paweld/lazarus-ccr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

git-svn-id: https://svn.code.sf.net/p/lazarus-ccr/svn@14 8e941d3f-bd1b-0410-a28a-d453659cc2b4

Browse Source
This commit is contained in:
sekelsenmat 2006-09-24 19:39:38 +00:00
parent f8e3459ac4
commit 756a56e35f
19 changed files with 4201 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1496
httpd/httpd_1_3/ap_config.inc Normal file
View File

File diff suppressed because it is too large Load Diff

116
httpd/httpd_1_3/http_log.inc Normal file
View File

@ -0,0 +1,116 @@
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
}
{$ifdef HAVE_SYSLOG}
//#include <syslog.h>
APLOG_EMERG = LOG_EMERG; { system is unusable }
APLOG_ALERT = LOG_ALERT; { action must be taken immediately }
APLOG_CRIT = LOG_CRIT; { critical conditions }
APLOG_ERR = LOG_ERR; { error conditions }
APLOG_WARNING = LOG_WARNING; { warning conditions }
APLOG_NOTICE = LOG_NOTICE; { normal but significant condition }
APLOG_INFO = LOG_INFO; { informational }
APLOG_DEBUG = LOG_DEBUG; { debug-level messages }
APLOG_LEVELMASK= LOG_PRIMASK; { mask off the level value }
{$else}
APLOG_EMERG = 0; { system is unusable }
APLOG_ALERT = 1; { action must be taken immediately }
APLOG_CRIT = 2; { critical conditions }
APLOG_ERR = 3; { error conditions }
APLOG_WARNING = 4; { warning conditions }
APLOG_NOTICE = 5; { normal but significant condition }
APLOG_INFO = 6; { informational }
APLOG_DEBUG = 7; { debug-level messages }
APLOG_LEVELMASK= 7; { mask off the level value }
{$endif}
APLOG_NOERRNO = (APLOG_LEVELMASK + 1);
{$ifdef WIN32}
{ Set to indicate that error msg should come from Win32's GetLastError(),
* not errno. }
APLOG_WIN32ERROR = ((APLOG_LEVELMASK + 1) * 2);
{$endif}
DEFAULT_LOGLEVEL = APLOG_WARNING;
//#define APLOG_MARK __FILE__,__LINE__
//API_EXPORT(void) ap_open_logs (server_rec *, pool *p);
{ The two primary logging functions, ap_log_error and ap_log_rerror,
* use a printf style format string to build the log message. It is
* VERY IMPORTANT that you not include any raw data from the network,
* such as the request-URI or request header fields, within the format
* string. Doing so makes the server vulnerable to a denial-of-service
* attack and other messy behavior. Instead, use a simple format string
* like "%s", followed by the string containing the untrusted data.
}
procedure ap_log_error(
const file_: PChar; line, level: Integer;
const s: Pserver_rec; const fmt: PChar; others: array of const);
cdecl; external LibHTTPD name 'ap_log_error';
// __attribute__((format(printf,5,6)));
procedure ap_log_perror(
const file_: PChar; line, level: Integer;
const s: Prequest_rec; const fmt: PChar; others: array of const);
cdecl; external LibHTTPD name 'ap_log_perror';
// __attribute__((format(printf,5,6)));
//API_EXPORT(void) ap_error_log2stderr (server_rec *);
//API_EXPORT(void) ap_log_pid (pool *p, char *fname);
{ These are for legacy code, new code should use ap_log_error,
* or ap_log_rerror.
}
{API_EXPORT(void) ap_log_error_old(const char *err, server_rec *s);
API_EXPORT(void) ap_log_unixerr(const char *routine, const char *file,
const char *msg, server_rec *s);
API_EXPORT_NONSTD(void) ap_log_printf(const server_rec *s, const char *fmt, ...)
__attribute__((format(printf,2,3)));
API_EXPORT(void) ap_log_reason(const char *reason, const char *fname,
request_rec *r);}
type
piped_log = record
p: PPool;
//#if !defined(NO_RELIABLE_PIPED_LOGS) || defined(TPF)
program_: PChar;
pid: cint;
fds: array[1..2] of cint;
//#else
// FILE *write_f;
//#endif
end;
{API_EXPORT(piped_log *) ap_open_piped_log (pool *p, const char *program);
API_EXPORT(void) ap_close_piped_log (piped_log *);}
{#if !defined(NO_RELIABLE_PIPED_LOGS) || defined(TPF)
#define ap_piped_log_read_fd(pl) ((pl)->fds[0])
#define ap_piped_log_write_fd(pl) ((pl)->fds[1])
#else}
//#define ap_piped_log_read_fd(pl) (-1)
//#define ap_piped_log_write_fd(pl) (fileno((pl)->write_f))
//#endif

129
httpd/httpd_1_3/http_main.inc Normal file
View File

@ -0,0 +1,129 @@
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
}
{
* Routines in http_main.c which other code --- in particular modules ---
* may want to call. Right now, that's limited to timeout handling.
* There are two functions which modules can call to trigger a timeout
* (with the per-virtual-server timeout duration); these are hard_timeout
* and soft_timeout.
*
* The difference between the two is what happens when the timeout
* expires (or earlier than that, if the client connection aborts) ---
* a soft_timeout just puts the connection to the client in an
* "aborted" state, which will cause http_protocol.c to stop trying to
* talk to the client, but otherwise allows the code to continue normally.
* hard_timeout(), by contrast, logs the request, and then aborts it
* completely --- longjmp()ing out to the accept() loop in http_main.
* Any resources tied into the request's resource pool will be cleaned up;
* everything that isn't will leak.
*
* soft_timeout() is recommended as a general rule, because it gives your
* code a chance to clean up. However, hard_timeout() may be the most
* convenient way of dealing with timeouts waiting for some external
* resource other than the client, if you can live with the restrictions.
*
* (When a hard timeout is in scope, critical sections can be guarded
* with block_alarms() and unblock_alarms() --- these are declared in
* alloc.c because they are most often used in conjunction with
* routines to allocate something or other, to make sure that the
* cleanup does get registered before any alarm is allowed to happen
* which might require it to be cleaned up; they * are, however,
* implemented in http_main.c).
*
* NOTE! It's not "fair" for a hard_timeout to be in scope through calls
* across modules. Your module code really has no idea what other modules may
* be present in the server, and they may not take too kindly to having a
* longjmp() happen -- it could result in corrupted state. Heck they may not
* even take to kindly to a soft_timeout()... because it can cause EINTR to
* happen on pretty much any syscall, and unless all the libraries and modules
* in use are known to deal well with EINTR it could cause corruption as well.
* But things are likely to do much better with a soft_timeout in scope than a
* hard_timeout.
*
* A module MAY NOT use a hard_timeout() across * sub_req_lookup_xxx()
* functions, or across run_sub_request() functions. A module SHOULD NOT use a
* soft_timeout() in either of these cases, but sometimes there's just no
* choice.
*
* kill_timeout() will disarm either variety of timeout.
*
* reset_timeout() resets the timeout in progress.
}
{API_EXPORT(void) ap_start_shutdown(void);
API_EXPORT(void) ap_start_restart(int);
API_EXPORT(void) ap_hard_timeout(char *, request_rec *);
API_EXPORT(void) ap_keepalive_timeout(char *, request_rec *);
API_EXPORT(void) ap_soft_timeout(char *, request_rec *);
API_EXPORT(void) ap_kill_timeout(request_rec *);
API_EXPORT(void) ap_reset_timeout(request_rec *);
API_EXPORT(void) ap_child_terminate(request_rec *r);
API_EXPORT(void) ap_sync_scoreboard_image(void);
API_EXPORT(int) ap_update_child_status(int child_num, int status, request_rec *r);
void ap_time_process_request(int child_num, int status);
API_EXPORT(unsigned int) ap_set_callback_and_alarm(void ( *fn) (int), int x);
API_EXPORT(int) ap_check_alarm(void);
void setup_signal_names(char *prefix);}
{ functions for determination and setting of accept() mutexing }
{char *ap_default_mutex_method(void);
char *ap_init_mutex_method(char *t);}
{$ifndef NO_OTHER_CHILD}
{
* register an other_child -- a child which the main loop keeps track of
* and knows it is different than the rest of the scoreboard.
*
* pid is the pid of the child.
*
* maintenance is a function that is invoked with a reason, the data
* pointer passed here, and when appropriate a status result from waitpid().
*
* write_fd is an fd that is probed for writing by select() if it is ever
* unwritable, then maintenance is invoked with reason OC_REASON_UNWRITABLE.
* This is useful for log pipe children, to know when they've blocked. To
* disable this feature, use -1 for write_fd.
}
//API_EXPORT(void) ap_register_other_child(int pid,
// void ( *maintenance) (int reason, void *data, ap_wait_t status), void *data,
// int write_fd);
const
OC_REASON_DEATH = 0; { child has died, caller must call
* unregister still }
OC_REASON_UNWRITABLE = 1; { write_fd is unwritable }
OC_REASON_RESTART = 2; { a restart is occuring, perform
* any necessary cleanup (including
* sending a special signal to child)
}
OC_REASON_UNREGISTER = 3; { unregister has been called, do
* whatever is necessary (including
* kill the child) }
OC_REASON_LOST = 4; { somehow the child exited without
* us knowing ... buggy os? }
{
* unregister an other_child. Note that the data pointer is used here, and
* is assumed to be unique per other_child. This is because the pid and
* write_fd are possibly killed off separately.
}
//API_EXPORT(void) ap_unregister_other_child(void *data);
{$endif}

