1
{ Licensed to the Apache Software Foundation (ASF) under one or more
2
* contributor license agreements. See the NOTICE file distributed with
3
* this work for additional information regarding copyright ownership.
4
* The ASF licenses this file to You under the Apache License, Version 2.0
5
* (the "License"); you may not use this file except in compliance with
6
* the License. You may obtain a copy of the License at
8
* http://www.apache.org/licenses/LICENSE-2.0
10
* Unless required by applicable law or agreed to in writing, software
11
* distributed under the License is distributed on an "AS IS" BASIS,
12
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
18
{$include apr/apr_hash.inc}
19
{#include "apr_optional.h"}
20
{$include util_filter.inc}
22
{#if APR_HAVE_STRUCT_RLIMIT
24
#include <sys/resource.h>
28
* @package CORE HTTP Daemon
31
{ ****************************************************************
33
* The most basic server code is encapsulated in a single module
34
* known as the core, which is just *barely* functional enough to
35
* serve documents, though not terribly well.
37
* Largely for NCSA back-compatibility reasons, the core needs to
38
* make pieces of its config structures available to other modules.
39
* The accessors are declared here, along with the interpretation
40
* of one of them (allow_options).
48
{ Includes directive }
50
{ FollowSymLinks directive }
56
{ IncludesNOEXEC directive }
58
{ SymLinksIfOwnerMatch directive }
60
{ MultiViews directive }
63
OPT_ALL = (OPT_INDEXES or OPT_INCLUDES or OPT_SYM_LINKS or OPT_EXECCGI);
66
* @defgroup get_remote_host Remote Host Resolution
67
* @ingroup APACHE_CORE_HTTPD
69
{ REMOTE_HOST returns the hostname, or NULL if the hostname
70
* lookup fails. It will force a DNS lookup according to the
71
* HostnameLookups setting.
75
{ REMOTE_NAME returns the hostname, or the dotted quad if the
76
* hostname lookup fails. It will force a DNS lookup according
77
* to the HostnameLookups setting.
81
{ REMOTE_NOLOOKUP is like REMOTE_NAME except that a DNS lookup is
84
REMOTE_NOLOOKUP = (2);
86
{ REMOTE_DOUBLE_REV will always force a DNS lookup, and also force
87
* a double reverse lookup, regardless of the HostnameLookups
88
* setting. The result is the (double reverse checked) hostname,
89
* or NULL if any of the lookups fail.
91
REMOTE_DOUBLE_REV = (3);
93
{ all of the requirements must be met }
95
{ any of the requirements must be met }
97
{ There are no applicable satisfy lines }
100
{ Make sure we don't write less than 8000 bytes at any one time.
102
AP_MIN_BYTES_TO_WRITE = 8000;
104
{ default maximum of internal redirects }
105
AP_DEFAULT_MAX_INTERNAL_REDIRECTS = 10;
107
{ default maximum subrequest nesting level }
108
AP_DEFAULT_MAX_SUBREQ_DEPTH = 10;
111
* Retrieve the value of Options for this request
112
* @param r The current request
113
* @return the Options bitmask
114
* @deffunc int ap_allow_options(request_rec *r)
116
function ap_allow_options(r: Prequest_rec): Integer;
117
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
118
external LibHTTPD name LibNamePrefix + 'ap_allow_options' + LibSuff4;
121
* Retrieve the value of the AllowOverride for this request
122
* @param r The current request
123
* @return the overrides bitmask
124
* @deffunc int ap_allow_overrides(request_rec *r)
126
function ap_allow_overrides(r: Prequest_rec): Integer;
127
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
128
external LibHTTPD name LibNamePrefix + 'ap_allow_overrides' + LibSuff4;
131
* Retrieve the value of the DefaultType directive, or text/plain if not set
132
* @param r The current request
133
* @return The default type
134
* @deffunc const char *ap_default_type(request_rec *r)
136
function ap_default_type(r: Prequest_rec): PChar;
137
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
138
external LibHTTPD name LibNamePrefix + 'ap_default_type' + LibSuff4;
141
* Retrieve the document root for this server
142
* @param r The current request
143
* @warning Don't use this! If your request went through a Userdir, or
144
* something like that, it'll screw you. But it's back-compatible...
145
* @return The document root
146
* @deffunc const char *ap_document_root(request_rec *r)
148
function ap_document_root(r: Prequest_rec): PChar;
149
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
150
external LibHTTPD name LibNamePrefix + 'ap_document_root' + LibSuff4;
153
* Lookup the remote client's DNS name or IP address
154
* @param conn The current connection
155
* @param dir_config The directory config vector from the request
156
* @param type The type of lookup to perform. One of:
158
* REMOTE_HOST returns the hostname, or NULL if the hostname
159
* lookup fails. It will force a DNS lookup according to the
160
* HostnameLookups setting.
161
* REMOTE_NAME returns the hostname, or the dotted quad if the
162
* hostname lookup fails. It will force a DNS lookup according
163
* to the HostnameLookups setting.
164
* REMOTE_NOLOOKUP is like REMOTE_NAME except that a DNS lookup is
166
* REMOTE_DOUBLE_REV will always force a DNS lookup, and also force
167
* a double reverse lookup, regardless of the HostnameLookups
168
* setting. The result is the (double reverse checked)
169
* hostname, or NULL if any of the lookups fail.
171
* @param str_is_ip unless NULL is passed, this will be set to non-zero on output when an IP address
173
* @return The remote hostname
174
* @deffunc const char *ap_get_remote_host(conn_rec *conn, void *dir_config, int type, int *str_is_ip)
176
function ap_get_remote_host(conn: Pconn_rec; dir_config: Pointer;
177
_type: Integer; str_is_ip: PInteger): PChar;
178
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
179
external LibHTTPD name LibNamePrefix + 'ap_get_remote_host' + LibSuff16;
182
* Retrieve the login name of the remote user. Undef if it could not be
184
* @param r The current request
185
* @return The user logged in to the client machine
186
* @deffunc const char *ap_get_remote_logname(request_rec *r)
188
function ap_get_remote_logname(r: Prequest_rec): PChar;
189
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
190
external LibHTTPD name LibNamePrefix + 'ap_get_remote_logname' + LibSuff4;
192
{ Used for constructing self-referencing URLs, and things like SERVER_PORT,
196
* build a fully qualified URL from the uri and information in the request rec
197
* @param p The pool to allocate the URL from
198
* @param uri The path to the requested file
199
* @param r The current request
200
* @return A fully qualified URL
201
* @deffunc char *ap_construct_url(apr_pool_t *p, const char *uri, request_rec *r)
203
function ap_construct_url(p: Papr_pool_t; const uri: PChar; r: Prequest_rec): PChar;
204
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
205
external LibHTTPD name LibNamePrefix + 'ap_construct_url' + LibSuff12;
208
* Get the current server name from the request
209
* @param r The current request
210
* @return the server name
211
* @deffunc const char *ap_get_server_name(request_rec *r)
213
function ap_get_server_name(r: Prequest_rec): PChar;
214
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
215
external LibHTTPD name LibNamePrefix + 'ap_get_server_name' + LibSuff4;
218
* Get the current server port
219
* @param The current request
220
* @return The server's port
221
* @deffunc apr_port_t ap_get_server_port(const request_rec *r)
223
function ap_get_server_port(r: Prequest_rec): apr_port_t;
224
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
225
external LibHTTPD name LibNamePrefix + 'ap_get_server_port' + LibSuff4;
228
* Return the limit on bytes in request msg body
229
* @param r The current request
230
* @return the maximum number of bytes in the request msg body
231
* @deffunc apr_off_t ap_get_limit_req_body(const request_rec *r)
233
function ap_get_limit_req_body(r: Prequest_rec): apr_off_t;
234
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
235
external LibHTTPD name LibNamePrefix + 'ap_get_limit_req_body' + LibSuff4;
238
* Return the limit on bytes in XML request msg body
239
* @param r The current request
240
* @return the maximum number of bytes in XML request msg body
241
* @deffunc size_t ap_get_limit_xml_body(const request_rec *r)
243
function ap_get_limit_xml_body(r: Prequest_rec): size_t;
244
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
245
external LibHTTPD name LibNamePrefix + 'ap_get_limit_xml_body' + LibSuff4;
248
* Install a custom response handler for a given status
249
* @param r The current request
250
* @param status The status for which the custom response should be used
251
* @param string The custom response. This can be a static string, a file
254
procedure ap_custom_response(r: Prequest_rec; status: Integer; const str: PChar);
255
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
256
external LibHTTPD name LibNamePrefix + 'ap_custom_response' + LibSuff12;
259
* Check if the current request is beyond the configured max. number of redirects or subrequests
260
* @param r The current request
261
* @return true (is exceeded) or false
262
* @deffunc int ap_is_recursion_limit_exceeded(const request_rec *r)
264
function ap_is_recursion_limit_exceeded(r: Prequest_rec): Integer;
265
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
266
external LibHTTPD name LibNamePrefix + 'ap_is_recursion_limit_exceeded' + LibSuff4;
269
* Check for a definition from the server command line
270
* @param name The define to check for
271
* @return 1 if defined, 0 otherwise
272
* @deffunc int ap_exists_config_define(const char *name)
274
function ap_exists_config_define(name: PChar): Integer;
275
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
276
external LibHTTPD name LibNamePrefix + 'ap_exists_config_define' + LibSuff4;
278
{ FIXME! See STATUS about how }
279
function ap_core_translate(r: Prequest_rec): Integer;
280
cdecl; external LibHTTPD name 'ap_core_translate';
282
{ Authentication stuff. This is one of the places where compatibility
283
* with the old config files *really* hurts; they don't discriminate at
284
* all between different authentication schemes, meaning that we need
285
* to maintain common state for all of them in the core, and make it
286
* available to the other modules through interfaces.
289
{ A structure to keep track of authorization requirements }
291
require_line = record
292
{ Where the require line is in the config file. }
293
method_mask: apr_int64_t;
294
{ The complete string from the command line }
299
* Return the type of authorization required for this request
300
* @param r The current request
301
* @return The authorization required
302
* @deffunc const char *ap_auth_type(request_rec *r)
304
function ap_auth_type(r: Prequest_rec): PChar;
305
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
306
external LibHTTPD name LibNamePrefix + 'ap_auth_type' + LibSuff4;
309
* Return the current Authorization realm
310
* @param r The current request
311
* @return The current authorization realm
312
* @deffunc const char *ap_auth_name(request_rec *r)
314
function ap_auth_name(r: Prequest_rec): PChar;
315
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
316
external LibHTTPD name LibNamePrefix + 'ap_auth_name' + LibSuff4;
319
* How the requires lines must be met.
320
* @param r The current request
321
* @return How the requirements must be met. One of:
323
* SATISFY_ANY -- any of the requirements must be met.
324
* SATISFY_ALL -- all of the requirements must be met.
325
* SATISFY_NOSPEC -- There are no applicable satisfy lines
327
* @deffunc int ap_satisfies(request_rec *r)
329
function ap_satisfies(r: Prequest_rec): Integer;
330
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
331
external LibHTTPD name LibNamePrefix + 'ap_satisfies' + LibSuff4;
334
* Retrieve information about all of the requires directives for this request
335
* @param r The current request
336
* @return An array of all requires directives for this request
337
* @deffunc const apr_array_header_t *ap_requires(request_rec *r)
339
function ap_requires(p: Papr_array_header_t): Integer;
340
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
341
external LibHTTPD name LibNamePrefix + 'ap_requires' + LibSuff4;
343
//#ifdef CORE_PRIVATE
346
* Core is also unlike other modules in being implemented in more than
347
* one file... so, data structures are declared here, even though most of
348
* the code that cares really is in http_core.c. Also, another accessor.
351
//AP_DECLARE_DATA extern module core_module;
353
{ Per-request configuration }
356
core_request_config = record
357
{ bucket brigade used by getline for look-ahead and
358
* ap_get_client_block for holding left-over request body }
359
bb: Papr_bucket_brigade;
361
{ an array of per-request working data elements, accessed
362
* by ID using ap_get_request_note()
363
* (Use ap_register_request_note() during initialization
368
{ There is a script processor installed on the output filter chain,
369
* so it needs the default_handler to deliver a (script) file into
370
* the chain so it can process it. Normally, default_handler only
371
* serves files on a GET request (assuming the file is actual content),
372
* since other methods are not content-retrieval. This flag overrides
373
* that behavior, stating that the "content" is actually a script and
374
* won't actually be delivered as the response for the non-GET method.
376
deliver_script: Integer;
378
{ Custom response strings registered via ap_custom_response(),
379
* or NULL; check per-dir config if nothing found here
381
response_code_strings: PPChar; { from ap_custom_response(), not from
384
{ Should addition of charset= be suppressed for this request?
386
suppress_charset: Integer;
389
{ Standard entries that are guaranteed to be accessible via
390
* ap_get_request_note() for each request (additional entries
391
* can be added with ap_register_request_note())
394
AP_NOTE_DIRECTORY_WALK = 0;
395
AP_NOTE_LOCATION_WALK = 1;
396
AP_NOTE_FILE_WALK = 2;
397
AP_NUM_STD_NOTES = 3;
400
* Reserve an element in the core_request_config->notes array
401
* for some application-specific data
402
* @return An integer key that can be passed to ap_get_request_note()
403
* during request processing to access this element for the
406
function ap_register_request_note: apr_size_t;
407
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
408
external LibHTTPD name LibNamePrefix + 'ap_register_request_note' + LibSuff0;
411
* Retrieve a pointer to an element in the core_request_config->notes array
412
* @param r The request
413
* @param note_num A key for the element: either a value obtained from
414
* ap_register_request_note() or one of the predefined AP_NOTE_*
416
* @return NULL if the note_num is invalid, otherwise a pointer to the
417
* requested note element.
418
* @remark At the start of a request, each note element is NULL. The
419
* handle provided by ap_get_request_note() is a pointer-to-pointer
420
* so that the caller can point the element to some app-specific
421
* data structure. The caller should guarantee that any such
422
* structure will last as long as the request itself.
424
function ap_get_request_note(r: Prequest_rec; note_num: apr_size_t): PPointer;
425
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
426
external LibHTTPD name LibNamePrefix + 'ap_get_request_note' + LibSuff8;
428
{ Per-directory configuration }
431
allow_options_t = cuchar;
432
overrides_t = cuchar;
435
* Bits of info that go into making an ETag for a file
436
* document. Why a long? Because char historically
437
* proved too short for Options, and int can be different
438
* sizes on different platforms.
440
etag_components_t = culong;
444
ETAG_NONE = (1 shl 0);
445
ETAG_MTIME = (1 shl 1);
446
ETAG_INODE = (1 shl 2);
447
ETAG_SIZE = (1 shl 3);
448
ETAG_BACKWARD = (ETAG_MTIME or ETAG_INODE or ETAG_SIZE);
449
ETAG_ALL = (ETAG_MTIME or ETAG_INODE or ETAG_SIZE);
451
{ Hostname resolution etc }
453
HOSTNAME_LOOKUP_OFF = 0;
454
HOSTNAME_LOOKUP_ON = 1;
455
HOSTNAME_LOOKUP_DOUBLE = 2;
456
OSTNAME_LOOKUP_UNSET = 3;
458
{ Hostname resolution etc }
460
USE_CANONICAL_NAME_OFF = (0);
461
USE_CANONICAL_NAME_ON = (1);
462
USE_CANONICAL_NAME_DNS = (2);
463
USE_CANONICAL_NAME_UNSET = (3);
465
{ should we force a charset on any outgoing parameterless content-type?
466
* if so, which charset?
468
ADD_DEFAULT_CHARSET_OFF = (0);
469
ADD_DEFAULT_CHARSET_ON = (1);
470
ADD_DEFAULT_CHARSET_UNSET = (2);
473
* Run-time performance tuning
475
ENABLE_MMAP_OFF = (0);
476
ENABLE_MMAP_ON = (1);
477
ENABLE_MMAP_UNSET = (2);
479
ENABLE_SENDFILE_OFF = (0);
480
ENABLE_SENDFILE_ON = (1);
481
ENABLE_SENDFILE_UNSET = (2);
483
USE_CANONICAL_PHYS_PORT_OFF = (0);
484
USE_CANONICAL_PHYS_PORT_ON = (1);
485
USE_CANONICAL_PHYS_PORT_UNSET = (2);
488
server_signature_e = (
495
core_dir_config = record
497
{ path of the directory/regex/etc. see also d_is_fnmatch/absolute below }
499
{ the number of slashes in d }
500
d_components: Cardinal;
502
{ If (opts & OPT_UNSET) then no absolute assignment to options has
504
* invariant: (opts_add & opts_remove) == 0
505
* Which said another way means that the last relative (options + or -)
506
* assignment made to each bit is recorded in exactly one of opts_add
509
opts: allow_options_t;
510
opts_add: allow_options_t;
511
opts_remove: allow_options_t;
512
override_: overrides_t;
513
override_opts: allow_options_t;
515
{ MIME typing --- the core doesn't do anything at all with this,
516
* but it does know what to slap on a request for a document which
517
* goes untyped by other mechanisms before it slips out the door...
520
ap_default_type: PChar;
522
{ Authentication stuff. Groan... }
524
satisfy: PInteger; { for every method one }
527
ap_requires: Papr_array_header_t;
529
{ Custom response config. These can contain text or a URL to redirect to.
530
* if response_code_strings is NULL then there are none in the config,
531
* if it's not null then it's allocated to sizeof(char*)*RESPONSE_CODES.
532
* This lets us do quick merges in merge_core_dir_configs().
535
response_code_strings: PPChar; { from ErrorDocument, not from
536
* ap_custom_response() }
538
{ Hostname resolution etc }
539
{ unsigned int hostname_lookups : 4; }
541
{ signed int content_md5 : 2; }{ calculate Content-MD5? }
543
{ unsigned use_canonical_name : 2; }
545
{ since is_fnmatch(conf->d) was being called so frequently in
546
* directory_walk() and its relatives, this field was created and
547
* is set to the result of that call.
549
{ unsigned d_is_fnmatch : 1; }
551
{ should we force a charset on any outgoing parameterless content-type?
552
* if so, which charset?
554
{ unsigned add_default_charset : 2; }
555
add_default_charset_name: PChar;
557
{ System Resource Control }
561
{$if defined(RLIMIT_DATA) or defined (RLIMIT_VMEM) or defined(RLIMIT_AS)}
564
{$ifdef RLIMIT_NPROC}
565
limit_nproc: Prlimit;
567
limit_req_body: apr_off_t; { limit on bytes in request msg body }
568
limit_xml_body: cLong; { limit on bytes in XML request msg body }
572
server_signature: server_signature_e;
577
sec_file: Papr_array_header_t;
580
mime_type: PChar; { forced with ForceType }
581
handler: PChar; { forced with SetHandler }
582
output_filters: PChar; { forced with SetOutputFilters }
583
input_filters: PChar; { forced with SetInputFilters }
584
accept_path_info: Integer; { forced with AcceptPathInfo }
586
ct_output_filters: Papr_hash_t; { added with AddOutputFilterByType }
589
* What attributes/data should be included in ETag generation?
591
etag_bits: etag_components_t;
592
etag_add: etag_components_t;
593
etag_remove: etag_components_t;
596
* Run-time performance tuning
598
{ unsigned int enable_mmap : 2; }{ whether files in this dir can be mmap'ed }
600
{ unsigned int enable_sendfile : 2; }{ files in this dir can be mmap'ed }
601
{ unsigned int allow_encoded_slashes : 1; }{ URLs may contain %2f w/o being
602
* pitched indiscriminately }
603
{ unsigned use_canonical_phys_port : 2;}
606
{ Per-server core configuration }
612
AP_TRACE_DISABLE = 0;
614
AP_TRACE_EXTENDED = 2;
617
core_server_config = record
623
{ Name translations --- we want the core to be able to do *something*
624
* so it's at least a minimally functional web server on its own (and
625
* can be tested that way). But let's keep it to the bare minimum:
627
ap_document_root: PChar;
632
sec_dir: Papr_array_header_t;
633
sec_url: Papr_array_header_t;
635
{ recursion backstopper }
636
redirect_limit: Integer; { maximum number of internal redirects }
637
subreq_limit: Integer; { maximum nesting level of subrequests }
640
accf_map: Papr_table_t;
643
trace_enable: Integer;
646
{ for AddOutputFiltersByType in core.c }
647
//void ap_add_output_filters_by_type(request_rec *r);
649
{ for http_config.c }
650
//void ap_core_reorder_directories(apr_pool_t *, server_rec *);
653
{AP_CORE_DECLARE(void) ap_add_per_dir_conf(server_rec *s, void *dir_config);
654
AP_CORE_DECLARE(void) ap_add_per_url_conf(server_rec *s, void *url_config);
655
AP_CORE_DECLARE(void) ap_add_file_conf(core_dir_config *conf, void *url_config);
656
AP_CORE_DECLARE_NONSTD(const char *) ap_limit_section(cmd_parms *cmd, void *dummy, const char *arg);}
658
{ Core filters; not exported. }
659
{int ap_core_input_filter(ap_filter_t *f, apr_bucket_brigade *b,
660
ap_input_mode_t mode, apr_read_type_e block,
661
apr_off_t readbytes);
662
apr_status_t ap_core_output_filter(ap_filter_t *f, apr_bucket_brigade *b);
664
#endif} { CORE_PRIVATE }
666
//AP_DECLARE(const char*) ap_get_server_protocol(server_rec* s);
667
//AP_DECLARE(void) ap_set_server_protocol(server_rec* s, const char* proto);
670
{ ----------------------------------------------------------------------
672
* Runtime status/management
682
ap_mgmt_value = record
686
2: (h_value: Papr_hash_t);
689
ap_mgmt_item_t = record
692
vtype: ap_mgmt_type_e;
696
{ Handles for core filters }
697
{extern AP_DECLARE_DATA ap_filter_rec_t *ap_subreq_core_filter_handle;
698
extern AP_DECLARE_DATA ap_filter_rec_t *ap_core_output_filter_handle;
699
extern AP_DECLARE_DATA ap_filter_rec_t *ap_content_length_filter_handle;
700
extern AP_DECLARE_DATA ap_filter_rec_t *ap_core_input_filter_handle;}
703
* This hook provdes a way for modules to provide metrics/statistics about
704
* their operational status.
706
* @param p A pool to use to create entries in the hash table
707
* @param val The name of the parameter(s) that is wanted. This is
708
* tree-structured would be in the form ('*' is all the tree,
709
* 'module.*' all of the module , 'module.foo.*', or
711
* @param ht The hash table to store the results. Keys are item names, and
712
* the values point to ap_mgmt_item_t structures.
716
ap_HOOK_get_mgmt_items_t = function(p: Papr_pool_t; const val: PChar;
717
ht: Papr_hash_t): Integer; cdecl;
719
procedure ap_hook_get_mgmt_items(pf: ap_HOOK_get_mgmt_items_t;
720
const aszPre: PPChar; const aszSucc: PPChar; nOrder: Integer);
721
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
722
external LibHTTPD name LibNamePrefix + 'ap_hook_get_mgmt_items' + LibSuff16;
724
{ ---------------------------------------------------------------------- }
726
{ ----------------------------------------------------------------------
728
* I/O logging with mod_logio
731
{APR_DECLARE_OPTIONAL_FN(void, ap_logio_add_bytes_out,
732
(conn_rec *c, apr_off_t bytes));}
734
{ ----------------------------------------------------------------------
736
* ident lookups with mod_ident
739
{APR_DECLARE_OPTIONAL_FN(const char *, ap_ident_lookup,