Same as the instance method of the same name.

Same as the instance method of the same name.

Same as the instance method of the same name.

Same as the instance method of the same name.

This method is called for each incoming request, and checks that the requested resource is accessible (basic user/password access control).
The method returns YES if access is granted, or returns NO and sets the appropriate response values if access is refused.
If access is refused by this method, the delegate is not informed of the request at all... so this forms an initial access control mechanism, but if it is passed, the delegate is still free to implement its own additional access control within the [<WebServerDelegate>-processRequest:response:for:] method.
The access control is managed by the WebServerAccess user default, which is a dictionary whose keys are paths, and whose values are dictionaries specifying the access control for those paths. Access control is done on the basis of the longest matching path.
Each access control dictionary contains an authentication realm string (keyed on Realm) and a dictionary containing username/password pairs (keyed on Users).
eg.

 WebServerAccess = {
   "" = {
     Realm = "general";
     Users = {
       Fred = 1942;
     };
   };
 };
 

This may only be called in the case where a call to the delegate's [<WebServerDelegate>-processRequest:response:for:] method to process a request returned NO, indicating that the delegate would handle the request in another thread and complete it later.

In such a case, the thread handling the request in the delegate must call this method upon completion (passing in the same request parameter that was passed to the delegate) to inform the WebServer instance that processing of the request has been completed and that it should now take over the job of sending the response to the client process.

Decode an application/x-www-form-urlencoded form and store its contents into the supplied dictionary.
The resulting dictionary keys are strings.
The resulting dictionary values are arrays of NSData objects.
You probably don't need to call this method yourself... more likely you will use the -parameters: method instead.
NB. For forms POST-ed using multipart/form-data you don't need to perform any explicit decoding as this will already have been done for you and the decoded form will be presented as the request GSMimeDocument. The fields of the form will be the component parts of the content of the request and can be accessed using the standard GSMimeDocument methods.
This method returns the number of fields actually decoded.

Encode an application/x-www-form-urlencoded form and store its representation in the supplied data object.
The dictionary contains the form, with keys as data objects or strings, and values as arrays of values to be placed in the data. Each value in the array may be a data object or a string.
As a special case, a value may be a data object or a string rather than an array... this is treated like an array of one value.
All non data keys and values are converted to data using utf-8 encoding.
This method returns the number of values actually encoded.

Returns YES if the server is for HTTPS (encrypted connections), NO otherwise.

Returns the index'th data parameter for the specified name.
Matching of names is case-insensitive
If there are no data items for the name, or if the index is too large for the number of items which exist, this returns nil.

Calls -parameter:at:from: with an index of zero.

Calls -parameterString:at:from:charset: with a nil charset so that UTF-8 encoding is used for string conversion.

Calls -parameter:at:from: and, if the result is non-nil converts the data to a string using the specified mime characterset, (if charset is nil, UTF-8 is used).

Calls -parameterString:at:from:charset: with an index of zero and a nil value for charset (which causes data to be treated as UTF-8).

Calls -parameterString:at:from:charset: with an index of zero.

Extracts request parameters from the HTTP query string and from the request body (if it was application/x-www-form-urlencoded or multipart/form-data) and return the extracted parameters as a mutable dictionary whose keys are the parameter names and whose values are arrays containing the data for each parameter.
You should call this no more than once per request, storing the result and using it as an argument to the methods used to extract particular parameters.
Parameters from the request data are added to any found in the query string.
Values provided as multipart/form-data are also available in a more flexible format as the content of the request.

Loads a template file from disk and places it in aResponse as content whose mime type is determined from the file extension using the provided mapping (or a simple built-in default mapping if map is nil).
If you have a dedicated web server for handling static pages (eg images) it is better to use that rather than vending static pages using this method. It's unlikely that this method can be as efficient as a dedicated server. However this mechanism is adequate for moderate throughputs.

Loads a template file from disk and places it in aResponse as content of type 'text/html' with a charset of 'utf-8'.
The argument aPath is a path relative to the root path set using the -setRoot: method.
Substitutes values into the template from map using the -substituteFrom:using:into:depth: method.
Returns NO if them template could not be read or if any substitution failed. In this case no value is set in the response.
If the response is actually text of another type, or you want another characterset used, you can change the content type header in the request after you call this method.