180
httpd/httpd_1_3/http_protocol.inc Normal file
View File

@ -0,0 +1,180 @@
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
}
{
* Prototypes for routines which either talk directly back to the user,
* or control the ones that eventually do.
}
{ Read a request and fill in the fields. }
//API_EXPORT(request_rec *) ap_read_request(conn_rec *c);
{ Send a single HTTP header field }
//API_EXPORT_NONSTD(int) ap_send_header_field(request_rec *r, const char *fieldname,
// const char *fieldval);
{ Send the minimal part of an HTTP response header... but modules should be
* very careful about using this, and should prefer ap_send_http_header().
* Much of the HTTP/1.1 implementation correctness depends on code in
* ap_send_http_header().
}
//API_EXPORT(void) ap_basic_http_header(request_rec *r);
{ Send the Status-Line and header fields for HTTP response }
//API_EXPORT(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);
//API_EXPORT(int) ap_send_http_options(request_rec *r);
{ Finish up stuff after a request }
//API_EXPORT(void) ap_finalize_request_protocol(request_rec *r);
{ Send error back to client... last arg indicates error status in case
* we get an error in the process of trying to deal with an ErrorDocument
* to handle some other error. In that case, we print the default report
* for the first thing that went wrong, and more briefly report on the
* problem with the ErrorDocument.
}
//API_EXPORT(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.
*
* May return an error status, typically USE_LOCAL_COPY (that when the
* permit_cache argument is set to one).
}
{API_EXPORT(int) ap_set_content_length(request_rec *r, long length);
API_EXPORT(int) ap_set_keepalive(request_rec *r);
API_EXPORT(time_t) ap_rationalize_mtime(request_rec *r, time_t mtime);
API_EXPORT(char *) ap_make_etag(request_rec *r, int force_weak);
API_EXPORT(void) ap_set_etag(request_rec *r);
API_EXPORT(void) ap_set_last_modified(request_rec *r);
API_EXPORT(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
* it a little more painless to slide things like HTTP-NG packetization
* underneath the main body of the code later. In the meantime, it lets
* us centralize a bit of accounting (bytes_sent).
*
* These also return the number of bytes written by the call.
* They should only be called with a timeout registered, for obvious reaasons.
* (Ditto the send_header stuff).
}
{API_EXPORT(long) ap_send_fd(FILE *f, request_rec *r);
API_EXPORT(long) ap_send_fd_length(FILE *f, request_rec *r, long length);
API_EXPORT(long) ap_send_fb(BUFF *f, request_rec *r);
API_EXPORT(long) ap_send_fb_length(BUFF *f, request_rec *r, long length);
API_EXPORT(size_t) ap_send_mmap(void *mm, request_rec *r, size_t offset,
size_t length);}
{ Hmmm... could macrofy these for now, and maybe forever, though the
* definitions of the macros would get a whole lot hairier.
}
//API_EXPORT(int) ap_rputc(int c, request_rec *r);
function ap_rputs(const str: PChar; r: Prequest_rec): cint;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibHTTPD name 'ap_rputs';
// external LibHTTPD name LibNamePrefix + 'ap_rputs' + LibSuff8;
{API_EXPORT(int) ap_rwrite(const void *buf, int nbyte, request_rec *r);
API_EXPORT_NONSTD(int) ap_rvputs(request_rec *r,...);
API_EXPORT(int) ap_vrprintf(request_rec *r, const char *fmt, va_list vlist);
API_EXPORT_NONSTD(int) ap_rprintf(request_rec *r, const char *fmt,...)
__attribute__((format(printf,2,3)));
API_EXPORT(int) ap_rflush(request_rec *r);}
{
* Index used in custom_responses array for a specific error code
* (only use outside protocol.c is in getting them configured).
}
//API_EXPORT(int) ap_index_of_response(int status);
{ Reading a block of data from the client connection (e.g., POST arg) }
{API_EXPORT(int) ap_setup_client_block(request_rec *r, int read_policy);
API_EXPORT(int) ap_should_client_block(request_rec *r);
API_EXPORT(long) ap_get_client_block(request_rec *r, char *buffer, int bufsiz);
API_EXPORT(int) ap_discard_request_body(request_rec *r);}
{ Sending a byterange }
{API_EXPORT(int) ap_set_byterange(request_rec *r);
API_EXPORT(int) ap_each_byterange(request_rec *r, long *offset, long *length);}
{ Support for the Basic authentication protocol. Note that there's
* nothing that prevents these from being in mod_auth.c, except that other
* modules which wanted to provide their own variants on finding users and
* passwords for Basic auth (a fairly common request) would then require
* mod_auth to be loaded or they wouldn't work.
*
* get_basic_auth_pw returns 0 (OK) if it set the 'pw' argument (and assured
* a correct value in r->connection->user); otherwise it returns an error
* code, either SERVER_ERROR if things are really confused, AUTH_REQUIRED
* if no authentication at all seemed to be in use, or DECLINED if there
* was authentication but it wasn't Basic (in which case, the caller should
* presumably decline as well).
*
* note_basic_auth_failure arranges for the right stuff to be scribbled on
* the HTTP return so that the client knows how to authenticate itself the
* next time. As does note_digest_auth_failure for Digest auth.
*
* note_auth_failure does the same thing, but will call the correct one
* based on the authentication type in use.
*
}
//API_EXPORT(void) ap_note_auth_failure(request_rec *r);
//API_EXPORT(void) ap_note_basic_auth_failure(request_rec *r);
//API_EXPORT(void) ap_note_digest_auth_failure(request_rec *r);
//API_EXPORT(int) ap_get_basic_auth_pw(request_rec *r, const char **pw);
{
* Setting up the protocol fields for subsidiary requests...
* Also, a wrapup function to keep the internal accounting straight.
}
//API_EXPORT(void) ap_set_sub_req_protocol(request_rec *rnew, const request_rec *r);
//API_EXPORT(void) ap_finalize_sub_req_protocol(request_rec *sub_r);
{ This is also useful for putting sub_reqs and internal_redirects together }
//CORE_EXPORT(void) ap_parse_uri(request_rec *r, const char *uri);
{ Get the method number associated with the given string, assumed to
* contain an HTTP method. Returns M_INVALID if not recognized.
}
//API_EXPORT(int) ap_method_number_of(const char *method);
//API_EXPORT(int) ap_getline(char *s, int n, BUFF *in, int fold);
//API_EXPORT(long) ap_get_chunk_size(char *b);

