Difference between revisions of "Unit HTTP"

Revision as of 05:25, 24 March 2017

`HTTP_TAB = Chr(9);`	Tab
`HTTP_SPACE = Chr(32);`	Space
`HTTP_DASH = '-';`	-
`HTTP_COLON = ':';`	:
`HTTP_LINE_END = Chr(13) + Chr(10);`	CR LF

`HTTP_PORT_SEPARATOR = ':';`	:
`HTTP_PATH_SEPARATOR = '/';`	/
`HTTP_QUERY_SEPARATOR = '?';`	?
`HTTP_PARAM_SEPARATOR = '=';`	=
`HTTP_PARAM_DELIMITER = '&';`	&
`HTTP_HEADER_SEPARATOR = ':';`	:
`HTTP_BOOKMARK_SEPARATOR = '#';`	#
`HTTP_PROTOCOL_SEPARATOR = '://';`	://

`HTTP_BUFFER_SIZE = SIZE_2K;`

HTTP date HTTP_DATE_*

`HTTP_DATE_FORMAT_RFC1123 = 'ddd, dd mmm yyyy hh:nn:ss "GMT"';`	RFC 822, updated by RFC 1123
`HTTP_DATE_FORMAT_RFC850 = 'dddd, dd-mmm-yy hh:nn:ss "GMT"';`	RFC 850, obsoleted by RFC 1036
`HTTP_DATE_FORMAT_ANSIC = 'ddd mmm d hh:nn:ss yyyy';`	ANSI C's asctime() format

`HTTP_DATE_FORMAT = HTTP_DATE_FORMAT_RFC1123;`

HTTP client HTTP_*

`HTTP_USERAGENT_STRING = 'Mozilla/5.0 (compatible; Ultibo/' + ULTIBO_RELEASE_VERSION + ')';`
`HTTP_REQUEST_TIMEOUT = 60000;`	60 seconds
`HTTP_KEEPALIVE_TIMEOUT = 300;`	300 seconds (5 minutes)
`HTTP_MAX_REDIRECTS = 16;`
`HTTP_PROXY_PORT_DEFAULT = 8080;`

HTTP server HTTP_SERVER_*

`HTTP_SERVER_STRING = 'Ultibo/' + ULTIBO_RELEASE_VERSION;`

HTTP protocol HTTP_PROTOCOL_*

`HTTP_PROTOCOL_NONE = 0;`
`HTTP_PROTOCOL_HTTP = 1;`
`HTTP_PROTOCOL_HTTPS = 2;`

`HTTP_PROTOCOL_STRING_HTTP = 'http';`
`HTTP_PROTOCOL_STRING_HTTPS = 'https';`

HTTP method HTTP_METHOD_*

`HTTP_METHOD_NONE = 0;`
`HTTP_METHOD_OPTIONS = 1;`
`HTTP_METHOD_GET = 2;`
`HTTP_METHOD_HEAD = 3;`
`HTTP_METHOD_POST = 4;`
`HTTP_METHOD_PUT = 5;`
`HTTP_METHOD_DELETE = 6;`
`HTTP_METHOD_TRACE = 7;`
`HTTP_METHOD_CONNECT = 8;`

`HTTP_METHOD_STRING_OPTIONS = 'OPTIONS';`
`HTTP_METHOD_STRING_GET = 'GET';`
`HTTP_METHOD_STRING_HEAD = 'HEAD';`
`HTTP_METHOD_STRING_POST = 'POST';`
`HTTP_METHOD_STRING_PUT = 'PUT';`
`HTTP_METHOD_STRING_DELETE = 'DELETE';`
`HTTP_METHOD_STRING_TRACE = 'TRACE';`
`HTTP_METHOD_STRING_CONNECT = 'CONNECT';`

HTTP version HTTP_VERSION_*

`HTTP_VERSION_00 = 0;`
`HTTP_VERSION_10 = 1;`
`HTTP_VERSION_11 = 2;`

`HTTP_VERSION = HTTP_VERSION_11;`

`HTTP_VERSION_STRING_10 = 'HTTP/1.0';`
`HTTP_VERSION_STRING_11 = 'HTTP/1.1';`

HTTP encoding HTTP_ENCODING_*

`HTTP_ENCODING_NONE = 0;`
`HTTP_ENCODING_IDENTITY = 1;`
`HTTP_ENCODING_CHUNKED = 2;`
`HTTP_ENCODING_GZIP = 3;`
`HTTP_ENCODING_COMPRESS = 4;`
`HTTP_ENCODING_DEFLATE = 5;`

`HTTP_ENCODING_STRING_IDENTITY = 'identity';`
`HTTP_ENCODING_STRING_CHUNKED = 'chunked';`
`HTTP_ENCODING_STRING_GZIP = 'gzip';`
`HTTP_ENCODING_STRING_COMPRESS = 'compress';`
`HTTP_ENCODING_STRING_DEFLATE = 'deflate';`

HTTP general header HTTP_GENERAL_HEADER_*

`HTTP_GENERAL_HEADER_CACHE_CONTROL = 'Cache-Control';`
`HTTP_GENERAL_HEADER_CONNECTION = 'Connection';`
`HTTP_GENERAL_HEADER_DATE = 'Date';`
`HTTP_GENERAL_HEADER_PRAGMA = 'Pragma';`
`HTTP_GENERAL_HEADER_TRAILER = 'Trailer';`
`HTTP_GENERAL_HEADER_TRANSFER_ENCODING = 'Transfer-Encoding';`
`HTTP_GENERAL_HEADER_UPGRADE = 'Upgrade';`
`HTTP_GENERAL_HEADER_VIA = 'Via';`
`HTTP_GENERAL_HEADER_WARNING = 'Warning';`

HTTP request header HTTP_REQUEST_HEADER_*

