{proplist_file, path()}:

If this property is defined, Inets expects to find all other properties defined in this file. The file must include all properties listed under mandatory properties.

{port, integer()} :

The port that the HTTP server listen to. If zero is specified as port, an arbitrary available port is picked and function httpd:info/2 can be used to determine which port was picked.

{server_name, string()}:

The name of your server, normally a fully qualified domain name.

{server_root, path()}:

Defines the home directory of the server, where log files, and so on, can be stored. Relative paths specified in other properties refer to this directory.

{document_root, path()}:

Defines the top directory for the documents that are available on the HTTP server.

{bind_address, ip_address() | hostname() | any}:

Default is any

{profile, atom()}:

Used together with bind_address and port to uniquely identify a HTTP server. This can be useful in a virtualized environment, where there can be more that one server that has the same bind_address and port. If this property is not explicitly set, it is assumed that the bind_address and port uniquely identifies the HTTP server.

{socket_type, ip_comm | {ip_comm, Config::proplist()} | {ssl, Config::proplist()}}:

For ip_comm configuration options, see gen_tcp:listen/2, some options that are used internally by httpd cannot be set.

{ipfamily, inet | inet6}:

Default is inet, legacy option inet6fb4 no longer makes sense and will be translated to inet.

{minimum_bytes_per_second, integer()}:

If given, sets a minimum of bytes per second value for connections.

{modules, [atom()]} :

Defines which modules the HTTP server uses when handling requests. Default is [mod_alias, mod_auth, mod_esi, mod_actions, mod_cgi, mod_dir, mod_get, mod_head, mod_log, mod_disk_log]. Notice that some mod-modules are dependent on others, so the order cannot be entirely arbitrary. See the Inets Web Server Modules in the User's Guide for details.

{customize, atom()}:

A callback module to customize the inets HTTP servers behaviour see httpd_custom_api

{disable_chunked_transfer_encoding_send, boolean()}:

Allows you to disable chunked transfer-encoding when sending a response to an HTTP/1.1 client. Default is false.

{keep_alive, boolean()}:

Instructs the server whether to use persistent connections when the client claims to be HTTP/1.1 compliant. Default is true.

{keep_alive_timeout, integer()}:

The number of seconds the server waits for a subsequent request from the client before closing the connection. Default is 150.

{max_body_size, integer()}:

Limits the size of the message body of an HTTP request. Default is no limit.

{max_clients, integer()}:

Limits the number of simultaneous requests that can be supported. Default is 150.

{max_header_size, integer()}:

Limits the size of the message header of an HTTP request. Default is 10240.

{max_content_length, integer()}:

Maximum content-length in an incoming request, in bytes. Requests with content larger than this are answered with status 413. Default is 100000000 (100 MB).

{max_uri_size, integer()}:

Limits the size of the HTTP request URI. Default is no limit.

{max_keep_alive_request, integer()}:

The number of requests that a client can do on one connection. When the server has responded to the number of requests defined by max_keep_alive_requests, the server closes the connection. The server closes it even if there are queued request. Default is no limit.

{max_client_body_chunk, integer()}:

Enforces chunking of a HTTP PUT or POST body data to be delivered to the mod_esi callback. Note this is not supported for mod_cgi. Default is no limit e.i the whole body is delivered as one entity, which could be very memory consuming. mod_esi(3erl).

{mime_types, [{MimeType, Extension}] | path()}:

MimeType = string() and Extension = string(). Files delivered to the client are MIME typed according to RFC 1590. File suffixes are mapped to MIME types before file delivery. The mapping between file suffixes and MIME types can be specified in the property list.

{mime_type, string()}:

When the server is asked to provide a document type that cannot be determined by the MIME Type Settings, the server uses this default type.

{server_admin, string()}:

Defines the email-address of the server administrator to be included in any error messages returned by the server.

{server_tokens, none|prod|major|minor|minimal|os|full|{private, string()}}:

Defines the look of the value of the server header.

{logger, Options::list()}:

Currently only one option is supported:

#{server_name => string()


  protocol => internal | 'TCP' | 'TLS' | 'HTTP',


  transport => "TCP "| "TLS", %% Present when protocol = 'HTTP'


  uri => string(), %% Present when protocol = 'HTTP' and URI is valid


  peer => inet:peername(),


  host => inet:hostname(),


  reason => term()
}

=ERROR REPORT==== 9-Oct-2019::09:33:27.350235 ===


   Server: My Server


 Protocol: HTTP
