Move the plugin loader into a seperate repository

.gitmodules

@@ -1,4 +0,0 @@
-[submodule "loader/src/mocha"]
-	path = loader/src/mocha
-	url = https://github.com/Maschell/mocha
-	branch = sd_access

.travis.yml

@@ -8,13 +8,10 @@ env:
   global:
     - DEVKITPRO=/opt/devkitpro
     - DEVKITPPC=/opt/devkitpro/devkitPPC
-    - DEVKITARM=/opt/devkitpro/devkitARM
-    - PORTLIBREPOS=$HOME/portlibrepos
 
 cache:
   directories:
     - "$HOME/.local"
-    - "$PORTLIBREPOS"
     - "$DEVKITPRO"
 
 addons:
@@ -23,63 +20,14 @@ addons:
     - p7zip-full
 
 before_install:
-  - mkdir -p "${PORTLIBREPOS}"
   - mkdir -p "${DEVKITPRO}" 
-  - 7z x -y ./loader/libs/portlibs.zip -o${DEVKITPRO}  
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then wget https://github.com/devkitPro/pacman/releases/download/devkitpro-pacman-1.0.1/devkitpro-pacman.deb -O /tmp/devkitpro-pacman.deb; fi
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo dpkg -i /tmp/devkitpro-pacman.deb; fi
   - yes | sudo dkp-pacman -Syu devkitPPC --needed
-  - yes | sudo dkp-pacman -Syu devkitARM --needed
   - yes | sudo dkp-pacman -Syu general-tools --needed
 
