Classes
struct	mbuf

struct	cs_sha1_ctx

struct	MD5Context

struct	cs_base64_ctx

struct	json_token

union	socket_address

struct	mg_str

struct	mg_mgr

struct	mg_connection

struct	mg_add_sock_opts

struct	mg_bind_opts

struct	mg_connect_opts

struct	http_message

struct	websocket_message

struct	mg_http_multipart_part

struct	mg_serve_http_opts

struct	mg_rpc_request

struct	mg_rpc_reply

struct	mg_rpc_error

struct	mg_mqtt_message

struct	mg_mqtt_topic_expression

struct	mg_send_mqtt_handshake_opts

struct	mg_dns_resource_record

struct	mg_dns_message

struct	mg_resolve_async_opts

Macros
#define	MG_VERSION "6.4"

#define	CS_COMMON_PLATFORM_H_

#define	CS_P_CUSTOM 0

#define	CS_P_UNIX 1

#define	CS_P_WINDOWS 2

#define	CS_P_ESP_LWIP 3

#define	CS_P_CC3200 4

#define	CS_P_MSP432 5

#define	NORETURN

#define	UNUSED

#define	NOINLINE

#define	WARN_UNUSED_RESULT

#define	ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))

#define	CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_ESP_LWIP_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_

#define	CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_

#define	CS_COMMON_CS_DBG_H_

#define	LOG(l, x)

#define	DBG(x)

#define	CS_COMMON_CS_TIME_H_

#define	CS_COMMON_MBUF_H_

#define	MBUF_SIZE_MULTIPLIER 1.5

#define	CS_COMMON_SHA1_H_

#define	CS_COMMON_MD5_H_

#define	CS_COMMON_BASE64_H_

#define	CS_COMMON_STR_UTIL_H_

#define	CS_MONGOOSE_DEPS_FROZEN_FROZEN_H_

#define	JSON_STRING_INVALID -1

#define	JSON_STRING_INCOMPLETE -2

#define	JSON_TOKEN_ARRAY_TOO_SMALL -3

#define	CS_COMMON_CS_DIRENT_H_

#define	CS_MONGOOSE_SRC_NET_H_

#define	MG_VPRINTF_BUFFER_SIZE 100

#define	MG_RECV_FUNC(s, b, l, f) recv(s, b, l, f)

#define	MG_SEND_FUNC(s, b, l, f) send(s, b, l, f)

#define	MG_EV_POLL 0 /* Sent to each connection on each mg_mgr_poll() call */

#define	MG_EV_ACCEPT 1 /* New connection accepted. union socket_address * */

#define	MG_EV_CONNECT 2 /* connect() succeeded or failed. int * */

#define	MG_EV_RECV 3 /* Data has benn received. int num_bytes /

#define	MG_EV_SEND 4 /* Data has been written to a socket. int num_bytes /

#define	MG_EV_CLOSE 5 /* Connection is closed. NULL */

#define	MG_EV_TIMER 6 /* now >= conn->ev_timer_time. double * */

#define	MG_F_LISTENING (1 << 0) /* This connection is listening */

#define	MG_F_UDP (1 << 1) /* This connection is UDP */

#define	MG_F_RESOLVING (1 << 2) /* Waiting for async resolver */

#define	MG_F_CONNECTING (1 << 3) /* connect() call in progress */

#define	MG_F_SSL_HANDSHAKE_DONE (1 << 4) /* SSL specific */

#define	MG_F_WANT_READ (1 << 5) /* SSL specific */

#define	MG_F_WANT_WRITE (1 << 6) /* SSL specific */

#define	MG_F_IS_WEBSOCKET (1 << 7) /* Websocket specific */

#define	MG_F_SEND_AND_CLOSE (1 << 10) /* Push remaining data and close */

#define	MG_F_CLOSE_IMMEDIATELY (1 << 11) /* Disconnect */

#define	MG_F_WEBSOCKET_NO_DEFRAG (1 << 12) /* Websocket specific */

#define	MG_F_DELETE_CHUNK (1 << 13) /* HTTP specific */

#define	MG_F_USER_1 (1 << 20) /* Flags left for application */

#define	MG_F_USER_2 (1 << 21)

#define	MG_F_USER_3 (1 << 22)

#define	MG_F_USER_4 (1 << 23)

#define	MG_F_USER_5 (1 << 24)

#define	MG_F_USER_6 (1 << 25)

#define	CS_MONGOOSE_SRC_NET_IF_H_

#define	CS_MONGOOSE_SRC_URI_H_

#define	CS_MONGOOSE_SRC_UTIL_H_

#define	MAX_PATH_SIZE 500

#define	MG_SOCK_STRINGIFY_IP 1

#define	MG_SOCK_STRINGIFY_PORT 2

#define	MG_SOCK_STRINGIFY_REMOTE 4

#define	MG_MK_STR(str_literal) { str_literal, sizeof(str_literal) - 1 }

#define	CS_MONGOOSE_SRC_HTTP_H_

#define	MG_MAX_HTTP_HEADERS 20

#define	MG_MAX_HTTP_REQUEST_SIZE 1024

#define	MG_MAX_PATH 256

#define	MG_MAX_HTTP_SEND_MBUF 1024

#define	MG_WEBSOCKET_PING_INTERVAL_SECONDS 5

#define	MG_CGI_ENVIRONMENT_SIZE 8192

#define	MG_MAX_CGI_ENVIR_VARS 64

#define	MG_ENV_EXPORT_TO_CGI "MONGOOSE_CGI"

#define	MG_EV_HTTP_REQUEST 100 /* struct http_message * */

#define	MG_EV_HTTP_REPLY 101 /* struct http_message * */

#define	MG_EV_HTTP_CHUNK 102 /* struct http_message * */

#define	MG_EV_SSI_CALL 105 /* char * */

#define	MG_EV_WEBSOCKET_HANDSHAKE_REQUEST 111 /* NULL */

#define	MG_EV_WEBSOCKET_HANDSHAKE_DONE 112 /* NULL */

#define	MG_EV_WEBSOCKET_FRAME 113 /* struct websocket_message * */

#define	MG_EV_WEBSOCKET_CONTROL_FRAME 114 /* struct websocket_message * */

#define	WEBSOCKET_OP_CONTINUE 0

#define	WEBSOCKET_OP_TEXT 1

#define	WEBSOCKET_OP_BINARY 2

#define	WEBSOCKET_OP_CLOSE 8

#define	WEBSOCKET_OP_PING 9

#define	WEBSOCKET_OP_PONG 10

#define	WEBSOCKET_DONT_FIN 0x100

#define	CS_MONGOOSE_SRC_JSON_RPC_H_

#define	JSON_RPC_PARSE_ERROR (-32700)

#define	JSON_RPC_INVALID_REQUEST_ERROR (-32600)

#define	JSON_RPC_METHOD_NOT_FOUND_ERROR (-32601)

#define	JSON_RPC_INVALID_PARAMS_ERROR (-32602)

#define	JSON_RPC_INTERNAL_ERROR (-32603)

#define	JSON_RPC_SERVER_ERROR (-32000)

#define	CS_MONGOOSE_SRC_MQTT_H_

#define	MG_MQTT_CMD_CONNECT 1

#define	MG_MQTT_CMD_CONNACK 2

#define	MG_MQTT_CMD_PUBLISH 3

#define	MG_MQTT_CMD_PUBACK 4

#define	MG_MQTT_CMD_PUBREC 5

#define	MG_MQTT_CMD_PUBREL 6

#define	MG_MQTT_CMD_PUBCOMP 7

#define	MG_MQTT_CMD_SUBSCRIBE 8

#define	MG_MQTT_CMD_SUBACK 9

#define	MG_MQTT_CMD_UNSUBSCRIBE 10

#define	MG_MQTT_CMD_UNSUBACK 11

#define	MG_MQTT_CMD_PINGREQ 12

#define	MG_MQTT_CMD_PINGRESP 13

#define	MG_MQTT_CMD_DISCONNECT 14

#define	MG_MQTT_EVENT_BASE 200

#define	MG_EV_MQTT_CONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNECT)

#define	MG_EV_MQTT_CONNACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNACK)

#define	MG_EV_MQTT_PUBLISH (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBLISH)

#define	MG_EV_MQTT_PUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBACK)

#define	MG_EV_MQTT_PUBREC (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREC)

#define	MG_EV_MQTT_PUBREL (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREL)

#define	MG_EV_MQTT_PUBCOMP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBCOMP)

#define	MG_EV_MQTT_SUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBSCRIBE)

#define	MG_EV_MQTT_SUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBACK)

#define	MG_EV_MQTT_UNSUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBSCRIBE)

#define	MG_EV_MQTT_UNSUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBACK)

#define	MG_EV_MQTT_PINGREQ (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGREQ)

#define	MG_EV_MQTT_PINGRESP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGRESP)

#define	MG_EV_MQTT_DISCONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_DISCONNECT)

#define	MG_MQTT_RETAIN 0x1

#define	MG_MQTT_DUP 0x4

#define	MG_MQTT_QOS(qos) ((qos) << 1)

#define	MG_MQTT_GET_QOS(flags) (((flags) &0x6) >> 1)

#define	MG_MQTT_SET_QOS(flags, qos) (flags) = ((flags) & ~0x6) \| ((qos) << 1)

#define	MG_MQTT_CLEAN_SESSION 0x02

#define	MG_MQTT_HAS_WILL 0x04

#define	MG_MQTT_WILL_RETAIN 0x20

#define	MG_MQTT_HAS_PASSWORD 0x40

#define	MG_MQTT_HAS_USER_NAME 0x80

#define	MG_MQTT_GET_WILL_QOS(flags) (((flags) &0x18) >> 3)

#define	MG_MQTT_SET_WILL_QOS(flags, qos) (flags) = ((flags) & ~0x18) \| ((qos) << 3)

#define	MG_EV_MQTT_CONNACK_ACCEPTED 0

#define	MG_EV_MQTT_CONNACK_UNACCEPTABLE_VERSION 1

#define	MG_EV_MQTT_CONNACK_IDENTIFIER_REJECTED 2

#define	MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE 3

#define	MG_EV_MQTT_CONNACK_BAD_AUTH 4

#define	MG_EV_MQTT_CONNACK_NOT_AUTHORIZED 5

#define	CS_MONGOOSE_SRC_MQTT_BROKER_H_

#define	CS_MONGOOSE_SRC_DNS_H_

#define	MG_DNS_A_RECORD 0x01 /* Lookup IP address */

#define	MG_DNS_CNAME_RECORD 0x05 /* Lookup CNAME */

#define	MG_DNS_AAAA_RECORD 0x1c /* Lookup IPv6 address */

#define	MG_DNS_MX_RECORD 0x0f /* Lookup mail server for domain */

#define	MG_MAX_DNS_QUESTIONS 32

#define	MG_MAX_DNS_ANSWERS 32

#define	MG_DNS_MESSAGE 100 /* High-level DNS message event */

#define	CS_MONGOOSE_SRC_DNS_SERVER_H_

#define	CS_MONGOOSE_SRC_RESOLV_H_

#define	CS_MONGOOSE_SRC_COAP_H_

Typedefs
typedef struct MD5Context	MD5_CTX

typedef void(*	cs_base64_putc_t) (char, void *)

typedef void *	SSL

typedef void *	SSL_CTX

typedef void(*	mg_event_handler_t) (struct mg_connection , int ev, void )

typedef int(*	mg_rpc_handler_t) (char buf, int len, struct mg_rpc_request req)

typedef void(*	mg_resolve_callback_t) (struct mg_dns_message dns_message, void user_data, enum mg_resolve_err)

Enumerations
enum	cs_log_level { LL_NONE = -1 , LL_ERROR = 0 , LL_WARN = 1 , LL_INFO = 2 , LL_DEBUG = 3 , LL_VERBOSE_DEBUG = 4 , _LL_MIN = -2 , _LL_MAX = 5 , LL_NONE = -1 , LL_ERROR = 0 , LL_WARN = 1 , LL_INFO = 2 , LL_DEBUG = 3 , LL_VERBOSE_DEBUG = 4 , _LL_MIN = -2 , _LL_MAX = 5 , LL_NONE = -1 , LL_ERROR = 0 , LL_WARN = 1 , LL_INFO = 2 , LL_DEBUG = 3 , LL_VERBOSE_DEBUG = 4 , _LL_MIN = -2 , _LL_MAX = 5 }

enum	json_type { JSON_TYPE_EOF = 0 , JSON_TYPE_STRING = 1 , JSON_TYPE_NUMBER = 2 , JSON_TYPE_OBJECT = 3 , JSON_TYPE_TRUE = 4 , JSON_TYPE_FALSE = 5 , JSON_TYPE_NULL = 6 , JSON_TYPE_ARRAY = 7 }

enum	mg_dns_resource_record_kind { MG_DNS_INVALID_RECORD = 0 , MG_DNS_QUESTION , MG_DNS_ANSWER , MG_DNS_INVALID_RECORD = 0 , MG_DNS_QUESTION , MG_DNS_ANSWER , MG_DNS_INVALID_RECORD = 0 , MG_DNS_QUESTION , MG_DNS_ANSWER }

enum	mg_resolve_err { MG_RESOLVE_OK = 0 , MG_RESOLVE_NO_ANSWERS = 1 , MG_RESOLVE_EXCEEDED_RETRY_COUNT = 2 , MG_RESOLVE_TIMEOUT = 3 , MG_RESOLVE_OK = 0 , MG_RESOLVE_NO_ANSWERS = 1 , MG_RESOLVE_EXCEEDED_RETRY_COUNT = 2 , MG_RESOLVE_TIMEOUT = 3 , MG_RESOLVE_OK = 0 , MG_RESOLVE_NO_ANSWERS = 1 , MG_RESOLVE_EXCEEDED_RETRY_COUNT = 2 , MG_RESOLVE_TIMEOUT = 3 }

Functions
void	cs_log_set_level (enum cs_log_level level)

void	cs_log_set_file (FILE *file)

void	cs_log_print_prefix (const char *func)

void	cs_log_printf (const char *fmt,...)

double	cs_time (void)

void	mbuf_init (struct mbuf *, size_t initial_capacity)

void	mbuf_free (struct mbuf *)

size_t	mbuf_append (struct mbuf , const void data, size_t data_size)

size_t	mbuf_insert (struct mbuf , size_t, const void , size_t)

void	mbuf_remove (struct mbuf *, size_t data_size)

void	mbuf_resize (struct mbuf *, size_t new_size)

void	mbuf_trim (struct mbuf *)

void	cs_sha1_init (cs_sha1_ctx *)

void	cs_sha1_update (cs_sha1_ctx , const unsigned char data, uint32_t len)

void	cs_sha1_final (unsigned char digest[20], cs_sha1_ctx *)

void	cs_hmac_sha1 (const unsigned char key, size_t key_len, const unsigned char text, size_t text_len, unsigned char out[20])

void	MD5_Init (MD5_CTX *c)

void	MD5_Update (MD5_CTX c, const unsigned char data, size_t len)

void	MD5_Final (unsigned char md, MD5_CTX c)

char *	cs_md5 (char buf[33],...)

void	cs_to_hex (char to, const unsigned char p, size_t len)

void	cs_base64_init (struct cs_base64_ctx ctx, cs_base64_putc_t putc, void user_data)

void	cs_base64_update (struct cs_base64_ctx ctx, const char str, size_t len)

void	cs_base64_finish (struct cs_base64_ctx *ctx)

void	cs_base64_encode (const unsigned char src, int src_len, char dst)

void	cs_fprint_base64 (FILE f, const unsigned char src, int src_len)

int	cs_base64_decode (const unsigned char s, int len, char dst)

size_t	c_strnlen (const char *s, size_t maxlen)

int	c_snprintf (char buf, size_t buf_size, const char format,...)

int	c_vsnprintf (char buf, size_t buf_size, const char format, va_list ap)

const char *	c_strnstr (const char s, const char find, size_t slen)

int	parse_json (const char json_string, int json_string_length, struct json_token tokens_array, int size_of_tokens_array)

struct json_token *	parse_json2 (const char *json_string, int string_length)

struct json_token *	find_json_token (struct json_token toks, const char path)

int	json_emit_long (char *buf, int buf_len, long value)

int	json_emit_double (char *buf, int buf_len, double value)

int	json_emit_quoted_str (char buf, int buf_len, const char str, int len)

int	json_emit_unquoted_str (char buf, int buf_len, const char str, int len)

int	json_emit (char buf, int buf_len, const char fmt,...)

int	json_emit_va (char buf, int buf_len, const char fmt, va_list)

void	mg_mgr_init (struct mg_mgr mgr, void user_data)

void	mg_mgr_free (struct mg_mgr *)

time_t	mg_mgr_poll (struct mg_mgr *, int milli)

void	mg_broadcast (struct mg_mgr , mg_event_handler_t func, void , size_t)

struct mg_connection *	mg_next (struct mg_mgr , struct mg_connection )

struct mg_connection *	mg_add_sock (struct mg_mgr *, sock_t, mg_event_handler_t)

struct mg_connection *	mg_add_sock_opt (struct mg_mgr *, sock_t, mg_event_handler_t, struct mg_add_sock_opts)

struct mg_connection *	mg_bind (struct mg_mgr , const char , mg_event_handler_t)

struct mg_connection *	mg_bind_opt (struct mg_mgr mgr, const char address, mg_event_handler_t handler, struct mg_bind_opts opts)

struct mg_connection *	mg_connect (struct mg_mgr mgr, const char address, mg_event_handler_t handler)

struct mg_connection *	mg_connect_opt (struct mg_mgr mgr, const char address, mg_event_handler_t handler, struct mg_connect_opts opts)

const char *	mg_set_ssl (struct mg_connection nc, const char cert, const char *ca_cert)

void	mg_send (struct mg_connection , const void buf, int len)

int	mg_printf (struct mg_connection , const char fmt,...)

int	mg_vprintf (struct mg_connection , const char fmt, va_list ap)

int	mg_socketpair (sock_t[2], int sock_type)

int	mg_resolve (const char domain_name, char ip_addr_buf, size_t buf_len)

int	mg_check_ip_acl (const char *acl, uint32_t remote_ip)

void	mg_enable_multithreading (struct mg_connection *nc)

double	mg_set_timer (struct mg_connection *c, double timestamp)

double	mg_time (void)

void	mg_if_connect_tcp (struct mg_connection nc, const union socket_address sa)

void	mg_if_connect_udp (struct mg_connection *nc)

void	mg_if_connect_cb (struct mg_connection *nc, int err)

int	mg_if_listen_tcp (struct mg_connection nc, union socket_address sa)

struct mg_connection *	mg_if_accept_new_conn (struct mg_connection *lc)

void	mg_if_accept_tcp_cb (struct mg_connection nc, union socket_address sa, size_t sa_len)

int	mg_if_listen_udp (struct mg_connection nc, union socket_address sa)

void	mg_if_tcp_send (struct mg_connection nc, const void buf, size_t len)

void	mg_if_udp_send (struct mg_connection nc, const void buf, size_t len)

void	mg_if_sent_cb (struct mg_connection *nc, int num_sent)

void	mg_if_recv_tcp_cb (struct mg_connection nc, void buf, int len)

void	mg_if_recv_udp_cb (struct mg_connection nc, void buf, int len, union socket_address *sa, size_t sa_len)

void	mg_if_recved (struct mg_connection *nc, size_t len)

void	mg_if_poll (struct mg_connection *nc, time_t now)

void	mg_if_timer (struct mg_connection *c, double now)

int	mg_if_create_conn (struct mg_connection *nc)

void	mg_if_destroy_conn (struct mg_connection *nc)

void	mg_close_conn (struct mg_connection *nc)

void	mg_if_get_conn_addr (struct mg_connection nc, int remote, union socket_address sa)

void	mg_sock_set (struct mg_connection *nc, sock_t sock)

int	mg_parse_uri (struct mg_str uri, struct mg_str scheme, struct mg_str user_info, struct mg_str host, unsigned int port, struct mg_str path, struct mg_str query, struct mg_str *fragment)

int	mg_normalize_uri_path (const struct mg_str in, struct mg_str out)

const char *	mg_skip (const char s, const char end_string, const char delimiters, struct mg_str v)

int	mg_ncasecmp (const char s1, const char s2, size_t len)

int	mg_casecmp (const char s1, const char s2)

int	mg_vcmp (const struct mg_str str2, const char str1)

int	mg_vcasecmp (const struct mg_str str2, const char str1)

int	mg_base64_decode (const unsigned char s, int len, char dst)

void	mg_base64_encode (const unsigned char src, int src_len, char dst)

int	mg_stat (const char path, cs_stat_t st)

FILE *	mg_fopen (const char path, const char mode)

int	mg_open (const char *path, int flag, int mode)

void	mg_set_close_on_exec (sock_t)

void	mg_conn_addr_to_str (struct mg_connection nc, char buf, size_t len, int flags)

void	mg_sock_to_str (sock_t sock, char *buf, size_t len, int flags)

void	mg_sock_addr_to_str (const union socket_address sa, char buf, size_t len, int flags)

int	mg_hexdump (const void buf, int len, char dst, int dst_len)

void	mg_hexdump_connection (struct mg_connection nc, const char path, const void *buf, int num_bytes, int ev)

int	mg_avprintf (char *buf, size_t size, const char fmt, va_list ap)

int	mg_is_big_endian (void)

const char *	mg_next_comma_list_entry (const char list, struct mg_str val, struct mg_str *eq_val)

int	mg_match_prefix (const char pattern, int pattern_len, const char str)

int	mg_match_prefix_n (const struct mg_str pattern, const struct mg_str str)

struct mg_str	mg_mk_str (const char *s)

void	mg_set_protocol_http_websocket (struct mg_connection *nc)

void	mg_send_websocket_handshake (struct mg_connection nc, const char uri, const char *extra_headers)

void	mg_send_websocket_handshake2 (struct mg_connection nc, const char path, const char host, const char protocol, const char *extra_headers)

struct mg_connection *	mg_connect_ws (struct mg_mgr mgr, mg_event_handler_t event_handler, const char url, const char protocol, const char extra_headers)

struct mg_connection *	mg_connect_ws_opt (struct mg_mgr mgr, mg_event_handler_t ev_handler, struct mg_connect_opts opts, const char url, const char protocol, const char extra_headers)

void	mg_send_websocket_frame (struct mg_connection nc, int op_and_flags, const void data, size_t data_len)

void	mg_send_websocket_framev (struct mg_connection nc, int op_and_flags, const struct mg_str strings, int num_strings)

void	mg_printf_websocket_frame (struct mg_connection nc, int op_and_flags, const char fmt,...)

void	mg_send_http_chunk (struct mg_connection nc, const char buf, size_t len)

void	mg_printf_http_chunk (struct mg_connection nc, const char fmt,...)

void	mg_send_response_line (struct mg_connection c, int status_code, const char extra_headers)

void	mg_send_head (struct mg_connection n, int status_code, int64_t content_length, const char extra_headers)

void	mg_printf_html_escape (struct mg_connection nc, const char fmt,...)

int	mg_parse_http (const char s, int n, struct http_message hm, int is_req)

struct mg_str *	mg_get_http_header (struct http_message hm, const char name)

int	mg_http_parse_header (struct mg_str hdr, const char var_name, char *buf, size_t buf_size)

size_t	mg_parse_multipart (const char buf, size_t buf_len, char var_name, size_t var_name_len, char file_name, size_t file_name_len, const char chunk, size_t chunk_len)

int	mg_get_http_var (const struct mg_str buf, const char name, char *dst, size_t dst_len)

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

int	mg_http_create_digest_auth_header (char buf, size_t buf_len, const char method, const char uri, const char auth_domain, const char user, const char passwd)

struct mg_connection *	mg_connect_http (struct mg_mgr mgr, mg_event_handler_t event_handler, const char url, const char extra_headers, const char post_data)

struct mg_connection *	mg_connect_http_opt (struct mg_mgr mgr, mg_event_handler_t ev_handler, struct mg_connect_opts opts, const char url, const char extra_headers, const char post_data)

void	mg_serve_http (struct mg_connection nc, struct http_message hm, struct mg_serve_http_opts opts)

void	mg_register_http_endpoint (struct mg_connection nc, const char uri_path, mg_event_handler_t handler)

int	mg_rpc_parse_reply (const char buf, int len, struct json_token toks, int max_toks, struct mg_rpc_reply , struct mg_rpc_error )

int	mg_rpc_create_request (char buf, int len, const char method, const char id, const char params_fmt,...)

int	mg_rpc_create_reply (char buf, int len, const struct mg_rpc_request req, const char *result_fmt,...)

int	mg_rpc_create_error (char buf, int len, struct mg_rpc_request req, int code, const char message, const char fmt,...)

int	mg_rpc_create_std_error (char buf, int len, struct mg_rpc_request req, int code)

int	mg_rpc_dispatch (const char buf, int, char dst, int dst_len, const char *methods, mg_rpc_handler_t handlers)

void	mg_set_protocol_mqtt (struct mg_connection *nc)

void	mg_send_mqtt_handshake (struct mg_connection nc, const char client_id)

void	mg_send_mqtt_handshake_opt (struct mg_connection nc, const char client_id, struct mg_send_mqtt_handshake_opts)

void	mg_mqtt_publish (struct mg_connection nc, const char topic, uint16_t message_id, int flags, const void *data, size_t len)

void	mg_mqtt_subscribe (struct mg_connection nc, const struct mg_mqtt_topic_expression topics, size_t topics_len, uint16_t message_id)

void	mg_mqtt_unsubscribe (struct mg_connection nc, char *topics, size_t topics_len, uint16_t message_id)

void	mg_mqtt_disconnect (struct mg_connection *nc)

void	mg_mqtt_connack (struct mg_connection *nc, uint8_t return_code)

void	mg_mqtt_puback (struct mg_connection *nc, uint16_t message_id)

void	mg_mqtt_pubrec (struct mg_connection *nc, uint16_t message_id)

void	mg_mqtt_pubrel (struct mg_connection *nc, uint16_t message_id)

void	mg_mqtt_pubcomp (struct mg_connection *nc, uint16_t message_id)

void	mg_mqtt_suback (struct mg_connection nc, uint8_t qoss, size_t qoss_len, uint16_t message_id)

void	mg_mqtt_unsuback (struct mg_connection *nc, uint16_t message_id)

void	mg_mqtt_ping (struct mg_connection *nc)

void	mg_mqtt_pong (struct mg_connection *nc)

int	mg_mqtt_next_subscribe_topic (struct mg_mqtt_message msg, struct mg_str topic, uint8_t *qos, int pos)

struct mg_dns_resource_record *	mg_dns_next_record (struct mg_dns_message msg, int query, struct mg_dns_resource_record prev)

int	mg_dns_parse_record_data (struct mg_dns_message msg, struct mg_dns_resource_record rr, void *data, size_t data_len)

