First commit on new repo.

.gitignore

@@ -0,0 +1,12 @@
+build/*
+*.cbp
+*.elf
+*.cscope_file_list
+*.layout
+screenshots/*
+release/*
+*.mod
+*.id*
+*.nam
+*.til
+*.layout

.gitmodules

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

.travis.yml

@@ -0,0 +1,40 @@
+sudo: required
+services:
+- docker
+addons:
+  apt:
+    packages:
+    - p7zip-full
+before_script:
+- docker build . -t wups-loader-builder
+script:
+- docker run -it --rm -v ${PWD}:/project wups-loader-builder 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)"
+- docker run -it --rm -v ${PWD}:/project wups-loader-builder make
+- cp meta/* wiiu/apps/wiiupluginloader
+- cp 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/WiiUPluginLoader $GIT_TAG > /dev/null 2>&1
+
+deploy:
+  provider: releases
+  skip_cleanup: true
+  prerelease: true
+  api_key:
+        secure: X2kG+KU92Z1G4nMNIycVWk1nvKjfmDlyyh0rYIKbpt2JmvBv/fO4v6oPrVVec7Zc3m42VeqFdjrCn0VatBwNkW9TLjGCysvZrUh2BOgA8cIfJvnt54bckbdbt4DgN6H/QAW7pHVjv6eDZLH4IhBIaxSDN60mhAu2Aa7cZdkkBrHeKwks+fztBNvOYqPcOgxWQbLtN2e9LBk+0tt6n64/Z5F37ydTXm5B8LSI5oEPifPWYfycqmEFxKJUIRPr149Iz62nET/aMC9fUOCjjTOS9k/J0NVuhD/433dto60OUXWGKrMSwfz1hP7HIChgEvxWeczSZP2MczcKm+jZgLK7ML7nIwBIMQovNb8qXdLfRY//IbGYTTjA/4efJ/Przpahry2/5JTAtWxVpfkjXNsajSFFxqYpHkNcYK0+lV2la+Gdp3l7ZkjTcAw22RA6Epfr53cYxXY7PapTc/g/Xe9SMI236QoMobDwAYsxU8Oz+LcCx7an1vJp3O59HqQx5YNNfmSSHOx3DY5Vt4Zxc4POx+v7UIJtJXJZWj09j1s/Spn1Lv7gRomxemneSzsNYMgLduQzwCGD9Eo8DDFyvr//nf5GOB5PDqSP1K9GfLlJs04YdT6Giw/p6JRqvQxnVFIP0I0tll6OARyd6+svjf+q6AQYdlUwYqF03ciFZ555QUo=
+  file: WiiUPluginLoader_$versiontag.zip
+  on:
+    repo: Maschell/WiiUPluginLoader
+    tags: false
+    all_branches: true

Dockerfile

@@ -0,0 +1,22 @@
+FROM wups/core:latest
+
+# clear portlibs. just in case.
+RUN rm -rf $DEVKITPRO/portlibs
+
+# Install devkitARM. Needed to build mocha.
+RUN yes | sudo dkp-pacman -Syu devkitARM --needed 
+ENV DEVKITARM=${DEVKITPRO}/devkitARM
+
+# Get dependencies
+COPY --from=wiiulegacy/dynamic_libs:0.1 /artifacts $DEVKITPRO/portlibs
+COPY --from=wiiulegacy/libiosuhax:0.3 /artifacts $DEVKITPRO/portlibs
+COPY --from=wiiulegacy/libfat:1.1.3a /artifacts $DEVKITPRO/portlibs
+COPY --from=wiiulegacy/libntfs:2013.1.13 /artifacts $DEVKITPRO/portlibs
+COPY --from=wiiulegacy/libutils:0.1 /artifacts $DEVKITPRO/portlibs
+COPY --from=wiiulegacy/libgui:0.1 /artifacts $DEVKITPRO/portlibs
+
+RUN wget https://github.com/Maschell/WiiUPluginLoader/libs/portlibs.zip  && \
+	7z x -y portlibs.zip -o${DEVKITPRO} && \
+	rm portlibs.zip
+	
+WORKDIR project

LICENSE

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

Makefile

@@ -0,0 +1,270 @@
+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
+#---------------------------------------------------------------------------------

README.md

@@ -0,0 +1,72 @@
+[Nightly builds](https://github.com/Maschell/WiiUPluginLoader/releases) | [Issue Tracker](https://github.com/Maschell/WiiUPluginLoader/issues) | [Discussion](https://gbatemp.net/threads/wii-u-plugin-system.496659/) | [Discord](https://discord.gg/bZ2rep2) | [Wiki](https://maschell.github.io/WiiUPluginSystem/dev_overview.html)
+
+# Wii U Plugin Loader [![Build Status](https://api.travis-ci.org/Maschell/WiiUPluginLoader.svg?branch=master)](https://travis-ci.org/Maschell/WiiUPluginLoader)
+
+This is the plugin loader for the [WiiUPluginSystem](https://github.com/Maschell/WiiUPluginSystem).
+
+# 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.
+
+## Usage
+
+Use the "Wii U Plugin Loader" to load plugins from the sd card. It is built to be loaded through the homebrew launcher, which can be either loaded with the browser exploit or haxchi.
+Plugins needs to be placed into the following folder:
+
+```
+sd:/wiiu/plugins
+```
+
+You need to start this Application every time you reboot your console.
+When you re-enter the homebrew launcher, the plugins will get unloaded.
+This means it's not possible to combine this with other homebrews (yet).
+
+## Create plugins
+Information on how to create plugin can be found in the [wiki](https://maschell.github.io/WiiUPluginSystem/dev_plugin_creation_overview.html).
+
+## 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.
+
+A detailed instruction can be found in the Wiki:
+
+- [How to compile the loader](https://maschell.github.io/WiiUPluginSystem/dev_compile_loader.html)  
+
+### Building using the Dockerfile
+It's possible to use a docker image for building. This way you don't need anything installed on your host system.
+
+```
+# Build docker image (only needed once
+docker build . -t wups-loader-builder
+
+# make 
+docker run -it --rm -v ${PWD}:/project wups-loader-builder make
+
+# make clean
+docker run -it --rm -v ${PWD}:/project wups-loader-builder make clean
+```
+
+# 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
+
+# Credits
+Some files are based on brainslug by Chadderz:  
+https://github.com/Chadderz121/brainslug-wii  
+Much stuff also wouldn't be possible without dimok789. He made many great tools and homebrew this stuff in based on (Makefiles, Mocha, homebrew channel, udp logger, dynamic_libs etc.)  
+Also thanks to everyone who made actual exploits.  

filelist.sh

@@ -0,0 +1,71 @@
+#! /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

gitrev.sh

@@ -0,0 +1,29 @@
+#! /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

@@ -0,0 +1,21 @@
+#! /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))

languages/english.lang

@@ -0,0 +1,54 @@
+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 ""

meta/meta.xml

@@ -0,0 +1,13 @@
+<?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>

src/Application.cpp

@@ -0,0 +1,255 @@
+/****************************************************************************
+ * 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());
+    }
+}

src/Application.h

@@ -0,0 +1,92 @@
+/****************************************************************************
+ * 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

src/common/common.h

@@ -0,0 +1,54 @@
+#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 */
+