`HTTP_REQUEST_HEADER_ACCEPT = 'Accept';`
`HTTP_REQUEST_HEADER_ACCEPT_CHARSET = 'Accept-Charset';`
`HTTP_REQUEST_HEADER_ACCEPT_ENCODING = 'Accept-Encoding';`
`HTTP_REQUEST_HEADER_ACCEPT_LANGUAGE = 'Accept-Language';`
`HTTP_REQUEST_HEADER_AUTHORIZATION = 'Authorization';`
`HTTP_REQUEST_HEADER_EXPECT = 'Expect';`
`HTTP_REQUEST_HEADER_FROM = 'From';`
`HTTP_REQUEST_HEADER_HOST = 'Host';`
`HTTP_REQUEST_HEADER_IF_MATCH = 'If-Match';`
`HTTP_REQUEST_HEADER_IF_MODIFIED_SINCE = 'If-Modified-Since';`
`HTTP_REQUEST_HEADER_IF_NONE_MATCH = 'If-None-Match';`
`HTTP_REQUEST_HEADER_IF_RANGE = 'If-Range'`
`HTTP_REQUEST_HEADER_IF_UNMODIFIED_SINCE = 'If-Unmodified-Since';`
`HTTP_REQUEST_HEADER_MAX_FORWARDS = 'Max-Forwards';`
`HTTP_REQUEST_HEADER_PROXY_AUTH = 'Proxy-Authorization';`
`HTTP_REQUEST_HEADER_RANGE = 'Range';`
`HTTP_REQUEST_HEADER_REFERER = 'Referer';`
`HTTP_REQUEST_HEADER_TE = 'TE';`
`HTTP_REQUEST_HEADER_USER_AGENT = 'User-Agent';`

HTTP response header HTTP_RESPONSE_HEADER_*

`HTTP_RESPONSE_HEADER_ACCEPT_RANGES = 'Accept-Ranges';`
`HTTP_RESPONSE_HEADER_AGE = 'Age';`
`HTTP_RESPONSE_HEADER_ETAG = 'ETag';`
`HTTP_RESPONSE_HEADER_LOCATION = 'Location';`
`HTTP_RESPONSE_HEADER_PROXY_AUTH = 'Proxy-Authenticate';`
`HTTP_RESPONSE_HEADER_RETRY_AFTER = 'Retry-After';`
`HTTP_RESPONSE_HEADER_SERVER = 'Server';`
`HTTP_RESPONSE_HEADER_VARY = 'Vary';`
`HTTP_RESPONSE_HEADER_WWW_AUTHENTICATE = 'WWW-Authenticate';`

HTTP entity header HTTP_ENTITY_HEADER_*

`HTTP_ENTITY_HEADER_ALLOW = 'Allow';`
`HTTP_ENTITY_HEADER_CONTENT_ENCODING = 'Content-Encoding';`
`HTTP_ENTITY_HEADER_CONTENT_LENGTH = 'Content-Length';`
`HTTP_ENTITY_HEADER_CONTENT_LOCATION = 'Content-Location';`
`HTTP_ENTITY_HEADER_CONTENT_MD5 = 'Content-MD5';`
`HTTP_ENTITY_HEADER_CONTENT_RANGE = 'Content-Range';`
`HTTP_ENTITY_HEADER_CONTENT_TYPE = 'Content-Type';`
`HTTP_ENTITY_HEADER_EXPIRES = 'Expires';`
`HTTP_ENTITY_HEADER_LAST_MODIFIED = 'Last-Modified';`

HTTP status HTTP_STATUS_*

`HTTP_STATUS_NONE = 0;`
`HTTP_STATUS_CONTINUE = 100;`	Continue
`HTTP_STATUS_SWITCH_PROTOCOL = 101;`	Switching Protocols
`HTTP_STATUS_OK = 200;`	OK
`HTTP_STATUS_CREATED = 201;`	Created
`HTTP_STATUS_ACCEPTED = 202;`	Accepted
`HTTP_STATUS_NON_AUTHORITATIVE = 203;`	Non-Authoritative Information
`HTTP_STATUS_NO_CONTENT = 204;`	No Content
`HTTP_STATUS_RESET_CONTENT = 205;`	Reset Content
`HTTP_STATUS_PARTIAL_CONTENT = 206;`	Partial Content
`HTTP_STATUS_MULTIPLE_CHOICES = 300;`	Multiple Choices
`HTTP_STATUS_MOVED_PERMANENT = 301;`	Moved Permanently
`HTTP_STATUS_FOUND = 302;`	Found
`HTTP_STATUS_SEE_OTHER = 303;`	See Other
`HTTP_STATUS_NOT_MODIFIED = 304;`	Not Modified
`HTTP_STATUS_USE_PROXY = 305;`	Use Proxy
`HTTP_STATUS_TEMPORARY_REDIRECT = 307;`	Temporary Redirect
`HTTP_STATUS_BAD_REQUEST = 400;`	Bad Request
`HTTP_STATUS_UNAUTHORIZED = 401;`	Unauthorized
`HTTP_STATUS_PAYMENT_REQUIRED = 402;`	Payment Required
`HTTP_STATUS_FORBIDDEN = 403;`	Forbidden
`HTTP_STATUS_NOT_FOUND = 404;`	Not Found
`HTTP_STATUS_METHOD_NOT_ALLOWED = 405;`	Method Not Allowed
`HTTP_STATUS_NOT_ACCEPTABLE = 406;`	Not Acceptable
`HTTP_STATUS_PROXY_AUTH_REQUIRED = 407;`	Proxy Authentication Required
`HTTP_STATUS_REQUEST_TIMEOUT = 408;`	Request Time-out
`HTTP_STATUS_CONFLICT = 409;`	Conflict
`HTTP_STATUS_GONE = 410;`	Gone
`HTTP_STATUS_LENGTH_REQUIRED = 411;`	Length Required
`HTTP_STATUS_PRECONDITION_FAILED = 412;`	Precondition Failed
`HTTP_STATUS_ENTITY_TOO_LARGE = 413;`	Request Entity Too Large
`HTTP_STATUS_URI_TOO_LARGE = 414;`	Request-URI Too Large
`HTTP_STATUS_UNSUPPORTED_MEDIA = 415;`	Unsupported Media Type
`HTTP_STATUS_RANGE_NOT_SATISFIED = 416;`	Requested range not satisfiable
`HTTP_STATUS_EXPECTATION_FAILED = 417;`	Expectation Failed
`HTTP_STATUS_INTERNAL_SERVER_ERROR = 500;`	Internal Server Error
`HTTP_STATUS_NOT_IMPLEMENTED = 501;`	Not Implemented
`HTTP_STATUS_BAD_GATEWAY = 502;`	Bad Gateway
`HTTP_STATUS_SERICE_UNAVAILABLE = 503;`	Service Unavailable
`HTTP_STATUS_GATEWAY_TIMEOUT = 504;`	Gateway Time-out
`HTTP_STATUS_VERSION_NOT_SUPPORTED = 505;`	HTTP Version not supported

`HTTP_MIN_STATUS = 100;`
`HTTP_MAX_STATUS = 599;`

HTTP reason HTTP_REASON_*

