civetweb.h File Reference

#include <stddef.h>
#include <stdio.h>

Go to the source code of this file.

Data Structures
struct	mg_header
struct	mg_request_info
struct	mg_response_info
struct	mg_client_cert
struct	mg_callbacks
struct	mg_websocket_subprotocols
struct	mg_option
struct	mg_server_port
struct	mg_form_data_handler
struct	mg_match_element
struct	mg_match_context
struct	mg_client_options
struct	mg_error_data
struct	mg_init_data

Macros
#define	CIVETWEB_VERSION   "1.16"
#define	CIVETWEB_VERSION_MAJOR   (1)
#define	CIVETWEB_VERSION_MINOR   (16)
#define	CIVETWEB_VERSION_PATCH   (0)
#define	CIVETWEB_API
#define	MG_MAX_HEADERS   (64)
#define	mg_server_ports   mg_server_port
#define	PRINTF_FORMAT_STRING(s)   s
#define	PRINTF_ARGS(x, y)
#define	MG_MATCH_CONTEXT_MAX_MATCHES   (32)

Typedefs
typedef int(*	mg_request_handler) (struct mg_connection *conn, void *cbdata)
typedef int(*	mg_websocket_connect_handler) (const struct mg_connection *, void *)
typedef void(*	mg_websocket_ready_handler) (struct mg_connection *, void *)
typedef int(*	mg_websocket_data_handler) (struct mg_connection *, int, char *, size_t, void *)
typedef void(*	mg_websocket_close_handler) (const struct mg_connection *, void *)
typedef int(*	mg_authorization_handler) (struct mg_connection *conn, void *cbdata)
typedef void *(*	mg_thread_func_t) (void *)

Enumerations
enum	{   MG_FEATURES_DEFAULT = 0x0u , MG_FEATURES_FILES = 0x1u , MG_FEATURES_TLS = 0x2u , MG_FEATURES_SSL = 0x2u ,   MG_FEATURES_CGI = 0x4u , MG_FEATURES_IPV6 = 0x8u , MG_FEATURES_WEBSOCKET = 0x10u , MG_FEATURES_LUA = 0x20u ,   MG_FEATURES_SSJS = 0x40u , MG_FEATURES_CACHE = 0x80u , MG_FEATURES_STATS = 0x100u , MG_FEATURES_COMPRESSION = 0x200u ,   MG_FEATURES_HTTP2 = 0x400u , MG_FEATURES_X_DOMAIN_SOCKET = 0x800u , MG_FEATURES_ALL = 0xFFFFu }
enum	{   MG_CONFIG_TYPE_UNKNOWN = 0x0 , MG_CONFIG_TYPE_NUMBER = 0x1 , MG_CONFIG_TYPE_STRING = 0x2 , MG_CONFIG_TYPE_FILE = 0x3 ,   MG_CONFIG_TYPE_DIRECTORY = 0x4 , MG_CONFIG_TYPE_BOOLEAN = 0x5 , MG_CONFIG_TYPE_EXT_PATTERN = 0x6 , MG_CONFIG_TYPE_STRING_LIST = 0x7 ,   MG_CONFIG_TYPE_STRING_MULTILINE = 0x8 , MG_CONFIG_TYPE_YES_NO_OPTIONAL = 0x9 }
enum	{   MG_WEBSOCKET_OPCODE_CONTINUATION = 0x0 , MG_WEBSOCKET_OPCODE_TEXT = 0x1 , MG_WEBSOCKET_OPCODE_BINARY = 0x2 , MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8 ,   MG_WEBSOCKET_OPCODE_PING = 0x9 , MG_WEBSOCKET_OPCODE_PONG = 0xa }
enum	{ MG_FORM_FIELD_STORAGE_SKIP = 0x0 , MG_FORM_FIELD_STORAGE_GET = 0x1 , MG_FORM_FIELD_STORAGE_STORE = 0x2 , MG_FORM_FIELD_STORAGE_ABORT = 0x10 }
enum	{ MG_FORM_FIELD_HANDLE_GET = 0x1 , MG_FORM_FIELD_HANDLE_NEXT = 0x8 , MG_FORM_FIELD_HANDLE_ABORT = 0x10 }
enum	{ MG_TIMEOUT_INFINITE = -1 }
enum	{   MG_ERROR_DATA_CODE_OK = 0u , MG_ERROR_DATA_CODE_INVALID_PARAM = 1u , MG_ERROR_DATA_CODE_INVALID_OPTION = 2u , MG_ERROR_DATA_CODE_INIT_TLS_FAILED = 3u ,   MG_ERROR_DATA_CODE_MISSING_OPTION = 4u , MG_ERROR_DATA_CODE_DUPLICATE_DOMAIN = 5u , MG_ERROR_DATA_CODE_OUT_OF_MEMORY = 6u , MG_ERROR_DATA_CODE_SERVER_STOPPED = 7u ,   MG_ERROR_DATA_CODE_INIT_LIBRARY_FAILED = 8u , MG_ERROR_DATA_CODE_OS_ERROR = 9u , MG_ERROR_DATA_CODE_INIT_PORTS_FAILED = 10u , MG_ERROR_DATA_CODE_INIT_USER_FAILED = 11u ,   MG_ERROR_DATA_CODE_INIT_ACL_FAILED = 12u , MG_ERROR_DATA_CODE_INVALID_PASS_FILE = 13u , MG_ERROR_DATA_CODE_SCRIPT_ERROR = 14u , MG_ERROR_DATA_CODE_HOST_NOT_FOUND = 15u ,   MG_ERROR_DATA_CODE_CONNECT_TIMEOUT = 16u , MG_ERROR_DATA_CODE_CONNECT_FAILED = 17u , MG_ERROR_DATA_CODE_TLS_CLIENT_CERT_ERROR = 18u , MG_ERROR_DATA_CODE_TLS_SERVER_CERT_ERROR = 19u ,   MG_ERROR_DATA_CODE_TLS_CONNECT_ERROR = 20u }

