(*
  OCaml HTTP - do it yourself (fully OCaml) HTTP daemon

  Copyright (C) <2002> Stefano Zacchiroli <zack@cs.unibo.it>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*)

  (** send a CRLF sequence on the given output channel, this is mandatory after
  the last header was sent and before start sending the response body *)
val send_CRLF: out_channel -> unit

  (** send response status line, version is the http version used in response,
  either code or status must be given (not both, not none) which represent the
  HTTP response code, outchan is the output channel to which send status line *)
val send_status_line:
  ?version: Http_types.version -> ?code: int -> ?status: Http_types.status ->
  out_channel ->
    unit

  (** like send_status_line but additionally will also send "Date" and "Server"
  standard headers *)
val send_basic_headers:
  ?version: Http_types.version -> ?code: int -> ?status: Http_types.status ->
  out_channel ->
    unit

  (** send an HTTP header on outchan *)
val send_header: header: string -> value: string -> out_channel -> unit

  (** as send_header, but for a list of pairs <header, value> *)
val send_headers: headers:(string * string) list -> out_channel -> unit

  (** send a file through an out_channel, file can be passed as an in_channel
  (if 'file' is given) or as a file name (if 'name' is given) *)
val send_file: ?name:string -> ?file:in_channel -> out_channel -> unit

  (** high level response function, respond on outchan sending: basic headers,
  headers probided via 'headers' argument, body given via 'body' argument.
  Default response status is 200, default response HTTP version is
  Http_common.http_version *)
val respond:
  ?body:string -> ?headers:(string * string) list ->
  ?version:Http_types.version -> ?code:int -> ?status:Http_types.status ->
  out_channel ->
    unit

  (** send a 404 (not found) HTTP response *)
val respond_not_found:
  url:string -> ?version: Http_types.version -> out_channel -> unit

  (** send a 403 (forbidden) HTTP response *)
val respond_forbidden:
  url:string -> ?version: Http_types.version -> out_channel -> unit

  (** send a "redirection" class response, optional body argument contains data
  that will be displayed in the body of the response, default response status is
  302 (moved permanently), only redirection status are accepted by this
  function, other values will raise Failure *)
val respond_redirect:
  location:string -> ?body:string ->
  ?version: Http_types.version ->
  ?code: int -> ?status: Http_types.redirection_status ->
  out_channel ->
    unit

  (** send an "error" response (i.e. 400 <= status < 600), optional body
  argument as per send_redirect, default response status is 400 (bad request),
  only error status are accepted by this function, other values will
  raise Failure *)
val respond_error:
  ?body:string ->
  ?version: Http_types.version ->
  ?code: int -> ?status: Http_types.error_status ->
  out_channel ->
    unit

  (** tipical static pages http daemon behaviour, if requested url is a file,
  return it, it it is a directory return a directory listing of it *)
val respond_file:
  fname:string -> ?version: Http_types.version -> out_channel -> unit

  (** respond using a prebuilt Http_types.response object *)
val respond_with: Http_types.response -> out_channel -> unit

  (** create an HTTP daemon listening on 'addr':'port' (defaults are
  addr:"0.0.0.0" and port:80), callback is the user supplied function which
  receive as a first parameter the path required by the the HTTP client as a
  string, and a list of pair <parameter, value> representing parameters passed
  via GET. The last argument of the callback is an output_channel connected to
  the HTTP client to which the user can write directly. 'timeout' parameter sets
  a timeout for each request processed by the daemon, if it's set to None,
  daemon waits forever for completed requests (use with care!), default is 5
  minute. 'mode' parameter has 3 possible values: `Single means that all request
  are handled by the same process, `Fork means that each request is handled by a
  separate process, `Thread means that each request is handled by a separate
  thread, default is `Fork; 'root' (mnemonic "document root") is the directory
  where the daemon chdir before starting up, default is current working
  directory *)
val start:
  ?addr: string -> ?port: int ->
  ?timeout: int option -> ?mode: Http_types.daemon_mode -> ?root: string ->
  (string -> (string * string) list -> out_channel -> unit) ->
    unit

  (** identical to 'start' above but callback receive two arguments, the second
  one is an out_channel as per 'start', but the secondo one is a Request.request
  object *)
val start':
  ?addr: string -> ?port: int ->
  ?timeout: int option -> ?mode: Http_types.daemon_mode -> ?root: string -> 
  (Http_types.request -> out_channel -> unit) ->
    unit

(*
  (** OO interface to HTTP daemons *)
class daemon:
  ?addr: string -> ?port: int ->
  ?timeout: int option -> ?mode: Http_types.daemon_mode ->?root:; string -> 
  (Http_types.request -> out_channel -> unit) ->
    Http_types.daemon
*)

  (** Trivial static pages HTTP daemon *)
module Trivial :
  sig
    val callback : string -> 'a -> out_channel -> unit
    val start : ?addr:string -> ?port:int -> unit -> unit
  end