ReactOS 0.4.15-dev-8093-g3285f69
misc.c
Go to the documentation of this file.
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 "setupapi_private.h"
23
24#include <winver.h>
25#include <lzexpand.h>
26
27/* Unicode constants */
28static const WCHAR BackSlash[] = {'\\',0};
29static const WCHAR TranslationRegKey[] = {'\\','V','e','r','F','i','l','e','I','n','f','o','\\','T','r','a','n','s','l','a','t','i','o','n',0};
30
31/* Handles and critical sections for the SetupLog API */
36{
37 0, 0, &setupapi_cs,
39 0, 0, { (DWORD_PTR)(__FILE__ ": setupapi_cs") }
40};
41static CRITICAL_SECTION setupapi_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
42
45 IN PWSTR InstallerName,
46 OUT HMODULE* ModulePointer,
47 OUT PVOID* FunctionPointer)
48{
50 LPSTR FunctionNameA = NULL;
51 PWCHAR Comma;
52 DWORD rc;
53
54 *ModulePointer = NULL;
55 *FunctionPointer = NULL;
56
57 Comma = strchrW(InstallerName, ',');
58 if (!Comma)
59 {
61 goto cleanup;
62 }
63
64 /* Load library */
65 *Comma = '\0';
66 hModule = LoadLibraryW(InstallerName);
67 *Comma = ',';
68 if (!hModule)
69 {
70 rc = GetLastError();
71 goto cleanup;
72 }
73
74 /* Skip comma spaces */
75 while (*Comma == ',' || isspaceW(*Comma))
76 Comma++;
77
78 /* W->A conversion for function name */
79 FunctionNameA = pSetupUnicodeToMultiByte(Comma, CP_ACP);
80 if (!FunctionNameA)
81 {
82 rc = GetLastError();
83 goto cleanup;
84 }
85
86 /* Search function */
87 *FunctionPointer = GetProcAddress(hModule, FunctionNameA);
88 if (!*FunctionPointer)
89 {
90 rc = GetLastError();
91 goto cleanup;
92 }
93
94 *ModulePointer = hModule;
95 rc = ERROR_SUCCESS;
96
98 if (rc != ERROR_SUCCESS && hModule)
100 MyFree(FunctionNameA);
101 return rc;
102}
103
104DWORD
106 IN HMODULE ModulePointer,
107 IN PVOID FunctionPointer)
108{
109 if (ModulePointer == NULL)
110 return ERROR_SUCCESS;
111 if (FreeLibrary(ModulePointer))
112 return ERROR_SUCCESS;
113 else
114 return GetLastError();
115}
116
117/**************************************************************************
118 * MyFree [SETUPAPI.@]
119 *
120 * Frees an allocated memory block from the process heap.
121 *
122 * PARAMS
123 * lpMem [I] pointer to memory block which will be freed
124 *
125 * RETURNS
126 * None
127 */
129{
130 TRACE("%p\n", lpMem);
131 HeapFree(GetProcessHeap(), 0, lpMem);
132}
133
134
135/**************************************************************************
136 * MyMalloc [SETUPAPI.@]
137 *
138 * Allocates memory block from the process heap.
139 *
140 * PARAMS
141 * dwSize [I] size of the allocated memory block
142 *
143 * RETURNS
144 * Success: pointer to allocated memory block
145 * Failure: NULL
146 */
148{
149 TRACE("%lu\n", dwSize);
150 return HeapAlloc(GetProcessHeap(), 0, dwSize);
151}
152
153
154/**************************************************************************
155 * MyRealloc [SETUPAPI.@]
156 *
157 * Changes the size of an allocated memory block or allocates a memory
158 * block from the process heap.
159 *
160 * PARAMS
161 * lpSrc [I] pointer to memory block which will be resized
162 * dwSize [I] new size of the memory block
163 *
164 * RETURNS
165 * Success: pointer to the resized memory block
166 * Failure: NULL
167 *
168 * NOTES
169 * If lpSrc is a NULL-pointer, then MyRealloc allocates a memory
170 * block like MyMalloc.
171 */
173{
174 TRACE("%p %lu\n", lpSrc, dwSize);
175
176 if (lpSrc == NULL)
177 return HeapAlloc(GetProcessHeap(), 0, dwSize);
178
179 return HeapReAlloc(GetProcessHeap(), 0, lpSrc, dwSize);
180}
181
182
183/**************************************************************************
184 * pSetupDuplicateString [SETUPAPI.@]
185 *
186 * Duplicates a unicode string.
187 *
188 * PARAMS
189 * lpSrc [I] pointer to the unicode string that will be duplicated
190 *
191 * RETURNS
192 * Success: pointer to the duplicated unicode string
193 * Failure: NULL
194 *
195 * NOTES
196 * Call MyFree() to release the duplicated string.
197 */
199{
200 LPWSTR lpDst;
201
202 TRACE("%s\n", debugstr_w(lpSrc));
203
204 lpDst = MyMalloc((lstrlenW(lpSrc) + 1) * sizeof(WCHAR));
205 if (lpDst == NULL)
206 return NULL;
207
208 strcpyW(lpDst, lpSrc);
209
210 return lpDst;
211}
212
213
214/**************************************************************************
215 * QueryRegistryValue [SETUPAPI.@]
216 *
217 * Retrieves value data from the registry and allocates memory for the
218 * value data.
219 *
220 * PARAMS
221 * hKey [I] Handle of the key to query
222 * lpValueName [I] Name of value under hkey to query
223 * lpData [O] Destination for the values contents,
224 * lpType [O] Destination for the value type
225 * lpcbData [O] Destination for the size of data
226 *
227 * RETURNS
228 * Success: ERROR_SUCCESS
229 * Failure: Otherwise
230 *
231 * NOTES
232 * Use MyFree to release the lpData buffer.
233 */
235 LPCWSTR lpValueName,
236 LPBYTE *lpData,
237 LPDWORD lpType,
238 LPDWORD lpcbData)
239{
240 LONG lError;
241
242 TRACE("%p %s %p %p %p\n",
243 hKey, debugstr_w(lpValueName), lpData, lpType, lpcbData);
244
245 /* Get required buffer size */
246 *lpcbData = 0;
247 lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, NULL, lpcbData);
248 if (lError != ERROR_SUCCESS)
249 return lError;
250
251 /* Allocate buffer */
252 *lpData = MyMalloc(*lpcbData);
253 if (*lpData == NULL)
255
256 /* Query registry value */
257 lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, *lpData, lpcbData);
258 if (lError != ERROR_SUCCESS)
259 MyFree(*lpData);
260
261 return lError;
262}
263
264
265/**************************************************************************
266 * pSetupMultiByteToUnicode [SETUPAPI.@]
267 *
268 * Converts a multi-byte string to a Unicode string.
269 *
270 * PARAMS
271 * lpMultiByteStr [I] Multi-byte string to be converted
272 * uCodePage [I] Code page
273 *
274 * RETURNS
275 * Success: pointer to the converted Unicode string
276 * Failure: NULL
277 *
278 * NOTE
279 * Use MyFree to release the returned Unicode string.
280 */
282{
283 LPWSTR lpUnicodeStr;
284 int nLength;
285
286 TRACE("%s %d\n", debugstr_a(lpMultiByteStr), uCodePage);
287
288 nLength = MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
289 -1, NULL, 0);
290 if (nLength == 0)
291 return NULL;
292
293 lpUnicodeStr = MyMalloc(nLength * sizeof(WCHAR));
294 if (lpUnicodeStr == NULL)
295 {
297 return NULL;
298 }
299
300 if (!MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
301 nLength, lpUnicodeStr, nLength))
302 {
303 MyFree(lpUnicodeStr);
304 return NULL;
305 }
306
307 return lpUnicodeStr;
308}
309
310
311/**************************************************************************
312 * pSetupUnicodeToMultiByte [SETUPAPI.@]
313 *
314 * Converts a Unicode string to a multi-byte string.
315 *
316 * PARAMS
317 * lpUnicodeStr [I] Unicode string to be converted
318 * uCodePage [I] Code page
319 *
320 * RETURNS
321 * Success: pointer to the converted multi-byte string
322 * Failure: NULL
323 *
324 * NOTE
325 * Use MyFree to release the returned multi-byte string.
326 */
328{
329 LPSTR lpMultiByteStr;
330 int nLength;
331
332 TRACE("%s %d\n", debugstr_w(lpUnicodeStr), uCodePage);
333
334 nLength = WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
335 NULL, 0, NULL, NULL);
336 if (nLength == 0)
337 return NULL;
338
339 lpMultiByteStr = MyMalloc(nLength);
340 if (lpMultiByteStr == NULL)
341 return NULL;
342
343 if (!WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
344 lpMultiByteStr, nLength, NULL, NULL))
345 {
346 MyFree(lpMultiByteStr);
347 return NULL;
348 }
349
350 return lpMultiByteStr;
351}
352
353
354/**************************************************************************
355 * DoesUserHavePrivilege [SETUPAPI.@]
356 *
357 * Check whether the current user has got a given privilege.
358 *
359 * PARAMS
360 * lpPrivilegeName [I] Name of the privilege to be checked
361 *
362 * RETURNS
363 * Success: TRUE
364 * Failure: FALSE
365 */
367{
368 HANDLE hToken;
370 PTOKEN_PRIVILEGES lpPrivileges;
371 LUID PrivilegeLuid;
372 DWORD i;
373 BOOL bResult = FALSE;
374
375 TRACE("%s\n", debugstr_w(lpPrivilegeName));
376
378 return FALSE;
379
381 {
383 {
384 CloseHandle(hToken);
385 return FALSE;
386 }
387 }
388
389 lpPrivileges = MyMalloc(dwSize);
390 if (lpPrivileges == NULL)
391 {
392 CloseHandle(hToken);
393 return FALSE;
394 }
395
396 if (!GetTokenInformation(hToken, TokenPrivileges, lpPrivileges, dwSize, &dwSize))
397 {
398 MyFree(lpPrivileges);
399 CloseHandle(hToken);
400 return FALSE;
401 }
402
403 CloseHandle(hToken);
404
405 if (!LookupPrivilegeValueW(NULL, lpPrivilegeName, &PrivilegeLuid))
406 {
407 MyFree(lpPrivileges);
408 return FALSE;
409 }
410
411 for (i = 0; i < lpPrivileges->PrivilegeCount; i++)
412 {
413 if (lpPrivileges->Privileges[i].Luid.HighPart == PrivilegeLuid.HighPart &&
414 lpPrivileges->Privileges[i].Luid.LowPart == PrivilegeLuid.LowPart)
415 {
416 bResult = TRUE;
417 }
418 }
419
420 MyFree(lpPrivileges);
421
422 return bResult;
423}
424
425
426/**************************************************************************
427 * pSetupEnablePrivilege [SETUPAPI.@]
428 *
429 * Enables or disables one of the current users privileges.
430 *
431 * PARAMS
432 * lpPrivilegeName [I] Name of the privilege to be changed
433 * bEnable [I] TRUE: Enables the privilege
434 * FALSE: Disables the privilege
435 *
436 * RETURNS
437 * Success: TRUE
438 * Failure: FALSE
439 */
441{
443 HANDLE hToken;
444 BOOL bResult;
445
446 TRACE("%s %s\n", debugstr_w(lpPrivilegeName), bEnable ? "TRUE" : "FALSE");
447
449 return FALSE;
450
451 Privileges.PrivilegeCount = 1;
452 Privileges.Privileges[0].Attributes = (bEnable) ? SE_PRIVILEGE_ENABLED : 0;
453
454 if (!LookupPrivilegeValueW(NULL, lpPrivilegeName,
455 &Privileges.Privileges[0].Luid))
456 {
457 CloseHandle(hToken);
458 return FALSE;
459 }
460
461 bResult = AdjustTokenPrivileges(hToken, FALSE, &Privileges, 0, NULL, NULL);
462
463 CloseHandle(hToken);
464
465 return bResult;
466}
467
468
469/**************************************************************************
470 * DelayedMove [SETUPAPI.@]
471 *
472 * Moves a file upon the next reboot.
473 *
474 * PARAMS
475 * lpExistingFileName [I] Current file name
476 * lpNewFileName [I] New file name
477 *
478 * RETURNS
479 * Success: TRUE
480 * Failure: FALSE
481 */
482BOOL WINAPI DelayedMove(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName)
483{
484 return MoveFileExW(lpExistingFileName, lpNewFileName,
486}
487
488
489/**************************************************************************
490 * FileExists [SETUPAPI.@]
491 *
492 * Checks whether a file exists.
493 *
494 * PARAMS
495 * lpFileName [I] Name of the file to check
496 * lpNewFileName [O] Optional information about the existing file
497 *
498 * RETURNS
499 * Success: TRUE
500 * Failure: FALSE
501 */
503{
504 WIN32_FIND_DATAW FindData;
505 HANDLE hFind;
506 UINT uErrorMode;
507 DWORD dwError;
508
510
511 hFind = FindFirstFileW(lpFileName, &FindData);
512 if (hFind == INVALID_HANDLE_VALUE)
513 {
514 dwError = GetLastError();
515 SetErrorMode(uErrorMode);
516 SetLastError(dwError);
517 return FALSE;
518 }
519
520 FindClose(hFind);
521
522 if (lpFileFindData)
523 memcpy(lpFileFindData, &FindData, sizeof(WIN32_FIND_DATAW));
524
525 SetErrorMode(uErrorMode);
526
527 return TRUE;
528}
529
530
531/**************************************************************************
532 * CaptureStringArg [SETUPAPI.@]
533 *
534 * Captures a UNICODE string.
535 *
536 * PARAMS
537 * lpSrc [I] UNICODE string to be captured
538 * lpDst [O] Pointer to the captured UNICODE string
539 *
540 * RETURNS
541 * Success: ERROR_SUCCESS
542 * Failure: ERROR_INVALID_PARAMETER
543 *
544 * NOTE
545 * Call MyFree to release the captured UNICODE string.
546 */
548{
549 if (pDst == NULL)
551
552 *pDst = pSetupDuplicateString(pSrc);
553
554 return ERROR_SUCCESS;
555}
556
557
558/**************************************************************************
559 * pSetupCaptureAndConvertAnsiArg [SETUPAPI.@]
560 *
561 * Captures an ANSI string and converts it to a UNICODE string.
562 *
563 * PARAMS
564 * lpSrc [I] ANSI string to be captured
565 * lpDst [O] Pointer to the captured UNICODE string
566 *
567 * RETURNS
568 * Success: ERROR_SUCCESS
569 * Failure: ERROR_INVALID_PARAMETER
570 *
571 * NOTE
572 * Call MyFree to release the captured UNICODE string.
573 */
575{
576 if (pDst == NULL)
578
579 *pDst = pSetupMultiByteToUnicode(pSrc, CP_ACP);
580
581 return ERROR_SUCCESS;
582}
583
584
585/**************************************************************************
586 * pSetupOpenAndMapFileForRead [SETUPAPI.@]
587 *
588 * Open and map a file to a buffer.
589 *
590 * PARAMS
591 * lpFileName [I] Name of the file to be opened
592 * lpSize [O] Pointer to the file size
593 * lpFile [0] Pointer to the file handle
594 * lpMapping [0] Pointer to the mapping handle
595 * lpBuffer [0] Pointer to the file buffer
596 *
597 * RETURNS
598 * Success: ERROR_SUCCESS
599 * Failure: Other
600 *
601 * NOTE
602 * Call UnmapAndCloseFile to release the file.
603 */
605 LPDWORD lpSize,
606 LPHANDLE lpFile,
607 LPHANDLE lpMapping,
609{
610 DWORD dwError;
611
612 TRACE("%s %p %p %p %p\n",
613 debugstr_w(lpFileName), lpSize, lpFile, lpMapping, lpBuffer);
614
616 OPEN_EXISTING, 0, NULL);
617 if (*lpFile == INVALID_HANDLE_VALUE)
618 return GetLastError();
619
620 *lpSize = GetFileSize(*lpFile, NULL);
621 if (*lpSize == INVALID_FILE_SIZE)
622 {
623 dwError = GetLastError();
624 CloseHandle(*lpFile);
625 return dwError;
626 }
627
628 *lpMapping = CreateFileMappingW(*lpFile, NULL, PAGE_READONLY, 0,
629 *lpSize, NULL);
630 if (*lpMapping == NULL)
631 {
632 dwError = GetLastError();
633 CloseHandle(*lpFile);
634 return dwError;
635 }
636
637 *lpBuffer = MapViewOfFile(*lpMapping, FILE_MAP_READ, 0, 0, *lpSize);
638 if (*lpBuffer == NULL)
639 {
640 dwError = GetLastError();
641 CloseHandle(*lpMapping);
642 CloseHandle(*lpFile);
643 return dwError;
644 }
645
646 return ERROR_SUCCESS;
647}
648
649
650/**************************************************************************
651 * pSetupUnmapAndCloseFile [SETUPAPI.@]
652 *
653 * Unmap and close a mapped file.
654 *
655 * PARAMS
656 * hFile [I] Handle to the file
657 * hMapping [I] Handle to the file mapping
658 * lpBuffer [I] Pointer to the file buffer
659 *
660 * RETURNS
661 * Success: TRUE
662 * Failure: FALSE
663 */
665{
666 TRACE("%p %p %p\n",
667 hFile, hMapping, lpBuffer);
668
670 return FALSE;
671
672 if (!CloseHandle(hMapping))
673 return FALSE;
674
675 if (!CloseHandle(hFile))
676 return FALSE;
677
678 return TRUE;
679}
680
681
682/**************************************************************************
683 * StampFileSecurity [SETUPAPI.@]
684 *
685 * Assign a new security descriptor to the given file.
686 *
687 * PARAMS
688 * lpFileName [I] Name of the file
689 * pSecurityDescriptor [I] New security descriptor
690 *
691 * RETURNS
692 * Success: ERROR_SUCCESS
693 * Failure: other
694 */
696{
697 TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
698
701 pSecurityDescriptor))
702 return GetLastError();
703
704 return ERROR_SUCCESS;
705}
706
707
708/**************************************************************************
709 * TakeOwnershipOfFile [SETUPAPI.@]
710 *
711 * Takes the ownership of the given file.
712 *
713 * PARAMS
714 * lpFileName [I] Name of the file
715 *
716 * RETURNS
717 * Success: ERROR_SUCCESS
718 * Failure: other
719 */
721{
722 SECURITY_DESCRIPTOR SecDesc;
723 HANDLE hToken = NULL;
724 PTOKEN_OWNER pOwner = NULL;
725 DWORD dwError;
727
728 TRACE("%s\n", debugstr_w(lpFileName));
729
731 return GetLastError();
732
733 if (!GetTokenInformation(hToken, TokenOwner, NULL, 0, &dwSize))
734 {
735 goto fail;
736 }
737
738 pOwner = (PTOKEN_OWNER)MyMalloc(dwSize);
739 if (pOwner == NULL)
740 {
741 CloseHandle(hToken);
743 }
744
745 if (!GetTokenInformation(hToken, TokenOwner, pOwner, dwSize, &dwSize))
746 {
747 goto fail;
748 }
749
751 {
752 goto fail;
753 }
754
755 if (!SetSecurityDescriptorOwner(&SecDesc, pOwner->Owner, FALSE))
756 {
757 goto fail;
758 }
759
761 {
762 goto fail;
763 }
764
765 MyFree(pOwner);
766 CloseHandle(hToken);
767
768 return ERROR_SUCCESS;
769
770fail:;
771 dwError = GetLastError();
772
773 MyFree(pOwner);
774
775 if (hToken != NULL)
776 CloseHandle(hToken);
777
778 return dwError;
779}
780
781
782/**************************************************************************
783 * RetreiveFileSecurity [SETUPAPI.@]
784 *
785 * Retrieve the security descriptor that is associated with the given file.
786 *
787 * PARAMS
788 * lpFileName [I] Name of the file
789 *
790 * RETURNS
791 * Success: ERROR_SUCCESS
792 * Failure: other
793 */
795 PSECURITY_DESCRIPTOR *pSecurityDescriptor)
796{
797 PSECURITY_DESCRIPTOR SecDesc;
798 DWORD dwSize = 0x100;
799 DWORD dwError;
800
801 TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
802
803 SecDesc = MyMalloc(dwSize);
804 if (SecDesc == NULL)
806
809 SecDesc, dwSize, &dwSize))
810 {
811 *pSecurityDescriptor = SecDesc;
812 return ERROR_SUCCESS;
813 }
814
815 dwError = GetLastError();
816 if (dwError != ERROR_INSUFFICIENT_BUFFER)
817 {
818 MyFree(SecDesc);
819 return dwError;
820 }
821
822 SecDesc = MyRealloc(SecDesc, dwSize);
823 if (SecDesc == NULL)
825
828 SecDesc, dwSize, &dwSize))
829 {
830 *pSecurityDescriptor = SecDesc;
831 return ERROR_SUCCESS;
832 }
833
834 dwError = GetLastError();
835 MyFree(SecDesc);
836
837 return dwError;
838}
839
840
841/*
842 * See: https://msdn.microsoft.com/en-us/library/bb432397(v=vs.85).aspx
843 * for more information.
844 */
846
847/***********************************************************************
848 * pSetupGetGlobalFlags (SETUPAPI.@)
849 */
851{
852 return GlobalSetupFlags;
853}
854
855/***********************************************************************
856 * pSetupModifyGlobalFlags (SETUPAPI.@)
857 */
859{
860 FIXME( "stub\n" );
862}
863
864/***********************************************************************
865 * pSetupSetGlobalFlags (SETUPAPI.@)
866 */
868{
869 pSetupModifyGlobalFlags(0xFFFFFFFF, flags);
870}
871
872/***********************************************************************
873 * SetupGetNonInteractiveMode (SETUPAPI.@)
874 */
876{
878}
879
880/***********************************************************************
881 * SetupSetNonInteractiveMode (SETUPAPI.@)
882 */
884{
885 BOOL OldValue;
886
889 NonInteractiveFlag ? PSPGF_NONINTERACTIVE : 0);
890
891 return OldValue;
892}
893
894/***********************************************************************
895 * AssertFail (SETUPAPI.@)
896 *
897 * Shows an assert fail error messagebox
898 *
899 * PARAMS
900 * lpFile [I] file where assert failed
901 * uLine [I] line number in file
902 * lpMessage [I] assert message
903 *
904 */
905VOID WINAPI AssertFail(LPSTR lpFile, UINT uLine, LPSTR lpMessage)
906{
907 CHAR szModule[MAX_PATH];
908 CHAR szBuffer[2048];
910// LPSTR lpBuffer;
911
912 TRACE("%s %u %s\n", lpFile, uLine, lpMessage);
913
915 lpName = strrchr(szModule, '\\');
916 if (lpName != NULL)
917 lpName++;
918 else
919 lpName = szModule;
920
921 wsprintfA(szBuffer,
922 "Assertion failure at line %u in file %s: %s\n\nCall DebugBreak()?",
923 uLine, lpFile, lpMessage);
924
925 if (MessageBoxA(NULL, szBuffer, lpName, MB_SETFOREGROUND |
927 DebugBreak();
928}
929
930
931/**************************************************************************
932 * GetSetFileTimestamp [SETUPAPI.@]
933 *
934 * Gets or sets a files timestamp.
935 *
936 * PARAMS
937 * lpFileName [I] File name
938 * lpCreationTime [I/O] Creation time
939 * lpLastAccessTime [I/O] Last access time
940 * lpLastWriteTime [I/O] Last write time
941 * bSetFileTime [I] TRUE: Set file times
942 * FALSE: Get file times
943 *
944 * RETURNS
945 * Success: ERROR_SUCCESS
946 * Failure: other
947 */
949 LPFILETIME lpCreationTime,
950 LPFILETIME lpLastAccessTime,
951 LPFILETIME lpLastWriteTime,
952 BOOLEAN bSetFileTime)
953{
955 BOOLEAN bRet;
956 DWORD dwError = ERROR_SUCCESS;
957
958 TRACE("%s %p %p %p %x\n", debugstr_w(lpFileName), lpCreationTime,
959 lpLastAccessTime, lpLastWriteTime, bSetFileTime);
960
962 bSetFileTime ? GENERIC_WRITE : GENERIC_READ,
964 NULL,
966 0,
967 NULL);
968
970 return GetLastError();
971
972 if (bSetFileTime)
973 bRet = SetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
974 else
975 bRet = GetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
976
977 if (bRet == FALSE)
978 dwError = GetLastError();
979
981
982 return dwError;
983}
984
985
986/**************************************************************************
987 * pSetupGetFileTitle [SETUPAPI.@]
988 *
989 * Returns a pointer to the last part of a fully qualified file name.
990 *
991 * PARAMS
992 * lpFileName [I] File name
993 *
994 * RETURNS
995 * Pointer to a files name.
996 */
999{
1000 LPWSTR ptr;
1001 LPWSTR ret;
1002 WCHAR c;
1003
1004 TRACE("%s\n", debugstr_w(lpFileName));
1005
1007 ret = ptr;
1008 while (TRUE)
1009 {
1010 c = *ptr;
1011
1012 if (c == 0)
1013 break;
1014
1015 ptr++;
1016 if (c == (WCHAR)'\\' || c == (WCHAR)'/' || c == (WCHAR)':')
1017 ret = ptr;
1018 }
1019
1020 return ret;
1021}
1022
1023
1024/**************************************************************************
1025 * pSetupConcatenatePaths [SETUPAPI.@]
1026 *
1027 * Concatenates two paths.
1028 *
1029 * PARAMS
1030 * lpPath [I/O] Path to append path to
1031 * lpAppend [I] Path to append
1032 * dwBufferSize [I] Size of the path buffer
1033 * lpRequiredSize [O] Required size for the concatenated path. Optional
1034 *
1035 * RETURNS
1036 * Success: TRUE
1037 * Failure: FALSE
1038 */
1041 LPCWSTR lpAppend,
1042 DWORD dwBufferSize,
1043 LPDWORD lpRequiredSize)
1044{
1045 DWORD dwPathSize;
1046 DWORD dwAppendSize;
1047 DWORD dwTotalSize;
1048 BOOL bBackslash = FALSE;
1049
1050 TRACE("%s %s %lu %p\n", debugstr_w(lpPath), debugstr_w(lpAppend),
1051 dwBufferSize, lpRequiredSize);
1052
1053 dwPathSize = lstrlenW(lpPath);
1054
1055 /* Ignore trailing backslash */
1056 if (lpPath[dwPathSize - 1] == (WCHAR)'\\')
1057 dwPathSize--;
1058
1059 dwAppendSize = lstrlenW(lpAppend);
1060
1061 /* Does the source string have a leading backslash? */
1062 if (lpAppend[0] == (WCHAR)'\\')
1063 {
1064 bBackslash = TRUE;
1065 dwAppendSize--;
1066 }
1067
1068 dwTotalSize = dwPathSize + dwAppendSize + 2;
1069 if (lpRequiredSize != NULL)
1070 *lpRequiredSize = dwTotalSize;
1071
1072 /* Append a backslash to the destination string */
1073 if (bBackslash == FALSE)
1074 {
1075 if (dwPathSize < dwBufferSize)
1076 {
1077 lpPath[dwPathSize - 1] = (WCHAR)'\\';
1078 dwPathSize++;
1079 }
1080 }
1081
1082 if (dwPathSize + dwAppendSize < dwBufferSize)
1083 {
1084 lstrcpynW(&lpPath[dwPathSize],
1085 lpAppend,
1086 dwAppendSize);
1087 }
1088
1089 if (dwBufferSize >= dwTotalSize)
1090 lpPath[dwTotalSize - 1] = 0;
1091
1092 return (dwBufferSize >= dwTotalSize);
1093}
1094
1095
1096/**************************************************************************
1097 * pSetupCenterWindowRelativeToParent [SETUPAPI.@]
1098 *
1099 * Centers a window relative to its parent.
1100 *
1101 * PARAMS
1102 * hwnd [I] Window to center.
1103 *
1104 * RETURNS
1105 * None
1106 */
1109{
1110 HWND hwndOwner;
1111 POINT ptOrigin;
1112 RECT rcWindow;
1113 RECT rcOwner;
1114 INT nWindowWidth, nWindowHeight;
1115 INT nOwnerWidth, nOwnerHeight;
1116 INT posX, posY;
1117
1118 hwndOwner = GetWindow(hwnd, GW_OWNER);
1119 if (hwndOwner == NULL)
1120 return;
1121
1122 ptOrigin.x = 0;
1123 ptOrigin.y = 0;
1124 ClientToScreen(hwndOwner, &ptOrigin);
1125
1126 GetWindowRect(hwnd, &rcWindow);
1127 GetClientRect(hwndOwner, &rcOwner);
1128
1129 nWindowWidth = rcWindow.right - rcWindow.left;
1130 nWindowHeight = rcWindow.bottom - rcWindow.top;
1131
1132 nOwnerWidth = rcOwner.right - rcOwner.left;
1133 nOwnerHeight = rcOwner.bottom - rcOwner.top;
1134
1135 posX = ((nOwnerWidth - nWindowWidth) / 2) + ptOrigin.x;
1136 posY = ((nOwnerHeight - nWindowHeight) / 2) + ptOrigin.y;
1137
1138 MoveWindow(hwnd, posX, posY, nWindowWidth, nWindowHeight, 0);
1139}
1140
1141
1142/**************************************************************************
1143 * pSetupGetVersionInfoFromImage [SETUPAPI.@]
1144 *
1145 * Retrieves version information for a given file.
1146 *
1147 * PARAMS
1148 * lpFileName [I] File name
1149 * lpFileVersion [O] Pointer to the full file version
1150 * lpVersionVarSize [O] Pointer to the size of the variable version
1151 * information
1152 *
1153 * RETURNS
1154 * Success: TRUE
1155 * Failure: FALSE
1156 */
1159 PULARGE_INTEGER lpFileVersion,
1160 LPWORD lpVersionVarSize)
1161{
1162 DWORD dwHandle;
1163 DWORD dwSize;
1164 LPVOID lpInfo;
1165 UINT uSize;
1166 VS_FIXEDFILEINFO *lpFixedInfo;
1167 LPWORD lpVarSize;
1168
1170 if (dwSize == 0)
1171 return FALSE;
1172
1173 lpInfo = MyMalloc(dwSize);
1174 if (lpInfo == NULL)
1175 return FALSE;
1176
1177 if (!GetFileVersionInfoW(lpFileName, 0, dwSize, lpInfo))
1178 {
1179 MyFree(lpInfo);
1180 return FALSE;
1181 }
1182
1183 if (!VerQueryValueW(lpInfo, BackSlash,
1184 (LPVOID*)&lpFixedInfo, &uSize))
1185 {
1186 MyFree(lpInfo);
1187 return FALSE;
1188 }
1189
1190 lpFileVersion->LowPart = lpFixedInfo->dwFileVersionLS;
1191 lpFileVersion->HighPart = lpFixedInfo->dwFileVersionMS;
1192
1193 *lpVersionVarSize = 0;
1194 if (!VerQueryValueW(lpInfo, TranslationRegKey,
1195 (LPVOID*)&lpVarSize, &uSize))
1196 {
1197 MyFree(lpInfo);
1198 return TRUE;
1199 }
1200
1201 if (uSize >= 4)
1202 {
1203 *lpVersionVarSize = *lpVarSize;
1204 }
1205
1206 MyFree(lpInfo);
1207
1208 return TRUE;
1209}
1210
1211/***********************************************************************
1212 * SetupUninstallOEMInfW (SETUPAPI.@)
1213 */
1215{
1216 static const WCHAR infW[] = {'\\','i','n','f','\\',0};
1218
1219 TRACE("%s, 0x%08x, %p\n", debugstr_w(inf_file), flags, reserved);
1220
1221 if (!inf_file)
1222 {
1224 return FALSE;
1225 }
1226
1227 if (!GetWindowsDirectoryW( target, sizeof(target)/sizeof(WCHAR) )) return FALSE;
1228
1229 strcatW( target, infW );
1231
1232 if (flags & SUOI_FORCEDELETE)
1233 return DeleteFileW(target);
1234
1235 FIXME("not deleting %s\n", debugstr_w(target));
1236
1237 return TRUE;
1238}
1239
1240/***********************************************************************
1241 * SetupUninstallOEMInfA (SETUPAPI.@)
1242 */
1244{
1245 BOOL ret;
1246 WCHAR *inf_fileW = NULL;
1247
1248 TRACE("%s, 0x%08x, %p\n", debugstr_a(inf_file), flags, reserved);
1249
1250 if (inf_file && !(inf_fileW = strdupAtoW( inf_file ))) return FALSE;
1251 ret = SetupUninstallOEMInfW( inf_fileW, flags, reserved );
1252 HeapFree( GetProcessHeap(), 0, inf_fileW );
1253 return ret;
1254}
1255
1256/***********************************************************************
1257 * InstallCatalog (SETUPAPI.@)
1258 */
1260{
1261 FIXME("%s, %s, %p\n", debugstr_a(catalog), debugstr_a(basename), fullname);
1262 return 0;
1263}
1264
1265/***********************************************************************
1266 * pSetupInstallCatalog (SETUPAPI.@)
1267 */
1269{
1270 HCATADMIN admin;
1271 HCATINFO cat;
1272
1273 TRACE ("%s, %s, %p\n", debugstr_w(catalog), debugstr_w(basename), fullname);
1274
1275 if (!CryptCATAdminAcquireContext(&admin,NULL,0))
1276 return GetLastError();
1277
1278 if (!(cat = CryptCATAdminAddCatalog( admin, (PWSTR)catalog, (PWSTR)basename, 0 )))
1279 {
1280 DWORD rc = GetLastError();
1282 return rc;
1283 }
1286
1287 if (fullname)
1288 FIXME("not returning full installed catalog path\n");
1289
1290 return NO_ERROR;
1291}
1292
1294{
1295 DWORD size;
1296 HANDLE handle;
1298 static const BYTE LZ_MAGIC[] = { 0x53, 0x5a, 0x44, 0x44, 0x88, 0xf0, 0x27, 0x33 };
1299 static const BYTE MSZIP_MAGIC[] = { 0x4b, 0x57, 0x41, 0x4a };
1300 static const BYTE NTCAB_MAGIC[] = { 0x4d, 0x53, 0x43, 0x46 };
1301 BYTE buffer[8];
1302
1305 {
1306 ERR("cannot open file %s\n", debugstr_w(file));
1307 return FILE_COMPRESSION_NONE;
1308 }
1309 if (!ReadFile( handle, buffer, sizeof(buffer), &size, NULL ) || size != sizeof(buffer))
1310 {
1312 return FILE_COMPRESSION_NONE;
1313 }
1314 if (!memcmp( buffer, LZ_MAGIC, sizeof(LZ_MAGIC) )) type = FILE_COMPRESSION_WINLZA;
1316 else if (!memcmp( buffer, NTCAB_MAGIC, sizeof(NTCAB_MAGIC) )) type = FILE_COMPRESSION_MSZIP; /* not a typo */
1317
1319 return type;
1320}
1321
1323{
1324 HANDLE handle;
1325
1328 {
1329 ERR("cannot open file %s\n", debugstr_w(file));
1330 return FALSE;
1331 }
1332 *size = GetFileSize( handle, NULL );
1334 return TRUE;
1335}
1336
1337static BOOL get_file_sizes_none( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1338{
1339 DWORD size;
1340
1341 if (!get_file_size( source, &size )) return FALSE;
1342 if (source_size) *source_size = size;
1343 if (target_size) *target_size = size;
1344 return TRUE;
1345}
1346
1347static BOOL get_file_sizes_lz( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1348{
1349 DWORD size;
1350 BOOL ret = TRUE;
1351
1352 if (source_size)
1353 {
1354 if (!get_file_size( source, &size )) ret = FALSE;
1355 else *source_size = size;
1356 }
1357 if (target_size)
1358 {
1359 INT file;
1360 OFSTRUCT of;
1361
1362 if ((file = LZOpenFileW( (LPWSTR)source, &of, OF_READ )) < 0)
1363 {
1364 ERR("cannot open source file for reading\n");
1365 return FALSE;
1366 }
1367 *target_size = LZSeek( file, 0, 2 );
1368 LZClose( file );
1369 }
1370 return ret;
1371}
1372
1374{
1375 DWORD *size = context;
1377
1378 switch (notification)
1379 {
1381 {
1382 *size = info->FileSize;
1383 return FILEOP_SKIP;
1384 }
1385 default: return NO_ERROR;
1386 }
1387}
1388
1389static BOOL get_file_sizes_cab( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1390{
1391 DWORD size;
1392 BOOL ret = TRUE;
1393
1394 if (source_size)
1395 {
1396 if (!get_file_size( source, &size )) ret = FALSE;
1397 else *source_size = size;
1398 }
1399 if (target_size)
1400 {
1402 }
1403 return ret;
1404}
1405
1406/***********************************************************************
1407 * SetupGetFileCompressionInfoExA (SETUPAPI.@)
1408 *
1409 * See SetupGetFileCompressionInfoExW.
1410 */
1412 PDWORD source_size, PDWORD target_size, PUINT type )
1413{
1414 BOOL ret;
1415 WCHAR *nameW = NULL, *sourceW = NULL;
1416 DWORD nb_chars = 0;
1417 LPSTR nameA;
1418
1419 TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_a(source), name, len, required,
1420 source_size, target_size, type);
1421
1422 if (!source || !(sourceW = pSetupMultiByteToUnicode( source, CP_ACP ))) return FALSE;
1423
1424 if (name)
1425 {
1427 if (!(nameW = HeapAlloc( GetProcessHeap(), 0, nb_chars * sizeof(WCHAR) )))
1428 {
1429 MyFree( sourceW );
1430 return FALSE;
1431 }
1432 }
1433 ret = SetupGetFileCompressionInfoExW( sourceW, nameW, nb_chars, &nb_chars, source_size, target_size, type );
1434 if (ret)
1435 {
1436 if ((nameA = pSetupUnicodeToMultiByte( nameW, CP_ACP )))
1437 {
1438 if (name && len >= nb_chars) lstrcpyA( name, nameA );
1439 else
1440 {
1442 ret = FALSE;
1443 }
1444 MyFree( nameA );
1445 }
1446 }
1447 if (required) *required = nb_chars;
1448 HeapFree( GetProcessHeap(), 0, nameW );
1449 MyFree( sourceW );
1450
1451 return ret;
1452}
1453
1454/***********************************************************************
1455 * SetupGetFileCompressionInfoExW (SETUPAPI.@)
1456 *
1457 * Get compression type and compressed/uncompressed sizes of a given file.
1458 *
1459 * PARAMS
1460 * source [I] File to examine.
1461 * name [O] Actual filename used.
1462 * len [I] Length in characters of 'name' buffer.
1463 * required [O] Number of characters written to 'name'.
1464 * source_size [O] Size of compressed file.
1465 * target_size [O] Size of uncompressed file.
1466 * type [O] Compression type.
1467 *
1468 * RETURNS
1469 * Success: TRUE
1470 * Failure: FALSE
1471 */
1473 PDWORD source_size, PDWORD target_size, PUINT type )
1474{
1475 UINT comp;
1476 BOOL ret = FALSE;
1477 DWORD source_len;
1478
1479 TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_w(source), name, len, required,
1480 source_size, target_size, type);
1481
1482 if (!source) return FALSE;
1483
1484 source_len = lstrlenW( source ) + 1;
1485 if (required) *required = source_len;
1486 if (name && len >= source_len)
1487 {
1488 lstrcpyW( name, source );
1489 ret = TRUE;
1490 }
1491 else return FALSE;
1492
1494 if (type) *type = comp;
1495
1496 switch (comp)
1497 {
1499 case FILE_COMPRESSION_NTCAB: ret = get_file_sizes_cab( source, source_size, target_size ); break;
1500 case FILE_COMPRESSION_NONE: ret = get_file_sizes_none( source, source_size, target_size ); break;
1501 case FILE_COMPRESSION_WINLZA: ret = get_file_sizes_lz( source, source_size, target_size ); break;
1502 default: break;
1503 }
1504 return ret;
1505}
1506
1507/***********************************************************************
1508 * SetupGetFileCompressionInfoA (SETUPAPI.@)
1509 *
1510 * See SetupGetFileCompressionInfoW.
1511 */
1513 PDWORD target_size, PUINT type )
1514{
1515 BOOL ret;
1516 DWORD error, required;
1517 LPSTR actual_name;
1518
1519 TRACE("%s, %p, %p, %p, %p\n", debugstr_a(source), name, source_size, target_size, type);
1520
1521 if (!source || !name || !source_size || !target_size || !type)
1523
1525 if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
1526
1527 ret = SetupGetFileCompressionInfoExA( source, actual_name, required, &required,
1528 source_size, target_size, type );
1529 if (!ret)
1530 {
1531 error = GetLastError();
1532 MyFree( actual_name );
1533 return error;
1534 }
1535 *name = actual_name;
1536 return ERROR_SUCCESS;
1537}
1538
1539/***********************************************************************
1540 * SetupGetFileCompressionInfoW (SETUPAPI.@)
1541 *
1542 * Get compression type and compressed/uncompressed sizes of a given file.
1543 *
1544 * PARAMS
1545 * source [I] File to examine.
1546 * name [O] Actual filename used.
1547 * source_size [O] Size of compressed file.
1548 * target_size [O] Size of uncompressed file.
1549 * type [O] Compression type.
1550 *
1551 * RETURNS
1552 * Success: ERROR_SUCCESS
1553 * Failure: Win32 error code.
1554 */
1556 PDWORD target_size, PUINT type )
1557{
1558 BOOL ret;
1559 DWORD error, required;
1560 LPWSTR actual_name;
1561
1562 TRACE("%s, %p, %p, %p, %p\n", debugstr_w(source), name, source_size, target_size, type);
1563
1564 if (!source || !name || !source_size || !target_size || !type)
1566
1568 if (!(actual_name = MyMalloc( required*sizeof(WCHAR) ))) return ERROR_NOT_ENOUGH_MEMORY;
1569
1570 ret = SetupGetFileCompressionInfoExW( source, actual_name, required, &required,
1571 source_size, target_size, type );
1572 if (!ret)
1573 {
1574 error = GetLastError();
1575 MyFree( actual_name );
1576 return error;
1577 }
1578 *name = actual_name;
1579 return ERROR_SUCCESS;
1580}
1581
1583{
1584 DWORD ret;
1585 LONG error;
1586 INT src, dst;
1587 OFSTRUCT sof, dof;
1588
1589 if ((src = LZOpenFileW( (LPWSTR)source, &sof, OF_READ )) < 0)
1590 {
1591 ERR("cannot open source file for reading\n");
1592 return ERROR_FILE_NOT_FOUND;
1593 }
1594 if ((dst = LZOpenFileW( (LPWSTR)target, &dof, OF_CREATE )) < 0)
1595 {
1596 ERR("cannot open target file for writing\n");
1597 LZClose( src );
1598 return ERROR_FILE_NOT_FOUND;
1599 }
1600 if ((error = LZCopy( src, dst )) >= 0) ret = ERROR_SUCCESS;
1601 else
1602 {
1603 WARN("failed to decompress file %d\n", error);
1605 }
1606
1607 LZClose( src );
1608 LZClose( dst );
1609 return ret;
1610}
1611
1613{
1616};
1617
1619{
1620 struct callback_context *context_info = context;
1622
1623 switch (notification)
1624 {
1626 {
1627 if (context_info->has_extracted)
1628 return FILEOP_ABORT;
1629
1630 TRACE("Requesting extraction of cabinet file %s\n",
1631 wine_dbgstr_w(info->NameInCabinet));
1632 strcpyW( info->FullTargetName, context_info->target );
1633 context_info->has_extracted = TRUE;
1634 return FILEOP_DOIT;
1635 }
1636 default: return NO_ERROR;
1637 }
1638}
1639
1641{
1642 struct callback_context context = {0, target};
1643 BOOL ret;
1644
1646
1647 if (ret) return ERROR_SUCCESS;
1648 else return GetLastError();
1649}
1650
1651/***********************************************************************
1652 * SetupDecompressOrCopyFileA (SETUPAPI.@)
1653 *
1654 * See SetupDecompressOrCopyFileW.
1655 */
1657{
1658 DWORD ret = 0;
1659 WCHAR *sourceW = NULL, *targetW = NULL;
1660
1661 if (source && !(sourceW = pSetupMultiByteToUnicode( source, CP_ACP ))) return FALSE;
1662 if (target && !(targetW = pSetupMultiByteToUnicode( target, CP_ACP )))
1663 {
1664 MyFree( sourceW );
1666 }
1667
1669
1670 MyFree( sourceW );
1671 MyFree( targetW );
1672
1673 return ret;
1674}
1675
1676/***********************************************************************
1677 * SetupDecompressOrCopyFileW (SETUPAPI.@)
1678 *
1679 * Copy a file and decompress it if needed.
1680 *
1681 * PARAMS
1682 * source [I] File to copy.
1683 * target [I] Filename of the copy.
1684 * type [I] Compression type.
1685 *
1686 * RETURNS
1687 * Success: ERROR_SUCCESS
1688 * Failure: Win32 error code.
1689 */
1691{
1692 UINT comp;
1694
1695 if (!source || !target) return ERROR_INVALID_PARAMETER;
1696
1697 if (!type) comp = detect_compression_type( source );
1698 else comp = *type;
1699
1700 switch (comp)
1701 {
1704 else ret = GetLastError();
1705 break;
1708 break;
1712 break;
1713 default:
1714 WARN("unknown compression type %d\n", comp);
1715 break;
1716 }
1717
1718 TRACE("%s -> %s %d\n", debugstr_w(source), debugstr_w(target), comp);
1719 return ret;
1720}
1721
1722/*
1723 * implemented (used by pSetupGuidFromString)
1724 */
1725static BOOL TrimGuidString(PCWSTR szString, LPWSTR szNewString)
1726{
1727 WCHAR szBuffer[39];
1728 INT Index;
1729
1730 if (wcslen(szString) == 38)
1731 {
1732 if ((szString[0] == L'{') && (szString[37] == L'}'))
1733 {
1734 for (Index = 0; Index < wcslen(szString); Index++)
1735 szBuffer[Index] = szString[Index + 1];
1736
1737 szBuffer[36] = L'\0';
1738 wcscpy(szNewString, szBuffer);
1739 return TRUE;
1740 }
1741 }
1742 szNewString[0] = L'\0';
1743 return FALSE;
1744}
1745
1746/*
1747 * implemented
1748 */
1749DWORD
1750WINAPI
1752{
1754 WCHAR szBuffer[39];
1755
1756 if (!TrimGuidString(pString, szBuffer))
1757 {
1759 }
1760
1761 Status = UuidFromStringW(szBuffer, lpGUID);
1762 if (Status != RPC_S_OK)
1763 {
1765 }
1766
1767 return NO_ERROR;
1768}
1769
1770/*
1771 * implemented
1772 */
1773DWORD
1774WINAPI
1776{
1778 RPC_WSTR rpcBuffer;
1779 WCHAR szBuffer[39];
1780
1781 if (dwStringLen < 39)
1782 {
1784 }
1785
1786 Status = UuidToStringW(lpGUID, &rpcBuffer);
1787 if (Status != RPC_S_OK)
1788 {
1789 return Status;
1790 }
1791
1792 wcscpy(szBuffer, L"{");
1793 wcscat(szBuffer, rpcBuffer);
1794 wcscat(szBuffer, L"}");
1795
1796 wcscpy(pString, szBuffer);
1797
1798 RpcStringFreeW(&rpcBuffer);
1799 return NO_ERROR;
1800}
1801
1802/*
1803 * implemented
1804 */
1805BOOL
1806WINAPI
1808{
1809 return IsEqualGUID(lpGUID, &GUID_NULL);
1810}
1811
1812/*
1813 * implemented
1814 */
1815BOOL
1816WINAPI
1818{
1820 BOOL bResult = FALSE;
1821 PSID lpSid;
1822
1824 DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
1825 &lpSid))
1826 {
1827 return FALSE;
1828 }
1829
1830 if (!CheckTokenMembership(NULL, lpSid, &bResult))
1831 {
1832 bResult = FALSE;
1833 }
1834
1835 FreeSid(lpSid);
1836
1837 return bResult;
1838}
1839
1840/***********************************************************************
1841 * SetupInitializeFileLogW(SETUPAPI.@)
1842 */
1844{
1845 struct FileLog * Log;
1846 HANDLE hLog;
1847 WCHAR Windir[MAX_PATH];
1848 DWORD ret;
1849
1850 TRACE("%s, 0x%x\n",debugstr_w(LogFileName),Flags);
1851
1853 {
1855 {
1856 /* insufficient privileges */
1858 return INVALID_HANDLE_VALUE;
1859 }
1860
1862 {
1863 /* invalid parameter */
1865 return INVALID_HANDLE_VALUE;
1866 }
1867
1869 if (!ret || ret >= MAX_PATH)
1870 {
1871 /* generic failure */
1872 return INVALID_HANDLE_VALUE;
1873 }
1874
1875 /* append path */
1876 wcscat(Windir, L"repair\\setup.log");
1877 }
1878 else
1879 {
1880 if (!LogFileName)
1881 {
1882 /* invalid parameter */
1884 return INVALID_HANDLE_VALUE;
1885 }
1886 /* copy filename */
1887 wcsncpy(Windir, LogFileName, MAX_PATH);
1888 }
1889
1890 if (FileExists(Windir, NULL))
1891 {
1892 /* take ownership */
1893 ret = TakeOwnershipOfFile(Windir);
1894
1895 if (ret != ERROR_SUCCESS)
1896 {
1897 /* failed */
1899 return INVALID_HANDLE_VALUE;
1900 }
1901
1903 {
1904 /* failed */
1905 return INVALID_HANDLE_VALUE;
1906 }
1907
1908 if ((Flags & SPFILELOG_FORCENEW))
1909 {
1910 if (!DeleteFileW(Windir))
1911 {
1912 /* failed */
1913 return INVALID_HANDLE_VALUE;
1914 }
1915 }
1916 }
1917
1918 /* open log file */
1919 hLog = CreateFileW(Windir,
1922 NULL,
1925 NULL);
1926
1928 {
1929 /* failed */
1930 return INVALID_HANDLE_VALUE;
1931 }
1932
1933 /* close log handle */
1935
1936 /* allocate file log struct */
1937 Log = HeapAlloc(GetProcessHeap(), 0, sizeof(struct FileLog));
1938 if (!Log)
1939 {
1940 /* not enough memory */
1942 return INVALID_HANDLE_VALUE;
1943 }
1944
1945 /* initialize log */
1946 Log->LogName = HeapAlloc(GetProcessHeap(), 0, (wcslen(Windir)+1) * sizeof(WCHAR));
1947 if (!Log->LogName)
1948 {
1949 /* not enough memory */
1950 HeapFree(GetProcessHeap(), 0, Log);
1952 return INVALID_HANDLE_VALUE;
1953 }
1954
1955 wcscpy(Log->LogName, Windir);
1958
1959 return (HSPFILELOG)Log;
1960}
1961
1962/***********************************************************************
1963 * SetupInitializeFileLogA(SETUPAPI.@)
1964 */
1966{
1968 LPWSTR LogFileNameW = NULL;
1969
1970 TRACE("%s, 0x%x\n",debugstr_a(LogFileName),Flags);
1971
1972 if (LogFileName)
1973 {
1974 LogFileNameW = strdupAtoW(LogFileName);
1975
1976 if (!LogFileNameW)
1977 {
1978 /* not enough memory */
1980 return INVALID_HANDLE_VALUE;
1981 }
1982
1983 hLog = SetupInitializeFileLogW(LogFileNameW, Flags);
1984 HeapFree(GetProcessHeap(), 0, LogFileNameW);
1985 }
1986 else
1987 {
1989 }
1990
1991 return hLog;
1992}
1993
1994/***********************************************************************
1995 * SetupTerminateFileLog(SETUPAPI.@)
1996 */
1998{
1999 struct FileLog * Log;
2000
2001 TRACE ("%p\n",FileLogHandle);
2002
2003 Log = (struct FileLog *)FileLogHandle;
2004
2005 /* free file log handle */
2006 HeapFree(GetProcessHeap(), 0, Log->LogName);
2007 HeapFree(GetProcessHeap(), 0, Log);
2008
2010
2011 return TRUE;
2012}
2013
2014/***********************************************************************
2015 * SetupCloseLog(SETUPAPI.@)
2016 */
2018{
2020
2023
2026
2028}
2029
2030/***********************************************************************
2031 * SetupOpenLog(SETUPAPI.@)
2032 */
2034{
2036
2037 static const WCHAR setupactlog[] = {'\\','s','e','t','u','p','a','c','t','.','l','o','g',0};
2038 static const WCHAR setuperrlog[] = {'\\','s','e','t','u','p','e','r','r','.','l','o','g',0};
2039
2041
2043 {
2045 return TRUE;
2046 }
2047
2049 lstrcatW(path, setupactlog);
2050
2054 {
2056 return FALSE;
2057 }
2058
2060
2062 lstrcatW(path, setuperrlog);
2063
2067 {
2071 return FALSE;
2072 }
2073
2075
2077
2078 return TRUE;
2079}
2080
2081/***********************************************************************
2082 * SetupLogErrorA(SETUPAPI.@)
2083 */
2085{
2086 static const char null[] = "(null)";
2087 BOOL ret;
2088 DWORD written;
2089 DWORD len;
2090
2092
2094 {
2096 ret = FALSE;
2097 goto done;
2098 }
2099
2100 if (message == NULL)
2101 message = null;
2102
2103 len = lstrlenA(message);
2104
2105 ret = WriteFile(setupact, message, len, &written, NULL);
2106 if (!ret)
2107 goto done;
2108
2109 if (severity >= LogSevMaximum)
2110 {
2111 ret = FALSE;
2112 goto done;
2113 }
2114
2116 ret = WriteFile(setuperr, message, len, &written, NULL);
2117
2118done:
2120 return ret;
2121}
2122
2123/***********************************************************************
2124 * SetupLogErrorW(SETUPAPI.@)
2125 */
2127{
2128 LPSTR msg = NULL;
2129 DWORD len;
2130 BOOL ret;
2131
2132 if (message)
2133 {
2136 if (msg == NULL)
2137 {
2139 return FALSE;
2140 }
2142 }
2143
2144 /* This is the normal way to proceed. The log files are ASCII files
2145 * and W is to be converted.
2146 */
2148
2150 return ret;
2151}
unsigned char BOOLEAN
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define msg(x)
Definition: auth_time.c:54
static const WCHAR infW[]
Definition: axinstall.c:35
static const WCHAR nameW[]
Definition: main.c:46
int null(void)
Definition: ftp.c:1794
static HANDLE hLog
Definition: misc.cpp:13
#define FIXME(fmt,...)
Definition: debug.h:114
#define WARN(fmt,...)
Definition: debug.h:115
#define ERR(fmt,...)
Definition: debug.h:113
#define MSZIP_MAGIC
Definition: cabinet.c:218
HINSTANCE hInstance
Definition: charmap.c:19
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define NO_ERROR
Definition: dderror.h:5
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
BOOL WINAPI LookupPrivilegeValueW(LPCWSTR lpSystemName, LPCWSTR lpPrivilegeName, PLUID lpLuid)
Definition: misc.c:782
BOOL WINAPI CheckTokenMembership(IN HANDLE ExistingTokenHandle, IN PSID SidToCheck, OUT PBOOL IsMember)
Definition: token.c:21
BOOL WINAPI AdjustTokenPrivileges(HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength)
Definition: security.c:374
BOOL WINAPI GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength)
Definition: security.c:411
BOOL WINAPI OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle)
Definition: security.c:294
BOOL WINAPI SetFileSecurityW(LPCWSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor)
Definition: security.c:1509
BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID *pSid)
Definition: security.c:674
BOOL WINAPI InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision)
Definition: security.c:929
PVOID WINAPI FreeSid(PSID pSid)
Definition: security.c:698
BOOL WINAPI GetFileSecurityW(LPCWSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded)
Definition: security.c:1404
HMODULE hModule
Definition: animate.c:44
static WCHAR * strdupAtoW(const char *str)
Definition: main.c:65
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define PAGE_READONLY
Definition: compat.h:138
#define UnmapViewOfFile
Definition: compat.h:746
#define CP_ACP
Definition: compat.h:109
#define OPEN_EXISTING
Definition: compat.h:775
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
#define SetFilePointer
Definition: compat.h:743
#define SetLastError(x)
Definition: compat.h:752
#define GetProcAddress(x, y)
Definition: compat.h:753
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define HeapAlloc
Definition: compat.h:733
#define HeapReAlloc
Definition: compat.h:734
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:744
#define FreeLibrary(x)
Definition: compat.h:748
#define GetCurrentProcess()
Definition: compat.h:759
#define GENERIC_READ
Definition: compat.h:135
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CreateFileW
Definition: compat.h:741
#define FILE_MAP_READ
Definition: compat.h:776
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define CALLBACK
Definition: compat.h:35
#define lstrcpyW
Definition: compat.h:749
#define WideCharToMultiByte
Definition: compat.h:111
#define MapViewOfFile
Definition: compat.h:745
#define MultiByteToWideChar
Definition: compat.h:110
#define LoadLibraryW(x)
Definition: compat.h:747
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
#define FILE_SHARE_READ
Definition: compat.h:136
#define lstrcpynW
Definition: compat.h:738
#define lstrlenW
Definition: compat.h:750
static void cleanup(void)
Definition: main.c:1335
UINT WINAPI SetErrorMode(IN UINT uMode)
Definition: except.c:751
BOOL WINAPI CopyFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN BOOL bFailIfExists)
Definition: copy.c:439
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
BOOL WINAPI SetFileAttributesW(LPCWSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:794
BOOL WINAPI SetFileTime(IN HANDLE hFile, CONST FILETIME *lpCreationTime OPTIONAL, CONST FILETIME *lpLastAccessTime OPTIONAL, CONST FILETIME *lpLastWriteTime OPTIONAL)
Definition: fileinfo.c:948
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:331
BOOL WINAPI GetFileTime(IN HANDLE hFile, OUT LPFILETIME lpCreationTime OPTIONAL, OUT LPFILETIME lpLastAccessTime OPTIONAL, OUT LPFILETIME lpLastWriteTime OPTIONAL)
Definition: fileinfo.c:896
HANDLE WINAPI FindFirstFileW(IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:320
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
BOOL WINAPI MoveFileExW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName OPTIONAL, IN DWORD dwFlags)
Definition: move.c:1120
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
DWORD WINAPI GetModuleFileNameA(HINSTANCE hModule, LPSTR lpFilename, DWORD nSize)
Definition: loader.c:539
UINT WINAPI GetSystemWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2397
UINT WINAPI GetWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2352
static void basename(LPCWSTR path, LPWSTR name)
Definition: profile.c:38
DWORD WINAPI CaptureStringArg(LPCWSTR pSrc, LPWSTR *pDst)
Definition: misc.c:547
DWORD WINAPI GetSetFileTimestamp(LPCWSTR lpFileName, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime, BOOLEAN bSetFileTime)
Definition: misc.c:948
LPWSTR WINAPI pSetupGetFileTitle(LPCWSTR lpFileName)
Definition: misc.c:998
BOOL WINAPI pSetupConcatenatePaths(LPWSTR lpPath, LPCWSTR lpAppend, DWORD dwBufferSize, LPDWORD lpRequiredSize)
Definition: misc.c:1040
BOOL WINAPI pSetupUnmapAndCloseFile(HANDLE hFile, HANDLE hMapping, LPVOID lpBuffer)
Definition: misc.c:664
static BOOL get_file_sizes_none(LPCWSTR source, DWORD *source_size, DWORD *target_size)
Definition: misc.c:1337
static BOOL get_file_sizes_cab(LPCWSTR source, DWORD *source_size, DWORD *target_size)
Definition: misc.c:1389
DWORD WINAPI RetreiveFileSecurity(LPCWSTR lpFileName, PSECURITY_DESCRIPTOR *pSecurityDescriptor)
Definition: misc.c:794
BOOL WINAPI SetupLogErrorW(LPCWSTR message, LogSeverity severity)
Definition: misc.c:2126
BOOL WINAPI SetupUninstallOEMInfA(PCSTR inf_file, DWORD flags, PVOID reserved)
Definition: misc.c:1243
void WINAPI pSetupModifyGlobalFlags(DWORD mask, DWORD flags)
Definition: misc.c:858
static DWORD decompress_file_cab(LPCWSTR source, LPCWSTR target)
Definition: misc.c:1640
DWORD WINAPI SetupDecompressOrCopyFileW(PCWSTR source, PCWSTR target, PUINT type)
Definition: misc.c:1690
BOOL WINAPI SetupUninstallOEMInfW(PCWSTR inf_file, DWORD flags, PVOID reserved)
Definition: misc.c:1214
static DWORD decompress_file_lz(LPCWSTR source, LPCWSTR target)
Definition: misc.c:1582
BOOL WINAPI DoesUserHavePrivilege(LPCWSTR lpPrivilegeName)
Definition: misc.c:366
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
DWORD FreeFunctionPointer(IN HMODULE ModulePointer, IN PVOID FunctionPointer)
Definition: misc.c:105
BOOL WINAPI SetupOpenLog(BOOL reserved)
Definition: misc.c:2033
LPVOID WINAPI MyRealloc(LPVOID lpSrc, DWORD dwSize)
Definition: misc.c:172
static BOOL TrimGuidString(PCWSTR szString, LPWSTR szNewString)
Definition: misc.c:1725
BOOL WINAPI SetupTerminateFileLog(HANDLE FileLogHandle)
Definition: misc.c:1997
static const WCHAR TranslationRegKey[]
Definition: misc.c:29
BOOL WINAPI SetupGetFileCompressionInfoExA(PCSTR source, PSTR name, DWORD len, PDWORD required, PDWORD source_size, PDWORD target_size, PUINT type)
Definition: misc.c:1411
static HANDLE setupact
Definition: misc.c:32
static HANDLE setuperr
Definition: misc.c:33
static CRITICAL_SECTION_DEBUG critsect_debug
Definition: misc.c:35
DWORD WINAPI pSetupGetGlobalFlags(void)
Definition: misc.c:850
DWORD WINAPI TakeOwnershipOfFile(LPCWSTR lpFileName)
Definition: misc.c:720
LPVOID WINAPI MyMalloc(DWORD dwSize)
Definition: misc.c:147
DWORD WINAPI SetupDecompressOrCopyFileA(PCSTR source, PCSTR target, PUINT type)
Definition: misc.c:1656
void WINAPI pSetupSetGlobalFlags(DWORD flags)
Definition: misc.c:867
LPSTR WINAPI pSetupUnicodeToMultiByte(LPCWSTR lpUnicodeStr, UINT uCodePage)
Definition: misc.c:327
DWORD WINAPI pSetupCaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
Definition: misc.c:574
LONG WINAPI QueryRegistryValue(HKEY hKey, LPCWSTR lpValueName, LPBYTE *lpData, LPDWORD lpType, LPDWORD lpcbData)
Definition: misc.c:234
static const WCHAR BackSlash[]
Definition: misc.c:28
static UINT CALLBACK file_compression_info_callback(PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2)
Definition: misc.c:1373
BOOL WINAPI pSetupIsUserAdmin(VOID)
Definition: misc.c:1817
static CRITICAL_SECTION setupapi_cs
Definition: misc.c:34
BOOL WINAPI pSetupEnablePrivilege(LPCWSTR lpPrivilegeName, BOOL bEnable)
Definition: misc.c:440
VOID WINAPI AssertFail(LPSTR lpFile, UINT uLine, LPSTR lpMessage)
Definition: misc.c:905
BOOL WINAPI SetupGetNonInteractiveMode(VOID)
Definition: misc.c:875
DWORD WINAPI pSetupInstallCatalog(LPCWSTR catalog, LPCWSTR basename, LPWSTR fullname)
Definition: misc.c:1268
BOOL WINAPI FileExists(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFileFindData)
Definition: misc.c:502
DWORD WINAPI pSetupGuidFromString(PCWSTR pString, LPGUID lpGUID)
Definition: misc.c:1751
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
DWORD WINAPI SetupGetFileCompressionInfoA(PCSTR source, PSTR *name, PDWORD source_size, PDWORD target_size, PUINT type)
Definition: misc.c:1512
DWORD WINAPI SetupGetFileCompressionInfoW(PCWSTR source, PWSTR *name, PDWORD source_size, PDWORD target_size, PUINT type)
Definition: misc.c:1555
DWORD WINAPI InstallCatalog(LPCSTR catalog, LPCSTR basename, LPSTR fullname)
Definition: misc.c:1259
void WINAPI SetupCloseLog(void)
Definition: misc.c:2017
BOOL WINAPI SetupSetNonInteractiveMode(BOOL NonInteractiveFlag)
Definition: misc.c:883
DWORD WINAPI pSetupOpenAndMapFileForRead(LPCWSTR lpFileName, LPDWORD lpSize, LPHANDLE lpFile, LPHANDLE lpMapping, LPVOID *lpBuffer)
Definition: misc.c:604
LPWSTR WINAPI pSetupDuplicateString(LPCWSTR lpSrc)
Definition: misc.c:198
static BOOL get_file_sizes_lz(LPCWSTR source, DWORD *source_size, DWORD *target_size)
Definition: misc.c:1347
HSPFILELOG WINAPI SetupInitializeFileLogW(LPCWSTR LogFileName, DWORD Flags)
Definition: misc.c:1843
BOOL WINAPI DelayedMove(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName)
Definition: misc.c:482
HSPFILELOG WINAPI SetupInitializeFileLogA(LPCSTR LogFileName, DWORD Flags)
Definition: misc.c:1965
BOOL WINAPI SetupGetFileCompressionInfoExW(PCWSTR source, PWSTR name, DWORD len, PDWORD required, PDWORD source_size, PDWORD target_size, PUINT type)
Definition: misc.c:1472
VOID WINAPI pSetupCenterWindowRelativeToParent(HWND hwnd)
Definition: misc.c:1108
DWORD GlobalSetupFlags
Definition: misc.c:845
BOOL WINAPI pSetupIsGuidNull(LPGUID lpGUID)
Definition: misc.c:1807
DWORD WINAPI pSetupStringFromGuid(LPGUID lpGUID, PWSTR pString, DWORD dwStringLen)
Definition: misc.c:1775
BOOL WINAPI SetupLogErrorA(LPCSTR message, LogSeverity severity)
Definition: misc.c:2084
BOOL WINAPI pSetupGetVersionInfoFromImage(LPWSTR lpFileName, PULARGE_INTEGER lpFileVersion, LPWORD lpVersionVarSize)
Definition: misc.c:1158
DWORD WINAPI StampFileSecurity(LPCWSTR lpFileName, PSECURITY_DESCRIPTOR pSecurityDescriptor)
Definition: misc.c:695
static UINT detect_compression_type(LPCWSTR file)
Definition: misc.c:1293
DWORD GetFunctionPointer(IN PWSTR InstallerName, OUT HMODULE *ModulePointer, OUT PVOID *FunctionPointer)
Definition: misc.c:44
static UINT CALLBACK decompress_or_copy_callback(PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2)
Definition: misc.c:1618
BOOL WINAPI SetupIterateCabinetW(PCWSTR CabinetFile, DWORD Reserved, PSP_FILE_CALLBACK_W MsgHandler, PVOID Context)
Definition: setupcab.c:575
BOOL WINAPI GetFileVersionInfoW(LPCWSTR filename, DWORD handle, DWORD datasize, LPVOID data)
Definition: version.c:845
BOOL WINAPI VerQueryValueW(LPCVOID pBlock, LPCWSTR lpSubBlock, LPVOID *lplpBuffer, PUINT puLen)
Definition: version.c:1049
DWORD WINAPI GetFileVersionInfoSizeW(LPCWSTR filename, LPDWORD handle)
Definition: version.c:611
BOOL WINAPI CryptCATAdminReleaseContext(HCATADMIN hCatAdmin, DWORD dwFlags)
Definition: crypt.c:444
HCATINFO WINAPI CryptCATAdminAddCatalog(HCATADMIN catAdmin, PWSTR catalogFile, PWSTR selectBaseName, DWORD flags)
Definition: crypt.c:162
BOOL WINAPI CryptCATAdminReleaseCatalogContext(HCATADMIN hCatAdmin, HCATINFO hCatInfo, DWORD dwFlags)
Definition: crypt.c:412
BOOL WINAPI CryptCATAdminAcquireContext(HCATADMIN *catAdmin, const GUID *sys, DWORD dwFlags)
Definition: crypt.c:97
r reserved
Definition: btrfs.c:3006
#define FILEOP_SKIP
Definition: fileqsup.h:49
#define FILEOP_DOIT
Definition: fileqsup.h:48
#define FILEOP_ABORT
Definition: fileqsup.h:47
#define MOVEFILE_REPLACE_EXISTING
Definition: filesup.h:28
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
FxString * pString
FxAutoRegKey hKey
Status
Definition: gdiplustypes.h:25
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLsizeiptr size
Definition: glext.h:5919
GLenum src
Definition: glext.h:6340
GLuint buffer
Definition: glext.h:5915
const GLubyte * c
Definition: glext.h:8905
GLenum GLint GLuint mask
Definition: glext.h:6028
GLenum GLenum dst
Definition: glext.h:6340
GLbitfield flags
Definition: glext.h:7161
GLenum GLenum severity
Definition: glext.h:7750
GLenum GLsizei len
Definition: glext.h:6722
GLenum target
Definition: glext.h:7315
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
static const WCHAR sourceW[]
Definition: jsregexp.c:37
#define c
Definition: ke_i.h:80
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
#define wine_dbgstr_w
Definition: kernel32.h:34
#define GUID_NULL
Definition: ks.h:106
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
LONG WINAPI LZSeek(HFILE fd, LONG off, INT type)
Definition: lzexpand.c:431
HFILE WINAPI LZOpenFileW(LPWSTR fn, LPOFSTRUCT ofs, WORD mode)
Definition: lzexpand.c:580
LONG WINAPI LZCopy(HFILE src, HFILE dest)
Definition: lzexpand.c:467
void WINAPI LZClose(HFILE fd)
Definition: lzexpand.c:595
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define OPEN_ALWAYS
Definition: disk.h:70
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
static PVOID ptr
Definition: dispmode.c:27
const char * fullname
Definition: shader.c:1766
static DWORD get_file_size(void)
Definition: integrity.c:149
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
_In_ HANDLE hFile
Definition: mswsock.h:90
unsigned int * PUINT
Definition: ndis.h:50
unsigned int UINT
Definition: ndis.h:50
#define SEM_FAILCRITICALERRORS
Definition: rtltypes.h:69
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define GENERIC_WRITE
Definition: nt_native.h:90
#define FILE_GENERIC_WRITE
Definition: nt_native.h:660
_Must_inspect_result_ _In_ ACCESS_MASK _In_opt_ POBJECT_ATTRIBUTES _In_opt_ PUNICODE_STRING LogFileName
Definition: nttmapi.h:324
#define L(x)
Definition: ntvdm.h:50
DWORD * PDWORD
Definition: pedump.c:68
long LONG
Definition: pedump.c:60
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define strchrW(s, c)
Definition: unicode.h:40
#define strcatW(d, s)
Definition: unicode.h:36
#define isspaceW(n)
Definition: unicode.h:58
#define strcpyW(d, s)
Definition: unicode.h:35
unsigned short * RPC_WSTR
Definition: rpcdce.h:46
#define RPC_S_OK
Definition: rpcnterr.h:22
RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, RPC_WSTR *StringUuid)
Definition: rpcrt4_main.c:540
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:175
RPC_STATUS WINAPI UuidFromStringW(RPC_WSTR s, UUID *uuid)
Definition: rpcrt4_main.c:614
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
_CRTIMP wchar_t *__cdecl wcsncpy(wchar_t *_Dest, const wchar_t *_Source, size_t _Count)
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
long RPC_STATUS
Definition: rpc.h:52
BOOL WINAPI SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted)
Definition: sec.c:312
#define LogSevMaximum
Definition: setupapi.h:457
#define FILE_COMPRESSION_WINLZA
Definition: setupapi.h:359
#define FILE_COMPRESSION_NTCAB
Definition: setupapi.h:364
#define SUOI_FORCEDELETE
Definition: setupapi.h:664
#define SPFILELOG_FORCENEW
Definition: setupapi.h:577
#define SPFILELOG_QUERYONLY
Definition: setupapi.h:578
#define LogSeverity
Definition: setupapi.h:458
#define FILE_COMPRESSION_MSZIP
Definition: setupapi.h:362
#define FILE_COMPRESSION_NONE
Definition: setupapi.h:356
#define LogSevInformation
Definition: setupapi.h:453
#define SPFILELOG_SYSTEMLOG
Definition: setupapi.h:575
#define SPFILENOTIFY_FILEINCABINET
Definition: setupapi.h:562
#define PSPGF_NONINTERACTIVE
#define TRACE(s)
Definition: solgame.cpp:4
DWORD SystemLog
DWORD ReadOnly
LPWSTR LogName
LIST_ENTRY ProcessLocksList
Definition: winbase.h:883
LONG HighPart
DWORD LowPart
PSID Owner
Definition: setypes.h:1028
$ULONG PrivilegeCount
Definition: setypes.h:1023
LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY]
Definition: setypes.h:1024
$ULONG LowPart
Definition: ntbasedef.h:569
$ULONG HighPart
Definition: ntbasedef.h:570
BOOL has_extracted
Definition: misc.c:1614
LPCWSTR target
Definition: misc.c:1615
Definition: http.c:7252
Definition: fci.c:127
Definition: inf.c:49
Definition: tftpd.h:60
Definition: name.c:39
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
DWORD dwFileVersionLS
Definition: compat.h:903
DWORD dwFileVersionMS
Definition: compat.h:902
#define DWORD_PTR
Definition: treelist.c:76
uint16_t * PWSTR
Definition: typedefs.h:56
char * PSTR
Definition: typedefs.h:51
const uint16_t * PCWSTR
Definition: typedefs.h:57
unsigned char * LPBYTE
Definition: typedefs.h:53
uint16_t * LPWORD
Definition: typedefs.h:56
uint32_t * LPDWORD
Definition: typedefs.h:59
int32_t INT
Definition: typedefs.h:58
const char * PCSTR
Definition: typedefs.h:52
#define IN
Definition: typedefs.h:39
uint16_t * PWCHAR
Definition: typedefs.h:56
#define OUT
Definition: typedefs.h:40
int ret
_In_ WDFCOLLECTION _In_ ULONG Index
#define FILE_END
Definition: winbase.h:114
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
_In_ LPCSTR lpFileName
Definition: winbase.h:3071
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
_In_ LPCSTR lpName
Definition: winbase.h:2789
void WINAPI DebugBreak(void)
#define INVALID_FILE_SIZE
Definition: winbase.h:548
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
#define OF_READ
Definition: winbase.h:116
#define OF_CREATE
Definition: winbase.h:125
#define MOVEFILE_DELAY_UNTIL_REBOOT
Definition: winbase.h:400
_In_ DWORD nLength
Definition: wincon.h:473
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
_In_ BOOL bEnable
Definition: winddi.h:3426
#define WINAPI
Definition: msvc.h:6
#define RPC_S_INVALID_STRING_UUID
Definition: winerror.h:1016
#define ERROR_FILE_INVALID
Definition: winerror.h:585
#define ERROR_INVALID_DATA
Definition: winerror.h:116
#define GW_OWNER
Definition: winuser.h:766
#define MB_SETFOREGROUND
Definition: winuser.h:814
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
int WINAPI MessageBoxA(_In_opt_ HWND hWnd, _In_opt_ LPCSTR lpText, _In_opt_ LPCSTR lpCaption, _In_ UINT uType)
#define MB_TASKMODAL
Definition: winuser.h:816
#define MB_YESNO
Definition: winuser.h:817
BOOL WINAPI ClientToScreen(_In_ HWND, _Inout_ LPPOINT)
int WINAPIV wsprintfA(_Out_ LPSTR, _In_ _Printf_format_string_ LPCSTR,...)
#define MB_ICONERROR
Definition: winuser.h:787
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
HWND WINAPI GetWindow(_In_ HWND, _In_ UINT)
#define IDYES
Definition: winuser.h:835
BOOL WINAPI MoveWindow(_In_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ BOOL)
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
_In_ PSECURITY_SUBJECT_CONTEXT _In_ BOOLEAN _In_ ACCESS_MASK _In_ ACCESS_MASK _Outptr_opt_ PPRIVILEGE_SET * Privileges
Definition: sefuncs.h:17
#define SECURITY_BUILTIN_DOMAIN_RID
Definition: setypes.h:581
#define DACL_SECURITY_INFORMATION
Definition: setypes.h:125
#define TOKEN_ADJUST_PRIVILEGES
Definition: setypes.h:930
#define TOKEN_QUERY
Definition: setypes.h:928
#define OWNER_SECURITY_INFORMATION
Definition: setypes.h:123
#define SECURITY_NT_AUTHORITY
Definition: setypes.h:554
@ TokenPrivileges
Definition: setypes.h:968
@ TokenOwner
Definition: setypes.h:969
#define SECURITY_DESCRIPTOR_REVISION
Definition: setypes.h:58
#define GROUP_SECURITY_INFORMATION
Definition: setypes.h:124
#define SE_PRIVILEGE_ENABLED
Definition: setypes.h:63
#define DOMAIN_ALIAS_RID_ADMINS
Definition: setypes.h:652
struct _TOKEN_OWNER * PTOKEN_OWNER
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
char CHAR
Definition: xmlstorage.h:175
unsigned char BYTE
Definition: xxhash.c:193