Transport: TLS


      URI: /not_there


     Host: 127.0.1.1:80


     Peer: 127.0.0.1:45253


   Reason: [{statuscode,404},{description,"Object Not Found"}]

{fun logger_filters:domain/2,
	{log,equal,[otp,inets, httpd, ServerID, error]}

[{kernel,


 [{logger,


  [{handler, http_error_test, logger_std_h,


    #{config => #{ file => "log/http_error.log" },


      filters => [{inets_httpd, {fun logger_filters:domain/2,


                                 {log, equal,


                                  [otp, inets, httpd, my_server, error]


                                 }}}],


      filter_default => stop }}]}]}].
	

logger:add_handler_filter(default,


                          inets_httpd,


                          {fun logger_filters:domain/2,


                           {log, equal,


                            [otp, inets, httpd, my_server, error]}}).

{log_format, common | combined}:

Defines if access logs are to be written according to the common log format or the extended common log format. The common format is one line looking like this: remotehost rfc931 authuser [date] "request" status bytes.

{error_log_format, pretty | compact}:

Default is pretty. If the error log is meant to be read directly by a human, pretty is the best option.

io:format("[~s] ~s, reason: ~n ~p ~n~n", [Date, Msg, Reason]).

io:format("[~s] ~s, reason: ~w ~n", [Date, Msg, Reason]).

{alias, {Alias, RealName}}:

Alias = string() and RealName = string(). alias allows documents to be stored in the local file system instead of the document_root location. URLs with a path beginning with url-path is mapped to local files beginning with directory-filename, for example:

{alias, {"/image", "/ftp/pub/image"}}

{re_write, {Re, Replacement}}:

Re = string() and Replacement = string(). re_write allows documents to be stored in the local file system instead of the document_root location. URLs are rewritten by re:replace/3 to produce a path in the local file-system, for example:

{re_write, {"^/[~]([^/]+)(.*)$", "/home/\\1/public\\2"}}

{directory_index, [string()]}:

directory_index specifies a list of resources to look for if a client requests a directory using a / at the end of the directory name. file depicts the name of a file in the directory. Several files can be given, in which case the server returns the first it finds, for example:

{directory_index, ["index.html", "welcome.html"]}

{script_alias, {Alias, RealName}}:

Alias = string() and RealName = string(). Have the same behavior as property alias, except that they also mark the target directory as containing CGI scripts. URLs with a path beginning with url-path are mapped to scripts beginning with directory-filename, for example:

{script_alias, {"/cgi-bin/", "/web/cgi-bin/"}}

{script_re_write, {Re, Replacement}}:

Re = string() and Replacement = string(). Have the same behavior as property re_write, except that they also mark the target directory as containing CGI scripts. URLs with a path beginning with url-path are mapped to scripts beginning with directory-filename, for example:

{script_re_write, {"^/cgi-bin/(\\d+)/", "/web/\\1/cgi-bin/"}}

{script_nocache, boolean()}:

If script_nocache is set to true, the HTTP server by default adds the header fields necessary to prevent proxies from caching the page. Generally this is preferred. Default to false.

{script_timeout, integer()}:

The time in seconds the web server waits between each chunk of data from the script. If the CGI script does not deliver any data before the timeout, the connection to the client is closed. Default is 15.

{action, {MimeType, CgiScript}} - requires mod_action:

MimeType = string() and CgiScript = string(). action adds an action activating a CGI script whenever a file of a certain MIME type is requested. It propagates the URL and file path of the requested document using the standard CGI PATH_INFO and PATH_TRANSLATED environment variables.

{action, {"text/plain", "/cgi-bin/log_and_deliver_text"}}

{script, {Method, CgiScript}} - requires mod_action:

Method = string() and CgiScript = string(). script adds an action activating a CGI script whenever a file is requested using a certain HTTP method. The method is either GET or POST, as defined in RFC 1945. It propagates the URL and file path of the requested document using the standard CGI PATH_INFO and PATH_TRANSLATED environment variables.

{script, {"PUT", "/cgi-bin/put"}}

{erl_script_alias, {URLPath, [AllowedModule]}}:

URLPath = string() and AllowedModule = atom(). erl_script_alias marks all URLs matching url-path as erl scheme scripts. A matching URL is mapped into a specific module and function, for example:

{erl_script_alias, {"/cgi-bin/example", [httpd_example]}}

{erl_script_nocache, boolean()}:

If erl_script_nocache is set to true, the server adds HTTP header fields preventing proxies from caching the page. This is generally a good idea for dynamic content, as the content often varies between each request. Default is false.

