d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove svnlite.

Browse Source 
Reviewed by:	bcr, imp, emaste
Differential Revision:	https://reviews.freebsd.org/D30737
This commit is contained in:
John Baldwin 2021-06-11 14:56:41 -07:00
parent e290182bcf
commit 0333fad1b7
1273 changed files with 25 additions and 828187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.inc1
View File

@ -2739,7 +2739,6 @@ NXBMAKEARGS+= \
MK_PROFILE=no \
MK_RETPOLINE=no \
MK_SENDMAIL=no \
MK_SVNLITE=no \
MK_TESTS=no \
MK_WERROR=no \
MK_ZFS=no

25
ObsoleteFiles.inc
View File

@ -40,6 +40,31 @@
# xargs -n1 | sort | uniq -d;
# done
# 20210611: Remove svn and svnlite
OLD_FILES+=usr/bin/svn
OLD_FILES+=usr/bin/svnadmin
OLD_FILES+=usr/bin/svnbench
OLD_FILES+=usr/bin/svndumpfilter
OLD_FILES+=usr/bin/svnfsfs
OLD_FILES+=usr/bin/svnlite
OLD_FILES+=usr/bin/svnliteadmin
OLD_FILES+=usr/bin/svnlitebench
OLD_FILES+=usr/bin/svnlitedumpfilter
OLD_FILES+=usr/bin/svnlitefsfs
OLD_FILES+=usr/bin/svnlitelook
OLD_FILES+=usr/bin/svnlitemucc
OLD_FILES+=usr/bin/svnliterdump
OLD_FILES+=usr/bin/svnliteserve
OLD_FILES+=usr/bin/svnlitesync
OLD_FILES+=usr/bin/svnliteversion
OLD_FILES+=usr/bin/svnlook
OLD_FILES+=usr/bin/svnmucc
OLD_FILES+=usr/bin/svnrdump
OLD_FILES+=usr/bin/svnserve
OLD_FILES+=usr/bin/svnsync
OLD_FILES+=usr/bin/svnversion
OLD_FILES+=usr/share/man/man1/svnlite.1.gz
# 20210607: remove ancontrol(8) related programs
OLD_FILES+=usr/sbin/ancontrol
OLD_FILES+=usr/share/man/man8/ancontrol.8.gz

83
contrib/apr-util/CHANGES
View File

@ -1,83 +0,0 @@
-*- coding: utf-8 -*-
Changes with APR-util 1.6.1
*) Win32: Add function exports from new apr_crypto API's missing in 1.6.0.
*) Win32: Introduce XML_PARSER build-time variable to select the expat
library name to be linked to libaprutil-1.dll. See Makefile.win
*) Win32: Removed lingering xml/xml.dsp project forked from the expat
Project in the 1.9x era. Use expat's maintained build schema instead,
prior to building apr-util.
*) apr_crypto: Fix compatibility with LibreSSL. PR 61596.
[Bernard Spil <brnrd freebsd.org>, Yann Ylavic]
*) sdbm: better database/page validation to fail cleanly when corrupted.
[Yann Ylavic]
Changes with APR-util 1.6.0
*) The expat dependency of apr-util is no longer built with apr-util.
Install expat (including development headers and libraries) first
before building apr-util. [https://libexpat.github.io/]
*) Mark apr_dbd_freetds as unsupported, and remove it from all builds
[Nick Kew]
*) Update MySQL build to stop using libmysqlclient_r.
[Petr Sumbera <petr.sumbera oracle.com>]
*) apr_buckets: Add apr_bucket_file_set_buf_size() which allows to configure
the size of the buffer used to read files. [Yann Ylavic]
*) apr_crypto: avoid excessive iteration in bcrypt hash.
[Hanno Böck <hanno hboeck.de>]
*) apr_siphash: Implement keyed hash function SipHash. [Yann Ylavic]
*) apr_crypto: Add apr_crypto_key() function which supports keys
generated from a passphrase or a raw secret provided by the caller.
Deprecate apr_crypto_passphrase(). [Graham Leggett]
*) apr_crypto_nss: Ensure the SECItem returned by PK11_ParamFromIV
is properly freed. [Graham Leggett]
*) apr_crypto: Don't cache the driver if initialisation fails. This
stops the second and subsequent attempt to use the API from failing
claiming the library is not initialised. [Graham Leggett]
*) apr_crypto: Add a native CommonCrypto implementation for iOS and OSX
where OpenSSL has been deprecated. [Graham Leggett]
*) apr_xml_to_text: Add style APR_XML_X2T_PARSED to maintain a
consistent namespace prefix. [Jari Urpalainen
<jari.urpalainen nokia.com>]
Changes with APR-util 1.5.x and later:
*) http://svn.apache.org/viewvc/apr/apr-util/branches/1.5.x/CHANGES?view=markup
Changes with APR-util 1.4.x and later:
*) http://svn.apache.org/viewvc/apr/apr-util/branches/1.4.x/CHANGES?view=markup
Changes for APR-util 1.3.x and later:
*) http://svn.apache.org/viewvc/apr/apr-util/branches/1.3.x/CHANGES?view=markup
Changes for APR-util 1.2.x and later:
*) http://svn.apache.org/viewvc/apr/apr-util/branches/1.2.x/CHANGES?view=markup
Changes for APR-util 1.1.x and later:
*) http://svn.apache.org/viewvc/apr/apr-util/branches/1.1.x/CHANGES?view=markup
Changes for APR-util 1.0.x and later:
*) http://svn.apache.org/viewvc/apr/apr-util/branches/1.0.x/CHANGES?view=markup
Changes for APR-util 0.9.x and later/earlier:
*) http://svn.apache.org/viewvc/apr/apr-util/branches/0.9.x/CHANGES?view=markup

355
contrib/apr-util/CMakeLists.txt
View File

@ -1,355 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Read README.cmake before using this.
PROJECT(APR-Util C)
CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
FIND_PACKAGE(OpenSSL)
FIND_PACKAGE(expat)
OPTION(APU_HAVE_CRYPTO "Crypto support" OFF)
OPTION(APU_HAVE_ODBC "Build ODBC DBD driver" ON)
OPTION(APR_HAS_LDAP "LDAP support" ON)
OPTION(INSTALL_PDB "Install .pdb files (if generated)" ON)
OPTION(APR_BUILD_TESTAPR "Build the test suite" OFF)
OPTION(TEST_STATIC_LIBS "Test programs use APR static libraries instead of shared libraries?" OFF)
SET(APR_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE STRING "Directory with APR include files")
SET(APR_LIBRARIES "${CMAKE_INSTALL_PREFIX}/lib/libapr-1.lib" CACHE STRING "APR library to link with")
IF(NOT EXISTS "${APR_INCLUDE_DIR}/apr.h")
MESSAGE(FATAL_ERROR "APR include directory ${APR_INCLUDE_DIR} is not correct.")
ENDIF()
FOREACH(onelib ${APR_LIBRARIES})
IF(NOT EXISTS ${onelib})
MESSAGE(FATAL_ERROR "APR library ${onelib} was not found.")
ENDIF()
ENDFOREACH()
IF(APU_HAVE_CRYPTO)
IF(NOT OPENSSL_FOUND)
MESSAGE(FATAL_ERROR "OpenSSL is the only supported crypto implementation, and it wasn't found!")
ENDIF()
ENDIF()
# create 1-or-0 representation of feature tests for apu.h
SET(apu_have_crypto_10 0)
SET(apu_have_apr_iconv_10 0) # not yet implemented
SET(apr_has_ldap_10 0)
IF(APU_HAVE_CRYPTO)
SET(apu_have_crypto_10 1)
ENDIF()
IF(APR_HAS_LDAP)
SET(apr_has_ldap_10 1)
ENDIF()
IF(NOT EXPAT_FOUND)
MESSAGE(FATAL_ERROR "Expat is required, and it wasn't found!")
ENDIF()
SET(XMLLIB_INCLUDE_DIR ${EXPAT_INCLUDE_DIRS})
SET(XMLLIB_LIBRARIES ${EXPAT_LIBRARIES})
SET(LDAP_LIBRARIES)
IF(APR_HAS_LDAP)
SET(LDAP_LIBRARIES wldap32)
ENDIF()
CONFIGURE_FILE(include/apu.hwc
${PROJECT_BINARY_DIR}/apu.h)
CONFIGURE_FILE(include/apr_ldap.hwc
${PROJECT_BINARY_DIR}/apr_ldap.h)
# "COPYONLY" just because anything else isn't implemented ;)
CONFIGURE_FILE(include/private/apu_config.hw
${PROJECT_BINARY_DIR}/apu_config.h
COPYONLY)
CONFIGURE_FILE(include/private/apu_select_dbm.hw
${PROJECT_BINARY_DIR}/apu_select_dbm.h
COPYONLY)
CONFIGURE_FILE(include/apu_want.hw
${PROJECT_BINARY_DIR}/apu_want.h
COPYONLY)
# Generated .h files are stored in PROJECT_BINARY_DIR, not the
# source tree.
#
# BROKEN: not searching PROJECT_BINARY_DIR first, so you have to
# manually delete apu.h in PROJECT_SOURCE_DIR/include if
# you've generated apu.h before using a different build
SET(APR_INCLUDE_DIRECTORIES
${PROJECT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${CMAKE_CURRENT_SOURCE_DIR}/include/private
${APR_INCLUDE_DIR}
)
INCLUDE_DIRECTORIES(${APR_INCLUDE_DIRECTORIES} ${XMLLIB_INCLUDE_DIR})
SET(APR_PUBLIC_HEADERS_STATIC
include/apr_anylock.h
include/apr_base64.h
include/apr_buckets.h
include/apr_crypto.h
include/apr_date.h
include/apr_dbd.h
include/apr_dbm.h
include/apr_hooks.h
include/apr_ldap_init.h
include/apr_ldap_option.h
include/apr_ldap_rebind.h
include/apr_ldap_url.h
include/apr_md4.h
include/apr_md5.h
include/apr_memcache.h
include/apr_optional.h
include/apr_optional_hooks.h
include/apr_queue.h
include/apr_redis.h
include/apr_reslist.h
include/apr_rmm.h
include/apr_sdbm.h
include/apr_sha1.h
include/apr_siphash.h
include/apr_strmatch.h
include/apr_thread_pool.h
include/apr_uri.h
include/apr_uuid.h
include/apr_xlate.h
include/apr_xml.h
include/apu_errno.h
include/apu_version.h
)
# apu_config.h and apu_select_dbm.h are private
SET(APR_PUBLIC_HEADERS_GENERATED
${PROJECT_BINARY_DIR}/apu.h
${PROJECT_BINARY_DIR}/apr_ldap.h
${PROJECT_BINARY_DIR}/apu_want.h
)
SET(APR_SOURCES
buckets/apr_brigade.c
buckets/apr_buckets.c
buckets/apr_buckets_alloc.c
buckets/apr_buckets_eos.c
buckets/apr_buckets_file.c
buckets/apr_buckets_flush.c
buckets/apr_buckets_heap.c
buckets/apr_buckets_mmap.c
buckets/apr_buckets_pipe.c
buckets/apr_buckets_pool.c
buckets/apr_buckets_refcount.c
buckets/apr_buckets_simple.c
buckets/apr_buckets_socket.c
crypto/apr_crypto.c
crypto/apr_md4.c
crypto/apr_md5.c
crypto/apr_passwd.c
crypto/apr_sha1.c
crypto/apr_siphash.c
crypto/crypt_blowfish.c
crypto/getuuid.c
crypto/uuid.c
dbd/apr_dbd.c
dbm/apr_dbm.c
dbm/apr_dbm_sdbm.c
dbm/sdbm/sdbm.c
dbm/sdbm/sdbm_hash.c
dbm/sdbm/sdbm_lock.c
dbm/sdbm/sdbm_pair.c
encoding/apr_base64.c
hooks/apr_hooks.c
memcache/apr_memcache.c
misc/apr_date.c
misc/apr_queue.c
misc/apr_reslist.c
misc/apr_rmm.c
misc/apr_thread_pool.c
misc/apu_dso.c
misc/apu_version.c
redis/apr_redis.c
strmatch/apr_strmatch.c
uri/apr_uri.c
xlate/xlate.c
xml/apr_xml.c
)
IF(APR_HAS_LDAP)
SET(APR_SOURCES ${APR_SOURCES} ldap/apr_ldap_stub.c ldap/apr_ldap_url.c)
ENDIF()
SET(APR_TEST_SOURCES
test/abts.c
test/testbuckets.c
test/testcrypto.c
test/testdate.c
test/testdbd.c
test/testdbm.c
test/testldap.c
test/testmd4.c
test/testmd5.c
test/testmemcache.c
test/testpass.c
test/testqueue.c
test/testredis.c
test/testreslist.c
test/testrmm.c
test/testsiphash.c
test/teststrmatch.c
test/testuri.c
test/testutil.c
test/testuuid.c
test/testxlate.c
test/testxml.c
)
SET(install_targets)
SET(install_bin_pdb)
SET(dbd_drivers)
# Note: The WINNT definition on some targets is used only by libaprutil.rc.
# libaprutil-1 is shared, aprutil-1 is static
ADD_LIBRARY(libaprutil-1 SHARED ${APR_SOURCES} ${APR_PUBLIC_HEADERS_GENERATED} libaprutil.rc)
SET(install_targets ${install_targets} libaprutil-1)
SET(install_bin_pdb ${install_bin_pdb} ${PROJECT_BINARY_DIR}/libaprutil-1.pdb)
TARGET_LINK_LIBRARIES(libaprutil-1 ${APR_LIBRARIES} ${XMLLIB_LIBRARIES})
SET_TARGET_PROPERTIES(libaprutil-1 PROPERTIES COMPILE_DEFINITIONS "APU_DECLARE_EXPORT;APR_DECLARE_EXPORT;XML_STATIC;WINNT")
ADD_LIBRARY(aprutil-1 STATIC ${APR_SOURCES} ${APR_PUBLIC_HEADERS_GENERATED})
SET(install_targets ${install_targets} aprutil-1)
TARGET_LINK_LIBRARIES(aprutil-1 ${APR_LIBRARIES} ${XMLLIB_LIBRARIES})
SET_TARGET_PROPERTIES(aprutil-1 PROPERTIES COMPILE_DEFINITIONS "APU_DECLARE_STATIC;APR_DECLARE_STATIC;APU_DSO_MODULE_BUILD;XML_STATIC")
IF(APU_HAVE_CRYPTO)
IF(NOT OPENSSL_FOUND)
MESSAGE(FATAL_ERROR "Only OpenSSL-based crypto is currently implemented in the cmake build")
ENDIF()
ADD_LIBRARY(apr_crypto_openssl-1 SHARED crypto/apr_crypto_openssl.c libaprutil.rc)
SET(install_targets ${install_targets} apr_crypto_openssl-1)
SET(install_bin_pdb ${install_bin_pdb} ${PROJECT_BINARY_DIR}/apr_crypto_openssl-1.pdb)
SET_TARGET_PROPERTIES(apr_crypto_openssl-1 PROPERTIES INCLUDE_DIRECTORIES "${APR_INCLUDE_DIRECTORIES};${OPENSSL_INCLUDE_DIR}")
SET_TARGET_PROPERTIES(apr_crypto_openssl-1 PROPERTIES COMPILE_DEFINITIONS "WINNT")
SET_TARGET_PROPERTIES(apr_crypto_openssl-1 PROPERTIES COMPILE_FLAGS "-DAPR_DECLARE_EXPORT=1 -DAPU_DECLARE_EXPORT=1 -DDLL_NAME=apr_crypto_openssl")
TARGET_LINK_LIBRARIES(apr_crypto_openssl-1 libaprutil-1 ${APR_LIBRARIES} ${OPENSSL_LIBRARIES})
ENDIF()
IF(APU_HAVE_ODBC)
ADD_LIBRARY(apr_dbd_odbc-1 SHARED dbd/apr_dbd_odbc.c libaprutil.rc)
SET(install_targets ${install_targets} apr_dbd_odbc-1)
SET(install_bin_pdb ${install_bin_pdb} ${PROJECT_BINARY_DIR}/apr_dbd_odbc-1.pdb)
SET(dbd_drivers ${dbd_drivers} odbc)
TARGET_LINK_LIBRARIES(apr_dbd_odbc-1 libaprutil-1 ${APR_LIBRARIES} odbc32 odbccp32)
SET_PROPERTY(TARGET apr_dbd_odbc-1 APPEND PROPERTY LINK_FLAGS /export:apr_dbd_odbc_driver)
SET_TARGET_PROPERTIES(apr_dbd_odbc-1 PROPERTIES COMPILE_DEFINITIONS "APU_HAVE_ODBC;HAVE_SQL_H;APU_DECLARE_EXPORT;APR_DECLARE_EXPORT;APU_DSO_MODULE_BUILD;WINNT")
SET_TARGET_PROPERTIES(apr_dbd_odbc-1 PROPERTIES COMPILE_FLAGS "-DAPR_DECLARE_EXPORT=1 -DAPU_DECLARE_EXPORT=1 -DDLL_NAME=apr_dbd_odbc")
ENDIF()
IF(APR_HAS_LDAP)
ADD_LIBRARY(apr_ldap-1 SHARED ldap/apr_ldap_init.c ldap/apr_ldap_option.c
ldap/apr_ldap_rebind.c libaprutil.rc)
SET(install_targets ${install_targets} apr_ldap-1)
SET(install_bin_pdb ${install_bin_pdb} ${PROJECT_BINARY_DIR}/apr_ldap-1.pdb)
TARGET_LINK_LIBRARIES(apr_ldap-1 libaprutil-1 ${APR_LIBRARIES} ${LDAP_LIBRARIES})
SET_TARGET_PROPERTIES(apr_ldap-1 PROPERTIES COMPILE_DEFINITIONS "WINNT")
SET_TARGET_PROPERTIES(apr_ldap-1 PROPERTIES COMPILE_FLAGS "-DAPR_DECLARE_EXPORT=1 -DAPU_DECLARE_EXPORT=1 -DDLL_NAME=apr_ldap")
SET(apr_ldap_libraries apr_ldap-1)
ELSE()
SET(apr_ldap_libraries)
ENDIF()
IF(APR_BUILD_TESTAPR)
ENABLE_TESTING()
# Create a "check" target that displays test program output to the console.
ADD_CUSTOM_TARGET(check COMMAND ${CMAKE_CTEST_COMMAND} --verbose)
# copy data files to build directory so that we can run programs from there
EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E make_directory
${PROJECT_BINARY_DIR}/data)
EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E copy_if_different
${PROJECT_SOURCE_DIR}/test/data/billion-laughs.xml
${PROJECT_BINARY_DIR}/data/billion-laughs.xml)
IF(TEST_STATIC_LIBS)
SET(whichapr aprutil-1)
SET(apiflag "-DAPR_DECLARE_STATIC -DAPU_DECLARE_STATIC")
ELSE()
SET(whichapr libaprutil-1)
SET(apiflag)
ENDIF()
ADD_EXECUTABLE(testall ${APR_TEST_SOURCES})
TARGET_LINK_LIBRARIES(testall ${whichapr} ${apr_ldap_libraries} ${XMLLIB_LIBRARIES} ${LDAP_LIBRARIES})
IF(apiflag)
SET_TARGET_PROPERTIES(testall PROPERTIES COMPILE_FLAGS ${apiflag})
ENDIF()
ADD_TEST(NAME testall COMMAND testall)
ADD_EXECUTABLE(dbd test/dbd.c)
TARGET_LINK_LIBRARIES(dbd ${whichapr})
IF(apiflag)
SET_TARGET_PROPERTIES(dbd PROPERTIES COMPILE_FLAGS ${apiflag})
ENDIF()
# dbd is run multiple times with different parameters.
FOREACH(somedbd ${dbd_drivers})
ADD_TEST(NAME dbd-${somedbd} COMMAND dbd ${somedbd})
ENDFOREACH()
ENDIF (APR_BUILD_TESTAPR)
# Installation
INSTALL(TARGETS ${install_targets}
RUNTIME DESTINATION bin
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
)
IF(INSTALL_PDB)
INSTALL(FILES ${install_bin_pdb}
DESTINATION bin
CONFIGURATIONS RelWithDebInfo Debug)
ENDIF()
INSTALL(FILES ${APR_PUBLIC_HEADERS_STATIC} ${APR_PUBLIC_HEADERS_GENERATED} DESTINATION include)
STRING(TOUPPER "${CMAKE_BUILD_TYPE}" buildtype)
MESSAGE(STATUS "")
MESSAGE(STATUS "")
MESSAGE(STATUS "APR-Util configuration summary:")
MESSAGE(STATUS "")
MESSAGE(STATUS " Build type ...................... : ${CMAKE_BUILD_TYPE}")
MESSAGE(STATUS " Install .pdb (if available)...... : ${INSTALL_PDB}")
MESSAGE(STATUS " Install prefix .................. : ${CMAKE_INSTALL_PREFIX}")
MESSAGE(STATUS " C compiler ...................... : ${CMAKE_C_COMPILER}")
MESSAGE(STATUS " APR include directory ........... : ${APR_INCLUDE_DIR}")
MESSAGE(STATUS " APR libraries ................... : ${APR_LIBRARIES}")
MESSAGE(STATUS " DBD ODBC driver ................. : ${APU_HAVE_ODBC}")
MESSAGE(STATUS " APU_HAVE_CRYPTO ................. : ${APU_HAVE_CRYPTO}")
MESSAGE(STATUS " APR_HAS_LDAP .................... : ${APR_HAS_LDAP}")
MESSAGE(STATUS " Build test suite ................ : ${APR_BUILD_TESTAPR}")
IF(TEST_STATIC_LIBS)
MESSAGE(STATUS " (testing static libraries)")
ELSE()
MESSAGE(STATUS " (testing dynamic libraries)")
ENDIF()

459
contrib/apr-util/LICENSE
View File

@ -1,459 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
APACHE PORTABLE RUNTIME SUBCOMPONENTS:
The Apache Portable Runtime includes a number of subcomponents with
separate copyright notices and license terms. Your use of the source
code for the these subcomponents is subject to the terms and
conditions of the following licenses.
For the include\apr_md5.h component:
/*
* This is work is derived from material Copyright RSA Data Security, Inc.
*
* The RSA copyright statement and Licence for that original material is
* included below. This is followed by the Apache copyright statement and
* licence for the modifications made to that material.
*/
/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
For the passwd\apr_md5.c component:
/*
* This is work is derived from material Copyright RSA Data Security, Inc.
*
* The RSA copyright statement and Licence for that original material is
* included below. This is followed by the Apache copyright statement and
* licence for the modifications made to that material.
*/
/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
*/
/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
/*
* The apr_md5_encode() routine uses much code obtained from the FreeBSD 3.0
* MD5 crypt() function, which is licenced as follows:
* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <phk@login.dknet.dk> wrote this file. As long as you retain this notice you
* can do whatever you want with this stuff. If we meet some day, and you think
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
* ----------------------------------------------------------------------------
*/
For the crypto\apr_md4.c component:
* This is derived from material copyright RSA Data Security, Inc.
* Their notice is reproduced below in its entirety.
*
* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
* rights reserved.
*
* License to copy and use this software is granted provided that it
* is identified as the "RSA Data Security, Inc. MD4 Message-Digest
* Algorithm" in all material mentioning or referencing this software
* or this function.
*
* License is also granted to make and use derivative works provided
* that such works are identified as "derived from the RSA Data
* Security, Inc. MD4 Message-Digest Algorithm" in all material
* mentioning or referencing the derived work.
*
* RSA Data Security, Inc. makes no representations concerning either
* the merchantability of this software or the suitability of this
* software for any particular purpose. It is provided "as is"
* without express or implied warranty of any kind.
*
* These notices must be retained in any copies of any part of this
* documentation and/or software.
*/
For the crypto\crypt_blowfish.c(.h) component:
* Written by Solar Designer <solar at openwall.com> in 1998-2011.
* No copyright is claimed, and the software is hereby placed in the public
* domain. In case this attempt to disclaim copyright and place the software
* in the public domain is deemed null and void, then the software is
* Copyright (c) 1998-2011 Solar Designer and it is hereby released to the
* general public under the following terms:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted.
*
* There's ABSOLUTELY NO WARRANTY, express or implied.
See crypto/crypt_blowfish.c for more information.
For the include\apr_md4.h component:
*
* This is derived from material copyright RSA Data Security, Inc.
* Their notice is reproduced below in its entirety.
*
* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
* rights reserved.
*
* License to copy and use this software is granted provided that it
* is identified as the "RSA Data Security, Inc. MD4 Message-Digest
* Algorithm" in all material mentioning or referencing this software
* or this function.
*
* License is also granted to make and use derivative works provided
* that such works are identified as "derived from the RSA Data
* Security, Inc. MD4 Message-Digest Algorithm" in all material
* mentioning or referencing the derived work.
*
* RSA Data Security, Inc. makes no representations concerning either
* the merchantability of this software or the suitability of this
* software for any particular purpose. It is provided "as is"
* without express or implied warranty of any kind.
*
* These notices must be retained in any copies of any part of this
* documentation and/or software.
*/
For the test\testmd4.c component:
*
* This is derived from material copyright RSA Data Security, Inc.
* Their notice is reproduced below in its entirety.
*
* Copyright (C) 1990-2, RSA Data Security, Inc. Created 1990. All
* rights reserved.
*
* RSA Data Security, Inc. makes no representations concerning either
* the merchantability of this software or the suitability of this
* software for any particular purpose. It is provided "as is"
* without express or implied warranty of any kind.
*
* These notices must be retained in any copies of any part of this
* documentation and/or software.
*/
For the xml\expat\conftools\install-sh component:
#
# install - install a program, script, or datafile
# This comes from X11R5 (mit/util/scripts/install.sh).
#
# Copyright 1991 by the Massachusetts Institute of Technology
#
# Permission to use, copy, modify, distribute, and sell this software and its
# documentation for any purpose is hereby granted without fee, provided that
# the above copyright notice appear in all copies and that both that
# copyright notice and this permission notice appear in supporting
# documentation, and that the name of M.I.T. not be used in advertising or
# publicity pertaining to distribution of the software without specific,
# written prior permission. M.I.T. makes no representations about the
# suitability of this software for any purpose. It is provided "as is"
# without express or implied warranty.
#
For the expat xml parser component:
Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
and Clark Cooper
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
====================================================================
For the ldap/apr_ldap_url.c component:
/* Portions Copyright 1998-2002 The OpenLDAP Foundation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted only as authorized by the OpenLDAP
* Public License. A copy of this license is available at
* http://www.OpenLDAP.org/license.html or in file LICENSE in the
* top-level directory of the distribution.
*
* OpenLDAP is a registered trademark of the OpenLDAP Foundation.
*
* Individual files and/or contributed packages may be copyright by
* other parties and subject to additional restrictions.
*
* This work is derived from the University of Michigan LDAP v3.3
* distribution. Information concerning this software is available
* at: http://www.umich.edu/~dirsvcs/ldap/
*
* This work also contains materials derived from public sources.
*
* Additional information about OpenLDAP can be obtained at:
* http://www.openldap.org/
*/
/*
* Portions Copyright (c) 1992-1996 Regents of the University of Michigan.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that this notice is preserved and that due credit is given
* to the University of Michigan at Ann Arbor. The name of the University
* may not be used to endorse or promote products derived from this
* software without specific prior written permission. This software
* is provided ``as is'' without express or implied warranty.
*/

123
contrib/apr-util/Makefile.in
View File

@ -1,123 +0,0 @@
#
# Top-level Makefile for APRUTIL
#
CPP = @CPP@
# gets substituted into some targets
APRUTIL_MAJOR_VERSION=@APRUTIL_MAJOR_VERSION@
APRUTIL_DOTTED_VERSION=@APRUTIL_DOTTED_VERSION@
srcdir = @srcdir@
VPATH = @srcdir@
INCLUDES = @APRUTIL_PRIV_INCLUDES@ @APR_INCLUDES@ @APRUTIL_INCLUDES@
APRUTIL_LDFLAGS = @APRUTIL_LDFLAGS@
APRUTIL_LIBS = @APRUTIL_LIBS@
TARGET_LIB = lib@APRUTIL_LIBNAME@.la
INSTALL_SUBDIRS = @APR_ICONV_DIR@
EXTRA_SOURCE_DIRS = @APR_ICONV_DIR@
APRUTIL_PCFILE = apr-util-$(APRUTIL_MAJOR_VERSION).pc
APU_CONFIG = apu-$(APRUTIL_MAJOR_VERSION)-config
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
APU_MODULES = @APU_MODULES@
LINK_MODULE = $(LIBTOOL) $(LTFLAGS) --mode=link $(CC) $(LT_LDFLAGS) $(ALL_CFLAGS) $(ALL_LDFLAGS) $(APRUTIL_LDFLAGS) -release $(APRUTIL_MAJOR_VERSION) -module -rpath $(APU_DSO_LIBDIR)
APU_DSO_LIBDIR = @APU_DSO_LIBDIR@
LT_VERSION = @APU_LTVERSION@
EXTRA_OBJECTS = @EXTRA_OBJECTS@
LDADD_dbd_pgsql = @LDADD_dbd_pgsql@
LDADD_dbd_oracle = @LDADD_dbd_oracle@
LDADD_dbd_sqlite2 = @LDADD_dbd_sqlite2@
LDADD_dbd_sqlite3 = @LDADD_dbd_sqlite3@
LDADD_dbd_mysql = @LDADD_dbd_mysql@
LDADD_dbd_odbc = @LDADD_dbd_odbc@
LDADD_dbm_db = @LDADD_dbm_db@
LDADD_dbm_gdbm = @LDADD_dbm_gdbm@
LDADD_dbm_ndbm = @LDADD_dbm_ndbm@
LDADD_ldap = @LDADD_ldap@
LDADD_crypto_openssl = @LDADD_crypto_openssl@
LDADD_crypto_nss = @LDADD_crypto_nss@
LDADD_crypto_commoncrypto = @LDADD_crypto_commoncrypto@
TARGETS = $(TARGET_LIB) aprutil.exp apu-config.out $(APU_MODULES)
# bring in rules.mk for standard functionality
@INCLUDE_RULES@
@INCLUDE_OUTPUTS@
CLEAN_SUBDIRS = test @APR_ICONV_DIR@
CLEAN_TARGETS = exports.c export_vars.c aprutil.exp .make.dirs apu-config.out
DISTCLEAN_TARGETS = config.cache config.log config.status libtool \
include/private/apu_config.h include/private/apu_private.h \
include/private/apu_select_dbm.h include/apr_ldap.h include/apu.h \
export_vars.sh $(APU_CONFIG) build/rules.mk include/apu_want.h \
apr-util.pc build/pkg/pkginfo
EXTRACLEAN_TARGETS = configure aclocal.m4 include/private/apu_config.h.in \
exports.c build-outputs.mk \
build/apr_common.m4 build/find_apr.m4 build/install.sh \
build/config.guess build/config.sub
prefix=@prefix@
exec_prefix=@exec_prefix@
bindir=@bindir@
libdir=@libdir@
includedir=@includedir@
top_srcdir=@abs_srcdir@
top_blddir=@abs_builddir@
# Create apu-config script suitable for the install tree
apu-config.out: $(APU_CONFIG)
sed 's,^\(location=\).*$$,\1installed,' < $(APU_CONFIG) > $@
install: $(TARGETS) install-modules
$(APR_MKDIR) $(DESTDIR)$(includedir) $(DESTDIR)$(libdir)/pkgconfig \
$(DESTDIR)$(libdir) $(DESTDIR)$(bindir)
for f in $(top_srcdir)/include/*.h $(top_blddir)/include/*.h; do \
$(INSTALL_DATA) $${f} $(DESTDIR)$(includedir); \
done
$(INSTALL_DATA) apr-util.pc $(DESTDIR)$(libdir)/pkgconfig/$(APRUTIL_PCFILE)
list='$(INSTALL_SUBDIRS)'; for i in $$list; do \
( cd $$i ; $(MAKE) DESTDIR=$(DESTDIR) install ); \
done
$(LIBTOOL) --mode=install $(INSTALL) -m 755 $(TARGET_LIB) $(DESTDIR)$(libdir)
$(INSTALL_DATA) aprutil.exp $(DESTDIR)$(libdir)
$(INSTALL) -m 755 apu-config.out $(DESTDIR)$(bindir)/$(APU_CONFIG)
$(TARGET_LIB): $(OBJECTS) $(EXTRA_OBJECTS)
$(LINK) @lib_target@ $(EXTRA_OBJECTS) $(ALL_LIBS) $(APRUTIL_LDFLAGS) $(APRUTIL_LIBS)
install-modules: install-modules-@APU_HAVE_MODULES@
install-modules-no:
install-modules-yes: $(APU_MODULES)
$(APR_MKDIR) $(DESTDIR)$(APU_DSO_LIBDIR)
@for m in $(APU_MODULES); do $(LIBTOOL) $(LT_LTFLAGS) $(LTFLAGS) --mode=install $(INSTALL) -m 755 $$m $(DESTDIR)$(APU_DSO_LIBDIR); done
exports.c: $(HEADERS)
$(APR_MKEXPORT) $(HEADERS) > $@
export_vars.c: $(HEADERS)
$(APR_MKVAREXPORT) $(HEADERS) > $@
aprutil.exp: exports.c export_vars.c
@echo "#! lib@APRUTIL_LIBNAME@.so" > $@
@echo "* This file was AUTOGENERATED at build time." >> $@
@echo "* Please do not edit by hand." >> $@
$(CPP) $(ALL_CPPFLAGS) $(ALL_INCLUDES) exports.c | grep "ap_hack_" | sed -e 's/^.*[)]\(.*\);$$/\1/' >> $@
$(CPP) $(ALL_CPPFLAGS) $(ALL_INCLUDES) export_vars.c | sed -e 's/^\#[^!]*//' | sed -e '/^$$/d' >> $@
dox:
doxygen $(top_srcdir)/docs/doxygen.conf
test: check
check: $(TARGET_LIB)
cd test && $(MAKE) all check
.PHONY: install-modules install-modules-yes install-modules-no dox test check

384
contrib/apr-util/Makefile.win
View File

@ -1,384 +0,0 @@
# Makefile.win for Win32 APR + APR-iconv + APR-util
#
# Targets are:
#
# buildall - compile everything
# checkall - run APR + APR-util regression tests
# install - compile everything
# clean - mop up everything
#
# You can override the build mechanism, choose only one;
#
# USEMAK=1 - compile from exported make files
# USEDSW=1 - compile from .dsw / .dsp VC6 projects
# USESLN=1 - compile from converted .sln / .vcproj VC7+ files
#
# Define ARCH to your desired preference (your PATH must point
# to the correct compiler tools!) Choose only one;
#
# ARCH="Win32 Release"
# ARCH="Win32 Debug"
# ARCH="Win32 Release9x"
# ARCH="Win32 Debug9x"
# ARCH="x64 Release"
# ARCH="x64 Debug"
#
# Provide the APR_PATH, API_PATH and APU_PATH entirely relative
# to one another! At this time, building the libraries themselves
# is only expected to work if the defaults (../apr, ../apr-iconv
# and ../apr-util) are used, or if they are built with USEMAK=1.
#
# APR_PATH=..\apr-1.3.0
# API_PATH=..\apr-iconv-1.3.0
# APU_PATH=..\apr-util-1.3.0
#
# Provide a DBD_LIST argument after configuring LIB and INCLUDE with
# the SDK paths of the corresponding client support libraries.
# ODBC is always built on Windows, so it does not get included in DBD_LIST
# Note that at this time, none of these are supported on win32, per say.
#
# DBD_LIST="sqlite3 pgsql oracle mysql freetds"
#
# Provide a DBM_LIST argument after configuring LIB and INCLUDE with
# the SDK paths of the corresponding database support libraries. Right
# now only db has been configured, gdbm and ndbm require additional study.
# Note that at this time, none of these are supported on win32, per say.
#
# DBM_LIST="db gdbm"
#
# Provide a CRYPTO_LIST argument after configuring LIB and INCLUDE with
# the SDK paths of the corresponding cryptographic support libraries.
#
# CRYPTO_LIST="nss openssl"
#
# Provide the XML_PARSER argument after configuring LIB and INCLUDE with
# the expat path of the corresponding xml parser, e.g. libexpatMT to choose
# static, or libexpat (default) to choose the dynamic library for aprutil-1.dll
# (Static libaprutil-1.lib always presumes libexpatMT with XML_STATIC flag.)
#
# XML_PARSER="libexpat"
#
# For example;
#
# nmake -f Makefile.win PREFIX=C:\APR buildall checkall installall clean
#
!IF EXIST("aprutil.sln") && ([devenv /help > NUL 2>&1] == 0) \
&& !defined(USEMAK) && !defined(USEDSW)
USESLN=1
USEMAK=0
USEDSW=0
!ELSEIF EXIST("aprutil.mak") && !defined(USEDSW)
USESLN=0
USEMAK=1
USEDSW=0
!ELSE
USESLN=0
USEMAK=0
USEDSW=1
!ENDIF
PREFIX=..\apr-dist
!IF EXIST("..\openssl")
!IF EXIST("..\openssl\libcrypto.lib")
SSLOPT=_HAVE_OSSL110=1
!ENDIF
!ENDIF
# Legacy default (and unwise alternative) for libapr-1.dll is libexpatMT
XML_PARSER="libexpat"
!IF "$(XML_PARSER)" == "libexpat"
XMLOPT=XML_PARSER=$(XML_PARSER)
!ELSE
XMLOPT=XML_PARSER=$(XML_PARSER) XML_OPTIONS="/D XML_STATIC"
!ENDIF
!IF [$(COMSPEC) /c cl /nologo /? \
| $(SystemRoot)\System32\find.exe "x64" >NUL ] == 0
ARCH=x64 Release
!ELSE
ARCH=Win32 Release
!ENDIF
APR_PATH=..\apr
API_PATH=..\apr-iconv
APU_PATH=..\apr-util
!MESSAGE ARCH = $(ARCH)
!MESSAGE APR_PATH = $(APR_PATH)
!MESSAGE API_PATH = $(API_PATH) (apr-iconv)
!MESSAGE APU_PATH = $(APU_PATH) (apr-util)
!MESSAGE PREFIX = $(PREFIX) (install path)
!MESSAGE DBD_LIST = $(DBD_LIST)
!MESSAGE DBM_LIST = $(DBM_LIST)
!MESSAGE CRYPTO_LIST = $(CRYPTO_LIST)
# Utility and Translation things, nothing here for the user
#
!IF "$(ARCH)" == "Win32 Release"
SLNARCH=Release|Win32
ARCHPATH=Release
LIBSPATH=LibR
ARCHOSPATH=Release
LIBSOSPATH=LibR
!ELSEIF "$(ARCH)" == "Win32 Debug"
SLNARCH=Debug|Win32
ARCHPATH=Debug
LIBSPATH=LibD
ARCHOSPATH=Debug
LIBSOSPATH=LibD
!ELSEIF "$(ARCH)" == "Win32 Release9x"
SLNARCH=Release9x|Win32
ARCHPATH=Release
LIBSPATH=LibR
ARCHOSPATH=9x\Release
LIBSOSPATH=9x\LibR
!ELSEIF "$(ARCH)" == "Win32 Debug9x"
SLNARCH=Debug9x|Win32
ARCHPATH=Debug
LIBSPATH=LibD
ARCHOSPATH=9x\Debug
LIBSOSPATH=9x\LibD
!ELSEIF "$(ARCH)" == "x64 Release"
SLNARCH=Release|x64
ARCHPATH=x64\Release
LIBSPATH=x64\LibR
ARCHOSPATH=x64\Release
LIBSOSPATH=x64\LibR
!ELSEIF "$(ARCH)" == "x64 Debug"
SLNARCH=Debug|x64
ARCHPATH=x64\Debug
LIBSPATH=x64\LibD
ARCHOSPATH=x64\Debug
LIBSOSPATH=x64\LibD
!ENDIF
!IFNDEF MAKEOPT
# Only default the behavior if MAKEOPT= is omitted
!IFDEF _NMAKE_VER
# Microsoft NMake options
MAKEOPT=-nologo
!ELSEIF "$(MAKE)" == "make"
# Borland make options? Not really supported (yet)
MAKEOPT=-s -N
!ENDIF
!ENDIF
# Sanity Checks
#
!IF !EXIST("$(APR_PATH)\apr.dsp") || !EXIST("$(API_PATH)\apriconv.dsp") \
|| !EXIST("$(APU_PATH)\aprutil.dsp")
!MESSAGE Please check out or download and unpack the Apache Portability Runtime
!MESSAGE sources (apr, apr-iconv and apr-util) under a single parent dir,
!MESSAGE or provide APR_PATH, API_PATH and APU_PATH (all relative to each other,
!MESSAGE or all absolute paths).
!MESSAGE Apache cannot build without these libraries!
!MESSAGE
!ERROR Need apr and apr-iconv alongside apr-util to build!
!ENDIF
all: buildall checkall
# To help win32 pick up the locations where they don't fall in the usual
# path locations. This may not be completely effective for USESLN/USEDSP
# oriented builds, just yet
#
LIB=$(APR_PATH)\$(ARCHOSPATH);$(APR_PATH)\$(LIBSOSPATH);$(API_PATH)\$(ARCHPATH);$(API_PATH)\$(LIBSPATH);$(APU_PATH)\$(ARCHPATH);$(APU_PATH)\$(LIBSPATH);$(LIB)
INCLUDE=$(APR_PATH)\include;$(API_PATH)\include;$(INCLUDE)
!IF $(USEMAK) == 1
clean:
$(MAKE) $(MAKEOPT) -f Makefile.win ARCH="$(ARCH)" \
CTARGET=CLEAN buildall
buildall:
cd $(APR_PATH)
$(MAKE) $(MAKEOPT) -f apr.mak CFG="apr - $(ARCH)" RECURSE=0 $(CTARGET)
$(MAKE) $(MAKEOPT) -f libapr.mak CFG="libapr - $(ARCH)" RECURSE=0 $(CTARGET)
cd build
$(MAKE) $(MAKEOPT) -f aprapp.mak CFG="aprapp - $(ARCH)" RECURSE=0 $(CTARGET)
$(MAKE) $(MAKEOPT) -f libaprapp.mak CFG="libaprapp - $(ARCH)" RECURSE=0 $(CTARGET)
cd ..
cd $(API_PATH)
$(MAKE) $(MAKEOPT) -f apriconv.mak CFG="apriconv - $(ARCH)" RECURSE=0 $(CTARGET)
$(MAKE) $(MAKEOPT) -f libapriconv.mak CFG="libapriconv - $(ARCH)" RECURSE=0 $(CTARGET)
!IF "$(CTARGET)" == "CLEAN"
$(MAKE) $(MAKEOPT) -f build\modules.mk.win clean \
BUILD_MODE="$(ARCH)" BIND_MODE=shared API_SOURCE=.
!ELSE
cd ccs
$(MAKE) $(MAKEOPT) -f Makefile.win all \
BUILD_MODE="$(ARCH)" BIND_MODE=shared
cd ..\ces
$(MAKE) $(MAKEOPT) -f Makefile.win all \
BUILD_MODE="$(ARCH)" BIND_MODE=shared
cd ..
!ENDIF
cd $(APU_PATH)
$(MAKE) $(MAKEOPT) $(SSLOPT) $(XMLOPT) -f aprutil.mak CFG="aprutil - $(ARCH)" RECURSE=0 $(CTARGET)
$(MAKE) $(MAKEOPT) $(SSLOPT) $(XMLOPT) -f libaprutil.mak CFG="libaprutil - $(ARCH)" RECURSE=0 $(CTARGET)
cd ldap
$(MAKE) $(MAKEOPT) -f apr_ldap.mak CFG="apr_ldap - $(ARCH)" RECURSE=0 $(CTARGET)
cd ..
cd dbd
for %d in (odbc $(DBD_LIST)) do \
$(MAKE) $(MAKEOPT) -f apr_dbd_%d.mak CFG="apr_dbd_%d - $(ARCH)" RECURSE=0 $(CTARGET)
cd ..
cd dbm
for %d in ($(DBM_LIST) x) do if not %d == x \
$(MAKE) $(MAKEOPT) -f apr_dbm_%d.mak CFG="apr_dbm_%d - $(ARCH)" RECURSE=0 $(CTARGET)
cd ..
cd crypto
for %d in ($(CRYPTO_LIST) x) do if not %d == x \
$(MAKE) $(MAKEOPT) $(SSLOPT) -f apr_crypto_%d.mak CFG="apr_crypto_%d - $(ARCH)" RECURSE=0 $(CTARGET)
cd ..
!ELSEIF $(USESLN) == 1
clean:
-for %d in (odbc $(DBD_LIST)) do \
devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project apr_dbd_%d
-for %d in ($(DBM_LIST) x) do if not %d == x \
devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project apr_dbm_%d
-for %d in ($(CRYPTO_LIST) x) do if not %d == x \
devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project apr_crypto_%d
-devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project apr_ldap
-devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project libaprutil
-devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project aprutil
cd $(API_PATH)
-$(MAKE) $(MAKEOPT) -f build\modules.mk.win clean \
BUILD_MODE="$(ARCH)" BIND_MODE=shared API_SOURCE=.
cd $(APU_PATH)
-devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project libapriconv
-devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project apriconv
-devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project libaprapp
-devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project aprapp
-devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project libapr
-devenv aprutil.sln /useenv /clean "$(SLNARCH)" /project apr
buildall:
devenv aprutil.sln /useenv /build "$(SLNARCH)" /project aprapp
devenv aprutil.sln /useenv /build "$(SLNARCH)" /project libaprapp
devenv aprutil.sln /useenv /build "$(SLNARCH)" /project aprutil
devenv aprutil.sln /useenv /build "$(SLNARCH)" /project libaprutil
devenv aprutil.sln /useenv /build "$(SLNARCH)" /project apr_ldap
for %d in (odbc $(DBD_LIST)) do \
devenv aprutil.sln /useenv /build "$(SLNARCH)" /project apr_dbd_%d
for %d in ($(DBM_LIST) x) do if not %d == x \
devenv aprutil.sln /useenv /build "$(SLNARCH)" /project apr_dbm_%d
for %d in ($(CRYPTO_LIST) x) do if not %d == x \
devenv aprutil.sln /useenv /build "$(SLNARCH)" /project apr_crypto_%d
!ELSE
# $(USEDSP) == 1
clean:
-for %d in (odbc $(DBD_LIST)) do \
msdev aprutil.dsw /USEENV /MAKE "apr_dbd_%d - $(ARCH)" /CLEAN
-for %d in ($(DBM_LIST) x) do if not %d == x \
msdev aprutil.dsw /USEENV /MAKE "apr_dbm_%d - $(ARCH)" /CLEAN
-for %d in ($(CRYPTO_LIST) x) do if not %d == x \
msdev aprutil.dsw /USEENV /MAKE "apr_crypto_%d - $(ARCH)" /CLEAN
-msdev aprutil.dsw /USEENV /MAKE "apr_ldap - $(ARCH)" /CLEAN
-msdev aprutil.dsw /USEENV /MAKE "libaprutil - $(ARCH)" /CLEAN
-msdev aprutil.dsw /USEENV /MAKE "aprutil - $(ARCH)" /CLEAN
cd $(API_PATH)
$(MAKE) $(MAKEOPT) -f build\modules.mk.win clean \
BUILD_MODE="$(ARCH)" BIND_MODE=shared API_SOURCE=.
cd $(APU_PATH)
-msdev aprutil.dsw /USEENV /MAKE "libapriconv - $(ARCH)" /CLEAN
-msdev aprutil.dsw /USEENV /MAKE "apriconv - $(ARCH)" /CLEAN
-msdev aprutil.dsw /USEENV /MAKE "libaprapp - $(ARCH)" /CLEAN
-msdev aprutil.dsw /USEENV /MAKE "aprapp - $(ARCH)" /CLEAN
-msdev aprutil.dsw /USEENV /MAKE "libapr - $(ARCH)" /CLEAN
-msdev aprutil.dsw /USEENV /MAKE "apr - $(ARCH)" /CLEAN
buildall:
@msdev aprutil.dsw /USEENV /MAKE "aprapp - $(ARCH)"
@msdev aprutil.dsw /USEENV /MAKE "aprutil - $(ARCH)"
@msdev aprutil.dsw /USEENV /MAKE "libaprapp - $(ARCH)"
@msdev aprutil.dsw /USEENV /MAKE "libaprutil - $(ARCH)"
@msdev aprutil.dsw /USEENV /MAKE "apr_ldap - $(ARCH)"
@for %d in (odbc $(DBD_LIST)) do \
msdev aprutil.dsw /USEENV /MAKE "apr_dbd_%d - $(ARCH)"
@for %d in ($(DBM_LIST) x) do if not %d == x \
msdev aprutil.dsw /USEENV /MAKE "apr_dbm_%d - $(ARCH)"
@for %d in ($(CRYPTO_LIST) x) do if not %d == x \
msdev aprutil.dsw /USEENV /MAKE "apr_crypto_%d - $(ARCH)"
!ENDIF
checkapr:
cd $(APR_PATH)\test
$(MAKE) $(MAKEOPT) -f Makefile.win MODEL=static \
OUTDIR=$(LIBSOSPATH) check
$(MAKE) $(MAKEOPT) -f Makefile.win MODEL=dynamic \
OUTDIR=$(ARCHOSPATH) check
cd ..
cd $(APU_PATH)
checkapu:
cd $(APU_PATH)
cd test
$(MAKE) $(MAKEOPT) -f Makefile.win MODEL=static \
OUTDIR=$(LIBSPATH) APROUTDIR=$(LIBSOSPATH) \
APR_PATH=..\$(APR_PATH) API_PATH=..\$(API_PATH) check
$(MAKE) $(MAKEOPT) -f Makefile.win MODEL=dynamic \
OUTDIR=$(ARCHPATH) APROUTDIR=$(ARCHOSPATH) \
APR_PATH=..\$(APR_PATH) API_PATH=..\$(API_PATH) check
cd ..
checkall: checkapr checkapu
install:
echo Y >.y
echo A >.A
@if NOT EXIST "$(PREFIX)\." mkdir "$(PREFIX)"
@if NOT EXIST "$(PREFIX)\bin\." mkdir "$(PREFIX)\bin"
@if NOT EXIST "$(PREFIX)\bin\iconv\." mkdir "$(PREFIX)\bin\iconv"
@if NOT EXIST "$(PREFIX)\include\." mkdir "$(PREFIX)\include"
@if NOT EXIST "$(PREFIX)\lib\." mkdir "$(PREFIX)\lib"
copy CHANGES "$(PREFIX)\CHANGES.txt" <.y
copy LICENSE "$(PREFIX)\LICENSE.txt" <.y
copy NOTICE "$(PREFIX)\NOTICE.txt" <.y
xcopy $(APR_PATH)\include\*.h "$(PREFIX)\include\" /d < .a
xcopy $(APU_PATH)\include\*.h "$(PREFIX)\include\" /d < .a
copy $(APR_PATH)\$(LIBSOSPATH)\apr-1.lib "$(PREFIX)\lib\" <.y
copy $(APR_PATH)\$(LIBSOSPATH)\apr-1.pdb "$(PREFIX)\lib\" <.y
copy $(APU_PATH)\$(LIBSPATH)\aprutil-1.lib "$(PREFIX)\lib\" <.y
copy $(APU_PATH)\$(LIBSPATH)\aprutil-1.pdb "$(PREFIX)\lib\" <.y
copy $(APR_PATH)\$(ARCHOSPATH)\libapr-1.lib "$(PREFIX)\lib\" <.y
copy $(APR_PATH)\$(ARCHOSPATH)\libapr-1.exp "$(PREFIX)\lib\" <.y
copy $(APU_PATH)\$(ARCHPATH)\libaprutil-1.lib "$(PREFIX)\lib\" <.y
copy $(APU_PATH)\$(ARCHPATH)\libaprutil-1.exp "$(PREFIX)\lib\" <.y
copy $(APR_PATH)\$(ARCHOSPATH)\libapr-1.dll "$(PREFIX)\bin\" <.y
copy $(APR_PATH)\$(ARCHOSPATH)\libapr-1.pdb "$(PREFIX)\bin\" <.y
copy $(API_PATH)\$(ARCHPATH)\libapriconv-1.dll "$(PREFIX)\bin\" <.y
copy $(API_PATH)\$(ARCHPATH)\libapriconv-1.pdb "$(PREFIX)\bin\" <.y
copy $(APU_PATH)\$(ARCHPATH)\libaprutil-1.dll "$(PREFIX)\bin\" <.y
copy $(APU_PATH)\$(ARCHPATH)\libaprutil-1.pdb "$(PREFIX)\bin\" <.y
copy $(APU_PATH)\ldap\$(ARCHPATH)\apr_ldap-1.dll "$(PREFIX)\bin\" <.y
copy $(APU_PATH)\ldap\$(ARCHPATH)\apr_ldap-1.pdb "$(PREFIX)\bin\" <.y
for %d in (odbc $(DBD_LIST)) do ( \
copy $(APU_PATH)\dbd\$(ARCHPATH)\apr_dbd_%d-1.dll "$(PREFIX)\bin\" <.y && \
copy $(APU_PATH)\dbd\$(ARCHPATH)\apr_dbd_%d-1.pdb "$(PREFIX)\bin\" <.y \
)
for %d in ($(DBM_LIST) x) do if not %d == x ( \
copy $(APU_PATH)\dbm\$(ARCHPATH)\apr_dbm_%d-1.dll "$(PREFIX)\bin\" <.y && \
copy $(APU_PATH)\dbm\$(ARCHPATH)\apr_dbm_%d-1.pdb "$(PREFIX)\bin\" <.y \
)
for %d in ($(CRYPTO_LIST) x) do if not %d == x ( \
copy $(APU_PATH)\crypto\$(ARCHPATH)\apr_crypto_%d-1.dll "$(PREFIX)\bin\" <.y && \
copy $(APU_PATH)\crypto\$(ARCHPATH)\apr_crypto_%d-1.pdb "$(PREFIX)\bin\" <.y \
)
xcopy $(API_PATH)\$(ARCHPATH)\iconv\*.so "$(PREFIX)\bin\iconv\" /d < .a
xcopy $(API_PATH)\$(ARCHPATH)\iconv\*.pdb "$(PREFIX)\bin\iconv\" /d < .a
del .y
del .a

14
contrib/apr-util/NOTICE
View File

@ -1,14 +0,0 @@
Apache Portable Runtime Utility Library
Copyright (c) 2000-2016 The Apache Software Foundation.
This product includes software developed at
The Apache Software Foundation (http://www.apache.org/).
Portions of this software were developed at the National Center
for Supercomputing Applications (NCSA) at the University of
Illinois at Urbana-Champaign.
This software contains code derived from the RSA Data Security
Inc. MD5 Message-Digest Algorithm, including various
modifications by Spyglass Inc., Carnegie Mellon University, and
Bell Communications Research, Inc (Bellcore).

310
contrib/apr-util/NWGNUmakefile
View File

@ -1,310 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
ldap \
xml \
$(EOLIST)
ifdef WITH_APR_DBD
SUBDIRS += \
dbd \
$(EOLIST)
endif
ifdef WITH_APR_DBM
SUBDIRS += \
dbm \
$(EOLIST)
endif
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
include $(APR_WORK)/build/NWGNUhead.inc
#
# Make sure all needed macro's are defined
#
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(APR)/include \
$(APR)/include/arch/NetWare \
$(APU)/include \
$(APU)/uri \
$(APU)/dbm/sdbm \
$(APU)/include/private \
$(APUXML)/expat/lib \
$(LDAPSDK)/inc \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
$(EOLIST)
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME =
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION =
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME =
#
# If this is specified, it will override VERSION value in
# $(APR_WORK)/build/NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE =
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If this is specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(APR)/misc/netware/apache.xdc. XDCData can
# be disabled by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# Declare all target files (you must add your files here)
#
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(EOLIST)
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(OBJDIR)/apulib.lib \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(EOLIST)
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
$(EOLIST)
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
$(EOLIST)
#
# Any symbols exported to here
#
FILES_nlm_exports = \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(OBJDIR)/apr_base64.o \
$(OBJDIR)/apr_brigade.o \
$(OBJDIR)/apr_buckets.o \
$(OBJDIR)/apr_buckets_alloc.o \
$(OBJDIR)/apr_buckets_eos.o \
$(OBJDIR)/apr_buckets_file.o \
$(OBJDIR)/apr_buckets_flush.o \
$(OBJDIR)/apr_buckets_heap.o \
$(OBJDIR)/apr_buckets_mmap.o \
$(OBJDIR)/apr_buckets_pipe.o \
$(OBJDIR)/apr_buckets_pool.o \
$(OBJDIR)/apr_buckets_refcount.o \
$(OBJDIR)/apr_buckets_simple.o \
$(OBJDIR)/apr_buckets_socket.o \
$(OBJDIR)/apr_crypto.o \
$(OBJDIR)/apr_date.o \
$(OBJDIR)/apr_dbm.o \
$(OBJDIR)/apr_dbd.o \
$(OBJDIR)/apr_dbm_sdbm.o \
$(OBJDIR)/apu_dso.o \
$(OBJDIR)/apr_hooks.o \
$(OBJDIR)/apr_md4.o \
$(OBJDIR)/apr_md5.o \
$(OBJDIR)/apr_memcache.o \
$(OBJDIR)/apr_passwd.o \
$(OBJDIR)/apr_queue.o \
$(OBJDIR)/apr_redis.o \
$(OBJDIR)/apr_reslist.o \
$(OBJDIR)/apr_rmm.o \
$(OBJDIR)/apr_sha1.o \
$(OBJDIR)/apr_siphash.o \
$(OBJDIR)/apu_version.o \
$(OBJDIR)/getuuid.o \
$(OBJDIR)/uuid.o \
$(OBJDIR)/apr_strmatch.o \
$(OBJDIR)/apr_thread_pool.o \
$(OBJDIR)/apr_uri.o \
$(OBJDIR)/crypt_blowfish.o \
$(OBJDIR)/sdbm.o \
$(OBJDIR)/sdbm_hash.o \
$(OBJDIR)/sdbm_lock.o \
$(OBJDIR)/sdbm_pair.o \
$(OBJDIR)/xlate.o \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(APR_WORK)/build/NWGNUhead.inc for examples)
#
install :: nlms FORCE
#
# Any specialized rules here
#
vpath %.c buckets:crypto:dbd:dbm:dbm/sdbm:encoding:hooks:ldap:memcache:redis:misc:strmatch:uri:xlate:xml
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

111
contrib/apr-util/README
View File

@ -1,111 +0,0 @@
Apache Portable Runtime Utility Library README
----------------------------------------------
The Apache Portable Runtime Utility Library provides a predictable
and consistent interface to underlying client library interfaces.
This API assures predictable if not identical behavior regardless
of which libraries are available on a given platform.
APR and its companion libraries are implemented entirely in C
and provide a common programming interface across a wide variety
of operating system platforms without sacrificing performance.
Currently supported platforms include:
UNIX variants
Windows
Netware
Mac OS X
OS/2
To give a brief overview, the primary core
subsystems of APR-util 1.3 include the following:
Hashing and UUID services
Multiple SQL DBD client interfaces
Multiple flat-database DBM client interfaces
Typesafe function Hooks abstraction
LDAP SSL connections for a variety of LDAP toolkits
MemCache interface
Date parsing rourtines
Resource Lists
Thread Pools
Queues
Relocatable Memory Management functions
String filename-style pattern matching
URI Parsing
Charset translation (iconv based)
XML parsing (expat)
For a more complete list, please refer to the following URLs:
http://apr.apache.org/docs/apr-util/modules.html
Users of APR 0.9 should be aware that migrating to the APR 1.x
programming interfaces may require some adjustments; APR 1.x is
neither source nor binary compatible with earlier APR 0.9 releases.
Users of APR 1.x can expect consistent interfaces and binary backwards
compatibility throughout the entire APR 1.x release cycle, as defined
in our versioning rules:
http://apr.apache.org/versioning.html
APR is already used extensively by the Apache HTTP Server
version 2 and the Subversion revision control system, to
name but a few. We list all known projects using APR at
http://apr.apache.org/projects.html -- so please let us know
if you find our libraries useful in your own projects!
Database Providers
------------------
As of apr-util version 1.2.11, MySQL DBD driver is shipped as part of the
distribution. However, to avoid licensing incompatibilities, it is not
built by default. To enable MySQL support, use the --with-mysql option,
but be aware that the MySQL license may introduce licensing implications
for your compiled code. Similarly, the bindings for propritary drivers
such as Oracle (--with-oracle option) must also be explicitly enabled.
On windows, selection of supported drivers is via the environment values
DBD_LIST (for mysql, oracle, pgsql, sqlite2 and/or sqlite3)
and DBM_LIST (db and/or gdbm). DBD odbc and DBM sdbm are unconditionally
compiled and installed, do not include these in the list.
Whenever distributing apr-util in combination with database client
drivers, always review the license requirements of all components.
Cryptographic Software Notice
-----------------------------
This distribution includes cryptographic software. The country in
which you currently reside may have restrictions on the import,
possession, use, and/or re-export to another country, of
encryption software. BEFORE using any encryption software, please
check your country's laws, regulations and policies concerning the
import, possession, or use, and re-export of encryption software, to
see if this is permitted. See http://www.wassenaar.org/ for more
information.
The U.S. Government Department of Commerce, Bureau of Industry and
Security (BIS), has classified this software as Export Commodity
Control Number (ECCN) 5D002.C.1, which includes information security
software using or performing cryptographic functions with asymmetric
algorithms. The form and manner of this Apache Software Foundation
distribution makes it eligible for export under the License Exception
ENC Technology Software Unrestricted (TSU) exception (see the BIS
Export Administration Regulations, Section 740.13) for both object
code and source code.
The following provides more details on the included cryptographic
software:
APR-Util provides an abstract interface for symmetrical cryptographic
functions that make use of a general-purpose encryption library,
such as OpenSSL, NSS, or the operating system's platform-specific
facilities. This interface is known as the apr_crypto interface,
with implementation beneath the /crypto directory.
APR-Util provides an abstract interface for SSL encrypted LDAP (ldaps
and STARTTLS style) connections, which can be powered by OpenLDAP,
Netscape LDAP SDK, Mozilla LDAP SDK, or other platform specific ldap
interfaces.

11
contrib/apr-util/README.FREETDS
View File

@ -1,11 +0,0 @@
The APR DBD Driver for FreeTDS has been removed from the build.
It is known to have problems, and we are not able to maintain it.
The source code is still available. If you want it and are able
to manage maintenance for yourself, you can patch the build and
work through issues that affect you, but you're on your own.
We expect that for most users, the ODBC driver will serve as
an alternative.
Sorry.

139
contrib/apr-util/README.cmake
View File

@ -1,139 +0,0 @@
Experimental cmake-based build support for APR-Util on Microsoft Windows
Status
------
This build support is currently intended only for Microsoft Windows.
Only Windows NT-based systems can be targeted. (The traditional
Windows build support for APR can target Windows 9x as well.)
This build support is experimental. Specifically,
* It does not support all features of APR-Util.
* Some components may not be built correctly and/or in a manner
compatible with the previous Windows build support.
* Build interfaces, such as the mechanisms which are used to enable
optional functionality or specify prerequisites, may change from
release to release as feedback is received from users and bugs and
limitations are resolved.
Important: Refer to the "Known Bugs and Limitations" section for further
information.
It is beyond the scope of this document to document or explain
how to utilize the various cmake features, such as different
build backends or provisions for finding support libraries.
Please refer to the cmake documentation for additional information
that applies to building any project with cmake.
Prerequisites
-------------
The following tools must be in PATH:
* cmake, version 2.8 or later
cmake version 3.1.3 or later is required to work with current OpenSSL
releases. (OpenSSL is an optional prerequisite of APR-Util.)
* If using a command-line compiler: compiler and linker and related tools
(Refer to the cmake documentation for more information.)
The following support libraries are mandatory:
* APR 1.4.x or APR 1.5.x, built with cmake
Optional support libraries allow optional features of APR to be enabled:
* OpenSSL
* many others potentially, though the build support isn't currently
implemented
How to build
------------
1. cd to a clean directory for building (i.e., don't build in your
source tree)
2. Some cmake backends may want your compile tools in PATH. (Hint: "Visual
Studio Command Prompt")
3. set CMAKE_LIBRARY_PATH=d:\path\to\prereq1\lib;d:\path\to\prereq2\lib;...
4. set CMAKE_INCLUDE_PATH=d:\path\to\prereq1\include;d:\path\to\prereq2\include;...
5. cmake -G "some backend, like 'NMake Makefiles'"
-DCMAKE_INSTALL_PREFIX=d:/path/to/aprinst
-DAPR-Util-specific-flags
d:/path/to/aprutilsource
If APR 1.x was installed to a different directory than APR-Util,
also pass these additional arguments:
-DAPR_INCLUDE_DIR=d:/path/to/apr1inst/include
-DAPR_LIBRARIES=d:/path/to/apr1inst/lib/libapr-1.lib
Alternately, use cmake-gui and update settings in the GUI.
APR-Util feature flags:
APU_HAVE_CRYPTO Build crypt support (only the OpenSSL
implementation is currently supported)
Default: OFF
APU_HAVE_ODBC Build ODBC DBD driver
Default: ON
APR_BUILD_TESTAPR Build APR-Util test suite
Default: OFF
TEST_STATIC_LIBS Build the test suite to test the APR static
library instead of the APR dynamic library.
Default: OFF
In order to build the test suite against both
static and dynamic libraries, separate builds
will be required, one with TEST_STATIC_LIBS
set to ON.
INSTALL_PDB Install .pdb files if generated.
Default: ON
CMAKE_C_FLAGS_RELEASE, _DEBUG, _RELWITHDEBINFO, _MINSIZEREL
CMAKE_BUILD_TYPE
For NMake Makefiles the choices are at least DEBUG, RELEASE,
RELWITHDEBINFO, and MINSIZEREL
Other backends make have other selections.
6. build using chosen backend (e.g., "nmake install")
Known Bugs and Limitations
--------------------------
* If include/apu.h or other generated files have been created in the source
directory by another build system, they will be used unexpectedly and
cause the build to fail.
* Options should be provided for remaining features, along with finding any
necessary libraries
+ DBM:
. APU_HAVE_GDBM
. APU_HAVE_NDBM
. APU_HAVE_DB
+ DBD:
. APU_HAVE_PGSQL
. APU_HAVE_MYSQL
. APU_HAVE_SQLITE3
. APU_HAVE_SQLITE2
. APU_HAVE_ORACLE
+ CRYPTO:
. APU_HAVE_NSS
+ XLATE, APU_HAVE_ICONV (no way to consume an apr-iconv build yet)
* Static builds of APR modules are not supported.
* CHANGES/LICENSE/NOTICE is not installed, unlike Makefile.win.
(But unlike Makefile.win we want to call them APR-Util-CHANGES.txt
and so on.) But perhaps that is a job for a higher-level script.
Generally:
* Many APR-Util features have not been tested with this build.
* Developers need to examine the existing Windows build in great detail and see
what is missing from the cmake-based build, whether a feature or some build
nuance.
* Any feedback you can provide on your experiences with this build will be
helpful.

13
contrib/apr-util/apr-util.pc.in
View File

@ -1,13 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
APRUTIL_MAJOR_VERSION=@APRUTIL_MAJOR_VERSION@
includedir=@includedir@
Name: APR Utils
Description: Companion library for APR
Version: @APRUTIL_DOTTED_VERSION@
# assume that apr-util requires libapr of same major version
Requires: apr-@APRUTIL_MAJOR_VERSION@
Libs: -L${libdir} -l@APRUTIL_LIBNAME@ @LDADD_ldap@ @APRUTIL_EXPORT_LIBS@
Cflags: -I${includedir}

200
contrib/apr-util/apr-util.spec
View File

@ -1,200 +0,0 @@
%define apuver 1
Summary: Apache Portable Runtime Utility library
Name: apr-util
Version: 1.6.1
Release: 1
License: Apache Software License
Group: System Environment/Libraries
URL: http://apr.apache.org/
Source0: http://www.apache.org/dist/apr/%{name}-%{version}.tar.bz2
BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot
BuildRequires: autoconf, libtool, doxygen, apr-devel >= 1.4.0
BuildRequires: expat-devel, libuuid-devel
%description
The mission of the Apache Portable Runtime (APR) is to provide a
free library of C data structures and routines. This library
contains additional utility interfaces for APR; including support
for XML, LDAP, database interfaces, URI parsing and more.
%package devel
Group: Development/Libraries
Summary: APR utility library development kit
Requires: apr-util = %{version}-%{release}, apr-devel
Requires: db4-devel, expat-devel
%description devel
This package provides the support files which can be used to
build applications using the APR utility library. The mission
of the Apache Portable Runtime (APR) is to provide a free
library of C data structures and routines.
%package dbm
Group: Development/Libraries
Summary: APR utility library DBM driver
BuildRequires: db4-devel
Requires: apr-util = %{version}-%{release}
%description dbm
This package provides the DBM driver for the apr-util.
%package pgsql
Group: Development/Libraries
Summary: APR utility library PostgreSQL DBD driver
BuildRequires: postgresql-devel
Requires: apr-util = %{version}-%{release}
%description pgsql
This package provides the PostgreSQL driver for the apr-util
DBD (database abstraction) interface.
%package mysql
Group: Development/Libraries
Summary: APR utility library MySQL DBD driver
BuildRequires: mysql-devel
Requires: apr-util = %{version}-%{release}
%description mysql
This package provides the MySQL driver for the apr-util DBD
(database abstraction) interface.
%package sqlite
Group: Development/Libraries
Summary: APR utility library SQLite DBD driver
BuildRequires: sqlite-devel >= 3.0.0
Requires: apr-util = %{version}-%{release}
%description sqlite
This package provides the SQLite driver for the apr-util DBD
(database abstraction) interface.
%package odbc
Group: Development/Libraries
Summary: APR utility library ODBC DBD driver
BuildRequires: unixODBC-devel
Requires: apr-util = %{version}-%{release}
%description odbc
This package provides the ODBC driver for the apr-util DBD
(database abstraction) interface.
%package ldap
Group: Development/Libraries
Summary: APR utility library LDAP support
BuildRequires: openldap-devel
Requires: apr-util = %{version}-%{release}
%description ldap
This package provides the LDAP support for the apr-util.
%package openssl
Group: Development/Libraries
Summary: APR utility library OpenSSL crypto support
BuildRequires: openssl-devel
Requires: apr-util = %{version}-%{release}
%description openssl
This package provides crypto support for apr-util based on OpenSSL.
%package nss
Group: Development/Libraries
Summary: APR utility library NSS crypto support
BuildRequires: nss-devel
Requires: apr-util = %{version}-%{release}
%description nss
This package provides crypto support for apr-util based on Mozilla NSS.
%prep
%setup -q
%build
%configure --with-apr=%{_prefix} \
--includedir=%{_includedir}/apr-%{apuver} \
--with-ldap --without-gdbm \
--with-sqlite3 --with-pgsql --with-mysql --with-odbc \
--with-berkeley-db \
--with-crypto --with-openssl --with-nss \
--without-sqlite2
make %{?_smp_mflags} && make dox
%check
# Run non-interactive tests
pushd test
make %{?_smp_mflags} all CFLAGS=-fno-strict-aliasing
make check || exit 1
popd
%install
rm -rf $RPM_BUILD_ROOT
make install DESTDIR=$RPM_BUILD_ROOT
# Documentation
mv docs/dox/html html
# Unpackaged files
rm -f $RPM_BUILD_ROOT%{_libdir}/aprutil.exp
%clean
rm -rf $RPM_BUILD_ROOT
%post -p /sbin/ldconfig
%postun -p /sbin/ldconfig
%files
%defattr(-,root,root,-)
%doc CHANGES LICENSE NOTICE
%{_libdir}/libaprutil-%{apuver}.so.*
%dir %{_libdir}/apr-util-%{apuver}
%files dbm
%defattr(-,root,root,-)
%{_libdir}/apr-util-%{apuver}/apr_dbm_db*
%files pgsql
%defattr(-,root,root,-)
%{_libdir}/apr-util-%{apuver}/apr_dbd_pgsql*
%files mysql
%defattr(-,root,root,-)
%{_libdir}/apr-util-%{apuver}/apr_dbd_mysql*
%files sqlite
%defattr(-,root,root,-)
%{_libdir}/apr-util-%{apuver}/apr_dbd_sqlite*
%files odbc
%defattr(-,root,root,-)
%{_libdir}/apr-util-%{apuver}/apr_dbd_odbc*
%files ldap
%defattr(-,root,root,-)
%{_libdir}/apr-util-%{apuver}/apr_ldap*
%files openssl
%defattr(-,root,root,-)
%{_libdir}/apr-util-%{apuver}/apr_crypto_openssl*
%files nss
%defattr(-,root,root,-)
%{_libdir}/apr-util-%{apuver}/apr_crypto_nss*
%files devel
%defattr(-,root,root,-)
%{_bindir}/apu-%{apuver}-config
%{_libdir}/libaprutil-%{apuver}.*a
%{_libdir}/libaprutil-%{apuver}.so
%{_libdir}/pkgconfig/apr-util-%{apuver}.pc
%{_includedir}/apr-%{apuver}/*.h
%doc html
%changelog
* Tue Jun 22 2004 Graham Leggett <minfrin@sharp.fm> 1.0.0-1
- update to support v1.0.0 of APR
* Tue Jun 22 2004 Graham Leggett <minfrin@sharp.fm> 1.0.0-1
- derived from Fedora Core apr.spec

443
contrib/apr-util/aprutil.dsw
View File

@ -1,443 +0,0 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "apr"="..\apr\apr.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Project: "apr_crypto_nss"=".\crypto\apr_crypto_nss.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "apr_crypto_openssl"=".\crypto\apr_crypto_openssl.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "apr_dbd_mysql"=".\dbd\apr_dbd_mysql.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "apr_dbd_odbc"=".\dbd\apr_dbd_odbc.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
}}}
###############################################################################
Project: "apr_dbd_oracle"=".\dbd\apr_dbd_oracle.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "apr_dbd_pgsql"=".\dbd\apr_dbd_pgsql.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "apr_dbd_sqlite2"=".\dbd\apr_dbd_sqlite2.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "apr_dbd_sqlite3"=".\dbd\apr_dbd_sqlite3.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "apr_dbm_db"=".\dbm\apr_dbm_db.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "apr_dbm_gdbm"=".\dbm\apr_dbm_gdbm.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "apr_ldap"=".\ldap\apr_ldap.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprutil
End Project Dependency
}}}
###############################################################################
Project: "aprapp"="..\apr\build\aprapp.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name preaprapp
End Project Dependency
}}}
###############################################################################
Project: "apriconv"="..\apr-iconv\apriconv.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name preapriconv
End Project Dependency
}}}
###############################################################################
Project: "aprutil"=".\aprutil.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name preaprutil
End Project Dependency
Begin Project Dependency
Project_Dep_Name apriconv
End Project Dependency
}}}
###############################################################################
Project: "libapr"="..\apr\libapr.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Project: "libaprapp"="..\apr\build\libaprapp.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name prelibaprapp
End Project Dependency
}}}
###############################################################################
Project: "libapriconv"="..\apr-iconv\libapriconv.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
}}}
###############################################################################
Project: "libapriconv_ccs_modules"="..\apr-iconv\ccs\libapriconv_ccs_modules.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libapriconv
End Project Dependency
}}}
###############################################################################
Project: "libapriconv_ces_modules"="..\apr-iconv\ces\libapriconv_ces_modules.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libapriconv
End Project Dependency
}}}
###############################################################################
Project: "libaprutil"=".\libaprutil.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
Begin Project Dependency
Project_Dep_Name libaprapp
End Project Dependency
Begin Project Dependency
Project_Dep_Name libapriconv
End Project Dependency
Begin Project Dependency
Project_Dep_Name libapriconv_ccs_modules
End Project Dependency
Begin Project Dependency
Project_Dep_Name libapriconv_ces_modules
End Project Dependency
}}}
###############################################################################
Project: "preaprapp"="..\apr\build\preaprapp.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name apr
End Project Dependency
}}}
###############################################################################
Project: "preapriconv"="..\apr-iconv\build\preapriconv.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name apr
End Project Dependency
}}}
###############################################################################
Project: "preaprutil"=".\build\preaprutil.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name apr
End Project Dependency
Begin Project Dependency
Project_Dep_Name aprapp
End Project Dependency
}}}
###############################################################################
Project: "prelibaprapp"="..\apr\build\prelibaprapp.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name libapr
End Project Dependency
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

221
contrib/apr-util/apu-config.in
View File

@ -1,221 +0,0 @@
#!/bin/sh
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# APR-util script designed to allow easy command line access to APR-util
# configuration parameters.
APRUTIL_MAJOR_VERSION="@APRUTIL_MAJOR_VERSION@"
APRUTIL_DOTTED_VERSION="@APRUTIL_DOTTED_VERSION@"
prefix="@prefix@"
exec_prefix="@exec_prefix@"
bindir="@bindir@"
libdir="@libdir@"
includedir="@includedir@"
LIBS="@APRUTIL_EXPORT_LIBS@"
INCLUDES="@APRUTIL_INCLUDES@"
LDFLAGS="@APRUTIL_LDFLAGS@"
LDAP_LIBS="@LDADD_ldap@"
DBM_LIBS="@LDADD_dbm_db@ @LDADD_dbm_gdbm@ @LDADD_dbm_ndbm@"
APRUTIL_LIBNAME="@APRUTIL_LIBNAME@"
APU_SOURCE_DIR="@abs_srcdir@"
APU_BUILD_DIR="@abs_builddir@"
APR_XML_EXPAT_OLD="@APR_XML_EXPAT_OLD@"
APU_DB_VERSION="@apu_db_version@"
# NOTE: the following line is modified during 'make install': alter with care!
location=@APU_CONFIG_LOCATION@
show_usage()
{
cat << EOF
Usage: apu-$APRUTIL_MAJOR_VERSION-config [OPTION]
Known values for OPTION are:
--prefix[=DIR] change prefix to DIR
--bindir print location where binaries are installed
--includes print include information
--includedir print location where headers are installed
--ldflags print linker flags
--libs print library information
--avoid-ldap do not include ldap library information with --libs
--ldap-libs print library information to link with ldap
--avoid-dbm do not include DBM library information with --libs
--dbm-libs print additional library information to link with DBM
--srcdir print APR-util source directory
--link-ld print link switch(es) for linking to APR-util
--link-libtool print the libtool inputs for linking to APR-util
--apu-la-file print the path to the .la file, if available
--old-expat indicate if APR-util was built against an old expat
--db-version print the DB version
--version print APR-util's version as a dotted triple
--help print this help
When linking with libtool, an application should do something like:
APU_LIBS="\`apu-$APRUTIL_MAJOR_VERSION-config --link-libtool --libs\`"
or when linking directly:
APU_LIBS="\`apu-$APRUTIL_MAJOR_VERSION-config --link-ld --libs\`"
An application should use the results of --includes, and --ldflags in
their build process.
EOF
}
if test $# -eq 0; then
show_usage
exit 1
fi
if test "$location" = "installed"; then
LA_FILE="$libdir/lib${APRUTIL_LIBNAME}.la"
else
LA_FILE="$APU_BUILD_DIR/lib${APRUTIL_LIBNAME}.la"
fi
flags=""
while test $# -gt 0; do
# Normalize the prefix.
case "$1" in
-*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
*) optarg= ;;
esac
case "$1" in
# It is possible for the user to override our prefix.
--prefix=*)
prefix=$optarg
;;
--prefix)
echo $prefix
exit 0
;;
--bindir)
echo $bindir
exit 0
;;
--avoid-ldap)
LDAP_LIBS=""
;;
--avoid-dbm)
DBM_LIBS=""
;;
--libs)
flags="$flags $LDAP_LIBS $DBM_LIBS $LIBS"
;;
--ldap-libs)
flags="$flags $LDAP_LIBS"
;;
--dbm-libs)
flags="$flags $DBM_LIBS"
;;
--includedir)
if test "$location" = "installed"; then
flags="$includedir"
elif test "$location" = "source"; then
flags="$APU_SOURCE_DIR/include"
else
# this is for VPATH builds
flags="$APU_BUILD_DIR/include $APU_SOURCE_DIR/include"
fi
echo $flags
exit 0
;;
--includes)
if test "$location" = "installed"; then
flags="$flags -I$includedir $INCLUDES"
elif test "$location" = "source"; then
flags="$flags -I$APU_SOURCE_DIR/include $INCLUDES"
else
# this is for VPATH builds
flags="$flags -I$APU_BUILD_DIR/include -I$APU_SOURCE_DIR/include $INCLUDES"
fi
;;
--ldflags)
flags="$flags $LDFLAGS"
;;
--srcdir)
echo $APU_SOURCE_DIR
exit 0
;;
--version)
echo $APRUTIL_DOTTED_VERSION
exit 0
;;
--link-ld)
if test "$location" = "installed"; then
### avoid using -L if libdir is a "standard" location like /usr/lib
flags="$flags -L$libdir -l$APRUTIL_LIBNAME"
else
flags="$flags -L$APU_BUILD_DIR -l$APRUTIL_LIBNAME"
fi
;;
--link-libtool)
# If the LA_FILE exists where we think it should be, use it. If we're
# installed and the LA_FILE does not exist, assume to use -L/-l
# (the LA_FILE may not have been installed). If we're building ourselves,
# we'll assume that at some point the .la file be created.
if test -f "$LA_FILE"; then
flags="$flags $LA_FILE"
elif test "$location" = "installed"; then
### avoid using -L if libdir is a "standard" location like /usr/lib
# Since the user is specifying they are linking with libtool, we
# *know* that -R will be recognized by libtool.
flags="$flags -L$libdir -R$libdir -l$APRUTIL_LIBNAME"
else
flags="$flags $LA_FILE"
fi
;;
--apu-la-file)
if test -f "$LA_FILE"; then
flags="$flags $LA_FILE"
fi
;;
--old-expat)
if test ! -n "$APR_XML_EXPAT_OLD"; then
echo "no"
else
echo "$APR_XML_EXPAT_OLD"
fi
exit 0
;;
--db-version)
echo $APU_DB_VERSION
exit 0
;;
--help)
show_usage
exit 0
;;
*)
show_usage
exit 1
;;
esac
# Next please.
shift
done
if test -n "$flags"; then
echo "$flags"
fi
exit 0

736
contrib/apr-util/buckets/apr_brigade.c
View File

@ -1,736 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr.h"
#include "apr_lib.h"
#include "apr_strings.h"
#include "apr_pools.h"
#include "apr_tables.h"
#include "apr_buckets.h"
#include "apr_errno.h"
#define APR_WANT_MEMFUNC
#define APR_WANT_STRFUNC
#include "apr_want.h"
#if APR_HAVE_SYS_UIO_H
#include <sys/uio.h>
#endif
static apr_status_t brigade_cleanup(void *data)
{
return apr_brigade_cleanup(data);
}
APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data)
{
apr_bucket_brigade *b = data;
apr_bucket *e;
while (!APR_BRIGADE_EMPTY(b)) {
e = APR_BRIGADE_FIRST(b);
apr_bucket_delete(e);
}
/* We don't need to free(bb) because it's allocated from a pool. */
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b)
{
apr_pool_cleanup_kill(b->p, b, brigade_cleanup);
return apr_brigade_cleanup(b);
}
APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p,
apr_bucket_alloc_t *list)
{
apr_bucket_brigade *b;
b = apr_palloc(p, sizeof(*b));
b->p = p;
b->bucket_alloc = list;
APR_RING_INIT(&b->list, apr_bucket, link);
apr_pool_cleanup_register(b->p, b, brigade_cleanup, apr_pool_cleanup_null);
return b;
}
APU_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b,
apr_bucket *e,
apr_bucket_brigade *a)
{
apr_bucket *f;
if (!a) {
a = apr_brigade_create(b->p, b->bucket_alloc);
}
else if (!APR_BRIGADE_EMPTY(a)) {
apr_brigade_cleanup(a);
}
/* Return an empty brigade if there is nothing left in
* the first brigade to split off
*/
if (e != APR_BRIGADE_SENTINEL(b)) {
f = APR_RING_LAST(&b->list);
APR_RING_UNSPLICE(e, f, link);
APR_RING_SPLICE_HEAD(&a->list, e, f, apr_bucket, link);
}
APR_BRIGADE_CHECK_CONSISTENCY(a);
APR_BRIGADE_CHECK_CONSISTENCY(b);
return a;
}
APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
apr_bucket *e)
{
return apr_brigade_split_ex(b, e, NULL);
}
APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
apr_off_t point,
apr_bucket **after_point)
{
apr_bucket *e;
const char *s;
apr_size_t len;
apr_uint64_t point64;
apr_status_t rv;
if (point < 0) {
/* this could cause weird (not necessarily SEGV) things to happen */
return APR_EINVAL;
}
if (point == 0) {
*after_point = APR_BRIGADE_FIRST(b);
return APR_SUCCESS;
}
/*
* Try to reduce the following casting mess: We know that point will be
* larger equal 0 now and forever and thus that point (apr_off_t) and
* apr_size_t will fit into apr_uint64_t in any case.
*/
point64 = (apr_uint64_t)point;
APR_BRIGADE_CHECK_CONSISTENCY(b);
for (e = APR_BRIGADE_FIRST(b);
e != APR_BRIGADE_SENTINEL(b);
e = APR_BUCKET_NEXT(e))
{
/* For an unknown length bucket, while 'point64' is beyond the possible
* size contained in apr_size_t, read and continue...
*/
if ((e->length == (apr_size_t)(-1))
&& (point64 > (apr_uint64_t)APR_SIZE_MAX)) {
/* point64 is too far out to simply split this bucket,
* we must fix this bucket's size and keep going... */
rv = apr_bucket_read(e, &s, &len, APR_BLOCK_READ);
if (rv != APR_SUCCESS) {
*after_point = e;
return rv;
}
}
else if ((point64 < (apr_uint64_t)e->length)
|| (e->length == (apr_size_t)(-1))) {
/* We already consumed buckets where point64 is beyond
* our interest ( point64 > APR_SIZE_MAX ), above.
* Here point falls between 0 and APR_SIZE_MAX
* and is within this bucket, or this bucket's len
* is undefined, so now we are ready to split it.
* First try to split the bucket natively... */
if ((rv = apr_bucket_split(e, (apr_size_t)point64))
!= APR_ENOTIMPL) {
*after_point = APR_BUCKET_NEXT(e);
return rv;
}
/* if the bucket cannot be split, we must read from it,
* changing its type to one that can be split */
rv = apr_bucket_read(e, &s, &len, APR_BLOCK_READ);
if (rv != APR_SUCCESS) {
*after_point = e;
return rv;
}
/* this assumes that len == e->length, which is okay because e
* might have been morphed by the apr_bucket_read() above, but
* if it was, the length would have been adjusted appropriately */
if (point64 < (apr_uint64_t)e->length) {
rv = apr_bucket_split(e, (apr_size_t)point64);
*after_point = APR_BUCKET_NEXT(e);
return rv;
}
}
if (point64 == (apr_uint64_t)e->length) {
*after_point = APR_BUCKET_NEXT(e);
return APR_SUCCESS;
}
point64 -= (apr_uint64_t)e->length;
}
*after_point = APR_BRIGADE_SENTINEL(b);
return APR_INCOMPLETE;
}
APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb,
int read_all, apr_off_t *length)
{
apr_off_t total = 0;
apr_bucket *bkt;
apr_status_t status = APR_SUCCESS;
for (bkt = APR_BRIGADE_FIRST(bb);
bkt != APR_BRIGADE_SENTINEL(bb);
bkt = APR_BUCKET_NEXT(bkt))
{
if (bkt->length == (apr_size_t)(-1)) {
const char *ignore;
apr_size_t len;
if (!read_all) {
total = -1;
break;
}
if ((status = apr_bucket_read(bkt, &ignore, &len,
APR_BLOCK_READ)) != APR_SUCCESS) {
break;
}
}
total += bkt->length;
}
*length = total;
return status;
}
APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb,
char *c, apr_size_t *len)
{
apr_size_t actual = 0;
apr_bucket *b;
for (b = APR_BRIGADE_FIRST(bb);
b != APR_BRIGADE_SENTINEL(bb);
b = APR_BUCKET_NEXT(b))
{
const char *str;
apr_size_t str_len;
apr_status_t status;
status = apr_bucket_read(b, &str, &str_len, APR_BLOCK_READ);
if (status != APR_SUCCESS) {
return status;
}
/* If we would overflow. */
if (str_len + actual > *len) {
str_len = *len - actual;
}
/* XXX: It appears that overflow of the final bucket
* is DISCARDED without any warning to the caller.
*
* No, we only copy the data up to their requested size. -- jre
*/
memcpy(c, str, str_len);
c += str_len;
actual += str_len;
/* This could probably be actual == *len, but be safe from stray
* photons. */
if (actual >= *len) {
break;
}
}
*len = actual;
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb,
char **c,
apr_size_t *len,
apr_pool_t *pool)
{
apr_off_t actual;
apr_size_t total;
apr_status_t rv;
apr_brigade_length(bb, 1, &actual);
/* XXX: This is dangerous beyond belief. At least in the
* apr_brigade_flatten case, the user explicitly stated their
* buffer length - so we don't up and palloc 4GB for a single
* file bucket. This API must grow a useful max boundry,
* either compiled-in or preset via the *len value.
*
* Shouldn't both fn's grow an additional return value for
* the case that the brigade couldn't be flattened into the
* provided or allocated buffer (such as APR_EMOREDATA?)
* Not a failure, simply an advisory result.
*/
total = (apr_size_t)actual;
*c = apr_palloc(pool, total);
rv = apr_brigade_flatten(bb, *c, &total);
if (rv != APR_SUCCESS) {
return rv;
}
*len = total;
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut,
apr_bucket_brigade *bbIn,
apr_read_type_e block,
apr_off_t maxbytes)
{
apr_off_t readbytes = 0;
while (!APR_BRIGADE_EMPTY(bbIn)) {
const char *pos;
const char *str;
apr_size_t len;
apr_status_t rv;
apr_bucket *e;
e = APR_BRIGADE_FIRST(bbIn);
rv = apr_bucket_read(e, &str, &len, block);
if (rv != APR_SUCCESS) {
return rv;
}
pos = memchr(str, APR_ASCII_LF, len);
/* We found a match. */
if (pos != NULL) {
apr_bucket_split(e, pos - str + 1);
APR_BUCKET_REMOVE(e);
APR_BRIGADE_INSERT_TAIL(bbOut, e);
return APR_SUCCESS;
}
APR_BUCKET_REMOVE(e);
if (APR_BUCKET_IS_METADATA(e) || len > APR_BUCKET_BUFF_SIZE/4) {
APR_BRIGADE_INSERT_TAIL(bbOut, e);
}
else {
if (len > 0) {
rv = apr_brigade_write(bbOut, NULL, NULL, str, len);
if (rv != APR_SUCCESS) {
return rv;
}
}
apr_bucket_destroy(e);
}
readbytes += len;
/* We didn't find an APR_ASCII_LF within the maximum line length. */
if (readbytes >= maxbytes) {
break;
}
}
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b,
struct iovec *vec, int *nvec)
{
int left = *nvec;
apr_bucket *e;
struct iovec *orig;
apr_size_t iov_len;
const char *iov_base;
apr_status_t rv;
orig = vec;
for (e = APR_BRIGADE_FIRST(b);
e != APR_BRIGADE_SENTINEL(b);
e = APR_BUCKET_NEXT(e))
{
if (left-- == 0)
break;
rv = apr_bucket_read(e, &iov_base, &iov_len, APR_NONBLOCK_READ);
if (rv != APR_SUCCESS)
return rv;
/* Set indirectly since types differ: */
vec->iov_len = iov_len;
vec->iov_base = (void *)iov_base;
++vec;
}
*nvec = (int)(vec - orig);
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b,
apr_brigade_flush flush,
void *ctx,
va_list va)
{
#define MAX_VECS 8
struct iovec vec[MAX_VECS];
apr_size_t i = 0;
for (;;) {
char *str = va_arg(va, char *);
apr_status_t rv;
if (str == NULL)
break;
vec[i].iov_base = str;
vec[i].iov_len = strlen(str);
i++;
if (i == MAX_VECS) {
rv = apr_brigade_writev(b, flush, ctx, vec, i);
if (rv != APR_SUCCESS)
return rv;
i = 0;
}
}
if (i != 0)
return apr_brigade_writev(b, flush, ctx, vec, i);
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b,
apr_brigade_flush flush, void *ctx,
const char c)
{
return apr_brigade_write(b, flush, ctx, &c, 1);
}
APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b,
apr_brigade_flush flush,
void *ctx,
const char *str, apr_size_t nbyte)
{
apr_bucket *e = APR_BRIGADE_LAST(b);
apr_size_t remaining = APR_BUCKET_BUFF_SIZE;
char *buf = NULL;
/*
* If the last bucket is a heap bucket and its buffer is not shared with
* another bucket, we may write into that bucket.
*/
if (!APR_BRIGADE_EMPTY(b) && APR_BUCKET_IS_HEAP(e)
&& ((apr_bucket_heap *)(e->data))->refcount.refcount == 1) {
apr_bucket_heap *h = e->data;
/* HEAP bucket start offsets are always in-memory, safe to cast */
remaining = h->alloc_len - (e->length + (apr_size_t)e->start);
buf = h->base + e->start + e->length;
}
if (nbyte > remaining) {
/* either a buffer bucket exists but is full,
* or no buffer bucket exists and the data is too big
* to buffer. In either case, we should flush. */
if (flush) {
e = apr_bucket_transient_create(str, nbyte, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
return flush(b, ctx);
}
else {
e = apr_bucket_heap_create(str, nbyte, NULL, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
return APR_SUCCESS;
}
}
else if (!buf) {
/* we don't have a buffer, but the data is small enough
* that we don't mind making a new buffer */
buf = apr_bucket_alloc(APR_BUCKET_BUFF_SIZE, b->bucket_alloc);
e = apr_bucket_heap_create(buf, APR_BUCKET_BUFF_SIZE,
apr_bucket_free, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
e->length = 0; /* We are writing into the brigade, and
* allocating more memory than we need. This
* ensures that the bucket thinks it is empty just
* after we create it. We'll fix the length
* once we put data in it below.
*/
}
/* there is a sufficiently big buffer bucket available now */
memcpy(buf, str, nbyte);
e->length += nbyte;
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b,
apr_brigade_flush flush,
void *ctx,
const struct iovec *vec,
apr_size_t nvec)
{
apr_bucket *e;
apr_size_t total_len;
apr_size_t i;
char *buf;
/* Compute the total length of the data to be written.
*/
total_len = 0;
for (i = 0; i < nvec; i++) {
total_len += vec[i].iov_len;
}
/* If the data to be written is very large, try to convert
* the iovec to transient buckets rather than copying.
*/
if (total_len > APR_BUCKET_BUFF_SIZE) {
if (flush) {
for (i = 0; i < nvec; i++) {
e = apr_bucket_transient_create(vec[i].iov_base,
vec[i].iov_len,
b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
}
return flush(b, ctx);
}
else {
for (i = 0; i < nvec; i++) {
e = apr_bucket_heap_create((const char *) vec[i].iov_base,
vec[i].iov_len, NULL,
b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
}
return APR_SUCCESS;
}
}
i = 0;
/* If there is a heap bucket at the end of the brigade
* already, and its refcount is 1, copy into the existing bucket.
*/
e = APR_BRIGADE_LAST(b);
if (!APR_BRIGADE_EMPTY(b) && APR_BUCKET_IS_HEAP(e)
&& ((apr_bucket_heap *)(e->data))->refcount.refcount == 1) {
apr_bucket_heap *h = e->data;
apr_size_t remaining = h->alloc_len -
(e->length + (apr_size_t)e->start);
buf = h->base + e->start + e->length;
if (remaining >= total_len) {
/* Simple case: all the data will fit in the
* existing heap bucket
*/
for (; i < nvec; i++) {
apr_size_t len = vec[i].iov_len;
memcpy(buf, (const void *) vec[i].iov_base, len);
buf += len;
}
e->length += total_len;
return APR_SUCCESS;
}
else {
/* More complicated case: not all of the data
* will fit in the existing heap bucket. The
* total data size is <= APR_BUCKET_BUFF_SIZE,
* so we'll need only one additional bucket.
*/
const char *start_buf = buf;
for (; i < nvec; i++) {
apr_size_t len = vec[i].iov_len;
if (len > remaining) {
break;
}
memcpy(buf, (const void *) vec[i].iov_base, len);
buf += len;
remaining -= len;
}
e->length += (buf - start_buf);
total_len -= (buf - start_buf);
if (flush) {
apr_status_t rv = flush(b, ctx);
if (rv != APR_SUCCESS) {
return rv;
}
}
/* Now fall through into the case below to
* allocate another heap bucket and copy the
* rest of the array. (Note that i is not
* reset to zero here; it holds the index
* of the first vector element to be
* written to the new bucket.)
*/
}
}
/* Allocate a new heap bucket, and copy the data into it.
* The checks above ensure that the amount of data to be
* written here is no larger than APR_BUCKET_BUFF_SIZE.
*/
buf = apr_bucket_alloc(APR_BUCKET_BUFF_SIZE, b->bucket_alloc);
e = apr_bucket_heap_create(buf, APR_BUCKET_BUFF_SIZE,
apr_bucket_free, b->bucket_alloc);
for (; i < nvec; i++) {
apr_size_t len = vec[i].iov_len;
memcpy(buf, (const void *) vec[i].iov_base, len);
buf += len;
}
e->length = total_len;
APR_BRIGADE_INSERT_TAIL(b, e);
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb,
apr_brigade_flush flush, void *ctx,
const char *str)
{
return apr_brigade_write(bb, flush, ctx, str, strlen(str));
}
APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b,
apr_brigade_flush flush,
void *ctx, ...)
{
va_list va;
apr_status_t rv;
va_start(va, ctx);
rv = apr_brigade_vputstrs(b, flush, ctx, va);
va_end(va);
return rv;
}
APU_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b,
apr_brigade_flush flush,
void *ctx,
const char *fmt, ...)
{
va_list ap;
apr_status_t rv;
va_start(ap, fmt);
rv = apr_brigade_vprintf(b, flush, ctx, fmt, ap);
va_end(ap);
return rv;
}
struct brigade_vprintf_data_t {
apr_vformatter_buff_t vbuff;
apr_bucket_brigade *b; /* associated brigade */
apr_brigade_flush *flusher; /* flushing function */
void *ctx;
char *cbuff; /* buffer to flush from */
};
static apr_status_t brigade_flush(apr_vformatter_buff_t *buff)
{
/* callback function passed to ap_vformatter to be
* called when vformatter needs to buff and
* buff.curpos > buff.endpos
*/
/* "downcast," have really passed a brigade_vprintf_data_t* */
struct brigade_vprintf_data_t *vd = (struct brigade_vprintf_data_t*)buff;
apr_status_t res = APR_SUCCESS;
res = apr_brigade_write(vd->b, *vd->flusher, vd->ctx, vd->cbuff,
APR_BUCKET_BUFF_SIZE);
if(res != APR_SUCCESS) {
return -1;
}
vd->vbuff.curpos = vd->cbuff;
vd->vbuff.endpos = vd->cbuff + APR_BUCKET_BUFF_SIZE;
return res;
}
APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b,
apr_brigade_flush flush,
void *ctx,
const char *fmt, va_list va)
{
/* the cast, in order of appearance */
struct brigade_vprintf_data_t vd;
char buf[APR_BUCKET_BUFF_SIZE];
int written;
vd.vbuff.curpos = buf;
vd.vbuff.endpos = buf + APR_BUCKET_BUFF_SIZE;
vd.b = b;
vd.flusher = &flush;
vd.ctx = ctx;
vd.cbuff = buf;
written = apr_vformatter(brigade_flush, &vd.vbuff, fmt, va);
if (written == -1) {
return -1;
}
/* write out what remains in the buffer */
return apr_brigade_write(b, flush, ctx, buf, vd.vbuff.curpos - buf);
}
/* A "safe" maximum bucket size, 1Gb */
#define MAX_BUCKET_SIZE (0x40000000)
APU_DECLARE(apr_bucket *) apr_brigade_insert_file(apr_bucket_brigade *bb,
apr_file_t *f,
apr_off_t start,
apr_off_t length,
apr_pool_t *p)
{
apr_bucket *e;
if (sizeof(apr_off_t) == sizeof(apr_size_t) || length < MAX_BUCKET_SIZE) {
e = apr_bucket_file_create(f, start, (apr_size_t)length, p,
bb->bucket_alloc);
}
else {
/* Several buckets are needed. */
e = apr_bucket_file_create(f, start, MAX_BUCKET_SIZE, p,
bb->bucket_alloc);
while (length > MAX_BUCKET_SIZE) {
apr_bucket *ce;
apr_bucket_copy(e, &ce);
APR_BRIGADE_INSERT_TAIL(bb, ce);
e->start += MAX_BUCKET_SIZE;
length -= MAX_BUCKET_SIZE;
}
e->length = (apr_size_t)length; /* Resize just the last bucket */
}
APR_BRIGADE_INSERT_TAIL(bb, e);
return e;
}

46
contrib/apr-util/buckets/apr_buckets.c
View File

@ -1,46 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data,
apr_pool_t *pool)
{
return APR_SUCCESS;
}
APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data,
apr_pool_t *pool)
{
return APR_ENOTIMPL;
}
APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data,
apr_size_t point)
{
return APR_ENOTIMPL;
}
APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e,
apr_bucket **c)
{
return APR_ENOTIMPL;
}
APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data)
{
return;
}

234
contrib/apr-util/buckets/apr_buckets_alloc.c
View File

@ -1,234 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdlib.h>
#include "apr_buckets.h"
#include "apr_allocator.h"
#include "apr_version.h"
#define ALLOC_AMT (8192 - APR_MEMNODE_T_SIZE)
typedef struct node_header_t {
apr_size_t size;
apr_bucket_alloc_t *alloc;
apr_memnode_t *memnode;
struct node_header_t *next;
} node_header_t;
#define SIZEOF_NODE_HEADER_T APR_ALIGN_DEFAULT(sizeof(node_header_t))
#define SMALL_NODE_SIZE (APR_BUCKET_ALLOC_SIZE + SIZEOF_NODE_HEADER_T)
/** A list of free memory from which new buckets or private bucket
* structures can be allocated.
*/
struct apr_bucket_alloc_t {
apr_pool_t *pool;
apr_allocator_t *allocator;
node_header_t *freelist;
apr_memnode_t *blocks;
};
static apr_status_t alloc_cleanup(void *data)
{
apr_bucket_alloc_t *list = data;
apr_allocator_free(list->allocator, list->blocks);
#if APR_POOL_DEBUG
if (list->pool && list->allocator != apr_pool_allocator_get(list->pool)) {
apr_allocator_destroy(list->allocator);
}
#endif
return APR_SUCCESS;
}
APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p)
{
apr_allocator_t *allocator = apr_pool_allocator_get(p);
apr_bucket_alloc_t *list;
#if APR_POOL_DEBUG
/* may be NULL for debug mode. */
if (allocator == NULL) {
if (apr_allocator_create(&allocator) != APR_SUCCESS) {
apr_abortfunc_t fn = apr_pool_abort_get(p);
if (fn)
(fn)(APR_ENOMEM);
abort();
}
}
#endif
list = apr_bucket_alloc_create_ex(allocator);
if (list == NULL) {
apr_abortfunc_t fn = apr_pool_abort_get(p);
if (fn)
(fn)(APR_ENOMEM);
abort();
}
list->pool = p;
apr_pool_cleanup_register(list->pool, list, alloc_cleanup,
apr_pool_cleanup_null);
return list;
}
APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(
apr_allocator_t *allocator)
{
apr_bucket_alloc_t *list;
apr_memnode_t *block;
block = apr_allocator_alloc(allocator, ALLOC_AMT);
if (!block) {
return NULL;
}
list = (apr_bucket_alloc_t *)block->first_avail;
list->pool = NULL;
list->allocator = allocator;
list->freelist = NULL;
list->blocks = block;
block->first_avail += APR_ALIGN_DEFAULT(sizeof(*list));
return list;
}
APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list)
{
if (list->pool) {
apr_pool_cleanup_kill(list->pool, list, alloc_cleanup);
}
apr_allocator_free(list->allocator, list->blocks);
#if APR_POOL_DEBUG
if (list->pool && list->allocator != apr_pool_allocator_get(list->pool)) {
apr_allocator_destroy(list->allocator);
}
#endif
}
APU_DECLARE_NONSTD(apr_size_t) apr_bucket_alloc_aligned_floor(apr_bucket_alloc_t *list,
apr_size_t size)
{
if (size <= SMALL_NODE_SIZE) {
size = SMALL_NODE_SIZE;
}
else {
#if APR_VERSION_AT_LEAST(1,6,0)
if (size < APR_MEMNODE_T_SIZE) {
size = apr_allocator_align(list->allocator, 0);
}
else {
size = apr_allocator_align(list->allocator,
size - APR_MEMNODE_T_SIZE);
}
#else
/* Assumes the minimum (default) allocator's boundary of 4K and
* minimum (immutable before APR-1.6.x) allocation size of 8K,
* hence possibly (yet unlikely) under-estimating the floor...
*/
size = APR_ALIGN(size, 4096);
if (size < 8192) {
size = 8192;
}
#endif
size -= APR_MEMNODE_T_SIZE;
}
size -= SIZEOF_NODE_HEADER_T;
return size;
}
APU_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size,
apr_bucket_alloc_t *list)
{
node_header_t *node;
apr_memnode_t *active = list->blocks;
char *endp;
size += SIZEOF_NODE_HEADER_T;
if (size <= SMALL_NODE_SIZE) {
if (list->freelist) {
node = list->freelist;
list->freelist = node->next;
}
else {
endp = active->first_avail + SMALL_NODE_SIZE;
if (endp >= active->endp) {
list->blocks = apr_allocator_alloc(list->allocator, ALLOC_AMT);
if (!list->blocks) {
list->blocks = active;
return NULL;
}
list->blocks->next = active;
active = list->blocks;
endp = active->first_avail + SMALL_NODE_SIZE;
}
node = (node_header_t *)active->first_avail;
node->alloc = list;
node->memnode = active;
node->size = SMALL_NODE_SIZE;
active->first_avail = endp;
}
}
else {
apr_memnode_t *memnode = apr_allocator_alloc(list->allocator, size);
if (!memnode) {
return NULL;
}
node = (node_header_t *)memnode->first_avail;
node->alloc = list;
node->memnode = memnode;
node->size = size;
}
return ((char *)node) + SIZEOF_NODE_HEADER_T;
}
#ifdef APR_BUCKET_DEBUG
#if APR_HAVE_STDLIB_H
#include <stdlib.h>
#endif
static void check_not_already_free(node_header_t *node)
{
apr_bucket_alloc_t *list = node->alloc;
node_header_t *curr = list->freelist;
while (curr) {
if (node == curr) {
abort();
}
curr = curr->next;
}
}
#else
#define check_not_already_free(node)
#endif
APU_DECLARE_NONSTD(void) apr_bucket_free(void *mem)
{
node_header_t *node = (node_header_t *)((char *)mem - SIZEOF_NODE_HEADER_T);
apr_bucket_alloc_t *list = node->alloc;
if (node->size == SMALL_NODE_SIZE) {
check_not_already_free(node);
node->next = list->freelist;
list->freelist = node;
}
else {
apr_allocator_free(list->allocator, node->memnode);
}
}

54
contrib/apr-util/buckets/apr_buckets_eos.c
View File

@ -1,54 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
static apr_status_t eos_bucket_read(apr_bucket *b, const char **str,
apr_size_t *len, apr_read_type_e block)
{
*str = NULL;
*len = 0;
return APR_SUCCESS;
}
APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b)
{
b->length = 0;
b->start = 0;
b->data = NULL;
b->type = &apr_bucket_type_eos;
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_eos_make(b);
}
APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_eos = {
"EOS", 5, APR_BUCKET_METADATA,
apr_bucket_destroy_noop,
eos_bucket_read,
apr_bucket_setaside_noop,
apr_bucket_split_notimpl,
apr_bucket_simple_copy
};

242
contrib/apr-util/buckets/apr_buckets_file.c
View File

@ -1,242 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr.h"
#include "apr_general.h"
#include "apr_file_io.h"
#include "apr_buckets.h"
#if APR_HAS_MMAP
#include "apr_mmap.h"
/* mmap support for static files based on ideas from John Heidemann's
* patch against 1.0.5. See
* <http://www.isi.edu/~johnh/SOFTWARE/APACHE/index.html>.
*/
#endif /* APR_HAS_MMAP */
static void file_bucket_destroy(void *data)
{
apr_bucket_file *f = data;
if (apr_bucket_shared_destroy(f)) {
/* no need to close the file here; it will get
* done automatically when the pool gets cleaned up */
apr_bucket_free(f);
}
}
#if APR_HAS_MMAP
static int file_make_mmap(apr_bucket *e, apr_size_t filelength,
apr_off_t fileoffset, apr_pool_t *p)
{
apr_bucket_file *a = e->data;
apr_mmap_t *mm;
if (!a->can_mmap) {
return 0;
}
if (filelength > APR_MMAP_LIMIT) {
if (apr_mmap_create(&mm, a->fd, fileoffset, APR_MMAP_LIMIT,
APR_MMAP_READ, p) != APR_SUCCESS)
{
return 0;
}
apr_bucket_split(e, APR_MMAP_LIMIT);
filelength = APR_MMAP_LIMIT;
}
else if ((filelength < APR_MMAP_THRESHOLD) ||
(apr_mmap_create(&mm, a->fd, fileoffset, filelength,
APR_MMAP_READ, p) != APR_SUCCESS))
{
return 0;
}
apr_bucket_mmap_make(e, mm, 0, filelength);
file_bucket_destroy(a);
return 1;
}
#endif
static apr_status_t file_bucket_read(apr_bucket *e, const char **str,
apr_size_t *len, apr_read_type_e block)
{
apr_bucket_file *a = e->data;
apr_file_t *f = a->fd;
apr_bucket *b = NULL;
char *buf;
apr_status_t rv;
apr_size_t filelength = e->length; /* bytes remaining in file past offset */
apr_off_t fileoffset = e->start;
#if APR_HAS_THREADS && !APR_HAS_XTHREAD_FILES
apr_int32_t flags;
#endif
#if APR_HAS_MMAP
if (file_make_mmap(e, filelength, fileoffset, a->readpool)) {
return apr_bucket_read(e, str, len, block);
}
#endif
#if APR_HAS_THREADS && !APR_HAS_XTHREAD_FILES
if ((flags = apr_file_flags_get(f)) & APR_FOPEN_XTHREAD) {
/* this file descriptor is shared across multiple threads and
* this OS doesn't support that natively, so as a workaround
* we must reopen the file into a->readpool */
const char *fname;
apr_file_name_get(&fname, f);
rv = apr_file_open(&f, fname, (flags & ~APR_FOPEN_XTHREAD), 0, a->readpool);
if (rv != APR_SUCCESS)
return rv;
a->fd = f;
}
#endif
*str = NULL; /* in case we die prematurely */
*len = (filelength > a->read_size) ? a->read_size : filelength;
buf = apr_bucket_alloc(*len, e->list);
/* Handle offset ... */
rv = apr_file_seek(f, APR_SET, &fileoffset);
if (rv != APR_SUCCESS) {
apr_bucket_free(buf);
return rv;
}
rv = apr_file_read(f, buf, len);
if (rv != APR_SUCCESS && rv != APR_EOF) {
apr_bucket_free(buf);
return rv;
}
filelength -= *len;
/*
* Change the current bucket to refer to what we read,
* even if we read nothing because we hit EOF.
*/
apr_bucket_heap_make(e, buf, *len, apr_bucket_free);
/* If we have more to read from the file, then create another bucket */
if (filelength > 0 && rv != APR_EOF) {
/* for efficiency, we can just build a new apr_bucket struct
* to wrap around the existing file bucket */
b = apr_bucket_alloc(sizeof(*b), e->list);
b->start = fileoffset + (*len);
b->length = filelength;
b->data = a;
b->type = &apr_bucket_type_file;
b->free = apr_bucket_free;
b->list = e->list;
APR_BUCKET_INSERT_AFTER(e, b);
}
else {
file_bucket_destroy(a);
}
*str = buf;
return rv;
}
APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd,
apr_off_t offset,
apr_size_t len, apr_pool_t *p)
{
apr_bucket_file *f;
f = apr_bucket_alloc(sizeof(*f), b->list);
f->fd = fd;
f->readpool = p;
#if APR_HAS_MMAP
f->can_mmap = 1;
#endif
f->read_size = APR_BUCKET_BUFF_SIZE;
b = apr_bucket_shared_make(b, f, offset, len);
b->type = &apr_bucket_type_file;
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd,
apr_off_t offset,
apr_size_t len, apr_pool_t *p,
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_file_make(b, fd, offset, len, p);
}
APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *e,
int enabled)
{
#if APR_HAS_MMAP
apr_bucket_file *a = e->data;
a->can_mmap = enabled;
return APR_SUCCESS;
#else
return APR_ENOTIMPL;
#endif /* APR_HAS_MMAP */
}
APU_DECLARE(apr_status_t) apr_bucket_file_set_buf_size(apr_bucket *e,
apr_size_t size)
{
apr_bucket_file *a = e->data;
if (size <= APR_BUCKET_BUFF_SIZE) {
a->read_size = APR_BUCKET_BUFF_SIZE;
}
else {
apr_size_t floor = apr_bucket_alloc_aligned_floor(e->list, size);
a->read_size = (size < floor) ? size : floor;
}
return APR_SUCCESS;
}
static apr_status_t file_bucket_setaside(apr_bucket *data, apr_pool_t *reqpool)
{
apr_bucket_file *a = data->data;
apr_file_t *fd = NULL;
apr_file_t *f = a->fd;
apr_pool_t *curpool = apr_file_pool_get(f);
if (apr_pool_is_ancestor(curpool, reqpool)) {
return APR_SUCCESS;
}
if (!apr_pool_is_ancestor(a->readpool, reqpool)) {
a->readpool = reqpool;
}
apr_file_setaside(&fd, f, reqpool);
a->fd = fd;
return APR_SUCCESS;
}
APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_file = {
"FILE", 5, APR_BUCKET_DATA,
file_bucket_destroy,
file_bucket_read,
file_bucket_setaside,
apr_bucket_shared_split,
apr_bucket_shared_copy
};

54
contrib/apr-util/buckets/apr_buckets_flush.c
View File

@ -1,54 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
static apr_status_t flush_bucket_read(apr_bucket *b, const char **str,
apr_size_t *len, apr_read_type_e block)
{
*str = NULL;
*len = 0;
return APR_SUCCESS;
}
APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b)
{
b->length = 0;
b->start = 0;
b->data = NULL;
b->type = &apr_bucket_type_flush;
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_flush_make(b);
}
APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_flush = {
"FLUSH", 5, APR_BUCKET_METADATA,
apr_bucket_destroy_noop,
flush_bucket_read,
apr_bucket_setaside_noop,
apr_bucket_split_notimpl,
apr_bucket_simple_copy
};

96
contrib/apr-util/buckets/apr_buckets_heap.c
View File

@ -1,96 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
#define APR_WANT_MEMFUNC
#include "apr_want.h"
static apr_status_t heap_bucket_read(apr_bucket *b, const char **str,
apr_size_t *len, apr_read_type_e block)
{
apr_bucket_heap *h = b->data;
*str = h->base + b->start;
*len = b->length;
return APR_SUCCESS;
}
static void heap_bucket_destroy(void *data)
{
apr_bucket_heap *h = data;
if (apr_bucket_shared_destroy(h)) {
(*h->free_func)(h->base);
apr_bucket_free(h);
}
}
/* Warning: if you change this function, be sure to
* change apr_bucket_pool_make() too! */
APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf,
apr_size_t length,
void (*free_func)(void *data))
{
apr_bucket_heap *h;
h = apr_bucket_alloc(sizeof(*h), b->list);
if (!free_func) {
h->alloc_len = length;
h->base = apr_bucket_alloc(h->alloc_len, b->list);
if (h->base == NULL) {
apr_bucket_free(h);
return NULL;
}
h->free_func = apr_bucket_free;
memcpy(h->base, buf, length);
}
else {
/* XXX: we lose the const qualifier here which indicates
* there's something screwy with the API...
*/
h->base = (char *) buf;
h->alloc_len = length;
h->free_func = free_func;
}
b = apr_bucket_shared_make(b, h, 0, length);
b->type = &apr_bucket_type_heap;
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf,
apr_size_t length,
void (*free_func)(void *data),
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_heap_make(b, buf, length, free_func);
}
APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_heap = {
"HEAP", 5, APR_BUCKET_DATA,
heap_bucket_destroy,
heap_bucket_read,
apr_bucket_setaside_noop,
apr_bucket_shared_split,
apr_bucket_shared_copy
};

144
contrib/apr-util/buckets/apr_buckets_mmap.c
View File

@ -1,144 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
#if APR_HAS_MMAP
static apr_status_t mmap_bucket_read(apr_bucket *b, const char **str,
apr_size_t *length, apr_read_type_e block)
{
apr_bucket_mmap *m = b->data;
apr_status_t ok;
void *addr;
if (!m->mmap) {
/* the apr_mmap_t was already cleaned up out from under us */
return APR_EINVAL;
}
ok = apr_mmap_offset(&addr, m->mmap, b->start);
if (ok != APR_SUCCESS) {
return ok;
}
*str = addr;
*length = b->length;
return APR_SUCCESS;
}
static apr_status_t mmap_bucket_cleanup(void *data)
{
/* the apr_mmap_t is about to disappear out from under us, so we
* have no choice but to pretend it doesn't exist anymore. the
* refcount is now useless because there's nothing to refer to
* anymore. so the only valid action on any remaining referrer
* is to delete it. no more reads, no more anything. */
apr_bucket_mmap *m = data;
m->mmap = NULL;
return APR_SUCCESS;
}
static void mmap_bucket_destroy(void *data)
{
apr_bucket_mmap *m = data;
if (apr_bucket_shared_destroy(m)) {
if (m->mmap) {
apr_pool_cleanup_kill(m->mmap->cntxt, m, mmap_bucket_cleanup);
apr_mmap_delete(m->mmap);
}
apr_bucket_free(m);
}
}
/*
* XXX: are the start and length arguments useful?
*/
APU_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm,
apr_off_t start,
apr_size_t length)
{
apr_bucket_mmap *m;
m = apr_bucket_alloc(sizeof(*m), b->list);
m->mmap = mm;
apr_pool_cleanup_register(mm->cntxt, m, mmap_bucket_cleanup,
apr_pool_cleanup_null);
b = apr_bucket_shared_make(b, m, start, length);
b->type = &apr_bucket_type_mmap;
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm,
apr_off_t start,
apr_size_t length,
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_mmap_make(b, mm, start, length);
}
static apr_status_t mmap_bucket_setaside(apr_bucket *b, apr_pool_t *p)
{
apr_bucket_mmap *m = b->data;
apr_mmap_t *mm = m->mmap;
apr_mmap_t *new_mm;
apr_status_t ok;
if (!mm) {
/* the apr_mmap_t was already cleaned up out from under us */
return APR_EINVAL;
}
/* shortcut if possible */
if (apr_pool_is_ancestor(mm->cntxt, p)) {
return APR_SUCCESS;
}
/* duplicate apr_mmap_t into new pool */
ok = apr_mmap_dup(&new_mm, mm, p);
if (ok != APR_SUCCESS) {
return ok;
}
/* decrement refcount on old apr_bucket_mmap */
mmap_bucket_destroy(m);
/* create new apr_bucket_mmap pointing to new apr_mmap_t */
apr_bucket_mmap_make(b, new_mm, b->start, b->length);
return APR_SUCCESS;
}
APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_mmap = {
"MMAP", 5, APR_BUCKET_DATA,
mmap_bucket_destroy,
mmap_bucket_read,
mmap_bucket_setaside,
apr_bucket_shared_split,
apr_bucket_shared_copy
};
#endif

119
contrib/apr-util/buckets/apr_buckets_pipe.c
View File

@ -1,119 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
static apr_status_t pipe_bucket_read(apr_bucket *a, const char **str,
apr_size_t *len, apr_read_type_e block)
{
apr_file_t *p = a->data;
char *buf;
apr_status_t rv;
apr_interval_time_t timeout;
if (block == APR_NONBLOCK_READ) {
apr_file_pipe_timeout_get(p, &timeout);
apr_file_pipe_timeout_set(p, 0);
}
*str = NULL;
*len = APR_BUCKET_BUFF_SIZE;
buf = apr_bucket_alloc(*len, a->list); /* XXX: check for failure? */
rv = apr_file_read(p, buf, len);
if (block == APR_NONBLOCK_READ) {
apr_file_pipe_timeout_set(p, timeout);
}
if (rv != APR_SUCCESS && rv != APR_EOF) {
apr_bucket_free(buf);
return rv;
}
/*
* If there's more to read we have to keep the rest of the pipe
* for later. Otherwise, we'll close the pipe.
* XXX: Note that more complicated bucket types that
* refer to data not in memory and must therefore have a read()
* function similar to this one should be wary of copying this
* code because if they have a destroy function they probably
* want to migrate the bucket's subordinate structure from the
* old bucket to a raw new one and adjust it as appropriate,
* rather than destroying the old one and creating a completely
* new bucket.
*/
if (*len > 0) {
apr_bucket_heap *h;
/* Change the current bucket to refer to what we read */
a = apr_bucket_heap_make(a, buf, *len, apr_bucket_free);
h = a->data;
h->alloc_len = APR_BUCKET_BUFF_SIZE; /* note the real buffer size */
*str = buf;
APR_BUCKET_INSERT_AFTER(a, apr_bucket_pipe_create(p, a->list));
}
else {
apr_bucket_free(buf);
a = apr_bucket_immortal_make(a, "", 0);
*str = a->data;
if (rv == APR_EOF) {
apr_file_close(p);
}
}
return APR_SUCCESS;
}
APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, apr_file_t *p)
{
/*
* A pipe is closed when the end is reached in pipe_bucket_read(). If
* the pipe isn't read to the end (e.g., error path), the pipe will be
* closed when its pool goes away.
*
* Note that typically the pipe is allocated from the request pool
* so it will disappear when the request is finished. However the
* core filter may decide to set aside the tail end of a CGI
* response if the connection is pipelined. This turns out not to
* be a problem because the core will have read to the end of the
* stream so the bucket(s) that it sets aside will be the heap
* buckets created by pipe_bucket_read() above.
*/
b->type = &apr_bucket_type_pipe;
b->length = (apr_size_t)(-1);
b->start = -1;
b->data = p;
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *p,
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_pipe_make(b, p);
}
APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pipe = {
"PIPE", 5, APR_BUCKET_DATA,
apr_bucket_destroy_noop,
pipe_bucket_read,
apr_bucket_setaside_notimpl,
apr_bucket_split_notimpl,
apr_bucket_copy_notimpl
};

142
contrib/apr-util/buckets/apr_buckets_pool.c
View File

@ -1,142 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
#define APR_WANT_MEMFUNC
#include "apr_want.h"
static apr_status_t pool_bucket_cleanup(void *data)
{
apr_bucket_pool *p = data;
/*
* If the pool gets cleaned up, we have to copy the data out
* of the pool and onto the heap. But the apr_buckets out there
* that point to this pool bucket need to be notified such that
* they can morph themselves into a regular heap bucket the next
* time they try to read. To avoid having to manipulate
* reference counts and b->data pointers, the apr_bucket_pool
* actually _contains_ an apr_bucket_heap as its first element,
* so the two share their apr_bucket_refcount member, and you
* can typecast a pool bucket struct to make it look like a
* regular old heap bucket struct.
*/
p->heap.base = apr_bucket_alloc(p->heap.alloc_len, p->list);
memcpy(p->heap.base, p->base, p->heap.alloc_len);
p->base = NULL;
p->pool = NULL;
return APR_SUCCESS;
}
static apr_status_t pool_bucket_read(apr_bucket *b, const char **str,
apr_size_t *len, apr_read_type_e block)
{
apr_bucket_pool *p = b->data;
const char *base = p->base;
if (p->pool == NULL) {
/*
* pool has been cleaned up... masquerade as a heap bucket from now
* on. subsequent bucket operations will use the heap bucket code.
*/
b->type = &apr_bucket_type_heap;
base = p->heap.base;
}
*str = base + b->start;
*len = b->length;
return APR_SUCCESS;
}
static void pool_bucket_destroy(void *data)
{
apr_bucket_pool *p = data;
/* If the pool is cleaned up before the last reference goes
* away, the data is really now on the heap; heap_destroy() takes
* over. free() in heap_destroy() thinks it's freeing
* an apr_bucket_heap, when in reality it's freeing the whole
* apr_bucket_pool for us.
*/
if (p->pool) {
/* the shared resource is still in the pool
* because the pool has not been cleaned up yet
*/
if (apr_bucket_shared_destroy(p)) {
apr_pool_cleanup_kill(p->pool, p, pool_bucket_cleanup);
apr_bucket_free(p);
}
}
else {
/* the shared resource is no longer in the pool, it's
* on the heap, but this reference still thinks it's a pool
* bucket. we should just go ahead and pass control to
* heap_destroy() for it since it doesn't know any better.
*/
apr_bucket_type_heap.destroy(p);
}
}
APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b,
const char *buf, apr_size_t length, apr_pool_t *pool)
{
apr_bucket_pool *p;
p = apr_bucket_alloc(sizeof(*p), b->list);
/* XXX: we lose the const qualifier here which indicates
* there's something screwy with the API...
*/
/* XXX: why is this? buf is const, p->base is const... what's
* the problem? --jcw */
p->base = (char *) buf;
p->pool = pool;
p->list = b->list;
b = apr_bucket_shared_make(b, p, 0, length);
b->type = &apr_bucket_type_pool;
/* pre-initialize heap bucket member */
p->heap.alloc_len = length;
p->heap.base = NULL;
p->heap.free_func = apr_bucket_free;
apr_pool_cleanup_register(p->pool, p, pool_bucket_cleanup,
apr_pool_cleanup_null);
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf,
apr_size_t length,
apr_pool_t *pool,
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_pool_make(b, buf, length, pool);
}
APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pool = {
"POOL", 5, APR_BUCKET_DATA,
pool_bucket_destroy,
pool_bucket_read,
apr_bucket_setaside_noop, /* don't need to setaside thanks to the cleanup*/
apr_bucket_shared_split,
apr_bucket_shared_copy
};

64
contrib/apr-util/buckets/apr_buckets_refcount.c
View File

@ -1,64 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *a,
apr_size_t point)
{
apr_bucket_refcount *r = a->data;
apr_status_t rv;
if ((rv = apr_bucket_simple_split(a, point)) != APR_SUCCESS) {
return rv;
}
r->refcount++;
return APR_SUCCESS;
}
APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a,
apr_bucket **b)
{
apr_bucket_refcount *r = a->data;
apr_bucket_simple_copy(a, b);
r->refcount++;
return APR_SUCCESS;
}
APU_DECLARE(int) apr_bucket_shared_destroy(void *data)
{
apr_bucket_refcount *r = data;
r->refcount--;
return (r->refcount == 0);
}
APU_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data,
apr_off_t start,
apr_size_t length)
{
apr_bucket_refcount *r = data;
b->data = r;
b->start = start;
b->length = length;
/* caller initializes the type field */
r->refcount = 1;
return b;
}

137
contrib/apr-util/buckets/apr_buckets_simple.c
View File

@ -1,137 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a,
apr_bucket **b)
{
*b = apr_bucket_alloc(sizeof(**b), a->list); /* XXX: check for failure? */
**b = *a;
return APR_SUCCESS;
}
APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *a,
apr_size_t point)
{
apr_bucket *b;
if (point > a->length) {
return APR_EINVAL;
}
apr_bucket_simple_copy(a, &b);
a->length = point;
b->length -= point;
b->start += point;
APR_BUCKET_INSERT_AFTER(a, b);
return APR_SUCCESS;
}
static apr_status_t simple_bucket_read(apr_bucket *b, const char **str,
apr_size_t *len, apr_read_type_e block)
{
*str = (char *)b->data + b->start;
*len = b->length;
return APR_SUCCESS;
}
APU_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b,
const char *buf,
apr_size_t length)
{
b->data = (char *)buf;
b->length = length;
b->start = 0;
b->type = &apr_bucket_type_immortal;
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf,
apr_size_t length,
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_immortal_make(b, buf, length);
}
/*
* XXX: This function could do with some tweaking to reduce memory
* usage in various cases, e.g. share buffers in the heap between all
* the buckets that are set aside, or even spool set-aside data to
* disk if it gets too voluminous (but if it does then that's probably
* a bug elsewhere). There should probably be a apr_brigade_setaside()
* function that co-ordinates the action of all the bucket setaside
* functions to improve memory efficiency.
*/
static apr_status_t transient_bucket_setaside(apr_bucket *b, apr_pool_t *pool)
{
b = apr_bucket_heap_make(b, (char *)b->data + b->start, b->length, NULL);
if (b == NULL) {
return APR_ENOMEM;
}
return APR_SUCCESS;
}
APU_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b,
const char *buf,
apr_size_t length)
{
b->data = (char *)buf;
b->length = length;
b->start = 0;
b->type = &apr_bucket_type_transient;
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf,
apr_size_t length,
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_transient_make(b, buf, length);
}
const apr_bucket_type_t apr_bucket_type_immortal = {
"IMMORTAL", 5, APR_BUCKET_DATA,
apr_bucket_destroy_noop,
simple_bucket_read,
apr_bucket_setaside_noop,
apr_bucket_simple_split,
apr_bucket_simple_copy
};
APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_transient = {
"TRANSIENT", 5, APR_BUCKET_DATA,
apr_bucket_destroy_noop,
simple_bucket_read,
transient_bucket_setaside,
apr_bucket_simple_split,
apr_bucket_simple_copy
};

114
contrib/apr-util/buckets/apr_buckets_socket.c
View File

@ -1,114 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_buckets.h"
static apr_status_t socket_bucket_read(apr_bucket *a, const char **str,
apr_size_t *len, apr_read_type_e block)
{
apr_socket_t *p = a->data;
char *buf;
apr_status_t rv;
apr_interval_time_t timeout;
if (block == APR_NONBLOCK_READ) {
apr_socket_timeout_get(p, &timeout);
apr_socket_timeout_set(p, 0);
}
*str = NULL;
*len = APR_BUCKET_BUFF_SIZE;
buf = apr_bucket_alloc(*len, a->list); /* XXX: check for failure? */
rv = apr_socket_recv(p, buf, len);
if (block == APR_NONBLOCK_READ) {
apr_socket_timeout_set(p, timeout);
}
if (rv != APR_SUCCESS && rv != APR_EOF) {
apr_bucket_free(buf);
return rv;
}
/*
* If there's more to read we have to keep the rest of the socket
* for later. XXX: Note that more complicated bucket types that
* refer to data not in memory and must therefore have a read()
* function similar to this one should be wary of copying this
* code because if they have a destroy function they probably
* want to migrate the bucket's subordinate structure from the
* old bucket to a raw new one and adjust it as appropriate,
* rather than destroying the old one and creating a completely
* new bucket.
*
* Even if there is nothing more to read, don't close the socket here
* as we have to use it to send any response :) We could shut it
* down for reading, but there is no benefit to doing so.
*/
if (*len > 0) {
apr_bucket_heap *h;
/* Change the current bucket to refer to what we read */
a = apr_bucket_heap_make(a, buf, *len, apr_bucket_free);
h = a->data;
h->alloc_len = APR_BUCKET_BUFF_SIZE; /* note the real buffer size */
*str = buf;
APR_BUCKET_INSERT_AFTER(a, apr_bucket_socket_create(p, a->list));
}
else {
apr_bucket_free(buf);
a = apr_bucket_immortal_make(a, "", 0);
*str = a->data;
}
return APR_SUCCESS;
}
APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, apr_socket_t *p)
{
/*
* XXX: We rely on a cleanup on some pool or other to actually
* destroy the socket. We should probably explicitly call apr to
* destroy it instead.
*
* Note that typically the socket is allocated from the connection pool
* so it will disappear when the connection is finished.
*/
b->type = &apr_bucket_type_socket;
b->length = (apr_size_t)(-1);
b->start = -1;
b->data = p;
return b;
}
APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *p,
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_socket_make(b, p);
}
APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_socket = {
"SOCKET", 5, APR_BUCKET_DATA,
apr_bucket_destroy_noop,
socket_bucket_read,
apr_bucket_setaside_notimpl,
apr_bucket_split_notimpl,
apr_bucket_copy_notimpl
};

152
contrib/apr-util/build-outputs.mk
View File

@ -1,152 +0,0 @@
# DO NOT EDIT. AUTOMATICALLY GENERATED.
buckets/apr_brigade.lo: buckets/apr_brigade.c .make.dirs include/apr_buckets.h
buckets/apr_buckets.lo: buckets/apr_buckets.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_alloc.lo: buckets/apr_buckets_alloc.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_eos.lo: buckets/apr_buckets_eos.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_file.lo: buckets/apr_buckets_file.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_flush.lo: buckets/apr_buckets_flush.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_heap.lo: buckets/apr_buckets_heap.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_mmap.lo: buckets/apr_buckets_mmap.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_pipe.lo: buckets/apr_buckets_pipe.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_pool.lo: buckets/apr_buckets_pool.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_refcount.lo: buckets/apr_buckets_refcount.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_simple.lo: buckets/apr_buckets_simple.c .make.dirs include/apr_buckets.h
buckets/apr_buckets_socket.lo: buckets/apr_buckets_socket.c .make.dirs include/apr_buckets.h
crypto/apr_crypto.lo: crypto/apr_crypto.c .make.dirs include/apr_crypto.h include/apu_errno.h include/apu_version.h include/private/apr_crypto_internal.h include/private/apu_internal.h
crypto/apr_md4.lo: crypto/apr_md4.c .make.dirs include/apr_md4.h include/apr_xlate.h
crypto/apr_md5.lo: crypto/apr_md5.c .make.dirs include/apr_md5.h include/apr_xlate.h
crypto/apr_passwd.lo: crypto/apr_passwd.c .make.dirs include/apr_md5.h include/apr_sha1.h include/apr_xlate.h
crypto/apr_sha1.lo: crypto/apr_sha1.c .make.dirs include/apr_base64.h include/apr_sha1.h include/apr_xlate.h
crypto/apr_siphash.lo: crypto/apr_siphash.c .make.dirs include/apr_siphash.h
crypto/crypt_blowfish.lo: crypto/crypt_blowfish.c .make.dirs
crypto/getuuid.lo: crypto/getuuid.c .make.dirs include/apr_md5.h include/apr_uuid.h include/apr_xlate.h
crypto/uuid.lo: crypto/uuid.c .make.dirs include/apr_uuid.h
dbd/apr_dbd.lo: dbd/apr_dbd.c .make.dirs include/apr_dbd.h include/apu_version.h include/private/apr_dbd_internal.h include/private/apu_internal.h
dbm/apr_dbm.lo: dbm/apr_dbm.c .make.dirs include/apr_dbm.h include/apu_version.h include/private/apr_dbm_private.h include/private/apu_internal.h
dbm/apr_dbm_sdbm.lo: dbm/apr_dbm_sdbm.c .make.dirs include/apr_dbm.h include/apr_sdbm.h include/private/apr_dbm_private.h
dbm/sdbm/sdbm.lo: dbm/sdbm/sdbm.c .make.dirs include/apr_sdbm.h
dbm/sdbm/sdbm_hash.lo: dbm/sdbm/sdbm_hash.c .make.dirs include/apr_sdbm.h
dbm/sdbm/sdbm_lock.lo: dbm/sdbm/sdbm_lock.c .make.dirs include/apr_sdbm.h
dbm/sdbm/sdbm_pair.lo: dbm/sdbm/sdbm_pair.c .make.dirs include/apr_sdbm.h
encoding/apr_base64.lo: encoding/apr_base64.c .make.dirs include/apr_base64.h include/apr_xlate.h
hooks/apr_hooks.lo: hooks/apr_hooks.c .make.dirs include/apr_hooks.h include/apr_optional.h include/apr_optional_hooks.h
ldap/apr_ldap_stub.lo: ldap/apr_ldap_stub.c .make.dirs include/apu_version.h include/private/apu_internal.h
ldap/apr_ldap_url.lo: ldap/apr_ldap_url.c .make.dirs
memcache/apr_memcache.lo: memcache/apr_memcache.c .make.dirs include/apr_buckets.h include/apr_memcache.h include/apr_reslist.h
misc/apr_date.lo: misc/apr_date.c .make.dirs include/apr_date.h
misc/apr_queue.lo: misc/apr_queue.c .make.dirs include/apr_queue.h
misc/apr_reslist.lo: misc/apr_reslist.c .make.dirs include/apr_reslist.h
misc/apr_rmm.lo: misc/apr_rmm.c .make.dirs include/apr_anylock.h include/apr_rmm.h
misc/apr_thread_pool.lo: misc/apr_thread_pool.c .make.dirs include/apr_thread_pool.h
misc/apu_dso.lo: misc/apu_dso.c .make.dirs include/apu_version.h include/private/apu_internal.h
misc/apu_version.lo: misc/apu_version.c .make.dirs include/apu_version.h
redis/apr_redis.lo: redis/apr_redis.c .make.dirs include/apr_buckets.h include/apr_redis.h include/apr_reslist.h
strmatch/apr_strmatch.lo: strmatch/apr_strmatch.c .make.dirs include/apr_strmatch.h
uri/apr_uri.lo: uri/apr_uri.c .make.dirs include/apr_uri.h
xlate/xlate.lo: xlate/xlate.c .make.dirs include/apr_xlate.h
xml/apr_xml.lo: xml/apr_xml.c .make.dirs include/apr_xlate.h include/apr_xml.h
OBJECTS_all = buckets/apr_brigade.lo buckets/apr_buckets.lo buckets/apr_buckets_alloc.lo buckets/apr_buckets_eos.lo buckets/apr_buckets_file.lo buckets/apr_buckets_flush.lo buckets/apr_buckets_heap.lo buckets/apr_buckets_mmap.lo buckets/apr_buckets_pipe.lo buckets/apr_buckets_pool.lo buckets/apr_buckets_refcount.lo buckets/apr_buckets_simple.lo buckets/apr_buckets_socket.lo crypto/apr_crypto.lo crypto/apr_md4.lo crypto/apr_md5.lo crypto/apr_passwd.lo crypto/apr_sha1.lo crypto/apr_siphash.lo crypto/crypt_blowfish.lo crypto/getuuid.lo crypto/uuid.lo dbd/apr_dbd.lo dbm/apr_dbm.lo dbm/apr_dbm_sdbm.lo dbm/sdbm/sdbm.lo dbm/sdbm/sdbm_hash.lo dbm/sdbm/sdbm_lock.lo dbm/sdbm/sdbm_pair.lo encoding/apr_base64.lo hooks/apr_hooks.lo ldap/apr_ldap_stub.lo ldap/apr_ldap_url.lo memcache/apr_memcache.lo misc/apr_date.lo misc/apr_queue.lo misc/apr_reslist.lo misc/apr_rmm.lo misc/apr_thread_pool.lo misc/apu_dso.lo misc/apu_version.lo redis/apr_redis.lo strmatch/apr_strmatch.lo uri/apr_uri.lo xlate/xlate.lo xml/apr_xml.lo
OBJECTS_unix = $(OBJECTS_all)
OBJECTS_aix = $(OBJECTS_all)
OBJECTS_beos = $(OBJECTS_all)
OBJECTS_os2 = $(OBJECTS_all)
OBJECTS_os390 = $(OBJECTS_all)
OBJECTS_win32 = $(OBJECTS_all)
HEADERS = $(top_srcdir)/include/apr_anylock.h $(top_srcdir)/include/apr_base64.h $(top_srcdir)/include/apr_buckets.h $(top_srcdir)/include/apr_crypto.h $(top_srcdir)/include/apr_date.h $(top_srcdir)/include/apr_dbd.h $(top_srcdir)/include/apr_dbm.h $(top_srcdir)/include/apr_hooks.h $(top_srcdir)/include/apr_ldap_init.h $(top_srcdir)/include/apr_ldap_option.h $(top_srcdir)/include/apr_ldap_rebind.h $(top_srcdir)/include/apr_ldap_url.h $(top_srcdir)/include/apr_md4.h $(top_srcdir)/include/apr_md5.h $(top_srcdir)/include/apr_memcache.h $(top_srcdir)/include/apr_optional.h $(top_srcdir)/include/apr_optional_hooks.h $(top_srcdir)/include/apr_queue.h $(top_srcdir)/include/apr_redis.h $(top_srcdir)/include/apr_reslist.h $(top_srcdir)/include/apr_rmm.h $(top_srcdir)/include/apr_sdbm.h $(top_srcdir)/include/apr_sha1.h $(top_srcdir)/include/apr_siphash.h $(top_srcdir)/include/apr_strmatch.h $(top_srcdir)/include/apr_thread_pool.h $(top_srcdir)/include/apr_uri.h $(top_srcdir)/include/apr_uuid.h $(top_srcdir)/include/apr_xlate.h $(top_srcdir)/include/apr_xml.h $(top_srcdir)/include/apu_errno.h $(top_srcdir)/include/apu_version.h $(top_srcdir)/include/private/apr_crypto_internal.h $(top_srcdir)/include/private/apr_dbd_internal.h $(top_srcdir)/include/private/apr_dbd_odbc_v2.h $(top_srcdir)/include/private/apr_dbm_private.h $(top_srcdir)/include/private/apu_internal.h
SOURCE_DIRS = xml redis dbm encoding hooks buckets uri misc crypto dbd strmatch memcache dbm/sdbm ldap xlate $(EXTRA_SOURCE_DIRS)
ldap/apr_ldap_init.lo: ldap/apr_ldap_init.c .make.dirs include/private/apu_internal.h
ldap/apr_ldap_option.lo: ldap/apr_ldap_option.c .make.dirs
ldap/apr_ldap_rebind.lo: ldap/apr_ldap_rebind.c .make.dirs include/apr_ldap_rebind.h
OBJECTS_ldap = ldap/apr_ldap_init.lo ldap/apr_ldap_option.lo ldap/apr_ldap_rebind.lo
MODULE_ldap = ldap/apr_ldap.la
ldap/apr_ldap.la: ldap/apr_ldap_init.lo ldap/apr_ldap_option.lo ldap/apr_ldap_rebind.lo
$(LINK_MODULE) -o $@ $(OBJECTS_ldap) $(LDADD_ldap)
crypto/apr_crypto_openssl.lo: crypto/apr_crypto_openssl.c .make.dirs include/apr_buckets.h include/apr_crypto.h include/apu_errno.h include/private/apr_crypto_internal.h
OBJECTS_crypto_openssl = crypto/apr_crypto_openssl.lo
MODULE_crypto_openssl = crypto/apr_crypto_openssl.la
crypto/apr_crypto_openssl.la: crypto/apr_crypto_openssl.lo
$(LINK_MODULE) -o $@ $(OBJECTS_crypto_openssl) $(LDADD_crypto_openssl)
crypto/apr_crypto_nss.lo: crypto/apr_crypto_nss.c .make.dirs include/apr_buckets.h include/apr_crypto.h include/apu_errno.h include/private/apr_crypto_internal.h
OBJECTS_crypto_nss = crypto/apr_crypto_nss.lo
MODULE_crypto_nss = crypto/apr_crypto_nss.la
crypto/apr_crypto_nss.la: crypto/apr_crypto_nss.lo
$(LINK_MODULE) -o $@ $(OBJECTS_crypto_nss) $(LDADD_crypto_nss)
crypto/apr_crypto_commoncrypto.lo: crypto/apr_crypto_commoncrypto.c .make.dirs include/apr_buckets.h include/apr_crypto.h include/apu_errno.h include/private/apr_crypto_internal.h
OBJECTS_crypto_commoncrypto = crypto/apr_crypto_commoncrypto.lo
MODULE_crypto_commoncrypto = crypto/apr_crypto_commoncrypto.la
crypto/apr_crypto_commoncrypto.la: crypto/apr_crypto_commoncrypto.lo
$(LINK_MODULE) -o $@ $(OBJECTS_crypto_commoncrypto) $(LDADD_crypto_commoncrypto)
dbd/apr_dbd_pgsql.lo: dbd/apr_dbd_pgsql.c .make.dirs include/apr_buckets.h include/apr_dbd.h include/private/apr_dbd_internal.h
OBJECTS_dbd_pgsql = dbd/apr_dbd_pgsql.lo
MODULE_dbd_pgsql = dbd/apr_dbd_pgsql.la
dbd/apr_dbd_pgsql.la: dbd/apr_dbd_pgsql.lo
$(LINK_MODULE) -o $@ $(OBJECTS_dbd_pgsql) $(LDADD_dbd_pgsql)
dbd/apr_dbd_sqlite2.lo: dbd/apr_dbd_sqlite2.c .make.dirs include/apr_buckets.h include/apr_dbd.h include/private/apr_dbd_internal.h
OBJECTS_dbd_sqlite2 = dbd/apr_dbd_sqlite2.lo
MODULE_dbd_sqlite2 = dbd/apr_dbd_sqlite2.la
dbd/apr_dbd_sqlite2.la: dbd/apr_dbd_sqlite2.lo
$(LINK_MODULE) -o $@ $(OBJECTS_dbd_sqlite2) $(LDADD_dbd_sqlite2)
dbd/apr_dbd_sqlite3.lo: dbd/apr_dbd_sqlite3.c .make.dirs include/apr_buckets.h include/apr_dbd.h include/private/apr_dbd_internal.h
OBJECTS_dbd_sqlite3 = dbd/apr_dbd_sqlite3.lo
MODULE_dbd_sqlite3 = dbd/apr_dbd_sqlite3.la
dbd/apr_dbd_sqlite3.la: dbd/apr_dbd_sqlite3.lo
$(LINK_MODULE) -o $@ $(OBJECTS_dbd_sqlite3) $(LDADD_dbd_sqlite3)
dbd/apr_dbd_oracle.lo: dbd/apr_dbd_oracle.c .make.dirs include/apr_buckets.h include/apr_dbd.h include/private/apr_dbd_internal.h
OBJECTS_dbd_oracle = dbd/apr_dbd_oracle.lo
MODULE_dbd_oracle = dbd/apr_dbd_oracle.la
dbd/apr_dbd_oracle.la: dbd/apr_dbd_oracle.lo
$(LINK_MODULE) -o $@ $(OBJECTS_dbd_oracle) $(LDADD_dbd_oracle)
dbd/apr_dbd_mysql.lo: dbd/apr_dbd_mysql.c .make.dirs include/apr_buckets.h include/apr_dbd.h include/apu_version.h include/private/apr_dbd_internal.h
OBJECTS_dbd_mysql = dbd/apr_dbd_mysql.lo
MODULE_dbd_mysql = dbd/apr_dbd_mysql.la
dbd/apr_dbd_mysql.la: dbd/apr_dbd_mysql.lo
$(LINK_MODULE) -o $@ $(OBJECTS_dbd_mysql) $(LDADD_dbd_mysql)
dbd/apr_dbd_odbc.lo: dbd/apr_dbd_odbc.c .make.dirs include/apr_buckets.h include/apr_dbd.h include/apu_version.h include/private/apr_dbd_internal.h include/private/apr_dbd_odbc_v2.h
OBJECTS_dbd_odbc = dbd/apr_dbd_odbc.lo
MODULE_dbd_odbc = dbd/apr_dbd_odbc.la
dbd/apr_dbd_odbc.la: dbd/apr_dbd_odbc.lo
$(LINK_MODULE) -o $@ $(OBJECTS_dbd_odbc) $(LDADD_dbd_odbc)
dbm/apr_dbm_berkeleydb.lo: dbm/apr_dbm_berkeleydb.c .make.dirs include/apr_dbm.h include/private/apr_dbm_private.h
OBJECTS_dbm_db = dbm/apr_dbm_berkeleydb.lo
MODULE_dbm_db = dbm/apr_dbm_db.la
dbm/apr_dbm_db.la: dbm/apr_dbm_berkeleydb.lo
$(LINK_MODULE) -o $@ $(OBJECTS_dbm_db) $(LDADD_dbm_db)
dbm/apr_dbm_gdbm.lo: dbm/apr_dbm_gdbm.c .make.dirs include/apr_dbm.h include/private/apr_dbm_private.h
OBJECTS_dbm_gdbm = dbm/apr_dbm_gdbm.lo
MODULE_dbm_gdbm = dbm/apr_dbm_gdbm.la
dbm/apr_dbm_gdbm.la: dbm/apr_dbm_gdbm.lo
$(LINK_MODULE) -o $@ $(OBJECTS_dbm_gdbm) $(LDADD_dbm_gdbm)
dbm/apr_dbm_ndbm.lo: dbm/apr_dbm_ndbm.c .make.dirs include/apr_dbm.h include/private/apr_dbm_private.h
OBJECTS_dbm_ndbm = dbm/apr_dbm_ndbm.lo
MODULE_dbm_ndbm = dbm/apr_dbm_ndbm.la
dbm/apr_dbm_ndbm.la: dbm/apr_dbm_ndbm.lo
$(LINK_MODULE) -o $@ $(OBJECTS_dbm_ndbm) $(LDADD_dbm_ndbm)
BUILD_DIRS = buckets crypto dbd dbm dbm/sdbm encoding hooks ldap memcache misc redis strmatch uri xlate xml
.make.dirs: $(srcdir)/build-outputs.mk
@for d in $(BUILD_DIRS); do test -d $$d || mkdir $$d; done
@echo timestamp > $@

104
contrib/apr-util/build.conf
View File

@ -1,104 +0,0 @@
#
# Configuration file for APRUTIL. Used by APR/build/gen-build.py
#
[options]
# the platform-independent .c files
paths =
buckets/*.c
crypto/apr_crypto.c
crypto/apr_md4.c
crypto/apr_md5.c
crypto/apr_passwd.c
crypto/apr_sha1.c
crypto/apr_siphash.c
crypto/getuuid.c
crypto/uuid.c
crypto/crypt_blowfish.c
dbm/apr_dbm_sdbm.c
dbm/apr_dbm.c
dbm/sdbm/*.c
encoding/*.c
hooks/*.c
ldap/apr_ldap_stub.c
ldap/apr_ldap_url.c
misc/*.c
memcache/*.c
redis/*.c
uri/apr_uri.c
xml/*.c
strmatch/*.c
xlate/*.c
dbd/apr_dbd.c
# we have no platform-specific subdirs
platform_dirs =
# the public headers
headers = include/*.h include/private/*.h
modules =
ldap crypto_openssl crypto_nss crypto_commoncrypto dbd_pgsql
dbd_sqlite2 dbd_sqlite3 dbd_oracle dbd_mysql dbd_odbc
dbm_db dbm_gdbm dbm_ndbm
# gen_uri_delim.c
# we have a recursive makefile for the test files (for now)
# test/*.c
[crypto_commoncrypto]
paths = crypto/apr_crypto_commoncrypto.c
target = crypto/apr_crypto_commoncrypto.la
[crypto_openssl]
paths = crypto/apr_crypto_openssl.c
target = crypto/apr_crypto_openssl.la
[crypto_nss]
paths = crypto/apr_crypto_nss.c
target = crypto/apr_crypto_nss.la
[dbd_pgsql]
paths = dbd/apr_dbd_pgsql.c
target = dbd/apr_dbd_pgsql.la
[dbd_sqlite2]
paths = dbd/apr_dbd_sqlite2.c
target = dbd/apr_dbd_sqlite2.la
[dbd_sqlite3]
paths = dbd/apr_dbd_sqlite3.c
target = dbd/apr_dbd_sqlite3.la
[dbd_oracle]
paths = dbd/apr_dbd_oracle.c
target = dbd/apr_dbd_oracle.la
[dbd_mysql]
paths = dbd/apr_dbd_mysql.c
target = dbd/apr_dbd_mysql.la
[dbd_odbc]
paths = dbd/apr_dbd_odbc.c
target = dbd/apr_dbd_odbc.la
[dbm_db]
paths = dbm/apr_dbm_berkeleydb.c
target = dbm/apr_dbm_db.la
[dbm_gdbm]
paths = dbm/apr_dbm_gdbm.c
target = dbm/apr_dbm_gdbm.la
[dbm_ndbm]
paths = dbm/apr_dbm_ndbm.c
target = dbm/apr_dbm_ndbm.la
[ldap]
paths = ldap/apr_ldap_init.c
ldap/apr_ldap_option.c
ldap/apr_ldap_rebind.c
target = ldap/apr_ldap.la

118
contrib/apr-util/buildconf
View File

@ -1,118 +0,0 @@
#!/bin/sh
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
if [ "$1" = "--verbose" -o "$1" = "-v" ]; then
verbose="--verbose"
shift
fi
# Default place to look for apr source. Can be overridden with
# --with-apr=[directory]
apr_src_dir=../apr
while test $# -gt 0
do
# Normalize
case "$1" in
-*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
*) optarg= ;;
esac
case "$1" in
--with-apr=*)
apr_src_dir=$optarg
;;
esac
shift
done
if [ -f "$apr_src_dir/build/apr_common.m4" ]; then
apr_src_dir=`cd $apr_src_dir; pwd`
echo ""
echo "Looking for apr source in $apr_src_dir"
else
echo ""
echo "Problem finding apr source in $apr_src_dir."
echo "Use:"
echo " --with-apr=[directory]"
exit 1
fi
set -e
# Remove some files, then copy them from apr source tree
rm -f build/apr_common.m4 build/find_apr.m4 build/install.sh \
build/config.guess build/config.sub build/get-version.sh
cp -p $apr_src_dir/build/apr_common.m4 $apr_src_dir/build/find_apr.m4 \
$apr_src_dir/build/install.sh $apr_src_dir/build/config.guess \
$apr_src_dir/build/config.sub $apr_src_dir/build/get-version.sh \
build/
# Remove aclocal.m4 as it'll break some builds...
rm -rf aclocal.m4 autom4te*.cache
#
# Generate the autoconf header (include/apu_config.h) and ./configure
#
echo "Creating include/private/apu_config.h ..."
${AUTOHEADER:-autoheader} $verbose
echo "Creating configure ..."
### do some work to toss config.cache?
if ${AUTOCONF:-autoconf} $verbose; then
:
else
echo "autoconf failed"
exit 1
fi
#
# Generate build-outputs.mk for the build system
#
echo "Generating 'make' outputs ..."
$apr_src_dir/build/gen-build.py $verbose make
# Remove autoconf cache again
rm -rf autom4te*.cache
# Create RPM Spec file
if [ -f `which cut` ]; then
echo rebuilding rpm spec file
REVISION=`build/get-version.sh all include/apu_version.h APU`
VERSION=`echo $REVISION | cut -d- -s -f1`
RELEASE=`echo $REVISION | cut -d- -s -f2`
if [ "x$VERSION" = "x" ]; then
VERSION=$REVISION
RELEASE=1
fi
sed -e "s/APU_VERSION/$VERSION/" -e "s/APU_RELEASE/$RELEASE/" \
./build/rpm/apr-util.spec.in > apr-util.spec
fi
# Verify the tree was clean, notify user if not (normal in development)
#
if [ -f "include/apu.h" -o -f "include/private/apu_config.h" -o \
-f "include/apu_want.h" -o -f "include/private/apu_select_dbm.h" ]; then
echo ""
echo "Generated include files already exist, the tree is not clean."
echo "The resulting build-outputs.mk file is incorrect"
fi
exit 0

232
contrib/apr-util/config.layout
View File

@ -1,232 +0,0 @@
##
## config.layout -- Pre-defined Installation Path Layouts
##
## Hints:
## - layouts can be loaded with configure's --enable-layout=ID option
## - when no --enable-layout option is given, the default layout is `apr'
## - a trailing plus character (`+') on paths is replaced with a
## `/<target>' suffix where <target> is currently hardcoded to 'apr'.
## (This may become a configurable parameter at some point.)
##
# Classical APR-util path layout designed for parallel installs.
<Layout apr-util>
prefix: /usr/local/apr
exec_prefix: ${prefix}
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/bin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/modules
mandir: ${prefix}/man
sysconfdir: ${prefix}/conf
datadir: ${prefix}
installbuilddir: ${datadir}/build
includedir: ${prefix}/include/apr-${APRUTIL_MAJOR_VERSION}
localstatedir: ${prefix}
libsuffix: -${APRUTIL_MAJOR_VERSION}
</Layout>
# Classical single-installation APR path layout.
<Layout classic>
prefix: /usr/local/apr
exec_prefix: ${prefix}
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/bin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/modules
mandir: ${prefix}/man
sysconfdir: ${prefix}/conf
datadir: ${prefix}
installbuilddir: ${datadir}/build
includedir: ${prefix}/include
localstatedir: ${prefix}
</Layout>
# GNU standards conforming path layout.
# See FSF's GNU project `make-stds' document for details.
<Layout GNU>
prefix: /usr/local
exec_prefix: ${prefix}
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/sbin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/libexec
mandir: ${prefix}/man
sysconfdir: ${prefix}/etc+
datadir: ${prefix}/share+
installbuilddir: ${datadir}/build
includedir: ${prefix}/include+
localstatedir: ${prefix}/var+
runtimedir: ${localstatedir}/run
</Layout>
# Mac OS X Server (Rhapsody)
<Layout Mac OS X Server>
prefix: /Local/Library/WebServer
exec_prefix: /usr
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/sbin
libdir: ${exec_prefix}/lib
libexecdir: /System/Library/apr/Modules
mandir: ${exec_prefix}/share/man
sysconfdir: ${prefix}/Configuration
datadir: ${prefix}
installbuilddir: /System/Library/apr/Build
includedir: /System/Library/Frameworks/apr.framework/Versions/2.0/Headers
localstatedir: /var
runtimedir: ${prefix}/Logs
</Layout>
# Darwin/Mac OS Layout
<Layout Darwin>
prefix: /usr
exec_prefix: ${prefix}
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/sbin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/libexec+
mandir: ${prefix}/share/man
datadir: /Library/WebServer
sysconfdir: /etc+
installbuilddir: ${prefix}/share/httpd/build
includedir: ${prefix}/include+
localstatedir: /var
runtimedir: ${localstatedir}/run
</Layout>
# Red Hat Linux 7.x layout
<Layout RedHat>
prefix: /usr
exec_prefix: ${prefix}
bindir: ${prefix}/bin
sbindir: ${prefix}/sbin
libdir: ${prefix}/lib
libexecdir: ${prefix}/lib/apr
mandir: ${prefix}/man
sysconfdir: /etc/httpd/conf
datadir: /var/www
installbuilddir: ${datadir}/build
includedir: ${prefix}/include/apr
localstatedir: /var
runtimedir: ${localstatedir}/run
</Layout>
# According to the /opt filesystem conventions
<Layout opt>
prefix: /opt/apr
exec_prefix: ${prefix}
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/sbin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/libexec
mandir: ${prefix}/man
sysconfdir: /etc${prefix}
datadir: ${prefix}/share
installbuilddir: ${datadir}/build
includedir: ${prefix}/include
localstatedir: /var${prefix}
runtimedir: ${localstatedir}/run
</Layout>
# BeOS layout...
<Layout beos>
prefix: /boot/home/apr
exec_prefix: ${prefix}
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/bin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/libexec
mandir: ${prefix}/man
sysconfdir: ${prefix}/conf
datadir: ${prefix}
installbuilddir: ${datadir}/build
includedir: ${prefix}/include
localstatedir: ${prefix}
runtimedir: ${localstatedir}/logs
</Layout>
# SuSE 6.x layout
<Layout SuSE>
prefix: /usr
exec_prefix: ${prefix}
bindir: ${prefix}/bin
sbindir: ${prefix}/sbin
libdir: ${prefix}/lib
libexecdir: ${prefix}/lib/apr
mandir: ${prefix}/share/man
sysconfdir: /etc/httpd
datadir: /usr/local/httpd
installbuilddir: ${datadir}/build
includedir: ${prefix}/include/apr
localstatedir: /var/lib/httpd
runtimedir: /var/run
</Layout>
# BSD/OS layout
<Layout BSDI>
prefix: /var/www
exec_prefix: /usr/contrib
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/bin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/libexec/apr
mandir: ${exec_prefix}/man
sysconfdir: ${prefix}/conf
datadir: ${prefix}
installbuilddir: ${datadir}/build
includedir: ${exec_prefix}/include/apr
localstatedir: /var
runtimedir: ${localstatedir}/run
</Layout>
# Solaris 8 Layout
<Layout Solaris>
prefix: /usr/apr
exec_prefix: ${prefix}
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/bin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/libexec
mandir: ${exec_prefix}/man
sysconfdir: /etc/apr
datadir: /var/apr
installbuilddir: ${datadir}/build
includedir: ${exec_prefix}/include
localstatedir: ${prefix}
runtimedir: /var/run
</Layout>
# OpenBSD Layout
<Layout OpenBSD>
prefix: /var/www
exec_prefix: /usr
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/sbin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/lib/apr/modules
mandir: ${exec_prefix}/share/man
sysconfdir: ${prefix}/conf
datadir: ${prefix}
installbuilddir: ${prefix}/build
includedir: ${exec_prefix}/lib/apr/include
localstatedir: ${prefix}
runtimedir: ${prefix}/logs
</Layout>
# Debian layout
<Layout Debian>
prefix:
exec_prefix: ${prefix}/usr
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/sbin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/lib/apr/modules
mandir: ${exec_prefix}/share/man
datadir: ${exec_prefix}/share/apr
includedir: ${exec_prefix}/include/apr-${APRUTIL_MAJOR_VERSION}
localstatedir: ${prefix}/var/run
runtimedir: ${prefix}/var/run
infodir: ${exec_prefix}/share/info
libsuffix: -${APRUTIL_MAJOR_VERSION}
installbuilddir: ${prefix}/usr/share/apache2/build
</Layout>

25340
contrib/apr-util/configure vendored
View File

File diff suppressed because it is too large Load Diff

344
contrib/apr-util/configure.in
View File

@ -1,344 +0,0 @@
dnl
dnl Process this file with autoconf to produce a configure script
dnl
AC_PREREQ(2.59)
AC_INIT(export_vars.sh.in)
AC_CONFIG_HEADER(include/private/apu_config.h)
AC_CONFIG_AUX_DIR(build)
sinclude(build/apu-conf.m4)
sinclude(build/apu-iconv.m4)
sinclude(build/apu-hints.m4)
sinclude(build/apr_common.m4)
sinclude(build/find_apr.m4)
sinclude(build/crypto.m4)
sinclude(build/dbm.m4)
sinclude(build/dbd.m4)
sinclude(build/dso.m4)
dnl Generate ./config.nice for reproducing runs of configure
dnl
APR_CONFIG_NICE(config.nice)
dnl # Some initial steps for configuration. We setup the default directory
dnl # and which files are to be configured.
dnl Absolute source/build directory
abs_srcdir=`(cd $srcdir && pwd)`
abs_builddir=`pwd`
if test "$abs_builddir" != "$abs_srcdir"; then
USE_VPATH=1
APU_CONFIG_LOCATION=build
else
APU_CONFIG_LOCATION=source
fi
AC_SUBST(APU_CONFIG_LOCATION)
AC_CANONICAL_SYSTEM
AC_PROG_INSTALL
# Use -no-install or -no-fast-install to link the test
# programs on all platforms but Darwin, where it would cause
# the programs to be linked against installed versions of
# libapr instead of those just built.
case $host in
*-apple-darwin*)
LT_NO_INSTALL=""
;;
*-mingw*)
LT_NO_INSTALL="-no-fast-install"
;;
*)
LT_NO_INSTALL="-no-install"
;;
esac
AC_SUBST(LT_NO_INSTALL)
dnl
dnl compute the top directory of the build
dnl note: this is needed for LIBTOOL and exporting the bundled Expat
dnl
top_builddir="$abs_builddir"
AC_SUBST(top_builddir)
AC_SUBST(abs_srcdir)
AC_SUBST(abs_builddir)
dnl Initialize mkdir -p functionality.
APR_MKDIR_P_CHECK($abs_srcdir/build/mkdir.sh)
dnl get our version information
get_version="$abs_srcdir/build/get-version.sh"
version_hdr="$abs_srcdir/include/apu_version.h"
APRUTIL_MAJOR_VERSION="`$get_version major $version_hdr APU`"
APRUTIL_DOTTED_VERSION="`$get_version all $version_hdr APU`"
APU_LTVERSION="-version-info `$get_version libtool $version_hdr APU`"
AC_SUBST(APRUTIL_DOTTED_VERSION)
AC_SUBST(APRUTIL_MAJOR_VERSION)
AC_SUBST(APU_LTVERSION)
echo "APR-util Version: ${APRUTIL_DOTTED_VERSION}"
dnl Enable the layout handling code, then reparse the prefix-style
dnl arguments due to autoconf being a PITA.
APR_ENABLE_LAYOUT(apr-util)
APR_PARSE_ARGUMENTS
dnl load os-specific hints for apr-util
APU_PRELOAD
dnl
dnl set up the compilation flags and stuff
dnl
APRUTIL_INCLUDES=""
APRUTIL_PRIV_INCLUDES="-I$top_builddir/include -I$top_builddir/include/private"
if test -n "$USE_VPATH"; then
APRUTIL_PRIV_INCLUDES="$APRUTIL_PRIV_INCLUDES -I$abs_srcdir/include/private -I$abs_srcdir/include"
fi
dnl
dnl Find the APR includes directory and (possibly) the source (base) dir.
dnl
APU_FIND_APR
dnl
dnl even though we use apr_rules.mk for building apr-util, we need
dnl to grab CC and CPP ahead of time so that apr-util config tests
dnl use the same compiler as APR; we need the same compiler options
dnl and feature test macros as well
dnl
APR_SETIFNULL(CC, `$apr_config --cc`)
APR_SETIFNULL(CPP, `$apr_config --cpp`)
APR_ADDTO(CFLAGS, `$apr_config --cflags`)
APR_ADDTO(CPPFLAGS, `$apr_config --cppflags`)
apr_shlibpath_var=`$apr_config --shlib-path-var`
AC_SUBST(apr_shlibpath_var)
dnl
dnl Find the APR-ICONV directory.
dnl
AC_ARG_WITH(apr-iconv,
[ --with-apr-iconv=DIR relative path to apr-iconv source],
[ apu_apriconv_dir="$withval"
if test "$apu_apriconv_dir" != "no"; then
if test -d "$apu_apriconv_dir"; then
APR_SUBDIR_CONFIG("$apu_apriconv_dir",
[$apache_apr_flags \
--prefix=$prefix \
--exec-prefix=$exec_prefix \
--libdir=$libdir \
--includedir=$includedir \
--bindir=$bindir \
--datadir=$datadir \
--with-installbuilddir=$installbuilddir],
[--enable-layout=*|\'--enable-layout=*])
APRUTIL_EXPORT_LIBS="$abs_srcdir/$apu_apriconv_dir/lib/libapriconv.la \
$APRUTIL_EXPORT_LIBS"
APRUTIL_INCLUDES="-I$abs_srcdir/$apu_apriconv_dir/include \
$APRUTIL_INCLUDES"
APR_ICONV_DIR="$apu_apriconv_dir"
else
APR_ICONV_DIR=""
fi
else
APR_ICONV_DIR=""
fi
])
AC_SUBST(APR_ICONV_DIR)
dnl Find LDAP library
dnl Determine what DBM backend type to use.
dnl Find Expat
dnl Find an iconv library
APU_CHECK_CRYPTO
APU_FIND_LDAP
APU_CHECK_DBM
APU_CHECK_DBD
APU_CHECK_DBD_MYSQL
APU_CHECK_DBD_SQLITE3
APU_CHECK_DBD_SQLITE2
APU_CHECK_DBD_ORACLE
APU_CHECK_DBD_ODBC
APU_FIND_EXPAT
APU_FIND_ICONV
dnl Enable DSO build; must be last:
APU_CHECK_UTIL_DSO
AC_SEARCH_LIBS(crypt, crypt ufc)
AC_MSG_CHECKING(if system crypt() function is threadsafe)
if test "x$apu_crypt_threadsafe" = "x1"; then
AC_DEFINE(APU_CRYPT_THREADSAFE, 1, [Define if the system crypt() function is threadsafe])
msg="yes"
else
msg="no"
fi
AC_MSG_RESULT([$msg])
AC_CHECK_FUNCS(crypt_r, [ crypt_r="1" ], [ crypt_r="0" ])
if test "$crypt_r" = "1"; then
APU_CHECK_CRYPT_R_STYLE
fi
AC_CACHE_CHECK([whether the compiler handles weak symbols], [apu_cv_weak_symbols],
[AC_TRY_RUN([
__attribute__ ((weak))
int weak_noop(void)
{
return 0;
}
int main()
{
return weak_noop();
}], [apu_cv_weak_symbols=yes], [apu_cv_weak_symbols=no], [apu_cv_weak_symbols=no])])
if test "$apu_cv_weak_symbols" = "yes"; then
AC_DEFINE(HAVE_WEAK_SYMBOLS, 1, [Define if compiler handles weak symbols])
fi
AC_CACHE_CHECK([for memset_s support], [apu_cv_memset_s],
[AC_TRY_RUN([
#ifdef HAVE_STRING_H
#define __STDC_WANT_LIB_EXT1__ 1
#include <string.h>
#endif
int main(int argc, const char **argv)
{
char buf[1] = {1};
return memset_s(buf, sizeof buf, 0, sizeof buf) != 0 || *buf != '\0';
}], [apu_cv_memset_s=yes], [apu_cv_memset_s=no], [apu_cv_memset_s=no])])
if test "$apu_cv_memset_s" = "yes"; then
AC_DEFINE([HAVE_MEMSET_S], 1, [Define if memset_s function is supported])
fi
AC_CACHE_CHECK([for explicit_bzero support], [apu_cv_explicit_bzero],
[AC_TRY_RUN([
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
int main(int argc, const char **argv)
{
char buf[1] = {1};
explicit_bzero(buf, sizeof buf);
return *buf != '\0';
}], [apu_cv_explicit_bzero=yes], [apu_cv_explicit_bzero=no], [apu_cv_explicit_bzero=no])])
if test "$apu_cv_explicit_bzero" = "yes"; then
AC_DEFINE([HAVE_EXPLICIT_BZERO], 1, [Define if explicit_bzero function is supported])
fi
so_ext=$APR_SO_EXT
lib_target=$APR_LIB_TARGET
AC_SUBST(so_ext)
AC_SUBST(lib_target)
APRUTIL_LIBNAME="aprutil${libsuffix}"
AC_SUBST(APRUTIL_LIBNAME)
# Set up destination directory for DSOs.
APU_DSO_LIBDIR="\${libdir}/apr-util-${APRUTIL_MAJOR_VERSION}"
# Set APU_HAVE_MODULES appropriately for the Makefile
if test -n "$APU_MODULES"; then
APU_HAVE_MODULES=yes
else
APU_HAVE_MODULES=no
fi
# Define expanded libdir for apu_config.h
APR_EXPAND_VAR(abs_dso_libdir, $APU_DSO_LIBDIR)
AC_DEFINE_UNQUOTED([APU_DSO_LIBDIR], ["$abs_dso_libdir"],
[Define to be absolute path to DSO directory])
AC_SUBST(APU_HAVE_MODULES)
AC_SUBST(APU_DSO_LIBDIR)
AC_SUBST(APU_MODULES)
AC_SUBST(EXTRA_OBJECTS)
dnl
dnl Prep all the flags and stuff for compilation and export to other builds
dnl
APR_ADDTO(APRUTIL_LIBS, [$APR_LIBS])
AC_SUBST(APRUTIL_EXPORT_LIBS)
AC_SUBST(APRUTIL_PRIV_INCLUDES)
AC_SUBST(APRUTIL_INCLUDES)
AC_SUBST(APRUTIL_LDFLAGS)
AC_SUBST(APRUTIL_LIBS)
AC_SUBST(LDFLAGS)
dnl copy apr's rules.mk into our build directory.
if test ! -d ./build; then
$mkdir_p build
fi
dnl
dnl MinGW: If APR is shared, APR_DECLARE_EXPORT will be defined in the
dnl internal CPPFLAGS, but APR-Util needs APU_DECLARE_EXPORT instead.
dnl If APR is static, APR_DECLARE_STATIC will be defined in the
dnl internal CPPFLAGS, but APR-Util needs APU_DECLARE_STATIC too.
dnl
case $host in
*-mingw*)
sed -e 's/-DAPR_DECLARE_EXPORT/-DAPU_DECLARE_EXPORT/' \
-e 's/-DAPR_DECLARE_STATIC/-DAPU_DECLARE_STATIC -DAPR_DECLARE_STATIC/' \
< $APR_BUILD_DIR/apr_rules.mk > $abs_builddir/build/rules.mk
;;
*)
cp $APR_BUILD_DIR/apr_rules.mk $abs_builddir/build/rules.mk
;;
esac
dnl
dnl BSD/OS (BSDi) needs to use a different include syntax in the Makefiles
dnl
case "$host_alias" in
*bsdi* | BSD/OS)
# Check whether they've installed GNU make
if make --version > /dev/null 2>&1; then
INCLUDE_RULES="include $abs_builddir/build/rules.mk"
INCLUDE_OUTPUTS="include $abs_srcdir/build-outputs.mk"
else
INCLUDE_RULES=".include \"$abs_builddir/build/rules.mk\""
INCLUDE_OUTPUTS=".include \"$abs_srcdir/build-outputs.mk\""
fi
;;
*)
INCLUDE_RULES="include $abs_builddir/build/rules.mk"
INCLUDE_OUTPUTS="include $abs_srcdir/build-outputs.mk"
;;
esac
AC_SUBST(INCLUDE_RULES)
AC_SUBST(INCLUDE_OUTPUTS)
for d in include include/private; do
test -d $top_builddir/$d || mkdir $top_builddir/$d
done
AC_CONFIG_FILES([Makefile export_vars.sh
build/pkg/pkginfo apr-util.pc
apu-$APRUTIL_MAJOR_VERSION-config:apu-config.in
include/private/apu_select_dbm.h
include/apr_ldap.h
include/apu.h include/apu_want.h])
AC_CONFIG_COMMANDS([default], [
chmod +x apu-$APRUTIL_MAJOR_VERSION-config
],[
APRUTIL_MAJOR_VERSION=$APRUTIL_MAJOR_VERSION
])
if test -d $srcdir/test; then
AC_CONFIG_FILES([test/Makefile])
fi
AC_OUTPUT

608
contrib/apr-util/crypto/apr_crypto.c
View File

@ -1,608 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <ctype.h>
#include <stdio.h>
#include "apu_config.h"
#include "apu.h"
#include "apr_pools.h"
#include "apr_dso.h"
#include "apr_strings.h"
#include "apr_hash.h"
#include "apr_thread_mutex.h"
#include "apr_lib.h"
#if APU_HAVE_CRYPTO
#include "apu_internal.h"
#include "apr_crypto_internal.h"
#include "apr_crypto.h"
#include "apu_version.h"
static apr_hash_t *drivers = NULL;
#define ERROR_SIZE 1024
#define CLEANUP_CAST (apr_status_t (*)(void*))
#define APR_TYPEDEF_STRUCT(type, incompletion) \
struct type { \
incompletion \
void *unk[]; \
};
APR_TYPEDEF_STRUCT(apr_crypto_t,
apr_pool_t *pool;
apr_crypto_driver_t *provider;
)
APR_TYPEDEF_STRUCT(apr_crypto_key_t,
apr_pool_t *pool;
apr_crypto_driver_t *provider;
const apr_crypto_t *f;
)
APR_TYPEDEF_STRUCT(apr_crypto_block_t,
apr_pool_t *pool;
apr_crypto_driver_t *provider;
const apr_crypto_t *f;
)
typedef struct apr_crypto_clear_t {
void *buffer;
apr_size_t size;
} apr_crypto_clear_t;
#if !APU_DSO_BUILD
#define DRIVER_LOAD(name,driver_name,pool,params,rv,result) \
{ \
extern const apr_crypto_driver_t driver_name; \
apr_hash_set(drivers,name,APR_HASH_KEY_STRING,&driver_name); \
if (driver_name.init) { \
rv = driver_name.init(pool, params, result); \
} \
*driver = &driver_name; \
}
#endif
static apr_status_t apr_crypto_term(void *ptr)
{
/* set drivers to NULL so init can work again */
drivers = NULL;
/* Everything else we need is handled by cleanups registered
* when we created mutexes and loaded DSOs
*/
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_crypto_init(apr_pool_t *pool)
{
apr_status_t ret = APR_SUCCESS;
apr_pool_t *parent;
if (drivers != NULL) {
return APR_SUCCESS;
}
/* Top level pool scope, need process-scope lifetime */
for (parent = apr_pool_parent_get(pool);
parent && parent != pool;
parent = apr_pool_parent_get(pool))
pool = parent;
#if APU_DSO_BUILD
/* deprecate in 2.0 - permit implicit initialization */
apu_dso_init(pool);
#endif
drivers = apr_hash_make(pool);
apr_pool_cleanup_register(pool, NULL, apr_crypto_term,
apr_pool_cleanup_null);
return ret;
}
static apr_status_t crypto_clear(void *ptr)
{
apr_crypto_clear_t *clear = (apr_crypto_clear_t *)ptr;
apr_crypto_memzero(clear->buffer, clear->size);
clear->buffer = NULL;
clear->size = 0;
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_crypto_clear(apr_pool_t *pool,
void *buffer, apr_size_t size)
{
apr_crypto_clear_t *clear = apr_palloc(pool, sizeof(apr_crypto_clear_t));
clear->buffer = buffer;
clear->size = size;
apr_pool_cleanup_register(pool, clear, crypto_clear,
apr_pool_cleanup_null);
return APR_SUCCESS;
}
#if defined(HAVE_WEAK_SYMBOLS)
void apr__memzero_explicit(void *buffer, apr_size_t size);
__attribute__ ((weak))
void apr__memzero_explicit(void *buffer, apr_size_t size)
{
memset(buffer, 0, size);
}
#endif
APU_DECLARE(apr_status_t) apr_crypto_memzero(void *buffer, apr_size_t size)
{
#if defined(WIN32)
SecureZeroMemory(buffer, size);
#elif defined(HAVE_MEMSET_S)
if (size) {
return memset_s(buffer, (rsize_t)size, 0, (rsize_t)size);
}
#elif defined(HAVE_EXPLICIT_BZERO)
explicit_bzero(buffer, size);
#elif defined(HAVE_WEAK_SYMBOLS)
apr__memzero_explicit(buffer, size);
#else
apr_size_t i;
volatile unsigned char *volatile ptr = buffer;
for (i = 0; i < size; ++i) {
ptr[i] = 0;
}
#endif
return APR_SUCCESS;
}
APU_DECLARE(int) apr_crypto_equals(const void *buf1, const void *buf2,
apr_size_t size)
{
const unsigned char *p1 = buf1;
const unsigned char *p2 = buf2;
unsigned char diff = 0;
apr_size_t i;
for (i = 0; i < size; ++i) {
diff |= p1[i] ^ p2[i];
}
return 1 & ((diff - 1) >> 8);
}
APU_DECLARE(apr_status_t) apr_crypto_get_driver(
const apr_crypto_driver_t **driver, const char *name,
const char *params, const apu_err_t **result, apr_pool_t *pool)
{
#if APU_DSO_BUILD
char modname[32];
char symname[34];
apr_dso_handle_t *dso;
apr_dso_handle_sym_t symbol;
#endif
apr_status_t rv;
if (result) {
*result = NULL; /* until further notice */
}
#if APU_DSO_BUILD
rv = apu_dso_mutex_lock();
if (rv) {
return rv;
}
#endif
*driver = apr_hash_get(drivers, name, APR_HASH_KEY_STRING);
if (*driver) {
#if APU_DSO_BUILD
apu_dso_mutex_unlock();
#endif
return APR_SUCCESS;
}
#if APU_DSO_BUILD
/* The driver DSO must have exactly the same lifetime as the
* drivers hash table; ignore the passed-in pool */
pool = apr_hash_pool_get(drivers);
#if defined(NETWARE)
apr_snprintf(modname, sizeof(modname), "crypto%s.nlm", name);
#elif defined(WIN32) || defined(__CYGWIN__)
apr_snprintf(modname, sizeof(modname),
"apr_crypto_%s-" APU_STRINGIFY(APU_MAJOR_VERSION) ".dll", name);
#else
apr_snprintf(modname, sizeof(modname),
"apr_crypto_%s-" APU_STRINGIFY(APU_MAJOR_VERSION) ".so", name);
#endif
apr_snprintf(symname, sizeof(symname), "apr_crypto_%s_driver", name);
rv = apu_dso_load(&dso, &symbol, modname, symname, pool);
if (rv == APR_SUCCESS || rv == APR_EINIT) { /* previously loaded?!? */
apr_crypto_driver_t *d = symbol;
rv = APR_SUCCESS;
if (d->init) {
rv = d->init(pool, params, result);
}
if (APR_SUCCESS == rv) {
*driver = symbol;
name = apr_pstrdup(pool, name);
apr_hash_set(drivers, name, APR_HASH_KEY_STRING, *driver);
}
}
apu_dso_mutex_unlock();
if (APR_SUCCESS != rv && result && !*result) {
char *buffer = apr_pcalloc(pool, ERROR_SIZE);
apu_err_t *err = apr_pcalloc(pool, sizeof(apu_err_t));
if (err && buffer) {
apr_dso_error(dso, buffer, ERROR_SIZE - 1);
err->msg = buffer;
err->reason = apr_pstrdup(pool, modname);
*result = err;
}
}
#else /* not builtin and !APR_HAS_DSO => not implemented */
rv = APR_ENOTIMPL;
/* Load statically-linked drivers: */
#if APU_HAVE_OPENSSL
if (name[0] == 'o' && !strcmp(name, "openssl")) {
DRIVER_LOAD("openssl", apr_crypto_openssl_driver, pool, params, rv, result);
}
#endif
#if APU_HAVE_NSS
if (name[0] == 'n' && !strcmp(name, "nss")) {
DRIVER_LOAD("nss", apr_crypto_nss_driver, pool, params, rv, result);
}
#endif
#if APU_HAVE_COMMONCRYPTO
if (name[0] == 'c' && !strcmp(name, "commoncrypto")) {
DRIVER_LOAD("commoncrypto", apr_crypto_commoncrypto_driver, pool, params, rv, result);
}
#endif
#if APU_HAVE_MSCAPI
if (name[0] == 'm' && !strcmp(name, "mscapi")) {
DRIVER_LOAD("mscapi", apr_crypto_mscapi_driver, pool, params, rv, result);
}
#endif
#if APU_HAVE_MSCNG
if (name[0] == 'm' && !strcmp(name, "mscng")) {
DRIVER_LOAD("mscng", apr_crypto_mscng_driver, pool, params, rv, result);
}
#endif
#endif
return rv;
}
/**
* @brief Return the name of the driver.
*
* @param driver - The driver in use.
* @return The name of the driver.
*/
APU_DECLARE(const char *)apr_crypto_driver_name (
const apr_crypto_driver_t *driver)
{
return driver->name;
}
/**
* @brief Get the result of the last operation on a context. If the result
* is NULL, the operation was successful.
* @param result - the result structure
* @param f - context pointer
* @return APR_SUCCESS for success
*/
APU_DECLARE(apr_status_t) apr_crypto_error(const apu_err_t **result,
const apr_crypto_t *f)
{
return f->provider->error(result, f);
}
/**
* @brief Create a context for supporting encryption. Keys, certificates,
* algorithms and other parameters will be set per context. More than
* one context can be created at one time. A cleanup will be automatically
* registered with the given pool to guarantee a graceful shutdown.
* @param f - context pointer will be written here
* @param driver - driver to use
* @param params - array of key parameters
* @param pool - process pool
* @return APR_ENOENGINE when the engine specified does not exist. APR_EINITENGINE
* if the engine cannot be initialised.
* @remarks NSS: currently no params are supported.
* @remarks OpenSSL: the params can have "engine" as a key, followed by an equal
* sign and a value.
*/
APU_DECLARE(apr_status_t) apr_crypto_make(apr_crypto_t **f,
const apr_crypto_driver_t *driver, const char *params, apr_pool_t *pool)
{
return driver->make(f, driver, params, pool);
}
/**
* @brief Get a hash table of key types, keyed by the name of the type against
* a pointer to apr_crypto_block_key_type_t, which in turn begins with an
* integer.
*
* @param types - hashtable of key types keyed to constants.
* @param f - encryption context
* @return APR_SUCCESS for success
*/
APU_DECLARE(apr_status_t) apr_crypto_get_block_key_types(apr_hash_t **types,
const apr_crypto_t *f)
{
return f->provider->get_block_key_types(types, f);
}
/**
* @brief Get a hash table of key modes, keyed by the name of the mode against
* a pointer to apr_crypto_block_key_mode_t, which in turn begins with an
* integer.
*
* @param modes - hashtable of key modes keyed to constants.
* @param f - encryption context
* @return APR_SUCCESS for success
*/
APU_DECLARE(apr_status_t) apr_crypto_get_block_key_modes(apr_hash_t **modes,
const apr_crypto_t *f)
{
return f->provider->get_block_key_modes(modes, f);
}
/**
* @brief Create a key from the provided secret or passphrase. The key is cleaned
* up when the context is cleaned, and may be reused with multiple encryption
* or decryption operations.
* @note If *key is NULL, a apr_crypto_key_t will be created from a pool. If
* *key is not NULL, *key must point at a previously created structure.
* @param key The key returned, see note.
* @param rec The key record, from which the key will be derived.
* @param f The context to use.
* @param p The pool to use.
* @return Returns APR_ENOKEY if the pass phrase is missing or empty, or if a backend
* error occurred while generating the key. APR_ENOCIPHER if the type or mode
* is not supported by the particular backend. APR_EKEYTYPE if the key type is
* not known. APR_EPADDING if padding was requested but is not supported.
* APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_key(apr_crypto_key_t **key,
const apr_crypto_key_rec_t *rec, const apr_crypto_t *f, apr_pool_t *p)
{
return f->provider->key(key, rec, f, p);
}
/**
* @brief Create a key from the given passphrase. By default, the PBKDF2
* algorithm is used to generate the key from the passphrase. It is expected
* that the same pass phrase will generate the same key, regardless of the
* backend crypto platform used. The key is cleaned up when the context
* is cleaned, and may be reused with multiple encryption or decryption
* operations.
* @note If *key is NULL, a apr_crypto_key_t will be created from a pool. If
* *key is not NULL, *key must point at a previously created structure.
* @param key The key returned, see note.
* @param ivSize The size of the initialisation vector will be returned, based
* on whether an IV is relevant for this type of crypto.
* @param pass The passphrase to use.
* @param passLen The passphrase length in bytes
* @param salt The salt to use.
* @param saltLen The salt length in bytes
* @param type 3DES_192, AES_128, AES_192, AES_256.
* @param mode Electronic Code Book / Cipher Block Chaining.
* @param doPad Pad if necessary.
* @param iterations Number of iterations to use in algorithm
* @param f The context to use.
* @param p The pool to use.
* @return Returns APR_ENOKEY if the pass phrase is missing or empty, or if a backend
* error occurred while generating the key. APR_ENOCIPHER if the type or mode
* is not supported by the particular backend. APR_EKEYTYPE if the key type is
* not known. APR_EPADDING if padding was requested but is not supported.
* APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_passphrase(apr_crypto_key_t **key,
apr_size_t *ivSize, const char *pass, apr_size_t passLen,
const unsigned char * salt, apr_size_t saltLen,
const apr_crypto_block_key_type_e type,
const apr_crypto_block_key_mode_e mode, const int doPad,
const int iterations, const apr_crypto_t *f, apr_pool_t *p)
{
return f->provider->passphrase(key, ivSize, pass, passLen, salt, saltLen,
type, mode, doPad, iterations, f, p);
}
/**
* @brief Initialise a context for encrypting arbitrary data using the given key.
* @note If *ctx is NULL, a apr_crypto_block_t will be created from a pool. If
* *ctx is not NULL, *ctx must point at a previously created structure.
* @param ctx The block context returned, see note.
* @param iv Optional initialisation vector. If the buffer pointed to is NULL,
* an IV will be created at random, in space allocated from the pool.
* If the buffer pointed to is not NULL, the IV in the buffer will be
* used.
* @param key The key structure to use.
* @param blockSize The block size of the cipher.
* @param p The pool to use.
* @return Returns APR_ENOIV if an initialisation vector is required but not specified.
* Returns APR_EINIT if the backend failed to initialise the context. Returns
* APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_encrypt_init(
apr_crypto_block_t **ctx, const unsigned char **iv,
const apr_crypto_key_t *key, apr_size_t *blockSize, apr_pool_t *p)
{
return key->provider->block_encrypt_init(ctx, iv, key, blockSize, p);
}
/**
* @brief Encrypt data provided by in, write it to out.
* @note The number of bytes written will be written to outlen. If
* out is NULL, outlen will contain the maximum size of the
* buffer needed to hold the data, including any data
* generated by apr_crypto_block_encrypt_finish below. If *out points
* to NULL, a buffer sufficiently large will be created from
* the pool provided. If *out points to a not-NULL value, this
* value will be used as a buffer instead.
* @param out Address of a buffer to which data will be written,
* see note.
* @param outlen Length of the output will be written here.
* @param in Address of the buffer to read.
* @param inlen Length of the buffer to read.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
* not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_encrypt(unsigned char **out,
apr_size_t *outlen, const unsigned char *in, apr_size_t inlen,
apr_crypto_block_t *ctx)
{
return ctx->provider->block_encrypt(out, outlen, in, inlen, ctx);
}
/**
* @brief Encrypt final data block, write it to out.
* @note If necessary the final block will be written out after being
* padded. Typically the final block will be written to the
* same buffer used by apr_crypto_block_encrypt, offset by the
* number of bytes returned as actually written by the
* apr_crypto_block_encrypt() call. After this call, the context
* is cleaned and can be reused by apr_crypto_block_encrypt_init().
* @param out Address of a buffer to which data will be written. This
* buffer must already exist, and is usually the same
* buffer used by apr_evp_crypt(). See note.
* @param outlen Length of the output will be written here.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred.
* @return APR_EPADDING if padding was enabled and the block was incorrectly
* formatted.
* @return APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_encrypt_finish(unsigned char *out,
apr_size_t *outlen, apr_crypto_block_t *ctx)
{
return ctx->provider->block_encrypt_finish(out, outlen, ctx);
}
/**
* @brief Initialise a context for decrypting arbitrary data using the given key.
* @note If *ctx is NULL, a apr_crypto_block_t will be created from a pool. If
* *ctx is not NULL, *ctx must point at a previously created structure.
* @param ctx The block context returned, see note.
* @param blockSize The block size of the cipher.
* @param iv Optional initialisation vector.
* @param key The key structure to use.
* @param p The pool to use.
* @return Returns APR_ENOIV if an initialisation vector is required but not specified.
* Returns APR_EINIT if the backend failed to initialise the context. Returns
* APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_decrypt_init(
apr_crypto_block_t **ctx, apr_size_t *blockSize,
const unsigned char *iv, const apr_crypto_key_t *key, apr_pool_t *p)
{
return key->provider->block_decrypt_init(ctx, blockSize, iv, key, p);
}
/**
* @brief Decrypt data provided by in, write it to out.
* @note The number of bytes written will be written to outlen. If
* out is NULL, outlen will contain the maximum size of the
* buffer needed to hold the data, including any data
* generated by apr_crypto_block_decrypt_finish below. If *out points
* to NULL, a buffer sufficiently large will be created from
* the pool provided. If *out points to a not-NULL value, this
* value will be used as a buffer instead.
* @param out Address of a buffer to which data will be written,
* see note.
* @param outlen Length of the output will be written here.
* @param in Address of the buffer to read.
* @param inlen Length of the buffer to read.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
* not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_decrypt(unsigned char **out,
apr_size_t *outlen, const unsigned char *in, apr_size_t inlen,
apr_crypto_block_t *ctx)
{
return ctx->provider->block_decrypt(out, outlen, in, inlen, ctx);
}
/**
* @brief Decrypt final data block, write it to out.
* @note If necessary the final block will be written out after being
* padded. Typically the final block will be written to the
* same buffer used by apr_crypto_block_decrypt, offset by the
* number of bytes returned as actually written by the
* apr_crypto_block_decrypt() call. After this call, the context
* is cleaned and can be reused by apr_crypto_block_decrypt_init().
* @param out Address of a buffer to which data will be written. This
* buffer must already exist, and is usually the same
* buffer used by apr_evp_crypt(). See note.
* @param outlen Length of the output will be written here.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred.
* @return APR_EPADDING if padding was enabled and the block was incorrectly
* formatted.
* @return APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_decrypt_finish(unsigned char *out,
apr_size_t *outlen, apr_crypto_block_t *ctx)
{
return ctx->provider->block_decrypt_finish(out, outlen, ctx);
}
/**
* @brief Clean encryption / decryption context.
* @note After cleanup, a context is free to be reused if necessary.
* @param ctx The block context to use.
* @return Returns APR_ENOTIMPL if not supported.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_cleanup(apr_crypto_block_t *ctx)
{
return ctx->provider->block_cleanup(ctx);
}
/**
* @brief Clean encryption / decryption context.
* @note After cleanup, a context is free to be reused if necessary.
* @param f The context to use.
* @return Returns APR_ENOTIMPL if not supported.
*/
APU_DECLARE(apr_status_t) apr_crypto_cleanup(apr_crypto_t *f)
{
return f->provider->cleanup(f);
}
/**
* @brief Shutdown the crypto library.
* @note After shutdown, it is expected that the init function can be called again.
* @param driver - driver to use
* @return Returns APR_ENOTIMPL if not supported.
*/
APU_DECLARE(apr_status_t) apr_crypto_shutdown(const apr_crypto_driver_t *driver)
{
return driver->shutdown();
}
#endif /* APU_HAVE_CRYPTO */

906
contrib/apr-util/crypto/apr_crypto_commoncrypto.c
View File

@ -1,906 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr.h"
#include "apr_lib.h"
#include "apu.h"
#include "apu_errno.h"
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
#include "apr_strings.h"
#include "apr_time.h"
#include "apr_buckets.h"
#include "apr_random.h"
#include "apr_crypto_internal.h"
#if APU_HAVE_CRYPTO
#include <CommonCrypto/CommonCrypto.h>
#define LOG_PREFIX "apr_crypto_commoncrypto: "
struct apr_crypto_t
{
apr_pool_t *pool;
const apr_crypto_driver_t *provider;
apu_err_t *result;
apr_hash_t *types;
apr_hash_t *modes;
apr_random_t *rng;
};
struct apr_crypto_key_t
{
apr_pool_t *pool;
const apr_crypto_driver_t *provider;
const apr_crypto_t *f;
CCAlgorithm algorithm;
CCOptions options;
unsigned char *key;
int keyLen;
int ivSize;
apr_size_t blockSize;
};
struct apr_crypto_block_t
{
apr_pool_t *pool;
const apr_crypto_driver_t *provider;
const apr_crypto_t *f;
const apr_crypto_key_t *key;
CCCryptorRef ref;
};
static struct apr_crypto_block_key_type_t key_types[] =
{
{ APR_KEY_3DES_192, 24, 8, 8 },
{ APR_KEY_AES_128, 16, 16, 16 },
{ APR_KEY_AES_192, 24, 16, 16 },
{ APR_KEY_AES_256, 32, 16, 16 } };
static struct apr_crypto_block_key_mode_t key_modes[] =
{
{ APR_MODE_ECB },
{ APR_MODE_CBC } };
/**
* Fetch the most recent error from this driver.
*/
static apr_status_t crypto_error(const apu_err_t **result,
const apr_crypto_t *f)
{
*result = f->result;
return APR_SUCCESS;
}
/**
* Shutdown the crypto library and release resources.
*/
static apr_status_t crypto_shutdown(void)
{
return APR_SUCCESS;
}
static apr_status_t crypto_shutdown_helper(void *data)
{
return crypto_shutdown();
}
/**
* Initialise the crypto library and perform one time initialisation.
*/
static apr_status_t crypto_init(apr_pool_t *pool, const char *params,
const apu_err_t **result)
{
apr_pool_cleanup_register(pool, pool, crypto_shutdown_helper,
apr_pool_cleanup_null);
return APR_SUCCESS;
}
/**
* @brief Clean encryption / decryption context.
* @note After cleanup, a context is free to be reused if necessary.
* @param ctx The block context to use.
* @return Returns APR_ENOTIMPL if not supported.
*/
static apr_status_t crypto_block_cleanup(apr_crypto_block_t *ctx)
{
if (ctx->ref) {
CCCryptorRelease(ctx->ref);
ctx->ref = NULL;
}
return APR_SUCCESS;
}
static apr_status_t crypto_block_cleanup_helper(void *data)
{
apr_crypto_block_t *block = (apr_crypto_block_t *) data;
return crypto_block_cleanup(block);
}
/**
* @brief Clean encryption / decryption context.
* @note After cleanup, a context is free to be reused if necessary.
* @param f The context to use.
* @return Returns APR_ENOTIMPL if not supported.
*/
static apr_status_t crypto_cleanup(apr_crypto_t *f)
{
return APR_SUCCESS;
}
static apr_status_t crypto_cleanup_helper(void *data)
{
apr_crypto_t *f = (apr_crypto_t *) data;
return crypto_cleanup(f);
}
/**
* @brief Create a context for supporting encryption. Keys, certificates,
* algorithms and other parameters will be set per context. More than
* one context can be created at one time. A cleanup will be automatically
* registered with the given pool to guarantee a graceful shutdown.
* @param f - context pointer will be written here
* @param provider - provider to use
* @param params - array of key parameters
* @param pool - process pool
* @return APR_ENOENGINE when the engine specified does not exist. APR_EINITENGINE
* if the engine cannot be initialised.
*/
static apr_status_t crypto_make(apr_crypto_t **ff,
const apr_crypto_driver_t *provider, const char *params,
apr_pool_t *pool)
{
apr_crypto_t *f = apr_pcalloc(pool, sizeof(apr_crypto_t));
apr_status_t rv;
if (!f) {
return APR_ENOMEM;
}
*ff = f;
f->pool = pool;
f->provider = provider;
/* seed the secure random number generator */
f->rng = apr_random_standard_new(pool);
if (!f->rng) {
return APR_ENOMEM;
}
do {
unsigned char seed[8];
rv = apr_generate_random_bytes(seed, sizeof(seed));
if (rv != APR_SUCCESS) {
return rv;
}
apr_random_add_entropy(f->rng, seed, sizeof(seed));
rv = apr_random_secure_ready(f->rng);
} while (rv == APR_ENOTENOUGHENTROPY);
f->result = apr_pcalloc(pool, sizeof(apu_err_t));
if (!f->result) {
return APR_ENOMEM;
}
f->types = apr_hash_make(pool);
if (!f->types) {
return APR_ENOMEM;
}
apr_hash_set(f->types, "3des192", APR_HASH_KEY_STRING, &(key_types[0]));
apr_hash_set(f->types, "aes128", APR_HASH_KEY_STRING, &(key_types[1]));
apr_hash_set(f->types, "aes192", APR_HASH_KEY_STRING, &(key_types[2]));
apr_hash_set(f->types, "aes256", APR_HASH_KEY_STRING, &(key_types[3]));
f->modes = apr_hash_make(pool);
if (!f->modes) {
return APR_ENOMEM;
}
apr_hash_set(f->modes, "ecb", APR_HASH_KEY_STRING, &(key_modes[0]));
apr_hash_set(f->modes, "cbc", APR_HASH_KEY_STRING, &(key_modes[1]));
apr_pool_cleanup_register(pool, f, crypto_cleanup_helper,
apr_pool_cleanup_null);
return APR_SUCCESS;
}
/**
* @brief Get a hash table of key types, keyed by the name of the type against
* a pointer to apr_crypto_block_key_type_t.
*
* @param types - hashtable of key types keyed to constants.
* @param f - encryption context
* @return APR_SUCCESS for success
*/
static apr_status_t crypto_get_block_key_types(apr_hash_t **types,
const apr_crypto_t *f)
{
*types = f->types;
return APR_SUCCESS;
}
/**
* @brief Get a hash table of key modes, keyed by the name of the mode against
* a pointer to apr_crypto_block_key_mode_t.
*
* @param modes - hashtable of key modes keyed to constants.
* @param f - encryption context
* @return APR_SUCCESS for success
*/
static apr_status_t crypto_get_block_key_modes(apr_hash_t **modes,
const apr_crypto_t *f)
{
*modes = f->modes;
return APR_SUCCESS;
}
/*
* Work out which mechanism to use.
*/
static apr_status_t crypto_cipher_mechanism(apr_crypto_key_t *key,
const apr_crypto_block_key_type_e type,
const apr_crypto_block_key_mode_e mode, const int doPad, apr_pool_t *p)
{
/* handle padding */
key->options = doPad ? kCCOptionPKCS7Padding : 0;
/* determine the algorithm to be used */
switch (type) {
case (APR_KEY_3DES_192):
/* A 3DES key */
if (mode == APR_MODE_CBC) {
key->algorithm = kCCAlgorithm3DES;
key->keyLen = kCCKeySize3DES;
key->ivSize = kCCBlockSize3DES;
key->blockSize = kCCBlockSize3DES;
}
else {
key->algorithm = kCCAlgorithm3DES;
key->options += kCCOptionECBMode;
key->keyLen = kCCKeySize3DES;
key->ivSize = 0;
key->blockSize = kCCBlockSize3DES;
}
break;
case (APR_KEY_AES_128):
if (mode == APR_MODE_CBC) {
key->algorithm = kCCAlgorithmAES128;
key->keyLen = kCCKeySizeAES128;
key->ivSize = kCCBlockSizeAES128;
key->blockSize = kCCBlockSizeAES128;
}
else {
key->algorithm = kCCAlgorithmAES128;
key->options += kCCOptionECBMode;
key->keyLen = kCCKeySizeAES128;
key->ivSize = 0;
key->blockSize = kCCBlockSizeAES128;
}
break;
case (APR_KEY_AES_192):
if (mode == APR_MODE_CBC) {
key->algorithm = kCCAlgorithmAES128;
key->keyLen = kCCKeySizeAES192;
key->ivSize = kCCBlockSizeAES128;
key->blockSize = kCCBlockSizeAES128;
}
else {
key->algorithm = kCCAlgorithmAES128;
key->options += kCCOptionECBMode;
key->keyLen = kCCKeySizeAES192;
key->ivSize = 0;
key->blockSize = kCCBlockSizeAES128;
}
break;
case (APR_KEY_AES_256):
if (mode == APR_MODE_CBC) {
key->algorithm = kCCAlgorithmAES128;
key->keyLen = kCCKeySizeAES256;
key->ivSize = kCCBlockSizeAES128;
key->blockSize = kCCBlockSizeAES128;
}
else {
key->algorithm = kCCAlgorithmAES128;
key->options += kCCOptionECBMode;
key->keyLen = kCCKeySizeAES256;
key->ivSize = 0;
key->blockSize = kCCBlockSizeAES128;
}
break;
default:
/* TODO: Support CAST, Blowfish */
/* unknown key type, give up */
return APR_EKEYTYPE;
}
/* make space for the key */
key->key = apr_palloc(p, key->keyLen);
if (!key->key) {
return APR_ENOMEM;
}
apr_crypto_clear(p, key->key, key->keyLen);
return APR_SUCCESS;
}
/**
* @brief Create a key from the provided secret or passphrase. The key is cleaned
* up when the context is cleaned, and may be reused with multiple encryption
* or decryption operations.
* @note If *key is NULL, a apr_crypto_key_t will be created from a pool. If
* *key is not NULL, *key must point at a previously created structure.
* @param key The key returned, see note.
* @param rec The key record, from which the key will be derived.
* @param f The context to use.
* @param p The pool to use.
* @return Returns APR_ENOKEY if the pass phrase is missing or empty, or if a backend
* error occurred while generating the key. APR_ENOCIPHER if the type or mode
* is not supported by the particular backend. APR_EKEYTYPE if the key type is
* not known. APR_EPADDING if padding was requested but is not supported.
* APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_key(apr_crypto_key_t **k,
const apr_crypto_key_rec_t *rec, const apr_crypto_t *f, apr_pool_t *p)
{
apr_status_t rv;
apr_crypto_key_t *key = *k;
if (!key) {
*k = key = apr_pcalloc(p, sizeof *key);
}
if (!key) {
return APR_ENOMEM;
}
key->f = f;
key->provider = f->provider;
/* decide on what cipher mechanism we will be using */
rv = crypto_cipher_mechanism(key, rec->type, rec->mode, rec->pad, p);
if (APR_SUCCESS != rv) {
return rv;
}
switch (rec->ktype) {
case APR_CRYPTO_KTYPE_PASSPHRASE: {
/* generate the key */
if ((f->result->rc = CCKeyDerivationPBKDF(kCCPBKDF2,
rec->k.passphrase.pass, rec->k.passphrase.passLen,
rec->k.passphrase.salt, rec->k.passphrase.saltLen,
kCCPRFHmacAlgSHA1, rec->k.passphrase.iterations, key->key,
key->keyLen)) == kCCParamError) {
return APR_ENOKEY;
}
break;
}
case APR_CRYPTO_KTYPE_SECRET: {
/* sanity check - key correct size? */
if (rec->k.secret.secretLen != key->keyLen) {
return APR_EKEYLENGTH;
}
/* copy the key */
memcpy(key->key, rec->k.secret.secret, rec->k.secret.secretLen);
break;
}
default: {
return APR_ENOKEY;
}
}
return APR_SUCCESS;
}
/**
* @brief Create a key from the given passphrase. By default, the PBKDF2
* algorithm is used to generate the key from the passphrase. It is expected
* that the same pass phrase will generate the same key, regardless of the
* backend crypto platform used. The key is cleaned up when the context
* is cleaned, and may be reused with multiple encryption or decryption
* operations.
* @note If *key is NULL, a apr_crypto_key_t will be created from a pool. If
* *key is not NULL, *key must point at a previously created structure.
* @param key The key returned, see note.
* @param ivSize The size of the initialisation vector will be returned, based
* on whether an IV is relevant for this type of crypto.
* @param pass The passphrase to use.
* @param passLen The passphrase length in bytes
* @param salt The salt to use.
* @param saltLen The salt length in bytes
* @param type 3DES_192, AES_128, AES_192, AES_256.
* @param mode Electronic Code Book / Cipher Block Chaining.
* @param doPad Pad if necessary.
* @param iterations Iteration count
* @param f The context to use.
* @param p The pool to use.
* @return Returns APR_ENOKEY if the pass phrase is missing or empty, or if a backend
* error occurred while generating the key. APR_ENOCIPHER if the type or mode
* is not supported by the particular backend. APR_EKEYTYPE if the key type is
* not known. APR_EPADDING if padding was requested but is not supported.
* APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_passphrase(apr_crypto_key_t **k, apr_size_t *ivSize,
const char *pass, apr_size_t passLen, const unsigned char * salt,
apr_size_t saltLen, const apr_crypto_block_key_type_e type,
const apr_crypto_block_key_mode_e mode, const int doPad,
const int iterations, const apr_crypto_t *f, apr_pool_t *p)
{
apr_status_t rv;
apr_crypto_key_t *key = *k;
if (!key) {
*k = key = apr_pcalloc(p, sizeof *key);
if (!key) {
return APR_ENOMEM;
}
}
key->f = f;
key->provider = f->provider;
/* decide on what cipher mechanism we will be using */
rv = crypto_cipher_mechanism(key, type, mode, doPad, p);
if (APR_SUCCESS != rv) {
return rv;
}
/* generate the key */
if ((f->result->rc = CCKeyDerivationPBKDF(kCCPBKDF2, pass, passLen, salt,
saltLen, kCCPRFHmacAlgSHA1, iterations, key->key, key->keyLen))
== kCCParamError) {
return APR_ENOKEY;
}
if (ivSize) {
*ivSize = key->ivSize;
}
return APR_SUCCESS;
}
/**
* @brief Initialise a context for encrypting arbitrary data using the given key.
* @note If *ctx is NULL, a apr_crypto_block_t will be created from a pool. If
* *ctx is not NULL, *ctx must point at a previously created structure.
* @param ctx The block context returned, see note.
* @param iv Optional initialisation vector. If the buffer pointed to is NULL,
* an IV will be created at random, in space allocated from the pool.
* If the buffer pointed to is not NULL, the IV in the buffer will be
* used.
* @param key The key structure.
* @param blockSize The block size of the cipher.
* @param p The pool to use.
* @return Returns APR_ENOIV if an initialisation vector is required but not specified.
* Returns APR_EINIT if the backend failed to initialise the context. Returns
* APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_block_encrypt_init(apr_crypto_block_t **ctx,
const unsigned char **iv, const apr_crypto_key_t *key,
apr_size_t *blockSize, apr_pool_t *p)
{
unsigned char *usedIv;
apr_crypto_block_t *block = *ctx;
if (!block) {
*ctx = block = apr_pcalloc(p, sizeof(apr_crypto_block_t));
}
if (!block) {
return APR_ENOMEM;
}
block->f = key->f;
block->pool = p;
block->provider = key->provider;
block->key = key;
apr_pool_cleanup_register(p, block, crypto_block_cleanup_helper,
apr_pool_cleanup_null);
/* generate an IV, if necessary */
usedIv = NULL;
if (key->ivSize) {
if (iv == NULL) {
return APR_ENOIV;
}
if (*iv == NULL) {
apr_status_t status;
usedIv = apr_pcalloc(p, key->ivSize);
if (!usedIv) {
return APR_ENOMEM;
}
apr_crypto_clear(p, usedIv, key->ivSize);
status = apr_random_secure_bytes(block->f->rng, usedIv,
key->ivSize);
if (APR_SUCCESS != status) {
return status;
}
*iv = usedIv;
}
else {
usedIv = (unsigned char *) *iv;
}
}
/* create a new context for encryption */
switch ((block->f->result->rc = CCCryptorCreate(kCCEncrypt, key->algorithm,
key->options, key->key, key->keyLen, usedIv, &block->ref))) {
case kCCSuccess: {
break;
}
case kCCParamError: {
return APR_EINIT;
}
case kCCMemoryFailure: {
return APR_ENOMEM;
}
case kCCAlignmentError: {
return APR_EPADDING;
}
case kCCUnimplemented: {
return APR_ENOTIMPL;
}
default: {
return APR_EINIT;
}
}
if (blockSize) {
*blockSize = key->blockSize;
}
return APR_SUCCESS;
}
/**
* @brief Encrypt data provided by in, write it to out.
* @note The number of bytes written will be written to outlen. If
* out is NULL, outlen will contain the maximum size of the
* buffer needed to hold the data, including any data
* generated by apr_crypto_block_encrypt_finish below. If *out points
* to NULL, a buffer sufficiently large will be created from
* the pool provided. If *out points to a not-NULL value, this
* value will be used as a buffer instead.
* @param out Address of a buffer to which data will be written,
* see note.
* @param outlen Length of the output will be written here.
* @param in Address of the buffer to read.
* @param inlen Length of the buffer to read.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
* not implemented.
*/
static apr_status_t crypto_block_encrypt(unsigned char **out,
apr_size_t *outlen, const unsigned char *in, apr_size_t inlen,
apr_crypto_block_t *ctx)
{
apr_size_t outl = *outlen;
unsigned char *buffer;
/* are we after the maximum size of the out buffer? */
if (!out) {
*outlen = CCCryptorGetOutputLength(ctx->ref, inlen, 1);
return APR_SUCCESS;
}
/* must we allocate the output buffer from a pool? */
if (!*out) {
outl = CCCryptorGetOutputLength(ctx->ref, inlen, 1);
buffer = apr_palloc(ctx->pool, outl);
if (!buffer) {
return APR_ENOMEM;
}
apr_crypto_clear(ctx->pool, buffer, outl);
*out = buffer;
}
switch ((ctx->f->result->rc = CCCryptorUpdate(ctx->ref, in, inlen, (*out),
outl, &outl))) {
case kCCSuccess: {
break;
}
case kCCBufferTooSmall: {
return APR_ENOSPACE;
}
default: {
return APR_ECRYPT;
}
}
*outlen = outl;
return APR_SUCCESS;
}
/**
* @brief Encrypt final data block, write it to out.
* @note If necessary the final block will be written out after being
* padded. Typically the final block will be written to the
* same buffer used by apr_crypto_block_encrypt, offset by the
* number of bytes returned as actually written by the
* apr_crypto_block_encrypt() call. After this call, the context
* is cleaned and can be reused by apr_crypto_block_encrypt_init().
* @param out Address of a buffer to which data will be written. This
* buffer must already exist, and is usually the same
* buffer used by apr_evp_crypt(). See note.
* @param outlen Length of the output will be written here.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred.
* @return APR_EPADDING if padding was enabled and the block was incorrectly
* formatted.
* @return APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_block_encrypt_finish(unsigned char *out,
apr_size_t *outlen, apr_crypto_block_t *ctx)
{
apr_size_t len = *outlen;
ctx->f->result->rc = CCCryptorFinal(ctx->ref, out,
CCCryptorGetOutputLength(ctx->ref, 0, 1), &len);
/* always clean up */
crypto_block_cleanup(ctx);
switch (ctx->f->result->rc) {
case kCCSuccess: {
break;
}
case kCCBufferTooSmall: {
return APR_ENOSPACE;
}
case kCCAlignmentError: {
return APR_EPADDING;
}
case kCCDecodeError: {
return APR_ECRYPT;
}
default: {
return APR_ECRYPT;
}
}
*outlen = len;
return APR_SUCCESS;
}
/**
* @brief Initialise a context for decrypting arbitrary data using the given key.
* @note If *ctx is NULL, a apr_crypto_block_t will be created from a pool. If
* *ctx is not NULL, *ctx must point at a previously created structure.
* @param ctx The block context returned, see note.
* @param blockSize The block size of the cipher.
* @param iv Optional initialisation vector. If the buffer pointed to is NULL,
* an IV will be created at random, in space allocated from the pool.
* If the buffer is not NULL, the IV in the buffer will be used.
* @param key The key structure.
* @param p The pool to use.
* @return Returns APR_ENOIV if an initialisation vector is required but not specified.
* Returns APR_EINIT if the backend failed to initialise the context. Returns
* APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_block_decrypt_init(apr_crypto_block_t **ctx,
apr_size_t *blockSize, const unsigned char *iv,
const apr_crypto_key_t *key, apr_pool_t *p)
{
apr_crypto_block_t *block = *ctx;
if (!block) {
*ctx = block = apr_pcalloc(p, sizeof(apr_crypto_block_t));
}
if (!block) {
return APR_ENOMEM;
}
block->f = key->f;
block->pool = p;
block->provider = key->provider;
apr_pool_cleanup_register(p, block, crypto_block_cleanup_helper,
apr_pool_cleanup_null);
/* generate an IV, if necessary */
if (key->ivSize) {
if (iv == NULL) {
return APR_ENOIV;
}
}
/* create a new context for decryption */
switch ((block->f->result->rc = CCCryptorCreate(kCCDecrypt, key->algorithm,
key->options, key->key, key->keyLen, iv, &block->ref))) {
case kCCSuccess: {
break;
}
case kCCParamError: {
return APR_EINIT;
}
case kCCMemoryFailure: {
return APR_ENOMEM;
}
case kCCAlignmentError: {
return APR_EPADDING;
}
case kCCUnimplemented: {
return APR_ENOTIMPL;
}
default: {
return APR_EINIT;
}
}
if (blockSize) {
*blockSize = key->blockSize;
}
return APR_SUCCESS;
}
/**
* @brief Decrypt data provided by in, write it to out.
* @note The number of bytes written will be written to outlen. If
* out is NULL, outlen will contain the maximum size of the
* buffer needed to hold the data, including any data
* generated by apr_crypto_block_decrypt_finish below. If *out points
* to NULL, a buffer sufficiently large will be created from
* the pool provided. If *out points to a not-NULL value, this
* value will be used as a buffer instead.
* @param out Address of a buffer to which data will be written,
* see note.
* @param outlen Length of the output will be written here.
* @param in Address of the buffer to read.
* @param inlen Length of the buffer to read.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
* not implemented.
*/
static apr_status_t crypto_block_decrypt(unsigned char **out,
apr_size_t *outlen, const unsigned char *in, apr_size_t inlen,
apr_crypto_block_t *ctx)
{
apr_size_t outl = *outlen;
unsigned char *buffer;
/* are we after the maximum size of the out buffer? */
if (!out) {
*outlen = CCCryptorGetOutputLength(ctx->ref, inlen, 1);
return APR_SUCCESS;
}
/* must we allocate the output buffer from a pool? */
if (!*out) {
outl = CCCryptorGetOutputLength(ctx->ref, inlen, 1);
buffer = apr_palloc(ctx->pool, outl);
if (!buffer) {
return APR_ENOMEM;
}
apr_crypto_clear(ctx->pool, buffer, outl);
*out = buffer;
}
switch ((ctx->f->result->rc = CCCryptorUpdate(ctx->ref, in, inlen, (*out),
outl, &outl))) {
case kCCSuccess: {
break;
}
case kCCBufferTooSmall: {
return APR_ENOSPACE;
}
default: {
return APR_ECRYPT;
}
}
*outlen = outl;
return APR_SUCCESS;
}
/**
* @brief Decrypt final data block, write it to out.
* @note If necessary the final block will be written out after being
* padded. Typically the final block will be written to the
* same buffer used by apr_crypto_block_decrypt, offset by the
* number of bytes returned as actually written by the
* apr_crypto_block_decrypt() call. After this call, the context
* is cleaned and can be reused by apr_crypto_block_decrypt_init().
* @param out Address of a buffer to which data will be written. This
* buffer must already exist, and is usually the same
* buffer used by apr_evp_crypt(). See note.
* @param outlen Length of the output will be written here.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred.
* @return APR_EPADDING if padding was enabled and the block was incorrectly
* formatted.
* @return APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_block_decrypt_finish(unsigned char *out,
apr_size_t *outlen, apr_crypto_block_t *ctx)
{
apr_size_t len = *outlen;
ctx->f->result->rc = CCCryptorFinal(ctx->ref, out,
CCCryptorGetOutputLength(ctx->ref, 0, 1), &len);
/* always clean up */
crypto_block_cleanup(ctx);
switch (ctx->f->result->rc) {
case kCCSuccess: {
break;
}
case kCCBufferTooSmall: {
return APR_ENOSPACE;
}
case kCCAlignmentError: {
return APR_EPADDING;
}
case kCCDecodeError: {
return APR_ECRYPT;
}
default: {
return APR_ECRYPT;
}
}
*outlen = len;
return APR_SUCCESS;
}
/**
* OSX Common Crypto module.
*/
APU_MODULE_DECLARE_DATA const apr_crypto_driver_t apr_crypto_commoncrypto_driver =
{
"commoncrypto", crypto_init, crypto_make, crypto_get_block_key_types,
crypto_get_block_key_modes, crypto_passphrase,
crypto_block_encrypt_init, crypto_block_encrypt,
crypto_block_encrypt_finish, crypto_block_decrypt_init,
crypto_block_decrypt, crypto_block_decrypt_finish, crypto_block_cleanup,
crypto_cleanup, crypto_shutdown, crypto_error, crypto_key
};
#endif

1097
contrib/apr-util/crypto/apr_crypto_nss.c
View File

File diff suppressed because it is too large Load Diff

973
contrib/apr-util/crypto/apr_crypto_openssl.c
View File

@ -1,973 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_lib.h"
#include "apu.h"
#include "apu_errno.h"
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
#include "apr_strings.h"
#include "apr_time.h"
#include "apr_buckets.h"
#include "apr_crypto_internal.h"
#if APU_HAVE_CRYPTO
#include <openssl/evp.h>
#include <openssl/rand.h>
#include <openssl/engine.h>
#define LOG_PREFIX "apr_crypto_openssl: "
#ifndef APR_USE_OPENSSL_PRE_1_1_API
#if defined(LIBRESSL_VERSION_NUMBER)
/* LibreSSL declares OPENSSL_VERSION_NUMBER == 2.0 but does not include most
* changes from OpenSSL >= 1.1 (new functions, macros, deprecations, ...), so
* we have to work around this...
*/
#define APR_USE_OPENSSL_PRE_1_1_API (1)
#else
#define APR_USE_OPENSSL_PRE_1_1_API (OPENSSL_VERSION_NUMBER < 0x10100000L)
#endif
#endif
struct apr_crypto_t {
apr_pool_t *pool;
const apr_crypto_driver_t *provider;
apu_err_t *result;
apr_crypto_config_t *config;
apr_hash_t *types;
apr_hash_t *modes;
};
struct apr_crypto_config_t {
ENGINE *engine;
};
struct apr_crypto_key_t {
apr_pool_t *pool;
const apr_crypto_driver_t *provider;
const apr_crypto_t *f;
const EVP_CIPHER * cipher;
unsigned char *key;
int keyLen;
int doPad;
int ivSize;
};
struct apr_crypto_block_t {
apr_pool_t *pool;
const apr_crypto_driver_t *provider;
const apr_crypto_t *f;
EVP_CIPHER_CTX *cipherCtx;
int initialised;
int ivSize;
int blockSize;
int doPad;
};
static struct apr_crypto_block_key_type_t key_types[] =
{
{ APR_KEY_3DES_192, 24, 8, 8 },
{ APR_KEY_AES_128, 16, 16, 16 },
{ APR_KEY_AES_192, 24, 16, 16 },
{ APR_KEY_AES_256, 32, 16, 16 } };
static struct apr_crypto_block_key_mode_t key_modes[] =
{
{ APR_MODE_ECB },
{ APR_MODE_CBC } };
/* sufficient space to wrap a key */
#define BUFFER_SIZE 128
/**
* Fetch the most recent error from this driver.
*/
static apr_status_t crypto_error(const apu_err_t **result,
const apr_crypto_t *f)
{
*result = f->result;
return APR_SUCCESS;
}
/**
* Shutdown the crypto library and release resources.
*/
static apr_status_t crypto_shutdown(void)
{
ERR_free_strings();
EVP_cleanup();
ENGINE_cleanup();
return APR_SUCCESS;
}
static apr_status_t crypto_shutdown_helper(void *data)
{
return crypto_shutdown();
}
/**
* Initialise the crypto library and perform one time initialisation.
*/
static apr_status_t crypto_init(apr_pool_t *pool, const char *params,
const apu_err_t **result)
{
#if APR_USE_OPENSSL_PRE_1_1_API
(void)CRYPTO_malloc_init();
#else
OPENSSL_malloc_init();
#endif
ERR_load_crypto_strings();
/* SSL_load_error_strings(); */
OpenSSL_add_all_algorithms();
ENGINE_load_builtin_engines();
ENGINE_register_all_complete();
apr_pool_cleanup_register(pool, pool, crypto_shutdown_helper,
apr_pool_cleanup_null);
return APR_SUCCESS;
}
#if OPENSSL_VERSION_NUMBER < 0x0090802fL
/* Code taken from OpenSSL 0.9.8b, see
* https://github.com/openssl/openssl/commit/cf6bc84148cb15af09b292394aaf2b45f0d5af0d
*/
EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void)
{
EVP_CIPHER_CTX *ctx = OPENSSL_malloc(sizeof *ctx);
if (ctx)
EVP_CIPHER_CTX_init(ctx);
return ctx;
}
void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
{
if (ctx) {
EVP_CIPHER_CTX_cleanup(ctx);
OPENSSL_free(ctx);
}
}
#endif
/**
* @brief Clean encryption / decryption context.
* @note After cleanup, a context is free to be reused if necessary.
* @param ctx The block context to use.
* @return Returns APR_ENOTIMPL if not supported.
*/
static apr_status_t crypto_block_cleanup(apr_crypto_block_t *ctx)
{
if (ctx->initialised) {
EVP_CIPHER_CTX_free(ctx->cipherCtx);
ctx->initialised = 0;
}
return APR_SUCCESS;
}
static apr_status_t crypto_block_cleanup_helper(void *data)
{
apr_crypto_block_t *block = (apr_crypto_block_t *) data;
return crypto_block_cleanup(block);
}
/**
* @brief Clean encryption / decryption context.
* @note After cleanup, a context is free to be reused if necessary.
* @param f The context to use.
* @return Returns APR_ENOTIMPL if not supported.
*/
static apr_status_t crypto_cleanup(apr_crypto_t *f)
{
if (f->config->engine) {
ENGINE_finish(f->config->engine);
ENGINE_free(f->config->engine);
f->config->engine = NULL;
}
return APR_SUCCESS;
}
static apr_status_t crypto_cleanup_helper(void *data)
{
apr_crypto_t *f = (apr_crypto_t *) data;
return crypto_cleanup(f);
}
/**
* @brief Create a context for supporting encryption. Keys, certificates,
* algorithms and other parameters will be set per context. More than
* one context can be created at one time. A cleanup will be automatically
* registered with the given pool to guarantee a graceful shutdown.
* @param f - context pointer will be written here
* @param provider - provider to use
* @param params - array of key parameters
* @param pool - process pool
* @return APR_ENOENGINE when the engine specified does not exist. APR_EINITENGINE
* if the engine cannot be initialised.
*/
static apr_status_t crypto_make(apr_crypto_t **ff,
const apr_crypto_driver_t *provider, const char *params,
apr_pool_t *pool)
{
apr_crypto_config_t *config = NULL;
apr_crypto_t *f = apr_pcalloc(pool, sizeof(apr_crypto_t));
const char *engine = NULL;
struct {
const char *field;
const char *value;
int set;
} fields[] = {
{ "engine", NULL, 0 },
{ NULL, NULL, 0 }
};
const char *ptr;
size_t klen;
char **elts = NULL;
char *elt;
int i = 0, j;
apr_status_t status;
if (params) {
if (APR_SUCCESS != (status = apr_tokenize_to_argv(params, &elts, pool))) {
return status;
}
while ((elt = elts[i])) {
ptr = strchr(elt, '=');
if (ptr) {
for (klen = ptr - elt; klen && apr_isspace(elt[klen - 1]); --klen)
;
ptr++;
}
else {
for (klen = strlen(elt); klen && apr_isspace(elt[klen - 1]); --klen)
;
}
elt[klen] = 0;
for (j = 0; fields[j].field != NULL; ++j) {
if (!strcasecmp(fields[j].field, elt)) {
fields[j].set = 1;
if (ptr) {
fields[j].value = ptr;
}
break;
}
}
i++;
}
engine = fields[0].value;
}
if (!f) {
return APR_ENOMEM;
}
*ff = f;
f->pool = pool;
f->provider = provider;
config = f->config = apr_pcalloc(pool, sizeof(apr_crypto_config_t));
if (!config) {
return APR_ENOMEM;
}
f->result = apr_pcalloc(pool, sizeof(apu_err_t));
if (!f->result) {
return APR_ENOMEM;
}
f->types = apr_hash_make(pool);
if (!f->types) {
return APR_ENOMEM;
}
apr_hash_set(f->types, "3des192", APR_HASH_KEY_STRING, &(key_types[0]));
apr_hash_set(f->types, "aes128", APR_HASH_KEY_STRING, &(key_types[1]));
apr_hash_set(f->types, "aes192", APR_HASH_KEY_STRING, &(key_types[2]));
apr_hash_set(f->types, "aes256", APR_HASH_KEY_STRING, &(key_types[3]));
f->modes = apr_hash_make(pool);
if (!f->modes) {
return APR_ENOMEM;
}
apr_hash_set(f->modes, "ecb", APR_HASH_KEY_STRING, &(key_modes[0]));
apr_hash_set(f->modes, "cbc", APR_HASH_KEY_STRING, &(key_modes[1]));
apr_pool_cleanup_register(pool, f, crypto_cleanup_helper,
apr_pool_cleanup_null);
if (engine) {
config->engine = ENGINE_by_id(engine);
if (!config->engine) {
return APR_ENOENGINE;
}
if (!ENGINE_init(config->engine)) {
ENGINE_free(config->engine);
config->engine = NULL;
return APR_EINITENGINE;
}
}
return APR_SUCCESS;
}
/**
* @brief Get a hash table of key types, keyed by the name of the type against
* a pointer to apr_crypto_block_key_type_t.
*
* @param types - hashtable of key types keyed to constants.
* @param f - encryption context
* @return APR_SUCCESS for success
*/
static apr_status_t crypto_get_block_key_types(apr_hash_t **types,
const apr_crypto_t *f)
{
*types = f->types;
return APR_SUCCESS;
}
/**
* @brief Get a hash table of key modes, keyed by the name of the mode against
* a pointer to apr_crypto_block_key_mode_t.
*
* @param modes - hashtable of key modes keyed to constants.
* @param f - encryption context
* @return APR_SUCCESS for success
*/
static apr_status_t crypto_get_block_key_modes(apr_hash_t **modes,
const apr_crypto_t *f)
{
*modes = f->modes;
return APR_SUCCESS;
}
/*
* Work out which mechanism to use.
*/
static apr_status_t crypto_cipher_mechanism(apr_crypto_key_t *key,
const apr_crypto_block_key_type_e type,
const apr_crypto_block_key_mode_e mode, const int doPad, apr_pool_t *p)
{
/* determine the cipher to be used */
switch (type) {
case (APR_KEY_3DES_192):
/* A 3DES key */
if (mode == APR_MODE_CBC) {
key->cipher = EVP_des_ede3_cbc();
}
else {
key->cipher = EVP_des_ede3_ecb();
}
break;
case (APR_KEY_AES_128):
if (mode == APR_MODE_CBC) {
key->cipher = EVP_aes_128_cbc();
}
else {
key->cipher = EVP_aes_128_ecb();
}
break;
case (APR_KEY_AES_192):
if (mode == APR_MODE_CBC) {
key->cipher = EVP_aes_192_cbc();
}
else {
key->cipher = EVP_aes_192_ecb();
}
break;
case (APR_KEY_AES_256):
if (mode == APR_MODE_CBC) {
key->cipher = EVP_aes_256_cbc();
}
else {
key->cipher = EVP_aes_256_ecb();
}
break;
default:
/* unknown key type, give up */
return APR_EKEYTYPE;
}
/* find the length of the key we need */
key->keyLen = EVP_CIPHER_key_length(key->cipher);
/* make space for the key */
key->key = apr_pcalloc(p, key->keyLen);
if (!key->key) {
return APR_ENOMEM;
}
apr_crypto_clear(p, key->key, key->keyLen);
return APR_SUCCESS;
}
/**
* @brief Create a key from the provided secret or passphrase. The key is cleaned
* up when the context is cleaned, and may be reused with multiple encryption
* or decryption operations.
* @note If *key is NULL, a apr_crypto_key_t will be created from a pool. If
* *key is not NULL, *key must point at a previously created structure.
* @param key The key returned, see note.
* @param rec The key record, from which the key will be derived.
* @param f The context to use.
* @param p The pool to use.
* @return Returns APR_ENOKEY if the pass phrase is missing or empty, or if a backend
* error occurred while generating the key. APR_ENOCIPHER if the type or mode
* is not supported by the particular backend. APR_EKEYTYPE if the key type is
* not known. APR_EPADDING if padding was requested but is not supported.
* APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_key(apr_crypto_key_t **k,
const apr_crypto_key_rec_t *rec, const apr_crypto_t *f, apr_pool_t *p)
{
apr_crypto_key_t *key = *k;
apr_status_t rv;
if (!key) {
*k = key = apr_pcalloc(p, sizeof *key);
if (!key) {
return APR_ENOMEM;
}
}
key->f = f;
key->provider = f->provider;
/* decide on what cipher mechanism we will be using */
rv = crypto_cipher_mechanism(key, rec->type, rec->mode, rec->pad, p);
if (APR_SUCCESS != rv) {
return rv;
}
switch (rec->ktype) {
case APR_CRYPTO_KTYPE_PASSPHRASE: {
/* generate the key */
if (PKCS5_PBKDF2_HMAC_SHA1(rec->k.passphrase.pass,
rec->k.passphrase.passLen,
(unsigned char *) rec->k.passphrase.salt,
rec->k.passphrase.saltLen, rec->k.passphrase.iterations,
key->keyLen, key->key) == 0) {
return APR_ENOKEY;
}
break;
}
case APR_CRYPTO_KTYPE_SECRET: {
/* sanity check - key correct size? */
if (rec->k.secret.secretLen != key->keyLen) {
return APR_EKEYLENGTH;
}
/* copy the key */
memcpy(key->key, rec->k.secret.secret, rec->k.secret.secretLen);
break;
}
default: {
return APR_ENOKEY;
}
}
key->doPad = rec->pad;
/* note: openssl incorrectly returns non zero IV size values for ECB
* algorithms, so work around this by ignoring the IV size.
*/
if (APR_MODE_ECB != rec->mode) {
key->ivSize = EVP_CIPHER_iv_length(key->cipher);
}
return APR_SUCCESS;
}
/**
* @brief Create a key from the given passphrase. By default, the PBKDF2
* algorithm is used to generate the key from the passphrase. It is expected
* that the same pass phrase will generate the same key, regardless of the
* backend crypto platform used. The key is cleaned up when the context
* is cleaned, and may be reused with multiple encryption or decryption
* operations.
* @note If *key is NULL, a apr_crypto_key_t will be created from a pool. If
* *key is not NULL, *key must point at a previously created structure.
* @param key The key returned, see note.
* @param ivSize The size of the initialisation vector will be returned, based
* on whether an IV is relevant for this type of crypto.
* @param pass The passphrase to use.
* @param passLen The passphrase length in bytes
* @param salt The salt to use.
* @param saltLen The salt length in bytes
* @param type 3DES_192, AES_128, AES_192, AES_256.
* @param mode Electronic Code Book / Cipher Block Chaining.
* @param doPad Pad if necessary.
* @param iterations Iteration count
* @param f The context to use.
* @param p The pool to use.
* @return Returns APR_ENOKEY if the pass phrase is missing or empty, or if a backend
* error occurred while generating the key. APR_ENOCIPHER if the type or mode
* is not supported by the particular backend. APR_EKEYTYPE if the key type is
* not known. APR_EPADDING if padding was requested but is not supported.
* APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_passphrase(apr_crypto_key_t **k, apr_size_t *ivSize,
const char *pass, apr_size_t passLen, const unsigned char * salt,
apr_size_t saltLen, const apr_crypto_block_key_type_e type,
const apr_crypto_block_key_mode_e mode, const int doPad,
const int iterations, const apr_crypto_t *f, apr_pool_t *p)
{
apr_crypto_key_t *key = *k;
apr_status_t rv;
if (!key) {
*k = key = apr_pcalloc(p, sizeof *key);
if (!key) {
return APR_ENOMEM;
}
}
key->f = f;
key->provider = f->provider;
/* decide on what cipher mechanism we will be using */
rv = crypto_cipher_mechanism(key, type, mode, doPad, p);
if (APR_SUCCESS != rv) {
return rv;
}
/* generate the key */
if (PKCS5_PBKDF2_HMAC_SHA1(pass, passLen, (unsigned char *) salt, saltLen,
iterations, key->keyLen, key->key) == 0) {
return APR_ENOKEY;
}
key->doPad = doPad;
/* note: openssl incorrectly returns non zero IV size values for ECB
* algorithms, so work around this by ignoring the IV size.
*/
if (APR_MODE_ECB != mode) {
key->ivSize = EVP_CIPHER_iv_length(key->cipher);
}
if (ivSize) {
*ivSize = key->ivSize;
}
return APR_SUCCESS;
}
/**
* @brief Initialise a context for encrypting arbitrary data using the given key.
* @note If *ctx is NULL, a apr_crypto_block_t will be created from a pool. If
* *ctx is not NULL, *ctx must point at a previously created structure.
* @param ctx The block context returned, see note.
* @param iv Optional initialisation vector. If the buffer pointed to is NULL,
* an IV will be created at random, in space allocated from the pool.
* If the buffer pointed to is not NULL, the IV in the buffer will be
* used.
* @param key The key structure.
* @param blockSize The block size of the cipher.
* @param p The pool to use.
* @return Returns APR_ENOIV if an initialisation vector is required but not specified.
* Returns APR_EINIT if the backend failed to initialise the context. Returns
* APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_block_encrypt_init(apr_crypto_block_t **ctx,
const unsigned char **iv, const apr_crypto_key_t *key,
apr_size_t *blockSize, apr_pool_t *p)
{
unsigned char *usedIv;
apr_crypto_config_t *config = key->f->config;
apr_crypto_block_t *block = *ctx;
if (!block) {
*ctx = block = apr_pcalloc(p, sizeof(apr_crypto_block_t));
}
if (!block) {
return APR_ENOMEM;
}
block->f = key->f;
block->pool = p;
block->provider = key->provider;
apr_pool_cleanup_register(p, block, crypto_block_cleanup_helper,
apr_pool_cleanup_null);
/* create a new context for encryption */
if (!block->initialised) {
block->cipherCtx = EVP_CIPHER_CTX_new();
block->initialised = 1;
}
/* generate an IV, if necessary */
usedIv = NULL;
if (key->ivSize) {
if (iv == NULL) {
return APR_ENOIV;
}
if (*iv == NULL) {
usedIv = apr_pcalloc(p, key->ivSize);
if (!usedIv) {
return APR_ENOMEM;
}
apr_crypto_clear(p, usedIv, key->ivSize);
if (!((RAND_status() == 1)
&& (RAND_bytes(usedIv, key->ivSize) == 1))) {
return APR_ENOIV;
}
*iv = usedIv;
}
else {
usedIv = (unsigned char *) *iv;
}
}
/* set up our encryption context */
#if CRYPTO_OPENSSL_CONST_BUFFERS
if (!EVP_EncryptInit_ex(block->cipherCtx, key->cipher, config->engine,
key->key, usedIv)) {
#else
if (!EVP_EncryptInit_ex(block->cipherCtx, key->cipher, config->engine, (unsigned char *) key->key, (unsigned char *) usedIv)) {
#endif
return APR_EINIT;
}
/* Clear up any read padding */
if (!EVP_CIPHER_CTX_set_padding(block->cipherCtx, key->doPad)) {
return APR_EPADDING;
}
if (blockSize) {
*blockSize = EVP_CIPHER_block_size(key->cipher);
}
return APR_SUCCESS;
}
/**
* @brief Encrypt data provided by in, write it to out.
* @note The number of bytes written will be written to outlen. If
* out is NULL, outlen will contain the maximum size of the
* buffer needed to hold the data, including any data
* generated by apr_crypto_block_encrypt_finish below. If *out points
* to NULL, a buffer sufficiently large will be created from
* the pool provided. If *out points to a not-NULL value, this
* value will be used as a buffer instead.
* @param out Address of a buffer to which data will be written,
* see note.
* @param outlen Length of the output will be written here.
* @param in Address of the buffer to read.
* @param inlen Length of the buffer to read.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
* not implemented.
*/
static apr_status_t crypto_block_encrypt(unsigned char **out,
apr_size_t *outlen, const unsigned char *in, apr_size_t inlen,
apr_crypto_block_t *ctx)
{
int outl = *outlen;
unsigned char *buffer;
/* are we after the maximum size of the out buffer? */
if (!out) {
*outlen = inlen + EVP_MAX_BLOCK_LENGTH;
return APR_SUCCESS;
}
/* must we allocate the output buffer from a pool? */
if (!*out) {
buffer = apr_palloc(ctx->pool, inlen + EVP_MAX_BLOCK_LENGTH);
if (!buffer) {
return APR_ENOMEM;
}
apr_crypto_clear(ctx->pool, buffer, inlen + EVP_MAX_BLOCK_LENGTH);
*out = buffer;
}
#if CRYPT_OPENSSL_CONST_BUFFERS
if (!EVP_EncryptUpdate(ctx->cipherCtx, (*out), &outl, in, inlen)) {
#else
if (!EVP_EncryptUpdate(ctx->cipherCtx, (*out), &outl,
(unsigned char *) in, inlen)) {
#endif
#if APR_USE_OPENSSL_PRE_1_1_API
EVP_CIPHER_CTX_cleanup(ctx->cipherCtx);
#else
EVP_CIPHER_CTX_reset(ctx->cipherCtx);
#endif
return APR_ECRYPT;
}
*outlen = outl;
return APR_SUCCESS;
}
/**
* @brief Encrypt final data block, write it to out.
* @note If necessary the final block will be written out after being
* padded. Typically the final block will be written to the
* same buffer used by apr_crypto_block_encrypt, offset by the
* number of bytes returned as actually written by the
* apr_crypto_block_encrypt() call. After this call, the context
* is cleaned and can be reused by apr_crypto_block_encrypt_init().
* @param out Address of a buffer to which data will be written. This
* buffer must already exist, and is usually the same
* buffer used by apr_evp_crypt(). See note.
* @param outlen Length of the output will be written here.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred.
* @return APR_EPADDING if padding was enabled and the block was incorrectly
* formatted.
* @return APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_block_encrypt_finish(unsigned char *out,
apr_size_t *outlen, apr_crypto_block_t *ctx)
{
apr_status_t rc = APR_SUCCESS;
int len = *outlen;
if (EVP_EncryptFinal_ex(ctx->cipherCtx, out, &len) == 0) {
rc = APR_EPADDING;
}
else {
*outlen = len;
}
#if APR_USE_OPENSSL_PRE_1_1_API
EVP_CIPHER_CTX_cleanup(ctx->cipherCtx);
#else
EVP_CIPHER_CTX_reset(ctx->cipherCtx);
#endif
return rc;
}
/**
* @brief Initialise a context for decrypting arbitrary data using the given key.
* @note If *ctx is NULL, a apr_crypto_block_t will be created from a pool. If
* *ctx is not NULL, *ctx must point at a previously created structure.
* @param ctx The block context returned, see note.
* @param blockSize The block size of the cipher.
* @param iv Optional initialisation vector. If the buffer pointed to is NULL,
* an IV will be created at random, in space allocated from the pool.
* If the buffer is not NULL, the IV in the buffer will be used.
* @param key The key structure.
* @param p The pool to use.
* @return Returns APR_ENOIV if an initialisation vector is required but not specified.
* Returns APR_EINIT if the backend failed to initialise the context. Returns
* APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_block_decrypt_init(apr_crypto_block_t **ctx,
apr_size_t *blockSize, const unsigned char *iv,
const apr_crypto_key_t *key, apr_pool_t *p)
{
apr_crypto_config_t *config = key->f->config;
apr_crypto_block_t *block = *ctx;
if (!block) {
*ctx = block = apr_pcalloc(p, sizeof(apr_crypto_block_t));
}
if (!block) {
return APR_ENOMEM;
}
block->f = key->f;
block->pool = p;
block->provider = key->provider;
apr_pool_cleanup_register(p, block, crypto_block_cleanup_helper,
apr_pool_cleanup_null);
/* create a new context for encryption */
if (!block->initialised) {
block->cipherCtx = EVP_CIPHER_CTX_new();
block->initialised = 1;
}
/* generate an IV, if necessary */
if (key->ivSize) {
if (iv == NULL) {
return APR_ENOIV;
}
}
/* set up our encryption context */
#if CRYPTO_OPENSSL_CONST_BUFFERS
if (!EVP_DecryptInit_ex(block->cipherCtx, key->cipher, config->engine,
key->key, iv)) {
#else
if (!EVP_DecryptInit_ex(block->cipherCtx, key->cipher, config->engine, (unsigned char *) key->key, (unsigned char *) iv)) {
#endif
return APR_EINIT;
}
/* Clear up any read padding */
if (!EVP_CIPHER_CTX_set_padding(block->cipherCtx, key->doPad)) {
return APR_EPADDING;
}
if (blockSize) {
*blockSize = EVP_CIPHER_block_size(key->cipher);
}
return APR_SUCCESS;
}
/**
* @brief Decrypt data provided by in, write it to out.
* @note The number of bytes written will be written to outlen. If
* out is NULL, outlen will contain the maximum size of the
* buffer needed to hold the data, including any data
* generated by apr_crypto_block_decrypt_finish below. If *out points
* to NULL, a buffer sufficiently large will be created from
* the pool provided. If *out points to a not-NULL value, this
* value will be used as a buffer instead.
* @param out Address of a buffer to which data will be written,
* see note.
* @param outlen Length of the output will be written here.
* @param in Address of the buffer to read.
* @param inlen Length of the buffer to read.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
* not implemented.
*/
static apr_status_t crypto_block_decrypt(unsigned char **out,
apr_size_t *outlen, const unsigned char *in, apr_size_t inlen,
apr_crypto_block_t *ctx)
{
int outl = *outlen;
unsigned char *buffer;
/* are we after the maximum size of the out buffer? */
if (!out) {
*outlen = inlen + EVP_MAX_BLOCK_LENGTH;
return APR_SUCCESS;
}
/* must we allocate the output buffer from a pool? */
if (!(*out)) {
buffer = apr_palloc(ctx->pool, inlen + EVP_MAX_BLOCK_LENGTH);
if (!buffer) {
return APR_ENOMEM;
}
apr_crypto_clear(ctx->pool, buffer, inlen + EVP_MAX_BLOCK_LENGTH);
*out = buffer;
}
#if CRYPT_OPENSSL_CONST_BUFFERS
if (!EVP_DecryptUpdate(ctx->cipherCtx, *out, &outl, in, inlen)) {
#else
if (!EVP_DecryptUpdate(ctx->cipherCtx, *out, &outl, (unsigned char *) in,
inlen)) {
#endif
#if APR_USE_OPENSSL_PRE_1_1_API
EVP_CIPHER_CTX_cleanup(ctx->cipherCtx);
#else
EVP_CIPHER_CTX_reset(ctx->cipherCtx);
#endif
return APR_ECRYPT;
}
*outlen = outl;
return APR_SUCCESS;
}
/**
* @brief Decrypt final data block, write it to out.
* @note If necessary the final block will be written out after being
* padded. Typically the final block will be written to the
* same buffer used by apr_crypto_block_decrypt, offset by the
* number of bytes returned as actually written by the
* apr_crypto_block_decrypt() call. After this call, the context
* is cleaned and can be reused by apr_crypto_block_decrypt_init().
* @param out Address of a buffer to which data will be written. This
* buffer must already exist, and is usually the same
* buffer used by apr_evp_crypt(). See note.
* @param outlen Length of the output will be written here.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred.
* @return APR_EPADDING if padding was enabled and the block was incorrectly
* formatted.
* @return APR_ENOTIMPL if not implemented.
*/
static apr_status_t crypto_block_decrypt_finish(unsigned char *out,
apr_size_t *outlen, apr_crypto_block_t *ctx)
{
apr_status_t rc = APR_SUCCESS;
int len = *outlen;
if (EVP_DecryptFinal_ex(ctx->cipherCtx, out, &len) == 0) {
rc = APR_EPADDING;
}
else {
*outlen = len;
}
#if APR_USE_OPENSSL_PRE_1_1_API
EVP_CIPHER_CTX_cleanup(ctx->cipherCtx);
#else
EVP_CIPHER_CTX_reset(ctx->cipherCtx);
#endif
return rc;
}
/**
* OpenSSL module.
*/
APU_MODULE_DECLARE_DATA const apr_crypto_driver_t apr_crypto_openssl_driver = {
"openssl", crypto_init, crypto_make, crypto_get_block_key_types,
crypto_get_block_key_modes, crypto_passphrase,
crypto_block_encrypt_init, crypto_block_encrypt,
crypto_block_encrypt_finish, crypto_block_decrypt_init,
crypto_block_decrypt, crypto_block_decrypt_finish,
crypto_block_cleanup, crypto_cleanup, crypto_shutdown, crypto_error,
crypto_key
};
#endif

404
contrib/apr-util/crypto/apr_md4.c
View File

@ -1,404 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This is derived from material copyright RSA Data Security, Inc.
* Their notice is reproduced below in its entirety.
*
* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
* rights reserved.
*
* License to copy and use this software is granted provided that it
* is identified as the "RSA Data Security, Inc. MD4 Message-Digest
* Algorithm" in all material mentioning or referencing this software
* or this function.
*
* License is also granted to make and use derivative works provided
* that such works are identified as "derived from the RSA Data
* Security, Inc. MD4 Message-Digest Algorithm" in all material
* mentioning or referencing the derived work.
*
* RSA Data Security, Inc. makes no representations concerning either
* the merchantability of this software or the suitability of this
* software for any particular purpose. It is provided "as is"
* without express or implied warranty of any kind.
*
* These notices must be retained in any copies of any part of this
* documentation and/or software.
*/
#include "apr_strings.h"
#include "apr_md4.h"
#include "apr_lib.h"
#if APR_HAVE_STRING_H
#include <string.h>
#endif
#if APR_HAVE_UNISTD_H
#include <unistd.h>
#endif
/* Constants for MD4Transform routine.
*/
#define S11 3
#define S12 7
#define S13 11
#define S14 19
#define S21 3
#define S22 5
#define S23 9
#define S24 13
#define S31 3
#define S32 9
#define S33 11
#define S34 15
static void MD4Transform(apr_uint32_t state[4], const unsigned char block[64]);
static void Encode(unsigned char *output, const apr_uint32_t *input,
unsigned int len);
static void Decode(apr_uint32_t *output, const unsigned char *input,
unsigned int len);
static unsigned char PADDING[64] =
{
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
#if APR_CHARSET_EBCDIC
static apr_xlate_t *xlate_ebcdic_to_ascii; /* used in apr_md4_encode() */
#endif
/* F, G and I are basic MD4 functions.
*/
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
/* ROTATE_LEFT rotates x left n bits.
*/
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
/* FF, GG and HH are transformations for rounds 1, 2 and 3 */
/* Rotation is separate from addition to prevent recomputation */
#define FF(a, b, c, d, x, s) { \
(a) += F ((b), (c), (d)) + (x); \
(a) = ROTATE_LEFT ((a), (s)); \
}
#define GG(a, b, c, d, x, s) { \
(a) += G ((b), (c), (d)) + (x) + (apr_uint32_t)0x5a827999; \
(a) = ROTATE_LEFT ((a), (s)); \
}
#define HH(a, b, c, d, x, s) { \
(a) += H ((b), (c), (d)) + (x) + (apr_uint32_t)0x6ed9eba1; \
(a) = ROTATE_LEFT ((a), (s)); \
}
/* MD4 initialization. Begins an MD4 operation, writing a new context.
*/
APU_DECLARE(apr_status_t) apr_md4_init(apr_md4_ctx_t *context)
{
context->count[0] = context->count[1] = 0;
/* Load magic initialization constants. */
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
#if APR_HAS_XLATE
context->xlate = NULL;
#endif
return APR_SUCCESS;
}
#if APR_HAS_XLATE
/* MD4 translation setup. Provides the APR translation handle
* to be used for translating the content before calculating the
* digest.
*/
APU_DECLARE(apr_status_t) apr_md4_set_xlate(apr_md4_ctx_t *context,
apr_xlate_t *xlate)
{
apr_status_t rv;
int is_sb;
/* TODO: remove the single-byte-only restriction from this code
*/
rv = apr_xlate_sb_get(xlate, &is_sb);
if (rv != APR_SUCCESS) {
return rv;
}
if (!is_sb) {
return APR_EINVAL;
}
context->xlate = xlate;
return APR_SUCCESS;
}
#endif /* APR_HAS_XLATE */
/* MD4 block update operation. Continues an MD4 message-digest
* operation, processing another message block, and updating the
* context.
*/
APU_DECLARE(apr_status_t) apr_md4_update(apr_md4_ctx_t *context,
const unsigned char *input,
apr_size_t inputLen)
{
unsigned int i, idx, partLen;
#if APR_HAS_XLATE
apr_size_t inbytes_left, outbytes_left;
#endif
/* Compute number of bytes mod 64 */
idx = (unsigned int)((context->count[0] >> 3) & 0x3F);
/* Update number of bits */
if ((context->count[0] += ((apr_uint32_t)inputLen << 3))
< ((apr_uint32_t)inputLen << 3))
context->count[1]++;
context->count[1] += (apr_uint32_t)inputLen >> 29;
partLen = 64 - idx;
/* Transform as many times as possible. */
#if !APR_HAS_XLATE
if (inputLen >= partLen) {
memcpy(&context->buffer[idx], input, partLen);
MD4Transform(context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD4Transform(context->state, &input[i]);
idx = 0;
}
else
i = 0;
/* Buffer remaining input */
memcpy(&context->buffer[idx], &input[i], inputLen - i);
#else /*APR_HAS_XLATE*/
if (inputLen >= partLen) {
if (context->xlate) {
inbytes_left = outbytes_left = partLen;
apr_xlate_conv_buffer(context->xlate, (const char *)input,
&inbytes_left,
(char *)&context->buffer[idx],
&outbytes_left);
}
else {
memcpy(&context->buffer[idx], input, partLen);
}
MD4Transform(context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64) {
if (context->xlate) {
unsigned char inp_tmp[64];
inbytes_left = outbytes_left = 64;
apr_xlate_conv_buffer(context->xlate, (const char *)&input[i],
&inbytes_left,
(char *)inp_tmp, &outbytes_left);
MD4Transform(context->state, inp_tmp);
}
else {
MD4Transform(context->state, &input[i]);
}
}
idx = 0;
}
else
i = 0;
/* Buffer remaining input */
if (context->xlate) {
inbytes_left = outbytes_left = inputLen - i;
apr_xlate_conv_buffer(context->xlate, (const char *)&input[i],
&inbytes_left, (char *)&context->buffer[idx],
&outbytes_left);
}
else {
memcpy(&context->buffer[idx], &input[i], inputLen - i);
}
#endif /*APR_HAS_XLATE*/
return APR_SUCCESS;
}
/* MD4 finalization. Ends an MD4 message-digest operation, writing the
* the message digest and zeroizing the context.
*/
APU_DECLARE(apr_status_t) apr_md4_final(
unsigned char digest[APR_MD4_DIGESTSIZE],
apr_md4_ctx_t *context)
{
unsigned char bits[8];
unsigned int idx, padLen;
/* Save number of bits */
Encode(bits, context->count, 8);
#if APR_HAS_XLATE
/* apr_md4_update() should not translate for this final round. */
context->xlate = NULL;
#endif /*APR_HAS_XLATE*/
/* Pad out to 56 mod 64. */
idx = (unsigned int) ((context->count[0] >> 3) & 0x3f);
padLen = (idx < 56) ? (56 - idx) : (120 - idx);
apr_md4_update(context, PADDING, padLen);
/* Append length (before padding) */
apr_md4_update(context, bits, 8);
/* Store state in digest */
Encode(digest, context->state, APR_MD4_DIGESTSIZE);
/* Zeroize sensitive information. */
memset(context, 0, sizeof(*context));
return APR_SUCCESS;
}
/* MD4 computation in one step (init, update, final)
*/
APU_DECLARE(apr_status_t) apr_md4(unsigned char digest[APR_MD4_DIGESTSIZE],
const unsigned char *input,
apr_size_t inputLen)
{
apr_md4_ctx_t ctx;
apr_status_t rv;
apr_md4_init(&ctx);
if ((rv = apr_md4_update(&ctx, input, inputLen)) != APR_SUCCESS)
return rv;
return apr_md4_final(digest, &ctx);
}
/* MD4 basic transformation. Transforms state based on block. */
static void MD4Transform(apr_uint32_t state[4], const unsigned char block[64])
{
apr_uint32_t a = state[0], b = state[1], c = state[2], d = state[3],
x[APR_MD4_DIGESTSIZE];
Decode(x, block, 64);
/* Round 1 */
FF (a, b, c, d, x[ 0], S11); /* 1 */
FF (d, a, b, c, x[ 1], S12); /* 2 */
FF (c, d, a, b, x[ 2], S13); /* 3 */
FF (b, c, d, a, x[ 3], S14); /* 4 */
FF (a, b, c, d, x[ 4], S11); /* 5 */
FF (d, a, b, c, x[ 5], S12); /* 6 */
FF (c, d, a, b, x[ 6], S13); /* 7 */
FF (b, c, d, a, x[ 7], S14); /* 8 */
FF (a, b, c, d, x[ 8], S11); /* 9 */
FF (d, a, b, c, x[ 9], S12); /* 10 */
FF (c, d, a, b, x[10], S13); /* 11 */
FF (b, c, d, a, x[11], S14); /* 12 */
FF (a, b, c, d, x[12], S11); /* 13 */
FF (d, a, b, c, x[13], S12); /* 14 */
FF (c, d, a, b, x[14], S13); /* 15 */
FF (b, c, d, a, x[15], S14); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[ 0], S21); /* 17 */
GG (d, a, b, c, x[ 4], S22); /* 18 */
GG (c, d, a, b, x[ 8], S23); /* 19 */
GG (b, c, d, a, x[12], S24); /* 20 */
GG (a, b, c, d, x[ 1], S21); /* 21 */
GG (d, a, b, c, x[ 5], S22); /* 22 */
GG (c, d, a, b, x[ 9], S23); /* 23 */
GG (b, c, d, a, x[13], S24); /* 24 */
GG (a, b, c, d, x[ 2], S21); /* 25 */
GG (d, a, b, c, x[ 6], S22); /* 26 */
GG (c, d, a, b, x[10], S23); /* 27 */
GG (b, c, d, a, x[14], S24); /* 28 */
GG (a, b, c, d, x[ 3], S21); /* 29 */
GG (d, a, b, c, x[ 7], S22); /* 30 */
GG (c, d, a, b, x[11], S23); /* 31 */
GG (b, c, d, a, x[15], S24); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[ 0], S31); /* 33 */
HH (d, a, b, c, x[ 8], S32); /* 34 */
HH (c, d, a, b, x[ 4], S33); /* 35 */
HH (b, c, d, a, x[12], S34); /* 36 */
HH (a, b, c, d, x[ 2], S31); /* 37 */
HH (d, a, b, c, x[10], S32); /* 38 */
HH (c, d, a, b, x[ 6], S33); /* 39 */
HH (b, c, d, a, x[14], S34); /* 40 */
HH (a, b, c, d, x[ 1], S31); /* 41 */
HH (d, a, b, c, x[ 9], S32); /* 42 */
HH (c, d, a, b, x[ 5], S33); /* 43 */
HH (b, c, d, a, x[13], S34); /* 44 */
HH (a, b, c, d, x[ 3], S31); /* 45 */
HH (d, a, b, c, x[11], S32); /* 46 */
HH (c, d, a, b, x[ 7], S33); /* 47 */
HH (b, c, d, a, x[15], S34); /* 48 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
/* Zeroize sensitive information. */
memset(x, 0, sizeof(x));
}
/* Encodes input (apr_uint32_t) into output (unsigned char). Assumes len is
* a multiple of 4.
*/
static void Encode(unsigned char *output, const apr_uint32_t *input,
unsigned int len)
{
unsigned int i, j;
apr_uint32_t k;
for (i = 0, j = 0; j < len; i++, j += 4) {
k = input[i];
output[j] = (unsigned char)(k & 0xff);
output[j + 1] = (unsigned char)((k >> 8) & 0xff);
output[j + 2] = (unsigned char)((k >> 16) & 0xff);
output[j + 3] = (unsigned char)((k >> 24) & 0xff);
}
}
/* Decodes input (unsigned char) into output (apr_uint32_t). Assumes len is
* a multiple of 4.
*/
static void Decode(apr_uint32_t *output, const unsigned char *input,
unsigned int len)
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((apr_uint32_t)input[j]) |
(((apr_uint32_t)input[j + 1]) << 8) |
(((apr_uint32_t)input[j + 2]) << 16) |
(((apr_uint32_t)input[j + 3]) << 24);
}
#if APR_CHARSET_EBCDIC
APU_DECLARE(apr_status_t) apr_MD4InitEBCDIC(apr_xlate_t *xlate)
{
xlate_ebcdic_to_ascii = xlate;
return APR_SUCCESS;
}
#endif

666
contrib/apr-util/crypto/apr_md5.c
View File

@ -1,666 +0,0 @@
/*
* This is work is derived from material Copyright RSA Data Security, Inc.
*
* The RSA copyright statement and Licence for that original material is
* included below. This is followed by the Apache copyright statement and
* licence for the modifications made to that material.
*/
/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
*/
/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* The apr_md5_encode() routine uses much code obtained from the FreeBSD 3.0
* MD5 crypt() function, which is licenced as follows:
* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <phk@login.dknet.dk> wrote this file. As long as you retain this notice you
* can do whatever you want with this stuff. If we meet some day, and you think
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
* ----------------------------------------------------------------------------
*/
#include "apr_strings.h"
#include "apr_md5.h"
#include "apr_lib.h"
#include "apu_config.h"
#if APR_HAVE_STRING_H
#include <string.h>
#endif
/* Constants for MD5Transform routine.
*/
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static void MD5Transform(apr_uint32_t state[4], const unsigned char block[64]);
static void Encode(unsigned char *output, const apr_uint32_t *input,
unsigned int len);
static void Decode(apr_uint32_t *output, const unsigned char *input,
unsigned int len);
static const unsigned char PADDING[64] =
{
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
#if APR_CHARSET_EBCDIC
static apr_xlate_t *xlate_ebcdic_to_ascii; /* used in apr_md5_encode() */
#endif
#define DO_XLATE 0
#define SKIP_XLATE 1
/* F, G, H and I are basic MD5 functions.
*/
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
/* ROTATE_LEFT rotates x left n bits.
*/
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
* Rotation is separate from addition to prevent recomputation.
*/
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
/* MD5 initialization. Begins an MD5 operation, writing a new context.
*/
APU_DECLARE(apr_status_t) apr_md5_init(apr_md5_ctx_t *context)
{
context->count[0] = context->count[1] = 0;
/* Load magic initialization constants. */
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
context->xlate = NULL;
return APR_SUCCESS;
}
/* MD5 translation setup. Provides the APR translation handle
* to be used for translating the content before calculating the
* digest.
*/
APU_DECLARE(apr_status_t) apr_md5_set_xlate(apr_md5_ctx_t *context,
apr_xlate_t *xlate)
{
#if APR_HAS_XLATE
apr_status_t rv;
int is_sb;
/* TODO: remove the single-byte-only restriction from this code
*/
rv = apr_xlate_sb_get(xlate, &is_sb);
if (rv != APR_SUCCESS) {
return rv;
}
if (!is_sb) {
return APR_EINVAL;
}
context->xlate = xlate;
return APR_SUCCESS;
#else
return APR_ENOTIMPL;
#endif /* APR_HAS_XLATE */
}
/* MD5 block update operation. Continues an MD5 message-digest
* operation, processing another message block, and updating the
* context.
*/
static apr_status_t md5_update_buffer(apr_md5_ctx_t *context,
const void *vinput,
apr_size_t inputLen,
int xlate_buffer)
{
const unsigned char *input = vinput;
unsigned int i, idx, partLen;
#if APR_HAS_XLATE
apr_size_t inbytes_left, outbytes_left;
#endif
/* Compute number of bytes mod 64 */
idx = (unsigned int)((context->count[0] >> 3) & 0x3F);
/* Update number of bits */
if ((context->count[0] += ((apr_uint32_t)inputLen << 3))
< ((apr_uint32_t)inputLen << 3))
context->count[1]++;
context->count[1] += (apr_uint32_t)inputLen >> 29;
partLen = 64 - idx;
/* Transform as many times as possible. */
#if !APR_HAS_XLATE
if (inputLen >= partLen) {
memcpy(&context->buffer[idx], input, partLen);
MD5Transform(context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform(context->state, &input[i]);
idx = 0;
}
else
i = 0;
/* Buffer remaining input */
memcpy(&context->buffer[idx], &input[i], inputLen - i);
#else /*APR_HAS_XLATE*/
if (inputLen >= partLen) {
if (context->xlate && (xlate_buffer == DO_XLATE)) {
inbytes_left = outbytes_left = partLen;
apr_xlate_conv_buffer(context->xlate, (const char *)input,
&inbytes_left,
(char *)&context->buffer[idx],
&outbytes_left);
}
else {
memcpy(&context->buffer[idx], input, partLen);
}
MD5Transform(context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64) {
if (context->xlate && (xlate_buffer == DO_XLATE)) {
unsigned char inp_tmp[64];
inbytes_left = outbytes_left = 64;
apr_xlate_conv_buffer(context->xlate, (const char *)&input[i],
&inbytes_left, (char *)inp_tmp,
&outbytes_left);
MD5Transform(context->state, inp_tmp);
}
else {
MD5Transform(context->state, &input[i]);
}
}
idx = 0;
}
else
i = 0;
/* Buffer remaining input */
if (context->xlate && (xlate_buffer == DO_XLATE)) {
inbytes_left = outbytes_left = inputLen - i;
apr_xlate_conv_buffer(context->xlate, (const char *)&input[i],
&inbytes_left, (char *)&context->buffer[idx],
&outbytes_left);
}
else {
memcpy(&context->buffer[idx], &input[i], inputLen - i);
}
#endif /*APR_HAS_XLATE*/
return APR_SUCCESS;
}
/* MD5 block update operation. API with the default setting
* for EBCDIC translations
*/
APU_DECLARE(apr_status_t) apr_md5_update(apr_md5_ctx_t *context,
const void *input,
apr_size_t inputLen)
{
return md5_update_buffer(context, input, inputLen, DO_XLATE);
}
/* MD5 finalization. Ends an MD5 message-digest operation, writing the
* the message digest and zeroizing the context.
*/
APU_DECLARE(apr_status_t) apr_md5_final(unsigned char digest[APR_MD5_DIGESTSIZE],
apr_md5_ctx_t *context)
{
unsigned char bits[8];
unsigned int idx, padLen;
/* Save number of bits */
Encode(bits, context->count, 8);
#if APR_HAS_XLATE
/* apr_md5_update() should not translate for this final round. */
context->xlate = NULL;
#endif /*APR_HAS_XLATE*/
/* Pad out to 56 mod 64. */
idx = (unsigned int)((context->count[0] >> 3) & 0x3f);
padLen = (idx < 56) ? (56 - idx) : (120 - idx);
apr_md5_update(context, PADDING, padLen);
/* Append length (before padding) */
apr_md5_update(context, bits, 8);
/* Store state in digest */
Encode(digest, context->state, APR_MD5_DIGESTSIZE);
/* Zeroize sensitive information. */
memset(context, 0, sizeof(*context));
return APR_SUCCESS;
}
/* MD5 in one step (init, update, final)
*/
APU_DECLARE(apr_status_t) apr_md5(unsigned char digest[APR_MD5_DIGESTSIZE],
const void *_input,
apr_size_t inputLen)
{
const unsigned char *input = _input;
apr_md5_ctx_t ctx;
apr_status_t rv;
apr_md5_init(&ctx);
if ((rv = apr_md5_update(&ctx, input, inputLen)) != APR_SUCCESS)
return rv;
return apr_md5_final(digest, &ctx);
}
/* MD5 basic transformation. Transforms state based on block. */
static void MD5Transform(apr_uint32_t state[4], const unsigned char block[64])
{
apr_uint32_t a = state[0], b = state[1], c = state[2], d = state[3],
tmpbuf[APR_MD5_DIGESTSIZE];
const apr_uint32_t *x;
#if !APR_IS_BIGENDIAN
if ((apr_uintptr_t)block % sizeof(apr_uint32_t) == 0) {
x = (apr_uint32_t *)block;
} else
#endif
{
Decode(tmpbuf, block, 64);
x = tmpbuf;
}
/* Round 1 */
FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */
FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
/* Round 2 */
GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */
HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */
/* Round 4 */
II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
#if !APR_IS_BIGENDIAN
if (x == tmpbuf)
#endif
{
/* Zeroize sensitive information. */
memset(tmpbuf, 0, sizeof(tmpbuf));
}
}
/* Encodes input (apr_uint32_t) into output (unsigned char). Assumes len is
* a multiple of 4.
*/
static void Encode(unsigned char *output, const apr_uint32_t *input,
unsigned int len)
{
unsigned int i, j;
apr_uint32_t k;
for (i = 0, j = 0; j < len; i++, j += 4) {
k = input[i];
output[j] = (unsigned char)(k & 0xff);
output[j + 1] = (unsigned char)((k >> 8) & 0xff);
output[j + 2] = (unsigned char)((k >> 16) & 0xff);
output[j + 3] = (unsigned char)((k >> 24) & 0xff);
}
}
/* Decodes input (unsigned char) into output (apr_uint32_t). Assumes len is
* a multiple of 4.
*/
static void Decode(apr_uint32_t *output, const unsigned char *input,
unsigned int len)
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((apr_uint32_t)input[j]) |
(((apr_uint32_t)input[j + 1]) << 8) |
(((apr_uint32_t)input[j + 2]) << 16) |
(((apr_uint32_t)input[j + 3]) << 24);
}
#if APR_CHARSET_EBCDIC
APU_DECLARE(apr_status_t) apr_MD5InitEBCDIC(apr_xlate_t *xlate)
{
xlate_ebcdic_to_ascii = xlate;
return APR_SUCCESS;
}
#endif
/*
* Define the Magic String prefix that identifies a password as being
* hashed using our algorithm.
*/
static const char * const apr1_id = "$apr1$";
/*
* The following MD5 password encryption code was largely borrowed from
* the FreeBSD 3.0 /usr/src/lib/libcrypt/crypt.c file, which is
* licenced as stated at the top of this file.
*/
static void to64(char *s, unsigned long v, int n)
{
static unsigned char itoa64[] = /* 0 ... 63 => ASCII - 64 */
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
while (--n >= 0) {
*s++ = itoa64[v&0x3f];
v >>= 6;
}
}
APU_DECLARE(apr_status_t) apr_md5_encode(const char *pw, const char *salt,
char *result, apr_size_t nbytes)
{
/*
* Minimum size is 8 bytes for salt, plus 1 for the trailing NUL,
* plus 4 for the '$' separators, plus the password hash itself.
* Let's leave a goodly amount of leeway.
*/
char passwd[120], *p;
const char *sp, *ep;
unsigned char final[APR_MD5_DIGESTSIZE];
apr_ssize_t sl, pl, i;
apr_md5_ctx_t ctx, ctx1;
unsigned long l;
/*
* Refine the salt first. It's possible we were given an already-hashed
* string as the salt argument, so extract the actual salt value from it
* if so. Otherwise just use the string up to the first '$' as the salt.
*/
sp = salt;
/*
* If it starts with the magic string, then skip that.
*/
if (!strncmp(sp, apr1_id, strlen(apr1_id))) {
sp += strlen(apr1_id);
}
/*
* It stops at the first '$' or 8 chars, whichever comes first
*/
for (ep = sp; (*ep != '\0') && (*ep != '$') && (ep < (sp + 8)); ep++) {
continue;
}
/*
* Get the length of the true salt
*/
sl = ep - sp;
/*
* 'Time to make the doughnuts..'
*/
apr_md5_init(&ctx);
#if APR_CHARSET_EBCDIC
apr_md5_set_xlate(&ctx, xlate_ebcdic_to_ascii);
#endif
/*
* The password first, since that is what is most unknown
*/
apr_md5_update(&ctx, pw, strlen(pw));
/*
* Then our magic string
*/
apr_md5_update(&ctx, apr1_id, strlen(apr1_id));
/*
* Then the raw salt
*/
apr_md5_update(&ctx, sp, sl);
/*
* Then just as many characters of the MD5(pw, salt, pw)
*/
apr_md5_init(&ctx1);
#if APR_CHARSET_EBCDIC
apr_md5_set_xlate(&ctx1, xlate_ebcdic_to_ascii);
#endif
apr_md5_update(&ctx1, pw, strlen(pw));
apr_md5_update(&ctx1, sp, sl);
apr_md5_update(&ctx1, pw, strlen(pw));
apr_md5_final(final, &ctx1);
for (pl = strlen(pw); pl > 0; pl -= APR_MD5_DIGESTSIZE) {
md5_update_buffer(&ctx, final,
(pl > APR_MD5_DIGESTSIZE) ? APR_MD5_DIGESTSIZE : pl, SKIP_XLATE);
}
/*
* Don't leave anything around in vm they could use.
*/
memset(final, 0, sizeof(final));
/*
* Then something really weird...
*/
for (i = strlen(pw); i != 0; i >>= 1) {
if (i & 1) {
md5_update_buffer(&ctx, final, 1, SKIP_XLATE);
}
else {
apr_md5_update(&ctx, pw, 1);
}
}
/*
* Now make the output string. We know our limitations, so we
* can use the string routines without bounds checking.
*/
strcpy(passwd, apr1_id);
strncat(passwd, sp, sl);
strcat(passwd, "$");
apr_md5_final(final, &ctx);
/*
* And now, just to make sure things don't run too fast..
* On a 60 Mhz Pentium this takes 34 msec, so you would
* need 30 seconds to build a 1000 entry dictionary...
*/
for (i = 0; i < 1000; i++) {
apr_md5_init(&ctx1);
/*
* apr_md5_final clears out ctx1.xlate at the end of each loop,
* so need to to set it each time through
*/
#if APR_CHARSET_EBCDIC
apr_md5_set_xlate(&ctx1, xlate_ebcdic_to_ascii);
#endif
if (i & 1) {
apr_md5_update(&ctx1, pw, strlen(pw));
}
else {
md5_update_buffer(&ctx1, final, APR_MD5_DIGESTSIZE, SKIP_XLATE);
}
if (i % 3) {
apr_md5_update(&ctx1, sp, sl);
}
if (i % 7) {
apr_md5_update(&ctx1, pw, strlen(pw));
}
if (i & 1) {
md5_update_buffer(&ctx1, final, APR_MD5_DIGESTSIZE, SKIP_XLATE);
}
else {
apr_md5_update(&ctx1, pw, strlen(pw));
}
apr_md5_final(final,&ctx1);
}
p = passwd + strlen(passwd);
l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; to64(p, l, 4); p += 4;
l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; to64(p, l, 4); p += 4;
l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; to64(p, l, 4); p += 4;
l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; to64(p, l, 4); p += 4;
l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; to64(p, l, 4); p += 4;
l = final[11] ; to64(p, l, 2); p += 2;
*p = '\0';
/*
* Don't leave anything around in vm they could use.
*/
memset(final, 0, sizeof(final));
apr_cpystrn(result, passwd, nbytes - 1);
return APR_SUCCESS;
}

200
contrib/apr-util/crypto/apr_passwd.c
View File

@ -1,200 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_strings.h"
#include "apr_md5.h"
#include "apr_lib.h"
#include "apr_sha1.h"
#include "apu_config.h"
#include "crypt_blowfish.h"
#if APR_HAVE_STRING_H
#include <string.h>
#endif
#if APR_HAVE_CRYPT_H
#include <crypt.h>
#endif
#if APR_HAVE_UNISTD_H
#include <unistd.h>
#endif
#if APR_HAVE_PTHREAD_H
#include <pthread.h>
#endif
#if APR_HAVE_STDLIB_H
#include <stdlib.h>
#endif
static const char * const apr1_id = "$apr1$";
#if !defined(WIN32) && !defined(BEOS) && !defined(NETWARE)
#if defined(APU_CRYPT_THREADSAFE) || !APR_HAS_THREADS || \
defined(CRYPT_R_CRYPTD) || defined(CRYPT_R_STRUCT_CRYPT_DATA)
#define crypt_mutex_lock()
#define crypt_mutex_unlock()
#elif APR_HAVE_PTHREAD_H && defined(PTHREAD_MUTEX_INITIALIZER)
static pthread_mutex_t crypt_mutex = PTHREAD_MUTEX_INITIALIZER;
static void crypt_mutex_lock(void)
{
pthread_mutex_lock(&crypt_mutex);
}
static void crypt_mutex_unlock(void)
{
pthread_mutex_unlock(&crypt_mutex);
}
#else
#error apr_password_validate() is not threadsafe. rebuild APR without thread support.
#endif
#endif
#if defined(WIN32) || defined(BEOS) || defined(NETWARE) || defined(__ANDROID__)
#define CRYPT_MISSING 1
#else
#define CRYPT_MISSING 0
#endif
/*
* Validate a plaintext password against a smashed one. Uses either
* crypt() (if available) or apr_md5_encode() or apr_sha1_base64(), depending
* upon the format of the smashed input password. Returns APR_SUCCESS if
* they match, or APR_EMISMATCH if they don't. If the platform doesn't
* support crypt, then the default check is against a clear text string.
*/
APU_DECLARE(apr_status_t) apr_password_validate(const char *passwd,
const char *hash)
{
char sample[200];
#if !CRYPT_MISSING
char *crypt_pw;
#endif
if (hash[0] == '$'
&& hash[1] == '2'
&& (hash[2] == 'a' || hash[2] == 'y')
&& hash[3] == '$') {
if (_crypt_blowfish_rn(passwd, hash, sample, sizeof(sample)) == NULL)
return APR_FROM_OS_ERROR(errno);
}
else if (!strncmp(hash, apr1_id, strlen(apr1_id))) {
/*
* The hash was created using our custom algorithm.
*/
apr_md5_encode(passwd, hash, sample, sizeof(sample));
}
else if (!strncmp(hash, APR_SHA1PW_ID, APR_SHA1PW_IDLEN)) {
apr_sha1_base64(passwd, (int)strlen(passwd), sample);
}
else {
/*
* It's not our algorithm, so feed it to crypt() if possible.
*/
#if CRYPT_MISSING
return (strcmp(passwd, hash) == 0) ? APR_SUCCESS : APR_EMISMATCH;
#elif defined(CRYPT_R_CRYPTD)
apr_status_t rv;
CRYPTD *buffer = malloc(sizeof(*buffer));
if (buffer == NULL)
return APR_ENOMEM;
crypt_pw = crypt_r(passwd, hash, buffer);
if (!crypt_pw)
rv = APR_EMISMATCH;
else
rv = (strcmp(crypt_pw, hash) == 0) ? APR_SUCCESS : APR_EMISMATCH;
free(buffer);
return rv;
#elif defined(CRYPT_R_STRUCT_CRYPT_DATA)
apr_status_t rv;
struct crypt_data *buffer = malloc(sizeof(*buffer));
if (buffer == NULL)
return APR_ENOMEM;
#ifdef __GLIBC_PREREQ
/*
* For not too old glibc (>= 2.3.2), it's enough to set
* buffer.initialized = 0. For < 2.3.2 and for other platforms,
* we need to zero the whole struct.
*/
#if __GLIBC_PREREQ(2,4)
#define USE_CRYPT_DATA_INITALIZED
#endif
#endif
#ifdef USE_CRYPT_DATA_INITALIZED
buffer->initialized = 0;
#else
memset(buffer, 0, sizeof(*buffer));
#endif
crypt_pw = crypt_r(passwd, hash, buffer);
if (!crypt_pw)
rv = APR_EMISMATCH;
else
rv = (strcmp(crypt_pw, hash) == 0) ? APR_SUCCESS : APR_EMISMATCH;
free(buffer);
return rv;
#else
/* Do a bit of sanity checking since we know that crypt_r()
* should always be used for threaded builds on AIX, and
* problems in configure logic can result in the wrong
* choice being made.
*/
#if defined(_AIX) && APR_HAS_THREADS
#error Configuration error! crypt_r() should have been selected!
#endif
{
apr_status_t rv;
/* Handle thread safety issues by holding a mutex around the
* call to crypt().
*/
crypt_mutex_lock();
crypt_pw = crypt(passwd, hash);
if (!crypt_pw) {
rv = APR_EMISMATCH;
}
else {
rv = (strcmp(crypt_pw, hash) == 0) ? APR_SUCCESS : APR_EMISMATCH;
}
crypt_mutex_unlock();
return rv;
}
#endif
}
return (strcmp(sample, hash) == 0) ? APR_SUCCESS : APR_EMISMATCH;
}
static const char * const bcrypt_id = "$2y$";
APU_DECLARE(apr_status_t) apr_bcrypt_encode(const char *pw,
unsigned int count,
const unsigned char *salt,
apr_size_t salt_len,
char *out, apr_size_t out_len)
{
char setting[40];
if (_crypt_gensalt_blowfish_rn(bcrypt_id, count, (const char *)salt,
salt_len, setting, sizeof(setting)) == NULL)
return APR_FROM_OS_ERROR(errno);
if (_crypt_blowfish_rn(pw, setting, out, out_len) == NULL)
return APR_FROM_OS_ERROR(errno);
return APR_SUCCESS;
}

368
contrib/apr-util/crypto/apr_sha1.c
View File

@ -1,368 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* The exported function:
*
* apr_sha1_base64(const char *clear, int len, char *out);
*
* provides a means to SHA1 crypt/encode a plaintext password in
* a way which makes password files compatible with those commonly
* used in netscape web and ldap installations. It was put together
* by Clinton Wong <clintdw@netcom.com>, who also notes that:
*
* Note: SHA1 support is useful for migration purposes, but is less
* secure than Apache's password format, since Apache's (MD5)
* password format uses a random eight character salt to generate
* one of many possible hashes for the same password. Netscape
* uses plain SHA1 without a salt, so the same password
* will always generate the same hash, making it easier
* to break since the search space is smaller.
*
* See also the documentation in support/SHA1 as to hints on how to
* migrate an existing netscape installation and other supplied utitlites.
*
* This software also makes use of the following component:
*
* NIST Secure Hash Algorithm
* heavily modified by Uwe Hollerbach uh@alumni.caltech edu
* from Peter C. Gutmann's implementation as found in
* Applied Cryptography by Bruce Schneier
* This code is hereby placed in the public domain
*/
#include "apr_sha1.h"
#include "apr_base64.h"
#include "apr_strings.h"
#include "apr_lib.h"
#if APR_CHARSET_EBCDIC
#include "apr_xlate.h"
#endif /*APR_CHARSET_EBCDIC*/
#include <string.h>
/* a bit faster & bigger, if defined */
#define UNROLL_LOOPS
/* NIST's proposed modification to SHA, 7/11/94 */
#define USE_MODIFIED_SHA
/* SHA f()-functions */
#define f1(x,y,z) ((x & y) | (~x & z))
#define f2(x,y,z) (x ^ y ^ z)
#define f3(x,y,z) ((x & y) | (x & z) | (y & z))
#define f4(x,y,z) (x ^ y ^ z)
/* SHA constants */
#define CONST1 0x5a827999L
#define CONST2 0x6ed9eba1L
#define CONST3 0x8f1bbcdcL
#define CONST4 0xca62c1d6L
/* 32-bit rotate */
#define ROT32(x,n) ((x << n) | (x >> (32 - n)))
#define FUNC(n,i) \
temp = ROT32(A,5) + f##n(B,C,D) + E + W[i] + CONST##n; \
E = D; D = C; C = ROT32(B,30); B = A; A = temp
#define SHA_BLOCKSIZE 64
#if APR_CHARSET_EBCDIC
static apr_xlate_t *ebcdic2ascii_xlate;
APU_DECLARE(apr_status_t) apr_SHA1InitEBCDIC(apr_xlate_t *x)
{
apr_status_t rv;
int onoff;
/* Only single-byte conversion is supported.
*/
rv = apr_xlate_sb_get(x, &onoff);
if (rv) {
return rv;
}
if (!onoff) { /* If conversion is not single-byte-only */
return APR_EINVAL;
}
ebcdic2ascii_xlate = x;
return APR_SUCCESS;
}
#endif
/* do SHA transformation */
static void sha_transform(apr_sha1_ctx_t *sha_info)
{
int i;
apr_uint32_t temp, A, B, C, D, E, W[80];
for (i = 0; i < 16; ++i) {
W[i] = sha_info->data[i];
}
for (i = 16; i < 80; ++i) {
W[i] = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];
#ifdef USE_MODIFIED_SHA
W[i] = ROT32(W[i], 1);
#endif /* USE_MODIFIED_SHA */
}
A = sha_info->digest[0];
B = sha_info->digest[1];
C = sha_info->digest[2];
D = sha_info->digest[3];
E = sha_info->digest[4];
#ifdef UNROLL_LOOPS
FUNC(1, 0); FUNC(1, 1); FUNC(1, 2); FUNC(1, 3); FUNC(1, 4);
FUNC(1, 5); FUNC(1, 6); FUNC(1, 7); FUNC(1, 8); FUNC(1, 9);
FUNC(1,10); FUNC(1,11); FUNC(1,12); FUNC(1,13); FUNC(1,14);
FUNC(1,15); FUNC(1,16); FUNC(1,17); FUNC(1,18); FUNC(1,19);
FUNC(2,20); FUNC(2,21); FUNC(2,22); FUNC(2,23); FUNC(2,24);
FUNC(2,25); FUNC(2,26); FUNC(2,27); FUNC(2,28); FUNC(2,29);
FUNC(2,30); FUNC(2,31); FUNC(2,32); FUNC(2,33); FUNC(2,34);
FUNC(2,35); FUNC(2,36); FUNC(2,37); FUNC(2,38); FUNC(2,39);
FUNC(3,40); FUNC(3,41); FUNC(3,42); FUNC(3,43); FUNC(3,44);
FUNC(3,45); FUNC(3,46); FUNC(3,47); FUNC(3,48); FUNC(3,49);
FUNC(3,50); FUNC(3,51); FUNC(3,52); FUNC(3,53); FUNC(3,54);
FUNC(3,55); FUNC(3,56); FUNC(3,57); FUNC(3,58); FUNC(3,59);
FUNC(4,60); FUNC(4,61); FUNC(4,62); FUNC(4,63); FUNC(4,64);
FUNC(4,65); FUNC(4,66); FUNC(4,67); FUNC(4,68); FUNC(4,69);
FUNC(4,70); FUNC(4,71); FUNC(4,72); FUNC(4,73); FUNC(4,74);
FUNC(4,75); FUNC(4,76); FUNC(4,77); FUNC(4,78); FUNC(4,79);
#else /* !UNROLL_LOOPS */
for (i = 0; i < 20; ++i) {
FUNC(1,i);
}
for (i = 20; i < 40; ++i) {
FUNC(2,i);
}
for (i = 40; i < 60; ++i) {
FUNC(3,i);
}
for (i = 60; i < 80; ++i) {
FUNC(4,i);
}
#endif /* !UNROLL_LOOPS */
sha_info->digest[0] += A;
sha_info->digest[1] += B;
sha_info->digest[2] += C;
sha_info->digest[3] += D;
sha_info->digest[4] += E;
}
union endianTest {
long Long;
char Char[sizeof(long)];
};
static char isLittleEndian(void)
{
static union endianTest u;
u.Long = 1;
return (u.Char[0] == 1);
}
/* change endianness of data */
/* count is the number of bytes to do an endian flip */
static void maybe_byte_reverse(apr_uint32_t *buffer, int count)
{
int i;
apr_byte_t ct[4], *cp;
if (isLittleEndian()) { /* do the swap only if it is little endian */
count /= sizeof(apr_uint32_t);
cp = (apr_byte_t *) buffer;
for (i = 0; i < count; ++i) {
ct[0] = cp[0];
ct[1] = cp[1];
ct[2] = cp[2];
ct[3] = cp[3];
cp[0] = ct[3];
cp[1] = ct[2];
cp[2] = ct[1];
cp[3] = ct[0];
cp += sizeof(apr_uint32_t);
}
}
}
/* initialize the SHA digest */
APU_DECLARE(void) apr_sha1_init(apr_sha1_ctx_t *sha_info)
{
sha_info->digest[0] = 0x67452301L;
sha_info->digest[1] = 0xefcdab89L;
sha_info->digest[2] = 0x98badcfeL;
sha_info->digest[3] = 0x10325476L;
sha_info->digest[4] = 0xc3d2e1f0L;
sha_info->count_lo = 0L;
sha_info->count_hi = 0L;
sha_info->local = 0;
}
/* update the SHA digest */
APU_DECLARE(void) apr_sha1_update_binary(apr_sha1_ctx_t *sha_info,
const unsigned char *buffer,
unsigned int count)
{
unsigned int i;
if ((sha_info->count_lo + ((apr_uint32_t) count << 3)) < sha_info->count_lo) {
++sha_info->count_hi;
}
sha_info->count_lo += (apr_uint32_t) count << 3;
sha_info->count_hi += (apr_uint32_t) count >> 29;
if (sha_info->local) {
i = SHA_BLOCKSIZE - sha_info->local;
if (i > count) {
i = count;
}
memcpy(((apr_byte_t *) sha_info->data) + sha_info->local, buffer, i);
count -= i;
buffer += i;
sha_info->local += i;
if (sha_info->local == SHA_BLOCKSIZE) {
maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
sha_transform(sha_info);
}
else {
return;
}
}
while (count >= SHA_BLOCKSIZE) {
memcpy(sha_info->data, buffer, SHA_BLOCKSIZE);
buffer += SHA_BLOCKSIZE;
count -= SHA_BLOCKSIZE;
maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
sha_transform(sha_info);
}
memcpy(sha_info->data, buffer, count);
sha_info->local = count;
}
APU_DECLARE(void) apr_sha1_update(apr_sha1_ctx_t *sha_info, const char *buf,
unsigned int count)
{
#if APR_CHARSET_EBCDIC
int i;
const apr_byte_t *buffer = (const apr_byte_t *) buf;
apr_size_t inbytes_left, outbytes_left;
if ((sha_info->count_lo + ((apr_uint32_t) count << 3)) < sha_info->count_lo) {
++sha_info->count_hi;
}
sha_info->count_lo += (apr_uint32_t) count << 3;
sha_info->count_hi += (apr_uint32_t) count >> 29;
/* Is there a remainder of the previous Update operation? */
if (sha_info->local) {
i = SHA_BLOCKSIZE - sha_info->local;
if (i > count) {
i = count;
}
inbytes_left = outbytes_left = i;
apr_xlate_conv_buffer(ebcdic2ascii_xlate, buffer, &inbytes_left,
((apr_byte_t *) sha_info->data) + sha_info->local,
&outbytes_left);
count -= i;
buffer += i;
sha_info->local += i;
if (sha_info->local == SHA_BLOCKSIZE) {
maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
sha_transform(sha_info);
}
else {
return;
}
}
while (count >= SHA_BLOCKSIZE) {
inbytes_left = outbytes_left = SHA_BLOCKSIZE;
apr_xlate_conv_buffer(ebcdic2ascii_xlate, buffer, &inbytes_left,
(apr_byte_t *) sha_info->data, &outbytes_left);
buffer += SHA_BLOCKSIZE;
count -= SHA_BLOCKSIZE;
maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
sha_transform(sha_info);
}
inbytes_left = outbytes_left = count;
apr_xlate_conv_buffer(ebcdic2ascii_xlate, buffer, &inbytes_left,
(apr_byte_t *) sha_info->data, &outbytes_left);
sha_info->local = count;
#else
apr_sha1_update_binary(sha_info, (const unsigned char *) buf, count);
#endif
}
/* finish computing the SHA digest */
APU_DECLARE(void) apr_sha1_final(unsigned char digest[APR_SHA1_DIGESTSIZE],
apr_sha1_ctx_t *sha_info)
{
int count, i, j;
apr_uint32_t lo_bit_count, hi_bit_count, k;
lo_bit_count = sha_info->count_lo;
hi_bit_count = sha_info->count_hi;
count = (int) ((lo_bit_count >> 3) & 0x3f);
((apr_byte_t *) sha_info->data)[count++] = 0x80;
if (count > SHA_BLOCKSIZE - 8) {
memset(((apr_byte_t *) sha_info->data) + count, 0, SHA_BLOCKSIZE - count);
maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
sha_transform(sha_info);
memset((apr_byte_t *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
}
else {
memset(((apr_byte_t *) sha_info->data) + count, 0,
SHA_BLOCKSIZE - 8 - count);
}
maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
sha_info->data[14] = hi_bit_count;
sha_info->data[15] = lo_bit_count;
sha_transform(sha_info);
for (i = 0, j = 0; j < APR_SHA1_DIGESTSIZE; i++) {
k = sha_info->digest[i];
digest[j++] = (unsigned char) ((k >> 24) & 0xff);
digest[j++] = (unsigned char) ((k >> 16) & 0xff);
digest[j++] = (unsigned char) ((k >> 8) & 0xff);
digest[j++] = (unsigned char) (k & 0xff);
}
}
APU_DECLARE(void) apr_sha1_base64(const char *clear, int len, char *out)
{
int l;
apr_sha1_ctx_t context;
apr_byte_t digest[APR_SHA1_DIGESTSIZE];
apr_sha1_init(&context);
apr_sha1_update(&context, clear, len);
apr_sha1_final(digest, &context);
/* private marker. */
apr_cpystrn(out, APR_SHA1PW_ID, APR_SHA1PW_IDLEN + 1);
/* SHA1 hash is always 20 chars */
l = apr_base64_encode_binary(out + APR_SHA1PW_IDLEN, digest, sizeof(digest));
out[l + APR_SHA1PW_IDLEN] = '\0';
/*
* output of base64 encoded SHA1 is always 28 chars + APR_SHA1PW_IDLEN
*/
}

196
contrib/apr-util/crypto/apr_siphash.c
View File

@ -1,196 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* SipHash (C reference implementation, APR-ized), originating from:
* https://131002.net/siphash/siphash24.c.
*/
#include "apr_siphash.h"
#define ROTL64(x, n) (((x) << (n)) | ((x) >> (64 - (n))))
#define U8TO64_LE(p) \
(((apr_uint64_t)((p)[0]) ) | \
((apr_uint64_t)((p)[1]) << 8) | \
((apr_uint64_t)((p)[2]) << 16) | \
((apr_uint64_t)((p)[3]) << 24) | \
((apr_uint64_t)((p)[4]) << 32) | \
((apr_uint64_t)((p)[5]) << 40) | \
((apr_uint64_t)((p)[6]) << 48) | \
((apr_uint64_t)((p)[7]) << 56))
#define U64TO8_LE(p, v) \
do { \
(p)[0] = (unsigned char)((v) ); \
(p)[1] = (unsigned char)((v) >> 8); \
(p)[2] = (unsigned char)((v) >> 16); \
(p)[3] = (unsigned char)((v) >> 24); \
(p)[4] = (unsigned char)((v) >> 32); \
(p)[5] = (unsigned char)((v) >> 40); \
(p)[6] = (unsigned char)((v) >> 48); \
(p)[7] = (unsigned char)((v) >> 56); \
} while (0)
#define SIPROUND() \
do { \
v0 += v1; v1=ROTL64(v1,13); v1 ^= v0; v0=ROTL64(v0,32); \
v2 += v3; v3=ROTL64(v3,16); v3 ^= v2; \
v0 += v3; v3=ROTL64(v3,21); v3 ^= v0; \
v2 += v1; v1=ROTL64(v1,17); v1 ^= v2; v2=ROTL64(v2,32); \
} while(0)
#define SIPHASH(r, s, n, k) \
do { \
const unsigned char *ptr, *end; \
apr_uint64_t v0, v1, v2, v3, m; \
apr_uint64_t k0, k1; \
unsigned int rem; \
\
k0 = U8TO64_LE(k + 0); \
k1 = U8TO64_LE(k + 8); \
v3 = k1 ^ (apr_uint64_t)0x7465646279746573ULL; \
v2 = k0 ^ (apr_uint64_t)0x6c7967656e657261ULL; \
v1 = k1 ^ (apr_uint64_t)0x646f72616e646f6dULL; \
v0 = k0 ^ (apr_uint64_t)0x736f6d6570736575ULL; \
\
rem = (unsigned int)(n & 0x7); \
for (ptr = s, end = ptr + n - rem; ptr < end; ptr += 8) { \
m = U8TO64_LE(ptr); \
v3 ^= m; \
cROUNDS \
v0 ^= m; \
} \
m = (apr_uint64_t)(n & 0xff) << 56; \
switch (rem) { \
case 7: m |= (apr_uint64_t)ptr[6] << 48; \
case 6: m |= (apr_uint64_t)ptr[5] << 40; \
case 5: m |= (apr_uint64_t)ptr[4] << 32; \
case 4: m |= (apr_uint64_t)ptr[3] << 24; \
case 3: m |= (apr_uint64_t)ptr[2] << 16; \
case 2: m |= (apr_uint64_t)ptr[1] << 8; \
case 1: m |= (apr_uint64_t)ptr[0]; \
case 0: break; \
} \
v3 ^= m; \
cROUNDS \
v0 ^= m; \
\
v2 ^= 0xff; \
dROUNDS \
\
r = v0 ^ v1 ^ v2 ^ v3; \
} while (0)
APU_DECLARE(apr_uint64_t) apr_siphash(const void *src, apr_size_t len,
const unsigned char key[APR_SIPHASH_KSIZE],
unsigned int c, unsigned int d)
{
apr_uint64_t h;
unsigned int i;
#undef cROUNDS
#define cROUNDS \
for (i = 0; i < c; ++i) { \
SIPROUND(); \
}
#undef dROUNDS
#define dROUNDS \
for (i = 0; i < d; ++i) { \
SIPROUND(); \
}
SIPHASH(h, src, len, key);
return h;
}
APU_DECLARE(void) apr_siphash_auth(unsigned char out[APR_SIPHASH_DSIZE],
const void *src, apr_size_t len,
const unsigned char key[APR_SIPHASH_KSIZE],
unsigned int c, unsigned int d)
{
apr_uint64_t h;
h = apr_siphash(src, len, key, c, d);
U64TO8_LE(out, h);
}
APU_DECLARE(apr_uint64_t) apr_siphash24(const void *src, apr_size_t len,
const unsigned char key[APR_SIPHASH_KSIZE])
{
apr_uint64_t h;
#undef cROUNDS
#define cROUNDS \
SIPROUND(); \
SIPROUND();
#undef dROUNDS
#define dROUNDS \
SIPROUND(); \
SIPROUND(); \
SIPROUND(); \
SIPROUND();
SIPHASH(h, src, len, key);
return h;
}
APU_DECLARE(void) apr_siphash24_auth(unsigned char out[APR_SIPHASH_DSIZE],
const void *src, apr_size_t len,
const unsigned char key[APR_SIPHASH_KSIZE])
{
apr_uint64_t h;
h = apr_siphash24(src, len, key);
U64TO8_LE(out, h);
}
APU_DECLARE(apr_uint64_t) apr_siphash48(const void *src, apr_size_t len,
const unsigned char key[APR_SIPHASH_KSIZE])
{
apr_uint64_t h;
#undef cROUNDS
#define cROUNDS \
SIPROUND(); \
SIPROUND(); \
SIPROUND(); \
SIPROUND();
#undef dROUNDS
#define dROUNDS \
SIPROUND(); \
SIPROUND(); \
SIPROUND(); \
SIPROUND(); \
SIPROUND(); \
SIPROUND(); \
SIPROUND(); \
SIPROUND();
SIPHASH(h, src, len, key);
return h;
}
APU_DECLARE(void) apr_siphash48_auth(unsigned char out[APR_SIPHASH_DSIZE],
const void *src, apr_size_t len,
const unsigned char key[APR_SIPHASH_KSIZE])
{
apr_uint64_t h;
h = apr_siphash48(src, len, key);
U64TO8_LE(out, h);
}

902
contrib/apr-util/crypto/crypt_blowfish.c
View File

@ -1,902 +0,0 @@
/*
* The crypt_blowfish homepage is:
*
* http://www.openwall.com/crypt/
*
* This code comes from John the Ripper password cracker, with reentrant
* and crypt(3) interfaces added, but optimizations specific to password
* cracking removed.
*
* Written by Solar Designer <solar at openwall.com> in 1998-2011.
* No copyright is claimed, and the software is hereby placed in the public
* domain. In case this attempt to disclaim copyright and place the software
* in the public domain is deemed null and void, then the software is
* Copyright (c) 1998-2011 Solar Designer and it is hereby released to the
* general public under the following terms:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted.
*
* There's ABSOLUTELY NO WARRANTY, express or implied.
*
* It is my intent that you should be able to use this on your system,
* as part of a software package, or anywhere else to improve security,
* ensure compatibility, or for any other purpose. I would appreciate
* it if you give credit where it is due and keep your modifications in
* the public domain as well, but I don't require that in order to let
* you place this code and any modifications you make under a license
* of your choice.
*
* This implementation is mostly compatible with OpenBSD's bcrypt.c (prefix
* "$2a$") by Niels Provos <provos at citi.umich.edu>, and uses some of his
* ideas. The password hashing algorithm was designed by David Mazieres
* <dm at lcs.mit.edu>. For more information on the level of compatibility,
* prefer refer to the comments in BF_set_key() below and to the included
* crypt(3) man page.
*
* There's a paper on the algorithm that explains its design decisions:
*
* http://www.usenix.org/events/usenix99/provos.html
*
* Some of the tricks in BF_ROUND might be inspired by Eric Young's
* Blowfish library (I can't be sure if I would think of something if I
* hadn't seen his code).
*/
#include <string.h>
#include <errno.h>
#ifndef __set_errno
#define __set_errno(val) errno = (val)
#endif
/* Just to make sure the prototypes match the actual definitions */
#include "crypt_blowfish.h"
#ifdef __i386__
#define BF_ASM 0
#define BF_SCALE 1
#elif defined(__x86_64__) || defined(__alpha__) || defined(__hppa__)
#define BF_ASM 0
#define BF_SCALE 1
#else
#define BF_ASM 0
#define BF_SCALE 0
#endif
typedef unsigned int BF_word;
typedef signed int BF_word_signed;
/* Number of Blowfish rounds, this is also hardcoded into a few places */
#define BF_N 16
typedef BF_word BF_key[BF_N + 2];
typedef struct {
BF_word S[4][0x100];
BF_key P;
} BF_ctx;
/*
* Magic IV for 64 Blowfish encryptions that we do at the end.
* The string is "OrpheanBeholderScryDoubt" on big-endian.
*/
static BF_word BF_magic_w[6] = {
0x4F727068, 0x65616E42, 0x65686F6C,
0x64657253, 0x63727944, 0x6F756274
};
/*
* P-box and S-box tables initialized with digits of Pi.
*/
static BF_ctx BF_init_state = {
{
{
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
}, {
0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
}, {
0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
}, {
0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
}
}, {
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
0x9216d5d9, 0x8979fb1b
}
};
static unsigned char BF_itoa64[64 + 1] =
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
static unsigned char BF_atoi64[0x60] = {
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1,
54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 64, 64, 64, 64, 64,
64, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 64, 64, 64, 64, 64,
64, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 64, 64, 64, 64, 64
};
#define BF_safe_atoi64(dst, src) \
{ \
tmp = (unsigned char)(src); \
if ((unsigned int)(tmp -= 0x20) >= 0x60) return -1; \
tmp = BF_atoi64[tmp]; \
if (tmp > 63) return -1; \
(dst) = tmp; \
}
static int BF_decode(BF_word *dst, const char *src, int size)
{
unsigned char *dptr = (unsigned char *)dst;
unsigned char *end = dptr + size;
const unsigned char *sptr = (const unsigned char *)src;
unsigned int tmp, c1, c2, c3, c4;
do {
BF_safe_atoi64(c1, *sptr++);
BF_safe_atoi64(c2, *sptr++);
*dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4);
if (dptr >= end) break;
BF_safe_atoi64(c3, *sptr++);
*dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2);
if (dptr >= end) break;
BF_safe_atoi64(c4, *sptr++);
*dptr++ = ((c3 & 0x03) << 6) | c4;
} while (dptr < end);
return 0;
}
static void BF_encode(char *dst, const BF_word *src, int size)
{
const unsigned char *sptr = (const unsigned char *)src;
const unsigned char *end = sptr + size;
unsigned char *dptr = (unsigned char *)dst;
unsigned int c1, c2;
do {
c1 = *sptr++;
*dptr++ = BF_itoa64[c1 >> 2];
c1 = (c1 & 0x03) << 4;
if (sptr >= end) {
*dptr++ = BF_itoa64[c1];
break;
}
c2 = *sptr++;
c1 |= c2 >> 4;
*dptr++ = BF_itoa64[c1];
c1 = (c2 & 0x0f) << 2;
if (sptr >= end) {
*dptr++ = BF_itoa64[c1];
break;
}
c2 = *sptr++;
c1 |= c2 >> 6;
*dptr++ = BF_itoa64[c1];
*dptr++ = BF_itoa64[c2 & 0x3f];
} while (sptr < end);
}
static void BF_swap(BF_word *x, int count)
{
static int endianness_check = 1;
char *is_little_endian = (char *)&endianness_check;
BF_word tmp;
if (*is_little_endian)
do {
tmp = *x;
tmp = (tmp << 16) | (tmp >> 16);
*x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
} while (--count);
}
#if BF_SCALE
/* Architectures which can shift addresses left by 2 bits with no extra cost */
#define BF_ROUND(L, R, N) \
tmp1 = L & 0xFF; \
tmp2 = L >> 8; \
tmp2 &= 0xFF; \
tmp3 = L >> 16; \
tmp3 &= 0xFF; \
tmp4 = L >> 24; \
tmp1 = data.ctx.S[3][tmp1]; \
tmp2 = data.ctx.S[2][tmp2]; \
tmp3 = data.ctx.S[1][tmp3]; \
tmp3 += data.ctx.S[0][tmp4]; \
tmp3 ^= tmp2; \
R ^= data.ctx.P[N + 1]; \
tmp3 += tmp1; \
R ^= tmp3;
#else
/* Architectures with no complicated addressing modes supported */
#define BF_INDEX(S, i) \
(*((BF_word *)(((unsigned char *)S) + (i))))
#define BF_ROUND(L, R, N) \
tmp1 = L & 0xFF; \
tmp1 <<= 2; \
tmp2 = L >> 6; \
tmp2 &= 0x3FC; \
tmp3 = L >> 14; \
tmp3 &= 0x3FC; \
tmp4 = L >> 22; \
tmp4 &= 0x3FC; \
tmp1 = BF_INDEX(data.ctx.S[3], tmp1); \
tmp2 = BF_INDEX(data.ctx.S[2], tmp2); \
tmp3 = BF_INDEX(data.ctx.S[1], tmp3); \
tmp3 += BF_INDEX(data.ctx.S[0], tmp4); \
tmp3 ^= tmp2; \
R ^= data.ctx.P[N + 1]; \
tmp3 += tmp1; \
R ^= tmp3;
#endif
/*
* Encrypt one block, BF_N is hardcoded here.
*/
#define BF_ENCRYPT \
L ^= data.ctx.P[0]; \
BF_ROUND(L, R, 0); \
BF_ROUND(R, L, 1); \
BF_ROUND(L, R, 2); \
BF_ROUND(R, L, 3); \
BF_ROUND(L, R, 4); \
BF_ROUND(R, L, 5); \
BF_ROUND(L, R, 6); \
BF_ROUND(R, L, 7); \
BF_ROUND(L, R, 8); \
BF_ROUND(R, L, 9); \
BF_ROUND(L, R, 10); \
BF_ROUND(R, L, 11); \
BF_ROUND(L, R, 12); \
BF_ROUND(R, L, 13); \
BF_ROUND(L, R, 14); \
BF_ROUND(R, L, 15); \
tmp4 = R; \
R = L; \
L = tmp4 ^ data.ctx.P[BF_N + 1];
#if BF_ASM
#define BF_body() \
_BF_body_r(&data.ctx);
#else
#define BF_body() \
L = R = 0; \
ptr = data.ctx.P; \
do { \
ptr += 2; \
BF_ENCRYPT; \
*(ptr - 2) = L; \
*(ptr - 1) = R; \
} while (ptr < &data.ctx.P[BF_N + 2]); \
\
ptr = data.ctx.S[0]; \
do { \
ptr += 2; \
BF_ENCRYPT; \
*(ptr - 2) = L; \
*(ptr - 1) = R; \
} while (ptr < &data.ctx.S[3][0xFF]);
#endif
static void BF_set_key(const char *key, BF_key expanded, BF_key initial,
unsigned char flags)
{
const char *ptr = key;
unsigned int bug, i, j;
BF_word safety, sign, diff, tmp[2];
/*
* There was a sign extension bug in older revisions of this function. While
* we would have liked to simply fix the bug and move on, we have to provide
* a backwards compatibility feature (essentially the bug) for some systems and
* a safety measure for some others. The latter is needed because for certain
* multiple inputs to the buggy algorithm there exist easily found inputs to
* the correct algorithm that produce the same hash. Thus, we optionally
* deviate from the correct algorithm just enough to avoid such collisions.
* While the bug itself affected the majority of passwords containing
* characters with the 8th bit set (although only a percentage of those in a
* collision-producing way), the anti-collision safety measure affects
* only a subset of passwords containing the '\xff' character (not even all of
* those passwords, just some of them). This character is not found in valid
* UTF-8 sequences and is rarely used in popular 8-bit character encodings.
* Thus, the safety measure is unlikely to cause much annoyance, and is a
* reasonable tradeoff to use when authenticating against existing hashes that
* are not reliably known to have been computed with the correct algorithm.
*
* We use an approach that tries to minimize side-channel leaks of password
* information - that is, we mostly use fixed-cost bitwise operations instead
* of branches or table lookups. (One conditional branch based on password
* length remains. It is not part of the bug aftermath, though, and is
* difficult and possibly unreasonable to avoid given the use of C strings by
* the caller, which results in similar timing leaks anyway.)
*
* For actual implementation, we set an array index in the variable "bug"
* (0 means no bug, 1 means sign extension bug emulation) and a flag in the
* variable "safety" (bit 16 is set when the safety measure is requested).
* Valid combinations of settings are:
*
* Prefix "$2a$": bug = 0, safety = 0x10000
* Prefix "$2x$": bug = 1, safety = 0
* Prefix "$2y$": bug = 0, safety = 0
*/
bug = (unsigned int)flags & 1;
safety = ((BF_word)flags & 2) << 15;
sign = diff = 0;
for (i = 0; i < BF_N + 2; i++) {
tmp[0] = tmp[1] = 0;
for (j = 0; j < 4; j++) {
tmp[0] <<= 8;
tmp[0] |= (unsigned char)*ptr; /* correct */
tmp[1] <<= 8;
tmp[1] |= (BF_word_signed)(signed char)*ptr; /* bug */
/*
* Sign extension in the first char has no effect - nothing to overwrite yet,
* and those extra 24 bits will be fully shifted out of the 32-bit word. For
* chars 2, 3, 4 in each four-char block, we set bit 7 of "sign" if sign
* extension in tmp[1] occurs. Once this flag is set, it remains set.
*/
if (j)
sign |= tmp[1] & 0x80;
if (!*ptr)
ptr = key;
else
ptr++;
}
diff |= tmp[0] ^ tmp[1]; /* Non-zero on any differences */
expanded[i] = tmp[bug];
initial[i] = BF_init_state.P[i] ^ tmp[bug];
}
/*
* At this point, "diff" is zero iff the correct and buggy algorithms produced
* exactly the same result. If so and if "sign" is non-zero, which indicates
* that there was a non-benign sign extension, this means that we have a
* collision between the correctly computed hash for this password and a set of
* passwords that could be supplied to the buggy algorithm. Our safety measure
* is meant to protect from such many-buggy to one-correct collisions, by
* deviating from the correct algorithm in such cases. Let's check for this.
*/
diff |= diff >> 16; /* still zero iff exact match */
diff &= 0xffff; /* ditto */
diff += 0xffff; /* bit 16 set iff "diff" was non-zero (on non-match) */
sign <<= 9; /* move the non-benign sign extension flag to bit 16 */
sign &= ~diff & safety; /* action needed? */
/*
* If we have determined that we need to deviate from the correct algorithm,
* flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but
* let's stick to it now. It came out of the approach we used above, and it's
* not any worse than any other choice we could make.)
*
* It is crucial that we don't do the same to the expanded key used in the main
* Eksblowfish loop. By doing it to only one of these two, we deviate from a
* state that could be directly specified by a password to the buggy algorithm
* (and to the fully correct one as well, but that's a side-effect).
*/
initial[0] ^= sign;
}
static char *BF_crypt(const char *key, const char *setting,
char *output, int size,
BF_word min)
{
#if BF_ASM
extern void _BF_body_r(BF_ctx *ctx);
#endif
static const unsigned char flags_by_subtype[26] =
{2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 4, 0};
struct {
BF_ctx ctx;
BF_key expanded_key;
union {
BF_word salt[4];
BF_word output[6];
} binary;
} data;
BF_word L, R;
BF_word tmp1, tmp2, tmp3, tmp4;
BF_word *ptr;
BF_word count;
int i;
if (size < 7 + 22 + 31 + 1) {
__set_errno(ERANGE);
return NULL;
}
if (setting[0] != '$' ||
setting[1] != '2' ||
setting[2] < 'a' || setting[2] > 'z' ||
!flags_by_subtype[(unsigned int)(unsigned char)setting[2] - 'a'] ||
setting[3] != '$' ||
setting[4] < '0' || setting[4] > '1' ||
setting[5] < '0' || setting[5] > '9' ||
(setting[4] == '1' && setting[5] > '7') ||
setting[6] != '$') {
__set_errno(EINVAL);
return NULL;
}
count = (BF_word)1 << ((setting[4] - '0') * 10 + (setting[5] - '0'));
if (count < min || BF_decode(data.binary.salt, &setting[7], 16)) {
__set_errno(EINVAL);
return NULL;
}
BF_swap(data.binary.salt, 4);
BF_set_key(key, data.expanded_key, data.ctx.P,
flags_by_subtype[(unsigned int)(unsigned char)setting[2] - 'a']);
memcpy(data.ctx.S, BF_init_state.S, sizeof(data.ctx.S));
L = R = 0;
for (i = 0; i < BF_N + 2; i += 2) {
L ^= data.binary.salt[i & 2];
R ^= data.binary.salt[(i & 2) + 1];
BF_ENCRYPT;
data.ctx.P[i] = L;
data.ctx.P[i + 1] = R;
}
ptr = data.ctx.S[0];
do {
ptr += 4;
L ^= data.binary.salt[(BF_N + 2) & 3];
R ^= data.binary.salt[(BF_N + 3) & 3];
BF_ENCRYPT;
*(ptr - 4) = L;
*(ptr - 3) = R;
L ^= data.binary.salt[(BF_N + 4) & 3];
R ^= data.binary.salt[(BF_N + 5) & 3];
BF_ENCRYPT;
*(ptr - 2) = L;
*(ptr - 1) = R;
} while (ptr < &data.ctx.S[3][0xFF]);
do {
int done;
for (i = 0; i < BF_N + 2; i += 2) {
data.ctx.P[i] ^= data.expanded_key[i];
data.ctx.P[i + 1] ^= data.expanded_key[i + 1];
}
done = 0;
do {
BF_body();
if (done)
break;
done = 1;
tmp1 = data.binary.salt[0];
tmp2 = data.binary.salt[1];
tmp3 = data.binary.salt[2];
tmp4 = data.binary.salt[3];
for (i = 0; i < BF_N; i += 4) {
data.ctx.P[i] ^= tmp1;
data.ctx.P[i + 1] ^= tmp2;
data.ctx.P[i + 2] ^= tmp3;
data.ctx.P[i + 3] ^= tmp4;
}
data.ctx.P[16] ^= tmp1;
data.ctx.P[17] ^= tmp2;
} while (1);
} while (--count);
for (i = 0; i < 6; i += 2) {
L = BF_magic_w[i];
R = BF_magic_w[i + 1];
count = 64;
do {
BF_ENCRYPT;
} while (--count);
data.binary.output[i] = L;
data.binary.output[i + 1] = R;
}
memcpy(output, setting, 7 + 22 - 1);
output[7 + 22 - 1] = BF_itoa64[(int)
BF_atoi64[(int)setting[7 + 22 - 1] - 0x20] & 0x30];
/* This has to be bug-compatible with the original implementation, so
* only encode 23 of the 24 bytes. :-) */
BF_swap(data.binary.output, 6);
BF_encode(&output[7 + 22], data.binary.output, 23);
output[7 + 22 + 31] = '\0';
return output;
}
int _crypt_output_magic(const char *setting, char *output, int size)
{
if (size < 3)
return -1;
output[0] = '*';
output[1] = '0';
output[2] = '\0';
if (setting[0] == '*' && setting[1] == '0')
output[1] = '1';
return 0;
}
/*
* Please preserve the runtime self-test. It serves two purposes at once:
*
* 1. We really can't afford the risk of producing incompatible hashes e.g.
* when there's something like gcc bug 26587 again, whereas an application or
* library integrating this code might not also integrate our external tests or
* it might not run them after every build. Even if it does, the miscompile
* might only occur on the production build, but not on a testing build (such
* as because of different optimization settings). It is painful to recover
* from incorrectly-computed hashes - merely fixing whatever broke is not
* enough. Thus, a proactive measure like this self-test is needed.
*
* 2. We don't want to leave sensitive data from our actual password hash
* computation on the stack or in registers. Previous revisions of the code
* would do explicit cleanups, but simply running the self-test after hash
* computation is more reliable.
*
* The performance cost of this quick self-test is around 0.6% at the "$2a$08"
* setting.
*/
char *_crypt_blowfish_rn(const char *key, const char *setting,
char *output, int size)
{
const char *test_key = "8b \xd0\xc1\xd2\xcf\xcc\xd8";
const char *test_setting = "$2a$00$abcdefghijklmnopqrstuu";
static const char * const test_hash[2] =
{"VUrPmXD6q/nVSSp7pNDhCR9071IfIRe\0\x55", /* $2x$ */
"i1D709vfamulimlGcq0qq3UvuUasvEa\0\x55"}; /* $2a$, $2y$ */
char *retval;
const char *p;
int save_errno, ok;
struct {
char s[7 + 22 + 1];
char o[7 + 22 + 31 + 1 + 1 + 1];
} buf;
/* Hash the supplied password */
_crypt_output_magic(setting, output, size);
retval = BF_crypt(key, setting, output, size, 16);
save_errno = errno;
/*
* Do a quick self-test. It is important that we make both calls to BF_crypt()
* from the same scope such that they likely use the same stack locations,
* which makes the second call overwrite the first call's sensitive data on the
* stack and makes it more likely that any alignment related issues would be
* detected by the self-test.
*/
memcpy(buf.s, test_setting, sizeof(buf.s));
if (retval)
buf.s[2] = setting[2];
memset(buf.o, 0x55, sizeof(buf.o));
buf.o[sizeof(buf.o) - 1] = 0;
p = BF_crypt(test_key, buf.s, buf.o, sizeof(buf.o) - (1 + 1), 1);
ok = (p == buf.o &&
!memcmp(p, buf.s, 7 + 22) &&
!memcmp(p + (7 + 22),
test_hash[(unsigned int)(unsigned char)buf.s[2] & 1],
31 + 1 + 1 + 1));
{
const char *k = "\xff\xa3" "34" "\xff\xff\xff\xa3" "345";
BF_key ae, ai, ye, yi;
BF_set_key(k, ae, ai, 2); /* $2a$ */
BF_set_key(k, ye, yi, 4); /* $2y$ */
ai[0] ^= 0x10000; /* undo the safety (for comparison) */
ok = ok && ai[0] == 0xdb9c59bc && ye[17] == 0x33343500 &&
!memcmp(ae, ye, sizeof(ae)) &&
!memcmp(ai, yi, sizeof(ai));
}
__set_errno(save_errno);
if (ok)
return retval;
/* Should not happen */
_crypt_output_magic(setting, output, size);
__set_errno(EINVAL); /* pretend we don't support this hash type */
return NULL;
}
char *_crypt_gensalt_blowfish_rn(const char *prefix, unsigned long count,
const char *input, int size, char *output, int output_size)
{
if (size < 16 || output_size < 7 + 22 + 1 ||
(count && (count < 4 || count > 17)) ||
prefix[0] != '$' || prefix[1] != '2' ||
(prefix[2] != 'a' && prefix[2] != 'y')) {
if (output_size > 0) output[0] = '\0';
__set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL);
return NULL;
}
if (!count) count = 5;
output[0] = '$';
output[1] = '2';
output[2] = prefix[2];
output[3] = '$';
output[4] = '0' + count / 10;
output[5] = '0' + count % 10;
output[6] = '$';
BF_encode(&output[7], (const BF_word *)input, 16);
output[7 + 22] = '\0';
return output;
}

27
contrib/apr-util/crypto/crypt_blowfish.h
View File

@ -1,27 +0,0 @@
/*
* Written by Solar Designer <solar at openwall.com> in 2000-2011.
* No copyright is claimed, and the software is hereby placed in the public
* domain. In case this attempt to disclaim copyright and place the software
* in the public domain is deemed null and void, then the software is
* Copyright (c) 2000-2011 Solar Designer and it is hereby released to the
* general public under the following terms:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted.
*
* There's ABSOLUTELY NO WARRANTY, express or implied.
*
* See crypt_blowfish.c for more information.
*/
#ifndef _CRYPT_BLOWFISH_H
#define _CRYPT_BLOWFISH_H
extern int _crypt_output_magic(const char *setting, char *output, int size);
extern char *_crypt_blowfish_rn(const char *key, const char *setting,
char *output, int size);
extern char *_crypt_gensalt_blowfish_rn(const char *prefix,
unsigned long count,
const char *input, int size, char *output, int output_size);
#endif

208
contrib/apr-util/crypto/getuuid.c
View File

@ -1,208 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* This attempts to generate V1 UUIDs according to the Internet Draft
* located at http://www.webdav.org/specs/draft-leach-uuids-guids-01.txt
*/
#include "apr.h"
#include "apr_uuid.h"
#include "apr_md5.h"
#include "apr_general.h"
#include "apr_portable.h"
#if APR_HAVE_UNISTD_H
#include <unistd.h> /* for getpid, gethostname */
#endif
#if APR_HAVE_STDLIB_H
#include <stdlib.h> /* for rand, srand */
#endif
#if APR_HAVE_STRING_H
#include <string.h>
#endif
#if APR_HAVE_STRINGS_H
#include <strings.h>
#endif
#if APR_HAVE_NETDB_H
#include <netdb.h>
#endif
#if APR_HAVE_SYS_TIME_H
#include <sys/time.h> /* for gettimeofday */
#endif
#define NODE_LENGTH 6
static int uuid_state_seqnum;
static unsigned char uuid_state_node[NODE_LENGTH] = { 0 };
static void get_random_info(unsigned char node[NODE_LENGTH])
{
#if APR_HAS_RANDOM
(void) apr_generate_random_bytes(node, NODE_LENGTH);
#else
unsigned char seed[APR_MD5_DIGESTSIZE];
apr_md5_ctx_t c;
/* ### probably should revise some of this to be a bit more portable */
/* Leach & Salz use Linux-specific struct sysinfo;
* replace with pid/tid for portability (in the spirit of mod_unique_id) */
struct {
/* Add thread id here, if applicable, when we get to pthread or apr */
pid_t pid;
#ifdef NETWARE
apr_uint64_t t;
#else
struct timeval t;
#endif
char hostname[257];
} r;
apr_md5_init(&c);
#ifdef NETWARE
r.pid = NXThreadGetId();
NXGetTime(NX_SINCE_BOOT, NX_USECONDS, &(r.t));
#else
r.pid = getpid();
gettimeofday(&r.t, (struct timezone *)0);
#endif
gethostname(r.hostname, 256);
apr_md5_update(&c, (const unsigned char *)&r, sizeof(r));
apr_md5_final(seed, &c);
memcpy(node, seed, NODE_LENGTH); /* use a subset of the seed bytes */
#endif
}
/* This implementation generates a random node ID instead of a
system-dependent call to get IEEE node ID. This is also more secure:
we aren't passing out our MAC address.
*/
static void get_pseudo_node_identifier(unsigned char *node)
{
get_random_info(node);
node[0] |= 0x01; /* this designates a random multicast node ID */
}
static void get_system_time(apr_uint64_t *uuid_time)
{
/* ### fix this call to be more portable? */
*uuid_time = apr_time_now();
/* Offset between UUID formatted times and Unix formatted times.
UUID UTC base time is October 15, 1582.
Unix base time is January 1, 1970. */
*uuid_time = (*uuid_time * 10) + APR_TIME_C(0x01B21DD213814000);
}
/* true_random -- generate a crypto-quality random number. */
static int true_random(void)
{
apr_uint64_t time_now;
#if APR_HAS_RANDOM
unsigned char buf[2];
if (apr_generate_random_bytes(buf, 2) == APR_SUCCESS) {
return (buf[0] << 8) | buf[1];
}
#endif
/* crap. this isn't crypto quality, but it will be Good Enough */
time_now = apr_time_now();
srand((unsigned int)(((time_now >> 32) ^ time_now) & 0xffffffff));
return rand() & 0x0FFFF;
}
static void init_state(void)
{
uuid_state_seqnum = true_random();
get_pseudo_node_identifier(uuid_state_node);
}
static void get_current_time(apr_uint64_t *timestamp)
{
/* ### this needs to be made thread-safe! */
apr_uint64_t time_now;
static apr_uint64_t time_last = 0;
static apr_uint64_t fudge = 0;
get_system_time(&time_now);
/* if clock reading changed since last UUID generated... */
if (time_last != time_now) {
/* The clock reading has changed since the last UUID was generated.
Reset the fudge factor. if we are generating them too fast, then
the fudge may need to be reset to something greater than zero. */
if (time_last + fudge > time_now)
fudge = time_last + fudge - time_now + 1;
else
fudge = 0;
time_last = time_now;
}
else {
/* We generated two really fast. Bump the fudge factor. */
++fudge;
}
*timestamp = time_now + fudge;
}
APU_DECLARE(void) apr_uuid_get(apr_uuid_t *uuid)
{
apr_uint64_t timestamp;
unsigned char *d = uuid->data;
#if APR_HAS_OS_UUID
if (apr_os_uuid_get(d) == APR_SUCCESS) {
return;
}
#endif /* !APR_HAS_OS_UUID */
if (!uuid_state_node[0])
init_state();
get_current_time(&timestamp);
/* time_low, uint32 */
d[3] = (unsigned char)timestamp;
d[2] = (unsigned char)(timestamp >> 8);
d[1] = (unsigned char)(timestamp >> 16);
d[0] = (unsigned char)(timestamp >> 24);
/* time_mid, uint16 */
d[5] = (unsigned char)(timestamp >> 32);
d[4] = (unsigned char)(timestamp >> 40);
/* time_hi_and_version, uint16 */
d[7] = (unsigned char)(timestamp >> 48);
d[6] = (unsigned char)(((timestamp >> 56) & 0x0F) | 0x10);
/* clock_seq_hi_and_reserved, uint8 */
d[8] = (unsigned char)(((uuid_state_seqnum >> 8) & 0x3F) | 0x80);
/* clock_seq_low, uint8 */
d[9] = (unsigned char)uuid_state_seqnum;
/* node, byte[6] */
memcpy(&d[10], uuid_state_node, NODE_LENGTH);
}

130
contrib/apr-util/crypto/uuid.c
View File

@ -1,130 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h> /* for sprintf */
#include "apr.h"
#include "apr_uuid.h"
#include "apr_errno.h"
#include "apr_lib.h"
APU_DECLARE(void) apr_uuid_format(char *buffer, const apr_uuid_t *uuid)
{
const unsigned char *d = uuid->data;
sprintf(buffer,
"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],
d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]);
}
/* convert a pair of hex digits to an integer value [0,255] */
#if 'A' == 65
static unsigned char parse_hexpair(const char *s)
{
int result;
int temp;
result = s[0] - '0';
if (result > 48)
result = (result - 39) << 4;
else if (result > 16)
result = (result - 7) << 4;
else
result = result << 4;
temp = s[1] - '0';
if (temp > 48)
result |= temp - 39;
else if (temp > 16)
result |= temp - 7;
else
result |= temp;
return (unsigned char)result;
}
#else
static unsigned char parse_hexpair(const char *s)
{
int result;
if (isdigit(*s)) {
result = (*s - '0') << 4;
}
else {
if (isupper(*s)) {
result = (*s - 'A' + 10) << 4;
}
else {
result = (*s - 'a' + 10) << 4;
}
}
++s;
if (isdigit(*s)) {
result |= (*s - '0');
}
else {
if (isupper(*s)) {
result |= (*s - 'A' + 10);
}
else {
result |= (*s - 'a' + 10);
}
}
return (unsigned char)result;
}
#endif
APU_DECLARE(apr_status_t) apr_uuid_parse(apr_uuid_t *uuid,
const char *uuid_str)
{
int i;
unsigned char *d = uuid->data;
for (i = 0; i < 36; ++i) {
char c = uuid_str[i];
if (!apr_isxdigit(c) &&
!(c == '-' && (i == 8 || i == 13 || i == 18 || i == 23)))
/* ### need a better value */
return APR_BADARG;
}
if (uuid_str[36] != '\0') {
/* ### need a better value */
return APR_BADARG;
}
d[0] = parse_hexpair(&uuid_str[0]);
d[1] = parse_hexpair(&uuid_str[2]);
d[2] = parse_hexpair(&uuid_str[4]);
d[3] = parse_hexpair(&uuid_str[6]);
d[4] = parse_hexpair(&uuid_str[9]);
d[5] = parse_hexpair(&uuid_str[11]);
d[6] = parse_hexpair(&uuid_str[14]);
d[7] = parse_hexpair(&uuid_str[16]);
d[8] = parse_hexpair(&uuid_str[19]);
d[9] = parse_hexpair(&uuid_str[21]);
for (i = 6; i--;)
d[10 + i] = parse_hexpair(&uuid_str[i*2+24]);
return APR_SUCCESS;
}

295
contrib/apr-util/dbd/NWGNUdbdmysql
View File

@ -1,295 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
$(EOLIST)
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
ifndef EnvironmentDefined
include $(APR_WORK)/build/NWGNUhead.inc
endif
#include $(APR)\build\NWGNUcustom.inc
#
# build this level's files
#
# Make sure all needed macro's are defined
#
# LINK_STATIC = 1
# for now defined here - should finally go into build/NWGNUenvironment.inc
MYSQL_INC = $(MYSQLSDK)/include
MYSQL_IMP = libmysql.imp
MYSQL_LIB = libmysqlclient_r.lib libz.lib
MYSQL_NLM = libmysql
ifneq "$(wildcard $(MYSQL_INC)/mysql.h)" "$(MYSQL_INC)/mysql.h"
$(error MYSQLSDK does not point to a valid MySQL SDK)
endif
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(APR)/include/arch/netware \
$(APR)/include \
$(APU)/include \
$(APU)/include/private \
$(APR) \
$(MYSQL_INC) \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
-DAPU_DSO_MODULE_BUILD \
-DAPU_HAVE_MYSQL=1 \
-DHAVE_MYSQL_H \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
-l $(MYSQLSDK)/lib \
$(EOLIST)
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME = dbdmysql
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION = Apache Portability Runtime Library $(VERSION_STR) DBD MySQL Driver Module
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME = dbdmysql
#
# If this is specified, it will override VERSION value in
# $(AP_WORK)\build\NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE = 8192
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If these are specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled
# by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(OBJDIR)/$(NLM_NAME).nlm \
$(EOLIST)
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(OBJDIR)/apr_dbd_mysql.o \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(PRELUDE) \
$(EOLIST)
ifeq ($(LINK_STATIC),1)
FILES_nlm_libs += \
$(MYSQL_LIB) \
$(EOLIST)
endif
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
aprlib \
libc \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_modules += \
$(MYSQL_NLM) \
$(EOLIST)
endif
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
@aprlib.imp \
@libc.imp \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_Ximports += \
@$(MYSQL_IMP) \
$(EOLIST)
endif
#
# Any symbols exported to here
#
FILES_nlm_exports = \
apr_dbd_mysql_driver \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(AP_WORK)\build\NWGNUhead.inc for examples)
#
install :: nlms FORCE
#
# Any specialized rules here
#
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

301
contrib/apr-util/dbd/NWGNUdbdpgsql
View File

@ -1,301 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
$(EOLIST)
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
ifndef EnvironmentDefined
include $(APR_WORK)/build/NWGNUhead.inc
endif
#include $(APR)\build\NWGNUcustom.inc
#
# build this level's files
#
# Make sure all needed macro's are defined
#
# LINK_STATIC = 1
# for now defined here - should finally go into build/NWGNUenvironment.inc
PGSQL_INC = $(PGSQLSDK)/inc
PGSQL_IMP = libpq.imp
PGSQL_LIB = libpq.lib
PGSQL_NLM = libpq
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(APR)/include/arch/netware \
$(APR)/include \
$(APU)/include \
$(APU)/include/private \
$(APR) \
$(PGSQL_INC) \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
-DAPU_DSO_MODULE_BUILD \
-DAPU_HAVE_PGSQL=1 \
-DHAVE_LIBPQ_FE_H \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
$(EOLIST)
ifdef LINK_STATIC
XLFLAGS += \
-l $(PGSQLSDK)/lib \
$(EOLIST)
else
XLFLAGS += \
-l $(PGSQLSDK)/imp \
$(EOLIST)
endif
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME = dbdpgsql
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION = Apache Portability Runtime Library $(VERSION_STR) DBD PostgreSQL Driver Module
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME = dbdpgsql
#
# If this is specified, it will override VERSION value in
# $(AP_WORK)\build\NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE = 8192
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If these are specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled
# by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(OBJDIR)/$(NLM_NAME).nlm \
$(EOLIST)
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(OBJDIR)/apr_dbd_pgsql.o \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(PRELUDE) \
$(EOLIST)
ifeq ($(LINK_STATIC),1)
FILES_nlm_libs += \
$(PGSQL_LIB) \
$(EOLIST)
endif
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
aprlib \
libc \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_modules += \
$(PGSQL_NLM) \
$(EOLIST)
endif
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
@aprlib.imp \
@libc.imp \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_Ximports += \
@$(PGSQL_IMP) \
$(EOLIST)
endif
#
# Any symbols exported to here
#
FILES_nlm_exports = \
apr_dbd_pgsql_driver \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(AP_WORK)\build\NWGNUhead.inc for examples)
#
install :: nlms FORCE
#
# Any specialized rules here
#
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

296
contrib/apr-util/dbd/NWGNUdbdsqli2
View File

@ -1,296 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
$(EOLIST)
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
ifndef EnvironmentDefined
include $(APR_WORK)/build/NWGNUhead.inc
endif
#include $(APR)\build\NWGNUcustom.inc
#
# build this level's files
#
# Make sure all needed macro's are defined
#
# LINK_STATIC = 1
# for now defined here - should finally go into build/NWGNUenvironment.inc
SQLITE2_INC = $(SQLITE2SDK)/src
SQLITE2_IMP = $(SQLITE2SDK)/lsqlite2.imp
SQLITE2_LIB = $(SQLITE2SDK)/lsqlite2.lib
SQLITE2_NLM = lsqlite2
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(APR)/include/arch/netware \
$(APR)/include \
$(APU)/include \
$(APU)/include/private \
$(APR) \
$(SQLITE2_INC) \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
-DAPU_DSO_MODULE_BUILD \
-DAPU_HAVE_SQLITE2=1 \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
$(EOLIST)
ifdef LINK_STATIC
XLFLAGS += \
-l $(SQLITE2SDK) \
$(EOLIST)
endif
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME = dbdsqli2
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION = Apache Portability Runtime Library $(VERSION_STR) DBD SQLite2 Driver Module
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME = dbdsqli2
#
# If this is specified, it will override VERSION value in
# $(AP_WORK)\build\NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE = 8192
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If these are specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled
# by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(OBJDIR)\$(NLM_NAME).nlm \
$(EOLIST)
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(OBJDIR)/apr_dbd_sqlite2.o \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(PRELUDE) \
$(EOLIST)
ifeq ($(LINK_STATIC),1)
FILES_nlm_libs += \
$(SQLITE2_LIB) \
$(EOLIST)
endif
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
aprlib \
libc \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_modules += \
$(SQLITE2_NLM) \
$(EOLIST)
endif
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
@$(APR)/aprlib.imp \
@libc.imp \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_Ximports += \
@$(SQLITE2_IMP) \
$(EOLIST)
endif
#
# Any symbols exported to here
#
FILES_nlm_exports = \
apr_dbd_sqlite2_driver \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(AP_WORK)\build\NWGNUhead.inc for examples)
#
install :: nlms FORCE
#
# Any specialized rules here
#
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

298
contrib/apr-util/dbd/NWGNUdbdsqli3
View File

@ -1,298 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
$(EOLIST)
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
ifndef EnvironmentDefined
include $(APR_WORK)/build/NWGNUhead.inc
endif
#include $(APR)\build\NWGNUcustom.inc
#
# build this level's files
#
# Make sure all needed macro's are defined
#
# LINK_STATIC = 1
# for now defined here - should finally go into build/NWGNUenvironment.inc
SQLITE3_INC = $(SQLITE3SDK)/src
SQLITE3_IMP = $(SQLITE3SDK)/lsqlite3.imp
SQLITE3_LIB = $(SQLITE3SDK)/lsqlite3.lib
SQLITE3_NLM = lsqlite3
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(APR)/include/arch/netware \
$(APR)/include \
$(APU)/include \
$(APU)/include/private \
$(APR) \
$(SQLITE3_INC) \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
-DAPU_DSO_MODULE_BUILD \
-DAPU_HAVE_SQLITE3=1 \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
$(EOLIST)
ifdef LINK_STATIC
XLFLAGS += \
-l $(SQLITE3SDK) \
$(EOLIST)
endif
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME = dbdsqli3
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION = Apache Portability Runtime Library $(VERSION_STR) DBD SQLite3 Driver Module
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME = dbdsqli3
#
# If this is specified, it will override VERSION value in
# $(AP_WORK)\build\NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE = 8192
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If these are specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled
# by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(OBJDIR)\$(NLM_NAME).nlm \
$(EOLIST)
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(OBJDIR)/apr_dbd_sqlite3.o \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(PRELUDE) \
$(EOLIST)
ifeq ($(LINK_STATIC),1)
FILES_nlm_libs += \
$(SQLITE3_LIB) \
$(EOLIST)
endif
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
aprlib \
libc \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_modules += \
$(SQLITE3_NLM) \
$(EOLIST)
endif
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
@$(APR)/aprlib.imp \
@libc.imp \
apr_dbd_mutex_lock \
apr_dbd_mutex_unlock \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_Ximports += \
@$(SQLITE3_IMP) \
$(EOLIST)
endif
#
# Any symbols exported to here
#
FILES_nlm_exports = \
apr_dbd_sqlite3_driver \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(AP_WORK)\build\NWGNUhead.inc for examples)
#
install :: nlms FORCE
#
# Any specialized rules here
#
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

259
contrib/apr-util/dbd/NWGNUmakefile
View File

@ -1,259 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
$(EOLIST)
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
include $(APR_WORK)/build/NWGNUhead.inc
#
# build this level's files
#
# Make sure all needed macro's are defined
#
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
$(EOLIST)
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME =
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION =
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME =
#
# If this is specified, it will override VERSION value in
# $(AP_WORK)\build\NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE =
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If these are specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled
# by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(EOLIST)
ifeq "$(APU_HAVE_MYSQL)" "1"
ifeq "$(wildcard apr_dbd_mysql.c)" "apr_dbd_mysql.c"
TARGET_nlm += $(OBJDIR)/dbdmysql.nlm $(OBJDIR)/dbdmysql.nlm $(EOLIST)
endif
endif
ifeq "$(APU_HAVE_PGSQL)" "1"
TARGET_nlm += $(OBJDIR)/dbdpgsql.nlm $(OBJDIR)/dbdpgsql.nlm $(EOLIST)
endif
ifeq "$(APU_HAVE_SQLITE2)" "1"
TARGET_nlm += $(OBJDIR)/dbdsqli2.nlm $(OBJDIR)/dbdsqli2.nlm $(EOLIST)
endif
ifeq "$(APU_HAVE_SQLITE3)" "1"
TARGET_nlm += $(OBJDIR)/dbdsqli3.nlm $(OBJDIR)/dbdsqli3.nlm $(EOLIST)
endif
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(EOLIST)
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
$(EOLIST)
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
$(EOLIST)
#
# Any symbols exported to here
#
FILES_nlm_exports = \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(AP_WORK)\build\NWGNUhead.inc for examples)
#
install :: nlms $(INSTDIRS) FORCE
$(call COPY,$(OBJDIR)/*.nlm,$(INSTALLBASE))
#
# Any specialized rules here
#
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

573
contrib/apr-util/dbd/apr_dbd.c
View File

@ -1,573 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <ctype.h>
#include <stdio.h>
#include "apu_config.h"
#include "apu.h"
#include "apr_pools.h"
#include "apr_dso.h"
#include "apr_strings.h"
#include "apr_hash.h"
#include "apr_thread_mutex.h"
#include "apr_lib.h"
#include "apr_atomic.h"
#include "apu_internal.h"
#include "apr_dbd_internal.h"
#include "apr_dbd.h"
#include "apu_version.h"
static apr_hash_t *drivers = NULL;
static apr_uint32_t initialised = 0, in_init = 1;
#define CLEANUP_CAST (apr_status_t (*)(void*))
#if APR_HAS_THREADS
/* deprecated, but required for existing providers. Existing and new
* providers should be refactored to use a provider-specific mutex so
* that different providers do not block one another.
* In APR 1.3 this is no longer used for dso module loading, and
* apu_dso_mutex_[un]lock is used instead.
* In APR 2.0 this should become entirely local to libaprutil-2.so and
* no longer be exported.
*/
static apr_thread_mutex_t* mutex = NULL;
APU_DECLARE(apr_status_t) apr_dbd_mutex_lock()
{
return apr_thread_mutex_lock(mutex);
}
APU_DECLARE(apr_status_t) apr_dbd_mutex_unlock()
{
return apr_thread_mutex_unlock(mutex);
}
#else
APU_DECLARE(apr_status_t) apr_dbd_mutex_lock() {
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_dbd_mutex_unlock() {
return APR_SUCCESS;
}
#endif
#if !APU_DSO_BUILD
#define DRIVER_LOAD(name,driver,pool) \
{ \
extern const apr_dbd_driver_t driver; \
apr_hash_set(drivers,name,APR_HASH_KEY_STRING,&driver); \
if (driver.init) { \
driver.init(pool); \
} \
}
#endif
static apr_status_t apr_dbd_term(void *ptr)
{
/* set drivers to NULL so init can work again */
drivers = NULL;
/* Everything else we need is handled by cleanups registered
* when we created mutexes and loaded DSOs
*/
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_dbd_init(apr_pool_t *pool)
{
apr_status_t ret = APR_SUCCESS;
apr_pool_t *parent;
if (apr_atomic_inc32(&initialised)) {
apr_atomic_set32(&initialised, 1); /* prevent wrap-around */
while (apr_atomic_read32(&in_init)) /* wait until we get fully inited */
;
return APR_SUCCESS;
}
/* Top level pool scope, need process-scope lifetime */
for (parent = apr_pool_parent_get(pool);
parent && parent != pool;
parent = apr_pool_parent_get(pool))
pool = parent;
#if APU_DSO_BUILD
/* deprecate in 2.0 - permit implicit initialization */
apu_dso_init(pool);
#endif
drivers = apr_hash_make(pool);
#if APR_HAS_THREADS
ret = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, pool);
/* This already registers a pool cleanup */
#endif
#if !APU_DSO_BUILD
/* Load statically-linked drivers: */
#if APU_HAVE_MYSQL
DRIVER_LOAD("mysql", apr_dbd_mysql_driver, pool);
#endif
#if APU_HAVE_PGSQL
DRIVER_LOAD("pgsql", apr_dbd_pgsql_driver, pool);
#endif
#if APU_HAVE_SQLITE3
DRIVER_LOAD("sqlite3", apr_dbd_sqlite3_driver, pool);
#endif
#if APU_HAVE_SQLITE2
DRIVER_LOAD("sqlite2", apr_dbd_sqlite2_driver, pool);
#endif
#if APU_HAVE_ORACLE
DRIVER_LOAD("oracle", apr_dbd_oracle_driver, pool);
#endif
#if APU_HAVE_ODBC
DRIVER_LOAD("odbc", apr_dbd_odbc_driver, pool);
#endif
#if APU_HAVE_SOME_OTHER_BACKEND
DRIVER_LOAD("firebird", apr_dbd_other_driver, pool);
#endif
#endif /* APU_DSO_BUILD */
apr_pool_cleanup_register(pool, NULL, apr_dbd_term,
apr_pool_cleanup_null);
apr_atomic_dec32(&in_init);
return ret;
}
APU_DECLARE(apr_status_t) apr_dbd_get_driver(apr_pool_t *pool, const char *name,
const apr_dbd_driver_t **driver)
{
#if APU_DSO_BUILD
char modname[32];
char symname[34];
apr_dso_handle_sym_t symbol;
#endif
apr_status_t rv;
#if APU_DSO_BUILD
rv = apu_dso_mutex_lock();
if (rv) {
return rv;
}
#endif
*driver = apr_hash_get(drivers, name, APR_HASH_KEY_STRING);
if (*driver) {
#if APU_DSO_BUILD
apu_dso_mutex_unlock();
#endif
return APR_SUCCESS;
}
#if APU_DSO_BUILD
/* The driver DSO must have exactly the same lifetime as the
* drivers hash table; ignore the passed-in pool */
pool = apr_hash_pool_get(drivers);
#if defined(NETWARE)
apr_snprintf(modname, sizeof(modname), "dbd%s.nlm", name);
#elif defined(WIN32) || defined(__CYGWIN__)
apr_snprintf(modname, sizeof(modname),
"apr_dbd_%s-" APU_STRINGIFY(APU_MAJOR_VERSION) ".dll", name);
#else
apr_snprintf(modname, sizeof(modname),
"apr_dbd_%s-" APU_STRINGIFY(APU_MAJOR_VERSION) ".so", name);
#endif
apr_snprintf(symname, sizeof(symname), "apr_dbd_%s_driver", name);
rv = apu_dso_load(NULL, &symbol, modname, symname, pool);
if (rv == APR_SUCCESS || rv == APR_EINIT) { /* previously loaded?!? */
*driver = symbol;
name = apr_pstrdup(pool, name);
apr_hash_set(drivers, name, APR_HASH_KEY_STRING, *driver);
rv = APR_SUCCESS;
if ((*driver)->init) {
(*driver)->init(pool);
}
}
apu_dso_mutex_unlock();
#else /* not builtin and !APU_DSO_BUILD => not implemented */
rv = APR_ENOTIMPL;
#endif
return rv;
}
APU_DECLARE(apr_status_t) apr_dbd_open_ex(const apr_dbd_driver_t *driver,
apr_pool_t *pool, const char *params,
apr_dbd_t **handle,
const char **error)
{
apr_status_t rv;
*handle = (driver->open)(pool, params, error);
if (*handle == NULL) {
return APR_EGENERAL;
}
rv = apr_dbd_check_conn(driver, pool, *handle);
if ((rv != APR_SUCCESS) && (rv != APR_ENOTIMPL)) {
/* XXX: rv is APR error code, but apr_dbd_error() takes int! */
if (error) {
*error = apr_dbd_error(driver, *handle, rv);
}
apr_dbd_close(driver, *handle);
return APR_EGENERAL;
}
return APR_SUCCESS;
}
APU_DECLARE(apr_status_t) apr_dbd_open(const apr_dbd_driver_t *driver,
apr_pool_t *pool, const char *params,
apr_dbd_t **handle)
{
return apr_dbd_open_ex(driver,pool,params,handle,NULL);
}
APU_DECLARE(int) apr_dbd_transaction_start(const apr_dbd_driver_t *driver,
apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_transaction_t **trans)
{
int ret = driver->start_transaction(pool, handle, trans);
if (*trans) {
apr_pool_cleanup_register(pool, *trans,
CLEANUP_CAST driver->end_transaction,
apr_pool_cleanup_null);
}
return ret;
}
APU_DECLARE(int) apr_dbd_transaction_end(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_transaction_t *trans)
{
apr_pool_cleanup_kill(pool, trans, CLEANUP_CAST driver->end_transaction);
return driver->end_transaction(trans);
}
APU_DECLARE(int) apr_dbd_transaction_mode_get(const apr_dbd_driver_t *driver,
apr_dbd_transaction_t *trans)
{
return driver->transaction_mode_get(trans);
}
APU_DECLARE(int) apr_dbd_transaction_mode_set(const apr_dbd_driver_t *driver,
apr_dbd_transaction_t *trans,
int mode)
{
return driver->transaction_mode_set(trans, mode);
}
APU_DECLARE(apr_status_t) apr_dbd_close(const apr_dbd_driver_t *driver,
apr_dbd_t *handle)
{
return driver->close(handle);
}
APU_DECLARE(const char*) apr_dbd_name(const apr_dbd_driver_t *driver)
{
return driver->name;
}
APU_DECLARE(void*) apr_dbd_native_handle(const apr_dbd_driver_t *driver,
apr_dbd_t *handle)
{
return driver->native_handle(handle);
}
APU_DECLARE(int) apr_dbd_check_conn(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle)
{
return driver->check_conn(pool, handle);
}
APU_DECLARE(int) apr_dbd_set_dbname(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, const char *name)
{
return driver->set_dbname(pool,handle,name);
}
APU_DECLARE(int) apr_dbd_query(const apr_dbd_driver_t *driver,
apr_dbd_t *handle,
int *nrows, const char *statement)
{
return driver->query(handle,nrows,statement);
}
APU_DECLARE(int) apr_dbd_select(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, apr_dbd_results_t **res,
const char *statement, int random)
{
return driver->select(pool,handle,res,statement,random);
}
APU_DECLARE(int) apr_dbd_num_cols(const apr_dbd_driver_t *driver,
apr_dbd_results_t *res)
{
return driver->num_cols(res);
}
APU_DECLARE(int) apr_dbd_num_tuples(const apr_dbd_driver_t *driver,
apr_dbd_results_t *res)
{
return driver->num_tuples(res);
}
APU_DECLARE(int) apr_dbd_get_row(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_results_t *res, apr_dbd_row_t **row,
int rownum)
{
return driver->get_row(pool,res,row,rownum);
}
APU_DECLARE(const char*) apr_dbd_get_entry(const apr_dbd_driver_t *driver,
apr_dbd_row_t *row, int col)
{
return driver->get_entry(row,col);
}
APU_DECLARE(const char*) apr_dbd_get_name(const apr_dbd_driver_t *driver,
apr_dbd_results_t *res, int col)
{
return driver->get_name(res,col);
}
APU_DECLARE(const char*) apr_dbd_error(const apr_dbd_driver_t *driver,
apr_dbd_t *handle, int errnum)
{
return driver->error(handle,errnum);
}
APU_DECLARE(const char*) apr_dbd_escape(const apr_dbd_driver_t *driver,
apr_pool_t *pool, const char *string,
apr_dbd_t *handle)
{
return driver->escape(pool,string,handle);
}
APU_DECLARE(int) apr_dbd_prepare(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, const char *query,
const char *label,
apr_dbd_prepared_t **statement)
{
size_t qlen;
int i, nargs = 0, nvals = 0;
char *p, *pq;
const char *q;
apr_dbd_type_e *t;
if (!driver->pformat) {
return APR_ENOTIMPL;
}
/* find the number of parameters in the query */
for (q = query; *q; q++) {
if (q[0] == '%') {
if (apr_isalpha(q[1])) {
nargs++;
} else if (q[1] == '%') {
q++;
}
}
}
nvals = nargs;
qlen = strlen(query) +
nargs * (strlen(driver->pformat) + sizeof(nargs) * 3 + 2) + 1;
pq = apr_palloc(pool, qlen);
t = apr_pcalloc(pool, sizeof(*t) * nargs);
for (p = pq, q = query, i = 0; *q; q++) {
if (q[0] == '%') {
if (apr_isalpha(q[1])) {
switch (q[1]) {
case 'd': t[i] = APR_DBD_TYPE_INT; break;
case 'u': t[i] = APR_DBD_TYPE_UINT; break;
case 'f': t[i] = APR_DBD_TYPE_FLOAT; break;
case 'h':
switch (q[2]) {
case 'h':
switch (q[3]){
case 'd': t[i] = APR_DBD_TYPE_TINY; q += 2; break;
case 'u': t[i] = APR_DBD_TYPE_UTINY; q += 2; break;
}
break;
case 'd': t[i] = APR_DBD_TYPE_SHORT; q++; break;
case 'u': t[i] = APR_DBD_TYPE_USHORT; q++; break;
}
break;
case 'l':
switch (q[2]) {
case 'l':
switch (q[3]){
case 'd': t[i] = APR_DBD_TYPE_LONGLONG; q += 2; break;
case 'u': t[i] = APR_DBD_TYPE_ULONGLONG; q += 2; break;
}
break;
case 'd': t[i] = APR_DBD_TYPE_LONG; q++; break;
case 'u': t[i] = APR_DBD_TYPE_ULONG; q++; break;
case 'f': t[i] = APR_DBD_TYPE_DOUBLE; q++; break;
}
break;
case 'p':
if (q[2] == 'D') {
switch (q[3]) {
case 't': t[i] = APR_DBD_TYPE_TEXT; q += 2; break;
case 'i': t[i] = APR_DBD_TYPE_TIME; q += 2; break;
case 'd': t[i] = APR_DBD_TYPE_DATE; q += 2; break;
case 'a': t[i] = APR_DBD_TYPE_DATETIME; q += 2; break;
case 's': t[i] = APR_DBD_TYPE_TIMESTAMP; q += 2; break;
case 'z': t[i] = APR_DBD_TYPE_ZTIMESTAMP; q += 2; break;
case 'b': t[i] = APR_DBD_TYPE_BLOB; q += 2; break;
case 'c': t[i] = APR_DBD_TYPE_CLOB; q += 2; break;
case 'n': t[i] = APR_DBD_TYPE_NULL; q += 2; break;
}
}
break;
}
q++;
switch (t[i]) {
case APR_DBD_TYPE_NONE: /* by default, we expect strings */
t[i] = APR_DBD_TYPE_STRING;
break;
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB: /* three (3) more values passed in */
nvals += 3;
break;
default:
break;
}
/* insert database specific parameter reference */
p += apr_snprintf(p, qlen - (p - pq), driver->pformat, ++i);
} else if (q[1] == '%') { /* reduce %% to % */
*p++ = *q++;
} else {
*p++ = *q;
}
} else {
*p++ = *q;
}
}
*p = '\0';
return driver->prepare(pool,handle,pq,label,nargs,nvals,t,statement);
}
APU_DECLARE(int) apr_dbd_pquery(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement,
int nargs, const char **args)
{
return driver->pquery(pool,handle,nrows,statement,args);
}
APU_DECLARE(int) apr_dbd_pselect(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, apr_dbd_results_t **res,
apr_dbd_prepared_t *statement, int random,
int nargs, const char **args)
{
return driver->pselect(pool,handle,res,statement,random,args);
}
APU_DECLARE_NONSTD(int) apr_dbd_pvquery(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement, ...)
{
int ret;
va_list args;
va_start(args, statement);
ret = driver->pvquery(pool,handle,nrows,statement,args);
va_end(args);
return ret;
}
APU_DECLARE_NONSTD(int) apr_dbd_pvselect(const apr_dbd_driver_t *driver,
apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_results_t **res,
apr_dbd_prepared_t *statement,
int random, ...)
{
int ret;
va_list args;
va_start(args, random);
ret = driver->pvselect(pool,handle,res,statement,random,args);
va_end(args);
return ret;
}
APU_DECLARE(int) apr_dbd_pbquery(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement,
const void **args)
{
return driver->pbquery(pool,handle,nrows,statement,args);
}
APU_DECLARE(int) apr_dbd_pbselect(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, apr_dbd_results_t **res,
apr_dbd_prepared_t *statement, int random,
const void **args)
{
return driver->pbselect(pool,handle,res,statement,random,args);
}
APU_DECLARE_NONSTD(int) apr_dbd_pvbquery(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement, ...)
{
int ret;
va_list args;
va_start(args, statement);
ret = driver->pvbquery(pool,handle,nrows,statement,args);
va_end(args);
return ret;
}
APU_DECLARE_NONSTD(int) apr_dbd_pvbselect(const apr_dbd_driver_t *driver,
apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_results_t **res,
apr_dbd_prepared_t *statement,
int random, ...)
{
int ret;
va_list args;
va_start(args, random);
ret = driver->pvbselect(pool,handle,res,statement,random,args);
va_end(args);
return ret;
}
APU_DECLARE(apr_status_t) apr_dbd_datum_get(const apr_dbd_driver_t *driver,
apr_dbd_row_t *row, int col,
apr_dbd_type_e type, void *data)
{
return driver->datum_get(row,col,type,data);
}

1305
contrib/apr-util/dbd/apr_dbd_mysql.c
View File

File diff suppressed because it is too large Load Diff

1750
contrib/apr-util/dbd/apr_dbd_odbc.c
View File

File diff suppressed because it is too large Load Diff

2220
contrib/apr-util/dbd/apr_dbd_oracle.c
View File

File diff suppressed because it is too large Load Diff

1315
contrib/apr-util/dbd/apr_dbd_pgsql.c
View File

File diff suppressed because it is too large Load Diff

566
contrib/apr-util/dbd/apr_dbd_sqlite2.c
View File

@ -1,566 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apu.h"
#if APU_HAVE_SQLITE2
#include <ctype.h>
#include <stdlib.h>
#include <sqlite.h>
#include "apr_strings.h"
#include "apr_time.h"
#include "apr_buckets.h"
#include "apr_dbd_internal.h"
struct apr_dbd_transaction_t {
int mode;
int errnum;
apr_dbd_t *handle;
};
struct apr_dbd_t {
sqlite *conn;
char *errmsg;
apr_dbd_transaction_t *trans;
};
struct apr_dbd_results_t {
int random;
sqlite *handle;
char **res;
size_t ntuples;
size_t sz;
size_t index;
apr_pool_t *pool;
};
struct apr_dbd_row_t {
int n;
char **data;
apr_dbd_results_t *res;
};
struct apr_dbd_prepared_t {
const char *name;
int prepared;
};
#define FREE_ERROR_MSG(dbd) \
do { \
if(dbd && dbd->errmsg) { \
free(dbd->errmsg); \
dbd->errmsg = NULL; \
} \
} while(0);
static apr_status_t free_table(void *data)
{
sqlite_free_table(data);
return APR_SUCCESS;
}
static int dbd_sqlite_select(apr_pool_t * pool, apr_dbd_t * sql,
apr_dbd_results_t ** results, const char *query,
int seek)
{
char **result;
int ret = 0;
int tuples = 0;
int fields = 0;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
FREE_ERROR_MSG(sql);
ret = sqlite_get_table(sql->conn, query, &result, &tuples, &fields,
&sql->errmsg);
if (ret == SQLITE_OK) {
if (!*results) {
*results = apr_pcalloc(pool, sizeof(apr_dbd_results_t));
}
(*results)->res = result;
(*results)->ntuples = tuples;
(*results)->sz = fields;
(*results)->random = seek;
(*results)->pool = pool;
if (tuples > 0)
apr_pool_cleanup_register(pool, result, free_table,
apr_pool_cleanup_null);
ret = 0;
}
else {
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
}
return ret;
}
static const char *dbd_sqlite_get_name(const apr_dbd_results_t *res, int n)
{
if ((n < 0) || (n >= res->sz)) {
return NULL;
}
return res->res[n];
}
static int dbd_sqlite_get_row(apr_pool_t * pool, apr_dbd_results_t * res,
apr_dbd_row_t ** rowp, int rownum)
{
apr_dbd_row_t *row = *rowp;
int sequential = ((rownum >= 0) && res->random) ? 0 : 1;
if (row == NULL) {
row = apr_palloc(pool, sizeof(apr_dbd_row_t));
*rowp = row;
row->res = res;
row->n = sequential ? 0 : rownum - 1;
}
else {
if (sequential) {
++row->n;
}
else {
row->n = rownum - 1;
}
}
if (row->n >= res->ntuples) {
*rowp = NULL;
apr_pool_cleanup_run(res->pool, res->res, free_table);
res->res = NULL;
return -1;
}
/* Pointer magic explanation:
* The sqlite result is an array such that the first res->sz elements are
* the column names and each tuple follows afterwards
* ex: (from the sqlite2 documentation)
SELECT employee_name, login, host FROM users WHERE login LIKE * 'd%';
nrow = 2
ncolumn = 3
result[0] = "employee_name"
result[1] = "login"
result[2] = "host"
result[3] = "dummy"
result[4] = "No such user"
result[5] = 0
result[6] = "D. Richard Hipp"
result[7] = "drh"
result[8] = "zadok"
*/
row->data = res->res + res->sz + (res->sz * row->n);
return 0;
}
static const char *dbd_sqlite_get_entry(const apr_dbd_row_t * row, int n)
{
if ((n < 0) || (n >= row->res->sz)) {
return NULL;
}
return row->data[n];
}
static apr_status_t dbd_sqlite_datum_get(const apr_dbd_row_t *row, int n,
apr_dbd_type_e type, void *data)
{
if ((n < 0) || (n >= row->res->sz)) {
return APR_EGENERAL;
}
if (row->data[n] == NULL) {
return APR_ENOENT;
}
switch (type) {
case APR_DBD_TYPE_TINY:
*(char*)data = atoi(row->data[n]);
break;
case APR_DBD_TYPE_UTINY:
*(unsigned char*)data = atoi(row->data[n]);
break;
case APR_DBD_TYPE_SHORT:
*(short*)data = atoi(row->data[n]);
break;
case APR_DBD_TYPE_USHORT:
*(unsigned short*)data = atoi(row->data[n]);
break;
case APR_DBD_TYPE_INT:
*(int*)data = atoi(row->data[n]);
break;
case APR_DBD_TYPE_UINT:
*(unsigned int*)data = atoi(row->data[n]);
break;
case APR_DBD_TYPE_LONG:
*(long*)data = atol(row->data[n]);
break;
case APR_DBD_TYPE_ULONG:
*(unsigned long*)data = atol(row->data[n]);
break;
case APR_DBD_TYPE_LONGLONG:
*(apr_int64_t*)data = apr_atoi64(row->data[n]);
break;
case APR_DBD_TYPE_ULONGLONG:
*(apr_uint64_t*)data = apr_atoi64(row->data[n]);
break;
case APR_DBD_TYPE_FLOAT:
*(float*)data = atof(row->data[n]);
break;
case APR_DBD_TYPE_DOUBLE:
*(double*)data = atof(row->data[n]);
break;
case APR_DBD_TYPE_STRING:
case APR_DBD_TYPE_TEXT:
case APR_DBD_TYPE_TIME:
case APR_DBD_TYPE_DATE:
case APR_DBD_TYPE_DATETIME:
case APR_DBD_TYPE_TIMESTAMP:
case APR_DBD_TYPE_ZTIMESTAMP:
*(char**)data = row->data[n];
break;
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
apr_bucket *e;
apr_bucket_brigade *b = (apr_bucket_brigade*)data;
e = apr_bucket_pool_create(row->data[n],strlen(row->data[n]),
row->res->pool, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
}
break;
case APR_DBD_TYPE_NULL:
*(void**)data = NULL;
break;
default:
return APR_EGENERAL;
}
return APR_SUCCESS;
}
static const char *dbd_sqlite_error(apr_dbd_t * sql, int n)
{
return sql->errmsg;
}
static int dbd_sqlite_query(apr_dbd_t * sql, int *nrows, const char *query)
{
char **result;
int ret;
int tuples = 0;
int fields = 0;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
FREE_ERROR_MSG(sql);
ret =
sqlite_get_table(sql->conn, query, &result, &tuples, &fields,
&sql->errmsg);
if (ret == SQLITE_OK) {
*nrows = sqlite_changes(sql->conn);
if (tuples > 0)
free(result);
ret = 0;
}
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static apr_status_t free_mem(void *data)
{
sqlite_freemem(data);
return APR_SUCCESS;
}
static const char *dbd_sqlite_escape(apr_pool_t * pool, const char *arg,
apr_dbd_t * sql)
{
char *ret = sqlite_mprintf("%q", arg);
apr_pool_cleanup_register(pool, ret, free_mem, apr_pool_cleanup_null);
return ret;
}
static int dbd_sqlite_prepare(apr_pool_t * pool, apr_dbd_t * sql,
const char *query, const char *label,
int nargs, int nvals, apr_dbd_type_e *types,
apr_dbd_prepared_t ** statement)
{
return APR_ENOTIMPL;
}
static int dbd_sqlite_pquery(apr_pool_t * pool, apr_dbd_t * sql,
int *nrows, apr_dbd_prepared_t * statement,
const char **values)
{
return APR_ENOTIMPL;
}
static int dbd_sqlite_pvquery(apr_pool_t * pool, apr_dbd_t * sql,
int *nrows, apr_dbd_prepared_t * statement,
va_list args)
{
return APR_ENOTIMPL;
}
static int dbd_sqlite_pselect(apr_pool_t * pool, apr_dbd_t * sql,
apr_dbd_results_t ** results,
apr_dbd_prepared_t * statement,
int seek, const char **values)
{
return APR_ENOTIMPL;
}
static int dbd_sqlite_pvselect(apr_pool_t * pool, apr_dbd_t * sql,
apr_dbd_results_t ** results,
apr_dbd_prepared_t * statement, int seek,
va_list args)
{
return APR_ENOTIMPL;
}
static int dbd_sqlite_pbquery(apr_pool_t * pool, apr_dbd_t * sql,
int *nrows, apr_dbd_prepared_t * statement,
const void **values)
{
return APR_ENOTIMPL;
}
static int dbd_sqlite_pvbquery(apr_pool_t * pool, apr_dbd_t * sql,
int *nrows, apr_dbd_prepared_t * statement,
va_list args)
{
return APR_ENOTIMPL;
}
static int dbd_sqlite_pbselect(apr_pool_t * pool, apr_dbd_t * sql,
apr_dbd_results_t ** results,
apr_dbd_prepared_t * statement,
int seek, const void **values)
{
return APR_ENOTIMPL;
}
static int dbd_sqlite_pvbselect(apr_pool_t * pool, apr_dbd_t * sql,
apr_dbd_results_t ** results,
apr_dbd_prepared_t * statement, int seek,
va_list args)
{
return APR_ENOTIMPL;
}
static int dbd_sqlite_start_transaction(apr_pool_t * pool, apr_dbd_t * handle,
apr_dbd_transaction_t ** trans)
{
int ret, rows;
ret = dbd_sqlite_query(handle, &rows, "BEGIN TRANSACTION");
if (ret == 0) {
if (!*trans) {
*trans = apr_pcalloc(pool, sizeof(apr_dbd_transaction_t));
}
(*trans)->handle = handle;
handle->trans = *trans;
}
else {
ret = -1;
}
return ret;
}
static int dbd_sqlite_end_transaction(apr_dbd_transaction_t * trans)
{
int rows;
int ret = -1; /* no transaction is an error cond */
if (trans) {
/* rollback on error or explicit rollback request */
if (trans->errnum || TXN_DO_ROLLBACK(trans)) {
trans->errnum = 0;
ret =
dbd_sqlite_query(trans->handle, &rows,
"ROLLBACK TRANSACTION");
}
else {
ret =
dbd_sqlite_query(trans->handle, &rows, "COMMIT TRANSACTION");
}
trans->handle->trans = NULL;
}
return ret;
}
static int dbd_sqlite_transaction_mode_get(apr_dbd_transaction_t *trans)
{
if (!trans)
return APR_DBD_TRANSACTION_COMMIT;
return trans->mode;
}
static int dbd_sqlite_transaction_mode_set(apr_dbd_transaction_t *trans,
int mode)
{
if (!trans)
return APR_DBD_TRANSACTION_COMMIT;
return trans->mode = (mode & TXN_MODE_BITS);
}
static apr_status_t error_free(void *data)
{
free(data);
return APR_SUCCESS;
}
static apr_dbd_t *dbd_sqlite_open(apr_pool_t * pool, const char *params_,
const char **error)
{
apr_dbd_t *sql;
sqlite *conn = NULL;
char *perm;
int iperms = 600;
char* params = apr_pstrdup(pool, params_);
/* params = "[filename]:[permissions]"
* example: "shopping.db:600"
*/
perm = strstr(params, ":");
if (perm) {
*(perm++) = '\x00'; /* split the filename and permissions */
if (strlen(perm) > 0)
iperms = atoi(perm);
}
if (error) {
*error = NULL;
conn = sqlite_open(params, iperms, (char **)error);
if (*error) {
apr_pool_cleanup_register(pool, *error, error_free,
apr_pool_cleanup_null);
}
}
else {
conn = sqlite_open(params, iperms, NULL);
}
sql = apr_pcalloc(pool, sizeof(*sql));
sql->conn = conn;
return sql;
}
static apr_status_t dbd_sqlite_close(apr_dbd_t * handle)
{
if (handle->conn) {
sqlite_close(handle->conn);
handle->conn = NULL;
}
return APR_SUCCESS;
}
static apr_status_t dbd_sqlite_check_conn(apr_pool_t * pool,
apr_dbd_t * handle)
{
if (handle->conn == NULL)
return -1;
return APR_SUCCESS;
}
static int dbd_sqlite_select_db(apr_pool_t * pool, apr_dbd_t * handle,
const char *name)
{
return APR_ENOTIMPL;
}
static void *dbd_sqlite_native(apr_dbd_t * handle)
{
return handle->conn;
}
static int dbd_sqlite_num_cols(apr_dbd_results_t * res)
{
return res->sz;
}
static int dbd_sqlite_num_tuples(apr_dbd_results_t * res)
{
return res->ntuples;
}
APU_MODULE_DECLARE_DATA const apr_dbd_driver_t apr_dbd_sqlite2_driver = {
"sqlite2",
NULL,
dbd_sqlite_native,
dbd_sqlite_open,
dbd_sqlite_check_conn,
dbd_sqlite_close,
dbd_sqlite_select_db,
dbd_sqlite_start_transaction,
dbd_sqlite_end_transaction,
dbd_sqlite_query,
dbd_sqlite_select,
dbd_sqlite_num_cols,
dbd_sqlite_num_tuples,
dbd_sqlite_get_row,
dbd_sqlite_get_entry,
dbd_sqlite_error,
dbd_sqlite_escape,
dbd_sqlite_prepare,
dbd_sqlite_pvquery,
dbd_sqlite_pvselect,
dbd_sqlite_pquery,
dbd_sqlite_pselect,
dbd_sqlite_get_name,
dbd_sqlite_transaction_mode_get,
dbd_sqlite_transaction_mode_set,
NULL,
dbd_sqlite_pvbquery,
dbd_sqlite_pvbselect,
dbd_sqlite_pbquery,
dbd_sqlite_pbselect,
dbd_sqlite_datum_get
};
#endif

914
contrib/apr-util/dbd/apr_dbd_sqlite3.c
View File

@ -1,914 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apu.h"
#if APU_HAVE_SQLITE3
#include <ctype.h>
#include <stdlib.h>
#include <sqlite3.h>
#include "apr_strings.h"
#include "apr_time.h"
#include "apr_buckets.h"
#include "apr_dbd_internal.h"
#define MAX_RETRY_COUNT 15
#define MAX_RETRY_SLEEP 100000
struct apr_dbd_transaction_t {
int mode;
int errnum;
apr_dbd_t *handle;
};
struct apr_dbd_t {
sqlite3 *conn;
apr_dbd_transaction_t *trans;
apr_pool_t *pool;
apr_dbd_prepared_t *prep;
};
typedef struct {
char *name;
char *value;
int size;
int type;
} apr_dbd_column_t;
struct apr_dbd_row_t {
apr_dbd_results_t *res;
apr_dbd_column_t **columns;
apr_dbd_row_t *next_row;
int columnCount;
int rownum;
};
struct apr_dbd_results_t {
int random;
sqlite3 *handle;
sqlite3_stmt *stmt;
apr_dbd_row_t *next_row;
size_t sz;
int tuples;
char **col_names;
apr_pool_t *pool;
};
struct apr_dbd_prepared_t {
sqlite3_stmt *stmt;
apr_dbd_prepared_t *next;
int nargs;
int nvals;
apr_dbd_type_e *types;
};
#define dbd_sqlite3_is_success(x) (((x) == SQLITE_DONE) || ((x) == SQLITE_OK))
static int dbd_sqlite3_select_internal(apr_pool_t *pool,
apr_dbd_t *sql,
apr_dbd_results_t **results,
sqlite3_stmt *stmt, int seek)
{
int ret, retry_count = 0, column_count;
size_t i, num_tuples = 0;
int increment = 0;
apr_dbd_row_t *row = NULL;
apr_dbd_row_t *lastrow = NULL;
apr_dbd_column_t *column;
char *hold = NULL;
column_count = sqlite3_column_count(stmt);
if (!*results) {
*results = apr_pcalloc(pool, sizeof(apr_dbd_results_t));
}
(*results)->stmt = stmt;
(*results)->sz = column_count;
(*results)->random = seek;
(*results)->next_row = 0;
(*results)->tuples = 0;
(*results)->col_names = apr_pcalloc(pool, column_count * sizeof(char *));
(*results)->pool = pool;
do {
ret = sqlite3_step(stmt);
if (ret == SQLITE_BUSY) {
if (retry_count++ > MAX_RETRY_COUNT) {
ret = SQLITE_ERROR;
} else {
apr_dbd_mutex_unlock();
apr_sleep(MAX_RETRY_SLEEP);
apr_dbd_mutex_lock();
}
} else if (ret == SQLITE_ROW) {
int length;
row = apr_palloc(pool, sizeof(apr_dbd_row_t));
row->res = *results;
increment = sizeof(apr_dbd_column_t *);
length = increment * (*results)->sz;
row->columns = apr_palloc(pool, length);
row->columnCount = column_count;
for (i = 0; i < (*results)->sz; i++) {
column = apr_palloc(pool, sizeof(apr_dbd_column_t));
row->columns[i] = column;
/* copy column name once only */
if ((*results)->col_names[i] == NULL) {
(*results)->col_names[i] =
apr_pstrdup(pool, sqlite3_column_name(stmt, i));
}
column->name = (*results)->col_names[i];
column->size = sqlite3_column_bytes(stmt, i);
column->type = sqlite3_column_type(stmt, i);
column->value = NULL;
switch (column->type) {
case SQLITE_FLOAT:
case SQLITE_INTEGER:
case SQLITE_TEXT:
hold = (char *) sqlite3_column_text(stmt, i);
if (hold) {
column->value = apr_pstrmemdup(pool, hold,
column->size);
}
break;
case SQLITE_BLOB:
hold = (char *) sqlite3_column_blob(stmt, i);
if (hold) {
column->value = apr_pstrmemdup(pool, hold,
column->size);
}
break;
case SQLITE_NULL:
break;
}
}
row->rownum = num_tuples++;
row->next_row = 0;
(*results)->tuples = num_tuples;
if ((*results)->next_row == 0) {
(*results)->next_row = row;
}
if (lastrow != 0) {
lastrow->next_row = row;
}
lastrow = row;
}
} while (ret == SQLITE_ROW || ret == SQLITE_BUSY);
if (dbd_sqlite3_is_success(ret)) {
ret = 0;
}
return ret;
}
static int dbd_sqlite3_select(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results, const char *query,
int seek)
{
sqlite3_stmt *stmt = NULL;
const char *tail = NULL;
int ret;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_prepare(sql->conn, query, strlen(query), &stmt, &tail);
if (dbd_sqlite3_is_success(ret)) {
ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
}
sqlite3_finalize(stmt);
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static const char *dbd_sqlite3_get_name(const apr_dbd_results_t *res, int n)
{
if ((n < 0) || ((size_t)n >= res->sz)) {
return NULL;
}
return res->col_names[n];
}
static int dbd_sqlite3_get_row(apr_pool_t *pool, apr_dbd_results_t *res,
apr_dbd_row_t **rowp, int rownum)
{
int i = 0;
if (rownum == -1) {
*rowp = res->next_row;
if (*rowp == 0)
return -1;
res->next_row = (*rowp)->next_row;
return 0;
}
if (rownum > res->tuples) {
return -1;
}
rownum--;
*rowp = res->next_row;
for (; *rowp != 0; i++, *rowp = (*rowp)->next_row) {
if (i == rownum) {
return 0;
}
}
return -1;
}
static const char *dbd_sqlite3_get_entry(const apr_dbd_row_t *row, int n)
{
apr_dbd_column_t *column;
const char *value;
if ((n < 0) || (n >= row->columnCount)) {
return NULL;
}
column = row->columns[n];
value = column->value;
return value;
}
static apr_status_t dbd_sqlite3_datum_get(const apr_dbd_row_t *row, int n,
apr_dbd_type_e type, void *data)
{
if ((n < 0) || ((size_t)n >= row->res->sz)) {
return APR_EGENERAL;
}
if (row->columns[n]->type == SQLITE_NULL) {
return APR_ENOENT;
}
switch (type) {
case APR_DBD_TYPE_TINY:
*(char*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_UTINY:
*(unsigned char*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_SHORT:
*(short*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_USHORT:
*(unsigned short*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_INT:
*(int*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_UINT:
*(unsigned int*)data = atoi(row->columns[n]->value);
break;
case APR_DBD_TYPE_LONG:
*(long*)data = atol(row->columns[n]->value);
break;
case APR_DBD_TYPE_ULONG:
*(unsigned long*)data = atol(row->columns[n]->value);
break;
case APR_DBD_TYPE_LONGLONG:
*(apr_int64_t*)data = apr_atoi64(row->columns[n]->value);
break;
case APR_DBD_TYPE_ULONGLONG:
*(apr_uint64_t*)data = apr_atoi64(row->columns[n]->value);
break;
case APR_DBD_TYPE_FLOAT:
*(float*)data = (float)atof(row->columns[n]->value);
break;
case APR_DBD_TYPE_DOUBLE:
*(double*)data = atof(row->columns[n]->value);
break;
case APR_DBD_TYPE_STRING:
case APR_DBD_TYPE_TEXT:
case APR_DBD_TYPE_TIME:
case APR_DBD_TYPE_DATE:
case APR_DBD_TYPE_DATETIME:
case APR_DBD_TYPE_TIMESTAMP:
case APR_DBD_TYPE_ZTIMESTAMP:
*(char**)data = row->columns[n]->value;
break;
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
apr_bucket *e;
apr_bucket_brigade *b = (apr_bucket_brigade*)data;
e = apr_bucket_pool_create(row->columns[n]->value,
row->columns[n]->size,
row->res->pool, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
}
break;
case APR_DBD_TYPE_NULL:
*(void**)data = NULL;
break;
default:
return APR_EGENERAL;
}
return APR_SUCCESS;
}
static const char *dbd_sqlite3_error(apr_dbd_t *sql, int n)
{
return sqlite3_errmsg(sql->conn);
}
static int dbd_sqlite3_query_internal(apr_dbd_t *sql, sqlite3_stmt *stmt,
int *nrows)
{
int ret = -1, retry_count = 0;
while(retry_count++ <= MAX_RETRY_COUNT) {
ret = sqlite3_step(stmt);
if (ret != SQLITE_BUSY)
break;
apr_dbd_mutex_unlock();
apr_sleep(MAX_RETRY_SLEEP);
apr_dbd_mutex_lock();
}
*nrows = sqlite3_changes(sql->conn);
if (dbd_sqlite3_is_success(ret)) {
ret = 0;
}
return ret;
}
static int dbd_sqlite3_query(apr_dbd_t *sql, int *nrows, const char *query)
{
sqlite3_stmt *stmt = NULL;
const char *tail = NULL;
int ret = -1, length = 0;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
length = strlen(query);
apr_dbd_mutex_lock();
do {
ret = sqlite3_prepare(sql->conn, query, length, &stmt, &tail);
if (ret != SQLITE_OK) {
sqlite3_finalize(stmt);
break;
}
ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
sqlite3_finalize(stmt);
length -= (tail - query);
query = tail;
} while (length > 0);
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static apr_status_t free_mem(void *data)
{
sqlite3_free(data);
return APR_SUCCESS;
}
static const char *dbd_sqlite3_escape(apr_pool_t *pool, const char *arg,
apr_dbd_t *sql)
{
char *ret = sqlite3_mprintf("%q", arg);
apr_pool_cleanup_register(pool, ret, free_mem,
apr_pool_cleanup_null);
return ret;
}
static int dbd_sqlite3_prepare(apr_pool_t *pool, apr_dbd_t *sql,
const char *query, const char *label,
int nargs, int nvals, apr_dbd_type_e *types,
apr_dbd_prepared_t **statement)
{
sqlite3_stmt *stmt;
const char *tail = NULL;
int ret;
apr_dbd_mutex_lock();
ret = sqlite3_prepare(sql->conn, query, strlen(query), &stmt, &tail);
if (ret == SQLITE_OK) {
apr_dbd_prepared_t *prep;
prep = apr_pcalloc(sql->pool, sizeof(*prep));
prep->stmt = stmt;
prep->next = sql->prep;
prep->nargs = nargs;
prep->nvals = nvals;
prep->types = types;
/* link new statement to the handle */
sql->prep = prep;
*statement = prep;
} else {
sqlite3_finalize(stmt);
}
apr_dbd_mutex_unlock();
return ret;
}
static void dbd_sqlite3_bind(apr_dbd_prepared_t *statement, const char **values)
{
sqlite3_stmt *stmt = statement->stmt;
int i, j;
for (i = 0, j = 0; i < statement->nargs; i++, j++) {
if (values[j] == NULL) {
sqlite3_bind_null(stmt, i + 1);
}
else {
switch (statement->types[i]) {
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
char *data = (char *)values[j];
int size = atoi((char*)values[++j]);
/* skip table and column */
j += 2;
sqlite3_bind_blob(stmt, i + 1, data, size, SQLITE_STATIC);
}
break;
default:
sqlite3_bind_text(stmt, i + 1, values[j],
strlen(values[j]), SQLITE_STATIC);
break;
}
}
}
return;
}
static int dbd_sqlite3_pquery(apr_pool_t *pool, apr_dbd_t *sql,
int *nrows, apr_dbd_prepared_t *statement,
const char **values)
{
sqlite3_stmt *stmt = statement->stmt;
int ret = -1;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_reset(stmt);
if (ret == SQLITE_OK) {
dbd_sqlite3_bind(statement, values);
ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
sqlite3_reset(stmt);
}
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static int dbd_sqlite3_pvquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
apr_dbd_prepared_t *statement, va_list args)
{
const char **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nvals);
for (i = 0; i < statement->nvals; i++) {
values[i] = va_arg(args, const char*);
}
return dbd_sqlite3_pquery(pool, sql, nrows, statement, values);
}
static int dbd_sqlite3_pselect(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results,
apr_dbd_prepared_t *statement, int seek,
const char **values)
{
sqlite3_stmt *stmt = statement->stmt;
int ret;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_reset(stmt);
if (ret == SQLITE_OK) {
dbd_sqlite3_bind(statement, values);
ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
sqlite3_reset(stmt);
}
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static int dbd_sqlite3_pvselect(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results,
apr_dbd_prepared_t *statement, int seek,
va_list args)
{
const char **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nvals);
for (i = 0; i < statement->nvals; i++) {
values[i] = va_arg(args, const char*);
}
return dbd_sqlite3_pselect(pool, sql, results, statement, seek, values);
}
static void dbd_sqlite3_bbind(apr_dbd_prepared_t * statement,
const void **values)
{
sqlite3_stmt *stmt = statement->stmt;
int i, j;
apr_dbd_type_e type;
for (i = 0, j = 0; i < statement->nargs; i++, j++) {
type = (values[j] == NULL ? APR_DBD_TYPE_NULL : statement->types[i]);
switch (type) {
case APR_DBD_TYPE_TINY:
sqlite3_bind_int(stmt, i + 1, *(char*)values[j]);
break;
case APR_DBD_TYPE_UTINY:
sqlite3_bind_int(stmt, i + 1, *(unsigned char*)values[j]);
break;
case APR_DBD_TYPE_SHORT:
sqlite3_bind_int(stmt, i + 1, *(short*)values[j]);
break;
case APR_DBD_TYPE_USHORT:
sqlite3_bind_int(stmt, i + 1, *(unsigned short*)values[j]);
break;
case APR_DBD_TYPE_INT:
sqlite3_bind_int(stmt, i + 1, *(int*)values[j]);
break;
case APR_DBD_TYPE_UINT:
sqlite3_bind_int(stmt, i + 1, *(unsigned int*)values[j]);
break;
case APR_DBD_TYPE_LONG:
sqlite3_bind_int64(stmt, i + 1, *(long*)values[j]);
break;
case APR_DBD_TYPE_ULONG:
sqlite3_bind_int64(stmt, i + 1, *(unsigned long*)values[j]);
break;
case APR_DBD_TYPE_LONGLONG:
sqlite3_bind_int64(stmt, i + 1, *(apr_int64_t*)values[j]);
break;
case APR_DBD_TYPE_ULONGLONG:
sqlite3_bind_int64(stmt, i + 1, *(apr_uint64_t*)values[j]);
break;
case APR_DBD_TYPE_FLOAT:
sqlite3_bind_double(stmt, i + 1, *(float*)values[j]);
break;
case APR_DBD_TYPE_DOUBLE:
sqlite3_bind_double(stmt, i + 1, *(double*)values[j]);
break;
case APR_DBD_TYPE_STRING:
case APR_DBD_TYPE_TEXT:
case APR_DBD_TYPE_TIME:
case APR_DBD_TYPE_DATE:
case APR_DBD_TYPE_DATETIME:
case APR_DBD_TYPE_TIMESTAMP:
case APR_DBD_TYPE_ZTIMESTAMP:
sqlite3_bind_text(stmt, i + 1, values[j], strlen(values[j]),
SQLITE_STATIC);
break;
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
char *data = (char*)values[j];
apr_size_t size = *(apr_size_t*)values[++j];
sqlite3_bind_blob(stmt, i + 1, data, size, SQLITE_STATIC);
/* skip table and column */
j += 2;
}
break;
case APR_DBD_TYPE_NULL:
default:
sqlite3_bind_null(stmt, i + 1);
break;
}
}
return;
}
static int dbd_sqlite3_pbquery(apr_pool_t * pool, apr_dbd_t * sql,
int *nrows, apr_dbd_prepared_t * statement,
const void **values)
{
sqlite3_stmt *stmt = statement->stmt;
int ret = -1;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_reset(stmt);
if (ret == SQLITE_OK) {
dbd_sqlite3_bbind(statement, values);
ret = dbd_sqlite3_query_internal(sql, stmt, nrows);
sqlite3_reset(stmt);
}
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static int dbd_sqlite3_pvbquery(apr_pool_t * pool, apr_dbd_t * sql,
int *nrows, apr_dbd_prepared_t * statement,
va_list args)
{
const void **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nvals);
for (i = 0; i < statement->nvals; i++) {
values[i] = va_arg(args, const void*);
}
return dbd_sqlite3_pbquery(pool, sql, nrows, statement, values);
}
static int dbd_sqlite3_pbselect(apr_pool_t * pool, apr_dbd_t * sql,
apr_dbd_results_t ** results,
apr_dbd_prepared_t * statement,
int seek, const void **values)
{
sqlite3_stmt *stmt = statement->stmt;
int ret;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
apr_dbd_mutex_lock();
ret = sqlite3_reset(stmt);
if (ret == SQLITE_OK) {
dbd_sqlite3_bbind(statement, values);
ret = dbd_sqlite3_select_internal(pool, sql, results, stmt, seek);
sqlite3_reset(stmt);
}
apr_dbd_mutex_unlock();
if (TXN_NOTICE_ERRORS(sql->trans)) {
sql->trans->errnum = ret;
}
return ret;
}
static int dbd_sqlite3_pvbselect(apr_pool_t * pool, apr_dbd_t * sql,
apr_dbd_results_t ** results,
apr_dbd_prepared_t * statement, int seek,
va_list args)
{
const void **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nvals);
for (i = 0; i < statement->nvals; i++) {
values[i] = va_arg(args, const void*);
}
return dbd_sqlite3_pbselect(pool, sql, results, statement, seek, values);
}
static int dbd_sqlite3_start_transaction(apr_pool_t *pool,
apr_dbd_t *handle,
apr_dbd_transaction_t **trans)
{
int ret = 0;
int nrows = 0;
ret = dbd_sqlite3_query(handle, &nrows, "BEGIN IMMEDIATE");
if (!*trans) {
*trans = apr_pcalloc(pool, sizeof(apr_dbd_transaction_t));
(*trans)->handle = handle;
handle->trans = *trans;
}
return ret;
}
static int dbd_sqlite3_end_transaction(apr_dbd_transaction_t *trans)
{
int ret = -1; /* ending transaction that was never started is an error */
int nrows = 0;
if (trans) {
/* rollback on error or explicit rollback request */
if (trans->errnum || TXN_DO_ROLLBACK(trans)) {
trans->errnum = 0;
ret = dbd_sqlite3_query(trans->handle, &nrows, "ROLLBACK");
} else {
ret = dbd_sqlite3_query(trans->handle, &nrows, "COMMIT");
}
trans->handle->trans = NULL;
}
return ret;
}
static int dbd_sqlite3_transaction_mode_get(apr_dbd_transaction_t *trans)
{
if (!trans)
return APR_DBD_TRANSACTION_COMMIT;
return trans->mode;
}
static int dbd_sqlite3_transaction_mode_set(apr_dbd_transaction_t *trans,
int mode)
{
if (!trans)
return APR_DBD_TRANSACTION_COMMIT;
return trans->mode = (mode & TXN_MODE_BITS);
}
static apr_dbd_t *dbd_sqlite3_open(apr_pool_t *pool, const char *params,
const char **error)
{
apr_dbd_t *sql = NULL;
sqlite3 *conn = NULL;
int sqlres;
if (!params)
return NULL;
sqlres = sqlite3_open(params, &conn);
if (sqlres != SQLITE_OK) {
if (error) {
*error = apr_pstrdup(pool, sqlite3_errmsg(conn));
}
sqlite3_close(conn);
return NULL;
}
/* should we register rand or power functions to the sqlite VM? */
sql = apr_pcalloc(pool, sizeof(*sql));
sql->conn = conn;
sql->pool = pool;
sql->trans = NULL;
return sql;
}
static apr_status_t dbd_sqlite3_close(apr_dbd_t *handle)
{
apr_dbd_prepared_t *prep = handle->prep;
/* finalize all prepared statements, or we'll get SQLITE_BUSY on close */
while (prep) {
sqlite3_finalize(prep->stmt);
prep = prep->next;
}
sqlite3_close(handle->conn);
return APR_SUCCESS;
}
static apr_status_t dbd_sqlite3_check_conn(apr_pool_t *pool,
apr_dbd_t *handle)
{
return (handle->conn != NULL) ? APR_SUCCESS : APR_EGENERAL;
}
static int dbd_sqlite3_select_db(apr_pool_t *pool, apr_dbd_t *handle,
const char *name)
{
return APR_ENOTIMPL;
}
static void *dbd_sqlite3_native(apr_dbd_t *handle)
{
return handle->conn;
}
static int dbd_sqlite3_num_cols(apr_dbd_results_t *res)
{
return res->sz;
}
static int dbd_sqlite3_num_tuples(apr_dbd_results_t *res)
{
return res->tuples;
}
APU_MODULE_DECLARE_DATA const apr_dbd_driver_t apr_dbd_sqlite3_driver = {
"sqlite3",
NULL,
dbd_sqlite3_native,
dbd_sqlite3_open,
dbd_sqlite3_check_conn,
dbd_sqlite3_close,
dbd_sqlite3_select_db,
dbd_sqlite3_start_transaction,
dbd_sqlite3_end_transaction,
dbd_sqlite3_query,
dbd_sqlite3_select,
dbd_sqlite3_num_cols,
dbd_sqlite3_num_tuples,
dbd_sqlite3_get_row,
dbd_sqlite3_get_entry,
dbd_sqlite3_error,
dbd_sqlite3_escape,
dbd_sqlite3_prepare,
dbd_sqlite3_pvquery,
dbd_sqlite3_pvselect,
dbd_sqlite3_pquery,
dbd_sqlite3_pselect,
dbd_sqlite3_get_name,
dbd_sqlite3_transaction_mode_get,
dbd_sqlite3_transaction_mode_set,
"?",
dbd_sqlite3_pvbquery,
dbd_sqlite3_pvbselect,
dbd_sqlite3_pbquery,
dbd_sqlite3_pbselect,
dbd_sqlite3_datum_get
};
#endif

296
contrib/apr-util/dbd/unsupported/NWGNUdbdfreetds
View File

@ -1,296 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
$(EOLIST)
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
ifndef EnvironmentDefined
include $(APR_WORK)/build/NWGNUhead.inc
endif
#include $(APR)\build\NWGNUcustom.inc
#
# build this level's files
#
# Make sure all needed macro's are defined
#
# LINK_STATIC = 1
# for now defined here - should finally go into build/NWGNUenvironment.inc
FREETDS_INC = $(FREETDSSDK)/include
FREETDS_IMP = $(FREETDSSDK)/lib/libfreetds.imp
FREETDS_LIB = $(FREETDSSDK)/lib/libfreetds.lib
FREETDS_NLM = libfreetds
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(APR)/include/arch/netware \
$(APR)/include \
$(APU)/include \
$(APU)/include/private \
$(APR) \
$(FREETDS_INC) \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
-DAPU_HAVE_FREETDS=1 \
-DAPU_DSO_MODULE_BUILD \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
$(EOLIST)
ifdef LINK_STATIC
XLFLAGS += \
-l $(FREETDSSDK)/lib \
$(EOLIST)
endif
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME = dbdfreetds
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION = Apache Portability Runtime Library $(VERSION_STR) DBD FreeTDS Driver Module
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME = dbdfreetds
#
# If this is specified, it will override VERSION value in
# $(AP_WORK)\build\NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE = 8192
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If these are specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled
# by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(OBJDIR)\$(NLM_NAME).nlm \
$(EOLIST)
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(OBJDIR)/apr_dbd_freetds.o \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(PRELUDE) \
$(EOLIST)
ifeq ($(LINK_STATIC),1)
FILES_nlm_libs += \
$(FREETDS_LIB) \
$(EOLIST)
endif
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
aprlib \
libc \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_modules += \
$(FREETDS_NLM) \
$(EOLIST)
endif
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
@$(APR)/aprlib.imp \
@libc.imp \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_Ximports += \
@$(FREETDS_IMP) \
$(EOLIST)
endif
#
# Any symbols exported to here
#
FILES_nlm_exports = \
apr_dbd_freetds_driver \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(AP_WORK)\build\NWGNUhead.inc for examples)
#
install :: nlms FORCE
#
# Any specialized rules here
#
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

809
contrib/apr-util/dbd/unsupported/apr_dbd_freetds.c
View File

@ -1,809 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifdef I_CAN_DEAL_WITH_THIS_PARTIAL_DRIVER_AND_UNMAINTAINED_CODE_FOR_FREETDS
#include "apu.h"
#include "apu_config.h"
/* COMPILE_STUBS: compile stubs for unimplemented functions.
*
* This is required to compile in /trunk/, but can be
* undefined to compile a driver for httpd-2.2 and other
* APR-1.2 applications
*/
#define COMPILE_STUBS
#if APU_HAVE_FREETDS
#include <ctype.h>
#include <stdlib.h>
#include "apr_strings.h"
#include "apr_lib.h"
#include "apr_pools.h"
#include "apr_dbd_internal.h"
#ifdef HAVE_FREETDS_SYBDB_H
#include <freetds/sybdb.h>
#endif
#ifdef HAVE_SYBDB_H
#include <sybdb.h>
#endif
#include <stdio.h>
#include <sys/types.h>
#include <regex.h>
/* This probably needs to change for different applications */
#define MAX_COL_LEN 256
typedef struct freetds_cell_t {
int type;
DBINT len;
BYTE *data;
} freetds_cell_t;
struct apr_dbd_transaction_t {
int mode;
int errnum;
apr_dbd_t *handle;
};
struct apr_dbd_t {
DBPROCESS *proc;
apr_dbd_transaction_t *trans;
apr_pool_t *pool;
const char *params;
RETCODE err;
};
struct apr_dbd_results_t {
int random;
size_t ntuples;
size_t sz;
apr_pool_t *pool;
DBPROCESS *proc;
};
struct apr_dbd_row_t {
apr_dbd_results_t *res;
BYTE buf[MAX_COL_LEN];
};
struct apr_dbd_prepared_t {
int nargs;
regex_t **taint;
int *sz;
char *fmt;
};
#define dbd_freetds_is_success(x) (x == SUCCEED)
static int labelnum = 0; /* FIXME */
static regex_t dbd_freetds_find_arg;
/* execute a query that doesn't return a result set, mop up,
* and return and APR-flavoured status
*/
static RETCODE freetds_exec(DBPROCESS *proc, const char *query,
int want_results, int *nrows)
{
/* TBD */
RETCODE rv = dbcmd(proc, query);
if (rv != SUCCEED) {
return rv;
}
rv = dbsqlexec(proc);
if (rv != SUCCEED) {
return rv;
}
if (!want_results) {
while (dbresults(proc) != NO_MORE_RESULTS) {
++*nrows;
}
}
return SUCCEED;
}
static apr_status_t clear_result(void *data)
{
/* clear cursor */
return (dbcanquery((DBPROCESS*)data) == SUCCEED)
? APR_SUCCESS
: APR_EGENERAL;
}
static int dbd_freetds_select(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results,
const char *query, int seek)
{
apr_dbd_results_t *res;
if (sql->trans && (sql->trans->errnum != SUCCEED)) {
return 1;
}
/* the core of this is
* dbcmd(proc, query);
* dbsqlexec(proc);
* while (dbnextrow(dbproc) != NO_MORE_ROWS) {
* do things
* }
*
* Ignore seek
*/
sql->err = freetds_exec(sql->proc, query, 1, NULL);
if (!dbd_freetds_is_success(sql->err)) {
if (sql->trans) {
sql->trans->errnum = sql->err;
}
return 1;
}
sql->err = dbresults(sql->proc);
if (sql->err != SUCCEED) {
if (sql->trans) {
sql->trans->errnum = sql->err;
}
return 1;
}
if (!*results) {
*results = apr_pcalloc(pool, sizeof(apr_dbd_results_t));
}
res = *results;
res->proc = sql->proc;
res->random = seek;
res->pool = pool;
res->ntuples = dblastrow(sql->proc);
res->sz = dbnumcols(sql->proc);
apr_pool_cleanup_register(pool, sql->proc, clear_result,
apr_pool_cleanup_null);
#if 0
/* Now we have a result set. We need to bind to its vars */
res->vars = apr_palloc(pool, res->sz * sizeof(freetds_cell_t*));
for (i=1; i <= res->sz; ++i) {
freetds_cell_t *cell = &res->vars[i-1];
cell->type = dbcoltype(sql->proc, i);
cell->len = dbcollen(sql->proc, i);
cell->data = apr_palloc(pool, cell->len);
sql->err = dbbind(sql->proc, i, /*cell->type */ STRINGBIND, cell->len, cell->data);
if (sql->err != SUCCEED) {
fprintf(stderr, "dbbind error: %d, %d, %d", i, cell->type, cell->len);
}
if ((sql->err != SUCCEED) && (sql->trans != NULL)) {
sql->trans->errnum = sql->err;
}
}
#endif
return (sql->err == SUCCEED) ? 0 : 1;
}
static const char *dbd_untaint(apr_pool_t *pool, regex_t *rx, const char *val)
{
regmatch_t match[1];
if (rx == NULL) {
/* no untaint expression */
return val;
}
if (regexec(rx, val, 1, match, 0) == 0) {
return apr_pstrndup(pool, val+match[0].rm_so,
match[0].rm_eo - match[0].rm_so);
}
return "";
}
static const char *dbd_statement(apr_pool_t *pool,
apr_dbd_prepared_t *stmt,
int nargs, const char **args)
{
int i;
int len;
const char *var;
char *ret;
const char *p_in;
char *p_out;
char *q;
/* compute upper bound on length (since untaint shrinks) */
len = strlen(stmt->fmt) +1;
for (i=0; i<nargs; ++i) {
len += strlen(args[i]) - 2;
}
i = 0;
p_in = stmt->fmt;
p_out = ret = apr_palloc(pool, len);
/* FIXME silly bug - this'll catch %%s */
while (q = strstr(p_in, "%s"), q != NULL) {
len = q-p_in;
strncpy(p_out, p_in, len);
p_in += len;
p_out += len;
var = dbd_untaint(pool, stmt->taint[i], args[i]);
len = strlen(var);
strncpy(p_out, var, len);
p_in += 2;
p_out += len;
++i;
}
strcpy(p_out, p_in);
return ret;
}
static int dbd_freetds_pselect(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results,
apr_dbd_prepared_t *statement,
int seek, const char **values)
{
const char *query = dbd_statement(pool, statement,
statement->nargs, values);
return dbd_freetds_select(pool, sql, results, query, seek);
}
static int dbd_freetds_pvselect(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results,
apr_dbd_prepared_t *statement,
int seek, va_list args)
{
const char **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nargs);
for (i = 0; i < statement->nargs; i++) {
values[i] = va_arg(args, const char*);
}
return dbd_freetds_pselect(pool, sql, results, statement, seek, values);
}
static int dbd_freetds_query(apr_dbd_t *sql, int *nrows, const char *query);
static int dbd_freetds_pquery(apr_pool_t *pool, apr_dbd_t *sql,
int *nrows, apr_dbd_prepared_t *statement,
const char **values)
{
const char *query = dbd_statement(pool, statement,
statement->nargs, values);
return dbd_freetds_query(sql, nrows, query);
}
static int dbd_freetds_pvquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
apr_dbd_prepared_t *statement, va_list args)
{
const char **values;
int i;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
values = apr_palloc(pool, sizeof(*values) * statement->nargs);
for (i = 0; i < statement->nargs; i++) {
values[i] = va_arg(args, const char*);
}
return dbd_freetds_pquery(pool, sql, nrows, statement, values);
}
static int dbd_freetds_get_row(apr_pool_t *pool, apr_dbd_results_t *res,
apr_dbd_row_t **rowp, int rownum)
{
RETCODE rv = 0;
apr_dbd_row_t *row = *rowp;
int sequential = ((rownum >= 0) && res->random) ? 0 : 1;
if (row == NULL) {
row = apr_palloc(pool, sizeof(apr_dbd_row_t));
*rowp = row;
row->res = res;
}
/*
else {
if ( sequential ) {
++row->n;
}
else {
row->n = rownum;
}
}
*/
if (sequential) {
rv = dbnextrow(res->proc);
}
else {
rv = (rownum >= 0) ? dbgetrow(res->proc, rownum) : NO_MORE_ROWS;
}
switch (rv) {
case SUCCEED: return 0;
case REG_ROW: return 0;
case NO_MORE_ROWS:
apr_pool_cleanup_run(res->pool, res->proc, clear_result);
*rowp = NULL;
return -1;
case FAIL: return 1;
case BUF_FULL: return 2; /* FIXME */
default: return 3;
}
return 0;
}
static const char *dbd_freetds_get_entry(const apr_dbd_row_t *row, int n)
{
/* FIXME: support different data types */
/* this fails - bind gets some vars but not others
return (const char*)row->res->vars[n].data;
*/
DBPROCESS* proc = row->res->proc;
BYTE *ptr = dbdata(proc, n+1);
int t = dbcoltype(proc, n+1);
int l = dbcollen(proc, n+1);
if (dbwillconvert(t, SYBCHAR)) {
dbconvert(proc, t, ptr, l, SYBCHAR, (BYTE *)row->buf, -1);
return (const char*)row->buf;
}
return (char*)ptr;
}
static const char *dbd_freetds_error(apr_dbd_t *sql, int n)
{
/* XXX this doesn't seem to exist in the API ??? */
return apr_psprintf(sql->pool, "Error %d", sql->err);
}
static int dbd_freetds_query(apr_dbd_t *sql, int *nrows, const char *query)
{
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
*nrows = 0;
sql->err = freetds_exec(sql->proc, query, 0, nrows);
if (sql->err != SUCCEED) {
if (sql->trans) {
sql->trans->errnum = sql->err;
}
return 1;
}
return 0;
}
static const char *dbd_freetds_escape(apr_pool_t *pool, const char *arg,
apr_dbd_t *sql)
{
return arg;
}
static apr_status_t freetds_regfree(void *rx)
{
regfree((regex_t*)rx);
return APR_SUCCESS;
}
static int recurse_args(apr_pool_t *pool, int n, const char *query,
apr_dbd_prepared_t *stmt, int offs)
{
/* we only support %s arguments for now */
int ret;
char arg[256];
regmatch_t matches[3];
if (regexec(&dbd_freetds_find_arg, query, 3, matches, 0) != 0) {
/* No more args */
stmt->nargs = n;
stmt->taint = apr_palloc(pool, n*sizeof(regex_t*));
stmt->sz = apr_palloc(pool, n*sizeof(int));
ret = 0;
}
else {
int i;
int sz = 0;
int len = matches[1].rm_eo - matches[1].rm_so - 2;
if (len > 255) {
return 9999;
}
ret = recurse_args(pool, n+1, query+matches[0].rm_eo,
stmt, offs+matches[0].rm_eo);
memmove(stmt->fmt + offs + matches[1].rm_so,
stmt->fmt + offs + matches[0].rm_eo-1,
strlen(stmt->fmt+offs+matches[0].rm_eo)+2);
/* compile untaint to a regex if found */
if (matches[1].rm_so == -1) {
stmt->taint[n] = NULL;
}
else {
strncpy(arg, query+matches[1].rm_so+1,
matches[1].rm_eo - matches[1].rm_so - 2);
arg[matches[1].rm_eo - matches[1].rm_so - 2] = '\0';
stmt->taint[n] = apr_palloc(pool, sizeof(regex_t));
if (regcomp(stmt->taint[n], arg, REG_ICASE|REG_EXTENDED) != 0) {
++ret;
}
else {
apr_pool_cleanup_register(pool, stmt->taint[n], freetds_regfree,
apr_pool_cleanup_null);
}
}
/* record length if specified */
for (i=matches[2].rm_so; i<matches[2].rm_eo; ++i) {
sz = 10*sz + (query[i]-'\0');
}
}
return ret;
}
static int dbd_freetds_prepare(apr_pool_t *pool, apr_dbd_t *sql,
const char *query, const char *label,
int nargs, int nvals, apr_dbd_type_e *types,
apr_dbd_prepared_t **statement)
{
apr_dbd_prepared_t *stmt;
if (label == NULL) {
label = apr_psprintf(pool, "%d", labelnum++);
}
if (!*statement) {
*statement = apr_palloc(pool, sizeof(apr_dbd_prepared_t));
}
stmt = *statement;
#if 0
/* count args */
stmt->fmt = apr_pstrdup(pool, query);
stmt->fmt = recurse_args(pool, 0, query, stmt, stmt->fmt);
/* overestimate by a byte or two to simplify */
len = strlen("CREATE PROC apr.")
+ strlen(label)
+ stmt->nargs * strlen(" @arg1 varchar(len1),")
+ strlen(" AS begin ")
+ strlen(stmt->fmt)
+ strlen(" end "); /* extra byte for terminator */
pquery = apr_pcalloc(pool, len);
sprintf(pquery, "CREATE PROC apr.%s", label);
for (i=0; i<stmt->nargs; ++i) {
sprintf(pquery+strlen(pquery), " @arg%d varchar(%d)", i, stmt->sz[i]);
if (i < stmt->nargs-1) {
pquery[strlen(pquery)] = ',';
}
}
strcat(pquery, " AS BEGIN ");
strcat(pquery, stmt->fmt);
strcat(pquery, " END");
return (freetds_exec(sql->proc, pquery, 0, &i) == SUCCEED) ? 0 : 1;
#else
stmt->fmt = apr_pstrdup(pool, query);
return recurse_args(pool, 0, query, stmt, 0);
#endif
}
static int dbd_freetds_start_transaction(apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_transaction_t **trans)
{
int dummy;
/* XXX handle recursive transactions here */
handle->err = freetds_exec(handle->proc, "BEGIN TRANSACTION", 0, &dummy);
if (dbd_freetds_is_success(handle->err)) {
if (!*trans) {
*trans = apr_pcalloc(pool, sizeof(apr_dbd_transaction_t));
}
(*trans)->handle = handle;
handle->trans = *trans;
return 0;
}
return 1;
}
static int dbd_freetds_end_transaction(apr_dbd_transaction_t *trans)
{
int dummy;
if (trans) {
/* rollback on error or explicit rollback request */
if (trans->errnum) {
trans->errnum = 0;
trans->handle->err = freetds_exec(trans->handle->proc,
"ROLLBACK", 0, &dummy);
}
else {
trans->handle->err = freetds_exec(trans->handle->proc,
"COMMIT", 0, &dummy);
}
trans->handle->trans = NULL;
}
return (trans->handle->err == SUCCEED) ? 0 : 1;
}
static DBPROCESS *freetds_open(apr_pool_t *pool, const char *params,
const char **error)
{
char *server = NULL;
DBPROCESS *process;
LOGINREC *login;
static const char *delims = " \r\n\t;|,";
char *ptr;
char *key;
char *value;
int vlen;
int klen;
char *buf;
char *databaseName = NULL;
/* FIXME - this uses malloc */
/* FIXME - pass error message back to the caller in case of failure */
login = dblogin();
if (login == NULL) {
return NULL;
}
/* now set login properties */
for (ptr = strchr(params, '='); ptr; ptr = strchr(ptr, '=')) {
/* don't dereference memory that may not belong to us */
if (ptr == params) {
++ptr;
continue;
}
for (key = ptr-1; apr_isspace(*key); --key);
klen = 0;
while (apr_isalpha(*key)) {
--key;
++klen;
}
++key;
for (value = ptr+1; apr_isspace(*value); ++value);
vlen = strcspn(value, delims);
buf = apr_pstrndup(pool, value, vlen); /* NULL-terminated copy */
if (!strncasecmp(key, "username", klen)) {
DBSETLUSER(login, buf);
}
else if (!strncasecmp(key, "password", klen)) {
DBSETLPWD(login, buf);
}
else if (!strncasecmp(key, "appname", klen)) {
DBSETLAPP(login, buf);
}
else if (!strncasecmp(key, "dbname", klen)) {
databaseName = buf;
}
else if (!strncasecmp(key, "host", klen)) {
DBSETLHOST(login, buf);
}
else if (!strncasecmp(key, "charset", klen)) {
DBSETLCHARSET(login, buf);
}
else if (!strncasecmp(key, "lang", klen)) {
DBSETLNATLANG(login, buf);
}
else if (!strncasecmp(key, "server", klen)) {
server = buf;
}
else {
/* unknown param */
}
ptr = value+vlen;
}
process = dbopen(login, server);
if (process != NULL && databaseName != NULL)
{
dbuse(process, databaseName);
}
dbloginfree(login);
if (process == NULL) {
return NULL;
}
return process;
}
static apr_dbd_t *dbd_freetds_open(apr_pool_t *pool, const char *params,
const char **error)
{
apr_dbd_t *sql;
/* FIXME - pass error message back to the caller in case of failure */
DBPROCESS *process = freetds_open(pool, params, error);
if (process == NULL) {
return NULL;
}
sql = apr_pcalloc(pool, sizeof (apr_dbd_t));
sql->pool = pool;
sql->proc = process;
sql->params = params;
return sql;
}
static apr_status_t dbd_freetds_close(apr_dbd_t *handle)
{
dbclose(handle->proc);
return APR_SUCCESS;
}
static apr_status_t dbd_freetds_check_conn(apr_pool_t *pool,
apr_dbd_t *handle)
{
if (dbdead(handle->proc)) {
/* try again */
dbclose(handle->proc);
handle->proc = freetds_open(handle->pool, handle->params, NULL);
if (!handle->proc || dbdead(handle->proc)) {
return APR_EGENERAL;
}
}
/* clear it, in case this is called in error handling */
dbcancel(handle->proc);
return APR_SUCCESS;
}
static int dbd_freetds_select_db(apr_pool_t *pool, apr_dbd_t *handle,
const char *name)
{
/* ouch, it's declared int. But we can use APR 0/nonzero */
return (dbuse(handle->proc, (char*)name) == SUCCEED) ? APR_SUCCESS : APR_EGENERAL;
}
static void *dbd_freetds_native(apr_dbd_t *handle)
{
return handle->proc;
}
static int dbd_freetds_num_cols(apr_dbd_results_t* res)
{
return res->sz;
}
static int dbd_freetds_num_tuples(apr_dbd_results_t* res)
{
if (res->random) {
return res->ntuples;
}
else {
return -1;
}
}
static apr_status_t freetds_term(void *dummy)
{
dbexit();
regfree(&dbd_freetds_find_arg);
return APR_SUCCESS;
}
static int freetds_err_handler(DBPROCESS *dbproc, int severity, int dberr,
int oserr, char *dberrstr, char *oserrstr)
{
return INT_CANCEL; /* never exit */
}
static void dbd_freetds_init(apr_pool_t *pool)
{
int rv = regcomp(&dbd_freetds_find_arg,
"%(\\{[^}]*\\})?([0-9]*)[A-Za-z]", REG_EXTENDED);
if (rv != 0) {
char errmsg[256];
regerror(rv, &dbd_freetds_find_arg, errmsg, 256);
fprintf(stderr, "regcomp failed: %s\n", errmsg);
}
dbinit();
dberrhandle(freetds_err_handler);
apr_pool_cleanup_register(pool, NULL, freetds_term, apr_pool_cleanup_null);
}
#ifdef COMPILE_STUBS
/* get_name is the only one of these that is implemented */
static const char *dbd_freetds_get_name(const apr_dbd_results_t *res, int n)
{
return (const char*) dbcolname(res->proc, n+1); /* numbering starts at 1 */
}
/* These are stubs: transaction modes not implemented here */
#define DBD_NOTIMPL APR_ENOTIMPL;
static int dbd_freetds_transaction_mode_get(apr_dbd_transaction_t *trans)
{
return trans ? trans->mode : APR_DBD_TRANSACTION_COMMIT;
}
static int dbd_freetds_transaction_mode_set(apr_dbd_transaction_t *trans,
int mode)
{
if (trans) {
trans->mode = mode & TXN_MODE_BITS;
return trans->mode;
}
return APR_DBD_TRANSACTION_COMMIT;
}
static int dbd_freetds_pvbquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
apr_dbd_prepared_t *statement, va_list args)
{
return DBD_NOTIMPL;
}
static int dbd_freetds_pbquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
apr_dbd_prepared_t * statement,
const void **values)
{
return DBD_NOTIMPL;
}
static int dbd_freetds_pvbselect(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results,
apr_dbd_prepared_t *statement,
int seek, va_list args)
{
return DBD_NOTIMPL;
}
static int dbd_freetds_pbselect(apr_pool_t *pool, apr_dbd_t *sql,
apr_dbd_results_t **results,
apr_dbd_prepared_t *statement,
int seek, const void **values)
{
return DBD_NOTIMPL;
}
static apr_status_t dbd_freetds_datum_get(const apr_dbd_row_t *row, int n,
apr_dbd_type_e type, void *data)
{
return APR_ENOTIMPL;
}
#endif
APU_MODULE_DECLARE_DATA const apr_dbd_driver_t apr_dbd_freetds_driver = {
"freetds",
dbd_freetds_init,
dbd_freetds_native,
dbd_freetds_open,
dbd_freetds_check_conn,
dbd_freetds_close,
dbd_freetds_select_db,
dbd_freetds_start_transaction,
dbd_freetds_end_transaction,
dbd_freetds_query,
dbd_freetds_select,
dbd_freetds_num_cols,
dbd_freetds_num_tuples,
dbd_freetds_get_row,
dbd_freetds_get_entry,
dbd_freetds_error,
dbd_freetds_escape,
dbd_freetds_prepare,
dbd_freetds_pvquery,
dbd_freetds_pvselect,
dbd_freetds_pquery,
dbd_freetds_pselect,
/* this is only implemented to support httpd/2.2 standard usage,
* as in the original DBD implementation. Everything else is NOTIMPL.
*/
#ifdef COMPILE_STUBS
dbd_freetds_get_name,
dbd_freetds_transaction_mode_get,
dbd_freetds_transaction_mode_set,
"",
dbd_freetds_pvbquery,
dbd_freetds_pvbselect,
dbd_freetds_pbquery,
dbd_freetds_pbselect,
dbd_freetds_datum_get
#endif
};
#endif
#endif

299
contrib/apr-util/dbm/NWGNUdbmdb
View File

@ -1,299 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
$(EOLIST)
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
ifndef EnvironmentDefined
include $(APR_WORK)/build/NWGNUhead.inc
endif
#
# build this level's files
#
# Make sure all needed macro's are defined
#
# LINK_STATIC = 1
# for now defined here - should finally go into build/NWGNUenvironment.inc
DB_INC = $(DBSDK)/inc
DB_IMP = libdb47.imp
DB_LIB = libdb47.lib
DB_NLM = libdb47
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(APR)/include/arch/netware \
$(APR)/include \
$(APU)/include \
$(APU)/include/private \
$(APR) \
$(DB_INC) \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
-DAPU_DSO_MODULE_BUILD \
-DAPU_HAVE_DB=1 \
-DAPU_HAVE_DB_VERSION=4 \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
$(EOLIST)
ifdef LINK_STATIC
XLFLAGS += \
-l $(DBSDK)/lib \
$(EOLIST)
else
XLFLAGS += \
-l $(DBSDK)/imp \
$(EOLIST)
endif
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME = dbmdb
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION = Apache Portability Runtime Library $(VERSION_STR) DBM Berkeley DB Driver Module
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME = dbmdb
#
# If this is specified, it will override VERSION value in
# $(AP_WORK)\build\NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE = 8192
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If these are specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled
# by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(OBJDIR)\$(NLM_NAME).nlm \
$(EOLIST)
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(OBJDIR)/apr_dbm_berkeleydb.o \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(PRELUDE) \
$(EOLIST)
ifeq ($(LINK_STATIC),1)
FILES_nlm_libs += \
$(DB_LIB) \
$(EOLIST)
endif
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
aprlib \
libc \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_modules += \
$(DB_NLM) \
$(EOLIST)
endif
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
@aprlib.imp \
@libc.imp \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_Ximports += \
@$(DB_IMP) \
$(EOLIST)
endif
#
# Any symbols exported to here
#
FILES_nlm_exports = \
apr_dbm_type_db \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(AP_WORK)\build\NWGNUhead.inc for examples)
#
install :: nlms FORCE
#
# Any specialized rules here
#
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

298
contrib/apr-util/dbm/NWGNUdbmgdbm
View File

@ -1,298 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
$(EOLIST)
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
ifndef EnvironmentDefined
include $(APR_WORK)/build/NWGNUhead.inc
endif
#
# build this level's files
#
# Make sure all needed macro's are defined
#
# LINK_STATIC = 1
# for now defined here - should finally go into build/NWGNUenvironment.inc
GDBM_INC = $(GDBMSDK)/inc
GDBM_IMP = libgdbm.imp
GDBM_LIB = libgdbm.lib
GDBM_NLM = libgdbm
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(APR)/include/arch/netware \
$(APR)/include \
$(APU)/include \
$(APU)/include/private \
$(APR) \
$(GDBM_INC) \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
-DAPU_DSO_MODULE_BUILD \
-DAPU_HAVE_GDBM=1 \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
$(EOLIST)
ifdef LINK_STATIC
XLFLAGS += \
-l $(GDBMSDK)/lib \
$(EOLIST)
else
XLFLAGS += \
-l $(GDBMSDK)/imp \
$(EOLIST)
endif
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME = dbmgdbm
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION = Apache Portability Runtime Library $(VERSION_STR) GDBM Driver Module
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME = dbmgdbm
#
# If this is specified, it will override VERSION value in
# $(AP_WORK)\build\NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE = 8192
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If these are specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled
# by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(OBJDIR)\$(NLM_NAME).nlm \
$(EOLIST)
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(OBJDIR)/apr_dbm_gdbm.o \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(PRELUDE) \
$(EOLIST)
ifeq ($(LINK_STATIC),1)
FILES_nlm_libs += \
$(GDBM_LIB) \
$(EOLIST)
endif
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
aprlib \
libc \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_modules += \
$(GDBM_NLM) \
$(EOLIST)
endif
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
@aprlib.imp \
@libc.imp \
$(EOLIST)
ifneq ($(LINK_STATIC),1)
FILES_nlm_Ximports += \
@$(GDBM_IMP) \
$(EOLIST)
endif
#
# Any symbols exported to here
#
FILES_nlm_exports = \
apr_dbm_type_gdbm \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(AP_WORK)\build\NWGNUhead.inc for examples)
#
install :: nlms FORCE
#
# Any specialized rules here
#
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

251
contrib/apr-util/dbm/NWGNUmakefile
View File

@ -1,251 +0,0 @@
#
# Declare the sub-directories to be built here
#
SUBDIRS = \
$(EOLIST)
#
# Get the 'head' of the build environment. This includes default targets and
# paths to tools
#
include $(APR_WORK)/build/NWGNUhead.inc
#
# build this level's files
#
# Make sure all needed macro's are defined
#
#
# These directories will be at the beginning of the include list, followed by
# INCDIRS
#
XINCDIRS += \
$(EOLIST)
#
# These flags will come after CFLAGS
#
XCFLAGS += \
$(EOLIST)
#
# These defines will come after DEFINES
#
XDEFINES += \
$(EOLIST)
#
# These flags will be added to the link.opt file
#
XLFLAGS += \
$(EOLIST)
#
# These values will be appended to the correct variables based on the value of
# RELEASE
#
ifeq "$(RELEASE)" "debug"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "noopt"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
ifeq "$(RELEASE)" "release"
XINCDIRS += \
$(EOLIST)
XCFLAGS += \
$(EOLIST)
XDEFINES += \
$(EOLIST)
XLFLAGS += \
$(EOLIST)
endif
#
# These are used by the link target if an NLM is being generated
# This is used by the link 'name' directive to name the nlm. If left blank
# TARGET_nlm (see below) will be used.
#
NLM_NAME =
#
# This is used by the link '-desc ' directive.
# If left blank, NLM_NAME will be used.
#
NLM_DESCRIPTION =
#
# This is used by the '-threadname' directive. If left blank,
# NLM_NAME Thread will be used.
#
NLM_THREAD_NAME =
#
# If this is specified, it will override VERSION value in
# $(AP_WORK)\build\NWGNUenvironment.inc
#
NLM_VERSION =
#
# If this is specified, it will override the default of 64K
#
NLM_STACK_SIZE =
#
# If this is specified it will be used by the link '-entry' directive
#
NLM_ENTRY_SYM =
#
# If this is specified it will be used by the link '-exit' directive
#
NLM_EXIT_SYM =
#
# If this is specified it will be used by the link '-check' directive
#
NLM_CHECK_SYM =
#
# If these are specified it will be used by the link '-flags' directive
#
NLM_FLAGS =
#
# If this is specified it will be linked in with the XDCData option in the def
# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled
# by setting APACHE_UNIPROC in the environment
#
XDCDATA =
#
# If there is an NLM target, put it here
#
TARGET_nlm = \
$(EOLIST)
ifeq "$(APU_HAVE_DB)" "1"
TARGET_nlm += $(OBJDIR)/dbmdb.nlm $(OBJDIR)/dbmdb.nlm $(EOLIST)
endif
ifeq "$(APU_HAVE_GDBM)" "1"
TARGET_nlm += $(OBJDIR)/dbmgdbm.nlm $(OBJDIR)/dbmgdbm.nlm $(EOLIST)
endif
#
# If there is an LIB target, put it here
#
TARGET_lib = \
$(EOLIST)
#
# These are the OBJ files needed to create the NLM target above.
# Paths must all use the '/' character
#
FILES_nlm_objs = \
$(EOLIST)
#
# These are the LIB files needed to create the NLM target above.
# These will be added as a library command in the link.opt file.
#
FILES_nlm_libs = \
$(EOLIST)
#
# These are the modules that the above NLM target depends on to load.
# These will be added as a module command in the link.opt file.
#
FILES_nlm_modules = \
$(EOLIST)
#
# If the nlm has a msg file, put it's path here
#
FILE_nlm_msg =
#
# If the nlm has a hlp file put it's path here
#
FILE_nlm_hlp =
#
# If this is specified, it will override $(NWOS)\copyright.txt.
#
FILE_nlm_copyright =
#
# Any additional imports go here
#
FILES_nlm_Ximports = \
$(EOLIST)
#
# Any symbols exported to here
#
FILES_nlm_exports = \
$(EOLIST)
#
# These are the OBJ files needed to create the LIB target above.
# Paths must all use the '/' character
#
FILES_lib_objs = \
$(EOLIST)
#
# implement targets and dependancies (leave this section alone)
#
libs :: $(OBJDIR) $(TARGET_lib)
nlms :: libs $(TARGET_nlm)
#
# Updated this target to create necessary directories and copy files to the
# correct place. (See $(AP_WORK)\build\NWGNUhead.inc for examples)
#
install :: nlms $(INSTDIRS) FORCE
$(call COPY,$(OBJDIR)/*.nlm,$(INSTALLBASE))
#
# Any specialized rules here
#
#
# Include the 'tail' makefile that has targets that depend on variables defined
# in this makefile
#
include $(APRBUILD)/NWGNUtail.inc

307
contrib/apr-util/dbm/apr_dbm.c
View File

@ -1,307 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr.h"
#include "apr_dso.h"
#include "apr_hash.h"
#include "apr_errno.h"
#include "apr_pools.h"
#include "apr_strings.h"
#define APR_WANT_MEMFUNC
#define APR_WANT_STRFUNC
#include "apr_want.h"
#include "apr_general.h"
#include "apr_atomic.h"
#include "apu_config.h"
#include "apu.h"
#include "apu_internal.h"
#include "apu_version.h"
#include "apr_dbm_private.h"
#include "apu_select_dbm.h"
#include "apr_dbm.h"
#include "apr_dbm_private.h"
/* ### note: the setting of DBM_VTABLE will go away once we have multiple
### DBMs in here.
### Well, that day is here. So, do we remove DBM_VTABLE and the old
### API entirely? Oh, what to do. We need an APU_DEFAULT_DBM #define.
### Sounds like a job for autoconf. */
#if APU_USE_DB
#define DBM_VTABLE apr_dbm_type_db
#define DBM_NAME "db"
#elif APU_USE_GDBM
#define DBM_VTABLE apr_dbm_type_gdbm
#define DBM_NAME "gdbm"
#elif APU_USE_NDBM
#define DBM_VTABLE apr_dbm_type_ndbm
#define DBM_NAME "ndbm"
#elif APU_USE_SDBM
#define DBM_VTABLE apr_dbm_type_sdbm
#define DBM_NAME "sdbm"
#else /* Not in the USE_xDBM list above */
#error a DBM implementation was not specified
#endif
#if APU_DSO_BUILD
static apr_hash_t *drivers = NULL;
static apr_uint32_t initialised = 0, in_init = 1;
static apr_status_t dbm_term(void *ptr)
{
/* set drivers to NULL so init can work again */
drivers = NULL;
/* Everything else we need is handled by cleanups registered
* when we created mutexes and loaded DSOs
*/
return APR_SUCCESS;
}
#endif /* APU_DSO_BUILD */
static apr_status_t dbm_open_type(apr_dbm_type_t const* * vtable,
const char *type,
apr_pool_t *pool)
{
#if !APU_DSO_BUILD
*vtable = NULL;
if (!strcasecmp(type, "default")) *vtable = &DBM_VTABLE;
#if APU_HAVE_DB
else if (!strcasecmp(type, "db")) *vtable = &apr_dbm_type_db;
#endif
else if (*type && !strcasecmp(type + 1, "dbm")) {
#if APU_HAVE_GDBM
if (*type == 'G' || *type == 'g') *vtable = &apr_dbm_type_gdbm;
#endif
#if APU_HAVE_NDBM
if (*type == 'N' || *type == 'n') *vtable = &apr_dbm_type_ndbm;
#endif
#if APU_HAVE_SDBM
if (*type == 'S' || *type == 's') *vtable = &apr_dbm_type_sdbm;
#endif
/* avoid empty block */ ;
}
if (*vtable)
return APR_SUCCESS;
return APR_ENOTIMPL;
#else /* APU_DSO_BUILD */
char modname[32];
char symname[34];
apr_dso_handle_sym_t symbol;
apr_status_t rv;
int usertype = 0;
if (!strcasecmp(type, "default")) type = DBM_NAME;
else if (!strcasecmp(type, "db")) type = "db";
else if (*type && !strcasecmp(type + 1, "dbm")) {
if (*type == 'G' || *type == 'g') type = "gdbm";
else if (*type == 'N' || *type == 'n') type = "ndbm";
else if (*type == 'S' || *type == 's') type = "sdbm";
}
else usertype = 1;
if (apr_atomic_inc32(&initialised)) {
apr_atomic_set32(&initialised, 1); /* prevent wrap-around */
while (apr_atomic_read32(&in_init)) /* wait until we get fully inited */
;
}
else {
apr_pool_t *parent;
/* Top level pool scope, need process-scope lifetime */
for (parent = apr_pool_parent_get(pool);
parent && parent != pool;
parent = apr_pool_parent_get(pool))
pool = parent;
/* deprecate in 2.0 - permit implicit initialization */
apu_dso_init(pool);
drivers = apr_hash_make(pool);
apr_hash_set(drivers, "sdbm", APR_HASH_KEY_STRING, &apr_dbm_type_sdbm);
apr_pool_cleanup_register(pool, NULL, dbm_term,
apr_pool_cleanup_null);
apr_atomic_dec32(&in_init);
}
rv = apu_dso_mutex_lock();
if (rv) {
*vtable = NULL;
return rv;
}
*vtable = apr_hash_get(drivers, type, APR_HASH_KEY_STRING);
if (*vtable) {
apu_dso_mutex_unlock();
return APR_SUCCESS;
}
/* The driver DSO must have exactly the same lifetime as the
* drivers hash table; ignore the passed-in pool */
pool = apr_hash_pool_get(drivers);
#if defined(NETWARE)
apr_snprintf(modname, sizeof(modname), "dbm%s.nlm", type);
#elif defined(WIN32) || defined (__CYGWIN__)
apr_snprintf(modname, sizeof(modname),
"apr_dbm_%s-" APU_STRINGIFY(APU_MAJOR_VERSION) ".dll", type);
#else
apr_snprintf(modname, sizeof(modname),
"apr_dbm_%s-" APU_STRINGIFY(APU_MAJOR_VERSION) ".so", type);
#endif
apr_snprintf(symname, sizeof(symname), "apr_dbm_type_%s", type);
rv = apu_dso_load(NULL, &symbol, modname, symname, pool);
if (rv == APR_SUCCESS || rv == APR_EINIT) { /* previously loaded?!? */
*vtable = symbol;
if (usertype)
type = apr_pstrdup(pool, type);
apr_hash_set(drivers, type, APR_HASH_KEY_STRING, *vtable);
rv = APR_SUCCESS;
}
else
*vtable = NULL;
apu_dso_mutex_unlock();
return rv;
#endif /* APU_DSO_BUILD */
}
APU_DECLARE(apr_status_t) apr_dbm_open_ex(apr_dbm_t **pdb, const char *type,
const char *pathname,
apr_int32_t mode,
apr_fileperms_t perm,
apr_pool_t *pool)
{
apr_dbm_type_t const* vtable = NULL;
apr_status_t rv = dbm_open_type(&vtable, type, pool);
if (rv == APR_SUCCESS) {
rv = (vtable->open)(pdb, pathname, mode, perm, pool);
}
return rv;
}
APU_DECLARE(apr_status_t) apr_dbm_open(apr_dbm_t **pdb, const char *pathname,
apr_int32_t mode, apr_fileperms_t perm,
apr_pool_t *pool)
{
return apr_dbm_open_ex(pdb, DBM_NAME, pathname, mode, perm, pool);
}
APU_DECLARE(void) apr_dbm_close(apr_dbm_t *dbm)
{
(*dbm->type->close)(dbm);
}
APU_DECLARE(apr_status_t) apr_dbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t *pvalue)
{
return (*dbm->type->fetch)(dbm, key, pvalue);
}
APU_DECLARE(apr_status_t) apr_dbm_store(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t value)
{
return (*dbm->type->store)(dbm, key, value);
}
APU_DECLARE(apr_status_t) apr_dbm_delete(apr_dbm_t *dbm, apr_datum_t key)
{
return (*dbm->type->del)(dbm, key);
}
APU_DECLARE(int) apr_dbm_exists(apr_dbm_t *dbm, apr_datum_t key)
{
return (*dbm->type->exists)(dbm, key);
}
APU_DECLARE(apr_status_t) apr_dbm_firstkey(apr_dbm_t *dbm, apr_datum_t *pkey)
{
return (*dbm->type->firstkey)(dbm, pkey);
}
APU_DECLARE(apr_status_t) apr_dbm_nextkey(apr_dbm_t *dbm, apr_datum_t *pkey)
{
return (*dbm->type->nextkey)(dbm, pkey);
}
APU_DECLARE(void) apr_dbm_freedatum(apr_dbm_t *dbm, apr_datum_t data)
{
(*dbm->type->freedatum)(dbm, data);
}
APU_DECLARE(char *) apr_dbm_geterror(apr_dbm_t *dbm, int *errcode,
char *errbuf, apr_size_t errbufsize)
{
if (errcode != NULL)
*errcode = dbm->errcode;
/* assert: errbufsize > 0 */
if (dbm->errmsg == NULL)
*errbuf = '\0';
else
(void) apr_cpystrn(errbuf, dbm->errmsg, errbufsize);
return errbuf;
}
APU_DECLARE(apr_status_t) apr_dbm_get_usednames_ex(apr_pool_t *p,
const char *type,
const char *pathname,
const char **used1,
const char **used2)
{
apr_dbm_type_t const* vtable;
apr_status_t rv = dbm_open_type(&vtable, type, p);
if (rv == APR_SUCCESS) {
(vtable->getusednames)(p, pathname, used1, used2);
return APR_SUCCESS;
}
return rv;
}
APU_DECLARE(void) apr_dbm_get_usednames(apr_pool_t *p,
const char *pathname,
const char **used1,
const char **used2)
{
apr_dbm_get_usednames_ex(p, DBM_NAME, pathname, used1, used2);
}
/* Most DBM libraries take a POSIX mode for creating files. Don't trust
* the mode_t type, some platforms may not support it, int is safe.
*/
APU_DECLARE(int) apr_posix_perms2mode(apr_fileperms_t perm)
{
int mode = 0;
mode |= 0700 & (perm >> 2); /* User is off-by-2 bits */
mode |= 0070 & (perm >> 1); /* Group is off-by-1 bit */
mode |= 0007 & (perm); /* World maps 1 for 1 */
return mode;
}

404
contrib/apr-util/dbm/apr_dbm_berkeleydb.c
View File

@ -1,404 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_strings.h"
#define APR_WANT_MEMFUNC
#include "apr_want.h"
#define APU_WANT_DB
#include "apu_want.h"
#if APR_HAVE_STDLIB_H
#include <stdlib.h> /* for abort() */
#endif
#include "apu_config.h"
#include "apu.h"
#if APU_HAVE_DB
#include "apr_dbm_private.h"
/*
* We pick up all varieties of Berkeley DB through db.h (included through
* apu_select_dbm.h). This code has been compiled/tested against DB1,
* DB_185, DB2, DB3, and DB4.
*/
#if defined(DB_VERSION_MAJOR) && (DB_VERSION_MAJOR >= 4)
/* We will treat anything greater than 4.1 as DB4.
* We can treat 4.0 as DB3.
*/
#if DB_VERSION_MAJOR > 4 || (defined(DB_VERSION_MINOR) && (DB_VERSION_MINOR >= 1))
#define DB_VER 4
#elif DB_VERSION_MAJOR == 4
#define DB_VER 3
#endif
#elif defined(DB_VERSION_MAJOR) && (DB_VERSION_MAJOR == 3)
#define DB_VER 3
#elif defined(DB_VERSION_MAJOR) && (DB_VERSION_MAJOR == 2)
#define DB_VER 2
#else
#define DB_VER 1
#endif
typedef struct {
DB *bdb;
#if DB_VER != 1
DBC *curs;
#endif
} real_file_t;
#if DB_VER == 1
#define TXN_ARG
#else
#define TXN_ARG NULL,
#endif
#define GET_BDB(f) (((real_file_t *)(f))->bdb)
#define do_fetch(bdb, k, v) ((*(bdb)->get)(bdb, TXN_ARG &(k), &(v), 0))
#if DB_VER == 1
#include <sys/fcntl.h>
#define APR_DBM_DBMODE_RO O_RDONLY
#define APR_DBM_DBMODE_RW O_RDWR
#define APR_DBM_DBMODE_RWCREATE (O_CREAT | O_RDWR)
#define APR_DBM_DBMODE_RWTRUNC (O_CREAT | O_RDWR | O_TRUNC)
#else
#define APR_DBM_DBMODE_RO DB_RDONLY
#define APR_DBM_DBMODE_RW 0
#define APR_DBM_DBMODE_RWCREATE DB_CREATE
#define APR_DBM_DBMODE_RWTRUNC DB_TRUNCATE
#endif /* DBVER == 1 */
/* --------------------------------------------------------------------------
**
** UTILITY FUNCTIONS
*/
/* map a DB error to an apr_status_t */
static apr_status_t db2s(int dberr)
{
if (dberr != 0) {
/* ### need to fix this */
return APR_OS_START_USEERR + dberr;
}
return APR_SUCCESS;
}
static apr_status_t set_error(apr_dbm_t *dbm, apr_status_t dbm_said)
{
apr_status_t rv = APR_SUCCESS;
/* ### ignore whatever the DBM said (dbm_said); ask it explicitly */
if (dbm_said == APR_SUCCESS) {
dbm->errcode = 0;
dbm->errmsg = NULL;
}
else {
/* ### need to fix. dberr was tossed in db2s(). */
/* ### use db_strerror() */
dbm->errcode = dbm_said;
#if DB_VER == 1 || DB_VER == 2
dbm->errmsg = NULL;
#else
dbm->errmsg = db_strerror(dbm_said - APR_OS_START_USEERR);
#endif
rv = dbm_said;
}
return rv;
}
/* --------------------------------------------------------------------------
**
** DEFINE THE VTABLE FUNCTIONS FOR BERKELEY DB
**
** ### we may need three sets of these: db1, db2, db3
*/
static apr_status_t vt_db_open(apr_dbm_t **pdb, const char *pathname,
apr_int32_t mode, apr_fileperms_t perm,
apr_pool_t *pool)
{
real_file_t file;
int dbmode;
*pdb = NULL;
switch (mode) {
case APR_DBM_READONLY:
dbmode = APR_DBM_DBMODE_RO;
break;
case APR_DBM_READWRITE:
dbmode = APR_DBM_DBMODE_RW;
break;
case APR_DBM_RWCREATE:
dbmode = APR_DBM_DBMODE_RWCREATE;
break;
case APR_DBM_RWTRUNC:
dbmode = APR_DBM_DBMODE_RWTRUNC;
break;
default:
return APR_EINVAL;
}
{
int dberr;
#if DB_VER >= 3
if ((dberr = db_create(&file.bdb, NULL, 0)) == 0) {
if ((dberr = (*file.bdb->open)(file.bdb,
#if DB_VER == 4
NULL,
#endif
pathname, NULL,
DB_HASH, dbmode,
apr_posix_perms2mode(perm))) != 0) {
/* close the DB handler */
(void) (*file.bdb->close)(file.bdb, 0);
}
}
file.curs = NULL;
#elif DB_VER == 2
dberr = db_open(pathname, DB_HASH, dbmode, apr_posix_perms2mode(perm),
NULL, NULL, &file.bdb);
file.curs = NULL;
#else
file.bdb = dbopen(pathname, dbmode, apr_posix_perms2mode(perm),
DB_HASH, NULL);
if (file.bdb == NULL)
return APR_EGENERAL; /* ### need a better error */
dberr = 0;
#endif
if (dberr != 0)
return db2s(dberr);
}
/* we have an open database... return it */
*pdb = apr_pcalloc(pool, sizeof(**pdb));
(*pdb)->pool = pool;
(*pdb)->type = &apr_dbm_type_db;
(*pdb)->file = apr_pmemdup(pool, &file, sizeof(file));
/* ### register a cleanup to close the DBM? */
return APR_SUCCESS;
}
static void vt_db_close(apr_dbm_t *dbm)
{
(*GET_BDB(dbm->file)->close)(GET_BDB(dbm->file)
#if DB_VER != 1
, 0
#endif
);
}
static apr_status_t vt_db_fetch(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t * pvalue)
{
DBT ckey = { 0 };
DBT rd = { 0 };
int dberr;
ckey.data = key.dptr;
ckey.size = key.dsize;
dberr = do_fetch(GET_BDB(dbm->file), ckey, rd);
/* "not found" is not an error. return zero'd value. */
if (dberr ==
#if DB_VER == 1
RET_SPECIAL
#else
DB_NOTFOUND
#endif
) {
memset(&rd, 0, sizeof(rd));
dberr = 0;
}
pvalue->dptr = rd.data;
pvalue->dsize = rd.size;
/* store the error info into DBM, and return a status code. Also, note
that *pvalue should have been cleared on error. */
return set_error(dbm, db2s(dberr));
}
static apr_status_t vt_db_store(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t value)
{
apr_status_t rv;
DBT ckey = { 0 };
DBT cvalue = { 0 };
ckey.data = key.dptr;
ckey.size = key.dsize;
cvalue.data = value.dptr;
cvalue.size = value.dsize;
rv = db2s((*GET_BDB(dbm->file)->put)(GET_BDB(dbm->file),
TXN_ARG
&ckey,
&cvalue,
0));
/* store any error info into DBM, and return a status code. */
return set_error(dbm, rv);
}
static apr_status_t vt_db_del(apr_dbm_t *dbm, apr_datum_t key)
{
apr_status_t rv;
DBT ckey = { 0 };
ckey.data = key.dptr;
ckey.size = key.dsize;
rv = db2s((*GET_BDB(dbm->file)->del)(GET_BDB(dbm->file),
TXN_ARG
&ckey,
0));
/* store any error info into DBM, and return a status code. */
return set_error(dbm, rv);
}
static int vt_db_exists(apr_dbm_t *dbm, apr_datum_t key)
{
DBT ckey = { 0 }; /* converted key */
DBT data = { 0 };
int dberr;
ckey.data = key.dptr;
ckey.size = key.dsize;
dberr = do_fetch(GET_BDB(dbm->file), ckey, data);
/* note: the result data is "loaned" to us; we don't need to free it */
/* DB returns DB_NOTFOUND if it doesn't exist. but we want to say
that *any* error means it doesn't exist. */
return dberr == 0;
}
static apr_status_t vt_db_firstkey(apr_dbm_t *dbm, apr_datum_t * pkey)
{
real_file_t *f = dbm->file;
DBT first = { 0 };
DBT data = { 0 };
int dberr;
#if DB_VER == 1
dberr = (*f->bdb->seq)(f->bdb, &first, &data, R_FIRST);
#else
if ((dberr = (*f->bdb->cursor)(f->bdb, NULL, &f->curs
#if DB_VER >= 3 || ((DB_VERSION_MAJOR == 2) && (DB_VERSION_MINOR > 5))
, 0
#endif
)) == 0) {
dberr = (*f->curs->c_get)(f->curs, &first, &data, DB_FIRST);
if (dberr == DB_NOTFOUND) {
memset(&first, 0, sizeof(first));
(*f->curs->c_close)(f->curs);
f->curs = NULL;
dberr = 0;
}
}
#endif
pkey->dptr = first.data;
pkey->dsize = first.size;
/* store any error info into DBM, and return a status code. */
return set_error(dbm, db2s(dberr));
}
static apr_status_t vt_db_nextkey(apr_dbm_t *dbm, apr_datum_t * pkey)
{
real_file_t *f = dbm->file;
DBT ckey = { 0 };
DBT data = { 0 };
int dberr;
ckey.data = pkey->dptr;
ckey.size = pkey->dsize;
#if DB_VER == 1
dberr = (*f->bdb->seq)(f->bdb, &ckey, &data, R_NEXT);
if (dberr == RET_SPECIAL) {
dberr = 0;
ckey.data = NULL;
ckey.size = 0;
}
#else
if (f->curs == NULL)
return APR_EINVAL;
dberr = (*f->curs->c_get)(f->curs, &ckey, &data, DB_NEXT);
if (dberr == DB_NOTFOUND) {
(*f->curs->c_close)(f->curs);
f->curs = NULL;
dberr = 0;
ckey.data = NULL;
ckey.size = 0;
}
#endif
pkey->dptr = ckey.data;
pkey->dsize = ckey.size;
/* store any error info into DBM, and return a status code. */
/* ### or use db2s(dberr) instead of APR_SUCCESS? */
return set_error(dbm, APR_SUCCESS);
}
static void vt_db_freedatum(apr_dbm_t *dbm, apr_datum_t data)
{
/* nothing to do */
}
static void vt_db_usednames(apr_pool_t *pool, const char *pathname,
const char **used1, const char **used2)
{
*used1 = apr_pstrdup(pool, pathname);
*used2 = NULL;
}
APU_MODULE_DECLARE_DATA const apr_dbm_type_t apr_dbm_type_db = {
"db",
vt_db_open,
vt_db_close,
vt_db_fetch,
vt_db_store,
vt_db_del,
vt_db_exists,
vt_db_firstkey,
vt_db_nextkey,
vt_db_freedatum,
vt_db_usednames
};
#endif /* APU_HAVE_DB */

255
contrib/apr-util/dbm/apr_dbm_gdbm.c
View File

@ -1,255 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apu_config.h"
#include "apu.h"
#include "apr_strings.h"
#if APR_HAVE_STDLIB_H
#include <stdlib.h> /* for free() */
#endif
#if APU_HAVE_GDBM
#include "apr_dbm_private.h"
#include <gdbm.h>
#define APR_DBM_DBMODE_RO GDBM_READER
#define APR_DBM_DBMODE_RW GDBM_WRITER
#define APR_DBM_DBMODE_RWCREATE GDBM_WRCREAT
#define APR_DBM_DBMODE_RWTRUNC GDBM_NEWDB
/* map a GDBM error to an apr_status_t */
static apr_status_t g2s(int gerr)
{
if (gerr == -1) {
/* ### need to fix this */
return APR_EGENERAL;
}
return APR_SUCCESS;
}
static apr_status_t datum_cleanup(void *dptr)
{
if (dptr)
free(dptr);
return APR_SUCCESS;
}
static apr_status_t set_error(apr_dbm_t *dbm, apr_status_t dbm_said)
{
apr_status_t rv = APR_SUCCESS;
/* ### ignore whatever the DBM said (dbm_said); ask it explicitly */
if ((dbm->errcode = gdbm_errno) == GDBM_NO_ERROR) {
dbm->errmsg = NULL;
}
else {
dbm->errmsg = gdbm_strerror(gdbm_errno);
rv = APR_EGENERAL; /* ### need something better */
}
/* captured it. clear it now. */
gdbm_errno = GDBM_NO_ERROR;
return rv;
}
/* --------------------------------------------------------------------------
**
** DEFINE THE VTABLE FUNCTIONS FOR GDBM
*/
static apr_status_t vt_gdbm_open(apr_dbm_t **pdb, const char *pathname,
apr_int32_t mode, apr_fileperms_t perm,
apr_pool_t *pool)
{
GDBM_FILE file;
int dbmode;
*pdb = NULL;
switch (mode) {
case APR_DBM_READONLY:
dbmode = APR_DBM_DBMODE_RO;
break;
case APR_DBM_READWRITE:
dbmode = APR_DBM_DBMODE_RW;
break;
case APR_DBM_RWCREATE:
dbmode = APR_DBM_DBMODE_RWCREATE;
break;
case APR_DBM_RWTRUNC:
dbmode = APR_DBM_DBMODE_RWTRUNC;
break;
default:
return APR_EINVAL;
}
/* Note: stupid cast to get rid of "const" on the pathname */
file = gdbm_open((char *) pathname, 0, dbmode, apr_posix_perms2mode(perm),
NULL);
if (file == NULL)
return APR_EGENERAL; /* ### need a better error */
/* we have an open database... return it */
*pdb = apr_pcalloc(pool, sizeof(**pdb));
(*pdb)->pool = pool;
(*pdb)->type = &apr_dbm_type_gdbm;
(*pdb)->file = file;
/* ### register a cleanup to close the DBM? */
return APR_SUCCESS;
}
static void vt_gdbm_close(apr_dbm_t *dbm)
{
gdbm_close(dbm->file);
}
static apr_status_t vt_gdbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t *pvalue)
{
datum kd, rd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
rd = gdbm_fetch(dbm->file, kd);
pvalue->dptr = rd.dptr;
pvalue->dsize = rd.dsize;
if (pvalue->dptr)
apr_pool_cleanup_register(dbm->pool, pvalue->dptr, datum_cleanup,
apr_pool_cleanup_null);
/* store the error info into DBM, and return a status code. Also, note
that *pvalue should have been cleared on error. */
return set_error(dbm, APR_SUCCESS);
}
static apr_status_t vt_gdbm_store(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t value)
{
int rc;
datum kd, vd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
vd.dptr = value.dptr;
vd.dsize = value.dsize;
rc = gdbm_store(dbm->file, kd, vd, GDBM_REPLACE);
/* store any error info into DBM, and return a status code. */
return set_error(dbm, g2s(rc));
}
static apr_status_t vt_gdbm_del(apr_dbm_t *dbm, apr_datum_t key)
{
int rc;
datum kd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
rc = gdbm_delete(dbm->file, kd);
/* store any error info into DBM, and return a status code. */
return set_error(dbm, g2s(rc));
}
static int vt_gdbm_exists(apr_dbm_t *dbm, apr_datum_t key)
{
datum kd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
return gdbm_exists(dbm->file, kd) != 0;
}
static apr_status_t vt_gdbm_firstkey(apr_dbm_t *dbm, apr_datum_t *pkey)
{
datum rd;
rd = gdbm_firstkey(dbm->file);
pkey->dptr = rd.dptr;
pkey->dsize = rd.dsize;
if (pkey->dptr)
apr_pool_cleanup_register(dbm->pool, pkey->dptr, datum_cleanup,
apr_pool_cleanup_null);
/* store any error info into DBM, and return a status code. */
return set_error(dbm, APR_SUCCESS);
}
static apr_status_t vt_gdbm_nextkey(apr_dbm_t *dbm, apr_datum_t *pkey)
{
datum kd, rd;
kd.dptr = pkey->dptr;
kd.dsize = pkey->dsize;
rd = gdbm_nextkey(dbm->file, kd);
pkey->dptr = rd.dptr;
pkey->dsize = rd.dsize;
if (pkey->dptr)
apr_pool_cleanup_register(dbm->pool, pkey->dptr, datum_cleanup,
apr_pool_cleanup_null);
/* store any error info into DBM, and return a status code. */
return set_error(dbm, APR_SUCCESS);
}
static void vt_gdbm_freedatum(apr_dbm_t *dbm, apr_datum_t data)
{
(void) apr_pool_cleanup_run(dbm->pool, data.dptr, datum_cleanup);
}
static void vt_gdbm_usednames(apr_pool_t *pool, const char *pathname,
const char **used1, const char **used2)
{
*used1 = apr_pstrdup(pool, pathname);
*used2 = NULL;
}
APU_MODULE_DECLARE_DATA const apr_dbm_type_t apr_dbm_type_gdbm = {
"gdbm",
vt_gdbm_open,
vt_gdbm_close,
vt_gdbm_fetch,
vt_gdbm_store,
vt_gdbm_del,
vt_gdbm_exists,
vt_gdbm_firstkey,
vt_gdbm_nextkey,
vt_gdbm_freedatum,
vt_gdbm_usednames
};
#endif /* APU_HAVE_GDBM */

238
contrib/apr-util/dbm/apr_dbm_ndbm.c
View File

@ -1,238 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_strings.h"
#if APR_HAVE_STDLIB_H
#include <stdlib.h> /* for free() */
#endif
#include "apu_config.h"
#include "apu.h"
#if APU_HAVE_NDBM
#include "apr_dbm_private.h"
#include <ndbm.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define APR_DBM_DBMODE_RO O_RDONLY
#define APR_DBM_DBMODE_RW O_RDWR
#define APR_DBM_DBMODE_RWCREATE (O_RDWR|O_CREAT)
#define APR_DBM_DBMODE_RWTRUNC (O_RDWR|O_CREAT|O_TRUNC)
/* map a NDBM error to an apr_status_t */
static apr_status_t ndbm2s(int ndbmerr)
{
if (ndbmerr == -1) {
/* ### need to fix this */
return APR_EGENERAL;
}
return APR_SUCCESS;
}
static apr_status_t set_error(apr_dbm_t *dbm, apr_status_t dbm_said)
{
apr_status_t rv = APR_SUCCESS;
/* ### ignore whatever the DBM said (dbm_said); ask it explicitly */
dbm->errmsg = NULL;
if (dbm_error((DBM*)dbm->file)) {
dbm->errmsg = NULL;
rv = APR_EGENERAL; /* ### need something better */
}
/* captured it. clear it now. */
dbm_clearerr((DBM*)dbm->file);
return rv;
}
/* --------------------------------------------------------------------------
**
** DEFINE THE VTABLE FUNCTIONS FOR NDBM
*/
static apr_status_t vt_ndbm_open(apr_dbm_t **pdb, const char *pathname,
apr_int32_t mode, apr_fileperms_t perm,
apr_pool_t *pool)
{
DBM *file;
int dbmode;
*pdb = NULL;
switch (mode) {
case APR_DBM_READONLY:
dbmode = APR_DBM_DBMODE_RO;
break;
case APR_DBM_READWRITE:
dbmode = APR_DBM_DBMODE_RW;
break;
case APR_DBM_RWCREATE:
dbmode = APR_DBM_DBMODE_RWCREATE;
break;
case APR_DBM_RWTRUNC:
dbmode = APR_DBM_DBMODE_RWTRUNC;
break;
default:
return APR_EINVAL;
}
{
file = dbm_open(pathname, dbmode, apr_posix_perms2mode(perm));
if (file == NULL)
return APR_EGENERAL; /* ### need a better error */
}
/* we have an open database... return it */
*pdb = apr_pcalloc(pool, sizeof(**pdb));
(*pdb)->pool = pool;
(*pdb)->type = &apr_dbm_type_ndbm;
(*pdb)->file = file;
/* ### register a cleanup to close the DBM? */
return APR_SUCCESS;
}
static void vt_ndbm_close(apr_dbm_t *dbm)
{
dbm_close(dbm->file);
}
static apr_status_t vt_ndbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t *pvalue)
{
datum kd, rd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
rd = dbm_fetch(dbm->file, kd);
pvalue->dptr = rd.dptr;
pvalue->dsize = rd.dsize;
/* store the error info into DBM, and return a status code. Also, note
that *pvalue should have been cleared on error. */
return set_error(dbm, APR_SUCCESS);
}
static apr_status_t vt_ndbm_store(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t value)
{
int rc;
datum kd, vd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
vd.dptr = value.dptr;
vd.dsize = value.dsize;
rc = dbm_store(dbm->file, kd, vd, DBM_REPLACE);
/* store any error info into DBM, and return a status code. */
return set_error(dbm, ndbm2s(rc));
}
static apr_status_t vt_ndbm_del(apr_dbm_t *dbm, apr_datum_t key)
{
int rc;
datum kd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
rc = dbm_delete(dbm->file, kd);
/* store any error info into DBM, and return a status code. */
return set_error(dbm, ndbm2s(rc));
}
static int vt_ndbm_exists(apr_dbm_t *dbm, apr_datum_t key)
{
datum kd, rd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
rd = dbm_fetch(dbm->file, kd);
return rd.dptr != NULL;
}
static apr_status_t vt_ndbm_firstkey(apr_dbm_t *dbm, apr_datum_t *pkey)
{
datum rd;
rd = dbm_firstkey(dbm->file);
pkey->dptr = rd.dptr;
pkey->dsize = rd.dsize;
/* store any error info into DBM, and return a status code. */
return set_error(dbm, APR_SUCCESS);
}
static apr_status_t vt_ndbm_nextkey(apr_dbm_t *dbm, apr_datum_t *pkey)
{
datum kd, rd;
kd.dptr = pkey->dptr;
kd.dsize = pkey->dsize;
rd = dbm_nextkey(dbm->file);
pkey->dptr = rd.dptr;
pkey->dsize = rd.dsize;
/* store any error info into DBM, and return a status code. */
return set_error(dbm, APR_SUCCESS);
}
static void vt_ndbm_freedatum(apr_dbm_t *dbm, apr_datum_t data)
{
/* nothing to do */
}
static void vt_ndbm_usednames(apr_pool_t *pool, const char *pathname,
const char **used1, const char **used2)
{
*used1 = apr_pstrdup(pool, pathname);
*used2 = NULL;
}
APU_MODULE_DECLARE_DATA const apr_dbm_type_t apr_dbm_type_ndbm = {
"ndbm",
vt_ndbm_open,
vt_ndbm_close,
vt_ndbm_fetch,
vt_ndbm_store,
vt_ndbm_del,
vt_ndbm_exists,
vt_ndbm_firstkey,
vt_ndbm_nextkey,
vt_ndbm_freedatum,
vt_ndbm_usednames
};
#endif /* APU_HAVE_NDBM */

223
contrib/apr-util/dbm/apr_dbm_sdbm.c
View File

@ -1,223 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_strings.h"
#define APR_WANT_MEMFUNC
#define APR_WANT_STRFUNC
#include "apr_want.h"
#include "apu_config.h"
#include "apu.h"
#if APU_HAVE_SDBM
#include "apr_dbm_private.h"
#include "apr_sdbm.h"
#define APR_DBM_DBMODE_RO (APR_FOPEN_READ | APR_FOPEN_BUFFERED)
#define APR_DBM_DBMODE_RW (APR_FOPEN_READ | APR_FOPEN_WRITE)
#define APR_DBM_DBMODE_RWCREATE (APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE)
#define APR_DBM_DBMODE_RWTRUNC (APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE | \
APR_FOPEN_TRUNCATE)
static apr_status_t set_error(apr_dbm_t *dbm, apr_status_t dbm_said)
{
dbm->errcode = dbm_said;
if (dbm_said != APR_SUCCESS) {
dbm->errmsg = apr_psprintf(dbm->pool, "%pm", &dbm_said);
} else {
dbm->errmsg = NULL;
}
return dbm_said;
}
/* --------------------------------------------------------------------------
**
** DEFINE THE VTABLE FUNCTIONS FOR SDBM
*/
static apr_status_t vt_sdbm_open(apr_dbm_t **pdb, const char *pathname,
apr_int32_t mode, apr_fileperms_t perm,
apr_pool_t *pool)
{
apr_sdbm_t *file;
int dbmode;
*pdb = NULL;
switch (mode) {
case APR_DBM_READONLY:
dbmode = APR_DBM_DBMODE_RO;
break;
case APR_DBM_READWRITE:
dbmode = APR_DBM_DBMODE_RW;
break;
case APR_DBM_RWCREATE:
dbmode = APR_DBM_DBMODE_RWCREATE;
break;
case APR_DBM_RWTRUNC:
dbmode = APR_DBM_DBMODE_RWTRUNC;
break;
default:
return APR_EINVAL;
}
{
apr_status_t rv;
rv = apr_sdbm_open(&file, pathname, dbmode, perm, pool);
if (rv != APR_SUCCESS)
return rv;
}
/* we have an open database... return it */
*pdb = apr_pcalloc(pool, sizeof(**pdb));
(*pdb)->pool = pool;
(*pdb)->type = &apr_dbm_type_sdbm;
(*pdb)->file = file;
/* ### register a cleanup to close the DBM? */
return APR_SUCCESS;
}
static void vt_sdbm_close(apr_dbm_t *dbm)
{
apr_sdbm_close(dbm->file);
}
static apr_status_t vt_sdbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t *pvalue)
{
apr_status_t rv;
apr_sdbm_datum_t kd, rd;
kd.dptr = key.dptr;
kd.dsize = (int)key.dsize;
rv = apr_sdbm_fetch(dbm->file, &rd, kd);
pvalue->dptr = rd.dptr;
pvalue->dsize = rd.dsize;
/* store the error info into DBM, and return a status code. Also, note
that *pvalue should have been cleared on error. */
return set_error(dbm, rv);
}
static apr_status_t vt_sdbm_store(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t value)
{
apr_status_t rv;
apr_sdbm_datum_t kd, vd;
kd.dptr = key.dptr;
kd.dsize = (int)key.dsize;
vd.dptr = value.dptr;
vd.dsize = (int)value.dsize;
rv = apr_sdbm_store(dbm->file, kd, vd, APR_SDBM_REPLACE);
/* store any error info into DBM, and return a status code. */
return set_error(dbm, rv);
}
static apr_status_t vt_sdbm_del(apr_dbm_t *dbm, apr_datum_t key)
{
apr_status_t rv;
apr_sdbm_datum_t kd;
kd.dptr = key.dptr;
kd.dsize = (int)key.dsize;
rv = apr_sdbm_delete(dbm->file, kd);
/* store any error info into DBM, and return a status code. */
return set_error(dbm, rv);
}
static int vt_sdbm_exists(apr_dbm_t *dbm, apr_datum_t key)
{
int exists;
apr_sdbm_datum_t vd, kd;
kd.dptr = key.dptr;
kd.dsize = (int)key.dsize;
if (apr_sdbm_fetch(dbm->file, &vd, kd) != APR_SUCCESS)
exists = 0;
else
exists = vd.dptr != NULL;
return exists;
}
static apr_status_t vt_sdbm_firstkey(apr_dbm_t *dbm, apr_datum_t *pkey)
{
apr_status_t rv;
apr_sdbm_datum_t rd;
rv = apr_sdbm_firstkey(dbm->file, &rd);
pkey->dptr = rd.dptr;
pkey->dsize = rd.dsize;
/* store any error info into DBM, and return a status code. */
return set_error(dbm, rv);
}
static apr_status_t vt_sdbm_nextkey(apr_dbm_t *dbm, apr_datum_t *pkey)
{
apr_sdbm_datum_t rd;
(void)apr_sdbm_nextkey(dbm->file, &rd);
pkey->dptr = rd.dptr;
pkey->dsize = rd.dsize;
/* store any error info into DBM, and return a status code. */
return set_error(dbm, APR_SUCCESS);
}
static void vt_sdbm_freedatum(apr_dbm_t *dbm, apr_datum_t data)
{
}
static void vt_sdbm_usednames(apr_pool_t *pool, const char *pathname,
const char **used1, const char **used2)
{
*used1 = apr_pstrcat(pool, pathname, APR_SDBM_DIRFEXT, NULL);
*used2 = apr_pstrcat(pool, pathname, APR_SDBM_PAGFEXT, NULL);
}
APU_MODULE_DECLARE_DATA const apr_dbm_type_t apr_dbm_type_sdbm = {
"sdbm",
vt_sdbm_open,
vt_sdbm_close,
vt_sdbm_fetch,
vt_sdbm_store,
vt_sdbm_del,
vt_sdbm_exists,
vt_sdbm_firstkey,
vt_sdbm_nextkey,
vt_sdbm_freedatum,
vt_sdbm_usednames
};
#endif /* APU_HAVE_SDBM */

584
contrib/apr-util/dbm/sdbm/sdbm.c
View File

@ -1,584 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* sdbm - ndbm work-alike hashed database library
* based on Per-Aake Larson's Dynamic Hashing algorithms. BIT 18 (1978).
* author: oz@nexus.yorku.ca
* ex-public domain, ported to APR for Apache 2
* core routines
*/
#include "apr.h"
#include "apr_file_io.h"
#include "apr_strings.h"
#include "apr_errno.h"
#include "apr_sdbm.h"
#include "sdbm_tune.h"
#include "sdbm_pair.h"
#include "sdbm_private.h"
#include <string.h> /* for memset() */
#include <stdlib.h> /* for malloc() and free() */
/*
* forward
*/
static int getdbit (apr_sdbm_t *, long);
static apr_status_t setdbit(apr_sdbm_t *, long);
static apr_status_t getpage(apr_sdbm_t *db, long, int, int);
static apr_status_t getnext(apr_sdbm_datum_t *key, apr_sdbm_t *db);
static apr_status_t makroom(apr_sdbm_t *, long, int);
/*
* useful macros
*/
#define bad(x) ((x).dptr == NULL || (x).dsize <= 0)
#define exhash(item) sdbm_hash((item).dptr, (item).dsize)
#define OFF_PAG(off) (apr_off_t) (off) * PBLKSIZ
#define OFF_DIR(off) (apr_off_t) (off) * DBLKSIZ
static const long masks[] = {
000000000000, 000000000001, 000000000003, 000000000007,
000000000017, 000000000037, 000000000077, 000000000177,
000000000377, 000000000777, 000000001777, 000000003777,
000000007777, 000000017777, 000000037777, 000000077777,
000000177777, 000000377777, 000000777777, 000001777777,
000003777777, 000007777777, 000017777777, 000037777777,
000077777777, 000177777777, 000377777777, 000777777777,
001777777777, 003777777777, 007777777777, 017777777777
};
const apr_sdbm_datum_t sdbm_nullitem = { NULL, 0 };
static apr_status_t database_cleanup(void *data)
{
apr_sdbm_t *db = data;
/*
* Can't rely on apr_sdbm_unlock, since it will merely
* decrement the refcnt if several locks are held.
*/
if (db->flags & (SDBM_SHARED_LOCK | SDBM_EXCLUSIVE_LOCK))
(void) apr_file_unlock(db->dirf);
(void) apr_file_close(db->dirf);
(void) apr_file_close(db->pagf);
free(db);
return APR_SUCCESS;
}
static apr_status_t prep(apr_sdbm_t **pdb, const char *dirname, const char *pagname,
apr_int32_t flags, apr_fileperms_t perms, apr_pool_t *p)
{
apr_sdbm_t *db;
apr_status_t status;
*pdb = NULL;
db = malloc(sizeof(*db));
memset(db, 0, sizeof(*db));
db->pagbno = -1L;
db->pool = p;
/*
* adjust user flags so that WRONLY becomes RDWR,
* as required by this package. Also set our internal
* flag for RDONLY if needed.
*/
if (!(flags & APR_FOPEN_WRITE)) {
db->flags |= SDBM_RDONLY;
}
/*
* adjust the file open flags so that we handle locking
* on our own (don't rely on any locking behavior within
* an apr_file_t, in case it's ever introduced, and set
* our own flag.
*/
if (flags & APR_FOPEN_SHARELOCK) {
db->flags |= SDBM_SHARED;
flags &= ~APR_FOPEN_SHARELOCK;
}
flags |= APR_FOPEN_BINARY | APR_FOPEN_READ;
/*
* open the files in sequence, and stat the dirfile.
* If we fail anywhere, undo everything, return NULL.
*/
if ((status = apr_file_open(&db->dirf, dirname, flags, perms, p))
!= APR_SUCCESS)
goto error;
if ((status = apr_file_open(&db->pagf, pagname, flags, perms, p))
!= APR_SUCCESS)
goto error;
if ((status = apr_sdbm_lock(db, (db->flags & SDBM_RDONLY)
? APR_FLOCK_SHARED
: APR_FLOCK_EXCLUSIVE))
!= APR_SUCCESS)
goto error;
/* apr_pcalloc zeroed the buffers
* apr_sdbm_lock stated the dirf->size and invalidated the cache
*/
/*
* if we are opened in SHARED mode, unlock ourself
*/
if (db->flags & SDBM_SHARED)
if ((status = apr_sdbm_unlock(db)) != APR_SUCCESS)
goto error;
/* make sure that we close the database at some point */
apr_pool_cleanup_register(p, db, database_cleanup, apr_pool_cleanup_null);
/* Done! */
*pdb = db;
return APR_SUCCESS;
error:
if (db->dirf && db->pagf)
(void) apr_sdbm_unlock(db);
if (db->dirf != NULL)
(void) apr_file_close(db->dirf);
if (db->pagf != NULL) {
(void) apr_file_close(db->pagf);
}
free(db);
return status;
}
APU_DECLARE(apr_status_t) apr_sdbm_open(apr_sdbm_t **db, const char *file,
apr_int32_t flags,
apr_fileperms_t perms, apr_pool_t *p)
{
char *dirname = apr_pstrcat(p, file, APR_SDBM_DIRFEXT, NULL);
char *pagname = apr_pstrcat(p, file, APR_SDBM_PAGFEXT, NULL);
return prep(db, dirname, pagname, flags, perms, p);
}
APU_DECLARE(apr_status_t) apr_sdbm_close(apr_sdbm_t *db)
{
return apr_pool_cleanup_run(db->pool, db, database_cleanup);
}
APU_DECLARE(apr_status_t) apr_sdbm_fetch(apr_sdbm_t *db, apr_sdbm_datum_t *val,
apr_sdbm_datum_t key)
{
apr_status_t status;
if (db == NULL || bad(key))
return APR_EINVAL;
if ((status = apr_sdbm_lock(db, APR_FLOCK_SHARED)) != APR_SUCCESS)
return status;
if ((status = getpage(db, exhash(key), 0, 1)) == APR_SUCCESS) {
*val = getpair(db->pagbuf, key);
/* ### do we want a not-found result? */
}
(void) apr_sdbm_unlock(db);
return status;
}
static apr_status_t write_page(apr_sdbm_t *db, const char *buf, long pagno)
{
apr_status_t status;
apr_off_t off = OFF_PAG(pagno);
if ((status = apr_file_seek(db->pagf, APR_SET, &off)) == APR_SUCCESS)
status = apr_file_write_full(db->pagf, buf, PBLKSIZ, NULL);
return status;
}
APU_DECLARE(apr_status_t) apr_sdbm_delete(apr_sdbm_t *db,
const apr_sdbm_datum_t key)
{
apr_status_t status;
if (db == NULL || bad(key))
return APR_EINVAL;
if (apr_sdbm_rdonly(db))
return APR_EINVAL;
if ((status = apr_sdbm_lock(db, APR_FLOCK_EXCLUSIVE)) != APR_SUCCESS)
return status;
if ((status = getpage(db, exhash(key), 0, 1)) == APR_SUCCESS) {
if (!delpair(db->pagbuf, key))
/* ### should we define some APRUTIL codes? */
status = APR_EGENERAL;
else
status = write_page(db, db->pagbuf, db->pagbno);
}
(void) apr_sdbm_unlock(db);
return status;
}
APU_DECLARE(apr_status_t) apr_sdbm_store(apr_sdbm_t *db, apr_sdbm_datum_t key,
apr_sdbm_datum_t val, int flags)
{
int need;
register long hash;
apr_status_t status;
if (db == NULL || bad(key))
return APR_EINVAL;
if (apr_sdbm_rdonly(db))
return APR_EINVAL;
need = key.dsize + val.dsize;
/*
* is the pair too big (or too small) for this database ??
*/
if (need < 0 || need > PAIRMAX)
return APR_EINVAL;
if ((status = apr_sdbm_lock(db, APR_FLOCK_EXCLUSIVE)) != APR_SUCCESS)
return status;
if ((status = getpage(db, (hash = exhash(key)), 0, 1)) == APR_SUCCESS) {
/*
* if we need to replace, delete the key/data pair
* first. If it is not there, ignore.
*/
if (flags == APR_SDBM_REPLACE)
(void) delpair(db->pagbuf, key);
else if (!(flags & APR_SDBM_INSERTDUP) && duppair(db->pagbuf, key)) {
status = APR_EEXIST;
goto error;
}
/*
* if we do not have enough room, we have to split.
*/
if (!fitpair(db->pagbuf, need))
if ((status = makroom(db, hash, need)) != APR_SUCCESS)
goto error;
/*
* we have enough room or split is successful. insert the key,
* and update the page file.
*/
(void) putpair(db->pagbuf, key, val);
status = write_page(db, db->pagbuf, db->pagbno);
}
error:
(void) apr_sdbm_unlock(db);
return status;
}
/*
* makroom - make room by splitting the overfull page
* this routine will attempt to make room for SPLTMAX times before
* giving up.
*/
static apr_status_t makroom(apr_sdbm_t *db, long hash, int need)
{
long newp;
char twin[PBLKSIZ];
char *pag = db->pagbuf;
char *new = twin;
register int smax = SPLTMAX;
apr_status_t status;
do {
/*
* split the current page
*/
(void) splpage(pag, new, db->hmask + 1);
/*
* address of the new page
*/
newp = (hash & db->hmask) | (db->hmask + 1);
/*
* write delay, read avoidence/cache shuffle:
* select the page for incoming pair: if key is to go to the new page,
* write out the previous one, and copy the new one over, thus making
* it the current page. If not, simply write the new page, and we are
* still looking at the page of interest. current page is not updated
* here, as sdbm_store will do so, after it inserts the incoming pair.
*/
if (hash & (db->hmask + 1)) {
if ((status = write_page(db, db->pagbuf, db->pagbno))
!= APR_SUCCESS)
return status;
db->pagbno = newp;
(void) memcpy(pag, new, PBLKSIZ);
}
else {
if ((status = write_page(db, new, newp)) != APR_SUCCESS)
return status;
}
if ((status = setdbit(db, db->curbit)) != APR_SUCCESS)
return status;
/*
* see if we have enough room now
*/
if (fitpair(pag, need))
return APR_SUCCESS;
/*
* try again... update curbit and hmask as getpage would have
* done. because of our update of the current page, we do not
* need to read in anything. BUT we have to write the current
* [deferred] page out, as the window of failure is too great.
*/
db->curbit = 2 * db->curbit
+ ((hash & (db->hmask + 1)) ? 2 : 1);
db->hmask |= db->hmask + 1;
if ((status = write_page(db, db->pagbuf, db->pagbno))
!= APR_SUCCESS)
return status;
} while (--smax);
/*
* if we are here, this is real bad news. After SPLTMAX splits,
* we still cannot fit the key. say goodnight.
*/
#if 0
(void) write(2, "sdbm: cannot insert after SPLTMAX attempts.\n", 44);
#endif
/* ### ENOSPC not really appropriate but better than nothing */
return APR_ENOSPC;
}
/* Reads 'len' bytes from file 'f' at offset 'off' into buf.
* 'off' is given relative to the start of the file.
* If 'create' is asked and EOF is returned while reading, this is taken
* as success (i.e. a cleared buffer is returned).
*/
static apr_status_t read_from(apr_file_t *f, void *buf,
apr_off_t off, apr_size_t len,
int create)
{
apr_status_t status;
if ((status = apr_file_seek(f, APR_SET, &off)) != APR_SUCCESS ||
((status = apr_file_read_full(f, buf, len, NULL)) != APR_SUCCESS)) {
/* if EOF is reached, pretend we read all zero's */
if (status == APR_EOF && create) {
memset(buf, 0, len);
status = APR_SUCCESS;
}
}
return status;
}
/*
* the following two routines will break if
* deletions aren't taken into account. (ndbm bug)
*/
APU_DECLARE(apr_status_t) apr_sdbm_firstkey(apr_sdbm_t *db,
apr_sdbm_datum_t *key)
{
apr_status_t status;
if ((status = apr_sdbm_lock(db, APR_FLOCK_SHARED)) != APR_SUCCESS)
return status;
/*
* start at page 0
*/
if ((status = getpage(db, 0, 1, 1)) == APR_SUCCESS) {
db->blkptr = 0;
db->keyptr = 0;
status = getnext(key, db);
}
(void) apr_sdbm_unlock(db);
return status;
}
APU_DECLARE(apr_status_t) apr_sdbm_nextkey(apr_sdbm_t *db,
apr_sdbm_datum_t *key)
{
apr_status_t status;
if ((status = apr_sdbm_lock(db, APR_FLOCK_SHARED)) != APR_SUCCESS)
return status;
status = getnext(key, db);
(void) apr_sdbm_unlock(db);
return status;
}
/*
* all important binary tree traversal
*/
static apr_status_t getpage(apr_sdbm_t *db, long hash, int by_num, int create)
{
apr_status_t status;
register long pagb;
if (by_num) {
pagb = hash;
}
else {
register int hbit = 0;
register long dbit = 0;
while (dbit < db->maxbno && getdbit(db, dbit))
dbit = 2 * dbit + ((hash & (1 << hbit++)) ? 2 : 1);
debug(("dbit: %d...", dbit));
db->curbit = dbit;
db->hmask = masks[hbit];
pagb = hash & db->hmask;
}
/*
* see if the block we need is already in memory.
* note: this lookaside cache has about 10% hit rate.
*/
if (pagb != db->pagbno) {
/*
* note: here, we assume a "hole" is read as 0s.
* if not, must zero pagbuf first.
* ### joe: this assumption was surely never correct? but
* ### we make it so in read_from anyway.
*/
if ((status = read_from(db->pagf, db->pagbuf,
OFF_PAG(pagb), PBLKSIZ,
create)) != APR_SUCCESS)
return status;
if (!chkpage(db->pagbuf))
return APR_ENOSPC; /* ### better error? */
db->pagbno = pagb;
debug(("pag read: %d\n", pagb));
}
return APR_SUCCESS;
}
static int getdbit(apr_sdbm_t *db, long dbit)
{
register long c;
register long dirb;
c = dbit / BYTESIZ;
dirb = c / DBLKSIZ;
if (dirb != db->dirbno) {
if (read_from(db->dirf, db->dirbuf,
OFF_DIR(dirb), DBLKSIZ,
1) != APR_SUCCESS)
return 0;
db->dirbno = dirb;
debug(("dir read: %d\n", dirb));
}
return db->dirbuf[c % DBLKSIZ] & (1 << dbit % BYTESIZ);
}
static apr_status_t setdbit(apr_sdbm_t *db, long dbit)
{
register long c;
register long dirb;
apr_status_t status;
apr_off_t off;
c = dbit / BYTESIZ;
dirb = c / DBLKSIZ;
if (dirb != db->dirbno) {
if ((status = read_from(db->dirf, db->dirbuf,
OFF_DIR(dirb), DBLKSIZ,
1)) != APR_SUCCESS)
return status;
db->dirbno = dirb;
debug(("dir read: %d\n", dirb));
}
db->dirbuf[c % DBLKSIZ] |= (1 << dbit % BYTESIZ);
if (dbit >= db->maxbno)
db->maxbno += DBLKSIZ * BYTESIZ;
off = OFF_DIR(dirb);
if ((status = apr_file_seek(db->dirf, APR_SET, &off)) == APR_SUCCESS)
status = apr_file_write_full(db->dirf, db->dirbuf, DBLKSIZ, NULL);
return status;
}
/*
* getnext - get the next key in the page, and if done with
* the page, try the next page in sequence
*/
static apr_status_t getnext(apr_sdbm_datum_t *key, apr_sdbm_t *db)
{
apr_status_t status;
for (;;) {
db->keyptr++;
*key = getnkey(db->pagbuf, db->keyptr);
if (key->dptr != NULL)
return APR_SUCCESS;
/*
* we either run out, or there is nothing on this page..
* try the next one... If we lost our position on the
* file, we will have to seek.
*/
db->blkptr++;
db->keyptr = 0;
/* ### EOF acceptable here too? */
if ((status = getpage(db, db->blkptr, 1, 0)) != APR_SUCCESS)
return status;
}
/* NOTREACHED */
}
APU_DECLARE(int) apr_sdbm_rdonly(apr_sdbm_t *db)
{
/* ### Should we return true if the first lock is a share lock,
* to reflect that apr_sdbm_store and apr_sdbm_delete will fail?
*/
return (db->flags & SDBM_RDONLY) != 0;
}

63
contrib/apr-util/dbm/sdbm/sdbm_hash.c
View File

@ -1,63 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* sdbm - ndbm work-alike hashed database library
* based on Per-Aake Larson's Dynamic Hashing algorithms. BIT 18 (1978).
* author: oz@nexus.yorku.ca
* status: ex-public domain. keep it that way.
*
* hashing routine
*/
#include "apr_sdbm.h"
#include "sdbm_private.h"
/*
* polynomial conversion ignoring overflows
* [this seems to work remarkably well, in fact better
* then the ndbm hash function. Replace at your own risk]
* use: 65599 nice.
* 65587 even better.
*/
long sdbm_hash(const char *str, int len)
{
register unsigned long n = 0;
#define DUFF /* go ahead and use the loop-unrolled version */
#ifdef DUFF
#define HASHC n = *str++ + 65599 * n
if (len > 0) {
register int loop = (len + 8 - 1) >> 3;
switch(len & (8 - 1)) {
case 0: do {
HASHC; case 7: HASHC;
case 6: HASHC; case 5: HASHC;
case 4: HASHC; case 3: HASHC;
case 2: HASHC; case 1: HASHC;
} while (--loop);
}
}
#else
while (len--)
n = *str++ + 65599 * n;
#endif
return n;
}

79
contrib/apr-util/dbm/sdbm/sdbm_lock.c
View File

@ -1,79 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_file_info.h"
#include "apr_file_io.h"
#include "apr_sdbm.h"
#include "sdbm_private.h"
#include "sdbm_tune.h"
/* NOTE: this function may block until it acquires the lock */
APU_DECLARE(apr_status_t) apr_sdbm_lock(apr_sdbm_t *db, int type)
{
apr_status_t status;
int lock_type = type & APR_FLOCK_TYPEMASK;
if (!(lock_type == APR_FLOCK_SHARED || lock_type == APR_FLOCK_EXCLUSIVE))
return APR_EINVAL;
if (db->flags & SDBM_EXCLUSIVE_LOCK) {
++db->lckcnt;
return APR_SUCCESS;
}
else if (db->flags & SDBM_SHARED_LOCK) {
/*
* Cannot promote a shared lock to an exlusive lock
* in a cross-platform compatibile manner.
*/
if (type == APR_FLOCK_EXCLUSIVE)
return APR_EINVAL;
++db->lckcnt;
return APR_SUCCESS;
}
/*
* zero size: either a fresh database, or one with a single,
* unsplit data page: dirpage is all zeros.
*/
if ((status = apr_file_lock(db->dirf, type)) == APR_SUCCESS)
{
apr_finfo_t finfo;
if ((status = apr_file_info_get(&finfo, APR_FINFO_SIZE, db->dirf))
!= APR_SUCCESS) {
(void) apr_file_unlock(db->dirf);
return status;
}
SDBM_INVALIDATE_CACHE(db, finfo);
++db->lckcnt;
if (type == APR_FLOCK_SHARED)
db->flags |= SDBM_SHARED_LOCK;
else if (type == APR_FLOCK_EXCLUSIVE)
db->flags |= SDBM_EXCLUSIVE_LOCK;
}
return status;
}
APU_DECLARE(apr_status_t) apr_sdbm_unlock(apr_sdbm_t *db)
{
if (!(db->flags & (SDBM_SHARED_LOCK | SDBM_EXCLUSIVE_LOCK)))
return APR_EINVAL;
if (--db->lckcnt > 0)
return APR_SUCCESS;
db->flags &= ~(SDBM_SHARED_LOCK | SDBM_EXCLUSIVE_LOCK);
return apr_file_unlock(db->dirf);
}

320
contrib/apr-util/dbm/sdbm/sdbm_pair.c
View File

@ -1,320 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* sdbm - ndbm work-alike hashed database library
* based on Per-Aake Larson's Dynamic Hashing algorithms. BIT 18 (1978).
* author: oz@nexus.yorku.ca
* status: ex-public domain.
*
* page-level routines
*/
#include "apr_sdbm.h"
#include "sdbm_tune.h"
#include "sdbm_pair.h"
#include "sdbm_private.h"
#include <string.h> /* for memset() */
#define exhash(item) sdbm_hash((item).dptr, (item).dsize)
/*
* forward
*/
static int seepair(char *, int, char *, int);
/*
* page format:
* +------------------------------+
* ino | n | keyoff | datoff | keyoff |
* +------------+--------+--------+
* | datoff | - - - ----> |
* +--------+---------------------+
* | F R E E A R E A |
* +--------------+---------------+
* | <---- - - - | data |
* +--------+-----+----+----------+
* | key | data | key |
* +--------+----------+----------+
*
* calculating the offsets for free area: if the number
* of entries (ino[0]) is zero, the offset to the END of
* the free area is the block size. Otherwise, it is the
* nth (ino[ino[0]]) entry's offset.
*/
int
fitpair(pag, need)
char *pag;
int need;
{
register int n;
register int off;
register int avail;
register short *ino = (short *) pag;
off = ((n = ino[0]) > 0) ? ino[n] : PBLKSIZ;
avail = off - (n + 1) * sizeof(short);
need += 2 * sizeof(short);
debug(("avail %d need %d\n", avail, need));
return need <= avail;
}
void
putpair(pag, key, val)
char *pag;
apr_sdbm_datum_t key;
apr_sdbm_datum_t val;
{
register int n;
register int off;
register short *ino = (short *) pag;
off = ((n = ino[0]) > 0) ? ino[n] : PBLKSIZ;
/*
* enter the key first
*/
off -= key.dsize;
(void) memcpy(pag + off, key.dptr, key.dsize);
ino[n + 1] = off;
/*
* now the data
*/
off -= val.dsize;
(void) memcpy(pag + off, val.dptr, val.dsize);
ino[n + 2] = off;
/*
* adjust item count
*/
ino[0] += 2;
}
apr_sdbm_datum_t
getpair(pag, key)
char *pag;
apr_sdbm_datum_t key;
{
register int i;
register int n;
apr_sdbm_datum_t val;
register short *ino = (short *) pag;
if ((n = ino[0]) == 0)
return sdbm_nullitem;
if ((i = seepair(pag, n, key.dptr, key.dsize)) == 0)
return sdbm_nullitem;
val.dptr = pag + ino[i + 1];
val.dsize = ino[i] - ino[i + 1];
return val;
}
int
duppair(pag, key)
char *pag;
apr_sdbm_datum_t key;
{
register short *ino = (short *) pag;
return ino[0] > 0 && seepair(pag, ino[0], key.dptr, key.dsize) > 0;
}
apr_sdbm_datum_t
getnkey(pag, num)
char *pag;
int num;
{
apr_sdbm_datum_t key;
register int off;
register short *ino = (short *) pag;
num = num * 2 - 1;
if (ino[0] == 0 || num > ino[0])
return sdbm_nullitem;
off = (num > 1) ? ino[num - 1] : PBLKSIZ;
key.dptr = pag + ino[num];
key.dsize = off - ino[num];
return key;
}
int
delpair(pag, key)
char *pag;
apr_sdbm_datum_t key;
{
register int n;
register int i;
register short *ino = (short *) pag;
if ((n = ino[0]) == 0)
return 0;
if ((i = seepair(pag, n, key.dptr, key.dsize)) == 0)
return 0;
/*
* found the key. if it is the last entry
* [i.e. i == n - 1] we just adjust the entry count.
* hard case: move all data down onto the deleted pair,
* shift offsets onto deleted offsets, and adjust them.
* [note: 0 < i < n]
*/
if (i < n - 1) {
register int m;
register char *dst = pag + (i == 1 ? PBLKSIZ : ino[i - 1]);
register char *src = pag + ino[i + 1];
register short zoo = (short) (dst - src);
debug(("free-up %d ", zoo));
/*
* shift data/keys down
*/
m = ino[i + 1] - ino[n];
#undef DUFF /* just use memmove. it should be plenty fast. */
#ifdef DUFF
#define MOVB *--dst = *--src
if (m > 0) {
register int loop = (m + 8 - 1) >> 3;
switch (m & (8 - 1)) {
case 0: do {
MOVB; case 7: MOVB;
case 6: MOVB; case 5: MOVB;
case 4: MOVB; case 3: MOVB;
case 2: MOVB; case 1: MOVB;
} while (--loop);
}
}
#else
dst -= m;
src -= m;
memmove(dst, src, m);
#endif
/*
* adjust offset index up
*/
while (i < n - 1) {
ino[i] = ino[i + 2] + zoo;
i++;
}
}
ino[0] -= 2;
return 1;
}
/*
* search for the key in the page.
* return offset index in the range 0 < i < n.
* return 0 if not found.
*/
static int
seepair(pag, n, key, siz)
char *pag;
register int n;
register char *key;
register int siz;
{
register int i;
register int off = PBLKSIZ;
register short *ino = (short *) pag;
for (i = 1; i < n; i += 2) {
if (siz == off - ino[i] &&
memcmp(key, pag + ino[i], siz) == 0)
return i;
off = ino[i + 1];
}
return 0;
}
void
splpage(pag, new, sbit)
char *pag;
char *new;
long sbit;
{
apr_sdbm_datum_t key;
apr_sdbm_datum_t val;
register int n;
register int off = PBLKSIZ;
char cur[PBLKSIZ];
register short *ino = (short *) cur;
(void) memcpy(cur, pag, PBLKSIZ);
(void) memset(pag, 0, PBLKSIZ);
(void) memset(new, 0, PBLKSIZ);
n = ino[0];
for (ino++; n > 0; ino += 2) {
key.dptr = cur + ino[0];
key.dsize = off - ino[0];
val.dptr = cur + ino[1];
val.dsize = ino[0] - ino[1];
/*
* select the page pointer (by looking at sbit) and insert
*/
(void) putpair((exhash(key) & sbit) ? new : pag, key, val);
off = ino[1];
n -= 2;
}
debug(("%d split %d/%d\n", ((short *) cur)[0] / 2,
((short *) new)[0] / 2,
((short *) pag)[0] / 2));
}
/*
* check page sanity:
* number of entries should be something
* reasonable, and all offsets in the index should be in order.
* this could be made more rigorous.
*/
int
chkpage(pag)
char *pag;
{
register int n;
register int off;
register short *ino = (short *) pag;
if ((n = ino[0]) < 0 || n > PBLKSIZ / sizeof(short))
return 0;
if (n > 0) {
off = PBLKSIZ;
for (ino++; n > 0; ino += 2) {
if (ino[0] < 0 || ino[0] > off ||
ino[1] < 0 || ino[1] > off ||
ino[1] > ino[0])
return 0;
off = ino[1];
n -= 2;
}
}
return 1;
}

40
contrib/apr-util/dbm/sdbm/sdbm_pair.h
View File

@ -1,40 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef SDBM_PAIR_H
#define SDBM_PAIR_H
/* Mini EMBED (pair.c) */
#define chkpage apu__sdbm_chkpage
#define delpair apu__sdbm_delpair
#define duppair apu__sdbm_duppair
#define fitpair apu__sdbm_fitpair
#define getnkey apu__sdbm_getnkey
#define getpair apu__sdbm_getpair
#define putpair apu__sdbm_putpair
#define splpage apu__sdbm_splpage
int fitpair(char *, int);
void putpair(char *, apr_sdbm_datum_t, apr_sdbm_datum_t);
apr_sdbm_datum_t getpair(char *, apr_sdbm_datum_t);
int delpair(char *, apr_sdbm_datum_t);
int chkpage (char *);
apr_sdbm_datum_t getnkey(char *, int);
void splpage(char *, char *, long);
int duppair(char *, apr_sdbm_datum_t);
#endif /* SDBM_PAIR_H */

84
contrib/apr-util/dbm/sdbm/sdbm_private.h
View File

@ -1,84 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* sdbm - ndbm work-alike hashed database library
* based on Per-Ake Larson's Dynamic Hashing algorithms. BIT 18 (1978).
* author: oz@nexus.yorku.ca
*/
#ifndef SDBM_PRIVATE_H
#define SDBM_PRIVATE_H
#include "apr.h"
#include "apr_pools.h"
#include "apr_file_io.h"
#include "apr_errno.h" /* for apr_status_t */
#if 0
/* if the block/page size is increased, it breaks perl apr_sdbm_t compatibility */
#define DBLKSIZ 16384
#define PBLKSIZ 8192
#define PAIRMAX 8008 /* arbitrary on PBLKSIZ-N */
#else
#define DBLKSIZ 4096
#define PBLKSIZ 1024
#define PAIRMAX 1008 /* arbitrary on PBLKSIZ-N */
#endif
#define SPLTMAX 10 /* maximum allowed splits */
/* for apr_sdbm_t.flags */
#define SDBM_RDONLY 0x1 /* data base open read-only */
#define SDBM_SHARED 0x2 /* data base open for sharing */
#define SDBM_SHARED_LOCK 0x4 /* data base locked for shared read */
#define SDBM_EXCLUSIVE_LOCK 0x8 /* data base locked for write */
struct apr_sdbm_t {
apr_pool_t *pool;
apr_file_t *dirf; /* directory file descriptor */
apr_file_t *pagf; /* page file descriptor */
apr_int32_t flags; /* status/error flags, see below */
long maxbno; /* size of dirfile in bits */
long curbit; /* current bit number */
long hmask; /* current hash mask */
long blkptr; /* current block for nextkey */
int keyptr; /* current key for nextkey */
long blkno; /* current page to read/write */
long pagbno; /* current page in pagbuf */
char pagbuf[PBLKSIZ]; /* page file block buffer */
long dirbno; /* current block in dirbuf */
char dirbuf[DBLKSIZ]; /* directory file block buffer */
int lckcnt; /* number of calls to sdbm_lock */
};
#define sdbm_hash apu__sdbm_hash
#define sdbm_nullitem apu__sdbm_nullitem
extern const apr_sdbm_datum_t sdbm_nullitem;
long sdbm_hash(const char *str, int len);
/*
* zero the cache
*/
#define SDBM_INVALIDATE_CACHE(db, finfo) \
do { db->dirbno = (!finfo.size) ? 0 : -1; \
db->pagbno = -1; \
db->maxbno = (long)(finfo.size * BYTESIZ); \
} while (0);
#endif /* SDBM_PRIVATE_H */

40
contrib/apr-util/dbm/sdbm/sdbm_tune.h
View File

@ -1,40 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* sdbm - ndbm work-alike hashed database library
* tuning and portability constructs [not nearly enough]
* author: oz@nexus.yorku.ca
*/
#ifndef SDBM_TUNE_H
#define SDBM_TUNE_H
#include "apr_errno.h"
/* ### this might be better off as sizeof(char *) */
#define BYTESIZ 8
/*
* misc
*/
#ifdef DEBUG
#define debug(x) printf x
#else
#define debug(x)
#endif
#endif /* SDBM_TUNE_H */

32
contrib/apr-util/docs/doxygen.conf
View File

@ -1,32 +0,0 @@
PROJECT_NAME="Apache Portable Runtime Utility Library"
INPUT=.
QUIET=YES
RECURSIVE=YES
FILE_PATTERNS=*.h
OUTPUT_DIRECTORY=docs/dox
MACRO_EXPANSION=YES
EXPAND_ONLY_PREDEF=YES
#EXPAND_AS_DEFINED=
# not sure why this doesn't work as EXPAND_AS_DEFINED, it should!
PREDEFINED="APU_DECLARE(x)=x" \
"APU_DECLARE_NONSTD(x)=x" \
"APU_DECLARE_DATA" \
"APU_MODULE_DECLARE_DATA" \
"APU_DECLARE_LDAP(x)=x" \
"APR_HAS_MMAP" \
"APR_HAS_THREADS" \
"APR_HAS_XLATE" \
"__attribute__(x)=" \
DOXYGEN=
OPTIMIZE_OUTPUT_FOR_C=YES
FULL_PATH_NAMES=YES
CASE_SENSE_NAMES=NO
# some autoconf guru needs to make configure set this correctly...
#STRIP_FROM_PATH=/root/apache/httpd-2.0-8/srclib/apr-util
GENERATE_TAGFILE=docs/dox/apu.tag

268
contrib/apr-util/encoding/apr_base64.c
View File

@ -1,268 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* base64 encoder/decoder. Originally part of main/util.c
* but moved here so that support/ab and apr_sha1.c could
* use it. This meant removing the apr_palloc()s and adding
* ugly 'len' functions, which is quite a nasty cost.
*/
#include "apr_base64.h"
#if APR_CHARSET_EBCDIC
#include "apr_xlate.h"
#endif /* APR_CHARSET_EBCDIC */
/* aaaack but it's fast and const should make it shared text page. */
static const unsigned char pr2six[256] =
{
#if !APR_CHARSET_EBCDIC
/* ASCII table */
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64,
64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
#else /*APR_CHARSET_EBCDIC*/
/* EBCDIC table */
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 64, 64, 64, 64, 64, 64,
64, 35, 36, 37, 38, 39, 40, 41, 42, 43, 64, 64, 64, 64, 64, 64,
64, 64, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 64, 64, 64, 64, 64, 64,
64, 9, 10, 11, 12, 13, 14, 15, 16, 17, 64, 64, 64, 64, 64, 64,
64, 64, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64, 64,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64
#endif /*APR_CHARSET_EBCDIC*/
};
#if APR_CHARSET_EBCDIC
static apr_xlate_t *xlate_to_ebcdic;
static unsigned char os_toascii[256];
APU_DECLARE(apr_status_t) apr_base64init_ebcdic(apr_xlate_t *to_ascii,
apr_xlate_t *to_ebcdic)
{
int i;
apr_size_t inbytes_left, outbytes_left;
apr_status_t rv;
int onoff;
/* Only single-byte conversion is supported.
*/
rv = apr_xlate_sb_get(to_ascii, &onoff);
if (rv) {
return rv;
}
if (!onoff) { /* If conversion is not single-byte-only */
return APR_EINVAL;
}
rv = apr_xlate_sb_get(to_ebcdic, &onoff);
if (rv) {
return rv;
}
if (!onoff) { /* If conversion is not single-byte-only */
return APR_EINVAL;
}
xlate_to_ebcdic = to_ebcdic;
for (i = 0; i < sizeof(os_toascii); i++) {
os_toascii[i] = i;
}
inbytes_left = outbytes_left = sizeof(os_toascii);
apr_xlate_conv_buffer(to_ascii, os_toascii, &inbytes_left,
os_toascii, &outbytes_left);
return APR_SUCCESS;
}
#endif /*APR_CHARSET_EBCDIC*/
APU_DECLARE(int) apr_base64_decode_len(const char *bufcoded)
{
int nbytesdecoded;
register const unsigned char *bufin;
register apr_size_t nprbytes;
bufin = (const unsigned char *) bufcoded;
while (pr2six[*(bufin++)] <= 63);
nprbytes = (bufin - (const unsigned char *) bufcoded) - 1;
nbytesdecoded = (((int)nprbytes + 3) / 4) * 3;
return nbytesdecoded + 1;
}
APU_DECLARE(int) apr_base64_decode(char *bufplain, const char *bufcoded)
{
#if APR_CHARSET_EBCDIC
apr_size_t inbytes_left, outbytes_left;
#endif /* APR_CHARSET_EBCDIC */
int len;
len = apr_base64_decode_binary((unsigned char *) bufplain, bufcoded);
#if APR_CHARSET_EBCDIC
inbytes_left = outbytes_left = len;
apr_xlate_conv_buffer(xlate_to_ebcdic, bufplain, &inbytes_left,
bufplain, &outbytes_left);
#endif /* APR_CHARSET_EBCDIC */
bufplain[len] = '\0';
return len;
}
/* This is the same as apr_base64_decode() except on EBCDIC machines, where
* the conversion of the output to ebcdic is left out.
*/
APU_DECLARE(int) apr_base64_decode_binary(unsigned char *bufplain,
const char *bufcoded)
{
int nbytesdecoded;
register const unsigned char *bufin;
register unsigned char *bufout;
register apr_size_t nprbytes;
bufin = (const unsigned char *) bufcoded;
while (pr2six[*(bufin++)] <= 63);
nprbytes = (bufin - (const unsigned char *) bufcoded) - 1;
nbytesdecoded = (((int)nprbytes + 3) / 4) * 3;
bufout = (unsigned char *) bufplain;
bufin = (const unsigned char *) bufcoded;
while (nprbytes > 4) {
*(bufout++) =
(unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
*(bufout++) =
(unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
*(bufout++) =
(unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);
bufin += 4;
nprbytes -= 4;
}
/* Note: (nprbytes == 1) would be an error, so just ingore that case */
if (nprbytes > 1) {
*(bufout++) =
(unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
}
if (nprbytes > 2) {
*(bufout++) =
(unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
}
if (nprbytes > 3) {
*(bufout++) =
(unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);
}
nbytesdecoded -= (4 - (int)nprbytes) & 3;
return nbytesdecoded;
}
static const char basis_64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
APU_DECLARE(int) apr_base64_encode_len(int len)
{
return ((len + 2) / 3 * 4) + 1;
}
APU_DECLARE(int) apr_base64_encode(char *encoded, const char *string, int len)
{
#if !APR_CHARSET_EBCDIC
return apr_base64_encode_binary(encoded, (const unsigned char *) string, len);
#else /* APR_CHARSET_EBCDIC */
int i;
char *p;
p = encoded;
for (i = 0; i < len - 2; i += 3) {
*p++ = basis_64[(os_toascii[string[i]] >> 2) & 0x3F];
*p++ = basis_64[((os_toascii[string[i]] & 0x3) << 4) |
((int) (os_toascii[string[i + 1]] & 0xF0) >> 4)];
*p++ = basis_64[((os_toascii[string[i + 1]] & 0xF) << 2) |
((int) (os_toascii[string[i + 2]] & 0xC0) >> 6)];
*p++ = basis_64[os_toascii[string[i + 2]] & 0x3F];
}
if (i < len) {
*p++ = basis_64[(os_toascii[string[i]] >> 2) & 0x3F];
if (i == (len - 1)) {
*p++ = basis_64[((os_toascii[string[i]] & 0x3) << 4)];
*p++ = '=';
}
else {
*p++ = basis_64[((os_toascii[string[i]] & 0x3) << 4) |
((int) (os_toascii[string[i + 1]] & 0xF0) >> 4)];
*p++ = basis_64[((os_toascii[string[i + 1]] & 0xF) << 2)];
}
*p++ = '=';
}
*p++ = '\0';
return p - encoded;
#endif /* APR_CHARSET_EBCDIC */
}
/* This is the same as apr_base64_encode() except on EBCDIC machines, where
* the conversion of the input to ascii is left out.
*/
APU_DECLARE(int) apr_base64_encode_binary(char *encoded,
const unsigned char *string, int len)
{
int i;
char *p;
p = encoded;
for (i = 0; i < len - 2; i += 3) {
*p++ = basis_64[(string[i] >> 2) & 0x3F];
*p++ = basis_64[((string[i] & 0x3) << 4) |
((int) (string[i + 1] & 0xF0) >> 4)];
*p++ = basis_64[((string[i + 1] & 0xF) << 2) |
((int) (string[i + 2] & 0xC0) >> 6)];
*p++ = basis_64[string[i + 2] & 0x3F];
}
if (i < len) {
*p++ = basis_64[(string[i] >> 2) & 0x3F];
if (i == (len - 1)) {
*p++ = basis_64[((string[i] & 0x3) << 4)];
*p++ = '=';
}
else {
*p++ = basis_64[((string[i] & 0x3) << 4) |
((int) (string[i + 1] & 0xF0) >> 4)];
*p++ = basis_64[((string[i + 1] & 0xF) << 2)];
}
*p++ = '=';
}
*p++ = '\0';
return (int)(p - encoded);
}

13
contrib/apr-util/export_vars.sh.in
View File

@ -1,13 +0,0 @@
#
# export_vars.sh
#
# This shell script is used to export vars to the application using the
# APRUTIL library. This script should be "sourced" to ensure the variable
# values are set within the calling script's context. For example:
#
# $ . path/to/apr-util/export_vars.sh
#
APRUTIL_EXPORT_INCLUDES="@APRUTIL_INCLUDES@"
APRUTIL_EXPORT_LIBS="@APRUTIL_EXPORT_LIBS@"
APRUTIL_LDFLAGS="@APRUTIL_LDFLAGS@"

414
contrib/apr-util/hooks/apr_hooks.c
View File

@ -1,414 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "apr_pools.h"
#include "apr_tables.h"
#include "apr.h"
#include "apr_hooks.h"
#include "apr_hash.h"
#include "apr_optional_hooks.h"
#include "apr_optional.h"
#define APR_WANT_MEMFUNC
#define APR_WANT_STRFUNC
#include "apr_want.h"
#if 0
#define apr_palloc(pool,size) malloc(size)
#endif
APU_DECLARE_DATA apr_pool_t *apr_hook_global_pool = NULL;
APU_DECLARE_DATA int apr_hook_debug_enabled = 0;
APU_DECLARE_DATA const char *apr_hook_debug_current = NULL;
/** @deprecated @see apr_hook_global_pool */
APU_DECLARE_DATA apr_pool_t *apr_global_hook_pool = NULL;
/** @deprecated @see apr_hook_debug_enabled */
APU_DECLARE_DATA int apr_debug_module_hooks = 0;
/** @deprecated @see apr_hook_debug_current */
APU_DECLARE_DATA const char *apr_current_hooking_module = NULL;
/* NB: This must echo the LINK_##name structure */
typedef struct
{
void (*dummy)(void *);
const char *szName;
const char * const *aszPredecessors;
const char * const *aszSuccessors;
int nOrder;
} TSortData;
typedef struct tsort_
{
void *pData;
int nPredecessors;
struct tsort_ **ppPredecessors;
struct tsort_ *pNext;
} TSort;
#ifdef NETWARE
#include "apr_private.h"
#define get_apd APP_DATA* apd = (APP_DATA*)get_app_data(gLibId);
#define s_aHooksToSort ((apr_array_header_t *)(apd->gs_aHooksToSort))
#define s_phOptionalHooks ((apr_hash_t *)(apd->gs_phOptionalHooks))
#define s_phOptionalFunctions ((apr_hash_t *)(apd->gs_phOptionalFunctions))
#endif
static int crude_order(const void *a_,const void *b_)
{
const TSortData *a=a_;
const TSortData *b=b_;
return a->nOrder-b->nOrder;
}
static TSort *prepare(apr_pool_t *p,TSortData *pItems,int nItems)
{
TSort *pData=apr_palloc(p,nItems*sizeof *pData);
int n;
qsort(pItems,nItems,sizeof *pItems,crude_order);
for(n=0 ; n < nItems ; ++n) {
pData[n].nPredecessors=0;
pData[n].ppPredecessors=apr_pcalloc(p,nItems*sizeof *pData[n].ppPredecessors);
pData[n].pNext=NULL;
pData[n].pData=&pItems[n];
}
for(n=0 ; n < nItems ; ++n) {
int i,k;
for(i=0 ; pItems[n].aszPredecessors && pItems[n].aszPredecessors[i] ; ++i)
for(k=0 ; k < nItems ; ++k)
if(!strcmp(pItems[k].szName,pItems[n].aszPredecessors[i])) {
int l;
for(l=0 ; l < pData[n].nPredecessors ; ++l)
if(pData[n].ppPredecessors[l] == &pData[k])
goto got_it;
pData[n].ppPredecessors[pData[n].nPredecessors]=&pData[k];
++pData[n].nPredecessors;
got_it:
break;
}
for(i=0 ; pItems[n].aszSuccessors && pItems[n].aszSuccessors[i] ; ++i)
for(k=0 ; k < nItems ; ++k)
if(!strcmp(pItems[k].szName,pItems[n].aszSuccessors[i])) {
int l;
for(l=0 ; l < pData[k].nPredecessors ; ++l)
if(pData[k].ppPredecessors[l] == &pData[n])
goto got_it2;
pData[k].ppPredecessors[pData[k].nPredecessors]=&pData[n];
++pData[k].nPredecessors;
got_it2:
break;
}
}
return pData;
}
/* Topologically sort, dragging out-of-order items to the front. Note that
this tends to preserve things that want to be near the front better, and
changing that behaviour might compromise some of Apache's behaviour (in
particular, mod_log_forensic might otherwise get pushed to the end, and
core.c's log open function used to end up at the end when pushing items
to the back was the methedology). Also note that the algorithm could
go back to its original simplicity by sorting from the back instead of
the front.
*/
static TSort *tsort(TSort *pData,int nItems)
{
int nTotal;
TSort *pHead=NULL;
TSort *pTail=NULL;
for(nTotal=0 ; nTotal < nItems ; ++nTotal) {
int n,i,k;
for(n=0 ; ; ++n) {
if(n == nItems)
assert(0); /* we have a loop... */
if(!pData[n].pNext) {
if(pData[n].nPredecessors) {
for(k=0 ; ; ++k) {
assert(k < nItems);
if(pData[n].ppPredecessors[k])
break;
}
for(i=0 ; ; ++i) {
assert(i < nItems);
if(&pData[i] == pData[n].ppPredecessors[k]) {
n=i-1;
break;
}
}
} else
break;
}
}
if(pTail)
pTail->pNext=&pData[n];
else
pHead=&pData[n];
pTail=&pData[n];
pTail->pNext=pTail; /* fudge it so it looks linked */
for(i=0 ; i < nItems ; ++i)
for(k=0 ; k < nItems ; ++k)
if(pData[i].ppPredecessors[k] == &pData[n]) {
--pData[i].nPredecessors;
pData[i].ppPredecessors[k]=NULL;
break;
}
}
pTail->pNext=NULL; /* unfudge the tail */
return pHead;
}
static apr_array_header_t *sort_hook(apr_array_header_t *pHooks,
const char *szName)
{
apr_pool_t *p;
TSort *pSort;
apr_array_header_t *pNew;
int n;
apr_pool_create(&p, apr_hook_global_pool);
pSort=prepare(p,(TSortData *)pHooks->elts,pHooks->nelts);
pSort=tsort(pSort,pHooks->nelts);
pNew=apr_array_make(apr_hook_global_pool,pHooks->nelts,sizeof(TSortData));
if(apr_hook_debug_enabled)
printf("Sorting %s:",szName);
for(n=0 ; pSort ; pSort=pSort->pNext,++n) {
TSortData *pHook;
assert(n < pHooks->nelts);
pHook=apr_array_push(pNew);
memcpy(pHook,pSort->pData,sizeof *pHook);
if(apr_hook_debug_enabled)
printf(" %s",pHook->szName);
}
if(apr_hook_debug_enabled)
fputc('\n',stdout);
/* destroy the pool - the sorted hooks were already copied */
apr_pool_destroy(p);
return pNew;
}
#ifndef NETWARE
static apr_array_header_t *s_aHooksToSort;
#endif
typedef struct
{
const char *szHookName;
apr_array_header_t **paHooks;
} HookSortEntry;
APU_DECLARE(void) apr_hook_sort_register(const char *szHookName,
apr_array_header_t **paHooks)
{
#ifdef NETWARE
get_apd
#endif
HookSortEntry *pEntry;
if(!s_aHooksToSort)
s_aHooksToSort=apr_array_make(apr_hook_global_pool,1,sizeof(HookSortEntry));
pEntry=apr_array_push(s_aHooksToSort);
pEntry->szHookName=szHookName;
pEntry->paHooks=paHooks;
}
APU_DECLARE(void) apr_hook_sort_all(void)
{
#ifdef NETWARE
get_apd
#endif
int n;
if (!s_aHooksToSort) {
s_aHooksToSort = apr_array_make(apr_hook_global_pool, 1, sizeof(HookSortEntry));
}
for(n=0 ; n < s_aHooksToSort->nelts ; ++n) {
HookSortEntry *pEntry=&((HookSortEntry *)s_aHooksToSort->elts)[n];
*pEntry->paHooks=sort_hook(*pEntry->paHooks,pEntry->szHookName);
}
}
#ifndef NETWARE
static apr_hash_t *s_phOptionalHooks;
static apr_hash_t *s_phOptionalFunctions;
#endif
APU_DECLARE(void) apr_hook_deregister_all(void)
{
#ifdef NETWARE
get_apd
#endif
int n;
if (!s_aHooksToSort) {
return;
}
for(n=0 ; n < s_aHooksToSort->nelts ; ++n) {
HookSortEntry *pEntry=&((HookSortEntry *)s_aHooksToSort->elts)[n];
*pEntry->paHooks=NULL;
}
s_aHooksToSort=NULL;
s_phOptionalHooks=NULL;
s_phOptionalFunctions=NULL;
}
APU_DECLARE(void) apr_hook_debug_show(const char *szName,
const char * const *aszPre,
const char * const *aszSucc)
{
int nFirst;
printf(" Hooked %s",szName);
if(aszPre) {
fputs(" pre(",stdout);
nFirst=1;
while(*aszPre) {
if(!nFirst)
fputc(',',stdout);
nFirst=0;
fputs(*aszPre,stdout);
++aszPre;
}
fputc(')',stdout);
}
if(aszSucc) {
fputs(" succ(",stdout);
nFirst=1;
while(*aszSucc) {
if(!nFirst)
fputc(',',stdout);
nFirst=0;
fputs(*aszSucc,stdout);
++aszSucc;
}
fputc(')',stdout);
}
fputc('\n',stdout);
}
/* Optional hook support */
APR_DECLARE_EXTERNAL_HOOK(apr,APU,void,_optional,(void))
APU_DECLARE(apr_array_header_t *) apr_optional_hook_get(const char *szName)
{
#ifdef NETWARE
get_apd
#endif
apr_array_header_t **ppArray;
if(!s_phOptionalHooks)
return NULL;
ppArray=apr_hash_get(s_phOptionalHooks,szName,strlen(szName));
if(!ppArray)
return NULL;
return *ppArray;
}
APU_DECLARE(void) apr_optional_hook_add(const char *szName,void (*pfn)(void),
const char * const *aszPre,
const char * const *aszSucc,int nOrder)
{
#ifdef NETWARE
get_apd
#endif
apr_array_header_t *pArray=apr_optional_hook_get(szName);
apr_LINK__optional_t *pHook;
if(!pArray) {
apr_array_header_t **ppArray;
pArray=apr_array_make(apr_hook_global_pool,1,
sizeof(apr_LINK__optional_t));
if(!s_phOptionalHooks)
s_phOptionalHooks=apr_hash_make(apr_hook_global_pool);
ppArray=apr_palloc(apr_hook_global_pool,sizeof *ppArray);
*ppArray=pArray;
apr_hash_set(s_phOptionalHooks,szName,strlen(szName),ppArray);
apr_hook_sort_register(szName,ppArray);
}
pHook=apr_array_push(pArray);
pHook->pFunc=pfn;
pHook->aszPredecessors=aszPre;
pHook->aszSuccessors=aszSucc;
pHook->nOrder=nOrder;
pHook->szName=apr_hook_debug_current;
if(apr_hook_debug_enabled)
apr_hook_debug_show(szName,aszPre,aszSucc);
}
/* optional function support */
APU_DECLARE(apr_opt_fn_t *) apr_dynamic_fn_retrieve(const char *szName)
{
#ifdef NETWARE
get_apd
#endif
if(!s_phOptionalFunctions)
return NULL;
return (void(*)(void))apr_hash_get(s_phOptionalFunctions,szName,strlen(szName));
}
/* Deprecated */
APU_DECLARE_NONSTD(void) apr_dynamic_fn_register(const char *szName,
apr_opt_fn_t *pfn)
{
#ifdef NETWARE
get_apd
#endif
if(!s_phOptionalFunctions)
s_phOptionalFunctions=apr_hash_make(apr_hook_global_pool);
apr_hash_set(s_phOptionalFunctions,szName,strlen(szName),(void *)pfn);
}
#if 0
void main()
{
const char *aszAPre[]={"b","c",NULL};
const char *aszBPost[]={"a",NULL};
const char *aszCPost[]={"b",NULL};
TSortData t1[]=
{
{ "a",aszAPre,NULL },
{ "b",NULL,aszBPost },
{ "c",NULL,aszCPost }
};
TSort *pResult;
pResult=prepare(t1,3);
pResult=tsort(pResult,3);
for( ; pResult ; pResult=pResult->pNext)
printf("%s\n",pResult->pData->szName);
}
#endif

128
contrib/apr-util/include/apr_anylock.h
View File

@ -1,128 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file apr_anylock.h
* @brief APR-Util transparent any lock flavor wrapper
*/
#ifndef APR_ANYLOCK_H
#define APR_ANYLOCK_H
#include "apr_proc_mutex.h"
#include "apr_thread_mutex.h"
#include "apr_thread_rwlock.h"
/** Structure that may contain any APR lock type */
typedef struct apr_anylock_t {
/** Indicates what type of lock is in lock */
enum tm_lock {
apr_anylock_none, /**< None */
apr_anylock_procmutex, /**< Process-based */
apr_anylock_threadmutex, /**< Thread-based */
apr_anylock_readlock, /**< Read lock */
apr_anylock_writelock /**< Write lock */
} type;
/** Union of all possible APR locks */
union apr_anylock_u_t {
apr_proc_mutex_t *pm; /**< Process mutex */
#if APR_HAS_THREADS
apr_thread_mutex_t *tm; /**< Thread mutex */
apr_thread_rwlock_t *rw; /**< Read-write lock */
#endif
} lock;
} apr_anylock_t;
#if APR_HAS_THREADS
/** Lock an apr_anylock_t structure */
#define APR_ANYLOCK_LOCK(lck) \
(((lck)->type == apr_anylock_none) \
? APR_SUCCESS \
: (((lck)->type == apr_anylock_threadmutex) \
? apr_thread_mutex_lock((lck)->lock.tm) \
: (((lck)->type == apr_anylock_procmutex) \
? apr_proc_mutex_lock((lck)->lock.pm) \
: (((lck)->type == apr_anylock_readlock) \
? apr_thread_rwlock_rdlock((lck)->lock.rw) \
: (((lck)->type == apr_anylock_writelock) \
? apr_thread_rwlock_wrlock((lck)->lock.rw) \
: APR_EINVAL)))))
#else /* APR_HAS_THREADS */
#define APR_ANYLOCK_LOCK(lck) \
(((lck)->type == apr_anylock_none) \
? APR_SUCCESS \
: (((lck)->type == apr_anylock_procmutex) \
? apr_proc_mutex_lock((lck)->lock.pm) \
: APR_EINVAL))
#endif /* APR_HAS_THREADS */
#if APR_HAS_THREADS
/** Try to lock an apr_anylock_t structure */
#define APR_ANYLOCK_TRYLOCK(lck) \
(((lck)->type == apr_anylock_none) \
? APR_SUCCESS \
: (((lck)->type == apr_anylock_threadmutex) \
? apr_thread_mutex_trylock((lck)->lock.tm) \
: (((lck)->type == apr_anylock_procmutex) \
? apr_proc_mutex_trylock((lck)->lock.pm) \
: (((lck)->type == apr_anylock_readlock) \
? apr_thread_rwlock_tryrdlock((lck)->lock.rw) \
: (((lck)->type == apr_anylock_writelock) \
? apr_thread_rwlock_trywrlock((lck)->lock.rw) \
: APR_EINVAL)))))
#else /* APR_HAS_THREADS */
#define APR_ANYLOCK_TRYLOCK(lck) \
(((lck)->type == apr_anylock_none) \
? APR_SUCCESS \
: (((lck)->type == apr_anylock_procmutex) \
? apr_proc_mutex_trylock((lck)->lock.pm) \
: APR_EINVAL))
#endif /* APR_HAS_THREADS */
#if APR_HAS_THREADS
/** Unlock an apr_anylock_t structure */
#define APR_ANYLOCK_UNLOCK(lck) \
(((lck)->type == apr_anylock_none) \
? APR_SUCCESS \
: (((lck)->type == apr_anylock_threadmutex) \
? apr_thread_mutex_unlock((lck)->lock.tm) \
: (((lck)->type == apr_anylock_procmutex) \
? apr_proc_mutex_unlock((lck)->lock.pm) \
: ((((lck)->type == apr_anylock_readlock) || \
((lck)->type == apr_anylock_writelock)) \
? apr_thread_rwlock_unlock((lck)->lock.rw) \
: APR_EINVAL))))
#else /* APR_HAS_THREADS */
#define APR_ANYLOCK_UNLOCK(lck) \
(((lck)->type == apr_anylock_none) \
? APR_SUCCESS \
: (((lck)->type == apr_anylock_procmutex) \
? apr_proc_mutex_unlock((lck)->lock.pm) \
: APR_EINVAL))
#endif /* APR_HAS_THREADS */
#endif /* !APR_ANYLOCK_H */

113
contrib/apr-util/include/apr_base64.h
View File

@ -1,113 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* The apr_vsnprintf/apr_snprintf functions are based on, and used with the
* permission of, the SIO stdio-replacement strx_* functions by Panos
* Tsirigotis <panos@alumni.cs.colorado.edu> for xinetd.
*/
/**
* @file apr_base64.h
* @brief APR-UTIL Base64 Encoding
*/
#ifndef APR_BASE64_H
#define APR_BASE64_H
#include "apu.h"
#include "apr_general.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup APR_Util_Base64 Base64 Encoding
* @ingroup APR_Util
* @{
*/
/* Simple BASE64 encode/decode functions.
*
* As we might encode binary strings, hence we require the length of
* the incoming plain source. And return the length of what we decoded.
*
* The decoding function takes any non valid char (i.e. whitespace, \0
* or anything non A-Z,0-9 etc as terminal.
*
* plain strings/binary sequences are not assumed '\0' terminated. Encoded
* strings are neither. But probably should.
*
*/
/**
* Given the length of an un-encoded string, get the length of the
* encoded string.
* @param len the length of an unencoded string.
* @return the length of the string after it is encoded, including the
* trailing \0
*/
APU_DECLARE(int) apr_base64_encode_len(int len);
/**
* Encode a text string using base64encoding.
* @param coded_dst The destination string for the encoded string.
* @param plain_src The original string in plain text
* @param len_plain_src The length of the plain text string
* @return the length of the encoded string
*/
APU_DECLARE(int) apr_base64_encode(char * coded_dst, const char *plain_src,
int len_plain_src);
/**
* Encode an EBCDIC string using base64encoding.
* @param coded_dst The destination string for the encoded string.
* @param plain_src The original string in plain text
* @param len_plain_src The length of the plain text string
* @return the length of the encoded string
*/
APU_DECLARE(int) apr_base64_encode_binary(char * coded_dst,
const unsigned char *plain_src,
int len_plain_src);
/**
* Determine the maximum buffer length required to decode the plain text
* string given the encoded string.
* @param coded_src The encoded string
* @return the maximum required buffer length for the plain text string
*/
APU_DECLARE(int) apr_base64_decode_len(const char * coded_src);
/**
* Decode a string to plain text
* @param plain_dst The destination string for the plain text
* @param coded_src The encoded string
* @return the length of the plain text string
*/
APU_DECLARE(int) apr_base64_decode(char * plain_dst, const char *coded_src);
/**
* Decode an EBCDIC string to plain text
* @param plain_dst The destination string for the plain text
* @param coded_src The encoded string
* @return the length of the plain text string
*/
APU_DECLARE(int) apr_base64_decode_binary(unsigned char * plain_dst,
const char *coded_src);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_BASE64_H */

1598
contrib/apr-util/include/apr_buckets.h
View File

File diff suppressed because it is too large Load Diff

507
contrib/apr-util/include/apr_crypto.h
View File

@ -1,507 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef APR_CRYPTO_H
#define APR_CRYPTO_H
#include "apu.h"
#include "apr_pools.h"
#include "apr_tables.h"
#include "apr_hash.h"
#include "apu_errno.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @file apr_crypto.h
* @brief APR-UTIL Crypto library
*/
/**
* @defgroup APR_Util_Crypto Crypto routines
* @ingroup APR_Util
* @{
*/
#if APU_HAVE_CRYPTO
#ifndef APU_CRYPTO_RECOMMENDED_DRIVER
#if APU_HAVE_COMMONCRYPTO
#define APU_CRYPTO_RECOMMENDED_DRIVER "commoncrypto"
#else
#if APU_HAVE_OPENSSL
#define APU_CRYPTO_RECOMMENDED_DRIVER "openssl"
#else
#if APU_HAVE_NSS
#define APU_CRYPTO_RECOMMENDED_DRIVER "nss"
#else
#if APU_HAVE_MSCNG
#define APU_CRYPTO_RECOMMENDED_DRIVER "mscng"
#else
#if APU_HAVE_MSCAPI
#define APU_CRYPTO_RECOMMENDED_DRIVER "mscapi"
#else
#endif
#endif
#endif
#endif
#endif
#endif
/**
* Symmetric Key types understood by the library.
*
* NOTE: It is expected that this list will grow over time.
*
* Interoperability Matrix:
*
* The matrix is based on the testcrypto.c unit test, which attempts to
* test whether a simple encrypt/decrypt will succeed, as well as testing
* whether an encrypted string by one library can be decrypted by the
* others.
*
* Some libraries will successfully encrypt and decrypt their own data,
* but won't decrypt data from another library. It is hoped that over
* time these anomalies will be found and fixed, but until then it is
* recommended that ciphers are chosen that interoperate across platform.
*
* An X below means the test passes, it does not necessarily mean that
* encryption performed is correct or secure. Applications should stick
* to ciphers that pass the interoperablity tests on the right hand side
* of the table.
*
* Aligned data is data whose length is a multiple of the block size for
* the chosen cipher. Padded data is data that is not aligned by block
* size and must be padded by the crypto library.
*
* OpenSSL CommonCrypto NSS Interop
* Align Pad Align Pad Align Pad Align Pad
* 3DES_192/CBC X X X X X X X X
* 3DES_192/ECB X X X X
* AES_256/CBC X X X X X X X X
* AES_256/ECB X X X X X X
* AES_192/CBC X X X X X X
* AES_192/ECB X X X X X
* AES_128/CBC X X X X X X
* AES_128/ECB X X X X X
*
* Conclusion: for padded data, use 3DES_192/CBC or AES_256/CBC. For
* aligned data, use 3DES_192/CBC, AES_256/CBC or AES_256/ECB.
*/
typedef enum
{
APR_KEY_NONE, APR_KEY_3DES_192, /** 192 bit (3-Key) 3DES */
APR_KEY_AES_128, /** 128 bit AES */
APR_KEY_AES_192, /** 192 bit AES */
APR_KEY_AES_256
/** 256 bit AES */
} apr_crypto_block_key_type_e;
typedef enum
{
APR_MODE_NONE, /** An error condition */
APR_MODE_ECB, /** Electronic Code Book */
APR_MODE_CBC
/** Cipher Block Chaining */
} apr_crypto_block_key_mode_e;
/* These are opaque structs. Instantiation is up to each backend */
typedef struct apr_crypto_driver_t apr_crypto_driver_t;
typedef struct apr_crypto_t apr_crypto_t;
typedef struct apr_crypto_config_t apr_crypto_config_t;
typedef struct apr_crypto_key_t apr_crypto_key_t;
typedef struct apr_crypto_block_t apr_crypto_block_t;
typedef struct apr_crypto_block_key_type_t {
apr_crypto_block_key_type_e type;
int keysize;
int blocksize;
int ivsize;
} apr_crypto_block_key_type_t;
typedef struct apr_crypto_block_key_mode_t {
apr_crypto_block_key_mode_e mode;
} apr_crypto_block_key_mode_t;
typedef struct apr_crypto_passphrase_t {
const char *pass;
apr_size_t passLen;
const unsigned char * salt;
apr_size_t saltLen;
int iterations;
} apr_crypto_passphrase_t;
typedef struct apr_crypto_secret_t {
const unsigned char *secret;
apr_size_t secretLen;
} apr_crypto_secret_t;
typedef enum {
/** Key is derived from a passphrase */
APR_CRYPTO_KTYPE_PASSPHRASE = 1,
/** Key is derived from a raw key */
APR_CRYPTO_KTYPE_SECRET = 2,
} apr_crypto_key_type;
typedef struct apr_crypto_key_rec_t {
apr_crypto_key_type ktype;
apr_crypto_block_key_type_e type;
apr_crypto_block_key_mode_e mode;
int pad;
union {
apr_crypto_passphrase_t passphrase;
apr_crypto_secret_t secret;
} k;
} apr_crypto_key_rec_t;
/**
* @brief Perform once-only initialisation. Call once only.
*
* @param pool - pool to register any shutdown cleanups, etc
* @return APR_NOTIMPL in case of no crypto support.
*/
APU_DECLARE(apr_status_t) apr_crypto_init(apr_pool_t *pool);
/**
* @brief Zero out the buffer provided when the pool is cleaned up.
*
* @param pool - pool to register the cleanup
* @param buffer - buffer to zero out
* @param size - size of the buffer to zero out
*/
APU_DECLARE(apr_status_t) apr_crypto_clear(apr_pool_t *pool, void *buffer,
apr_size_t size);
/**
* @brief Always zero out the buffer provided, without being optimized out by
* the compiler.
*
* @param buffer - buffer to zero out
* @param size - size of the buffer to zero out
*/
APU_DECLARE(apr_status_t) apr_crypto_memzero(void *buffer, apr_size_t size);
/**
* @brief Timing attacks safe buffers comparison, where the executing time does
* not depend on the bytes compared but solely on the number of bytes.
*
* @param buf1 - first buffer to compare
* @param buf2 - second buffer to compare
* @param size - size of the buffers to compare
* @return 1 if the buffers are equals, 0 otherwise.
*/
APU_DECLARE(int) apr_crypto_equals(const void *buf1, const void *buf2,
apr_size_t size);
/**
* @brief Get the driver struct for a name
*
* @param driver - pointer to driver struct.
* @param name - driver name
* @param params - array of initialisation parameters
* @param result - result and error message on failure
* @param pool - (process) pool to register cleanup
* @return APR_SUCCESS for success
* @return APR_ENOTIMPL for no driver (when DSO not enabled)
* @return APR_EDSOOPEN if DSO driver file can't be opened
* @return APR_ESYMNOTFOUND if the driver file doesn't contain a driver
* @remarks NSS: the params can have "dir", "key3", "cert7" and "secmod"
* keys, each followed by an equal sign and a value. Such key/value pairs can
* be delimited by space or tab. If the value contains a space, surround the
* whole key value pair in quotes: "dir=My Directory".
* @remarks OpenSSL: currently no params are supported.
*/
APU_DECLARE(apr_status_t) apr_crypto_get_driver(
const apr_crypto_driver_t **driver,
const char *name, const char *params, const apu_err_t **result,
apr_pool_t *pool);
/**
* @brief Return the name of the driver.
*
* @param driver - The driver in use.
* @return The name of the driver.
*/
APU_DECLARE(const char *) apr_crypto_driver_name(
const apr_crypto_driver_t *driver);
/**
* @brief Get the result of the last operation on a context. If the result
* is NULL, the operation was successful.
* @param result - the result structure
* @param f - context pointer
* @return APR_SUCCESS for success
*/
APU_DECLARE(apr_status_t) apr_crypto_error(const apu_err_t **result,
const apr_crypto_t *f);
/**
* @brief Create a context for supporting encryption. Keys, certificates,
* algorithms and other parameters will be set per context. More than
* one context can be created at one time. A cleanup will be automatically
* registered with the given pool to guarantee a graceful shutdown.
* @param f - context pointer will be written here
* @param driver - driver to use
* @param params - array of key parameters
* @param pool - process pool
* @return APR_ENOENGINE when the engine specified does not exist. APR_EINITENGINE
* if the engine cannot be initialised.
* @remarks NSS: currently no params are supported.
* @remarks OpenSSL: the params can have "engine" as a key, followed by an equal
* sign and a value.
*/
APU_DECLARE(apr_status_t) apr_crypto_make(apr_crypto_t **f,
const apr_crypto_driver_t *driver, const char *params,
apr_pool_t *pool);
/**
* @brief Get a hash table of key types, keyed by the name of the type against
* a pointer to apr_crypto_block_key_type_t, which in turn begins with an
* integer.
*
* @param types - hashtable of key types keyed to constants.
* @param f - encryption context
* @return APR_SUCCESS for success
*/
APU_DECLARE(apr_status_t) apr_crypto_get_block_key_types(apr_hash_t **types,
const apr_crypto_t *f);
/**
* @brief Get a hash table of key modes, keyed by the name of the mode against
* a pointer to apr_crypto_block_key_mode_t, which in turn begins with an
* integer.
*
* @param modes - hashtable of key modes keyed to constants.
* @param f - encryption context
* @return APR_SUCCESS for success
*/
APU_DECLARE(apr_status_t) apr_crypto_get_block_key_modes(apr_hash_t **modes,
const apr_crypto_t *f);
/**
* @brief Create a key from the provided secret or passphrase. The key is cleaned
* up when the context is cleaned, and may be reused with multiple encryption
* or decryption operations.
* @note If *key is NULL, a apr_crypto_key_t will be created from a pool. If
* *key is not NULL, *key must point at a previously created structure.
* @param key The key returned, see note.
* @param rec The key record, from which the key will be derived.
* @param f The context to use.
* @param p The pool to use.
* @return Returns APR_ENOKEY if the pass phrase is missing or empty, or if a backend
* error occurred while generating the key. APR_ENOCIPHER if the type or mode
* is not supported by the particular backend. APR_EKEYTYPE if the key type is
* not known. APR_EPADDING if padding was requested but is not supported.
* APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_key(apr_crypto_key_t **key,
const apr_crypto_key_rec_t *rec, const apr_crypto_t *f, apr_pool_t *p);
/**
* @brief Create a key from the given passphrase. By default, the PBKDF2
* algorithm is used to generate the key from the passphrase. It is expected
* that the same pass phrase will generate the same key, regardless of the
* backend crypto platform used. The key is cleaned up when the context
* is cleaned, and may be reused with multiple encryption or decryption
* operations.
* @note If *key is NULL, a apr_crypto_key_t will be created from a pool. If
* *key is not NULL, *key must point at a previously created structure.
* @param key The key returned, see note.
* @param ivSize The size of the initialisation vector will be returned, based
* on whether an IV is relevant for this type of crypto.
* @param pass The passphrase to use.
* @param passLen The passphrase length in bytes
* @param salt The salt to use.
* @param saltLen The salt length in bytes
* @param type 3DES_192, AES_128, AES_192, AES_256.
* @param mode Electronic Code Book / Cipher Block Chaining.
* @param doPad Pad if necessary.
* @param iterations Number of iterations to use in algorithm
* @param f The context to use.
* @param p The pool to use.
* @return Returns APR_ENOKEY if the pass phrase is missing or empty, or if a backend
* error occurred while generating the key. APR_ENOCIPHER if the type or mode
* is not supported by the particular backend. APR_EKEYTYPE if the key type is
* not known. APR_EPADDING if padding was requested but is not supported.
* APR_ENOTIMPL if not implemented.
* @deprecated Replaced by apr_crypto_key().
*/
APU_DECLARE(apr_status_t) apr_crypto_passphrase(apr_crypto_key_t **key,
apr_size_t *ivSize, const char *pass, apr_size_t passLen,
const unsigned char * salt, apr_size_t saltLen,
const apr_crypto_block_key_type_e type,
const apr_crypto_block_key_mode_e mode, const int doPad,
const int iterations, const apr_crypto_t *f, apr_pool_t *p);
/**
* @brief Initialise a context for encrypting arbitrary data using the given key.
* @note If *ctx is NULL, a apr_crypto_block_t will be created from a pool. If
* *ctx is not NULL, *ctx must point at a previously created structure.
* @param ctx The block context returned, see note.
* @param iv Optional initialisation vector. If the buffer pointed to is NULL,
* an IV will be created at random, in space allocated from the pool.
* If the buffer pointed to is not NULL, the IV in the buffer will be
* used.
* @param key The key structure to use.
* @param blockSize The block size of the cipher.
* @param p The pool to use.
* @return Returns APR_ENOIV if an initialisation vector is required but not specified.
* Returns APR_EINIT if the backend failed to initialise the context. Returns
* APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_encrypt_init(
apr_crypto_block_t **ctx, const unsigned char **iv,
const apr_crypto_key_t *key, apr_size_t *blockSize, apr_pool_t *p);
/**
* @brief Encrypt data provided by in, write it to out.
* @note The number of bytes written will be written to outlen. If
* out is NULL, outlen will contain the maximum size of the
* buffer needed to hold the data, including any data
* generated by apr_crypto_block_encrypt_finish below. If *out points
* to NULL, a buffer sufficiently large will be created from
* the pool provided. If *out points to a not-NULL value, this
* value will be used as a buffer instead.
* @param out Address of a buffer to which data will be written,
* see note.
* @param outlen Length of the output will be written here.
* @param in Address of the buffer to read.
* @param inlen Length of the buffer to read.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
* not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_encrypt(unsigned char **out,
apr_size_t *outlen, const unsigned char *in, apr_size_t inlen,
apr_crypto_block_t *ctx);
/**
* @brief Encrypt final data block, write it to out.
* @note If necessary the final block will be written out after being
* padded. Typically the final block will be written to the
* same buffer used by apr_crypto_block_encrypt, offset by the
* number of bytes returned as actually written by the
* apr_crypto_block_encrypt() call. After this call, the context
* is cleaned and can be reused by apr_crypto_block_encrypt_init().
* @param out Address of a buffer to which data will be written. This
* buffer must already exist, and is usually the same
* buffer used by apr_evp_crypt(). See note.
* @param outlen Length of the output will be written here.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred.
* @return APR_EPADDING if padding was enabled and the block was incorrectly
* formatted.
* @return APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_encrypt_finish(unsigned char *out,
apr_size_t *outlen, apr_crypto_block_t *ctx);
/**
* @brief Initialise a context for decrypting arbitrary data using the given key.
* @note If *ctx is NULL, a apr_crypto_block_t will be created from a pool. If
* *ctx is not NULL, *ctx must point at a previously created structure.
* @param ctx The block context returned, see note.
* @param blockSize The block size of the cipher.
* @param iv Optional initialisation vector.
* @param key The key structure to use.
* @param p The pool to use.
* @return Returns APR_ENOIV if an initialisation vector is required but not specified.
* Returns APR_EINIT if the backend failed to initialise the context. Returns
* APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_decrypt_init(
apr_crypto_block_t **ctx, apr_size_t *blockSize,
const unsigned char *iv, const apr_crypto_key_t *key, apr_pool_t *p);
/**
* @brief Decrypt data provided by in, write it to out.
* @note The number of bytes written will be written to outlen. If
* out is NULL, outlen will contain the maximum size of the
* buffer needed to hold the data, including any data
* generated by apr_crypto_block_decrypt_finish below. If *out points
* to NULL, a buffer sufficiently large will be created from
* the pool provided. If *out points to a not-NULL value, this
* value will be used as a buffer instead.
* @param out Address of a buffer to which data will be written,
* see note.
* @param outlen Length of the output will be written here.
* @param in Address of the buffer to read.
* @param inlen Length of the buffer to read.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
* not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_decrypt(unsigned char **out,
apr_size_t *outlen, const unsigned char *in, apr_size_t inlen,
apr_crypto_block_t *ctx);
/**
* @brief Decrypt final data block, write it to out.
* @note If necessary the final block will be written out after being
* padded. Typically the final block will be written to the
* same buffer used by apr_crypto_block_decrypt, offset by the
* number of bytes returned as actually written by the
* apr_crypto_block_decrypt() call. After this call, the context
* is cleaned and can be reused by apr_crypto_block_decrypt_init().
* @param out Address of a buffer to which data will be written. This
* buffer must already exist, and is usually the same
* buffer used by apr_evp_crypt(). See note.
* @param outlen Length of the output will be written here.
* @param ctx The block context to use.
* @return APR_ECRYPT if an error occurred.
* @return APR_EPADDING if padding was enabled and the block was incorrectly
* formatted.
* @return APR_ENOTIMPL if not implemented.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_decrypt_finish(unsigned char *out,
apr_size_t *outlen, apr_crypto_block_t *ctx);
/**
* @brief Clean encryption / decryption context.
* @note After cleanup, a context is free to be reused if necessary.
* @param ctx The block context to use.
* @return Returns APR_ENOTIMPL if not supported.
*/
APU_DECLARE(apr_status_t) apr_crypto_block_cleanup(apr_crypto_block_t *ctx);
/**
* @brief Clean encryption / decryption context.
* @note After cleanup, a context is free to be reused if necessary.
* @param f The context to use.
* @return Returns APR_ENOTIMPL if not supported.
*/
APU_DECLARE(apr_status_t) apr_crypto_cleanup(apr_crypto_t *f);
/**
* @brief Shutdown the crypto library.
* @note After shutdown, it is expected that the init function can be called again.
* @param driver - driver to use
* @return Returns APR_ENOTIMPL if not supported.
*/
APU_DECLARE(apr_status_t) apr_crypto_shutdown(
const apr_crypto_driver_t *driver);
#endif /* APU_HAVE_CRYPTO */
/** @} */
#ifdef __cplusplus
}
#endif
#endif

106
contrib/apr-util/include/apr_date.h
View File

@ -1,106 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef APR_DATE_H
#define APR_DATE_H
/**
* @file apr_date.h
* @brief APR-UTIL date routines
*/
/**
* @defgroup APR_Util_Date Date routines
* @ingroup APR_Util
* @{
*/
/*
* apr_date.h: prototypes for date parsing utility routines
*/
#include "apu.h"
#include "apr_time.h"
#ifdef __cplusplus
extern "C" {
#endif
/** A bad date. */
#define APR_DATE_BAD ((apr_time_t)0)
/**
* Compare a string to a mask
* @param data The string to compare
* @param mask Mask characters (arbitrary maximum is 256 characters):
* <PRE>
* '\@' - uppercase letter
* '\$' - lowercase letter
* '\&' - hex digit
* '#' - digit
* '~' - digit or space
* '*' - swallow remaining characters
* </PRE>
* @remark The mask tests for an exact match for any other character
* @return 1 if the string matches, 0 otherwise
*/
APU_DECLARE(int) apr_date_checkmask(const char *data, const char *mask);
/**
* Parses an HTTP date in one of three standard forms:
* <PRE>
* Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
* Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
* Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format
* </PRE>
* @param date The date in one of the three formats above
* @return the apr_time_t number of microseconds since 1 Jan 1970 GMT, or
* 0 if this would be out of range or if the date is invalid.
*/
APU_DECLARE(apr_time_t) apr_date_parse_http(const char *date);
/**
* Parses a string resembling an RFC 822 date. This is meant to be
* leinent in its parsing of dates. Hence, this will parse a wider
* range of dates than apr_date_parse_http.
*
* The prominent mailer (or poster, if mailer is unknown) that has
* been seen in the wild is included for the unknown formats.
* <PRE>
* Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
* Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
* Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format
* Sun, 6 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
* Sun, 06 Nov 94 08:49:37 GMT ; RFC 822
* Sun, 6 Nov 94 08:49:37 GMT ; RFC 822
* Sun, 06 Nov 94 08:49 GMT ; Unknown [drtr\@ast.cam.ac.uk]
* Sun, 6 Nov 94 08:49 GMT ; Unknown [drtr\@ast.cam.ac.uk]
* Sun, 06 Nov 94 8:49:37 GMT ; Unknown [Elm 70.85]
* Sun, 6 Nov 94 8:49:37 GMT ; Unknown [Elm 70.85]
* </PRE>
*
* @param date The date in one of the formats above
* @return the apr_time_t number of microseconds since 1 Jan 1970 GMT, or
* 0 if this would be out of range or if the date is invalid.
*/
APU_DECLARE(apr_time_t) apr_date_parse_rfc(const char *date);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_DATE_H */

549
contrib/apr-util/include/apr_dbd.h
View File

@ -1,549 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* Overview of what this is and does:
* http://www.apache.org/~niq/dbd.html
*/
#ifndef APR_DBD_H
#define APR_DBD_H
#include "apu.h"
#include "apr_pools.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @file apr_dbd.h
* @brief APR-UTIL DBD library
*/
/**
* @defgroup APR_Util_DBD DBD routines
* @ingroup APR_Util
* @{
*/
/**
* Mapping of C to SQL types, used for prepared statements.
* @remarks
* For apr_dbd_p[v]query/select functions, in and out parameters are always
* const char * (i.e. regular nul terminated strings). LOB types are passed
* with four (4) arguments: payload, length, table and column, all as const
* char *, where table and column are reserved for future use by Oracle.
* @remarks
* For apr_dbd_p[v]bquery/select functions, in and out parameters are
* described next to each enumeration constant and are generally native binary
* types or some APR data type. LOB types are passed with four (4) arguments:
* payload (char*), length (apr_size_t*), table (char*) and column (char*).
* Table and column are reserved for future use by Oracle.
*/
typedef enum {
APR_DBD_TYPE_NONE,
APR_DBD_TYPE_TINY, /**< \%hhd : in, out: char* */
APR_DBD_TYPE_UTINY, /**< \%hhu : in, out: unsigned char* */
APR_DBD_TYPE_SHORT, /**< \%hd : in, out: short* */
APR_DBD_TYPE_USHORT, /**< \%hu : in, out: unsigned short* */
APR_DBD_TYPE_INT, /**< \%d : in, out: int* */
APR_DBD_TYPE_UINT, /**< \%u : in, out: unsigned int* */
APR_DBD_TYPE_LONG, /**< \%ld : in, out: long* */
APR_DBD_TYPE_ULONG, /**< \%lu : in, out: unsigned long* */
APR_DBD_TYPE_LONGLONG, /**< \%lld : in, out: apr_int64_t* */
APR_DBD_TYPE_ULONGLONG, /**< \%llu : in, out: apr_uint64_t* */
APR_DBD_TYPE_FLOAT, /**< \%f : in, out: float* */
APR_DBD_TYPE_DOUBLE, /**< \%lf : in, out: double* */
APR_DBD_TYPE_STRING, /**< \%s : in: char*, out: char** */
APR_DBD_TYPE_TEXT, /**< \%pDt : in: char*, out: char** */
APR_DBD_TYPE_TIME, /**< \%pDi : in: char*, out: char** */
APR_DBD_TYPE_DATE, /**< \%pDd : in: char*, out: char** */
APR_DBD_TYPE_DATETIME, /**< \%pDa : in: char*, out: char** */
APR_DBD_TYPE_TIMESTAMP, /**< \%pDs : in: char*, out: char** */
APR_DBD_TYPE_ZTIMESTAMP, /**< \%pDz : in: char*, out: char** */
APR_DBD_TYPE_BLOB, /**< \%pDb : in: char* apr_size_t* char* char*, out: apr_bucket_brigade* */
APR_DBD_TYPE_CLOB, /**< \%pDc : in: char* apr_size_t* char* char*, out: apr_bucket_brigade* */
APR_DBD_TYPE_NULL /**< \%pDn : in: void*, out: void** */
} apr_dbd_type_e;
/* These are opaque structs. Instantiation is up to each backend */
typedef struct apr_dbd_driver_t apr_dbd_driver_t;
typedef struct apr_dbd_t apr_dbd_t;
typedef struct apr_dbd_transaction_t apr_dbd_transaction_t;
typedef struct apr_dbd_results_t apr_dbd_results_t;
typedef struct apr_dbd_row_t apr_dbd_row_t;
typedef struct apr_dbd_prepared_t apr_dbd_prepared_t;
/** apr_dbd_init: perform once-only initialisation. Call once only.
*
* @param pool - pool to register any shutdown cleanups, etc
*/
APU_DECLARE(apr_status_t) apr_dbd_init(apr_pool_t *pool);
/** apr_dbd_get_driver: get the driver struct for a name
*
* @param pool - (process) pool to register cleanup
* @param name - driver name
* @param driver - pointer to driver struct.
* @return APR_SUCCESS for success
* @return APR_ENOTIMPL for no driver (when DSO not enabled)
* @return APR_EDSOOPEN if DSO driver file can't be opened
* @return APR_ESYMNOTFOUND if the driver file doesn't contain a driver
*/
APU_DECLARE(apr_status_t) apr_dbd_get_driver(apr_pool_t *pool, const char *name,
const apr_dbd_driver_t **driver);
/** apr_dbd_open_ex: open a connection to a backend
*
* @param driver - driver struct.
* @param pool - working pool
* @param params - arguments to driver (implementation-dependent)
* @param handle - pointer to handle to return
* @param error - descriptive error.
* @return APR_SUCCESS for success
* @return APR_EGENERAL if driver exists but connection failed
* @remarks PostgreSQL: the params is passed directly to the PQconnectdb()
* function (check PostgreSQL documentation for more details on the syntax).
* @remarks SQLite2: the params is split on a colon, with the first part used
* as the filename and second part converted to an integer and used as file
* mode.
* @remarks SQLite3: the params is passed directly to the sqlite3_open()
* function as a filename to be opened (check SQLite3 documentation for more
* details).
* @remarks Oracle: the params can have "user", "pass", "dbname" and "server"
* keys, each followed by an equal sign and a value. Such key/value pairs can
* be delimited by space, CR, LF, tab, semicolon, vertical bar or comma.
* @remarks MySQL: the params can have "host", "port", "user", "pass",
* "dbname", "sock", "flags" "fldsz", "group" and "reconnect" keys, each
* followed by an equal sign and a value. Such key/value pairs can be
* delimited by space, CR, LF, tab, semicolon, vertical bar or comma. For
* now, "flags" can only recognise CLIENT_FOUND_ROWS (check MySQL manual for
* details). The value associated with "fldsz" determines maximum amount of
* memory (in bytes) for each of the fields in the result set of prepared
* statements. By default, this value is 1 MB. The value associated with
* "group" determines which group from configuration file to use (see
* MYSQL_READ_DEFAULT_GROUP option of mysql_options() in MySQL manual).
* Reconnect is set to 1 by default (i.e. true).
*/
APU_DECLARE(apr_status_t) apr_dbd_open_ex(const apr_dbd_driver_t *driver,
apr_pool_t *pool, const char *params,
apr_dbd_t **handle,
const char **error);
/** apr_dbd_open: open a connection to a backend
*
* @param driver - driver struct.
* @param pool - working pool
* @param params - arguments to driver (implementation-dependent)
* @param handle - pointer to handle to return
* @return APR_SUCCESS for success
* @return APR_EGENERAL if driver exists but connection failed
* @see apr_dbd_open_ex
*/
APU_DECLARE(apr_status_t) apr_dbd_open(const apr_dbd_driver_t *driver,
apr_pool_t *pool, const char *params,
apr_dbd_t **handle);
/** apr_dbd_close: close a connection to a backend
*
* @param driver - driver struct.
* @param handle - handle to close
* @return APR_SUCCESS for success or error status
*/
APU_DECLARE(apr_status_t) apr_dbd_close(const apr_dbd_driver_t *driver,
apr_dbd_t *handle);
/* apr-function-shaped versions of things */
/** apr_dbd_name: get the name of the driver
*
* @param driver - the driver
* @return - name
*/
APU_DECLARE(const char*) apr_dbd_name(const apr_dbd_driver_t *driver);
/** apr_dbd_native_handle: get native database handle of the underlying db
*
* @param driver - the driver
* @param handle - apr_dbd handle
* @return - native handle
*/
APU_DECLARE(void*) apr_dbd_native_handle(const apr_dbd_driver_t *driver,
apr_dbd_t *handle);
/** check_conn: check status of a database connection
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection to check
* @return APR_SUCCESS or error
*/
APU_DECLARE(int) apr_dbd_check_conn(const apr_dbd_driver_t *driver, apr_pool_t *pool,
apr_dbd_t *handle);
/** apr_dbd_set_dbname: select database name. May be a no-op if not supported.
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection
* @param name - the database to select
* @return 0 for success or error code
*/
APU_DECLARE(int) apr_dbd_set_dbname(const apr_dbd_driver_t *driver, apr_pool_t *pool,
apr_dbd_t *handle, const char *name);
/** apr_dbd_transaction_start: start a transaction. May be a no-op.
*
* @param driver - the driver
* @param pool - a pool to use for error messages (if any).
* @param handle - the db connection
* @param trans - ptr to a transaction. May be null on entry
* @return 0 for success or error code
* @remarks Note that transaction modes, set by calling
* apr_dbd_transaction_mode_set(), will affect all query/select calls within
* a transaction. By default, any error in query/select during a transaction
* will cause the transaction to inherit the error code and any further
* query/select calls will fail immediately. Put transaction in "ignore
* errors" mode to avoid that. Use "rollback" mode to do explicit rollback.
*/
APU_DECLARE(int) apr_dbd_transaction_start(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle,
apr_dbd_transaction_t **trans);
/** apr_dbd_transaction_end: end a transaction
* (commit on success, rollback on error).
* May be a no-op.
*
* @param driver - the driver
* @param handle - the db connection
* @param trans - the transaction.
* @return 0 for success or error code
*/
APU_DECLARE(int) apr_dbd_transaction_end(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_transaction_t *trans);
#define APR_DBD_TRANSACTION_COMMIT 0x00 /**< commit the transaction */
#define APR_DBD_TRANSACTION_ROLLBACK 0x01 /**< rollback the transaction */
#define APR_DBD_TRANSACTION_IGNORE_ERRORS 0x02 /**< ignore transaction errors */
/** apr_dbd_transaction_mode_get: get the mode of transaction
*
* @param driver - the driver
* @param trans - the transaction
* @return mode of transaction
*/
APU_DECLARE(int) apr_dbd_transaction_mode_get(const apr_dbd_driver_t *driver,
apr_dbd_transaction_t *trans);
/** apr_dbd_transaction_mode_set: set the mode of transaction
*
* @param driver - the driver
* @param trans - the transaction
* @param mode - new mode of the transaction
* @return the mode of transaction in force after the call
*/
APU_DECLARE(int) apr_dbd_transaction_mode_set(const apr_dbd_driver_t *driver,
apr_dbd_transaction_t *trans,
int mode);
/** apr_dbd_query: execute an SQL query that doesn't return a result set
*
* @param driver - the driver
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the SQL statement to execute
* @return 0 for success or error code
*/
APU_DECLARE(int) apr_dbd_query(const apr_dbd_driver_t *driver, apr_dbd_t *handle,
int *nrows, const char *statement);
/** apr_dbd_select: execute an SQL query that returns a result set
*
* @param driver - the driver
* @param pool - pool to allocate the result set
* @param handle - the connection
* @param res - pointer to result set pointer. May point to NULL on entry
* @param statement - the SQL statement to execute
* @param random - 1 to support random access to results (seek any row);
* 0 to support only looping through results in order
* (async access - faster)
* @return 0 for success or error code
*/
APU_DECLARE(int) apr_dbd_select(const apr_dbd_driver_t *driver, apr_pool_t *pool,
apr_dbd_t *handle, apr_dbd_results_t **res,
const char *statement, int random);
/** apr_dbd_num_cols: get the number of columns in a results set
*
* @param driver - the driver
* @param res - result set.
* @return number of columns
*/
APU_DECLARE(int) apr_dbd_num_cols(const apr_dbd_driver_t *driver,
apr_dbd_results_t *res);
/** apr_dbd_num_tuples: get the number of rows in a results set
* of a synchronous select
*
* @param driver - the driver
* @param res - result set.
* @return number of rows, or -1 if the results are asynchronous
*/
APU_DECLARE(int) apr_dbd_num_tuples(const apr_dbd_driver_t *driver,
apr_dbd_results_t *res);
/** apr_dbd_get_row: get a row from a result set
*
* @param driver - the driver
* @param pool - pool to allocate the row
* @param res - result set pointer
* @param row - pointer to row pointer. May point to NULL on entry
* @param rownum - row number (counting from 1), or -1 for "next row".
* Ignored if random access is not supported.
* @return 0 for success, -1 for rownum out of range or data finished
*/
APU_DECLARE(int) apr_dbd_get_row(const apr_dbd_driver_t *driver, apr_pool_t *pool,
apr_dbd_results_t *res, apr_dbd_row_t **row,
int rownum);
/** apr_dbd_get_entry: get an entry from a row
*
* @param driver - the driver
* @param row - row pointer
* @param col - entry number
* @return value from the row, or NULL if col is out of bounds.
*/
APU_DECLARE(const char*) apr_dbd_get_entry(const apr_dbd_driver_t *driver,
apr_dbd_row_t *row, int col);
/** apr_dbd_get_name: get an entry name from a result set
*
* @param driver - the driver
* @param res - result set pointer
* @param col - entry number
* @return name of the entry, or NULL if col is out of bounds.
*/
APU_DECLARE(const char*) apr_dbd_get_name(const apr_dbd_driver_t *driver,
apr_dbd_results_t *res, int col);
/** apr_dbd_error: get current error message (if any)
*
* @param driver - the driver
* @param handle - the connection
* @param errnum - error code from operation that returned an error
* @return the database current error message, or message for errnum
* (implementation-dependent whether errnum is ignored)
*/
APU_DECLARE(const char*) apr_dbd_error(const apr_dbd_driver_t *driver,
apr_dbd_t *handle, int errnum);
/** apr_dbd_escape: escape a string so it is safe for use in query/select
*
* @param driver - the driver
* @param pool - pool to alloc the result from
* @param string - the string to escape
* @param handle - the connection
* @return the escaped, safe string
*/
APU_DECLARE(const char*) apr_dbd_escape(const apr_dbd_driver_t *driver,
apr_pool_t *pool, const char *string,
apr_dbd_t *handle);
/** apr_dbd_prepare: prepare a statement
*
* @param driver - the driver
* @param pool - pool to alloc the result from
* @param handle - the connection
* @param query - the SQL query
* @param label - A label for the prepared statement.
* use NULL for temporary prepared statements
* (eg within a Request in httpd)
* @param statement - statement to prepare. May point to null on entry.
* @return 0 for success or error code
* @remarks To specify parameters of the prepared query, use \%s, \%d etc.
* (see below for full list) in place of database specific parameter syntax
* (e.g. for PostgreSQL, this would be $1, $2, for SQLite3 this would be ?
* etc.). For instance: "SELECT name FROM customers WHERE name=%s" would be
* a query that this function understands.
* @remarks Here is the full list of format specifiers that this function
* understands and what they map to in SQL: \%hhd (TINY INT), \%hhu (UNSIGNED
* TINY INT), \%hd (SHORT), \%hu (UNSIGNED SHORT), \%d (INT), \%u (UNSIGNED
* INT), \%ld (LONG), \%lu (UNSIGNED LONG), \%lld (LONG LONG), \%llu
* (UNSIGNED LONG LONG), \%f (FLOAT, REAL), \%lf (DOUBLE PRECISION), \%s
* (VARCHAR), \%pDt (TEXT), \%pDi (TIME), \%pDd (DATE), \%pDa (DATETIME),
* \%pDs (TIMESTAMP), \%pDz (TIMESTAMP WITH TIME ZONE), \%pDb (BLOB), \%pDc
* (CLOB) and \%pDn (NULL). Not all databases have support for all these
* types, so the underlying driver will attempt the "best match" where
* possible. A \% followed by any letter not in the above list will be
* interpreted as VARCHAR (i.e. \%s).
*/
APU_DECLARE(int) apr_dbd_prepare(const apr_dbd_driver_t *driver, apr_pool_t *pool,
apr_dbd_t *handle, const char *query,
const char *label,
apr_dbd_prepared_t **statement);
/** apr_dbd_pquery: query using a prepared statement + args
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the prepared statement to execute
* @param nargs - ignored (for backward compatibility only)
* @param args - args to prepared statement
* @return 0 for success or error code
*/
APU_DECLARE(int) apr_dbd_pquery(const apr_dbd_driver_t *driver, apr_pool_t *pool,
apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement, int nargs,
const char **args);
/** apr_dbd_pselect: select using a prepared statement + args
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection
* @param res - pointer to query results. May point to NULL on entry
* @param statement - the prepared statement to execute
* @param random - Whether to support random-access to results
* @param nargs - ignored (for backward compatibility only)
* @param args - args to prepared statement
* @return 0 for success or error code
*/
APU_DECLARE(int) apr_dbd_pselect(const apr_dbd_driver_t *driver, apr_pool_t *pool,
apr_dbd_t *handle, apr_dbd_results_t **res,
apr_dbd_prepared_t *statement, int random,
int nargs, const char **args);
/** apr_dbd_pvquery: query using a prepared statement + args
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the prepared statement to execute
* @param ... - varargs list
* @return 0 for success or error code
*/
APU_DECLARE_NONSTD(int) apr_dbd_pvquery(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement, ...);
/** apr_dbd_pvselect: select using a prepared statement + args
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection
* @param res - pointer to query results. May point to NULL on entry
* @param statement - the prepared statement to execute
* @param random - Whether to support random-access to results
* @param ... - varargs list
* @return 0 for success or error code
*/
APU_DECLARE_NONSTD(int) apr_dbd_pvselect(const apr_dbd_driver_t *driver,
apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_results_t **res,
apr_dbd_prepared_t *statement,
int random, ...);
/** apr_dbd_pbquery: query using a prepared statement + binary args
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the prepared statement to execute
* @param args - binary args to prepared statement
* @return 0 for success or error code
*/
APU_DECLARE(int) apr_dbd_pbquery(const apr_dbd_driver_t *driver,
apr_pool_t *pool, apr_dbd_t *handle,
int *nrows, apr_dbd_prepared_t *statement,
const void **args);
/** apr_dbd_pbselect: select using a prepared statement + binary args
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection
* @param res - pointer to query results. May point to NULL on entry
* @param statement - the prepared statement to execute
* @param random - Whether to support random-access to results
* @param args - binary args to prepared statement
* @return 0 for success or error code
*/
APU_DECLARE(int) apr_dbd_pbselect(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, apr_dbd_results_t **res,
apr_dbd_prepared_t *statement, int random,
const void **args);
/** apr_dbd_pvbquery: query using a prepared statement + binary args
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection
* @param nrows - number of rows affected.
* @param statement - the prepared statement to execute
* @param ... - varargs list of binary args
* @return 0 for success or error code
*/
APU_DECLARE_NONSTD(int) apr_dbd_pvbquery(const apr_dbd_driver_t *driver,
apr_pool_t *pool,
apr_dbd_t *handle, int *nrows,
apr_dbd_prepared_t *statement, ...);
/** apr_dbd_pvbselect: select using a prepared statement + binary args
*
* @param driver - the driver
* @param pool - working pool
* @param handle - the connection
* @param res - pointer to query results. May point to NULL on entry
* @param statement - the prepared statement to execute
* @param random - Whether to support random-access to results
* @param ... - varargs list of binary args
* @return 0 for success or error code
*/
APU_DECLARE_NONSTD(int) apr_dbd_pvbselect(const apr_dbd_driver_t *driver,
apr_pool_t *pool, apr_dbd_t *handle,
apr_dbd_results_t **res,
apr_dbd_prepared_t *statement,
int random, ...);
/** apr_dbd_datum_get: get a binary entry from a row
*
* @param driver - the driver
* @param row - row pointer
* @param col - entry number
* @param type - type of data to get
* @param data - pointer to data, allocated by the caller
* @return APR_SUCCESS on success, APR_ENOENT if data is NULL or APR_EGENERAL
*/
APU_DECLARE(apr_status_t) apr_dbd_datum_get(const apr_dbd_driver_t *driver,
apr_dbd_row_t *row, int col,
apr_dbd_type_e type, void *data);
/** @} */
#ifdef __cplusplus
}
#endif
#endif

227
contrib/apr-util/include/apr_dbm.h
View File

@ -1,227 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef APR_DBM_H
#define APR_DBM_H
#include "apu.h"
#include "apr.h"
#include "apr_errno.h"
#include "apr_pools.h"
#include "apr_file_info.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @file apr_dbm.h
* @brief APR-UTIL DBM library
*/
/**
* @defgroup APR_Util_DBM DBM routines
* @ingroup APR_Util
* @{
*/
/**
* Structure for referencing a dbm
*/
typedef struct apr_dbm_t apr_dbm_t;
/**
* Structure for referencing the datum record within a dbm
*/
typedef struct
{
/** pointer to the 'data' to retrieve/store in the DBM */
char *dptr;
/** size of the 'data' to retrieve/store in the DBM */
apr_size_t dsize;
} apr_datum_t;
/* modes to open the DB */
#define APR_DBM_READONLY 1 /**< open for read-only access */
#define APR_DBM_READWRITE 2 /**< open for read-write access */
#define APR_DBM_RWCREATE 3 /**< open for r/w, create if needed */
#define APR_DBM_RWTRUNC 4 /**< open for r/w, truncating an existing
DB if present */
/**
* Open a dbm file by file name and type of DBM
* @param dbm The newly opened database
* @param type The type of the DBM (not all may be available at run time)
* <pre>
* db for Berkeley DB files
* gdbm for GDBM files
* ndbm for NDBM files
* sdbm for SDBM files (always available)
* default for the default DBM type
* </pre>
* @param name The dbm file name to open
* @param mode The flag value
* <PRE>
* APR_DBM_READONLY open for read-only access
* APR_DBM_READWRITE open for read-write access
* APR_DBM_RWCREATE open for r/w, create if needed
* APR_DBM_RWTRUNC open for r/w, truncate if already there
* </PRE>
* @param perm Permissions to apply to if created
* @param cntxt The pool to use when creating the dbm
* @remark The dbm name may not be a true file name, as many dbm packages
* append suffixes for seperate data and index files.
* @bug In apr-util 0.9 and 1.x, the type arg was case insensitive. This
* was highly inefficient, and as of 2.x the dbm name must be provided in
* the correct case (lower case for all bundled providers)
*/
APU_DECLARE(apr_status_t) apr_dbm_open_ex(apr_dbm_t **dbm, const char* type,
const char *name,
apr_int32_t mode, apr_fileperms_t perm,
apr_pool_t *cntxt);
/**
* Open a dbm file by file name
* @param dbm The newly opened database
* @param name The dbm file name to open
* @param mode The flag value
* <PRE>
* APR_DBM_READONLY open for read-only access
* APR_DBM_READWRITE open for read-write access
* APR_DBM_RWCREATE open for r/w, create if needed
* APR_DBM_RWTRUNC open for r/w, truncate if already there
* </PRE>
* @param perm Permissions to apply to if created
* @param cntxt The pool to use when creating the dbm
* @remark The dbm name may not be a true file name, as many dbm packages
* append suffixes for seperate data and index files.
*/
APU_DECLARE(apr_status_t) apr_dbm_open(apr_dbm_t **dbm, const char *name,
apr_int32_t mode, apr_fileperms_t perm,
apr_pool_t *cntxt);
/**
* Close a dbm file previously opened by apr_dbm_open
* @param dbm The database to close
*/
APU_DECLARE(void) apr_dbm_close(apr_dbm_t *dbm);
/**
* Fetch a dbm record value by key
* @param dbm The database
* @param key The key datum to find this record
* @param pvalue The value datum retrieved for this record
*/
APU_DECLARE(apr_status_t) apr_dbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t *pvalue);
/**
* Store a dbm record value by key
* @param dbm The database
* @param key The key datum to store this record by
* @param value The value datum to store in this record
*/
APU_DECLARE(apr_status_t) apr_dbm_store(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t value);
/**
* Delete a dbm record value by key
* @param dbm The database
* @param key The key datum of the record to delete
* @remark It is not an error to delete a non-existent record.
*/
APU_DECLARE(apr_status_t) apr_dbm_delete(apr_dbm_t *dbm, apr_datum_t key);
/**
* Search for a key within the dbm
* @param dbm The database
* @param key The datum describing a key to test
*/
APU_DECLARE(int) apr_dbm_exists(apr_dbm_t *dbm, apr_datum_t key);
/**
* Retrieve the first record key from a dbm
* @param dbm The database
* @param pkey The key datum of the first record
*/
APU_DECLARE(apr_status_t) apr_dbm_firstkey(apr_dbm_t *dbm, apr_datum_t *pkey);
/**
* Retrieve the next record key from a dbm
* @param dbm The database
* @param pkey The key datum of the next record
*/
APU_DECLARE(apr_status_t) apr_dbm_nextkey(apr_dbm_t *dbm, apr_datum_t *pkey);
/**
* Proactively toss any memory associated with the apr_datum_t.
* @param dbm The database
* @param data The datum to free.
*/
APU_DECLARE(void) apr_dbm_freedatum(apr_dbm_t *dbm, apr_datum_t data);
/**
* Report more information when an apr_dbm function fails.
* @param dbm The database
* @param errcode A DBM-specific value for the error (for logging). If this
* isn't needed, it may be NULL.
* @param errbuf Location to store the error text
* @param errbufsize The size of the provided buffer
* @return The errbuf parameter, for convenience.
*/
APU_DECLARE(char *) apr_dbm_geterror(apr_dbm_t *dbm, int *errcode,
char *errbuf, apr_size_t errbufsize);
/**
* If the specified file/path were passed to apr_dbm_open(), return the
* actual file/path names which would be (created and) used. At most, two
* files may be used; used2 may be NULL if only one file is used.
* @param pool The pool for allocating used1 and used2.
* @param type The type of DBM you require info on @see apr_dbm_open_ex
* @param pathname The path name to generate used-names from.
* @param used1 The first pathname used by the apr_dbm implementation.
* @param used2 The second pathname used by apr_dbm. If only one file is
* used by the specific implementation, this will be set to NULL.
* @return An error if the specified type is invalid.
* @remark The dbm file(s) don't need to exist. This function only manipulates
* the pathnames.
*/
APU_DECLARE(apr_status_t) apr_dbm_get_usednames_ex(apr_pool_t *pool,
const char *type,
const char *pathname,
const char **used1,
const char **used2);
/**
* If the specified file/path were passed to apr_dbm_open(), return the
* actual file/path names which would be (created and) used. At most, two
* files may be used; used2 may be NULL if only one file is used.
* @param pool The pool for allocating used1 and used2.
* @param pathname The path name to generate used-names from.
* @param used1 The first pathname used by the apr_dbm implementation.
* @param used2 The second pathname used by apr_dbm. If only one file is
* used by the specific implementation, this will be set to NULL.
* @remark The dbm file(s) don't need to exist. This function only manipulates
* the pathnames.
*/
APU_DECLARE(void) apr_dbm_get_usednames(apr_pool_t *pool,
const char *pathname,
const char **used1,
const char **used2);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_DBM_H */

358
contrib/apr-util/include/apr_hooks.h
View File

@ -1,358 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef APR_HOOKS_H
#define APR_HOOKS_H
#include "apu.h"
/* For apr_array_header_t */
#include "apr_tables.h"
/**
* @file apr_hooks.h
* @brief Apache hook functions
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup APR_Util_Hook Hook Functions
* @ingroup APR_Util
* @{
*/
/**
* @defgroup apr_hook_probes Hook probe capability
* APR hooks provide a trace probe capability for capturing
* the flow of control and return values with hooks.
*
* In order to use this facility, the application must define
* the symbol APR_HOOK_PROBES_ENABLED and the four APR_HOOK_PROBE_
* macros described below before including apr_hooks.h in files
* that use the APR_IMPLEMENT_EXTERNAL_HOOK_* macros.
*
* This probe facility is not provided for APR optional hooks.
* @{
*/
#ifdef APR_HOOK_PROBES_ENABLED
#define APR_HOOK_INT_DCL_UD void *ud = NULL
#else
/** internal implementation detail to avoid the ud declaration when
* hook probes are not used
*/
#define APR_HOOK_INT_DCL_UD
/**
* User-defined hook probe macro that is invoked when the hook
* is run, before calling any hook functions.
* @param ud A void * user data field that should be filled in by
* this macro, and will be provided to the other hook probe macros.
* @param ns The namespace prefix of the hook functions
* @param name The name of the hook
* @param args The argument list to the hook functions, with enclosing
* parens.
*/
#define APR_HOOK_PROBE_ENTRY(ud,ns,name,args)
/**
* User-defined hook probe macro that is invoked after the hook
* has run.
* @param ud A void * user data field that was filled in by the user-
* provided APR_HOOK_PROBE_ENTRY().
* @param ns The namespace prefix of the hook functions
* @param name The name of the hook
* @param rv The return value of the hook, or 0 if the hook is void.
* @param args The argument list to the hook functions, with enclosing
* parens.
*/
#define APR_HOOK_PROBE_RETURN(ud,ns,name,rv,args)
/**
* User-defined hook probe macro that is invoked before calling a
* hook function.
* @param ud A void * user data field that was filled in by the user-
* provided APR_HOOK_PROBE_ENTRY().
* @param ns The namespace prefix of the hook functions
* @param name The name of the hook
* @param src The value of apr_hook_debug_current at the time the function
* was hooked (usually the source file implementing the hook function).
* @param args The argument list to the hook functions, with enclosing
* parens.
*/
#define APR_HOOK_PROBE_INVOKE(ud,ns,name,src,args)
/**
* User-defined hook probe macro that is invoked after calling a
* hook function.
* @param ud A void * user data field that was filled in by the user-
* provided APR_HOOK_PROBE_ENTRY().
* @param ns The namespace prefix of the hook functions
* @param name The name of the hook
* @param src The value of apr_hook_debug_current at the time the function
* was hooked (usually the source file implementing the hook function).
* @param rv The return value of the hook function, or 0 if the hook is void.
* @param args The argument list to the hook functions, with enclosing
* parens.
*/
#define APR_HOOK_PROBE_COMPLETE(ud,ns,name,src,rv,args)
#endif
/** @} */
/** macro to return the prototype of the hook function */
#define APR_IMPLEMENT_HOOK_GET_PROTO(ns,link,name) \
link##_DECLARE(apr_array_header_t *) ns##_hook_get_##name(void)
/** macro to declare the hook correctly */
#define APR_DECLARE_EXTERNAL_HOOK(ns,link,ret,name,args) \
typedef ret ns##_HOOK_##name##_t args; \
link##_DECLARE(void) ns##_hook_##name(ns##_HOOK_##name##_t *pf, \
const char * const *aszPre, \
const char * const *aszSucc, int nOrder); \
link##_DECLARE(ret) ns##_run_##name args; \
APR_IMPLEMENT_HOOK_GET_PROTO(ns,link,name); \
typedef struct ns##_LINK_##name##_t \
{ \
ns##_HOOK_##name##_t *pFunc; \
const char *szName; \
const char * const *aszPredecessors; \
const char * const *aszSuccessors; \
int nOrder; \
} ns##_LINK_##name##_t;
/** macro to declare the hook structure */
#define APR_HOOK_STRUCT(members) \
static struct { members } _hooks;
/** macro to link the hook structure */
#define APR_HOOK_LINK(name) \
apr_array_header_t *link_##name;
/** macro to implement the hook */
#define APR_IMPLEMENT_EXTERNAL_HOOK_BASE(ns,link,name) \
link##_DECLARE(void) ns##_hook_##name(ns##_HOOK_##name##_t *pf,const char * const *aszPre, \
const char * const *aszSucc,int nOrder) \
{ \
ns##_LINK_##name##_t *pHook; \
if(!_hooks.link_##name) \
{ \
_hooks.link_##name=apr_array_make(apr_hook_global_pool,1,sizeof(ns##_LINK_##name##_t)); \
apr_hook_sort_register(#name,&_hooks.link_##name); \
} \
pHook=apr_array_push(_hooks.link_##name); \
pHook->pFunc=pf; \
pHook->aszPredecessors=aszPre; \
pHook->aszSuccessors=aszSucc; \
pHook->nOrder=nOrder; \
pHook->szName=apr_hook_debug_current; \
if(apr_hook_debug_enabled) \
apr_hook_debug_show(#name,aszPre,aszSucc); \
} \
APR_IMPLEMENT_HOOK_GET_PROTO(ns,link,name) \
{ \
return _hooks.link_##name; \
}
/**
* Implement a hook that has no return code, and therefore runs all of the
* registered functions
* @param ns The namespace prefix of the hook functions
* @param link The linkage declaration prefix of the hook
* @param name The name of the hook
* @param args_decl The declaration of the arguments for the hook
* @param args_use The names for the arguments for the hook
* @note The link prefix FOO corresponds to FOO_DECLARE() macros, which
* provide export linkage from the module that IMPLEMENTs the hook, and
* import linkage from external modules that link to the hook's module.
*/
#define APR_IMPLEMENT_EXTERNAL_HOOK_VOID(ns,link,name,args_decl,args_use) \
APR_IMPLEMENT_EXTERNAL_HOOK_BASE(ns,link,name) \
link##_DECLARE(void) ns##_run_##name args_decl \
{ \
ns##_LINK_##name##_t *pHook; \
int n; \
APR_HOOK_INT_DCL_UD; \
\
APR_HOOK_PROBE_ENTRY(ud, ns, name, args_use); \
\
if(_hooks.link_##name) \
{ \
pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \
for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \
{ \
APR_HOOK_PROBE_INVOKE(ud, ns, name, (char *)pHook[n].szName, args_use); \
pHook[n].pFunc args_use; \
APR_HOOK_PROBE_COMPLETE(ud, ns, name, (char *)pHook[n].szName, 0, args_use); \
} \
} \
\
APR_HOOK_PROBE_RETURN(ud, ns, name, 0, args_use); \
\
}
/* FIXME: note that this returns ok when nothing is run. I suspect it should
really return decline, but that breaks Apache currently - Ben
*/
/**
* Implement a hook that runs until one of the functions returns something
* other than OK or DECLINE
* @param ns The namespace prefix of the hook functions
* @param link The linkage declaration prefix of the hook
* @param ret Type to return
* @param name The name of the hook
* @param args_decl The declaration of the arguments for the hook
* @param args_use The names for the arguments for the hook
* @param ok Success value
* @param decline Decline value
* @note The link prefix FOO corresponds to FOO_DECLARE() macros, which
* provide export linkage from the module that IMPLEMENTs the hook, and
* import linkage from external modules that link to the hook's module.
*/
#define APR_IMPLEMENT_EXTERNAL_HOOK_RUN_ALL(ns,link,ret,name,args_decl,args_use,ok,decline) \
APR_IMPLEMENT_EXTERNAL_HOOK_BASE(ns,link,name) \
link##_DECLARE(ret) ns##_run_##name args_decl \
{ \
ns##_LINK_##name##_t *pHook; \
int n; \
ret rv = ok; \
APR_HOOK_INT_DCL_UD; \
\
APR_HOOK_PROBE_ENTRY(ud, ns, name, args_use); \
\
if(_hooks.link_##name) \
{ \
pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \
for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \
{ \
APR_HOOK_PROBE_INVOKE(ud, ns, name, (char *)pHook[n].szName, args_use); \
rv=pHook[n].pFunc args_use; \
APR_HOOK_PROBE_COMPLETE(ud, ns, name, (char *)pHook[n].szName, rv, args_use); \
if(rv != ok && rv != decline) \
break; \
rv = ok; \
} \
} \
\
APR_HOOK_PROBE_RETURN(ud, ns, name, rv, args_use); \
\
return rv; \
}
/**
* Implement a hook that runs until the first function returns something
* other than the value of decline
* @param ns The namespace prefix of the hook functions
* @param link The linkage declaration prefix of the hook
* @param name The name of the hook
* @param ret Type to return
* @param args_decl The declaration of the arguments for the hook
* @param args_use The names for the arguments for the hook
* @param decline Decline value
* @note The link prefix FOO corresponds to FOO_DECLARE() macros, which
* provide export linkage from the module that IMPLEMENTs the hook, and
* import linkage from external modules that link to the hook's module.
*/
#define APR_IMPLEMENT_EXTERNAL_HOOK_RUN_FIRST(ns,link,ret,name,args_decl,args_use,decline) \
APR_IMPLEMENT_EXTERNAL_HOOK_BASE(ns,link,name) \
link##_DECLARE(ret) ns##_run_##name args_decl \
{ \
ns##_LINK_##name##_t *pHook; \
int n; \
ret rv = decline; \
APR_HOOK_INT_DCL_UD; \
\
APR_HOOK_PROBE_ENTRY(ud, ns, name, args_use); \
\
if(_hooks.link_##name) \
{ \
pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \
for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \
{ \
APR_HOOK_PROBE_INVOKE(ud, ns, name, (char *)pHook[n].szName, args_use); \
rv=pHook[n].pFunc args_use; \
APR_HOOK_PROBE_COMPLETE(ud, ns, name, (char *)pHook[n].szName, rv, args_use); \
\
if(rv != decline) \
break; \
} \
} \
\
APR_HOOK_PROBE_RETURN(ud, ns, name, rv, args_use); \
\
return rv; \
}
/* Hook orderings */
/** run this hook first, before ANYTHING */
#define APR_HOOK_REALLY_FIRST (-10)
/** run this hook first */
#define APR_HOOK_FIRST 0
/** run this hook somewhere */
#define APR_HOOK_MIDDLE 10
/** run this hook after every other hook which is defined*/
#define APR_HOOK_LAST 20
/** run this hook last, after EVERYTHING */
#define APR_HOOK_REALLY_LAST 30
/**
* The global pool used to allocate any memory needed by the hooks.
*/
APU_DECLARE_DATA extern apr_pool_t *apr_hook_global_pool;
/**
* A global variable to determine if debugging information about the
* hooks functions should be printed.
*/
APU_DECLARE_DATA extern int apr_hook_debug_enabled;
/**
* The name of the module that is currently registering a function.
*/
APU_DECLARE_DATA extern const char *apr_hook_debug_current;
/**
* Register a hook function to be sorted.
* @param szHookName The name of the Hook the function is registered for
* @param aHooks The array which stores all of the functions for this hook
*/
APU_DECLARE(void) apr_hook_sort_register(const char *szHookName,
apr_array_header_t **aHooks);
/**
* Sort all of the registered functions for a given hook.
*/
APU_DECLARE(void) apr_hook_sort_all(void);
/**
* Print all of the information about the current hook. This is used for
* debugging purposes.
* @param szName The name of the hook
* @param aszPre All of the functions in the predecessor array
* @param aszSucc All of the functions in the successor array
*/
APU_DECLARE(void) apr_hook_debug_show(const char *szName,
const char * const *aszPre,
const char * const *aszSucc);
/**
* Remove all currently registered functions.
*/
APU_DECLARE(void) apr_hook_deregister_all(void);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* APR_HOOKS_H */

197
contrib/apr-util/include/apr_ldap.h.in
View File

@ -1,197 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* apr_ldap.h is generated from apr_ldap.h.in by configure -- do not edit apr_ldap.h
*/
/**
* @file apr_ldap.h
* @brief APR-UTIL LDAP
*/
#ifndef APU_LDAP_H
#define APU_LDAP_H
/**
* @defgroup APR_Util_LDAP LDAP
* @ingroup APR_Util
* @{
*/
/* this will be defined if LDAP support was compiled into apr-util */
#define APR_HAS_LDAP @apu_has_ldap@
/* identify the LDAP toolkit used */
#define APR_HAS_NETSCAPE_LDAPSDK @apu_has_ldap_netscape@
#define APR_HAS_SOLARIS_LDAPSDK @apu_has_ldap_solaris@
#define APR_HAS_NOVELL_LDAPSDK @apu_has_ldap_novell@
#define APR_HAS_MOZILLA_LDAPSDK @apu_has_ldap_mozilla@
#define APR_HAS_OPENLDAP_LDAPSDK @apu_has_ldap_openldap@
#define APR_HAS_MICROSOFT_LDAPSDK @apu_has_ldap_microsoft@
#define APR_HAS_TIVOLI_LDAPSDK @apu_has_ldap_tivoli@
#define APR_HAS_ZOS_LDAPSDK @apu_has_ldap_zos@
#define APR_HAS_OTHER_LDAPSDK @apu_has_ldap_other@
/*
* Handle the case when LDAP is enabled
*/
#if APR_HAS_LDAP
/*
* The following #defines are DEPRECATED and should not be used for
* anything. They remain to maintain binary compatibility.
* The original code defined the OPENLDAP SDK as present regardless
* of what really was there, which was way bogus. In addition, the
* apr_ldap_url_parse*() functions have been rewritten specifically for
* APR, so the APR_HAS_LDAP_URL_PARSE macro is forced to zero.
*/
#if APR_HAS_TIVOLI_LDAPSDK
#define APR_HAS_LDAP_SSL 0
#else
#define APR_HAS_LDAP_SSL 1
#endif
#define APR_HAS_LDAP_URL_PARSE 0
#if APR_HAS_OPENLDAP_LDAPSDK && !defined(LDAP_DEPRECATED)
/* Ensure that the "deprecated" interfaces are still exposed
* with OpenLDAP >= 2.3; these were exposed by default in earlier
* releases. */
#define LDAP_DEPRECATED 1
#endif
/*
* Include the standard LDAP header files.
*/
@lber_h@
@ldap_h@
@ldap_ssl_h@
/*
* Detected standard functions
*/
#define APR_HAS_LDAPSSL_CLIENT_INIT @apu_has_ldapssl_client_init@
#define APR_HAS_LDAPSSL_CLIENT_DEINIT @apu_has_ldapssl_client_deinit@
#define APR_HAS_LDAPSSL_ADD_TRUSTED_CERT @apu_has_ldapssl_add_trusted_cert@
#define APR_HAS_LDAP_START_TLS_S @apu_has_ldap_start_tls_s@
#define APR_HAS_LDAP_SSLINIT @apu_has_ldap_sslinit@
#define APR_HAS_LDAPSSL_INIT @apu_has_ldapssl_init@
#define APR_HAS_LDAPSSL_INSTALL_ROUTINES @apu_has_ldapssl_install_routines@
/*
* Make sure the secure LDAP port is defined
*/
#ifndef LDAPS_PORT
#define LDAPS_PORT 636 /* ldaps:/// default LDAP over TLS port */
#endif
/*
* For ldap function calls that input a size limit on the number of returned elements
* Some SDKs do not have the define for LDAP_DEFAULT_LIMIT (-1) or LDAP_NO_LIMIT (0)
* LDAP_DEFAULT_LIMIT is preferred as it allows inheritance from whatever the SDK
* or process is configured for.
*/
#ifdef LDAP_DEFAULT_LIMIT
#define APR_LDAP_SIZELIMIT LDAP_DEFAULT_LIMIT
#else
#ifdef LDAP_NO_LIMIT
#define APR_LDAP_SIZELIMIT LDAP_NO_LIMIT
#endif
#endif
#ifndef APR_LDAP_SIZELIMIT
#define APR_LDAP_SIZELIMIT 0 /* equivalent to LDAP_NO_LIMIT, and what goes on the wire */
#endif
/*
* z/OS is missing some defines
*/
#ifndef LDAP_VERSION_MAX
#define LDAP_VERSION_MAX LDAP_VERSION
#endif
#if APR_HAS_ZOS_LDAPSDK
#define LDAP_VENDOR_NAME "IBM z/OS"
#endif
/* Note: Macros defining const casting has been removed in APR v1.0,
* pending real support for LDAP v2.0 toolkits.
*
* In the mean time, please use an LDAP v3.0 toolkit.
*/
#if LDAP_VERSION_MAX <= 2
#error Support for LDAP v2.0 toolkits has been removed from apr-util. Please use an LDAP v3.0 toolkit.
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* This structure allows the C LDAP API error codes to be returned
* along with plain text error messages that explain to us mere mortals
* what really happened.
*/
typedef struct apr_ldap_err_t {
const char *reason;
const char *msg;
int rc;
} apr_ldap_err_t;
#ifdef __cplusplus
}
#endif
/* The MS SDK returns LDAP_UNAVAILABLE when the backend has closed the connection
* between LDAP calls. Protect with APR_HAS_MICROSOFT_LDAPSDK in case someone
* manually chooses another SDK on Windows
*/
#if APR_HAS_MICROSOFT_LDAPSDK
#define APR_LDAP_IS_SERVER_DOWN(s) ((s) == LDAP_SERVER_DOWN \
|| (s) == LDAP_UNAVAILABLE)
#else
#define APR_LDAP_IS_SERVER_DOWN(s) ((s) == LDAP_SERVER_DOWN)
#endif
/* These symbols are not actually exported in a DSO build, but mapped into
* a private exported function array for apr_ldap_stub to bind dynamically.
* Rename them appropriately to protect the global namespace.
*/
#ifdef APU_DSO_LDAP_BUILD
#define apr_ldap_info apr__ldap_info
#define apr_ldap_init apr__ldap_init
#define apr_ldap_ssl_init apr__ldap_ssl_init
#define apr_ldap_ssl_deinit apr__ldap_ssl_deinit
#define apr_ldap_get_option apr__ldap_get_option
#define apr_ldap_set_option apr__ldap_set_option
#define apr_ldap_rebind_init apr__ldap_rebind_init
#define apr_ldap_rebind_add apr__ldap_rebind_add
#define apr_ldap_rebind_remove apr__ldap_rebind_remove
#define APU_DECLARE_LDAP(type) type
#else
#define APU_DECLARE_LDAP(type) APU_DECLARE(type)
#endif
#include "apr_ldap_url.h"
#include "apr_ldap_init.h"
#include "apr_ldap_option.h"
#include "apr_ldap_rebind.h"
#endif /* APR_HAS_LDAP */
/** @} */
#endif /* APU_LDAP_H */

158
contrib/apr-util/include/apr_ldap.hnw
View File

@ -1,158 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* apr_ldap.h is generated from apr_ldap.h.in by configure -- do not edit apr_ldap.h
*/
/**
* @file apr_ldap.h
* @brief APR-UTIL LDAP
*/
#ifndef APU_LDAP_H
#define APU_LDAP_H
/**
* @defgroup APR_Util_LDAP LDAP
* @ingroup APR_Util
* @{
*/
/* this will be defined if LDAP support was compiled into apr-util */
#define APR_HAS_LDAP 1
/* identify the LDAP toolkit used */
#define APR_HAS_NETSCAPE_LDAPSDK 0
#define APR_HAS_SOLARIS_LDAPSDK 0
#define APR_HAS_NOVELL_LDAPSDK 1
#define APR_HAS_MOZILLA_LDAPSDK 0
#define APR_HAS_OPENLDAP_LDAPSDK 0
#define APR_HAS_MICROSOFT_LDAPSDK 0
#define APR_HAS_OTHER_LDAPSDK 0
/*
* Handle the case when LDAP is enabled
*/
#if APR_HAS_LDAP
/*
* The following #defines are DEPRECATED and should not be used for
* anything. They remain to maintain binary compatibility.
* The original code defined the OPENLDAP SDK as present regardless
* of what really was there, which was way bogus. In addition, the
* apr_ldap_url_parse*() functions have been rewritten specifically for
* APR, so the APR_HAS_LDAP_URL_PARSE macro is forced to zero.
*/
#define APR_HAS_LDAP_SSL 1
#define APR_HAS_LDAP_URL_PARSE 0
/*
* Include the standard LDAP header files.
*/
#ifdef GENEXPORTS
#define LDAP_VERSION_MAX 3
#define LDAP_INSUFFICIENT_ACCESS
#else
#include <lber.h>
#include <ldap.h>
#if APR_HAS_LDAP_SSL
#include <ldap_ssl.h>
#endif
#endif
/*
* Detected standard functions
*/
#define APR_HAS_LDAPSSL_CLIENT_INIT 1
#define APR_HAS_LDAPSSL_CLIENT_DEINIT 1
#define APR_HAS_LDAPSSL_ADD_TRUSTED_CERT 1
#define APR_HAS_LDAP_START_TLS_S 0
#define APR_HAS_LDAP_SSLINIT 0
#define APR_HAS_LDAPSSL_INIT 1
#define APR_HAS_LDAPSSL_INSTALL_ROUTINES 0
/*
* Make sure the secure LDAP port is defined
*/
#ifndef LDAPS_PORT
#define LDAPS_PORT 636 /* ldaps:/// default LDAP over TLS port */
#endif
/* Note: Macros defining const casting has been removed in APR v1.0,
* pending real support for LDAP v2.0 toolkits.
*
* In the mean time, please use an LDAP v3.0 toolkit.
*/
#if LDAP_VERSION_MAX <= 2
#error Support for LDAP v2.0 toolkits has been removed from apr-util. Please use an LDAP v3.0 toolkit.
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* This structure allows the C LDAP API error codes to be returned
* along with plain text error messages that explain to us mere mortals
* what really happened.
*/
typedef struct apr_ldap_err_t {
const char *reason;
const char *msg;
int rc;
} apr_ldap_err_t;
#ifdef __cplusplus
}
#endif
#define APR_LDAP_IS_SERVER_DOWN(s) ((s) == LDAP_SERVER_DOWN)
/* These symbols are not actually exported in a DSO build, but mapped into
* a private exported function array for apr_ldap_stub to bind dynamically.
* Rename them appropriately to protect the global namespace.
*/
#ifdef APU_DSO_LDAP_BUILD
#define apr_ldap_info apr__ldap_info
#define apr_ldap_init apr__ldap_init
#define apr_ldap_ssl_init apr__ldap_ssl_init
#define apr_ldap_ssl_deinit apr__ldap_ssl_deinit
#define apr_ldap_get_option apr__ldap_get_option
#define apr_ldap_set_option apr__ldap_set_option
#define apr_ldap_rebind_init apr__ldap_rebind_init
#define apr_ldap_rebind_add apr__ldap_rebind_add
#define apr_ldap_rebind_remove apr__ldap_rebind_remove
#define APU_DECLARE_LDAP(type) type
#else
#define APU_DECLARE_LDAP(type) APU_DECLARE(type)
#endif
#include "apr_ldap_url.h"
#include "apr_ldap_init.h"
#include "apr_ldap_option.h"
#include "apr_ldap_rebind.h"
/** @} */
#endif /* APR_HAS_LDAP */
#endif /* APU_LDAP_H */

197
contrib/apr-util/include/apr_ldap.hw
View File

@ -1,197 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* apr_ldap.h is generated from apr_ldap.h.in by configure -- do not edit apr_ldap.h
*/
/**
* @file apr_ldap.h
* @brief APR-UTIL LDAP
*/
#ifndef APU_LDAP_H
#define APU_LDAP_H
/**
* @defgroup APR_Util_LDAP LDAP
* @ingroup APR_Util
* @{
*/
/* this will be defined if LDAP support was compiled into apr-util */
#define APR_HAS_LDAP 1
/* identify the LDAP toolkit used */
#define APR_HAS_NETSCAPE_LDAPSDK 0
#define APR_HAS_SOLARIS_LDAPSDK 0
#define APR_HAS_NOVELL_LDAPSDK 0
#define APR_HAS_MOZILLA_LDAPSDK 0
#define APR_HAS_OPENLDAP_LDAPSDK 0
#define APR_HAS_MICROSOFT_LDAPSDK 1
#define APR_HAS_TIVOLI_LDAPSDK 0
#define APR_HAS_ZOS_LDAPSDK 0
#define APR_HAS_OTHER_LDAPSDK 0
/*
* Handle the case when LDAP is enabled
*/
#if APR_HAS_LDAP
/*
* The following #defines are DEPRECATED and should not be used for
* anything. They remain to maintain binary compatibility.
* The original code defined the OPENLDAP SDK as present regardless
* of what really was there, which was way bogus. In addition, the
* apr_ldap_url_parse*() functions have been rewritten specifically for
* APR, so the APR_HAS_LDAP_URL_PARSE macro is forced to zero.
*/
#if APR_HAS_TIVOLI_LDAPSDK
#define APR_HAS_LDAP_SSL 0
#else
#define APR_HAS_LDAP_SSL 1
#endif
#define APR_HAS_LDAP_URL_PARSE 0
#if APR_HAS_OPENLDAP_LDAPSDK && !defined(LDAP_DEPRECATED)
/* Ensure that the "deprecated" interfaces are still exposed
* with OpenLDAP >= 2.3; these were exposed by default in earlier
* releases. */
#define LDAP_DEPRECATED 1
#endif
/*
* Include the standard LDAP header files.
*/
#include <winldap.h>
/*
* Detected standard functions
*/
#define APR_HAS_LDAPSSL_CLIENT_INIT 0
#define APR_HAS_LDAPSSL_CLIENT_DEINIT 0
#define APR_HAS_LDAPSSL_ADD_TRUSTED_CERT 0
#define APR_HAS_LDAP_START_TLS_S 0
#define APR_HAS_LDAP_SSLINIT 1
#define APR_HAS_LDAPSSL_INIT 0
#define APR_HAS_LDAPSSL_INSTALL_ROUTINES 0
/*
* Make sure the secure LDAP port is defined
*/
#ifndef LDAPS_PORT
#define LDAPS_PORT 636 /* ldaps:/// default LDAP over TLS port */
#endif
/*
* For ldap function calls that input a size limit on the number of returned elements
* Some SDKs do not have the define for LDAP_DEFAULT_LIMIT (-1) or LDAP_NO_LIMIT (0)
* LDAP_DEFAULT_LIMIT is preferred as it allows inheritance from whatever the SDK
* or process is configured for.
*/
#ifdef LDAP_DEFAULT_LIMIT
#define APR_LDAP_SIZELIMIT LDAP_DEFAULT_LIMIT
#else
#ifdef LDAP_NO_LIMIT
#define APR_LDAP_SIZELIMIT LDAP_NO_LIMIT
#endif
#endif
#ifndef APR_LDAP_SIZELIMIT
#define APR_LDAP_SIZELIMIT 0 /* equivalent to LDAP_NO_LIMIT, and what goes on the wire */
#endif
/*
* z/OS is missing some defines
*/
#ifndef LDAP_VERSION_MAX
#define LDAP_VERSION_MAX LDAP_VERSION
#endif
#if APR_HAS_ZOS_LDAPSDK
#define LDAP_VENDOR_NAME "IBM z/OS"
#endif
/* Note: Macros defining const casting has been removed in APR v1.0,
* pending real support for LDAP v2.0 toolkits.
*
* In the mean time, please use an LDAP v3.0 toolkit.
*/
#if LDAP_VERSION_MAX <= 2
#error Support for LDAP v2.0 toolkits has been removed from apr-util. Please use an LDAP v3.0 toolkit.
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* This structure allows the C LDAP API error codes to be returned
* along with plain text error messages that explain to us mere mortals
* what really happened.
*/
typedef struct apr_ldap_err_t {
const char *reason;
const char *msg;
int rc;
} apr_ldap_err_t;
#ifdef __cplusplus
}
#endif
/* The MS SDK returns LDAP_UNAVAILABLE when the backend has closed the connection
* between LDAP calls. Protect with APR_HAS_MICROSOFT_LDAPSDK in case someone
* manually chooses another SDK on Windows
*/
#if APR_HAS_MICROSOFT_LDAPSDK
#define APR_LDAP_IS_SERVER_DOWN(s) ((s) == LDAP_SERVER_DOWN \
|| (s) == LDAP_UNAVAILABLE)
#else
#define APR_LDAP_IS_SERVER_DOWN(s) ((s) == LDAP_SERVER_DOWN)
#endif
/* These symbols are not actually exported in a DSO build, but mapped into
* a private exported function array for apr_ldap_stub to bind dynamically.
* Rename them appropriately to protect the global namespace.
*/
#ifdef APU_DSO_LDAP_BUILD
#define apr_ldap_info apr__ldap_info
#define apr_ldap_init apr__ldap_init
#define apr_ldap_ssl_init apr__ldap_ssl_init
#define apr_ldap_ssl_deinit apr__ldap_ssl_deinit
#define apr_ldap_get_option apr__ldap_get_option
#define apr_ldap_set_option apr__ldap_set_option
#define apr_ldap_rebind_init apr__ldap_rebind_init
#define apr_ldap_rebind_add apr__ldap_rebind_add
#define apr_ldap_rebind_remove apr__ldap_rebind_remove
#define APU_DECLARE_LDAP(type) type
#else
#define APU_DECLARE_LDAP(type) APU_DECLARE(type)
#endif
#include "apr_ldap_url.h"
#include "apr_ldap_init.h"
#include "apr_ldap_option.h"
#include "apr_ldap_rebind.h"
/** @} */
#endif /* APR_HAS_LDAP */
#endif /* APU_LDAP_H */

197
contrib/apr-util/include/apr_ldap.hwc
View File

@ -1,197 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* apr_ldap.h is generated from apr_ldap.h.in by configure -- do not edit apr_ldap.h
*/
/**
* @file apr_ldap.h
* @brief APR-UTIL LDAP
*/
#ifndef APU_LDAP_H
#define APU_LDAP_H
/**
* @defgroup APR_Util_LDAP LDAP
* @ingroup APR_Util
* @{
*/
/* this will be defined if LDAP support was compiled into apr-util */
#define APR_HAS_LDAP @apr_has_ldap_10@
/* identify the LDAP toolkit used */
#define APR_HAS_NETSCAPE_LDAPSDK 0
#define APR_HAS_SOLARIS_LDAPSDK 0
#define APR_HAS_NOVELL_LDAPSDK 0
#define APR_HAS_MOZILLA_LDAPSDK 0
#define APR_HAS_OPENLDAP_LDAPSDK 0
#define APR_HAS_MICROSOFT_LDAPSDK 1
#define APR_HAS_TIVOLI_LDAPSDK 0
#define APR_HAS_ZOS_LDAPSDK 0
#define APR_HAS_OTHER_LDAPSDK 0
/*
* Handle the case when LDAP is enabled
*/
#if APR_HAS_LDAP
/*
* The following #defines are DEPRECATED and should not be used for
* anything. They remain to maintain binary compatibility.
* The original code defined the OPENLDAP SDK as present regardless
* of what really was there, which was way bogus. In addition, the
* apr_ldap_url_parse*() functions have been rewritten specifically for
* APR, so the APR_HAS_LDAP_URL_PARSE macro is forced to zero.
*/
#if APR_HAS_TIVOLI_LDAPSDK
#define APR_HAS_LDAP_SSL 0
#else
#define APR_HAS_LDAP_SSL 1
#endif
#define APR_HAS_LDAP_URL_PARSE 0
#if APR_HAS_OPENLDAP_LDAPSDK && !defined(LDAP_DEPRECATED)
/* Ensure that the "deprecated" interfaces are still exposed
* with OpenLDAP >= 2.3; these were exposed by default in earlier
* releases. */
#define LDAP_DEPRECATED 1
#endif
/*
* Include the standard LDAP header files.
*/
#include <winldap.h>
/*
* Detected standard functions
*/
#define APR_HAS_LDAPSSL_CLIENT_INIT 0
#define APR_HAS_LDAPSSL_CLIENT_DEINIT 0
#define APR_HAS_LDAPSSL_ADD_TRUSTED_CERT 0
#define APR_HAS_LDAP_START_TLS_S 0
#define APR_HAS_LDAP_SSLINIT 1
#define APR_HAS_LDAPSSL_INIT 0
#define APR_HAS_LDAPSSL_INSTALL_ROUTINES 0
/*
* Make sure the secure LDAP port is defined
*/
#ifndef LDAPS_PORT
#define LDAPS_PORT 636 /* ldaps:/// default LDAP over TLS port */
#endif
/*
* For ldap function calls that input a size limit on the number of returned elements
* Some SDKs do not have the define for LDAP_DEFAULT_LIMIT (-1) or LDAP_NO_LIMIT (0)
* LDAP_DEFAULT_LIMIT is preferred as it allows inheritance from whatever the SDK
* or process is configured for.
*/
#ifdef LDAP_DEFAULT_LIMIT
#define APR_LDAP_SIZELIMIT LDAP_DEFAULT_LIMIT
#else
#ifdef LDAP_NO_LIMIT
#define APR_LDAP_SIZELIMIT LDAP_NO_LIMIT
#endif
#endif
#ifndef APR_LDAP_SIZELIMIT
#define APR_LDAP_SIZELIMIT 0 /* equivalent to LDAP_NO_LIMIT, and what goes on the wire */
#endif
/*
* z/OS is missing some defines
*/
#ifndef LDAP_VERSION_MAX
#define LDAP_VERSION_MAX LDAP_VERSION
#endif
#if APR_HAS_ZOS_LDAPSDK
#define LDAP_VENDOR_NAME "IBM z/OS"
#endif
/* Note: Macros defining const casting has been removed in APR v1.0,
* pending real support for LDAP v2.0 toolkits.
*
* In the mean time, please use an LDAP v3.0 toolkit.
*/
#if LDAP_VERSION_MAX <= 2
#error Support for LDAP v2.0 toolkits has been removed from apr-util. Please use an LDAP v3.0 toolkit.
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* This structure allows the C LDAP API error codes to be returned
* along with plain text error messages that explain to us mere mortals
* what really happened.
*/
typedef struct apr_ldap_err_t {
const char *reason;
const char *msg;
int rc;
} apr_ldap_err_t;
#ifdef __cplusplus
}
#endif
/* The MS SDK returns LDAP_UNAVAILABLE when the backend has closed the connection
* between LDAP calls. Protect with APR_HAS_MICROSOFT_LDAPSDK in case someone
* manually chooses another SDK on Windows
*/
#if APR_HAS_MICROSOFT_LDAPSDK
#define APR_LDAP_IS_SERVER_DOWN(s) ((s) == LDAP_SERVER_DOWN \
|| (s) == LDAP_UNAVAILABLE)
#else
#define APR_LDAP_IS_SERVER_DOWN(s) ((s) == LDAP_SERVER_DOWN)
#endif
/* These symbols are not actually exported in a DSO build, but mapped into
* a private exported function array for apr_ldap_stub to bind dynamically.
* Rename them appropriately to protect the global namespace.
*/
#ifdef APU_DSO_LDAP_BUILD
#define apr_ldap_info apr__ldap_info
#define apr_ldap_init apr__ldap_init
#define apr_ldap_ssl_init apr__ldap_ssl_init
#define apr_ldap_ssl_deinit apr__ldap_ssl_deinit
#define apr_ldap_get_option apr__ldap_get_option
#define apr_ldap_set_option apr__ldap_set_option
#define apr_ldap_rebind_init apr__ldap_rebind_init
#define apr_ldap_rebind_add apr__ldap_rebind_add
#define apr_ldap_rebind_remove apr__ldap_rebind_remove
#define APU_DECLARE_LDAP(type) type
#else
#define APU_DECLARE_LDAP(type) APU_DECLARE(type)
#endif
#include "apr_ldap_url.h"
#include "apr_ldap_init.h"
#include "apr_ldap_option.h"
#include "apr_ldap_rebind.h"
/** @} */
#endif /* APR_HAS_LDAP */
#endif /* APU_LDAP_H */

165
contrib/apr-util/include/apr_ldap_init.h
View File

@ -1,165 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file apr_ldap_init.h
* @brief APR-UTIL LDAP ldap_init() functions
*/
#ifndef APR_LDAP_INIT_H
#define APR_LDAP_INIT_H
/**
* @addtogroup APR_Util_LDAP
* @{
*/
#include "apr_ldap.h"
#if APR_HAS_LDAP
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* Macro to detect security related return values.
*/
#if defined(LDAP_INSUFFICIENT_ACCESS)
#define APU_LDAP_INSUFFICIENT_ACCESS LDAP_INSUFFICIENT_ACCESS
#elif defined(LDAP_INSUFFICIENT_RIGHTS)
#define APU_LDAP_INSUFFICIENT_ACCESS LDAP_INSUFFICIENT_RIGHTS
#elif defined(APR_HAS_MICROSOFT_LDAPSDK)
/* The macros above fail to contemplate that LDAP_RETCODE values
* may be represented by an enum. autoconf tests would be much
* more robust.
*/
#define APU_LDAP_INSUFFICIENT_ACCESS LDAP_INSUFFICIENT_RIGHTS
#else
#error The security return codes must be added to support this LDAP toolkit.
#endif
#if defined(LDAP_SECURITY_ERROR)
#define APU_LDAP_SECURITY_ERROR LDAP_SECURITY_ERROR
#else
#define APU_LDAP_SECURITY_ERROR(n) \
(LDAP_INAPPROPRIATE_AUTH == n) ? 1 \
: (LDAP_INVALID_CREDENTIALS == n) ? 1 \
: (APU_LDAP_INSUFFICIENT_ACCESS == n) ? 1 \
: 0
#endif
/**
* APR LDAP SSL Initialise function
*
* This function initialises SSL on the underlying LDAP toolkit
* if this is necessary.
*
* If a CA certificate is provided, this is set, however the setting
* of certificates via this method has been deprecated and will be removed in
* APR v2.0.
*
* The apr_ldap_set_option() function with the APR_LDAP_OPT_TLS_CERT option
* should be used instead to set certificates.
*
* If SSL support is not available on this platform, or a problem
* was encountered while trying to set the certificate, the function
* will return APR_EGENERAL. Further LDAP specific error information
* can be found in result_err.
* @param pool The pool to use
* @param cert_auth_file The name of the certificate to use, can be NULL
* @param cert_file_type The type of certificate specified. See the
* apr_ldap_set_option() APR_LDAP_OPT_TLS_CERT option for details.
* @param result_err The returned result
*/
APU_DECLARE_LDAP(int) apr_ldap_ssl_init(apr_pool_t *pool,
const char *cert_auth_file,
int cert_file_type,
apr_ldap_err_t **result_err);
/**
* APR LDAP SSL De-Initialise function
*
* This function tears down any SSL certificate setup previously
* set using apr_ldap_ssl_init(). It should be called to clean
* up if a graceful restart of a service is attempted.
* @todo currently we do not check whether apr_ldap_ssl_init()
* has been called first - we probably should.
*/
APU_DECLARE_LDAP(int) apr_ldap_ssl_deinit(void);
/**
* APR LDAP initialise function
*
* This function is responsible for initialising an LDAP
* connection in a toolkit independant way. It does the
* job of ldap_init() from the C api.
*
* It handles both the SSL and non-SSL case, and attempts
* to hide the complexity setup from the user. This function
* assumes that any certificate setup necessary has already
* been done.
*
* If SSL or STARTTLS needs to be enabled, and the underlying
* toolkit supports it, the following values are accepted for
* secure:
*
* APR_LDAP_NONE: No encryption
* APR_LDAP_SSL: SSL encryption (ldaps://)
* APR_LDAP_STARTTLS: Force STARTTLS on ldap://
* @remark The Novell toolkit is only able to set the SSL mode via this
* function. To work around this limitation, set the SSL mode here if no
* per connection client certificates are present, otherwise set secure
* APR_LDAP_NONE here, then set the per connection client certificates,
* followed by setting the SSL mode via apr_ldap_set_option(). As Novell
* does not support per connection client certificates, this problem is
* worked around while still being compatible with other LDAP toolkits.
* @param pool The pool to use
* @param ldap The LDAP handle
* @param hostname The name of the host to connect to. This can be either a
* DNS name, or an IP address.
* @param portno The port to connect to
* @param secure The security mode to set
* @param result_err The returned result
*/
APU_DECLARE_LDAP(int) apr_ldap_init(apr_pool_t *pool,
LDAP **ldap,
const char *hostname,
int portno,
int secure,
apr_ldap_err_t **result_err);
/**
* APR LDAP info function
*
* This function returns a string describing the LDAP toolkit
* currently in use. The string is placed inside result_err->reason.
* @param pool The pool to use
* @param result_err The returned result
*/
APU_DECLARE_LDAP(int) apr_ldap_info(apr_pool_t *pool,
apr_ldap_err_t **result_err);
#ifdef __cplusplus
}
#endif
#endif /* APR_HAS_LDAP */
/** @} */
#endif /* APR_LDAP_URL_H */

254
contrib/apr-util/include/apr_ldap_option.h
View File

@ -1,254 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file apr_ldap_option.h
* @brief APR-UTIL LDAP ldap_*_option() functions
*/
#ifndef APR_LDAP_OPTION_H
#define APR_LDAP_OPTION_H
/**
* @addtogroup APR_Util_LDAP
* @{
*/
#include "apr_ldap.h"
#if APR_HAS_LDAP
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/*
* The following defines handle the different TLS certificate
* options available. If these options are missing, APR will try and
* emulate support for this using the deprecated ldap_start_tls_s()
* function.
*/
/**
* Set SSL mode to one of APR_LDAP_NONE, APR_LDAP_SSL, APR_LDAP_STARTTLS
* or APR_LDAP_STOPTLS.
*/
#define APR_LDAP_OPT_TLS 0x6fff
/**
* Set zero or more CA certificates, client certificates or private
* keys globally, or per connection (where supported).
*/
#define APR_LDAP_OPT_TLS_CERT 0x6ffe
/**
* Set the LDAP library to no verify the server certificate. This means
* all servers are considered trusted.
*/
#define APR_LDAP_OPT_VERIFY_CERT 0x6ffd
/**
* Set the LDAP library to indicate if referrals should be chased during
* LDAP searches.
*/
#define APR_LDAP_OPT_REFERRALS 0x6ffc
/**
* Set the LDAP library to indicate a maximum number of referral hops to
* chase before giving up on the search.
*/
#define APR_LDAP_OPT_REFHOPLIMIT 0x6ffb
/**
* Structures for the apr_set_option() cases
*/
/**
* APR_LDAP_OPT_TLS_CERT
*
* This structure includes possible options to set certificates on
* system initialisation. Different SDKs have different certificate
* requirements, and to achieve this multiple certificates must be
* specified at once passed as an (apr_array_header_t *).
*
* Netscape:
* Needs the CA cert database (cert7.db), the client cert database (key3.db)
* and the security module file (secmod.db) set at the system initialisation
* time. Three types are supported: APR_LDAP_CERT7_DB, APR_LDAP_KEY3_DB and
* APR_LDAP_SECMOD.
*
* To specify a client cert connection, a certificate nickname needs to be
* provided with a type of APR_LDAP_CERT.
* int ldapssl_enable_clientauth( LDAP *ld, char *keynickname,
* char *keypasswd, char *certnickname );
* keynickname is currently not used, and should be set to ""
*
* Novell:
* Needs CA certificates and client certificates set at system initialisation
* time. Three types are supported: APR_LDAP_CA*, APR_LDAP_CERT* and
* APR_LDAP_KEY*.
*
* Certificates cannot be specified per connection.
*
* The functions used are:
* ldapssl_add_trusted_cert(serverTrustedRoot, serverTrustedRootEncoding);
* Clients certs and keys are set at system initialisation time with
* int ldapssl_set_client_cert (
* void *cert,
* int type
* void *password);
* type can be LDAPSSL_CERT_FILETYPE_B64 or LDAPSSL_CERT_FILETYPE_DER
* ldapssl_set_client_private_key(clientPrivateKey,
* clientPrivateKeyEncoding,
* clientPrivateKeyPassword);
*
* OpenSSL:
* Needs one or more CA certificates to be set at system initialisation time
* with a type of APR_LDAP_CA*.
*
* May have one or more client certificates set per connection with a type of
* APR_LDAP_CERT*, and keys with APR_LDAP_KEY*.
*/
/** CA certificate type unknown */
#define APR_LDAP_CA_TYPE_UNKNOWN 0
/** binary DER encoded CA certificate */
#define APR_LDAP_CA_TYPE_DER 1
/** PEM encoded CA certificate */
#define APR_LDAP_CA_TYPE_BASE64 2
/** Netscape/Mozilla cert7.db CA certificate database */
#define APR_LDAP_CA_TYPE_CERT7_DB 3
/** Netscape/Mozilla secmod file */
#define APR_LDAP_CA_TYPE_SECMOD 4
/** Client certificate type unknown */
#define APR_LDAP_CERT_TYPE_UNKNOWN 5
/** binary DER encoded client certificate */
#define APR_LDAP_CERT_TYPE_DER 6
/** PEM encoded client certificate */
#define APR_LDAP_CERT_TYPE_BASE64 7
/** Netscape/Mozilla key3.db client certificate database */
#define APR_LDAP_CERT_TYPE_KEY3_DB 8
/** Netscape/Mozilla client certificate nickname */
#define APR_LDAP_CERT_TYPE_NICKNAME 9
/** Private key type unknown */
#define APR_LDAP_KEY_TYPE_UNKNOWN 10
/** binary DER encoded private key */
#define APR_LDAP_KEY_TYPE_DER 11
/** PEM encoded private key */
#define APR_LDAP_KEY_TYPE_BASE64 12
/** PKCS#12 encoded client certificate */
#define APR_LDAP_CERT_TYPE_PFX 13
/** PKCS#12 encoded private key */
#define APR_LDAP_KEY_TYPE_PFX 14
/** Openldap directory full of base64-encoded cert
* authorities with hashes in corresponding .0 directory
*/
#define APR_LDAP_CA_TYPE_CACERTDIR_BASE64 15
/**
* Certificate structure.
*
* This structure is used to store certificate details. An array of
* these structures is passed to apr_ldap_set_option() to set CA
* and client certificates.
* @param type Type of certificate APR_LDAP_*_TYPE_*
* @param path Path, file or nickname of the certificate
* @param password Optional password, can be NULL
*/
typedef struct apr_ldap_opt_tls_cert_t apr_ldap_opt_tls_cert_t;
struct apr_ldap_opt_tls_cert_t {
int type;
const char *path;
const char *password;
};
/**
* APR_LDAP_OPT_TLS
*
* This sets the SSL level on the LDAP handle.
*
* Netscape/Mozilla:
* Supports SSL, but not STARTTLS
* SSL is enabled by calling ldapssl_install_routines().
*
* Novell:
* Supports SSL and STARTTLS.
* SSL is enabled by calling ldapssl_install_routines(). Note that calling
* other ldap functions before ldapssl_install_routines() may cause this
* function to fail.
* STARTTLS is enabled by calling ldapssl_start_tls_s() after calling
* ldapssl_install_routines() (check this).
*
* OpenLDAP:
* Supports SSL and supports STARTTLS, but none of this is documented:
* http://www.openldap.org/lists/openldap-software/200409/msg00618.html
* Documentation for both SSL support and STARTTLS has been deleted from
* the OpenLDAP documentation and website.
*/
/** No encryption */
#define APR_LDAP_NONE 0
/** SSL encryption (ldaps://) */
#define APR_LDAP_SSL 1
/** TLS encryption (STARTTLS) */
#define APR_LDAP_STARTTLS 2
/** end TLS encryption (STOPTLS) */
#define APR_LDAP_STOPTLS 3
/**
* APR LDAP get option function
*
* This function gets option values from a given LDAP session if
* one was specified. It maps to the native ldap_get_option() function.
* @param pool The pool to use
* @param ldap The LDAP handle
* @param option The LDAP_OPT_* option to return
* @param outvalue The value returned (if any)
* @param result_err The apr_ldap_err_t structure contained detailed results
* of the operation.
*/
APU_DECLARE_LDAP(int) apr_ldap_get_option(apr_pool_t *pool,
LDAP *ldap,
int option,
void *outvalue,
apr_ldap_err_t **result_err);
/**
* APR LDAP set option function
*
* This function sets option values to a given LDAP session if
* one was specified. It maps to the native ldap_set_option() function.
*
* Where an option is not supported by an LDAP toolkit, this function
* will try and apply legacy functions to achieve the same effect,
* depending on the platform.
* @param pool The pool to use
* @param ldap The LDAP handle
* @param option The LDAP_OPT_* option to set
* @param invalue The value to set
* @param result_err The apr_ldap_err_t structure contained detailed results
* of the operation.
*/
APU_DECLARE_LDAP(int) apr_ldap_set_option(apr_pool_t *pool,
LDAP *ldap,
int option,
const void *invalue,
apr_ldap_err_t **result_err);
#ifdef __cplusplus
}
#endif
#endif /* APR_HAS_LDAP */
/** @} */
#endif /* APR_LDAP_OPTION_H */

98
contrib/apr-util/include/apr_ldap_rebind.h
View File

@ -1,98 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* The APR LDAP rebind functions provide an implementation of
* a rebind procedure that can be used to allow clients to chase referrals,
* using the same credentials used to log in originally.
*
* Use of this implementation is optional.
*
* @file apr_ldap_rebind.h
* @brief Apache LDAP library
*/
#ifndef APU_LDAP_REBIND_H
#define APU_LDAP_REBIND_H
/**
* @addtogroup APR_Util_LDAP
* @{
**/
#if defined(DOXYGEN)
#include "apr_ldap.h"
#endif
/*
* Handle the case when LDAP is enabled
*/
#if APR_HAS_LDAP
/**
* APR LDAP initialize rebind lock
*
* This function creates the lock for controlling access to the xref list..
* @param pool Pool to use when creating the xref_lock.
*/
APU_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_init(apr_pool_t *pool);
/**
* APR LDAP rebind_add function
*
* This function creates a cross reference entry for the specified ldap
* connection. The rebind callback function will look up this ldap
* connection so it can retrieve the bindDN and bindPW for use in any
* binds while referrals are being chased.
*
* This function will add the callback to the LDAP handle passed in.
*
* A cleanup is registered within the pool provided to remove this
* entry when the pool is removed. Alternatively apr_ldap_rebind_remove()
* can be called to explicitly remove the entry at will.
*
* @param pool The pool to use
* @param ld The LDAP connectionhandle
* @param bindDN The bind DN to be used for any binds while chasing
* referrals on this ldap connection.
* @param bindPW The bind Password to be used for any binds while
* chasing referrals on this ldap connection.
*/
APU_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_add(apr_pool_t *pool,
LDAP *ld,
const char *bindDN,
const char *bindPW);
/**
* APR LDAP rebind_remove function
*
* This function removes the rebind cross reference entry for the
* specified ldap connection.
*
* If not explicitly removed, this function will be called automatically
* when the pool is cleaned up.
*
* @param ld The LDAP connectionhandle
*/
APU_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_remove(LDAP *ld);
#endif /* APR_HAS_LDAP */
/** @} */
#endif /* APU_LDAP_REBIND_H */

120
contrib/apr-util/include/apr_ldap_url.h
View File

@ -1,120 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file apr_ldap_url.h
* @brief APR-UTIL LDAP ldap_init() functions
*/
#ifndef APR_LDAP_URL_H
#define APR_LDAP_URL_H
/**
* @addtogroup APR_Util_LDAP
* @{
*/
#if defined(DOXYGEN)
#include "apr_ldap.h"
#endif
#if APR_HAS_LDAP
#include "apu.h"
#include "apr_pools.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/** Structure to access an exploded LDAP URL */
typedef struct apr_ldap_url_desc_t {
struct apr_ldap_url_desc_t *lud_next;
char *lud_scheme;
char *lud_host;
int lud_port;
char *lud_dn;
char **lud_attrs;
int lud_scope;
char *lud_filter;
char **lud_exts;
int lud_crit_exts;
} apr_ldap_url_desc_t;
#ifndef APR_LDAP_URL_SUCCESS
#define APR_LDAP_URL_SUCCESS 0x00 /* Success */
#define APR_LDAP_URL_ERR_MEM 0x01 /* can't allocate memory space */
#define APR_LDAP_URL_ERR_PARAM 0x02 /* parameter is bad */
#define APR_LDAP_URL_ERR_BADSCHEME 0x03 /* URL doesn't begin with "ldap[si]://" */
#define APR_LDAP_URL_ERR_BADENCLOSURE 0x04 /* URL is missing trailing ">" */
#define APR_LDAP_URL_ERR_BADURL 0x05 /* URL is bad */
#define APR_LDAP_URL_ERR_BADHOST 0x06 /* host port is bad */
#define APR_LDAP_URL_ERR_BADATTRS 0x07 /* bad (or missing) attributes */
#define APR_LDAP_URL_ERR_BADSCOPE 0x08 /* scope string is invalid (or missing) */
#define APR_LDAP_URL_ERR_BADFILTER 0x09 /* bad or missing filter */
#define APR_LDAP_URL_ERR_BADEXTS 0x0a /* bad or missing extensions */
#endif
/**
* Is this URL an ldap url? ldap://
* @param url The url to test
*/
APU_DECLARE(int) apr_ldap_is_ldap_url(const char *url);
/**
* Is this URL an SSL ldap url? ldaps://
* @param url The url to test
*/
APU_DECLARE(int) apr_ldap_is_ldaps_url(const char *url);
/**
* Is this URL an ldap socket url? ldapi://
* @param url The url to test
*/
APU_DECLARE(int) apr_ldap_is_ldapi_url(const char *url);
/**
* Parse an LDAP URL.
* @param pool The pool to use
* @param url_in The URL to parse
* @param ludpp The structure to return the exploded URL
* @param result_err The result structure of the operation
*/
APU_DECLARE(int) apr_ldap_url_parse_ext(apr_pool_t *pool,
const char *url_in,
apr_ldap_url_desc_t **ludpp,
apr_ldap_err_t **result_err);
/**
* Parse an LDAP URL.
* @param pool The pool to use
* @param url_in The URL to parse
* @param ludpp The structure to return the exploded URL
* @param result_err The result structure of the operation
*/
APU_DECLARE(int) apr_ldap_url_parse(apr_pool_t *pool,
const char *url_in,
apr_ldap_url_desc_t **ludpp,
apr_ldap_err_t **result_err);
#ifdef __cplusplus
}
#endif
#endif /* APR_HAS_LDAP */
/** @} */
#endif /* APR_LDAP_URL_H */

135
contrib/apr-util/include/apr_md4.h
View File

@ -1,135 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* This is derived from material copyright RSA Data Security, Inc.
* Their notice is reproduced below in its entirety.
*
* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
* rights reserved.
*
* License to copy and use this software is granted provided that it
* is identified as the "RSA Data Security, Inc. MD4 Message-Digest
* Algorithm" in all material mentioning or referencing this software
* or this function.
*
* License is also granted to make and use derivative works provided
* that such works are identified as "derived from the RSA Data
* Security, Inc. MD4 Message-Digest Algorithm" in all material
* mentioning or referencing the derived work.
*
* RSA Data Security, Inc. makes no representations concerning either
* the merchantability of this software or the suitability of this
* software for any particular purpose. It is provided "as is"
* without express or implied warranty of any kind.
*
* These notices must be retained in any copies of any part of this
* documentation and/or software.
*/
#ifndef APR_MD4_H
#define APR_MD4_H
#include "apu.h"
#include "apr_xlate.h"
/**
* @file apr_md4.h
* @brief APR-UTIL MD4 Library
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup APR_Util_MD4 MD4 Library
* @ingroup APR_Util
* @{
*/
/** The digestsize for MD4 */
#define APR_MD4_DIGESTSIZE 16
/** @see apr_md4_ctx_t */
typedef struct apr_md4_ctx_t apr_md4_ctx_t;
/** MD4 context. */
struct apr_md4_ctx_t {
/** state (ABCD) */
apr_uint32_t state[4];
/** number of bits, modulo 2^64 (lsb first) */
apr_uint32_t count[2];
/** input buffer */
unsigned char buffer[64];
#if APR_HAS_XLATE
/** translation handle */
apr_xlate_t *xlate;
#endif
};
/**
* MD4 Initialize. Begins an MD4 operation, writing a new context.
* @param context The MD4 context to initialize.
*/
APU_DECLARE(apr_status_t) apr_md4_init(apr_md4_ctx_t *context);
#if APR_HAS_XLATE
/**
* MDr4 translation setup. Provides the APR translation handle to be used
* for translating the content before calculating the digest.
* @param context The MD4 content to set the translation for.
* @param xlate The translation handle to use for this MD4 context
*/
APU_DECLARE(apr_status_t) apr_md4_set_xlate(apr_md4_ctx_t *context,
apr_xlate_t *xlate);
#else
#define apr_md4_set_xlate(context, xlate) APR_ENOTIMPL
#endif
/**
* MD4 block update operation. Continue an MD4 message-digest operation,
* processing another message block, and updating the context.
* @param context The MD4 content to update.
* @param input next message block to update
* @param inputLen The length of the next message block
*/
APU_DECLARE(apr_status_t) apr_md4_update(apr_md4_ctx_t *context,
const unsigned char *input,
apr_size_t inputLen);
/**
* MD4 finalization. Ends an MD4 message-digest operation, writing the
* message digest and zeroing the context
* @param digest The final MD4 digest
* @param context The MD4 content we are finalizing.
*/
APU_DECLARE(apr_status_t) apr_md4_final(
unsigned char digest[APR_MD4_DIGESTSIZE],
apr_md4_ctx_t *context);
/**
* MD4 digest computation
* @param digest The MD4 digest
* @param input message block to use
* @param inputLen The length of the message block
*/
APU_DECLARE(apr_status_t) apr_md4(unsigned char digest[APR_MD4_DIGESTSIZE],
const unsigned char *input,
apr_size_t inputLen);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_MD4_H */

176
contrib/apr-util/include/apr_md5.h
View File

@ -1,176 +0,0 @@
/*
* This is work is derived from material Copyright RSA Data Security, Inc.
*
* The RSA copyright statement and Licence for that original material is
* included below. This is followed by the Apache copyright statement and
* licence for the modifications made to that material.
*/
/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef APR_MD5_H
#define APR_MD5_H
#include "apu.h"
#include "apr_xlate.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @file apr_md5.h
* @brief APR MD5 Routines
*/
/**
* @defgroup APR_MD5 MD5 Routines
* @ingroup APR
* @{
*/
/** The MD5 digest size */
#define APR_MD5_DIGESTSIZE 16
/** @see apr_md5_ctx_t */
typedef struct apr_md5_ctx_t apr_md5_ctx_t;
/** MD5 context. */
struct apr_md5_ctx_t {
/** state (ABCD) */
apr_uint32_t state[4];
/** number of bits, modulo 2^64 (lsb first) */
apr_uint32_t count[2];
/** input buffer */
unsigned char buffer[64];
/** translation handle
* ignored if xlate is unsupported
*/
apr_xlate_t *xlate;
};
/**
* MD5 Initialize. Begins an MD5 operation, writing a new context.
* @param context The MD5 context to initialize.
*/
APU_DECLARE(apr_status_t) apr_md5_init(apr_md5_ctx_t *context);
/**
* MD5 translation setup. Provides the APR translation handle to be used
* for translating the content before calculating the digest.
* @param context The MD5 content to set the translation for.
* @param xlate The translation handle to use for this MD5 context
*/
APU_DECLARE(apr_status_t) apr_md5_set_xlate(apr_md5_ctx_t *context,
apr_xlate_t *xlate);
/**
* MD5 block update operation. Continue an MD5 message-digest operation,
* processing another message block, and updating the context.
* @param context The MD5 content to update.
* @param input next message block to update
* @param inputLen The length of the next message block
*/
APU_DECLARE(apr_status_t) apr_md5_update(apr_md5_ctx_t *context,
const void *input,
apr_size_t inputLen);
/**
* MD5 finalization. Ends an MD5 message-digest operation, writing the
* message digest and zeroing the context
* @param digest The final MD5 digest
* @param context The MD5 content we are finalizing.
*/
APU_DECLARE(apr_status_t) apr_md5_final(unsigned char digest[APR_MD5_DIGESTSIZE],
apr_md5_ctx_t *context);
/**
* MD5 in one step
* @param digest The final MD5 digest
* @param input The message block to use
* @param inputLen The length of the message block
*/
APU_DECLARE(apr_status_t) apr_md5(unsigned char digest[APR_MD5_DIGESTSIZE],
const void *input,
apr_size_t inputLen);
/**
* Encode a password using an MD5 algorithm
* @param password The password to encode
* @param salt The salt string to use for the encoding
* @param result The string to store the encoded password in
* @param nbytes The size of the result buffer
*/
APU_DECLARE(apr_status_t) apr_md5_encode(const char *password, const char *salt,
char *result, apr_size_t nbytes);
/**
* Encode a password using the bcrypt algorithm
* @param password The password to encode
* @param count The cost of the encoding, possible values are 4 to 31
* @param salt Pointer to binary data to be used as salt for the encoding
* @param salt_len The size of the salt data (must be >= 16)
* @param out The string to store the encoded password in
* @param out_len The size of the result buffer (must be >= 61)
*/
APU_DECLARE(apr_status_t) apr_bcrypt_encode(const char *pw,
unsigned int count,
const unsigned char *salt,
apr_size_t salt_len,
char *out, apr_size_t out_len);
/**
* Validate hashes created by APR-supported algorithms: md5, bcrypt, and sha1.
* hashes created by crypt are supported only on platforms that provide
* crypt(3), so don't rely on that function unless you know that your
* application will be run only on platforms that support it. On platforms
* that don't support crypt(3), this falls back to a clear text string
* comparison.
* @param passwd The password to validate
* @param hash The password to validate against
*/
APU_DECLARE(apr_status_t) apr_password_validate(const char *passwd,
const char *hash);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_MD5_H */

444
contrib/apr-util/include/apr_memcache.h
View File

@ -1,444 +0,0 @@
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef APR_MEMCACHE_H
#define APR_MEMCACHE_H
/**
* @file apr_memcache.h
* @brief Client interface for memcached
* @remark To use this interface you must have a separate memcached
* server running. See the memcached website at http://www.danga.com/memcached/
* for more information.
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_time.h"
#include "apr_strings.h"
#include "apr_network_io.h"
#include "apr_ring.h"
#include "apr_buckets.h"
#include "apr_reslist.h"
#include "apr_hash.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup APR_Util_MC Memcached Client Routines
* @ingroup APR_Util
* @{
*/
/** Specifies the status of a memcached server */
typedef enum
{
APR_MC_SERVER_LIVE, /**< Server is alive and responding to requests */
APR_MC_SERVER_DEAD /**< Server is not responding to requests */
} apr_memcache_server_status_t;
/** Opaque memcache client connection object */
typedef struct apr_memcache_conn_t apr_memcache_conn_t;
/** Memcache Server Info Object */
typedef struct apr_memcache_server_t apr_memcache_server_t;
struct apr_memcache_server_t
{
const char *host; /**< Hostname of this Server */
apr_port_t port; /**< Port of this Server */
apr_memcache_server_status_t status; /**< @see apr_memcache_server_status_t */
#if APR_HAS_THREADS || defined(DOXYGEN)
apr_reslist_t *conns; /**< Resource list of actual client connections */
#else
apr_memcache_conn_t *conn;
#endif
apr_pool_t *p; /** Pool to use for private allocations */
#if APR_HAS_THREADS
apr_thread_mutex_t *lock;
#endif
apr_time_t btime;
};
/* Custom hash callback function prototype, user for server selection.
* @param baton user selected baton
* @param data data to hash
* @param data_len length of data
*/
typedef apr_uint32_t (*apr_memcache_hash_func)(void *baton,
const char *data,
const apr_size_t data_len);
typedef struct apr_memcache_t apr_memcache_t;
/* Custom Server Select callback function prototype.
* @param baton user selected baton
* @param mc memcache instance, use mc->live_servers to select a node
* @param hash hash of the selected key.
*/
typedef apr_memcache_server_t* (*apr_memcache_server_func)(void *baton,
apr_memcache_t *mc,
const apr_uint32_t hash);
/** Container for a set of memcached servers */
struct apr_memcache_t
{
apr_uint32_t flags; /**< Flags, Not currently used */
apr_uint16_t nalloc; /**< Number of Servers Allocated */
apr_uint16_t ntotal; /**< Number of Servers Added */
apr_memcache_server_t **live_servers; /**< Array of Servers */
apr_pool_t *p; /** Pool to use for allocations */
void *hash_baton;
apr_memcache_hash_func hash_func;
void *server_baton;
apr_memcache_server_func server_func;
};
/** Returned Data from a multiple get */
typedef struct
{
apr_status_t status;
const char* key;
apr_size_t len;
char *data;
apr_uint16_t flags;
} apr_memcache_value_t;
/**
* Creates a crc32 hash used to split keys between servers
* @param mc The memcache client object to use
* @param data Data to be hashed
* @param data_len Length of the data to use
* @return crc32 hash of data
* @remark The crc32 hash is not compatible with old memcached clients.
*/
APU_DECLARE(apr_uint32_t) apr_memcache_hash(apr_memcache_t *mc,
const char *data,
const apr_size_t data_len);
/**
* Pure CRC32 Hash. Used by some clients.
*/
APU_DECLARE(apr_uint32_t) apr_memcache_hash_crc32(void *baton,
const char *data,
const apr_size_t data_len);
/**
* hash compatible with the standard Perl Client.
*/
APU_DECLARE(apr_uint32_t) apr_memcache_hash_default(void *baton,
const char *data,
const apr_size_t data_len);
/**
* Picks a server based on a hash
* @param mc The memcache client object to use
* @param hash Hashed value of a Key
* @return server that controls specified hash
* @see apr_memcache_hash
*/
APU_DECLARE(apr_memcache_server_t *) apr_memcache_find_server_hash(apr_memcache_t *mc,
const apr_uint32_t hash);
/**
* server selection compatible with the standard Perl Client.
*/
APU_DECLARE(apr_memcache_server_t *) apr_memcache_find_server_hash_default(void *baton,
apr_memcache_t *mc,
const apr_uint32_t hash);
/**
* Adds a server to a client object
* @param mc The memcache client object to use
* @param server Server to add
* @remark Adding servers is not thread safe, and should be done once at startup.
* @warning Changing servers after startup may cause keys to go to
* different servers.
*/
APU_DECLARE(apr_status_t) apr_memcache_add_server(apr_memcache_t *mc,
apr_memcache_server_t *server);
/**
* Finds a Server object based on a hostname/port pair
* @param mc The memcache client object to use
* @param host Hostname of the server
* @param port Port of the server
* @return Server with matching Hostname and Port, or NULL if none was found.
*/
APU_DECLARE(apr_memcache_server_t *) apr_memcache_find_server(apr_memcache_t *mc,
const char *host,
apr_port_t port);
/**
* Enables a Server for use again
* @param mc The memcache client object to use
* @param ms Server to Activate
*/
APU_DECLARE(apr_status_t) apr_memcache_enable_server(apr_memcache_t *mc,
apr_memcache_server_t *ms);
/**
* Disable a Server
* @param mc The memcache client object to use
* @param ms Server to Disable
*/
APU_DECLARE(apr_status_t) apr_memcache_disable_server(apr_memcache_t *mc,
apr_memcache_server_t *ms);
/**
* Creates a new Server Object
* @param p Pool to use
* @param host hostname of the server
* @param port port of the server
* @param min minimum number of client sockets to open
* @param smax soft maximum number of client connections to open
* @param max hard maximum number of client connections
* @param ttl time to live in microseconds of a client connection
* @param ns location of the new server object
* @see apr_reslist_create
* @remark min, smax, and max are only used when APR_HAS_THREADS
*/
APU_DECLARE(apr_status_t) apr_memcache_server_create(apr_pool_t *p,
const char *host,
apr_port_t port,
apr_uint32_t min,
apr_uint32_t smax,
apr_uint32_t max,
apr_uint32_t ttl,
apr_memcache_server_t **ns);
/**
* Creates a new memcached client object
* @param p Pool to use
* @param max_servers maximum number of servers
* @param flags Not currently used
* @param mc location of the new memcache client object
*/
APU_DECLARE(apr_status_t) apr_memcache_create(apr_pool_t *p,
apr_uint16_t max_servers,
apr_uint32_t flags,
apr_memcache_t **mc);
/**
* Gets a value from the server, allocating the value out of p
* @param mc client to use
* @param p Pool to use
* @param key null terminated string containing the key
* @param baton location of the allocated value
* @param len length of data at baton
* @param flags any flags set by the client for this key
* @return
*/
APU_DECLARE(apr_status_t) apr_memcache_getp(apr_memcache_t *mc,
apr_pool_t *p,
const char* key,
char **baton,
apr_size_t *len,
apr_uint16_t *flags);
/**
* Add a key to a hash for a multiget query
* if the hash (*value) is NULL it will be created
* @param data_pool pool from where the hash and their items are created from
* @param key null terminated string containing the key
* @param values hash of keys and values that this key will be added to
* @return
*/
APU_DECLARE(void) apr_memcache_add_multget_key(apr_pool_t *data_pool,
const char* key,
apr_hash_t **values);
/**
* Gets multiple values from the server, allocating the values out of p
* @param mc client to use
* @param temp_pool Pool used for temporary allocations. May be cleared inside this
* call.
* @param data_pool Pool used to allocate data for the returned values.
* @param values hash of apr_memcache_value_t keyed by strings, contains the
* result of the multiget call.
* @return
*/
APU_DECLARE(apr_status_t) apr_memcache_multgetp(apr_memcache_t *mc,
apr_pool_t *temp_pool,
apr_pool_t *data_pool,
apr_hash_t *values);
/**
* Sets a value by key on the server
* @param mc client to use
* @param key null terminated string containing the key
* @param baton data to store on the server
* @param data_size length of data at baton
* @param timeout time in seconds for the data to live on the server
* @param flags any flags set by the client for this key
*/
APU_DECLARE(apr_status_t) apr_memcache_set(apr_memcache_t *mc,
const char *key,
char *baton,
const apr_size_t data_size,
apr_uint32_t timeout,
apr_uint16_t flags);
/**
* Adds value by key on the server
* @param mc client to use
* @param key null terminated string containing the key
* @param baton data to store on the server
* @param data_size length of data at baton
* @param timeout time for the data to live on the server
* @param flags any flags set by the client for this key
* @return APR_SUCCESS if the key was added, APR_EEXIST if the key
* already exists on the server.
*/
APU_DECLARE(apr_status_t) apr_memcache_add(apr_memcache_t *mc,
const char *key,
char *baton,
const apr_size_t data_size,
apr_uint32_t timeout,
apr_uint16_t flags);
/**
* Replaces value by key on the server
* @param mc client to use
* @param key null terminated string containing the key
* @param baton data to store on the server
* @param data_size length of data at baton
* @param timeout time for the data to live on the server
* @param flags any flags set by the client for this key
* @return APR_SUCCESS if the key was added, APR_EEXIST if the key
* did not exist on the server.
*/
APU_DECLARE(apr_status_t) apr_memcache_replace(apr_memcache_t *mc,
const char *key,
char *baton,
const apr_size_t data_size,
apr_uint32_t timeout,
apr_uint16_t flags);
/**
* Deletes a key from a server
* @param mc client to use
* @param key null terminated string containing the key
* @param timeout time for the delete to stop other clients from adding
*/
APU_DECLARE(apr_status_t) apr_memcache_delete(apr_memcache_t *mc,
const char *key,
apr_uint32_t timeout);
/**
* Increments a value
* @param mc client to use
* @param key null terminated string containing the key
* @param n number to increment by
* @param nv new value after incrementing
*/
APU_DECLARE(apr_status_t) apr_memcache_incr(apr_memcache_t *mc,
const char *key,
apr_int32_t n,
apr_uint32_t *nv);
/**
* Decrements a value
* @param mc client to use
* @param key null terminated string containing the key
* @param n number to decrement by
* @param new_value new value after decrementing
*/
APU_DECLARE(apr_status_t) apr_memcache_decr(apr_memcache_t *mc,
const char *key,
apr_int32_t n,
apr_uint32_t *new_value);
/**
* Query a server's version
* @param ms server to query
* @param p Pool to allocate answer from
* @param baton location to store server version string
* @param len length of the server version string
*/
APU_DECLARE(apr_status_t) apr_memcache_version(apr_memcache_server_t *ms,
apr_pool_t *p,
char **baton);
typedef struct
{
/** Version string of this server */
const char *version;
/** Process id of this server process */
apr_uint32_t pid;
/** Number of seconds this server has been running */
apr_uint32_t uptime;
/** current UNIX time according to the server */
apr_time_t time;
/** The size of a pointer on the current machine */
apr_uint32_t pointer_size;
/** Accumulated user time for this process */
apr_time_t rusage_user;
/** Accumulated system time for this process */
apr_time_t rusage_system;
/** Current number of items stored by the server */
apr_uint32_t curr_items;
/** Total number of items stored by this server */
apr_uint32_t total_items;
/** Current number of bytes used by this server to store items */
apr_uint64_t bytes;
/** Number of open connections */
apr_uint32_t curr_connections;
/** Total number of connections opened since the server started running */
apr_uint32_t total_connections;
/** Number of connection structures allocated by the server */
apr_uint32_t connection_structures;
/** Cumulative number of retrieval requests */
apr_uint32_t cmd_get;
/** Cumulative number of storage requests */
apr_uint32_t cmd_set;
/** Number of keys that have been requested and found present */
apr_uint32_t get_hits;
/** Number of items that have been requested and not found */
apr_uint32_t get_misses;
/** Number of items removed from cache because they passed their
expiration time */
apr_uint64_t evictions;
/** Total number of bytes read by this server */
apr_uint64_t bytes_read;
/** Total number of bytes sent by this server */
apr_uint64_t bytes_written;
/** Number of bytes this server is allowed to use for storage. */
apr_uint32_t limit_maxbytes;
/** Number of threads the server is running (if built with threading) */
apr_uint32_t threads;
} apr_memcache_stats_t;
/**
* Query a server for statistics
* @param ms server to query
* @param p Pool to allocate answer from
* @param stats location of the new statistics structure
*/
APU_DECLARE(apr_status_t) apr_memcache_stats(apr_memcache_server_t *ms,
apr_pool_t *p,
apr_memcache_stats_t **stats);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* APR_MEMCACHE_H */

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