RSC=rc.exe
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "API_EXPORT_SYMBOLS" /FD /c
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /I ".\modules\mpm\winnt" /I ".\lib\expat-lite" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
RSC=rc.exe
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
-# ADD BASE CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "API_EXPORT_SYMBOLS" /FD /c
+# ADD BASE CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /I ".\modules\mpm\winnt" /I ".\lib\expat-lite" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# PROP Intermediate_Dir ".\CoreR"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "API_EXPORT_SYMBOLS" /FD /c
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# PROP Intermediate_Dir ".\CoreD"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "API_EXPORT_SYMBOLS" /FD /c
+# ADD BASE CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# SUBTRACT CPP /YX
# ADD BASE MTL /nologo /D "_DEBUG" /win32
# Exuberant etags is necessary since it can ignore some defined symbols
# that obscure the function signatures.
-ignore=API_EXPORT,API_EXPORT_NONSTD,__declspec
+ignore=AP_DECLARE,AP_DECLARE_NONSTD,__declspec
# Create an etags file at the root of the source
# tree, then create symbol links to it from each
RSC=rc.exe
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "API_EXPORT_SYMBOLS" /FD /c
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /I ".\modules\mpm\winnt" /I ".\lib\expat-lite" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
RSC=rc.exe
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
-# ADD BASE CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "API_EXPORT_SYMBOLS" /FD /c
+# ADD BASE CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /I ".\modules\mpm\winnt" /I ".\lib\expat-lite" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
#define AP_DECLARE_DATA __declspec(dllimport)
#endif
-/* XXX: move to compatibility aliases once the symbol rename is complete
- */
-#define API_EXPORT(t) AP_DECLARE(t)
-#define API_EXPORT_NONSTD(t) AP_DECLARE_NONSTD(t)
-#define API_VAR_EXPORT AP_DECLARE_DATA
-
#if !defined(WIN32) || defined(AP_MODULE_DECLARE_STATIC)
/**
* Declare a dso module's exported module structure as AP_MODULE_DECLARE_DATA.
* content_languages MUST all be lowercase strings,
* and MAY NOT be modified in place -- modifications
* require pstrdup().
- * 19980317 (1.3b6-dev) -
CORE_EXPORTs for win32 and <Perl>
+ * 19980317 (1.3b6-dev) -
AP_CORE_DECLAREs for win32 and <Perl>
* API export basic_http_header, send_header_field,
* set_keepalive, srm_command_loop, check_cmd_context,
* tm2sec
* spacetoplus(), plustospace(), client_to_stdout()
* removed
- * 19980324 (1.3b6-dev) - API_EXPORT(index_of_response)
+ * 19980324 (1.3b6-dev) - AP_DECLARE(index_of_response)
* 19980413 (1.3b6-dev) - The BIG SYMBOL RENAMING: general ap_ prefix
* (see src/include/compat.h for more details)
* apr_vformatter() API, see src/include/ap.h
* @return 1 for shutdown 0 otherwise.
* @deffunc int ap_mpm_run(apr_pool_t *pconf, apr_pool_t *plog, server_rec *server_conf)
*/
-API_EXPORT(int) ap_mpm_run(apr_pool_t *pconf, apr_pool_t *plog, server_rec *server_conf);
+AP_DECLARE(int) ap_mpm_run(apr_pool_t *pconf, apr_pool_t *plog, server_rec *server_conf);
/**
* predicate indicating if a graceful stop has been requested ...
* @return 1 if a graceful stop has been requested, 0 otherwise
* @deffunc int ap_graceful_stop_signalled*void)
*/
-API_EXPORT(int) ap_graceful_stop_signalled(void);
+AP_DECLARE(int) ap_graceful_stop_signalled(void);
/**
* ap_start_shutdown() and ap_start_restart() is a function to initiate
* @deffunc void ap_start_shutdown(void)
*/
-API_EXPORT(void) ap_start_shutdown(void);
+AP_DECLARE(void) ap_start_shutdown(void);
#endif
* @return The module-specific data
* @deffunc void *ap_get_module_config(void *conf_vector, module *m)
*/
-API_EXPORT(void *) ap_get_module_config(void *conf_vector, module *m);
+AP_DECLARE(void *) ap_get_module_config(void *conf_vector, module *m);
/**
* Generic accessors for other modules to set at their own module-specific
* data
* @param val The module-specific data to set
* @deffunc void ap_set_module_config(void *conf_vector, module *m, void *val)
*/
-API_EXPORT(void) ap_set_module_config(void *conf_vector, module *m, void *val);
+AP_DECLARE(void) ap_set_module_config(void *conf_vector, module *m, void *val);
#define ap_get_module_config(v,m) \
(((void **)(v))[(m)->module_index])
* @return An error string or NULL on success
* @deffunc const char *ap_set_string_slot(cmd_parms *cmd, void *struct_ptr, const char *arg)
*/
-API_EXPORT_NONSTD(const char *) ap_set_string_slot(cmd_parms *, void *,
+AP_DECLARE_NONSTD(const char *) ap_set_string_slot(cmd_parms *, void *,
const char *);
/**
* @return 0 if the method is not limited in the current scope
* @deffunc ap_method_is_limited(cmd_parms *cmd, const char *method)
*/
-API_EXPORT(int) ap_method_is_limited(cmd_parms *cmd, const char *method);
+AP_DECLARE(int) ap_method_is_limited(cmd_parms *cmd, const char *method);
/**
* Generic command handling function for strings, always sets the value
* @return An error string or NULL on success
* @deffunc const char *ap_set_string_slot_lower(cmd_parms *cmd, void *struct_ptr, const char *arg)
*/
-API_EXPORT_NONSTD(const char *) ap_set_string_slot_lower(cmd_parms *,
+AP_DECLARE_NONSTD(const char *) ap_set_string_slot_lower(cmd_parms *,
void *, const char *);
/**
* Generic command handling function for flags
* @return An error string or NULL on success
* @deffunc const char *ap_set_flag_slot(cmd_parms *cmd, void *struct_ptr, int arg)
*/
-API_EXPORT_NONSTD(const char *) ap_set_flag_slot(cmd_parms *, void *, int);
+AP_DECLARE_NONSTD(const char *) ap_set_flag_slot(cmd_parms *, void *, int);
/**
* Generic command handling function for files
* @param cmd The command parameters for this directive
* @return An error string or NULL on success
* @deffunc const char *ap_set_file_slot(cmd_parms *cmd, char *struct_ptr, const char *arg)
*/
-API_EXPORT_NONSTD(const char *) ap_set_file_slot(cmd_parms *, char *, const char *);
+AP_DECLARE_NONSTD(const char *) ap_set_file_slot(cmd_parms *, char *, const char *);
/**
* For modules which need to read config files, open logs, etc. ...
* @param fname The file name
* @deffunc const char *ap_server_root_relative(apr_pool_t *p, const char *fname)
*/
-API_EXPORT(const char *) ap_server_root_relative(apr_pool_t *p, const char *fname);
+AP_DECLARE(const char *) ap_server_root_relative(apr_pool_t *p, const char *fname);
/* Finally, the hook for dynamically loading modules in... */
* @param m the module structure of the module to add
* @deffunc void ap_add_module(module *m)
*/
-API_EXPORT(void) ap_add_module(module *m);
+AP_DECLARE(void) ap_add_module(module *m);
/**
* Remove a module from the server. There are some caveats:
* when the module is removed, its slot is lost so all the current
* @param m the module structure of the module to remove
* @deffunc void ap_remove_module(module *m)
*/
-API_EXPORT(void) ap_remove_module(module *m);
+AP_DECLARE(void) ap_remove_module(module *m);
/**
* Add a module to the chained modules list and the list of loaded modules
* @param m the module structure of the module to add
* @deffunc void ap_add_loaded_module(module *m)
*/
-API_EXPORT(void) ap_add_loaded_module(module *mod);
+AP_DECLARE(void) ap_add_loaded_module(module *mod);
/**
* Remove a module fromthe chained modules list and the list of loaded modules
* @param m the module structure of the module to remove
* @deffunc void ap_remove_loaded_module(module *m)
*/
-API_EXPORT(void) ap_remove_loaded_module(module *mod);
+AP_DECLARE(void) ap_remove_loaded_module(module *mod);
/**
* Add a module to the list of loaded module based on the name of the
* module
* @return 1 on success, 0 on failure
* @deffunc int ap_add_named_module(const char *name)
*/
-API_EXPORT(int) ap_add_named_module(const char *name);
+AP_DECLARE(int) ap_add_named_module(const char *name);
/**
* Clear all of the modules from the loaded module list
* @deffunc void ap_add_named_module(void)
*/
-API_EXPORT(void) ap_clear_module_list(void);
+AP_DECLARE(void) ap_clear_module_list(void);
/**
* Find the name of the specified module
* @param m The module to get the name for
* @return the name of the module
* @deffunc const char *ap_find_module_name(module *m)
*/
-API_EXPORT(const char *) ap_find_module_name(module *m);
+AP_DECLARE(const char *) ap_find_module_name(module *m);
/**
* Find a module based on the name of the module
* @param name the name of the module
* @return the module structure if found, NULL otherwise
* @deffunc module *ap_find_linked_module(const char *name)
*/
-API_EXPORT(module *) ap_find_linked_module(const char *name);
+AP_DECLARE(module *) ap_find_linked_module(const char *name);
/**
* Open a configfile_t as apr_file_t
* @param name the name of the file to open
* @deffunc apr_status_t ap_pcfg_openfile(configfile_t **ret_cfg, apr_pool_t *p, const char *name)
*/
-API_EXPORT(apr_status_t) ap_pcfg_openfile(configfile_t **, apr_pool_t *p, const char *name);
+AP_DECLARE(apr_status_t) ap_pcfg_openfile(configfile_t **, apr_pool_t *p, const char *name);
/**
* Allocate a configfile_t handle with user defined functions and params
* @param close_func The close function
* @deffunc configfile_t *ap_pcfg_open_custom(apr_pool_t *p, const char *descr, void *param, int(*getc_func)(void*), void *(*gets_func) (void *buf, size_t bufsiz, void *param), int(*close_func)(void *param))
*/
-API_EXPORT(configfile_t *) ap_pcfg_open_custom(apr_pool_t *p, const char *descr,
+AP_DECLARE(configfile_t *) ap_pcfg_open_custom(apr_pool_t *p, const char *descr,
void *param,
int(*getc_func)(void*),
void *(*gets_func) (void *buf, size_t bufsiz, void *param),
* @return 1 on success, 0 on failure
* @deffunc int ap_cfg_getline(char *buf, size_t bufsize, configfile_t *cfp)
*/
-API_EXPORT(int) ap_cfg_getline(char *buf, size_t bufsize, configfile_t *cfp);
+AP_DECLARE(int) ap_cfg_getline(char *buf, size_t bufsize, configfile_t *cfp);
/**
* Read one char from open configfile_t, increase line number upon LF
* @return the character read
* @deffunc int ap_cfg_getc(configfile_t *cfp)
*/
-API_EXPORT(int) ap_cfg_getc(configfile_t *cfp);
+AP_DECLARE(int) ap_cfg_getc(configfile_t *cfp);
/**
* Detach from open configfile_t, calling the close handler
* @return 1 on sucess, 0 on failure
* @deffunc int ap_cfg_closefile(configfile_t *cfp)
*/
-API_EXPORT(int) ap_cfg_closefile(configfile_t *cfp);
+AP_DECLARE(int) ap_cfg_closefile(configfile_t *cfp);
/**
* Read all data between the current <foo> and the matching </foo>. All
* @retrn Error string on failure, NULL on success
* @deffunc const char *ap_soak_end_container(cmd_parms *cmd, char *directive)
*/
-API_EXPORT(const char *) ap_soak_end_container(cmd_parms *cmd, char *directive);
+AP_DECLARE(const char *) ap_soak_end_container(cmd_parms *cmd, char *directive);
/**
* Read all data between the current <foo> and the matching </foo> and build
* @return Error string on erro, NULL otherwise
* @deffunc const char *ap_build_config(cmd_parms *parms, apr_pool_t *conf_pool, apr_pool_t *temp_pool, ap_directive_t **conftree)
*/
-API_EXPORT(const char *) ap_build_config(cmd_parms *parms,
+AP_DECLARE(const char *) ap_build_config(cmd_parms *parms,
apr_pool_t *conf_pool,
apr_pool_t *temp_pool,
ap_directive_t **conftree);
* @return Error string on error, NULL otherwise
* @deffunc const char *ap_walk_config(ap_directive_t *conftree, cmd_parms *parms, void *config)
*/
-API_EXPORT(const char *) ap_walk_config(ap_directive_t *conftree,
+AP_DECLARE(const char *) ap_walk_config(ap_directive_t *conftree,
cmd_parms *parms, void *config);
/**
* @return Error string on error, NULL on success
* @deffunc const char *ap_check_cmd_context(cmd_parms *cmd, unsigned forbidden)
*/
-API_EXPORT(const char *) ap_check_cmd_context(cmd_parms *cmd, unsigned forbidden);
+AP_DECLARE(const char *) ap_check_cmd_context(cmd_parms *cmd, unsigned forbidden);
/* ap_check_cmd_context(): Forbidden in: */
#define NOT_IN_VIRTUALHOST 0x01 /* <Virtualhost> */
* The topmost module in the list
* @defvar module *top_module
*/
-extern API_VAR_EXPORT module *top_module;
+extern AP_DECLARE_DATA module *top_module;
/**
* Array of all statically linked modules
* @defvar module *ap_prelinked_modules[]
*/
-extern API_VAR_EXPORT module *ap_prelinked_modules[];
+extern AP_DECLARE_DATA module *ap_prelinked_modules[];
/**
* Array of all preloaded modules
* @defvar module *ap_preloaded_modules[]
*/
-extern API_VAR_EXPORT module *ap_preloaded_modules[];
+extern AP_DECLARE_DATA module *ap_preloaded_modules[];
/**
* Array of all loaded modules
* @defvar module **ap_loaded_modules
*/
-extern API_VAR_EXPORT module **ap_loaded_modules;
+extern AP_DECLARE_DATA module **ap_loaded_modules;
/* For mod_so.c... */
/** Run a single module's two create_config hooks
* @param process The process that is currently running the server
* @deffunc void ap_setup_prelinked_modules(process_rec *process)
*/
-API_EXPORT(void) ap_setup_prelinked_modules(process_rec *process);
+AP_DECLARE(void) ap_setup_prelinked_modules(process_rec *process);
/**
*Show the preloaded configuration directives, the help string explaining
* what parts of the configuration they are allowed. Used for httpd -h.
* @deffunc void ap_show_directives(void)
*/
-API_EXPORT(void) ap_show_directives(void);
+AP_DECLARE(void) ap_show_directives(void);
/**
* Show the preloaded module names. Used for httpd -l.
* @deffunc void ap_show_modules(void)
*/
-API_EXPORT(void) ap_show_modules(void);
+AP_DECLARE(void) ap_show_modules(void);
/**
* Read all config files and setup the server
* @return The setup server_rec list.
* @deffunc server_rec *ap_read_config(process_rec *process, apr_pool_t *temp_pool, const char *config_name, ap_directive_t **conftree)
*/
-API_EXPORT(server_rec*) ap_read_config(process_rec *process, apr_pool_t *temp_pool, const char *config_name, ap_directive_t **conftree);
+AP_DECLARE(server_rec*) ap_read_config(process_rec *process, apr_pool_t *temp_pool, const char *config_name, ap_directive_t **conftree);
/**
* Run all post config hooks for loaded modules.
* @param s The list of server_rec structures
* @deffunc void ap_post_config_hook(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
*/
-API_EXPORT(void) ap_post_config_hook(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s);
+AP_DECLARE(void) ap_post_config_hook(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s);
/**
* Run all rewrite args hooks for loaded modules
* @param process The process currently running the server
* @deffunc void ap_run_rewrite_args(process_rec *process)
*/
-API_EXPORT(void) ap_run_rewrite_args(process_rec *process);
+AP_DECLARE(void) ap_run_rewrite_args(process_rec *process);
/**
* Run the register hooks function for a specified module
* @param m The module to run the register hooks function fo
* @deffunc void ap_register_hooks(module *m)
*/
-API_EXPORT(void) ap_register_hooks(module *m);
+AP_DECLARE(void) ap_register_hooks(module *m);
/**
* Setup all virtual hosts
* @param main_server The head of the server_rec list
* @deffunc void ap_fixup_virtual_hosts(apr_pool_t *p, server_rec *main_server)
*/
-API_EXPORT(void) ap_fixup_virtual_hosts(apr_pool_t *p, server_rec *main_server);
+AP_DECLARE(void) ap_fixup_virtual_hosts(apr_pool_t *p, server_rec *main_server);
/* For http_request.c... */
* @return The config vector
* @deffunc void *ap_create_per_dir_config(apr_pool_t *p)
*/
-CORE_EXPORT(void *) ap_create_per_dir_config(apr_pool_t *p);
+AP_CORE_DECLARE(void *) ap_create_per_dir_config(apr_pool_t *p);
/**
* Run all of the modules merge per dir config functions
* return Error string on error, NULL on success
* @deffunc const char *ap_init_virtual_host(apr_pool_t *p, const char *hostname, server_rec *main_server, server_rec **ps)
*/
-CORE_EXPORT(const char *) ap_init_virtual_host(apr_pool_t *p, const char *hostname,
+AP_CORE_DECLARE(const char *) ap_init_virtual_host(apr_pool_t *p, const char *hostname,
server_rec *main_server, server_rec **);
/**
* @param p The pool for general allocation
* @param ptemp The pool for temporary allocations
*/
-API_EXPORT(void) ap_process_config_tree(server_rec *s, ap_directive_t *conftree,
+AP_DECLARE(void) ap_process_config_tree(server_rec *s, ap_directive_t *conftree,
apr_pool_t *p, apr_pool_t *ptemp);
* @return The directive definition of the specified directive
* @deffunc const command_rec *ap_find_command(const char *name, const command_rec *cmds)
*/
-CORE_EXPORT(const command_rec *) ap_find_command(const char *name, const command_rec *cmds);
+AP_CORE_DECLARE(const command_rec *) ap_find_command(const char *name, const command_rec *cmds);
/**
* Find a given directive in a list module
* @return The directive definition of the specified directive
* @deffunc const command_rec *ap_find_command_in_modules(const char *cmd_name,module **mod)
*/
-CORE_EXPORT(const command_rec *) ap_find_command_in_modules(const char *cmd_name, module **mod);
+AP_CORE_DECLARE(const command_rec *) ap_find_command_in_modules(const char *cmd_name, module **mod);
/**
* Add a per_dir and per_server config vector to a given module
* @return The new config vector
* @deffunc void *ap_set_config_vectors(cmd_parms *parms, void *config, module *mod)
*/
-CORE_EXPORT(void *) ap_set_config_vectors(cmd_parms *parms, void *config, module *mod);
+AP_CORE_DECLARE(void *) ap_set_config_vectors(cmd_parms *parms, void *config, module *mod);
#endif
* @param c The connection on which the request is read
* @deffunc void ap_process_connection(conn_rec *)
*/
-CORE_EXPORT(void) ap_process_connection(conn_rec *);
+AP_CORE_DECLARE(void) ap_process_connection(conn_rec *);
/**
* The http pre-protocol handler. This makes sets up Apache to serve http
* @return the Options bitmask
* @deffunc int ap_allow_options(request_rec *r)
*/
-API_EXPORT(int) ap_allow_options (request_rec *);
+AP_DECLARE(int) ap_allow_options (request_rec *);
/**
* Retrieve the value of the AllowOverride for this request
* @param r The current request
* @return the overrides bitmask
* @deffunc int ap_allow_overrides(request_rec *r)
*/
-API_EXPORT(int) ap_allow_overrides (request_rec *);
+AP_DECLARE(int) ap_allow_overrides (request_rec *);
/**
* Retrieve the value of the DefaultType directive, or text/plain if not set
* @param r The current request
* @return The default type
* @deffunc const char *ap_default_type(request_rec *r)
*/
-API_EXPORT(const char *) ap_default_type (request_rec *);
+AP_DECLARE(const char *) ap_default_type (request_rec *);
/**
* Retrieve the document root for this server
* @param r The current request
* @return The document root
* @deffunc const char *ap_document_root(request_rec *r)
*/
-API_EXPORT(const char *) ap_document_root (request_rec *);
+AP_DECLARE(const char *) ap_document_root (request_rec *);
/**
* Lookup the remote client's DNS name or IP address
* @param conn The current connection
* @return The remote hostname
* @deffunc const char *ap_get_remote_host(conn_rec *conn, void *dir_config, int type)
*/
-API_EXPORT(const char *) ap_get_remote_host(conn_rec *conn, void *dir_config, int type);
+AP_DECLARE(const char *) ap_get_remote_host(conn_rec *conn, void *dir_config, int type);
/**
* Retrieve the login name of the remote user. Undef if it could not be
* determined
* @return The user logged in to the client machine
* @deffunc const char *ap_get_remote_logname(request_rec *r)
*/
-API_EXPORT(const char *) ap_get_remote_logname(request_rec *r);
+AP_DECLARE(const char *) ap_get_remote_logname(request_rec *r);
/* Used for constructing self-referencing URLs, and things like SERVER_PORT,
* and SERVER_NAME.
* @return A fully qualified URL
* @deffunc char *ap_construct_url(apr_pool_t *p, const char *uri, request_rec *r)
*/
-API_EXPORT(char *) ap_construct_url(apr_pool_t *p, const char *uri, request_rec *r);
+AP_DECLARE(char *) ap_construct_url(apr_pool_t *p, const char *uri, request_rec *r);
/**
* Get the current server name from the request
* @param r The current request
* @return the server name
* @deffunc const char *ap_get_server_name(request_rec *r)
*/
-API_EXPORT(const char *) ap_get_server_name(request_rec *r);
+AP_DECLARE(const char *) ap_get_server_name(request_rec *r);
/**
* Get the current server port
* @param The current request
* @return The server's port
* @deffunc unsigned ap_get_server_port(const request_rec *r)
*/
-API_EXPORT(unsigned) ap_get_server_port(const request_rec *r);
+AP_DECLARE(unsigned) ap_get_server_port(const request_rec *r);
/**
* Return the limit on bytes in request msg body
* @param r The current request
* @return the maximum number of bytes in the request msg body
* @deffunc unsigned long ap_get_limit_req_body(const request_rec *r)
*/
-API_EXPORT(unsigned long) ap_get_limit_req_body(const request_rec *r);
+AP_DECLARE(unsigned long) ap_get_limit_req_body(const request_rec *r);
/**
* Return the limit on bytes in XML request msg body
* @param r The current request
* @return the maximum number of bytes in XML request msg body
* @deffunc size_t ap_get_limit_xml_body(const request_rec *r)
*/
-API_EXPORT(size_t) ap_get_limit_xml_body(const request_rec *r);
+AP_DECLARE(size_t) ap_get_limit_xml_body(const request_rec *r);
/**
* Install a custom response handler for a given status
* @param r The current request
* or a URL
* @deffunc void ap_custom_response(request_rec *r, int status, char *string)
*/
-API_EXPORT(void) ap_custom_response(request_rec *r, int status, char *string);
+AP_DECLARE(void) ap_custom_response(request_rec *r, int status, char *string);
/**
* Check for a definition from the server command line
* @param name The define to check for
* @return 1 if defined, 0 otherwise
* @deffunc int ap_exists_config_define(const char *name)
*/
-API_EXPORT(int) ap_exists_config_define(const char *name);
+AP_DECLARE(int) ap_exists_config_define(const char *name);
/* FIXME! See STATUS about how */
-API_EXPORT_NONSTD(int) ap_core_translate(request_rec *r);
+AP_DECLARE_NONSTD(int) ap_core_translate(request_rec *r);
/* Authentication stuff. This is one of the places where compatibility
* with the old config files *really* hurts; they don't discriminate at
* @return The authorization required
* @deffunc const char *ap_auth_type(request_rec *r)
*/
-API_EXPORT(const char *) ap_auth_type (request_rec *);
+AP_DECLARE(const char *) ap_auth_type (request_rec *);
/**
* Return the current Authorization realm
* @param r The current request
* @return The current authorization realm
* @deffunc const char *ap_auth_name(request_rec *r)
*/
-API_EXPORT(const char *) ap_auth_name (request_rec *);
+AP_DECLARE(const char *) ap_auth_name (request_rec *);
/**
* How the requires lines must be met.
* @param r The current request
* </PRE>
* @deffunc int ap_satisfies(request_rec *r)
*/
-API_EXPORT(int) ap_satisfies (request_rec *r);
+AP_DECLARE(int) ap_satisfies (request_rec *r);
/**
* Retrieve information about all of the requires directives for this request
* @param r The current request
* @return An array of all requires directives for this request
* @deffunc const apr_array_header_t *ap_requires(request_rec *r)
*/
-API_EXPORT(const apr_array_header_t *) ap_requires (request_rec *);
+AP_DECLARE(const apr_array_header_t *) ap_requires (request_rec *);
#ifdef WIN32
/*
typedef enum { INTERPRETER_SOURCE_UNSET, INTERPRETER_SOURCE_REGISTRY_STRICT,
INTERPRETER_SOURCE_REGISTRY, INTERPRETER_SOURCE_SHEBANG
} interpreter_source_e;
-API_EXPORT(file_type_e) ap_get_win32_interpreter(const request_rec *,
+AP_DECLARE(file_type_e) ap_get_win32_interpreter(const request_rec *,
char **interpreter,
char **arguments);
#endif
char *ap_response_code_string (request_rec *r, int error_index);
-extern API_VAR_EXPORT module core_module;
+extern AP_DECLARE_DATA module core_module;
/* Per-directory configuration */
void ap_core_reorder_directories(apr_pool_t *, server_rec *);
/* for mod_perl */
-CORE_EXPORT(void) ap_add_per_dir_conf (server_rec *s, void *dir_config);
-CORE_EXPORT(void) ap_add_per_url_conf (server_rec *s, void *url_config);
-CORE_EXPORT(void) ap_add_file_conf(core_dir_config *conf, void *url_config);
-CORE_EXPORT_NONSTD(const char *) ap_limit_section (cmd_parms *cmd, void *dummy, const char *arg);
+AP_CORE_DECLARE(void) ap_add_per_dir_conf (server_rec *s, void *dir_config);
+AP_CORE_DECLARE(void) ap_add_per_url_conf (server_rec *s, void *url_config);
+AP_CORE_DECLARE(void) ap_add_file_conf(core_dir_config *conf, void *url_config);
+AP_CORE_DECLARE_NONSTD(const char *) ap_limit_section (cmd_parms *cmd, void *dummy, const char *arg);
#endif
* untrusted data.
* @deffunc void ap_log_error(const char *file, int line, int level, apr_status_t status, const server_rec *s, const char *fmt, ...)
*/
-API_EXPORT(void) ap_log_error(const char *file, int line, int level,
+AP_DECLARE(void) ap_log_error(const char *file, int line, int level,
apr_status_t status, const server_rec *s,
const char *fmt, ...)
__attribute__((format(printf,6,7)));
* untrusted data.
* @deffunc void ap_log_error(const char *file, int line, int level, apr_status_t status, apr_pool_t *p, const char *fmt, ...)
*/
-API_EXPORT(void) ap_log_perror(const char *file, int line, int level,
+AP_DECLARE(void) ap_log_perror(const char *file, int line, int level,
apr_status_t status, apr_pool_t *p,
const char *fmt, ...)
__attribute__((format(printf,6,7)));
* untrusted data.
* @deffunc void ap_log_error(const char *file, int line, int level, apr_status_t status, request_rec *s, const char *fmt, ...)
*/
-API_EXPORT(void) ap_log_rerror(const char *file, int line, int level,
+AP_DECLARE(void) ap_log_rerror(const char *file, int line, int level,
apr_status_t status, const request_rec *s,
const char *fmt, ...)
__attribute__((format(printf,6,7)));
* @param s The current server
* @deffunc void ap_error_log2stderr(server_rec *s)
*/
-API_EXPORT(void) ap_error_log2stderr (server_rec *);
+AP_DECLARE(void) ap_error_log2stderr (server_rec *);
/**
* Log the current pid of the parent process
* @return The piped log structure
* @deffunc piped_log *ap_open_piped_log(apr_pool_t *p, const char *program)
*/
-API_EXPORT(piped_log *) ap_open_piped_log (apr_pool_t *p, const char *program);
+AP_DECLARE(piped_log *) ap_open_piped_log (apr_pool_t *p, const char *program);
/**
* Close the piped log and kill the logging process
* @param pl The piped log structure
* @deffunc void ap_close_piped_log(piped_log *pl)
*/
-API_EXPORT(void) ap_close_piped_log (piped_log *);
+AP_DECLARE(void) ap_close_piped_log (piped_log *);
/**
* A macro to access the read side of the piped log pipe
*/
/** The name of the Apache executable */
-extern API_VAR_EXPORT const char *ap_server_argv0;
+extern AP_DECLARE_DATA const char *ap_server_argv0;
/** The global server's ServerRoot */
-extern API_VAR_EXPORT const char *ap_server_root;
+extern AP_DECLARE_DATA const char *ap_server_root;
/* for -C, -c and -D switches */
/** An array of all -C directives. These are processed before the server's
* config file */
-extern API_VAR_EXPORT apr_array_header_t *ap_server_pre_read_config;
+extern AP_DECLARE_DATA apr_array_header_t *ap_server_pre_read_config;
/** An array of all -c directives. These are processed after the server's
* config file */
-extern API_VAR_EXPORT apr_array_header_t *ap_server_post_read_config;
+extern AP_DECLARE_DATA apr_array_header_t *ap_server_post_read_config;
/** An array of all -D defines on the command line. This allows people to
* effect the server based on command line options */
-extern API_VAR_EXPORT apr_array_header_t *ap_server_config_defines;
+extern AP_DECLARE_DATA apr_array_header_t *ap_server_config_defines;
#ifdef __cplusplus
}
* @param fieldval The value of the header
* @deffunc int ap_send_header_field(request_rec *r, const char *fieldname, const char *fieldval)
*/
-API_EXPORT_NONSTD(int) ap_send_header_field(request_rec *r, const char *fieldname,
+AP_DECLARE_NONSTD(int) ap_send_header_field(request_rec *r, const char *fieldname,
const char *fieldval);
/**
* correctness depends on code in ap_send_http_header().
* @deffunc void ap_basic_http_header(request_rec *r)
*/
-API_EXPORT(void) ap_basic_http_header(request_rec *r);
+AP_DECLARE(void) ap_basic_http_header(request_rec *r);
/**
* Send the Status-Line and header fields for HTTP response
* @param l The current request
* @deffunc void ap_send_http_header(request_rec *l)
*/
-API_EXPORT(void) ap_send_http_header(request_rec *l);
+AP_DECLARE(void) ap_send_http_header(request_rec *l);
/* Send the response to special method requests */
-API_EXPORT(int) ap_send_http_trace(request_rec *r);
+AP_DECLARE(int) ap_send_http_trace(request_rec *r);
int ap_send_http_options(request_rec *r);
/* Finish up stuff after a request */
* @param r The current request
* @deffunc void ap_finalize_request_protocol(request_rec *r)
*/
-API_EXPORT(void) ap_finalize_request_protocol(request_rec *r);
+AP_DECLARE(void) ap_finalize_request_protocol(request_rec *r);
/**
* Send error back to client.
* on the problem with the ErrorDocument.
* @deffunc void ap_send_error_response(request_rec *r, int recursive_error)
*/
-API_EXPORT(void) ap_send_error_response(request_rec *r, int recursive_error);
+AP_DECLARE(void) ap_send_error_response(request_rec *r, int recursive_error);
/* Set last modified header line from the lastmod date of the associated file.
* Also, set content length.
* @return Always 0, can be safely ignored
* @deffunc int ap_set_content_length(request_rec *r, long length)
*/
-API_EXPORT(int) ap_set_content_length(request_rec *r, long length);
+AP_DECLARE(int) ap_set_content_length(request_rec *r, long length);
/**
* Set the keepalive status for this request
* @param r The current request
* @return 1 if keepalive can be set, 0 otherwise
* @deffunc int ap_set_keepalive(request_rec *r)
*/
-API_EXPORT(int) ap_set_keepalive(request_rec *r);
+AP_DECLARE(int) ap_set_keepalive(request_rec *r);
/**
* Return the latest rational time from a request/mtime pair. Mtime is
* returned unless it's in the future, in which case we return the current time.
* @return the latest rational time.
* @deffunc apr_time_t ap_rationalize_mtime(request_rec *r, apr_time_t mtime)
*/
-API_EXPORT(apr_time_t) ap_rationalize_mtime(request_rec *r, apr_time_t mtime);
+AP_DECLARE(apr_time_t) ap_rationalize_mtime(request_rec *r, apr_time_t mtime);
/**
* Construct an entity tag from the resource information. If it's a real
* file, build in some of the file characteristics.
* @return The entity tag
* @deffunc char *ap_make_etag(request_rec *r, int force_weak)
*/
-API_EXPORT(char *) ap_make_etag(request_rec *r, int force_weak);
+AP_DECLARE(char *) ap_make_etag(request_rec *r, int force_weak);
/**
* Set the E-tag outgoing header
* @param The current request
* @deffunc void ap_set_etag(request_rec *r)
*/
-API_EXPORT(void) ap_set_etag(request_rec *r);
+AP_DECLARE(void) ap_set_etag(request_rec *r);
/**
* Set the last modified time for the file being sent
* @param r The current request
* @deffunc void ap_set_last_modified(request_rec *r)
*/
-API_EXPORT(void) ap_set_last_modified(request_rec *r);
+AP_DECLARE(void) ap_set_last_modified(request_rec *r);
/**
* Implements condition GET rules for HTTP/1.1 specification. This function
* inspects the client headers and determines if the response fulfills
* @return 1 if the response fulfills the condition GET rules, 0 otherwise
* @deffunc int ap_meets_conditions(request_rec *r)
*/
-API_EXPORT(int) ap_meets_conditions(request_rec *r);
+AP_DECLARE(int) ap_meets_conditions(request_rec *r);
/* Other ways to send stuff at the client. All of these keep track
* of bytes_sent automatically. This indirection is intended to make
* @param nbytes Amount of data actually sent
* @deffunc apr_status_t ap_send_fd(apr_file_t *fd, request_rec *r, apr_off_t offset, apr_size_t length, apr_size_t *nbytes);
*/
-API_EXPORT(apr_status_t) ap_send_fd(apr_file_t *fd, request_rec *r, apr_off_t offset,
+AP_DECLARE(apr_status_t) ap_send_fd(apr_file_t *fd, request_rec *r, apr_off_t offset,
apr_size_t length, apr_size_t *nbytes);
/**
* Send an MMAP'ed file to the client
* @return The number of bytes sent
* @deffunc size_t ap_send_mmap(apr_mmap_t *mm, request_rec *r, size_t offset, size_t length)
*/
-API_EXPORT(size_t) ap_send_mmap(apr_mmap_t *mm, request_rec *r, size_t offset,
+AP_DECLARE(size_t) ap_send_mmap(apr_mmap_t *mm, request_rec *r, size_t offset,
size_t length);
/**
* @return Pointer to the newly created structure.
* @deffunc ap_method_list_t ap_make_method_list(apr_pool_t *p, int nelts)
*/
-API_EXPORT(ap_method_list_t *) ap_make_method_list(apr_pool_t *p, int nelts);
-API_EXPORT(void) ap_copy_method_list(ap_method_list_t *dest,
+AP_DECLARE(ap_method_list_t *) ap_make_method_list(apr_pool_t *p, int nelts);
+AP_DECLARE(void) ap_copy_method_list(ap_method_list_t *dest,
ap_method_list_t *src);
-API_EXPORT_NONSTD(void) ap_method_list_do(int (*comp) (void *urec, const char *mname,
+AP_DECLARE_NONSTD(void) ap_method_list_do(int (*comp) (void *urec, const char *mname,
int mnum),
void *rec,
const ap_method_list_t *ml, ...);
-API_EXPORT(void) ap_method_list_vdo(int (*comp) (void *urec, const char *mname,
+AP_DECLARE(void) ap_method_list_vdo(int (*comp) (void *urec, const char *mname,
int mnum),
void *rec, const ap_method_list_t *ml,
va_list vp);
* @return 1 if method is in the list, otherwise 0
* @deffunc int ap_method_in_list(const char *method, ap_method_list_t *l)
*/
-API_EXPORT(int) ap_method_in_list(ap_method_list_t *l, const char *method);
+AP_DECLARE(int) ap_method_in_list(ap_method_list_t *l, const char *method);
/**
* Add an HTTP method name to an ap_method_list_t structure if it isn't
* @return None.
* @deffunc void ap_method_in_list(ap_method_list_t *l, const char *method)
*/
-API_EXPORT(void) ap_method_list_add(ap_method_list_t *l, const char *method);
+AP_DECLARE(void) ap_method_list_add(ap_method_list_t *l, const char *method);
/**
* Remove an HTTP method name from an ap_method_list_t structure.
* @return None.
* @deffunc void ap_method_list_remove(ap_method_list_t *l, const char *method)
*/
-API_EXPORT(void) ap_method_list_remove(ap_method_list_t *l,
+AP_DECLARE(void) ap_method_list_remove(ap_method_list_t *l,
const char *method);
/**
* @return None.
* @deffunc void ap_clear_method_list(ap_method_list_t *l)
*/
-API_EXPORT(void) ap_clear_method_list(ap_method_list_t *l);
+AP_DECLARE(void) ap_clear_method_list(ap_method_list_t *l);
/* Hmmm... could macrofy these for now, and maybe forever, though the
* definitions of the macros would get a whole lot hairier.
* @return The number of bytes sent
* @deffunc int ap_rputc(int c, request_rec *r)
*/
-API_EXPORT(int) ap_rputc(int c, request_rec *r);
+AP_DECLARE(int) ap_rputc(int c, request_rec *r);
/**
* Output a string for the current request
* @param str The string to output
* @return The number of bytes sent
* @deffunc int ap_rputs(const char *str, request_rec *r)
*/
-API_EXPORT(int) ap_rputs(const char *str, request_rec *r);
+AP_DECLARE(int) ap_rputs(const char *str, request_rec *r);
/**
* Write a buffer for the current request
* @param buf The buffer to write
* @return The number of bytes sent
* @deffunc int ap_rwrite(const void *buf, int nbyte, request_rec *r)
*/
-API_EXPORT(int) ap_rwrite(const void *buf, int nbyte, request_rec *r);
+AP_DECLARE(int) ap_rwrite(const void *buf, int nbyte, request_rec *r);
/**
* Write an unspecified number of strings to the request
* @param r The current request
* @return The number of bytes sent
* @deffunc int ap_rvputs(request_rec *r, ...)
*/
-API_EXPORT_NONSTD(int) ap_rvputs(request_rec *r,...);
+AP_DECLARE_NONSTD(int) ap_rvputs(request_rec *r,...);
/**
* Output data to the client in a printf format
* @param r The current request
* @return The number of bytes sent
* @deffunc int ap_vrprintf(request_rec *r, const char *fmt, va_list vlist)
*/
-API_EXPORT(int) ap_vrprintf(request_rec *r, const char *fmt, va_list vlist);
+AP_DECLARE(int) ap_vrprintf(request_rec *r, const char *fmt, va_list vlist);
/**
* Output data to the client in a printf format
* @param r The current request
* @return The number of bytes sent
* @deffunc int ap_rprintf(request_rec *r, const char *fmt, ...)
*/
-API_EXPORT_NONSTD(int) ap_rprintf(request_rec *r, const char *fmt,...)
+AP_DECLARE_NONSTD(int) ap_rprintf(request_rec *r, const char *fmt,...)
__attribute__((format(printf,2,3)));
/**
* Flush all of the data for the current request to the client
* @return The number of bytes sent
* @deffunc int ap_rflush(request_rec *r)
*/
-API_EXPORT(int) ap_rflush(request_rec *r);
+AP_DECLARE(int) ap_rflush(request_rec *r);
/**
* Index used in custom_responses array for a specific error code
* @return The index of the response
* @deffunc int ap_index_of_response(int status)
*/
-API_EXPORT(int) ap_index_of_response(int status);
+AP_DECLARE(int) ap_index_of_response(int status);
/**
* Return the Status-Line for a given status code (excluding the
* @return The Status-Line
* @deffunc const char *ap_get_status_line(int status)
*/
-API_EXPORT(const char *) ap_get_status_line(int status);
+AP_DECLARE(const char *) ap_get_status_line(int status);
/* Reading a block of data from the client connection (e.g., POST arg) */
* @return either OK or an error code
* @deffunc int ap_setup_cleint_block(request_rec *r, int read_policy)
*/
-API_EXPORT(int) ap_setup_client_block(request_rec *r, int read_policy);
+AP_DECLARE(int) ap_setup_client_block(request_rec *r, int read_policy);
/**
* Determine if the client has sent any data. This also sends a
* 100 Continue resposne to HTTP/1.1 clients, so modules should not be called
* @return 0 if there is no message to read, 1 otherwise
* @deffunc int ap_should_client_block(request_rec *r)
*/
-API_EXPORT(int) ap_should_client_block(request_rec *r);
+AP_DECLARE(int) ap_should_client_block(request_rec *r);
/**
* Call this in a loop. It will put data into a buffer and return the length
* of the input block
* if EOF, or -1 if there was an error
* @deffunc long ap_get_client_block(request_rec *r, char *buffer, int bufsiz)
*/
-API_EXPORT(long) ap_get_client_block(request_rec *r, char *buffer, int bufsiz);
+AP_DECLARE(long) ap_get_client_block(request_rec *r, char *buffer, int bufsiz);
/**
* In HTTP/1.1, any method can have a body. However, most GET handlers
* wouldn't know what to do with a request body if they received one.
* @return error status if request is malformed, OK otherwise
* @deffunc int ap_discard_request_body(request_rec *r)
*/
-API_EXPORT(int) ap_discard_request_body(request_rec *r);
+AP_DECLARE(int) ap_discard_request_body(request_rec *r);
/* Sending a byterange */
* @return 1 if request was setup for byte range requests, 0 otherwise
* @deffunc int ap_set_byterange(request_rec *r)
*/
-API_EXPORT(int) ap_set_byterange(request_rec *r);
+AP_DECLARE(int) ap_set_byterange(request_rec *r);
/**
* Send one byte range chunk for a byte range request
* @param r The current request
* @param length Set to the length in should be after the chunk is sent
* @deffunc int ap_each_byterange(request_rec *r, apr_off_t *offset, apr_size_t *length)
*/
-API_EXPORT(int) ap_each_byterange(request_rec *r, apr_off_t *offset,
+AP_DECLARE(int) ap_each_byterange(request_rec *r, apr_off_t *offset,
apr_size_t *length);
/**
* Setup the output headers so that the client knows how to authenticate
* @param r The current request
* @deffunc void ap_note_auth_failure(request_rec *r)
*/
-API_EXPORT(void) ap_note_auth_failure(request_rec *r);
+AP_DECLARE(void) ap_note_auth_failure(request_rec *r);
/**
* Setup the output headers so that the client knows how to authenticate
* itself the next time, if an authentication request failed. This function
* @param r The current request
* @deffunc void ap_note_basic_auth_failure(request_rec *r)
*/
-API_EXPORT(void) ap_note_basic_auth_failure(request_rec *r);
+AP_DECLARE(void) ap_note_basic_auth_failure(request_rec *r);
/**
* Setup the output headers so that the client knows how to authenticate
* itself the next time, if an authentication request failed. This function
* @param r The current request
* @deffunc void ap_note_digest_auth_failure(request_rec *r)
*/
-API_EXPORT(void) ap_note_digest_auth_failure(request_rec *r);
+AP_DECLARE(void) ap_note_digest_auth_failure(request_rec *r);
/**
* Get the password from the request headers
* @param r The current request
* decline as well).
* @deffunc int ap_get_basic_auth_pw(request_rec *r, const char **pw)
*/
-API_EXPORT(int) ap_get_basic_auth_pw(request_rec *r, const char **pw);
+AP_DECLARE(int) ap_get_basic_auth_pw(request_rec *r, const char **pw);
/*
* Setting up the protocol fields for subsidiary requests...
* @param uri The uri to break apart
* @deffunc void ap_parse_uri(request_rec *r, const char *uri)
*/
-CORE_EXPORT(void) ap_parse_uri(request_rec *r, const char *uri);
+AP_CORE_DECLARE(void) ap_parse_uri(request_rec *r, const char *uri);
/**
* Get the method number associated with the given string, assumed to
* @return The method number
* @deffunc int ap_method_number_of(const char *method)
*/
-API_EXPORT(int) ap_method_number_of(const char *method);
+AP_DECLARE(int) ap_method_number_of(const char *method);
/**
* Get the method name associated with the given internal method
* @return The name corresponding to the method number
* @deffunc const char *ap_method_name_of(int methnum)
*/
-API_EXPORT(const char *) ap_method_name_of(int methnum);
+AP_DECLARE(const char *) ap_method_name_of(int methnum);
int http_filter(ap_filter_t *f, ap_bucket_brigade *b, apr_ssize_t length);
* @return The new request record
* @deffunc request_rec * ap_sub_req_lookup_uri(const char *new_file, const request_rec *r)
*/
-API_EXPORT(request_rec *) ap_sub_req_lookup_uri(const char *new_file,
+AP_DECLARE(request_rec *) ap_sub_req_lookup_uri(const char *new_file,
const request_rec *r);
/**
* Create a sub request for the given file. This sub request can be
* @return The new request record
* @deffunc request_rec * ap_sub_req_lookup_file(const char *new_file, const request_rec *r)
*/
-API_EXPORT(request_rec *) ap_sub_req_lookup_file(const char *new_file,
+AP_DECLARE(request_rec *) ap_sub_req_lookup_file(const char *new_file,
const request_rec *r);
/**
* Create a sub request for the given URI using a specific method. This
* @return The new request record
* @deffunc request_rec * ap_sub_req_method_uri(const char *method, const char *new_file, const request_rec *r)
*/
-API_EXPORT(request_rec *) ap_sub_req_method_uri(const char *method,
+AP_DECLARE(request_rec *) ap_sub_req_method_uri(const char *method,
const char *new_file,
const request_rec *r);
* @return The return code for the sub request
* @deffunc int ap_run_sub_req(request_rec *r)
*/
-API_EXPORT(int) ap_run_sub_req(request_rec *r);
+AP_DECLARE(int) ap_run_sub_req(request_rec *r);
/**
* Free the memory associated with a sub request
* @param r The sub request to finish
* @deffunc void ap_destroy_sub_req(request_rec *r)
*/
-API_EXPORT(void) ap_destroy_sub_req(request_rec *r);
+AP_DECLARE(void) ap_destroy_sub_req(request_rec *r);
/*
* Then there's the case that you want some other request to be served
* @param r The current request
* @deffunc void ap_internal_redirect(const char *new_uri, request_rec *r)
*/
-API_EXPORT(void) ap_internal_redirect(const char *new_uri, request_rec *r);
+AP_DECLARE(void) ap_internal_redirect(const char *new_uri, request_rec *r);
/**
* This function is designed for things like actions or CGI scripts, when
* @param r The current request
* @deffunc void ap_internal_redirect_handler(const char *new_uri, request_rec *r)
*/
-API_EXPORT(void) ap_internal_redirect_handler(const char *new_uri, request_rec *r);
+AP_DECLARE(void) ap_internal_redirect_handler(const char *new_uri, request_rec *r);
/**
* Can be used within any handler to determine if any authentication
* @return 1 if authentication is required, 0 otherwise
* @deffunc int ap_some_auth_required(request_rec *r)
*/
-API_EXPORT(int) ap_some_auth_required(request_rec *r);
+AP_DECLARE(int) ap_some_auth_required(request_rec *r);
/**
* Determine if the current request is the main request or a sub requests
* @retrn 1 if this is a main request, 0 otherwise
* @deffunc int ap_is_initial_req(request_rec *r)
*/
-API_EXPORT(int) ap_is_initial_req(request_rec *r);
+AP_DECLARE(int) ap_is_initial_req(request_rec *r);
/**
* Function to set the r->mtime field to the specified value if it's later
* @param dependency_time Time to set the mtime to
* @deffunc void ap_update_mtime(request_rec *r, apr_time_t dependency_mtime)
*/
-API_EXPORT(void) ap_update_mtime(request_rec *r, apr_time_t dependency_mtime);
+AP_DECLARE(void) ap_update_mtime(request_rec *r, apr_time_t dependency_mtime);
/**
* Add one or more methods to the list permitted to access the resource.
* @return None.
* @deffunc void ap_allow_methods(request_rec *r, int reset, ...)
*/
-API_EXPORT(void) ap_allow_methods(request_rec *r, int reset, ...);
+AP_DECLARE(void) ap_allow_methods(request_rec *r, int reset, ...);
#define MERGE_ALLOW 0
#define REPLACE_ALLOW 1
* @param r The current request
* @deffunc void ap_die(int type, request_rec *r)
*/
-API_EXPORT(void) ap_die(int type, request_rec *r);
+AP_DECLARE(void) ap_die(int type, request_rec *r);
#endif
/* Hooks */
* return 0 otherwise
* @deffunc int ap_matches_request_vhost(request_rec *r, const char *host, unsigned port)
*/
-API_EXPORT(int) ap_matches_request_vhost(request_rec *r, const char *host,
+AP_DECLARE(int) ap_matches_request_vhost(request_rec *r, const char *host,
unsigned port);
#ifdef __cplusplus
* @return The server version string
* @deffunc const char *ap_get_server_version(void)
*/
-API_EXPORT(const char *) ap_get_server_version(void);
+AP_DECLARE(const char *) ap_get_server_version(void);
/**
* Add a component to the version string
* @param component The string to add
* @deffunc void ap_add_version_component(apr_pool_t *pconf, const char *component)
*/
-API_EXPORT(void) ap_add_version_component(apr_pool_t *pconf, const char *component);
+AP_DECLARE(void) ap_add_version_component(apr_pool_t *pconf, const char *component);
/**
* Get the date a time that the server was built
* @return The server build time string
*/
-API_EXPORT(const char *) ap_get_server_built(void);
+AP_DECLARE(const char *) ap_get_server_built(void);
/* Numeric release version identifier: MMNNFFRBB: major minor fix final beta
* Always increases along the same track as the source branch.
int limit_req_fields;
};
-/* stuff marked API_EXPORT is part of the API, and intended for use
+/* stuff marked AP_DECLARE is part of the API, and intended for use
* by modules
*/
-#ifndef API_EXPORT
-#define API_EXPORT(type) type
+#ifndef AP_DECLARE
+#define AP_DECLARE(type) type
#endif
-/* Stuff marked API_EXPORT_NONSTD is part of the API, and intended for
- * use by modules. The difference between API_EXPORT and
- * API_EXPORT_NONSTD is that the latter is required for any functions
+/* Stuff marked AP_DECLARE_NONSTD is part of the API, and intended for
+ * use by modules. The difference between AP_DECLARE and
+ * AP_DECLARE_NONSTD is that the latter is required for any functions
* which use varargs or are used via indirect function call. This
* is to accomodate the two calling conventions in windows dlls.
*/
-#ifndef API_EXPORT_NONSTD
-#define API_EXPORT_NONSTD(type) type
+#ifndef AP_DECLARE_NONSTD
+#define AP_DECLARE_NONSTD(type) type
#endif
-#ifndef MODULE_VAR_EXPORT
-#define MODULE_VAR_EXPORT
+#ifndef AP_MODULE_DECLARE_DATA
+#define AP_MODULE_DECLARE_DATA
#endif
-#ifndef API_VAR_EXPORT
-#define API_VAR_EXPORT
+#ifndef AP_DECLARE_DATA
+#define AP_DECLARE_DATA
#endif
-/* modules should not used functions marked CORE_EXPORT
- * or CORE_EXPORT_NONSTD */
-#ifndef CORE_EXPORT
-#define CORE_EXPORT API_EXPORT
+/* modules should not used functions marked AP_CORE_DECLARE
+ * or AP_CORE_DECLARE_NONSTD */
+#ifndef AP_CORE_DECLARE
+#define AP_CORE_DECLARE AP_DECLARE
#endif
-#ifndef CORE_EXPORT_NONSTD
-#define CORE_EXPORT_NONSTD API_EXPORT_NONSTD
+#ifndef AP_CORE_DECLARE_NONSTD
+#define AP_CORE_DECLARE_NONSTD AP_DECLARE_NONSTD
#endif
/* On Mac OS X Server, symbols that conflict with loaded dylibs
* @return the field minus any parameters
* @deffunc char *ap_field_noparam(apr_pool_t *p, const char *intype);
*/
-API_EXPORT(char *) ap_field_noparam(apr_pool_t *p, const char *intype);
+AP_DECLARE(char *) ap_field_noparam(apr_pool_t *p, const char *intype);
/**
* Convert a time from an integer into a string in a specified format
* @return The string that represents the specified time
* @deffunc char *ap_ht_time(apr_pool_t *p, apr_time_t t, const char *fmt, int gmt)
*/
-API_EXPORT(char *) ap_ht_time(apr_pool_t *p, apr_time_t t, const char *fmt, int gmt);
+AP_DECLARE(char *) ap_ht_time(apr_pool_t *p, apr_time_t t, const char *fmt, int gmt);
/* String handling. The *_nc variants allow you to use non-const char **s as
arguments (unfortunately C won't automatically convert a char ** to a const
* @return A copy of the characters up to the first stop character
* @deffunc char *ap_getword(apr_pool_t *p, const char **line, char stop);
*/
-API_EXPORT(char *) ap_getword(apr_pool_t *p, const char **line, char stop);
+AP_DECLARE(char *) ap_getword(apr_pool_t *p, const char **line, char stop);
/**
* Get the characters until the first occurance of a specified character
* @param p The pool to allocate memory out of
* @tip This is the same as ap_getword, except it doesn't use const char **.
* @deffunc char *ap_getword_nc(apr_pool_t *p, char **line, char stop);
*/
-API_EXPORT(char *) ap_getword_nc(apr_pool_t *p, char **line, char stop);
+AP_DECLARE(char *) ap_getword_nc(apr_pool_t *p, char **line, char stop);
/**
* Get the first word from a given string. A word is defined as all characters
* @retrn The first word in the line
* @deffunc char *ap_getword_white(apr_pool_t *p, const char **line)
*/
-API_EXPORT(char *) ap_getword_white(apr_pool_t *p, const char **line);
+AP_DECLARE(char *) ap_getword_white(apr_pool_t *p, const char **line);
/**
* Get the first word from a given string. A word is defined as all characters
* up to the first whitespace.
* @tip The same as ap_getword_white, except it doesn't use const char **.
* @deffunc char *ap_getword_white_nc(apr_pool_t *p, const char **line)
*/
-API_EXPORT(char *) ap_getword_white_nc(apr_pool_t *p, char **line);
+AP_DECLARE(char *) ap_getword_white_nc(apr_pool_t *p, char **line);
/**
* Get all characters from the first occurance of stop to the first '\0'
* character
* @deffunc char *ap_getword_nulls(apr_pool_t *p, const char **line, char stop)
*/
-API_EXPORT(char *) ap_getword_nulls(apr_pool_t *p, const char **line, char stop);
+AP_DECLARE(char *) ap_getword_nulls(apr_pool_t *p, const char **line, char stop);
/**
* Get all characters from the first occurance of stop to the first '\0'
* @param p The pool to allocate memory out of
* @tip The same as ap_getword_nulls, except it doesn't use const char **.
* @deffunc char *ap_getword_nulls_nc(apr_pool_t *p, char **line, char stop)
*/
-API_EXPORT(char *) ap_getword_nulls_nc(apr_pool_t *p, char **line, char stop);
+AP_DECLARE(char *) ap_getword_nulls_nc(apr_pool_t *p, char **line, char stop);
/**
* Get the second word in the string paying attention to quoting
* @return A copy of the string
* @deffunc char *ap_getword_conf(apr_pool_t *p, const char **line)
*/
-API_EXPORT(char *) ap_getword_conf(apr_pool_t *p, const char **line);
+AP_DECLARE(char *) ap_getword_conf(apr_pool_t *p, const char **line);
/**
* Get the second word in the string paying attention to quoting
* @param p The pool to allocate out of
* @tip The same as ap_getword_conf, except it doesn't use const char **.
* @deffunc char *ap_getword_conf_nc(apr_pool_t *p, char **line)
*/
-API_EXPORT(char *) ap_getword_conf_nc(apr_pool_t *p, char **line);
+AP_DECLARE(char *) ap_getword_conf_nc(apr_pool_t *p, char **line);
/**
* Check a string for any ${ENV} environment variable construct and replace
* @return The string with the replaced environment variables
* @deffunc const char *ap_resolve_env(apr_pool_t *p, const char *word)
*/
-API_EXPORT(const char *) ap_resolve_env(apr_pool_t *p, const char * word);
+AP_DECLARE(const char *) ap_resolve_env(apr_pool_t *p, const char * word);
/**
* Size an HTTP header field list item, as separated by a comma.
* character. len is the length of the item excluding any beginning whitespace.
* @deffunc const char *ap_size_list_item(const char **field, int *len)
*/
-API_EXPORT(const char *) ap_size_list_item(const char **field, int *len);
+AP_DECLARE(const char *) ap_size_list_item(const char **field, int *len);
/**
* Retrieve an HTTP header field list item, as separated by a comma,
* shifted to the next non-comma, non-whitespace.
* @deffunc char *ap_get_list_item(apr_pool_t *p, const char **field)
*/
-API_EXPORT(char *) ap_get_list_item(apr_pool_t *p, const char **field);
+AP_DECLARE(char *) ap_get_list_item(apr_pool_t *p, const char **field);
/**
* Find an item in canonical form (lowercase, no extra spaces) within
* @return 1 if found, 0 if not found.
* @deffunc int ap_find_list_item(apr_pool_t *p, const char *line, const char *tok)
*/
-API_EXPORT(int) ap_find_list_item(apr_pool_t *p, const char *line, const char *tok);
+AP_DECLARE(int) ap_find_list_item(apr_pool_t *p, const char *line, const char *tok);
/**
* Retrieve a token, spacing over it and returning a pointer to
* @return the first non-white byte after the token
* @deffunc char *ap_get_token(apr_pool_t *p, const char **accept_line, int accept_white)
*/
-API_EXPORT(char *) ap_get_token(apr_pool_t *p, const char **accept_line, int accept_white);
+AP_DECLARE(char *) ap_get_token(apr_pool_t *p, const char **accept_line, int accept_white);
/**
* find http tokens, see the definition of token from RFC2068
* @return 1 if the token is found, 0 otherwise
* @deffunc int ap_find_token(apr_pool_t *p, const char *line, const char *tok)
*/
-API_EXPORT(int) ap_find_token(apr_pool_t *p, const char *line, const char *tok);
+AP_DECLARE(int) ap_find_token(apr_pool_t *p, const char *line, const char *tok);
/**
* find http tokens from the end of the line
* @return 1 if the token is found, 0 otherwise
* @deffunc int ap_find_last_token(apr_pool_t *p, const char *line, const char *tok)
*/
-API_EXPORT(int) ap_find_last_token(apr_pool_t *p, const char *line, const char *tok);
+AP_DECLARE(int) ap_find_last_token(apr_pool_t *p, const char *line, const char *tok);
/**
* Check for an Absolute URI syntax
* @return 1 if URI, 0 otherwise
* @deffunc int ap_is_url(const char *u)
*/
-API_EXPORT(int) ap_is_url(const char *u);
+AP_DECLARE(int) ap_is_url(const char *u);
/**
* Unescape a URL
* @return 0 on success, non-zero otherwise
* @deffunc int ap_unescape_url(char *url)
*/
-API_EXPORT(int) ap_unescape_url(char *url);
+AP_DECLARE(int) ap_unescape_url(char *url);
/**
* Remove all double slashes from a string
* @param name The string to parse
* @deffunc void ap_no2slash(char *name)
*/
-API_EXPORT(void) ap_no2slash(char *name);
+AP_DECLARE(void) ap_no2slash(char *name);
/**
* Remove all ./ and ../ substrings from a file name
* @param name the file name to parse
* @deffunc void ap_getparents(char *name)
*/
-API_EXPORT(void) ap_getparents(char *name);
+AP_DECLARE(void) ap_getparents(char *name);
/**
* Escape a path segment, as defined in RFC 1808
* @return The converted URL
* @deffunc char *ap_escape_path_segment(apr_pool_t *p, const char *s)
*/
-API_EXPORT(char *) ap_escape_path_segment(apr_pool_t *p, const char *s);
+AP_DECLARE(char *) ap_escape_path_segment(apr_pool_t *p, const char *s);
/**
* convert an OS path to a URL in an OS dependant way.
* @param p The pool to allocate out of
* @return The converted URL
* @deffunc char *ap_os_escape_path(apr_pool_t *p, const char *path, int partial)
*/
-API_EXPORT(char *) ap_os_escape_path(apr_pool_t *p, const char *path, int partial);
+AP_DECLARE(char *) ap_os_escape_path(apr_pool_t *p, const char *path, int partial);
#define ap_escape_uri(ppool,path) ap_os_escape_path(ppool,path,1)
/**
* @return The escaped string
* @deffunc char *ap_escape_html(apr_pool_t *p, const char *s)
*/
-API_EXPORT(char *) ap_escape_html(apr_pool_t *p, const char *s);
+AP_DECLARE(char *) ap_escape_html(apr_pool_t *p, const char *s);
/**
* Construct a full hostname
* @return The server's hostname
* @deffunc char *ap_construct_server(apr_pool_t *p, const char *hostname, unsiged port, const request_rec *r)
*/
-API_EXPORT(char *) ap_construct_server(apr_pool_t *p, const char *hostname,
+AP_DECLARE(char *) ap_construct_server(apr_pool_t *p, const char *hostname,
unsigned port, const request_rec *r);
/**
* Escape a shell command
* @return The escaped hostname
* @deffunc char *ap_escape_shell_cmd(apr_pool_t *p, const char *s)
*/
-API_EXPORT(char *) ap_escape_shell_cmd(apr_pool_t *p, const char *s);
+AP_DECLARE(char *) ap_escape_shell_cmd(apr_pool_t *p, const char *s);
/**
* Count the number of directories in a path
* @return The number of directories
* @deffunc int ap_count_dirs(const char *path)
*/
-API_EXPORT(int) ap_count_dirs(const char *path);
+AP_DECLARE(int) ap_count_dirs(const char *path);
/**
* Copy at most n leading directories of s into d d should be at least as
* large as s plus 1 extra byte
* whereas n = 1 returns the "d:/" root. On all other platforms, n = 0
* returns the empty string.
*/
-API_EXPORT(char *) ap_make_dirstr_prefix(char *d, const char *s, int n);
+AP_DECLARE(char *) ap_make_dirstr_prefix(char *d, const char *s, int n);
/**
* return the parent directory name including trailing / of the file s
* @param p The pool to allocate out of
* @return A copy of the file's parent directory
* @deffunc char *ap_make_dirstr_parent(apr_pool_t *p, const char *s)
*/
-API_EXPORT(char *) ap_make_dirstr_parent(apr_pool_t *p, const char *s);
+AP_DECLARE(char *) ap_make_dirstr_parent(apr_pool_t *p, const char *s);
/**
* Given a directory and filename, create a single path out of them. This
* @return A copy of the full path
* @deffunc char *ap_make_full_path(apr_pool_t *a, const char *dir, const char *f)
*/
-API_EXPORT(char *) ap_make_full_path(apr_pool_t *a, const char *dir, const char *f);
+AP_DECLARE(char *) ap_make_full_path(apr_pool_t *a, const char *dir, const char *f);
/**
* Does the provided string contain wildcard characters? This is useful
* @return 1 if the string has wildcards, 0 otherwise
* @deffunc int ap_is_matchexp(const char *str)
*/
-API_EXPORT(int) ap_is_matchexp(const char *str);
+AP_DECLARE(int) ap_is_matchexp(const char *str);
/**
* Determine if a string matches a patterm containing the wildcards '?' or '*'
* @return 1 if the two strings match, 0 otherwise
* @deffunc int ap_strcmp_match(const char *str, const char *exp)
*/
-API_EXPORT(int) ap_strcmp_match(const char *str, const char *exp);
+AP_DECLARE(int) ap_strcmp_match(const char *str, const char *exp);
/**
* Determine if a string matches a patterm containing the wildcards '?' or '*',
* ignoring case
* @return 1 if the two strings match, 0 otherwise
* @deffunc int ap_strcasecmp_match(const char *str, const char *exp)
*/
-API_EXPORT(int) ap_strcasecmp_match(const char *str, const char *exp);
+AP_DECLARE(int) ap_strcasecmp_match(const char *str, const char *exp);
/**
* Find the first occurrence of the substring s2 in s1, regardless of case
* @return A pointer to the beginning of the substring
* @deffunc char *ap_strcasestr(const char *s1, const char *s2)
*/
-API_EXPORT(char *) ap_strcasestr(const char *s1, const char *s2);
+AP_DECLARE(char *) ap_strcasestr(const char *s1, const char *s2);
/**
* Return a pointer to the location inside of bigstring immediately after prefix
* @return A pointer relative to bigstring after prefix
* deffunc char *ap_stripprefix(const char *bigstring, const char *prefix);
*/
-API_EXPORT(char *) ap_stripprefix(const char *bigstring, const char *prefix);
+AP_DECLARE(char *) ap_stripprefix(const char *bigstring, const char *prefix);
/**
* Decode a base64 encoded string into memory allocated out of a pool
* @return The decoded string
* @deffunc char *ap_pbase64decode(apr_pool_t *p, const char *bufcoded)
*/
-API_EXPORT(char *) ap_pbase64decode(apr_pool_t *p, const char *bufcoded);
+AP_DECLARE(char *) ap_pbase64decode(apr_pool_t *p, const char *bufcoded);
/**
* Encode a string into memory allocated out of a pool in base 64 format
* @return The encoded string
* @deffunc char *ap_pbase64encode(apr_pool_t *p, char *string)
*/
-API_EXPORT(char *) ap_pbase64encode(apr_pool_t *p, char *string);
+AP_DECLARE(char *) ap_pbase64encode(apr_pool_t *p, char *string);
#include "pcreposix.h"
* @return The compiled regular expression
* @deffunc regex_t *ap_pregcomp(apr_pool_t *p, const char *pattern, int cflags)
*/
-API_EXPORT(regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,
+AP_DECLARE(regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,
int cflags);
/**
* Free the memory associated with a compiled regular expression
* @param reg The regular expression to free
* @deffunc void ap_pregfree(apr_pool_t *p, regex_t *reg)
*/
-API_EXPORT(void) ap_pregfree(apr_pool_t *p, regex_t *reg);
+AP_DECLARE(void) ap_pregfree(apr_pool_t *p, regex_t *reg);
/**
* Match a null-terminated string against a pre-compiled regex.
* @return 0 for successful match, REG_NOMATCH otherwise
* @deffunc int ap_regexec(regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags)
*/
-API_EXPORT(int) ap_regexec(regex_t *preg, const char *string,
+AP_DECLARE(int) ap_regexec(regex_t *preg, const char *string,
size_t nmatch, regmatch_t pmatch[], int eflags);
/**
* @param errbuf_size The size of the buffer
* @deffunc size_t ap_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
*/
-API_EXPORT(size_t) ap_regerror(int errcode, const regex_t *preg,
+AP_DECLARE(size_t) ap_regerror(int errcode, const regex_t *preg,
char *errbuf, size_t errbuf_size);
/**
* @param pmatch the pmatch array returned from ap_pregex
* @deffunc char *ap_pregsub(apr_pool_t *p, const char *input, const char *source, size_t nmatch, regmatch_t pmatch[])
*/
-API_EXPORT(char *) ap_pregsub(apr_pool_t *p, const char *input, const char *source,
+AP_DECLARE(char *) ap_pregsub(apr_pool_t *p, const char *input, const char *source,
size_t nmatch, regmatch_t pmatch[]);
/**
* @param s The content-type to convert to lowercase
* @deffunc void ap_content_type_tolower(char *s)
*/
-API_EXPORT(void) ap_content_type_tolower(char *s);
+AP_DECLARE(void) ap_content_type_tolower(char *s);
/**
* convert a string to all lowercase
* @param s The string to convert to lowercase
* @deffunc void ap_str_tolower(char *s)
*/
-API_EXPORT(void) ap_str_tolower(char *s);
+AP_DECLARE(void) ap_str_tolower(char *s);
/**
* Search a string from left to right for the first occurrence of a
* @return The index of the first occurrence of c in str
* @deffunc int ap_ind(const char *str, char c)
*/
-API_EXPORT(int) ap_ind(const char *str, char c); /* Sigh... */
+AP_DECLARE(int) ap_ind(const char *str, char c); /* Sigh... */
/**
* Search a string from right to left for the first occurrence of a
* @return The index of the first occurrence of c in str
* @deffunc int ap_rind(const char *str, char c)
*/
-API_EXPORT(int) ap_rind(const char *str, char c);
+AP_DECLARE(int) ap_rind(const char *str, char c);
/**
* Given a string, replace any bare " with \" .
* @return A copy of the string with escaped quotes
* @deffunc char * ap_escape_quotes(apr_pool_t *p, const char *instring)
*/
-API_EXPORT(char *) ap_escape_quotes(apr_pool_t *p, const char *instring);
+AP_DECLARE(char *) ap_escape_quotes(apr_pool_t *p, const char *instring);
/* Misc system hackery */
/**
* @return The user id corresponding to a name
* @deffunc uid_t ap_uname2id(const char *name)
*/
-API_EXPORT(uid_t) ap_uname2id(const char *name);
+AP_DECLARE(uid_t) ap_uname2id(const char *name);
/**
* Convert a group name to a numeric ID
* @param name The name to convert
* @return The group id corresponding to a name
* @deffunc gid_t ap_gname2id(const char *name)
*/
-API_EXPORT(gid_t) ap_gname2id(const char *name);
+AP_DECLARE(gid_t) ap_gname2id(const char *name);
/**
* Given the name of an object in the file system determine if it is a directory
* @param name The name of the object to check
* @return 1 if it is a directory, 0 otherwise
* @deffunc int ap_is_rdirectory(const char *name)
*/
-API_EXPORT(int) ap_is_rdirectory(const char *name);
+AP_DECLARE(int) ap_is_rdirectory(const char *name);
/**
* Given the name of an object in the file system determine if it is a directory - this version is symlink aware
* @param name The name of the object to check
* @return 1 if it is a directory, 0 otherwise
* @deffunc int ap_is_directory(const char *name)
*/
-API_EXPORT(int) ap_is_directory(const char *name);
+AP_DECLARE(int) ap_is_directory(const char *name);
/**
* Given a pathname in file, extract the directory and chdir to that directory
* @param file The file who's directory we wish to switch to
* @deffunc void ap_chdir_file(const char *file)
*/
-API_EXPORT(void) ap_chdir_file(const char *file);
+AP_DECLARE(void) ap_chdir_file(const char *file);
/**
* Get the maximum number of daemons processes for this version of Apache
* @return The maximum number of daemon processes
* @deffunc int ap_get_max_daemons(void)
*/
-API_EXPORT(int) ap_get_max_daemons(void);
+AP_DECLARE(int) ap_get_max_daemons(void);
#ifdef _OSD_POSIX
extern const char *os_set_account(apr_pool_t *p, const char *account);
* @param nLine The line the assertion is defined on
* @deffunc void ap_log_assert(const char *szExp, const char *szFile, int nLine)
*/
-API_EXPORT(void) ap_log_assert(const char *szExp, const char *szFile, int nLine)
+AP_DECLARE(void) ap_log_assert(const char *szExp, const char *szFile, int nLine)
__attribute__((noreturn));
#define ap_assert(exp) ((exp) ? (void)0 : ap_log_assert(#exp,__FILE__,__LINE__))
#define RAISE_SIGSTOP(x)
#endif
-API_EXPORT(extern const char *) ap_psignature(const char *prefix, request_rec *r);
+AP_DECLARE(extern const char *) ap_psignature(const char *prefix, request_rec *r);
/* strtoul does not exist on sunos4. */
#ifdef strtoul
* for the connection.
* @deffunc const char *ap_get_connection_status(long conn_id, const char *key)
*/
-API_EXPORT(const char *) ap_get_connection_status(long conn_id, const char *key);
+AP_DECLARE(const char *) ap_get_connection_status(long conn_id, const char *key);
/**
* Get an array of current connection IDs.
* @return An array of all the current connection IDs
* @deffunc apr_array_header_t *ap_get_connections(apr_pool_t *p)
*/
-API_EXPORT(apr_array_header_t *) ap_get_connections(apr_pool_t *p);
+AP_DECLARE(apr_array_header_t *) ap_get_connections(apr_pool_t *p);
/**
* Get an array of keys from a given connection.
* @return an array of keys from a given connection
* @deffunc apr_array_header_t *ap_get_connection_keys(apr_pool_t *p, long conn_id)
*/
-API_EXPORT(apr_array_header_t *) ap_get_connection_keys(apr_pool_t *p,
+AP_DECLARE(apr_array_header_t *) ap_get_connection_keys(apr_pool_t *p,
long conn_id);
/**
* @param value value to set for the key
* @deffunc void ap_update_connection_status(long conn_id, const char *key, const char *value)
*/
-API_EXPORT(void) ap_update_connection_status(long conn_id, const char *key, const char *value);
+AP_DECLARE(void) ap_update_connection_status(long conn_id, const char *key, const char *value);
/**
* Clear out this connection's status values. Normally called when a
* @param conn_id The connection ID to clear
* @deffunc void ap_reset_connection_status(long conn_id)
*/
-API_EXPORT(void) ap_reset_connection_status(long conn_id);
+AP_DECLARE(void) ap_reset_connection_status(long conn_id);
/**
* Returns the most up-to-date status table available, in the form of an array
* @return The table of statuses for all connections
* @deffunc apr_array_header_t *ap_get_status_table(apr_pool_t *p)
*/
-API_EXPORT(apr_array_header_t *) ap_get_status_table(apr_pool_t *p);
+AP_DECLARE(apr_array_header_t *) ap_get_status_table(apr_pool_t *p);
#endif /* APACHE_SERVER_STATS_H */
* @param The translation handle to use for the actual work
* @deffunc apr_status_t ap_set_content_xlate(request_rec *r, int output, apr_xlate_t *xlate)
*/
-API_EXPORT(apr_status_t) ap_set_content_xlate(request_rec *r, int output,
+AP_DECLARE(apr_status_t) ap_set_content_xlate(request_rec *r, int output,
apr_xlate_t *xlate);
#ifdef __cplusplus
* @return 1 if the string matches, 0 otherwise
* @deffunc int ap_checkmask(const char *data, const char *mask)
*/
-API_EXPORT(int) ap_checkmask(const char *data, const char *mask);
+AP_DECLARE(int) ap_checkmask(const char *data, const char *mask);
/**
* Parses an HTTP date in one of three standard forms:
* 0 if this would be out of range or if the date is invalid.
* @deffunc apr_time_t ap_parseHTTPdate(const char *date)
*/
-API_EXPORT(apr_time_t) ap_parseHTTPdate(const char *date);
+AP_DECLARE(apr_time_t) ap_parseHTTPdate(const char *date);
#ifdef __cplusplus
}
* @return apr_status_t value
* @deffunc apr_status_t ap_get_brigade(ap_filter_t *filter, ap_bucket_brigade *bucket, apr_ssize_t length)
*/
-API_EXPORT(apr_status_t) ap_get_brigade(ap_filter_t *filter, ap_bucket_brigade *bucket, apr_ssize_t length);
+AP_DECLARE(apr_status_t) ap_get_brigade(ap_filter_t *filter, ap_bucket_brigade *bucket, apr_ssize_t length);
/**
* Pass the current bucket brigade down to the next filter on the filter
* @return apr_status_t value
* @deffunc apr_status_t ap_pass_brigade(ap_filter_t *filter, ap_bucket_brigade *bucket)
*/
-API_EXPORT(apr_status_t) ap_pass_brigade(ap_filter_t *filter, ap_bucket_brigade *bucket);
+AP_DECLARE(apr_status_t) ap_pass_brigade(ap_filter_t *filter, ap_bucket_brigade *bucket);
/*
* ap_register_input_filter():
* @param The type of filter function, either AP_FTYPE_CONTENT or AP_FTYPE_CONNECTION
* @deffunc void ap_register_input_filter(const char *name, ap_in_filter_func filter_func, ap_filter_type ftype)
*/
-API_EXPORT(void) ap_register_input_filter(const char *name,
+AP_DECLARE(void) ap_register_input_filter(const char *name,
ap_in_filter_func filter_func,
ap_filter_type ftype);
/*
* @param The type of filter function, either AP_FTYPE_CONTENT or AP_FTYPE_CONNECTION
* @deffunc void ap_register_output_filter(const char *name, ap_out_filter_func filter_func, ap_filter_type ftype)
*/
-API_EXPORT(void) ap_register_output_filter(const char *name,
+AP_DECLARE(void) ap_register_output_filter(const char *name,
ap_out_filter_func filter_func,
ap_filter_type ftype);
* @param c The connection to add the fillter for
* @deffunc void ap_add_input_filter(const char *name, void *ctx, request_rec *r, conn_rec *c)
*/
-API_EXPORT(void) ap_add_input_filter(const char *name, void *ctx, request_rec *r, conn_rec *c);
+AP_DECLARE(void) ap_add_input_filter(const char *name, void *ctx, request_rec *r, conn_rec *c);
/**
* Add a filter to the current request. Filters are added in a FIFO manner.
* @param c The connection to add this filter for
* @deffunc void ap_add_output_filter(const char *name, void *ctx, request_rec *r, conn_rec *c)
*/
-API_EXPORT(void) ap_add_output_filter(const char *name, void *ctx,
+AP_DECLARE(void) ap_add_output_filter(const char *name, void *ctx,
request_rec *r, conn_rec *c);
/* The next two filters are for abstraction purposes only. They could be
* on return
* @deffunc void ap_save_brigade(ap_filter_t *f, ap_bucket_brigade **save_to, ap_bucket_brigade **b)
*/
-API_EXPORT(void) ap_save_brigade(ap_filter_t *f, ap_bucket_brigade **save_to,
+AP_DECLARE(void) ap_save_brigade(ap_filter_t *f, ap_bucket_brigade **save_to,
ap_bucket_brigade **b);
#ifdef __cplusplus
* @return The checksum
* @deffunc char *ap_md5(apr_pool_t *a, const unsigned char *string)
*/
-API_EXPORT(char *) ap_md5(apr_pool_t *a, const unsigned char *string);
+AP_DECLARE(char *) ap_md5(apr_pool_t *a, const unsigned char *string);
/**
* Create an MD5 checksum of a string of binary data
* @return The checksum
* @deffunc char *ap_md5_binary(apr_pool_t *a, const unsigned char *buf, int len)
*/
-API_EXPORT(char *) ap_md5_binary(apr_pool_t *a, const unsigned char *buf, int len);
+AP_DECLARE(char *) ap_md5_binary(apr_pool_t *a, const unsigned char *buf, int len);
/**
* Convert an MD5 checksum into a base64 encoding
* @return The converted encoding
* @deffunc char *ap_md5contextTo64(apr_pool_t *p, apr_md5_ctx_t *context)
*/
-API_EXPORT(char *) ap_md5contextTo64(apr_pool_t *p, apr_md5_ctx_t *context);
+AP_DECLARE(char *) ap_md5contextTo64(apr_pool_t *p, apr_md5_ctx_t *context);
#ifdef APACHE_XLATE
/**
* @warning The xlate parameter is only available if APACHE_XLATE is defined
* @deffunc char *ap_md5digest(apr_pool_t *p, apr_file_t *infile, apr_xlate_t *xlate)
*/
-API_EXPORT(char *) ap_md5digest(apr_pool_t *p, apr_file_t *infile,
+AP_DECLARE(char *) ap_md5digest(apr_pool_t *p, apr_file_t *infile,
apr_xlate_t *xlate);
#else
-API_EXPORT(char *) ap_md5digest(apr_pool_t *p, apr_file_t *infile);
+AP_DECLARE(char *) ap_md5digest(apr_pool_t *p, apr_file_t *infile);
#endif
#ifdef __cplusplus
* use with an exec call.
* @deffunc char **ap_create_environment(apr_pool_t *p, apr_table_t *t)
*/
-API_EXPORT(char **) ap_create_environment(apr_pool_t *p, apr_table_t *t);
+AP_DECLARE(char **) ap_create_environment(apr_pool_t *p, apr_table_t *t);
/**
* This "cute" little function comes about because the path info on
* @return The length of the path info
* @deffunc int ap_fine_path_info(const char *uri, const char *path_info)
*/
-API_EXPORT(int) ap_find_path_info(const char *uri, const char *path_info);
+AP_DECLARE(int) ap_find_path_info(const char *uri, const char *path_info);
/**
* Add CGI environment variables required by HTTP/1.1 to the request's
* @param r the current request
* @deffunc void ap_add_cgi_vars(request_rec *r)
*/
-API_EXPORT(void) ap_add_cgi_vars(request_rec *r);
+AP_DECLARE(void) ap_add_cgi_vars(request_rec *r);
/**
* Add common CGI environment variables to the requests environment table
* @param r The current request
* @deffunc void ap_add_common_vars(request_rec *r)
*/
-API_EXPORT(void) ap_add_common_vars(request_rec *r);
+AP_DECLARE(void) ap_add_common_vars(request_rec *r);
/**
* Read headers output from a script, ensuring that the output is valid. If
* @return HTTP_OK on success, HTTP_INTERNAL_SERVER_ERROR otherwise
* @deffunc int ap_scan_script_header_err(request_rec *r, apr_file_t *f, char *buffer)
*/
-API_EXPORT(int) ap_scan_script_header_err(request_rec *r, apr_file_t *f, char *buffer);
+AP_DECLARE(int) ap_scan_script_header_err(request_rec *r, apr_file_t *f, char *buffer);
/**
* Read headers strings from a script, ensuring that the output is valid. If
* @return HTTP_OK on success, HTTP_INTERNAL_SERVER_ERROR otherwise
* @deffunc int ap_scan_script_header_err_core(request_rec *r, char *buffer, int (*getsfunc)(char *, int, void *), void *getsfunc_data)
*/
-API_EXPORT_NONSTD(int) ap_scan_script_header_err_strs(request_rec *r,
+AP_DECLARE_NONSTD(int) ap_scan_script_header_err_strs(request_rec *r,
char *buffer,
const char **termch,
int *termarg, ...);
* @return HTTP_OK on success, HTTP_INTERNAL_SERVER_ERROR otherwise
* @deffunc int ap_scan_script_header_err_core(request_rec *r, char *buffer, int (*getsfunc)(char *, int, void *), void *getsfunc_data)
*/
-API_EXPORT(int) ap_scan_script_header_err_core(request_rec *r, char *buffer,
+AP_DECLARE(int) ap_scan_script_header_err_core(request_rec *r, char *buffer,
int (*getsfunc) (char *, int, void *),
void *getsfunc_data);
* @param r The currnt request
* @deffunc void ap_send_size(apr_ssize_t size, request_rec *r)
*/
-API_EXPORT(void) ap_send_size(apr_ssize_t size, request_rec *r);
+AP_DECLARE(void) ap_send_size(apr_ssize_t size, request_rec *r);
#ifdef __cplusplus
}
* @return The default port for this scheme
* @deffunc unsigned short ap_default_port_for_scheme(const char *scheme_str)
*/
-API_EXPORT(unsigned short) ap_default_port_for_scheme(const char *scheme_str);
+AP_DECLARE(unsigned short) ap_default_port_for_scheme(const char *scheme_str);
/**
* Return the default for the current request
* @return The default port
* @deffunc unsigned short ap_default_port_for_request(const request_rec *r)
*/
-API_EXPORT(unsigned short) ap_default_port_for_request(const request_rec *r);
+AP_DECLARE(unsigned short) ap_default_port_for_request(const request_rec *r);
/**
* Create a copy of a "struct hostent" record; it was presumably returned
* @param hp hostent to duplicate
* @deffunc struct hostent * ap_pduphostent(apr_pool_t *p, const struct hostent *hp)
*/
-API_EXPORT(struct hostent *) ap_pduphostent(apr_pool_t *p, const struct hostent *hp);
+AP_DECLARE(struct hostent *) ap_pduphostent(apr_pool_t *p, const struct hostent *hp);
/**
* resolve hostname, if successful return an ALLOCATED COPY OF the hostent
* @return The allocated hostent structure
* @deffunc struct hostent * ap_pgethostbyname(apr_pool_t *p, const char *hostname)
*/
-API_EXPORT(struct hostent *) ap_pgethostbyname(apr_pool_t *p, const char *hostname);
+AP_DECLARE(struct hostent *) ap_pgethostbyname(apr_pool_t *p, const char *hostname);
/**
* Unparse a uri_components structure to an URI string. Optionally suppress
* @return The uri as a string
* @deffunc char * ap_unparse_uri_components(apr_pool_t *p, const uri_components *uptr, unsigned flags)
*/
-API_EXPORT(char *) ap_unparse_uri_components(apr_pool_t *p, const uri_components *uptr,
+AP_DECLARE(char *) ap_unparse_uri_components(apr_pool_t *p, const uri_components *uptr,
unsigned flags);
/**
* @return An HTTP status code
* @deffunc int ap_parse_uri_components(apr_pool_t *p, const char *uri, uri_components *uptr)
*/
-API_EXPORT(int) ap_parse_uri_components(apr_pool_t *p, const char *uri, uri_components *uptr);
+AP_DECLARE(int) ap_parse_uri_components(apr_pool_t *p, const char *uri, uri_components *uptr);
/**
* Special case for CONNECT parsing: it comes with the hostinfo part only
* @return An HTTP status code
* @deffunc int ap_parse_hostinfo_components(apr_pool_t *p, const char *hostinfo, uri_components *uptr)
*/
-API_EXPORT(int) ap_parse_hostinfo_components(apr_pool_t *p, const char *hostinfo, uri_components *uptr);
+AP_DECLARE(int) ap_parse_hostinfo_components(apr_pool_t *p, const char *hostinfo, uri_components *uptr);
/**
* Setup everything necessary to parse uri's
* @deffunc void ap_util_uri_init(void)
*/
-API_EXPORT(void) ap_util_uri_init(void);
+AP_DECLARE(void) ap_util_uri_init(void);
#ifdef __cplusplus
}
* @param text The new text to append
* @deffunc void ap_text_append(apr_pool_t *p, ap_text_header *hdr, const char *text)
*/
-API_EXPORT(void) ap_text_append(apr_pool_t *p, ap_text_header *hdr,
+AP_DECLARE(void) ap_text_append(apr_pool_t *p, ap_text_header *hdr,
const char *text);
* @return HTTP status code
* @deffunc int ap_xml_parse_input(request_rec *r, ap_xml_doc **pdoc)
*/
-API_EXPORT(int) ap_xml_parse_input(request_rec *r, ap_xml_doc **pdoc);
+AP_DECLARE(int) ap_xml_parse_input(request_rec *r, ap_xml_doc **pdoc);
/**
* @param psize Size of the converted text
* @deffunc void ap_xml_to_text(apr_pool_t *p, const ap_xml_elem *elem, int style, apr_array_header_t *namespaces, int *ns_map, const char **pbuf, size_t *psize);
*/
-API_EXPORT(void) ap_xml_to_text(apr_pool_t *p, const ap_xml_elem *elem,
+AP_DECLARE(void) ap_xml_to_text(apr_pool_t *p, const ap_xml_elem *elem,
int style, apr_array_header_t *namespaces,
int *ns_map, const char **pbuf, size_t *psize);
* @return the string that was stored in the XML element
* @deffunc const char *ap_xml_empty_elem(apr_pool_t *p, const ap_xml_elem *elem)
*/
-API_EXPORT(const char *) ap_xml_empty_elem(apr_pool_t *p,
+AP_DECLARE(const char *) ap_xml_empty_elem(apr_pool_t *p,
const ap_xml_elem *elem);
/**
* @return The quoted string
* @deffunc const char *ap_xml_quote_string(apr_pool_t *p, const char *s, int quotes)
*/
-API_EXPORT(const char *) ap_xml_quote_string(apr_pool_t *p, const char *s,
+AP_DECLARE(const char *) ap_xml_quote_string(apr_pool_t *p, const char *s,
int quotes);
/**
* @param elem The element to quote
* @deffunc void ap_xml_quote_elem(apr_pool_t *p, ap_xml_elem *elem)
*/
-API_EXPORT(void) ap_xml_quote_elem(apr_pool_t *p, ap_xml_elem *elem);
+AP_DECLARE(void) ap_xml_quote_elem(apr_pool_t *p, ap_xml_elem *elem);
/* manage an array of unique URIs: ap_xml_insert_uri() and AP_XML_URI_ITEM() */
* @return int The uri's index
* @deffunc int ap_xml_insert_uri(apr_array_header_t *uri_array, const char *uri)
*/
-API_EXPORT(int) ap_xml_insert_uri(apr_array_header_t *uri_array,
+AP_DECLARE(int) ap_xml_insert_uri(apr_array_header_t *uri_array,
const char *uri);
#define AP_XML_GET_URI_ITEM(ary, i) (((const char * const *)(ary)->elts)[i])
# PROP Intermediate_Dir ".\CoreR"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "API_EXPORT_SYMBOLS" /FD /c
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD CPP /nologo /MD /W3 /GX /O2 /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# PROP Intermediate_Dir ".\CoreD"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "API_EXPORT_SYMBOLS" /FD /c
+# ADD BASE CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# ADD CPP /nologo /MDd /W3 /GX /ZI /Od /I ".\include" /I ".\lib\apr\include" /I ".\os\win32" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_DECLARE_EXPORT" /FD /c
# SUBTRACT CPP /YX
# ADD BASE MTL /nologo /D "_DEBUG" /win32
apr_array_header_t *denys;
} access_dir_conf;
-module MODULE_VAR_EXPORT access_module;
+module AP_MODULE_DECLARE_DATA access_module;
static void *create_access_dir_config(apr_pool_t *p, char *dummy)
{
ap_hook_access_checker(check_dir_access,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT access_module =
+module AP_MODULE_DECLARE_DATA access_module =
{
STANDARD20_MODULE_STUFF,
create_access_dir_config, /* dir config creater */
{NULL}
};
-module MODULE_VAR_EXPORT auth_module;
+module AP_MODULE_DECLARE_DATA auth_module;
static char *get_pw(request_rec *r, char *user, char *auth_pwfile)
{
ap_hook_auth_checker(check_user_access,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT auth_module =
+module AP_MODULE_DECLARE_DATA auth_module =
{
STANDARD20_MODULE_STUFF,
create_auth_dir_config, /* dir config creater */
{NULL}
};
-module MODULE_VAR_EXPORT auth_anon_module;
+module AP_MODULE_DECLARE_DATA auth_anon_module;
static int anon_authenticate_basic_user(request_rec *r)
{
ap_hook_auth_checker(check_anon_access,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT auth_anon_module =
+module AP_MODULE_DECLARE_DATA auth_anon_module =
{
STANDARD20_MODULE_STUFF,
create_anon_auth_dir_config,/* dir config creater */
{NULL}
};
-module MODULE_VAR_EXPORT auth_dbm_module;
+module AP_MODULE_DECLARE_DATA auth_dbm_module;
static char *get_dbm_pw(request_rec *r, char *user, char *auth_dbmpwfile)
{
ap_hook_auth_checker(dbm_check_auth, NULL, NULL, AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT auth_dbm_module =
+module AP_MODULE_DECLARE_DATA auth_dbm_module =
{
STANDARD20_MODULE_STUFF,
create_dbm_auth_dir_config, /* dir config creater */
static long num_buckets = DEF_NUM_BUCKETS;
-module MODULE_VAR_EXPORT auth_digest_module;
+module AP_MODULE_DECLARE_DATA auth_digest_module;
/*
* initialization code
ap_hook_fixups(add_auth_info, NULL, NULL, AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT auth_digest_module =
+module AP_MODULE_DECLARE_DATA auth_digest_module =
{
STANDARD20_MODULE_STUFF,
create_digest_dir_config, /* dir config creater */
#include "apr_mmap.h"
#include "apr_strings.h"
-module MODULE_VAR_EXPORT file_cache_module;
+module AP_MODULE_DECLARE_DATA file_cache_module;
static int once_through = 0;
typedef struct {
{ NULL }
};
-module MODULE_VAR_EXPORT file_cache_module =
+module AP_MODULE_DECLARE_DATA file_cache_module =
{
STANDARD20_MODULE_STUFF,
NULL, /* create per-directory config structure */
#include "http_config.h"
#include "http_connection.h"
-API_VAR_EXPORT module echo_module;
+AP_DECLARE_DATA module echo_module;
typedef struct
{
ap_hook_process_connection(process_echo_connection,NULL,NULL,AP_HOOK_MIDDLE);
}
-API_VAR_EXPORT module echo_module = {
+AP_DECLARE_DATA module echo_module = {
STANDARD20_MODULE_STUFF,
NULL, /* create per-directory config structure */
NULL, /* merge per-directory config structures */
#define RAW_ASCII_CHAR(ch) (ch)
#endif /*CHARSET_EBCDIC*/
-module MODULE_VAR_EXPORT includes_module;
+module AP_MODULE_DECLARE_DATA includes_module;
/* just need some arbitrary non-NULL pointer which can't also be a request_rec */
#define NESTED_INCLUDE_MAGIC (&includes_module)
ap_register_output_filter("INCLUDES", includes_filter, AP_FTYPE_CONTENT);
}
-module MODULE_VAR_EXPORT includes_module =
+module AP_MODULE_DECLARE_DATA includes_module =
{
STANDARD20_MODULE_STUFF,
create_includes_dir_config, /* dir config creater */
{NULL}
};
-module MODULE_VAR_EXPORT asis_module =
+module AP_MODULE_DECLARE_DATA asis_module =
{
STANDARD20_MODULE_STUFF,
NULL, /* create per-directory config structure */
#include <strings.h>
#endif
-module MODULE_VAR_EXPORT autoindex_module;
+module AP_MODULE_DECLARE_DATA autoindex_module;
/****************************************************************
*
{NULL}
};
-module MODULE_VAR_EXPORT autoindex_module =
+module AP_MODULE_DECLARE_DATA autoindex_module =
{
STANDARD20_MODULE_STUFF,
create_autoindex_config, /* dir config creater */
#include <strings.h>
#endif
-module MODULE_VAR_EXPORT cgi_module;
+module AP_MODULE_DECLARE_DATA cgi_module;
/* KLUDGE --- for back-combatibility, we don't have to check ExecCGI
* in ScriptAliased directories, which means we need to know if this
{NULL}
};
-module MODULE_VAR_EXPORT cgi_module =
+module AP_MODULE_DECLARE_DATA cgi_module =
{
STANDARD20_MODULE_STUFF,
NULL, /* dir config creater */
#include <sys/un.h> /* for sockaddr_un */
#include <sys/types.h>
-module MODULE_VAR_EXPORT cgid_module;
+module AP_MODULE_DECLARE_DATA cgid_module;
static void cgid_init(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *main_server);
static int once_through = 0;
ap_hook_post_config(cgid_init, NULL, NULL, AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT cgid_module = {
+module AP_MODULE_DECLARE_DATA cgid_module = {
STANDARD20_MODULE_STUFF,
NULL, /* dir config creater */
NULL, /* dir merger --- default is to override */
char *fname;
} info_clines;
-module MODULE_VAR_EXPORT info_module;
+module AP_MODULE_DECLARE_DATA info_module;
extern module *top_module;
/* shamelessly lifted from http_config.c */
{NULL}
};
-module MODULE_VAR_EXPORT info_module =
+module AP_MODULE_DECLARE_DATA info_module =
{
STANDARD_MODULE_STUFF,
NULL, /* initializer */
#define STATUS_MAGIC_TYPE "application/x-httpd-status"
-module MODULE_VAR_EXPORT status_module;
+module AP_MODULE_DECLARE_DATA status_module;
static int print_status_value(void *data, const char *key, const char *val)
{
{NULL}
};
-module MODULE_VAR_EXPORT status_module =
+module AP_MODULE_DECLARE_DATA status_module =
{
STANDARD20_MODULE_STUFF,
NULL, /* create per-dir config */
* these are part of the core server config.
*/
-CORE_EXPORT(void) ap_add_per_dir_conf(server_rec *s, void *dir_config)
+AP_CORE_DECLARE(void) ap_add_per_dir_conf(server_rec *s, void *dir_config)
{
core_server_config *sconf = ap_get_module_config(s->module_config,
&core_module);
*new_space = dir_config;
}
-CORE_EXPORT(void) ap_add_per_url_conf(server_rec *s, void *url_config)
+AP_CORE_DECLARE(void) ap_add_per_url_conf(server_rec *s, void *url_config)
{
core_server_config *sconf = ap_get_module_config(s->module_config,
&core_module);
*new_space = url_config;
}
-CORE_EXPORT(void) ap_add_file_conf(core_dir_config *conf, void *url_config)
+AP_CORE_DECLARE(void) ap_add_file_conf(core_dir_config *conf, void *url_config)
{
void **new_space = (void **)apr_push_array(conf->sec);
* here...
*/
-API_EXPORT(int) ap_allow_options(request_rec *r)
+AP_DECLARE(int) ap_allow_options(request_rec *r)
{
core_dir_config *conf =
(core_dir_config *)ap_get_module_config(r->per_dir_config, &core_module);
return conf->opts;
}
-API_EXPORT(int) ap_allow_overrides(request_rec *r)
+AP_DECLARE(int) ap_allow_overrides(request_rec *r)
{
core_dir_config *conf;
conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
return conf->override;
}
-API_EXPORT(const char *) ap_auth_type(request_rec *r)
+AP_DECLARE(const char *) ap_auth_type(request_rec *r)
{
core_dir_config *conf;
return conf->ap_auth_type;
}
-API_EXPORT(const char *) ap_auth_name(request_rec *r)
+AP_DECLARE(const char *) ap_auth_name(request_rec *r)
{
core_dir_config *conf;
return conf->ap_auth_name;
}
-API_EXPORT(const char *) ap_default_type(request_rec *r)
+AP_DECLARE(const char *) ap_default_type(request_rec *r)
{
core_dir_config *conf;
: DEFAULT_CONTENT_TYPE;
}
-API_EXPORT(const char *) ap_document_root(request_rec *r) /* Don't use this! */
+AP_DECLARE(const char *) ap_document_root(request_rec *r) /* Don't use this! */
{
core_server_config *conf;
return conf->ap_document_root;
}
-API_EXPORT(const apr_array_header_t *) ap_requires(request_rec *r)
+AP_DECLARE(const apr_array_header_t *) ap_requires(request_rec *r)
{
core_dir_config *conf;
return conf->ap_requires;
}
-API_EXPORT(int) ap_satisfies(request_rec *r)
+AP_DECLARE(int) ap_satisfies(request_rec *r)
{
core_dir_config *conf;
conn->double_reverse = -1;
}
-API_EXPORT(const char *) ap_get_remote_host(conn_rec *conn, void *dir_config,
+AP_DECLARE(const char *) ap_get_remote_host(conn_rec *conn, void *dir_config,
int type)
{
struct in_addr *iaddr;
}
}
-API_EXPORT(const char *) ap_get_remote_logname(request_rec *r)
+AP_DECLARE(const char *) ap_get_remote_logname(request_rec *r)
{
core_dir_config *dir_conf;
* The assumption is that DNS lookups are sufficiently quick...
* -- fanf 1998-10-03
*/
-API_EXPORT(const char *) ap_get_server_name(request_rec *r)
+AP_DECLARE(const char *) ap_get_server_name(request_rec *r)
{
conn_rec *conn = r->connection;
core_dir_config *d;
return r->server->server_hostname;
}
-API_EXPORT(unsigned) ap_get_server_port(const request_rec *r)
+AP_DECLARE(unsigned) ap_get_server_port(const request_rec *r)
{
unsigned port;
core_dir_config *d =
return port;
}
-API_EXPORT(char *) ap_construct_url(apr_pool_t *p, const char *uri,
+AP_DECLARE(char *) ap_construct_url(apr_pool_t *p, const char *uri,
request_rec *r)
{
unsigned port = ap_get_server_port(r);
return apr_psprintf(p, "%s://%s:%u%s", ap_http_method(r), host, port, uri);
}
-API_EXPORT(unsigned long) ap_get_limit_req_body(const request_rec *r)
+AP_DECLARE(unsigned long) ap_get_limit_req_body(const request_rec *r)
{
core_dir_config *d =
(core_dir_config *)ap_get_module_config(r->per_dir_config, &core_module);
return buffer;
}
-API_EXPORT (file_type_e) ap_get_win32_interpreter(const request_rec *r,
+AP_DECLARE (file_type_e) ap_get_win32_interpreter(const request_rec *r,
char** interpreter,
char** arguments)
{
return NULL;
}
-API_EXPORT(const char *) ap_check_cmd_context(cmd_parms *cmd,
+AP_DECLARE(const char *) ap_check_cmd_context(cmd_parms *cmd,
unsigned forbidden)
{
const char *gt = (cmd->cmd->name[0] == '<'
return NULL;
}
-API_EXPORT(void) ap_custom_response(request_rec *r, int status, char *string)
+AP_DECLARE(void) ap_custom_response(request_rec *r, int status, char *string)
{
core_dir_config *conf =
ap_get_module_config(r->per_dir_config, &core_module);
return NULL;
}
-CORE_EXPORT_NONSTD(const char *) ap_limit_section(cmd_parms *cmd, void *dummy,
+AP_CORE_DECLARE_NONSTD(const char *) ap_limit_section(cmd_parms *cmd, void *dummy,
const char *arg) {
const char *limited_methods = ap_getword(cmd->pool, &arg, '>');
void *tog = cmd->cmd->cmd_data;
}
}
-API_EXPORT(int) ap_exists_config_define(const char *name)
+AP_DECLARE(int) ap_exists_config_define(const char *name)
{
char **defines;
int i;
return NULL;
}
-API_EXPORT(const char *) ap_psignature(const char *prefix, request_rec *r)
+AP_DECLARE(const char *) ap_psignature(const char *prefix, request_rec *r)
{
char sport[20];
core_dir_config *conf;
return APR_SUCCESS;
}
-API_EXPORT(const char *) ap_get_server_version(void)
+AP_DECLARE(const char *) ap_get_server_version(void)
{
return (server_version ? server_version : AP_SERVER_BASEVERSION);
}
-API_EXPORT(void) ap_add_version_component(apr_pool_t *pconf, const char *component)
+AP_DECLARE(void) ap_add_version_component(apr_pool_t *pconf, const char *component)
{
if (! version_locked) {
/*
return NULL;
}
-API_EXPORT(size_t) ap_get_limit_xml_body(const request_rec *r)
+AP_DECLARE(size_t) ap_get_limit_xml_body(const request_rec *r)
{
core_dir_config *conf;
* Core handlers for various phases of server operation...
*/
-API_EXPORT_NONSTD(int) ap_core_translate(request_rec *r)
+AP_DECLARE_NONSTD(int) ap_core_translate(request_rec *r)
{
void *sconf = r->server->module_config;
core_server_config *conf = ap_get_module_config(sconf, &core_module);
ap_register_output_filter("BUFFER", buffer_filter, AP_FTYPE_CONNECTION);
}
-API_VAR_EXPORT module core_module = {
+AP_DECLARE_DATA module core_module = {
STANDARD20_MODULE_STUFF,
create_core_dir_config, /* create per-directory config structure */
merge_core_dir_configs, /* merge per-directory config structures */
static int internal_byterange(int, long *, request_rec *, const char **,
apr_off_t *, apr_size_t *);
-API_EXPORT(int) ap_set_byterange(request_rec *r)
+AP_DECLARE(int) ap_set_byterange(request_rec *r)
{
const char *range, *if_range, *match;
long range_start, range_end;
return 1;
}
-API_EXPORT(int) ap_each_byterange(request_rec *r, apr_off_t *offset,
+AP_DECLARE(int) ap_each_byterange(request_rec *r, apr_off_t *offset,
apr_size_t *length)
{
return internal_byterange(1, NULL, r, &r->range, offset, length);
return 1;
}
-API_EXPORT(int) ap_set_content_length(request_rec *r, long clength)
+AP_DECLARE(int) ap_set_content_length(request_rec *r, long clength)
{
r->clength = clength;
apr_table_setn(r->headers_out, "Content-Length", apr_psprintf(r->pool, "%ld", clength));
return 0;
}
-API_EXPORT(int) ap_set_keepalive(request_rec *r)
+AP_DECLARE(int) ap_set_keepalive(request_rec *r)
{
int ka_sent = 0;
int wimpy = ap_find_token(r->pool,
* to limit the number of calls to time(). We don't check for futurosity
* unless the mtime is at least as new as the reference.
*/
-API_EXPORT(apr_time_t) ap_rationalize_mtime(request_rec *r, apr_time_t mtime)
+AP_DECLARE(apr_time_t) ap_rationalize_mtime(request_rec *r, apr_time_t mtime)
{
apr_time_t now;
return (mtime > now) ? now : mtime;
}
-API_EXPORT(int) ap_meets_conditions(request_rec *r)
+AP_DECLARE(int) ap_meets_conditions(request_rec *r)
{
const char *etag = apr_table_get(r->headers_out, "ETag");
const char *if_match, *if_modified_since, *if_unmodified, *if_nonematch;
* could be modified again in as short an interval. We rationalize the
* modification time we're given to keep it from being in the future.
*/
-API_EXPORT(char *) ap_make_etag(request_rec *r, int force_weak)
+AP_DECLARE(char *) ap_make_etag(request_rec *r, int force_weak)
{
char *etag;
char *weak;
return etag;
}
-API_EXPORT(void) ap_set_etag(request_rec *r)
+AP_DECLARE(void) ap_set_etag(request_rec *r)
{
char *etag;
char *variant_etag, *vlv;
* of the mtime field in the request structure - rationalized to keep it from
* being in the future.
*/
-API_EXPORT(void) ap_set_last_modified(request_rec *r)
+AP_DECLARE(void) ap_set_last_modified(request_rec *r)
{
apr_time_t mod_time = ap_rationalize_mtime(r, r->mtime);
char *datestr = apr_palloc(r->pool, APR_RFC822_DATE_LEN);
* list. Hopefully it (and other routines) can eventually be moved to
* something like a mod_http_methods.c, complete with config stuff.
*/
-API_EXPORT(int) ap_method_number_of(const char *method)
+AP_DECLARE(int) ap_method_number_of(const char *method)
{
switch (*method) {
case 'H':
* Turn a known method number into a name. Doesn't work for
* extension methods, obviously.
*/
-API_EXPORT(const char *) ap_method_name_of(int methnum)
+AP_DECLARE(const char *) ap_method_name_of(int methnum)
{
static const char *AP_HTTP_METHODS[METHODS] = { NULL };
* - sets r->uri to request uri (without r->args part)
* - sets r->hostname (if not set already) from request (scheme://host:port)
*/
-CORE_EXPORT(void) ap_parse_uri(request_rec *r, const char *uri)
+AP_CORE_DECLARE(void) ap_parse_uri(request_rec *r, const char *uri)
{
int status = HTTP_OK;
* Support for the Basic authentication protocol, and a bit for Digest.
*/
-API_EXPORT(void) ap_note_auth_failure(request_rec *r)
+AP_DECLARE(void) ap_note_auth_failure(request_rec *r)
{
if (!strcasecmp(ap_auth_type(r), "Basic"))
ap_note_basic_auth_failure(r);
ap_note_digest_auth_failure(r);
}
-API_EXPORT(void) ap_note_basic_auth_failure(request_rec *r)
+AP_DECLARE(void) ap_note_basic_auth_failure(request_rec *r)
{
if (strcasecmp(ap_auth_type(r), "Basic"))
ap_note_auth_failure(r);
NULL));
}
-API_EXPORT(void) ap_note_digest_auth_failure(request_rec *r)
+AP_DECLARE(void) ap_note_digest_auth_failure(request_rec *r)
{
apr_table_setn(r->err_headers_out,
r->proxyreq ? "Proxy-Authenticate" : "WWW-Authenticate",
ap_auth_name(r), r->request_time));
}
-API_EXPORT(int) ap_get_basic_auth_pw(request_rec *r, const char **pw)
+AP_DECLARE(int) ap_get_basic_auth_pw(request_rec *r, const char **pw)
{
const char *auth_line = apr_table_get(r->headers_in,
r->proxyreq ? "Proxy-Authorization"
* If that sad event occurs, replace the code below with a linear search
* from status_lines[shortcut[i]] to status_lines[shortcut[i+1]-1];
*/
-API_EXPORT(int) ap_index_of_response(int status)
+AP_DECLARE(int) ap_index_of_response(int status)
{
static int shortcut[6] = {0, LEVEL_200, LEVEL_300, LEVEL_400,
LEVEL_500, RESPONSE_CODES};
return LEVEL_500; /* 600 or above is also illegal */
}
-API_EXPORT(const char *) ap_get_status_line(int status)
+AP_DECLARE(const char *) ap_get_status_line(int status)
{
return status_lines[ap_index_of_response(status)];
}
* In other words, don't change this one without checking table_do in alloc.c.
* It returns true unless there was a write error of some kind.
*/
-API_EXPORT_NONSTD(int) ap_send_header_field(request_rec *r,
+AP_DECLARE_NONSTD(int) ap_send_header_field(request_rec *r,
const char *fieldname, const char *fieldval)
{
return (0 < checked_bputstrs(r, fieldname, ": ", fieldval, CRLF, NULL));
}
-API_EXPORT(void) ap_basic_http_header(request_rec *r)
+AP_DECLARE(void) ap_basic_http_header(request_rec *r)
{
char *protocol;
char *date = NULL;
* Create a new method list with the specified number of preallocated
* extension slots.
*/
-API_EXPORT(ap_method_list_t *) ap_make_method_list(apr_pool_t *p, int nelts)
+AP_DECLARE(ap_method_list_t *) ap_make_method_list(apr_pool_t *p, int nelts)
{
ap_method_list_t *ml;
* Make a copy of a method list (primarily for subrequests that may
* subsequently change it; don't want them changing the parent's, too!).
*/
-API_EXPORT(void) ap_copy_method_list(ap_method_list_t *dest,
+AP_DECLARE(void) ap_copy_method_list(ap_method_list_t *dest,
ap_method_list_t *src)
{
int i;
/*
* Invoke a callback routine for each method in the specified list.
*/
-API_EXPORT_NONSTD(void) ap_method_list_do(int (*comp) (void *urec, const char *mname,
+AP_DECLARE_NONSTD(void) ap_method_list_do(int (*comp) (void *urec, const char *mname,
int mnum),
void *rec,
const ap_method_list_t *ml, ...)
va_end(vp);
}
-API_EXPORT(void) ap_method_list_vdo(int (*comp) (void *mrec,
+AP_DECLARE(void) ap_method_list_vdo(int (*comp) (void *mrec,
const char *mname,
int mnum),
void *rec, const ap_method_list_t *ml,
* Return true if the specified HTTP method is in the provided
* method list.
*/
-API_EXPORT(int) ap_method_in_list(ap_method_list_t *l, const char *method)
+AP_DECLARE(int) ap_method_in_list(ap_method_list_t *l, const char *method)
{
int methnum;
int i;
/*
* Add the specified method to a method list (if it isn't already there).
*/
-API_EXPORT(void) ap_method_list_add(ap_method_list_t *l, const char *method)
+AP_DECLARE(void) ap_method_list_add(ap_method_list_t *l, const char *method)
{
int methnum;
int i;
/*
* Remove the specified method from a method list.
*/
-API_EXPORT(void) ap_method_list_remove(ap_method_list_t *l,
+AP_DECLARE(void) ap_method_list_remove(ap_method_list_t *l,
const char *method)
{
int methnum;
/*
* Reset a method list to be completely empty.
*/
-API_EXPORT(void) ap_clear_method_list(ap_method_list_t *l)
+AP_DECLARE(void) ap_clear_method_list(ap_method_list_t *l)
{
l->method_mask = 0;
l->method_list->nelts = 0;
return list + 2;
}
-API_EXPORT(int) ap_send_http_trace(request_rec *r)
+AP_DECLARE(int) ap_send_http_trace(request_rec *r)
{
int rv;
}
}
-API_EXPORT(void) ap_send_http_header(request_rec *r)
+AP_DECLARE(void) ap_send_http_header(request_rec *r)
{
int i;
const long int zero = 0L;
* information for any wrappers around the response message body
* (i.e., transfer encodings). It should have been named finalize_response.
*/
-API_EXPORT(void) ap_finalize_request_protocol(request_rec *r)
+AP_DECLARE(void) ap_finalize_request_protocol(request_rec *r)
{
/* tell the filter chain there is no more content coming */
if (!r->eos_sent) {
* If an error occurs on input, we force an end to keepalive.
*/
-API_EXPORT(int) ap_setup_client_block(request_rec *r, int read_policy)
+AP_DECLARE(int) ap_setup_client_block(request_rec *r, int read_policy)
{
const char *tenc = apr_table_get(r->headers_in, "Transfer-Encoding");
const char *lenp = apr_table_get(r->headers_in, "Content-Length");
return OK;
}
-API_EXPORT(int) ap_should_client_block(request_rec *r)
+AP_DECLARE(int) ap_should_client_block(request_rec *r)
{
/* First check if we have already read the request body */
* hold a chunk-size line, including any extensions. For now, we'll leave
* that to the caller, at least until we can come up with a better solution.
*/
-API_EXPORT(long) ap_get_client_block(request_rec *r, char *buffer, int bufsiz)
+AP_DECLARE(long) ap_get_client_block(request_rec *r, char *buffer, int bufsiz)
{
int c;
apr_size_t len_to_read;
* if ((retval = ap_discard_request_body(r)) != OK)
* return retval;
*/
-API_EXPORT(int) ap_discard_request_body(request_rec *r)
+AP_DECLARE(int) ap_discard_request_body(request_rec *r)
{
int rv;
/*
* Send the body of a response to the client.
*/
-API_EXPORT(apr_status_t) ap_send_fd(apr_file_t *fd, request_rec *r, apr_off_t offset,
+AP_DECLARE(apr_status_t) ap_send_fd(apr_file_t *fd, request_rec *r, apr_off_t offset,
apr_size_t len, apr_size_t *nbytes)
{
ap_bucket_brigade *bb = NULL;
}
#if 0
/* Leave the old implementation around temporarily for reference purposes */
-API_EXPORT(apr_status_t) ap_send_fd(apr_file_t *fd, request_rec *r, apr_off_t offset,
+AP_DECLARE(apr_status_t) ap_send_fd(apr_file_t *fd, request_rec *r, apr_off_t offset,
apr_size_t length, apr_size_t *nbytes)
{
apr_status_t rv = APR_SUCCESS;
#endif
/* send data from an in-memory buffer */
-API_EXPORT(size_t) ap_send_mmap(apr_mmap_t *mm, request_rec *r, size_t offset,
+AP_DECLARE(size_t) ap_send_mmap(apr_mmap_t *mm, request_rec *r, size_t offset,
size_t length)
{
ap_bucket_brigade *bb = NULL;
}
#endif /* USE_MMAP_FILES */
-API_EXPORT(int) ap_rputc(int c, request_rec *r)
+AP_DECLARE(int) ap_rputc(int c, request_rec *r)
{
ap_bucket_brigade *bb = NULL;
ap_bucket *b;
return c;
}
-API_EXPORT(int) ap_rputs(const char *str, request_rec *r)
+AP_DECLARE(int) ap_rputs(const char *str, request_rec *r)
{
ap_bucket_brigade *bb = NULL;
ap_bucket *b;
return len;
}
-API_EXPORT(int) ap_rwrite(const void *buf, int nbyte, request_rec *r)
+AP_DECLARE(int) ap_rwrite(const void *buf, int nbyte, request_rec *r)
{
ap_bucket_brigade *bb = NULL;
ap_bucket *b;
return nbyte;
}
-API_EXPORT(int) ap_vrprintf(request_rec *r, const char *fmt, va_list va)
+AP_DECLARE(int) ap_vrprintf(request_rec *r, const char *fmt, va_list va)
{
ap_bucket_brigade *bb = NULL;
apr_ssize_t written;
/* TODO: Make ap pa_bucket_vprintf that printfs directly into a
* bucket.
*/
-API_EXPORT_NONSTD(int) ap_rprintf(request_rec *r, const char *fmt, ...)
+AP_DECLARE_NONSTD(int) ap_rprintf(request_rec *r, const char *fmt, ...)
{
va_list va;
int n;
return n;
}
-API_EXPORT_NONSTD(int) ap_rvputs(request_rec *r, ...)
+AP_DECLARE_NONSTD(int) ap_rvputs(request_rec *r, ...)
{
ap_bucket_brigade *bb = NULL;
apr_ssize_t written;
return written;
}
-API_EXPORT(int) ap_rflush(request_rec *r)
+AP_DECLARE(int) ap_rflush(request_rec *r)
{
/* ### this is probably incorrect, but we have no mechanism for telling
### the filter chain to flush any content they may be holding.
* and 5xx (server error) messages that have not been redirected to another
* handler via the ErrorDocument feature.
*/
-API_EXPORT(void) ap_send_error_response(request_rec *r, int recursive_error)
+AP_DECLARE(void) ap_send_error_response(request_rec *r, int recursive_error)
{
int status = r->status;
int idx = ap_index_of_response(status);
return rr;
}
-API_EXPORT(request_rec *) ap_sub_req_method_uri(const char *method,
+AP_DECLARE(request_rec *) ap_sub_req_method_uri(const char *method,
const char *new_file,
const request_rec *r)
{
return rnew;
}
-API_EXPORT(request_rec *) ap_sub_req_lookup_uri(const char *new_file,
+AP_DECLARE(request_rec *) ap_sub_req_lookup_uri(const char *new_file,
const request_rec *r)
{
return ap_sub_req_method_uri("GET", new_file, r);
}
-API_EXPORT(request_rec *) ap_sub_req_lookup_file(const char *new_file,
+AP_DECLARE(request_rec *) ap_sub_req_lookup_file(const char *new_file,
const request_rec *r)
{
request_rec *rnew;
return rnew;
}
-API_EXPORT(int) ap_run_sub_req(request_rec *r)
+AP_DECLARE(int) ap_run_sub_req(request_rec *r)
{
int retval;
return retval;
}
-API_EXPORT(void) ap_destroy_sub_req(request_rec *r)
+AP_DECLARE(void) ap_destroy_sub_req(request_rec *r)
{
/* Reclaim the space */
apr_destroy_pool(r->pool);
* Mainline request processing...
*/
-API_EXPORT(void) ap_die(int type, request_rec *r)
+AP_DECLARE(void) ap_die(int type, request_rec *r)
{
int error_index = ap_index_of_response(type);
char *custom_response = ap_response_code_string(r, error_index);
ap_die(status, r);
}
-API_EXPORT(int) ap_some_auth_required(request_rec *r)
+AP_DECLARE(int) ap_some_auth_required(request_rec *r)
{
/* Is there a require line configured for the type of *this* req? */
return new;
}
-API_EXPORT(void) ap_internal_redirect(const char *new_uri, request_rec *r)
+AP_DECLARE(void) ap_internal_redirect(const char *new_uri, request_rec *r)
{
request_rec *new = internal_internal_redirect(new_uri, r);
process_request_internal(new);
* using AddHandler, and you want to preserve the content type across
* an internal redirect.
*/
-API_EXPORT(void) ap_internal_redirect_handler(const char *new_uri, request_rec *r)
+AP_DECLARE(void) ap_internal_redirect_handler(const char *new_uri, request_rec *r)
{
request_rec *new = internal_internal_redirect(new_uri, r);
if (r->handler)
/*
* Is it the initial main request, which we only get *once* per HTTP request?
*/
-API_EXPORT(int) ap_is_initial_req(request_rec *r)
+AP_DECLARE(int) ap_is_initial_req(request_rec *r)
{
return
(r->main == NULL) /* otherwise, this is a sub-request */
* Function to set the r->mtime field to the specified value if it's later
* than what's already there.
*/
-API_EXPORT(void) ap_update_mtime(request_rec *r, apr_time_t dependency_mtime)
+AP_DECLARE(void) ap_update_mtime(request_rec *r, apr_time_t dependency_mtime)
{
if (r->mtime < dependency_mtime) {
r->mtime = dependency_mtime;
}
}
-API_EXPORT(void) ap_allow_methods(request_rec *r, int reset, ...)
+AP_DECLARE(void) ap_allow_methods(request_rec *r, int reset, ...)
{
const char *method;
va_list methods;
'\0'
};
-module MODULE_VAR_EXPORT mime_module;
+module AP_MODULE_DECLARE_DATA mime_module;
static void *create_mime_dir_config(apr_pool_t *p, char *dummy)
{
ap_hook_post_config(mime_post_config,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT mime_module = {
+module AP_MODULE_DECLARE_DATA mime_module = {
STANDARD20_MODULE_STUFF,
create_mime_dir_config, /* create per-directory config structure */
merge_mime_dir_configs, /* merge per-directory config structures */
#include <strings.h>
#endif
-module MODULE_VAR_EXPORT config_log_module;
+module AP_MODULE_DECLARE_DATA config_log_module;
static int xfer_flags = (APR_WRITE | APR_APPEND | APR_CREATE);
static apr_fileperms_t xfer_perms = APR_OS_DEFAULT;
ap_hook_log_transaction(multi_log_transaction,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT config_log_module =
+module AP_MODULE_DECLARE_DATA config_log_module =
{
STANDARD20_MODULE_STUFF,
NULL, /* create per-dir config */
apr_array_header_t *redirects;
} alias_dir_conf;
-module MODULE_VAR_EXPORT alias_module;
+module AP_MODULE_DECLARE_DATA alias_module;
static void *create_alias_config(apr_pool_t *p, server_rec *s)
{
ap_hook_fixups(fixup_redir,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT alias_module =
+module AP_MODULE_DECLARE_DATA alias_module =
{
STANDARD20_MODULE_STUFF,
create_alias_dir_config, /* dir config creater */
#include "http_main.h"
#include "util_script.h"
-module MODULE_VAR_EXPORT dir_module;
+module AP_MODULE_DECLARE_DATA dir_module;
typedef struct dir_config_struct {
apr_array_header_t *index_names;
{NULL}
};
-module MODULE_VAR_EXPORT dir_module = {
+module AP_MODULE_DECLARE_DATA dir_module = {
STANDARD20_MODULE_STUFF,
create_dir_config, /* create per-directory config structure */
merge_dir_configs, /* merge per-directory config structures */
double strtod(); /* SunOS needed this */
#endif
-module MODULE_VAR_EXPORT imap_module;
+module AP_MODULE_DECLARE_DATA imap_module;
typedef struct {
char *imap_menu;
{NULL}
};
-module MODULE_VAR_EXPORT imap_module =
+module AP_MODULE_DECLARE_DATA imap_module =
{
STANDARD20_MODULE_STUFF,
create_imap_dir_config, /* dir config creater */
apr_array_header_t *language_priority;
} neg_dir_config;
-module MODULE_VAR_EXPORT negotiation_module;
+module AP_MODULE_DECLARE_DATA negotiation_module;
static void *create_neg_dir_config(apr_pool_t *p, char *dummy)
{
ap_hook_type_checker(handle_multi,NULL,NULL,AP_HOOK_FIRST);
}
-module MODULE_VAR_EXPORT negotiation_module =
+module AP_MODULE_DECLARE_DATA negotiation_module =
{
STANDARD20_MODULE_STUFF,
create_neg_dir_config, /* dir config creator */
}
/* the main config structure */
-module MODULE_VAR_EXPORT rewrite_module = {
+module AP_MODULE_DECLARE_DATA rewrite_module = {
STANDARD20_MODULE_STUFF,
config_perdir_create, /* create per-dir config structures */
config_perdir_merge, /* merge per-dir config structures */
#include "apr_dso.h"
#include "apr_strings.h"
-module MODULE_VAR_EXPORT so_module;
+module AP_MODULE_DECLARE_DATA so_module;
/*
{ NULL }
};
-module MODULE_VAR_EXPORT so_module = {
+module AP_MODULE_DECLARE_DATA so_module = {
STANDARD20_MODULE_STUFF,
NULL, /* create per-dir config */
NULL, /* merge per-dir config */
* Activate it with "CheckSpelling On"
*/
-MODULE_VAR_EXPORT module speling_module;
+AP_MODULE_DECLARE_DATA module speling_module;
typedef struct {
int enabled;
ap_hook_fixups(check_speling,NULL,NULL,AP_HOOK_LAST);
}
-module MODULE_VAR_EXPORT speling_module =
+module AP_MODULE_DECLARE_DATA speling_module =
{
STANDARD20_MODULE_STUFF,
create_mconfig_for_directory, /* create per-dir config */
#include "http_request.h" /* for ap_hook_translate_name */
-module MODULE_VAR_EXPORT vhost_alias_module;
+module AP_MODULE_DECLARE_DATA vhost_alias_module;
/*
ap_hook_translate_name(mva_translate, NULL, NULL, AP_HOOK_MIDDLE);
};
-module MODULE_VAR_EXPORT vhost_alias_module =
+module AP_MODULE_DECLARE_DATA vhost_alias_module =
{
STANDARD20_MODULE_STUFF,
NULL, /* dir config creater */
#define DEFAULT_METASUFFIX ".meta"
#define DEFAULT_METAFILES 0
-module MODULE_VAR_EXPORT cern_meta_module;
+module AP_MODULE_DECLARE_DATA cern_meta_module;
typedef struct {
const char *metadir;
{
ap_hook_fixups(add_cern_meta_data,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT cern_meta_module =
+module AP_MODULE_DECLARE_DATA cern_meta_module =
{
STANDARD20_MODULE_STUFF,
create_cern_meta_dir_config,/* dir config creater */
int vars_present;
} env_dir_config_rec;
-module MODULE_VAR_EXPORT env_module;
+module AP_MODULE_DECLARE_DATA env_module;
static void *create_env_dir_config(apr_pool_t *p, char *dummy)
{
}
-module MODULE_VAR_EXPORT env_module =
+module AP_MODULE_DECLARE_DATA env_module =
{
STANDARD20_MODULE_STUFF,
create_env_dir_config, /* dir config creater */
#define ACTIVE_OFF 0
#define ACTIVE_DONTCARE 2
-module MODULE_VAR_EXPORT expires_module;
+module AP_MODULE_DECLARE_DATA expires_module;
static void *create_dir_expires_config(apr_pool_t *p, char *dummy)
{
ap_hook_fixups(add_expires,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT expires_module =
+module AP_MODULE_DECLARE_DATA expires_module =
{
STANDARD20_MODULE_STUFF,
create_dir_expires_config, /* dir config creater */
apr_array_header_t *headers;
} headers_conf;
-module MODULE_VAR_EXPORT headers_module;
+module AP_MODULE_DECLARE_DATA headers_module;
static void *create_headers_config(apr_pool_t *p, server_rec *s)
{
{
ap_hook_fixups(fixup_headers,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT headers_module =
+module AP_MODULE_DECLARE_DATA headers_module =
{
STANDARD20_MODULE_STUFF,
create_headers_dir_config, /* dir config creater */
apr_array_header_t *conditionals;
} sei_cfg_rec;
-module MODULE_VAR_EXPORT setenvif_module;
+module AP_MODULE_DECLARE_DATA setenvif_module;
/*
* These routines, the create- and merge-config functions, are called
ap_hook_post_read_request(match_headers, NULL, NULL, AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT setenvif_module =
+module AP_MODULE_DECLARE_DATA setenvif_module =
{
STANDARD20_MODULE_STUFF,
create_setenvif_config_dir, /* dir config creater */
ap_hook_post_read_request(gen_unique_id, NULL, NULL, AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT unique_id_module = {
+module AP_MODULE_DECLARE_DATA unique_id_module = {
STANDARD20_MODULE_STUFF,
NULL, /* dir config creater */
NULL, /* dir merger --- default is to override */
#include "http_request.h"
#include "apr_strings.h"
-module MODULE_VAR_EXPORT usertrack_module;
+module AP_MODULE_DECLARE_DATA usertrack_module;
typedef struct {
int always;
{
ap_hook_fixups(spot_cookie,NULL,NULL,AP_HOOK_MIDDLE);
}
-module MODULE_VAR_EXPORT usertrack_module = {
+module AP_MODULE_DECLARE_DATA usertrack_module = {
STANDARD20_MODULE_STUFF,
make_cookie_dir, /* dir config creater */
NULL, /* dir merger --- default is to override */
ap_hook_post_read_request(proxy_detect, NULL, NULL, AP_HOOK_FIRST);
}
-module MODULE_VAR_EXPORT proxy_module =
+module AP_MODULE_DECLARE_DATA proxy_module =
{
STANDARD20_MODULE_STUFF,
NULL, /* create per-directory config structure */
#include <arpa/inet.h>
#endif
-extern module MODULE_VAR_EXPORT proxy_module;
+extern module AP_MODULE_DECLARE_DATA proxy_module;
/* for proxy_canonenc() */
#include <string.h>
-API_EXPORT(char *)ap_os_case_canonical_filename(apr_pool_t *pPool, const char *szFile)
+AP_DECLARE(char *)ap_os_case_canonical_filename(apr_pool_t *pPool, const char *szFile)
{
char buf[HUGE_STRING_LEN];
char buf2[HUGE_STRING_LEN];
}
#endif /* NEED_AP_SYS_SIGLIST */
-API_EXPORT(void) unixd_set_rlimit(cmd_parms *cmd, struct rlimit **plimit,
+AP_DECLARE(void) unixd_set_rlimit(cmd_parms *cmd, struct rlimit **plimit,
const char *arg, const char * arg2, int type)
{
#if (defined(RLIMIT_CPU) || defined(RLIMIT_DATA) || defined(RLIMIT_VMEM) || defined(RLIMIT_NPROC) || defined(RLIMIT_AS)) && APR_HAVE_STRUCT_RLIMIT && APR_HAVE_GETRLIMIT
const char *unixd_set_group(cmd_parms *cmd, void *dummy, const char *arg);
#if defined(RLIMIT_CPU) || defined(RLIMIT_DATA) || defined(RLIMIT_VMEM) || \
defined(RLIMIT_NPROC) || defined(RLIMIT_AS)
-API_EXPORT(void) unixd_set_rlimit(cmd_parms *cmd, struct rlimit **plimit,
+AP_DECLARE(void) unixd_set_rlimit(cmd_parms *cmd, struct rlimit **plimit,
const char *arg, const char * arg2, int type);
#endif
}
/* OS-dependent filename routines in util_win32.c */
-API_EXPORT(char *) ap_os_canonical_filename(apr_pool_t *p, const char *file);
-API_EXPORT(char *) ap_os_case_canonical_filename(apr_pool_t *pPool, const char *szFile);
-API_EXPORT(char *) ap_os_systemcase_filename(apr_pool_t *pPool, const char *szFile);
-API_EXPORT(int) ap_os_is_filename_valid(const char *file);
+AP_DECLARE(char *) ap_os_canonical_filename(apr_pool_t *p, const char *file);
+AP_DECLARE(char *) ap_os_case_canonical_filename(apr_pool_t *pPool, const char *szFile);
+AP_DECLARE(char *) ap_os_systemcase_filename(apr_pool_t *pPool, const char *szFile);
+AP_DECLARE(int) ap_os_is_filename_valid(const char *file);
typedef void thread;
typedef void event;
* is present on the existing path. This routine also
* converts alias names to long names.
*/
-API_EXPORT(char *) ap_os_systemcase_filename(apr_pool_t *pPool,
+AP_DECLARE(char *) ap_os_systemcase_filename(apr_pool_t *pPool,
const char *szFile)
{
char buf[HUGE_STRING_LEN];
/* Perform canonicalization with the exception that the
* input case is preserved.
*/
-API_EXPORT(char *) ap_os_case_canonical_filename(apr_pool_t *pPool,
+AP_DECLARE(char *) ap_os_case_canonical_filename(apr_pool_t *pPool,
const char *szFile)
{
char *pNewStr;
/* Perform complete canonicalization.
*/
-API_EXPORT(char *) ap_os_canonical_filename(apr_pool_t *pPool, const char *szFile)
+AP_DECLARE(char *) ap_os_canonical_filename(apr_pool_t *pPool, const char *szFile)
{
char *pNewName;
pNewName = ap_os_case_canonical_filename(pPool, szFile);
* If the path fails ANY of these tests, the result must be to deny access.
*/
-API_EXPORT(int) ap_os_is_filename_valid(const char *file)
+AP_DECLARE(int) ap_os_is_filename_valid(const char *file)
{
const char *segstart;
unsigned int seglength;
static const char server_built[] = "unknown";
#endif
-API_EXPORT(const char *) ap_get_server_built()
+AP_DECLARE(const char *) ap_get_server_built()
{
return server_built;
}
#include <strings.h>
#endif
-API_VAR_EXPORT const char *ap_server_argv0;
+AP_DECLARE_DATA const char *ap_server_argv0;
-API_VAR_EXPORT const char *ap_server_root;
+AP_DECLARE_DATA const char *ap_server_root;
-API_VAR_EXPORT apr_array_header_t *ap_server_pre_read_config;
-API_VAR_EXPORT apr_array_header_t *ap_server_post_read_config;
-API_VAR_EXPORT apr_array_header_t *ap_server_config_defines;
+AP_DECLARE_DATA apr_array_header_t *ap_server_pre_read_config;
+AP_DECLARE_DATA apr_array_header_t *ap_server_post_read_config;
+AP_DECLARE_DATA apr_array_header_t *ap_server_config_defines;
AP_HOOK_STRUCT(
AP_HOOK_LINK(header_parser)
* than DYNAMIC_MODULE_LIMIT.
*/
static int dynamic_modules = 0;
-API_VAR_EXPORT module *top_module = NULL;
-API_VAR_EXPORT module **ap_loaded_modules=NULL;
+AP_DECLARE_DATA module *top_module = NULL;
+AP_DECLARE_DATA module **ap_loaded_modules=NULL;
typedef int (*handler_func) (request_rec *);
typedef void *(*dir_maker_func) (apr_pool_t *, char *);
*/
#ifndef ap_get_module_config
-API_EXPORT(void *) ap_get_module_config(void *conf_vector, module *m)
+AP_DECLARE(void *) ap_get_module_config(void *conf_vector, module *m)
{
void **confv = (void **) conf_vector;
return confv[m->module_index];
#endif
#ifndef ap_set_module_config
-API_EXPORT(void) ap_set_module_config(void *conf_vector, module *m, void *val)
+AP_DECLARE(void) ap_set_module_config(void *conf_vector, module *m, void *val)
{
void **confv = (void **) conf_vector;
confv[m->module_index] = val;
return create_empty_config(p);
}
-CORE_EXPORT(void *) ap_create_per_dir_config(apr_pool_t *p)
+AP_CORE_DECLARE(void *) ap_create_per_dir_config(apr_pool_t *p)
{
return create_empty_config(p);
}
return HTTP_INTERNAL_SERVER_ERROR;
}
-API_EXPORT(int) ap_method_is_limited(cmd_parms *cmd, const char *method) {
+AP_DECLARE(int) ap_method_is_limited(cmd_parms *cmd, const char *method) {
int methnum;
int i;
char **xmethod;
return 0;
}
-API_EXPORT(void) ap_register_hooks(module *m)
+AP_DECLARE(void) ap_register_hooks(module *m)
{
if(m->register_hooks)
{
/* One-time setup for precompiled modules --- NOT to be done on restart */
-API_EXPORT(void) ap_add_module(module *m)
+AP_DECLARE(void) ap_add_module(module *m)
{
/* This could be called from an AddModule httpd.conf command,
* after the file has been linked and the module structure within it
* all our current data. I.e. when doing a restart.
*/
-API_EXPORT(void) ap_remove_module(module *m)
+AP_DECLARE(void) ap_remove_module(module *m)
{
module *modp;
total_modules--;
}
-API_EXPORT(void) ap_add_loaded_module(module *mod)
+AP_DECLARE(void) ap_add_loaded_module(module *mod)
{
module **m;
*m = NULL;
}
-API_EXPORT(void) ap_remove_loaded_module(module *mod)
+AP_DECLARE(void) ap_remove_loaded_module(module *mod)
{
module **m;
module **m2;
*m = NULL;
}
-API_EXPORT(void) ap_setup_prelinked_modules(process_rec *process)
+AP_DECLARE(void) ap_setup_prelinked_modules(process_rec *process)
{
module **m;
module **m2;
ap_sort_hooks();
}
-API_EXPORT(const char *) ap_find_module_name(module *m)
+AP_DECLARE(const char *) ap_find_module_name(module *m)
{
return m->name;
}
-API_EXPORT(module *) ap_find_linked_module(const char *name)
+AP_DECLARE(module *) ap_find_linked_module(const char *name)
{
module *modp;
}
/* Add a named module. Returns 1 if module found, 0 otherwise. */
-API_EXPORT(int) ap_add_named_module(const char *name)
+AP_DECLARE(int) ap_add_named_module(const char *name)
{
module *modp;
int i = 0;
}
/* Clear the internal list of modules, in preparation for starting over. */
-API_EXPORT(void) ap_clear_module_list()
+AP_DECLARE(void) ap_clear_module_list()
{
module **m = &top_module;
module **next_m;
}
}
-CORE_EXPORT(const command_rec *) ap_find_command(const char *name, const command_rec *cmds)
+AP_CORE_DECLARE(const command_rec *) ap_find_command(const char *name, const command_rec *cmds)
{
while (cmds->name)
if (!strcasecmp(name, cmds->name))
return NULL;
}
-CORE_EXPORT(const command_rec *) ap_find_command_in_modules(const char *cmd_name, module **mod)
+AP_CORE_DECLARE(const command_rec *) ap_find_command_in_modules(const char *cmd_name, module **mod)
{
const command_rec *cmdp;
module *modp;
return NULL;
}
-CORE_EXPORT(void *) ap_set_config_vectors(cmd_parms *parms, void *config, module *mod)
+AP_CORE_DECLARE(void *) ap_set_config_vectors(cmd_parms *parms, void *config, module *mod)
{
void *mconfig = ap_get_module_config(config, mod);
void *sconfig = ap_get_module_config(parms->server->module_config, mod);
/* NOTREACHED */
}
-API_EXPORT(const char *) ap_walk_config(ap_directive_t *current,
+AP_DECLARE(const char *) ap_walk_config(ap_directive_t *current,
cmd_parms *parms, void *config)
{
void *oldconfig = parms->context;
}
-API_EXPORT(const char *) ap_build_config(cmd_parms *parms,
+AP_DECLARE(const char *) ap_build_config(cmd_parms *parms,
apr_pool_t *p, apr_pool_t *temp_pool,
ap_directive_t **conftree)
{
* Generic command functions...
*/
-API_EXPORT_NONSTD(const char *) ap_set_string_slot(cmd_parms *cmd,
+AP_DECLARE_NONSTD(const char *) ap_set_string_slot(cmd_parms *cmd,
void *struct_ptr,
const char *arg)
{
return NULL;
}
-API_EXPORT_NONSTD(const char *) ap_set_string_slot_lower(cmd_parms *cmd,
+AP_DECLARE_NONSTD(const char *) ap_set_string_slot_lower(cmd_parms *cmd,
void *struct_ptr,
const char *arg_)
{
return NULL;
}
-API_EXPORT_NONSTD(const char *) ap_set_flag_slot(cmd_parms *cmd,
+AP_DECLARE_NONSTD(const char *) ap_set_flag_slot(cmd_parms *cmd,
void *struct_ptr_v, int arg)
{
/* This one's pretty generic too... */
return NULL;
}
-API_EXPORT_NONSTD(const char *) ap_set_file_slot(cmd_parms *cmd, char *struct_ptr,
+AP_DECLARE_NONSTD(const char *) ap_set_file_slot(cmd_parms *cmd, char *struct_ptr,
const char *arg)
{
/* Prepend server_root to relative arg.
static cmd_parms default_parms =
{NULL, 0, -1, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
-API_EXPORT(const char *) ap_server_root_relative(apr_pool_t *p, const char *file)
+AP_DECLARE(const char *) ap_server_root_relative(apr_pool_t *p, const char *file)
{
if(ap_os_is_path_absolute(file))
return file;
return ap_make_full_path(p, ap_server_root, file);
}
-API_EXPORT(const char *) ap_soak_end_container(cmd_parms *cmd, char *directive)
+AP_DECLARE(const char *) ap_soak_end_container(cmd_parms *cmd, char *directive)
{
char l[MAX_STRING_LEN];
const char *args;
ap_cfg_closefile(cfp);
}
-API_EXPORT(void)ap_process_config_tree(server_rec *s, ap_directive_t *conftree,
+AP_DECLARE(void)ap_process_config_tree(server_rec *s, ap_directive_t *conftree,
apr_pool_t *p, apr_pool_t *ptemp)
{
const char *errmsg;
return OK;
}
-CORE_EXPORT(const char *) ap_init_virtual_host(apr_pool_t *p, const char *hostname,
+AP_CORE_DECLARE(const char *) ap_init_virtual_host(apr_pool_t *p, const char *hostname,
server_rec *main_server, server_rec **ps)
{
server_rec *s = (server_rec *) apr_pcalloc(p, sizeof(server_rec));
}
-API_EXPORT(void) ap_fixup_virtual_hosts(apr_pool_t *p, server_rec *main_server)
+AP_DECLARE(void) ap_fixup_virtual_hosts(apr_pool_t *p, server_rec *main_server)
{
server_rec *virt;
}
-API_EXPORT(server_rec*) ap_read_config(process_rec *process, apr_pool_t *ptemp,
+AP_DECLARE(server_rec*) ap_read_config(process_rec *process, apr_pool_t *ptemp,
const char *confname,
ap_directive_t **conftree)
{
(*m->create_dir_config)(p, NULL));
}
-API_EXPORT(void) ap_run_rewrite_args(process_rec *process)
+AP_DECLARE(void) ap_run_rewrite_args(process_rec *process)
{
module *m;
(*m->rewrite_args) (process);
}
-API_EXPORT(void) ap_post_config_hook(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
+AP_DECLARE(void) ap_post_config_hook(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
ap_run_post_config(pconf,plog,ptemp,s);
init_handlers(pconf);
* the directive arguments, in what module they are handled, and in
* what parts of the configuration they are allowed. Used for httpd -h.
*/
-API_EXPORT(void) ap_show_directives()
+AP_DECLARE(void) ap_show_directives()
{
const command_rec *pc;
int n;
}
/* Show the preloaded module names. Used for httpd -l. */
-API_EXPORT(void) ap_show_modules()
+AP_DECLARE(void) ap_show_modules()
{
int n;
ap_bclose(c->client);
}
-CORE_EXPORT(void) ap_process_connection(conn_rec *c)
+AP_CORE_DECLARE(void) ap_process_connection(conn_rec *c)
{
ap_update_vhost_given_ip(c);
}
}
-API_EXPORT(void) ap_error_log2stderr(server_rec *s) {
+AP_DECLARE(void) ap_error_log2stderr(server_rec *s) {
apr_file_t *errfile = NULL;
apr_open_stderr(&errfile, s->process->pool);
#endif
}
-API_EXPORT(void) ap_log_error(const char *file, int line, int level,
+AP_DECLARE(void) ap_log_error(const char *file, int line, int level,
apr_status_t status, const server_rec *s,
const char *fmt, ...)
{
va_end(args);
}
-API_EXPORT(void) ap_log_perror(const char *file, int line, int level,
+AP_DECLARE(void) ap_log_perror(const char *file, int line, int level,
apr_status_t status, apr_pool_t *p,
const char *fmt, ...)
{
va_end(args);
}
-API_EXPORT(void) ap_log_rerror(const char *file, int line, int level,
+AP_DECLARE(void) ap_log_rerror(const char *file, int line, int level,
apr_status_t status, const request_rec *r,
const char *fmt, ...)
{
saved_pid = mypid;
}
-API_EXPORT(void) ap_log_assert(const char *szExp, const char *szFile, int nLine)
+AP_DECLARE(void) ap_log_assert(const char *szExp, const char *szFile, int nLine)
{
char time_str[APR_CTIME_LEN];
return APR_SUCCESS;
}
-API_EXPORT(piped_log *) ap_open_piped_log(apr_pool_t *p, const char *program)
+AP_DECLARE(piped_log *) ap_open_piped_log(apr_pool_t *p, const char *program)
{
piped_log *pl;
return APR_SUCCESS;
}
-API_EXPORT(piped_log *) ap_open_piped_log(apr_pool_t *p, const char *program)
+AP_DECLARE(piped_log *) ap_open_piped_log(apr_pool_t *p, const char *program)
{
piped_log *pl;
apr_file_t *dummy = NULL;
#endif
-API_EXPORT(void) ap_close_piped_log(piped_log *pl)
+AP_DECLARE(void) ap_close_piped_log(piped_log *pl)
{
apr_run_cleanup(pl->p, pl, piped_log_cleanup);
}
static int max_spare_threads=0;
static int ap_thread_limit=0;
static time_t ap_restart_time=0;
-API_VAR_EXPORT int ap_extended_status = 0;
+AP_DECLARE_DATA int ap_extended_status = 0;
static int num_listening_sockets = 0; /* set by open_listeners in ap_mpm_run */
static apr_socket_t ** listening_sockets;
apr_lock_t *accept_mutex = NULL;
int raise_sigstop_flags;
#endif
-API_EXPORT(int) ap_get_max_daemons(void)
+AP_DECLARE(int) ap_get_max_daemons(void)
{
return ap_max_child_assigned;
}
{ NULL }
};
-module MODULE_VAR_EXPORT mpm_beos_module = {
+module AP_MODULE_DECLARE_DATA mpm_beos_module = {
MPM20_MODULE_STUFF,
NULL, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
ap_scoreboard_image = NULL;
}
-API_EXPORT(int) ap_exists_scoreboard_image(void)
+AP_DECLARE(int) ap_exists_scoreboard_image(void)
{
return (ap_scoreboard_image ? 1 : 0);
}
#include <sys/times.h>
#include "mpm_default.h" /* For HARD_.*_LIMIT */
-API_EXPORT(int) ap_exists_scoreboard_image(void);
+AP_DECLARE(int) ap_exists_scoreboard_image(void);
void reinit_scoareboard(apr_pool_t *p);
void cleanup_scoreboard(void);
void ap_beos_set_maintain_connection_status(int flag);
void ap_beos_force_reset_connection_status(long conn_id);
void reinit_scoreboard(apr_pool_t *p);
void update_scoreboard_global(void);
-API_EXPORT(int) find_child_by_pid(int pid);
+AP_DECLARE(int) find_child_by_pid(int pid);
int ap_update_child_status(int child_num, int thread_num, int status, request_rec *r);
void ap_time_process_request(int child_num, int thread_num, int status);
static int max_threads = 0;
static int max_requests_per_child = 0;
static const char *ap_pid_fname=NULL;
-API_VAR_EXPORT const char *ap_scoreboard_fname=NULL;
+AP_DECLARE_DATA const char *ap_scoreboard_fname=NULL;
static int num_daemons=0;
static int workers_may_exit = 0;
static int requests_this_child;
static const char *lock_fname;
static pthread_mutex_t thread_accept_mutex = PTHREAD_MUTEX_INITIALIZER;
-API_EXPORT(int) ap_get_max_daemons(void)
+AP_DECLARE(int) ap_get_max_daemons(void)
{
return ap_max_daemons_limit;
}
{ NULL }
};
-module MODULE_VAR_EXPORT mpm_dexter_module = {
+module AP_MODULE_DECLARE_DATA mpm_dexter_module = {
MPM20_MODULE_STUFF,
NULL, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
/* The generic shared memory chunk code */
void reinit_scoreboard(apr_pool_t *p);
-API_EXPORT(void) reopen_scoreboard(apr_pool_t *p);
+AP_DECLARE(void) reopen_scoreboard(apr_pool_t *p);
/* The stuff for Dexter's status table */
#define SCOREBOARD_SIZE sizeof(scoreboard)
-API_VAR_EXPORT extern const char *ap_scoreboard_fname;
+AP_DECLARE_DATA extern const char *ap_scoreboard_fname;
apr_status_t ap_cleanup_shared_mem(void *d);
static int max_threads = 0;
static int max_requests_per_child = 0;
static const char *ap_pid_fname=NULL;
-API_VAR_EXPORT const char *ap_scoreboard_fname=NULL;
+AP_DECLARE_DATA const char *ap_scoreboard_fname=NULL;
static int num_daemons=0;
static int curr_child_num=0;
static int workers_may_exit = 0;
char ap_coredump_dir[MAX_STRING_LEN];
-module MODULE_VAR_EXPORT mpm_perchild_module;
+module AP_MODULE_DECLARE_DATA mpm_perchild_module;
static apr_file_t *pipe_of_death_in = NULL;
static apr_file_t *pipe_of_death_out = NULL;
static const char *lock_fname;
static pthread_mutex_t thread_accept_mutex = PTHREAD_MUTEX_INITIALIZER;
-API_EXPORT(int) ap_get_max_daemons(void)
+AP_DECLARE(int) ap_get_max_daemons(void)
{
return ap_max_daemons_limit;
}
return c;
}
-module MODULE_VAR_EXPORT mpm_perchild_module = {
+module AP_MODULE_DECLARE_DATA mpm_perchild_module = {
MPM20_MODULE_STUFF,
NULL, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
static int max_spare_threads=0;
static int ap_daemons_limit=0;
static time_t ap_restart_time=0;
-API_VAR_EXPORT int ap_extended_status = 0;
+AP_DECLARE_DATA int ap_extended_status = 0;
static int workers_may_exit = 0;
static int requests_this_child;
static int num_listenfds = 0;
int raise_sigstop_flags;
#endif
-API_EXPORT(int) ap_get_max_daemons(void)
+AP_DECLARE(int) ap_get_max_daemons(void)
{
return ap_max_daemons_limit;
}
{ NULL }
};
-module MODULE_VAR_EXPORT mpm_mpmt_beos_module = {
+module AP_MODULE_DECLARE_DATA mpm_mpmt_beos_module = {
MPM20_MODULE_STUFF,
NULL, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
ap_scoreboard_image = NULL;
}
-API_EXPORT(int) ap_exists_scoreboard_image(void)
+AP_DECLARE(int) ap_exists_scoreboard_image(void)
{
return (ap_scoreboard_image ? 1 : 0);
}
#include <sys/times.h>
#include "mpm_default.h" /* For HARD_.*_LIMIT */
-API_EXPORT(int) ap_exists_scoreboard_image(void);
+AP_DECLARE(int) ap_exists_scoreboard_image(void);
void reinit_scoareboard(apr_pool_t *p);
void cleanup_scoreboard(void);
void ap_mpmt_beos_set_maintain_connection_status(int flag);
void ap_mpmt_beos_force_reset_connection_status(long conn_id);
void reinit_scoreboard(apr_pool_t *p);
void update_scoreboard_global(void);
-API_EXPORT(int) find_child_by_pid(int pid);
+AP_DECLARE(int) find_child_by_pid(int pid);
int ap_update_child_status(int child_num, int thread_num, int status, request_rec *r);
void ap_time_process_request(int child_num, int thread_num, int status);
int ap_threads_per_child=0; /* Worker threads per child */
int ap_max_requests_per_child=0;
static const char *ap_pid_fname=NULL;
-API_VAR_EXPORT const char *ap_scoreboard_fname=NULL;
+AP_DECLARE_DATA const char *ap_scoreboard_fname=NULL;
static int ap_daemons_to_start=0;
static int min_spare_threads=0;
static int max_spare_threads=0;
static int ap_daemons_limit=0;
static time_t ap_restart_time=0;
-API_VAR_EXPORT int ap_extended_status = 0;
+AP_DECLARE_DATA int ap_extended_status = 0;
static int workers_may_exit = 0;
static int requests_this_child;
static int num_listensocks = 0;
#define SAFE_ACCEPT(stmt) (stmt)
#endif
-API_EXPORT(int) ap_get_max_daemons(void)
+AP_DECLARE(int) ap_get_max_daemons(void)
{
return ap_max_daemons_limit;
}
{ NULL }
};
-module MODULE_VAR_EXPORT mpm_mpmt_pthread_module = {
+module AP_MODULE_DECLARE_DATA mpm_mpmt_pthread_module = {
MPM20_MODULE_STUFF,
NULL, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
{
}
-API_EXPORT(int) ap_exists_scoreboard_image(void)
+AP_DECLARE(int) ap_exists_scoreboard_image(void)
{
return (ap_scoreboard_image ? 1 : 0);
}
}
-API_EXPORT(int) find_child_by_pid(apr_proc_t *pid)
+AP_DECLARE(int) find_child_by_pid(apr_proc_t *pid)
{
int i;
int max_daemons_limit = ap_get_max_daemons();
#define SCOREBOARD_FRAMES SCOREBOARD_SIZE/4095 + 1
#endif
-API_EXPORT(int) ap_exists_scoreboard_image(void);
+AP_DECLARE(int) ap_exists_scoreboard_image(void);
void reinit_scoreboard(apr_pool_t *p);
apr_status_t ap_cleanup_shared_mem(void *d);
-API_EXPORT(void) ap_sync_scoreboard_image(void);
+AP_DECLARE(void) ap_sync_scoreboard_image(void);
void ap_mpmt_pthread_force_reset_connection_status(long conn_id);
-API_EXPORT(void) reopen_scoreboard(apr_pool_t *p);
+AP_DECLARE(void) reopen_scoreboard(apr_pool_t *p);
apr_inline void ap_sync_scoreboard_image(void);
void increment_counts(int child_num, int thread_num, request_rec *r);
void update_scoreboard_global(void);
-API_EXPORT(int) find_child_by_pid(apr_proc_t *pid);
+AP_DECLARE(int) find_child_by_pid(apr_proc_t *pid);
int ap_update_child_status(int child_num, int thread_num, int status, request_rec *r);
void ap_time_process_request(int child_num, int thread_num, int status);
-API_VAR_EXPORT extern scoreboard *ap_scoreboard_image;
-API_VAR_EXPORT extern const char *ap_scoreboard_fname;
+AP_DECLARE_DATA extern scoreboard *ap_scoreboard_image;
+AP_DECLARE_DATA extern const char *ap_scoreboard_fname;
-API_VAR_EXPORT extern ap_generation_t volatile ap_my_generation;
+AP_DECLARE_DATA extern ap_generation_t volatile ap_my_generation;
/* for time_process_request() in http_main.c */
#define START_PREQUEST 1
static int max_threads = 0;
static int max_requests_per_child = 0;
static const char *ap_pid_fname=NULL;
-API_VAR_EXPORT const char *ap_scoreboard_fname=NULL;
+AP_DECLARE_DATA const char *ap_scoreboard_fname=NULL;
static int num_daemons=0;
static int curr_child_num=0;
static int workers_may_exit = 0;
char ap_coredump_dir[MAX_STRING_LEN];
-module MODULE_VAR_EXPORT mpm_perchild_module;
+module AP_MODULE_DECLARE_DATA mpm_perchild_module;
static apr_file_t *pipe_of_death_in = NULL;
static apr_file_t *pipe_of_death_out = NULL;
static const char *lock_fname;
static pthread_mutex_t thread_accept_mutex = PTHREAD_MUTEX_INITIALIZER;
-API_EXPORT(int) ap_get_max_daemons(void)
+AP_DECLARE(int) ap_get_max_daemons(void)
{
return ap_max_daemons_limit;
}
return c;
}
-module MODULE_VAR_EXPORT mpm_perchild_module = {
+module AP_MODULE_DECLARE_DATA mpm_perchild_module = {
MPM20_MODULE_STUFF,
NULL, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
/* The generic shared memory chunk code */
void reinit_scoreboard(apr_pool_t *p);
-API_EXPORT(void) reopen_scoreboard(apr_pool_t *p);
+AP_DECLARE(void) reopen_scoreboard(apr_pool_t *p);
/* The stuff for perchild's status table */
#define SCOREBOARD_SIZE sizeof(scoreboard)
-API_VAR_EXPORT extern const char *ap_scoreboard_fname;
+AP_DECLARE_DATA extern const char *ap_scoreboard_fname;
apr_status_t ap_cleanup_shared_mem(void *d);
#ifdef __cplusplus
char tpf_server_name[INETD_SERVNAME_LENGTH+1];
#endif /* TPF */
-API_VAR_EXPORT scoreboard *ap_scoreboard_image = NULL;
+AP_DECLARE_DATA scoreboard *ap_scoreboard_image = NULL;
static new_scoreboard *ap_new_scoreboard_image = NULL;
#ifdef GPROF
#endif
}
-API_EXPORT(int) ap_exists_scoreboard_image(void)
+AP_DECLARE(int) ap_exists_scoreboard_image(void)
{
return (ap_scoreboard_image ? 1 : 0);
}
-API_EXPORT(int) ap_get_max_daemons(void)
+AP_DECLARE(int) ap_get_max_daemons(void)
{
return ap_max_daemons_limit;
}
{ NULL }
};
-module MODULE_VAR_EXPORT mpm_prefork_module = {
+module AP_MODULE_DECLARE_DATA mpm_prefork_module = {
MPM20_MODULE_STUFF,
NULL, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
#define SCOREBOARD_FRAMES SCOREBOARD_SIZE/4095 + 1
#endif
-API_EXPORT(void) ap_sync_scoreboard_image(void);
-API_EXPORT(int) ap_exists_scoreboard_image(void);
+AP_DECLARE(void) ap_sync_scoreboard_image(void);
+AP_DECLARE(int) ap_exists_scoreboard_image(void);
-API_VAR_EXPORT extern scoreboard *ap_scoreboard_image;
+AP_DECLARE_DATA extern scoreboard *ap_scoreboard_image;
-API_VAR_EXPORT extern ap_generation_t volatile ap_my_generation;
+AP_DECLARE_DATA extern ap_generation_t volatile ap_my_generation;
/* for time_process_request() in http_main.c */
#define START_PREQUEST 1
#define SCOREBOARD_FRAMES SCOREBOARD_SIZE/4095 + 1
#endif
-API_EXPORT(int) ap_exists_scoreboard_image(void);
+AP_DECLARE(int) ap_exists_scoreboard_image(void);
-API_VAR_EXPORT extern scoreboard *ap_scoreboard_image;
+AP_DECLARE_DATA extern scoreboard *ap_scoreboard_image;
/* for time_process_request() in http_main.c */
#define SAFE_ACCEPT(stmt) do {stmt;} while(0)
#endif
-API_EXPORT(int) ap_exists_scoreboard_image(void)
+AP_DECLARE(int) ap_exists_scoreboard_image(void)
{
return (ap_scoreboard_image ? 1 : 0);
}
-API_EXPORT(int) ap_get_max_daemons(void)
+AP_DECLARE(int) ap_get_max_daemons(void)
{
return max_daemons_limit;
}
* Child process main loop.
*/
-API_EXPORT(void) ap_child_terminate(request_rec *r)
+AP_DECLARE(void) ap_child_terminate(request_rec *r)
{
r->connection->keepalive = 0;
ap_scoreboard_image->parent[THREAD_GLOBAL(child_num)].deferred_die = 1;
/* Stub functions until this MPM supports the connection status API */
-API_EXPORT(void) ap_update_connection_status(long conn_id, const char *key, \
+AP_DECLARE(void) ap_update_connection_status(long conn_id, const char *key, \
const char *value)
{
/* NOP */
}
-API_EXPORT(void) ap_reset_connection_status(long conn_id)
+AP_DECLARE(void) ap_reset_connection_status(long conn_id)
{
/* NOP */
}
{ NULL }
};
-module MODULE_VAR_EXPORT mpm_spmt_os2_module = {
+module AP_MODULE_DECLARE_DATA mpm_spmt_os2_module = {
MPM20_MODULE_STUFF,
NULL, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
static int volatile is_graceful = 0;
-API_EXPORT(int) ap_graceful_stop_signalled(void)
+AP_DECLARE(int) ap_graceful_stop_signalled(void)
{
return is_graceful;
}
-API_EXPORT(void) ap_start_shutdown(void)
+AP_DECLARE(void) ap_start_shutdown(void)
{
signal_parent(0);
}
-API_EXPORT(void) ap_start_restart(int gracefully)
+AP_DECLARE(void) ap_start_restart(int gracefully)
{
is_graceful = gracefully;
signal_parent(1);
}
}
-API_EXPORT(int) ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s )
+AP_DECLARE(int) ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s )
{
static int restart = 0; /* Default is "not a restart" */
/* Stub functions until this MPM supports the connection status API */
-API_EXPORT(void) ap_update_connection_status(long conn_id, const char *key, \
+AP_DECLARE(void) ap_update_connection_status(long conn_id, const char *key, \
const char *value)
{
/* NOP */
}
-API_EXPORT(void) ap_reset_connection_status(long conn_id)
+AP_DECLARE(void) ap_reset_connection_status(long conn_id)
{
/* NOP */
}
-API_EXPORT(apr_array_header_t *) ap_get_status_table(apr_pool_t *p)
+AP_DECLARE(apr_array_header_t *) ap_get_status_table(apr_pool_t *p)
{
/* NOP */
return NULL;
{ NULL }
};
-MODULE_VAR_EXPORT module mpm_winnt_module = {
+AP_MODULE_DECLARE_DATA module mpm_winnt_module = {
MPM20_MODULE_STUFF,
winnt_rewrite_args, /* hook to run before apache parses args */
NULL, /* create per-directory config structure */
extern int ap_extended_status;
extern void clean_child_exit(int);
-API_EXPORT(void) ap_start_shutdown(void);
-API_EXPORT(void) ap_start_restart(int gracefully);
+AP_DECLARE(void) ap_start_shutdown(void);
+AP_DECLARE(void) ap_start_restart(int gracefully);
void setup_signal_names(char *prefix);
void signal_parent(int type);
* Examine a field value (such as a media-/content-type) string and return
* it sans any parameters; e.g., strip off any ';charset=foo' and the like.
*/
-API_EXPORT(char *) ap_field_noparam(apr_pool_t *p, const char *intype)
+AP_DECLARE(char *) ap_field_noparam(apr_pool_t *p, const char *intype)
{
const char *semi;
}
}
-API_EXPORT(char *) ap_ht_time(apr_pool_t *p, apr_time_t t, const char *fmt, int gmt)
+AP_DECLARE(char *) ap_ht_time(apr_pool_t *p, apr_time_t t, const char *fmt, int gmt)
{
apr_size_t retcode;
char ts[MAX_STRING_LEN];
* Based loosely on sections of wildmat.c by Rich Salz
* Hmmm... shouldn't this really go component by component?
*/
-API_EXPORT(int) ap_strcmp_match(const char *str, const char *exp)
+AP_DECLARE(int) ap_strcmp_match(const char *str, const char *exp)
{
int x, y;
return (str[x] != '\0');
}
-API_EXPORT(int) ap_strcasecmp_match(const char *str, const char *exp)
+AP_DECLARE(int) ap_strcasecmp_match(const char *str, const char *exp)
{
int x, y;
return (str[x] != '\0');
}
-API_EXPORT(int) ap_is_matchexp(const char *str)
+AP_DECLARE(int) ap_is_matchexp(const char *str)
{
register int x;
return APR_SUCCESS;
}
-API_EXPORT(regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,
+AP_DECLARE(regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,
int cflags)
{
regex_t *preg = apr_palloc(p, sizeof(regex_t));
return preg;
}
-API_EXPORT(void) ap_pregfree(apr_pool_t *p, regex_t * reg)
+AP_DECLARE(void) ap_pregfree(apr_pool_t *p, regex_t * reg)
{
regfree(reg);
apr_kill_cleanup(p, (void *) reg, regex_cleanup);
* Similar to standard strstr() but we ignore case in this version.
* Based on the strstr() implementation further below.
*/
-API_EXPORT(char *) ap_strcasestr(const char *s1, const char *s2)
+AP_DECLARE(char *) ap_strcasestr(const char *s1, const char *s2)
{
char *p1, *p2;
if (*s2 == '\0') {
* can use standard pointer comparisons in the calling function
* (eg: test if ap_stripprefix(a,b) == a)
*/
-API_EXPORT(char *) ap_stripprefix(const char *bigstring, const char *prefix)
+AP_DECLARE(char *) ap_stripprefix(const char *bigstring, const char *prefix)
{
char *p1;
if (*prefix == '\0') {
* This is especially important for the DSO situations of modules.
* DO NOT MAKE A MACRO OUT OF THIS FUNCTION!
*/
-API_EXPORT(int) ap_regexec(regex_t *preg, const char *string,
+AP_DECLARE(int) ap_regexec(regex_t *preg, const char *string,
size_t nmatch, regmatch_t pmatch[], int eflags)
{
return regexec(preg, string, nmatch, pmatch, eflags);
}
-API_EXPORT(size_t) ap_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
+AP_DECLARE(size_t) ap_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
{
return regerror(errcode, preg, errbuf, errbuf_size);
}
* AT&T V8 regexp package.
*/
-API_EXPORT(char *) ap_pregsub(apr_pool_t *p, const char *input, const char *source,
+AP_DECLARE(char *) ap_pregsub(apr_pool_t *p, const char *input, const char *source,
size_t nmatch, regmatch_t pmatch[])
{
const char *src = input;
/*
* Parse .. so we don't compromise security
*/
-API_EXPORT(void) ap_getparents(char *name)
+AP_DECLARE(void) ap_getparents(char *name)
{
int l, w;
}
}
-API_EXPORT(void) ap_no2slash(char *name)
+AP_DECLARE(void) ap_no2slash(char *name)
{
char *d, *s;
* /a/b, 3 ==> /a/b/
* /a/b, 4 ==> /a/b/
*/
-API_EXPORT(char *) ap_make_dirstr_prefix(char *d, const char *s, int n)
+AP_DECLARE(char *) ap_make_dirstr_prefix(char *d, const char *s, int n)
{
#if defined(HAVE_DRIVE_LETTERS) || defined(NETWARE)
if (!n) {
/*
* return the parent directory name including trailing / of the file s
*/
-API_EXPORT(char *) ap_make_dirstr_parent(apr_pool_t *p, const char *s)
+AP_DECLARE(char *) ap_make_dirstr_parent(apr_pool_t *p, const char *s)
{
const char *last_slash = ap_strrchr_c(s, '/');
char *d;
}
-API_EXPORT(int) ap_count_dirs(const char *path)
+AP_DECLARE(int) ap_count_dirs(const char *path)
{
register int x, n;
}
-API_EXPORT(void) ap_chdir_file(const char *file)
+AP_DECLARE(void) ap_chdir_file(const char *file)
{
const char *x;
char buf[HUGE_STRING_LEN];
* error... ah well. */
}
-API_EXPORT(char *) ap_getword_nc(apr_pool_t *atrans, char **line, char stop)
+AP_DECLARE(char *) ap_getword_nc(apr_pool_t *atrans, char **line, char stop)
{
return ap_getword(atrans, (const char **) line, stop);
}
-API_EXPORT(char *) ap_getword(apr_pool_t *atrans, const char **line, char stop)
+AP_DECLARE(char *) ap_getword(apr_pool_t *atrans, const char **line, char stop)
{
const char *pos = ap_strchr_c(*line, stop);
char *res;
return res;
}
-API_EXPORT(char *) ap_getword_white_nc(apr_pool_t *atrans, char **line)
+AP_DECLARE(char *) ap_getword_white_nc(apr_pool_t *atrans, char **line)
{
return ap_getword_white(atrans, (const char **) line);
}
-API_EXPORT(char *) ap_getword_white(apr_pool_t *atrans, const char **line)
+AP_DECLARE(char *) ap_getword_white(apr_pool_t *atrans, const char **line)
{
int pos = -1, x;
char *res;
return res;
}
-API_EXPORT(char *) ap_getword_nulls_nc(apr_pool_t *atrans, char **line, char stop)
+AP_DECLARE(char *) ap_getword_nulls_nc(apr_pool_t *atrans, char **line, char stop)
{
return ap_getword_nulls(atrans, (const char **) line, stop);
}
-API_EXPORT(char *) ap_getword_nulls(apr_pool_t *atrans, const char **line, char stop)
+AP_DECLARE(char *) ap_getword_nulls(apr_pool_t *atrans, const char **line, char stop)
{
const char *pos = ap_strchr_c(*line, stop);
char *res;
#endif
}
-API_EXPORT(char *) ap_getword_conf_nc(apr_pool_t *p, char **line)
+AP_DECLARE(char *) ap_getword_conf_nc(apr_pool_t *p, char **line)
{
return ap_getword_conf(p, (const char **) line);
}
-API_EXPORT(char *) ap_getword_conf(apr_pool_t *p, const char **line)
+AP_DECLARE(char *) ap_getword_conf(apr_pool_t *p, const char **line)
{
const char *str = *line, *strend;
char *res;
* environment value does not exist, leave the ${ENV}
* construct alone; it means something else.
*/
-API_EXPORT(const char *) ap_resolve_env(apr_pool_t *p, const char * word)
+AP_DECLARE(const char *) ap_resolve_env(apr_pool_t *p, const char * word)
{
char tmp[ MAX_STRING_LEN ];
const char *s, *e;
return apr_pstrdup(p,tmp);
}
-API_EXPORT(int) ap_cfg_closefile(configfile_t *cfp)
+AP_DECLARE(int) ap_cfg_closefile(configfile_t *cfp)
{
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, NULL,
}
/* Open a configfile_t as FILE, return open configfile_t struct pointer */
-API_EXPORT(apr_status_t) ap_pcfg_openfile(configfile_t **ret_cfg, apr_pool_t *p, const char *name)
+AP_DECLARE(apr_status_t) ap_pcfg_openfile(configfile_t **ret_cfg, apr_pool_t *p, const char *name)
{
configfile_t *new_cfg;
apr_file_t *file = NULL;
/* Allocate a configfile_t handle with user defined functions and params */
-API_EXPORT(configfile_t *) ap_pcfg_open_custom(apr_pool_t *p, const char *descr,
+AP_DECLARE(configfile_t *) ap_pcfg_open_custom(apr_pool_t *p, const char *descr,
void *param,
int(*getch)(void *param),
void *(*getstr) (void *buf, size_t bufsiz, void *param),
/* Read one character from a configfile_t */
-API_EXPORT(int) ap_cfg_getc(configfile_t *cfp)
+AP_DECLARE(int) ap_cfg_getc(configfile_t *cfp)
{
register int ch = cfp->getch(cfp->param);
if (ch == LF)
/* Read one line from open configfile_t, strip LF, increase line number */
/* If custom handler does not define a getstr() function, read char by char */
-API_EXPORT(int) ap_cfg_getline(char *buf, size_t bufsize, configfile_t *cfp)
+AP_DECLARE(int) ap_cfg_getline(char *buf, size_t bufsize, configfile_t *cfp)
{
/* If a "get string" function is defined, use it */
if (cfp->getstr != NULL) {
* of field is shifted to the next non-comma, non-whitespace character.
* len is the length of the item excluding any beginning whitespace.
*/
-API_EXPORT(const char *) ap_size_list_item(const char **field, int *len)
+AP_DECLARE(const char *) ap_size_list_item(const char **field, int *len)
{
const unsigned char *ptr = (const unsigned char *)*field;
const unsigned char *token;
* the converted list item (or NULL if none) and the address pointed to by
* field is shifted to the next non-comma, non-whitespace.
*/
-API_EXPORT(char *) ap_get_list_item(apr_pool_t *p, const char **field)
+AP_DECLARE(char *) ap_get_list_item(apr_pool_t *p, const char **field)
{
const char *tok_start;
const unsigned char *ptr;
* This would be much more efficient if we stored header fields as
* an array of list items as they are received instead of a plain string.
*/
-API_EXPORT(int) ap_find_list_item(apr_pool_t *p, const char *line, const char *tok)
+AP_DECLARE(int) ap_find_list_item(apr_pool_t *p, const char *line, const char *tok)
{
const unsigned char *pos;
const unsigned char *ptr = (const unsigned char *)line;
* by whitespace at the caller's option.
*/
-API_EXPORT(char *) ap_get_token(apr_pool_t *p, const char **accept_line, int accept_white)
+AP_DECLARE(char *) ap_get_token(apr_pool_t *p, const char **accept_line, int accept_white)
{
const char *ptr = *accept_line;
const char *tok_start;
/* find http tokens, see the definition of token from RFC2068 */
-API_EXPORT(int) ap_find_token(apr_pool_t *p, const char *line, const char *tok)
+AP_DECLARE(int) ap_find_token(apr_pool_t *p, const char *line, const char *tok)
{
const unsigned char *start_token;
const unsigned char *s;
}
-API_EXPORT(int) ap_find_last_token(apr_pool_t *p, const char *line, const char *tok)
+AP_DECLARE(int) ap_find_last_token(apr_pool_t *p, const char *line, const char *tok)
{
int llen, tlen, lidx;
return (strncasecmp(&line[lidx], tok, tlen) == 0);
}
-API_EXPORT(char *) ap_escape_shell_cmd(apr_pool_t *p, const char *str)
+AP_DECLARE(char *) ap_escape_shell_cmd(apr_pool_t *p, const char *str)
{
char *cmd;
unsigned char *d;
* decoding %2f -> / (a special character)
* returns HTTP_NOT_FOUND
*/
-API_EXPORT(int) ap_unescape_url(char *url)
+AP_DECLARE(int) ap_unescape_url(char *url)
{
register int badesc, badpath;
char *x, *y;
return OK;
}
-API_EXPORT(char *) ap_construct_server(apr_pool_t *p, const char *hostname,
+AP_DECLARE(char *) ap_construct_server(apr_pool_t *p, const char *hostname,
unsigned port, const request_rec *r)
{
if (ap_is_default_port(port, r))
* something with a '/' in it (and thus does not prefix "./").
*/
-API_EXPORT(char *) ap_escape_path_segment(apr_pool_t *p, const char *segment)
+AP_DECLARE(char *) ap_escape_path_segment(apr_pool_t *p, const char *segment)
{
char *copy = apr_palloc(p, 3 * strlen(segment) + 1);
const unsigned char *s = (const unsigned char *)segment;
return copy;
}
-API_EXPORT(char *) ap_os_escape_path(apr_pool_t *p, const char *path, int partial)
+AP_DECLARE(char *) ap_os_escape_path(apr_pool_t *p, const char *path, int partial)
{
char *copy = apr_palloc(p, 3 * strlen(path) + 3);
const unsigned char *s = (const unsigned char *)path;
/* ap_escape_uri is now a macro for os_escape_path */
-API_EXPORT(char *) ap_escape_html(apr_pool_t *p, const char *s)
+AP_DECLARE(char *) ap_escape_html(apr_pool_t *p, const char *s)
{
int i, j;
char *x;
return x;
}
-API_EXPORT(int) ap_is_directory(const char *path)
+AP_DECLARE(int) ap_is_directory(const char *path)
{
apr_finfo_t finfo;
return (finfo.filetype == APR_DIR);
}
-API_EXPORT(int) ap_is_rdirectory(const char *path)
+AP_DECLARE(int) ap_is_rdirectory(const char *path)
{
apr_finfo_t finfo;
return (finfo.filetype == APR_DIR);
}
-API_EXPORT(char *) ap_make_full_path(apr_pool_t *a, const char *src1,
+AP_DECLARE(char *) ap_make_full_path(apr_pool_t *a, const char *src1,
const char *src2)
{
register int x;
/*
* Check for an absoluteURI syntax (see section 3.2 in RFC2068).
*/
-API_EXPORT(int) ap_is_url(const char *u)
+AP_DECLARE(int) ap_is_url(const char *u)
{
register int x;
}
#endif /* def NEED_INITGROUPS */
-API_EXPORT(int) ap_ind(const char *s, char c)
+AP_DECLARE(int) ap_ind(const char *s, char c)
{
register int x;
return -1;
}
-API_EXPORT(int) ap_rind(const char *s, char c)
+AP_DECLARE(int) ap_rind(const char *s, char c)
{
register int x;
return -1;
}
-API_EXPORT(void) ap_str_tolower(char *str)
+AP_DECLARE(void) ap_str_tolower(char *str)
{
while (*str) {
*str = apr_tolower(*str);
}
}
-API_EXPORT(uid_t) ap_uname2id(const char *name)
+AP_DECLARE(uid_t) ap_uname2id(const char *name)
{
#ifdef WIN32
return (1);
#endif
}
-API_EXPORT(gid_t) ap_gname2id(const char *name)
+AP_DECLARE(gid_t) ap_gname2id(const char *name)
{
#ifdef WIN32
return (1);
/* simple 'pool' alloc()ing glue to ap_base64.c
*/
-API_EXPORT(char *) ap_pbase64decode(apr_pool_t *p, const char *bufcoded)
+AP_DECLARE(char *) ap_pbase64decode(apr_pool_t *p, const char *bufcoded)
{
char *decoded;
int l;
return decoded;
}
-API_EXPORT(char *) ap_pbase64encode(apr_pool_t *p, char *string)
+AP_DECLARE(char *) ap_pbase64encode(apr_pool_t *p, char *string)
{
char *encoded;
int l = strlen(string);
* also need to compress spaces and such to be able to compare
* properly. -djg
*/
-API_EXPORT(void) ap_content_type_tolower(char *str)
+AP_DECLARE(void) ap_content_type_tolower(char *str)
{
char *semi;
/*
* Given a string, replace any bare " with \" .
*/
-API_EXPORT(char *) ap_escape_quotes (apr_pool_t *p, const char *instring)
+AP_DECLARE(char *) ap_escape_quotes (apr_pool_t *p, const char *instring)
{
int newlen = 0;
const char *inchr = instring;
apr_xlate_t *ap_locale_to_ascii, *ap_locale_from_ascii;
-API_EXPORT(apr_status_t) ap_set_content_xlate(request_rec *r, int output,
+AP_DECLARE(apr_status_t) ap_set_content_xlate(request_rec *r, int output,
apr_xlate_t *xlate)
{
apr_status_t rv;
* * - swallow remaining characters
* <x> - exact match for any other character
*/
-API_EXPORT(int) ap_checkmask(const char *data, const char *mask)
+AP_DECLARE(int) ap_checkmask(const char *data, const char *mask)
{
int i;
char d;
* but many changes since then.
*
*/
-API_EXPORT(apr_time_t) ap_parseHTTPdate(const char *date)
+AP_DECLARE(apr_time_t) ap_parseHTTPdate(const char *date)
{
apr_exploded_time_t ds;
apr_time_t result;
apr_register_cleanup(FILTER_POOL, NULL, filter_cleanup, apr_null_cleanup);
}
-API_EXPORT(void) ap_register_input_filter(const char *name,
+AP_DECLARE(void) ap_register_input_filter(const char *name,
ap_in_filter_func filter_func,
ap_filter_type ftype)
{
®istered_input_filters);
}
-API_EXPORT(void) ap_register_output_filter(const char *name,
+AP_DECLARE(void) ap_register_output_filter(const char *name,
ap_out_filter_func filter_func,
ap_filter_type ftype)
{
®istered_output_filters);
}
-API_EXPORT(void) ap_add_input_filter(const char *name, void *ctx,
+AP_DECLARE(void) ap_add_input_filter(const char *name, void *ctx,
request_rec *r, conn_rec *c)
{
ap_filter_rec_t *frec = registered_input_filters;
}
}
-API_EXPORT(void) ap_add_output_filter(const char *name, void *ctx,
+AP_DECLARE(void) ap_add_output_filter(const char *name, void *ctx,
request_rec *r, conn_rec *c)
{
ap_filter_rec_t *frec = registered_output_filters;
* save data off to the side should probably create their own temporary
* brigade especially for that use.
*/
-API_EXPORT(apr_status_t) ap_get_brigade(ap_filter_t *next,
+AP_DECLARE(apr_status_t) ap_get_brigade(ap_filter_t *next,
ap_bucket_brigade *bb, apr_ssize_t length)
{
if (next) {
* the current filter. At that point, we can just call the first filter in
* the stack, or r->output_filters.
*/
-API_EXPORT(apr_status_t) ap_pass_brigade(ap_filter_t *next, ap_bucket_brigade *bb)
+AP_DECLARE(apr_status_t) ap_pass_brigade(ap_filter_t *next, ap_bucket_brigade *bb)
{
if (next) {
ap_bucket *e;
return AP_NOBODY_WROTE;
}
-API_EXPORT(void) ap_save_brigade(ap_filter_t *f, ap_bucket_brigade **saveto,
+AP_DECLARE(void) ap_save_brigade(ap_filter_t *f, ap_bucket_brigade **saveto,
ap_bucket_brigade **b)
{
ap_bucket *e;
#include "util_md5.h"
#include "util_ebcdic.h"
-API_EXPORT(char *) ap_md5_binary(apr_pool_t *p, const unsigned char *buf, int length)
+AP_DECLARE(char *) ap_md5_binary(apr_pool_t *p, const unsigned char *buf, int length)
{
const char *hex = "0123456789abcdef";
apr_md5_ctx_t my_md5;
return apr_pstrdup(p, result);
}
-API_EXPORT(char *) ap_md5(apr_pool_t *p, const unsigned char *string)
+AP_DECLARE(char *) ap_md5(apr_pool_t *p, const unsigned char *string)
{
return ap_md5_binary(p, string, (int) strlen((char *)string));
}
static char basis_64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-API_EXPORT(char *) ap_md5contextTo64(apr_pool_t *a, apr_md5_ctx_t *context)
+AP_DECLARE(char *) ap_md5contextTo64(apr_pool_t *a, apr_md5_ctx_t *context)
{
unsigned char digest[18];
char *encodedDigest;
#ifdef APACHE_XLATE
-API_EXPORT(char *) ap_md5digest(apr_pool_t *p, apr_file_t *infile,
+AP_DECLARE(char *) ap_md5digest(apr_pool_t *p, apr_file_t *infile,
apr_xlate_t *xlate)
{
apr_md5_ctx_t context;
#else
-API_EXPORT(char *) ap_md5digest(apr_pool_t *p, apr_file_t *infile)
+AP_DECLARE(char *) ap_md5digest(apr_pool_t *p, apr_file_t *infile)
{
apr_md5_ctx_t context;
unsigned char buf[1000];
return res;
}
-API_EXPORT(char **) ap_create_environment(apr_pool_t *p, apr_table_t *t)
+AP_DECLARE(char **) ap_create_environment(apr_pool_t *p, apr_table_t *t)
{
apr_array_header_t *env_arr = apr_table_elts(t);
apr_table_entry_t *elts = (apr_table_entry_t *) env_arr->elts;
return env;
}
-API_EXPORT(void) ap_add_common_vars(request_rec *r)
+AP_DECLARE(void) ap_add_common_vars(request_rec *r)
{
apr_table_t *e;
server_rec *s = r->server;
* and find as much of the two that match as possible.
*/
-API_EXPORT(int) ap_find_path_info(const char *uri, const char *path_info)
+AP_DECLARE(int) ap_find_path_info(const char *uri, const char *path_info)
{
int lu = strlen(uri);
int lp = strlen(path_info);
return apr_pstrndup(r->pool, first, last - first);
}
-API_EXPORT(void) ap_add_cgi_vars(request_rec *r)
+AP_DECLARE(void) ap_add_cgi_vars(request_rec *r)
{
apr_table_t *e = r->subprocess_env;
return 1;
}
-API_EXPORT(int) ap_scan_script_header_err_core(request_rec *r, char *buffer,
+AP_DECLARE(int) ap_scan_script_header_err_core(request_rec *r, char *buffer,
int (*getsfunc) (char *, int, void *),
void *getsfunc_data)
{
return apr_fgets(buf, len, (apr_file_t *) f) == APR_SUCCESS;
}
-API_EXPORT(int) ap_scan_script_header_err(request_rec *r, apr_file_t *f,
+AP_DECLARE(int) ap_scan_script_header_err(request_rec *r, apr_file_t *f,
char *buffer)
{
return ap_scan_script_header_err_core(r, buffer, getsfunc_FILE, f);
* character is returned to **arg, **data. (The first optional arg is
* counted as 0.)
*/
-API_EXPORT_NONSTD(int) ap_scan_script_header_err_strs(request_rec *r,
+AP_DECLARE_NONSTD(int) ap_scan_script_header_err_strs(request_rec *r,
char *buffer,
const char **termch,
int *termarg, ...)
return res;
}
-API_EXPORT(void) ap_send_size(apr_ssize_t size, request_rec *r)
+AP_DECLARE(void) ap_send_size(apr_ssize_t size, request_rec *r)
{
/* XXX: this -1 thing is a gross hack */
if (size == (apr_ssize_t)-1) {
};
-API_EXPORT(unsigned short) ap_default_port_for_scheme(const char *scheme_str)
+AP_DECLARE(unsigned short) ap_default_port_for_scheme(const char *scheme_str)
{
schemes_t *scheme;
return 0;
}
-API_EXPORT(unsigned short) ap_default_port_for_request(const request_rec *r)
+AP_DECLARE(unsigned short) ap_default_port_for_request(const request_rec *r)
{
return (r->parsed_uri.scheme)
? ap_default_port_for_scheme(r->parsed_uri.scheme)
* from a call to gethostbyname() and lives in static storage.
* By creating a copy we can tuck it away for later use.
*/
-API_EXPORT(struct hostent *) ap_pduphostent(apr_pool_t *p, const struct hostent *hp)
+AP_DECLARE(struct hostent *) ap_pduphostent(apr_pool_t *p, const struct hostent *hp)
{
struct hostent *newent;
char **ptrs;
* COPY OF the hostent structure, intended to be stored and used later.
* (gethostbyname() uses static storage that would be overwritten on each call)
*/
-API_EXPORT(struct hostent *) ap_pgethostbyname(apr_pool_t *p, const char *hostname)
+AP_DECLARE(struct hostent *) ap_pgethostbyname(apr_pool_t *p, const char *hostname)
{
struct hostent *hp = gethostbyname(hostname);
return (hp == NULL) ? NULL : ap_pduphostent(p, hp);
/* Unparse a uri_components structure to an URI string.
* Optionally suppress the password for security reasons.
*/
-API_EXPORT(char *) ap_unparse_uri_components(apr_pool_t *p, const uri_components *uptr, unsigned flags)
+AP_DECLARE(char *) ap_unparse_uri_components(apr_pool_t *p, const uri_components *uptr, unsigned flags)
{
char *ret = "";
static regex_t re_uri;
static regex_t re_hostpart;
-API_EXPORT(void) ap_util_uri_init(void)
+AP_DECLARE(void) ap_util_uri_init(void)
{
int ret;
const char *re_str;
* - fills in fields of uri_components *uptr
* - none on any of the r->* fields
*/
-API_EXPORT(int) ap_parse_uri_components(apr_pool_t *p, const char *uri, uri_components *uptr)
+AP_DECLARE(int) ap_parse_uri_components(apr_pool_t *p, const char *uri, uri_components *uptr)
{
int ret;
regmatch_t match[10]; /* This must have at least as much elements
#define NOTEND_HOSTINFO (T_SLASH | T_QUESTION | T_HASH | T_NUL)
#define NOTEND_PATH (T_QUESTION | T_HASH | T_NUL)
-API_EXPORT(void) ap_util_uri_init(void)
+AP_DECLARE(void) ap_util_uri_init(void)
{
/* nothing to do */
}
* - fills in fields of uri_components *uptr
* - none on any of the r->* fields
*/
-API_EXPORT(int) ap_parse_uri_components(apr_pool_t *p, const char *uri, uri_components *uptr)
+AP_DECLARE(int) ap_parse_uri_components(apr_pool_t *p, const char *uri, uri_components *uptr)
{
const char *s;
const char *s1;
* currently at http://www.mcom.com/newsref/std/tunneling_ssl.html
* for the format of the "CONNECT host:port HTTP/1.0" request
*/
-API_EXPORT(int) ap_parse_hostinfo_components(apr_pool_t *p, const char *hostinfo, uri_components *uptr)
+AP_DECLARE(int) ap_parse_hostinfo_components(apr_pool_t *p, const char *hostinfo, uri_components *uptr)
{
const char *s;
char *endstr;
ap_text_append(ctx->p, hdr, s);
}
-API_EXPORT(int) ap_xml_parse_input(request_rec * r, ap_xml_doc **pdoc)
+AP_DECLARE(int) ap_xml_parse_input(request_rec * r, ap_xml_doc **pdoc)
{
int result;
ap_xml_ctx ctx =
return HTTP_BAD_REQUEST;
}
-API_EXPORT(void) ap_text_append(apr_pool_t * p, ap_text_header *hdr,
+AP_DECLARE(void) ap_text_append(apr_pool_t * p, ap_text_header *hdr,
const char *text)
{
ap_text *t = apr_palloc(p, sizeof(*t));
** quotes is typically set to true for XML strings that will occur within
** double quotes -- attribute values.
*/
-API_EXPORT(const char *) ap_xml_quote_string(apr_pool_t *p, const char *s,
+AP_DECLARE(const char *) ap_xml_quote_string(apr_pool_t *p, const char *s,
int quotes)
{
const char *scan;
return s;
}
-API_EXPORT(void) ap_xml_quote_elem(apr_pool_t *p, ap_xml_elem *elem)
+AP_DECLARE(void) ap_xml_quote_elem(apr_pool_t *p, ap_xml_elem *elem)
{
ap_text *scan_txt;
ap_xml_attr *scan_attr;
}
/* convert an element to a text string */
-API_EXPORT(void) ap_xml_to_text(apr_pool_t * p, const ap_xml_elem *elem,
+AP_DECLARE(void) ap_xml_to_text(apr_pool_t * p, const ap_xml_elem *elem,
int style, apr_array_header_t *namespaces,
int *ns_map, const char **pbuf, size_t *psize)
{
*psize = size;
}
-API_EXPORT(const char *) ap_xml_empty_elem(apr_pool_t * p,
+AP_DECLARE(const char *) ap_xml_empty_elem(apr_pool_t * p,
const ap_xml_elem *elem)
{
if (elem->ns == AP_XML_NS_NONE) {
}
/* return the URI's (existing) index, or insert it and return a new index */
-API_EXPORT(int) ap_xml_insert_uri(apr_array_header_t *uri_array,
+AP_DECLARE(int) ap_xml_insert_uri(apr_array_header_t *uri_array,
const char *uri)
{
int i;
* we just call it a match. But here we require the host:port to match
* the ServerName and/or ServerAliases.
*/
-API_EXPORT(int) ap_matches_request_vhost(request_rec *r, const char *host,
+AP_DECLARE(int) ap_matches_request_vhost(request_rec *r, const char *host,
unsigned port)
{
server_rec *s;
open(FP, "<$base.c");
my $content = join('', <FP>);
close(FP);
- if ($content =~ m|.*module\s+(?:MODULE_VAR_EXPORT\s+)?([a-zA-Z0-9_]+)_module\s*=\s*.*|s) {
+ if ($content =~ m|.*module\s+(?:AP_MODULE_DECLARE_DATA\s+)?([a-zA-Z0-9_]+)_module\s*=\s*.*|s) {
$name = "$1";
$filename = "$base.c";
$filename =~ s|^[^/]+/||;
};
/* Dispatch list for API hooks */
-module MODULE_VAR_EXPORT %NAME%_module = {
+module AP_MODULE_DECLARE_DATA %NAME%_module = {
STANDARD20_MODULE_STUFF,
NULL, /* create per-dir config structures */
NULL, /* merge per-dir config structures */
*
* Roy Fielding, 1996
*/
-#define API_EXPORT(x) x
+#define AP_DECLARE(x) x
#include <stdio.h>
#include <stdlib.h>
void *ap_dummy_mutex = &ap_dummy_mutex;
char *ap_server_argv0;
-API_EXPORT(void) ap_block_alarms(void)
+AP_DECLARE(void) ap_block_alarms(void)
{
;
}
-API_EXPORT(void) ap_unblock_alarms(void)
+AP_DECLARE(void) ap_unblock_alarms(void)
{
;
}
-API_EXPORT(void) ap_log_error(const char *file, int line, int level,
+AP_DECLARE(void) ap_log_error(const char *file, int line, int level,
const request_rec *r, const char *fmt, ...)
{
;
void *ap_dummy_mutex = &ap_dummy_mutex;
char *ap_server_argv0;
-API_EXPORT(void) ap_block_alarms(void)
+AP_DECLARE(void) ap_block_alarms(void)
{
;
}
-API_EXPORT(void) ap_unblock_alarms(void)
+AP_DECLARE(void) ap_unblock_alarms(void)
{
;
}
-API_EXPORT(void) ap_log_error(const char *file, int line, int level,
+AP_DECLARE(void) ap_log_error(const char *file, int line, int level,
const request_rec *r, const char *fmt, ...)
{
;
projects / apache / commitdiff