### Example Installation Output

Source: https://civetweb.github.io/civetweb/Building.html

This is an example output of the 'make -n install PREFIX=/opt/civetweb' command, showing the installation steps without actually performing them.

```bash
install -d -m 755  "/opt/civetweb/share/doc/civetweb"
install -m 644 resources/itworks.html /opt/civetweb/share/doc/civetweb/index.html
install -m 644 resources/civetweb_64x64.png /opt/civetweb/share/doc/civetweb/
install -d -m 755  "/opt/civetweb/etc"
install -m 644 resources/civetweb.conf  "/opt/civetweb/etc/"
sed -i 's#^document_root.*$#document_root /opt/civetweb/share/doc/civetweb#' "/opt/civetweb/etc/civetweb.conf"
sed -i 's#^listening_ports.*$#listening_ports 8080#' "/opt/civetweb/etc/civetweb.conf"
install -d -m 755  "/opt/civetweb/share/doc/civetweb"
install -m 644 *.md "/opt/civetweb/share/doc/civetweb"
install -d -m 755 "/opt/civetweb/bin"
install -m 755 civetweb "/opt/civetweb/bin/"
```

--------------------------------

### Start CivetWeb with Configuration File

Source: https://civetweb.github.io/civetweb/UserManual.html

Example of starting the CivetWeb server using a configuration file. The settings in 'CivetWeb.conf' are applied.

```bash
$ cat CivetWeb.conf
listening_ports 1234
document_root /var/www
$ CivetWeb
```

--------------------------------

### Start CivetWeb with Command Line Arguments

Source: https://civetweb.github.io/civetweb/UserManual.html

Example of starting the CivetWeb server using command-line arguments for listening ports and document root.

```bash
$ CivetWeb -listening_ports 1234 -document_root /var/www
```

--------------------------------

### Minimal CivetWeb Server Initialization and Handler Setup (C)

Source: https://civetweb.github.io/civetweb/Embedding.html

Demonstrates the essential steps to initialize CivetWeb, start the server, set a request handler for '/hello', and then stop the server. Ensure to call mg_init_library(0) before mg_start() and mg_exit_library() after mg_stop().

```c
{
    /* Server context handle */
    struct mg_context *ctx;

    /* Initialize the library */
    mg_init_library(0);

    /* Start the server */
    ctx = mg_start(NULL, 0, NULL);

    /* Add some handler */
    mg_set_request_handler(ctx, "/hello", handler, "Hello world");

    ... Run the application ...
    
    /* Stop the server */
    mg_stop(ctx);

    /* Un-initialize the library */
    mg_exit_library();
}
```

--------------------------------

### Install CivetWeb

Source: https://civetweb.github.io/civetweb/Building.html

Install CivetWeb on the system. This command is primarily for Linux.

```bash
make install
```

--------------------------------

### Install CivetWeb using vcpkg

Source: https://civetweb.github.io/civetweb/Installing.html

Use the vcpkg dependency manager to download and install CivetWeb. Ensure vcpkg is set up correctly before running these commands.

```bash
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
./vcpkg install civetweb

```

--------------------------------

### Configure CivetWeb Standalone Server

Source: https://civetweb.github.io/civetweb/UserManual.html

Example of a CivetWeb configuration file. Lines starting with '#' and empty lines are ignored. Configuration options can be overridden by command-line arguments.

```config
document_root c:\www
listening_ports 80,443s
ssl_certificate c:\CivetWeb\ssl_cert.pem

```

--------------------------------

### Build and Install CivetWeb in Docker

Source: https://civetweb.github.io/civetweb/Docker.html

Compiles CivetWeb with all features enabled and installs it to the /app directory within the Docker build stage.

```Dockerfile
RUN make build && \
    make WITH_ALL=1 && \
    make install PREFIX=/app
```

--------------------------------

### Basic Lua Server Page Example

Source: https://civetweb.github.io/civetweb/UserManual.html

This example demonstrates how to use `mg.write()` to output dynamic content and access request information within a Lua Server Page.

```html
<p>
  <span>Today is:</span>
  <? mg.write(os.date("%A")) ?>
</p>
<p>
  URI is <?=mg.request_info.uri?>
</p>

```

--------------------------------

### Dry Run Installation with Custom Prefix

Source: https://civetweb.github.io/civetweb/Building.html

Perform a dry run of the 'make install' command to see where CivetWeb would be installed with a custom PREFIX. The -n option prevents actual installation.