Functions
CIVETWEB_API unsigned	mg_init_library (unsigned features)
CIVETWEB_API unsigned	mg_exit_library (void)
CIVETWEB_API struct mg_context *	mg_start (const struct mg_callbacks *callbacks, void *user_data, const char **configuration_options)
CIVETWEB_API void	mg_stop (struct mg_context *)
CIVETWEB_API int	mg_start_domain (struct mg_context *ctx, const char **configuration_options)
CIVETWEB_API void	mg_set_request_handler (struct mg_context *ctx, const char *uri, mg_request_handler handler, void *cbdata)
CIVETWEB_API void	mg_set_websocket_handler (struct mg_context *ctx, const char *uri, mg_websocket_connect_handler connect_handler, mg_websocket_ready_handler ready_handler, mg_websocket_data_handler data_handler, mg_websocket_close_handler close_handler, void *cbdata)
CIVETWEB_API void	mg_set_websocket_handler_with_subprotocols (struct mg_context *ctx, const char *uri, struct mg_websocket_subprotocols *subprotocols, mg_websocket_connect_handler connect_handler, mg_websocket_ready_handler ready_handler, mg_websocket_data_handler data_handler, mg_websocket_close_handler close_handler, void *cbdata)
CIVETWEB_API void	mg_set_auth_handler (struct mg_context *ctx, const char *uri, mg_authorization_handler handler, void *cbdata)
CIVETWEB_API const char *	mg_get_option (const struct mg_context *ctx, const char *name)
CIVETWEB_API struct mg_context *	mg_get_context (const struct mg_connection *conn)
CIVETWEB_API void *	mg_get_user_data (const struct mg_context *ctx)
CIVETWEB_API void *	mg_get_user_context_data (const struct mg_connection *conn)
CIVETWEB_API void *	mg_get_thread_pointer (const struct mg_connection *conn)
CIVETWEB_API void	mg_set_user_connection_data (const struct mg_connection *conn, void *data)
CIVETWEB_API void *	mg_get_user_connection_data (const struct mg_connection *conn)
CIVETWEB_API int	mg_get_request_link (const struct mg_connection *conn, char *buf, size_t buflen)
CIVETWEB_API const struct mg_option *	mg_get_valid_options (void)
CIVETWEB_API int	mg_get_server_ports (const struct mg_context *ctx, int size, struct mg_server_port *ports)
CIVETWEB_API int	mg_modify_passwords_file (const char *passwords_file_name, const char *realm, const char *user, const char *password)
CIVETWEB_API int	mg_modify_passwords_file_ha1 (const char *passwords_file_name, const char *realm, const char *user, const char *ha1)
CIVETWEB_API const struct mg_request_info *	mg_get_request_info (const struct mg_connection *)
CIVETWEB_API const struct mg_response_info *	mg_get_response_info (const struct mg_connection *)
CIVETWEB_API int	mg_write (struct mg_connection *, const void *buf, size_t len)
CIVETWEB_API int	mg_websocket_write (struct mg_connection *conn, int opcode, const char *data, size_t data_len)
CIVETWEB_API int	mg_websocket_client_write (struct mg_connection *conn, int opcode, const char *data, size_t data_len)
CIVETWEB_API void	mg_lock_connection (struct mg_connection *conn)
CIVETWEB_API void	mg_unlock_connection (struct mg_connection *conn)
CIVETWEB_API void	mg_lock_context (struct mg_context *ctx)
CIVETWEB_API void	mg_unlock_context (struct mg_context *ctx)
CIVETWEB_API int	mg_printf (struct mg_connection *, PRINTF_FORMAT_STRING(const char *fmt),...) PRINTF_ARGS(2
CIVETWEB_API int CIVETWEB_API int	mg_send_chunk (struct mg_connection *conn, const char *chunk, unsigned int chunk_len)
CIVETWEB_API void	mg_send_file (struct mg_connection *conn, const char *path)
CIVETWEB_API int	mg_send_file_body (struct mg_connection *conn, const char *path)
CIVETWEB_API int	mg_send_http_error (struct mg_connection *conn, int status_code, PRINTF_FORMAT_STRING(const char *fmt),...) PRINTF_ARGS(3
CIVETWEB_API int CIVETWEB_API int	mg_send_http_ok (struct mg_connection *conn, const char *mime_type, long long content_length)
CIVETWEB_API int	mg_send_http_redirect (struct mg_connection *conn, const char *target_url, int redirect_code)
CIVETWEB_API int	mg_send_digest_access_authentication_request (struct mg_connection *conn, const char *realm)
CIVETWEB_API int	mg_check_digest_access_authentication (struct mg_connection *conn, const char *realm, const char *filename)
CIVETWEB_API void	mg_send_mime_file (struct mg_connection *conn, const char *path, const char *mime_type)
CIVETWEB_API void	mg_send_mime_file2 (struct mg_connection *conn, const char *path, const char *mime_type, const char *additional_headers)
CIVETWEB_API long long	mg_store_body (struct mg_connection *conn, const char *path)
CIVETWEB_API int	mg_read (struct mg_connection *, void *buf, size_t len)
CIVETWEB_API const char *	mg_get_header (const struct mg_connection *, const char *name)
CIVETWEB_API int	mg_get_var (const char *data, size_t data_len, const char *var_name, char *dst, size_t dst_len)
CIVETWEB_API int	mg_get_var2 (const char *data, size_t data_len, const char *var_name, char *dst, size_t dst_len, size_t occurrence)
CIVETWEB_API int	mg_split_form_urlencoded (char *data, struct mg_header *form_fields, unsigned num_form_fields)
CIVETWEB_API int	mg_get_cookie (const char *cookie, const char *var_name, char *buf, size_t buf_len)
CIVETWEB_API struct mg_connection *	mg_download (const char *host, int port, int use_ssl, char *error_buffer, size_t error_buffer_size, PRINTF_FORMAT_STRING(const char *request_fmt),...) PRINTF_ARGS(6
CIVETWEB_API struct mg_connection CIVETWEB_API void	mg_close_connection (struct mg_connection *conn)
CIVETWEB_API int	mg_handle_form_request (struct mg_connection *conn, struct mg_form_data_handler *fdh)
CIVETWEB_API int	mg_start_thread (mg_thread_func_t f, void *p)
CIVETWEB_API const char *	mg_get_builtin_mime_type (const char *file_name)
CIVETWEB_API const char *	mg_get_response_code_text (const struct mg_connection *conn, int response_code)
CIVETWEB_API const char *	mg_version (void)
CIVETWEB_API int	mg_url_decode (const char *src, int src_len, char *dst, int dst_len, int is_form_url_encoded)
CIVETWEB_API int	mg_url_encode (const char *src, char *dst, size_t dst_len)
CIVETWEB_API int	mg_base64_encode (const unsigned char *src, size_t src_len, char *dst, size_t *dst_len)
CIVETWEB_API int	mg_base64_decode (const char *src, size_t src_len, unsigned char *dst, size_t *dst_len)
CIVETWEB_API char *	mg_md5 (char buf[33],...)
CIVETWEB_API void	mg_cry (const struct mg_connection *conn, PRINTF_FORMAT_STRING(const char *fmt),...) PRINTF_ARGS(2
CIVETWEB_API void CIVETWEB_API int	mg_strcasecmp (const char *s1, const char *s2)
CIVETWEB_API int	mg_strncasecmp (const char *s1, const char *s2, size_t len)
CIVETWEB_API struct mg_connection *	mg_connect_websocket_client (const char *host, int port, int use_ssl, char *error_buffer, size_t error_buffer_size, const char *path, const char *origin, mg_websocket_data_handler data_func, mg_websocket_close_handler close_func, void *user_data)
CIVETWEB_API struct mg_connection *	mg_connect_websocket_client_extensions (const char *host, int port, int use_ssl, char *error_buffer, size_t error_buffer_size, const char *path, const char *origin, const char *extensions, mg_websocket_data_handler data_func, mg_websocket_close_handler close_func, void *user_data)
CIVETWEB_API struct mg_connection *	mg_connect_client (const char *host, int port, int use_ssl, char *error_buffer, size_t error_buffer_size)
CIVETWEB_API struct mg_connection *	mg_connect_client_secure (const struct mg_client_options *client_options, char *error_buffer, size_t error_buffer_size)
CIVETWEB_API struct mg_connection *	mg_connect_websocket_client_secure (const struct mg_client_options *client_options, char *error_buffer, size_t error_buffer_size, const char *path, const char *origin, mg_websocket_data_handler data_func, mg_websocket_close_handler close_func, void *user_data)
CIVETWEB_API struct mg_connection *	mg_connect_websocket_client_secure_extensions (const struct mg_client_options *client_options, char *error_buffer, size_t error_buffer_size, const char *path, const char *origin, const char *extensions, mg_websocket_data_handler data_func, mg_websocket_close_handler close_func, void *user_data)
CIVETWEB_API int	mg_get_response (struct mg_connection *conn, char *ebuf, size_t ebuf_len, int timeout)
CIVETWEB_API int	mg_response_header_start (struct mg_connection *conn, int status)
CIVETWEB_API int	mg_response_header_add (struct mg_connection *conn, const char *header, const char *value, int value_len)
CIVETWEB_API int	mg_response_header_add_lines (struct mg_connection *conn, const char *http1_headers)
CIVETWEB_API int	mg_response_header_send (struct mg_connection *conn)
CIVETWEB_API unsigned	mg_check_feature (unsigned feature)
CIVETWEB_API int	mg_get_system_info (char *buffer, int buflen)
CIVETWEB_API int	mg_get_context_info (const struct mg_context *ctx, char *buffer, int buflen)
CIVETWEB_API void	mg_disable_connection_keep_alive (struct mg_connection *conn)
CIVETWEB_API struct mg_context *	mg_start2 (struct mg_init_data *init, struct mg_error_data *error)
CIVETWEB_API int	mg_start_domain2 (struct mg_context *ctx, const char **configuration_options, struct mg_error_data *error)

Macro Definition Documentation

CIVETWEB_API

#define CIVETWEB_API

Definition at line 43 of file civetweb.h.

Referenced by connect_socket().

CIVETWEB_VERSION

#define CIVETWEB_VERSION   "1.16"

Definition at line 26 of file civetweb.h.

Referenced by mg_version().

CIVETWEB_VERSION_MAJOR

#define CIVETWEB_VERSION_MAJOR   (1)

Definition at line 27 of file civetweb.h.

CIVETWEB_VERSION_MINOR

#define CIVETWEB_VERSION_MINOR   (16)

Definition at line 28 of file civetweb.h.

CIVETWEB_VERSION_PATCH

#define CIVETWEB_VERSION_PATCH   (0)

Definition at line 29 of file civetweb.h.

MG_MATCH_CONTEXT_MAX_MATCHES

#define MG_MATCH_CONTEXT_MAX_MATCHES   (32)

Definition at line 1370 of file civetweb.h.

MG_MAX_HEADERS

#define MG_MAX_HEADERS   (64)

Definition at line 141 of file civetweb.h.

Referenced by parse_http_headers().

mg_server_ports

#define mg_server_ports   mg_server_port

Definition at line 724 of file civetweb.h.

PRINTF_ARGS

#define PRINTF_ARGS	(		x,
			y )

Definition at line 883 of file civetweb.h.

PRINTF_FORMAT_STRING

#define PRINTF_FORMAT_STRING

(

s

)

s

Definition at line 877 of file civetweb.h.

Typedef Documentation

mg_authorization_handler

typedef int(* mg_authorization_handler) (struct mg_connection *conn, void *cbdata)

Definition at line 606 of file civetweb.h.

mg_request_handler

typedef int(* mg_request_handler) (struct mg_connection *conn, void *cbdata)

Definition at line 492 of file civetweb.h.

mg_thread_func_t

typedef void *(* mg_thread_func_t) (void *)

Definition at line 1307 of file civetweb.h.

mg_websocket_close_handler

typedef void(* mg_websocket_close_handler) (const struct mg_connection *, void *)

Definition at line 555 of file civetweb.h.

mg_websocket_connect_handler

typedef int(* mg_websocket_connect_handler) (const struct mg_connection *, void *)

Definition at line 547 of file civetweb.h.

mg_websocket_data_handler

typedef int(* mg_websocket_data_handler) (struct mg_connection *, int, char *, size_t, void *)

Definition at line 550 of file civetweb.h.

mg_websocket_ready_handler

typedef void(* mg_websocket_ready_handler) (struct mg_connection *, void *)

Definition at line 549 of file civetweb.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MG_FORM_FIELD_STORAGE_SKIP
MG_FORM_FIELD_STORAGE_GET
MG_FORM_FIELD_STORAGE_STORE
MG_FORM_FIELD_STORAGE_ABORT

Definition at line 1270 of file civetweb.h.

     {
    /* Skip this field (neither get nor store it). Continue with the
     * next field. */
    MG_FORM_FIELD_STORAGE_SKIP = 0x0,
    /* Get the field value. */
    MG_FORM_FIELD_STORAGE_GET = 0x1,
    /* Store the field value into a file. */
    MG_FORM_FIELD_STORAGE_STORE = 0x2,
    /* Stop parsing this request. Skip the remaining fields. */
    MG_FORM_FIELD_STORAGE_ABORT = 0x10
};

anonymous enum

anonymous enum

Enumerator
MG_FORM_FIELD_HANDLE_GET
MG_FORM_FIELD_HANDLE_NEXT
MG_FORM_FIELD_HANDLE_ABORT

Definition at line 1283 of file civetweb.h.

     {
    /* Only "field_get": If there is more data in this field, get the next
     * chunk. Otherwise: handle the next field. */
    MG_FORM_FIELD_HANDLE_GET = 0x1,
    /* Handle the next field */
    MG_FORM_FIELD_HANDLE_NEXT = 0x8,
    /* Stop parsing this request */
    MG_FORM_FIELD_HANDLE_ABORT = 0x10
};

anonymous enum

anonymous enum

Enumerator
MG_TIMEOUT_INFINITE

Definition at line 1524 of file civetweb.h.

{ MG_TIMEOUT_INFINITE = -1 };

anonymous enum

anonymous enum

Enumerator
MG_ERROR_DATA_CODE_OK
MG_ERROR_DATA_CODE_INVALID_PARAM
MG_ERROR_DATA_CODE_INVALID_OPTION
MG_ERROR_DATA_CODE_INIT_TLS_FAILED
MG_ERROR_DATA_CODE_MISSING_OPTION
MG_ERROR_DATA_CODE_DUPLICATE_DOMAIN
MG_ERROR_DATA_CODE_OUT_OF_MEMORY
MG_ERROR_DATA_CODE_SERVER_STOPPED
MG_ERROR_DATA_CODE_INIT_LIBRARY_FAILED
MG_ERROR_DATA_CODE_OS_ERROR
MG_ERROR_DATA_CODE_INIT_PORTS_FAILED
MG_ERROR_DATA_CODE_INIT_USER_FAILED
MG_ERROR_DATA_CODE_INIT_ACL_FAILED
MG_ERROR_DATA_CODE_INVALID_PASS_FILE
MG_ERROR_DATA_CODE_SCRIPT_ERROR
MG_ERROR_DATA_CODE_HOST_NOT_FOUND
MG_ERROR_DATA_CODE_CONNECT_TIMEOUT
MG_ERROR_DATA_CODE_CONNECT_FAILED
MG_ERROR_DATA_CODE_TLS_CLIENT_CERT_ERROR
MG_ERROR_DATA_CODE_TLS_SERVER_CERT_ERROR
MG_ERROR_DATA_CODE_TLS_CONNECT_ERROR

Definition at line 1732 of file civetweb.h.

     {
    /* No error */
    MG_ERROR_DATA_CODE_OK = 0u,
 
    /* Caller provided invalid parameter */
    MG_ERROR_DATA_CODE_INVALID_PARAM = 1u,
 
    /* "configuration_option" contains invalid element */
    MG_ERROR_DATA_CODE_INVALID_OPTION = 2u,
 
    /* Initializen TLS / SSL library failed */
    MG_ERROR_DATA_CODE_INIT_TLS_FAILED = 3u,
 
    /* Mandatory "configuration_option" missing */
    MG_ERROR_DATA_CODE_MISSING_OPTION = 4u,
 
    /* Duplicate "authentication_domain" option */
    MG_ERROR_DATA_CODE_DUPLICATE_DOMAIN = 5u,
 
    /* Not enough memory */
    MG_ERROR_DATA_CODE_OUT_OF_MEMORY = 6u,
 
    /* Server already stopped */
    MG_ERROR_DATA_CODE_SERVER_STOPPED = 7u,
 
    /* mg_init_library must be called first */
    MG_ERROR_DATA_CODE_INIT_LIBRARY_FAILED = 8u,
 
    /* Operating system function failed */
    MG_ERROR_DATA_CODE_OS_ERROR = 9u,
 
    /* Failed to bind to server ports */
    MG_ERROR_DATA_CODE_INIT_PORTS_FAILED = 10u,
 
    /* Failed to switch user (option "run_as_user") */
    MG_ERROR_DATA_CODE_INIT_USER_FAILED = 11u,
 
    /* Access Control List error */
    MG_ERROR_DATA_CODE_INIT_ACL_FAILED = 12u,
 
    /* Global password file error */
    MG_ERROR_DATA_CODE_INVALID_PASS_FILE = 13u,
 
    /* Lua background script init error */
    MG_ERROR_DATA_CODE_SCRIPT_ERROR = 14u,
 
    /* Client: Host not found, invalid IP to connect */
    MG_ERROR_DATA_CODE_HOST_NOT_FOUND = 15u,
 
    /* Client: TCP connect timeout */
    MG_ERROR_DATA_CODE_CONNECT_TIMEOUT = 16u,
 
    /* Client: TCP connect failed */
    MG_ERROR_DATA_CODE_CONNECT_FAILED = 17u,
 
    /* Error using TLS client certificate */
    MG_ERROR_DATA_CODE_TLS_CLIENT_CERT_ERROR = 18u,
 
    /* Error setting trusted TLS server certificate for client connection */
    MG_ERROR_DATA_CODE_TLS_SERVER_CERT_ERROR = 19u,
 
    /* Error establishing TLS connection to HTTPS server */
    MG_ERROR_DATA_CODE_TLS_CONNECT_ERROR = 20u
};

anonymous enum

anonymous enum

Enumerator
MG_FEATURES_DEFAULT
MG_FEATURES_FILES
MG_FEATURES_TLS
MG_FEATURES_SSL
MG_FEATURES_CGI
MG_FEATURES_IPV6
MG_FEATURES_WEBSOCKET
MG_FEATURES_LUA
MG_FEATURES_SSJS
MG_FEATURES_CACHE
MG_FEATURES_STATS
MG_FEATURES_COMPRESSION
MG_FEATURES_HTTP2
MG_FEATURES_X_DOMAIN_SOCKET
MG_FEATURES_ALL

Definition at line 56 of file civetweb.h.

     {
    MG_FEATURES_DEFAULT = 0x0u,
 
    /* Support files from local directories */
    /* Will only work, if NO_FILES is not set. */
    MG_FEATURES_FILES = 0x1u,
 
    /* Support transport layer security (TLS). */
    /* SSL is still often used synonymously for TLS. */
    /* Will only work, if NO_SSL is not set. */
    MG_FEATURES_TLS = 0x2u,
    MG_FEATURES_SSL = 0x2u,
 
    /* Support common gateway interface (CGI). */
    /* Will only work, if NO_CGI is not set. */
    MG_FEATURES_CGI = 0x4u,
 
    /* Support IPv6. */
    /* Will only work, if USE_IPV6 is set. */
    MG_FEATURES_IPV6 = 0x8u,
 
    /* Support WebSocket protocol. */
    /* Will only work, if USE_WEBSOCKET is set. */
    MG_FEATURES_WEBSOCKET = 0x10u,
 
    /* Support server side Lua scripting. */
    /* Will only work, if USE_LUA is set. */
    MG_FEATURES_LUA = 0x20u,
 
    /* Support server side JavaScript scripting. */
    /* Will only work, if USE_DUKTAPE is set. */
    MG_FEATURES_SSJS = 0x40u,
 
    /* Provide data required for caching files. */
    /* Will only work, if NO_CACHING is not set. */
    MG_FEATURES_CACHE = 0x80u,
 
    /* Collect server status information. */
    /* Will only work, if USE_SERVER_STATS is set. */
    MG_FEATURES_STATS = 0x100u,
 
    /* Support on-the-fly compression. */
    /* Will only work, if USE_ZLIB is set. */
    MG_FEATURES_COMPRESSION = 0x200u,
 
    /* HTTP/2 support enabled. */
    MG_FEATURES_HTTP2 = 0x400u,
 
    /* Support unix domain sockets. */
    MG_FEATURES_X_DOMAIN_SOCKET = 0x800u,
 
    /* Bit mask for all feature defines. */
    MG_FEATURES_ALL = 0xFFFFu
};

anonymous enum

anonymous enum

Enumerator
MG_CONFIG_TYPE_UNKNOWN
MG_CONFIG_TYPE_NUMBER
MG_CONFIG_TYPE_STRING
MG_CONFIG_TYPE_FILE
MG_CONFIG_TYPE_DIRECTORY
MG_CONFIG_TYPE_BOOLEAN
MG_CONFIG_TYPE_EXT_PATTERN
MG_CONFIG_TYPE_STRING_LIST
MG_CONFIG_TYPE_STRING_MULTILINE
MG_CONFIG_TYPE_YES_NO_OPTIONAL

Definition at line 693 of file civetweb.h.

     {
    MG_CONFIG_TYPE_UNKNOWN = 0x0,
    MG_CONFIG_TYPE_NUMBER = 0x1,
    MG_CONFIG_TYPE_STRING = 0x2,
    MG_CONFIG_TYPE_FILE = 0x3,
    MG_CONFIG_TYPE_DIRECTORY = 0x4,
    MG_CONFIG_TYPE_BOOLEAN = 0x5,
    MG_CONFIG_TYPE_EXT_PATTERN = 0x6,
    MG_CONFIG_TYPE_STRING_LIST = 0x7,
    MG_CONFIG_TYPE_STRING_MULTILINE = 0x8,
    MG_CONFIG_TYPE_YES_NO_OPTIONAL = 0x9
};

anonymous enum

anonymous enum

Enumerator
MG_WEBSOCKET_OPCODE_CONTINUATION
MG_WEBSOCKET_OPCODE_TEXT
MG_WEBSOCKET_OPCODE_BINARY
MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE
MG_WEBSOCKET_OPCODE_PING
MG_WEBSOCKET_OPCODE_PONG

Definition at line 857 of file civetweb.h.

     {
    MG_WEBSOCKET_OPCODE_CONTINUATION = 0x0,
    MG_WEBSOCKET_OPCODE_TEXT = 0x1,
    MG_WEBSOCKET_OPCODE_BINARY = 0x2,
    MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8,
    MG_WEBSOCKET_OPCODE_PING = 0x9,
    MG_WEBSOCKET_OPCODE_PONG = 0xa
};

Function Documentation

mg_base64_decode()

CIVETWEB_API int mg_base64_decode	(	const char *	src,
		size_t	src_len,
		unsigned char *	dst,
		size_t *	dst_len )

Definition at line 7383 of file civetweb.c.

{
    size_t i;
    unsigned char a, b, c, d;
    size_t dst_len_limit = (size_t)-1;
    size_t dst_len_used = 0;
 
    if (dst_len != NULL) {
        dst_len_limit = *dst_len;
        *dst_len = 0;
    }
 
    for (i = 0; i < src_len; i += 4) {
        /* Read 4 characters from BASE64 string */
        a = b64reverse(src[i]);
        if (a >= 254) {
            return (int)i;
        }
 
        b = b64reverse(((i + 1) >= src_len) ? 0 : src[i + 1]);
        if (b >= 254) {
            return (int)i + 1;
        }
 
        c = b64reverse(((i + 2) >= src_len) ? 0 : src[i + 2]);
        if (c == 254) {
            return (int)i + 2;
        }
 
        d = b64reverse(((i + 3) >= src_len) ? 0 : src[i + 3]);
        if (d == 254) {
            return (int)i + 3;
        }
 
        /* Add first (of 3) decoded character */
        if (dst_len_used < dst_len_limit) {
            dst[dst_len_used] = (unsigned char)((unsigned char)(a << 2)
                                                + (unsigned char)(b >> 4));
        }
        dst_len_used++;
 
        if (c != 255) {
            if (dst_len_used < dst_len_limit) {
 
                dst[dst_len_used] = (unsigned char)((unsigned char)(b << 4)
                                                    + (unsigned char)(c >> 2));
            }
            dst_len_used++;
            if (d != 255) {
                if (dst_len_used < dst_len_limit) {
                    dst[dst_len_used] =
                        (unsigned char)((unsigned char)(c << 6) + d);
                }
                dst_len_used++;
            }
        }
    }
 
    /* Add terminating zero */
    if (dst_len_used < dst_len_limit) {
        dst[dst_len_used] = '\0';
    }
    dst_len_used++;
    if (dst_len != NULL) {
        *dst_len = dst_len_used;
    }
 
    if (dst_len_used > dst_len_limit) {
        /* Out of memory */
        return 0;
    }
 
    /* Return -1 for "OK" */
    return -1;
}

References b64reverse(), and NULL.

Referenced by parse_auth_header().

mg_base64_encode()

CIVETWEB_API int mg_base64_encode	(	const unsigned char *	src,
		size_t	src_len,
		char *	dst,
		size_t *	dst_len )

Definition at line 7305 of file civetweb.c.

{
    static const char *b64 =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    size_t i, j;
    int a, b, c;
 
    if (dst_len != NULL) {
        /* Expected length including 0 termination: */
        /* IN 1 -> OUT 5, IN 2 -> OUT 5, IN 3 -> OUT 5, IN 4 -> OUT 9,
         * IN 5 -> OUT 9, IN 6 -> OUT 9, IN 7 -> OUT 13, etc. */
        size_t expected_len = ((src_len + 2) / 3) * 4 + 1;
        if (*dst_len < expected_len) {
            if (*dst_len > 0) {
                dst[0] = '\0';
            }
            *dst_len = expected_len;
            return 0;
        }
    }
 
    for (i = j = 0; i < src_len; i += 3) {
        a = src[i];
        b = ((i + 1) >= src_len) ? 0 : src[i + 1];
        c = ((i + 2) >= src_len) ? 0 : src[i + 2];
 
        dst[j++] = b64[a >> 2];
        dst[j++] = b64[((a & 3) << 4) | (b >> 4)];
        if (i + 1 < src_len) {
            dst[j++] = b64[(b & 15) << 2 | (c >> 6)];
        }
        if (i + 2 < src_len) {
            dst[j++] = b64[c & 63];
        }
    }
    while (j % 4 != 0) {
        dst[j++] = '=';
    }
    dst[j++] = '\0';
 
    if (dst_len != NULL) {
        *dst_len = (size_t)j;
    }
 
    /* Return -1 for "OK" */
    return -1;
}

References NULL.

mg_check_digest_access_authentication()

CIVETWEB_API int mg_check_digest_access_authentication	(	struct mg_connection *	conn,
		const char *	realm,
		const char *	filename )

Definition at line 8893 of file civetweb.c.

{
    struct mg_file file = STRUCT_FILE_INITIALIZER;
    int auth;
 
    if (!conn || !filename) {
        return -1;
    }
    if (!mg_fopen(conn, filename, MG_FOPEN_MODE_READ, &file)) {
        return -2;
    }
 
    auth = authorize(conn, &file, realm);
 
    mg_fclose(&file.access);
 
    return auth;
}

References mg_file::access, authorize(), mg_fclose(), mg_fopen(), MG_FOPEN_MODE_READ, and STRUCT_FILE_INITIALIZER.

mg_check_feature()

CIVETWEB_API unsigned mg_check_feature

(

unsigned

feature

)

Definition at line 21430 of file civetweb.c.

{
    static const unsigned feature_set = 0
    /* Set bits for available features according to API documentation.
     * This bit mask is created at compile time, according to the active
     * preprocessor defines. It is a single const value at runtime. */
#if !defined(NO_FILES)
                                        | MG_FEATURES_FILES
#endif
#if !defined(NO_SSL) || defined(USE_MBEDTLS)
                                        | MG_FEATURES_SSL
#endif
#if !defined(NO_CGI)
                                        | MG_FEATURES_CGI
#endif
#if defined(USE_IPV6)
                                        | MG_FEATURES_IPV6
#endif
#if defined(USE_WEBSOCKET)
                                        | MG_FEATURES_WEBSOCKET
#endif
#if defined(USE_LUA)
                                        | MG_FEATURES_LUA
#endif
#if defined(USE_DUKTAPE)
                                        | MG_FEATURES_SSJS
#endif
#if !defined(NO_CACHING)
                                        | MG_FEATURES_CACHE
#endif
#if defined(USE_SERVER_STATS)
                                        | MG_FEATURES_STATS
#endif
#if defined(USE_ZLIB)
                                        | MG_FEATURES_COMPRESSION
#endif
#if defined(USE_HTTP2)
                                        | MG_FEATURES_HTTP2
#endif
#if defined(USE_X_DOM_SOCKET)
                                        | MG_FEATURES_X_DOMAIN_SOCKET
#endif
 
    /* Set some extra bits not defined in the API documentation.
     * These bits may change without further notice. */
#if defined(MG_LEGACY_INTERFACE)
                                        | 0x80000000u
#endif
#if defined(MG_EXPERIMENTAL_INTERFACES)
                                        | 0x40000000u
#endif
#if !defined(NO_RESPONSE_BUFFERING)
                                        | 0x20000000u
#endif
#if defined(MEMORY_DEBUGGING)
                                        | 0x10000000u
#endif
        ;
    return (feature & feature_set);
}

References MG_FEATURES_CACHE, MG_FEATURES_CGI, MG_FEATURES_COMPRESSION, MG_FEATURES_FILES, MG_FEATURES_HTTP2, MG_FEATURES_IPV6, MG_FEATURES_LUA, MG_FEATURES_SSJS, MG_FEATURES_SSL, MG_FEATURES_STATS, MG_FEATURES_WEBSOCKET, and MG_FEATURES_X_DOMAIN_SOCKET.

Referenced by mg_get_system_info(), and mg_init_library().

mg_close_connection()

CIVETWEB_API struct mg_connection CIVETWEB_API void mg_close_connection

(

struct mg_connection *

conn

)

Definition at line 17938 of file civetweb.c.

{
    if ((conn == NULL) || (conn->phys_ctx == NULL)) {
        return;
    }
 
#if defined(USE_WEBSOCKET)
    if (conn->phys_ctx->context_type == CONTEXT_SERVER) {
        if (conn->in_websocket_handling) {
            /* Set close flag, so the server thread can exit. */
            conn->must_close = 1;
            return;
        }
    }
    if (conn->phys_ctx->context_type == CONTEXT_WS_CLIENT) {
 
        unsigned int i;
 
        /* client context: loops must end */
        STOP_FLAG_ASSIGN(&conn->phys_ctx->stop_flag, 1);
        conn->must_close = 1;
 
        /* We need to get the client thread out of the select/recv call
         * here. */
        /* Since we use a sleep quantum of some seconds to check for recv
         * timeouts, we will just wait a few seconds in mg_join_thread. */
 
        /* join worker thread */
        for (i = 0; i < conn->phys_ctx->cfg_worker_threads; i++) {
            mg_join_thread(conn->phys_ctx->worker_threadids[i]);
        }
    }
#endif /* defined(USE_WEBSOCKET) */
 
    close_connection(conn);
 
#if !defined(NO_SSL) && !defined(USE_MBEDTLS) // TODO: mbedTLS client
    if (((conn->phys_ctx->context_type == CONTEXT_HTTP_CLIENT)
         || (conn->phys_ctx->context_type == CONTEXT_WS_CLIENT))
        && (conn->phys_ctx->dd.ssl_ctx != NULL)) {
        SSL_CTX_free(conn->phys_ctx->dd.ssl_ctx);
    }
#endif
 
#if defined(USE_WEBSOCKET)
    if (conn->phys_ctx->context_type == CONTEXT_WS_CLIENT) {
        mg_free(conn->phys_ctx->worker_threadids);
        (void)pthread_mutex_destroy(&conn->mutex);
        mg_free(conn);
    } else if (conn->phys_ctx->context_type == CONTEXT_HTTP_CLIENT) {
        (void)pthread_mutex_destroy(&conn->mutex);
        mg_free(conn);
    }
#else
    if (conn->phys_ctx->context_type == CONTEXT_HTTP_CLIENT) { /* Client */
        (void)pthread_mutex_destroy(&conn->mutex);
        mg_free(conn);
    }
#endif /* defined(USE_WEBSOCKET) */
}

References mg_context::cfg_worker_threads, close_connection(), CONTEXT_HTTP_CLIENT, CONTEXT_SERVER, mg_context::context_type, CONTEXT_WS_CLIENT, mg_context::dd, mg_free(), mg_join_thread(), mg_connection::must_close, mg_connection::mutex, NULL, mg_connection::phys_ctx, mg_domain_context::ssl_ctx, mg_context::stop_flag, STOP_FLAG_ASSIGN, and mg_context::worker_threadids.

Referenced by mg_connect_websocket_client_impl(), mg_download(), and run_client().

mg_connect_client()

CIVETWEB_API struct mg_connection * mg_connect_client	(	const char *	host,
		int	port,
		int	use_ssl,
		char *	error_buffer,
		size_t	error_buffer_size )

Definition at line 18253 of file civetweb.c.

{
    struct mg_client_options opts;
    struct mg_init_data init;
    struct mg_error_data error;
 
    memset(&init, 0, sizeof(init));
 
    memset(&error, 0, sizeof(error));
    error.text_buffer_size = error_buffer_size;
    error.text = error_buffer;
 
    memset(&opts, 0, sizeof(opts));
    opts.host = host;
    opts.port = port;
    if (use_ssl) {
        opts.host_name = host;
    }
 
    return mg_connect_client_impl(&opts, use_ssl, &init, &error);
}

References error(), mg_client_options::host, mg_client_options::host_name, mg_connect_client_impl(), and mg_client_options::port.

Referenced by mg_download(), and run_client().

mg_connect_client_secure()

CIVETWEB_API struct mg_connection * mg_connect_client_secure	(	const struct mg_client_options *	client_options,
		char *	error_buffer,
		size_t	error_buffer_size )

Definition at line 18237 of file civetweb.c.

{
    struct mg_init_data init;
    struct mg_error_data error;
 
    memset(&init, 0, sizeof(init));
    memset(&error, 0, sizeof(error));
    error.text_buffer_size = error_buffer_size;
    error.text = error_buffer;
    return mg_connect_client_impl(client_options, 1, &init, &error);
}

References error(), and mg_connect_client_impl().

mg_connect_websocket_client()

CIVETWEB_API struct mg_connection * mg_connect_websocket_client	(	const char *	host,
		int	port,
		int	use_ssl,
		char *	error_buffer,
		size_t	error_buffer_size,
		const char *	path,
		const char *	origin,
		mg_websocket_data_handler	data_func,
		mg_websocket_close_handler	close_func,
		void *	user_data )

Definition at line 19212 of file civetweb.c.

{
    struct mg_client_options client_options;
    memset(&client_options, 0, sizeof(client_options));
    client_options.host = host;
    client_options.port = port;
 
    return mg_connect_websocket_client_impl(&client_options,
                                            use_ssl,
                                            error_buffer,
                                            error_buffer_size,
                                            path,
                                            origin,
                                            NULL,
                                            data_func,
                                            close_func,
                                            user_data);
}

References close_func(), mg_client_options::host, mg_connect_websocket_client_impl(), NULL, and mg_client_options::port.

mg_connect_websocket_client_extensions()

CIVETWEB_API struct mg_connection * mg_connect_websocket_client_extensions	(	const char *	host,
		int	port,
		int	use_ssl,
		char *	error_buffer,
		size_t	error_buffer_size,
		const char *	path,
		const char *	origin,
		const char *	extensions,
		mg_websocket_data_handler	data_func,
		mg_websocket_close_handler	close_func,
		void *	user_data )

Definition at line 19269 of file civetweb.c.

{
    struct mg_client_options client_options;
    memset(&client_options, 0, sizeof(client_options));
    client_options.host = host;
    client_options.port = port;
 
    return mg_connect_websocket_client_impl(&client_options,
                                            use_ssl,
                                            error_buffer,
                                            error_buffer_size,
                                            path,
                                            origin,
                                            extensions,
                                            data_func,
                                            close_func,
                                            user_data);
}

References close_func(), mg_client_options::host, mg_connect_websocket_client_impl(), and mg_client_options::port.

mg_connect_websocket_client_secure()

CIVETWEB_API struct mg_connection * mg_connect_websocket_client_secure	(	const struct mg_client_options *	client_options,
		char *	error_buffer,
		size_t	error_buffer_size,
		const char *	path,
		const char *	origin,
		mg_websocket_data_handler	data_func,
		mg_websocket_close_handler	close_func,
		void *	user_data )

Definition at line 19242 of file civetweb.c.

{
    if (!client_options) {
        return NULL;
    }
    return mg_connect_websocket_client_impl(client_options,
                                            1,
                                            error_buffer,
                                            error_buffer_size,
                                            path,
                                            origin,
                                            NULL,
                                            data_func,
                                            close_func,
                                            user_data);
}

References close_func(), mg_connect_websocket_client_impl(), and NULL.

mg_connect_websocket_client_secure_extensions()

CIVETWEB_API struct mg_connection * mg_connect_websocket_client_secure_extensions	(	const struct mg_client_options *	client_options,
		char *	error_buffer,
		size_t	error_buffer_size,
		const char *	path,
		const char *	origin,
		const char *	extensions,
		mg_websocket_data_handler	data_func,
		mg_websocket_close_handler	close_func,
		void *	user_data )

Definition at line 19300 of file civetweb.c.

{
    if (!client_options) {
        return NULL;
    }
    return mg_connect_websocket_client_impl(client_options,
                                            1,
                                            error_buffer,
                                            error_buffer_size,
                                            path,
                                            origin,
                                            extensions,
                                            data_func,
                                            close_func,
                                            user_data);
}

References close_func(), mg_connect_websocket_client_impl(), and NULL.

mg_cry()

CIVETWEB_API void mg_cry	(	const struct mg_connection *	conn,
		PRINTF_FORMAT_STRING(const char *fmt)	,
			... )

mg_disable_connection_keep_alive()

CIVETWEB_API void mg_disable_connection_keep_alive

(

struct mg_connection *

conn

)

Definition at line 22042 of file civetweb.c.

{
    /* https://github.com/civetweb/civetweb/issues/727 */
    if (conn != NULL) {
        conn->must_close = 1;
    }
}

References mg_connection::must_close, and NULL.

mg_download()

CIVETWEB_API struct mg_connection * mg_download	(	const char *	host,
		int	port,
		int	use_ssl,
		char *	error_buffer,
		size_t	error_buffer_size,
		PRINTF_FORMAT_STRING(const char *request_fmt)	,
			... )

mg_exit_library()

CIVETWEB_API unsigned mg_exit_library

(

void

)

Definition at line 22477 of file civetweb.c.

{
    if (mg_init_library_called <= 0) {
        return 0;
    }
 
    mg_global_lock();
 
    mg_init_library_called--;
    if (mg_init_library_called == 0) {
#if (defined(OPENSSL_API_1_0) || defined(OPENSSL_API_1_1)) && !defined(NO_SSL)
        if (mg_openssl_initialized) {
            uninitialize_openssl();
            mg_openssl_initialized = 0;
        }
#endif
 
#if defined(_WIN32)
        (void)WSACleanup();
        (void)pthread_mutex_destroy(&global_log_file_lock);
#else
        (void)pthread_mutexattr_destroy(&pthread_mutex_attr);
#endif
 
        (void)pthread_key_delete(sTlsKey);
 
#if defined(USE_LUA)
        lua_exit_optional_libraries();
#endif
        mg_free(all_methods);
        all_methods = NULL;
 
        mg_global_unlock();
        (void)pthread_mutex_destroy(&global_lock_mutex);
        return 1;
    }
 
    mg_global_unlock();
    return 1;
}

References all_methods, global_lock_mutex, mg_free(), mg_global_lock(), mg_global_unlock(), mg_init_library_called, NULL, pthread_mutex_attr, sTlsKey, and uninitialize_openssl().

Referenced by run_client().

mg_get_builtin_mime_type()

CIVETWEB_API const char * mg_get_builtin_mime_type

(

const char *

file_name

)

Definition at line 8332 of file civetweb.c.

{
    const char *ext;
    size_t i, path_len;
 
    path_len = strlen(path);
 
    for (i = 0; builtin_mime_types[i].extension != NULL; i++) {
        ext = path + (path_len - builtin_mime_types[i].ext_len);
        if ((path_len > builtin_mime_types[i].ext_len)
            && (mg_strcasecmp(ext, builtin_mime_types[i].extension) == 0)) {
            return builtin_mime_types[i].mime_type;
        }
    }
 
    return "text/plain";
}

References builtin_mime_types, ext_len, extension, mg_strcasecmp(), and NULL.

Referenced by get_mime_type().

mg_get_context()

CIVETWEB_API struct mg_context * mg_get_context

(

const struct mg_connection *

conn

)

Definition at line 3188 of file civetweb.c.

{
    return (conn == NULL) ? (struct mg_context *)NULL : (conn->phys_ctx);
}

References NULL, and mg_connection::phys_ctx.

Referenced by mg_get_user_context_data().

mg_get_context_info()

CIVETWEB_API int mg_get_context_info	(	const struct mg_context *	ctx,
		char *	buffer,
		int	buflen )

Definition at line 21843 of file civetweb.c.

{
#if defined(USE_SERVER_STATS)
    char *end, *append_eoobj = NULL, block[256];
    size_t context_info_length = 0;
 
#if defined(_WIN32)
    static const char eol[] = "\r\n", eoobj[] = "\r\n}\r\n";
#else
    static const char eol[] = "\n", eoobj[] = "\n}\n";
#endif
    struct mg_memory_stat *ms = get_memory_stat((struct mg_context *)ctx);
 
    if ((buffer == NULL) || (buflen < 1)) {
        buflen = 0;
        end = buffer;
    } else {
        *buffer = 0;
        end = buffer + buflen;
    }
    if (buflen > (int)(sizeof(eoobj) - 1)) {
        /* has enough space to append eoobj */
        append_eoobj = buffer;
        end -= sizeof(eoobj) - 1;
    }
 
    context_info_length += mg_str_append(&buffer, end, "{");
 
    if (ms) { /* <-- should be always true */
              /* Memory information */
        int blockCount = (int)ms->blockCount;
        int64_t totalMemUsed = ms->totalMemUsed;
        int64_t maxMemUsed = ms->maxMemUsed;
        if (totalMemUsed > maxMemUsed) {
            maxMemUsed = totalMemUsed;
        }
 
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    "%s\"memory\" : {%s"
                    "\"blocks\" : %i,%s"
                    "\"used\" : %" INT64_FMT ",%s"
                    "\"maxUsed\" : %" INT64_FMT "%s"
                    "}",
                    eol,
                    eol,
                    blockCount,
                    eol,
                    totalMemUsed,
                    eol,
                    maxMemUsed,
                    eol);
        context_info_length += mg_str_append(&buffer, end, block);
    }
 
    if (ctx) {
        /* Declare all variables at begin of the block, to comply
         * with old C standards. */
        char start_time_str[64] = {0};
        char now_str[64] = {0};
        time_t start_time = ctx->start_time;
        time_t now = time(NULL);
        int64_t total_data_read, total_data_written;
        int active_connections = (int)ctx->active_connections;
        int max_active_connections = (int)ctx->max_active_connections;
        int total_connections = (int)ctx->total_connections;
        if (active_connections > max_active_connections) {
            max_active_connections = active_connections;
        }
        if (active_connections > total_connections) {
            total_connections = active_connections;
        }
 
        /* Connections information */
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"connections\" : {%s"
                    "\"active\" : %i,%s"
                    "\"maxActive\" : %i,%s"
                    "\"total\" : %i%s"
                    "}",
                    eol,
                    eol,
                    active_connections,
                    eol,
                    max_active_connections,
                    eol,
                    total_connections,
                    eol);
        context_info_length += mg_str_append(&buffer, end, block);
 
        /* Queue information */
#if !defined(ALTERNATIVE_QUEUE)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"queue\" : {%s"
                    "\"length\" : %i,%s"
                    "\"filled\" : %i,%s"
                    "\"maxFilled\" : %i,%s"
                    "\"full\" : %s%s"
                    "}",
                    eol,
                    eol,
                    ctx->sq_size,
                    eol,
                    ctx->sq_head - ctx->sq_tail,
                    eol,
                    ctx->sq_max_fill,
                    eol,
                    (ctx->sq_blocked ? "true" : "false"),
                    eol);
        context_info_length += mg_str_append(&buffer, end, block);
#endif
 
        /* Requests information */
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"requests\" : {%s"
                    "\"total\" : %lu%s"
                    "}",
                    eol,
                    eol,
                    (unsigned long)ctx->total_requests,
                    eol);
        context_info_length += mg_str_append(&buffer, end, block);
 
        /* Data information */
        total_data_read =
            mg_atomic_add64((volatile int64_t *)&ctx->total_data_read, 0);
        total_data_written =
            mg_atomic_add64((volatile int64_t *)&ctx->total_data_written, 0);
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"data\" : {%s"
                    "\"read\" : %" INT64_FMT ",%s"
                    "\"written\" : %" INT64_FMT "%s"
                    "}",
                    eol,
                    eol,
                    total_data_read,
                    eol,
                    total_data_written,
                    eol);
        context_info_length += mg_str_append(&buffer, end, block);
 
        /* Execution time information */
        gmt_time_string(start_time_str,
                        sizeof(start_time_str) - 1,
                        &start_time);
        gmt_time_string(now_str, sizeof(now_str) - 1, &now);
 
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"time\" : {%s"
                    "\"uptime\" : %.0f,%s"
                    "\"start\" : \"%s\",%s"
                    "\"now\" : \"%s\"%s"
                    "}",
                    eol,
                    eol,
                    difftime(now, start_time),
                    eol,
                    start_time_str,
                    eol,
                    now_str,
                    eol);
        context_info_length += mg_str_append(&buffer, end, block);
    }
 
    /* Terminate string */
    if (append_eoobj) {
        strcat(append_eoobj, eoobj);
    }
    context_info_length += sizeof(eoobj) - 1;
 
    return (int)context_info_length;