{erl_script_timeout, integer()}:

If erl_script_timeout sets the time in seconds the server waits between each chunk of data to be delivered through mod_esi:deliver/2. Default is 15. This is only relevant for scripts that use the erl scheme.

{error_log, path()}:

Defines the filename of the error log file to be used to log server errors. If the filename does not begin with a slash (/), it is assumed to be relative to the server_root.

{security_log, path()}:

Defines the filename of the access log file to be used to log security events. If the filename does not begin with a slash (/), it is assumed to be relative to the server_root.

{transfer_log, path()}:

Defines the filename of the access log file to be used to log incoming requests. If the filename does not begin with a slash (/), it is assumed to be relative to the server_root.

{disk_log_format, internal | external}:

Defines the file format of the log files. See disk_log for details. If the internal file format is used, the log file is repaired after a crash. When a log file is repaired, data can disappear. When the external file format is used, httpd does not start if the log file is broken. Default is external.

{error_disk_log, path()}:

Defines the filename of the (disk_log(3erl)) error log file to be used to log server errors. If the filename does not begin with a slash (/), it is assumed to be relative to the server_root.

{error_disk_log_size, {MaxBytes, MaxFiles}}:

MaxBytes = integer() and MaxFiles = integer(). Defines the properties of the (disk_log(3erl)) error log file. This file is of type wrap log and max bytes is written to each file and max files is used before the first file is truncated and reused.

{security_disk_log, path()}:

Defines the filename of the (disk_log(3erl)) access log file logging incoming security events, that is, authenticated requests. If the filename does not begin with a slash (/), it is assumed to be relative to the server_root.

{security_disk_log_size, {MaxBytes, MaxFiles}}:

MaxBytes = integer() and MaxFiles = integer(). Defines the properties of the disk_log(3erl) access log file. This file is of type wrap log and max bytes is written to each file and max files is used before the first file is truncated and reused.

{transfer_disk_log, path()}:

Defines the filename of the (disk_log(3erl)) access log file logging incoming requests. If the filename does not begin with a slash (/), it is assumed to be relative to the server_root.

{transfer_disk_log_size, {MaxBytes, MaxFiles}}:

MaxBytes = integer() and MaxFiles = integer(). Defines the properties of the disk_log(3erl) access log file. This file is of type wrap log and max bytes is written to each file and max files is used before the first file is truncated and reused.

{allow_from, all | [RegxpHostString]}:

Defines a set of hosts to be granted access to a given directory, for example:

{allow_from, ["123.34.56.11", "150.100.23"]}

{deny_from, all | [RegxpHostString]}:

Defines a set of hosts to be denied access to a given directory, for example:

{deny_from, ["123.34.56.11", "150.100.23"]}

{auth_type, plain | dets | mnesia}:

Sets the type of authentication database that is used for the directory. The key difference between the different methods is that dynamic data can be saved when Mnesia and Dets are used.

{auth_user_file, path()}:

Sets the name of a file containing the list of users and passwords for user authentication. The filename can be either absolute or relative to the server_root. If using the plain storage method, this file is a plain text file where each line contains a username followed by a colon, followed by the non-encrypted password. If usernames are duplicated, the behavior is undefined.

 ragnar:s7Xxv7


 edward:wwjau8 

{auth_group_file, path()}:

Sets the name of a file containing the list of user groups for user authentication. The filename can be either absolute or relative to the server_root. If the plain storage method is used, the group file is a plain text file, where each line contains a group name followed by a colon, followed by the members usernames separated by spaces.

group1: bob joe ante

{auth_name, string()}:

Sets the name of the authorization realm (auth-domain) for a directory. This string informs the client about which username and password to use.

{auth_access_password, string()}:

If set to other than "NoPassword", the password is required for all API calls. If the password is set to "DummyPassword", the password must be changed before any other API calls. To secure the authenticating data, the password must be changed after the web server is started. Otherwise it is written in clear text in the configuration file.

{require_user, [string()]}:

Defines users to grant access to a given directory using a secret password.

{require_group, [string()]}:

Defines users to grant access to a given directory using a secret password.

{data_file, path()}:

Name of the security data file. The filename can either be absolute or relative to the server_root. This file is used to store persistent data for module mod_security.

{max_retries, integer()}:

Specifies the maximum number of attempts to authenticate a user before the user is blocked out. If a user successfully authenticates while blocked, the user receives a 403 (Forbidden) response from the server. If the user makes a failed attempt while blocked, the server returns 401 (Unauthorized), for security reasons. Default is 3. Can be set to infinity.