void	mg_send_dns_query (struct mg_connection nc, const char name, int query_type)

int	mg_dns_insert_header (struct mbuf io, size_t pos, struct mg_dns_message msg)

int	mg_dns_copy_body (struct mbuf io, struct mg_dns_message msg)

int	mg_dns_encode_record (struct mbuf io, struct mg_dns_resource_record rr, const char name, size_t nlen, const void rdata, size_t rlen)

int	mg_parse_dns (const char buf, int len, struct mg_dns_message msg)

size_t	mg_dns_uncompress_name (struct mg_dns_message msg, struct mg_str name, char *dst, int dst_len)

void	mg_set_protocol_dns (struct mg_connection *nc)

int	mg_resolve_async (struct mg_mgr mgr, const char name, int query, mg_resolve_callback_t cb, void *data)

int	mg_resolve_async_opt (struct mg_mgr mgr, const char name, int query, mg_resolve_callback_t cb, void *data, struct mg_resolve_async_opts opts)

int	mg_resolve_from_hosts_file (const char host, union socket_address usa)

Variables
enum cs_log_level	cs_log_level

char *	mbuf::buf

size_t	mbuf::len

size_t	mbuf::size

uint32_t	cs_sha1_ctx::state [5]

uint32_t	cs_sha1_ctx::count [2]

unsigned char	cs_sha1_ctx::buffer [64]

uint32_t	MD5Context::buf [4]

uint32_t	MD5Context::bits [2]

unsigned char	MD5Context::in [64]

cs_base64_putc_t	cs_base64_ctx::b64_putc

unsigned char	cs_base64_ctx::chunk [3]

int	cs_base64_ctx::chunk_size

void *	cs_base64_ctx::user_data

const char *	json_token::ptr

int	json_token::len

int	json_token::num_desc

enum json_type	json_token::type

struct sockaddr	socket_address::sa

struct sockaddr_in	socket_address::sin

struct sockaddr	socket_address::sin6

const char *	mg_str::p

size_t	mg_str::len

struct mg_connection *	mg_mgr::active_connections

const char *	mg_mgr::hexdump_file

sock_t	mg_mgr::ctl [2]

void *	mg_mgr::user_data

void *	mg_mgr::mgr_data

struct mg_connection *	mg_connection::next

struct mg_connection *	mg_connection::prev

struct mg_connection *	mg_connection::listener

struct mg_mgr *	mg_connection::mgr

sock_t	mg_connection::sock

int	mg_connection::err

union socket_address	mg_connection::sa

size_t	mg_connection::recv_mbuf_limit

struct mbuf	mg_connection::recv_mbuf

struct mbuf	mg_connection::send_mbuf

SSL *	mg_connection::ssl

SSL_CTX *	mg_connection::ssl_ctx

time_t	mg_connection::last_io_time

double	mg_connection::ev_timer_time

mg_event_handler_t	mg_connection::proto_handler

void *	mg_connection::proto_data

void(*	mg_connection::proto_data_destructor )(void *proto_data)

mg_event_handler_t	mg_connection::handler

void *	mg_connection::user_data

void * mg_connection::v

mg_event_handler_t mg_connection::f

union {
void * mg_connection::v

mg_event_handler_t mg_connection::f

}	mg_connection::priv_1

void *	mg_connection::priv_2

void *	mg_connection::mgr_data

unsigned long	mg_connection::flags

void *	mg_add_sock_opts::user_data

unsigned int	mg_add_sock_opts::flags

const char **	mg_add_sock_opts::error_string

void *	mg_bind_opts::user_data

unsigned int	mg_bind_opts::flags

const char **	mg_bind_opts::error_string

void *	mg_connect_opts::user_data

unsigned int	mg_connect_opts::flags

const char **	mg_connect_opts::error_string

struct mg_str	http_message::message

struct mg_str	http_message::method

struct mg_str	http_message::uri

struct mg_str	http_message::proto

int	http_message::resp_code

struct mg_str	http_message::resp_status_msg

struct mg_str	http_message::query_string

struct mg_str	http_message::header_names [MG_MAX_HTTP_HEADERS]

struct mg_str	http_message::header_values [MG_MAX_HTTP_HEADERS]

struct mg_str	http_message::body

unsigned char *	websocket_message::data

size_t	websocket_message::size

unsigned char	websocket_message::flags

const char *	mg_http_multipart_part::file_name

const char *	mg_http_multipart_part::var_name

struct mg_str	mg_http_multipart_part::data

int	mg_http_multipart_part::status

void *	mg_http_multipart_part::user_data

const char *	mg_serve_http_opts::document_root

const char *	mg_serve_http_opts::index_files

const char *	mg_serve_http_opts::per_directory_auth_file

const char *	mg_serve_http_opts::auth_domain

const char *	mg_serve_http_opts::global_auth_file

const char *	mg_serve_http_opts::enable_directory_listing

const char *	mg_serve_http_opts::ssi_pattern

const char *	mg_serve_http_opts::ip_acl

const char *	mg_serve_http_opts::url_rewrites

const char *	mg_serve_http_opts::dav_document_root

const char *	mg_serve_http_opts::dav_auth_file

const char *	mg_serve_http_opts::hidden_file_pattern

const char *	mg_serve_http_opts::cgi_file_pattern

const char *	mg_serve_http_opts::cgi_interpreter

const char *	mg_serve_http_opts::custom_mime_types

const char *	mg_serve_http_opts::extra_headers

struct json_token *	mg_rpc_request::message

struct json_token *	mg_rpc_request::id

struct json_token *	mg_rpc_request::method

struct json_token *	mg_rpc_request::params

struct json_token *	mg_rpc_reply::message

struct json_token *	mg_rpc_reply::id

struct json_token *	mg_rpc_reply::result

struct json_token *	mg_rpc_error::message

struct json_token *	mg_rpc_error::id

struct json_token *	mg_rpc_error::error_code

struct json_token *	mg_rpc_error::error_message

struct json_token *	mg_rpc_error::error_data

int	mg_mqtt_message::cmd

struct mg_str	mg_mqtt_message::payload

int	mg_mqtt_message::qos

uint8_t	mg_mqtt_message::connack_ret_code

uint16_t	mg_mqtt_message::message_id

char *	mg_mqtt_message::topic

const char *	mg_mqtt_topic_expression::topic

uint8_t	mg_mqtt_topic_expression::qos

unsigned char	mg_send_mqtt_handshake_opts::flags

uint16_t	mg_send_mqtt_handshake_opts::keep_alive

const char *	mg_send_mqtt_handshake_opts::will_topic

const char *	mg_send_mqtt_handshake_opts::will_message

const char *	mg_send_mqtt_handshake_opts::user_name

const char *	mg_send_mqtt_handshake_opts::password

struct mg_str	mg_dns_resource_record::name

int	mg_dns_resource_record::rtype

int	mg_dns_resource_record::rclass

int	mg_dns_resource_record::ttl

enum mg_dns_resource_record_kind	mg_dns_resource_record::kind

struct mg_str	mg_dns_resource_record::rdata

struct mg_str	mg_dns_message::pkt

uint16_t	mg_dns_message::flags

uint16_t	mg_dns_message::transaction_id

int	mg_dns_message::num_questions

int	mg_dns_message::num_answers

struct mg_dns_resource_record	mg_dns_message::questions [MG_MAX_DNS_QUESTIONS]

struct mg_dns_resource_record	mg_dns_message::answers [MG_MAX_DNS_ANSWERS]

const char *	mg_resolve_async_opts::nameserver_url

int	mg_resolve_async_opts::max_retries

int	mg_resolve_async_opts::timeout

int	mg_resolve_async_opts::accept_literal

int	mg_resolve_async_opts::only_literal

struct mg_connection **	mg_resolve_async_opts::dns_conn

Detailed Description

Macro Definition Documentation

◆ ARRAY_SIZE

#define ARRAY_SIZE ( array ) (sizeof(array) / sizeof(array[0]))

Definition at line 119 of file mongoose6.h.

◆ CS_COMMON_BASE64_H_

#define CS_COMMON_BASE64_H_

Definition at line 967 of file mongoose6.h.

◆ CS_COMMON_CS_DBG_H_

#define CS_COMMON_CS_DBG_H_

Definition at line 739 of file mongoose6.h.

◆ CS_COMMON_CS_DIRENT_H_

#define CS_COMMON_CS_DIRENT_H_

Definition at line 1106 of file mongoose6.h.

◆ CS_COMMON_CS_TIME_H_

#define CS_COMMON_CS_TIME_H_

Definition at line 799 of file mongoose6.h.

◆ CS_COMMON_MBUF_H_

#define CS_COMMON_MBUF_H_

Definition at line 820 of file mongoose6.h.

◆ CS_COMMON_MD5_H_

#define CS_COMMON_MD5_H_

Definition at line 923 of file mongoose6.h.

◆ CS_COMMON_PLATFORM_H_

#define CS_COMMON_PLATFORM_H_

Definition at line 70 of file mongoose6.h.

◆ CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_

#define CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_

Definition at line 419 of file mongoose6.h.

◆ CS_COMMON_PLATFORMS_PLATFORM_ESP_LWIP_H_

#define CS_COMMON_PLATFORMS_PLATFORM_ESP_LWIP_H_

Definition at line 363 of file mongoose6.h.

◆ CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_

#define CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_

Definition at line 536 of file mongoose6.h.

◆ CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_

#define CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_

Definition at line 266 of file mongoose6.h.

◆ CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_

#define CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_

Definition at line 124 of file mongoose6.h.

◆ CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_

#define CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_

Definition at line 630 of file mongoose6.h.

◆ CS_COMMON_SHA1_H_

#define CS_COMMON_SHA1_H_

Definition at line 889 of file mongoose6.h.

◆ CS_COMMON_STR_UTIL_H_

#define CS_COMMON_STR_UTIL_H_

Definition at line 1009 of file mongoose6.h.

◆ CS_MONGOOSE_DEPS_FROZEN_FROZEN_H_

#define CS_MONGOOSE_DEPS_FROZEN_FROZEN_H_

Definition at line 1052 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_COAP_H_

#define CS_MONGOOSE_SRC_COAP_H_

Definition at line 3501 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_DNS_H_

#define CS_MONGOOSE_SRC_DNS_H_

Definition at line 3156 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_DNS_SERVER_H_

#define CS_MONGOOSE_SRC_DNS_SERVER_H_

Definition at line 3311 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_HTTP_H_

#define CS_MONGOOSE_SRC_HTTP_H_

Definition at line 2023 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_JSON_RPC_H_

#define CS_MONGOOSE_SRC_JSON_RPC_H_

Definition at line 2723 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_MQTT_BROKER_H_

#define CS_MONGOOSE_SRC_MQTT_BROKER_H_

Definition at line 3068 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_MQTT_H_

#define CS_MONGOOSE_SRC_MQTT_H_

Definition at line 2873 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_NET_H_

#define CS_MONGOOSE_SRC_NET_H_

Definition at line 1160 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_NET_IF_H_

#define CS_MONGOOSE_SRC_NET_IF_H_

Definition at line 1659 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_RESOLV_H_

#define CS_MONGOOSE_SRC_RESOLV_H_

Definition at line 3402 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_URI_H_

#define CS_MONGOOSE_SRC_URI_H_

Definition at line 1743 of file mongoose6.h.

◆ CS_MONGOOSE_SRC_UTIL_H_

#define CS_MONGOOSE_SRC_UTIL_H_

Definition at line 1794 of file mongoose6.h.

◆ CS_P_CC3200

#define CS_P_CC3200 4

Definition at line 80 of file mongoose6.h.

◆ CS_P_CUSTOM

#define CS_P_CUSTOM 0

Definition at line 76 of file mongoose6.h.

◆ CS_P_ESP_LWIP

#define CS_P_ESP_LWIP 3

Definition at line 79 of file mongoose6.h.

◆ CS_P_MSP432

#define CS_P_MSP432 5

Definition at line 81 of file mongoose6.h.

◆ CS_P_UNIX

#define CS_P_UNIX 1

Definition at line 77 of file mongoose6.h.

◆ CS_P_WINDOWS

#define CS_P_WINDOWS 2

Definition at line 78 of file mongoose6.h.

◆ DBG

#define DBG ( x )

Value:

  if (cs_log_level >= LL_VERBOSE_DEBUG) { \
    cs_log_print_prefix(__func__);        \
    cs_log_printf x;                      \
  }

Definition at line 773 of file mongoose6.h.

◆ JSON_RPC_INTERNAL_ERROR

#define JSON_RPC_INTERNAL_ERROR (-32603)

Definition at line 2810 of file mongoose6.h.

◆ JSON_RPC_INVALID_PARAMS_ERROR

#define JSON_RPC_INVALID_PARAMS_ERROR (-32602)

Definition at line 2809 of file mongoose6.h.

◆ JSON_RPC_INVALID_REQUEST_ERROR

#define JSON_RPC_INVALID_REQUEST_ERROR (-32600)

Definition at line 2807 of file mongoose6.h.

◆ JSON_RPC_METHOD_NOT_FOUND_ERROR

#define JSON_RPC_METHOD_NOT_FOUND_ERROR (-32601)

Definition at line 2808 of file mongoose6.h.

◆ JSON_RPC_PARSE_ERROR

#define JSON_RPC_PARSE_ERROR (-32700)

Definition at line 2806 of file mongoose6.h.

◆ JSON_RPC_SERVER_ERROR

#define JSON_RPC_SERVER_ERROR (-32000)

Definition at line 2811 of file mongoose6.h.

◆ JSON_STRING_INCOMPLETE

#define JSON_STRING_INCOMPLETE -2

Definition at line 1080 of file mongoose6.h.

◆ JSON_STRING_INVALID

#define JSON_STRING_INVALID -1

Definition at line 1079 of file mongoose6.h.

◆ JSON_TOKEN_ARRAY_TOO_SMALL

#define JSON_TOKEN_ARRAY_TOO_SMALL -3

Definition at line 1081 of file mongoose6.h.

◆ LOG

#define LOG	(	l,
		x
	)

Value:

  if (cs_log_level >= l) {         \
    cs_log_print_prefix(__func__); \
    cs_log_printf x;               \
  }

Definition at line 765 of file mongoose6.h.

◆ MAX_PATH_SIZE

#define MAX_PATH_SIZE 500

Definition at line 1804 of file mongoose6.h.

◆ MBUF_SIZE_MULTIPLIER

#define MBUF_SIZE_MULTIPLIER 1.5

Definition at line 829 of file mongoose6.h.

◆ MG_CGI_ENVIRONMENT_SIZE

#define MG_CGI_ENVIRONMENT_SIZE 8192

Definition at line 2055 of file mongoose6.h.

◆ MG_DNS_A_RECORD

#define MG_DNS_A_RECORD 0x01 /* Lookup IP address */

Definition at line 3163 of file mongoose6.h.

◆ MG_DNS_AAAA_RECORD

#define MG_DNS_AAAA_RECORD 0x1c /* Lookup IPv6 address */

Definition at line 3165 of file mongoose6.h.

◆ MG_DNS_CNAME_RECORD

#define MG_DNS_CNAME_RECORD 0x05 /* Lookup CNAME */

Definition at line 3164 of file mongoose6.h.

◆ MG_DNS_MESSAGE

#define MG_DNS_MESSAGE 100 /* High-level DNS message event */

Definition at line 3171 of file mongoose6.h.

◆ MG_DNS_MX_RECORD

#define MG_DNS_MX_RECORD 0x0f /* Lookup mail server for domain */

Definition at line 3166 of file mongoose6.h.

◆ MG_ENV_EXPORT_TO_CGI

#define MG_ENV_EXPORT_TO_CGI "MONGOOSE_CGI"

Definition at line 2063 of file mongoose6.h.

◆ MG_EV_ACCEPT

#define MG_EV_ACCEPT 1 /* New connection accepted. union socket_address * */

Definition at line 1220 of file mongoose6.h.

◆ MG_EV_CLOSE

#define MG_EV_CLOSE 5 /* Connection is closed. NULL */

Definition at line 1224 of file mongoose6.h.

◆ MG_EV_CONNECT

#define MG_EV_CONNECT 2 /* connect() succeeded or failed. int * */

Definition at line 1221 of file mongoose6.h.

◆ MG_EV_HTTP_CHUNK

#define MG_EV_HTTP_CHUNK 102 /* struct http_message * */

Definition at line 2116 of file mongoose6.h.

◆ MG_EV_HTTP_REPLY

#define MG_EV_HTTP_REPLY 101 /* struct http_message * */

Definition at line 2115 of file mongoose6.h.

◆ MG_EV_HTTP_REQUEST

#define MG_EV_HTTP_REQUEST 100 /* struct http_message * */

Definition at line 2114 of file mongoose6.h.

◆ MG_EV_MQTT_CONNACK

#define MG_EV_MQTT_CONNACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNACK)

Definition at line 2918 of file mongoose6.h.

◆ MG_EV_MQTT_CONNACK_ACCEPTED

#define MG_EV_MQTT_CONNACK_ACCEPTED 0

Definition at line 2950 of file mongoose6.h.

◆ MG_EV_MQTT_CONNACK_BAD_AUTH

#define MG_EV_MQTT_CONNACK_BAD_AUTH 4

Definition at line 2954 of file mongoose6.h.

◆ MG_EV_MQTT_CONNACK_IDENTIFIER_REJECTED

#define MG_EV_MQTT_CONNACK_IDENTIFIER_REJECTED 2

Definition at line 2952 of file mongoose6.h.

◆ MG_EV_MQTT_CONNACK_NOT_AUTHORIZED

#define MG_EV_MQTT_CONNACK_NOT_AUTHORIZED 5

Definition at line 2955 of file mongoose6.h.

◆ MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE

#define MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE 3

Definition at line 2953 of file mongoose6.h.

◆ MG_EV_MQTT_CONNACK_UNACCEPTABLE_VERSION

#define MG_EV_MQTT_CONNACK_UNACCEPTABLE_VERSION 1

Definition at line 2951 of file mongoose6.h.

◆ MG_EV_MQTT_CONNECT

#define MG_EV_MQTT_CONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNECT)

Definition at line 2917 of file mongoose6.h.

◆ MG_EV_MQTT_DISCONNECT

#define MG_EV_MQTT_DISCONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_DISCONNECT)

Definition at line 2930 of file mongoose6.h.

◆ MG_EV_MQTT_PINGREQ

#define MG_EV_MQTT_PINGREQ (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGREQ)

Definition at line 2928 of file mongoose6.h.

◆ MG_EV_MQTT_PINGRESP

#define MG_EV_MQTT_PINGRESP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGRESP)

Definition at line 2929 of file mongoose6.h.

◆ MG_EV_MQTT_PUBACK

#define MG_EV_MQTT_PUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBACK)

Definition at line 2920 of file mongoose6.h.

◆ MG_EV_MQTT_PUBCOMP

#define MG_EV_MQTT_PUBCOMP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBCOMP)

Definition at line 2923 of file mongoose6.h.

◆ MG_EV_MQTT_PUBLISH

#define MG_EV_MQTT_PUBLISH (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBLISH)

Definition at line 2919 of file mongoose6.h.

◆ MG_EV_MQTT_PUBREC

#define MG_EV_MQTT_PUBREC (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREC)

Definition at line 2921 of file mongoose6.h.

◆ MG_EV_MQTT_PUBREL

#define MG_EV_MQTT_PUBREL (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREL)

Definition at line 2922 of file mongoose6.h.

◆ MG_EV_MQTT_SUBACK

#define MG_EV_MQTT_SUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBACK)

Definition at line 2925 of file mongoose6.h.

◆ MG_EV_MQTT_SUBSCRIBE

#define MG_EV_MQTT_SUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBSCRIBE)

Definition at line 2924 of file mongoose6.h.

◆ MG_EV_MQTT_UNSUBACK

#define MG_EV_MQTT_UNSUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBACK)

Definition at line 2927 of file mongoose6.h.

◆ MG_EV_MQTT_UNSUBSCRIBE

#define MG_EV_MQTT_UNSUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBSCRIBE)

Definition at line 2926 of file mongoose6.h.

◆ MG_EV_POLL

#define MG_EV_POLL 0 /* Sent to each connection on each mg_mgr_poll() call */

Definition at line 1219 of file mongoose6.h.

◆ MG_EV_RECV

#define MG_EV_RECV 3 /* Data has benn received. int *num_bytes */

Definition at line 1222 of file mongoose6.h.

◆ MG_EV_SEND

#define MG_EV_SEND 4 /* Data has been written to a socket. int *num_bytes */

Definition at line 1223 of file mongoose6.h.

◆ MG_EV_SSI_CALL

#define MG_EV_SSI_CALL 105 /* char * */

Definition at line 2117 of file mongoose6.h.

◆ MG_EV_TIMER

#define MG_EV_TIMER 6 /* now >= conn->ev_timer_time. double * */

Definition at line 1225 of file mongoose6.h.

◆ MG_EV_WEBSOCKET_CONTROL_FRAME

#define MG_EV_WEBSOCKET_CONTROL_FRAME 114 /* struct websocket_message * */

Definition at line 2122 of file mongoose6.h.

◆ MG_EV_WEBSOCKET_FRAME

#define MG_EV_WEBSOCKET_FRAME 113 /* struct websocket_message * */

Definition at line 2121 of file mongoose6.h.

◆ MG_EV_WEBSOCKET_HANDSHAKE_DONE

#define MG_EV_WEBSOCKET_HANDSHAKE_DONE 112 /* NULL */

Definition at line 2120 of file mongoose6.h.

◆ MG_EV_WEBSOCKET_HANDSHAKE_REQUEST

#define MG_EV_WEBSOCKET_HANDSHAKE_REQUEST 111 /* NULL */

Definition at line 2119 of file mongoose6.h.

◆ MG_F_CLOSE_IMMEDIATELY

#define MG_F_CLOSE_IMMEDIATELY (1 << 11) /* Disconnect */

Definition at line 1289 of file mongoose6.h.

◆ MG_F_CONNECTING

#define MG_F_CONNECTING (1 << 3) /* connect() call in progress */

Definition at line 1281 of file mongoose6.h.

◆ MG_F_DELETE_CHUNK

#define MG_F_DELETE_CHUNK (1 << 13) /* HTTP specific */

Definition at line 1291 of file mongoose6.h.

◆ MG_F_IS_WEBSOCKET

#define MG_F_IS_WEBSOCKET (1 << 7) /* Websocket specific */

Definition at line 1285 of file mongoose6.h.

◆ MG_F_LISTENING

#define MG_F_LISTENING (1 << 0) /* This connection is listening */

Definition at line 1278 of file mongoose6.h.

◆ MG_F_RESOLVING

#define MG_F_RESOLVING (1 << 2) /* Waiting for async resolver */

Definition at line 1280 of file mongoose6.h.

◆ MG_F_SEND_AND_CLOSE

#define MG_F_SEND_AND_CLOSE (1 << 10) /* Push remaining data and close */

Definition at line 1288 of file mongoose6.h.

◆ MG_F_SSL_HANDSHAKE_DONE

#define MG_F_SSL_HANDSHAKE_DONE (1 << 4) /* SSL specific */

Definition at line 1282 of file mongoose6.h.

◆ MG_F_UDP

#define MG_F_UDP (1 << 1) /* This connection is UDP */

Definition at line 1279 of file mongoose6.h.

◆ MG_F_USER_1

#define MG_F_USER_1 (1 << 20) /* Flags left for application */

Definition at line 1293 of file mongoose6.h.

◆ MG_F_USER_2

#define MG_F_USER_2 (1 << 21)

Definition at line 1294 of file mongoose6.h.

◆ MG_F_USER_3

#define MG_F_USER_3 (1 << 22)

Definition at line 1295 of file mongoose6.h.

◆ MG_F_USER_4

#define MG_F_USER_4 (1 << 23)

Definition at line 1296 of file mongoose6.h.

◆ MG_F_USER_5

#define MG_F_USER_5 (1 << 24)

Definition at line 1297 of file mongoose6.h.

◆ MG_F_USER_6

#define MG_F_USER_6 (1 << 25)

Definition at line 1298 of file mongoose6.h.

◆ MG_F_WANT_READ

#define MG_F_WANT_READ (1 << 5) /* SSL specific */

Definition at line 1283 of file mongoose6.h.

◆ MG_F_WANT_WRITE

#define MG_F_WANT_WRITE (1 << 6) /* SSL specific */

Definition at line 1284 of file mongoose6.h.

◆ MG_F_WEBSOCKET_NO_DEFRAG

#define MG_F_WEBSOCKET_NO_DEFRAG (1 << 12) /* Websocket specific */

Definition at line 1290 of file mongoose6.h.

◆ MG_MAX_CGI_ENVIR_VARS

#define MG_MAX_CGI_ENVIR_VARS 64

Definition at line 2059 of file mongoose6.h.

◆ MG_MAX_DNS_ANSWERS

#define MG_MAX_DNS_ANSWERS 32

Definition at line 3169 of file mongoose6.h.

◆ MG_MAX_DNS_QUESTIONS

#define MG_MAX_DNS_QUESTIONS 32

Definition at line 3168 of file mongoose6.h.

◆ MG_MAX_HTTP_HEADERS

#define MG_MAX_HTTP_HEADERS 20

Definition at line 2031 of file mongoose6.h.

◆ MG_MAX_HTTP_REQUEST_SIZE

#define MG_MAX_HTTP_REQUEST_SIZE 1024

Definition at line 2035 of file mongoose6.h.

◆ MG_MAX_HTTP_SEND_MBUF

#define MG_MAX_HTTP_SEND_MBUF 1024

Definition at line 2047 of file mongoose6.h.

◆ MG_MAX_PATH

#define MG_MAX_PATH 256

Definition at line 2042 of file mongoose6.h.

◆ MG_MK_STR

#define MG_MK_STR ( str_literal ) { str_literal, sizeof(str_literal) - 1 }

Definition at line 2006 of file mongoose6.h.

◆ MG_MQTT_CLEAN_SESSION

#define MG_MQTT_CLEAN_SESSION 0x02

Definition at line 2940 of file mongoose6.h.

◆ MG_MQTT_CMD_CONNACK

#define MG_MQTT_CMD_CONNACK 2

Definition at line 2901 of file mongoose6.h.

◆ MG_MQTT_CMD_CONNECT

#define MG_MQTT_CMD_CONNECT 1

Definition at line 2900 of file mongoose6.h.

◆ MG_MQTT_CMD_DISCONNECT

#define MG_MQTT_CMD_DISCONNECT 14

Definition at line 2913 of file mongoose6.h.

◆ MG_MQTT_CMD_PINGREQ

#define MG_MQTT_CMD_PINGREQ 12

Definition at line 2911 of file mongoose6.h.

◆ MG_MQTT_CMD_PINGRESP

#define MG_MQTT_CMD_PINGRESP 13