#else
    (void)ctx;
    if ((buffer != NULL) && (buflen > 0)) {
        *buffer = 0;
    }
    return 0;
#endif
}

References block(), gmt_time_string(), INT64_FMT, mg_snprintf(), mg_str_append(), NULL, mg_context::sq_blocked, mg_context::sq_head, mg_context::sq_size, mg_context::sq_tail, and mg_context::start_time.

mg_get_cookie()

CIVETWEB_API int mg_get_cookie	(	const char *	cookie,
		const char *	var_name,
		char *	buf,
		size_t	buf_len )

Definition at line 7256 of file civetweb.c.

{
    const char *s, *p, *end;
    int name_len, len = -1;
 
    if ((dst == NULL) || (dst_size == 0)) {
        return -2;
    }
 
    dst[0] = '\0';
    if ((var_name == NULL) || ((s = cookie_header) == NULL)) {
        return -1;
    }
 
    name_len = (int)strlen(var_name);
    end = s + strlen(s);
    for (; (s = mg_strcasestr(s, var_name)) != NULL; s += name_len) {
        if (s[name_len] == '=') {
            /* HCP24: now check is it a substring or a full cookie name */
            if ((s == cookie_header) || (s[-1] == ' ')) {
                s += name_len + 1;
                if ((p = strchr(s, ' ')) == NULL) {
                    p = end;
                }
                if (p[-1] == ';') {
                    p--;
                }
                if ((*s == '"') && (p[-1] == '"') && (p > s + 1)) {
                    s++;
                    p--;
                }
                if ((size_t)(p - s) < dst_size) {
                    len = (int)(p - s);
                    mg_strlcpy(dst, s, (size_t)len + 1);
                } else {
                    len = -3;
                }
                break;
            }
        }
    }
    return len;
}

References mg_strcasestr(), mg_strlcpy(), NULL, and s.

mg_get_header()

CIVETWEB_API const char * mg_get_header	(	const struct mg_connection *	conn,
		const char *	name )

Definition at line 3855 of file civetweb.c.

{
    if (!conn) {
        return NULL;
    }
 
    if (conn->connection_type == CONNECTION_TYPE_REQUEST) {
        return get_header(conn->request_info.http_headers,
                          conn->request_info.num_headers,
                          name);
    }
    if (conn->connection_type == CONNECTION_TYPE_RESPONSE) {
        return get_header(conn->response_info.http_headers,
                          conn->response_info.num_headers,
                          name);
    }
    return NULL;
}

References mg_connection::connection_type, CONNECTION_TYPE_REQUEST, CONNECTION_TYPE_RESPONSE, get_header(), mg_request_info::http_headers, mg_response_info::http_headers, name, NULL, mg_request_info::num_headers, mg_response_info::num_headers, mg_connection::request_info, and mg_connection::response_info.

Referenced by dav_move_file(), forward_body_data(), handle_propfind(), handle_static_file_request(), header_val(), interpret_uri(), is_not_modified(), parse_auth_header(), prepare_cgi_environment(), put_file(), send_cors_header(), should_keep_alive(), and should_switch_to_protocol().

mg_get_option()

CIVETWEB_API const char * mg_get_option	(	const struct mg_context *	ctx,
		const char *	name )

Definition at line 3173 of file civetweb.c.

{
    int i;
    if ((i = get_option_index(name)) == -1) {
        return NULL;
    } else if (!ctx || ctx->dd.config[i] == NULL) {
        return "";
    } else {
        return ctx->dd.config[i];
    }
}

References mg_domain_context::config, mg_context::dd, get_option_index(), name, and NULL.

mg_get_request_info()

CIVETWEB_API const struct mg_request_info * mg_get_request_info

(

const struct mg_connection *

conn

)

Definition at line 3521 of file civetweb.c.

{
    if (!conn) {
        return NULL;
    }
#if defined(MG_ALLOW_USING_GET_REQUEST_INFO_FOR_RESPONSE)
    if (conn->connection_type == CONNECTION_TYPE_RESPONSE) {
        char txt[16];
        struct mg_workerTLS *tls =
            (struct mg_workerTLS *)pthread_getspecific(sTlsKey);
 
        sprintf(txt, "%03i", conn->response_info.status_code);
        if (strlen(txt) == 3) {
            memcpy(tls->txtbuf, txt, 4);
        } else {
            strcpy(tls->txtbuf, "ERR");
        }
 
        ((struct mg_connection *)conn)->request_info.local_uri =
            tls->txtbuf; /* use thread safe buffer */
        ((struct mg_connection *)conn)->request_info.local_uri_raw =
            tls->txtbuf; /* use the same thread safe buffer */
        ((struct mg_connection *)conn)->request_info.request_uri =
            tls->txtbuf; /* use  the same thread safe buffer */
 
        ((struct mg_connection *)conn)->request_info.num_headers =
            conn->response_info.num_headers;
        memcpy(((struct mg_connection *)conn)->request_info.http_headers,
               conn->response_info.http_headers,
               sizeof(conn->response_info.http_headers));
    } else
#endif
        if (conn->connection_type != CONNECTION_TYPE_REQUEST) {
        return NULL;
    }
    return &conn->request_info;
}

References mg_connection::connection_type, CONNECTION_TYPE_REQUEST, CONNECTION_TYPE_RESPONSE, mg_request_info::http_headers, mg_response_info::http_headers, NULL, mg_response_info::num_headers, mg_connection::request_info, mg_connection::response_info, mg_response_info::status_code, and sTlsKey.

Referenced by get_request_handler(), and user_handler().

mg_get_request_link()

CIVETWEB_API int mg_get_request_link	(	const struct mg_connection *	conn,
		char *	buf,
		size_t	buflen )

Definition at line 3745 of file civetweb.c.

{
    return mg_construct_local_link(conn, buf, buflen, NULL, -1, NULL);
}

References mg_construct_local_link(), and NULL.

Referenced by dav_lock_file(), dav_proppatch(), dav_unlock_file(), and handle_request().

mg_get_response()

CIVETWEB_API int mg_get_response	(	struct mg_connection *	conn,
		char *	ebuf,
		size_t	ebuf_len,
		int	timeout )

Definition at line 18822 of file civetweb.c.

{
    int err, ret;
    char txt[32]; /* will not overflow */
    char *save_timeout;
    char *new_timeout;
 
    if (ebuf_len > 0) {
        ebuf[0] = '\0';
    }
 
    if (!conn) {
        mg_snprintf(conn,
                    NULL, /* No truncation check for ebuf */
                    ebuf,
                    ebuf_len,
                    "%s",
                    "Parameter error");
        return -1;
    }
 
    /* Reset the previous responses */
    conn->data_len = 0;
 
    /* Implementation of API function for HTTP clients */
    save_timeout = conn->dom_ctx->config[REQUEST_TIMEOUT];
 
    if (timeout >= 0) {
        mg_snprintf(conn, NULL, txt, sizeof(txt), "%i", timeout);
        new_timeout = txt;
    } else {
        new_timeout = NULL;
    }
 
    conn->dom_ctx->config[REQUEST_TIMEOUT] = new_timeout;
    ret = get_response(conn, ebuf, ebuf_len, &err);
    conn->dom_ctx->config[REQUEST_TIMEOUT] = save_timeout;
 
    /* TODO: here, the URI is the http response code */
    conn->request_info.local_uri_raw = conn->request_info.request_uri;
    conn->request_info.local_uri = conn->request_info.local_uri_raw;
 
    /* TODO (mid): Define proper return values - maybe return length?
     * For the first test use <0 for error and >0 for OK */
    return (ret == 0) ? -1 : +1;
}