```bash
make -n install PREFIX=/opt/civetweb
```

--------------------------------

### List Make Options

Source: https://civetweb.github.io/civetweb/Building.html

Run this command to get a list of all supported make options for building CivetWeb on Linux, BSD, and OSX.

```bash
make help
```

--------------------------------

### Install Runtime Dependencies in Docker Image Stage

Source: https://civetweb.github.io/civetweb/Docker.html

Installs only the necessary runtime libraries for CivetWeb in the final Docker image stage.

```Dockerfile
FROM alpine:3.18
RUN apk update && \
    apk add --no-cache \
    libstdc++ zlib
```

--------------------------------

### Build CivetWeb on Linux

Source: https://civetweb.github.io/civetweb/Installing.html

Standard build process for CivetWeb on Linux systems. This involves downloading the source, compiling, and installing.

```bash
make help
make
make install

```

--------------------------------

### mg_start

Source: https://civetweb.github.io/civetweb/api/mg_start.html

Initializes the Civetweb web server. It's the primary function to call for server setup, accepting callbacks for event handling and options for configuration. Returns a context pointer on success or NULL on failure.

```APIDOC
## mg_start

### Description
The function `mg_start()` is the only function needed to call to initialize the webserver. After the function returns and a pointer to a context structure is provided, it is guaranteed that the server has started and is listening on the designated ports. In case of failure a NULL pointer is returned. The behaviour of the web server is controlled by a list of callback functions and a list of options. The callback functions can do application specific processing of events which are encountered by the webserver. If a specific callback function is set to NULL, the webserver uses their default callback routine. The options list controls how the webserver should be started and contains settings for for example the ports to listen on, the maximum number of threads created to handle requests in parallel and if settings for SSL encryption.
As a side effect on Unix systems, SIGCHLD and SIGPIPE signals will be ignored. If custom processing is needed for these signals, signal handlers must be setup after the call to `mg_start()` has completed.

### Parameters
#### Function Parameters
- **`callbacks`** (`const struct mg_callbacks *`) - A structure with optional callback functions to process requests from the web server.
- **`user_data`** (`void *`) - A pointer to optional user data.
- **`options`** (`char **`) - A list of options used to initialize the web server. The list consists of an NULL terminated list of option-value string pairs.

#### Options
- **`cgi_environment`** (string) - The option `cgi_environment` can contain extra variables to be passed to the CGI script in addition to the standard environment variables. The lust must be a comma separated list of name=value pairs like this: `VARIABLE1=VALUE1,VARIABLE2=VALUE2`.
- **`cgi_interpreter`** (string) - The option `cgi_interpreter` can contain a path to an executable which will be used as a CGI interpreter for **all** CGI scripts regardless of the script file extension. If this option is not set (which is the default), CivetWeb looks at the first line of a CGI script to see if an interpreter is defined there. This first line is formatted as a shebang line as common in unix style shell scripts, but this will also work in Windows. For more information about the syntax, please see the Wikipedia page about the shebang line.
- **`cgi_pattern`** (string) - Default: `**.cgi$|**.pl$|**.php$` - All files that match `cgi_pattern` are treated as CGI files. The default pattern allows CGI files to be anywhere. To restrict CGIs to a certain directory, use `/path/to/cgi-bin/**.cgi` as a pattern. Note that the full path of the local file is matched against the pattern, not the URI provided in the client request.
- **`put_delete_auth_file`** (string) - The option `put_delete_auth_file` defines the password file to be used for PUT and DELETE requests. Without a password file it is not possible to put new files to the server, or to delete existing ones. This only applies to direct HTTP requests which use the PUT and DELETE methods without server side scripting. PUT and DELETE requests might still be handled by Lua scripts and CGI pages.

### Return Value
- **`struct mg_context *`** - A pointer to a context structure when successful, or NULL in case of failure.

### See Also
- `struct mg_callbacks;`
- `mg_stop();`
```

--------------------------------

### SSI Exec Directive Example

Source: https://civetweb.github.io/civetweb/UserManual.html

Shows how to use the `<!--#exec "command">` directive to execute a server command and display its output. Ensure the command is safe to execute.

```html
<!--#exec "ls -l" -->
```

--------------------------------

### init_context

Source: https://civetweb.github.io/civetweb/api/mg_callbacks.html

Callback function called after the CivetWeb server has been initialized and started, but before any requests are processed.

```APIDOC
## init_context

### Description
This callback function is executed after the CivetWeb server has successfully started and completed its initialization. It is called before the server begins handling any incoming client requests, providing a window for the application to perform any necessary setup tasks.
```

--------------------------------

### Set Docker Container Entrypoint

Source: https://civetweb.github.io/civetweb/Docker.html

Defines the command that will be executed when the container starts, launching the CivetWeb server with its configuration file.

```Dockerfile
ENTRYPOINT  [ "/app/bin/civetweb", "/app/etc/civetweb.conf" ]
```

--------------------------------

### Install Build Dependencies in Dockerfile

Source: https://civetweb.github.io/civetweb/Docker.html

Installs build tools and libraries for CivetWeb compilation within the Docker build stage.

```Dockerfile
FROM alpine:3.18 AS build
RUN apk update && \
    apk add --no-cache \
    build-base zlib-dev
```

--------------------------------

### SSL Cipher List Examples

Source: https://civetweb.github.io/civetweb/UserManual.html

Illustrates how to configure the `ssl_cipher_list` option to specify which SSL/TLS ciphers the server should offer to clients. Examples include enabling all ciphers or excluding specific types.

```plaintext
ALL
```

```plaintext
ALL:!eNULL
```

```plaintext
AES128:!MD5
```

--------------------------------

### SSI Include Directive Examples

Source: https://civetweb.github.io/civetweb/UserManual.html

Demonstrates different ways to use the `<!--#include ...>` directive for Server Side Includes. Paths can be relative to the web server root, the current document, or absolute.

```html
<!--#include virtual="path">
```

```html
<!--#include abspath="path">
```

```html
<!--#include file="path">,
```

```html
<!--#include "path">
```

--------------------------------

### Examples of CivetWeb Pattern Matching

Source: https://civetweb.github.io/civetweb/UserManual.html

Illustrates various patterns used for matching file names in CivetWeb configuration. Covers matching file extensions, specific directories, and multiple file types.

```regex
**.cgi$
/foo
**a$|**b$
/data/????.css$
/data/*.js$
/api/*/*.cgi$
/*.jpg$|/*.jpeg$
**.jpg$|**.jpeg$

```

--------------------------------

### Kepler Syntax Lua Server Page Example

Source: https://civetweb.github.io/civetweb/UserManual.html

This example shows the use of Kepler Syntax (`<% %>` and `<%= %>`) for embedding Lua code and variables within an HTML page. It iterates over request information.

```html
<ul>
   <% for key, value in pairs(mg.request_info) do %>
   <li> <%= key %>: <%= value %> </li>
   <% end %>
</ul>

```

--------------------------------

### OpenSSL Library Load Error

Source: https://civetweb.github.io/civetweb/OpenSSL.html

This error message indicates that the SSL library has not been installed correctly. For Windows, consider using pre-built binaries and ensure the installation directory is the default system folder.

```log
load_dll: cannot load libeay32.*/libcrypto.*/ssleay32.*/libssl.*