Sets the time after which an idle connection should be shut down.
Default is 30.0

Sets the delegate object which processes requests for the receiver.

Sets a flag to determine whether logging of request and connection durations is to be performed.
If this is YES then the duration of requests and connections will be logged using the [<WebServerDelegate>-webLog:for:] method.
The request duration is calculated from the point where the first byte of data in the request is read to the point where the response has been completely written.
This is useful for debugging and where a full audit trail is required.

Sets the maximum size of an uploaded request body.
The default is 4M bytes.
The HTTP failure response for too large a body is 413.

Sets the maximum number of simultaneous connections with clients.
The default is 128.
A value of zero permits unlimited connections.
If this limit is reached, the behavior of the software depends upon the value set by the -setMaxConnectionsReject: method.

Sets the maximum number of simultaneous connections with a particular remote host.
The default is 32.
A value of zero permits unlimited connections.
If this value is greater than that of -setMaxConnections: then it will have no effect as the maximum number of connections from one host cannot be reached.
The HTTP failure response for too many connections from a host is 503.

This setting (default value NO) determines the behavior of the software when the number of simultaneous incoming connections exceeds the value set by the -setMaxConnections: method.

If reject is NO, the software will simply not accept the incoming connections until some earlier connection is terminated, so the incoming connections will be queued by the operating system and may time-out if no connections become free quickly enough for them to be handled. In the case of a huge number of incoming connections the 'listen' queue of the operating system may fill up and connections may be lost altogether.

If reject is yes, then the service will set aside a slot for one extra connection and, when the number of permitted connections is exceeded, the server will accept the first additional connection, send back an HTTP 503 response, and drop the additional connection again. This means that clients should receive a 503 response rather than finding that their connection attempts block and possible time out.

Sets the maximum size of an incoming request (including all headers, but not the body).
The default is 8K bytes.
The HTTP failure response for too large a request is 413.

Sets the port and security information for the receiver... without this the receiver will not listen for incoming requests.
If secure is nil then the receiver listens on aPort for HTTP requests.
If secure is not nil, the receiver listens for HTTPS instead.
If secure is a dictionary containing CertificateFile, KeyFile and Password then the server will use the specified certificate and key files (which it will access using the password).
The secure dictionary may also contain other dictionaries keyed on IP addresses, and if the address that an incoming connection arrived on matches the key of a dictionary, that dictionary is used to provide the certificate information, with the top-level values being used as a fallback.
This method returns YES on success, NO on failure... if it returns NO then the receiver will not be capable of handling incoming web requests!
Typically a failure will be due to an invalid port being specified... a port may not already be in use and may not be in the range up to 1024 (unless running as the super-user).
Call this with a nil port argument to shut the server down as soon as all current connections are closed.

Set root path for loading template files from.
Templates may only be loaded from within this directory.

Sets the maximum recursion depth allowed for substitutions into templates. This defaults to 4.

Sets a flag to determine whether verbose logging is to be performed.
If this is YES then all incoming requests and their responses will be logged using the [<WebServerDelegate>-webLog:for:] method.
Setting this to YES automatically sets duration logging to YES as well, though you can then call -setDurationLogging: to set it back to NO.
This is useful for debugging and where a full audit trail is required.

Perform substitutions replacing the markup in aTemplate with the values supplied by map and appending the results to the result.
Substitutions are recursive, and the depth argument is used to specify the current recursion depth (you should normally call this method with a depth of zero at the start of processing a template).
Any value inside SGML comment delimiters ('<!--' and '-->') is treated as a possible key in map and the entire comment is replaced by the corresponding map value (unless it is nil). Recursive substitution is done unless the mapped value starts with an SGML comment.
While the map is nominally a dictionary, in fact it may be any object which responds to the objectForKey: method by returning an NSString or nil.
The method returns YES on success, NO on failure (depth too great).
You don't normally need to use this method directly... call the -produceResponse:fromTemplate:using: method instead.

Handle a notification that the defaults have been updated... change WebServer configuration if necessary.