References mg_domain_context::config, mg_connection::data_len, mg_connection::dom_ctx, get_response(), mg_request_info::local_uri, mg_request_info::local_uri_raw, mg_snprintf(), NULL, mg_connection::request_info, REQUEST_TIMEOUT, and mg_request_info::request_uri.

Referenced by run_client().

mg_get_response_code_text()

CIVETWEB_API const char * mg_get_response_code_text	(	const struct mg_connection *	conn,
		int	response_code )

Definition at line 4176 of file civetweb.c.

{
    /* See IANA HTTP status code assignment:
     * http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
     */
 
    switch (response_code) {
        /* RFC2616 Section 10.1 - Informational 1xx */
    case 100:
        return "Continue"; /* RFC2616 Section 10.1.1 */
    case 101:
        return "Switching Protocols"; /* RFC2616 Section 10.1.2 */
    case 102:
        return "Processing"; /* RFC2518 Section 10.1 */
 
        /* RFC2616 Section 10.2 - Successful 2xx */
    case 200:
        return "OK"; /* RFC2616 Section 10.2.1 */
    case 201:
        return "Created"; /* RFC2616 Section 10.2.2 */
    case 202:
        return "Accepted"; /* RFC2616 Section 10.2.3 */
    case 203:
        return "Non-Authoritative Information"; /* RFC2616 Section 10.2.4 */
    case 204:
        return "No Content"; /* RFC2616 Section 10.2.5 */
    case 205:
        return "Reset Content"; /* RFC2616 Section 10.2.6 */
    case 206:
        return "Partial Content"; /* RFC2616 Section 10.2.7 */
    case 207:
        return "Multi-Status"; /* RFC2518 Section 10.2, RFC4918 Section 11.1
                                */
    case 208:
        return "Already Reported"; /* RFC5842 Section 7.1 */
 
    case 226:
        return "IM used"; /* RFC3229 Section 10.4.1 */
 
        /* RFC2616 Section 10.3 - Redirection 3xx */
    case 300:
        return "Multiple Choices"; /* RFC2616 Section 10.3.1 */
    case 301:
        return "Moved Permanently"; /* RFC2616 Section 10.3.2 */
    case 302:
        return "Found"; /* RFC2616 Section 10.3.3 */
    case 303:
        return "See Other"; /* RFC2616 Section 10.3.4 */
    case 304:
        return "Not Modified"; /* RFC2616 Section 10.3.5 */
    case 305:
        return "Use Proxy"; /* RFC2616 Section 10.3.6 */
    case 307:
        return "Temporary Redirect"; /* RFC2616 Section 10.3.8 */
    case 308:
        return "Permanent Redirect"; /* RFC7238 Section 3 */
 
        /* RFC2616 Section 10.4 - Client Error 4xx */
    case 400:
        return "Bad Request"; /* RFC2616 Section 10.4.1 */
    case 401:
        return "Unauthorized"; /* RFC2616 Section 10.4.2 */
    case 402:
        return "Payment Required"; /* RFC2616 Section 10.4.3 */
    case 403:
        return "Forbidden"; /* RFC2616 Section 10.4.4 */
    case 404:
        return "Not Found"; /* RFC2616 Section 10.4.5 */
    case 405:
        return "Method Not Allowed"; /* RFC2616 Section 10.4.6 */
    case 406:
        return "Not Acceptable"; /* RFC2616 Section 10.4.7 */
    case 407:
        return "Proxy Authentication Required"; /* RFC2616 Section 10.4.8 */
    case 408:
        return "Request Time-out"; /* RFC2616 Section 10.4.9 */
    case 409:
        return "Conflict"; /* RFC2616 Section 10.4.10 */
    case 410:
        return "Gone"; /* RFC2616 Section 10.4.11 */
    case 411:
        return "Length Required"; /* RFC2616 Section 10.4.12 */
    case 412:
        return "Precondition Failed"; /* RFC2616 Section 10.4.13 */
    case 413:
        return "Request Entity Too Large"; /* RFC2616 Section 10.4.14 */
    case 414:
        return "Request-URI Too Large"; /* RFC2616 Section 10.4.15 */
    case 415:
        return "Unsupported Media Type"; /* RFC2616 Section 10.4.16 */
    case 416:
        return "Requested range not satisfiable"; /* RFC2616 Section 10.4.17
                                                   */
    case 417:
        return "Expectation Failed"; /* RFC2616 Section 10.4.18 */
 
    case 421:
        return "Misdirected Request"; /* RFC7540 Section 9.1.2 */
    case 422:
        return "Unproccessable entity"; /* RFC2518 Section 10.3, RFC4918
                                         * Section 11.2 */
    case 423:
        return "Locked"; /* RFC2518 Section 10.4, RFC4918 Section 11.3 */
    case 424:
        return "Failed Dependency"; /* RFC2518 Section 10.5, RFC4918
                                     * Section 11.4 */
 
    case 426:
        return "Upgrade Required"; /* RFC 2817 Section 4 */
 
    case 428:
        return "Precondition Required"; /* RFC 6585, Section 3 */
    case 429:
        return "Too Many Requests"; /* RFC 6585, Section 4 */
 
    case 431:
        return "Request Header Fields Too Large"; /* RFC 6585, Section 5 */
 
    case 451:
        return "Unavailable For Legal Reasons"; /* draft-tbray-http-legally-restricted-status-05,
                                                 * Section 3 */
 
        /* RFC2616 Section 10.5 - Server Error 5xx */
    case 500:
        return "Internal Server Error"; /* RFC2616 Section 10.5.1 */
    case 501:
        return "Not Implemented"; /* RFC2616 Section 10.5.2 */
    case 502:
        return "Bad Gateway"; /* RFC2616 Section 10.5.3 */
    case 503:
        return "Service Unavailable"; /* RFC2616 Section 10.5.4 */
    case 504:
        return "Gateway Time-out"; /* RFC2616 Section 10.5.5 */
    case 505:
        return "HTTP Version not supported"; /* RFC2616 Section 10.5.6 */
    case 506:
        return "Variant Also Negotiates"; /* RFC 2295, Section 8.1 */
    case 507:
        return "Insufficient Storage"; /* RFC2518 Section 10.6, RFC4918
                                        * Section 11.5 */
    case 508:
        return "Loop Detected"; /* RFC5842 Section 7.1 */
 
    case 510:
        return "Not Extended"; /* RFC 2774, Section 7 */
    case 511:
        return "Network Authentication Required"; /* RFC 6585, Section 6 */
 
        /* Other status codes, not shown in the IANA HTTP status code
         * assignment.
         * E.g., "de facto" standards due to common use, ... */
    case 418:
        return "I am a teapot"; /* RFC2324 Section 2.3.2 */
    case 419:
        return "Authentication Timeout"; /* common use */
    case 420:
        return "Enhance Your Calm"; /* common use */
    case 440:
        return "Login Timeout"; /* common use */
    case 509:
        return "Bandwidth Limit Exceeded"; /* common use */
 
    default:
        /* This error code is unknown. This should not happen. */
        if (conn) {
            mg_cry_internal(conn,
                            "Unknown HTTP response code: %u",
                            response_code);
        }
 
        /* Return at least a category according to RFC 2616 Section 10. */
        if (response_code >= 100 && response_code < 200) {
            /* Unknown informational status code */
            return "Information";
        }
        if (response_code >= 200 && response_code < 300) {
            /* Unknown success code */
            return "Success";
        }
        if (response_code >= 300 && response_code < 400) {
            /* Unknown redirection code */
            return "Redirection";
        }
        if (response_code >= 400 && response_code < 500) {
            /* Unknown request error code */
            return "Client Error";
        }
        if (response_code >= 500 && response_code < 600) {
            /* Unknown server error code */
            return "Server Error";
        }
 
        /* Response code not even within reasonable range */
        return "";
    }
}

References mg_cry_internal.

Referenced by mg_send_http_error_impl().

mg_get_response_info()

CIVETWEB_API const struct mg_response_info * mg_get_response_info

(

const struct mg_connection *

conn

)

Definition at line 3561 of file civetweb.c.

{
    if (!conn) {
        return NULL;
    }
    if (conn->connection_type != CONNECTION_TYPE_RESPONSE) {
        return NULL;
    }
    return &conn->response_info;
}

References mg_connection::connection_type, CONNECTION_TYPE_RESPONSE, NULL, and mg_connection::response_info.

Referenced by run_client().

mg_get_server_ports()

CIVETWEB_API int mg_get_server_ports	(	const struct mg_context *	ctx,
		int	size,
		struct mg_server_port *	ports )

Definition at line 3248 of file civetweb.c.

{
    int i, cnt = 0;
 
    if (size <= 0) {
        return -1;
    }
    memset(ports, 0, sizeof(*ports) * (size_t)size);
    if (!ctx) {
        return -1;
    }
    if (!ctx->listening_sockets) {
        return -1;
    }
 
    for (i = 0; (i < size) && (i < (int)ctx->num_listening_sockets); i++) {
 
        ports[cnt].port =
            ntohs(USA_IN_PORT_UNSAFE(&(ctx->listening_sockets[i].lsa)));
        ports[cnt].is_ssl = ctx->listening_sockets[i].is_ssl;
        ports[cnt].is_redirect = ctx->listening_sockets[i].ssl_redir;
 
        if (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET) {
            /* IPv4 */
            ports[cnt].protocol = 1;
            cnt++;
        } else if (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET6) {
            /* IPv6 */
            ports[cnt].protocol = 3;
            cnt++;
        }
    }
 
    return cnt;
}

References mg_server_port::is_redirect, socket::is_ssl, mg_server_port::is_ssl, mg_context::listening_sockets, socket::lsa, mg_context::num_listening_sockets, mg_server_port::port, mg_server_port::protocol, usa::sa, socket::ssl_redir, and USA_IN_PORT_UNSAFE.

mg_get_system_info()

CIVETWEB_API int mg_get_system_info	(	char *	buffer,
		int	buflen )

Definition at line 21512 of file civetweb.c.

{
    char *end, *append_eoobj = NULL, block[256];
    size_t system_info_length = 0;
 
#if defined(_WIN32)
    static const char eol[] = "\r\n", eoobj[] = "\r\n}\r\n";
#else
    static const char eol[] = "\n", eoobj[] = "\n}\n";
#endif
 
    if ((buffer == NULL) || (buflen < 1)) {
        buflen = 0;
        end = buffer;
    } else {
        *buffer = 0;
        end = buffer + buflen;
    }
    if (buflen > (int)(sizeof(eoobj) - 1)) {
        /* has enough space to append eoobj */
        append_eoobj = buffer;
        if (end) {
            end -= sizeof(eoobj) - 1;
        }
    }
 
    system_info_length += mg_str_append(&buffer, end, "{");
 
    /* Server version */
    {
        const char *version = mg_version();
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    "%s\"version\" : \"%s\"",
                    eol,
                    version);
        system_info_length += mg_str_append(&buffer, end, block);
    }
 
    /* System info */
    {
#if defined(_WIN32)
        DWORD dwVersion = 0;
        DWORD dwMajorVersion = 0;
        DWORD dwMinorVersion = 0;
        SYSTEM_INFO si;
 
        GetSystemInfo(&si);
 
#if defined(_MSC_VER)
#pragma warning(push)
        /* GetVersion was declared deprecated */
#pragma warning(disable : 4996)
#endif
        dwVersion = GetVersion();
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
 
        dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
        dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
 
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"os\" : \"Windows %u.%u\"",
                    eol,
                    (unsigned)dwMajorVersion,
                    (unsigned)dwMinorVersion);
        system_info_length += mg_str_append(&buffer, end, block);
 
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"cpu\" : \"type %u, cores %u, mask %x\"",
                    eol,
                    (unsigned)si.wProcessorArchitecture,
                    (unsigned)si.dwNumberOfProcessors,
                    (unsigned)si.dwActiveProcessorMask);
        system_info_length += mg_str_append(&buffer, end, block);
#elif defined(__ZEPHYR__)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"os\" : \"%s %s\"",
                    eol,
                    "Zephyr OS",
                    ZEPHYR_VERSION);
        system_info_length += mg_str_append(&buffer, end, block);
#else
        struct utsname name;
        memset(&name, 0, sizeof(name));
        uname(&name);
 
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"os\" : \"%s %s (%s) - %s\"",
                    eol,
                    name.sysname,
                    name.version,
                    name.release,
                    name.machine);
        system_info_length += mg_str_append(&buffer, end, block);
#endif
    }
 
    /* Features */
    {
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"features\" : %lu"
                    ",%s\"feature_list\" : \"Server:%s%s%s%s%s%s%s%s%s\"",
                    eol,
                    (unsigned long)mg_check_feature(0xFFFFFFFFu),
                    eol,
                    mg_check_feature(MG_FEATURES_FILES) ? " Files" : "",
                    mg_check_feature(MG_FEATURES_SSL) ? " HTTPS" : "",
                    mg_check_feature(MG_FEATURES_CGI) ? " CGI" : "",
                    mg_check_feature(MG_FEATURES_IPV6) ? " IPv6" : "",
                    mg_check_feature(MG_FEATURES_WEBSOCKET) ? " WebSockets"
                                                            : "",
                    mg_check_feature(MG_FEATURES_LUA) ? " Lua" : "",
                    mg_check_feature(MG_FEATURES_SSJS) ? " JavaScript" : "",
                    mg_check_feature(MG_FEATURES_CACHE) ? " Cache" : "",
                    mg_check_feature(MG_FEATURES_STATS) ? " Stats" : "");
        system_info_length += mg_str_append(&buffer, end, block);
 
#if defined(USE_LUA)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"lua_version\" : \"%u (%s)\"",
                    eol,
                    (unsigned)LUA_VERSION_NUM,
                    LUA_RELEASE);
        system_info_length += mg_str_append(&buffer, end, block);
#endif
#if defined(USE_DUKTAPE)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"javascript\" : \"Duktape %u.%u.%u\"",
                    eol,
                    (unsigned)DUK_VERSION / 10000,
                    ((unsigned)DUK_VERSION / 100) % 100,
                    (unsigned)DUK_VERSION % 100);
        system_info_length += mg_str_append(&buffer, end, block);
#endif
    }
 
    /* Build identifier. If BUILD_DATE is not set, __DATE__ will be used. */
    {
#if defined(BUILD_DATE)
        const char *bd = BUILD_DATE;
#else
#if defined(GCC_DIAGNOSTIC)
#if GCC_VERSION >= 40900
#pragma GCC diagnostic push
        /* Disable idiotic compiler warning -Wdate-time, appeared in gcc5. This
         * does not work in some versions. If "BUILD_DATE" is defined to some
         * string, it is used instead of __DATE__. */
#pragma GCC diagnostic ignored "-Wdate-time"
#endif
#endif
        const char *bd = __DATE__;
#if defined(GCC_DIAGNOSTIC)
#if GCC_VERSION >= 40900
#pragma GCC diagnostic pop
#endif
#endif
#endif
 
        mg_snprintf(
            NULL, NULL, block, sizeof(block), ",%s\"build\" : \"%s\"", eol, bd);
 
        system_info_length += mg_str_append(&buffer, end, block);
    }
 
    /* Compiler information */
    /* http://sourceforge.net/p/predef/wiki/Compilers/ */
    {
#if defined(_MSC_VER)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"MSC: %u (%u)\"",
                    eol,
                    (unsigned)_MSC_VER,
                    (unsigned)_MSC_FULL_VER);
        system_info_length += mg_str_append(&buffer, end, block);
#elif defined(__MINGW64__)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"MinGW64: %u.%u\"",
                    eol,
                    (unsigned)__MINGW64_VERSION_MAJOR,
                    (unsigned)__MINGW64_VERSION_MINOR);
        system_info_length += mg_str_append(&buffer, end, block);
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"MinGW32: %u.%u\"",
                    eol,
                    (unsigned)__MINGW32_MAJOR_VERSION,
                    (unsigned)__MINGW32_MINOR_VERSION);
        system_info_length += mg_str_append(&buffer, end, block);
#elif defined(__MINGW32__)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"MinGW32: %u.%u\"",
                    eol,
                    (unsigned)__MINGW32_MAJOR_VERSION,
                    (unsigned)__MINGW32_MINOR_VERSION);
        system_info_length += mg_str_append(&buffer, end, block);
#elif defined(__clang__)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"clang: %u.%u.%u (%s)\"",
                    eol,
                    __clang_major__,
                    __clang_minor__,
                    __clang_patchlevel__,
                    __clang_version__);
        system_info_length += mg_str_append(&buffer, end, block);
#elif defined(__GNUC__)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"gcc: %u.%u.%u\"",
                    eol,
                    (unsigned)__GNUC__,
                    (unsigned)__GNUC_MINOR__,
                    (unsigned)__GNUC_PATCHLEVEL__);
        system_info_length += mg_str_append(&buffer, end, block);
#elif defined(__INTEL_COMPILER)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"Intel C/C++: %u\"",
                    eol,
                    (unsigned)__INTEL_COMPILER);
        system_info_length += mg_str_append(&buffer, end, block);
#elif defined(__BORLANDC__)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"Borland C: 0x%x\"",
                    eol,
                    (unsigned)__BORLANDC__);
        system_info_length += mg_str_append(&buffer, end, block);
#elif defined(__SUNPRO_C)
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"Solaris: 0x%x\"",
                    eol,
                    (unsigned)__SUNPRO_C);
        system_info_length += mg_str_append(&buffer, end, block);
#else
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"compiler\" : \"other\"",
                    eol);
        system_info_length += mg_str_append(&buffer, end, block);
#endif
    }
 
    /* Determine 32/64 bit data mode.
     * see https://en.wikipedia.org/wiki/64-bit_computing */
    {
        mg_snprintf(NULL,
                    NULL,
                    block,
                    sizeof(block),
                    ",%s\"data_model\" : \"int:%u/%u/%u/%u, float:%u/%u/%u, "
                    "char:%u/%u, "
                    "ptr:%u, size:%u, time:%u\"",
                    eol,
                    (unsigned)sizeof(short),
                    (unsigned)sizeof(int),
                    (unsigned)sizeof(long),
                    (unsigned)sizeof(long long),
                    (unsigned)sizeof(float),
                    (unsigned)sizeof(double),
                    (unsigned)sizeof(long double),
                    (unsigned)sizeof(char),
                    (unsigned)sizeof(wchar_t),
                    (unsigned)sizeof(void *),
                    (unsigned)sizeof(size_t),
                    (unsigned)sizeof(time_t));
        system_info_length += mg_str_append(&buffer, end, block);
    }
 
    /* Terminate string */
    if (append_eoobj) {
        strcat(append_eoobj, eoobj);
    }
    system_info_length += sizeof(eoobj) - 1;
 
    return (int)system_info_length;
}

References block(), DUK_VERSION, LUA_RELEASE, LUA_VERSION_NUM, mg_check_feature(), MG_FEATURES_CACHE, MG_FEATURES_CGI, MG_FEATURES_FILES, MG_FEATURES_IPV6, MG_FEATURES_LUA, MG_FEATURES_SSJS, MG_FEATURES_SSL, MG_FEATURES_STATS, MG_FEATURES_WEBSOCKET, mg_snprintf(), mg_str_append(), mg_version(), name, and NULL.

Referenced by init_system_info().

mg_get_thread_pointer()

CIVETWEB_API void * mg_get_thread_pointer

(

const struct mg_connection *

conn

)

Definition at line 3209 of file civetweb.c.

{
    /* both methods should return the same pointer */
    if (conn) {
        /* quick access, in case conn is known */
        return conn->tls_user_ptr;
    } else {
        /* otherwise get pointer from thread local storage (TLS) */
        struct mg_workerTLS *tls =
            (struct mg_workerTLS *)pthread_getspecific(sTlsKey);
        return tls->user_ptr;
    }
}

References sTlsKey, mg_connection::tls_user_ptr, and mg_workerTLS::user_ptr.

mg_get_user_connection_data()

CIVETWEB_API void * mg_get_user_connection_data

(

const struct mg_connection *

conn

)

Definition at line 3238 of file civetweb.c.

{
    if (conn != NULL) {
        return conn->request_info.conn_data;
    }
    return NULL;
}