`HTTP_REASON_100 = 'Continue';`
`HTTP_REASON_101 = 'Switching Protocols';`
`HTTP_REASON_200 = 'OK';`
`HTTP_REASON_201 = 'Created';`
`HTTP_REASON_202 = 'Accepted';`
`HTTP_REASON_203 = 'Non-Authoritative Information';`
`HTTP_REASON_204 = 'No Content';`
`HTTP_REASON_205 = 'Reset Content';`
`HTTP_REASON_206 = 'Partial Content';`
`HTTP_REASON_300 = 'Multiple Choices';`
`HTTP_REASON_301 = 'Moved Permanently';`
`HTTP_REASON_302 = 'Found';`
`HTTP_REASON_303 = 'See Other';`
`HTTP_REASON_304 = 'Not Modified';`
`HTTP_REASON_305 = 'Use Proxy';`
`HTTP_REASON_307 = 'Temporary Redirect';`
`HTTP_REASON_400 = 'Bad Request';`
`HTTP_REASON_401 = 'Unauthorized';`
`HTTP_REASON_402 = 'Payment Required';`
`HTTP_REASON_403 = 'Forbidden';`
`HTTP_REASON_404 = 'Not Found';`
`HTTP_REASON_405 = 'Method Not Allowed';`
`HTTP_REASON_406 = 'Not Acceptable';`
`HTTP_REASON_407 = 'Proxy Authentication Required';`
`HTTP_REASON_408 = 'Request Time-out';`
`HTTP_REASON_409 = 'Conflict';`
`HTTP_REASON_410 = 'Gone';`
`HTTP_REASON_411 = 'Length Required';`
`HTTP_REASON_412 = 'Precondition Failed';`
`HTTP_REASON_413 = 'Request Entity Too Large';`
`HTTP_REASON_414 = 'Request-URI Too Large';`
`HTTP_REASON_415 = 'Unsupported Media Type';`
`HTTP_REASON_416 = 'Requested range not satisfiable';`
`HTTP_REASON_417 = 'Expectation Failed';`
`HTTP_REASON_500 = 'Internal Server Error';`
`HTTP_REASON_501 = 'Not Implemented';`
`HTTP_REASON_502 = 'Bad Gateway';`
`HTTP_REASON_503 = 'Service Unavailable';`
`HTTP_REASON_504 = 'Gateway Time-out';`
`HTTP_REASON_505 = 'HTTP Version not supported ';`

HTTP content type HTTP_CONTENT_*

`HTTP_CONTENT_TEXT_HTML = 'text/html';`

HTTP cache control HTTP_CACHE_*

`HTTP_CACHE_NO_CACHE = 'no-cache';`

HTTP connection HTTP_CONNECTION_*

`HTTP_CONNECTION_CLOSE = 'close';`
`HTTP_CONNECTION_KEEPALIVE = 'keep-alive';`

HTTP request flag HTTP_REQUEST_FLAG_*

`HTTP_REQUEST_FLAG_NONE = $00000000;`
`HTTP_REQUEST_FLAG_CONTENT_RECEIVED = $00000001;`	Server
`HTTP_REQUEST_FLAG_LINE_SENT = $00000002;`	Client
`HTTP_REQUEST_FLAG_HEADERS_SENT = $00000004;`	Client
`HTTP_REQUEST_FLAG_CONTENT_SENT = $00000008;`	Client

HTTP response flag HTTP_RESPONSE_FLAG_*

`HTTP_RESPONSE_FLAG_NONE = $00000000;`
`HTTP_RESPONSE_FLAG_STATUS_SENT = $00000001;`	Server
`HTTP_RESPONSE_FLAG_HEADERS_SENT = $00000002;`	Server
`HTTP_RESPONSE_FLAG_CONTENT_SENT = $00000004;`	Server
`HTTP_RESPONSE_FLAG_CONNECTION_CLOSE = $00000008;`	Server / Client
`HTTP_RESPONSE_FLAG_NO_CACHE = $00000010;`	Server / Client
`HTTP_RESPONSE_FLAG_CONTENT_RECEIVED = $00000020;`	Client

HTTP client state HTTP_CLIENT_STATE_*

`HTTP_CLIENT_STATE_NONE = 0;`
`HTTP_CLIENT_STATE_REQUEST = 1;`
`HTTP_CLIENT_STATE_REDIRECT = 2;`
`HTTP_CLIENT_STATE_SUCCESS = 3;`
`HTTP_CLIENT_STATE_FAILURE = 4;`

HTTP host flag HTTP_HOST_FLAG_*

`HTTP_HOST_FLAG_NONE = $00000000;`
`HTTP_HOST_FLAG_DEFAULT = $00000001;`
`HTTP_HOST_FLAG_DOMAIN = $00000002;`

HTTP CGI flag HTTP_CGI_FLAG_*

`HTTP_CGI_FLAG_NONE = $00000000;`
`HTTP_CGI_FLAG_FOLDER = $00000001;`
`HTTP_CGI_FLAG_SUBTREE = $00000002;`
`HTTP_CGI_FLAG_EXTENSION = $00000004;`

HTTP error flag HTTP_ERROR_FLAG_*

`HTTP_ERROR_FLAG_NONE = $00000000;`
`HTTP_ERROR_FLAG_DEFAULT = $00000001;`

HTTP module flag HTTP_MODULE_FLAG_*

`HTTP_MODULE_FLAG_NONE = $00000000;`

HTTP document flag HTTP_DOCUMENT_FLAG_*

`HTTP_DOCUMENT_FLAG_NONE = $00000000;`
`HTTP_DOCUMENT_FLAG_DEFAULT = $00000001;`
`HTTP_DOCUMENT_FLAG_FOLDER = $00000002;`
`HTTP_DOCUMENT_FLAG_SUBTREE = $00000004;`
`HTTP_DOCUMENT_FLAG_EXTENSION = $00000008;`

HTTP mime type HTTP_MIME_TYPE_*

See: Apache mime.types file
`HTTP_MIME_TYPE_MAX = 28;`

