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 }

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 }

enum	mg_resolve_err { 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.

                                        { \
    cs_log_print_prefix(__func__);        \
    cs_log_printf x;                      \
  }

◆ 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.

                         {         \
    cs_log_print_prefix(__func__); \
    cs_log_printf x;               \
  }

◆ 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.

2007 { str_literal, sizeof(str_literal) - 1 }

◆ 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

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

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

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;
}

Here is the call graph for this function:

◆ 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;
}

Here is the call graph for this function:

◆ 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);
}

Here is the call graph for this function:

◆ 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';
}

Here is the call graph for this function:

◆ 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 call graph for this function:

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 call graph for this function:

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 call graph for this function:

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;
}

Here is the call graph for this function:

◆ 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 call graph for this function:

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;
  }
}

Here is the call graph for this function:

◆ 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;
}

Here is the call graph for this function:

◆ 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 */
  }
}

Here is the call graph for this function:

◆ 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;
}

Here is the call graph for this function:

◆ 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;
}

Here is the call graph for this function:

◆ 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
}

Here is the call graph for this function:

◆ 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 call graph for this function:

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;
}

Here is the call graph for this function:

◆ 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 call graph for this function:

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 call graph for this function:

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 call graph for this function:

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 call graph for this function:

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 1694 of file mongoose614.cxx.

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

Here is the call graph for this function:

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;
}

Here is the call graph for this function:

◆ 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
}

Here is the call graph for this function:

◆ 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 call graph for this function:

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
}

Here is the call graph for this function:

◆ 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;
}

Here is the call graph for this function:

◆ 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;
}

Here is the call graph for this function:

◆ 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 call graph for this function:

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;
}

Here is the call graph for this function:

◆ 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;
}

Here is the call graph for this function:

◆ 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 3197 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 2094 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 340 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 2108 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.

◆ [] [1/2]

mg_event_handler_t { ... } ::f

Definition at line 1272 of file mongoose6.h.

◆ f [2/2]

mg_event_handler_t mg_connection::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 2090 of file mongoose6.h.

◆ header_values

struct mg_str http_message::header_values

Definition at line 2091 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 3185 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 2068 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 2071 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 3181 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 2878 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 3191 of file mongoose6.h.

◆ prev

struct mg_connection * mg_connection::prev

Definition at line 1247 of file mongoose6.h.

◆ [union]

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 2073 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 2087 of file mongoose6.h.

◆ questions

struct mg_dns_resource_record mg_dns_message::questions

Definition at line 3196 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 3186 of file mongoose6.h.

◆ recv_mbuf

struct mbuf mg_connection::recv_mbuf

Definition at line 1255 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 2077 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 1195 of file mongoose6.h.

◆ sa [2/2]

union socket_address mg_connection::sa

Definition at line 1253 of file mongoose6.h.

◆ send_mbuf

struct mbuf mg_connection::send_mbuf

Definition at line 1256 of file mongoose6.h.

◆ sin

struct sockaddr_in socket_address::sin

Definition at line 1196 of file mongoose6.h.

◆ sin6

struct sockaddr socket_address::sin6

Definition at line 1200 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 1075 of file mongoose6.h.

◆ uri

struct mg_str http_message::uri

Definition at line 2072 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