```

--------------------------------

### Server API Functions

Source: https://civetweb.github.io/civetweb/APIReference.html

Functions for starting, stopping, configuring, and managing the CivetWeb server instance.

```APIDOC
## Server API Functions

### `mg_start( callbacks, user_data, options );`
Starts a new CivetWeb server instance with provided callbacks, user data, and options.

### `mg_start2( init, error );`
Starts a new CivetWeb server instance with initialization data and an error handler.

### `mg_start_domain( ctx, configuration_options );`
Starts a new domain within an existing server context.

### `mg_start_domain2( ctx, configuration_options, error );`
Starts a new domain within an existing server context with an error handler.

### `mg_stop( ctx );`
Stops the CivetWeb server instance associated with the given context.

### `mg_get_builtin_mime_type( file_name );`
Retrieves the MIME type for a given file name based on built-in mappings.

### `mg_get_option( ctx, name );`
Retrieves the value of a specific server option.

### `mg_get_server_ports( ctx, size, ports );`
Retrieves the list of ports the server is listening on.

### `mg_get_user_data( ctx );`
Retrieves the user-defined data associated with the server context.

### `mg_set_auth_handler( ctx, uri, handler, cbdata );`
Sets a custom authentication handler for a specific URI.

### `mg_set_request_handler( ctx, uri, handler, cbdata );`
Sets a custom request handler for a specific URI.

### `mg_set_websocket_handler( ctx, uri, connect_handler, ready_handler, data_handler, close_handler, cbdata );`
Sets a WebSocket handler for a specific URI with various callback functions.

