Unit HTTP

Return to Unit Reference

Description

---

Ultibo HTTP interface unit

To be documented

Constants

---

[Expand]

HTTP specific constants HTTP_*

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;

[Expand]

HTTP date constants 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;

[Expand]

HTTP client constants 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;

[Expand]

HTTP server constants HTTP_SERVER_*

HTTP_SERVER_STRING = 'Ultibo/' + ULTIBO_RELEASE_VERSION;

[Expand]

HTTP protocol constants HTTP_PROTOCOL_*

HTTP_PROTOCOL_NONE = 0;
HTTP_PROTOCOL_HTTP = 1;
HTTP_PROTOCOL_HTTPS = 2;
HTTP_PROTOCOL_STRING_HTTP = 'http';
HTTP_PROTOCOL_STRING_HTTPS = 'https';

[Expand]

HTTP method constants 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';

[Expand]

HTTP version constants 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';

[Expand]

HTTP encoding constants 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';

[Expand]

HTTP general header constants 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';

[Expand]

HTTP request header constants 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';

[Expand]

HTTP response header constants 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';

[Expand]

HTTP entity header constants 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';

[Expand]

HTTP status constants 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;

[Expand]

HTTP reason constants 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 ';

[Expand]

HTTP content type constants HTTP_CONTENT_*

HTTP_CONTENT_TEXT_HTML = 'text/html';

[Expand]

HTTP cache control constants HTTP_CACHE_*

HTTP_CACHE_NO_CACHE = 'no-cache';

[Expand]

HTTP connection constants HTTP_CONNECTION_*

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

[Expand]

HTTP request flag constants 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

[Expand]

HTTP response flag constants 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

[Expand]

HTTP client state constants 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;

[Expand]

HTTP host flag constants HTTP_HOST_FLAG_*

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

[Expand]

HTTP CGI flag constants HTTP_CGI_FLAG_*

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

[Expand]

HTTP error flag constants HTTP_ERROR_FLAG_*

HTTP_ERROR_FLAG_NONE = $00000000;
HTTP_ERROR_FLAG_DEFAULT = $00000001;

[Expand]

HTTP module flag constants HTTP_MODULE_FLAG_*

HTTP_MODULE_FLAG_NONE = $00000000;

[Expand]

HTTP document flag constants 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;

[Expand]

HTTP mime type constants 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';

[Expand]

HTTP logging constants 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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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

[Expand]

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;

Function declarations

---

Initialization functions

[Expand]

procedure HTTPInit;

Description: To be documented

Note	None documented

HTTP helper functions

[Expand]

function HTTPEncode(const AValue:String; AReserved:THTTPReservedChars):String;

Description: To be documented

Note	None documented

[Expand]

function HTTPDecode(const AValue:String):String;

Description: To be documented

Note	None documented

[Expand]

function HTTPParseURI(const AURI:String; var AProtocol,AHost,APort,APath,AQuery:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPBuildURI(const AProtocol,AHost,APort,APath,AQuery:String; var AURI:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPParseHost(const AHost:String; var AName,APort:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPBuildHost(const AName,APort:String; var AHost:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPParseParam(const AParam:String; var AName,AValue:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPBuildParam(const AName,AValue:String; var AParam:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPParseQuery(const AQuery:String; AParams:THTTPParams):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPBuildQuery(AParams:THTTPParams; var AQuery:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPParseHeader(const AHeader:String; var AName,AValue:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPBuildHeader(const AName,AValue:String; var AHeader:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPPathExtractName(const ASource:String; var AName:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPPathExtractDir(const ASource:String; var APath:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPPathExtractPath(const ASource:String; var APath:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPPathExtractExtension(const ASource:String; var AExtension:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPParseRequestLine(const ARequest:String; var AMethod:LongWord; var AURL:String; var AVersion:LongWord):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPBuildRequestLine(AMethod:LongWord; const AURL:String; AVersion:LongWord; var ARequest:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPParseResponseLine(const AResponse:String; var AVersion,AStatus:LongWord; var AReason:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function HTTPBuildResponseLine(AVersion,AStatus:LongWord; const AReason:String; var AResponse:String):Boolean;

Description: To be documented

Note	None documented

[Expand]

function FileTimeToHTTPDate(const AFileTime:TFileTime):String;

Description: To be documented

Note	None documented

[Expand]

function HTTPDateToFileTime(const AHTTPDate:String):TFileTime;

Description: To be documented

Note	None documented

[Expand]

function DateTimeToHTTPDate(const ADateTime:TDateTime):String;

Description: To be documented

Note	None documented

[Expand]

function HTTPDateToDateTime(const AHTTPDate:String):TDateTime;

Description: To be documented

Note	None documented

[Expand]

function StringToHTTPProtocol(const AProtocol:String):LongWord;

Description: To be documented

Note	None documented

[Expand]

function HTTPProtocolToString(AProtocol:LongWord):String;

Description: To be documented

Note	None documented

[Expand]

function StringToHTTPMethod(const AMethod:String):LongWord;

Description: To be documented

Note	None documented

[Expand]

function HTTPMethodToString(AMethod:LongWord):String;

Description: To be documented

Note	None documented

[Expand]

function StringToHTTPVersion(const AVersion:String):LongWord;

Description: To be documented

Note	None documented

[Expand]

function HTTPVersionToString(AVersion:LongWord):String;

Description: To be documented

Note	None documented

[Expand]

function StringToHTTPEncoding(const AEncoding:String):LongWord;

Description: To be documented

Note	None documented

[Expand]

function HTTPEncodingToString(AEncoding:LongWord):String;

Description: To be documented

Note	None documented

[Expand]

function StringToHTTPStatus(const AStatus:String):LongWord;

Description: To be documented

Note	None documented

[Expand]

function HTTPStatusToString(AStatus:LongWord):String;

Description: To be documented

Note	None documented

[Expand]

procedure HTTPLog(Level:LongWord;const AText:String);

Description: To be documented

Note	None documented

[Expand]

procedure HTTPLogInfo(const AText:String);

Description: To be documented

Note	None documented

[Expand]

procedure HTTPLogError(const AText:String);

Description: To be documented

Note	None documented

[Expand]

procedure HTTPLogDebug(const AText:String);

Description: To be documented

Note	None documented

Return to Unit Reference