src/common/retain_vars.cpp

@@ -0,0 +1,18 @@
+#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;

src/common/retain_vars.h

@@ -0,0 +1,20 @@
+#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_

src/custom/gui/DefaultGuiSelectBox.cpp

@@ -0,0 +1,52 @@
+/****************************************************************************
+ * 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);
+}

src/custom/gui/DefaultGuiSelectBox.h

@@ -0,0 +1,45 @@
+/****************************************************************************
+ * 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

src/custom/gui/DefaultGuiSwitch.cpp

@@ -0,0 +1,48 @@
+/****************************************************************************
+ * 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);
+}

src/custom/gui/DefaultGuiSwitch.h

@@ -0,0 +1,45 @@
+/****************************************************************************
+ * 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

src/entry.c

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

src/libelf/_elftc.h

@@ -0,0 +1,430 @@
+/*-
+ * 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 */

src/libelf/_libelf.h

@@ -0,0 +1,223 @@
+/*-
+ * 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_ */

src/libelf/_libelf_ar.h

@@ -0,0 +1,56 @@
+/*-
+ * 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_ */

src/libelf/_libelf_config.h

@@ -0,0 +1,193 @@
+/*-
+ * 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__) */

src/libelf/elf.c

@@ -0,0 +1,40 @@
+/*-
+ * 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
+};

src/libelf/elf_begin.c

@@ -0,0 +1,91 @@
+/*-
+ * 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);
+}

src/libelf/elf_cntl.c

@@ -0,0 +1,58 @@
+/*-
+ * 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;
+}

src/libelf/elf_data.c

@@ -0,0 +1,254 @@
+/*-
+ * 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);
+}

src/libelf/elf_end.c

@@ -0,0 +1,97 @@
+/*-
+ * 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);
+}

src/libelf/elf_errmsg.c

@@ -0,0 +1,85 @@
+/*-
+ * 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];
+}

src/libelf/elf_errno.c

@@ -0,0 +1,43 @@
+/*-
+ * 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);
+}

src/libelf/elf_fill.c

@@ -0,0 +1,39 @@
+/*-
+ * 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;
+}

src/libelf/elf_flag.c

@@ -0,0 +1,198 @@
+/*-
+ * 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));
+}

src/libelf/elf_getarhdr.c

@@ -0,0 +1,47 @@
+/*-
+ * 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));
+}

src/libelf/elf_getarsym.c

@@ -0,0 +1,58 @@
+/*-
+ * 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);
+}

src/libelf/elf_getbase.c

@@ -0,0 +1,48 @@
+/*-
+ * 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));
+}

src/libelf/elf_getident.c

@@ -0,0 +1,68 @@
+/*-
+ * 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);
+}

src/libelf/elf_hash.c

@@ -0,0 +1,56 @@
+/*-
+ * 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);
+}

src/libelf/elf_kind.c

@@ -0,0 +1,44 @@
+/*-
+ * 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);
+}

src/libelf/elf_memory.c

@@ -0,0 +1,47 @@
+/*-
+ * 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));
+}

src/libelf/elf_next.c

@@ -0,0 +1,62 @@
+/*-
+ * 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);
+}

src/libelf/elf_open.c

@@ -0,0 +1,67 @@
+/*-
+ * 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));
+}

src/libelf/elf_phnum.c

@@ -0,0 +1,67 @@
+/*-
+ * 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);
+}

src/libelf/elf_rand.c

@@ -0,0 +1,59 @@
+/*-
+ * 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);
+}

src/libelf/elf_rawfile.c

@@ -0,0 +1,53 @@
+/*-
+ * 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);
+}

src/libelf/elf_scn.c

@@ -0,0 +1,233 @@
+/*-
+ * 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));
+}

src/libelf/elf_shnum.c

@@ -0,0 +1,67 @@
+/*-
+ * 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);
+}

src/libelf/elf_shstrndx.c

@@ -0,0 +1,82 @@
+/*-
+ * 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));
+}

src/libelf/elf_strptr.c

@@ -0,0 +1,132 @@
+/*-
+ * 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);
+}

src/libelf/elf_version.c

@@ -0,0 +1,52 @@
+/*-
+ * 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);
+}

src/libelf/gelf.h

@@ -0,0 +1,106 @@
+/*-
+ * 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_ */