64
httpd/httpd_1_3/http_request.inc Normal file
View File

@ -0,0 +1,64 @@
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
}
{ http_request.c is the code which handles the main line of request
* processing, once a request has been read in (finding the right per-
* directory configuration, building it if necessary, and calling all
* the module dispatch functions in the right order).
*
* The pieces here which are public to the modules, allow them to learn
* how the server would handle some other file or URI, or perhaps even
* direct the server to serve that other file instead of the one the
* client requested directly.
*
* There are two ways to do that. The first is the sub_request mechanism,
* which handles looking up files and URIs as adjuncts to some other
* request (e.g., directory entries for multiviews and directory listings);
* the lookup functions stop short of actually running the request, but
* (e.g., for includes), a module may call for the request to be run
* by calling run_sub_req. The space allocated to create sub_reqs can be
* reclaimed by calling destroy_sub_req --- be sure to copy anything you care
* about which was allocated in its pool elsewhere before doing this.
}
{API_EXPORT(request_rec *) ap_sub_req_lookup_uri(const char *new_file,
const request_rec *r);
API_EXPORT(request_rec *) ap_sub_req_lookup_file(const char *new_file,
const request_rec *r);
API_EXPORT(request_rec *) ap_sub_req_method_uri(const char *method,
const char *new_file,
const request_rec *r);
API_EXPORT(int) ap_run_sub_req(request_rec *r);
API_EXPORT(void) ap_destroy_sub_req(request_rec *r);}
{
* Then there's the case that you want some other request to be served
* as the top-level request INSTEAD of what the client requested directly.
* If so, call this from a handler, and then immediately return OK.
}
{API_EXPORT(void) ap_internal_redirect(const char *new_uri, request_rec *);
API_EXPORT(void) ap_internal_redirect_handler(const char *new_uri, request_rec *);
API_EXPORT(int) ap_some_auth_required(request_rec *r);
API_EXPORT(int) ap_is_initial_req(request_rec *r);
API_EXPORT(time_t) ap_update_mtime(request_rec *r, time_t dependency_mtime);}
{$ifdef CORE_PRIVATE}
{ Function called by main.c to handle first-level request }
API_EXPORT(void) ap_process_request(request_rec *);
API_EXPORT(void) ap_die(int type, request_rec *r);
{$endif}

1195
httpd/httpd_1_3/httpd.inc Normal file
View File

File diff suppressed because it is too large Load Diff

181
httpd/httpd_1_3/httpd.pas Normal file
View File

@ -0,0 +1,181 @@
{
httpd.pas
Copyright (C) 2006 Felipe Monteiro de Carvalho
This unit is a pascal binding for the Apache 1.3.37 headers.
The headers were released under the following copyright:
}
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
}
unit httpd;
{$ifdef fpc}
{$mode delphi}{$H+}
{$endif}
{$IFNDEF FPC}
{$DEFINE WINDOWS}
{$ENDIF}
{$IFDEF WIN32}
{$DEFINE WINDOWS}
{$ENDIF}
{$ifdef Unix}
{$PACKRECORDS C}
{$endif}
interface
uses
{$ifdef WINDOWS}
Windows,
{$ELSE}
UnixType,
{$ENDIF}
ctypes;
const
{$ifndef fpc}
LineEnding = #13#10;
{$endif}
{$IFDEF WINDOWS}
LibHTTPD = 'libhttpd.dll';
{$ELSE}
LibHTTPD = '';
{$ENDIF}
{$define Apache1_3}
{ Declarations moved here to be on top of all declarations }
{ configuration vector structure }
type
ap_conf_vector_t = record end;
Pap_conf_vector_t = ^ap_conf_vector_t;
PPap_conf_vector_t = ^Pap_conf_vector_t;
{
Main httpd header files
Note: There are more include files other then these, because some include files
include more files.
}
{.$include ap_provider.inc}
{.$include util_cfgtree.inc}
{$include httpd.inc}
{$include http_config.inc}
{$include http_core.inc}
{$include http_log.inc}
{$include http_main.inc}
{$include http_protocol.inc}
{$include http_request.inc}
{$include http_vhost.inc}
{.$include util_script.inc}
{.$include util_time.inc}
{.$include util_md5.inc}
{.$include ap_mpm.inc}
implementation
{
Macros transformed into functions in the translation
}
{ from httpd.inc }
{ Internal representation for a HTTP protocol number, e.g., HTTP/1.1 }
function HTTP_VERSION(major, minor: Integer): Integer;
begin
Result := (1000*(major)+(minor));
end;
{ Major part of HTTP protocol }
function HTTP_VERSION_MAJOR(number: Integer): Integer;
begin
Result := number div 1000;
end;
{ Minor part of HTTP protocol }
function HTTP_VERSION_MINOR(number: Integer): Integer;
begin
Result := number mod 1000;
end;
{function ap_escape_uri(p: Papr_pool_t; const path: PChar): PChar;
begin
Result := ap_os_escape_path(p, path, 1);
end;}
{ from http_config.inc }
{ Use this in all standard modules }
procedure STANDARD_MODULE_STUFF(var mod_: module);
begin
mod_.version := MODULE_MAGIC_NUMBER_MAJOR;
mod_.minor_version := MODULE_MAGIC_NUMBER_MINOR;
mod_.module_index := -1;
// mod_.name: PChar;
mod_.dynamic_load_handle := nil;
mod_.next := nil;
mod_.magic := MODULE_MAGIC_COOKIE;
end;
//procedure STANDARD20_MODULE_STUFF(var mod_: module);
//begin
// mod_.version := MODULE_MAGIC_NUMBER_MAJOR;
// mod_.minor_version := MODULE_MAGIC_NUMBER_MINOR;
// mod_.module_index := -1;
// mod_.name: PChar;
// mod_.dynamic_load_handle := nil;
// mod_.next := nil;
// mod_.magic := MODULE_MAGIC_COOKIE;
// mod_.rewrite_args := nil;
//end;
{ Use this only in MPMs }
//procedure MPM20_MODULE_STUFF(var mod_: module);
//begin
// mod_.version := MODULE_MAGIC_NUMBER_MAJOR;
// mod_.minor_version := MODULE_MAGIC_NUMBER_MINOR;
// mod_.module_index := -1;
// mod_.name: PChar;
// mod_.dynamic_load_handle := nil;
// mod_.next := nil;
// mod_.magic := MODULE_MAGIC_COOKIE;
//end;
function ap_get_module_config(v: Pap_conf_vector_t; m: Pmodule): Pap_conf_vector_t;
begin
Result := Pointer(Integer(v) + m^.module_index);
end;
procedure ap_set_module_config(v: Pap_conf_vector_t; m: Pmodule; val: Pap_conf_vector_t);
var
P: PPointer;
begin
P := PPointer(Integer(v) + m^.module_index);
P^ := val;
end;
end.