{block_time, integer()}:

Specifies the number of minutes a user is blocked. After this time has passed, the user automatically regains access. Default is 60.

{fail_expire_time, integer()}:

Specifies the number of minutes a failed user authentication is remembered. If a user authenticates after this time has passed, the previous failed authentications are forgotten. Default is 30.

{auth_timeout, integer()}:

Specifies the number of seconds a successful user authentication is remembered. After this time has passed, the authentication is no longer reported. Default is 30.

Types:

Fetches information about the HTTP server. When called with only the pid, all properties are fetched. When called with a list of specific properties, they are fetched. The available properties are the same as the start options of the server.

Types:

Fetches information about the HTTP server. When called with only Address and Port, all properties are fetched. When called with a list of specific properties, they are fetched. The available properties are the same as the start options of the server.

Types:

Reloads the HTTP server configuration without restarting the server. Incoming requests are answered with a temporary down message during the reload time.

If mode is disturbing, the server is blocked forcefully, all ongoing requests terminates, and the reload starts immediately. If mode is non-disturbing, no new connections are accepted, but ongoing requests are allowed to complete before the reload is done.

data:

Type [{InteractionKey,InteractionValue}] is used to propagate data between modules. Depicted interaction_data() in function type declarations.

socket_type:

socket_type() indicates whether it is an IP socket or an ssl socket.

socket:

The socket, in format ip_comm or ssl, depending on socket_type.

config_db:

The config file directives stored as key-value tuples in an ETS table. Depicted config_db() in function type declarations.

method:

Type "GET" | "POST" | "HEAD" | "TRACE", that is, the HTTP method.

absolute_uri:

If the request is an HTTP/1.1 request, the URI can be in the absolute URI format. In that case, httpd saves the absolute URI in this field. An Example of an absolute URI is "http://ServerName:Part/cgi-bin/find.pl?person=jocke"

request_uri:

The Request-URI as defined in RFC 1945, for example, "/cgi-bin/find.pl?person=jocke".

http_version:

The HTTP version of the request, that is, "HTTP/1.0", or "HTTP/1.1".

request_line:

The Request-Line as defined inRFC 1945, for example, "GET /cgi-bin/find.pl?person=jocke HTTP/1.0".

parsed_header:

Type [{HeaderKey,HeaderValue}]. parsed_header contains all HTTP header fields from the HTTP request stored in a list as key-value tuples. See RFC 2616 for a listing of all header fields. For example, the date field is stored as {"date","Wed, 15 Oct 1997 14:35:17 GMT"}. RFC 2616 defines that HTTP is a case-insensitive protocol and the header fields can be in lower case or upper case. httpd ensures that all header field names are in lower case.

entity_body:

The entity-Body as defined in RFC 2616, for example, data sent from a CGI script using the POST method.

connection:

true | false. If set to true, the connection to the client is a persistent connection and is not closed when the request is served.

Types:

When a valid request reaches httpd, it calls do/1 in each module, defined by the configuration option of Module. The function can generate data for other modules or a response that can be sent back to the client.

The field data in ModData is a list. This list is the list returned from the last call to do/1.

Body is the body of the HTTP response that is sent back to the client. An appropriate header is appended to the message. StatusCode is the status code of the response, see RFC 2616 for the appropriate values.

Head is a key value list of HTTP header fields. The server constructs an HTTP header from this data. See RFC 2616 for the appropriate value for each header field. If the client is an HTTP/1.0 client, the server filters the list so that only HTTP/1.0 header fields are sent back to the client.

If Body is returned and equal to {Fun,Arg}, the web server tries apply/2 on Fun with Arg as argument. The web server expects that the fun either returns a list (Body) that is an HTTP response, or the atom sent if the HTTP response is sent back to the client. If close is returned from the fun, something has gone wrong and the server signals this to the client by closing the connection.

Types:

When httpd is shut down, it tries to execute remove/1 in each Erlang web server callback module. The programmer can use this function to clean up resources created in the store function.

Types:

Checks the validity of the configuration options before saving them in the internal database. This function can also have a side effect, that is, setup of necessary extra resources implied by the configuration option. It can also resolve possible dependencies among configuration options by changing the value of the option. This function only needs clauses for the options implemented by this particular callback module.

Types:

parse_query/1 parses incoming data to erl and eval scripts (see mod_esi(3erl)) as defined in the standard URL format, that is, '+' becomes 'space' and decoding of hexadecimal characters (%xx).