2 * Setupapi miscellaneous functions
4 * Copyright 2005 Eric Kohl
5 * Copyright 2007 Hans Leidekker
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.
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.
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
32 #include "wine/unicode.h"
33 #include "wine/debug.h"
35 #include "setupapi_private.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
40 /* arbitrary limit not related to what native actually uses */
41 #define OEM_INDEX_LIMIT 999
43 /**************************************************************************
46 * Frees an allocated memory block from the process heap.
49 * lpMem [I] pointer to memory block which will be freed
54 VOID WINAPI MyFree(LPVOID lpMem)
56 HeapFree(GetProcessHeap(), 0, lpMem);
60 /**************************************************************************
61 * MyMalloc [SETUPAPI.@]
63 * Allocates memory block from the process heap.
66 * dwSize [I] size of the allocated memory block
69 * Success: pointer to allocated memory block
72 LPVOID WINAPI MyMalloc(DWORD dwSize)
74 return HeapAlloc(GetProcessHeap(), 0, dwSize);
78 /**************************************************************************
79 * MyRealloc [SETUPAPI.@]
81 * Changes the size of an allocated memory block or allocates a memory
82 * block from the process heap.
85 * lpSrc [I] pointer to memory block which will be resized
86 * dwSize [I] new size of the memory block
89 * Success: pointer to the resized memory block
93 * If lpSrc is a NULL-pointer, then MyRealloc allocates a memory
94 * block like MyMalloc.
96 LPVOID WINAPI MyRealloc(LPVOID lpSrc, DWORD dwSize)
99 return HeapAlloc(GetProcessHeap(), 0, dwSize);
101 return HeapReAlloc(GetProcessHeap(), 0, lpSrc, dwSize);
105 /**************************************************************************
106 * DuplicateString [SETUPAPI.@]
108 * Duplicates a unicode string.
111 * lpSrc [I] pointer to the unicode string that will be duplicated
114 * Success: pointer to the duplicated unicode string
118 * Call MyFree() to release the duplicated string.
120 LPWSTR WINAPI DuplicateString(LPCWSTR lpSrc)
124 lpDst = MyMalloc((lstrlenW(lpSrc) + 1) * sizeof(WCHAR));
128 strcpyW(lpDst, lpSrc);
134 /**************************************************************************
135 * QueryRegistryValue [SETUPAPI.@]
137 * Retrieves value data from the registry and allocates memory for the
141 * hKey [I] Handle of the key to query
142 * lpValueName [I] Name of value under hkey to query
143 * lpData [O] Destination for the values contents,
144 * lpType [O] Destination for the value type
145 * lpcbData [O] Destination for the size of data
148 * Success: ERROR_SUCCESS
152 * Use MyFree to release the lpData buffer.
154 LONG WINAPI QueryRegistryValue(HKEY hKey,
162 TRACE("%p %s %p %p %p\n",
163 hKey, debugstr_w(lpValueName), lpData, lpType, lpcbData);
165 /* Get required buffer size */
167 lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, NULL, lpcbData);
168 if (lError != ERROR_SUCCESS)
171 /* Allocate buffer */
172 *lpData = MyMalloc(*lpcbData);
174 return ERROR_NOT_ENOUGH_MEMORY;
176 /* Query registry value */
177 lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, *lpData, lpcbData);
178 if (lError != ERROR_SUCCESS)
185 /**************************************************************************
186 * IsUserAdmin [SETUPAPI.@]
188 * Checks whether the current user is a member of the Administrators group.
197 BOOL WINAPI IsUserAdmin(VOID)
199 SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
202 PTOKEN_GROUPS lpGroups;
205 BOOL bResult = FALSE;
209 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
214 if (!GetTokenInformation(hToken, TokenGroups, NULL, 0, &dwSize))
216 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
223 lpGroups = MyMalloc(dwSize);
224 if (lpGroups == NULL)
230 if (!GetTokenInformation(hToken, TokenGroups, lpGroups, dwSize, &dwSize))
239 if (!AllocateAndInitializeSid(&Authority, 2, SECURITY_BUILTIN_DOMAIN_RID,
240 DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
247 for (i = 0; i < lpGroups->GroupCount; i++)
249 if (EqualSid(lpSid, lpGroups->Groups[i].Sid))
263 /**************************************************************************
264 * MultiByteToUnicode [SETUPAPI.@]
266 * Converts a multi-byte string to a Unicode string.
269 * lpMultiByteStr [I] Multi-byte string to be converted
270 * uCodePage [I] Code page
273 * Success: pointer to the converted Unicode string
277 * Use MyFree to release the returned Unicode string.
279 LPWSTR WINAPI MultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
284 nLength = MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
289 lpUnicodeStr = MyMalloc(nLength * sizeof(WCHAR));
290 if (lpUnicodeStr == NULL)
293 if (!MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
294 nLength, lpUnicodeStr, nLength))
296 MyFree(lpUnicodeStr);
304 /**************************************************************************
305 * UnicodeToMultiByte [SETUPAPI.@]
307 * Converts a Unicode string to a multi-byte string.
310 * lpUnicodeStr [I] Unicode string to be converted
311 * uCodePage [I] Code page
314 * Success: pointer to the converted multi-byte string
318 * Use MyFree to release the returned multi-byte string.
320 LPSTR WINAPI UnicodeToMultiByte(LPCWSTR lpUnicodeStr, UINT uCodePage)
322 LPSTR lpMultiByteStr;
325 nLength = WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
326 NULL, 0, NULL, NULL);
330 lpMultiByteStr = MyMalloc(nLength);
331 if (lpMultiByteStr == NULL)
334 if (!WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
335 lpMultiByteStr, nLength, NULL, NULL))
337 MyFree(lpMultiByteStr);
341 return lpMultiByteStr;
345 /**************************************************************************
346 * DoesUserHavePrivilege [SETUPAPI.@]
348 * Check whether the current user has got a given privilege.
351 * lpPrivilegeName [I] Name of the privilege to be checked
357 BOOL WINAPI DoesUserHavePrivilege(LPCWSTR lpPrivilegeName)
361 PTOKEN_PRIVILEGES lpPrivileges;
364 BOOL bResult = FALSE;
366 TRACE("%s\n", debugstr_w(lpPrivilegeName));
368 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
371 if (!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwSize))
373 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
380 lpPrivileges = MyMalloc(dwSize);
381 if (lpPrivileges == NULL)
387 if (!GetTokenInformation(hToken, TokenPrivileges, lpPrivileges, dwSize, &dwSize))
389 MyFree(lpPrivileges);
396 if (!LookupPrivilegeValueW(NULL, lpPrivilegeName, &PrivilegeLuid))
398 MyFree(lpPrivileges);
402 for (i = 0; i < lpPrivileges->PrivilegeCount; i++)
404 if (lpPrivileges->Privileges[i].Luid.HighPart == PrivilegeLuid.HighPart &&
405 lpPrivileges->Privileges[i].Luid.LowPart == PrivilegeLuid.LowPart)
411 MyFree(lpPrivileges);
417 /**************************************************************************
418 * EnablePrivilege [SETUPAPI.@]
420 * Enables or disables one of the current users privileges.
423 * lpPrivilegeName [I] Name of the privilege to be changed
424 * bEnable [I] TRUE: Enables the privilege
425 * FALSE: Disables the privilege
431 BOOL WINAPI EnablePrivilege(LPCWSTR lpPrivilegeName, BOOL bEnable)
433 TOKEN_PRIVILEGES Privileges;
437 TRACE("%s %s\n", debugstr_w(lpPrivilegeName), bEnable ? "TRUE" : "FALSE");
439 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
442 Privileges.PrivilegeCount = 1;
443 Privileges.Privileges[0].Attributes = (bEnable) ? SE_PRIVILEGE_ENABLED : 0;
445 if (!LookupPrivilegeValueW(NULL, lpPrivilegeName,
446 &Privileges.Privileges[0].Luid))
452 bResult = AdjustTokenPrivileges(hToken, FALSE, &Privileges, 0, NULL, NULL);
460 /**************************************************************************
461 * DelayedMove [SETUPAPI.@]
463 * Moves a file upon the next reboot.
466 * lpExistingFileName [I] Current file name
467 * lpNewFileName [I] New file name
473 BOOL WINAPI DelayedMove(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName)
475 return MoveFileExW(lpExistingFileName, lpNewFileName,
476 MOVEFILE_REPLACE_EXISTING | MOVEFILE_DELAY_UNTIL_REBOOT);
480 /**************************************************************************
481 * FileExists [SETUPAPI.@]
483 * Checks whether a file exists.
486 * lpFileName [I] Name of the file to check
487 * lpNewFileName [O] Optional information about the existing file
493 BOOL WINAPI FileExists(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFileFindData)
495 WIN32_FIND_DATAW FindData;
500 uErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
502 hFind = FindFirstFileW(lpFileName, &FindData);
503 if (hFind == INVALID_HANDLE_VALUE)
505 dwError = GetLastError();
506 SetErrorMode(uErrorMode);
507 SetLastError(dwError);
514 memcpy(lpFileFindData, &FindData, sizeof(WIN32_FIND_DATAW));
516 SetErrorMode(uErrorMode);
522 /**************************************************************************
523 * CaptureStringArg [SETUPAPI.@]
525 * Captures a UNICODE string.
528 * lpSrc [I] UNICODE string to be captured
529 * lpDst [O] Pointer to the captured UNICODE string
532 * Success: ERROR_SUCCESS
533 * Failure: ERROR_INVALID_PARAMETER
536 * Call MyFree to release the captured UNICODE string.
538 DWORD WINAPI CaptureStringArg(LPCWSTR pSrc, LPWSTR *pDst)
541 return ERROR_INVALID_PARAMETER;
543 *pDst = DuplicateString(pSrc);
545 return ERROR_SUCCESS;
549 /**************************************************************************
550 * CaptureAndConvertAnsiArg [SETUPAPI.@]
552 * Captures an ANSI string and converts it to a UNICODE string.
555 * lpSrc [I] ANSI string to be captured
556 * lpDst [O] Pointer to the captured UNICODE string
559 * Success: ERROR_SUCCESS
560 * Failure: ERROR_INVALID_PARAMETER
563 * Call MyFree to release the captured UNICODE string.
565 DWORD WINAPI CaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
568 return ERROR_INVALID_PARAMETER;
570 *pDst = MultiByteToUnicode(pSrc, CP_ACP);
572 return ERROR_SUCCESS;
576 /**************************************************************************
577 * OpenAndMapFileForRead [SETUPAPI.@]
579 * Open and map a file to a buffer.
582 * lpFileName [I] Name of the file to be opened
583 * lpSize [O] Pointer to the file size
584 * lpFile [0] Pointer to the file handle
585 * lpMapping [0] Pointer to the mapping handle
586 * lpBuffer [0] Pointer to the file buffer
589 * Success: ERROR_SUCCESS
593 * Call UnmapAndCloseFile to release the file.
595 DWORD WINAPI OpenAndMapFileForRead(LPCWSTR lpFileName,
603 TRACE("%s %p %p %p %p\n",
604 debugstr_w(lpFileName), lpSize, lpFile, lpMapping, lpBuffer);
606 *lpFile = CreateFileW(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
607 OPEN_EXISTING, 0, NULL);
608 if (*lpFile == INVALID_HANDLE_VALUE)
609 return GetLastError();
611 *lpSize = GetFileSize(*lpFile, NULL);
612 if (*lpSize == INVALID_FILE_SIZE)
614 dwError = GetLastError();
615 CloseHandle(*lpFile);
619 *lpMapping = CreateFileMappingW(*lpFile, NULL, PAGE_READONLY, 0,
621 if (*lpMapping == NULL)
623 dwError = GetLastError();
624 CloseHandle(*lpFile);
628 *lpBuffer = MapViewOfFile(*lpMapping, FILE_MAP_READ, 0, 0, *lpSize);
629 if (*lpBuffer == NULL)
631 dwError = GetLastError();
632 CloseHandle(*lpMapping);
633 CloseHandle(*lpFile);
637 return ERROR_SUCCESS;
641 /**************************************************************************
642 * UnmapAndCloseFile [SETUPAPI.@]
644 * Unmap and close a mapped file.
647 * hFile [I] Handle to the file
648 * hMapping [I] Handle to the file mapping
649 * lpBuffer [I] Pointer to the file buffer
655 BOOL WINAPI UnmapAndCloseFile(HANDLE hFile, HANDLE hMapping, LPVOID lpBuffer)
658 hFile, hMapping, lpBuffer);
660 if (!UnmapViewOfFile(lpBuffer))
663 if (!CloseHandle(hMapping))
666 if (!CloseHandle(hFile))
673 /**************************************************************************
674 * StampFileSecurity [SETUPAPI.@]
676 * Assign a new security descriptor to the given file.
679 * lpFileName [I] Name of the file
680 * pSecurityDescriptor [I] New security descriptor
683 * Success: ERROR_SUCCESS
686 DWORD WINAPI StampFileSecurity(LPCWSTR lpFileName, PSECURITY_DESCRIPTOR pSecurityDescriptor)
688 TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
690 if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
691 GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
692 pSecurityDescriptor))
693 return GetLastError();
695 return ERROR_SUCCESS;
699 /**************************************************************************
700 * TakeOwnershipOfFile [SETUPAPI.@]
702 * Takes the ownership of the given file.
705 * lpFileName [I] Name of the file
708 * Success: ERROR_SUCCESS
711 DWORD WINAPI TakeOwnershipOfFile(LPCWSTR lpFileName)
713 SECURITY_DESCRIPTOR SecDesc;
714 HANDLE hToken = NULL;
715 PTOKEN_OWNER pOwner = NULL;
719 TRACE("%s\n", debugstr_w(lpFileName));
721 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
722 return GetLastError();
724 if (!GetTokenInformation(hToken, TokenOwner, NULL, 0, &dwSize))
729 pOwner = (PTOKEN_OWNER)MyMalloc(dwSize);
733 return ERROR_NOT_ENOUGH_MEMORY;
736 if (!GetTokenInformation(hToken, TokenOwner, pOwner, dwSize, &dwSize))
741 if (!InitializeSecurityDescriptor(&SecDesc, SECURITY_DESCRIPTOR_REVISION))
746 if (!SetSecurityDescriptorOwner(&SecDesc, pOwner->Owner, FALSE))
751 if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION, &SecDesc))
759 return ERROR_SUCCESS;
762 dwError = GetLastError();
773 /**************************************************************************
774 * RetreiveFileSecurity [SETUPAPI.@]
776 * Retrieve the security descriptor that is associated with the given file.
779 * lpFileName [I] Name of the file
782 * Success: ERROR_SUCCESS
785 DWORD WINAPI RetreiveFileSecurity(LPCWSTR lpFileName,
786 PSECURITY_DESCRIPTOR *pSecurityDescriptor)
788 PSECURITY_DESCRIPTOR SecDesc;
789 DWORD dwSize = 0x100;
792 SecDesc = (PSECURITY_DESCRIPTOR)MyMalloc(dwSize);
794 return ERROR_NOT_ENOUGH_MEMORY;
796 if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
797 GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
798 SecDesc, dwSize, &dwSize))
800 *pSecurityDescriptor = SecDesc;
801 return ERROR_SUCCESS;
804 dwError = GetLastError();
805 if (dwError != ERROR_INSUFFICIENT_BUFFER)
811 SecDesc = (PSECURITY_DESCRIPTOR)MyRealloc(SecDesc, dwSize);
813 return ERROR_NOT_ENOUGH_MEMORY;
815 if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
816 GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
817 SecDesc, dwSize, &dwSize))
819 *pSecurityDescriptor = SecDesc;
820 return ERROR_SUCCESS;
823 dwError = GetLastError();
830 static DWORD global_flags = 0; /* FIXME: what should be in here? */
832 /***********************************************************************
833 * pSetupGetGlobalFlags (SETUPAPI.@)
835 DWORD WINAPI pSetupGetGlobalFlags(void)
842 /***********************************************************************
843 * pSetupSetGlobalFlags (SETUPAPI.@)
845 void WINAPI pSetupSetGlobalFlags( DWORD flags )
847 global_flags = flags;
850 /***********************************************************************
851 * CMP_WaitNoPendingInstallEvents (SETUPAPI.@)
853 DWORD WINAPI CMP_WaitNoPendingInstallEvents( DWORD dwTimeout )
855 FIXME("%d\n", dwTimeout);
856 return WAIT_OBJECT_0;
859 /***********************************************************************
860 * AssertFail (SETUPAPI.@)
862 * Shows an assert fail error messagebox
865 * lpFile [I] file where assert failed
866 * uLine [I] line number in file
867 * lpMessage [I] assert message
870 void WINAPI AssertFail(LPCSTR lpFile, UINT uLine, LPCSTR lpMessage)
872 FIXME("%s %u %s\n", lpFile, uLine, lpMessage);
875 /***********************************************************************
876 * SetupCopyOEMInfA (SETUPAPI.@)
878 BOOL WINAPI SetupCopyOEMInfA( PCSTR source, PCSTR location,
879 DWORD media_type, DWORD style, PSTR dest,
880 DWORD buffer_size, PDWORD required_size, PSTR *component )
883 LPWSTR destW = NULL, sourceW = NULL, locationW = NULL;
886 TRACE("%s, %s, %d, %d, %p, %d, %p, %p\n", debugstr_a(source), debugstr_a(location),
887 media_type, style, dest, buffer_size, required_size, component);
889 if (dest && !(destW = MyMalloc( buffer_size * sizeof(WCHAR) ))) return FALSE;
890 if (source && !(sourceW = strdupAtoW( source ))) goto done;
891 if (location && !(locationW = strdupAtoW( location ))) goto done;
893 if (!(ret = SetupCopyOEMInfW( sourceW, locationW, media_type, style, destW,
894 buffer_size, &size, NULL )))
896 if (required_size) *required_size = size;
902 if (buffer_size >= size)
904 WideCharToMultiByte( CP_ACP, 0, destW, -1, dest, buffer_size, NULL, NULL );
905 if (component) *component = strrchr( dest, '\\' ) + 1;
909 SetLastError( ERROR_INSUFFICIENT_BUFFER );
916 HeapFree( GetProcessHeap(), 0, sourceW );
917 HeapFree( GetProcessHeap(), 0, locationW );
918 if (ret) SetLastError(ERROR_SUCCESS);
922 static int compare_files( HANDLE file1, HANDLE file2 )
929 while( ReadFile(file1, buffer1, sizeof(buffer1), &size1, NULL) &&
930 ReadFile(file2, buffer2, sizeof(buffer2), &size2, NULL) )
934 return size1 > size2 ? 1 : -1;
937 ret = memcmp( buffer1, buffer2, size1 );
945 /***********************************************************************
946 * SetupCopyOEMInfW (SETUPAPI.@)
948 BOOL WINAPI SetupCopyOEMInfW( PCWSTR source, PCWSTR location,
949 DWORD media_type, DWORD style, PWSTR dest,
950 DWORD buffer_size, PDWORD required_size, PWSTR *component )
953 WCHAR target[MAX_PATH], catalog_file[MAX_PATH], *p;
954 static const WCHAR inf[] = { '\\','i','n','f','\\',0 };
955 static const WCHAR wszVersion[] = { 'V','e','r','s','i','o','n',0 };
956 static const WCHAR wszCatalogFile[] = { 'C','a','t','a','l','o','g','F','i','l','e',0 };
960 TRACE("%s, %s, %d, %d, %p, %d, %p, %p\n", debugstr_w(source), debugstr_w(location),
961 media_type, style, dest, buffer_size, required_size, component);
965 SetLastError(ERROR_INVALID_PARAMETER);
969 /* check for a relative path */
970 if (!(*source == '\\' || (*source && source[1] == ':')))
972 SetLastError(ERROR_FILE_NOT_FOUND);
976 if (!GetWindowsDirectoryW( target, sizeof(target)/sizeof(WCHAR) )) return FALSE;
978 strcatW( target, inf );
979 if ((p = strrchrW( source, '\\' )))
980 strcatW( target, p + 1 );
982 /* does the file exist already? */
983 if ((GetFileAttributesW( target ) != INVALID_FILE_ATTRIBUTES) &&
984 !(style & SP_COPY_NOOVERWRITE))
986 static const WCHAR oem[] = { 'o','e','m',0 };
988 LARGE_INTEGER source_file_size;
991 source_file = CreateFileW( source, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
992 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
993 NULL, OPEN_EXISTING, 0, NULL );
994 if (source_file == INVALID_HANDLE_VALUE)
997 if (!GetFileSizeEx( source_file, &source_file_size ))
999 CloseHandle( source_file );
1003 p = strrchrW( target, '\\' ) + 1;
1004 memcpy( p, oem, sizeof(oem) );
1005 p += sizeof(oem)/sizeof(oem[0]) - 1;
1007 /* generate OEMnnn.inf ending */
1008 for (i = 0; i < OEM_INDEX_LIMIT; i++)
1010 static const WCHAR format[] = { '%','u','.','i','n','f',0 };
1012 LARGE_INTEGER dest_file_size;
1014 wsprintfW( p, format, i );
1015 dest_file = CreateFileW( target, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
1016 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1017 NULL, OPEN_EXISTING, 0, NULL );
1018 /* if we found a file name that doesn't exist then we're done */
1019 if (dest_file == INVALID_HANDLE_VALUE)
1021 /* now check if the same inf file has already been copied to the inf
1022 * directory. if so, use that file and don't create a new one */
1023 if (!GetFileSizeEx( dest_file, &dest_file_size ) ||
1024 (dest_file_size.QuadPart != source_file_size.QuadPart) ||
1025 compare_files( source_file, dest_file ))
1027 CloseHandle( dest_file );
1030 CloseHandle( dest_file );
1034 CloseHandle( source_file );
1035 if (i == OEM_INDEX_LIMIT)
1037 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1042 hinf = SetupOpenInfFileW( source, NULL, INF_STYLE_WIN4, NULL );
1043 if (hinf == INVALID_HANDLE_VALUE) return FALSE;
1045 if (SetupGetLineTextW( NULL, hinf, wszVersion, wszCatalogFile, catalog_file,
1046 sizeof(catalog_file)/sizeof(catalog_file[0]), NULL ))
1048 WCHAR source_cat[MAX_PATH];
1049 strcpyW( source_cat, source );
1051 p = strrchrW( source_cat, '\\' );
1053 else p = source_cat;
1055 strcpyW( p, catalog_file );
1057 FIXME("install catalog file %s\n", debugstr_w( source_cat ));
1059 SetupCloseInfFile( hinf );
1061 if (!(ret = CopyFileW( source, target, (style & SP_COPY_NOOVERWRITE) != 0 )))
1064 if (style & SP_COPY_DELETESOURCE)
1065 DeleteFileW( source );
1067 size = strlenW( target ) + 1;
1070 if (buffer_size >= size)
1072 strcpyW( dest, target );
1076 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1081 if (component) *component = p + 1;
1082 if (required_size) *required_size = size;
1083 if (ret) SetLastError(ERROR_SUCCESS);
1088 /***********************************************************************
1089 * InstallCatalog (SETUPAPI.@)
1091 DWORD WINAPI InstallCatalog( LPCSTR catalog, LPCSTR basename, LPSTR fullname )
1093 FIXME("%s, %s, %p\n", debugstr_a(catalog), debugstr_a(basename), fullname);
1097 static UINT detect_compression_type( LPCWSTR file )
1101 UINT type = FILE_COMPRESSION_NONE;
1102 static const BYTE LZ_MAGIC[] = { 0x53, 0x5a, 0x44, 0x44, 0x88, 0xf0, 0x27, 0x33 };
1103 static const BYTE MSZIP_MAGIC[] = { 0x4b, 0x57, 0x41, 0x4a };
1104 static const BYTE NTCAB_MAGIC[] = { 0x4d, 0x53, 0x43, 0x46 };
1107 handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
1108 if (handle == INVALID_HANDLE_VALUE)
1110 ERR("cannot open file %s\n", debugstr_w(file));
1111 return FILE_COMPRESSION_NONE;
1113 if (!ReadFile( handle, buffer, sizeof(buffer), &size, NULL ) || size != sizeof(buffer))
1115 CloseHandle( handle );
1116 return FILE_COMPRESSION_NONE;
1118 if (!memcmp( buffer, LZ_MAGIC, sizeof(LZ_MAGIC) )) type = FILE_COMPRESSION_WINLZA;
1119 else if (!memcmp( buffer, MSZIP_MAGIC, sizeof(MSZIP_MAGIC) )) type = FILE_COMPRESSION_MSZIP;
1120 else if (!memcmp( buffer, NTCAB_MAGIC, sizeof(NTCAB_MAGIC) )) type = FILE_COMPRESSION_MSZIP; /* not a typo */
1122 CloseHandle( handle );
1126 static BOOL get_file_size( LPCWSTR file, DWORD *size )
1130 handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
1131 if (handle == INVALID_HANDLE_VALUE)
1133 ERR("cannot open file %s\n", debugstr_w(file));
1136 *size = GetFileSize( handle, NULL );
1137 CloseHandle( handle );
1141 static BOOL get_file_sizes_none( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1145 if (!get_file_size( source, &size )) return FALSE;
1146 if (source_size) *source_size = size;
1147 if (target_size) *target_size = size;
1151 static BOOL get_file_sizes_lz( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1158 if (!get_file_size( source, &size )) ret = FALSE;
1159 else *source_size = size;
1166 if ((file = LZOpenFileW( (LPWSTR)source, &of, OF_READ )) < 0)
1168 ERR("cannot open source file for reading\n");
1171 *target_size = LZSeek( file, 0, 2 );
1177 static UINT CALLBACK file_compression_info_callback( PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2 )
1179 DWORD *size = context;
1180 FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
1182 switch (notification)
1184 case SPFILENOTIFY_FILEINCABINET:
1186 *size = info->FileSize;
1189 default: return NO_ERROR;
1193 static BOOL get_file_sizes_cab( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1200 if (!get_file_size( source, &size )) ret = FALSE;
1201 else *source_size = size;
1205 ret = SetupIterateCabinetW( source, 0, file_compression_info_callback, target_size );
1210 /***********************************************************************
1211 * SetupGetFileCompressionInfoExA (SETUPAPI.@)
1213 * See SetupGetFileCompressionInfoExW.
1215 BOOL WINAPI SetupGetFileCompressionInfoExA( PCSTR source, PSTR name, DWORD len, PDWORD required,
1216 PDWORD source_size, PDWORD target_size, PUINT type )
1219 WCHAR *nameW = NULL, *sourceW = NULL;
1223 TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_a(source), name, len, required,
1224 source_size, target_size, type);
1226 if (!source || !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
1230 ret = SetupGetFileCompressionInfoExW( sourceW, NULL, 0, &nb_chars, NULL, NULL, NULL );
1231 if (!(nameW = HeapAlloc( GetProcessHeap(), 0, nb_chars * sizeof(WCHAR) )))
1237 ret = SetupGetFileCompressionInfoExW( sourceW, nameW, nb_chars, &nb_chars, source_size, target_size, type );
1240 if ((nameA = UnicodeToMultiByte( nameW, CP_ACP )))
1242 if (name && len >= nb_chars) lstrcpyA( name, nameA );
1245 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1251 if (required) *required = nb_chars;
1252 HeapFree( GetProcessHeap(), 0, nameW );
1258 /***********************************************************************
1259 * SetupGetFileCompressionInfoExW (SETUPAPI.@)
1261 * Get compression type and compressed/uncompressed sizes of a given file.
1264 * source [I] File to examine.
1265 * name [O] Actual filename used.
1266 * len [I] Length in characters of 'name' buffer.
1267 * required [O] Number of characters written to 'name'.
1268 * source_size [O] Size of compressed file.
1269 * target_size [O] Size of uncompressed file.
1270 * type [O] Compression type.
1276 BOOL WINAPI SetupGetFileCompressionInfoExW( PCWSTR source, PWSTR name, DWORD len, PDWORD required,
1277 PDWORD source_size, PDWORD target_size, PUINT type )
1283 TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_w(source), name, len, required,
1284 source_size, target_size, type);
1286 if (!source) return FALSE;
1288 source_len = lstrlenW( source ) + 1;
1289 if (required) *required = source_len;
1290 if (name && len >= source_len)
1292 lstrcpyW( name, source );
1297 comp = detect_compression_type( source );
1298 if (type) *type = comp;
1302 case FILE_COMPRESSION_MSZIP:
1303 case FILE_COMPRESSION_NTCAB: ret = get_file_sizes_cab( source, source_size, target_size ); break;
1304 case FILE_COMPRESSION_NONE: ret = get_file_sizes_none( source, source_size, target_size ); break;
1305 case FILE_COMPRESSION_WINLZA: ret = get_file_sizes_lz( source, source_size, target_size ); break;
1311 /***********************************************************************
1312 * SetupGetFileCompressionInfoA (SETUPAPI.@)
1314 * See SetupGetFileCompressionInfoW.
1316 DWORD WINAPI SetupGetFileCompressionInfoA( PCSTR source, PSTR *name, PDWORD source_size,
1317 PDWORD target_size, PUINT type )
1320 DWORD error, required;
1323 TRACE("%s, %p, %p, %p, %p\n", debugstr_a(source), name, source_size, target_size, type);
1325 if (!source || !name || !source_size || !target_size || !type)
1326 return ERROR_INVALID_PARAMETER;
1328 ret = SetupGetFileCompressionInfoExA( source, NULL, 0, &required, NULL, NULL, NULL );
1329 if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
1331 ret = SetupGetFileCompressionInfoExA( source, actual_name, required, &required,
1332 source_size, target_size, type );
1335 error = GetLastError();
1336 MyFree( actual_name );
1339 *name = actual_name;
1340 return ERROR_SUCCESS;
1343 /***********************************************************************
1344 * SetupGetFileCompressionInfoW (SETUPAPI.@)
1346 * Get compression type and compressed/uncompressed sizes of a given file.
1349 * source [I] File to examine.
1350 * name [O] Actual filename used.
1351 * source_size [O] Size of compressed file.
1352 * target_size [O] Size of uncompressed file.
1353 * type [O] Compression type.
1356 * Success: ERROR_SUCCESS
1357 * Failure: Win32 error code.
1359 DWORD WINAPI SetupGetFileCompressionInfoW( PCWSTR source, PWSTR *name, PDWORD source_size,
1360 PDWORD target_size, PUINT type )
1363 DWORD error, required;
1366 TRACE("%s, %p, %p, %p, %p\n", debugstr_w(source), name, source_size, target_size, type);
1368 if (!source || !name || !source_size || !target_size || !type)
1369 return ERROR_INVALID_PARAMETER;
1371 ret = SetupGetFileCompressionInfoExW( source, NULL, 0, &required, NULL, NULL, NULL );
1372 if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
1374 ret = SetupGetFileCompressionInfoExW( source, actual_name, required, &required,
1375 source_size, target_size, type );
1378 error = GetLastError();
1379 MyFree( actual_name );
1382 *name = actual_name;
1383 return ERROR_SUCCESS;
1386 static DWORD decompress_file_lz( LPCWSTR source, LPCWSTR target )
1393 if ((src = LZOpenFileW( (LPWSTR)source, &sof, OF_READ )) < 0)
1395 ERR("cannot open source file for reading\n");
1396 return ERROR_FILE_NOT_FOUND;
1398 if ((dst = LZOpenFileW( (LPWSTR)target, &dof, OF_CREATE )) < 0)
1400 ERR("cannot open target file for writing\n");
1402 return ERROR_FILE_NOT_FOUND;
1404 if ((error = LZCopy( src, dst )) >= 0) ret = ERROR_SUCCESS;
1407 WARN("failed to decompress file %d\n", error);
1408 ret = ERROR_INVALID_DATA;
1416 static UINT CALLBACK decompress_or_copy_callback( PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2 )
1418 FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
1420 switch (notification)
1422 case SPFILENOTIFY_FILEINCABINET:
1424 LPCWSTR filename, targetname = context;
1427 if ((p = strrchrW( targetname, '\\' ))) filename = p + 1;
1428 else filename = targetname;
1430 if (!lstrcmpiW( filename, info->NameInCabinet ))
1432 strcpyW( info->FullTargetName, targetname );
1437 default: return NO_ERROR;
1441 static DWORD decompress_file_cab( LPCWSTR source, LPCWSTR target )
1445 ret = SetupIterateCabinetW( source, 0, decompress_or_copy_callback, (PVOID)target );
1447 if (ret) return ERROR_SUCCESS;
1448 else return GetLastError();
1451 /***********************************************************************
1452 * SetupDecompressOrCopyFileA (SETUPAPI.@)
1454 * See SetupDecompressOrCopyFileW.
1456 DWORD WINAPI SetupDecompressOrCopyFileA( PCSTR source, PCSTR target, PUINT type )
1459 WCHAR *sourceW = NULL, *targetW = NULL;
1461 if (source && !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
1462 if (target && !(targetW = MultiByteToUnicode( target, CP_ACP )))
1465 return ERROR_NOT_ENOUGH_MEMORY;
1468 ret = SetupDecompressOrCopyFileW( sourceW, targetW, type );
1476 /***********************************************************************
1477 * SetupDecompressOrCopyFileW (SETUPAPI.@)
1479 * Copy a file and decompress it if needed.
1482 * source [I] File to copy.
1483 * target [I] Filename of the copy.
1484 * type [I] Compression type.
1487 * Success: ERROR_SUCCESS
1488 * Failure: Win32 error code.
1490 DWORD WINAPI SetupDecompressOrCopyFileW( PCWSTR source, PCWSTR target, PUINT type )
1493 DWORD ret = ERROR_INVALID_PARAMETER;
1495 if (!source || !target) return ERROR_INVALID_PARAMETER;
1497 if (!type) comp = detect_compression_type( source );
1502 case FILE_COMPRESSION_NONE:
1503 if (CopyFileW( source, target, FALSE )) ret = ERROR_SUCCESS;
1504 else ret = GetLastError();
1506 case FILE_COMPRESSION_WINLZA:
1507 ret = decompress_file_lz( source, target );
1509 case FILE_COMPRESSION_NTCAB:
1510 case FILE_COMPRESSION_MSZIP:
1511 ret = decompress_file_cab( source, target );
1514 WARN("unknown compression type %d\n", comp);
1518 TRACE("%s -> %s %d\n", debugstr_w(source), debugstr_w(target), comp);