-install:
-  - cd $PORTLIBREPOS
-  - ((git clone https://github.com/Maschell/dynamic_libs.git -b lib && (7z x -y ./dynamic_libs/libs/portlibs.zip -o${DEVKITPRO})) || (cd dynamic_libs && git pull))
-  - (git clone https://github.com/dimok789/libiosuhax.git || (cd libiosuhax && git pull))
-  - (git clone https://github.com/Maschell/libfat.git || (cd libfat && git pull))   
-  - (git clone https://github.com/Maschell/libntfs-wiiu.git || (cd libntfs-wiiu && git pull))   
-  - (git clone https://github.com/Maschell/libutils.git || (cd libutils && git pull))   
-  - ((git clone https://github.com/Maschell/libgui.git && (7z x -y ./libgui/libs/portlibs.zip -o${DEVKITPRO})) || (cd libgui && git pull))
-  - (cd dynamic_libs && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))
-  - (cd libiosuhax && make -j8 && make install) 
-  - (cd libfat && make wiiu-release && make wiiu-install)
-  - (cd libntfs-wiiu && make wiiu-install)
-  - (cd libutils && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))
-  - (cd libgui && ((make -j8 | grep -c "built ... ") && make install) || echo "no need for make install")
-
 before_script:
   - cd $TRAVIS_BUILD_DIR/
   
 script:
 - make && make install
-- (cd loader && make)
-
-before_deploy:
-- cd $TRAVIS_BUILD_DIR/
-- mkdir -p "wiiu/apps/wiiupluginloader"
-- commit="$(git rev-parse --short=7 HEAD)"
-- chmod +x gitrev.sh
-- versiontag="$(./gitrev.sh)"
-- (cd loader && make)
-- cp loader/meta/* wiiu/apps/wiiupluginloader
-- cp loader/wiiupluginloader.elf wiiu/apps/wiiupluginloader
-- zip -r WiiUPluginLoader_$versiontag.zip wiiu
-- git config --global user.email "builds@travis-ci.com"
-- git config --global user.name "Travis CI"
-- export GIT_TAG=WiiUPluginLoader-$versiontag
-- commitLog="$(git log -1 --pretty=%B)"
-- commitMessage="$(echo -e "-\n" && echo "WiiUPluginLoader nightly build. Not a stable release. Expect bugs!\n Only use the plugins with the bundled loaded as they may not work on others." && echo -e "\nCommitlog:\n")"
-- git tag $GIT_TAG -a -m "$commitMessage" -m "$commitLog"
-- git push --quiet https://$GITHUBKEY@github.com/Maschell/WiiUPluginSystem $GIT_TAG > /dev/null 2>&1
-
-deploy:
-  provider: releases
-  skip_cleanup: true
-  prerelease: true
-  api_key:
-    secure: "BdoeihqS+jQGq98cPyF22iCKx68stGSWa3t5ZotLcp8z9EYBODjGLOITbDxm1WsuVbC17dq4ESLogVhLSs1I3Kjfb+oESRTAh6X5tsRpxVWkvpiqk9pkMOQPLq1t1QDAKagm6BtEJ2lkMWD9a0G+Z8d7Fc6BE3TqqTf+DxVsX04ArxA9znLgOtJZxgIbSFhCPGU2PXueiWLcOzLL6u2Bp6FmPcGYOkM3K8BD45+9CjYqv+/SIv7ckJW8KI1CaNOIyrvLGv8VyQ18dAB9DRScB6kIAyInAStwQbvGbU6E+fKSJcdoqGuZIxMgBObo4KIN98pVckMsacXXuEk7BYc9lsdQkB9WhJWfJbmDoXF7Ur4pno/3rGSVD8RC96sCO7mrjKnlbACu4ybvVJvxSq6F4DRG6vpamh03AiiMHaQZG4kOC1CuOA26UG+k0kE9ErlkKa1IcfF/l0G+6UN2Ahx8UNXSu3WJR7IVj6jwVDWKnJnPwKcYjHq7Gn3UnIt+h/j1qN2KuYPZujnuaB/RCHNt0VmHylpmOeQPU4aWHq/KZHj3eSpecSXV9G7Xb9BjbK+cNft+vnmJBqQTyKJG1cWwty38bjJnAwsS249KdBWBowzZmeZoLPvdZaPrLBEfb2+p/ty2aMqKFj66ev/aQBSMkiOnIaVjFzl7UtCutm0FEAo="
-  file: WiiUPluginLoader_$versiontag.zip
-  on:
-    repo: Maschell/WiiUPluginSystem
-    tags: false
-    all_branches: true

README.MD

@@ -7,27 +7,16 @@ WARNING: THIS PROJECT HAS JUST STARTED AND IS FOR DEVS AND PEOPLE WHO WANT TO PL
 
 The Wii U Plugin allows you to load multiple plugins on your Wii U which enhance your experience. 
 For example you can mod your games, use USB controller, swap your gamepad and TV screen and much more.
-
-# Features
-
-The project is still in it's very early days, but it already has basic functions to play with.
-
-- The plugins will be loaded, even when you swap the running game.
-- Support for up to 32 plugins at the same time.
-- Each plugin can override up to 100 different existing system functions.
-- Multiple plugins can override the same system functions.
-- Plugins can register for certain hook (for example whenever an application was started)
-- Plugins inherit the SD/USB access from the loader. All plugins have global SD and USB (FAT32 only) access.
-- Plugins can be configured at run-time. Press L, DPAD down, and minus on the gamepad at the same time to open the configuration menu.
-
 # How to build
 
 A detailed instruction can be found in the Wiki:
 
 - [Installing the required libraries for creating plugins](https://maschell.github.io/WiiUPluginSystem/dev_required_libraries.html)  
-- [How to compile the loader](https://maschell.github.io/WiiUPluginSystem/dev_compile_loader.html)  
 
-### Plugins
+# Plugin loader
+To load the plugins, you need the WiiUPluginLoader, you can find it [here](https://github.com/Maschell/WiiUPluginLoader).
+
+# Plugins
 
 Last but not least you need to build the plugins that should be loaded.
 Plugins depend on the "WUPS library" installed in build step one, other dependencies are optional.
@@ -64,12 +53,6 @@ Settings made using the configuration menu will be saved to the SD Card and relo
 For logging (for example of the loader) you need to start the UdpDebugReader on a computer in the same network. 
 This has been created by @dimok789 and can be found in the tools folder.
 
-# Load a plugin via network
-While the loader is running, it's possible to load a single plugin via [wiiload](http://wiibrew.org/wiki/Wiiload).  
-When using this feature, this and all plugins in `sd:/wiiu/plugins/temp` will be loaded. The plugin will copied to the SDCard, this mean a SDCard is required.
-A windows executable can be found in `tools/wiiload.exe`  
-More information about wiiload and alternatives can be found here: http://wiibrew.org/wiki/Wiiload
-
 # Future and contribution
 On the Discord you can more information about open tasks and how to contribute: https://discord.gg/bZ2rep2
 

gitrev.sh

@@ -1,29 +0,0 @@
-#! /bin/bash
-#
-rev_new=$(git rev-parse --short=7 HEAD)
-version=$(cat ./loader/src/version.h 2>/dev/null | cut -d '"' -f2)
-
-
-rev_date=`date -u +%Y%m%d%H%M%S`
-
-    cat <<EOF > ./loader/meta/meta.xml
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<app version="1">
-  <name>Wii U Plugin Loader</name>
-  <coder>Maschell</coder>
-  <url>https://github.com/Maschell/WiiUPluginSystem</url>
-  <version>$version-nightly-$rev_new</version>
-  <release_date>$rev_date</release_date>
-  <short_description>Plugin loader for the Wii U</short_description>
-  <long_description></long_description>
-  <category>tool</category>
-
-</app>
-EOF
-
-    cat <<EOF > ./loader/src/version.h
-#define APP_VERSION "$version-nightly-$rev_new"
-EOF
-
-
-echo $version-nightly-$rev_new

installupdateportlibs.sh

@@ -1,21 +0,0 @@
-#! /bin/bash
-# 
-7z x -y ./loader/libs/portlibs.zip -o${DEVKITPRO}  
-mkdir portlib_repos
-cd portlib_repos
-((git clone https://github.com/Maschell/dynamic_libs.git -b lib && (7z x -y ./dynamic_libs/libs/portlibs.zip -o${DEVKITPRO})) || (cd dynamic_libs && git pull))
-(git clone https://github.com/dimok789/libiosuhax.git || (cd libiosuhax && git pull))
-(git clone https://github.com/Maschell/libfat.git || (cd libfat && git pull))   
-(git clone https://github.com/Maschell/libntfs-wiiu.git || (cd libntfs-wiiu && git pull))   
-(git clone https://github.com/Maschell/libutils.git || (cd libutils && git pull))   
-((git clone https://github.com/Maschell/libgui.git && (7z x -y ./libgui/libs/portlibs.zip -o${DEVKITPRO})) || (cd libgui && git pull))   
-(git clone https://github.com/Maschell/fs_wrapper.git || (cd fs_wrapper && git pull))  
-(git clone https://github.com/Maschell/controller_patcher.git || (cd controller_patcher && git pull))
-(cd dynamic_libs && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))
-(cd libiosuhax && make -j8 && make install) 
-(cd libfat && make wiiu-release && make wiiu-install)
-(cd libntfs-wiiu && make wiiu-install)
-(cd libutils && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))
-(cd libgui && ((make -j8 | grep -c "built ... ") && make install) || echo "no need for make install")
-(cd fs_wrapper && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))
-(cd controller_patcher && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))

loader/LICENSE

@@ -1,674 +0,0 @@
-                    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:
-
-    {project}  Copyright (C) {year}  {fullname}
-    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>.

loader/Makefile

@@ -1,270 +0,0 @@
-DO_LOGGING := 1
-
-#---------------------------------------------------------------------------------
-# Clear the implicit built in rules
-#---------------------------------------------------------------------------------
-.SUFFIXES:
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(DEVKITPPC)),)
-$(error "Please set DEVKITPPC in your environment. export DEVKITPPC=<path to>devkitPPC")
-endif
-ifeq ($(strip $(DEVKITPRO)),)
-$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>devkitPRO")
-endif
-
-export PATH			:=	$(DEVKITPPC)/bin:$(PORTLIBS)/bin:$(PATH):$(DEVKITPRO)/tools/bin
-export PORTLIBS		:=	$(DEVKITPRO)/portlibs/ppc
-
-PREFIX	:=	powerpc-eabi-
-
-export AS	:=	$(PREFIX)as
-export CC	:=	$(PREFIX)gcc
-export CXX	:=	$(PREFIX)g++
-export AR	:=	$(PREFIX)ar
-export OBJCOPY	:=	$(PREFIX)objcopy
-
-print-%  : ; @echo $* = $($*)
-
-#---------------------------------------------------------------------------------
-# TARGET is the name of the output
-# BUILD is the directory where object files & intermediate files will be placed
-# SOURCES is a list of directories containing source code
-# INCLUDES is a list of directories containing extra header files
-#---------------------------------------------------------------------------------
-TARGET    :=  wiiupluginloader
-BUILD     :=  build
-BUILD_DBG	:=  $(TARGET)_dbg
-SOURCES   :=  src/common \
-              src/custom/gui \
-              src/libelf \
-              src/menu/content \
-              src/menu \
-              src/mymemory \
-              src/mykernel \
-              src/myutils \
-              src/patcher \
-              src/plugin \
-              src/resources \
-              src/settings \
-              src/
-
-DATA		:=  data/images \
-                data/sounds \
-                data/fonts \
-
-INCLUDES  :=  src/libelf \
-              src/
-
-#---------------------------------------------------------------------------------
-# options for code generation
-#---------------------------------------------------------------------------------
-CFLAGS	:=  -std=gnu11 -mrvl -mcpu=750 -meabi -mhard-float -ffast-math \
-		    -O0 -D__wiiu__ -Wall -Wextra -Wno-unused-parameter -Wno-strict-aliasing -D_GNU_SOURCE $(INCLUDE)
-CXXFLAGS := -std=gnu++11 -mrvl -mcpu=750 -meabi -mhard-float -ffast-math \
-		    -O0 -D__wiiu__ -Wall -Wextra -Wno-unused-parameter -Wno-strict-aliasing -D_GNU_SOURCE $(INCLUDE)
-
-ifeq ($(DO_LOGGING), 1)
-   CFLAGS += -D__LOGGING__
-   CXXFLAGS += -D__LOGGING__
-endif
-
-ASFLAGS	:= -mregnames
-LDFLAGS	:= -nostartfiles -Wl,-Map,$(notdir $@).map,-wrap,malloc,-wrap,free,-wrap,memalign,-wrap,calloc,-wrap,realloc,-wrap,malloc_usable_size,-wrap,_malloc_r,-wrap,_free_r,-wrap,_realloc_r,-wrap,_calloc_r,-wrap,_memalign_r,-wrap,_malloc_usable_size_r,-wrap,valloc,-wrap,_valloc_r,-wrap,_pvalloc_r,--gc-sections
-
-#---------------------------------------------------------------------------------
-Q := @
-MAKEFLAGS += --no-print-directory
-#---------------------------------------------------------------------------------
-# any extra libraries we wish to link with the project
-#---------------------------------------------------------------------------------
-LIBS	:= -lgui -lm -lgcc -lfat -lntfs -liosuhax -lutils -ldynamiclibs  -lfreetype -lgd -lpng -ljpeg -lz  -lmad -lvorbisidec
-
-#---------------------------------------------------------------------------------
-# list of directories containing libraries, this must be the top level containing
-# include and lib
-#---------------------------------------------------------------------------------
-LIBDIRS	:=	$(CURDIR)	\
-			$(DEVKITPPC)/lib  \
-			$(DEVKITPRO)/wups
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(BUILD),$(notdir $(CURDIR)))
-#---------------------------------------------------------------------------------
-export PROJECTDIR := $(CURDIR)
-export OUTPUT	:=	$(CURDIR)/$(TARGETDIR)/$(TARGET)
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
-					$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-export DEPSDIR	:=	$(CURDIR)/$(BUILD)
-
-#---------------------------------------------------------------------------------
-# automatically build a list of object files for our project
-#---------------------------------------------------------------------------------
-FILELIST	:=	$(shell bash ./filelist.sh)
-LANGUAGES	:=	$(shell bash ./updatelang.sh)
-CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
-CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
-sFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
-SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.S)))
-BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
-TTFFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.ttf)))
-PNGFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.png)))
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-	export LD	:=	$(CC)
-else
-	export LD	:=	$(CXX)
-endif
-
-export OFILES	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) \
-					$(sFILES:.s=.o) $(SFILES:.S=.o) \
-					$(PNGFILES:.png=.png.o) $(addsuffix .o,$(BINFILES))
-
-#---------------------------------------------------------------------------------
-# build a list of include paths
-#---------------------------------------------------------------------------------
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-					$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-                    -I$(PORTLIBS)/include -I$(CURDIR)/$(BUILD) \
-					-I$(PORTLIBS)/include/libutils \
-                    -I$(PORTLIBS)/include/freetype2 -I$(PORTLIBS)/include/libgui
-
-
-#---------------------------------------------------------------------------------
-# build a list of library paths
-#---------------------------------------------------------------------------------
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib) \
-					-L$(PORTLIBS)/lib
-
-export OUTPUT	:=	$(CURDIR)/$(TARGET)
-.PHONY: $(BUILD) clean install
-
-#---------------------------------------------------------------------------------
-$(BUILD): $(CURDIR)/src/mocha/ios_kernel/ios_kernel.bin.h
-	@[ -d $@ ] || mkdir -p $@
-	@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
-
-$(CURDIR)/src/mocha/ios_kernel/ios_kernel.bin.h: $(CURDIR)/src/mocha/ios_usb/ios_usb.bin.h $(CURDIR)/src/mocha/ios_mcp/ios_mcp.bin.h $(CURDIR)/src/mocha/ios_fs/ios_fs.bin.h $(CURDIR)/src/mocha/ios_bsp/ios_bsp.bin.h $(CURDIR)/src/mocha/ios_acp/ios_acp.bin.h
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_kernel -f  $(CURDIR)/src/mocha/ios_kernel/Makefile
-
-$(CURDIR)/src/mocha/ios_usb/ios_usb.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_usb -f  $(CURDIR)/src/mocha/ios_usb/Makefile
-
-$(CURDIR)/src/mocha/ios_fs/ios_fs.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_fs -f  $(CURDIR)/src/mocha/ios_fs/Makefile
-
-$(CURDIR)/src/mocha/ios_bsp/ios_bsp.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_bsp -f  $(CURDIR)/src/mocha/ios_bsp/Makefile
-
-$(CURDIR)/src/mocha/ios_mcp/ios_mcp.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_mcp -f  $(CURDIR)/src/mocha/ios_mcp/Makefile
-
-$(CURDIR)/src/mocha/ios_acp/ios_acp.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_acp -f  $(CURDIR)/src/mocha/ios_acp/Makefile
-
-#---------------------------------------------------------------------------------
-clean:
-	@echo clean ...
-	@rm -fr $(BUILD) $(OUTPUT).elf $(OUTPUT).bin $(BUILD_DBG).elf
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_kernel -f  $(CURDIR)/src/mocha/ios_kernel/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_usb -f  $(CURDIR)/src/mocha/ios_usb/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_fs -f  $(CURDIR)/src/mocha/ios_fs/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_bsp -f  $(CURDIR)/src/mocha/ios_bsp/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_mcp -f  $(CURDIR)/src/mocha/ios_mcp/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_acp -f $(CURDIR)/src/mocha/ios_acp/Makefile clean
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-$(OUTPUT).elf:  $(OFILES)
-
-#---------------------------------------------------------------------------------
-# This rule links in binary data with the .jpg extension
-#---------------------------------------------------------------------------------
-%.elf: link.ld $(OFILES)
-	@echo "linking ... $(TARGET).elf"
-	$(Q)$(LD) -n -T $^ $(LDFLAGS) -o ../$(BUILD_DBG).elf  $(LIBPATHS) $(LIBS)
-	$(Q)$(OBJCOPY) -S -R .comment -R .gnu.attributes ../$(BUILD_DBG).elf $@
-
-#---------------------------------------------------------------------------------
-%.a:
-#---------------------------------------------------------------------------------
-	@echo $(notdir $@)
-	@rm -f $@
-	@$(AR) -rc $@ $^
-
-#---------------------------------------------------------------------------------
-%.o: %.cpp
-	@echo $(notdir $<)
-	@$(CXX) -MMD -MP -MF $(DEPSDIR)/$*.d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER)
-
-#---------------------------------------------------------------------------------
-%.o: %.c
-	@echo $(notdir $<)
-	@$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d $(CFLAGS) -c $< -o $@ $(ERROR_FILTER)
-
-#---------------------------------------------------------------------------------
-%.o: %.S
-	@echo $(notdir $<)
-	@$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d -x assembler-with-cpp $(ASFLAGS) -c $< -o $@ $(ERROR_FILTER)
-	
-#---------------------------------------------------------------------------------
-%.o: %.s
-	@echo $(notdir $<)
-	@$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d -x assembler-with-cpp $(ASFLAGS) -c $< -o $@ $(ERROR_FILTER)
-
-#---------------------------------------------------------------------------------
-%.png.o : %.png
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.jpg.o : %.jpg
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.ttf.o : %.ttf
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.bin.o : %.bin
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.wav.o : %.wav
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.mp3.o : %.mp3
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.ogg.o : %.ogg
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.tga.o : %.tga
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------

loader/README.md

@@ -1,9 +0,0 @@
-# Wii U Plugin Loader [![Build Status](https://api.travis-ci.org/Maschell/WiiUPluginSystem.svg?branch=master)](https://travis-ci.org/Maschell/WiiUPluginSystem)
-
-## Building
-
-For building you need: 
-- [dynamic_libs](https://github.com/Maschell/dynamic_libs/tree/lib) for access to the functions.
-- [libutils](https://github.com/Maschell/libutils) for common functions.
-
-Install them (in this order) according to their README's. Don't forget the dependencies of the libs itself.

loader/filelist.sh

@@ -1,71 +0,0 @@
-#! /bin/bash
-#
-# Automatic resource file list generation
-# Created by Dimok
-
-outFile="./src/resources/filelist.cpp"
-count_old=$(cat $outFile 2>/dev/null | tr -d '\n\n' | sed 's/[^0-9]*\([0-9]*\).*/\1/')
-
-count=0
-if [[ $OSTYPE == darwin* ]];
-then
-
-for i in $(gfind ./data/images/ ./data/sounds/ ./data/fonts/ -maxdepth 1 -type f  \( ! -printf "%f\n" \) | sort -f)
-do
-	files[count]=$i
-	count=$((count+1))
-done
-
-else
-
-for i in $(find ./data/images/ ./data/sounds/ ./data/fonts/ -maxdepth 1 -type f  \( ! -printf "%f\n" \) | sort -f)
-do
-	files[count]=$i
-	count=$((count+1))
-done
-
-fi
-
-if [ "$count_old" != "$count" ] || [ ! -f $outFile ]
-then
-
-echo "Generating filelist.c for $count files." >&2
-cat <<EOF > $outFile
-/****************************************************************************
- * Resource files.
- * This file is generated automatically.
- * Includes $count files.
- *
- * NOTE:
- * Any manual modification of this file will be overwriten by the generation.
- *****************************************************************************/
-#include <resources/filelist.h>
-#include <stdint.h>
-
-EOF
-
-for i in ${files[@]}
-do
-	filename=${i%.*}
-	extension=${i##*.}
-	echo 'extern const uint8_t '$filename'_'$extension'[];' >> $outFile
-	echo 'extern const uint32_t '$filename'_'$extension'_size;' >> $outFile
-	echo '' >> $outFile
-done
-
-echo 'static ResourceFile ResourceList[] =' >> $outFile
-echo '{' >> $outFile
-
-for i in ${files[@]}
-do
-	filename=${i%.*}
-	extension=${i##*.}
-	echo -e '\t{"'$i'", '$filename'_'$extension', '$filename'_'$extension'_size, NULL, 0},' >> $outFile
-done
-
-echo -e '\t{NULL, NULL, 0, NULL, 0}' >> $outFile
-echo '};' >> $outFile
-echo '' >> $outFile
-echo 'ResourceFile * getResourceList(){ return ResourceList; }' >> $outFile
-echo '' >> $outFile
-fi

loader/languages/english.lang

@@ -1,54 +0,0 @@
-msgid "Press HOME to return."
-msgstr ""
-
-msgid "Language"
-msgstr ""
-
-msgid "Press B to return to the plugin overview."
-msgstr ""
-
-# English translations for Wii U Plugin System loader
-# This file is distributed under the same license as the PACKAGE package.
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSION\n"
-"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2017-05-08 17:13+0200\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
-"Language: \n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-msgid "Press B to return to the plugin overview, HOME to return to the running application."
-msgstr ""
-
-#: src/menu/content/ContentHome.cpp:24
-msgid "Welcome to the Wii U plugin loader"
-msgstr ""
-
-#: src/menu/content/ContentHome.cpp:33
-msgid "Exit to HBL  "
-msgstr ""
-
-#: src/menu/content/ContentHome.cpp:36
-msgid "Apply Patches"
-msgstr ""
-
-#: src/myutils/ConfigUtils.cpp:113
-msgid "Press HOME to return to the running application."
-msgstr ""
-
-#: src/myutils/ConfigUtils.cpp:114
-msgid "Configurable running plugins:"
-msgstr ""
-
-#: src/myutils/ConfigUtils.cpp:118
-msgid "No configurable running plugins found."
-msgstr ""
-
-#: src/myutils/ConfigUtils.cpp:243
-msgid "B = plugin overview, HOME  = back to running application."
-msgstr ""

loader/meta/meta.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<app version="1">
-  <name>Wii U Plugin Loader</name>
-  <coder>Maschell</coder>
-  <url>https://github.com/Maschell/WiiUPluginSystem</url>
-  <version>pre-alpha</version>
-  <release_date>201802103162900</release_date>
-  <short_description>Plugin loader for the Wii U</short_description>
-  <long_description>
-  </long_description>
-  <category>tool</category>
-
-</app>

loader/src/Application.cpp

@@ -1,255 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2015 Dimok
- * Modified by Maschell, 2018 for Wii U Plugin System loader
- *
- * 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/>.
- ****************************************************************************/
-#include "Application.h"
-#include "common/common.h"
-#include <dynamic_libs/os_functions.h>
-#include <gui/FreeTypeGX.h>
-#include <gui/VPadController.h>
-#include <gui/WPadController.h>
-#include "resources/Resources.h"
-#include <sounds/SoundHandler.hpp>
-#include <utils/logger.h>
-#include "settings/CSettings.h"
-#include "myutils/TcpReceiver.h"
-#include "mymemory/memory_mapping.h"
-
-Application *Application::applicationInstance = NULL;
-bool Application::exitApplication = false;
-
-Application::Application()
-    : CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff, 0, 0x20000)
-    , bgMusic(NULL)
-    , video(NULL)
-    , mainWindow(NULL)
-    , exitCode(EXIT_RELAUNCH_ON_LOAD) {
-    controller[0] = new VPadController(GuiTrigger::CHANNEL_1);
-    controller[1] = new WPadController(GuiTrigger::CHANNEL_2);
-    controller[2] = new WPadController(GuiTrigger::CHANNEL_3);
-    controller[3] = new WPadController(GuiTrigger::CHANNEL_4);
-    controller[4] = new WPadController(GuiTrigger::CHANNEL_5);
-
-    CSettings::instance()->Load();
-
-    //! create bgMusic
-    bgMusic = new GuiSound(Resources::GetFile("bgMusic.mp3"), Resources::GetFileSize("bgMusic.mp3"));
-
-    //! load language
-    loadLanguageFromConfig();
-
-    exitApplication = false;
-}
-
-Application::~Application() {
-    DEBUG_FUNCTION_LINE("Destroy music\n");
-    delete bgMusic;
-
-    DEBUG_FUNCTION_LINE("Destroy controller\n");
-
-    for(int32_t i = 0; i < 5; i++)
-        delete controller[i];
-
-    //We may have to handle Asyncdelete in the Destructors.
-    DEBUG_FUNCTION_LINE("Destroy async deleter\n");
-    do {
-        DEBUG_FUNCTION_LINE("Triggering AsyncDeleter\n");
-        AsyncDeleter::triggerDeleteProcess();
-        while(!AsyncDeleter::realListEmpty()) {
-            DEBUG_FUNCTION_LINE("Waiting...\n");
-            os_usleep(1000);
-        }
-    } while(!AsyncDeleter::deleteListEmpty());
-    AsyncDeleter::destroyInstance();
-
-    DEBUG_FUNCTION_LINE("Clear resources\n");
-    Resources::Clear();
-
-    DEBUG_FUNCTION_LINE("Stop sound handler\n");
-    SoundHandler::DestroyInstance();
-}
-
-int32_t Application::exec() {
-    //! start main GX2 thread
-    resumeThread();
-    //! now wait for thread to finish
-    shutdownThread();
-
-    return exitCode;
-}
-
-void Application::reloadUI() {
-    reloadUIflag = true;
-}
-void Application::fadeOut() {
-    GuiImage fadeOut(video->getTvWidth(), video->getTvHeight(), (GX2Color) {
-        0, 0, 0, 255
-    });
-
-    for(int32_t i = 0; i < 255; i += 10) {
-        if(i > 255)
-            i = 255;
-
-        fadeOut.setAlpha(i / 255.0f);
-
-        //! start rendering DRC
-        video->prepareDrcRendering();
-        mainWindow->drawDrc(video);
-
-        GX2SetDepthOnlyControl(GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_ALWAYS);
-        fadeOut.draw(video);
-        GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_LEQUAL);
-
-        video->drcDrawDone();
-
-        //! start rendering TV
-        video->prepareTvRendering();
-
-        mainWindow->drawTv(video);
-
-        GX2SetDepthOnlyControl(GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_ALWAYS);
-        fadeOut.draw(video);
-        GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_LEQUAL);
-
-        video->tvDrawDone();
-
-        //! as last point update the effects as it can drop elements
-        mainWindow->updateEffects();
-
-        video->waitForVSync();
-    }
-
-    //! one last cleared black screen
-    video->prepareDrcRendering();
-    video->drcDrawDone();
-    video->prepareTvRendering();
-    video->tvDrawDone();
-    video->waitForVSync();
-    video->tvEnable(false);
-    video->drcEnable(false);
-}
-
-void Application::executeThread(void) {
-    DEBUG_FUNCTION_LINE("Initialize video\n");
-    video = new CVideo(GX2_TV_SCAN_MODE_720P, GX2_DRC_SINGLE);
-
-    DEBUG_FUNCTION_LINE("Video size %i x %i\n", video->getTvWidth(), video->getTvHeight());
-
-    //! setup default Font
-    DEBUG_FUNCTION_LINE("Initialize main font system\n");
-    FreeTypeGX *fontSystem = new FreeTypeGX(Resources::GetFile("font.ttf"), Resources::GetFileSize("font.ttf"), true);
-    GuiText::setPresetFont(fontSystem);
-
-    reloadUIflag = true;
-    if(bgMusic != NULL) {
-        bgMusic->SetLoop(true);
-        bgMusic->SetVolume(50);
-        bgMusic->Stop(); //CHANG MEEEEEEEEEEEEEEEEEEE
-    }
-
-
-    while(reloadUIflag) {
-        reloadUIflag = false;
-        exitCode = EXIT_RELAUNCH_ON_LOAD;
-        DEBUG_FUNCTION_LINE("Initialize the language\n");
-        loadLanguageFromConfig();
-        DEBUG_FUNCTION_LINE("Initialize main window\n");
-        mainWindow = MainWindow::getInstance(video->getTvWidth(), video->getTvHeight());
-
-        exitApplication = false;
-        //! main GX2 loop (60 Hz cycle with max priority on core 1)
-
-        DEBUG_FUNCTION_LINE("Starting TcpReceiver\n");
-        TcpReceiver pluginReceiver(4299);
-        DEBUG_FUNCTION_LINE("Entering main loop\n");
-        while(!exitApplication && !reloadUIflag) {
-            //! Read out inputs
-            for(int32_t i = 0; i < 5; i++) {
-                if(controller[i]->update(video->getTvWidth(), video->getTvHeight()) == false)
-                    continue;
-
-                if(controller[i]->data.buttons_d & VPAD_BUTTON_PLUS) {
-                    exitCode = APPLICATION_CLOSE_APPLY;
-                    if(linkPluginsCallback != NULL) {
-                        bool result = linkPluginsCallback();
-                        if(!result) {
-                            // On linking errors return to the HBL.
-                            #warning TODO: proper error handling when linking fails.
-                            exitCode = APPLICATION_CLOSE_MIIMAKER;
-                        }
-                    }
-                    exitApplication = true;
-                }
-
-                if(controller[i]->data.buttons_d & VPAD_BUTTON_MINUS) {
-                    exitCode = APPLICATION_CLOSE_APPLY_MEMORY;
-                    exitApplication = true;
-                }
-
-                if(controller[i]->data.buttons_d & VPAD_BUTTON_HOME) {
-                    exitCode = APPLICATION_CLOSE_MIIMAKER;
-                    exitApplication = true;
-                }
-
-                //! update controller states
-                mainWindow->update(controller[i]);
-            }
-            mainWindow->process();
-
-            //! start rendering DRC
-            video->prepareDrcRendering();
-            mainWindow->drawDrc(video);
-            video->drcDrawDone();
-
-            //! start rendering TV
-            video->prepareTvRendering();
-            mainWindow->drawTv(video);
-            video->tvDrawDone();
-
-            //! enable screen after first frame render
-            if(video->getFrameCount() == 0) {
-                video->tvEnable(true);
-                video->drcEnable(true);
-            }
-
-
-            //! as last point update the effects as it can drop elements
-            mainWindow->updateEffects();
-
-            video->waitForVSync();
-
-            //! transfer elements to real delete list here after all processes are finished
-            //! the elements are transfered to another list to delete the elements in a separate thread
-            //! and avoid blocking the GUI thread
-            AsyncDeleter::triggerDeleteProcess();
-        }
-        DEBUG_FUNCTION_LINE("Fading out\n");
-        fadeOut();
-        DEBUG_FUNCTION_LINE("Destroying the MainWindow\n");
-        MainWindow::destroyInstance();
-    }
-    DEBUG_FUNCTION_LINE("Delete fontSystem\n");
-    delete fontSystem;
-    DEBUG_FUNCTION_LINE("Delete video\n");
-    delete video;
-}
-
-void Application::loadLanguageFromConfig() {
-    if(!CSettings::getValueAsString(CSettings::AppLanguage).empty()) {
-        std::string languagePath = std::string(DEFAULT_LANG_PATH) + "/" + CSettings::getValueAsString(CSettings::AppLanguage) + std::string(LANGUAGE_FILE_EXT);
-        gettextLoadLanguage(languagePath.c_str());
-    }
-}

loader/src/Application.h

@@ -1,92 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2015 Dimok
- * Modified by Maschell, 2018 for Wii U Plugin System loader
- *
- * 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/>.
- ****************************************************************************/
-#ifndef _APPLICATION_H
-#define _APPLICATION_H
-
-#include "menu/MainWindow.h"
-#include <functional>
-#include <video/CVideo.h>
-#include <system/CThread.h>
-#include <language/gettext.h>
-
-#define APPLICATION_CLOSE_APPLY             1
-#define APPLICATION_CLOSE_APPLY_MEMORY      3
-#define APPLICATION_CLOSE_MIIMAKER          2
-
-class Application : public CThread {
-public:
-    static Application * instance() {
-        if(!applicationInstance)
-            applicationInstance = new Application();
-        return applicationInstance;
-    }
-    static void destroyInstance() {
-        if(applicationInstance) {
-            delete applicationInstance;
-            applicationInstance = NULL;
-        }
-    }
-
-    CVideo *getVideo(void) const {
-        return video;
-    }
-    MainWindow *getMainWindow(void) const {
-        return mainWindow;
-    }
-
-    GuiSound *getBgMusic(void) const {
-        return bgMusic;
-    }
-
-    int32_t exec(void);
-    void fadeOut(void);
-
-    void reloadUI(void);
-
-    void quit(int32_t code) {
-        exitCode = code;
-        exitApplication = true;
-    }
-
-    void setLinkPluginsCallback(std::function<bool(void)> fun) {
-        linkPluginsCallback = fun;
-        DEBUG_FUNCTION_LINE("Set callback to %08X \n",linkPluginsCallback);
-    }
-private:
-    Application();
-
-    virtual ~Application();
-
-    static Application *applicationInstance;
-    static bool exitApplication;
-
-    void executeThread(void);
-
-    void loadLanguageFromConfig();
-
-    bool reloadUIflag = false;
-
-    GuiSound *bgMusic;
-    CVideo *video;
-    MainWindow *mainWindow;
-    GuiController *controller[5];
-    int32_t exitCode;
-    std::function<bool(void)> linkPluginsCallback = NULL;
-};
-
-#endif //_APPLICATION_H

loader/src/common/common.h

@@ -1,54 +0,0 @@
-#ifndef COMMON_H
-#define    COMMON_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <dynamic_libs/os_defs.h>
-
-#define CAFE_OS_SD_PATH             "/vol/external01"
-#define WIIU_PATH                   "/wiiu"
-#define SD_PATH                     "sd:"
-#define USB_PATH                    "usb:"
-#define DEFAULT_NAME_PACKAGE        "DEFAULT"
-#define NAME_PREFIX_SD              "sd: "
-#define NAME_PREFIX_USB             "usb:"
-
-#define ELF_DATA_ADDR               (*(volatile uint32_t*)(MEM_BASE + 0x1300 + 0x00))
-#define ELF_DATA_SIZE               (*(volatile uint32_t*)(MEM_BASE + 0x1300 + 0x04))
-#define MAIN_ENTRY_ADDR             (*(volatile uint32_t*)(MEM_BASE + 0x1400 + 0x00))
-
-#ifndef EXIT_SUCCESS
-#define EXIT_SUCCESS                0
-#endif
-#define EXIT_HBL_EXIT               0xFFFFFFFE
-#define EXIT_RELAUNCH_ON_LOAD       0xFFFFFFFD
-
-#define DEFAULT_WUPSLOADER_PATH     SD_PATH WIIU_PATH "/apps/wiiupluginsystem"
-#define DEFAULT_LANG_PATH           DEFAULT_WUPSLOADER_PATH "/languages"
-#define LANGUAGE_FILE_EXT           ".lang"
-#define PLUGIN_CONFIG_FILE_EXT      ".cfg"
-#define PLUGIN_FILE_EXT             ".mod"
-
-#define WUPS_PLUGIN_PATH            SD_PATH WIIU_PATH "/plugins"
-#define WUPS_TEMP_PLUGIN_PATH       SD_PATH WIIU_PATH "/plugins/temp"
-#define WUPS_TEMP_PLUGIN_FILE       WUPS_TEMP_PLUGIN_PATH "/temp" PLUGIN_FILE_EXT
-
-#define WUPS_SDUSB_MOUNTED_NONE     0
-#define WUPS_SDUSB_MOUNTED_FAKE          (1<<0)
-#define WUPS_SDUSB_MOUNTED_OS_SD         (1<<1)
-#define WUPS_SDUSB_LIBIOSU_LOADED        (1<<2)
-#define WUPS_SD_MOUNTED_LIBFAT           (1<<3)
-#define WUPS_USB_MOUNTED_LIBFAT          (1<<4)
-#define WUPS_USB_MOUNTED_LIBNTFS         (1<<5)
-
-#define WUPS_SD_MOUNTED                  (WUPS_SDUSB_MOUNTED_OS_SD | WUPS_SD_MOUNTED_LIBFAT)
-#define WUPS_USB_MOUNTED                 (WUPS_USB_MOUNTED_LIBFAT)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif    /* COMMON_H */
-

loader/src/common/retain_vars.cpp

@@ -1,18 +0,0 @@
-#include "retain_vars.h"
-#include "myutils/overlay_helper.h"
-replacement_data_t gbl_replacement_data __attribute__((section(".data")));
-dyn_linking_relocation_data_t gbl_dyn_linking_data __attribute__((section(".data")));
-
-uint8_t gAppStatus __attribute__((section(".data"))) = 0;
-uint64_t gGameTitleID __attribute__((section(".data"))) = 0;
-volatile uint8_t gSDInitDone __attribute__((section(".data"))) = 0;
-
-void * ntfs_mounts __attribute__((section(".data"))) = NULL;
-int32_t ntfs_mount_count __attribute__((section(".data"))) = 0;
-
-struct buffer_store drc_store __attribute__((section(".data")));
-struct buffer_store tv_store __attribute__((section(".data")));
-
-
-char gbl_common_data[0x20000] __attribute__((section(".data")));
-char * gbl_common_data_ptr __attribute__((section(".data"))) = gbl_common_data;

loader/src/common/retain_vars.h

@@ -1,20 +0,0 @@
-#ifndef RETAINS_VARS_H_
-#define RETAINS_VARS_H_
-#include "patcher/function_patcher.h"
-#include "plugin/dynamic_linking_defines.h"
-
-extern replacement_data_t gbl_replacement_data;
-extern dyn_linking_relocation_data_t gbl_dyn_linking_data;
-
-extern uint8_t gAppStatus;
-extern uint64_t gGameTitleID;
-extern volatile uint8_t gSDInitDone;
-
-
-extern void * ntfs_mounts;
-extern int32_t ntfs_mount_count;
-
-extern struct buffer_store drc_store;
-extern struct buffer_store tv_store;
-
-#endif // RETAINS_VARS_H_

loader/src/custom/gui/DefaultGuiSelectBox.cpp

@@ -1,52 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2017 Maschell
- *
- * 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/>.
- ****************************************************************************/
-#include "DefaultGuiSelectBox.h"
-/**
- * Constructor for the DefaultGuiSelectBox class.
- */
-
-DefaultGuiSelectBox::DefaultGuiSelectBox(std::string caption, GuiFrame *parent)
- : GuiSelectBox(NULL,caption)
- ,topBackgroundImg_imgdata(Resources::GetImageData("gameSettingsButton.png"))
- ,topBackgroundImg_img(topBackgroundImg_imgdata)
- ,topHighlightedImg_imgdata(Resources::GetImageData("gameSettingsButtonSelected.png"))
- ,topHighlightedImg_img(topHighlightedImg_imgdata)
- ,valueImageData(Resources::GetImageData("gameSettingsButtonEx.png"))
- ,valueSelectedImageData(Resources::GetImageData("gameSettingsButtonExSelected.png"))
- ,valueHighlightedImageData(Resources::GetImageData("gameSettingsButtonExHighlighted.png"))
- ,buttonClickSound(Resources::GetSound("settings_click_2.mp3"))
-{
-    setSize(topBackgroundImg_img.getWidth(),topBackgroundImg_img.getHeight());
-    this->setImageTopBackground(&topBackgroundImg_img);
-    this->setImageTopHighlighted(&topHighlightedImg_img);
-    this->setImageValueBackground(valueImageData);
-    this->setImageValueHighlighted(valueHighlightedImageData);
-    this->setImageValueSelected(valueSelectedImageData);
-    this->setSoundClick(buttonClickSound);
-}
-/**
- * Destructor for the DefaultGuiSelectBox class.
- */
-DefaultGuiSelectBox::~DefaultGuiSelectBox()
-{
-    Resources::RemoveImageData(topBackgroundImg_imgdata);
-    Resources::RemoveImageData(topHighlightedImg_imgdata);
-    Resources::RemoveImageData(valueImageData);
-    Resources::RemoveImageData(valueSelectedImageData);
-    Resources::RemoveImageData(valueHighlightedImageData);
-    Resources::RemoveSound(buttonClickSound);
-}

loader/src/custom/gui/DefaultGuiSelectBox.h

@@ -1,45 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2017 Maschell
- *
- * 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/>.
- ****************************************************************************/
-#ifndef DEFAULT_GUI_SELECTBOX_H_
-#define DEFAULT_GUI_SELECTBOX_H_
-
-#include <gui/GuiSelectBox.h>
-
-//!A simple select box with default values.
-class DefaultGuiSelectBox : public GuiSelectBox{
-	public:
-		//!Constructor
-		//!\param checked Checked
-		DefaultGuiSelectBox(std::string caption, GuiFrame *parent = NULL);
-		//!Destructor
-		virtual ~DefaultGuiSelectBox();
-
-	protected:
-        GuiImageData * topBackgroundImg_imgdata;
-        GuiImage topBackgroundImg_img;
-
-        GuiImageData * topHighlightedImg_imgdata;
-        GuiImage topHighlightedImg_img;
-
-        GuiImageData * valueImageData;
-        GuiImageData * valueSelectedImageData;
-        GuiImageData * valueHighlightedImageData;
-
-        GuiSound * buttonClickSound;
-};
-
-#endif

loader/src/custom/gui/DefaultGuiSwitch.cpp

@@ -1,48 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2017 Maschell
- *
- * 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/>.
- ****************************************************************************/
-#include "DefaultGuiSwitch.h"
-/**
- * Constructor for the DefaultGuiSwitch class.
- */
-
-DefaultGuiSwitch::DefaultGuiSwitch(bool checked)
- : GuiSwitch(NULL,checked)
- ,switchbase_imgdata(Resources::GetImageData("switchIconBase.png"))
- ,switchbase_img(switchbase_imgdata)
- ,switchbase_highlighted_imgdata(Resources::GetImageData("switchIconBaseHighlighted.png"))
- ,switchbase_highlighted_img(switchbase_highlighted_imgdata)
- ,switchOn_imgdata(Resources::GetImageData("switchIconOn.png"))
- ,switchOn_img(switchOn_imgdata)
- ,switchOff_imgdata(Resources::GetImageData("switchIconOff.png"))
- ,switchOff_img(switchOff_imgdata)
-{
-    setSize(switchbase_img.getWidth(),switchbase_img.getHeight());
-    this->setImageBackground(&switchbase_img);
-    this->setImageHighlighted(&switchbase_highlighted_img);
-    this->setImageOn(&switchOn_img);
-    this->setImageOff(&switchOff_img);
-}
-/**
- * Destructor for the DefaultGuiSwitch class.
- */
-DefaultGuiSwitch::~DefaultGuiSwitch()
-{
-    Resources::RemoveImageData(switchbase_imgdata);
-    Resources::RemoveImageData(switchbase_highlighted_imgdata);
-    Resources::RemoveImageData(switchOn_imgdata);
-    Resources::RemoveImageData(switchOff_imgdata);
-}

loader/src/custom/gui/DefaultGuiSwitch.h

@@ -1,45 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2017 Maschell
- *
- * 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/>.
- ****************************************************************************/
-#ifndef DEFAULT_GUI_SWTICH_H_
-#define DEFAULT_GUI_SWTICH_H_
-
-#include <gui/GuiSwitch.h>
-
-//!A simple switch
-class DefaultGuiSwitch : public GuiSwitch{
-	public:
-		//!Constructor
-		//!\param checked Checked
-		DefaultGuiSwitch(bool checked);
-		//!Destructor
-		virtual ~DefaultGuiSwitch();
-
-	protected:
-        GuiImageData * switchbase_imgdata = NULL;
-        GuiImage switchbase_img;
-
-        GuiImageData * switchbase_highlighted_imgdata = NULL;
-        GuiImage switchbase_highlighted_img;
-
-        GuiImageData * switchOn_imgdata = NULL;
-        GuiImage switchOn_img;
-
-        GuiImageData * switchOff_imgdata = NULL;
-        GuiImage switchOff_img;
-};
-
-#endif

loader/src/entry.c

@@ -1,9 +0,0 @@
-#include <string.h>
-#include "main.h"
-
-int32_t __entry_menu(int32_t argc, char **argv) {
-    //! *******************************************************************
-    //! *                 Jump to our application                    *
-    //! *******************************************************************
-    return Menu_Main(argc,argv);
-}

loader/src/libelf/_elftc.h

@@ -1,430 +0,0 @@
-/*-
- * Copyright (c) 2009 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- *
- * $Id: _elftc.h 2495 2012-04-23 05:31:56Z jkoshy $
- */
-
-/**
- ** Miscellanous definitions needed by multiple components.
- **/
-
-#ifndef	_ELFTC_H
-#define	_ELFTC_H
-
-#ifndef	NULL
-#define NULL 	((void *) 0)
-#endif
-
-#ifndef	offsetof
-#define	offsetof(T, M)		((int) &((T*) 0) -> M)
-#endif
-
-/* --QUEUE-MACROS-- [[ */
-
-/*
- * Supply macros missing from <sys/queue.h>
- */
-
-/*
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
- */
-
-#ifndef	STAILQ_CONCAT
-#define	STAILQ_CONCAT(head1, head2) do {			\
-	if (!STAILQ_EMPTY((head2))) {				\
-		*(head1)->stqh_last = (head2)->stqh_first;	\
-		(head1)->stqh_last = (head2)->stqh_last;	\
-		STAILQ_INIT((head2));				\
-	}							\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_EMPTY
-#define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
-#endif
-
-#ifndef	STAILQ_ENTRY
-#define	STAILQ_ENTRY(type)					\
-struct {							\
-	struct type *stqe_next;	/* next element */		\
-}
-#endif
-
-#ifndef	STAILQ_FIRST
-#define	STAILQ_FIRST(head)	((head)->stqh_first)
-#endif
-
-#ifndef	STAILQ_HEAD
-#define	STAILQ_HEAD(name, type)					\
-struct name {							\
-	struct type *stqh_first; /* first element */		\
-	struct type **stqh_last; /* addr of last next element */ \
-}
-#endif
-
-#ifndef	STAILQ_HEAD_INITIALIZER
-#define	STAILQ_HEAD_INITIALIZER(head)				\
-	{ NULL, &(head).stqh_first }
-#endif
-
-#ifndef	STAILQ_FOREACH
-#define	STAILQ_FOREACH(var, head, field)			\
-	for ((var) = ((head)->stqh_first);			\
-		(var);						\
-		(var) = ((var)->field.stqe_next))
-#endif
-
-#ifndef	STAILQ_FOREACH_SAFE
-#define STAILQ_FOREACH_SAFE(var, head, field, tvar)		\
-       for ((var) = STAILQ_FIRST((head));			\
-	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);	\
-	    (var) = (tvar))
-#endif
-
-#ifndef	STAILQ_INIT
-#define	STAILQ_INIT(head) do {					\
-	(head)->stqh_first = NULL;				\
-	(head)->stqh_last = &(head)->stqh_first;		\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_INSERT_HEAD
-#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
-	if (((elm)->field.stqe_next = (head)->stqh_first) == NULL)	\
-		(head)->stqh_last = &(elm)->field.stqe_next;		\
-	(head)->stqh_first = (elm);					\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_INSERT_TAIL
-#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
-	(elm)->field.stqe_next = NULL;					\
-	*(head)->stqh_last = (elm);					\
-	(head)->stqh_last = &(elm)->field.stqe_next;			\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_INSERT_AFTER
-#define	STAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
-		(head)->stqh_last = &(elm)->field.stqe_next;		\
-	(listelm)->field.stqe_next = (elm);				\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_LAST
-#define STAILQ_LAST(head, type, field)					\
-	(STAILQ_EMPTY((head)) ?					\
-	    NULL : ((struct type *)(void *)				\
-	    ((char *)((head)->stqh_last) - offsetof(struct type, field))))
-#endif
-
-#ifndef	STAILQ_NEXT
-#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
-#endif
-
-#ifndef	STAILQ_REMOVE
-#define	STAILQ_REMOVE(head, elm, type, field) do {			\
-	if ((head)->stqh_first == (elm)) {				\
-		STAILQ_REMOVE_HEAD((head), field);			\
-	} else {							\
-		struct type *curelm = (head)->stqh_first;		\
-		while (curelm->field.stqe_next != (elm))		\
-			curelm = curelm->field.stqe_next;		\
-		if ((curelm->field.stqe_next =				\
-			curelm->field.stqe_next->field.stqe_next) == NULL) \
-			    (head)->stqh_last = &(curelm)->field.stqe_next; \
-	}								\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_REMOVE_HEAD
-#define	STAILQ_REMOVE_HEAD(head, field) do {				\
-	if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == \
-	    NULL)							\
-		(head)->stqh_last = &(head)->stqh_first;		\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	TAILQ_FOREACH_SAFE
-#define TAILQ_FOREACH_SAFE(var, head, field, tvar)                      \
-	for ((var) = TAILQ_FIRST((head));                               \
-	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);            \
-	    (var) = (tvar))
-#endif
-
-/* ]] --QUEUE-MACROS-- */
-
-/*
- * VCS Ids.
- */
-
-#ifndef	ELFTC_VCSID
-
-#if defined(GEKKO)
-#define ELFTC_VCSID(ID) /**/
-#endif
-
-#if defined(__wiiu__)
-#define ELFTC_VCSID(ID) /**/
-#endif
-
-#if defined(__DragonFly__)
-#define	ELFTC_VCSID(ID)		__RCSID(ID)
-#endif
-
-#if defined(__FreeBSD__)
-#define	ELFTC_VCSID(ID)		__FBSDID(ID)
-#endif
-
-#if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
-#if defined(__GNUC__)
-#define	ELFTC_VCSID(ID)		__asm__(".ident\t\"" ID "\"")
-#else
-#define	ELFTC_VCSID(ID)		/**/
-#endif
-#endif
-
-#if defined(__minix)
-#if defined(__GNUC__)
-#define	ELFTC_VCSID(ID)		__asm__(".ident\t\"" ID "\"")
-#else
-#define	ELFTC_VCSID(ID)		/**/
-#endif	/* __GNU__ */
-#endif
-
-#if defined(__NetBSD__)
-#define	ELFTC_VCSID(ID)		__RCSID(ID)
-#endif
-
-#if defined(__OpenBSD__)
-#if defined(__GNUC__)
-#define	ELFTC_VCSID(ID)		__asm__(".ident\t\"" ID "\"")
-#else
-#define	ELFTC_VCSID(ID)		/**/
-#endif	/* __GNUC__ */
-#endif
-
-#endif	/* ELFTC_VCSID */
-
-/*
- * Provide an equivalent for getprogname(3).
- */
-
-#ifndef	ELFTC_GETPROGNAME
-
-#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__minix) || \
-    defined(__NetBSD__)
-
-#include <stdlib.h>
-
-#define	ELFTC_GETPROGNAME()	getprogname()
-
-#endif	/* __DragonFly__ || __FreeBSD__ || __minix || __NetBSD__ */
-
-
-#if defined(__GLIBC__)
-
-/*
- * GLIBC based systems have a global 'char *' pointer referencing
- * the executable's name.
- */
-extern const char *program_invocation_short_name;
-
-#define	ELFTC_GETPROGNAME()	program_invocation_short_name
-
-#endif	/* __GLIBC__ */
-
-
-#if defined(__OpenBSD__)
-
-extern const char *__progname;
-
-#define	ELFTC_GETPROGNAME()	__progname
-
-#endif	/* __OpenBSD__ */
-
-#endif	/* ELFTC_GETPROGNAME */
-
-
-/**
- ** Per-OS configuration.
- **/
-
-#if defined(GEKKO)
-
-#include <sys/param.h>
-
-#define	ELFTC_BYTE_ORDER			BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		BIG_ENDIAN
-
-#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
-#define	roundup2	roundup
-
-#define	ELFTC_HAVE_MMAP				0
-#define	ELFTC_HAVE_STRMODE			0/
-#define ELFTC_NEED_BYTEORDER_EXTENSIONS		1
-
-#endif
-
-#if defined(__wiiu__)
-
-#include <sys/param.h>
-
-#define	ELFTC_BYTE_ORDER			BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		BIG_ENDIAN
-
-#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
-#define	roundup2	roundup
-
-#define	ELFTC_HAVE_MMAP				0
-#define	ELFTC_HAVE_STRMODE			0/
-#define ELFTC_NEED_BYTEORDER_EXTENSIONS		1
-
-#endif
-
-
-#if defined(__DragonFly__)
-
-#include <osreldate.h>
-#include <sys/endian.h>
-
-#define	ELFTC_BYTE_ORDER			_BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		_LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		_BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-
-#endif
-
-#if defined(__GLIBC__)
-
-#include <endian.h>
-
-#define	ELFTC_BYTE_ORDER			__BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		__LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		__BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-
-/*
- * Debian GNU/Linux and Debian GNU/kFreeBSD do not have strmode(3).
- */
-#define	ELFTC_HAVE_STRMODE			0
-
-/* Whether we need to supply {be,le}32dec. */
-#define ELFTC_NEED_BYTEORDER_EXTENSIONS		1
-
-#define	roundup2	roundup
-
-#endif	/* __GLIBC__ */
-
-
-#if defined(__FreeBSD__)
-
-#include <osreldate.h>
-#include <sys/endian.h>
-
-#define	ELFTC_BYTE_ORDER			_BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		_LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		_BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-#define	ELFTC_HAVE_STRMODE			1
-#if __FreeBSD_version <= 900000
-#define	ELFTC_BROKEN_YY_NO_INPUT		1
-#endif
-#endif	/* __FreeBSD__ */
-
-
-#if defined(__minix)
-#define	ELFTC_HAVE_MMAP				0
-#endif	/* __minix */
-
-
-#if defined(__NetBSD__)
-
-#include <sys/param.h>
-#include <sys/endian.h>
-
-#define	ELFTC_BYTE_ORDER			_BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		_LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		_BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-#define	ELFTC_HAVE_STRMODE			1
-#if __NetBSD_Version__ <= 599002100
-/* from src/doc/CHANGES: flex(1): Import flex-2.5.35 [christos 20091025] */
-/* and 5.99.21 was from Wed Oct 21 21:28:36 2009 UTC */
-#  define ELFTC_BROKEN_YY_NO_INPUT		1
-#endif
-#endif	/* __NetBSD __ */
-
-
-#if defined(__OpenBSD__)
-
-#include <sys/param.h>
-#include <sys/endian.h>
-
-#define	ELFTC_BYTE_ORDER			_BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		_LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		_BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-#define	ELFTC_HAVE_STRMODE			1
-
-#define	ELFTC_NEED_BYTEORDER_EXTENSIONS		1
-#define	roundup2	roundup
-
-#endif	/* __OpenBSD__ */
-
-#endif	/* _ELFTC_H */

loader/src/libelf/_libelf.h

@@ -1,223 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- *
- * $Id: _libelf.h 2365 2011-12-29 04:36:44Z jkoshy $
- */
-
-#ifndef	__LIBELF_H_
-#define	__LIBELF_H_
-
-#include <sys/queue.h>
-
-#include "_libelf_config.h"
-
-#include "_elftc.h"
-
-/*
- * Library-private data structures.
- */
-
-#define LIBELF_MSG_SIZE	256
-
-struct _libelf_globals {
-	int		libelf_arch;
-	unsigned int	libelf_byteorder;
-	int		libelf_class;
-	int		libelf_error;
-	int		libelf_fillchar;
-	unsigned int	libelf_version;
-	char		libelf_msg[LIBELF_MSG_SIZE];
-};
-
-extern struct _libelf_globals _libelf;
-
-#define	LIBELF_PRIVATE(N)	(_libelf.libelf_##N)
-
-#define	LIBELF_ELF_ERROR_MASK			0xFF
-#define	LIBELF_OS_ERROR_SHIFT			8
-
-#define	LIBELF_ERROR(E, O) (((E) & LIBELF_ELF_ERROR_MASK) |	\
-	((O) << LIBELF_OS_ERROR_SHIFT))
-
-#define	LIBELF_SET_ERROR(E, O) do {					\
-		LIBELF_PRIVATE(error) = LIBELF_ERROR(ELF_E_##E, (O));	\
-	} while (0)
-
-#define	LIBELF_ADJUST_AR_SIZE(S)	(((S) + 1U) & ~1U)
-
-/*
- * Flags for library internal use.  These use the upper 16 bits of the
- * `e_flags' field.
- */
-#define	LIBELF_F_API_MASK	0x00FFFF  /* Flags defined by the API. */
-#define	LIBELF_F_AR_HEADER	0x010000  /* translated header available */
-#define	LIBELF_F_AR_VARIANT_SVR4 0x020000 /* BSD style ar(1) archive */
-#define	LIBELF_F_DATA_MALLOCED	0x040000 /* whether data was malloc'ed */
-#define	LIBELF_F_RAWFILE_MALLOC	0x080000 /* whether e_rawfile was malloc'ed */
-#define	LIBELF_F_RAWFILE_MMAP	0x100000 /* whether e_rawfile was mmap'ed */
-#define	LIBELF_F_SHDRS_LOADED	0x200000 /* whether all shdrs were read in */
-#define	LIBELF_F_SPECIAL_FILE	0x400000 /* non-regular file */
-
-struct _Elf {
-	int		e_activations;	/* activation count */
-	unsigned int	e_byteorder;	/* ELFDATA* */
-	int		e_class;	/* ELFCLASS*  */
-	Elf_Cmd		e_cmd;		/* ELF_C_* used at creation time */
-	int		e_fd;		/* associated file descriptor */
-	unsigned int	e_flags;	/* ELF_F_* & LIBELF_F_* flags */
-	Elf_Kind	e_kind;		/* ELF_K_* */
-	Elf		*e_parent; 	/* non-NULL for archive members */
-	char		*e_rawfile;	/* uninterpreted bytes */
-	size_t		e_rawsize;	/* size of uninterpreted bytes */
-	unsigned int	e_version;	/* file version */
-
-	/*
-	 * Header information for archive members.  See the
-	 * LIBELF_F_AR_HEADER flag.
-	 */
-	union {
-		Elf_Arhdr	*e_arhdr;	/* translated header */
-		char		*e_rawhdr;	/* untranslated header */
-	} e_hdr;
-
-	union {
-		struct {		/* ar(1) archives */
-			off_t	e_next;	/* set by elf_rand()/elf_next() */
-			int	e_nchildren;
-			char	*e_rawstrtab;	/* file name strings */
-			size_t	e_rawstrtabsz;
-			char	*e_rawsymtab;	/* symbol table */
-			size_t	e_rawsymtabsz;
-			Elf_Arsym *e_symtab;
-			size_t	e_symtabsz;
-		} e_ar;
-		struct {		/* regular ELF files */
-			union {
-				Elf32_Ehdr *e_ehdr32;
-				Elf64_Ehdr *e_ehdr64;
-			} e_ehdr;
-			union {
-				Elf32_Phdr *e_phdr32;
-				Elf64_Phdr *e_phdr64;
-			} e_phdr;
-			STAILQ_HEAD(, _Elf_Scn)	e_scn;	/* section list */
-			size_t	e_nphdr;	/* number of Phdr entries */
-			size_t	e_nscn;		/* number of sections */
-			size_t	e_strndx;	/* string table section index */
-		} e_elf;
-	} e_u;
-};
-
-/*
- * The internal descriptor wrapping the "Elf_Data" type.
- */
-struct _Libelf_Data {
-	Elf_Data	d_data;		/* The exported descriptor. */
-	Elf_Scn		*d_scn;		/* The containing section */
-	unsigned int	d_flags;
-	STAILQ_ENTRY(_Libelf_Data) d_next;
-};
-
-struct _Elf_Scn {
-	union {
-		Elf32_Shdr	s_shdr32;
-		Elf64_Shdr	s_shdr64;
-	} s_shdr;
-	STAILQ_HEAD(, _Libelf_Data) s_data;	/* translated data */
-	STAILQ_HEAD(, _Libelf_Data) s_rawdata;	/* raw data */
-	STAILQ_ENTRY(_Elf_Scn) s_next;
-	struct _Elf	*s_elf;		/* parent ELF descriptor */
-	unsigned int	s_flags;	/* flags for the section as a whole */
-	size_t		s_ndx;		/* index# for this section */
-	uint64_t	s_offset;	/* managed by elf_update() */
-	uint64_t	s_rawoff;	/* original offset in the file */
-	uint64_t	s_size;		/* managed by elf_update() */
-};
-
-
-enum {
-	ELF_TOFILE,
-	ELF_TOMEMORY
-};
-
-#define	LIBELF_COPY_U32(DST,SRC,NAME)	do {		\
-		if ((SRC)->NAME > UINT_MAX) {		\
-			LIBELF_SET_ERROR(RANGE, 0);	\
-			return (0);			\
-		}					\
-		(DST)->NAME = (SRC)->NAME;		\
-	} while (0)
-
-#define	LIBELF_COPY_S32(DST,SRC,NAME)	do {		\
-		if ((SRC)->NAME > INT_MAX ||		\
-		    (SRC)->NAME < INT_MIN) {		\
-			LIBELF_SET_ERROR(RANGE, 0);	\
-			return (0);			\
-		}					\
-		(DST)->NAME = (SRC)->NAME;		\
-	} while (0)
-
-
-/*
- * Function Prototypes.
- */
-
-struct _Libelf_Data *_libelf_allocate_data(Elf_Scn *_s);
-Elf	*_libelf_allocate_elf(void);
-Elf_Scn	*_libelf_allocate_scn(Elf *_e, size_t _ndx);
-Elf_Arhdr *_libelf_ar_gethdr(Elf *_e);
-Elf	*_libelf_ar_open(Elf *_e, int _reporterror);
-Elf	*_libelf_ar_open_member(int _fd, Elf_Cmd _c, Elf *_ar);
-int	_libelf_ar_get_member(char *_s, size_t _sz, int _base, size_t *_ret);
-Elf_Arsym *_libelf_ar_process_bsd_symtab(Elf *_ar, size_t *_dst);
-Elf_Arsym *_libelf_ar_process_svr4_symtab(Elf *_ar, size_t *_dst);
-unsigned long _libelf_checksum(Elf *_e, int _elfclass);
-void	*_libelf_ehdr(Elf *_e, int _elfclass, int _allocate);
-int	_libelf_falign(Elf_Type _t, int _elfclass);
-size_t	_libelf_fsize(Elf_Type _t, int _elfclass, unsigned int _version,
-    size_t count);
-int	(*_libelf_get_translator(Elf_Type _t, int _direction, int _elfclass))
-	    (char *_dst, size_t dsz, char *_src, size_t _cnt, int _byteswap);
-void	*_libelf_getphdr(Elf *_e, int _elfclass);
-void	*_libelf_getshdr(Elf_Scn *_scn, int _elfclass);
-void	_libelf_init_elf(Elf *_e, Elf_Kind _kind);
-int	_libelf_load_section_headers(Elf *e, void *ehdr);
-int	_libelf_malign(Elf_Type _t, int _elfclass);
-Elf	*_libelf_memory(char *_image, size_t _sz, int _reporterror);
-size_t	_libelf_msize(Elf_Type _t, int _elfclass, unsigned int _version);
-void	*_libelf_newphdr(Elf *_e, int _elfclass, size_t _count);
-Elf	*_libelf_open_object(int _fd, Elf_Cmd _c, int _reporterror);
-struct _Libelf_Data *_libelf_release_data(struct _Libelf_Data *_d);
-Elf	*_libelf_release_elf(Elf *_e);
-Elf_Scn	*_libelf_release_scn(Elf_Scn *_s);
-int	_libelf_setphnum(Elf *_e, void *_eh, int _elfclass, size_t _phnum);
-int	_libelf_setshnum(Elf *_e, void *_eh, int _elfclass, size_t _shnum);
-int	_libelf_setshstrndx(Elf *_e, void *_eh, int _elfclass,
-    size_t _shstrndx);
-Elf_Data *_libelf_xlate(Elf_Data *_d, const Elf_Data *_s,
-    unsigned int _encoding, int _elfclass, int _direction);
-int	_libelf_xlate_shtype(uint32_t _sht);
-
-#endif	/* __LIBELF_H_ */