Definition at line 2912 of file mongoose6.h.

◆ MG_MQTT_CMD_PUBACK

#define MG_MQTT_CMD_PUBACK 4

Definition at line 2903 of file mongoose6.h.

◆ MG_MQTT_CMD_PUBCOMP

#define MG_MQTT_CMD_PUBCOMP 7

Definition at line 2906 of file mongoose6.h.

◆ MG_MQTT_CMD_PUBLISH

#define MG_MQTT_CMD_PUBLISH 3

Definition at line 2902 of file mongoose6.h.

◆ MG_MQTT_CMD_PUBREC

#define MG_MQTT_CMD_PUBREC 5

Definition at line 2904 of file mongoose6.h.

◆ MG_MQTT_CMD_PUBREL

#define MG_MQTT_CMD_PUBREL 6

Definition at line 2905 of file mongoose6.h.

◆ MG_MQTT_CMD_SUBACK

#define MG_MQTT_CMD_SUBACK 9

Definition at line 2908 of file mongoose6.h.

◆ MG_MQTT_CMD_SUBSCRIBE

#define MG_MQTT_CMD_SUBSCRIBE 8

Definition at line 2907 of file mongoose6.h.

◆ MG_MQTT_CMD_UNSUBACK

#define MG_MQTT_CMD_UNSUBACK 11

Definition at line 2910 of file mongoose6.h.

◆ MG_MQTT_CMD_UNSUBSCRIBE

#define MG_MQTT_CMD_UNSUBSCRIBE 10

Definition at line 2909 of file mongoose6.h.

◆ MG_MQTT_DUP

#define MG_MQTT_DUP 0x4

Definition at line 2934 of file mongoose6.h.

◆ MG_MQTT_EVENT_BASE

#define MG_MQTT_EVENT_BASE 200

Definition at line 2916 of file mongoose6.h.

◆ MG_MQTT_GET_QOS

#define MG_MQTT_GET_QOS ( flags ) (((flags) &0x6) >> 1)

Definition at line 2936 of file mongoose6.h.

◆ MG_MQTT_GET_WILL_QOS

#define MG_MQTT_GET_WILL_QOS ( flags ) (((flags) &0x18) >> 3)

Definition at line 2945 of file mongoose6.h.

◆ MG_MQTT_HAS_PASSWORD

#define MG_MQTT_HAS_PASSWORD 0x40

Definition at line 2943 of file mongoose6.h.

◆ MG_MQTT_HAS_USER_NAME

#define MG_MQTT_HAS_USER_NAME 0x80

Definition at line 2944 of file mongoose6.h.

◆ MG_MQTT_HAS_WILL

#define MG_MQTT_HAS_WILL 0x04

Definition at line 2941 of file mongoose6.h.

◆ MG_MQTT_QOS

#define MG_MQTT_QOS ( qos ) ((qos) << 1)

Definition at line 2935 of file mongoose6.h.

◆ MG_MQTT_RETAIN

#define MG_MQTT_RETAIN 0x1

Definition at line 2933 of file mongoose6.h.

◆ MG_MQTT_SET_QOS

#define MG_MQTT_SET_QOS	(	flags,
		qos
	)	(flags) = ((flags) & ~0x6) \| ((qos) << 1)

Definition at line 2937 of file mongoose6.h.

◆ MG_MQTT_SET_WILL_QOS

#define MG_MQTT_SET_WILL_QOS	(	flags,
		qos
	)	(flags) = ((flags) & ~0x18) \| ((qos) << 3)

Definition at line 2946 of file mongoose6.h.

◆ MG_MQTT_WILL_RETAIN

#define MG_MQTT_WILL_RETAIN 0x20

Definition at line 2942 of file mongoose6.h.

◆ MG_RECV_FUNC

#define MG_RECV_FUNC	(	s,
		b,
		l,
		f
	)	recv(s, b, l, f)

Definition at line 1186 of file mongoose6.h.

◆ MG_SEND_FUNC

#define MG_SEND_FUNC	(	s,
		b,
		l,
		f
	)	send(s, b, l, f)

Definition at line 1187 of file mongoose6.h.

◆ MG_SOCK_STRINGIFY_IP

#define MG_SOCK_STRINGIFY_IP 1

Definition at line 1904 of file mongoose6.h.

◆ MG_SOCK_STRINGIFY_PORT

#define MG_SOCK_STRINGIFY_PORT 2

Definition at line 1905 of file mongoose6.h.

◆ MG_SOCK_STRINGIFY_REMOTE

#define MG_SOCK_STRINGIFY_REMOTE 4

Definition at line 1906 of file mongoose6.h.

◆ MG_VERSION

#define MG_VERSION "6.4"

Definition at line 26 of file mongoose6.h.

◆ MG_VPRINTF_BUFFER_SIZE

#define MG_VPRINTF_BUFFER_SIZE 100

Definition at line 1179 of file mongoose6.h.

◆ MG_WEBSOCKET_PING_INTERVAL_SECONDS

#define MG_WEBSOCKET_PING_INTERVAL_SECONDS 5

Definition at line 2051 of file mongoose6.h.

◆ NOINLINE

#define NOINLINE

Definition at line 114 of file mongoose6.h.

◆ NORETURN

#define NORETURN

Definition at line 112 of file mongoose6.h.

◆ UNUSED

#define UNUSED

Definition at line 113 of file mongoose6.h.

◆ WARN_UNUSED_RESULT

#define WARN_UNUSED_RESULT

Definition at line 115 of file mongoose6.h.

◆ WEBSOCKET_DONT_FIN

#define WEBSOCKET_DONT_FIN 0x100

Definition at line 2365 of file mongoose6.h.

◆ WEBSOCKET_OP_BINARY

#define WEBSOCKET_OP_BINARY 2

Definition at line 2348 of file mongoose6.h.

◆ WEBSOCKET_OP_CLOSE

#define WEBSOCKET_OP_CLOSE 8

Definition at line 2349 of file mongoose6.h.

◆ WEBSOCKET_OP_CONTINUE

#define WEBSOCKET_OP_CONTINUE 0

Definition at line 2346 of file mongoose6.h.

◆ WEBSOCKET_OP_PING

#define WEBSOCKET_OP_PING 9

Definition at line 2350 of file mongoose6.h.

◆ WEBSOCKET_OP_PONG

#define WEBSOCKET_OP_PONG 10

Definition at line 2351 of file mongoose6.h.

◆ WEBSOCKET_OP_TEXT

#define WEBSOCKET_OP_TEXT 1

Definition at line 2347 of file mongoose6.h.

Typedef Documentation

◆ cs_base64_putc_t

typedef void(* cs_base64_putc_t) (char, void *)

Definition at line 977 of file mongoose6.h.

◆ MD5_CTX

typedef struct MD5Context MD5_CTX

◆ mg_event_handler_t

typedef void(* mg_event_handler_t) (struct mg_connection *, int ev, void *)

Definition at line 1216 of file mongoose6.h.

◆ mg_resolve_callback_t

typedef void(* mg_resolve_callback_t) (struct mg_dns_message *dns_message, void *user_data, enum mg_resolve_err)

Definition at line 3416 of file mongoose6.h.

◆ mg_rpc_handler_t

typedef int(* mg_rpc_handler_t) (char *buf, int len, struct mg_rpc_request *req)

Definition at line 2830 of file mongoose6.h.

◆ SSL

typedef void* SSL

Definition at line 1174 of file mongoose6.h.

◆ SSL_CTX

typedef void* SSL_CTX

Definition at line 1175 of file mongoose6.h.

Enumeration Type Documentation

◆ cs_log_level

enum cs_log_level

Enumerator
LL_NONE
LL_ERROR
LL_WARN
LL_INFO
LL_DEBUG
LL_VERBOSE_DEBUG
_LL_MIN
_LL_MAX
LL_NONE
LL_ERROR
LL_WARN
LL_INFO
LL_DEBUG
LL_VERBOSE_DEBUG
_LL_MIN
_LL_MAX
LL_NONE
LL_ERROR
LL_WARN
LL_INFO
LL_DEBUG
LL_VERBOSE_DEBUG
_LL_MIN
_LL_MAX

Definition at line 741 of file mongoose6.h.

                   {
   LL_NONE = -1,
   LL_ERROR = 0,
   LL_WARN = 1,
   LL_INFO = 2,
   LL_DEBUG = 3,
   LL_VERBOSE_DEBUG = 4,
  
   _LL_MIN = -2,
   _LL_MAX = 5,
 };

◆ json_type

enum json_type

Enumerator
JSON_TYPE_EOF
JSON_TYPE_STRING
JSON_TYPE_NUMBER
JSON_TYPE_OBJECT
JSON_TYPE_TRUE
JSON_TYPE_FALSE
JSON_TYPE_NULL
JSON_TYPE_ARRAY

Definition at line 1060 of file mongoose6.h.

                {
   JSON_TYPE_EOF = 0, /* End of parsed tokens marker */
   JSON_TYPE_STRING = 1,
   JSON_TYPE_NUMBER = 2,
   JSON_TYPE_OBJECT = 3,
   JSON_TYPE_TRUE = 4,
   JSON_TYPE_FALSE = 5,
   JSON_TYPE_NULL = 6,
   JSON_TYPE_ARRAY = 7
 };

◆ mg_dns_resource_record_kind

enum mg_dns_resource_record_kind

Enumerator
MG_DNS_INVALID_RECORD
MG_DNS_QUESTION
MG_DNS_ANSWER
MG_DNS_INVALID_RECORD
MG_DNS_QUESTION
MG_DNS_ANSWER
MG_DNS_INVALID_RECORD
MG_DNS_QUESTION
MG_DNS_ANSWER

Definition at line 3173 of file mongoose6.h.

                                  {
   MG_DNS_INVALID_RECORD = 0,
   MG_DNS_QUESTION,
   MG_DNS_ANSWER
 };

◆ mg_resolve_err

enum mg_resolve_err

Enumerator
MG_RESOLVE_OK
MG_RESOLVE_NO_ANSWERS
MG_RESOLVE_EXCEEDED_RETRY_COUNT
MG_RESOLVE_TIMEOUT
MG_RESOLVE_OK
MG_RESOLVE_NO_ANSWERS
MG_RESOLVE_EXCEEDED_RETRY_COUNT
MG_RESOLVE_TIMEOUT
MG_RESOLVE_OK
MG_RESOLVE_NO_ANSWERS
MG_RESOLVE_EXCEEDED_RETRY_COUNT
MG_RESOLVE_TIMEOUT

Definition at line 3409 of file mongoose6.h.

                     {
   MG_RESOLVE_OK = 0,
   MG_RESOLVE_NO_ANSWERS = 1,
   MG_RESOLVE_EXCEEDED_RETRY_COUNT = 2,
   MG_RESOLVE_TIMEOUT = 3
 };

Function Documentation

◆ c_snprintf()

int c_snprintf	(	char *	buf,
		size_t	buf_size,
		const char *	format,
			...
	)

Definition at line 2061 of file mongoose614.cxx.

                                                                  {
   int result;
   va_list ap;
   va_start(ap, fmt);
   result = c_vsnprintf(buf, buf_size, fmt, ap);
   va_end(ap);
   return result;
 }

Here is the call graph for this function:

◆ c_strnlen()

size_t c_strnlen	(	const char *	s,
		size_t	maxlen
	)

Definition at line 1860 of file mongoose614.cxx.

                                                {
   size_t l = 0;
   for (; l < maxlen && s[l] != '\0'; l++) {
   }
   return l;
 }

◆ c_strnstr()

const char * c_strnstr	(	const char *	s,
		const char *	find,
		size_t	slen
	)

Definition at line 2102 of file mongoose614.cxx.

                                                                     {
   size_t find_length = strlen(find);
   size_t i;
  
   for (i = 0; i < slen; i++) {
     if (i + find_length > slen) {
       return NULL;
     }
  
     if (strncmp(&s[i], find, find_length) == 0) {
       return &s[i];
     }
   }
  
   return NULL;
 }

◆ c_vsnprintf()

int c_vsnprintf	(	char *	buf,
		size_t	buf_size,
		const char *	format,
		va_list	ap
	)

Definition at line 1923 of file mongoose614.cxx.

                                                                          {
   int ch, i = 0, len_mod, flags, precision, field_width;
  
   while ((ch = *fmt++) != '\0') {
     if (ch != '%') {
       C_SNPRINTF_APPEND_CHAR(ch);
     } else {
       /*
        * Conversion specification:
        *   zero or more flags (one of: # 0 - <space> + ')
        *   an optional minimum  field  width (digits)
        *   an  optional precision (. followed by digits, or *)
        *   an optional length modifier (one of: hh h l ll L q j z t)
        *   conversion specifier (one of: d i o u x X e E f F g G a A c s p n)
        */
       flags = field_width = precision = len_mod = 0;
  
       /* Flags. only zero-pad flag is supported. */
       if (*fmt == '0') {
         flags |= C_SNPRINTF_FLAG_ZERO;
       }
  
       /* Field width */
       while (*fmt >= '0' && *fmt <= '9') {
         field_width *= 10;
         field_width += *fmt++ - '0';
       }
       /* Dynamic field width */
       if (*fmt == '*') {
         field_width = va_arg(ap, int);
         fmt++;
       }
  
       /* Precision */
       if (*fmt == '.') {
         fmt++;
         if (*fmt == '*') {
           precision = va_arg(ap, int);
           fmt++;
         } else {
           while (*fmt >= '0' && *fmt <= '9') {
             precision *= 10;
             precision += *fmt++ - '0';
           }
         }
       }
  
       /* Length modifier */
       switch (*fmt) {
         case 'h':
         case 'l':
         case 'L':
         case 'I':
         case 'q':
         case 'j':
         case 'z':
         case 't':
           len_mod = *fmt++;
           if (*fmt == 'h') {
             len_mod = 'H';
             fmt++;
           }
           if (*fmt == 'l') {
             len_mod = 'q';
             fmt++;
           }
           break;
       }
  
       ch = *fmt++;
       if (ch == 's') {
         const char *s = va_arg(ap, const char *); /* Always fetch parameter */
         int j;
         int pad = field_width - (precision >= 0 ? c_strnlen(s, precision) : 0);
         for (j = 0; j < pad; j++) {
           C_SNPRINTF_APPEND_CHAR(' ');
         }
  
         /* `s` may be NULL in case of %.*s */
         if (s != NULL) {
           /* Ignore negative and 0 precisions */
           for (j = 0; (precision <= 0 || j < precision) && s[j] != '\0'; j++) {
             C_SNPRINTF_APPEND_CHAR(s[j]);
           }
         }
       } else if (ch == 'c') {
         ch = va_arg(ap, int); /* Always fetch parameter */
         C_SNPRINTF_APPEND_CHAR(ch);
       } else if (ch == 'd' && len_mod == 0) {
         i += c_itoa(buf + i, buf_size - i, va_arg(ap, int), 10, flags,
                     field_width);
       } else if (ch == 'd' && len_mod == 'l') {
         i += c_itoa(buf + i, buf_size - i, va_arg(ap, long), 10, flags,
                     field_width);
 #ifdef SSIZE_MAX
       } else if (ch == 'd' && len_mod == 'z') {
         i += c_itoa(buf + i, buf_size - i, va_arg(ap, ssize_t), 10, flags,
                     field_width);
 #endif
       } else if (ch == 'd' && len_mod == 'q') {
         i += c_itoa(buf + i, buf_size - i, va_arg(ap, int64_t), 10, flags,
                     field_width);
       } else if ((ch == 'x' || ch == 'u') && len_mod == 0) {
         i += c_itoa(buf + i, buf_size - i, va_arg(ap, unsigned),
                     ch == 'x' ? 16 : 10, flags, field_width);
       } else if ((ch == 'x' || ch == 'u') && len_mod == 'l') {
         i += c_itoa(buf + i, buf_size - i, va_arg(ap, unsigned long),
                     ch == 'x' ? 16 : 10, flags, field_width);
       } else if ((ch == 'x' || ch == 'u') && len_mod == 'z') {
         i += c_itoa(buf + i, buf_size - i, va_arg(ap, size_t),
                     ch == 'x' ? 16 : 10, flags, field_width);
       } else if (ch == 'p') {
         unsigned long num = (unsigned long) (uintptr_t) va_arg(ap, void *);
         C_SNPRINTF_APPEND_CHAR('0');
         C_SNPRINTF_APPEND_CHAR('x');
         i += c_itoa(buf + i, buf_size - i, num, 16, flags, 0);
       } else {
 #ifndef NO_LIBC
         /*
          * TODO(lsm): abort is not nice in a library, remove it
          * Also, ESP8266 SDK doesn't have it
          */
         abort();
 #endif
       }
     }
   }
  
   /* Zero-terminate the result */
   if (buf_size > 0) {
     buf[i < (int) buf_size ? i : (int) buf_size - 1] = '\0';
   }
  
   return i;
 }

Here is the call graph for this function:

◆ cs_base64_decode()

int cs_base64_decode	(	const unsigned char *	s,
		int	len,
		char *	dst
	)

Definition at line 305 of file mongoose6.cxx.

                                                                  {
   unsigned char a, b, c, d;
   int orig_len = len;
   while (len >= 4 && (a = from_b64(s[0])) != 255 &&
          (b = from_b64(s[1])) != 255 && (c = from_b64(s[2])) != 255 &&
          (d = from_b64(s[3])) != 255) {
     s += 4;
     len -= 4;
     if (a == 200 || b == 200) break; /* '=' can't be there */
     *dst++ = a << 2 | b >> 4;
     if (c == 200) break;
     *dst++ = b << 4 | c >> 2;
     if (d == 200) break;
     *dst++ = c << 6 | d;
   }
   *dst = 0;
   return orig_len - len;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cs_base64_encode()

void cs_base64_encode	(	const unsigned char *	src,
		int	src_len,
		char *	dst
	)

Definition at line 241 of file mongoose6.cxx.

                                                                         {
   BASE64_ENCODE_BODY;
 }

◆ cs_base64_finish()

void cs_base64_finish ( struct cs_base64_ctx * ctx )

Definition at line 195 of file mongoose6.cxx.

                                                  {
   if (ctx->chunk_size > 0) {
     int i;
     memset(&ctx->chunk[ctx->chunk_size], 0, 3 - ctx->chunk_size);
     cs_base64_emit_chunk(ctx);
     for (i = 0; i < (3 - ctx->chunk_size); i++) {
       ctx->b64_putc('=', ctx->user_data);
     }
   }
 }

Here is the call graph for this function:

◆ cs_base64_init()

void cs_base64_init	(	struct cs_base64_ctx *	ctx,
		cs_base64_putc_t	putc,
		void *	user_data
	)

Definition at line 176 of file mongoose6.cxx.

                                      {
   ctx->chunk_size = 0;
   ctx->b64_putc = b64_putc;
   ctx->user_data = user_data;
 }

◆ cs_base64_update()

void cs_base64_update	(	struct cs_base64_ctx *	ctx,
		const char *	str,
		size_t	len
	)

Definition at line 183 of file mongoose6.cxx.

                                                                               {
   const unsigned char *src = (const unsigned char *) str;
   size_t i;
   for (i = 0; i < len; i++) {
     ctx->chunk[ctx->chunk_size++] = src[i];
     if (ctx->chunk_size == 3) {
       cs_base64_emit_chunk(ctx);
       ctx->chunk_size = 0;
     }
   }
 }

Here is the call graph for this function:

◆ cs_fprint_base64()

void cs_fprint_base64	(	FILE *	f,
		const unsigned char *	src,
		int	src_len
	)

Definition at line 257 of file mongoose6.cxx.

                                                                       {
   BASE64_ENCODE_BODY;
 }

◆ cs_hmac_sha1()

void cs_hmac_sha1	(	const unsigned char *	key,
		size_t	key_len,
		const unsigned char *	text,
		size_t	text_len,
		unsigned char	out[20]
	)

Definition at line 1714 of file mongoose6.cxx.

                                          {
   cs_sha1_ctx ctx;
   unsigned char buf1[64], buf2[64], tmp_key[20], i;
  
   if (keylen > sizeof(buf1)) {
     cs_sha1_init(&ctx);
     cs_sha1_update(&ctx, key, keylen);
     cs_sha1_final(tmp_key, &ctx);
     key = tmp_key;
     keylen = sizeof(tmp_key);
   }
  
   memset(buf1, 0, sizeof(buf1));
   memset(buf2, 0, sizeof(buf2));
   memcpy(buf1, key, keylen);
   memcpy(buf2, key, keylen);
  
   for (i = 0; i < sizeof(buf1); i++) {
     buf1[i] ^= 0x36;
     buf2[i] ^= 0x5c;
   }
  
   cs_sha1_init(&ctx);
   cs_sha1_update(&ctx, buf1, sizeof(buf1));
   cs_sha1_update(&ctx, data, datalen);
   cs_sha1_final(out, &ctx);
  
   cs_sha1_init(&ctx);
   cs_sha1_update(&ctx, buf2, sizeof(buf2));
   cs_sha1_update(&ctx, out, 20);
   cs_sha1_final(out, &ctx);
 }

Here is the call graph for this function:

◆ cs_log_print_prefix()

void cs_log_print_prefix ( const char * func )

Definition at line 355 of file mongoose6.cxx.

                                            {
   if (cs_log_file == NULL) cs_log_file = stderr;
   fprintf(cs_log_file, "%-20s ", func);
 #ifdef CS_LOG_TS_DIFF
   {
     double now = cs_time();
     fprintf(cs_log_file, "%7u ", (unsigned int) ((now - cs_log_ts) * 1000000));
     cs_log_ts = now;
   }
 #endif
 }

Here is the call graph for this function:

◆ cs_log_printf()

void cs_log_printf	(	const char *	fmt,
			...
	)

Definition at line 367 of file mongoose6.cxx.

                                          {
   va_list ap;
   va_start(ap, fmt);
   vfprintf(cs_log_file, fmt, ap);
   va_end(ap);
   fputc('\n', cs_log_file);
   fflush(cs_log_file);
 }

◆ cs_log_set_file()

void cs_log_set_file ( FILE * file )

Definition at line 376 of file mongoose6.cxx.

                                  {
   cs_log_file = file;
 }

◆ cs_log_set_level()

void cs_log_set_level ( enum cs_log_level level )

Definition at line 723 of file mongoose614.cxx.

                                                {
   cs_log_level = level;
 #if CS_LOG_ENABLE_TS_DIFF && CS_ENABLE_STDIO
   cs_log_ts = cs_time();
 #endif
 }

Here is the call graph for this function:

◆ cs_md5()

char* cs_md5	(	char	buf[33],
			...
	)

Definition at line 1377 of file mongoose6.cxx.

                                 {
   unsigned char hash[16];
   const unsigned char *p;
   va_list ap;
   MD5_CTX ctx;
  
   MD5_Init(&ctx);
  
   va_start(ap, buf);
   while ((p = va_arg(ap, const unsigned char *) ) != NULL) {
     size_t len = va_arg(ap, size_t);
     MD5_Update(&ctx, p, len);
   }
   va_end(ap);
  
   MD5_Final(hash, &ctx);
   cs_to_hex(buf, hash, sizeof(hash));
  
   return buf;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cs_sha1_final()

void cs_sha1_final	(	unsigned char	digest[20],
		cs_sha1_ctx *	context
	)

Definition at line 1690 of file mongoose6.cxx.

                                                                    {
   unsigned i;
   unsigned char finalcount[8], c;
  
   for (i = 0; i < 8; i++) {
     finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >>
                                       ((3 - (i & 3)) * 8)) &
                                      255);
   }
   c = 0200;
   cs_sha1_update(context, &c, 1);
   while ((context->count[0] & 504) != 448) {
     c = 0000;
     cs_sha1_update(context, &c, 1);
   }
   cs_sha1_update(context, finalcount, 8);
   for (i = 0; i < 20; i++) {
     digest[i] =
         (unsigned char) ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
   }
   memset(context, '\0', sizeof(*context));
   memset(&finalcount, '\0', sizeof(finalcount));
 }

Here is the call graph for this function:

◆ cs_sha1_init()

void cs_sha1_init ( cs_sha1_ctx * context )

Definition at line 1661 of file mongoose6.cxx.

                                         {
   context->state[0] = 0x67452301;
   context->state[1] = 0xEFCDAB89;
   context->state[2] = 0x98BADCFE;
   context->state[3] = 0x10325476;
   context->state[4] = 0xC3D2E1F0;
   context->count[0] = context->count[1] = 0;
 }

◆ cs_sha1_update()

void cs_sha1_update	(	cs_sha1_ctx *	context,
		const unsigned char *	data,
		uint32_t	len
	)

Definition at line 1670 of file mongoose6.cxx.

                                   {
   uint32_t i, j;
  
   j = context->count[0];
   if ((context->count[0] += len << 3) < j) context->count[1]++;
   context->count[1] += (len >> 29);
   j = (j >> 3) & 63;
   if ((j + len) > 63) {
     memcpy(&context->buffer[j], data, (i = 64 - j));
     cs_sha1_transform(context->state, context->buffer);
     for (; i + 63 < len; i += 64) {
       cs_sha1_transform(context->state, &data[i]);
     }
     j = 0;
   } else
     i = 0;
   memcpy(&context->buffer[j], &data[i], len - i);
 }

Here is the call graph for this function:

◆ cs_time()

double cs_time ( void )

Definition at line 931 of file mongoose614.cxx.

                      {
   double now;
 #ifndef _WIN32
   struct timeval tv;
   if (gettimeofday(&tv, NULL /* tz */) != 0) return 0;
   now = (double) tv.tv_sec + (((double) tv.tv_usec) / 1000000.0);
 #else
   SYSTEMTIME sysnow;
   FILETIME ftime;
   GetLocalTime(&sysnow);
   SystemTimeToFileTime(&sysnow, &ftime);
   /*
    * 1. VC 6.0 doesn't support conversion uint64 -> double, so, using int64
    * This should not cause a problems in this (21th) century
    * 2. Windows FILETIME is a number of 100-nanosecond intervals since January
    * 1, 1601 while time_t is a number of _seconds_ since January 1, 1970 UTC,
    * thus, we need to convert to seconds and adjust amount (subtract 11644473600
    * seconds)
    */
   now = (double) (((int64_t) ftime.dwLowDateTime +
                    ((int64_t) ftime.dwHighDateTime << 32)) /
                   10000000.0) -
         11644473600;
 #endif /* _WIN32 */
   return now;
 }

Here is the call graph for this function:

◆ cs_to_hex()

void cs_to_hex	(	char *	to,
		const unsigned char *	p,
		size_t	len
	)

Definition at line 2132 of file mongoose614.cxx.

                                                              {
   static const char *hex = "0123456789abcdef";
  
   for (; len--; p++) {
     *to++ = hex[p[0] >> 4];
     *to++ = hex[p[0] & 0x0f];
   }
   *to = '\0';
 }

