mirrors/rufus
1
0
Fork 0
mirror of https://github.com/pbatard/rufus.git synced 2025-05-09 12:31:57 -04:00
Code Issues Projects Releases Packages Wiki Activity

[vhd] add wimlib support

Browse source 
* This includes all the changes applied to wimlib for MSVC compilation support.
* The vast majority of these changes were original, but a very small set came
  was lifted from https://github.com/ebiggers/wimlib/pull/6 (which we discovered
  after we went through this whole exercise on our own...)
This commit is contained in:
Pete Batard 2025-04-21 20:47:03 +01:00
parent 1ed92072b8
commit 9f7d623e2e
No known key found for this signature in database
GPG key ID: 38E0CF5E69EDD671
74 changed files with 2748 additions and 317 deletions
Download patch file Download diff file Expand all files Collapse all files

68
.vs/rufus.vcxproj
View file

@ -121,19 +121,19 @@
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<BuildLog />
<ClCompile>
<PreprocessorDefinitions>_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_RUFUS;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\src\wimlib;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<ExceptionHandling>Async</ExceptionHandling>
<DisableSpecificWarnings>4091;5255;28251;28252;28253;%(DisableSpecificWarnings)</DisableSpecificWarnings>
<Optimization>Disabled</Optimization>
<AdditionalOptions>/utf-8 $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<AdditionalOptions>/utf-8 /std:clatest $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;ntdll.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;%(AdditionalDependencies)</AdditionalDependencies>
<UACExecutionLevel>RequireAdministrator</UACExecutionLevel>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
@ -152,18 +152,18 @@
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
<BuildLog />
<ClCompile>
<PreprocessorDefinitions>_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_RUFUS;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\src\wimlib;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<ExceptionHandling>Async</ExceptionHandling>
<DisableSpecificWarnings>4091;5255;28251;28252;28253;%(DisableSpecificWarnings)</DisableSpecificWarnings>
<AdditionalOptions>/utf-8 $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<AdditionalOptions>/utf-8 /std:clatest $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;ole32.lib;advapi32.lib;gdi32.lib;shell32.lib;comdlg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;ntdll.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;ole32.lib;advapi32.lib;gdi32.lib;shell32.lib;comdlg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<UACExecutionLevel>RequireAdministrator</UACExecutionLevel>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
@ -184,18 +184,18 @@
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
<BuildLog />
<ClCompile>
<PreprocessorDefinitions>_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_RUFUS;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\src\wimlib;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<ExceptionHandling>Async</ExceptionHandling>
<DisableSpecificWarnings>4091;5255;28251;28252;28253;%(DisableSpecificWarnings)</DisableSpecificWarnings>
<AdditionalOptions>/utf-8 $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<AdditionalOptions>/utf-8 /std:clatest $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;ole32.lib;advapi32.lib;gdi32.lib;shell32.lib;comdlg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;ntdll.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;ole32.lib;advapi32.lib;gdi32.lib;shell32.lib;comdlg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<UACExecutionLevel>RequireAdministrator</UACExecutionLevel>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
@ -219,8 +219,8 @@
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\src\wimlib;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_RUFUS;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
@ -229,10 +229,10 @@
<ExceptionHandling>Async</ExceptionHandling>
<DisableSpecificWarnings>4091;5255;28251;28252;28253;%(DisableSpecificWarnings)</DisableSpecificWarnings>
<Optimization>Disabled</Optimization>
<AdditionalOptions>/utf-8 $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<AdditionalOptions>/utf-8 /std:clatest $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;ntdll.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;%(AdditionalDependencies)</AdditionalDependencies>
<UACExecutionLevel>RequireAdministrator</UACExecutionLevel>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
@ -251,20 +251,20 @@
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<BuildLog />
<ClCompile>
<PreprocessorDefinitions>_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_RUFUS;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\src\wimlib;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<ExceptionHandling>Async</ExceptionHandling>
<DisableSpecificWarnings>4091;5255;28251;28252;28253;%(DisableSpecificWarnings)</DisableSpecificWarnings>
<UndefinePreprocessorDefinitions>NDEBUG</UndefinePreprocessorDefinitions>
<AdditionalOptions>/utf-8 $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<AdditionalOptions>/utf-8 /std:clatest $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<StringPooling>true</StringPooling>
</ClCompile>
<Link>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;ntdll.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;%(AdditionalDependencies)</AdditionalDependencies>
<UACExecutionLevel>RequireAdministrator</UACExecutionLevel>
<GenerateDebugInformation>false</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
@ -283,20 +283,20 @@
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
<BuildLog />
<ClCompile>
<PreprocessorDefinitions>_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_RUFUS;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\src\wimlib;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<ExceptionHandling>Async</ExceptionHandling>
<DisableSpecificWarnings>4091;5255;28251;28252;28253;%(DisableSpecificWarnings)</DisableSpecificWarnings>
<UndefinePreprocessorDefinitions>NDEBUG</UndefinePreprocessorDefinitions>
<AdditionalOptions>/utf-8 $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<AdditionalOptions>/utf-8 /std:clatest $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<StringPooling>true</StringPooling>
</ClCompile>
<Link>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;ole32.lib;advapi32.lib;gdi32.lib;shell32.lib;comdlg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;ntdll.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;ole32.lib;advapi32.lib;gdi32.lib;shell32.lib;comdlg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<UACExecutionLevel>RequireAdministrator</UACExecutionLevel>
<GenerateDebugInformation>false</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
@ -317,20 +317,20 @@
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
<BuildLog />
<ClCompile>
<PreprocessorDefinitions>_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_RUFUS;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\src\wimlib;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<ExceptionHandling>Async</ExceptionHandling>
<DisableSpecificWarnings>4091;5255;28251;28252;28253;%(DisableSpecificWarnings)</DisableSpecificWarnings>
<UndefinePreprocessorDefinitions>NDEBUG</UndefinePreprocessorDefinitions>
<AdditionalOptions>/utf-8 $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<AdditionalOptions>/utf-8 /std:clatest $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<StringPooling>true</StringPooling>
</ClCompile>
<Link>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;ole32.lib;advapi32.lib;gdi32.lib;shell32.lib;comdlg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;ntdll.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;ole32.lib;advapi32.lib;gdi32.lib;shell32.lib;comdlg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<UACExecutionLevel>RequireAdministrator</UACExecutionLevel>
<GenerateDebugInformation>false</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
@ -354,20 +354,20 @@
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<PreprocessorDefinitions>_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>_RUFUS;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;COBJMACROS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<WarningLevel>Level3</WarningLevel>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\src;..\src\msvc-missing;..\src\ms-sys\inc;..\src\syslinux\libinstaller;..\src\syslinux\libfat;..\src\syslinux\win;..\src\libcdio;..\src\getopt;..\src\wimlib;..\res;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<CompileAs>CompileAsC</CompileAs>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<ExceptionHandling>Async</ExceptionHandling>
<DisableSpecificWarnings>4091;5255;28251;28252;28253;%(DisableSpecificWarnings)</DisableSpecificWarnings>
<UndefinePreprocessorDefinitions>NDEBUG</UndefinePreprocessorDefinitions>
<AdditionalOptions>/utf-8 $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<AdditionalOptions>/utf-8 /std:clatest $(ExternalCompilerOptions) %(AdditionalOptions)</AdditionalOptions>
<StringPooling>true</StringPooling>
</ClCompile>
<Link>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>advapi32.lib;comctl32.lib;crypt32.lib;gdi32.lib;ole32.lib;dwmapi.lib;setupapi.lib;shell32.lib;ntdll.lib;shlwapi.lib;version.lib;virtdisk.lib;wininet.lib;wintrust.lib;%(AdditionalDependencies)</AdditionalDependencies>
<UACExecutionLevel>RequireAdministrator</UACExecutionLevel>
<GenerateDebugInformation>false</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
@ -413,6 +413,7 @@
<ClCompile Include="..\src\xml.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\res\dbx\dbx_info.h" />
<ClInclude Include="..\res\grub2\grub2_version.h" />
<ClInclude Include="..\res\grub\grub_version.h" />
<ClInclude Include="..\src\badblocks.h" />
@ -491,6 +492,9 @@
<ProjectReference Include="ext2fs.vcxproj">
<Project>{b01f5886-2b39-4b66-b65c-6427135b6a02}</Project>
</ProjectReference>
<ProjectReference Include="wimlib.vcxproj">
<Project>{633cfc82-e01b-4777-bde4-dc0739804332}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">

3
.vs/rufus.vcxproj.filters
View file

@ -197,6 +197,9 @@
<ClInclude Include="..\src\efi.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\res\dbx\dbx_info.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\msvc-missing\unistd.h">
<Filter>Header Files</Filter>
</ClInclude>

416
.vs/wimlib.vcxproj Normal file
View file

@ -0,0 +1,416 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|ARM">
<Configuration>Debug</Configuration>
<Platform>ARM</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|ARM64">
<Configuration>Debug</Configuration>
<Platform>ARM64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|ARM">
<Configuration>Release</Configuration>
<Platform>ARM</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|ARM64">
<Configuration>Release</Configuration>
<Platform>ARM64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\src\wimlib\avl_tree.c" />
<ClCompile Include="..\src\wimlib\blob_table.c" />
<ClCompile Include="..\src\wimlib\compress.c" />
<ClCompile Include="..\src\wimlib\compress_common.c" />
<ClCompile Include="..\src\wimlib\compress_parallel.c" />
<ClCompile Include="..\src\wimlib\compress_serial.c" />
<ClCompile Include="..\src\wimlib\cpu_features.c" />
<ClCompile Include="..\src\wimlib\decompress.c" />
<ClCompile Include="..\src\wimlib\decompress_common.c" />
<ClCompile Include="..\src\wimlib\dentry.c" />
<ClCompile Include="..\src\wimlib\divsufsort.c" />
<ClCompile Include="..\src\wimlib\encoding.c" />
<ClCompile Include="..\src\wimlib\error.c" />
<ClCompile Include="..\src\wimlib\export_image.c" />
<ClCompile Include="..\src\wimlib\extract.c" />
<ClCompile Include="..\src\wimlib\file_io.c" />
<ClCompile Include="..\src\wimlib\header.c" />
<ClCompile Include="..\src\wimlib\inode.c" />
<ClCompile Include="..\src\wimlib\inode_fixup.c" />
<ClCompile Include="..\src\wimlib\inode_table.c" />
<ClCompile Include="..\src\wimlib\integrity.c" />
<ClCompile Include="..\src\wimlib\iterate_dir.c" />
<ClCompile Include="..\src\wimlib\lcpit_matchfinder.c" />
<ClCompile Include="..\src\wimlib\lzms_common.c" />
<ClCompile Include="..\src\wimlib\lzms_compress.c" />
<ClCompile Include="..\src\wimlib\lzms_decompress.c" />
<ClCompile Include="..\src\wimlib\lzx_common.c" />
<ClCompile Include="..\src\wimlib\lzx_compress.c" />
<ClCompile Include="..\src\wimlib\lzx_decompress.c" />
<ClCompile Include="..\src\wimlib\metadata_resource.c" />
<ClCompile Include="..\src\wimlib\pathlist.c" />
<ClCompile Include="..\src\wimlib\paths.c" />
<ClCompile Include="..\src\wimlib\pattern.c" />
<ClCompile Include="..\src\wimlib\progress.c" />
<ClCompile Include="..\src\wimlib\registry.c" />
<ClCompile Include="..\src\wimlib\reparse.c" />
<ClCompile Include="..\src\wimlib\resource.c" />
<ClCompile Include="..\src\wimlib\scan.c" />
<ClCompile Include="..\src\wimlib\security.c" />
<ClCompile Include="..\src\wimlib\sha1.c" />
<ClCompile Include="..\src\wimlib\solid.c" />
<ClCompile Include="..\src\wimlib\split.c" />
<ClCompile Include="..\src\wimlib\tagged_items.c" />
<ClCompile Include="..\src\wimlib\textfile.c" />
<ClCompile Include="..\src\wimlib\threads.c" />
<ClCompile Include="..\src\wimlib\timestamp.c" />
<ClCompile Include="..\src\wimlib\update_image.c" />
<ClCompile Include="..\src\wimlib\util.c" />
<ClCompile Include="..\src\wimlib\wim.c" />
<ClCompile Include="..\src\wimlib\wimboot.c" />
<ClCompile Include="..\src\wimlib\win32_apply.c" />
<ClCompile Include="..\src\wimlib\win32_capture.c" />
<ClCompile Include="..\src\wimlib\win32_common.c" />
<ClCompile Include="..\src\wimlib\win32_replacements.c" />
<ClCompile Include="..\src\wimlib\win32_vss.c" />
<ClCompile Include="..\src\wimlib\write.c" />
<ClCompile Include="..\src\wimlib\xml.c" />
<ClCompile Include="..\src\wimlib\xmlproc.c" />
<ClCompile Include="..\src\wimlib\xml_windows.c" />
<ClCompile Include="..\src\wimlib\xpress_compress.c" />
<ClCompile Include="..\src\wimlib\xpress_decompress.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\src\wimlib\config.h" />
<ClInclude Include="..\src\wimlib\wimlib.h" />
<ClInclude Include="..\src\wimlib\wimlib\alloca.h" />
<ClInclude Include="..\src\wimlib\wimlib\apply.h" />
<ClInclude Include="..\src\wimlib\wimlib\assert.h" />
<ClInclude Include="..\src\wimlib\wimlib\avl_tree.h" />
<ClInclude Include="..\src\wimlib\wimlib\bitops.h" />
<ClInclude Include="..\src\wimlib\wimlib\blob_table.h" />
<ClInclude Include="..\src\wimlib\wimlib\bt_matchfinder.h" />
<ClInclude Include="..\src\wimlib\wimlib\case.h" />
<ClInclude Include="..\src\wimlib\wimlib\chunk_compressor.h" />
<ClInclude Include="..\src\wimlib\wimlib\compiler.h" />
<ClInclude Include="..\src\wimlib\wimlib\compressor_ops.h" />
<ClInclude Include="..\src\wimlib\wimlib\compress_common.h" />
<ClInclude Include="..\src\wimlib\wimlib\cpu_features.h" />
<ClInclude Include="..\src\wimlib\wimlib\decompressor_ops.h" />
<ClInclude Include="..\src\wimlib\wimlib\decompress_common.h" />
<ClInclude Include="..\src\wimlib\wimlib\dentry.h" />
<ClInclude Include="..\src\wimlib\wimlib\divsufsort.h" />
<ClInclude Include="..\src\wimlib\wimlib\encoding.h" />
<ClInclude Include="..\src\wimlib\wimlib\endianness.h" />
<ClInclude Include="..\src\wimlib\wimlib\error.h" />
<ClInclude Include="..\src\wimlib\wimlib\file_io.h" />
<ClInclude Include="..\src\wimlib\wimlib\glob.h" />
<ClInclude Include="..\src\wimlib\wimlib\guid.h" />
<ClInclude Include="..\src\wimlib\wimlib\hc_matchfinder.h" />
<ClInclude Include="..\src\wimlib\wimlib\header.h" />
<ClInclude Include="..\src\wimlib\wimlib\inode.h" />
<ClInclude Include="..\src\wimlib\wimlib\inode_table.h" />
<ClInclude Include="..\src\wimlib\wimlib\integrity.h" />
<ClInclude Include="..\src\wimlib\wimlib\lcpit_matchfinder.h" />
<ClInclude Include="..\src\wimlib\wimlib\list.h" />
<ClInclude Include="..\src\wimlib\wimlib\lzms_common.h" />
<ClInclude Include="..\src\wimlib\wimlib\lzms_constants.h" />
<ClInclude Include="..\src\wimlib\wimlib\lzx_common.h" />
<ClInclude Include="..\src\wimlib\wimlib\lzx_constants.h" />
<ClInclude Include="..\src\wimlib\wimlib\matchfinder_common.h" />
<ClInclude Include="..\src\wimlib\wimlib\metadata.h" />
<ClInclude Include="..\src\wimlib\wimlib\ntfs_3g.h" />
<ClInclude Include="..\src\wimlib\wimlib\object_id.h" />
<ClInclude Include="..\src\wimlib\wimlib\pathlist.h" />
<ClInclude Include="..\src\wimlib\wimlib\paths.h" />
<ClInclude Include="..\src\wimlib\wimlib\pattern.h" />
<ClInclude Include="..\src\wimlib\wimlib\progress.h" />
<ClInclude Include="..\src\wimlib\wimlib\registry.h" />
<ClInclude Include="..\src\wimlib\wimlib\reparse.h" />
<ClInclude Include="..\src\wimlib\wimlib\resource.h" />
<ClInclude Include="..\src\wimlib\wimlib\scan.h" />
<ClInclude Include="..\src\wimlib\wimlib\security.h" />
<ClInclude Include="..\src\wimlib\wimlib\security_descriptor.h" />
<ClInclude Include="..\src\wimlib\wimlib\sha1.h" />
<ClInclude Include="..\src\wimlib\wimlib\solid.h" />
<ClInclude Include="..\src\wimlib\wimlib\tagged_items.h" />
<ClInclude Include="..\src\wimlib\wimlib\test_support.h" />
<ClInclude Include="..\src\wimlib\wimlib\textfile.h" />
<ClInclude Include="..\src\wimlib\wimlib\threads.h" />
<ClInclude Include="..\src\wimlib\wimlib\timestamp.h" />
<ClInclude Include="..\src\wimlib\wimlib\types.h" />
<ClInclude Include="..\src\wimlib\wimlib\unaligned.h" />
<ClInclude Include="..\src\wimlib\wimlib\unix_data.h" />
<ClInclude Include="..\src\wimlib\wimlib\util.h" />
<ClInclude Include="..\src\wimlib\wimlib\wim.h" />
<ClInclude Include="..\src\wimlib\wimlib\wimboot.h" />
<ClInclude Include="..\src\wimlib\wimlib\win32.h" />
<ClInclude Include="..\src\wimlib\wimlib\win32_common.h" />
<ClInclude Include="..\src\wimlib\wimlib\win32_vss.h" />
<ClInclude Include="..\src\wimlib\wimlib\wof.h" />
<ClInclude Include="..\src\wimlib\wimlib\write.h" />
<ClInclude Include="..\src\wimlib\wimlib\xattr.h" />
<ClInclude Include="..\src\wimlib\wimlib\xml.h" />
<ClInclude Include="..\src\wimlib\wimlib\xmlproc.h" />
<ClInclude Include="..\src\wimlib\wimlib\xml_windows.h" />
<ClInclude Include="..\src\wimlib\wimlib\xpress_constants.h" />
<ClInclude Include="..\src\wimlib\wimlib_tchar.h" />
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{633CFC82-E01B-4777-BDE4-DC0739804332}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>wimlib</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
<WindowsSDKDesktopARMSupport>true</WindowsSDKDesktopARMSupport>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
<WindowsSDKDesktopARM64Support>true</WindowsSDKDesktopARM64Support>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
<WindowsSDKDesktopARMSupport>true</WindowsSDKDesktopARMSupport>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
<WindowsSDKDesktopARM64Support>true</WindowsSDKDesktopARM64Support>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<PropertyGroup>
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">$(SolutionDir)arm\$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">$(SolutionDir)arm\$(Configuration)\$(ProjectName)\</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">$(SolutionDir)arm\$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">$(SolutionDir)arm\$(Configuration)\$(ProjectName)\</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">$(SolutionDir)arm64\$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">$(SolutionDir)arm64\$(Configuration)\$(ProjectName)\</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">$(SolutionDir)arm64\$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">$(SolutionDir)arm64\$(Configuration)\$(ProjectName)\</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)x86\$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)x86\$(Configuration)\$(ProjectName)\</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)x86\$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)x86\$(Configuration)\$(ProjectName)\</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)x64\$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)x64\$(Configuration)\$(ProjectName)\</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)x64\$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)x64\$(Configuration)\$(ProjectName)\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">false</LinkIncremental>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">false</LinkIncremental>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">false</LinkIncremental>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">false</LinkIncremental>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</LinkIncremental>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</LinkIncremental>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\src;..\src\wimlib;..\src\msvc-missing;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<DisableSpecificWarnings>4018;4146;4267;4244;4334;4789;4996;6201;6239;6246;6255;6262;6297;6326;28252;28253</DisableSpecificWarnings>
<CompileAs>CompileAsC</CompileAs>
<AdditionalOptions>/std:clatest</AdditionalOptions>
<PreprocessorDefinitions>_RUFUS;HAVE_CONFIG_H;UNICODE;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;_FILE_OFFSET_BITS=64;__SSE2__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
<Lib>
<TargetMachine>MachineX86</TargetMachine>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\src;..\src\wimlib;..\src\msvc-missing;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<AdditionalOptions>/std:clatest</AdditionalOptions>
<DisableSpecificWarnings>4018;4146;4267;4244;4334;4789;4996;6201;6239;6246;6255;6262;6297;6326;28252;28253</DisableSpecificWarnings>
<PreprocessorDefinitions>_RUFUS;HAVE_CONFIG_H;UNICODE;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;_FILE_OFFSET_BITS=64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
<Lib />
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\src;..\src\wimlib;..\src\msvc-missing;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<AdditionalOptions>/std:clatest</AdditionalOptions>
<DisableSpecificWarnings>4018;4146;4267;4244;4334;4789;4996;6201;6239;6246;6255;6262;6297;6326;28252;28253</DisableSpecificWarnings>
<PreprocessorDefinitions>_RUFUS;HAVE_CONFIG_H;UNICODE;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;_FILE_OFFSET_BITS=64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
<Lib />
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<AdditionalIncludeDirectories>..\src;..\src\wimlib;..\src\msvc-missing;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<DisableSpecificWarnings>4018;4146;4267;4244;4334;4789;4996;6201;6239;6246;6255;6262;6297;6326;28252;28253</DisableSpecificWarnings>
<CompileAs>CompileAsC</CompileAs>
<AdditionalOptions>/std:clatest</AdditionalOptions>
<StringPooling>true</StringPooling>
<PreprocessorDefinitions>_RUFUS;HAVE_CONFIG_H;UNICODE;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;_FILE_OFFSET_BITS=64;__SSE2__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Lib>
<TargetMachine>MachineX86</TargetMachine>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>..\src;..\src\wimlib;..\src\msvc-missing;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<AdditionalOptions>/std:clatest</AdditionalOptions>
<DisableSpecificWarnings>4018;4146;4267;4244;4334;4789;4996;6201;6239;6246;6255;6262;6297;6326;28252;28253</DisableSpecificWarnings>
<StringPooling>true</StringPooling>
<PreprocessorDefinitions>_RUFUS;HAVE_CONFIG_H;UNICODE;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;_FILE_OFFSET_BITS=64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Lib />
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>..\src;..\src\wimlib;..\src\msvc-missing;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<AdditionalOptions>/std:clatest</AdditionalOptions>
<DisableSpecificWarnings>4018;4146;4267;4244;4334;4789;4996;6201;6239;6246;6255;6262;6297;6326;28252;28253</DisableSpecificWarnings>
<StringPooling>true</StringPooling>
<PreprocessorDefinitions>_RUFUS;HAVE_CONFIG_H;UNICODE;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;_FILE_OFFSET_BITS=64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Lib />
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\src;..\src\wimlib;..\src\msvc-missing;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<DisableSpecificWarnings>4018;4146;4267;4244;4334;4789;4996;6201;6239;6246;6255;6262;6297;6326;28252;28253</DisableSpecificWarnings>
<CompileAs>CompileAsC</CompileAs>
<AdditionalOptions>/std:clatest</AdditionalOptions>
<PreprocessorDefinitions>_RUFUS;HAVE_CONFIG_H;UNICODE;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;_FILE_OFFSET_BITS=64;__SSE2__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
<Lib>
<TargetMachine>MachineX64</TargetMachine>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<AdditionalIncludeDirectories>..\src;..\src\wimlib;..\src\msvc-missing;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<DisableSpecificWarnings>4018;4146;4267;4244;4334;4789;4996;6201;6239;6246;6255;6262;6297;6326;28252;28253</DisableSpecificWarnings>
<CompileAs>CompileAsC</CompileAs>
<AdditionalOptions>/std:clatest</AdditionalOptions>
<StringPooling>true</StringPooling>
<PreprocessorDefinitions>_RUFUS;HAVE_CONFIG_H;UNICODE;_OFF_T_DEFINED;_off_t=__int64;off_t=_off_t;_FILE_OFFSET_BITS=64;__SSE2__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
<Lib>
<TargetMachine>MachineX64</TargetMachine>
</Lib>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

422
.vs/wimlib.vcxproj.filters Normal file
View file

