Resource is basically a set of Rsrc monadic computations for each HTTP methods.

The resource monad. This monad implements MonadIO so it can do any IO actions.

FormData represents a form value and possibly an uploaded file name.

Get the Config value for this httpd.

Get the SockAddr of the remote host.

Get the string representation of the address of remote host. If you want a SockAddr instead of HostName, use getRemoteAddr.

Resolve an address to the remote host.

Return the X.509 certificate of the client, or Nothing if:

• This request didn't came through an SSL stream.
• The client didn't send us its certificate.
• The OpenSSL.Session.VerificationMode of OpenSSL.Session.SSLContext in SSLConfig has not been set to OpenSSL.Session.VerifyPeer.

Return the Request value representing the request header. You usually don't need to call this function directly.

Get the Method value of the request.

Get the URI of the request.

Get the HTTP version of the request.

Get the path of this Rsrc (to be exact, Resource) in the corresponding Network.HTTP.Lucu.ResourceTree. The result of this action is the exact path in the tree even when the Resource is Network.HTTP.Lucu.greedy.

Example:

   main :: IO ()
   main = let tree :: Network.HTTP.Lucu.ResourceTree
              tree = fromList [ ([foo], Network.HTTP.Lucu.greedy resFoo) ]
          in Network.withSocketsDo . Network.HTTP.Lucu.runHttpd defaultConfig $ Network.HTTP.Lucu.resourceMap tree

resFoo :: Resource
   resFoo = singleton
            ( GET
            , do requestURI   <- getRequestURI
                 resourcePath <- getResourcePath
                 pathInfo     <- getPathInfo
                 -- Network.URI.uriPath requestURI == "foobar/baz"
                 -- resourcePath       == [foo]
                 -- pathInfo           == [bar, baz]
                 ...
            )

This is an analogy of CGI PATH_INFO. getPathInfo always returns [] if the corresponding Resource is not greedy. See getResourcePath.

Note that the returned path components are URI-decoded.

Assume the query part of request URI as application/x-www-form-urlencoded, and parse it into pairs of (name, formData). This function doesn't read the request body.

getHeader name returns the value of the request header field name. Comparison of header name is case-insensitive. Note that this function is not intended to be used so frequently: there should be functions like getContentType for every common headers.

Return the list of MIMEType enumerated on the value of request header "Accept", or [] if absent.

Return the list of (contentCoding, qvalue) enumerated on the value of request header "Accept-Encoding". The list is sorted in descending order by qvalue.

Return True iff a given content-coding is acceptable by the client.

Return the value of request header "Content-Type" as MIMEType.

Return the value of request header "Authorization" as AuthCredential.

Tell the system that the Rsrc found an entity for the request URI. If this is a GET or HEAD request, a found entity means a datum to be replied. If this is a PUT or DELETE request, it means a datum which was stored for the URI until now. For POST requests it raises an error.

foundEntity performs "If-Match" test or "If-None-Match" test whenever possible, and if those tests fail, it immediately aborts with status "412 Precondition Failed" or "304 Not Modified" depending on the situation.

If the request method is either GET or HEAD, foundEntity automatically puts "ETag" and "Last-Modified" headers into the response.

Tell the system that the Rsrc found an entity for the request URI. The only difference from foundEntity is that foundETag doesn't (nor can't) put "Last-Modified" header into the response.

Using this function is discouraged. You should use foundEntity whenever possible.

Tell the system that the Rsrc found an entity for the request URI. The only difference from foundEntity is that foundTimeStamp performs "If-Modified-Since" test or "If-Unmodified-Since" test instead of "If-Match" test or "If-None-Match" test. Be aware that any tests based on a last modification time are unsafe because it is possible to mess up such tests by modifying the entity twice in a second.

Using this function is discouraged. You should use foundEntity whenever possible.

foundNoEntity mStr tells the system that the Rsrc found no entity for the request URI. mStr is an optional error message to be replied to the client.

If the request method is PUT, foundNoEntity performs "If-Match" test and when that fails it aborts with status "412 Precondition Failed". If the request method is GET, HEAD, POST or DELETE, foundNoEntity always aborts with status "404 Not Found".

foundNoEntity' is the same as foundNoEntity Nothing.

getChunk n attempts to read a chunk of request body up to n bytes. You can incrementally read the request body by repeatedly calling this function. If there is nothing to be read anymore, getChunk returns empty and makes Rsrc transit to the Deciding Header state.

getChunks limit attemts to read the entire request body up to limit bytes, and then make the Rsrc transit to the /Deciding Header/ state. When the actual size of the body is larger than limit bytes, getChunks immediately aborts with status "413 Request Entity Too Large". When the request has no body, it returns an empty string.

When the limit is Nothing, getChunks uses the default limitation value (cnfMaxEntityLength) instead.

getChunks returns a lazy ByteString but it's not really lazy: reading from the socket just happens at the computation of getChunks, not at the evaluation of the ByteString.

getForm limit attempts to read the request body with getChunks and parse it as application/x-www-form-urlencoded or multipart/form-data. If the request header "Content-Type" is neither of them, getForm aborts with status "415 Unsupported Media Type". If the request has no "Content-Type", it aborts with "400 Bad Request".

Note that there are currently a few limitations on parsing multipart/form-data. See: parseMultipartFormData

Declare the response status code. If you don't call this function, the status code will be defaulted to "200 OK".

redirect code uri declares the response status as code and "Location" header field as uri. The code must satisfy isRedirection or it raises an error.

setContentType mType declares the response header "Content-Type" as mType. Declaring "Content-Type" is mandatory for sending a response body.

setContentEncoding codings declares the response header "Content-Encoding" as codings.

setWWWAuthenticate challenge declares the response header "WWW-Authenticate" as challenge.

setLocation uri declares the response header "Location" as uri. You usually don't need to call this function directly.

setHeader name value declares the value of the response header name as value. Note that this function is not intended to be used so frequently: there should be specialised functions like Network.HTTP.Lucu.setContentType for every common headers.

Some important headers (especially "Content-Length" and "Transfer-Encoding") may be silently dropped or overwritten by the system not to corrupt the interaction with client at the viewpoint of HTTP protocol layer. For instance, if we are keeping the connection alive, without this manipulation it will be a catastrophe when we send a header "Content-Length: 10" and actually send a body of 20 bytes long to the remote peer. In this case the client shall only accept the first 10 bytes of response body and thinks that the residual 10 bytes is a part of the header of the next response.

deleteHeader name deletes a response header name if any. This function is not intended to be used so frequently.

Write a chunk in ByteString to the response body. You must first declare the response header "Content-Type" before applying this function. See setContentType.

Write a chunk in lazy ByteString to the response body. It can be safely applied to an infinitely long ByteString.

Note that you must first declare the response header "Content-Type" before applying this function. See setContentType.

Run a Builder to construct a chunk, and write it to the response body. It can be safely applied to a Builder producing an infinitely long stream of octets.

Note that you must first declare the response header "Content-Type" before applying this function. See Network.HTTP.Lucu.setContentType.