loader/src/libelf/_libelf_ar.h

@@ -1,56 +0,0 @@
-/*-
- * Copyright (c) 2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- *
- * $Id: _libelf_ar.h 2032 2011-10-23 09:07:00Z jkoshy $
- */
-
-#ifndef	__LIBELF_AR_H_
-#define	__LIBELF_AR_H_
-
-/*
- * Prototypes and declarations needed by libelf's ar(1) archive
- * handling code.
- */
-
-#include <ar.h>
-
-#define	LIBELF_AR_BSD_EXTENDED_NAME_PREFIX	"#1/"
-#define	LIBELF_AR_BSD_SYMTAB_NAME		"__.SYMDEF"
-#define	LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE	\
-	(sizeof(LIBELF_AR_BSD_EXTENDED_NAME_PREFIX) - 1)
-
-#define	IS_EXTENDED_BSD_NAME(NAME)				\
-	(strncmp((NAME), LIBELF_AR_BSD_EXTENDED_NAME_PREFIX,	\
-	 LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE) == 0)
-
-
-char	*_libelf_ar_get_string(const char *_buf, size_t _sz, int _rawname,
-    int _svr4names);
-char	*_libelf_ar_get_raw_name(const struct ar_hdr *_arh);
-char	*_libelf_ar_get_translated_name(const struct ar_hdr *_arh, Elf *_ar);
-int	_libelf_ar_get_number(const char *_buf, size_t _sz, int _base,
-    size_t *_ret);
-
-#endif	/* __LIBELF_AR_H_ */

loader/src/libelf/_libelf_config.h

@@ -1,193 +0,0 @@
-/*-
- * Copyright (c) 2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- *
- * $Id: _libelf_config.h 2287 2011-12-04 06:45:47Z jkoshy $
- */
-
-#ifdef	GEKKO
-
-#define	LIBELF_ARCH		EM_PPC
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#endif	/* GEKKO */
-
-#ifdef	__wiiu__
-
-#define	LIBELF_ARCH		EM_PPC
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#endif	/* __wiiu__ */
-
-#ifdef	__DragonFly__
-
-#if	defined(__amd64__)
-#define	LIBELF_ARCH		EM_X86_64
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS64
-#elif	defined(__i386__)
-#define	LIBELF_ARCH		EM_386
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS32
-#endif
-
-#endif	/* __DragonFly__ */
-
-#ifdef __FreeBSD__
-
-/*
- * Define LIBELF_{ARCH,BYTEORDER,CLASS} based on the machine architecture.
- * See also: <machine/elf.h>.
- */
-
-#if	defined(__amd64__)
-
-#define	LIBELF_ARCH		EM_X86_64
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS64
-
-#elif	defined(__arm__)
-
-#define	LIBELF_ARCH		EM_ARM
-#if	defined(__ARMEB__)	/* Big-endian ARM. */
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#else
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#endif
-#define	LIBELF_CLASS		ELFCLASS32
-
-#elif	defined(__i386__)
-
-#define	LIBELF_ARCH		EM_386
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#elif	defined(__ia64__)
-
-#define	LIBELF_ARCH		EM_IA_64
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS64
-
-#elif	defined(__mips__)
-
-#define	LIBELF_ARCH		EM_MIPS
-#if	defined(__MIPSEB__)
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#else
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#endif
-#define	LIBELF_CLASS		ELFCLASS32
-
-#elif	defined(__powerpc__)
-
-#define	LIBELF_ARCH		EM_PPC
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#elif	defined(__sparc__)
-
-#define	LIBELF_ARCH		EM_SPARCV9
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#define	LIBELF_CLASS		ELFCLASS64
-
-#else
-#error	Unknown FreeBSD architecture.
-#endif
-#endif  /* __FreeBSD__ */
-
-/*
- * Definitions for Minix3.
- */
-#ifdef __minix
-
-#define	LIBELF_ARCH		EM_386
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#endif	/* __minix */
-
-#ifdef __NetBSD__
-
-#include <machine/elf_machdep.h>
-
-#if	!defined(ARCH_ELFSIZE)
-#error	ARCH_ELFSIZE is not defined.
-#endif
-
-#if	ARCH_ELFSIZE == 32
-#define	LIBELF_ARCH		ELF32_MACHDEP_ID
-#define	LIBELF_BYTEORDER	ELF32_MACHDEP_ENDIANNESS
-#define	LIBELF_CLASS		ELFCLASS32
-#define	Elf_Note		Elf32_Nhdr
-#else
-#define	LIBELF_ARCH		ELF64_MACHDEP_ID
-#define	LIBELF_BYTEORDER	ELF64_MACHDEP_ENDIANNESS
-#define	LIBELF_CLASS		ELFCLASS64
-#define	Elf_Note		Elf64_Nhdr
-#endif
-
-#endif	/* __NetBSD__ */
-
-#if defined(__OpenBSD__)
-
-#include <machine/exec.h>
-
-#define	LIBELF_ARCH		ELF_TARG_MACH
-#define	LIBELF_BYTEORDER	ELF_TARG_DATA
-#define	LIBELF_CLASS		ELF_TARG_CLASS
-
-#endif
-
-/*
- * GNU & Linux compatibility.
- *
- * `__linux__' is defined in an environment runs the Linux kernel and glibc.
- * `__GNU__' is defined in an environment runs a GNU kernel (Hurd) and glibc.
- * `__GLIBC__' is defined for an environment that runs glibc over a non-GNU
- *     kernel such as GNU/kFreeBSD.
- */
-
-#if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
-
-#if defined(__linux__)
-
-#include "native-elf-format.h"
-
-#define	LIBELF_CLASS		ELFTC_CLASS
-#define	LIBELF_ARCH		ELFTC_ARCH
-#define	LIBELF_BYTEORDER	ELFTC_BYTEORDER
-
-#endif	/* defined(__linux__) */
-
-#if	LIBELF_CLASS == ELFCLASS32
-#define	Elf_Note		Elf32_Nhdr
-#elif   LIBELF_CLASS == ELFCLASS64
-#define	Elf_Note		Elf64_Nhdr
-#else
-#error  LIBELF_CLASS needs to be one of ELFCLASS32 or ELFCLASS64
-#endif
-
-#endif /* defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) */

loader/src/libelf/elf.c

@@ -1,40 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-struct _libelf_globals _libelf = {
-	.libelf_arch		= LIBELF_ARCH,
-	.libelf_byteorder	= LIBELF_BYTEORDER,
-	.libelf_class		= LIBELF_CLASS,
-	.libelf_error		= 0,
-	.libelf_fillchar	= 0,
-	.libelf_version		= EV_NONE
-};

loader/src/libelf/elf_begin.c

@@ -1,91 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_begin.c 2364 2011-12-28 17:55:25Z jkoshy $");
-
-Elf *
-elf_begin(int fd, Elf_Cmd c, Elf *a)
-{
-	Elf *e;
-
-	e = NULL;
-
-	if (LIBELF_PRIVATE(version) == EV_NONE) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	switch (c) {
-	case ELF_C_NULL:
-		return (NULL);
-
-	case ELF_C_WRITE:
-		/*
-		 * The ELF_C_WRITE command is required to ignore the
-		 * descriptor passed in.
-		 */
-		a = NULL;
-		break;
-
-	case ELF_C_RDWR:
-		if (a != NULL) { /* not allowed for ar(1) archives. */
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			return (NULL);
-		}
-		/*FALLTHROUGH*/
-	case ELF_C_READ:
-		/*
-		 * Descriptor `a' could be for a regular ELF file, or
-		 * for an ar(1) archive.  If descriptor `a' was opened
-		 * using a valid file descriptor, we need to check if
-		 * the passed in `fd' value matches the original one.
-		 */
-		if (a &&
-		    ((a->e_fd != -1 && a->e_fd != fd) || c != a->e_cmd)) {
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			return (NULL);
-		}
-		break;
-
-	default:
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-
-	}
-
-	if (a == NULL)
-		e = _libelf_open_object(fd, c, 1);
-	else if (a->e_kind == ELF_K_AR)
-		e = _libelf_ar_open_member(a->e_fd, c, a);
-	else
-		(e = a)->e_activations++;
-
-	return (e);
-}

loader/src/libelf/elf_cntl.c

@@ -1,58 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_cntl.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-int
-elf_cntl(Elf *e, Elf_Cmd c)
-{
-	if (e == NULL ||
-	    (c != ELF_C_FDDONE && c != ELF_C_FDREAD)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (-1);
-	}
-
-	if (e->e_parent) {
-		LIBELF_SET_ERROR(ARCHIVE, 0);
-		return (-1);
-	}
-
-	if (c == ELF_C_FDREAD) {
-		if (e->e_cmd == ELF_C_WRITE) {
-			LIBELF_SET_ERROR(MODE, 0);
-			return (-1);
-		}
-		else
-			return (0);
-	}
-
-	e->e_fd = -1;
-	return 0;
-}

loader/src/libelf/elf_data.c

