231 lines
9.2 KiB
C
231 lines
9.2 KiB
C
/* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/**
|
|
* @file ap_socache.h
|
|
* @brief Small object cache provider interface.
|
|
*
|
|
* @defgroup AP_SOCACHE ap_socache
|
|
* @ingroup APACHE_MODS
|
|
* @{
|
|
*/
|
|
|
|
#ifndef AP_SOCACHE_H
|
|
#define AP_SOCACHE_H
|
|
|
|
#include "httpd.h"
|
|
#include "ap_provider.h"
|
|
#include "apr_pools.h"
|
|
#include "apr_time.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/** If this flag is set, the store/retrieve/remove/status interfaces
|
|
* of the provider are NOT safe to be called concurrently from
|
|
* multiple processes or threads, and an external global mutex must be
|
|
* used to serialize access to the provider.
|
|
*/
|
|
/* XXX: Even if store/retrieve/remove is atomic, isn't it useful to note
|
|
* independently that status and iterate may or may not be?
|
|
*/
|
|
#define AP_SOCACHE_FLAG_NOTMPSAFE (0x0001)
|
|
|
|
/** A cache instance. */
|
|
typedef struct ap_socache_instance_t ap_socache_instance_t;
|
|
|
|
/** Hints which may be passed to the init function; providers may
|
|
* ignore some or all of these hints. */
|
|
struct ap_socache_hints {
|
|
/** Approximate average length of IDs: */
|
|
apr_size_t avg_id_len;
|
|
/** Approximate average size of objects: */
|
|
apr_size_t avg_obj_size;
|
|
/** Suggested interval between expiry cleanup runs; */
|
|
apr_interval_time_t expiry_interval;
|
|
};
|
|
|
|
/**
|
|
* Iterator callback prototype for the ap_socache_provider_t->iterate() method
|
|
* @param instance The cache instance
|
|
* @param s Associated server context (for logging)
|
|
* @param userctx User defined pointer passed from the iterator call
|
|
* @param id Unique ID for the object (binary blob)
|
|
* with a trailing null char for convenience
|
|
* @param idlen Length of id blob
|
|
* @param data Output buffer to place retrieved data (binary blob)
|
|
* with a trailing null char for convenience
|
|
* @param datalen Length of data buffer
|
|
* @param pool Pool for temporary allocations
|
|
* @return APR status value; return APR_SUCCESS or the iteration will halt;
|
|
* this value is returned to the ap_socache_provider_t->iterate() caller
|
|
*/
|
|
typedef apr_status_t (ap_socache_iterator_t)(ap_socache_instance_t *instance,
|
|
server_rec *s,
|
|
void *userctx,
|
|
const unsigned char *id,
|
|
unsigned int idlen,
|
|
const unsigned char *data,
|
|
unsigned int datalen,
|
|
apr_pool_t *pool);
|
|
|
|
/** A socache provider structure. socache providers are registered
|
|
* with the ap_provider.h interface using the AP_SOCACHE_PROVIDER_*
|
|
* constants. */
|
|
typedef struct ap_socache_provider_t {
|
|
/** Canonical provider name. */
|
|
const char *name;
|
|
|
|
/** Bitmask of AP_SOCACHE_FLAG_* flags. */
|
|
unsigned int flags;
|
|
|
|
/**
|
|
* Create a session cache based on the given configuration string.
|
|
* The instance pointer returned in the instance parameter will be
|
|
* passed as the first argument to subsequent invocations.
|
|
*
|
|
* @param instance Output parameter to which instance object is written.
|
|
* @param arg User-specified configuration string. May be NULL to
|
|
* force use of defaults.
|
|
* @param tmp Pool to be used for any temporary allocations
|
|
* @param p Pool to be use for any allocations lasting as long as
|
|
* the created instance
|
|
* @return NULL on success, or an error string on failure.
|
|
*/
|
|
const char *(*create)(ap_socache_instance_t **instance, const char *arg,
|
|
apr_pool_t *tmp, apr_pool_t *p);
|
|
|
|
/**
|
|
* Initialize the cache. The cname must be of maximum length 16
|
|
* characters, and uniquely identifies the consumer of the cache
|
|
* within the server; using the module name is recommended, e.g.
|
|
* "mod_ssl-sess". This string may be used within a filesystem
|
|
* path so use of only alphanumeric [a-z0-9_-] characters is
|
|
* recommended. If hints is non-NULL, it gives a set of hints for
|
|
* the provider. Returns APR error code.
|
|
*
|
|
* @param instance The cache instance
|
|
* @param cname A unique string identifying the consumer of this API
|
|
* @param hints Optional hints argument describing expected cache use
|
|
* @param s Server structure to which the cache is associated
|
|
* @param pool Pool for long-lived allocations
|
|
* @return APR status value indicating success.
|
|
*/
|
|
apr_status_t (*init)(ap_socache_instance_t *instance, const char *cname,
|
|
const struct ap_socache_hints *hints,
|
|
server_rec *s, apr_pool_t *pool);
|
|
|
|
/**
|
|
* Destroy a given cache instance object.
|
|
* @param instance The cache instance to destroy.
|
|
* @param s Associated server structure (for logging purposes)
|
|
*/
|
|
void (*destroy)(ap_socache_instance_t *instance, server_rec *s);
|
|
|
|
/**
|
|
* Store an object in a cache instance.
|
|
* @param instance The cache instance
|
|
* @param s Associated server structure (for logging purposes)
|
|
* @param id Unique ID for the object; binary blob
|
|
* @param idlen Length of id blob
|
|
* @param expiry Absolute time at which the object expires
|
|
* @param data Data to store; binary blob
|
|
* @param datalen Length of data blob
|
|
* @param pool Pool for temporary allocations.
|
|
* @return APR status value.
|
|
*/
|
|
apr_status_t (*store)(ap_socache_instance_t *instance, server_rec *s,
|
|
const unsigned char *id, unsigned int idlen,
|
|
apr_time_t expiry,
|
|
unsigned char *data, unsigned int datalen,
|
|
apr_pool_t *pool);
|
|
|
|
/**
|
|
* Retrieve a cached object.
|
|
*
|
|
* @param instance The cache instance
|
|
* @param s Associated server structure (for logging purposes)
|
|
* @param id Unique ID for the object; binary blob
|
|
* @param idlen Length of id blob
|
|
* @param data Output buffer to place retrievd data (binary blob)
|
|
* @param datalen On entry, length of data buffer; on exit, the
|
|
* number of bytes written to the data buffer.
|
|
* @param pool Pool for temporary allocations.
|
|
* @return APR status value; APR_NOTFOUND if the object was not
|
|
* found
|
|
*/
|
|
apr_status_t (*retrieve)(ap_socache_instance_t *instance, server_rec *s,
|
|
const unsigned char *id, unsigned int idlen,
|
|
unsigned char *data, unsigned int *datalen,
|
|
apr_pool_t *pool);
|
|
|
|
/**
|
|
* Remove an object from the cache
|
|
*
|
|
* @param instance The cache instance
|
|
* @param s Associated server structure (for logging purposes)
|
|
* @param id Unique ID for the object; binary blob
|
|
* @param idlen Length of id blob
|
|
* @param pool Pool for temporary allocations.
|
|
*/
|
|
apr_status_t (*remove)(ap_socache_instance_t *instance, server_rec *s,
|
|
const unsigned char *id, unsigned int idlen,
|
|
apr_pool_t *pool);
|
|
|
|
/**
|
|
* Dump the status of a cache instance for mod_status. Will use
|
|
* the ap_r* interfaces to produce appropriate status output.
|
|
* XXX: ap_r* are deprecated, bad dogfood
|
|
*
|
|
* @param instance The cache instance
|
|
* @param r The request structure
|
|
* @param flags The AP_STATUS_* constants used (see mod_status.h)
|
|
*/
|
|
void (*status)(ap_socache_instance_t *instance, request_rec *r, int flags);
|
|
|
|
/**
|
|
* Dump all cached objects through an iterator callback.
|
|
* @param instance The cache instance
|
|
* @param s Associated server context (for processing and logging)
|
|
* @param userctx User defined pointer passed through to the iterator
|
|
* @param iterator The user provided callback function which will receive
|
|
* individual calls for each unexpired id/data pair
|
|
* @param pool Pool for temporary allocations.
|
|
* @return APR status value; APR_NOTFOUND if the object was not
|
|
* found
|
|
*/
|
|
apr_status_t (*iterate)(ap_socache_instance_t *instance, server_rec *s,
|
|
void *userctx, ap_socache_iterator_t *iterator,
|
|
apr_pool_t *pool);
|
|
|
|
} ap_socache_provider_t;
|
|
|
|
/** The provider group used to register socache providers. */
|
|
#define AP_SOCACHE_PROVIDER_GROUP "socache"
|
|
/** The provider version used to register socache providers. */
|
|
#define AP_SOCACHE_PROVIDER_VERSION "0"
|
|
|
|
/** Default provider name. */
|
|
#define AP_SOCACHE_DEFAULT_PROVIDER "default"
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* AP_SOCACHE_H */
|
|
/** @} */
|