References mg_request_info::conn_data, NULL, and mg_connection::request_info.

mg_get_user_context_data()

CIVETWEB_API void * mg_get_user_context_data

(

const struct mg_connection *

conn

)

Definition at line 3202 of file civetweb.c.

{
    return mg_get_user_data(mg_get_context(conn));
}

References mg_get_context(), and mg_get_user_data().

mg_get_user_data()

CIVETWEB_API void * mg_get_user_data

(

const struct mg_context *

ctx

)

Definition at line 3195 of file civetweb.c.

{
    return (ctx == NULL) ? NULL : ctx->user_data;
}

References NULL, and mg_context::user_data.

Referenced by mg_get_user_context_data().

mg_get_valid_options()

CIVETWEB_API const struct mg_option * mg_get_valid_options

(

void

)

Definition at line 2833 of file civetweb.c.

{
    return config_options;
}

References config_options.

Referenced by set_option(), and show_usage_and_exit().

mg_get_var()

CIVETWEB_API int mg_get_var	(	const char *	data,
		size_t	data_len,
		const char *	var_name,
		char *	dst,
		size_t	dst_len )

Definition at line 7088 of file civetweb.c.

{
    return mg_get_var2(data, data_len, name, dst, dst_len, 0);
}

References mg_get_var2(), and name.

mg_get_var2()

CIVETWEB_API int mg_get_var2	(	const char *	data,
		size_t	data_len,
		const char *	var_name,
		char *	dst,
		size_t	dst_len,
		size_t	occurrence )

Definition at line 7099 of file civetweb.c.

{
    const char *p, *e, *s;
    size_t name_len;
    int len;
 
    if ((dst == NULL) || (dst_len == 0)) {
        len = -2;
    } else if ((data == NULL) || (name == NULL) || (data_len == 0)) {
        len = -1;
        dst[0] = '\0';
    } else {
        name_len = strlen(name);
        e = data + data_len;
        len = -1;
        dst[0] = '\0';
 
        /* data is "var1=val1&var2=val2...". Find variable first */
        for (p = data; p + name_len < e; p++) {
            if (((p == data) || (p[-1] == '&')) && (p[name_len] == '=')
                && !mg_strncasecmp(name, p, name_len) && 0 == occurrence--) {
                /* Point p to variable value */
                p += name_len + 1;
 
                /* Point s to the end of the value */
                s = (const char *)memchr(p, '&', (size_t)(e - p));
                if (s == NULL) {
                    s = e;
                }
                DEBUG_ASSERT(s >= p);
                if (s < p) {
                    return -3;
                }
 
                /* Decode variable into destination buffer */
                len = mg_url_decode(p, (int)(s - p), dst, (int)dst_len, 1);
 
                /* Redirect error code from -1 to -2 (destination buffer too
                 * small). */
                if (len == -1) {
                    len = -2;
                }
                break;
            }
        }
    }
 
    return len;
}

References DEBUG_ASSERT, mg_strncasecmp(), mg_url_decode(), name, NULL, and s.

Referenced by mg_get_var().

mg_handle_form_request()

CIVETWEB_API int mg_handle_form_request	(	struct mg_connection *	conn,
		struct mg_form_data_handler *	fdh )

mg_init_library()

CIVETWEB_API unsigned mg_init_library

(

unsigned

features

)

Definition at line 22347 of file civetweb.c.

{
    unsigned features_to_init = mg_check_feature(features & 0xFFu);
    unsigned features_inited = features_to_init;
 
    if (mg_init_library_called <= 0) {
        /* Not initialized yet */
        if (0 != pthread_mutex_init(&global_lock_mutex, NULL)) {
            return 0;
        }
    }
 
    mg_global_lock();
 
    if (mg_init_library_called <= 0) {
        int i;
        size_t len;
 
#if defined(_WIN32)
        int file_mutex_init = 1;
        int wsa = 1;
#else
        int mutexattr_init = 1;
#endif
        int failed = 1;
        int key_create = pthread_key_create(&sTlsKey, tls_dtor);
 
        if (key_create == 0) {
#if defined(_WIN32)
            file_mutex_init =
                pthread_mutex_init(&global_log_file_lock, &pthread_mutex_attr);
            if (file_mutex_init == 0) {
                /* Start WinSock */
                WSADATA data;
                failed = wsa = WSAStartup(MAKEWORD(2, 2), &data);
            }
#else
            mutexattr_init = pthread_mutexattr_init(&pthread_mutex_attr);
            if (mutexattr_init == 0) {
                failed = pthread_mutexattr_settype(&pthread_mutex_attr,
                                                   PTHREAD_MUTEX_RECURSIVE);
            }
#endif
        }
 
        if (failed) {
#if defined(_WIN32)
            if (wsa == 0) {
                (void)WSACleanup();
            }
            if (file_mutex_init == 0) {
                (void)pthread_mutex_destroy(&global_log_file_lock);
            }
#else
            if (mutexattr_init == 0) {
                (void)pthread_mutexattr_destroy(&pthread_mutex_attr);
            }
#endif
            if (key_create == 0) {
                (void)pthread_key_delete(sTlsKey);
            }
            mg_global_unlock();
            (void)pthread_mutex_destroy(&global_lock_mutex);
            return 0;
        }
 
        len = 1;
        for (i = 0; http_methods[i].name != NULL; i++) {
            size_t sl = strlen(http_methods[i].name);
            len += sl;
            if (i > 0) {
                len += 2;
            }
        }
        all_methods = (char *)mg_malloc(len);
        if (!all_methods) {
            /* Must never happen */
            mg_global_unlock();
            (void)pthread_mutex_destroy(&global_lock_mutex);
            return 0;
        }
        all_methods[0] = 0;
        for (i = 0; http_methods[i].name != NULL; i++) {
            if (i > 0) {
                strcat(all_methods, ", ");
                strcat(all_methods, http_methods[i].name);
            } else {
                strcpy(all_methods, http_methods[i].name);
            }
        }
    }
 
#if defined(USE_LUA)
    lua_init_optional_libraries();
#endif
 
#if (defined(OPENSSL_API_1_0) || defined(OPENSSL_API_1_1)                      \
     || defined(OPENSSL_API_3_0))                                              \
    && !defined(NO_SSL)
 
    if (features_to_init & MG_FEATURES_SSL) {
        if (!mg_openssl_initialized) {
            char ebuf[128];
            if (initialize_openssl(ebuf, sizeof(ebuf))) {
                mg_openssl_initialized = 1;
            } else {
                (void)ebuf;
                DEBUG_TRACE("Initializing SSL failed: %s", ebuf);
                features_inited &= ~((unsigned)(MG_FEATURES_SSL));
            }
        } else {
            /* ssl already initialized */
        }
    }
 
#endif
 
    if (mg_init_library_called <= 0) {
        mg_init_library_called = 1;
    } else {
        mg_init_library_called++;
    }
    mg_global_unlock();
 
    return features_inited;
}

References all_methods, DEBUG_TRACE, global_lock_mutex, http_methods, initialize_openssl(), mg_check_feature(), MG_FEATURES_SSL, mg_global_lock(), mg_global_unlock(), mg_init_library_called, mg_malloc(), mg_http_method_info::name, name, NULL, pthread_mutex_attr, sTlsKey, and tls_dtor().

Referenced by legacy_init(), and run_client().

mg_lock_connection()

CIVETWEB_API void mg_lock_connection

(

struct mg_connection *

conn

)

Definition at line 13000 of file civetweb.c.

{
    if (conn) {
        (void)pthread_mutex_lock(&conn->mutex);
    }
}

References mg_connection::mutex.

Referenced by close_connection().

mg_lock_context()

CIVETWEB_API void mg_lock_context

(

struct mg_context *

ctx

)

Definition at line 13018 of file civetweb.c.

{
    if (ctx && (ctx->context_type == CONTEXT_SERVER)) {
        (void)pthread_mutex_lock(&ctx->nonce_mutex);
    }
}

References CONTEXT_SERVER, mg_context::context_type, and mg_context::nonce_mutex.

Referenced by dav_lock_file(), dav_unlock_file(), get_request_handler(), mg_set_handler_type(), mg_start_domain2(), refresh_trust(), release_handler_ref(), send_authorization_request(), ssl_servername_callback(), sslize(), and switch_domain_context().

mg_md5()

CIVETWEB_API char * mg_md5	(	char	buf[33],
			... )

Definition at line 8404 of file civetweb.c.

{
    md5_byte_t hash[16];
    const char *p;
    va_list ap;
    md5_state_t ctx;
 
    md5_init(&ctx);
 
    va_start(ap, buf);
    while ((p = va_arg(ap, const char *)) != NULL) {
        md5_append(&ctx, (const md5_byte_t *)p, strlen(p));
    }
    va_end(ap);
 
    md5_finish(&ctx, hash);
    bin2str(buf, hash, sizeof(hash));
    return buf;
}

References bin2str(), and NULL.

Referenced by check_password_digest(), dav_lock_file(), mg_modify_passwords_file(), and read_auth_file().

mg_modify_passwords_file()

CIVETWEB_API int mg_modify_passwords_file	(	const char *	passwords_file_name,
		const char *	realm,
		const char *	user,
		const char *	password )

Definition at line 9220 of file civetweb.c.

{
    char ha1buf[33];
    if ((fname == NULL) || (domain == NULL) || (user == NULL)) {
        return 0;
    }
    if ((pass == NULL) || (pass[0] == 0)) {
        return mg_modify_passwords_file_ha1(fname, domain, user, NULL);
    }
 
    mg_md5(ha1buf, user, ":", domain, ":", pass, NULL);
    return mg_modify_passwords_file_ha1(fname, domain, user, ha1buf);
}

References mg_md5(), mg_modify_passwords_file_ha1(), and NULL.

Referenced by start_civetweb().

mg_modify_passwords_file_ha1()

CIVETWEB_API int mg_modify_passwords_file_ha1	(	const char *	passwords_file_name,
		const char *	realm,
		const char *	user,
		const char *	ha1 )

Definition at line 9057 of file civetweb.c.

{
    int found = 0, i, result = 1;
    char line[512], u[256], d[256], h[256];
    struct stat st = {0};
    FILE *fp = NULL;
    char *temp_file = NULL;
    int temp_file_offs = 0;
 
    /* Regard empty password as no password - remove user record. */
    if ((ha1 != NULL) && (ha1[0] == '\0')) {
        ha1 = NULL;
    }
 
    /* Other arguments must not be empty */
    if ((fname == NULL) || (domain == NULL) || (user == NULL)) {
        return 0;
    }
 
    /* Using the given file format, user name and domain must not contain
     * the ':' character */
    if (strchr(user, ':') != NULL) {
        return 0;
    }
    if (strchr(domain, ':') != NULL) {
        return 0;
    }
 
    /* Do not allow control characters like newline in user name and domain.
     * Do not allow excessively long names either. */
    for (i = 0; ((i < 255) && (user[i] != 0)); i++) {
        if (iscntrl((unsigned char)user[i])) {
            return 0;
        }
    }
    if (user[i]) {
        return 0; /* user name too long */
    }
    for (i = 0; ((i < 255) && (domain[i] != 0)); i++) {
        if (iscntrl((unsigned char)domain[i])) {
            return 0;
        }
    }
    if (domain[i]) {
        return 0; /* domain name too long */
    }
 
    /* The maximum length of the path to the password file is limited */
    if (strlen(fname) >= UTF8_PATH_MAX) {
        return 0;
    }
 
    /* Check if the file exists, and get file size */
    if (0 == stat(fname, &st)) {
        int temp_buf_len;
        if (st.st_size > 10485760) {
            /* Some funster provided a >10 MB text file */
            return 0;
        }
 
        /* Add enough space for one more line */
        temp_buf_len = (int)st.st_size + 1024;
 
        /* Allocate memory (instead of using a temporary file) */
        temp_file = (char *)mg_calloc((size_t)temp_buf_len, 1);
        if (!temp_file) {
            /* Out of memory */
            return 0;
        }
 
        /* File exists. Read it into a memory buffer. */
        fp = fopen(fname, "r");
        if (fp == NULL) {
            /* Cannot read file. No permission? */
            mg_free(temp_file);
            return 0;
        }
 
        /* Read content and store in memory */
        while ((fgets(line, sizeof(line), fp) != NULL)
               && ((temp_file_offs + 600) < temp_buf_len)) {
            /* file format is "user:domain:hash\n" */
            if (sscanf(line, "%255[^:]:%255[^:]:%255s", u, d, h) != 3) {
                continue;
            }
            u[255] = 0;
            d[255] = 0;
            h[255] = 0;
 
            if (!strcmp(u, user) && !strcmp(d, domain)) {
                /* Found the user: change the password hash or drop the user
                 */
                if ((ha1 != NULL) && (!found)) {
                    i = sprintf(temp_file + temp_file_offs,
                                "%s:%s:%s\n",
                                user,
                                domain,
                                ha1);
                    if (i < 1) {
                        fclose(fp);
                        mg_free(temp_file);
                        return 0;
                    }
                    temp_file_offs += i;
                }
                found = 1;
            } else {
                /* Copy existing user, including password hash */
                i = sprintf(temp_file + temp_file_offs, "%s:%s:%s\n", u, d, h);
                if (i < 1) {
                    fclose(fp);
                    mg_free(temp_file);
                    return 0;
                }
                temp_file_offs += i;
            }
        }
        fclose(fp);
    }
 
    /* Create new file */
    fp = fopen(fname, "w");
    if (!fp) {
        mg_free(temp_file);
        return 0;
    }
 
#if !defined(_WIN32)
    /* On Linux & co., restrict file read/write permissions to the owner */
    if (fchmod(fileno(fp), S_IRUSR | S_IWUSR) != 0) {
        result = 0;
    }
#endif
 
    if ((temp_file != NULL) && (temp_file_offs > 0)) {
        /* Store buffered content of old file */
        if (fwrite(temp_file, 1, (size_t)temp_file_offs, fp)
            != (size_t)temp_file_offs) {
            result = 0;
        }
    }
 
    /* If new user, just add it */
    if ((ha1 != NULL) && (!found)) {
        if (fprintf(fp, "%s:%s:%s\n", user, domain, ha1) < 6) {
            result = 0;
        }
    }
 
    /* All data written */
    if (fclose(fp) != 0) {
        result = 0;
    }
 
    mg_free(temp_file);
    return result;
}

References fwrite(), mg_calloc(), mg_free(), NULL, and UTF8_PATH_MAX.

Referenced by mg_modify_passwords_file().

mg_printf()

CIVETWEB_API int mg_printf	(	struct mg_connection *	,
		PRINTF_FORMAT_STRING(const char *fmt)	,
			... )

mg_read()

CIVETWEB_API int mg_read	(	struct mg_connection *	conn,
		void *	buf,
		size_t	len )

Definition at line 6614 of file civetweb.c.

{
    if (len > INT_MAX) {
        len = INT_MAX;
    }
 
    if (conn == NULL) {
        return 0;
    }
 
    if (conn->is_chunked) {
        size_t all_read = 0;
 
        while (len > 0) {
            if (conn->is_chunked >= 3) {
                /* No more data left to read */
                return 0;
            }
            if (conn->is_chunked != 1) {
                /* Has error */
                return -1;
            }
 
            if (conn->consumed_content != conn->content_len) {
                /* copy from the current chunk */
                int read_ret = mg_read_inner(conn, (char *)buf + all_read, len);
 
                if (read_ret < 1) {
                    /* read error */
                    conn->is_chunked = 2;
                    return -1;
                }
 
                all_read += (size_t)read_ret;
                len -= (size_t)read_ret;
 
                if (conn->consumed_content == conn->content_len) {
                    /* Add data bytes in the current chunk have been read,
                     * so we are expecting \r\n now. */
                    char x[2];
                    conn->content_len += 2;
                    if ((mg_read_inner(conn, x, 2) != 2) || (x[0] != '\r')
                        || (x[1] != '\n')) {
                        /* Protocol violation */
                        conn->is_chunked = 2;
                        return -1;
                    }
                }
 
            } else {
                /* fetch a new chunk */
                size_t i;
                char lenbuf[64];
                char *end = NULL;
                unsigned long chunkSize = 0;
 
                for (i = 0; i < (sizeof(lenbuf) - 1); i++) {
                    conn->content_len++;
                    if (mg_read_inner(conn, lenbuf + i, 1) != 1) {
                        lenbuf[i] = 0;
                    }
                    if ((i > 0) && (lenbuf[i] == ';')) {
                        // chunk extension --> skip chars until next CR
                        //
                        // RFC 2616, 3.6.1 Chunked Transfer Coding
                        // (https://www.rfc-editor.org/rfc/rfc2616#page-25)
                        //
                        // chunk          = chunk-size [ chunk-extension ] CRLF
                        //                  chunk-data CRLF
                        // ...
                        // chunk-extension= *( ";" chunk-ext-name [ "="
                        // chunk-ext-val ] )
                        do
                            ++conn->content_len;
                        while (mg_read_inner(conn, lenbuf + i, 1) == 1
                               && lenbuf[i] != '\r');
                    }
                    if ((i > 0) && (lenbuf[i] == '\r')
                        && (lenbuf[i - 1] != '\r')) {
                        continue;
                    }
                    if ((i > 1) && (lenbuf[i] == '\n')
                        && (lenbuf[i - 1] == '\r')) {
                        lenbuf[i + 1] = 0;
                        chunkSize = strtoul(lenbuf, &end, 16);
                        if (chunkSize == 0) {
                            /* regular end of content */
                            conn->is_chunked = 3;
                        }
                        break;
                    }
                    if (!isxdigit((unsigned char)lenbuf[i])) {
                        /* illegal character for chunk length */
                        conn->is_chunked = 2;
                        return -1;
                    }
                }
                if ((end == NULL) || (*end != '\r')) {
                    /* chunksize not set correctly */
                    conn->is_chunked = 2;
                    return -1;
                }
                if (conn->is_chunked == 3) {
                    /* try discarding trailer for keep-alive */
 
                    // We found the last chunk (length 0) including the
                    // CRLF that terminates that chunk. Now follows a possibly
                    // empty trailer and a final CRLF.
                    //
                    // see RFC 2616, 3.6.1 Chunked Transfer Coding
                    // (https://www.rfc-editor.org/rfc/rfc2616#page-25)
                    //
                    // Chunked-Body   = *chunk
                    //                  last-chunk
                    //                  trailer
                    //                  CRLF
                    // ...
                    // last-chunk     = 1*("0") [ chunk-extension ] CRLF
                    // ...
                    // trailer        = *(entity-header CRLF)
 
                    int crlf_count = 2; // one CRLF already determined
 
                    while (crlf_count < 4 && conn->is_chunked == 3) {
                        ++conn->content_len;
                        if (mg_read_inner(conn, lenbuf, 1) == 1) {
                            if ((crlf_count == 0 || crlf_count == 2)) {
                                if (lenbuf[0] == '\r')
                                    ++crlf_count;
                                else
                                    crlf_count = 0;
                            } else {
                                // previous character was a CR
                                // --> next character must be LF
 
                                if (lenbuf[0] == '\n')
                                    ++crlf_count;
                                else
                                    conn->is_chunked = 2;
                            }
                        } else
                            // premature end of trailer
                            conn->is_chunked = 2;
                    }
 
                    if (conn->is_chunked == 2)
                        return -1;
                    else
                        conn->is_chunked = 4;
 
                    break;
                }
 
                /* append a new chunk */
                conn->content_len += (int64_t)chunkSize;
            }
        }
 
        return (int)all_read;
    }
    return mg_read_inner(conn, buf, len);
}

References mg_connection::consumed_content, mg_connection::content_len, mg_connection::is_chunked, mg_read_inner(), and NULL.

Referenced by discard_unread_request_data(), forward_body_data(), mg_store_body(), and run_client().

mg_response_header_add()

CIVETWEB_API int mg_response_header_add	(	struct mg_connection *	conn,
		const char *	header,
		const char *	value,
		int	value_len )