### `mg_set_websocket_handler_with_subprotocols( ctx, uri, subprotocols, connect_handler, ready_handler, data_handler, close_handler, cbdata );`
Sets a WebSocket handler with support for specified subprotocols.

### `mg_lock_context( ctx );`
Acquires a lock on the server context for thread-safe operations.

### `mg_unlock_context( ctx );`
Releases the lock on the server context.

### `mg_get_context( conn );`
Retrieves the server context associated with a given connection.

### `mg_send_http_error( conn, status_code, fmt, ... );`
Sends an HTTP error response to the client.

### `mg_send_http_ok( conn, mime_type, content_length );`
Sends an HTTP OK response with specified MIME type and content length.

### `mg_send_http_redirect( conn, target_url, redirect_code );`
Sends an HTTP redirect response to the client.

### `mg_send_digest_access_authentication_request( conn, realm );`
Sends a Digest Access Authentication challenge to the client.

### `mg_check_digest_access_authentication( conn, realm, filename );`
Checks if the client's Digest Access Authentication credentials are valid.

### `mg_modify_passwords_file( passwords_file_name, realm, user, password );`
Modifies the password file to add or update user credentials.

### `mg_modify_passwords_file_ha1( passwords_file_name, realm, user, ha1 );`
Modifies the password file to add or update user credentials using HA1 hash.

### `mg_get_request_info( conn );`
Retrieves information about the current HTTP request.

### `mg_get_request_link( conn, buf, buflen );`
Retrieves the request URI or link associated with the connection.

### `mg_handle_form_request( conn, fdh );`
Handles form data submission for a given connection.

### `mg_send_file( conn, path );`
Sends a file as an HTTP response.

### `mg_send_mime_file( conn, path, mime_type );`
Sends a file with a specified MIME type as an HTTP response.

### `mg_send_mime_file2( conn, path, mime_type, additional_headers );`
Sends a file with a specified MIME type and additional headers as an HTTP response.

### `mg_websocket_write( conn, opcode, data, data_len );`
Writes data to a WebSocket connection.

### `mg_response_header_*();`
Functions for manipulating response headers (specific functions not detailed).
```

--------------------------------

### init_ssl_domain Callback

Source: https://civetweb.github.io/civetweb/api/mg_callbacks.html

The `init_ssl_domain()` callback is called during SSL library initialization for a specific domain. It allows custom SSL certificate setup per domain. Similar to `init_ssl`, return values control CivetWeb's subsequent actions.

```APIDOC
## init_ssl_domain Callback

### Description
The callback function `init_ssl_domain()` is called when CivetWeb initializes the SSL library. The parameter `server_domain` is a pointer to the `authentication_domain` config parameter of the domain being configured. The `ssl_ctx` parameter is a pointer to the SSL context being configure. The parameter `user_data` contains a pointer to the data which was provided to `mg_start()` when the server was started. The callback function can return 0 to signal that CivetWeb should setup the SSL certificate. With a return value of 1 the callback function signals CivetWeb that the certificate has already been setup and no further processing is necessary. The value -1 should be returned when the SSL initialization fails.

### Signature
`int (*init_ssl_domain)( const char *server_domain, void *ssl_ctx, void *user_data );`
```

--------------------------------

### Lua Background Script Functions

Source: https://civetweb.github.io/civetweb/UserManual.html

Implement these functions in your Lua background script for server startup, shutdown, and log handling. The 'start()' callback can be used for timer creation.

```lua
function start()
  -- called when the server is started
end

function stop()
  -- called when the server is stopped
end

function log(req, res)
  -- called when an access log entry is created
end
```

--------------------------------

### Worker Thread Loop Example

Source: https://civetweb.github.io/civetweb/Embedding.html

Illustrates the basic infinite loop structure of a CivetWeb worker thread, which continuously consumes and processes new connections.

```c
static void *worker_thread() {
  while (consume_socket()) {
    process_new_connection();
  }
}
```

--------------------------------

### Websocket Root Paths

Source: https://civetweb.github.io/civetweb/UserManual.html

Access `mg.websocket_root` and `mg.fallback_websocket_root` to get configured websocket root paths.

```lua
mg.websocket_root
mg.fallback_websocket_root
```

--------------------------------

### Configure Civetweb Error Log

Source: https://civetweb.github.io/civetweb/OpenSSL.html

Set up an error log file in 'civetweb.conf' to capture detailed information when the OpenSSL configuration is incorrect and the server fails to start.

```config
error_log_file error.log

