diff -r 1fdbf4170ef4 -r b8bf95b39952 src/server/public/nsapi.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/server/public/nsapi.h Sat Jan 14 13:53:44 2012 +0100 @@ -0,0 +1,1342 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2008 Sun Microsystems, Inc. All rights reserved. + * + * THE BSD LICENSE + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of the nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef PUBLIC_NSAPI_H +#define PUBLIC_NSAPI_H + +/* + * File: nsapi.h + * + * Description: + * + * This file defines an interface for extending the server with + * in-process plug-ins. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* NSAPI version defined by this header file */ +#define NSAPI_VERSION 303 + +/* Define USE_NSAPI_VERSION to use a specific NSAPI version at compile time */ +#ifdef USE_NSAPI_VERSION +#if USE_NSAPI_VERSION < 300 || USE_NSAPI_VERSION > NSAPI_VERSION +#error This header file does not support the requested NSAPI version +#else +#undef NSAPI_VERSION +#define NSAPI_VERSION USE_NSAPI_VERSION +#endif +#endif + +/* --- Begin native platform configuration definitions --- */ + +#if !defined(XP_WIN32) && !defined(XP_UNIX) +#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) +#define XP_WIN32 +#else +#define XP_UNIX +#endif +#endif + +#ifdef XP_UNIX +#define NSAPI_PUBLIC +#define ZERO(ptr, len) memset(ptr, 0, len) +#ifdef AIX +#define TCPLEN_T size_t +#endif +#ifdef HPUX +#define TCPLEN_T int +#endif +#ifndef TCPLEN_T +#define TCPLEN_T socklen_t +#endif +#endif /* XP_UNIX */ + +#ifdef XP_WIN32 +#define NSAPI_PUBLIC __declspec(dllexport) +struct iovec { + char *iov_base; + unsigned iov_len; +}; +#ifndef S_ISDIR +#define S_ISDIR(mode) ((mode & S_IFMT) == S_IFDIR) +#endif +#ifndef S_ISREG +#define S_ISREG(mode) ((mode & S_IFMT) == S_IFREG) +#endif +#ifndef S_ISLNK +#define S_ISLNK(x) (0) +#endif +#define caddr_t PCHAR +#define NEED_STRCASECMP +#define NEED_STRNCASECMP +#define ZERO(ptr, len) ZeroMemory(ptr, len) +#define TCPLEN_T int +#endif /* XP_WIN32 */ + +/* --- End native platform configuration definitions --- */ + +/* --- Begin miscellaneous definitions --- */ + +/* Used in some places as a length limit on error messages */ +#define MAGNUS_ERROR_LEN 1024 + +/* Carriage return and line feed */ +#define CR 13 +#define LF 10 +#ifdef XP_WIN32 +#define ENDLINE "\r\n" +#else +#define ENDLINE "\n" +#endif + +/* mime.types file identification line */ +#define NCC_MT_MAGIC "#--Netscape Communications Corporation MIME Information" +#define NCC_MT_MAGIC_LEN 55 + +/* The character which separates extensions with cinfo_find */ +#define CINFO_SEPARATOR '.' + +/* The maximum length of a line in a mime.types file */ +#define CINFO_MAX_LEN 1024 + +/* The maximum length of an error message */ +#define MAX_ERROR_LEN 4096 + +/* + * A warning is a minor mishap, such as a 404 being issued. + */ +#define LOG_WARN 0 + +/* + * A misconfig is when there is a syntax error or permission violation in + * a config file. + */ +#define LOG_MISCONFIG 1 + +/* + * Security warnings are issued when authentication fails, or a host is + * given a 403 return code. + */ +#define LOG_SECURITY 2 + +/* + * A failure is when a request could not be fulfilled due to an internal + * problem, such as a CGI script exiting prematurely, or a filesystem + * permissions problem. + */ +#define LOG_FAILURE 3 + +/* + * A catastrophe is a fatal server error such as running out of + * memory or processes, or a system call failing, or even a server crash. + * The server child cannot recover from a catastrophe. + */ +#define LOG_CATASTROPHE 4 + +/* + * Informational message, of no concern. + */ +#define LOG_INFORM 5 + +/* + * Internal diagnostic message. + */ +#define LOG_VERBOSE 6 + +/* + * The time format to use in the error log + */ +#define ERR_TIMEFMT "[%d/%b/%Y:%H:%M:%S]" + + +/* The fd you will get if you are reporting errors to SYSLOG */ +#define ERRORS_TO_SYSLOG NULL + +/* Return codes from file I/O routines */ +#define IO_OKAY 1 +#define IO_ERROR -1 +#define IO_EOF 0 +#define NETBUF_EOF -1 +#define NETBUF_ERROR -2 +#define NETBUF_FULL -3 + +/* The disk page size on this machine. */ +#define FILE_BUFFERSIZE 4096 + +#ifdef XP_UNIX + +#define FILE_PATHSEP '/' +#define FILE_PARENT "../" + +#elif defined(XP_WIN32) + +#define FILE_PATHSEP '/' +#define FILE_PARENT "..\\" + +#endif /* XP_WIN32 */ + +#define NET_INFINITE_TIMEOUT 0 +#define NET_ZERO_TIMEOUT -1 + +#ifdef USE_REGEX +/* WILDPAT uses regular expressions */ +#define WILDPAT_VALID(exp) regexp_valid(exp) +#define WILDPAT_MATCH(str, exp) regexp_match(str, exp) +#define WILDPAT_CMP(str, exp) regexp_cmp(str, exp) +#define WILDPAT_CASECMP(str, exp) regexp_casecmp(str, exp) +#define WILDPAT_USES_REGEXP 1 +#else +/* WILDPAT uses shell expressions */ +#define WILDPAT_VALID(exp) shexp_valid(exp) +#define WILDPAT_MATCH(str, exp) shexp_match(str, exp) +#define WILDPAT_CMP(str, exp) shexp_cmp(str, exp) +#define WILDPAT_CASECMP(str, exp) shexp_casecmp(str, exp) +#define WILDPAT_USES_SHEXP 1 +#endif + +/* Define return codes from WILDPAT_VALID */ +#define NON_WILDPAT -1 /* exp is ordinary string */ +#define INVALID_WILDPAT -2 /* exp is an invalid pattern */ +#define VALID_WILDPAT 1 /* exp is a valid pattern */ + +/* Define return codes from regexp_valid and shexp_valid */ +#define NON_SXP NON_WILDPAT /* exp is an ordinary string */ +#define INVALID_SXP INVALID_WILDPAT /* exp is an invalid shell exp */ +#define VALID_SXP VALID_WILDPAT /* exp is a valid shell exp */ + +#define NON_REGEXP NON_SXP +#define INVALID_REGEXP INVALID_SXP +#define VALID_REGEXP VALID_SXP + +#define SYSTHREAD_DEFAULT_PRIORITY 16 + +/* The longest line in the configuration file */ +#define CONF_MAXLEN 16384 + +#define HTTP_DATE_LEN 30 +#define HTTP_DATE_FMT "%a, %d %b %Y %T GMT" + +/* HTTP status codes */ +#define PROTOCOL_CONTINUE 100 +#define PROTOCOL_SWITCHING 101 +#define PROTOCOL_OK 200 +#define PROTOCOL_CREATED 201 +#define PROTOCOL_ACCEPTED 202 +#define PROTOCOL_NONAUTHORITATIVE 203 +#define PROTOCOL_NO_RESPONSE 204 +#define PROTOCOL_NO_CONTENT 204 +#define PROTOCOL_RESET_CONTENT 205 +#define PROTOCOL_PARTIAL_CONTENT 206 +#define PROTOCOL_MULTI_STATUS 207 +#define PROTOCOL_MULTIPLE_CHOICES 300 +#define PROTOCOL_MOVED_PERMANENTLY 301 +#define PROTOCOL_REDIRECT 302 +#define PROTOCOL_SEE_OTHER 303 +#define PROTOCOL_NOT_MODIFIED 304 +#define PROTOCOL_USE_PROXY 305 +#define PROTOCOL_TEMPORARY_REDIRECT 307 +#define PROTOCOL_BAD_REQUEST 400 +#define PROTOCOL_UNAUTHORIZED 401 +#define PROTOCOL_PAYMENT_REQUIRED 402 +#define PROTOCOL_FORBIDDEN 403 +#define PROTOCOL_NOT_FOUND 404 +#define PROTOCOL_METHOD_NOT_ALLOWED 405 +#define PROTOCOL_NOT_ACCEPTABLE 406 +#define PROTOCOL_PROXY_UNAUTHORIZED 407 +#define PROTOCOL_REQUEST_TIMEOUT 408 +#define PROTOCOL_CONFLICT 409 +#define PROTOCOL_GONE 410 +#define PROTOCOL_LENGTH_REQUIRED 411 +#define PROTOCOL_PRECONDITION_FAIL 412 +#define PROTOCOL_ENTITY_TOO_LARGE 413 +#define PROTOCOL_URI_TOO_LARGE 414 +#define PROTOCOL_UNSUPPORTED_MEDIA_TYPE 415 +#define PROTOCOL_REQUESTED_RANGE_NOT_SATISFIABLE 416 +#define PROTOCOL_EXPECTATION_FAILED 417 +#define PROTOCOL_LOCKED 423 +#define PROTOCOL_FAILED_DEPENDENCY 424 +#define PROTOCOL_SERVER_ERROR 500 +#define PROTOCOL_NOT_IMPLEMENTED 501 +#define PROTOCOL_BAD_GATEWAY 502 +#define PROTOCOL_SERVICE_UNAVAILABLE 503 +#define PROTOCOL_GATEWAY_TIMEOUT 504 +#define PROTOCOL_VERSION_NOT_SUPPORTED 505 +#define PROTOCOL_INSUFFICIENT_STORAGE 507 + +#define PROTOCOL_VERSION_HTTP09 9 +#define PROTOCOL_VERSION_HTTP10 100 +#define PROTOCOL_VERSION_HTTP11 101 +#define CURRENT_PROTOCOL_VERSION PROTOCOL_VERSION_HTTP11 + +/* Definitions for HTTP over SSL */ +#define HTTPS_PORT 443 +#define HTTPS_URL "https" + +/* Definitions for HTTP over TCP */ +#define HTTP_PORT 80 +#define HTTP_URL "http" + + +#define REQ_MAX_LINE 4096 + +/* + * The REQ_ return codes. These codes are used to determine what the server + * should do after a particular module completes its task. + * + * Func type functions return these as do many internal functions. + */ + +/* The function performed its task, proceed with the request */ +#define REQ_PROCEED 0 +/* The entire request should be aborted: An error occurred */ +#define REQ_ABORTED -1 +/* The function performed no task, but proceed anyway */ +#define REQ_NOACTION -2 +/* Tear down the session and exit */ +#define REQ_EXIT -3 +/* Restart the entire request-response process */ +#define REQ_RESTART -4 +/* Too busy to execute this now */ +#define REQ_TOOBUSY -5 + + +/**** NSAPI extensions ****/ + +/* The function is still in progress (async extension) */ +#define REQ_PROCESSING -8 + +/**** END NSAPI extensions ****/ + + +/* --- End miscellaneous definitions --- */ + +/* --- Begin native platform includes --- */ + +#ifdef XP_UNIX +#include +#include +#include /* new */ +#ifndef HPUX +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#endif /* XP_UNIX */ + +#ifdef XP_WIN32 +#include +#include +#include +#include +#endif /* XP_WIN32 */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/* --- End native platform includes --- */ + +/* --- Begin type definitions --- */ + +/* NOTE: both SYS_FILE and SYS_NETFD are actually NSPR PRFileDesc * and can */ +/* be used with NSPR API calls (after casting them to PRFileDesc *) */ + +#ifndef SYS_FILE_T +typedef void *SYS_FILE; +#define SYS_FILE_T void * +#endif /* !SYS_FILE_T */ + +#define SYS_ERROR_FD ((SYS_FILE)-1) + +#ifndef SYS_NETFD_T +typedef void *SYS_NETFD; +#define SYS_NETFD_T void * +#endif /* !SYS_NETFD_T */ + +/* Error value for a SYS_NETFD */ +#ifndef SYS_NET_ERRORFD +#define SYS_NET_ERRORFD ((SYS_NETFD)-1) +#endif /* !SYS_NET_ERRORFD */ + +/* + * These structures were originally defined in nsapi.h, but those definitions + * were removed in iPlanet Web Server 4.0. The contents of these structures + * are now private to the server implementation and must not be accessed + * directly. Instead, use the objset_*, object_*, directive_table_*, and + * directive_* accessor functions. + */ +typedef struct directive directive; +typedef struct dtable dtable; +typedef struct httpd_object httpd_object; +typedef struct httpd_objset httpd_objset; + +/* + * Type: filebuffer, filebuf_t + * + * Description: + * + * This structure is used to represent a buffered file. On some + * systems the file may be memory-mapped. A filebuffer is created + * by filebuf_open(), and destroyed by filebuf_close(). + * + * Notes: + * + * Direct access to the members of this structure, not using + * macros defined here, is discouraged. + * + * The filebuf alias that used to be defined for this type was + * found to conflict with a C++ class of the same name, so it + * has been renamed to filebuf_t. + */ +typedef struct filebuffer filebuffer; + +/* Version of filebuffer when memory-mapped files are supported */ +struct filebuffer { + SYS_FILE fd; +#ifdef XP_WIN32 + HANDLE fdmap; +#endif + caddr_t fp; + int len; + + unsigned char *inbuf; + int cursize; + + int pos; + const char *errmsg; +}; + +/* Return next character or IO_EOF */ +#define filebuf_getc(b) ((b)->pos == (b)->len ? IO_EOF : (int)((b)->fp)[(b)->pos++]) + +#define filebuf_iseof(b) ((b)->pos == (b)->len) + +/* C++ streamio defines a filebuf class. */ +typedef filebuffer filebuf_t; + +#ifdef XP_WIN32 +/* Use a filebuffer to read data from a pipe */ +#define pipebuf_getc(b) \ + ((b)->pos != (b)->cursize ? (int)((b)->inbuf[(b)->pos++]) : pipebuf_next(b,1)) +#endif /* XP_WIN32 */ + +/* + * Type: netbuf + * + * Description: + * + * This structure is used to represent a buffered network socket. + * It is created by netbuf_open(), and destroyed by netbuf_close(). + * + * Notes: + * + * Direct access to the members of this structure, not using + * macros defined here, is discouraged. + * + * The inbuf field used to be (unsigned char *), but is now + * simply (char *). The value returned by the netbuf_getc() + * macro is (int). + */ +typedef struct netbuf netbuf; +struct netbuf { + SYS_NETFD sd; + + int pos, cursize, maxsize, rdtimeout; +#ifdef XP_WIN32 + CHAR address[64]; +#endif /* XP_WIN32 */ + unsigned char *inbuf; + char *errmsg; +#ifndef XP_WIN32 + char address[64]; +#endif /* !XP_WIN32 */ +}; + +/* + * netbuf_getc gets a character from the given network buffer and returns + * it (as an integer). + * + * It will return (int) IO_ERROR for an error and (int) IO_EOF for + * an error condition or EOF respectively. + */ +#define netbuf_getc(b) \ + ((b)->pos != (b)->cursize ? (int)((b)->inbuf[(b)->pos++]) : netbuf_next(b,1)) + +/* + * buffer_error returns the last error that occurred with buffer. Don't use + * this unless you know an error occurred. Independent of network/file type. + */ +#define buffer_error(b) ((b)->errmsg) + +/* + * Type: sendfiledata + * + * Description: + * + * This structure is used to pass arguments to the net_sendfile() + * function. offset and len may be set to 0 to transmit a file in its + * entirety. + */ +typedef struct sendfiledata sendfiledata; +struct sendfiledata { + SYS_FILE fd; /* file to send */ + size_t offset; /* offset in file to start sending from */ + size_t len; /* number of bytes to send from file */ + const void *header; /* data to send before file */ + int hlen; /* number of bytes to send before file */ + const void *trailer; /* data to send after file */ + int tlen; /* number of bytes to send after file */ +}; + +/* + * Type: NSAPIIOVec + * + * Description: + * + * This structure is used to pass arguments to the net_writev() + * and FilterWritevFunc() functions. + */ +#ifdef _LP64 +typedef struct NSAPIIOVec NSAPIIOVec; +struct NSAPIIOVec { + char *iov_base; + int iov_len; +}; +#else +typedef struct iovec NSAPIIOVec; +#endif /* _LP64 */ + + +/* + * Type: cinfo + * + * Description: + * + * This is a structure that captures the information in the name/value + * pairs on one line of a mime.types file. A cinfo structure is + * stored in the memory-resident database, indexed by each of the + * file extensions specified in the "exts" name/value pair. It + * defines various attributes of resources with names containing + * the specified file extensions. + * + * Notes: + * + * Pointers to cinfo structures returned by this API may or may not + * need to freed by the caller. See the individual function + * descriptions. + * + * The strings referenced by the fields of cinfo structures returned + * by this API should be considered read-only, and do not need to be + * freed by the caller, even when the cinfo structure does. + */ +typedef struct cinfo cinfo; +struct cinfo { + char *type; + char *encoding; + char *language; +}; + + +typedef void* CONDVAR; +typedef void *COUNTING_SEMAPHORE; +typedef void* CRITICAL; + +#ifdef XP_UNIX +typedef DIR* SYS_DIR; +typedef struct dirent SYS_DIRENT; +#endif /* XP_UNIX */ + +#ifdef XP_WIN32 + +typedef struct dirent_s dirent_s; +struct dirent_s { + char *d_name; +}; + +typedef struct dir_s dir_s; +struct dir_s { + HANDLE dp; + WIN32_FIND_DATA fdata; + dirent_s de; +}; + +typedef dir_s* SYS_DIR; +typedef dirent_s SYS_DIRENT; + +#endif /* XP_WIN32 */ + +typedef struct pb_param pb_param; +struct pb_param { + char *name,*value; +}; + +typedef struct pb_entry pb_entry; +struct pb_entry { + pb_param *param; + struct pb_entry *next; +}; + +typedef struct pblock pblock; +struct pblock { + int hsize; + struct pb_entry **ht; +}; + +#ifndef POOL_HANDLE_T +#define POOL_HANDLE_T +typedef void *pool_handle_t; +#endif + +#ifndef SEMAPHORE_T +typedef void *SEMAPHORE; +#define SEMAPHORE_T void * +#endif /* !SEMAPHORE_T */ + +#define SESSION_HASHSIZE 5 + +typedef struct PListStruct_s PListStruct_s; +typedef struct ACLListHandle ACLListHandle; + +#ifndef PR_AF_INET +typedef union PRNetAddr PRNetAddr; +#endif + +typedef struct Session Session; +typedef struct Request Request; +struct Session { + pblock *client; /* client-specific information */ + + SYS_NETFD csd; /* client file descriptor */ + netbuf *inbuf; /* input buffer */ + int csd_open; + + struct in_addr iaddr; + + pool_handle_t *pool; + + void *clauth; /* v2 ACL client authentication information */ + struct Session *next; + int fill; + struct sockaddr_in local_addr; /* local addr for this session */ + + PListStruct_s *subject; + int ssl; /* 0 = SSL OFF, 1 = SSL ON */ + int clientauth; /* 0 = client auth OFF, 1 = client auth ON */ + + PRNetAddr *pr_client_addr; + PRNetAddr *pr_local_addr; +}; + +/* + * FuncPtr is a pointer to an NSAPI SAF function + */ + +#ifdef XP_UNIX +typedef int Func(pblock *, Session *, Request *); +#else /* XP_WIN32 */ +typedef int _cdecl Func(pblock *, Session *, Request *); +#endif /* XP_WIN32 */ + +typedef Func *FuncPtr; + +/* + * FuncStruct is a structure used in the static declaration of the + * functions. This static declaration is parsed into a hash table at + * startup. + */ + +typedef struct FuncStruct FuncStruct; + +struct FuncStruct { + const char * name; + FuncPtr func; + struct FuncStruct *next; + unsigned flags; + unsigned poolID; + unsigned pool_resolved; +}; + +/* + * VSInitFunc, VSDestroyFunc, VSDirectiveInitFunc and VSDirectiveDestroyFunc + */ +typedef struct VirtualServer VirtualServer; +typedef int VSInitFunc(VirtualServer *incoming, const VirtualServer *current); +typedef void VSDestroyFunc(VirtualServer *outgoing); +typedef VSInitFunc *VSInitFuncPtr; +typedef VSDestroyFunc *VSDestroyFuncPtr; +typedef int VSDirectiveInitFunc(const directive *dir, VirtualServer *incoming, const VirtualServer *current); +typedef void VSDirectiveDestroyFunc(const directive *dir, VirtualServer *outgoing); +typedef VSDirectiveInitFunc *VSDirectiveInitFuncPtr; +typedef VSDirectiveDestroyFunc *VSDirectiveDestroyFuncPtr; + +/* + * Filter is an opaque filter identifier + */ +typedef struct Filter Filter; + +/* + * FilterContext stores context associated with a particular filter layer + */ + +typedef struct FilterContext FilterContext; + +struct FilterContext { + pool_handle_t *pool; /* pool context was allocated from */ + Session *sn; /* session being processed */ + Request *rq; /* request being processed */ + void *data; /* filter-defined private data */ +}; + +/* + * FilterLayer represents one layer of a filter stack + */ + +typedef struct FilterLayer FilterLayer; + +struct FilterLayer { + Filter *filter; /* the filter at this layer in the filter stack */ + FilterContext *context; /* context for the filter */ + SYS_NETFD lower; /* access to the next filter layer in the stack */ +}; + +/* + * Function prototypes for filter methods + */ +typedef int (FilterInsertFunc)(FilterLayer *layer, pblock *pb); +typedef void (FilterRemoveFunc)(FilterLayer *layer); +typedef int (FilterFlushFunc)(FilterLayer *layer); +typedef int (FilterReadFunc)(FilterLayer *layer, void *buf, int amount, int timeout); +typedef int (FilterWriteFunc)(FilterLayer *layer, const void *buf, int amount); +typedef int (FilterWritevFunc)(FilterLayer *layer, const NSAPIIOVec *iov, int iov_size); +typedef int (FilterSendfileFunc)(FilterLayer *layer, sendfiledata *sfd); + +/* + * FilterMethods is passed to filter_create() to declare the filter methods for + * a new filter. Each instance of the FilterMethods structure should be + * initialized using the FILTER_METHODS_INITIALIZER macro. + */ + +typedef struct FilterMethods FilterMethods; + +struct FilterMethods { + size_t size; +#if NSAPI_VERSION >= 302 + FilterInsertFunc *insert; + FilterRemoveFunc *remove; + FilterFlushFunc *flush; + FilterReadFunc *read; + FilterWriteFunc *write; + FilterWritevFunc *writev; + FilterSendfileFunc *sendfile; +#else + void *reserved1; + void *reserved2; + void *reserved3; + void *reserved4; + void *reserved5; + void *reserved6; + void *reserved7; +#endif /* NSAPI_VERSION >= 302 */ +}; + +#define FILTER_METHODS_INITIALIZER \ +{ \ + sizeof(FilterMethods), \ + NULL, /* insert */ \ + NULL, /* remove */ \ + NULL, /* flush */ \ + NULL, /* read */ \ + NULL, /* write */ \ + NULL, /* writev */ \ + NULL /* sendfile */ \ +} + +/* + * Filter order definitions for filter_create() + */ +#define FILTER_CONTENT_GENERATION 0xf0000 +#define FILTER_CONTENT_TRANSLATION_HIGH 0xa0000 +#define FILTER_CONTENT_TRANSLATION 0x90000 +#define FILTER_CONTENT_TRANSLATION_LOW 0x80000 +#define FILTER_CONTENT_CODING 0x50000 +#define FILTER_TRANSFER_CODING 0x40000 +#define FILTER_MESSAGE_CODING 0x30000 +#define FILTER_TRANSPORT_CODING 0x20000 +#define FILTER_NETWORK 0x10000 + +typedef struct shmem_s shmem_s; +struct shmem_s { + void *data; /* the data */ +#ifdef XP_WIN32 + HANDLE fdmap; +#endif /* XP_WIN32 */ + int size; /* the maximum length of the data */ + + char *name; /* internal use: filename to unlink if exposed */ + SYS_FILE fd; /* internal use: file descriptor for region */ +}; + +/* Define a handle for a thread */ +typedef void* SYS_THREAD; + +/* Define an error value for the thread handle */ +#define SYS_THREAD_ERROR NULL + + +typedef struct conf_global_vars_s conf_global_vars_s; +struct conf_global_vars_s { + + /* What port we listen to */ + int Vport; /* OBSOLETE */ +#define server_portnum 80 + + /* What address to bind to */ + char *Vaddr; /* OBSOLETE */ + + /* User to run as */ + struct passwd *Vuserpw; + + /* Directory to chroot to */ + char *Vchr; + + /* Where to log our pid to */ + char *Vpidfn; + +#define pool_max conf_getglobals()->Vpool_max + int Vpool_max; +#define pool_min conf_getglobals()->Vpool_min + int Vpool_min; /* OBSOLETE */ +#define pool_life conf_getglobals()->Vpool_life + int Vpool_life; /* OBSOLETE */ + + /* For multiprocess UNIX servers, the maximum threads per process */ +#define pool_maxthreads conf_getglobals()->Vpool_maxthreads + int Vpool_maxthreads; + +#define pool_minthreads conf_getglobals()->Vpool_minthreads + int Vpool_minthreads; /* OBSOLETE */ + + char *Vsecure_keyfn; /* OBSOLETE */ + char *Vsecure_certfn; /* OBSOLETE */ + +#define security_active 0 + int Vsecurity_active; + int Vssl3_active; /* OBSOLETE */ + int Vssl2_active; /* OBSOLETE */ + int Vsecure_auth; /* OBSOLETE */ + int Vsecurity_session_timeout; + long Vssl3_session_timeout; + + /* The server's hostname as should be reported in self-ref URLs */ +#define server_hostname "x4" + char *Vserver_hostname; + + /* The main object from which all are derived */ +#define root_object conf_getglobals()->Vroot_object + char *Vroot_object; + + /* The object set the administrator has asked us to load */ +#define std_os conf_getglobals()->Vstd_os + httpd_objset *Vstd_os; + + /* The root of ACL data structures */ + void *Vacl_root; + + /* The main error log, where all errors are logged */ + char *Vmaster_error_log; + + /* The server root directory (contains instance subdirectories) */ +#define server_root conf_getglobals()->Vserver_root + char *Vserver_root; + + /* This server's id */ +#define server_id conf_getglobals()->Vserver_id + char *Vserver_id; + + /* Admin server users file */ + char *Vadmin_users; + + /* The installation directory (contains bin and lib subdirectories) */ + char *Vnetsite_root; + + /* Digest authentication stale nonce timeout value */ + int digest_stale_timeout; + + int single_accept; /* OBSOLETE */ + int num_keep_alives; /* OBSOLETE */ + int log_verbose; /* OBSOLETE */ + int mmap_flags; /* OBSOLETE */ + int mmap_prots; /* OBSOLETE */ + int unused1; + int unused2; + + /* Begin Enterprise 3.0 fields */ + int accept_language; /* turn accept-language on/off */ + + char *mtahost; + char *nntphost; /* OBSOLETE */ + + /* The root of ACL data structures */ + void *Vacl_root_30; + + char *agentFilePath; /* OBSOLETE */ + + int Allowed; /* OBSOLETE */ + + pblock *genericGlobals; /* OBSOLETE */ + + char *agentsACLFile; /* OBSOLETE */ + + int wait_for_cgi; /* OBSOLETE */ + int cgiwatch_timeout; /* OBSOLETE */ + int started_by_watchdog; + int restarted_by_watchdog; + int old_accel_cache_enabled; /* OBSOLETE */ + int Vssl_cache_entries; + int blocking_listen_socket; /* OBSOLETE */ + pblock **initfns; + char *vs_config_file; /* OBSOLETE */ +}; + +/* Type used for Request rq_attr bit flags */ +#ifdef AIX +#define RQATTR unsigned +#else +#define RQATTR unsigned long +#endif + +struct Request { + /* Server working variables */ + pblock *vars; + + /* The method, URI, and protocol revision of this request */ + pblock *reqpb; + /* Protocol specific headers */ + int loadhdrs; + pblock *headers; + + /* Server's response headers */ + int senthdrs; + pblock *srvhdrs; + + /* The object set constructed to fulfill this request */ + httpd_objset *os; + /* Array of objects that were created from .nsconfig files */ + httpd_objset *tmpos; + + /* The stat last returned by request_stat_path */ + char *statpath; + char *staterr; + struct stat *finfo; + + /* access control state */ + int aclstate; /* ACL decision state */ + int acldirno; /* deciding ACL directive number */ + char *aclname; /* name of deciding ACL */ + pblock *aclpb; /* OBSOLETE */ + /* 3.0 ACL list pointer */ + ACLListHandle *acllist; + + int request_is_cacheable; /* */ + int directive_is_cacheable; /* set by SAFs with no external side effects that make decisions based solely on URI and path */ + + char *cached_headers; /* OBSOLETE */ + int cached_headers_len; /* OBSOLETE */ + char *unused; + + /* HTTP/1.1 features */ +#define REQ_TIME(x) (x)->req_start + time_t req_start; /* time request arrived - used for selecting weak or strong cache validation */ + short protv_num; /* protocol version number */ + short method_num; /* method number */ + struct rq_attr { + RQATTR abs_uri:1; /* set if absolute URI was used */ + RQATTR chunked:1; /* chunked transfer-coding */ + RQATTR keep_alive:1; /* connection keep-alive */ + RQATTR pipelined:1; /* request packet is pipelined */ + RQATTR internal_req:1; /* this was an internal request */ + RQATTR perm_req:1; /* don't FREE() this request */ + RQATTR header_file_present:1; /* OBSOLETE */ + RQATTR footer_file_present:1; /* OBSOLETE */ + RQATTR jvm_attached:1; /* OBSOLETE */ + RQATTR req_restarted:1; /* request was restarted */ + RQATTR jvm_request_locked:1; /* used for first-request serialization on some platforms */ + RQATTR default_type_set:1; /* set if default types were set using set-default-type objecttype function */ + RQATTR is_web_app:1; /* OBSOLETE */ + RQATTR ssl_unclean_shutdown:1; /* set if browser requires unclean SSL shutdown */ + RQATTR vary_accept_language:1; /* set if request was restarted based on an accept-language header */ + RQATTR reserved:17; /* if you add a flag, make sure to subtract from this */ + } rq_attr; + char *hostname; /* hostname used to access server (always non-NULL) */ + int allowed; /* OBSOLETE */ + int byterange; /* OBSOLETE */ + short status_num; /* HTTP status code */ + + int staterrno; /* used for rqstat */ + Request *orig_rq; /* original Request - used for internal redirects */ +}; + +/* Request attribute macros */ +#define ABS_URI(x) (x)->rq_attr.abs_uri +#define CHUNKED(x) (x)->rq_attr.chunked +#define KEEP_ALIVE(x) (x)->rq_attr.keep_alive +#define PIPELINED(x) (x)->rq_attr.pipelined +#define INTERNAL_REQUEST(x) (x)->rq_attr.internal_req +#define RESTARTED_REQUEST(x) (x)->rq_attr.req_restarted +#define PERM_REQUEST(x) (x)->rq_attr.perm_req +#define JVM_REQUEST_LOCKED(x) (x)->rq_attr.jvm_request_locked +#define SSL_UNCLEAN_SHUTDOWN(x) (x)->rq_attr.ssl_unclean_shutdown +#define VARY_ACCEPT_LANGUAGE(x) (x)->rq_attr.vary_accept_language + +/* Define methods for HTTP/1.1 */ +#define METHOD_HEAD 0 +#define METHOD_GET 1 +#define METHOD_PUT 2 +#define METHOD_POST 3 +#define METHOD_DELETE 4 +#define METHOD_TRACE 5 +#define METHOD_OPTIONS 6 +/* The following methods are Netscape method extensions */ +#define METHOD_MOVE 7 +#define METHOD_INDEX 8 +#define METHOD_MKDIR 9 +#define METHOD_RMDIR 10 +#define METHOD_COPY 11 +#define METHOD_MAX 12 /* Number of methods available on this server */ + +#define ISMGET(r) ((r)->method_num == METHOD_GET) +#define ISMHEAD(r) ((r)->method_num == METHOD_HEAD) +#define ISMPUT(r) ((r)->method_num == METHOD_PUT) +#define ISMPOST(r) ((r)->method_num == METHOD_POST) +#define ISMDELETE(r) ((r)->method_num == METHOD_DELETE) +#define ISMMOVE(r) ((r)->method_num == METHOD_MOVE) +#define ISMINDEX(r) ((r)->method_num == METHOD_INDEX) +#define ISMMKDIR(r) ((r)->method_num == METHOD_MKDIR) +#define ISMRMDIR(r) ((r)->method_num == METHOD_RMDIR) +#define ISMCOPY(r) ((r)->method_num == METHOD_COPY) +#define ISMTRACE(r) ((r)->method_num == METHOD_TRACE) +#define ISMOPTIONS(r) ((r)->method_num == METHOD_OPTIONS) + + +/* --- End type definitions --- */ + +/* --- Begin dispatch vector table definition --- */ +/* --- End dispatch vector table definition --- */ + +/* --- Begin API macro definitions --- */ + +#ifndef INTNSAPI + +#if NSAPI_VERSION >= 301 + +/* + * In Sun ONE Web Server 6.1 and higher, http_parse_request("", NULL, NULL) + * returns the NSAPI version. In previous releases, it returns -1. + */ +#define __NSAPI_RUNTIME_VERSION \ + ((*__nsapi30_table->f_http_parse_request)("", NULL, NULL)) + +/* + * NSAPI_RUNTIME_VERSION returns the NSAPI version the server implements. The + * returned NSAPI version number is reliable only in iPlanet Web Server 6.0, + * Netscape Enterprise Server 6.0, and Sun ONE Web Server 6.0 and higher. + */ +#define NSAPI_RUNTIME_VERSION \ + (__NSAPI_RUNTIME_VERSION > 0 ? __NSAPI_RUNTIME_VERSION : 301) + +#endif /* NSAPI_VERSION >= 301 */ + +#define system_version (*__nsapi30_table->f_system_version) + +/* + * Depending on the system, memory allocated via these macros may come from + * an arena. If these functions are called from within an Init function, they + * will be allocated from permanent storage. Otherwise, they will be freed + * when the current request is finished. + */ + + + +#endif /* !INTNSAPI */ + +#ifdef XP_UNIX +#define dir_open opendir +#define dir_read readdir +#define dir_close closedir +#define dir_create(path) mkdir(path, 0755) +#define dir_remove rmdir +#define system_chdir chdir +#define file_unix2local(path,p2) strcpy(p2,path) +#endif /* XP_UNIX */ + +#ifdef XP_WIN32 +#define dir_create _mkdir +#define dir_remove _rmdir +#define system_chdir SetCurrentDirectory +#endif /* XP_WIN32 */ + +/* + * Thread-safe variants of localtime and gmtime + */ +#define system_localtime(curtime, ret) util_localtime(curtime, ret) +#define system_gmtime(curtime, ret) util_gmtime(curtime, ret) + +/* + * pblock_find finds the entry with the given name in pblock pb. + * + * If it is successful, it returns the param block. If not, it returns NULL. + */ +#define pblock_find(name, pb) (pblock_fr(name,pb,0)) + +/* + * pblock_remove behaves exactly like pblock_find, but removes the given + * entry from pb. + */ +#define pblock_remove(name, pb) (pblock_fr(name,pb,1)) + +/* + * session_dns returns the DNS hostname of the client of this session, + * and inserts it into the client pblock. Returns NULL if unavailable. + */ +#define session_dns(sn) session_dns_lookup(sn, 0) + +/* + * session_maxdns looks up a hostname from an IP address, and then verifies + * that the host is really who they claim to be. + */ +#define session_maxdns(sn) session_dns_lookup(sn, 1) + + +/* nsapi functions */ + +ssize_t net_write(SYS_NETFD fd, void *buf, size_t nbytes); + +NSAPI_PUBLIC pb_param *INTparam_create(const char *name, const char *value); + +NSAPI_PUBLIC int INTparam_free(pb_param *pp); + +NSAPI_PUBLIC pblock *INTpblock_create(int n); + +NSAPI_PUBLIC void INTpblock_free(pblock *pb); + +NSAPI_PUBLIC char *INTpblock_findval(const char *name, const pblock *pb); + +NSAPI_PUBLIC pb_param *INTpblock_nvinsert(const char *name, const char *value, pblock *pb); + +NSAPI_PUBLIC pb_param *pblock_nvlinsert(const char *name, int namelen, const char *value, int valuelen, pblock *pb); + +NSAPI_PUBLIC pb_param *INTpblock_nninsert(const char *name, int value, pblock *pb); + +NSAPI_PUBLIC void INTpblock_pinsert(pb_param *pp, pblock *pb); + +NSAPI_PUBLIC int INTpblock_str2pblock(const char *str, pblock *pb); + +NSAPI_PUBLIC char *INTpblock_pblock2str(const pblock *pb, char *str); + +NSAPI_PUBLIC int INTpblock_copy(const pblock *src, pblock *dst); + +NSAPI_PUBLIC pblock *INTpblock_dup(const pblock *src); + +NSAPI_PUBLIC char **INTpblock_pb2env(const pblock *pb, char **env); + +NSAPI_PUBLIC void pblock_nvreplace (const char *name, const char *value, pblock *pb); + +NSAPI_PUBLIC pb_param *pblock_param_create(pblock *pb, const char *name, const char *value); + +NSAPI_PUBLIC pblock *pblock_create_pool(pool_handle_t *pool_handle, int n); + +NSAPI_PUBLIC pb_param *INTpblock_fr(const char *name, pblock *pb, int remove); + +NSAPI_PUBLIC char *INTpblock_replace(const char *name,char * new_value,pblock *pb); + +NSAPI_PUBLIC int INTpblock_str2pblock_lowercasename(const char *str, pblock *pb); + +//NSAPI_PUBLIC pb_param *pblock_removeone(pblock *pb); + +//NSAPI_PUBLIC const pb_key *pblock_key(const char *name); + +//NSAPI_PUBLIC pb_param *pblock_key_param_create(pblock *pb, const pb_key *key, const char *value, int valuelen); + +//NSAPI_PUBLIC char *pblock_findkeyval(const pb_key *key, const pblock *pb); + +//NSAPI_PUBLIC pb_param *pblock_findkey(const pb_key *key, const pblock *pb); + +//NSAPI_PUBLIC pb_param *pblock_removekey(const pb_key *key, pblock *pb); + +//NSAPI_PUBLIC pb_param *pblock_kvinsert(const pb_key *key, const char *value, int valuelen, pblock *pb); + +//NSAPI_PUBLIC void pblock_kpinsert(const pb_key *key, pb_param *pp, pblock *pb); + +//NSAPI_PUBLIC void pblock_kvreplace(const pb_key *key, const char *value, int valuelen, pblock *pb); + +//NSAPI_PUBLIC pb_param *pblock_kninsert(const pb_key *key, int value, pblock *pb); + +//NSAPI_PUBLIC pb_param *pblock_kllinsert(const pb_key *key, PRInt64 value, pblock *pb); + +#define param_create INTparam_create +#define param_free INTparam_free +#define pblock_create INTpblock_create +#define pblock_free INTpblock_free +#define pblock_findval INTpblock_findval +#define pblock_nvinsert INTpblock_nvinsert +#define pblock_nninsert INTpblock_nninsert +#define pblock_pinsert INTpblock_pinsert +#define pblock_str2pblock INTpblock_str2pblock +#define pblock_pblock2str INTpblock_pblock2str +#define pblock_copy INTpblock_copy +#define pblock_dup INTpblock_dup +#define pblock_pb2env INTpblock_pb2env +#define pblock_fr INTpblock_fr +#define pblock_replace INTpblock_replace + + + +void protocol_status(Session *sn, Request *rq, int n, const char *m); + +int http_start_response(Session *sn, Request *rq); +#define protocol_start_response http_start_response +int request_header(char *name, char **value, Session *sn, Request *rq); + +typedef void (*thrstartfunc)(void *); +SYS_THREAD INTsysthread_start(int prio, int stksz, thrstartfunc fn, void *arg); +NSAPI_PUBLIC void INTsysthread_sleep(int milliseconds); + +#define systhread_start INTsysthread_start +#define systhread_sleep INTsysthread_sleep + + +void webserver_atrestart(void (*fn)(void *), void *data); +#define magnus_atrestart webserver_atrestart + + +NSAPI_PUBLIC int INTshexp_match(const char *str, const char *exp); +#define shexp_match INTshexp_match + + + +NSAPI_PUBLIC char *session_dns_lookup(Session *s, int verify); + + +/* --- OBSOLETE ---------------------------------------------------------- + * The following macros/functions are obsolete and are only maintained for + * compatibility. Do not use them. + * ----------------------------------------------------------------------- + */ + + +/* new macro and function definitions begin */ + +/* netbuf functions */ +NSAPI_PUBLIC netbuf *netbuf_open(SYS_NETFD sd, int sz); + +NSAPI_PUBLIC void netbuf_close(netbuf *buf); + +NSAPI_PUBLIC unsigned char * netbuf_replace(netbuf *buf, + unsigned char *inbuf, int pos, int cursize, int maxsize); + +NSAPI_PUBLIC int netbuf_next(netbuf *buf, int advance); + +NSAPI_PUBLIC int netbuf_getbytes(netbuf *buf, char *buffer, int size); + +NSAPI_PUBLIC int netbuf_grab(netbuf *buf, int sz); + +/* end new macro and function definitions */ + +#define SYS_STDERR STDERR_FILENO + +#ifdef XP_WIN32 + +typedef HANDLE pid_t; + +#define ERROR_PIPE \ + (ERROR_BROKEN_PIPE | ERROR_BAD_PIPE | \ + ERROR_PIPE_BUSY | ERROR_PIPE_LISTENING | ERROR_PIPE_NOT_CONNECTED) +#define CONVERT_TO_PRINTABLE_FORMAT(Filename) \ +{ \ + register char *s; \ + if (Filename) \ + for (s = Filename; *s; s++) \ + if ( *s == '\\') \ + *s = '/'; \ +} +#define CONVERT_TO_NATIVE_FS(Filename) \ +{ \ + register char *s; \ + if (Filename) \ + for (s = Filename; *s; s++) \ + if ( *s == '/') \ + *s = '\\'; \ +} + +#ifdef INTNSAPI +NSAPI_PUBLIC extern nsapi_dispatch_t *__nsapi30_table; +#if NSAPI_VERSION >= 302 +NSAPI_PUBLIC extern nsapi302_dispatch_t *__nsapi302_table; +#endif /* NSAPI_VERSION >= 302 */ +#if NSAPI_VERSION >= 303 +NSAPI_PUBLIC extern nsapi303_dispatch_t *__nsapi303_table; +#endif /* NSAPI_VERSION >= 303 */ +#else +__declspec(dllimport) nsapi_dispatch_t *__nsapi30_table; +#if NSAPI_VERSION >= 302 +__declspec(dllimport) nsapi302_dispatch_t *__nsapi302_table; +#endif /* NSAPI_VERSION >= 302 */ +#if NSAPI_VERSION >= 303 +__declspec(dllimport) nsapi303_dispatch_t *__nsapi303_table; +#endif /* NSAPI_VERSION >= 303 */ +#endif /* INTNSAPI */ + +#else /* !XP_WIN32 */ + + +#endif /* XP_WIN32 */ + +#ifdef __cplusplus +} +#endif + +#endif /* !PUBLIC_NSAPI_H */