avr
/
avrdude
mirror of https://github.com/mariusgreuel/avrdude.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add support for Visual Studio 2019

This commit is contained in:
Marius Greuel 2020-01-18 19:05:50 +02:00
parent d4aeff190e
commit a9f311ba84
130 changed files with 32036 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitattributes vendored Normal file
View File

@ -0,0 +1,4 @@
* text=auto eol=lf
*.sln text eol=crlf
*.vcxproj text eol=crlf
*.vcxproj.filters text eol=crlf

67
.gitignore vendored Normal file
View File

@ -0,0 +1,67 @@
.deps
.libs
autom4te.cache
m4
ac_cfg.h
ac_cfg.h.in
aclocal.m4
avrdude
avrdude.conf
avrdude.conf.tmp
avrdude.spec
compile
config.guess
config.log
config.status
config.sub
config_gram.c
config_gram.h
configure
depcomp
INSTALL
install-sh
lexer.c
libtool
ltmain.sh
Makefile
Makefile.in
mdate-sh
mkinstalldirs
missing
stamp-h.in
stamp-h1
texinfo.tex
y.output
y.tab.h
ylwrap
*.o
*.lo
*.a
*.la
*.diff
*.patch
## Ignore Visual Studio build results
# User-specific files
*.suo
*.user
*.userosscache
*.sln.docstates
# Build results
[Dd]ebug/
[Rr]elease/
x64/
x86/
# Visual Studio cache/options directory
.vs/
# Include pre-built files
!ac_cfg.h
!config_gram.c
!config_gram.h
!lexer.c

4
avrdude.h
View File

@ -42,6 +42,10 @@ int avrdude_message(const int msglvl, const char *format, ...);
#include "ac_cfg.h"
#include <windows.h>
#ifdef _MSC_VER
#include "msvc/msvc_compat.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif

61
avrdude.sln Normal file
View File

@ -0,0 +1,61 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.30104.148
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "avrdude", "avrdude.vcxproj", "{718DDC4C-324E-485F-BE18-2D211659A2F4}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libelf", "external\libelf\libelf.vcxproj", "{A2D07885-A0D1-473B-83B2-209CD008EE8F}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libhidapi", "external\libhidapi\libhidapi.vcxproj", "{17054837-6AE6-44D7-914D-9625EDEF4657}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libusb", "external\libusb\libusb.vcxproj", "{22615EC5-9DBC-4538-9C01-2CD535B3810B}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{718DDC4C-324E-485F-BE18-2D211659A2F4}.Debug|x64.ActiveCfg = Debug|x64
{718DDC4C-324E-485F-BE18-2D211659A2F4}.Debug|x64.Build.0 = Debug|x64
{718DDC4C-324E-485F-BE18-2D211659A2F4}.Debug|x86.ActiveCfg = Debug|Win32
{718DDC4C-324E-485F-BE18-2D211659A2F4}.Debug|x86.Build.0 = Debug|Win32
{718DDC4C-324E-485F-BE18-2D211659A2F4}.Release|x64.ActiveCfg = Release|x64
{718DDC4C-324E-485F-BE18-2D211659A2F4}.Release|x64.Build.0 = Release|x64
{718DDC4C-324E-485F-BE18-2D211659A2F4}.Release|x86.ActiveCfg = Release|Win32
{718DDC4C-324E-485F-BE18-2D211659A2F4}.Release|x86.Build.0 = Release|Win32
{A2D07885-A0D1-473B-83B2-209CD008EE8F}.Debug|x64.ActiveCfg = Debug|x64
{A2D07885-A0D1-473B-83B2-209CD008EE8F}.Debug|x64.Build.0 = Debug|x64
{A2D07885-A0D1-473B-83B2-209CD008EE8F}.Debug|x86.ActiveCfg = Debug|Win32
{A2D07885-A0D1-473B-83B2-209CD008EE8F}.Debug|x86.Build.0 = Debug|Win32
{A2D07885-A0D1-473B-83B2-209CD008EE8F}.Release|x64.ActiveCfg = Release|x64
{A2D07885-A0D1-473B-83B2-209CD008EE8F}.Release|x64.Build.0 = Release|x64
{A2D07885-A0D1-473B-83B2-209CD008EE8F}.Release|x86.ActiveCfg = Release|Win32
{A2D07885-A0D1-473B-83B2-209CD008EE8F}.Release|x86.Build.0 = Release|Win32
{17054837-6AE6-44D7-914D-9625EDEF4657}.Debug|x64.ActiveCfg = Debug|x64
{17054837-6AE6-44D7-914D-9625EDEF4657}.Debug|x64.Build.0 = Debug|x64
{17054837-6AE6-44D7-914D-9625EDEF4657}.Debug|x86.ActiveCfg = Debug|Win32
{17054837-6AE6-44D7-914D-9625EDEF4657}.Debug|x86.Build.0 = Debug|Win32
{17054837-6AE6-44D7-914D-9625EDEF4657}.Release|x64.ActiveCfg = Release|x64
{17054837-6AE6-44D7-914D-9625EDEF4657}.Release|x64.Build.0 = Release|x64
{17054837-6AE6-44D7-914D-9625EDEF4657}.Release|x86.ActiveCfg = Release|Win32
{17054837-6AE6-44D7-914D-9625EDEF4657}.Release|x86.Build.0 = Release|Win32
{22615EC5-9DBC-4538-9C01-2CD535B3810B}.Debug|x64.ActiveCfg = Debug|x64
{22615EC5-9DBC-4538-9C01-2CD535B3810B}.Debug|x64.Build.0 = Debug|x64
{22615EC5-9DBC-4538-9C01-2CD535B3810B}.Debug|x86.ActiveCfg = Debug|Win32
{22615EC5-9DBC-4538-9C01-2CD535B3810B}.Debug|x86.Build.0 = Debug|Win32
{22615EC5-9DBC-4538-9C01-2CD535B3810B}.Release|x64.ActiveCfg = Release|x64
{22615EC5-9DBC-4538-9C01-2CD535B3810B}.Release|x64.Build.0 = Release|x64
{22615EC5-9DBC-4538-9C01-2CD535B3810B}.Release|x86.ActiveCfg = Release|Win32
{22615EC5-9DBC-4538-9C01-2CD535B3810B}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {6126B4FE-5EEC-46A7-934A-F3B0314F6B75}
EndGlobalSection
EndGlobal

267
avrdude.vcxproj Normal file
View File

@ -0,0 +1,267 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</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>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
<ProjectGuid>{718DDC4C-324E-485F-BE18-2D211659A2F4}</ProjectGuid>
<RootNamespace>avrdude</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PreprocessorDefinitions>WIN32NATIVE;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;_WINSOCK_DEPRECATED_NO_WARNINGS;LOG_APPNAME="avrdude";WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>msvc;msvc\generated;.;external\libelf\include;external\libhidapi\include;external\libusb\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<WarningLevel>Level3</WarningLevel>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PreprocessorDefinitions>WIN32NATIVE;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;_WINSOCK_DEPRECATED_NO_WARNINGS;LOG_APPNAME="avrdude";_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>msvc;msvc\generated;.;external\libelf\include;external\libhidapi\include;external\libusb\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<WarningLevel>Level3</WarningLevel>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PreprocessorDefinitions>WIN32NATIVE;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;_WINSOCK_DEPRECATED_NO_WARNINGS;LOG_APPNAME="avrdude";WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>msvc;msvc\generated;.;external\libelf\include;external\libhidapi\include;external\libusb\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<WarningLevel>Level3</WarningLevel>
<ConformanceMode>true</ConformanceMode>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<PreprocessorDefinitions>WIN32NATIVE;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;_WINSOCK_DEPRECATED_NO_WARNINGS;LOG_APPNAME="avrdude";NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>msvc;msvc\generated;.;external\libelf\include;external\libhidapi\include;external\libusb\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<WarningLevel>Level3</WarningLevel>
<ConformanceMode>true</ConformanceMode>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="arduino.c" />
<ClCompile Include="avr.c" />
<ClCompile Include="avr910.c" />
<ClCompile Include="avrftdi.c" />
<ClCompile Include="avrftdi_tpi.c" />
<ClCompile Include="avrpart.c" />
<ClCompile Include="bitbang.c" />
<ClCompile Include="buspirate.c" />
<ClCompile Include="butterfly.c" />
<ClCompile Include="config.c" />
<ClCompile Include="confwin.c" />
<ClCompile Include="crc16.c" />
<ClCompile Include="dfu.c" />
<ClCompile Include="fileio.c" />
<ClCompile Include="flip1.c" />
<ClCompile Include="flip2.c" />
<ClCompile Include="ft245r.c" />
<ClCompile Include="jtag3.c" />
<ClCompile Include="jtagmkI.c" />
<ClCompile Include="jtagmkII.c" />
<ClCompile Include="linuxgpio.c" />
<ClCompile Include="lists.c" />
<ClCompile Include="main.c" />
<ClCompile Include="micronucleus.c" />
<ClCompile Include="par.c" />
<ClCompile Include="pgm.c" />
<ClCompile Include="pgm_type.c" />
<ClCompile Include="pickit2.c" />
<ClCompile Include="pindefs.c" />
<ClCompile Include="ppi.c" />
<ClCompile Include="ppiwin.c" />
<ClCompile Include="safemode.c" />
<ClCompile Include="serbb_posix.c" />
<ClCompile Include="serbb_win32.c" />
<ClCompile Include="ser_avrdoper.c" />
<ClCompile Include="ser_posix.c" />
<ClCompile Include="ser_win32.c" />
<ClCompile Include="stk500.c" />
<ClCompile Include="stk500generic.c" />
<ClCompile Include="stk500v2.c" />
<ClCompile Include="term.c" />
<ClCompile Include="update.c" />
<ClCompile Include="usbasp.c" />
<ClCompile Include="usbtiny.c" />
<ClCompile Include="usb_hidapi.c" />
<ClCompile Include="usb_libusb.c" />
<ClCompile Include="wiring.c" />
<ClCompile Include="msvc\generated\config_gram.c" />
<ClCompile Include="msvc\generated\lexer.c">
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">CONFIG_DIR=".";__STDC_VERSION__=199901L;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">CONFIG_DIR=".";__STDC_VERSION__=199901L;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">CONFIG_DIR=".";__STDC_VERSION__=199901L;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">CONFIG_DIR=".";__STDC_VERSION__=199901L;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<ClCompile Include="msvc\getopt.c" />
<ClCompile Include="msvc\gettimeofday.c" />
<ClCompile Include="msvc\unistd.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="arduino.h" />
<ClInclude Include="avr910.h" />
<ClInclude Include="avrdude.h" />
<ClInclude Include="avrftdi.h" />
<ClInclude Include="avrftdi_private.h" />
<ClInclude Include="avrftdi_tpi.h" />
<ClInclude Include="bitbang.h" />
<ClInclude Include="buspirate.h" />
<ClInclude Include="butterfly.h" />
<ClInclude Include="config.h" />
<ClInclude Include="crc16.h" />
<ClInclude Include="dfu.h" />
<ClInclude Include="flip1.h" />
<ClInclude Include="flip2.h" />
<ClInclude Include="freebsd_ppi.h" />
<ClInclude Include="ft245r.h" />
<ClInclude Include="jtag3.h" />
<ClInclude Include="jtag3_private.h" />
<ClInclude Include="jtagmkI.h" />
<ClInclude Include="jtagmkII.h" />
<ClInclude Include="jtagmkII_private.h" />
<ClInclude Include="jtagmkI_private.h" />
<ClInclude Include="libavrdude.h" />
<ClInclude Include="linuxgpio.h" />
<ClInclude Include="linux_ppdev.h" />
<ClInclude Include="micronucleus.h" />
<ClInclude Include="my_ddk_hidsdi.h" />
<ClInclude Include="par.h" />
<ClInclude Include="pickit2.h" />
<ClInclude Include="ppi.h" />
<ClInclude Include="serbb.h" />
<ClInclude Include="ser_win32.h" />
<ClInclude Include="solaris_ecpp.h" />
<ClInclude Include="stk500.h" />
<ClInclude Include="stk500generic.h" />
<ClInclude Include="stk500v2.h" />
<ClInclude Include="stk500v2_private.h" />
<ClInclude Include="stk500_private.h" />
<ClInclude Include="term.h" />
<ClInclude Include="tpi.h" />
<ClInclude Include="usbasp.h" />
<ClInclude Include="usbdevs.h" />
<ClInclude Include="usbtiny.h" />
<ClInclude Include="wiring.h" />
<ClInclude Include="msvc\generated\ac_cfg.h" />
<ClInclude Include="msvc\generated\config_gram.h" />
<ClInclude Include="msvc\getopt.h" />
<ClInclude Include="msvc\msvc_compat.h" />
<ClInclude Include="msvc\sys\time.h" />
<ClInclude Include="msvc\unistd.h" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="external\libelf\libelf.vcxproj">
<Project>{a2d07885-a0d1-473b-83b2-209cd008ee8f}</Project>
</ProjectReference>
<ProjectReference Include="external\libhidapi\libhidapi.vcxproj">
<Project>{17054837-6ae6-44d7-914d-9625edef4657}</Project>
</ProjectReference>
<ProjectReference Include="external\libusb\libusb.vcxproj">
<Project>{22615ec5-9dbc-4538-9c01-2cd535b3810b}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

332
avrdude.vcxproj.filters Normal file
View File

@ -0,0 +1,332 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="2 Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
</Filter>
<Filter Include="1 Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;c++;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="3 Generated Files">
<UniqueIdentifier>{be5ce6e6-223e-4d41-8915-29103d899c5a}</UniqueIdentifier>
</Filter>
<Filter Include="4 msvc">
<UniqueIdentifier>{dbbd7498-e1e9-4d80-b91f-137dc5b988f1}</UniqueIdentifier>
</Filter>
<Filter Include="4 msvc\sys">
<UniqueIdentifier>{1cc9d4fb-f03f-48cb-8af7-3e96681dc03b}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="arduino.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="avr.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="avr910.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="avrftdi.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="avrftdi_tpi.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="avrpart.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="bitbang.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="buspirate.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="butterfly.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="config.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="confwin.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="crc16.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="dfu.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="fileio.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="flip1.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="flip2.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="ft245r.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="jtag3.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="jtagmkI.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="jtagmkII.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="linuxgpio.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="lists.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="main.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="micronucleus.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="par.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="pgm.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="pgm_type.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="pickit2.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="pindefs.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="ppi.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="ppiwin.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="safemode.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="ser_avrdoper.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="ser_posix.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="ser_win32.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="serbb_posix.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="serbb_win32.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="stk500.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="stk500generic.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="stk500v2.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="term.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="update.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="usb_hidapi.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="usb_libusb.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="usbasp.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="usbtiny.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="wiring.c">
<Filter>1 Source Files</Filter>
</ClCompile>
<ClCompile Include="msvc\generated\config_gram.c">
<Filter>3 Generated Files</Filter>
</ClCompile>
<ClCompile Include="msvc\generated\lexer.c">
<Filter>3 Generated Files</Filter>
</ClCompile>
<ClCompile Include="msvc\getopt.c">
<Filter>4 msvc</Filter>
</ClCompile>
<ClCompile Include="msvc\gettimeofday.c">
<Filter>4 msvc</Filter>
</ClCompile>
<ClCompile Include="msvc\unistd.cpp">
<Filter>4 msvc</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="arduino.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="avr910.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="avrdude.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="avrftdi.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="avrftdi_private.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="avrftdi_tpi.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="bitbang.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="buspirate.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="butterfly.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="config.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="crc16.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="dfu.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="flip1.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="flip2.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="freebsd_ppi.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="ft245r.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="jtag3.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="jtag3_private.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="jtagmkI.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="jtagmkI_private.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="jtagmkII.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="jtagmkII_private.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="libavrdude.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="linux_ppdev.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="linuxgpio.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="micronucleus.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="my_ddk_hidsdi.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="par.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="pickit2.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="ppi.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="ser_win32.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="serbb.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="solaris_ecpp.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="stk500.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="stk500_private.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="stk500generic.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="stk500v2.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="stk500v2_private.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="term.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="tpi.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="usbasp.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="usbdevs.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="usbtiny.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="wiring.h">
<Filter>2 Header Files</Filter>
</ClInclude>
<ClInclude Include="msvc\generated\ac_cfg.h">
<Filter>3 Generated Files</Filter>
</ClInclude>
<ClInclude Include="msvc\generated\config_gram.h">
<Filter>3 Generated Files</Filter>
</ClInclude>
<ClInclude Include="msvc\getopt.h">
<Filter>4 msvc</Filter>
</ClInclude>
<ClInclude Include="msvc\unistd.h">
<Filter>4 msvc</Filter>
</ClInclude>
<ClInclude Include="msvc\sys\time.h">
<Filter>4 msvc\sys</Filter>
</ClInclude>
<ClInclude Include="msvc\msvc_compat.h">
<Filter>4 msvc</Filter>
</ClInclude>
</ItemGroup>
</Project>

4
avrftdi_private.h
View File

@ -16,7 +16,11 @@
/* ftdi.h includes usb.h */
#include <ftdi.h>
#else
#ifdef _MSC_VER
#pragma message("No libftdi or libusb support. Install libftdi1/libusb-1.0 or libftdi/libusb and run configure/make again.")
#else
#warning No libftdi or libusb support. Install libftdi1/libusb-1.0 or libftdi/libusb and run configure/make again.
#endif
#define DO_NOT_BUILD_AVRFTDI
#endif

62
clean.bat Normal file
View File

@ -0,0 +1,62 @@
@echo off
rmdir /s /q ".vs" >nul 2>nul
rmdir /s /q "Debug" >nul 2>nul
rmdir /s /q "Release" >nul 2>nul
rmdir /s /q "x64" >nul 2>nul
rmdir /s /q "external\libelf\Debug" >nul 2>nul
rmdir /s /q "external\libelf\Release" >nul 2>nul
rmdir /s /q "external\libelf\x64" >nul 2>nul
rmdir /s /q "external\libhidapi\Debug" >nul 2>nul
rmdir /s /q "external\libhidapi\Release" >nul 2>nul
rmdir /s /q "external\libhidapi\x64" >nul 2>nul
rmdir /s /q "external\libusb\Debug" >nul 2>nul
rmdir /s /q "external\libusb\Release" >nul 2>nul
rmdir /s /q "external\libusb\x64" >nul 2>nul
rmdir /s /q .deps
rmdir /s /q .libs
rmdir /s /q autom4te.cache
rmdir /s /q m4
del ac_cfg.h
del ac_cfg.h.in
del aclocal.m4
del avrdude
del avrdude.conf
del avrdude.conf.tmp
del avrdude.spec
del compile
del config.guess
del config.log
del config.status
del config.sub
del config_gram.c
del config_gram.h
del configure
del depcomp
del INSTALL
del install-sh
del lexer.c
del libtool
del ltmain.sh
del Makefile
del Makefile.in
del mdate-sh
del mkinstalldirs
del missing
del stamp-h.in
del stamp-h1
del texinfo.tex
del y.output
del y.tab.h
del ylwrap
del *.o
del *.lo
del *.a
del *.la
del *.diff
del *.patch

481
external/libelf/COPYING.LIB vendored Normal file
View File

@ -0,0 +1,481 @@
GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
c) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
d) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

1435
external/libelf/ChangeLog vendored Normal file
View File

File diff suppressed because it is too large Load Diff

332
external/libelf/README vendored Normal file
View File

@ -0,0 +1,332 @@
This is the public release of libelf-0.8.13, a free ELF object
file access library. If you have problems with applications
that use libelf and work with the commercial (SVR4, Solaris)
version but not with this one, please contact me.
IMPORTANT NOTE: If you have libelf-0.5.2 installed, you probably
have a file .../include/elf.h that contains the single line
``#include <libelf/elf.h>''. REMOVE THIS FILE BEFORE YOU RUN
configure.
Installation is straightforward - the package is autoconf'ed. Just do
``cd libelf-0.8.13; ./configure; make; make install''. Header files
will be installed in .../include/libelf/. If your system does not
provide its own versions of libelf.h, nlist.h or gelf.h, ``make
install'' will add the missing headers. If you prefer not to have
these files installed in /usr/include, use ``--disable-compat'' and
add ``-I /usr/include/libelf'' to your CFLAGS when compiling
libelf-based programs.
Note to distribution makers: You can install libelf in a separate root
hierarchy by using the command ``make instroot=/my/root install''.
You should also use the ``--enable-compat'' configure option in that
case, or run ``make instroot=/my/root install-compat'' manually, to
install all the required header files.
If you are running Linux with libc 5.* as the default C library,
and you plan to use the 64-bit functions, you must either use
``-I.../include/libelf'', or remove /usr/include/libelf.h and use
``--enable-compat'' when running configure. Libc 6.* (aka glibc2)
doesn't have its own <libelf.h>, <nlist.h> or <gelf.h>.
You need an ANSI/ISO C compiler to build libelf. Gcc is optimal.
On some systems (in particular, Solaris and all variants of Linux),
``make'' will try to build a shared library. If you run into problems
on your system, please pass ``--disable-shared'' to configure.
If you build a shared library and want it to be installed as
``libelf-0.8.13.so'' rather than ``libelf.so.0.8.13'', please use
``./configure --enable-gnu-names''. Other files, e.g. ``libelf.so'' and
``libelf.so.0'' are NOT affected.
Another configure option, ``--enable-debug'', adds debugging code to
libelf; if you don't run into problems, you will probably not need it.
When creating an ELF shared library, it is possible to add references
to other shared libraries in the DYNAMIC section of the resulting
file. The make variable DEPSHLIBS contains a list of libraries to add.
It is set to ``-lc'' on Linux systems, and empty otherwise. To
override this setting, use something like ``make DEPSHLIBS="-la -lb"''.
For Linux, `-lc' is included automagically.
NLS is available and enabled by default. To turn it off, pass the
``--disable-nls'' option to configure.
Libelf can use gettext or catgets for accessing message
catalogs. If gettext is available AND is part of libc (i.e. not
in a separate library), it will be used. Otherwise, configure
will look for catgets. If you have gettext in a separate
library and want to use it, you should pass the library's name
to configure, e.g. ``LIBS=-lintl ./configure''. Note that you
MUST link your libelf-based applications with -lintl then,
which is probably not what you want, or change the DEPSHLIBS variable
described above (in case you're building a shared library).
If you have GNU gettext 0.10 installed on your system, and if GNU gettext
runs on top of the catgets interface (rather old Linux systems, using
libc5), configure will refuse to use it and use catgets instead. If you
absolutely want to use GNU gettext, go ahead and rebuild it (which is
IMHO a good idea in general in this case):
cd .../gettext-0.10
ac_cv_func_catgets=no ac_cv_func_gettext=no ./configure
make
make install
After that, return to the libelf build directory, remove
config.cache, and start over.
*** Large File Support (LFS) applications ***
Some 32-bit systems support files that are larger than the address space
of the architecture. On these, the `off_t' data type may have 32 or
64 bits, depending on the API you choose. Since off_t is also part of
the libelf API, in particular the Elf_Data and Elf_Arhdr structures,
an application compiled with large file support will need a version of
libelf that has also been compiled with LFS; otherwise, it won't work
correctly. Similarly, a program compiled without LFS needs a library
compiled without LFS.
Note that libelf is currently unable to process large files on 32-bit
architectures, whether you compile it for LFS or not, for the simple
reason that the files won't fit into the processes' address space.
Therefore, libelf is compiled without LFS by default. It can of course
read and write ELF files for 64-bit architectures, but they will be
limited in length on a 32-bit system.
You may compile libelf with large file support by setting CPPFLAGS at
configuration time:
CPPFLAGS=`getconf LFS_CFLAGS` ./configure
But I really, really recommend you don't, because it breaks binary
compatibility with existing libelf based applications.
*** 64-bit support ***
Starting with libelf-0.7.0, libelf also supports 64-bit ELF files.
This is enabled by default unless your system (or your compiler) does
not support 64-bit integers, or lacks 64-bit declarations in <elf.h>.
If you have problems building with 64-bit support, please do
./configure --disable-elf64
for the moment, and contact me. Please note that I haven't tested 64-bit
support much. There are still some unresolved problems, e.g. IRIX
uses different Elf64_Rel and Elf64_Rela structures (they replaced the
r_info member), and the enumeration values for Elf_Type differ from
the commercial (SVR4) implementation of libelf - they broke binary
compatibility for no good reason, and I'm not willing to follow their
footsteps. The result is that libelf-0.7.* ist upward compatible with
libelf-0.6.4 (as it should be) but INCOMPATIBLE WITH SVR4 LIBELF. If you
have both versions installed, you'd better make sure that you link with
the library that matches the <libelf.h> you're #include'ing.
*** Symbol Versioning ***
Libelf >= 0.8.0 supports the data structures and definitions used for
symbol versioning on Solaris and Linux, in particular, the Elfxx_Verdef,
Elfxx_Verdaux, Elfxx_Verneed, Elfxx_Vernaux and Elfxx_Versym structures
and the SHT_XXX_verdef, SHT_XXX_verneed and SHT_XXX_versym section types
(where `xx' is either `32' or `64', and `XXX' is either `SUNW' or `GNU').
Libelf now translates versioning sections to/from their external
representation properly (earlier versions left them in `raw' format,
with the data type set to ELF_T_BYTE). This may cause problems on
systems which use the same (OS-specific) section types for different
purposes. The configure program tries to figure out if your OS uses
versioning; if that check fails, you can use
./configure --disable-versioning
to turn off versioning translation support.
*** W32 Support ***
There is now some support for building on W32 systems (requires Microsoft
VC++). In order to build a W32 DLL, cd into the `lib' subdirectory, edit
build.bat if necessary (it needs the path to your compiler binaries) and
run it. If you're lucky, libelf.dll and the import/export libraries will
be built. If not, please drop me a line.
I tested it on XP Pro (SP2), using VC++ 2005 Express Edition.
Apparently, Visual Studio .NET 2003 works fine as well.
Various notes regarding the W32 port:
- When you open() an ELF file, remember to use the O_BINARY flag.
- You may have to add /MD to the linker command line.
*** Missing things ***
* There is no documentation. You can use the Solaris
manpages instead (available at http://docs.sun.com/).
The ELF file format is described in several places;
among them Suns "Linker and Libraries Guide" and the
"System V Application Binary Interface" documents;
http://www.caldera.com/developer/devspecs/gabi41.pdf and
http://www.caldera.com/developer/gabi/ are probably good
starting points. Processor-specific documentation is spread
across a number of `Processor Supplement' documents, one
for each architecture; you'll have to use a search engine to
find them.
* The COFF file format is not understood. This is so obsolete
that it will probably never be implemented.
* nlist(3) is incomplete; the n_type and n_sclass
members of struct nl are set to zero even if type
(that is, debug) information is available.
* Libelf does not translate Solaris' `Move' and `Syminfo'
sections. You can read them using elf_getdata(), but you'll
only get raw (untranslated) bytes.
Changes since 0.8.12:
* New function elf_getaroff().
* Build fixes.
Changes since 0.8.11:
* Due to some unfortunate confusion, the elf_getphnum(),
elf_getshnum() and elf_getshstrndx() are not compatible
between libelf implementations. Therefore, the developers
decided to replace them with new functions: elf_getphdrnum(),
elf_getshdrnum() and elf_getshdrstrndx(), which will always
return -1 on failure and 0 on success. Code using the old
interface should be upgraded to increase portability.
Changes since 0.8.10:
* Fixed a bug in elf_rawfile().
* If you use ELF_F_LAYOUT together with ELF_F_LAYOUT_OVERLAP,
elf_update() will now tolerate overlapping sections.
Changes since 0.8.9:
* Ported to QNX Neutrino.
* Fixed Windows build errors.
* Parallel (make -j) installation should work now.
* It's now possible to enable and disable select sanity checks
libelf performs. Currently, this affects the "NUL terminated
string table entry" check performed in elf_strptr(). By
default, the function will return an error if the string
requested is not properly terminated - because some
applications might dump core otherwise. If you configure
libelf with `--disable-sanity-checks', however, the check
(and, in the future, probably others as well) is disabled
by default. You can still turn it on and off at runtime by
setting the LIBELF_SANITY_CHECKS environment variable to
an integer value:
# disable all sanity checks
export LIBELF_SANITY_CHECKS=0
# enable all sanity checks
export LIBELF_SANITY_CHECKS=-1
Each bit of the value corresponds to a particular check,
so you could use LIBELF_SANITY_CHECKS=1 to enable only
the elf_strptr() check. You may also use a value in hex
(0x...) or octal (0...) format.
Changes since 0.8.8:
* Improved translator for symbol versioning sections.
* The W32 library is now built in the `lib' subdirectory.
* Windows DLLs should work now.
Changes since 0.8.6:
* added elf_getphnum().
* added elf_getshnum().
* added elf_getshstrndx().
* added elfx_update_shstrndx().
* handle interrupted reads/writes more gracefully.
* added (partial) support for unusual e_[ps]hentsize values.
* fixed the bugs introduced in 0.8.7.
Changes since 0.8.5:
* added W32 support.
* added workaround for alignment errors in archive members.
* my email address has changed again ;)
Changes since 0.8.4:
* elf_strptr() should now work more safely with fragmented
or badly formatted string tables.
Changes since 0.8.3:
* Fixed a bug in elf_update() that was introduced in 0.8.3.
Changes since 0.8.2:
* Should compile on MacOSX now.
* Can read and write files with more than 65280 sections
* Tries to handle 64-bit ELF files that use 8-byte hash table
entries. In particular, libelf tries to guess the data type in
elf_getdata(), and doesn't override sh_entsize in elf_update()
any longer. If you want the library to pick the entry size,
you must set its value to 0 before you call elf_update().
* No longer dumps core in elf_update() when a versioning section
has no data. Instead, it returns an error message. Note that
you're supposed to provide a valid d_buf for any section, unless
it's empty or has SHT_NOBITS type.
* Building a shared library is now the default (if supported).
Changes since 0.8.0:
* Corrected typo in lib/{32,64}.xlatetof.c that sometimes
caused a compilation failure.
* Use open(name, O_RDONLY|O_BINARY) in lib/nlist.c.
Changes since 0.7.0:
* I implemented the gelf_* interface, as found on Solaris.
I don't know whether it's compatible -- the Solaris manpage
isn't very specific, so I had to guess return values etc. in
some cases.
* Added elf{32,64}_checksum (supposed to be compatible with
Solaris).
* Added symbol versioning support.
Changes since 0.6.4:
* Fixed configure for IRIX systems
* Added check for truncated archive members
* Added check for misaligned SHDR/PHDR tables
* Support for building libelf together with GNU libc
* Added elf_memory(3)
* Added 64-bit support
Changes since 0.5.2:
* some bug fixes
* mmap support
* new directory layout
* There is a new function, elf_delscn(), that deletes
a section from an ELF file. It also adjusts the
sh_link and sh_info members in the section header
table, if (and ONLY if) the ELF standard indicates
that these values are section indices. References
to the deleted section will be cleared, so be careful.
* my email address has changed ;)
Where to get libelf:
ftp://ftp.ibiblio.org/pub/Linux/libs/
http://www.mr511.de/software/
Michael "Tired" Riepe
<libelf@mr511.de>

1
external/libelf/VERSION vendored Normal file
View File

@ -0,0 +1 @@
0.8.13

305
external/libelf/include/libelf.h vendored Normal file
View File

@ -0,0 +1,305 @@
/*
* libelf.h - public header file for libelf.
* Copyright (C) 1995 - 2008 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/* @(#) $Id: libelf.h,v 1.29 2009/07/07 17:57:43 michael Exp $ */
#ifndef _LIBELF_H
#define _LIBELF_H
#include <stddef.h> /* for size_t */
#include <sys/types.h>
#if __LIBELF_INTERNAL__
#include <sys_elf.h>
#else /* __LIBELF_INTERNAL__ */
#include <libelf/sys_elf.h>
#endif /* __LIBELF_INTERNAL__ */
#if defined __GNUC__ && !defined __cplusplus
#define DEPRECATED __attribute__((deprecated))
#else
#define DEPRECATED /* nothing */
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#ifndef __P
# if (__STDC__ + 0) || defined(__cplusplus) || defined(_WIN32)
# define __P(args) args
# else /* __STDC__ || defined(__cplusplus) */
# define __P(args) ()
# endif /* __STDC__ || defined(__cplusplus) */
#endif /* __P */
/*
* Commands
*/
typedef enum {
ELF_C_NULL = 0, /* must be first, 0 */
ELF_C_READ,
ELF_C_WRITE,
ELF_C_CLR,
ELF_C_SET,
ELF_C_FDDONE,
ELF_C_FDREAD,
ELF_C_RDWR,
ELF_C_NUM /* must be last */
} Elf_Cmd;
/*
* Flags
*/
#define ELF_F_DIRTY 0x1
#define ELF_F_LAYOUT 0x4
/*
* Allow sections to overlap when ELF_F_LAYOUT is in effect.
* Note that this flag ist NOT portable, and that it may render
* the output file unusable. Use with extreme caution!
*/
#define ELF_F_LAYOUT_OVERLAP 0x10000000
/*
* File types
*/
typedef enum {
ELF_K_NONE = 0, /* must be first, 0 */
ELF_K_AR,
ELF_K_COFF,
ELF_K_ELF,
ELF_K_NUM /* must be last */
} Elf_Kind;
/*
* Data types
*/
typedef enum {
ELF_T_BYTE = 0, /* must be first, 0 */
ELF_T_ADDR,
ELF_T_DYN,
ELF_T_EHDR,
ELF_T_HALF,
ELF_T_OFF,
ELF_T_PHDR,
ELF_T_RELA,
ELF_T_REL,
ELF_T_SHDR,
ELF_T_SWORD,
ELF_T_SYM,
ELF_T_WORD,
/*
* New stuff for 64-bit.
*
* Most implementations add ELF_T_SXWORD after ELF_T_SWORD
* which breaks binary compatibility with earlier versions.
* If this causes problems for you, contact me.
*/
ELF_T_SXWORD,
ELF_T_XWORD,
/*
* Symbol versioning. Sun broke binary compatibility (again!),
* but I won't.
*/
ELF_T_VDEF,
ELF_T_VNEED,
ELF_T_NUM /* must be last */
} Elf_Type;
/*
* Elf descriptor
*/
typedef struct Elf Elf;
/*
* Section descriptor
*/
typedef struct Elf_Scn Elf_Scn;
/*
* Archive member header
*/
typedef struct {
char* ar_name;
time_t ar_date;
long ar_uid;
long ar_gid;
unsigned long ar_mode;
off_t ar_size;
char* ar_rawname;
} Elf_Arhdr;
/*
* Archive symbol table
*/
typedef struct {
char* as_name;
size_t as_off;
unsigned long as_hash;
} Elf_Arsym;
/*
* Data descriptor
*/
typedef struct {
void* d_buf;
Elf_Type d_type;
size_t d_size;
off_t d_off;
size_t d_align;
unsigned d_version;
} Elf_Data;
/*
* Function declarations
*/
extern Elf *elf_begin __P((int __fd, Elf_Cmd __cmd, Elf *__ref));
extern Elf *elf_memory __P((char *__image, size_t __size));
extern int elf_cntl __P((Elf *__elf, Elf_Cmd __cmd));
extern int elf_end __P((Elf *__elf));
extern const char *elf_errmsg __P((int __err));
extern int elf_errno __P((void));
extern void elf_fill __P((int __fill));
extern unsigned elf_flagdata __P((Elf_Data *__data, Elf_Cmd __cmd,
unsigned __flags));
extern unsigned elf_flagehdr __P((Elf *__elf, Elf_Cmd __cmd,
unsigned __flags));
extern unsigned elf_flagelf __P((Elf *__elf, Elf_Cmd __cmd,
unsigned __flags));
extern unsigned elf_flagphdr __P((Elf *__elf, Elf_Cmd __cmd,
unsigned __flags));
extern unsigned elf_flagscn __P((Elf_Scn *__scn, Elf_Cmd __cmd,
unsigned __flags));
extern unsigned elf_flagshdr __P((Elf_Scn *__scn, Elf_Cmd __cmd,
unsigned __flags));
extern size_t elf32_fsize __P((Elf_Type __type, size_t __count,
unsigned __ver));
extern Elf_Arhdr *elf_getarhdr __P((Elf *__elf));
extern Elf_Arsym *elf_getarsym __P((Elf *__elf, size_t *__ptr));
extern off_t elf_getbase __P((Elf *__elf));
extern Elf_Data *elf_getdata __P((Elf_Scn *__scn, Elf_Data *__data));
extern Elf32_Ehdr *elf32_getehdr __P((Elf *__elf));
extern char *elf_getident __P((Elf *__elf, size_t *__ptr));
extern Elf32_Phdr *elf32_getphdr __P((Elf *__elf));
extern Elf_Scn *elf_getscn __P((Elf *__elf, size_t __index));
extern Elf32_Shdr *elf32_getshdr __P((Elf_Scn *__scn));
extern unsigned long elf_hash __P((const unsigned char *__name));
extern Elf_Kind elf_kind __P((Elf *__elf));
extern size_t elf_ndxscn __P((Elf_Scn *__scn));
extern Elf_Data *elf_newdata __P((Elf_Scn *__scn));
extern Elf32_Ehdr *elf32_newehdr __P((Elf *__elf));
extern Elf32_Phdr *elf32_newphdr __P((Elf *__elf, size_t __count));
extern Elf_Scn *elf_newscn __P((Elf *__elf));
extern Elf_Cmd elf_next __P((Elf *__elf));
extern Elf_Scn *elf_nextscn __P((Elf *__elf, Elf_Scn *__scn));
extern size_t elf_rand __P((Elf *__elf, size_t __offset));
extern Elf_Data *elf_rawdata __P((Elf_Scn *__scn, Elf_Data *__data));
extern char *elf_rawfile __P((Elf *__elf, size_t *__ptr));
extern char *elf_strptr __P((Elf *__elf, size_t __section, size_t __offset));
extern off_t elf_update __P((Elf *__elf, Elf_Cmd __cmd));
extern unsigned elf_version __P((unsigned __ver));
extern Elf_Data *elf32_xlatetof __P((Elf_Data *__dst, const Elf_Data *__src,
unsigned __encode));
extern Elf_Data *elf32_xlatetom __P((Elf_Data *__dst, const Elf_Data *__src,
unsigned __encode));
/*
* Additional functions found on Solaris
*/
extern long elf32_checksum __P((Elf *__elf));
#if __LIBELF64
/*
* 64-bit ELF functions
* Not available on all platforms
*/
extern Elf64_Ehdr *elf64_getehdr __P((Elf *__elf));
extern Elf64_Ehdr *elf64_newehdr __P((Elf *__elf));
extern Elf64_Phdr *elf64_getphdr __P((Elf *__elf));
extern Elf64_Phdr *elf64_newphdr __P((Elf *__elf, size_t __count));
extern Elf64_Shdr *elf64_getshdr __P((Elf_Scn *__scn));
extern size_t elf64_fsize __P((Elf_Type __type, size_t __count,
unsigned __ver));
extern Elf_Data *elf64_xlatetof __P((Elf_Data *__dst, const Elf_Data *__src,
unsigned __encode));
extern Elf_Data *elf64_xlatetom __P((Elf_Data *__dst, const Elf_Data *__src,
unsigned __encode));
/*
* Additional functions found on Solaris
*/
extern long elf64_checksum __P((Elf *__elf));
#endif /* __LIBELF64 */
/*
* ELF format extensions
*
* These functions return 0 on failure, 1 on success. Since other
* implementations of libelf may behave differently (there was quite
* some confusion about the correct values), they are now officially
* deprecated and should be replaced with the three new functions below.
*/
DEPRECATED extern int elf_getphnum __P((Elf *__elf, size_t *__resultp));
DEPRECATED extern int elf_getshnum __P((Elf *__elf, size_t *__resultp));
DEPRECATED extern int elf_getshstrndx __P((Elf *__elf, size_t *__resultp));
/*
* Replacement functions (return -1 on failure, 0 on success).
*/
extern int elf_getphdrnum __P((Elf *__elf, size_t *__resultp));
extern int elf_getshdrnum __P((Elf *__elf, size_t *__resultp));
extern int elf_getshdrstrndx __P((Elf *__elf, size_t *__resultp));
/*
* Convenience functions
*
* elfx_update_shstrndx is elf_getshstrndx's counterpart.
* It should be used to set the e_shstrndx member.
* There is no update function for e_shnum or e_phnum
* because libelf handles them internally.
*/
extern int elfx_update_shstrndx __P((Elf *__elf, size_t __index));
/*
* Experimental extensions:
*
* elfx_movscn() moves section `__scn' directly after section `__after'.
* elfx_remscn() removes section `__scn'. Both functions update
* the section indices; elfx_remscn() also adjusts the ELF header's
* e_shnum member. The application is responsible for updating other
* data (in particular, e_shstrndx and the section headers' sh_link and
* sh_info members).
*
* elfx_movscn() returns the new index of the moved section.
* elfx_remscn() returns the original index of the removed section.
* A return value of zero indicates an error.
*/
extern size_t elfx_movscn __P((Elf *__elf, Elf_Scn *__scn, Elf_Scn *__after));
extern size_t elfx_remscn __P((Elf *__elf, Elf_Scn *__scn));
/*
* elf_delscn() is obsolete. Please use elfx_remscn() instead.
*/
extern size_t elf_delscn __P((Elf *__elf, Elf_Scn *__scn));
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _LIBELF_H */

996
external/libelf/include/libelf/elf_repl.h vendored Normal file
View File

@ -0,0 +1,996 @@
/*
* elf_repl.h - public header file for systems that lack it.
* Copyright (C) 1995 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/* @(#) $Id: elf_repl.h,v 1.22 2009/11/01 13:04:19 michael Exp $ */
/*
* NEVER INCLUDE THIS FILE DIRECTLY - USE <libelf.h> INSTEAD!
*/
#ifndef _ELF_REPL_H
#define _ELF_REPL_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/*
* Scalar data types
*/
typedef __libelf_u32_t Elf32_Addr;
typedef __libelf_u16_t Elf32_Half;
typedef __libelf_u32_t Elf32_Off;
typedef __libelf_i32_t Elf32_Sword;
typedef __libelf_u32_t Elf32_Word;
#define ELF32_FSZ_ADDR 4
#define ELF32_FSZ_HALF 2
#define ELF32_FSZ_OFF 4
#define ELF32_FSZ_SWORD 4
#define ELF32_FSZ_WORD 4
#if __LIBELF64
typedef __libelf_u64_t Elf64_Addr;
typedef __libelf_u16_t Elf64_Half;
typedef __libelf_u64_t Elf64_Off;
typedef __libelf_i32_t Elf64_Sword;
typedef __libelf_u32_t Elf64_Word;
typedef __libelf_i64_t Elf64_Sxword;
typedef __libelf_u64_t Elf64_Xword;
#define ELF64_FSZ_ADDR 8
#define ELF64_FSZ_HALF 2
#define ELF64_FSZ_OFF 8
#define ELF64_FSZ_SWORD 4
#define ELF64_FSZ_WORD 4
#define ELF64_FSZ_SXWORD 8
#define ELF64_FSZ_XWORD 8
/*
* Blame Sun for this...
*/
typedef __libelf_u64_t Elf64_Lword;
typedef __libelf_u64_t Elf32_Lword;
#endif /* __LIBELF64 */
/*
* ELF header
*/
#define EI_NIDENT 16
typedef struct {
unsigned char e_ident[EI_NIDENT];
Elf32_Half e_type;
Elf32_Half e_machine;
Elf32_Word e_version;
Elf32_Addr e_entry;
Elf32_Off e_phoff;
Elf32_Off e_shoff;
Elf32_Word e_flags;
Elf32_Half e_ehsize;
Elf32_Half e_phentsize;
Elf32_Half e_phnum;
Elf32_Half e_shentsize;
Elf32_Half e_shnum;
Elf32_Half e_shstrndx;
} Elf32_Ehdr;
#if __LIBELF64
typedef struct {
unsigned char e_ident[EI_NIDENT];
Elf64_Half e_type;
Elf64_Half e_machine;
Elf64_Word e_version;
Elf64_Addr e_entry;
Elf64_Off e_phoff;
Elf64_Off e_shoff;
Elf64_Word e_flags;
Elf64_Half e_ehsize;
Elf64_Half e_phentsize;
Elf64_Half e_phnum;
Elf64_Half e_shentsize;
Elf64_Half e_shnum;
Elf64_Half e_shstrndx;
} Elf64_Ehdr;
#endif /* __LIBELF64 */
/*
* e_ident
*/
#define EI_MAG0 0
#define EI_MAG1 1
#define EI_MAG2 2
#define EI_MAG3 3
#define EI_CLASS 4
#define EI_DATA 5
#define EI_VERSION 6
#define EI_OSABI 7
#define EI_ABIVERSION 8
#define EI_PAD 9
#define ELFMAG0 0x7f
#define ELFMAG1 'E'
#define ELFMAG2 'L'
#define ELFMAG3 'F'
#define ELFMAG "\177ELF"
#define SELFMAG 4
/*
* e_ident[EI_CLASS]
*/
#define ELFCLASSNONE 0
#define ELFCLASS32 1
#define ELFCLASS64 2
#define ELFCLASSNUM 3
/*
* e_ident[EI_DATA]
*/
#define ELFDATANONE 0
#define ELFDATA2LSB 1
#define ELFDATA2MSB 2
#define ELFDATANUM 3
/*
* e_ident[EI_OSABI]
*/
#define ELFOSABI_NONE 0 /* No extensions or unspecified */
#define ELFOSABI_SYSV ELFOSABI_NONE
#define ELFOSABI_HPUX 1 /* Hewlett-Packard HP-UX */
#define ELFOSABI_NETBSD 2 /* NetBSD */
#define ELFOSABI_LINUX 3 /* Linux */
#define ELFOSABI_SOLARIS 6 /* Sun Solaris */
#define ELFOSABI_AIX 7 /* AIX */
#define ELFOSABI_IRIX 8 /* IRIX */
#define ELFOSABI_FREEBSD 9 /* FreeBSD */
#define ELFOSABI_TRU64 10 /* Compaq TRU64 UNIX */
#define ELFOSABI_MODESTO 11 /* Novell Modesto */
#define ELFOSABI_OPENBSD 12 /* Open BSD */
#define ELFOSABI_OPENVMS 13 /* Open VMS */
#define ELFOSABI_NSK 14 /* Hewlett-Packard Non-Stop Kernel */
#define ELFOSABI_AROS 15 /* Amiga Research OS */
/* these are probably obsolete: */
#define ELFOSABI_ARM 97 /* ARM */
#define ELFOSABI_STANDALONE 255 /* standalone (embedded) application */
/*
* e_type
*/
#define ET_NONE 0
#define ET_REL 1
#define ET_EXEC 2
#define ET_DYN 3
#define ET_CORE 4
#define ET_NUM 5
#define ET_LOOS 0xfe00
#define ET_HIOS 0xfeff
#define ET_LOPROC 0xff00
#define ET_HIPROC 0xffff
/*
* e_machine
*/
#define EM_NONE 0 /* No machine */
#define EM_M32 1 /* AT&T WE 32100 */
#define EM_SPARC 2 /* SPARC */
#define EM_386 3 /* Intel 80386 */
#define EM_68K 4 /* Motorola 68000 */
#define EM_88K 5 /* Motorola 88000 */
#define EM_486 6 /* Intel i486 (DO NOT USE THIS ONE) */
#define EM_860 7 /* Intel 80860 */
#define EM_MIPS 8 /* MIPS I Architecture */
#define EM_S370 9 /* IBM System/370 Processor */
#define EM_MIPS_RS3_LE 10 /* MIPS RS3000 Little-endian */
#define EM_SPARC64 11 /* SPARC 64-bit */
#define EM_PARISC 15 /* Hewlett-Packard PA-RISC */
#define EM_VPP500 17 /* Fujitsu VPP500 */
#define EM_SPARC32PLUS 18 /* Enhanced instruction set SPARC */
#define EM_960 19 /* Intel 80960 */
#define EM_PPC 20 /* PowerPC */
#define EM_PPC64 21 /* 64-bit PowerPC */
#define EM_S390 22 /* IBM System/390 Processor */
#define EM_V800 36 /* NEC V800 */
#define EM_FR20 37 /* Fujitsu FR20 */
#define EM_RH32 38 /* TRW RH-32 */
#define EM_RCE 39 /* Motorola RCE */
#define EM_ARM 40 /* Advanced RISC Machines ARM */
#define EM_ALPHA 41 /* Digital Alpha */
#define EM_SH 42 /* Hitachi SH */
#define EM_SPARCV9 43 /* SPARC Version 9 */
#define EM_TRICORE 44 /* Siemens TriCore embedded processor */
#define EM_ARC 45 /* Argonaut RISC Core, Argonaut Technologies Inc. */
#define EM_H8_300 46 /* Hitachi H8/300 */
#define EM_H8_300H 47 /* Hitachi H8/300H */
#define EM_H8S 48 /* Hitachi H8S */
#define EM_H8_500 49 /* Hitachi H8/500 */
#define EM_IA_64 50 /* Intel IA-64 processor architecture */
#define EM_MIPS_X 51 /* Stanford MIPS-X */
#define EM_COLDFIRE 52 /* Motorola ColdFire */
#define EM_68HC12 53 /* Motorola M68HC12 */
#define EM_MMA 54 /* Fujitsu MMA Multimedia Accelerator */
#define EM_PCP 55 /* Siemens PCP */
#define EM_NCPU 56 /* Sony nCPU embedded RISC processor */
#define EM_NDR1 57 /* Denso NDR1 microprocessor */
#define EM_STARCORE 58 /* Motorola Star*Core processor */
#define EM_ME16 59 /* Toyota ME16 processor */
#define EM_ST100 60 /* STMicroelectronics ST100 processor */
#define EM_TINYJ 61 /* Advanced Logic Corp. TinyJ embedded processor family */
#define EM_X86_64 62 /* AMD x86-64 architecture */
#define EM_AMD64 EM_X86_64
#define EM_PDSP 63 /* Sony DSP Processor */
#define EM_FX66 66 /* Siemens FX66 microcontroller */
#define EM_ST9PLUS 67 /* STMicroelectronics ST9+ 8/16 bit microcontroller */
#define EM_ST7 68 /* STMicroelectronics ST7 8-bit microcontroller */
#define EM_68HC16 69 /* Motorola MC68HC16 Microcontroller */
#define EM_68HC11 70 /* Motorola MC68HC11 Microcontroller */
#define EM_68HC08 71 /* Motorola MC68HC08 Microcontroller */
#define EM_68HC05 72 /* Motorola MC68HC05 Microcontroller */
#define EM_SVX 73 /* Silicon Graphics SVx */
#define EM_ST19 74 /* STMicroelectronics ST19 8-bit microcontroller */
#define EM_VAX 75 /* Digital VAX */
#define EM_CRIS 76 /* Axis Communications 32-bit embedded processor */
#define EM_JAVELIN 77 /* Infineon Technologies 32-bit embedded processor */
#define EM_FIREPATH 78 /* Element 14 64-bit DSP Processor */
#define EM_ZSP 79 /* LSI Logic 16-bit DSP Processor */
#define EM_MMIX 80 /* Donald Knuth's educational 64-bit processor */
#define EM_HUANY 81 /* Harvard University machine-independent object files */
#define EM_PRISM 82 /* SiTera Prism */
#define EM_AVR 83 /* Atmel AVR 8-bit microcontroller */
#define EM_FR30 84 /* Fujitsu FR30 */
#define EM_D10V 85 /* Mitsubishi D10V */
#define EM_D30V 86 /* Mitsubishi D30V */
#define EM_V850 87 /* NEC v850 */
#define EM_M32R 88 /* Mitsubishi M32R */
#define EM_MN10300 89 /* Matsushita MN10300 */
#define EM_MN10200 90 /* Matsushita MN10200 */
#define EM_PJ 91 /* picoJava */
#define EM_OPENRISC 92 /* OpenRISC 32-bit embedded processor */
#define EM_ARC_A5 93 /* ARC Cores Tangent-A5 */
#define EM_XTENSA 94 /* Tensilica Xtensa Architecture */
#define EM_VIDEOCORE 95 /* Alphamosaic VideoCore processor */
#define EM_TMM_GPP 96 /* Thompson Multimedia General Purpose Processor */
#define EM_NS32K 97 /* National Semiconductor 32000 series */
#define EM_TPC 98 /* Tenor Network TPC processor */
#define EM_SNP1K 99 /* Trebia SNP 1000 processor */
#define EM_ST200 100 /* STMicroelectronics (www.st.com) ST200 microcontroller */
#define EM_IP2K 101 /* Ubicom IP2xxx microcontroller family */
#define EM_MAX 102 /* MAX Processor */
#define EM_CR 103 /* National Semiconductor CompactRISC microprocessor */
#define EM_F2MC16 104 /* Fujitsu F2MC16 */
#define EM_MSP430 105 /* Texas Instruments embedded microcontroller msp430 */
#define EM_BLACKFIN 106 /* Analog Devices Blackfin (DSP) processor */
#define EM_SE_C33 107 /* S1C33 Family of Seiko Epson processors */
#define EM_SEP 108 /* Sharp embedded microprocessor */
#define EM_ARCA 109 /* Arca RISC Microprocessor */
#define EM_UNICORE 110 /* Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University */
#define EM_NUM 111
/*
* e_ident[EI_VERSION], e_version
*/
#define EV_NONE 0
#define EV_CURRENT 1
#define EV_NUM 2
/*
* Section header
*/
typedef struct {
Elf32_Word sh_name;
Elf32_Word sh_type;
Elf32_Word sh_flags;
Elf32_Addr sh_addr;
Elf32_Off sh_offset;
Elf32_Word sh_size;
Elf32_Word sh_link;
Elf32_Word sh_info;
Elf32_Word sh_addralign;
Elf32_Word sh_entsize;
} Elf32_Shdr;
#if __LIBELF64
typedef struct {
Elf64_Word sh_name;
Elf64_Word sh_type;
Elf64_Xword sh_flags;
Elf64_Addr sh_addr;
Elf64_Off sh_offset;
Elf64_Xword sh_size;
Elf64_Word sh_link;
Elf64_Word sh_info;
Elf64_Xword sh_addralign;
Elf64_Xword sh_entsize;
} Elf64_Shdr;
#endif /* __LIBELF64 */
/*
* Special section indices
*/
#define SHN_UNDEF 0
#define SHN_LORESERVE 0xff00
#define SHN_LOPROC 0xff00
#define SHN_HIPROC 0xff1f
#define SHN_LOOS 0xff20
#define SHN_HIOS 0xff3f
#define SHN_ABS 0xfff1
#define SHN_COMMON 0xfff2
#define SHN_XINDEX 0xffff
#define SHN_HIRESERVE 0xffff
/*
* sh_type
*/
#define SHT_NULL 0
#define SHT_PROGBITS 1
#define SHT_SYMTAB 2
#define SHT_STRTAB 3
#define SHT_RELA 4
#define SHT_HASH 5
#define SHT_DYNAMIC 6
#define SHT_NOTE 7
#define SHT_NOBITS 8
#define SHT_REL 9
#define SHT_SHLIB 10
#define SHT_DYNSYM 11
#define SHT_INIT_ARRAY 14
#define SHT_FINI_ARRAY 15
#define SHT_PREINIT_ARRAY 16
#define SHT_GROUP 17
#define SHT_SYMTAB_SHNDX 18
#define SHT_NUM 19
#define SHT_LOOS 0x60000000
#define SHT_HIOS 0x6fffffff
#define SHT_LOPROC 0x70000000
#define SHT_HIPROC 0x7fffffff
#define SHT_LOUSER 0x80000000
#define SHT_HIUSER 0xffffffff
/*
* Solaris extensions
*/
#define SHT_LOSUNW 0x6ffffff4
#define SHT_SUNW_dof 0x6ffffff4
#define SHT_SUNW_cap 0x6ffffff5
#define SHT_SUNW_SIGNATURE 0x6ffffff6
#define SHT_SUNW_ANNOTATE 0x6ffffff7
#define SHT_SUNW_DEBUGSTR 0x6ffffff8
#define SHT_SUNW_DEBUG 0x6ffffff9
#define SHT_SUNW_move 0x6ffffffa
#define SHT_SUNW_COMDAT 0x6ffffffb
#define SHT_SUNW_syminfo 0x6ffffffc
#define SHT_SUNW_verdef 0x6ffffffd
#define SHT_SUNW_verneed 0x6ffffffe
#define SHT_SUNW_versym 0x6fffffff
#define SHT_HISUNW 0x6fffffff
#define SHT_SPARC_GOTDATA 0x70000000
#define SHT_AMD64_UNWIND 0x70000001
/*
* GNU extensions
*/
#define SHT_GNU_verdef 0x6ffffffd
#define SHT_GNU_verneed 0x6ffffffe
#define SHT_GNU_versym 0x6fffffff
/*
* sh_flags
*/
#define SHF_WRITE 0x1
#define SHF_ALLOC 0x2
#define SHF_EXECINSTR 0x4
#define SHF_MERGE 0x10
#define SHF_STRINGS 0x20
#define SHF_INFO_LINK 0x40
#define SHF_LINK_ORDER 0x80
#define SHF_OS_NONCONFORMING 0x100
#define SHF_GROUP 0x200
#define SHF_TLS 0x400
#define SHF_MASKOS 0x0ff00000
#define SHF_MASKPROC 0xf0000000
/*
* Solaris extensions
*/
#define SHF_AMD64_LARGE 0x10000000
#define SHF_ORDERED 0x40000000
#define SHF_EXCLUDE 0x80000000
/*
* Section group flags
*/
#define GRP_COMDAT 0x1
#define GRP_MASKOS 0x0ff00000
#define GRP_MASKPROC 0xf0000000
/*
* Symbol table
*/
typedef struct {
Elf32_Word st_name;
Elf32_Addr st_value;
Elf32_Word st_size;
unsigned char st_info;
unsigned char st_other;
Elf32_Half st_shndx;
} Elf32_Sym;
#if __LIBELF64
typedef struct {
Elf64_Word st_name;
unsigned char st_info;
unsigned char st_other;
Elf64_Half st_shndx;
Elf64_Addr st_value;
Elf64_Xword st_size;
} Elf64_Sym;
#endif /* __LIBELF64 */
/*
* Special symbol indices
*/
#define STN_UNDEF 0
/*
* Macros for manipulating st_info
*/
#define ELF32_ST_BIND(i) ((i)>>4)
#define ELF32_ST_TYPE(i) ((i)&0xf)
#define ELF32_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
#if __LIBELF64
#define ELF64_ST_BIND(i) ((i)>>4)
#define ELF64_ST_TYPE(i) ((i)&0xf)
#define ELF64_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
#endif /* __LIBELF64 */
/*
* Symbol binding
*/
#define STB_LOCAL 0
#define STB_GLOBAL 1
#define STB_WEAK 2
#define STB_NUM 3
#define STB_LOOS 10
#define STB_HIOS 12
#define STB_LOPROC 13
#define STB_HIPROC 15
/*
* Symbol types
*/
#define STT_NOTYPE 0
#define STT_OBJECT 1
#define STT_FUNC 2
#define STT_SECTION 3
#define STT_FILE 4
#define STT_COMMON 5
#define STT_TLS 6
#define STT_NUM 7
#define STT_LOOS 10
#define STT_HIOS 12
#define STT_LOPROC 13
#define STT_HIPROC 15
/*
* Macros for manipulating st_other
*/
#define ELF32_ST_VISIBILITY(o) ((o)&0x3)
#if __LIBELF64
#define ELF64_ST_VISIBILITY(o) ((o)&0x3)
#endif /* __LIBELF64 */
/*
* Symbol visibility
*/
#define STV_DEFAULT 0
#define STV_INTERNAL 1
#define STV_HIDDEN 2
#define STV_PROTECTED 3
/*
* Relocation
*/
typedef struct {
Elf32_Addr r_offset;
Elf32_Word r_info;
} Elf32_Rel;
typedef struct {
Elf32_Addr r_offset;
Elf32_Word r_info;
Elf32_Sword r_addend;
} Elf32_Rela;
#if __LIBELF64
typedef struct {
Elf64_Addr r_offset;
Elf64_Xword r_info;
} Elf64_Rel;
typedef struct {
Elf64_Addr r_offset;
Elf64_Xword r_info;
Elf64_Sxword r_addend;
} Elf64_Rela;
#endif /* __LIBELF64 */
/*
* Macros for manipulating r_info
*/
#define ELF32_R_SYM(i) ((i)>>8)
#define ELF32_R_TYPE(i) ((unsigned char)(i))
#define ELF32_R_INFO(s,t) (((s)<<8)+(unsigned char)(t))
#if __LIBELF64
#define ELF64_R_SYM(i) ((Elf64_Xword)(i)>>32)
#define ELF64_R_TYPE(i) ((i)&0xffffffffL)
#define ELF64_R_INFO(s,t) (((Elf64_Xword)(s)<<32)+((t)&0xffffffffL))
#endif /* __LIBELF64 */
/*
* Note entry header
*/
typedef struct {
Elf32_Word n_namesz; /* name size */
Elf32_Word n_descsz; /* descriptor size */
Elf32_Word n_type; /* descriptor type */
} Elf32_Nhdr;
#if __LIBELF64
/* Solaris and GNU use this layout. Be compatible. */
/* XXX: Latest ELF specs say it's 64-bit!!! */
typedef struct {
Elf64_Word n_namesz; /* name size */
Elf64_Word n_descsz; /* descriptor size */
Elf64_Word n_type; /* descriptor type */
} Elf64_Nhdr;
#endif /* __LIBELF64 */
/*
* Well-known descriptor types for ET_CORE files
*/
#define NT_PRSTATUS 1
#define NT_PRFPREG 2
#define NT_PRPSINFO 3
/*
* Program header
*/
typedef struct {
Elf32_Word p_type;
Elf32_Off p_offset;
Elf32_Addr p_vaddr;
Elf32_Addr p_paddr;
Elf32_Word p_filesz;
Elf32_Word p_memsz;
Elf32_Word p_flags;
Elf32_Word p_align;
} Elf32_Phdr;
#if __LIBELF64
typedef struct {
Elf64_Word p_type;
Elf64_Word p_flags;
Elf64_Off p_offset;
Elf64_Addr p_vaddr;
Elf64_Addr p_paddr;
Elf64_Xword p_filesz;
Elf64_Xword p_memsz;
Elf64_Xword p_align;
} Elf64_Phdr;
#endif /* __LIBELF64 */
/*
* Special numbers
*/
#define PN_XNUM 0xffff
/*
* p_type
*/
#define PT_NULL 0
#define PT_LOAD 1
#define PT_DYNAMIC 2
#define PT_INTERP 3
#define PT_NOTE 4
#define PT_SHLIB 5
#define PT_PHDR 6
#define PT_TLS 7
#define PT_NUM 8
#define PT_LOOS 0x60000000
#define PT_HIOS 0x6fffffff
#define PT_LOPROC 0x70000000
#define PT_HIPROC 0x7fffffff
/*
* Solaris extensions
*/
#define PT_SUNW_UNWIND 0x6464e550
#define PT_LOSUNW 0x6ffffffa
#define PT_SUNWBSS 0x6ffffffa
#define PT_SUNWSTACK 0x6ffffffb
#define PT_SUNWDTRACE 0x6ffffffc
#define PT_SUNWCAP 0x6ffffffd
#define PT_HISUNW 0x6fffffff
/*
* p_flags
*/
#define PF_X 0x1
#define PF_W 0x2
#define PF_R 0x4
#define PF_MASKOS 0x0ff00000
#define PF_MASKPROC 0xf0000000
/*
* Dynamic structure
*/
typedef struct {
Elf32_Sword d_tag;
union {
Elf32_Word d_val;
Elf32_Addr d_ptr;
} d_un;
} Elf32_Dyn;
#if __LIBELF64
typedef struct {
Elf64_Sxword d_tag;
union {
Elf64_Xword d_val;
Elf64_Addr d_ptr;
} d_un;
} Elf64_Dyn;
#endif /* __LIBELF64 */
/*
* Dynamic array tags
*/
/* d_un exec shared */
#define DT_NULL 0 /* ign. mand. mand. */
#define DT_NEEDED 1 /* d_val opt. opt. */
#define DT_PLTRELSZ 2 /* d_val opt. opt. */
#define DT_PLTGOT 3 /* d_ptr opt. opt. */
#define DT_HASH 4 /* d_ptr mand. mand. */
#define DT_STRTAB 5 /* d_ptr mand. mand. */
#define DT_SYMTAB 6 /* d_ptr mand. mand. */
#define DT_RELA 7 /* d_ptr mand. opt. */
#define DT_RELASZ 8 /* d_val mand. opt. */
#define DT_RELAENT 9 /* d_val mand. opt. */
#define DT_STRSZ 10 /* d_val mand. mand. */
#define DT_SYMENT 11 /* d_val mand. mand. */
#define DT_INIT 12 /* d_ptr opt. opt. */
#define DT_FINI 13 /* d_ptr opt. opt. */
#define DT_SONAME 14 /* d_val ign. opt. */
#define DT_RPATH 15 /* d_val opt. ign. */
#define DT_SYMBOLIC 16 /* ign. ign. opt. */
#define DT_REL 17 /* d_ptr mand. opt. */
#define DT_RELSZ 18 /* d_val mand. opt. */
#define DT_RELENT 19 /* d_val mand. opt. */
#define DT_PLTREL 20 /* d_val opt. opt. */
#define DT_DEBUG 21 /* d_ptr opt. ign. */
#define DT_TEXTREL 22 /* ign. opt. opt. */
#define DT_JMPREL 23 /* d_ptr opt. opt. */
#define DT_BIND_NOW 24 /* ign. opt. opt. */
#define DT_INIT_ARRAY 25 /* d_ptr opt. opt. */
#define DT_FINI_ARRAY 26 /* d_ptr opt. opt. */
#define DT_INIT_ARRAYSZ 27 /* d_val opt. opt. */
#define DT_FINI_ARRAYSZ 28 /* d_val opt. opt. */
#define DT_RUNPATH 29 /* d_val opt. opt. */
#define DT_FLAGS 30 /* d_val opt. opt. */
#define DT_ENCODING 32 /* odd/even encoding rule starts here */
#define DT_PREINIT_ARRAY 32 /* d_ptr opt. ign. */
#define DT_PREINIT_ARRAYSZ 33 /* d_val opt. ign. */
#define DT_NUM 34
#define DT_LOOS 0x6000000D
#define DT_HIOS 0x6ffff000
#define DT_LOPROC 0x70000000
#define DT_HIPROC 0x7fffffff
/*
* DT_FLAGS values
*/
#define DF_ORIGIN 0x1
#define DF_SYMBOLIC 0x2
#define DF_TEXTREL 0x4
#define DF_BIND_NOW 0x8
#define DF_STATIC_TLS 0x10
/*
* Solaris extensions
*/
#define DT_VALRNGLO 0x6ffffd00
#define DT_CHECKSUM 0x6ffffdf8
#define DT_PLTPADSZ 0x6ffffdf9
#define DT_MOVEENT 0x6ffffdfa
#define DT_MOVESZ 0x6ffffdfb
#define DT_FEATURE_1 0x6ffffdfc
#define DT_POSFLAG_1 0x6ffffdfd
#define DT_SYMINSZ 0x6ffffdfe
#define DT_SYMINENT 0x6ffffdff
#define DT_VALRNGHI 0x6ffffdff
#define DT_ADDRRNGLO 0x6ffffe00
#define DT_CONFIG 0x6ffffefa
#define DT_DEPAUDIT 0x6ffffefb
#define DT_AUDIT 0x6ffffefc
#define DT_PLTPAD 0x6ffffefd
#define DT_MOVETAB 0x6ffffefe
#define DT_SYMINFO 0x6ffffeff
#define DT_ADDRRNGHI 0x6ffffeff
#define DT_RELACOUNT 0x6ffffff9
#define DT_RELCOUNT 0x6ffffffa
#define DT_FLAGS_1 0x6ffffffb
#define DT_VERDEF 0x6ffffffc
#define DT_VERDEFNUM 0x6ffffffd
#define DT_VERNEED 0x6ffffffe
#define DT_VERNEEDNUM 0x6fffffff
#define DT_AUXILIARY 0x7ffffffd
#define DT_USED 0x7ffffffe
#define DT_FILTER 0x7fffffff
/*
* GNU extensions
*/
#define DT_VERSYM 0x6ffffff0
/*
* DT_FEATURE_1 values
*/
#define DTF_1_PARINIT 0x1
#define DTF_1_CONFEXP 0x2
/*
* DT_POSFLAG_1 values
*/
#define DF_P1_LAZYLOAD 0x1
#define DF_P1_GROUPPERM 0x2
/*
* DT_FLAGS_1 values
*/
#define DF_1_NOW 0x00000001
#define DF_1_GLOBAL 0x00000002
#define DF_1_GROUP 0x00000004
#define DF_1_NODELETE 0x00000008
#define DF_1_LOADFLTR 0x00000010
#define DF_1_INITFIRST 0x00000020
#define DF_1_NOOPEN 0x00000040
#define DF_1_ORIGIN 0x00000080
#define DF_1_DIRECT 0x00000100
#define DF_1_TRANS 0x00000200
#define DF_1_INTERPOSE 0x00000400
#define DF_1_NODEFLIB 0x00000800
#define DF_1_NODUMP 0x00001000
#define DF_1_CONFALT 0x00002000
#define DF_1_ENDFILTEE 0x00004000
#define DF_1_DISPRELDNE 0x00008000
#define DF_1_DISPRELPND 0x00010000
/*
* Syminfo structure
*/
typedef struct {
Elf32_Half si_boundto;
Elf32_Half si_flags;
} Elf32_Syminfo;
#if __LIBELF64
typedef struct {
Elf64_Half si_boundto;
Elf64_Half si_flags;
} Elf64_Syminfo;
#endif /* __LIBELF64 */
/*
* Syminfo version (stored in unused first entry)
*/
#define SYMINFO_NONE 0
#define SYMINFO_CURRENT 1
#define SYMINFO_NUM 2
/*
* si_boundto special values
*/
#define SYMINFO_BT_LOWRESERVE 0xff00
#define SYMINFO_BT_PARENT 0xfffe /* bound to parent */
#define SYMINFO_BT_SELF 0xffff /* bound to self */
/*
* si_flags
*/
#define SYMINFO_FLG_DIRECT 0x01 /* bound to an object */
#define SYMINFO_FLG_PASSTHRU 0x02 /* pass-thru symbol */
#define SYMINFO_FLG_COPY 0x04 /* result of a copy relocation */
#define SYMINFO_FLG_LAZYLOAD 0x08 /* bound to lazy-loaded object */
/*
* Version definitions
*/
typedef struct {
Elf32_Half vd_version;
Elf32_Half vd_flags;
Elf32_Half vd_ndx;
Elf32_Half vd_cnt;
Elf32_Word vd_hash;
Elf32_Word vd_aux;
Elf32_Word vd_next;
} Elf32_Verdef;
typedef struct {
Elf32_Word vda_name;
Elf32_Word vda_next;
} Elf32_Verdaux;
typedef struct {
Elf32_Half vn_version;
Elf32_Half vn_cnt;
Elf32_Word vn_file;
Elf32_Word vn_aux;
Elf32_Word vn_next;
} Elf32_Verneed;
typedef struct {
Elf32_Word vna_hash;
Elf32_Half vna_flags;
Elf32_Half vna_other;
Elf32_Word vna_name;
Elf32_Word vna_next;
} Elf32_Vernaux;
typedef Elf32_Half Elf32_Versym;
#if __LIBELF64
typedef struct {
Elf64_Half vd_version;
Elf64_Half vd_flags;
Elf64_Half vd_ndx;
Elf64_Half vd_cnt;
Elf64_Word vd_hash;
Elf64_Word vd_aux;
Elf64_Word vd_next;
} Elf64_Verdef;
typedef struct {
Elf64_Word vda_name;
Elf64_Word vda_next;
} Elf64_Verdaux;
typedef struct {
Elf64_Half vn_version;
Elf64_Half vn_cnt;
Elf64_Word vn_file;
Elf64_Word vn_aux;
Elf64_Word vn_next;
} Elf64_Verneed;
typedef struct {
Elf64_Word vna_hash;
Elf64_Half vna_flags;
Elf64_Half vna_other;
Elf64_Word vna_name;
Elf64_Word vna_next;
} Elf64_Vernaux;
typedef Elf64_Half Elf64_Versym;
#endif /* __LIBELF64 */
/*
* vd_version
*/
#define VER_DEF_NONE 0
#define VER_DEF_CURRENT 1
#define VER_DEF_NUM 2
/*
* vn_version
*/
#define VER_NEED_NONE 0
#define VER_NEED_CURRENT 1
#define VER_NEED_NUM 2
/*
* vd_flags / vna_flags
*/
#define VER_FLG_BASE 0x1 /* vd_flags only */
#define VER_FLG_WEAK 0x2
/*
* Elf*_Versym special values
*/
#define VER_NDX_LOCAL 0
#define VER_NDX_GLOBAL 1
/*
* Solaris extensions
*/
/*
* Move section
*/
#if __LIBELF64
typedef struct {
Elf32_Lword m_value;
Elf32_Word m_info;
Elf32_Word m_poffset;
Elf32_Half m_repeat;
Elf32_Half m_stride;
} Elf32_Move;
typedef struct {
Elf64_Lword m_value;
Elf64_Xword m_info;
Elf64_Xword m_poffset;
Elf64_Half m_repeat;
Elf64_Half m_stride;
} Elf64_Move;
#define ELF32_M_SYM(info) ((info)>>8)
#define ELF32_M_SIZE(info) ((unsigned char)(info))
#define ELF32_M_INFO(sym, sz) (((sym)<<8)+(unsigned char)(sz))
#define ELF64_M_SYM(info) ((Elf64_Xword)(info)>>8)
#define ELF64_M_SIZE(info) ((unsigned char)(info))
#define ELF64_M_INFO(sym, sz) (((Elf64_Xword)(sym)<<8)+(unsigned char)(sz))
#endif /* __LIBELF64 */
/*
* Capabilities
*/
typedef struct {
Elf32_Word c_tag;
union {
Elf32_Word c_val;
Elf32_Addr c_ptr;
} c_un;
} Elf32_Cap;
#if __LIBELF64
typedef struct {
Elf64_Xword c_tag;
union {
Elf64_Xword c_val;
Elf64_Addr c_ptr;
} c_un;
} Elf64_Cap;
#endif /* __LIBELF64 */
#define CA_SUNW_NULL 0 /* c_un ignored */
#define CA_SUNW_HW_1 1 /* c_un.c_val */
#define CA_SUNW_SF_1 2 /* c_un.c_val */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _ELF_REPL_H */

130
external/libelf/include/libelf/sys_elf.h vendored Normal file
View File

@ -0,0 +1,130 @@
/*
* lib/sys_elf.h.w32 - internal configuration file for W32 port
* Copyright (C) 2004 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* @(#) $Id: sys_elf.h.w32,v 1.2 2006/09/07 15:55:42 michael Exp $
*/
/*
* DO NOT USE THIS IN APPLICATIONS - #include <libelf.h> INSTEAD!
*/
/* Define to `<elf.h>' or `<sys/elf.h>' if one of them is present */
#undef __LIBELF_HEADER_ELF_H
/* Define if Elf32_Dyn is declared in <link.h> */
#undef __LIBELF_NEED_LINK_H
/* Define if Elf32_Dyn is declared in <sys/link.h> */
#undef __LIBELF_NEED_SYS_LINK_H
/* Define if you want 64-bit support (and your system supports it) */
#define __LIBELF64 1
/* Define if you want 64-bit support, and are running IRIX */
#undef __LIBELF64_IRIX
/* Define if you want 64-bit support, and are running Linux */
#undef __LIBELF64_LINUX
/* Define if you want symbol versioning (and your system supports it) */
#define __LIBELF_SYMBOL_VERSIONS 1
/* Define to a 64-bit signed integer type if one exists */
#define __libelf_i64_t __int64
/* Define to a 64-bit unsigned integer type if one exists */
#define __libelf_u64_t unsigned __int64
/* Define to a 32-bit signed integer type if one exists */
#define __libelf_i32_t int
/* Define to a 32-bit unsigned integer type if one exists */
#define __libelf_u32_t unsigned int
/* Define to a 16-bit signed integer type if one exists */
#define __libelf_i16_t short int
/* Define to a 16-bit unsigned integer type if one exists */
#define __libelf_u16_t unsigned short int
/*
* Ok, now get the correct instance of elf.h...
*/
#ifdef __LIBELF_HEADER_ELF_H
# include __LIBELF_HEADER_ELF_H
#else /* __LIBELF_HEADER_ELF_H */
# if __LIBELF_INTERNAL__
# include <elf_repl.h>
# else /* __LIBELF_INTERNAL__ */
# include <libelf/elf_repl.h>
# endif /* __LIBELF_INTERNAL__ */
#endif /* __LIBELF_HEADER_ELF_H */
/*
* On some systems, <elf.h> is severely broken. Try to fix it.
*/
#ifdef __LIBELF_HEADER_ELF_H
# ifndef ELF32_FSZ_ADDR
# define ELF32_FSZ_ADDR 4
# define ELF32_FSZ_HALF 2
# define ELF32_FSZ_OFF 4
# define ELF32_FSZ_SWORD 4
# define ELF32_FSZ_WORD 4
# endif /* ELF32_FSZ_ADDR */
# ifndef STN_UNDEF
# define STN_UNDEF 0
# endif /* STN_UNDEF */
# if __LIBELF64
# ifndef ELF64_FSZ_ADDR
# define ELF64_FSZ_ADDR 8
# define ELF64_FSZ_HALF 2
# define ELF64_FSZ_OFF 8
# define ELF64_FSZ_SWORD 4
# define ELF64_FSZ_WORD 4
# define ELF64_FSZ_SXWORD 8
# define ELF64_FSZ_XWORD 8
# endif /* ELF64_FSZ_ADDR */
# ifndef ELF64_ST_BIND
# define ELF64_ST_BIND(i) ((i)>>4)
# define ELF64_ST_TYPE(i) ((i)&0xf)
# define ELF64_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
# endif /* ELF64_ST_BIND */
# ifndef ELF64_R_SYM
# define ELF64_R_SYM(i) ((Elf64_Xword)(i)>>32)
# define ELF64_R_TYPE(i) ((i)&0xffffffffL)
# define ELF64_R_INFO(s,t) (((Elf64_Xword)(s)<<32)+((t)&0xffffffffL))
# endif /* ELF64_R_SYM */
# if __LIBELF64_LINUX
typedef __libelf_u64_t Elf64_Addr;
typedef __libelf_u16_t Elf64_Half;
typedef __libelf_u64_t Elf64_Off;
typedef __libelf_i32_t Elf64_Sword;
typedef __libelf_u32_t Elf64_Word;
typedef __libelf_i64_t Elf64_Sxword;
typedef __libelf_u64_t Elf64_Xword;
# endif /* __LIBELF64_LINUX */
# endif /* __LIBELF64 */
#endif /* __LIBELF_HEADER_ELF_H */

222
external/libelf/libelf.vcxproj vendored Normal file
View File

@ -0,0 +1,222 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</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\32.fsize.c" />
<ClCompile Include="src\32.getehdr.c" />
<ClCompile Include="src\32.getphdr.c" />
<ClCompile Include="src\32.getshdr.c" />
<ClCompile Include="src\32.newehdr.c" />
<ClCompile Include="src\32.newphdr.c" />
<ClCompile Include="src\32.xlatetof.c" />
<ClCompile Include="src\64.xlatetof.c" />
<ClCompile Include="src\assert.c" />
<ClCompile Include="src\begin.c" />
<ClCompile Include="src\checksum.c" />
<ClCompile Include="src\cntl.c" />
<ClCompile Include="src\cook.c" />
<ClCompile Include="src\data.c" />
<ClCompile Include="src\end.c" />
<ClCompile Include="src\errmsg.c" />
<ClCompile Include="src\errno.c" />
<ClCompile Include="src\fill.c" />
<ClCompile Include="src\flag.c" />
<ClCompile Include="src\gelfehdr.c" />
<ClCompile Include="src\gelfphdr.c" />
<ClCompile Include="src\gelfshdr.c" />
<ClCompile Include="src\gelftrans.c" />
<ClCompile Include="src\getarhdr.c" />
<ClCompile Include="src\getaroff.c" />
<ClCompile Include="src\getarsym.c" />
<ClCompile Include="src\getbase.c" />
<ClCompile Include="src\getdata.c" />
<ClCompile Include="src\getident.c" />
<ClCompile Include="src\getscn.c" />
<ClCompile Include="src\hash.c" />
<ClCompile Include="src\input.c" />
<ClCompile Include="src\kind.c" />
<ClCompile Include="src\memset.c" />
<ClCompile Include="src\ndxscn.c" />
<ClCompile Include="src\newdata.c" />
<ClCompile Include="src\newscn.c" />
<ClCompile Include="src\next.c" />
<ClCompile Include="src\nextscn.c" />
<ClCompile Include="src\nlist.c" />
<ClCompile Include="src\opt.delscn.c" />
<ClCompile Include="src\rand.c" />
<ClCompile Include="src\rawdata.c" />
<ClCompile Include="src\rawfile.c" />
<ClCompile Include="src\strptr.c" />
<ClCompile Include="src\swap64.c" />
<ClCompile Include="src\update.c" />
<ClCompile Include="src\verdef_32_tof.c" />
<ClCompile Include="src\verdef_32_tom.c" />
<ClCompile Include="src\verdef_64_tof.c" />
<ClCompile Include="src\verdef_64_tom.c" />
<ClCompile Include="src\version.c" />
<ClCompile Include="src\x.elfext.c" />
<ClCompile Include="src\x.movscn.c" />
<ClCompile Include="src\x.remscn.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\libelf.h" />
<ClInclude Include="include\libelf\elf_repl.h" />
<ClInclude Include="include\libelf\sys_elf.h" />
<ClInclude Include="src\byteswap.h" />
<ClInclude Include="src\config.h" />
<ClInclude Include="src\errors.h" />
<ClInclude Include="src\ext_types.h" />
<ClInclude Include="src\gelf.h" />
<ClInclude Include="src\nlist.h" />
<ClInclude Include="src\private.h" />
<ClInclude Include="src\verdef.h" />
<ClInclude Include="src\verneed.h" />
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{a2d07885-a0d1-473b-83b2-209cd008ee8f}</ProjectGuid>
<RootNamespace>libelf</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
<ProjectName>libelf</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;HAVE_CONFIG_H=1;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>include;include\libelf;src</AdditionalIncludeDirectories>
<DisableSpecificWarnings>4244;4267;4311</DisableSpecificWarnings>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;HAVE_CONFIG_H=1;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<AdditionalIncludeDirectories>include;include\libelf;src</AdditionalIncludeDirectories>
<DisableSpecificWarnings>4244;4267;4311</DisableSpecificWarnings>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;HAVE_CONFIG_H=1;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>include;include\libelf;src</AdditionalIncludeDirectories>
<DisableSpecificWarnings>4244;4267;4311</DisableSpecificWarnings>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;HAVE_CONFIG_H=1;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<AdditionalIncludeDirectories>include;include\libelf;src</AdditionalIncludeDirectories>
<DisableSpecificWarnings>4244;4267;4311</DisableSpecificWarnings>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

74
external/libelf/libelf.vcxproj.filters vendored Normal file
View File

@ -0,0 +1,74 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<ClCompile Include="src\32.fsize.c" />
<ClCompile Include="src\32.getehdr.c" />
<ClCompile Include="src\32.getphdr.c" />
<ClCompile Include="src\32.getshdr.c" />
<ClCompile Include="src\32.newehdr.c" />
<ClCompile Include="src\32.newphdr.c" />
<ClCompile Include="src\32.xlatetof.c" />
<ClCompile Include="src\64.xlatetof.c" />
<ClCompile Include="src\assert.c" />
<ClCompile Include="src\begin.c" />
<ClCompile Include="src\checksum.c" />
<ClCompile Include="src\cntl.c" />
<ClCompile Include="src\cook.c" />
<ClCompile Include="src\data.c" />
<ClCompile Include="src\end.c" />
<ClCompile Include="src\errmsg.c" />
<ClCompile Include="src\errno.c" />
<ClCompile Include="src\fill.c" />
<ClCompile Include="src\flag.c" />
<ClCompile Include="src\gelfehdr.c" />
<ClCompile Include="src\gelfphdr.c" />
<ClCompile Include="src\gelfshdr.c" />
<ClCompile Include="src\gelftrans.c" />
<ClCompile Include="src\getarhdr.c" />
<ClCompile Include="src\getaroff.c" />
<ClCompile Include="src\getarsym.c" />
<ClCompile Include="src\getbase.c" />
<ClCompile Include="src\getdata.c" />
<ClCompile Include="src\getident.c" />
<ClCompile Include="src\getscn.c" />
<ClCompile Include="src\hash.c" />
<ClCompile Include="src\input.c" />
<ClCompile Include="src\kind.c" />
<ClCompile Include="src\memset.c" />
<ClCompile Include="src\ndxscn.c" />
<ClCompile Include="src\newdata.c" />
<ClCompile Include="src\newscn.c" />
<ClCompile Include="src\next.c" />
<ClCompile Include="src\nextscn.c" />
<ClCompile Include="src\nlist.c" />
<ClCompile Include="src\opt.delscn.c" />
<ClCompile Include="src\rand.c" />
<ClCompile Include="src\rawdata.c" />
<ClCompile Include="src\rawfile.c" />
<ClCompile Include="src\strptr.c" />
<ClCompile Include="src\swap64.c" />
<ClCompile Include="src\update.c" />
<ClCompile Include="src\verdef_32_tof.c" />
<ClCompile Include="src\verdef_32_tom.c" />
<ClCompile Include="src\verdef_64_tof.c" />
<ClCompile Include="src\verdef_64_tom.c" />
<ClCompile Include="src\version.c" />
<ClCompile Include="src\x.elfext.c" />
<ClCompile Include="src\x.movscn.c" />
<ClCompile Include="src\x.remscn.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="src\byteswap.h" />
<ClInclude Include="src\config.h" />
<ClInclude Include="src\errors.h" />
<ClInclude Include="src\ext_types.h" />
<ClInclude Include="src\gelf.h" />
<ClInclude Include="src\nlist.h" />
<ClInclude Include="src\private.h" />
<ClInclude Include="src\verdef.h" />
<ClInclude Include="src\verneed.h" />
<ClInclude Include="include\libelf\elf_repl.h" />
<ClInclude Include="include\libelf\sys_elf.h" />
<ClInclude Include="include\libelf.h" />
</ItemGroup>
</Project>

155
external/libelf/src/32.fsize.c vendored Normal file
View File

@ -0,0 +1,155 @@
/*
32.fsize.c - implementation of the elf{32,64}_fsize(3) functions.
Copyright (C) 1995 - 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <ext_types.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: 32.fsize.c,v 1.13 2008/05/23 08:15:33 michael Exp $";
#endif /* lint */
const size_t
_elf_fmsize[2][EV_CURRENT - EV_NONE][ELF_T_NUM][2] = {
/* ELFCLASS32 */
{
/* version 1 */
{
{ sizeof(unsigned char), sizeof(unsigned char) },
{ sizeof(Elf32_Addr), sizeof(__ext_Elf32_Addr) },
{ sizeof(Elf32_Dyn), sizeof(__ext_Elf32_Dyn) },
{ sizeof(Elf32_Ehdr), sizeof(__ext_Elf32_Ehdr) },
{ sizeof(Elf32_Half), sizeof(__ext_Elf32_Half) },
{ sizeof(Elf32_Off), sizeof(__ext_Elf32_Off) },
{ sizeof(Elf32_Phdr), sizeof(__ext_Elf32_Phdr) },
{ sizeof(Elf32_Rela), sizeof(__ext_Elf32_Rela) },
{ sizeof(Elf32_Rel), sizeof(__ext_Elf32_Rel) },
{ sizeof(Elf32_Shdr), sizeof(__ext_Elf32_Shdr) },
{ sizeof(Elf32_Sword), sizeof(__ext_Elf32_Sword) },
{ sizeof(Elf32_Sym), sizeof(__ext_Elf32_Sym) },
{ sizeof(Elf32_Word), sizeof(__ext_Elf32_Word) },
{ 0, 0 }, /* there is no Elf32_Sxword */
{ 0, 0 }, /* there is no Elf32_Xword */
/* XXX: check Solaris values */
{ 0, 0 }, /* Elf32_Verdef/Verdaux size varies */
{ 0, 0 }, /* Elf32_Verneed/Vernaux size varies */
},
},
#if __LIBELF64
/* ELFCLASS64 */
{
/* version 1 */
{
{ sizeof(unsigned char), sizeof(unsigned char) },
{ sizeof(Elf64_Addr), sizeof(__ext_Elf64_Addr) },
{ sizeof(Elf64_Dyn), sizeof(__ext_Elf64_Dyn) },
{ sizeof(Elf64_Ehdr), sizeof(__ext_Elf64_Ehdr) },
{ sizeof(Elf64_Half), sizeof(__ext_Elf64_Half) },
{ sizeof(Elf64_Off), sizeof(__ext_Elf64_Off) },
{ sizeof(Elf64_Phdr), sizeof(__ext_Elf64_Phdr) },
{ sizeof(Elf64_Rela), sizeof(__ext_Elf64_Rela) },
{ sizeof(Elf64_Rel), sizeof(__ext_Elf64_Rel) },
{ sizeof(Elf64_Shdr), sizeof(__ext_Elf64_Shdr) },
{ sizeof(Elf64_Sword), sizeof(__ext_Elf64_Sword) },
{ sizeof(Elf64_Sym), sizeof(__ext_Elf64_Sym) },
{ sizeof(Elf64_Word), sizeof(__ext_Elf64_Word) },
{ sizeof(Elf64_Sxword), sizeof(__ext_Elf64_Sxword) },
{ sizeof(Elf64_Xword), sizeof(__ext_Elf64_Xword) },
/* XXX: check Solaris values */
{ 0, 0 }, /* Elf64_Verdef/Verdaux size varies */
{ 0, 0 }, /* Elf64_Verneed/Vernaux size varies */
},
},
#endif /* __LIBELF64 */
};
static size_t
_elf_fsize(unsigned cls, Elf_Type type, unsigned ver) {
size_t n = 0;
if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
}
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
else if (!(n = _fsize(cls, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
return n;
}
size_t
elf32_fsize(Elf_Type type, size_t count, unsigned ver) {
return count * _elf_fsize(ELFCLASS32, type, ver);
}
#if __LIBELF64
size_t
elf64_fsize(Elf_Type type, size_t count, unsigned ver) {
return count * _elf_fsize(ELFCLASS64, type, ver);
}
size_t
gelf_fsize(Elf *elf, Elf_Type type, size_t count, unsigned ver) {
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (valid_class(elf->e_class)) {
return count * _elf_fsize(elf->e_class, type, ver);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
}
return 0;
}
/*
* Extension: report memory size
*/
size_t
gelf_msize(Elf *elf, Elf_Type type, size_t count, unsigned ver) {
size_t n;
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (!valid_class(elf->e_class)) {
seterr(ERROR_UNKNOWN_CLASS);
}
else if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
}
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
else if (!(n = _msize(elf->e_class, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
else {
return count * n;
}
}
return 0;
}
#endif /* __LIBELF64 */

56
external/libelf/src/32.getehdr.c vendored Normal file
View File

@ -0,0 +1,56 @@
/*
32.getehdr.c - implementation of the elf{32,64}_getehdr(3) functions.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: 32.getehdr.c,v 1.9 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
char*
_elf_getehdr(Elf *elf, unsigned cls) {
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_class != cls) {
seterr(ERROR_CLASSMISMATCH);
}
else if (elf->e_ehdr || _elf_cook(elf)) {
return elf->e_ehdr;
}
return NULL;
}
Elf32_Ehdr*
elf32_getehdr(Elf *elf) {
return (Elf32_Ehdr*)_elf_getehdr(elf, ELFCLASS32);
}
#if __LIBELF64
Elf64_Ehdr*
elf64_getehdr(Elf *elf) {
return (Elf64_Ehdr*)_elf_getehdr(elf, ELFCLASS64);
}
#endif /* __LIBELF64 */

56
external/libelf/src/32.getphdr.c vendored Normal file
View File

@ -0,0 +1,56 @@
/*
32.getphdr.c - implementation of the elf{32,64}_getphdr(3) functions.
Copyright (C) 1995 - 2000 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: 32.getphdr.c,v 1.11 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
char*
_elf_getphdr(Elf *elf, unsigned cls) {
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_class != cls) {
seterr(ERROR_CLASSMISMATCH);
}
else if (elf->e_ehdr || _elf_cook(elf)) {
return elf->e_phdr;
}
return NULL;
}
Elf32_Phdr*
elf32_getphdr(Elf *elf) {
return (Elf32_Phdr*)_elf_getphdr(elf, ELFCLASS32);
}
#if __LIBELF64
Elf64_Phdr*
elf64_getphdr(Elf *elf) {
return (Elf64_Phdr*)_elf_getphdr(elf, ELFCLASS64);
}
#endif /* __LIBELF64 */

58
external/libelf/src/32.getshdr.c vendored Normal file
View File

@ -0,0 +1,58 @@
/*
32.getshdr.c - implementation of the elf{32,64}_getshdr(3) functions.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: 32.getshdr.c,v 1.10 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
Elf32_Shdr*
elf32_getshdr(Elf_Scn *scn) {
if (!scn) {
return NULL;
}
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(scn->s_elf);
elf_assert(scn->s_elf->e_magic == ELF_MAGIC);
if (scn->s_elf->e_class == ELFCLASS32) {
return &scn->s_shdr32;
}
seterr(ERROR_CLASSMISMATCH);
return NULL;
}
#if __LIBELF64
Elf64_Shdr*
elf64_getshdr(Elf_Scn *scn) {
if (!scn) {
return NULL;
}
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(scn->s_elf);
elf_assert(scn->s_elf->e_magic == ELF_MAGIC);
if (scn->s_elf->e_class == ELFCLASS64) {
return &scn->s_shdr64;
}
seterr(ERROR_CLASSMISMATCH);
return NULL;
}
#endif /* __LIBELF64 */

80
external/libelf/src/32.newehdr.c vendored Normal file
View File

@ -0,0 +1,80 @@
/*
* 32.newehdr.c - implementation of the elf{32,64}_newehdr(3) functions.
* Copyright (C) 1995 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: 32.newehdr.c,v 1.16 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
static char*
_elf_newehdr(Elf *elf, unsigned cls) {
size_t size;
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_readable) {
return _elf_getehdr(elf, cls);
}
else if (!elf->e_ehdr) {
size = _msize(cls, _elf_version, ELF_T_EHDR);
elf_assert(size);
if ((elf->e_ehdr = (char*)malloc(size))) {
memset(elf->e_ehdr, 0, size);
elf->e_ehdr_flags |= ELF_F_DIRTY;
elf->e_kind = ELF_K_ELF;
elf->e_class = cls;
return elf->e_ehdr;
}
seterr(ERROR_MEM_EHDR);
}
else if (elf->e_class != cls) {
seterr(ERROR_CLASSMISMATCH);
}
else {
elf_assert(elf->e_kind == ELF_K_ELF);
return elf->e_ehdr;
}
return NULL;
}
Elf32_Ehdr*
elf32_newehdr(Elf *elf) {
return (Elf32_Ehdr*)_elf_newehdr(elf, ELFCLASS32);
}
#if __LIBELF64
Elf64_Ehdr*
elf64_newehdr(Elf *elf) {
return (Elf64_Ehdr*)_elf_newehdr(elf, ELFCLASS64);
}
unsigned long
gelf_newehdr(Elf *elf, int cls) {
if (!valid_class(cls) || !_msize(cls, _elf_version, ELF_T_EHDR)) {
seterr(ERROR_UNKNOWN_CLASS);
return 0;
}
return (unsigned long)_elf_newehdr(elf, cls);
}
#endif /* __LIBELF64 */

118
external/libelf/src/32.newphdr.c vendored Normal file
View File

@ -0,0 +1,118 @@
/*
* 32.newphdr.c - implementation of the elf{32,64}_newphdr(3) functions.
* Copyright (C) 1995 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: 32.newphdr.c,v 1.16 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
static char*
_elf_newphdr(Elf *elf, size_t count, unsigned cls) {
size_t extcount = 0;
Elf_Scn *scn = NULL;
char *phdr = NULL;
size_t size;
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (!elf->e_ehdr && !elf->e_readable) {
seterr(ERROR_NOEHDR);
}
else if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_class != cls) {
seterr(ERROR_CLASSMISMATCH);
}
else if (elf->e_ehdr || _elf_cook(elf)) {
size = _msize(cls, _elf_version, ELF_T_PHDR);
elf_assert(size);
if (!(scn = _elf_first_scn(elf))) {
return NULL;
}
if (count) {
if (!(phdr = (char*)malloc(count * size))) {
seterr(ERROR_MEM_PHDR);
return NULL;
}
memset(phdr, 0, count * size);
}
elf_assert(elf->e_ehdr);
elf->e_phnum = count;
if (count >= PN_XNUM) {
/*
* get NULL section (create it if necessary)
*/
extcount = count;
count = PN_XNUM;
}
if (cls == ELFCLASS32) {
((Elf32_Ehdr*)elf->e_ehdr)->e_phnum = count;
scn->s_shdr32.sh_info = extcount;
}
#if __LIBELF64
else if (cls == ELFCLASS64) {
((Elf64_Ehdr*)elf->e_ehdr)->e_phnum = count;
scn->s_shdr64.sh_info = extcount;
}
#endif /* __LIBELF64 */
else {
seterr(ERROR_UNIMPLEMENTED);
if (phdr) {
free(phdr);
}
return NULL;
}
if (elf->e_phdr) {
free(elf->e_phdr);
}
elf->e_phdr = phdr;
elf->e_phdr_flags |= ELF_F_DIRTY;
elf->e_ehdr_flags |= ELF_F_DIRTY;
scn->s_scn_flags |= ELF_F_DIRTY;
return phdr;
}
return NULL;
}
Elf32_Phdr*
elf32_newphdr(Elf *elf, size_t count) {
return (Elf32_Phdr*)_elf_newphdr(elf, count, ELFCLASS32);
}
#if __LIBELF64
Elf64_Phdr*
elf64_newphdr(Elf *elf, size_t count) {
return (Elf64_Phdr*)_elf_newphdr(elf, count, ELFCLASS64);
}
unsigned long
gelf_newphdr(Elf *elf, size_t phnum) {
if (!valid_class(elf->e_class)) {
seterr(ERROR_UNKNOWN_CLASS);
return 0;
}
return (unsigned long)_elf_newphdr(elf, phnum, elf->e_class);
}
#endif /* __LIBELF64 */

438
external/libelf/src/32.xlatetof.c vendored Normal file
View File

@ -0,0 +1,438 @@
/*
* 32.xlatetof.c - implementation of the elf32_xlateto[fm](3) functions.
* Copyright (C) 1995 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <ext_types.h>
#include <byteswap.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: 32.xlatetof.c,v 1.27 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
/*
* Ugly, ugly
*/
#ifdef _WIN32
# define Cat2(a,b)a##b
# define Cat3(a,b,c)a##b##c
# define Ex1(m1,m2,a,b)m1##m2(a##b)
# define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
#else /* _WIN32 */
# define x
# if defined/**/x
# define Cat2(a,b)a##b
# define Cat3(a,b,c)a##b##c
# define Ex1(m1,m2,a,b)m1##m2(a##b)
# define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
# else
# define Cat2(a,b)a/**/b
# define Cat3(a,b,c)a/**/b/**/c
# define Ex1(m1,m2,a,b)m1/**/m2(a/**/b)
# define Ex2(m1,m2,a,b,c)m1/**/m2(a,b/**/c)
# endif
# undef x
#endif /* _WIN32 */
/*
* auxiliary macros for execution order reversal
*/
#define seq_forw(a,b) a b
#define seq_back(a,b) b a
/*
* function instantiator
*/
#define copy_type_e_io(name,e,io,tfrom,tto,copy) \
static size_t \
Cat3(name,_,io)(unsigned char *dst, const unsigned char *src, size_t n) { \
n /= sizeof(tfrom); \
if (n && dst) { \
const tfrom *from = (const tfrom*)src; \
tto *to = (tto*)dst; \
size_t i; \
\
if (sizeof(tfrom) < sizeof(tto)) { \
from += n; \
to += n; \
for (i = 0; i < n; i++) { \
--from; \
--to; \
copy(e,io,seq_back) \
} \
} \
else { \
for (i = 0; i < n; i++) { \
copy(e,io,seq_forw) \
from++; \
to++; \
} \
} \
} \
return n * sizeof(tto); \
}
#define copy_type_e(name,e,type,copy) \
copy_type_e_io(name,e,tom,Cat2(__ext_,type),type,copy) \
copy_type_e_io(name,e,tof,type,Cat2(__ext_,type),copy)
/*
* master function instantiator
*/
#define copy_type(name,version,type,copy) \
copy_type_e(Cat3(name,L,version),L,type,copy) \
copy_type_e(Cat3(name,M,version),M,type,copy)
/*
* scalar copying
*/
#define copy_scalar_tom(type) *to = Cat2(__load_,type)(*from);
#define copy_scalar_tof(type) Cat2(__store_,type)(*to, *from);
/*
* structure member copying
*/
#define copy_tom(mb,type) to->mb = Cat2(__load_,type)(from->mb);
#define copy_tof(mb,type) Cat2(__store_,type)(to->mb, from->mb);
/*
* structure member copying (direction independent)
*/
#define copy_byte(e,io,mb) to->mb = from->mb;
#define copy_addr(e,io,mb) Ex2(copy_,io,mb,u32,e)
#define copy_half(e,io,mb) Ex2(copy_,io,mb,u16,e)
#define copy_off(e,io,mb) Ex2(copy_,io,mb,u32,e)
#define copy_sword(e,io,mb) Ex2(copy_,io,mb,i32,e)
#define copy_word(e,io,mb) Ex2(copy_,io,mb,u32,e)
#define copy_arr(e,io,mb) \
array_copy(to->mb, sizeof(to->mb), from->mb, sizeof(from->mb));
/*
* scalar copying (direction independent)
* these macros are used as `copy' arguments to copy_type()
*/
#define copy_addr_11(e,io,seq) Ex1(copy_scalar_,io,u32,e)
#define copy_half_11(e,io,seq) Ex1(copy_scalar_,io,u16,e)
#define copy_off_11(e,io,seq) Ex1(copy_scalar_,io,u32,e)
#define copy_sword_11(e,io,seq) Ex1(copy_scalar_,io,i32,e)
#define copy_word_11(e,io,seq) Ex1(copy_scalar_,io,u32,e)
/*
* structure copying (direction independent)
* these macros are used as `copy' arguments to copy_type()
*/
#define copy_dyn_11(e,io,seq) \
seq(copy_sword(e,io,d_tag), \
seq(copy_addr(e,io,d_un.d_ptr), \
nullcopy))
#define copy_ehdr_11(e,io,seq) \
seq(copy_arr(e,io,e_ident), \
seq(copy_half(e,io,e_type), \
seq(copy_half(e,io,e_machine), \
seq(copy_word(e,io,e_version), \
seq(copy_addr(e,io,e_entry), \
seq(copy_off(e,io,e_phoff), \
seq(copy_off(e,io,e_shoff), \
seq(copy_word(e,io,e_flags), \
seq(copy_half(e,io,e_ehsize), \
seq(copy_half(e,io,e_phentsize), \
seq(copy_half(e,io,e_phnum), \
seq(copy_half(e,io,e_shentsize), \
seq(copy_half(e,io,e_shnum), \
seq(copy_half(e,io,e_shstrndx), \
nullcopy))))))))))))))
#define copy_phdr_11(e,io,seq) \
seq(copy_word(e,io,p_type), \
seq(copy_off(e,io,p_offset), \
seq(copy_addr(e,io,p_vaddr), \
seq(copy_addr(e,io,p_paddr), \
seq(copy_word(e,io,p_filesz), \
seq(copy_word(e,io,p_memsz), \
seq(copy_word(e,io,p_flags), \
seq(copy_word(e,io,p_align), \
nullcopy))))))))
#define copy_rela_11(e,io,seq) \
seq(copy_addr(e,io,r_offset), \
seq(copy_word(e,io,r_info), \
seq(copy_sword(e,io,r_addend), \
nullcopy)))
#define copy_rel_11(e,io,seq) \
seq(copy_addr(e,io,r_offset), \
seq(copy_word(e,io,r_info), \
nullcopy))
#define copy_shdr_11(e,io,seq) \
seq(copy_word(e,io,sh_name), \
seq(copy_word(e,io,sh_type), \
seq(copy_word(e,io,sh_flags), \
seq(copy_addr(e,io,sh_addr), \
seq(copy_off(e,io,sh_offset), \
seq(copy_word(e,io,sh_size), \
seq(copy_word(e,io,sh_link), \
seq(copy_word(e,io,sh_info), \
seq(copy_word(e,io,sh_addralign), \
seq(copy_word(e,io,sh_entsize), \
nullcopy))))))))))
#define copy_sym_11(e,io,seq) \
seq(copy_word(e,io,st_name), \
seq(copy_addr(e,io,st_value), \
seq(copy_word(e,io,st_size), \
seq(copy_byte(e,io,st_info), \
seq(copy_byte(e,io,st_other), \
seq(copy_half(e,io,st_shndx), \
nullcopy))))))
#define nullcopy /**/
static size_t
byte_copy(unsigned char *dst, const unsigned char *src, size_t n) {
if (n && dst && dst != src) {
#if HAVE_BROKEN_MEMMOVE
size_t i;
if (dst >= src + n || dst + n <= src) {
memcpy(dst, src, n);
}
else if (dst < src) {
for (i = 0; i < n; i++) {
dst[i] = src[i];
}
}
else {
for (i = n; --i; ) {
dst[i] = src[i];
}
}
#else /* HAVE_BROKEN_MEMMOVE */
memmove(dst, src, n);
#endif /* HAVE_BROKEN_MEMMOVE */
}
return n;
}
static void
array_copy(unsigned char *dst, size_t dlen, const unsigned char *src, size_t slen) {
byte_copy(dst, src, dlen < slen ? dlen : slen);
if (dlen > slen) {
memset(dst + slen, 0, dlen - slen);
}
}
/*
* instantiate copy functions
*/
copy_type(addr_32,_,Elf32_Addr,copy_addr_11)
copy_type(half_32,_,Elf32_Half,copy_half_11)
copy_type(off_32,_,Elf32_Off,copy_off_11)
copy_type(sword_32,_,Elf32_Sword,copy_sword_11)
copy_type(word_32,_,Elf32_Word,copy_word_11)
copy_type(dyn_32,11,Elf32_Dyn,copy_dyn_11)
copy_type(ehdr_32,11,Elf32_Ehdr,copy_ehdr_11)
copy_type(phdr_32,11,Elf32_Phdr,copy_phdr_11)
copy_type(rela_32,11,Elf32_Rela,copy_rela_11)
copy_type(rel_32,11,Elf32_Rel,copy_rel_11)
copy_type(shdr_32,11,Elf32_Shdr,copy_shdr_11)
copy_type(sym_32,11,Elf32_Sym,copy_sym_11)
typedef size_t (*xlator)(unsigned char*, const unsigned char*, size_t);
typedef xlator xltab[ELF_T_NUM][2];
/*
* translation table (32-bit, version 1 -> version 1)
*/
#if PIC
static xltab
#else /* PIC */
static const xltab
#endif /* PIC */
xlate32_11[/*encoding*/] = {
{
{ byte_copy, byte_copy },
{ addr_32L__tom, addr_32L__tof },
{ dyn_32L11_tom, dyn_32L11_tof },
{ ehdr_32L11_tom, ehdr_32L11_tof },
{ half_32L__tom, half_32L__tof },
{ off_32L__tom, off_32L__tof },
{ phdr_32L11_tom, phdr_32L11_tof },
{ rela_32L11_tom, rela_32L11_tof },
{ rel_32L11_tom, rel_32L11_tof },
{ shdr_32L11_tom, shdr_32L11_tof },
{ sword_32L__tom, sword_32L__tof },
{ sym_32L11_tom, sym_32L11_tof },
{ word_32L__tom, word_32L__tof },
{ 0, 0 }, /* there is no Sxword */
{ 0, 0 }, /* there is no Xword */
#if __LIBELF_SYMBOL_VERSIONS
{ _elf_verdef_32L11_tom, _elf_verdef_32L11_tof },
{ _elf_verneed_32L11_tom, _elf_verneed_32L11_tof },
#else /* __LIBELF_SYMBOL_VERSIONS */
{ 0, 0 },
{ 0, 0 },
#endif /* __LIBELF_SYMBOL_VERSIONS */
},
{
{ byte_copy, byte_copy },
{ addr_32M__tom, addr_32M__tof },
{ dyn_32M11_tom, dyn_32M11_tof },
{ ehdr_32M11_tom, ehdr_32M11_tof },
{ half_32M__tom, half_32M__tof },
{ off_32M__tom, off_32M__tof },
{ phdr_32M11_tom, phdr_32M11_tof },
{ rela_32M11_tom, rela_32M11_tof },
{ rel_32M11_tom, rel_32M11_tof },
{ shdr_32M11_tom, shdr_32M11_tof },
{ sword_32M__tom, sword_32M__tof },
{ sym_32M11_tom, sym_32M11_tof },
{ word_32M__tom, word_32M__tof },
{ 0, 0 }, /* there is no Sxword */
{ 0, 0 }, /* there is no Xword */
#if __LIBELF_SYMBOL_VERSIONS
{ _elf_verdef_32M11_tom, _elf_verdef_32M11_tof },
{ _elf_verneed_32M11_tom, _elf_verneed_32M11_tof },
#else /* __LIBELF_SYMBOL_VERSIONS */
{ 0, 0 },
{ 0, 0 },
#endif /* __LIBELF_SYMBOL_VERSIONS */
},
};
/*
* main translation table (32-bit)
*/
#if PIC
static xltab*
#else /* PIC */
static const xltab *const
#endif /* PIC */
xlate32[EV_CURRENT - EV_NONE][EV_CURRENT - EV_NONE] = {
{ xlate32_11, },
};
#define translator(sv,dv,enc,type,d) \
(xlate32[(sv) - EV_NONE - 1] \
[(dv) - EV_NONE - 1] \
[(enc) - ELFDATA2LSB] \
[(type) - ELF_T_BYTE] \
[d])
/*
* destination buffer size
*/
size_t
_elf32_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) {
Elf_Type type = src->d_type;
unsigned sv = src->d_version;
xlator op;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return (size_t)-1;
}
if (tof) {
/*
* Encoding doesn't really matter (the translator only looks at
* the source, which resides in memory), but we need a proper
* encoding to select a translator...
*/
encode = ELFDATA2LSB;
}
else if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return (size_t)-1;
}
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
if (!(op = translator(sv, dv, encode, type, tof))) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
return (*op)(NULL, src->d_buf, src->d_size);
}
/*
* direction-independent translation
*/
static Elf_Data*
elf32_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
Elf_Type type;
int dv;
int sv;
size_t dsize;
size_t tmp;
xlator op;
if (!src || !dst) {
return NULL;
}
if (!src->d_buf || !dst->d_buf) {
seterr(ERROR_NULLBUF);
return NULL;
}
if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return NULL;
}
sv = src->d_version;
dv = dst->d_version;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return NULL;
}
type = src->d_type;
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
op = translator(sv, dv, encode, type, tof);
if (!op) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
dsize = (*op)(NULL, src->d_buf, src->d_size);
if (dsize == (size_t)-1) {
return NULL;
}
if (dst->d_size < dsize) {
seterr(ERROR_DST2SMALL);
return NULL;
}
if (dsize) {
tmp = (*op)(dst->d_buf, src->d_buf, src->d_size);
if (tmp == (size_t)-1) {
return NULL;
}
elf_assert(tmp == dsize);
}
dst->d_size = dsize;
dst->d_type = type;
return dst;
}
/*
* finally, the "official" translation functions
*/
Elf_Data*
elf32_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
return elf32_xlate(dst, src, encode, 0);
}
Elf_Data*
elf32_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
return elf32_xlate(dst, src, encode, 1);
}

512
external/libelf/src/64.xlatetof.c vendored Normal file
View File

@ -0,0 +1,512 @@
/*
* 64.xlatetof.c - implementation of the elf64_xlateto[fm](3) functions.
* Copyright (C) 1995 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <ext_types.h>
#include <byteswap.h>
#if __LIBELF64
#ifndef lint
static const char rcsid[] = "@(#) $Id: 64.xlatetof.c,v 1.27 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
/*
* Ugly, ugly
*/
#ifdef _WIN32
# define Cat2(a,b)a##b
# define Cat3(a,b,c)a##b##c
# define Ex1(m1,m2,a,b)m1##m2(a##b)
# define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
#else /* _WIN32 */
# define x
# if defined/**/x
# define Cat2(a,b)a##b
# define Cat3(a,b,c)a##b##c
# define Ex1(m1,m2,a,b)m1##m2(a##b)
# define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
# else
# define Cat2(a,b)a/**/b
# define Cat3(a,b,c)a/**/b/**/c
# define Ex1(m1,m2,a,b)m1/**/m2(a/**/b)
# define Ex2(m1,m2,a,b,c)m1/**/m2(a,b/**/c)
# endif
# undef x
#endif /* _WIN32 */
/*
* auxiliary macros for execution order reversal
*/
#define seq_forw(a,b) a b
#define seq_back(a,b) b a
/*
* function instantiator
*/
#define copy_type_e_io(name,e,io,tfrom,tto,copy) \
static size_t \
Cat3(name,_,io)(unsigned char *dst, const unsigned char *src, size_t n) { \
n /= sizeof(tfrom); \
if (n && dst) { \
const tfrom *from = (const tfrom*)src; \
tto *to = (tto*)dst; \
size_t i; \
\
if (sizeof(tfrom) < sizeof(tto)) { \
from += n; \
to += n; \
for (i = 0; i < n; i++) { \
--from; \
--to; \
copy(e,io,seq_back) \
} \
} \
else { \
for (i = 0; i < n; i++) { \
copy(e,io,seq_forw) \
from++; \
to++; \
} \
} \
} \
return n * sizeof(tto); \
}
#define copy_type_e(name,e,type,copy) \
copy_type_e_io(name,e,tom,Cat2(__ext_,type),type,copy) \
copy_type_e_io(name,e,tof,type,Cat2(__ext_,type),copy)
/*
* master function instantiator
*/
#define copy_type(name,version,type,copy) \
copy_type_e(Cat3(name,L,version),L,type,copy) \
copy_type_e(Cat3(name,M,version),M,type,copy)
/*
* scalar copying
*/
#define copy_scalar_tom(type) *to = Cat2(__load_,type)(*from);
#define copy_scalar_tof(type) Cat2(__store_,type)(*to, *from);
/*
* structure member copying
*/
#define copy_tom(mb,type) to->mb = Cat2(__load_,type)(from->mb);
#define copy_tof(mb,type) Cat2(__store_,type)(to->mb, from->mb);
/*
* structure member copying (direction independent)
*/
#define copy_byte(e,io,mb) to->mb = from->mb;
#define copy_addr(e,io,mb) Ex2(copy_,io,mb,u64,e)
#define copy_half(e,io,mb) Ex2(copy_,io,mb,u16,e)
#define copy_off(e,io,mb) Ex2(copy_,io,mb,u64,e)
#define copy_sword(e,io,mb) Ex2(copy_,io,mb,i32,e)
#define copy_word(e,io,mb) Ex2(copy_,io,mb,u32,e)
#define copy_sxword(e,io,mb) Ex2(copy_,io,mb,i64,e)
#define copy_xword(e,io,mb) Ex2(copy_,io,mb,u64,e)
#define copy_arr(e,io,mb) \
array_copy(to->mb, sizeof(to->mb), from->mb, sizeof(from->mb));
/*
* scalar copying (direction independent)
* these macros are used as `copy' arguments to copy_type()
*/
#define copy_addr_11(e,io,seq) Ex1(copy_scalar_,io,u64,e)
#define copy_half_11(e,io,seq) Ex1(copy_scalar_,io,u16,e)
#define copy_off_11(e,io,seq) Ex1(copy_scalar_,io,u64,e)
#define copy_sword_11(e,io,seq) Ex1(copy_scalar_,io,i32,e)
#define copy_word_11(e,io,seq) Ex1(copy_scalar_,io,u32,e)
#define copy_sxword_11(e,io,seq)Ex1(copy_scalar_,io,i64,e)
#define copy_xword_11(e,io,seq) Ex1(copy_scalar_,io,u64,e)
/*
* structure copying (direction independent)
* these macros are used as `copy' arguments to copy_type()
*/
#define copy_dyn_11(e,io,seq) \
seq(copy_xword(e,io,d_tag), \
seq(copy_addr(e,io,d_un.d_ptr), \
nullcopy))
#define copy_ehdr_11(e,io,seq) \
seq(copy_arr(e,io,e_ident), \
seq(copy_half(e,io,e_type), \
seq(copy_half(e,io,e_machine), \
seq(copy_word(e,io,e_version), \
seq(copy_addr(e,io,e_entry), \
seq(copy_off(e,io,e_phoff), \
seq(copy_off(e,io,e_shoff), \
seq(copy_word(e,io,e_flags), \
seq(copy_half(e,io,e_ehsize), \
seq(copy_half(e,io,e_phentsize), \
seq(copy_half(e,io,e_phnum), \
seq(copy_half(e,io,e_shentsize), \
seq(copy_half(e,io,e_shnum), \
seq(copy_half(e,io,e_shstrndx), \
nullcopy))))))))))))))
#define copy_phdr_11(e,io,seq) \
seq(copy_word(e,io,p_type), \
seq(copy_word(e,io,p_flags), \
seq(copy_off(e,io,p_offset), \
seq(copy_addr(e,io,p_vaddr), \
seq(copy_addr(e,io,p_paddr), \
seq(copy_xword(e,io,p_filesz), \
seq(copy_xword(e,io,p_memsz), \
seq(copy_xword(e,io,p_align), \
nullcopy))))))))
#if __LIBELF64_IRIX
#define copy_rela_11(e,io,seq) \
seq(copy_addr(e,io,r_offset), \
seq(copy_word(e,io,r_sym), \
seq(copy_byte(e,io,r_ssym), \
seq(copy_byte(e,io,r_type3), \
seq(copy_byte(e,io,r_type2), \
seq(copy_byte(e,io,r_type), \
seq(copy_sxword(e,io,r_addend), \
nullcopy)))))))
#define copy_rel_11(e,io,seq) \
seq(copy_addr(e,io,r_offset), \
seq(copy_word(e,io,r_sym), \
seq(copy_byte(e,io,r_ssym), \
seq(copy_byte(e,io,r_type3), \
seq(copy_byte(e,io,r_type2), \
seq(copy_byte(e,io,r_type), \
nullcopy))))))
#else /* __LIBELF64_IRIX */
#define copy_rela_11(e,io,seq) \
seq(copy_addr(e,io,r_offset), \
seq(copy_xword(e,io,r_info), \
seq(copy_sxword(e,io,r_addend), \
nullcopy)))
#define copy_rel_11(e,io,seq) \
seq(copy_addr(e,io,r_offset), \
seq(copy_xword(e,io,r_info), \
nullcopy))
#endif /* __LIBELF64_IRIX */
#define copy_shdr_11(e,io,seq) \
seq(copy_word(e,io,sh_name), \
seq(copy_word(e,io,sh_type), \
seq(copy_xword(e,io,sh_flags), \
seq(copy_addr(e,io,sh_addr), \
seq(copy_off(e,io,sh_offset), \
seq(copy_xword(e,io,sh_size), \
seq(copy_word(e,io,sh_link), \
seq(copy_word(e,io,sh_info), \
seq(copy_xword(e,io,sh_addralign), \
seq(copy_xword(e,io,sh_entsize), \
nullcopy))))))))))
#define copy_sym_11(e,io,seq) \
seq(copy_word(e,io,st_name), \
seq(copy_byte(e,io,st_info), \
seq(copy_byte(e,io,st_other), \
seq(copy_half(e,io,st_shndx), \
seq(copy_addr(e,io,st_value), \
seq(copy_xword(e,io,st_size), \
nullcopy))))))
#define nullcopy /**/
static size_t
byte_copy(unsigned char *dst, const unsigned char *src, size_t n) {
if (n && dst && dst != src) {
#if HAVE_BROKEN_MEMMOVE
size_t i;
if (dst >= src + n || dst + n <= src) {
memcpy(dst, src, n);
}
else if (dst < src) {
for (i = 0; i < n; i++) {
dst[i] = src[i];
}
}
else {
for (i = n; --i; ) {
dst[i] = src[i];
}
}
#else /* HAVE_BROKEN_MEMMOVE */
memmove(dst, src, n);
#endif /* HAVE_BROKEN_MEMMOVE */
}
return n;
}
static void
array_copy(unsigned char *dst, size_t dlen, const unsigned char *src, size_t slen) {
byte_copy(dst, src, dlen < slen ? dlen : slen);
if (dlen > slen) {
memset(dst + slen, 0, dlen - slen);
}
}
/*
* instantiate copy functions
*/
copy_type(addr_64,_,Elf64_Addr,copy_addr_11)
copy_type(half_64,_,Elf64_Half,copy_half_11)
copy_type(off_64,_,Elf64_Off,copy_off_11)
copy_type(sword_64,_,Elf64_Sword,copy_sword_11)
copy_type(word_64,_,Elf64_Word,copy_word_11)
copy_type(sxword_64,_,Elf64_Sxword,copy_sxword_11)
copy_type(xword_64,_,Elf64_Xword,copy_xword_11)
copy_type(dyn_64,11,Elf64_Dyn,copy_dyn_11)
copy_type(ehdr_64,11,Elf64_Ehdr,copy_ehdr_11)
copy_type(phdr_64,11,Elf64_Phdr,copy_phdr_11)
copy_type(rela_64,11,Elf64_Rela,copy_rela_11)
copy_type(rel_64,11,Elf64_Rel,copy_rel_11)
copy_type(shdr_64,11,Elf64_Shdr,copy_shdr_11)
copy_type(sym_64,11,Elf64_Sym,copy_sym_11)
typedef size_t (*xlator)(unsigned char*, const unsigned char*, size_t);
typedef xlator xltab[ELF_T_NUM][2];
/*
* translation table (64-bit, version 1 -> version 1)
*/
#if PIC
static xltab
#else /* PIC */
static const xltab
#endif /* PIC */
xlate64_11[/*encoding*/] = {
{
{ byte_copy, byte_copy },
{ addr_64L__tom, addr_64L__tof },
{ dyn_64L11_tom, dyn_64L11_tof },
{ ehdr_64L11_tom, ehdr_64L11_tof },
{ half_64L__tom, half_64L__tof },
{ off_64L__tom, off_64L__tof },
{ phdr_64L11_tom, phdr_64L11_tof },
{ rela_64L11_tom, rela_64L11_tof },
{ rel_64L11_tom, rel_64L11_tof },
{ shdr_64L11_tom, shdr_64L11_tof },
{ sword_64L__tom, sword_64L__tof },
{ sym_64L11_tom, sym_64L11_tof },
{ word_64L__tom, word_64L__tof },
{ sxword_64L__tom, sxword_64L__tof },
{ xword_64L__tom, xword_64L__tof },
#if __LIBELF_SYMBOL_VERSIONS
{ _elf_verdef_64L11_tom, _elf_verdef_64L11_tof },
{ _elf_verneed_64L11_tom, _elf_verneed_64L11_tof },
#else /* __LIBELF_SYMBOL_VERSIONS */
{ 0, 0 },
{ 0, 0 },
#endif /* __LIBELF_SYMBOL_VERSIONS */
},
{
{ byte_copy, byte_copy },
{ addr_64M__tom, addr_64M__tof },
{ dyn_64M11_tom, dyn_64M11_tof },
{ ehdr_64M11_tom, ehdr_64M11_tof },
{ half_64M__tom, half_64M__tof },
{ off_64M__tom, off_64M__tof },
{ phdr_64M11_tom, phdr_64M11_tof },
{ rela_64M11_tom, rela_64M11_tof },
{ rel_64M11_tom, rel_64M11_tof },
{ shdr_64M11_tom, shdr_64M11_tof },
{ sword_64M__tom, sword_64M__tof },
{ sym_64M11_tom, sym_64M11_tof },
{ word_64M__tom, word_64M__tof },
{ sxword_64M__tom, sxword_64M__tof },
{ xword_64M__tom, xword_64M__tof },
#if __LIBELF_SYMBOL_VERSIONS
{ _elf_verdef_64M11_tom, _elf_verdef_64M11_tof },
{ _elf_verneed_64M11_tom, _elf_verneed_64M11_tof },
#else /* __LIBELF_SYMBOL_VERSIONS */
{ 0, 0 },
{ 0, 0 },
#endif /* __LIBELF_SYMBOL_VERSIONS */
},
};
/*
* main translation table (64-bit)
*/
#if PIC
static xltab*
#else /* PIC */
static const xltab *const
#endif /* PIC */
xlate64[EV_CURRENT - EV_NONE][EV_CURRENT - EV_NONE] = {
{ xlate64_11, },
};
#define translator(sv,dv,enc,type,d) \
(xlate64[(sv) - EV_NONE - 1] \
[(dv) - EV_NONE - 1] \
[(enc) - ELFDATA2LSB] \
[(type) - ELF_T_BYTE] \
[d])
/*
* destination buffer size
*/
size_t
_elf64_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) {
Elf_Type type = src->d_type;
unsigned sv = src->d_version;
xlator op;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return (size_t)-1;
}
if (tof) {
/*
* Encoding doesn't really matter (the translator only looks at
* the source, which resides in memory), but we need a proper
* encoding to select a translator...
*/
encode = ELFDATA2LSB;
}
else if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return (size_t)-1;
}
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
if (!(op = translator(sv, dv, encode, type, tof))) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
return (*op)(NULL, src->d_buf, src->d_size);
}
/*
* direction-independent translation
*/
static Elf_Data*
elf64_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
Elf_Type type;
int dv;
int sv;
size_t dsize;
size_t tmp;
xlator op;
if (!src || !dst) {
return NULL;
}
if (!src->d_buf || !dst->d_buf) {
seterr(ERROR_NULLBUF);
return NULL;
}
if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return NULL;
}
sv = src->d_version;
dv = dst->d_version;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return NULL;
}
type = src->d_type;
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
op = translator(sv, dv, encode, type, tof);
if (!op) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
dsize = (*op)(NULL, src->d_buf, src->d_size);
if (dsize == (size_t)-1) {
return NULL;
}
if (dst->d_size < dsize) {
seterr(ERROR_DST2SMALL);
return NULL;
}
if (dsize) {
tmp = (*op)(dst->d_buf, src->d_buf, src->d_size);
if (tmp == (size_t)-1) {
return NULL;
}
elf_assert(tmp == dsize);
}
dst->d_size = dsize;
dst->d_type = type;
return dst;
}
/*
* finally, the "official" translation functions
*/
Elf_Data*
elf64_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
return elf64_xlate(dst, src, encode, 0);
}
Elf_Data*
elf64_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
return elf64_xlate(dst, src, encode, 1);
}
Elf_Data*
gelf_xlatetom(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode) {
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_class == ELFCLASS32) {
return elf32_xlatetom(dst, src, encode);
}
else if (elf->e_class == ELFCLASS64) {
return elf64_xlatetom(dst, src, encode);
}
else if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
}
return NULL;
}
Elf_Data*
gelf_xlatetof(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode) {
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_class == ELFCLASS32) {
return elf32_xlatetof(dst, src, encode);
}
else if (elf->e_class == ELFCLASS64) {
return elf64_xlatetof(dst, src, encode);
}
else if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
}
return NULL;
}
#endif /* __LIBELF64__ */

33
external/libelf/src/assert.c vendored Normal file
View File

@ -0,0 +1,33 @@
/*
assert.c - assert function for libelf.
Copyright (C) 1999 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: assert.c,v 1.5 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
#include <stdio.h>
void
__elf_assert(const char *file, unsigned line, const char *cond) {
fprintf(stderr, "%s:%u: libelf assertion failure: %s\n",
file, line, cond);
abort();
}

429
external/libelf/src/begin.c vendored Normal file
View File

@ -0,0 +1,429 @@
/*
* begin.c - implementation of the elf_begin(3) and elf_memory(3) functions.
* Copyright (C) 1995 - 2004 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: begin.c,v 1.22 2009/11/01 13:04:19 michael Exp $";
#endif /* lint */
static const Elf _elf_init = INIT_ELF;
static const char fmag[] = ARFMAG;
static unsigned long
getnum(const char *str, size_t len, int base, size_t *err) {
unsigned long result = 0;
while (len && *str == ' ') {
str++; len--;
}
while (len && *str >= '0' && (*str - '0') < base) {
result = base * result + *str++ - '0'; len--;
}
while (len && *str == ' ') {
str++; len--;
}
if (len) {
*err = len;
}
return result;
}
static void
_elf_init_ar(Elf *elf) {
struct ar_hdr *hdr;
size_t offset;
size_t size;
size_t err = 0;
elf->e_kind = ELF_K_AR;
elf->e_idlen = SARMAG;
elf->e_off = SARMAG;
/* process special members */
offset = SARMAG;
while (!elf->e_strtab && offset + sizeof(*hdr) <= elf->e_size) {
hdr = (struct ar_hdr*)(elf->e_data + offset);
if (memcmp(hdr->ar_fmag, fmag, sizeof(fmag) - 1)) {
break;
}
if (hdr->ar_name[0] != '/') {
break;
}
size = getnum(hdr->ar_size, sizeof(hdr->ar_size), 10, &err);
if (err || !size) {
break;
}
offset += sizeof(*hdr);
if (offset + size > elf->e_size) {
break;
}
if (hdr->ar_name[1] == '/' && hdr->ar_name[2] == ' ') {
elf->e_strtab = elf->e_data + offset;
elf->e_strlen = size;
break;
}
if (hdr->ar_name[1] != ' ') {
break;
}
/*
* Windows (.lib) archives provide two symbol tables
* The first one is the one we want.
*/
if (!elf->e_symtab) {
elf->e_symtab = elf->e_data + offset;
elf->e_symlen = size;
}
offset += size + (size & 1);
}
}
static Elf_Arhdr*
_elf_arhdr(Elf *arf) {
struct ar_hdr *hdr;
Elf_Arhdr *arhdr;
size_t namelen;
size_t tmp;
char *name;
size_t err = 0;
if (arf->e_off == arf->e_size) {
/* no error! */
return NULL;
}
if (arf->e_off < 0 || arf->e_off > arf->e_size) {
seterr(ERROR_OUTSIDE);
return NULL;
}
if (arf->e_off + sizeof(*hdr) > arf->e_size) {
seterr(ERROR_TRUNC_ARHDR);
return NULL;
}
elf_assert(arf->e_data != NULL);
hdr = (struct ar_hdr*)(arf->e_data + arf->e_off);
if (memcmp(hdr->ar_fmag, fmag, sizeof(fmag) - 1)) {
seterr(ERROR_ARFMAG);
return NULL;
}
name = hdr->ar_name;
for (namelen = sizeof(hdr->ar_name); namelen > 0; namelen--) {
if (name[namelen - 1] != ' ') {
break;
}
}
if (name[0] == '/') {
if (name[1] >= '0' && name[1] <= '9') {
if (!arf->e_strtab) {
seterr(ERROR_ARSTRTAB);
return NULL;
}
tmp = getnum(&name[1], namelen - 1, 10, &err);
if (err) {
seterr(ERROR_ARSPECIAL);
return NULL;
}
if (tmp < 0 || tmp >= arf->e_strlen) {
seterr(ERROR_ARSTRTAB);
return NULL;
}
for (namelen = tmp; namelen < arf->e_strlen; namelen++) {
if (arf->e_strtab[namelen] == '/') {
break;
}
}
if (namelen == arf->e_strlen) {
seterr(ERROR_ARSTRTAB);
return NULL;
}
name = arf->e_strtab + tmp;
namelen -= tmp;
}
else if (namelen != 1 && !(namelen == 2 && name[1] == '/')) {
seterr(ERROR_ARSPECIAL);
return NULL;
}
}
else if (namelen > 0 && name[namelen - 1] == '/') {
namelen--;
}
/* XXX some broken software omits the trailing slash
else {
namelen = 0;
}
*/
if (!(arhdr = (Elf_Arhdr*)malloc(sizeof(*arhdr) +
sizeof(hdr->ar_name) + namelen + 2))) {
seterr(ERROR_MEM_ARHDR);
return NULL;
}
arhdr->ar_name = NULL;
arhdr->ar_rawname = (char*)(arhdr + 1);
arhdr->ar_date = getnum(hdr->ar_date, sizeof(hdr->ar_date), 10, &err);
arhdr->ar_uid = getnum(hdr->ar_uid, sizeof(hdr->ar_uid), 10, &err);
arhdr->ar_gid = getnum(hdr->ar_gid, sizeof(hdr->ar_gid), 10, &err);
arhdr->ar_mode = getnum(hdr->ar_mode, sizeof(hdr->ar_mode), 8, &err);
arhdr->ar_size = getnum(hdr->ar_size, sizeof(hdr->ar_size), 10, &err);
if (err) {
free(arhdr);
seterr(ERROR_ARHDR);
return NULL;
}
if (arf->e_off + sizeof(struct ar_hdr) + arhdr->ar_size > arf->e_size) {
free(arhdr);
seterr(ERROR_TRUNC_MEMBER);
return NULL;
}
memcpy(arhdr->ar_rawname, hdr->ar_name, sizeof(hdr->ar_name));
arhdr->ar_rawname[sizeof(hdr->ar_name)] = '\0';
if (namelen) {
arhdr->ar_name = arhdr->ar_rawname + sizeof(hdr->ar_name) + 1;
memcpy(arhdr->ar_name, name, namelen);
arhdr->ar_name[namelen] = '\0';
}
return arhdr;
}
static void
_elf_check_type(Elf *elf, size_t size) {
elf->e_idlen = size;
if (size >= EI_NIDENT && !memcmp(elf->e_data, ELFMAG, SELFMAG)) {
elf->e_kind = ELF_K_ELF;
elf->e_idlen = EI_NIDENT;
elf->e_class = elf->e_data[EI_CLASS];
elf->e_encoding = elf->e_data[EI_DATA];
elf->e_version = elf->e_data[EI_VERSION];
}
else if (size >= SARMAG && !memcmp(elf->e_data, ARMAG, SARMAG)) {
_elf_init_ar(elf);
}
}
Elf*
elf_begin(int fd, Elf_Cmd cmd, Elf *ref) {
Elf_Arhdr *arhdr = NULL;
size_t size = 0;
off_t off;
Elf *elf;
elf_assert(_elf_init.e_magic == ELF_MAGIC);
if (_elf_version == EV_NONE) {
seterr(ERROR_VERSION_UNSET);
return NULL;
}
else if (cmd == ELF_C_NULL) {
return NULL;
}
else if (cmd == ELF_C_WRITE) {
ref = NULL;
}
else if (cmd != ELF_C_READ && cmd != ELF_C_RDWR) {
seterr(ERROR_INVALID_CMD);
return NULL;
}
else if (ref) {
elf_assert(ref->e_magic == ELF_MAGIC);
if (!ref->e_readable || (cmd == ELF_C_RDWR && !ref->e_writable)) {
seterr(ERROR_CMDMISMATCH);
return NULL;
}
if (ref->e_kind != ELF_K_AR) {
ref->e_count++;
return ref;
}
if (cmd == ELF_C_RDWR) {
seterr(ERROR_MEMBERWRITE);
return NULL;
}
if (ref->e_memory) {
fd = ref->e_fd;
}
else if (fd != ref->e_fd) {
seterr(ERROR_FDMISMATCH);
return NULL;
}
if (!(arhdr = _elf_arhdr(ref))) {
return NULL;
}
size = arhdr->ar_size;
}
else if ((off = lseek(fd, (off_t)0, SEEK_END)) == (off_t)-1
|| (off_t)(size = off) != off) {
seterr(ERROR_IO_GETSIZE);
return NULL;
}
if (!(elf = (Elf*)malloc(sizeof(Elf)))) {
seterr(ERROR_MEM_ELF);
return NULL;
}
*elf = _elf_init;
elf->e_fd = fd;
elf->e_parent = ref;
elf->e_size = elf->e_dsize = size;
if (cmd != ELF_C_READ) {
elf->e_writable = 1;
}
if (cmd != ELF_C_WRITE) {
elf->e_readable = 1;
}
else {
return elf;
}
if (ref) {
size_t offset = ref->e_off + sizeof(struct ar_hdr);
Elf *xelf;
elf_assert(arhdr);
elf->e_arhdr = arhdr;
elf->e_base = ref->e_base + offset;
/*
* Share the archive's memory image. To avoid
* multiple independent elf descriptors if the
* same member is requested twice, scan the list
* of open members for duplicates.
*
* I don't know how SVR4 handles this case. Don't rely on it.
*/
for (xelf = ref->e_members; xelf; xelf = xelf->e_link) {
elf_assert(xelf->e_parent == ref);
if (xelf->e_base == elf->e_base) {
free(arhdr);
free(elf);
xelf->e_count++;
return xelf;
}
}
if (size == 0) {
elf->e_data = NULL;
}
#if 1
else {
/*
* Archive members may be misaligned. Freezing them will
* cause libelf to allocate buffers for translated data,
* which should be properly aligned in all cases.
*/
elf_assert(!ref->e_cooked);
elf->e_data = elf->e_rawdata = ref->e_data + offset;
}
#else
else if (ref->e_data == ref->e_rawdata) {
elf_assert(!ref->e_cooked);
/*
* archive is frozen - freeze member, too
*/
elf->e_data = elf->e_rawdata = ref->e_data + offset;
}
else {
elf_assert(!ref->e_memory);
elf->e_data = ref->e_data + offset;
/*
* The member's memory image may have been modified if
* the member has been processed before. Since we need the
* original image, we have to re-read the archive file.
* Will fail if the archive's file descriptor is disabled.
*/
if (!ref->e_cooked) {
ref->e_cooked = 1;
}
else if (!_elf_read(ref, elf->e_data, offset, size)) {
free(arhdr);
free(elf);
return NULL;
}
}
#endif
elf->e_next = offset + size + (size & 1);
elf->e_disabled = ref->e_disabled;
elf->e_memory = ref->e_memory;
/* parent/child linking */
elf->e_link = ref->e_members;
ref->e_members = elf;
ref->e_count++;
/* Slowaris compatibility - do not rely on this! */
ref->e_off = elf->e_next;
}
else if (size) {
#if HAVE_MMAP
/*
* Using mmap on writable files will interfere with elf_update
*/
if (!elf->e_writable && (elf->e_data = _elf_mmap(elf))) {
elf->e_unmap_data = 1;
}
else
#endif /* HAVE_MMAP */
if (!(elf->e_data = _elf_read(elf, NULL, 0, size))) {
free(elf);
return NULL;
}
}
_elf_check_type(elf, size);
return elf;
}
Elf*
elf_memory(char *image, size_t size) {
Elf *elf;
elf_assert(_elf_init.e_magic == ELF_MAGIC);
if (_elf_version == EV_NONE) {
seterr(ERROR_VERSION_UNSET);
return NULL;
}
else if (size == 0 || image == NULL) {
/* TODO: set error code? */
return NULL;
}
if (!(elf = (Elf*)malloc(sizeof(Elf)))) {
seterr(ERROR_MEM_ELF);
return NULL;
}
*elf = _elf_init;
elf->e_size = elf->e_dsize = size;
elf->e_data = elf->e_rawdata = image;
elf->e_readable = 1;
elf->e_disabled = 1;
elf->e_memory = 1;
_elf_check_type(elf, size);
return elf;
}
#if __LIBELF64
int
gelf_getclass(Elf *elf) {
if (elf && elf->e_kind == ELF_K_ELF && valid_class(elf->e_class)) {
return elf->e_class;
}
return ELFCLASSNONE;
}
#endif /* __LIBELF64 */

95
external/libelf/src/byteswap.h vendored Normal file
View File

@ -0,0 +1,95 @@
/*
byteswap.h - functions and macros for byte swapping.
Copyright (C) 1995 - 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/* @(#) $Id: byteswap.h,v 1.7 2008/05/23 08:15:34 michael Exp $ */
#ifndef _BYTESWAP_H
#define _BYTESWAP_H
#define lu(from,i,s) (((__libelf_u32_t)((unsigned char*)(from))[i])<<(s))
#define li(from,i,s) (((__libelf_i32_t)(( signed char*)(from))[i])<<(s))
#define __load_u16L(from) ((__libelf_u32_t) \
(lu(from,1,8) | lu(from,0,0)))
#define __load_u16M(from) ((__libelf_u32_t) \
(lu(from,0,8) | lu(from,1,0)))
#define __load_i16L(from) ((__libelf_i32_t) \
(li(from,1,8) | lu(from,0,0)))
#define __load_i16M(from) ((__libelf_i32_t) \
(li(from,0,8) | lu(from,1,0)))
#define __load_u32L(from) ((__libelf_u32_t) \
(lu(from,3,24) | lu(from,2,16) | lu(from,1,8) | lu(from,0,0)))
#define __load_u32M(from) ((__libelf_u32_t) \
(lu(from,0,24) | lu(from,1,16) | lu(from,2,8) | lu(from,3,0)))
#define __load_i32L(from) ((__libelf_i32_t) \
(li(from,3,24) | lu(from,2,16) | lu(from,1,8) | lu(from,0,0)))
#define __load_i32M(from) ((__libelf_i32_t) \
(li(from,0,24) | lu(from,1,16) | lu(from,2,8) | lu(from,3,0)))
#define su(to,i,v,s) (((char*)(to))[i]=((__libelf_u32_t)(v)>>(s)))
#define si(to,i,v,s) (((char*)(to))[i]=((__libelf_i32_t)(v)>>(s)))
#define __store_u16L(to,v) \
(su(to,1,v,8), su(to,0,v,0))
#define __store_u16M(to,v) \
(su(to,0,v,8), su(to,1,v,0))
#define __store_i16L(to,v) \
(si(to,1,v,8), si(to,0,v,0))
#define __store_i16M(to,v) \
(si(to,0,v,8), si(to,1,v,0))
#define __store_u32L(to,v) \
(su(to,3,v,24), su(to,2,v,16), su(to,1,v,8), su(to,0,v,0))
#define __store_u32M(to,v) \
(su(to,0,v,24), su(to,1,v,16), su(to,2,v,8), su(to,3,v,0))
#define __store_i32L(to,v) \
(si(to,3,v,24), si(to,2,v,16), si(to,1,v,8), si(to,0,v,0))
#define __store_i32M(to,v) \
(si(to,0,v,24), si(to,1,v,16), si(to,2,v,8), si(to,3,v,0))
#if __LIBELF64
/*
* conversion functions from swap64.c
*/
extern __libelf_u64_t _elf_load_u64L(const unsigned char *from);
extern __libelf_u64_t _elf_load_u64M(const unsigned char *from);
extern __libelf_i64_t _elf_load_i64L(const unsigned char *from);
extern __libelf_i64_t _elf_load_i64M(const unsigned char *from);
extern void _elf_store_u64L(unsigned char *to, __libelf_u64_t v);
extern void _elf_store_u64M(unsigned char *to, __libelf_u64_t v);
extern void _elf_store_i64L(unsigned char *to, __libelf_u64_t v);
extern void _elf_store_i64M(unsigned char *to, __libelf_u64_t v);
/*
* aliases for existing conversion code
*/
#define __load_u64L _elf_load_u64L
#define __load_u64M _elf_load_u64M
#define __load_i64L _elf_load_i64L
#define __load_i64M _elf_load_i64M
#define __store_u64L _elf_store_u64L
#define __store_u64M _elf_store_u64M
#define __store_i64L _elf_store_i64L
#define __store_i64M _elf_store_i64M
#endif /* __LIBELF64 */
#endif /* _BYTESWAP_H */

178
external/libelf/src/checksum.c vendored Normal file
View File

@ -0,0 +1,178 @@
/*
checksum.c - implementation of the elf{32,64}_checksum(3) functions.
Copyright (C) 1995 - 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: checksum.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
/*
* Compatibility note:
*
* The algorithm used in {elf32,elf64,gelf}_checksum() does not seem to
* be documented. I hope I got it right. My implementation does the
* following:
*
* - skip sections that do not have the SHF_ALLOC flag set
* - skip sections of type SHT_NULL, SHT_NOBITS, SHT_DYNSYM and
* SHT_DYNAMIC
* - add all data bytes from the remaining sections, modulo 2**32
* - add upper and lower half of the result
* - subtract 0xffff if the result is > 0xffff
* - if any error occurs, return 0L
*/
static int
skip_section(Elf_Scn *scn, unsigned cls) {
if (cls == ELFCLASS32) {
Elf32_Shdr *shdr = &scn->s_shdr32;
if (!(shdr->sh_flags & SHF_ALLOC)) {
return 1;
}
switch (shdr->sh_type) {
case SHT_NULL:
case SHT_NOBITS:
/* Solaris seems to ignore these, too */
case SHT_DYNSYM:
case SHT_DYNAMIC:
return 1;
}
}
#if __LIBELF64
else if (cls == ELFCLASS64) {
Elf64_Shdr *shdr = &scn->s_shdr64;
if (!(shdr->sh_flags & SHF_ALLOC)) {
return 1;
}
switch (shdr->sh_type) {
case SHT_NULL:
case SHT_NOBITS:
/* Solaris seems to ignore these, too */
case SHT_DYNSYM:
case SHT_DYNAMIC:
return 1;
}
}
#endif /* __LIBELF64 */
else {
seterr(ERROR_UNIMPLEMENTED);
}
return 0;
}
static long
add_bytes(unsigned char *ptr, size_t len) {
long csum = 0;
while (len--) {
csum += *ptr++;
}
return csum;
}
static long
_elf_csum(Elf *elf) {
long csum = 0;
Elf_Data *data;
Elf_Scn *scn;
if (!elf->e_ehdr && !_elf_cook(elf)) {
/* propagate errors from _elf_cook */
return 0L;
}
seterr(0);
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
if (scn->s_index == SHN_UNDEF || skip_section(scn, elf->e_class)) {
continue;
}
data = NULL;
while ((data = elf_getdata(scn, data))) {
if (data->d_size) {
if (data->d_buf == NULL) {
seterr(ERROR_NULLBUF);
return 0L;
}
csum += add_bytes(data->d_buf, data->d_size);
}
}
}
if (_elf_errno) {
return 0L;
}
csum = (csum & 0xffff) + ((csum >> 16) & 0xffff);
if (csum > 0xffff) {
csum -= 0xffff;
}
return csum;
}
long
elf32_checksum(Elf *elf) {
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_class != ELFCLASS32) {
seterr(ERROR_CLASSMISMATCH);
}
else {
return _elf_csum(elf);
}
}
return 0L;
}
#if __LIBELF64
long
elf64_checksum(Elf *elf) {
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_class != ELFCLASS64) {
seterr(ERROR_CLASSMISMATCH);
}
else {
return _elf_csum(elf);
}
}
return 0L;
}
long
gelf_checksum(Elf *elf) {
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (!valid_class(elf->e_class)) {
seterr(ERROR_UNKNOWN_CLASS);
}
else {
return _elf_csum(elf);
}
}
return 0L;
}
#endif /* __LIBELF64 */

71
external/libelf/src/cntl.c vendored Normal file
View File

@ -0,0 +1,71 @@
/*
cntl.c - implementation of the elf_cntl(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: cntl.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
int
elf_cntl(Elf *elf, Elf_Cmd cmd) {
Elf_Scn *scn;
Elf *child;
if (!elf) {
return -1;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (cmd == ELF_C_FDREAD) {
if (!elf->e_readable) {
seterr(ERROR_WRONLY);
return -1;
}
}
else if (cmd != ELF_C_FDDONE) {
seterr(ERROR_INVALID_CMD);
return -1;
}
if (elf->e_disabled) {
return 0;
}
if (elf->e_kind == ELF_K_AR) {
for (child = elf->e_members; child; child = child->e_link) {
elf_assert(elf == child->e_parent);
if (elf_cntl(child, cmd)) {
return -1;
}
}
}
else if (elf->e_kind == ELF_K_ELF && cmd == ELF_C_FDREAD) {
if (!elf->e_ehdr && !_elf_cook(elf)) {
return -1;
}
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
if (scn->s_index == SHN_UNDEF || scn->s_type == SHT_NULL) {
continue;
}
else if (!elf_getdata(scn, NULL)) {
return -1;
}
}
}
elf->e_disabled = 1;
return 0;
}

164
external/libelf/src/config.h vendored Normal file
View File

@ -0,0 +1,164 @@
/*
* lib/config.h.w32 - configuration file for W32 port
* Copyright (C) 2004 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* @(#) $Id: config.h.w32,v 1.2 2006/09/07 15:55:42 michael Exp $
*/
/* Define to empty if the keyword does not work. */
#undef const
/* Define if you have a working `mmap' system call. */
#undef HAVE_MMAP
/* Define to `long' if <sys/types.h> doesn't define. */
#undef off_t
/* Define to `unsigned' if <sys/types.h> doesn't define. */
#undef size_t
/* Define if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Define if you want to include extra debugging code */
#define ENABLE_DEBUG 1
/* Define if memmove() does not copy overlapping arrays correctly */
#undef HAVE_BROKEN_MEMMOVE
/* Define if you have the catgets function. */
#undef HAVE_CATGETS
/* Define if you have the dgettext function. */
#undef HAVE_DGETTEXT
/* Define if you have the memset function. */
#define HAVE_MEMSET 1
/* Define if struct nlist is declared in <elf.h> or <sys/elf.h> */
#undef HAVE_STRUCT_NLIST_DECLARATION
/* Define if Elf32_Dyn is declared in <link.h> */
#undef __LIBELF_NEED_LINK_H
/* Define if Elf32_Dyn is declared in <sys/link.h> */
#undef __LIBELF_NEED_SYS_LINK_H
/* Define to `<elf.h>' or `<sys/elf.h>' if one of them is present */
#undef __LIBELF_HEADER_ELF_H
/* Define if you want 64-bit support (and your system supports it) */
#define __LIBELF64 1
/* Define if you want 64-bit support, and are running IRIX */
#undef __LIBELF64_IRIX
/* Define if you want 64-bit support, and are running Linux */
#undef __LIBELF64_LINUX
/* Define if you want symbol versioning (and your system supports it) */
#define __LIBELF_SYMBOL_VERSIONS 1
/* Define if symbol versioning uses Sun section type (SHT_SUNW_*) */
#define __LIBELF_SUN_SYMBOL_VERSIONS 1
/* Define if symbol versioning uses GNU section types (SHT_GNU_*) */
#undef __LIBELF_GNU_SYMBOL_VERSIONS
/* Define to a 64-bit signed integer type if one exists */
#define __libelf_i64_t __int64
/* Define to a 64-bit unsigned integer type if one exists */
#define __libelf_u64_t unsigned __int64
/* Define to a 32-bit signed integer type if one exists */
#define __libelf_i32_t int
/* Define to a 32-bit unsigned integer type if one exists */
#define __libelf_u32_t unsigned int
/* Define to a 16-bit signed integer type if one exists */
#define __libelf_i16_t short int
/* Define to a 16-bit unsigned integer type if one exists */
#define __libelf_u16_t unsigned short int
/* The number of bytes in a __int64. */
#define SIZEOF___INT64 8
/* The number of bytes in a int. */
#define SIZEOF_INT 4
/* The number of bytes in a long. */
#define SIZEOF_LONG 4
/* The number of bytes in a long long. */
#define SIZEOF_LONG_LONG 0
/* The number of bytes in a short. */
#define SIZEOF_SHORT 2
/* Define if you have the ftruncate function. */
#undef HAVE_FTRUNCATE
/* Define if you have the getpagesize function. */
#undef HAVE_GETPAGESIZE
/* Define if you have the memcmp function. */
#define HAVE_MEMCMP 1
/* Define if you have the memcpy function. */
#define HAVE_MEMCPY 1
/* Define if you have the memmove function. */
#define HAVE_MEMMOVE 1
/* Define if you have the memset function. */
#define HAVE_MEMSET 1
/* Define if you have the <ar.h> header file. */
#undef HAVE_AR_H
/* Define if you have the <elf.h> header file. */
#undef HAVE_ELF_H
/* Define if you have the <fcntl.h> header file. */
#undef HAVE_FCNTL_H
/* Define if you have the <gelf.h> header file. */
#undef HAVE_GELF_H
/* Define if you have the <libelf.h> header file. */
#undef HAVE_LIBELF_H
/* Define if you have the <link.h> header file. */
#undef HAVE_LINK_H
/* Define if you have the <nlist.h> header file. */
#undef HAVE_NLIST_H
/* Define if you have the <sys/elf.h> header file. */
#undef HAVE_SYS_ELF_H
/* Define if you have the <sys/link.h> header file. */
#undef HAVE_SYS_LINK_H
/* Define if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1

501
external/libelf/src/cook.c vendored Normal file
View File

@ -0,0 +1,501 @@
/*
* cook.c - read and translate ELF files.
* Copyright (C) 1995 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: cook.c,v 1.29 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
const Elf_Scn _elf_scn_init = INIT_SCN;
const Scn_Data _elf_data_init = INIT_DATA;
Elf_Type
_elf_scn_type(unsigned t) {
switch (t) {
case SHT_DYNAMIC: return ELF_T_DYN;
case SHT_DYNSYM: return ELF_T_SYM;
case SHT_HASH: return ELF_T_WORD;
case SHT_REL: return ELF_T_REL;
case SHT_RELA: return ELF_T_RELA;
case SHT_SYMTAB: return ELF_T_SYM;
case SHT_SYMTAB_SHNDX: return ELF_T_WORD; /* XXX: really? */
#if __LIBELF_SYMBOL_VERSIONS
#if __LIBELF_SUN_SYMBOL_VERSIONS
case SHT_SUNW_verdef: return ELF_T_VDEF;
case SHT_SUNW_verneed: return ELF_T_VNEED;
case SHT_SUNW_versym: return ELF_T_HALF;
#else /* __LIBELF_SUN_SYMBOL_VERSIONS */
case SHT_GNU_verdef: return ELF_T_VDEF;
case SHT_GNU_verneed: return ELF_T_VNEED;
case SHT_GNU_versym: return ELF_T_HALF;
#endif /* __LIBELF_SUN_SYMBOL_VERSIONS */
#endif /* __LIBELF_SYMBOL_VERSIONS */
}
return ELF_T_BYTE;
}
/*
* Check for overflow on 32-bit systems
*/
#define overflow(a,b,t) (sizeof(a) < sizeof(t) && (t)(a) != (b))
#define truncerr(t) ((t)==ELF_T_EHDR?ERROR_TRUNC_EHDR: \
((t)==ELF_T_PHDR?ERROR_TRUNC_PHDR: \
ERROR_INTERNAL))
#define memerr(t) ((t)==ELF_T_EHDR?ERROR_MEM_EHDR: \
((t)==ELF_T_PHDR?ERROR_MEM_PHDR: \
ERROR_INTERNAL))
Elf_Data*
_elf_xlatetom(const Elf *elf, Elf_Data *dst, const Elf_Data *src) {
if (elf->e_class == ELFCLASS32) {
return elf32_xlatetom(dst, src, elf->e_encoding);
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
return elf64_xlatetom(dst, src, elf->e_encoding);
}
#endif /* __LIBELF64 */
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
static char*
_elf_item(void *buf, Elf *elf, Elf_Type type, size_t off) {
Elf_Data src, dst;
elf_assert(valid_type(type));
if (off < 0 || off > elf->e_size) {
seterr(ERROR_OUTSIDE);
return NULL;
}
src.d_type = type;
src.d_version = elf->e_version;
src.d_size = _fsize(elf->e_class, src.d_version, type);
elf_assert(src.d_size);
if ((elf->e_size - off) < src.d_size) {
seterr(truncerr(type));
return NULL;
}
dst.d_version = _elf_version;
dst.d_size = _msize(elf->e_class, dst.d_version, type);
elf_assert(dst.d_size);
if (!(dst.d_buf = buf) && !(dst.d_buf = malloc(dst.d_size))) {
seterr(memerr(type));
return NULL;
}
elf_assert(elf->e_data);
if (elf->e_rawdata) {
src.d_buf = elf->e_rawdata + off;
}
else {
src.d_buf = elf->e_data + off;
}
if (_elf_xlatetom(elf, &dst, &src)) {
return (char*)dst.d_buf;
}
if (dst.d_buf != buf) {
free(dst.d_buf);
}
return NULL;
}
static int
_elf_cook_phdr(Elf *elf) {
size_t num, off, entsz;
if (elf->e_class == ELFCLASS32) {
num = ((Elf32_Ehdr*)elf->e_ehdr)->e_phnum;
off = ((Elf32_Ehdr*)elf->e_ehdr)->e_phoff;
entsz = ((Elf32_Ehdr*)elf->e_ehdr)->e_phentsize;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
num = ((Elf64_Ehdr*)elf->e_ehdr)->e_phnum;
off = ((Elf64_Ehdr*)elf->e_ehdr)->e_phoff;
entsz = ((Elf64_Ehdr*)elf->e_ehdr)->e_phentsize;
/*
* Check for overflow on 32-bit systems
*/
if (overflow(off, ((Elf64_Ehdr*)elf->e_ehdr)->e_phoff, Elf64_Off)) {
seterr(ERROR_OUTSIDE);
return 0;
}
}
#endif /* __LIBELF64 */
else {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
if (off) {
Elf_Scn *scn;
size_t size;
unsigned i;
char *p;
if (num == PN_XNUM) {
/*
* Overflow in ehdr->e_phnum.
* Get real value from first SHDR.
*/
if (!(scn = elf->e_scn_1)) {
seterr(ERROR_NOSUCHSCN);
return 0;
}
if (elf->e_class == ELFCLASS32) {
num = scn->s_shdr32.sh_info;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
num = scn->s_shdr64.sh_info;
}
#endif /* __LIBELF64 */
/* we already had this
else {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
*/
}
size = _fsize(elf->e_class, elf->e_version, ELF_T_PHDR);
elf_assert(size);
#if ENABLE_EXTENDED_FORMAT
if (entsz < size) {
#else /* ENABLE_EXTENDED_FORMAT */
if (entsz != size) {
#endif /* ENABLE_EXTENDED_FORMAT */
seterr(ERROR_EHDR_PHENTSIZE);
return 0;
}
size = _msize(elf->e_class, _elf_version, ELF_T_PHDR);
elf_assert(size);
if (!(p = malloc(num * size))) {
seterr(memerr(ELF_T_PHDR));
return 0;
}
for (i = 0; i < num; i++) {
if (!_elf_item(p + i * size, elf, ELF_T_PHDR, off + i * entsz)) {
free(p);
return 0;
}
}
elf->e_phdr = p;
elf->e_phnum = num;
}
return 1;
}
static int
_elf_cook_shdr(Elf *elf) {
size_t num, off, entsz;
if (elf->e_class == ELFCLASS32) {
num = ((Elf32_Ehdr*)elf->e_ehdr)->e_shnum;
off = ((Elf32_Ehdr*)elf->e_ehdr)->e_shoff;
entsz = ((Elf32_Ehdr*)elf->e_ehdr)->e_shentsize;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
num = ((Elf64_Ehdr*)elf->e_ehdr)->e_shnum;
off = ((Elf64_Ehdr*)elf->e_ehdr)->e_shoff;
entsz = ((Elf64_Ehdr*)elf->e_ehdr)->e_shentsize;
/*
* Check for overflow on 32-bit systems
*/
if (overflow(off, ((Elf64_Ehdr*)elf->e_ehdr)->e_shoff, Elf64_Off)) {
seterr(ERROR_OUTSIDE);
return 0;
}
}
#endif /* __LIBELF64 */
else {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
if (off) {
struct tmp {
Elf_Scn scn;
Scn_Data data;
} *head;
Elf_Data src, dst;
Elf_Scn *scn;
Scn_Data *sd;
unsigned i;
if (off < 0 || off > elf->e_size) {
seterr(ERROR_OUTSIDE);
return 0;
}
src.d_type = ELF_T_SHDR;
src.d_version = elf->e_version;
src.d_size = _fsize(elf->e_class, src.d_version, ELF_T_SHDR);
elf_assert(src.d_size);
#if ENABLE_EXTENDED_FORMAT
if (entsz < src.d_size) {
#else /* ENABLE_EXTENDED_FORMAT */
if (entsz != src.d_size) {
#endif /* ENABLE_EXTENDED_FORMAT */
seterr(ERROR_EHDR_SHENTSIZE);
return 0;
}
dst.d_version = EV_CURRENT;
if (num == 0) {
union {
Elf32_Shdr sh32;
#if __LIBELF64
Elf64_Shdr sh64;
#endif /* __LIBELF64 */
} u;
/*
* Overflow in ehdr->e_shnum.
* Get real value from first SHDR.
*/
if (elf->e_size - off < entsz) {
seterr(ERROR_TRUNC_SHDR);
return 0;
}
if (elf->e_rawdata) {
src.d_buf = elf->e_rawdata + off;
}
else {
src.d_buf = elf->e_data + off;
}
dst.d_buf = &u;
dst.d_size = sizeof(u);
if (!_elf_xlatetom(elf, &dst, &src)) {
return 0;
}
elf_assert(dst.d_size == _msize(elf->e_class, EV_CURRENT, ELF_T_SHDR));
elf_assert(dst.d_type == ELF_T_SHDR);
if (elf->e_class == ELFCLASS32) {
num = u.sh32.sh_size;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
num = u.sh64.sh_size;
/*
* Check for overflow on 32-bit systems
*/
if (overflow(num, u.sh64.sh_size, Elf64_Xword)) {
seterr(ERROR_OUTSIDE);
return 0;
}
}
#endif /* __LIBELF64 */
}
if ((elf->e_size - off) / entsz < num) {
seterr(ERROR_TRUNC_SHDR);
return 0;
}
if (!(head = (struct tmp*)malloc(num * sizeof(struct tmp)))) {
seterr(ERROR_MEM_SCN);
return 0;
}
for (scn = NULL, i = num; i-- > 0; ) {
head[i].scn = _elf_scn_init;
head[i].data = _elf_data_init;
head[i].scn.s_link = scn;
if (!scn) {
elf->e_scn_n = &head[i].scn;
}
scn = &head[i].scn;
sd = &head[i].data;
if (elf->e_rawdata) {
src.d_buf = elf->e_rawdata + off + i * entsz;
}
else {
src.d_buf = elf->e_data + off + i * entsz;
}
dst.d_buf = &scn->s_uhdr;
dst.d_size = sizeof(scn->s_uhdr);
if (!_elf_xlatetom(elf, &dst, &src)) {
elf->e_scn_n = NULL;
free(head);
return 0;
}
elf_assert(dst.d_size == _msize(elf->e_class, EV_CURRENT, ELF_T_SHDR));
elf_assert(dst.d_type == ELF_T_SHDR);
scn->s_elf = elf;
scn->s_index = i;
scn->s_data_1 = sd;
scn->s_data_n = sd;
sd->sd_scn = scn;
if (elf->e_class == ELFCLASS32) {
Elf32_Shdr *shdr = &scn->s_shdr32;
scn->s_type = shdr->sh_type;
scn->s_size = shdr->sh_size;
scn->s_offset = shdr->sh_offset;
sd->sd_data.d_align = shdr->sh_addralign;
sd->sd_data.d_type = _elf_scn_type(scn->s_type);
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
Elf64_Shdr *shdr = &scn->s_shdr64;
scn->s_type = shdr->sh_type;
scn->s_size = shdr->sh_size;
scn->s_offset = shdr->sh_offset;
sd->sd_data.d_align = shdr->sh_addralign;
/*
* Check for overflow on 32-bit systems
*/
if (overflow(scn->s_size, shdr->sh_size, Elf64_Xword)
|| overflow(scn->s_offset, shdr->sh_offset, Elf64_Off)
|| overflow(sd->sd_data.d_align, shdr->sh_addralign, Elf64_Xword)) {
seterr(ERROR_OUTSIDE);
return 0;
}
sd->sd_data.d_type = _elf_scn_type(scn->s_type);
/*
* QUIRKS MODE:
*
* Some 64-bit architectures use 64-bit entries in the
* .hash section. This violates the ELF standard, and
* should be fixed. It's mostly harmless as long as the
* binary and the machine running your program have the
* same byte order, but you're in trouble if they don't,
* and if the entry size is wrong.
*
* As a workaround, I let libelf guess the right size
* for the binary. This relies pretty much on the fact
* that the binary provides correct data in the section
* headers. If it doesn't, it's probably broken anyway.
* Therefore, libelf uses a standard conforming value
* when it's not absolutely sure.
*/
if (scn->s_type == SHT_HASH) {
int override = 0;
/*
* sh_entsize must reflect the entry size
*/
if (shdr->sh_entsize == ELF64_FSZ_ADDR) {
override++;
}
/*
* sh_size must be a multiple of sh_entsize
*/
if (shdr->sh_size % ELF64_FSZ_ADDR == 0) {
override++;
}
/*
* There must be room for at least 2 entries
*/
if (shdr->sh_size >= 2 * ELF64_FSZ_ADDR) {
override++;
}
/*
* sh_addralign must be correctly set
*/
if (shdr->sh_addralign == ELF64_FSZ_ADDR) {
override++;
}
/*
* The section must be properly aligned
*/
if (shdr->sh_offset % ELF64_FSZ_ADDR == 0) {
override++;
}
/* XXX: also look at the data? */
/*
* Make a conservative decision...
*/
if (override >= 5) {
sd->sd_data.d_type = ELF_T_ADDR;
}
}
/*
* END QUIRKS MODE.
*/
}
#endif /* __LIBELF64 */
/* we already had this
else {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
*/
sd->sd_data.d_size = scn->s_size;
sd->sd_data.d_version = _elf_version;
}
elf_assert(scn == &head[0].scn);
elf->e_scn_1 = &head[0].scn;
head[0].scn.s_freeme = 1;
}
return 1;
}
static int
_elf_cook_file(Elf *elf) {
elf->e_ehdr = _elf_item(NULL, elf, ELF_T_EHDR, 0);
if (!elf->e_ehdr) {
return 0;
}
/*
* Note: _elf_cook_phdr may require the first section header!
*/
if (!_elf_cook_shdr(elf)) {
return 0;
}
if (!_elf_cook_phdr(elf)) {
return 0;
}
return 1;
}
int
_elf_cook(Elf *elf) {
elf_assert(_elf_scn_init.s_magic == SCN_MAGIC);
elf_assert(_elf_data_init.sd_magic == DATA_MAGIC);
elf_assert(elf);
elf_assert(elf->e_magic == ELF_MAGIC);
elf_assert(elf->e_kind == ELF_K_ELF);
elf_assert(!elf->e_ehdr);
if (!valid_version(elf->e_version)) {
seterr(ERROR_UNKNOWN_VERSION);
}
else if (!valid_encoding(elf->e_encoding)) {
seterr(ERROR_UNKNOWN_ENCODING);
}
else if (valid_class(elf->e_class)) {
return _elf_cook_file(elf);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return 0;
}

36
external/libelf/src/data.c vendored Normal file
View File

@ -0,0 +1,36 @@
/*
* data.c - libelf internal variables.
* Copyright (C) 1995 - 1998, 2007 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: data.c,v 1.8 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
unsigned _elf_version = EV_NONE;
int _elf_errno = 0;
int _elf_fill = 0;
#if ENABLE_SANITY_CHECKS
#define SANITY_CHECKS -1
#else
#define SANITY_CHECKS 0
#endif
int _elf_sanity_checks = SANITY_CHECKS;

118
external/libelf/src/end.c vendored Normal file
View File

@ -0,0 +1,118 @@
/*
* end.c - implementation of the elf_end(3) function.
* Copyright (C) 1995 - 2004 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: end.c,v 1.12 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
#if HAVE_MMAP
#include <sys/mman.h>
#endif /* HAVE_MMAP */
static void
_elf_free(void *ptr) {
if (ptr) {
free(ptr);
}
}
static void
_elf_free_scns(Elf *elf, Elf_Scn *scn) {
Scn_Data *sd, *tmp;
Elf_Scn *freescn;
for (freescn = NULL; scn; scn = scn->s_link) {
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(scn->s_elf == elf);
for (sd = scn->s_data_1; sd; sd = tmp) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
tmp = sd->sd_link;
if (sd->sd_free_data) {
_elf_free(sd->sd_memdata);
}
if (sd->sd_freeme) {
free(sd);
}
}
if ((sd = scn->s_rawdata)) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
if (sd->sd_free_data) {
_elf_free(sd->sd_memdata);
}
if (sd->sd_freeme) {
free(sd);
}
}
if (scn->s_freeme) {
_elf_free(freescn);
freescn = scn;
}
}
_elf_free(freescn);
}
int
elf_end(Elf *elf) {
Elf **siblings;
if (!elf) {
return 0;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (--elf->e_count) {
return elf->e_count;
}
if (elf->e_parent) {
elf_assert(elf->e_parent->e_magic == ELF_MAGIC);
elf_assert(elf->e_parent->e_kind == ELF_K_AR);
siblings = &elf->e_parent->e_members;
while (*siblings) {
if (*siblings == elf) {
*siblings = elf->e_link;
break;
}
siblings = &(*siblings)->e_link;
}
elf_end(elf->e_parent);
_elf_free(elf->e_arhdr);
}
#if HAVE_MMAP
else if (elf->e_unmap_data) {
munmap(elf->e_data, elf->e_size);
}
#endif /* HAVE_MMAP */
else if (!elf->e_memory) {
_elf_free(elf->e_data);
}
_elf_free_scns(elf, elf->e_scn_1);
if (elf->e_rawdata != elf->e_data) {
_elf_free(elf->e_rawdata);
}
if (elf->e_free_syms) {
_elf_free(elf->e_symtab);
}
_elf_free(elf->e_ehdr);
_elf_free(elf->e_phdr);
free(elf);
return 0;
}

77
external/libelf/src/errmsg.c vendored Normal file
View File

@ -0,0 +1,77 @@
/*
* errmsg.c - implementation of the elf_errmsg(3) function.
* Copyright (C) 1995 - 1999, 2004 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: errmsg.c,v 1.11 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
#if HAVE_DGETTEXT
# undef HAVE_CATGETS
# include <libintl.h>
#else /* HAVE_DGETTEXT */
# define dgettext(dom, str) str
#endif /* HAVE_DGETTEXT */
#if HAVE_CATGETS
# include <nl_types.h>
static nl_catd _libelf_cat = (nl_catd)0;
#endif /* HAVE_CATGETS */
#if HAVE_DGETTEXT || HAVE_CATGETS
static const char domain[] = "libelf";
#endif /* HAVE_DGETTEXT || HAVE_CATGETS */
#if PIC
static const char *_messages[] = {
#else /* PIC */
static const char *const _messages[] = {
#endif /* PIC */
#define __err__(a,b) b,
#include <errors.h> /* include string tables from errors.h */
#undef __err__
};
const char*
elf_errmsg(int err) {
if (err == 0) {
err = _elf_errno;
if (err == 0) {
return NULL;
}
}
else if (err == -1) {
err = _elf_errno;
}
if (err < 0 || err >= ERROR_NUM || _messages[err] == NULL) {
err = ERROR_UNKNOWN;
}
#if HAVE_CATGETS
if (_libelf_cat == (nl_catd)0) {
_libelf_cat = catopen(domain, 0);
}
if (_libelf_cat != (nl_catd)-1) {
return catgets(_libelf_cat, 1, err + 1, _messages[err]);
}
#endif /* HAVE_CATGETS */
return dgettext(domain, _messages[err]);
}

32
external/libelf/src/errno.c vendored Normal file
View File

@ -0,0 +1,32 @@
/*
errno.c - implementation of the elf_errno(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: errno.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
int
elf_errno(void) {
int tmp = _elf_errno;
_elf_errno = 0;
return tmp;
}

100
external/libelf/src/errors.h vendored Normal file
View File

@ -0,0 +1,100 @@
/*
* errors.h - exhaustive list of all error codes and messages for libelf.
* Copyright (C) 1995 - 2003, 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/* @(#) $Id: errors.h,v 1.18 2008/05/23 08:15:34 michael Exp $ */
/* dummy for xgettext */
#define _(str) str
__err__(ERROR_OK, _("no error"))
__err__(ERROR_UNKNOWN, _("unknown error"))
__err__(ERROR_INTERNAL, _("Internal error: unknown reason"))
__err__(ERROR_UNIMPLEMENTED, _("Internal error: not implemented"))
__err__(ERROR_WRONLY, _("Request error: cntl(ELF_C_FDREAD) on write-only file"))
__err__(ERROR_INVALID_CMD, _("Request error: invalid ELF_C_* argument"))
__err__(ERROR_FDDISABLED, _("Request error: file descriptor disabled"))
__err__(ERROR_NOTARCHIVE, _("Request error: not an archive"))
__err__(ERROR_BADOFF, _("Request error: offset out of range"))
__err__(ERROR_UNKNOWN_VERSION, _("Request error: unknown ELF version"))
__err__(ERROR_CMDMISMATCH, _("Request error: ELF_C_* argument does not match"))
__err__(ERROR_MEMBERWRITE, _("Request error: archive member begin() for writing"))
__err__(ERROR_FDMISMATCH, _("Request error: archive/member file descriptor mismatch"))
__err__(ERROR_NOTELF, _("Request error: not an ELF file"))
__err__(ERROR_CLASSMISMATCH, _("Request error: class file/memory mismatch"))
__err__(ERROR_UNKNOWN_TYPE, _("Request error: invalid ELF_T_* argument"))
__err__(ERROR_UNKNOWN_ENCODING, _("Request error: unknown data encoding"))
__err__(ERROR_DST2SMALL, _("Request error: destination buffer too small"))
__err__(ERROR_NULLBUF, _("Request error: d_buf is NULL"))
__err__(ERROR_UNKNOWN_CLASS, _("Request error: unknown ELF class"))
__err__(ERROR_ELFSCNMISMATCH, _("Request error: section does not belong to file"))
__err__(ERROR_NOSUCHSCN, _("Request error: no section at index"))
__err__(ERROR_NULLSCN, _("Request error: can't manipulate null section"))
__err__(ERROR_SCNDATAMISMATCH, _("Request error: data does not belong to section"))
__err__(ERROR_NOSTRTAB, _("Request error: no string table"))
__err__(ERROR_BADSTROFF, _("Request error: string table offset out of range"))
__err__(ERROR_RDONLY, _("Request error: update(ELF_C_WRITE) on read-only file"))
__err__(ERROR_IO_SEEK, _("I/O error: seek"))
__err__(ERROR_IO_2BIG, _("I/O error: file too big for memory"))
__err__(ERROR_IO_READ, _("I/O error: raw read"))
__err__(ERROR_IO_GETSIZE, _("I/O error: get file size"))
__err__(ERROR_IO_WRITE, _("I/O error: output write"))
__err__(ERROR_IO_TRUNC, _("I/O error: can't truncate output file"))
__err__(ERROR_VERSION_UNSET, _("Sequence error: must set ELF version first"))
__err__(ERROR_NOEHDR, _("Sequence error: must create ELF header first"))
__err__(ERROR_OUTSIDE, _("Format error: reference outside file"))
__err__(ERROR_TRUNC_ARHDR, _("Format error: archive header truncated"))
__err__(ERROR_ARFMAG, _("Format error: archive fmag"))
__err__(ERROR_ARHDR, _("Format error: archive header"))
__err__(ERROR_TRUNC_MEMBER, _("Format error: archive member truncated"))
__err__(ERROR_SIZE_ARSYMTAB, _("Format error: archive symbol table size"))
__err__(ERROR_ARSTRTAB, _("Format error: archive string table"))
__err__(ERROR_ARSPECIAL, _("Format error: archive special name unknown"))
__err__(ERROR_TRUNC_EHDR, _("Format error: ELF header truncated"))
__err__(ERROR_TRUNC_PHDR, _("Format error: program header table truncated"))
__err__(ERROR_TRUNC_SHDR, _("Format error: section header table truncated"))
__err__(ERROR_TRUNC_SCN, _("Format error: data region truncated"))
__err__(ERROR_ALIGN_PHDR, _("Format error: program header table alignment"))
__err__(ERROR_ALIGN_SHDR, _("Format error: section header table alignment"))
__err__(ERROR_VERDEF_FORMAT, _("Format error: bad parameter in Verdef record"))
__err__(ERROR_VERDEF_VERSION, _("Format error: unknown Verdef version"))
__err__(ERROR_VERNEED_FORMAT, _("Format error: bad parameter in Verneed record"))
__err__(ERROR_VERNEED_VERSION, _("Format error: unknown Verneed version"))
__err__(ERROR_EHDR_SHNUM, _("Format error: bad e_shnum value"))
__err__(ERROR_EHDR_SHENTSIZE, _("Format error: bad e_shentsize value"))
__err__(ERROR_EHDR_PHENTSIZE, _("Format error: bad e_phentsize value"))
__err__(ERROR_UNTERM, _("Format error: unterminated string in string table"))
__err__(ERROR_SCN2SMALL, _("Layout error: section size too small for data"))
__err__(ERROR_SCN_OVERLAP, _("Layout error: overlapping sections"))
__err__(ERROR_MEM_ELF, _("Memory error: elf descriptor"))
__err__(ERROR_MEM_ARSYMTAB, _("Memory error: archive symbol table"))
__err__(ERROR_MEM_ARHDR, _("Memory error: archive member header"))
__err__(ERROR_MEM_EHDR, _("Memory error: ELF header"))
__err__(ERROR_MEM_PHDR, _("Memory error: program header table"))
__err__(ERROR_MEM_SHDR, _("Memory error: section header table"))
__err__(ERROR_MEM_SCN, _("Memory error: section descriptor"))
__err__(ERROR_MEM_SCNDATA, _("Memory error: section data"))
__err__(ERROR_MEM_OUTBUF, _("Memory error: output file space"))
__err__(ERROR_MEM_TEMPORARY, _("Memory error: temporary buffer"))
__err__(ERROR_BADVALUE, _("GElf error: value out of range"))
__err__(ERROR_BADINDEX, _("GElf error: index out of range"))
__err__(ERROR_BADTYPE, _("GElf error: type mismatch"))
__err__(ERROR_MEM_SYM, _("GElf error: not enough memory for GElf_Sym"))
__err__(ERROR_MEM_DYN, _("GElf error: not enough memory for GElf_Dyn"))
__err__(ERROR_MEM_RELA, _("GElf error: not enough memory for GElf_Rela"))
__err__(ERROR_MEM_REL, _("GElf error: not enough memory for GElf_Rel"))

334
external/libelf/src/ext_types.h vendored Normal file
View File

@ -0,0 +1,334 @@
/*
ext_types.h - external representation of ELF data types.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/* @(#) $Id: ext_types.h,v 1.9 2008/05/23 08:15:34 michael Exp $ */
#ifndef _EXT_TYPES_H
#define _EXT_TYPES_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/*
* Scalar data types
*/
typedef unsigned char __ext_Elf32_Addr [ELF32_FSZ_ADDR];
typedef unsigned char __ext_Elf32_Half [ELF32_FSZ_HALF];
typedef unsigned char __ext_Elf32_Off [ELF32_FSZ_OFF];
typedef unsigned char __ext_Elf32_Sword [ELF32_FSZ_SWORD];
typedef unsigned char __ext_Elf32_Word [ELF32_FSZ_WORD];
#if __LIBELF64
typedef unsigned char __ext_Elf32_Lword [8];
typedef unsigned char __ext_Elf64_Addr [ELF64_FSZ_ADDR];
typedef unsigned char __ext_Elf64_Half [ELF64_FSZ_HALF];
typedef unsigned char __ext_Elf64_Off [ELF64_FSZ_OFF];
typedef unsigned char __ext_Elf64_Sword [ELF64_FSZ_SWORD];
typedef unsigned char __ext_Elf64_Word [ELF64_FSZ_WORD];
typedef unsigned char __ext_Elf64_Sxword[ELF64_FSZ_SXWORD];
typedef unsigned char __ext_Elf64_Xword [ELF64_FSZ_XWORD];
typedef unsigned char __ext_Elf64_Lword [8];
#endif /* __LIBELF64 */
/*
* ELF header
*/
typedef struct {
unsigned char e_ident[EI_NIDENT];
__ext_Elf32_Half e_type;
__ext_Elf32_Half e_machine;
__ext_Elf32_Word e_version;
__ext_Elf32_Addr e_entry;
__ext_Elf32_Off e_phoff;
__ext_Elf32_Off e_shoff;
__ext_Elf32_Word e_flags;
__ext_Elf32_Half e_ehsize;
__ext_Elf32_Half e_phentsize;
__ext_Elf32_Half e_phnum;
__ext_Elf32_Half e_shentsize;
__ext_Elf32_Half e_shnum;
__ext_Elf32_Half e_shstrndx;
} __ext_Elf32_Ehdr;
#if __LIBELF64
typedef struct {
unsigned char e_ident[EI_NIDENT];
__ext_Elf64_Half e_type;
__ext_Elf64_Half e_machine;
__ext_Elf64_Word e_version;
__ext_Elf64_Addr e_entry;
__ext_Elf64_Off e_phoff;
__ext_Elf64_Off e_shoff;
__ext_Elf64_Word e_flags;
__ext_Elf64_Half e_ehsize;
__ext_Elf64_Half e_phentsize;
__ext_Elf64_Half e_phnum;
__ext_Elf64_Half e_shentsize;
__ext_Elf64_Half e_shnum;
__ext_Elf64_Half e_shstrndx;
} __ext_Elf64_Ehdr;
#endif /* __LIBELF64 */
/*
* Section header
*/
typedef struct {
__ext_Elf32_Word sh_name;
__ext_Elf32_Word sh_type;
__ext_Elf32_Word sh_flags;
__ext_Elf32_Addr sh_addr;
__ext_Elf32_Off sh_offset;
__ext_Elf32_Word sh_size;
__ext_Elf32_Word sh_link;
__ext_Elf32_Word sh_info;
__ext_Elf32_Word sh_addralign;
__ext_Elf32_Word sh_entsize;
} __ext_Elf32_Shdr;
#if __LIBELF64
typedef struct {
__ext_Elf64_Word sh_name;
__ext_Elf64_Word sh_type;
__ext_Elf64_Xword sh_flags;
__ext_Elf64_Addr sh_addr;
__ext_Elf64_Off sh_offset;
__ext_Elf64_Xword sh_size;
__ext_Elf64_Word sh_link;
__ext_Elf64_Word sh_info;
__ext_Elf64_Xword sh_addralign;
__ext_Elf64_Xword sh_entsize;
} __ext_Elf64_Shdr;
#endif /* __LIBELF64 */
/*
* Symbol table
*/
typedef struct {
__ext_Elf32_Word st_name;
__ext_Elf32_Addr st_value;
__ext_Elf32_Word st_size;
unsigned char st_info;
unsigned char st_other;
__ext_Elf32_Half st_shndx;
} __ext_Elf32_Sym;
#if __LIBELF64
typedef struct {
__ext_Elf64_Word st_name;
unsigned char st_info;
unsigned char st_other;
__ext_Elf64_Half st_shndx;
__ext_Elf64_Addr st_value;
__ext_Elf64_Xword st_size;
} __ext_Elf64_Sym;
#endif /* __LIBELF64 */
/*
* Relocation
*/
typedef struct {
__ext_Elf32_Addr r_offset;
__ext_Elf32_Word r_info;
} __ext_Elf32_Rel;
typedef struct {
__ext_Elf32_Addr r_offset;
__ext_Elf32_Word r_info;
__ext_Elf32_Sword r_addend;
} __ext_Elf32_Rela;
#if __LIBELF64
typedef struct {
__ext_Elf64_Addr r_offset;
#if __LIBELF64_IRIX
__ext_Elf64_Word r_sym;
unsigned char r_ssym;
unsigned char r_type3;
unsigned char r_type2;
unsigned char r_type;
#else /* __LIBELF64_IRIX */
__ext_Elf64_Xword r_info;
#endif /* __LIBELF64_IRIX */
} __ext_Elf64_Rel;
typedef struct {
__ext_Elf64_Addr r_offset;
#if __LIBELF64_IRIX
__ext_Elf64_Word r_sym;
unsigned char r_ssym;
unsigned char r_type3;
unsigned char r_type2;
unsigned char r_type;
#else /* __LIBELF64_IRIX */
__ext_Elf64_Xword r_info;
#endif /* __LIBELF64_IRIX */
__ext_Elf64_Sxword r_addend;
} __ext_Elf64_Rela;
#endif /* __LIBELF64 */
/*
* Program header
*/
typedef struct {
__ext_Elf32_Word p_type;
__ext_Elf32_Off p_offset;
__ext_Elf32_Addr p_vaddr;
__ext_Elf32_Addr p_paddr;
__ext_Elf32_Word p_filesz;
__ext_Elf32_Word p_memsz;
__ext_Elf32_Word p_flags;
__ext_Elf32_Word p_align;
} __ext_Elf32_Phdr;
#if __LIBELF64
typedef struct {
__ext_Elf64_Word p_type;
__ext_Elf64_Word p_flags;
__ext_Elf64_Off p_offset;
__ext_Elf64_Addr p_vaddr;
__ext_Elf64_Addr p_paddr;
__ext_Elf64_Xword p_filesz;
__ext_Elf64_Xword p_memsz;
__ext_Elf64_Xword p_align;
} __ext_Elf64_Phdr;
#endif /* __LIBELF64 */
/*
* Dynamic structure
*/
typedef struct {
__ext_Elf32_Sword d_tag;
union {
__ext_Elf32_Word d_val;
__ext_Elf32_Addr d_ptr;
} d_un;
} __ext_Elf32_Dyn;
#if __LIBELF64
typedef struct {
__ext_Elf64_Sxword d_tag;
union {
__ext_Elf64_Xword d_val;
__ext_Elf64_Addr d_ptr;
} d_un;
} __ext_Elf64_Dyn;
#endif /* __LIBELF64 */
/*
* Version definitions
*/
typedef struct {
__ext_Elf32_Half vd_version;
__ext_Elf32_Half vd_flags;
__ext_Elf32_Half vd_ndx;
__ext_Elf32_Half vd_cnt;
__ext_Elf32_Word vd_hash;
__ext_Elf32_Word vd_aux;
__ext_Elf32_Word vd_next;
} __ext_Elf32_Verdef;
typedef struct {
__ext_Elf32_Word vda_name;
__ext_Elf32_Word vda_next;
} __ext_Elf32_Verdaux;
typedef struct {
__ext_Elf32_Half vn_version;
__ext_Elf32_Half vn_cnt;
__ext_Elf32_Word vn_file;
__ext_Elf32_Word vn_aux;
__ext_Elf32_Word vn_next;
} __ext_Elf32_Verneed;
typedef struct {
__ext_Elf32_Word vna_hash;
__ext_Elf32_Half vna_flags;
__ext_Elf32_Half vna_other;
__ext_Elf32_Word vna_name;
__ext_Elf32_Word vna_next;
} __ext_Elf32_Vernaux;
#if __LIBELF64
typedef struct {
__ext_Elf64_Half vd_version;
__ext_Elf64_Half vd_flags;
__ext_Elf64_Half vd_ndx;
__ext_Elf64_Half vd_cnt;
__ext_Elf64_Word vd_hash;
__ext_Elf64_Word vd_aux;
__ext_Elf64_Word vd_next;
} __ext_Elf64_Verdef;
typedef struct {
__ext_Elf64_Word vda_name;
__ext_Elf64_Word vda_next;
} __ext_Elf64_Verdaux;
typedef struct {
__ext_Elf64_Half vn_version;
__ext_Elf64_Half vn_cnt;
__ext_Elf64_Word vn_file;
__ext_Elf64_Word vn_aux;
__ext_Elf64_Word vn_next;
} __ext_Elf64_Verneed;
typedef struct {
__ext_Elf64_Word vna_hash;
__ext_Elf64_Half vna_flags;
__ext_Elf64_Half vna_other;
__ext_Elf64_Word vna_name;
__ext_Elf64_Word vna_next;
} __ext_Elf64_Vernaux;
#endif /* __LIBELF64 */
/*
* Move section
*/
#if __LIBELF64
typedef struct {
__ext_Elf32_Lword m_value;
__ext_Elf32_Word m_info;
__ext_Elf32_Word m_poffset;
__ext_Elf32_Half m_repeat;
__ext_Elf32_Half m_stride;
} __ext_Elf32_Move;
typedef struct {
__ext_Elf64_Lword m_value;
__ext_Elf64_Xword m_info;
__ext_Elf64_Xword m_poffset;
__ext_Elf64_Half m_repeat;
__ext_Elf64_Half m_stride;
} __ext_Elf64_Move;
#endif /* __LIBELF64 */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _EXT_TYPES_H */

29
external/libelf/src/fill.c vendored Normal file
View File

@ -0,0 +1,29 @@
/*
fill.c - implementation of the elf_fill(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: fill.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
void
elf_fill(int fill) {
_elf_fill = fill;
}

92
external/libelf/src/flag.c vendored Normal file
View File

@ -0,0 +1,92 @@
/*
flag.c - implementation of the elf_flag*(3) functions.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: flag.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
static unsigned
_elf_flag(unsigned *f, Elf_Cmd cmd, unsigned flags) {
if (cmd == ELF_C_SET) {
return *f |= flags;
}
if (cmd == ELF_C_CLR) {
return *f &= ~flags;
}
seterr(ERROR_INVALID_CMD);
return 0;
}
unsigned
elf_flagdata(Elf_Data *data, Elf_Cmd cmd, unsigned flags) {
Scn_Data *sd = (Scn_Data*)data;
if (!sd) {
return 0;
}
elf_assert(sd->sd_magic == DATA_MAGIC);
return _elf_flag(&sd->sd_data_flags, cmd, flags);
}
unsigned
elf_flagehdr(Elf *elf, Elf_Cmd cmd, unsigned flags) {
if (!elf) {
return 0;
}
elf_assert(elf->e_magic == ELF_MAGIC);
return _elf_flag(&elf->e_ehdr_flags, cmd, flags);
}
unsigned
elf_flagelf(Elf *elf, Elf_Cmd cmd, unsigned flags) {
if (!elf) {
return 0;
}
elf_assert(elf->e_magic == ELF_MAGIC);
return _elf_flag(&elf->e_elf_flags, cmd, flags);
}
unsigned
elf_flagphdr(Elf *elf, Elf_Cmd cmd, unsigned flags) {
if (!elf) {
return 0;
}
elf_assert(elf->e_magic == ELF_MAGIC);
return _elf_flag(&elf->e_phdr_flags, cmd, flags);
}
unsigned
elf_flagscn(Elf_Scn *scn, Elf_Cmd cmd, unsigned flags) {
if (!scn) {
return 0;
}
elf_assert(scn->s_magic == SCN_MAGIC);
return _elf_flag(&scn->s_scn_flags, cmd, flags);
}
unsigned
elf_flagshdr(Elf_Scn *scn, Elf_Cmd cmd, unsigned flags) {
if (!scn) {
return 0;
}
elf_assert(scn->s_magic == SCN_MAGIC);
return _elf_flag(&scn->s_shdr_flags, cmd, flags);
}

155
external/libelf/src/gelf.h vendored Normal file
View File

@ -0,0 +1,155 @@
/*
* gelf.h - public header file for libelf.
* Copyright (C) 2000 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/* @(#) $Id: gelf.h,v 1.16 2008/05/23 08:15:34 michael Exp $ */
#ifndef _GELF_H
#define _GELF_H
#if __LIBELF_INTERNAL__
#include <libelf.h>
#else /* __LIBELF_INTERNAL__ */
#include <libelf/libelf.h>
#endif /* __LIBELF_INTERNAL__ */
#if __LIBELF_NEED_LINK_H
#include <link.h>
#elif __LIBELF_NEED_SYS_LINK_H
#include <sys/link.h>
#endif /* __LIBELF_NEED_LINK_H */
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#ifndef __P
# if (__STDC__ + 0) || defined(__cplusplus) || defined(_WIN32)
# define __P(args) args
# else /* __STDC__ || defined(__cplusplus) */
# define __P(args) ()
# endif /* __STDC__ || defined(__cplusplus) */
#endif /* __P */
#if !__LIBELF64
#error "GElf is not supported on this system."
#else /* __LIBELF64 */
typedef Elf64_Addr GElf_Addr;
typedef Elf64_Half GElf_Half;
typedef Elf64_Off GElf_Off;
typedef Elf64_Sword GElf_Sword;
typedef Elf64_Word GElf_Word;
typedef Elf64_Sxword GElf_Sxword;
typedef Elf64_Xword GElf_Xword;
typedef Elf64_Ehdr GElf_Ehdr;
typedef Elf64_Phdr GElf_Phdr;
typedef Elf64_Shdr GElf_Shdr;
typedef Elf64_Dyn GElf_Dyn;
typedef Elf64_Rel GElf_Rel;
typedef Elf64_Rela GElf_Rela;
typedef Elf64_Sym GElf_Sym;
/*
* Symbol versioning
*/
#if __LIBELF_SYMBOL_VERSIONS
typedef Elf64_Verdef GElf_Verdef;
typedef Elf64_Verneed GElf_Verneed;
typedef Elf64_Verdaux GElf_Verdaux;
typedef Elf64_Vernaux GElf_Vernaux;
#endif /* __LIBELF_SYMBOL_VERSIONS */
/*
* These types aren't implemented (yet)
*
typedef Elf64_Move GElf_Move;
typedef Elf64_Syminfo GElf_Syminfo;
*/
/*
* Generic macros
*/
#define GELF_ST_BIND ELF64_ST_BIND
#define GELF_ST_TYPE ELF64_ST_TYPE
#define GELF_ST_INFO ELF64_ST_INFO
#define GELF_R_TYPE ELF64_R_TYPE
#define GELF_R_SYM ELF64_R_SYM
#define GELF_R_INFO ELF64_R_INFO
/*
* Function declarations
*/
extern int gelf_getclass __P((Elf *__elf));
extern size_t gelf_fsize __P((Elf *__elf, Elf_Type __type, size_t __count, unsigned __ver));
extern Elf_Data *gelf_xlatetof __P((Elf *__elf, Elf_Data *__dst, const Elf_Data *__src, unsigned __encode));
extern Elf_Data *gelf_xlatetom __P((Elf *__elf, Elf_Data *__dst, const Elf_Data *__src, unsigned __encode));
extern GElf_Ehdr *gelf_getehdr __P((Elf *__elf, GElf_Ehdr *__dst));
extern int gelf_update_ehdr __P((Elf *__elf, GElf_Ehdr *__src));
extern unsigned long gelf_newehdr __P((Elf *__elf, int __elfclass));
extern GElf_Phdr *gelf_getphdr __P((Elf *__elf, int ndx, GElf_Phdr *__dst));
extern int gelf_update_phdr __P((Elf *__elf, int ndx, GElf_Phdr *__src));
extern unsigned long gelf_newphdr __P((Elf *__elf, size_t __phnum));
extern GElf_Shdr *gelf_getshdr __P((Elf_Scn *__scn, GElf_Shdr *__dst));
extern int gelf_update_shdr __P((Elf_Scn *__scn, GElf_Shdr *__src));
extern GElf_Dyn *gelf_getdyn __P((Elf_Data *__src, int __ndx, GElf_Dyn *__dst));
extern int gelf_update_dyn __P((Elf_Data *__dst, int __ndx, GElf_Dyn *__src));
extern GElf_Rel *gelf_getrel __P((Elf_Data *__src, int __ndx, GElf_Rel *__dst));
extern int gelf_update_rel __P((Elf_Data *__dst, int __ndx, GElf_Rel *__src));
extern GElf_Rela *gelf_getrela __P((Elf_Data *__src, int __ndx, GElf_Rela *__dst));
extern int gelf_update_rela __P((Elf_Data *__dst, int __ndx, GElf_Rela *__src));
extern GElf_Sym *gelf_getsym __P((Elf_Data *__src, int __ndx, GElf_Sym *__dst));
extern int gelf_update_sym __P((Elf_Data *__dst, int __ndx, GElf_Sym *__src));
extern long gelf_checksum __P((Elf *__elf));
/*
* These functions aren't implemented (yet)
*
extern GElf_Move *gelf_getmove __P((Elf_Data *__src, int __ndx, GElf_Move *__src));
extern int gelf_update_move __P((Elf_Data *__dst, int __ndx, GElf_Move *__src));
*
extern GElf_Syminfo* gelf_getsyminfo __P((Elf_Data *__src, int __ndx, GElf_Syminfo *__dst));
extern int gelf_update_syminfo __P((Elf_Data *__dst, int __ndx, GElf_Syminfo *__src));
*/
/*
* Extensions (not available in other versions of libelf)
*/
extern size_t gelf_msize __P((Elf *__elf, Elf_Type __type, size_t __count, unsigned __ver));
#endif /* __LIBELF64 */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _GELF_H */

140
external/libelf/src/gelfehdr.c vendored Normal file
View File

@ -0,0 +1,140 @@
/*
* gelfehdr.c - gelf_* translation functions.
* Copyright (C) 2000 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#if __LIBELF64
#ifndef lint
static const char rcsid[] = "@(#) $Id: gelfehdr.c,v 1.9 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
#define check_and_copy(type, d, s, name, eret) \
do { \
if (sizeof((d)->name) < sizeof((s)->name) \
&& (type)(s)->name != (s)->name) { \
seterr(ERROR_BADVALUE); \
return (eret); \
} \
(d)->name = (type)(s)->name; \
} while (0)
GElf_Ehdr*
gelf_getehdr(Elf *elf, GElf_Ehdr *dst) {
GElf_Ehdr buf;
char *tmp;
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
tmp = _elf_getehdr(elf, elf->e_class);
if (!tmp) {
return NULL;
}
if (!dst) {
dst = &buf;
}
if (elf->e_class == ELFCLASS64) {
*dst = *(Elf64_Ehdr*)tmp;
}
else if (elf->e_class == ELFCLASS32) {
Elf32_Ehdr *src = (Elf32_Ehdr*)tmp;
memcpy(dst->e_ident, src->e_ident, EI_NIDENT);
check_and_copy(GElf_Half, dst, src, e_type, NULL);
check_and_copy(GElf_Half, dst, src, e_machine, NULL);
check_and_copy(GElf_Word, dst, src, e_version, NULL);
check_and_copy(GElf_Addr, dst, src, e_entry, NULL);
check_and_copy(GElf_Off, dst, src, e_phoff, NULL);
check_and_copy(GElf_Off, dst, src, e_shoff, NULL);
check_and_copy(GElf_Word, dst, src, e_flags, NULL);
check_and_copy(GElf_Half, dst, src, e_ehsize, NULL);
check_and_copy(GElf_Half, dst, src, e_phentsize, NULL);
check_and_copy(GElf_Half, dst, src, e_phnum, NULL);
check_and_copy(GElf_Half, dst, src, e_shentsize, NULL);
check_and_copy(GElf_Half, dst, src, e_shnum, NULL);
check_and_copy(GElf_Half, dst, src, e_shstrndx, NULL);
}
else {
if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return NULL;
}
if (dst == &buf) {
dst = (GElf_Ehdr*)malloc(sizeof(GElf_Ehdr));
if (!dst) {
seterr(ERROR_MEM_EHDR);
return NULL;
}
*dst = buf;
}
return dst;
}
int
gelf_update_ehdr(Elf *elf, GElf_Ehdr *src) {
char *tmp;
if (!elf || !src) {
return 0;
}
elf_assert(elf->e_magic == ELF_MAGIC);
tmp = _elf_getehdr(elf, elf->e_class);
if (!tmp) {
return 0;
}
if (elf->e_class == ELFCLASS64) {
*(Elf64_Ehdr*)tmp = *src;
}
else if (elf->e_class == ELFCLASS32) {
Elf32_Ehdr *dst = (Elf32_Ehdr*)tmp;
memcpy(dst->e_ident, src->e_ident, EI_NIDENT);
check_and_copy(Elf32_Half, dst, src, e_type, 0);
check_and_copy(Elf32_Half, dst, src, e_machine, 0);
check_and_copy(Elf32_Word, dst, src, e_version, 0);
check_and_copy(Elf32_Addr, dst, src, e_entry, 0);
check_and_copy(Elf32_Off, dst, src, e_phoff, 0);
check_and_copy(Elf32_Off, dst, src, e_shoff, 0);
check_and_copy(Elf32_Word, dst, src, e_flags, 0);
check_and_copy(Elf32_Half, dst, src, e_ehsize, 0);
check_and_copy(Elf32_Half, dst, src, e_phentsize, 0);
check_and_copy(Elf32_Half, dst, src, e_phnum, 0);
check_and_copy(Elf32_Half, dst, src, e_shentsize, 0);
check_and_copy(Elf32_Half, dst, src, e_shnum, 0);
check_and_copy(Elf32_Half, dst, src, e_shstrndx, 0);
}
else {
if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return 0;
}
return 1;
}
#endif /* __LIBELF64 */

148
external/libelf/src/gelfphdr.c vendored Normal file
View File

@ -0,0 +1,148 @@
/*
* gelfphdr.c - gelf_* translation functions.
* Copyright (C) 2000 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#if __LIBELF64
#ifndef lint
static const char rcsid[] = "@(#) $Id: gelfphdr.c,v 1.9 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
#define check_and_copy(type, d, s, name, eret) \
do { \
if (sizeof((d)->name) < sizeof((s)->name) \
&& (type)(s)->name != (s)->name) { \
seterr(ERROR_BADVALUE); \
return (eret); \
} \
(d)->name = (type)(s)->name; \
} while (0)
GElf_Phdr*
gelf_getphdr(Elf *elf, int ndx, GElf_Phdr *dst) {
GElf_Phdr buf;
char *tmp;
size_t n;
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
tmp = _elf_getphdr(elf, elf->e_class);
if (!tmp) {
return NULL;
}
if (ndx < 0 || ndx >= elf->e_phnum) {
seterr(ERROR_BADINDEX);
return NULL;
}
n = _msize(elf->e_class, _elf_version, ELF_T_PHDR);
if (n == 0) {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
if (!dst) {
dst = &buf;
}
if (elf->e_class == ELFCLASS64) {
*dst = *(Elf64_Phdr*)(tmp + ndx * n);
}
else if (elf->e_class == ELFCLASS32) {
Elf32_Phdr *src = (Elf32_Phdr*)(tmp + ndx * n);
check_and_copy(GElf_Word, dst, src, p_type, NULL);
check_and_copy(GElf_Word, dst, src, p_flags, NULL);
check_and_copy(GElf_Off, dst, src, p_offset, NULL);
check_and_copy(GElf_Addr, dst, src, p_vaddr, NULL);
check_and_copy(GElf_Addr, dst, src, p_paddr, NULL);
check_and_copy(GElf_Xword, dst, src, p_filesz, NULL);
check_and_copy(GElf_Xword, dst, src, p_memsz, NULL);
check_and_copy(GElf_Xword, dst, src, p_align, NULL);
}
else {
if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return NULL;
}
if (dst == &buf) {
dst = (GElf_Phdr*)malloc(sizeof(GElf_Phdr));
if (!dst) {
seterr(ERROR_MEM_PHDR);
return NULL;
}
*dst = buf;
}
return dst;
}
int
gelf_update_phdr(Elf *elf, int ndx, GElf_Phdr *src) {
char *tmp;
size_t n;
if (!elf || !src) {
return 0;
}
elf_assert(elf->e_magic == ELF_MAGIC);
tmp = _elf_getphdr(elf, elf->e_class);
if (!tmp) {
return 0;
}
if (ndx < 0 || ndx >= elf->e_phnum) {
seterr(ERROR_BADINDEX);
return 0;
}
n = _msize(elf->e_class, _elf_version, ELF_T_PHDR);
if (n == 0) {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
if (elf->e_class == ELFCLASS64) {
*(Elf64_Phdr*)(tmp + ndx * n) = *src;
}
else if (elf->e_class == ELFCLASS32) {
Elf32_Phdr *dst = (Elf32_Phdr*)(tmp + ndx * n);
check_and_copy(Elf32_Word, dst, src, p_type, 0);
check_and_copy(Elf32_Off, dst, src, p_offset, 0);
check_and_copy(Elf32_Addr, dst, src, p_vaddr, 0);
check_and_copy(Elf32_Addr, dst, src, p_paddr, 0);
check_and_copy(Elf32_Word, dst, src, p_filesz, 0);
check_and_copy(Elf32_Word, dst, src, p_memsz, 0);
check_and_copy(Elf32_Word, dst, src, p_flags, 0);
check_and_copy(Elf32_Word, dst, src, p_align, 0);
}
else {
if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return 0;
}
return 1;
}
#endif /* __LIBELF64 */

125
external/libelf/src/gelfshdr.c vendored Normal file
View File

@ -0,0 +1,125 @@
/*
* gelfshdr.c - gelf_* translation functions.
* Copyright (C) 2000 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#if __LIBELF64
#ifndef lint
static const char rcsid[] = "@(#) $Id: gelfshdr.c,v 1.10 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
#define check_and_copy(type, d, s, name, eret) \
do { \
if (sizeof((d)->name) < sizeof((s)->name) \
&& (type)(s)->name != (s)->name) { \
seterr(ERROR_BADVALUE); \
return (eret); \
} \
(d)->name = (type)(s)->name; \
} while (0)
GElf_Shdr*
gelf_getshdr(Elf_Scn *scn, GElf_Shdr *dst) {
GElf_Shdr buf;
if (!scn) {
return NULL;
}
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(scn->s_elf);
elf_assert(scn->s_elf->e_magic == ELF_MAGIC);
if (!dst) {
dst = &buf;
}
if (scn->s_elf->e_class == ELFCLASS64) {
*dst = scn->s_shdr64;
}
else if (scn->s_elf->e_class == ELFCLASS32) {
Elf32_Shdr *src = &scn->s_shdr32;
check_and_copy(GElf_Word, dst, src, sh_name, NULL);
check_and_copy(GElf_Word, dst, src, sh_type, NULL);
check_and_copy(GElf_Xword, dst, src, sh_flags, NULL);
check_and_copy(GElf_Addr, dst, src, sh_addr, NULL);
check_and_copy(GElf_Off, dst, src, sh_offset, NULL);
check_and_copy(GElf_Xword, dst, src, sh_size, NULL);
check_and_copy(GElf_Word, dst, src, sh_link, NULL);
check_and_copy(GElf_Word, dst, src, sh_info, NULL);
check_and_copy(GElf_Xword, dst, src, sh_addralign, NULL);
check_and_copy(GElf_Xword, dst, src, sh_entsize, NULL);
}
else {
if (valid_class(scn->s_elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return NULL;
}
if (dst == &buf) {
dst = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
if (!dst) {
seterr(ERROR_MEM_SHDR);
return NULL;
}
*dst = buf;
}
return dst;
}
int
gelf_update_shdr(Elf_Scn *scn, GElf_Shdr *src) {
if (!scn || !src) {
return 0;
}
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(scn->s_elf);
elf_assert(scn->s_elf->e_magic == ELF_MAGIC);
if (scn->s_elf->e_class == ELFCLASS64) {
scn->s_shdr64 = *src;
}
else if (scn->s_elf->e_class == ELFCLASS32) {
Elf32_Shdr *dst = &scn->s_shdr32;
check_and_copy(Elf32_Word, dst, src, sh_name, 0);
check_and_copy(Elf32_Word, dst, src, sh_type, 0);
check_and_copy(Elf32_Word, dst, src, sh_flags, 0);
check_and_copy(Elf32_Addr, dst, src, sh_addr, 0);
check_and_copy(Elf32_Off, dst, src, sh_offset, 0);
check_and_copy(Elf32_Word, dst, src, sh_size, 0);
check_and_copy(Elf32_Word, dst, src, sh_link, 0);
check_and_copy(Elf32_Word, dst, src, sh_info, 0);
check_and_copy(Elf32_Word, dst, src, sh_addralign, 0);
check_and_copy(Elf32_Word, dst, src, sh_entsize, 0);
}
else {
if (valid_class(scn->s_elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return 0;
}
return 1;
}
#endif /* __LIBELF64 */

407
external/libelf/src/gelftrans.c vendored Normal file
View File

@ -0,0 +1,407 @@
/*
gelftrans.c - gelf_* translation functions.
Copyright (C) 2000 - 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#if __LIBELF64
#ifndef lint
static const char rcsid[] = "@(#) $Id: gelftrans.c,v 1.10 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
#define check_and_copy(type, d, s, name, eret) \
do { \
if (sizeof((d)->name) < sizeof((s)->name) \
&& (type)(s)->name != (s)->name) { \
seterr(ERROR_BADVALUE); \
return (eret); \
} \
(d)->name = (type)(s)->name; \
} while (0)
/*
* These macros are missing on some Linux systems
*/
#if !defined(ELF32_R_SYM) || !defined(ELF32_R_TYPE) || !defined(ELF32_R_INFO)
# undef ELF32_R_SYM
# undef ELF32_R_TYPE
# undef ELF32_R_INFO
# define ELF32_R_SYM(i) ((i)>>8)
# define ELF32_R_TYPE(i) ((unsigned char)(i))
# define ELF32_R_INFO(s,t) (((s)<<8)+(unsigned char)(t))
#endif /* !defined(...) */
#if !defined(ELF64_R_SYM) || !defined(ELF64_R_TYPE) || !defined(ELF64_R_INFO)
# undef ELF64_R_SYM
# undef ELF64_R_TYPE
# undef ELF64_R_INFO
# define ELF64_R_SYM(i) ((i)>>32)
# define ELF64_R_TYPE(i) ((i)&0xffffffffL)
# define ELF64_R_INFO(s,t) (((Elf64_Xword)(s)<<32)+((t)&0xffffffffL))
#endif /* !defined(...) */
static char*
get_addr_and_class(const Elf_Data *data, int ndx, Elf_Type type, unsigned *cls) {
Scn_Data *sd = (Scn_Data*)data;
Elf_Scn *scn;
Elf *elf;
size_t n;
if (!sd) {
return NULL;
}
elf_assert(sd->sd_magic == DATA_MAGIC);
scn = sd->sd_scn;
elf_assert(scn);
elf_assert(scn->s_magic == SCN_MAGIC);
elf = scn->s_elf;
elf_assert(elf);
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
return NULL;
}
if (!valid_class(elf->e_class)) {
seterr(ERROR_UNKNOWN_CLASS);
return NULL;
}
if (data->d_type != type) {
seterr(ERROR_BADTYPE);
return NULL;
}
n = _msize(elf->e_class, data->d_version, type);
if (n == 0) {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
if (ndx < 0 || data->d_size < (ndx + 1) * n) {
seterr(ERROR_BADINDEX);
return NULL;
}
if (!data->d_buf) {
seterr(ERROR_NULLBUF);
return NULL;
}
if (cls) {
*cls = elf->e_class;
}
return (char*)data->d_buf + n * ndx;
}
GElf_Sym*
gelf_getsym(Elf_Data *src, int ndx, GElf_Sym *dst) {
GElf_Sym buf;
unsigned cls;
char *tmp;
if (!dst) {
dst = &buf;
}
tmp = get_addr_and_class(src, ndx, ELF_T_SYM, &cls);
if (!tmp) {
return NULL;
}
if (cls == ELFCLASS64) {
*dst = *(Elf64_Sym*)tmp;
}
else if (cls == ELFCLASS32) {
Elf32_Sym *src = (Elf32_Sym*)tmp;
check_and_copy(GElf_Word, dst, src, st_name, NULL);
check_and_copy(unsigned char, dst, src, st_info, NULL);
check_and_copy(unsigned char, dst, src, st_other, NULL);
check_and_copy(GElf_Half, dst, src, st_shndx, NULL);
check_and_copy(GElf_Addr, dst, src, st_value, NULL);
check_and_copy(GElf_Xword, dst, src, st_size, NULL);
}
else {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
if (dst == &buf) {
dst = (GElf_Sym*)malloc(sizeof(GElf_Sym));
if (!dst) {
seterr(ERROR_MEM_SYM);
return NULL;
}
*dst = buf;
}
return dst;
}
int
gelf_update_sym(Elf_Data *dst, int ndx, GElf_Sym *src) {
unsigned cls;
char *tmp;
tmp = get_addr_and_class(dst, ndx, ELF_T_SYM, &cls);
if (!tmp) {
return 0;
}
if (cls == ELFCLASS64) {
*(Elf64_Sym*)tmp = *src;
}
else if (cls == ELFCLASS32) {
Elf32_Sym *dst = (Elf32_Sym*)tmp;
check_and_copy(Elf32_Word, dst, src, st_name, 0);
check_and_copy(Elf32_Addr, dst, src, st_value, 0);
check_and_copy(Elf32_Word, dst, src, st_size, 0);
check_and_copy(unsigned char, dst, src, st_info, 0);
check_and_copy(unsigned char, dst, src, st_other, 0);
check_and_copy(Elf32_Half, dst, src, st_shndx, 0);
}
else {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
return 1;
}
GElf_Dyn*
gelf_getdyn(Elf_Data *src, int ndx, GElf_Dyn *dst) {
GElf_Dyn buf;
unsigned cls;
char *tmp;
if (!dst) {
dst = &buf;
}
tmp = get_addr_and_class(src, ndx, ELF_T_DYN, &cls);
if (!tmp) {
return NULL;
}
if (cls == ELFCLASS64) {
*dst = *(Elf64_Dyn*)tmp;
}
else if (cls == ELFCLASS32) {
Elf32_Dyn *src = (Elf32_Dyn*)tmp;
check_and_copy(GElf_Sxword, dst, src, d_tag, NULL);
check_and_copy(GElf_Xword, dst, src, d_un.d_val, NULL);
}
else {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
if (dst == &buf) {
dst = (GElf_Dyn*)malloc(sizeof(GElf_Dyn));
if (!dst) {
seterr(ERROR_MEM_DYN);
return NULL;
}
*dst = buf;
}
return dst;
}
int
gelf_update_dyn(Elf_Data *dst, int ndx, GElf_Dyn *src) {
unsigned cls;
char *tmp;
tmp = get_addr_and_class(dst, ndx, ELF_T_DYN, &cls);
if (!tmp) {
return 0;
}
if (cls == ELFCLASS64) {
*(Elf64_Dyn*)tmp = *src;
}
else if (cls == ELFCLASS32) {
Elf32_Dyn *dst = (Elf32_Dyn*)tmp;
check_and_copy(Elf32_Sword, dst, src, d_tag, 0);
check_and_copy(Elf32_Word, dst, src, d_un.d_val, 0);
}
else {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
return 1;
}
GElf_Rela*
gelf_getrela(Elf_Data *src, int ndx, GElf_Rela *dst) {
GElf_Rela buf;
unsigned cls;
char *tmp;
if (!dst) {
dst = &buf;
}
tmp = get_addr_and_class(src, ndx, ELF_T_RELA, &cls);
if (!tmp) {
return NULL;
}
if (cls == ELFCLASS64) {
*dst = *(Elf64_Rela*)tmp;
}
else if (cls == ELFCLASS32) {
Elf32_Rela *src = (Elf32_Rela*)tmp;
check_and_copy(GElf_Addr, dst, src, r_offset, NULL);
dst->r_info = ELF64_R_INFO((Elf64_Xword)ELF32_R_SYM(src->r_info),
(Elf64_Xword)ELF32_R_TYPE(src->r_info));
check_and_copy(GElf_Sxword, dst, src, r_addend, NULL);
}
else {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
if (dst == &buf) {
dst = (GElf_Rela*)malloc(sizeof(GElf_Rela));
if (!dst) {
seterr(ERROR_MEM_RELA);
return NULL;
}
*dst = buf;
}
return dst;
}
int
gelf_update_rela(Elf_Data *dst, int ndx, GElf_Rela *src) {
unsigned cls;
char *tmp;
tmp = get_addr_and_class(dst, ndx, ELF_T_RELA, &cls);
if (!tmp) {
return 0;
}
if (cls == ELFCLASS64) {
*(Elf64_Rela*)tmp = *src;
}
else if (cls == ELFCLASS32) {
Elf32_Rela *dst = (Elf32_Rela*)tmp;
check_and_copy(Elf32_Addr, dst, src, r_offset, 0);
if (ELF64_R_SYM(src->r_info) > 0xffffffUL
|| ELF64_R_TYPE(src->r_info) > 0xffUL) {
seterr(ERROR_BADVALUE);
return 0;
}
dst->r_info = ELF32_R_INFO((Elf32_Word)ELF64_R_SYM(src->r_info),
(Elf32_Word)ELF64_R_TYPE(src->r_info));
check_and_copy(Elf32_Sword, dst, src, r_addend, 0);
}
else {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
return 1;
}
GElf_Rel*
gelf_getrel(Elf_Data *src, int ndx, GElf_Rel *dst) {
GElf_Rel buf;
unsigned cls;
char *tmp;
if (!dst) {
dst = &buf;
}
tmp = get_addr_and_class(src, ndx, ELF_T_REL, &cls);
if (!tmp) {
return NULL;
}
if (cls == ELFCLASS64) {
*dst = *(Elf64_Rel*)tmp;
}
else if (cls == ELFCLASS32) {
Elf32_Rel *src = (Elf32_Rel*)tmp;
check_and_copy(GElf_Addr, dst, src, r_offset, NULL);
dst->r_info = ELF64_R_INFO((Elf64_Xword)ELF32_R_SYM(src->r_info),
(Elf64_Xword)ELF32_R_TYPE(src->r_info));
}
else {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
if (dst == &buf) {
dst = (GElf_Rel*)malloc(sizeof(GElf_Rel));
if (!dst) {
seterr(ERROR_MEM_REL);
return NULL;
}
*dst = buf;
}
return dst;
}
int
gelf_update_rel(Elf_Data *dst, int ndx, GElf_Rel *src) {
unsigned cls;
char *tmp;
tmp = get_addr_and_class(dst, ndx, ELF_T_REL, &cls);
if (!tmp) {
return 0;
}
if (cls == ELFCLASS64) {
*(Elf64_Rel*)tmp = *src;
}
else if (cls == ELFCLASS32) {
Elf32_Rel *dst = (Elf32_Rel*)tmp;
check_and_copy(Elf32_Addr, dst, src, r_offset, 0);
if (ELF64_R_SYM(src->r_info) > 0xffffffUL
|| ELF64_R_TYPE(src->r_info) > 0xffUL) {
seterr(ERROR_BADVALUE);
return 0;
}
dst->r_info = ELF32_R_INFO((Elf32_Word)ELF64_R_SYM(src->r_info),
(Elf32_Word)ELF64_R_TYPE(src->r_info));
}
else {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
return 1;
}
#if 0
GElf_Syminfo*
gelf_getsyminfo(Elf_Data *src, int ndx, GElf_Syminfo *dst) {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
int
gelf_update_syminfo(Elf_Data *dst, int ndx, GElf_Syminfo *src) {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
GElf_Move*
gelf_getmove(Elf_Data *src, int ndx, GElf_Move *src) {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
int
gelf_update_move(Elf_Data *dst, int ndx, GElf_Move *src) {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
#endif
#endif /* __LIBELF64 */

37
external/libelf/src/getarhdr.c vendored Normal file
View File

@ -0,0 +1,37 @@
/*
getarhdr.c - implementation of the elf_getarhdr(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: getarhdr.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
Elf_Arhdr*
elf_getarhdr(Elf *elf) {
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_arhdr) {
return elf->e_arhdr;
}
seterr(ERROR_NOTARCHIVE);
return NULL;
}

40
external/libelf/src/getaroff.c vendored Normal file
View File

@ -0,0 +1,40 @@
/*
* getaroff.c - implementation of the elf_getaroff(3) function.
* Copyright (C) 2009 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: getaroff.c,v 1.1 2009/11/01 13:04:19 michael Exp $";
#endif /* lint */
off_t
elf_getaroff(Elf *elf) {
Elf *ref;
if (!elf) {
return (off_t)-1;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (!(ref = elf->e_parent)) {
return (off_t)-1;
}
elf_assert(ref->e_magic == ELF_MAGIC);
elf_assert(elf->e_base >= ref->e_base + SARMAG + sizeof(struct ar_hdr));
return (off_t)(elf->e_base - ref->e_base - sizeof(struct ar_hdr));
}

87
external/libelf/src/getarsym.c vendored Normal file
View File

@ -0,0 +1,87 @@
/*
* getarsym.c - implementation of the elf_getarsym(3) function.
* Copyright (C) 1995 - 1998, 2004 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <byteswap.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: getarsym.c,v 1.9 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
Elf_Arsym*
elf_getarsym(Elf *elf, size_t *ptr) {
Elf_Arsym *syms;
size_t count;
size_t tmp;
size_t i;
char *s;
char *e;
if (!ptr) {
ptr = &tmp;
}
*ptr = 0;
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_AR) {
seterr(ERROR_NOTARCHIVE);
return NULL;
}
if (elf->e_symtab && !elf->e_free_syms) {
if (elf->e_symlen < 4) {
seterr(ERROR_SIZE_ARSYMTAB);
return NULL;
}
count = __load_u32M(elf->e_symtab);
if (elf->e_symlen < 4 * (count + 1)) {
seterr(ERROR_SIZE_ARSYMTAB);
return NULL;
}
if (!(syms = (Elf_Arsym*)malloc((count + 1) * sizeof(*syms)))) {
seterr(ERROR_MEM_ARSYMTAB);
return NULL;
}
s = elf->e_symtab + 4 * (count + 1);
e = elf->e_symtab + elf->e_symlen;
for (i = 0; i < count; i++, s++) {
syms[i].as_name = s;
while (s < e && *s) {
s++;
}
if (s >= e) {
seterr(ERROR_SIZE_ARSYMTAB);
free(syms);
return NULL;
}
elf_assert(!*s);
syms[i].as_hash = elf_hash((unsigned char*)syms[i].as_name);
syms[i].as_off = __load_u32M(elf->e_symtab + 4 * (i + 1));
}
syms[count].as_name = NULL;
syms[count].as_hash = ~0UL;
syms[count].as_off = 0;
elf->e_symtab = (char*)syms;
elf->e_symlen = count + 1;
elf->e_free_syms = 1;
}
*ptr = elf->e_symlen;
return (Elf_Arsym*)elf->e_symtab;
}

33
external/libelf/src/getbase.c vendored Normal file
View File

@ -0,0 +1,33 @@
/*
getbase.c - implementation of the elf_getbase(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: getbase.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
off_t
elf_getbase(Elf *elf) {
if (!elf) {
return -1;
}
elf_assert(elf->e_magic == ELF_MAGIC);
return (off_t)elf->e_base;
}

157
external/libelf/src/getdata.c vendored Normal file
View File

@ -0,0 +1,157 @@
/*
getdata.c - implementation of the elf_getdata(3) function.
Copyright (C) 1995 - 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: getdata.c,v 1.13 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
static Elf_Data*
_elf_cook_scn(Elf *elf, Elf_Scn *scn, Scn_Data *sd) {
Elf_Data dst;
Elf_Data src;
int flag = 0;
size_t dlen;
elf_assert(elf->e_data);
/*
* Prepare source
*/
src = sd->sd_data;
src.d_version = elf->e_version;
if (elf->e_rawdata) {
src.d_buf = elf->e_rawdata + scn->s_offset;
}
else {
src.d_buf = elf->e_data + scn->s_offset;
}
/*
* Prepare destination (needs prepared source!)
*/
dst = sd->sd_data;
if (elf->e_class == ELFCLASS32) {
dlen = _elf32_xltsize(&src, dst.d_version, elf->e_encoding, 0);
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
dlen = _elf64_xltsize(&src, dst.d_version, elf->e_encoding, 0);
}
#endif /* __LIBELF64 */
else {
elf_assert(valid_class(elf->e_class));
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
if (dlen == (size_t)-1) {
return NULL;
}
dst.d_size = dlen;
if (elf->e_rawdata != elf->e_data && dst.d_size <= src.d_size) {
dst.d_buf = elf->e_data + scn->s_offset;
}
else if (!(dst.d_buf = malloc(dst.d_size))) {
seterr(ERROR_MEM_SCNDATA);
return NULL;
}
else {
flag = 1;
}
/*
* Translate data
*/
if (_elf_xlatetom(elf, &dst, &src)) {
sd->sd_memdata = (char*)dst.d_buf;
sd->sd_data = dst;
if (!(sd->sd_free_data = flag)) {
elf->e_cooked = 1;
}
return &sd->sd_data;
}
if (flag) {
free(dst.d_buf);
}
return NULL;
}
Elf_Data*
elf_getdata(Elf_Scn *scn, Elf_Data *data) {
Scn_Data *sd;
Elf *elf;
if (!scn) {
return NULL;
}
elf_assert(scn->s_magic == SCN_MAGIC);
if (scn->s_index == SHN_UNDEF) {
seterr(ERROR_NULLSCN);
}
else if (data) {
for (sd = scn->s_data_1; sd; sd = sd->sd_link) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
if (data == &sd->sd_data) {
/*
* sd_link allocated by elf_newdata().
*/
return &sd->sd_link->sd_data;
}
}
seterr(ERROR_SCNDATAMISMATCH);
}
else if ((sd = scn->s_data_1)) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
elf = scn->s_elf;
elf_assert(elf);
elf_assert(elf->e_magic == ELF_MAGIC);
if (sd->sd_freeme) {
/* allocated by elf_newdata() */
return &sd->sd_data;
}
else if (scn->s_type == SHT_NULL) {
seterr(ERROR_NULLSCN);
}
else if (sd->sd_memdata) {
/* already cooked */
return &sd->sd_data;
}
else if (scn->s_offset < 0 || scn->s_offset > elf->e_size) {
seterr(ERROR_OUTSIDE);
}
else if (scn->s_type == SHT_NOBITS || !scn->s_size) {
/* no data to read */
return &sd->sd_data;
}
else if (scn->s_offset + scn->s_size > elf->e_size) {
seterr(ERROR_TRUNC_SCN);
}
else if (valid_class(elf->e_class)) {
return _elf_cook_scn(elf, scn, sd);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
}
return NULL;
}

48
external/libelf/src/getident.c vendored Normal file
View File

@ -0,0 +1,48 @@
/*
getident.c - implementation of the elf_getident(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: getident.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
#endif /* lint */
char*
elf_getident(Elf *elf, size_t *ptr) {
size_t tmp;
if (!ptr) {
ptr = &tmp;
}
if (!elf) {
*ptr = 0;
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_ELF) {
*ptr = elf->e_idlen;
return elf->e_data;
}
if (elf->e_ehdr || _elf_cook(elf)) {
*ptr = elf->e_idlen;
return elf->e_ehdr;
}
*ptr = 0;
return NULL;
}

48
external/libelf/src/getscn.c vendored Normal file
View File

@ -0,0 +1,48 @@
/*
getscn.c - implementation of the elf_getscn(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: getscn.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
Elf_Scn*
elf_getscn(Elf *elf, size_t index) {
Elf_Scn *scn;
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_ehdr || _elf_cook(elf)) {
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(scn->s_elf == elf);
if (scn->s_index == index) {
return scn;
}
}
seterr(ERROR_NOSUCHSCN);
}
return NULL;
}

38
external/libelf/src/hash.c vendored Normal file
View File

@ -0,0 +1,38 @@
/*
hash.c - implementation of the elf_hash(3) function.
Copyright (C) 1995 - 2002 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: hash.c,v 1.10 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
unsigned long
elf_hash(const unsigned char *name) {
unsigned long hash = 0;
unsigned long tmp;
while (*name) {
hash = (hash << 4) + (unsigned char)*name++;
if ((tmp = hash & 0xf0000000)) {
hash ^= tmp | (tmp >> 24);
}
}
return hash;
}

106
external/libelf/src/input.c vendored Normal file
View File

@ -0,0 +1,106 @@
/*
* input.c - low-level input for libelf.
* Copyright (C) 1995 - 2001, 2005 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: input.c,v 1.11 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
#include <errno.h>
#if HAVE_MMAP
#include <sys/mman.h>
#endif /* HAVE_MMAP */
static int
xread(int fd, char *buffer, size_t len) {
size_t done = 0;
size_t n;
while (done < len) {
n = read(fd, buffer + done, len - done);
if (n == 0) {
/* premature end of file */
return -1;
}
else if (n != (size_t)-1) {
/* some bytes read, continue */
done += n;
}
else if (errno != EAGAIN && errno != EINTR) {
/* real error */
return -1;
}
}
return 0;
}
void*
_elf_read(Elf *elf, void *buffer, size_t off, size_t len) {
void *tmp;
elf_assert(elf);
elf_assert(elf->e_magic == ELF_MAGIC);
elf_assert(off >= 0 && off + len <= elf->e_size);
if (elf->e_disabled) {
seterr(ERROR_FDDISABLED);
}
else if (len) {
off += elf->e_base;
if (lseek(elf->e_fd, (off_t)off, SEEK_SET) != (off_t)off) {
seterr(ERROR_IO_SEEK);
}
else if (!(tmp = buffer) && !(tmp = malloc(len))) {
seterr(ERROR_IO_2BIG);
}
else if (xread(elf->e_fd, tmp, len)) {
seterr(ERROR_IO_READ);
if (tmp != buffer) {
free(tmp);
}
}
else {
return tmp;
}
}
return NULL;
}
void*
_elf_mmap(Elf *elf) {
#if HAVE_MMAP
void *tmp;
elf_assert(elf);
elf_assert(elf->e_magic == ELF_MAGIC);
elf_assert(elf->e_base == 0);
if (elf->e_disabled) {
seterr(ERROR_FDDISABLED);
}
else if (elf->e_size) {
tmp = (void*)mmap(0, elf->e_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE, elf->e_fd, 0);
if (tmp != (void*)-1) {
return tmp;
}
}
#endif /* HAVE_MMAP */
return NULL;
}

33
external/libelf/src/kind.c vendored Normal file
View File

@ -0,0 +1,33 @@
/*
kind.c - implementation of the elf_kind(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: kind.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
Elf_Kind
elf_kind(Elf *elf) {
if (!elf) {
return ELF_K_NONE;
}
elf_assert(elf->e_magic == ELF_MAGIC);
return elf->e_kind;
}

82
external/libelf/src/libelf.def vendored Normal file
View File

@ -0,0 +1,82 @@
LIBRARY libelf
VERSION 0.8
EXPORTS
elf_begin
elf_cntl
elf_delscn
elf_end
elf_errmsg
elf_errno
elf_fill
elf_flagdata
elf_flagehdr
elf_flagelf
elf_flagphdr
elf_flagscn
elf_flagshdr
elf_getarhdr
elf_getarsym
elf_getbase
elf_getdata
elf_getident
elf_getscn
elf_hash
elf_kind
elf_memory
elf_ndxscn
elf_newdata
elf_newscn
elf_next
elf_nextscn
elf_rand
elf_rawdata
elf_rawfile
elf_strptr
elf_update
elf_version
elf32_checksum
elf32_fsize
elf32_getehdr
elf32_getphdr
elf32_getshdr
elf32_newehdr
elf32_newphdr
elf32_xlatetof
elf32_xlatetom
elf64_checksum
elf64_fsize
elf64_getehdr
elf64_getphdr
elf64_getshdr
elf64_newehdr
elf64_newphdr
elf64_xlatetof
elf64_xlatetom
elfx_movscn
elfx_remscn
gelf_checksum
gelf_fsize
gelf_getclass
gelf_getdyn
gelf_getehdr
gelf_getphdr
gelf_getrel
gelf_getrela
gelf_getshdr
gelf_getsym
gelf_msize
gelf_newehdr
gelf_newphdr
gelf_update_dyn
gelf_update_ehdr
gelf_update_phdr
gelf_update_rel
gelf_update_rela
gelf_update_shdr
gelf_update_sym
gelf_xlatetof
gelf_xlatetom
elf_getphnum
elf_getshnum
elf_getshstrndx
elfx_update_shstrndx

53
external/libelf/src/memset.c vendored Normal file
View File

@ -0,0 +1,53 @@
/*
* memset.c - replacement for memset(3), using duff's device.
* Copyright (C) 1995 - 2004 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
#ifndef lint
static const char rcsid[] = "@(#) $Id: memset.c,v 1.11 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
#include <stddef.h> /* for size_t */
#include <sys/types.h>
void*
_elf_memset(void *s, int c, size_t n) {
char *t = (char*)s;
if (n) {
switch (n % 8u) {
do {
n -= 8;
default:
case 0: *t++ = (char)c;
case 7: *t++ = (char)c;
case 6: *t++ = (char)c;
case 5: *t++ = (char)c;
case 4: *t++ = (char)c;
case 3: *t++ = (char)c;
case 2: *t++ = (char)c;
case 1: *t++ = (char)c;
}
while (n > 8);
}
}
return s;
}

33
external/libelf/src/ndxscn.c vendored Normal file
View File

@ -0,0 +1,33 @@
/*
ndxscn.c - implementation of the elf_ndxscn(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: ndxscn.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
size_t
elf_ndxscn(Elf_Scn *scn) {
if (!scn) {
return SHN_UNDEF;
}
elf_assert(scn->s_magic == SCN_MAGIC);
return scn->s_index;
}

56
external/libelf/src/newdata.c vendored Normal file
View File

@ -0,0 +1,56 @@
/*
newdata.c - implementation of the elf_newdata(3) function.
Copyright (C) 1995 - 2000 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: newdata.c,v 1.10 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
Elf_Data*
elf_newdata(Elf_Scn *scn) {
Scn_Data *sd;
if (!scn) {
return NULL;
}
elf_assert(scn->s_magic == SCN_MAGIC);
if (scn->s_index == SHN_UNDEF) {
seterr(ERROR_NULLSCN);
}
else if (!(sd = (Scn_Data*)malloc(sizeof(*sd)))) {
seterr(ERROR_MEM_SCNDATA);
}
else {
*sd = _elf_data_init;
sd->sd_scn = scn;
sd->sd_data_flags = ELF_F_DIRTY;
sd->sd_freeme = 1;
sd->sd_data.d_version = _elf_version;
if (scn->s_data_n) {
scn->s_data_n->sd_link = sd;
}
else {
scn->s_data_1 = sd;
}
scn->s_data_n = sd;
return &sd->sd_data;
}
return NULL;
}

145
external/libelf/src/newscn.c vendored Normal file
View File

@ -0,0 +1,145 @@
/*
* newscn.c - implementation of the elf_newscn(3) function.
* Copyright (C) 1995 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: newscn.c,v 1.13 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
int
_elf_update_shnum(Elf *elf, size_t shnum) {
size_t extshnum = 0;
Elf_Scn *scn;
elf_assert(elf);
elf_assert(elf->e_ehdr);
scn = elf->e_scn_1;
elf_assert(scn);
elf_assert(scn->s_index == 0);
if (shnum >= SHN_LORESERVE) {
extshnum = shnum;
shnum = 0;
}
if (elf->e_class == ELFCLASS32) {
((Elf32_Ehdr*)elf->e_ehdr)->e_shnum = shnum;
scn->s_shdr32.sh_size = extshnum;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
((Elf64_Ehdr*)elf->e_ehdr)->e_shnum = shnum;
scn->s_shdr64.sh_size = extshnum;
}
#endif /* __LIBELF64 */
else {
if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return -1;
}
elf->e_ehdr_flags |= ELF_F_DIRTY;
scn->s_shdr_flags |= ELF_F_DIRTY;
return 0;
}
static Elf_Scn*
_makescn(Elf *elf, size_t index) {
Elf_Scn *scn;
elf_assert(elf);
elf_assert(elf->e_magic == ELF_MAGIC);
elf_assert(elf->e_ehdr);
elf_assert(_elf_scn_init.s_magic == SCN_MAGIC);
if (!(scn = (Elf_Scn*)malloc(sizeof(*scn)))) {
seterr(ERROR_MEM_SCN);
return NULL;
}
*scn = _elf_scn_init;
scn->s_elf = elf;
scn->s_scn_flags = ELF_F_DIRTY;
scn->s_shdr_flags = ELF_F_DIRTY;
scn->s_freeme = 1;
scn->s_index = index;
return scn;
}
Elf_Scn*
_elf_first_scn(Elf *elf) {
Elf_Scn *scn;
elf_assert(elf);
elf_assert(elf->e_magic == ELF_MAGIC);
if ((scn = elf->e_scn_1)) {
return scn;
}
if ((scn = _makescn(elf, 0))) {
elf->e_scn_1 = elf->e_scn_n = scn;
if (_elf_update_shnum(elf, 1)) {
free(scn);
elf->e_scn_1 = elf->e_scn_n = scn = NULL;
}
}
return scn;
}
static Elf_Scn*
_buildscn(Elf *elf) {
Elf_Scn *scn;
if (!_elf_first_scn(elf)) {
return NULL;
}
scn = elf->e_scn_n;
elf_assert(scn);
if (!(scn = _makescn(elf, scn->s_index + 1))) {
return NULL;
}
if (_elf_update_shnum(elf, scn->s_index + 1)) {
free(scn);
return NULL;
}
elf->e_scn_n = elf->e_scn_n->s_link = scn;
return scn;
}
Elf_Scn*
elf_newscn(Elf *elf) {
Elf_Scn *scn;
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (!elf->e_readable && !elf->e_ehdr) {
seterr(ERROR_NOEHDR);
}
else if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (!elf->e_ehdr && !_elf_cook(elf)) {
return NULL;
}
else if ((scn = _buildscn(elf))) {
return scn;
}
return NULL;
}

42
external/libelf/src/next.c vendored Normal file
View File

@ -0,0 +1,42 @@
/*
next.c - implementation of the elf_next(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: next.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
Elf_Cmd
elf_next(Elf *elf) {
if (!elf) {
return ELF_C_NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (!elf->e_parent) {
return ELF_C_NULL;
}
elf_assert(elf->e_parent->e_magic == ELF_MAGIC);
elf_assert(elf->e_parent->e_kind == ELF_K_AR);
elf->e_parent->e_off = elf->e_next;
if (elf->e_next == elf->e_parent->e_size) {
return ELF_C_NULL;
}
return ELF_C_READ;
}

54
external/libelf/src/nextscn.c vendored Normal file
View File

@ -0,0 +1,54 @@
/*
nextscn.c - implementation of the elf_nextscn(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: nextscn.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
Elf_Scn*
elf_nextscn(Elf *elf, Elf_Scn *scn) {
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (scn) {
elf_assert(scn->s_magic == SCN_MAGIC);
if (scn->s_elf == elf) {
return scn->s_link;
}
seterr(ERROR_ELFSCNMISMATCH);
}
else if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_ehdr || _elf_cook(elf)) {
elf_assert(elf->e_ehdr);
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(scn->s_elf == elf);
if (scn->s_index == 1) {
return scn;
}
}
seterr(ERROR_NOSUCHSCN);
}
return NULL;
}

253
external/libelf/src/nlist.c vendored Normal file
View File

@ -0,0 +1,253 @@
/*
* nlist.c - implementation of the nlist(3) function.
* Copyright (C) 1995 - 2004 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <nlist.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: nlist.c,v 1.15 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
#if !defined(_WIN32)
#if HAVE_FCNTL_H
#include <fcntl.h>
#else
extern int open();
#endif /* HAVE_FCNTL_H */
#endif /* defined(_WIN32) */
#ifndef O_RDONLY
#define O_RDONLY 0
#endif /* O_RDONLY */
#ifndef O_BINARY
#define O_BINARY 0
#endif /* O_BINARY */
#define FILE_OPEN_MODE (O_RDONLY | O_BINARY)
#define PRIME 217
struct hash {
const char* name;
unsigned long hash;
unsigned next;
};
static const char*
symbol_name(Elf *elf, const void *syms, const char *names, size_t nlimit, size_t index) {
size_t off;
if (elf->e_class == ELFCLASS32) {
off = ((Elf32_Sym*)syms)[index].st_name;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
off = ((Elf64_Sym*)syms)[index].st_name;
}
#endif /* __LIBELF64 */
else {
return NULL;
}
if (off >= 0 && off < nlimit) {
return &names[off];
}
return NULL;
}
static void
copy_symbol(Elf *elf, struct nlist *np, const void *syms, size_t index) {
if (elf->e_class == ELFCLASS32) {
np->n_value = ((Elf32_Sym*)syms)[index].st_value;
np->n_scnum = ((Elf32_Sym*)syms)[index].st_shndx;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
np->n_value = ((Elf64_Sym*)syms)[index].st_value;
np->n_scnum = ((Elf64_Sym*)syms)[index].st_shndx;
}
#endif /* __LIBELF64 */
/*
* this needs more work
*/
np->n_type = 0;
np->n_sclass = 0;
np->n_numaux = 0;
}
static int
_elf_nlist(Elf *elf, struct nlist *nl) {
unsigned first[PRIME];
Elf_Scn *symtab = NULL;
Elf_Scn *strtab = NULL;
Elf_Data *symdata;
Elf_Data *strdata;
size_t symsize;
size_t nsymbols;
const char *name;
struct hash *table;
unsigned long hash;
unsigned i;
struct nlist *np;
/*
* Get and translate ELF header, section table and so on.
* Must be class independent, so don't use elf32_get*().
*/
if (elf->e_kind != ELF_K_ELF) {
return -1;
}
if (!elf->e_ehdr && !_elf_cook(elf)) {
return -1;
}
/*
* Find symbol table. If there is none, try dynamic symbols.
*/
for (symtab = elf->e_scn_1; symtab; symtab = symtab->s_link) {
if (symtab->s_type == SHT_SYMTAB) {
break;
}
if (symtab->s_type == SHT_DYNSYM) {
strtab = symtab;
}
}
if (!symtab && !(symtab = strtab)) {
return -1;
}
/*
* Get associated string table.
*/
i = 0;
if (elf->e_class == ELFCLASS32) {
i = symtab->s_shdr32.sh_link;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
i = symtab->s_shdr64.sh_link;
}
#endif /* __LIBELF64 */
if (i == 0) {
return -1;
}
for (strtab = elf->e_scn_1; strtab; strtab = strtab->s_link) {
if (strtab->s_index == i) {
break;
}
}
if (!strtab || strtab->s_type != SHT_STRTAB) {
return -1;
}
/*
* Get and translate section data.
*/
symdata = elf_getdata(symtab, NULL);
strdata = elf_getdata(strtab, NULL);
if (!symdata || !strdata) {
return -1;
}
symsize = _msize(elf->e_class, _elf_version, ELF_T_SYM);
elf_assert(symsize);
nsymbols = symdata->d_size / symsize;
if (!symdata->d_buf || !strdata->d_buf || !nsymbols || !strdata->d_size) {
return -1;
}
/*
* Build a simple hash table.
*/
if (!(table = (struct hash*)malloc(nsymbols * sizeof(*table)))) {
return -1;
}
for (i = 0; i < PRIME; i++) {
first[i] = 0;
}
for (i = 0; i < nsymbols; i++) {
table[i].name = NULL;
table[i].hash = 0;
table[i].next = 0;
}
for (i = 1; i < nsymbols; i++) {
name = symbol_name(elf, symdata->d_buf, strdata->d_buf,
strdata->d_size, i);
if (name == NULL) {
free(table);
return -1;
}
if (*name != '\0') {
table[i].name = name;
table[i].hash = elf_hash((unsigned char*)name);
hash = table[i].hash % PRIME;
table[i].next = first[hash];
first[hash] = i;
}
}
/*
* Lookup symbols, one by one.
*/
for (np = nl; (name = np->n_name) && *name; np++) {
hash = elf_hash((unsigned char*)name);
for (i = first[hash % PRIME]; i; i = table[i].next) {
if (table[i].hash == hash && !strcmp(table[i].name, name)) {
break;
}
}
if (i) {
copy_symbol(elf, np, symdata->d_buf, i);
}
else {
np->n_value = 0;
np->n_scnum = 0;
np->n_type = 0;
np->n_sclass = 0;
np->n_numaux = 0;
}
}
free(table);
return 0;
}
int
nlist(const char *filename, struct nlist *nl) {
int result = -1;
unsigned oldver;
Elf *elf;
int fd;
if ((oldver = elf_version(EV_CURRENT)) != EV_NONE) {
if ((fd = open(filename, FILE_OPEN_MODE)) != -1) {
if ((elf = elf_begin(fd, ELF_C_READ, NULL))) {
result = _elf_nlist(elf, nl);
elf_end(elf);
}
close(fd);
}
elf_version(oldver);
}
if (result) {
while (nl->n_name && *nl->n_name) {
nl->n_value = 0;
nl++;
}
}
return result;
}

48
external/libelf/src/nlist.h vendored Normal file
View File

@ -0,0 +1,48 @@
/*
* nlist.h - public header file for nlist(3).
* Copyright (C) 1995 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/* @(#) $Id: nlist.h,v 1.10 2008/05/23 08:15:35 michael Exp $ */
#ifndef _NLIST_H
#define _NLIST_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
struct nlist {
char* n_name;
long n_value;
short n_scnum;
unsigned short n_type;
char n_sclass;
char n_numaux;
};
#if (__STDC__ + 0) || defined(__cplusplus) || defined(_WIN32)
extern int nlist(const char *__filename, struct nlist *__nl);
#else /* __STDC__ || defined(__cplusplus) */
extern int nlist();
#endif /* __STDC__ || defined(__cplusplus) */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _NLIST_H */

205
external/libelf/src/opt.delscn.c vendored Normal file
View File

@ -0,0 +1,205 @@
/*
opt.delscn.c - implementation of the elf_delscn(3) function.
Copyright (C) 1995 - 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: opt.delscn.c,v 1.12 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
static size_t
_newindex(size_t old, size_t index) {
return old == index ? SHN_UNDEF : (old > index ? old - 1 : old);
}
static void
_elf32_update_shdr(Elf *elf, size_t index) {
Elf32_Shdr *shdr;
Elf_Scn *scn;
((Elf32_Ehdr*)elf->e_ehdr)->e_shnum = elf->e_scn_n->s_index + 1;
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
shdr = &scn->s_shdr32;
switch (shdr->sh_type) {
case SHT_REL:
case SHT_RELA:
shdr->sh_info = _newindex(shdr->sh_info, index);
/* fall through */
case SHT_DYNSYM:
case SHT_DYNAMIC:
case SHT_HASH:
case SHT_SYMTAB:
#if __LIBELF_SYMBOL_VERSIONS
#if __LIBELF_SUN_SYMBOL_VERSIONS
case SHT_SUNW_verdef:
case SHT_SUNW_verneed:
case SHT_SUNW_versym:
#else /* __LIBELF_SUN_SYMBOL_VERSIONS */
case SHT_GNU_verdef:
case SHT_GNU_verneed:
case SHT_GNU_versym:
#endif /* __LIBELF_SUN_SYMBOL_VERSIONS */
#endif /* __LIBELF_SYMBOL_VERSIONS */
shdr->sh_link = _newindex(shdr->sh_link, index);
/* fall through */
default:
break;
}
}
}
#if __LIBELF64
static void
_elf64_update_shdr(Elf *elf, size_t index) {
Elf64_Shdr *shdr;
Elf_Scn *scn;
((Elf64_Ehdr*)elf->e_ehdr)->e_shnum = elf->e_scn_n->s_index + 1;
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
shdr = &scn->s_shdr64;
switch (shdr->sh_type) {
case SHT_REL:
case SHT_RELA:
shdr->sh_info = _newindex(shdr->sh_info, index);
/* fall through */
case SHT_DYNSYM:
case SHT_DYNAMIC:
case SHT_HASH:
case SHT_SYMTAB:
#if __LIBELF_SYMBOL_VERSIONS
#if __LIBELF_SUN_SYMBOL_VERSIONS
case SHT_SUNW_verdef:
case SHT_SUNW_verneed:
case SHT_SUNW_versym:
#else /* __LIBELF_SUN_SYMBOL_VERSIONS */
case SHT_GNU_verdef:
case SHT_GNU_verneed:
case SHT_GNU_versym:
#endif /* __LIBELF_SUN_SYMBOL_VERSIONS */
#endif /* __LIBELF_SYMBOL_VERSIONS */
shdr->sh_link = _newindex(shdr->sh_link, index);
/* fall through */
default:
break;
}
}
}
#endif /* __LIBELF64 */
size_t
elf_delscn(Elf *elf, Elf_Scn *scn) {
Elf_Scn *pscn;
Scn_Data *sd;
Scn_Data *tmp;
size_t index;
if (!elf || !scn) {
return SHN_UNDEF;
}
elf_assert(elf->e_magic == ELF_MAGIC);
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(elf->e_ehdr);
if (scn->s_elf != elf) {
seterr(ERROR_ELFSCNMISMATCH);
return SHN_UNDEF;
}
elf_assert(elf->e_scn_1);
if (scn == elf->e_scn_1) {
seterr(ERROR_NULLSCN);
return SHN_UNDEF;
}
/*
* Find previous section.
*/
for (pscn = elf->e_scn_1; pscn->s_link; pscn = pscn->s_link) {
if (pscn->s_link == scn) {
break;
}
}
if (pscn->s_link != scn) {
seterr(ERROR_ELFSCNMISMATCH);
return SHN_UNDEF;
}
/*
* Unlink section.
*/
if (elf->e_scn_n == scn) {
elf->e_scn_n = pscn;
}
pscn->s_link = scn->s_link;
index = scn->s_index;
/*
* Free section descriptor and data.
*/
for (sd = scn->s_data_1; sd; sd = tmp) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
tmp = sd->sd_link;
if (sd->sd_free_data && sd->sd_memdata) {
free(sd->sd_memdata);
}
if (sd->sd_freeme) {
free(sd);
}
}
if ((sd = scn->s_rawdata)) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
if (sd->sd_free_data && sd->sd_memdata) {
free(sd->sd_memdata);
}
if (sd->sd_freeme) {
free(sd);
}
}
if (scn->s_freeme) {
elf_assert(scn->s_index > 0);
free(scn);
}
/*
* Adjust section indices.
*/
for (scn = pscn->s_link; scn; scn = scn->s_link) {
elf_assert(scn->s_index > index);
scn->s_index--;
}
/*
* Adjust ELF header and well-known section headers.
*/
if (elf->e_class == ELFCLASS32) {
_elf32_update_shdr(elf, index);
return index;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
_elf64_update_shdr(elf, index);
return index;
}
#endif /* __LIBELF64 */
else if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return SHN_UNDEF;
}

446
external/libelf/src/private.h vendored Normal file
View File

@ -0,0 +1,446 @@
/*
* private.h - private definitions for libelf.
* Copyright (C) 1995 - 2007 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/* @(#) $Id: private.h,v 1.40 2009/11/01 13:04:19 michael Exp $ */
#ifndef _PRIVATE_H
#define _PRIVATE_H
#define __LIBELF_INTERNAL__ 1
#if HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
/*
* Workaround for GLIBC bug:
* include <stdint.h> before <sys/types.h>
*/
#if HAVE_STDINT_H
#include <stdint.h>
#endif
#include <sys/types.h>
#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else /* STDC_HEADERS */
extern void *malloc(), *realloc();
extern void free(), bcopy(), abort();
extern int strcmp(), strncmp(), memcmp();
extern void *memcpy(), *memmove(), *memset();
#endif /* STDC_HEADERS */
#if defined(_WIN32)
#include <io.h>
#else
#if HAVE_UNISTD_H
# include <unistd.h>
#else /* HAVE_UNISTD_H */
extern int read(), write(), close();
extern off_t lseek();
#if HAVE_FTRUNCATE
extern int ftruncate();
#endif /* HAVE_FTRUNCATE */
#endif /* HAVE_UNISTD_H */
#endif /* defined(_WIN32) */
#ifndef SEEK_SET
#define SEEK_SET 0
#endif /* SEEK_SET */
#ifndef SEEK_CUR
#define SEEK_CUR 1
#endif /* SEEK_CUR */
#ifndef SEEK_END
#define SEEK_END 2
#endif /* SEEK_END */
#if !HAVE_MEMCMP
# define memcmp strncmp
#endif /* !HAVE_MEMCMP */
#if !HAVE_MEMCPY
# define memcpy(d,s,n) bcopy(s,d,n)
#endif /* !HAVE_MEMCPY */
#if !HAVE_MEMMOVE
# define memmove(d,s,n) bcopy(s,d,n)
#endif /* !HAVE_MEMMOVE */
#if !HAVE_MEMSET
# define memset _elf_memset
extern void *_elf_memset();
#endif /* !HAVE_MEMSET */
#if HAVE_STRUCT_NLIST_DECLARATION
# define nlist __override_nlist_declaration
#endif /* HAVE_STRUCT_NLIST_DECLARATION */
#if __LIBELF_NEED_LINK_H
# include <link.h>
#elif __LIBELF_NEED_SYS_LINK_H
# include <sys/link.h>
#endif /* __LIBELF_NEED_LINK_H */
#if HAVE_AR_H
#include <ar.h>
#else /* HAVE_AR_H */
#define ARMAG "!<arch>\n"
#define SARMAG 8
struct ar_hdr {
char ar_name[16];
char ar_date[12];
char ar_uid[6];
char ar_gid[6];
char ar_mode[8];
char ar_size[10];
char ar_fmag[2];
};
#define ARFMAG "`\n"
#endif /* HAVE_AR_H */
#include <libelf.h>
#if HAVE_STRUCT_NLIST_DECLARATION
# undef nlist
#endif /* HAVE_STRUCT_NLIST_DECLARATION */
#if __LIBELF64
#include <gelf.h>
#endif /* __LIBELF64 */
typedef struct Scn_Data Scn_Data;
/*
* ELF descriptor
*/
struct Elf {
/* common */
size_t e_size; /* file/member size */
size_t e_dsize; /* size of memory image */
Elf_Kind e_kind; /* kind of file */
char* e_data; /* file/member data */
char* e_rawdata; /* file/member raw data */
size_t e_idlen; /* identifier size */
int e_fd; /* file descriptor */
unsigned e_count; /* activation count */
/* archive members (still common) */
Elf* e_parent; /* NULL if not an archive member */
size_t e_next; /* 0 if not an archive member */
size_t e_base; /* 0 if not an archive member */
Elf* e_link; /* next archive member or NULL */
Elf_Arhdr* e_arhdr; /* archive member header or NULL */
/* archives */
size_t e_off; /* current member offset (for elf_begin) */
Elf* e_members; /* linked list of active archive members */
char* e_symtab; /* archive symbol table */
size_t e_symlen; /* length of archive symbol table */
char* e_strtab; /* archive string table */
size_t e_strlen; /* length of archive string table */
/* ELF files */
unsigned e_class; /* ELF class */
unsigned e_encoding; /* ELF data encoding */
unsigned e_version; /* ELF version */
char* e_ehdr; /* ELF header */
char* e_phdr; /* ELF program header table */
size_t e_phnum; /* size of program header table */
Elf_Scn* e_scn_1; /* first section */
Elf_Scn* e_scn_n; /* last section */
unsigned e_elf_flags; /* elf flags (ELF_F_*) */
unsigned e_ehdr_flags; /* ehdr flags (ELF_F_*) */
unsigned e_phdr_flags; /* phdr flags (ELF_F_*) */
/* misc flags */
unsigned e_readable : 1; /* file is readable */
unsigned e_writable : 1; /* file is writable */
unsigned e_disabled : 1; /* e_fd has been disabled */
unsigned e_cooked : 1; /* e_data was modified */
unsigned e_free_syms : 1; /* e_symtab is malloc'ed */
unsigned e_unmap_data : 1; /* e_data is mmap'ed */
unsigned e_memory : 1; /* created by elf_memory() */
/* magic number for debugging */
long e_magic;
};
#define ELF_MAGIC 0x012b649e
#define INIT_ELF {\
/* e_size */ 0,\
/* e_dsize */ 0,\
/* e_kind */ ELF_K_NONE,\
/* e_data */ NULL,\
/* e_rawdata */ NULL,\
/* e_idlen */ 0,\
/* e_fd */ -1,\
/* e_count */ 1,\
/* e_parent */ NULL,\
/* e_next */ 0,\
/* e_base */ 0,\
/* e_link */ NULL,\
/* e_arhdr */ NULL,\
/* e_off */ 0,\
/* e_members */ NULL,\
/* e_symtab */ NULL,\
/* e_symlen */ 0,\
/* e_strtab */ NULL,\
/* e_strlen */ 0,\
/* e_class */ ELFCLASSNONE,\
/* e_encoding */ ELFDATANONE,\
/* e_version */ EV_NONE,\
/* e_ehdr */ NULL,\
/* e_phdr */ NULL,\
/* e_phnum */ 0,\
/* e_scn_1 */ NULL,\
/* e_scn_n */ NULL,\
/* e_elf_flags */ 0,\
/* e_ehdr_flags */ 0,\
/* e_phdr_flags */ 0,\
/* e_readable */ 0,\
/* e_writable */ 0,\
/* e_disabled */ 0,\
/* e_cooked */ 0,\
/* e_free_syms */ 0,\
/* e_unmap_data */ 0,\
/* e_memory */ 0,\
/* e_magic */ ELF_MAGIC\
}
/*
* Section descriptor
*/
struct Elf_Scn {
Elf_Scn* s_link; /* pointer to next Elf_Scn */
Elf* s_elf; /* pointer to elf descriptor */
size_t s_index; /* number of this section */
unsigned s_scn_flags; /* section flags (ELF_F_*) */
unsigned s_shdr_flags; /* shdr flags (ELF_F_*) */
Scn_Data* s_data_1; /* first data buffer */
Scn_Data* s_data_n; /* last data buffer */
Scn_Data* s_rawdata; /* raw data buffer */
/* data copied from shdr */
unsigned s_type; /* section type */
size_t s_offset; /* section offset */
size_t s_size; /* section size */
/* misc flags */
unsigned s_freeme : 1; /* this Elf_Scn was malloc'ed */
/* section header */
union {
#if __LIBELF64
Elf64_Shdr u_shdr64;
#endif /* __LIBELF64 */
Elf32_Shdr u_shdr32;
} s_uhdr;
/* magic number for debugging */
long s_magic;
};
#define s_shdr32 s_uhdr.u_shdr32
#define s_shdr64 s_uhdr.u_shdr64
#define SCN_MAGIC 0x012c747d
#define INIT_SCN {\
/* s_link */ NULL,\
/* s_elf */ NULL,\
/* s_index */ 0,\
/* s_scn_flags */ 0,\
/* s_shdr_flags */ 0,\
/* s_data_1 */ NULL,\
/* s_data_n */ NULL,\
/* s_rawdata */ NULL,\
/* s_type */ SHT_NULL,\
/* s_offset */ 0,\
/* s_size */ 0,\
/* s_freeme */ 0,\
/* s_uhdr */ {{0,}},\
/* s_magic */ SCN_MAGIC\
}
/*
* Data descriptor
*/
struct Scn_Data {
Elf_Data sd_data; /* must be first! */
Scn_Data* sd_link; /* pointer to next Scn_Data */
Elf_Scn* sd_scn; /* pointer to section */
char* sd_memdata; /* memory image of section */
unsigned sd_data_flags; /* data flags (ELF_F_*) */
/* misc flags */
unsigned sd_freeme : 1; /* this Scn_Data was malloc'ed */
unsigned sd_free_data : 1; /* sd_memdata is malloc'ed */
/* magic number for debugging */
long sd_magic;
};
#define DATA_MAGIC 0x01072639
#define INIT_DATA {\
{\
/* d_buf */ NULL,\
/* d_type */ ELF_T_BYTE,\
/* d_size */ 0,\
/* d_off */ 0,\
/* d_align */ 0,\
/* d_version */ EV_NONE\
},\
/* sd_link */ NULL,\
/* sd_scn */ NULL,\
/* sd_memdata */ NULL,\
/* sd_data_flags */ 0,\
/* sd_freeme */ 0,\
/* sd_free_data */ 0,\
/* sd_magic */ DATA_MAGIC\
}
/*
* Private status variables
*/
extern unsigned _elf_version;
extern int _elf_errno;
extern int _elf_fill;
extern int _elf_sanity_checks;
#define SANITY_CHECK_STRPTR (1u << 0)
/*
* Private functions
*/
extern void *_elf_read __P((Elf*, void*, size_t, size_t));
extern void *_elf_mmap __P((Elf*));
extern int _elf_cook __P((Elf*));
extern char *_elf_getehdr __P((Elf*, unsigned));
extern char *_elf_getphdr __P((Elf*, unsigned));
extern Elf_Data *_elf_xlatetom __P((const Elf*, Elf_Data*, const Elf_Data*));
extern Elf_Type _elf_scn_type __P((unsigned));
extern size_t _elf32_xltsize __P((const Elf_Data *__src, unsigned __dv, unsigned __encode, int __tof));
extern size_t _elf64_xltsize __P((const Elf_Data *__src, unsigned __dv, unsigned __encode, int __tof));
extern int _elf_update_shnum(Elf *__elf, size_t __shnum);
extern Elf_Scn *_elf_first_scn(Elf *__elf);
/*
* Special translators
*/
extern size_t _elf_verdef_32L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verdef_32L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verdef_32M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verdef_32M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verdef_64L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verdef_64L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verdef_64M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verdef_64M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verneed_32L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verneed_32L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verneed_32M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verneed_32M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verneed_64L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verneed_64L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verneed_64M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
extern size_t _elf_verneed_64M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
/*
* Private data
*/
extern const Elf_Scn _elf_scn_init;
extern const Scn_Data _elf_data_init;
extern const size_t _elf_fmsize[2][EV_CURRENT - EV_NONE][ELF_T_NUM][2];
/*
* Access macros for _elf_fmsize[]
*/
#define _fmsize(c,v,t,w) \
(_elf_fmsize[(c)-ELFCLASS32][(v)-EV_NONE-1][(t)-ELF_T_BYTE][(w)])
#define _fsize(c,v,t) _fmsize((c),(v),(t),1)
#define _msize(c,v,t) _fmsize((c),(v),(t),0)
/*
* Various checks
*/
#define valid_class(c) ((c) >= ELFCLASS32 && (c) <= ELFCLASS64)
#define valid_encoding(e) ((e) >= ELFDATA2LSB && (e) <= ELFDATA2MSB)
#define valid_version(v) ((v) > EV_NONE && (v) <= EV_CURRENT)
#define valid_type(t) ((unsigned)(t) < ELF_T_NUM)
/*
* Error codes
*/
enum {
#define __err__(a,b) a,
#include <errors.h> /* include constants from errors.h */
#undef __err__
ERROR_NUM
};
#define seterr(err) (_elf_errno = (err))
/*
* Sizes of data types (external representation)
* These definitions should be in <elf.h>, but...
*/
#ifndef ELF32_FSZ_ADDR
# define ELF32_FSZ_ADDR 4
# define ELF32_FSZ_HALF 2
# define ELF32_FSZ_OFF 4
# define ELF32_FSZ_SWORD 4
# define ELF32_FSZ_WORD 4
#endif /* ELF32_FSZ_ADDR */
#ifndef ELF64_FSZ_ADDR
# define ELF64_FSZ_ADDR 8
# define ELF64_FSZ_HALF 2
# define ELF64_FSZ_OFF 8
# define ELF64_FSZ_SWORD 4
# define ELF64_FSZ_SXWORD 8
# define ELF64_FSZ_WORD 4
# define ELF64_FSZ_XWORD 8
#endif /* ELF64_FSZ_ADDR */
/*
* More missing pieces, in no particular order
*/
#ifndef SHT_SYMTAB_SHNDX
#define SHT_SYMTAB_SHNDX 18
#endif /* SHT_SYMTAB_SHNDX */
#ifndef SHN_XINDEX
#define SHN_XINDEX 0xffff
#endif /* SHN_XINDEX */
#ifndef PN_XNUM
#define PN_XNUM 0xffff
#endif /* PN_XNUM */
/*
* Debugging
*/
#if ENABLE_DEBUG
extern void __elf_assert __P((const char*, unsigned, const char*));
# if (__STDC__ + 0)
# define elf_assert(x) do{if(!(x))__elf_assert(__FILE__,__LINE__,#x);}while(0)
# else /* __STDC__ */
# define elf_assert(x) do{if(!(x))__elf_assert(__FILE__,__LINE__,"x");}while(0)
# endif /* __STDC__ */
#else /* ENABLE_DEBUG */
# define elf_assert(x) do{}while(0)
#endif /* ENABLE_DEBUG */
/*
* Return values for certain functions
*/
#define LIBELF_SUCCESS 1
#define LIBELF_FAILURE 0
#endif /* _PRIVATE_H */

43
external/libelf/src/rand.c vendored Normal file
View File

@ -0,0 +1,43 @@
/*
rand.c - implementation of the elf_rand(3) function.
Copyright (C) 1995 - 1998 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: rand.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
size_t
elf_rand(Elf *elf, size_t offset) {
if (!elf) {
return 0;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_AR) {
seterr(ERROR_NOTARCHIVE);
}
else if (offset <= 0 || offset > elf->e_size) {
seterr(ERROR_BADOFF);
}
else {
elf->e_off = offset;
return offset;
}
return 0;
}

89
external/libelf/src/rawdata.c vendored Normal file
View File

@ -0,0 +1,89 @@
/*
rawdata.c - implementation of the elf_rawdata(3) function.
Copyright (C) 1995 - 2000 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: rawdata.c,v 1.10 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
Elf_Data*
elf_rawdata(Elf_Scn *scn, Elf_Data *data) {
Scn_Data *sd;
Elf *elf;
if (!scn) {
return NULL;
}
elf_assert(scn->s_magic == SCN_MAGIC);
elf = scn->s_elf;
elf_assert(elf);
elf_assert(elf->e_magic == ELF_MAGIC);
if (!elf->e_readable) {
return NULL;
}
else if (scn->s_index == SHN_UNDEF || scn->s_type == SHT_NULL) {
seterr(ERROR_NULLSCN);
}
else if (data) {
return NULL;
}
else if ((sd = scn->s_rawdata)) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
return &sd->sd_data;
}
else if (scn->s_offset < 0 || scn->s_offset > elf->e_size) {
seterr(ERROR_OUTSIDE);
}
else if (scn->s_type != SHT_NOBITS
&& scn->s_offset + scn->s_size > elf->e_size) {
seterr(ERROR_TRUNC_SCN);
}
else if (!(sd = (Scn_Data*)malloc(sizeof(*sd)))) {
seterr(ERROR_MEM_SCNDATA);
}
else {
*sd = _elf_data_init;
sd->sd_scn = scn;
sd->sd_freeme = 1;
sd->sd_data.d_size = scn->s_size;
sd->sd_data.d_version = _elf_version;
if (scn->s_type != SHT_NOBITS && scn->s_size) {
if (!(sd->sd_memdata = (char*)malloc(scn->s_size))) {
seterr(ERROR_IO_2BIG);
free(sd);
return NULL;
}
else if (elf->e_rawdata) {
memcpy(sd->sd_memdata, elf->e_rawdata + scn->s_offset, scn->s_size);
}
else if (!_elf_read(elf, sd->sd_memdata, scn->s_offset, scn->s_size)) {
free(sd->sd_memdata);
free(sd);
return NULL;
}
sd->sd_data.d_buf = sd->sd_memdata;
sd->sd_free_data = 1;
}
scn->s_rawdata = sd;
return &sd->sd_data;
}
return NULL;
}

54
external/libelf/src/rawfile.c vendored Normal file
View File

@ -0,0 +1,54 @@
/*
* rawfile.c - implementation of the elf_rawfile(3) function.
* Copyright (C) 1995 - 2009 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: rawfile.c,v 1.8 2009/05/22 17:07:46 michael Exp $";
#endif /* lint */
char*
elf_rawfile(Elf *elf, size_t *ptr) {
size_t tmp;
if (!ptr) {
ptr = &tmp;
}
*ptr = 0;
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (!elf->e_readable) {
return NULL;
}
else if (elf->e_size) {
if (!elf->e_rawdata) {
elf_assert(elf->e_data);
if (!elf->e_cooked) {
elf->e_rawdata = elf->e_data;
}
else if (!(elf->e_rawdata = _elf_read(elf, NULL, 0, elf->e_size))) {
return NULL;
}
}
*ptr = elf->e_size;
}
return elf->e_rawdata;
}

150
external/libelf/src/strptr.c vendored Normal file
View File

@ -0,0 +1,150 @@
/*
* strptr.c - implementation of the elf_strptr(3) function.
* Copyright (C) 1995 - 2007 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: strptr.c,v 1.12 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
char*
elf_strptr(Elf *elf, size_t section, size_t offset) {
Elf_Data *data;
Elf_Scn *scn;
size_t n;
char *s;
if (!elf) {
return NULL;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (!(scn = elf_getscn(elf, section))) {
return NULL;
}
if (scn->s_index == SHN_UNDEF) {
seterr(ERROR_NOSTRTAB);
return NULL;
}
/*
* checking the section header is more appropriate
*/
if (elf->e_class == ELFCLASS32) {
if (scn->s_shdr32.sh_type != SHT_STRTAB) {
seterr(ERROR_NOSTRTAB);
return NULL;
}
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
if (scn->s_shdr64.sh_type != SHT_STRTAB) {
seterr(ERROR_NOSTRTAB);
return NULL;
}
}
#endif /* __LIBELF64 */
else if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
}
else {
seterr(ERROR_UNKNOWN_CLASS);
return NULL;
}
/*
* Find matching buffer
*/
n = 0;
data = NULL;
if (elf->e_elf_flags & ELF_F_LAYOUT) {
/*
* Programmer is responsible for d_off
* Note: buffers may be in any order!
*/
while ((data = elf_getdata(scn, data))) {
n = data->d_off;
if (offset >= n && offset - n < data->d_size) {
/*
* Found it
*/
break;
}
}
}
else {
/*
* Calculate offsets myself
*/
while ((data = elf_getdata(scn, data))) {
if (data->d_align > 1) {
n += data->d_align - 1;
n -= n % data->d_align;
}
if (offset < n) {
/*
* Invalid offset: points into a hole
*/
seterr(ERROR_BADSTROFF);
return NULL;
}
if (offset - n < data->d_size) {
/*
* Found it
*/
break;
}
n += data->d_size;
}
}
if (data == NULL) {
/*
* Not found
*/
seterr(ERROR_BADSTROFF);
return NULL;
}
if (data->d_buf == NULL) {
/*
* Buffer is NULL (usually the programmers' fault)
*/
seterr(ERROR_NULLBUF);
return NULL;
}
offset -= n;
s = (char*)data->d_buf;
if (!(_elf_sanity_checks & SANITY_CHECK_STRPTR)) {
return s + offset;
}
/*
* Perform extra sanity check
*/
for (n = offset; n < data->d_size; n++) {
if (s[n] == '\0') {
/*
* Return properly NUL terminated string
*/
return s + offset;
}
}
/*
* String is not NUL terminated
* Return error to avoid SEGV in application
*/
seterr(ERROR_UNTERM);
return NULL;
}

81
external/libelf/src/swap64.c vendored Normal file
View File

@ -0,0 +1,81 @@
/*
swap64.c - 64-bit byte swapping functions.
Copyright (C) 1995 - 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <byteswap.h>
#if __LIBELF64
#ifndef lint
static const char rcsid[] = "@(#) $Id: swap64.c,v 1.6 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
__libelf_u64_t
_elf_load_u64L(const unsigned char *from) {
return ((__libelf_u64_t)__load_u32L(from + 4) << 32)
| (__libelf_u64_t)__load_u32L(from);
}
__libelf_u64_t
_elf_load_u64M(const unsigned char *from) {
return ((__libelf_u64_t)__load_u32M(from) << 32)
| (__libelf_u64_t)__load_u32M(from + 4);
}
__libelf_i64_t
_elf_load_i64L(const unsigned char *from) {
return ((__libelf_i64_t)__load_i32L(from + 4) << 32)
| (__libelf_u64_t)__load_u32L(from);
}
__libelf_i64_t
_elf_load_i64M(const unsigned char *from) {
return ((__libelf_i64_t)__load_i32M(from) << 32)
| (__libelf_u64_t)__load_u32M(from + 4);
}
void
_elf_store_u64L(unsigned char *to, __libelf_u64_t v) {
__store_u32L(to, (__libelf_u32_t)v);
v >>= 32;
__store_u32L(to + 4, (__libelf_u32_t)v);
}
void
_elf_store_u64M(unsigned char *to, __libelf_u64_t v) {
__store_u32M(to + 4, (__libelf_u32_t)v);
v >>= 32;
__store_u32M(to, (__libelf_u32_t)v);
}
void
_elf_store_i64L(unsigned char *to, __libelf_u64_t v) {
__store_u32L(to, (__libelf_u32_t)v);
v >>= 32;
__store_i32L(to + 4, (__libelf_u32_t)v);
}
void
_elf_store_i64M(unsigned char *to, __libelf_u64_t v) {
__store_u32M(to + 4, (__libelf_u32_t)v);
v >>= 32;
__store_i32M(to, (__libelf_u32_t)v);
}
#endif /* __LIBELF64 */

1021
external/libelf/src/update.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

241
external/libelf/src/verdef.h vendored Normal file
View File

@ -0,0 +1,241 @@
/*
* verdef.h - copy versioning information.
* Copyright (C) 2001 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef lint
static const char verdef_h_rcsid[] = "@(#) $Id: verdef.h,v 1.13 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
#if VER_DEF_CURRENT != 1
#error libelf currently does not support VER_DEF_CURRENT != 1
#endif /* VER_DEF_CURRENT != 1 */
#if TOFILE
static void
__store_verdaux(verdaux_ftype *dst, const verdaux_mtype *src, unsigned enc) {
if (enc == ELFDATA2LSB) {
__store_u32L(dst->vda_name, src->vda_name);
__store_u32L(dst->vda_next, src->vda_next);
}
else {
__store_u32M(dst->vda_name, src->vda_name);
__store_u32M(dst->vda_next, src->vda_next);
}
}
static void
__store_verdef(verdef_ftype *dst, const verdef_mtype *src, unsigned enc) {
if (enc == ELFDATA2LSB) {
__store_u16L(dst->vd_version, src->vd_version);
__store_u16L(dst->vd_flags, src->vd_flags);
__store_u16L(dst->vd_ndx, src->vd_ndx);
__store_u16L(dst->vd_cnt, src->vd_cnt);
__store_u32L(dst->vd_hash, src->vd_hash);
__store_u32L(dst->vd_aux, src->vd_aux);
__store_u32L(dst->vd_next, src->vd_next);
}
else {
__store_u16M(dst->vd_version, src->vd_version);
__store_u16M(dst->vd_flags, src->vd_flags);
__store_u16M(dst->vd_ndx, src->vd_ndx);
__store_u16M(dst->vd_cnt, src->vd_cnt);
__store_u32M(dst->vd_hash, src->vd_hash);
__store_u32M(dst->vd_aux, src->vd_aux);
__store_u32M(dst->vd_next, src->vd_next);
}
}
typedef verdaux_mtype verdaux_stype;
typedef verdaux_ftype verdaux_dtype;
typedef verdef_mtype verdef_stype;
typedef verdef_ftype verdef_dtype;
typedef align_mtype verdef_atype;
#define copy_verdaux_srctotmp(d, s, e) (*(d) = *(s))
#define copy_verdaux_tmptodst(d, s, e) __store_verdaux((d), (s), (e))
#define copy_verdef_srctotmp(d, s, e) (*(d) = *(s))
#define copy_verdef_tmptodst(d, s, e) __store_verdef((d), (s), (e))
#define translator_suffix _tof
#else /* TOFILE */
static void
__load_verdaux(verdaux_mtype *dst, const verdaux_ftype *src, unsigned enc) {
if (enc == ELFDATA2LSB) {
dst->vda_name = __load_u32L(src->vda_name);
dst->vda_next = __load_u32L(src->vda_next);
}
else {
dst->vda_name = __load_u32M(src->vda_name);
dst->vda_next = __load_u32M(src->vda_next);
}
}
static void
__load_verdef(verdef_mtype *dst, const verdef_ftype *src, unsigned enc) {
if (enc == ELFDATA2LSB) {
dst->vd_version = __load_u16L(src->vd_version);
dst->vd_flags = __load_u16L(src->vd_flags);
dst->vd_ndx = __load_u16L(src->vd_ndx);
dst->vd_cnt = __load_u16L(src->vd_cnt);
dst->vd_hash = __load_u32L(src->vd_hash);
dst->vd_aux = __load_u32L(src->vd_aux);
dst->vd_next = __load_u32L(src->vd_next);
}
else {
dst->vd_version = __load_u16M(src->vd_version);
dst->vd_flags = __load_u16M(src->vd_flags);
dst->vd_ndx = __load_u16M(src->vd_ndx);
dst->vd_cnt = __load_u16M(src->vd_cnt);
dst->vd_hash = __load_u32M(src->vd_hash);
dst->vd_aux = __load_u32M(src->vd_aux);
dst->vd_next = __load_u32M(src->vd_next);
}
}
typedef verdaux_ftype verdaux_stype;
typedef verdaux_mtype verdaux_dtype;
typedef verdef_ftype verdef_stype;
typedef verdef_mtype verdef_dtype;
typedef align_ftype verdef_atype;
#define copy_verdaux_srctotmp(d, s, e) __load_verdaux((d), (s), (e))
#define copy_verdaux_tmptodst(d, s, e) (*(d) = *(s))
#define copy_verdef_srctotmp(d, s, e) __load_verdef((d), (s), (e))
#define copy_verdef_tmptodst(d, s, e) (*(d) = *(s))
#define translator_suffix _tom
#endif /* TOFILE */
#define cat3(a,b,c) a##b##c
#define xlt3(p,e,s) cat3(p,e,s)
#define xltprefix(x) xlt3(x,_,class_suffix)
#define translator(x,e) xlt3(xltprefix(_elf_##x),e,translator_suffix)
static size_t
xlt_verdef(unsigned char *dst, const unsigned char *src, size_t n, unsigned enc) {
size_t off;
if (sizeof(verdef_stype) != sizeof(verdef_dtype)
|| sizeof(verdaux_stype) != sizeof(verdaux_dtype)) {
/* never happens for ELF v1 and Verneed v1 */
seterr(ERROR_UNIMPLEMENTED);
return (size_t)-1;
}
/* size translation shortcut */
if (dst == NULL) {
return n;
}
if (src == NULL) {
seterr(ERROR_NULLBUF);
return (size_t)-1;
}
off = 0;
while (off + sizeof(verdef_stype) <= n) {
const verdef_stype *svd;
verdef_dtype *dvd;
verdef_mtype vd;
size_t acount;
size_t aoff;
/*
* check for proper alignment
*/
if (off % sizeof(verdef_atype)) {
seterr(ERROR_VERDEF_FORMAT);
return (size_t)-1;
}
/*
* copy and check src
*/
svd = (verdef_stype*)(src + off);
dvd = (verdef_dtype*)(dst + off);
copy_verdef_srctotmp(&vd, svd, enc);
if (vd.vd_version < 1
|| vd.vd_version > VER_DEF_CURRENT) {
seterr(ERROR_VERDEF_VERSION);
return (size_t)-1;
}
if (vd.vd_cnt < 1
|| vd.vd_aux == 0) {
seterr(ERROR_VERDEF_FORMAT);
return (size_t)-1;
}
copy_verdef_tmptodst(dvd, &vd, enc);
/*
* copy aux array
*/
aoff = off + vd.vd_aux;
for (acount = 0; acount < vd.vd_cnt; acount++) {
const verdaux_stype *svda;
verdaux_dtype *dvda;
verdaux_mtype vda;
/*
* are we still inside the buffer limits?
*/
if (aoff + sizeof(verdaux_stype) > n) {
break;
}
/*
* check for proper alignment
*/
if (aoff % sizeof(verdef_atype)) {
seterr(ERROR_VERDEF_FORMAT);
return (size_t)-1;
}
/*
* copy and check src
*/
svda = (verdaux_stype*)(src + aoff);
dvda = (verdaux_dtype*)(dst + aoff);
copy_verdaux_srctotmp(&vda, svda, enc);
copy_verdaux_tmptodst(dvda, &vda, enc);
/*
* advance to next verdaux
*/
if (vda.vda_next == 0) {
/* end of list */
break;
}
aoff += vda.vda_next;
}
/*
* advance to next verdef
*/
if (vd.vd_next == 0) {
/* end of list */
break;
}
off += vd.vd_next;
}
return n;
}
size_t
translator(verdef,L11)(unsigned char *dst, const unsigned char *src, size_t n) {
return xlt_verdef(dst, src, n, ELFDATA2LSB);
}
size_t
translator(verdef,M11)(unsigned char *dst, const unsigned char *src, size_t n) {
return xlt_verdef(dst, src, n, ELFDATA2MSB);
}

53
external/libelf/src/verdef_32_tof.c vendored Normal file
View File

@ -0,0 +1,53 @@
/*
verdef_32_tof.c - copy 32-bit versioning information.
Copyright (C) 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <ext_types.h>
#include <byteswap.h>
#if __LIBELF_SYMBOL_VERSIONS
#ifndef lint
static const char rcsid[] = "@(#) $Id: verdef_32_tof.c,v 1.5 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
typedef Elf32_Verdaux verdaux_mtype;
typedef Elf32_Verdef verdef_mtype;
typedef Elf32_Vernaux vernaux_mtype;
typedef Elf32_Verneed verneed_mtype;
typedef Elf32_Word align_mtype;
typedef __ext_Elf32_Verdaux verdaux_ftype;
typedef __ext_Elf32_Verdef verdef_ftype;
typedef __ext_Elf32_Vernaux vernaux_ftype;
typedef __ext_Elf32_Verneed verneed_ftype;
typedef __ext_Elf32_Word align_ftype;
#define class_suffix 32
#undef TOFILE
#define TOFILE 1
/*
* Include shared code
*/
#include "verdef.h"
#include "verneed.h"
#endif /* __LIBELF_SYMBOL_VERSIONS */

53
external/libelf/src/verdef_32_tom.c vendored Normal file
View File

@ -0,0 +1,53 @@
/*
verdef_32_tom.c - copy 32-bit versioning information.
Copyright (C) 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <ext_types.h>
#include <byteswap.h>
#if __LIBELF_SYMBOL_VERSIONS
#ifndef lint
static const char rcsid[] = "@(#) $Id: verdef_32_tom.c,v 1.5 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
typedef Elf32_Verdaux verdaux_mtype;
typedef Elf32_Verdef verdef_mtype;
typedef Elf32_Vernaux vernaux_mtype;
typedef Elf32_Verneed verneed_mtype;
typedef Elf32_Word align_mtype;
typedef __ext_Elf32_Verdaux verdaux_ftype;
typedef __ext_Elf32_Verdef verdef_ftype;
typedef __ext_Elf32_Vernaux vernaux_ftype;
typedef __ext_Elf32_Verneed verneed_ftype;
typedef __ext_Elf32_Word align_ftype;
#define class_suffix 32
#undef TOFILE
#define TOFILE 0
/*
* Include shared code
*/
#include "verdef.h"
#include "verneed.h"
#endif /* __LIBELF_SYMBOL_VERSIONS */

53
external/libelf/src/verdef_64_tof.c vendored Normal file
View File

@ -0,0 +1,53 @@
/*
verdef_64_tof.c - copy 64-bit versioning information.
Copyright (C) 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <ext_types.h>
#include <byteswap.h>
#if __LIBELF64 && __LIBELF_SYMBOL_VERSIONS
#ifndef lint
static const char rcsid[] = "@(#) $Id: verdef_64_tof.c,v 1.5 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
typedef Elf64_Verdaux verdaux_mtype;
typedef Elf64_Verdef verdef_mtype;
typedef Elf64_Vernaux vernaux_mtype;
typedef Elf64_Verneed verneed_mtype;
typedef Elf64_Word align_mtype;
typedef __ext_Elf64_Verdaux verdaux_ftype;
typedef __ext_Elf64_Verdef verdef_ftype;
typedef __ext_Elf64_Vernaux vernaux_ftype;
typedef __ext_Elf64_Verneed verneed_ftype;
typedef __ext_Elf64_Word align_ftype;
#define class_suffix 64
#undef TOFILE
#define TOFILE 1
/*
* Include shared code
*/
#include "verdef.h"
#include "verneed.h"
#endif /* __LIBELF64 && __LIBELF_SYMBOL_VERSIONS */

53
external/libelf/src/verdef_64_tom.c vendored Normal file
View File

@ -0,0 +1,53 @@
/*
verdef_64_tom.c - copy 64-bit versioning information.
Copyright (C) 2001 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#include <ext_types.h>
#include <byteswap.h>
#if __LIBELF64 && __LIBELF_SYMBOL_VERSIONS
#ifndef lint
static const char rcsid[] = "@(#) $Id: verdef_64_tom.c,v 1.5 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
typedef Elf64_Verdaux verdaux_mtype;
typedef Elf64_Verdef verdef_mtype;
typedef Elf64_Vernaux vernaux_mtype;
typedef Elf64_Verneed verneed_mtype;
typedef Elf64_Word align_mtype;
typedef __ext_Elf64_Verdaux verdaux_ftype;
typedef __ext_Elf64_Verdef verdef_ftype;
typedef __ext_Elf64_Vernaux vernaux_ftype;
typedef __ext_Elf64_Verneed verneed_ftype;
typedef __ext_Elf64_Word align_ftype;
#define class_suffix 64
#undef TOFILE
#define TOFILE 0
/*
* Include shared code
*/
#include "verdef.h"
#include "verneed.h"
#endif /* __LIBELF64 && __LIBELF_SYMBOL_VERSIONS */

245
external/libelf/src/verneed.h vendored Normal file
View File

@ -0,0 +1,245 @@
/*
* verneed.h - copy versioning information.
* Copyright (C) 2001 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef lint
static const char verneed_h_rcsid[] = "@(#) $Id: verneed.h,v 1.13 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
#if VER_NEED_CURRENT != 1
#error libelf currently does not support VER_NEED_CURRENT != 1
#endif /* VER_NEED_CURRENT != 1 */
#if TOFILE
static void
__store_vernaux(vernaux_ftype *dst, const vernaux_mtype *src, unsigned enc) {
if (enc == ELFDATA2LSB) {
__store_u32L(dst->vna_hash, src->vna_hash);
__store_u16L(dst->vna_flags, src->vna_flags);
__store_u16L(dst->vna_other, src->vna_other);
__store_u32L(dst->vna_name, src->vna_name);
__store_u32L(dst->vna_next, src->vna_next);
}
else {
__store_u32M(dst->vna_hash, src->vna_hash);
__store_u16M(dst->vna_flags, src->vna_flags);
__store_u16M(dst->vna_other, src->vna_other);
__store_u32M(dst->vna_name, src->vna_name);
__store_u32M(dst->vna_next, src->vna_next);
}
}
static void
__store_verneed(verneed_ftype *dst, const verneed_mtype *src, unsigned enc) {
if (enc == ELFDATA2LSB) {
__store_u16L(dst->vn_version, src->vn_version);
__store_u16L(dst->vn_cnt, src->vn_cnt);
__store_u32L(dst->vn_file, src->vn_file);
__store_u32L(dst->vn_aux, src->vn_aux);
__store_u32L(dst->vn_next, src->vn_next);
}
else {
__store_u16M(dst->vn_version, src->vn_version);
__store_u16M(dst->vn_cnt, src->vn_cnt);
__store_u32M(dst->vn_file, src->vn_file);
__store_u32M(dst->vn_aux, src->vn_aux);
__store_u32M(dst->vn_next, src->vn_next);
}
}
typedef vernaux_mtype vernaux_stype;
typedef vernaux_ftype vernaux_dtype;
typedef verneed_mtype verneed_stype;
typedef verneed_ftype verneed_dtype;
typedef align_mtype verneed_atype;
#define copy_vernaux_srctotmp(d, s, e) (*(d) = *(s))
#define copy_vernaux_tmptodst(d, s, e) __store_vernaux((d), (s), (e))
#define copy_verneed_srctotmp(d, s, e) (*(d) = *(s))
#define copy_verneed_tmptodst(d, s, e) __store_verneed((d), (s), (e))
#define translator_suffix _tof
#else /* TOFILE */
static void
__load_vernaux(vernaux_mtype *dst, const vernaux_ftype *src, unsigned enc) {
if (enc == ELFDATA2LSB) {
dst->vna_hash = __load_u32L(src->vna_hash);
dst->vna_flags = __load_u16L(src->vna_flags);
dst->vna_other = __load_u16L(src->vna_other);
dst->vna_name = __load_u32L(src->vna_name);
dst->vna_next = __load_u32L(src->vna_next);
}
else {
dst->vna_hash = __load_u32M(src->vna_hash);
dst->vna_flags = __load_u16M(src->vna_flags);
dst->vna_other = __load_u16M(src->vna_other);
dst->vna_name = __load_u32M(src->vna_name);
dst->vna_next = __load_u32M(src->vna_next);
}
}
static void
__load_verneed(verneed_mtype *dst, const verneed_ftype *src, unsigned enc) {
if (enc == ELFDATA2LSB) {
dst->vn_version = __load_u16L(src->vn_version);
dst->vn_cnt = __load_u16L(src->vn_cnt);
dst->vn_file = __load_u32L(src->vn_file);
dst->vn_aux = __load_u32L(src->vn_aux);
dst->vn_next = __load_u32L(src->vn_next);
}
else {
dst->vn_version = __load_u16M(src->vn_version);
dst->vn_cnt = __load_u16M(src->vn_cnt);
dst->vn_file = __load_u32M(src->vn_file);
dst->vn_aux = __load_u32M(src->vn_aux);
dst->vn_next = __load_u32M(src->vn_next);
}
}
typedef vernaux_ftype vernaux_stype;
typedef vernaux_mtype vernaux_dtype;
typedef verneed_ftype verneed_stype;
typedef verneed_mtype verneed_dtype;
typedef align_ftype verneed_atype;
#define copy_vernaux_srctotmp(d, s, e) __load_vernaux((d), (s), (e))
#define copy_vernaux_tmptodst(d, s, e) (*(d) = *(s))
#define copy_verneed_srctotmp(d, s, e) __load_verneed((d), (s), (e))
#define copy_verneed_tmptodst(d, s, e) (*(d) = *(s))
#define translator_suffix _tom
#endif /* TOFILE */
#define cat3(a,b,c) a##b##c
#define xlt3(p,e,s) cat3(p,e,s)
#define xltprefix(x) xlt3(x,_,class_suffix)
#define translator(x,e) xlt3(xltprefix(_elf_##x),e,translator_suffix)
static size_t
xlt_verneed(unsigned char *dst, const unsigned char *src, size_t n, unsigned enc) {
size_t off;
if (sizeof(verneed_stype) != sizeof(verneed_dtype)
|| sizeof(vernaux_stype) != sizeof(vernaux_dtype)) {
/* never happens for ELF v1 and Verneed v1 */
seterr(ERROR_UNIMPLEMENTED);
return (size_t)-1;
}
/* size translation shortcut */
if (dst == NULL) {
return n;
}
if (src == NULL) {
seterr(ERROR_NULLBUF);
return (size_t)-1;
}
off = 0;
while (off + sizeof(verneed_stype) <= n) {
const verneed_stype *svn;
verneed_dtype *dvn;
verneed_mtype vn;
size_t acount;
size_t aoff;
/*
* check for proper alignment
*/
if (off % sizeof(verneed_atype)) {
seterr(ERROR_VERNEED_FORMAT);
return (size_t)-1;
}
/*
* copy and check src
*/
svn = (verneed_stype*)(src + off);
dvn = (verneed_dtype*)(dst + off);
copy_verneed_srctotmp(&vn, svn, enc);
if (vn.vn_version < 1
|| vn.vn_version > VER_NEED_CURRENT) {
seterr(ERROR_VERNEED_VERSION);
return (size_t)-1;
}
if (vn.vn_cnt < 1
|| vn.vn_aux == 0) {
seterr(ERROR_VERNEED_FORMAT);
return (size_t)-1;
}
copy_verneed_tmptodst(dvn, &vn, enc);
/*
* copy aux array
*/
aoff = off + vn.vn_aux;
for (acount = 0; acount < vn.vn_cnt; acount++) {
const vernaux_stype *svna;
vernaux_dtype *dvna;
vernaux_mtype vna;
/*
* are we still inside the buffer limits?
*/
if (aoff + sizeof(vernaux_stype) > n) {
break;
}
/*
* check for proper alignment
*/
if (aoff % sizeof(verneed_atype)) {
seterr(ERROR_VERNEED_FORMAT);
return (size_t)-1;
}
/*
* copy and check src
*/
svna = (vernaux_stype*)(src + aoff);
dvna = (vernaux_dtype*)(dst + aoff);
copy_vernaux_srctotmp(&vna, svna, enc);
copy_vernaux_tmptodst(dvna, &vna, enc);
/*
* advance to next vernaux
*/
if (vna.vna_next == 0) {
/* end of list */
break;
}
aoff += vna.vna_next;
}
/*
* advance to next verneed
*/
if (vn.vn_next == 0) {
/* end of list */
break;
}
off += vn.vn_next;
}
return n;
}
size_t
translator(verneed,L11)(unsigned char *dst, const unsigned char *src, size_t n) {
return xlt_verneed(dst, src, n, ELFDATA2LSB);
}
size_t
translator(verneed,M11)(unsigned char *dst, const unsigned char *src, size_t n) {
return xlt_verneed(dst, src, n, ELFDATA2MSB);
}

44
external/libelf/src/version.c vendored Normal file
View File

@ -0,0 +1,44 @@
/*
* version.c - implementation of the elf_version(3) function.
* Copyright (C) 1995 - 1998, 2007 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: version.c,v 1.8 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
unsigned
elf_version(unsigned ver) {
const char *s;
unsigned tmp;
if ((s = getenv("LIBELF_SANITY_CHECKS"))) {
_elf_sanity_checks = (int)strtol(s, (char**)NULL, 0);
}
if (ver == EV_NONE) {
return EV_CURRENT;
}
if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
return EV_NONE;
}
tmp = _elf_version == EV_NONE ? EV_CURRENT : _elf_version;
_elf_version = ver;
return tmp;
}

190
external/libelf/src/x.elfext.c vendored Normal file
View File

@ -0,0 +1,190 @@
/*
* x.elfext.c -- handle ELF format extensions
* Copyright (C) 2002 - 2006 Michael Riepe
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: x.elfext.c,v 1.5 2009/07/07 17:57:43 michael Exp $";
#endif /* lint */
int
elf_getphdrnum(Elf *elf, size_t *resultp) {
if (!elf) {
return -1;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
return -1;
}
if (!elf->e_ehdr && !_elf_cook(elf)) {
return -1;
}
if (resultp) {
*resultp = elf->e_phnum;
}
return 0;
}
int
elf_getshdrnum(Elf *elf, size_t *resultp) {
size_t num = 0;
Elf_Scn *scn;
if (!elf) {
return -1;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
return -1;
}
if (!elf->e_ehdr && !_elf_cook(elf)) {
return -1;
}
if ((scn = elf->e_scn_n)) {
num = scn->s_index + 1;
}
if (resultp) {
*resultp = num;
}
return 0;
}
int
elf_getshdrstrndx(Elf *elf, size_t *resultp) {
size_t num = 0;
size_t dummy;
Elf_Scn *scn;
if (!elf) {
return -1;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (resultp == NULL) {
resultp = &dummy; /* handle NULL pointer gracefully */
}
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
return -1;
}
if (!elf->e_ehdr && !_elf_cook(elf)) {
return -1;
}
if (elf->e_class == ELFCLASS32) {
num = ((Elf32_Ehdr*)elf->e_ehdr)->e_shstrndx;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
num = ((Elf64_Ehdr*)elf->e_ehdr)->e_shstrndx;
}
#endif /* __LIBELF64 */
else {
if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return -1;
}
if (num != SHN_XINDEX) {
*resultp = num;
return 0;
}
/*
* look at first section header
*/
if (!(scn = elf->e_scn_1)) {
seterr(ERROR_NOSUCHSCN);
return -1;
}
elf_assert(scn->s_magic == SCN_MAGIC);
#if __LIBELF64
if (elf->e_class == ELFCLASS64) {
*resultp = scn->s_shdr64.sh_link;
return 0;
}
#endif /* __LIBELF64 */
*resultp = scn->s_shdr32.sh_link;
return 0;
}
int
elf_getphnum(Elf *elf, size_t *resultp) {
return elf_getphdrnum(elf, resultp) ? LIBELF_FAILURE : LIBELF_SUCCESS;
}
int
elf_getshnum(Elf *elf, size_t *resultp) {
return elf_getshdrnum(elf, resultp) ? LIBELF_FAILURE : LIBELF_SUCCESS;
}
int
elf_getshstrndx(Elf *elf, size_t *resultp) {
return elf_getshdrstrndx(elf, resultp) ? LIBELF_FAILURE : LIBELF_SUCCESS;
}
int
elfx_update_shstrndx(Elf *elf, size_t value) {
size_t extvalue = 0;
Elf_Scn *scn;
if (!elf) {
return LIBELF_FAILURE;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (value >= SHN_LORESERVE) {
extvalue = value;
value = SHN_XINDEX;
}
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
return LIBELF_FAILURE;
}
if (!elf->e_ehdr && !_elf_cook(elf)) {
return LIBELF_FAILURE;
}
if (!(scn = _elf_first_scn(elf))) {
return LIBELF_FAILURE;
}
elf_assert(scn->s_magic == SCN_MAGIC);
if (elf->e_class == ELFCLASS32) {
((Elf32_Ehdr*)elf->e_ehdr)->e_shstrndx = value;
scn->s_shdr32.sh_link = extvalue;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
((Elf64_Ehdr*)elf->e_ehdr)->e_shstrndx = value;
scn->s_shdr64.sh_link = extvalue;
}
#endif /* __LIBELF64 */
else {
if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
return LIBELF_FAILURE;
}
elf->e_ehdr_flags |= ELF_F_DIRTY;
scn->s_shdr_flags |= ELF_F_DIRTY;
return LIBELF_SUCCESS;
}

112
external/libelf/src/x.movscn.c vendored Normal file
View File

@ -0,0 +1,112 @@
/*
x.movscn.c - implementation of the elfx_movscn(3) function.
Copyright (C) 1995 - 2001, 2003 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: x.movscn.c,v 1.14 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
size_t
elfx_movscn(Elf *elf, Elf_Scn *scn, Elf_Scn *after) {
Elf_Scn *prev;
Elf_Scn *tmp;
int off;
if (!elf || !scn || !after) {
return SHN_UNDEF;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
return SHN_UNDEF;
}
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(after->s_magic == SCN_MAGIC);
if (scn->s_elf != elf || after->s_elf != elf) {
seterr(ERROR_ELFSCNMISMATCH);
return SHN_UNDEF;
}
elf_assert(elf->e_scn_1);
if (scn == elf->e_scn_1) {
seterr(ERROR_NULLSCN);
return SHN_UNDEF;
}
if (scn == after || scn == after->s_link) {
/* nothing to do */
return scn->s_index;
}
/*
* Find previous section.
*/
prev = NULL;
for (tmp = elf->e_scn_1; tmp->s_link; tmp = tmp->s_link) {
if (tmp->s_link == scn) {
prev = tmp;
break;
}
}
elf_assert(prev != NULL);
/*
* Update section indices
*/
off = 0;
for (tmp = elf->e_scn_1; tmp; tmp = tmp->s_link) {
if (off) {
tmp->s_index += off;
}
if (tmp == after) {
off++;
}
else if (tmp == scn) {
off--;
}
}
elf_assert(off == 0);
/*
* Move section.
*/
prev->s_link = scn->s_link;
scn->s_link = after->s_link;
after->s_link = scn;
scn->s_index = after->s_index + 1;
if (elf->e_scn_n == scn) {
elf->e_scn_n = prev;
}
else if (elf->e_scn_n == after) {
elf->e_scn_n = scn;
}
#if ENABLE_DEBUG
/*
* Check section indices
*/
tmp = elf->e_scn_1;
elf_assert(tmp->s_index == 0);
while (tmp->s_link) {
elf_assert(tmp->s_link->s_index == tmp->s_index + 1);
tmp = tmp->s_link;
}
#endif /* ENABLE_DEBUG */
return scn->s_index;
}

119
external/libelf/src/x.remscn.c vendored Normal file
View File

@ -0,0 +1,119 @@
/*
x.remscn.c - implementation of the elfx_remscn(3) function.
Copyright (C) 1995 - 2001, 2003 Michael Riepe
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <private.h>
#ifndef lint
static const char rcsid[] = "@(#) $Id: x.remscn.c,v 1.15 2008/05/23 08:15:35 michael Exp $";
#endif /* lint */
size_t
elfx_remscn(Elf *elf, Elf_Scn *scn) {
Elf_Scn *pscn;
Scn_Data *sd;
Scn_Data *tmp;
size_t index;
if (!elf || !scn) {
return SHN_UNDEF;
}
elf_assert(elf->e_magic == ELF_MAGIC);
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
return SHN_UNDEF;
}
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(elf->e_ehdr);
if (scn->s_elf != elf) {
seterr(ERROR_ELFSCNMISMATCH);
return SHN_UNDEF;
}
elf_assert(elf->e_scn_1);
if (scn == elf->e_scn_1) {
seterr(ERROR_NULLSCN);
return SHN_UNDEF;
}
/*
* Find previous section.
*/
for (pscn = elf->e_scn_1; pscn->s_link; pscn = pscn->s_link) {
if (pscn->s_link == scn) {
break;
}
}
if (pscn->s_link != scn) {
seterr(ERROR_ELFSCNMISMATCH);
return SHN_UNDEF;
}
/*
* Unlink section.
*/
if (elf->e_scn_n == scn) {
elf->e_scn_n = pscn;
}
pscn->s_link = scn->s_link;
index = scn->s_index;
/*
* Free section descriptor and data.
*/
for (sd = scn->s_data_1; sd; sd = tmp) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
tmp = sd->sd_link;
if (sd->sd_free_data && sd->sd_memdata) {
free(sd->sd_memdata);
}
if (sd->sd_freeme) {
free(sd);
}
}
if ((sd = scn->s_rawdata)) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
if (sd->sd_free_data && sd->sd_memdata) {
free(sd->sd_memdata);
}
if (sd->sd_freeme) {
free(sd);
}
}
if (scn->s_freeme) {
elf_assert(scn->s_index > 0);
free(scn);
}
/*
* Adjust section indices.
*/
for (scn = pscn->s_link; scn; scn = scn->s_link) {
elf_assert(scn->s_index > index);
scn->s_index--;
}
/*
* Adjust section count in ELF header
*/
if (_elf_update_shnum(elf, elf->e_scn_n->s_index + 1)) {
return SHN_UNDEF;
}
return index;
}

18
external/libhidapi/AUTHORS.txt vendored Normal file
View File

@ -0,0 +1,18 @@
HIDAPI Authors:
Alan Ott <alan@signal11.us>:
Original Author and Maintainer
Linux, Windows, and Mac implementations
Ludovic Rousseau <rousseau@debian.org>:
Formatting for Doxygen documentation
Bug fixes
Correctness fixes
libusb/hidapi Team:
Development/maintainance since June 4th 2019
For a comprehensive list of contributions, see the commit list at github:
https://github.com/libusb/hidapi/commits/master

15
external/libhidapi/HACKING.txt vendored Normal file
View File

@ -0,0 +1,15 @@
This file is mostly for the maintainer.
1. Build hidapi.dll
2. Build hidtest.exe in DEBUG and RELEASE
3. Commit all
4. Run the Following
export VERSION=0.1.0
export TAG_NAME=hidapi-$VERSION
git tag $TAG_NAME
git archive --format zip --prefix $TAG_NAME/ $TAG_NAME >../$TAG_NAME.zip
5. Test the zip file.
6. Run the following:
git push origin $TAG_NAME

26
external/libhidapi/LICENSE-bsd.txt vendored Normal file
View File

@ -0,0 +1,26 @@
Copyright (c) 2010, Alan Ott, Signal 11 Software
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of Signal 11 Software nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

674
external/libhidapi/LICENSE-gpl3.txt vendored Normal file
View File

@ -0,0 +1,674 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

9
external/libhidapi/LICENSE-orig.txt vendored Normal file
View File

@ -0,0 +1,9 @@
HIDAPI - Multi-Platform library for
communication with HID devices.
Copyright 2009, Alan Ott, Signal 11 Software.
All Rights Reserved.
This software may be used by anyone for any reason so
long as the copyright notice in the source files
remains intact.

13
external/libhidapi/LICENSE.txt vendored Normal file
View File

@ -0,0 +1,13 @@
HIDAPI can be used under one of three licenses.
1. The GNU General Public License, version 3.0, in LICENSE-gpl3.txt
2. A BSD-Style License, in LICENSE-bsd.txt.
3. The more liberal original HIDAPI license. LICENSE-orig.txt
The license chosen is at the discretion of the user of HIDAPI. For example:
1. An author of GPL software would likely use HIDAPI under the terms of the
GPL.
2. An author of commercial closed-source software would likely use HIDAPI
under the terms of the BSD-style license or the original HIDAPI license.

380
external/libhidapi/README.md vendored Normal file
View File

@ -0,0 +1,380 @@
## HIDAPI library for Windows, Linux, FreeBSD and macOS
| CI instance | Status |
|----------------------|--------|
| `macOS master` | [![Build Status](https://travis-ci.org/libusb/hidapi.svg?branch=master)](https://travis-ci.org/libusb/hidapi) |
| `Windows master` | [![Build status](https://ci.appveyor.com/api/projects/status/r482aevuigmi86rk/branch/master?svg=true)](https://ci.appveyor.com/project/Youw/hidapi/branch/master) |
| `Linux/BSD, last build (branch/PR)` | [![builds.sr.ht status](https://builds.sr.ht/~qbicz/hidapi.svg)](https://builds.sr.ht/~qbicz/hidapi?) |
HIDAPI is a multi-platform library which allows an application to interface
with USB and Bluetooth HID-Class devices on Windows, Linux, FreeBSD, and macOS.
HIDAPI can be either built as a shared library (`.so`, `.dll` or `.dylib`) or
can be embedded directly into a target application by adding a single source
file (per platform) and a single header.
HIDAPI library was originally developed by Alan Ott ([signal11](https://github.com/signal11)).
It was moved to [libusb/hidapi](https://github.com/libusb/hidapi) on June 4th, 2019, in order to merge important bugfixes and continue development of the library.
## Table of Contents
* [About](#about)
* [What Does the API Look Like?](#what-does-the-api-look-like)
* [License](#license)
* [Download](#download)
* [Build Instructions](#build-instructions)
* [Prerequisites](#prerequisites)
* [Linux](#linux)
* [FreeBSD](#freebsd)
* [Mac](#mac)
* [Windows](#windows)
* [Building HIDAPI into a shared library on Unix Platforms](#building-hidapi-into-a-shared-library-on-unix-platforms)
* [Building the manual way on Unix platforms](#building-the-manual-way-on-unix-platforms)
* [Building on Windows](#building-on-windows)
* [Cross Compiling](#cross-compiling)
* [Prerequisites](#prerequisites-1)
* [Building HIDAPI](#building-hidapi)
## About
HIDAPI has five back-ends:
* Windows (using `hid.dll`)
* Linux/hidraw (using the Kernel's hidraw driver)
* Linux/libusb (using libusb-1.0)
* FreeBSD (using libusb-1.0)
* Mac (using IOHidManager)
On Linux, either the hidraw or the libusb back-end can be used. There are
tradeoffs, and the functionality supported is slightly different.
__Linux/hidraw__ (`linux/hid.c`):
This back-end uses the hidraw interface in the Linux kernel, and supports
both USB and Bluetooth HID devices. It requires kernel version at least 2.6.39
to build. In addition, it will only communicate with devices which have hidraw
nodes associated with them.
Keyboards, mice, and some other devices which are blacklisted from having
hidraw nodes will not work. Fortunately, for nearly all the uses of hidraw,
this is not a problem.
__Linux/FreeBSD/libusb__ (`libusb/hid.c`):
This back-end uses libusb-1.0 to communicate directly to a USB device. This
back-end will of course not work with Bluetooth devices.
HIDAPI also comes with a Test GUI. The Test GUI is cross-platform and uses
Fox Toolkit <http://www.fox-toolkit.org>. It will build on every platform
which HIDAPI supports. Since it relies on a 3rd party library, building it
is optional but recommended because it is so useful when debugging hardware.
## What Does the API Look Like?
The API provides the most commonly used HID functions including sending
and receiving of input, output, and feature reports. The sample program,
which communicates with a heavily hacked up version of the Microchip USB
Generic HID sample looks like this (with error checking removed for
simplicity):
**Warning: Only run the code you understand, and only when it conforms to the
device spec. Writing data at random to your HID devices can break them.**
```c
#ifdef WIN32
#include <windows.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include "hidapi.h"
#define MAX_STR 255
int main(int argc, char* argv[])
{
int res;
unsigned char buf[65];
wchar_t wstr[MAX_STR];
hid_device *handle;
int i;
// Initialize the hidapi library
res = hid_init();
// Open the device using the VID, PID,
// and optionally the Serial number.
handle = hid_open(0x4d8, 0x3f, NULL);
// Read the Manufacturer String
res = hid_get_manufacturer_string(handle, wstr, MAX_STR);
wprintf(L"Manufacturer String: %s\n", wstr);
// Read the Product String
res = hid_get_product_string(handle, wstr, MAX_STR);
wprintf(L"Product String: %s\n", wstr);
// Read the Serial Number String
res = hid_get_serial_number_string(handle, wstr, MAX_STR);
wprintf(L"Serial Number String: (%d) %s\n", wstr[0], wstr);
// Read Indexed String 1
res = hid_get_indexed_string(handle, 1, wstr, MAX_STR);
wprintf(L"Indexed String 1: %s\n", wstr);
// Toggle LED (cmd 0x80). The first byte is the report number (0x0).
buf[0] = 0x0;
buf[1] = 0x80;
res = hid_write(handle, buf, 65);
// Request state (cmd 0x81). The first byte is the report number (0x0).
buf[0] = 0x0;
buf[1] = 0x81;
res = hid_write(handle, buf, 65);
// Read requested state
res = hid_read(handle, buf, 65);
// Print out the returned buffer.
for (i = 0; i < 4; i++)
printf("buf[%d]: %d\n", i, buf[i]);
// Close the device
hid_close(handle);
// Finalize the hidapi library
res = hid_exit();
return 0;
}
```
You can also use [hidtest/test.c](hidtest/test.c)
as a starting point for your applications.
## License
HIDAPI may be used by one of three licenses as outlined in [LICENSE.txt](LICENSE.txt).
## Download
HIDAPI can be downloaded from GitHub
```sh
git clone git://github.com/libusb/hidapi.git
```
## Build Instructions
This section is long. Don't be put off by this. It's not long because it's
complicated to build HIDAPI; it's quite the opposite. This section is long
because of the flexibility of HIDAPI and the large number of ways in which
it can be built and used. You will likely pick a single build method.
HIDAPI can be built in several different ways. If you elect to build a
shared library, you will need to build it from the HIDAPI source
distribution. If you choose instead to embed HIDAPI directly into your
application, you can skip the building and look at the provided platform
Makefiles for guidance. These platform Makefiles are located in `linux/`,
`libusb/`, `mac/` and `windows/` and are called `Makefile-manual`. In addition,
Visual Studio projects are provided. Even if you're going to embed HIDAPI
into your project, it is still beneficial to build the example programs.
### Prerequisites:
#### Linux:
On Linux, you will need to install development packages for libudev,
libusb and optionally Fox-toolkit (for the test GUI). On
Debian/Ubuntu systems these can be installed by running:
```sh
sudo apt-get install libudev-dev libusb-1.0-0-dev libfox-1.6-dev
```
If you downloaded the source directly from the git repository (using
git clone), you'll need Autotools:
```sh
sudo apt-get install autotools-dev autoconf automake libtool
```
#### FreeBSD:
On FreeBSD you will need to install GNU make, libiconv, and
optionally Fox-Toolkit (for the test GUI). This is done by running
the following:
```sh
pkg_add -r gmake libiconv fox16
```
If you downloaded the source directly from the git repository (using
git clone), you'll need Autotools:
```sh
pkg_add -r autotools
```
#### Mac:
On Mac, you will need to install Fox-Toolkit if you wish to build
the Test GUI. There are two ways to do this, and each has a slight
complication. Which method you use depends on your use case.
If you wish to build the Test GUI just for your own testing on your
own computer, then the easiest method is to install Fox-Toolkit
using ports:
```sh
sudo port install fox
```
If you wish to build the TestGUI app bundle to redistribute to
others, you will need to install Fox-toolkit from source. This is
because the version of fox that gets installed using ports uses the
ports X11 libraries which are not compatible with the Apple X11
libraries. If you install Fox with ports and then try to distribute
your built app bundle, it will simply fail to run on other systems.
To install Fox-Toolkit manually, download the source package from
<http://www.fox-toolkit.org>, extract it, and run the following from
within the extracted source:
```sh
./configure && make && make install
```
#### Windows:
On Windows, if you want to build the test GUI, you will need to get
the `hidapi-externals.zip` package from the download site. This
contains pre-built binaries for Fox-toolkit. Extract
`hidapi-externals.zip` just outside of hidapi, so that
hidapi-externals and hidapi are on the same level, as shown:
```
Parent_Folder
|
+hidapi
+hidapi-externals
```
Again, this step is not required if you do not wish to build the
test GUI.
### Building HIDAPI into a shared library on Unix Platforms:
On Unix-like systems such as Linux, FreeBSD, macOS, and even Windows, using
MinGW or Cygwin, the easiest way to build a standard system-installed shared
library is to use the GNU Autotools build system. If you checked out the
source from the git repository, run the following:
```sh
./bootstrap
./configure
make
make install # as root, or using sudo
```
If you downloaded a source package (i.e.: if you did not run git clone), you
can skip the `./bootstrap` step.
`./configure` can take several arguments which control the build. The two most
likely to be used are:
```sh
--enable-testgui
Enable build of the Test GUI. This requires Fox toolkit to
be installed. Instructions for installing Fox-Toolkit on
each platform are in the Prerequisites section above.
--prefix=/usr
Specify where you want the output headers and libraries to
be installed. The example above will put the headers in
/usr/include and the binaries in /usr/lib. The default is to
install into /usr/local which is fine on most systems.
```
### Building the manual way on Unix platforms:
Manual Makefiles are provided mostly to give the user and idea what it takes
to build a program which embeds HIDAPI directly inside of it. These should
really be used as examples only. If you want to build a system-wide shared
library, use the Autotools method described above.
To build HIDAPI using the manual Makefiles, change to the directory
of your platform and run make. For example, on Linux run:
```sh
cd linux/
make -f Makefile-manual
```
To build the Test GUI using the manual makefiles:
```sh
cd testgui/
make -f Makefile-manual
```
### Building on Windows:
To build the HIDAPI DLL on Windows using Visual Studio, build the `.sln` file
in the `windows/` directory.
To build the Test GUI on windows using Visual Studio, build the `.sln` file in
the `testgui/` directory.
To build HIDAPI using MinGW or Cygwin using Autotools, use the instructions
in the section [Building HIDAPI into a shared library on Unix Platforms](#building-hidapi-into-a-shared-library-on-unix-platforms)
above. Note that building the Test GUI with MinGW or Cygwin will
require the Windows procedure in the [Prerequisites](#prerequisites-1) section
above (i.e.: `hidapi-externals.zip`).
To build HIDAPI using MinGW using the Manual Makefiles, see the section
[Building the manual way on Unix platforms](#building-the-manual-way-on-unix-platforms)
above.
HIDAPI can also be built using the Windows DDK (now also called the Windows
Driver Kit or WDK). This method was originally required for the HIDAPI build
but not anymore. However, some users still prefer this method. It is not as
well supported anymore but should still work. Patches are welcome if it does
not. To build using the DDK:
1. Install the Windows Driver Kit (WDK) from Microsoft.
2. From the Start menu, in the Windows Driver Kits folder, select Build
Environments, then your operating system, then the x86 Free Build
Environment (or one that is appropriate for your system).
3. From the console, change directory to the `windows/ddk_build/` directory,
which is part of the HIDAPI distribution.
4. Type build.
5. You can find the output files (DLL and LIB) in a subdirectory created
by the build system which is appropriate for your environment. On
Windows XP, this directory is `objfre_wxp_x86/i386`.
## Cross Compiling
This section talks about cross compiling HIDAPI for Linux using Autotools.
This is useful for using HIDAPI on embedded Linux targets. These
instructions assume the most raw kind of embedded Linux build, where all
prerequisites will need to be built first. This process will of course vary
based on your embedded Linux build system if you are using one, such as
OpenEmbedded or Buildroot.
For the purpose of this section, it will be assumed that the following
environment variables are exported.
```sh
$ export STAGING=$HOME/out
$ export HOST=arm-linux
```
`STAGING` and `HOST` can be modified to suit your setup.
### Prerequisites
Note that the build of libudev is the very basic configuration.
Build libusb. From the libusb source directory, run:
```sh
./configure --host=$HOST --prefix=$STAGING
make
make install
```
Build libudev. From the libudev source directory, run:
```sh
./configure --disable-gudev --disable-introspection --disable-hwdb \
--host=$HOST --prefix=$STAGING
make
make install
```
### Building HIDAPI
Build HIDAPI:
```
PKG_CONFIG_DIR= \
PKG_CONFIG_LIBDIR=$STAGING/lib/pkgconfig:$STAGING/share/pkgconfig \
PKG_CONFIG_SYSROOT_DIR=$STAGING \
./configure --host=$HOST --prefix=$STAGING
```

446
external/libhidapi/include/hidapi/hidapi.h vendored Normal file
View File

@ -0,0 +1,446 @@
/*******************************************************
HIDAPI - Multi-Platform library for
communication with HID devices.
Alan Ott
Signal 11 Software
8/22/2009
Copyright 2009, All Rights Reserved.
At the discretion of the user of this library,
this software may be licensed under the terms of the
GNU General Public License v3, a BSD-Style license, or the
original HIDAPI license as outlined in the LICENSE.txt,
LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
files located at the root of the source distribution.
These files may also be found in the public source
code repository located at:
https://github.com/libusb/hidapi .
********************************************************/
/** @file
* @defgroup API hidapi API
*/
#ifndef HIDAPI_H__
#define HIDAPI_H__
#include <wchar.h>
#ifdef _WIN32
#define HID_API_EXPORT __declspec(dllexport)
#define HID_API_CALL
#else
#define HID_API_EXPORT /**< API export macro */
#define HID_API_CALL /**< API call macro */
#endif
#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/
#ifdef __cplusplus
extern "C" {
#endif
struct hid_device_;
typedef struct hid_device_ hid_device; /**< opaque hidapi structure */
/** hidapi info structure */
struct hid_device_info {
/** Platform-specific device path */
char *path;
/** Device Vendor ID */
unsigned short vendor_id;
/** Device Product ID */
unsigned short product_id;
/** Serial Number */
wchar_t *serial_number;
/** Device Release Number in binary-coded decimal,
also known as Device Version Number */
unsigned short release_number;
/** Manufacturer String */
wchar_t *manufacturer_string;
/** Product string */
wchar_t *product_string;
/** Usage Page for this Device/Interface
(Windows/Mac only). */
unsigned short usage_page;
/** Usage for this Device/Interface
(Windows/Mac only).*/
unsigned short usage;
/** The USB interface which this logical device
represents.
* Valid on both Linux implementations in all cases.
* Valid on the Windows implementation only if the device
contains more than one interface.
* Valid on the Mac implementation if and only if the device
is a USB HID device. */
int interface_number;
/** Pointer to the next device */
struct hid_device_info *next;
};
/** @brief Initialize the HIDAPI library.
This function initializes the HIDAPI library. Calling it is not
strictly necessary, as it will be called automatically by
hid_enumerate() and any of the hid_open_*() functions if it is
needed. This function should be called at the beginning of
execution however, if there is a chance of HIDAPI handles
being opened by different threads simultaneously.
@ingroup API
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_init(void);
/** @brief Finalize the HIDAPI library.
This function frees all of the static data associated with
HIDAPI. It should be called at the end of execution to avoid
memory leaks.
@ingroup API
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_exit(void);
/** @brief Enumerate the HID Devices.
This function returns a linked list of all the HID devices
attached to the system which match vendor_id and product_id.
If @p vendor_id is set to 0 then any vendor matches.
If @p product_id is set to 0 then any product matches.
If @p vendor_id and @p product_id are both set to 0, then
all HID devices will be returned.
@ingroup API
@param vendor_id The Vendor ID (VID) of the types of device
to open.
@param product_id The Product ID (PID) of the types of
device to open.
@returns
This function returns a pointer to a linked list of type
struct #hid_device_info, containing information about the HID devices
attached to the system, or NULL in the case of failure. Free
this linked list by calling hid_free_enumeration().
*/
struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id);
/** @brief Free an enumeration Linked List
This function frees a linked list created by hid_enumerate().
@ingroup API
@param devs Pointer to a list of struct_device returned from
hid_enumerate().
*/
void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs);
/** @brief Open a HID device using a Vendor ID (VID), Product ID
(PID) and optionally a serial number.
If @p serial_number is NULL, the first device with the
specified VID and PID is opened.
This function sets the return value of hid_error().
@ingroup API
@param vendor_id The Vendor ID (VID) of the device to open.
@param product_id The Product ID (PID) of the device to open.
@param serial_number The Serial Number of the device to open
(Optionally NULL).
@returns
This function returns a pointer to a #hid_device object on
success or NULL on failure.
*/
HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);
/** @brief Open a HID device by its path name.
The path name be determined by calling hid_enumerate(), or a
platform-specific path name can be used (eg: /dev/hidraw0 on
Linux).
This function sets the return value of hid_error().
@ingroup API
@param path The path name of the device to open
@returns
This function returns a pointer to a #hid_device object on
success or NULL on failure.
*/
HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path);
/** @brief Write an Output report to a HID device.
The first byte of @p data[] must contain the Report ID. For
devices which only support a single report, this must be set
to 0x0. The remaining bytes contain the report data. Since
the Report ID is mandatory, calls to hid_write() will always
contain one more byte than the report contains. For example,
if a hid report is 16 bytes long, 17 bytes must be passed to
hid_write(), the Report ID (or 0x0, for devices with a
single report), followed by the report data (16 bytes). In
this example, the length passed in would be 17.
hid_write() will send the data on the first OUT endpoint, if
one exists. If it does not, it will send the data through
the Control Endpoint (Endpoint 0).
This function sets the return value of hid_error().
@ingroup API
@param dev A device handle returned from hid_open().
@param data The data to send, including the report number as
the first byte.
@param length The length in bytes of the data to send.
@returns
This function returns the actual number of bytes written and
-1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length);
/** @brief Read an Input report from a HID device with timeout.
Input reports are returned
to the host through the INTERRUPT IN endpoint. The first byte will
contain the Report number if the device uses numbered reports.
This function sets the return value of hid_error().
@ingroup API
@param dev A device handle returned from hid_open().
@param data A buffer to put the read data into.
@param length The number of bytes to read. For devices with
multiple reports, make sure to read an extra byte for
the report number.
@param milliseconds timeout in milliseconds or -1 for blocking wait.
@returns
This function returns the actual number of bytes read and
-1 on error. If no packet was available to be read within
the timeout period, this function returns 0.
*/
int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds);
/** @brief Read an Input report from a HID device.
Input reports are returned
to the host through the INTERRUPT IN endpoint. The first byte will
contain the Report number if the device uses numbered reports.
This function sets the return value of hid_error().
@ingroup API
@param dev A device handle returned from hid_open().
@param data A buffer to put the read data into.
@param length The number of bytes to read. For devices with
multiple reports, make sure to read an extra byte for
the report number.
@returns
This function returns the actual number of bytes read and
-1 on error. If no packet was available to be read and
the handle is in non-blocking mode, this function returns 0.
*/
int HID_API_EXPORT HID_API_CALL hid_read(hid_device *dev, unsigned char *data, size_t length);
/** @brief Set the device handle to be non-blocking.
In non-blocking mode calls to hid_read() will return
immediately with a value of 0 if there is no data to be
read. In blocking mode, hid_read() will wait (block) until
there is data to read before returning.
Nonblocking can be turned on and off at any time.
@ingroup API
@param dev A device handle returned from hid_open().
@param nonblock enable or not the nonblocking reads
- 1 to enable nonblocking
- 0 to disable nonblocking.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock);
/** @brief Send a Feature report to the device.
Feature reports are sent over the Control endpoint as a
Set_Report transfer. The first byte of @p data[] must
contain the Report ID. For devices which only support a
single report, this must be set to 0x0. The remaining bytes
contain the report data. Since the Report ID is mandatory,
calls to hid_send_feature_report() will always contain one
more byte than the report contains. For example, if a hid
report is 16 bytes long, 17 bytes must be passed to
hid_send_feature_report(): the Report ID (or 0x0, for
devices which do not use numbered reports), followed by the
report data (16 bytes). In this example, the length passed
in would be 17.
This function sets the return value of hid_error().
@ingroup API
@param dev A device handle returned from hid_open().
@param data The data to send, including the report number as
the first byte.
@param length The length in bytes of the data to send, including
the report number.
@returns
This function returns the actual number of bytes written and
-1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length);
/** @brief Get a feature report from a HID device.
Set the first byte of @p data[] to the Report ID of the
report to be read. Make sure to allow space for this
extra byte in @p data[]. Upon return, the first byte will
still contain the Report ID, and the report data will
start in data[1].
This function sets the return value of hid_error().
@ingroup API
@param dev A device handle returned from hid_open().
@param data A buffer to put the read data into, including
the Report ID. Set the first byte of @p data[] to the
Report ID of the report to be read, or set it to zero
if your device does not use numbered reports.
@param length The number of bytes to read, including an
extra byte for the report ID. The buffer can be longer
than the actual report.
@returns
This function returns the number of bytes read plus
one for the report ID (which is still in the first
byte), or -1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length);
/** @brief Get a input report from a HID device.
Set the first byte of @p data[] to the Report ID of the
report to be read. Make sure to allow space for this
extra byte in @p data[]. Upon return, the first byte will
still contain the Report ID, and the report data will
start in data[1].
@ingroup API
@param device A device handle returned from hid_open().
@param data A buffer to put the read data into, including
the Report ID. Set the first byte of @p data[] to the
Report ID of the report to be read, or set it to zero
if your device does not use numbered reports.
@param length The number of bytes to read, including an
extra byte for the report ID. The buffer can be longer
than the actual report.
@returns
This function returns the number of bytes read plus
one for the report ID (which is still in the first
byte), or -1 on error.
*/
int HID_API_EXPORT HID_API_CALL hid_get_input_report(hid_device *dev, unsigned char *data, size_t length);
/** @brief Close a HID device.
This function sets the return value of hid_error().
@ingroup API
@param dev A device handle returned from hid_open().
*/
void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev);
/** @brief Get The Manufacturer String from a HID device.
@ingroup API
@param dev A device handle returned from hid_open().
@param string A wide string buffer to put the data into.
@param maxlen The length of the buffer in multiples of wchar_t.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen);
/** @brief Get The Product String from a HID device.
@ingroup API
@param dev A device handle returned from hid_open().
@param string A wide string buffer to put the data into.
@param maxlen The length of the buffer in multiples of wchar_t.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen);
/** @brief Get The Serial Number String from a HID device.
@ingroup API
@param dev A device handle returned from hid_open().
@param string A wide string buffer to put the data into.
@param maxlen The length of the buffer in multiples of wchar_t.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen);
/** @brief Get a string from a HID device, based on its string index.
@ingroup API
@param dev A device handle returned from hid_open().
@param string_index The index of the string to get.
@param string A wide string buffer to put the data into.
@param maxlen The length of the buffer in multiples of wchar_t.
@returns
This function returns 0 on success and -1 on error.
*/
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen);
/** @brief Get a string describing the last error which occurred.
Whether a function sets the last error is noted in its
documentation. These functions will reset the last error
to NULL before their execution.
Strings returned from hid_error() must not be freed by the user!
This function is thread-safe, and error messages are thread-local.
@ingroup API
@param dev A device handle returned from hid_open(),
or NULL to get the last non-device-specific error
(e.g. for errors in hid_open() itself).
@returns
This function returns a string containing the last error
which occurred or NULL if none has occurred.
*/
HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *dev);
#ifdef __cplusplus
}
#endif
#endif

156
external/libhidapi/libhidapi.vcxproj vendored Normal file
View File

@ -0,0 +1,156 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</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\hid.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\hidapi\hidapi.h" />
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{17054837-6ae6-44d7-914d-9625edef4657}</ProjectGuid>
<RootNamespace>libhidapi</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>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>include\hidapi</AdditionalIncludeDirectories>
<DisableSpecificWarnings>4267</DisableSpecificWarnings>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<AdditionalIncludeDirectories>include\hidapi</AdditionalIncludeDirectories>
<DisableSpecificWarnings>4267</DisableSpecificWarnings>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>include\hidapi</AdditionalIncludeDirectories>
<DisableSpecificWarnings>4267</DisableSpecificWarnings>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<AdditionalIncludeDirectories>include\hidapi</AdditionalIncludeDirectories>
<DisableSpecificWarnings>4267</DisableSpecificWarnings>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

9
external/libhidapi/libhidapi.vcxproj.filters vendored Normal file
View File

@ -0,0 +1,9 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<ClInclude Include="include\hidapi\hidapi.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\hid.c" />
</ItemGroup>
</Project>

1019
external/libhidapi/src/hid.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

16
external/libusb/AUTHORS.txt vendored Normal file
View File

@ -0,0 +1,16 @@
Library, Test Programs:
Stephan Meyer, <ste_meyer@web.de>
Johannes Erdfelt, <johannes@erdfelt.com>
Thomas Sailer, <sailer@ife.ee.ethz.ch>
Drivers, Installer:
Stephan Meyer, <ste_meyer@web.de>
Travis Robinson, <libusbdotnet@gmail.com>
Testing, Technical support:
Xiaofan Chen, <xiaofanc@gmail.com>

674
external/libusb/COPYING_GPL.txt vendored Normal file
View File

@ -0,0 +1,674 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

165
external/libusb/COPYING_LGPL.txt vendored Normal file
View File

@ -0,0 +1,165 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.

12
external/libusb/README.in vendored Normal file
View File

@ -0,0 +1,12 @@
This is libusb-win32 (http://libusb-win32.sourceforge.net) version @VERSION@.
Libusb-win32 is a library that allows userspace application to access USB
devices on Windows operation systems (Win2k, WinXP, Vista, Win7).
It is derived from and fully API compatible to libusb available at
http://libusb.sourceforge.net.
For more information visit the project's web site at:
http://libusb-win32.sourceforge.net
http://sourceforge.net/projects/libusb-win32

429
external/libusb/include/lusb0_usb.h vendored Normal file
View File

@ -0,0 +1,429 @@
#ifndef __LUSB0_USB__
#define __LUSB0_USB__
#include <stdlib.h>
/*
* 'interface' is defined somewhere in the Windows header files. This macro
* is deleted here to avoid conflicts and compile errors.
*/
#ifdef interface
#undef interface
#endif
/*
* PATH_MAX from limits.h can't be used on Windows if the dll and
* import libraries are build/used by different compilers
*/
#define LIBUSB_PATH_MAX 512
/*
* USB spec information
*
* This is all stuff grabbed from various USB specs and is pretty much
* not subject to change
*/
/*
* Device and/or Interface Class codes
*/
#define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */
#define USB_CLASS_AUDIO 1
#define USB_CLASS_COMM 2
#define USB_CLASS_HID 3
#define USB_CLASS_PRINTER 7
#define USB_CLASS_MASS_STORAGE 8
#define USB_CLASS_HUB 9
#define USB_CLASS_DATA 10
#define USB_CLASS_VENDOR_SPEC 0xff
/*
* Descriptor types
*/
#define USB_DT_DEVICE 0x01
#define USB_DT_CONFIG 0x02
#define USB_DT_STRING 0x03
#define USB_DT_INTERFACE 0x04
#define USB_DT_ENDPOINT 0x05
#define USB_DT_HID 0x21
#define USB_DT_REPORT 0x22
#define USB_DT_PHYSICAL 0x23
#define USB_DT_HUB 0x29
/*
* Descriptor sizes per descriptor type
*/
#define USB_DT_DEVICE_SIZE 18
#define USB_DT_CONFIG_SIZE 9
#define USB_DT_INTERFACE_SIZE 9
#define USB_DT_ENDPOINT_SIZE 7
#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */
#define USB_DT_HUB_NONVAR_SIZE 7
/* ensure byte-packed structures */
#include <pshpack1.h>
/* All standard descriptors have these 2 fields in common */
struct usb_descriptor_header
{
unsigned char bLength;
unsigned char bDescriptorType;
};
/* String descriptor */
struct usb_string_descriptor
{
unsigned char bLength;
unsigned char bDescriptorType;
unsigned short wData[1];
};
/* HID descriptor */
struct usb_hid_descriptor
{
unsigned char bLength;
unsigned char bDescriptorType;
unsigned short bcdHID;
unsigned char bCountryCode;
unsigned char bNumDescriptors;
};
/* Endpoint descriptor */
#define USB_MAXENDPOINTS 32
struct usb_endpoint_descriptor
{
unsigned char bLength;
unsigned char bDescriptorType;
unsigned char bEndpointAddress;
unsigned char bmAttributes;
unsigned short wMaxPacketSize;
unsigned char bInterval;
unsigned char bRefresh;
unsigned char bSynchAddress;
unsigned char *extra; /* Extra descriptors */
int extralen;
};
#ifndef __USBSPEC_H__
#define USB_ENDPOINT_ADDRESS_MASK 0x0f /* in bEndpointAddress */
#define USB_ENDPOINT_DIR_MASK 0x80
#define USB_ENDPOINT_TYPE_MASK 0x03 /* in bmAttributes */
#define USB_ENDPOINT_TYPE_CONTROL 0
#define USB_ENDPOINT_TYPE_ISOCHRONOUS 1
#define USB_ENDPOINT_TYPE_BULK 2
#define USB_ENDPOINT_TYPE_INTERRUPT 3
#endif
/* Interface descriptor */
#define USB_MAXINTERFACES 32
struct usb_interface_descriptor
{
unsigned char bLength;
unsigned char bDescriptorType;
unsigned char bInterfaceNumber;
unsigned char bAlternateSetting;
unsigned char bNumEndpoints;
unsigned char bInterfaceClass;
unsigned char bInterfaceSubClass;
unsigned char bInterfaceProtocol;
unsigned char iInterface;
struct usb_endpoint_descriptor *endpoint;
unsigned char *extra; /* Extra descriptors */
int extralen;
};
#define USB_MAXALTSETTING 128 /* Hard limit */
struct usb_interface
{
struct usb_interface_descriptor *altsetting;
int num_altsetting;
};
/* Configuration descriptor information.. */
#define USB_MAXCONFIG 8
struct usb_config_descriptor
{
unsigned char bLength;
unsigned char bDescriptorType;
unsigned short wTotalLength;
unsigned char bNumInterfaces;
unsigned char bConfigurationValue;
unsigned char iConfiguration;
unsigned char bmAttributes;
unsigned char MaxPower;
struct usb_interface *interface;
unsigned char *extra; /* Extra descriptors */
int extralen;
};
/* Device descriptor */
struct usb_device_descriptor
{
unsigned char bLength;
unsigned char bDescriptorType;
unsigned short bcdUSB;
unsigned char bDeviceClass;
unsigned char bDeviceSubClass;
unsigned char bDeviceProtocol;
unsigned char bMaxPacketSize0;
unsigned short idVendor;
unsigned short idProduct;
unsigned short bcdDevice;
unsigned char iManufacturer;
unsigned char iProduct;
unsigned char iSerialNumber;
unsigned char bNumConfigurations;
};
struct usb_ctrl_setup
{
unsigned char bRequestType;
unsigned char bRequest;
unsigned short wValue;
unsigned short wIndex;
unsigned short wLength;
};
/*
* Standard requests
*/
#define USB_REQ_GET_STATUS 0x00
#define USB_REQ_CLEAR_FEATURE 0x01
/* 0x02 is reserved */
#define USB_REQ_SET_FEATURE 0x03
/* 0x04 is reserved */
#define USB_REQ_SET_ADDRESS 0x05
#define USB_REQ_GET_DESCRIPTOR 0x06
#define USB_REQ_SET_DESCRIPTOR 0x07
#define USB_REQ_GET_CONFIGURATION 0x08
#define USB_REQ_SET_CONFIGURATION 0x09
#define USB_REQ_GET_INTERFACE 0x0A
#define USB_REQ_SET_INTERFACE 0x0B
#define USB_REQ_SYNCH_FRAME 0x0C
#define USB_TYPE_STANDARD (0x00 << 5)
#define USB_TYPE_CLASS (0x01 << 5)
#define USB_TYPE_VENDOR (0x02 << 5)
#define USB_TYPE_RESERVED (0x03 << 5)
#define USB_RECIP_DEVICE 0x00
#define USB_RECIP_INTERFACE 0x01
#define USB_RECIP_ENDPOINT 0x02
#define USB_RECIP_OTHER 0x03
/*
* Various libusb API related stuff
*/
#define USB_ENDPOINT_IN 0x80
#define USB_ENDPOINT_OUT 0x00
/* Error codes */
#define USB_ERROR_BEGIN 500000
/*
* This is supposed to look weird. This file is generated from autoconf
* and I didn't want to make this too complicated.
*/
#define USB_LE16_TO_CPU(x)
/*
* Device reset types for usb_reset_ex.
* http://msdn.microsoft.com/en-us/library/ff537269%28VS.85%29.aspx
* http://msdn.microsoft.com/en-us/library/ff537243%28v=vs.85%29.aspx
*/
#define USB_RESET_TYPE_RESET_PORT (1 << 0)
#define USB_RESET_TYPE_CYCLE_PORT (1 << 1)
#define USB_RESET_TYPE_FULL_RESET (USB_RESET_TYPE_CYCLE_PORT | USB_RESET_TYPE_RESET_PORT)
/* Data types */
/* struct usb_device; */
/* struct usb_bus; */
struct usb_device
{
struct usb_device *next, *prev;
char filename[LIBUSB_PATH_MAX];
struct usb_bus *bus;
struct usb_device_descriptor descriptor;
struct usb_config_descriptor *config;
void *dev; /* Darwin support */
unsigned char devnum;
unsigned char num_children;
struct usb_device **children;
};
struct usb_bus
{
struct usb_bus *next, *prev;
char dirname[LIBUSB_PATH_MAX];
struct usb_device *devices;
unsigned long location;
struct usb_device *root_dev;
};
/* Version information, Windows specific */
struct usb_version
{
struct
{
int major;
int minor;
int micro;
int nano;
} dll;
struct
{
int major;
int minor;
int micro;
int nano;
} driver;
};
struct usb_dev_handle;
typedef struct usb_dev_handle usb_dev_handle;
/* Variables */
#ifndef __USB_C__
#define usb_busses usb_get_busses()
#endif
#include <poppack.h>
#ifdef __cplusplus
extern "C"
{
#endif
/* Function prototypes */
/* usb.c */
usb_dev_handle *usb_open(struct usb_device *dev);
int usb_close(usb_dev_handle *dev);
int usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf,
size_t buflen);
int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf,
size_t buflen);
/* descriptors.c */
int usb_get_descriptor_by_endpoint(usb_dev_handle *udev, int ep,
unsigned char type, unsigned char index,
void *buf, int size);
int usb_get_descriptor(usb_dev_handle *udev, unsigned char type,
unsigned char index, void *buf, int size);
/* <arch>.c */
int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size,
int timeout);
int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size,
int timeout);
int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size,
int timeout);
int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size,
int timeout);
int usb_control_msg(usb_dev_handle *dev, int requesttype, int request,
int value, int index, char *bytes, int size,
int timeout);
int usb_set_configuration(usb_dev_handle *dev, int configuration);
int usb_claim_interface(usb_dev_handle *dev, int interface);
int usb_release_interface(usb_dev_handle *dev, int interface);
int usb_set_altinterface(usb_dev_handle *dev, int alternate);
int usb_resetep(usb_dev_handle *dev, unsigned int ep);
int usb_clear_halt(usb_dev_handle *dev, unsigned int ep);
int usb_reset(usb_dev_handle *dev);
int usb_reset_ex(usb_dev_handle *dev, unsigned int reset_type);
char *usb_strerror(void);
void usb_init(void);
void usb_set_debug(int level);
int usb_find_busses(void);
int usb_find_devices(void);
struct usb_device *usb_device(usb_dev_handle *dev);
struct usb_bus *usb_get_busses(void);
#ifdef _WINDOWS_
/* Windows specific functions */
#define LIBUSB_HAS_INSTALL_SERVICE_NP 1
int usb_install_service_np(void);
void CALLBACK usb_install_service_np_rundll(HWND wnd, HINSTANCE instance,
LPSTR cmd_line, int cmd_show);
#define LIBUSB_HAS_UNINSTALL_SERVICE_NP 1
int usb_uninstall_service_np(void);
void CALLBACK usb_uninstall_service_np_rundll(HWND wnd, HINSTANCE instance,
LPSTR cmd_line, int cmd_show);
#define LIBUSB_HAS_INSTALL_DRIVER_NP 1
int usb_install_driver_np(const char *inf_file);
void CALLBACK usb_install_driver_np_rundll(HWND wnd, HINSTANCE instance,
LPSTR cmd_line, int cmd_show);
#define LIBUSB_HAS_TOUCH_INF_FILE_NP 1
int usb_touch_inf_file_np(const char *inf_file);
void CALLBACK usb_touch_inf_file_np_rundll(HWND wnd, HINSTANCE instance,
LPSTR cmd_line, int cmd_show);
#define LIBUSB_HAS_INSTALL_NEEDS_RESTART_NP 1
int usb_install_needs_restart_np(void);
#define LIBUSB_HAS_INSTALL_NP 1
int usb_install_npW(HWND hwnd, HINSTANCE instance, LPCWSTR cmd_line, int starg_arg);
int usb_install_npA(HWND hwnd, HINSTANCE instance, LPCSTR cmd_line, int starg_arg);
#define usb_install_np usb_install_npA
void CALLBACK usb_install_np_rundll(HWND wnd, HINSTANCE instance,
LPSTR cmd_line, int cmd_show);
#endif
const struct usb_version *usb_get_version(void);
int usb_isochronous_setup_async(usb_dev_handle *dev, void **context,
unsigned char ep, int pktsize);
int usb_bulk_setup_async(usb_dev_handle *dev, void **context,
unsigned char ep);
int usb_interrupt_setup_async(usb_dev_handle *dev, void **context,
unsigned char ep);
int usb_submit_async(void *context, char *bytes, int size);
int usb_reap_async(void *context, int timeout);
int usb_reap_async_nocancel(void *context, int timeout);
int usb_cancel_async(void *context);
int usb_free_async(void **context);
#ifdef __cplusplus
}
#endif
#endif /* __LUSB0_USB__ */

166
external/libusb/libusb.vcxproj vendored Normal file
View File

@ -0,0 +1,166 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</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\descriptors.c" />
<ClCompile Include="src\error.c" />
<ClCompile Include="src\registry.c" />
<ClCompile Include="src\usb.c" />
<ClCompile Include="src\windows.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\lusb0_usb.h" />
<ClInclude Include="src\driver_api.h" />
<ClInclude Include="src\error.h" />
<ClInclude Include="src\libusb-win32_version.h" />
<ClInclude Include="src\registry.h" />
<ClInclude Include="src\usbi.h" />
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{22615ec5-9dbc-4538-9c01-2cd535b3810b}</ProjectGuid>
<RootNamespace>libusb</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
<ProjectName>libusb</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<DisableSpecificWarnings>4996</DisableSpecificWarnings>
<AdditionalIncludeDirectories>include</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<DisableSpecificWarnings>4996</DisableSpecificWarnings>
<AdditionalIncludeDirectories>include</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<DisableSpecificWarnings>4996</DisableSpecificWarnings>
<AdditionalIncludeDirectories>include</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<DisableSpecificWarnings>4996</DisableSpecificWarnings>
<AdditionalIncludeDirectories>include</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

18
external/libusb/libusb.vcxproj.filters vendored Normal file
View File

@ -0,0 +1,18 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<ClCompile Include="src\descriptors.c" />
<ClCompile Include="src\error.c" />
<ClCompile Include="src\registry.c" />
<ClCompile Include="src\usb.c" />
<ClCompile Include="src\windows.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\lusb0_usb.h" />
<ClInclude Include="src\driver_api.h" />
<ClInclude Include="src\error.h" />
<ClInclude Include="src\libusb-win32_version.h" />
<ClInclude Include="src\registry.h" />
<ClInclude Include="src\usbi.h" />
</ItemGroup>
</Project>

Some files were not shown because too many files have changed in this diff Show More