Referenced by dav_lock_file(), dav_mkcol(), dav_move_file(), dav_proppatch(), delete_file(), handle_directory_request(), handle_not_modified_static_file_request(), handle_propfind(), handle_ssi_file_request(), handle_static_file_request(), mg_send_http_error_impl(), mg_send_http_ok(), mg_send_http_redirect(), put_file(), send_additional_header(), send_authorization_request(), send_cors_header(), send_no_cache_header(), send_options(), and send_static_cache_header().

mg_response_header_add_lines()

CIVETWEB_API int mg_response_header_add_lines	(	struct mg_connection *	conn,
		const char *	http1_headers )

Referenced by handle_static_file_request(), and send_additional_header().

mg_response_header_send()

CIVETWEB_API int mg_response_header_send

(

struct mg_connection *

conn

)

Referenced by dav_lock_file(), dav_mkcol(), dav_move_file(), dav_proppatch(), dav_unlock_file(), delete_file(), handle_directory_request(), handle_not_modified_static_file_request(), handle_propfind(), handle_ssi_file_request(), handle_static_file_request(), mg_send_http_error_impl(), mg_send_http_ok(), mg_send_http_redirect(), put_file(), send_authorization_request(), and send_options().

mg_response_header_start()

CIVETWEB_API int mg_response_header_start	(	struct mg_connection *	conn,
		int	status )

Referenced by dav_lock_file(), dav_mkcol(), dav_move_file(), dav_proppatch(), dav_unlock_file(), delete_file(), handle_directory_request(), handle_not_modified_static_file_request(), handle_propfind(), handle_ssi_file_request(), handle_static_file_request(), mg_send_http_error_impl(), mg_send_http_ok(), mg_send_http_redirect(), put_file(), send_authorization_request(), and send_options().

mg_send_chunk()

CIVETWEB_API int CIVETWEB_API int mg_send_chunk	(	struct mg_connection *	conn,
		const char *	chunk,
		unsigned int	chunk_len )

Definition at line 6860 of file civetweb.c.

{
    char lenbuf[16];
    size_t lenbuf_len;
    int ret;
    int t;
 
    /* First store the length information in a text buffer. */
    sprintf(lenbuf, "%x\r\n", chunk_len);
    lenbuf_len = strlen(lenbuf);
 
    /* Then send length information, chunk and terminating \r\n. */
    ret = mg_write(conn, lenbuf, lenbuf_len);
    if (ret != (int)lenbuf_len) {
        return -1;
    }
    t = ret;
 
    ret = mg_write(conn, chunk, chunk_len);
    if (ret != (int)chunk_len) {
        return -1;
    }
    t += ret;
 
    ret = mg_write(conn, "\r\n", 2);
    if (ret != 2) {
        return -1;
    }
    t += ret;
 
    return t;
}

References chunk(), and mg_write().

mg_send_digest_access_authentication_request()

CIVETWEB_API int mg_send_digest_access_authentication_request	(	struct mg_connection *	conn,
		const char *	realm )

Definition at line 9022 of file civetweb.c.

{
    if (conn && conn->dom_ctx) {
        send_authorization_request(conn, realm);
        return 0;
    }
    return -1;
}

References mg_connection::dom_ctx, and send_authorization_request().

mg_send_file()

CIVETWEB_API void mg_send_file	(	struct mg_connection *	conn,
		const char *	path )

Definition at line 10510 of file civetweb.c.

{
    mg_send_mime_file2(conn, path, NULL, NULL);
}

References mg_send_mime_file2(), and NULL.

mg_send_file_body()

CIVETWEB_API int mg_send_file_body	(	struct mg_connection *	conn,
		const char *	path )

Definition at line 10451 of file civetweb.c.

{
    struct mg_file file = STRUCT_FILE_INITIALIZER;
    if (!mg_fopen(conn, path, MG_FOPEN_MODE_READ, &file)) {
        return -1;
    }
    fclose_on_exec(&file.access, conn);
    send_file_data(conn, &file, 0, INT64_MAX, 0); /* send static file */
    (void)mg_fclose(&file.access); /* Ignore errors for readonly files */
    return 0;                      /* >= 0 for OK */
}

References mg_file::access, fclose_on_exec(), INT64_MAX, mg_fclose(), mg_fopen(), MG_FOPEN_MODE_READ, send_file_data(), and STRUCT_FILE_INITIALIZER.

mg_send_http_error()

CIVETWEB_API int mg_send_http_error	(	struct mg_connection *	conn,
		int	status_code,
		PRINTF_FORMAT_STRING(const char *fmt)	,
			... )

mg_send_http_ok()

CIVETWEB_API int CIVETWEB_API int mg_send_http_ok	(	struct mg_connection *	conn,
		const char *	mime_type,
		long long	content_length )

Definition at line 4576 of file civetweb.c.

{
    if ((mime_type == NULL) || (*mime_type == 0)) {
        /* No content type defined: default to text/html */
        mime_type = "text/html";
    }
 
    mg_response_header_start(conn, 200);
    send_no_cache_header(conn);
    send_additional_header(conn);
    send_cors_header(conn);
    mg_response_header_add(conn, "Content-Type", mime_type, -1);
    if (content_length < 0) {
        /* Size not known. Use chunked encoding (HTTP/1.x) */
        if (conn->protocol_type == PROTOCOL_TYPE_HTTP1) {
            /* Only HTTP/1.x defines "chunked" encoding, HTTP/2 does not*/
            mg_response_header_add(conn, "Transfer-Encoding", "chunked", -1);
        }
    } else {
        char len[32];
        int trunc = 0;
        mg_snprintf(conn,
                    &trunc,
                    len,
                    sizeof(len),
                    "%" UINT64_FMT,
                    (uint64_t)content_length);
        if (!trunc) {
            /* Since 32 bytes is enough to hold any 64 bit decimal number,
             * !trunc is always true */
            mg_response_header_add(conn, "Content-Length", len, -1);
        }
    }
    mg_response_header_send(conn);
 
    return 0;
}

References mg_response_header_add(), mg_response_header_send(), mg_response_header_start(), mg_snprintf(), mime_type, NULL, mg_connection::protocol_type, PROTOCOL_TYPE_HTTP1, send_additional_header(), send_cors_header(), send_no_cache_header(), and UINT64_FMT.

mg_send_http_redirect()

CIVETWEB_API int mg_send_http_redirect	(	struct mg_connection *	conn,
		const char *	target_url,
		int	redirect_code )

Definition at line 4618 of file civetweb.c.

{
    /* Send a 30x redirect response.
     *
     * Redirect types (status codes):
     *
     * Status | Perm/Temp | Method              | Version
     *   301  | permanent | POST->GET undefined | HTTP/1.0
     *   302  | temporary | POST->GET undefined | HTTP/1.0
     *   303  | temporary | always use GET      | HTTP/1.1
     *   307  | temporary | always keep method  | HTTP/1.1
     *   308  | permanent | always keep method  | HTTP/1.1
     */
 
#if defined(MG_SEND_REDIRECT_BODY)
    char redirect_body[MG_BUF_LEN];
    size_t content_len = 0;
    char content_len_text[32];
#endif
 
    /* In case redirect_code=0, use 307. */
    if (redirect_code == 0) {
        redirect_code = 307;
    }
 
    /* In case redirect_code is none of the above, return error. */
    if ((redirect_code != 301) && (redirect_code != 302)
        && (redirect_code != 303) && (redirect_code != 307)
        && (redirect_code != 308)) {
        /* Parameter error */
        return -2;
    }
 
    /* If target_url is not defined, redirect to "/". */
    if ((target_url == NULL) || (*target_url == 0)) {
        target_url = "/";
    }
 
#if defined(MG_SEND_REDIRECT_BODY)
    /* TODO: condition name? */
 
    /* Prepare a response body with a hyperlink.
     *
     * According to RFC2616 (and RFC1945 before):
     * Unless the request method was HEAD, the entity of the
     * response SHOULD contain a short hypertext note with a hyperlink to
     * the new URI(s).
     *
     * However, this response body is not useful in M2M communication.
     * Probably the original reason in the RFC was, clients not supporting
     * a 30x HTTP redirect could still show the HTML page and let the user
     * press the link. Since current browsers support 30x HTTP, the additional
     * HTML body does not seem to make sense anymore.
     *
     * The new RFC7231 (Section 6.4) does no longer recommend it ("SHOULD"),
     * but it only notes:
     * The server's response payload usually contains a short
     * hypertext note with a hyperlink to the new URI(s).
     *
     * Deactivated by default. If you need the 30x body, set the define.
     */
    mg_snprintf(
        conn,
        NULL /* ignore truncation */,
        redirect_body,
        sizeof(redirect_body),
        "<html><head>%s</head><body><a href=\"%s\">%s</a></body></html>",
        redirect_text,
        target_url,
        target_url);
    content_len = strlen(reply);
    sprintf(content_len_text, "%lu", (unsigned long)content_len);
#endif
 
    /* Send all required headers */
    mg_response_header_start(conn, redirect_code);
    mg_response_header_add(conn, "Location", target_url, -1);
    if ((redirect_code == 301) || (redirect_code == 308)) {
        /* Permanent redirect */
        send_static_cache_header(conn);
    } else {
        /* Temporary redirect */
        send_no_cache_header(conn);
    }
    send_additional_header(conn);
    send_cors_header(conn);
#if defined(MG_SEND_REDIRECT_BODY)
    mg_response_header_add(conn, "Content-Type", "text/html", -1);
    mg_response_header_add(conn, "Content-Length", content_len_text, -1);
#else
    mg_response_header_add(conn, "Content-Length", "0", 1);
#endif
    mg_response_header_send(conn);
 
#if defined(MG_SEND_REDIRECT_BODY)
    /* Send response body */
    /* ... unless it is a HEAD request */
    if (0 != strcmp(conn->request_info.request_method, "HEAD")) {
        ret = mg_write(conn, redirect_body, content_len);
    }
#endif
 
    return 1;
}

References MG_BUF_LEN, mg_response_header_add(), mg_response_header_send(), mg_response_header_start(), mg_snprintf(), mg_write(), NULL, mg_connection::request_info, mg_request_info::request_method, send_additional_header(), send_cors_header(), send_no_cache_header(), and send_static_cache_header().

Referenced by handle_request(), and redirect_to_https_port().

mg_send_mime_file()

CIVETWEB_API void mg_send_mime_file	(	struct mg_connection *	conn,
		const char *	path,
		const char *	mime_type )

Definition at line 10517 of file civetweb.c.

{
    mg_send_mime_file2(conn, path, mime_type, NULL);
}

References mg_send_mime_file2(), mime_type, and NULL.

mg_send_mime_file2()

CIVETWEB_API void mg_send_mime_file2	(	struct mg_connection *	conn,
		const char *	path,
		const char *	mime_type,
		const char *	additional_headers )

Definition at line 10526 of file civetweb.c.

{
    struct mg_file file = STRUCT_FILE_INITIALIZER;
 
    if (!conn) {
        /* No conn */
        return;
    }
 
    if (mg_stat(conn, path, &file.stat)) {
#if !defined(NO_CACHING)
        if (is_not_modified(conn, &file.stat)) {
            /* Send 304 "Not Modified" - this must not send any body data */
            handle_not_modified_static_file_request(conn, &file);
        } else
#endif /* NO_CACHING */
            if (file.stat.is_directory) {
            if (!mg_strcasecmp(conn->dom_ctx->config[ENABLE_DIRECTORY_LISTING],
                               "yes")) {
                handle_directory_request(conn, path);
            } else {
                mg_send_http_error(conn,
                                   403,
                                   "%s",
                                   "Error: Directory listing denied");
            }
        } else {
            handle_static_file_request(
                conn, path, &file, mime_type, additional_headers);
        }
    } else {
        mg_send_http_error(conn, 404, "%s", "Error: File not found");
    }
}

References mg_domain_context::config, mg_connection::dom_ctx, ENABLE_DIRECTORY_LISTING, handle_directory_request(), handle_not_modified_static_file_request(), handle_static_file_request(), mg_file_stat::is_directory, is_not_modified(), mg_send_http_error(), mg_stat(), mg_strcasecmp(), mime_type, mg_file::stat, and STRUCT_FILE_INITIALIZER.

Referenced by mg_send_file(), and mg_send_mime_file().

mg_set_auth_handler()

CIVETWEB_API void mg_set_auth_handler	(	struct mg_context *	ctx,
		const char *	uri,
		mg_authorization_handler	handler,
		void *	cbdata )

Definition at line 14538 of file civetweb.c.

{
    mg_set_handler_type(ctx,
                        &(ctx->dd),
                        uri,
                        AUTH_HANDLER,
                        handler == NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        handler,
                        cbdata);
}

References AUTH_HANDLER, mg_handler_info::cbdata, mg_context::dd, mg_handler_info::handler, mg_set_handler_type(), NULL, and mg_handler_info::uri.

mg_set_request_handler()

CIVETWEB_API void mg_set_request_handler	(	struct mg_context *	ctx,
		const char *	uri,
		mg_request_handler	handler,
		void *	cbdata )

Definition at line 14466 of file civetweb.c.

{
    mg_set_handler_type(ctx,
                        &(ctx->dd),
                        uri,
                        REQUEST_HANDLER,
                        handler == NULL,
                        handler,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        cbdata);
}

References mg_handler_info::cbdata, mg_context::dd, mg_handler_info::handler, mg_set_handler_type(), NULL, REQUEST_HANDLER, and mg_handler_info::uri.

Referenced by start_http_server().

mg_set_user_connection_data()

CIVETWEB_API void mg_set_user_connection_data	(	const struct mg_connection *	conn,
		void *	data )

Definition at line 3225 of file civetweb.c.

{
    if (const_conn != NULL) {
        /* Const cast, since "const struct mg_connection *" does not mean
         * the connection object is not modified. Here "const" is used,
         * to indicate mg_read/mg_write/mg_send/.. must not be called. */
        struct mg_connection *conn = (struct mg_connection *)const_conn;
        conn->request_info.conn_data = data;
    }
}

References mg_request_info::conn_data, NULL, and mg_connection::request_info.

Referenced by close_connection(), and init_connection().

mg_set_websocket_handler()

CIVETWEB_API void mg_set_websocket_handler	(	struct mg_context *	ctx,
		const char *	uri,
		mg_websocket_connect_handler	connect_handler,
		mg_websocket_ready_handler	ready_handler,
		mg_websocket_data_handler	data_handler,
		mg_websocket_close_handler	close_handler,
		void *	cbdata )

Definition at line 14488 of file civetweb.c.

{
    mg_set_websocket_handler_with_subprotocols(ctx,
                                               uri,
                                               NULL,
                                               connect_handler,
                                               ready_handler,
                                               data_handler,
                                               close_handler,
                                               cbdata);
}

References mg_handler_info::cbdata, mg_handler_info::close_handler, mg_handler_info::connect_handler, mg_handler_info::data_handler, mg_set_websocket_handler_with_subprotocols(), NULL, mg_handler_info::ready_handler, and mg_handler_info::uri.

mg_set_websocket_handler_with_subprotocols()

CIVETWEB_API void mg_set_websocket_handler_with_subprotocols	(	struct mg_context *	ctx,
		const char *	uri,
		struct mg_websocket_subprotocols *	subprotocols,
		mg_websocket_connect_handler	connect_handler,
		mg_websocket_ready_handler	ready_handler,
		mg_websocket_data_handler	data_handler,
		mg_websocket_close_handler	close_handler,
		void *	cbdata )

Definition at line 14508 of file civetweb.c.

{
    int is_delete_request = (connect_handler == NULL) && (ready_handler == NULL)
                            && (data_handler == NULL)
                            && (close_handler == NULL);
    mg_set_handler_type(ctx,
                        &(ctx->dd),
                        uri,
                        WEBSOCKET_HANDLER,
                        is_delete_request,
                        NULL,
                        subprotocols,
                        connect_handler,
                        ready_handler,
                        data_handler,
                        close_handler,
                        NULL,
                        cbdata);
}

References mg_handler_info::cbdata, mg_handler_info::close_handler, mg_handler_info::connect_handler, mg_handler_info::data_handler, mg_context::dd, mg_set_handler_type(), NULL, mg_handler_info::ready_handler, mg_handler_info::subprotocols, mg_handler_info::uri, and WEBSOCKET_HANDLER.

Referenced by mg_set_websocket_handler().

mg_split_form_urlencoded()

CIVETWEB_API int mg_split_form_urlencoded	(	char *	data,
		struct mg_header *	form_fields,
		unsigned	num_form_fields )

Definition at line 7157 of file civetweb.c.

{
    char *b;
    int i;
    int num = 0;
 
    if (data == NULL) {
        /* parameter error */
        return -1;
    }
 
    if ((form_fields == NULL) && (num_form_fields == 0)) {
        /* determine the number of expected fields */
        if (data[0] == 0) {
            return 0;
        }
        /* count number of & to return the number of key-value-pairs */
        num = 1;
        while (*data) {
            if (*data == '&') {
                num++;
            }
            data++;
        }
        return num;
    }
 
    if ((form_fields == NULL) || ((int)num_form_fields <= 0)) {
        /* parameter error */
        return -1;
    }
 
    for (i = 0; i < (int)num_form_fields; i++) {
        /* extract key-value pairs from input data */
        while ((*data == ' ') || (*data == '\t')) {
            /* skip initial spaces */
            data++;
        }
        if (*data == 0) {
            /* end of string reached */
            break;
        }
        form_fields[num].name = data;
 
        /* find & or = */
        b = data;
        while ((*b != 0) && (*b != '&') && (*b != '=')) {
            b++;
        }
 
        if (*b == 0) {
            /* last key without value */
            form_fields[num].value = NULL;
        } else if (*b == '&') {
            /* mid key without value */
            form_fields[num].value = NULL;
        } else {
            /* terminate string */
            *b = 0;
            /* value starts after '=' */
            data = b + 1;
            form_fields[num].value = data;
        }
 
        /* new field is stored */
        num++;
 
        /* find a next key */
        b = strchr(data, '&');
        if (b == 0) {
            /* no more data */
            break;
        } else {
            /* terminate value of last field at '&' */
            *b = 0;
            /* next key-value-pairs starts after '&' */
            data = b + 1;
        }
    }
 
    /* Decode all values */
    for (i = 0; i < num; i++) {
        if (form_fields[i].name) {
            url_decode_in_place((char *)form_fields[i].name);
        }
        if (form_fields[i].value) {
            url_decode_in_place((char *)form_fields[i].value);
        }
    }
 
    /* return number of fields found */
    return num;
}

References mg_header::name, name, NULL, url_decode_in_place(), mg_header::value, and value.

mg_start()

CIVETWEB_API struct mg_context * mg_start	(	const struct mg_callbacks *	callbacks,
		void *	user_data,
		const char **	configuration_options )

Definition at line 21205 of file civetweb.c.

{
    struct mg_init_data init = {0};
    init.callbacks = callbacks;
    init.user_data = user_data;
    init.configuration_options = options;
 
    return mg_start2(&init, NULL);
}

References mg_init_data::callbacks, mg_init_data::configuration_options, mg_start2(), NULL, and mg_init_data::user_data.

Referenced by start_http_server().

mg_start2()

CIVETWEB_API struct mg_context * mg_start2	(	struct mg_init_data *	init,
		struct mg_error_data *	error )

Definition at line 20464 of file civetweb.c.

