Difference between revisions of "Unit HTTP"

From Ultibo.org
Jump to: navigation, search
Line 797: Line 797:
 
|-
 
|-
 
| <code>HTTP_RESPONSE_FLAG_CONNECTION_CLOSE = $00000008;</code>
 
| <code>HTTP_RESPONSE_FLAG_CONNECTION_CLOSE = $00000008;</code>
−
| Server / Client
+
| Server/Client
 
|-
 
|-
 
| <code>HTTP_RESPONSE_FLAG_NO_CACHE = $00000010;</code>
 
| <code>HTTP_RESPONSE_FLAG_NO_CACHE = $00000010;</code>
−
| Server / Client
+
| Server/Client
 
|-
 
|-
 
| <code>HTTP_RESPONSE_FLAG_CONTENT_RECEIVED = $00000020;</code>
 
| <code>HTTP_RESPONSE_FLAG_CONTENT_RECEIVED = $00000020;</code>

Revision as of 03:27, 13 April 2017

Return to Unit Reference


Description

Ultibo HTTP interface unit

To be documented

Constants


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;  


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;


Function declarations


Initialization functions 

procedure HTTPInit;
Description: To be documented
Note None documented


HTTP helper functions 

function HTTPEncode(const AValue:String; AReserved:THTTPReservedChars):String;
Description: To be documented
Note None documented 


function HTTPDecode(const AValue:String):String;
Description: To be documented
Note None documented 


function HTTPParseURI(const AURI:String; var AProtocol,AHost,APort,APath,AQuery:String):Boolean;
Description: To be documented
Note None documented 


function HTTPBuildURI(const AProtocol,AHost,APort,APath,AQuery:String; var AURI:String):Boolean;
Description: To be documented
Note None documented 


function HTTPParseHost(const AHost:String; var AName,APort:String):Boolean;
Description: To be documented
Note None documented 


function HTTPBuildHost(const AName,APort:String; var AHost:String):Boolean;
Description: To be documented
Note None documented 


function HTTPParseParam(const AParam:String; var AName,AValue:String):Boolean;
Description: To be documented
Note None documented 


function HTTPBuildParam(const AName,AValue:String; var AParam:String):Boolean;
Description: To be documented
Note None documented 


function HTTPParseQuery(const AQuery:String; AParams:THTTPParams):Boolean;
Description: To be documented
Note None documented 


function HTTPBuildQuery(AParams:THTTPParams; var AQuery:String):Boolean;
Description: To be documented
Note None documented 


function HTTPParseHeader(const AHeader:String; var AName,AValue:String):Boolean;
Description: To be documented
Note None documented 


function HTTPBuildHeader(const AName,AValue:String; var AHeader:String):Boolean;
Description: To be documented
Note None documented 


function HTTPPathExtractName(const ASource:String; var AName:String):Boolean;
Description: To be documented
Note None documented 


function HTTPPathExtractDir(const ASource:String; var APath:String):Boolean;
Description: To be documented
Note None documented 


function HTTPPathExtractPath(const ASource:String; var APath:String):Boolean;
Description: To be documented
Note None documented 


function HTTPPathExtractExtension(const ASource:String; var AExtension:String):Boolean;
Description: To be documented
Note None documented 


function HTTPParseRequestLine(const ARequest:String; var AMethod:LongWord; var AURL:String; var AVersion:LongWord):Boolean;
Description: To be documented
Note None documented 


function HTTPBuildRequestLine(AMethod:LongWord; const AURL:String; AVersion:LongWord; var ARequest:String):Boolean;
Description: To be documented
Note None documented 


function HTTPParseResponseLine(const AResponse:String; var AVersion,AStatus:LongWord; var AReason:String):Boolean;
Description: To be documented
Note None documented 


function HTTPBuildResponseLine(AVersion,AStatus:LongWord; const AReason:String; var AResponse:String):Boolean;
Description: To be documented
Note None documented 


function FileTimeToHTTPDate(const AFileTime:TFileTime):String;
Description: To be documented
Note None documented 


function HTTPDateToFileTime(const AHTTPDate:String):TFileTime;
Description: To be documented
Note None documented 


function DateTimeToHTTPDate(const ADateTime:TDateTime):String;
Description: To be documented
Note None documented 


function HTTPDateToDateTime(const AHTTPDate:String):TDateTime;
Description: To be documented
Note None documented 


function StringToHTTPProtocol(const AProtocol:String):LongWord;
Description: To be documented
Note None documented 


function HTTPProtocolToString(AProtocol:LongWord):String;
Description: To be documented
Note None documented 


function StringToHTTPMethod(const AMethod:String):LongWord;
Description: To be documented
Note None documented 


function HTTPMethodToString(AMethod:LongWord):String;
Description: To be documented
Note None documented 


function StringToHTTPVersion(const AVersion:String):LongWord;
Description: To be documented
Note None documented 


function HTTPVersionToString(AVersion:LongWord):String;
Description: To be documented
Note None documented 


function StringToHTTPEncoding(const AEncoding:String):LongWord;
Description: To be documented
Note None documented 


function HTTPEncodingToString(AEncoding:LongWord):String;
Description: To be documented
Note None documented 


function StringToHTTPStatus(const AStatus:String):LongWord;
Description: To be documented
Note None documented 


function HTTPStatusToString(AStatus:LongWord):String;
Description: To be documented
Note None documented 


procedure HTTPLog(Level:LongWord;const AText:String);
Description: To be documented
Note None documented 


procedure HTTPLogInfo(const AText:String);
Description: To be documented
Note None documented 


procedure HTTPLogError(const AText:String);
Description: To be documented
Note None documented 


procedure HTTPLogDebug(const AText:String);
Description: To be documented
Note None documented


Return to Unit Reference

Retrieved from "https://ultibo.org/mediawiki_ultibo_org/index.php?title=Unit_HTTP&oldid=2865"