@ -0,0 +1,422 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\src\wimlib\wim.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\extract.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\xml.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\xmlproc.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\util.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\error.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\win32_replacements.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\win32_common.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\blob_table.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\encoding.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\cpu_features.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\threads.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\win32_apply.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\win32_vss.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\header.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\metadata_resource.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\resource.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\security.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\decompress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\decompress_common.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\sha1.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\xpress_decompress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\write.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\file_io.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\progress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\integrity.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\dentry.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\export_image.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\inode.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\iterate_dir.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\avl_tree.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\win32_capture.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\timestamp.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\pathlist.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\paths.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\scan.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\lzms_common.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\lzms_decompress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\lzx_common.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\lzx_decompress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\solid.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\reparse.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\compress_parallel.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\compress_serial.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\compress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\xpress_compress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\lzms_compress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\lzx_compress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\compress_common.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\pattern.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\lcpit_matchfinder.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\textfile.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\divsufsort.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\inode_table.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\inode_fixup.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\tagged_items.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\wimboot.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\update_image.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\xml_windows.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\registry.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\wimlib\split.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\src\wimlib\config.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\assert.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\blob_table.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\cpu_features.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\dentry.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\encoding.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\file_io.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\integrity.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\metadata.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\security.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\threads.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\wim.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\win32.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\xml.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\list.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\resource.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\sha1.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\types.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\util.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib_tchar.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\compiler.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\avl_tree.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\case.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\inode.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\error.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\guid.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\header.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\apply.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\progress.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\endianness.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\object_id.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\pathlist.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\paths.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\pattern.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\reparse.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\tagged_items.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\unix_data.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\xattr.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\timestamp.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\write.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\xmlproc.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\test_support.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\glob.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\win32_common.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\win32_vss.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\bitops.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\ntfs_3g.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\scan.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\unaligned.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\inode_table.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\textfile.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\wimboot.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\wof.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\alloca.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\decompress_common.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\decompressor_ops.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\xpress_constants.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\chunk_compressor.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\solid.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\lzms_common.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\lzms_constants.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\lzx_common.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\lzx_constants.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\compress_common.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\compressor_ops.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\hc_matchfinder.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\matchfinder_common.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\bt_matchfinder.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\lcpit_matchfinder.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\divsufsort.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\xml_windows.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\registry.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\src\wimlib\wimlib\security_descriptor.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>

3
configure vendored
View file

@ -4758,6 +4758,8 @@ ac_config_files="$ac_config_files src/syslinux/libinstaller/Makefile"
ac_config_files="$ac_config_files src/syslinux/win/Makefile"
ac_config_files="$ac_config_files src/wimlib/Makefile"
cat >confcache <<\_ACEOF
# This file is a shell script that caches the results of configure
# tests run on this system so they can be shared between configure
@ -5491,6 +5493,7 @@ do
"src/syslinux/libfat/Makefile") CONFIG_FILES="$CONFIG_FILES src/syslinux/libfat/Makefile" ;;
"src/syslinux/libinstaller/Makefile") CONFIG_FILES="$CONFIG_FILES src/syslinux/libinstaller/Makefile" ;;
"src/syslinux/win/Makefile") CONFIG_FILES="$CONFIG_FILES src/syslinux/win/Makefile" ;;
"src/wimlib/Makefile") CONFIG_FILES="$CONFIG_FILES src/wimlib/Makefile" ;;
*) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
esac

1
configure.ac
View file

@ -84,4 +84,5 @@ AC_CONFIG_FILES([src/ms-sys/Makefile])
AC_CONFIG_FILES([src/syslinux/libfat/Makefile])
AC_CONFIG_FILES([src/syslinux/libinstaller/Makefile])
AC_CONFIG_FILES([src/syslinux/win/Makefile])
AC_CONFIG_FILES([src/wimlib/Makefile])
AC_OUTPUT

27
rufus.sln
View file

@ -1,8 +1,11 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.29215.179
# Visual Studio Version 17
VisualStudioVersion = 17.8.34330.188
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rufus", ".vs\rufus.vcxproj", "{731858A7-0303-4988-877B-9C0DD6471864}"
ProjectSection(ProjectDependencies) = postProject
{633CFC82-E01B-4777-BDE4-DC0739804332} = {633CFC82-E01B-4777-BDE4-DC0739804332}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ms-sys", ".vs\ms-sys.vcxproj", "{2B1D078D-8EB4-4398-9CA4-23457265A7F6}"
EndProject
@ -24,8 +27,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bled", ".vs\bled.vcxproj",
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ext2fs", ".vs\ext2fs.vcxproj", "{B01F5886-2B39-4B66-B65C-6427135B6A02}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "wimlib", ".vs\wimlib.vcxproj", "{633CFC82-E01B-4777-BDE4-DC0739804332}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|arm = Debug|arm
@ -214,6 +217,22 @@ Global
{B01F5886-2B39-4B66-B65C-6427135B6A02}.Release|x64.Build.0 = Release|x64
{B01F5886-2B39-4B66-B65C-6427135B6A02}.Release|x86.ActiveCfg = Release|Win32
{B01F5886-2B39-4B66-B65C-6427135B6A02}.Release|x86.Build.0 = Release|Win32
{633CFC82-E01B-4777-BDE4-DC0739804332}.Debug|arm.ActiveCfg = Debug|ARM
{633CFC82-E01B-4777-BDE4-DC0739804332}.Debug|arm.Build.0 = Debug|ARM
{633CFC82-E01B-4777-BDE4-DC0739804332}.Debug|arm64.ActiveCfg = Debug|ARM64
{633CFC82-E01B-4777-BDE4-DC0739804332}.Debug|arm64.Build.0 = Debug|ARM64
{633CFC82-E01B-4777-BDE4-DC0739804332}.Debug|x64.ActiveCfg = Debug|x64
{633CFC82-E01B-4777-BDE4-DC0739804332}.Debug|x64.Build.0 = Debug|x64
{633CFC82-E01B-4777-BDE4-DC0739804332}.Debug|x86.ActiveCfg = Debug|Win32
{633CFC82-E01B-4777-BDE4-DC0739804332}.Debug|x86.Build.0 = Debug|Win32
{633CFC82-E01B-4777-BDE4-DC0739804332}.Release|arm.ActiveCfg = Release|ARM
{633CFC82-E01B-4777-BDE4-DC0739804332}.Release|arm.Build.0 = Release|ARM
{633CFC82-E01B-4777-BDE4-DC0739804332}.Release|arm64.ActiveCfg = Release|ARM64
{633CFC82-E01B-4777-BDE4-DC0739804332}.Release|arm64.Build.0 = Release|ARM64
{633CFC82-E01B-4777-BDE4-DC0739804332}.Release|x64.ActiveCfg = Release|x64
{633CFC82-E01B-4777-BDE4-DC0739804332}.Release|x64.Build.0 = Release|x64
{633CFC82-E01B-4777-BDE4-DC0739804332}.Release|x86.ActiveCfg = Release|Win32
{633CFC82-E01B-4777-BDE4-DC0739804332}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

8
src/Makefile.am
View file

@ -1,6 +1,6 @@
SUBDIRS = ../.mingw bled ext2fs ms-sys syslinux/libfat syslinux/libinstaller syslinux/win libcdio/iso9660 libcdio/udf libcdio/driver ../res/loc
SUBDIRS = ../.mingw bled ext2fs ms-sys syslinux/libfat syslinux/libinstaller syslinux/win libcdio/iso9660 libcdio/udf libcdio/driver wimlib ../res/loc
# As far as I can tell, the following libraries are *not* vulnerable to side-loading, so we link using their regular version:
NONVULNERABLE_LIBS = -lsetupapi -lole32 -lgdi32 -lshlwapi -lcrypt32 -lcomctl32 -luuid
NONVULNERABLE_LIBS = -lsetupapi -lole32 -lgdi32 -lshlwapi -lcrypt32 -lcomctl32 -luuid -lntdll
# The following libraries are vulnerable (or have an unknown vulnerability status), so we link using our delay-loaded replacement:
# See https://github.com/pbatard/rufus/issues/2272
# Oh, and don't bother trying to delay load cfgmgr32.dll, even with the DECLSPEC_IMPORT __attribute__((visibility("hidden")))
@ -19,8 +19,8 @@ AM_V_WINDRES = $(AM_V_WINDRES_$(V))
rufus_SOURCES = badblocks.c dev.c dos.c dos_locale.c drive.c format.c format_ext.c format_fat32.c hash.c icon.c iso.c \
localization.c net.c parser.c pki.c process.c re.c rufus.c smart.c stdfn.c stdio.c stdlg.c syslinux.c ui.c vhd.c wue.c xml.c
rufus_CFLAGS = -I$(srcdir)/ms-sys/inc -I$(srcdir)/syslinux/libfat -I$(srcdir)/syslinux/libinstaller -I$(srcdir)/syslinux/win -I$(srcdir)/libcdio -I$(srcdir)/../res $(AM_CFLAGS) \
rufus_CFLAGS = -I$(srcdir)/ms-sys/inc -I$(srcdir)/syslinux/libfat -I$(srcdir)/syslinux/libinstaller -I$(srcdir)/syslinux/win -I$(srcdir)/libcdio -I$(srcdir)/wimlib -I$(srcdir)/../res $(AM_CFLAGS) \
-DEXT2_FLAT_INCLUDES=0 -DSOLUTION=rufus
rufus_LDFLAGS = $(AM_LDFLAGS) -mwindows -L $(srcdir)/../.mingw
rufus_LDADD = rufus_rc.o bled/libbled.a ext2fs/libext2fs.a ms-sys/libmssys.a syslinux/libfat/libfat.a syslinux/libinstaller/libinstaller.a syslinux/win/libwin.a \
libcdio/iso9660/libiso9660.a libcdio/udf/libudf.a libcdio/driver/libdriver.a $(NONVULNERABLE_LIBS) $(VULNERABLE_LIBS)
libcdio/iso9660/libiso9660.a libcdio/udf/libudf.a libcdio/driver/libdriver.a wimlib/libwim.a $(NONVULNERABLE_LIBS) $(VULNERABLE_LIBS)

12
src/Makefile.in
View file

@ -106,8 +106,8 @@ rufus_DEPENDENCIES = rufus_rc.o bled/libbled.a ext2fs/libext2fs.a \
ms-sys/libmssys.a syslinux/libfat/libfat.a \
syslinux/libinstaller/libinstaller.a syslinux/win/libwin.a \
libcdio/iso9660/libiso9660.a libcdio/udf/libudf.a \
libcdio/driver/libdriver.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1)
libcdio/driver/libdriver.a wimlib/libwim.a \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
rufus_LINK = $(CCLD) $(rufus_CFLAGS) $(CFLAGS) $(rufus_LDFLAGS) \
$(LDFLAGS) -o $@
AM_V_P = $(am__v_P_@AM_V@)
@ -273,9 +273,9 @@ target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
SUBDIRS = ../.mingw bled ext2fs ms-sys syslinux/libfat syslinux/libinstaller syslinux/win libcdio/iso9660 libcdio/udf libcdio/driver ../res/loc
SUBDIRS = ../.mingw bled ext2fs ms-sys syslinux/libfat syslinux/libinstaller syslinux/win libcdio/iso9660 libcdio/udf libcdio/driver wimlib ../res/loc
# As far as I can tell, the following libraries are *not* vulnerable to side-loading, so we link using their regular version:
NONVULNERABLE_LIBS = -lsetupapi -lole32 -lgdi32 -lshlwapi -lcrypt32 -lcomctl32 -luuid
NONVULNERABLE_LIBS = -lsetupapi -lole32 -lgdi32 -lshlwapi -lcrypt32 -lcomctl32 -luuid -lntdll
# The following libraries are vulnerable (or have an unknown vulnerability status), so we link using our delay-loaded replacement:
# See https://github.com/pbatard/rufus/issues/2272
# Oh, and don't bother trying to delay load cfgmgr32.dll, even with the DECLSPEC_IMPORT __attribute__((visibility("hidden")))
@ -288,12 +288,12 @@ AM_V_WINDRES = $(AM_V_WINDRES_$(V))
rufus_SOURCES = badblocks.c dev.c dos.c dos_locale.c drive.c format.c format_ext.c format_fat32.c hash.c icon.c iso.c \
localization.c net.c parser.c pki.c process.c re.c rufus.c smart.c stdfn.c stdio.c stdlg.c syslinux.c ui.c vhd.c wue.c xml.c
rufus_CFLAGS = -I$(srcdir)/ms-sys/inc -I$(srcdir)/syslinux/libfat -I$(srcdir)/syslinux/libinstaller -I$(srcdir)/syslinux/win -I$(srcdir)/libcdio -I$(srcdir)/../res $(AM_CFLAGS) \
rufus_CFLAGS = -I$(srcdir)/ms-sys/inc -I$(srcdir)/syslinux/libfat -I$(srcdir)/syslinux/libinstaller -I$(srcdir)/syslinux/win -I$(srcdir)/libcdio -I$(srcdir)/wimlib -I$(srcdir)/../res $(AM_CFLAGS) \
-DEXT2_FLAT_INCLUDES=0 -DSOLUTION=rufus
rufus_LDFLAGS = $(AM_LDFLAGS) -mwindows -L $(srcdir)/../.mingw
rufus_LDADD = rufus_rc.o bled/libbled.a ext2fs/libext2fs.a ms-sys/libmssys.a syslinux/libfat/libfat.a syslinux/libinstaller/libinstaller.a syslinux/win/libwin.a \
libcdio/iso9660/libiso9660.a libcdio/udf/libudf.a libcdio/driver/libdriver.a $(NONVULNERABLE_LIBS) $(VULNERABLE_LIBS)
libcdio/iso9660/libiso9660.a libcdio/udf/libudf.a libcdio/driver/libdriver.a wimlib/libwim.a $(NONVULNERABLE_LIBS) $(VULNERABLE_LIBS)
all: all-recursive

2
src/libcdio/config.h
View file

@ -46,7 +46,7 @@
#endif
/* Define to 1 if you have the `ftruncate' function. */
/* #undef HAVE_FTRUNCATE */
#define HAVE_FTRUNCATE 1
/* Define if you have the iconv() function and it works. */
/* #undef HAVE_ICONV */

4
src/license.h
View file

@ -56,6 +56,10 @@ const char* additional_copyrights =
"https://www.gnu.org/software/libcdio\\line\n"
"GNU General Public License (GPL) v3 or later\\line\n"
"\\line\n"
"WIM image manipulation support from wimlib by Carl Thijssen and Eric Biggers:\\line\n"
"https://wimlib.net\\line\n"
"GNU General Public License (GPL) v3 or later\\line\n"
"\\line\n"
"Syslinux support from Syslinux by H. Peter Anvin et al.:\\line\n"
"https://syslinux.org/\\line\n"
"GNU General Public License (GPL) v2 or later\\line\n"

35
src/msvc-missing/unistd.h
View file

@ -24,11 +24,10 @@ typedef unsigned short mode_t;
#ifndef _SSIZE_T_DEFINED
#define _SSIZE_T_DEFINED
#undef ssize_t
#ifdef _WIN64
typedef __int64 ssize_t;
#else
typedef int ssize_t;
#endif /* _WIN64 */
/* From https://awesomekling.github.io/How-SerenityOS-declares-ssize_t/ */
#define unsigned signed
typedef size_t ssize_t;
#undef unsigned
#endif /* _SSIZE_T_DEFINED */
/* ext2fs needs this, which we picked from libcdio-driver/filemode.h */
@ -39,4 +38,30 @@ typedef int ssize_t;
# define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
#endif
/* access() mode flags */
#ifndef R_OK
#define R_OK 4
#endif
#ifndef W_OK
#define W_OK 2
#endif
#ifndef F_OK
#define F_OK 0
#endif
#endif
/* Standard file descriptors. */
#ifndef STDIN_FILENO
#define STDIN_FILENO 0
#endif
#ifndef STDOUT_FILENO
#define STDOUT_FILENO 1
#endif
#ifndef STDERR_FILENO
#define STDERR_FILENO 2
#endif
/* For wimlib */
#define ftruncate _chsize_s
#define snwprintf(dst, count, ...) _snwprintf_s(dst, count, _TRUNCATE, __VA_ARGS__)
#define vsnwprintf _vsnwprintf

12
src/rufus.c
View file

@ -3825,10 +3825,20 @@ relaunch:
}
#if defined(_DEBUG) || defined(TEST) || defined(ALPHA)
extern int TestHashes(void);
#include "wimlib.h"
// Ctrl-T => Alternate Test mode that doesn't require a full rebuild
if ((ctrl_without_focus || ((GetKeyState(VK_CONTROL) & 0x8000) && (msg.message == WM_KEYDOWN)))
&& (msg.wParam == 'T')) {
TestHashes();
int r;
WIMStruct* wim;
r = wimlib_open_wim(L"C:\\tmp\\boot.wim", WIMLIB_OPEN_FLAG_CHECK_INTEGRITY, &wim);
if (r == 0) {
wimlib_print_header(wim);
wimlib_free(wim);
} else {
uprintf("Failed to open WIM: %d", r);
}
// TestHashes();
continue;
}
#endif

1
src/rufus.h
View file