6
httpd/httpd_2_0/apr/apr.pas
View File

@ -92,6 +92,8 @@ type
apr_int64_t = Int64;
apr_uint64_t = Int64;
apr_socklen_t = Integer;
apr_uint32_tso_handle_t = cuint;
type
{$IFDEF WINDOWS}
@ -102,8 +104,11 @@ type
{$ENDIF}
apr_int32_t = Integer;
Papr_int32_t = ^Integer;
apr_size_t = size_t;
Papr_size_t = ^apr_size_t;
apr_int16_t = SmallInt;
Papr_int16_t = ^SmallInt;
va_list = Pointer;
@ -182,6 +187,7 @@ type
{$include apr_thread_proc.inc}
{$include apr_version.inc}
{$include apr_poll.inc}
implementation

259
httpd/httpd_2_0/apr/apr_poll.inc Normal file
View File

@ -0,0 +1,259 @@
{ Copyright 2000-2005 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
}
{
* @file apr_poll.h
* @brief APR Poll interface
}
{#include "apr.h"
#include "apr_pools.h"
#include "apr_errno.h"
#include "apr_inherit.h"
#include "apr_file_io.h"
#include "apr_network_io.h"
#if APR_HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif}
{
* @defgroup apr_poll Poll Routines
* @ingroup APR
}
{
* @defgroup apr_poll_opt Poll options
}
const
APR_POLLIN = $001; {< Can read without blocking }
APR_POLLPRI = $002; {< Priority data available }
APR_POLLOUT = $004; {< Can write without blocking }
APR_POLLERR = $010; {< Pending error }
APR_POLLHUP = $020; {< Hangup occurred }
APR_POLLNVAL = $040; {< Descriptior invalid }
{ Used in apr_pollfd_t to determine what the apr_descriptor is }
type
apr_datatype_e = (
APR_NO_DESC, {< nothing here }
APR_POLL_SOCKET, {< descriptor refers to a socket }
APR_POLL_FILE, {< descriptor refers to a file }
APR_POLL_LASTDESC {< descriptor is the last one in the list }
);
{ Union of either an APR file or socket. }
apr_descriptor = record
case Integer of
1: (f: Papr_file_t); {< file }
2: (s: Papr_socket_t); {< socket }
end;
{ @see apr_pollfd_t }
Papr_pollfd_t = ^apr_pollfd_t;
PPapr_pollfd_t = ^Papr_pollfd_t;
{ Poll descriptor set. }
apr_pollfd_t = record
p: Papr_pool_t; {< associated pool }
desc_type: apr_datatype_e; {< descriptor type }
reqevents: apr_int16_t; {< requested events }
rtnevents: apr_int16_t; {< returned events }
desc: apr_descriptor; {< @see apr_descriptor }
client_data: Pointer; {< allows app to associate context }
end;
{
* Setup the memory required for poll to operate properly
* @param new_poll The poll structure to be used.
* @param num The number of socket descriptors to be polled.
* @param cont The pool to operate on.
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
}
function apr_poll_setup(new_poll: PPapr_pollfd_t; num: apr_int32_t;
cont: Papr_pool_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_poll_setup' + LibSuff12;
{
* Poll the sockets in the poll structure
* @param aprset The poll structure we will be using.
* @param numsock The number of sockets we are polling
* @param nsds The number of sockets signalled.
* @param timeout The amount of time in microseconds to wait. This is
* a maximum, not a minimum. If a socket is signalled, we
* will wake up before this time. A negative number means
* wait until a socket is signalled.
* @remark
* <PRE>
* The number of sockets signalled is returned in the second argument.
*
* This is a blocking call, and it will not return until either a
* socket has been signalled, or the timeout has expired.
* </PRE>
}
function apr_poll(aprset: Papr_pollfd_t; numsock: apr_int32_t;
nsds: Papr_int32_t; timeout: apr_interval_time_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_poll' + LibSuff16;
{
* Add a socket to the poll structure.
* @param aprset The poll structure we will be using.
* @param sock The socket to add to the current poll structure.
* @param event The events to look for when we do the poll. One of:
* <PRE>
* APR_POLLIN signal if read will not block
* APR_POLLPRI signal if prioirty data is availble to be read
* APR_POLLOUT signal if write will not block
* </PRE>
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
}
function apr_poll_socket_add(aprset: Papr_pollfd_t; sock: Papr_socket_t;
event: apr_int16_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_poll_socket_add' + LibSuff12;
{
* Modify a socket in the poll structure with mask.
* @param aprset The poll structure we will be using.
* @param sock The socket to modify in poll structure.
* @param events The events to stop looking for during the poll. One of:
* <PRE>
* APR_POLLIN signal if read will not block
* APR_POLLPRI signal if priority data is available to be read
* APR_POLLOUT signal if write will not block
* </PRE>
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
}
function apr_poll_socket_mask(aprset: Papr_pollfd_t; sock: Papr_socket_t;
events: apr_int16_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_poll_socket_mask' + LibSuff12;
{
* Remove a socket from the poll structure.
* @param aprset The poll structure we will be using.
* @param sock The socket to remove from the current poll structure.
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
}
function apr_poll_socket_remove(aprset: Papr_pollfd_t; sock: Papr_socket_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_poll_socket_remove' + LibSuff8;
{
* Clear all events in the poll structure.
* @param aprset The poll structure we will be using.
* @param events The events to clear from all sockets. One of:
* <PRE>
* APR_POLLIN signal if read will not block
* APR_POLLPRI signal if priority data is available to be read
* APR_POLLOUT signal if write will not block
* </PRE>
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
}
function apr_poll_socket_clear(aprset: Papr_pollfd_t;
events: apr_int16_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_poll_socket_clear' + LibSuff8;
{
* Get the return events for the specified socket.
* @param event The returned events for the socket. One of:
* <PRE>
* APR_POLLIN Data is available to be read
* APR_POLLPRI Priority data is availble to be read
* APR_POLLOUT Write will succeed
* APR_POLLERR An error occurred on the socket
* APR_POLLHUP The connection has been terminated
* APR_POLLNVAL This is an invalid socket to poll on.
* Socket not open.
* </PRE>
* @param sock The socket we wish to get information about.
* @param aprset The poll structure we will be using.
* @deprecated This function is deprecated, APR applications should control the pollset memory themselves.
}
function apr_poll_revents_get(event: Papr_int16_t; sock: Papr_socket_t;
aprset: Papr_pollfd_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_poll_revents_get' + LibSuff12;
{ General-purpose poll API for arbitrarily large numbers of
* file descriptors
}
{ Opaque structure used for pollset API }
type
apr_pollset_t = record end;
Papr_pollset_t = ^apr_pollset_t;
PPapr_pollset_t = ^Papr_pollset_t;
{
* Setup a pollset object
* @param pollset The pointer in which to return the newly created object
* @param size The maximum number of descriptors that this pollset can hold
* @param p The pool from which to allocate the pollset
* @param flags Optional flags to modify the operation of the pollset
* (reserved for future expansion)
}
function apr_pollset_create(pollset: PPapr_pollset_t; size: apr_uint32_tso_handle_t;
p: Papr_pool_t; flags: apr_uint32_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_pollset_create' + LibSuff16;
{
* Destroy a pollset object
* @param pollset The pollset to destroy
}
function apr_pollset_destroy(pollset: Papr_pollset_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_pollset_destroy' + LibSuff4;
{
* Add a socket or file descriptor to a pollset
* @param pollset The pollset to which to add the descriptor
* @param descriptor The descriptor to add
* @remark If you set client_data in the descriptor, that value
* will be returned in the client_data field whenever this
* descriptor is signalled in apr_pollset_poll().
}
function apr_pollset_add(pollset: Papr_pollset_t;
const descriptor: Papr_pollfd_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_pollset_add' + LibSuff8;
{
* Remove a descriptor from a pollset
* @param pollset The pollset from which to remove the descriptor
* @param descriptor The descriptor to remove
}
function apr_pollset_remove(pollset: Papr_pollset_t;
const descriptor: Papr_pollfd_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_pollset_remove' + LibSuff8;
{
* Block for activity on the descriptor(s) in a pollset
* @param pollset The pollset to use
* @param timeout Timeout in microseconds
* @param num Number of signalled descriptors (output parameter)
* @param descriptors Array of signalled descriptors (output parameter)
}
function apr_pollset_poll(pollset: Papr_pollset_t; timeout: apr_interval_time_t;
num: Papr_int32_t; const descriptors: PPapr_pollfd_t): apr_status_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibAPR name LibNamePrefix + 'apr_pollset_poll' + LibSuff16;

39
httpd/httpd_2_2/apr/apr.pas
View File

@ -107,7 +107,44 @@ type
va_list = Pointer;
// TEMPORARY
// Network structures
sockaddr = record
sa_family: cushort; // address family, AF_xxx
sa_data: array [1..14] of Char; // (NBO) 14 bytes of protocol address
end;
in_addr = record
s_addr: culong; // load with inet_aton()
end;
sockaddr_in = record
sin_family: cshort; // e.g. AF_INET
sin_port: cushort; // e.g. htons(3490)
sin_addr: in_addr; // see struct in_addr, below
sin_zero: array [1..8] of Char; // zero this if you want to
end;
in6_addr = record
Case Integer of
1: (u6_addr8: array [1..16] of Byte);
2: (u6_addr16: array [1..8] of Word);
3: (u6_addr32: array [1..4] of Cardinal);
end;
//#define s6_addr in6_u.u6_addr8
//#define s6_addr16 in6_u.u6_addr16
//#define s6_addr32 in6_u.u6_addr32
sockaddr_in6 = record
sin6_family: cushort;
sin6_port: Word;
sin6_flowinfo: Cardinal;
sin6_addr: in6_addr;
sin6_scope_id: Cardinal;
end;
// TEMPORARY
Papr_xml_ns_scope = Pointer;
Pap_method_list_t = Pointer;

6
httpd/httpd_2_2/apr/apr_network_io.inc
View File

@ -104,10 +104,10 @@ const
* We need to make sure we always have an in_addr type, so APR will just
* define it ourselves, if the platform doesn't provide it.
}
type
{type
in_addr = record
s_addr: apr_uint32_t; {< storage to hold the IP# }
end;
s_addr: apr_uint32_t; < storage to hold the IP#
end;}
{$endif}
const

24
httpd/httpd_2_2/http_log.inc
View File

@ -1,9 +1,9 @@
{ Copyright 1999-2005 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
@ -331,6 +331,18 @@ type
level: Integer; status: apr_status_t; const s: Pserver_rec;
const r: Prequest_rec; p: Papr_pool_t; const errstr: PChar); cdecl;
{
* hook method to log error messages
* @ingroup hooks
* @param file The file in which this function is called
* @param line The line number on which this function is called
* @param level The level of this error message
* @param status The status code from the previous command
* @param s The server which we are logging for
* @param r The request which we are logging for
* @param pool Memory pool to allocate from
* @param errstr message to log
}
procedure ap_hook_error_log(pf: ap_HOOK_error_log_t; const aszPre: PPChar;
const aszSucc: PPChar; nOrder: Integer);
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}

23
httpd/httpd_2_2/http_main.inc
View File

@ -1,9 +1,9 @@
{ Copyright 1999-2005 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
@ -12,7 +12,7 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
}
}
//#include "apr_optional.h"
@ -21,7 +21,7 @@
* can safely ignore and pass on from its rewrite_args() handler.
}
const
AP_SERVER_BASEARGS = 'C:c:D:d:E:e:f:vVlLtSh?X';
AP_SERVER_BASEARGS = 'C:c:D:d:E:e:f:vVlLtSMh?X';
{
* @package Command line options
@ -43,5 +43,12 @@ const
* effect the server based on command line options }
//AP_DECLARE_DATA extern apr_array_header_t *ap_server_config_defines;
{
* An optional function to send signal to server on presence of '-k'
* command line argument.
* Called if MPM defines AP_MPM_WANT_SIGNAL_SERVER
* @param status The exit status after sending signal
* @param pool Memory pool to allocate from
}
//APR_DECLARE_OPTIONAL_FN(int, ap_signal_server, (int *, apr_pool_t *));

53
httpd/httpd_2_2/http_protocol.inc
View File

@ -1,9 +1,9 @@
{ Copyright 1999-2005 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
@ -294,26 +294,16 @@ function ap_make_method_list(p: Papr_pool_t; nelts: Integer): Pap_method_list_t;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibHTTPD name LibNamePrefix + 'ap_make_method_list' + LibSuff8;
{
* Copy a method list
*
* @param dest List to copy to
* @param src List to copy from
}
procedure ap_copy_method_list(dest, src: Pap_method_list_t);
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibHTTPD name LibNamePrefix + 'ap_copy_method_list' + LibSuff8;
type
comp_t = procedure (urec: Pointer; const mname: PChar; mnum: Integer);
procedure ap_method_list_do(
comp: comp_t; rec: Pointer; ml: Pap_method_list_t; others: array of const);
cdecl; external LibHTTPD name 'ap_method_list_do';
type
ap_method_list_vdo_t = function (urec: Pointer; const mname: PChar;
mnum: Integer): Integer; cdecl;
procedure ap_method_list_vdo(comp: ap_method_list_vdo_t;
rec: Pointer; const ml: Pap_method_list_t; cp: va_list);
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibHTTPD name LibNamePrefix + 'ap_method_list_vdo' + LibSuff16;
{
* Search for an HTTP method name in an ap_method_list_t structure, and
* return true if found.
@ -720,19 +710,18 @@ procedure ap_hook_log_transaction(pf: ap_HOOK_log_transaction_t;
external LibHTTPD name LibNamePrefix + 'ap_hook_log_transaction' + LibSuff16;
{
* This hook allows modules to retrieve the http method from a request. This
* allows Apache modules to easily extend the methods that Apache understands
* This hook allows modules to retrieve the http scheme for a request. This
* allows Apache modules to easily extend the scheme that Apache understands
* @param r The current request
* @return The http method from the request
* @deffunc const char *ap_run_http_method(const request_rec *r)
}
type
ap_HOOK_http_method_t = function(const r: Prequest_rec): PChar; cdecl;
procedure ap_hook_http_method(pf: ap_HOOK_http_method_t;
procedure ap_hook_http_scheme(pf: ap_HOOK_http_method_t;
const aszPre: PPChar; const aszSucc: PPChar; nOrder: Integer);
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibHTTPD name LibNamePrefix + 'ap_hook_http_method' + LibSuff16;
external LibHTTPD name LibNamePrefix + 'ap_hook_http_scheme' + LibSuff16;
{
* Return the default port from the current request
@ -816,13 +805,19 @@ function ap_old_write_filter(f: Pap_filter_t; b: Papr_bucket_brigade): apr_statu
cdecl; external LibHTTPD name 'ap_old_write_filter';
{
* Setting up the protocol fields for subsidiary requests...
* Also, a wrapup function to keep the internal accounting straight.
* Sett up the protocol fields for subsidiary requests
* @param rnew New Sub Request
* @param r current request
}
procedure ap_set_sub_req_protocol(rnew: Prequest_rec; const r: Prequest_rec);
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibHTTPD name LibNamePrefix + 'ap_set_sub_req_protocol' + LibSuff8;
{
* A wrapup function to keep the internal accounting straight.
* Indicates that there is no more content coming.
* @param sub_r Subrequest that is now compete
}
procedure ap_finalize_sub_req_protocol(sub_r: Prequest_rec);
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibHTTPD name LibNamePrefix + 'ap_finalize_sub_req_protocol' + LibSuff4;

45
httpd/httpd_2_2/http_vhost.inc
View File

@ -1,9 +1,9 @@
{ Copyright 1999-2005 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
@ -45,10 +45,41 @@ procedure ap_fini_vhost_config(p: Papr_pool_t; main_server: Pserver_rec);
}
//const char *ap_parse_vhost_addrs(apr_pool_t *p, const char *hostname, server_rec *s);
{ handle NameVirtualHost directive }
{
* handle NameVirtualHost directive
* @param cmd Command Parameters structure
* @param dummy NOT USED
* @param arg a host of the form "<address>[:port]"
}
//const char *ap_set_name_virtual_host (cmd_parms *cmd, void *dummy,
// const char *arg);
{
* Callback function for every Name Based Virtual Host.
* @param baton Opaque user object
* @param conn The current Connection
* @param s The current Server
* @see ap_vhost_iterate_given_conn
* @return 0 on success, any non-zero return will stop the iteration.
}
type
ap_vhost_iterate_conn_cb = function (baton: Pointer; conn: Pconn_rec; s: Pserver_rec): Integer;
{
* For every virtual host on this connection, call func_cb.
* @param conn The current connection
* @param func_cb Function called for every Name Based Virtual Host for this
* connection.
* @param baton Opaque object passed to func_cb.
* @return The return value from func_cb.
* @note If func_cb returns non-zero, the function will return at this point,
* and not continue iterating the virtual hosts.
}
function ap_vhost_iterate_given_conn(conn: Pconn_rec;
func_cb: ap_vhost_iterate_conn_cb; baton: Pointer): Integer;
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
external LibHTTPD name LibNamePrefix + 'ap_vhost_iterate_given_conn' + LibSuff12;
{
* given an ip address only, give our best guess as to what vhost it is
* @param conn The current connection

7
httpd/httpd_2_2/httpd.inc
View File

@ -953,9 +953,14 @@ type
{
* @brief A structure to contain connection state information
}
APR_RING_ENTRY_conn_state_t = record
next: Pconn_state_t;
prev: Pconn_state_t;
end;
conn_state_t = record
{ APR_RING of expiration timeouts }
timeout_list: conn_state_t; // APR_RING_ENTRY(conn_state_t);
timeout_list: APR_RING_ENTRY_conn_state_t;
{ the expiration time of the next keepalive timeout }
expiration_time: apr_time_t;
{ Current state of the connection }

14
httpd/httpd_2_2/httpd.pas
View File

@ -6,12 +6,12 @@
This unit is a pascal binding for the Apache 2.0.58 headers.
The headers were released under the following copyright:
}
{ Copyright 1999-2005 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
{ Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
@ -20,7 +20,7 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
}
}
unit httpd;
{$ifdef fpc}

396
httpd/mod_hello.lpi
View File

@ -7,7 +7,7 @@
<MainUnit Value="0"/>
<IconPath Value="./"/>
<TargetFileExt Value=".exe"/>
<ActiveEditorIndexAtStart Value="0"/>
<ActiveEditorIndexAtStart Value="4"/>
</General>
<PublishOptions>
<Version Value="2"/>
@ -21,15 +21,15 @@
<LaunchingApplication PathPlusParams="/usr/X11R6/bin/xterm -T 'Lazarus Run Output' -e $(LazarusDir)/tools/runwait.sh $(TargetCmdLine)"/>
</local>
</RunParams>
<Units Count="13">
<Units Count="57">
<Unit0>
<Filename Value="mod_hello.lpr"/>
<IsPartOfProject Value="True"/>
<UnitName Value="mod_hello"/>
<CursorPos X="12" Y="50"/>
<TopLine Value="22"/>
<CursorPos X="5" Y="22"/>
<TopLine Value="108"/>
<EditorIndex Value="0"/>
<UsageCount Value="23"/>
<UsageCount Value="36"/>
<Loaded Value="True"/>
</Unit0>
<Unit1>
@ -41,8 +41,8 @@
</Unit1>
<Unit2>
<Filename Value="httpd_2_0/httpd.inc"/>
<CursorPos X="11" Y="4"/>
<TopLine Value="3"/>
<CursorPos X="1" Y="13"/>
<TopLine Value="1"/>
<UsageCount Value="10"/>
</Unit2>
<Unit3>
@ -53,8 +53,8 @@
</Unit3>
<Unit4>
<Filename Value="httpd_2_0/http_log.inc"/>
<CursorPos X="7" Y="158"/>
<TopLine Value="148"/>
<CursorPos X="1" Y="181"/>
<TopLine Value="153"/>
<UsageCount Value="10"/>
</Unit4>
<Unit5>
@ -65,8 +65,8 @@
</Unit5>
<Unit6>
<Filename Value="httpd_2_0/http_config.inc"/>
<CursorPos X="14" Y="311"/>
<TopLine Value="310"/>
<CursorPos X="11" Y="160"/>
<TopLine Value="138"/>
<UsageCount Value="10"/>
</Unit6>
<Unit7>
@ -81,20 +81,22 @@
<UnitName Value="httpd"/>
<CursorPos X="11" Y="163"/>
<TopLine Value="136"/>
<UsageCount Value="22"/>
<UsageCount Value="35"/>
</Unit8>
<Unit9>
<Filename Value="httpd_2_0/apr/apr_network_io.inc"/>
<CursorPos X="27" Y="109"/>
<TopLine Value="94"/>
<CursorPos X="17" Y="197"/>
<TopLine Value="178"/>
<UsageCount Value="10"/>
</Unit9>
<Unit10>
<Filename Value="httpd_2_0/apr/apr.pas"/>
<UnitName Value="apr"/>
<CursorPos X="24" Y="135"/>
<TopLine Value="126"/>
<CursorPos X="34" Y="96"/>
<TopLine Value="78"/>
<EditorIndex Value="4"/>
<UsageCount Value="10"/>
<Loaded Value="True"/>
</Unit10>
<Unit11>
<Filename Value="../httpd-2.0.58/srclib/apr/include/apr_network_io.h"/>
@ -110,12 +112,364 @@
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit12>
<Unit13>
<Filename Value="httpd_1_3/httpd.pas"/>
<UnitName Value="httpd"/>
<CursorPos X="21" Y="169"/>
<TopLine Value="146"/>
<UsageCount Value="16"/>
</Unit13>
<Unit14>
<Filename Value="httpd_1_3/ap_config.inc"/>
<CursorPos X="1" Y="22"/>
<TopLine Value="114"/>
<UsageCount Value="15"/>
</Unit14>
<Unit15>
<Filename Value="httpd_1_3/ap_alloc.inc"/>
<CursorPos X="4" Y="126"/>
<TopLine Value="110"/>
<UsageCount Value="12"/>
</Unit15>
<Unit16>
<Filename Value="httpd_1_3/http_config.inc"/>
<CursorPos X="1" Y="146"/>
<TopLine Value="128"/>
<UsageCount Value="14"/>
</Unit16>
<Unit17>
<Filename Value="httpd_2_0/ap_provider.inc"/>
<CursorPos X="34" Y="20"/>
<TopLine Value="18"/>
<UsageCount Value="10"/>
</Unit17>
<Unit18>
<Filename Value="httpd_1_3/buff.inc"/>
<CursorPos X="1" Y="185"/>
<TopLine Value="1"/>
<UsageCount Value="11"/>
</Unit18>
<Unit19>
<Filename Value="httpd_1_3/ap.inc"/>
<CursorPos X="3" Y="35"/>
<TopLine Value="20"/>
<UsageCount Value="11"/>
</Unit19>
<Unit20>
<Filename Value="httpd_1_3/httpd.inc"/>
<CursorPos X="14" Y="22"/>
<TopLine Value="1"/>
<UsageCount Value="14"/>
</Unit20>
<Unit21>
<Filename Value="../../../Apache/apache_1.3.37/src/include/httpd.h"/>
<CursorPos X="9" Y="215"/>
<TopLine Value="197"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit21>
<Unit22>
<Filename Value="../../../Apache/apache_1.3.37/src/support/suexec.h"/>
<CursorPos X="44" Y="54"/>
<TopLine Value="36"/>
<UsageCount Value="11"/>
<SyntaxHighlighter Value="C++"/>
</Unit22>
<Unit23>
<Filename Value="../../../Apache/apache_1.3.37/src/modules/proxy/mod_proxy.h"/>
<CursorPos X="8" Y="296"/>
<TopLine Value="276"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit23>
<Unit24>
<Filename Value="../../../Apache/apache_1.3.37/src/include/ap_alloc.h"/>
<CursorPos X="7" Y="180"/>
<TopLine Value="155"/>
<UsageCount Value="11"/>
<SyntaxHighlighter Value="C++"/>
</Unit24>
<Unit25>
<Filename Value="../../../Apache/apache_1.3.37/src/include/ap_config.h"/>
<CursorPos X="22" Y="22"/>
<TopLine Value="7"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit25>
<Unit26>
<Filename Value="httpd_1_3/util_uri.inc"/>
<CursorPos X="4" Y="49"/>
<TopLine Value="38"/>
<UsageCount Value="11"/>
</Unit26>
<Unit27>
<Filename Value="../../../Apache/apache_1.3.37/src/include/util_uri.h"/>
<CursorPos X="12" Y="53"/>
<TopLine Value="45"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit27>
<Unit28>
<Filename Value="../../../Apache/apache_1.3.37/src/include/http_config.h"/>
<CursorPos X="27" Y="174"/>
<TopLine Value="126"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit28>
<Unit29>
<Filename Value="httpd_1_3/http_core.inc"/>
<CursorPos X="1" Y="387"/>
<TopLine Value="352"/>
<UsageCount Value="14"/>
</Unit29>
<Unit30>
<Filename Value="httpd_1_3/http_request.inc"/>
<CursorPos X="78" Y="57"/>
<TopLine Value="29"/>
<UsageCount Value="11"/>
</Unit30>
<Unit31>
<Filename Value="httpd_2_0/pcreposix.inc"/>
<CursorPos X="1" Y="74"/>
<TopLine Value="34"/>
<UsageCount Value="10"/>
</Unit31>
<Unit32>
<Filename Value="httpd_1_3/hsregex.inc"/>
<CursorPos X="1" Y="15"/>
<TopLine Value="1"/>
<UsageCount Value="11"/>
</Unit32>
<Unit33>
<Filename Value="../../../Apache/apache_1.3.37/src/regex/regex2.h"/>
<CursorPos X="8" Y="115"/>
<TopLine Value="82"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit33>
<Unit34>
<Filename Value="httpd_1_3/http_log.inc"/>
<CursorPos X="11" Y="67"/>
<TopLine Value="52"/>
<UsageCount Value="10"/>
</Unit34>
<Unit35>
<Filename Value="httpd_1_3/http_main.inc"/>
<CursorPos X="27" Y="123"/>
<TopLine Value="18"/>
<UsageCount Value="13"/>
</Unit35>
<Unit36>
<Filename Value="httpd_1_3/http_protocol.inc"/>
<CursorPos X="77" Y="108"/>
<TopLine Value="85"/>
<UsageCount Value="10"/>
</Unit36>
<Unit37>
<Filename Value="httpd_1_3/http_vhost.inc"/>
<CursorPos X="1" Y="33"/>
<TopLine Value="10"/>
<UsageCount Value="10"/>
</Unit37>
<Unit38>
<Filename Value="../../../Apache/apache_1.3.37/src/modules/example/mod_example.c"/>
<CursorPos X="7" Y="1011"/>
<TopLine Value="1004"/>
<UsageCount Value="13"/>
<SyntaxHighlighter Value="C++"/>
</Unit38>
<Unit39>
<Filename Value="httpd_1_3/ap_mmn.inc"/>
<CursorPos X="34" Y="208"/>
<TopLine Value="192"/>
<UsageCount Value="11"/>
</Unit39>
<Unit40>
<Filename Value="httpd_2_0/ap_config.inc"/>
<CursorPos X="1" Y="1"/>
<TopLine Value="1"/>
<UsageCount Value="10"/>
</Unit40>
<Unit41>
<Filename Value="/usr/share/fpcsrc/rtl/linux/ptypes.inc"/>
<CursorPos X="5" Y="68"/>
<TopLine Value="52"/>
<UsageCount Value="10"/>
</Unit41>
<Unit42>
<Filename Value="httpd_2_2/http_main.inc"/>
<CursorPos X="1" Y="16"/>
<TopLine Value="1"/>
<EditorIndex Value="1"/>
<UsageCount Value="11"/>
<Loaded Value="True"/>
</Unit42>
<Unit43>
<Filename Value="httpd_2_2/httpd.inc"/>
<CursorPos X="10" Y="975"/>
<TopLine Value="959"/>
<EditorIndex Value="2"/>
<UsageCount Value="11"/>
<Loaded Value="True"/>
</Unit43>
<Unit44>
<Filename Value="httpd_2_2/httpd.pas"/>
<UnitName Value="httpd"/>
<CursorPos X="81" Y="89"/>
<TopLine Value="82"/>
<EditorIndex Value="6"/>
<UsageCount Value="11"/>
<Loaded Value="True"/>
</Unit44>
<Unit45>
<Filename Value="httpd_2_2/http_log.inc"/>
<CursorPos X="1" Y="15"/>
<TopLine Value="1"/>
<EditorIndex Value="7"/>
<UsageCount Value="11"/>
<Loaded Value="True"/>
</Unit45>
<Unit46>
<Filename Value="httpd_2_2/http_protocol.inc"/>
<CursorPos X="1" Y="15"/>
<TopLine Value="1"/>
<EditorIndex Value="8"/>
<UsageCount Value="11"/>
<Loaded Value="True"/>
</Unit46>
<Unit47>
<Filename Value="httpd_2_2/http_vhost.inc"/>
<CursorPos X="30" Y="52"/>
<TopLine Value="1"/>
<EditorIndex Value="9"/>
<UsageCount Value="11"/>
<Loaded Value="True"/>
</Unit47>
<Unit48>
<Filename Value="httpd_2_2/apr/apr_network_io.inc"/>
<CursorPos X="14" Y="197"/>
<TopLine Value="178"/>
<UsageCount Value="10"/>
</Unit48>
<Unit49>
<Filename Value="httpd_2_2/apr/apr.pas"/>
<UnitName Value="apr"/>
<CursorPos X="15" Y="137"/>
<TopLine Value="52"/>
<UsageCount Value="10"/>
</Unit49>
<Unit50>
<Filename Value="../../../Apache/httpd-2.2.3/srclib/apr/include/apr_ring.h"/>
<CursorPos X="9" Y="70"/>
<TopLine Value="52"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit50>
<Unit51>
<Filename Value="../../../Apache/httpd-2.2.3/srclib/apr/include/apr_mmap.h"/>
<CursorPos X="5" Y="85"/>
<TopLine Value="67"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit51>
<Unit52>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<CursorPos X="84" Y="212"/>
<TopLine Value="196"/>
<EditorIndex Value="3"/>
<UsageCount Value="10"/>
<Loaded Value="True"/>
</Unit52>
<Unit53>
<Filename Value="../../../Apache/httpd-2.0.58/include/http_config.h"/>
<CursorPos X="1" Y="75"/>
<TopLine Value="57"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit53>
<Unit54>
<Filename Value="../../../Apache/httpd-2.0.58/include/http_core.h"/>
<CursorPos X="10" Y="585"/>
<TopLine Value="570"/>
<UsageCount Value="10"/>
<SyntaxHighlighter Value="C++"/>
</Unit54>
<Unit55>
<Filename Value="httpd_2_0/http_core.inc"/>
<CursorPos X="16" Y="650"/>
<TopLine Value="634"/>
<UsageCount Value="10"/>
</Unit55>
<Unit56>
<Filename Value="httpd_2_0/apr/apr_dso.inc"/>
<CursorPos X="1" Y="81"/>
<TopLine Value="63"/>
<EditorIndex Value="5"/>
<UsageCount Value="10"/>
<Loaded Value="True"/>
</Unit56>
</Units>
<JumpHistory Count="1" HistoryIndex="0">
<JumpHistory Count="15" HistoryIndex="14">
<Position1>
<Filename Value="mod_hello.lpr"/>
<Caret Line="50" Column="11" TopLine="34"/>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="3" Column="1" TopLine="1"/>
</Position1>
<Position2>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="63" Column="3" TopLine="47"/>
</Position2>
<Position3>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="64" Column="1" TopLine="47"/>
</Position3>
<Position4>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="63" Column="3" TopLine="47"/>
</Position4>
<Position5>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="59" Column="3" TopLine="47"/>
</Position5>
<Position6>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="71" Column="16" TopLine="55"/>
</Position6>
<Position7>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="68" Column="14" TopLine="54"/>
</Position7>
<Position8>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="71" Column="27" TopLine="55"/>
</Position8>
<Position9>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="84" Column="49" TopLine="68"/>
</Position9>
<Position10>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="67" Column="1" TopLine="51"/>
</Position10>
<Position11>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="109" Column="20" TopLine="93"/>
</Position11>
<Position12>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="189" Column="50" TopLine="173"/>
</Position12>
<Position13>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="211" Column="53" TopLine="195"/>
</Position13>
<Position14>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="202" Column="23" TopLine="190"/>
</Position14>
<Position15>
<Filename Value="httpd_2_0/apr/apr_poll.inc"/>
<Caret Line="212" Column="84" TopLine="196"/>
</Position15>
</JumpHistory>
</ProjectOptions>
<CompilerOptions>
@ -124,8 +478,8 @@
<Filename Value="mod_hello.so"/>
</Target>
<SearchPaths>
<OtherUnitFiles Value="httpd_2_0/;httpd_2_0/apr/;httpd_2_0/apriconv/;httpd_2_0/aprutil/"/>
<SrcPath Value="httpd_2_0/;httpd_2_0/apr/;httpd_2_0/apriconv/;httpd_2_0/aprutil/"/>
<OtherUnitFiles Value="httpd_2_0/;httpd_2_0/apr/;httpd_2_0/aprutil/"/>
<SrcPath Value="httpd_2_0/;httpd_2_0/apr/;httpd_2_0/aprutil/"/>
</SearchPaths>
<CodeGeneration>
<Generate Value="Faster"/>

66
httpd/mod_hello.lpr
View File

@ -7,13 +7,17 @@ library mod_hello;
* The mode must be objfpc on this unit because the unix code uses
* some extensions introduced on Free Pascal
*******************************************************************}
{$mode objfpc}{$H+}
{$ifdef fpc}
{$mode objfpc}{$H+}
{$endif}
{$IFDEF WIN32}
{$DEFINE WINDOWS}
{$ENDIF}
uses SysUtils, httpd, apr;
{$define Apache2_2}
uses SysUtils, httpd {$ifndef Apache1_3}, apr{$endif};
var
test_module: module; {$ifdef Unix} public name 'test_module'; {$endif}
@ -47,12 +51,18 @@ begin
end;
{ The following line just prints a message to the errorlog }
ap_log_error(MODULE_NAME, 54, APLOG_NOERRNO or APLOG_NOTICE, 0, r^.server,
ap_log_error(MODULE_NAME, 54, APLOG_NOERRNO or APLOG_NOTICE,
{$ifndef Apache1_3}0,{$endif} r^.server,
'mod_hello: %s', [PChar('Before content is output')]);
{ We set the content type before doing anything else }
ap_set_content_type(r, 'text/html');
{$ifdef Apache1_3}
r^.content_type := 'text/html';
// ap_send_http_header(r);
{$else}
ap_set_content_type(r, 'text/html');
{$endif}
{ If the request is for a header only, and not a request for
the whole content, then return OK now. We don't have to do
anything else. }
@ -72,7 +82,7 @@ begin
ap_rputs('<BODY BGCOLOR="#FFFFFF">' + LineEnding ,r);
ap_rputs('<H1>Hello world</H1>' + LineEnding, r);
ap_rputs('This is the first Apache Module working with the new binding from Free Pascal' + LineEnding, r);
ap_rprintf(r, '<br>A sample line generated by ap_rprintf<br>' + LineEnding, []);
// ap_rprintf(r, '<br>A sample line generated by ap_rprintf<br>' + LineEnding, []);
ap_rputs('</BODY></HTML>' + LineEnding, r);
{ We can either return OK or DECLINED at this point. If we return
@ -83,25 +93,51 @@ end;
{*******************************************************************
* Registers the hooks
*******************************************************************}
{$ifdef apache1_3}
procedure hw_init(s: PServer_rec; p: PPool); cdecl;
begin
end;
var
hw_handlers: array[0..0] of handler_rec =
(
(content_type: 'hw_app'; handler: @DefaultHandler)
);
{$else}
procedure RegisterHooks(p: Papr_pool_t); cdecl;
begin
ap_hook_handler(@DefaultHandler, nil, nil, APR_HOOK_MIDDLE);
end;
{$endif}
{*******************************************************************
* Library initialization code
*******************************************************************}
begin
default_module_ptr := @test_module;
FillChar(default_module_ptr^, SizeOf(default_module_ptr^), 0);
with test_module do
begin
version := MODULE_MAGIC_NUMBER_MAJOR;
minor_version := MODULE_MAGIC_NUMBER_MINOR;
module_index := -1;
name := MODULE_NAME;
magic := MODULE_MAGIC_COOKIE;
register_hooks := @RegisterHooks;
end;
{$ifdef apache1_3}
STANDARD_MODULE_STUFF(test_module);
with test_module do
begin
name := MODULE_NAME;
init := @hw_init;
handlers := hw_handlers;
end;
{$else}
STANDARD20_MODULE_STUFF(test_module);
with test_module do
begin
name := MODULE_NAME;
register_hooks := @RegisterHooks;
end;
{$endif}
end.