{
    struct mg_context *ctx;
    const char *name, *value, *default_value;
    int idx, ok, workerthreadcount;
    unsigned int i;
    int itmp;
    void (*exit_callback)(const struct mg_context *ctx) = 0;
    const char **options =
        ((init != NULL) ? (init->configuration_options) : (NULL));
 
    struct mg_workerTLS tls;
 
    if (error != NULL) {
        error->code = MG_ERROR_DATA_CODE_OK;
        error->code_sub = 0;
        if (error->text_buffer_size > 0) {
            *error->text = 0;
        }
    }
 
    if (mg_init_library_called == 0) {
        /* Legacy INIT, if mg_start is called without mg_init_library.
         * Note: This will cause a memory leak when unloading the library.
         */
        legacy_init(options);
    }
    if (mg_init_library_called == 0) {
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INIT_LIBRARY_FAILED;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        "Library uninitialized");
        }
        return NULL;
    }
 
    /* Allocate context and initialize reasonable general case defaults. */
    ctx = (struct mg_context *)mg_calloc(1, sizeof(*ctx));
    if (ctx == NULL) {
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_OUT_OF_MEMORY;
            error->code_sub = (unsigned)sizeof(*ctx);
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        "Out of memory");
        }
        return NULL;
    }
 
    /* Random number generator will initialize at the first call */
    ctx->dd.auth_nonce_mask =
        (uint64_t)get_random() ^ (uint64_t)(ptrdiff_t)(options);
 
    /* Save started thread index to reuse in other external API calls
     * For the sake of thread synchronization all non-civetweb threads
     * can be considered as single external thread */
    ctx->starter_thread_idx = (unsigned)mg_atomic_inc(&thread_idx_max);
    tls.is_master = -1; /* Thread calling mg_start */
    tls.thread_idx = ctx->starter_thread_idx;
#if defined(_WIN32)
    tls.pthread_cond_helper_mutex = NULL;
#endif
    pthread_setspecific(sTlsKey, &tls);
 
    ok = (0 == pthread_mutex_init(&ctx->thread_mutex, &pthread_mutex_attr));
#if !defined(ALTERNATIVE_QUEUE)
    ok &= (0 == pthread_cond_init(&ctx->sq_empty, NULL));
    ok &= (0 == pthread_cond_init(&ctx->sq_full, NULL));
    ctx->sq_blocked = 0;
#endif
    ok &= (0 == pthread_mutex_init(&ctx->nonce_mutex, &pthread_mutex_attr));
#if defined(USE_LUA)
    ok &= (0 == pthread_mutex_init(&ctx->lua_bg_mutex, &pthread_mutex_attr));
#endif
    if (!ok) {
        unsigned error_id = (unsigned)ERRNO;
        const char *err_msg =
            "Cannot initialize thread synchronization objects";
        /* Fatal error - abort start. However, this situation should never
         * occur in practice. */
 
        mg_cry_ctx_internal(ctx, "%s", err_msg);
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_OS_ERROR;
            error->code_sub = error_id;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        mg_free(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
 
    if ((init != NULL) && (init->callbacks != NULL)) {
        /* Set all callbacks except exit_context. */
        ctx->callbacks = *init->callbacks;
        exit_callback = init->callbacks->exit_context;
        /* The exit callback is activated once the context is successfully
         * created. It should not be called, if an incomplete context object
         * is deleted during a failed initialization. */
        ctx->callbacks.exit_context = 0;
    }
    ctx->user_data = ((init != NULL) ? (init->user_data) : (NULL));
    ctx->dd.handlers = NULL;
    ctx->dd.next = NULL;
 
#if defined(USE_LUA)
    lua_ctx_init(ctx);
#endif
 
    /* Store options */
    while (options && (name = *options++) != NULL) {
        idx = get_option_index(name);
        if (idx == -1) {
            mg_cry_ctx_internal(ctx, "Invalid option: %s", name);
            if (error != NULL) {
                error->code = MG_ERROR_DATA_CODE_INVALID_OPTION;
                error->code_sub = (unsigned)-1;
                mg_snprintf(NULL,
                            NULL, /* No truncation check for error buffers */
                            error->text,
                            error->text_buffer_size,
                            "Invalid configuration option: %s",
                            name);
            }
 
            free_context(ctx);
            pthread_setspecific(sTlsKey, NULL);
            return NULL;
 
        } else if ((value = *options++) == NULL) {
            mg_cry_ctx_internal(ctx, "%s: option value cannot be NULL", name);
            if (error != NULL) {
                error->code = MG_ERROR_DATA_CODE_INVALID_OPTION;
                error->code_sub = (unsigned)idx;
                mg_snprintf(NULL,
                            NULL, /* No truncation check for error buffers */
                            error->text,
                            error->text_buffer_size,
                            "Invalid configuration option value: %s",
                            name);
            }
 
            free_context(ctx);
            pthread_setspecific(sTlsKey, NULL);
            return NULL;
        }
        if (ctx->dd.config[idx] != NULL) {
            /* A duplicate configuration option is not an error - the last
             * option value will be used. */
            mg_cry_ctx_internal(ctx, "warning: %s: duplicate option", name);
            mg_free(ctx->dd.config[idx]);
        }
        ctx->dd.config[idx] = mg_strdup_ctx(value, ctx);
        DEBUG_TRACE("[%s] -> [%s]", name, value);
    }
 
    /* Set default value if needed */
    for (i = 0; config_options[i].name != NULL; i++) {
        default_value = config_options[i].default_value;
        if ((ctx->dd.config[i] == NULL) && (default_value != NULL)) {
            ctx->dd.config[i] = mg_strdup_ctx(default_value, ctx);
        }
    }
 
    /* Request size option */
    itmp = atoi(ctx->dd.config[MAX_REQUEST_SIZE]);
    if (itmp < 1024) {
        mg_cry_ctx_internal(ctx,
                            "%s too small",
                            config_options[MAX_REQUEST_SIZE].name);
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INVALID_OPTION;
            error->code_sub = (unsigned)MAX_REQUEST_SIZE;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "Invalid configuration option value: %s",
                        config_options[MAX_REQUEST_SIZE].name);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
    ctx->max_request_size = (unsigned)itmp;
 
    /* Queue length */
#if !defined(ALTERNATIVE_QUEUE)
    itmp = atoi(ctx->dd.config[CONNECTION_QUEUE_SIZE]);
    if (itmp < 1) {
        mg_cry_ctx_internal(ctx,
                            "%s too small",
                            config_options[CONNECTION_QUEUE_SIZE].name);
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INVALID_OPTION;
            error->code_sub = CONNECTION_QUEUE_SIZE;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "Invalid configuration option value: %s",
                        config_options[CONNECTION_QUEUE_SIZE].name);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
    ctx->squeue =
        (struct socket *)mg_calloc((unsigned int)itmp, sizeof(struct socket));
    if (ctx->squeue == NULL) {
        mg_cry_ctx_internal(ctx,
                            "Out of memory: Cannot allocate %s",
                            config_options[CONNECTION_QUEUE_SIZE].name);
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_OUT_OF_MEMORY;
            error->code_sub = (unsigned)itmp * (unsigned)sizeof(struct socket);
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "Out of memory: Cannot allocate %s",
                        config_options[CONNECTION_QUEUE_SIZE].name);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
    ctx->sq_size = itmp;
#endif
 
    /* Worker thread count option */
    workerthreadcount = atoi(ctx->dd.config[NUM_THREADS]);
 
    if ((workerthreadcount > MAX_WORKER_THREADS) || (workerthreadcount <= 0)) {
        if (workerthreadcount <= 0) {
            mg_cry_ctx_internal(ctx, "%s", "Invalid number of worker threads");
        } else {
            mg_cry_ctx_internal(ctx, "%s", "Too many worker threads");
        }
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INVALID_OPTION;
            error->code_sub = NUM_THREADS;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "Invalid configuration option value: %s",
                        config_options[NUM_THREADS].name);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
 
    /* Document root */
#if defined(NO_FILES)
    if (ctx->dd.config[DOCUMENT_ROOT] != NULL) {
        mg_cry_ctx_internal(ctx, "%s", "Document root must not be set");
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INVALID_OPTION;
            error->code_sub = (unsigned)DOCUMENT_ROOT;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "Invalid configuration option value: %s",
                        config_options[DOCUMENT_ROOT].name);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
#endif
 
    get_system_name(&ctx->systemName);
 
#if defined(USE_LUA)
    /* If a Lua background script has been configured, start it. */
    ctx->lua_bg_log_available = 0;
    if (ctx->dd.config[LUA_BACKGROUND_SCRIPT] != NULL) {
        char ebuf[256];
        struct vec opt_vec;
        struct vec eq_vec;
        const char *sparams;
 
        memset(ebuf, 0, sizeof(ebuf));
        pthread_mutex_lock(&ctx->lua_bg_mutex);
 
        /* Create a Lua state, load all standard libraries and the mg table */
        lua_State *state = mg_lua_context_script_prepare(
            ctx->dd.config[LUA_BACKGROUND_SCRIPT], ctx, ebuf, sizeof(ebuf));
        if (!state) {
            mg_cry_ctx_internal(ctx,
                                "lua_background_script load error: %s",
                                ebuf);
            if (error != NULL) {
                error->code = MG_ERROR_DATA_CODE_SCRIPT_ERROR;
                mg_snprintf(NULL,
                            NULL, /* No truncation check for error buffers */
                            error->text,
                            error->text_buffer_size,
                            "Error in script %s: %s",
                            config_options[LUA_BACKGROUND_SCRIPT].name,
                            ebuf);
            }
 
            pthread_mutex_unlock(&ctx->lua_bg_mutex);
 
            free_context(ctx);
            pthread_setspecific(sTlsKey, NULL);
            return NULL;
        }
 
        /* Add a table with parameters into mg.params */
        sparams = ctx->dd.config[LUA_BACKGROUND_SCRIPT_PARAMS];
        if (sparams && sparams[0]) {
            lua_getglobal(state, "mg");
            lua_pushstring(state, "params");
            lua_newtable(state);
 
            while ((sparams = next_option(sparams, &opt_vec, &eq_vec))
                   != NULL) {
                reg_llstring(
                    state, opt_vec.ptr, opt_vec.len, eq_vec.ptr, eq_vec.len);
                if (mg_strncasecmp(sparams, opt_vec.ptr, opt_vec.len) == 0)
                    break;
            }
            lua_rawset(state, -3);
            lua_pop(state, 1);
        }
 
        /* Call script */
        state = mg_lua_context_script_run(state,
                                          ctx->dd.config[LUA_BACKGROUND_SCRIPT],
                                          ctx,
                                          ebuf,
                                          sizeof(ebuf));
        if (!state) {
            mg_cry_ctx_internal(ctx,
                                "lua_background_script start error: %s",
                                ebuf);
            if (error != NULL) {
                error->code = MG_ERROR_DATA_CODE_SCRIPT_ERROR;
                mg_snprintf(NULL,
                            NULL, /* No truncation check for error buffers */
                            error->text,
                            error->text_buffer_size,
                            "Error in script %s: %s",
                            config_options[DOCUMENT_ROOT].name,
                            ebuf);
            }
            pthread_mutex_unlock(&ctx->lua_bg_mutex);
 
            free_context(ctx);
            pthread_setspecific(sTlsKey, NULL);
            return NULL;
        }
 
        /* state remains valid */
        ctx->lua_background_state = (void *)state;
        pthread_mutex_unlock(&ctx->lua_bg_mutex);
 
    } else {
        ctx->lua_background_state = 0;
    }
#endif
 
    /* Step by step initialization of ctx - depending on build options */
#if !defined(NO_FILESYSTEMS)
    if (!set_gpass_option(ctx, NULL)) {
        const char *err_msg = "Invalid global password file";
        /* Fatal error - abort start. */
        mg_cry_ctx_internal(ctx, "%s", err_msg);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INVALID_PASS_FILE;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
#endif
 
#if defined(USE_MBEDTLS)
    if (!mg_sslctx_init(ctx, NULL)) {
        const char *err_msg = "Error initializing SSL context";
        /* Fatal error - abort start. */
        mg_cry_ctx_internal(ctx, "%s", err_msg);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INIT_TLS_FAILED;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
 
#elif !defined(NO_SSL)
    if (!init_ssl_ctx(ctx, NULL)) {
        const char *err_msg = "Error initializing SSL context";
        /* Fatal error - abort start. */
        mg_cry_ctx_internal(ctx, "%s", err_msg);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INIT_TLS_FAILED;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
#endif
 
    if (!set_ports_option(ctx)) {
        const char *err_msg = "Failed to setup server ports";
        /* Fatal error - abort start. */
        mg_cry_ctx_internal(ctx, "%s", err_msg);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INIT_PORTS_FAILED;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
 
#if !defined(_WIN32) && !defined(__ZEPHYR__)
    if (!set_uid_option(ctx)) {
        const char *err_msg = "Failed to run as configured user";
        /* Fatal error - abort start. */
        mg_cry_ctx_internal(ctx, "%s", err_msg);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INIT_USER_FAILED;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
#endif
 
    if (!set_acl_option(ctx)) {
        const char *err_msg = "Failed to setup access control list";
        /* Fatal error - abort start. */
        mg_cry_ctx_internal(ctx, "%s", err_msg);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INIT_ACL_FAILED;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
 
    ctx->cfg_worker_threads = ((unsigned int)(workerthreadcount));
    ctx->worker_threadids = (pthread_t *)mg_calloc_ctx(ctx->cfg_worker_threads,
                                                       sizeof(pthread_t),
                                                       ctx);
 
    if (ctx->worker_threadids == NULL) {
        const char *err_msg = "Not enough memory for worker thread ID array";
        mg_cry_ctx_internal(ctx, "%s", err_msg);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_OUT_OF_MEMORY;
            error->code_sub =
                (unsigned)ctx->cfg_worker_threads * (unsigned)sizeof(pthread_t);
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
    ctx->worker_connections =
        (struct mg_connection *)mg_calloc_ctx(ctx->cfg_worker_threads,
                                              sizeof(struct mg_connection),
                                              ctx);
    if (ctx->worker_connections == NULL) {
        const char *err_msg =
            "Not enough memory for worker thread connection array";
        mg_cry_ctx_internal(ctx, "%s", err_msg);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_OUT_OF_MEMORY;
            error->code_sub = (unsigned)ctx->cfg_worker_threads
                              * (unsigned)sizeof(struct mg_connection);
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
 
#if defined(ALTERNATIVE_QUEUE)
    ctx->client_wait_events =
        (void **)mg_calloc_ctx(ctx->cfg_worker_threads,
                               sizeof(ctx->client_wait_events[0]),
                               ctx);
    if (ctx->client_wait_events == NULL) {
        const char *err_msg = "Not enough memory for worker event array";
        mg_cry_ctx_internal(ctx, "%s", err_msg);
        mg_free(ctx->worker_threadids);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_OUT_OF_MEMORY;
            error->code_sub = (unsigned)ctx->cfg_worker_threads
                              * (unsigned)sizeof(ctx->client_wait_events[0]);
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
 
    ctx->client_socks =
        (struct socket *)mg_calloc_ctx(ctx->cfg_worker_threads,
                                       sizeof(ctx->client_socks[0]),
                                       ctx);
    if (ctx->client_socks == NULL) {
        const char *err_msg = "Not enough memory for worker socket array";
        mg_cry_ctx_internal(ctx, "%s", err_msg);
        mg_free(ctx->client_wait_events);
        mg_free(ctx->worker_threadids);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_OUT_OF_MEMORY;
            error->code_sub = (unsigned)ctx->cfg_worker_threads
                              * (unsigned)sizeof(ctx->client_socks[0]);
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
 
    for (i = 0; (unsigned)i < ctx->cfg_worker_threads; i++) {
        ctx->client_wait_events[i] = event_create();
        if (ctx->client_wait_events[i] == 0) {
            const char *err_msg = "Error creating worker event %i";
            mg_cry_ctx_internal(ctx, err_msg, i);
            while (i > 0) {
                i--;
                event_destroy(ctx->client_wait_events[i]);
            }
            mg_free(ctx->client_socks);
            mg_free(ctx->client_wait_events);
            mg_free(ctx->worker_threadids);
 
            if (error != NULL) {
                error->code = MG_ERROR_DATA_CODE_OS_ERROR;
                error->code_sub = (unsigned)ERRNO;
                mg_snprintf(NULL,
                            NULL, /* No truncation check for error buffers */
                            error->text,
                            error->text_buffer_size,
                            err_msg,
                            i);
            }
 
            free_context(ctx);
            pthread_setspecific(sTlsKey, NULL);
            return NULL;
        }
    }
#endif
 
#if defined(USE_TIMERS)
    if (timers_init(ctx) != 0) {
        const char *err_msg = "Error creating timers";
        mg_cry_ctx_internal(ctx, "%s", err_msg);
 
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_OS_ERROR;
            error->code_sub = (unsigned)ERRNO;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        err_msg);
        }
 
        free_context(ctx);
        pthread_setspecific(sTlsKey, NULL);
        return NULL;
    }
#endif
 
    /* Context has been created - init user libraries */
    if (ctx->callbacks.init_context) {
        ctx->callbacks.init_context(ctx);
    }
 
    /* From now, the context is successfully created.
     * When it is destroyed, the exit callback should be called. */
    ctx->callbacks.exit_context = exit_callback;
    ctx->context_type = CONTEXT_SERVER; /* server context */
 
    /* Start worker threads */
    for (i = 0; i < ctx->cfg_worker_threads; i++) {
        /* worker_thread sets up the other fields */
        ctx->worker_connections[i].phys_ctx = ctx;
        if (mg_start_thread_with_id(worker_thread,
                                    &ctx->worker_connections[i],
                                    &ctx->worker_threadids[i])
            != 0) {
 
            long error_no = (long)ERRNO;
 
            /* thread was not created */
            if (i > 0) {
                /* If the second, third, ... thread cannot be created, set a
                 * warning, but keep running. */
                mg_cry_ctx_internal(ctx,
                                    "Cannot start worker thread %i: error %ld",
                                    i + 1,
                                    error_no);
 
                /* If the server initialization should stop here, all
                 * threads that have already been created must be stopped
                 * first, before any free_context(ctx) call.
                 */
 
            } else {
                /* If the first worker thread cannot be created, stop
                 * initialization and free the entire server context. */
                mg_cry_ctx_internal(ctx,
                                    "Cannot create threads: error %ld",
                                    error_no);
 
                if (error != NULL) {
                    error->code = MG_ERROR_DATA_CODE_OS_ERROR;
                    error->code_sub = (unsigned)error_no;
                    mg_snprintf(
                        NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "Cannot create first worker thread: error %ld",
                        error_no);
                }
 
                free_context(ctx);
                pthread_setspecific(sTlsKey, NULL);
                return NULL;
            }
            break;
        }
    }
 
    /* Start master (listening) thread */
    mg_start_thread_with_id(master_thread, ctx, &ctx->masterthreadid);
 
    pthread_setspecific(sTlsKey, NULL);
    return ctx;
}

References mg_domain_context::auth_nonce_mask, mg_context::callbacks, mg_init_data::callbacks, mg_context::cfg_worker_threads, mg_domain_context::config, config_options, mg_init_data::configuration_options, CONNECTION_QUEUE_SIZE, CONTEXT_SERVER, mg_context::context_type, mg_context::dd, DEBUG_TRACE, mg_option::default_value, DOCUMENT_ROOT, ERRNO, error(), mg_callbacks::exit_context, free_context(), get_option_index(), get_random(), get_system_name(), mg_domain_context::handlers, mg_callbacks::init_context, init_ssl_ctx(), mg_workerTLS::is_master, legacy_init(), vec::len, lua_getglobal, lua_newtable, lua_pop, lua_pushstring(), lua_rawset(), master_thread(), mg_context::masterthreadid, MAX_REQUEST_SIZE, mg_context::max_request_size, MAX_WORKER_THREADS, mg_atomic_inc(), mg_calloc(), mg_calloc_ctx, mg_cry_ctx_internal, MG_ERROR_DATA_CODE_INIT_ACL_FAILED, MG_ERROR_DATA_CODE_INIT_LIBRARY_FAILED, MG_ERROR_DATA_CODE_INIT_PORTS_FAILED, MG_ERROR_DATA_CODE_INIT_TLS_FAILED, MG_ERROR_DATA_CODE_INIT_USER_FAILED, MG_ERROR_DATA_CODE_INVALID_OPTION, MG_ERROR_DATA_CODE_INVALID_PASS_FILE, MG_ERROR_DATA_CODE_OK, MG_ERROR_DATA_CODE_OS_ERROR, MG_ERROR_DATA_CODE_OUT_OF_MEMORY, MG_ERROR_DATA_CODE_SCRIPT_ERROR, mg_free(), mg_init_library_called, mg_snprintf(), mg_start_thread_with_id(), mg_strdup_ctx(), mg_strncasecmp(), mg_option::name, name, mg_domain_context::next, next_option(), mg_context::nonce_mutex, NULL, NUM_THREADS, mg_connection::phys_ctx, pthread_mutex_attr, vec::ptr, set_acl_option(), set_gpass_option(), set_ports_option(), set_uid_option(), mg_context::sq_blocked, mg_context::sq_empty, mg_context::sq_full, mg_context::sq_size, mg_context::squeue, mg_context::starter_thread_idx, sTlsKey, mg_context::systemName, mg_workerTLS::thread_idx, thread_idx_max, mg_context::thread_mutex, mg_context::user_data, mg_init_data::user_data, value, mg_context::worker_connections, worker_thread(), and mg_context::worker_threadids.

Referenced by mg_start(), and start_civetweb().

mg_start_domain()

CIVETWEB_API int mg_start_domain	(	struct mg_context *	ctx,
		const char **	configuration_options )

Definition at line 21422 of file civetweb.c.

{
    return mg_start_domain2(ctx, options, NULL);
}

References mg_start_domain2(), and NULL.

Referenced by start_civetweb().

mg_start_domain2()

CIVETWEB_API int mg_start_domain2	(	struct mg_context *	ctx,
		const char **	configuration_options,
		struct mg_error_data *	error )

Definition at line 21220 of file civetweb.c.

{
    const char *name;
    const char *value;
    const char *default_value;
    struct mg_domain_context *new_dom;
    struct mg_domain_context *dom;
    int idx, i;
 
    if (error != NULL) {
        error->code = MG_ERROR_DATA_CODE_OK;
        error->code_sub = 0;
        if (error->text_buffer_size > 0) {
            *error->text = 0;
        }
    }
 
    if ((ctx == NULL) || (options == NULL)) {
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INVALID_PARAM;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        "Invalid parameters");
        }
        return -1;
    }
 
    if (!STOP_FLAG_IS_ZERO(&ctx->stop_flag)) {
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_SERVER_STOPPED;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        "Server already stopped");
        }
        return -7;
    }
 
    new_dom = (struct mg_domain_context *)
        mg_calloc_ctx(1, sizeof(struct mg_domain_context), ctx);
 
    if (!new_dom) {
        /* Out of memory */
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_OUT_OF_MEMORY;
            error->code_sub = (unsigned)sizeof(struct mg_domain_context);
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        "Out or memory");
        }
        return -6;
    }
 
    /* Store options - TODO: unite duplicate code */
    while (options && (name = *options++) != NULL) {
        idx = get_option_index(name);
        if (idx == -1) {
            mg_cry_ctx_internal(ctx, "Invalid option: %s", name);
            if (error != NULL) {
                error->code = MG_ERROR_DATA_CODE_INVALID_OPTION;
                error->code_sub = (unsigned)-1;
                mg_snprintf(NULL,
                            NULL, /* No truncation check for error buffers */
                            error->text,
                            error->text_buffer_size,
                            "Invalid option: %s",
                            name);
            }
            mg_free(new_dom);
            return -2;
        } else if ((value = *options++) == NULL) {
            mg_cry_ctx_internal(ctx, "%s: option value cannot be NULL", name);
            if (error != NULL) {
                error->code = MG_ERROR_DATA_CODE_INVALID_OPTION;
                error->code_sub = (unsigned)idx;
                mg_snprintf(NULL,
                            NULL, /* No truncation check for error buffers */
                            error->text,
                            error->text_buffer_size,
                            "Invalid option value: %s",
                            name);
            }
            mg_free(new_dom);
            return -2;
        }
        if (new_dom->config[idx] != NULL) {
            /* Duplicate option: Later values overwrite earlier ones. */
            mg_cry_ctx_internal(ctx, "warning: %s: duplicate option", name);
            mg_free(new_dom->config[idx]);
        }
        new_dom->config[idx] = mg_strdup_ctx(value, ctx);
        DEBUG_TRACE("[%s] -> [%s]", name, value);
    }
 
    /* Authentication domain is mandatory */
    /* TODO: Maybe use a new option hostname? */
    if (!new_dom->config[AUTHENTICATION_DOMAIN]) {
        mg_cry_ctx_internal(ctx, "%s", "authentication domain required");
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_MISSING_OPTION;
            error->code_sub = AUTHENTICATION_DOMAIN;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "Mandatory option %s missing",
                        config_options[AUTHENTICATION_DOMAIN].name);
        }
        mg_free(new_dom);
        return -4;
    }
 
    /* Set default value if needed. Take the config value from
     * ctx as a default value. */
    for (i = 0; config_options[i].name != NULL; i++) {
        default_value = ctx->dd.config[i];
        if ((new_dom->config[i] == NULL) && (default_value != NULL)) {
            new_dom->config[i] = mg_strdup_ctx(default_value, ctx);
        }
    }
 
    new_dom->handlers = NULL;
    new_dom->next = NULL;
    new_dom->nonce_count = 0;
    new_dom->auth_nonce_mask = get_random() ^ (get_random() << 31);
 
#if defined(USE_LUA) && defined(USE_WEBSOCKET)
    new_dom->shared_lua_websockets = NULL;
#endif
 
#if !defined(NO_SSL) && !defined(USE_MBEDTLS)
    if (!init_ssl_ctx(ctx, new_dom)) {
        /* Init SSL failed */
        if (error != NULL) {
            error->code = MG_ERROR_DATA_CODE_INIT_TLS_FAILED;
            mg_snprintf(NULL,
                        NULL, /* No truncation check for error buffers */
                        error->text,
                        error->text_buffer_size,
                        "%s",
                        "Initializing SSL context failed");
        }
        mg_free(new_dom);
        return -3;
    }
#endif
 
    /* Add element to linked list. */
    mg_lock_context(ctx);
 
    idx = 0;
    dom = &(ctx->dd);
    for (;;) {
        if (!mg_strcasecmp(new_dom->config[AUTHENTICATION_DOMAIN],
                           dom->config[AUTHENTICATION_DOMAIN])) {
            /* Domain collision */
            mg_cry_ctx_internal(ctx,
                                "domain %s already in use",
                                new_dom->config[AUTHENTICATION_DOMAIN]);
            if (error != NULL) {
                error->code = MG_ERROR_DATA_CODE_DUPLICATE_DOMAIN;
                mg_snprintf(NULL,
                            NULL, /* No truncation check for error buffers */
                            error->text,
                            error->text_buffer_size,
                            "Domain %s specified by %s is already in use",
                            new_dom->config[AUTHENTICATION_DOMAIN],
                            config_options[AUTHENTICATION_DOMAIN].name);
            }
            mg_free(new_dom);
            mg_unlock_context(ctx);
            return -5;
        }
 
        /* Count number of domains */
        idx++;
 
        if (dom->next == NULL) {
            dom->next = new_dom;
            break;
        }
        dom = dom->next;
    }
 
    mg_unlock_context(ctx);
 
    /* Return domain number */
    return idx;
}

References mg_domain_context::auth_nonce_mask, AUTHENTICATION_DOMAIN, mg_domain_context::config, config_options, mg_context::dd, DEBUG_TRACE, error(), get_option_index(), get_random(), mg_domain_context::handlers, init_ssl_ctx(), mg_calloc_ctx, mg_cry_ctx_internal, MG_ERROR_DATA_CODE_DUPLICATE_DOMAIN, MG_ERROR_DATA_CODE_INIT_TLS_FAILED, MG_ERROR_DATA_CODE_INVALID_OPTION, MG_ERROR_DATA_CODE_INVALID_PARAM, MG_ERROR_DATA_CODE_MISSING_OPTION, MG_ERROR_DATA_CODE_OK, MG_ERROR_DATA_CODE_OUT_OF_MEMORY, MG_ERROR_DATA_CODE_SERVER_STOPPED, mg_free(), mg_lock_context(), mg_snprintf(), mg_strcasecmp(), mg_strdup_ctx(), mg_unlock_context(), mg_option::name, name, mg_domain_context::next, mg_domain_context::nonce_count, NULL, mg_context::stop_flag, STOP_FLAG_IS_ZERO, and value.

Referenced by mg_start_domain().

mg_start_thread()

CIVETWEB_API int mg_start_thread	(	mg_thread_func_t	f,
		void *	p )

Definition at line 5700 of file civetweb.c.

{
    pthread_t thread_id;
    pthread_attr_t attr;
    int result;
 
    (void)pthread_attr_init(&attr);
    (void)pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
#if defined(__ZEPHYR__)
    pthread_attr_setstack(&attr, &civetweb_main_stack, ZEPHYR_STACK_SIZE);
#elif defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)
    /* Compile-time option to control stack size,
     * e.g. -DUSE_STACK_SIZE=16384 */
    (void)pthread_attr_setstacksize(&attr, USE_STACK_SIZE);
#endif /* defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) */
 
    result = pthread_create(&thread_id, &attr, func, param);
    pthread_attr_destroy(&attr);
 
    return result;
}

mg_stop()

CIVETWEB_API void mg_stop

(

struct mg_context *

ctx

)

Definition at line 20346 of file civetweb.c.

{
    pthread_t mt;
    if (!ctx) {
        return;
    }
 
    /* We don't use a lock here. Calling mg_stop with the same ctx from
     * two threads is not allowed. */
    mt = ctx->masterthreadid;
    if (mt == 0) {
        return;
    }
 
    ctx->masterthreadid = 0;
 
    /* Set stop flag, so all threads know they have to exit. */
    STOP_FLAG_ASSIGN(&ctx->stop_flag, 1);
 
    /* Join timer thread */
#if defined(USE_TIMERS)
    timers_exit(ctx);
#endif
 
    /* Wait until everything has stopped. */
    while (!STOP_FLAG_IS_TWO(&ctx->stop_flag)) {
        (void)mg_sleep(10);
    }
 
    /* Wait to stop master thread */
    mg_join_thread(mt);
 
    /* Close remaining Lua states */
#if defined(USE_LUA)
    lua_ctx_exit(ctx);
#endif
 
    /* Free memory */
    free_context(ctx);
}

References free_context(), mg_context::masterthreadid, mg_join_thread(), mg_sleep, mg_context::stop_flag, STOP_FLAG_ASSIGN, and STOP_FLAG_IS_TWO.

Referenced by start_http_server(), and stop_civetweb().

mg_store_body()

CIVETWEB_API long long mg_store_body	(	struct mg_connection *	conn,
		const char *	path )

Definition at line 10622 of file civetweb.c.

{
    char buf[MG_BUF_LEN];
    long long len = 0;
    int ret, n;
    struct mg_file fi;
 
    if (conn->consumed_content != 0) {
        mg_cry_internal(conn, "%s: Contents already consumed", __func__);
        return -11;
    }
 
    ret = put_dir(conn, path);
    if (ret < 0) {
        /* -1 for path too long,
         * -2 for path can not be created. */
        return ret;
    }
    if (ret != 1) {
        /* Return 0 means, path itself is a directory. */
        return 0;
    }
 
    if (mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &fi) == 0) {
        return -12;
    }
 
    ret = mg_read(conn, buf, sizeof(buf));
    while (ret > 0) {
        n = (int)fwrite(buf, 1, (size_t)ret, fi.access.fp);
        if (n != ret) {
            (void)mg_fclose(
                &fi.access); /* File is bad and will be removed anyway. */
            remove_bad_file(conn, path);
            return -13;
        }
        len += ret;
        ret = mg_read(conn, buf, sizeof(buf));
    }
 
    /* File is open for writing. If fclose fails, there was probably an
     * error flushing the buffer to disk, so the file on disk might be
     * broken. Delete it and return an error to the caller. */
    if (mg_fclose(&fi.access) != 0) {
        remove_bad_file(conn, path);
        return -14;
    }
 
    return len;
}