```

--------------------------------

### CGI Script Interpreter Directive

Source: https://civetweb.github.io/civetweb/UserManual.html

Ensure your CGI script files start with a shebang line specifying the interpreter, like this example for Perl. This is an alternative to configuring a global cgi_interpreter.

```shell
#!/path/to/perl.exe
```

--------------------------------

### Buildroot Integration

Source: https://civetweb.github.io/civetweb/Building.html

Instructions for integrating Civetweb into a Buildroot environment. This involves adding Civetweb's configuration files to the Buildroot package directory.

```bash
source "package/civetweb/Config.in"
```

--------------------------------

### Get Current Time

Source: https://civetweb.github.io/civetweb/UserManual.html

Use `mg.time` to get the current Unix timestamp. If a boolean argument is true, it returns the time since server startup.

```lua
mg.time([bool])
```

--------------------------------

### Build with MinGW-w64/TDM-GCC

Source: https://civetweb.github.io/civetweb/Building.html

Use this command to build CivetWeb with MinGW-w64 or TDM-GCC. Ensure you are in the CivetWeb sources directory.

```bash
mingw32-make CC=gcc
```

--------------------------------

### external_ssl_ctx_domain

Source: https://civetweb.github.io/civetweb/api/mg_callbacks.html

Callback function called when CivetWeb is about to create or free a SSL context for a domain. It allows for custom SSL context setup or signals that setup is already complete.

```APIDOC
## external_ssl_ctx_domain

### Description
This callback function is invoked when CivetWeb is preparing to create (`*ssl_ctx` is `NULL`) or free (`*ssl_ctx` is not `NULL`) an SSL context. The `server_domain` parameter points to the `authentication_domain` configuration for the domain in question, and `user_data` holds data provided during `mg_start()`.

### Return Values
- `0`: Signals CivetWeb to proceed with its default SSL context setup.
- `1`: Indicates that the callback function has already set up the SSL context, and no further processing by CivetWeb is needed. `init_ssl()` and `init_ssl_domain()` will not be called.
- `-1`: Signals that the SSL context initialization failed.
```

--------------------------------

### Build Libraries with Options

Source: https://civetweb.github.io/civetweb/Building.html

Build static and shared libraries for CivetWeb. Additional make options can configure the library build, such as enabling IPv6 or Lua support.

```bash
make lib WITH_IPV6=1
```

```bash
make clean slib WITH_LUA=1 WITH_WEBSOCKET=1
```

--------------------------------

### Get Random Float

Source: https://civetweb.github.io/civetweb/UserManual.html

Use `mg.random` to obtain a random floating-point number.

```lua
mg.random()
```

--------------------------------

### init_ssl Callback

Source: https://civetweb.github.io/civetweb/api/mg_callbacks.html

The `init_ssl()` callback is triggered during CivetWeb's SSL library initialization. It allows for custom SSL context configuration. Returning 0 prompts CivetWeb to set up the certificate, while 1 indicates it's already done. A return value of -1 signifies failure.

```APIDOC
## init_ssl Callback

### Description
The callback function `init_ssl()` is called when CivetWeb initializes the SSL library. The `ssl_ctx` parameter is a pointer to the SSL context being configure. The parameter `user_data` contains a pointer to the data which was provided to `mg_start()` when the server was started. The callback function can return 0 to signal that CivetWeb should setup the SSL certificate. With a return value of 1 the callback function signals CivetWeb that the certificate has already been setup and no further processing is necessary. The value -1 should be returned when the SSL initialization fails.

### Signature
`int (*init_ssl)( void *ssl_ctx, void *user_data );`
```

--------------------------------

### Hashing and Utility Functions

Source: https://civetweb.github.io/civetweb/UserManual.html

Functions for generating MD5 hashes, managing keep-alive, and getting timestamps.

```APIDOC
## mg.md5

### Description
Calculates the MD5 hash of a given string.

### Method
`mg.md5(str)`

### Parameters
- **str** (string) - The string to hash.

### Returns
- The MD5 hash of the string.
```

```APIDOC
## mg.keep_alive

### Description
Allows or forbids the use of HTTP keep-alive for the current request.

### Method
`mg.keep_alive(bool)`

### Parameters
- **bool** (boolean) - True to allow keep-alive, false to forbid.
```

```APIDOC
## mg.time

### Description
Gets the current Unix timestamp. Optionally includes milliseconds or time since startup.

### Method
`mg.time([bool])`

### Parameters
- **bool** (boolean, optional) - If true, returns the time since startup.