@ -200,6 +200,7 @@ static __inline void static_repchr(char* p, char s, char r) {
extern void uprintf(const char *format, ...);
extern void uprintfs(const char *str);
extern void wuprintf(const wchar_t* format, ...);
#define vuprintf(...) do { if (verbose) uprintf(__VA_ARGS__); } while(0)
#define vvuprintf(...) do { if (verbose > 1) uprintf(__VA_ARGS__); } while(0)
#define suprintf(...) do { if (!bSilent) uprintf(__VA_ARGS__); } while(0)

10
src/rufus.rc
View file

@ -33,7 +33,7 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
IDD_DIALOG DIALOGEX 12, 12, 232, 326
STYLE DS_SETFONT | DS_MODALFRAME | DS_CENTER | WS_MINIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU
EXSTYLE WS_EX_ACCEPTFILES
CAPTION "Rufus 4.8.2235"
CAPTION "Rufus 4.8.2236"
FONT 9, "Segoe UI Symbol", 400, 0, 0x0
BEGIN
LTEXT "Drive Properties",IDS_DRIVE_PROPERTIES_TXT,8,6,53,12,NOT WS_GROUP
@ -407,8 +407,8 @@ END
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION 4,8,2235,0
PRODUCTVERSION 4,8,2235,0
FILEVERSION 4,8,2236,0
PRODUCTVERSION 4,8,2236,0
FILEFLAGSMASK 0x3fL
#ifdef _DEBUG
FILEFLAGS 0x1L
@ -426,13 +426,13 @@ BEGIN
VALUE "Comments", "https://rufus.ie"
VALUE "CompanyName", "Akeo Consulting"
VALUE "FileDescription", "Rufus"
VALUE "FileVersion", "4.8.2235"
VALUE "FileVersion", "4.8.2236"
VALUE "InternalName", "Rufus"
VALUE "LegalCopyright", "© 2011-2025 Pete Batard (GPL v3)"
VALUE "LegalTrademarks", "https://www.gnu.org/licenses/gpl-3.0.html"
VALUE "OriginalFilename", "rufus-4.8.exe"
VALUE "ProductName", "Rufus"
VALUE "ProductVersion", "4.8.2235"
VALUE "ProductVersion", "4.8.2236"
END
END
BLOCK "VarFileInfo"

28
src/stdio.c
View file

@ -99,6 +99,34 @@ void uprintf(const char *format, ...)
free(wbuf);
}
void wuprintf(const wchar_t* format, ...)
{
static wchar_t wbuf[4096];
wchar_t* p = wbuf;
va_list args;
int n;
va_start(args, format);
n = _vsnwprintf_s(p, ARRAYSIZE(wbuf) - 3, _TRUNCATE, format, args);
va_end(args);
p += (n < 0) ? ARRAYSIZE(wbuf) - 3 : n;
if (n >= 1 && p[-1] == L'\n') {
p[-1] = L'\r';
*p++ = L'\n';
*p = L'\0';
}
// coverity[dont_call]
OutputDebugStringW(wbuf);
if ((hLog != NULL) && (hLog != INVALID_HANDLE_VALUE)) {
Edit_SetSel(hLog, MAX_LOG_SIZE, MAX_LOG_SIZE);
Edit_ReplaceSel(hLog, wbuf);
Edit_Scroll(hLog, Edit_GetLineCount(hLog), 0);
}
}
void uprintfs(const char* str)
{
wchar_t* wstr;

11
src/wimlib/Makefile.am Normal file
View file

@ -0,0 +1,11 @@
noinst_LIBRARIES = libwim.a
libwim_a_SOURCES = avl_tree.c blob_table.c compress.c compress_common.c compress_parallel.c \
compress_serial.c cpu_features.c decompress.c decompress_common.c dentry.c divsufsort.c \
encoding.c error.c export_image.c extract.c file_io.c header.c inode.c inode_fixup.c \
inode_table.c integrity.c iterate_dir.c lcpit_matchfinder.c lzms_common.c lzms_compress.c \
lzms_decompress.c lzx_common.c lzx_compress.c lzx_decompress.c metadata_resource.c \
pathlist.c paths.c pattern.c progress.c registry.c reparse.c resource.c scan.c security.c \
sha1.c solid.c split.c tagged_items.c textfile.c threads.c timestamp.c update_image.c \
util.c wim.c wimboot.c win32_apply.c win32_capture.c win32_common.c win32_replacements.c \
win32_vss.c write.c xml.c xmlproc.c xml_windows.c xpress_compress.c xpress_decompress.c
libwim_a_CFLAGS = $(AM_CFLAGS) -I$(srcdir)/.. -DHAVE_CONFIG_H -D_RUFUS -D__SSE2__ -D_POSIX -D_POSIX_THREAD_SAFE_FUNCTIONS -DUNICODE -D_UNICODE -D__MINGW_USE_VC2005_COMPAT -Wno-undef -Wno-strict-aliasing -Wno-shadow -Wno-incompatible-pointer-types -Wno-sequence-point

886
src/wimlib/Makefile.in Normal file
View file

@ -0,0 +1,886 @@
# Makefile.in generated by automake 1.14.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994-2013 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
am__make_running_with_option = \
case $${target_option-} in \
?) ;; \
*) echo "am__make_running_with_option: internal error: invalid" \
"target option '$${target_option-}' specified" >&2; \
exit 1;; \
esac; \
has_opt=no; \
sane_makeflags=$$MAKEFLAGS; \
if $(am__is_gnu_make); then \
sane_makeflags=$$MFLAGS; \
else \
case $$MAKEFLAGS in \
*\\[\ \ ]*) \
bs=\\; \
sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
esac; \
fi; \
skip_next=no; \
strip_trailopt () \
{ \
flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
}; \
for flg in $$sane_makeflags; do \
test $$skip_next = yes && { skip_next=no; continue; }; \
case $$flg in \
*=*|--*) continue;; \
-*I) strip_trailopt 'I'; skip_next=yes;; \
-*I?*) strip_trailopt 'I';; \
-*O) strip_trailopt 'O'; skip_next=yes;; \
-*O?*) strip_trailopt 'O';; \
-*l) strip_trailopt 'l'; skip_next=yes;; \
-*l?*) strip_trailopt 'l';; \
-[dEDm]) skip_next=yes;; \
-[JT]) skip_next=yes;; \
esac; \
case $$flg in \
*$$target_option*) has_opt=yes; break;; \
esac; \
done; \
test $$has_opt = yes
am__make_dryrun = (target_option=n; $(am__make_running_with_option))
am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
subdir = src/wimlib
DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
LIBRARIES = $(noinst_LIBRARIES)
ARFLAGS = cru
AM_V_AR = $(am__v_AR_@AM_V@)
am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
am__v_AR_0 = @echo " AR " $@;
am__v_AR_1 =
libwim_a_AR = $(AR) $(ARFLAGS)
libwim_a_LIBADD =
am_libwim_a_OBJECTS = libwim_a-avl_tree.$(OBJEXT) \
libwim_a-blob_table.$(OBJEXT) libwim_a-compress.$(OBJEXT) \
libwim_a-compress_common.$(OBJEXT) \
libwim_a-compress_parallel.$(OBJEXT) \
libwim_a-compress_serial.$(OBJEXT) \
libwim_a-cpu_features.$(OBJEXT) libwim_a-decompress.$(OBJEXT) \
libwim_a-decompress_common.$(OBJEXT) libwim_a-dentry.$(OBJEXT) \
libwim_a-divsufsort.$(OBJEXT) libwim_a-encoding.$(OBJEXT) \
libwim_a-error.$(OBJEXT) libwim_a-export_image.$(OBJEXT) \
libwim_a-extract.$(OBJEXT) libwim_a-file_io.$(OBJEXT) \
libwim_a-header.$(OBJEXT) libwim_a-inode.$(OBJEXT) \
libwim_a-inode_fixup.$(OBJEXT) libwim_a-inode_table.$(OBJEXT) \
libwim_a-integrity.$(OBJEXT) libwim_a-iterate_dir.$(OBJEXT) \
libwim_a-lcpit_matchfinder.$(OBJEXT) \
libwim_a-lzms_common.$(OBJEXT) \
libwim_a-lzms_compress.$(OBJEXT) \
libwim_a-lzms_decompress.$(OBJEXT) \
libwim_a-lzx_common.$(OBJEXT) libwim_a-lzx_compress.$(OBJEXT) \
libwim_a-lzx_decompress.$(OBJEXT) \
libwim_a-metadata_resource.$(OBJEXT) \
libwim_a-pathlist.$(OBJEXT) libwim_a-paths.$(OBJEXT) \
libwim_a-pattern.$(OBJEXT) libwim_a-progress.$(OBJEXT) \
libwim_a-registry.$(OBJEXT) libwim_a-reparse.$(OBJEXT) \
libwim_a-resource.$(OBJEXT) libwim_a-scan.$(OBJEXT) \
libwim_a-security.$(OBJEXT) libwim_a-sha1.$(OBJEXT) \
libwim_a-solid.$(OBJEXT) libwim_a-split.$(OBJEXT) \
libwim_a-tagged_items.$(OBJEXT) libwim_a-textfile.$(OBJEXT) \
libwim_a-threads.$(OBJEXT) libwim_a-timestamp.$(OBJEXT) \
libwim_a-update_image.$(OBJEXT) libwim_a-util.$(OBJEXT) \
libwim_a-wim.$(OBJEXT) libwim_a-wimboot.$(OBJEXT) \
libwim_a-win32_apply.$(OBJEXT) \
libwim_a-win32_capture.$(OBJEXT) \
libwim_a-win32_common.$(OBJEXT) \
libwim_a-win32_replacements.$(OBJEXT) \
libwim_a-win32_vss.$(OBJEXT) libwim_a-write.$(OBJEXT) \
libwim_a-xml.$(OBJEXT) libwim_a-xmlproc.$(OBJEXT) \
libwim_a-xml_windows.$(OBJEXT) \
libwim_a-xpress_compress.$(OBJEXT) \
libwim_a-xpress_decompress.$(OBJEXT)
libwim_a_OBJECTS = $(am_libwim_a_OBJECTS)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
am__v_P_0 = false
am__v_P_1 = :
AM_V_GEN = $(am__v_GEN_@AM_V@)
am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
am__v_GEN_0 = @echo " GEN " $@;
am__v_GEN_1 =
AM_V_at = $(am__v_at_@AM_V@)
am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
am__v_at_0 = @
am__v_at_1 =
DEFAULT_INCLUDES = -I.@am__isrc@
depcomp =
am__depfiles_maybe =
AM_V_lt = $(am__v_lt_@AM_V@)
am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
am__v_lt_0 = --silent
am__v_lt_1 =
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
AM_V_CC = $(am__v_CC_@AM_V@)
am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
am__v_CC_0 = @echo " CC " $@;
am__v_CC_1 =
CCLD = $(CC)
LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
AM_V_CCLD = $(am__v_CCLD_@AM_V@)
am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
am__v_CCLD_0 = @echo " CCLD " $@;
am__v_CCLD_1 =
SOURCES = $(libwim_a_SOURCES)
am__can_run_installinfo = \
case $$AM_UPDATE_INFO_DIR in \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
# Read a list of newline-separated strings from the standard input,
# and print each of them once, without duplicates. Input order is
# *not* preserved.
am__uniquify_input = $(AWK) '\
BEGIN { nonempty = 0; } \
{ items[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in items) print i; }; } \
'
# Make sure the list of sources is unique. This is necessary because,
# e.g., the same source file might be shared among _SOURCES variables
# for different programs/libraries.
am__define_uniq_tagged_files = \
list='$(am__tagged_files)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | $(am__uniquify_input)`
ETAGS = etags
CTAGS = ctags
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AM_CFLAGS = @AM_CFLAGS@
AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
AM_LDFLAGS = @AM_LDFLAGS@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CFLAGS = @CFLAGS@
CPPFLAGS = @CPPFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DLLTOOL = @DLLTOOL@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EXEEXT = @EXEEXT@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LTLIBOBJS = @LTLIBOBJS@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
OBJEXT = @OBJEXT@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
RM = @RM@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
SUFFIX = @SUFFIX@
VERSION = @VERSION@
VISIBILITY_CFLAGS = @VISIBILITY_CFLAGS@
WINDRES = @WINDRES@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
am__leading_dot = @am__leading_dot@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build_alias = @build_alias@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host_alias = @host_alias@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
runstatedir = @runstatedir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
noinst_LIBRARIES = libwim.a
libwim_a_SOURCES = avl_tree.c blob_table.c compress.c compress_common.c compress_parallel.c \
compress_serial.c cpu_features.c decompress.c decompress_common.c dentry.c divsufsort.c \
encoding.c error.c export_image.c extract.c file_io.c header.c inode.c inode_fixup.c \
inode_table.c integrity.c iterate_dir.c lcpit_matchfinder.c lzms_common.c lzms_compress.c \
lzms_decompress.c lzx_common.c lzx_compress.c lzx_decompress.c metadata_resource.c \
pathlist.c paths.c pattern.c progress.c registry.c reparse.c resource.c scan.c security.c \
sha1.c solid.c split.c tagged_items.c textfile.c threads.c timestamp.c update_image.c \
util.c wim.c wimboot.c win32_apply.c win32_capture.c win32_common.c win32_replacements.c \
win32_vss.c write.c xml.c xmlproc.c xml_windows.c xpress_compress.c xpress_decompress.c
libwim_a_CFLAGS = $(AM_CFLAGS) -I$(srcdir)/.. -DHAVE_CONFIG_H -D_RUFUS -D__SSE2__ -D_POSIX -D_POSIX_THREAD_SAFE_FUNCTIONS -DUNICODE -D_UNICODE -D__MINGW_USE_VC2005_COMPAT -Wno-undef -Wno-strict-aliasing -Wno-shadow -Wno-incompatible-pointer-types -Wno-sequence-point
all: all-am
.SUFFIXES:
.SUFFIXES: .c .o .obj
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign --ignore-deps src/wimlib/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --foreign --ignore-deps src/wimlib/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
clean-noinstLIBRARIES:
-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
libwim.a: $(libwim_a_OBJECTS) $(libwim_a_DEPENDENCIES) $(EXTRA_libwim_a_DEPENDENCIES)
$(AM_V_at)-rm -f libwim.a
$(AM_V_AR)$(libwim_a_AR) libwim.a $(libwim_a_OBJECTS) $(libwim_a_LIBADD)
$(AM_V_at)$(RANLIB) libwim.a
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
.c.o:
$(AM_V_CC)$(COMPILE) -c -o $@ $<
.c.obj:
$(AM_V_CC)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
libwim_a-avl_tree.o: avl_tree.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-avl_tree.o `test -f 'avl_tree.c' || echo '$(srcdir)/'`avl_tree.c
libwim_a-avl_tree.obj: avl_tree.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-avl_tree.obj `if test -f 'avl_tree.c'; then $(CYGPATH_W) 'avl_tree.c'; else $(CYGPATH_W) '$(srcdir)/avl_tree.c'; fi`
libwim_a-blob_table.o: blob_table.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-blob_table.o `test -f 'blob_table.c' || echo '$(srcdir)/'`blob_table.c
libwim_a-blob_table.obj: blob_table.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-blob_table.obj `if test -f 'blob_table.c'; then $(CYGPATH_W) 'blob_table.c'; else $(CYGPATH_W) '$(srcdir)/blob_table.c'; fi`
libwim_a-compress.o: compress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-compress.o `test -f 'compress.c' || echo '$(srcdir)/'`compress.c
libwim_a-compress.obj: compress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-compress.obj `if test -f 'compress.c'; then $(CYGPATH_W) 'compress.c'; else $(CYGPATH_W) '$(srcdir)/compress.c'; fi`
libwim_a-compress_common.o: compress_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-compress_common.o `test -f 'compress_common.c' || echo '$(srcdir)/'`compress_common.c
libwim_a-compress_common.obj: compress_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-compress_common.obj `if test -f 'compress_common.c'; then $(CYGPATH_W) 'compress_common.c'; else $(CYGPATH_W) '$(srcdir)/compress_common.c'; fi`
libwim_a-compress_parallel.o: compress_parallel.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-compress_parallel.o `test -f 'compress_parallel.c' || echo '$(srcdir)/'`compress_parallel.c
libwim_a-compress_parallel.obj: compress_parallel.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-compress_parallel.obj `if test -f 'compress_parallel.c'; then $(CYGPATH_W) 'compress_parallel.c'; else $(CYGPATH_W) '$(srcdir)/compress_parallel.c'; fi`
libwim_a-compress_serial.o: compress_serial.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-compress_serial.o `test -f 'compress_serial.c' || echo '$(srcdir)/'`compress_serial.c
libwim_a-compress_serial.obj: compress_serial.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-compress_serial.obj `if test -f 'compress_serial.c'; then $(CYGPATH_W) 'compress_serial.c'; else $(CYGPATH_W) '$(srcdir)/compress_serial.c'; fi`
libwim_a-cpu_features.o: cpu_features.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-cpu_features.o `test -f 'cpu_features.c' || echo '$(srcdir)/'`cpu_features.c
libwim_a-cpu_features.obj: cpu_features.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-cpu_features.obj `if test -f 'cpu_features.c'; then $(CYGPATH_W) 'cpu_features.c'; else $(CYGPATH_W) '$(srcdir)/cpu_features.c'; fi`
libwim_a-decompress.o: decompress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-decompress.o `test -f 'decompress.c' || echo '$(srcdir)/'`decompress.c
libwim_a-decompress.obj: decompress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-decompress.obj `if test -f 'decompress.c'; then $(CYGPATH_W) 'decompress.c'; else $(CYGPATH_W) '$(srcdir)/decompress.c'; fi`
libwim_a-decompress_common.o: decompress_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-decompress_common.o `test -f 'decompress_common.c' || echo '$(srcdir)/'`decompress_common.c
libwim_a-decompress_common.obj: decompress_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-decompress_common.obj `if test -f 'decompress_common.c'; then $(CYGPATH_W) 'decompress_common.c'; else $(CYGPATH_W) '$(srcdir)/decompress_common.c'; fi`
libwim_a-dentry.o: dentry.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-dentry.o `test -f 'dentry.c' || echo '$(srcdir)/'`dentry.c
libwim_a-dentry.obj: dentry.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-dentry.obj `if test -f 'dentry.c'; then $(CYGPATH_W) 'dentry.c'; else $(CYGPATH_W) '$(srcdir)/dentry.c'; fi`
libwim_a-divsufsort.o: divsufsort.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-divsufsort.o `test -f 'divsufsort.c' || echo '$(srcdir)/'`divsufsort.c
libwim_a-divsufsort.obj: divsufsort.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-divsufsort.obj `if test -f 'divsufsort.c'; then $(CYGPATH_W) 'divsufsort.c'; else $(CYGPATH_W) '$(srcdir)/divsufsort.c'; fi`
libwim_a-encoding.o: encoding.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-encoding.o `test -f 'encoding.c' || echo '$(srcdir)/'`encoding.c
libwim_a-encoding.obj: encoding.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-encoding.obj `if test -f 'encoding.c'; then $(CYGPATH_W) 'encoding.c'; else $(CYGPATH_W) '$(srcdir)/encoding.c'; fi`
libwim_a-error.o: error.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-error.o `test -f 'error.c' || echo '$(srcdir)/'`error.c
libwim_a-error.obj: error.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-error.obj `if test -f 'error.c'; then $(CYGPATH_W) 'error.c'; else $(CYGPATH_W) '$(srcdir)/error.c'; fi`
libwim_a-export_image.o: export_image.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-export_image.o `test -f 'export_image.c' || echo '$(srcdir)/'`export_image.c
libwim_a-export_image.obj: export_image.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-export_image.obj `if test -f 'export_image.c'; then $(CYGPATH_W) 'export_image.c'; else $(CYGPATH_W) '$(srcdir)/export_image.c'; fi`
libwim_a-extract.o: extract.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-extract.o `test -f 'extract.c' || echo '$(srcdir)/'`extract.c
libwim_a-extract.obj: extract.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-extract.obj `if test -f 'extract.c'; then $(CYGPATH_W) 'extract.c'; else $(CYGPATH_W) '$(srcdir)/extract.c'; fi`
libwim_a-file_io.o: file_io.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-file_io.o `test -f 'file_io.c' || echo '$(srcdir)/'`file_io.c
libwim_a-file_io.obj: file_io.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-file_io.obj `if test -f 'file_io.c'; then $(CYGPATH_W) 'file_io.c'; else $(CYGPATH_W) '$(srcdir)/file_io.c'; fi`
libwim_a-header.o: header.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-header.o `test -f 'header.c' || echo '$(srcdir)/'`header.c
libwim_a-header.obj: header.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-header.obj `if test -f 'header.c'; then $(CYGPATH_W) 'header.c'; else $(CYGPATH_W) '$(srcdir)/header.c'; fi`
libwim_a-inode.o: inode.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-inode.o `test -f 'inode.c' || echo '$(srcdir)/'`inode.c
libwim_a-inode.obj: inode.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-inode.obj `if test -f 'inode.c'; then $(CYGPATH_W) 'inode.c'; else $(CYGPATH_W) '$(srcdir)/inode.c'; fi`
libwim_a-inode_fixup.o: inode_fixup.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-inode_fixup.o `test -f 'inode_fixup.c' || echo '$(srcdir)/'`inode_fixup.c
libwim_a-inode_fixup.obj: inode_fixup.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-inode_fixup.obj `if test -f 'inode_fixup.c'; then $(CYGPATH_W) 'inode_fixup.c'; else $(CYGPATH_W) '$(srcdir)/inode_fixup.c'; fi`
libwim_a-inode_table.o: inode_table.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-inode_table.o `test -f 'inode_table.c' || echo '$(srcdir)/'`inode_table.c
libwim_a-inode_table.obj: inode_table.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-inode_table.obj `if test -f 'inode_table.c'; then $(CYGPATH_W) 'inode_table.c'; else $(CYGPATH_W) '$(srcdir)/inode_table.c'; fi`
libwim_a-integrity.o: integrity.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-integrity.o `test -f 'integrity.c' || echo '$(srcdir)/'`integrity.c
libwim_a-integrity.obj: integrity.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-integrity.obj `if test -f 'integrity.c'; then $(CYGPATH_W) 'integrity.c'; else $(CYGPATH_W) '$(srcdir)/integrity.c'; fi`
libwim_a-iterate_dir.o: iterate_dir.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-iterate_dir.o `test -f 'iterate_dir.c' || echo '$(srcdir)/'`iterate_dir.c
libwim_a-iterate_dir.obj: iterate_dir.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-iterate_dir.obj `if test -f 'iterate_dir.c'; then $(CYGPATH_W) 'iterate_dir.c'; else $(CYGPATH_W) '$(srcdir)/iterate_dir.c'; fi`
libwim_a-lcpit_matchfinder.o: lcpit_matchfinder.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lcpit_matchfinder.o `test -f 'lcpit_matchfinder.c' || echo '$(srcdir)/'`lcpit_matchfinder.c
libwim_a-lcpit_matchfinder.obj: lcpit_matchfinder.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lcpit_matchfinder.obj `if test -f 'lcpit_matchfinder.c'; then $(CYGPATH_W) 'lcpit_matchfinder.c'; else $(CYGPATH_W) '$(srcdir)/lcpit_matchfinder.c'; fi`
libwim_a-lzms_common.o: lzms_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzms_common.o `test -f 'lzms_common.c' || echo '$(srcdir)/'`lzms_common.c
libwim_a-lzms_common.obj: lzms_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzms_common.obj `if test -f 'lzms_common.c'; then $(CYGPATH_W) 'lzms_common.c'; else $(CYGPATH_W) '$(srcdir)/lzms_common.c'; fi`
libwim_a-lzms_compress.o: lzms_compress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzms_compress.o `test -f 'lzms_compress.c' || echo '$(srcdir)/'`lzms_compress.c
libwim_a-lzms_compress.obj: lzms_compress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzms_compress.obj `if test -f 'lzms_compress.c'; then $(CYGPATH_W) 'lzms_compress.c'; else $(CYGPATH_W) '$(srcdir)/lzms_compress.c'; fi`
libwim_a-lzms_decompress.o: lzms_decompress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzms_decompress.o `test -f 'lzms_decompress.c' || echo '$(srcdir)/'`lzms_decompress.c
libwim_a-lzms_decompress.obj: lzms_decompress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzms_decompress.obj `if test -f 'lzms_decompress.c'; then $(CYGPATH_W) 'lzms_decompress.c'; else $(CYGPATH_W) '$(srcdir)/lzms_decompress.c'; fi`
libwim_a-lzx_common.o: lzx_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzx_common.o `test -f 'lzx_common.c' || echo '$(srcdir)/'`lzx_common.c
libwim_a-lzx_common.obj: lzx_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzx_common.obj `if test -f 'lzx_common.c'; then $(CYGPATH_W) 'lzx_common.c'; else $(CYGPATH_W) '$(srcdir)/lzx_common.c'; fi`
libwim_a-lzx_compress.o: lzx_compress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzx_compress.o `test -f 'lzx_compress.c' || echo '$(srcdir)/'`lzx_compress.c
libwim_a-lzx_compress.obj: lzx_compress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzx_compress.obj `if test -f 'lzx_compress.c'; then $(CYGPATH_W) 'lzx_compress.c'; else $(CYGPATH_W) '$(srcdir)/lzx_compress.c'; fi`
libwim_a-lzx_decompress.o: lzx_decompress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzx_decompress.o `test -f 'lzx_decompress.c' || echo '$(srcdir)/'`lzx_decompress.c
libwim_a-lzx_decompress.obj: lzx_decompress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-lzx_decompress.obj `if test -f 'lzx_decompress.c'; then $(CYGPATH_W) 'lzx_decompress.c'; else $(CYGPATH_W) '$(srcdir)/lzx_decompress.c'; fi`
libwim_a-metadata_resource.o: metadata_resource.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-metadata_resource.o `test -f 'metadata_resource.c' || echo '$(srcdir)/'`metadata_resource.c
libwim_a-metadata_resource.obj: metadata_resource.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-metadata_resource.obj `if test -f 'metadata_resource.c'; then $(CYGPATH_W) 'metadata_resource.c'; else $(CYGPATH_W) '$(srcdir)/metadata_resource.c'; fi`
libwim_a-pathlist.o: pathlist.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-pathlist.o `test -f 'pathlist.c' || echo '$(srcdir)/'`pathlist.c
libwim_a-pathlist.obj: pathlist.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-pathlist.obj `if test -f 'pathlist.c'; then $(CYGPATH_W) 'pathlist.c'; else $(CYGPATH_W) '$(srcdir)/pathlist.c'; fi`
libwim_a-paths.o: paths.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-paths.o `test -f 'paths.c' || echo '$(srcdir)/'`paths.c
libwim_a-paths.obj: paths.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-paths.obj `if test -f 'paths.c'; then $(CYGPATH_W) 'paths.c'; else $(CYGPATH_W) '$(srcdir)/paths.c'; fi`
libwim_a-pattern.o: pattern.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-pattern.o `test -f 'pattern.c' || echo '$(srcdir)/'`pattern.c
libwim_a-pattern.obj: pattern.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-pattern.obj `if test -f 'pattern.c'; then $(CYGPATH_W) 'pattern.c'; else $(CYGPATH_W) '$(srcdir)/pattern.c'; fi`
libwim_a-progress.o: progress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-progress.o `test -f 'progress.c' || echo '$(srcdir)/'`progress.c
libwim_a-progress.obj: progress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-progress.obj `if test -f 'progress.c'; then $(CYGPATH_W) 'progress.c'; else $(CYGPATH_W) '$(srcdir)/progress.c'; fi`
libwim_a-registry.o: registry.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-registry.o `test -f 'registry.c' || echo '$(srcdir)/'`registry.c
libwim_a-registry.obj: registry.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-registry.obj `if test -f 'registry.c'; then $(CYGPATH_W) 'registry.c'; else $(CYGPATH_W) '$(srcdir)/registry.c'; fi`
libwim_a-reparse.o: reparse.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-reparse.o `test -f 'reparse.c' || echo '$(srcdir)/'`reparse.c
libwim_a-reparse.obj: reparse.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-reparse.obj `if test -f 'reparse.c'; then $(CYGPATH_W) 'reparse.c'; else $(CYGPATH_W) '$(srcdir)/reparse.c'; fi`
libwim_a-resource.o: resource.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-resource.o `test -f 'resource.c' || echo '$(srcdir)/'`resource.c
libwim_a-resource.obj: resource.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-resource.obj `if test -f 'resource.c'; then $(CYGPATH_W) 'resource.c'; else $(CYGPATH_W) '$(srcdir)/resource.c'; fi`
libwim_a-scan.o: scan.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-scan.o `test -f 'scan.c' || echo '$(srcdir)/'`scan.c
libwim_a-scan.obj: scan.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-scan.obj `if test -f 'scan.c'; then $(CYGPATH_W) 'scan.c'; else $(CYGPATH_W) '$(srcdir)/scan.c'; fi`
libwim_a-security.o: security.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-security.o `test -f 'security.c' || echo '$(srcdir)/'`security.c
libwim_a-security.obj: security.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-security.obj `if test -f 'security.c'; then $(CYGPATH_W) 'security.c'; else $(CYGPATH_W) '$(srcdir)/security.c'; fi`
libwim_a-sha1.o: sha1.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-sha1.o `test -f 'sha1.c' || echo '$(srcdir)/'`sha1.c
libwim_a-sha1.obj: sha1.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-sha1.obj `if test -f 'sha1.c'; then $(CYGPATH_W) 'sha1.c'; else $(CYGPATH_W) '$(srcdir)/sha1.c'; fi`
libwim_a-solid.o: solid.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-solid.o `test -f 'solid.c' || echo '$(srcdir)/'`solid.c
libwim_a-solid.obj: solid.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-solid.obj `if test -f 'solid.c'; then $(CYGPATH_W) 'solid.c'; else $(CYGPATH_W) '$(srcdir)/solid.c'; fi`
libwim_a-split.o: split.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-split.o `test -f 'split.c' || echo '$(srcdir)/'`split.c
libwim_a-split.obj: split.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-split.obj `if test -f 'split.c'; then $(CYGPATH_W) 'split.c'; else $(CYGPATH_W) '$(srcdir)/split.c'; fi`
libwim_a-tagged_items.o: tagged_items.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-tagged_items.o `test -f 'tagged_items.c' || echo '$(srcdir)/'`tagged_items.c
libwim_a-tagged_items.obj: tagged_items.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-tagged_items.obj `if test -f 'tagged_items.c'; then $(CYGPATH_W) 'tagged_items.c'; else $(CYGPATH_W) '$(srcdir)/tagged_items.c'; fi`
libwim_a-textfile.o: textfile.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-textfile.o `test -f 'textfile.c' || echo '$(srcdir)/'`textfile.c
libwim_a-textfile.obj: textfile.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-textfile.obj `if test -f 'textfile.c'; then $(CYGPATH_W) 'textfile.c'; else $(CYGPATH_W) '$(srcdir)/textfile.c'; fi`
libwim_a-threads.o: threads.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-threads.o `test -f 'threads.c' || echo '$(srcdir)/'`threads.c
libwim_a-threads.obj: threads.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-threads.obj `if test -f 'threads.c'; then $(CYGPATH_W) 'threads.c'; else $(CYGPATH_W) '$(srcdir)/threads.c'; fi`
libwim_a-timestamp.o: timestamp.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-timestamp.o `test -f 'timestamp.c' || echo '$(srcdir)/'`timestamp.c
libwim_a-timestamp.obj: timestamp.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-timestamp.obj `if test -f 'timestamp.c'; then $(CYGPATH_W) 'timestamp.c'; else $(CYGPATH_W) '$(srcdir)/timestamp.c'; fi`
libwim_a-update_image.o: update_image.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-update_image.o `test -f 'update_image.c' || echo '$(srcdir)/'`update_image.c
libwim_a-update_image.obj: update_image.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-update_image.obj `if test -f 'update_image.c'; then $(CYGPATH_W) 'update_image.c'; else $(CYGPATH_W) '$(srcdir)/update_image.c'; fi`
libwim_a-util.o: util.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-util.o `test -f 'util.c' || echo '$(srcdir)/'`util.c
libwim_a-util.obj: util.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-util.obj `if test -f 'util.c'; then $(CYGPATH_W) 'util.c'; else $(CYGPATH_W) '$(srcdir)/util.c'; fi`
libwim_a-wim.o: wim.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-wim.o `test -f 'wim.c' || echo '$(srcdir)/'`wim.c
libwim_a-wim.obj: wim.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-wim.obj `if test -f 'wim.c'; then $(CYGPATH_W) 'wim.c'; else $(CYGPATH_W) '$(srcdir)/wim.c'; fi`
libwim_a-wimboot.o: wimboot.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-wimboot.o `test -f 'wimboot.c' || echo '$(srcdir)/'`wimboot.c
libwim_a-wimboot.obj: wimboot.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-wimboot.obj `if test -f 'wimboot.c'; then $(CYGPATH_W) 'wimboot.c'; else $(CYGPATH_W) '$(srcdir)/wimboot.c'; fi`
libwim_a-win32_apply.o: win32_apply.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_apply.o `test -f 'win32_apply.c' || echo '$(srcdir)/'`win32_apply.c
libwim_a-win32_apply.obj: win32_apply.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_apply.obj `if test -f 'win32_apply.c'; then $(CYGPATH_W) 'win32_apply.c'; else $(CYGPATH_W) '$(srcdir)/win32_apply.c'; fi`
libwim_a-win32_capture.o: win32_capture.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_capture.o `test -f 'win32_capture.c' || echo '$(srcdir)/'`win32_capture.c
libwim_a-win32_capture.obj: win32_capture.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_capture.obj `if test -f 'win32_capture.c'; then $(CYGPATH_W) 'win32_capture.c'; else $(CYGPATH_W) '$(srcdir)/win32_capture.c'; fi`
libwim_a-win32_common.o: win32_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_common.o `test -f 'win32_common.c' || echo '$(srcdir)/'`win32_common.c
libwim_a-win32_common.obj: win32_common.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_common.obj `if test -f 'win32_common.c'; then $(CYGPATH_W) 'win32_common.c'; else $(CYGPATH_W) '$(srcdir)/win32_common.c'; fi`
libwim_a-win32_replacements.o: win32_replacements.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_replacements.o `test -f 'win32_replacements.c' || echo '$(srcdir)/'`win32_replacements.c
libwim_a-win32_replacements.obj: win32_replacements.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_replacements.obj `if test -f 'win32_replacements.c'; then $(CYGPATH_W) 'win32_replacements.c'; else $(CYGPATH_W) '$(srcdir)/win32_replacements.c'; fi`
libwim_a-win32_vss.o: win32_vss.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_vss.o `test -f 'win32_vss.c' || echo '$(srcdir)/'`win32_vss.c
libwim_a-win32_vss.obj: win32_vss.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-win32_vss.obj `if test -f 'win32_vss.c'; then $(CYGPATH_W) 'win32_vss.c'; else $(CYGPATH_W) '$(srcdir)/win32_vss.c'; fi`
libwim_a-write.o: write.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-write.o `test -f 'write.c' || echo '$(srcdir)/'`write.c
libwim_a-write.obj: write.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-write.obj `if test -f 'write.c'; then $(CYGPATH_W) 'write.c'; else $(CYGPATH_W) '$(srcdir)/write.c'; fi`
libwim_a-xml.o: xml.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xml.o `test -f 'xml.c' || echo '$(srcdir)/'`xml.c
libwim_a-xml.obj: xml.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xml.obj `if test -f 'xml.c'; then $(CYGPATH_W) 'xml.c'; else $(CYGPATH_W) '$(srcdir)/xml.c'; fi`
libwim_a-xmlproc.o: xmlproc.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xmlproc.o `test -f 'xmlproc.c' || echo '$(srcdir)/'`xmlproc.c
libwim_a-xmlproc.obj: xmlproc.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xmlproc.obj `if test -f 'xmlproc.c'; then $(CYGPATH_W) 'xmlproc.c'; else $(CYGPATH_W) '$(srcdir)/xmlproc.c'; fi`
libwim_a-xml_windows.o: xml_windows.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xml_windows.o `test -f 'xml_windows.c' || echo '$(srcdir)/'`xml_windows.c
libwim_a-xml_windows.obj: xml_windows.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xml_windows.obj `if test -f 'xml_windows.c'; then $(CYGPATH_W) 'xml_windows.c'; else $(CYGPATH_W) '$(srcdir)/xml_windows.c'; fi`
libwim_a-xpress_compress.o: xpress_compress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xpress_compress.o `test -f 'xpress_compress.c' || echo '$(srcdir)/'`xpress_compress.c
libwim_a-xpress_compress.obj: xpress_compress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xpress_compress.obj `if test -f 'xpress_compress.c'; then $(CYGPATH_W) 'xpress_compress.c'; else $(CYGPATH_W) '$(srcdir)/xpress_compress.c'; fi`
libwim_a-xpress_decompress.o: xpress_decompress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xpress_decompress.o `test -f 'xpress_decompress.c' || echo '$(srcdir)/'`xpress_decompress.c
libwim_a-xpress_decompress.obj: xpress_decompress.c
$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libwim_a_CFLAGS) $(CFLAGS) -c -o libwim_a-xpress_decompress.obj `if test -f 'xpress_decompress.c'; then $(CYGPATH_W) 'xpress_decompress.c'; else $(CYGPATH_W) '$(srcdir)/xpress_decompress.c'; fi`
ID: $(am__tagged_files)
$(am__define_uniq_tagged_files); mkid -fID $$unique
tags: tags-am
TAGS: tags
tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
set x; \
here=`pwd`; \
$(am__define_uniq_tagged_files); \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: ctags-am
CTAGS: ctags
ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
$(am__define_uniq_tagged_files); \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
cscopelist: cscopelist-am
cscopelist-am: $(am__tagged_files)
list='$(am__tagged_files)'; \
case "$(srcdir)" in \
[\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
*) sdir=$(subdir)/$(srcdir) ;; \
esac; \
for i in $$list; do \
if test -f "$$i"; then \
echo "$(subdir)/$$i"; \
else \
echo "$$sdir/$$i"; \
fi; \
done >> $(top_builddir)/cscope.files
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
check-am: all-am
check: check-am
all-am: Makefile $(LIBRARIES)
installdirs:
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
if test -z '$(STRIP)'; then \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
install; \
else \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
fi
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic clean-noinstLIBRARIES mostlyclean-am
distclean: distclean-am
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am:
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am:
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
clean-noinstLIBRARIES cscopelist-am ctags ctags-am distclean \
distclean-compile distclean-generic distclean-tags dvi dvi-am \
html html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-man install-pdf install-pdf-am \
install-ps install-ps-am install-strip installcheck \
installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-compile \
mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \
uninstall-am
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