@@ -1,254 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <assert.h>
-#include <errno.h>
-#include <libelf.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_data.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-Elf_Data *
-elf_getdata(Elf_Scn *s, Elf_Data *ed)
-{
-	Elf *e;
-	unsigned int sh_type;
-	int elfclass, elftype;
-	size_t fsz, msz, count;
-	struct _Libelf_Data *d;
-	uint64_t sh_align, sh_offset, sh_size;
-	int (*xlate)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (s == NULL || (e = s->s_elf) == NULL ||
-	    (d != NULL && s != d->d_scn)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	assert(e->e_kind == ELF_K_ELF);
-
-	if (d == NULL && (d = STAILQ_FIRST(&s->s_data)) != NULL)
-		return (&d->d_data);
-
-	if (d != NULL)
-		return (&STAILQ_NEXT(d, d_next)->d_data);
-
-	if (e->e_rawfile == NULL) {
-		/*
-		 * In the ELF_C_WRITE case, there is no source that
-		 * can provide data for the section.
-		 */
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	elfclass = e->e_class;
-
-	assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
-
-	if (elfclass == ELFCLASS32) {
-		sh_type   = s->s_shdr.s_shdr32.sh_type;
-		sh_offset = (uint64_t) s->s_shdr.s_shdr32.sh_offset;
-		sh_size   = (uint64_t) s->s_shdr.s_shdr32.sh_size;
-		sh_align  = (uint64_t) s->s_shdr.s_shdr32.sh_addralign;
-	} else {
-		sh_type   = s->s_shdr.s_shdr64.sh_type;
-		sh_offset = s->s_shdr.s_shdr64.sh_offset;
-		sh_size   = s->s_shdr.s_shdr64.sh_size;
-		sh_align  = s->s_shdr.s_shdr64.sh_addralign;
-	}
-
-	if (sh_type == SHT_NULL) {
-		LIBELF_SET_ERROR(SECTION, 0);
-		return (NULL);
-	}
-
-	if ((elftype = _libelf_xlate_shtype(sh_type)) < ELF_T_FIRST ||
-	    elftype > ELF_T_LAST || (sh_type != SHT_NOBITS &&
-	    sh_offset + sh_size > (uint64_t) e->e_rawsize)) {
-		LIBELF_SET_ERROR(SECTION, 0);
-		return (NULL);
-	}
-
-	if ((fsz = (elfclass == ELFCLASS32 ? elf32_fsize : elf64_fsize)
-            (elftype, (size_t) 1, e->e_version)) == 0) {
-		LIBELF_SET_ERROR(UNIMPL, 0);
-		return (NULL);
-	}
-
-	if (sh_size % fsz) {
-		LIBELF_SET_ERROR(SECTION, 0);
-		return (NULL);
-	}
-
-	count = sh_size / fsz;
-
-	msz = _libelf_msize(elftype, elfclass, e->e_version);
-
-	assert(msz > 0);
-
-	if ((d = _libelf_allocate_data(s)) == NULL)
-		return (NULL);
-
-	d->d_data.d_buf     = NULL;
-	d->d_data.d_off     = 0;
-	d->d_data.d_align   = sh_align;
-	d->d_data.d_size    = msz * count;
-	d->d_data.d_type    = elftype;
-	d->d_data.d_version = e->e_version;
-
-	if (sh_type == SHT_NOBITS || sh_size == 0) {
-	        STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
-		return (&d->d_data);
-        }
-
-	if ((d->d_data.d_buf = malloc(msz*count)) == NULL) {
-		(void) _libelf_release_data(d);
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	d->d_flags  |= LIBELF_F_DATA_MALLOCED;
-
-	xlate = _libelf_get_translator(elftype, ELF_TOMEMORY, elfclass);
-	if (!(*xlate)(d->d_data.d_buf, d->d_data.d_size,
-	    e->e_rawfile + sh_offset, count,
-	    e->e_byteorder != LIBELF_PRIVATE(byteorder))) {
-		_libelf_release_data(d);
-		LIBELF_SET_ERROR(DATA, 0);
-		return (NULL);
-	}
-
-	STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
-
-	return (&d->d_data);
-}
-
-Elf_Data *
-elf_newdata(Elf_Scn *s)
-{
-	Elf *e;
-	struct _Libelf_Data *d;
-
-	if (s == NULL || (e = s->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	assert(e->e_kind == ELF_K_ELF);
-
-	/*
-	 * elf_newdata() has to append a data descriptor, so
-	 * bring in existing section data if not already present.
-	 */
-	if (e->e_rawfile && s->s_size > 0 && STAILQ_EMPTY(&s->s_data))
-		if (elf_getdata(s, NULL) == NULL)
-			return (NULL);
-
-	if ((d = _libelf_allocate_data(s)) == NULL)
-		return (NULL);
-
-	STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
-
-	d->d_data.d_align = 1;
-	d->d_data.d_buf = NULL;
-	d->d_data.d_off = (uint64_t) ~0;
-	d->d_data.d_size = 0;
-	d->d_data.d_type = ELF_T_BYTE;
-	d->d_data.d_version = LIBELF_PRIVATE(version);
-
-	(void) elf_flagscn(s, ELF_C_SET, ELF_F_DIRTY);
-
-	return (&d->d_data);
-}
-
-/*
- * Retrieve a data descriptor for raw (untranslated) data for section
- * `s'.
- */
-
-Elf_Data *
-elf_rawdata(Elf_Scn *s, Elf_Data *ed)
-{
-	Elf *e;
-	int elf_class;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-	uint64_t sh_align, sh_offset, sh_size;
-
-	if (s == NULL || (e = s->s_elf) == NULL || e->e_rawfile == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	assert(e->e_kind == ELF_K_ELF);
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL && (d = STAILQ_FIRST(&s->s_rawdata)) != NULL)
-		return (&d->d_data);
-
-	if (d != NULL)
-		return (&STAILQ_NEXT(d, d_next)->d_data);
-
-	elf_class = e->e_class;
-
-	assert(elf_class == ELFCLASS32 || elf_class == ELFCLASS64);
-
-	if (elf_class == ELFCLASS32) {
-		sh_type   = s->s_shdr.s_shdr32.sh_type;
-		sh_offset = (uint64_t) s->s_shdr.s_shdr32.sh_offset;
-		sh_size   = (uint64_t) s->s_shdr.s_shdr32.sh_size;
-		sh_align  = (uint64_t) s->s_shdr.s_shdr32.sh_addralign;
-	} else {
-		sh_type   = s->s_shdr.s_shdr64.sh_type;
-		sh_offset = s->s_shdr.s_shdr64.sh_offset;
-		sh_size   = s->s_shdr.s_shdr64.sh_size;
-		sh_align  = s->s_shdr.s_shdr64.sh_addralign;
-	}
-
-	if (sh_type == SHT_NULL)
-		return (NULL);
-
-	if ((d = _libelf_allocate_data(s)) == NULL)
-		return (NULL);
-
-	d->d_data.d_buf = (sh_type == SHT_NOBITS || sh_size == 0) ? NULL :
-	    e->e_rawfile + sh_offset;
-	d->d_data.d_off     = 0;
-	d->d_data.d_align   = sh_align;
-	d->d_data.d_size    = sh_size;
-	d->d_data.d_type    = ELF_T_BYTE;
-	d->d_data.d_version = e->e_version;
-
-	STAILQ_INSERT_TAIL(&s->s_rawdata, d, d_next);
-
-	return (&d->d_data);
-}

loader/src/libelf/elf_end.c

@@ -1,97 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2009,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-#if	ELFTC_HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
-ELFTC_VCSID("$Id: elf_end.c 2240 2011-11-28 06:36:48Z jkoshy $");
-
-int
-elf_end(Elf *e)
-{
-	Elf *sv;
-	Elf_Scn *scn, *tscn;
-
-	if (e == NULL || e->e_activations == 0)
-		return (0);
-
-	if (--e->e_activations > 0)
-		return (e->e_activations);
-
-	assert(e->e_activations == 0);
-
-	while (e && e->e_activations == 0) {
-		switch (e->e_kind) {
-		case ELF_K_AR:
-			/*
-			 * If we still have open child descriptors, we
-			 * need to defer reclaiming resources till all
-			 * the child descriptors for the archive are
-			 * closed.
-			 */
-			if (e->e_u.e_ar.e_nchildren > 0)
-				return (0);
-			break;
-		case ELF_K_ELF:
-			/*
-			 * Reclaim all section descriptors.
-			 */
-			STAILQ_FOREACH_SAFE(scn, &e->e_u.e_elf.e_scn, s_next,
-			    tscn)
- 				scn = _libelf_release_scn(scn);
-			break;
-		case ELF_K_NUM:
-			assert(0);
-		default:
-			break;
-		}
-
-		if (e->e_rawfile) {
-			if (e->e_flags & LIBELF_F_RAWFILE_MALLOC)
-				free(e->e_rawfile);
-#if	ELFTC_HAVE_MMAP
-			else if (e->e_flags & LIBELF_F_RAWFILE_MMAP)
-				(void) munmap(e->e_rawfile, e->e_rawsize);
-#endif
-		}
-
-		sv = e;
-		if ((e = e->e_parent) != NULL)
-			e->e_u.e_ar.e_nchildren--;
-		sv = _libelf_release_elf(sv);
-	}
-
-	return (0);
-}

loader/src/libelf/elf_errmsg.c

@@ -1,85 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_errmsg.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * Retrieve a human readable translation for an error message.
- */
-
-const char *_libelf_errors[] = {
-#define	DEFINE_ERROR(N,S)	[ELF_E_##N] = S
-	DEFINE_ERROR(NONE,	"No Error"),
-	DEFINE_ERROR(ARCHIVE,	"Malformed ar(1) archive"),
-	DEFINE_ERROR(ARGUMENT,	"Invalid argument"),
-	DEFINE_ERROR(CLASS,	"ELF class mismatch"),
-	DEFINE_ERROR(DATA,	"Invalid data buffer descriptor"),
-	DEFINE_ERROR(HEADER,	"Missing or malformed ELF header"),
-	DEFINE_ERROR(IO,	"I/O error"),
-	DEFINE_ERROR(LAYOUT,	"Layout constraint violation"),
-	DEFINE_ERROR(MODE,	"Incorrect ELF descriptor mode"),
-	DEFINE_ERROR(RANGE,	"Value out of range of target"),
-	DEFINE_ERROR(RESOURCE,	"Resource exhaustion"),
-	DEFINE_ERROR(SECTION,	"Invalid section descriptor"),
-	DEFINE_ERROR(SEQUENCE,	"API calls out of sequence"),
-	DEFINE_ERROR(UNIMPL,	"Unimplemented feature"),
-	DEFINE_ERROR(VERSION,	"Unknown ELF API version"),
-	DEFINE_ERROR(NUM,	"Unknown error")
-#undef	DEFINE_ERROR
-};
-
-const char *
-elf_errmsg(int error)
-{
-	int oserr;
-
-	if (error == ELF_E_NONE &&
-	    (error = LIBELF_PRIVATE(error)) == 0)
-	    return NULL;
-	else if (error == -1)
-	    error = LIBELF_PRIVATE(error);
-
-	oserr = error >> LIBELF_OS_ERROR_SHIFT;
-	error &= LIBELF_ELF_ERROR_MASK;
-
-	if (error < ELF_E_NONE || error >= ELF_E_NUM)
-		return _libelf_errors[ELF_E_NUM];
-	if (oserr) {
-		(void) snprintf(LIBELF_PRIVATE(msg),
-		    sizeof(LIBELF_PRIVATE(msg)), "%s: %s",
-		    _libelf_errors[error], strerror(oserr));
-		return (const char *)&LIBELF_PRIVATE(msg);
-	}
-	return _libelf_errors[error];
-}

loader/src/libelf/elf_errno.c

@@ -1,43 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_errno.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-int
-elf_errno(void)
-{
-	int old;
-
-	old = LIBELF_PRIVATE(error);
-	LIBELF_PRIVATE(error) = 0;
-	return (old & LIBELF_ELF_ERROR_MASK);
-}

loader/src/libelf/elf_fill.c

@@ -1,39 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_fill.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-void
-elf_fill(int fill)
-{
-	LIBELF_PRIVATE(fillchar) = fill;
-}

loader/src/libelf/elf_flag.c

@@ -1,198 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2009,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_flag.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-unsigned int
-elf_flagarhdr(Elf_Arhdr *a, Elf_Cmd c, unsigned int flags)
-{
-	unsigned int r;
-
-	if (a == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (flags & ~ELF_F_DIRTY) != 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (c == ELF_C_SET)
-		r = a->ar_flags |= flags;
-	else
-		r = a->ar_flags &= ~flags;
-
-	return (r & LIBELF_F_API_MASK);
-}
-
-unsigned int
-elf_flagdata(Elf_Data *d, Elf_Cmd c, unsigned int flags)
-{
-	unsigned int r;
-	struct _Libelf_Data *ld;
-
-	if (d == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (flags & ~ELF_F_DIRTY) != 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ld = (struct _Libelf_Data *) d;
-
-	if (c == ELF_C_SET)
-		r = ld->d_flags |= flags;
-	else
-		r = ld->d_flags &= ~flags;
-
-	return (r & LIBELF_F_API_MASK);
-}
-
-unsigned int
-elf_flagehdr(Elf *e, Elf_Cmd c, unsigned int flags)
-{
-	int ec;
-	void *ehdr;
-
-	if (e == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (e->e_kind != ELF_K_ELF) || (flags & ~ELF_F_DIRTY) != 0 ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32)
-		ehdr = e->e_u.e_elf.e_ehdr.e_ehdr32;
-	else
-		ehdr = e->e_u.e_elf.e_ehdr.e_ehdr64;
-
-	if (ehdr == NULL) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (0);
-	}
-
-	return (elf_flagelf(e, c, flags));
-}
-
-unsigned int
-elf_flagelf(Elf *e, Elf_Cmd c, unsigned int flags)
-{
-	int r;
-
-	if (e == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (e->e_kind != ELF_K_ELF) ||
-	    (flags & ~(ELF_F_ARCHIVE | ELF_F_ARCHIVE_SYSV |
-	    ELF_F_DIRTY | ELF_F_LAYOUT)) != 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if ((flags & ELF_F_ARCHIVE_SYSV) && (flags & ELF_F_ARCHIVE) == 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if ((flags & ELF_F_ARCHIVE) && e->e_cmd != ELF_C_WRITE) {
-		LIBELF_SET_ERROR(MODE, 0);
-		return (0);
-	}
-
-	if (c == ELF_C_SET)
-		r = e->e_flags |= flags;
-	else
-		r = e->e_flags &= ~flags;
-	return (r & LIBELF_F_API_MASK);
-}
-
-unsigned int
-elf_flagphdr(Elf *e, Elf_Cmd c, unsigned int flags)
-{
-	int ec;
-	void *phdr;
-
-	if (e == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (e->e_kind != ELF_K_ELF) || (flags & ~ELF_F_DIRTY) != 0 ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32)
-		phdr = e->e_u.e_elf.e_phdr.e_phdr32;
-	else
-		phdr = e->e_u.e_elf.e_phdr.e_phdr64;
-
-	if (phdr == NULL) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (0);
-	}
-
-	return (elf_flagelf(e, c, flags));
-}
-
-unsigned int
-elf_flagscn(Elf_Scn *s, Elf_Cmd c, unsigned int flags)
-{
-	int r;
-
-	if (s == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (flags & ~ELF_F_DIRTY) != 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (c == ELF_C_SET)
-		r = s->s_flags |= flags;
-	else
-		r = s->s_flags &= ~flags;
-	return (r & LIBELF_F_API_MASK);
-}
-
-unsigned int
-elf_flagshdr(Elf_Scn *s, Elf_Cmd c, unsigned int flags)
-{
-	return (elf_flagscn(s, c, flags));
-}

loader/src/libelf/elf_getarhdr.c

@@ -1,47 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_getarhdr.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Arhdr *
-elf_getarhdr(Elf *e)
-{
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (e->e_flags & LIBELF_F_AR_HEADER)
-		return (e->e_hdr.e_arhdr);
-
-	return (_libelf_ar_gethdr(e));
-}

loader/src/libelf/elf_getarsym.c

@@ -1,58 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_getarsym.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Arsym *
-elf_getarsym(Elf *ar, size_t *ptr)
-{
-	size_t n;
-	Elf_Arsym *symtab;
-
-	n = 0;
-	symtab = NULL;
-
-	if (ar == NULL || ar->e_kind != ELF_K_AR)
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-	else if ((symtab = ar->e_u.e_ar.e_symtab) != NULL)
-		n = ar->e_u.e_ar.e_symtabsz;
-	else if (ar->e_u.e_ar.e_rawsymtab)
-		symtab = (ar->e_flags & LIBELF_F_AR_VARIANT_SVR4) ?
-		    _libelf_ar_process_svr4_symtab(ar, &n) :
-		    _libelf_ar_process_bsd_symtab(ar, &n);
-	else
-		LIBELF_SET_ERROR(ARCHIVE, 0);
-
-	if (ptr)
-		*ptr = n;
-	return (symtab);
-}

loader/src/libelf/elf_getbase.c

@@ -1,48 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_getbase.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-off_t
-elf_getbase(Elf *e)
-{
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return ((off_t) -1);
-	}
-
-	if (e->e_parent == NULL)
-		return ((off_t) 0);
-
-	return ((off_t) ((uintptr_t) e->e_rawfile -
-	    (uintptr_t) e->e_parent->e_rawfile));
-}

loader/src/libelf/elf_getident.c

@@ -1,68 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <assert.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_getident.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-char *
-elf_getident(Elf *e, size_t *sz)
-{
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		goto error;
-	}
-
-	if (e->e_cmd == ELF_C_WRITE && e->e_rawfile == NULL) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		goto error;
-	}
-
-	assert(e->e_kind != ELF_K_AR || e->e_cmd == ELF_C_READ);
-
-	if (sz) {
-		if (e->e_kind == ELF_K_AR)
-			*sz = SARMAG;
-		else if (e->e_kind == ELF_K_ELF)
-			*sz = EI_NIDENT;
-		else
-			*sz = e->e_rawsize;
-	}
-
-	return ((char *) e->e_rawfile);
-
- error:
-	if (sz)
-		*sz = 0;
-	return (NULL);
-}

loader/src/libelf/elf_hash.c

@@ -1,56 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_hash.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * This elf_hash function is defined by the System V ABI.
- */
-
-unsigned long
-elf_hash(const char *name)
-{
-	unsigned long h, t;
-	const unsigned char *s;
-
-	s = (const unsigned char *) name;
-	h = t = 0;
-
-	for (; *s != '\0'; h = h & ~t) {
-		h = (h << 4) + *s++;
-		t = h & 0xF0000000UL;
-		if (t)
-			h ^= t >> 24;
-	}
-
-	return (h);
-}

loader/src/libelf/elf_kind.c

@@ -1,44 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_kind.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Kind
-elf_kind(Elf *e)
-{
-	if (e == NULL)
-		return (ELF_K_NONE);
-	if (e->e_kind == ELF_K_AR ||
-	    e->e_kind == ELF_K_ELF)
-		return (e->e_kind);
-	return (ELF_K_NONE);
-}

loader/src/libelf/elf_memory.c

@@ -1,47 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_memory.c 2368 2011-12-29 06:34:28Z jkoshy $");
-
-Elf *
-elf_memory(char *image, size_t sz)
-{
-	if (LIBELF_PRIVATE(version) == EV_NONE) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	if (image == NULL || sz == 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	return (_libelf_memory(image, sz, 1));
-}

loader/src/libelf/elf_next.c

@@ -1,62 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <assert.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_next.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Cmd
-elf_next(Elf *e)
-{
-	off_t next;
-	Elf *parent;
-
-	if (e == NULL)
-		return (ELF_C_NULL);
-
-	 if ((parent = e->e_parent) == NULL) {
-		 LIBELF_SET_ERROR(ARGUMENT, 0);
-		 return (ELF_C_NULL);
-	 }
-
-	assert (parent->e_kind == ELF_K_AR);
-	assert (parent->e_cmd == ELF_C_READ);
-	assert(e->e_rawfile > parent->e_rawfile);
-
-	next = e->e_rawfile - parent->e_rawfile + e->e_rawsize;
-	next = (next + 1) & ~1;	/* round up to an even boundary */
-
-	parent->e_u.e_ar.e_next = (next >= (off_t) parent->e_rawsize) ?
-	    (off_t) 0 : next;
-
-	return (ELF_C_READ);
-}

loader/src/libelf/elf_open.c

@@ -1,67 +0,0 @@
-/*-
- * Copyright (c) 2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id$");
-
-/*
- * Extension API: open a file for reading, ignoring parse errors.
- */
-
-Elf *
-elf_open(int fd)
-{
-	if (LIBELF_PRIVATE(version) == EV_NONE) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	return (_libelf_open_object(fd, ELF_C_READ, 0));
-}
-
-/*
- * Extension API: create an ELF descriptor for an in-memory object,
- * ignoring parse errors.
- */
-
-Elf *
-elf_openmemory(char *image, size_t sz)
-{
-	if (LIBELF_PRIVATE(version) == EV_NONE) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	if (image == NULL || sz == 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	return (_libelf_memory(image, sz, 0));
-}

loader/src/libelf/elf_phnum.c

@@ -1,67 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_phnum.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-static int
-_libelf_getphdrnum(Elf *e, size_t *phnum)
-{
-	void *eh;
-	int ec;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (-1);
-	}
-
-	if ((eh = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (-1);
-
-	*phnum = e->e_u.e_elf.e_nphdr;
-
-	return (0);
-}
-
-int
-elf_getphdrnum(Elf *e, size_t *phnum)
-{
-	return (_libelf_getphdrnum(e, phnum));
-}
-
-/* Deprecated API */
-int
-elf_getphnum(Elf *e, size_t *phnum)
-{
-	return (_libelf_getphdrnum(e, phnum) >= 0);
-}

loader/src/libelf/elf_rand.c

@@ -1,59 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_rand.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-off_t
-elf_rand(Elf *ar, off_t offset)
-{
-	struct ar_hdr *arh;
-
-	if (ar == NULL || ar->e_kind != ELF_K_AR ||
-	    (offset & 1) || offset < SARMAG ||
-	    offset + sizeof(struct ar_hdr) >= ar->e_rawsize) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return 0;
-	}
-
-	arh = (struct ar_hdr *) (ar->e_rawfile + offset);
-
-	/* a too simple sanity check */
-	if (arh->ar_fmag[0] != '`' || arh->ar_fmag[1] != '\n') {
-		LIBELF_SET_ERROR(ARCHIVE, 0);
-		return 0;
-	}
-
-	ar->e_u.e_ar.e_next = offset;
-
-	return (offset);
-}

loader/src/libelf/elf_rawfile.c

@@ -1,53 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_rawfile.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-char *
-elf_rawfile(Elf *e, size_t *sz)
-{
-	char *ptr;
-	size_t size;
-
-	size = e ? e->e_rawsize : 0;
-	ptr = NULL;
-
-	if (e == NULL)
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-	else if ((ptr = e->e_rawfile) == NULL && e->e_cmd == ELF_C_WRITE)
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-
-	if (sz)
-		*sz = size;
-
-	return (ptr);
-}

loader/src/libelf/elf_scn.c

@@ -1,233 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-#include <sys/queue.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <stddef.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_scn.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * Load an ELF section table and create a list of Elf_Scn structures.
- */
-int
-_libelf_load_section_headers(Elf *e, void *ehdr)
-{
-	int ec, swapbytes;
-	size_t fsz, i, shnum;
-	uint64_t shoff;
-	char *src;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-	Elf_Scn *scn;
-	int (*xlator)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-
-	assert(e != NULL);
-	assert(ehdr != NULL);
-	assert((e->e_flags & LIBELF_F_SHDRS_LOADED) == 0);
-
-#define	CHECK_EHDR(E,EH)	do {				\
-		if (fsz != (EH)->e_shentsize ||			\
-		    shoff + fsz * shnum > e->e_rawsize) {	\
-			LIBELF_SET_ERROR(HEADER, 0);		\
-			return (0);				\
-		}						\
-	} while (0)
-
-	ec = e->e_class;
-	fsz = _libelf_fsize(ELF_T_SHDR, ec, e->e_version, (size_t) 1);
-	assert(fsz > 0);
-
-	shnum = e->e_u.e_elf.e_nscn;
-
-	if (ec == ELFCLASS32) {
-		eh32 = (Elf32_Ehdr *) ehdr;
-		shoff = (uint64_t) eh32->e_shoff;
-		CHECK_EHDR(e, eh32);
-	} else {
-		eh64 = (Elf64_Ehdr *) ehdr;
-		shoff = eh64->e_shoff;
-		CHECK_EHDR(e, eh64);
-	}
-
-	xlator = _libelf_get_translator(ELF_T_SHDR, ELF_TOMEMORY, ec);
-
-	swapbytes = e->e_byteorder != LIBELF_PRIVATE(byteorder);
-	src = e->e_rawfile + shoff;
-
-	/*
-	 * If the file is using extended numbering then section #0
-	 * would have already been read in.
-	 */
-
-	i = 0;
-	if (!STAILQ_EMPTY(&e->e_u.e_elf.e_scn)) {
-		/* commented out to prevent build error
-        assert(STAILQ_FIRST(&e->e_u.e_elf.e_scn) ==
-		    STAILQ_LAST(&e->e_u.e_elf.e_scn, _Elf_Scn, s_next));*/
-
-		i = 1;
-		src += fsz;
-	}
-
-	for (; i < shnum; i++, src += fsz) {
-		if ((scn = _libelf_allocate_scn(e, i)) == NULL)
-			return (0);
-
-		(*xlator)((char *) &scn->s_shdr, sizeof(scn->s_shdr), src,
-		    (size_t) 1, swapbytes);
-
-		if (ec == ELFCLASS32) {
-			scn->s_offset = scn->s_rawoff =
-			    scn->s_shdr.s_shdr32.sh_offset;
-			scn->s_size = scn->s_shdr.s_shdr32.sh_size;
-		} else {
-			scn->s_offset = scn->s_rawoff =
-			    scn->s_shdr.s_shdr64.sh_offset;
-			scn->s_size = scn->s_shdr.s_shdr64.sh_size;
-		}
-	}
-
-	e->e_flags |= LIBELF_F_SHDRS_LOADED;
-
-	return (1);
-}
-
-
-Elf_Scn *
-elf_getscn(Elf *e, size_t index)
-{
-	int ec;
-	void *ehdr;
-	Elf_Scn *s;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (NULL);
-
-	if (e->e_cmd != ELF_C_WRITE &&
-	    (e->e_flags & LIBELF_F_SHDRS_LOADED) == 0 &&
-	    _libelf_load_section_headers(e, ehdr) == 0)
-		return (NULL);
-
-	STAILQ_FOREACH(s, &e->e_u.e_elf.e_scn, s_next)
-		if (s->s_ndx == index)
-			return (s);
-
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}
-
-size_t
-elf_ndxscn(Elf_Scn *s)
-{
-	if (s == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (SHN_UNDEF);
-	}
-	return (s->s_ndx);
-}
-
-Elf_Scn *
-elf_newscn(Elf *e)
-{
-	int ec;
-	void *ehdr;
-	Elf_Scn *scn;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) {
-		LIBELF_SET_ERROR(CLASS, 0);
-		return (NULL);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (NULL);
-
-	/*
-	 * The application may be asking for a new section descriptor
-	 * on an ELF object opened with ELF_C_RDWR or ELF_C_READ.  We
-	 * need to bring in the existing section information before
-	 * appending a new one to the list.
-	 *
-	 * Per the ELF(3) API, an application is allowed to open a
-	 * file using ELF_C_READ, mess with its internal structure and
-	 * use elf_update(...,ELF_C_NULL) to compute its new layout.
-	 */
-	if (e->e_cmd != ELF_C_WRITE &&
-	    (e->e_flags & LIBELF_F_SHDRS_LOADED) == 0 &&
-	    _libelf_load_section_headers(e, ehdr) == 0)
-		return (NULL);
-
-	if (STAILQ_EMPTY(&e->e_u.e_elf.e_scn)) {
-		assert(e->e_u.e_elf.e_nscn == 0);
-		if ((scn = _libelf_allocate_scn(e, (size_t) SHN_UNDEF)) ==
-		    NULL)
-			return (NULL);
-		e->e_u.e_elf.e_nscn++;
-	}
-
-	assert(e->e_u.e_elf.e_nscn > 0);
-
-	if ((scn = _libelf_allocate_scn(e, e->e_u.e_elf.e_nscn)) == NULL)
-		return (NULL);
-
-	e->e_u.e_elf.e_nscn++;
-
-	(void) elf_flagscn(scn, ELF_C_SET, ELF_F_DIRTY);
-
-	return (scn);
-}
-
-Elf_Scn *
-elf_nextscn(Elf *e, Elf_Scn *s)
-{
-	if (e == NULL || (e->e_kind != ELF_K_ELF) ||
-	    (s && s->s_elf != e)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	return (s == NULL ? elf_getscn(e, (size_t) 1) :
-	    STAILQ_NEXT(s, s_next));
-}

loader/src/libelf/elf_shnum.c

@@ -1,67 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_shnum.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-static int
-_libelf_getshdrnum(Elf *e, size_t *shnum)
-{
-	void *eh;
-	int ec;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (-1);
-	}
-
-	if ((eh = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (-1);
-
-	*shnum = e->e_u.e_elf.e_nscn;
-
-	return (0);
-}
-
-int
-elf_getshdrnum(Elf *e, size_t *shnum)
-{
-	return (_libelf_getshdrnum(e, shnum));
-}
-
-/* Deprecated API. */
-int
-elf_getshnum(Elf *e, size_t *shnum)
-{
-	return (_libelf_getshdrnum(e, shnum) >= 0);
-}

loader/src/libelf/elf_shstrndx.c

@@ -1,82 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_shstrndx.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-static int
-_libelf_getshdrstrndx(Elf *e, size_t *strndx)
-{
-	void *eh;
-	int ec;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (-1);
-	}
-
-	if ((eh = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (-1);
-
-	*strndx = e->e_u.e_elf.e_strndx;
-
-	return (0);
-}
-
-int
-elf_getshdrstrndx(Elf *e, size_t *strndx)
-{
-	return (_libelf_getshdrstrndx(e, strndx));
-}
-
-int
-elf_getshstrndx(Elf *e, size_t *strndx)	/* Deprecated API. */
-{
-	return (_libelf_getshdrstrndx(e, strndx) >= 0);
-}
-
-int
-elf_setshstrndx(Elf *e, size_t strndx)
-{
-	void *eh;
-	int ec;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) ||
-	    ((eh = _libelf_ehdr(e, ec, 0)) == NULL)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	return (_libelf_setshstrndx(e, eh, ec, strndx));
-}

loader/src/libelf/elf_strptr.c

@@ -1,132 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/param.h>
-
-#include <assert.h>
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_strptr.c 2271 2011-12-03 17:06:35Z jkoshy $");
-
-/*
- * Convert an ELF section#,offset pair to a string pointer.
- */
-
-char *
-elf_strptr(Elf *e, size_t scndx, size_t offset)
-{
-	Elf_Scn *s;
-	Elf_Data *d;
-	size_t alignment, count;
-	GElf_Shdr shdr;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((s = elf_getscn(e, scndx)) == NULL ||
-	    gelf_getshdr(s, &shdr) == NULL)
-		return (NULL);
-
-	if (shdr.sh_type != SHT_STRTAB ||
-	    offset >= shdr.sh_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	d = NULL;
-	if (e->e_flags & ELF_F_LAYOUT) {
-
-		/*
-		 * The application is taking responsibility for the
-		 * ELF object's layout, so we can directly translate
-		 * an offset to a `char *' address using the `d_off'
-		 * members of Elf_Data descriptors.
-		 */
-		while ((d = elf_getdata(s, d)) != NULL) {
-
-			if (d->d_buf == 0 || d->d_size == 0)
-				continue;
-
-			if (d->d_type != ELF_T_BYTE) {
-				LIBELF_SET_ERROR(DATA, 0);
-				return (NULL);
-			}
-
-			if (offset >= d->d_off &&
-			    offset < d->d_off + d->d_size)
-				return ((char *) d->d_buf + offset - d->d_off);
-		}
-	} else {
-		/*
-		 * Otherwise, the `d_off' members are not useable and
-		 * we need to compute offsets ourselves, taking into
-		 * account 'holes' in coverage of the section introduced
-		 * by alignment requirements.
-		 */
-		count = (size_t) 0;	/* cumulative count of bytes seen */
-		while ((d = elf_getdata(s, d)) != NULL && count <= offset) {
-
-			if (d->d_buf == NULL || d->d_size == 0)
-				continue;
-
-			if (d->d_type != ELF_T_BYTE) {
-				LIBELF_SET_ERROR(DATA, 0);
-				return (NULL);
-			}
-
-			if ((alignment = d->d_align) > 1) {
-				if ((alignment & (alignment - 1)) != 0) {
-					LIBELF_SET_ERROR(DATA, 0);
-					return (NULL);
-				}
-				count = roundup2(count, alignment);
-			}
-
-			if (offset < count) {
-				/* offset starts in the 'hole' */
-				LIBELF_SET_ERROR(ARGUMENT, 0);
-				return (NULL);
-			}
-
-			if (offset < count + d->d_size) {
-				if (d->d_buf != NULL)
-					return ((char *) d->d_buf +
-					    offset - count);
-				LIBELF_SET_ERROR(DATA, 0);
-				return (NULL);
-			}
-
-			count += d->d_size;
-		}
-	}
-
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}

loader/src/libelf/elf_version.c

@@ -1,52 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_version.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-unsigned int
-elf_version(unsigned int v)
-{
-	unsigned int old;
-
-	if ((old = LIBELF_PRIVATE(version)) == EV_NONE)
-		old = EV_CURRENT;
-
-	if (v == EV_NONE)
-		return old;
-	if (v > EV_CURRENT) {
-		LIBELF_SET_ERROR(VERSION, 0);
-		return EV_NONE;
-	}
-
-	LIBELF_PRIVATE(version) = v;
-	return (old);
-}

loader/src/libelf/gelf.h

@@ -1,106 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- *
- * $Id: gelf.h 1168 2010-09-04 01:03:25Z jkoshy $
- */
-
-#ifndef	_GELF_H_
-#define	_GELF_H_
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-typedef Elf64_Addr	GElf_Addr;	/* Addresses */
-typedef Elf64_Half	GElf_Half;	/* Half words (16 bit) */
-typedef Elf64_Off	GElf_Off;	/* Offsets */
-typedef Elf64_Sword	GElf_Sword;	/* Signed words (32 bit) */
-typedef Elf64_Sxword	GElf_Sxword;	/* Signed long words (64 bit) */
-typedef Elf64_Word	GElf_Word;	/* Unsigned words (32 bit) */
-typedef Elf64_Xword	GElf_Xword;	/* Unsigned long words (64 bit) */
-
-typedef Elf64_Dyn	GElf_Dyn;	/* ".dynamic" section entries */
-typedef Elf64_Ehdr	GElf_Ehdr;	/* ELF header */
-typedef Elf64_Phdr	GElf_Phdr;	/* Program header */
-typedef Elf64_Shdr	GElf_Shdr;	/* Section header */
-typedef Elf64_Sym	GElf_Sym;	/* Symbol table entries */
-typedef Elf64_Rel	GElf_Rel;	/* Relocation entries */
-typedef Elf64_Rela	GElf_Rela;	/* Relocation entries with addend */
-
-typedef	Elf64_Cap	GElf_Cap;	/* SW/HW capabilities */
-typedef Elf64_Move	GElf_Move;	/* Move entries */
-typedef Elf64_Syminfo	GElf_Syminfo;	/* Symbol information */
-
-#define	GELF_M_INFO			ELF64_M_INFO
-#define	GELF_M_SIZE			ELF64_M_SIZE
-#define	GELF_M_SYM			ELF64_M_SYM
-
-#define	GELF_R_INFO			ELF64_R_INFO
-#define	GELF_R_SYM			ELF64_R_SYM
-#define	GELF_R_TYPE			ELF64_R_TYPE
-#define	GELF_R_TYPE_DATA		ELF64_R_TYPE_DATA
-#define	GELF_R_TYPE_ID			ELF64_R_TYPE_ID
-#define	GELF_R_TYPE_INFO		ELF64_R_TYPE_INFO
-
-#define	GELF_ST_BIND			ELF64_ST_BIND
-#define	GELF_ST_INFO			ELF64_ST_INFO
-#define	GELF_ST_TYPE			ELF64_ST_TYPE
-#define	GELF_ST_VISIBILITY		ELF64_ST_VISIBILITY
-
-long		gelf_checksum(Elf *_elf);
-size_t		gelf_fsize(Elf *_elf, Elf_Type _type, size_t _count,
-			unsigned int _version);
-int		gelf_getclass(Elf *_elf);
-GElf_Dyn	*gelf_getdyn(Elf_Data *_data, int _index, GElf_Dyn *_dst);
-GElf_Ehdr	*gelf_getehdr(Elf *_elf, GElf_Ehdr *_dst);
-GElf_Phdr	*gelf_getphdr(Elf *_elf, int _index, GElf_Phdr *_dst);
-GElf_Rel	*gelf_getrel(Elf_Data *_src, int _index, GElf_Rel *_dst);
-GElf_Rela	*gelf_getrela(Elf_Data *_src, int _index, GElf_Rela *_dst);
-GElf_Shdr	*gelf_getshdr(Elf_Scn *_scn, GElf_Shdr *_dst);
-GElf_Sym	*gelf_getsym(Elf_Data *_src, int _index, GElf_Sym *_dst);
-GElf_Sym	*gelf_getsymshndx(Elf_Data *_src, Elf_Data *_shindexsrc,
-			int _index, GElf_Sym *_dst, Elf32_Word *_shindexdst);
-void *		gelf_newehdr(Elf *_elf, int _class);
-void *		gelf_newphdr(Elf *_elf, size_t _phnum);
-int		gelf_update_dyn(Elf_Data *_dst, int _index, GElf_Dyn *_src);
-int		gelf_update_ehdr(Elf *_elf, GElf_Ehdr *_src);
-int		gelf_update_phdr(Elf *_elf, int _index, GElf_Phdr *_src);
-int		gelf_update_rel(Elf_Data *_dst, int _index, GElf_Rel *_src);
-int		gelf_update_rela(Elf_Data *_dst, int _index, GElf_Rela *_src);
-int		gelf_update_shdr(Elf_Scn *_dst, GElf_Shdr *_src);
-int		gelf_update_sym(Elf_Data *_dst, int _index, GElf_Sym *_src);
-int		gelf_update_symshndx(Elf_Data *_symdst, Elf_Data *_shindexdst,
-			int _index, GElf_Sym *_symsrc, Elf32_Word _shindexsrc);
-Elf_Data 	*gelf_xlatetof(Elf *_elf, Elf_Data *_dst, const Elf_Data *_src, unsigned int _encode);
-Elf_Data 	*gelf_xlatetom(Elf *_elf, Elf_Data *_dst, const Elf_Data *_src, unsigned int _encode);
-
-GElf_Cap	*gelf_getcap(Elf_Data *_data, int _index, GElf_Cap *_cap);
-GElf_Move	*gelf_getmove(Elf_Data *_src, int _index, GElf_Move *_dst);
-GElf_Syminfo	*gelf_getsyminfo(Elf_Data *_src, int _index, GElf_Syminfo *_dst);
-int		gelf_update_cap(Elf_Data *_dst, int _index, GElf_Cap *_src);
-int		gelf_update_move(Elf_Data *_dst, int _index, GElf_Move *_src);
-int		gelf_update_syminfo(Elf_Data *_dst, int _index, GElf_Syminfo *_src);
-
-#endif	/* _GELF_H_ */

loader/src/libelf/gelf_cap.c

@@ -1,151 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_cap.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Cap *
-gelf_getcap(Elf_Data *ed, int ndx, GElf_Cap *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	Elf32_Cap *cap32;
-	Elf64_Cap *cap64;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_CAP) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_CAP, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-
-		cap32 = (Elf32_Cap *) d->d_data.d_buf + ndx;
-
-		dst->c_tag  = cap32->c_tag;
-		dst->c_un.c_val = (Elf64_Xword) cap32->c_un.c_val;
-
-	} else {
-
-		cap64 = (Elf64_Cap *) d->d_data.d_buf + ndx;
-
-		*dst = *cap64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_cap(Elf_Data *ed, int ndx, GElf_Cap *gc)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	Elf32_Cap *cap32;
-	Elf64_Cap *cap64;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || gc == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_CAP) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_CAP, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		cap32 = (Elf32_Cap *) d->d_data.d_buf + ndx;
-
-		LIBELF_COPY_U32(cap32, gc, c_tag);
-		LIBELF_COPY_U32(cap32, gc, c_un.c_val);
-	} else {
-		cap64 = (Elf64_Cap *) d->d_data.d_buf + ndx;
-
-		*cap64 = *gc;
-	}
-
-	return (1);
-}

loader/src/libelf/gelf_checksum.c

@@ -1,58 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_checksum.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-long
-elf32_checksum(Elf *e)
-{
-	return (_libelf_checksum(e, ELFCLASS32));
-}
-
-long
-elf64_checksum(Elf *e)
-{
-	return (_libelf_checksum(e, ELFCLASS64));
-}
-
-long
-gelf_checksum(Elf *e)
-{
-	int ec;
-	if (e == NULL ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0L);
-	}
-	return (_libelf_checksum(e, ec));
-}

loader/src/libelf/gelf_dyn.c

@@ -1,150 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_dyn.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Dyn *
-gelf_getdyn(Elf_Data *ed, int ndx, GElf_Dyn *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	Elf32_Dyn *dyn32;
-	Elf64_Dyn *dyn64;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_DYN) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_DYN, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		dyn32 = (Elf32_Dyn *) d->d_data.d_buf + ndx;
-
-		dst->d_tag      = dyn32->d_tag;
-		dst->d_un.d_val = (Elf64_Xword) dyn32->d_un.d_val;
-
-	} else {
-
-		dyn64 = (Elf64_Dyn *) d->d_data.d_buf + ndx;
-
-		*dst = *dyn64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_dyn(Elf_Data *ed, int ndx, GElf_Dyn *ds)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	Elf32_Dyn *dyn32;
-	Elf64_Dyn *dyn64;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || ds == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_DYN) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_DYN, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		dyn32 = (Elf32_Dyn *) d->d_data.d_buf + ndx;
-
-		LIBELF_COPY_S32(dyn32, ds, d_tag);
-		LIBELF_COPY_U32(dyn32, ds, d_un.d_val);
-	} else {
-		dyn64 = (Elf64_Dyn *) d->d_data.d_buf + ndx;
-
-		*dyn64 = *ds;
-	}
-
-	return (1);
-}

loader/src/libelf/gelf_ehdr.c

@@ -1,168 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <limits.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_ehdr.c 2268 2011-12-03 17:05:11Z jkoshy $");
-
-Elf32_Ehdr *
-elf32_getehdr(Elf *e)
-{
-	return (_libelf_ehdr(e, ELFCLASS32, 0));
-}
-
-Elf64_Ehdr *
-elf64_getehdr(Elf *e)
-{
-	return (_libelf_ehdr(e, ELFCLASS64, 0));
-}
-
-GElf_Ehdr *
-gelf_getehdr(Elf *e, GElf_Ehdr *d)
-{
-	int ec;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-
-	if (d == NULL || e == NULL ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		if ((eh32 = _libelf_ehdr(e, ELFCLASS32, 0)) == NULL)
-			return (NULL);
-
-		(void) memcpy(d->e_ident, eh32->e_ident,
-		    sizeof(eh32->e_ident));
-		d->e_type		= eh32->e_type;
-		d->e_machine		= eh32->e_machine;
-		d->e_version		= eh32->e_version;
-		d->e_entry		= eh32->e_entry;
-		d->e_phoff		= eh32->e_phoff;
-		d->e_shoff		= eh32->e_shoff;
-		d->e_flags		= eh32->e_flags;
-		d->e_ehsize		= eh32->e_ehsize;
-		d->e_phentsize		= eh32->e_phentsize;
-		d->e_phnum		= eh32->e_phnum;
-		d->e_shentsize		= eh32->e_shentsize;
-		d->e_shnum		= eh32->e_shnum;
-		d->e_shstrndx		= eh32->e_shstrndx;
-
-		return (d);
-	}
-
-	assert(ec == ELFCLASS64);
-
-	if ((eh64 = _libelf_ehdr(e, ELFCLASS64, 0)) == NULL)
-		return (NULL);
-	*d = *eh64;
-
-	return (d);
-}
-
-Elf32_Ehdr *
-elf32_newehdr(Elf *e)
-{
-	return (_libelf_ehdr(e, ELFCLASS32, 1));
-}
-
-Elf64_Ehdr *
-elf64_newehdr(Elf *e)
-{
-	return (_libelf_ehdr(e, ELFCLASS64, 1));
-}
-
-void *
-gelf_newehdr(Elf *e, int ec)
-{
-	if (e != NULL &&
-	    (ec == ELFCLASS32 || ec == ELFCLASS64))
-		return (_libelf_ehdr(e, ec, 1));
-
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}
-
-int
-gelf_update_ehdr(Elf *e, GElf_Ehdr *s)
-{
-	int ec;
-	void *ehdr;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-
-	if (s== NULL || e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (e->e_cmd == ELF_C_READ) {
-		LIBELF_SET_ERROR(MODE, 0);
-		return (0);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (0);
-
-	(void) elf_flagehdr(e, ELF_C_SET, ELF_F_DIRTY);
-
-	if (ec == ELFCLASS64) {
-		eh64 = (Elf64_Ehdr *) ehdr;
-		*eh64 = *s;
-		return (1);
-	}
-
-	eh32 = (Elf32_Ehdr *) ehdr;
-
-	(void) memcpy(eh32->e_ident, s->e_ident, sizeof(eh32->e_ident));
-
-	eh32->e_type      = s->e_type;
-	eh32->e_machine   = s->e_machine;
-	eh32->e_version   = s->e_version;
-	LIBELF_COPY_U32(eh32, s, e_entry);
-	LIBELF_COPY_U32(eh32, s, e_phoff);
-	LIBELF_COPY_U32(eh32, s, e_shoff);
-	eh32->e_flags     = s->e_flags;
-	eh32->e_ehsize    = s->e_ehsize;
-	eh32->e_phentsize = s->e_phentsize;
-	eh32->e_phnum     = s->e_phnum;
-	eh32->e_shentsize = s->e_shentsize;
-	eh32->e_shnum     = s->e_shnum;
-	eh32->e_shstrndx  = s->e_shstrndx;
-
-	return (1);
-}

loader/src/libelf/gelf_fsize.c

@@ -1,62 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_fsize.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-size_t
-elf32_fsize(Elf_Type t, size_t c, unsigned int v)
-{
-	return (_libelf_fsize(t, ELFCLASS32, v, c));
-}
-
-size_t
-elf64_fsize(Elf_Type t, size_t c, unsigned int v)
-{
-	return (_libelf_fsize(t, ELFCLASS64, v, c));
-}
-
-size_t
-gelf_fsize(Elf *e, Elf_Type t, size_t c, unsigned int v)
-{
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (e->e_class == ELFCLASS32 || e->e_class == ELFCLASS64)
-		return (_libelf_fsize(t, e->e_class, v, c));
-
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (0);
-}

loader/src/libelf/gelf_getclass.c

@@ -1,39 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_getclass.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-int
-gelf_getclass(Elf *e)
-{
-	return (e != NULL ? e->e_class : ELFCLASSNONE);
-}

loader/src/libelf/gelf_move.c

@@ -1,157 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_move.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Move *
-gelf_getmove(Elf_Data *ed, int ndx, GElf_Move *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Move *move32;
-	Elf64_Move *move64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_MOVE) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_MOVE, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-
-		move32 = (Elf32_Move *) d->d_data.d_buf + ndx;
-
-		dst->m_value   = move32->m_value;
-		dst->m_info    = (Elf64_Xword) move32->m_info;
-		dst->m_poffset = (Elf64_Xword) move32->m_poffset;
-		dst->m_repeat  = move32->m_repeat;
-		dst->m_stride = move32->m_stride;
-	} else {
-
-		move64 = (Elf64_Move *) d->d_data.d_buf + ndx;
-
-		*dst = *move64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_move(Elf_Data *ed, int ndx, GElf_Move *gm)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Move *move32;
-	Elf64_Move *move64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || gm == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_MOVE) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_MOVE, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		move32 = (Elf32_Move *) d->d_data.d_buf + ndx;
-
-		move32->m_value  = gm->m_value;
-		LIBELF_COPY_U32(move32, gm, m_info);
-		LIBELF_COPY_U32(move32, gm, m_poffset);
-		move32->m_repeat  = gm->m_repeat;
-		move32->m_stride = gm->m_stride;
-
-	} else {
-		move64 = (Elf64_Move *) d->d_data.d_buf + ndx;
-
-		*move64 = *gm;
-	}
-
-	return (1);
-}

loader/src/libelf/gelf_phdr.c

@@ -1,178 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-#include <libelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_phdr.c 2268 2011-12-03 17:05:11Z jkoshy $");
-
-Elf32_Phdr *
-elf32_getphdr(Elf *e)
-{
-	return (_libelf_getphdr(e, ELFCLASS32));
-}
-
-Elf64_Phdr *
-elf64_getphdr(Elf *e)
-{
-	return (_libelf_getphdr(e, ELFCLASS64));
-}
-
-GElf_Phdr *
-gelf_getphdr(Elf *e, int index, GElf_Phdr *d)
-{
-	int ec;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-	Elf32_Phdr *ep32;
-	Elf64_Phdr *ep64;
-
-	if (d == NULL || e == NULL ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) ||
-	    (e->e_kind != ELF_K_ELF) || index < 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		if ((eh32 = _libelf_ehdr(e, ELFCLASS32, 0)) == NULL ||
-		    ((ep32 = _libelf_getphdr(e, ELFCLASS32)) == NULL))
-			return (NULL);
-
-		if (index >= eh32->e_phnum) {
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			return (NULL);
-		}
-
-		ep32 += index;
-
-		d->p_type   = ep32->p_type;
-		d->p_offset = ep32->p_offset;
-		d->p_vaddr  = (Elf64_Addr) ep32->p_vaddr;
-		d->p_paddr  = (Elf64_Addr) ep32->p_paddr;
-		d->p_filesz = (Elf64_Xword) ep32->p_filesz;
-		d->p_memsz  = (Elf64_Xword) ep32->p_memsz;
-		d->p_flags  = ep32->p_flags;
-		d->p_align  = (Elf64_Xword) ep32->p_align;
-
-	} else {
-		if ((eh64 = _libelf_ehdr(e, ELFCLASS64, 0)) == NULL ||
-		    (ep64 = _libelf_getphdr(e, ELFCLASS64)) == NULL)
-			return (NULL);
-
-		if (index >= eh64->e_phnum) {
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			return (NULL);
-		}
-
-		ep64 += index;
-
-		*d = *ep64;
-	}
-
-	return (d);
-}
-
-Elf32_Phdr *
-elf32_newphdr(Elf *e, size_t count)
-{
-	return (_libelf_newphdr(e, ELFCLASS32, count));
-}
-
-Elf64_Phdr *
-elf64_newphdr(Elf *e, size_t count)
-{
-	return (_libelf_newphdr(e, ELFCLASS64, count));
-}
-
-void *
-gelf_newphdr(Elf *e, size_t count)
-{
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-	return (_libelf_newphdr(e, e->e_class, count));
-}
-
-int
-gelf_update_phdr(Elf *e, int ndx, GElf_Phdr *s)
-{
-	int ec, phnum;
-	void *ehdr;
-	Elf32_Phdr *ph32;
-	Elf64_Phdr *ph64;
-
-	if (s == NULL || e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (e->e_cmd == ELF_C_READ) {
-		LIBELF_SET_ERROR(MODE, 0);
-		return (0);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (0);
-
-	if (ec == ELFCLASS32)
-		phnum = ((Elf32_Ehdr *) ehdr)->e_phnum;
-	else
-		phnum = ((Elf64_Ehdr *) ehdr)->e_phnum;
-
-	if (ndx < 0 || ndx > phnum) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	(void) elf_flagphdr(e, ELF_C_SET, ELF_F_DIRTY);
-
-	if (ec == ELFCLASS64) {
-		ph64 = e->e_u.e_elf.e_phdr.e_phdr64 + ndx;
-		*ph64 = *s;
-		return (1);
-	}
-
-	ph32 = e->e_u.e_elf.e_phdr.e_phdr32 + ndx;
-
-	ph32->p_type     =  s->p_type;
-	ph32->p_flags    =  s->p_flags;
-	LIBELF_COPY_U32(ph32, s, p_offset);
-	LIBELF_COPY_U32(ph32, s, p_vaddr);
-	LIBELF_COPY_U32(ph32, s, p_paddr);
-	LIBELF_COPY_U32(ph32, s, p_filesz);
-	LIBELF_COPY_U32(ph32, s, p_memsz);
-	LIBELF_COPY_U32(ph32, s, p_align);
-
-	return (1);
-}

loader/src/libelf/gelf_rel.c

@@ -1,159 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_rel.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Rel *
-gelf_getrel(Elf_Data *ed, int ndx, GElf_Rel *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Rel *rel32;
-	Elf64_Rel *rel64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_REL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_REL, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		rel32 = (Elf32_Rel *) d->d_data.d_buf + ndx;
-
-		dst->r_offset = (Elf64_Addr) rel32->r_offset;
-		dst->r_info   = ELF64_R_INFO(
-		    (Elf64_Xword) ELF32_R_SYM(rel32->r_info),
-		    ELF32_R_TYPE(rel32->r_info));
-
-	} else {
-
-		rel64 = (Elf64_Rel *) d->d_data.d_buf + ndx;
-
-		*dst = *rel64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_rel(Elf_Data *ed, int ndx, GElf_Rel *dr)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Rel *rel32;
-	Elf64_Rel *rel64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dr == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_REL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_REL, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		rel32 = (Elf32_Rel *) d->d_data.d_buf + ndx;
-
-		LIBELF_COPY_U32(rel32, dr, r_offset);
-
-		if (ELF64_R_SYM(dr->r_info) > ELF32_R_SYM(~0UL) ||
-		    ELF64_R_TYPE(dr->r_info) > ELF32_R_TYPE(~0U)) {
-			LIBELF_SET_ERROR(RANGE, 0);
-			return (0);
-		}
-		rel32->r_info = ELF32_R_INFO(ELF64_R_SYM(dr->r_info),
-		    ELF64_R_TYPE(dr->r_info));
-	} else {
-		rel64 = (Elf64_Rel *) d->d_data.d_buf + ndx;
-
-		*rel64 = *dr;
-	}
-
-	return (1);
-}

loader/src/libelf/gelf_rela.c

@@ -1,162 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_rela.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Rela *
-gelf_getrela(Elf_Data *ed, int ndx, GElf_Rela *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Rela *rela32;
-	Elf64_Rela *rela64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_RELA) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_RELA, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		rela32 = (Elf32_Rela *) d->d_data.d_buf + ndx;
-
-		dst->r_offset = (Elf64_Addr) rela32->r_offset;
-		dst->r_info   = ELF64_R_INFO(
-		    (Elf64_Xword) ELF32_R_SYM(rela32->r_info),
-		    ELF32_R_TYPE(rela32->r_info));
-		dst->r_addend = (Elf64_Sxword) rela32->r_addend;
-
-	} else {
-
-		rela64 = (Elf64_Rela *) d->d_data.d_buf + ndx;
-
-		*dst = *rela64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_rela(Elf_Data *ed, int ndx, GElf_Rela *dr)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Rela *rela32;
-	Elf64_Rela *rela64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dr == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_RELA) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_RELA, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		rela32 = (Elf32_Rela *) d->d_data.d_buf + ndx;
-
-		LIBELF_COPY_U32(rela32, dr, r_offset);
-
-		if (ELF64_R_SYM(dr->r_info) > ELF32_R_SYM(~0UL) ||
-		    ELF64_R_TYPE(dr->r_info) > ELF32_R_TYPE(~0U)) {
-			LIBELF_SET_ERROR(RANGE, 0);
-			return (0);
-		}
-		rela32->r_info = ELF32_R_INFO(ELF64_R_SYM(dr->r_info),
-		    ELF64_R_TYPE(dr->r_info));
-
-		LIBELF_COPY_S32(rela32, dr, r_addend);
-	} else {
-		rela64 = (Elf64_Rela *) d->d_data.d_buf + ndx;
-
-		*rela64 = *dr;
-	}
-
-	return (1);
-}

