[GME-commit] GMESRC/GME/Include/apr apr.h, NONE, 1.1 apr.h.in, NONE, 1.1 apr.hnw, NONE, 1.1 apr.hw, NONE, 1.1 apr_allocator.h, NONE, 1.1 apr_atomic.h, NONE, 1.1 apr_compat.h, NONE, 1.1 apr_dso.h, NONE, 1.1 apr_env.h, NONE, 1.1 apr_errno.h, NONE, 1.1 apr_file_info.h, NONE, 1.1 apr_file_io.h, NONE, 1.1 apr_fnmatch.h, NONE, 1.1 apr_general.h, NONE, 1.1 apr_getopt.h, NONE, 1.1 apr_global_mutex.h, NONE, 1.1 apr_hash.h, NONE, 1.1 apr_inherit.h, NONE, 1.1 apr_lib.h, NONE, 1.1 apr_mmap.h, NONE, 1.1 apr_network_io.h, NONE, 1.1 apr_poll.h, NONE, 1.1 apr_pools.h, NONE, 1.1 apr_portable.h, NONE, 1.1 apr_proc_mutex.h, NONE, 1.1 apr_ring.h, NONE, 1.1 apr_shm.h, NONE, 1.1 apr_signal.h, NONE, 1.1 apr_strings.h, NONE, 1.1 apr_support.h, NONE, 1.1 apr_tables.h, NONE, 1.1 apr_thread_cond.h, NONE, 1.1 apr_thread_mutex.h, NONE, 1.1 apr_thread_proc.h, NONE, 1.1 apr_thread_rwlock.h, NONE, 1.1 apr_time.h, NONE, 1.1 apr_user.h, NONE, 1.1 apr_version.h, NONE, 1.1 apr_want.h, NONE, 1.1
Log messages of CVS commits
gme-commit at list.isis.vanderbilt.edu
Wed Feb 13 12:39:00 CST 2008
Update of /project/gme-repository/GMESRC/GME/Include/apr
In directory escher:/tmp/cvs-serv6993
Added Files:
apr.h apr.h.in apr.hnw apr.hw apr_allocator.h apr_atomic.h
apr_compat.h apr_dso.h apr_env.h apr_errno.h apr_file_info.h
apr_file_io.h apr_fnmatch.h apr_general.h apr_getopt.h
apr_global_mutex.h apr_hash.h apr_inherit.h apr_lib.h
apr_mmap.h apr_network_io.h apr_poll.h apr_pools.h
apr_portable.h apr_proc_mutex.h apr_ring.h apr_shm.h
apr_signal.h apr_strings.h apr_support.h apr_tables.h
apr_thread_cond.h apr_thread_mutex.h apr_thread_proc.h
apr_thread_rwlock.h apr_time.h apr_user.h apr_version.h
apr_want.h
Log Message:
Apr-Apache Portable Runtime include files.
CVS User: Zoltan Molnar, ISIS (zolmol)
--- NEW FILE: apr_support.h ---
/* 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_SUPPORT_H
#define APR_SUPPORT_H
/**
* @file apr_support.h
* @brief APR Support functions
*/
#include "apr.h"
#include "apr_network_io.h"
#include "apr_file_io.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_support Internal APR support functions
* @ingroup APR
* @{
*/
/**
* Wait for IO to occur or timeout.
*/
apr_status_t apr_wait_for_io_or_timeout(apr_file_t *f, apr_socket_t *s,
int for_read);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_SUPPORT_H */
--- NEW FILE: apr_general.h ---
/* 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_GENERAL_H
#define APR_GENERAL_H
/**
* @file apr_general.h
* This is collection of oddballs that didn't fit anywhere else,
* and might move to more appropriate headers with the release
* of APR 1.0.
* @brief APR Miscellaneous library routines
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#if APR_HAVE_SIGNAL_H
#include <signal.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_general Miscellaneous library routines
* @ingroup APR
* This is collection of oddballs that didn't fit anywhere else,
* and might move to more appropriate headers with the release
* of APR 1.0.
* @{
*/
/** FALSE */
#ifndef FALSE
#define FALSE 0
#endif
/** TRUE */
#ifndef TRUE
#define TRUE (!FALSE)
#endif
/** a space */
#define APR_ASCII_BLANK '\040'
/** a carrige return */
#define APR_ASCII_CR '\015'
/** a line feed */
#define APR_ASCII_LF '\012'
/** a tab */
#define APR_ASCII_TAB '\011'
/** signal numbers typedef */
typedef int apr_signum_t;
/**
* Finding offsets of elements within structures.
* Taken from the X code... they've sweated portability of this stuff
* so we don't have to. Sigh...
* @param p_type pointer type name
* @param field data field within the structure pointed to
* @return offset
*/
#if defined(CRAY) || (defined(__arm) && !defined(LINUX))
#ifdef __STDC__
#define APR_OFFSET(p_type,field) _Offsetof(p_type,field)
#else
#ifdef CRAY2
#define APR_OFFSET(p_type,field) \
(sizeof(int)*((unsigned int)&(((p_type)NULL)->field)))
#else /* !CRAY2 */
#define APR_OFFSET(p_type,field) ((unsigned int)&(((p_type)NULL)->field))
#endif /* !CRAY2 */
#endif /* __STDC__ */
#else /* ! (CRAY || __arm) */
#define APR_OFFSET(p_type,field) \
((long) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL)))
#endif /* !CRAY */
/**
* Finding offsets of elements within structures.
* @param s_type structure type name
* @param field data field within the structure
* @return offset
*/
#if defined(offsetof) && !defined(__cplusplus)
#define APR_OFFSETOF(s_type,field) offsetof(s_type,field)
#else
#define APR_OFFSETOF(s_type,field) APR_OFFSET(s_type*,field)
#endif
/** @deprecated @see APR_OFFSET */
#define APR_XtOffset APR_OFFSET
/** @deprecated @see APR_OFFSETOF */
#define APR_XtOffsetOf APR_OFFSETOF
#ifndef DOXYGEN
/* A couple of prototypes for functions in case some platform doesn't
* have it
*/
#if (!APR_HAVE_STRCASECMP) && (APR_HAVE_STRICMP)
#define strcasecmp(s1, s2) stricmp(s1, s2)
#elif (!APR_HAVE_STRCASECMP)
int strcasecmp(const char *a, const char *b);
#endif
#if (!APR_HAVE_STRNCASECMP) && (APR_HAVE_STRNICMP)
#define strncasecmp(s1, s2, n) strnicmp(s1, s2, n)
#elif (!APR_HAVE_STRNCASECMP)
int strncasecmp(const char *a, const char *b, size_t n);
#endif
#endif
/**
* Alignment macros
*/
/* APR_ALIGN() is only to be used to align on a power of 2 boundary */
#define APR_ALIGN(size, boundary) \
(((size) + ((boundary) - 1)) & ~((boundary) - 1))
/** Default alignment */
#define APR_ALIGN_DEFAULT(size) APR_ALIGN(size, 8)
/**
* String and memory functions
*/
/** Properly quote a value as a string in the C preprocessor */
#define APR_STRINGIFY(n) APR_STRINGIFY_HELPER(n)
/** Helper macro for APR_STRINGIFY */
#define APR_STRINGIFY_HELPER(n) #n
#if (!APR_HAVE_MEMMOVE)
#define memmove(a,b,c) bcopy(b,a,c)
#endif
#if (!APR_HAVE_MEMCHR)
void *memchr(const void *s, int c, size_t n);
#endif
/** @} */
/**
* @defgroup apr_library Library initialization and termination
* @{
*/
/**
* Setup any APR internal data structures. This MUST be the first function
* called for any APR library.
* @remark See apr_app_initialize if this is an application, rather than
* a library consumer of apr.
*/
APR_DECLARE(apr_status_t) apr_initialize(void);
/**
* Set up an application with normalized argc, argv (and optionally env) in
* order to deal with platform-specific oddities, such as Win32 services,
* code pages and signals. This must be the first function called for any
* APR program.
* @param argc Pointer to the argc that may be corrected
* @param argv Pointer to the argv that may be corrected
* @param env Pointer to the env that may be corrected, may be NULL
* @remark See apr_initialize if this is a library consumer of apr.
* Otherwise, this call is identical to apr_initialize, and must be closed
* with a call to apr_terminate at the end of program execution.
*/
APR_DECLARE(apr_status_t) apr_app_initialize(int *argc,
char const * const * *argv,
char const * const * *env);
/**
* Tear down any APR internal data structures which aren't torn down
* automatically.
* @remark An APR program must call this function at termination once it
* has stopped using APR services. The APR developers suggest using
* atexit to ensure this is called. When using APR from a language
* other than C that has problems with the calling convention, use
* apr_terminate2() instead.
*/
APR_DECLARE_NONSTD(void) apr_terminate(void);
/**
* Tear down any APR internal data structures which aren't torn down
* automatically, same as apr_terminate
* @remark An APR program must call either the apr_terminate or apr_terminate2
* function once it it has finished using APR services. The APR
* developers suggest using atexit(apr_terminate) to ensure this is done.
* apr_terminate2 exists to allow non-c language apps to tear down apr,
* while apr_terminate is recommended from c language applications.
*/
APR_DECLARE(void) apr_terminate2(void);
/** @} */
/**
* @defgroup apr_random Random Functions
* @{
*/
#if APR_HAS_RANDOM || defined(DOXYGEN)
/* TODO: I'm not sure this is the best place to put this prototype...*/
/**
* Generate random bytes.
* @param buf Buffer to fill with random bytes
* @param length Length of buffer in bytes (becomes apr_size_t in APR 1.0)
*/
#ifdef APR_ENABLE_FOR_1_0
APR_DECLARE(apr_status_t) apr_generate_random_bytes(unsigned char * buf,
apr_size_t length);
#else
APR_DECLARE(apr_status_t) apr_generate_random_bytes(unsigned char * buf,
int length);
#endif
#endif
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_GENERAL_H */
--- NEW FILE: apr_network_io.h ---
/* 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_NETWORK_IO_H
#define APR_NETWORK_IO_H
/**
* @file apr_network_io.h
* @brief APR Network library
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_file_io.h"
#include "apr_errno.h"
#include "apr_inherit.h"
#if APR_HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_network_io Network Routines
* @ingroup APR
* @{
*/
#ifndef APR_MAX_SECS_TO_LINGER
/** Maximum seconds to linger */
#define APR_MAX_SECS_TO_LINGER 30
#endif
#ifndef MAX_SECS_TO_LINGER
/** @deprecated @see APR_MAX_SECS_TO_LINGER */
#define MAX_SECS_TO_LINGER APR_MAX_SECS_TO_LINGER
#endif
#ifndef APRMAXHOSTLEN
/** Maximum hostname length */
#define APRMAXHOSTLEN 256
#endif
#ifndef APR_ANYADDR
/** Default 'any' address */
#define APR_ANYADDR "0.0.0.0"
#endif
/**
* @defgroup apr_sockopt Socket option definitions
* @{
*/
#define APR_SO_LINGER 1 /**< Linger */
#define APR_SO_KEEPALIVE 2 /**< Keepalive */
#define APR_SO_DEBUG 4 /**< Debug */
#define APR_SO_NONBLOCK 8 /**< Non-blocking IO */
#define APR_SO_REUSEADDR 16 /**< Reuse addresses */
#define APR_SO_TIMEOUT 32 /**< Timeout */
#define APR_SO_SNDBUF 64 /**< Send buffer */
#define APR_SO_RCVBUF 128 /**< Receive buffer */
#define APR_SO_DISCONNECTED 256 /**< Disconnected */
#define APR_TCP_NODELAY 512 /**< For SCTP sockets, this is mapped
* to STCP_NODELAY internally.
*/
#define APR_TCP_NOPUSH 1024 /**< No push */
#define APR_RESET_NODELAY 2048 /**< This flag is ONLY set internally
* when we set APR_TCP_NOPUSH with
* APR_TCP_NODELAY set to tell us that
* APR_TCP_NODELAY should be turned on
* again when NOPUSH is turned off
*/
#define APR_INCOMPLETE_READ 4096 /**< Set on non-blocking sockets
* (timeout != 0) on which the
* previous read() did not fill a buffer
* completely. the next apr_socket_recv()
* will first call select()/poll() rather than
* going straight into read(). (Can also
* be set by an application to force a
* select()/poll() call before the next
* read, in cases where the app expects
* that an immediate read would fail.)
*/
#define APR_INCOMPLETE_WRITE 8192 /**< like APR_INCOMPLETE_READ, but for write
* @see APR_INCOMPLETE_READ
*/
#define APR_IPV6_V6ONLY 16384 /**< Don't accept IPv4 connections on an
* IPv6 listening socket.
*/
/** @} */
/** Define what type of socket shutdown should occur. */
typedef enum {
APR_SHUTDOWN_READ, /**< no longer allow read request */
APR_SHUTDOWN_WRITE, /**< no longer allow write requests */
APR_SHUTDOWN_READWRITE /**< no longer allow read or write requests */
} apr_shutdown_how_e;
#define APR_IPV4_ADDR_OK 0x01 /**< @see apr_sockaddr_info_get() */
#define APR_IPV6_ADDR_OK 0x02 /**< @see apr_sockaddr_info_get() */
#if (!APR_HAVE_IN_ADDR)
/**
* We need to make sure we always have an in_addr type, so APR will just
* define it ourselves, if the platform doesn't provide it.
*/
struct in_addr {
apr_uint32_t s_addr; /**< storage to hold the IP# */
};
#endif
/**
* @def APR_INET
* Not all platforms have these defined, so we'll define them here
* The default values come from FreeBSD 4.1.1
*/
#define APR_INET AF_INET
/** @def APR_UNSPEC
* Let the system decide which address family to use
*/
#ifdef AF_UNSPEC
#define APR_UNSPEC AF_UNSPEC
#else
#define APR_UNSPEC 0
#endif
#if APR_HAVE_IPV6
#define APR_INET6 AF_INET6
#endif
/**
* @defgroup IP_Proto IP Protocol Definitions for use when creating sockets
* @{
*/
#define APR_PROTO_TCP 6 /**< TCP */
#define APR_PROTO_UDP 17 /**< UDP */
#define APR_PROTO_SCTP 132 /**< SCTP */
/** @} */
/**
* Enum to tell us if we're interested in remote or local socket
*/
typedef enum {
APR_LOCAL,
APR_REMOTE
} apr_interface_e;
/**
* The specific declaration of inet_addr's ... some platforms fall back
* inet_network (this is not good, but necessary)
*/
#if APR_HAVE_INET_ADDR
#define apr_inet_addr inet_addr
#elif APR_HAVE_INET_NETWORK /* only DGUX, as far as I know */
/**
* @warning
* not generally safe... inet_network() and inet_addr() perform
* different functions */
#define apr_inet_addr inet_network
#endif
/** A structure to represent sockets */
typedef struct apr_socket_t apr_socket_t;
/**
* A structure to encapsulate headers and trailers for apr_socket_sendfile
*/
typedef struct apr_hdtr_t apr_hdtr_t;
/** A structure to represent in_addr */
typedef struct in_addr apr_in_addr_t;
/** A structure to represent an IP subnet */
typedef struct apr_ipsubnet_t apr_ipsubnet_t;
/** @remark use apr_uint16_t just in case some system has a short that isn't 16 bits... */
typedef apr_uint16_t apr_port_t;
/** @remark It's defined here as I think it should all be platform safe...
* @see apr_sockaddr_t
*/
typedef struct apr_sockaddr_t apr_sockaddr_t;
/**
* APRs socket address type, used to ensure protocol independence
*/
struct apr_sockaddr_t {
/** The pool to use... */
apr_pool_t *pool;
/** The hostname */
char *hostname;
/** Either a string of the port number or the service name for the port */
char *servname;
/** The numeric port */
apr_port_t port;
/** The family */
apr_int32_t family;
/** Union of either IPv4 or IPv6 sockaddr. */
union {
/** IPv4 sockaddr structure */
struct sockaddr_in sin;
#if APR_HAVE_IPV6
/** IPv6 sockaddr structure */
struct sockaddr_in6 sin6;
#endif
} sa;
/** How big is the sockaddr we're using? */
apr_socklen_t salen;
/** How big is the ip address structure we're using? */
int ipaddr_len;
/** How big should the address buffer be? 16 for v4 or 46 for v6
* used in inet_ntop... */
int addr_str_len;
/** This points to the IP address structure within the appropriate
* sockaddr structure. */
void *ipaddr_ptr;
/** If multiple addresses were found by apr_sockaddr_info_get(), this
* points to a representation of the next address. */
apr_sockaddr_t *next;
};
#if APR_HAS_SENDFILE
/**
* Support reusing the socket on platforms which support it (from disconnect,
* specifically Win32.
* @remark Optional flag passed into apr_socket_sendfile()
*/
#define APR_SENDFILE_DISCONNECT_SOCKET 1
#endif
/** A structure to encapsulate headers and trailers for apr_socket_sendfile */
struct apr_hdtr_t {
/** An iovec to store the headers sent before the file. */
struct iovec* headers;
/** number of headers in the iovec */
int numheaders;
/** An iovec to store the trailers sent after the file. */
struct iovec* trailers;
/** number of trailers in the iovec */
int numtrailers;
};
/* function definitions */
/**
* Create a socket.
* @remark With APR 1.0, this function follows the prototype
* of apr_socket_create_ex.
* @param new_sock The new socket that has been set up.
* @param family The address family of the socket (e.g., APR_INET).
* @param type The type of the socket (e.g., SOCK_STREAM).
* @param cont The pool to use
*/
APR_DECLARE(apr_status_t) apr_socket_create(apr_socket_t **new_sock,
int family, int type,
apr_pool_t *cont);
/**
* Create a socket.
* @remark With APR 1.0, this function is deprecated and apr_socket_create
* follows this prototype.
* @param new_sock The new socket that has been set up.
* @param family The address family of the socket (e.g., APR_INET).
* @param type The type of the socket (e.g., SOCK_STREAM).
* @param protocol The protocol of the socket (e.g., APR_PROTO_TCP).
* @param cont The pool to use
*/
APR_DECLARE(apr_status_t) apr_socket_create_ex(apr_socket_t **new_sock,
int family, int type,
int protocol,
apr_pool_t *cont);
/**
* Shutdown either reading, writing, or both sides of a socket.
* @param thesocket The socket to close
* @param how How to shutdown the socket. One of:
* <PRE>
* APR_SHUTDOWN_READ no longer allow read requests
* APR_SHUTDOWN_WRITE no longer allow write requests
* APR_SHUTDOWN_READWRITE no longer allow read or write requests
* </PRE>
* @see apr_shutdown_how_e
* @remark This does not actually close the socket descriptor, it just
* controls which calls are still valid on the socket.
*/
APR_DECLARE(apr_status_t) apr_socket_shutdown(apr_socket_t *thesocket,
apr_shutdown_how_e how);
/** @deprecated @see apr_socket_shutdown */
APR_DECLARE(apr_status_t) apr_shutdown(apr_socket_t *thesocket,
apr_shutdown_how_e how);
/**
* Close a socket.
* @param thesocket The socket to close
*/
APR_DECLARE(apr_status_t) apr_socket_close(apr_socket_t *thesocket);
/**
* Bind the socket to its associated port
* @param sock The socket to bind
* @param sa The socket address to bind to
* @remark This may be where we will find out if there is any other process
* using the selected port.
*/
APR_DECLARE(apr_status_t) apr_socket_bind(apr_socket_t *sock,
apr_sockaddr_t *sa);
/** @deprecated @see apr_socket_bind */
APR_DECLARE(apr_status_t) apr_bind(apr_socket_t *sock, apr_sockaddr_t *sa);
/**
* Listen to a bound socket for connections.
* @param sock The socket to listen on
* @param backlog The number of outstanding connections allowed in the sockets
* listen queue. If this value is less than zero, the listen
* queue size is set to zero.
*/
APR_DECLARE(apr_status_t) apr_socket_listen(apr_socket_t *sock,
apr_int32_t backlog);
/** @deprecated @see apr_socket_listen */
APR_DECLARE(apr_status_t) apr_listen(apr_socket_t *sock, apr_int32_t backlog);
/**
* Accept a new connection request
* @param new_sock A copy of the socket that is connected to the socket that
* made the connection request. This is the socket which should
* be used for all future communication.
* @param sock The socket we are listening on.
* @param connection_pool The pool for the new socket.
*/
APR_DECLARE(apr_status_t) apr_socket_accept(apr_socket_t **new_sock,
apr_socket_t *sock,
apr_pool_t *connection_pool);
/** @deprecated @see apr_socket_accept */
APR_DECLARE(apr_status_t) apr_accept(apr_socket_t **new_sock,
apr_socket_t *sock,
apr_pool_t *connection_pool);
/**
* Issue a connection request to a socket either on the same machine
* or a different one.
* @param sock The socket we wish to use for our side of the connection
* @param sa The address of the machine we wish to connect to. If NULL,
* APR assumes that the sockaddr_in in the apr_socket is
* completely filled out.
*/
APR_DECLARE(apr_status_t) apr_socket_connect(apr_socket_t *sock,
apr_sockaddr_t *sa);
/** @deprecated @see apr_socket_connect */
APR_DECLARE(apr_status_t) apr_connect(apr_socket_t *sock, apr_sockaddr_t *sa);
/**
* Create apr_sockaddr_t from hostname, address family, and port.
* @param sa The new apr_sockaddr_t.
* @param hostname The hostname or numeric address string to resolve/parse, or
* NULL to build an address that corresponds to 0.0.0.0 or ::
* @param family The address family to use, or APR_UNSPEC if the system should
* decide.
* @param port The port number.
* @param flags Special processing flags:
* <PRE>
* APR_IPV4_ADDR_OK first query for IPv4 addresses; only look
* for IPv6 addresses if the first query failed;
* only valid if family is APR_UNSPEC and hostname
* isn't NULL; mutually exclusive with
* APR_IPV6_ADDR_OK
* APR_IPV6_ADDR_OK first query for IPv6 addresses; only look
* for IPv4 addresses if the first query failed;
* only valid if family is APR_UNSPEC and hostname
* isn't NULL and APR_HAVE_IPV6; mutually exclusive
* with APR_IPV4_ADDR_OK
* </PRE>
* @param p The pool for the apr_sockaddr_t and associated storage.
*/
APR_DECLARE(apr_status_t) apr_sockaddr_info_get(apr_sockaddr_t **sa,
const char *hostname,
apr_int32_t family,
apr_port_t port,
apr_int32_t flags,
apr_pool_t *p);
/**
* Look up the host name from an apr_sockaddr_t.
* @param hostname The hostname.
* @param sa The apr_sockaddr_t.
* @param flags Special processing flags.
*/
APR_DECLARE(apr_status_t) apr_getnameinfo(char **hostname,
apr_sockaddr_t *sa,
apr_int32_t flags);
/**
* Parse hostname/IP address with scope id and port.
*
* Any of the following strings are accepted:
* 8080 (just the port number)
* www.apache.org (just the hostname)
* www.apache.org:8080 (hostname and port number)
* [fe80::1]:80 (IPv6 numeric address string only)
* [fe80::1%eth0] (IPv6 numeric address string and scope id)
*
* Invalid strings:
* (empty string)
* [abc] (not valid IPv6 numeric address string)
* abc:65536 (invalid port number)
*
* @param addr The new buffer containing just the hostname. On output, *addr
* will be NULL if no hostname/IP address was specfied.
* @param scope_id The new buffer containing just the scope id. On output,
* *scope_id will be NULL if no scope id was specified.
* @param port The port number. On output, *port will be 0 if no port was
* specified.
* ### FIXME: 0 is a legal port (per RFC 1700). this should
* ### return something besides zero if the port is missing.
* @param str The input string to be parsed.
* @param p The pool from which *addr and *scope_id are allocated.
* @remark If scope id shouldn't be allowed, check for scope_id != NULL in
* addition to checking the return code. If addr/hostname should be
* required, check for addr == NULL in addition to checking the
* return code.
*/
APR_DECLARE(apr_status_t) apr_parse_addr_port(char **addr,
char **scope_id,
apr_port_t *port,
const char *str,
apr_pool_t *p);
/**
* Get name of the current machine
* @param buf A buffer to store the hostname in.
* @param len The maximum length of the hostname that can be stored in the
* buffer provided. The suggested length is APRMAXHOSTLEN + 1.
* @param cont The pool to use.
* @remark If the buffer was not large enough, an error will be returned.
*/
APR_DECLARE(apr_status_t) apr_gethostname(char *buf, int len, apr_pool_t *cont);
/**
* Return the data associated with the current socket
* @param data The user data associated with the socket.
* @param key The key to associate with the user data.
* @param sock The currently open socket.
*/
APR_DECLARE(apr_status_t) apr_socket_data_get(void **data, const char *key,
apr_socket_t *sock);
/**
* Set the data associated with the current socket.
* @param sock The currently open socket.
* @param data The user data to associate with the socket.
* @param key The key to associate with the data.
* @param cleanup The cleanup to call when the socket is destroyed.
*/
APR_DECLARE(apr_status_t) apr_socket_data_set(apr_socket_t *sock, void *data,
const char *key,
apr_status_t (*cleanup)(void*));
/**
* Send data over a network.
* @param sock The socket to send the data over.
* @param buf The buffer which contains the data to be sent.
* @param len On entry, the number of bytes to send; on exit, the number
* of bytes sent.
* @remark
* <PRE>
* This functions acts like a blocking write by default. To change
* this behavior, use apr_socket_timeout_set().
*
* It is possible for both bytes to be sent and an error to be returned.
*
* APR_EINTR is never returned.
* </PRE>
*/
APR_DECLARE(apr_status_t) apr_socket_send(apr_socket_t *sock, const char *buf,
apr_size_t *len);
/** @deprecated @see apr_socket_send */
APR_DECLARE(apr_status_t) apr_send(apr_socket_t *sock, const char *buf,
apr_size_t *len);
/**
* Send multiple packets of data over a network.
* @param sock The socket to send the data over.
* @param vec The array of iovec structs containing the data to send
* @param nvec The number of iovec structs in the array
* @param len Receives the number of bytes actually written
* @remark
* <PRE>
* This functions acts like a blocking write by default. To change
* this behavior, use apr_socket_timeout_set().
* The number of bytes actually sent is stored in argument 3.
*
* It is possible for both bytes to be sent and an error to be returned.
*
* APR_EINTR is never returned.
* </PRE>
*/
APR_DECLARE(apr_status_t) apr_socket_sendv(apr_socket_t *sock,
const struct iovec *vec,
apr_int32_t nvec, apr_size_t *len);
/** @deprecated @see apr_socket_sendv */
APR_DECLARE(apr_status_t) apr_sendv(apr_socket_t *sock,
const struct iovec *vec,
apr_int32_t nvec, apr_size_t *len);
/**
* @param sock The socket to send from
* @param where The apr_sockaddr_t describing where to send the data
* @param flags The flags to use
* @param buf The data to send
* @param len The length of the data to send
*/
APR_DECLARE(apr_status_t) apr_socket_sendto(apr_socket_t *sock,
apr_sockaddr_t *where,
apr_int32_t flags, const char *buf,
apr_size_t *len);
/** @deprecated @see apr_socket_sendto */
APR_DECLARE(apr_status_t) apr_sendto(apr_socket_t *sock, apr_sockaddr_t *where,
apr_int32_t flags, const char *buf,
apr_size_t *len);
/**
* @param from The apr_sockaddr_t to fill in the recipient info
* @param sock The socket to use
* @param flags The flags to use
* @param buf The buffer to use
* @param len The length of the available buffer
*/
APR_DECLARE(apr_status_t) apr_socket_recvfrom(apr_sockaddr_t *from,
apr_socket_t *sock,
apr_int32_t flags, char *buf,
apr_size_t *len);
/** @deprecated @see apr_socket_recvfrom */
APR_DECLARE(apr_status_t) apr_recvfrom(apr_sockaddr_t *from, apr_socket_t *sock,
apr_int32_t flags, char *buf,
apr_size_t *len);
#if APR_HAS_SENDFILE || defined(DOXYGEN)
/**
* Send a file from an open file descriptor to a socket, along with
* optional headers and trailers
* @param sock The socket to which we're writing
* @param file The open file from which to read
* @param hdtr A structure containing the headers and trailers to send
* @param offset Offset into the file where we should begin writing
* @param len (input) - Number of bytes to send from the file
* (output) - Number of bytes actually sent,
* including headers, file, and trailers
* @param flags APR flags that are mapped to OS specific flags
* @remark This functions acts like a blocking write by default. To change
* this behavior, use apr_socket_timeout_set().
* The number of bytes actually sent is stored in argument 5.
*/
APR_DECLARE(apr_status_t) apr_socket_sendfile(apr_socket_t *sock,
apr_file_t *file,
apr_hdtr_t *hdtr,
apr_off_t *offset,
apr_size_t *len,
apr_int32_t flags);
/** @deprecated @see apr_socket_sendfile */
APR_DECLARE(apr_status_t) apr_sendfile(apr_socket_t *sock, apr_file_t *file,
apr_hdtr_t *hdtr, apr_off_t *offset,
apr_size_t *len, apr_int32_t flags);
#endif /* APR_HAS_SENDFILE */
/**
* Read data from a network.
* @param sock The socket to read the data from.
* @param buf The buffer to store the data in.
* @param len On entry, the number of bytes to receive; on exit, the number
* of bytes received.
* @remark
* <PRE>
* This functions acts like a blocking read by default. To change
* this behavior, use apr_socket_timeout_set().
* The number of bytes actually sent is stored in argument 3.
*
* It is possible for both bytes to be received and an APR_EOF or
* other error to be returned.
*
* APR_EINTR is never returned.
* </PRE>
*/
APR_DECLARE(apr_status_t) apr_socket_recv(apr_socket_t *sock,
char *buf, apr_size_t *len);
/** @deprecated @see apr_socket_recv */
APR_DECLARE(apr_status_t) apr_recv(apr_socket_t *sock,
char *buf, apr_size_t *len);
/**
* Setup socket options for the specified socket
* @param sock The socket to set up.
* @param opt The option we would like to configure. One of:
* <PRE>
* APR_SO_DEBUG -- turn on debugging information
* APR_SO_KEEPALIVE -- keep connections active
* APR_SO_LINGER -- lingers on close if data is present
* APR_SO_NONBLOCK -- Turns blocking on/off for socket
* APR_SO_REUSEADDR -- The rules used in validating addresses
* supplied to bind should allow reuse
* of local addresses.
* APR_SO_SNDBUF -- Set the SendBufferSize
* APR_SO_RCVBUF -- Set the ReceiveBufferSize
* </PRE>
* @param on Value for the option.
*/
APR_DECLARE(apr_status_t) apr_socket_opt_set(apr_socket_t *sock,
apr_int32_t opt, apr_int32_t on);
/** @deprecated @see apr_socket_opt_set */
APR_DECLARE(apr_status_t) apr_setsocketopt(apr_socket_t *sock,
apr_int32_t opt, apr_int32_t on);
/**
* Setup socket timeout for the specified socket
* @param sock The socket to set up.
* @param t Value for the timeout.
* <PRE>
* t > 0 -- read and write calls return APR_TIMEUP if specified time
* elapsess with no data read or written
* t == 0 -- read and write calls never block
* t < 0 -- read and write calls block
* </PRE>
*/
APR_DECLARE(apr_status_t) apr_socket_timeout_set(apr_socket_t *sock,
apr_interval_time_t t);
/**
* Query socket options for the specified socket
* @param sock The socket to query
* @param opt The option we would like to query. One of:
* <PRE>
* APR_SO_DEBUG -- turn on debugging information
* APR_SO_KEEPALIVE -- keep connections active
* APR_SO_LINGER -- lingers on close if data is present
* APR_SO_NONBLOCK -- Turns blocking on/off for socket
* APR_SO_REUSEADDR -- The rules used in validating addresses
* supplied to bind should allow reuse
* of local addresses.
* APR_SO_SNDBUF -- Set the SendBufferSize
* APR_SO_RCVBUF -- Set the ReceiveBufferSize
* APR_SO_DISCONNECTED -- Query the disconnected state of the socket.
* (Currently only used on Windows)
* </PRE>
* @param on Socket option returned on the call.
*/
APR_DECLARE(apr_status_t) apr_socket_opt_get(apr_socket_t *sock,
apr_int32_t opt, apr_int32_t *on);
/** @deprecated @see apr_socket_opt_set */
APR_DECLARE(apr_status_t) apr_getsocketopt(apr_socket_t *sock,
apr_int32_t opt, apr_int32_t *on);
/**
* Query socket timeout for the specified socket
* @param sock The socket to query
* @param t Socket timeout returned from the query.
*/
APR_DECLARE(apr_status_t) apr_socket_timeout_get(apr_socket_t *sock,
apr_interval_time_t *t);
/**
* Query the specified socket if at the OOB/Urgent data mark
* @param sock The socket to query
* @param atmark Is set to true if socket is at the OOB/urgent mark,
* otherwise is set to false.
*/
APR_DECLARE(apr_status_t) apr_socket_atmark(apr_socket_t *sock,
int *atmark);
/**
* Return an apr_sockaddr_t from an apr_socket_t
* @param sa The returned apr_sockaddr_t.
* @param which Which interface do we want the apr_sockaddr_t for?
* @param sock The socket to use
*/
APR_DECLARE(apr_status_t) apr_socket_addr_get(apr_sockaddr_t **sa,
apr_interface_e which,
apr_socket_t *sock);
/**
* Set the port in an APR socket address.
* @param sockaddr The socket address to set.
* @param port The port to be stored in the socket address.
* @deprecated @see apr_sockaddr_info_get
*/
APR_DECLARE(apr_status_t) apr_sockaddr_port_set(apr_sockaddr_t *sockaddr,
apr_port_t port);
/**
* Return the port in an APR socket address.
* @param port The port from the socket address.
* @param sockaddr The socket address to reference.
* @deprecated Access port field directly.
*/
APR_DECLARE(apr_status_t) apr_sockaddr_port_get(apr_port_t *port,
apr_sockaddr_t *sockaddr);
/**
* Set the IP address in an APR socket address.
* @param sockaddr The socket address to use
* @param addr The IP address to attach to the socket.
* Use APR_ANYADDR to use any IP addr on the machine.
* @deprecated @see apr_sockaddr_info_get
*/
APR_DECLARE(apr_status_t) apr_sockaddr_ip_set(apr_sockaddr_t *sockaddr,
const char *addr);
/**
* Return the IP address (in numeric address string format) in
* an APR socket address. APR will allocate storage for the IP address
* string from the pool of the apr_sockaddr_t.
* @param addr The IP address.
* @param sockaddr The socket address to reference.
*/
APR_DECLARE(apr_status_t) apr_sockaddr_ip_get(char **addr,
apr_sockaddr_t *sockaddr);
/**
* See if the IP addresses in two APR socket addresses are
* equivalent. Appropriate logic is present for comparing
* IPv4-mapped IPv6 addresses with IPv4 addresses.
*
* @param addr1 One of the APR socket addresses.
* @param addr2 The other APR socket address.
* @remark The return value will be non-zero if the addresses
* are equivalent.
*/
APR_DECLARE(int) apr_sockaddr_equal(const apr_sockaddr_t *addr1,
const apr_sockaddr_t *addr2);
#if APR_FILES_AS_SOCKETS || defined(DOXYGEN)
/**
* Convert a File type to a socket so that it can be used in a poll operation.
* @param newsock the newly created socket which represents a file.
* @param file the file to mask as a socket.
* @warning This is not available on all platforms. Platforms that have the
* ability to poll files for data to be read/written/exceptions will
* have the APR_FILES_AS_SOCKETS macro defined as true.
* @deprecated This function has been deprecated, because of the new poll
* implementation.
*/
APR_DECLARE(apr_status_t) apr_socket_from_file(apr_socket_t **newsock,
apr_file_t *file);
#endif /* APR_FILES_AS_SOCKETS */
/**
* Given an apr_sockaddr_t and a service name, set the port for the service
* @param sockaddr The apr_sockaddr_t that will have its port set
* @param servname The name of the service you wish to use
*/
APR_DECLARE(apr_status_t) apr_getservbyname(apr_sockaddr_t *sockaddr,
const char *servname);
/**
* Build an ip-subnet representation from an IP address and optional netmask or
* number-of-bits.
* @param ipsub The new ip-subnet representation
* @param ipstr The input IP address string
* @param mask_or_numbits The input netmask or number-of-bits string, or NULL
* @param p The pool to allocate from
*/
APR_DECLARE(apr_status_t) apr_ipsubnet_create(apr_ipsubnet_t **ipsub,
const char *ipstr,
const char *mask_or_numbits,
apr_pool_t *p);
/**
* Test the IP address in an apr_sockaddr_t against a pre-built ip-subnet
* representation.
* @param ipsub The ip-subnet representation
* @param sa The socket address to test
* @return non-zero if the socket address is within the subnet, 0 otherwise
*/
APR_DECLARE(int) apr_ipsubnet_test(apr_ipsubnet_t *ipsub, apr_sockaddr_t *sa);
#if APR_HAS_SO_ACCEPTFILTER || defined(DOXYGEN)
/**
* Set an OS level accept filter.
* @param sock The socket to put the accept filter on.
* @param name The accept filter
* @param args Any extra args to the accept filter. Passing NULL here removes
* the accept filter.
*/
apr_status_t apr_socket_accept_filter(apr_socket_t *sock, char *name,
char *args);
#endif
/**
* Return the protocol of the socket.
* @param sock The socket to query.
* @param protocol The returned protocol (e.g., APR_PROTO_TCP).
*/
APR_DECLARE(apr_status_t) apr_socket_protocol_get(apr_socket_t *sock,
int *protocol);
/**
* Set a socket to be inherited by child processes.
*/
APR_DECLARE_INHERIT_SET(socket);
/** @deprecated @see apr_socket_inherit_set */
APR_DECLARE(void) apr_socket_set_inherit(apr_socket_t *skt);
/**
* Unset a socket from being inherited by child processes.
*/
APR_DECLARE_INHERIT_UNSET(socket);
/** @deprecated @see apr_socket_inherit_unset */
APR_DECLARE(void) apr_socket_unset_inherit(apr_socket_t *skt);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_NETWORK_IO_H */
--- NEW FILE: apr_portable.h ---
/* 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.
*/
/* This header file is where you should put ANY platform specific information.
* This should be the only header file that programs need to include that
* actually has platform dependant code which refers to the .
*/
#ifndef APR_PORTABLE_H
#define APR_PORTABLE_H
/**
* @file apr_portable.h
* @brief APR Portability Routines
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_thread_proc.h"
#include "apr_file_io.h"
#include "apr_network_io.h"
#include "apr_errno.h"
#include "apr_global_mutex.h"
#include "apr_proc_mutex.h"
#include "apr_time.h"
#include "apr_dso.h"
#include "apr_shm.h"
#if APR_HAVE_DIRENT_H
#include <dirent.h>
#endif
#if APR_HAVE_FCNTL_H
#include <fcntl.h>
#endif
#if APR_HAVE_PTHREAD_H
#include <pthread.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_portabile Portability Routines
* @ingroup APR
* @{
*/
#ifdef WIN32
/* The primitives for Windows types */
typedef HANDLE apr_os_file_t;
typedef HANDLE apr_os_dir_t;
typedef SOCKET apr_os_sock_t;
typedef HANDLE apr_os_proc_mutex_t;
typedef HANDLE apr_os_thread_t;
typedef HANDLE apr_os_proc_t;
typedef DWORD apr_os_threadkey_t;
typedef FILETIME apr_os_imp_time_t;
typedef SYSTEMTIME apr_os_exp_time_t;
typedef HANDLE apr_os_dso_handle_t;
typedef HANDLE apr_os_shm_t;
#elif defined(OS2)
typedef HFILE apr_os_file_t;
typedef HDIR apr_os_dir_t;
typedef int apr_os_sock_t;
typedef HMTX apr_os_proc_mutex_t;
typedef TID apr_os_thread_t;
typedef PID apr_os_proc_t;
typedef PULONG apr_os_threadkey_t;
typedef struct timeval apr_os_imp_time_t;
typedef struct tm apr_os_exp_time_t;
typedef HMODULE apr_os_dso_handle_t;
typedef void* apr_os_shm_t;
#elif defined(__BEOS__)
#include <kernel/OS.h>
#include <kernel/image.h>
struct apr_os_proc_mutex_t {
sem_id sem;
int32 ben;
};
typedef int apr_os_file_t;
typedef DIR apr_os_dir_t;
typedef int apr_os_sock_t;
typedef struct apr_os_proc_mutex_t apr_os_proc_mutex_t;
typedef thread_id apr_os_thread_t;
typedef thread_id apr_os_proc_t;
typedef int apr_os_threadkey_t;
typedef struct timeval apr_os_imp_time_t;
typedef struct tm apr_os_exp_time_t;
typedef image_id apr_os_dso_handle_t;
typedef void* apr_os_shm_t;
#elif defined(NETWARE)
typedef int apr_os_file_t;
typedef DIR apr_os_dir_t;
typedef int apr_os_sock_t;
typedef NXMutex_t apr_os_proc_mutex_t;
typedef NXThreadId_t apr_os_thread_t;
typedef long apr_os_proc_t;
typedef NXKey_t apr_os_threadkey_t;
typedef struct timeval apr_os_imp_time_t;
typedef struct tm apr_os_exp_time_t;
typedef void * apr_os_dso_handle_t;
typedef void* apr_os_shm_t;
#else
/* Any other OS should go above this one. This is the lowest common
* denominator typedefs for all UNIX-like systems. :)
*/
/** Basic OS process mutex structure. */
struct apr_os_proc_mutex_t {
#if APR_HAS_SYSVSEM_SERIALIZE || APR_HAS_FCNTL_SERIALIZE || APR_HAS_FLOCK_SERIALIZE
int crossproc;
#endif
#if APR_HAS_PROC_PTHREAD_SERIALIZE
pthread_mutex_t *pthread_interproc;
#endif
#if APR_HAS_THREADS
/* If no threads, no need for thread locks */
#if APR_USE_PTHREAD_SERIALIZE
pthread_mutex_t *intraproc;
#endif
#endif
};
typedef int apr_os_file_t; /**< native file */
typedef DIR apr_os_dir_t; /**< native dir */
typedef int apr_os_sock_t; /**< native dir */
typedef struct apr_os_proc_mutex_t apr_os_proc_mutex_t; /**< native proces
* mutex
*/
#if APR_HAS_THREADS && APR_HAVE_PTHREAD_H
typedef pthread_t apr_os_thread_t; /**< native thread */
typedef pthread_key_t apr_os_threadkey_t; /**< native thread address
* space */
#endif
typedef pid_t apr_os_proc_t; /**< native pid */
typedef struct timeval apr_os_imp_time_t; /**< native timeval */
typedef struct tm apr_os_exp_time_t; /**< native tm */
/** @var apr_os_dso_handle_t
* native dso types
*/
#if defined(HPUX) || defined(HPUX10) || defined(HPUX11)
#include <dl.h>
typedef shl_t apr_os_dso_handle_t;
#elif defined(DARWIN)
#include <mach-o/dyld.h>
typedef NSModule apr_os_dso_handle_t;
#else
typedef void * apr_os_dso_handle_t;
#endif
typedef void* apr_os_shm_t; /**< native SHM */
#endif
/**
* @typedef apr_os_sock_info_t
* @brief alias for local OS socket
*/
/**
* everything APR needs to know about an active socket to construct
* an APR socket from it; currently, this is platform-independent
*/
struct apr_os_sock_info_t {
apr_os_sock_t *os_sock; /**< always required */
struct sockaddr *local; /**< NULL if not yet bound */
struct sockaddr *remote; /**< NULL if not connected */
int family; /**< always required (APR_INET, APR_INET6, etc.) */
int type; /**< always required (SOCK_STREAM, SOCK_DGRAM, etc.) */
#ifdef APR_ENABLE_FOR_1_0 /**< enable with APR 1.0 */
int protocol; /**< 0 or actual protocol (APR_PROTO_SCTP, APR_PROTO_TCP, etc.) */
#endif
};
typedef struct apr_os_sock_info_t apr_os_sock_info_t;
#if APR_PROC_MUTEX_IS_GLOBAL || defined(DOXYGEN)
/** Opaque global mutex type */
#define apr_os_global_mutex_t apr_os_proc_mutex_t
/** @return apr_os_global_mutex */
#define apr_os_global_mutex_get apr_os_proc_mutex_get
#else
/** Thread and process mutex for those platforms where process mutexes
* are not held in threads.
*/
struct apr_os_global_mutex_t {
apr_pool_t *pool;
apr_proc_mutex_t *proc_mutex;
#if APR_HAS_THREADS
apr_thread_mutex_t *thread_mutex;
#endif /* APR_HAS_THREADS */
};
typedef struct apr_os_global_mutex_t apr_os_global_mutex_t;
APR_DECLARE(apr_status_t) apr_os_global_mutex_get(apr_os_global_mutex_t *ospmutex,
apr_global_mutex_t *pmutex);
#endif
/**
* convert the file from apr type to os specific type.
* @param thefile The os specific file we are converting to
* @param file The apr file to convert.
* @remark On Unix, it is only possible to get a file descriptor from
* an apr file type.
*/
APR_DECLARE(apr_status_t) apr_os_file_get(apr_os_file_t *thefile,
apr_file_t *file);
/**
* convert the dir from apr type to os specific type.
* @param thedir The os specific dir we are converting to
* @param dir The apr dir to convert.
*/
APR_DECLARE(apr_status_t) apr_os_dir_get(apr_os_dir_t **thedir,
apr_dir_t *dir);
/**
* Convert the socket from an apr type to an OS specific socket
* @param thesock The socket to convert.
* @param sock The os specifc equivelant of the apr socket..
*/
APR_DECLARE(apr_status_t) apr_os_sock_get(apr_os_sock_t *thesock,
apr_socket_t *sock);
/**
* Convert the proc mutex from os specific type to apr type
* @param ospmutex The os specific proc mutex we are converting to.
* @param pmutex The apr proc mutex to convert.
*/
APR_DECLARE(apr_status_t) apr_os_proc_mutex_get(apr_os_proc_mutex_t *ospmutex,
apr_proc_mutex_t *pmutex);
/**
* Get the exploded time in the platforms native format.
* @param ostime the native time format
* @param aprtime the time to convert
*/
APR_DECLARE(apr_status_t) apr_os_exp_time_get(apr_os_exp_time_t **ostime,
apr_time_exp_t *aprtime);
/**
* Get the imploded time in the platforms native format.
* @param ostime the native time format
* @param aprtime the time to convert
*/
APR_DECLARE(apr_status_t) apr_os_imp_time_get(apr_os_imp_time_t **ostime,
apr_time_t *aprtime);
/**
* convert the shm from apr type to os specific type.
* @param osshm The os specific shm representation
* @param shm The apr shm to convert.
*/
APR_DECLARE(apr_status_t) apr_os_shm_get(apr_os_shm_t *osshm,
apr_shm_t *shm);
#if APR_HAS_THREADS || defined(DOXYGEN)
/**
* @defgroup apr_os_thread Thread portability Routines
* @{
*/
/**
* convert the thread to os specific type from apr type.
* @param thethd The apr thread to convert
* @param thd The os specific thread we are converting to
*/
APR_DECLARE(apr_status_t) apr_os_thread_get(apr_os_thread_t **thethd,
apr_thread_t *thd);
/**
* convert the thread private memory key to os specific type from an apr type.
* @param thekey The apr handle we are converting from.
* @param key The os specific handle we are converting to.
*/
APR_DECLARE(apr_status_t) apr_os_threadkey_get(apr_os_threadkey_t *thekey,
apr_threadkey_t *key);
/**
* convert the thread from os specific type to apr type.
* @param thd The apr thread we are converting to.
* @param thethd The os specific thread to convert
* @param cont The pool to use if it is needed.
*/
APR_DECLARE(apr_status_t) apr_os_thread_put(apr_thread_t **thd,
apr_os_thread_t *thethd,
apr_pool_t *cont);
/**
* convert the thread private memory key from os specific type to apr type.
* @param key The apr handle we are converting to.
* @param thekey The os specific handle to convert
* @param cont The pool to use if it is needed.
*/
APR_DECLARE(apr_status_t) apr_os_threadkey_put(apr_threadkey_t **key,
apr_os_threadkey_t *thekey,
apr_pool_t *cont);
/**
* Get the thread ID
*/
APR_DECLARE(apr_os_thread_t) apr_os_thread_current(void);
/**
* Compare two thread id's
* @param tid1 1st Thread ID to compare
* @param tid2 2nd Thread ID to compare
*/
APR_DECLARE(int) apr_os_thread_equal(apr_os_thread_t tid1,
apr_os_thread_t tid2);
/** @} */
#endif /* APR_HAS_THREADS */
/**
* convert the file from os specific type to apr type.
* @param file The apr file we are converting to.
* @param thefile The os specific file to convert
* @param flags The flags that were used to open this file.
* @param cont The pool to use if it is needed.
* @remark On Unix, it is only possible to put a file descriptor into
* an apr file type.
*/
APR_DECLARE(apr_status_t) apr_os_file_put(apr_file_t **file,
apr_os_file_t *thefile,
apr_int32_t flags, apr_pool_t *cont);
/**
* convert the file from os specific type to apr type.
* @param file The apr file we are converting to.
* @param thefile The os specific pipe to convert
* @param cont The pool to use if it is needed.
* @remark On Unix, it is only possible to put a file descriptor into
* an apr file type.
*/
APR_DECLARE(apr_status_t) apr_os_pipe_put(apr_file_t **file,
apr_os_file_t *thefile,
apr_pool_t *cont);
/**
* convert the file from os specific type to apr type.
* @param file The apr file we are converting to.
* @param thefile The os specific pipe to convert
* @param register_cleanup A cleanup will be registered on the apr_file_t
* to issue apr_file_close().
* @param cont The pool to use if it is needed.
* @remark On Unix, it is only possible to put a file descriptor into
* an apr file type.
*/
APR_DECLARE(apr_status_t) apr_os_pipe_put_ex(apr_file_t **file,
apr_os_file_t *thefile,
int register_cleanup,
apr_pool_t *cont);
/**
* convert the dir from os specific type to apr type.
* @param dir The apr dir we are converting to.
* @param thedir The os specific dir to convert
* @param cont The pool to use when creating to apr directory.
*/
APR_DECLARE(apr_status_t) apr_os_dir_put(apr_dir_t **dir,
apr_os_dir_t *thedir,
apr_pool_t *cont);
/**
* Convert a socket from the os specific type to the apr type
* @param sock The pool to use.
* @param thesock The socket to convert to.
* @param cont The socket we are converting to an apr type.
* @remark If it is a true socket, it is best to call apr_os_sock_make()
* and provide APR with more information about the socket.
*/
APR_DECLARE(apr_status_t) apr_os_sock_put(apr_socket_t **sock,
apr_os_sock_t *thesock,
apr_pool_t *cont);
/**
* Create a socket from an existing descriptor and local and remote
* socket addresses.
* @param apr_sock The new socket that has been set up
* @param os_sock_info The os representation of the socket handle and
* other characteristics of the socket
* @param cont The pool to use
* @remark If you only know the descriptor/handle or if it isn't really
* a true socket, use apr_os_sock_put() instead.
*/
APR_DECLARE(apr_status_t) apr_os_sock_make(apr_socket_t **apr_sock,
apr_os_sock_info_t *os_sock_info,
apr_pool_t *cont);
/**
* Convert the proc mutex from os specific type to apr type
* @param pmutex The apr proc mutex we are converting to.
* @param ospmutex The os specific proc mutex to convert.
* @param cont The pool to use if it is needed.
*/
APR_DECLARE(apr_status_t) apr_os_proc_mutex_put(apr_proc_mutex_t **pmutex,
apr_os_proc_mutex_t *ospmutex,
apr_pool_t *cont);
/**
* Put the imploded time in the APR format.
* @param aprtime the APR time format
* @param ostime the time to convert
* @param cont the pool to use if necessary
*/
APR_DECLARE(apr_status_t) apr_os_imp_time_put(apr_time_t *aprtime,
apr_os_imp_time_t **ostime,
apr_pool_t *cont);
/**
* Put the exploded time in the APR format.
* @param aprtime the APR time format
* @param ostime the time to convert
* @param cont the pool to use if necessary
*/
APR_DECLARE(apr_status_t) apr_os_exp_time_put(apr_time_exp_t *aprtime,
apr_os_exp_time_t **ostime,
apr_pool_t *cont);
/**
* convert the shared memory from os specific type to apr type.
* @param shm The apr shm representation of osshm
* @param osshm The os specific shm identity
* @param cont The pool to use if it is needed.
* @remark On fork()ed architectures, this is typically nothing more than
* the memory block mapped. On non-fork architectures, this is typically
* some internal handle to pass the mapping from process to process.
*/
APR_DECLARE(apr_status_t) apr_os_shm_put(apr_shm_t **shm,
apr_os_shm_t *osshm,
apr_pool_t *cont);
#if APR_HAS_DSO || defined(DOXYGEN)
/**
* @defgroup apr_os_dso DSO (Dynamic Loading) Portabiliity Routines
* @{
*/
/**
* convert the dso handle from os specific to apr
* @param dso The apr handle we are converting to
* @param thedso the os specific handle to convert
* @param pool the pool to use if it is needed
*/
APR_DECLARE(apr_status_t) apr_os_dso_handle_put(apr_dso_handle_t **dso,
apr_os_dso_handle_t thedso,
apr_pool_t *pool);
/**
* convert the apr dso handle into an os specific one
* @param aprdso The apr dso handle to convert
* @param dso The os specific dso to return
*/
APR_DECLARE(apr_status_t) apr_os_dso_handle_get(apr_os_dso_handle_t *dso,
apr_dso_handle_t *aprdso);
#if APR_HAS_OS_UUID
/**
* Private: apr-util's apr_uuid module when supported by the platform
*/
APR_DECLARE(apr_status_t) apr_os_uuid_get(unsigned char *uuid_data);
#endif
/** @} */
#endif /* APR_HAS_DSO */
/**
* Get the name of the system default characer set.
* @param pool the pool to allocate the name from, if needed
*/
APR_DECLARE(const char*) apr_os_default_encoding(apr_pool_t *pool);
/**
* Get the name of the current locale character set.
* @param pool the pool to allocate the name from, if needed
* @remark Defers to apr_os_default_encoding if the current locale's
* data can't be retreved on this system.
*/
APR_DECLARE(const char*) apr_os_locale_encoding(apr_pool_t *pool);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_PORTABLE_H */
--- NEW FILE: apr_inherit.h ---
/* 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_INHERIT_H
#define APR_INHERIT_H
/**
* @file apr_inherit.h
* @brief APR File Handle Inheritance Helpers
* @remark This internal header includes internal declaration helpers
* for other headers to declare apr_foo_inherit_[un]set functions.
*/
/**
* Prototype for type-specific declarations of apr_foo_inherit_set
* functions.
* @remark Doxygen unwraps this macro (via doxygen.conf) to provide
* actual help for each specific occurance of apr_foo_inherit_set.
* @remark the linkage is specified for APR. It would be possible to expand
* the macros to support other linkages.
*/
#define APR_DECLARE_INHERIT_SET(type) \
APR_DECLARE(apr_status_t) apr_##type##_inherit_set( \
apr_##type##_t *the##type)
/**
* Prototype for type-specific declarations of apr_foo_inherit_unset
* functions.
* @remark Doxygen unwraps this macro (via doxygen.conf) to provide
* actual help for each specific occurance of apr_foo_inherit_unset.
* @remark the linkage is specified for APR. It would be possible to expand
* the macros to support other linkages.
*/
#define APR_DECLARE_INHERIT_UNSET(type) \
APR_DECLARE(apr_status_t) apr_##type##_inherit_unset( \
apr_##type##_t *the##type)
#endif /* ! APR_INHERIT_H */
--- NEW FILE: apr_file_io.h ---
/* 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_FILE_IO_H
#define APR_FILE_IO_H
/**
* @file apr_file_io.h
* @brief APR File I/O Handling
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_time.h"
#include "apr_errno.h"
#include "apr_file_info.h"
#include "apr_inherit.h"
#define APR_WANT_STDIO /**< for SEEK_* */
#define APR_WANT_IOVEC /**< for apr_file_writev */
#include "apr_want.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_file_io File I/O Handling Functions
* @ingroup APR
* @{
*/
/**
* @defgroup apr_file_open_flags File Open Flags/Routines
* @{
*/
/* Note to implementors: Values in the range 0x00100000--0x80000000
are reserved for platform-specific values. */
#define APR_READ 0x00001 /**< Open the file for reading */
#define APR_WRITE 0x00002 /**< Open the file for writing */
#define APR_CREATE 0x00004 /**< Create the file if not there */
#define APR_APPEND 0x00008 /**< Append to the end of the file */
#define APR_TRUNCATE 0x00010 /**< Open the file and truncate to 0 length */
#define APR_BINARY 0x00020 /**< Open the file in binary mode */
#define APR_EXCL 0x00040 /**< Open should fail if APR_CREATE and file
exists. */
#define APR_BUFFERED 0x00080 /**< Open the file for buffered I/O */
#define APR_DELONCLOSE 0x00100 /**< Delete the file after close */
#define APR_XTHREAD 0x00200 /**< Platform dependent tag to open the file
for use across multiple threads */
#define APR_SHARELOCK 0x00400 /**< Platform dependent support for higher
level locked read/write access to support
writes across process/machines */
#define APR_FILE_NOCLEANUP 0x00800 /**< Do not register a cleanup when the file
is opened */
#define APR_SENDFILE_ENABLED 0x01000 /**< Advisory flag that this file should
support apr_sendfile operation */
#define APR_LARGEFILE 0x04000 /**< Platform dependent flag to enable large file
support; WARNING see below. */
/** @warning The APR_LARGEFILE flag only has effect on some platforms
* where sizeof(apr_off_t) == 4. Where implemented, it allows opening
* and writing to a file which exceeds the size which can be
* represented by apr_off_t (2 gigabytes). When a file's size does
* exceed 2Gb, apr_file_info_get() will fail with an error on the
* descriptor, likewise apr_stat()/apr_lstat() will fail on the
* filename. apr_dir_read() will fail with APR_INCOMPLETE on a
* directory entry for a large file depending on the particular
* APR_FINFO_* flags. Generally, it is not recommended to use this
* flag. */
/** @} */
/**
* @defgroup apr_file_seek_flags File Seek Flags
* @{
*/
/* flags for apr_file_seek */
/** Set the file position */
#define APR_SET SEEK_SET
/** Current */
#define APR_CUR SEEK_CUR
/** Go to end of file */
#define APR_END SEEK_END
/** @} */
/**
* @defgroup apr_file_attrs_set_flags File Attribute Flags
* @{
*/
/* flags for apr_file_attrs_set */
#define APR_FILE_ATTR_READONLY 0x01 /**< File is read-only */
#define APR_FILE_ATTR_EXECUTABLE 0x02 /**< File is executable */
#define APR_FILE_ATTR_HIDDEN 0x04 /**< File is hidden */
/** @} */
/** File attributes */
typedef apr_uint32_t apr_fileattrs_t;
/** should be same as whence type in lseek, POSIX defines this as int */
typedef int apr_seek_where_t;
/**
* Structure for referencing files.
*/
typedef struct apr_file_t apr_file_t;
/* File lock types/flags */
/**
* @defgroup apr_file_lock_types File Lock Types
* @{
*/
#define APR_FLOCK_SHARED 1 /**< Shared lock. More than one process
or thread can hold a shared lock
at any given time. Essentially,
this is a "read lock", preventing
writers from establishing an
exclusive lock. */
#define APR_FLOCK_EXCLUSIVE 2 /**< Exclusive lock. Only one process
may hold an exclusive lock at any
given time. This is analogous to
a "write lock". */
#define APR_FLOCK_TYPEMASK 0x000F /**< mask to extract lock type */
#define APR_FLOCK_NONBLOCK 0x0010 /**< do not block while acquiring the
file lock */
/** @} */
/**
* Open the specified file.
* @param newf The opened file descriptor.
* @param fname The full path to the file (using / on all systems)
* @param flag Or'ed value of:
* <PRE>
* APR_READ open for reading
* APR_WRITE open for writing
* APR_CREATE create the file if not there
* APR_APPEND file ptr is set to end prior to all writes
* APR_TRUNCATE set length to zero if file exists
* APR_BINARY not a text file (This flag is ignored on
* UNIX because it has no meaning)
* APR_BUFFERED buffer the data. Default is non-buffered
* APR_EXCL return error if APR_CREATE and file exists
* APR_DELONCLOSE delete the file after closing.
* APR_XTHREAD Platform dependent tag to open the file
* for use across multiple threads
* APR_SHARELOCK Platform dependent support for higher
* level locked read/write access to support
* writes across process/machines
* APR_FILE_NOCLEANUP Do not register a cleanup with the pool
* passed in on the <EM>cont</EM> argument (see below).
* The apr_os_file_t handle in apr_file_t will not
* be closed when the pool is destroyed.
* APR_SENDFILE_ENABLED Open with appropriate platform semantics
* for sendfile operations. Advisory only,
* apr_sendfile does not check this flag.
* </PRE>
* @param perm Access permissions for file.
* @param pool The pool to use.
* @remark If perm is APR_OS_DEFAULT and the file is being created, appropriate
* default permissions will be used. *arg1 must point to a valid file_t,
* or NULL (in which case it will be allocated)
*/
APR_DECLARE(apr_status_t) apr_file_open(apr_file_t **newf, const char *fname,
apr_int32_t flag, apr_fileperms_t perm,
apr_pool_t *pool);
/**
* Close the specified file.
* @param file The file descriptor to close.
*/
APR_DECLARE(apr_status_t) apr_file_close(apr_file_t *file);
/**
* delete the specified file.
* @param path The full path to the file (using / on all systems)
* @param cont The pool to use.
* @remark If the file is open, it won't be removed until all instances are closed.
*/
APR_DECLARE(apr_status_t) apr_file_remove(const char *path, apr_pool_t *cont);
/**
* rename the specified file.
* @param from_path The full path to the original file (using / on all systems)
* @param to_path The full path to the new file (using / on all systems)
* @param pool The pool to use.
* @warning If a file exists at the new location, then it will be overwritten.
* Moving files or directories across devices may not be possible.
*/
APR_DECLARE(apr_status_t) apr_file_rename(const char *from_path,
const char *to_path,
apr_pool_t *pool);
/**
* copy the specified file to another file.
* @param from_path The full path to the original file (using / on all systems)
* @param to_path The full path to the new file (using / on all systems)
* @param perms Access permissions for the new file if it is created.
* In place of the usual or'd combination of file permissions, the
* value APR_FILE_SOURCE_PERMS may be given, in which case the source
* file's permissions are copied.
* @param pool The pool to use.
* @remark The new file does not need to exist, it will be created if required.
* @warning If the new file already exists, its contents will be overwritten.
*/
APR_DECLARE(apr_status_t) apr_file_copy(const char *from_path,
const char *to_path,
apr_fileperms_t perms,
apr_pool_t *pool);
/**
* append the specified file to another file.
* @param from_path The full path to the source file (using / on all systems)
* @param to_path The full path to the destination file (using / on all systems)
* @param perms Access permissions for the destination file if it is created.
* In place of the usual or'd combination of file permissions, the
* value APR_FILE_SOURCE_PERMS may be given, in which case the source
* file's permissions are copied.
* @param pool The pool to use.
* @remark The new file does not need to exist, it will be created if required.
*/
APR_DECLARE(apr_status_t) apr_file_append(const char *from_path,
const char *to_path,
apr_fileperms_t perms,
apr_pool_t *pool);
/**
* Are we at the end of the file
* @param fptr The apr file we are testing.
* @remark Returns APR_EOF if we are at the end of file, APR_SUCCESS otherwise.
*/
APR_DECLARE(apr_status_t) apr_file_eof(apr_file_t *fptr);
/**
* open standard error as an apr file pointer.
* @param thefile The apr file to use as stderr.
* @param cont The pool to allocate the file out of.
*
* @remark The only reason that the apr_file_open_std* functions exist
* is that you may not always have a stderr/out/in on Windows. This
* is generally a problem with newer versions of Windows and services.
*
* The other problem is that the C library functions generally work
* differently on Windows and Unix. So, by using apr_file_open_std*
* functions, you can get a handle to an APR struct that works with
* the APR functions which are supposed to work identically on all
* platforms.
*/
APR_DECLARE(apr_status_t) apr_file_open_stderr(apr_file_t **thefile,
apr_pool_t *cont);
/**
* open standard output as an apr file pointer.
* @param thefile The apr file to use as stdout.
* @param cont The pool to allocate the file out of.
*
* @remark The only reason that the apr_file_open_std* functions exist
* is that you may not always have a stderr/out/in on Windows. This
* is generally a problem with newer versions of Windows and services.
*
* The other problem is that the C library functions generally work
* differently on Windows and Unix. So, by using apr_file_open_std*
* functions, you can get a handle to an APR struct that works with
* the APR functions which are supposed to work identically on all
* platforms.
*/
APR_DECLARE(apr_status_t) apr_file_open_stdout(apr_file_t **thefile,
apr_pool_t *cont);
/**
* open standard input as an apr file pointer.
* @param thefile The apr file to use as stdin.
* @param cont The pool to allocate the file out of.
*
* @remark The only reason that the apr_file_open_std* functions exist
* is that you may not always have a stderr/out/in on Windows. This
* is generally a problem with newer versions of Windows and services.
*
* The other problem is that the C library functions generally work
* differently on Windows and Unix. So, by using apr_file_open_std*
* functions, you can get a handle to an APR struct that works with
* the APR functions which are supposed to work identically on all
* platforms.
*/
APR_DECLARE(apr_status_t) apr_file_open_stdin(apr_file_t **thefile,
apr_pool_t *cont);
/**
* Read data from the specified file.
* @param thefile The file descriptor to read from.
* @param buf The buffer to store the data to.
* @param nbytes On entry, the number of bytes to read; on exit, the number of bytes read.
* @remark apr_file_read will read up to the specified number of bytes, but
* never more. If there isn't enough data to fill that number of
* bytes, all of the available data is read. The third argument is
* modified to reflect the number of bytes read. If a char was put
* back into the stream via ungetc, it will be the first character
* returned.
*
* It is not possible for both bytes to be read and an APR_EOF or other
* error to be returned.
*
* APR_EINTR is never returned.
*/
APR_DECLARE(apr_status_t) apr_file_read(apr_file_t *thefile, void *buf,
apr_size_t *nbytes);
/**
* Write data to the specified file.
* @param thefile The file descriptor to write to.
* @param buf The buffer which contains the data.
* @param nbytes On entry, the number of bytes to write; on exit, the number
* of bytes written.
* @remark apr_file_write will write up to the specified number of bytes, but never
* more. If the OS cannot write that many bytes, it will write as many
* as it can. The third argument is modified to reflect the * number
* of bytes written.
*
* It is possible for both bytes to be written and an error to be returned.
*
* APR_EINTR is never returned.
*/
APR_DECLARE(apr_status_t) apr_file_write(apr_file_t *thefile, const void *buf,
apr_size_t *nbytes);
/**
* Write data from iovec array to the specified file.
* @param thefile The file descriptor to write to.
* @param vec The array from which to get the data to write to the file.
* @param nvec The number of elements in the struct iovec array. This must
* be smaller than APR_MAX_IOVEC_SIZE. If it isn't, the function
* will fail with APR_EINVAL.
* @param nbytes The number of bytes written.
* @remark It is possible for both bytes to be written and an error to be returned.
* APR_EINTR is never returned.
*
* apr_file_writev is available even if the underlying operating system
*
* doesn't provide writev().
*/
APR_DECLARE(apr_status_t) apr_file_writev(apr_file_t *thefile,
const struct iovec *vec,
apr_size_t nvec, apr_size_t *nbytes);
/**
* Read data from the specified file, ensuring that the buffer is filled
* before returning.
* @param thefile The file descriptor to read from.
* @param buf The buffer to store the data to.
* @param nbytes The number of bytes to read.
* @param bytes_read If non-NULL, this will contain the number of bytes read.
* @remark apr_file_read will read up to the specified number of bytes, but never
* more. If there isn't enough data to fill that number of bytes,
* then the process/thread will block until it is available or EOF
* is reached. If a char was put back into the stream via ungetc,
* it will be the first character returned.
*
* It is possible for both bytes to be read and an error to be
* returned. And if *bytes_read is less than nbytes, an
* accompanying error is _always_ returned.
*
* APR_EINTR is never returned.
*/
APR_DECLARE(apr_status_t) apr_file_read_full(apr_file_t *thefile, void *buf,
apr_size_t nbytes,
apr_size_t *bytes_read);
/**
* Write data to the specified file, ensuring that all of the data is
* written before returning.
* @param thefile The file descriptor to write to.
* @param buf The buffer which contains the data.
* @param nbytes The number of bytes to write.
* @param bytes_written If non-NULL, this will contain the number of bytes written.
* @remark apr_file_write will write up to the specified number of bytes, but never
* more. If the OS cannot write that many bytes, the process/thread
* will block until they can be written. Exceptional error such as
* "out of space" or "pipe closed" will terminate with an error.
*
* It is possible for both bytes to be written and an error to be
* returned. And if *bytes_written is less than nbytes, an
* accompanying error is _always_ returned.
*
* APR_EINTR is never returned.
*/
APR_DECLARE(apr_status_t) apr_file_write_full(apr_file_t *thefile, const void *buf,
apr_size_t nbytes,
apr_size_t *bytes_written);
/**
* put a character into the specified file.
* @param ch The character to write.
* @param thefile The file descriptor to write to
*/
APR_DECLARE(apr_status_t) apr_file_putc(char ch, apr_file_t *thefile);
/**
* get a character from the specified file.
* @param ch The character to read into
* @param thefile The file descriptor to read from
*/
APR_DECLARE(apr_status_t) apr_file_getc(char *ch, apr_file_t *thefile);
/**
* put a character back onto a specified stream.
* @param ch The character to write.
* @param thefile The file descriptor to write to
*/
APR_DECLARE(apr_status_t) apr_file_ungetc(char ch, apr_file_t *thefile);
/**
* Get a string from a specified file.
* @param str The buffer to store the string in.
* @param len The length of the string
* @param thefile The file descriptor to read from
* @remark The buffer will be '\0'-terminated if any characters are stored.
*/
APR_DECLARE(apr_status_t) apr_file_gets(char *str, int len, apr_file_t *thefile);
/**
* Put the string into a specified file.
* @param str The string to write.
* @param thefile The file descriptor to write to
*/
APR_DECLARE(apr_status_t) apr_file_puts(const char *str, apr_file_t *thefile);
/**
* Flush the file's buffer.
* @param thefile The file descriptor to flush
*/
APR_DECLARE(apr_status_t) apr_file_flush(apr_file_t *thefile);
/**
* duplicate the specified file descriptor.
* @param new_file The structure to duplicate into.
* @param old_file The file to duplicate.
* @param p The pool to use for the new file.
* @remark *new_file must point to a valid apr_file_t, or point to NULL
*/
APR_DECLARE(apr_status_t) apr_file_dup(apr_file_t **new_file,
apr_file_t *old_file,
apr_pool_t *p);
/**
* duplicate the specified file descriptor and close the original
* @param new_file The old file that is to be closed and reused
* @param old_file The file to duplicate
* @param p The pool to use for the new file
*
* @remark new_file MUST point at a valid apr_file_t. It cannot be NULL
*/
APR_DECLARE(apr_status_t) apr_file_dup2(apr_file_t *new_file,
apr_file_t *old_file,
apr_pool_t *p);
/**
* move the specified file descriptor to a new pool
* @param new_file Pointer in which to return the new apr_file_t
* @param old_file The file to move
* @param p The pool to which the descriptor is to be moved
* @remark Unlike apr_file_dup2(), this function doesn't do an
* OS dup() operation on the underlying descriptor; it just
* moves the descriptor's apr_file_t wrapper to a new pool.
* @remark The new pool need not be an ancestor of old_file's pool.
* @remark After calling this function, old_file may not be used
*/
APR_DECLARE(apr_status_t) apr_file_setaside(apr_file_t **new_file,
apr_file_t *old_file,
apr_pool_t *p);
/**
* Move the read/write file offset to a specified byte within a file.
* @param thefile The file descriptor
* @param where How to move the pointer, one of:
* <PRE>
* APR_SET -- set the offset to offset
* APR_CUR -- add the offset to the current position
* APR_END -- add the offset to the current file size
* </PRE>
* @param offset The offset to move the pointer to.
* @remark The third argument is modified to be the offset the pointer
was actually moved to.
*/
APR_DECLARE(apr_status_t) apr_file_seek(apr_file_t *thefile,
apr_seek_where_t where,
apr_off_t *offset);
/**
* Create an anonymous pipe.
* @param in The file descriptor to use as input to the pipe.
* @param out The file descriptor to use as output from the pipe.
* @param cont The pool to operate on.
*/
APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out,
apr_pool_t *cont);
/**
* Create a named pipe.
* @param filename The filename of the named pipe
* @param perm The permissions for the newly created pipe.
* @param cont The pool to operate on.
*/
APR_DECLARE(apr_status_t) apr_file_namedpipe_create(const char *filename,
apr_fileperms_t perm,
apr_pool_t *cont);
/**
* Get the timeout value for a pipe or manipulate the blocking state.
* @param thepipe The pipe we are getting a timeout for.
* @param timeout The current timeout value in microseconds.
*/
APR_DECLARE(apr_status_t) apr_file_pipe_timeout_get(apr_file_t *thepipe,
apr_interval_time_t *timeout);
/**
* Set the timeout value for a pipe or manipulate the blocking state.
* @param thepipe The pipe we are setting a timeout on.
* @param timeout The timeout value in microseconds. Values < 0 mean wait
* forever, 0 means do not wait at all.
*/
APR_DECLARE(apr_status_t) apr_file_pipe_timeout_set(apr_file_t *thepipe,
apr_interval_time_t timeout);
/** file (un)locking functions. */
/**
* Establish a lock on the specified, open file. The lock may be advisory
* or mandatory, at the discretion of the platform. The lock applies to
* the file as a whole, rather than a specific range. Locks are established
* on a per-thread/process basis; a second lock by the same thread will not
* block.
* @param thefile The file to lock.
* @param type The type of lock to establish on the file.
*/
APR_DECLARE(apr_status_t) apr_file_lock(apr_file_t *thefile, int type);
/**
* Remove any outstanding locks on the file.
* @param thefile The file to unlock.
*/
APR_DECLARE(apr_status_t) apr_file_unlock(apr_file_t *thefile);
/**accessor and general file_io functions. */
/**
* return the file name of the current file.
* @param new_path The path of the file.
* @param thefile The currently open file.
*/
APR_DECLARE(apr_status_t) apr_file_name_get(const char **new_path,
apr_file_t *thefile);
/**
* Return the data associated with the current file.
* @param data The user data associated with the file.
* @param key The key to use for retreiving data associated with this file.
* @param file The currently open file.
*/
APR_DECLARE(apr_status_t) apr_file_data_get(void **data, const char *key,
apr_file_t *file);
/**
* Set the data associated with the current file.
* @param file The currently open file.
* @param data The user data to associate with the file.
* @param key The key to use for assocaiteing data with the file.
* @param cleanup The cleanup routine to use when the file is destroyed.
*/
APR_DECLARE(apr_status_t) apr_file_data_set(apr_file_t *file, void *data,
const char *key,
apr_status_t (*cleanup)(void *));
/**
* Write a string to a file using a printf format.
* @param fptr The file to write to.
* @param format The format string
* @param ... The values to substitute in the format string
* @return The number of bytes written
*/
APR_DECLARE_NONSTD(int) apr_file_printf(apr_file_t *fptr,
const char *format, ...)
__attribute__((format(printf,2,3)));
/**
* set the specified file's permission bits.
* @param fname The file (name) to apply the permissions to.
* @param perms The permission bits to apply to the file.
* @warning Some platforms may not be able to apply all of the available
* permission bits; APR_INCOMPLETE will be returned if some permissions
* are specified which could not be set.
*
* Platforms which do not implement this feature will return APR_ENOTIMPL.
*/
APR_DECLARE(apr_status_t) apr_file_perms_set(const char *fname,
apr_fileperms_t perms);
/**
* Set attributes of the specified file.
* @param fname The full path to the file (using / on all systems)
* @param attributes Or'd combination of
* <PRE>
* APR_FILE_ATTR_READONLY - make the file readonly
* APR_FILE_ATTR_EXECUTABLE - make the file executable
* APR_FILE_ATTR_HIDDEN - make the file hidden
* </PRE>
* @param attr_mask Mask of valid bits in attributes.
* @param cont the pool to use.
* @remark This function should be used in preference to explict manipulation
* of the file permissions, because the operations to provide these
* attributes are platform specific and may involve more than simply
* setting permission bits.
* @warning Platforms which do not implement this feature will return
* APR_ENOTIMPL.
*/
APR_DECLARE(apr_status_t) apr_file_attrs_set(const char *fname,
apr_fileattrs_t attributes,
apr_fileattrs_t attr_mask,
apr_pool_t *cont);
/**
* Set the mtime of the specified file.
* @param fname The full path to the file (using / on all systems)
* @param mtime The mtime to apply to the file.
* @param pool The pool to use.
* @warning Platforms which do not implement this feature will return
* APR_ENOTIMPL.
*/
APR_DECLARE(apr_status_t) apr_file_mtime_set(const char *fname,
apr_time_t mtime,
apr_pool_t *pool);
/**
* Create a new directory on the file system.
* @param path the path for the directory to be created. (use / on all systems)
* @param perm Permissions for the new direcoty.
* @param cont the pool to use.
*/
APR_DECLARE(apr_status_t) apr_dir_make(const char *path, apr_fileperms_t perm,
apr_pool_t *cont);
/** Creates a new directory on the file system, but behaves like
* 'mkdir -p'. Creates intermediate directories as required. No error
* will be reported if PATH already exists.
* @param path the path for the directory to be created. (use / on all systems)
* @param perm Permissions for the new direcoty.
* @param pool the pool to use.
*/
APR_DECLARE(apr_status_t) apr_dir_make_recursive(const char *path,
apr_fileperms_t perm,
apr_pool_t *pool);
/**
* Remove directory from the file system.
* @param path the path for the directory to be removed. (use / on all systems)
* @param cont the pool to use.
*/
APR_DECLARE(apr_status_t) apr_dir_remove(const char *path, apr_pool_t *cont);
/**
* get the specified file's stats.
* @param finfo Where to store the information about the file.
* @param wanted The desired apr_finfo_t fields, as a bit flag of APR_FINFO_ values
* @param thefile The file to get information about.
*/
APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo,
apr_int32_t wanted,
apr_file_t *thefile);
/**
* Truncate the file's length to the specified offset
* @param fp The file to truncate
* @param offset The offset to truncate to.
*/
APR_DECLARE(apr_status_t) apr_file_trunc(apr_file_t *fp, apr_off_t offset);
/**
* Retrieve the flags that were passed into apr_file_open()
* when the file was opened.
* @return apr_int32_t the flags
*/
APR_DECLARE(apr_int32_t) apr_file_flags_get(apr_file_t *f);
/**
* Get the pool used by the file.
*/
APR_POOL_DECLARE_ACCESSOR(file);
/**
* Set a file to be inherited by child processes.
*
*/
APR_DECLARE_INHERIT_SET(file);
/** @deprecated @see apr_file_inherit_set */
APR_DECLARE(void) apr_file_set_inherit(apr_file_t *file);
/**
* Unset a file from being inherited by child processes.
*/
APR_DECLARE_INHERIT_UNSET(file);
/** @deprecated @see apr_file_inherit_unset */
APR_DECLARE(void) apr_file_unset_inherit(apr_file_t *file);
/**
* Open a temporary file
* @param fp The apr file to use as a temporary file.
* @param templ The template to use when creating a temp file.
* @param flags The flags to open the file with. If this is zero,
* the file is opened with
* APR_CREATE | APR_READ | APR_WRITE | APR_EXCL | APR_DELONCLOSE
* @param p The pool to allocate the file out of.
* @remark
* This function generates a unique temporary file name from template.
* The last six characters of template must be XXXXXX and these are replaced
* with a string that makes the filename unique. Since it will be modified,
* template must not be a string constant, but should be declared as a character
* array.
*
*/
APR_DECLARE(apr_status_t) apr_file_mktemp(apr_file_t **fp, char *templ,
apr_int32_t flags, apr_pool_t *p);
/**
* Find an existing directory suitable as a temporary storage location.
* @param temp_dir The temp directory.
* @param p The pool to use for any necessary allocations.
* @remark
* This function uses an algorithm to search for a directory that an
* an application can use for temporary storage. Once such a
* directory is found, that location is cached by the library. Thus,
* callers only pay the cost of this algorithm once if that one time
* is successful.
*
*/
APR_DECLARE(apr_status_t) apr_temp_dir_get(const char **temp_dir,
apr_pool_t *p);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_FILE_IO_H */
--- NEW FILE: apr_file_info.h ---
/* 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_FILE_INFO_H
#define APR_FILE_INFO_H
/**
* @file apr_file_info.h
* @brief APR File Information
*/
#include "apr.h"
#include "apr_user.h"
#include "apr_pools.h"
#include "apr_tables.h"
#include "apr_time.h"
#include "apr_errno.h"
#if APR_HAVE_SYS_UIO_H
#include <sys/uio.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_file_info File Information
* @ingroup APR
* @{
*/
/* Many applications use the type member to determine the
* existance of a file or initialization of the file info,
* so the APR_NOFILE value must be distinct from APR_UNKFILE.
*/
/** apr_filetype_e values for the filetype member of the
* apr_file_info_t structure
* @warning: Not all of the filetypes below can be determined.
* For example, a given platform might not correctly report
* a socket descriptor as APR_SOCK if that type isn't
* well-identified on that platform. In such cases where
* a filetype exists but cannot be described by the recognized
* flags below, the filetype will be APR_UNKFILE. If the
* filetype member is not determined, the type will be APR_NOFILE.
*/
typedef enum {
APR_NOFILE = 0, /**< no file type determined */
APR_REG, /**< a regular file */
APR_DIR, /**< a directory */
APR_CHR, /**< a character device */
APR_BLK, /**< a block device */
APR_PIPE, /**< a FIFO / pipe */
APR_LNK, /**< a symbolic link */
APR_SOCK, /**< a [unix domain] socket */
APR_UNKFILE = 127 /**< a file of some other unknown type */
} apr_filetype_e;
/**
* @defgroup apr_file_permissions File Permissions flags
* @{
*/
#define APR_USETID 0x8000 /**< Set user id */
#define APR_UREAD 0x0400 /**< Read by user */
#define APR_UWRITE 0x0200 /**< Write by user */
#define APR_UEXECUTE 0x0100 /**< Execute by user */
#define APR_GSETID 0x4000 /**< Set group id */
#define APR_GREAD 0x0040 /**< Read by group */
#define APR_GWRITE 0x0020 /**< Write by group */
#define APR_GEXECUTE 0x0010 /**< Execute by group */
#define APR_WSTICKY 0x2000 /**< Sticky bit */
#define APR_WREAD 0x0004 /**< Read by others */
#define APR_WWRITE 0x0002 /**< Write by others */
#define APR_WEXECUTE 0x0001 /**< Execute by others */
#define APR_OS_DEFAULT 0x0FFF /**< use OS's default permissions */
/* additional permission flags for apr_file_copy and apr_file_append */
#define APR_FILE_SOURCE_PERMS 0x1000 /**< Copy source file's permissions */
/** @} */
/**
* Structure for referencing directories.
*/
typedef struct apr_dir_t apr_dir_t;
/**
* Structure for determining file permissions.
*/
typedef apr_int32_t apr_fileperms_t;
#if (defined WIN32) || (defined NETWARE)
/**
* Structure for determining the inode of the file.
*/
typedef apr_uint64_t apr_ino_t;
/**
* Structure for determining the device the file is on.
*/
typedef apr_uint32_t apr_dev_t;
#else
/** The inode of the file. */
typedef ino_t apr_ino_t;
/**
* Structure for determining the device the file is on.
*/
typedef dev_t apr_dev_t;
#endif
/**
* @defgroup apr_file_stat Stat Functions
* @{
*/
/** file info structure */
typedef struct apr_finfo_t apr_finfo_t;
#define APR_FINFO_LINK 0x00000001 /**< Stat the link not the file itself if it is a link */
#define APR_FINFO_MTIME 0x00000010 /**< Modification Time */
#define APR_FINFO_CTIME 0x00000020 /**< Creation Time */
#define APR_FINFO_ATIME 0x00000040 /**< Access Time */
#define APR_FINFO_SIZE 0x00000100 /**< Size of the file */
#define APR_FINFO_CSIZE 0x00000200 /**< Storage size consumed by the file */
#define APR_FINFO_DEV 0x00001000 /**< Device */
#define APR_FINFO_INODE 0x00002000 /**< Inode */
#define APR_FINFO_NLINK 0x00004000 /**< Number of links */
#define APR_FINFO_TYPE 0x00008000 /**< Type */
#define APR_FINFO_USER 0x00010000 /**< User */
#define APR_FINFO_GROUP 0x00020000 /**< Group */
#define APR_FINFO_UPROT 0x00100000 /**< User protection bits */
#define APR_FINFO_GPROT 0x00200000 /**< Group protection bits */
#define APR_FINFO_WPROT 0x00400000 /**< World protection bits */
#define APR_FINFO_ICASE 0x01000000 /**< if dev is case insensitive */
#define APR_FINFO_NAME 0x02000000 /**< ->name in proper case */
#define APR_FINFO_MIN 0x00008170 /**< type, mtime, ctime, atime, size */
#define APR_FINFO_IDENT 0x00003000 /**< dev and inode */
#define APR_FINFO_OWNER 0x00030000 /**< user and group */
#define APR_FINFO_PROT 0x00700000 /**< all protections */
#define APR_FINFO_NORM 0x0073b170 /**< an atomic unix apr_stat() */
#define APR_FINFO_DIRENT 0x02000000 /**< an atomic unix apr_dir_read() */
/**
* The file information structure. This is analogous to the POSIX
* stat structure.
*/
struct apr_finfo_t {
/** Allocates memory and closes lingering handles in the specified pool */
apr_pool_t *pool;
/** The bitmask describing valid fields of this apr_finfo_t structure
* including all available 'wanted' fields and potentially more */
apr_int32_t valid;
/** The access permissions of the file. Mimics Unix access rights. */
apr_fileperms_t protection;
/** The type of file. One of APR_REG, APR_DIR, APR_CHR, APR_BLK, APR_PIPE,
* APR_LNK or APR_SOCK. If the type is undetermined, the value is APR_NOFILE.
* If the type cannot be determined, the value is APR_UNKFILE.
*/
apr_filetype_e filetype;
/** The user id that owns the file */
apr_uid_t user;
/** The group id that owns the file */
apr_gid_t group;
/** The inode of the file. */
apr_ino_t inode;
/** The id of the device the file is on. */
apr_dev_t device;
/** The number of hard links to the file. */
apr_int32_t nlink;
/** The size of the file */
apr_off_t size;
/** The storage size consumed by the file */
apr_off_t csize;
/** The time the file was last accessed */
apr_time_t atime;
/** The time the file was last modified */
apr_time_t mtime;
/** The time the file was last changed */
apr_time_t ctime;
/** The pathname of the file (possibly unrooted) */
const char *fname;
/** The file's name (no path) in filesystem case */
const char *name;
/** The file's handle, if accessed (can be submitted to apr_duphandle) */
struct apr_file_t *filehand;
};
/**
* get the specified file's stats. The file is specified by filename,
* instead of using a pre-opened file.
* @param finfo Where to store the information about the file, which is
* never touched if the call fails.
* @param fname The name of the file to stat.
* @param wanted The desired apr_finfo_t fields, as a bit flag of APR_FINFO_
values
* @param cont the pool to use to allocate the new file.
*
* @note If @c APR_INCOMPLETE is returned all the fields in @a finfo may
* not be filled in, and you need to check the @c finfo->valid bitmask
* to verify that what you're looking for is there.
*/
APR_DECLARE(apr_status_t) apr_stat(apr_finfo_t *finfo, const char *fname,
apr_int32_t wanted, apr_pool_t *cont);
/**
* get the specified file's stats. The file is specified by filename,
* instead of using a pre-opened file. If the file is a symlink, this function
* will get the stats for the symlink not the file the symlink refers to.
* @param finfo Where to store the information about the file, which is
* never touched if the call fails.
* @param fname The name of the file to stat.
* @param wanted The desired apr_finfo_t fields, as a bit flag of APR_FINFO_ values
* @param cont the pool to use to allocate the new file.
* @deprecated This function is deprecated, it's equivalent to calling apr_stat with
* the wanted flag value APR_FINFO_LINK
*/
APR_DECLARE(apr_status_t) apr_lstat(apr_finfo_t *finfo, const char *fname,
apr_int32_t wanted, apr_pool_t *cont);
/** @} */
/**
* @defgroup apr_dir Directory Manipulation Functions
* @{
*/
/**
* Open the specified directory.
* @param new_dir The opened directory descriptor.
* @param dirname The full path to the directory (use / on all systems)
* @param cont The pool to use.
*/
APR_DECLARE(apr_status_t) apr_dir_open(apr_dir_t **new_dir,
const char *dirname,
apr_pool_t *cont);
/**
* close the specified directory.
* @param thedir the directory descriptor to close.
*/
APR_DECLARE(apr_status_t) apr_dir_close(apr_dir_t *thedir);
/**
* Read the next entry from the specified directory.
* @param finfo the file info structure and filled in by apr_dir_read
* @param wanted The desired apr_finfo_t fields, as a bit flag of APR_FINFO_
values
* @param thedir the directory descriptor returned from apr_dir_open
* @remark No ordering is guaranteed for the entries read.
*
* @note If @c APR_INCOMPLETE is returned all the fields in @a finfo may
* not be filled in, and you need to check the @c finfo->valid bitmask
* to verify that what you're looking for is there.
*/
APR_DECLARE(apr_status_t) apr_dir_read(apr_finfo_t *finfo, apr_int32_t wanted,
apr_dir_t *thedir);
/**
* Rewind the directory to the first entry.
* @param thedir the directory descriptor to rewind.
*/
APR_DECLARE(apr_status_t) apr_dir_rewind(apr_dir_t *thedir);
/** @} */
/**
* @defgroup apr_filepath Filepath Manipulation Functions
* @{
*/
/** Cause apr_filepath_merge to fail if addpath is above rootpath */
#define APR_FILEPATH_NOTABOVEROOT 0x01
/** internal: Only meaningful with APR_FILEPATH_NOTABOVEROOT */
#define APR_FILEPATH_SECUREROOTTEST 0x02
/** Cause apr_filepath_merge to fail if addpath is above rootpath,
* even given a rootpath /foo/bar and an addpath ../bar/bash
*/
#define APR_FILEPATH_SECUREROOT 0x03
/** Fail apr_filepath_merge if the merged path is relative */
#define APR_FILEPATH_NOTRELATIVE 0x04
/** Fail apr_filepath_merge if the merged path is absolute */
#define APR_FILEPATH_NOTABSOLUTE 0x08
/** Return the file system's native path format (e.g. path delimiters
* of ':' on MacOS9, '\' on Win32, etc.) */
#define APR_FILEPATH_NATIVE 0x10
/** Resolve the true case of existing directories and file elements
* of addpath, (resolving any aliases on Win32) and append a proper
* trailing slash if a directory
*/
#define APR_FILEPATH_TRUENAME 0x20
/**
* Extract the rootpath from the given filepath
* @param rootpath the root file path returned with APR_SUCCESS or APR_EINCOMPLETE
* @param filepath the pathname to parse for its root component
* @param flags the desired rules to apply, from
* <PRE>
* APR_FILEPATH_NATIVE Use native path seperators (e.g. '\' on Win32)
* APR_FILEPATH_TRUENAME Tests that the root exists, and makes it proper
* </PRE>
* @param p the pool to allocate the new path string from
* @remark on return, filepath points to the first non-root character in the
* given filepath. In the simplest example, given a filepath of "/foo",
* returns the rootpath of "/" and filepath points at "foo". This is far
* more complex on other platforms, which will canonicalize the root form
* to a consistant format, given the APR_FILEPATH_TRUENAME flag, and also
* test for the validity of that root (e.g., that a drive d:/ or network
* share //machine/foovol/).
* The function returns APR_ERELATIVE if filepath isn't rooted (an
* error), APR_EINCOMPLETE if the root path is ambigious (but potentially
* legitimate, e.g. "/" on Windows is incomplete because it doesn't specify
* the drive letter), or APR_EBADPATH if the root is simply invalid.
* APR_SUCCESS is returned if filepath is an absolute path.
*/
APR_DECLARE(apr_status_t) apr_filepath_root(const char **rootpath,
const char **filepath,
apr_int32_t flags,
apr_pool_t *p);
/**
* Merge additional file path onto the previously processed rootpath
* @param newpath the merged paths returned
* @param rootpath the root file path (NULL uses the current working path)
* @param addpath the path to add to the root path
* @param flags the desired APR_FILEPATH_ rules to apply when merging
* @param p the pool to allocate the new path string from
* @remark if the flag APR_FILEPATH_TRUENAME is given, and the addpath
* contains wildcard characters ('*', '?') on platforms that don't support
* such characters within filenames, the paths will be merged, but the
* result code will be APR_EPATHWILD, and all further segments will not
* reflect the true filenames including the wildcard and following segments.
*/
APR_DECLARE(apr_status_t) apr_filepath_merge(char **newpath,
const char *rootpath,
const char *addpath,
apr_int32_t flags,
apr_pool_t *p);
/**
* Split a search path into separate components
* @param pathelts the returned components of the search path
* @param liststr the search path (e.g., <tt>getenv("PATH")</tt>)
* @param p the pool to allocate the array and path components from
* @remark empty path componenta do not become part of @a pathelts.
* @remark the path separator in @a liststr is system specific;
* e.g., ':' on Unix, ';' on Windows, etc.
*/
APR_DECLARE(apr_status_t) apr_filepath_list_split(apr_array_header_t **pathelts,
const char *liststr,
apr_pool_t *p);
/**
* Merge a list of search path components into a single search path
* @param liststr the returned search path; may be NULL if @a pathelts is empty
* @param pathelts the components of the search path
* @param p the pool to allocate the search path from
* @remark emtpy strings in the source array are ignored.
* @remark the path separator in @a liststr is system specific;
* e.g., ':' on Unix, ';' on Windows, etc.
*/
APR_DECLARE(apr_status_t) apr_filepath_list_merge(char **liststr,
apr_array_header_t *pathelts,
apr_pool_t *p);
/**
* Return the default file path (for relative file names)
* @param path the default path string returned
* @param flags optional flag APR_FILEPATH_NATIVE to retrieve the
* default file path in os-native format.
* @param p the pool to allocate the default path string from
*/
APR_DECLARE(apr_status_t) apr_filepath_get(char **path, apr_int32_t flags,
apr_pool_t *p);
/**
* Set the default file path (for relative file names)
* @param path the default path returned
* @param p the pool to allocate any working storage
*/
APR_DECLARE(apr_status_t) apr_filepath_set(const char *path, apr_pool_t *p);
/** The FilePath character encoding is unknown */
#define APR_FILEPATH_ENCODING_UNKNOWN 0
/** The FilePath character encoding is locale-dependent */
#define APR_FILEPATH_ENCODING_LOCALE 1
/** The FilePath character encoding is UTF-8 */
#define APR_FILEPATH_ENCODING_UTF8 2
/**
* Determine the encoding used internally by the FilePath functions
* @param style points to a variable which receives the encoding style flag
* @param p the pool to allocate any working storage
* @remark Use @c apr_os_locale_encoding and/or @c apr_os_default_encoding
* to get the name of the path encoding if it's not UTF-8.
*/
APR_DECLARE(apr_status_t) apr_filepath_encoding(int *style, apr_pool_t *p);
/** @} */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_FILE_INFO_H */
--- NEW FILE: apr_getopt.h ---
/* 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_GETOPT_H
#define APR_GETOPT_H
/**
* @file apr_getopt.h
* @brief APR Command Arguments (getopt)
*/
#include "apr_pools.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_getopt Command Argument Parsing
* @ingroup APR
* @{
*/
/**
* defintion of a error function
*/
typedef void (apr_getopt_err_fn_t)(void *arg, const char *err, ...);
/** @see apr_getopt_t */
typedef struct apr_getopt_t apr_getopt_t;
/**
* Structure to store command line argument information.
*/
struct apr_getopt_t {
/** context for processing */
apr_pool_t *cont;
/** function to print error message (NULL == no messages) */
apr_getopt_err_fn_t *errfn;
/** user defined first arg to pass to error message */
void *errarg;
/** index into parent argv vector */
int ind;
/** character checked for validity */
int opt;
/** reset getopt */
int reset;
/** count of arguments */
int argc;
/** array of pointers to arguments */
const char **argv;
/** argument associated with option */
char const* place;
/** set to nonzero to support interleaving options with regular args */
int interleave;
/** start of non-option arguments skipped for interleaving */
int skip_start;
/** end of non-option arguments skipped for interleaving */
int skip_end;
};
/** @see apr_getopt_option_t */
typedef struct apr_getopt_option_t apr_getopt_option_t;
/**
* Structure used to describe options that getopt should search for.
*/
struct apr_getopt_option_t {
/** long option name, or NULL if option has no long name */
const char *name;
/** option letter, or a value greater than 255 if option has no letter */
int optch;
/** nonzero if option takes an argument */
int has_arg;
/** a description of the option */
const char *description;
};
/**
* Initialize the arguments for parsing by apr_getopt().
* @param os The options structure created for apr_getopt()
* @param cont The pool to operate on
* @param argc The number of arguments to parse
* @param argv The array of arguments to parse
* @remark Arguments 2 and 3 are most commonly argc and argv from main(argc, argv)
* The errfn is initialized to fprintf(stderr... but may be overridden.
*/
APR_DECLARE(apr_status_t) apr_getopt_init(apr_getopt_t **os, apr_pool_t *cont,
int argc, const char * const *argv);
/**
* Parse the options initialized by apr_getopt_init().
* @param os The apr_opt_t structure returned by apr_getopt_init()
* @param opts A string of characters that are acceptable options to the
* program. Characters followed by ":" are required to have an
* option associated
* @param option_ch The next option character parsed
* @param option_arg The argument following the option character:
* @return There are four potential status values on exit. They are:
* <PRE>
* APR_EOF -- No more options to parse
* APR_BADCH -- Found a bad option character
* APR_BADARG -- No argument followed the option flag
* APR_SUCCESS -- The next option was found.
* </PRE>
*/
APR_DECLARE(apr_status_t) apr_getopt(apr_getopt_t *os, const char *opts,
char *option_ch, const char **option_arg);
/**
* Parse the options initialized by apr_getopt_init(), accepting long
* options beginning with "--" in addition to single-character
* options beginning with "-".
* @param os The apr_getopt_t structure created by apr_getopt_init()
* @param opts A pointer to a list of apr_getopt_option_t structures, which
* can be initialized with { "name", optch, has_args }. has_args
* is nonzero if the option requires an argument. A structure
* with an optch value of 0 terminates the list.
* @param option_ch Receives the value of "optch" from the apr_getopt_option_t
* structure corresponding to the next option matched.
* @param option_arg Receives the argument following the option, if any.
* @return There are four potential status values on exit. They are:
* <PRE>
* APR_EOF -- No more options to parse
* APR_BADCH -- Found a bad option character
* APR_BADARG -- No argument followed the option flag
* APR_SUCCESS -- The next option was found.
* </PRE>
* When APR_SUCCESS is returned, os->ind gives the index of the first
* non-option argument. On error, a message will be printed to stdout unless
* os->err is set to 0. If os->interleave is set to nonzero, options can come
* after arguments, and os->argv will be permuted to leave non-option arguments
* at the end (the original argv is unaffected).
*/
APR_DECLARE(apr_status_t) apr_getopt_long(apr_getopt_t *os,
const apr_getopt_option_t *opts,
int *option_ch,
const char **option_arg);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_GETOPT_H */
--- NEW FILE: apr_version.h ---
/* 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_VERSION_H
#define APR_VERSION_H
#include "apr.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @file apr_version.h
* @brief APR Versioning Interface
*
* APR'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 APR by use of the compile-time
* constants and the use of the run-time query function.
*
* APR 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 APR.
*/
/** 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 APR_MAJOR_VERSION 0
/**
* Minor API changes that do not cause binary compatibility problems.
* Should be reset to 0 when upgrading APR_MAJOR_VERSION
*/
#define APR_MINOR_VERSION 9
/** patch level */
#define APR_PATCH_VERSION 12
/**
* This symbol is defined for internal, "development" copies of APR. This
* symbol will be #undef'd for releases.
*/
#undef APR_IS_DEV_VERSION
/** The formatted string of APR's version */
#define APR_VERSION_STRING \
APR_STRINGIFY(APR_MAJOR_VERSION) "." \
APR_STRINGIFY(APR_MINOR_VERSION) "." \
APR_STRINGIFY(APR_PATCH_VERSION) \
APR_IS_DEV_STRING
/**
* The numeric version information is broken out into fields within this
* structure.
*/
typedef struct {
int major; /**< major number */
int minor; /**< minor number */
int patch; /**< patch number */
int is_dev; /**< is development (1 or 0) */
} apr_version_t;
/**
* Return APR's version information information in a numeric form.
*
* @param pvsn Pointer to a version structure for returning the version
* information.
*/
APR_DECLARE(void) apr_version(apr_version_t *pvsn);
/** Return APR's version information as a string. */
APR_DECLARE(const char *) apr_version_string(void);
/** Internal: string form of the "is dev" flag */
#ifdef APR_IS_DEV_VERSION
#define APR_IS_DEV_STRING "-dev"
#else
#define APR_IS_DEV_STRING ""
#endif
#ifdef __cplusplus
}
#endif
#endif /* APR_VERSION_H */
--- NEW FILE: apr_allocator.h ---
/* 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_ALLOCATOR_H
#define APR_ALLOCATOR_H
/**
* @file apr_allocator.h
* @brief APR Internal Memory Allocation
*/
#include "apr.h"
#include "apr_errno.h"
#define APR_WANT_MEMFUNC /**< For no good reason? */
#include "apr_want.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup apr_allocator Internal Memory Allocation
* @ingroup APR
* @{
*/
/** the allocator structure */
typedef struct apr_allocator_t apr_allocator_t;
/** the structure which holds information about the allocation */
typedef struct apr_memnode_t apr_memnode_t;
/** basic memory node structure */
struct apr_memnode_t {
apr_memnode_t *next; /**< next memnode */
apr_memnode_t **ref; /**< reference to self */
apr_uint32_t index; /**< size */
apr_uint32_t free_index; /**< how much free */
char *first_avail; /**< pointer to first free memory */
char *endp; /**< pointer to end of free memory */
};
/** The base size of a memory node - aligned. */
#define APR_MEMNODE_T_SIZE APR_ALIGN_DEFAULT(sizeof(apr_memnode_t))
/** Symbolic constants */
#define APR_ALLOCATOR_MAX_FREE_UNLIMITED 0
/**
* Create a new allocator
* @param allocator The allocator we have just created.
*
*/
APR_DECLARE(apr_status_t) apr_allocator_create(apr_allocator_t **allocator);
/**
* Destroy an allocator
* @param allocator The allocator to be destroyed
* @remark Any memnodes not given back to the allocator prior to destroying
* will _not_ be free()d.
*/
APR_DECLARE(void) apr_allocator_destroy(apr_allocator_t *allocator);
/**
* Allocate a block of mem from the allocator
* @param allocator The allocator to allocate from
* @param size The size of the mem to allocate (excluding the
* memnode structure)
*/
APR_DECLARE(apr_memnode_t *) apr_allocator_alloc(apr_allocator_t *allocator,
apr_size_t size);
/**
* Free a block of mem, giving it back to the allocator
* @param allocator The allocator to give the mem back to
* @param memnode The memory node to return
*/
APR_DECLARE(void) apr_allocator_free(apr_allocator_t *allocator,
apr_memnode_t *memnode);
#include "apr_pools.h"
/**
* Set the owner of the allocator
* @param allocator The allocator to set the owner for
* @param pool The pool that is to own the allocator
* @remark Typically pool is the highest level pool using the allocator
*/
/*
* XXX: see if we can come up with something a bit better. Currently
* you can make a pool an owner, but if the pool doesn't use the allocator
* the allocator will never be destroyed.
*/
APR_DECLARE(void) apr_allocator_owner_set(apr_allocator_t *allocator,
apr_pool_t *pool);
/** @deprecated @see apr_allocator_owner_set */
APR_DECLARE(void) apr_allocator_set_owner(apr_allocator_t *allocator,
apr_pool_t *pool);
/**
* Get the current owner of the allocator
* @param allocator The allocator to get the owner from
*/
APR_DECLARE(apr_pool_t *) apr_allocator_owner_get(apr_allocator_t *allocator);
/** @deprecated @see apr_allocator_owner_get */
APR_DECLARE(apr_pool_t *) apr_allocator_get_owner(
apr_allocator_t *allocator);
/**
* Set the current threshold at which the allocator should start
* giving blocks back to the system.
* @param allocator The allocator the set the threshold on
* @param size The threshold. 0 == unlimited.
*/
APR_DECLARE(void) apr_allocator_max_free_set(apr_allocator_t *allocator,
apr_size_t size);
/** @deprecated @see apr_allocator_max_free_set */
APR_DECLARE(void) apr_allocator_set_max_free(apr_allocator_t *allocator,
apr_size_t size);
#include "apr_thread_mutex.h"
#if APR_HAS_THREADS
/**
* Set a mutex for the allocator to use
* @param allocator The allocator to set the mutex for
* @param mutex The mutex
*/
APR_DECLARE(void) apr_allocator_mutex_set(apr_allocator_t *allocator,
apr_thread_mutex_t *mutex);
/** @deprecated @see apr_allocator_mutex_set */
APR_DECLARE(void) apr_allocator_set_mutex(apr_allocator_t *allocator,
apr_thread_mutex_t *mutex);
/**
* Get the mutex currently set for the allocator
* @param allocator The allocator
*/
APR_DECLARE(apr_thread_mutex_t *) apr_allocator_mutex_get(
apr_allocator_t *allocator);
/** @deprecated @see apr_allocator_mutex_get */
APR_DECLARE(apr_thread_mutex_t *) apr_allocator_get_mutex(
apr_allocator_t *allocator);
#endif /* APR_HAS_THREADS */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_ALLOCATOR_H */
--- NEW FILE: apr.h.in ---
/* 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_H
#define APR_H
/* GENERATED FILE WARNING! DO NOT EDIT apr.h
*
* You must modify apr.h.in instead.
*
* And please, make an effort to stub apr.hw and apr.hnw in the process.
*/
/**
* @file apr.h
* @brief APR Platform Definitions
* @remark This is a generated header generated from include/apr.h.in by
* ./configure, or copied from include/apr.hw or include/apr.hnw
* for Win32 or Netware by those build environments, respectively.
*/
/**
* @defgroup APR Apache Portability Runtime library
* @{
*/
/**
* @defgroup apr_platform Platform Definitions
* @{
*/
/* So that we can use inline on some critical functions, and use
* GNUC attributes (such as to get -Wall warnings for printf-like
* functions). Only do this in gcc 2.7 or later ... it may work
* on earlier stuff, but why chance it.
*
* We've since discovered that the gcc shipped with NeXT systems
* as "cc" is completely broken. It claims to be __GNUC__ and so
* on, but it doesn't implement half of the things that __GNUC__
* means. In particular it's missing inline and the __attribute__
* stuff. So we hack around it. PR#1613. -djg
*/
#if !defined(__GNUC__) || __GNUC__ < 2 || \
(__GNUC__ == 2 && __GNUC_MINOR__ < 7) ||\
defined(NEXT)
#ifndef __attribute__
#define __attribute__(__x)
#endif
#define APR_INLINE
#define APR_HAS_INLINE 0
#else
#define APR_INLINE __inline__
#define APR_HAS_INLINE 1
#endif
#define APR_HAVE_ARPA_INET_H @arpa_ineth@
#define APR_HAVE_CONIO_H @conioh@
#define APR_HAVE_CRYPT_H @crypth@
#define APR_HAVE_CTYPE_H @ctypeh@
#define APR_HAVE_DIRENT_H @direnth@
#define APR_HAVE_ERRNO_H @errnoh@
#define APR_HAVE_FCNTL_H @fcntlh@
#define APR_HAVE_IO_H @ioh@
#define APR_HAVE_LIMITS_H @limitsh@
#define APR_HAVE_NETDB_H @netdbh@
#define APR_HAVE_NETINET_IN_H @netinet_inh@
#define APR_HAVE_NETINET_SCTP_H @netinet_sctph@
#define APR_HAVE_NETINET_SCTP_UIO_H @netinet_sctp_uioh@
#define APR_HAVE_NETINET_TCP_H @netinet_tcph@
#define APR_HAVE_PTHREAD_H @pthreadh@
#define APR_HAVE_SEMAPHORE_H @semaphoreh@
#define APR_HAVE_SIGNAL_H @signalh@
#define APR_HAVE_STDARG_H @stdargh@
#define APR_HAVE_STDINT_H @stdint@
#define APR_HAVE_STDIO_H @stdioh@
#define APR_HAVE_STDLIB_H @stdlibh@
#define APR_HAVE_STRING_H @stringh@
#define APR_HAVE_STRINGS_H @stringsh@
#define APR_HAVE_SYS_IOCTL_H @sys_ioctlh@
#define APR_HAVE_SYS_SENDFILE_H @sys_sendfileh@
#define APR_HAVE_SYS_SIGNAL_H @sys_signalh@
#define APR_HAVE_SYS_SOCKET_H @sys_socketh@
#define APR_HAVE_SYS_SOCKIO_H @sys_sockioh@
#define APR_HAVE_SYS_SYSLIMITS_H @sys_syslimitsh@
#define APR_HAVE_SYS_TIME_H @sys_timeh@
#define APR_HAVE_SYS_TYPES_H @sys_typesh@
#define APR_HAVE_SYS_UIO_H @sys_uioh@
#define APR_HAVE_SYS_UN_H @sys_unh@
#define APR_HAVE_SYS_WAIT_H @sys_waith@
#define APR_HAVE_TIME_H @timeh@
#define APR_HAVE_UNISTD_H @unistdh@
/** @} */
/* We don't include our conditional headers within the doxyblocks
* or the extern "C" namespace
*/
#if APR_HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#if APR_HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS)
/* C99 7.18.4 requires that stdint.h only exposes INT64_C
* and UINT64_C for C++ implementations if this is defined: */
#define __STDC_CONSTANT_MACROS
#endif
#if APR_HAVE_STDINT_H
#include <stdint.h>
#endif
#if APR_HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#ifdef OS2
#define INCL_DOS
#define INCL_DOSERRORS
#include <os2.h>
#endif
/* header files for PATH_MAX, _POSIX_PATH_MAX */
#if APR_HAVE_LIMITS_H
#include <limits.h>
#else
#if APR_HAVE_SYS_SYSLIMITS_H
#include <sys/syslimits.h>
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup apr_platform
* @ingroup APR
* @{
*/
#define APR_HAVE_SHMEM_MMAP_TMP @havemmaptmp@
#define APR_HAVE_SHMEM_MMAP_SHM @havemmapshm@
#define APR_HAVE_SHMEM_MMAP_ZERO @havemmapzero@
#define APR_HAVE_SHMEM_SHMGET_ANON @haveshmgetanon@
#define APR_HAVE_SHMEM_SHMGET @haveshmget@
#define APR_HAVE_SHMEM_MMAP_ANON @havemmapanon@
#define APR_HAVE_SHMEM_BEOS @havebeosarea@
#define APR_USE_SHMEM_MMAP_TMP @usemmaptmp@
#define APR_USE_SHMEM_MMAP_SHM @usemmapshm@
#define APR_USE_SHMEM_MMAP_ZERO @usemmapzero@
#define APR_USE_SHMEM_SHMGET_ANON @useshmgetanon@
#define APR_USE_SHMEM_SHMGET @useshmget@
#define APR_USE_SHMEM_MMAP_ANON @usemmapanon@
#define APR_USE_SHMEM_BEOS @usebeosarea@
#define APR_USE_FLOCK_SERIALIZE @flockser@
#define APR_USE_SYSVSEM_SERIALIZE @sysvser@
#define APR_USE_POSIXSEM_SERIALIZE @posixser@
#define APR_USE_FCNTL_SERIALIZE @fcntlser@
#define APR_USE_PROC_PTHREAD_SERIALIZE @procpthreadser@
#define APR_USE_PTHREAD_SERIALIZE @pthreadser@
#define APR_HAS_FLOCK_SERIALIZE @hasflockser@
#define APR_HAS_SYSVSEM_SERIALIZE @hassysvser@
#define APR_HAS_POSIXSEM_SERIALIZE @hasposixser@
#define APR_HAS_FCNTL_SERIALIZE @hasfcntlser@
#define APR_HAS_PROC_PTHREAD_SERIALIZE @hasprocpthreadser@
#define APR_HAS_RWLOCK_SERIALIZE @hasrwlockser@
#define APR_PROCESS_LOCK_IS_GLOBAL @proclockglobal@
#define APR_HAVE_CORKABLE_TCP @have_corkable_tcp@
#define APR_HAVE_GETRLIMIT @have_getrlimit@
#define APR_HAVE_IN_ADDR @have_in_addr@
#define APR_HAVE_INET_ADDR @have_inet_addr@
#define APR_HAVE_INET_NETWORK @have_inet_network@
#define APR_HAVE_IPV6 @have_ipv6@
#define APR_HAVE_MEMMOVE @have_memmove@
#define APR_HAVE_SETRLIMIT @have_setrlimit@
#define APR_HAVE_SIGACTION @have_sigaction@
#define APR_HAVE_SIGSUSPEND @have_sigsuspend@
#define APR_HAVE_SIGWAIT @have_sigwait@
#define APR_HAVE_STRCASECMP @have_strcasecmp@
#define APR_HAVE_STRDUP @have_strdup@
#define APR_HAVE_STRICMP @have_stricmp@
#define APR_HAVE_STRNCASECMP @have_strncasecmp@
#define APR_HAVE_STRNICMP @have_strnicmp@
#define APR_HAVE_STRSTR @have_strstr@
#define APR_HAVE_MEMCHR @have_memchr@
#define APR_HAVE_STRUCT_RLIMIT @struct_rlimit@
#define APR_HAVE_UNION_SEMUN @have_union_semun@
#define APR_HAVE_SCTP @have_sctp@
/* APR Feature Macros */
#define APR_HAS_SHARED_MEMORY @sharedmem@
#define APR_HAS_THREADS @threads@
#define APR_HAS_SENDFILE @sendfile@
#define APR_HAS_MMAP @mmap@
#define APR_HAS_FORK @fork@
#define APR_HAS_RANDOM @rand@
#define APR_HAS_OTHER_CHILD @oc@
#define APR_HAS_DSO @aprdso@
#define APR_HAS_SO_ACCEPTFILTER @acceptfilter@
#define APR_HAS_UNICODE_FS 0
#define APR_HAS_PROC_INVOKED 0
#define APR_HAS_USER 1
#define APR_HAS_LARGE_FILES 0
#define APR_HAS_XTHREAD_FILES 0
#define APR_HAS_OS_UUID 0
/* APR sets APR_FILES_AS_SOCKETS to 1 on systems where it is possible
* to poll on files/pipes. On such a system, the application can
* call apr_socket_from_file() to get an APR socket representation and
* then pass the socket representation to apr_poll_socket_add().
*/
#define APR_FILES_AS_SOCKETS @file_as_socket@
/* Not all platforms have a real INADDR_NONE. This macro replaces INADDR_NONE
* on all platforms.
*/
#define APR_INADDR_NONE @apr_inaddr_none@
/* This macro indicates whether or not EBCDIC is the native character set.
*/
#define APR_CHARSET_EBCDIC @apr_charset_ebcdic@
/* If we have a TCP implementation that can be "corked", what flag
* do we use?
*/
#define APR_TCP_NOPUSH_FLAG @apr_tcp_nopush_flag@
/* Is the TCP_NODELAY socket option inherited from listening sockets?
*/
#define APR_TCP_NODELAY_INHERITED @tcp_nodelay_inherited@
/* Is the O_NONBLOCK flag inherited from listening sockets?
*/
#define APR_O_NONBLOCK_INHERITED @o_nonblock_inherited@
/* Typedefs that APR needs. */
typedef unsigned char apr_byte_t;
typedef @short_value@ apr_int16_t;
typedef unsigned @short_value@ apr_uint16_t;
typedef @int_value@ apr_int32_t;
typedef unsigned @int_value@ apr_uint32_t;
typedef @long_value@ apr_int64_t;
typedef unsigned @long_value@ apr_uint64_t;
typedef @size_t_value@ apr_size_t;
typedef @ssize_t_value@ apr_ssize_t;
typedef @off_t_value@ apr_off_t;
typedef @socklen_t_value@ apr_socklen_t;
#define APR_SIZEOF_VOIDP @voidp_size@
/* Mechanisms to properly type numeric literals */
@int64_literal@
/* Definitions that APR programs need to work properly. */
/**
* Thread callbacks from APR functions must be declared with APR_THREAD_FUNC,
* so that they follow the platform's calling convention.
* @example
*/
/** void* APR_THREAD_FUNC my_thread_entry_fn(apr_thread_t *thd, void *data);
*/
#define APR_THREAD_FUNC
/**
* The public APR functions are declared with APR_DECLARE(), so they may
* use the most appropriate calling convention. Public APR functions with
* variable arguments must use APR_DECLARE_NONSTD().
*
* @remark Both the declaration and implementations must use the same macro.
* @example
*/
/** APR_DECLARE(rettype) apr_func(args)
* @see APR_DECLARE_NONSTD @see APR_DECLARE_DATA
* @remark Note that when APR compiles the library itself, it passes the
* symbol -DAPR_DECLARE_EXPORT to the compiler on some platforms (e.g. Win32)
* to export public symbols from the dynamic library build.\n
* The user must define the APR_DECLARE_STATIC when compiling to target
* the static APR library on some platforms (e.g. Win32.) The public symbols
* are neither exported nor imported when APR_DECLARE_STATIC is defined.\n
* By default, compiling an application and including the APR public
* headers, without defining APR_DECLARE_STATIC, will prepare the code to be
* linked to the dynamic library.
*/
#define APR_DECLARE(type) type
/**
* The public APR functions using variable arguments are declared with
* APR_DECLARE_NONSTD(), as they must follow the C language calling convention.
* @see APR_DECLARE @see APR_DECLARE_DATA
* @remark Both the declaration and implementations must use the same macro.
* @example
*/
/** APR_DECLARE_NONSTD(rettype) apr_func(args, ...);
*/
#define APR_DECLARE_NONSTD(type) type
/**
* The public APR variables are declared with AP_MODULE_DECLARE_DATA.
* This assures the appropriate indirection is invoked at compile time.
* @see APR_DECLARE @see APR_DECLARE_NONSTD
* @remark Note that the declaration and implementations use different forms,
* but both must include the macro.
* @example
*/
/** extern APR_DECLARE_DATA type apr_variable;\n
* APR_DECLARE_DATA type apr_variable = value;
*/
#define APR_DECLARE_DATA
/* Define APR_SSIZE_T_FMT.
* If ssize_t is an integer we define it to be "d",
* if ssize_t is a long int we define it to be "ld",
* if ssize_t is neither we declare an error here.
* I looked for a better way to define this here, but couldn't find one, so
* to find the logic for this definition search for "ssize_t_fmt" in
* configure.in.
*/
@ssize_t_fmt@
/* And APR_SIZE_T_FMT */
@size_t_fmt@
/* And APR_OFF_T_FMT */
@off_t_fmt@
/* And APR_PID_T_FMT */
@pid_t_fmt@
/* And APR_INT64_T_FMT */
@int64_t_fmt@
@int64_t_fmt_len@
/* And APR_UINT64_T_FMT */
@uint64_t_fmt@
@uint64_t_fmt_len@
/* And APR_UINT64_T_HEX_FMT */
@uint64_t_hex_fmt@
#define APR_UINT64_T_HEX_FMT_LEN (sizeof(APR_UINT64_T_HEX_FMT) - 1)
/* Deal with atoi64 variables ... these should move to apr_private.h */
#define APR_HAVE_INT64_STRFN @have_int64_strfn@
#define APR_INT64_STRFN @int64_strfn@
/* are we going to force the generic atomic operations */
#define APR_FORCE_ATOMIC_GENERIC @apr_force_atomic_generic@
/* Does the proc mutex lock threads too */
#define APR_PROC_MUTEX_IS_GLOBAL @proc_mutex_is_global@
/* Local machine definition for console and log output. */
#define APR_EOL_STR "@eolstr@"
#if APR_HAVE_SYS_WAIT_H
#ifdef WEXITSTATUS
#define apr_wait_t int
#else
#define apr_wait_t union wait
#define WEXITSTATUS(status) (int)((status).w_retcode)
#define WTERMSIG(status) (int)((status).w_termsig)
#endif /* !WEXITSTATUS */
#endif /* HAVE_SYS_WAIT_H */
#if defined(PATH_MAX)
#define APR_PATH_MAX PATH_MAX
#elif defined(_POSIX_PATH_MAX)
#define APR_PATH_MAX _POSIX_PATH_MAX
#else
#error no decision has been made on APR_PATH_MAX for your platform
#endif
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* APR_H */
--- NEW FILE: apr_thread_cond.h ---
/* 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_THREAD_COND_H
#define APR_THREAD_COND_H
/**
* @file apr_thread_cond.h
* @brief APR Condition Variable Routines
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#include "apr_time.h"
#include "apr_thread_mutex.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#if APR_HAS_THREADS || defined(DOXYGEN)
/**
* @defgroup apr_thread_cond Condition Variable Routines
* @ingroup APR
* @{
*/
/** Opaque structure for thread condition variables */
typedef struct apr_thread_cond_t apr_thread_cond_t;
/**
* Create and initialize a condition variable that can be used to signal
* and schedule threads in a single process.
* @param cond the memory address where the newly created condition variable
* will be stored.
* @param pool the pool from which to allocate the mutex.
*/
APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
apr_pool_t *pool);
/**
* Put the active calling thread to sleep until signaled to wake up. Each
* condition variable must be associated with a mutex, and that mutex must
* be locked before calling this function, or the behavior will be
* undefined. As the calling thread is put to sleep, the given mutex
* will be simultaneously released; and as this thread wakes up the lock
* is again simultaneously acquired.
* @param cond the condition variable on which to block.
* @param mutex the mutex that must be locked upon entering this function,
* is released while the thread is asleep, and is again acquired before
* returning from this function.
*/
APR_DECLARE(apr_status_t) apr_thread_cond_wait(apr_thread_cond_t *cond,
apr_thread_mutex_t *mutex);
/**
* Put the active calling thread to sleep until signaled to wake up or
* the timeout is reached. Each condition variable must be associated
* with a mutex, and that mutex must be locked before calling this
* function, or the behavior will be undefined. As the calling thread
* is put to sleep, the given mutex will be simultaneously released;
* and as this thread wakes up the lock is again simultaneously acquired.
* @param cond the condition variable on which to block.
* @param mutex the mutex that must be locked upon entering this function,
* is released while the thread is asleep, and is again acquired before
* returning from this function.
* @param timeout The amount of time in microseconds to wait. This is
* a maximum, not a minimum. If the condition is signaled, we
* will wake up before this time, otherwise the error APR_TIMEUP
* is returned.
*/
APR_DECLARE(apr_status_t) apr_thread_cond_timedwait(apr_thread_cond_t *cond,
apr_thread_mutex_t *mutex,
apr_interval_time_t timeout);
/**
* Signals a singla thread, if one exists, that is blocking on the given
* condition variable. That thread is then scheduled to wake up and acquire
* the associated mutex. Although it is not required, if predictible schedule
* is desired, that mutex must be locked while calling this function.
* @param cond the condition variable on which to produce the signal.
*/
APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond);
/**
* Signals all threads blocking on the given condition variable.
* Each thread that was signaled is then schedule to wake up and acquire
* the associated mutex. This will happen in a serialized manner.
* @param cond the condition variable on which to produce the broadcast.
*/
APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond);
/**
* Destroy the condition variable and free the associated memory.
* @param cond the condition variable to destroy.
*/
APR_DECLARE(apr_status_t) apr_thread_cond_destroy(apr_thread_cond_t *cond);
/**
* Get the pool used by this thread_cond.
* @return apr_pool_t the pool
*/
APR_POOL_DECLARE_ACCESSOR(thread_cond);
#endif /* APR_HAS_THREADS */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_THREAD_COND_H */
--- NEW FILE: apr.hnw ---
/* 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_H
#define APR_H
/* GENERATED FILE WARNING! DO NOT EDIT apr.h
*
* You must modify apr.hnw instead.
*
* And please, make an effort to stub apr.hw and apr.h.in in the process.
*
* This is the NetWare specific version of apr.h. It is copied from
* apr.hnw at the start of a NetWare build by prebuildNW.bat.
*/
/**
* @file apr.h
* @brief APR Platform Definitions
* @remark This is a generated header generated from include/apr.h.in by
* ./configure, or copied from include/apr.hw or include/apr.hnw
* for Win32 or Netware by those build environments, respectively.
*/
#if defined(NETWARE) || defined(DOXYGEN)
#define FD_SETSIZE 1024
#include <sys/types.h>
#include <stddef.h>
#include <stdio.h>
#include <time.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <nks/thread.h>
#include <nks/synch.h>
#include <nks/time.h>
#include <signal.h>
#include <novsock2.h>
#include <sys/types.h>
#ifdef NW_BUILD_IPV6
#include <novtcpip.h>
#endif
#define _POSIX_THREAD_SAFE_FUNCTIONS 1
#define READDIR_IS_THREAD_SAFE 1
/* Keep #include'd headers from within the __cplusplus or doxyblocks */
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup apr_platform Platform Definitions
* @ingroup APR
* @{
*/
#define APR_INLINE
#define APR_HAS_INLINE 0
#ifndef __attribute__
#define __attribute__(__x)
#endif
#define ENUM_BITFIELD(e,n,w) signed int n : w
#define APR_HAVE_ARPA_INET_H 0
#define APR_HAVE_CONIO_H 0
#define APR_HAVE_CRYPT_H 0
#define APR_HAVE_CTYPE_H 1
#define APR_HAVE_DIRENT_H 1
#define APR_HAVE_ERRNO_H 1
#define APR_HAVE_FCNTL_H 1
#define APR_HAVE_IO_H 0
#define APR_HAVE_LIMITS_H 1
#define APR_HAVE_NETDB_H 0
#define APR_HAVE_NETINET_IN_H 0
#define APR_HAVE_NETINET_SCTP_H 0
#define APR_HAVE_NETINET_SCTP_UIO_H 0
#define APR_HAVE_NETINET_TCP_H 0
#define APR_HAVE_PTHREAD_H 0
#define APR_HAVE_SIGNAL_H 1
#define APR_HAVE_STDARG_H 1
#define APR_HAVE_STDINT_H 0
#define APR_HAVE_STDIO_H 1
#define APR_HAVE_STDLIB_H 1
#define APR_HAVE_STRING_H 1
#define APR_HAVE_STRINGS_H 0
#define APR_HAVE_STRTOLL 1
#define APR_HAVE_SYS_SENDFILE_H 0
#define APR_HAVE_SYS_SIGNAL_H 0
#define APR_HAVE_SYS_SOCKET_H 0
#define APR_HAVE_SYS_SOCKIO_H 0
#define APR_HAVE_SYS_SYSLIMITS_H 0
#define APR_HAVE_SYS_TIME_H 0
#define APR_HAVE_SYS_TYPES_H 1
#define APR_HAVE_SYS_UIO_H 1
#define APR_HAVE_SYS_UN_H 0
#define APR_HAVE_SYS_WAIT_H 0
#define APR_HAVE_TIME_H 1
#define APR_HAVE_UNISTD_H 1
#define APR_HAVE_SHMEM_MMAP_TMP 0
#define APR_HAVE_SHMEM_MMAP_SHM 0
#define APR_HAVE_SHMEM_MMAP_ZERO 0
#define APR_HAVE_SHMEM_SHMGET_ANON 0
#define APR_HAVE_SHMEM_SHMGET 0
#define APR_HAVE_SHMEM_MMAP_ANON 0
#define APR_HAVE_SHMEM_BEOS 0
#define APR_USE_SHMEM_MMAP_TMP 0
#define APR_USE_SHMEM_MMAP_SHM 0
#define APR_USE_SHMEM_MMAP_ZERO 0
#define APR_USE_SHMEM_SHMGET_ANON 0
#define APR_USE_SHMEM_SHMGET 0
#define APR_USE_SHMEM_MMAP_ANON 0
#define APR_USE_SHMEM_BEOS 0
#define APR_USE_FLOCK_SERIALIZE 0
#define APR_USE_SYSVSEM_SERIALIZE 0
#define APR_USE_FCNTL_SERIALIZE 0
#define APR_USE_PROC_PTHREAD_SERIALIZE 0
#define APR_USE_PTHREAD_SERIALIZE 0
#define APR_HAS_FLOCK_SERIALIZE 0
#define APR_HAS_SYSVSEM_SERIALIZE 0
#define APR_HAS_FCNTL_SERIALIZE 0
#define APR_HAS_PROC_PTHREAD_SERIALIZE 0
#define APR_HAS_RWLOCK_SERIALIZE 0
#define APR_HAS_LOCK_CREATE_NP 0
#define APR_PROCESS_LOCK_IS_GLOBAL 1
#define APR_FILE_BASED_SHM 0
#define APR_HAVE_CORKABLE_TCP 0
#define APR_HAVE_GETRLIMIT 0
#define APR_HAVE_ICONV 0
#define APR_HAVE_IN_ADDR 1
#define APR_HAVE_INET_ADDR 1
#define APR_HAVE_INET_NETWORK 0
#ifdef NW_BUILD_IPV6
#define APR_HAVE_IPV6 1
#else
#define APR_HAVE_IPV6 0
#endif
#define APR_HAVE_MEMCHR 1
#define APR_HAVE_MEMMOVE 1
#define APR_HAVE_SETRLIMIT 0
#define APR_HAVE_SIGACTION 0
#define APR_HAVE_SIGSUSPEND 0
#define APR_HAVE_SIGWAIT 0
#define APR_HAVE_STRCASECMP 1
#define APR_HAVE_STRDUP 1
#define APR_HAVE_STRICMP 1
#define APR_HAVE_STRNCASECMP 1
#define APR_HAVE_STRNICMP 1
#define APR_HAVE_STRSTR 1
#define APR_HAVE_STRUCT_RLIMIT 0
#define APR_HAVE_UNION_SEMUN 0
#define APR_HAVE_SCTP 0
/* APR Feature Macros */
#define APR_HAS_SHARED_MEMORY 0
#define APR_HAS_THREADS 1
#define APR_HAS_SENDFILE 0
#define APR_HAS_MMAP 0
#define APR_HAS_FORK 0
#define APR_HAS_RANDOM 1
#define APR_HAS_OTHER_CHILD 0
#define APR_HAS_DSO 1
#define APR_HAS_SO_ACCEPTFILTER 0
#define APR_HAS_UNICODE_FS 0
#define APR_HAS_PROC_INVOKED 0
#define APR_HAS_USER 1
#define APR_HAS_LARGE_FILES 0
#define APR_HAS_XTHREAD_FILES 0
#define APR_HAS_OS_UUID 0
/* Netware can poll on files/pipes.
*/
#define APR_FILES_AS_SOCKETS 1
/* Not all platforms have a real INADDR_NONE. This macro replaces INADDR_NONE
* on all platforms.
*/
#define APR_INADDR_NONE INADDR_NONE
/* This macro indicates whether or not EBCDIC is the native character set.
*/
#define APR_CHARSET_EBCDIC 0
/* Is the TCP_NODELAY socket option inherited from listening sockets?
*/
#define APR_TCP_NODELAY_INHERITED 1
/* Is the O_NONBLOCK flag inherited from listening sockets?
*/
#define APR_O_NONBLOCK_INHERITED 1
/* Typedefs that APR needs. */
typedef unsigned char apr_byte_t;
typedef short apr_int16_t;
typedef unsigned short apr_uint16_t;
typedef int apr_int32_t;
typedef unsigned int apr_uint32_t;
typedef long long apr_int64_t;
typedef unsigned long long apr_uint64_t;
typedef size_t apr_size_t;
typedef ssize_t apr_ssize_t;
typedef off_t apr_off_t;
typedef int apr_socklen_t;
#ifdef UNKNOWN_NETWARE_64BIT_FLAG_NEEDED
#define APR_SIZEOF_VOIDP 8
#else
#define APR_SIZEOF_VOIDP 4
#endif
/* Mechanisms to properly type numeric literals */
#ifdef __GNUC__
#define APR_INT64_C(val) (val)
#else
#define APR_INT64_C(val) (val##i64)
#endif
/* PROC mutex is a GLOBAL mutex on Netware */
#define APR_PROC_MUTEX_IS_GLOBAL 1
/* Definitions that APR programs need to work properly. */
/**
* Thread callbacks from APR functions must be declared with APR_THREAD_FUNC,
* so that they follow the platform's calling convention.
* @example
*/
/** void* APR_THREAD_FUNC my_thread_entry_fn(apr_thread_t *thd, void *data);
*/
#define APR_THREAD_FUNC
/**
* The public APR functions are declared with APR_DECLARE(), so they may
* use the most appropriate calling convention. Public APR functions with
* variable arguments must use APR_DECLARE_NONSTD().
*
* @remark Both the declaration and implementations must use the same macro.
* @example
*/
/** APR_DECLARE(rettype) apr_func(args)
* @see APR_DECLARE_NONSTD @see APR_DECLARE_DATA
* @remark Note that when APR compiles the library itself, it passes the
* symbol -DAPR_DECLARE_EXPORT to the compiler on some platforms (e.g. Win32)
* to export public symbols from the dynamic library build.\n
* The user must define the APR_DECLARE_STATIC when compiling to target
* the static APR library on some platforms (e.g. Win32.) The public symbols
* are neither exported nor imported when APR_DECLARE_STATIC is defined.\n
* By default, compiling an application and including the APR public
* headers, without defining APR_DECLARE_STATIC, will prepare the code to be
* linked to the dynamic library.
*/
#define APR_DECLARE(type) type
/**
* The public APR functions using variable arguments are declared with
* APR_DECLARE_NONSTD(), as they must follow the C language calling convention.
* @see APR_DECLARE @see APR_DECLARE_DATA
* @remark Both the declaration and implementations must use the same macro.
* @example
*/
/** APR_DECLARE_NONSTD(rettype) apr_func(args, ...);
*/
#define APR_DECLARE_NONSTD(type) type
/**
* The public APR variables are declared with AP_MODULE_DECLARE_DATA.
* This assures the appropriate indirection is invoked at compile time.
* @see APR_DECLARE @see APR_DECLARE_NONSTD
* @remark Note that the declaration and implementations use different forms,
* but both must include the macro.
* @example
*/
/** extern APR_DECLARE_DATA type apr_variable;\n
* APR_DECLARE_DATA type apr_variable = value;
*/
#define APR_DECLARE_DATA
#define APR_SSIZE_T_FMT "d"
#define APR_SIZE_T_FMT "d"
#define APR_OFF_T_FMT "ld"
#define APR_PID_T_FMT "d"
/* Local machine definition for console and log output. */
#define APR_EOL_STR "\r\n"
typedef int apr_wait_t;
#define APR_PATH_MAX PATH_MAX
#define APR_INT64_T_FMT "lld"
#define APR_INT64_T_FMT_LEN 3
#define APR_UINT64_T_FMT "llu"
#define APR_UINT64_T_FMT_LEN 3
#define APR_UINT64_T_HEX_FMT "llx"
#define APR_UINT64_T_HEX_FMT_LEN (sizeof(APR_UINT64_T_HEX_FMT) - 1)
#define APR_TIME_T_FMT APR_INT64_T_FMT
/* Deal with atoi64 variables ... these should move to apr_private.h */
#define APR_HAVE_INT64_STRFN 1
#define APR_INT64_STRFN strtoll
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* NETWARE */
#endif /* APR_H */
--- NEW FILE: apr_compat.h ---
/* 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_COMPAT_H
#define APR_COMPAT_H
/**
* @file apr_compat.h
* @brief APR Legacy Apache 1.3 Compatibility
* @deprecated These defines are only present for historical purposes
*/
/**
* @defgroup apr_compat APR Legacy Apache 1.3 Compatibility
* @ingroup APR
* @{
*/
/* redefine 1.3.x symbols to those that now live in libapr */
/** @see APR_INLINE */
#define ap_inline APR_INLINE
/** @deprecated @see apr_md5_ctx_t */
#define ap_md5_ctx_t apr_md5_ctx_t
/** @deprecated @see apr_md5_encode */
#define ap_MD5Encode apr_md5_encode
/** @deprecated @see apr_md5_final */
#define ap_MD5Final apr_md5_final
/** @deprecated @see apr_md5_init */
#define ap_MD5Init apr_md5_init
/** @deprecated @see apr_md5_update */
#define ap_MD5Update apr_md5_update
/** @deprecated @see apr_array_append */
#define ap_append_arrays apr_array_append
/** @deprecated @see apr_array_cat */
#define ap_array_cat apr_array_cat
/** @deprecated @see apr_array_header_t */
#define ap_array_header_t apr_array_header_t
/** @deprecated @see apr_array_pstrcat */
#define ap_array_pstrcat apr_array_pstrcat
/** @deprecated @see apr_pool_free_blocks_num_bytes */
#define ap_bytes_in_free_blocks apr_pool_free_blocks_num_bytes
/** @deprecated @see apr_pool_num_bytes */
#define ap_bytes_in_pool apr_pool_num_bytes
/** @deprecated @see apr_check_file_time */
#define ap_check_file_time apr_check_file_time
/** @deprecated @see apr_filetype_e */
#define ap_filetype_e apr_filetype_e
/** @deprecated @see apr_pool_cleanup_for_exec */
#define ap_cleanup_for_exec apr_pool_cleanup_for_exec
/** @deprecated @see apr_pool_clear */
#define ap_clear_pool apr_pool_clear
/** @deprecated @see apr_table_clear */
#define ap_clear_table apr_table_clear
/** @deprecated @see apr_array_copy */
#define ap_copy_array apr_array_copy
/** @deprecated @see apr_array_copy_hdr */
#define ap_copy_array_hdr apr_array_copy_hdr
/** @deprecated @see apr_table_copy */
#define ap_copy_table apr_table_copy
/** @deprecated @see apr_cpystrn */
#define ap_cpystrn apr_cpystrn
/** @deprecated @see apr_day_snames */
#define ap_day_snames apr_day_snames
/** @deprecated @see apr_pool_destroy */
#define ap_destroy_pool apr_pool_destroy
/** @deprecated @see apr_time_exp_t */
#define ap_exploded_time_t apr_time_exp_t
/** @deprecated @see apr_fnmatch */
#define ap_fnmatch apr_fnmatch
/** @deprecated @see apr_getopt */
#define ap_getopt apr_getopt
/** @deprecated @see apr_inet_addr */
#define ap_inet_addr apr_inet_addr
/** @deprecated @see apr_pool_alloc_init */
#define ap_init_alloc apr_pool_alloc_init
/** @deprecated @see apr_is_empty_table */
#define ap_is_empty_table apr_is_empty_table
/** @deprecated @see apr_fnmatch_test */
#define ap_is_fnmatch apr_fnmatch_test
/** @deprecated @see apr_pool_cleanup_kill */
#define ap_kill_cleanup apr_pool_cleanup_kill
/** @deprecated @see apr_array_make */
#define ap_make_array apr_array_make
/** @deprecated @see apr_pool_sub_make */
#define ap_make_sub_pool apr_pool_sub_make
/** @deprecated @see apr_table_make */
#define ap_make_table apr_table_make
/** @deprecated @see apr_month_snames */
#define ap_month_snames apr_month_snames
/** @deprecated @see apr_pool_note_subprocess*/
#define ap_note_subprocess apr_pool_note_subprocess
/** @deprecated @see apr_pool_cleanup_null */
#define ap_null_cleanup apr_pool_cleanup_null
/** @deprecated @see apr_filepath_merge */
#define ap_os_canonical_filename apr_filepath_merge
/** @deprecated @see apr_filepath_merge */
#define ap_os_case_canonical_filename apr_filepath_merge
/** @deprecated @see apr_dso_load */
#define ap_os_dso_load apr_dso_load
/** @deprecated @see apr_dso_unload */
#define ap_os_dso_unload apr_dso_unload
/** @deprecated @see apr_dso_sym */
#define ap_os_dso_sym apr_dso_sym
/** @deprecated @see apr_dso_error */
#define ap_os_dso_error apr_dso_error
/** @deprecated @see apr_filepath_merge
* @warning apr_filepath_merge rejects invalid filenames */
#define ap_os_is_filename_valid apr_filepath_merge
/** @deprecated @see apr_proc_kill */
#define ap_os_kill apr_proc_kill
/** @deprecated @see apr_filepath_merge */
#define ap_os_systemcase_canonical_filename apr_filepath_merge
/** @deprecated @see apr_table_overlap */
#define ap_overlap_tables apr_table_overlap
/** @deprecated @see apr_table_overlay */
#define ap_overlay_tables apr_table_overlay
/** @deprecated @see apr_palloc */
#define ap_palloc apr_palloc
/** @deprecated @see apr_pcalloc */
#define ap_pcalloc apr_pcalloc
/** @deprecated @see apr_pool_join */
#define ap_pool_join apr_pool_join
/** @deprecated @see apr_psprintf */
#define ap_psprintf apr_psprintf
/** @deprecated @see apr_pstrcat */
#define ap_pstrcat apr_pstrcat
/** @deprecated @see apr_pstrdup */
#define ap_pstrdup apr_pstrdup
/** @deprecated @see apr_pstrndup */
#define ap_pstrndup apr_pstrndup
/** @deprecated @see apr_array_push */
#define ap_push_array apr_array_push
/** @deprecated @see apr_pvsprintf */
#define ap_pvsprintf apr_pvsprintf
/** @deprecated @see apr_pool_cleanup_register */
#define ap_register_cleanup apr_pool_cleanup_register
/** @deprecated @see apr_proc_other_child_register */
#define ap_register_other_child apr_proc_other_child_register
/** @deprecated @see apr_pool_cleanup_run */
#define ap_run_cleanup apr_pool_cleanup_run
/** @deprecated @see apr_signal */
#define ap_signal apr_signal
/** @deprecated @see apr_snprintf */
#define ap_snprintf apr_snprintf
/** @deprecated @see apr_table_add */
#define ap_table_add apr_table_add
/** @deprecated @see apr_table_addn */
#define ap_table_addn apr_table_addn
/** @deprecated @see apr_table_do */
#define ap_table_do apr_table_do
/** @deprecated @see apr_table_elts */
#define ap_table_elts apr_table_elts
/** @deprecated @see apr_table_get */
#define ap_table_get apr_table_get
/** @deprecated @see apr_table_merge */
#define ap_table_merge apr_table_merge
/** @deprecated @see apr_table_mergen */
#define ap_table_mergen apr_table_mergen
/** @deprecated @see apr_table_set */
#define ap_table_set apr_table_set
/** @deprecated @see apr_table_setn */
#define ap_table_setn apr_table_setn
/** @deprecated @see apr_table_unset */
#define ap_table_unset apr_table_unset
/** @deprecated @see apr_proc_other_child_unregister */
#define ap_unregister_other_child apr_proc_other_child_unregister
/** @deprecated @see apr_password_validate */
#define ap_validate_password apr_password_validate
/** @deprecated @see apr_vformatter */
#define ap_vformatter apr_vformatter
/** @deprecated @see apr_vsnprintf */
#define ap_vsnprintf apr_vsnprintf
/** @deprecated @see apr_wait_t */
#define ap_wait_t apr_wait_t
/** @deprecated @see apr_isalnum */
#define ap_isalnum apr_isalnum
/** @deprecated @see apr_isalpha*/
#define ap_isalpha apr_isalpha
/** @deprecated @see apr_iscntrl */
#define ap_iscntrl apr_iscntrl
/** @deprecated @see apr_isdigit */
#define ap_isdigit apr_isdigit
/** @deprecated @see apr_isgraph */
#define ap_isgraph apr_isgraph
/** @deprecated @see apr_islower */
#define ap_islower apr_islower
/** @deprecated @see apr_isascii */
#define ap_isascii apr_isascii
/** @deprecated @see apr_isprint */
#define ap_isprint apr_isprint
/** @deprecated @see apr_ispunct */
#define ap_ispunct apr_ispunct
/** @deprecated @see apr_isspace */
#define ap_isspace apr_isspace
/** @deprecated @see apr_isupper */
#define ap_isupper apr_isupper
/** @deprecated @see apr_isxdigit */
#define ap_isxdigit apr_isxdigit
/** @deprecated @see apr_tolower */
#define ap_tolower apr_tolower
/** @deprecated @see apr_toupper */
#define ap_toupper apr_toupper
/** @deprecated @see APR_USEC_PER_SEC */
#define AP_USEC_PER_SEC APR_USEC_PER_SEC
/** @deprecated @see APR_RFC822_DATE_LEN */
#define AP_RFC822_DATE_LEN APR_RFC822_DATE_LEN
/** @deprecated @see APR_OVERLAP_TABLES_MERGE */
#define AP_OVERLAP_TABLES_MERGE APR_OVERLAP_TABLES_MERGE
/** @deprecated @see APR_OVERLAP_TABLES_SET */
#define AP_OVERLAP_TABLES_SET APR_OVERLAP_TABLES_SET
/** @} */
#endif /* APR_COMPAT_H */
--- NEW FILE: apr_thread_proc.h ---
/* 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_THREAD_PROC_H
#define APR_THREAD_PROC_H
/**
* @file apr_thread_proc.h
* @brief APR Thread and Process Library
*/
#include "apr.h"
#include "apr_file_io.h"
#include "apr_pools.h"
#include "apr_errno.h"
#if APR_HAVE_STRUCT_RLIMIT
#include <sys/time.h>
#include <sys/resource.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_thread_proc Threads and Process Functions
* @ingroup APR
* @{
*/
typedef enum {
APR_SHELLCMD, /**< use the shell to invoke the program */
APR_PROGRAM, /**< invoke the program directly, no copied env */
APR_PROGRAM_ENV, /**< invoke the program, replicating our environment */
APR_PROGRAM_PATH, /**< find program on PATH, use our environment */
APR_SHELLCMD_ENV /**< use the shell to invoke the program,
* replicating our environment
*/
} apr_cmdtype_e;
typedef enum {
APR_WAIT, /**< wait for the specified process to finish */
APR_NOWAIT /**< do not wait -- just see if it has finished */
} apr_wait_how_e;
/* I am specifically calling out the values so that the macros below make
* more sense. Yes, I know I don't need to, but I am hoping this makes what
* I am doing more clear. If you want to add more reasons to exit, continue
* to use bitmasks.
*/
typedef enum {
APR_PROC_EXIT = 1, /**< process exited normally */
APR_PROC_SIGNAL = 2, /**< process exited due to a signal */
APR_PROC_SIGNAL_CORE = 4 /**< process exited and dumped a core file */
} apr_exit_why_e;
/** did we exit the process */
#define APR_PROC_CHECK_EXIT(x) (x & APR_PROC_EXIT)
/** did we get a signal */
#define APR_PROC_CHECK_SIGNALED(x) (x & APR_PROC_SIGNAL)
/** did we get core */
#define APR_PROC_CHECK_CORE_DUMP(x) (x & APR_PROC_SIGNAL_CORE)
/** @see apr_procattr_io_set */
#define APR_NO_PIPE 0
/** @see apr_procattr_io_set */
#define APR_FULL_BLOCK 1
/** @see apr_procattr_io_set */
#define APR_FULL_NONBLOCK 2
/** @see apr_procattr_io_set */
#define APR_PARENT_BLOCK 3
/** @see apr_procattr_io_set */
#define APR_CHILD_BLOCK 4
/** @see apr_procattr_limit_set */
#define APR_LIMIT_CPU 0
/** @see apr_procattr_limit_set */
#define APR_LIMIT_MEM 1
/** @see apr_procattr_limit_set */
#define APR_LIMIT_NPROC 2
/** @see apr_procattr_limit_set */
#define APR_LIMIT_NOFILE 3
/**
* @defgroup APR_OC Other Child Flags
* @{
*/
#define APR_OC_REASON_DEATH 0 /**< child has died, caller must call
* unregister still */
#define APR_OC_REASON_UNWRITABLE 1 /**< write_fd is unwritable */
#define APR_OC_REASON_RESTART 2 /**< a restart is occuring, perform
* any necessary cleanup (including
* sending a special signal to child)
*/
#define APR_OC_REASON_UNREGISTER 3 /**< unregister has been called, do
* whatever is necessary (including
* kill the child) */
#define APR_OC_REASON_LOST 4 /**< somehow the child exited without
* us knowing ... buggy os? */
#define APR_OC_REASON_RUNNING 5 /**< a health check is occuring,
* for most maintainence functions
* this is a no-op.
*/
/** @} */
/** The APR process type */
typedef struct apr_proc_t {
/** The process ID */
pid_t pid;
/** Parent's side of pipe to child's stdin */
apr_file_t *in;
/** Parent's side of pipe to child's stdout */
apr_file_t *out;
/** Parent's side of pipe to child's stdouterr */
apr_file_t *err;
#if APR_HAS_PROC_INVOKED || defined(DOXYGEN)
/** Diagnositics/debugging string of the command invoked for
* this process [only present if APR_HAS_PROC_INVOKED is true]
* @remark Only enabled on Win32 by default.
* @bug This should either always or never be present in release
* builds - since it breaks binary compatibility. We may enable
* it always in APR 1.0 yet leave it undefined in most cases.
*/
char *invoked;
#endif
#if defined(WIN32) || defined(DOXYGEN)
/** (Win32 only) Creator's handle granting access to the process
* @remark This handle is closed and reset to NULL in every case
* corresponding to a waitpid() on Unix which returns the exit status.
* Therefore Win32 correspond's to Unix's zombie reaping characteristics
* and avoids potential handle leaks.
*/
HANDLE hproc;
#endif
} apr_proc_t;
/**
* The prototype for APR child errfn functions. (See the description
* of apr_procattr_child_errfn_set() for more information.)
* It is passed the following parameters:
* @param pool Pool associated with the apr_proc_t. If your child
* error function needs user data, associate it with this
* pool.
* @param err APR error code describing the error
* @param description Text description of type of processing which failed
*/
typedef void (apr_child_errfn_t)(apr_pool_t *proc, apr_status_t err,
const char *description);
/** Opaque Thread structure. */
typedef struct apr_thread_t apr_thread_t;
/** Opaque Thread attributes structure. */
typedef struct apr_threadattr_t apr_threadattr_t;
/** Opaque Process attributes structure. */
typedef struct apr_procattr_t apr_procattr_t;
/** Opaque control variable for one-time atomic variables. */
typedef struct apr_thread_once_t apr_thread_once_t;
/** Opaque thread private address space. */
typedef struct apr_threadkey_t apr_threadkey_t;
/** Opaque record of child process. */
typedef struct apr_other_child_rec_t apr_other_child_rec_t;
/**
* The prototype for any APR thread worker functions.
*/
typedef void *(APR_THREAD_FUNC *apr_thread_start_t)(apr_thread_t*, void*);
typedef enum {
APR_KILL_NEVER, /**< process is never sent any signals */
APR_KILL_ALWAYS, /**< process is sent SIGKILL on apr_pool_t cleanup */
APR_KILL_AFTER_TIMEOUT, /**< SIGTERM, wait 3 seconds, SIGKILL */
APR_JUST_WAIT, /**< wait forever for the process to complete */
APR_KILL_ONLY_ONCE /**< send SIGTERM and then wait */
} apr_kill_conditions_e;
/* Thread Function definitions */
#if APR_HAS_THREADS
/**
* Create and initialize a new threadattr variable
* @param new_attr The newly created threadattr.
* @param cont The pool to use
*/
APR_DECLARE(apr_status_t) apr_threadattr_create(apr_threadattr_t **new_attr,
apr_pool_t *cont);
/**
* Set if newly created threads should be created in detached state.
* @param attr The threadattr to affect
* @param on Thread detach state on or off
*/
APR_DECLARE(apr_status_t) apr_threadattr_detach_set(apr_threadattr_t *attr,
apr_int32_t on);
/**
* Get the detach state for this threadattr.
* @param attr The threadattr to reference
*/
APR_DECLARE(apr_status_t) apr_threadattr_detach_get(apr_threadattr_t *attr);
/**
* Set the stack size of newly created threads.
* @param attr The threadattr to affect
* @param stacksize The stack size in bytes
*/
APR_DECLARE(apr_status_t) apr_threadattr_stacksize_set(apr_threadattr_t *attr,
apr_size_t stacksize);
/**
* Create a new thread of execution
* @param new_thread The newly created thread handle.
* @param attr The threadattr to use to determine how to create the thread
* @param func The function to start the new thread in
* @param data Any data to be passed to the starting function
* @param cont The pool to use
*/
APR_DECLARE(apr_status_t) apr_thread_create(apr_thread_t **new_thread,
apr_threadattr_t *attr,
apr_thread_start_t func,
void *data, apr_pool_t *cont);
/**
* stop the current thread
* @param thd The thread to stop
* @param retval The return value to pass back to any thread that cares
*/
APR_DECLARE(apr_status_t) apr_thread_exit(apr_thread_t *thd,
apr_status_t retval);
/**
* block until the desired thread stops executing.
* @param retval The return value from the dead thread.
* @param thd The thread to join
*/
APR_DECLARE(apr_status_t) apr_thread_join(apr_status_t *retval,
apr_thread_t *thd);
/**
* force the current thread to yield the processor
*/
APR_DECLARE(void) apr_thread_yield(void);
/**
* Initialize the control variable for apr_thread_once. If this isn't
* called, apr_initialize won't work.
* @param control The control variable to initialize
* @param p The pool to allocate data from.
*/
APR_DECLARE(apr_status_t) apr_thread_once_init(apr_thread_once_t **control,
apr_pool_t *p);
/**
* Run the specified function one time, regardless of how many threads
* call it.
* @param control The control variable. The same variable should
* be passed in each time the function is tried to be
* called. This is how the underlying functions determine
* if the function has ever been called before.
* @param func The function to call.
*/
APR_DECLARE(apr_status_t) apr_thread_once(apr_thread_once_t *control,
void (*func)(void));
/**
* detach a thread
* @param thd The thread to detach
*/
APR_DECLARE(apr_status_t) apr_thread_detach(apr_thread_t *thd);
/**
* Return the pool associated with the current thread.
* @param data The user data associated with the thread.
* @param key The key to associate with the data
* @param thread The currently open thread.
*/
APR_DECLARE(apr_status_t) apr_thread_data_get(void **data, const char *key,
apr_thread_t *thread);
/**
* Return the pool associated with the current thread.
* @param data The user data to associate with the thread.
* @param key The key to use for associating the data with the thread
* @param cleanup The cleanup routine to use when the thread is destroyed.
* @param thread The currently open thread.
*/
APR_DECLARE(apr_status_t) apr_thread_data_set(void *data, const char *key,
apr_status_t (*cleanup) (void *),
apr_thread_t *thread);
/**
* Create and initialize a new thread private address space
* @param key The thread private handle.
* @param dest The destructor to use when freeing the private memory.
* @param cont The pool to use
*/
APR_DECLARE(apr_status_t) apr_threadkey_private_create(apr_threadkey_t **key,
void (*dest)(void *),
apr_pool_t *cont);
/**
* Get a pointer to the thread private memory
* @param new_mem The data stored in private memory
* @param key The handle for the desired thread private memory
*/
APR_DECLARE(apr_status_t) apr_threadkey_private_get(void **new_mem,
apr_threadkey_t *key);
/**
* Set the data to be stored in thread private memory
* @param priv The data to be stored in private memory
* @param key The handle for the desired thread private memory
*/
APR_DECLARE(apr_status_t) apr_threadkey_private_set(void *priv,
apr_threadkey_t *key);
/**
* Free the thread private memory
* @param key The handle for the desired thread private memory
*/
APR_DECLARE(apr_status_t) apr_threadkey_private_delete(apr_threadkey_t *key);
/**
* Return the pool associated with the current threadkey.
* @param data The user data associated with the threadkey.
* @param key The key associated with the data
* @param threadkey The currently open threadkey.
*/
APR_DECLARE(apr_status_t) apr_threadkey_data_get(void **data, const char *key,
apr_threadkey_t *threadkey);
/**
* Return the pool associated with the current threadkey.
* @param data The data to set.
* @param key The key to associate with the data.
* @param cleanup The cleanup routine to use when the file is destroyed.
* @param threadkey The currently open threadkey.
*/
APR_DECLARE(apr_status_t) apr_threadkey_data_set(void *data, const char *key,
apr_status_t (*cleanup) (void *),
apr_threadkey_t *threadkey);
#endif
/**
* Create and initialize a new procattr variable
* @param new_attr The newly created procattr.
* @param cont The pool to use
*/
APR_DECLARE(apr_status_t) apr_procattr_create(apr_procattr_t **new_attr,
apr_pool_t *cont);
/**
* Determine if any of stdin, stdout, or stderr should be linked to pipes
* when starting a child process.
* @param attr The procattr we care about.
* @param in Should stdin be a pipe back to the parent?
* @param out Should stdout be a pipe back to the parent?
* @param err Should stderr be a pipe back to the parent?
*/
APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr,
apr_int32_t in, apr_int32_t out,
apr_int32_t err);
/**
* Set the child_in and/or parent_in values to existing apr_file_t values.
* @param attr The procattr we care about.
* @param child_in apr_file_t value to use as child_in. Must be a valid file.
* @param parent_in apr_file_t value to use as parent_in. Must be a valid file.
* @remark This is NOT a required initializer function. This is
* useful if you have already opened a pipe (or multiple files)
* that you wish to use, perhaps persistently across multiple
* process invocations - such as a log file. You can save some
* extra function calls by not creating your own pipe since this
* creates one in the process space for you.
*/
APR_DECLARE(apr_status_t) apr_procattr_child_in_set(struct apr_procattr_t *attr,
apr_file_t *child_in,
apr_file_t *parent_in);
/**
* Set the child_out and parent_out values to existing apr_file_t values.
* @param attr The procattr we care about.
* @param child_out apr_file_t value to use as child_out. Must be a valid file.
* @param parent_out apr_file_t value to use as parent_out. Must be a valid file.
* @remark This is NOT a required initializer function. This is
* useful if you have already opened a pipe (or multiple files)
* that you wish to use, perhaps persistently across multiple
* process invocations - such as a log file.
*/
APR_DECLARE(apr_status_t) apr_procattr_child_out_set(struct apr_procattr_t *attr,
apr_file_t *child_out,
apr_file_t *parent_out);
/**
* Set the child_err and parent_err values to existing apr_file_t values.
* @param attr The procattr we care about.
* @param child_err apr_file_t value to use as child_err. Must be a valid file.
* @param parent_err apr_file_t value to use as parent_err. Must be a valid file.
* @remark This is NOT a required initializer function. This is
* useful if you have already opened a pipe (or multiple files)
* that you wish to use, perhaps persistently across multiple
* process invocations - such as a log file.
*/
APR_DECLARE(apr_status_t) apr_procattr_child_err_set(struct apr_procattr_t *attr,
apr_file_t *child_err,
apr_file_t *parent_err);
/**
* Set which directory the child process should start executing in.
* @param attr The procattr we care about.
* @param dir Which dir to start in. By default, this is the same dir as
* the parent currently resides in, when the createprocess call
* is made.
*/
APR_DECLARE(apr_status_t) apr_procattr_dir_set(apr_procattr_t *attr,
const char *dir);
/**
* Set what type of command the child process will call.
* @param attr The procattr we care about.
* @param cmd The type of command. One of:
* <PRE>
* APR_SHELLCMD -- Anything that the shell can handle
* APR_PROGRAM -- Executable program (default)
* APR_PROGRAM_ENV -- Executable program, copy environment
* APR_PROGRAM_PATH -- Executable program on PATH, copy env
* </PRE>
*/
APR_DECLARE(apr_status_t) apr_procattr_cmdtype_set(apr_procattr_t *attr,
apr_cmdtype_e cmd);
/**
* Determine if the child should start in detached state.
* @param attr The procattr we care about.
* @param detach Should the child start in detached state? Default is no.
*/
APR_DECLARE(apr_status_t) apr_procattr_detach_set(apr_procattr_t *attr,
apr_int32_t detach);
#if APR_HAVE_STRUCT_RLIMIT
/**
* Set the Resource Utilization limits when starting a new process.
* @param attr The procattr we care about.
* @param what Which limit to set, one of:
* <PRE>
* APR_LIMIT_CPU
* APR_LIMIT_MEM
* APR_LIMIT_NPROC
* APR_LIMIT_NOFILE
* </PRE>
* @param limit Value to set the limit to.
*/
APR_DECLARE(apr_status_t) apr_procattr_limit_set(apr_procattr_t *attr,
apr_int32_t what,
struct rlimit *limit);
#endif
/**
* Specify an error function to be called in the child process if APR
* encounters an error in the child prior to running the specified program.
* @param attr The procattr describing the child process to be created.
* @param errfn The function to call in the child process.
* @remark At the present time, it will only be called from apr_proc_create()
* on platforms where fork() is used. It will never be called on other
* platforms, on those platforms apr_proc_create() will return the error
* in the parent process rather than invoke the callback in the now-forked
* child process.
*/
APR_DECLARE(apr_status_t) apr_procattr_child_errfn_set(apr_procattr_t *attr,
apr_child_errfn_t *errfn);
/**
* Specify that apr_proc_create() should do whatever it can to report
* failures to the caller of apr_proc_create(), rather than find out in
* the child.
* @param attr The procattr describing the child process to be created.
* @param chk Flag to indicate whether or not extra work should be done
* to try to report failures to the caller.
* @remark This flag only affects apr_proc_create() on platforms where
* fork() is used. This leads to extra overhead in the calling
* process, but that may help the application handle such
* errors more gracefully.
*/
APR_DECLARE(apr_status_t) apr_procattr_error_check_set(apr_procattr_t *attr,
apr_int32_t chk);
/**
* Determine if the child should start in its own address space or using the
* current one from its parent
* @param attr The procattr we care about.
* @param addrspace Should the child start in its own address space? Default
* is no on NetWare and yes on other platforms.
*/
APR_DECLARE(apr_status_t) apr_procattr_addrspace_set(apr_procattr_t *attr,
apr_int32_t addrspace);
#if APR_HAS_FORK
/**
* This is currently the only non-portable call in APR. This executes
* a standard unix fork.
* @param proc The resulting process handle.
* @param cont The pool to use.
*/
APR_DECLARE(apr_status_t) apr_proc_fork(apr_proc_t *proc, apr_pool_t *cont);
#endif
/**
* Create a new process and execute a new program within that process.
* @param new_proc The resulting process handle.
* @param progname The program to run
* @param args the arguments to pass to the new program. The first
* one should be the program name.
* @param env The new environment table for the new process. This
* should be a list of NULL-terminated strings. This argument
* is ignored for APR_PROGRAM_ENV, APR_PROGRAM_PATH, and
* APR_SHELLCMD_ENV types of commands.
* @param attr the procattr we should use to determine how to create the new
* process
* @param cont The pool to use.
*/
APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *new_proc,
const char *progname,
const char * const *args,
const char * const *env,
apr_procattr_t *attr,
apr_pool_t *cont);
/**
* Wait for a child process to die
* @param proc The process handle that corresponds to the desired child process
* @param exitcode The returned exit status of the child, if a child process
* dies, or the signal that caused the child to die.
* On platforms that don't support obtaining this information,
* the status parameter will be returned as APR_ENOTIMPL.
* @param exitwhy Why the child died, the bitwise or of:
* <PRE>
* APR_PROC_EXIT -- process terminated normally
* APR_PROC_SIGNAL -- process was killed by a signal
* APR_PROC_SIGNAL_CORE -- process was killed by a signal, and
* generated a core dump.
* </PRE>
* @param waithow How should we wait. One of:
* <PRE>
* APR_WAIT -- block until the child process dies.
* APR_NOWAIT -- return immediately regardless of if the
* child is dead or not.
* </PRE>
* @remark The childs status is in the return code to this process. It is one of:
* <PRE>
* APR_CHILD_DONE -- child is no longer running.
* APR_CHILD_NOTDONE -- child is still running.
* </PRE>
*/
APR_DECLARE(apr_status_t) apr_proc_wait(apr_proc_t *proc,
int *exitcode, apr_exit_why_e *exitwhy,
apr_wait_how_e waithow);
/**
* Wait for any current child process to die and return information
* about that child.
* @param proc Pointer to NULL on entry, will be filled out with child's
* information
* @param exitcode The returned exit status of the child, if a child process
* dies, or the signal that caused the child to die.
* On platforms that don't support obtaining this information,
* the status parameter will be returned as APR_ENOTIMPL.
* @param exitwhy Why the child died, the bitwise or of:
* <PRE>
* APR_PROC_EXIT -- process terminated normally
* APR_PROC_SIGNAL -- process was killed by a signal
* APR_PROC_SIGNAL_CORE -- process was killed by a signal, and
* generated a core dump.
* </PRE>
* @param waithow How should we wait. One of:
* <PRE>
* APR_WAIT -- block until the child process dies.
* APR_NOWAIT -- return immediately regardless of if the
* child is dead or not.
* </PRE>
* @param p Pool to allocate child information out of.
* @bug Passing proc as a *proc rather than **proc was an odd choice
* for some platforms... this should be revisited in 1.0
*/
APR_DECLARE(apr_status_t) apr_proc_wait_all_procs(apr_proc_t *proc,
int *exitcode,
apr_exit_why_e *exitwhy,
apr_wait_how_e waithow,
apr_pool_t *p);
#define APR_PROC_DETACH_FOREGROUND 0 /**< Do not detach */
#define APR_PROC_DETACH_DAEMONIZE 1 /**< Detach */
/**
* Detach the process from the controlling terminal.
* @param daemonize set to non-zero if the process should daemonize
* and become a background process, else it will
* stay in the foreground.
*/
APR_DECLARE(apr_status_t) apr_proc_detach(int daemonize);
/**
* Register an other_child -- a child associated to its registered
* maintence callback. This callback is invoked when the process
* dies, is disconnected or disappears.
* @param proc The child process to register.
* @param maintenance maintenance is a function that is invoked with a
* reason and the data pointer passed here.
* @param data Opaque context data passed to the maintenance function.
* @param write_fd An fd that is probed for writing. If it is ever unwritable
* then the maintenance is invoked with reason
* OC_REASON_UNWRITABLE.
* @param p The pool to use for allocating memory.
* @bug write_fd duplicates the proc->out stream, it's really redundant
* and should be replaced in the APR 1.0 API with a bitflag of which
* proc->in/out/err handles should be health checked.
* @bug no platform currently tests the pipes health.
*/
APR_DECLARE(void) apr_proc_other_child_register(apr_proc_t *proc,
void (*maintenance) (int reason,
void *,
int status),
void *data, apr_file_t *write_fd,
apr_pool_t *p);
/**
* Stop watching the specified other child.
* @param data The data to pass to the maintenance function. This is
* used to find the process to unregister.
* @warning Since this can be called by a maintenance function while we're
* scanning the other_children list, all scanners should protect
* themself by loading ocr->next before calling any maintenance
* function.
*/
APR_DECLARE(void) apr_proc_other_child_unregister(void *data);
/**
* Notify the maintenance callback of a registered other child process
* that application has detected an event, such as death.
* @param proc The process to check
* @param reason The reason code to pass to the maintenance function
* @param status The status to pass to the maintenance function
* @remark An example of code using this behavior;
* <pre>
* rv = apr_proc_wait_all_procs(&proc, &exitcode, &status, APR_WAIT, p);
* if (APR_STATUS_IS_CHILD_DONE(rv)) {
* #if APR_HAS_OTHER_CHILD
* if (apr_proc_other_child_alert(&proc, APR_OC_REASON_DEATH, status)
* == APR_SUCCESS) {
* ; (already handled)
* }
* else
* #endif
* [... handling non-otherchild processes death ...]
* </pre>
*/
APR_DECLARE(apr_status_t) apr_proc_other_child_alert(apr_proc_t *proc,
int reason,
int status);
/**
* Test one specific other child processes and invoke the maintenance callback
* with the appropriate reason code, if still running, or the appropriate reason
* code if the process is no longer healthy.
* @param ocr The registered other child
* @param reason The reason code (e.g. APR_OC_REASON_RESTART) if still running
*/
APR_DECLARE(void) apr_proc_other_child_refresh(apr_other_child_rec_t *ocr,
int reason);
/**
* Test all registered other child processes and invoke the maintenance callback
* with the appropriate reason code, if still running, or the appropriate reason
* code if the process is no longer healthy.
* @param reason The reason code (e.g. APR_OC_REASON_RESTART) to running processes
*/
APR_DECLARE(void) apr_proc_other_child_refresh_all(int reason);
/** @deprecated @see apr_proc_other_child_refresh_all
* @remark Call apr_proc_other_child_refresh_all(APR_OC_REASON_RESTART)
* or apr_proc_other_child_refresh_all(APR_OC_REASON_RUNNING) instead.
* @bug The differing implementations of this function on Win32 (_RUNNING checks)
* and Unix (used only for _RESTART) are the reason it will be dropped with APR 1.0.
*/
APR_DECLARE(void) apr_proc_other_child_check(void);
/** @deprecated @see apr_proc_other_child_alert
* @bug This function's name had nothing to do with it's purpose
*/
APR_DECLARE(apr_status_t) apr_proc_other_child_read(apr_proc_t *proc, int status);
/**
* Terminate a process.
* @param proc The process to terminate.
* @param sig How to kill the process.
*/
APR_DECLARE(apr_status_t) apr_proc_kill(apr_proc_t *proc, int sig);
/**
* Register a process to be killed when a pool dies.
* @param a The pool to use to define the processes lifetime
* @param proc The process to register
* @param how How to kill the process, one of:
* <PRE>
* APR_KILL_NEVER -- process is never sent any signals
* APR_KILL_ALWAYS -- process is sent SIGKILL on apr_pool_t cleanup
* APR_KILL_AFTER_TIMEOUT -- SIGTERM, wait 3 seconds, SIGKILL
* APR_JUST_WAIT -- wait forever for the process to complete
* APR_KILL_ONLY_ONCE -- send SIGTERM and then wait
* </PRE>
*/
APR_DECLARE(void) apr_pool_note_subprocess(apr_pool_t *a, apr_proc_t *proc,
apr_kill_conditions_e how);
#if APR_HAS_THREADS
#if (APR_HAVE_SIGWAIT || APR_HAVE_SIGSUSPEND) && !defined(OS2)
/**
* Setup the process for a single thread to be used for all signal handling.
* @warning This must be called before any threads are created
*/
APR_DECLARE(apr_status_t) apr_setup_signal_thread(void);
/**
* Make the current thread listen for signals. This thread will loop
* forever, calling a provided function whenever it receives a signal. That
* functions should return 1 if the signal has been handled, 0 otherwise.
* @param signal_handler The function to call when a signal is received
* apr_status_t apr_signal_thread((int)(*signal_handler)(int signum))
*/
APR_DECLARE(apr_status_t) apr_signal_thread(int(*signal_handler)(int signum));
#endif /* (APR_HAVE_SIGWAIT || APR_HAVE_SIGSUSPEND) && !defined(OS2) */
/**
* Get the child-pool used by the thread from the thread info.
* @return apr_pool_t the pool
*/
APR_POOL_DECLARE_ACCESSOR(thread);
#endif /* APR_HAS_THREADS */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_THREAD_PROC_H */
--- NEW FILE: apr_dso.h ---
/* 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_DSO_DOT_H
#define APR_DSO_DOT_H
/**
* @file apr_dso.h
* @brief APR Dynamic Object Handling Routines
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup apr_dso Dynamic Object Handling
* @ingroup APR
* @{
*/
#if APR_HAS_DSO || defined(DOXYGEN)
/**
* Structure for referencing dynamic objects
*/
typedef struct apr_dso_handle_t apr_dso_handle_t;
/**
* Structure for referencing symbols from dynamic objects
*/
typedef void * apr_dso_handle_sym_t;
/**
* Load a DSO library.
* @param res_handle Location to store new handle for the DSO.
* @param path Path to the DSO library
* @param ctx Pool to use.
* @bug We aught to provide an alternative to RTLD_GLOBAL, which
* is the only supported method of loading DSOs today.
*/
APR_DECLARE(apr_status_t) apr_dso_load(apr_dso_handle_t **res_handle,
const char *path, apr_pool_t *ctx);
/**
* Close a DSO library.
* @param handle handle to close.
*/
APR_DECLARE(apr_status_t) apr_dso_unload(apr_dso_handle_t *handle);
/**
* Load a symbol from a DSO handle.
* @param ressym Location to store the loaded symbol
* @param handle handle to load the symbol from.
* @param symname Name of the symbol to load.
*/
APR_DECLARE(apr_status_t) apr_dso_sym(apr_dso_handle_sym_t *ressym,
apr_dso_handle_t *handle,
const char *symname);
/**
* Report more information when a DSO function fails.
* @param dso The dso handle that has been opened
* @param buf Location to store the dso error
* @param bufsize The size of the provided buffer
*/
APR_DECLARE(const char *) apr_dso_error(apr_dso_handle_t *dso, char *buf, apr_size_t bufsize);
#endif /* APR_HAS_DSO */
/** @} */
#ifdef __cplusplus
}
#endif
#endif
--- NEW FILE: apr_proc_mutex.h ---
/* 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_PROC_MUTEX_H
#define APR_PROC_MUTEX_H
/**
* @file apr_proc_mutex.h
* @brief APR Process Locking Routines
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_proc_mutex Process Locking Routines
* @ingroup APR
* @{
*/
/**
* Enumerated potential types for APR process locking methods
* @warning Check APR_HAS_foo_SERIALIZE defines to see if the platform supports
* APR_LOCK_foo. Only APR_LOCK_DEFAULT is portable.
*/
typedef enum {
APR_LOCK_FCNTL, /**< fcntl() */
APR_LOCK_FLOCK, /**< flock() */
APR_LOCK_SYSVSEM, /**< System V Semaphores */
APR_LOCK_PROC_PTHREAD, /**< POSIX pthread process-based locking */
APR_LOCK_POSIXSEM, /**< POSIX semaphore process-based locking */
APR_LOCK_DEFAULT /**< Use the default process lock */
} apr_lockmech_e;
/** Opaque structure representing a process mutex. */
typedef struct apr_proc_mutex_t apr_proc_mutex_t;
/* Function definitions */
/**
* Create and initialize a mutex that can be used to synchronize processes.
* @param mutex the memory address where the newly created mutex will be
* stored.
* @param fname A file name to use if the lock mechanism requires one. This
* argument should always be provided. The lock code itself will
* determine if it should be used.
* @param mech The mechanism to use for the interprocess lock, if any; one of
* <PRE>
* APR_LOCK_FCNTL
* APR_LOCK_FLOCK
* APR_LOCK_SYSVSEM
* APR_LOCK_POSIXSEM
* APR_LOCK_PROC_PTHREAD
* APR_LOCK_DEFAULT pick the default mechanism for the platform
* </PRE>
* @param pool the pool from which to allocate the mutex.
* @see apr_lockmech_e
* @warning Check APR_HAS_foo_SERIALIZE defines to see if the platform supports
* APR_LOCK_foo. Only APR_LOCK_DEFAULT is portable.
*/
APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
const char *fname,
apr_lockmech_e mech,
apr_pool_t *pool);
/**
* Re-open a mutex in a child process.
* @param mutex The newly re-opened mutex structure.
* @param fname A file name to use if the mutex mechanism requires one. This
* argument should always be provided. The mutex code itself will
* determine if it should be used. This filename should be the
* same one that was passed to apr_proc_mutex_create().
* @param pool The pool to operate on.
* @remark This function must be called to maintain portability, even
* if the underlying lock mechanism does not require it.
*/
APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
const char *fname,
apr_pool_t *pool);
/**
* Acquire the lock for the given mutex. If the mutex is already locked,
* the current thread will be put to sleep until the lock becomes available.
* @param mutex the mutex on which to acquire the lock.
*/
APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex);
/**
* Attempt to acquire the lock for the given mutex. If the mutex has already
* been acquired, the call returns immediately with APR_EBUSY. Note: it
* is important that the APR_STATUS_IS_EBUSY(s) macro be used to determine
* if the return value was APR_EBUSY, for portability reasons.
* @param mutex the mutex on which to attempt the lock acquiring.
*/
APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex);
/**
* Release the lock for the given mutex.
* @param mutex the mutex from which to release the lock.
*/
APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex);
/**
* Destroy the mutex and free the memory associated with the lock.
* @param mutex the mutex to destroy.
*/
APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex);
/**
* Destroy the mutex and free the memory associated with the lock.
* @param mutex the mutex to destroy.
* @note This function is generally used to kill a cleanup on an already
* created mutex
*/
APR_DECLARE(apr_status_t) apr_proc_mutex_cleanup(void *mutex);
/**
* Return the name of the lockfile for the mutex, or NULL
* if the mutex doesn't use a lock file
*/
APR_DECLARE(const char *) apr_proc_mutex_lockfile(apr_proc_mutex_t *mutex);
/**
* Display the name of the mutex, as it relates to the actual method used.
* This matches the valid options for Apache's AcceptMutex directive
* @param mutex the name of the mutex
*/
APR_DECLARE(const char *) apr_proc_mutex_name(apr_proc_mutex_t *mutex);
/**
* Display the name of the default mutex: APR_LOCK_DEFAULT
*/
APR_DECLARE(const char *) apr_proc_mutex_defname(void);
/**
* Get the pool used by this proc_mutex.
* @return apr_pool_t the pool
*/
APR_POOL_DECLARE_ACCESSOR(proc_mutex);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_PROC_MUTEX_H */
--- NEW FILE: apr_tables.h ---
/* 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_TABLES_H
#define APR_TABLES_H
/**
* @file apr_tables.h
* @brief APR Table library
*/
#include "apr.h"
#include "apr_pools.h"
#if APR_HAVE_STDARG_H
#include <stdarg.h> /* for va_list */
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_tables Table and Array Functions
* @ingroup APR
* Tables are used to store entirely opaque structures
* for applications, while Arrays are usually used to
* deal with string lists.
* @{
*/
/** the table abstract data type */
typedef struct apr_table_t apr_table_t;
/** @see apr_array_header_t */
typedef struct apr_array_header_t apr_array_header_t;
/** An opaque array type */
struct apr_array_header_t {
/** The pool the array is allocated out of */
apr_pool_t *pool;
/** The amount of memory allocated for each element of the array */
int elt_size;
/** The number of active elements in the array */
int nelts;
/** The number of elements allocated in the array */
int nalloc;
/** The elements in the array */
char *elts;
};
/**
* The (opaque) structure for string-content tables.
*/
typedef struct apr_table_entry_t apr_table_entry_t;
/** The type for each entry in a string-content table */
struct apr_table_entry_t {
/** The key for the current table entry */
char *key; /* maybe NULL in future;
* check when iterating thru table_elts
*/
/** The value for the current table entry */
char *val;
/** A checksum for the key, for use by the apr_table internals */
apr_uint32_t key_checksum;
};
/**
* Get the elements from a table
* @param t The table
* @return An array containing the contents of the table
*/
APR_DECLARE(const apr_array_header_t *) apr_table_elts(const apr_table_t *t);
/**
* Determine if the table is empty
* @param t The table to check
* @return True if empty, False otherwise
*/
APR_DECLARE(int) apr_is_empty_table(const apr_table_t *t);
/**
* Determine if the array is empty
* @param a The array to check
* @return True if empty, False otherwise
*/
APR_DECLARE(int) apr_is_empty_array(const apr_array_header_t *a);
/**
* Create an array
* @param p The pool to allocate the memory out of
* @param nelts the number of elements in the initial array
* @param elt_size The size of each element in the array.
* @return The new array
*/
APR_DECLARE(apr_array_header_t *) apr_array_make(apr_pool_t *p,
int nelts, int elt_size);
/**
* Add a new element to an array
* @param arr The array to add an element to.
* @return Location for the new element in the array.
* @remark If there are no free spots in the array, then this function will
* allocate new space for the new element.
*/
APR_DECLARE(void *) apr_array_push(apr_array_header_t *arr);
/**
* Remove an element from an array
* @param arr The array to remove an element from.
* @return Location of the element in the array.
* @remark If there are no elements in the array, NULL is returned.
*/
APR_DECLARE(void *) apr_array_pop(apr_array_header_t *arr);
/**
* Concatenate two arrays together
* @param dst The destination array, and the one to go first in the combined
* array
* @param src The source array to add to the destination array
*/
APR_DECLARE(void) apr_array_cat(apr_array_header_t *dst,
const apr_array_header_t *src);
/**
* Copy the entire array
* @param p The pool to allocate the copy of the array out of
* @param arr The array to copy
* @return An exact copy of the array passed in
* @remark The alternate apr_array_copy_hdr copies only the header, and arranges
* for the elements to be copied if (and only if) the code subsequently
* does a push or arraycat.
*/
APR_DECLARE(apr_array_header_t *) apr_array_copy(apr_pool_t *p,
const apr_array_header_t *arr);
/**
* Copy the headers of the array, and arrange for the elements to be copied if
* and only if the code subsequently does a push or arraycat.
* @param p The pool to allocate the copy of the array out of
* @param arr The array to copy
* @return An exact copy of the array passed in
* @remark The alternate apr_array_copy copies the *entire* array.
*/
APR_DECLARE(apr_array_header_t *) apr_array_copy_hdr(apr_pool_t *p,
const apr_array_header_t *arr);
/**
* Append one array to the end of another, creating a new array in the process.
* @param p The pool to allocate the new array out of
* @param first The array to put first in the new array.
* @param second The array to put second in the new array.
* @return A new array containing the data from the two arrays passed in.
*/
APR_DECLARE(apr_array_header_t *) apr_array_append(apr_pool_t *p,
const apr_array_header_t *first,
const apr_array_header_t *second);
/**
* Generates a new string from the apr_pool_t containing the concatenated
* sequence of substrings referenced as elements within the array. The string
* will be empty if all substrings are empty or null, or if there are no
* elements in the array. If sep is non-NUL, it will be inserted between
* elements as a separator.
* @param p The pool to allocate the string out of
* @param arr The array to generate the string from
* @param sep The separator to use
* @return A string containing all of the data in the array.
*/
APR_DECLARE(char *) apr_array_pstrcat(apr_pool_t *p,
const apr_array_header_t *arr,
const char sep);
/**
* Make a new table
* @param p The pool to allocate the pool out of
* @param nelts The number of elements in the initial table.
* @return The new table.
* @warning This table can only store text data
*/
APR_DECLARE(apr_table_t *) apr_table_make(apr_pool_t *p, int nelts);
/**
* Create a new table and copy another table into it
* @param p The pool to allocate the new table out of
* @param t The table to copy
* @return A copy of the table passed in
*/
APR_DECLARE(apr_table_t *) apr_table_copy(apr_pool_t *p,
const apr_table_t *t);
/**
* Delete all of the elements from a table
* @param t The table to clear
*/
APR_DECLARE(void) apr_table_clear(apr_table_t *t);
/**
* Get the value associated with a given key from the table. After this call,
* The data is still in the table
* @param t The table to search for the key
* @param key The key to search for
* @return The value associated with the key
*/
APR_DECLARE(const char *) apr_table_get(const apr_table_t *t, const char *key);
/**
* Add a key/value pair to a table, if another element already exists with the
* same key, this will over-write the old data.
* @param t The table to add the data to.
* @param key The key fo use
* @param val The value to add
* @remark When adding data, this function makes a copy of both the key and the
* value.
*/
APR_DECLARE(void) apr_table_set(apr_table_t *t, const char *key,
const char *val);
/**
* Add a key/value pair to a table, if another element already exists with the
* same key, this will over-write the old data.
* @param t The table to add the data to.
* @param key The key to use
* @param val The value to add
* @warning When adding data, this function does not make a copy of the key or
* the value, so care should be taken to ensure that the values will
* not change after they have been added..
*/
APR_DECLARE(void) apr_table_setn(apr_table_t *t, const char *key,
const char *val);
/**
* Remove data from the table
* @param t The table to remove data from
* @param key The key of the data being removed
*/
APR_DECLARE(void) apr_table_unset(apr_table_t *t, const char *key);
/**
* Add data to a table by merging the value with data that has already been
* stored
* @param t The table to search for the data
* @param key The key to merge data for
* @param val The data to add
* @remark If the key is not found, then this function acts like apr_table_add
*/
APR_DECLARE(void) apr_table_merge(apr_table_t *t, const char *key,
const char *val);
/**
* Add data to a table by merging the value with data that has already been
* stored
* @param t The table to search for the data
* @param key The key to merge data for
* @param val The data to add
* @remark If the key is not found, then this function acts like apr_table_addn
*/
APR_DECLARE(void) apr_table_mergen(apr_table_t *t, const char *key,
const char *val);
/**
* Add data to a table, regardless of whether there is another element with the
* same key.
* @param t The table to add to
* @param key The key to use
* @param val The value to add.
* @remark When adding data, this function makes a copy of both the key and the
* value.
*/
APR_DECLARE(void) apr_table_add(apr_table_t *t, const char *key,
const char *val);
/**
* Add data to a table, regardless of whether there is another element with the
* same key.
* @param t The table to add to
* @param key The key to use
* @param val The value to add.
* @remark When adding data, this function does not make a copy of the key or the
* value, so care should be taken to ensure that the values will not
* change after they have been added..
*/
APR_DECLARE(void) apr_table_addn(apr_table_t *t, const char *key,
const char *val);
/**
* Merge two tables into one new table
* @param p The pool to use for the new table
* @param overlay The first table to put in the new table
* @param base The table to add at the end of the new table
* @return A new table containing all of the data from the two passed in
*/
APR_DECLARE(apr_table_t *) apr_table_overlay(apr_pool_t *p,
const apr_table_t *overlay,
const apr_table_t *base);
/**
* Declaration prototype for the iterator callback function of apr_table_do()
* and apr_table_vdo().
* @param rec The data passed as the first argument to apr_table_[v]do()
* @param key The key from this iteration of the table
* @param value The value from this iteration of the table
* @remark Iteration continues while this callback function returns non-zero.
* To export the callback function for apr_table_[v]do() it must be declared
* in the _NONSTD convention.
*/
typedef int (apr_table_do_callback_fn_t)(void *rec, const char *key,
const char *value);
/**
* Iterate over a table running the provided function once for every
* element in the table. If there is data passed in as a vararg, then the
* function is only run on those elements whose key matches something in
* the vararg. If the vararg is NULL, then every element is run through the
* function. Iteration continues while the function returns non-zero.
* @param comp The function to run
* @param rec The data to pass as the first argument to the function
* @param t The table to iterate over
* @param ... The vararg. If this is NULL, then all elements in the table are
* run through the function, otherwise only those whose key matches
* are run.
* @return FALSE if one of the comp() iterations returned zero; TRUE if all
* iterations returned non-zero
* @see apr_table_do_callback_fn_t
*/
APR_DECLARE_NONSTD(int) apr_table_do(apr_table_do_callback_fn_t *comp,
void *rec, const apr_table_t *t, ...);
/**
* Iterate over a table running the provided function once for every
* element in the table. If there is data passed in as a vararg, then the
* function is only run on those element's whose key matches something in
* the vararg. If the vararg is NULL, then every element is run through the
* function. Iteration continues while the function returns non-zero.
* @param comp The function to run
* @param rec The data to pass as the first argument to the function
* @param t The table to iterate over
* @param vp The vararg table. If this is NULL, then all elements in the
* table are run through the function, otherwise only those
* whose key matches are run.
* @return FALSE if one of the comp() iterations returned zero; TRUE if all
* iterations returned non-zero
* @see apr_table_do_callback_fn_t
*/
APR_DECLARE(int) apr_table_vdo(apr_table_do_callback_fn_t *comp,
void *rec, const apr_table_t *t, va_list vp);
/** flag for overlap to use apr_table_setn */
#define APR_OVERLAP_TABLES_SET (0)
/** flag for overlap to use apr_table_mergen */
#define APR_OVERLAP_TABLES_MERGE (1)
/**
* For each element in table b, either use setn or mergen to add the data
* to table a. Which method is used is determined by the flags passed in.
* @param a The table to add the data to.
* @param b The table to iterate over, adding its data to table a
* @param flags How to add the table to table a. One of:
* APR_OVERLAP_TABLES_SET Use apr_table_setn
* APR_OVERLAP_TABLES_MERGE Use apr_table_mergen
* @remark This function is highly optimized, and uses less memory and CPU cycles
* than a function that just loops through table b calling other functions.
*/
/**
*<PRE>
* Conceptually, apr_table_overlap does this:
*
* apr_array_header_t *barr = apr_table_elts(b);
* apr_table_entry_t *belt = (apr_table_entry_t *)barr->elts;
* int i;
*
* for (i = 0; i < barr->nelts; ++i) {
* if (flags & APR_OVERLAP_TABLES_MERGE) {
* apr_table_mergen(a, belt[i].key, belt[i].val);
* }
* else {
* apr_table_setn(a, belt[i].key, belt[i].val);
* }
* }
*
* Except that it is more efficient (less space and cpu-time) especially
* when b has many elements.
*
* Notice the assumptions on the keys and values in b -- they must be
* in an ancestor of a's pool. In practice b and a are usually from
* the same pool.
* </PRE>
*/
APR_DECLARE(void) apr_table_overlap(apr_table_t *a, const apr_table_t *b,
unsigned flags);
/**
* Eliminate redunandant entries in a table by either overwriting
* or merging duplicates
*
* @param t Table.
* @param flags APR_OVERLAP_TABLES_MERGE to merge, or
* APR_OVERLAP_TABLES_SET to overwrite
*/
APR_DECLARE(void) apr_table_compress(apr_table_t *t, unsigned flags);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_TABLES_H */
--- NEW FILE: apr_atomic.h ---
/* 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_ATOMIC_H
#define APR_ATOMIC_H
/**
* @file apr_atomic.h
* @brief APR Atomic Operations
*/
#include "apr.h"
#include "apr_pools.h"
/* Platform includes for atomics */
#if defined(NETWARE) || defined(__MVS__) /* OS/390 */
#include <stdlib.h>
#elif defined(__FreeBSD__)
#include <machine/atomic.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup apr_atomic Atomic Operations
* @ingroup APR
* @{
*/
/* easiest way to get these documented for the moment */
#if defined(DOXYGEN)
/**
* structure for holding a atomic value.
* this number >only< has a 24 bit size on some platforms
*/
typedef apr_atomic_t;
/**
* this function is required on some platforms to initialize the
* atomic operation's internal structures
* @param p pool
* @return APR_SUCCESS on successful completion
*/
apr_status_t apr_atomic_init(apr_pool_t *p);
/**
* read the value stored in a atomic variable
* @param mem the pointer
* @warning on certain platforms this number is not stored
* directly in the pointer. in others it is
*/
apr_uint32_t apr_atomic_read(volatile apr_atomic_t *mem);
/**
* set the value for atomic.
* @param mem the pointer
* @param val the value
*/
void apr_atomic_set(volatile apr_atomic_t *mem, apr_uint32_t val);
/**
* Add 'val' to the atomic variable
* @param mem pointer to the atomic value
* @param val the addition
*/
void apr_atomic_add(volatile apr_atomic_t *mem, apr_uint32_t val);
/**
* increment the atomic variable by 1
* @param mem pointer to the atomic value
*/
void apr_atomic_inc(volatile apr_atomic_t *mem);
/**
* decrement the atomic variable by 1
* @param mem pointer to the atomic value
* @return zero if the value is zero, otherwise non-zero
*/
int apr_atomic_dec(volatile apr_atomic_t *mem);
/**
* compare the atomic's value with cmp.
* If they are the same swap the value with 'with'
* @param mem pointer to the atomic value
* @param with what to swap it with
* @param cmp the value to compare it to
* @return the old value of the atomic
* @warning do not mix apr_atomic's with the CAS function.
* on some platforms they may be implemented by different mechanisms
*/
apr_uint32_t apr_atomic_cas(volatile apr_uint32_t *mem, long with, long cmp);
/**
* compare the pointer's value with cmp.
* If they are the same swap the value with 'with'
* @param mem pointer to the pointer
* @param with what to swap it with
* @param cmp the value to compare it to
* @return the old value of the pointer
*/
void *apr_atomic_casptr(volatile void **mem, void *with, const void *cmp);
#else /* !DOXYGEN */
/* The following definitions provide optimized, OS-specific
* implementations of the APR atomic functions on various
* platforms. Any atomic operation that isn't redefined as
* a macro here will be declared as a function later, and
* apr_atomic.c will provide a mutex-based default implementation.
*/
#if defined(WIN32)
#define apr_atomic_t LONG
#define apr_atomic_add(mem, val) InterlockedExchangeAdd(mem,val)
#define apr_atomic_dec(mem) InterlockedDecrement(mem)
#define apr_atomic_inc(mem) InterlockedIncrement(mem)
#define apr_atomic_set(mem, val) InterlockedExchange(mem, val)
#define apr_atomic_read(mem) (*mem)
#define apr_atomic_cas(mem,with,cmp) InterlockedCompareExchange(mem,with,cmp)
#define apr_atomic_init(pool) APR_SUCCESS
#define apr_atomic_casptr(mem,with,cmp) InterlockedCompareExchangePointer(mem,with,cmp)
#elif defined(NETWARE)
#define apr_atomic_t unsigned long
#define apr_atomic_add(mem, val) atomic_add(mem,val)
#define apr_atomic_inc(mem) atomic_inc(mem)
#define apr_atomic_set(mem, val) (*mem = val)
#define apr_atomic_read(mem) (*mem)
#define apr_atomic_init(pool) APR_SUCCESS
#define apr_atomic_cas(mem,with,cmp) atomic_cmpxchg((unsigned long *)(mem),(unsigned long)(cmp),(unsigned long)(with))
int apr_atomic_dec(apr_atomic_t *mem);
void *apr_atomic_casptr(void **mem, void *with, const void *cmp);
#define APR_OVERRIDE_ATOMIC_DEC 1
#define APR_OVERRIDE_ATOMIC_CASPTR 1
inline int apr_atomic_dec(apr_atomic_t *mem)
{
return (atomic_xchgadd(mem, 0xFFFFFFFF) - 1);
}
inline void *apr_atomic_casptr(void **mem, void *with, const void *cmp)
{
return (void*)atomic_cmpxchg((unsigned long *)mem,(unsigned long)cmp,(unsigned long)with);
}
#elif defined(__FreeBSD__)
#define apr_atomic_t apr_uint32_t
#define apr_atomic_add(mem, val) (atomic_add_int(mem,val),mem)
#define apr_atomic_dec(mem) (atomic_subtract_int(mem,1),mem)
#define apr_atomic_inc(mem) (atomic_add_int(mem,1),mem)
#define apr_atomic_set(mem, val) (atomic_set_int(mem, val),mem)
#define apr_atomic_read(mem) (*mem)
#elif (defined(__linux__) || defined(__EMX__)) && defined(__i386__) && !APR_FORCE_ATOMIC_GENERIC
#define apr_atomic_t apr_uint32_t
#define apr_atomic_cas(mem,with,cmp) \
({ apr_atomic_t prev; \
asm volatile ("lock; cmpxchgl %1, %2" \
: "=a" (prev) \
: "r" (with), "m" (*(mem)), "0"(cmp) \
: "memory"); \
prev;})
#define apr_atomic_add(mem, val) \
({ register apr_atomic_t last; \
do { \
last = *(mem); \
} while (apr_atomic_cas((mem), last + (val), last) != last); \
})
#define apr_atomic_dec(mem) \
({ register apr_atomic_t last; \
do { \
last = *(mem); \
} while (apr_atomic_cas((mem), last - 1, last) != last); \
(--last != 0); })
#define apr_atomic_inc(mem) \
({ register apr_atomic_t last; \
do { \
last = *(mem); \
} while (apr_atomic_cas((mem), last + 1, last) != last); \
})
#define apr_atomic_set(mem, val) (*(mem) = val)
#define apr_atomic_read(mem) (*(mem))
#define apr_atomic_init(pool) APR_SUCCESS
#elif defined(__MVS__) /* OS/390 */
#define apr_atomic_t cs_t
apr_int32_t apr_atomic_add(volatile apr_atomic_t *mem, apr_int32_t val);
apr_uint32_t apr_atomic_cas(volatile apr_atomic_t *mem, apr_uint32_t swap,
apr_uint32_t cmp);
#define APR_OVERRIDE_ATOMIC_ADD 1
#define APR_OVERRIDE_ATOMIC_CAS 1
#define apr_atomic_inc(mem) apr_atomic_add(mem, 1)
#define apr_atomic_dec(mem) apr_atomic_add(mem, -1)
#define apr_atomic_init(pool) APR_SUCCESS
/* warning: the following two operations, _read and _set, are atomic
* if the memory variables are aligned (the usual case).
*
* If you try really hard and manage to mis-align them, they are not
* guaranteed to be atomic on S/390. But then your program will blow up
* with SIGBUS on a sparc, or with a S0C6 abend if you use the mis-aligned
* variables with other apr_atomic_* operations on OS/390.
*/
#define apr_atomic_read(p) (*p)
#define apr_atomic_set(mem, val) (*mem = val)
#endif /* end big if-elseif switch for platform-specifics */
/* Default implementation of the atomic API
* The definitions above may override some or all of the
* atomic functions with optimized, platform-specific versions.
* Any operation that hasn't been overridden as a macro above
* is declared as a function here, unless APR_OVERRIDE_ATOMIC_[OPERATION]
* is defined. (The purpose of the APR_OVERRIDE_ATOMIC_* is
* to allow a platform to declare an apr_atomic_*() function
* with a different signature than the default.)
*/
#if !defined(apr_atomic_t)
#define apr_atomic_t apr_uint32_t
#endif
#if !defined(apr_atomic_init) && !defined(APR_OVERRIDE_ATOMIC_INIT)
apr_status_t apr_atomic_init(apr_pool_t *p);
#endif
#if !defined(apr_atomic_read) && !defined(APR_OVERRIDE_ATOMIC_READ)
#define apr_atomic_read(p) *p
#endif
#if !defined(apr_atomic_set) && !defined(APR_OVERRIDE_ATOMIC_SET)
void apr_atomic_set(volatile apr_atomic_t *mem, apr_uint32_t val);
#define APR_ATOMIC_NEED_DEFAULT_INIT 1
#endif
#if !defined(apr_atomic_add) && !defined(APR_OVERRIDE_ATOMIC_ADD)
void apr_atomic_add(volatile apr_atomic_t *mem, apr_uint32_t val);
#define APR_ATOMIC_NEED_DEFAULT_INIT 1
#endif
#if !defined(apr_atomic_inc) && !defined(APR_OVERRIDE_ATOMIC_INC)
void apr_atomic_inc(volatile apr_atomic_t *mem);
#define APR_ATOMIC_NEED_DEFAULT_INIT 1
#endif
#if !defined(apr_atomic_dec) && !defined(APR_OVERRIDE_ATOMIC_DEC)
int apr_atomic_dec(volatile apr_atomic_t *mem);
#define APR_ATOMIC_NEED_DEFAULT_INIT 1
#endif
#if !defined(apr_atomic_cas) && !defined(APR_OVERRIDE_ATOMIC_CAS)
apr_uint32_t apr_atomic_cas(volatile apr_uint32_t *mem,long with,long cmp);
#define APR_ATOMIC_NEED_DEFAULT_INIT 1
#endif
#if !defined(apr_atomic_casptr) && !defined(APR_OVERRIDE_ATOMIC_CASPTR)
#if APR_SIZEOF_VOIDP == 4
#define apr_atomic_casptr(mem, with, cmp) (void *)apr_atomic_cas((apr_uint32_t *)(mem), (long)(with), (long)cmp)
#else
void *apr_atomic_casptr(volatile void **mem, void *with, const void *cmp);
#define APR_ATOMIC_NEED_DEFAULT_INIT 1
#endif
#endif
#ifndef APR_ATOMIC_NEED_DEFAULT_INIT
#define APR_ATOMIC_NEED_DEFAULT_INIT 0
#endif
/* If we're using the default versions of any of the atomic functions,
* we'll need the atomic init to set up mutexes. If a platform-specific
* override above has replaced the atomic_init with a macro, it's an error.
*/
#if APR_ATOMIC_NEED_DEFAULT_INIT
#if defined(apr_atomic_init) || defined(APR_OVERRIDE_ATOMIC_INIT)
#error Platform has redefined apr_atomic_init, but other default default atomics require a default apr_atomic_init
#endif
#endif /* APR_ATOMIC_NEED_DEFAULT_INIT */
#endif /* !DOXYGEN */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_ATOMIC_H */
--- NEW FILE: apr.hw ---
/* 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_H
#define APR_H
/* GENERATED FILE WARNING! DO NOT EDIT apr.h
*
* You must modify apr.hw instead.
*
* And please, make an effort to stub apr.hnw and apr.h.in in the process.
*
* This is the Win32 specific version of apr.h. It is copied from
* apr.hw by the apr.dsp and libapr.dsp projects.
*/
/**
* @file apr.h
* @brief APR Platform Definitions
* @remark This is a generated header generated from include/apr.h.in by
* ./configure, or copied from include/apr.hw or include/apr.hnw
* for Win32 or Netware by those build environments, respectively.
*/
#if defined(WIN32) || defined(DOXYGEN)
/* Ignore most warnings (back down to /W3) for poorly constructed headers
*/
#if defined(_MSC_VER) && _MSC_VER >= 1200
#pragma warning(push, 3)
#endif
/* disable or reduce the frequency of...
* C4057: indirection to slightly different base types
* C4075: slight indirection changes (unsigned short* vs short[])
* C4100: unreferenced formal parameter
* C4127: conditional expression is constant
* C4201: nonstandard extension nameless struct/unions
* C4244: int to char/short - precision loss
* C4514: unreferenced inline function removed
*/
#pragma warning(disable: 4100 4127 4201 4514; once: 4057 4075 4244)
/* Ignore Microsoft's interpretation of secure development
* and the POSIX string handling API
*/
#if defined(_MSC_VER) && _MSC_VER >= 1400
#define _CRT_SECURE_NO_DEPRECATE
#pragma warning(disable: 4996)
#endif
/* Has windows.h already been included? If so, our preferences don't matter,
* but we will still need the winsock things no matter what was included.
* If not, include a restricted set of windows headers to our tastes.
*/
#ifndef _WINDOWS_
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef _WIN32_WINNT
/* Restrict the server to a subset of Windows NT 4.0 header files by default
*/
#define _WIN32_WINNT 0x0400
#endif
#ifndef NOUSER
#define NOUSER
#endif
#ifndef NOMCX
#define NOMCX
#endif
#ifndef NOIME
#define NOIME
#endif
#include <windows.h>
/*
* Add a _very_few_ declarations missing from the restricted set of headers
* (If this list becomes extensive, re-enable the required headers above!)
* winsock headers were excluded by WIN32_LEAN_AND_MEAN, so include them now
*/
#define SW_HIDE 0
#ifndef _WIN32_WCE
#include <winsock2.h>
#include <mswsock.h>
#else
#include <winsock.h>
#endif
#endif /* !_WINDOWS_ */
/**
* @defgroup apr_platform Platform Definitions
* @ingroup APR
* @{
*/
#define APR_INLINE __inline
#define APR_HAS_INLINE 1
#ifndef __attribute__
#define __attribute__(__x)
#endif
#define NO_USE_SIGACTION
#ifndef _WIN32_WCE
#define APR_HAVE_ARPA_INET_H 0
#define APR_HAVE_CONIO_H 1
#define APR_HAVE_CRYPT_H 0
#define APR_HAVE_CTYPE_H 1
#define APR_HAVE_DIRENT_H 0
#define APR_HAVE_ERRNO_H 1
#define APR_HAVE_FCNTL_H 1
#define APR_HAVE_IO_H 1
#define APR_HAVE_LIMITS_H 1
#define APR_HAVE_NETDB_H 0
#define APR_HAVE_NETINET_IN_H 0
#define APR_HAVE_NETINET_SCTP_H 0
#define APR_HAVE_NETINET_SCTP_UIO_H 0
#define APR_HAVE_NETINET_TCP_H 0
#define APR_HAVE_PTHREAD_H 0
#define APR_HAVE_SIGNAL_H 1
#define APR_HAVE_STDARG_H 1
#define APR_HAVE_STDINT_H 0
#define APR_HAVE_STDIO_H 1
#define APR_HAVE_STDLIB_H 1
#define APR_HAVE_STRING_H 1
#define APR_HAVE_STRINGS_H 0
#define APR_HAVE_SYS_SENDFILE_H 0
#define APR_HAVE_SYS_SIGNAL_H 0
#define APR_HAVE_SYS_SOCKET_H 0
#define APR_HAVE_SYS_SOCKIO_H 0
#define APR_HAVE_SYS_SYSLIMITS_H 0
#define APR_HAVE_SYS_TIME_H 0
#define APR_HAVE_SYS_TYPES_H 1
#define APR_HAVE_SYS_UIO_H 0
#define APR_HAVE_SYS_WAIT_H 0
#define APR_HAVE_UNISTD_H 0
#define APR_HAVE_STDDEF_H 1
#define APR_HAVE_PROCESS_H 1
#define APR_HAVE_TIME_H 1
#else
#define APR_HAVE_ARPA_INET_H 0
#define APR_HAVE_CONIO_H 0
#define APR_HAVE_CRYPT_H 0
#define APR_HAVE_CTYPE_H 0
#define APR_HAVE_DIRENT_H 0
#define APR_HAVE_ERRNO_H 0
#define APR_HAVE_FCNTL_H 0
#define APR_HAVE_IO_H 0
#define APR_HAVE_LIMITS_H 0
#define APR_HAVE_NETDB_H 0
#define APR_HAVE_NETINET_IN_H 0
#define APR_HAVE_NETINET_TCP_H 0
#define APR_HAVE_PTHREAD_H 0
#define APR_HAVE_SIGNAL_H 0
#define APR_HAVE_STDARG_H 0
#define APR_HAVE_STDINT_H 0
#define APR_HAVE_STDIO_H 1
#define APR_HAVE_STDLIB_H 1
#define APR_HAVE_STRING_H 1
#define APR_HAVE_STRINGS_H 0
#define APR_HAVE_SYS_SENDFILE_H 0
#define APR_HAVE_SYS_SIGNAL_H 0
#define APR_HAVE_SYS_SOCKET_H 0
#define APR_HAVE_SYS_SYSLIMITS_H 0
#define APR_HAVE_SYS_TIME_H 0
#define APR_HAVE_SYS_TYPES_H 0
#define APR_HAVE_SYS_UIO_H 0
#define APR_HAVE_SYS_WAIT_H 0
#define APR_HAVE_UNISTD_H 0
#define APR_HAVE_STDDEF_H 0
#define APR_HAVE_PROCESS_H 0
#define APR_HAVE_TIME_H 0
#endif
#define APR_USE_FLOCK_SERIALIZE 0
#define APR_USE_SYSVSEM_SERIALIZE 0
#define APR_USE_FCNTL_SERIALIZE 0
#define APR_USE_PROC_PTHREAD_SERIALIZE 0
#define APR_USE_PTHREAD_SERIALIZE 0
#define APR_HAS_FLOCK_SERIALIZE 0
#define APR_HAS_SYSVSEM_SERIALIZE 0
#define APR_HAS_FCNTL_SERIALIZE 0
#define APR_HAS_PROC_PTHREAD_SERIALIZE 0
#define APR_HAS_RWLOCK_SERIALIZE 0
#define APR_HAS_LOCK_CREATE_NP 0
#define APR_PROCESS_LOCK_IS_GLOBAL 0
#define APR_USES_ANONYMOUS_SHM 0
#define APR_USES_FILEBASED_SHM 0
#define APR_USES_KEYBASED_SHM 0
#define APR_FILE_BASED_SHM 0
#define APR_MEM_BASED_SHM 0
#define APR_HAVE_CORKABLE_TCP 0
#define APR_HAVE_GETRLIMIT 0
#define APR_HAVE_ICONV 0
#define APR_HAVE_IN_ADDR 1
#define APR_HAVE_INET_ADDR 1
#define APR_HAVE_INET_NETWORK 0
#define APR_HAVE_IPV6 0
#define APR_HAVE_MEMMOVE 1
#define APR_HAVE_SETRLIMIT 0
#define APR_HAVE_SIGACTION 0
#define APR_HAVE_SIGSUSPEND 0
#define APR_HAVE_SIGWAIT 0
#define APR_HAVE_STRCASECMP 0
#define APR_HAVE_STRDUP 1
#define APR_HAVE_STRNCASECMP 0
#define APR_HAVE_STRSTR 1
#define APR_HAVE_MEMCHR 1
#define APR_HAVE_STRUCT_RLIMIT 0
#define APR_HAVE_UNION_SEMUN 0
#define APR_HAVE_SCTP 0
#ifndef _WIN32_WCE
#define APR_HAVE_STRICMP 1
#define APR_HAVE_STRNICMP 1
#else
#define APR_HAVE_STRICMP 0
#define APR_HAVE_STRNICMP 0
#endif
/** @} */
/* We don't include our conditional headers within the doxyblocks
* or the extern "C" namespace
*/
#if APR_HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if APR_HAVE_STDIO_H
#include <stdio.h>
#endif
#if APR_HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#if APR_HAVE_STDDEF_H
#include <stddef.h>
#endif
#if APR_HAVE_TIME_H
#include <time.h>
#endif
#if APR_HAVE_PROCESS_H
#include <process.h>
#endif
#if APR_HAVE_IPV6
#include <ws2tcpip.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup apr_platform
* @ingroup APR
* @{
*/
/* APR Feature Macros */
#define APR_HAS_SHARED_MEMORY 1
#define APR_HAS_THREADS 1
#define APR_HAS_MMAP 1
#define APR_HAS_FORK 0
#define APR_HAS_RANDOM 1
#define APR_HAS_OTHER_CHILD 1
#define APR_HAS_DSO 1
#define APR_HAS_SO_ACCEPTFILTER 0
#define APR_HAS_UNICODE_FS 1
#define APR_HAS_PROC_INVOKED 1
#ifndef _WIN32_WCE
#define APR_HAS_SENDFILE 1
#define APR_HAS_USER 1
#define APR_HAS_LARGE_FILES 1
#define APR_HAS_XTHREAD_FILES 1
#else
#define APR_HAS_SENDFILE 0
#define APR_HAS_USER 0
#define APR_HAS_LARGE_FILES 0
#define APR_HAS_XTHREAD_FILES 0
#endif
#define APR_HAS_OS_UUID 1
/* Win32 cannot poll [just yet] on files/pipes.
*/
#define APR_FILES_AS_SOCKETS 0
/* Not all platforms have a real INADDR_NONE. This macro replaces INADDR_NONE
* on all platforms.
*/
#define APR_INADDR_NONE INADDR_NONE
/* This macro indicates whether or not EBCDIC is the native character set.
*/
#define APR_CHARSET_EBCDIC 0
/* Is the TCP_NODELAY socket option inherited from listening sockets?
*/
#define APR_TCP_NODELAY_INHERITED 1
/* Is the O_NONBLOCK flag inherited from listening sockets?
*/
#define APR_O_NONBLOCK_INHERITED 1
/* Typedefs that APR needs. */
typedef unsigned char apr_byte_t;
typedef short apr_int16_t;
typedef unsigned short apr_uint16_t;
typedef int apr_int32_t;
typedef unsigned int apr_uint32_t;
typedef __int64 apr_int64_t;
typedef unsigned __int64 apr_uint64_t;
typedef size_t apr_size_t;
#if APR_HAVE_STDDEF_H
typedef ptrdiff_t apr_ssize_t;
#else
typedef int apr_ssize_t;
#endif
#if APR_HAS_LARGE_FILES
typedef __int64 apr_off_t;
#else
typedef int apr_off_t;
#endif
typedef int apr_socklen_t;
#ifdef WIN64
#define APR_SIZEOF_VOIDP 8
#else
#define APR_SIZEOF_VOIDP 4
#endif
/* XXX These simply don't belong here, perhaps in apr_portable.h
* based on some APR_HAVE_PID/GID/UID?
*/
typedef int pid_t;
typedef int uid_t;
typedef int gid_t;
/* Mechanisms to properly type numeric literals */
#define APR_INT64_C(val) (val##i64)
#if APR_HAVE_IPV6
/* Appears in later flavors, not the originals. */
#ifndef in_addr6
#define in6_addr in_addr6
#endif
#ifndef WS2TCPIP_INLINE
#define IN6_IS_ADDR_V4MAPPED(a) \
( (*(const apr_uint64_t *)(const void *)(&(a)->s6_addr[0]) == 0) \
&& (*(const apr_uint32_t *)(const void *)(&(a)->s6_addr[8]) == ntohl(0x0000ffff)))
#endif
#endif /* APR_HAS_IPV6 */
/* Definitions that APR programs need to work properly. */
/**
* Thread callbacks from APR functions must be declared with APR_THREAD_FUNC,
* so that they follow the platform's calling convention.
* @example
*/
/** void* APR_THREAD_FUNC my_thread_entry_fn(apr_thread_t *thd, void *data);
*/
#define APR_THREAD_FUNC __stdcall
#if defined(DOXYGEN) || !defined(WIN32)
/**
* The public APR functions are declared with APR_DECLARE(), so they may
* use the most appropriate calling convention. Public APR functions with
* variable arguments must use APR_DECLARE_NONSTD().
*
* @remark Both the declaration and implementations must use the same macro.
* @example
*/
/** APR_DECLARE(rettype) apr_func(args)
* @see APR_DECLARE_NONSTD @see APR_DECLARE_DATA
* @remark Note that when APR compiles the library itself, it passes the
* symbol -DAPR_DECLARE_EXPORT to the compiler on some platforms (e.g. Win32)
* to export public symbols from the dynamic library build.\n
* The user must define the APR_DECLARE_STATIC when compiling to target
* the static APR library on some platforms (e.g. Win32.) The public symbols
* are neither exported nor imported when APR_DECLARE_STATIC is defined.\n
* By default, compiling an application and including the APR public
* headers, without defining APR_DECLARE_STATIC, will prepare the code to be
* linked to the dynamic library.
*/
#define APR_DECLARE(type) type
/**
* The public APR functions using variable arguments are declared with
* APR_DECLARE_NONSTD(), as they must follow the C language calling convention.
* @see APR_DECLARE @see APR_DECLARE_DATA
* @remark Both the declaration and implementations must use the same macro.
* @example
*/
/** APR_DECLARE_NONSTD(rettype) apr_func(args, ...);
*/
#define APR_DECLARE_NONSTD(type) type
/**
* The public APR variables are declared with AP_MODULE_DECLARE_DATA.
* This assures the appropriate indirection is invoked at compile time.
* @see APR_DECLARE @see APR_DECLARE_NONSTD
* @remark Note that the declaration and implementations use different forms,
* but both must include the macro.
* @example
*/
/** extern APR_DECLARE_DATA type apr_variable;\n
* APR_DECLARE_DATA type apr_variable = value;
*/
#define APR_DECLARE_DATA
#elif defined(APR_DECLARE_STATIC)
#define APR_DECLARE(type) type __stdcall
#define APR_DECLARE_NONSTD(type) type
#define APR_DECLARE_DATA
#elif defined(APR_DECLARE_EXPORT)
#define APR_DECLARE(type) __declspec(dllexport) type __stdcall
#define APR_DECLARE_NONSTD(type) __declspec(dllexport) type
#define APR_DECLARE_DATA __declspec(dllexport)
#else
#define APR_DECLARE(type) __declspec(dllimport) type __stdcall
#define APR_DECLARE_NONSTD(type) __declspec(dllimport) type
#define APR_DECLARE_DATA __declspec(dllimport)
#endif
#ifdef WIN64
#define APR_SSIZE_T_FMT "I64d"
#define APR_SIZE_T_FMT "I64d"
#else
#define APR_SSIZE_T_FMT "d"
#define APR_SIZE_T_FMT "d"
#endif
#if APR_HAS_LARGE_FILES
#define APR_OFF_T_FMT "I64d"
#else
#define APR_OFF_T_FMT "d"
#endif
#define APR_PID_T_FMT "d"
#define APR_INT64_T_FMT "I64d"
#define APR_INT64_T_FMT_LEN 4
#define APR_UINT64_T_FMT "I64u"
#define APR_UINT64_T_FMT_LEN 4
#define APR_UINT64_T_HEX_FMT "I64x"
#define APR_UINT64_T_HEX_FMT_LEN (sizeof(APR_UINT64_T_HEX_FMT) - 1)
/* Deal with atoi64 variables ... these should move to apr_private.h */
/* MSVC 7.0 introduced _strtoui64 */
#if _MSC_VER >= 1300 && _INTEGRAL_MAX_BITS >= 64
#define APR_HAVE_INT64_STRFN 1
#define APR_INT64_STRFN _strtoui64
#else
#define APR_HAVE_INT64_STRFN 0
#define APR_INT64_STRFN undef
#endif
/* Local machine definition for console and log output. */
#define APR_EOL_STR "\r\n"
/* No difference between PROC and GLOBAL mutex */
#define APR_PROC_MUTEX_IS_GLOBAL 1
typedef int apr_wait_t;
/* struct iovec is needed to emulate Unix writev */
struct iovec {
char* iov_base;
apr_size_t iov_len;
};
/* Nasty Win32 .h ommissions we really need */
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
#if APR_HAS_UNICODE_FS
/* An arbitrary size that is digestable. True max is a bit less than 32000 */
#define APR_PATH_MAX 8192
#else /* !APR_HAS_UNICODE_FS */
#define APR_PATH_MAX MAX_PATH
#endif
/** @} */
#ifdef __cplusplus
}
#endif
/* Done with badly written headers
*/
#if defined(_MSC_VER) && _MSC_VER >= 1200
#pragma warning(pop)
#endif
/* Ignore Microsoft's interpretation of secure development
* and their opinion of the POSIX standard string handling API
*/
#if defined(_MSC_VER) && _MSC_VER >= 1400
#define _CRT_SECURE_NO_DEPRECATE
#pragma warning(disable: 4996)
#endif
#endif /* WIN32 */
#endif /* APR_H */
--- NEW FILE: apr_errno.h ---
/* 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_ERRNO_H
#define APR_ERRNO_H
[...1180 lines suppressed...]
/** inappropiate file type or format */
#define APR_STATUS_IS_EFTYPE(s) ((s) == APR_EFTYPE)
/** broken pipe */
#define APR_STATUS_IS_EPIPE(s) ((s) == APR_EPIPE)
/** cross device link */
#define APR_STATUS_IS_EXDEV(s) ((s) == APR_EXDEV)
/** Directory Not Empty */
#define APR_STATUS_IS_ENOTEMPTY(s) ((s) == APR_ENOTEMPTY || \
(s) == APR_EEXIST)
/** @} */
#endif /* !defined(NETWARE) && !defined(OS2) && !defined(WIN32) */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_ERRNO_H */
--- NEW FILE: apr_want.h ---
/* 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 "apr.h" /* configuration data */
/**
* @file apr_want.h
* @brief APR Standard Headers Support
*
* <PRE>
* Features:
*
* APR_WANT_STRFUNC: strcmp, strcat, strcpy, etc
* APR_WANT_MEMFUNC: memcmp, memcpy, etc
* APR_WANT_STDIO: <stdio.h> and related bits
* APR_WANT_IOVEC: struct iovec
* APR_WANT_BYTEFUNC: htons, htonl, ntohl, ntohs
*
* Typical usage:
*
* #define APR_WANT_STRFUNC
* #define APR_WANT_MEMFUNC
* #include "apr_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 apr_want.h)
* </PRE>
*/
/* --------------------------------------------------------------------- */
#ifdef APR_WANT_STRFUNC
#if APR_HAVE_STRING_H
#include <string.h>
#endif
#if APR_HAVE_STRINGS_H
#include <strings.h>
#endif
#undef APR_WANT_STRFUNC
#endif
/* --------------------------------------------------------------------- */
#ifdef APR_WANT_MEMFUNC
#if APR_HAVE_STRING_H
#include <string.h>
#endif
#undef APR_WANT_MEMFUNC
#endif
/* --------------------------------------------------------------------- */
#ifdef APR_WANT_STDIO
#if APR_HAVE_STDIO_H
#include <stdio.h>
#endif
#undef APR_WANT_STDIO
#endif
/* --------------------------------------------------------------------- */
#ifdef APR_WANT_IOVEC
#if APR_HAVE_SYS_UIO_H
#include <sys/uio.h>
#endif
#undef APR_WANT_IOVEC
#endif
/* --------------------------------------------------------------------- */
#ifdef APR_WANT_BYTEFUNC
/* Single Unix says they are in arpa/inet.h. Linux has them in
* netinet/in.h. FreeBSD has them in arpa/inet.h but requires that
* netinet/in.h be included first.
*/
#if APR_HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#if APR_HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#undef APR_WANT_BYTEFUNC
#endif
/* --------------------------------------------------------------------- */
--- NEW FILE: apr_env.h ---
/* 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_ENV_H
#define APR_ENV_H
/**
* @file apr_env.h
* @brief APR Environment functions
*/
#include "apr_errno.h"
#include "apr_pools.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_env Functions for manupulating the environment
* @ingroup APR
* @{
*/
/**
* Get the value of an environment variable
* @param value the returned value, allocated from @a pool
* @param envvar the name of the environment variable
* @param pool where to allocate @a value and any temporary storage from
*/
APR_DECLARE(apr_status_t) apr_env_get(char **value, const char *envvar,
apr_pool_t *pool);
/**
* Set the value of an environment variable
* @param envvar the name of the environment variable
* @param value the value to set
* @param pool where to allocate temporary storage from
*/
APR_DECLARE(apr_status_t) apr_env_set(const char *envvar, const char *value,
apr_pool_t *pool);
/**
* Delete a variable from the environment
* @param envvar the name of the environment variable
* @param pool where to allocate temporary storage from
*/
APR_DECLARE(apr_status_t) apr_env_delete(const char *envvar, apr_pool_t *pool);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_ENV_H */
--- NEW FILE: apr_user.h ---
/* 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_USER_H
#define APR_USER_H
/**
* @file apr_user.h
* @brief APR User ID Services
*/
#include "apr.h"
#include "apr_errno.h"
#include "apr_pools.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_user User and Group ID Services
* @ingroup APR
* @{
*/
/**
* Structure for determining user ownership.
*/
#ifdef WIN32
typedef PSID apr_uid_t;
#else
typedef uid_t apr_uid_t;
#endif
/**
* Structure for determining group ownership.
*/
#ifdef WIN32
typedef PSID apr_gid_t;
#else
typedef gid_t apr_gid_t;
#endif
#if APR_HAS_USER
/**
* Get the userid (and groupid) of the calling process
* @param userid Returns the user id
* @param groupid Returns the user's group id
* @param p The pool from which to allocate working space
* @remark This function is available only if APR_HAS_USER is defined.
*/
APR_DECLARE(apr_status_t) apr_uid_current(apr_uid_t *userid,
apr_gid_t *groupid,
apr_pool_t *p);
/** @deprecated @see apr_uid_current */
APR_DECLARE(apr_status_t) apr_current_userid(apr_uid_t *userid,
apr_gid_t *groupid,
apr_pool_t *p);
/**
* Get the user name for a specified userid
* @param username Pointer to new string containing user name (on output)
* @param userid The userid
* @param p The pool from which to allocate the string
* @remark This function is available only if APR_HAS_USER is defined.
*/
APR_DECLARE(apr_status_t) apr_uid_name_get(char **username, apr_uid_t userid,
apr_pool_t *p);
/** @deprecated @see apr_uid_name_get */
APR_DECLARE(apr_status_t) apr_get_username(char **username, apr_uid_t userid,
apr_pool_t *p);
/**
* Get the userid (and groupid) for the specified username
* @param userid Returns the user id
* @param groupid Returns the user's group id
* @param username The username to lookup
* @param p The pool from which to allocate working space
* @remark This function is available only if APR_HAS_USER is defined.
*/
APR_DECLARE(apr_status_t) apr_uid_get(apr_uid_t *userid, apr_gid_t *groupid,
const char *username, apr_pool_t *p);
/** @deprecated @see apr_uid_get */
APR_DECLARE(apr_status_t) apr_get_userid(apr_uid_t *userid, apr_gid_t *groupid,
const char *username, apr_pool_t *p);
/**
* Get the home directory for the named user
* @param dirname Pointer to new string containing directory name (on output)
* @param username The named user
* @param p The pool from which to allocate the string
* @remark This function is available only if APR_HAS_USER is defined.
*/
APR_DECLARE(apr_status_t) apr_uid_homepath_get(char **dirname,
const char *username,
apr_pool_t *p);
/** @deprecated @see apr_uid_homepath_get */
APR_DECLARE(apr_status_t) apr_get_home_directory(char **dirname,
const char *username,
apr_pool_t *p);
/**
* Compare two user identifiers for equality.
* @param left One uid to test
* @param right Another uid to test
* @return APR_SUCCESS if the apr_uid_t strutures identify the same user,
* APR_EMISMATCH if not, APR_BADARG if an apr_uid_t is invalid.
* @remark This function is available only if APR_HAS_USER is defined.
*/
#if defined(WIN32)
APR_DECLARE(apr_status_t) apr_uid_compare(apr_uid_t left, apr_uid_t right);
/** @deprecated @see apr_uid_compare */
APR_DECLARE(apr_status_t) apr_compare_users(apr_uid_t left, apr_uid_t right);
#else
#define apr_uid_compare(left,right) (((left) == (right)) ? APR_SUCCESS : APR_EMISMATCH)
/** @deprecated @see apr_uid_compare */
#define apr_compare_users(left,right) (((left) == (right)) ? APR_SUCCESS : APR_EMISMATCH)
#endif
/**
* Get the group name for a specified groupid
* @param groupname Pointer to new string containing group name (on output)
* @param groupid The groupid
* @param p The pool from which to allocate the string
* @remark This function is available only if APR_HAS_USER is defined.
*/
APR_DECLARE(apr_status_t) apr_gid_name_get(char **groupname,
apr_gid_t groupid, apr_pool_t *p);
/** @deprecated @see apr_gid_name_get */
APR_DECLARE(apr_status_t) apr_group_name_get(char **groupname,
apr_gid_t groupid, apr_pool_t *p);
/** @deprecated @see apr_gid_name_get */
APR_DECLARE(apr_status_t) apr_get_groupname(char **groupname,
apr_gid_t groupid, apr_pool_t *p);
/**
* Get the groupid for a specified group name
* @param groupid Pointer to the group id (on output)
* @param groupname The group name to look up
* @param p The pool from which to allocate the string
* @remark This function is available only if APR_HAS_USER is defined.
*/
APR_DECLARE(apr_status_t) apr_gid_get(apr_gid_t *groupid,
const char *groupname, apr_pool_t *p);
/** @deprecated @see apr_gid_get */
APR_DECLARE(apr_status_t) apr_get_groupid(apr_gid_t *groupid,
const char *groupname, apr_pool_t *p);
/**
* Compare two group identifiers for equality.
* @param left One gid to test
* @param right Another gid to test
* @return APR_SUCCESS if the apr_gid_t strutures identify the same group,
* APR_EMISMATCH if not, APR_BADARG if an apr_gid_t is invalid.
* @remark This function is available only if APR_HAS_USER is defined.
*/
#if defined(WIN32)
APR_DECLARE(apr_status_t) apr_gid_compare(apr_gid_t left, apr_gid_t right);
/** @deprecated @see apr_gid_compare */
APR_DECLARE(apr_status_t) apr_compare_groups(apr_gid_t left, apr_gid_t right);
#else
#define apr_gid_compare(left,right) (((left) == (right)) ? APR_SUCCESS : APR_EMISMATCH)
/** @deprecated @see apr_gid_compare */
#define apr_compare_groups(left,right) (((left) == (right)) ? APR_SUCCESS : APR_EMISMATCH)
#endif
#endif /* ! APR_HAS_USER */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_USER_H */
--- NEW FILE: apr_thread_rwlock.h ---
/* 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_THREAD_RWLOCK_H
#define APR_THREAD_RWLOCK_H
/**
* @file apr_thread_rwlock.h
* @brief APR Reader/Writer Lock Routines
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#if APR_HAS_THREADS
/**
* @defgroup apr_thread_rwlock Reader/Writer Lock Routines
* @ingroup APR
* @{
*/
/** Opaque read-write thread-safe lock. */
typedef struct apr_thread_rwlock_t apr_thread_rwlock_t;
/**
* Create and initialize a read-write lock that can be used to synchronize
* threads.
* @param rwlock the memory address where the newly created readwrite lock
* will be stored.
* @param pool the pool from which to allocate the mutex.
*/
APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
apr_pool_t *pool);
/**
* Acquire a shared-read lock on the given read-write lock. This will allow
* multiple threads to enter the same critical section while they have acquired
* the read lock.
* @param rwlock the read-write lock on which to acquire the shared read.
*/
APR_DECLARE(apr_status_t) apr_thread_rwlock_rdlock(apr_thread_rwlock_t *rwlock);
/**
* Attempt to acquire the shread-read lock on the given read-write lock. This
* is the same as apr_thread_rwlock_rdlock(), only that the funtion fails
* if there is another thread holding the write lock, or if there are any
* write threads blocking on the lock. If the function failes for this case,
* APR_EBUSY will be returned. Note: it is important that the
* APR_STATUS_IS_EBUSY(s) macro be used to determine if the return value was
* APR_EBUSY, for portability reasons.
* @param rwlock the rwlock on which to attempt the shared read.
*/
APR_DECLARE(apr_status_t) apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t *rwlock);
/**
* Acquire an exclusive-write lock on the given read-write lock. This will
* allow only one single thread to enter the critical sections. If there
* are any threads currently holding thee read-lock, this thread is put to
* sleep until it can have exclusive access to the lock.
* @param rwlock the read-write lock on which to acquire the exclusive write.
*/
APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock);
/**
* Attempt to acquire the exclusive-write lock on the given read-write lock.
* This is the same as apr_thread_rwlock_wrlock(), only that the funtion fails
* if there is any other thread holding the lock (for reading or writing),
* in which case the function will return APR_EBUSY. Note: it is important
* that the APR_STATUS_IS_EBUSY(s) macro be used to determine if the return
* value was APR_EBUSY, for portability reasons.
* @param rwlock the rwlock on which to attempt the exclusive write.
*/
APR_DECLARE(apr_status_t) apr_thread_rwlock_trywrlock(apr_thread_rwlock_t *rwlock);
/**
* Release either the read or write lock currently held by the calling thread
* associated with the given read-write lock.
* @param rwlock the read-write lock to be released (unlocked).
*/
APR_DECLARE(apr_status_t) apr_thread_rwlock_unlock(apr_thread_rwlock_t *rwlock);
/**
* Destroy the read-write lock and free the associated memory.
* @param rwlock the rwlock to destroy.
*/
APR_DECLARE(apr_status_t) apr_thread_rwlock_destroy(apr_thread_rwlock_t *rwlock);
/**
* Get the pool used by this thread_rwlock.
* @return apr_pool_t the pool
*/
APR_POOL_DECLARE_ACCESSOR(thread_rwlock);
#endif /* APR_HAS_THREADS */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_THREAD_RWLOCK_H */
--- NEW FILE: apr_thread_mutex.h ---
/* 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_THREAD_MUTEX_H
#define APR_THREAD_MUTEX_H
/**
* @file apr_thread_mutex.h
* @brief APR Thread Mutex Routines
*/
#include "apr.h"
#include "apr_errno.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#if APR_HAS_THREADS || defined(DOXYGEN)
/**
* @defgroup apr_thread_mutex Thread Mutex Routines
* @ingroup APR
* @{
*/
/** Opaque thread-local mutex structure */
typedef struct apr_thread_mutex_t apr_thread_mutex_t;
#define APR_THREAD_MUTEX_DEFAULT 0x0 /**< platform-optimal lock behavior */
#define APR_THREAD_MUTEX_NESTED 0x1 /**< enable nested (recursive) locks */
#define APR_THREAD_MUTEX_UNNESTED 0x2 /**< disable nested locks */
/* Delayed the include to avoid a circular reference */
#include "apr_pools.h"
/**
* Create and initialize a mutex that can be used to synchronize threads.
* @param mutex the memory address where the newly created mutex will be
* stored.
* @param flags Or'ed value of:
* <PRE>
* APR_THREAD_MUTEX_DEFAULT platform-optimal lock behavior.
* APR_THREAD_MUTEX_NESTED enable nested (recursive) locks.
* APR_THREAD_MUTEX_UNNESTED disable nested locks (non-recursive).
* </PRE>
* @param pool the pool from which to allocate the mutex.
* @warning Be cautious in using APR_THREAD_MUTEX_DEFAULT. While this is the
* most optimial mutex based on a given platform's performance charateristics,
* it will behave as either a nested or an unnested lock.
*/
APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
unsigned int flags,
apr_pool_t *pool);
/**
* Acquire the lock for the given mutex. If the mutex is already locked,
* the current thread will be put to sleep until the lock becomes available.
* @param mutex the mutex on which to acquire the lock.
*/
APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex);
/**
* Attempt to acquire the lock for the given mutex. If the mutex has already
* been acquired, the call returns immediately with APR_EBUSY. Note: it
* is important that the APR_STATUS_IS_EBUSY(s) macro be used to determine
* if the return value was APR_EBUSY, for portability reasons.
* @param mutex the mutex on which to attempt the lock acquiring.
*/
APR_DECLARE(apr_status_t) apr_thread_mutex_trylock(apr_thread_mutex_t *mutex);
/**
* Release the lock for the given mutex.
* @param mutex the mutex from which to release the lock.
*/
APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex);
/**
* Destroy the mutex and free the memory associated with the lock.
* @param mutex the mutex to destroy.
*/
APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex);
/**
* Get the pool used by this thread_mutex.
* @return apr_pool_t the pool
*/
APR_POOL_DECLARE_ACCESSOR(thread_mutex);
#endif /* APR_HAS_THREADS */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_THREAD_MUTEX_H */
--- NEW FILE: apr_fnmatch.h ---
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)fnmatch.h 8.1 (Berkeley) 6/2/93
*/
/* This file has been modified by the Apache Software Foundation. */
#ifndef _APR_FNMATCH_H_
#define _APR_FNMATCH_H_
/**
* @file apr_fnmatch.h
* @brief APR FNMatch Functions
*/
#include "apr_errno.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup apr_fnmatch Filename Matching Functions
* @ingroup APR
* @{
*/
#define APR_FNM_NOMATCH 1 /**< Match failed. */
#define APR_FNM_NOESCAPE 0x01 /**< Disable backslash escaping. */
#define APR_FNM_PATHNAME 0x02 /**< Slash must be matched by slash. */
#define APR_FNM_PERIOD 0x04 /**< Period must be matched by period. */
#define APR_FNM_CASE_BLIND 0x08 /**< Compare characters case-insensitively.
* @remark This flag is an Apache addition
*/
#define FNM_NOMATCH APR_FNM_NOMATCH /**< @deprecated @see APR_FNM_NOMATCH */
#define FNM_NOESCAPE APR_FNM_NOESCAPE /**< @deprecated @see APR_FNM_NOESCAPE */
#define FNM_PATHNAME APR_FNM_PATHNAME /**< @deprecated @see APR_FNM_PATHNAME */
#define FNM_PERIOD APR_FNM_PERIOD /**< @deprecated @see APR_FNM_PERIOD */
#define FNM_CASE_BLIND APR_FNM_CASE_BLIND /**< @deprecated @see APR_FNM_CASE_BLIND */
/**
* Try to match the string to the given pattern, return APR_SUCCESS if
* match, else return APR_FNM_NOMATCH.
* @param pattern The pattern to match to
* @param strings The string we are trying to match
* @param flags flags to use in the match. Bitwise OR of:
* <PRE>
* APR_FNM_NOESCAPE Disable backslash escaping
* APR_FNM_PATHNAME Slash must be matched by slash
* APR_FNM_PERIOD Period must be matched by period
* APR_FNM_CASE_BLIND Compare characters case-insensitively.
* </PRE>
*/
APR_DECLARE(apr_status_t) apr_fnmatch(const char *pattern,
const char *strings, int flags);
/**
* Determine if the given pattern is a regular expression.
* @param pattern The pattern to search for glob characters.
* @return non-zero if pattern has any glob characters in it
*/
APR_DECLARE(int) apr_fnmatch_test(const char *pattern);
/** @deprecated @see apr_fnmatch_test */
APR_DECLARE(int) apr_is_fnmatch(const char *pattern);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !_APR_FNMATCH_H_ */
--- NEW FILE: apr_strings.h ---
/* 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.
*/
/* Portions of this file are covered by */
/* -*- mode: c; c-file-style: "k&r" -*-
strnatcmp.c -- Perform 'natural order' comparisons of strings in C.
Copyright (C) 2000 by Martin Pool <mbp at humbug.org.au>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#ifndef APR_STRINGS_H
#define APR_STRINGS_H
/**
* @file apr_strings.h
* @brief APR Strings library
*/
#include "apr.h"
#include "apr_errno.h"
#include "apr_pools.h"
#define APR_WANT_IOVEC
#include "apr_want.h"
#if APR_HAVE_STDARG_H
#include <stdarg.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_strings String routines
* @ingroup APR
* @{
*/
/**
* Do a natural order comparison of two strings.
* @param a The first string to compare
* @param b The second string to compare
* @return Either <0, 0, or >0. If the first string is less than the second
* this returns <0, if they are equivalent it returns 0, and if the
* first string is greater than second string it retuns >0.
*/
APR_DECLARE(int) apr_strnatcmp(char const *a, char const *b);
/**
* Do a natural order comparison of two strings ignoring the case of the
* strings.
* @param a The first string to compare
* @param b The second string to compare
* @return Either <0, 0, or >0. If the first string is less than the second
* this returns <0, if they are equivalent it returns 0, and if the
* first string is greater than second string it retuns >0.
*/
APR_DECLARE(int) apr_strnatcasecmp(char const *a, char const *b);
/**
* duplicate a string into memory allocated out of a pool
* @param p The pool to allocate out of
* @param s The string to duplicate
* @return The new string
*/
APR_DECLARE(char *) apr_pstrdup(apr_pool_t *p, const char *s);
/**
* Create a null-terminated string by making a copy of a sequence
* of characters and appending a null byte
* @param p The pool to allocate out of
* @param s The block of characters to duplicate
* @param n The number of characters to duplicate
* @return The new string
* @remark This is a faster alternative to apr_pstrndup, for use
* when you know that the string being duplicated really
* has 'n' or more characters. If the string might contain
* fewer characters, use apr_pstrndup.
*/
APR_DECLARE(char *) apr_pstrmemdup(apr_pool_t *p, const char *s, apr_size_t n);
/**
* duplicate the first n characters of a string into memory allocated
* out of a pool; the new string will be null-terminated
* @param p The pool to allocate out of
* @param s The string to duplicate
* @param n The number of characters to duplicate
* @return The new string
*/
APR_DECLARE(char *) apr_pstrndup(apr_pool_t *p, const char *s, apr_size_t n);
/**
* Duplicate a block of memory.
*
* @param p The pool to allocate from
* @param m The memory to duplicate
* @param n The number of bytes to duplicate
* @return The new block of memory
*/
APR_DECLARE(void *) apr_pmemdup(apr_pool_t *p, const void *m, apr_size_t n);
/**
* Concatenate multiple strings, allocating memory out a pool
* @param p The pool to allocate out of
* @param ... The strings to concatenate. The final string must be NULL
* @return The new string
*/
APR_DECLARE_NONSTD(char *) apr_pstrcat(apr_pool_t *p, ...);
/**
* Concatenate multiple strings specified in a writev-style vector
* @param p The pool from which to allocate
* @param vec The strings to concatenate
* @param nvec The number of strings to concatenate
* @param nbytes (output) strlen of new string (pass in NULL to omit)
* @return The new string
*/
APR_DECLARE(char *) apr_pstrcatv(apr_pool_t *p, const struct iovec *vec,
apr_size_t nvec, apr_size_t *nbytes);
/**
* printf-style style printing routine. The data is output to a string
* allocated from a pool
* @param p The pool to allocate out of
* @param fmt The format of the string
* @param ap The arguments to use while printing the data
* @return The new string
*/
APR_DECLARE(char *) apr_pvsprintf(apr_pool_t *p, const char *fmt, va_list ap);
/**
* printf-style style printing routine. The data is output to a string
* allocated from a pool
* @param p The pool to allocate out of
* @param fmt The format of the string
* @param ... The arguments to use while printing the data
* @return The new string
*/
APR_DECLARE_NONSTD(char *) apr_psprintf(apr_pool_t *p, const char *fmt, ...)
__attribute__((format(printf,2,3)));
/**
* copy n characters from src to dst
* @param dst The destination string
* @param src The source string
* @param dst_size The space available in dst; dst always receives
* null-termination, so if src is longer than
* dst_size, the actual number of characters copied is
* dst_size - 1.
* @remark
* <PRE>
* We re-implement this function to implement these specific changes:
* 1) strncpy() doesn't always null terminate and we want it to.
* 2) strncpy() null fills, which is bogus, esp. when copy 8byte strings
* into 8k blocks.
* 3) Instead of returning the pointer to the beginning of the
* destination string, we return a pointer to the terminating null
* to allow us to check for truncation.
* </PRE>
*/
APR_DECLARE(char *) apr_cpystrn(char *dst, const char *src,
apr_size_t dst_size);
/**
* Strip spaces from a string
* @param dest The destination string. It is okay to modify the string
* in place. Namely dest == src
* @param src The string to rid the spaces from.
*/
APR_DECLARE(char *) apr_collapse_spaces(char *dest, const char *src);
/**
* Convert the arguments to a program from one string to an array of
* strings terminated by a NULL pointer
* @param arg_str The arguments to convert
* @param argv_out Output location. This is a pointer to an array of strings.
* @param token_context Pool to use.
*/
APR_DECLARE(apr_status_t) apr_tokenize_to_argv(const char *arg_str,
char ***argv_out,
apr_pool_t *token_context);
/**
* Split a string into separate null-terminated tokens. The tokens are
* delimited in the string by one or more characters from the sep
* argument.
* @param str The string to separate; this should be specified on the
* first call to apr_strtok() for a given string, and NULL
* on subsequent calls.
* @param sep The set of delimiters
* @param last Internal state saved by apr_strtok() between calls.
* @return The next token from the string
*/
APR_DECLARE(char *) apr_strtok(char *str, const char *sep, char **last);
/**
* @defgroup APR_Strings_Snprintf snprintf implementations
* @warning
* These are snprintf implementations based on apr_vformatter().
*
* Note that various standards and implementations disagree on the return
* value of snprintf, and side-effects due to %n in the formatting string.
* apr_snprintf (and apr_vsnprintf) behaves as follows:
*
* Process the format string until the entire string is exhausted, or
* the buffer fills. If the buffer fills then stop processing immediately
* (so no further %n arguments are processed), and return the buffer
* length. In all cases the buffer is NUL terminated. It will return the
* number of characters inserted into the buffer, not including the
* terminating NUL. As a special case, if len is 0, apr_snprintf will
* return the number of characters that would have been inserted if
* the buffer had been infinite (in this case, *buffer can be NULL)
*
* In no event does apr_snprintf return a negative number.
* @{
*/
/**
* snprintf routine based on apr_vformatter. This means it understands the
* same extensions.
* @param buf The buffer to write to
* @param len The size of the buffer
* @param format The format string
* @param ... The arguments to use to fill out the format string.
*/
APR_DECLARE_NONSTD(int) apr_snprintf(char *buf, apr_size_t len,
const char *format, ...)
__attribute__((format(printf,3,4)));
/**
* vsnprintf routine based on apr_vformatter. This means it understands the
* same extensions.
* @param buf The buffer to write to
* @param len The size of the buffer
* @param format The format string
* @param ap The arguments to use to fill out the format string.
*/
APR_DECLARE(int) apr_vsnprintf(char *buf, apr_size_t len, const char *format,
va_list ap);
/** @} */
/**
* create a string representation of an int, allocated from a pool
* @param p The pool from which to allocate
* @param n The number to format
* @return The string representation of the number
*/
APR_DECLARE(char *) apr_itoa(apr_pool_t *p, int n);
/**
* create a string representation of a long, allocated from a pool
* @param p The pool from which to allocate
* @param n The number to format
* @return The string representation of the number
*/
APR_DECLARE(char *) apr_ltoa(apr_pool_t *p, long n);
/**
* create a string representation of an apr_off_t, allocated from a pool
* @param p The pool from which to allocate
* @param n The number to format
* @return The string representation of the number
*/
APR_DECLARE(char *) apr_off_t_toa(apr_pool_t *p, apr_off_t n);
/**
* parse a numeric string into a 64-bit numeric value
* @param buf The string to parse. It may contain optional whitespace,
* followed by an optional '+' (positive, default) or '-' (negative)
* character, followed by an optional '0x' prefix if base is 0 or 16,
* followed by numeric digits appropriate for base.
* @param end A pointer to the end of the valid character in buf. If
* not nil, it is set to the first invalid character in buf.
* @param base A numeric base in the range between 2 and 36 inclusive,
* or 0. If base is zero, buf will be treated as base ten unless its
* digits are prefixed with '0x', in which case it will be treated as
* base 16.
* @return The numeric value of the string.
*/
APR_DECLARE(apr_int64_t) apr_strtoi64(const char *buf, char **end, int base);
/**
* parse a base-10 numeric string into a 64-bit numeric value.
* Equivalent to apr_strtoi64(buf, (char**)NULL, 10).
* @param buf The string to parse
* @return The numeric value of the string
*/
APR_DECLARE(apr_int64_t) apr_atoi64(const char *buf);
/**
* Format a binary size (magnitiudes are 2^10 rather than 10^3) from an apr_off_t,
* as bytes, K, M, T, etc, to a four character compacted human readable string.
* @param size The size to format
* @param buf The 5 byte text buffer (counting the trailing null)
* @return The buf passed to apr_strfsize()
* @remark All negative sizes report ' - ', apr_strfsize only formats positive values.
*/
APR_DECLARE(char *) apr_strfsize(apr_off_t size, char *buf);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_STRINGS_H */
--- NEW FILE: apr.h ---
/* 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_H
#define APR_H
/* GENERATED FILE WARNING! DO NOT EDIT apr.h
*
* You must modify apr.hw instead.
*
* And please, make an effort to stub apr.hnw and apr.h.in in the process.
*
* This is the Win32 specific version of apr.h. It is copied from
* apr.hw by the apr.dsp and libapr.dsp projects.
*/
/**
* @file apr.h
* @brief APR Platform Definitions
* @remark This is a generated header generated from include/apr.h.in by
* ./configure, or copied from include/apr.hw or include/apr.hnw
* for Win32 or Netware by those build environments, respectively.
*/
#if defined(WIN32) || defined(DOXYGEN)
/* Ignore most warnings (back down to /W3) for poorly constructed headers
*/
#if defined(_MSC_VER) && _MSC_VER >= 1200
#pragma warning(push, 3)
#endif
/* disable or reduce the frequency of...
* C4057: indirection to slightly different base types
* C4075: slight indirection changes (unsigned short* vs short[])
* C4100: unreferenced formal parameter
* C4127: conditional expression is constant
* C4201: nonstandard extension nameless struct/unions
* C4244: int to char/short - precision loss
* C4514: unreferenced inline function removed
*/
#pragma warning(disable: 4100 4127 4201 4514; once: 4057 4075 4244)
/* Ignore Microsoft's interpretation of secure development
* and the POSIX string handling API
*/
#if defined(_MSC_VER) && _MSC_VER >= 1400
#define _CRT_SECURE_NO_DEPRECATE
#pragma warning(disable: 4996)
#endif
/* Has windows.h already been included? If so, our preferences don't matter,
* but we will still need the winsock things no matter what was included.
* If not, include a restricted set of windows headers to our tastes.
*/
#ifndef _WINDOWS_
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef _WIN32_WINNT
/* Restrict the server to a subset of Windows NT 4.0 header files by default
*/
#define _WIN32_WINNT 0x0400
#endif
#ifndef NOUSER
#define NOUSER
#endif
#ifndef NOMCX
#define NOMCX
#endif
#ifndef NOIME
#define NOIME
#endif
#include <windows.h>
/*
* Add a _very_few_ declarations missing from the restricted set of headers
* (If this list becomes extensive, re-enable the required headers above!)
* winsock headers were excluded by WIN32_LEAN_AND_MEAN, so include them now
*/
#define SW_HIDE 0
#ifndef _WIN32_WCE
#include <winsock2.h>
#include <mswsock.h>
#else
#include <winsock.h>
#endif
#endif /* !_WINDOWS_ */
/**
* @defgroup apr_platform Platform Definitions
* @ingroup APR
* @{
*/
#define APR_INLINE __inline
#define APR_HAS_INLINE 1
#ifndef __attribute__
#define __attribute__(__x)
#endif
#define NO_USE_SIGACTION
#ifndef _WIN32_WCE
#define APR_HAVE_ARPA_INET_H 0
#define APR_HAVE_CONIO_H 1
#define APR_HAVE_CRYPT_H 0
#define APR_HAVE_CTYPE_H 1
#define APR_HAVE_DIRENT_H 0
#define APR_HAVE_ERRNO_H 1
#define APR_HAVE_FCNTL_H 1
#define APR_HAVE_IO_H 1
#define APR_HAVE_LIMITS_H 1
#define APR_HAVE_NETDB_H 0
#define APR_HAVE_NETINET_IN_H 0
#define APR_HAVE_NETINET_SCTP_H 0
#define APR_HAVE_NETINET_SCTP_UIO_H 0
#define APR_HAVE_NETINET_TCP_H 0
#define APR_HAVE_PTHREAD_H 0
#define APR_HAVE_SIGNAL_H 1
#define APR_HAVE_STDARG_H 1
#define APR_HAVE_STDINT_H 0
#define APR_HAVE_STDIO_H 1
#define APR_HAVE_STDLIB_H 1
#define APR_HAVE_STRING_H 1
#define APR_HAVE_STRINGS_H 0
#define APR_HAVE_SYS_SENDFILE_H 0
#define APR_HAVE_SYS_SIGNAL_H 0
#define APR_HAVE_SYS_SOCKET_H 0
#define APR_HAVE_SYS_SOCKIO_H 0
#define APR_HAVE_SYS_SYSLIMITS_H 0
#define APR_HAVE_SYS_TIME_H 0
#define APR_HAVE_SYS_TYPES_H 1
#define APR_HAVE_SYS_UIO_H 0
#define APR_HAVE_SYS_WAIT_H 0
#define APR_HAVE_UNISTD_H 0
#define APR_HAVE_STDDEF_H 1
#define APR_HAVE_PROCESS_H 1
#define APR_HAVE_TIME_H 1
#else
#define APR_HAVE_ARPA_INET_H 0
#define APR_HAVE_CONIO_H 0
#define APR_HAVE_CRYPT_H 0
#define APR_HAVE_CTYPE_H 0
#define APR_HAVE_DIRENT_H 0
#define APR_HAVE_ERRNO_H 0
#define APR_HAVE_FCNTL_H 0
#define APR_HAVE_IO_H 0
#define APR_HAVE_LIMITS_H 0
#define APR_HAVE_NETDB_H 0
#define APR_HAVE_NETINET_IN_H 0
#define APR_HAVE_NETINET_TCP_H 0
#define APR_HAVE_PTHREAD_H 0
#define APR_HAVE_SIGNAL_H 0
#define APR_HAVE_STDARG_H 0
#define APR_HAVE_STDINT_H 0
#define APR_HAVE_STDIO_H 1
#define APR_HAVE_STDLIB_H 1
#define APR_HAVE_STRING_H 1
#define APR_HAVE_STRINGS_H 0
#define APR_HAVE_SYS_SENDFILE_H 0
#define APR_HAVE_SYS_SIGNAL_H 0
#define APR_HAVE_SYS_SOCKET_H 0
#define APR_HAVE_SYS_SYSLIMITS_H 0
#define APR_HAVE_SYS_TIME_H 0
#define APR_HAVE_SYS_TYPES_H 0
#define APR_HAVE_SYS_UIO_H 0
#define APR_HAVE_SYS_WAIT_H 0
#define APR_HAVE_UNISTD_H 0
#define APR_HAVE_STDDEF_H 0
#define APR_HAVE_PROCESS_H 0
#define APR_HAVE_TIME_H 0
#endif
#define APR_USE_FLOCK_SERIALIZE 0
#define APR_USE_SYSVSEM_SERIALIZE 0
#define APR_USE_FCNTL_SERIALIZE 0
#define APR_USE_PROC_PTHREAD_SERIALIZE 0
#define APR_USE_PTHREAD_SERIALIZE 0
#define APR_HAS_FLOCK_SERIALIZE 0
#define APR_HAS_SYSVSEM_SERIALIZE 0
#define APR_HAS_FCNTL_SERIALIZE 0
#define APR_HAS_PROC_PTHREAD_SERIALIZE 0
#define APR_HAS_RWLOCK_SERIALIZE 0
#define APR_HAS_LOCK_CREATE_NP 0
#define APR_PROCESS_LOCK_IS_GLOBAL 0
#define APR_USES_ANONYMOUS_SHM 0
#define APR_USES_FILEBASED_SHM 0
#define APR_USES_KEYBASED_SHM 0
#define APR_FILE_BASED_SHM 0
#define APR_MEM_BASED_SHM 0
#define APR_HAVE_CORKABLE_TCP 0
#define APR_HAVE_GETRLIMIT 0
#define APR_HAVE_ICONV 0
#define APR_HAVE_IN_ADDR 1
#define APR_HAVE_INET_ADDR 1
#define APR_HAVE_INET_NETWORK 0
#define APR_HAVE_IPV6 0
#define APR_HAVE_MEMMOVE 1
#define APR_HAVE_SETRLIMIT 0
#define APR_HAVE_SIGACTION 0
#define APR_HAVE_SIGSUSPEND 0
#define APR_HAVE_SIGWAIT 0
#define APR_HAVE_STRCASECMP 0
#define APR_HAVE_STRDUP 1
#define APR_HAVE_STRNCASECMP 0
#define APR_HAVE_STRSTR 1
#define APR_HAVE_MEMCHR 1
#define APR_HAVE_STRUCT_RLIMIT 0
#define APR_HAVE_UNION_SEMUN 0
#define APR_HAVE_SCTP 0
#ifndef _WIN32_WCE
#define APR_HAVE_STRICMP 1
#define APR_HAVE_STRNICMP 1
#else
#define APR_HAVE_STRICMP 0
#define APR_HAVE_STRNICMP 0
#endif
/** @} */
/* We don't include our conditional headers within the doxyblocks
* or the extern "C" namespace
*/
#if APR_HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if APR_HAVE_STDIO_H
#include <stdio.h>
#endif
#if APR_HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#if APR_HAVE_STDDEF_H
#include <stddef.h>
#endif
#if APR_HAVE_TIME_H
#include <time.h>
#endif
#if APR_HAVE_PROCESS_H
#include <process.h>
#endif
#if APR_HAVE_IPV6
#include <ws2tcpip.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup apr_platform
* @ingroup APR
* @{
*/
/* APR Feature Macros */
#define APR_HAS_SHARED_MEMORY 1
#define APR_HAS_THREADS 1
#define APR_HAS_MMAP 1
#define APR_HAS_FORK 0
#define APR_HAS_RANDOM 1
#define APR_HAS_OTHER_CHILD 1
#define APR_HAS_DSO 1
#define APR_HAS_SO_ACCEPTFILTER 0
#define APR_HAS_UNICODE_FS 1
#define APR_HAS_PROC_INVOKED 1
#ifndef _WIN32_WCE
#define APR_HAS_SENDFILE 1
#define APR_HAS_USER 1
#define APR_HAS_LARGE_FILES 1
#define APR_HAS_XTHREAD_FILES 1
#else
#define APR_HAS_SENDFILE 0
#define APR_HAS_USER 0
#define APR_HAS_LARGE_FILES 0
#define APR_HAS_XTHREAD_FILES 0
#endif
#define APR_HAS_OS_UUID 1
/* Win32 cannot poll [just yet] on files/pipes.
*/
#define APR_FILES_AS_SOCKETS 0
/* Not all platforms have a real INADDR_NONE. This macro replaces INADDR_NONE
* on all platforms.
*/
#define APR_INADDR_NONE INADDR_NONE
/* This macro indicates whether or not EBCDIC is the native character set.
*/
#define APR_CHARSET_EBCDIC 0
/* Is the TCP_NODELAY socket option inherited from listening sockets?
*/
#define APR_TCP_NODELAY_INHERITED 1
/* Is the O_NONBLOCK flag inherited from listening sockets?
*/
#define APR_O_NONBLOCK_INHERITED 1
/* Typedefs that APR needs. */
typedef unsigned char apr_byte_t;
typedef short apr_int16_t;
typedef unsigned short apr_uint16_t;
typedef int apr_int32_t;
typedef unsigned int apr_uint32_t;
typedef __int64 apr_int64_t;
typedef unsigned __int64 apr_uint64_t;
typedef size_t apr_size_t;
#if APR_HAVE_STDDEF_H
typedef ptrdiff_t apr_ssize_t;
#else
typedef int apr_ssize_t;
#endif
#if APR_HAS_LARGE_FILES
typedef __int64 apr_off_t;
#else
typedef int apr_off_t;
#endif
typedef int apr_socklen_t;
#ifdef WIN64
#define APR_SIZEOF_VOIDP 8
#else
#define APR_SIZEOF_VOIDP 4
#endif
/* XXX These simply don't belong here, perhaps in apr_portable.h
* based on some APR_HAVE_PID/GID/UID?
*/
typedef int pid_t;
typedef int uid_t;
typedef int gid_t;
/* Mechanisms to properly type numeric literals */
#define APR_INT64_C(val) (val##i64)
#if APR_HAVE_IPV6
/* Appears in later flavors, not the originals. */
#ifndef in_addr6
#define in6_addr in_addr6
#endif
#ifndef WS2TCPIP_INLINE
#define IN6_IS_ADDR_V4MAPPED(a) \
( (*(const apr_uint64_t *)(const void *)(&(a)->s6_addr[0]) == 0) \
&& (*(const apr_uint32_t *)(const void *)(&(a)->s6_addr[8]) == ntohl(0x0000ffff)))
#endif
#endif /* APR_HAS_IPV6 */
/* Definitions that APR programs need to work properly. */
/**
* Thread callbacks from APR functions must be declared with APR_THREAD_FUNC,
* so that they follow the platform's calling convention.
* @example
*/
/** void* APR_THREAD_FUNC my_thread_entry_fn(apr_thread_t *thd, void *data);
*/
#define APR_THREAD_FUNC __stdcall
#if defined(DOXYGEN) || !defined(WIN32)
/**
* The public APR functions are declared with APR_DECLARE(), so they may
* use the most appropriate calling convention. Public APR functions with
* variable arguments must use APR_DECLARE_NONSTD().
*
* @remark Both the declaration and implementations must use the same macro.
* @example
*/
/** APR_DECLARE(rettype) apr_func(args)
* @see APR_DECLARE_NONSTD @see APR_DECLARE_DATA
* @remark Note that when APR compiles the library itself, it passes the
* symbol -DAPR_DECLARE_EXPORT to the compiler on some platforms (e.g. Win32)
* to export public symbols from the dynamic library build.\n
* The user must define the APR_DECLARE_STATIC when compiling to target
* the static APR library on some platforms (e.g. Win32.) The public symbols
* are neither exported nor imported when APR_DECLARE_STATIC is defined.\n
* By default, compiling an application and including the APR public
* headers, without defining APR_DECLARE_STATIC, will prepare the code to be
* linked to the dynamic library.
*/
#define APR_DECLARE(type) type
/**
* The public APR functions using variable arguments are declared with
* APR_DECLARE_NONSTD(), as they must follow the C language calling convention.
* @see APR_DECLARE @see APR_DECLARE_DATA
* @remark Both the declaration and implementations must use the same macro.
* @example
*/
/** APR_DECLARE_NONSTD(rettype) apr_func(args, ...);
*/
#define APR_DECLARE_NONSTD(type) type
/**
* The public APR variables are declared with AP_MODULE_DECLARE_DATA.
* This assures the appropriate indirection is invoked at compile time.
* @see APR_DECLARE @see APR_DECLARE_NONSTD
* @remark Note that the declaration and implementations use different forms,
* but both must include the macro.
* @example
*/
/** extern APR_DECLARE_DATA type apr_variable;\n
* APR_DECLARE_DATA type apr_variable = value;
*/
#define APR_DECLARE_DATA
#elif defined(APR_DECLARE_STATIC)
#define APR_DECLARE(type) type __stdcall
#define APR_DECLARE_NONSTD(type) type
#define APR_DECLARE_DATA
#elif defined(APR_DECLARE_EXPORT)
#define APR_DECLARE(type) __declspec(dllexport) type __stdcall
#define APR_DECLARE_NONSTD(type) __declspec(dllexport) type
#define APR_DECLARE_DATA __declspec(dllexport)
#else
#define APR_DECLARE(type) __declspec(dllimport) type __stdcall
#define APR_DECLARE_NONSTD(type) __declspec(dllimport) type
#define APR_DECLARE_DATA __declspec(dllimport)
#endif
#ifdef WIN64
#define APR_SSIZE_T_FMT "I64d"
#define APR_SIZE_T_FMT "I64d"
#else
#define APR_SSIZE_T_FMT "d"
#define APR_SIZE_T_FMT "d"
#endif
#if APR_HAS_LARGE_FILES
#define APR_OFF_T_FMT "I64d"
#else
#define APR_OFF_T_FMT "d"
#endif
#define APR_PID_T_FMT "d"
#define APR_INT64_T_FMT "I64d"
#define APR_INT64_T_FMT_LEN 4
#define APR_UINT64_T_FMT "I64u"
#define APR_UINT64_T_FMT_LEN 4
#define APR_UINT64_T_HEX_FMT "I64x"
#define APR_UINT64_T_HEX_FMT_LEN (sizeof(APR_UINT64_T_HEX_FMT) - 1)
/* Deal with atoi64 variables ... these should move to apr_private.h */
/* MSVC 7.0 introduced _strtoui64 */
#if _MSC_VER >= 1300 && _INTEGRAL_MAX_BITS >= 64
#define APR_HAVE_INT64_STRFN 1
#define APR_INT64_STRFN _strtoui64
#else
#define APR_HAVE_INT64_STRFN 0
#define APR_INT64_STRFN undef
#endif
/* Local machine definition for console and log output. */
#define APR_EOL_STR "\r\n"
/* No difference between PROC and GLOBAL mutex */
#define APR_PROC_MUTEX_IS_GLOBAL 1
typedef int apr_wait_t;
/* struct iovec is needed to emulate Unix writev */
struct iovec {
char* iov_base;
apr_size_t iov_len;
};
/* Nasty Win32 .h ommissions we really need */
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
#if APR_HAS_UNICODE_FS
/* An arbitrary size that is digestable. True max is a bit less than 32000 */
#define APR_PATH_MAX 8192
#else /* !APR_HAS_UNICODE_FS */
#define APR_PATH_MAX MAX_PATH
#endif
/** @} */
#ifdef __cplusplus
}
#endif
/* Done with badly written headers
*/
#if defined(_MSC_VER) && _MSC_VER >= 1200
#pragma warning(pop)
#endif
/* Ignore Microsoft's interpretation of secure development
* and their opinion of the POSIX standard string handling API
*/
#if defined(_MSC_VER) && _MSC_VER >= 1400
#define _CRT_SECURE_NO_DEPRECATE
#pragma warning(disable: 4996)
#endif
#endif /* WIN32 */
#endif /* APR_H */
--- NEW FILE: apr_signal.h ---
/* 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_SIGNAL_H
#define APR_SIGNAL_H
/**
* @file apr_signal.h
* @brief APR Signal Handling
*/
#include "apr.h"
#include "apr_pools.h"
#if APR_HAVE_SIGNAL_H
#include <signal.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_signal Handling
* @ingroup APR
* @{
*/
#if APR_HAVE_SIGACTION || defined(DOXYGEN)
#if defined(DARWIN) && !defined(__cplusplus) && !defined(_ANSI_SOURCE)
/* work around Darwin header file bugs
* http://www.opensource.apple.com/bugs/X/BSD%20Kernel/2657228.html
*/
#undef SIG_DFL
#undef SIG_IGN
#undef SIG_ERR
#define SIG_DFL (void (*)(int))0
#define SIG_IGN (void (*)(int))1
#define SIG_ERR (void (*)(int))-1
#endif
/** Function prototype for signal handlers */
typedef void apr_sigfunc_t(int);
/**
* Set the signal handler function for a given signal
* @param signo The signal (eg... SIGWINCH)
* @param func the function to get called
*/
APR_DECLARE(apr_sigfunc_t *) apr_signal(int signo, apr_sigfunc_t * func);
#if defined(SIG_IGN) && !defined(SIG_ERR)
#define SIG_ERR ((apr_sigfunc_t *) -1)
#endif
#else /* !APR_HAVE_SIGACTION */
#define apr_signal(a, b) signal(a, b)
#endif
/**
* Get the description for a specific signal number
* @param signum The signal number
* @return The description of the signal
*/
APR_DECLARE(const char *) apr_signal_description_get(int signum);
/** @deprecated @see apr_signal_description_get */
APR_DECLARE(const char *) apr_signal_get_description(int signum);
/**
* APR-private function for initializing the signal package
* @internal
* @param pglobal The internal, global pool
*/
void apr_signal_init(apr_pool_t *pglobal);
/** @} */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* APR_SIGNAL_H */
--- NEW FILE: apr_hash.h ---
/* 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_HASH_H
#define APR_HASH_H
/**
* @file apr_hash.h
* @brief APR Hash Tables
*/
#include "apr_pools.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup apr_hash Hash Tables
* @ingroup APR
* @{
*/
/**
* When passing a key to apr_hash_set or apr_hash_get, this value can be
* passed to indicate a string-valued key, and have apr_hash compute the
* length automatically.
*
* @remark apr_hash will use strlen(key) for the length. The null-terminator
* is not included in the hash value (why throw a constant in?).
* Since the hash table merely references the provided key (rather
* than copying it), apr_hash_this() will return the null-term'd key.
*/
#define APR_HASH_KEY_STRING (-1)
/**
* Abstract type for hash tables.
*/
typedef struct apr_hash_t apr_hash_t;
/**
* Abstract type for scanning hash tables.
*/
typedef struct apr_hash_index_t apr_hash_index_t;
/**
* Create a hash table.
* @param pool The pool to allocate the hash table out of
* @return The hash table just created
*/
APR_DECLARE(apr_hash_t *) apr_hash_make(apr_pool_t *pool);
/**
* Make a copy of a hash table
* @param pool The pool from which to allocate the new hash table
* @param h The hash table to clone
* @return The hash table just created
* @remark Makes a shallow copy
*/
APR_DECLARE(apr_hash_t *) apr_hash_copy(apr_pool_t *pool,
const apr_hash_t *h);
/**
* Associate a value with a key in a hash table.
* @param ht The hash table
* @param key Pointer to the key
* @param klen Length of the key. Can be APR_HASH_KEY_STRING to use the string length.
* @param val Value to associate with the key
* @remark If the value is NULL the hash entry is deleted.
*/
APR_DECLARE(void) apr_hash_set(apr_hash_t *ht, const void *key,
apr_ssize_t klen, const void *val);
/**
* Look up the value associated with a key in a hash table.
* @param ht The hash table
* @param key Pointer to the key
* @param klen Length of the key. Can be APR_HASH_KEY_STRING to use the string length.
* @return Returns NULL if the key is not present.
*/
APR_DECLARE(void *) apr_hash_get(apr_hash_t *ht, const void *key,
apr_ssize_t klen);
/**
* Start iterating over the entries in a hash table.
* @param p The pool to allocate the apr_hash_index_t iterator. If this
* pool is NULL, then an internal, non-thread-safe iterator is used.
* @param ht The hash table
* @remark There is no restriction on adding or deleting hash entries during
* an iteration (although the results may be unpredictable unless all you do
* is delete the current entry) and multiple iterations can be in
* progress at the same time.
* @example
*/
/**
* <PRE>
*
* int sum_values(apr_pool_t *p, apr_hash_t *ht)
* {
* apr_hash_index_t *hi;
* void *val;
* int sum = 0;
* for (hi = apr_hash_first(p, ht); hi; hi = apr_hash_next(hi)) {
* apr_hash_this(hi, NULL, NULL, &val);
* sum += *(int *)val;
* }
* return sum;
* }
* </PRE>
*/
APR_DECLARE(apr_hash_index_t *) apr_hash_first(apr_pool_t *p, apr_hash_t *ht);
/**
* Continue iterating over the entries in a hash table.
* @param hi The iteration state
* @return a pointer to the updated iteration state. NULL if there are no more
* entries.
*/
APR_DECLARE(apr_hash_index_t *) apr_hash_next(apr_hash_index_t *hi);
/**
* Get the current entry's details from the iteration state.
* @param hi The iteration state
* @param key Return pointer for the pointer to the key.
* @param klen Return pointer for the key length.
* @param val Return pointer for the associated value.
* @remark The return pointers should point to a variable that will be set to the
* corresponding data, or they may be NULL if the data isn't interesting.
*/
APR_DECLARE(void) apr_hash_this(apr_hash_index_t *hi, const void **key,
apr_ssize_t *klen, void **val);
/**
* Get the number of key/value pairs in the hash table.
* @param ht The hash table
* @return The number of key/value pairs in the hash table.
*/
APR_DECLARE(unsigned int) apr_hash_count(apr_hash_t *ht);
/**
* Merge two hash tables into one new hash table. The values of the overlay
* hash override the values of the base if both have the same key.
* @param p The pool to use for the new hash table
* @param overlay The table to add to the initial table
* @param base The table that represents the initial values of the new table
* @return A new hash table containing all of the data from the two passed in
*/
APR_DECLARE(apr_hash_t *) apr_hash_overlay(apr_pool_t *p,
const apr_hash_t *overlay,
const apr_hash_t *base);
/**
* Merge two hash tables into one new hash table. If the same key
* is present in both tables, call the supplied merge function to
* produce a merged value for the key in the new table.
* @param p The pool to use for the new hash table
* @param h1 The first of the tables to merge
* @param h2 The second of the tables to merge
* @param merger A callback function to merge values, or NULL to
* make values from h1 override values from h2 (same semantics as
* apr_hash_overlay())
* @param data Client data to pass to the merger function
* @return A new hash table containing all of the data from the two passed in
*/
APR_DECLARE(apr_hash_t *) apr_hash_merge(apr_pool_t *p,
const apr_hash_t *h1,
const apr_hash_t *h2,
void * (*merger)(apr_pool_t *p,
const void *key,
apr_ssize_t klen,
const void *h1_val,
const void *h2_val,
const void *data),
const void *data);
/**
* Get a pointer to the pool which the hash table was created in
*/
APR_POOL_DECLARE_ACCESSOR(hash);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_HASH_H */
--- NEW FILE: apr_lib.h ---
/* 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_LIB_H
#define APR_LIB_H
/**
* @file apr_lib.h
* This is collection of oddballs that didn't fit anywhere else,
* and might move to more appropriate headers with the release
* of APR 1.0.
* @brief APR general purpose library routines
*/
#include "apr.h"
#include "apr_errno.h"
#if APR_HAVE_CTYPE_H
#include <ctype.h>
#endif
#if APR_HAVE_STDARG_H
#include <stdarg.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_lib General Purpose Library Routines
* @ingroup APR
* This is collection of oddballs that didn't fit anywhere else,
* and might move to more appropriate headers with the release
* of APR 1.0.
* @{
*/
/** A constant representing a 'large' string. */
#define HUGE_STRING_LEN 8192
/*
* Define the structures used by the APR general-purpose library.
*/
/** @see apr_vformatter_buff_t */
typedef struct apr_vformatter_buff_t apr_vformatter_buff_t;
/**
* Structure used by the variable-formatter routines.
*/
struct apr_vformatter_buff_t {
/** The current position */
char *curpos;
/** The end position of the format string */
char *endpos;
};
/**
* return the final element of the pathname
* @param pathname The path to get the final element of
* @return the final element of the path
* @remark
* <PRE>
* For example:
* "/foo/bar/gum" -> "gum"
* "/foo/bar/gum/" -> ""
* "gum" -> "gum"
* "bs\\path\\stuff" -> "stuff"
* </PRE>
*/
APR_DECLARE(const char *) apr_filepath_name_get(const char *pathname);
/** @deprecated @see apr_filepath_name_get */
APR_DECLARE(const char *) apr_filename_of_pathname(const char *pathname);
/**
* apr_killpg
* Small utility macros to make things easier to read. Not usually a
* goal, to be sure..
*/
#ifdef WIN32
#define apr_killpg(x, y)
#else /* WIN32 */
#ifdef NO_KILLPG
#define apr_killpg(x, y) (kill (-(x), (y)))
#else /* NO_KILLPG */
#define apr_killpg(x, y) (killpg ((x), (y)))
#endif /* NO_KILLPG */
#endif /* WIN32 */
/**
* apr_vformatter() is a generic printf-style formatting routine
* with some extensions.
* @param flush_func The function to call when the buffer is full
* @param c The buffer to write to
* @param fmt The format string
* @param ap The arguments to use to fill out the format string.
*
* @remark
* <PRE>
* The extensions are:
*
* %%pA takes a struct in_addr *, and prints it as a.b.c.d
* %%pI takes an apr_sockaddr_t * and prints it as a.b.c.d:port or
* [ipv6-address]:port
* %%pT takes an apr_os_thread_t * and prints it in decimal
* ('0' is printed if !APR_HAS_THREADS)
* %%pp takes a void * and outputs it in hex
*
* The %%p hacks are to force gcc's printf warning code to skip
* over a pointer argument without complaining. This does
* mean that the ANSI-style %%p (output a void * in hex format) won't
* work as expected at all, but that seems to be a fair trade-off
* for the increased robustness of having printf-warnings work.
*
* Additionally, apr_vformatter allows for arbitrary output methods
* using the apr_vformatter_buff and flush_func.
*
* The apr_vformatter_buff has two elements curpos and endpos.
* curpos is where apr_vformatter will write the next byte of output.
* It proceeds writing output to curpos, and updating curpos, until
* either the end of output is reached, or curpos == endpos (i.e. the
* buffer is full).
*
* If the end of output is reached, apr_vformatter returns the
* number of bytes written.
*
* When the buffer is full, the flush_func is called. The flush_func
* can return -1 to indicate that no further output should be attempted,
* and apr_vformatter will return immediately with -1. Otherwise
* the flush_func should flush the buffer in whatever manner is
* appropriate, re apr_pool_t nitialize curpos and endpos, and return 0.
*
* Note that flush_func is only invoked as a result of attempting to
* write another byte at curpos when curpos >= endpos. So for
* example, it's possible when the output exactly matches the buffer
* space available that curpos == endpos will be true when
* apr_vformatter returns.
*
* apr_vformatter does not call out to any other code, it is entirely
* self-contained. This allows the callers to do things which are
* otherwise "unsafe". For example, apr_psprintf uses the "scratch"
* space at the unallocated end of a block, and doesn't actually
* complete the allocation until apr_vformatter returns. apr_psprintf
* would be completely broken if apr_vformatter were to call anything
* that used this same pool. Similarly http_bprintf() uses the "scratch"
* space at the end of its output buffer, and doesn't actually note
* that the space is in use until it either has to flush the buffer
* or until apr_vformatter returns.
* </PRE>
*/
APR_DECLARE(int) apr_vformatter(int (*flush_func)(apr_vformatter_buff_t *b),
apr_vformatter_buff_t *c, const char *fmt,
va_list ap);
/**
* Display a prompt and read in the password from stdin.
* @param prompt The prompt to display
* @param pwbuf Buffer to store the password
* @param bufsize The length of the password buffer.
*/
APR_DECLARE(apr_status_t) apr_password_get(const char *prompt, char *pwbuf,
apr_size_t *bufsize);
/** @} */
/**
* @defgroup apr_ctype ctype functions
* These macros allow correct support of 8-bit characters on systems which
* support 8-bit characters. Pretty dumb how the cast is required, but
* that's legacy libc for ya. These new macros do not support EOF like
* the standard macros do. Tough.
* @{
*/
/** @see isalnum */
#define apr_isalnum(c) (isalnum(((unsigned char)(c))))
/** @see isalpha */
#define apr_isalpha(c) (isalpha(((unsigned char)(c))))
/** @see iscntrl */
#define apr_iscntrl(c) (iscntrl(((unsigned char)(c))))
/** @see isdigit */
#define apr_isdigit(c) (isdigit(((unsigned char)(c))))
/** @see isgraph */
#define apr_isgraph(c) (isgraph(((unsigned char)(c))))
/** @see islower*/
#define apr_islower(c) (islower(((unsigned char)(c))))
/** @see isascii */
#ifdef isascii
#define apr_isascii(c) (isascii(((unsigned char)(c))))
#else
#define apr_isascii(c) (((c) & ~0x7f)==0)
#endif
/** @see isprint */
#define apr_isprint(c) (isprint(((unsigned char)(c))))
/** @see ispunct */
#define apr_ispunct(c) (ispunct(((unsigned char)(c))))
/** @see isspace */
#define apr_isspace(c) (isspace(((unsigned char)(c))))
/** @see isupper */
#define apr_isupper(c) (isupper(((unsigned char)(c))))
/** @see isxdigit */
#define apr_isxdigit(c) (isxdigit(((unsigned char)(c))))
/** @see tolower */
#define apr_tolower(c) (tolower(((unsigned char)(c))))
/** @see toupper */
#define apr_toupper(c) (toupper(((unsigned char)(c))))
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_LIB_H */
--- NEW FILE: apr_poll.h ---
/* 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_POLL_H
#define APR_POLL_H
/**
* @file apr_poll.h
* @brief APR Poll interface
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#include "apr_inherit.h"
#include "apr_file_io.h"
#include "apr_network_io.h"
#if APR_HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_poll Poll Routines
* @ingroup APR
* @{
*/
/**
* @defgroup apr_poll_opt Poll options
* @{
*/
#define APR_POLLIN 0x001 /**< Can read without blocking */
#define APR_POLLPRI 0x002 /**< Priority data available */
#define APR_POLLOUT 0x004 /**< Can write without blocking */
#define APR_POLLERR 0x010 /**< Pending error */
#define APR_POLLHUP 0x020 /**< Hangup occurred */
#define APR_POLLNVAL 0x040 /**< Descriptior invalid */
/** @} */
/** Used in apr_pollfd_t to determine what the apr_descriptor is */
typedef enum {
APR_NO_DESC, /**< nothing here */
APR_POLL_SOCKET, /**< descriptor refers to a socket */
APR_POLL_FILE, /**< descriptor refers to a file */
APR_POLL_LASTDESC /**< descriptor is the last one in the list */
} apr_datatype_e ;
/** Union of either an APR file or socket. */
typedef union {
apr_file_t *f; /**< file */
apr_socket_t *s; /**< socket */
} apr_descriptor;
/** @see apr_pollfd_t */
typedef struct apr_pollfd_t apr_pollfd_t;
/** Poll descriptor set. */
struct apr_pollfd_t {
apr_pool_t *p; /**< associated pool */
apr_datatype_e desc_type; /**< descriptor type */
apr_int16_t reqevents; /**< requested events */
apr_int16_t rtnevents; /**< returned events */
apr_descriptor desc; /**< @see apr_descriptor */
void *client_data; /**< allows app to associate context */
};
/**
* Setup the memory required for poll to operate properly
* @param new_poll The poll structure to be used.
* @param num The number of socket descriptors to be polled.
* @param cont The pool to operate on.
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
*/
APR_DECLARE(apr_status_t) apr_poll_setup(apr_pollfd_t **new_poll,
apr_int32_t num,
apr_pool_t *cont);
/**
* Poll the sockets in the poll structure
* @param aprset The poll structure we will be using.
* @param numsock The number of sockets we are polling
* @param nsds The number of sockets signalled.
* @param timeout The amount of time in microseconds to wait. This is
* a maximum, not a minimum. If a socket is signalled, we
* will wake up before this time. A negative number means
* wait until a socket is signalled.
* @remark
* <PRE>
* The number of sockets signalled is returned in the second argument.
*
* This is a blocking call, and it will not return until either a
* socket has been signalled, or the timeout has expired.
* </PRE>
*/
APR_DECLARE(apr_status_t) apr_poll(apr_pollfd_t *aprset, apr_int32_t numsock,
apr_int32_t *nsds,
apr_interval_time_t timeout);
/**
* Add a socket to the poll structure.
* @param aprset The poll structure we will be using.
* @param sock The socket to add to the current poll structure.
* @param event The events to look for when we do the poll. One of:
* <PRE>
* APR_POLLIN signal if read will not block
* APR_POLLPRI signal if prioirty data is availble to be read
* APR_POLLOUT signal if write will not block
* </PRE>
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
*/
APR_DECLARE(apr_status_t) apr_poll_socket_add(apr_pollfd_t *aprset,
apr_socket_t *sock,
apr_int16_t event);
/**
* Modify a socket in the poll structure with mask.
* @param aprset The poll structure we will be using.
* @param sock The socket to modify in poll structure.
* @param events The events to stop looking for during the poll. One of:
* <PRE>
* APR_POLLIN signal if read will not block
* APR_POLLPRI signal if priority data is available to be read
* APR_POLLOUT signal if write will not block
* </PRE>
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
*/
APR_DECLARE(apr_status_t) apr_poll_socket_mask(apr_pollfd_t *aprset,
apr_socket_t *sock,
apr_int16_t events);
/**
* Remove a socket from the poll structure.
* @param aprset The poll structure we will be using.
* @param sock The socket to remove from the current poll structure.
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
*/
APR_DECLARE(apr_status_t) apr_poll_socket_remove(apr_pollfd_t *aprset,
apr_socket_t *sock);
/**
* Clear all events in the poll structure.
* @param aprset The poll structure we will be using.
* @param events The events to clear from all sockets. One of:
* <PRE>
* APR_POLLIN signal if read will not block
* APR_POLLPRI signal if priority data is available to be read
* APR_POLLOUT signal if write will not block
* </PRE>
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
*/
APR_DECLARE(apr_status_t) apr_poll_socket_clear(apr_pollfd_t *aprset,
apr_int16_t events);
/**
* Get the return events for the specified socket.
* @param event The returned events for the socket. One of:
* <PRE>
* APR_POLLIN Data is available to be read
* APR_POLLPRI Priority data is availble to be read
* APR_POLLOUT Write will succeed
* APR_POLLERR An error occurred on the socket
* APR_POLLHUP The connection has been terminated
* APR_POLLNVAL This is an invalid socket to poll on.
* Socket not open.
* </PRE>
* @param sock The socket we wish to get information about.
* @param aprset The poll structure we will be using.
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
*/
APR_DECLARE(apr_status_t) apr_poll_revents_get(apr_int16_t *event,
apr_socket_t *sock,
apr_pollfd_t *aprset);
/* General-purpose poll API for arbitrarily large numbers of
* file descriptors
*/
/** Opaque structure used for pollset API */
typedef struct apr_pollset_t apr_pollset_t;
/**
* Setup a pollset object
* @param pollset The pointer in which to return the newly created object
* @param size The maximum number of descriptors that this pollset can hold
* @param p The pool from which to allocate the pollset
* @param flags Optional flags to modify the operation of the pollset
* (reserved for future expansion)
*/
APR_DECLARE(apr_status_t) apr_pollset_create(apr_pollset_t **pollset,
apr_uint32_t size,
apr_pool_t *p,
apr_uint32_t flags);
/**
* Destroy a pollset object
* @param pollset The pollset to destroy
*/
APR_DECLARE(apr_status_t) apr_pollset_destroy(apr_pollset_t *pollset);
/**
* Add a socket or file descriptor to a pollset
* @param pollset The pollset to which to add the descriptor
* @param descriptor The descriptor to add
* @remark If you set client_data in the descriptor, that value
* will be returned in the client_data field whenever this
* descriptor is signalled in apr_pollset_poll().
*/
APR_DECLARE(apr_status_t) apr_pollset_add(apr_pollset_t *pollset,
const apr_pollfd_t *descriptor);
/**
* Remove a descriptor from a pollset
* @param pollset The pollset from which to remove the descriptor
* @param descriptor The descriptor to remove
*/
APR_DECLARE(apr_status_t) apr_pollset_remove(apr_pollset_t *pollset,
const apr_pollfd_t *descriptor);
/**
* Block for activity on the descriptor(s) in a pollset
* @param pollset The pollset to use
* @param timeout Timeout in microseconds
* @param num Number of signalled descriptors (output parameter)
* @param descriptors Array of signalled descriptors (output parameter)
*/
APR_DECLARE(apr_status_t) apr_pollset_poll(apr_pollset_t *pollset,
apr_interval_time_t timeout,
apr_int32_t *num,
const apr_pollfd_t **descriptors);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_POLL_H */
--- NEW FILE: apr_shm.h ---
/* 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_SHM_H
#define APR_SHM_H
/**
* @file apr_shm.h
* @brief APR Shared Memory Routines
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_shm Shared Memory Routines
* @ingroup APR
* @{
*/
/**
* Private, platform-specific data struture representing a shared memory
* segment.
*/
typedef struct apr_shm_t apr_shm_t;
/**
* Create and make accessable a shared memory segment.
* @param m The shared memory structure to create.
* @param reqsize The desired size of the segment.
* @param filename The file to use for shared memory on platforms that
* require it.
* @param pool the pool from which to allocate the shared memory
* structure.
* @remark A note about Anonymous vs. Named shared memory segments:
* Not all plaforms support anonymous shared memory segments, but in
* some cases it is prefered over other types of shared memory
* implementations. Passing a NULL 'file' parameter to this function
* will cause the subsystem to use anonymous shared memory segments.
* If such a system is not available, APR_ENOTIMPL is returned.
* @remark A note about allocation sizes:
* On some platforms it is necessary to store some metainformation
* about the segment within the actual segment. In order to supply
* the caller with the requested size it may be necessary for the
* implementation to request a slightly greater segment length
* from the subsystem. In all cases, the apr_shm_baseaddr_get()
* function will return the first usable byte of memory.
*
*/
APR_DECLARE(apr_status_t) apr_shm_create(apr_shm_t **m,
apr_size_t reqsize,
const char *filename,
apr_pool_t *pool);
/**
* Destroy a shared memory segment and associated memory.
* @param m The shared memory segment structure to destroy.
*/
APR_DECLARE(apr_status_t) apr_shm_destroy(apr_shm_t *m);
/**
* Attach to a shared memory segment that was created
* by another process.
* @param m The shared memory structure to create.
* @param filename The file used to create the original segment.
* (This MUST match the original filename.)
* @param pool the pool from which to allocate the shared memory
* structure for this process.
*/
APR_DECLARE(apr_status_t) apr_shm_attach(apr_shm_t **m,
const char *filename,
apr_pool_t *pool);
/**
* Detach from a shared memory segment without destroying it.
* @param m The shared memory structure representing the segment
* to detach from.
*/
APR_DECLARE(apr_status_t) apr_shm_detach(apr_shm_t *m);
/**
* Retrieve the base address of the shared memory segment.
* NOTE: This address is only usable within the callers address
* space, since this API does not guarantee that other attaching
* processes will maintain the same address mapping.
* @param m The shared memory segment from which to retrieve
* the base address.
*/
APR_DECLARE(void *) apr_shm_baseaddr_get(const apr_shm_t *m);
/**
* Retrieve the length of a shared memory segment in bytes.
* @param m The shared memory segment from which to retrieve
* the segment length.
*/
APR_DECLARE(apr_size_t) apr_shm_size_get(const apr_shm_t *m);
/**
* Get the pool used by this shared memory segment.
*/
APR_POOL_DECLARE_ACCESSOR(shm);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* APR_SHM_T */
--- NEW FILE: apr_ring.h ---
/* 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.
*/
/*
* This code draws heavily from the 4.4BSD <sys/queue.h> macros
* and Dean Gaudet's "splim/ring.h".
* <http://www.freebsd.org/cgi/cvsweb.cgi/src/sys/sys/queue.h>
* <http://www.arctic.org/~dean/splim/>
*
* We'd use Dean's code directly if we could guarantee the
* availability of inline functions.
*/
#ifndef APR_RING_H
#define APR_RING_H
/**
* @file apr_ring.h
* @brief APR Rings
*/
/*
* for offsetof()
*/
#include "apr_general.h"
/**
* @defgroup apr_ring Ring Macro Implementations
* @ingroup APR
* A ring is a kind of doubly-linked list that can be manipulated
* without knowing where its head is.
* @{
*/
/**
* The Ring Element
*
* A ring element struct is linked to the other elements in the ring
* through its ring entry field, e.g.
* <pre>
* struct my_element_t {
* APR_RING_ENTRY(my_element_t) link;
* int foo;
* char *bar;
* };
* </pre>
*
* An element struct may be put on more than one ring if it has more
* than one APR_RING_ENTRY field. Each APR_RING_ENTRY has a corresponding
* APR_RING_HEAD declaration.
*
* @warning For strict C standards compliance you should put the APR_RING_ENTRY
* first in the element struct unless the head is always part of a larger
* object with enough earlier fields to accommodate the offsetof() used
* to compute the ring sentinel below. You can usually ignore this caveat.
*/
#define APR_RING_ENTRY(elem) \
struct { \
struct elem *next; \
struct elem *prev; \
}
/**
* The Ring Head
*
* Each ring is managed via its head, which is a struct declared like this:
* <pre>
* APR_RING_HEAD(my_ring_t, my_element_t);
* struct my_ring_t ring, *ringp;
* </pre>
*
* This struct looks just like the element link struct so that we can
* be sure that the typecasting games will work as expected.
*
* The first element in the ring is next after the head, and the last
* element is just before the head.
*/
#define APR_RING_HEAD(head, elem) \
struct head { \
struct elem *next; \
struct elem *prev; \
}
/**
* The Ring Sentinel
*
* This is the magic pointer value that occurs before the first and
* after the last elements in the ring, computed from the address of
* the ring's head. The head itself isn't an element, but in order to
* get rid of all the special cases when dealing with the ends of the
* ring, we play typecasting games to make it look like one.
*
* Here is a diagram to illustrate the arrangements of the next and
* prev pointers of each element in a single ring. Note that they point
* to the start of each element, not to the APR_RING_ENTRY structure.
*
* <pre>
* +->+------+<-+ +->+------+<-+ +->+------+<-+
* | |struct| | | |struct| | | |struct| |
* / | elem | \/ | elem | \/ | elem | \
* ... | | /\ | | /\ | | ...
* +------+ | | +------+ | | +------+
* ...--|prev | | +--|ring | | +--|prev |
* | next|--+ | entry|--+ | next|--...
* +------+ +------+ +------+
* | etc. | | etc. | | etc. |
* : : : : : :
* </pre>
*
* The APR_RING_HEAD is nothing but a bare APR_RING_ENTRY. The prev
* and next pointers in the first and last elements don't actually
* point to the head, they point to a phantom place called the
* sentinel. Its value is such that last->next->next == first because
* the offset from the sentinel to the head's next pointer is the same
* as the offset from the start of an element to its next pointer.
* This also works in the opposite direction.
*
* <pre>
* last first
* +->+------+<-+ +->sentinel<-+ +->+------+<-+
* | |struct| | | | | |struct| |
* / | elem | \/ \/ | elem | \
* ... | | /\ /\ | | ...
* +------+ | | +------+ | | +------+
* ...--|prev | | +--|ring | | +--|prev |
* | next|--+ | head|--+ | next|--...
* +------+ +------+ +------+
* | etc. | | etc. |
* : : : :
* </pre>
*
* Note that the offset mentioned above is different for each kind of
* ring that the element may be on, and each kind of ring has a unique
* name for its APR_RING_ENTRY in each element, and has its own type
* for its APR_RING_HEAD.
*
* Note also that if the offset is non-zero (which is required if an
* element has more than one APR_RING_ENTRY), the unreality of the
* sentinel may have bad implications on very perverse implementations
* of C -- see the warning in APR_RING_ENTRY.
*
* @param hp The head of the ring
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_SENTINEL(hp, elem, link) \
(struct elem *)((char *)(hp) - APR_OFFSETOF(struct elem, link))
/**
* The first element of the ring
* @param hp The head of the ring
*/
#define APR_RING_FIRST(hp) (hp)->next
/**
* The last element of the ring
* @param hp The head of the ring
*/
#define APR_RING_LAST(hp) (hp)->prev
/**
* The next element in the ring
* @param ep The current element
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_NEXT(ep, link) (ep)->link.next
/**
* The previous element in the ring
* @param ep The current element
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_PREV(ep, link) (ep)->link.prev
/**
* Initialize a ring
* @param hp The head of the ring
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_INIT(hp, elem, link) do { \
APR_RING_FIRST((hp)) = APR_RING_SENTINEL((hp), elem, link); \
APR_RING_LAST((hp)) = APR_RING_SENTINEL((hp), elem, link); \
} while (0)
/**
* Determine if a ring is empty
* @param hp The head of the ring
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
* @return true or false
*/
#define APR_RING_EMPTY(hp, elem, link) \
(APR_RING_FIRST((hp)) == APR_RING_SENTINEL((hp), elem, link))
/**
* Initialize a singleton element
* @param ep The element
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_ELEM_INIT(ep, link) do { \
APR_RING_NEXT((ep), link) = (ep); \
APR_RING_PREV((ep), link) = (ep); \
} while (0)
/**
* Splice the sequence ep1..epN into the ring before element lep
* (..lep.. becomes ..ep1..epN..lep..)
* @warning This doesn't work for splicing before the first element or on
* empty rings... see APR_RING_SPLICE_HEAD for one that does
* @param lep Element in the ring to splice before
* @param ep1 First element in the sequence to splice in
* @param epN Last element in the sequence to splice in
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_SPLICE_BEFORE(lep, ep1, epN, link) do { \
APR_RING_NEXT((epN), link) = (lep); \
APR_RING_PREV((ep1), link) = APR_RING_PREV((lep), link); \
APR_RING_NEXT(APR_RING_PREV((lep), link), link) = (ep1); \
APR_RING_PREV((lep), link) = (epN); \
} while (0)
/**
* Splice the sequence ep1..epN into the ring after element lep
* (..lep.. becomes ..lep..ep1..epN..)
* @warning This doesn't work for splicing after the last element or on
* empty rings... see APR_RING_SPLICE_TAIL for one that does
* @param lep Element in the ring to splice after
* @param ep1 First element in the sequence to splice in
* @param epN Last element in the sequence to splice in
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_SPLICE_AFTER(lep, ep1, epN, link) do { \
APR_RING_PREV((ep1), link) = (lep); \
APR_RING_NEXT((epN), link) = APR_RING_NEXT((lep), link); \
APR_RING_PREV(APR_RING_NEXT((lep), link), link) = (epN); \
APR_RING_NEXT((lep), link) = (ep1); \
} while (0)
/**
* Insert the element nep into the ring before element lep
* (..lep.. becomes ..nep..lep..)
* @warning This doesn't work for inserting before the first element or on
* empty rings... see APR_RING_INSERT_HEAD for one that does
* @param lep Element in the ring to insert before
* @param nep Element to insert
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_INSERT_BEFORE(lep, nep, link) \
APR_RING_SPLICE_BEFORE((lep), (nep), (nep), link)
/**
* Insert the element nep into the ring after element lep
* (..lep.. becomes ..lep..nep..)
* @warning This doesn't work for inserting after the last element or on
* empty rings... see APR_RING_INSERT_TAIL for one that does
* @param lep Element in the ring to insert after
* @param nep Element to insert
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_INSERT_AFTER(lep, nep, link) \
APR_RING_SPLICE_AFTER((lep), (nep), (nep), link)
/**
* Splice the sequence ep1..epN into the ring before the first element
* (..hp.. becomes ..hp..ep1..epN..)
* @param hp Head of the ring
* @param ep1 First element in the sequence to splice in
* @param epN Last element in the sequence to splice in
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_SPLICE_HEAD(hp, ep1, epN, elem, link) \
APR_RING_SPLICE_AFTER(APR_RING_SENTINEL((hp), elem, link), \
(ep1), (epN), link)
/**
* Splice the sequence ep1..epN into the ring after the last element
* (..hp.. becomes ..ep1..epN..hp..)
* @param hp Head of the ring
* @param ep1 First element in the sequence to splice in
* @param epN Last element in the sequence to splice in
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_SPLICE_TAIL(hp, ep1, epN, elem, link) \
APR_RING_SPLICE_BEFORE(APR_RING_SENTINEL((hp), elem, link), \
(ep1), (epN), link)
/**
* Insert the element nep into the ring before the first element
* (..hp.. becomes ..hp..nep..)
* @param hp Head of the ring
* @param nep Element to insert
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_INSERT_HEAD(hp, nep, elem, link) \
APR_RING_SPLICE_HEAD((hp), (nep), (nep), elem, link)
/**
* Insert the element nep into the ring after the last element
* (..hp.. becomes ..nep..hp..)
* @param hp Head of the ring
* @param nep Element to insert
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_INSERT_TAIL(hp, nep, elem, link) \
APR_RING_SPLICE_TAIL((hp), (nep), (nep), elem, link)
/**
* Concatenate ring h2 onto the end of ring h1, leaving h2 empty.
* @param h1 Head of the ring to concatenate onto
* @param h2 Head of the ring to concatenate
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_CONCAT(h1, h2, elem, link) do { \
if (!APR_RING_EMPTY((h2), elem, link)) { \
APR_RING_SPLICE_BEFORE(APR_RING_SENTINEL((h1), elem, link), \
APR_RING_FIRST((h2)), \
APR_RING_LAST((h2)), link); \
APR_RING_INIT((h2), elem, link); \
} \
} while (0)
/**
* Prepend ring h2 onto the beginning of ring h1, leaving h2 empty.
* @param h1 Head of the ring to prepend onto
* @param h2 Head of the ring to prepend
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_PREPEND(h1, h2, elem, link) do { \
if (!APR_RING_EMPTY((h2), elem, link)) { \
APR_RING_SPLICE_AFTER(APR_RING_SENTINEL((h1), elem, link), \
APR_RING_FIRST((h2)), \
APR_RING_LAST((h2)), link); \
APR_RING_INIT((h2), elem, link); \
} \
} while (0)
/**
* Unsplice a sequence of elements from a ring
* @warning The unspliced sequence is left with dangling pointers at either end
* @param ep1 First element in the sequence to unsplice
* @param epN Last element in the sequence to unsplice
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_UNSPLICE(ep1, epN, link) do { \
APR_RING_NEXT(APR_RING_PREV((ep1), link), link) = \
APR_RING_NEXT((epN), link); \
APR_RING_PREV(APR_RING_NEXT((epN), link), link) = \
APR_RING_PREV((ep1), link); \
} while (0)
/**
* Remove a single element from a ring
* @warning The unspliced element is left with dangling pointers at either end
* @param ep Element to remove
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_REMOVE(ep, link) \
APR_RING_UNSPLICE((ep), (ep), link)
/**
* Iterate through a ring
* @param ep The current element
* @param hp The ring to iterate over
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
* @remark This is the same as either:
* <pre>
* ep = APR_RING_FIRST(hp);
* while (ep != APR_RING_SENTINEL(hp, elem, link)) {
* ...
* ep = APR_RING_NEXT(ep, link);
* }
* OR
* for (ep = APR_RING_FIRST(hp);
* ep != APR_RING_SENTINEL(hp, elem, link);
* ep = APR_RING_NEXT(ep, link)) {
* ...
* }
* </pre>
* @warning Be aware that you cannot change the value of ep within
* the foreach loop, nor can you destroy the ring element it points to.
* Modifying the prev and next pointers of the element is dangerous
* but can be done if you're careful. If you change ep's value or
* destroy the element it points to, then APR_RING_FOREACH
* will have no way to find out what element to use for its next
* iteration. The reason for this can be seen by looking closely
* at the equivalent loops given in the tip above. So, for example,
* if you are writing a loop that empties out a ring one element
* at a time, APR_RING_FOREACH just won't work for you. Do it
* by hand, like so:
* <pre>
* while (!APR_RING_EMPTY(hp, elem, link)) {
* ep = APR_RING_FIRST(hp);
* ...
* APR_RING_REMOVE(ep, link);
* }
* </pre>
* @deprecated This macro causes more headaches than it's worth. Use
* one of the alternatives documented here instead; the clarity gained
* in what's really going on is well worth the extra line or two of code.
* This macro will be removed at some point in the future.
*/
#define APR_RING_FOREACH(ep, hp, elem, link) \
for ((ep) = APR_RING_FIRST((hp)); \
(ep) != APR_RING_SENTINEL((hp), elem, link); \
(ep) = APR_RING_NEXT((ep), link))
/**
* Iterate through a ring backwards
* @param ep The current element
* @param hp The ring to iterate over
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
* @see APR_RING_FOREACH
*/
#define APR_RING_FOREACH_REVERSE(ep, hp, elem, link) \
for ((ep) = APR_RING_LAST((hp)); \
(ep) != APR_RING_SENTINEL((hp), elem, link); \
(ep) = APR_RING_PREV((ep), link))
/* Debugging tools: */
#ifdef APR_RING_DEBUG
#include <stdio.h>
#include <assert.h>
#define APR_RING_CHECK_ONE(msg, ptr) \
fprintf(stderr, "*** %s %p\n", msg, ptr)
#define APR_RING_CHECK(hp, elem, link, msg) \
APR_RING_CHECK_ELEM(APR_RING_SENTINEL(hp, elem, link), elem, link, msg)
#define APR_RING_CHECK_ELEM(ep, elem, link, msg) do { \
struct elem *start = (ep); \
struct elem *here = start; \
fprintf(stderr, "*** ring check start -- %s\n", msg); \
do { \
fprintf(stderr, "\telem %p\n", here); \
fprintf(stderr, "\telem->next %p\n", \
APR_RING_NEXT(here, link)); \
fprintf(stderr, "\telem->prev %p\n", \
APR_RING_PREV(here, link)); \
fprintf(stderr, "\telem->next->prev %p\n", \
APR_RING_PREV(APR_RING_NEXT(here, link), link)); \
fprintf(stderr, "\telem->prev->next %p\n", \
APR_RING_NEXT(APR_RING_PREV(here, link), link)); \
if (APR_RING_PREV(APR_RING_NEXT(here, link), link) != here) { \
fprintf(stderr, "\t*** elem->next->prev != elem\n"); \
break; \
} \
if (APR_RING_NEXT(APR_RING_PREV(here, link), link) != here) { \
fprintf(stderr, "\t*** elem->prev->next != elem\n"); \
break; \
} \
here = APR_RING_NEXT(here, link); \
} while (here != start); \
fprintf(stderr, "*** ring check end\n"); \
} while (0)
#define APR_RING_CHECK_CONSISTENCY(hp, elem, link) \
APR_RING_CHECK_ELEM_CONSISTENCY(APR_RING_SENTINEL(hp, elem, link),\
elem, link)
#define APR_RING_CHECK_ELEM_CONSISTENCY(ep, elem, link) do { \
struct elem *start = (ep); \
struct elem *here = start; \
do { \
assert(APR_RING_PREV(APR_RING_NEXT(here, link), link) == here); \
assert(APR_RING_NEXT(APR_RING_PREV(here, link), link) == here); \
here = APR_RING_NEXT(here, link); \
} while (here != start); \
} while (0)
#else
/**
* Print a single pointer value to STDERR
* (This is a no-op unless APR_RING_DEBUG is defined.)
* @param msg Descriptive message
* @param ptr Pointer value to print
*/
#define APR_RING_CHECK_ONE(msg, ptr)
/**
* Dump all ring pointers to STDERR, starting with the head and looping all
* the way around the ring back to the head. Aborts if an inconsistency
* is found.
* (This is a no-op unless APR_RING_DEBUG is defined.)
* @param hp Head of the ring
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
* @param msg Descriptive message
*/
#define APR_RING_CHECK(hp, elem, link, msg)
/**
* Loops around a ring and checks all the pointers for consistency. Pops
* an assertion if any inconsistency is found. Same idea as APR_RING_CHECK()
* except that it's silent if all is well.
* (This is a no-op unless APR_RING_DEBUG is defined.)
* @param hp Head of the ring
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_CHECK_CONSISTENCY(hp, elem, link)
/**
* Dump all ring pointers to STDERR, starting with the given element and
* looping all the way around the ring back to that element. Aborts if
* an inconsistency is found.
* (This is a no-op unless APR_RING_DEBUG is defined.)
* @param ep The element
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
* @param msg Descriptive message
*/
#define APR_RING_CHECK_ELEM(ep, elem, link, msg)
/**
* Loops around a ring, starting with the given element, and checks all
* the pointers for consistency. Pops an assertion if any inconsistency
* is found. Same idea as APR_RING_CHECK_ELEM() except that it's silent
* if all is well.
* (This is a no-op unless APR_RING_DEBUG is defined.)
* @param ep The element
* @param elem The name of the element struct
* @param link The name of the APR_RING_ENTRY in the element struct
*/
#define APR_RING_CHECK_ELEM_CONSISTENCY(ep, elem, link)
#endif
/** @} */
#endif /* !APR_RING_H */
--- NEW FILE: apr_global_mutex.h ---
/* 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_GLOBAL_MUTEX_H
#define APR_GLOBAL_MUTEX_H
/**
* @file apr_global_mutex.h
* @brief APR Global Locking Routines
*/
#include "apr.h"
#include "apr_proc_mutex.h" /* only for apr_lockmech_e */
#include "apr_pools.h"
#include "apr_errno.h"
#if APR_PROC_MUTEX_IS_GLOBAL
#include "apr_proc_mutex.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup APR_GlobalMutex Global Locking Routines
* @ingroup APR
* @{
*/
#if !APR_PROC_MUTEX_IS_GLOBAL || defined(DOXYGEN)
/** Opaque global mutex structure. */
typedef struct apr_global_mutex_t apr_global_mutex_t;
/* Function definitions */
/**
* Create and initialize a mutex that can be used to synchronize both
* processes and threads. Note: There is considerable overhead in using
* this API if only cross-process or cross-thread mutual exclusion is
* required. See apr_proc_mutex.h and apr_thread_mutex.h for more
* specialized lock routines.
* @param mutex the memory address where the newly created mutex will be
* stored.
* @param fname A file name to use if the lock mechanism requires one. This
* argument should always be provided. The lock code itself will
* determine if it should be used.
* @param mech The mechanism to use for the interprocess lock, if any; one of
* <PRE>
* APR_LOCK_FCNTL
* APR_LOCK_FLOCK
* APR_LOCK_SYSVSEM
* APR_LOCK_POSIXSEM
* APR_LOCK_PROC_PTHREAD
* APR_LOCK_DEFAULT pick the default mechanism for the platform
* </PRE>
* @param pool the pool from which to allocate the mutex.
* @warning Check APR_HAS_foo_SERIALIZE defines to see if the platform supports
* APR_LOCK_foo. Only APR_LOCK_DEFAULT is portable.
*/
APR_DECLARE(apr_status_t) apr_global_mutex_create(apr_global_mutex_t **mutex,
const char *fname,
apr_lockmech_e mech,
apr_pool_t *pool);
/**
* Re-open a mutex in a child process.
* @param mutex The newly re-opened mutex structure.
* @param fname A file name to use if the mutex mechanism requires one. This
* argument should always be provided. The mutex code itself will
* determine if it should be used. This filename should be the
* same one that was passed to apr_global_mutex_create().
* @param pool The pool to operate on.
* @remark This function must be called to maintain portability, even
* if the underlying lock mechanism does not require it.
*/
APR_DECLARE(apr_status_t) apr_global_mutex_child_init(
apr_global_mutex_t **mutex,
const char *fname,
apr_pool_t *pool);
/**
* Acquire the lock for the given mutex. If the mutex is already locked,
* the current thread will be put to sleep until the lock becomes available.
* @param mutex the mutex on which to acquire the lock.
*/
APR_DECLARE(apr_status_t) apr_global_mutex_lock(apr_global_mutex_t *mutex);
/**
* Attempt to acquire the lock for the given mutex. If the mutex has already
* been acquired, the call returns immediately with APR_EBUSY. Note: it
* is important that the APR_STATUS_IS_EBUSY(s) macro be used to determine
* if the return value was APR_EBUSY, for portability reasons.
* @param mutex the mutex on which to attempt the lock acquiring.
*/
APR_DECLARE(apr_status_t) apr_global_mutex_trylock(apr_global_mutex_t *mutex);
/**
* Release the lock for the given mutex.
* @param mutex the mutex from which to release the lock.
*/
APR_DECLARE(apr_status_t) apr_global_mutex_unlock(apr_global_mutex_t *mutex);
/**
* Destroy the mutex and free the memory associated with the lock.
* @param mutex the mutex to destroy.
*/
APR_DECLARE(apr_status_t) apr_global_mutex_destroy(apr_global_mutex_t *mutex);
/**
* Get the pool used by this global_mutex.
* @return apr_pool_t the pool
*/
APR_POOL_DECLARE_ACCESSOR(global_mutex);
#else /* APR_PROC_MUTEX_IS_GLOBAL */
/* Some platforms [e.g. Win32] have cross process locks that are truly
* global locks, since there isn't the concept of cross-process locks.
* Define these platforms in terms of an apr_proc_mutex_t.
*/
#define apr_global_mutex_t apr_proc_mutex_t
#define apr_global_mutex_create apr_proc_mutex_create
#define apr_global_mutex_child_init apr_proc_mutex_child_init
#define apr_global_mutex_lock apr_proc_mutex_lock
#define apr_global_mutex_trylock apr_proc_mutex_trylock
#define apr_global_mutex_unlock apr_proc_mutex_unlock
#define apr_global_mutex_destroy apr_proc_mutex_destroy
#define apr_global_mutex_pool_get apr_proc_mutex_pool_get
#endif
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ndef APR_GLOBAL_MUTEX_H */
--- NEW FILE: apr_time.h ---
/* 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_TIME_H
#define APR_TIME_H
/**
* @file apr_time.h
* @brief APR Time Library
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_time Time Routines
* @ingroup APR
* @{
*/
/** month names */
APR_DECLARE_DATA extern const char apr_month_snames[12][4];
/** day names */
APR_DECLARE_DATA extern const char apr_day_snames[7][4];
/** number of microseconds since 00:00:00 january 1, 1970 UTC */
typedef apr_int64_t apr_time_t;
/** mechanism to properly type apr_time_t literals */
#define APR_TIME_C(val) APR_INT64_C(val)
/** mechanism to properly print apr_time_t values */
#define APR_TIME_T_FMT APR_INT64_T_FMT
/** intervals for I/O timeouts, in microseconds */
typedef apr_int64_t apr_interval_time_t;
/** short interval for I/O timeouts, in microseconds */
typedef apr_int32_t apr_short_interval_time_t;
/** number of microseconds per second */
#define APR_USEC_PER_SEC APR_TIME_C(1000000)
/** @return apr_time_t as a second */
#define apr_time_sec(time) ((time) / APR_USEC_PER_SEC)
/** @return apr_time_t as a usec */
#define apr_time_usec(time) ((time) % APR_USEC_PER_SEC)
/** @return apr_time_t as a msec */
#define apr_time_msec(time) (((time) / 1000) % 1000)
/** @return apr_time_t as a msec */
#define apr_time_as_msec(time) ((time) / 1000)
/** @return a second as an apr_time_t */
#define apr_time_from_sec(sec) ((apr_time_t)(sec) * APR_USEC_PER_SEC)
/** @return a second and usec combination as an apr_time_t */
#define apr_time_make(sec, usec) ((apr_time_t)(sec) * APR_USEC_PER_SEC \
+ (apr_time_t)(usec))
/**
* @return the current time
*/
APR_DECLARE(apr_time_t) apr_time_now(void);
/** @see apr_time_exp_t */
typedef struct apr_time_exp_t apr_time_exp_t;
/**
* a structure similar to ANSI struct tm with the following differences:
* - tm_usec isn't an ANSI field
* - tm_gmtoff isn't an ANSI field (it's a bsdism)
*/
struct apr_time_exp_t {
/** microseconds past tm_sec */
apr_int32_t tm_usec;
/** (0-61) seconds past tm_min */
apr_int32_t tm_sec;
/** (0-59) minutes past tm_hour */
apr_int32_t tm_min;
/** (0-23) hours past midnight */
apr_int32_t tm_hour;
/** (1-31) day of the month */
apr_int32_t tm_mday;
/** (0-11) month of the year */
apr_int32_t tm_mon;
/** year since 1900 */
apr_int32_t tm_year;
/** (0-6) days since sunday */
apr_int32_t tm_wday;
/** (0-365) days since jan 1 */
apr_int32_t tm_yday;
/** daylight saving time */
apr_int32_t tm_isdst;
/** seconds east of UTC */
apr_int32_t tm_gmtoff;
};
/**
* convert an ansi time_t to an apr_time_t
* @param result the resulting apr_time_t
* @param input the time_t to convert
*/
APR_DECLARE(apr_status_t) apr_time_ansi_put(apr_time_t *result,
time_t input);
/**
* convert a time to its human readable components using an offset
* from GMT
* @param result the exploded time
* @param input the time to explode
* @param offs the number of seconds offset to apply
*/
APR_DECLARE(apr_status_t) apr_time_exp_tz(apr_time_exp_t *result,
apr_time_t input,
apr_int32_t offs);
/** @deprecated @see apr_time_exp_tz */
APR_DECLARE(apr_status_t) apr_explode_time(apr_time_exp_t *result,
apr_time_t input,
apr_int32_t offs);
/**
* convert a time to its human readable components in GMT timezone
* @param result the exploded time
* @param input the time to explode
*/
APR_DECLARE(apr_status_t) apr_time_exp_gmt(apr_time_exp_t *result,
apr_time_t input);
/**
* convert a time to its human readable components in local timezone
* @param result the exploded time
* @param input the time to explode
*/
APR_DECLARE(apr_status_t) apr_time_exp_lt(apr_time_exp_t *result,
apr_time_t input);
/** @deprecated @see apr_time_exp_lt */
APR_DECLARE(apr_status_t) apr_explode_localtime(apr_time_exp_t *result,
apr_time_t input);
/**
* Convert time value from human readable format to a numeric apr_time_t
* e.g. elapsed usec since epoch
* @param result the resulting imploded time
* @param input the input exploded time
*/
APR_DECLARE(apr_status_t) apr_time_exp_get(apr_time_t *result,
apr_time_exp_t *input);
/**
* Convert time value from human readable format to a numeric apr_time_t that
* always represents GMT
* @param result the resulting imploded time
* @param input the input exploded time
*/
APR_DECLARE(apr_status_t) apr_time_exp_gmt_get(apr_time_t *result,
apr_time_exp_t *input);
/** @deprecated @see apr_time_exp_gmt_get */
APR_DECLARE(apr_status_t) apr_implode_gmt(apr_time_t *result,
apr_time_exp_t *input);
/**
* Sleep for the specified number of micro-seconds.
* @param t desired amount of time to sleep.
* @warning May sleep for longer than the specified time.
*/
APR_DECLARE(void) apr_sleep(apr_interval_time_t t);
/** length of a RFC822 Date */
#define APR_RFC822_DATE_LEN (30)
/**
* apr_rfc822_date formats dates in the RFC822
* format in an efficient manner. It is a fixed length
* format which requires the indicated amount of storage,
* including the trailing null byte.
* @param date_str String to write to.
* @param t the time to convert
*/
APR_DECLARE(apr_status_t) apr_rfc822_date(char *date_str, apr_time_t t);
/** length of a CTIME date */
#define APR_CTIME_LEN (25)
/**
* apr_ctime formats dates in the ctime() format
* in an efficient manner. it is a fixed length format
* and requires the indicated amount of storage including
* the trailing null byte.
* Unlike ANSI/ISO C ctime(), apr_ctime() does not include
* a \n at the end of the string.
* @param date_str String to write to.
* @param t the time to convert
*/
APR_DECLARE(apr_status_t) apr_ctime(char *date_str, apr_time_t t);
/**
* formats the exploded time according to the format specified
* @param s string to write to
* @param retsize The length of the returned string
* @param max The maximum length of the string
* @param format The format for the time string
* @param tm The time to convert
*/
APR_DECLARE(apr_status_t) apr_strftime(char *s, apr_size_t *retsize,
apr_size_t max, const char *format,
apr_time_exp_t *tm);
/**
* Improve the clock resolution for the lifetime of the given pool.
* Generally this is only desireable on benchmarking and other very
* time-sensitive applications, and has no impact on most platforms.
* @param p The pool to associate the finer clock resolution
*/
APR_DECLARE(void) apr_time_clock_hires(apr_pool_t *p);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_TIME_H */
--- NEW FILE: apr_pools.h ---
/* 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_POOLS_H
#define APR_POOLS_H
/**
* @file apr_pools.h
* @brief APR memory allocation
*
* Resource allocation routines...
*
* designed so that we don't have to keep track of EVERYTHING so that
* it can be explicitly freed later (a fundamentally unsound strategy ---
* particularly in the presence of die()).
*
* Instead, we maintain pools, and allocate items (both memory and I/O
* handlers) from the pools --- currently there are two, one for per
* transaction info, and one for config info. When a transaction is over,
* we can delete everything in the per-transaction apr_pool_t without fear,
* and without thinking too hard about it either.
*/
#include "apr.h"
#include "apr_errno.h"
#include "apr_general.h" /* for APR_STRINGIFY */
#define APR_WANT_MEMFUNC /**< for no good reason? */
#include "apr_want.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup apr_pools Memory Pool Functions
* @ingroup APR
* @{
*/
/** The fundamental pool type */
typedef struct apr_pool_t apr_pool_t;
/**
* Declaration helper macro to construct apr_foo_pool_get()s.
*
* This standardized macro is used by opaque (APR) data types to return
* the apr_pool_t that is associated with the data type.
*
* APR_POOL_DECLARE_ACCESSOR() is used in a header file to declare the
* accessor function. A typical usage and result would be:
* <pre>
* APR_POOL_DECLARE_ACCESSOR(file);
* becomes:
* APR_DECLARE(apr_pool_t *) apr_file_pool_get(apr_file_t *ob);
* </pre>
* @remark Doxygen unwraps this macro (via doxygen.conf) to provide
* actual help for each specific occurance of apr_foo_pool_get.
* @remark the linkage is specified for APR. It would be possible to expand
* the macros to support other linkages.
*/
#define APR_POOL_DECLARE_ACCESSOR(type) \
APR_DECLARE(apr_pool_t *) apr_##type##_pool_get \
(const apr_##type##_t *the##type)
/**
* Implementation helper macro to provide apr_foo_pool_get()s.
*
* In the implementation, the APR_POOL_IMPLEMENT_ACCESSOR() is used to
* actually define the function. It assumes the field is named "pool".
*/
#define APR_POOL_IMPLEMENT_ACCESSOR(type) \
APR_DECLARE(apr_pool_t *) apr_##type##_pool_get \
(const apr_##type##_t *the##type) \
{ return the##type->pool; }
/**
* Pool debug levels
*
* <pre>
* | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
* ---------------------------------
* | | | | | | | | x | General debug code enabled (usefull in
* combination with --with-efence).
*
* | | | | | | | x | | Verbose output on stderr (report
* CREATE, CLEAR, DESTROY).
*
* | | | | x | | | | | Verbose output on stderr (report
* PALLOC, PCALLOC).
*
* | | | | | | x | | | Lifetime checking. On each use of a
* pool, check its lifetime. If the pool
* is out of scope, abort().
* In combination with the verbose flag
* above, it will output LIFE in such an
* event prior to aborting.
*
* | | | | | x | | | | Pool owner checking. On each use of a
* pool, check if the current thread is the
* pools owner. If not, abort(). In
* combination with the verbose flag above,
* it will output OWNER in such an event
* prior to aborting. Use the debug
* function apr_pool_owner_set() to switch
* a pools ownership.
*
* When no debug level was specified, assume general debug mode.
* If level 0 was specified, debugging is switched off
* </pre>
*/
#if defined(APR_POOL_DEBUG)
#if (APR_POOL_DEBUG != 0) && (APR_POOL_DEBUG - 0 == 0)
#undef APR_POOL_DEBUG
#define APR_POOL_DEBUG 1
#endif
#else
#define APR_POOL_DEBUG 0
#endif
/** the place in the code where the particular function was called */
#define APR_POOL__FILE_LINE__ __FILE__ ":" APR_STRINGIFY(__LINE__)
/** A function that is called when allocation fails. */
typedef int (*apr_abortfunc_t)(int retcode);
/*
* APR memory structure manipulators (pools, tables, and arrays).
*/
/*
* Initialization
*/
/**
* Setup all of the internal structures required to use pools
* @remark Programs do NOT need to call this directly. APR will call this
* automatically from apr_initialize.
* @internal
*/
APR_DECLARE(apr_status_t) apr_pool_initialize(void);
/**
* Tear down all of the internal structures required to use pools
* @remark Programs do NOT need to call this directly. APR will call this
* automatically from apr_terminate.
* @internal
*/
APR_DECLARE(void) apr_pool_terminate(void);
/*
* Pool creation/destruction
*/
#include "apr_allocator.h"
/**
* Create a new pool.
* @param newpool The pool we have just created.
* @param parent The parent pool. If this is NULL, the new pool is a root
* pool. If it is non-NULL, the new pool will inherit all
* of its parent pool's attributes, except the apr_pool_t will
* be a sub-pool.
* @param abort_fn A function to use if the pool cannot allocate more memory.
* @param allocator The allocator to use with the new pool. If NULL the
* allocator of the parent pool will be used.
*/
APR_DECLARE(apr_status_t) apr_pool_create_ex(apr_pool_t **newpool,
apr_pool_t *parent,
apr_abortfunc_t abort_fn,
apr_allocator_t *allocator);
/**
* Debug version of apr_pool_create_ex.
* @param newpool @see apr_pool_create.
* @param parent @see apr_pool_create.
* @param abort_fn @see apr_pool_create.
* @param allocator @see apr_pool_create.
* @param file_line Where the function is called from.
* This is usually APR_POOL__FILE_LINE__.
* @remark Only available when APR_POOL_DEBUG is defined.
* Call this directly if you have you apr_pool_create_ex
* calls in a wrapper function and wish to override
* the file_line argument to reflect the caller of
* your wrapper function. If you do not have
* apr_pool_create_ex in a wrapper, trust the macro
* and don't call apr_pool_create_ex_debug directly.
*/
APR_DECLARE(apr_status_t) apr_pool_create_ex_debug(apr_pool_t **newpool,
apr_pool_t *parent,
apr_abortfunc_t abort_fn,
apr_allocator_t *allocator,
const char *file_line);
#if APR_POOL_DEBUG
#define apr_pool_create_ex(newpool, parent, abort_fn, allocator) \
apr_pool_create_ex_debug(newpool, parent, abort_fn, allocator, \
APR_POOL__FILE_LINE__)
#endif
/**
* Create a new pool.
* @param newpool The pool we have just created.
* @param parent The parent pool. If this is NULL, the new pool is a root
* pool. If it is non-NULL, the new pool will inherit all
* of its parent pool's attributes, except the apr_pool_t will
* be a sub-pool.
*/
#if defined(DOXYGEN)
APR_DECLARE(apr_status_t) apr_pool_create(apr_pool_t **newpool,
apr_pool_t *parent);
#else
#if APR_POOL_DEBUG
#define apr_pool_create(newpool, parent) \
apr_pool_create_ex_debug(newpool, parent, NULL, NULL, \
APR_POOL__FILE_LINE__)
#else
#define apr_pool_create(newpool, parent) \
apr_pool_create_ex(newpool, parent, NULL, NULL)
#endif
#endif
/** @deprecated @see apr_pool_create_ex */
#if APR_POOL_DEBUG
#define apr_pool_sub_make(newpool, parent, abort_fn) \
(void)apr_pool_create_ex_debug(newpool, parent, abort_fn, \
NULL, \
APR_POOL__FILE_LINE__)
#else
#define apr_pool_sub_make(newpool, parent, abort_fn) \
(void)apr_pool_create_ex(newpool, parent, abort_fn, NULL)
#endif
/**
* Find the pools allocator
* @param pool The pool to get the allocator from.
*/
APR_DECLARE(apr_allocator_t *) apr_pool_allocator_get(apr_pool_t *pool);
/**
* Clear all memory in the pool and run all the cleanups. This also destroys all
* subpools.
* @param p The pool to clear
* @remark This does not actually free the memory, it just allows the pool
* to re-use this memory for the next allocation.
* @see apr_pool_destroy()
*/
APR_DECLARE(void) apr_pool_clear(apr_pool_t *p);
/**
* Debug version of apr_pool_clear.
* @param p See: apr_pool_clear.
* @param file_line Where the function is called from.
* This is usually APR_POOL__FILE_LINE__.
* @remark Only available when APR_POOL_DEBUG is defined.
* Call this directly if you have you apr_pool_clear
* calls in a wrapper function and wish to override
* the file_line argument to reflect the caller of
* your wrapper function. If you do not have
* apr_pool_clear in a wrapper, trust the macro
* and don't call apr_pool_destroy_clear directly.
*/
APR_DECLARE(void) apr_pool_clear_debug(apr_pool_t *p,
const char *file_line);
#if APR_POOL_DEBUG
#define apr_pool_clear(p) \
apr_pool_clear_debug(p, APR_POOL__FILE_LINE__)
#endif
/**
* Destroy the pool. This takes similar action as apr_pool_clear() and then
* frees all the memory.
* @param p The pool to destroy
* @remark This will actually free the memory
*/
APR_DECLARE(void) apr_pool_destroy(apr_pool_t *p);
/**
* Debug version of apr_pool_destroy.
* @param p See: apr_pool_destroy.
* @param file_line Where the function is called from.
* This is usually APR_POOL__FILE_LINE__.
* @remark Only available when APR_POOL_DEBUG is defined.
* Call this directly if you have you apr_pool_destroy
* calls in a wrapper function and wish to override
* the file_line argument to reflect the caller of
* your wrapper function. If you do not have
* apr_pool_destroy in a wrapper, trust the macro
* and don't call apr_pool_destroy_debug directly.
*/
APR_DECLARE(void) apr_pool_destroy_debug(apr_pool_t *p,
const char *file_line);
#if APR_POOL_DEBUG
#define apr_pool_destroy(p) \
apr_pool_destroy_debug(p, APR_POOL__FILE_LINE__)
#endif
/*
* Memory allocation
*/
/**
* Allocate a block of memory from a pool
* @param p The pool to allocate from
* @param size The amount of memory to allocate
* @return The allocated memory
*/
APR_DECLARE(void *) apr_palloc(apr_pool_t *p, apr_size_t size);
/**
* Debug version of apr_palloc
* @param p See: apr_palloc
* @param size See: apr_palloc
* @param file_line Where the function is called from.
* This is usually APR_POOL__FILE_LINE__.
* @return See: apr_palloc
*/
APR_DECLARE(void *) apr_palloc_debug(apr_pool_t *p, apr_size_t size,
const char *file_line);
#if APR_POOL_DEBUG
#define apr_palloc(p, size) \
apr_palloc_debug(p, size, APR_POOL__FILE_LINE__)
#endif
/**
* Allocate a block of memory from a pool and set all of the memory to 0
* @param p The pool to allocate from
* @param size The amount of memory to allocate
* @return The allocated memory
*/
#if defined(DOXYGEN)
APR_DECLARE(void *) apr_pcalloc(apr_pool_t *p, apr_size_t size);
#elif !APR_POOL_DEBUG
#define apr_pcalloc(p, size) memset(apr_palloc(p, size), 0, size)
#endif
/**
* Debug version of apr_pcalloc
* @param p See: apr_pcalloc
* @param size See: apr_pcalloc
* @param file_line Where the function is called from.
* This is usually APR_POOL__FILE_LINE__.
* @return See: apr_pcalloc
*/
APR_DECLARE(void *) apr_pcalloc_debug(apr_pool_t *p, apr_size_t size,
const char *file_line);
#if APR_POOL_DEBUG
#define apr_pcalloc(p, size) \
apr_pcalloc_debug(p, size, APR_POOL__FILE_LINE__)
#endif
/*
* Pool Properties
*/
/**
* Set the function to be called when an allocation failure occurs.
* @remark If the program wants APR to exit on a memory allocation error,
* then this function can be called to set the callback to use (for
* performing cleanup and then exiting). If this function is not called,
* then APR will return an error and expect the calling program to
* deal with the error accordingly.
*/
APR_DECLARE(void) apr_pool_abort_set(apr_abortfunc_t abortfunc,
apr_pool_t *pool);
/** @deprecated @see apr_pool_abort_set */
APR_DECLARE(void) apr_pool_set_abort(apr_abortfunc_t abortfunc,
apr_pool_t *pool);
/**
* Get the abort function associated with the specified pool.
* @param pool The pool for retrieving the abort function.
* @return The abort function for the given pool.
*/
APR_DECLARE(apr_abortfunc_t) apr_pool_abort_get(apr_pool_t *pool);
/** @deprecated @see apr_pool_abort_get */
APR_DECLARE(apr_abortfunc_t) apr_pool_get_abort(apr_pool_t *pool);
/**
* Get the parent pool of the specified pool.
* @param pool The pool for retrieving the parent pool.
* @return The parent of the given pool.
*/
APR_DECLARE(apr_pool_t *) apr_pool_parent_get(apr_pool_t *pool);
/** @deprecated @see apr_pool_parent_get */
APR_DECLARE(apr_pool_t *) apr_pool_get_parent(apr_pool_t *pool);
/**
* Determine if pool a is an ancestor of pool b
* @param a The pool to search
* @param b The pool to search for
* @return True if a is an ancestor of b, NULL is considered an ancestor
* of all pools.
*/
APR_DECLARE(int) apr_pool_is_ancestor(apr_pool_t *a, apr_pool_t *b);
/**
* Tag a pool (give it a name)
* @param pool The pool to tag
* @param tag The tag
*/
APR_DECLARE(void) apr_pool_tag(apr_pool_t *pool, const char *tag);
/*
* User data management
*/
/**
* Set the data associated with the current pool
* @param data The user data associated with the pool.
* @param key The key to use for association
* @param cleanup The cleanup program to use to cleanup the data (NULL if none)
* @param pool The current pool
* @warning The data to be attached to the pool should have a life span
* at least as long as the pool it is being attached to.
*
* Users of APR must take EXTREME care when choosing a key to
* use for their data. It is possible to accidentally overwrite
* data by choosing a key that another part of the program is using.
* Therefore it is advised that steps are taken to ensure that unique
* keys are used for all of the userdata objects in a particular pool
* (the same key in two different pools or a pool and one of its
* subpools is okay) at all times. Careful namespace prefixing of
* key names is a typical way to help ensure this uniqueness.
*/
APR_DECLARE(apr_status_t) apr_pool_userdata_set(
const void *data,
const char *key,
apr_status_t (*cleanup)(void *),
apr_pool_t *pool);
/**
* Set the data associated with the current pool
* @param data The user data associated with the pool.
* @param key The key to use for association
* @param cleanup The cleanup program to use to cleanup the data (NULL if none)
* @param pool The current pool
* @note same as apr_pool_userdata_set(), except that this version doesn't
* make a copy of the key (this function is useful, for example, when
* the key is a string literal)
* @warning This should NOT be used if the key could change addresses by
* any means between the apr_pool_userdata_setn() call and a
* subsequent apr_pool_userdata_get() on that key, such as if a
* static string is used as a userdata key in a DSO and the DSO could
* be unloaded and reloaded between the _setn() and the _get(). You
* MUST use apr_pool_userdata_set() in such cases.
* @warning More generally, the key and the data to be attached to the
* pool should have a life span at least as long as the pool itself.
*
*/
APR_DECLARE(apr_status_t) apr_pool_userdata_setn(
const void *data,
const char *key,
apr_status_t (*cleanup)(void *),
apr_pool_t *pool);
/**
* Return the data associated with the current pool.
* @param data The user data associated with the pool.
* @param key The key for the data to retrieve
* @param pool The current pool.
*/
APR_DECLARE(apr_status_t) apr_pool_userdata_get(void **data, const char *key,
apr_pool_t *pool);
/*
* Cleanup
*
* Cleanups are performed in the reverse order they were registered. That is:
* Last In, First Out.
*/
/**
* Register a function to be called when a pool is cleared or destroyed
* @param p The pool register the cleanup with
* @param data The data to pass to the cleanup function.
* @param plain_cleanup The function to call when the pool is cleared
* or destroyed
* @param child_cleanup The function to call when a child process is being
* shutdown - this function is called in the child, obviously!
*/
APR_DECLARE(void) apr_pool_cleanup_register(
apr_pool_t *p,
const void *data,
apr_status_t (*plain_cleanup)(void *),
apr_status_t (*child_cleanup)(void *));
/**
* Remove a previously registered cleanup function
* @param p The pool remove the cleanup from
* @param data The data to remove from cleanup
* @param cleanup The function to remove from cleanup
* @remarks For some strange reason only the plain_cleanup is handled by this
* function
*/
APR_DECLARE(void) apr_pool_cleanup_kill(apr_pool_t *p, const void *data,
apr_status_t (*cleanup)(void *));
/**
* Replace the child cleanup of a previously registered cleanup
* @param p The pool of the registered cleanup
* @param data The data of the registered cleanup
* @param plain_cleanup The plain cleanup function of the registered cleanup
* @param child_cleanup The function to register as the child cleanup
*/
APR_DECLARE(void) apr_pool_child_cleanup_set(
apr_pool_t *p,
const void *data,
apr_status_t (*plain_cleanup)(void *),
apr_status_t (*child_cleanup)(void *));
/**
* Run the specified cleanup function immediately and unregister it. Use
* @a data instead of the data that was registered with the cleanup.
* @param p The pool remove the cleanup from
* @param data The data to remove from cleanup
* @param cleanup The function to remove from cleanup
*/
APR_DECLARE(apr_status_t) apr_pool_cleanup_run(
apr_pool_t *p,
void *data,
apr_status_t (*cleanup)(void *));
/**
* An empty cleanup function
* @param data The data to cleanup
*/
APR_DECLARE_NONSTD(apr_status_t) apr_pool_cleanup_null(void *data);
/* Preparing for exec() --- close files, etc., but *don't* flush I/O
* buffers, *don't* wait for subprocesses, and *don't* free any memory.
*/
/**
* Run all of the child_cleanups, so that any unnecessary files are
* closed because we are about to exec a new program
*/
APR_DECLARE(void) apr_pool_cleanup_for_exec(void);
/**
* @defgroup PoolDebug Pool Debugging functions.
*
* pools have nested lifetimes -- sub_pools are destroyed when the
* parent pool is cleared. We allow certain liberties with operations
* on things such as tables (and on other structures in a more general
* sense) where we allow the caller to insert values into a table which
* were not allocated from the table's pool. The table's data will
* remain valid as long as all the pools from which its values are
* allocated remain valid.
*
* For example, if B is a sub pool of A, and you build a table T in
* pool B, then it's safe to insert data allocated in A or B into T
* (because B lives at most as long as A does, and T is destroyed when
* B is cleared/destroyed). On the other hand, if S is a table in
* pool A, it is safe to insert data allocated in A into S, but it
* is *not safe* to insert data allocated from B into S... because
* B can be cleared/destroyed before A is (which would leave dangling
* pointers in T's data structures).
*
* In general we say that it is safe to insert data into a table T
* if the data is allocated in any ancestor of T's pool. This is the
* basis on which the APR_POOL_DEBUG code works -- it tests these ancestor
* relationships for all data inserted into tables. APR_POOL_DEBUG also
* provides tools (apr_pool_find, and apr_pool_is_ancestor) for other
* folks to implement similar restrictions for their own data
* structures.
*
* However, sometimes this ancestor requirement is inconvenient --
* sometimes we're forced to create a sub pool (such as through
* apr_sub_req_lookup_uri), and the sub pool is guaranteed to have
* the same lifetime as the parent pool. This is a guarantee implemented
* by the *caller*, not by the pool code. That is, the caller guarantees
* they won't destroy the sub pool individually prior to destroying the
* parent pool.
*
* In this case the caller must call apr_pool_join() to indicate this
* guarantee to the APR_POOL_DEBUG code. There are a few examples spread
* through the standard modules.
*
* These functions are only implemented when #APR_POOL_DEBUG is set.
*
* @{
*/
#if APR_POOL_DEBUG || defined(DOXYGEN)
/**
* Guarantee that a subpool has the same lifetime as the parent.
* @param p The parent pool
* @param sub The subpool
*/
APR_DECLARE(void) apr_pool_join(apr_pool_t *p, apr_pool_t *sub);
/**
* Find a pool from something allocated in it.
* @param mem The thing allocated in the pool
* @return The pool it is allocated in
*/
APR_DECLARE(apr_pool_t *) apr_pool_find(const void *mem);
/**
* Report the number of bytes currently in the pool
* @param p The pool to inspect
* @param recurse Recurse/include the subpools' sizes
* @return The number of bytes
*/
APR_DECLARE(apr_size_t) apr_pool_num_bytes(apr_pool_t *p, int recurse);
/**
* Lock a pool
* @param pool The pool to lock
* @param flag The flag
*/
APR_DECLARE(void) apr_pool_lock(apr_pool_t *pool, int flag);
/* @} */
#else /* APR_POOL_DEBUG or DOXYGEN */
#ifdef apr_pool_join
#undef apr_pool_join
#endif
#define apr_pool_join(a,b)
#ifdef apr_pool_lock
#undef apr_pool_lock
#endif
#define apr_pool_lock(pool, lock)
#endif /* APR_POOL_DEBUG or DOXYGEN */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* !APR_POOLS_H */
--- NEW FILE: apr_mmap.h ---
/* 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_MMAP_H
#define APR_MMAP_H
/**
* @file apr_mmap.h
* @brief APR MMAP routines
*/
#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#include "apr_ring.h"
#include "apr_file_io.h" /* for apr_file_t */
#ifdef BEOS
#include <kernel/OS.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup apr_mmap MMAP (Memory Map) Routines
* @ingroup APR
* @{
*/
/** MMap opened for reading */
#define APR_MMAP_READ 1
/** MMap opened for writing */
#define APR_MMAP_WRITE 2
/** @see apr_mmap_t */
typedef struct apr_mmap_t apr_mmap_t;
/**
* @remark
* As far as I can tell the only really sane way to store an MMAP is as a
* void * and a length. BeOS requires this area_id, but that's just a little
* something extra. I am exposing this type, because it doesn't make much
* sense to keep it private, and opening it up makes some stuff easier in
* Apache.
*/
/** The MMAP structure */
struct apr_mmap_t {
/** The pool the mmap structure was allocated out of. */
apr_pool_t *cntxt;
#ifdef BEOS
/** An area ID. Only valid on BeOS */
area_id area;
#endif
#ifdef WIN32
/** The handle of the file mapping */
HANDLE mhandle;
/** The start of the real memory page area (mapped view) */
void *mv;
/** The physical start, size and offset */
apr_off_t pstart;
apr_size_t psize;
apr_off_t poffset;
#endif
/** The start of the memory mapped area */
void *mm;
/** The amount of data in the mmap */
apr_size_t size;
/** @deprecated this field is no longer used and will be removed
* in APR 1.0 */
int unused;
/** ring of apr_mmap_t's that reference the same
* mmap'ed region; acts in place of a reference count */
APR_RING_ENTRY(apr_mmap_t) link;
};
#if APR_HAS_MMAP || defined(DOXYGEN)
/** @def APR_MMAP_THRESHOLD
* Files have to be at least this big before they're mmap()d. This is to deal
* with systems where the expense of doing an mmap() and an munmap() outweighs
* the benefit for small files. It shouldn't be set lower than 1.
*/
#ifdef MMAP_THRESHOLD
# define APR_MMAP_THRESHOLD MMAP_THRESHOLD
#else
# ifdef SUNOS4
# define APR_MMAP_THRESHOLD (8*1024)
# else
# define APR_MMAP_THRESHOLD 1
# endif /* SUNOS4 */
#endif /* MMAP_THRESHOLD */
/** @def APR_MMAP_LIMIT
* Maximum size of MMap region
*/
#ifdef MMAP_LIMIT
# define APR_MMAP_LIMIT MMAP_LIMIT
#else
# define APR_MMAP_LIMIT (4*1024*1024)
#endif /* MMAP_LIMIT */
/** Can this file be MMaped */
#define APR_MMAP_CANDIDATE(filelength) \
((filelength >= APR_MMAP_THRESHOLD) && (filelength < APR_MMAP_LIMIT))
/* Function definitions */
/**
* Create a new mmap'ed file out of an existing APR file.
* @param newmmap The newly created mmap'ed file.
* @param file The file turn into an mmap.
* @param offset The offset into the file to start the data pointer at.
* @param size The size of the file
* @param flag bit-wise or of:
* <PRE>
* APR_MMAP_READ MMap opened for reading
* APR_MMAP_WRITE MMap opened for writing
* </PRE>
* @param cntxt The pool to use when creating the mmap.
*/
APR_DECLARE(apr_status_t) apr_mmap_create(apr_mmap_t **newmmap,
apr_file_t *file, apr_off_t offset,
apr_size_t size, apr_int32_t flag,
apr_pool_t *cntxt);
/**
* Duplicate the specified MMAP.
* @param new_mmap The structure to duplicate into.
* @param old_mmap The mmap to duplicate.
* @param p The pool to use for new_mmap.
* @param transfer_ownership DEPRECATED: this param is now ignored
* and should be removed prior to APR 1.0
*/
APR_DECLARE(apr_status_t) apr_mmap_dup(apr_mmap_t **new_mmap,
apr_mmap_t *old_mmap,
apr_pool_t *p,
int transfer_ownership);
#if defined(DOXYGEN)
/**
* Transfer the specified MMAP to a different pool
* @param new_mmap The structure to duplicate into.
* @param old_mmap The file to transfer.
* @param p The pool to use for new_mmap.
* @deprecated Just use apr_mmap_dup(). The transfer_ownership flag will
* go away soon anyway.
*/
APR_DECLARE(apr_status_t) apr_mmap_setaside(apr_mmap_t **new_mmap,
apr_mmap_t *old_mmap,
apr_pool_t *p);
#else
#define apr_mmap_setaside(new_mmap, old_mmap, p) apr_mmap_dup(new_mmap, old_mmap, p, 1)
#endif /* DOXYGEN */
/**
* Remove a mmap'ed.
* @param mm The mmap'ed file.
*/
APR_DECLARE(apr_status_t) apr_mmap_delete(apr_mmap_t *mm);
/**
* Move the pointer into the mmap'ed file to the specified offset.
* @param addr The pointer to the offset specified.
* @param mm The mmap'ed file.
* @param offset The offset to move to.
*/
APR_DECLARE(apr_status_t) apr_mmap_offset(void **addr, apr_mmap_t *mm,
apr_off_t offset);
#endif /* APR_HAS_MMAP */
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* ! APR_MMAP_H */
More information about the GME-commit
mailing list