### Returns
- The current Unix timestamp (with milliseconds if available).
```

--------------------------------

### Build CivetWeb Docker Image

Source: https://civetweb.github.io/civetweb/Docker.html

Command to build the Docker image locally, tagging it as 'civetweb:latest'.

```Shell
docker build -t civetweb:latest .
```

--------------------------------

### Run CivetWeb as Specific User

Source: https://civetweb.github.io/civetweb/UserManual.html

Switch CivetWeb's user credentials after startup. This is typically used when binding to privileged ports (like 80) on UNIX systems, allowing CivetWeb to drop root privileges after initialization for security.

```bash
civetweb -listening_ports 80 -run_as_user webserver
```

--------------------------------

### mg_get_var2

Source: https://civetweb.github.io/civetweb/api/mg_get_var2.html

Retrieves the content of a variable from POST data or GET URI, supporting multiple occurrences.

```APIDOC
## mg_get_var2

### Description
The function `mg_get_var2()` can be used to return the contents of a variable passed to the server as either POST data, or in the URI in a GET call. The function is similar to `mg_get_var()` but the difference is that `mg_get_var2()` can be used if the same variable is present multiple times in the data. The `occurrence` parameter is used to identify which instance of the variable must be returned where **`0`**is used for the first variable with the specified name,**`1`**for the second and so on.

The function returns the length of the variable content in the return buffer, **`-1`**if a variable with the specified name could not be found and**`-2`**if the pointer to the result buffer is NULL, the size of the result buffer is zero or when the result buffer is too small to contain the variable content and terminating NUL.

### Parameters
#### Path Parameters
- **`data`** (const char *) - Encoded data buffer from either POST data or a GET URI
- **`data_len`** (size_t) - The size of the encoded data buffer
- **`var_name`** (const char *) - The name of the variable to search for
- **`dst`** (char *) - Destination buffer to store the variable content
- **`dst_len`** (size_t) - The size of the destination buffer including the terminating NUL
- **`occurrence`** (size_t) - The instance index of the wanted variable

### Return Value
- **`int`** - Length of the variable contents, or an error code
```

--------------------------------

### mg_get_option

Source: https://civetweb.github.io/civetweb/api/mg_get_option.html

Retrieves the value of a specific configuration option from the Civetweb server context. Options are read-only and cannot be changed after the server has started.

```APIDOC
## mg_get_option

### Description
Retrieves the value of a specific configuration option from the Civetweb server context. Options are read-only and cannot be changed after the server has started. The function returns a pointer to a text string containing the value of the queried option, or NULL if an error occurred. If a valid option name is provided, a pointer to a string is guaranteed. If an option was empty or NULL during initialization, a pointer to an empty string is returned.

### Function Signature
`const char *mg_get_option( const struct mg_context *ctx, const char *name );`

### Parameters
#### Path Parameters
- **ctx** (`const struct mg_context *`) - Required - A pointer to the webserver context.
- **name** (`const char *`) - Required - The name of the option to query.

### Return Value
- `const char *` - A pointer to the option value in text, or NULL if an error occurred.
```

--------------------------------

### Build with Lua Support

Source: https://civetweb.github.io/civetweb/Building.html

Compile CivetWeb with Lua support enabled by setting the WITH_LUA=1 option on the command line.

```bash
make build WITH_LUA=1
```

--------------------------------

### mg_start_thread

Source: https://civetweb.github.io/civetweb/api/mg_start_thread.html

Starts a detached thread that executes a specified function with user-defined data. Returns 0 on success, or an error code otherwise.

```APIDOC
## mg_start_thread( func, cbdata );

### Description
The function `mg_start_thread()` is a convenience function to create a detached thread. The function returns **0** when successful and another value if an error occurred. A pointer to user supplied data can be passed which is then passed further on to the thread function as parameter.

### Parameters
#### Parameters
- **`func`** (`mg_thread_func_t`) - Function to start as a separate thread
- **`cbdata`** (`void *`) - User defined data to be passed to the thread as parameter

### Return Value
- **`int`** - Success or error code

### See Also
- `mg_start();`
```

--------------------------------

### Backup Original Private Key

Source: https://civetweb.github.io/civetweb/OpenSSL.html

Create a backup of the original private key before modifying it.

```bash
copy server.key server.key.orig
```

--------------------------------

### Set Default Index Files

Source: https://civetweb.github.io/civetweb/UserManual.html

Configure a comma-separated list of files to be treated as directory index files. The first matching file found in a directory is used.

```plaintext
index.xhtml,index.html,index.htm,index.cgi,index.shtml,index.php
```

--------------------------------

### init_lua

Source: https://civetweb.github.io/civetweb/api/mg_callbacks.html

Callback function invoked just before a Lua server page is served, provided Lua support was enabled at compile time.

```APIDOC
## init_lua