`HTTP_MIME_TYPES:array[0..HTTP_MIME_TYPE_MAX,0..1] of String = (`
`('avi','video/x-msvideo'),`
`('bat','application/x-msdownload'),`
`('bmp','image/bmp'),`
`('com','application/x-msdownload'),`
`('conf','text/plain'),`
`('css','text/css'),`
`('dll','application/x-msdownload'),`
`('doc','application/msword'),`
`('dot','application/msword'),`
`('exe','application/x-msdownload'),`
`('gif','image/gif'),`
`('html','text/html'),`
`('htm','text/html'),`
`('iso','application/octet-stream'),`
`('jpeg','image/jpeg'),`
`('jpg','image/jpeg'),`
`('pdf','application/pdf'),`
`('png','image/png'),`
`('txt','text/plain'),`
`('text','text/plain'),`
`('log','text/plain'),`
`('mov','video/quicktime'),`
`('mp3','audio/mpeg'),`
`('mp4','video/mp4'),`
`('msi','application/x-msdownload'),`
`('qt','video/quicktime'),`
`('tar','application/x-tar'),`
`('wmv','video/x-ms-wmv'),`
`('zip','application/zip') );`

`HTTP_MIME_TYPE_DEFAULT = 'application/octet-stream';`

HTTP logging HTTP_LOG_LEVEL_*

`HTTP_LOG_LEVEL_DEBUG = LOG_LEVEL_DEBUG;`	HTTP debugging messages
`HTTP_LOG_LEVEL_INFO = LOG_LEVEL_INFO;`	HTTP informational messages
`HTTP_LOG_LEVEL_ERROR = LOG_LEVEL_ERROR;`	HTTP error messages
`HTTP_LOG_LEVEL_NONE = LOG_LEVEL_NONE;`	No HTTP messages

Type definitions

HTTP reserved chars

`THTTPReservedChars = set of AnsiChar;`

HTTP redirect event

`THTTPRedirectEvent = function(AClient:THTTPClient; const AURL:String; var ALocation:String):Boolean of Object;`

HTTP password event

`THTTPPasswordEvent = function(AClient:THTTPClient; var AUsername,APassword:String):Boolean of Object;`

HTTP host event

`THTTPHostEvent = function(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean of Object;`

HTTP error event

`THTTPErrorEvent = function(AHost:THTTPHost; AError:THTTPError; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean of Object;`

HTTP module event

`THTTPModuleEvent = function(AHost:THTTPHost; AModule:THTTPModule; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean of Object;`

HTTP document event

`THTTPDocumentEvent = function(AHost:THTTPHost; ADocument:THTTPDocument; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean of Object;`

Class definitions

HTTP buffer

THTTPBuffer = class(TObject)

public
`constructor Create(ASize:LongWord);`
`destructor Destroy; override;`
private
`FLock:TCriticalSectionHandle;`

`FData:Pointer;`
`FSize:LongWord;`
`FCount:LongWord;`
`FStart:LongWord;`

`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function GetCount:LongWord;`
public
`property Count:LongWord read GetCount;`

`procedure Clear;`

`function ReadData:Char;`
`function WriteData(AChar:Char):Boolean;`

`function ReadLock(var ASize:LongWord):Pointer;`
`function ReadUnlock(ACount:LongWord):Boolean;`

`function WriteLock(var ASize:LongWord):Pointer;`
`function WriteUnlock(ACount:LongWord):Boolean;`

HTTP parameter

THTTPParam = class(TListObject)

public
`constructor Create(const AName:String);`
private
`FName:String;`
`FHash:LongWord;`
`FValue:String;`
public
`property Name:String read FName;`
`property Hash:LongWord read FHash;`
`property Value:String read FValue write FValue;`

HTTP parameters

THTTPParams = class(TObject)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FParams:TLinkedObjList;`
public
`procedure Clear;`

`function GetCount:Integer;`

`function GetParam(APrevious:THTTPParam):THTTPParam;`
`function FindParam(const AName:String):THTTPParam;`

`function AddParam(const AName,AValue:String):Boolean;`
`function DeleteParam(const AName:String):Boolean;`

HTTP header

THTTPHeader = class(TListObject)

public
`constructor Create(const AName:String);`
`destructor Destroy; override;`
private
`FName:String;`
`FHash:LongWord;`
`FValues:TLinkedStringList;`
public
`property Name:String read FName;`
`property Hash:LongWord read FHash;`

`function GetCount:Integer;`

`function GetValue(AIndex:Integer):String;`
`function SetValue(AIndex:Integer; const AValue:String):Boolean;`
`function FindValue(const AValue:String):Integer;`

`function AddValue(const AValue:String):Boolean;`
`function DeleteValue(const AValue:String):Boolean;`

HTTP headers

THTTPHeaders = class(TObject)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FHeaders:TLinkedObjList;`
public
`procedure Clear;`

`function GetCount:Integer;`

`function GetHeader(APrevious:THTTPHeader):THTTPHeader;`
`function FindHeader(const AName:String):THTTPHeader;`

`function AddHeader(const AName,AValue:String):Boolean;`
`function DeleteHeader(const AName:String):Boolean;`

HTTP client request

THTTPClientRequest = class(TObject)

public
`constructor Create(AClient:THTTPClient);`
`destructor Destroy; override;`
private
`FFlags:LongWord;`

`function GetLineSent:Boolean;`
`function GetHeadersSent:Boolean;`
`function GetContentSent:Boolean;`
protected
`FClient:THTTPClient;`
public
`URL:String;`
`Method:LongWord;`
`Version:LongWord;`

`Params:THTTPParams;`
`Headers:THTTPHeaders;`

`Protocol:String;`
`Host:String;`
`Port:String;`
`Path:String;`
`Query:String;`

`ContentStream:TStream;`
`ContentString:String;`

`RedirectCount:LongWord;`

`property Flags:LongWord read FFlags;`
`property Client:THTTPClient read FClient;`

`property LineSent:Boolean read GetLineSent;`
`property HeadersSent:Boolean read GetHeadersSent;`
`property ContentSent:Boolean read GetContentSent;`

`function Clear:Boolean;`

`function SetParam(const AName,AValue:String):Boolean;`
`function SetParamEx(const AName,AValue:String; AReplace:Boolean):Boolean;`

`function SetHeader(const AName,AValue:String):Boolean;`
`function SetHeaderEx(const AName,AValue:String; AReplace:Boolean):Boolean;`

`function WriteRequest:Boolean;`

`function WriteLine:Boolean;`
`function WriteHeaders:Boolean;`
`function WriteContentStream(AContent:TStream; ASize:LongWord; ACompleted:Boolean):Boolean;`
`function WriteContentString(const AContent:String; ASize:LongWord; ACompleted:Boolean):Boolean;`

HTTP client response

THTTPClientResponse = class(TObject)

public
`constructor Create(AClient:THTTPClient);`
`destructor Destroy; override;`
private
`FFlags:LongWord;`