• WebServerPort must be used to specify the port that the server listens on. See [WebServer -setPort:secure:] for details.
• WebServerSecure may be supplied to make the server operate as an HTTPS server rather than an HTTP server. See [WebServer -setPort:secure:] for details.
• WebServerBundles is a dictionary keyed on path strings, whose values are dictionaries, each containing per-handler configuration information and the name of the bundle containing the code to handle requests sent to the path. NB. the bundle name listed should omit the .bundle extension.

Returns YES on success, NO on failure (if the port of the WebServer cannot be set).

Returns the handler to be used for the specified path, or nil if there is no handler available.
If the info argument is non-null, it is used to return additional information, either the path actually matched, or an error string.

Return dictionary of all handlers by name (path in request which maps to that handler instance).

Return the WebServer instance that the receiver is acting as a delegate for.

Initialises the receiver as the delegate of HTTP and configures the WebServer based upon the settings found in the user defaults system by using the -defaultsUpdate: method.

Handles an incoming request by forwarding it to another handler.
If a direct mapping is available from the path in the request to an existing handler, that handler is used to process the request . Otherwise, the WebServerBundles dictionary (obtained from the defaults system) is used to map the request path to configuration information listing the bundle containing the handler to be used.

The configuration information is a dictionary containing the name of the bundle (keyed on 'Name'), and this is used to locate the bundle in the applications resources.
Before a request is passed on to a handler, two extra headers are set in it... x-http-path-base and x-http-path-info being the actual path matched for the handler, and the remainder of the path after that base part.

Registers an object as the handler for a particular path.
Registering a nil handler destroys any existing handler for the path.

Just write to stderr using NSLog.

Log an audit record as UTF8 data on stderr.

Just discard the message... please subclass or use a category to override this method if you wish to used the logged messages.

Process the HTTP request whose headers and data are provided in a GSMimeDocument.
Extra headers are created as follows -

x-http-method

The method from the HTTP request (eg. GET or POST)

x-http-path

The path from the HTTP request, or an empty string if there was no path.

x-http-query

The query string from the HTTP request or an empty string if there was no query.

x-http-version

The version from the HTTP request.

x-local-address

The IP address of the local host receiving the request.

x-local-port

The port of the local host receiving the request.

x-remote-address

The IP address of the host that the request came from.

x-remote-port

The port of the host that the request came from.

x-http-username

The username from the 'authorization' header if the request supplied HTTP basic authentication.

x-http-password

The password from the 'authorization' header if the request supplied HTTP basic authentication.

x-count-requests

The number of requests being precessed at the point when this request started (includes this request).

x-count-connections

The number of connections established to the WebServer at the point when this request started (including the connection this request arrived on).

x-count-connected-hosts

The number of connects hosts (IP addresses) at the point when this request started (including the host which sent this request).

x-count-host-connections

The number of connections to the web server from the host which sent this request at the point when this request started (includes the connection that this request arrived on).

On completion, the method must modify response to contain the data and headers to be sent out.
The 'content-length' header need not be set in the response as it will be overridden anyway.
The special 'HTTP' header will be used as the response/status line. If not supplied, 'HTTP/1.1 200 Success' or 'HTTP/1.1 204 No Content' will be used as the response line, depending on whether the data is empty or not.
If an exception is raised by this method, the response produced will be set to 'HTTP/1.0 500 Internal Server Error' and the connection will be closed.
If the method returns YES, the WebServer instance sends the response to the client process which made the request.
If the method returns NO, the WebServer instance assumes that the delegate is processing the request in another thread (perhaps it will take a long time to process) and takes no action until the delegate calls [WebServer -completedWithResponse:] to let it know that processing is complete and the response should at last be sent out.

Log an error or warning... if the delegate does not implement this method, the message is logged to stderr using the NSLog function.

Log an audit record... if the delegate does not implement this method, the message is logged to stderr.
The logged record is similar to the Apache common log format, though it differs after the timestamp:

ip address

the address of the client host making the request

ident

not currently implemented... '-' as placeholder

ident

not currently implemented... '-' as placeholder

user

the remote user name from the authorization header, or '-'

timestamp

the date/time enclosed in square brackets

command

The command sent in the request... as a quoted string

agent

The user-agent header from the request... as a quoted string

result

The initial response line... as a quoted string

Log a debug... if the delegate does not implement this method, no logging is done.