### Description
This callback function is called immediately before a Lua server page is about to be served. This callback is only triggered if Lua page serving was enabled during CivetWeb compilation. The `lua_context` parameter is a `lua_State *` pointer, and `context_flags` provides information about the type of Lua environment being used.
```

--------------------------------

### Set Compile Flags with make

Source: https://civetweb.github.io/civetweb/Building.html

Use the COPT make option to define preprocessor flags during compilation. For example, to disable debug code and CGI support.

```bash
make build COPT="-DNDEBUG -DNO_CGI"
```

--------------------------------

### Compile CivetWeb

Source: https://civetweb.github.io/civetweb/Building.html

Compile the CivetWeb code. Use 'WITH_ALL=1' to enable all optional features.

```bash
make build
```

```bash
make WITH_ALL=1
```

--------------------------------

### mg_init_library

Source: https://civetweb.github.io/civetweb/api/mg_init_library.html

Initializes Civetweb library features. This function should be called before any other Civetweb function. It supports multiple calls via reference counting but is not thread-safe.

```APIDOC
## mg_init_library( feature );

### Description
The function `mg_init_library()` should be called from an application program before using any other function. It can be called multiple times (`mg_init_library` and `mg_exit_library` are reference counting). However, the caller must make sure it is not called in parallel (it is not guaranteed to be thread safe).

### Parameters
#### Path Parameters
- **feature** (unsigned) - Required - A bitmask indicating the features to be initialized.

### Return Value
- **unsigned** - A value indicating the initialized features is available. 0 is returned on error.

### Feature Flags
Value | Compilation option | Feature Flags | Description
---|---|---|---
**1** | !NO_FILES | MG_FEATURES_FILES | Able to serve files. If this feature is available, the webserver is able to serve files directly from a directory tree.
**2** | !NO_SSL | MG_FEATURES_TLS | Support for HTTPS. If this feature is available, the webserver can use encryption in the client-server connection. SSLv2, SSLv3, TLSv1.0, TLSv1.1 and TLSv1.2 are supported depending on the SSL library CivetWeb has been compiled with, but which protocols are used effectively when the server is running is dependent on the options used when the server is started.
**4** | !NO_CGI | MG_FEATURES_CGI | Support for CGI. If this feature is available, external CGI scripts can be called by the webserver.
**8** | USE_IPV6 | MG_FEATURES_IPV6 | Support IPv6. The CivetWeb library is capable of communicating over both IPv4 and IPv6, but IPv6 support is only available if it has been enabled at compile time.
**16** | USE_WEBSOCKET | MG_FEATURES_WEBSOCKET | Support for web sockets. WebSockets support is available in the CivetWeb library if the proper options has been used during cimpile time.
**32** | USE_LUA | MG_FEATURES_LUA | Support for Lua scripts and Lua server pages. CivetWeb supports server side scripting through the Lua language, if that has been enabled at compile time. Lua is an efficient scripting language which is less resource heavy than for example PHP.
**64** | USE_DUKTAPE | MG_FEATURES_SSJS | Support for server side JavaScript. Server side JavaScript can be used for dynamic page generation if the proper options have been set at compile time. Please note that client side JavaScript execution is always available if it has been enabled in the connecting browser.
**128** | !NO_CACHING | MG_FEATURES_CACHE | Support for caching. The web server will support caching, if it has not been disabled while compiling the library.
**256** | USE_SERVER_STATS | MG_FEATURES_STATS | Support server statistics. The web server will collect data for server statistics.
**512** | USE_ZLIB | MG_FEATURES_COMPRESSION | Support for on the fly compression. The web server may use ZLIB for on the fly data compression.
**1024** | USE_HTTP2 | MG_FEATURES_HTTP2 | Support for HTTP/2 protocol. The web server will accept HTTP/2 connections over HTTPS.
**2048** | USE_X_DOM_SOCKET | MG_FEATURES_X_DOMAIN_SOCKET | Support for UNIX domain sockets. The web server will allow to bind to domain sockets, in addition to TCP sockets.
**65535** |  | MG_FEATURES_ALL | All feature flags.