`function GetContentReceived:Boolean;`

`function GetNoCache:Boolean;`
`procedure SetNoCache(ANoCache:Boolean);`
`function GetConnectionClose:Boolean;`
`procedure SetConnectionClose(AConnectionClose:Boolean);`
protected
`FClient:THTTPClient;`
public
`Reason:String;`
`Status:LongWord;`
`Version:LongWord;`

`Headers:THTTPHeaders;`

`property Flags:LongWord read FFlags;`
`property Client:THTTPClient read FClient;`

`property ContentReceived:Boolean read GetContentReceived;`

`property NoCache:Boolean read GetNoCache write SetNoCache;`
`property ConnectionClose:Boolean read GetConnectionClose write SetConnectionClose;`

`function Clear:Boolean;`

`function GetHeader(const AName:String):String;`
`function GetHeaderEx(const AName:String):TStringList;`

`function FindHeader(const AName,AValue:String):Boolean;`

`function ReadContentStream(AContent:TStream; ASize:LongWord):Boolean;`
`function ReadContentString(var AContent:String; ASize:LongWord):Boolean;`

HTTP client

THTTPClient = class(TWinsock2TCPClient)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FLock:TCriticalSectionHandle;`

`FState:LongWord;`	Internal request state
`FBuffer:THTTPBuffer;`	Buffer for received data

`FRequest:THTTPClientRequest;`
`FResponse:THTTPClientResponse;`

`FTimeout:LongWord;`
`FUserAgent:String;`
`FAllowRedirect:Boolean;`
`FMaxRedirects:LongWord;`
`FKeepAlive:Boolean;`
`FKeepAliveTimeout:LongWord;`

`FOnRedirect:THTTPRedirectEvent;`
`FOnPassword:THTTPPasswordEvent;`

`FHost:String;`
`FPort:String;`
`FUsername:String;`
`FPassword:String;`

`FProxyHost:String;`
`FProxyPort:String;`
`FProxyUsername:String;`
`FProxyPassword:String;`

`FURL:String;`
`FMethod:LongWord;`
`FVersion:LongWord;`
`FMimeType:String;`
`FRangeStart:LongWord;`
`FRangeEnd:LongWord;`
`FEncoding:LongWord;`

`procedure SetTimeout(ATimeout:LongWord);`
`function GetUserAgent:String;`
`procedure SetUserAgent(const AUserAgent:String);`
`procedure SetAllowRedirect(AAllowRedirect:Boolean);`
`procedure SetMaxRedirects(AMaxRedirects:LongWord);`
`procedure SetKeepAlive(AKeepAlive:Boolean);`
`procedure SetKeepAliveTimeout(AKeepAliveTimeout:LongWord);`

`function GetHost:String;`
`procedure SetHost(const AHost:String);`
`function GetPort:String;`
`procedure SetPort(const APort:String);`
`function GetUsername:String;`
`procedure SetUsername(const AUsername:String);`
`function GetPassword:String;`
`procedure SetPassword(const APassword:String);`

`function GetProxyHost:String;`
`procedure SetProxyHost(const AProxyHost:String);`
`function GetProxyPort:String;`
`procedure SetProxyPort(const AProxyPort:String);`
`function GetProxyUsername:String;`
`procedure SetProxyUsername(const AProxyUsername:String);`
`function GetProxyPassword:String;`
`procedure SetProxyPassword(const AProxyPassword:String);`

`function GetURL:String;`
`procedure SetURL(const AURL:String);`
`procedure SetMethod(AMethod:LongWord);`
`procedure SetVersion(AVersion:LongWord);`
`function GetMimeType:String;`
`procedure SetMimeType(const AMimeType:String);`
`procedure SetRangeStart(ARangeStart:LongWord);`
`procedure SetRangeEnd(ARangeEnd:LongWord);`
`procedure SetEncoding(AEncoding:LongWord);`

`function GetResponseStatus:LongWord;`
`function GetResponseReason:String;`
`function GetResponseVersion:LongWord;`
`function GetResponseMimeType:String;`
`function GetResponseEncoding:LongWord;`
`function GetResponseContentSize:LongWord;`
protected
`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function DoRedirect(const AURL:String; var ALocation:String):Boolean;`
`function DoPassword(var AUsername,APassword:String):Boolean;`

`function ReadResponseLine(AResponse:THTTPClientResponse):Boolean;`
`function ReadResponseHeaders(AResponse:THTTPClientResponse):Boolean;`
`function ReadResponseContentStream(AResponse:THTTPClientResponse; AContent:TStream; ASize:LongWord):Boolean;`
`function ReadResponseContentString(AResponse:THTTPClientResponse; var AContent:String; ASize:LongWord):Boolean;`

`function WriteRequestLine(ARequest:THTTPClientRequest):Boolean;`
`function WriteRequestHeaders(ARequest:THTTPClientRequest):Boolean;`
`function WriteRequestContentStream(ARequest:THTTPClientRequest; AContent:TStream; ASize:LongWord):Boolean;`
`function WriteRequestContentString(ARequest:THTTPClientRequest; const AContent:String; ASize:LongWord):Boolean;`
public
`property Request:THTTPClientRequest read FRequest;`
`property Response:THTTPClientResponse read FResponse;`

`property Timeout:LongWord read FTimeout write SetTimeout;`
`property UserAgent:String read GetUserAgent write SetUserAgent;`
`property AllowRedirect:Boolean read FAllowRedirect write SetAllowRedirect;`
`property MaxRedirects:LongWord read FMaxRedirects write SetMaxRedirects;`
`property KeepAlive:Boolean read FKeepAlive write SetKeepAlive;`
`property KeepAliveTimeout:LongWord read FKeepAliveTimeout write SetKeepAliveTimeout;`

`property OnRedirect:THTTPRedirectEvent read FOnRedirect write FOnRedirect;`
`property OnPassword:THTTPPasswordEvent read FOnPassword write FOnPassword;`

`property Host:String read GetHost write SetHost;`
`property Port:String read GetPort write SetPort;`
`property Username:String read GetUsername write SetUsername;`
`property Password:String read GetPassword write SetPassword;`

`property ProxyHost:String read GetProxyHost write SetProxyHost;`
`property ProxyPort:String read GetProxyPort write SetProxyPort;`
`property ProxyUsername:String read GetProxyUsername write SetProxyUsername;`
`property ProxyPassword:String read GetProxyPassword write SetProxyPassword;`

`property RequestURL:String read GetURL write SetURL;`
`property RequestMethod:LongWord read FMethod write SetMethod;`
`property RequestVersion:LongWord read FVersion write SetVersion;`
`property RequestMimeType:String read GetMimeType write SetMimeType;`
`property RequestRangeStart:LongWord read FRangeStart write SetRangeStart;`
`property RequestRangeEnd:LongWord read FRangeEnd write SetRangeEnd;`
`property RequestEncoding:LongWord read FEncoding write SetEncoding;`

`property ResponseStatus:LongWord read GetResponseStatus;`
`property ResponseReason:String read GetResponseReason;`
`property ResponseVersion:LongWord read GetResponseVersion;`
`property ResponseMimeType:String read GetResponseMimeType;`
`property ResponseEncoding:LongWord read GetResponseEncoding;`
`property ResponseContentSize:LongWord read GetResponseContentSize;`

`function Head(const AURL:String):Boolean;`

`function GetString(const AURL:String; var AContent:String):Boolean;`
`function GetStream(const AURL:String; AContent:TStream):Boolean;`

`function PostString(const AURL:String; var AContent:String):Boolean;`
`function PostStream(const AURL:String; AContent:TStream):Boolean;`

`function SendRequest:Boolean;`
`function CloseRequest:Boolean;`
`function ClearRequest:Boolean;`
`function CancelRequest:Boolean;`

`function SetRequestParam(const AName,AValue:String):Boolean;`
`function SetRequestParamEx(const AName,AValue:String; AReplace:Boolean):Boolean;`

`function SetRequestHeader(const AName,AValue:String):Boolean;`
`function SetRequestHeaderEx(const AName,AValue:String; AReplace:Boolean):Boolean;`

`function SetRequestContentStream(AContent:TStream):Boolean;`
`function AddRequestContentString(const AContent:String):Boolean;`
`function SetRequestContentString(const AContent:String):Boolean;`

`function GetResponseHeader(const AName:String):String;`
`function GetResponseHeaderEx(const AName:String):TStringList;`

`function GetResponseContentStream(AContent:TStream; ASize:LongWord):Boolean;`
`function GetResponseContentString(var AContent:String; ASize:LongWord):Boolean;`

HTTP server request

THTTPServerRequest = class(TObject)

public
`constructor Create(AThread:TWinsock2TCPServerThread);`
`destructor Destroy; override;`
private
`FFlags:LongWord;`
`FThread:TWinsock2TCPServerThread;`

`function GetContentReceived:Boolean;`
protected
`FListener:THTTPListener;`
public
`URL:String;`
`Method:LongWord;`
`Version:LongWord;`

`Params:THTTPParams;`
`Headers:THTTPHeaders;`

`Protocol:String;`
`Host:String;`
`Port:String;`
`Path:String;`
`Query:String;`

`BasePath:String;`	The base path of the document or alias matched to this request
`BaseHost:String;`	The base name of the host or alias matched to this request

`property Flags:LongWord read FFlags;`
`property Thread:TWinsock2TCPServerThread read FThread;`

`property ContentReceived:Boolean read GetContentReceived;`

`function GetParam(const AName:String):String;`
`function GetHeader(const AName:String):String;`
`function GetHeaderEx(const AName:String):TStringList;`

`function FindHeader(const AName,AValue:String):Boolean;`

`function ReadContentStream(AContent:TStream; ASize:LongWord):Boolean;`
`function ReadContentString(var AContent:String; ASize:LongWord):Boolean;`

HTTP server response

THTTPServerResponse = class(TObject)

public
`constructor Create(AThread:TWinsock2TCPServerThread);`
`destructor Destroy; override;`
private
`FFlags:LongWord;`
`FThread:TWinsock2TCPServerThread;`

`function GetStatusSent:Boolean;`
`function GetHeadersSent:Boolean;`
`function GetContentSent:Boolean;`

`function GetNoCache:Boolean;`
`procedure SetNoCache(ANoCache:Boolean);`
`function GetConnectionClose:Boolean;`
`procedure SetConnectionClose(AConnectionClose:Boolean);`
protected
`FListener:THTTPListener;`
public
`Reason:String;`
`Status:LongWord;`
`Version:LongWord;`

`Headers:THTTPHeaders;`

`ContentStream:TStream;`
`ContentString:String;`

`property Flags:LongWord read FFlags;`
`property Thread:TWinsock2TCPServerThread read FThread;`

`property StatusSent:Boolean read GetStatusSent;`
`property HeadersSent:Boolean read GetHeadersSent;`
`property ContentSent:Boolean read GetContentSent;`

`property NoCache:Boolean read GetNoCache write SetNoCache;`
`property ConnectionClose:Boolean read GetConnectionClose write SetConnectionClose;`

`function SetHeader(const AName,AValue:String):Boolean;`
`function SetHeaderEx(const AName,AValue:String; AReplace:Boolean):Boolean;`

`function WriteResponse:Boolean;`

`function WriteStatus:Boolean;`
`function WriteHeaders:Boolean;`
`function WriteContentStream(AContent:TStream; ASize:LongWord; ACompleted:Boolean):Boolean;`
`function WriteContentString(const AContent:String; ASize:LongWord; ACompleted:Boolean):Boolean;`

HTTP host

THTTPHost = class(TListObject)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FLock:TCriticalSectionHandle;`