8
src/wimlib/blob_table.c
View file

@ -180,8 +180,8 @@ blob_release_location(struct blob_descriptor *blob)
(void*)&blob->staging_file_name);
#endif
case BLOB_IN_ATTACHED_BUFFER:
STATIC_ASSERT((void*)&blob->file_on_disk ==
(void*)&blob->attached_buffer);
STATIC_ASSERT(offsetof(struct blob_descriptor, file_on_disk) ==
offsetof(struct blob_descriptor, attached_buffer));
FREE(blob->file_on_disk);
break;
#ifdef _WIN32
@ -570,6 +570,7 @@ for_blob_in_table_sorted_by_sequential_order(struct blob_table *table,
* Note: if the WIM file contains solid resource(s), then this structure is
* sometimes overloaded to describe a "resource" rather than a "blob". See the
* code for details. */
PRAGMA_BEGIN_PACKED
struct blob_descriptor_disk {
/* Size, offset, and flags of the blob. */
@ -586,6 +587,7 @@ struct blob_descriptor_disk {
* zeroes if this blob is of zero length. */
u8 hash[SHA1_HASH_SIZE];
} __attribute__((packed));
PRAGMA_END_PACKED
/* Given a nonempty run of consecutive blob descriptors with the SOLID flag set,
* count how many specify resources (as opposed to blobs within those
@ -1178,7 +1180,7 @@ write_blob_table_from_blob_list(struct list_head *blob_list,
logical_offset = 0;
list_for_each_entry(blob, blob_list, blob_table_list) {
if (blob->out_reshdr.flags & WIM_RESHDR_FLAG_SOLID) {
struct wim_reshdr tmp_reshdr;
struct wim_reshdr tmp_reshdr = { 0 };
/* Eww. When WIMGAPI sees multiple solid resources, it
* expects the offsets to be adjusted as if there were

1
src/wimlib/compress_parallel.c
View file

@ -499,6 +499,7 @@ new_parallel_chunk_compressor(int out_ctype, u32 out_chunk_size,
return 0;
err:
if (ctx)
parallel_chunk_compressor_destroy(&ctx->base);
return ret;
}

27
src/wimlib/cpu_features.c
View file

@ -38,7 +38,7 @@
#include <stdlib.h>
#include <string.h>
#if defined(__i386__) || defined(__x86_64__)
#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
/*
* With old GCC versions we have to manually save and restore the x86_32 PIC
@ -50,6 +50,24 @@
# define EBX_CONSTRAINT "=b"
#endif
#if defined(_MSC_VER)
#include <intrin.h>
#define read_xcr _xgetbv
static inline void
cpuid(u32 leaf, u32 subleaf, u32* a, u32* b, u32* c, u32* d)
{
int regs[4];
__cpuidex(regs, leaf, subleaf);
*a = (uint32_t)regs[0];
*b = (uint32_t)regs[1];
*c = (uint32_t)regs[2];
*d = (uint32_t)regs[3];
}
#else
/* Execute the CPUID instruction. */
static inline void
cpuid(u32 leaf, u32 subleaf, u32 *a, u32 *b, u32 *c, u32 *d)
@ -79,6 +97,7 @@ read_xcr(u32 index)
return ((u64)d << 32) | a;
}
#endif
static u32
get_cpu_features(void)
@ -225,7 +244,7 @@ get_cpu_features(void)
return features;
}
#elif defined(__aarch64__) && defined(_WIN32)
#elif (defined(__aarch64__) || (defined(_M_ARM64)) && defined(_WIN32))
#include <windows.h>
@ -248,7 +267,7 @@ static const struct {
const char *name;
u32 feature;
} feature_table[] = {
#if defined(__i386__) || defined(__x86_64__)
#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
{"ssse3", X86_CPU_FEATURE_SSSE3},
{"sse4.1", X86_CPU_FEATURE_SSE4_1},
{"sse4.2", X86_CPU_FEATURE_SSE4_2},
@ -256,7 +275,7 @@ static const struct {
{"bmi2", X86_CPU_FEATURE_BMI2},
{"sha", X86_CPU_FEATURE_SHA},
{"sha1", X86_CPU_FEATURE_SHA},
#elif defined(__aarch64__)
#elif defined(__aarch64__) || defined(_M_ARM64)
{"sha1", ARM_CPU_FEATURE_SHA1},
#else
# error "CPU_FEATURES_ENABLED was set but no features are defined!"

6
src/wimlib/decompress_common.c
View file

@ -218,7 +218,7 @@ make_huffman_decode_table(u16 decode_table[], unsigned num_syms,
unsigned n = stores_per_loop;
do {
*(__m128i *)entry_ptr = v;
entry_ptr += sizeof(v);
entry_ptr = _PTR(entry_ptr + sizeof(v));
} while (--n);
}
}
@ -246,7 +246,7 @@ make_huffman_decode_table(u16 decode_table[], unsigned num_syms,
unsigned n = stores_per_loop;
do {
*(aliased_word_t *)entry_ptr = v;
entry_ptr += sizeof(v);
entry_ptr = _PTR(entry_ptr + sizeof(v));
} while (--n);
}
}
@ -263,7 +263,7 @@ make_huffman_decode_table(u16 decode_table[], unsigned num_syms,
unsigned n = stores_per_loop;
do {
*(u16 *)entry_ptr = v;
entry_ptr += sizeof(v);
entry_ptr = _PTR(entry_ptr + sizeof(v));
} while (--n);
}
}

6
src/wimlib/dentry.c
View file