loader/src/libelf/gelf_shdr.c

@@ -1,131 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_shdr.c 2268 2011-12-03 17:05:11Z jkoshy $");
-
-Elf32_Shdr *
-elf32_getshdr(Elf_Scn *s)
-{
-	return (_libelf_getshdr(s, ELFCLASS32));
-}
-
-Elf64_Shdr *
-elf64_getshdr(Elf_Scn *s)
-{
-	return (_libelf_getshdr(s, ELFCLASS64));
-}
-
-GElf_Shdr *
-gelf_getshdr(Elf_Scn *s, GElf_Shdr *d)
-{
-	int ec;
-	void *sh;
-	Elf32_Shdr *sh32;
-	Elf64_Shdr *sh64;
-
-	if (d == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((sh = _libelf_getshdr(s, ELFCLASSNONE)) == NULL)
-		return (NULL);
-
-	ec = s->s_elf->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32) {
-		sh32 = (Elf32_Shdr *) sh;
-
-		d->sh_name      = sh32->sh_name;
-		d->sh_type      = sh32->sh_type;
-		d->sh_flags     = (Elf64_Xword) sh32->sh_flags;
-		d->sh_addr      = (Elf64_Addr) sh32->sh_addr;
-		d->sh_offset    = (Elf64_Off) sh32->sh_offset;
-		d->sh_size      = (Elf64_Xword) sh32->sh_size;
-		d->sh_link      = sh32->sh_link;
-		d->sh_info      = sh32->sh_info;
-		d->sh_addralign = (Elf64_Xword) sh32->sh_addralign;
-		d->sh_entsize   = (Elf64_Xword) sh32->sh_entsize;
-	} else {
-		sh64 = (Elf64_Shdr *) sh;
-		*d = *sh64;
-	}
-
-	return (d);
-}
-
-int
-gelf_update_shdr(Elf_Scn *scn, GElf_Shdr *s)
-{
-	int ec;
-	Elf *e;
-	Elf32_Shdr *sh32;
-
-
-	if (s == NULL || scn == NULL || (e = scn->s_elf) == NULL ||
-	    e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (e->e_cmd == ELF_C_READ) {
-		LIBELF_SET_ERROR(MODE, 0);
-		return (0);
-	}
-
-	(void) elf_flagscn(scn, ELF_C_SET, ELF_F_DIRTY);
-
-	if (ec == ELFCLASS64) {
-		scn->s_shdr.s_shdr64 = *s;
-		return (1);
-	}
-
-	sh32 = &scn->s_shdr.s_shdr32;
-
-	sh32->sh_name	 =  s->sh_name;
-	sh32->sh_type	 =  s->sh_type;
-	LIBELF_COPY_U32(sh32, s, sh_flags);
-	LIBELF_COPY_U32(sh32, s, sh_addr);
-	LIBELF_COPY_U32(sh32, s, sh_offset);
-	LIBELF_COPY_U32(sh32, s, sh_size);
-	sh32->sh_link	 =  s->sh_link;
-	sh32->sh_info	 =  s->sh_info;
-	LIBELF_COPY_U32(sh32, s, sh_addralign);
-	LIBELF_COPY_U32(sh32, s, sh_entsize);
-
-	return (1);
-}

loader/src/libelf/gelf_sym.c

@@ -1,160 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_sym.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Sym *
-gelf_getsym(Elf_Data *ed, int ndx, GElf_Sym *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Sym *sym32;
-	Elf64_Sym *sym64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_SYM) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_SYM, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-
-		sym32 = (Elf32_Sym *) d->d_data.d_buf + ndx;
-
-		dst->st_name  = sym32->st_name;
-		dst->st_value = (Elf64_Addr) sym32->st_value;
-		dst->st_size  = (Elf64_Xword) sym32->st_size;
-		dst->st_info  = ELF64_ST_INFO(ELF32_ST_BIND(sym32->st_info),
-		    ELF32_ST_TYPE(sym32->st_info));
-		dst->st_other = sym32->st_other;
-		dst->st_shndx = sym32->st_shndx;
-	} else {
-
-		sym64 = (Elf64_Sym *) d->d_data.d_buf + ndx;
-
-		*dst = *sym64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_sym(Elf_Data *ed, int ndx, GElf_Sym *gs)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Sym *sym32;
-	Elf64_Sym *sym64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || gs == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_SYM) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_SYM, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		sym32 = (Elf32_Sym *) d->d_data.d_buf + ndx;
-
-		sym32->st_name  = gs->st_name;
-		sym32->st_info  = gs->st_info;
-		sym32->st_other = gs->st_other;
-		sym32->st_shndx = gs->st_shndx;
-
-		LIBELF_COPY_U32(sym32, gs, st_value);
-		LIBELF_COPY_U32(sym32, gs, st_size);
-	} else {
-		sym64 = (Elf64_Sym *) d->d_data.d_buf + ndx;
-
-		*sym64 = *gs;
-	}
-
-	return (1);
-}

loader/src/libelf/gelf_syminfo.c