References mg_file::access, mg_connection::consumed_content, mg_file_access::fp, fwrite(), MG_BUF_LEN, mg_cry_internal, mg_fclose(), mg_fopen(), MG_FOPEN_MODE_WRITE, mg_read(), put_dir(), and remove_bad_file().

mg_strcasecmp()

CIVETWEB_API void CIVETWEB_API int mg_strcasecmp	(	const char *	s1,
		const char *	s2 )

Definition at line 3034 of file civetweb.c.

{
    int diff;
 
    do {
        diff = lowercase(s1++) - lowercase(s2++);
    } while (diff == 0 && s1[-1] != '\0');
 
    return diff;
}

References lowercase().

Referenced by check_password_digest(), forward_body_data(), get_header(), get_rel_url_at_current_server(), get_req_headers(), get_request(), get_response(), handle_cgi_request(), handle_propfind(), handle_request(), init_connection(), init_ssl_ctx_impl(), interpret_uri(), is_not_modified(), mg_construct_local_link(), mg_get_builtin_mime_type(), mg_send_mime_file2(), mg_start_domain2(), refresh_trust(), send_file_data(), should_decode_query_string(), should_decode_url(), should_keep_alive(), ssl_servername_callback(), sslize(), and start_civetweb().

mg_strncasecmp()

CIVETWEB_API int mg_strncasecmp	(	const char *	s1,
		const char *	s2,
		size_t	len )

Definition at line 3019 of file civetweb.c.

{
    int diff = 0;
 
    if (len > 0) {
        do {
            diff = lowercase(s1++) - lowercase(s2++);
        } while (diff == 0 && s1[-1] != '\0' && --len > 0);
    }
 
    return diff;
}

References lowercase().

Referenced by get_mime_type(), get_rel_url_at_current_server(), get_uri_type(), header_has_option(), mg_get_var2(), mg_start2(), mg_strcasestr(), parse_auth_header(), and switch_domain_context().

mg_unlock_connection()

CIVETWEB_API void mg_unlock_connection

(

struct mg_connection *

conn

)

Definition at line 13009 of file civetweb.c.

{
    if (conn) {
        (void)pthread_mutex_unlock(&conn->mutex);
    }
}

References mg_connection::mutex.

Referenced by close_connection().

mg_unlock_context()

CIVETWEB_API void mg_unlock_context

(

struct mg_context *

ctx

)

Definition at line 13027 of file civetweb.c.

{
    if (ctx && (ctx->context_type == CONTEXT_SERVER)) {
        (void)pthread_mutex_unlock(&ctx->nonce_mutex);
    }
}

References CONTEXT_SERVER, mg_context::context_type, and mg_context::nonce_mutex.

Referenced by dav_lock_file(), dav_unlock_file(), get_request_handler(), mg_set_handler_type(), mg_start_domain2(), refresh_trust(), release_handler_ref(), send_authorization_request(), ssl_servername_callback(), sslize(), and switch_domain_context().

mg_url_decode()

CIVETWEB_API int mg_url_decode	(	const char *	src,
		int	src_len,
		char *	dst,
		int	dst_len,
		int	is_form_url_encoded )

Definition at line 7048 of file civetweb.c.

{
    int i, j, a, b;
#define HEXTOI(x) (isdigit(x) ? (x - '0') : (x - 'W'))
 
    for (i = j = 0; (i < src_len) && (j < (dst_len - 1)); i++, j++) {
        if ((i < src_len - 2) && (src[i] == '%')
            && isxdigit((unsigned char)src[i + 1])
            && isxdigit((unsigned char)src[i + 2])) {
            a = tolower((unsigned char)src[i + 1]);
            b = tolower((unsigned char)src[i + 2]);
            dst[j] = (char)((HEXTOI(a) << 4) | HEXTOI(b));
            i += 2;
        } else if (is_form_url_encoded && (src[i] == '+')) {
            dst[j] = ' ';
        } else {
            dst[j] = src[i];
        }
    }
 
    dst[j] = '\0'; /* Null-terminate the destination */
 
    return (i >= src_len) ? j : -1;
}

References HEXTOI.

Referenced by dav_move_file(), mg_get_var2(), and url_decode_in_place().

mg_url_encode()

CIVETWEB_API int mg_url_encode	(	const char *	src,
		char *	dst,
		size_t	dst_len )

Definition at line 9581 of file civetweb.c.

{
    static const char *dont_escape = "._-$,;~()";
    static const char *hex = "0123456789abcdef";
    char *pos = dst;
    const char *end = dst + dst_len - 1;
 
    for (; ((*src != '\0') && (pos < end)); src++, pos++) {
        if (isalnum((unsigned char)*src)
            || (strchr(dont_escape, *src) != NULL)) {
            *pos = *src;
        } else if (pos + 2 < end) {
            pos[0] = '%';
            pos[1] = hex[(unsigned char)*src >> 4];
            pos[2] = hex[(unsigned char)*src & 0xf];
            pos += 2;
        } else {
            break;
        }
    }
 
    *pos = '\0';
    return (*src == '\0') ? (int)(pos - dst) : -1;
}

References NULL.

Referenced by mg_construct_local_link(), and print_dir_entry().

mg_version()

CIVETWEB_API const char * mg_version

(

void

)

Definition at line 3514 of file civetweb.c.

{
    return CIVETWEB_VERSION;
}

References CIVETWEB_VERSION.

Referenced by init_server_name(), mg_get_system_info(), prepare_cgi_environment(), and show_server_name().

mg_websocket_client_write()

CIVETWEB_API int mg_websocket_client_write	(	struct mg_connection *	conn,
		int	opcode,
		const char *	data,
		size_t	data_len )

mg_websocket_write()

CIVETWEB_API int mg_websocket_write	(	struct mg_connection *	conn,
		int	opcode,
		const char *	data,
		size_t	data_len )

mg_write()

CIVETWEB_API int mg_write	(	struct mg_connection *	conn,
		const void *	buf,
		size_t	len )

Definition at line 6779 of file civetweb.c.

{
    time_t now;
    int n, total, allowed;
 
    if (conn == NULL) {
        return 0;
    }
    if (len > INT_MAX) {
        return -1;
    }
 
    /* Mark connection as "data sent" */
    conn->request_state = 10;
#if defined(USE_HTTP2)
    if (conn->protocol_type == PROTOCOL_TYPE_HTTP2) {
        http2_data_frame_head(conn, len, 0);
    }
#endif
 
    if (conn->throttle > 0) {
        if ((now = time(NULL)) != conn->last_throttle_time) {
            conn->last_throttle_time = now;
            conn->last_throttle_bytes = 0;
        }
        allowed = conn->throttle - conn->last_throttle_bytes;
        if (allowed > (int)len) {
            allowed = (int)len;
        }
 
        total = push_all(conn->phys_ctx,
                         NULL,
                         conn->client.sock,
                         conn->ssl,
                         (const char *)buf,
                         allowed);
 
        if (total == allowed) {
 
            buf = (const char *)buf + total;
            conn->last_throttle_bytes += total;
            while ((total < (int)len)
                   && STOP_FLAG_IS_ZERO(&conn->phys_ctx->stop_flag)) {
                allowed = (conn->throttle > ((int)len - total))
                              ? (int)len - total
                              : conn->throttle;
 
                n = push_all(conn->phys_ctx,
                             NULL,
                             conn->client.sock,
                             conn->ssl,
                             (const char *)buf,
                             allowed);
 
                if (n != allowed) {
                    break;
                }
                sleep(1);
                conn->last_throttle_bytes = allowed;
                conn->last_throttle_time = time(NULL);
                buf = (const char *)buf + n;
                total += n;
            }
        }
    } else {
        total = push_all(conn->phys_ctx,
                         NULL,
                         conn->client.sock,
                         conn->ssl,
                         (const char *)buf,
                         (int)len);
    }
    if (total > 0) {
        conn->num_bytes_sent += total;
    }
    return total;
}

References mg_connection::client, mg_connection::last_throttle_bytes, mg_connection::last_throttle_time, NULL, mg_connection::num_bytes_sent, mg_connection::phys_ctx, mg_connection::protocol_type, PROTOCOL_TYPE_HTTP2, push_all(), mg_connection::request_state, socket::sock, mg_connection::ssl, mg_context::stop_flag, STOP_FLAG_IS_ZERO, and mg_connection::throttle.

Referenced by handle_cgi_request(), mg_send_chunk(), mg_send_http_error_impl(), mg_send_http_redirect(), mg_vprintf(), send_file_data(), and send_ssi_file().