`FName:String;`
`FHash:LongWord;`
`FFlags:LongWord;`

`FDefaultMimeType:String;`

`FErrors:TLinkedList;`
`FAliases:TLinkedList;`
`FModules:TLinkedList;`
`FDocuments:TLinkedList;`
`FMimeTypes:TLinkedList;`

`FOnGet:THTTPHostEvent;`
`FOnHead:THTTPHostEvent;`
`FOnPost:THTTPHostEvent;`
`FOnPut:THTTPHostEvent;`
`FOnError:THTTPHostEvent;`

`FOnRequest:THTTPHostEvent;`
`FOnResponse:THTTPHostEvent;`

`function GetName:String;`
`procedure SetName(const AName:String);`
`procedure SetFlags(AFlags:LongWord);`

`function GetDefaultMimeType:String;`
`procedure SetDefaultMimeType(const ADefaultMimeType:String);`

`function GetIsDefault:Boolean;`
`procedure SetIsDefault(AIsDefault:Boolean);`
`function GetIsDomain:Boolean;`
`procedure SetIsDomain(AIsDomain:Boolean);`
protected
`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function MatchError(AStatus:LongWord):THTTPError; virtual;`
`function MatchDocument(const AName:String; var AAlias:THTTPAlias):THTTPDocument; virtual;`