@@ -1,151 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_syminfo.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Syminfo *
-gelf_getsyminfo(Elf_Data *ed, int ndx, GElf_Syminfo *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-	Elf32_Syminfo *syminfo32;
-	Elf64_Syminfo *syminfo64;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_SYMINFO) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_SYMINFO, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-
-		syminfo32 = (Elf32_Syminfo *) d->d_data.d_buf + ndx;
-
-		dst->si_boundto = syminfo32->si_boundto;
-		dst->si_flags   = syminfo32->si_flags;
-
-	} else {
-
-		syminfo64 = (Elf64_Syminfo *) d->d_data.d_buf + ndx;
-
-		*dst = *syminfo64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_syminfo(Elf_Data *ed, int ndx, GElf_Syminfo *gs)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-	Elf32_Syminfo *syminfo32;
-	Elf64_Syminfo *syminfo64;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || gs == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_SYMINFO) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_SYMINFO, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		syminfo32 = (Elf32_Syminfo *) d->d_data.d_buf + ndx;
-
-		syminfo32->si_boundto  = gs->si_boundto;
-		syminfo32->si_flags  = gs->si_flags;
-
-	} else {
-		syminfo64 = (Elf64_Syminfo *) d->d_data.d_buf + ndx;
-
-		*syminfo64 = *gs;
-	}
-
-	return (1);
-}

loader/src/libelf/gelf_symshndx.c

@@ -1,136 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_symshndx.c 2283 2011-12-04 04:07:24Z jkoshy $");
-
-GElf_Sym *
-gelf_getsymshndx(Elf_Data *d, Elf_Data *id, int ndx, GElf_Sym *dst,
-    Elf32_Word *shindex)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	struct _Libelf_Data *ld, *lid;
-
-	ld = (struct _Libelf_Data *) d;
-	lid = (struct _Libelf_Data *) id;
-
-	if (gelf_getsym(d, ndx, dst) == 0)
-		return (NULL);
-
-	if (lid == NULL || (scn = lid->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL || (e != ld->d_scn->s_elf) ||
-	    shindex == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_WORD ||
-	   id->d_type != ELF_T_WORD) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_WORD, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= id->d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	*shindex = ((Elf32_Word *) id->d_buf)[ndx];
-
-	return (dst);
-}
-
-int
-gelf_update_symshndx(Elf_Data *d, Elf_Data *id, int ndx, GElf_Sym *gs,
-    Elf32_Word xindex)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	struct _Libelf_Data *ld, *lid;
-
-	ld = (struct _Libelf_Data *) d;
-	lid = (struct _Libelf_Data *) id;
-
-	if (gelf_update_sym(d, ndx, gs) == 0)
-		return (0);
-
-	if (lid == NULL || (scn = lid->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL || (e != ld->d_scn->s_elf)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_WORD ||
-	    d->d_type != ELF_T_WORD) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_WORD, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= id->d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	*(((Elf32_Word *) id->d_buf) + ndx) = xindex;
-
-	return (1);
-}

loader/src/libelf/gelf_xlate.c

@@ -1,81 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-#include <libelf.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_xlate.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Data *
-elf32_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
-{
-	return _libelf_xlate(dst, src, encoding, ELFCLASS32, ELF_TOFILE);
-}
-
-Elf_Data *
-elf64_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
-{
-	return _libelf_xlate(dst, src, encoding, ELFCLASS64, ELF_TOFILE);
-}
-
-Elf_Data *
-elf32_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
-{
-	return _libelf_xlate(dst, src, encoding, ELFCLASS32, ELF_TOMEMORY);
-}
-
-Elf_Data *
-elf64_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
-{
-	return _libelf_xlate(dst, src, encoding, ELFCLASS64, ELF_TOMEMORY);
-}
-
-Elf_Data *
-gelf_xlatetom(Elf *e, Elf_Data *dst, const Elf_Data *src,
-    unsigned int encoding)
-{
-	if (e != NULL)
-		return (_libelf_xlate(dst, src, encoding, e->e_class,
-		    ELF_TOMEMORY));
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}
-
-Elf_Data *
-gelf_xlatetof(Elf *e, Elf_Data *dst, const Elf_Data *src,
-    unsigned int encoding)
-{
-	if (e != NULL)
-		return (_libelf_xlate(dst, src, encoding, e->e_class,
-		    ELF_TOFILE));
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}

loader/src/libelf/libelf.h

@@ -1,250 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- *
- * $Id: libelf.h 2366 2011-12-29 06:12:14Z jkoshy $
- */
-
-#ifndef	_LIBELF_H_
-#define	_LIBELF_H_
-
-#include <sys/types.h>
-
-#include <elfdefinitions.h>
-
-/* Library private data structures */
-typedef struct _Elf Elf;
-typedef struct _Elf_Scn Elf_Scn;
-
-/* File types */
-typedef enum {
-	ELF_K_NONE = 0,
-	ELF_K_AR,	/* `ar' archives */
-	ELF_K_COFF,	/* COFF files (unsupported) */
-	ELF_K_ELF,	/* ELF files */
-	ELF_K_NUM
-} Elf_Kind;
-
-#define	ELF_K_FIRST	ELF_K_NONE
-#define	ELF_K_LAST	ELF_K_NUM
-
-/* Data types */
-typedef enum {
-	ELF_T_ADDR,
-	ELF_T_BYTE,
-	ELF_T_CAP,
-	ELF_T_DYN,
-	ELF_T_EHDR,
-	ELF_T_HALF,
-	ELF_T_LWORD,
-	ELF_T_MOVE,
-	ELF_T_MOVEP,
-	ELF_T_NOTE,
-	ELF_T_OFF,
-	ELF_T_PHDR,
-	ELF_T_REL,
-	ELF_T_RELA,
-	ELF_T_SHDR,
-	ELF_T_SWORD,
-	ELF_T_SXWORD,
-	ELF_T_SYMINFO,
-	ELF_T_SYM,
-	ELF_T_VDEF,
-	ELF_T_VNEED,
-	ELF_T_WORD,
-	ELF_T_XWORD,
-	ELF_T_GNUHASH,	/* GNU style hash tables. */
-	ELF_T_NUM
-} Elf_Type;
-
-#define	ELF_T_FIRST	ELF_T_ADDR
-#define	ELF_T_LAST	ELF_T_GNUHASH
-
-/* Commands */
-typedef enum {
-	ELF_C_NULL = 0,
-	ELF_C_CLR,
-	ELF_C_FDDONE,
-	ELF_C_FDREAD,
-	ELF_C_RDWR,
-	ELF_C_READ,
-	ELF_C_SET,
-	ELF_C_WRITE,
-	ELF_C_NUM
-} Elf_Cmd;
-
-#define	ELF_C_FIRST	ELF_C_NULL
-#define	ELF_C_LAST	ELF_C_NUM
-
-/*
- * An `Elf_Data' structure describes data in an
- * ELF section.
- */
-typedef struct _Elf_Data {
-	/*
-	 * `Public' members that are part of the ELF(3) API.
-	 */
-	uint64_t	d_align;
-	void		*d_buf;
-	uint64_t	d_off;
-	uint64_t	d_size;
-	Elf_Type	d_type;
-	unsigned int	d_version;
-} Elf_Data;
-
-/*
- * An `Elf_Arhdr' structure describes an archive
- * header.
- */
-typedef struct {
-	time_t		ar_date;
-	char		*ar_name;	/* archive member name */
-	gid_t		ar_gid;
-	mode_t		ar_mode;
-	char		*ar_rawname;	/* 'raw' member name */
-	size_t		ar_size;
-	uid_t		ar_uid;
-
-	/*
-	 * Members that are not part of the public API.
-	 */
-	int		ar_flags;
-} Elf_Arhdr;
-
-/*
- * An `Elf_Arsym' describes an entry in the archive
- * symbol table.
- */
-typedef struct {
-	off_t		as_off;		/* byte offset to member's header */
-	unsigned long	as_hash;	/* elf_hash() value for name */
-	char		*as_name; 	/* null terminated symbol name */
-} Elf_Arsym;
-
-/*
- * Error numbers.
- */
-
-enum Elf_Error {
-	ELF_E_NONE,	/* No error */
-	ELF_E_ARCHIVE,	/* Malformed ar(1) archive */
-	ELF_E_ARGUMENT,	/* Invalid argument */
-	ELF_E_CLASS,	/* Mismatched ELF class */
-	ELF_E_DATA,	/* Invalid data descriptor */
-	ELF_E_HEADER,	/* Missing or malformed ELF header */
-	ELF_E_IO,	/* I/O error */
-	ELF_E_LAYOUT,	/* Layout constraint violation */
-	ELF_E_MODE,	/* Wrong mode for ELF descriptor */
-	ELF_E_RANGE,	/* Value out of range */
-	ELF_E_RESOURCE,	/* Resource exhaustion */
-	ELF_E_SECTION,	/* Invalid section descriptor */
-	ELF_E_SEQUENCE,	/* API calls out of sequence */
-	ELF_E_UNIMPL,	/* Feature is unimplemented */
-	ELF_E_VERSION,	/* Unknown API version */
-	ELF_E_NUM	/* Max error number */
-};
-
-/*
- * Flags defined by the API.
- */
-
-#define	ELF_F_LAYOUT	0x001U	/* application will layout the file */
-#define	ELF_F_DIRTY	0x002U	/* a section or ELF file is dirty */
-
-/* ELF(3) API extensions. */
-#define	ELF_F_ARCHIVE	   0x100U /* archive creation */
-#define	ELF_F_ARCHIVE_SYSV 0x200U /* SYSV style archive */
-
-Elf		*elf_begin(int _fd, Elf_Cmd _cmd, Elf *_elf);
-int		elf_cntl(Elf *_elf, Elf_Cmd _cmd);
-int		elf_end(Elf *_elf);
-const char	*elf_errmsg(int _error);
-int		elf_errno(void);
-void		elf_fill(int _fill);
-unsigned int	elf_flagarhdr(Elf_Arhdr *_arh, Elf_Cmd _cmd,
-			unsigned int _flags);
-unsigned int	elf_flagdata(Elf_Data *_data, Elf_Cmd _cmd,
-			unsigned int _flags);
-unsigned int	elf_flagehdr(Elf *_elf, Elf_Cmd _cmd, unsigned int _flags);
-unsigned int	elf_flagelf(Elf *_elf, Elf_Cmd _cmd, unsigned int _flags);
-unsigned int	elf_flagphdr(Elf *_elf, Elf_Cmd _cmd, unsigned int _flags);
-unsigned int	elf_flagscn(Elf_Scn *_scn, Elf_Cmd _cmd, unsigned int _flags);
-unsigned int	elf_flagshdr(Elf_Scn *_scn, Elf_Cmd _cmd, unsigned int _flags);
-Elf_Arhdr	*elf_getarhdr(Elf *_elf);
-Elf_Arsym	*elf_getarsym(Elf *_elf, size_t *_ptr);
-off_t		elf_getbase(Elf *_elf);
-Elf_Data	*elf_getdata(Elf_Scn *, Elf_Data *);
-char		*elf_getident(Elf *_elf, size_t *_ptr);
-int		elf_getphdrnum(Elf *_elf, size_t *_dst);
-int		elf_getphnum(Elf *_elf, size_t *_dst);	/* Deprecated */
-Elf_Scn		*elf_getscn(Elf *_elf, size_t _index);
-int		elf_getshdrnum(Elf *_elf, size_t *_dst);
-int		elf_getshnum(Elf *_elf, size_t *_dst);	/* Deprecated */
-int		elf_getshdrstrndx(Elf *_elf, size_t *_dst);
-int		elf_getshstrndx(Elf *_elf, size_t *_dst); /* Deprecated */
-unsigned long	elf_hash(const char *_name);
-Elf_Kind	elf_kind(Elf *_elf);
-Elf		*elf_memory(char *_image, size_t _size);
-size_t		elf_ndxscn(Elf_Scn *_scn);
-Elf_Data	*elf_newdata(Elf_Scn *_scn);
-Elf_Scn		*elf_newscn(Elf *_elf);
-Elf_Scn		*elf_nextscn(Elf *_elf, Elf_Scn *_scn);
-Elf_Cmd		elf_next(Elf *_elf);
-Elf		*elf_open(int _fd);
-Elf		*elf_openmemory(char *_image, size_t _size);
-off_t		elf_rand(Elf *_elf, off_t _off);
-Elf_Data	*elf_rawdata(Elf_Scn *_scn, Elf_Data *_data);
-char		*elf_rawfile(Elf *_elf, size_t *_size);
-int		elf_setshstrndx(Elf *_elf, size_t _shnum);
-char		*elf_strptr(Elf *_elf, size_t _section, size_t _offset);
-off_t		elf_update(Elf *_elf, Elf_Cmd _cmd);
-unsigned int	elf_version(unsigned int _version);
-
-long		elf32_checksum(Elf *_elf);
-size_t		elf32_fsize(Elf_Type _type, size_t _count,
-			unsigned int _version);
-Elf32_Ehdr	*elf32_getehdr(Elf *_elf);
-Elf32_Phdr	*elf32_getphdr(Elf *_elf);
-Elf32_Shdr	*elf32_getshdr(Elf_Scn *_scn);
-Elf32_Ehdr	*elf32_newehdr(Elf *_elf);
-Elf32_Phdr	*elf32_newphdr(Elf *_elf, size_t _count);
-Elf_Data	*elf32_xlatetof(Elf_Data *_dst, const Elf_Data *_src,
-			unsigned int _enc);
-Elf_Data	*elf32_xlatetom(Elf_Data *_dst, const Elf_Data *_src,
-			unsigned int _enc);
-
-long		elf64_checksum(Elf *_elf);
-size_t		elf64_fsize(Elf_Type _type, size_t _count,
-			unsigned int _version);
-Elf64_Ehdr	*elf64_getehdr(Elf *_elf);
-Elf64_Phdr	*elf64_getphdr(Elf *_elf);
-Elf64_Shdr	*elf64_getshdr(Elf_Scn *_scn);
-Elf64_Ehdr	*elf64_newehdr(Elf *_elf);
-Elf64_Phdr	*elf64_newphdr(Elf *_elf, size_t _count);
-Elf_Data	*elf64_xlatetof(Elf_Data *_dst, const Elf_Data *_src,
-			unsigned int _enc);
-Elf_Data	*elf64_xlatetom(Elf_Data *_dst, const Elf_Data *_src,
-			unsigned int _enc);
-
-#endif	/* _LIBELF_H_ */

loader/src/libelf/libelf_align.c

@@ -1,137 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <sys/types.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_align.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-struct align {
-	int a32;
-	int a64;
-};
-
-#ifdef	__GNUC__
-#define	MALIGN(N)	{					\
-		.a32 = __alignof__(Elf32_##N),			\
-		.a64 = __alignof__(Elf64_##N)			\
-	}
-#define	MALIGN64(V)	  {					\
-		.a32 = 0,					\
-		.a64 = __alignof__(Elf64_##V)			\
-	}
-#define	MALIGN_WORD()	{					\
-		.a32 = __alignof__(int32_t),			\
-		.a64 = __alignof__(int64_t)			\
-	    }
-#else
-#error	Need the __alignof__ builtin.
-#endif
-#define	UNSUPPORTED()	{					\
-		.a32 = 0,					\
-		.a64 = 0					\
-	}
-
-static struct align malign[ELF_T_NUM] = {
-	[ELF_T_ADDR]	= MALIGN(Addr),
-	[ELF_T_BYTE]	= { .a32 = 1, .a64 = 1 },
-	[ELF_T_CAP]	= MALIGN(Cap),
-	[ELF_T_DYN]	= MALIGN(Dyn),
-	[ELF_T_EHDR]	= MALIGN(Ehdr),
-	[ELF_T_HALF]	= MALIGN(Half),
-	[ELF_T_LWORD]	= MALIGN(Lword),
-	[ELF_T_MOVE]	= MALIGN(Move),
-	[ELF_T_MOVEP] 	= UNSUPPORTED(),
-	[ELF_T_NOTE]	= MALIGN(Nhdr),
-	[ELF_T_OFF]	= MALIGN(Off),
-	[ELF_T_PHDR]	= MALIGN(Phdr),
-	[ELF_T_REL]	= MALIGN(Rel),
-	[ELF_T_RELA]	= MALIGN(Rela),
-	[ELF_T_SHDR]	= MALIGN(Shdr),
-	[ELF_T_SWORD]	= MALIGN(Sword),
-	[ELF_T_SXWORD]	= MALIGN64(Sxword),
-	[ELF_T_SYM]	= MALIGN(Sym),
-	[ELF_T_SYMINFO]	= MALIGN(Syminfo),
-	[ELF_T_VDEF]	= MALIGN(Verdef),
-	[ELF_T_VNEED]	= MALIGN(Verneed),
-	[ELF_T_WORD]	= MALIGN(Word),
-	[ELF_T_XWORD]	= MALIGN64(Xword),
-	[ELF_T_GNUHASH] = MALIGN_WORD()
-};
-
-int
-_libelf_malign(Elf_Type t, int elfclass)
-{
-	if (t >= ELF_T_NUM || (int) t < 0)
-		return (0);
-
-	return (elfclass == ELFCLASS32 ? malign[t].a32 :
-	    malign[t].a64);
-}
-
-#define	FALIGN(A32,A64)	{ .a32 = (A32), .a64 = (A64) }
-
-static struct align falign[ELF_T_NUM] = {
-	[ELF_T_ADDR]	= FALIGN(4,8),
-	[ELF_T_BYTE]	= FALIGN(1,1),
-	[ELF_T_CAP]	= FALIGN(4,8),
-	[ELF_T_DYN]	= FALIGN(4,8),
-	[ELF_T_EHDR]	= FALIGN(4,8),
-	[ELF_T_HALF]	= FALIGN(2,2),
-	[ELF_T_LWORD]	= FALIGN(8,8),
-	[ELF_T_MOVE]	= FALIGN(8,8),
-	[ELF_T_MOVEP] 	= UNSUPPORTED(),
-	[ELF_T_NOTE]	= FALIGN(4,4),
-	[ELF_T_OFF]	= FALIGN(4,8),
-	[ELF_T_PHDR]	= FALIGN(4,8),
-	[ELF_T_REL]	= FALIGN(4,8),
-	[ELF_T_RELA]	= FALIGN(4,8),
-	[ELF_T_SHDR]	= FALIGN(4,8),
-	[ELF_T_SWORD]	= FALIGN(4,4),
-	[ELF_T_SXWORD]	= FALIGN(0,8),
-	[ELF_T_SYM]	= FALIGN(4,8),
-	[ELF_T_SYMINFO]	= FALIGN(2,2),
-	[ELF_T_VDEF]	= FALIGN(4,4),
-	[ELF_T_VNEED]	= FALIGN(4,4),
-	[ELF_T_WORD]	= FALIGN(4,4),
-	[ELF_T_XWORD]	= FALIGN(0,8),
-	[ELF_T_GNUHASH] = FALIGN(4,8)
-};
-
-int
-_libelf_falign(Elf_Type t, int elfclass)
-{
-	if (t >= ELF_T_NUM || (int) t < 0)
-		return (0);
-
-	return (elfclass == ELFCLASS32 ? falign[t].a32 :
-	    falign[t].a64);
-}

loader/src/libelf/libelf_allocate.c