◆ find_json_token()

struct json_token* find_json_token	(	struct json_token *	toks,
		const char *	path
	)

Definition at line 958 of file mongoose6.cxx.

                                                                               {
   while (path != 0 && path[0] != '\0') {
     int i, ind2 = 0, ind = -1, skip = 2, n = path_part_len(path);
     if (path[0] == '[') {
       if (toks->type != JSON_TYPE_ARRAY || !is_digit(path[1])) return 0;
       for (ind = 0, n = 1; path[n] != ']' && path[n] != '\0'; n++) {
         if (!is_digit(path[n])) return 0;
         ind *= 10;
         ind += path[n] - '0';
       }
       if (path[n++] != ']') return 0;
       skip = 1; /* In objects, we skip 2 elems while iterating, in arrays 1. */
     } else if (toks->type != JSON_TYPE_OBJECT)
       return 0;
     toks++;
     for (i = 0; i < toks[-1].num_desc; i += skip, ind2++) {
       /* ind == -1 indicated that we're iterating an array, not object */
       if (ind == -1 && toks[i].type != JSON_TYPE_STRING) return 0;
       if (ind2 == ind ||
           (ind == -1 && toks[i].len == n && compare(path, toks[i].ptr, n))) {
         i += skip - 1;
         break;
       };
       if (toks[i - 1 + skip].type == JSON_TYPE_ARRAY ||
           toks[i - 1 + skip].type == JSON_TYPE_OBJECT) {
         i += toks[i - 1 + skip].num_desc;
       }
     }
     if (i == toks[-1].num_desc) return 0;
     path += n;
     if (path[0] == '.') path++;
     if (path[0] == '\0') return &toks[i];
     toks += i;
   }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ json_emit()

int json_emit	(	char *	buf,
		int	buf_len,
		const char *	fmt,
			...
	)

Definition at line 1142 of file mongoose6.cxx.

                                                             {
   int len;
   va_list ap;
  
   va_start(ap, fmt);
   len = json_emit_va(buf, buf_len, fmt, ap);
   va_end(ap);
  
   return len;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ json_emit_double()

int json_emit_double	(	char *	buf,
		int	buf_len,
		double	value
	)

Definition at line 1002 of file mongoose6.cxx.

                                                            {
   char tmp[20];
   int n = snprintf(tmp, sizeof(tmp), "%g", value);
   strncpy(buf, tmp, buf_len > 0 ? buf_len : 0);
   return n;
 }

Here is the caller graph for this function:

◆ json_emit_long()

int json_emit_long	(	char *	buf,
		int	buf_len,
		long	value
	)

◆ json_emit_quoted_str()

int json_emit_quoted_str	(	char *	buf,
		int	buf_len,
		const char *	str,
		int	len
	)

Definition at line 1009 of file mongoose6.cxx.

                                                                        {
   const char *begin = s, *end = s + s_len, *str_end = str + len;
   char ch;
  
 #define EMIT(x)          \
   do {                   \
     if (s < end) *s = x; \
     s++;                 \
   } while (0)
  
   EMIT('"');
   while (str < str_end) {
     ch = *str++;
     switch (ch) {
       case '"':
         EMIT('\\');
         EMIT('"');
         break;
       case '\\':
         EMIT('\\');
         EMIT('\\');
         break;
       case '\b':
         EMIT('\\');
         EMIT('b');
         break;
       case '\f':
         EMIT('\\');
         EMIT('f');
         break;
       case '\n':
         EMIT('\\');
         EMIT('n');
         break;
       case '\r':
         EMIT('\\');
         EMIT('r');
         break;
       case '\t':
         EMIT('\\');
         EMIT('t');
         break;
       default:
         EMIT(ch);
     }
   }
   EMIT('"');
   if (s < end) {
     *s = '\0';
   }
  
   return s - begin;
 }

Here is the caller graph for this function:

◆ json_emit_unquoted_str()

int json_emit_unquoted_str	(	char *	buf,
		int	buf_len,
		const char *	str,
		int	len
	)

Definition at line 1063 of file mongoose6.cxx.

                                                                              {
   if (buf_len > 0 && len > 0) {
     int n = len < buf_len ? len : buf_len;
     memcpy(buf, str, n);
     if (n < buf_len) {
       buf[n] = '\0';
     }
   }
   return len;
 }

Here is the caller graph for this function:

◆ json_emit_va()

int json_emit_va	(	char *	buf,
		int	buf_len,
		const char *	fmt,
		va_list	ap
	)

Definition at line 1074 of file mongoose6.cxx.

                                                                   {
   const char *end = s + s_len, *str, *orig = s;
   size_t len;
  
   while (*fmt != '\0') {
     switch (*fmt) {
       case '[':
       case ']':
       case '{':
       case '}':
       case ',':
       case ':':
       case ' ':
       case '\r':
       case '\n':
       case '\t':
         if (s < end) {
           *s = *fmt;
         }
         s++;
         break;
       case 'i':
         s += json_emit_long(s, end - s, va_arg(ap, long) );
         break;
       case 'f':
         s += json_emit_double(s, end - s, va_arg(ap, double) );
         break;
       case 'v':
         str = va_arg(ap, char *);
         len = va_arg(ap, size_t);
         s += json_emit_quoted_str(s, end - s, str, len);
         break;
       case 'V':
         str = va_arg(ap, char *);
         len = va_arg(ap, size_t);
         s += json_emit_unquoted_str(s, end - s, str, len);
         break;
       case 's':
         str = va_arg(ap, char *);
         s += json_emit_quoted_str(s, end - s, str, strlen(str));
         break;
       case 'S':
         str = va_arg(ap, char *);
         s += json_emit_unquoted_str(s, end - s, str, strlen(str));
         break;
       case 'T':
         s += json_emit_unquoted_str(s, end - s, "true", 4);
         break;
       case 'F':
         s += json_emit_unquoted_str(s, end - s, "false", 5);
         break;
       case 'N':
         s += json_emit_unquoted_str(s, end - s, "null", 4);
         break;
       default:
         return 0;
     }
     fmt++;
   }
  
   /* Best-effort to 0-terminate generated string */
   if (s < end) {
     *s = '\0';
   }
  
   return s - orig;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mbuf_append()

size_t mbuf_append	(	struct mbuf *	a,
		const void *	data,
		size_t	data_size
	)

Definition at line 1623 of file mongoose614.cxx.

                                                                 {
   return mbuf_insert(a, a->len, buf, len);
 }

Here is the call graph for this function:

◆ mbuf_free()

void mbuf_free ( struct mbuf * mbuf )

Definition at line 1551 of file mongoose614.cxx.

                                   {
   if (mbuf->buf != NULL) {
     MBUF_FREE(mbuf->buf);
     mbuf_init(mbuf, 0);
   }
 }

Here is the call graph for this function:

◆ mbuf_init()

void mbuf_init	(	struct mbuf *	mbuf,
		size_t	initial_capacity
	)

Definition at line 1544 of file mongoose614.cxx.

                                                        {
   mbuf->len = mbuf->size = 0;
   mbuf->buf = NULL;
   mbuf_resize(mbuf, initial_size);
 }

Here is the call graph for this function:

◆ mbuf_insert()

size_t mbuf_insert	(	struct mbuf *	a,
		size_t	off,
		const void *	buf,
		size_t	len
	)

Definition at line 1579 of file mongoose614.cxx.

                                                                             {
   char *p = NULL;
  
   assert(a != NULL);
   assert(a->len <= a->size);
   assert(off <= a->len);
  
   /* check overflow */
   if (~(size_t) 0 - (size_t) a->buf < len) return 0;
  
   if (a->len + len <= a->size) {
     memmove(a->buf + off + len, a->buf + off, a->len - off);
     if (buf != NULL) {
       memcpy(a->buf + off, buf, len);
     }
     a->len += len;
   } else {
     size_t min_size = (a->len + len);
     size_t new_size = (size_t)(min_size * MBUF_SIZE_MULTIPLIER);
     if (new_size - min_size > MBUF_SIZE_MAX_HEADROOM) {
       new_size = min_size + MBUF_SIZE_MAX_HEADROOM;
     }
     p = (char *) MBUF_REALLOC(a->buf, new_size);
     if (p == NULL && new_size != min_size) {
       new_size = min_size;
       p = (char *) MBUF_REALLOC(a->buf, new_size);
     }
     if (p != NULL) {
       a->buf = p;
       if (off != a->len) {
         memmove(a->buf + off + len, a->buf + off, a->len - off);
       }
       if (buf != NULL) memcpy(a->buf + off, buf, len);
       a->len += len;
       a->size = new_size;
     } else {
       len = 0;
     }
   }
  
   return len;
 }

◆ mbuf_remove()

void mbuf_remove	(	struct mbuf *	mb,
		size_t	data_size
	)

Definition at line 1644 of file mongoose614.cxx.

                                             {
   if (n > 0 && n <= mb->len) {
     memmove(mb->buf, mb->buf + n, mb->len - n);
     mb->len -= n;
   }
 }

Here is the caller graph for this function:

◆ mbuf_resize()

void mbuf_resize	(	struct mbuf *	a,
		size_t	new_size
	)

Definition at line 1559 of file mongoose614.cxx.

                                                   {
   if (new_size > a->size || (new_size < a->size && new_size >= a->len)) {
     char *buf = (char *) MBUF_REALLOC(a->buf, new_size);
     /*
      * In case realloc fails, there's not much we can do, except keep things as
      * they are. Note that NULL is a valid return value from realloc when
      * size == 0, but that is covered too.
      */
     if (buf == NULL && new_size != 0) return;
     a->buf = buf;
     a->size = new_size;
   }
 }

◆ mbuf_trim()

void mbuf_trim ( struct mbuf * mbuf )

Definition at line 1574 of file mongoose614.cxx.

                                   {
   mbuf_resize(mbuf, mbuf->len);
 }

Here is the call graph for this function:

◆ MD5_Final()

void MD5_Final	(	unsigned char *	md,
		MD5_CTX *	c
	)

◆ MD5_Init()

void MD5_Init ( MD5_CTX * c )

Definition at line 1204 of file mongoose6.cxx.

                             {
   ctx->buf[0] = 0x67452301;
   ctx->buf[1] = 0xefcdab89;
   ctx->buf[2] = 0x98badcfe;
   ctx->buf[3] = 0x10325476;
  
   ctx->bits[0] = 0;
   ctx->bits[1] = 0;
 }

Here is the caller graph for this function:

◆ MD5_Update()

void MD5_Update	(	MD5_CTX *	c,
		const unsigned char *	data,
		size_t	len
	)

Definition at line 1296 of file mongoose6.cxx.

                                                                     {
   uint32_t t;
  
   t = ctx->bits[0];
   if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t) ctx->bits[1]++;
   ctx->bits[1] += (uint32_t) len >> 29;
  
   t = (t >> 3) & 0x3f;
  
   if (t) {
     unsigned char *p = (unsigned char *) ctx->in + t;
  
     t = 64 - t;
     if (len < t) {
       memcpy(p, buf, len);
       return;
     }
     memcpy(p, buf, t);
     byteReverse(ctx->in, 16);
     MD5Transform(ctx->buf, (uint32_t *) ctx->in);
     buf += t;
     len -= t;
   }
  
   while (len >= 64) {
     memcpy(ctx->in, buf, 64);
     byteReverse(ctx->in, 16);
     MD5Transform(ctx->buf, (uint32_t *) ctx->in);
     buf += 64;
     len -= 64;
   }
  
   memcpy(ctx->in, buf, len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_add_sock()

struct mg_connection* mg_add_sock	(	struct mg_mgr *	s,
		sock_t	sock,
		mg_event_handler_t	callback
	)

Definition at line 3062 of file mongoose6.cxx.

                                                                {
   struct mg_add_sock_opts opts;
   memset(&opts, 0, sizeof(opts));
   return mg_add_sock_opt(s, sock, callback, opts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_add_sock_opt()

struct mg_connection* mg_add_sock_opt	(	struct mg_mgr *	s,
		sock_t	sock,
		mg_event_handler_t	callback,
		struct mg_add_sock_opts	opts
	)

Definition at line 3051 of file mongoose6.cxx.

                                                                     {
   struct mg_connection *nc = mg_create_connection_base(s, callback, opts);
   if (nc != NULL) {
     mg_sock_set(nc, sock);
     mg_add_conn(nc->mgr, nc);
   }
   return nc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_avprintf()

int mg_avprintf	(	char **	buf,
		size_t	size,
		const char *	fmt,
		va_list	ap
	)

Definition at line 2213 of file mongoose614.cxx.

                                                                       {
   va_list ap_copy;
   int len;
  
   va_copy(ap_copy, ap);
   len = vsnprintf(*buf, size, fmt, ap_copy);
   va_end(ap_copy);
  
   if (len < 0) {
     /* eCos and Windows are not standard-compliant and return -1 when
      * the buffer is too small. Keep allocating larger buffers until we
      * succeed or out of memory. */
     *buf = NULL; /* LCOV_EXCL_START */
     while (len < 0) {
       MG_FREE(*buf);
       if (size == 0) {
         size = 5;
       }
       size *= 2;
       if ((*buf = (char *) MG_MALLOC(size)) == NULL) {
         len = -1;
         break;
       }
       va_copy(ap_copy, ap);
       len = vsnprintf(*buf, size - 1, fmt, ap_copy);
       va_end(ap_copy);
     }
  
     /*
      * Microsoft version of vsnprintf() is not always null-terminated, so put
      * the terminator manually
      */
     (*buf)[len] = 0;
     /* LCOV_EXCL_STOP */
   } else if (len >= (int) size) {
     /* Standard-compliant code path. Allocate a buffer that is large enough. */
     if ((*buf = (char *) MG_MALLOC(len + 1)) == NULL) {
       len = -1; /* LCOV_EXCL_LINE */
     } else {    /* LCOV_EXCL_LINE */
       va_copy(ap_copy, ap);
       len = vsnprintf(*buf, len + 1, fmt, ap_copy);
       va_end(ap_copy);
     }
   }
  
   return len;
 }

◆ mg_base64_decode()

int mg_base64_decode	(	const unsigned char *	s,
		int	len,
		char *	dst
	)

Definition at line 7878 of file mongoose6.cxx.

                                                                  {
   return cs_base64_decode(s, len, dst);
 }

Here is the call graph for this function:

◆ mg_base64_encode()

void mg_base64_encode	(	const unsigned char *	src,
		int	src_len,
		char *	dst
	)

Definition at line 7874 of file mongoose6.cxx.

                                                                         {
   cs_base64_encode(src, src_len, dst);
 }

Here is the call graph for this function:

◆ mg_bind()

struct mg_connection* mg_bind	(	struct mg_mgr *	srv,
		const char *	address,
		mg_event_handler_t	event_handler
	)

Definition at line 2898 of file mongoose6.cxx.

                                                                 {
   struct mg_bind_opts opts;
   memset(&opts, 0, sizeof(opts));
   return mg_bind_opt(srv, address, event_handler, opts);
 }

Here is the call graph for this function:

◆ mg_bind_opt()

struct mg_connection* mg_bind_opt	(	struct mg_mgr *	mgr,
		const char *	address,
		mg_event_handler_t	handler,
		struct mg_bind_opts	opts
	)

Definition at line 2905 of file mongoose6.cxx.

                                                             {
   union socket_address sa;
   struct mg_connection *nc = NULL;
   int proto, rc;
   struct mg_add_sock_opts add_sock_opts;
   char host[MG_MAX_HOST_LEN];
  
   MG_COPY_COMMON_CONNECTION_OPTIONS(&add_sock_opts, &opts);
  
   if (mg_parse_address(address, &sa, &proto, host, sizeof(host)) <= 0) {
     MG_SET_PTRPTR(opts.error_string, "cannot parse address");
     return NULL;
   }
  
   nc = mg_create_connection(mgr, callback, add_sock_opts);
   if (nc == NULL) {
     return NULL;
   }
  
   nc->sa = sa;
   nc->flags |= MG_F_LISTENING;
   if (proto == SOCK_DGRAM) {
     nc->flags |= MG_F_UDP;
     rc = mg_if_listen_udp(nc, &nc->sa);
   } else {
     rc = mg_if_listen_tcp(nc, &nc->sa);
   }
   if (rc != 0) {
     DBG(("Failed to open listener: %d", rc));
     MG_SET_PTRPTR(opts.error_string, "failed to open listener");
     mg_destroy_conn(nc);
     return NULL;
   }
 #ifdef MG_ENABLE_SSL
   if (opts.ssl_cert != NULL || opts.ssl_ca_cert != NULL) {
     const char *err = mg_set_ssl(nc, opts.ssl_cert, opts.ssl_ca_cert);
     if (err != NULL) {
       MG_SET_PTRPTR(opts.error_string, err);
       mg_destroy_conn(nc);
       return NULL;
     }
   }
 #endif /* MG_ENABLE_SSL */
   mg_add_conn(nc->mgr, nc);
  
   return nc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_broadcast()

void mg_broadcast	(	struct mg_mgr *	mgr,
		mg_event_handler_t	func,
		void *	data,
		size_t	len
	)

Definition at line 2960 of file mongoose6.cxx.

                               {
   struct ctl_msg ctl_msg;
  
   /*
    * Mongoose manager has a socketpair, `struct mg_mgr::ctl`,
    * where `mg_broadcast()` pushes the message.
    * `mg_mgr_poll()` wakes up, reads a message from the socket pair, and calls
    * specified callback for each connection. Thus the callback function executes
    * in event manager thread.
    */
   if (mgr->ctl[0] != INVALID_SOCKET && data != NULL &&
       len < sizeof(ctl_msg.message)) {
     size_t dummy;
  
     ctl_msg.callback = cb;
     memcpy(ctl_msg.message, data, len);
     dummy = MG_SEND_FUNC(mgr->ctl[0], (char *) &ctl_msg,
                          offsetof(struct ctl_msg, message) + len, 0);
     dummy = MG_RECV_FUNC(mgr->ctl[0], (char *) &len, 1, 0);
     (void) dummy; /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509 */
   }
 }

◆ mg_casecmp()

int mg_casecmp	(	const char *	s1,
		const char *	s2
	)

Definition at line 2198 of file mongoose614.cxx.

                                                {
   return mg_ncasecmp(s1, s2, (size_t) ~0);
 }

Here is the call graph for this function:

◆ mg_check_ip_acl()

int mg_check_ip_acl	(	const char *	acl,
		uint32_t	remote_ip
	)

Definition at line 3005 of file mongoose6.cxx.

                                                          {
   int allowed, flag;
   uint32_t net, mask;
   struct mg_str vec;
  
   /* If any ACL is set, deny by default */
   allowed = (acl == NULL || *acl == '\0') ? '+' : '-';
  
   while ((acl = mg_next_comma_list_entry(acl, &vec, NULL)) != NULL) {
     flag = vec.p[0];
     if ((flag != '+' && flag != '-') ||
         parse_net(&vec.p[1], &net, &mask) == 0) {
       return -1;
     }
  
     if (net == (remote_ip & mask)) {
       allowed = flag;
     }
   }
  
   DBG(("%08x %c", remote_ip, allowed));
   return allowed == '+';
 }

Here is the call graph for this function:

◆ mg_close_conn()

void mg_close_conn ( struct mg_connection * nc )

Definition at line 2546 of file mongoose614.cxx.

                                                {
   /* See if there's any remaining data to deliver. Skip if user completely
    * throttled the connection there will be no progress anyway. */
   if (conn->sock != INVALID_SOCKET && mg_do_recv(conn) == -2) {
     /* Receive is throttled, wait. */
     conn->flags |= MG_F_RECV_AND_CLOSE;
     return;
   }
 #if MG_ENABLE_SSL
   if (conn->flags & MG_F_SSL_HANDSHAKE_DONE) {
     mg_ssl_if_conn_close_notify(conn);
   }
 #endif
   /*
    * Clearly mark the connection as going away (if not already).
    * Some net_if impls (LwIP) need this for cleanly handling half-dead conns.
    */
   conn->flags |= MG_F_CLOSE_IMMEDIATELY;
   mg_remove_conn(conn);
   conn->iface->vtable->destroy_conn(conn);
   mg_call(conn, NULL, conn->user_data, MG_EV_CLOSE, NULL);
   mg_destroy_conn(conn, 0 /* destroy_if */);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_conn_addr_to_str()

void mg_conn_addr_to_str	(	struct mg_connection *	nc,
		char *	buf,
		size_t	len,
		int	flags
	)

Definition at line 7962 of file mongoose6.cxx.

                                     {
   union socket_address sa;
   memset(&sa, 0, sizeof(sa));
   mg_if_get_conn_addr(nc, flags & MG_SOCK_STRINGIFY_REMOTE, &sa);
   mg_sock_addr_to_str(&sa, buf, len, flags);
 }

Here is the call graph for this function:

◆ mg_connect()

struct mg_connection* mg_connect	(	struct mg_mgr *	mgr,
		const char *	address,
		mg_event_handler_t	handler
	)

Definition at line 2814 of file mongoose6.cxx.

                                                               {
   struct mg_connect_opts opts;
   memset(&opts, 0, sizeof(opts));
   return mg_connect_opt(mgr, address, callback, opts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_connect_http()

struct mg_connection* mg_connect_http	(	struct mg_mgr *	mgr,
		mg_event_handler_t	event_handler,
		const char *	url,
		const char *	extra_headers,
		const char *	post_data
	)

Definition at line 7692 of file mongoose6.cxx.

                                                              {
   struct mg_connect_opts opts;
   memset(&opts, 0, sizeof(opts));
   return mg_connect_http_opt(mgr, ev_handler, opts, url, extra_headers,
                              post_data);
 }

Here is the call graph for this function:

◆ mg_connect_http_opt()

struct mg_connection* mg_connect_http_opt	(	struct mg_mgr *	mgr,
		mg_event_handler_t	ev_handler,
		struct mg_connect_opts	opts,
		const char *	url,
		const char *	extra_headers,
		const char *	post_data
	)

Definition at line 7666 of file mongoose6.cxx.

                                                                  {
   char *addr = NULL;
   const char *path = NULL;
   struct mg_connection *nc = mg_connect_http_base(
       mgr, ev_handler, opts, "http://", "https://", url, &path, &addr);
  
   if (nc == NULL) {
     return NULL;
   }
  
   mg_printf(nc, "%s %s HTTP/1.1\r\nHost: %s\r\nContent-Length: %" SIZE_T_FMT
                 "\r\n%s\r\n%s",
             post_data == NULL ? "GET" : "POST", path, addr,
             post_data == NULL ? 0 : strlen(post_data),
             extra_headers == NULL ? "" : extra_headers,
             post_data == NULL ? "" : post_data);
  
   MG_FREE(addr);
   return nc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_connect_opt()

struct mg_connection* mg_connect_opt	(	struct mg_mgr *	mgr,
		const char *	address,
		mg_event_handler_t	handler,
		struct mg_connect_opts	opts
	)

Definition at line 2821 of file mongoose6.cxx.

                                                                   {
   struct mg_connection *nc = NULL;
   int proto, rc;
   struct mg_add_sock_opts add_sock_opts;
   char host[MG_MAX_HOST_LEN];
  
   MG_COPY_COMMON_CONNECTION_OPTIONS(&add_sock_opts, &opts);
  
   if ((nc = mg_create_connection(mgr, callback, add_sock_opts)) == NULL) {
     return NULL;
   } else if ((rc = mg_parse_address(address, &nc->sa, &proto, host,
                                     sizeof(host))) < 0) {
     /* Address is malformed */
     MG_SET_PTRPTR(opts.error_string, "cannot parse address");
     mg_destroy_conn(nc);
     return NULL;
   }
   nc->flags |= opts.flags & _MG_ALLOWED_CONNECT_FLAGS_MASK;
   nc->flags |= (proto == SOCK_DGRAM) ? MG_F_UDP : 0;
   nc->user_data = opts.user_data;
  
 #ifdef MG_ENABLE_SSL
   if (opts.ssl_cert != NULL || opts.ssl_ca_cert != NULL) {
     const char *err = mg_set_ssl(nc, opts.ssl_cert, opts.ssl_ca_cert);
     if (err != NULL) {
       MG_SET_PTRPTR(opts.error_string, err);
       mg_destroy_conn(nc);
       return NULL;
     }
     if (opts.ssl_ca_cert != NULL && (opts.ssl_server_name == NULL ||
                                      strcmp(opts.ssl_server_name, "*") != 0)) {
       if (opts.ssl_server_name == NULL) opts.ssl_server_name = host;
 #ifdef SSL_KRYPTON
       SSL_CTX_kr_set_verify_name(nc->ssl_ctx, opts.ssl_server_name);
 #else
       /* TODO(rojer): Implement server name verification on OpenSSL. */
       MG_SET_PTRPTR(opts.error_string,
                     "Server name verification requested but is not supported");
       mg_destroy_conn(nc);
       return NULL;
 #endif /* SSL_KRYPTON */
     }
   }
 #endif /* MG_ENABLE_SSL */
  
   if (rc == 0) {
 #ifndef MG_DISABLE_RESOLVER
     /*
      * DNS resolution is required for host.
      * mg_parse_address() fills port in nc->sa, which we pass to resolve_cb()
      */
     struct mg_connection *dns_conn = NULL;
     struct mg_resolve_async_opts o;
     memset(&o, 0, sizeof(o));
     o.dns_conn = &dns_conn;
     if (mg_resolve_async_opt(nc->mgr, host, MG_DNS_A_RECORD, resolve_cb, nc,
                              o) != 0) {
       MG_SET_PTRPTR(opts.error_string, "cannot schedule DNS lookup");
       mg_destroy_conn(nc);
       return NULL;
     }
     nc->priv_2 = dns_conn;
     nc->flags |= MG_F_RESOLVING;
     return nc;
 #else
     MG_SET_PTRPTR(opts.error_string, "Resolver is disabled");
     mg_destroy_conn(nc);
     return NULL;
 #endif
   } else {
     /* Address is parsed and resolved to IP. proceed with connect() */
     return mg_do_connect(nc, proto, &nc->sa);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_connect_ws()

struct mg_connection* mg_connect_ws	(	struct mg_mgr *	mgr,
		mg_event_handler_t	event_handler,
		const char *	url,
		const char *	protocol,
		const char *	extra_headers
	)

Definition at line 7723 of file mongoose6.cxx.

                                                                {
   struct mg_connect_opts opts;
   memset(&opts, 0, sizeof(opts));
   return mg_connect_ws_opt(mgr, ev_handler, opts, url, protocol, extra_headers);
 }

Here is the call graph for this function:

◆ mg_connect_ws_opt()

struct mg_connection* mg_connect_ws_opt	(	struct mg_mgr *	mgr,
		mg_event_handler_t	ev_handler,
		struct mg_connect_opts	opts,
		const char *	url,
		const char *	protocol,
		const char *	extra_headers
	)

Definition at line 7703 of file mongoose6.cxx.

                                                                    {
   char *addr = NULL;
   const char *path = NULL;
   struct mg_connection *nc = mg_connect_http_base(
       mgr, ev_handler, opts, "ws://", "wss://", url, &path, &addr);
  
   if (nc == NULL) {
     return NULL;
   }
  
   mg_send_websocket_handshake2(nc, path, addr, protocol, extra_headers);
  
   MG_FREE(addr);
   return nc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_dns_copy_body()

int mg_dns_copy_body	(	struct mbuf *	io,
		struct mg_dns_message *	msg
	)

Definition at line 8882 of file mongoose6.cxx.

                                                                   {
   return mbuf_append(io, msg->pkt.p + sizeof(struct mg_dns_header),
                      msg->pkt.len - sizeof(struct mg_dns_header));
 }

Here is the call graph for this function:

◆ mg_dns_encode_record()

int mg_dns_encode_record	(	struct mbuf *	io,
		struct mg_dns_resource_record *	rr,
		const char *	name,
		size_t	nlen,
		const void *	rdata,
		size_t	rlen
	)

Definition at line 8916 of file mongoose6.cxx.

                                       {
   size_t pos = io->len;
   uint16_t u16;
   uint32_t u32;
  
   if (rr->kind == MG_DNS_INVALID_RECORD) {
     return -1; /* LCOV_EXCL_LINE */
   }
  
   if (mg_dns_encode_name(io, name, nlen) == -1) {
     return -1;
   }
  
   u16 = htons(rr->rtype);
   mbuf_append(io, &u16, 2);
   u16 = htons(rr->rclass);
   mbuf_append(io, &u16, 2);
  
   if (rr->kind == MG_DNS_ANSWER) {
     u32 = htonl(rr->ttl);
     mbuf_append(io, &u32, 4);
  
     if (rr->rtype == MG_DNS_CNAME_RECORD) {
       int clen;
       /* fill size after encoding */
       size_t off = io->len;
       mbuf_append(io, &u16, 2);
       if ((clen = mg_dns_encode_name(io, (const char *) rdata, rlen)) == -1) {
         return -1;
       }
       u16 = clen;
       io->buf[off] = u16 >> 8;
       io->buf[off + 1] = u16 & 0xff;
     } else {
       u16 = htons(rlen);
       mbuf_append(io, &u16, 2);
       mbuf_append(io, rdata, rlen);
     }
   }
  
   return io->len - pos;
 }

Here is the call graph for this function:

◆ mg_dns_insert_header()

int mg_dns_insert_header	(	struct mbuf *	io,
		size_t	pos,
		struct mg_dns_message *	msg
	)

Definition at line 8869 of file mongoose6.cxx.

                                                      {
   struct mg_dns_header header;
  
   memset(&header, 0, sizeof(header));
   header.transaction_id = msg->transaction_id;
   header.flags = htons(msg->flags);
   header.num_questions = htons(msg->num_questions);
   header.num_answers = htons(msg->num_answers);
  
   return mbuf_insert(io, pos, &header, sizeof(header));
 }

Here is the call graph for this function:

◆ mg_dns_next_record()

struct mg_dns_resource_record* mg_dns_next_record	(	struct mg_dns_message *	msg,
		int	query,
		struct mg_dns_resource_record *	prev
	)

Definition at line 8826 of file mongoose6.cxx.

                                          {
   struct mg_dns_resource_record *rr;
  
   for (rr = (prev == NULL ? msg->answers : prev + 1);
        rr - msg->answers < msg->num_answers; rr++) {
     if (rr->rtype == query) {
       return rr;
     }
   }
   return NULL;
 }

◆ mg_dns_parse_record_data()

int mg_dns_parse_record_data	(	struct mg_dns_message *	msg,
		struct mg_dns_resource_record *	rr,
		void *	data,
		size_t	data_len
	)

Definition at line 8840 of file mongoose6.cxx.

                                               {
   switch (rr->rtype) {
     case MG_DNS_A_RECORD:
       if (data_len < sizeof(struct in_addr)) {
         return -1;
       }
       if (rr->rdata.p + data_len > msg->pkt.p + msg->pkt.len) {
         return -1;
       }
       memcpy(data, rr->rdata.p, data_len);
       return 0;
 #ifdef MG_ENABLE_IPV6
     case MG_DNS_AAAA_RECORD:
       if (data_len < sizeof(struct in6_addr)) {
         return -1; /* LCOV_EXCL_LINE */
       }
       memcpy(data, rr->rdata.p, data_len);
       return 0;
 #endif
     case MG_DNS_CNAME_RECORD:
       mg_dns_uncompress_name(msg, &rr->rdata, (char *) data, data_len);
       return 0;
   }
  
   return -1;
 }

Here is the call graph for this function:

◆ mg_dns_uncompress_name()

size_t mg_dns_uncompress_name	(	struct mg_dns_message *	msg,
		struct mg_str *	name,
		char *	dst,
		int	dst_len
	)

Definition at line 9084 of file mongoose6.cxx.

                                                       {
   int chunk_len;
   char *old_dst = dst;
   const unsigned char *data = (unsigned char *) name->p;
   const unsigned char *end = (unsigned char *) msg->pkt.p + msg->pkt.len;
  
   if (data >= end) {
     return 0;
   }
  
   while ((chunk_len = *data++)) {
     int leeway = dst_len - (dst - old_dst);
     if (data >= end) {
       return 0;
     }
  
     if (chunk_len & 0xc0) {
       uint16_t off = (data[-1] & (~0xc0)) << 8 | data[0];
       if (off >= msg->pkt.len) {
         return 0;
       }
       data = (unsigned char *) msg->pkt.p + off;
       continue;
     }
     if (chunk_len > leeway) {
       chunk_len = leeway;
     }
  
     if (data + chunk_len >= end) {
       return 0;
     }
  
     memcpy(dst, data, chunk_len);
     data += chunk_len;
     dst += chunk_len;
     leeway -= chunk_len;
     if (leeway == 0) {
       return dst - old_dst;
     }
     *dst++ = '.';
   }
  
   if (dst != old_dst) {
     *--dst = 0;
   }
   return dst - old_dst;
 }

◆ mg_enable_multithreading()

void mg_enable_multithreading ( struct mg_connection * nc )

◆ mg_fopen()

static FILE * mg_fopen	(	const char *	path,
		const char *	mode
	)

Definition at line 2331 of file mongoose4.cxx.

                                                           {
 #ifdef _WIN32
   wchar_t wbuf[PATH_MAX], wmode[20];
   to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
   MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, ARRAY_SIZE(wmode));
   return _wfopen(wbuf, wmode);
 #else
   return fopen(path, mode);
 #endif
 }

◆ mg_get_http_header()

struct mg_str* mg_get_http_header	(	struct http_message *	hm,
		const char *	name
	)

Definition at line 4466 of file mongoose6.cxx.

                                                                              {
   size_t i, len = strlen(name);
  
   for (i = 0; hm->header_names[i].len > 0; i++) {
     struct mg_str *h = &hm->header_names[i], *v = &hm->header_values[i];
     if (h->p != NULL && h->len == len && !mg_ncasecmp(h->p, name, len))
       return v;
   }
  
   return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_get_http_var()

int mg_get_http_var	(	const struct mg_str *	buf,
		const char *	name,
		char *	dst,
		size_t	dst_len
	)

Definition at line 5990 of file mongoose6.cxx.

                                     {
   const char *p, *e, *s;
   size_t name_len;
   int len;
  
   if (dst == NULL || dst_len == 0) {
     len = -2;
   } else if (buf->p == NULL || name == NULL || buf->len == 0) {
     len = -1;
     dst[0] = '\0';
   } else {
     name_len = strlen(name);
     e = buf->p + buf->len;
     len = -1;
     dst[0] = '\0';
  
     for (p = buf->p; p + name_len < e; p++) {
       if ((p == buf->p || p[-1] == '&') && p[name_len] == '=' &&
           !mg_ncasecmp(name, p, name_len)) {
         p += name_len + 1;
         s = (const char *) memchr(p, '&', (size_t)(e - p));
         if (s == NULL) {
           s = e;
         }
         len = mg_url_decode(p, (size_t)(s - p), dst, dst_len, 1);
         if (len == -1) {
           len = -2;
         }
         break;
       }
     }
   }
  
   return len;
 }

Here is the call graph for this function:

◆ mg_hexdump()

int mg_hexdump	(	const void *	buf,
		int	len,
		char *	dst,
		int	dst_len
	)

Definition at line 7971 of file mongoose6.cxx.

                                                                  {
   const unsigned char *p = (const unsigned char *) buf;
   char ascii[17] = "";
   int i, idx, n = 0;
  
   for (i = 0; i < len; i++) {
     idx = i % 16;
     if (idx == 0) {
       if (i > 0) n += snprintf(dst + n, dst_len - n, "  %s\n", ascii);
       n += snprintf(dst + n, dst_len - n, "%04x ", i);
     }
     n += snprintf(dst + n, dst_len - n, " %02x", p[i]);
     ascii[idx] = p[i] < 0x20 || p[i] > 0x7e ? '.' : p[i];
     ascii[idx + 1] = '\0';
   }
  
   while (i++ % 16) n += snprintf(dst + n, dst_len - n, "%s", "   ");
   n += snprintf(dst + n, dst_len - n, "  %s\n\n", ascii);
  
   return n;
 }

Here is the caller graph for this function:

◆ mg_hexdump_connection()

void mg_hexdump_connection	(	struct mg_connection *	nc,
		const char *	path,
		const void *	buf,
		int	num_bytes,
		int	ev
	)

Definition at line 8031 of file mongoose6.cxx.

                                                                    {
 #if !defined(NO_LIBC) && !defined(MG_DISABLE_STDIO)
   FILE *fp = NULL;
   char *hexbuf, src[60], dst[60];
   int buf_size = num_bytes * 5 + 100;
  
   if (strcmp(path, "-") == 0) {
     fp = stdout;
   } else if (strcmp(path, "--") == 0) {
     fp = stderr;
 #ifndef MG_DISABLE_FILESYSTEM
   } else {
     fp = fopen(path, "a");
 #endif
   }
   if (fp == NULL) return;
  
   mg_conn_addr_to_str(nc, src, sizeof(src),
                       MG_SOCK_STRINGIFY_IP | MG_SOCK_STRINGIFY_PORT);
   mg_conn_addr_to_str(nc, dst, sizeof(dst), MG_SOCK_STRINGIFY_IP |
                                                 MG_SOCK_STRINGIFY_PORT |
                                                 MG_SOCK_STRINGIFY_REMOTE);
   fprintf(
       fp, "%lu %p %s %s %s %d\n", (unsigned long) time(NULL), (void *) nc, src,
       ev == MG_EV_RECV ? "<-" : ev == MG_EV_SEND
                                     ? "->"
                                     : ev == MG_EV_ACCEPT
                                           ? "<A"
                                           : ev == MG_EV_CONNECT ? "C>" : "XX",
       dst, num_bytes);
   if (num_bytes > 0 && (hexbuf = (char *) MG_MALLOC(buf_size)) != NULL) {
     mg_hexdump(buf, num_bytes, hexbuf, buf_size);
     fprintf(fp, "%s", hexbuf);
     MG_FREE(hexbuf);
   }
   if (fp != stdin && fp != stdout) fclose(fp);
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_http_create_digest_auth_header()

int mg_http_create_digest_auth_header	(	char *	buf,
		size_t	buf_len,
		const char *	method,
		const char *	uri,
		const char *	auth_domain,
		const char *	user,
		const char *	passwd
	)

Definition at line 6156 of file mongoose6.cxx.

                                                           {
   static const char colon[] = ":", qop[] = "auth";
   static const size_t one = 1;
   char ha1[33], resp[33], cnonce[40];
  
   snprintf(cnonce, sizeof(cnonce), "%x", (unsigned int) time(NULL));
   cs_md5(ha1, user, (size_t) strlen(user), colon, one, auth_domain,
          (size_t) strlen(auth_domain), colon, one, passwd,
          (size_t) strlen(passwd), NULL);
   mg_mkmd5resp(method, strlen(method), uri, strlen(uri), ha1, sizeof(ha1) - 1,
                cnonce, strlen(cnonce), "1", one, cnonce, strlen(cnonce), qop,
                sizeof(qop) - 1, resp);
   return snprintf(buf, buf_len,
                   "Authorization: Digest username=\"%s\","
                   "realm=\"%s\",uri=\"%s\",qop=%s,nc=1,cnonce=%s,"
                   "nonce=%s,response=%s\r\n",
                   user, auth_domain, uri, qop, cnonce, cnonce, resp);
 }

Here is the call graph for this function:

◆ mg_http_parse_header()

int mg_http_parse_header	(	struct mg_str *	hdr,
		const char *	var_name,
		char *	buf,
		size_t	buf_size
	)

Definition at line 6084 of file mongoose6.cxx.

                                           {
   int ch = ' ', ch1 = ',', len = 0, n = strlen(var_name);
   const char *p, *end = hdr ? hdr->p + hdr->len : NULL, *s = NULL;
  
   if (buf != NULL && buf_size > 0) buf[0] = '\0';
   if (hdr == NULL) return 0;
  
   /* Find where variable starts */
   for (s = hdr->p; s != NULL && s + n < end; s++) {
     if ((s == hdr->p || s[-1] == ch || s[-1] == ch1) && s[n] == '=' &&
         !memcmp(s, var_name, n))
       break;
   }
  
   if (s != NULL && &s[n + 1] < end) {
     s += n + 1;
     if (*s == '"' || *s == '\'') {
       ch = ch1 = *s++;
     }
     p = s;
     while (p < end && p[0] != ch && p[0] != ch1 && len < (int) buf_size) {
       if (ch != ' ' && p[0] == '\\' && p[1] == ch) p++;
       buf[len++] = *p++;
     }
     if (len >= (int) buf_size || (ch != ' ' && *p != ch)) {
       len = 0;
     } else {
       if (len > 0 && s[len - 1] == ',') len--;
       if (len > 0 && s[len - 1] == ';') len--;
       buf[len] = '\0';
     }
   }
  
   return len;
 }

◆ mg_if_accept_new_conn()

struct mg_connection* mg_if_accept_new_conn ( struct mg_connection * lc )

Definition at line 2619 of file mongoose6.cxx.

                                                                       {
   struct mg_add_sock_opts opts;
   struct mg_connection *nc;
   memset(&opts, 0, sizeof(opts));
   nc = mg_create_connection(lc->mgr, lc->handler, opts);
   if (nc == NULL) return NULL;
   nc->listener = lc;
   nc->proto_handler = lc->proto_handler;
   nc->user_data = lc->user_data;
   nc->recv_mbuf_limit = lc->recv_mbuf_limit;
   mg_add_conn(nc->mgr, nc);
   DBG(("%p %p %d %d, %p %p", lc, nc, nc->sock, (int) nc->flags, lc->ssl_ctx,
        nc->ssl));
   return nc;
 }

Here is the call graph for this function:

◆ mg_if_accept_tcp_cb()

void mg_if_accept_tcp_cb	(	struct mg_connection *	nc,
		union socket_address *	sa,
		size_t	sa_len
	)

Definition at line 2635 of file mongoose6.cxx.

                                         {
   (void) sa_len;
   nc->sa = *sa;
   mg_call(nc, NULL, MG_EV_ACCEPT, &nc->sa);
 }

Here is the call graph for this function:

◆ mg_if_connect_cb()

void mg_if_connect_cb	(	struct mg_connection *	nc,
		int	err
	)

Definition at line 2758 of file mongoose6.cxx.

                                                          {
   DBG(("%p connect, err=%d", nc, err));
   nc->flags &= ~MG_F_CONNECTING;
   if (err != 0) {
     nc->flags |= MG_F_CLOSE_IMMEDIATELY;
   }
   mg_call(nc, NULL, MG_EV_CONNECT, &err);
 }

Here is the call graph for this function:

◆ mg_if_connect_tcp()

void mg_if_connect_tcp	(	struct mg_connection *	nc,
		const union socket_address *	sa
	)

Definition at line 3125 of file mongoose6.cxx.

                                                        {
   int rc;
   nc->sock = socket(AF_INET, SOCK_STREAM, 0);
   if (nc->sock < 0) {
     nc->sock = INVALID_SOCKET;
     nc->err = errno ? errno : 1;
     return;
   }
 #if !defined(MG_SOCKET_SIMPLELINK) && !defined(MG_ESP8266)
   mg_set_non_blocking_mode(nc->sock);
 #endif
   rc = connect(nc->sock, &sa->sa, sizeof(sa->sin));
   nc->err = mg_is_error(rc) ? errno : 0;
   DBG(("%p sock %d err %d", nc, nc->sock, nc->err));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_connect_udp()

void mg_if_connect_udp ( struct mg_connection * nc )

Definition at line 3142 of file mongoose6.cxx.

                                                  {
   nc->sock = socket(AF_INET, SOCK_DGRAM, 0);
   if (nc->sock < 0) {
     nc->sock = INVALID_SOCKET;
     nc->err = errno ? errno : 1;
     return;
   }
   nc->err = 0;
 }

Here is the caller graph for this function:

◆ mg_if_create_conn()

int mg_if_create_conn ( struct mg_connection * nc )

Definition at line 3181 of file mongoose6.cxx.

                                                 {
   (void) nc;
   return 1;
 }

Here is the caller graph for this function:

◆ mg_if_destroy_conn()

void mg_if_destroy_conn ( struct mg_connection * nc )

Definition at line 3186 of file mongoose6.cxx.

                                                   {
   if (nc->sock == INVALID_SOCKET) return;
   if (!(nc->flags & MG_F_UDP)) {
     closesocket(nc->sock);
   } else {
     /* Only close outgoing UDP sockets or listeners. */
     if (nc->listener == NULL) closesocket(nc->sock);
   }
   /*
    * avoid users accidentally double close a socket
    * because it can lead to difficult to debug situations.
    * It would happen only if reusing a destroyed mg_connection
    * but it's not always possible to run the code through an
    * address sanitizer.
    */
   nc->sock = INVALID_SOCKET;
 }

Here is the caller graph for this function:

◆ mg_if_get_conn_addr()

void mg_if_get_conn_addr	(	struct mg_connection *	nc,
		int	remote,
		union socket_address *	sa
	)

Definition at line 3773 of file mongoose6.cxx.

                                                    {
 #ifndef MG_SOCKET_SIMPLELINK
   mg_sock_get_addr(nc->sock, remote, sa);
 #else
   /* SimpleLink does not provide a way to get socket's peer address after
    * accept or connect. Address hould have been preserved in the connection,
    * so we do our best here by using it. */
   if (remote) memcpy(sa, &nc->sa, sizeof(*sa));
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_listen_tcp()

int mg_if_listen_tcp	(	struct mg_connection *	nc,
		union socket_address *	sa
	)

Definition at line 3152 of file mongoose6.cxx.

                                                                          {
   sock_t sock = mg_open_listening_socket(sa, SOCK_STREAM);
   if (sock == INVALID_SOCKET) {
     return (errno ? errno : 1);
   }
   mg_sock_set(nc, sock);
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_listen_udp()

int mg_if_listen_udp	(	struct mg_connection *	nc,
		union socket_address *	sa
	)

Definition at line 3161 of file mongoose6.cxx.

                                                                          {
   sock_t sock = mg_open_listening_socket(sa, SOCK_DGRAM);
   if (sock < 0) return (errno ? errno : 1);
   mg_sock_set(nc, sock);
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_poll()

void mg_if_poll	(	struct mg_connection *	nc,
		time_t	now
	)

Definition at line 2150 of file mongoose6.cxx.

                                                       {
   if (nc->ssl == NULL || (nc->flags & MG_F_SSL_HANDSHAKE_DONE)) {
     mg_call(nc, NULL, MG_EV_POLL, &now);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_recv_tcp_cb()

void mg_if_recv_tcp_cb	(	struct mg_connection *	nc,
		void *	buf,
		int	len
	)

Definition at line 2687 of file mongoose6.cxx.

                                                                      {
   mg_recv_common(nc, buf, len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_recv_udp_cb()

void mg_if_recv_udp_cb	(	struct mg_connection *	nc,
		void *	buf,
		int	len,
		union socket_address *	sa,
		size_t	sa_len
	)

Definition at line 2691 of file mongoose6.cxx.

                                                                 {
   assert(nc->flags & MG_F_UDP);
   DBG(("%p %u", nc, (unsigned int) len));
   if (nc->flags & MG_F_LISTENING) {
     struct mg_connection *lc = nc;
     /*
      * Do we have an existing connection for this source?
      * This is very inefficient for long connection lists.
      */
     for (nc = mg_next(lc->mgr, NULL); nc != NULL; nc = mg_next(lc->mgr, nc)) {
       if (memcmp(&nc->sa.sa, &sa->sa, sa_len) == 0 && nc->listener == lc) {
         break;
       }
     }
     if (nc == NULL) {
       struct mg_add_sock_opts opts;
       memset(&opts, 0, sizeof(opts));
       /* Create fake connection w/out sock initialization */
       nc = mg_create_connection_base(lc->mgr, lc->handler, opts);
       if (nc != NULL) {
         nc->sock = lc->sock;
         nc->listener = lc;
         nc->sa = *sa;
         nc->proto_handler = lc->proto_handler;
         nc->user_data = lc->user_data;
         nc->recv_mbuf_limit = lc->recv_mbuf_limit;
         nc->flags = MG_F_UDP;
         mg_add_conn(lc->mgr, nc);
         mg_call(nc, NULL, MG_EV_ACCEPT, &nc->sa);
       } else {
         DBG(("OOM"));
         /* No return here, we still need to drop on the floor */
       }
     }
   }
   if (nc != NULL) {
     mg_recv_common(nc, buf, len);
   } else {
     /* Drop on the floor. */
     MG_FREE(buf);
     mg_if_recved(nc, len);
   }
 }

Here is the call graph for this function:

◆ mg_if_recved()

void mg_if_recved	(	struct mg_connection *	nc,
		size_t	len
	)

Definition at line 3176 of file mongoose6.cxx.

                                                         {
   (void) nc;
   (void) len;
 }

Here is the caller graph for this function:

◆ mg_if_sent_cb()

void mg_if_sent_cb	(	struct mg_connection *	nc,
		int	num_sent
	)

Definition at line 2656 of file mongoose6.cxx.

                                                            {
   if (num_sent < 0) {
     nc->flags |= MG_F_CLOSE_IMMEDIATELY;
   }
   mg_call(nc, NULL, MG_EV_SEND, &num_sent);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_tcp_send()

void mg_if_tcp_send	(	struct mg_connection *	nc,
		const void *	buf,
		size_t	len
	)

Definition at line 3168 of file mongoose6.cxx.

                                                                            {
   mbuf_append(&nc->send_mbuf, buf, len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_timer()

void mg_if_timer	(	struct mg_connection *	c,
		double	now
	)

Definition at line 2136 of file mongoose6.cxx.

                                                       {
   if (c->ev_timer_time > 0 && now >= c->ev_timer_time) {
     double old_value = c->ev_timer_time;
     mg_call(c, NULL, MG_EV_TIMER, &now);
     /*
      * To prevent timer firing all the time, reset the timer after delivery.
      * However, in case user sets it to new value, do not reset.
      */
     if (c->ev_timer_time == old_value) {
       c->ev_timer_time = 0;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_udp_send()

void mg_if_udp_send	(	struct mg_connection *	nc,
		const void *	buf,
		size_t	len
	)

Definition at line 3172 of file mongoose6.cxx.

                                                                            {
   mbuf_append(&nc->send_mbuf, buf, len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_is_big_endian()

int mg_is_big_endian ( void )

Definition at line 8072 of file mongoose6.cxx.

                            {
   static const int n = 1;
   /* TODO(mkm) use compiletime check with 4-byte char literal */
   return ((char *) &n)[0] == 0;
 }

◆ mg_match_prefix()

size_t mg_match_prefix	(	const char *	pattern,
		int	pattern_len,
		const char *	str
	)

Definition at line 2354 of file mongoose614.cxx.

                                                                               {
   const struct mg_str pstr = {pattern, (size_t) pattern_len};
   struct mg_str s = {str, 0};
   if (str != NULL) s.len = strlen(str);
   return mg_match_prefix_n(pstr, s);
 }

Here is the call graph for this function:

◆ mg_match_prefix_n()

size_t mg_match_prefix_n	(	const struct mg_str	pattern,
		const struct mg_str	str
	)

Definition at line 2308 of file mongoose614.cxx.

                                                                                {
   const char *or_str;
   size_t res = 0, len = 0, i = 0, j = 0;
  
   if ((or_str = (const char *) memchr(pattern.p, '|', pattern.len)) != NULL ||
       (or_str = (const char *) memchr(pattern.p, ',', pattern.len)) != NULL) {
     struct mg_str pstr = {pattern.p, (size_t)(or_str - pattern.p)};
     res = mg_match_prefix_n(pstr, str);
     if (res > 0) return res;
     pstr.p = or_str + 1;
     pstr.len = (pattern.p + pattern.len) - (or_str + 1);
     return mg_match_prefix_n(pstr, str);
   }
  
   for (; i < pattern.len && j < str.len; i++, j++) {
     if (pattern.p[i] == '?') {
       continue;
     } else if (pattern.p[i] == '*') {
       i++;
       if (i < pattern.len && pattern.p[i] == '*') {
         i++;
         len = str.len - j;
       } else {
         len = 0;
         while (j + len < str.len && str.p[j + len] != '/') len++;
       }
       if (i == pattern.len || (pattern.p[i] == '$' && i == pattern.len - 1))
         return j + len;
       do {
         const struct mg_str pstr = {pattern.p + i, pattern.len - i};
         const struct mg_str sstr = {str.p + j + len, str.len - j - len};
         res = mg_match_prefix_n(pstr, sstr);
       } while (res == 0 && len != 0 && len-- > 0);
       return res == 0 ? 0 : j + res + len;
     } else if (str_util_lowercase(&pattern.p[i]) !=
                str_util_lowercase(&str.p[j])) {
       break;
     }
   }
   if (i < pattern.len && pattern.p[i] == '$') {
     return j == str.len ? str.len : 0;
   }
   return i == pattern.len ? j : 0;
 }

Here is the call graph for this function:

◆ mg_mgr_free()

void mg_mgr_free ( struct mg_mgr * m )

Definition at line 2238 of file mongoose6.cxx.

                                    {
   struct mg_connection *conn, *tmp_conn;
  
   DBG(("%p", m));
   if (m == NULL) return;
   /* Do one last poll, see https://github.com/cesanta/mongoose/issues/286 */
   mg_mgr_poll(m, 0);
  
 #ifndef MG_DISABLE_SOCKETPAIR
   if (m->ctl[0] != INVALID_SOCKET) closesocket(m->ctl[0]);
   if (m->ctl[1] != INVALID_SOCKET) closesocket(m->ctl[1]);
   m->ctl[0] = m->ctl[1] = INVALID_SOCKET;
 #endif
  
   for (conn = m->active_connections; conn != NULL; conn = tmp_conn) {
     tmp_conn = conn->next;
     mg_close_conn(conn);
   }
  
   mg_ev_mgr_free(m);
 }

Here is the call graph for this function:

◆ mg_mgr_init()

void mg_mgr_init	(	struct mg_mgr *	mgr,
		void *	user_data
	)

Definition at line 2179 of file mongoose6.cxx.

                                                     {
   memset(m, 0, sizeof(*m));
 #ifndef MG_DISABLE_SOCKETPAIR
   m->ctl[0] = m->ctl[1] = INVALID_SOCKET;
 #endif
   m->user_data = user_data;
  
 #ifdef _WIN32
   {
     WSADATA data;
     WSAStartup(MAKEWORD(2, 2), &data);
   }
 #elif defined(__unix__)
   /* Ignore SIGPIPE signal, so if client cancels the request, it
    * won't kill the whole process. */
   signal(SIGPIPE, SIG_IGN);
 #endif
  
 #ifdef MG_ENABLE_SSL
   {
     static int init_done;
     if (!init_done) {
       SSL_library_init();
       init_done++;
     }
   }
 #endif
  
   mg_ev_mgr_init(m);
   DBG(("=================================="));
   DBG(("init mgr=%p", m));
 }

Here is the call graph for this function:

◆ mg_mgr_poll()

time_t mg_mgr_poll	(	struct mg_mgr *	mgr,
		int	milli
	)

Definition at line 3594 of file mongoose6.cxx.

                                                        {
   double now = mg_time();
   double min_timer;
   struct mg_connection *nc, *tmp;
   struct timeval tv;
   fd_set read_set, write_set, err_set;
   sock_t max_fd = INVALID_SOCKET;
   int num_fds, num_ev, num_timers = 0;
  
   FD_ZERO(&read_set);
   FD_ZERO(&write_set);
   FD_ZERO(&err_set);
 #ifndef MG_DISABLE_SOCKETPAIR
   mg_add_to_set(mgr->ctl[1], &read_set, &max_fd);
 #endif
  
   /*
    * Note: it is ok to have connections with sock == INVALID_SOCKET in the list,
    * e.g. timer-only "connections".
    */
   min_timer = 0;
   for (nc = mgr->active_connections, num_fds = 0; nc != NULL; nc = tmp) {
     tmp = nc->next;
  
     //printf("nc %p -> mg_mgr_poll, mgr %p %p, pd %p, fp %p\n", nc, nc->mgr, mgr, nc->proto_data, (nc->proto_data?*(FILE**)nc->proto_data:NULL));
  
     if (nc->sock != INVALID_SOCKET) {
       num_fds++;
  
       if (!(nc->flags & MG_F_WANT_WRITE) &&
           nc->recv_mbuf.len < nc->recv_mbuf_limit &&
           (!(nc->flags & MG_F_UDP) || nc->listener == NULL)) {
         mg_add_to_set(nc->sock, &read_set, &max_fd);
       }
  
       if (((nc->flags & MG_F_CONNECTING) && !(nc->flags & MG_F_WANT_READ)) ||
           (nc->send_mbuf.len > 0 && !(nc->flags & MG_F_CONNECTING))) {
         mg_add_to_set(nc->sock, &write_set, &max_fd);
         mg_add_to_set(nc->sock, &err_set, &max_fd);
       }
     }
  
     if (nc->ev_timer_time > 0) {
       if (num_timers == 0 || nc->ev_timer_time < min_timer) {
         min_timer = nc->ev_timer_time;
       }
       num_timers++;
     }
   }
  
   /*
    * If there is a timer to be fired earlier than the requested timeout,
    * adjust the timeout.
    */
   if (num_timers > 0) {
     double timer_timeout_ms = (min_timer - mg_time()) * 1000 + 1 /* rounding */;
     if (timer_timeout_ms < timeout_ms) {
       timeout_ms = timer_timeout_ms;
     }
   }
   if (timeout_ms < 0) timeout_ms = 0;
  
   tv.tv_sec = timeout_ms / 1000;
   tv.tv_usec = (timeout_ms % 1000) * 1000;
  
   num_ev = select((int) max_fd + 1, &read_set, &write_set, &err_set, &tv);
   now = mg_time();
   DBG(("select @ %ld num_ev=%d of %d, timeout=%d", (long) now, num_ev, num_fds,
        timeout_ms));
  
 #ifndef MG_DISABLE_SOCKETPAIR
   if (num_ev > 0 && mgr->ctl[1] != INVALID_SOCKET &&
       FD_ISSET(mgr->ctl[1], &read_set)) {
     mg_mgr_handle_ctl_sock(mgr);
   }
 #endif
  
   for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
     int fd_flags = 0;
     if (nc->sock != INVALID_SOCKET) {
       if (num_ev > 0) {
         fd_flags = (FD_ISSET(nc->sock, &read_set) &&
                             (!(nc->flags & MG_F_UDP) || nc->listener == NULL)
                         ? _MG_F_FD_CAN_READ
                         : 0) |
                    (FD_ISSET(nc->sock, &write_set) ? _MG_F_FD_CAN_WRITE : 0) |
                    (FD_ISSET(nc->sock, &err_set) ? _MG_F_FD_ERROR : 0);
       }
 #ifdef MG_SOCKET_SIMPLELINK
       /* SimpleLink does not report UDP sockets as writeable. */
       if (nc->flags & MG_F_UDP &&
           (nc->send_mbuf.len > 0 || nc->flags & MG_F_CONNECTING)) {
         fd_flags |= _MG_F_FD_CAN_WRITE;
       }
 #endif
 #ifdef MG_LWIP
       /* With LWIP socket emulation layer, we don't get write events */
       fd_flags |= _MG_F_FD_CAN_WRITE;
 #endif
     }
     tmp = nc->next;
     mg_mgr_handle_conn(nc, fd_flags, now);
   }
  
   for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
     tmp = nc->next;
     if ((nc->flags & MG_F_CLOSE_IMMEDIATELY) ||
         (nc->send_mbuf.len == 0 && (nc->flags & MG_F_SEND_AND_CLOSE))) {
       //printf("nc %p -> mg_close_conn, mgr %p %p, pd %p, fp %p\n", nc, nc->mgr, mgr, nc->proto_data, (nc->proto_data?*(FILE**)nc->proto_data:NULL));
       mg_close_conn(nc);
     }
   }
  
   return now;
 }

Here is the call graph for this function:

◆ mg_mk_str()

struct mg_str mg_mk_str ( const char * s )

Definition at line 1691 of file mongoose614.cxx.

                                        {
   struct mg_str ret = {s, 0};
   if (s != NULL) ret.len = strlen(s);
   return ret;
 }

Here is the caller graph for this function:

◆ mg_mqtt_connack()

void mg_mqtt_connack	(	struct mg_connection *	nc,
		uint8_t	return_code
	)

Definition at line 8566 of file mongoose6.cxx.

                                                                     {
   uint8_t unused = 0;
   mg_send(nc, &unused, 1);
   mg_send(nc, &return_code, 1);
   mg_mqtt_prepend_header(nc, MG_MQTT_CMD_CONNACK, 0, 2);
 }

Here is the call graph for this function:

◆ mg_mqtt_disconnect()

void mg_mqtt_disconnect ( struct mg_connection * nc )

Definition at line 8624 of file mongoose6.cxx.

                                                   {
   mg_mqtt_prepend_header(nc, MG_MQTT_CMD_DISCONNECT, 0, 0);
 }

Here is the call graph for this function:

◆ mg_mqtt_next_subscribe_topic()

int mg_mqtt_next_subscribe_topic	(	struct mg_mqtt_message *	msg,
		struct mg_str *	topic,
		uint8_t *	qos,
		int	pos
	)

Definition at line 8535 of file mongoose6.cxx.

                                                                               {
   unsigned char *buf = (unsigned char *) msg->payload.p + pos;
   if ((size_t) pos >= msg->payload.len) {
     return -1;
   }
  
   topic->len = buf[0] << 8 | buf[1];
   topic->p = (char *) buf + 2;
   *qos = buf[2 + topic->len];
   return pos + 2 + topic->len + 1;
 }

◆ mg_mqtt_ping()

void mg_mqtt_ping ( struct mg_connection * nc )

Definition at line 8616 of file mongoose6.cxx.

                                             {
   mg_mqtt_prepend_header(nc, MG_MQTT_CMD_PINGREQ, 0, 0);
 }

Here is the call graph for this function:

◆ mg_mqtt_pong()

void mg_mqtt_pong ( struct mg_connection * nc )

Definition at line 8620 of file mongoose6.cxx.

                                             {
   mg_mqtt_prepend_header(nc, MG_MQTT_CMD_PINGRESP, 0, 0);
 }

Here is the call graph for this function:

◆ mg_mqtt_puback()

void mg_mqtt_puback	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Definition at line 8585 of file mongoose6.cxx.

                                                                    {
   mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBACK, message_id);
 }

Here is the call graph for this function:

◆ mg_mqtt_pubcomp()

void mg_mqtt_pubcomp	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Definition at line 8597 of file mongoose6.cxx.

                                                                     {
   mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBCOMP, message_id);
 }

Here is the call graph for this function:

◆ mg_mqtt_publish()

void mg_mqtt_publish	(	struct mg_connection *	nc,
		const char *	topic,
		uint16_t	message_id,
		int	flags,
		const void *	data,
		size_t	len
	)

Definition at line 8496 of file mongoose6.cxx.

                                  {
   size_t old_len = nc->send_mbuf.len;
  
   uint16_t topic_len = htons(strlen(topic));
   uint16_t message_id_net = htons(message_id);
  
   mg_send(nc, &topic_len, 2);
   mg_send(nc, topic, strlen(topic));
   if (MG_MQTT_GET_QOS(flags) > 0) {
     mg_send(nc, &message_id_net, 2);
   }
   mg_send(nc, data, len);
  
   mg_mqtt_prepend_header(nc, MG_MQTT_CMD_PUBLISH, flags,
                          nc->send_mbuf.len - old_len);
 }

Here is the call graph for this function:

◆ mg_mqtt_pubrec()

void mg_mqtt_pubrec	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Definition at line 8589 of file mongoose6.cxx.

                                                                    {
   mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBREC, message_id);
 }

Here is the call graph for this function:

◆ mg_mqtt_pubrel()

void mg_mqtt_pubrel	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Definition at line 8593 of file mongoose6.cxx.

                                                                    {
   mg_send_mqtt_short_command(nc, MG_MQTT_CMD_PUBREL, message_id);
 }

Here is the call graph for this function:

◆ mg_mqtt_suback()

void mg_mqtt_suback	(	struct mg_connection *	nc,
		uint8_t *	qoss,
		size_t	qoss_len,
		uint16_t	message_id
	)

Definition at line 8601 of file mongoose6.cxx.

                                          {
   size_t i;
   uint16_t message_id_net = htons(message_id);
   mg_send(nc, &message_id_net, 2);
   for (i = 0; i < qoss_len; i++) {
     mg_send(nc, &qoss[i], 1);
   }
   mg_mqtt_prepend_header(nc, MG_MQTT_CMD_SUBACK, MG_MQTT_QOS(1), 2 + qoss_len);
 }

Here is the call graph for this function:

◆ mg_mqtt_subscribe()

void mg_mqtt_subscribe	(	struct mg_connection *	nc,
		const struct mg_mqtt_topic_expression *	topics,
		size_t	topics_len,
		uint16_t	message_id
	)

Definition at line 8515 of file mongoose6.cxx.

                                                                {
   size_t old_len = nc->send_mbuf.len;
  
   uint16_t message_id_n = htons(message_id);
   size_t i;
  
   mg_send(nc, (char *) &message_id_n, 2);
   for (i = 0; i < topics_len; i++) {
     uint16_t topic_len_n = htons(strlen(topics[i].topic));
     mg_send(nc, &topic_len_n, 2);
     mg_send(nc, topics[i].topic, strlen(topics[i].topic));
     mg_send(nc, &topics[i].qos, 1);
   }
  
   mg_mqtt_prepend_header(nc, MG_MQTT_CMD_SUBSCRIBE, MG_MQTT_QOS(1),
                          nc->send_mbuf.len - old_len);
 }

Here is the call graph for this function:

◆ mg_mqtt_unsuback()

void mg_mqtt_unsuback	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Definition at line 8612 of file mongoose6.cxx.

                                                                      {
   mg_send_mqtt_short_command(nc, MG_MQTT_CMD_UNSUBACK, message_id);
 }

Here is the call graph for this function:

◆ mg_mqtt_unsubscribe()

void mg_mqtt_unsubscribe	(	struct mg_connection *	nc,
		char **	topics,
		size_t	topics_len,
		uint16_t	message_id
	)

Definition at line 8548 of file mongoose6.cxx.

                                                                  {
   size_t old_len = nc->send_mbuf.len;
  
   uint16_t message_id_n = htons(message_id);
   size_t i;
  
   mg_send(nc, (char *) &message_id_n, 2);
   for (i = 0; i < topics_len; i++) {
     uint16_t topic_len_n = htons(strlen(topics[i]));
     mg_send(nc, &topic_len_n, 2);
     mg_send(nc, topics[i], strlen(topics[i]));
   }
  
   mg_mqtt_prepend_header(nc, MG_MQTT_CMD_UNSUBSCRIBE, MG_MQTT_QOS(1),
                          nc->send_mbuf.len - old_len);
 }

Here is the call graph for this function:

◆ mg_ncasecmp()

int mg_ncasecmp	(	const char *	s1,
		const char *	s2,
		size_t	len
	)

Definition at line 2187 of file mongoose614.cxx.

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

Here is the call graph for this function:

◆ mg_next()

struct mg_connection* mg_next	(	struct mg_mgr *	s,
		struct mg_connection *	conn
	)

Definition at line 2955 of file mongoose6.cxx.

                                                                             {
   return conn == NULL ? s->active_connections : conn->next;
 }

◆ mg_next_comma_list_entry()

const char * mg_next_comma_list_entry	(	const char *	list,
		struct mg_str *	val,
		struct mg_str *	eq_val
	)

Definition at line 2263 of file mongoose614.cxx.

                                                             {
   struct mg_str ret = mg_next_comma_list_entry_n(mg_mk_str(list), val, eq_val);
   return ret.p;
 }

Here is the call graph for this function:

◆ mg_normalize_uri_path()

int mg_normalize_uri_path	(	const struct mg_str *	in,
		struct mg_str *	out
	)

Definition at line 4042 of file mongoose6.cxx.

                                                                        {
   const char *s = in->p, *se = s + in->len;
   char *cp = (char *) out->p, *d;
  
   if (in->len == 0 || *s != '/') {
     out->len = 0;
     return 0;
   }
  
   d = cp;
  
   while (s < se) {
     const char *next = s;
     struct mg_str component;
     parse_uri_component(&next, se, '/', &component);
     if (mg_vcmp(&component, ".") == 0) {
       /* Yum. */
     } else if (mg_vcmp(&component, "..") == 0) {
       /* Backtrack to previous slash. */
       if (d > cp + 1 && *(d - 1) == '/') d--;
       while (d > cp && *(d - 1) != '/') d--;
     } else {
       memmove(d, s, next - s);
       d += next - s;
     }
     s = next;
   }
   if (d == cp) *d++ = '/';
  
   out->p = cp;
   out->len = d - cp;
   return 1;
 }

Here is the call graph for this function:

◆ mg_open()

int mg_open	(	const char *	path,
		int	flag,
		int	mode
	)

Definition at line 7863 of file mongoose6.cxx.

                                                   { /* LCOV_EXCL_LINE */
 #ifdef _WIN32
   wchar_t wpath[MAX_PATH_SIZE];
   to_wchar(path, wpath, ARRAY_SIZE(wpath));
   return _wopen(wpath, flag, mode);
 #else
   return open(path, flag, mode); /* LCOV_EXCL_LINE */
 #endif
 }

◆ mg_parse_dns()

int mg_parse_dns	(	const char *	buf,
		int	len,
		struct mg_dns_message *	msg
	)

Definition at line 9048 of file mongoose6.cxx.

                                                                        {
   struct mg_dns_header *header = (struct mg_dns_header *) buf;
   unsigned char *data = (unsigned char *) buf + sizeof(*header);
   unsigned char *end = (unsigned char *) buf + len;
   int i;
  
   memset(msg, 0, sizeof(*msg));
   msg->pkt.p = buf;
   msg->pkt.len = len;
  
   if (len < (int) sizeof(*header)) return -1;
  
   msg->transaction_id = header->transaction_id;
   msg->flags = ntohs(header->flags);
   msg->num_questions = ntohs(header->num_questions);
   if (msg->num_questions > (int) ARRAY_SIZE(msg->questions)) {
     msg->num_questions = (int) ARRAY_SIZE(msg->questions);
   }
   msg->num_answers = ntohs(header->num_answers);
   if (msg->num_answers > (int) ARRAY_SIZE(msg->answers)) {
     msg->num_answers = (int) ARRAY_SIZE(msg->answers);
   }
  
   for (i = 0; i < msg->num_questions; i++) {
     data = mg_parse_dns_resource_record(data, end, &msg->questions[i], 0);
     if (data == NULL) return -1;
   }
  
   for (i = 0; i < msg->num_answers; i++) {
     data = mg_parse_dns_resource_record(data, end, &msg->answers[i], 1);
     if (data == NULL) return -1;
   }
  
   return 0;
 }

Here is the call graph for this function:

◆ mg_parse_http()

int mg_parse_http	(	const char *	s,
		int	n,
		struct http_message *	hm,
		int	is_req
	)

Definition at line 4402 of file mongoose6.cxx.

                                                                              {
   const char *end, *qs;
   int len = mg_http_get_request_len(s, n);
  
   if (len <= 0) return len;
  
   memset(hm, 0, sizeof(*hm));
   hm->message.p = s;
   hm->body.p = s + len;
   hm->message.len = hm->body.len = (size_t) ~0;
   end = s + len;
  
   /* Request is fully buffered. Skip leading whitespaces. */
   while (s < end && isspace(*(unsigned char *) s)) s++;
  
   if (is_req) {
     /* Parse request line: method, URI, proto */
     s = mg_skip(s, end, " ", &hm->method);
     s = mg_skip(s, end, " ", &hm->uri);
     s = mg_skip(s, end, "\r\n", &hm->proto);
     if (hm->uri.p <= hm->method.p || hm->proto.p <= hm->uri.p) return -1;
  
     /* If URI contains '?' character, initialize query_string */
     if ((qs = (char *) memchr(hm->uri.p, '?', hm->uri.len)) != NULL) {
       hm->query_string.p = qs + 1;
       hm->query_string.len = &hm->uri.p[hm->uri.len] - (qs + 1);
       hm->uri.len = qs - hm->uri.p;
     }
   } else {
     s = mg_skip(s, end, " ", &hm->proto);
     if (end - s < 4 || s[3] != ' ') return -1;
     hm->resp_code = atoi(s);
     if (hm->resp_code < 100 || hm->resp_code >= 600) return -1;
     s += 4;
     s = mg_skip(s, end, "\r\n", &hm->resp_status_msg);
   }
  
   s = mg_http_parse_headers(s, end, len, hm);
  
   /*
    * mg_parse_http() is used to parse both HTTP requests and HTTP
    * responses. If HTTP response does not have Content-Length set, then
    * body is read until socket is closed, i.e. body.len is infinite (~0).
    *
    * For HTTP requests though, according to
    * http://tools.ietf.org/html/rfc7231#section-8.1.3,
    * only POST and PUT methods have defined body semantics.
    * Therefore, if Content-Length is not specified and methods are
    * not one of PUT or POST, set body length to 0.
    *
    * So,
    * if it is HTTP request, and Content-Length is not set,
    * and method is not (PUT or POST) then reset body length to zero.
    */
   if (hm->body.len == (size_t) ~0 && is_req &&
       mg_vcasecmp(&hm->method, "PUT") != 0 &&
       mg_vcasecmp(&hm->method, "POST") != 0) {
     hm->body.len = 0;
     hm->message.len = len;
   }
  
   return len;
 }

Here is the call graph for this function:

◆ mg_parse_multipart()

size_t mg_parse_multipart	(	const char *	buf,
		size_t	buf_len,
		char *	var_name,
		size_t	var_name_len,
		char *	file_name,
		size_t	file_name_len,
		const char **	chunk,
		size_t *	chunk_len
	)

Definition at line 7732 of file mongoose6.cxx.

                                             {
   static const char cd[] = "Content-Disposition: ";
   size_t hl, bl, n, ll, pos, cdl = sizeof(cd) - 1;
  
   if (buf == NULL || buf_len <= 0) return 0;
   if ((hl = mg_http_get_request_len(buf, buf_len)) <= 0) return 0;
   if (buf[0] != '-' || buf[1] != '-' || buf[2] == '\n') return 0;
  
   /* Get boundary length */
   bl = mg_get_line_len(buf, buf_len);
  
   /* Loop through headers, fetch variable name and file name */
   var_name[0] = file_name[0] = '\0';
   for (n = bl; (ll = mg_get_line_len(buf + n, hl - n)) > 0; n += ll) {
     if (mg_ncasecmp(cd, buf + n, cdl) == 0) {
       struct mg_str header;
       header.p = buf + n + cdl;
       header.len = ll - (cdl + 2);
       mg_http_parse_header(&header, "name", var_name, var_name_len);
       mg_http_parse_header(&header, "filename", file_name, file_name_len);
     }
   }
  
   /* Scan through the body, search for terminating boundary */
   for (pos = hl; pos + (bl - 2) < buf_len; pos++) {
     if (buf[pos] == '-' && !memcmp(buf, &buf[pos], bl - 2)) {
       if (data_len != NULL) *data_len = (pos - 2) - hl;
       if (data != NULL) *data = buf + hl;
       return pos;
     }
   }
  
   return 0;
 }

Here is the call graph for this function:

◆ mg_parse_uri()

int mg_parse_uri	(	struct mg_str	uri,
		struct mg_str *	scheme,
		struct mg_str *	user_info,
		struct mg_str *	host,
		unsigned int *	port,
		struct mg_str *	path,
		struct mg_str *	query,
		struct mg_str *	fragment
	)

Definition at line 3926 of file mongoose6.cxx.

                                           {
   struct mg_str rscheme = {0, 0}, ruser_info = {0, 0}, rhost = {0, 0},
                 rpath = {0, 0}, rquery = {0, 0}, rfragment = {0, 0};
   unsigned int rport = 0;
   enum {
     P_START,
     P_SCHEME_OR_PORT,
     P_USER_INFO,
     P_HOST,
     P_PORT,
     P_REST
   } state = P_START;
  
   const char *p = uri.p, *end = p + uri.len;
   while (p < end) {
     switch (state) {
       case P_START:
         /*
          * expecting on of:
          * - `scheme://xxxx`
          * - `xxxx:port`
          * - `xxxx/path`
          */
         for (; p < end; p++) {
           if (*p == ':') {
             state = P_SCHEME_OR_PORT;
             break;
           } else if (*p == '/') {
             state = P_REST;
             break;
           }
         }
         if (state == P_START || state == P_REST) {
           rhost.p = uri.p;
           rhost.len = p - uri.p;
         }
         break;
       case P_SCHEME_OR_PORT:
         if (end - p >= 3 && memcmp(p, "://", 3) == 0) {
           rscheme.p = uri.p;
           rscheme.len = p - uri.p;
           state = P_USER_INFO;
           p += 2; /* point to last separator char */
         } else {
           rhost.p = uri.p;
           rhost.len = p - uri.p;
           state = P_PORT;
         }
         break;
       case P_USER_INFO:
         p++;
         ruser_info.p = p;
         for (; p < end; p++) {
           if (*p == '@') {
             state = P_HOST;
             break;
           } else if (*p == '/') {
             break;
           }
         }
         if (p == end || *p == '/') {
           /* backtrack and parse as host */
           state = P_HOST;
           p = ruser_info.p;
         }
         ruser_info.len = p - ruser_info.p;
         break;
       case P_HOST:
         if (*p == '@') p++;
         rhost.p = p;
         for (; p < end; p++) {
           if (*p == ':') {
             state = P_PORT;
             break;
           } else if (*p == '/') {
             state = P_REST;
             break;
           }
         }
         rhost.len = p - rhost.p;
         break;
       case P_PORT:
         p++;
         for (; p < end; p++) {
           if (*p == '/') {
             state = P_REST;
             break;
           }
           rport *= 10;
           rport += *p - '0';
         }
         break;
       case P_REST:
         /* `p` points to separator. `path` includes the separator */
         parse_uri_component(&p, end, '?', &rpath);
         parse_uri_component(&p, end, '#', &rquery);
         parse_uri_component(&p, end, '\0', &rfragment);
         break;
     }
   }
  
   if (scheme != 0) *scheme = rscheme;
   if (user_info != 0) *user_info = ruser_info;
   if (host != 0) *host = rhost;
   if (port != 0) *port = rport;
   if (path != 0) *path = rpath;
   if (query != 0) *query = rquery;
   if (fragment != 0) *fragment = rfragment;
  
   return 0;
 }

Here is the call graph for this function:

◆ mg_printf()

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

Definition at line 1922 of file mongoose4.cxx.

                                                                 {
   va_list ap;
   va_start(ap, fmt);
   return mg_vprintf(conn, fmt, ap);
 }

Here is the call graph for this function:

◆ mg_printf_html_escape()

void mg_printf_html_escape	(	struct mg_connection *	nc,
		const char *	fmt,
			...
	)

Definition at line 6057 of file mongoose6.cxx.

                                                                            {
   char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem;
   int i, j, len;
   va_list ap;
  
   va_start(ap, fmt);
   len = mg_avprintf(&buf, sizeof(mem), fmt, ap);
   va_end(ap);
  
   if (len >= 0) {
     for (i = j = 0; i < len; i++) {
       if (buf[i] == '<' || buf[i] == '>') {
         mg_send(nc, buf + j, i - j);
         mg_send(nc, buf[i] == '<' ? "&lt;" : "&gt;", 4);
         j = i + 1;
       }
     }
     mg_send(nc, buf + j, i - j);
   }
  
   /* LCOV_EXCL_START */
   if (buf != mem && buf != NULL) {
     MG_FREE(buf);
   }
   /* LCOV_EXCL_STOP */
 }

Here is the call graph for this function:

◆ mg_printf_http_chunk()

void mg_printf_http_chunk	(	struct mg_connection *	nc,
		const char *	fmt,
			...
	)

Definition at line 6037 of file mongoose6.cxx.

                                                                           {
   char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem;
   int len;
   va_list ap;
  
   va_start(ap, fmt);
   len = mg_avprintf(&buf, sizeof(mem), fmt, ap);
   va_end(ap);
  
   if (len >= 0) {
     mg_send_http_chunk(nc, buf, len);
   }
  
   /* LCOV_EXCL_START */
   if (buf != mem && buf != NULL) {
     MG_FREE(buf);
   }
   /* LCOV_EXCL_STOP */
 }

Here is the call graph for this function:

◆ mg_printf_websocket_frame()

void mg_printf_websocket_frame	(	struct mg_connection *	nc,
		int	op_and_flags,
		const char *	fmt,
			...
	)

Definition at line 4697 of file mongoose6.cxx.

                                                      {
   char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem;
   va_list ap;
   int len;
  
   va_start(ap, fmt);
   if ((len = mg_avprintf(&buf, sizeof(mem), fmt, ap)) > 0) {
     mg_send_websocket_frame(nc, op, buf, len);
   }
   va_end(ap);
  
   if (buf != mem && buf != NULL) {
     MG_FREE(buf);
   }
 }

Here is the call graph for this function:

◆ mg_register_http_endpoint()

void mg_register_http_endpoint	(	struct mg_connection *	nc,
		const char *	uri_path,
		mg_event_handler_t	handler
	)

Definition at line 7770 of file mongoose6.cxx.

                                                            {
   struct mg_http_proto_data *pd = mg_http_get_proto_data(nc);
   struct mg_http_endpoint *new_ep =
       (struct mg_http_endpoint *) calloc(1, sizeof(*new_ep));
   new_ep->name = strdup(uri_path);
   new_ep->name_len = strlen(new_ep->name);
   new_ep->handler = handler;
   new_ep->next = pd->endpoints;
   pd->endpoints = new_ep;
 }

Here is the call graph for this function:

◆ mg_resolve()

int mg_resolve	(	const char *	domain_name,
		char *	ip_addr_buf,
		size_t	buf_len
	)

Definition at line 2315 of file mongoose6.cxx.

                                                       {
   struct in_addr ad;
   return mg_resolve2(host, &ad) ? snprintf(buf, n, "%s", inet_ntoa(ad)) : 0;
 }

Here is the call graph for this function:

◆ mg_resolve_async()

int mg_resolve_async	(	struct mg_mgr *	mgr,
		const char *	name,
		int	query,
		mg_resolve_callback_t	cb,
		void *	data
	)

Definition at line 9447 of file mongoose6.cxx.

                                                            {
   struct mg_resolve_async_opts opts;
   memset(&opts, 0, sizeof(opts));
   return mg_resolve_async_opt(mgr, name, query, cb, data, opts);
 }

Here is the call graph for this function:

◆ mg_resolve_async_opt()

int mg_resolve_async_opt	(	struct mg_mgr *	mgr,
		const char *	name,
		int	query,
		mg_resolve_callback_t	cb,
		void *	data,
		struct mg_resolve_async_opts	opts
	)

Definition at line 9454 of file mongoose6.cxx.

                                                             {
   struct mg_resolve_async_request *req;
   struct mg_connection *dns_nc;
   const char *nameserver = opts.nameserver_url;
  
   DBG(("%s %d %p", name, query, opts.dns_conn));
  
   /* resolve with DNS */
   req = (struct mg_resolve_async_request *) MG_CALLOC(1, sizeof(*req));
   if (req == NULL) {
     return -1;
   }
  
   memset(req->name, 0, sizeof(req->name));
   strncpy(req->name, name, sizeof(req->name)-1);
   req->query = query;
   req->callback = cb;
   req->data = data;
   /* TODO(mkm): parse defaults out of resolve.conf */
   req->max_retries = opts.max_retries ? opts.max_retries : 2;
   req->timeout = opts.timeout ? opts.timeout : 5;
  
   /* Lazily initialize dns server */
   if (nameserver == NULL && mg_dns_server[0] == '\0' &&
       mg_get_ip_address_of_nameserver(mg_dns_server, sizeof(mg_dns_server)) ==
           -1) {
     strncpy(mg_dns_server, mg_default_dns_server, sizeof(mg_dns_server));
   }
  
   if (nameserver == NULL) {
     nameserver = mg_dns_server;
   }
  
   dns_nc = mg_connect(mgr, nameserver, mg_resolve_async_eh);
   if (dns_nc == NULL) {
     free(req);
     return -1;
   }
   dns_nc->user_data = req;
   if (opts.dns_conn != NULL) {
     *opts.dns_conn = dns_nc;
   }
  
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_resolve_from_hosts_file()

int mg_resolve_from_hosts_file	(	const char *	host,
		union socket_address *	usa
	)

Definition at line 9352 of file mongoose6.cxx.

                                                                             {
 #ifndef MG_DISABLE_FILESYSTEM
   /* TODO(mkm) cache /etc/hosts */
   FILE *fp;
   char line[1024];
   char *p;
   char alias[256];
   unsigned int a, b, c, d;
   int len = 0;
  
   if ((fp = fopen("/etc/hosts", "r")) == NULL) {
     return -1;
   }
  
   for (; fgets(line, sizeof(line), fp) != NULL;) {
     if (line[0] == '#') continue;
  
     if (sscanf(line, "%u.%u.%u.%u%n", &a, &b, &c, &d, &len) == 0) {
       /* TODO(mkm): handle ipv6 */
       continue;
     }
     for (p = line + len; sscanf(p, "%s%n", alias, &len) == 1; p += len) {
       if (strcmp(alias, name) == 0) {
         usa->sin.sin_addr.s_addr = htonl(a << 24 | b << 16 | c << 8 | d);
         fclose(fp);
         return 0;
       }
     }
   }
  
   fclose(fp);
 #endif
  
   return -1;
 }

Here is the caller graph for this function:

◆ mg_rpc_create_error()

int mg_rpc_create_error	(	char *	buf,
		int	len,
		struct mg_rpc_request *	req,
		int	code,
		const char *	message,
		const char *	fmt,
			...
	)

Definition at line 8219 of file mongoose6.cxx.

                                                                              {
   va_list ap;
   int n = 0;
  
   n += json_emit(buf + n, len - n, "{s:s,s:V,s:{s:i,s:s,s:", "jsonrpc", "2.0",
                  "id", req->id == NULL ? "null" : req->id->ptr,
                  req->id == NULL ? 4 : req->id->len, "error", "code",
                  (long) code, "message", message, "data");
   va_start(ap, fmt);
   n += json_emit_va(buf + n, len - n, fmt, ap);
   va_end(ap);
  
   n += json_emit(buf + n, len - n, "}}");
  
   return n;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_rpc_create_reply()

int mg_rpc_create_reply	(	char *	buf,
		int	len,
		const struct mg_rpc_request *	req,
		const char *	result_fmt,
			...
	)

Definition at line 8179 of file mongoose6.cxx.

                                                      {
   static const struct json_token null_tok = {"null", 4, 0, JSON_TYPE_NULL};
   const struct json_token *id = req->id == NULL ? &null_tok : req->id;
   va_list ap;
   int n = 0;
  
   n += json_emit(buf + n, len - n, "{s:s,s:", "jsonrpc", "2.0", "id");
   if (id->type == JSON_TYPE_STRING) {
     n += json_emit_quoted_str(buf + n, len - n, id->ptr, id->len);
   } else {
     n += json_emit_unquoted_str(buf + n, len - n, id->ptr, id->len);
   }
   n += json_emit(buf + n, len - n, ",s:", "result");
  
   va_start(ap, result_fmt);
   n += json_emit_va(buf + n, len - n, result_fmt, ap);
   va_end(ap);
  
   n += json_emit(buf + n, len - n, "}");
  
   return n;
 }

Here is the call graph for this function:

◆ mg_rpc_create_request()

int mg_rpc_create_request	(	char *	buf,
		int	len,
		const char *	method,
		const char *	id,
		const char *	params_fmt,
			...
	)

Definition at line 8203 of file mongoose6.cxx.

                                                                        {
   va_list ap;
   int n = 0;
  
   n += json_emit(buf + n, len - n, "{s:s,s:s,s:s,s:", "jsonrpc", "2.0", "id",
                  id, "method", method, "params");
   va_start(ap, params_fmt);
   n += json_emit_va(buf + n, len - n, params_fmt, ap);
   va_end(ap);
  
   n += json_emit(buf + n, len - n, "}");
  
   return n;
 }

Here is the call graph for this function:

◆ mg_rpc_create_std_error()

int mg_rpc_create_std_error	(	char *	buf,
		int	len,
		struct mg_rpc_request *	req,
		int	code
	)

Definition at line 8237 of file mongoose6.cxx.

                                       {
   const char *message = NULL;
  
   switch (code) {
     case JSON_RPC_PARSE_ERROR:
       message = "parse error";
       break;
     case JSON_RPC_INVALID_REQUEST_ERROR:
       message = "invalid request";
       break;
     case JSON_RPC_METHOD_NOT_FOUND_ERROR:
       message = "method not found";
       break;
     case JSON_RPC_INVALID_PARAMS_ERROR:
       message = "invalid parameters";
       break;
     case JSON_RPC_SERVER_ERROR:
       message = "server error";
       break;
     default:
       message = "unspecified error";
       break;
   }
  
   return mg_rpc_create_error(buf, len, req, code, message, "N");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_rpc_dispatch()

int mg_rpc_dispatch	(	const char *	buf,
		int	len,
		char *	dst,
		int	dst_len,
		const char **	methods,
		mg_rpc_handler_t *	handlers
	)

Definition at line 8265 of file mongoose6.cxx.

                                                                       {
   struct json_token tokens[200];
   struct mg_rpc_request req;
   int i, n;
  
   memset(&req, 0, sizeof(req));
   n = parse_json(buf, len, tokens, sizeof(tokens) / sizeof(tokens[0]));
   if (n <= 0) {
     int err_code = (n == JSON_STRING_INVALID) ? JSON_RPC_PARSE_ERROR
                                               : JSON_RPC_SERVER_ERROR;
     return mg_rpc_create_std_error(dst, dst_len, &req, err_code);
   }
  
   req.message = tokens;
   req.id = find_json_token(tokens, "id");
   req.method = find_json_token(tokens, "method");
   req.params = find_json_token(tokens, "params");
  
   if (req.id == NULL || req.method == NULL) {
     return mg_rpc_create_std_error(dst, dst_len, &req,
                                    JSON_RPC_INVALID_REQUEST_ERROR);
   }
  
   for (i = 0; methods[i] != NULL; i++) {
     int mlen = strlen(methods[i]);
     if (mlen == req.method->len &&
         memcmp(methods[i], req.method->ptr, mlen) == 0)
       break;
   }
  
   if (methods[i] == NULL) {
     return mg_rpc_create_std_error(dst, dst_len, &req,
                                    JSON_RPC_METHOD_NOT_FOUND_ERROR);
   }
  
   return handlers[i](dst, dst_len, &req);
 }

Here is the call graph for this function:

◆ mg_rpc_parse_reply()

int mg_rpc_parse_reply	(	const char *	buf,
		int	len,
		struct json_token *	toks,
		int	max_toks,
		struct mg_rpc_reply *	rep,
		struct mg_rpc_error *	er
	)

Definition at line 8304 of file mongoose6.cxx.

                                                 {
   int n = parse_json(buf, len, toks, max_toks);
  
   memset(rep, 0, sizeof(*rep));
   memset(er, 0, sizeof(*er));
  
   if (n > 0) {
     if ((rep->result = find_json_token(toks, "result")) != NULL) {
       rep->message = toks;
       rep->id = find_json_token(toks, "id");
     } else {
       er->message = toks;
       er->id = find_json_token(toks, "id");
       er->error_code = find_json_token(toks, "error.code");
       er->error_message = find_json_token(toks, "error.message");
       er->error_data = find_json_token(toks, "error.data");
     }
   }
   return n;
 }

Here is the call graph for this function:

◆ mg_send()

void mg_send	(	struct mg_connection *	nc,
		const void *	buf,
		int	len
	)

Definition at line 2642 of file mongoose6.cxx.

                                                                  {
   nc->last_io_time = mg_time();
   if (nc->flags & MG_F_UDP) {
     mg_if_udp_send(nc, buf, len);
   } else {
     mg_if_tcp_send(nc, buf, len);
   }
 #if !defined(NO_LIBC) && !defined(MG_DISABLE_HEXDUMP)
   if (nc->mgr && nc->mgr->hexdump_file != NULL) {
     mg_hexdump_connection(nc, nc->mgr->hexdump_file, buf, len, MG_EV_SEND);
   }
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_send_dns_query()

void mg_send_dns_query	(	struct mg_connection *	nc,
		const char *	name,
		int	query_type
	)

Definition at line 8961 of file mongoose6.cxx.

                                        {
   struct mg_dns_message *msg =
       (struct mg_dns_message *) MG_CALLOC(1, sizeof(*msg));
   struct mbuf pkt;
   struct mg_dns_resource_record *rr = &msg->questions[0];
  
   DBG(("%s %d", name, query_type));
  
   mbuf_init(&pkt, 64 /* Start small, it'll grow as needed. */);
  
   msg->transaction_id = ++mg_dns_tid;
   msg->flags = 0x100;
   msg->num_questions = 1;
  
   mg_dns_insert_header(&pkt, 0, msg);
  
   rr->rtype = query_type;
   rr->rclass = 1; /* Class: inet */
   rr->kind = MG_DNS_QUESTION;
  
   if (mg_dns_encode_record(&pkt, rr, name, strlen(name), NULL, 0) == -1) {
     /* TODO(mkm): return an error code */
     goto cleanup; /* LCOV_EXCL_LINE */
   }
  
   /* TCP DNS requires messages to be prefixed with len */
   if (!(nc->flags & MG_F_UDP)) {
     uint16_t len = htons(pkt.len);
     mbuf_insert(&pkt, 0, &len, 2);
   }
  
   mg_send(nc, pkt.buf, pkt.len);
   mbuf_free(&pkt);
  
 cleanup:
   MG_FREE(msg);
 }

Here is the call graph for this function:

◆ mg_send_head()

void mg_send_head	(	struct mg_connection *	n,
		int	status_code,
		int64_t	content_length,
		const char *	extra_headers
	)

Definition at line 5626 of file mongoose6.cxx.

                                                                      {
   mg_send_response_line(c, status_code, extra_headers);
   if (content_length < 0) {
     mg_printf(c, "%s", "Transfer-Encoding: chunked\r\n");
   } else {
     mg_printf(c, "Content-Length: %" INT64_FMT "\r\n", content_length);
   }
   mg_send(c, "\r\n", 2);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_send_http_chunk()

void mg_send_http_chunk	(	struct mg_connection *	nc,
		const char *	buf,
		size_t	len
	)

Definition at line 6027 of file mongoose6.cxx.

                                                                                {
   char chunk_size[50];
   int n;
  
   n = snprintf(chunk_size, sizeof(chunk_size), "%lX\r\n", (unsigned long) len);
   mg_send(nc, chunk_size, n);
   mg_send(nc, buf, len);
   mg_send(nc, "\r\n", 2);
 }

Here is the call graph for this function:

◆ mg_send_mqtt_handshake()

void mg_send_mqtt_handshake	(	struct mg_connection *	nc,
		const char *	client_id
	)

Definition at line 8438 of file mongoose6.cxx.

                                                                              {
   static struct mg_send_mqtt_handshake_opts opts;
   mg_send_mqtt_handshake_opt(nc, client_id, opts);
 }

Here is the call graph for this function:

◆ mg_send_mqtt_handshake_opt()

void mg_send_mqtt_handshake_opt	(	struct mg_connection *	nc,
		const char *	client_id,
		struct mg_send_mqtt_handshake_opts	opts
	)

Definition at line 8443 of file mongoose6.cxx.

                                                                          {
   uint8_t header = MG_MQTT_CMD_CONNECT << 4;
   uint8_t rem_len;
   uint16_t keep_alive;
   uint16_t client_id_len;
  
   /*
    * 9: version_header(len, magic_string, version_number), 1: flags, 2:
    * keep-alive timer,
    * 2: client_identifier_len, n: client_id
    */
   rem_len = 9 + 1 + 2 + 2 + strlen(client_id);
  
   mg_send(nc, &header, 1);
   mg_send(nc, &rem_len, 1);
   mg_send(nc, "\00\06MQIsdp\03", 9);
   mg_send(nc, &opts.flags, 1);
  
   if (opts.keep_alive == 0) {
     opts.keep_alive = 60;
   }
   keep_alive = htons(opts.keep_alive);
   mg_send(nc, &keep_alive, 2);
  
   client_id_len = htons(strlen(client_id));
   mg_send(nc, &client_id_len, 2);
   mg_send(nc, client_id, strlen(client_id));
 }

Here is the call graph for this function:

◆ mg_send_response_line()

void mg_send_response_line	(	struct mg_connection *	c,
		int	status_code,
		const char *	extra_headers
	)

Definition at line 5588 of file mongoose6.cxx.

                                                       {
   const char *status_message = "OK";
   switch (status_code) {
     case 206:
       status_message = "Partial Content";
       break;
     case 301:
       status_message = "Moved";
       break;
     case 302:
       status_message = "Found";
       break;
     case 401:
       status_message = "Unauthorized";
       break;
     case 403:
       status_message = "Forbidden";
       break;
     case 404:
       status_message = "Not Found";
       break;
     case 416:
       status_message = "Requested range not satisfiable";
       break;
     case 418:
       status_message = "I'm a teapot";
       break;
     case 500:
       status_message = "Internal Server Error";
       break;
   }
   mg_printf(nc, "HTTP/1.1 %d %s\r\n", status_code, status_message);
   if (extra_headers != NULL) {
     mg_printf(nc, "%s\r\n", extra_headers);
   }
 }

Here is the call graph for this function:

◆ mg_send_websocket_frame()

void mg_send_websocket_frame	(	struct mg_connection *	nc,
		int	op_and_flags,
		const void *	data,
		size_t	data_len
	)

Definition at line 4661 of file mongoose6.cxx.

                                          {
   struct ws_mask_ctx ctx;
   DBG(("%p %d %d", nc, op, (int) len));
   mg_send_ws_header(nc, op, len, &ctx);
   mg_send(nc, data, len);
  
   mg_ws_mask_frame(&nc->send_mbuf, &ctx);
  
   if (op == WEBSOCKET_OP_CLOSE) {
     nc->flags |= MG_F_SEND_AND_CLOSE;
   }
 }

Here is the call graph for this function:

◆ mg_send_websocket_framev()

void mg_send_websocket_framev	(	struct mg_connection *	nc,
		int	op_and_flags,
		const struct mg_str *	strings,
		int	num_strings
	)

Definition at line 4675 of file mongoose6.cxx.

                                                                       {
   struct ws_mask_ctx ctx;
   int i;
   int len = 0;
   for (i = 0; i < strvcnt; i++) {
     len += strv[i].len;
   }
  
   mg_send_ws_header(nc, op, len, &ctx);
  
   for (i = 0; i < strvcnt; i++) {
     mg_send(nc, strv[i].p, strv[i].len);
   }
  
   mg_ws_mask_frame(&nc->send_mbuf, &ctx);
  
   if (op == WEBSOCKET_OP_CLOSE) {
     nc->flags |= MG_F_SEND_AND_CLOSE;
   }
 }

Here is the call graph for this function:

◆ mg_send_websocket_handshake()

void mg_send_websocket_handshake	(	struct mg_connection *	nc,
		const char *	uri,
		const char *	extra_headers
	)

Definition at line 5580 of file mongoose6.cxx.

                                                             {
   mg_send_websocket_handshake2(nc, path, MG_WS_NO_HOST_HEADER_MAGIC, NULL,
                                extra_headers);
 }

Here is the call graph for this function:

◆ mg_send_websocket_handshake2()

void mg_send_websocket_handshake2	(	struct mg_connection *	nc,
		const char *	path,
		const char *	host,
		const char *	protocol,
		const char *	extra_headers
	)

Definition at line 5551 of file mongoose6.cxx.

                                                              {
   /* pretty poor source of randomness, TODO fix */
   unsigned long random = (unsigned long) path;
   char key[sizeof(random) * 3];
  
   mg_base64_encode((unsigned char *) &random, sizeof(random), key);
   mg_printf(nc,
             "GET %s HTTP/1.1\r\n"
             "Upgrade: websocket\r\n"
             "Connection: Upgrade\r\n"
             "Sec-WebSocket-Version: 13\r\n"
             "Sec-WebSocket-Key: %s\r\n",
             path, key);
  
   /* TODO(mkm): take default hostname from http proto data if host == NULL */
   if (host != MG_WS_NO_HOST_HEADER_MAGIC) {
     mg_printf(nc, "Host: %s\r\n", host);
   }
   if (protocol != NULL) {
     mg_printf(nc, "Sec-WebSocket-Protocol: %s\r\n", protocol);
   }
   if (extra_headers != NULL) {
     mg_printf(nc, "%s", extra_headers);
   }
   mg_printf(nc, "\r\n");
 }

Here is the call graph for this function:

◆ mg_serve_http()

void mg_serve_http	(	struct mg_connection *	nc,
		struct http_message *	hm,
		struct mg_serve_http_opts	opts
	)

Definition at line 7512 of file mongoose6.cxx.

                                                    {
   char *path = NULL;
   struct mg_str *hdr, path_info;
   uint32_t remote_ip = ntohl(*(uint32_t *) &nc->sa.sin.sin_addr);
  
   if (mg_check_ip_acl(opts.ip_acl, remote_ip) != 1) {
     /* Not allowed to connect */
     mg_http_send_error(nc, 403, NULL);
     nc->flags |= MG_F_SEND_AND_CLOSE;
     return;
   }
  
   if (mg_http_send_port_based_redirect(nc, hm, &opts)) {
     return;
   }
  
   if (opts.document_root == NULL) {
     opts.document_root = ".";
   }
   if (opts.per_directory_auth_file == NULL) {
     opts.per_directory_auth_file = ".htpasswd";
   }
   if (opts.enable_directory_listing == NULL) {
     opts.enable_directory_listing = "yes";
   }
   if (opts.cgi_file_pattern == NULL) {
     opts.cgi_file_pattern = "**.cgi$|**.php$";
   }
   if (opts.ssi_pattern == NULL) {
     opts.ssi_pattern = "**.shtml$|**.shtm$";
   }
   if (opts.index_files == NULL) {
     opts.index_files = "index.html,index.htm,index.shtml,index.cgi,index.php";
   }
   /* Normalize path - resolve "." and ".." (in-place). */
   if (!mg_normalize_uri_path(&hm->uri, &hm->uri)) {
     mg_http_send_error(nc, 400, NULL);
     return;
   }
   if (mg_uri_to_local_path(hm, &opts, &path, &path_info) == 0) {
     mg_http_send_error(nc, 404, NULL);
     return;
   }
   mg_send_http_file(nc, path, &path_info, hm, &opts);
  
   MG_FREE(path);
   path = NULL;
  
   /* Close connection for non-keep-alive requests */
   if (mg_vcmp(&hm->proto, "HTTP/1.1") != 0 ||
       ((hdr = mg_get_http_header(hm, "Connection")) != NULL &&
        mg_vcmp(hdr, "keep-alive") != 0)) {
 #if 0
     nc->flags |= MG_F_SEND_AND_CLOSE;
 #endif
   }
 }

Here is the call graph for this function:

◆ mg_set_close_on_exec()

void mg_set_close_on_exec ( sock_t sock )

Definition at line 7906 of file mongoose6.cxx.

                                        {
 #ifdef _WIN32
   (void) SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0);
 #elif defined(__unix__)
   fcntl(sock, F_SETFD, FD_CLOEXEC);
 #else
   (void) sock;
 #endif
 }

◆ mg_set_protocol_dns()

void mg_set_protocol_dns ( struct mg_connection * nc )

Definition at line 9164 of file mongoose6.cxx.

                                                    {
   nc->proto_handler = dns_handler;
 }

Here is the call graph for this function:

◆ mg_set_protocol_http_websocket()

void mg_set_protocol_http_websocket ( struct mg_connection * nc )

Definition at line 5545 of file mongoose6.cxx.

                                                               {
   nc->proto_handler = mg_http_handler;
 }

Here is the call graph for this function:

◆ mg_set_protocol_mqtt()

void mg_set_protocol_mqtt ( struct mg_connection * nc )

Definition at line 8434 of file mongoose6.cxx.

                                                     {
   nc->proto_handler = mqtt_handler;
 }

Here is the call graph for this function:

◆ mg_set_ssl()

const char* mg_set_ssl	(	struct mg_connection *	nc,
		const char *	cert,
		const char *	ca_cert
	)

Here is the caller graph for this function:

◆ mg_set_timer()

double mg_set_timer	(	struct mg_connection *	c,
		double	timestamp
	)

Definition at line 3035 of file mongoose6.cxx.

                                                                {
   double result = c->ev_timer_time;
   c->ev_timer_time = timestamp;
   /*
    * If this connection is resolving, it's not in the list of active
    * connections, so not processed yet. It has a DNS resolver connection
    * linked to it. Set up a timer for the DNS connection.
    */
   DBG(("%p %p %d -> %lu", c, c->priv_2, c->flags & MG_F_RESOLVING,
        (unsigned long) timestamp));
   if ((c->flags & MG_F_RESOLVING) && c->priv_2 != NULL) {
     ((struct mg_connection *) c->priv_2)->ev_timer_time = timestamp;
   }
   return result;
 }

◆ mg_skip()

const char* mg_skip	(	const char *	s,
		const char *	end_string,
		const char *	delimiters,
		struct mg_str *	v
	)

Definition at line 7795 of file mongoose6.cxx.

                                       {
   v->p = s;
   while (s < end && strchr(delims, *(unsigned char *) s) == NULL) s++;
   v->len = s - v->p;
   while (s < end && strchr(delims, *(unsigned char *) s) != NULL) s++;
   return s;
 }

◆ mg_sock_addr_to_str()

void mg_sock_addr_to_str	(	const union socket_address *	sa,
		char *	buf,
		size_t	len,
		int	flags
	)

Definition at line 7916 of file mongoose6.cxx.

                                     {
   int is_v6;
   if (buf == NULL || len <= 0) return;
   buf[0] = '\0';
 #if defined(MG_ENABLE_IPV6)
   is_v6 = sa->sa.sa_family == AF_INET6;
 #else
   is_v6 = 0;
 #endif
   if (flags & MG_SOCK_STRINGIFY_IP) {
 #if defined(MG_ENABLE_IPV6)
     const void *addr = NULL;
     char *start = buf;
     socklen_t capacity = len;
     if (!is_v6) {
       addr = &sa->sin.sin_addr;
     } else {
       addr = (void *) &sa->sin6.sin6_addr;
       if (flags & MG_SOCK_STRINGIFY_PORT) {
         *buf = '[';
         start++;
         capacity--;
       }
     }
     if (inet_ntop(sa->sa.sa_family, addr, start, capacity) == NULL) {
       *buf = '\0';
     }
 #elif defined(_WIN32) || defined(MG_LWIP)
     /* Only Windoze Vista (and newer) have inet_ntop() */
     strncpy(buf, inet_ntoa(sa->sin.sin_addr), len);
 #else
     inet_ntop(AF_INET, (void *) &sa->sin.sin_addr, buf, len);
 #endif
   }
   if (flags & MG_SOCK_STRINGIFY_PORT) {
     int port = ntohs(sa->sin.sin_port);
     if (flags & MG_SOCK_STRINGIFY_IP) {
       snprintf(buf + strlen(buf), len - (strlen(buf) + 1), "%s:%d",
                (is_v6 ? "]" : ""), port);
     } else {
       snprintf(buf, len, "%d", port);
     }
   }
 }

Here is the call graph for this function:

◆ mg_sock_set()

void mg_sock_set	(	struct mg_connection *	nc,
		sock_t	sock
	)

Definition at line 3556 of file mongoose6.cxx.

                                                         {
   mg_set_non_blocking_mode(sock);
   mg_set_close_on_exec(sock);
   nc->sock = sock;
   DBG(("%p %d", nc, sock));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_sock_to_str()

void mg_sock_to_str	(	sock_t	sock,
		char *	buf,
		size_t	len,
		int	flags
	)

Definition at line 3766 of file mongoose6.cxx.

                                                                    {
   union socket_address sa;
   mg_sock_get_addr(sock, flags & MG_SOCK_STRINGIFY_REMOTE, &sa);
   mg_sock_addr_to_str(&sa, buf, len, flags);
 }

Here is the call graph for this function:

◆ mg_socketpair()

int mg_socketpair	(	sock_t	sp[2],
		int	sock_type
	)

Definition at line 3711 of file mongoose6.cxx.

                                                {
   union socket_address sa;
   sock_t sock;
   socklen_t len = sizeof(sa.sin);
   int ret = 0;
  
   sock = sp[0] = sp[1] = INVALID_SOCKET;
  
   (void) memset(&sa, 0, sizeof(sa));
   sa.sin.sin_family = AF_INET;
   sa.sin.sin_port = htons(0);
   sa.sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */
  
   if ((sock = socket(AF_INET, sock_type, 0)) == INVALID_SOCKET) {
   } else if (bind(sock, &sa.sa, len) != 0) {
   } else if (sock_type == SOCK_STREAM && listen(sock, 1) != 0) {
   } else if (getsockname(sock, &sa.sa, &len) != 0) {
   } else if ((sp[0] = socket(AF_INET, sock_type, 0)) == INVALID_SOCKET) {
   } else if (connect(sp[0], &sa.sa, len) != 0) {
   } else if (sock_type == SOCK_DGRAM &&
              (getsockname(sp[0], &sa.sa, &len) != 0 ||
               connect(sock, &sa.sa, len) != 0)) {
   } else if ((sp[1] = (sock_type == SOCK_DGRAM ? sock
                                                : accept(sock, &sa.sa, &len))) ==
              INVALID_SOCKET) {
   } else {
     mg_set_close_on_exec(sp[0]);
     mg_set_close_on_exec(sp[1]);
     if (sock_type == SOCK_STREAM) closesocket(sock);
     ret = 1;
   }
  
   if (!ret) {
     if (sp[0] != INVALID_SOCKET) closesocket(sp[0]);
     if (sp[1] != INVALID_SOCKET) closesocket(sp[1]);
     if (sock != INVALID_SOCKET) closesocket(sock);
     sock = sp[0] = sp[1] = INVALID_SOCKET;
   }
  
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_stat()

int mg_stat	(	const char *	path,
		cs_stat_t *	st
	)

Definition at line 7841 of file mongoose6.cxx.

                                              {
 #ifdef _WIN32
   wchar_t wpath[MAX_PATH_SIZE];
   to_wchar(path, wpath, ARRAY_SIZE(wpath));
   DBG(("[%ls] -> %d", wpath, _wstati64(wpath, st)));
   return _wstati64(wpath, (struct _stati64 *) st);
 #else
   return stat(path, st);
 #endif
 }

Here is the caller graph for this function:

◆ mg_time()

double mg_time ( void )

Definition at line 3069 of file mongoose6.cxx.

                  {
   return cs_time();
 }

Here is the call graph for this function:

◆ mg_url_decode()

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

Definition at line 2606 of file mongoose4.cxx.

                                                         {
   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 (src[i] == '%' && i < src_len - 2 &&
         isxdigit(* (const unsigned char *) (src + i + 1)) &&
         isxdigit(* (const unsigned char *) (src + i + 2))) {
       a = tolower(* (const unsigned char *) (src + i + 1));
       b = tolower(* (const 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;
 }

◆ mg_vcasecmp()

int mg_vcasecmp	(	const struct mg_str *	str2,
		const char *	str1
	)

Definition at line 1717 of file mongoose614.cxx.

                                                              {
   size_t n2 = strlen(str2), n1 = str1->len;
   int r = mg_ncasecmp(str1->p, str2, (n1 < n2) ? n1 : n2);
   if (r == 0) {
     return n1 - n2;
   }
   return r;
 }

◆ mg_vcmp()

int mg_vcmp	(	const struct mg_str *	str2,
		const char *	str1
	)

Definition at line 1707 of file mongoose614.cxx.

                                                          {
   size_t n2 = strlen(str2), n1 = str1->len;
   int r = strncmp(str1->p, str2, (n1 < n2) ? n1 : n2);
   if (r == 0) {
     return n1 - n2;
   }
   return r;
 }

◆ mg_vprintf()

int mg_vprintf	(	struct mg_connection *	conn,
		const char *	fmt,
		va_list	ap
	)

Definition at line 1908 of file mongoose4.cxx.

                                                                         {
   char mem[MG_BUF_LEN], *buf = mem;
   int len;
  
   if ((len = alloc_vprintf(&buf, sizeof(mem), fmt, ap)) > 0) {
     len = mg_write(conn, buf, (size_t) len);
   }
   if (buf != mem && buf != NULL) {
     free(buf);
   }
  
   return len;
 }

Here is the call graph for this function:

◆ parse_json()

int parse_json	(	const char *	json_string,
		int	json_string_length,
		struct json_token *	tokens_array,
		int	size_of_tokens_array
	)

Definition at line 923 of file mongoose6.cxx.

                                                                               {
   struct frozen frozen;
  
   memset(&frozen, 0, sizeof(frozen));
   frozen.end = s + s_len;
   frozen.cur = s;
   frozen.tokens = arr;
   frozen.max_tokens = arr_len;
  
   TRY(doit(&frozen));
  
   return frozen.cur - s;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_json2()

struct json_token* parse_json2	(	const char *	json_string,
		int	string_length
	)

Definition at line 937 of file mongoose6.cxx.

                                                          {
   struct frozen frozen;
  
   memset(&frozen, 0, sizeof(frozen));
   frozen.end = s + s_len;
   frozen.cur = s;
   frozen.do_realloc = 1;
  
   if (doit(&frozen) < 0) {
     FROZEN_FREE((void *) frozen.tokens);
     frozen.tokens = NULL;
   }
   return frozen.tokens;
 }

Here is the call graph for this function:

Variable Documentation

◆ accept_literal

int mg_resolve_async_opts::accept_literal

Definition at line 3424 of file mongoose6.h.

◆ active_connections

struct mg_connection * mg_mgr::active_connections

Definition at line 1231 of file mongoose6.h.

◆ answers

struct mg_dns_resource_record mg_dns_message::answers

Definition at line 3195 of file mongoose6.h.

◆ auth_domain

const char* mg_serve_http_opts::auth_domain

Definition at line 2539 of file mongoose6.h.

◆ b64_putc

cs_base64_putc_t cs_base64_ctx::b64_putc

Definition at line 981 of file mongoose6.h.

◆ bits

uint32_t MD5Context::bits

Definition at line 932 of file mongoose6.h.

◆ body

struct mg_str http_message::body

Definition at line 2076 of file mongoose6.h.

◆ buf [1/2]

char * mbuf::buf

Definition at line 834 of file mongoose6.h.

◆ buf [2/2]

uint32_t MD5Context::buf

Definition at line 931 of file mongoose6.h.

◆ buffer

unsigned char cs_sha1_ctx::buffer

Definition at line 901 of file mongoose6.h.

◆ cgi_file_pattern

const char* mg_serve_http_opts::cgi_file_pattern

Definition at line 2597 of file mongoose6.h.

◆ cgi_interpreter

const char* mg_serve_http_opts::cgi_interpreter

Definition at line 2600 of file mongoose6.h.

◆ chunk

unsigned char cs_base64_ctx::chunk

Definition at line 982 of file mongoose6.h.

◆ chunk_size

int cs_base64_ctx::chunk_size

Definition at line 983 of file mongoose6.h.

◆ cmd

int mg_mqtt_message::cmd

Definition at line 2877 of file mongoose6.h.

◆ connack_ret_code

uint8_t mg_mqtt_message::connack_ret_code

Definition at line 2880 of file mongoose6.h.

◆ count

uint32_t cs_sha1_ctx::count

Definition at line 900 of file mongoose6.h.

◆ cs_log_level

enum cs_log_level cs_log_level

extern

Definition at line 305 of file mongoose6.cxx.

◆ ctl

sock_t mg_mgr::ctl[2]

Definition at line 1234 of file mongoose6.h.

◆ custom_mime_types

const char* mg_serve_http_opts::custom_mime_types

Definition at line 2606 of file mongoose6.h.

◆ data [1/2]

unsigned char * websocket_message::data

Definition at line 2099 of file mongoose6.h.

◆ data [2/2]

struct mg_str mg_http_multipart_part::data

Definition at line 2107 of file mongoose6.h.

◆ dav_auth_file

const char* mg_serve_http_opts::dav_auth_file

Definition at line 2591 of file mongoose6.h.

◆ dav_document_root

const char* mg_serve_http_opts::dav_document_root

Definition at line 2585 of file mongoose6.h.

◆ dns_conn

struct mg_connection ** mg_resolve_async_opts::dns_conn

Definition at line 3426 of file mongoose6.h.

◆ document_root

const char* mg_serve_http_opts::document_root

Definition at line 2522 of file mongoose6.h.

◆ enable_directory_listing

const char* mg_serve_http_opts::enable_directory_listing

Definition at line 2552 of file mongoose6.h.

◆ err

int mg_connection::err

Definition at line 1252 of file mongoose6.h.

◆ error_code

struct json_token* mg_rpc_error::error_code

Definition at line 2748 of file mongoose6.h.

◆ error_data

struct json_token* mg_rpc_error::error_data

Definition at line 2750 of file mongoose6.h.

◆ error_message

struct json_token* mg_rpc_error::error_message

Definition at line 2749 of file mongoose6.h.

◆ error_string [1/3]

const char ** mg_add_sock_opts::error_string

Definition at line 1368 of file mongoose6.h.

◆ error_string [2/3]

const char ** mg_bind_opts::error_string

Definition at line 1398 of file mongoose6.h.

◆ error_string [3/3]

const char ** mg_connect_opts::error_string

Definition at line 1438 of file mongoose6.h.

◆ ev_timer_time

double mg_connection::ev_timer_time

Definition at line 1260 of file mongoose6.h.

◆ extra_headers

const char* mg_serve_http_opts::extra_headers

Definition at line 2612 of file mongoose6.h.

◆ f [1/2]

mg_event_handler_t mg_connection::f

Definition at line 1272 of file mongoose6.h.

◆ [2/2]

mg_event_handler_t { ... } ::f

Definition at line 1272 of file mongoose6.h.

◆ file_name

const char * mg_http_multipart_part::file_name

Definition at line 2106 of file mongoose6.h.

◆ flags [1/7]

unsigned long mg_connection::flags

Definition at line 1276 of file mongoose6.h.

◆ flags [2/7]

unsigned int mg_add_sock_opts::flags

Definition at line 1367 of file mongoose6.h.

◆ flags [3/7]

unsigned int mg_bind_opts::flags

Definition at line 1397 of file mongoose6.h.

◆ flags [4/7]

unsigned int mg_connect_opts::flags

Definition at line 1437 of file mongoose6.h.

◆ flags [5/7]

unsigned char websocket_message::flags

Definition at line 2101 of file mongoose6.h.

◆ flags [6/7]

unsigned char mg_send_mqtt_handshake_opts::flags

Definition at line 2891 of file mongoose6.h.

◆ flags [7/7]

uint16_t mg_dns_message::flags

Definition at line 3192 of file mongoose6.h.

◆ global_auth_file

const char* mg_serve_http_opts::global_auth_file

Definition at line 2549 of file mongoose6.h.

◆ handler

mg_event_handler_t mg_connection::handler

Definition at line 1264 of file mongoose6.h.

◆ header_names

struct mg_str http_message::header_names

Definition at line 2076 of file mongoose6.h.

◆ header_values

struct mg_str http_message::header_values

Definition at line 2076 of file mongoose6.h.

◆ hexdump_file

const char* mg_mgr::hexdump_file

Definition at line 1232 of file mongoose6.h.

◆ hidden_file_pattern

const char* mg_serve_http_opts::hidden_file_pattern

Definition at line 2594 of file mongoose6.h.

◆ id [1/3]

struct json_token* mg_rpc_request::id

Definition at line 2732 of file mongoose6.h.

◆ id [2/3]

struct json_token* mg_rpc_reply::id

Definition at line 2740 of file mongoose6.h.

◆ id [3/3]

struct json_token* mg_rpc_error::id

Definition at line 2747 of file mongoose6.h.

◆ in

unsigned char MD5Context::in

Definition at line 933 of file mongoose6.h.

◆ index_files

const char* mg_serve_http_opts::index_files

Definition at line 2525 of file mongoose6.h.

◆ ip_acl

const char* mg_serve_http_opts::ip_acl

Definition at line 2558 of file mongoose6.h.

◆ keep_alive

uint16_t mg_send_mqtt_handshake_opts::keep_alive

Definition at line 2892 of file mongoose6.h.

◆ kind

enum mg_dns_resource_record_kind mg_dns_resource_record::kind

Definition at line 3184 of file mongoose6.h.

◆ last_io_time

time_t mg_connection::last_io_time

Definition at line 1259 of file mongoose6.h.

◆ len [1/3]

size_t mbuf::len

Definition at line 835 of file mongoose6.h.

◆ len [2/3]

int json_token::len

Definition at line 1073 of file mongoose6.h.

◆ len [3/3]

size_t mg_str::len

Definition at line 1207 of file mongoose6.h.

◆ listener

struct mg_connection * mg_connection::listener

Definition at line 1248 of file mongoose6.h.

◆ max_retries

int mg_resolve_async_opts::max_retries

Definition at line 3422 of file mongoose6.h.

◆ message [1/4]

struct mg_str http_message::message

Definition at line 1438 of file mongoose6.h.

◆ message [2/4]

struct json_token* mg_rpc_request::message

Definition at line 2731 of file mongoose6.h.

◆ message [3/4]

struct json_token* mg_rpc_reply::message

Definition at line 2739 of file mongoose6.h.

◆ message [4/4]

struct json_token* mg_rpc_error::message

Definition at line 2746 of file mongoose6.h.

◆ message_id

uint16_t mg_mqtt_message::message_id

Definition at line 2881 of file mongoose6.h.

◆ method [1/2]

struct mg_str http_message::method

Definition at line 1438 of file mongoose6.h.

◆ method [2/2]

struct json_token* mg_rpc_request::method

Definition at line 2733 of file mongoose6.h.

◆ mgr

struct mg_mgr * mg_connection::mgr

Definition at line 1249 of file mongoose6.h.

◆ mgr_data [1/2]

void* mg_mgr::mgr_data

Definition at line 1237 of file mongoose6.h.

◆ mgr_data [2/2]

void * mg_connection::mgr_data

Definition at line 1275 of file mongoose6.h.

◆ name

struct mg_str mg_dns_resource_record::name

Definition at line 2896 of file mongoose6.h.

◆ nameserver_url

const char* mg_resolve_async_opts::nameserver_url

Definition at line 3421 of file mongoose6.h.

◆ next

struct mg_connection * mg_connection::next

Definition at line 1247 of file mongoose6.h.

◆ num_answers

int mg_dns_message::num_answers

Definition at line 3195 of file mongoose6.h.

◆ num_desc

int json_token::num_desc

Definition at line 1074 of file mongoose6.h.

◆ num_questions

int mg_dns_message::num_questions

Definition at line 3194 of file mongoose6.h.

◆ only_literal

int mg_resolve_async_opts::only_literal

Definition at line 3425 of file mongoose6.h.

◆ p

const char * mg_str::p

Definition at line 1206 of file mongoose6.h.

◆ params

struct json_token* mg_rpc_request::params

Definition at line 2734 of file mongoose6.h.

◆ password

const char * mg_send_mqtt_handshake_opts::password

Definition at line 2896 of file mongoose6.h.

◆ payload

struct mg_str mg_mqtt_message::payload

Definition at line 2877 of file mongoose6.h.

◆ per_directory_auth_file

const char* mg_serve_http_opts::per_directory_auth_file

Definition at line 2536 of file mongoose6.h.

◆ pkt

struct mg_str mg_dns_message::pkt

Definition at line 3184 of file mongoose6.h.

◆ prev

struct mg_connection * mg_connection::prev

Definition at line 1247 of file mongoose6.h.

◆

union { ... } mg_connection::priv_1

◆ priv_2

void * mg_connection::priv_2

Definition at line 1274 of file mongoose6.h.

◆ proto

struct mg_str http_message::proto

Definition at line 1438 of file mongoose6.h.

◆ proto_data

void * mg_connection::proto_data

Definition at line 1262 of file mongoose6.h.

◆ proto_data_destructor

void(* mg_connection::proto_data_destructor)(void *proto_data)

Definition at line 1263 of file mongoose6.h.

◆ proto_handler

mg_event_handler_t mg_connection::proto_handler

Definition at line 1261 of file mongoose6.h.

◆ ptr

const char* json_token::ptr

Definition at line 1072 of file mongoose6.h.

◆ qos [1/2]

int mg_mqtt_message::qos

Definition at line 2879 of file mongoose6.h.

◆ qos [2/2]

uint8_t mg_mqtt_topic_expression::qos

Definition at line 2887 of file mongoose6.h.

◆ query_string

struct mg_str http_message::query_string

Definition at line 2076 of file mongoose6.h.

◆ questions

struct mg_dns_resource_record mg_dns_message::questions

Definition at line 3195 of file mongoose6.h.

◆ rclass

int mg_dns_resource_record::rclass

Definition at line 3183 of file mongoose6.h.

◆ rdata

struct mg_str mg_dns_resource_record::rdata

Definition at line 3184 of file mongoose6.h.

◆ recv_mbuf

struct mbuf mg_connection::recv_mbuf

Definition at line 1254 of file mongoose6.h.

◆ recv_mbuf_limit

size_t mg_connection::recv_mbuf_limit

Definition at line 1254 of file mongoose6.h.

◆ resp_code

int http_message::resp_code

Definition at line 2076 of file mongoose6.h.

◆ resp_status_msg

struct mg_str http_message::resp_status_msg

Definition at line 2076 of file mongoose6.h.

◆ result

struct json_token* mg_rpc_reply::result

Definition at line 2741 of file mongoose6.h.

◆ rtype

int mg_dns_resource_record::rtype

Definition at line 3182 of file mongoose6.h.

◆ sa [1/2]

struct sockaddr socket_address::sa

Definition at line 1074 of file mongoose6.h.

◆ sa [2/2]

union socket_address mg_connection::sa

Definition at line 1252 of file mongoose6.h.

◆ send_mbuf

struct mbuf mg_connection::send_mbuf

Definition at line 1254 of file mongoose6.h.

◆ sin

struct sockaddr_in socket_address::sin

Definition at line 1074 of file mongoose6.h.

◆ sin6

struct sockaddr socket_address::sin6

Definition at line 1074 of file mongoose6.h.

◆ size [1/2]

size_t mbuf::size

Definition at line 836 of file mongoose6.h.

◆ size [2/2]

size_t websocket_message::size

Definition at line 2100 of file mongoose6.h.

◆ sock

sock_t mg_connection::sock

Definition at line 1251 of file mongoose6.h.

◆ ssi_pattern

const char* mg_serve_http_opts::ssi_pattern

Definition at line 2555 of file mongoose6.h.

◆ ssl

SSL * mg_connection::ssl

Definition at line 1257 of file mongoose6.h.

◆ ssl_ctx

SSL_CTX* mg_connection::ssl_ctx

Definition at line 1258 of file mongoose6.h.

◆ state

uint32_t cs_sha1_ctx::state

Definition at line 899 of file mongoose6.h.

◆ status

int mg_http_multipart_part::status

Definition at line 2109 of file mongoose6.h.

◆ timeout

int mg_resolve_async_opts::timeout

Definition at line 3423 of file mongoose6.h.

◆ topic [1/2]

struct mg_str mg_mqtt_message::topic

Definition at line 2882 of file mongoose6.h.

◆ topic [2/2]

const char * mg_mqtt_topic_expression::topic

Definition at line 2886 of file mongoose6.h.

◆ transaction_id

uint16_t mg_dns_message::transaction_id

Definition at line 3193 of file mongoose6.h.

◆ ttl

int mg_dns_resource_record::ttl

Definition at line 3184 of file mongoose6.h.

◆ type

enum json_type json_token::type

Definition at line 1074 of file mongoose6.h.

◆ uri

struct mg_str http_message::uri

Definition at line 1438 of file mongoose6.h.

◆ url_rewrites

const char* mg_serve_http_opts::url_rewrites

Definition at line 2582 of file mongoose6.h.

◆ user_data [1/7]

void * cs_base64_ctx::user_data

Definition at line 984 of file mongoose6.h.

◆ user_data [2/7]

void * mg_mgr::user_data

Definition at line 1236 of file mongoose6.h.

◆ user_data [3/7]

void * mg_connection::user_data

Definition at line 1265 of file mongoose6.h.

◆ user_data [4/7]

void * mg_add_sock_opts::user_data

Definition at line 1366 of file mongoose6.h.

◆ user_data [5/7]

void * mg_bind_opts::user_data

Definition at line 1396 of file mongoose6.h.

◆ user_data [6/7]

void * mg_connect_opts::user_data

Definition at line 1436 of file mongoose6.h.

◆ user_data [7/7]

void * mg_http_multipart_part::user_data

Definition at line 2110 of file mongoose6.h.

◆ user_name

const char * mg_send_mqtt_handshake_opts::user_name

Definition at line 2895 of file mongoose6.h.

◆ [1/2]

void* { ... } ::v

Definition at line 1267 of file mongoose6.h.

◆ v [2/2]

void* mg_connection::v

Definition at line 1267 of file mongoose6.h.

◆ var_name

const char * mg_http_multipart_part::var_name

Definition at line 2107 of file mongoose6.h.

◆ will_message

const char * mg_send_mqtt_handshake_opts::will_message

Definition at line 2894 of file mongoose6.h.

◆ will_topic

const char * mg_send_mqtt_handshake_opts::will_topic

Definition at line 2893 of file mongoose6.h.

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ ARRAY_SIZE

◆ CS_COMMON_BASE64_H_

◆ CS_COMMON_CS_DBG_H_

◆ CS_COMMON_CS_DIRENT_H_

◆ CS_COMMON_CS_TIME_H_

◆ CS_COMMON_MBUF_H_

◆ CS_COMMON_MD5_H_

◆ CS_COMMON_PLATFORM_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_ESP_LWIP_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_

◆ CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_

◆ CS_COMMON_SHA1_H_

◆ CS_COMMON_STR_UTIL_H_

◆ CS_MONGOOSE_DEPS_FROZEN_FROZEN_H_

◆ CS_MONGOOSE_SRC_COAP_H_

◆ CS_MONGOOSE_SRC_DNS_H_

◆ CS_MONGOOSE_SRC_DNS_SERVER_H_

◆ CS_MONGOOSE_SRC_HTTP_H_

◆ CS_MONGOOSE_SRC_JSON_RPC_H_

◆ CS_MONGOOSE_SRC_MQTT_BROKER_H_

◆ CS_MONGOOSE_SRC_MQTT_H_

◆ CS_MONGOOSE_SRC_NET_H_

◆ CS_MONGOOSE_SRC_NET_IF_H_

◆ CS_MONGOOSE_SRC_RESOLV_H_

◆ CS_MONGOOSE_SRC_URI_H_

◆ CS_MONGOOSE_SRC_UTIL_H_

◆ CS_P_CC3200

◆ CS_P_CUSTOM

◆ CS_P_ESP_LWIP

◆ CS_P_MSP432

◆ CS_P_UNIX

◆ CS_P_WINDOWS

◆ DBG

◆ JSON_RPC_INTERNAL_ERROR

◆ JSON_RPC_INVALID_PARAMS_ERROR

◆ JSON_RPC_INVALID_REQUEST_ERROR

◆ JSON_RPC_METHOD_NOT_FOUND_ERROR

◆ JSON_RPC_PARSE_ERROR

◆ JSON_RPC_SERVER_ERROR

◆ JSON_STRING_INCOMPLETE

◆ JSON_STRING_INVALID

◆ JSON_TOKEN_ARRAY_TOO_SMALL

◆ LOG

◆ MAX_PATH_SIZE

◆ MBUF_SIZE_MULTIPLIER

◆ MG_CGI_ENVIRONMENT_SIZE

◆ MG_DNS_A_RECORD

◆ MG_DNS_AAAA_RECORD

◆ MG_DNS_CNAME_RECORD

◆ MG_DNS_MESSAGE

◆ MG_DNS_MX_RECORD

◆ MG_ENV_EXPORT_TO_CGI

◆ MG_EV_ACCEPT

◆ MG_EV_CLOSE

◆ MG_EV_CONNECT

◆ MG_EV_HTTP_CHUNK

◆ MG_EV_HTTP_REPLY

◆ MG_EV_HTTP_REQUEST

◆ MG_EV_MQTT_CONNACK

◆ MG_EV_MQTT_CONNACK_ACCEPTED

◆ MG_EV_MQTT_CONNACK_BAD_AUTH

◆ MG_EV_MQTT_CONNACK_IDENTIFIER_REJECTED

◆ MG_EV_MQTT_CONNACK_NOT_AUTHORIZED

◆ MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE

◆ MG_EV_MQTT_CONNACK_UNACCEPTABLE_VERSION

◆ MG_EV_MQTT_CONNECT

◆ MG_EV_MQTT_DISCONNECT

◆ MG_EV_MQTT_PINGREQ

◆ MG_EV_MQTT_PINGRESP