`function DoGet(ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
`function DoHead(ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
`function DoPost(ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
`function DoPut(ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
`function DoError(ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`

`function DoRequest(ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
`function DoResponse(ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
public
`property Name:String read GetName write SetName;`
`property Hash:LongWord read FHash;`
`property Flags:LongWord read FFlags write SetFlags;`

`property IsDefault:Boolean read GetIsDefault write SetIsDefault;`
`property IsDomain:Boolean read GetIsDomain write SetIsDomain;`

`property DefaultMimeType:String read GetDefaultMimeType write SetDefaultMimeType;`

`property OnGet:THTTPHostEvent read FOnGet write FOnGet;`
`property OnHead:THTTPHostEvent read FOnHead write FOnHead;`
`property OnPost:THTTPHostEvent read FOnPost write FOnPost;`
`property OnPut:THTTPHostEvent read FOnPut write FOnPut;`
`property OnError:THTTPHostEvent read FOnError write FOnError;`

`property OnRequest:THTTPHostEvent read FOnRequest write FOnRequest;`
`property OnResponse:THTTPHostEvent read FOnResponse write FOnResponse;`

`function FindError(AStatus:LongWord):THTTPError;`

`function RegisterError(AError:THTTPError):Boolean;`
`function DeregisterError(AError:THTTPError):Boolean;`

`function FindAlias(const AName:String):THTTPAlias;`
`function MatchAlias(const AName:String):THTTPAlias; virtual;`

`function RegisterAlias(AAlias:THTTPAlias):Boolean;`
`function DeregisterAlias(AAlias:THTTPAlias):Boolean;`

`function GetModule(APrevious:THTTPModule):THTTPModule;`
`function FindModule(AModule:THTTPModule):THTTPModule;`

`function RegisterModule(AModule:THTTPModule):Boolean;`
`function DeregisterModule(AModule:THTTPModule):Boolean;`

`function FindDocument(const AName:String):THTTPDocument;`

`function RegisterDocument(ADocument:THTTPDocument):Boolean;`
`function DeregisterDocument(ADocument:THTTPDocument):Boolean;`

`function LoadMimeTypes:Boolean;`

`function FindMimeType(const AExtension:String):THTTPMimeType;`
`function ResolveMimeType(const AExtension:String):String;`

`function RegisterMimeType(AMimeType:THTTPMimeType):Boolean;`
`function DeregisterMimeType(AMimeType:THTTPMimeType):Boolean;`

HTTP error

THTTPError = class(TListObject)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FLock:TCriticalSectionHandle;`

`FFlags:LongWord;`
`FStatus:LongWord;`

`FOnError:THTTPErrorEvent;`

`procedure SetFlags(AFlags:LongWord);`
`procedure SetStatus(AStatus:LongWord);`

`function GetIsDefault:Boolean;`
`procedure SetIsDefault(AIsDefault:Boolean);`
protected
`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function DoError(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
public
`property Flags:LongWord read FFlags write SetFlags;`
`property Status:LongWord read FStatus write SetStatus;`

`property IsDefault:Boolean read GetIsDefault write SetIsDefault;`

`property OnError:THTTPErrorEvent read FOnError write FOnError;`

HTTP alias

THTTPAlias = class(TListObject)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FLock:TMutexHandle;`

`FName:String;`
`FHash:LongWord;`

`function GetName:String;`
`procedure SetName(const AName:String);`
protected
`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`
public
`property Name:String read GetName write SetName;`
`property Hash:LongWord read FHash;`

HTTP module

THTTPModule = class(TListObject)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FLock:TCriticalSectionHandle;`

`FFlags:LongWord;`

`FOnRequest:THTTPModuleEvent;`
`FOnResponse:THTTPModuleEvent;`

`procedure SetFlags(AFlags:LongWord);`
protected
`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function DoRequest(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
`function DoResponse(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
public
`property Flags:LongWord read FFlags write SetFlags;`

`property OnRequest:THTTPModuleEvent read FOnRequest write FOnRequest;`
`property OnResponse:THTTPModuleEvent read FOnResponse write FOnResponse;`

HTTP document

THTTPDocument = class(TListObject)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FLock:TCriticalSectionHandle;`

`FName:String;`
`FHash:LongWord;`
`FFlags:LongWord;`

`FAliases:TLinkedList;`

`FOnGet:THTTPDocumentEvent;`
`FOnHead:THTTPDocumentEvent;`
`FOnPost:THTTPDocumentEvent;`
`FOnPut:THTTPDocumentEvent;`

`function GetName:String;`
`procedure SetName(const AName:String);`
`procedure SetFlags(AFlags:LongWord);`

`function GetIsDefault:Boolean;`
`procedure SetIsDefault(AIsDefault:Boolean);`
`function GetIsFolder:Boolean;`
`procedure SetIsFolder(AIsFolder:Boolean);`
`function GetIsSubtree:Boolean;`
`procedure SetIsSubtree(AIsSubtree:Boolean);`
`function GetIsExtension:Boolean;`
`procedure SetIsExtension(AIsExtension:Boolean);`
protected
`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function DoGet(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
`function DoHead(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
`function DoPost(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
`function DoPut(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; virtual;`
public
`property Name:String read GetName write SetName;`
`property Hash:LongWord read FHash;`
`property Flags:LongWord read FFlags write SetFlags;`

`property IsDefault:Boolean read GetIsDefault write SetIsDefault;`
`property IsFolder:Boolean read GetIsFolder write SetIsFolder;`
`property IsSubtree:Boolean read GetIsSubtree write SetIsSubtree;`
`property IsExtension:Boolean read GetIsExtension write SetIsExtension;`

`property OnGet:THTTPDocumentEvent read FOnGet write FOnGet;`
`property OnHead:THTTPDocumentEvent read FOnHead write FOnHead;`
`property OnPost:THTTPDocumentEvent read FOnPost write FOnPost;`
`property OnPut:THTTPDocumentEvent read FOnPut write FOnPut;`

`function FindAlias(const AName:String):THTTPAlias;`
`function MatchAlias(const AName:String):THTTPAlias; virtual;`

`function RegisterAlias(AAlias:THTTPAlias):Boolean;`
`function DeregisterAlias(AAlias:THTTPAlias):Boolean;`

HTTP mime type

THTTPMimeType = class(TListObject)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FLock:TMutexHandle;`

`FExtension:String;`
`FHash:LongWord;`
`FMimeType:String;`

`function GetExtension:String;`
`procedure SetExtension(const AExtension:String);`
`function GetMimeType:String;`
`procedure SetMimeType(const AMimeType:String);`
protected
`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`
public
`property Extension:String read GetExtension write SetExtension;`
`property Hash:LongWord read FHash;`
`property MimeType:String read GetMimeType write SetMimeType;`

HTTP redirect

THTTPRedirect = class(THTTPDocument)

public
`constructor Create;`
private
`FLocation:String;`
`FPermanent:Boolean;`

`function GetLocation:String;`
`procedure SetLocation(const ALocation:String);`
`procedure SetPermanent(APermanent:Boolean);`
protected
`function DoGet(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; override;`
public
`property Location:String read GetLocation write SetLocation;`
`property Permanent:Boolean read FPermanent write SetPermanent;`

HTTP folder

THTTPFolder = class(THTTPDocument)

public
`constructor Create;`
private
`FFolder:String;`
`FIndexPage:String;`
`FAllowCache:Boolean;`
`FAllowListing:Boolean;`
`FAllowSubtree:Boolean;`

`function GetFolder:String;`
`procedure SetFolder(const AFolder:String);`
`function GetIndexPage:String;`
`procedure SetIndexPage(const AIndexPage:String);`
`procedure SetAllowCache(AAllowCache:Boolean);`
`procedure SetAllowListing(AAllowListing:Boolean);`
`procedure SetAllowSubtree(AAllowSubtree:Boolean);`
protected
`function DoGet(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; override;`
`function DoHead(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; override;`

`function DoGetFile(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse; const AFile:String):Boolean; virtual;`
`function DoGetFolder(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse; const AFolder:String):Boolean; virtual;`
public
`property Folder:String read GetFolder write SetFolder;`
`property IndexPage:String read GetIndexPage write SetIndexPage;`
`property AllowCache:Boolean read FAllowCache write SetAllowCache;`
`property AllowListing:Boolean read FAllowListing write SetAllowListing;`
`property AllowSubtree:Boolean read FAllowSubtree write SetAllowSubtree;`

HTTP file

THTTPFile = class(THTTPDocument)

public
`constructor Create;`
private
`FFilename:String;`
`FAllowCache:Boolean;`

`function GetFilename:String;`
`procedure SetFilename(const AFilename:String);`
`procedure SetAllowCache(AAllowCache:Boolean);`
protected
`function DoGet(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; override;`
`function DoHead(AHost:THTTPHost; ARequest:THTTPServerRequest; AResponse:THTTPServerResponse):Boolean; override;`
public
`property Filename:String read GetFilename write SetFilename;`
`property AllowCache:Boolean read FAllowCache write SetAllowCache;`

HTTP listener

THTTPListener = class(TWinsock2TCPListener)

public
`constructor Create;`
`destructor Destroy; override;`
private
`FLock:TCriticalSectionHandle;`

`FHost:THTTPHost;`	Default Host
`FHosts:TLinkedList;`

`FServer:String;`

`function GetServer:String;`
`procedure SetServer(const AServer:String);`
protected
`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`procedure DoConnect(AThread:TWinsock2TCPServerThread); override;`
`procedure DoDisconnect(AThread:TWinsock2TCPServerThread); override;`

`function DoExecute(AThread:TWinsock2TCPServerThread):Boolean; override;`

`function MatchHost(const AName:String; var AAlias:THTTPAlias):THTTPHost;`

`function GetRequestLine(AThread:TWinsock2TCPServerThread; ARequest:THTTPServerRequest):Boolean;`
`function GetRequestHeaders(AThread:TWinsock2TCPServerThread; ARequest:THTTPServerRequest):Boolean;`
`function GetRequestContentStream(AThread:TWinsock2TCPServerThread; ARequest:THTTPServerRequest; AContent:TStream; ASize:LongWord):Boolean;`
`function GetRequestContentString(AThread:TWinsock2TCPServerThread; ARequest:THTTPServerRequest; var AContent:String; ASize:LongWord):Boolean;`

`function SendResponseLine(AThread:TWinsock2TCPServerThread; AResponse:THTTPServerResponse):Boolean;`
`function SendResponseHeaders(AThread:TWinsock2TCPServerThread; AResponse:THTTPServerResponse):Boolean;`
`function SendResponseContentStream(AThread:TWinsock2TCPServerThread; AResponse:THTTPServerResponse; AContent:TStream; ASize:LongWord):Boolean;`
`function SendResponseContentString(AThread:TWinsock2TCPServerThread; AResponse:THTTPServerResponse; const AContent:String; ASize:LongWord):Boolean;`
public
`property Server:String read GetServer write SetServer;`

`function FindHost(const AName:String):THTTPHost;`

`function RegisterHost(AHost:THTTPHost):Boolean;`
`function DeregisterHost(AHost:THTTPHost):Boolean;`

`function FindError(const AHost:String; AStatus:LongWord):THTTPError;`

`function RegisterError(const AHost:String; AError:THTTPError):Boolean;`
`function DeregisterError(const AHost:String; AError:THTTPError):Boolean;`

`function GetModule(const AHost:String; APrevious:THTTPModule):THTTPModule;`
`function FindModule(const AHost:String; AModule:THTTPModule):THTTPModule;`

`function RegisterModule(const AHost:String; AModule:THTTPModule):Boolean;`
`function DeregisterModule(const AHost:String; AModule:THTTPModule):Boolean;`

`function FindDocument(const AHost,AName:String):THTTPDocument;`

`function RegisterDocument(const AHost:String; ADocument:THTTPDocument):Boolean;`
`function DeregisterDocument(const AHost:String; ADocument:THTTPDocument):Boolean;`

`function LoadMimeTypes(const AHost:String):Boolean;`

`function FindMimeType(const AHost,AExtension:String):THTTPMimeType;`
`function ResolveMimeType(const AHost,AExtension:String):String;`

`function RegisterMimeType(const AHost:String; AMimeType:THTTPMimeType):Boolean;`
`function DeregisterMimeType(const AHost:String; AMimeType:THTTPMimeType):Boolean;`

Public variables

HTTP logging

`HTTP_DEFAULT_LOG_LEVEL:LongWord = HTTP_LOG_LEVEL_DEBUG;`	Minimum level for HTTP messages. Only messages with level greater than or equal to this will be printed.

`HTTP_LOG_ENABLED:Boolean;`