@@ -1,212 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-/*
- * Internal APIs
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <libelf.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_allocate.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-Elf *
-_libelf_allocate_elf(void)
-{
-	Elf *e;
-
-	if ((e = malloc(sizeof(*e))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, errno);
-		return NULL;
-	}
-
-	e->e_activations = 1;
-	e->e_hdr.e_rawhdr = NULL;
-	e->e_byteorder   = ELFDATANONE;
-	e->e_class       = ELFCLASSNONE;
-	e->e_cmd         = ELF_C_NULL;
-	e->e_fd          = -1;
-	e->e_flags	 = 0;
-	e->e_kind        = ELF_K_NONE;
-	e->e_parent      = NULL;
-	e->e_rawfile     = NULL;
-	e->e_rawsize     = 0;
-	e->e_version     = LIBELF_PRIVATE(version);
-
-	(void) memset(&e->e_u, 0, sizeof(e->e_u));
-
-	return (e);
-}
-
-void
-_libelf_init_elf(Elf *e, Elf_Kind kind)
-{
-	assert(e != NULL);
-	assert(e->e_kind == ELF_K_NONE);
-
-	e->e_kind = kind;
-
-	switch (kind) {
-	case ELF_K_ELF:
-		STAILQ_INIT(&e->e_u.e_elf.e_scn);
-		break;
-	default:
-		break;
-	}
-}
-
-#define	FREE(P)		do {				\
-		if (P)					\
-			free(P);			\
-	} while (0)
-
-
-Elf *
-_libelf_release_elf(Elf *e)
-{
-	Elf_Arhdr *arh;
-
-	switch (e->e_kind) {
-	case ELF_K_AR:
-		FREE(e->e_u.e_ar.e_symtab);
-		break;
-
-	case ELF_K_ELF:
-		switch (e->e_class) {
-		case ELFCLASS32:
-			FREE(e->e_u.e_elf.e_ehdr.e_ehdr32);
-			FREE(e->e_u.e_elf.e_phdr.e_phdr32);
-			break;
-		case ELFCLASS64:
-			FREE(e->e_u.e_elf.e_ehdr.e_ehdr64);
-			FREE(e->e_u.e_elf.e_phdr.e_phdr64);
-			break;
-		}
-
-		assert(STAILQ_EMPTY(&e->e_u.e_elf.e_scn));
-
-		if (e->e_flags & LIBELF_F_AR_HEADER) {
-			arh = e->e_hdr.e_arhdr;
-			FREE(arh->ar_name);
-			FREE(arh->ar_rawname);
-			free(arh);
-		}
-
-		break;
-
-	default:
-		break;
-	}
-
-	free(e);
-
-	return (NULL);
-}
-
-struct _Libelf_Data *
-_libelf_allocate_data(Elf_Scn *s)
-{
-	struct _Libelf_Data *d;
-
-	if ((d = calloc((size_t) 1, sizeof(*d))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	d->d_scn = s;
-
-	return (d);
-}
-
-struct _Libelf_Data *
-_libelf_release_data(struct _Libelf_Data *d)
-{
-
-	if (d->d_flags & LIBELF_F_DATA_MALLOCED)
-		free(d->d_data.d_buf);
-
-	free(d);
-
-	return (NULL);
-}
-
-Elf_Scn *
-_libelf_allocate_scn(Elf *e, size_t ndx)
-{
-	Elf_Scn *s;
-
-	if ((s = calloc((size_t) 1, sizeof(Elf_Scn))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, errno);
-		return (NULL);
-	}
-
-	s->s_elf = e;
-	s->s_ndx = ndx;
-
-	STAILQ_INIT(&s->s_data);
-	STAILQ_INIT(&s->s_rawdata);
-
-	STAILQ_INSERT_TAIL(&e->e_u.e_elf.e_scn, s, s_next);
-
-	return (s);
-}
-
-Elf_Scn *
-_libelf_release_scn(Elf_Scn *s)
-{
-	Elf *e;
-	struct _Libelf_Data *d, *td;
-
-	assert(s != NULL);
-
-	STAILQ_FOREACH_SAFE(d, &s->s_data, d_next, td) {
-		STAILQ_REMOVE(&s->s_data, d, _Libelf_Data, d_next);
-		d = _libelf_release_data(d);
-	}
-
-	STAILQ_FOREACH_SAFE(d, &s->s_rawdata, d_next, td) {
-		assert((d->d_flags & LIBELF_F_DATA_MALLOCED) == 0);
-		STAILQ_REMOVE(&s->s_rawdata, d, _Libelf_Data, d_next);
-		d = _libelf_release_data(d);
-	}
-
-	e = s->s_elf;
-
-	assert(e != NULL);
-
-	STAILQ_REMOVE(&e->e_u.e_elf.e_scn, s, _Elf_Scn, s_next);
-
-	free(s);
-
-	return (NULL);
-}

loader/src/libelf/libelf_ar.c

@@ -1,461 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <ctype.h>
-#include <libelf.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "_libelf.h"
-#include "_libelf_ar.h"
-
-ELFTC_VCSID("$Id: libelf_ar.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-#define	LIBELF_NALLOC_SIZE	16
-
-/*
- * `ar' archive handling.
- *
- * `ar' archives start with signature `ARMAG'.  Each archive member is
- * preceded by a header containing meta-data for the member.  This
- * header is described in <ar.h> (struct ar_hdr).  The header always
- * starts on an even address.  File data is padded with "\n"
- * characters to keep this invariant.
- *
- * Special considerations for `ar' archives:
- *
- * There are two variants of the `ar' archive format: traditional BSD
- * and SVR4.  These differ in the way long file names are treated, and
- * in the layout of the archive symbol table.
- *
- * The `ar' header only has space for a 16 character file name.
- *
- * In the SVR4 format, file names are terminated with a '/', so this
- * effectively leaves 15 characters for the actual file name.  Longer
- * file names stored in a separate 'string table' and referenced
- * indirectly from the name field.  The string table itself appears as
- * an archive member with name "// ".  An `indirect' file name in an
- * `ar' header matches the pattern "/[0-9]*". The digits form a
- * decimal number that corresponds to a byte offset into the string
- * table where the actual file name of the object starts.  Strings in
- * the string table are padded to start on even addresses.
- *
- * In the BSD format, file names can be upto 16 characters.  File
- * names shorter than 16 characters are padded to 16 characters using
- * (ASCII) space characters.  File names with embedded spaces and file
- * names longer than 16 characters are stored immediately after the
- * archive header and the name field set to a special indirect name
- * matching the pattern "#1/[0-9]+".  The digits form a decimal number
- * that corresponds to the actual length of the file name following
- * the archive header.  The content of the archive member immediately
- * follows the file name, and the size field of the archive member
- * holds the sum of the sizes of the member and of the appended file
- * name.
- *
- * Archives may also have a symbol table (see ranlib(1)), mapping
- * program symbols to object files inside the archive.
- *
- * In the SVR4 format, a symbol table uses a file name of "/ " in its
- * archive header.  The symbol table is structured as:
- *  - a 4-byte count of entries stored as a binary value, MSB first
- *  - 'n' 4-byte offsets, stored as binary values, MSB first
- *  - 'n' NUL-terminated strings, for ELF symbol names, stored unpadded.
- *
- * In the BSD format, the symbol table uses a file name of "__.SYMDEF".
- * It is structured as two parts:
- *  - The first part is an array of "ranlib" structures preceded by
- *    the size of the array in bytes.  Each "ranlib" structure
- *    describes one symbol.  Each structure contains an offset into
- *    the string table for the symbol name, and a file offset into the
- *    archive for the member defining the symbol.
- *  - The second part is a string table containing NUL-terminated
- *    strings, preceded by the size of the string table in bytes.
- *
- * If the symbol table and string table are is present in an archive
- * they must be the very first objects and in that order.
- */
-
-
-/*
- * Retrieve an archive header descriptor.
- */
-
-Elf_Arhdr *
-_libelf_ar_gethdr(Elf *e)
-{
-	Elf *parent;
-	char *namelen;
-	Elf_Arhdr *eh;
-	size_t n, nlen;
-	struct ar_hdr *arh;
-
-	if ((parent = e->e_parent) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	assert((e->e_flags & LIBELF_F_AR_HEADER) == 0);
-
-	arh = (struct ar_hdr *) (uintptr_t) e->e_hdr.e_rawhdr;
-
-	assert((uintptr_t) arh >= (uintptr_t) parent->e_rawfile + SARMAG);
-	assert((uintptr_t) arh <= (uintptr_t) parent->e_rawfile +
-	    parent->e_rawsize - sizeof(struct ar_hdr));
-
-	if ((eh = malloc(sizeof(Elf_Arhdr))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	e->e_hdr.e_arhdr = eh;
-	e->e_flags |= LIBELF_F_AR_HEADER;
-
-	eh->ar_name = eh->ar_rawname = NULL;
-
-	if ((eh->ar_name = _libelf_ar_get_translated_name(arh, parent)) ==
-	    NULL)
-		goto error;
-
-	if (_libelf_ar_get_number(arh->ar_uid, sizeof(arh->ar_uid), 10,
-	    &n) == 0)
-		goto error;
-	eh->ar_uid = (uid_t) n;
-
-	if (_libelf_ar_get_number(arh->ar_gid, sizeof(arh->ar_gid), 10,
-	    &n) == 0)
-		goto error;
-	eh->ar_gid = (gid_t) n;
-
-	if (_libelf_ar_get_number(arh->ar_mode, sizeof(arh->ar_mode), 8,
-	    &n) == 0)
-		goto error;
-	eh->ar_mode = (mode_t) n;
-
-	if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10,
-	    &n) == 0)
-		goto error;
-
-	/*
-	 * Get the true size of the member if extended naming is being used.
-	 */
-	if (IS_EXTENDED_BSD_NAME(arh->ar_name)) {
-		namelen = arh->ar_name +
-		    LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE;
-		if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) -
-		    LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nlen) == 0)
-			goto error;
-		n -= nlen;
-	}
-
-	eh->ar_size = n;
-
-	if ((eh->ar_rawname = _libelf_ar_get_raw_name(arh)) == NULL)
-		goto error;
-
-	eh->ar_flags = 0;
-
-	return (eh);
-
- error:
-	if (eh) {
-		if (eh->ar_name)
-			free(eh->ar_name);
-		if (eh->ar_rawname)
-			free(eh->ar_rawname);
-		free(eh);
-	}
-
-	e->e_flags &= ~LIBELF_F_AR_HEADER;
-	e->e_hdr.e_rawhdr = (char *) arh;
-
-	return (NULL);
-}
-
-Elf *
-_libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf)
-{
-	Elf *e;
-	char *member, *namelen;
-	size_t nsz, sz;
-	off_t next;
-	struct ar_hdr *arh;
-
-	assert(elf->e_kind == ELF_K_AR);
-
-	next = elf->e_u.e_ar.e_next;
-
-	/*
-	 * `next' is only set to zero by elf_next() when the last
-	 * member of an archive is processed.
-	 */
-	if (next == (off_t) 0)
-		return (NULL);
-
-	assert((next & 1) == 0);
-
-	arh = (struct ar_hdr *) (elf->e_rawfile + next);
-
-	/*
-	 * Retrieve the size of the member.
-	 */
-	if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10,
-	    &sz) == 0) {
-		LIBELF_SET_ERROR(ARCHIVE, 0);
-		return (NULL);
-	}
-
-	/*
-	 * Adjust the size field for members in BSD archives using
-	 * extended naming.
-	 */
-	if (IS_EXTENDED_BSD_NAME(arh->ar_name)) {
-		namelen = arh->ar_name +
-		    LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE;
-		if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) -
-		    LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nsz) == 0) {
-			LIBELF_SET_ERROR(ARCHIVE, 0);
-			return (NULL);
-		}
-
-		member = (char *) (arh + 1) + nsz;
-		sz -= nsz;
-	} else
-		member = (char *) (arh + 1);
-
-
-	if ((e = elf_memory((char *) member, sz)) == NULL)
-		return (NULL);
-
-	e->e_fd = fd;
-	e->e_cmd = c;
-	e->e_hdr.e_rawhdr = (char *) arh;
-
-	elf->e_u.e_ar.e_nchildren++;
-	e->e_parent = elf;
-
-	return (e);
-}
-
-/*
- * A BSD-style ar(1) symbol table has the following layout:
- *
- * - A count of bytes used by the following array of 'ranlib'
- *   structures, stored as a 'long'.
- * - An array of 'ranlib' structures.  Each array element is
- *   two 'long's in size.
- * - A count of bytes used for the following symbol table.
- * - The symbol table itself.
- */
-
-/*
- * A helper macro to read in a 'long' value from the archive.  We use
- * memcpy() since the source pointer may be misaligned with respect to
- * the natural alignment for a C 'long'.
- */
-#define	GET_LONG(P, V)do {				\
-		memcpy(&(V), (P), sizeof(long));	\
-		(P) += sizeof(long);			\
-	} while (0)
-
-Elf_Arsym *
-_libelf_ar_process_bsd_symtab(Elf *e, size_t *count)
-{
-	Elf_Arsym *symtab, *sym;
-	unsigned char *end, *p, *p0, *s, *s0;
-	const unsigned int entrysize = 2 * sizeof(long);
-	long arraysize, fileoffset, n, nentries, stroffset, strtabsize;
-
-	assert(e != NULL);
-	assert(count != NULL);
-	assert(e->e_u.e_ar.e_symtab == NULL);
-
-	symtab = NULL;
-
-	/*
-	 * The BSD symbol table always contains the count fields even
-	 * if there are no entries in it.
-	 */
-	if (e->e_u.e_ar.e_rawsymtabsz < 2 * sizeof(long))
-		goto symtaberror;
-
-	p = p0 = (unsigned char *) e->e_u.e_ar.e_rawsymtab;
-	end = p0 + e->e_u.e_ar.e_rawsymtabsz;
-
-	/*
-	 * Retrieve the size of the array of ranlib descriptors and
-	 * check it for validity.
-	 */
-	GET_LONG(p, arraysize);
-
-	if (p0 + arraysize >= end || (arraysize % entrysize != 0))
-		goto symtaberror;
-
-	/*
-	 * Check the value of the string table size.
-	 */
-	s = p + arraysize;
-	GET_LONG(s, strtabsize);
-
-	s0 = s;			/* Start of string table. */
-	if (s0 + strtabsize > end)
-		goto symtaberror;
-
-	nentries = arraysize / entrysize;
-
-	/*
-	 * Allocate space for the returned Elf_Arsym array.
-	 */
-	if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries + 1))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	/* Read in symbol table entries. */
-	for (n = 0, sym = symtab; n < nentries; n++, sym++) {
-		GET_LONG(p, stroffset);
-		GET_LONG(p, fileoffset);
-
-		s = s0 + stroffset;
-
-		if (s >= end)
-			goto symtaberror;
-
-		sym->as_off = fileoffset;
-		sym->as_hash = elf_hash((char *) s);
-		sym->as_name = (char *) s;
-	}
-
-	/* Fill up the sentinel entry. */
-	sym->as_name = NULL;
-	sym->as_hash = ~0UL;
-	sym->as_off = (off_t) 0;
-
-	/* Remember the processed symbol table. */
-	e->e_u.e_ar.e_symtab = symtab;
-
-	*count = e->e_u.e_ar.e_symtabsz = nentries + 1;
-
-	return (symtab);
-
-symtaberror:
-	if (symtab)
-		free(symtab);
-	LIBELF_SET_ERROR(ARCHIVE, 0);
-	return (NULL);
-}
-
-/*
- * An SVR4-style ar(1) symbol table has the following layout:
- *
- * - The first 4 bytes are a binary count of the number of entries in the
- *   symbol table, stored MSB-first.
- * - Then there are 'n' 4-byte binary offsets, also stored MSB first.
- * - Following this, there are 'n' null-terminated strings.
- */
-
-#define	GET_WORD(P, V) do {			\
-		(V) = 0;			\
-		(V) = (P)[0]; (V) <<= 8;	\
-		(V) += (P)[1]; (V) <<= 8;	\
-		(V) += (P)[2]; (V) <<= 8;	\
-		(V) += (P)[3];			\
-	} while (0)
-
-#define	INTSZ	4
-
-
-Elf_Arsym *
-_libelf_ar_process_svr4_symtab(Elf *e, size_t *count)
-{
-	size_t n, nentries, off;
-	Elf_Arsym *symtab, *sym;
-	unsigned char *p, *s, *end;
-
-	assert(e != NULL);
-	assert(count != NULL);
-	assert(e->e_u.e_ar.e_symtab == NULL);
-
-	symtab = NULL;
-
-	if (e->e_u.e_ar.e_rawsymtabsz < INTSZ)
-		goto symtaberror;
-
-	p = (unsigned char *) e->e_u.e_ar.e_rawsymtab;
-	end = p + e->e_u.e_ar.e_rawsymtabsz;
-
-	GET_WORD(p, nentries);
-	p += INTSZ;
-
-	if (nentries == 0 || p + nentries * INTSZ >= end)
-		goto symtaberror;
-
-	/* Allocate space for a nentries + a sentinel. */
-	if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	s = p + (nentries * INTSZ); /* start of the string table. */
-
-	for (n = nentries, sym = symtab; n > 0; n--) {
-
-		if (s >= end)
-			goto symtaberror;
-
-		off = 0;
-
-		GET_WORD(p, off);
-
-		sym->as_off = off;
-		sym->as_hash = elf_hash((char *) s);
-		sym->as_name = (char *) s;
-
-		p += INTSZ;
-		sym++;
-
-		for (; s < end && *s++ != '\0';) /* skip to next string */
-			;
-	}
-
-	/* Fill up the sentinel entry. */
-	sym->as_name = NULL;
-	sym->as_hash = ~0UL;
-	sym->as_off = (off_t) 0;
-
-	*count = e->e_u.e_ar.e_symtabsz = nentries + 1;
-	e->e_u.e_ar.e_symtab = symtab;
-
-	return (symtab);
-
-symtaberror:
-	if (symtab)
-		free(symtab);
-	LIBELF_SET_ERROR(ARCHIVE, 0);
-	return (NULL);
-}

loader/src/libelf/libelf_ar_util.c

@@ -1,359 +0,0 @@
-/*-
- * Copyright (c) 2006,2009,2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "_libelf.h"
-#include "_libelf_ar.h"
-
-ELFTC_VCSID("$Id: libelf_ar_util.c 2365 2011-12-29 04:36:44Z jkoshy $");
-
-/*
- * Convert a string bounded by `start' and `start+sz' (exclusive) to a
- * number in the specified base.
- */
-int
-_libelf_ar_get_number(const char *s, size_t sz, int base, size_t *ret)
-{
-	int c, v;
-	size_t r;
-	const char *e;
-
-	assert(base <= 10);
-
-	e = s + sz;
-
-	/* skip leading blanks */
-	for (;s < e && (c = *s) == ' '; s++)
-		;
-
-	r = 0L;
-	for (;s < e; s++) {
-		if ((c = *s) == ' ')
-			break;
-		if (c < '0' || c > '9')
-			return (0);
-		v = c - '0';
-		if (v >= base)		/* Illegal digit. */
-			break;
-		r *= base;
-		r += v;
-	}
-
-	*ret = r;
-
-	return (1);
-}
-
-/*
- * Return the translated name for an archive member.
- */
-char *
-_libelf_ar_get_translated_name(const struct ar_hdr *arh, Elf *ar)
-{
-	char c, *s;
-	size_t len, offset;
-	const char *buf, *p, *q, *r;
-	const size_t bufsize = sizeof(arh->ar_name);
-
-	assert(arh != NULL);
-	assert(ar->e_kind == ELF_K_AR);
-	assert((const char *) arh >= ar->e_rawfile &&
-	    (const char *) arh < ar->e_rawfile + ar->e_rawsize);
-
-	buf = arh->ar_name;
-
-	/*
-	 * Check for extended naming.
-	 *
-	 * If the name matches the pattern "^/[0-9]+", it is an
-	 * SVR4-style extended name.  If the name matches the pattern
-	 * "#1/[0-9]+", the entry uses BSD style extended naming.
-	 */
-	if (buf[0] == '/' && (c = buf[1]) >= '0' && c <= '9') {
-		/*
-		 * The value in field ar_name is a decimal offset into
-		 * the archive string table where the actual name
-		 * resides.
-		 */
-		if (_libelf_ar_get_number(buf + 1, bufsize - 1, 10,
-			&offset) == 0) {
-			LIBELF_SET_ERROR(ARCHIVE, 0);
-			return (NULL);
-		}
-
-		if (offset > ar->e_u.e_ar.e_rawstrtabsz) {
-			LIBELF_SET_ERROR(ARCHIVE, 0);
-			return (NULL);
-		}
-
-		p = q = ar->e_u.e_ar.e_rawstrtab + offset;
-		r = ar->e_u.e_ar.e_rawstrtab + ar->e_u.e_ar.e_rawstrtabsz;
-
-		for (; p < r && *p != '/'; p++)
-			;
-		len = p - q + 1; /* space for the trailing NUL */
-
-		if ((s = malloc(len)) == NULL) {
-			LIBELF_SET_ERROR(RESOURCE, 0);
-			return (NULL);
-		}
-
-		(void) strncpy(s, q, len - 1);
-		s[len - 1] = '\0';
-
-		return (s);
-	} else if (IS_EXTENDED_BSD_NAME(buf)) {
-		r = buf + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE;
-
-		if (_libelf_ar_get_number(r, bufsize -
-			LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10,
-			&len) == 0) {
-			LIBELF_SET_ERROR(ARCHIVE, 0);
-			return (NULL);
-		}
-
-		/*
-		 * Allocate space for the file name plus a
-		 * trailing NUL.
-		 */
-		if ((s = malloc(len + 1)) == NULL) {
-			LIBELF_SET_ERROR(RESOURCE, 0);
-			return (NULL);
-		}
-
-		/*
-		 * The file name follows the archive header.
-		 */
-		q = (const char *) (arh + 1);
-
-		(void) strncpy(s, q, len);
-		s[len] = '\0';
-
-		return (s);
-	}
-
-	/*
-	 * A 'normal' name.
-	 *
-	 * Skip back over trailing blanks from the end of the field.
-	 * In the SVR4 format, a '/' is used as a terminator for
-	 * non-special names.
-	 */
-	for (q = buf + bufsize - 1; q >= buf && *q == ' '; --q)
-		;
-
-	if (q >= buf) {
-		if (*q == '/') {
-			/*
-			 * SVR4 style names: ignore the trailing
-			 * character '/', but only if the name is not
-			 * one of the special names "/" and "//".
-			 */
-			if (q > buf + 1 ||
-			    (q == (buf + 1) && *buf != '/'))
-				q--;
-		}
-
-		len = q - buf + 2; /* Add space for a trailing NUL. */
-	} else {
-		/* The buffer only had blanks. */
-		buf = "";
-		len = 1;
-	}
-
-	if ((s = malloc(len)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	(void) strncpy(s, buf, len - 1);
-	s[len - 1] = '\0';
-
-	return (s);
-}
-
-/*
- * Return the raw name for an archive member, inclusive of any
- * formatting characters.
- */
-char *
-_libelf_ar_get_raw_name(const struct ar_hdr *arh)
-{
-	char *rawname;
-	const size_t namesz = sizeof(arh->ar_name);
-
-	if ((rawname = malloc(namesz + 1)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	(void) strncpy(rawname, arh->ar_name, namesz);
-	rawname[namesz] = '\0';
-	return (rawname);
-}
-
-/*
- * Open an 'ar' archive.
- */
-Elf *
-_libelf_ar_open(Elf *e, int reporterror)
-{
-	size_t sz;
-	int scanahead;
-	char *s, *end;
-	struct ar_hdr arh;
-
-	_libelf_init_elf(e, ELF_K_AR);
-
-	e->e_u.e_ar.e_nchildren = 0;
-	e->e_u.e_ar.e_next = (off_t) -1;
-
-	/*
-	 * Look for special members.
-	 */
-
-	s = e->e_rawfile + SARMAG;
-	end = e->e_rawfile + e->e_rawsize;
-
-	assert(e->e_rawsize > 0);
-
-	/*
-	 * We use heuristics to determine the flavor of the archive we
-	 * are examining.
-	 *
-	 * SVR4 flavor archives use the name "/ " and "// " for
-	 * special members.
-	 *
-	 * In BSD flavor archives the symbol table, if present, is the
-	 * first archive with name "__.SYMDEF".
-	 */
-
-#define	READ_AR_HEADER(S, ARH, SZ, END)					\
-	do {								\
-		if ((S) + sizeof((ARH)) > (END))			\
-		        goto error;					\
-		(void) memcpy(&(ARH), (S), sizeof((ARH)));		\
-		if ((ARH).ar_fmag[0] != '`' || (ARH).ar_fmag[1] != '\n') \
-			goto error;					\
-		if (_libelf_ar_get_number((ARH).ar_size,		\
-		    sizeof((ARH).ar_size), 10, &(SZ)) == 0)		\
-			goto error;					\
-	} while (0)
-
-	READ_AR_HEADER(s, arh, sz, end);
-
-	/*
-	 * Handle special archive members for the SVR4 format.
-	 */
-	if (arh.ar_name[0] == '/') {
-
-		assert(sz > 0);
-
-		e->e_flags |= LIBELF_F_AR_VARIANT_SVR4;
-
-		scanahead = 0;
-
-		/*
-		 * The symbol table (file name "/ ") always comes before the
-		 * string table (file name "// ").
-		 */
-		if (arh.ar_name[1] == ' ') {
-			/* "/ " => symbol table. */
-			scanahead = 1;	/* The string table to follow. */
-
-			s += sizeof(arh);
-			e->e_u.e_ar.e_rawsymtab = s;
-			e->e_u.e_ar.e_rawsymtabsz = sz;
-
-			sz = LIBELF_ADJUST_AR_SIZE(sz);
-			s += sz;
-
-		} else if (arh.ar_name[1] == '/' && arh.ar_name[2] == ' ') {
-			/* "// " => string table for long file names. */
-			s += sizeof(arh);
-			e->e_u.e_ar.e_rawstrtab = s;
-			e->e_u.e_ar.e_rawstrtabsz = sz;
-
-			sz = LIBELF_ADJUST_AR_SIZE(sz);
-			s += sz;
-		}
-
-		/*
-		 * If the string table hasn't been seen yet, look for
-		 * it in the next member.
-		 */
-		if (scanahead) {
-			READ_AR_HEADER(s, arh, sz, end);
-
-			/* "// " => string table for long file names. */
-			if (arh.ar_name[0] == '/' && arh.ar_name[1] == '/' &&
-			    arh.ar_name[2] == ' ') {
-
-				s += sizeof(arh);
-
-				e->e_u.e_ar.e_rawstrtab = s;
-				e->e_u.e_ar.e_rawstrtabsz = sz;
-
-				sz = LIBELF_ADJUST_AR_SIZE(sz);
-				s += sz;
-			}
-		}
-	} else if (strncmp(arh.ar_name, LIBELF_AR_BSD_SYMTAB_NAME,
-		sizeof(LIBELF_AR_BSD_SYMTAB_NAME) - 1) == 0) {
-		/*
-		 * BSD style archive symbol table.
-		 */
-		s += sizeof(arh);
-		e->e_u.e_ar.e_rawsymtab = s;
-		e->e_u.e_ar.e_rawsymtabsz = sz;
-
-		sz = LIBELF_ADJUST_AR_SIZE(sz);
-		s += sz;
-	}
-
-	/*
-	 * Update the 'next' offset, so that a subsequent elf_begin()
-	 * works as expected.
-	 */
-	e->e_u.e_ar.e_next = (off_t) (s - e->e_rawfile);
-
-	return (e);
-
-error:
-	if (!reporterror) {
-		e->e_kind = ELF_K_NONE;
-		return (e);
-	}
-
-	LIBELF_SET_ERROR(ARCHIVE, 0);
-	return (NULL);
-}

loader/src/libelf/libelf_checksum.c

@@ -1,100 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_checksum.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-static unsigned long
-_libelf_sum(unsigned long c, const unsigned char *s, size_t size)
-{
-	if (s == NULL || size == 0)
-		return (c);
-
-	while (size--)
-		c += *s++;
-
-	return (c);
-}
-
-unsigned long
-_libelf_checksum(Elf *e, int elfclass)
-{
-	size_t shn;
-	Elf_Scn *scn;
-	Elf_Data *d;
-	unsigned long checksum;
-	GElf_Ehdr eh;
-	GElf_Shdr shdr;
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0L);
-	}
-
-	if (e->e_class != elfclass) {
-		LIBELF_SET_ERROR(CLASS, 0);
-		return (0L);
-	}
-
-	if (gelf_getehdr(e, &eh) == NULL)
-		return (0);
-
-	/*
-	 * Iterate over all sections in the ELF file, computing the
-	 * checksum along the way.
-	 *
-	 * The first section is always SHN_UNDEF and can be skipped.
-	 * Non-allocatable sections are skipped, as are sections that
-	 * could be affected by utilities such as strip(1).
-	 */
-
-	checksum = 0;
-	for (shn = 1; shn < e->e_u.e_elf.e_nscn; shn++) {
-		if ((scn = elf_getscn(e, shn)) == NULL)
-			return (0);
-		if (gelf_getshdr(scn, &shdr) == NULL)
-			return (0);
-		if ((shdr.sh_flags & SHF_ALLOC) == 0 ||
-		    shdr.sh_type == SHT_DYNAMIC ||
-		    shdr.sh_type == SHT_DYNSYM)
-			continue;
-
-		d = NULL;
-		while ((d = elf_rawdata(scn, d)) != NULL)
-			checksum = _libelf_sum(checksum,
-			    (unsigned char *) d->d_buf, d->d_size);
-	}
-
-	/*
-	 * Return a 16-bit checksum compatible with Solaris.
-	 */
-	return (((checksum >> 16) & 0xFFFFUL) + (checksum & 0xFFFFUL));
-}

loader/src/libelf/libelf_data.c

@@ -1,88 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_data.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-int
-_libelf_xlate_shtype(uint32_t sht)
-{
-	switch (sht) {
-	case SHT_DYNAMIC:
-		return (ELF_T_DYN);
-	case SHT_DYNSYM:
-		return (ELF_T_SYM);
-	case SHT_FINI_ARRAY:
-		return (ELF_T_ADDR);
-	case SHT_GNU_HASH:
-		return (ELF_T_GNUHASH);
-	case SHT_GNU_LIBLIST:
-		return (ELF_T_WORD);
-	case SHT_GROUP:
-		return (ELF_T_WORD);
-	case SHT_HASH:
-		return (ELF_T_WORD);
-	case SHT_INIT_ARRAY:
-		return (ELF_T_ADDR);
-	case SHT_NOBITS:
-		return (ELF_T_BYTE);
-	case SHT_NOTE:
-		return (ELF_T_NOTE);
-	case SHT_PREINIT_ARRAY:
-		return (ELF_T_ADDR);
-	case SHT_PROGBITS:
-		return (ELF_T_BYTE);
-	case SHT_REL:
-		return (ELF_T_REL);
-	case SHT_RELA:
-		return (ELF_T_RELA);
-	case SHT_STRTAB:
-		return (ELF_T_BYTE);
-	case SHT_SYMTAB:
-		return (ELF_T_SYM);
-	case SHT_SYMTAB_SHNDX:
-		return (ELF_T_WORD);
-	case SHT_SUNW_dof:
-		return (ELF_T_BYTE);
-	case SHT_SUNW_move:
-		return (ELF_T_MOVE);
-	case SHT_SUNW_syminfo:
-		return (ELF_T_SYMINFO);
-	case SHT_SUNW_verdef:	/* == SHT_GNU_verdef */
-		return (ELF_T_VDEF);
-	case SHT_SUNW_verneed:	/* == SHT_GNU_verneed */
-		return (ELF_T_VNEED);
-	case SHT_SUNW_versym:	/* == SHT_GNU_versym */
-		return (ELF_T_HALF);
-	default:
-		return (-1);
-	}
-}

loader/src/libelf/libelf_ehdr.c

@@ -1,204 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_ehdr.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * Retrieve counts for sections, phdrs and the section string table index
- * from section header #0 of the ELF object.
- */
-static int
-_libelf_load_extended(Elf *e, int ec, uint64_t shoff, uint16_t phnum,
-    uint16_t strndx)
-{
-	Elf_Scn *scn;
-	size_t fsz;
-	int (*xlator)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-	uint32_t shtype;
-
-	assert(STAILQ_EMPTY(&e->e_u.e_elf.e_scn));
-
-	fsz = _libelf_fsize(ELF_T_SHDR, ec, e->e_version, 1);
-	assert(fsz > 0);
-
-	if (e->e_rawsize < shoff + fsz) { /* raw file too small */
-		LIBELF_SET_ERROR(HEADER, 0);
-		return (0);
-	}
-
-	if ((scn = _libelf_allocate_scn(e, (size_t) 0)) == NULL)
-		return (0);
-
-	xlator = _libelf_get_translator(ELF_T_SHDR, ELF_TOMEMORY, ec);
-	(*xlator)((char *) &scn->s_shdr, sizeof(scn->s_shdr),
-	    e->e_rawfile + shoff, (size_t) 1,
-	    e->e_byteorder != LIBELF_PRIVATE(byteorder));
-
-#define	GET_SHDR_MEMBER(M) ((ec == ELFCLASS32) ? scn->s_shdr.s_shdr32.M : \
-		scn->s_shdr.s_shdr64.M)
-
-	if ((shtype = GET_SHDR_MEMBER(sh_type)) != SHT_NULL) {
-		LIBELF_SET_ERROR(SECTION, 0);
-		return (0);
-	}
-
-	e->e_u.e_elf.e_nscn = GET_SHDR_MEMBER(sh_size);
-	e->e_u.e_elf.e_nphdr = (phnum != PN_XNUM) ? phnum :
-	    GET_SHDR_MEMBER(sh_info);
-	e->e_u.e_elf.e_strndx = (strndx != SHN_XINDEX) ? strndx :
-	    GET_SHDR_MEMBER(sh_link);
-#undef	GET_SHDR_MEMBER
-
-	return (1);
-}
-
-#define	EHDR_INIT(E,SZ)	 do {						\
-		Elf##SZ##_Ehdr *eh = (E);				\
-		eh->e_ident[EI_MAG0] = ELFMAG0;				\
-		eh->e_ident[EI_MAG1] = ELFMAG1;				\
-		eh->e_ident[EI_MAG2] = ELFMAG2;				\
-		eh->e_ident[EI_MAG3] = ELFMAG3;				\
-		eh->e_ident[EI_CLASS] = ELFCLASS##SZ;			\
-		eh->e_ident[EI_DATA]  = ELFDATANONE;			\
-		eh->e_ident[EI_VERSION] = LIBELF_PRIVATE(version);	\
-		eh->e_machine = EM_NONE;				\
-		eh->e_type    = ELF_K_NONE;				\
-		eh->e_version = LIBELF_PRIVATE(version);		\
-	} while (0)
-
-void *
-_libelf_ehdr(Elf *e, int ec, int allocate)
-{
-	void *ehdr;
-	size_t fsz, msz;
-	uint16_t phnum, shnum, strndx;
-	uint64_t shoff;
-	int (*xlator)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (e == NULL || e->e_kind != ELF_K_ELF) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (e->e_class != ELFCLASSNONE && e->e_class != ec) {
-		LIBELF_SET_ERROR(CLASS, 0);
-		return (NULL);
-	}
-
-	if (e->e_version != EV_CURRENT) {
-		LIBELF_SET_ERROR(VERSION, 0);
-		return (NULL);
-	}
-
-	if (e->e_class == ELFCLASSNONE)
-		e->e_class = ec;
-
-	if (ec == ELFCLASS32)
-		ehdr = (void *) e->e_u.e_elf.e_ehdr.e_ehdr32;
-	else
-		ehdr = (void *) e->e_u.e_elf.e_ehdr.e_ehdr64;
-
-	if (ehdr != NULL)	/* already have a translated ehdr */
-		return (ehdr);
-
-	fsz = _libelf_fsize(ELF_T_EHDR, ec, e->e_version, (size_t) 1);
-	assert(fsz > 0);
-
-	if (e->e_cmd != ELF_C_WRITE && e->e_rawsize < fsz) {
-		LIBELF_SET_ERROR(HEADER, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_EHDR, ec, EV_CURRENT);
-
-	assert(msz > 0);
-
-	if ((ehdr = calloc((size_t) 1, msz)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		e->e_u.e_elf.e_ehdr.e_ehdr32 = ehdr;
-		EHDR_INIT(ehdr,32);
-	} else {
-		e->e_u.e_elf.e_ehdr.e_ehdr64 = ehdr;
-		EHDR_INIT(ehdr,64);
-	}
-
-	if (allocate)
-		e->e_flags |= ELF_F_DIRTY;
-
-	if (e->e_cmd == ELF_C_WRITE)
-		return (ehdr);
-
-	xlator = _libelf_get_translator(ELF_T_EHDR, ELF_TOMEMORY, ec);
-	(*xlator)(ehdr, msz, e->e_rawfile, (size_t) 1,
-	    e->e_byteorder != LIBELF_PRIVATE(byteorder));
-
-	/*
-	 * If extended numbering is being used, read the correct
-	 * number of sections and program header entries.
-	 */
-	if (ec == ELFCLASS32) {
-		phnum = ((Elf32_Ehdr *) ehdr)->e_phnum;
-		shnum = ((Elf32_Ehdr *) ehdr)->e_shnum;
-		shoff = ((Elf32_Ehdr *) ehdr)->e_shoff;
-		strndx = ((Elf32_Ehdr *) ehdr)->e_shstrndx;
-	} else {
-		phnum = ((Elf64_Ehdr *) ehdr)->e_phnum;
-		shnum = ((Elf64_Ehdr *) ehdr)->e_shnum;
-		shoff = ((Elf64_Ehdr *) ehdr)->e_shoff;
-		strndx = ((Elf64_Ehdr *) ehdr)->e_shstrndx;
-	}
-
-	if (shnum >= SHN_LORESERVE ||
-	    (shoff == 0LL && (shnum != 0 || phnum == PN_XNUM ||
-		strndx == SHN_XINDEX))) {
-		LIBELF_SET_ERROR(HEADER, 0);
-		return (NULL);
-	}
-
-	if (shnum != 0 || shoff == 0LL) { /* not using extended numbering */
-		e->e_u.e_elf.e_nphdr = phnum;
-		e->e_u.e_elf.e_nscn = shnum;
-		e->e_u.e_elf.e_strndx = strndx;
-	} else if (_libelf_load_extended(e, ec, shoff, phnum, strndx) == 0)
-		return (NULL);
-
-	return (ehdr);
-}

loader/src/libelf/libelf_extended.c

@@ -1,136 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_extended.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * Retrieve section #0, allocating a new section if needed.
- */
-static Elf_Scn *
-_libelf_getscn0(Elf *e)
-{
-	Elf_Scn *s;
-
-	if ((s = STAILQ_FIRST(&e->e_u.e_elf.e_scn)) != NULL)
-		return (s);
-
-	return (_libelf_allocate_scn(e, (size_t) SHN_UNDEF));
-}
-
-int
-_libelf_setshnum(Elf *e, void *eh, int ec, size_t shnum)
-{
-	Elf_Scn *scn;
-
-	if (shnum >= SHN_LORESERVE) {
-		if ((scn = _libelf_getscn0(e)) == NULL)
-			return (0);
-
-		assert(scn->s_ndx == SHN_UNDEF);
-
-		if (ec == ELFCLASS32)
-			scn->s_shdr.s_shdr32.sh_size = shnum;
-		else
-			scn->s_shdr.s_shdr64.sh_size = shnum;
-
-		(void) elf_flagshdr(scn, ELF_C_SET, ELF_F_DIRTY);
-
-		shnum = 0;
-	}
-
-	if (ec == ELFCLASS32)
-		((Elf32_Ehdr *) eh)->e_shnum = shnum;
-	else
-		((Elf64_Ehdr *) eh)->e_shnum = shnum;
-
-
-	return (1);
-}
-
-int
-_libelf_setshstrndx(Elf *e, void *eh, int ec, size_t shstrndx)
-{
-	Elf_Scn *scn;
-
-	if (shstrndx >= SHN_LORESERVE) {
-		if ((scn = _libelf_getscn0(e)) == NULL)
-			return (0);
-
-		assert(scn->s_ndx == SHN_UNDEF);
-
-		if (ec == ELFCLASS32)
-			scn->s_shdr.s_shdr32.sh_link = shstrndx;
-		else
-			scn->s_shdr.s_shdr64.sh_link = shstrndx;
-
-		(void) elf_flagshdr(scn, ELF_C_SET, ELF_F_DIRTY);
-
-		shstrndx = SHN_XINDEX;
-	}
-
-	if (ec == ELFCLASS32)
-		((Elf32_Ehdr *) eh)->e_shstrndx = shstrndx;
-	else
-		((Elf64_Ehdr *) eh)->e_shstrndx = shstrndx;
-
-	return (1);
-}
-
-int
-_libelf_setphnum(Elf *e, void *eh, int ec, size_t phnum)
-{
-	Elf_Scn *scn;
-
-	if (phnum >= PN_XNUM) {
-		if ((scn = _libelf_getscn0(e)) == NULL)
-			return (0);
-
-		assert(scn->s_ndx == SHN_UNDEF);
-
-		if (ec == ELFCLASS32)
-			scn->s_shdr.s_shdr32.sh_info = phnum;
-		else
-			scn->s_shdr.s_shdr64.sh_info = phnum;
-
-		(void) elf_flagshdr(scn, ELF_C_SET, ELF_F_DIRTY);
-
-		phnum = PN_XNUM;
-	}
-
-	if (ec == ELFCLASS32)
-		((Elf32_Ehdr *) eh)->e_phnum = phnum;
-	else
-		((Elf64_Ehdr *) eh)->e_phnum = phnum;
-
-	return (1);
-}

loader/src/libelf/libelf_fsize.c

@@ -1,197 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- *
- * $Id: elf_types.m4 321 2009-03-07 16:59:14Z jkoshy $
- */
-
-/*
- * ELF types, defined in the "enum Elf_Type" API.
- *
- * The members of the list form a 2-tuple: (name, C-type-suffix).
- * + name is an Elf_Type symbol without the ELF_T_ prefix.
- * + C-type-suffix is the suffix for Elf32_ and Elf64_ type names.
- */
-
-
-
-/*
- * DEFINE_STRUCT(NAME,MEMBERLIST...)
- *
- * Map a type name to its members.
- *
- * Each member-list element comprises of pairs of (field name, type),
- * in the sequence used in the file representation of NAME.
- *
- * Each member list element comprises a pair containing a field name
- * and a basic type.  Basic types include IDENT, HALF, WORD, LWORD,
- * ADDR{32,64}, OFF{32,64}, SWORD, XWORD, SXWORD.
- *
- * The last element of a member list is the null element: _,_.
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_fsize.m4 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/* WARNING: GENERATED FROM libelf_fsize.m4. */
-
-/*
- * Create an array of file sizes from the elf_type definitions
- */
-
-
-
-struct fsize {
-	size_t fsz32;
-	size_t fsz64;
-};
-
-static struct fsize fsize[ELF_T_NUM] = {
-[ELF_T_ADDR] = { .fsz32 = sizeof(Elf32_Addr), .fsz64 = sizeof(Elf64_Addr) },
-
-[ELF_T_BYTE] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_CAP] = { .fsz32 = sizeof(Elf32_Word)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_DYN] = { .fsz32 = sizeof(Elf32_Sword)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Sxword)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_EHDR] = { .fsz32 = EI_NIDENT+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Word)+sizeof(Elf32_Addr)+sizeof(Elf32_Off)+sizeof(Elf32_Off)+sizeof(Elf32_Word)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+0, .fsz64 = EI_NIDENT+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Word)+sizeof(Elf64_Addr)+sizeof(Elf64_Off)+sizeof(Elf64_Off)+sizeof(Elf64_Word)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+0 },
-
-[ELF_T_GNUHASH] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_HALF] = { .fsz32 = sizeof(Elf32_Half), .fsz64 = sizeof(Elf64_Half) },
-
-[ELF_T_LWORD] = { .fsz32 = sizeof(Elf32_Lword), .fsz64 = sizeof(Elf64_Lword) },
-
-[ELF_T_MOVE] = { .fsz32 = sizeof(Elf32_Lword)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+0, .fsz64 = sizeof(Elf64_Lword)+sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+0 },
-
-[ELF_T_MOVEP] = { .fsz32 = 0, .fsz64 = 0 },
-
-[ELF_T_NOTE] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_OFF] = { .fsz32 = sizeof(Elf32_Off), .fsz64 = sizeof(Elf64_Off) },
-
-[ELF_T_PHDR] = { .fsz32 = sizeof(Elf32_Word)+sizeof(Elf32_Off)+sizeof(Elf32_Addr)+sizeof(Elf32_Addr)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Word)+sizeof(Elf64_Word)+sizeof(Elf64_Off)+sizeof(Elf64_Addr)+sizeof(Elf64_Addr)+sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_REL] = { .fsz32 = sizeof(Elf32_Addr)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Addr)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_RELA] = { .fsz32 = sizeof(Elf32_Addr)+sizeof(Elf32_Word)+sizeof(Elf32_Sword)+0, .fsz64 = sizeof(Elf64_Addr)+sizeof(Elf64_Xword)+sizeof(Elf64_Sxword)+0 },
-
-[ELF_T_SHDR] = { .fsz32 = sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Addr)+sizeof(Elf32_Off)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Word)+sizeof(Elf64_Word)+sizeof(Elf64_Xword)+sizeof(Elf64_Addr)+sizeof(Elf64_Off)+sizeof(Elf64_Xword)+sizeof(Elf64_Word)+sizeof(Elf64_Word)+sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_SWORD] = { .fsz32 = sizeof(Elf32_Sword), .fsz64 = sizeof(Elf64_Sword) },
-
-[ELF_T_SXWORD] = { .fsz32 = 0, .fsz64 = sizeof(Elf64_Sxword) },
-
-[ELF_T_SYMINFO] = { .fsz32 = sizeof(Elf32_Half)+sizeof(Elf32_Half)+0, .fsz64 = sizeof(Elf64_Half)+sizeof(Elf64_Half)+0 },
-
-[ELF_T_SYM] = { .fsz32 = sizeof(Elf32_Word)+sizeof(Elf32_Addr)+sizeof(Elf32_Word)+1+1+sizeof(Elf32_Half)+0, .fsz64 = sizeof(Elf64_Word)+1+1+sizeof(Elf64_Half)+sizeof(Elf64_Addr)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_VDEF] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_VNEED] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_WORD] = { .fsz32 = sizeof(Elf32_Word), .fsz64 = sizeof(Elf64_Word) },
-
-[ELF_T_XWORD] = { .fsz32 = 0, .fsz64 = sizeof(Elf64_Xword) },
-
-
-};
-
-size_t
-_libelf_fsize(Elf_Type t, int ec, unsigned int v, size_t c)
-{
-	size_t sz;
-
-	sz = 0;
-	if (v != EV_CURRENT)
-		LIBELF_SET_ERROR(VERSION, 0);
-	else if ((int) t < ELF_T_FIRST || t > ELF_T_LAST)
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-	else {
-		sz = ec == ELFCLASS64 ? fsize[t].fsz64 : fsize[t].fsz32;
-		if (sz == 0)
-			LIBELF_SET_ERROR(UNIMPL, 0);
-	}
-
-	return (sz*c);
-}

