mirror of
https://github.com/signalwire/freeswitch.git
synced 2026-11-15 22:08:33 +00:00
add apr-util 1.2.8 to in tree libs
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@3734 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Michael Jerris committed
1 parent
0488a5109a
commit
3b35430557
197 files changed
+130292
No files matched your search
@@ -0,0 +1,128 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @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 */
|
||||
@@ -0,0 +1,111 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
* 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-encrypted string, get the length of the
|
||||
* encrypted string.
|
||||
* @param len the length of an unencrypted string.
|
||||
* @return the length of the string after it is encrypted
|
||||
*/
|
||||
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 length of a plain text string given the encoded version
|
||||
* @param coded_src The encoded string
|
||||
* @return the length of 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 */
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,106 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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 */
|
||||
@@ -0,0 +1,357 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/* Overview of what this is and does:
|
||||
* http://www.apache.org/~niq/dbd.html
|
||||
*/
|
||||
|
||||
#ifndef APR_DBD_H
|
||||
#define APR_DBD_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @file apr_dbd.h
|
||||
* @brief APR-UTIL DBD library
|
||||
*/
|
||||
/**
|
||||
* @defgroup APR_Util_DBD DBD routines
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
|
||||
/* 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: open a connection to a backend
|
||||
*
|
||||
* @param pool - working pool
|
||||
* @param params - arguments to driver (implementation-dependent)
|
||||
* @param handle - pointer to handle to return
|
||||
* @param driver - driver struct.
|
||||
* @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 MySQL: the params can have "host", "port", "user", "pass",
|
||||
* "dbname", "sock", "flags" and "fldsz" 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.
|
||||
*/
|
||||
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 handle - handle to close
|
||||
* @param driver - driver struct.
|
||||
* @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 If any of the query/select calls during a transaction return
|
||||
* non-zero status code, the transaction will inherit this code and any
|
||||
* further query/select calls will fail immediately.
|
||||
*/
|
||||
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);
|
||||
|
||||
/** 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, 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_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 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.
|
||||
* Some drivers may support different data types using printf-like format:
|
||||
* for example %d (e.g. PostgreSQL) or %f for numeric data.
|
||||
*/
|
||||
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 - number of args to prepared statement
|
||||
* @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 - number of args to prepared statement
|
||||
* @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(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(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,
|
||||
...);
|
||||
|
||||
/** @} */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,224 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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>
|
||||
* GDBM for GDBM files
|
||||
* SDBM for SDBM files
|
||||
* DB for berkeley DB files
|
||||
* NDBM for NDBM files
|
||||
* 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.
|
||||
*/
|
||||
|
||||
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
|
||||
* @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 */
|
||||
@@ -0,0 +1,256 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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
|
||||
* @{
|
||||
*/
|
||||
/** 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; \
|
||||
\
|
||||
if(!_hooks.link_##name) \
|
||||
return; \
|
||||
\
|
||||
pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \
|
||||
for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \
|
||||
pHook[n].pFunc 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; \
|
||||
\
|
||||
if(!_hooks.link_##name) \
|
||||
return ok; \
|
||||
\
|
||||
pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \
|
||||
for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \
|
||||
{ \
|
||||
rv=pHook[n].pFunc args_use; \
|
||||
\
|
||||
if(rv != ok && rv != decline) \
|
||||
return rv; \
|
||||
} \
|
||||
return ok; \
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* 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; \
|
||||
\
|
||||
if(!_hooks.link_##name) \
|
||||
return decline; \
|
||||
\
|
||||
pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \
|
||||
for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \
|
||||
{ \
|
||||
rv=pHook[n].pFunc args_use; \
|
||||
\
|
||||
if(rv != decline) \
|
||||
return rv; \
|
||||
} \
|
||||
return decline; \
|
||||
}
|
||||
|
||||
/* 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 registerd 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 */
|
||||
@@ -0,0 +1,131 @@
|
||||
/* Copyright 2002-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* 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_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.
|
||||
*/
|
||||
#define APR_HAS_LDAP_SSL 1
|
||||
#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
|
||||
|
||||
|
||||
/* 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
|
||||
|
||||
#include "apr_ldap_url.h"
|
||||
#include "apr_ldap_init.h"
|
||||
#include "apr_ldap_option.h"
|
||||
|
||||
/** @} */
|
||||
#endif /* APR_HAS_LDAP */
|
||||
#endif /* APU_LDAP_H */
|
||||
@@ -0,0 +1,133 @@
|
||||
/* Copyright 2002-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* 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
|
||||
#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
|
||||
|
||||
#include "apr_ldap_url.h"
|
||||
#include "apr_ldap_init.h"
|
||||
#include "apr_ldap_option.h"
|
||||
|
||||
/** @} */
|
||||
#endif /* APR_HAS_LDAP */
|
||||
#endif /* APU_LDAP_H */
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
/* Copyright 2002-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* 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_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.
|
||||
*/
|
||||
|
||||
#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
|
||||
|
||||
|
||||
/* 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
|
||||
|
||||
#include "apr_ldap_url.h"
|
||||
#include "apr_ldap_init.h"
|
||||
#include "apr_ldap_option.h"
|
||||
|
||||
/** @} */
|
||||
#endif /* APR_HAS_LDAP */
|
||||
#endif /* APU_LDAP_H */
|
||||
@@ -0,0 +1,137 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file apr_ldap_init.h
|
||||
* @brief APR-UTIL LDAP ldap_init() functions
|
||||
*/
|
||||
#ifndef APR_LDAP_INIT_H
|
||||
#define APR_LDAP_INIT_H
|
||||
|
||||
/**
|
||||
* @defgroup APR_Util_LDAP LDAP
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
|
||||
#include "apr_ldap.h"
|
||||
|
||||
#if APR_HAS_LDAP
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/**
|
||||
* 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(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(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(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(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 */
|
||||
@@ -0,0 +1,240 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file apr_ldap_option.h
|
||||
* @brief APR-UTIL LDAP ldap_*_option() functions
|
||||
*/
|
||||
#ifndef APR_LDAP_OPTION_H
|
||||
#define APR_LDAP_OPTION_H
|
||||
|
||||
/**
|
||||
* @defgroup APR_Util_LDAP LDAP
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
|
||||
#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
|
||||
|
||||
/**
|
||||
* 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
|
||||
|
||||
/**
|
||||
* 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(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(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 */
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file apr_ldap_url.h
|
||||
* @brief APR-UTIL LDAP ldap_init() functions
|
||||
*/
|
||||
#ifndef APR_LDAP_URL_H
|
||||
#define APR_LDAP_URL_H
|
||||
|
||||
/**
|
||||
* @defgroup APR_Util_LDAP LDAP
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
|
||||
#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 */
|
||||
@@ -0,0 +1,135 @@
|
||||
/* Copyright 2001-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
/* 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 */
|
||||
@@ -0,0 +1,162 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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 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);
|
||||
|
||||
|
||||
/**
|
||||
* Validate hashes created by APR-supported algorithms: md5 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 */
|
||||
@@ -0,0 +1,92 @@
|
||||
/* Copyright 2001-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APR_OPTIONAL_H
|
||||
#define APR_OPTIONAL_H
|
||||
|
||||
#include "apu.h"
|
||||
/**
|
||||
* @file apr_optional.h
|
||||
* @brief APR-UTIL registration of functions exported by modules
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @defgroup APR_Util_Opt Optional Functions
|
||||
* @ingroup APR_Util
|
||||
*
|
||||
* Typesafe registration and retrieval of functions that may not be present
|
||||
* (i.e. functions exported by optional modules)
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* The type of an optional function.
|
||||
* @param name The name of the function
|
||||
*/
|
||||
#define APR_OPTIONAL_FN_TYPE(name) apr_OFN_##name##_t
|
||||
|
||||
/**
|
||||
* Declare an optional function.
|
||||
* @param ret The return type of the function
|
||||
* @param name The name of the function
|
||||
* @param args The function arguments (including brackets)
|
||||
*/
|
||||
#define APR_DECLARE_OPTIONAL_FN(ret,name,args) \
|
||||
typedef ret (APR_OPTIONAL_FN_TYPE(name)) args
|
||||
|
||||
/**
|
||||
* XXX: This doesn't belong here, then!
|
||||
* Private function! DO NOT USE!
|
||||
* @internal
|
||||
*/
|
||||
|
||||
typedef void (apr_opt_fn_t)(void);
|
||||
/** @internal */
|
||||
APU_DECLARE_NONSTD(void) apr_dynamic_fn_register(const char *szName,
|
||||
apr_opt_fn_t *pfn);
|
||||
|
||||
/**
|
||||
* Register an optional function. This can be later retrieved, type-safely, by
|
||||
* name. Like all global functions, the name must be unique. Note that,
|
||||
* confusingly but correctly, the function itself can be static!
|
||||
* @param name The name of the function
|
||||
*/
|
||||
#define APR_REGISTER_OPTIONAL_FN(name) do { \
|
||||
APR_OPTIONAL_FN_TYPE(name) *apu__opt = name; \
|
||||
apr_dynamic_fn_register(#name,(apr_opt_fn_t *)apu__opt); \
|
||||
} while (0)
|
||||
|
||||
/** @internal
|
||||
* Private function! DO NOT USE!
|
||||
*/
|
||||
APU_DECLARE(apr_opt_fn_t *) apr_dynamic_fn_retrieve(const char *szName);
|
||||
|
||||
/**
|
||||
* Retrieve an optional function. Returns NULL if the function is not present.
|
||||
* @param name The name of the function
|
||||
*/
|
||||
#define APR_RETRIEVE_OPTIONAL_FN(name) \
|
||||
(APR_OPTIONAL_FN_TYPE(name) *)apr_dynamic_fn_retrieve(#name)
|
||||
|
||||
/** @} */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* APR_OPTIONAL_H */
|
||||
@@ -0,0 +1,117 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
/**
|
||||
* @file apr_optional_hooks.h
|
||||
* @brief Apache optional hook functions
|
||||
*/
|
||||
|
||||
|
||||
#ifndef APR_OPTIONAL_HOOK_H
|
||||
#define APR_OPTIONAL_HOOK_H
|
||||
|
||||
#include "apr_tables.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/**
|
||||
* @defgroup APR_Util_OPT_HOOK Optional Hook Functions
|
||||
* @ingroup APR_Util_Hook
|
||||
* @{
|
||||
*/
|
||||
/**
|
||||
* Function to implemnt the APR_OPTIONAL_HOOK Macro
|
||||
* @internal
|
||||
* @see APR_OPTIONAL_HOOK
|
||||
*
|
||||
* @param name The name of the hook
|
||||
* @param pfn A pointer to a function that will be called
|
||||
* @param aszPre a NULL-terminated array of strings that name modules whose hooks should precede this one
|
||||
* @param aszSucc a NULL-terminated array of strings that name modules whose hooks should succeed this one
|
||||
* @param nOrder an integer determining order before honouring aszPre and aszSucc (for example HOOK_MIDDLE)
|
||||
*/
|
||||
|
||||
|
||||
APU_DECLARE(void) apr_optional_hook_add(const char *szName,void (*pfn)(void),
|
||||
const char * const *aszPre,
|
||||
const char * const *aszSucc,
|
||||
int nOrder);
|
||||
|
||||
/**
|
||||
* Hook to an optional hook.
|
||||
*
|
||||
* @param ns The namespace prefix of the hook functions
|
||||
* @param name The name of the hook
|
||||
* @param pfn A pointer to a function that will be called
|
||||
* @param aszPre a NULL-terminated array of strings that name modules whose hooks should precede this one
|
||||
* @param aszSucc a NULL-terminated array of strings that name modules whose hooks should succeed this one
|
||||
* @param nOrder an integer determining order before honouring aszPre and aszSucc (for example HOOK_MIDDLE)
|
||||
*/
|
||||
|
||||
#define APR_OPTIONAL_HOOK(ns,name,pfn,aszPre,aszSucc,nOrder) do { \
|
||||
ns##_HOOK_##name##_t *apu__hook = pfn; \
|
||||
apr_optional_hook_add(#name,(void (*)(void))apu__hook,aszPre, aszSucc, nOrder); \
|
||||
} while (0)
|
||||
|
||||
/**
|
||||
* @internal
|
||||
* @param szName - the name of the function
|
||||
* @return the hook structure for a given hook
|
||||
*/
|
||||
APU_DECLARE(apr_array_header_t *) apr_optional_hook_get(const char *szName);
|
||||
|
||||
/**
|
||||
* Implement an optional 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 The type of the return value of the hook
|
||||
* @param ret The type of the return value 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
|
||||
* @param ok Success value
|
||||
* @param decline Decline value
|
||||
*/
|
||||
#define APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(ns,link,ret,name,args_decl,args_use,ok,decline) \
|
||||
link##_DECLARE(ret) ns##_run_##name args_decl \
|
||||
{ \
|
||||
ns##_LINK_##name##_t *pHook; \
|
||||
int n; \
|
||||
ret rv; \
|
||||
apr_array_header_t *pHookArray=apr_optional_hook_get(#name); \
|
||||
\
|
||||
if(!pHookArray) \
|
||||
return ok; \
|
||||
\
|
||||
pHook=(ns##_LINK_##name##_t *)pHookArray->elts; \
|
||||
for(n=0 ; n < pHookArray->nelts ; ++n) \
|
||||
{ \
|
||||
rv=(pHook[n].pFunc)args_use; \
|
||||
\
|
||||
if(rv != ok && rv != decline) \
|
||||
return rv; \
|
||||
} \
|
||||
return ok; \
|
||||
}
|
||||
|
||||
/** @} */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* APR_OPTIONAL_HOOK_H */
|
||||
@@ -0,0 +1,138 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APR_QUEUE_H
|
||||
#define APR_QUEUE_H
|
||||
|
||||
/**
|
||||
* @file apr_queue.h
|
||||
* @brief Thread Safe FIFO bounded queue
|
||||
* @note Since most implementations of the queue are backed by a condition
|
||||
* variable implementation, it isn't available on systems without threads.
|
||||
* Although condition variables are some times available without threads.
|
||||
*/
|
||||
|
||||
#include "apu.h"
|
||||
#include "apr_errno.h"
|
||||
#include "apr_pools.h"
|
||||
|
||||
#if APR_HAS_THREADS
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/**
|
||||
* @defgroup APR_Util_FIFO Thread Safe FIFO bounded queue
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* opaque structure
|
||||
*/
|
||||
typedef struct apr_queue_t apr_queue_t;
|
||||
|
||||
/**
|
||||
* create a FIFO queue
|
||||
* @param queue The new queue
|
||||
* @param queue_capacity maximum size of the queue
|
||||
* @param a pool to allocate queue from
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_queue_create(apr_queue_t **queue,
|
||||
unsigned int queue_capacity,
|
||||
apr_pool_t *a);
|
||||
|
||||
/**
|
||||
* push/add a object to the queue, blocking if the queue is already full
|
||||
*
|
||||
* @param queue the queue
|
||||
* @param data the data
|
||||
* @returns APR_EINTR the blocking was interrupted (try again)
|
||||
* @returns APR_EOF the queue has been terminated
|
||||
* @returns APR_SUCCESS on a successfull push
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_queue_push(apr_queue_t *queue, void *data);
|
||||
|
||||
/**
|
||||
* pop/get an object from the queue, blocking if the queue is already empty
|
||||
*
|
||||
* @param queue the queue
|
||||
* @param data the data
|
||||
* @returns APR_EINTR the blocking was interrupted (try again)
|
||||
* @returns APR_EOF if the queue has been terminated
|
||||
* @returns APR_SUCCESS on a successfull pop
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_queue_pop(apr_queue_t *queue, void **data);
|
||||
|
||||
/**
|
||||
* push/add a object to the queue, returning immediatly if the queue is full
|
||||
*
|
||||
* @param queue the queue
|
||||
* @param data the data
|
||||
* @returns APR_EINTR the blocking operation was interrupted (try again)
|
||||
* @returns APR_EAGAIN the queue is full
|
||||
* @returns APR_EOF the queue has been terminated
|
||||
* @returns APR_SUCCESS on a successfull push
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_queue_trypush(apr_queue_t *queue, void *data);
|
||||
|
||||
/**
|
||||
* pop/get an object to the queue, returning immediatly if the queue is empty
|
||||
*
|
||||
* @param queue the queue
|
||||
* @param data the data
|
||||
* @returns APR_EINTR the blocking operation was interrupted (try again)
|
||||
* @returns APR_EAGAIN the queue is empty
|
||||
* @returns APR_EOF the queue has been terminated
|
||||
* @returns APR_SUCCESS on a successfull push
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_queue_trypop(apr_queue_t *queue, void **data);
|
||||
|
||||
/**
|
||||
* returns the size of the queue.
|
||||
*
|
||||
* @warning this is not threadsafe, and is intended for reporting/monitoring
|
||||
* of the queue.
|
||||
* @param queue the queue
|
||||
* @returns the size of the queue
|
||||
*/
|
||||
APU_DECLARE(unsigned int) apr_queue_size(apr_queue_t *queue);
|
||||
|
||||
/**
|
||||
* interrupt all the threads blocking on this queue.
|
||||
*
|
||||
* @param queue the queue
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_queue_interrupt_all(apr_queue_t *queue);
|
||||
|
||||
/**
|
||||
* terminate all queue, sendinging a interupt to all the
|
||||
* blocking threads
|
||||
*
|
||||
* @param queue the queue
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_queue_term(apr_queue_t *queue);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} */
|
||||
|
||||
#endif /* APR_HAS_THREADS */
|
||||
|
||||
#endif /* APRQUEUE_H */
|
||||
@@ -0,0 +1,144 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APR_RESLIST_H
|
||||
#define APR_RESLIST_H
|
||||
|
||||
/**
|
||||
* @file apr_reslist.h
|
||||
* @brief APR-UTIL Resource List Routines
|
||||
*/
|
||||
|
||||
#include "apr.h"
|
||||
#include "apu.h"
|
||||
#include "apr_pools.h"
|
||||
#include "apr_errno.h"
|
||||
#include "apr_time.h"
|
||||
|
||||
#if APR_HAS_THREADS
|
||||
|
||||
/**
|
||||
* @defgroup APR_Util_RL Resource List Routines
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/** Opaque resource list object */
|
||||
typedef struct apr_reslist_t apr_reslist_t;
|
||||
|
||||
/* Generic constructor called by resource list when it needs to create a
|
||||
* resource.
|
||||
* @param resource opaque resource
|
||||
* @param param flags
|
||||
* @param pool Pool
|
||||
*/
|
||||
typedef apr_status_t (*apr_reslist_constructor)(void **resource, void *params,
|
||||
apr_pool_t *pool);
|
||||
|
||||
/* Generic destructor called by resource list when it needs to destroy a
|
||||
* resource.
|
||||
* @param resource opaque resource
|
||||
* @param param flags
|
||||
* @param pool Pool
|
||||
*/
|
||||
typedef apr_status_t (*apr_reslist_destructor)(void *resource, void *params,
|
||||
apr_pool_t *pool);
|
||||
|
||||
/**
|
||||
* Create a new resource list with the following parameters:
|
||||
* @param reslist An address where the pointer to the new resource
|
||||
* list will be stored.
|
||||
* @param pool The pool to use for local storage and management
|
||||
* @param min Allowed minimum number of available resources. Zero
|
||||
* creates new resources only when needed.
|
||||
* @param smax Resources will be destroyed to meet this maximum
|
||||
* restriction as they expire.
|
||||
* @param hmax Absolute maximum limit on the number of total resources.
|
||||
* @param ttl If non-zero, sets the maximum amount of time a resource
|
||||
* may be available while exceeding the soft limit.
|
||||
* @param con Constructor routine that is called to create a new resource.
|
||||
* @param de Destructor routine that is called to destroy an expired resource.
|
||||
* @param params Passed to constructor and deconstructor
|
||||
* @param pool The pool from which to create this resoure list. Also the
|
||||
* same pool that is passed to the constructor and destructor
|
||||
* routines.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_reslist_create(apr_reslist_t **reslist,
|
||||
int min, int smax, int hmax,
|
||||
apr_interval_time_t ttl,
|
||||
apr_reslist_constructor con,
|
||||
apr_reslist_destructor de,
|
||||
void *params,
|
||||
apr_pool_t *pool);
|
||||
|
||||
/**
|
||||
* Destroy the given resource list and all resources controlled by
|
||||
* this list.
|
||||
* FIXME: Should this block until all resources become available,
|
||||
* or maybe just destroy all the free ones, or maybe destroy
|
||||
* them even though they might be in use by something else?
|
||||
* Currently it will abort if there are resources that haven't
|
||||
* been released, so there is an assumption that all resources
|
||||
* have been released to the list before calling this function.
|
||||
* @param reslist The reslist to destroy
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_reslist_destroy(apr_reslist_t *reslist);
|
||||
|
||||
/**
|
||||
* Retrieve a resource from the list, creating a new one if necessary.
|
||||
* If we have met our maximum number of resources, we will block
|
||||
* until one becomes available.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_reslist_acquire(apr_reslist_t *reslist,
|
||||
void **resource);
|
||||
|
||||
/**
|
||||
* Return a resource back to the list of available resources.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_reslist_release(apr_reslist_t *reslist,
|
||||
void *resource);
|
||||
|
||||
/**
|
||||
* Set the timeout the acquire will wait for a free resource
|
||||
* when the maximum number of resources is exceeded.
|
||||
* @param reslist The resource list.
|
||||
* @param timeout Timeout to wait. The zero waits forewer.
|
||||
*/
|
||||
APU_DECLARE(void) apr_reslist_timeout_set(apr_reslist_t *reslist,
|
||||
apr_interval_time_t timeout);
|
||||
|
||||
/**
|
||||
* Invalidate a resource in the pool - e.g. a database connection
|
||||
* that returns a "lost connection" error and can't be restored.
|
||||
* Use this instead of apr_reslist_release if the resource is bad.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_reslist_invalidate(apr_reslist_t *reslist,
|
||||
void *resource);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} */
|
||||
|
||||
#endif /* APR_HAS_THREADS */
|
||||
|
||||
#endif /* ! APR_RESLIST_H */
|
||||
@@ -0,0 +1,137 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APR_RMM_H
|
||||
#define APR_RMM_H
|
||||
/**
|
||||
* @file apr_rmm.h
|
||||
* @brief APR-UTIL Relocatable Memory Management Routines
|
||||
*/
|
||||
/**
|
||||
* @defgroup APR_Util_RMM Relocatable Memory Management Routines
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
|
||||
#include "apr.h"
|
||||
#include "apr_pools.h"
|
||||
#include "apr_errno.h"
|
||||
#include "apu.h"
|
||||
#include "apr_anylock.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/** Structure to access Relocatable, Managed Memory */
|
||||
typedef struct apr_rmm_t apr_rmm_t;
|
||||
|
||||
/** Fundamental allocation unit, within a specific apr_rmm_t */
|
||||
typedef apr_size_t apr_rmm_off_t;
|
||||
|
||||
/**
|
||||
* Initialize a relocatable memory block to be managed by the apr_rmm API.
|
||||
* @param rmm The relocatable memory block
|
||||
* @param lock An apr_anylock_t of the appropriate type of lock, or NULL
|
||||
* if no locking is required.
|
||||
* @param membuf The block of relocatable memory to be managed
|
||||
* @param memsize The size of relocatable memory block to be managed
|
||||
* @param cont The pool to use for local storage and management
|
||||
* @remark Both @param membuf and @param memsize must be aligned
|
||||
* (for instance using APR_ALIGN_DEFAULT).
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_rmm_init(apr_rmm_t **rmm, apr_anylock_t *lock,
|
||||
void *membuf, apr_size_t memsize,
|
||||
apr_pool_t *cont);
|
||||
|
||||
/**
|
||||
* Destroy a managed memory block.
|
||||
* @param rmm The relocatable memory block to destroy
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_rmm_destroy(apr_rmm_t *rmm);
|
||||
|
||||
/**
|
||||
* Attach to a relocatable memory block already managed by the apr_rmm API.
|
||||
* @param rmm The relocatable memory block
|
||||
* @param lock An apr_anylock_t of the appropriate type of lock
|
||||
* @param membuf The block of relocatable memory already under management
|
||||
* @param cont The pool to use for local storage and management
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_rmm_attach(apr_rmm_t **rmm, apr_anylock_t *lock,
|
||||
void *membuf, apr_pool_t *cont);
|
||||
|
||||
/**
|
||||
* Detach from the managed block of memory.
|
||||
* @param rmm The relocatable memory block to detach from
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_rmm_detach(apr_rmm_t *rmm);
|
||||
|
||||
/**
|
||||
* Allocate memory from the block of relocatable memory.
|
||||
* @param rmm The relocatable memory block
|
||||
* @param reqsize How much memory to allocate
|
||||
*/
|
||||
APU_DECLARE(apr_rmm_off_t) apr_rmm_malloc(apr_rmm_t *rmm, apr_size_t reqsize);
|
||||
|
||||
/**
|
||||
* Realloc memory from the block of relocatable memory.
|
||||
* @param rmm The relocatable memory block
|
||||
* @param entity The memory allocation to realloc
|
||||
* @param reqsize The new size
|
||||
*/
|
||||
APU_DECLARE(apr_rmm_off_t) apr_rmm_realloc(apr_rmm_t *rmm, void *entity, apr_size_t reqsize);
|
||||
|
||||
/**
|
||||
* Allocate memory from the block of relocatable memory and initialize it to zero.
|
||||
* @param rmm The relocatable memory block
|
||||
* @param reqsize How much memory to allocate
|
||||
*/
|
||||
APU_DECLARE(apr_rmm_off_t) apr_rmm_calloc(apr_rmm_t *rmm, apr_size_t reqsize);
|
||||
|
||||
/**
|
||||
* Free allocation returned by apr_rmm_malloc or apr_rmm_calloc.
|
||||
* @param rmm The relocatable memory block
|
||||
* @param entity The memory allocation to free
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_rmm_free(apr_rmm_t *rmm, apr_rmm_off_t entity);
|
||||
|
||||
/**
|
||||
* Retrieve the physical address of a relocatable allocation of memory
|
||||
* @param rmm The relocatable memory block
|
||||
* @param entity The memory allocation to free
|
||||
* @return address The address, aligned with APR_ALIGN_DEFAULT.
|
||||
*/
|
||||
APU_DECLARE(void *) apr_rmm_addr_get(apr_rmm_t *rmm, apr_rmm_off_t entity);
|
||||
|
||||
/**
|
||||
* Compute the offset of a relocatable allocation of memory
|
||||
* @param rmm The relocatable memory block
|
||||
* @param entity The physical address to convert to an offset
|
||||
*/
|
||||
APU_DECLARE(apr_rmm_off_t) apr_rmm_offset_get(apr_rmm_t *rmm, void *entity);
|
||||
|
||||
/**
|
||||
* Compute the required overallocation of memory needed to fit n allocs
|
||||
* @param n The number of alloc/calloc regions desired
|
||||
*/
|
||||
APU_DECLARE(apr_size_t) apr_rmm_overhead_get(int n);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/** @} */
|
||||
#endif /* ! APR_RMM_H */
|
||||
|
||||
@@ -0,0 +1,175 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* sdbm - ndbm work-alike hashed database library
|
||||
* based on Per-Ake Larson's Dynamic Hashing algorithms. BIT 18 (1978).
|
||||
* author: oz@nexus.yorku.ca
|
||||
* status: ex-public domain
|
||||
*/
|
||||
|
||||
#ifndef APR_SDBM_H
|
||||
#define APR_SDBM_H
|
||||
|
||||
#include "apu.h"
|
||||
#include "apr_errno.h"
|
||||
#include "apr_file_io.h" /* for apr_fileperms_t */
|
||||
|
||||
/**
|
||||
* @file apr_sdbm.h
|
||||
* @brief apr-util SDBM library
|
||||
*/
|
||||
/**
|
||||
* @defgroup APR_Util_DBM_SDBM SDBM library
|
||||
* @ingroup APR_Util_DBM
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Structure for referencing an sdbm
|
||||
*/
|
||||
typedef struct apr_sdbm_t apr_sdbm_t;
|
||||
|
||||
/**
|
||||
* Structure for referencing the datum record within an sdbm
|
||||
*/
|
||||
typedef struct {
|
||||
/** pointer to the data stored/retrieved */
|
||||
char *dptr;
|
||||
/** size of data */
|
||||
int dsize;
|
||||
} apr_sdbm_datum_t;
|
||||
|
||||
/* The extensions used for the database files */
|
||||
/** SDBM Directory file extension */
|
||||
#define APR_SDBM_DIRFEXT ".dir"
|
||||
/** SDBM page file extension */
|
||||
#define APR_SDBM_PAGFEXT ".pag"
|
||||
|
||||
/* flags to sdbm_store */
|
||||
#define APR_SDBM_INSERT 0 /**< Insert */
|
||||
#define APR_SDBM_REPLACE 1 /**< Replace */
|
||||
#define APR_SDBM_INSERTDUP 2 /**< Insert with duplicates */
|
||||
|
||||
/**
|
||||
* Open an sdbm database by file name
|
||||
* @param db The newly opened database
|
||||
* @param name The sdbm file to open
|
||||
* @param mode The flag values (APR_READ and APR_BINARY flags are implicit)
|
||||
* <PRE>
|
||||
* APR_WRITE open for read-write access
|
||||
* APR_CREATE create the sdbm if it does not exist
|
||||
* APR_TRUNCATE empty the contents of the sdbm
|
||||
* APR_EXCL fail for APR_CREATE if the file exists
|
||||
* APR_DELONCLOSE delete the sdbm when closed
|
||||
* APR_SHARELOCK support locking across process/machines
|
||||
* </PRE>
|
||||
* @param perms Permissions to apply to if created
|
||||
* @param p The pool to use when creating the sdbm
|
||||
* @remark The sdbm name is not a true file name, as sdbm appends suffixes
|
||||
* for seperate data and index files.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_sdbm_open(apr_sdbm_t **db, const char *name,
|
||||
apr_int32_t mode,
|
||||
apr_fileperms_t perms, apr_pool_t *p);
|
||||
|
||||
/**
|
||||
* Close an sdbm file previously opened by apr_sdbm_open
|
||||
* @param db The database to close
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_sdbm_close(apr_sdbm_t *db);
|
||||
|
||||
/**
|
||||
* Lock an sdbm database for concurency of multiple operations
|
||||
* @param db The database to lock
|
||||
* @param type The lock type
|
||||
* <PRE>
|
||||
* APR_FLOCK_SHARED
|
||||
* APR_FLOCK_EXCLUSIVE
|
||||
* </PRE>
|
||||
* @remark Calls to apr_sdbm_lock may be nested. All apr_sdbm functions
|
||||
* perform implicit locking. Since an APR_FLOCK_SHARED lock cannot be
|
||||
* portably promoted to an APR_FLOCK_EXCLUSIVE lock, apr_sdbm_store and
|
||||
* apr_sdbm_delete calls will fail if an APR_FLOCK_SHARED lock is held.
|
||||
* The apr_sdbm_lock call requires the database to be opened with the
|
||||
* APR_SHARELOCK mode value.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_sdbm_lock(apr_sdbm_t *db, int type);
|
||||
|
||||
/**
|
||||
* Release an sdbm lock previously aquired by apr_sdbm_lock
|
||||
* @param db The database to unlock
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_sdbm_unlock(apr_sdbm_t *db);
|
||||
|
||||
/**
|
||||
* Fetch an sdbm record value by key
|
||||
* @param db The database
|
||||
* @param value The value datum retrieved for this record
|
||||
* @param key The key datum to find this record
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_sdbm_fetch(apr_sdbm_t *db,
|
||||
apr_sdbm_datum_t *value,
|
||||
apr_sdbm_datum_t key);
|
||||
|
||||
/**
|
||||
* Store an sdbm record value by key
|
||||
* @param db The database
|
||||
* @param key The key datum to store this record by
|
||||
* @param value The value datum to store in this record
|
||||
* @param opt The method used to store the record
|
||||
* <PRE>
|
||||
* APR_SDBM_INSERT return an error if the record exists
|
||||
* APR_SDBM_REPLACE overwrite any existing record for key
|
||||
* </PRE>
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_sdbm_store(apr_sdbm_t *db, apr_sdbm_datum_t key,
|
||||
apr_sdbm_datum_t value, int opt);
|
||||
|
||||
/**
|
||||
* Delete an sdbm record value by key
|
||||
* @param db 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_sdbm_delete(apr_sdbm_t *db,
|
||||
const apr_sdbm_datum_t key);
|
||||
|
||||
/**
|
||||
* Retrieve the first record key from a dbm
|
||||
* @param db The database
|
||||
* @param key The key datum of the first record
|
||||
* @remark The keys returned are not ordered. To traverse the list of keys
|
||||
* for an sdbm opened with APR_SHARELOCK, the caller must use apr_sdbm_lock
|
||||
* prior to retrieving the first record, and hold the lock until after the
|
||||
* last call to apr_sdbm_nextkey.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_sdbm_firstkey(apr_sdbm_t *db, apr_sdbm_datum_t *key);
|
||||
|
||||
/**
|
||||
* Retrieve the next record key from an sdbm
|
||||
* @param db The database
|
||||
* @param key The key datum of the next record
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_sdbm_nextkey(apr_sdbm_t *db, apr_sdbm_datum_t *key);
|
||||
|
||||
/**
|
||||
* Returns true if the sdbm database opened for read-only access
|
||||
* @param db The database to test
|
||||
*/
|
||||
APU_DECLARE(int) apr_sdbm_rdonly(apr_sdbm_t *db);
|
||||
/** @} */
|
||||
#endif /* APR_SDBM_H */
|
||||
@@ -0,0 +1,121 @@
|
||||
/* Copyright 2001-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
/* 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
|
||||
*/
|
||||
|
||||
#ifndef APR_SHA1_H
|
||||
#define APR_SHA1_H
|
||||
|
||||
#include "apu.h"
|
||||
#include "apr_general.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @file apr_sha1.h
|
||||
* @brief APR-UTIL SHA1 library
|
||||
*/
|
||||
|
||||
/** size of the SHA1 DIGEST */
|
||||
#define APR_SHA1_DIGESTSIZE 20
|
||||
|
||||
/**
|
||||
* Define the Magic String prefix that identifies a password as being
|
||||
* hashed using our algorithm.
|
||||
*/
|
||||
#define APR_SHA1PW_ID "{SHA}"
|
||||
|
||||
/** length of the SHA Password */
|
||||
#define APR_SHA1PW_IDLEN 5
|
||||
|
||||
/** @see apr_sha1_ctx_t */
|
||||
typedef struct apr_sha1_ctx_t apr_sha1_ctx_t;
|
||||
|
||||
/**
|
||||
* SHA1 context structure
|
||||
*/
|
||||
struct apr_sha1_ctx_t {
|
||||
/** message digest */
|
||||
apr_uint32_t digest[5];
|
||||
/** 64-bit bit counts */
|
||||
apr_uint32_t count_lo, count_hi;
|
||||
/** SHA data buffer */
|
||||
apr_uint32_t data[16];
|
||||
/** unprocessed amount in data */
|
||||
int local;
|
||||
};
|
||||
|
||||
/**
|
||||
* Provide a means to SHA1 crypt/encode a plaintext password in a way which
|
||||
* makes password file compatible with those commonly use in netscape web
|
||||
* and ldap installations.
|
||||
* @param clear The plaintext password
|
||||
* @param len The length of the plaintext password
|
||||
* @param out The encrypted/encoded password
|
||||
* @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.
|
||||
*/
|
||||
APU_DECLARE(void) apr_sha1_base64(const char *clear, int len, char *out);
|
||||
|
||||
/**
|
||||
* Initialize the SHA digest
|
||||
* @param context The SHA context to initialize
|
||||
*/
|
||||
APU_DECLARE(void) apr_sha1_init(apr_sha1_ctx_t *context);
|
||||
|
||||
/**
|
||||
* Update the SHA digest
|
||||
* @param context The SHA1 context to update
|
||||
* @param input The buffer to add to the SHA digest
|
||||
* @param inputLen The length of the input buffer
|
||||
*/
|
||||
APU_DECLARE(void) apr_sha1_update(apr_sha1_ctx_t *context, const char *input,
|
||||
unsigned int inputLen);
|
||||
|
||||
/**
|
||||
* Update the SHA digest with binary data
|
||||
* @param context The SHA1 context to update
|
||||
* @param input The buffer to add to the SHA digest
|
||||
* @param inputLen The length of the input buffer
|
||||
*/
|
||||
APU_DECLARE(void) apr_sha1_update_binary(apr_sha1_ctx_t *context,
|
||||
const unsigned char *input,
|
||||
unsigned int inputLen);
|
||||
|
||||
/**
|
||||
* Finish computing the SHA digest
|
||||
* @param digest the output buffer in which to store the digest
|
||||
* @param context The context to finalize
|
||||
*/
|
||||
APU_DECLARE(void) apr_sha1_final(unsigned char digest[APR_SHA1_DIGESTSIZE],
|
||||
apr_sha1_ctx_t *context);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* APR_SHA1_H */
|
||||
@@ -0,0 +1,81 @@
|
||||
/* Copyright 2002-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APR_STRMATCH_H
|
||||
#define APR_STRMATCH_H
|
||||
/**
|
||||
* @file apr_strmatch.h
|
||||
* @brief APR-UTIL string matching routines
|
||||
*/
|
||||
|
||||
#include "apu.h"
|
||||
#include "apr_pools.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @defgroup APR_Util_StrMatch String matching routines
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @see apr_strmatch_pattern */
|
||||
typedef struct apr_strmatch_pattern apr_strmatch_pattern;
|
||||
|
||||
/**
|
||||
* Precompiled search pattern
|
||||
*/
|
||||
struct apr_strmatch_pattern {
|
||||
/** Function called to compare */
|
||||
const char *(*compare)(const apr_strmatch_pattern *this_pattern,
|
||||
const char *s, apr_size_t slen);
|
||||
const char *pattern; /**< Current pattern */
|
||||
apr_size_t length; /**< Current length */
|
||||
void *context; /**< hook to add precomputed metadata */
|
||||
};
|
||||
|
||||
#if defined(DOXYGEN)
|
||||
/**
|
||||
* Search for a precompiled pattern within a string
|
||||
* @param pattern The pattern
|
||||
* @param s The string in which to search for the pattern
|
||||
* @param slen The length of s (excluding null terminator)
|
||||
* @return A pointer to the first instance of the pattern in s, or
|
||||
* NULL if not found
|
||||
*/
|
||||
APU_DECLARE(const char *) apr_strmatch(const apr_strmatch_pattern *pattern,
|
||||
const char *s, apr_size_t slen);
|
||||
#else
|
||||
#define apr_strmatch(pattern, s, slen) (*((pattern)->compare))((pattern), (s), (slen))
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Precompile a pattern for matching using the Boyer-Moore-Horspool algorithm
|
||||
* @param p The pool from which to allocate the pattern
|
||||
* @param s The pattern string
|
||||
* @param case_sensitive Whether the matching should be case-sensitive
|
||||
* @return a pointer to the compiled pattern, or NULL if compilation fails
|
||||
*/
|
||||
APU_DECLARE(const apr_strmatch_pattern *) apr_strmatch_precompile(apr_pool_t *p, const char *s, int case_sensitive);
|
||||
|
||||
/** @} */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* !APR_STRMATCH_H */
|
||||
@@ -0,0 +1,178 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* apr_uri.h: External Interface of apr_uri.c
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file apr_uri.h
|
||||
* @brief APR-UTIL URI Routines
|
||||
*/
|
||||
|
||||
#ifndef APR_URI_H
|
||||
#define APR_URI_H
|
||||
|
||||
#include "apu.h"
|
||||
|
||||
#include "apr_network_io.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @defgroup APR_Util_URI URI
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define APR_URI_FTP_DEFAULT_PORT 21 /**< default FTP port */
|
||||
#define APR_URI_SSH_DEFAULT_PORT 22 /**< default SSH port */
|
||||
#define APR_URI_TELNET_DEFAULT_PORT 23 /**< default telnet port */
|
||||
#define APR_URI_GOPHER_DEFAULT_PORT 70 /**< default Gopher port */
|
||||
#define APR_URI_HTTP_DEFAULT_PORT 80 /**< default HTTP port */
|
||||
#define APR_URI_POP_DEFAULT_PORT 110 /**< default POP port */
|
||||
#define APR_URI_NNTP_DEFAULT_PORT 119 /**< default NNTP port */
|
||||
#define APR_URI_IMAP_DEFAULT_PORT 143 /**< default IMAP port */
|
||||
#define APR_URI_PROSPERO_DEFAULT_PORT 191 /**< default Prospero port */
|
||||
#define APR_URI_WAIS_DEFAULT_PORT 210 /**< default WAIS port */
|
||||
#define APR_URI_LDAP_DEFAULT_PORT 389 /**< default LDAP port */
|
||||
#define APR_URI_HTTPS_DEFAULT_PORT 443 /**< default HTTPS port */
|
||||
#define APR_URI_RTSP_DEFAULT_PORT 554 /**< default RTSP port */
|
||||
#define APR_URI_SNEWS_DEFAULT_PORT 563 /**< default SNEWS port */
|
||||
#define APR_URI_ACAP_DEFAULT_PORT 674 /**< default ACAP port */
|
||||
#define APR_URI_NFS_DEFAULT_PORT 2049 /**< default NFS port */
|
||||
#define APR_URI_TIP_DEFAULT_PORT 3372 /**< default TIP port */
|
||||
#define APR_URI_SIP_DEFAULT_PORT 5060 /**< default SIP port */
|
||||
|
||||
/** Flags passed to unparse_uri_components(): */
|
||||
/** suppress "scheme://user\@site:port" */
|
||||
#define APR_URI_UNP_OMITSITEPART (1U<<0)
|
||||
/** Just omit user */
|
||||
#define APR_URI_UNP_OMITUSER (1U<<1)
|
||||
/** Just omit password */
|
||||
#define APR_URI_UNP_OMITPASSWORD (1U<<2)
|
||||
/** omit "user:password\@" part */
|
||||
#define APR_URI_UNP_OMITUSERINFO (APR_URI_UNP_OMITUSER | \
|
||||
APR_URI_UNP_OMITPASSWORD)
|
||||
/** Show plain text password (default: show XXXXXXXX) */
|
||||
#define APR_URI_UNP_REVEALPASSWORD (1U<<3)
|
||||
/** Show "scheme://user\@site:port" only */
|
||||
#define APR_URI_UNP_OMITPATHINFO (1U<<4)
|
||||
/** Omit the "?queryarg" from the path */
|
||||
#define APR_URI_UNP_OMITQUERY (1U<<5)
|
||||
|
||||
/** @see apr_uri_t */
|
||||
typedef struct apr_uri_t apr_uri_t;
|
||||
|
||||
/**
|
||||
* A structure to encompass all of the fields in a uri
|
||||
*/
|
||||
struct apr_uri_t {
|
||||
/** scheme ("http"/"ftp"/...) */
|
||||
char *scheme;
|
||||
/** combined [user[:password]\@]host[:port] */
|
||||
char *hostinfo;
|
||||
/** user name, as in http://user:passwd\@host:port/ */
|
||||
char *user;
|
||||
/** password, as in http://user:passwd\@host:port/ */
|
||||
char *password;
|
||||
/** hostname from URI (or from Host: header) */
|
||||
char *hostname;
|
||||
/** port string (integer representation is in "port") */
|
||||
char *port_str;
|
||||
/** the request path (or "/" if only scheme://host was given) */
|
||||
char *path;
|
||||
/** Everything after a '?' in the path, if present */
|
||||
char *query;
|
||||
/** Trailing "#fragment" string, if present */
|
||||
char *fragment;
|
||||
|
||||
/** structure returned from gethostbyname() */
|
||||
struct hostent *hostent;
|
||||
|
||||
/** The port number, numeric, valid only if port_str != NULL */
|
||||
apr_port_t port;
|
||||
|
||||
/** has the structure been initialized */
|
||||
unsigned is_initialized:1;
|
||||
|
||||
/** has the DNS been looked up yet */
|
||||
unsigned dns_looked_up:1;
|
||||
/** has the dns been resolved yet */
|
||||
unsigned dns_resolved:1;
|
||||
};
|
||||
|
||||
/* apr_uri.c */
|
||||
/**
|
||||
* Return the default port for a given scheme. The schemes recognized are
|
||||
* http, ftp, https, gopher, wais, nntp, snews, and prospero
|
||||
* @param scheme_str The string that contains the current scheme
|
||||
* @return The default port for this scheme
|
||||
*/
|
||||
APU_DECLARE(apr_port_t) apr_uri_port_of_scheme(const char *scheme_str);
|
||||
|
||||
/**
|
||||
* Unparse a apr_uri_t structure to an URI string. Optionally
|
||||
* suppress the password for security reasons.
|
||||
* @param p The pool to allocate out of
|
||||
* @param uptr All of the parts of the uri
|
||||
* @param flags How to unparse the uri. One of:
|
||||
* <PRE>
|
||||
* APR_URI_UNP_OMITSITEPART Suppress "scheme://user\@site:port"
|
||||
* APR_URI_UNP_OMITUSER Just omit user
|
||||
* APR_URI_UNP_OMITPASSWORD Just omit password
|
||||
* APR_URI_UNP_OMITUSERINFO Omit "user:password\@" part
|
||||
* APR_URI_UNP_REVEALPASSWORD Show plain text password (default: show XXXXXXXX)
|
||||
* APR_URI_UNP_OMITPATHINFO Show "scheme://user\@site:port" only
|
||||
* APR_URI_UNP_OMITQUERY Omit "?queryarg" or "#fragment"
|
||||
* </PRE>
|
||||
* @return The uri as a string
|
||||
*/
|
||||
APU_DECLARE(char *) apr_uri_unparse(apr_pool_t *p,
|
||||
const apr_uri_t *uptr,
|
||||
unsigned flags);
|
||||
|
||||
/**
|
||||
* Parse a given URI, fill in all supplied fields of a apr_uri_t
|
||||
* structure. This eliminates the necessity of extracting host, port,
|
||||
* path, query info repeatedly in the modules.
|
||||
* @param p The pool to allocate out of
|
||||
* @param uri The uri to parse
|
||||
* @param uptr The apr_uri_t to fill out
|
||||
* @return APR_SUCCESS for success or error code
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_uri_parse(apr_pool_t *p, const char *uri,
|
||||
apr_uri_t *uptr);
|
||||
|
||||
/**
|
||||
* Special case for CONNECT parsing: it comes with the hostinfo part only
|
||||
* @param p The pool to allocate out of
|
||||
* @param hostinfo The hostinfo string to parse
|
||||
* @param uptr The apr_uri_t to fill out
|
||||
* @return APR_SUCCESS for success or error code
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_uri_parse_hostinfo(apr_pool_t *p,
|
||||
const char *hostinfo,
|
||||
apr_uri_t *uptr);
|
||||
|
||||
/** @} */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* APR_URI_H */
|
||||
@@ -0,0 +1,76 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file apr_uuid.h
|
||||
* @brief APR UUID library
|
||||
*/
|
||||
#ifndef APR_UUID_H
|
||||
#define APR_UUID_H
|
||||
|
||||
#include "apu.h"
|
||||
#include "apr_errno.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/**
|
||||
* @defgroup APR_UUID UUID Handling
|
||||
* @ingroup APR
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* we represent a UUID as a block of 16 bytes.
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
unsigned char data[16]; /**< the actual UUID */
|
||||
} apr_uuid_t;
|
||||
|
||||
/** UUIDs are formatted as: 00112233-4455-6677-8899-AABBCCDDEEFF */
|
||||
#define APR_UUID_FORMATTED_LENGTH 36
|
||||
|
||||
|
||||
/**
|
||||
* Generate and return a (new) UUID
|
||||
* @param uuid The resulting UUID
|
||||
*/
|
||||
APU_DECLARE(void) apr_uuid_get(apr_uuid_t *uuid);
|
||||
|
||||
/**
|
||||
* Format a UUID into a string, following the standard format
|
||||
* @param buffer The buffer to place the formatted UUID string into. It must
|
||||
* be at least APR_UUID_FORMATTED_LENGTH + 1 bytes long to hold
|
||||
* the formatted UUID and a null terminator
|
||||
* @param uuid The UUID to format
|
||||
*/
|
||||
APU_DECLARE(void) apr_uuid_format(char *buffer, const apr_uuid_t *uuid);
|
||||
|
||||
/**
|
||||
* Parse a standard-format string into a UUID
|
||||
* @param uuid The resulting UUID
|
||||
* @param uuid_str The formatted UUID
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_uuid_parse(apr_uuid_t *uuid, const char *uuid_str);
|
||||
|
||||
/** @} */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* APR_UUID_H */
|
||||
@@ -0,0 +1,163 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APR_XLATE_H
|
||||
#define APR_XLATE_H
|
||||
|
||||
#include "apu.h"
|
||||
#include "apr_pools.h"
|
||||
#include "apr_errno.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/**
|
||||
* @file apr_xlate.h
|
||||
* @brief APR I18N translation library
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup APR_XLATE I18N translation library
|
||||
* @ingroup APR
|
||||
* @{
|
||||
*/
|
||||
/** Opaque translation buffer */
|
||||
typedef struct apr_xlate_t apr_xlate_t;
|
||||
|
||||
/**
|
||||
* Set up for converting text from one charset to another.
|
||||
* @param convset The handle to be filled in by this function
|
||||
* @param topage The name of the target charset
|
||||
* @param frompage The name of the source charset
|
||||
* @param pool The pool to use
|
||||
* @remark
|
||||
* Specify APR_DEFAULT_CHARSET for one of the charset
|
||||
* names to indicate the charset of the source code at
|
||||
* compile time. This is useful if there are literal
|
||||
* strings in the source code which must be translated
|
||||
* according to the charset of the source code.
|
||||
* APR_DEFAULT_CHARSET is not useful if the source code
|
||||
* of the caller was not encoded in the same charset as
|
||||
* APR at compile time.
|
||||
*
|
||||
* @remark
|
||||
* Specify APR_LOCALE_CHARSET for one of the charset
|
||||
* names to indicate the charset of the current locale.
|
||||
*
|
||||
* @remark
|
||||
* Return APR_EINVAL if unable to procure a convset, or APR_ENOTIMPL
|
||||
* if charset transcoding is not available in this instance of
|
||||
* apr-util at all (i.e., APR_HAS_XLATE is undefined).
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_xlate_open(apr_xlate_t **convset,
|
||||
const char *topage,
|
||||
const char *frompage,
|
||||
apr_pool_t *pool);
|
||||
|
||||
/**
|
||||
* This is to indicate the charset of the sourcecode at compile time
|
||||
* names to indicate the charset of the source code at
|
||||
* compile time. This is useful if there are literal
|
||||
* strings in the source code which must be translated
|
||||
* according to the charset of the source code.
|
||||
*/
|
||||
#define APR_DEFAULT_CHARSET (const char *)0
|
||||
/**
|
||||
* To indicate charset names of the current locale
|
||||
*/
|
||||
#define APR_LOCALE_CHARSET (const char *)1
|
||||
|
||||
/**
|
||||
* Find out whether or not the specified conversion is single-byte-only.
|
||||
* @param convset The handle allocated by apr_xlate_open, specifying the
|
||||
* parameters of conversion
|
||||
* @param onoff Output: whether or not the conversion is single-byte-only
|
||||
* @remark
|
||||
* Return APR_ENOTIMPL if charset transcoding is not available
|
||||
* in this instance of apr-util (i.e., APR_HAS_XLATE is undefined).
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_xlate_sb_get(apr_xlate_t *convset, int *onoff);
|
||||
|
||||
/**
|
||||
* Convert a buffer of text from one codepage to another.
|
||||
* @param convset The handle allocated by apr_xlate_open, specifying
|
||||
* the parameters of conversion
|
||||
* @param inbuf The address of the source buffer
|
||||
* @param inbytes_left Input: the amount of input data to be translated
|
||||
* Output: the amount of input data not yet translated
|
||||
* @param outbuf The address of the destination buffer
|
||||
* @param outbytes_left Input: the size of the output buffer
|
||||
* Output: the amount of the output buffer not yet used
|
||||
* @remark
|
||||
* Returns APR_ENOTIMPL if charset transcoding is not available
|
||||
* in this instance of apr-util (i.e., APR_HAS_XLATE is undefined).
|
||||
* Returns APR_INCOMPLETE if the input buffer ends in an incomplete
|
||||
* multi-byte character.
|
||||
*
|
||||
* To correctly terminate the output buffer for some multi-byte
|
||||
* character set encodings, a final call must be made to this function
|
||||
* after the complete input string has been converted, passing
|
||||
* the inbuf and inbytes_left parameters as NULL. (Note that this
|
||||
* mode only works from version 1.1.0 onwards)
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_xlate_conv_buffer(apr_xlate_t *convset,
|
||||
const char *inbuf,
|
||||
apr_size_t *inbytes_left,
|
||||
char *outbuf,
|
||||
apr_size_t *outbytes_left);
|
||||
|
||||
/* @see apr_file_io.h the comment in apr_file_io.h about this hack */
|
||||
#ifdef APR_NOT_DONE_YET
|
||||
/**
|
||||
* The purpose of apr_xlate_conv_char is to translate one character
|
||||
* at a time. This needs to be written carefully so that it works
|
||||
* with double-byte character sets.
|
||||
* @param convset The handle allocated by apr_xlate_open, specifying the
|
||||
* parameters of conversion
|
||||
* @param inchar The character to convert
|
||||
* @param outchar The converted character
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_xlate_conv_char(apr_xlate_t *convset,
|
||||
char inchar, char outchar);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Convert a single-byte character from one charset to another.
|
||||
* @param convset The handle allocated by apr_xlate_open, specifying the
|
||||
* parameters of conversion
|
||||
* @param inchar The single-byte character to convert.
|
||||
* @warning This only works when converting between single-byte character sets.
|
||||
* -1 will be returned if the conversion can't be performed.
|
||||
*/
|
||||
APU_DECLARE(apr_int32_t) apr_xlate_conv_byte(apr_xlate_t *convset,
|
||||
unsigned char inchar);
|
||||
|
||||
/**
|
||||
* Close a codepage translation handle.
|
||||
* @param convset The codepage translation handle to close
|
||||
* @remark
|
||||
* Return APR_ENOTIMPL if charset transcoding is not available
|
||||
* in this instance of apr-util (i.e., APR_HAS_XLATE is undefined).
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_xlate_close(apr_xlate_t *convset);
|
||||
|
||||
/** @} */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ! APR_XLATE_H */
|
||||
@@ -0,0 +1,356 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
/**
|
||||
* @file apr_xml.h
|
||||
* @brief APR-UTIL XML Library
|
||||
*/
|
||||
#ifndef APR_XML_H
|
||||
#define APR_XML_H
|
||||
|
||||
/**
|
||||
* @defgroup APR_Util_XML XML
|
||||
* @ingroup APR_Util
|
||||
* @{
|
||||
*/
|
||||
#include "apr_pools.h"
|
||||
#include "apr_tables.h"
|
||||
#include "apr_file_io.h"
|
||||
|
||||
#include "apu.h"
|
||||
#if APR_CHARSET_EBCDIC
|
||||
#include "apr_xlate.h"
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @package Apache XML library
|
||||
*/
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
||||
/* ### these will need to move at some point to a more logical spot */
|
||||
|
||||
/** @see apr_text */
|
||||
typedef struct apr_text apr_text;
|
||||
|
||||
/** Structure to keep a linked list of pieces of text */
|
||||
struct apr_text {
|
||||
/** The current piece of text */
|
||||
const char *text;
|
||||
/** a pointer to the next piece of text */
|
||||
struct apr_text *next;
|
||||
};
|
||||
|
||||
/** @see apr_text_header */
|
||||
typedef struct apr_text_header apr_text_header;
|
||||
|
||||
/** A list of pieces of text */
|
||||
struct apr_text_header {
|
||||
/** The first piece of text in the list */
|
||||
apr_text *first;
|
||||
/** The last piece of text in the list */
|
||||
apr_text *last;
|
||||
};
|
||||
|
||||
/**
|
||||
* Append a piece of text to the end of a list
|
||||
* @param p The pool to allocate out of
|
||||
* @param hdr The text header to append to
|
||||
* @param text The new text to append
|
||||
*/
|
||||
APU_DECLARE(void) apr_text_append(apr_pool_t *p, apr_text_header *hdr,
|
||||
const char *text);
|
||||
|
||||
|
||||
/* --------------------------------------------------------------------
|
||||
**
|
||||
** XML PARSING
|
||||
*/
|
||||
|
||||
/*
|
||||
** Qualified namespace values
|
||||
**
|
||||
** APR_XML_NS_DAV_ID
|
||||
** We always insert the "DAV:" namespace URI at the head of the
|
||||
** namespace array. This means that it will always be at ID==0,
|
||||
** making it much easier to test for.
|
||||
**
|
||||
** APR_XML_NS_NONE
|
||||
** This special ID is used for two situations:
|
||||
**
|
||||
** 1) The namespace prefix begins with "xml" (and we do not know
|
||||
** what it means). Namespace prefixes with "xml" (any case) as
|
||||
** their first three characters are reserved by the XML Namespaces
|
||||
** specification for future use. mod_dav will pass these through
|
||||
** unchanged. When this identifier is used, the prefix is LEFT in
|
||||
** the element/attribute name. Downstream processing should not
|
||||
** prepend another prefix.
|
||||
**
|
||||
** 2) The element/attribute does not have a namespace.
|
||||
**
|
||||
** a) No prefix was used, and a default namespace has not been
|
||||
** defined.
|
||||
** b) No prefix was used, and the default namespace was specified
|
||||
** to mean "no namespace". This is done with a namespace
|
||||
** declaration of: xmlns=""
|
||||
** (this declaration is typically used to override a previous
|
||||
** specification for the default namespace)
|
||||
**
|
||||
** In these cases, we need to record that the elem/attr has no
|
||||
** namespace so that we will not attempt to prepend a prefix.
|
||||
** All namespaces that are used will have a prefix assigned to
|
||||
** them -- mod_dav will never set or use the default namespace
|
||||
** when generating XML. This means that "no prefix" will always
|
||||
** mean "no namespace".
|
||||
**
|
||||
** In both cases, the XML generation will avoid prepending a prefix.
|
||||
** For the first case, this means the original prefix/name will be
|
||||
** inserted into the output stream. For the latter case, it means
|
||||
** the name will have no prefix, and since we never define a default
|
||||
** namespace, this means it will have no namespace.
|
||||
**
|
||||
** Note: currently, mod_dav understands the "xmlns" prefix and the
|
||||
** "xml:lang" attribute. These are handled specially (they aren't
|
||||
** left within the XML tree), so the APR_XML_NS_NONE value won't ever
|
||||
** really apply to these values.
|
||||
*/
|
||||
#define APR_XML_NS_DAV_ID 0 /**< namespace ID for "DAV:" */
|
||||
#define APR_XML_NS_NONE -10 /**< no namespace for this elem/attr */
|
||||
|
||||
#define APR_XML_NS_ERROR_BASE -100 /**< used only during processing */
|
||||
/** Is this namespace an error? */
|
||||
#define APR_XML_NS_IS_ERROR(e) ((e) <= APR_XML_NS_ERROR_BASE)
|
||||
|
||||
/** @see apr_xml_attr */
|
||||
typedef struct apr_xml_attr apr_xml_attr;
|
||||
/** @see apr_xml_elem */
|
||||
typedef struct apr_xml_elem apr_xml_elem;
|
||||
/** @see apr_xml_doc */
|
||||
typedef struct apr_xml_doc apr_xml_doc;
|
||||
|
||||
/** apr_xml_attr: holds a parsed XML attribute */
|
||||
struct apr_xml_attr {
|
||||
/** attribute name */
|
||||
const char *name;
|
||||
/** index into namespace array */
|
||||
int ns;
|
||||
|
||||
/** attribute value */
|
||||
const char *value;
|
||||
|
||||
/** next attribute */
|
||||
struct apr_xml_attr *next;
|
||||
};
|
||||
|
||||
/** apr_xml_elem: holds a parsed XML element */
|
||||
struct apr_xml_elem {
|
||||
/** element name */
|
||||
const char *name;
|
||||
/** index into namespace array */
|
||||
int ns;
|
||||
/** xml:lang for attrs/contents */
|
||||
const char *lang;
|
||||
|
||||
/** cdata right after start tag */
|
||||
apr_text_header first_cdata;
|
||||
/** cdata after MY end tag */
|
||||
apr_text_header following_cdata;
|
||||
|
||||
/** parent element */
|
||||
struct apr_xml_elem *parent;
|
||||
/** next (sibling) element */
|
||||
struct apr_xml_elem *next;
|
||||
/** first child element */
|
||||
struct apr_xml_elem *first_child;
|
||||
/** first attribute */
|
||||
struct apr_xml_attr *attr;
|
||||
|
||||
/* used only during parsing */
|
||||
/** last child element */
|
||||
struct apr_xml_elem *last_child;
|
||||
/** namespaces scoped by this elem */
|
||||
struct apr_xml_ns_scope *ns_scope;
|
||||
|
||||
/* used by modules during request processing */
|
||||
/** Place for modules to store private data */
|
||||
void *priv;
|
||||
};
|
||||
|
||||
/** Is this XML element empty? */
|
||||
#define APR_XML_ELEM_IS_EMPTY(e) ((e)->first_child == NULL && \
|
||||
(e)->first_cdata.first == NULL)
|
||||
|
||||
/** apr_xml_doc: holds a parsed XML document */
|
||||
struct apr_xml_doc {
|
||||
/** root element */
|
||||
apr_xml_elem *root;
|
||||
/** array of namespaces used */
|
||||
apr_array_header_t *namespaces;
|
||||
};
|
||||
|
||||
/** Opaque XML parser structure */
|
||||
typedef struct apr_xml_parser apr_xml_parser;
|
||||
|
||||
/**
|
||||
* Create an XML parser
|
||||
* @param pool The pool for allocating the parser and the parse results.
|
||||
* @return The new parser.
|
||||
*/
|
||||
APU_DECLARE(apr_xml_parser *) apr_xml_parser_create(apr_pool_t *pool);
|
||||
|
||||
/**
|
||||
* Parse a File, producing a xml_doc
|
||||
* @param p The pool for allocating the parse results.
|
||||
* @param parser A pointer to *parser (needed so calling function can get
|
||||
* errors), will be set to NULL on successfull completion.
|
||||
* @param ppdoc A pointer to *apr_xml_doc (which has the parsed results in it)
|
||||
* @param xmlfd A file to read from.
|
||||
* @param buffer_length Buffer length which would be suitable
|
||||
* @return Any errors found during parsing.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_xml_parse_file(apr_pool_t *p,
|
||||
apr_xml_parser **parser,
|
||||
apr_xml_doc **ppdoc,
|
||||
apr_file_t *xmlfd,
|
||||
apr_size_t buffer_length);
|
||||
|
||||
|
||||
/**
|
||||
* Feed input into the parser
|
||||
* @param parser The XML parser for parsing this data.
|
||||
* @param data The data to parse.
|
||||
* @param len The length of the data.
|
||||
* @return Any errors found during parsing.
|
||||
* @remark Use apr_xml_parser_geterror() to get more error information.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_xml_parser_feed(apr_xml_parser *parser,
|
||||
const char *data,
|
||||
apr_size_t len);
|
||||
|
||||
/**
|
||||
* Terminate the parsing and return the result
|
||||
* @param parser The XML parser for parsing this data.
|
||||
* @param pdoc The resulting parse information. May be NULL to simply
|
||||
* terminate the parsing without fetching the info.
|
||||
* @return Any errors found during the final stage of parsing.
|
||||
* @remark Use apr_xml_parser_geterror() to get more error information.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_xml_parser_done(apr_xml_parser *parser,
|
||||
apr_xml_doc **pdoc);
|
||||
|
||||
/**
|
||||
* Fetch additional error information from the parser.
|
||||
* @param parser The XML parser to query for errors.
|
||||
* @param errbuf A buffer for storing error text.
|
||||
* @param errbufsize The length of the error text buffer.
|
||||
* @return The error buffer
|
||||
*/
|
||||
APU_DECLARE(char *) apr_xml_parser_geterror(apr_xml_parser *parser,
|
||||
char *errbuf,
|
||||
apr_size_t errbufsize);
|
||||
|
||||
|
||||
/**
|
||||
* Converts an XML element tree to flat text
|
||||
* @param p The pool to allocate out of
|
||||
* @param elem The XML element to convert
|
||||
* @param style How to covert the XML. One of:
|
||||
* <PRE>
|
||||
* APR_XML_X2T_FULL start tag, contents, end tag
|
||||
* APR_XML_X2T_INNER contents only
|
||||
* APR_XML_X2T_LANG_INNER xml:lang + inner contents
|
||||
* APR_XML_X2T_FULL_NS_LANG FULL + ns defns + xml:lang
|
||||
* </PRE>
|
||||
* @param namespaces The namespace of the current XML element
|
||||
* @param ns_map Namespace mapping
|
||||
* @param pbuf Buffer to put the converted text into
|
||||
* @param psize Size of the converted text
|
||||
*/
|
||||
APU_DECLARE(void) apr_xml_to_text(apr_pool_t *p, const apr_xml_elem *elem,
|
||||
int style, apr_array_header_t *namespaces,
|
||||
int *ns_map, const char **pbuf,
|
||||
apr_size_t *psize);
|
||||
|
||||
/* style argument values: */
|
||||
#define APR_XML_X2T_FULL 0 /**< start tag, contents, end tag */
|
||||
#define APR_XML_X2T_INNER 1 /**< contents only */
|
||||
#define APR_XML_X2T_LANG_INNER 2 /**< xml:lang + inner contents */
|
||||
#define APR_XML_X2T_FULL_NS_LANG 3 /**< FULL + ns defns + xml:lang */
|
||||
|
||||
/**
|
||||
* empty XML element
|
||||
* @param p The pool to allocate out of
|
||||
* @param elem The XML element to empty
|
||||
* @return the string that was stored in the XML element
|
||||
*/
|
||||
APU_DECLARE(const char *) apr_xml_empty_elem(apr_pool_t *p,
|
||||
const apr_xml_elem *elem);
|
||||
|
||||
/**
|
||||
* quote an XML string
|
||||
* Replace '<', '>', and '&' with '<', '>', and '&'.
|
||||
* @param p The pool to allocate out of
|
||||
* @param s The string to quote
|
||||
* @param quotes If quotes is true, then replace '"' with '"'.
|
||||
* @return The quoted string
|
||||
* @note If the string does not contain special characters, it is not
|
||||
* duplicated into the pool and the original string is returned.
|
||||
*/
|
||||
APU_DECLARE(const char *) apr_xml_quote_string(apr_pool_t *p, const char *s,
|
||||
int quotes);
|
||||
|
||||
/**
|
||||
* Quote an XML element
|
||||
* @param p The pool to allocate out of
|
||||
* @param elem The element to quote
|
||||
*/
|
||||
APU_DECLARE(void) apr_xml_quote_elem(apr_pool_t *p, apr_xml_elem *elem);
|
||||
|
||||
/* manage an array of unique URIs: apr_xml_insert_uri() and APR_XML_URI_ITEM() */
|
||||
|
||||
/**
|
||||
* return the URI's (existing) index, or insert it and return a new index
|
||||
* @param uri_array array to insert into
|
||||
* @param uri The uri to insert
|
||||
* @return int The uri's index
|
||||
*/
|
||||
APU_DECLARE(int) apr_xml_insert_uri(apr_array_header_t *uri_array,
|
||||
const char *uri);
|
||||
|
||||
/** Get the URI item for this XML element */
|
||||
#define APR_XML_GET_URI_ITEM(ary, i) (((const char * const *)(ary)->elts)[i])
|
||||
|
||||
#if APR_CHARSET_EBCDIC
|
||||
/**
|
||||
* Convert parsed tree in EBCDIC
|
||||
* @param p The pool to allocate out of
|
||||
* @param pdoc The apr_xml_doc to convert.
|
||||
* @param xlate The translation handle to use.
|
||||
* @return Any errors found during conversion.
|
||||
*/
|
||||
APU_DECLARE(apr_status_t) apr_xml_parser_convert_doc(apr_pool_t *p,
|
||||
apr_xml_doc *pdoc,
|
||||
apr_xlate_t *convset);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/** @} */
|
||||
#endif /* APR_XML_H */
|
||||
@@ -0,0 +1,91 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* apu.h is generated from apu.h.in by configure -- do not edit apu.h
|
||||
*/
|
||||
/* @file apu.h
|
||||
* @brief APR-Utility main file
|
||||
*/
|
||||
/**
|
||||
* @defgroup APR_Util APR Utility Functions
|
||||
* @{
|
||||
*/
|
||||
|
||||
|
||||
#ifndef APU_H
|
||||
#define APU_H
|
||||
|
||||
/**
|
||||
* APU_DECLARE_EXPORT is defined when building the APR-UTIL dynamic library,
|
||||
* so that all public symbols are exported.
|
||||
*
|
||||
* APU_DECLARE_STATIC is defined when including the APR-UTIL public headers,
|
||||
* to provide static linkage when the dynamic library may be unavailable.
|
||||
*
|
||||
* APU_DECLARE_STATIC and APU_DECLARE_EXPORT are left undefined when
|
||||
* including the APR-UTIL public headers, to import and link the symbols from
|
||||
* the dynamic APR-UTIL library and assure appropriate indirection and calling
|
||||
* conventions at compile time.
|
||||
*/
|
||||
|
||||
/**
|
||||
* The public APR-UTIL functions are declared with APU_DECLARE(), so they may
|
||||
* use the most appropriate calling convention. Public APR functions with
|
||||
* variable arguments must use APU_DECLARE_NONSTD().
|
||||
*
|
||||
* @deffunc APU_DECLARE(rettype) apr_func(args);
|
||||
*/
|
||||
#define APU_DECLARE(type) type
|
||||
/**
|
||||
* The public APR-UTIL functions using variable arguments are declared with
|
||||
* APU_DECLARE_NONSTD(), as they must use the C language calling convention.
|
||||
*
|
||||
* @deffunc APU_DECLARE_NONSTD(rettype) apr_func(args, ...);
|
||||
*/
|
||||
#define APU_DECLARE_NONSTD(type) type
|
||||
/**
|
||||
* The public APR-UTIL variables are declared with APU_DECLARE_DATA.
|
||||
* This assures the appropriate indirection is invoked at compile time.
|
||||
*
|
||||
* @deffunc APU_DECLARE_DATA type apr_variable;
|
||||
* @tip APU_DECLARE_DATA extern type apr_variable; syntax is required for
|
||||
* declarations within headers to properly import the variable.
|
||||
*/
|
||||
#define APU_DECLARE_DATA
|
||||
/*
|
||||
* we always have SDBM (it's in our codebase)
|
||||
*/
|
||||
#define APU_HAVE_SDBM @apu_have_sdbm@
|
||||
#define APU_HAVE_GDBM @apu_have_gdbm@
|
||||
#define APU_HAVE_NDBM @apu_have_ndbm@
|
||||
#define APU_HAVE_DB @apu_have_db@
|
||||
|
||||
#if APU_HAVE_DB
|
||||
#define APU_HAVE_DB_VERSION @apu_db_version@
|
||||
#endif /* APU_HAVE_DB */
|
||||
|
||||
#define APU_HAVE_PGSQL @apu_have_pgsql@
|
||||
#define APU_HAVE_MYSQL @apu_have_mysql@
|
||||
#define APU_HAVE_SQLITE3 @apu_have_sqlite3@
|
||||
#define APU_HAVE_SQLITE2 @apu_have_sqlite2@
|
||||
|
||||
#define APU_HAVE_APR_ICONV @have_apr_iconv@
|
||||
#define APU_HAVE_ICONV @have_iconv@
|
||||
#define APR_HAS_XLATE (APU_HAVE_APR_ICONV || APU_HAVE_ICONV)
|
||||
|
||||
#endif /* APU_H */
|
||||
/** @} */
|
||||
@@ -0,0 +1,84 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Note: This is a NetWare specific version of apu.h. It is renamed to
|
||||
* apu.h at the start of a NetWare build.
|
||||
*/
|
||||
/* @file apu.h
|
||||
* @brief APR-Utility main file
|
||||
*/
|
||||
/**
|
||||
* @defgroup APR_Util APR Utility Functions
|
||||
* @{
|
||||
*/
|
||||
|
||||
|
||||
#ifndef APU_H
|
||||
#define APU_H
|
||||
|
||||
/**
|
||||
* APU_DECLARE_EXPORT is defined when building the APR-UTIL dynamic library,
|
||||
* so that all public symbols are exported.
|
||||
*
|
||||
* APU_DECLARE_STATIC is defined when including the APR-UTIL public headers,
|
||||
* to provide static linkage when the dynamic library may be unavailable.
|
||||
*
|
||||
* APU_DECLARE_STATIC and APU_DECLARE_EXPORT are left undefined when
|
||||
* including the APR-UTIL public headers, to import and link the symbols from
|
||||
* the dynamic APR-UTIL library and assure appropriate indirection and calling
|
||||
* conventions at compile time.
|
||||
*/
|
||||
|
||||
/**
|
||||
* The public APR-UTIL functions are declared with APU_DECLARE(), so they may
|
||||
* use the most appropriate calling convention. Public APR functions with
|
||||
* variable arguments must use APU_DECLARE_NONSTD().
|
||||
*
|
||||
* @deffunc APU_DECLARE(rettype) apr_func(args);
|
||||
*/
|
||||
#define APU_DECLARE(type) type
|
||||
/**
|
||||
* The public APR-UTIL functions using variable arguments are declared with
|
||||
* APU_DECLARE_NONSTD(), as they must use the C language calling convention.
|
||||
*
|
||||
* @deffunc APU_DECLARE_NONSTD(rettype) apr_func(args, ...);
|
||||
*/
|
||||
#define APU_DECLARE_NONSTD(type) type
|
||||
/**
|
||||
* The public APR-UTIL variables are declared with APU_DECLARE_DATA.
|
||||
* This assures the appropriate indirection is invoked at compile time.
|
||||
*
|
||||
* @deffunc APU_DECLARE_DATA type apr_variable;
|
||||
* @tip APU_DECLARE_DATA extern type apr_variable; syntax is required for
|
||||
* declarations within headers to properly import the variable.
|
||||
*/
|
||||
#define APU_DECLARE_DATA
|
||||
/*
|
||||
* we always have SDBM (it's in our codebase)
|
||||
*/
|
||||
#define APU_HAVE_SDBM 1
|
||||
#define APU_HAVE_GDBM 0
|
||||
#define APU_HAVE_DB 0
|
||||
|
||||
|
||||
#define HAVE_ICONV_H 1
|
||||
#define APU_HAVE_APR_ICONV 0
|
||||
#define APU_HAVE_ICONV 1
|
||||
#define APR_HAS_XLATE (APU_HAVE_APR_ICONV || APU_HAVE_ICONV)
|
||||
|
||||
#endif /* APU_H */
|
||||
/** @} */
|
||||
@@ -0,0 +1,113 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Note: This is a Windows specific version of apu.h. It is renamed to
|
||||
* apu.h at the start of a Windows build.
|
||||
*/
|
||||
/* @file apu.h
|
||||
* @brief APR-Utility main file
|
||||
*/
|
||||
|
||||
#ifdef WIN32
|
||||
#ifndef APU_H
|
||||
#define APU_H
|
||||
/**
|
||||
* @defgroup APR_Util APR Utility Functions
|
||||
* @{
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* APU_DECLARE_EXPORT is defined when building the APR-UTIL dynamic library,
|
||||
* so that all public symbols are exported.
|
||||
*
|
||||
* APU_DECLARE_STATIC is defined when including the APR-UTIL public headers,
|
||||
* to provide static linkage when the dynamic library may be unavailable.
|
||||
*
|
||||
* APU_DECLARE_STATIC and APU_DECLARE_EXPORT are left undefined when
|
||||
* including the APR-UTIL public headers, to import and link the symbols from
|
||||
* the dynamic APR-UTIL library and assure appropriate indirection and calling
|
||||
* conventions at compile time.
|
||||
*/
|
||||
|
||||
#if defined(DOXYGEN) || !defined(WIN32)
|
||||
/**
|
||||
* The public APR-UTIL functions are declared with APU_DECLARE(), so they may
|
||||
* use the most appropriate calling convention. Public APR functions with
|
||||
* variable arguments must use APU_DECLARE_NONSTD().
|
||||
*
|
||||
* @deffunc APU_DECLARE(rettype) apr_func(args);
|
||||
*/
|
||||
#define APU_DECLARE(type) type
|
||||
/**
|
||||
* The public APR-UTIL functions using variable arguments are declared with
|
||||
* APU_DECLARE_NONSTD(), as they must use the C language calling convention.
|
||||
*
|
||||
* @deffunc APU_DECLARE_NONSTD(rettype) apr_func(args, ...);
|
||||
*/
|
||||
#define APU_DECLARE_NONSTD(type) type
|
||||
/**
|
||||
* The public APR-UTIL variables are declared with APU_DECLARE_DATA.
|
||||
* This assures the appropriate indirection is invoked at compile time.
|
||||
*
|
||||
* @deffunc APU_DECLARE_DATA type apr_variable;
|
||||
* @tip extern APU_DECLARE_DATA type apr_variable; syntax is required for
|
||||
* declarations within headers to properly import the variable.
|
||||
*/
|
||||
#define APU_DECLARE_DATA
|
||||
#elif defined(APU_DECLARE_STATIC)
|
||||
#define APU_DECLARE(type) type __stdcall
|
||||
#define APU_DECLARE_NONSTD(type) type __cdecl
|
||||
#define APU_DECLARE_DATA
|
||||
#elif defined(APU_DECLARE_EXPORT)
|
||||
#define APU_DECLARE(type) __declspec(dllexport) type __stdcall
|
||||
#define APU_DECLARE_NONSTD(type) __declspec(dllexport) type __cdecl
|
||||
#define APU_DECLARE_DATA __declspec(dllexport)
|
||||
#else
|
||||
#define APU_DECLARE(type) __declspec(dllimport) type __stdcall
|
||||
#define APU_DECLARE_NONSTD(type) __declspec(dllimport) type __cdecl
|
||||
#define APU_DECLARE_DATA __declspec(dllimport)
|
||||
#endif
|
||||
/** @} */
|
||||
/*
|
||||
* we always have SDBM (it's in our codebase)
|
||||
*/
|
||||
#define APU_HAVE_SDBM 1
|
||||
#define APU_HAVE_GDBM 0
|
||||
|
||||
/* Allow external override */
|
||||
#if !defined(APU_HAVE_DB)
|
||||
#define APU_HAVE_DB 0
|
||||
#endif
|
||||
|
||||
|
||||
#define APU_HAVE_APR_ICONV 1
|
||||
#define APU_HAVE_ICONV 0
|
||||
#define APR_HAS_XLATE (APU_HAVE_APR_ICONV || APU_HAVE_ICONV)
|
||||
|
||||
#if !defined(APU_HAVE_PGSQL)
|
||||
#define APU_HAVE_PGSQL 0
|
||||
#endif
|
||||
#if !defined(APU_HAVE_SQLITE2)
|
||||
#define APU_HAVE_SQLITE2 0
|
||||
#endif
|
||||
#if !defined(APU_HAVE_SQLITE3)
|
||||
#define APU_HAVE_SQLITE3 0
|
||||
#endif
|
||||
|
||||
#endif /* APU_H */
|
||||
#endif /* WIN32 */
|
||||
@@ -0,0 +1,134 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APU_VERSION_H
|
||||
#define APU_VERSION_H
|
||||
|
||||
/**
|
||||
* @file apu_version.h
|
||||
* @brief APR-util Versioning Interface
|
||||
*
|
||||
* APR-util's Version
|
||||
*
|
||||
* There are several different mechanisms for accessing the version. There
|
||||
* is a string form, and a set of numbers; in addition, there are constants
|
||||
* which can be compiled into your application, and you can query the library
|
||||
* being used for its actual version.
|
||||
*
|
||||
* Note that it is possible for an application to detect that it has been
|
||||
* compiled against a different version of APU by use of the compile-time
|
||||
* constants and the use of the run-time query function.
|
||||
*
|
||||
* APU version numbering follows the guidelines specified in:
|
||||
*
|
||||
* http://apr.apache.org/versioning.html
|
||||
*/
|
||||
|
||||
|
||||
/* The numeric compile-time version constants. These constants are the
|
||||
* authoritative version numbers for APU.
|
||||
*/
|
||||
|
||||
/** major version
|
||||
* Major API changes that could cause compatibility problems for older
|
||||
* programs such as structure size changes. No binary compatibility is
|
||||
* possible across a change in the major version.
|
||||
*/
|
||||
#define APU_MAJOR_VERSION 1
|
||||
|
||||
/** minor version
|
||||
* Minor API changes that do not cause binary compatibility problems.
|
||||
* Reset to 0 when upgrading APU_MAJOR_VERSION
|
||||
*/
|
||||
#define APU_MINOR_VERSION 2
|
||||
|
||||
/** patch level
|
||||
* The Patch Level never includes API changes, simply bug fixes.
|
||||
* Reset to 0 when upgrading APR_MINOR_VERSION
|
||||
*/
|
||||
#define APU_PATCH_VERSION 8
|
||||
|
||||
/**
|
||||
* The symbol APU_IS_DEV_VERSION is only defined for internal,
|
||||
* "development" copies of APU. It is undefined for released versions
|
||||
* of APU.
|
||||
*/
|
||||
/* #define APU_IS_DEV_VERSION */
|
||||
|
||||
|
||||
#if defined(APU_IS_DEV_VERSION) || defined(DOXYGEN)
|
||||
/** Internal: string form of the "is dev" flag */
|
||||
#define APU_IS_DEV_STRING "-dev"
|
||||
#else
|
||||
#define APU_IS_DEV_STRING ""
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef APU_STRINGIFY
|
||||
/** Properly quote a value as a string in the C preprocessor */
|
||||
#define APU_STRINGIFY(n) APU_STRINGIFY_HELPER(n)
|
||||
/** Helper macro for APU_STRINGIFY */
|
||||
#define APU_STRINGIFY_HELPER(n) #n
|
||||
#endif
|
||||
|
||||
/** The formatted string of APU's version */
|
||||
#define APU_VERSION_STRING \
|
||||
APU_STRINGIFY(APU_MAJOR_VERSION) "." \
|
||||
APU_STRINGIFY(APU_MINOR_VERSION) "." \
|
||||
APU_STRINGIFY(APU_PATCH_VERSION) \
|
||||
APU_IS_DEV_STRING
|
||||
|
||||
/** An alternative formatted string of APR's version */
|
||||
/* macro for Win32 .rc files using numeric csv representation */
|
||||
#define APU_VERSION_STRING_CSV APU_MAJOR_VERSION ##, \
|
||||
##APU_MINOR_VERSION ##, \
|
||||
##APU_PATCH_VERSION
|
||||
|
||||
|
||||
#ifndef APU_VERSION_ONLY
|
||||
|
||||
/* The C language API to access the version at run time,
|
||||
* as opposed to compile time. APU_VERSION_ONLY may be defined
|
||||
* externally when preprocessing apr_version.h to obtain strictly
|
||||
* the C Preprocessor macro declarations.
|
||||
*/
|
||||
|
||||
#include "apr_version.h"
|
||||
|
||||
#include "apu.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Return APR-util's version information information in a numeric form.
|
||||
*
|
||||
* @param pvsn Pointer to a version structure for returning the version
|
||||
* information.
|
||||
*/
|
||||
APU_DECLARE(void) apu_version(apr_version_t *pvsn);
|
||||
|
||||
/** Return APU's version information as a string. */
|
||||
APU_DECLARE(const char *) apu_version_string(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ndef APU_VERSION_ONLY */
|
||||
|
||||
#endif /* ndef APU_VERSION_H */
|
||||
@@ -0,0 +1,51 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include "apu.h" /* configuration data */
|
||||
|
||||
/**
|
||||
* @file apu_want.h
|
||||
* @brief APR Standard Headers Support
|
||||
*
|
||||
* <PRE>
|
||||
* Features:
|
||||
*
|
||||
* APU_WANT_DB: <@apu_db_header@>
|
||||
*
|
||||
* Typical usage:
|
||||
*
|
||||
* #define APU_WANT_DB
|
||||
* #include "apu_want.h"
|
||||
*
|
||||
* The appropriate headers will be included.
|
||||
*
|
||||
* Note: it is safe to use this in a header (it won't interfere with other
|
||||
* headers' or source files' use of apu_want.h)
|
||||
* </PRE>
|
||||
*/
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
#ifdef APU_WANT_DB
|
||||
|
||||
#if APU_HAVE_DB
|
||||
#include <@apu_db_header@>
|
||||
#endif
|
||||
|
||||
#undef APU_WANT_DB
|
||||
#endif
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include "apu.h" /* configuration data */
|
||||
|
||||
/**
|
||||
* @file apu_want.h
|
||||
* @brief APR Standard Headers Support
|
||||
*
|
||||
* <PRE>
|
||||
* Features:
|
||||
*
|
||||
* APU_WANT_DB: <@apu_db_header>
|
||||
*
|
||||
* Typical usage:
|
||||
*
|
||||
* #define APU_WANT_DB
|
||||
* #include "apu_want.h"
|
||||
*
|
||||
* The appropriate headers will be included.
|
||||
*
|
||||
* Note: it is safe to use this in a header (it won't interfere with other
|
||||
* headers' or source files' use of apu_want.h)
|
||||
* </PRE>
|
||||
*/
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
#ifdef APU_WANT_DB
|
||||
|
||||
#if APU_HAVE_DB
|
||||
/* win32 note.. you will need to change this for db1 */
|
||||
#include <db.h>
|
||||
#endif
|
||||
|
||||
#undef APU_WANT_DB
|
||||
#endif
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
@@ -0,0 +1,52 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include "apu.h" /* configuration data */
|
||||
|
||||
/**
|
||||
* @file apu_want.h
|
||||
* @brief APR Standard Headers Support
|
||||
*
|
||||
* <PRE>
|
||||
* Features:
|
||||
*
|
||||
* APU_WANT_DB: <@apu_db_header>
|
||||
*
|
||||
* Typical usage:
|
||||
*
|
||||
* #define APU_WANT_DB
|
||||
* #include "apu_want.h"
|
||||
*
|
||||
* The appropriate headers will be included.
|
||||
*
|
||||
* Note: it is safe to use this in a header (it won't interfere with other
|
||||
* headers' or source files' use of apu_want.h)
|
||||
* </PRE>
|
||||
*/
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
#ifdef APU_WANT_DB
|
||||
|
||||
#if APU_HAVE_DB
|
||||
/* win32 note.. you will need to change this for db1 */
|
||||
#include <db.h>
|
||||
#endif
|
||||
|
||||
#undef APU_WANT_DB
|
||||
#endif
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
@@ -0,0 +1,257 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/* Overview of what this is and does:
|
||||
* http://www.apache.org/~niq/dbd.html
|
||||
*/
|
||||
|
||||
#ifndef APR_DBD_INTERNAL_H
|
||||
#define APR_DBD_INTERNAL_H
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include "apr_dbd.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct apr_dbd_driver_t {
|
||||
/** name */
|
||||
const char *name;
|
||||
|
||||
/** init: allow driver to perform once-only initialisation.
|
||||
* Called once only. May be NULL
|
||||
*/
|
||||
void (*init)(apr_pool_t *pool);
|
||||
|
||||
/** native_handle: return the native database handle of the underlying db
|
||||
*
|
||||
* @param handle - apr_dbd handle
|
||||
* @return - native handle
|
||||
*/
|
||||
void *(*native_handle)(apr_dbd_t *handle);
|
||||
|
||||
/** open: obtain a database connection from the server rec.
|
||||
* Must be explicitly closed when you're finished with it.
|
||||
* WARNING: only use this when you need a connection with
|
||||
* a lifetime other than a request
|
||||
*
|
||||
* @param pool - a pool to use for error messages (if any).
|
||||
* @param s - server rec managing the underlying connection/pool.
|
||||
* @return database handle, or NULL on error.
|
||||
*/
|
||||
apr_dbd_t *(*open)(apr_pool_t *pool, const char *params);
|
||||
|
||||
/** check_conn: check status of a database connection
|
||||
*
|
||||
* @param pool - a pool to use for error messages (if any).
|
||||
* @param handle - the connection to check
|
||||
* @return APR_SUCCESS or error
|
||||
*/
|
||||
apr_status_t (*check_conn)(apr_pool_t *pool, apr_dbd_t *handle);
|
||||
|
||||
/** close: close/release a connection obtained from open()
|
||||
*
|
||||
* @param handle - the connection to release
|
||||
* @return APR_SUCCESS or error
|
||||
*/
|
||||
apr_status_t (*close)(apr_dbd_t *handle);
|
||||
|
||||
/** set_dbname: select database name. May be a no-op if not supported.
|
||||
*
|
||||
* @param pool - working pool
|
||||
* @param handle - the connection
|
||||
* @param name - the database to select
|
||||
* @return 0 for success or error code
|
||||
*/
|
||||
int (*set_dbname)(apr_pool_t* pool, apr_dbd_t *handle, const char *name);
|
||||
|
||||
/** transaction: start a transaction. May be a no-op.
|
||||
*
|
||||
* @param pool - a pool to use for error messages (if any).
|
||||
* @param handle - the connection
|
||||
* @param transaction - ptr to a transaction. May be null on entry
|
||||
* @return 0 for success or error code
|
||||
*/
|
||||
int (*start_transaction)(apr_pool_t *pool, apr_dbd_t *handle,
|
||||
apr_dbd_transaction_t **trans);
|
||||
|
||||
/** end_transaction: end a transaction
|
||||
* (commit on success, rollback on error).
|
||||
* May be a no-op.
|
||||
*
|
||||
* @param transaction - the transaction.
|
||||
* @return 0 for success or error code
|
||||
*/
|
||||
int (*end_transaction)(apr_dbd_transaction_t *trans);
|
||||
|
||||
/** query: execute an SQL query that doesn't return a result set
|
||||
*
|
||||
* @param handle - the connection
|
||||
* @param nrows - number of rows affected.
|
||||
* @param statement - the SQL statement to execute
|
||||
* @return 0 for success or error code
|
||||
*/
|
||||
int (*query)(apr_dbd_t *handle, int *nrows, const char *statement);
|
||||
|
||||
/** select: execute an SQL query that returns a result set
|
||||
*
|
||||
* @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
|
||||
*/
|
||||
int (*select)(apr_pool_t *pool, apr_dbd_t *handle, apr_dbd_results_t **res,
|
||||
const char *statement, int random);
|
||||
|
||||
/** num_cols: get the number of columns in a results set
|
||||
*
|
||||
* @param res - result set.
|
||||
* @return number of columns
|
||||
*/
|
||||
int (*num_cols)(apr_dbd_results_t *res);
|
||||
|
||||
/** num_tuples: get the number of rows in a results set
|
||||
* of a synchronous select
|
||||
*
|
||||
* @param res - result set.
|
||||
* @return number of rows, or -1 if the results are asynchronous
|
||||
*/
|
||||
int (*num_tuples)(apr_dbd_results_t *res);
|
||||
|
||||
/** get_row: get a row from a result set
|
||||
*
|
||||
* @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, 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
|
||||
*/
|
||||
int (*get_row)(apr_pool_t *pool, apr_dbd_results_t *res,
|
||||
apr_dbd_row_t **row, int rownum);
|
||||
|
||||
/** get_entry: get an entry from a row
|
||||
*
|
||||
* @param row - row pointer
|
||||
* @param col - entry number
|
||||
* @param val - entry to fill
|
||||
* @return 0 for success, -1 for no data, +1 for general error
|
||||
*/
|
||||
const char* (*get_entry)(const apr_dbd_row_t *row, int col);
|
||||
|
||||
/** error: get current error message (if any)
|
||||
*
|
||||
* @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)
|
||||
*/
|
||||
const char *(*error)(apr_dbd_t *handle, int errnum);
|
||||
|
||||
/** escape: escape a string so it is safe for use in query/select
|
||||
*
|
||||
* @param pool - pool to alloc the result from
|
||||
* @param string - the string to escape
|
||||
* @param handle - the connection
|
||||
* @return the escaped, safe string
|
||||
*/
|
||||
const char *(*escape)(apr_pool_t *pool, const char *string,
|
||||
apr_dbd_t *handle);
|
||||
|
||||
/** prepare: prepare a statement
|
||||
*
|
||||
* @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
|
||||
*/
|
||||
int (*prepare)(apr_pool_t *pool, apr_dbd_t *handle, const char *query,
|
||||
const char *label, apr_dbd_prepared_t **statement);
|
||||
|
||||
/** pvquery: query using a prepared statement + args
|
||||
*
|
||||
* @param pool - working pool
|
||||
* @param handle - the connection
|
||||
* @param nrows - number of rows affected.
|
||||
* @param statement - the prepared statement to execute
|
||||
* @param args - args to prepared statement
|
||||
* @return 0 for success or error code
|
||||
*/
|
||||
int (*pvquery)(apr_pool_t *pool, apr_dbd_t *handle, int *nrows,
|
||||
apr_dbd_prepared_t *statement, va_list args);
|
||||
|
||||
/** pvselect: select using a prepared statement + args
|
||||
*
|
||||
* @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 - args to prepared statement
|
||||
* @return 0 for success or error code
|
||||
*/
|
||||
int (*pvselect)(apr_pool_t *pool, apr_dbd_t *handle,
|
||||
apr_dbd_results_t **res,
|
||||
apr_dbd_prepared_t *statement, int random, va_list args);
|
||||
|
||||
/** pquery: query using a prepared statement + args
|
||||
*
|
||||
* @param pool - working pool
|
||||
* @param handle - the connection
|
||||
* @param nrows - number of rows affected.
|
||||
* @param statement - the prepared statement to execute
|
||||
* @param nargs - number of args to prepared statement
|
||||
* @param args - args to prepared statement
|
||||
* @return 0 for success or error code
|
||||
*/
|
||||
int (*pquery)(apr_pool_t *pool, apr_dbd_t *handle, int *nrows,
|
||||
apr_dbd_prepared_t *statement, int nargs,
|
||||
const char **args);
|
||||
|
||||
/** pselect: select using a prepared statement + args
|
||||
*
|
||||
* @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 - number of args to prepared statement
|
||||
* @param args - args to prepared statement
|
||||
* @return 0 for success or error code
|
||||
*/
|
||||
int (*pselect)(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);
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,125 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APR_DBM_PRIVATE_H
|
||||
#define APR_DBM_PRIVATE_H
|
||||
|
||||
#include "apr.h"
|
||||
#include "apr_errno.h"
|
||||
#include "apr_pools.h"
|
||||
#include "apr_dbm.h"
|
||||
#include "apr_file_io.h"
|
||||
|
||||
#include "apu.h"
|
||||
|
||||
/* ### for now, include the DBM selection; this will go away once we start
|
||||
### building and linking all of the DBMs at once. */
|
||||
#include "apu_select_dbm.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** @internal */
|
||||
|
||||
/**
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* Structure to describe the operations of the DBM
|
||||
*/
|
||||
typedef struct {
|
||||
/** The name of the DBM Type */
|
||||
const char *name;
|
||||
|
||||
/** Open the DBM */
|
||||
apr_status_t (*open)(apr_dbm_t **pdb, const char *pathname,
|
||||
apr_int32_t mode, apr_fileperms_t perm,
|
||||
apr_pool_t *pool);
|
||||
|
||||
/** Close the DBM */
|
||||
void (*close)(apr_dbm_t *dbm);
|
||||
|
||||
/** Fetch a dbm record value by key */
|
||||
apr_status_t (*fetch)(apr_dbm_t *dbm, apr_datum_t key,
|
||||
apr_datum_t * pvalue);
|
||||
|
||||
/** Store a dbm record value by key */
|
||||
apr_status_t (*store)(apr_dbm_t *dbm, apr_datum_t key, apr_datum_t value);
|
||||
|
||||
/** Delete a dbm record value by key */
|
||||
apr_status_t (*del)(apr_dbm_t *dbm, apr_datum_t key);
|
||||
|
||||
/** Search for a key within the dbm */
|
||||
int (*exists)(apr_dbm_t *dbm, apr_datum_t key);
|
||||
|
||||
/** Retrieve the first record key from a dbm */
|
||||
apr_status_t (*firstkey)(apr_dbm_t *dbm, apr_datum_t * pkey);
|
||||
|
||||
/** Retrieve the next record key from a dbm */
|
||||
apr_status_t (*nextkey)(apr_dbm_t *dbm, apr_datum_t * pkey);
|
||||
|
||||
/** Proactively toss any memory associated with the apr_datum_t. */
|
||||
void (*freedatum)(apr_dbm_t *dbm, apr_datum_t data);
|
||||
|
||||
/** Get the names that the DBM will use for a given pathname. */
|
||||
void (*getusednames)(apr_pool_t *pool,
|
||||
const char *pathname,
|
||||
const char **used1,
|
||||
const char **used2);
|
||||
|
||||
} apr_dbm_type_t;
|
||||
|
||||
|
||||
/**
|
||||
* The actual DBM
|
||||
*/
|
||||
struct apr_dbm_t
|
||||
{
|
||||
/** Associated pool */
|
||||
apr_pool_t *pool;
|
||||
|
||||
/** pointer to DB Implementation Specific data */
|
||||
void *file;
|
||||
|
||||
/** Current integer error code */
|
||||
int errcode;
|
||||
/** Current string error code */
|
||||
const char *errmsg;
|
||||
|
||||
/** the type of DBM */
|
||||
const apr_dbm_type_t *type;
|
||||
};
|
||||
|
||||
|
||||
/* Declare all of the builtin DBM providers */
|
||||
APU_DECLARE_DATA extern const apr_dbm_type_t apr_dbm_type_sdbm;
|
||||
APU_DECLARE_DATA extern const apr_dbm_type_t apr_dbm_type_gdbm;
|
||||
APU_DECLARE_DATA extern const apr_dbm_type_t apr_dbm_type_ndbm;
|
||||
APU_DECLARE_DATA extern const apr_dbm_type_t apr_dbm_type_db1;
|
||||
APU_DECLARE_DATA extern const apr_dbm_type_t apr_dbm_type_db2;
|
||||
APU_DECLARE_DATA extern const apr_dbm_type_t apr_dbm_type_db3;
|
||||
APU_DECLARE_DATA extern const apr_dbm_type_t apr_dbm_type_db4;
|
||||
APU_DECLARE_DATA extern const apr_dbm_type_t apr_dbm_type_db;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* APR_DBM_PRIVATE_H */
|
||||
@@ -0,0 +1,109 @@
|
||||
/* include/private/apu_config.h.in. Generated from configure.in by autoheader. */
|
||||
|
||||
/* define if Expat 1.0 or 1.1 was found */
|
||||
#undef APR_HAVE_OLD_EXPAT
|
||||
|
||||
/* Define if the system crypt() function is threadsafe */
|
||||
#undef APU_CRYPT_THREADSAFE
|
||||
|
||||
/* Define if the inbuf parm to iconv() is const char ** */
|
||||
#undef APU_ICONV_INBUF_CONST
|
||||
|
||||
/* Define if crypt_r has uses CRYPTD */
|
||||
#undef CRYPT_R_CRYPTD
|
||||
|
||||
/* Define if crypt_r uses struct crypt_data */
|
||||
#undef CRYPT_R_STRUCT_CRYPT_DATA
|
||||
|
||||
/* Define if CODESET is defined in langinfo.h */
|
||||
#undef HAVE_CODESET
|
||||
|
||||
/* Define to 1 if you have the `crypt_r' function. */
|
||||
#undef HAVE_CRYPT_R
|
||||
|
||||
/* Define to 1 if you have the file `AC_File'. */
|
||||
#undef HAVE_DBD_APR_DBD_MYSQL_C
|
||||
|
||||
/* Define to 1 if you have the <iconv.h> header file. */
|
||||
#undef HAVE_ICONV_H
|
||||
|
||||
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||
#undef HAVE_INTTYPES_H
|
||||
|
||||
/* Define to 1 if you have the <langinfo.h> header file. */
|
||||
#undef HAVE_LANGINFO_H
|
||||
|
||||
/* Define to 1 if you have the <lber.h> header file. */
|
||||
#undef HAVE_LBER_H
|
||||
|
||||
/* Defined if ldap.h is present */
|
||||
#undef HAVE_LDAP_H
|
||||
|
||||
/* Define to 1 if you have the <ldap_ssl.h> header file. */
|
||||
#undef HAVE_LDAP_SSL_H
|
||||
|
||||
/* Define to 1 if you have the `lber' library (-llber). */
|
||||
#undef HAVE_LIBLBER
|
||||
|
||||
/* Define to 1 if you have the <libpq-fe.h> header file. */
|
||||
#undef HAVE_LIBPQ_FE_H
|
||||
|
||||
/* Define to 1 if you have the <memory.h> header file. */
|
||||
#undef HAVE_MEMORY_H
|
||||
|
||||
/* Define to 1 if you have the <mysql.h> header file. */
|
||||
#undef HAVE_MYSQL_H
|
||||
|
||||
/* Define to 1 if you have the <mysql/mysql.h> header file. */
|
||||
#undef HAVE_MYSQL_MYSQL_H
|
||||
|
||||
/* Define to 1 if you have the `nl_langinfo' function. */
|
||||
#undef HAVE_NL_LANGINFO
|
||||
|
||||
/* Define to 1 if you have the <postgresql/libpq-fe.h> header file. */
|
||||
#undef HAVE_POSTGRESQL_LIBPQ_FE_H
|
||||
|
||||
/* Define to 1 if you have the <sqlite3.h> header file. */
|
||||
#undef HAVE_SQLITE3_H
|
||||
|
||||
/* Define to 1 if you have the <sqlite.h> header file. */
|
||||
#undef HAVE_SQLITE_H
|
||||
|
||||
/* Define to 1 if you have the <stdint.h> header file. */
|
||||
#undef HAVE_STDINT_H
|
||||
|
||||
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||
#undef HAVE_STDLIB_H
|
||||
|
||||
/* Define to 1 if you have the <strings.h> header file. */
|
||||
#undef HAVE_STRINGS_H
|
||||
|
||||
/* Define to 1 if you have the <string.h> header file. */
|
||||
#undef HAVE_STRING_H
|
||||
|
||||
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||
#undef HAVE_SYS_STAT_H
|
||||
|
||||
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||
#undef HAVE_SYS_TYPES_H
|
||||
|
||||
/* Define to 1 if you have the <unistd.h> header file. */
|
||||
#undef HAVE_UNISTD_H
|
||||
|
||||
/* Define to the address where bug reports for this package should be sent. */
|
||||
#undef PACKAGE_BUGREPORT
|
||||
|
||||
/* Define to the full name of this package. */
|
||||
#undef PACKAGE_NAME
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#undef PACKAGE_STRING
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#undef PACKAGE_TARNAME
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#undef PACKAGE_VERSION
|
||||
|
||||
/* Define to 1 if you have the ANSI C header files. */
|
||||
#undef STDC_HEADERS
|
||||
@@ -0,0 +1,39 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Note: This is a Windows specific version of apu_config.hw. It is copied
|
||||
* as apu_config.h at the start of a Windows build.
|
||||
*/
|
||||
|
||||
#ifdef WIN32
|
||||
|
||||
#ifndef APU_CONFIG_H
|
||||
#define APU_CONFIG_H
|
||||
|
||||
/*
|
||||
* Windows does not have GDBM, and we always use the bundled (new) Expat
|
||||
*/
|
||||
|
||||
/* Define if you have the gdbm library (-lgdbm). */
|
||||
/* #undef HAVE_LIBGDBM */
|
||||
|
||||
/* define if Expat 1.0 or 1.1 was found */
|
||||
/* #undef APR_HAVE_OLD_EXPAT */
|
||||
|
||||
|
||||
#endif /* APU_CONFIG_H */
|
||||
#endif /* WIN32 */
|
||||
@@ -0,0 +1,28 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APU_SELECT_DBM_H
|
||||
#define APU_SELECT_DBM_H
|
||||
|
||||
/*
|
||||
** The following macros control what features APRUTIL will use
|
||||
*/
|
||||
#define APU_USE_SDBM @apu_use_sdbm@
|
||||
#define APU_USE_NDBM @apu_use_ndbm@
|
||||
#define APU_USE_GDBM @apu_use_gdbm@
|
||||
#define APU_USE_DB @apu_use_db@
|
||||
|
||||
#endif /* !APU_SELECT_DBM_H */
|
||||
@@ -0,0 +1,32 @@
|
||||
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
||||
* applicable.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef APU_SELECT_DBM_H
|
||||
#define APU_SELECT_DBM_H
|
||||
|
||||
/*
|
||||
** The following macros control what features APRUTIL will use
|
||||
*/
|
||||
#define APU_USE_SDBM 1
|
||||
#define APU_USE_GDBM 0
|
||||
#define APU_USE_NDBM 0
|
||||
#define APU_USE_DB 0
|
||||
|
||||
#if APU_USE_DB
|
||||
#include <db.h>
|
||||
#endif
|
||||
|
||||
#endif /* !APU_SELECT_DBM_H */
|
||||
Reference in new issue
Block a user