src/libelf/gelf_cap.c

@@ -0,0 +1,151 @@
+/*-
+ * 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);
+}

src/libelf/gelf_checksum.c

@@ -0,0 +1,58 @@
+/*-
+ * 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));
+}

src/libelf/gelf_dyn.c

@@ -0,0 +1,150 @@
+/*-
+ * 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);
+}

src/libelf/gelf_ehdr.c

@@ -0,0 +1,168 @@
+/*-
+ * 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);
+}

src/libelf/gelf_fsize.c

@@ -0,0 +1,62 @@
+/*-
+ * 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);
+}

src/libelf/gelf_getclass.c

@@ -0,0 +1,39 @@
+/*-
+ * 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);
+}

src/libelf/gelf_move.c

@@ -0,0 +1,157 @@
+/*-
+ * 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);
+}

src/libelf/gelf_phdr.c

@@ -0,0 +1,178 @@
+/*-
+ * 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);
+}

src/libelf/gelf_rel.c

@@ -0,0 +1,159 @@
+/*-
+ * 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);
+}

src/libelf/gelf_rela.c

@@ -0,0 +1,162 @@
+/*-
+ * 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);
+}

src/libelf/gelf_shdr.c

@@ -0,0 +1,131 @@
+/*-
+ * 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);
+}

src/libelf/gelf_sym.c

@@ -0,0 +1,160 @@
+/*-
+ * 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);
+}

src/libelf/gelf_syminfo.c

@@ -0,0 +1,151 @@
+/*-
+ * 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);
+}

src/libelf/gelf_symshndx.c

@@ -0,0 +1,136 @@
+/*-
+ * 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);
+}

src/libelf/gelf_xlate.c

@@ -0,0 +1,81 @@
+/*-
+ * 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);
+}

src/libelf/libelf.h

@@ -0,0 +1,250 @@
+/*-
+ * 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_ */

src/libelf/libelf_align.c

@@ -0,0 +1,137 @@
+/*-
+ * 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);
+}

src/libelf/libelf_allocate.c

@@ -0,0 +1,212 @@
+/*-
+ * 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);
+}

src/libelf/libelf_ar.c

@@ -0,0 +1,461 @@
+/*-
+ * 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);
+}

src/libelf/libelf_ar_util.c

@@ -0,0 +1,359 @@
+/*-
+ * 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);
+}

src/libelf/libelf_checksum.c

@@ -0,0 +1,100 @@
+/*-
+ * 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));
+}

src/libelf/libelf_data.c

@@ -0,0 +1,88 @@
+/*-
+ * 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);
+	}
+}

src/libelf/libelf_ehdr.c

@@ -0,0 +1,204 @@
+/*-
+ * 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);
+}

src/libelf/libelf_extended.c

@@ -0,0 +1,136 @@
+/*-
+ * 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);
+}

src/libelf/libelf_fsize.c

@@ -0,0 +1,197 @@
+/*-
+ * 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);
+}

src/libelf/libelf_memory.c

@@ -0,0 +1,96 @@
+/*-
+ * 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);
+}

src/libelf/libelf_msize.c

@@ -0,0 +1,196 @@
+/*-
+ * 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);
+}

src/libelf/libelf_open.c

@@ -0,0 +1,240 @@
+/*-
+ * 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);
+}