loader/src/libelf/libelf_memory.c

@@ -1,96 +0,0 @@
-/*-
- * Copyright (c) 2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <ar.h>
-#include <assert.h>
-#include <string.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_memory.c 2368 2011-12-29 06:34:28Z jkoshy $");
-
-/*
- * Create an ELF descriptor for a memory image, optionally reporting
- * parse errors.
- */
-
-Elf *
-_libelf_memory(char *image, size_t sz, int reporterror)
-{
-	Elf *e;
-	int e_class;
-	enum Elf_Error error;
-	unsigned int e_byteorder, e_version;
-
-	assert(image != NULL);
-	assert(sz > 0);
-
-	if ((e = _libelf_allocate_elf()) == NULL)
-		return (NULL);
-
-	e->e_cmd = ELF_C_READ;
-	e->e_rawfile = image;
-	e->e_rawsize = sz;
-
-#undef	LIBELF_IS_ELF
-#define	LIBELF_IS_ELF(P) ((P)[EI_MAG0] == ELFMAG0 && 		\
-	(P)[EI_MAG1] == ELFMAG1 && (P)[EI_MAG2] == ELFMAG2 &&	\
-	(P)[EI_MAG3] == ELFMAG3)
-
-	if (sz > EI_NIDENT && LIBELF_IS_ELF(image)) {
-		e_byteorder = image[EI_DATA];
-		e_class     = image[EI_CLASS];
-		e_version   = image[EI_VERSION];
-
-		error = ELF_E_NONE;
-
-		if (e_version > EV_CURRENT)
-			error = ELF_E_VERSION;
-		else if ((e_byteorder != ELFDATA2LSB && e_byteorder !=
- 		    ELFDATA2MSB) || (e_class != ELFCLASS32 && e_class !=
-		    ELFCLASS64))
-			error = ELF_E_HEADER;
-
-		if (error != ELF_E_NONE) {
-			if (reporterror) {
-				LIBELF_PRIVATE(error) = LIBELF_ERROR(error, 0);
-				(void) _libelf_release_elf(e);
-				return (NULL);
-			}
-		} else {
-			_libelf_init_elf(e, ELF_K_ELF);
-
-			e->e_byteorder = e_byteorder;
-			e->e_class = e_class;
-			e->e_version = e_version;
-		}
-	} else if (sz >= SARMAG &&
-	    strncmp(image, ARMAG, (size_t) SARMAG) == 0)
-		return (_libelf_ar_open(e, reporterror));
-
-	return (e);
-}

loader/src/libelf/libelf_msize.c

@@ -1,196 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- *
- * $Id: elf_types.m4 321 2009-03-07 16:59:14Z jkoshy $
- */
-
-/*
- * ELF types, defined in the "enum Elf_Type" API.
- *
- * The members of the list form a 2-tuple: (name, C-type-suffix).
- * + name is an Elf_Type symbol without the ELF_T_ prefix.
- * + C-type-suffix is the suffix for Elf32_ and Elf64_ type names.
- */
-
-
-
-/*
- * DEFINE_STRUCT(NAME,MEMBERLIST...)
- *
- * Map a type name to its members.
- *
- * Each member-list element comprises of pairs of (field name, type),
- * in the sequence used in the file representation of NAME.
- *
- * Each member list element comprises a pair containing a field name
- * and a basic type.  Basic types include IDENT, HALF, WORD, LWORD,
- * ADDR{32,64}, OFF{32,64}, SWORD, XWORD, SXWORD.
- *
- * The last element of a member list is the null element: _,_.
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_msize.m4 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/* WARNING: GENERATED FROM libelf_msize.m4. */
-
-struct msize {
-	size_t	msz32;
-	size_t	msz64;
-};
-
-
-
-static struct msize msize[ELF_T_NUM] = {
-[ELF_T_ADDR] = { .msz32 = sizeof(Elf32_Addr), .msz64 = sizeof(Elf64_Addr) },
-
-[ELF_T_BYTE] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_CAP] = { .msz32 = sizeof(Elf32_Cap), .msz64 = sizeof(Elf64_Cap) },
-
-[ELF_T_DYN] = { .msz32 = sizeof(Elf32_Dyn), .msz64 = sizeof(Elf64_Dyn) },
-
-[ELF_T_EHDR] = { .msz32 = sizeof(Elf32_Ehdr), .msz64 = sizeof(Elf64_Ehdr) },
-
-[ELF_T_GNUHASH] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_HALF] = { .msz32 = sizeof(Elf32_Half), .msz64 = sizeof(Elf64_Half) },
-
-[ELF_T_LWORD] = { .msz32 = sizeof(Elf32_Lword), .msz64 = sizeof(Elf64_Lword) },
-
-[ELF_T_MOVE] = { .msz32 = sizeof(Elf32_Move), .msz64 = sizeof(Elf64_Move) },
-
-[ELF_T_MOVEP] = { .msz32 = 0, .msz64 = 0 },
-
-[ELF_T_NOTE] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_OFF] = { .msz32 = sizeof(Elf32_Off), .msz64 = sizeof(Elf64_Off) },
-
-[ELF_T_PHDR] = { .msz32 = sizeof(Elf32_Phdr), .msz64 = sizeof(Elf64_Phdr) },
-
-[ELF_T_REL] = { .msz32 = sizeof(Elf32_Rel), .msz64 = sizeof(Elf64_Rel) },
-
-[ELF_T_RELA] = { .msz32 = sizeof(Elf32_Rela), .msz64 = sizeof(Elf64_Rela) },
-
-[ELF_T_SHDR] = { .msz32 = sizeof(Elf32_Shdr), .msz64 = sizeof(Elf64_Shdr) },
-
-[ELF_T_SWORD] = { .msz32 = sizeof(Elf32_Sword), .msz64 = sizeof(Elf64_Sword) },
-
-[ELF_T_SXWORD] = { .msz32 = 0, .msz64 = sizeof(Elf64_Sxword) },
-
-[ELF_T_SYMINFO] = { .msz32 = sizeof(Elf32_Syminfo), .msz64 = sizeof(Elf64_Syminfo) },
-
-[ELF_T_SYM] = { .msz32 = sizeof(Elf32_Sym), .msz64 = sizeof(Elf64_Sym) },
-
-[ELF_T_VDEF] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_VNEED] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_WORD] = { .msz32 = sizeof(Elf32_Word), .msz64 = sizeof(Elf64_Word) },
-
-[ELF_T_XWORD] = { .msz32 = 0, .msz64 = sizeof(Elf64_Xword) },
-
-
-};
-
-size_t
-_libelf_msize(Elf_Type t, int elfclass, unsigned int version)
-{
-	size_t sz;
-
-	assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
-	assert((signed) t >= ELF_T_FIRST && t <= ELF_T_LAST);
-
-	if (version != EV_CURRENT) {
-		LIBELF_SET_ERROR(VERSION, 0);
-		return (0);
-	}
-
-	sz = (elfclass == ELFCLASS32) ? msize[t].msz32 : msize[t].msz64;
-
-	return (sz);
-}

loader/src/libelf/libelf_open.c

@@ -1,240 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <libelf.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "_libelf.h"
-
-#if	ELFTC_HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
-ELFTC_VCSID("$Id: libelf_open.c 2364 2011-12-28 17:55:25Z jkoshy $");
-
-#define	_LIBELF_INITSIZE	(64*1024)
-
-/*
- * Read from a device file, pipe or socket.
- */
-static void *
-_libelf_read_special_file(int fd, size_t *fsz)
-{
-	ssize_t readsz;
-	size_t bufsz, datasz;
-	unsigned char *buf, *t;
-
-	datasz = 0;
-	readsz = 0;
-	bufsz = _LIBELF_INITSIZE;
-	if ((buf = malloc(bufsz)) == NULL)
-		goto resourceerror;
-
-	/*
-	 * Read data from the file descriptor till we reach EOF, or
-	 * till an error is encountered.
-	 */
-	do {
-		/* Check if we need to expand the data buffer. */
-		if (datasz == bufsz) {
-			bufsz *= 2;
-			if ((t = realloc(buf, bufsz)) == NULL)
-				goto resourceerror;
-			buf = t;
-		}
-
-		do {
-			readsz = bufsz - datasz;
-			t = buf + datasz;
-			if ((readsz = read(fd, t, readsz)) <= 0)
-				break;
-			datasz += readsz;
-		} while (datasz < bufsz);
-
-	} while (readsz > 0);
-
-	if (readsz < 0) {
-		LIBELF_SET_ERROR(IO, errno);
-		goto error;
-	}
-
-	assert(readsz == 0);
-
-	/*
-	 * Free up extra buffer space.
-	 */
-	if (bufsz > datasz) {
-		if (datasz > 0) {
-			if ((t = realloc(buf, datasz)) == NULL)
-				goto resourceerror;
-			buf = t;
-		} else {	/* Zero bytes read. */
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			free(buf);
-			buf = NULL;
-		}
-	}
-
-	*fsz = datasz;
-	return (buf);
-
-resourceerror:
-	LIBELF_SET_ERROR(RESOURCE, 0);
-error:
-	if (buf != NULL)
-		free(buf);
-	return (NULL);
-}
-
-/*
- * Read the contents of the file referenced by the file descriptor
- * 'fd'.
- */
-
-Elf *
-_libelf_open_object(int fd, Elf_Cmd c, int reporterror)
-{
-	Elf *e;
-	void *m;
-	mode_t mode;
-	size_t fsize;
-	struct stat sb;
-	unsigned int flags;
-
-	assert(c == ELF_C_READ || c == ELF_C_RDWR || c == ELF_C_WRITE);
-
-	if (fstat(fd, &sb) < 0) {
-		LIBELF_SET_ERROR(IO, errno);
-		return (NULL);
-	}
-
-	mode = sb.st_mode;
-	fsize = (size_t) sb.st_size;
-
-	/*
-	 * Reject unsupported file types.
-	 */
-	if (!S_ISREG(mode) && !S_ISCHR(mode) && !S_ISFIFO(mode) &&
-	    !S_ISSOCK(mode)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	/*
-	 * For ELF_C_WRITE mode, allocate and return a descriptor.
-	 */
-	if (c == ELF_C_WRITE) {
-		if ((e = _libelf_allocate_elf()) != NULL) {
-			_libelf_init_elf(e, ELF_K_ELF);
-			e->e_byteorder = LIBELF_PRIVATE(byteorder);
-			e->e_fd = fd;
-			e->e_cmd = c;
-			if (!S_ISREG(mode))
-				e->e_flags |= LIBELF_F_SPECIAL_FILE;
-		}
-
-		return (e);
-	}
-
-
-	/*
-	 * ELF_C_READ and ELF_C_RDWR mode.
-	 */
-	m = NULL;
-	flags = 0;
-	if (S_ISREG(mode)) {
-#if	ELFTC_HAVE_MMAP
-		/*
-		 * Always map regular files in with 'PROT_READ'
-		 * permissions.
-		 *
-		 * For objects opened in ELF_C_RDWR mode, when
-		 * elf_update(3) is called, we remove this mapping,
-		 * write file data out using write(2), and map the new
-		 * contents back.
-		 */
-		m = mmap(NULL, fsize, PROT_READ, MAP_PRIVATE, fd, (off_t) 0);
-
-		if (m == MAP_FAILED)
-			m = NULL;
-		else
-			flags = LIBELF_F_RAWFILE_MMAP;
-#endif
-
-		/*
-		 * Fallback to a read() if the call to mmap() failed,
-		 * or if mmap() is not available.
-		 */
-		if (m == NULL) {
-			if ((m = malloc(fsize)) == NULL) {
-				LIBELF_SET_ERROR(RESOURCE, 0);
-				return (NULL);
-			}
-
-			if (read(fd, m, fsize) != (ssize_t) fsize) {
-				LIBELF_SET_ERROR(IO, errno);
-				free(m);
-				return (NULL);
-			}
-
-			flags = LIBELF_F_RAWFILE_MALLOC;
-		}
-	} else if ((m = _libelf_read_special_file(fd, &fsize)) != NULL)
-		flags = LIBELF_F_RAWFILE_MALLOC | LIBELF_F_SPECIAL_FILE;
-	else
-		return (NULL);
-
-	if ((e = _libelf_memory(m, fsize, reporterror)) == NULL) {
-		assert((flags & LIBELF_F_RAWFILE_MALLOC) ||
-		    (flags & LIBELF_F_RAWFILE_MMAP));
-		if (flags & LIBELF_F_RAWFILE_MALLOC)
-			free(m);
-#if	ELFTC_HAVE_MMAP
-		else
-			(void) munmap(m, fsize);
-#endif
-		return (NULL);
-	}
-
-	/* ar(1) archives aren't supported in RDWR mode. */
-	if (c == ELF_C_RDWR && e->e_kind == ELF_K_AR) {
-		(void) elf_end(e);
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	e->e_flags |= flags;
-	e->e_fd = fd;
-	e->e_cmd = c;
-
-	return (e);
-}

loader/src/libelf/libelf_phdr.c

@@ -1,156 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_phdr.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-void *
-_libelf_getphdr(Elf *e, int ec)
-{
-	size_t phnum, phentsize;
-	size_t fsz, msz;
-	uint64_t phoff;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-	void *ehdr, *phdr;
-	int (*xlator)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((phdr = (ec == ELFCLASS32 ?
-		 (void *) e->e_u.e_elf.e_phdr.e_phdr32 :
-		 (void *) e->e_u.e_elf.e_phdr.e_phdr64)) != NULL)
-		return (phdr);
-
-	/*
-	 * Check the PHDR related fields in the EHDR for sanity.
-	 */
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (NULL);
-
-	phnum = e->e_u.e_elf.e_nphdr;
-
-	if (ec == ELFCLASS32) {
-		eh32      = (Elf32_Ehdr *) ehdr;
-		phentsize = eh32->e_phentsize;
-		phoff     = (uint64_t) eh32->e_phoff;
-	} else {
-		eh64      = (Elf64_Ehdr *) ehdr;
-		phentsize = eh64->e_phentsize;
-		phoff     = (uint64_t) eh64->e_phoff;
-	}
-
-	fsz = gelf_fsize(e, ELF_T_PHDR, phnum, e->e_version);
-
-	assert(fsz > 0);
-
-	if ((uint64_t) e->e_rawsize < (phoff + fsz)) {
-		LIBELF_SET_ERROR(HEADER, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_PHDR, ec, EV_CURRENT);
-
-	assert(msz > 0);
-
-	if ((phdr = calloc(phnum, msz)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32)
-		e->e_u.e_elf.e_phdr.e_phdr32 = phdr;
-	else
-		e->e_u.e_elf.e_phdr.e_phdr64 = phdr;
-
-
-	xlator = _libelf_get_translator(ELF_T_PHDR, ELF_TOMEMORY, ec);
-	(*xlator)(phdr, phnum * msz, e->e_rawfile + phoff, phnum,
-	    e->e_byteorder != LIBELF_PRIVATE(byteorder));
-
-	return (phdr);
-}
-
-void *
-_libelf_newphdr(Elf *e, int ec, size_t count)
-{
-	void *ehdr, *newphdr, *oldphdr;
-	size_t msz;
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	assert(e->e_class == ec);
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-	assert(e->e_version == EV_CURRENT);
-
-	msz = _libelf_msize(ELF_T_PHDR, ec, e->e_version);
-
-	assert(msz > 0);
-
-	newphdr = NULL;
-	if (count > 0 && (newphdr = calloc(count, msz)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		if ((oldphdr = (void *) e->e_u.e_elf.e_phdr.e_phdr32) != NULL)
-			free(oldphdr);
-		e->e_u.e_elf.e_phdr.e_phdr32 = (Elf32_Phdr *) newphdr;
-	} else {
-		if ((oldphdr = (void *) e->e_u.e_elf.e_phdr.e_phdr64) != NULL)
-			free(oldphdr);
-		e->e_u.e_elf.e_phdr.e_phdr64 = (Elf64_Phdr *) newphdr;
-	}
-
-	e->e_u.e_elf.e_nphdr = count;
-
-	elf_flagphdr(e, ELF_C_SET, ELF_F_DIRTY);
-
-	return (newphdr);
-}