The parameters can added using bitwise or. Values above 65535 are reserved, the behavior of the function is undefined if any unknown bit is set.
```

--------------------------------

### Get Civetweb Version

Source: https://civetweb.github.io/civetweb/api/mg_version.html

The `mg_version()` function returns a constant character pointer to a string representing the current Civetweb version (e.g., "1.9").

```APIDOC
## mg_version()

### Description
The function `mg_version()` can be used to return the current Civetweb version. The function returns a pointer to a string with the current major and minor version number separated with a dot, for example “1.9”.

### Parameters
_none_

### Return Value
Type | Description  
---|---
`const char *` | A pointer to a text with the current CivetWeb version
```

--------------------------------

### struct mg_client_options

Source: https://civetweb.github.io/civetweb/api/mg_client_options.html

The `mg_client_options` structure contains host and security information to connect as a client to another host. A parameter of this type is used in the call to the function `mg_connect_client_secure();`. Please note that IPv6 addresses are only permitted if IPv6 support was enabled during compilation. You can use the function `mg_check_feature()` with the parameter `USE_IPV6` while running your application to check if IPv6 is supported.

```APIDOC
## struct mg_client_options

### Description
The `mg_client_options` structure contains host and security information to connect as a client to another host. A parameter of this type is used in the call to the function `mg_connect_client_secure();`. Please note that IPv6 addresses are only permitted if IPv6 support was enabled during compilation. You can use the function `mg_check_feature()` with the parameter `USE_IPV6` while running your application to check if IPv6 is supported.

### Fields
#### host
- Type: `const char *`
- Description: The hostname or IP address to connect to

#### port
- Type: `int`
- Description: The port on the server

#### client_cert
- Type: `const char *`
- Description: Pointer to client certificate

#### server_cert
- Type: `const char *`
- Description: Pointer to a server certificate

### See Also
- `mg_check_feature();`
- `mg_connect_client_secure();`
```

--------------------------------

### Calculate HA1 Hash for Password File Modification

Source: https://civetweb.github.io/civetweb/api/mg_modify_passwords_file_ha1.html

This example demonstrates how to calculate the HA1 hash required by mg_modify_passwords_file_ha1. The HA1 hash is the MD5 checksum of the string 'user:realm:password'.

```bash
$ echo -n "myuser:myrealm:secret" | md5sum
e67fd3248b58975c3e89ff18ecb75e2f  -
```

--------------------------------

### Override Configuration with Command Line Arguments

Source: https://civetweb.github.io/civetweb/UserManual.html

Demonstrates how command-line arguments take precedence over settings in a configuration file. The document root is set to 'D:\web' overriding the 'c:\www' specified in the config file.

```bash
CivetWeb -document_root D:\web
```

--------------------------------

### Cross Compiling with make

Source: https://civetweb.github.io/civetweb/Building.html

Specify the C compiler, compile options, and target operating system for cross-compilation using make options like CC, COPT, and TARGET_OS.

```bash
make CC=arm-none-linux-gnueabi-gcc COPT="-march=armv7-a  -mfpu=vfp -mfloat-abi=softfp" TARGET_OS=FROG
```

--------------------------------

### mg_response_header_start

Source: https://civetweb.github.io/civetweb/api/mg_response_header_X.html

Initializes the process of sending HTTP response headers. This function must be called once before adding any headers.

```APIDOC
## mg_response_header_start

### Description
Initializes the process of sending HTTP response headers. This function must be called once before adding any headers.

### Method
`mg_response_header_start( conn, status );`

### Parameters
#### Path Parameters
- **conn** (`struct mg_connection *`) - Required - The server is sending a response to this connection.
- **status** (`int`) - Required - HTTP status code to send (100-599).

### Return Value
`int` - An integer indicating success (>=0) or failure (<0).
- `-1`: Error: Invalid parameter (e.g., NULL pointer or value out of range).
- `-2`: Error: Invalid connection type. These functions must only be used in web server request handlers.
- `-3`: Error: Invalid connection status. These functions must be used before `mg_send()` or `mg_printf()` functions.

### See Also
- `mg_response_header_add()`
- `mg_response_header_add_lines()`
- `mg_response_header_send()`
```

--------------------------------

### Copy Built Application to Docker Image Stage

Source: https://civetweb.github.io/civetweb/Docker.html

Copies the compiled CivetWeb application from the build stage to the final runtime image, setting ownership to the civetweb user.

```Dockerfile
COPY --chown=civetweb:civetweb --from=build /app/ /app/
```