@ -71,6 +71,7 @@
/* On-disk format of a WIM dentry (directory entry), located in the metadata
* resource for a WIM image. */
PRAGMA_BEGIN_PACKED
struct wim_dentry_on_disk {
/* Length of this directory entry in bytes, not including any extra
@ -221,6 +222,7 @@ struct wim_extra_stream_entry_on_disk {
* @name_nbytes != 0; i.e., if this stream is named. */
utf16lechar name[];
} __attribute__((packed));
PRAGMA_END_PACKED
static void
do_dentry_set_name(struct wim_dentry *dentry, utf16lechar *name,
@ -488,7 +490,7 @@ calculate_dentry_full_path(struct wim_dentry *dentry)
d = d->d_parent; /* assumes d == d->d_parent for root */
} while (!dentry_is_root(d));
utf16lechar ubuf[ulen];
utf16lechar* ubuf = alloca(ulen * sizeof(utf16lechar));
utf16lechar *p = &ubuf[ulen];
d = dentry;
@ -846,7 +848,7 @@ get_parent_dentry(WIMStruct *wim, const tchar *path,
CASE_SENSITIVITY_TYPE case_type)
{
size_t path_len = tstrlen(path);
tchar buf[path_len + 1];
tchar* buf = alloca((path_len + 1) * sizeof(tchar));
tmemcpy(buf, path, path_len + 1);
to_parent_name(buf, path_len);

6
src/wimlib/encoding.c
View file

@ -56,9 +56,15 @@
#define INVALID_CODEPOINT 0xFFFFFFFF
#define VALIDATE(expr) if (validate && unlikely(!(expr))) goto invalid
#ifndef IS_SURROGATE
#define IS_SURROGATE(c) ((c) >= 0xD800 && (c) < 0xE000)
#endif
#ifndef IS_HIGH_SURROGATE
#define IS_HIGH_SURROGATE(c) ((c) >= 0xD800 && (c) < 0xDC00)
#endif
#ifndef IS_LOW_SURROGATE
#define IS_LOW_SURROGATE(c) ((c) >= 0xDC00 && (c) < 0xE000)
#endif
#define IS_UTF8_TAIL(c) (((c) & 0xC0) == 0x80)
/*

49
src/wimlib/extract.c
View file

@ -145,12 +145,13 @@ end_file_metadata_phase(struct apply_ctx *ctx)
/* Are all bytes in the specified buffer zero? */
static bool
is_all_zeroes(const u8 *p, const size_t size)
is_all_zeroes(const u8 *buf, const size_t size)
{
const u8 * const end = p + size;
uintptr_t p = (uintptr_t)buf;
const uintptr_t end = p + size;
for (; (uintptr_t)p % WORDBYTES && p != end; p++)
if (*p)
for (; p % WORDBYTES && p != end; p++)
if (*((const u8 *)p))
return false;
for (; end - p >= WORDBYTES; p += WORDBYTES)
@ -158,7 +159,7 @@ is_all_zeroes(const u8 *p, const size_t size)
return false;
for (; p != end; p++)
if (*p)
if (*((const u8*)p))
return false;
return true;
@ -187,14 +188,14 @@ is_all_zeroes(const u8 *p, const size_t size)
bool
detect_sparse_region(const void *data, size_t size, size_t *len_ret)
{
const void *p = data;
const void * const end = data + size;
uintptr_t p = (uintptr_t)data;
const uintptr_t end = p + size;
size_t len = 0;
bool zeroes = false;
while (p != end) {
size_t n = min(end - p, SPARSE_UNIT);
bool z = is_all_zeroes(p, n);
bool z = is_all_zeroes((const u8 *)p, n);
if (len != 0 && z != zeroes)
break;
@ -818,20 +819,13 @@ file_name_valid(utf16lechar *name, size_t num_chars, bool fix)
if (num_chars == 0)
return true;
for (i = 0; i < num_chars; i++) {
switch (le16_to_cpu(name[i])) {
#ifdef _WIN32
case '\x01'...'\x1F':
case '\\':
case ':':
case '*':
case '?':
case '"':
case '<':
case '>':
case '|':
#endif
case '/':
case '\0':
u16 c = le16_to_cpu(name[i]);
if (c == '/' || c == '\0'
#ifdef _WIN32
|| (c >= '\x01' && c <= '\x1F') || c == ':' || c == '?'
|| c == '"' || c == '<' || c == '>' || c == '|'
#endif
) {
if (fix)
name[i] = replacement_char;
else
@ -911,7 +905,7 @@ dentry_calculate_extraction_name(struct wim_dentry *dentry,
out_replace:
{
utf16lechar utf16_name_copy[dentry->d_name_nbytes / 2];
utf16lechar* utf16_name_copy = alloca(dentry->d_name_nbytes);
memcpy(utf16_name_copy, dentry->d_name, dentry->d_name_nbytes);
file_name_valid(utf16_name_copy, dentry->d_name_nbytes / 2, true);
@ -928,10 +922,11 @@ out_replace:
tchar_nchars /= sizeof(tchar);
size_t fixed_name_num_chars = tchar_nchars;
tchar fixed_name[tchar_nchars + 50];
tchar* fixed_name = alloca((tchar_nchars + 50) * sizeof(tchar));
tmemcpy(fixed_name, tchar_name, tchar_nchars);
fixed_name_num_chars += tsprintf(fixed_name + tchar_nchars,
fixed_name_num_chars += tsnprintf(fixed_name + tchar_nchars,
tchar_nchars + 50,
T(" (invalid filename #%lu)"),
++ctx->invalid_sequence);
@ -1895,7 +1890,7 @@ static int
extract_all_images(WIMStruct *wim, const tchar *target, int extract_flags)
{
size_t output_path_len = tstrlen(target);
tchar buf[output_path_len + 1 + 128 + 1];
tchar* buf = alloca((output_path_len + 1 + 128 + 1) * sizeof(tchar));
int ret;
int image;
const tchar *image_name;
@ -1917,7 +1912,7 @@ extract_all_images(WIMStruct *wim, const tchar *target, int extract_flags)
} else {
/* Image name is empty or contains forbidden characters.
* Use image number instead. */
tsprintf(buf + output_path_len + 1, T("%d"), image);
tsnprintf(buf + output_path_len + 1, output_path_len + 1 + 128 + 1, T("%d"), image);
}
ret = extract_single_image(wim, image, buf, extract_flags);
if (ret)

11
src/wimlib/file_io.c
View file

@ -61,7 +61,7 @@ full_read(struct filedes *fd, void *buf, size_t count)
continue;
return WIMLIB_ERR_READ;
}
buf += ret;
buf = _PTR(buf + ret);
count -= ret;
fd->offset += ret;
}
@ -86,9 +86,10 @@ pipe_read(struct filedes *fd, void *buf, size_t count, off_t offset)
/* Manually seek to the requested position. */
while (fd->offset != offset) {
size_t bytes_to_read = min(offset - fd->offset, BUFFER_SIZE);
u8 dummy[bytes_to_read];
u8* dummy = MALLOC(bytes_to_read);
ret = full_read(fd, dummy, bytes_to_read);
FREE(dummy);
if (ret)
return ret;
}
@ -131,7 +132,7 @@ full_pread(struct filedes *fd, void *buf, size_t count, off_t offset)
}
return WIMLIB_ERR_READ;
}
buf += ret;
buf = _PTR(buf + ret);
count -= ret;
offset += ret;
}
@ -159,7 +160,7 @@ full_write(struct filedes *fd, const void *buf, size_t count)
continue;
return WIMLIB_ERR_WRITE;
}
buf += ret;
buf = _PTR(buf + ret);
count -= ret;
fd->offset += ret;
}
@ -185,7 +186,7 @@ full_pwrite(struct filedes *fd, const void *buf, size_t count, off_t offset)
continue;
return WIMLIB_ERR_WRITE;
}
buf += ret;
buf = _PTR(buf + ret);
count -= ret;
offset += ret;
}

32
src/wimlib/header.c
View file

@ -62,7 +62,7 @@
int
read_wim_header(WIMStruct *wim, struct wim_header *hdr)
{
struct wim_header_disk disk_hdr __attribute__((aligned(8)));
PRAGMA_ALIGN(struct wim_header_disk disk_hdr, 8);
struct filedes *in_fd = &wim->in_fd;
const tchar *filename = wim->filename;
int ret;
@ -170,7 +170,7 @@ int
write_wim_header(const struct wim_header *hdr, struct filedes *out_fd,
off_t offset)
{
struct wim_header_disk disk_hdr __attribute__((aligned(8)));
PRAGMA_ALIGN(struct wim_header_disk disk_hdr, 8);
int ret;
disk_hdr.magic = cpu_to_le64(hdr->magic);
@ -210,21 +210,21 @@ write_wim_header_flags(u32 hdr_flags, struct filedes *out_fd)
static const struct {
u32 flag;
const char *name;
const tchar *name;
} hdr_flags[] = {
{WIM_HDR_FLAG_RESERVED, "RESERVED"},
{WIM_HDR_FLAG_COMPRESSION, "COMPRESSION"},
{WIM_HDR_FLAG_READONLY, "READONLY"},
{WIM_HDR_FLAG_SPANNED, "SPANNED"},
{WIM_HDR_FLAG_RESOURCE_ONLY, "RESOURCE_ONLY"},
{WIM_HDR_FLAG_METADATA_ONLY, "METADATA_ONLY"},
{WIM_HDR_FLAG_WRITE_IN_PROGRESS,"WRITE_IN_PROGRESS"},
{WIM_HDR_FLAG_RP_FIX, "RP_FIX"},
{WIM_HDR_FLAG_COMPRESS_RESERVED,"COMPRESS_RESERVED"},
{WIM_HDR_FLAG_COMPRESS_LZX, "COMPRESS_LZX"},
{WIM_HDR_FLAG_COMPRESS_XPRESS, "COMPRESS_XPRESS"},
{WIM_HDR_FLAG_COMPRESS_LZMS, "COMPRESS_LZMS"},
{WIM_HDR_FLAG_COMPRESS_XPRESS_2,"COMPRESS_XPRESS_2"},
{WIM_HDR_FLAG_RESERVED, T("RESERVED")},
{WIM_HDR_FLAG_COMPRESSION, T("COMPRESSION")},
{WIM_HDR_FLAG_READONLY, T("READONLY")},
{WIM_HDR_FLAG_SPANNED, T("SPANNED")},
{WIM_HDR_FLAG_RESOURCE_ONLY, T("RESOURCE_ONLY")},
{WIM_HDR_FLAG_METADATA_ONLY, T("METADATA_ONLY")},
{WIM_HDR_FLAG_WRITE_IN_PROGRESS,T("WRITE_IN_PROGRESS")},
{WIM_HDR_FLAG_RP_FIX, T("RP_FIX")},
{WIM_HDR_FLAG_COMPRESS_RESERVED,T("COMPRESS_RESERVED")},
{WIM_HDR_FLAG_COMPRESS_LZX, T("COMPRESS_LZX")},
{WIM_HDR_FLAG_COMPRESS_XPRESS, T("COMPRESS_XPRESS")},
{WIM_HDR_FLAG_COMPRESS_LZMS, T("COMPRESS_LZMS")},
{WIM_HDR_FLAG_COMPRESS_XPRESS_2,T("COMPRESS_XPRESS_2")},
};
/* API function documented in wimlib.h */

2
src/wimlib/integrity.c
View file

@ -47,12 +47,14 @@
#define INTEGRITY_MIN_CHUNK_SIZE 4096
#define INTEGRITY_MAX_CHUNK_SIZE 134217728
PRAGMA_BEGIN_PACKED
struct integrity_table {
u32 size;
u32 num_entries;
u32 chunk_size;
u8 sha1sums[][20];
} __attribute__((packed));
PRAGMA_END_PACKED
static int
calculate_chunk_sha1(struct filedes *in_fd, size_t this_chunk_size,

30
src/wimlib/lcpit_matchfinder.c
View file

@ -88,8 +88,8 @@
* Annual Symposium on Combinatorial Pattern Matching pp. 181-192.
*/
static void
build_LCP(u32 SA_and_LCP[restrict], const u32 ISA[restrict],
const u8 T[restrict], const u32 n,
build_LCP(u32* restrict SA_and_LCP, const u32* restrict ISA,
const u8* restrict T, const u32 n,
const u32 min_lcp, const u32 max_lcp)
{
u32 h = 0;
@ -170,7 +170,7 @@ build_LCP(u32 SA_and_LCP[restrict], const u32 ISA[restrict],
* Volume 1, Issue 4, pp. 605-623.
*/
static void
build_LCPIT(u32 intervals[restrict], u32 pos_data[restrict], const u32 n)
build_LCPIT(u32* restrict intervals, u32* restrict pos_data, const u32 n)
{
u32 * const SA_and_LCP = intervals;
u32 next_interval_idx;
@ -293,10 +293,10 @@ build_LCPIT(u32 intervals[restrict], u32 pos_data[restrict], const u32 n)
*/
static forceinline u32
lcpit_advance_one_byte(const u32 cur_pos,
u32 pos_data[restrict],
u32 intervals[restrict],
u32 next[restrict],
struct lz_match matches[restrict],
u32* restrict pos_data,
u32* restrict intervals,
u32* restrict next,
struct lz_match* restrict matches,
const bool record_matches)
{
u32 ref;
@ -389,8 +389,8 @@ expand_SA(void *p, u32 n)
/* Like build_LCP(), but for buffers larger than MAX_NORMAL_BUFSIZE. */
static void
build_LCP_huge(u64 SA_and_LCP64[restrict], const u32 ISA[restrict],
const u8 T[restrict], const u32 n,
build_LCP_huge(u64* restrict SA_and_LCP64, const u32* restrict ISA,
const u8* restrict T, const u32 n,
const u32 min_lcp, const u32 max_lcp)
{
u32 h = 0;
@ -426,7 +426,7 @@ build_LCP_huge(u64 SA_and_LCP64[restrict], const u32 ISA[restrict],
* 16n. (The non-huge version is 8n.)
*/
static void
build_LCPIT_huge(u64 intervals64[restrict], u32 pos_data[restrict], const u32 n)
build_LCPIT_huge(u64* restrict intervals64, u32* restrict pos_data, const u32 n)
{
u64 * const SA_and_LCP64 = intervals64;
u32 next_interval_idx;
@ -495,10 +495,10 @@ build_LCPIT_huge(u64 intervals64[restrict], u32 pos_data[restrict], const u32 n)
* MAX_NORMAL_BUFSIZE. */
static forceinline u32
lcpit_advance_one_byte_huge(const u32 cur_pos,
u32 pos_data[restrict],
u64 intervals64[restrict],
u32 prefetch_next[restrict],
struct lz_match matches[restrict],
u32* restrict pos_data,
u64* restrict intervals64,
u32* restrict prefetch_next,
struct lz_match* restrict matches,
const bool record_matches)
{
u32 interval_idx;
@ -645,7 +645,7 @@ build_SA(u32 SA[], const u8 T[], u32 n, u32 *tmp)
* the inverse suffix array is a mapping from suffix position to suffix rank.
*/
static void
build_ISA(u32 ISA[restrict], const u32 SA[restrict], u32 n)
build_ISA(u32* restrict ISA, const u32* restrict SA, u32 n)
{
for (u32 r = 0; r < n; r++)
ISA[SA[r]] = r;

4
src/wimlib/lzms_common.c
View file

@ -551,8 +551,8 @@ have_opcode:
* @last_target_usages must be a temporary array of length >= 65536.
*/
void
lzms_x86_filter(u8 data[restrict], s32 size,
s32 last_target_usages[restrict], bool undo)
lzms_x86_filter(u8* restrict data, s32 size,
s32* restrict last_target_usages, bool undo)
{
/*
* Note: this filter runs unconditionally and uses a custom algorithm to

8
src/wimlib/lzms_compress.c
View file

@ -177,6 +177,7 @@ check_that_powers_fit_in_bitfield(void)
/* A stripped-down version of the adaptive state in LZMS which excludes the
* probability entries and Huffman codes */
PRAGMA_BEGIN_ALIGN(64)
struct lzms_adaptive_state {
/* Recent offsets for LZ matches */
@ -198,7 +199,7 @@ struct lzms_adaptive_state {
u8 lz_rep_states[LZMS_NUM_LZ_REP_DECISIONS];
u8 delta_state;
u8 delta_rep_states[LZMS_NUM_DELTA_REP_DECISIONS];
} __attribute__((aligned(64)));
} PRAGMA_END_ALIGN(64);
/*
* This structure represents a byte position in the preprocessed input data and
@ -209,6 +210,7 @@ struct lzms_adaptive_state {
* each outgoing edge from this node is labeled with a literal or a match that
* can be taken to advance from this position to a later position.
*/
PRAGMA_BEGIN_ALIGN(64)
struct lzms_optimum_node {
/*
@ -251,7 +253,7 @@ struct lzms_optimum_node {
* maintained per-position and are only updated occasionally.
*/
struct lzms_adaptive_state state;
} __attribute__((aligned(64)));
} PRAGMA_END_ALIGN(64);
/* The main compressor structure */
struct lzms_compressor {
@ -921,7 +923,7 @@ lzms_encode_nonempty_item_list(struct lzms_compressor *c,
cur_node -= item.length;
cur_node->item = item;
item = orig_node->extra_items[i];
} while (++i != orig_node->num_extra_items);
} while (++i != orig_node->num_extra_items && i < 2);
}
cur_node -= item.length;
saved_item = cur_node->item;

8
src/wimlib/lzms_decompress.c
View file

@ -588,7 +588,7 @@ lzms_init_huffman_codes(struct lzms_decompressor *d, unsigned num_offset_slots)
LZMS_DELTA_POWER_TABLEBITS);
}
static noinline void
static _noinline void
lzms_rebuild_huffman_code(struct lzms_huffman_rebuild_info *rebuild_info)
{
lzms_build_huffman_code(rebuild_info);
@ -721,7 +721,7 @@ lzms_decompress(const void * const restrict in, const size_t in_nbytes,
{
struct lzms_decompressor *d = _d;
u8 *out_next = out;
u8 * const out_end = out + out_nbytes;
u8 * const out_end = _PTR(out + out_nbytes);
struct lzms_range_decoder rd;
struct lzms_input_bitstream is;
@ -742,8 +742,8 @@ lzms_decompress(const void * const restrict in, const size_t in_nbytes,
u32 match_state = 0;
u32 lz_state = 0;
u32 delta_state = 0;
u32 lz_rep_states[LZMS_NUM_LZ_REP_DECISIONS] = {};
u32 delta_rep_states[LZMS_NUM_DELTA_REP_DECISIONS] = {};
u32 lz_rep_states[LZMS_NUM_LZ_REP_DECISIONS] = { 0 };
u32 delta_rep_states[LZMS_NUM_DELTA_REP_DECISIONS] = { 0 };
/*
* Requirements on the compressed data:

41
src/wimlib/lzx_compress.c
View file

@ -260,6 +260,7 @@ struct lzx_block_split_stats {
* since items cannot be written until all items for the block have been chosen
* and the block's Huffman codes have been computed.
*/
PRAGMA_BEGIN_ALIGN(8)
struct lzx_sequence {
/*
@ -287,7 +288,7 @@ struct lzx_sequence {
u32 adjusted_offset_and_mainsym;
#define SEQ_MAINSYM_BITS 10
#define SEQ_MAINSYM_MASK (((u32)1 << SEQ_MAINSYM_BITS) - 1)
} __attribute__((aligned(8)));
} PRAGMA_END_ALIGN(8);
/*
* This structure represents a byte position in the input buffer and a node in
@ -298,6 +299,7 @@ struct lzx_sequence {
* each outgoing edge from this node is labeled with a literal or a match that
* can be taken to advance from this position to a later position.
*/
PRAGMA_BEGIN_ALIGN(8)
struct lzx_optimum_node {
/* The cost, in bits, of the lowest-cost path that has been found to
@ -333,7 +335,7 @@ struct lzx_optimum_node {
# define OPTIMUM_GAP_MATCH 0x80000000
#endif
} __attribute__((aligned(8)));
} PRAGMA_END_ALIGN(8);
/* The cost model for near-optimal parsing */
struct lzx_costs {
@ -511,9 +513,11 @@ static forceinline unsigned
lzx_get_offset_slot(struct lzx_compressor *c, u32 adjusted_offset,
bool is_16_bit)
{
#ifndef _MSC_VER
if (__builtin_constant_p(adjusted_offset) &&
adjusted_offset < LZX_NUM_RECENT_OFFSETS)
return adjusted_offset;
#endif
if (is_16_bit || adjusted_offset < ARRAY_LEN(c->offset_slot_tab_1))
return c->offset_slot_tab_1[adjusted_offset];
return c->offset_slot_tab_2[adjusted_offset >> 14];
@ -719,10 +723,10 @@ lzx_reset_symbol_frequencies(struct lzx_compressor *c)
}
static unsigned
lzx_compute_precode_items(const u8 lens[restrict],
const u8 prev_lens[restrict],
u32 precode_freqs[restrict],
unsigned precode_items[restrict])
lzx_compute_precode_items(const u8* restrict lens,
const u8* restrict prev_lens,
u32* restrict precode_freqs,
unsigned* restrict precode_items)
{
unsigned *itemptr;
unsigned run_start;
@ -842,14 +846,14 @@ lzx_compute_precode_items(const u8 lens[restrict],
*/
static void
lzx_write_compressed_code(struct lzx_output_bitstream *os,
const u8 lens[restrict],
const u8 prev_lens[restrict],
const u8* restrict lens,
const u8* restrict prev_lens,
unsigned num_lens)
{
u32 precode_freqs[LZX_PRECODE_NUM_SYMBOLS];
u8 precode_lens[LZX_PRECODE_NUM_SYMBOLS];
u32 precode_codewords[LZX_PRECODE_NUM_SYMBOLS];
unsigned precode_items[num_lens];
u8 precode_lens[LZX_PRECODE_NUM_SYMBOLS] = { 0 };
u32 precode_codewords[LZX_PRECODE_NUM_SYMBOLS] = { 0 };
unsigned* precode_items = alloca(num_lens * sizeof(unsigned));
unsigned num_precode_items;
unsigned precode_item;
unsigned precode_sym;
@ -1007,6 +1011,8 @@ lzx_write_sequences(struct lzx_output_bitstream *os, int block_type,
main_symbol = seq->adjusted_offset_and_mainsym & SEQ_MAINSYM_MASK;
offset_slot = (main_symbol - LZX_NUM_CHARS) / LZX_NUM_LEN_HEADERS;
if (offset_slot >= LZX_MAX_OFFSET_SLOTS)
return;
num_extra_bits = lzx_extra_offset_bits[offset_slot];
extra_bits = adjusted_offset - (lzx_offset_slot_base[offset_slot] +
LZX_OFFSET_ADJUSTMENT);
@ -1021,7 +1027,8 @@ lzx_write_sequences(struct lzx_output_bitstream *os, int block_type,
STATIC_ASSERT(WORDBITS < 64 || CAN_BUFFER(MAX_MATCH_BITS));
/* Output the main symbol for the match. */
if (main_symbol >= LZX_MAINCODE_MAX_NUM_SYMBOLS)
return;
lzx_add_bits(os, codes->codewords.main[main_symbol],
codes->lens.main[main_symbol]);
if (!CAN_BUFFER(MAX_MATCH_BITS))
@ -1029,7 +1036,8 @@ lzx_write_sequences(struct lzx_output_bitstream *os, int block_type,
/* If needed, output the length symbol for the match. */
if (matchlen >= LZX_MIN_SECONDARY_LEN) {
if (matchlen >= LZX_MIN_SECONDARY_LEN &&
matchlen < LZX_MIN_SECONDARY_LEN + LZX_LENCODE_NUM_SYMBOLS) {
lzx_add_bits(os, codes->codewords.len[matchlen -
LZX_MIN_SECONDARY_LEN],
codes->lens.len[matchlen -
@ -1313,9 +1321,10 @@ lzx_should_end_block(struct lzx_block_split_stats *stats)
* This is represented as a 64-bit integer for efficiency. There are three
* offsets of 21 bits each. Bit 64 is garbage.
*/
PRAGMA_BEGIN_ALIGN(8)
struct lzx_lru_queue {
u64 R;
} __attribute__((aligned(8)));
} PRAGMA_END_ALIGN(8);
#define LZX_QUEUE_OFFSET_SHIFT 21
#define LZX_QUEUE_OFFSET_MASK (((u64)1 << LZX_QUEUE_OFFSET_SHIFT) - 1)
@ -1563,7 +1572,7 @@ lzx_find_min_cost_path(struct lzx_compressor * const restrict c,
* been optimized by taking advantage of 'struct lzx_lru_queue' and
* 'struct lzx_optimum_node' both being 8 bytes in size and alignment.
*/
struct lzx_lru_queue queues[512];
struct lzx_lru_queue queues[512] = { 0 };
STATIC_ASSERT(ARRAY_LEN(queues) >= LZX_MAX_MATCH_LEN + 1);
STATIC_ASSERT(sizeof(c->optimum_nodes[0]) == sizeof(queues[0]));
#define QUEUE(node) \
@ -1572,7 +1581,7 @@ lzx_find_min_cost_path(struct lzx_compressor * const restrict c,
/*(queues[(uintptr_t)(node) / sizeof(*(node)) % ARRAY_LEN(queues)])*/
#if CONSIDER_GAP_MATCHES
u32 matches_before_gap[ARRAY_LEN(queues)];
u32 matches_before_gap[ARRAY_LEN(queues)] = { 0 };
#define MATCH_BEFORE_GAP(node) \
(matches_before_gap[(uintptr_t)(node) / sizeof(*(node)) % \
ARRAY_LEN(matches_before_gap)])

3
src/wimlib/lzx_decompress.c
View file

@ -70,6 +70,7 @@
#define LZX_READ_LENS_MAX_OVERRUN 50
PRAGMA_BEGIN_ALIGN(DECODE_TABLE_ALIGNMENT)
struct lzx_decompressor {
DECODE_TABLE(maincode_decode_table, LZX_MAINCODE_MAX_NUM_SYMBOLS,
@ -115,7 +116,7 @@ struct lzx_decompressor {
* bits of aligned offset blocks */
u8 extra_offset_bits_minus_aligned[LZX_MAX_OFFSET_SLOTS];
} __attribute__((aligned(DECODE_TABLE_ALIGNMENT)));
} PRAGMA_END_ALIGN(DECODE_TABLE_ALIGNMENT);
/* Read a Huffman-encoded symbol using the precode. */
static forceinline unsigned

2
src/wimlib/registry.c
View file

@ -114,6 +114,7 @@ struct vk {
le16 name_size;
le32 data_size;
le32 data_offset;
#ifndef _WIN32
#define REG_NONE cpu_to_le32(0)
#define REG_SZ cpu_to_le32(1)
#define REG_EXPAND_SZ cpu_to_le32(2)
@ -128,6 +129,7 @@ struct vk {
#define REG_RESOURCE_REQUIREMENTS_LIST cpu_to_le32(10)
#define REG_QWORD cpu_to_le32(11)
#define REG_QWORD_LITTLE_ENDIAN cpu_to_le32(11)
#endif
le32 data_type;
#define VK_COMPRESSED_NAME cpu_to_le16(0x0001)
le16 flags;

3
src/wimlib/resource.c
View file

@ -1383,8 +1383,7 @@ extract_blob_to_fd(struct blob_descriptor *blob, struct filedes *fd,
int
sha1_blob(struct blob_descriptor *blob)
{
static const struct read_blob_callbacks cbs = {
};
static const struct read_blob_callbacks cbs = { 0 };
return read_blob_with_sha1(blob, &cbs, false);
}

2
src/wimlib/security.c
View file

@ -33,11 +33,13 @@
#include "wimlib/sha1.h"
#include "wimlib/util.h"
PRAGMA_BEGIN_PACKED
struct wim_security_data_disk {
le32 total_length;
le32 num_entries;
le64 sizes[];
} __attribute__((packed));
PRAGMA_END_PACKED
struct wim_security_data *
new_wim_security_data(void)

100
src/wimlib/sha1.c
View file

@ -64,13 +64,19 @@ rol32(u32 v, int bits)
* the compiler from making counter-productive optimizations when there aren't
* enough registers available to hold the full array.
*/
#ifdef _MSC_VER
#include <intrin.h>
#pragma intrinsic(_ReadWriteBarrier)
#define FORCE_NOT_CACHED(array) _ReadWriteBarrier()
#else
#define FORCE_NOT_CACHED(array) asm volatile("" : "+m" (array))
#endif
/*
* Expands to FORCE_NOT_CACHED() if the architecture has 16 or fewer general
* purpose registers, otherwise does nothing.
*/
#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64) || defined(__arm__)
# define FORCE_NOT_CACHED_IF_FEW_REGS(array) FORCE_NOT_CACHED(array)
#else
# define FORCE_NOT_CACHED_IF_FEW_REGS(array) (void)(array)
@ -112,7 +118,7 @@ rol32(u32 v, int bits)
SHA1_GENERIC_5ROUNDS((i) + 15);
static void
sha1_blocks_generic(u32 h[5], const void *data, size_t num_blocks)
sha1_blocks_generic(u32 h[5], const u8 *data, size_t num_blocks)
{
do {
u32 a = h[0];
@ -160,7 +166,7 @@ sha1_blocks_generic(u32 h[5], const void *data, size_t num_blocks)
* During rounds 80-95, the first 16 message schedule words for the next block
* are prepared.
*/
#if defined(__i386__) || defined(__x86_64__)
#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
#include <immintrin.h>
#define SHA1_SSSE3_PRECALC(i, w0, w1, w2, w3, w4, w5, w6, w7) \
@ -173,18 +179,18 @@ sha1_blocks_generic(u32 h[5], const void *data, size_t num_blocks)
* w[i-16..i+3] are in (w0, w1, w2, w3, w4).
*/ \
if ((i) % 4 == 0) { \
w4 = _mm_alignr_epi8(w1, w0, 8) ^ w2; \
w4 = _mm_xor_si128(_mm_alignr_epi8(w1, w0, 8), w2); \
t0 = _mm_srli_si128(w3, 4); \
} else if ((i) % 4 == 1) { \
t0 ^= w4 ^ w0; \
t0 = _mm_xor_si128(t0, _mm_xor_si128(w4, w0)); \
t1 = _mm_slli_si128(t0, 12); \
} else if ((i) % 4 == 2) { \
t2 = _mm_slli_epi32(t1, 2); \
w4 = _mm_slli_epi32(t0, 1); \
t0 = _mm_srli_epi32(t0, 31); \
t2 ^= _mm_srli_epi32(t1, 30); \
t2 = _mm_xor_si128(t2, _mm_srli_epi32(t1, 30)); \
} else { \
w4 ^= t0 ^ t2; \
w4 = _mm_xor_si128(w4, _mm_xor_si128(t0, t2)); \
t0 = _mm_add_epi32(w4, k); \
_mm_store_si128((__m128i *)&tmp[((i) - 3) % 16], t0); \
} \
@ -196,21 +202,21 @@ sha1_blocks_generic(u32 h[5], const void *data, size_t num_blocks)
* note the reuse of w4.
*/ \
if ((i) % 4 == 0) \
w4 ^= _mm_alignr_epi8(w3, w2, 8); \
w4 = _mm_xor_si128(w4, _mm_alignr_epi8(w3, w2, 8)); \
else if ((i) % 4 == 1) \
w4 ^= w5 ^ w0; \
w4 = _mm_xor_si128(w4, _mm_xor_si128(w5, w0)); \
else if ((i) % 4 == 2) \
w4 = _mm_slli_epi32(w4, 2) ^ \
_mm_srli_epi32(w4, 30); \
w4 = _mm_xor_si128(_mm_slli_epi32(w4, 2), \
_mm_srli_epi32(w4, 30)); \
else \
_mm_store_si128((__m128i *)&tmp[((i) - 3) % 16],\
_mm_add_epi32(w4, k)); \
} else if ((i) < 96) { \
/* Precomputation of w[0..15] for next block */ \
if ((i) == 80 && --num_blocks != 0) \
data += SHA1_BLOCK_SIZE; \
data = _PTR(data + SHA1_BLOCK_SIZE); \
if ((i) % 4 == 0) \
w0 = _mm_loadu_si128(data + (((i) - 80) * 4)); \
w0 = _mm_loadu_si128(_PTR(data + (((i) - 80) * 4))); \
else if ((i) % 4 == 1) \
w0 = _mm_shuffle_epi8(w0, bswap32_mask); \
else if ((i) % 4 == 2) \
@ -252,12 +258,12 @@ sha1_blocks_generic(u32 h[5], const void *data, size_t num_blocks)
11, 10, 9, 8, 15, 14, 13, 12); \
__m128i w0, w1, w2, w3, w4, w5, w6, w7; \
__m128i k = _mm_set1_epi32(SHA1_K(0)); \
u32 tmp[16] __attribute__((aligned(16))); \
PRAGMA_ALIGN(u32 tmp[16], 16); \
\
w0 = _mm_shuffle_epi8(_mm_loadu_si128(data + 0), bswap32_mask); \
w1 = _mm_shuffle_epi8(_mm_loadu_si128(data + 16), bswap32_mask); \
w2 = _mm_shuffle_epi8(_mm_loadu_si128(data + 32), bswap32_mask); \
w3 = _mm_shuffle_epi8(_mm_loadu_si128(data + 48), bswap32_mask); \
w0 = _mm_shuffle_epi8(_mm_loadu_si128(_PTR(data + 0)), bswap32_mask); \
w1 = _mm_shuffle_epi8(_mm_loadu_si128(_PTR(data + 16)), bswap32_mask); \
w2 = _mm_shuffle_epi8(_mm_loadu_si128(_PTR(data + 32)), bswap32_mask); \
w3 = _mm_shuffle_epi8(_mm_loadu_si128(_PTR(data + 48)), bswap32_mask); \
_mm_store_si128((__m128i *)&tmp[0], _mm_add_epi32(w0, k)); \
_mm_store_si128((__m128i *)&tmp[4], _mm_add_epi32(w1, k)); \
_mm_store_si128((__m128i *)&tmp[8], _mm_add_epi32(w2, k)); \
@ -323,13 +329,13 @@ sha1_blocks_x86_avx_bmi2(u32 h[5], const void *data, size_t num_blocks)
* so during the j'th set of 4 rounds we do the SHA1MSG2 step for j+1'th set of
* message schedule words, PXOR for j+2'th set, and SHA1MSG1 for the j+3'th set.
*/
#if defined(__i386__) || defined(__x86_64__)
#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
#include <immintrin.h>
#define SHA1_NI_4ROUNDS(i, w0, w1, w2, w3, we0, we1) \
if ((i) < 16) \
w0 = _mm_shuffle_epi8( \
_mm_loadu_si128(data + ((i) * 4)), bswap_mask); \
_mm_loadu_si128(_PTR(data + ((i) * 4))), bswap_mask); \
if ((i) == 0) \
we0 = _mm_add_epi32(h_e, w0); \
else \
@ -339,7 +345,7 @@ sha1_blocks_x86_avx_bmi2(u32 h[5], const void *data, size_t num_blocks)
w1 = _mm_sha1msg2_epu32(w1, w0); \
abcd = _mm_sha1rnds4_epu32(abcd, we0, (i) / 20); \
if ((i) >= 8 && (i) < 72) \
w2 ^= w0; \
w2 = _mm_xor_si128(w2, w0); \
if ((i) >= 4 && (i) < 68) \
w3 = _mm_sha1msg1_epu32(w3, w0); \
/*
@ -355,7 +361,7 @@ sha1_blocks_x86_avx_bmi2(u32 h[5], const void *data, size_t num_blocks)
#define HAVE_SHA1_BLOCKS_X86_SHA
static void __attribute__((target("sha,sse4.1")))
sha1_blocks_x86_sha(u32 h[5], const void *data, size_t num_blocks)
sha1_blocks_x86_sha(u32 h[5], const u8 *data, size_t num_blocks)
{
const __m128i bswap_mask =
_mm_setr_epi8(15, 14, 13, 12, 11, 10, 9, 8,
@ -403,8 +409,8 @@ sha1_blocks_x86_sha(u32 h[5], const void *data, size_t num_blocks)
* set of 4 message schedule words: SHA1SU0 which does w[i-16] ^ w[i-14] ^
* w[i-8], and SHA1SU1 which XOR's in w[i-3] and rotates left by 1.
*/
#if defined(__aarch64__) && \
(defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 5))
#if (defined(__aarch64__) || defined(_M_ARM64)) && \
(defined(__clang__) || defined(_MSC_VER) || (defined(__GNUC__) && __GNUC__ >= 5))
/*
* clang's arm_neon.h used to have a bug where it only defined the SHA-1
@ -445,7 +451,7 @@ sha1_blocks_x86_sha(u32 h[5], const void *data, size_t num_blocks)
vsha1pq_u32((abcd), (e), (w)))
#define SHA1_CE_4ROUNDS(i, w0, w1, w2, w3, e0, e1) \
tmp = w0 + SHA1_CE_K(i); \
tmp = vaddq_u32(w0, SHA1_CE_K(i)); \
e1 = vsha1h_u32(vgetq_lane_u32(abcd, 0)); \
abcd = SHA1_CE_OP((i), abcd, e0, tmp); \
if ((i) >= 12 && (i) < 76) \
@ -471,7 +477,7 @@ static void
* too, but only in clang 15 and earlier. So, use "sha2" here.
*/
__attribute__((target("sha2")))
#else
#elif defined (__GNUC__)
/* gcc wants "+crypto". "+sha2" doesn't work. */
__attribute__((target("+crypto")))
#endif
@ -488,10 +494,10 @@ sha1_blocks_arm_ce(u32 h[5], const void *data, size_t num_blocks)
u32 e0 = h[4], e1;
uint32x4_t tmp, w0, w1, w2, w3;
w0 = vreinterpretq_u32_u8(vrev32q_u8(vld1q_u8(data + 0)));
w1 = vreinterpretq_u32_u8(vrev32q_u8(vld1q_u8(data + 16)));
w2 = vreinterpretq_u32_u8(vrev32q_u8(vld1q_u8(data + 32)));
w3 = vreinterpretq_u32_u8(vrev32q_u8(vld1q_u8(data + 48)));
w0 = vreinterpretq_u32_u8(vrev32q_u8(vld1q_u8(_PTR(data + 0))));
w1 = vreinterpretq_u32_u8(vrev32q_u8(vld1q_u8(_PTR(data + 16))));
w2 = vreinterpretq_u32_u8(vrev32q_u8(vld1q_u8(_PTR(data + 32))));
w3 = vreinterpretq_u32_u8(vrev32q_u8(vld1q_u8(_PTR(data + 48))));
SHA1_CE_16ROUNDS(0);
SHA1_CE_16ROUNDS(16);
@ -499,9 +505,9 @@ sha1_blocks_arm_ce(u32 h[5], const void *data, size_t num_blocks)
SHA1_CE_16ROUNDS(48);
SHA1_CE_16ROUNDS(64);
h_abcd += abcd;
h_abcd = vaddq_u32(h_abcd, abcd);
h[4] += e0;
data += SHA1_BLOCK_SIZE;
data = _PTR(data + SHA1_BLOCK_SIZE);
} while (--num_blocks);
vst1q_u32(h, h_abcd);
@ -517,23 +523,31 @@ sha1_blocks(u32 h[5], const void *data, size_t num_blocks)
{
#ifdef HAVE_SHA1_BLOCKS_X86_SHA
if ((cpu_features & (X86_CPU_FEATURE_SHA | X86_CPU_FEATURE_SSE4_1)) ==
(X86_CPU_FEATURE_SHA | X86_CPU_FEATURE_SSE4_1))
return sha1_blocks_x86_sha(h, data, num_blocks);
(X86_CPU_FEATURE_SHA | X86_CPU_FEATURE_SSE4_1)) {
sha1_blocks_x86_sha(h, data, num_blocks);
return;
}
#endif
#ifdef HAVE_SHA1_BLOCKS_X86_AVX_BMI2
if ((cpu_features & (X86_CPU_FEATURE_AVX | X86_CPU_FEATURE_BMI2)) ==
(X86_CPU_FEATURE_AVX | X86_CPU_FEATURE_BMI2))
return sha1_blocks_x86_avx_bmi2(h, data, num_blocks);
(X86_CPU_FEATURE_AVX | X86_CPU_FEATURE_BMI2)) {
sha1_blocks_x86_avx_bmi2(h, data, num_blocks);
return;
}
#endif
#ifdef HAVE_SHA1_BLOCKS_X86_SSSE3
if (cpu_features & X86_CPU_FEATURE_SSSE3)
return sha1_blocks_x86_ssse3(h, data, num_blocks);
if (cpu_features & X86_CPU_FEATURE_SSSE3) {
sha1_blocks_x86_ssse3(h, data, num_blocks);
return;
}
#endif
#ifdef HAVE_SHA1_BLOCKS_ARM_CE
if (cpu_features & ARM_CPU_FEATURE_SHA1)
return sha1_blocks_arm_ce(h, data, num_blocks);
if (cpu_features & ARM_CPU_FEATURE_SHA1) {
sha1_blocks_arm_ce(h, data, num_blocks);
return;
}
#endif
return sha1_blocks_generic(h, data, num_blocks);
sha1_blocks_generic(h, data, num_blocks);
}
/*
@ -572,14 +586,14 @@ sha1_update(struct sha1_ctx *ctx, const void *data, size_t len)
}
memcpy(&ctx->buffer[buffered], data, remaining);
sha1_blocks(ctx->h, ctx->buffer, 1);
data += remaining;
data = _PTR(data + remaining);
len -= remaining;
}
blocks = len / SHA1_BLOCK_SIZE;
if (blocks) {
sha1_blocks(ctx->h, data, blocks);
data += blocks * SHA1_BLOCK_SIZE;
data = _PTR(data + blocks * SHA1_BLOCK_SIZE);
len -= blocks * SHA1_BLOCK_SIZE;
}

3
src/wimlib/tagged_items.c
View file

@ -36,6 +36,7 @@
* Header that begins each tagged metadata item associated with a file in a WIM
* metadata resource
*/
PRAGMA_BEGIN_ALIGN(8)
struct tagged_item_header {
/* identifies the type of metadata item (see TAG_* constants) */
@ -48,7 +49,7 @@ struct tagged_item_header {
u8 data[0];
/* then zero-padded to an 8-byte boundary */
} __attribute__((aligned(8)));
} PRAGMA_END_ALIGN(8);
/*
* Retrieve from @inode the first metadata item that is tagged with @tag and

2
src/wimlib/threads.c
View file

@ -38,7 +38,7 @@
#ifdef _WIN32
static WINAPI DWORD
static DWORD WINAPI
win32_thrproc(LPVOID lpParameter)
{
struct thread *t = (struct thread *)lpParameter;

6
src/wimlib/timestamp.c
View file

@ -135,9 +135,13 @@ now_as_wim_timestamp(void)
void
wim_timestamp_to_str(u64 timestamp, tchar *buf, size_t len)
{
struct tm tm;
struct tm tm = { 0 };
time_t t = wim_timestamp_to_time_t(timestamp);
#ifdef _WIN32
gmtime_s(&tm, &t);
#else
gmtime_r(&t, &tm);
#endif
tstrftime(buf, len, T("%a %b %d %H:%M:%S %Y UTC"), &tm);
}

2
src/wimlib/update_image.c
View file

@ -742,7 +742,7 @@ get_capture_config(const tchar *config_file, struct capture_config *config,
size_t len = tstrlen(fs_source_path) +
tstrlen(wimboot_cfgfile);
struct stat st;
struct _stat64 st;
tmp_config_file = MALLOC((len + 1) * sizeof(tchar));
if (!tmp_config_file)

7
src/wimlib/util.c
View file

@ -36,7 +36,9 @@
#ifdef HAVE_SYS_SYSCALL_H
# include <sys/syscall.h>
#endif
#include <unistd.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include "wimlib.h"
#include "wimlib/assert.h"
@ -162,7 +164,8 @@ wimlib_set_memory_allocator(void *(*malloc_func)(size_t),
#ifndef HAVE_MEMPCPY
void *mempcpy(void *dst, const void *src, size_t n)
{
return memcpy(dst, src, n) + n;
void* ret = memcpy(dst, src, n);
return ret != NULL ? _PTR(ret + n) : NULL;
}
#endif

8
src/wimlib/wim.c
View file

@ -441,13 +441,13 @@ wimlib_print_available_images(const WIMStruct *wim, int image)
int first;
int last;
int i;
int n;
int n = 80;
if (image == WIMLIB_ALL_IMAGES) {
n = tprintf(T("Available Images:\n"));
tprintf(T("Available Images:\n"));
first = 1;
last = wim->hdr.image_count;
} else if (image >= 1 && image <= wim->hdr.image_count) {
n = tprintf(T("Information for Image %d\n"), image);
tprintf(T("Information for Image %d\n"), image);
first = image;
last = image;
} else {
@ -961,6 +961,7 @@ wimlib_global_init(int init_flags)
if (lib_initialized)
goto out;
mutex_init(&lib_initialization_mutex);
mutex_lock(&lib_initialization_mutex);
if (lib_initialized)
@ -1025,4 +1026,5 @@ wimlib_global_cleanup(void)
out_unlock:
mutex_unlock(&lib_initialization_mutex);
mutex_destroy(&lib_initialization_mutex);
}

136
src/wimlib/wimlib/compiler.h
View file

@ -27,6 +27,8 @@
* OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdlib.h>
#ifndef _WIMLIB_COMPILER_H
#define _WIMLIB_COMPILER_H
@ -49,17 +51,52 @@
# define __has_builtin(builtin) 0
#endif
#ifdef _MSC_VER
#if !__has_attribute(attribute)
#define __attribute__(x)
#endif
/* Declare that the annotated function should always be inlined. This might be
* desirable in highly tuned code, e.g. compression codecs. */
#define forceinline inline __attribute__((always_inline))
#define forceinline __inline
/* Declare that the annotated function should *not* be inlined. */
#define noinline __attribute__((noinline))
#define _noinline __declspec(noinline)
/* Functionally the same as 'noinline', but documents that the reason for not
* inlining is to prevent the annotated function from being inlined into a
* recursive function, thereby increasing its stack usage. */
#define noinline_for_stack noinline
#define noinline_for_stack _noinline
/* Hint that the expression is usually true. */
#define likely(expr) (expr)
/* Hint that the expression is usually false. */
#define unlikely(expr) (expr)
#if defined(_M_IX86) || defined(_M_X64)
/* Prefetch into L1 cache for read. */
#define prefetchr _m_prefetch
/* Prefetch into L1 cache for write. */
#define prefetchw _m_prefetchw
#else
#define prefetchr(x)
#define prefetchw(x)
#endif
#else
/* Declare that the annotated function should always be inlined. This might be
* desirable in highly tuned code, e.g. compression codecs. */
#define forceinline inline __attribute__((always_inline))
/* Declare that the annotated function should *not* be inlined. */
#define _noinline __attribute__((noinline))
/* Functionally the same as 'noinline', but documents that the reason for not
* inlining is to prevent the annotated function from being inlined into a
* recursive function, thereby increasing its stack usage. */
#define noinline_for_stack _noinline
/* Hint that the expression is usually true. */
#define likely(expr) __builtin_expect(!!(expr), 1)
@ -72,6 +109,7 @@
/* Prefetch into L1 cache for write. */
#define prefetchw(addr) __builtin_prefetch((addr), 1)
#endif
/* Hint that the annotated function takes a printf()-like format string and
* arguments. This is currently disabled on Windows because MinGW does not
@ -101,24 +139,29 @@
/* UNALIGNED_ACCESS_IS_FAST should be defined to 1 if unaligned memory accesses
* can be performed efficiently on the target platform. */
#if defined(__x86_64__) || defined(__i386__) || \
#if defined(__x86_64__) || defined(__i386__) || defined(_M_IX86) || defined(_M_X64) || \
defined(__ARM_FEATURE_UNALIGNED) || defined(__powerpc64__)
# define UNALIGNED_ACCESS_IS_FAST 1
#else
# define UNALIGNED_ACCESS_IS_FAST 0
#endif
/* Get the minimum of two variables, without multiple evaluation. */
#ifndef _MSC_VER
#undef min
#define min(a, b) ({ typeof(a) _a = (a); typeof(b) _b = (b); \
(_a < _b) ? _a : _b; })
#endif
#undef MIN
#define MIN(a, b) min((a), (b))
/* Get the maximum of two variables, without multiple evaluation. */
#ifndef _MSC_VER
#undef max
#define max(a, b) ({ typeof(a) _a = (a); typeof(b) _b = (b); \
(_a > _b) ? _a : _b; })
#endif
#undef MAX
#define MAX(a, b) max((a), (b))
@ -128,7 +171,7 @@
/* Swap the values of two variables, without multiple evaluation. */
#ifndef swap
# define swap(a, b) ({ typeof(a) _a = (a); (a) = (b); (b) = _a; })
# define swap(a, b) do { typeof(a) _a = (a); (a) = (b); (b) = _a; } while(0)
#endif
#define SWAP(a, b) swap((a), (b))
@ -152,11 +195,92 @@
/* STATIC_ASSERT_ZERO() - verify the truth of an expression at compilation time
* and also produce a result of value '0' to be used in constant expressions */
#define STATIC_ASSERT_ZERO(expr) ((int)sizeof(char[-!(expr)]))
#define STATIC_ASSERT_ZERO(expr) (0 * sizeof(char[1 - 2 * !(expr)]))
#define CONCAT_IMPL(s1, s2) s1##s2
/* CONCAT() - concatenate two tokens at preprocessing time. */
#define CONCAT(s1, s2) CONCAT_IMPL(s1, s2)
#ifdef _MSC_VER
#define PRAGMA_BEGIN_PACKED __pragma(pack(push, 1))
#define PRAGMA_END_PACKED __pragma(pack(pop))
#else
#define PRAGMA_BEGIN_PACKED
#define PRAGMA_END_PACKED
#endif
#ifdef _MSC_VER
#define PRAGMA_ALIGN(x, a) __declspec(align(a)) x
#define PRAGMA_BEGIN_ALIGN(a) __declspec(align(a))
#define PRAGMA_END_ALIGN(a)
#else
#define PRAGMA_ALIGN(x, a) x __attribute__((aligned(a)))
#define PRAGMA_BEGIN_ALIGN(a)
#define PRAGMA_END_ALIGN(a) __attribute__((aligned(a)))
#endif
#ifdef _MSC_VER
#define _PTR(x) (void*)((uintptr_t)x)
#else
#define _PTR(x) x
#endif
#ifdef _MSC_VER
#include <intrin.h>
#include <stdint.h>
uint32_t __inline __builtin_ctz(uint32_t value)
{
unsigned long trailing_zero = 0;
if (_BitScanForward(&trailing_zero, value))
return trailing_zero;
return 32;
}
uint32_t __inline __builtin_clz(uint32_t value)
{
unsigned long leading_zero = 0;
if (_BitScanReverse(&leading_zero, value))
return 31 - leading_zero;
return 32;
}
#if defined(_M_X64) || defined(_M_ARM64)
uint32_t __inline __builtin_clzll(uint64_t value)
{
unsigned long leading_zero = 0;
if (_BitScanReverse64(&leading_zero, value))
return 63 - leading_zero;
return 64;
}
uint32_t __inline __builtin_ctzll(uint64_t value)
{
unsigned long trailing_zero = 0;
if (_BitScanForward64(&trailing_zero, value))
return trailing_zero;
return 64;
}
#else
uint32_t __inline __builtin_clzll(uint64_t value)
{
if (value == 0)
return 64;
uint32_t msh = (uint32_t)(value >> 32);
uint32_t lsh = (uint32_t)(value & 0xFFFFFFFF);
if (msh != 0)
return __builtin_clz(msh);
return 32 + __builtin_clz(lsh);
}
uint32_t __inline __builtin_ctzll(uint64_t value)
{
if (value == 0)
return 64;
uint32_t msh = (uint32_t)(value >> 32);
uint32_t lsh = (uint32_t)(value & 0xFFFFFFFF);
if (msh != 0)
return __builtin_ctz(msh);
return 32 + __builtin_ctz(lsh);
}
#endif
#define __builtin_clzl __builtin_clzll
#endif
#endif /* _WIMLIB_COMPILER_H */

2
src/wimlib/wimlib/cpu_features.h
View file

@ -13,6 +13,8 @@
#define ARM_CPU_FEATURE_SHA1 0x00000001
#if (defined(__i386__) || defined(__x86_64__)) || \
(defined (_M_IX86) || defined (_M_X64) || defined(_M_ARM64)) || \
(defined(__aarch64__) && defined(__linux__)) || \
(defined(__aarch64__) && defined(__linux__)) || \
(defined(__aarch64__) && defined(__APPLE__)) || \
(defined(__aarch64__) && defined(_WIN32))

5
src/wimlib/wimlib/decompress_common.h
View file

@ -401,16 +401,17 @@ read_huffsym(struct input_bitstream *is, const u16 decode_table[],
* DECODE_TABLE_ALIGNMENT-byte aligned boundary as well.
*/
#define DECODE_TABLE(name, num_syms, table_bits, max_codeword_len) \
PRAGMA_BEGIN_ALIGN(DECODE_TABLE_ALIGNMENT) \
u16 name[DECODE_TABLE_SIZE((num_syms), (table_bits), \
(max_codeword_len))] \
__attribute__((aligned(DECODE_TABLE_ALIGNMENT)))
PRAGMA_END_ALIGN(DECODE_TABLE_ALIGNMENT)
/*
* Declare the temporary "working_space" array needed for building the decode
* table for a Huffman code.
*/
#define DECODE_TABLE_WORKING_SPACE(name, num_syms, max_codeword_len) \
u16 name[2 * ((max_codeword_len) + 1) + (num_syms)];
u16 name[2 * ((max_codeword_len) + 1) + (num_syms)]
int
make_huffman_decode_table(u16 decode_table[], unsigned num_syms,

11
src/wimlib/wimlib/endianness.h
View file

@ -42,6 +42,15 @@
/* Watch out for conflict with ntfs-3g/endians.h ... */
#ifndef _NTFS_ENDIANS_H
#ifdef _MSC_VER
#include <intrin.h>
#define bswap16 _byteswap_ushort
#define bswap32 _byteswap_ulong
#define bswap64 _byteswap_uint64
#else
#define bswap16_const(n) \
((((u16)(n) & 0x00FF) << 8) | \
(((u16)(n) & 0xFF00) >> 8))
@ -93,6 +102,8 @@ static forceinline u64 do_bswap64(u64 n)
#define bswap32(n) (__builtin_constant_p(n) ? bswap32_const(n) : do_bswap32(n))
#define bswap64(n) (__builtin_constant_p(n) ? bswap64_const(n) : do_bswap64(n))
#endif /* _MSC_VER */
#if CPU_IS_BIG_ENDIAN()
# define cpu_to_le16(n) ((_force_attr le16)bswap16(n))
# define cpu_to_le32(n) ((_force_attr le32)bswap32(n))

11
src/wimlib/wimlib/error.h
View file

@ -19,10 +19,21 @@ wimlib_warning(const tchar *format, ...);
void _format_attribute(printf, 1, 2) __attribute__((cold))
wimlib_warning_with_errno(const tchar *format, ...);
#ifdef _RUFUS
#include "rufus.h"
#ifdef ERROR
#undef ERROR
#endif
#define ERROR(format, ...) wuprintf(T(format)T("\n"), ## __VA_ARGS__)
#define ERROR_WITH_ERRNO ERROR
#define WARNING(format, ...) wuprintf(T(format)T("\n"), ## __VA_ARGS__)
#define WARNING_WITH_ERRNO WARNING
#else
#define ERROR(format, ...) wimlib_error(T(format), ## __VA_ARGS__)
#define ERROR_WITH_ERRNO(format, ...) wimlib_error_with_errno(T(format), ## __VA_ARGS__)
#define WARNING(format, ...) wimlib_warning(T(format), ## __VA_ARGS__)
#define WARNING_WITH_ERRNO(format, ...) wimlib_warning_with_errno(T(format), ## __VA_ARGS__)
#endif
extern bool wimlib_print_errors;
extern FILE *wimlib_error_file;

6
src/wimlib/wimlib/file_io.h
View file

@ -4,6 +4,7 @@
#include <stdbool.h>
#include <stddef.h>
#include <sys/types.h>
#include <unistd.h>
/* Wrapper around a file descriptor that keeps track of offset (including in
* pipes, which don't support lseek()) and a cached flag that tells whether the
@ -48,7 +49,12 @@ static inline void filedes_invalidate(struct filedes *fd)
fd->fd = -1;
}
#ifdef _MSC_VER
#include <io.h>
#define filedes_close(f) _close((f)->fd)
#else
#define filedes_close(f) close((f)->fd)
#endif
static inline bool
filedes_valid(const struct filedes *fd)

2
src/wimlib/wimlib/guid.h
View file

@ -34,7 +34,7 @@ guids_equal(const u8 guid1[GUID_SIZE], const u8 guid2[GUID_SIZE])
static inline void
generate_guid(u8 guid[GUID_SIZE])
{
return get_random_bytes(guid, GUID_SIZE);
get_random_bytes(guid, GUID_SIZE);
}
#endif /* _WIMLIB_GUID_H */

2
src/wimlib/wimlib/header.h
View file

@ -48,6 +48,7 @@
((u64)'\0' << 54))
/* On-disk format of the WIM header. */
PRAGMA_BEGIN_PACKED
struct wim_header_disk {
/* +0x00: Magic characters WIM_MAGIC or PWM_MAGIC. */
@ -111,6 +112,7 @@ struct wim_header_disk {
/* +0xd0 (208) */
} __attribute__((packed));
PRAGMA_END_PACKED
/*
* Arbitrarily limit the maximum number of images to 65535, to prevent huge

2
src/wimlib/wimlib/inode.h
View file

@ -229,7 +229,7 @@ struct wim_inode {
/* Optional extra data for a WIM inode */
struct wim_inode_extra {
size_t size; /* Size of the extra data in bytes */
u8 data[] __attribute__((aligned(8))); /* The extra data */
PRAGMA_ALIGN(u8 data[], 8); /* The extra data */
};
/*

12
src/wimlib/wimlib/list.h
View file

@ -182,8 +182,13 @@ list_splice_tail(struct list_head *list, struct list_head *head)
* @type: the type of the struct this is embedded in.
* @member: the name of the list_struct within the struct.
*/
#ifdef _MSC_VER
#define list_entry(ptr, type, member) \
((type *)((uintptr_t)(ptr) - (uintptr_t)offsetof(type, member)))
#else
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
#endif
/**
* list_first_entry - get the first element from a list
@ -324,10 +329,15 @@ hlist_add_head(struct hlist_node *n, struct hlist_head *h)
#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
#ifdef _MSC_VER
#define hlist_entry_safe(ptr, type, member) \
( (ptr) ? hlist_entry(ptr, type, member) : NULL )
#else
#define hlist_entry_safe(ptr, type, member) \
({ typeof(ptr) ____ptr = (ptr); \
____ptr ? hlist_entry(____ptr, type, member) : NULL; \
})
#endif
/**
* hlist_for_each_entry - iterate over list of given type
@ -349,7 +359,7 @@ hlist_add_head(struct hlist_node *n, struct hlist_head *h)
*/
#define hlist_for_each_entry_safe(pos, n, head, member) \
for (pos = hlist_entry_safe((head)->first, typeof(*pos), member);\
pos && ({ n = pos->member.next; 1; }); \
pos && ((n = pos->member.next) - n + 1); \
pos = hlist_entry_safe(n, typeof(*pos), member))
#endif /* _WIMLIB_LIST_H */

2
src/wimlib/wimlib/progress.h
View file

@ -75,7 +75,7 @@ static inline tchar *
progress_get_win32_path(const tchar *path)
{
#ifdef _WIN32
if (!wcsncmp(path, L"\\??\\", 4)) {
if (path != NULL && !wcsncmp(path, L"\\??\\", 4)) {
((wchar_t *)path)[1] = L'\\';
return (wchar_t *)&path[1];
}

6
src/wimlib/wimlib/resource.h
View file

@ -58,6 +58,7 @@ struct wim_resource_descriptor {
};
/* On-disk version of a WIM resource header. */
PRAGMA_BEGIN_PACKED
struct wim_reshdr_disk {
/* Size of the resource as it appears in the WIM file (possibly
* compressed). */
@ -73,6 +74,7 @@ struct wim_reshdr_disk {
/* Uncompressed size of the resource, in bytes. */
le64 uncompressed_size;
} __attribute__((packed));
PRAGMA_END_PACKED
/* In-memory version of a WIM resource header (`struct wim_reshdr_disk'). */
struct wim_reshdr {
@ -138,6 +140,7 @@ put_wim_reshdr(const struct wim_reshdr *reshdr,
/* Alternate chunk table format for resources with WIM_RESHDR_FLAG_SOLID set.
*/
PRAGMA_BEGIN_PACKED
struct alt_chunk_table_header_disk {
/* Uncompressed size of the resource in bytes. */
le64 res_usize;
@ -159,6 +162,7 @@ struct alt_chunk_table_header_disk {
/* This header is directly followed by a table of compressed sizes of
* the chunks (4 bytes per entry). */
} __attribute__((packed));
PRAGMA_END_PACKED
static inline unsigned int
get_chunk_entry_size(u64 res_size, bool is_alt)
@ -315,6 +319,7 @@ write_metadata_resource(WIMStruct *wim, int image, int write_resource_flags);
#define PWM_BLOB_MAGIC 0x2b9b9ba2443db9d8ULL
/* Header that precedes each blob in a pipable WIM. */
PRAGMA_BEGIN_PACKED
struct pwm_blob_hdr {
le64 magic; /* +0 */
le64 uncompressed_size; /* +8 */
@ -328,5 +333,6 @@ struct pwm_blob_hdr {
struct pwm_chunk_hdr {
le32 compressed_size;
} __attribute__((packed));
PRAGMA_END_PACKED
#endif /* _WIMLIB_RESOURCE_H */

2
src/wimlib/wimlib/timestamp.h
View file

@ -7,7 +7,9 @@
#ifndef _WIMLIB_TIMESTAMP_H
#define _WIMLIB_TIMESTAMP_H
#ifdef HAVE_SYS_TIMES_H
#include <sys/time.h>
#endif
#include <time.h>
#include "wimlib/types.h"

2
src/wimlib/wimlib/util.h
View file

@ -87,6 +87,7 @@ memdup(const void *mem, size_t size);
#ifndef HAVE_MEMPCPY
void *
mempcpy(void *dst, const void *src, size_t n);
#define wmempcpy(d, s, n) mempcpy(d, s, (n) * sizeof(wchar_t))
#endif
/**************************
@ -107,7 +108,6 @@ static inline bool
is_power_of_2(unsigned long n)
{
return (n != 0 && (n & (n - 1)) == 0);
}
static inline u64

1
src/wimlib/wimlib/win32.h
View file

@ -7,6 +7,7 @@
#ifdef _WIN32
#include <unistd.h>
#include "wimlib/types.h"
struct blob_descriptor;

263
src/wimlib/wimlib/win32_common.h
View file

@ -6,9 +6,11 @@
#ifndef _WIMLIB_WIN32_COMMON_H
#define _WIMLIB_WIN32_COMMON_H
#define UMDF_USING_NTSTATUS
#include <ntstatus.h>
#include <windows.h>
#include <winternl.h>
#include <unistd.h>
#ifdef ERROR
# undef ERROR
@ -17,8 +19,232 @@
/* ntdll definitions */
#ifdef _MSC_VER
#define FILE_OPENED 0x00000001
#ifndef FILE_SHARE_VALID_FLAGS
#define FILE_SHARE_VALID_FLAGS 0x00000007
#endif
typedef struct _FILE_NAME_INFORMATION {
ULONG FileNameLength;
WCHAR FileName[1];
} FILE_NAME_INFORMATION;
typedef struct _FILE_BASIC_INFORMATION {
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
ULONG FileAttributes;
} FILE_BASIC_INFORMATION;
typedef struct _FILE_DISPOSITION_INFORMATION {
BOOLEAN DoDeleteFile;
} FILE_DISPOSITION_INFORMATION;
typedef struct _FILE_LINK_INFORMATION {
union {
BOOLEAN ReplaceIfExists;
ULONG Flags;
} DUMMYUNIONNAME;
HANDLE RootDirectory;
ULONG FileNameLength;
WCHAR FileName[1];
} FILE_LINK_INFORMATION, *PFILE_LINK_INFORMATION;
typedef struct _FILE_ALLOCATION_INFORMATION {
LARGE_INTEGER AllocationSize;
} FILE_ALLOCATION_INFORMATION;
typedef struct _FILE_END_OF_FILE_INFORMATION {
LARGE_INTEGER EndOfFile;
} FILE_END_OF_FILE_INFORMATION;
typedef struct _FILE_FULL_EA_INFORMATION {
ULONG NextEntryOffset;
UCHAR Flags;
UCHAR EaNameLength;
USHORT EaValueLength;
CHAR EaName[1];
} FILE_FULL_EA_INFORMATION;
typedef struct _FILE_INTERNAL_INFORMATION {
LARGE_INTEGER IndexNumber;
} FILE_INTERNAL_INFORMATION;
typedef struct _FILE_NAMES_INFORMATION {
ULONG NextEntryOffset;
ULONG FileIndex;
ULONG FileNameLength;
WCHAR FileName[1];
} FILE_NAMES_INFORMATION;
typedef struct _FILE_FS_VOLUME_INFORMATION {
LARGE_INTEGER VolumeCreationTime;
ULONG VolumeSerialNumber;
ULONG VolumeLabelLength;
BOOLEAN SupportsObjects;
WCHAR VolumeLabel[1];
} FILE_FS_VOLUME_INFORMATION;
typedef struct _FILE_STANDARD_INFORMATION {
LARGE_INTEGER AllocationSize;
LARGE_INTEGER EndOfFile;
ULONG NumberOfLinks;
BOOLEAN DeletePending;
BOOLEAN Directory;
} FILE_STANDARD_INFORMATION;
typedef struct _FILE_EA_INFORMATION {
ULONG EaSize;
} FILE_EA_INFORMATION;
typedef struct _FILE_ACCESS_INFORMATION {
ACCESS_MASK AccessFlags;
} FILE_ACCESS_INFORMATION;
typedef struct _FILE_POSITION_INFORMATION {
LARGE_INTEGER CurrentByteOffset;
} FILE_POSITION_INFORMATION;
typedef struct _FILE_MODE_INFORMATION {
ULONG Mode;
} FILE_MODE_INFORMATION;
typedef struct _FILE_ALIGNMENT_INFORMATION {
ULONG AlignmentRequirement;
} FILE_ALIGNMENT_INFORMATION;
typedef struct _FILE_STREAM_INFORMATION {
ULONG NextEntryOffset;
ULONG StreamNameLength;
LARGE_INTEGER StreamSize;
LARGE_INTEGER StreamAllocationSize;
WCHAR StreamName[1];
} FILE_STREAM_INFORMATION;
typedef struct _FILE_ALL_INFORMATION {
FILE_BASIC_INFORMATION BasicInformation;
FILE_STANDARD_INFORMATION StandardInformation;
FILE_INTERNAL_INFORMATION InternalInformation;
FILE_EA_INFORMATION EaInformation;
FILE_ACCESS_INFORMATION AccessInformation;
FILE_POSITION_INFORMATION PositionInformation;
FILE_MODE_INFORMATION ModeInformation;
FILE_ALIGNMENT_INFORMATION AlignmentInformation;
FILE_NAME_INFORMATION NameInformation;
} FILE_ALL_INFORMATION;
typedef struct _FILE_FS_ATTRIBUTE_INFORMATION {
ULONG FileSystemAttributes;
ULONG MaximumComponentNameLength;
ULONG FileSystemNameLength;
WCHAR FileSystemName[1];
} FILE_FS_ATTRIBUTE_INFORMATION;
typedef enum {
FileDirectoryInformationAlt = 1,
FileFullDirectoryInformation = 2,
FileBothDirectoryInformation = 3,
FileBasicInformation = 4,
FileStandardInformation = 5,
FileInternalInformation = 6,
FileEaInformation = 7,
FileAccessInformation = 8,
FileNameInformation = 9,
FileRenameInformation = 10,
FileLinkInformation = 11,
FileNamesInformation = 12,
FileDispositionInformation = 13,
FilePositionInformation = 14,
FileFullEaInformation = 15,
FileModeInformation = 16,
FileAlignmentInformation = 17,
FileAllInformation = 18,
FileAllocationInformation = 19,
FileEndOfFileInformation = 20,
FileAlternateNameInformation = 21,
FileStreamInformation = 22,
FilePipeInformation = 23,
FilePipeLocalInformation = 24,
FilePipeRemoteInformation = 25,
FileMailslotQueryInformation = 26,
FileMailslotSetInformation = 27,
FileCompressionInformation = 28,
FileObjectIdInformation = 29,
FileCompletionInformation = 30,
FileMoveClusterInformation = 31,
FileQuotaInformation = 32,
FileReparsePointInformation = 33,
FileNetworkOpenInformation = 34,
FileAttributeTagInformation = 35,
FileTrackingInformation = 36,
FileIdBothDirectoryInformation = 37,
FileIdFullDirectoryInformation = 38,
FileValidDataLengthInformation = 39,
FileShortNameInformation = 40,
FileIoCompletionNotificationInformation = 41,
FileIoStatusBlockRangeInformation = 42,
FileIoPriorityHintInformation = 43,
FileSfioReserveInformation = 44,
FileSfioVolumeInformation = 45,
FileHardLinkInformation = 46,
FileProcessIdsUsingFileInformation = 47,
FileNormalizedNameInformation = 48,
FileNetworkPhysicalNameInformation = 49,
FileIdGlobalTxDirectoryInformation = 50,
FileIsRemoteDeviceInformation = 51,
FileUnusedInformation = 52,
FileNumaNodeInformation = 53,
FileStandardLinkInformation = 54,
FileRemoteProtocolInformation = 55,
FileRenameInformationBypassAccessCheck = 56,
FileLinkInformationBypassAccessCheck = 57,
FileVolumeNameInformation = 58,
FileIdInformation = 59,
FileIdExtdDirectoryInformation = 60,
FileReplaceCompletionInformation = 61,
FileHardLinkFullIdInformation = 62,
FileIdExtdBothDirectoryInformation = 63,
FileDispositionInformationEx = 64,
FileRenameInformationEx = 65,
FileRenameInformationExBypassAccessCheck = 66,
FileDesiredStorageClassInformation = 67,
FileStatInformation = 68,
FileMemoryPartitionInformation = 69,
FileStatLxInformation = 70,
FileCaseSensitiveInformation = 71,
FileLinkInformationEx = 72,
FileLinkInformationExBypassAccessCheck = 73,
FileStorageReserveIdInformation = 74,
FileCaseSensitiveInformationForceAccessCheck = 75,
FileKnownFolderInformation = 76,
FileStatBasicInformation = 77,
FileId64ExtdDirectoryInformation = 78,
FileId64ExtdBothDirectoryInformation = 79,
FileIdAllExtdDirectoryInformation = 80,
FileIdAllExtdBothDirectoryInformation = 81,
FileStreamReservationInformation,
FileMupProviderInfo,
FileMaximumInformation
} FILE_INFORMATION_CLASS_ALT;
typedef enum _FSINFOCLASS {
FileFsVolumeInformation = 1,
FileFsLabelInformation,
FileFsSizeInformation,
FileFsDeviceInformation,
FileFsAttributeInformation,
FileFsControlInformation,
FileFsFullSizeInformation,
FileFsObjectIdInformation,
FileFsDriverPathInformation,
FileFsVolumeFlagsInformation,
FileFsMaximumInformation
} FS_INFORMATION_CLASS;
#endif
typedef struct _RTLP_CURDIR_REF {
LONG RefCount;
HANDLE Handle;
@ -84,6 +310,22 @@ NtQueryDirectoryFile(IN HANDLE FileHandle,
IN PUNICODE_STRING FileName OPTIONAL,
IN BOOLEAN RestartScan);
NTSTATUS
NTAPI
NtQueryInformationFile(IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass);
NTSTATUS
NTAPI
NtQueryVolumeInformationFile(IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID FsInformation,
IN ULONG Length,
IN FS_INFORMATION_CLASS FsInformationClass);
NTSTATUS
NTAPI
NtQuerySecurityObject(IN HANDLE Handle,
@ -98,6 +340,14 @@ NtSetSecurityObject(IN HANDLE Handle,
IN SECURITY_INFORMATION SecurityInformation,
IN PSECURITY_DESCRIPTOR SecurityDescriptor);
NTSTATUS
NTAPI
NtSetInformationFile(IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass);
NTSTATUS
NTAPI
NtOpenSymbolicLinkObject(PHANDLE LinkHandle,
@ -123,6 +373,19 @@ NtSetEaFile(IN HANDLE FileHandle,
OUT PVOID Buffer,
IN ULONG Length);
NTSTATUS
NTAPI
NtFsControlFile(IN HANDLE FileHandle,
IN HANDLE Event,
IN PIO_APC_ROUTINE ApcRoutine,
IN PVOID ApcContext,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG FsControlCode,
IN PVOID InputBuffer,
IN ULONG InputBufferLength,
OUT PVOID OutputBuffer,
IN ULONG OutputBufferLength);
/* Dynamically loaded ntdll functions */
extern NTSTATUS (WINAPI *func_RtlDosPathNameToNtPathName_U_WithStatus)

5
src/wimlib/wimlib/wof.h
View file

@ -36,6 +36,7 @@
#ifdef _WIN32
#ifndef _MSC_VER
/*
* The Windows Overlay Filesystem filter (WOF, a.k.a. wof.sys) is a filesystem
* filter driver, available in Windows 8.1 and later, which allows files to be
@ -205,6 +206,8 @@ typedef struct _WIM_PROVIDER_UPDATE_OVERLAY_INPUT {
ULONG WimFileNameLength;
} WIM_PROVIDER_UPDATE_OVERLAY_INPUT, *PWIM_PROVIDER_UPDATE_OVERLAY_INPUT;
#endif
/*----------------------------------------------------------------------------*
* WOF reparse point and WimOverlay.dat structs (undocumented) *
*----------------------------------------------------------------------------*/
@ -219,6 +222,7 @@ typedef struct _WIM_PROVIDER_UPDATE_OVERLAY_INPUT {
* WOF, although they document the structures which must be passed into the
* ioctls, which are often similar.
*/
PRAGMA_BEGIN_PACKED
struct wim_provider_rpdata {
/* Set to 2. Uncertain meaning. */
le32 version;
@ -416,6 +420,7 @@ struct WimOverlay_dat_entry_2 {
utf16lechar wim_file_name[];
} __attribute__((packed));
} __attribute__((packed));
PRAGMA_END_PACKED
static void __attribute__((unused))
wof_check_structs(void)

9
src/wimlib/wimlib/xattr.h
View file

@ -22,6 +22,7 @@
* item tagged with TAG_XATTRS. This is the preferred xattr format, since it is
* also used by WIMGAPI and DISM starting in Windows 10 version 1607.
*/
PRAGMA_BEGIN_PACKED
struct wim_xattr_entry {
/* length of xattr value in bytes */
@ -41,6 +42,7 @@ struct wim_xattr_entry {
/* no padding at end! */
} __attribute__((packed));
PRAGMA_END_PACKED
static inline size_t
xattr_entry_size(const struct wim_xattr_entry *entry)
@ -57,7 +59,7 @@ xattr_entry_size(const struct wim_xattr_entry *entry)
static inline struct wim_xattr_entry *
xattr_entry_next(const struct wim_xattr_entry *entry)
{
return (void *)entry + xattr_entry_size(entry);
return (void *)_PTR(entry + xattr_entry_size(entry));
}
static inline bool
@ -80,6 +82,7 @@ valid_xattr_entry(const struct wim_xattr_entry *entry, size_t avail)
* xattr support in both WIMGAPI and wimlib). Now we use TAG_XATTRS for both
* Windows and Linux xattrs.
*/
PRAGMA_BEGIN_ALIGN(4)
struct wimlib_xattr_entry_old {
/* length of xattr name in bytes, excluding a null terminator */
@ -98,7 +101,7 @@ struct wimlib_xattr_entry_old {
/* u8 value[0]; */
/* then zero-padded to a 4-byte boundary */
} __attribute__((aligned(4)));
} PRAGMA_END_ALIGN(4);
static inline size_t
old_xattr_entry_size(const struct wimlib_xattr_entry_old *entry)
@ -116,7 +119,7 @@ old_xattr_entry_size(const struct wimlib_xattr_entry_old *entry)
static inline struct wimlib_xattr_entry_old *
old_xattr_entry_next(const struct wimlib_xattr_entry_old *entry)
{
return (void *)entry + old_xattr_entry_size(entry);
return (void *)_PTR(entry + old_xattr_entry_size(entry));
}
static inline bool

22
src/wimlib/wimlib_tchar.h
View file

@ -4,7 +4,7 @@
/* Functions to act on "tchar" strings, which have a platform-dependent encoding
* and character size. */
#ifdef _WIN32
#if defined(_WIN32)
#include <wchar.h>
/*
* For Windows builds, the "tchar" type will be 2 bytes and will be equivalent
@ -26,9 +26,22 @@ typedef wchar_t tchar;
# define tmempcpy wmempcpy
# define tstrcat wcscat
# define tstrcpy wcscpy
#ifdef _RUFUS
# define tprintf wuprintf
#else
# define tprintf wprintf
#endif
#ifdef _WIN32
# define tsprintf _swprintf
#else
# define tsprintf swprintf
#endif
# define tsnprintf snwprintf
#ifdef _RUFUS
# define tfprintf(f, ...) ((f == stdout || f == stderr) ? wuprintf(__VA_ARGS__) : fwprintf(f, __VA_ARGS__))
#else
# define tfprintf fwprintf
#endif
# define tvfprintf vfwprintf
# define tscanf swscanf
# define istalpha(c) iswalpha((wchar_t)(c))
@ -44,10 +57,17 @@ typedef wchar_t tchar;
# define tmemcmp wmemcmp
# define tstrcasecmp _wcsicmp
# define tstrftime wcsftime
#ifdef _RUFUS
# define tputchar(c) wuprintf(L"%c", c)
# define tputc(c, f) ((f == stdout || f == stderr) ? wuprintf(L"%c", c) : _putw(c, f))
# define tputs(s) wuprintf(L"%s\n", s)
# define tfputs(s, f) ((f == stdout || f == stderr) ? wuprintf(s) : fputws(s, f))
#else
# define tputchar putwchar
# define tputc putwc
# define tputs _putws
# define tfputs fputws
#endif
# define tfopen _wfopen
# define topen _wopen
# define tstat _wstati64

64
src/wimlib/win32_apply.c
View file

@ -1137,7 +1137,7 @@ adjust_compression_attribute(HANDLE h, const struct wim_dentry *dentry,
{
const bool compressed = (dentry->d_inode->i_attributes &
FILE_ATTRIBUTE_COMPRESSED);
FILE_BASIC_INFORMATION info;
FILE_BASIC_INFORMATION info = { 0 };
USHORT compression_state;
NTSTATUS status;
@ -1244,7 +1244,7 @@ remove_conflicting_short_name(const struct wim_dentry *dentry, struct win32_appl
HANDLE h;
size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) +
(13 * sizeof(wchar_t));
u8 buf[bufsize] __attribute__((aligned(8)));
u8* buf = wimlib_aligned_malloc(bufsize, 8);
bool retried = false;
FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf;
@ -1289,6 +1289,7 @@ retry:
}
NtClose(h);
out:
wimlib_aligned_free(buf);
build_extraction_path(dentry, ctx);
return status;
}
@ -1326,7 +1327,7 @@ set_short_name(HANDLE h, const struct wim_dentry *dentry,
size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) +
max(dentry->d_short_name_nbytes, sizeof(wchar_t)) +
sizeof(wchar_t);
u8 buf[bufsize] __attribute__((aligned(8)));
u8* buf = wimlib_aligned_malloc(bufsize, 8);
FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf;
NTSTATUS status;
bool tried_to_remove_existing = false;
@ -1339,8 +1340,10 @@ set_short_name(HANDLE h, const struct wim_dentry *dentry,
retry:
status = NtSetInformationFile(h, &ctx->iosb, info, bufsize,
FileShortNameInformation);
if (NT_SUCCESS(status))
if (NT_SUCCESS(status)) {
wimlib_aligned_free(buf);
return 0;
}
if (status == STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME) {
if (dentry->d_short_name_nbytes == 0)
@ -1353,8 +1356,10 @@ retry:
ret = win32_get_drive_path(ctx->common.target,
volume);
if (ret)
if (ret) {
wimlib_aligned_free(buf);
return ret;
}
if (try_to_enable_short_names(volume))
goto retry;
}
@ -1392,10 +1397,12 @@ retry:
ctx->num_set_short_name_failures++;
else
ctx->num_remove_short_name_failures++;
wimlib_aligned_free(buf);
return 0;
}
winnt_error(status, L"Can't set short name on \"%ls\"", current_path(ctx));
wimlib_aligned_free(buf);
return WIMLIB_ERR_SET_SHORT_NAME;
}
@ -1634,7 +1641,7 @@ create_empty_streams(const struct wim_dentry *dentry,
if (strm->stream_type == STREAM_TYPE_REPARSE_POINT &&
ctx->common.supported_features.reparse_points)
{
u8 buf[REPARSE_DATA_OFFSET] __attribute__((aligned(8)));
PRAGMA_ALIGN(u8 buf[REPARSE_DATA_OFFSET], 8);
struct reparse_buffer_disk *rpbuf =
(struct reparse_buffer_disk *)buf;
complete_reparse_point(rpbuf, inode, 0);
@ -1843,7 +1850,7 @@ create_link(HANDLE h, const struct wim_dentry *dentry,
size_t bufsize = offsetof(FILE_LINK_INFORMATION, FileName) +
ctx->pathbuf.Length + sizeof(wchar_t);
u8 buf[bufsize] __attribute__((aligned(8)));
u8* buf = wimlib_aligned_malloc(bufsize, 8);
FILE_LINK_INFORMATION *info = (FILE_LINK_INFORMATION *)buf;
NTSTATUS status;
@ -1868,11 +1875,14 @@ create_link(HANDLE h, const struct wim_dentry *dentry,
status = NtSetInformationFile(h, &ctx->iosb, info,
bufsize,
FileLinkInformation);
if (NT_SUCCESS(status))
if (NT_SUCCESS(status)) {
wimlib_aligned_free(buf);
return 0;
}
} while (++i < 32);
winnt_error(status, L"Failed to create link \"%ls\"",
current_path(ctx));
wimlib_aligned_free(buf);
return WIMLIB_ERR_LINK;
} else {
HANDLE h2;
@ -2205,7 +2215,7 @@ try_rpfix(struct reparse_buffer_disk *rpbuf, u16 *rpbuflen_p,
fixed_subst_name_nchars = target_ntpath_nchars + relpath_nchars;
wchar_t fixed_subst_name[fixed_subst_name_nchars];
wchar_t* fixed_subst_name = MALLOC(fixed_subst_name_nchars * sizeof(wchar_t));
wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer, target_ntpath_nchars);
wmemcpy(&fixed_subst_name[target_ntpath_nchars], relpath, relpath_nchars);
@ -2225,6 +2235,7 @@ try_rpfix(struct reparse_buffer_disk *rpbuf, u16 *rpbuflen_p,
link.print_name = (wchar_t *)fixed_print_name;
link.print_name_nbytes = fixed_print_name_nchars * sizeof(wchar_t);
make_link_reparse_point(&link, rpbuf, rpbuflen_p);
FREE(fixed_subst_name);
}
/* Sets the reparse point on the specified file. This handles "fixing" the
@ -2370,12 +2381,12 @@ fail:
static int
pwrite_to_handle(HANDLE h, const void *data, size_t size, u64 offset)
{
const void * const end = data + size;
const void *p;
const uintptr_t end = (uintptr_t)data + size;
uintptr_t p;
IO_STATUS_BLOCK iosb;
NTSTATUS status;
for (p = data; p != end; p += iosb.Information,
for (p = (uintptr_t)data; p != end; p += iosb.Information,
offset += iosb.Information)
{
LARGE_INTEGER offs = { .QuadPart = offset };
@ -2398,8 +2409,8 @@ win32_extract_chunk(const struct blob_descriptor *blob, u64 offset,
const void *chunk, size_t size, void *_ctx)
{
struct win32_apply_ctx *ctx = _ctx;
const void * const end = chunk + size;
const void *p;
const uintptr_t end = (uintptr_t)chunk + size;
uintptr_t p;
bool zeroes;
size_t len;
unsigned i;
@ -2409,13 +2420,13 @@ win32_extract_chunk(const struct blob_descriptor *blob, u64 offset,
* For sparse streams, only write nonzero regions. This lets the
* filesystem use holes to represent zero regions.
*/
for (p = chunk; p != end; p += len, offset += len) {
zeroes = maybe_detect_sparse_region(p, end - p, &len,
for (p = (uintptr_t)chunk; p != end; p += len, offset += len) {
zeroes = maybe_detect_sparse_region((const void*)p, end - p, &len,
ctx->any_sparse_streams);
for (i = 0; i < ctx->num_open_handles; i++) {
if (!zeroes || !ctx->is_sparse_stream[i]) {
ret = pwrite_to_handle(ctx->open_handles[i],
p, len, offset);
(void*)p, len, offset);
if (ret)
return ret;
}
@ -2837,11 +2848,11 @@ set_object_id(HANDLE h, const struct wim_inode *inode,
static int
set_xattrs(HANDLE h, const struct wim_inode *inode, struct win32_apply_ctx *ctx)
{
const void *entries, *entries_end;
uintptr_t entries, entries_end;
u32 len;
const struct wim_xattr_entry *entry;
size_t bufsize = 0;
u8 _buf[1024] __attribute__((aligned(4)));
PRAGMA_ALIGN(u8 _buf[1024], 4);
u8 *buf = _buf;
FILE_FULL_EA_INFORMATION *ea, *ea_prev;
NTSTATUS status;
@ -2850,15 +2861,14 @@ set_xattrs(HANDLE h, const struct wim_inode *inode, struct win32_apply_ctx *ctx)
if (!ctx->common.supported_features.xattrs)
return 0;
entries = inode_get_xattrs(inode, &len);
if (likely(entries == NULL || len == 0)) /* No extended attributes? */
entries = (uintptr_t)inode_get_xattrs(inode, &len);
if (likely(entries == 0 || len == 0)) /* No extended attributes? */
return 0;
entries_end = entries + len;
entry = entries;
for (entry = entries; (void *)entry < entries_end;
for (entry = (const struct wim_xattr_entry*)entries; (uintptr_t)entry < entries_end;
entry = xattr_entry_next(entry)) {
if (!valid_xattr_entry(entry, entries_end - (void *)entry)) {
if (!valid_xattr_entry(entry, (size_t)(entries_end - (uintptr_t)entry))) {
ERROR("\"%"TS"\": extended attribute is corrupt or unsupported",
inode_any_full_path(inode));
return WIMLIB_ERR_INVALID_XATTR;
@ -2883,7 +2893,7 @@ set_xattrs(HANDLE h, const struct wim_inode *inode, struct win32_apply_ctx *ctx)
ea_prev = NULL;
ea = (FILE_FULL_EA_INFORMATION *)buf;
for (entry = entries; (void *)entry < entries_end;
for (entry = (const struct wim_xattr_entry*)entries; (uintptr_t)entry < entries_end;
entry = xattr_entry_next(entry)) {
u8 *p;
@ -2899,6 +2909,10 @@ set_xattrs(HANDLE h, const struct wim_inode *inode, struct win32_apply_ctx *ctx)
ea_prev = ea;
ea = (FILE_FULL_EA_INFORMATION *)p;
}
if (ea_prev == NULL) {
ret = WIMLIB_ERR_INVALID_PARAM;
goto out;
}
ea_prev->NextEntryOffset = 0;
wimlib_assert((u8 *)ea - buf == bufsize);

81
src/wimlib/win32_capture.c
View file

@ -305,9 +305,9 @@ windows_file_to_string(const struct windows_file *file, u8 *buf, size_t bufsize)
memcpy(&file_id,
(u8 *)file->path + file->path_nbytes - sizeof(file_id),
sizeof(file_id));
swprintf((wchar_t *)buf, L"NTFS inode 0x%016"PRIx64, file_id);
swprintf((wchar_t *)buf, bufsize, L"NTFS inode 0x%016"PRIx64, file_id);
} else if (file->path_nbytes + 3 * sizeof(wchar_t) <= bufsize) {
swprintf((wchar_t *)buf, L"\"%ls\"", file->path);
swprintf((wchar_t *)buf, bufsize, L"\"%ls\"", file->path);
} else {
return L"(name too long)";
}
@ -330,7 +330,7 @@ read_winnt_stream_prefix(const struct windows_file *file,
};
HANDLE h;
NTSTATUS status;
u8 buf[BUFFER_SIZE] __attribute__((aligned(8)));
PRAGMA_ALIGN(u8 buf[BUFFER_SIZE], 8);
u64 bytes_remaining;
int ret;
@ -512,7 +512,7 @@ winnt_get_short_name(HANDLE h, struct wim_dentry *dentry)
* course has to create its own handle. */
NTSTATUS status;
IO_STATUS_BLOCK iosb;
u8 buf[128] __attribute__((aligned(8)));
PRAGMA_ALIGN(u8 buf[128], 8);
const FILE_NAME_INFORMATION *info;
status = NtQueryInformationFile(h, &iosb, buf, sizeof(buf),
@ -537,7 +537,7 @@ winnt_load_security_descriptor(HANDLE h, struct wim_inode *inode,
struct winnt_scan_ctx *ctx)
{
SECURITY_INFORMATION requestedInformation;
u8 _buf[4096] __attribute__((aligned(8)));
PRAGMA_ALIGN(u8 _buf[4096], 8);
u8 *buf;
ULONG bufsize;
ULONG len_needed;
@ -705,7 +705,7 @@ winnt_load_xattrs(HANDLE h, struct wim_inode *inode,
{
IO_STATUS_BLOCK iosb;
NTSTATUS status;
u8 _buf[1024] __attribute__((aligned(4)));
PRAGMA_ALIGN(u8 _buf[1024], 4);
u8 *buf = _buf;
const FILE_FULL_EA_INFORMATION *ea;
struct wim_xattr_entry *entry;
@ -821,7 +821,7 @@ winnt_recurse_directory(HANDLE h,
const size_t bufsize = 8192;
IO_STATUS_BLOCK iosb;
NTSTATUS status;
int ret;
int ret = WIMLIB_ERR_SUCCESS;
buf = MALLOC(bufsize);
if (!buf)
@ -894,7 +894,7 @@ file_has_ino_and_dev(HANDLE h, u64 ino, u64 dev)
NTSTATUS status;
IO_STATUS_BLOCK iosb;
FILE_INTERNAL_INFORMATION int_info;
FILE_FS_VOLUME_INFORMATION vol_info;
FILE_FS_VOLUME_INFORMATION vol_info = { 0 };
status = NtQueryInformationFile(h, &iosb, &int_info, sizeof(int_info),
FileInternalInformation);
@ -1013,7 +1013,7 @@ winnt_rpfix_progress(struct scan_params *params,
const struct link_reparse_point *link, int scan_status)
{
size_t print_name_nchars = link->print_name_nbytes / sizeof(wchar_t);
wchar_t print_name0[print_name_nchars + 1];
wchar_t* print_name0 = alloca((print_name_nchars + 1) * sizeof(wchar_t));
wmemcpy(print_name0, link->print_name, print_name_nchars);
print_name0[print_name_nchars] = L'\0';
@ -1082,14 +1082,16 @@ winnt_try_rpfix(struct reparse_buffer_disk *rpbuf, u16 *rpbuflen_p,
* what exactly the prefix is, as long as it looks like an absolute
* path. */
static const wchar_t prefix[6] = L"\\??\\X:";
static const wchar_t prefix[] = L"\\??\\X:";
static const size_t num_unprintable_chars = 4;
size_t rel_target_nbytes =
link.substitute_name_nbytes - ((const u8 *)rel_target -
(const u8 *)link.substitute_name);
wchar_t tmp[(sizeof(prefix) + rel_target_nbytes) / sizeof(wchar_t)];
wchar_t* tmp = alloca(sizeof(prefix) + rel_target_nbytes);
if (!tmp)
return 0;
memcpy(tmp, prefix, sizeof(prefix));
memcpy(tmp + ARRAY_LEN(prefix), rel_target, rel_target_nbytes);
@ -1331,7 +1333,7 @@ winnt_scan_data_streams(HANDLE h, struct wim_inode *inode, u64 file_size,
struct winnt_scan_ctx *ctx)
{
int ret;
u8 _buf[4096] __attribute__((aligned(8)));
PRAGMA_ALIGN(u8 _buf[4096], 8);
u8 *buf;
size_t bufsize;
IO_STATUS_BLOCK iosb;
@ -1654,12 +1656,11 @@ get_file_info(HANDLE h, struct file_info *info)
static void
get_volume_information(HANDLE h, struct winnt_scan_ctx *ctx)
{
u8 _attr_info[sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 128]
__attribute__((aligned(8)));
PRAGMA_ALIGN(u8 _attr_info[sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 128], 8);
FILE_FS_ATTRIBUTE_INFORMATION *attr_info = (void *)_attr_info;
FILE_FS_VOLUME_INFORMATION vol_info;
struct file_info file_info;
IO_STATUS_BLOCK iosb;
IO_STATUS_BLOCK iosb = { 0 };
NTSTATUS status;
/* Get volume flags */
@ -1960,6 +1961,7 @@ winnt_do_scan_warnings(const wchar_t *path, const struct winnt_scan_ctx *ctx)
#ifdef ENABLE_FAST_MFT_SCAN
#ifndef _MSC_VER
typedef struct {
u64 StartingCluster;
u64 ClusterCount;
@ -2071,6 +2073,7 @@ typedef struct {
RETRIEVAL_POINTERS_BUFFER RetrievalPointers;
} ExtentInformation;
} STREAM_EXTENT_ENTRY;
#endif
/* Extract the MFT number part of the full inode number */
#define NTFS_MFT_NO(ref) ((ref) & (((u64)1 << 48) - 1))
@ -2137,13 +2140,13 @@ struct ntfs_inode_map {
#define NTFS_INODE(node) \
avl_tree_entry((node), struct ntfs_inode, index_node)
#define SKIP_ALIGNED(p, size) ((void *)(p) + ALIGN((size), 8))
#define SKIP_ALIGNED(p, size) (_PTR((p) + ALIGN((size), 8)))
/* Get a pointer to the first dentry of the inode. */
#define FIRST_DENTRY(ni) SKIP_ALIGNED((ni), sizeof(struct ntfs_inode))
/* Get a pointer to the first stream of the inode. */
#define FIRST_STREAM(ni) ((const void *)ni + ni->first_stream_offset)
#define FIRST_STREAM(ni) (_PTR(ni + ni->first_stream_offset))
/* Advance to the next dentry of the inode. */
#define NEXT_DENTRY(nd) SKIP_ALIGNED((nd), sizeof(struct ntfs_dentry) + \
@ -2227,7 +2230,7 @@ validate_names_and_compute_total_length(const FILE_LAYOUT_ENTRY *file,
size_t *total_length_ret)
{
const FILE_LAYOUT_NAME_ENTRY *name =
(const void *)file + file->FirstNameOffset;
_PTR(file + file->FirstNameOffset);
size_t total = 0;
size_t num_long_names = 0;
@ -2251,7 +2254,7 @@ validate_names_and_compute_total_length(const FILE_LAYOUT_ENTRY *file,
}
if (name->NextNameOffset == 0)
break;
name = (const void *)name + name->NextNameOffset;
name = _PTR(name + name->NextNameOffset);
}
if (unlikely(num_long_names == 0)) {
@ -2320,7 +2323,7 @@ validate_streams_and_compute_total_length(const FILE_LAYOUT_ENTRY *file,
u32 *special_streams_ret)
{
const STREAM_LAYOUT_ENTRY *stream =
(const void *)file + file->FirstStreamOffset;
_PTR(file + file->FirstStreamOffset);
size_t total = 0;
u32 special_streams = 0;
@ -2352,7 +2355,7 @@ validate_streams_and_compute_total_length(const FILE_LAYOUT_ENTRY *file,
}
if (stream->NextStreamOffset == 0)
break;
stream = (const void *)stream + stream->NextStreamOffset;
stream = _PTR(stream + stream->NextStreamOffset);
}
*total_length_ret = total;
@ -2365,7 +2368,7 @@ load_name_information(const FILE_LAYOUT_ENTRY *file, struct ntfs_inode *ni,
void *p)
{
const FILE_LAYOUT_NAME_ENTRY *name =
(const void *)file + file->FirstNameOffset;
_PTR(file + file->FirstNameOffset);
for (;;) {
struct ntfs_dentry *nd = p;
/* Note that a name may be just a short (DOS) name, just a long
@ -2386,12 +2389,12 @@ load_name_information(const FILE_LAYOUT_ENTRY *file, struct ntfs_inode *ni,
nd->parent_ino = name->ParentFileReferenceNumber;
memcpy(nd->name, name->FileName, name->FileNameLength);
nd->name[name->FileNameLength / 2] = L'\0';
p += ALIGN(sizeof(struct ntfs_dentry) +
name->FileNameLength + sizeof(wchar_t), 8);
p = _PTR(p + ALIGN(sizeof(struct ntfs_dentry) +
name->FileNameLength + sizeof(wchar_t), 8));
}
if (name->NextNameOffset == 0)
break;
name = (const void *)name + name->NextNameOffset;
name = _PTR(name + name->NextNameOffset);
}
return p;
}
@ -2404,7 +2407,7 @@ load_starting_lcn(const STREAM_LAYOUT_ENTRY *stream)
if (stream->ExtentInformationOffset == 0)
return 0;
entry = (const void *)stream + stream->ExtentInformationOffset;
entry = _PTR(stream + stream->ExtentInformationOffset);
if (!(entry->Flags & STREAM_EXTENT_ENTRY_AS_RETRIEVAL_POINTERS))
return 0;
@ -2417,7 +2420,7 @@ load_stream_information(const FILE_LAYOUT_ENTRY *file, struct ntfs_inode *ni,
void *p)
{
const STREAM_LAYOUT_ENTRY *stream =
(const void *)file + file->FirstStreamOffset;
_PTR(file + file->FirstStreamOffset);
const u32 first_stream_offset = (const u8 *)p - (const u8 *)ni;
for (;;) {
struct ntfs_stream *ns = p;
@ -2429,15 +2432,19 @@ load_stream_information(const FILE_LAYOUT_ENTRY *file, struct ntfs_inode *ni,
ni->num_streams++;
if (name_nchars == 0)
ni->starting_lcn = load_starting_lcn(stream);
#ifdef _MSC_VER
ns->size = stream->EndOfFile.QuadPart;
#else
ns->size = stream->EndOfFile;
#endif
wmemcpy(ns->name, name, name_nchars);
ns->name[name_nchars] = L'\0';
p += ALIGN(sizeof(struct ntfs_stream) +
(name_nchars + 1) * sizeof(wchar_t), 8);
p = _PTR(p + ALIGN(sizeof(struct ntfs_stream) +
(name_nchars + 1) * sizeof(wchar_t), 8));
}
if (stream->NextStreamOffset == 0)
break;
stream = (const void *)stream + stream->NextStreamOffset;
stream = _PTR(stream + stream->NextStreamOffset);
}
return p;
}
@ -2447,7 +2454,7 @@ static int
load_one_file(const FILE_LAYOUT_ENTRY *file, struct ntfs_inode_map *inode_map)
{
const FILE_LAYOUT_INFO_ENTRY *info =
(const void *)file + file->ExtraInfoOffset;
_PTR(file + file->ExtraInfoOffset);
size_t inode_size;
struct ntfs_inode *ni;
size_t n;
@ -2485,9 +2492,15 @@ load_one_file(const FILE_LAYOUT_ENTRY *file, struct ntfs_inode_map *inode_map)
ni->ino = file->FileReferenceNumber;
ni->attributes = info->BasicInformation.FileAttributes;
#ifdef _MSC_VER
ni->creation_time = info->BasicInformation.CreationTime.QuadPart;
ni->last_write_time = info->BasicInformation.LastWriteTime.QuadPart;
ni->last_access_time = info->BasicInformation.LastAccessTime.QuadPart;
#else
ni->creation_time = info->BasicInformation.CreationTime;
ni->last_write_time = info->BasicInformation.LastWriteTime;
ni->last_access_time = info->BasicInformation.LastAccessTime;
#endif
ni->security_id = info->SecurityId;
ni->special_streams = special_streams;
@ -2553,14 +2566,14 @@ load_files_from_mft(const wchar_t *path, struct ntfs_inode_map *inode_map)
out, outsize, NULL)))
{
const FILE_LAYOUT_ENTRY *file =
(const void *)out + out->FirstFileOffset;
_PTR(out + out->FirstFileOffset);
for (;;) {
ret = load_one_file(file, inode_map);
if (ret)
goto out;
if (file->NextFileOffset == 0)
break;
file = (const void *)file + file->NextFileOffset;
file = _PTR(file + file->NextFileOffset);
}
in.Flags &= ~QUERY_FILE_LAYOUT_RESTART;
}
@ -2895,7 +2908,7 @@ process_children:
&child,
nd->name,
nd->is_primary,
(void *)nd - nd->offset_from_inode,
_PTR(nd - nd->offset_from_inode),
ctx,
inode_map,
security_map);

32
src/wimlib/win32_common.c
View file

@ -37,7 +37,7 @@ win32_modify_privilege(const wchar_t *privilege, bool enable)
{
HANDLE hToken;
LUID luid;
TOKEN_PRIVILEGES newState;
TOKEN_PRIVILEGES newState = { 0 };
bool ret = FALSE;
if (!OpenProcessToken(GetCurrentProcess(),
@ -94,10 +94,16 @@ NTSTATUS (WINAPI *func_RtlDosPathNameToNtPathName_U_WithStatus)
(IN PCWSTR DosName,
OUT PUNICODE_STRING NtName,
OUT PCWSTR *PartName,
OUT PRTL_RELATIVE_NAME_U RelativeName);
OUT PRTL_RELATIVE_NAME_U RelativeName) = NULL;
BOOLEAN (WINAPI *func_RtlDosPathNameToNtPathName_U)
(IN PCWSTR DosName,
OUT PUNICODE_STRING NtName,
OUT PCWSTR* PartName,
OUT PRTL_RELATIVE_NAME_U RelativeName) = NULL;
NTSTATUS (WINAPI *func_RtlCreateSystemVolumeInformationFolder)
(PCUNICODE_STRING VolumeRootPath);
(PCUNICODE_STRING VolumeRootPath) = NULL;
static bool acquired_privileges = false;
@ -117,9 +123,14 @@ init_ntdll(void)
(void *)GetProcAddress(ntdll_handle,
"RtlDosPathNameToNtPathName_U_WithStatus");
func_RtlDosPathNameToNtPathName_U =
(void*)GetProcAddress(ntdll_handle,
"RtlDosPathNameToNtPathName_U");
func_RtlCreateSystemVolumeInformationFolder =
(void *)GetProcAddress(ntdll_handle,
"RtlCreateSystemVolumeInformationFolder");
return 0;
}
@ -183,11 +194,14 @@ win32_path_to_nt_path(const wchar_t *win32_path, UNICODE_STRING *nt_path)
status = (*func_RtlDosPathNameToNtPathName_U_WithStatus)(win32_path,
nt_path,
NULL, NULL);
} else {
if (RtlDosPathNameToNtPathName_U(win32_path, nt_path, NULL, NULL))
} else if (func_RtlDosPathNameToNtPathName_U) {
if ((*func_RtlDosPathNameToNtPathName_U)(win32_path, nt_path, NULL, NULL))
status = STATUS_SUCCESS;
else
status = STATUS_NO_MEMORY;
} else {
winnt_error(STATUS_UNSUCCESSFUL, L"RtlDosPathNameToNtPathName_U functions not found");
return WIMLIB_ERR_RESOURCE_NOT_FOUND;
}
if (likely(NT_SUCCESS(status)))
@ -269,7 +283,7 @@ static void
windows_msg(u32 code, const wchar_t *format, va_list va,
bool is_ntstatus, bool is_error)
{
wchar_t _buf[STACK_MAX / 8];
wchar_t _buf[STACK_MAX / 8] = { 0 };
wchar_t *buf = _buf;
size_t buflen = ARRAY_LEN(_buf);
size_t ret;
@ -378,14 +392,14 @@ winnt_error(NTSTATUS status, const wchar_t *format, ...)
* permission is, in general, required on the handle.
*/
NTSTATUS
winnt_fsctl(HANDLE h, u32 code, const void *in, u32 in_size,
void *out, u32 out_size_avail, u32 *actual_out_size_ret)
winnt_fsctl(HANDLE h, u32 code, const void* in, u32 in_size,
void* out, u32 out_size_avail, u32* actual_out_size_ret)
{
IO_STATUS_BLOCK iosb;
NTSTATUS status;
status = NtFsControlFile(h, NULL, NULL, NULL, &iosb, code,
(void *)in, in_size, out, out_size_avail);
(void*)in, in_size, out, out_size_avail);
if (status == STATUS_PENDING) {
/* Beware: this case is often encountered with remote
* filesystems, but rarely with local filesystems. */

6
src/wimlib/win32_replacements.c
View file

@ -428,7 +428,7 @@ win32_rename_replacement(const wchar_t *srcpath, const wchar_t *dstpath)
* which on Windows will in fact not actually delete it immediately but
* rather mark it for deletion when the last handle to it is closed. */
{
static const wchar_t orig_suffix[5] = L".orig";
static const wchar_t orig_suffix[] = L".orig";
const size_t num_rand_chars = 9;
wchar_t *p;
@ -477,7 +477,7 @@ do_pread_or_pwrite(int fd, void *buf, size_t count, off_t offset,
HANDLE h;
LARGE_INTEGER orig_offset;
DWORD result = 0xFFFFFFFF;
LARGE_INTEGER relative_offset;
LARGE_INTEGER relative_offset = { 0 };
OVERLAPPED overlapped;
BOOL bret;
DWORD err = 0;
@ -754,7 +754,7 @@ get_random_bytes(void *p, size_t n)
wimlib_assert(0);
count = 0;
}
p += count;
p = _PTR(p + count);
n -= count;
}
}

7
src/wimlib/win32_vss.c
View file

@ -375,7 +375,7 @@ request_vss_snapshot(IVssBackupComponents *vss, wchar_t *volume,
return false;
}
res = vss->vtable->AddToSnapshotSet(vss, volume, (GUID){}, snapshot_id);
res = vss->vtable->AddToSnapshotSet(vss, volume, (GUID){ 0 }, snapshot_id);
if (FAILED(res)) {
ERROR("IVssBackupComponents.AddToSnapshotSet() error: %x",
(u32)res);
@ -496,8 +496,9 @@ vss_create_snapshot(const wchar_t *source, UNICODE_STRING *vss_path_ret,
ret = WIMLIB_ERR_NOMEM;
goto err;
}
wsprintf(vss_path_ret->Buffer, L"\\??\\%ls\\%ls",
swprintf(vss_path_ret->Buffer,
vss_path_ret->MaximumLength / sizeof(wchar_t),
L"\\??\\%ls\\%ls",
&snapshot->props.m_pwszSnapshotDeviceObject[4],
&source_abspath[3]);
*snapshot_ret = &snapshot->base;

12
src/wimlib/write.c
View file

@ -1020,6 +1020,9 @@ write_blob_process_chunk(const struct blob_descriptor *blob, u64 offset,
const u8 *chunkptr, *chunkend;
wimlib_assert(size != 0);
wimlib_assert(ctx);
if (!ctx)
return WIMLIB_ERR_INVALID_PARAM;
if (ctx->compressor == NULL) {
/* Write chunk uncompressed. */
@ -1042,6 +1045,8 @@ write_blob_process_chunk(const struct blob_descriptor *blob, u64 offset,
ret = prepare_chunk_buffer(ctx);
if (ret)
return ret;
if (!ctx->cur_chunk_buf)
return WIMLIB_ERR_INTEGRITY;
}
if (ctx->write_resource_flags & WRITE_RESOURCE_FLAG_SOLID) {
@ -1132,6 +1137,9 @@ compute_blob_list_stats(struct list_head *blob_list,
const struct wim_resource_descriptor *rdesc = blob->rdesc;
WIMStruct *wim = rdesc->wim;
wimlib_assert(wim);
if (!wim)
return WIMLIB_ERR_INVALID_PARAM;
if (prev_wim_part != wim) {
prev_wim_part = wim;
total_parts++;
@ -3247,7 +3255,9 @@ overwrite_wim_via_tmpfile(WIMStruct *wim, int write_flags, unsigned num_threads)
/* Write the WIM to a temporary file in the same directory as the
* original WIM. */
wim_name_len = tstrlen(wim->filename);
tchar tmpfile[wim_name_len + 10];
tchar* tmpfile = alloca((wim_name_len + 10) * sizeof(tchar));
if (!tmpfile)
return WIMLIB_ERR_NOMEM;
tmemcpy(tmpfile, wim->filename, wim_name_len);
get_random_alnum_chars(tmpfile + wim_name_len, 9);
tmpfile[wim_name_len + 9] = T('\0');

7
src/wimlib/xml.c
View file

@ -173,7 +173,12 @@ do_xml_path_walk(struct xml_node *element, const tchar *path, bool create,
struct xml_node **result_ret)
{
size_t n = tstrlen(path) + 1;
#ifdef _RUFUS
wimlib_assert(n < MAX_PATH);
tchar buf[MAX_PATH];
#else
tchar buf[n];
#endif
tchar *p;
tchar c;
@ -1049,7 +1054,7 @@ write_wim_xml_data(WIMStruct *wim, int image, u64 total_bytes,
struct wim_xml_info *info = wim->xml_info;
int ret;
struct xml_node *orig_totalbytes_element;
struct xml_out_buf buf = {};
struct xml_out_buf buf = { 0 };
const utf16lechar *raw_doc;
size_t raw_doc_size;

8
src/wimlib/xml_windows.c
View file

@ -348,10 +348,11 @@ language_id_to_name(u16 id)
return NULL;
}
#ifndef _WIN32
/* PE binary processor architecture codes (common ones only) */
#define IMAGE_FILE_MACHINE_I386 0x014C
#define IMAGE_FILE_MACHINE_ARM 0x01C0
#define IMAGE_FILE_MACHINE_ARMV7 0x01C4
#define IMAGE_FILE_MACHINE_ARMNT 0x01C4
#define IMAGE_FILE_MACHINE_THUMB 0x01C2
#define IMAGE_FILE_MACHINE_IA64 0x0200
#define IMAGE_FILE_MACHINE_AMD64 0x8664
@ -363,6 +364,7 @@ language_id_to_name(u16 id)
#define PROCESSOR_ARCHITECTURE_IA64 6
#define PROCESSOR_ARCHITECTURE_AMD64 9
#define PROCESSOR_ARCHITECTURE_ARM64 12
#endif
/* Translate a processor architecture code as given in a PE binary to the code
* used by the Windows API. Returns -1 if the code is not recognized. */
@ -373,7 +375,7 @@ pe_arch_to_windows_arch(unsigned pe_arch)
case IMAGE_FILE_MACHINE_I386:
return PROCESSOR_ARCHITECTURE_INTEL;
case IMAGE_FILE_MACHINE_ARM:
case IMAGE_FILE_MACHINE_ARMV7:
case IMAGE_FILE_MACHINE_ARMNT:
case IMAGE_FILE_MACHINE_THUMB:
return PROCESSOR_ARCHITECTURE_ARM;
case IMAGE_FILE_MACHINE_IA64:
@ -536,7 +538,7 @@ set_default_language(struct windows_info_ctx *ctx, const struct regf *regf)
const char *language_name = language_id_to_name(language_id);
if (language_name) {
size_t len = strlen(language_name);
tchar tstr[len + 1];
tchar *tstr = alloca((len + 1) * sizeof(tchar));
for (size_t i = 0; i <= len; i++)
tstr[i] = language_name[i];
set_string_property(ctx, T("WINDOWS/LANGUAGES/DEFAULT"),

4
src/wimlib/xmlproc.c
View file

@ -29,6 +29,7 @@
#include <string.h>
#include "wimlib/assert.h"
#include "wimlib/error.h"
#include "wimlib/test_support.h"
#include "wimlib/util.h"
@ -705,6 +706,9 @@ static void
xml_write_element(struct xml_node *element, struct xml_out_buf *buf)
{
struct xml_node *child;
wimlib_assert(element != NULL);
if (element == NULL)
return;
/* Write the start tag. */
xml_puts(buf, T("<"));

10
src/wimlib/xpress_compress.c
View file

@ -98,8 +98,8 @@ struct xpress_item;
struct xpress_compressor {
/* Pointer to the compress() implementation chosen at allocation time */
size_t (*impl)(struct xpress_compressor *,
const void *, size_t, void *, size_t);
size_t (*impl)(struct xpress_compressor * restrict,
const void * restrict, size_t, void *, size_t);
/* Symbol frequency counters for the Huffman code */
u32 freqs[XPRESS_NUM_SYMBOLS];
@ -529,7 +529,7 @@ xpress_compress_greedy(struct xpress_compressor * restrict c,
const u8 * const in_end = in_begin + in_nbytes;
struct xpress_item *next_chosen_item = c->chosen_items;
unsigned len_3_too_far;
u32 next_hashes[2] = {};
u32 next_hashes[2] = { 0 };
if (in_nbytes <= 8192)
len_3_too_far = 2048;
@ -592,7 +592,7 @@ xpress_compress_lazy(struct xpress_compressor * restrict c,
const u8 * const in_end = in_begin + in_nbytes;
struct xpress_item *next_chosen_item = c->chosen_items;
unsigned len_3_too_far;
u32 next_hashes[2] = {};
u32 next_hashes[2] = { 0 };
if (in_nbytes <= 8192)
len_3_too_far = 2048;
@ -907,7 +907,7 @@ xpress_find_matches(struct xpress_compressor * restrict c,
const u8 * const in_begin = in;
const u8 *in_next = in_begin;
struct lz_match *cache_ptr = c->match_cache;
u32 next_hashes[2] = {};
u32 next_hashes[2] = { 0 };
u32 max_len = in_nbytes;
u32 nice_len = min(max_len, c->nice_match_length);

3
src/wimlib/xpress_decompress.c
View file

@ -76,6 +76,7 @@
/* This value is chosen for fast decompression. */
#define XPRESS_TABLEBITS 11
PRAGMA_BEGIN_ALIGN(DECODE_TABLE_ALIGNMENT)
struct xpress_decompressor {
union {
DECODE_TABLE(decode_table, XPRESS_NUM_SYMBOLS,
@ -84,7 +85,7 @@ struct xpress_decompressor {
};
DECODE_TABLE_WORKING_SPACE(working_space, XPRESS_NUM_SYMBOLS,
XPRESS_MAX_CODEWORD_LEN);
} __attribute__((aligned(DECODE_TABLE_ALIGNMENT)));
} PRAGMA_END_ALIGN(DECODE_TABLE_ALIGNMENT);
static int
xpress_decompress(const void *restrict compressed_data, size_t compressed_size,