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

Граф включаемых заголовочных файлов для mongoose.h:

Граф файлов, в которые включается этот файл:

Структуры данных
struct	mg_str

struct	mbuf

struct	cs_sha1_ctx

struct	MD5Context

struct	cs_base64_ctx

struct	mg_iface

struct	mg_iface_vtable

union	socket_address

struct	mg_mgr

struct	mg_connection

struct	mg_mgr_init_opts

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_ssi_call_ctx

struct	mg_mqtt_message

struct	mg_mqtt_topic_expression

struct	mg_send_mqtt_handshake_opts

struct	mg_mqtt_proto_data

struct	mg_dns_resource_record

struct	mg_dns_message

struct	mg_resolve_async_opts

Макросы
#define	CS_MONGOOSE_SRC_COMMON_H_

#define	MG_VERSION "6.7"

#define	CS_COMMON_PLATFORM_H_

#define	CS_P_CUSTOM 0

#define	CS_P_UNIX 1

#define	CS_P_WINDOWS 2

#define	CS_P_ESP32 15

#define	CS_P_ESP8266 3

#define	CS_P_CC3200 4

#define	CS_P_MSP432 5

#define	CS_P_CC3100 6

#define	CS_P_TM4C129 14

#define	CS_P_MBED 7

#define	CS_P_WINCE 8

#define	CS_P_NXP_LPC 13

#define	CS_P_NXP_KINETIS 9

#define	CS_P_NRF51 12

#define	CS_P_NRF52 10

#define	CS_P_PIC32 11

#define	CS_P_STM32 16

#define	MG_NET_IF_SOCKET 1

#define	MG_NET_IF_SIMPLELINK 2

#define	MG_NET_IF_LWIP_LOW_LEVEL 3

#define	MG_NET_IF_PIC32 4

#define	MG_SSL_IF_OPENSSL 1

#define	MG_SSL_IF_MBEDTLS 2

#define	MG_SSL_IF_SIMPLELINK 3

#define	WEAK

#define	NORETURN

#define	NOINLINE

#define	WARN_UNUSED_RESULT

#define	NOINSTR

#define	DO_NOT_WARN_UNUSED

#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_ESP32_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_ESP8266_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_CC3100_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_TM4C129_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_MBED_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_NRF51_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_NRF52_H_

#define	CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_WINCE_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_NXP_LPC_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_NXP_KINETIS_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_PIC32_H_

#define	CS_COMMON_PLATFORMS_PLATFORM_STM32_H_

#define	CS_COMMON_PLATFORMS_LWIP_MG_LWIP_H_

#define	MG_LWIP 0

#define	CS_COMMON_CS_TIME_H_

#define	CS_COMMON_MG_STR_H_

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

#define	CS_COMMON_MBUF_H_

#define	MBUF_SIZE_MULTIPLIER 1.5

#define	CS_COMMON_SHA1_H_

#define	DISABLE_SHA1 0

#define	CS_COMMON_MD5_H_

#define	DISABLE_MD5 0

#define	CS_COMMON_BASE64_H_

#define	DISABLE_BASE64 0

#define	CS_COMMON_STR_UTIL_H_

#define	CS_ENABLE_STRDUP 0

#define	CS_ENABLE_TO64 0

#define	CS_STRINGIFY_LIT(x) #x

#define	CS_STRINGIFY_MACRO(x) CS_STRINGIFY_LIT(x)

#define	_SYS_QUEUE_H_

#define	QMD_TRACE_ELEM(elem)

#define	QMD_TRACE_HEAD(head)

#define	QMD_SAVELINK(name, link)

#define	TRACEBUF

#define	TRACEBUF_INITIALIZER

#define	TRASHIT(x)

#define	QUEUE_TYPEOF(type) struct type

#define	SLIST_HEAD(name, type)

#define	SLIST_CLASS_HEAD(name, type)

#define	SLIST_HEAD_INITIALIZER(head) { NULL }

#define	SLIST_ENTRY(type)

#define	SLIST_CLASS_ENTRY(type)

#define	SLIST_EMPTY(head) ((head)->slh_first == NULL)

#define	SLIST_FIRST(head) ((head)->slh_first)

#define	SLIST_FOREACH(var, head, field)

#define	SLIST_FOREACH_FROM(var, head, field)

#define	SLIST_FOREACH_SAFE(var, head, field, tvar)

#define	SLIST_FOREACH_FROM_SAFE(var, head, field, tvar)

#define	SLIST_FOREACH_PREVPTR(var, varp, head, field)

#define	SLIST_INIT(head)

#define	SLIST_INSERT_AFTER(slistelm, elm, field)

#define	SLIST_INSERT_HEAD(head, elm, field)

#define	SLIST_NEXT(elm, field) ((elm)->field.sle_next)

#define	SLIST_REMOVE(head, elm, type, field)

#define	SLIST_REMOVE_AFTER(elm, field)

#define	SLIST_REMOVE_HEAD(head, field)

#define	SLIST_SWAP(head1, head2, type)

#define	STAILQ_HEAD(name, type)

#define	STAILQ_CLASS_HEAD(name, type)

#define	STAILQ_HEAD_INITIALIZER(head) { NULL, &(head).stqh_first }

#define	STAILQ_ENTRY(type)

#define	STAILQ_CLASS_ENTRY(type)

#define	STAILQ_CONCAT(head1, head2)

#define	STAILQ_EMPTY(head) ((head)->stqh_first == NULL)

#define	STAILQ_FIRST(head) ((head)->stqh_first)

#define	STAILQ_FOREACH(var, head, field)

#define	STAILQ_FOREACH_FROM(var, head, field)

#define	STAILQ_FOREACH_SAFE(var, head, field, tvar)

#define	STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)

#define	STAILQ_INIT(head)

#define	STAILQ_INSERT_AFTER(head, tqelm, elm, field)

#define	STAILQ_INSERT_HEAD(head, elm, field)

#define	STAILQ_INSERT_TAIL(head, elm, field)

#define	STAILQ_LAST(head, type, field)

#define	STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)

#define	STAILQ_REMOVE(head, elm, type, field)

#define	STAILQ_REMOVE_AFTER(head, elm, field)

#define	STAILQ_REMOVE_HEAD(head, field)

#define	STAILQ_SWAP(head1, head2, type)

#define	LIST_HEAD(name, type)

#define	LIST_CLASS_HEAD(name, type)

#define	LIST_HEAD_INITIALIZER(head) { NULL }

#define	LIST_ENTRY(type)

#define	LIST_CLASS_ENTRY(type)

#define	QMD_LIST_CHECK_HEAD(head, field)

#define	QMD_LIST_CHECK_NEXT(elm, field)

#define	QMD_LIST_CHECK_PREV(elm, field)

#define	LIST_EMPTY(head) ((head)->lh_first == NULL)

#define	LIST_FIRST(head) ((head)->lh_first)

#define	LIST_FOREACH(var, head, field)

#define	LIST_FOREACH_FROM(var, head, field)

#define	LIST_FOREACH_SAFE(var, head, field, tvar)

#define	LIST_FOREACH_FROM_SAFE(var, head, field, tvar)

#define	LIST_INIT(head)

#define	LIST_INSERT_AFTER(listelm, elm, field)

#define	LIST_INSERT_BEFORE(listelm, elm, field)

#define	LIST_INSERT_HEAD(head, elm, field)

#define	LIST_NEXT(elm, field) ((elm)->field.le_next)

#define	LIST_PREV(elm, head, type, field)

#define	LIST_REMOVE(elm, field)

#define	LIST_SWAP(head1, head2, type, field)

#define	TAILQ_HEAD(name, type)

#define	TAILQ_CLASS_HEAD(name, type)

#define	TAILQ_HEAD_INITIALIZER(head) { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }

#define	TAILQ_ENTRY(type)

#define	TAILQ_CLASS_ENTRY(type)

#define	QMD_TAILQ_CHECK_HEAD(head, field)

#define	QMD_TAILQ_CHECK_TAIL(head, headname)

#define	QMD_TAILQ_CHECK_NEXT(elm, field)

#define	QMD_TAILQ_CHECK_PREV(elm, field)

#define	TAILQ_CONCAT(head1, head2, field)

#define	TAILQ_EMPTY(head) ((head)->tqh_first == NULL)

#define	TAILQ_FIRST(head) ((head)->tqh_first)

#define	TAILQ_FOREACH(var, head, field)

#define	TAILQ_FOREACH_FROM(var, head, field)

#define	TAILQ_FOREACH_SAFE(var, head, field, tvar)

#define	TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)

#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)

#define	TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field)

#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)

#define	TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar)

#define	TAILQ_INIT(head)

#define	TAILQ_INSERT_AFTER(head, listelm, elm, field)

#define	TAILQ_INSERT_BEFORE(listelm, elm, field)

#define	TAILQ_INSERT_HEAD(head, elm, field)

#define	TAILQ_INSERT_TAIL(head, elm, field)

#define	TAILQ_LAST(head, headname) ((((struct headname )((head)->tqh_last))->tqh_last))

#define	TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)

#define	TAILQ_PREV(elm, headname, field) ((((struct headname )((elm)->field.tqe_prev))->tqh_last))

#define	TAILQ_REMOVE(head, elm, field)

#define	TAILQ_SWAP(head1, head2, type, field)

#define	CS_MONGOOSE_SRC_FEATURES_H_

#define	MG_DISABLE_HTTP_DIGEST_AUTH 0

#define	MG_DISABLE_HTTP_KEEP_ALIVE 0

#define	MG_DISABLE_PFS 0

#define	MG_DISABLE_WS_RANDOM_MASK 0

#define	MG_ENABLE_ASYNC_RESOLVER 1

#define	MG_ENABLE_BROADCAST 0

#define	MG_ENABLE_COAP 0

#define	MG_ENABLE_DEBUG 0

#define	MG_ENABLE_DIRECTORY_LISTING 0

#define	MG_ENABLE_DNS 1

#define	MG_ENABLE_DNS_SERVER 0

#define	MG_ENABLE_FAKE_DAVLOCK 0

#define	MG_ENABLE_FILESYSTEM 0

#define	MG_ENABLE_GETADDRINFO 0

#define	MG_ENABLE_HEXDUMP CS_ENABLE_STDIO

#define	MG_ENABLE_HTTP 1

#define	MG_ENABLE_HTTP_CGI 0

#define	MG_ENABLE_HTTP_SSI MG_ENABLE_FILESYSTEM

#define	MG_ENABLE_HTTP_SSI_EXEC 0

#define	MG_ENABLE_HTTP_STREAMING_MULTIPART 0

#define	MG_ENABLE_HTTP_WEBDAV 0

#define	MG_ENABLE_HTTP_WEBSOCKET MG_ENABLE_HTTP

#define	MG_ENABLE_IPV6 0

#define	MG_ENABLE_JAVASCRIPT 0

#define	MG_ENABLE_MQTT 1

#define	MG_ENABLE_MQTT_BROKER 0

#define	MG_ENABLE_SSL 0

#define	MG_ENABLE_SYNC_RESOLVER 0

#define	MG_ENABLE_STDIO CS_ENABLE_STDIO

#define	MG_NET_IF MG_NET_IF_SOCKET

#define	MG_SSL_IF MG_SSL_IF_OPENSSL

#define	MG_ENABLE_THREADS 0

#define	MG_ENABLE_HTTP_URL_REWRITES (CS_PLATFORM == CS_P_WINDOWS \|\| CS_PLATFORM == CS_P_UNIX)

#define	MG_ENABLE_TUN MG_ENABLE_HTTP_WEBSOCKET

#define	MG_ENABLE_SNTP 0

#define	MG_ENABLE_EXTRA_ERRORS_DESC 0

#define	CS_MONGOOSE_SRC_NET_IF_H_

#define	MG_MAIN_IFACE 0

#define	CS_MONGOOSE_SRC_SSL_IF_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 (1 << 4) /* SSL is enabled on the connection */

#define	MG_F_SSL_HANDSHAKE_DONE (1 << 5) /* SSL hanshake has completed */

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

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

#define	MG_F_IS_WEBSOCKET (1 << 8) /* 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_ENABLE_BROADCAST (1 << 14) /* Allow broadcast address usage */

#define	MG_F_TUN_DO_NOT_RECONNECT (1 << 15) /* Don't reconnect tunnel */

#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_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	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_CGI_ENVIRONMENT_SIZE 8192

#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_SSI_CALL_CTX 106 /* struct mg_ssi_call_ctx * */

#define	MG_EV_WEBSOCKET_HANDSHAKE_REQUEST 111 /* struct http_message * */

#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_HTTP_SERVER_H_

#define	CS_MONGOOSE_SRC_HTTP_CLIENT_H_

#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_PTR_RECORD 0x0c /* Lookup PTR */

#define	MG_DNS_TXT_RECORD 0x10 /* Lookup TXT */

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

#define	MG_DNS_SRV_RECORD 0x21 /* Lookup SRV */

#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_

#define	CS_MONGOOSE_SRC_SNTP_H_

Определения типов
typedef struct MD5Context	MD5_CTX

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

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

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

Перечисления
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 }

Функции
double	cs_time (void)

struct mg_str	mg_mk_str (const char *s)

struct mg_str	mg_mk_str_n (const char *s, size_t len)

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

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

struct mg_str	mg_strdup (const struct mg_str s)

int	mg_strcmp (const struct mg_str str1, const struct mg_str str2)

int	mg_strncmp (const struct mg_str str1, const struct mg_str str2, size_t n)

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_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, int *dec_len)

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)

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

void	cs_from_hex (char to, const char p, size_t len)

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

int	mg_casecmp (const char s1, const char s2)

int	mg_asprintf (char *buf, size_t size, const char fmt,...)

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

struct mg_iface *	mg_if_create_iface (struct mg_iface_vtable vtable, struct mg_mgr mgr)

struct mg_iface *	mg_find_iface (struct mg_mgr mgr, struct mg_iface_vtable vtable, struct mg_iface *from)

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)

void	mg_if_connect_cb (struct mg_connection *nc, int err)

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, int own)

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_poll (struct mg_connection *nc, time_t now)

void	mg_if_timer (struct mg_connection *c, double now)

void	mg_mgr_init (struct mg_mgr mgr, void user_data)

void	mg_mgr_init_opt (struct mg_mgr mgr, void user_data, struct mg_mgr_init_opts opts)

void	mg_mgr_free (struct mg_mgr *)

time_t	mg_mgr_poll (struct mg_mgr *, int milli)

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)

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_check_ip_acl (const char *acl, uint32_t remote_ip)

double	mg_set_timer (struct mg_connection *c, double timestamp)

double	mg_time (void)

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_base64_decode (const unsigned char s, int len, char dst)

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

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_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)

void	mg_mbuf_append_base64_putc (char ch, void *user_data)

void	mg_mbuf_append_base64 (struct mbuf mbuf, const void data, size_t len)

void	mg_basic_auth_header (const char user, const char pass, struct mbuf *buf)

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)

void	mg_send_websocket_handshake3 (struct mg_connection nc, const char path, const char host, const char protocol, const char extra_headers, const char user, const char *pass)

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,...)

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

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)

int	mg_get_http_basic_auth (struct http_message hm, char user, size_t user_len, char *pass, size_t pass_len)

int	mg_parse_http_basic_auth (struct mg_str hdr, char user, size_t user_len, char *pass, size_t pass_len)

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)

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

int	mg_http_check_digest_auth (struct http_message hm, const char auth_domain, FILE *fp)

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 nc, int status_code, const char extra_headers)

void	mg_http_send_error (struct mg_connection nc, int code, const char reason)

void	mg_http_send_redirect (struct mg_connection *nc, int status_code, const struct mg_str location, const struct mg_str 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,...)

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)

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)

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_questions (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_dns_encode_name (struct mbuf io, const char name, size_t len)

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)

Переменные
struct mg_iface_vtable *	mg_ifaces []

int	mg_num_ifaces

Макросы

◆ _SYS_QUEUE_H_

#define _SYS_QUEUE_H_

◆ ARRAY_SIZE

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

◆ CS_COMMON_BASE64_H_

#define CS_COMMON_BASE64_H_

◆ CS_COMMON_CS_TIME_H_

#define CS_COMMON_CS_TIME_H_

◆ CS_COMMON_MBUF_H_

#define CS_COMMON_MBUF_H_

◆ CS_COMMON_MD5_H_

#define CS_COMMON_MD5_H_

◆ CS_COMMON_MG_STR_H_

#define CS_COMMON_MG_STR_H_

◆ CS_COMMON_PLATFORM_H_

#define CS_COMMON_PLATFORM_H_

◆ CS_COMMON_PLATFORMS_LWIP_MG_LWIP_H_

#define CS_COMMON_PLATFORMS_LWIP_MG_LWIP_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_CC3100_H_

#define CS_COMMON_PLATFORMS_PLATFORM_CC3100_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_

#define CS_COMMON_PLATFORMS_PLATFORM_CC3200_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_ESP32_H_

#define CS_COMMON_PLATFORMS_PLATFORM_ESP32_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_ESP8266_H_

#define CS_COMMON_PLATFORMS_PLATFORM_ESP8266_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_MBED_H_

#define CS_COMMON_PLATFORMS_PLATFORM_MBED_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_

#define CS_COMMON_PLATFORMS_PLATFORM_MSP432_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_NRF51_H_

#define CS_COMMON_PLATFORMS_PLATFORM_NRF51_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_NRF52_H_

#define CS_COMMON_PLATFORMS_PLATFORM_NRF52_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_NXP_KINETIS_H_

#define CS_COMMON_PLATFORMS_PLATFORM_NXP_KINETIS_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_NXP_LPC_H_

#define CS_COMMON_PLATFORMS_PLATFORM_NXP_LPC_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_PIC32_H_

#define CS_COMMON_PLATFORMS_PLATFORM_PIC32_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_STM32_H_

#define CS_COMMON_PLATFORMS_PLATFORM_STM32_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_TM4C129_H_

#define CS_COMMON_PLATFORMS_PLATFORM_TM4C129_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_

#define CS_COMMON_PLATFORMS_PLATFORM_UNIX_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_WINCE_H_

#define CS_COMMON_PLATFORMS_PLATFORM_WINCE_H_

◆ CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_

#define CS_COMMON_PLATFORMS_PLATFORM_WINDOWS_H_

◆ CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_

#define CS_COMMON_PLATFORMS_SIMPLELINK_CS_SIMPLELINK_H_

◆ CS_COMMON_SHA1_H_

#define CS_COMMON_SHA1_H_

◆ CS_COMMON_STR_UTIL_H_

#define CS_COMMON_STR_UTIL_H_

◆ CS_ENABLE_STRDUP

#define CS_ENABLE_STRDUP 0

◆ CS_ENABLE_TO64

#define CS_ENABLE_TO64 0

◆ CS_MONGOOSE_SRC_COAP_H_

#define CS_MONGOOSE_SRC_COAP_H_

◆ CS_MONGOOSE_SRC_COMMON_H_

#define CS_MONGOOSE_SRC_COMMON_H_

◆ CS_MONGOOSE_SRC_DNS_H_

#define CS_MONGOOSE_SRC_DNS_H_

◆ CS_MONGOOSE_SRC_DNS_SERVER_H_

#define CS_MONGOOSE_SRC_DNS_SERVER_H_

◆ CS_MONGOOSE_SRC_FEATURES_H_

#define CS_MONGOOSE_SRC_FEATURES_H_

◆ CS_MONGOOSE_SRC_HTTP_CLIENT_H_

#define CS_MONGOOSE_SRC_HTTP_CLIENT_H_

◆ CS_MONGOOSE_SRC_HTTP_H_

#define CS_MONGOOSE_SRC_HTTP_H_

◆ CS_MONGOOSE_SRC_HTTP_SERVER_H_

#define CS_MONGOOSE_SRC_HTTP_SERVER_H_

◆ CS_MONGOOSE_SRC_MQTT_BROKER_H_

#define CS_MONGOOSE_SRC_MQTT_BROKER_H_

◆ CS_MONGOOSE_SRC_MQTT_H_

#define CS_MONGOOSE_SRC_MQTT_H_

◆ CS_MONGOOSE_SRC_NET_H_

#define CS_MONGOOSE_SRC_NET_H_

◆ CS_MONGOOSE_SRC_NET_IF_H_

#define CS_MONGOOSE_SRC_NET_IF_H_

◆ CS_MONGOOSE_SRC_RESOLV_H_

#define CS_MONGOOSE_SRC_RESOLV_H_

◆ CS_MONGOOSE_SRC_SNTP_H_

#define CS_MONGOOSE_SRC_SNTP_H_

◆ CS_MONGOOSE_SRC_SSL_IF_H_

#define CS_MONGOOSE_SRC_SSL_IF_H_

◆ CS_MONGOOSE_SRC_URI_H_

#define CS_MONGOOSE_SRC_URI_H_

◆ CS_MONGOOSE_SRC_UTIL_H_

#define CS_MONGOOSE_SRC_UTIL_H_

◆ CS_P_CC3100

#define CS_P_CC3100 6

◆ CS_P_CC3200

#define CS_P_CC3200 4

◆ CS_P_CUSTOM

#define CS_P_CUSTOM 0

◆ CS_P_ESP32

#define CS_P_ESP32 15

◆ CS_P_ESP8266

#define CS_P_ESP8266 3

◆ CS_P_MBED

#define CS_P_MBED 7

◆ CS_P_MSP432

#define CS_P_MSP432 5

◆ CS_P_NRF51

#define CS_P_NRF51 12

◆ CS_P_NRF52

#define CS_P_NRF52 10

◆ CS_P_NXP_KINETIS

#define CS_P_NXP_KINETIS 9

◆ CS_P_NXP_LPC

#define CS_P_NXP_LPC 13

◆ CS_P_PIC32

#define CS_P_PIC32 11

◆ CS_P_STM32

#define CS_P_STM32 16

◆ CS_P_TM4C129

#define CS_P_TM4C129 14

◆ CS_P_UNIX

#define CS_P_UNIX 1

◆ CS_P_WINCE

#define CS_P_WINCE 8

◆ CS_P_WINDOWS

#define CS_P_WINDOWS 2

◆ CS_STRINGIFY_LIT

#define CS_STRINGIFY_LIT ( x ) #x

◆ CS_STRINGIFY_MACRO

#define CS_STRINGIFY_MACRO ( x ) CS_STRINGIFY_LIT(x)

◆ DISABLE_BASE64

#define DISABLE_BASE64 0

◆ DISABLE_MD5

#define DISABLE_MD5 0

◆ DISABLE_SHA1

#define DISABLE_SHA1 0

◆ DO_NOT_WARN_UNUSED

#define DO_NOT_WARN_UNUSED

◆ LIST_CLASS_ENTRY

#define LIST_CLASS_ENTRY ( type )

Макроопределение:

struct {                                \
    class type *le_next;    /* next element */          \
    class type **le_prev;   /* address of previous next element */  \
}

◆ LIST_CLASS_HEAD

#define LIST_CLASS_HEAD	(	name,
		type
	)

Макроопределение:

struct name {                               \
    class type *lh_first;   /* first element */         \
}

◆ LIST_EMPTY

#define LIST_EMPTY ( head ) ((head)->lh_first == NULL)

◆ LIST_ENTRY

#define LIST_ENTRY ( type )

Макроопределение:

struct {                                \
    struct type *le_next;   /* next element */          \
    struct type **le_prev;  /* address of previous next element */  \
}

◆ LIST_FIRST

#define LIST_FIRST ( head ) ((head)->lh_first)

◆ LIST_FOREACH

#define LIST_FOREACH	(	var,
		head,
		field
	)

Макроопределение:

for ((var) = LIST_FIRST((head));                \
        (var);                          \
        (var) = LIST_NEXT((var), field))

◆ LIST_FOREACH_FROM

#define LIST_FOREACH_FROM	(	var,
		head,
		field
	)

Макроопределение:

for ((var) = ((var) ? (var) : LIST_FIRST((head)));      \
        (var);                          \
        (var) = LIST_NEXT((var), field))

◆ LIST_FOREACH_FROM_SAFE

#define LIST_FOREACH_FROM_SAFE	(	var,
		head,
		field,
		tvar
	)

Макроопределение:

for ((var) = ((var) ? (var) : LIST_FIRST((head)));      \
        (var) && ((tvar) = LIST_NEXT((var), field), 1);     \
        (var) = (tvar))

◆ LIST_FOREACH_SAFE

#define LIST_FOREACH_SAFE	(	var,
		head,
		field,
		tvar
	)

Макроопределение:

for ((var) = LIST_FIRST((head));                \
        (var) && ((tvar) = LIST_NEXT((var), field), 1);     \
        (var) = (tvar))

◆ LIST_HEAD

#define LIST_HEAD	(	name,
		type
	)

Макроопределение:

struct name {                               \
    struct type *lh_first;  /* first element */         \
}

◆ LIST_HEAD_INITIALIZER

#define LIST_HEAD_INITIALIZER ( head ) { NULL }

◆ LIST_INIT

#define LIST_INIT ( head )

Макроопределение:

do {                        \
    LIST_FIRST((head)) = NULL;                  \
} while (0)

◆ LIST_INSERT_AFTER

#define LIST_INSERT_AFTER	(	listelm,
		elm,
		field
	)

Макроопределение:

do {            \
    QMD_LIST_CHECK_NEXT(listelm, field);                \
    if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
        LIST_NEXT((listelm), field)->field.le_prev =        \
            &LIST_NEXT((elm), field);               \
    LIST_NEXT((listelm), field) = (elm);                \
    (elm)->field.le_prev = &LIST_NEXT((listelm), field);        \
} while (0)

◆ LIST_INSERT_BEFORE

#define LIST_INSERT_BEFORE	(	listelm,
		elm,
		field
	)

Макроопределение:

do {            \
    QMD_LIST_CHECK_PREV(listelm, field);                \
    (elm)->field.le_prev = (listelm)->field.le_prev;        \
    LIST_NEXT((elm), field) = (listelm);                \
    *(listelm)->field.le_prev = (elm);              \
    (listelm)->field.le_prev = &LIST_NEXT((elm), field);        \
} while (0)

◆ LIST_INSERT_HEAD

#define LIST_INSERT_HEAD	(	head,
		elm,
		field
	)

Макроопределение:

do {                \
    QMD_LIST_CHECK_HEAD((head), field);             \
    if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
        LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
    LIST_FIRST((head)) = (elm);                 \
    (elm)->field.le_prev = &LIST_FIRST((head));         \
} while (0)

◆ LIST_NEXT

#define LIST_NEXT	(	elm,
		field
	)	((elm)->field.le_next)

◆ LIST_PREV

#define LIST_PREV	(	elm,
		head,
		type,
		field
	)

Макроопределение:

((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL :   \
        __containerof((elm)->field.le_prev,         \
        QUEUE_TYPEOF(type), field.le_next))

◆ LIST_REMOVE

#define LIST_REMOVE	(	elm,
		field
	)

Макроопределение:

do {                    \
    QMD_SAVELINK(oldnext, (elm)->field.le_next);            \
    QMD_SAVELINK(oldprev, (elm)->field.le_prev);            \
    QMD_LIST_CHECK_NEXT(elm, field);                \
    QMD_LIST_CHECK_PREV(elm, field);                \
    if (LIST_NEXT((elm), field) != NULL)                \
        LIST_NEXT((elm), field)->field.le_prev =        \
            (elm)->field.le_prev;               \
    *(elm)->field.le_prev = LIST_NEXT((elm), field);        \
    TRASHIT(*oldnext);                      \
    TRASHIT(*oldprev);                      \
} while (0)

◆ LIST_SWAP

#define LIST_SWAP	(	head1,
		head2,
		type,
		field
	)

Макроопределение:

do {            \
    QUEUE_TYPEOF(type) *swap_tmp = LIST_FIRST(head1);       \
    LIST_FIRST((head1)) = LIST_FIRST((head2));          \
    LIST_FIRST((head2)) = swap_tmp;                 \
    if ((swap_tmp = LIST_FIRST((head1))) != NULL)           \
        swap_tmp->field.le_prev = &LIST_FIRST((head1));     \
    if ((swap_tmp = LIST_FIRST((head2))) != NULL)           \
        swap_tmp->field.le_prev = &LIST_FIRST((head2));     \
} while (0)

◆ MAX_PATH_SIZE

#define MAX_PATH_SIZE 500

◆ MBUF_SIZE_MULTIPLIER

#define MBUF_SIZE_MULTIPLIER 1.5

◆ MG_CGI_ENVIRONMENT_SIZE

#define MG_CGI_ENVIRONMENT_SIZE 8192

◆ MG_DISABLE_HTTP_DIGEST_AUTH

#define MG_DISABLE_HTTP_DIGEST_AUTH 0

◆ MG_DISABLE_HTTP_KEEP_ALIVE

#define MG_DISABLE_HTTP_KEEP_ALIVE 0

◆ MG_DISABLE_PFS

#define MG_DISABLE_PFS 0

◆ MG_DISABLE_WS_RANDOM_MASK

#define MG_DISABLE_WS_RANDOM_MASK 0

◆ MG_DNS_A_RECORD

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

◆ MG_DNS_AAAA_RECORD

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

◆ MG_DNS_CNAME_RECORD

#define MG_DNS_CNAME_RECORD 0x05 /* Lookup CNAME */

◆ MG_DNS_MESSAGE

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

◆ MG_DNS_MX_RECORD

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

◆ MG_DNS_PTR_RECORD

#define MG_DNS_PTR_RECORD 0x0c /* Lookup PTR */

◆ MG_DNS_SRV_RECORD

#define MG_DNS_SRV_RECORD 0x21 /* Lookup SRV */

◆ MG_DNS_TXT_RECORD

#define MG_DNS_TXT_RECORD 0x10 /* Lookup TXT */

◆ MG_ENABLE_ASYNC_RESOLVER

#define MG_ENABLE_ASYNC_RESOLVER 1

◆ MG_ENABLE_BROADCAST

#define MG_ENABLE_BROADCAST 0

◆ MG_ENABLE_COAP

#define MG_ENABLE_COAP 0

◆ MG_ENABLE_DEBUG

#define MG_ENABLE_DEBUG 0

◆ MG_ENABLE_DIRECTORY_LISTING

#define MG_ENABLE_DIRECTORY_LISTING 0

◆ MG_ENABLE_DNS

#define MG_ENABLE_DNS 1

◆ MG_ENABLE_DNS_SERVER

#define MG_ENABLE_DNS_SERVER 0

◆ MG_ENABLE_EXTRA_ERRORS_DESC

#define MG_ENABLE_EXTRA_ERRORS_DESC 0

◆ MG_ENABLE_FAKE_DAVLOCK

#define MG_ENABLE_FAKE_DAVLOCK 0

◆ MG_ENABLE_FILESYSTEM

#define MG_ENABLE_FILESYSTEM 0

◆ MG_ENABLE_GETADDRINFO

#define MG_ENABLE_GETADDRINFO 0

◆ MG_ENABLE_HEXDUMP

#define MG_ENABLE_HEXDUMP CS_ENABLE_STDIO

◆ MG_ENABLE_HTTP

#define MG_ENABLE_HTTP 1

◆ MG_ENABLE_HTTP_CGI

#define MG_ENABLE_HTTP_CGI 0

◆ MG_ENABLE_HTTP_SSI

#define MG_ENABLE_HTTP_SSI MG_ENABLE_FILESYSTEM

◆ MG_ENABLE_HTTP_SSI_EXEC

#define MG_ENABLE_HTTP_SSI_EXEC 0

◆ MG_ENABLE_HTTP_STREAMING_MULTIPART

#define MG_ENABLE_HTTP_STREAMING_MULTIPART 0

◆ MG_ENABLE_HTTP_URL_REWRITES

#define MG_ENABLE_HTTP_URL_REWRITES (CS_PLATFORM == CS_P_WINDOWS || CS_PLATFORM == CS_P_UNIX)

◆ MG_ENABLE_HTTP_WEBDAV

#define MG_ENABLE_HTTP_WEBDAV 0

◆ MG_ENABLE_HTTP_WEBSOCKET

#define MG_ENABLE_HTTP_WEBSOCKET MG_ENABLE_HTTP

◆ MG_ENABLE_IPV6

#define MG_ENABLE_IPV6 0

◆ MG_ENABLE_JAVASCRIPT

#define MG_ENABLE_JAVASCRIPT 0

◆ MG_ENABLE_MQTT

#define MG_ENABLE_MQTT 1

◆ MG_ENABLE_MQTT_BROKER

#define MG_ENABLE_MQTT_BROKER 0

◆ MG_ENABLE_SNTP

#define MG_ENABLE_SNTP 0

◆ MG_ENABLE_SSL

#define MG_ENABLE_SSL 0

◆ MG_ENABLE_STDIO

#define MG_ENABLE_STDIO CS_ENABLE_STDIO

◆ MG_ENABLE_SYNC_RESOLVER

#define MG_ENABLE_SYNC_RESOLVER 0

◆ MG_ENABLE_THREADS

#define MG_ENABLE_THREADS 0

◆ MG_ENABLE_TUN

#define MG_ENABLE_TUN MG_ENABLE_HTTP_WEBSOCKET

◆ MG_EV_ACCEPT

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

◆ MG_EV_CLOSE

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

◆ MG_EV_CONNECT

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

◆ MG_EV_HTTP_CHUNK

#define MG_EV_HTTP_CHUNK 102 /* struct http_message * */

◆ MG_EV_HTTP_REPLY

#define MG_EV_HTTP_REPLY 101 /* struct http_message * */

◆ MG_EV_HTTP_REQUEST

#define MG_EV_HTTP_REQUEST 100 /* struct http_message * */

◆ MG_EV_MQTT_CONNACK

#define MG_EV_MQTT_CONNACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNACK)

◆ MG_EV_MQTT_CONNACK_ACCEPTED

#define MG_EV_MQTT_CONNACK_ACCEPTED 0

◆ MG_EV_MQTT_CONNACK_BAD_AUTH

#define MG_EV_MQTT_CONNACK_BAD_AUTH 4

◆ MG_EV_MQTT_CONNACK_IDENTIFIER_REJECTED

#define MG_EV_MQTT_CONNACK_IDENTIFIER_REJECTED 2

◆ MG_EV_MQTT_CONNACK_NOT_AUTHORIZED

#define MG_EV_MQTT_CONNACK_NOT_AUTHORIZED 5

◆ MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE

#define MG_EV_MQTT_CONNACK_SERVER_UNAVAILABLE 3

◆ MG_EV_MQTT_CONNACK_UNACCEPTABLE_VERSION

#define MG_EV_MQTT_CONNACK_UNACCEPTABLE_VERSION 1

◆ MG_EV_MQTT_CONNECT

#define MG_EV_MQTT_CONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_CONNECT)

◆ MG_EV_MQTT_DISCONNECT

#define MG_EV_MQTT_DISCONNECT (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_DISCONNECT)

◆ MG_EV_MQTT_PINGREQ

#define MG_EV_MQTT_PINGREQ (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGREQ)

◆ MG_EV_MQTT_PINGRESP

#define MG_EV_MQTT_PINGRESP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PINGRESP)

◆ MG_EV_MQTT_PUBACK

#define MG_EV_MQTT_PUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBACK)

◆ MG_EV_MQTT_PUBCOMP

#define MG_EV_MQTT_PUBCOMP (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBCOMP)

◆ MG_EV_MQTT_PUBLISH

#define MG_EV_MQTT_PUBLISH (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBLISH)

◆ MG_EV_MQTT_PUBREC

#define MG_EV_MQTT_PUBREC (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREC)

◆ MG_EV_MQTT_PUBREL

#define MG_EV_MQTT_PUBREL (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_PUBREL)

◆ MG_EV_MQTT_SUBACK

#define MG_EV_MQTT_SUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBACK)

◆ MG_EV_MQTT_SUBSCRIBE

#define MG_EV_MQTT_SUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_SUBSCRIBE)

◆ MG_EV_MQTT_UNSUBACK

#define MG_EV_MQTT_UNSUBACK (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBACK)

◆ MG_EV_MQTT_UNSUBSCRIBE

#define MG_EV_MQTT_UNSUBSCRIBE (MG_MQTT_EVENT_BASE + MG_MQTT_CMD_UNSUBSCRIBE)

◆ MG_EV_POLL

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

◆ MG_EV_RECV

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

◆ MG_EV_SEND

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

◆ MG_EV_SSI_CALL

#define MG_EV_SSI_CALL 105 /* char * */

◆ MG_EV_SSI_CALL_CTX

#define MG_EV_SSI_CALL_CTX 106 /* struct mg_ssi_call_ctx * */

◆ MG_EV_TIMER

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

◆ MG_EV_WEBSOCKET_CONTROL_FRAME

#define MG_EV_WEBSOCKET_CONTROL_FRAME 114 /* struct websocket_message * */

◆ MG_EV_WEBSOCKET_FRAME

#define MG_EV_WEBSOCKET_FRAME 113 /* struct websocket_message * */

◆ MG_EV_WEBSOCKET_HANDSHAKE_DONE

#define MG_EV_WEBSOCKET_HANDSHAKE_DONE 112 /* NULL */

◆ MG_EV_WEBSOCKET_HANDSHAKE_REQUEST

#define MG_EV_WEBSOCKET_HANDSHAKE_REQUEST 111 /* struct http_message * */

◆ MG_F_CLOSE_IMMEDIATELY

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

◆ MG_F_CONNECTING

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

◆ MG_F_DELETE_CHUNK

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

◆ MG_F_ENABLE_BROADCAST

#define MG_F_ENABLE_BROADCAST (1 << 14) /* Allow broadcast address usage */

◆ MG_F_IS_WEBSOCKET

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

◆ MG_F_LISTENING

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

◆ MG_F_RESOLVING

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

◆ MG_F_SEND_AND_CLOSE

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

◆ MG_F_SSL

#define MG_F_SSL (1 << 4) /* SSL is enabled on the connection */

◆ MG_F_SSL_HANDSHAKE_DONE

#define MG_F_SSL_HANDSHAKE_DONE (1 << 5) /* SSL hanshake has completed */

◆ MG_F_TUN_DO_NOT_RECONNECT

#define MG_F_TUN_DO_NOT_RECONNECT (1 << 15) /* Don't reconnect tunnel */

◆ MG_F_UDP

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

◆ MG_F_USER_1

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

◆ MG_F_USER_2

#define MG_F_USER_2 (1 << 21)

◆ MG_F_USER_3

#define MG_F_USER_3 (1 << 22)

◆ MG_F_USER_4

#define MG_F_USER_4 (1 << 23)

◆ MG_F_USER_5

#define MG_F_USER_5 (1 << 24)

◆ MG_F_USER_6

#define MG_F_USER_6 (1 << 25)

◆ MG_F_WANT_READ

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

◆ MG_F_WANT_WRITE

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

◆ MG_F_WEBSOCKET_NO_DEFRAG

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

◆ MG_LWIP

#define MG_LWIP 0

◆ MG_MAIN_IFACE

#define MG_MAIN_IFACE 0

◆ MG_MAX_DNS_ANSWERS

#define MG_MAX_DNS_ANSWERS 32

◆ MG_MAX_DNS_QUESTIONS

#define MG_MAX_DNS_QUESTIONS 32

◆ MG_MAX_HTTP_HEADERS

#define MG_MAX_HTTP_HEADERS 20

◆ MG_MAX_HTTP_REQUEST_SIZE

#define MG_MAX_HTTP_REQUEST_SIZE 1024

◆ MG_MAX_HTTP_SEND_MBUF

#define MG_MAX_HTTP_SEND_MBUF 1024

◆ MG_MAX_PATH

#define MG_MAX_PATH 256

◆ MG_MK_STR

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

◆ MG_MQTT_CLEAN_SESSION

#define MG_MQTT_CLEAN_SESSION 0x02

◆ MG_MQTT_CMD_CONNACK

#define MG_MQTT_CMD_CONNACK 2

◆ MG_MQTT_CMD_CONNECT

#define MG_MQTT_CMD_CONNECT 1

◆ MG_MQTT_CMD_DISCONNECT

#define MG_MQTT_CMD_DISCONNECT 14

◆ MG_MQTT_CMD_PINGREQ

#define MG_MQTT_CMD_PINGREQ 12

◆ MG_MQTT_CMD_PINGRESP

#define MG_MQTT_CMD_PINGRESP 13

◆ MG_MQTT_CMD_PUBACK

#define MG_MQTT_CMD_PUBACK 4

◆ MG_MQTT_CMD_PUBCOMP

#define MG_MQTT_CMD_PUBCOMP 7

◆ MG_MQTT_CMD_PUBLISH

#define MG_MQTT_CMD_PUBLISH 3

◆ MG_MQTT_CMD_PUBREC

#define MG_MQTT_CMD_PUBREC 5

◆ MG_MQTT_CMD_PUBREL

#define MG_MQTT_CMD_PUBREL 6

◆ MG_MQTT_CMD_SUBACK

#define MG_MQTT_CMD_SUBACK 9

◆ MG_MQTT_CMD_SUBSCRIBE

#define MG_MQTT_CMD_SUBSCRIBE 8

◆ MG_MQTT_CMD_UNSUBACK

#define MG_MQTT_CMD_UNSUBACK 11

◆ MG_MQTT_CMD_UNSUBSCRIBE

#define MG_MQTT_CMD_UNSUBSCRIBE 10

◆ MG_MQTT_DUP

#define MG_MQTT_DUP 0x4

◆ MG_MQTT_EVENT_BASE

#define MG_MQTT_EVENT_BASE 200

◆ MG_MQTT_GET_QOS

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

◆ MG_MQTT_GET_WILL_QOS

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

◆ MG_MQTT_HAS_PASSWORD

#define MG_MQTT_HAS_PASSWORD 0x40

◆ MG_MQTT_HAS_USER_NAME

#define MG_MQTT_HAS_USER_NAME 0x80

◆ MG_MQTT_HAS_WILL

#define MG_MQTT_HAS_WILL 0x04

◆ MG_MQTT_QOS

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

◆ MG_MQTT_RETAIN

#define MG_MQTT_RETAIN 0x1

◆ MG_MQTT_SET_QOS

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

◆ MG_MQTT_SET_WILL_QOS

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

◆ MG_MQTT_WILL_RETAIN

#define MG_MQTT_WILL_RETAIN 0x20

◆ MG_NET_IF

#define MG_NET_IF MG_NET_IF_SOCKET

◆ MG_NET_IF_LWIP_LOW_LEVEL

#define MG_NET_IF_LWIP_LOW_LEVEL 3

◆ MG_NET_IF_PIC32

#define MG_NET_IF_PIC32 4

◆ MG_NET_IF_SIMPLELINK

#define MG_NET_IF_SIMPLELINK 2

◆ MG_NET_IF_SOCKET

#define MG_NET_IF_SOCKET 1

◆ MG_RECV_FUNC

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

◆ MG_SEND_FUNC

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

◆ MG_SOCK_STRINGIFY_IP

#define MG_SOCK_STRINGIFY_IP 1

◆ MG_SOCK_STRINGIFY_PORT

#define MG_SOCK_STRINGIFY_PORT 2

◆ MG_SOCK_STRINGIFY_REMOTE

#define MG_SOCK_STRINGIFY_REMOTE 4

◆ MG_SSL_IF

#define MG_SSL_IF MG_SSL_IF_OPENSSL

◆ MG_SSL_IF_MBEDTLS

#define MG_SSL_IF_MBEDTLS 2

◆ MG_SSL_IF_OPENSSL

#define MG_SSL_IF_OPENSSL 1

◆ MG_SSL_IF_SIMPLELINK

#define MG_SSL_IF_SIMPLELINK 3

◆ MG_VERSION

#define MG_VERSION "6.7"

◆ MG_VPRINTF_BUFFER_SIZE

#define MG_VPRINTF_BUFFER_SIZE 100

◆ NOINLINE

#define NOINLINE

◆ NOINSTR

#define NOINSTR

◆ NORETURN

#define NORETURN

◆ QMD_LIST_CHECK_HEAD

#define QMD_LIST_CHECK_HEAD	(	head,
		field
	)

◆ QMD_LIST_CHECK_NEXT

#define QMD_LIST_CHECK_NEXT	(	elm,
		field
	)

◆ QMD_LIST_CHECK_PREV

#define QMD_LIST_CHECK_PREV	(	elm,
		field
	)

◆ QMD_SAVELINK

#define QMD_SAVELINK	(	name,
		link
	)

◆ QMD_TAILQ_CHECK_HEAD

#define QMD_TAILQ_CHECK_HEAD	(	head,
		field
	)

◆ QMD_TAILQ_CHECK_NEXT

#define QMD_TAILQ_CHECK_NEXT	(	elm,
		field
	)

◆ QMD_TAILQ_CHECK_PREV

#define QMD_TAILQ_CHECK_PREV	(	elm,
		field
	)

◆ QMD_TAILQ_CHECK_TAIL

#define QMD_TAILQ_CHECK_TAIL	(	head,
		headname
	)

◆ QMD_TRACE_ELEM

#define QMD_TRACE_ELEM ( elem )

◆ QMD_TRACE_HEAD

#define QMD_TRACE_HEAD ( head )

◆ QUEUE_TYPEOF

#define QUEUE_TYPEOF ( type ) struct type

◆ SLIST_CLASS_ENTRY

#define SLIST_CLASS_ENTRY ( type )

Макроопределение:

struct {                                \
    class type *sle_next;       /* next element */      \
}

◆ SLIST_CLASS_HEAD

#define SLIST_CLASS_HEAD	(	name,
		type
	)

Макроопределение:

struct name {                               \
    class type *slh_first;  /* first element */         \
}

◆ SLIST_EMPTY

#define SLIST_EMPTY ( head ) ((head)->slh_first == NULL)

◆ SLIST_ENTRY

#define SLIST_ENTRY ( type )

Макроопределение:

struct {                                \
    struct type *sle_next;  /* next element */          \
}

◆ SLIST_FIRST

#define SLIST_FIRST ( head ) ((head)->slh_first)

◆ SLIST_FOREACH

#define SLIST_FOREACH	(	var,
		head,
		field
	)

Макроопределение:

for ((var) = SLIST_FIRST((head));               \
        (var);                          \
        (var) = SLIST_NEXT((var), field))

◆ SLIST_FOREACH_FROM

#define SLIST_FOREACH_FROM	(	var,
		head,
		field
	)

Макроопределение:

for ((var) = ((var) ? (var) : SLIST_FIRST((head)));     \
        (var);                          \
        (var) = SLIST_NEXT((var), field))

◆ SLIST_FOREACH_FROM_SAFE

#define SLIST_FOREACH_FROM_SAFE	(	var,
		head,
		field,
		tvar
	)

Макроопределение:

for ((var) = ((var) ? (var) : SLIST_FIRST((head)));     \
        (var) && ((tvar) = SLIST_NEXT((var), field), 1);        \
        (var) = (tvar))

◆ SLIST_FOREACH_PREVPTR

#define SLIST_FOREACH_PREVPTR	(	var,
		varp,
		head,
		field
	)

Макроопределение:

for ((varp) = &SLIST_FIRST((head));             \
        ((var) = *(varp)) != NULL;                  \
        (varp) = &SLIST_NEXT((var), field))

◆ SLIST_FOREACH_SAFE

#define SLIST_FOREACH_SAFE	(	var,
		head,
		field,
		tvar
	)

Макроопределение:

for ((var) = SLIST_FIRST((head));               \
        (var) && ((tvar) = SLIST_NEXT((var), field), 1);        \
        (var) = (tvar))

◆ SLIST_HEAD

#define SLIST_HEAD	(	name,
		type
	)

Макроопределение:

struct name {                               \
    struct type *slh_first; /* first element */         \
}

◆ SLIST_HEAD_INITIALIZER

#define SLIST_HEAD_INITIALIZER ( head ) { NULL }

◆ SLIST_INIT

#define SLIST_INIT ( head )

Макроопределение:

do {                        \
    SLIST_FIRST((head)) = NULL;                 \
} while (0)

◆ SLIST_INSERT_AFTER

#define SLIST_INSERT_AFTER	(	slistelm,
		elm,
		field
	)

Макроопределение:

do {            \
    SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);   \
    SLIST_NEXT((slistelm), field) = (elm);              \
} while (0)

◆ SLIST_INSERT_HEAD

#define SLIST_INSERT_HEAD	(	head,
		elm,
		field
	)

Макроопределение:

do {            \
    SLIST_NEXT((elm), field) = SLIST_FIRST((head));         \
    SLIST_FIRST((head)) = (elm);                    \
} while (0)

◆ SLIST_NEXT

#define SLIST_NEXT	(	elm,
		field
	)	((elm)->field.sle_next)

◆ SLIST_REMOVE

#define SLIST_REMOVE	(	head,
		elm,
		type,
		field
	)

Макроопределение:

do {            \
    QMD_SAVELINK(oldnext, (elm)->field.sle_next);           \
    if (SLIST_FIRST((head)) == (elm)) {             \
        SLIST_REMOVE_HEAD((head), field);           \
    }                               \
    else {                              \
        QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head);     \
        while (SLIST_NEXT(curelm, field) != (elm))      \
            curelm = SLIST_NEXT(curelm, field);     \
        SLIST_REMOVE_AFTER(curelm, field);          \
    }                               \
    TRASHIT(*oldnext);                      \
} while (0)

◆ SLIST_REMOVE_AFTER

#define SLIST_REMOVE_AFTER	(	elm,
		field
	)

Макроопределение:

do {                \
    SLIST_NEXT(elm, field) =                    \
        SLIST_NEXT(SLIST_NEXT(elm, field), field);          \
} while (0)

◆ SLIST_REMOVE_HEAD

#define SLIST_REMOVE_HEAD	(	head,
		field
	)

Макроопределение:

do {                \
    SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);   \
} while (0)

◆ SLIST_SWAP

#define SLIST_SWAP	(	head1,
		head2,
		type
	)

Макроопределение:

do {                \
    QUEUE_TYPEOF(type) *swap_first = SLIST_FIRST(head1);        \
    SLIST_FIRST(head1) = SLIST_FIRST(head2);            \
    SLIST_FIRST(head2) = swap_first;                \
} while (0)

◆ STAILQ_CLASS_ENTRY

#define STAILQ_CLASS_ENTRY ( type )

Макроопределение:

struct {                                \
    class type *stqe_next;  /* next element */          \
}

◆ STAILQ_CLASS_HEAD

#define STAILQ_CLASS_HEAD	(	name,
		type
	)

Макроопределение:

struct name {                               \
    class type *stqh_first; /* first element */         \
    class type **stqh_last; /* addr of last next element */     \
}

◆ STAILQ_CONCAT

#define STAILQ_CONCAT	(	head1,
		head2
	)

Макроопределение:

do {                \
    if (!STAILQ_EMPTY((head2))) {                   \
        *(head1)->stqh_last = (head2)->stqh_first;      \
        (head1)->stqh_last = (head2)->stqh_last;        \
        STAILQ_INIT((head2));                   \
    }                               \
} while (0)

◆ STAILQ_EMPTY

#define STAILQ_EMPTY ( head ) ((head)->stqh_first == NULL)

◆ STAILQ_ENTRY

#define STAILQ_ENTRY ( type )

Макроопределение:

struct {                                \
    struct type *stqe_next; /* next element */          \
}

◆ STAILQ_FIRST

#define STAILQ_FIRST ( head ) ((head)->stqh_first)

◆ STAILQ_FOREACH

#define STAILQ_FOREACH	(	var,
		head,
		field
	)

Макроопределение:

for((var) = STAILQ_FIRST((head));               \
       (var);                           \
       (var) = STAILQ_NEXT((var), field))

◆ STAILQ_FOREACH_FROM

#define STAILQ_FOREACH_FROM	(	var,
		head,
		field
	)

Макроопределение:

for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));        \
       (var);                           \
       (var) = STAILQ_NEXT((var), field))

◆ STAILQ_FOREACH_FROM_SAFE

#define STAILQ_FOREACH_FROM_SAFE	(	var,
		head,
		field,
		tvar
	)

Макроопределение:

for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));        \
        (var) && ((tvar) = STAILQ_NEXT((var), field), 1);       \
        (var) = (tvar))

◆ STAILQ_FOREACH_SAFE

#define STAILQ_FOREACH_SAFE	(	var,
		head,
		field,
		tvar
	)

Макроопределение:

for ((var) = STAILQ_FIRST((head));              \
        (var) && ((tvar) = STAILQ_NEXT((var), field), 1);       \
        (var) = (tvar))

◆ STAILQ_HEAD

#define STAILQ_HEAD	(	name,
		type
	)

Макроопределение:

struct name {                               \
    struct type *stqh_first;/* first element */         \
    struct type **stqh_last;/* addr of last next element */     \
}

◆ STAILQ_HEAD_INITIALIZER

#define STAILQ_HEAD_INITIALIZER ( head ) { NULL, &(head).stqh_first }

◆ STAILQ_INIT

#define STAILQ_INIT ( head )

Макроопределение:

do {                        \
    STAILQ_FIRST((head)) = NULL;                    \
    (head)->stqh_last = &STAILQ_FIRST((head));          \
} while (0)

◆ STAILQ_INSERT_AFTER

#define STAILQ_INSERT_AFTER	(	head,
		tqelm,
		elm,
		field
	)

Макроопределение:

do {        \
    if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
        (head)->stqh_last = &STAILQ_NEXT((elm), field);     \
    STAILQ_NEXT((tqelm), field) = (elm);                \
} while (0)

◆ STAILQ_INSERT_HEAD

#define STAILQ_INSERT_HEAD	(	head,
		elm,
		field
	)

Макроопределение:

do {            \
    if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
        (head)->stqh_last = &STAILQ_NEXT((elm), field);     \
    STAILQ_FIRST((head)) = (elm);                   \
} while (0)

◆ STAILQ_INSERT_TAIL

#define STAILQ_INSERT_TAIL	(	head,
		elm,
		field
	)

Макроопределение:

do {            \
    STAILQ_NEXT((elm), field) = NULL;               \
    *(head)->stqh_last = (elm);                 \
    (head)->stqh_last = &STAILQ_NEXT((elm), field);         \
} while (0)

◆ STAILQ_LAST

#define STAILQ_LAST	(	head,
		type,
		field
	)

Макроопределение:

(STAILQ_EMPTY((head)) ? NULL :              \
        __containerof((head)->stqh_last,            \
        QUEUE_TYPEOF(type), field.stqe_next))

◆ STAILQ_NEXT

#define STAILQ_NEXT	(	elm,
		field
	)	((elm)->field.stqe_next)

◆ STAILQ_REMOVE

#define STAILQ_REMOVE	(	head,
		elm,
		type,
		field
	)

Макроопределение:

do {            \
    QMD_SAVELINK(oldnext, (elm)->field.stqe_next);          \
    if (STAILQ_FIRST((head)) == (elm)) {                \
        STAILQ_REMOVE_HEAD((head), field);          \
    }                               \
    else {                              \
        QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head);    \
        while (STAILQ_NEXT(curelm, field) != (elm))     \
            curelm = STAILQ_NEXT(curelm, field);        \
        STAILQ_REMOVE_AFTER(head, curelm, field);       \
    }                               \
    TRASHIT(*oldnext);                      \
} while (0)

◆ STAILQ_REMOVE_AFTER

#define STAILQ_REMOVE_AFTER	(	head,
		elm,
		field
	)

Макроопределение:

do {            \
    if ((STAILQ_NEXT(elm, field) =                  \
         STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL)  \
        (head)->stqh_last = &STAILQ_NEXT((elm), field);     \
} while (0)

◆ STAILQ_REMOVE_HEAD

#define STAILQ_REMOVE_HEAD	(	head,
		field
	)

Макроопределение:

do {                \
    if ((STAILQ_FIRST((head)) =                 \
         STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)     \
        (head)->stqh_last = &STAILQ_FIRST((head));      \
} while (0)

◆ STAILQ_SWAP

#define STAILQ_SWAP	(	head1,
		head2,
		type
	)

Макроопределение:

do {                \
    QUEUE_TYPEOF(type) *swap_first = STAILQ_FIRST(head1);       \
    QUEUE_TYPEOF(type) **swap_last = (head1)->stqh_last;        \
    STAILQ_FIRST(head1) = STAILQ_FIRST(head2);          \
    (head1)->stqh_last = (head2)->stqh_last;            \
    STAILQ_FIRST(head2) = swap_first;               \
    (head2)->stqh_last = swap_last;                 \
    if (STAILQ_EMPTY(head1))                    \
        (head1)->stqh_last = &STAILQ_FIRST(head1);      \
    if (STAILQ_EMPTY(head2))                    \
        (head2)->stqh_last = &STAILQ_FIRST(head2);      \
} while (0)

◆ TAILQ_CLASS_ENTRY

#define TAILQ_CLASS_ENTRY ( type )

Макроопределение:

struct {                                \
    class type *tqe_next;   /* next element */          \
    class type **tqe_prev;  /* address of previous next element */  \
    TRACEBUF                            \
}

◆ TAILQ_CLASS_HEAD

#define TAILQ_CLASS_HEAD	(	name,
		type
	)

Макроопределение:

struct name {                               \
    class type *tqh_first;  /* first element */         \
    class type **tqh_last;  /* addr of last next element */     \
    TRACEBUF                            \
}

◆ TAILQ_CONCAT

#define TAILQ_CONCAT	(	head1,
		head2,
		field
	)

Макроопределение:

do {                \
    if (!TAILQ_EMPTY(head2)) {                  \
        *(head1)->tqh_last = (head2)->tqh_first;        \
        (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
        (head1)->tqh_last = (head2)->tqh_last;          \
        TAILQ_INIT((head2));                    \
        QMD_TRACE_HEAD(head1);                  \
        QMD_TRACE_HEAD(head2);                  \
    }                               \
} while (0)

◆ TAILQ_EMPTY

#define TAILQ_EMPTY ( head ) ((head)->tqh_first == NULL)

◆ TAILQ_ENTRY

#define TAILQ_ENTRY ( type )

Макроопределение:

struct {                                \
    struct type *tqe_next;  /* next element */          \
    struct type **tqe_prev; /* address of previous next element */  \
    TRACEBUF                            \
}

◆ TAILQ_FIRST

#define TAILQ_FIRST ( head ) ((head)->tqh_first)

◆ TAILQ_FOREACH

#define TAILQ_FOREACH	(	var,
		head,
		field
	)

Макроопределение:

for ((var) = TAILQ_FIRST((head));               \
        (var);                          \
        (var) = TAILQ_NEXT((var), field))

◆ TAILQ_FOREACH_FROM

#define TAILQ_FOREACH_FROM	(	var,
		head,
		field
	)

Макроопределение:

for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));     \
        (var);                          \
        (var) = TAILQ_NEXT((var), field))

◆ TAILQ_FOREACH_FROM_SAFE

#define TAILQ_FOREACH_FROM_SAFE	(	var,
		head,
		field,
		tvar
	)

Макроопределение:

for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));     \
        (var) && ((tvar) = TAILQ_NEXT((var), field), 1);        \
        (var) = (tvar))

◆ TAILQ_FOREACH_REVERSE

#define TAILQ_FOREACH_REVERSE	(	var,
		head,
		headname,
		field
	)

Макроопределение:

for ((var) = TAILQ_LAST((head), headname);          \
        (var);                          \
        (var) = TAILQ_PREV((var), headname, field))

◆ TAILQ_FOREACH_REVERSE_FROM

#define TAILQ_FOREACH_REVERSE_FROM	(	var,
		head,
		headname,
		field
	)

Макроопределение:

for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));    \
        (var);                          \
        (var) = TAILQ_PREV((var), headname, field))

◆ TAILQ_FOREACH_REVERSE_FROM_SAFE

#define TAILQ_FOREACH_REVERSE_FROM_SAFE	(	var,
		head,
		headname,
		field,
		tvar
	)

Макроопределение:

for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));    \
        (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);  \
        (var) = (tvar))

◆ TAILQ_FOREACH_REVERSE_SAFE

#define TAILQ_FOREACH_REVERSE_SAFE	(	var,
		head,
		headname,
		field,
		tvar
	)

Макроопределение:

for ((var) = TAILQ_LAST((head), headname);          \
        (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);  \
        (var) = (tvar))

◆ TAILQ_FOREACH_SAFE

#define TAILQ_FOREACH_SAFE	(	var,
		head,
		field,
		tvar
	)

Макроопределение:

for ((var) = TAILQ_FIRST((head));               \
        (var) && ((tvar) = TAILQ_NEXT((var), field), 1);        \
        (var) = (tvar))

◆ TAILQ_HEAD

#define TAILQ_HEAD	(	name,
		type
	)

Макроопределение:

struct name {                               \
    struct type *tqh_first; /* first element */         \
    struct type **tqh_last; /* addr of last next element */     \
    TRACEBUF                            \
}

◆ TAILQ_HEAD_INITIALIZER

#define TAILQ_HEAD_INITIALIZER ( head ) { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }

◆ TAILQ_INIT

#define TAILQ_INIT ( head )

Макроопределение:

do {                        \
    TAILQ_FIRST((head)) = NULL;                 \
    (head)->tqh_last = &TAILQ_FIRST((head));            \
    QMD_TRACE_HEAD(head);                       \
} while (0)

◆ TAILQ_INSERT_AFTER

#define TAILQ_INSERT_AFTER	(	head,
		listelm,
		elm,
		field
	)

Макроопределение:

do {        \
    QMD_TAILQ_CHECK_NEXT(listelm, field);               \
    if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
            &TAILQ_NEXT((elm), field);              \
    else {                              \
        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
        QMD_TRACE_HEAD(head);                   \
    }                               \
    TAILQ_NEXT((listelm), field) = (elm);               \
    (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);      \
    QMD_TRACE_ELEM(&(elm)->field);                  \
    QMD_TRACE_ELEM(&(listelm)->field);              \
} while (0)

◆ TAILQ_INSERT_BEFORE

#define TAILQ_INSERT_BEFORE	(	listelm,
		elm,
		field
	)

Макроопределение:

do {            \
    QMD_TAILQ_CHECK_PREV(listelm, field);               \
    (elm)->field.tqe_prev = (listelm)->field.tqe_prev;      \
    TAILQ_NEXT((elm), field) = (listelm);               \
    *(listelm)->field.tqe_prev = (elm);             \
    (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);      \
    QMD_TRACE_ELEM(&(elm)->field);                  \
    QMD_TRACE_ELEM(&(listelm)->field);              \
} while (0)

◆ TAILQ_INSERT_HEAD

#define TAILQ_INSERT_HEAD	(	head,
		elm,
		field
	)

Макроопределение:

do {            \
    QMD_TAILQ_CHECK_HEAD(head, field);              \
    if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)   \
        TAILQ_FIRST((head))->field.tqe_prev =           \
            &TAILQ_NEXT((elm), field);              \
    else                                \
        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
    TAILQ_FIRST((head)) = (elm);                    \
    (elm)->field.tqe_prev = &TAILQ_FIRST((head));           \
    QMD_TRACE_HEAD(head);                       \
    QMD_TRACE_ELEM(&(elm)->field);                  \
} while (0)

◆ TAILQ_INSERT_TAIL

#define TAILQ_INSERT_TAIL	(	head,
		elm,
		field
	)

Макроопределение:

do {            \
    QMD_TAILQ_CHECK_TAIL(head, field);              \
    TAILQ_NEXT((elm), field) = NULL;                \
    (elm)->field.tqe_prev = (head)->tqh_last;           \
    *(head)->tqh_last = (elm);                  \
    (head)->tqh_last = &TAILQ_NEXT((elm), field);           \
    QMD_TRACE_HEAD(head);                       \
    QMD_TRACE_ELEM(&(elm)->field);                  \
} while (0)

◆ TAILQ_LAST

#define TAILQ_LAST	(	head,
		headname
	)	((((struct headname )((head)->tqh_last))->tqh_last))

◆ TAILQ_NEXT

#define TAILQ_NEXT	(	elm,
		field
	)	((elm)->field.tqe_next)

◆ TAILQ_PREV

#define TAILQ_PREV	(	elm,
		headname,
		field
	)	((((struct headname )((elm)->field.tqe_prev))->tqh_last))

◆ TAILQ_REMOVE

#define TAILQ_REMOVE	(	head,
		elm,
		field
	)

Макроопределение:

do {                \
    QMD_SAVELINK(oldnext, (elm)->field.tqe_next);           \
    QMD_SAVELINK(oldprev, (elm)->field.tqe_prev);           \
    QMD_TAILQ_CHECK_NEXT(elm, field);               \
    QMD_TAILQ_CHECK_PREV(elm, field);               \
    if ((TAILQ_NEXT((elm), field)) != NULL)             \
        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
            (elm)->field.tqe_prev;              \
    else {                              \
        (head)->tqh_last = (elm)->field.tqe_prev;       \
        QMD_TRACE_HEAD(head);                   \
    }                               \
    *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);      \
    TRASHIT(*oldnext);                      \
    TRASHIT(*oldprev);                      \
    QMD_TRACE_ELEM(&(elm)->field);                  \
} while (0)

◆ TAILQ_SWAP

#define TAILQ_SWAP	(	head1,
		head2,
		type,
		field
	)

Макроопределение:

do {            \
    QUEUE_TYPEOF(type) *swap_first = (head1)->tqh_first;        \
    QUEUE_TYPEOF(type) **swap_last = (head1)->tqh_last;     \
    (head1)->tqh_first = (head2)->tqh_first;            \
    (head1)->tqh_last = (head2)->tqh_last;              \
    (head2)->tqh_first = swap_first;                \
    (head2)->tqh_last = swap_last;                  \
    if ((swap_first = (head1)->tqh_first) != NULL)          \
        swap_first->field.tqe_prev = &(head1)->tqh_first;   \
    else                                \
        (head1)->tqh_last = &(head1)->tqh_first;        \
    if ((swap_first = (head2)->tqh_first) != NULL)          \
        swap_first->field.tqe_prev = &(head2)->tqh_first;   \
    else                                \
        (head2)->tqh_last = &(head2)->tqh_first;        \
} while (0)

◆ TRACEBUF

#define TRACEBUF

◆ TRACEBUF_INITIALIZER

#define TRACEBUF_INITIALIZER

◆ TRASHIT

#define TRASHIT ( x )

◆ WARN_UNUSED_RESULT

#define WARN_UNUSED_RESULT

◆ WEAK

#define WEAK

◆ WEBSOCKET_DONT_FIN

#define WEBSOCKET_DONT_FIN 0x100

◆ WEBSOCKET_OP_BINARY

#define WEBSOCKET_OP_BINARY 2

◆ WEBSOCKET_OP_CLOSE

#define WEBSOCKET_OP_CLOSE 8

◆ WEBSOCKET_OP_CONTINUE

#define WEBSOCKET_OP_CONTINUE 0

◆ WEBSOCKET_OP_PING

#define WEBSOCKET_OP_PING 9

◆ WEBSOCKET_OP_PONG

#define WEBSOCKET_OP_PONG 10

◆ WEBSOCKET_OP_TEXT

#define WEBSOCKET_OP_TEXT 1

Типы

◆ cs_base64_putc_t

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

◆ MD5_CTX

typedef struct MD5Context MD5_CTX

◆ mg_event_handler_t

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

◆ mg_resolve_callback_t

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

Перечисления

◆ mg_dns_resource_record_kind

enum mg_dns_resource_record_kind

Элементы перечислений
MG_DNS_INVALID_RECORD
MG_DNS_QUESTION
MG_DNS_ANSWER

◆ mg_resolve_err

enum mg_resolve_err

Элементы перечислений
MG_RESOLVE_OK
MG_RESOLVE_NO_ANSWERS
MG_RESOLVE_EXCEEDED_RETRY_COUNT
MG_RESOLVE_TIMEOUT

Функции

◆ c_snprintf()

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

Граф вызовов:

Граф вызова функции:

◆ c_strnlen()

size_t c_strnlen	(	const char *	s,
		size_t	maxlen
	)

Граф вызова функции:

◆ c_strnstr()

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

Граф вызовов:

Граф вызова функции:

◆ c_vsnprintf()

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

Граф вызовов:

Граф вызова функции:

◆ cs_base64_decode()

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

Граф вызовов:

Граф вызова функции:

◆ cs_base64_encode()

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

Граф вызовов:

Граф вызова функции:

◆ cs_base64_finish()

void cs_base64_finish ( struct cs_base64_ctx * ctx )

Граф вызовов:

Граф вызова функции:

◆ cs_base64_init()

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

Граф вызова функции:

◆ cs_base64_update()

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

Граф вызовов:

Граф вызова функции:

◆ cs_fprint_base64()

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

Граф вызова функции:

◆ cs_from_hex()

void cs_from_hex	(	char *	to,
		const char *	p,
		size_t	len
	)

Граф вызовов:

Граф вызова функции:

◆ 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]
	)

Граф вызовов:

◆ cs_md5()

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

Граф вызовов:

Граф вызова функции:

◆ cs_sha1_final()

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

Граф вызовов:

Граф вызова функции:

◆ cs_sha1_init()

void cs_sha1_init ( cs_sha1_ctx * )

Граф вызова функции:

◆ cs_sha1_update()

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

Граф вызовов:

Граф вызова функции:

◆ cs_time()

double cs_time ( void )

Граф вызова функции:

◆ cs_to_hex()

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

Граф вызова функции:

◆ mbuf_append()

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

Граф вызовов:

Граф вызова функции:

◆ mbuf_free()

void mbuf_free ( struct mbuf * )

Граф вызовов:

Граф вызова функции:

◆ mbuf_init()

void mbuf_init	(	struct mbuf *	,
		size_t	initial_capacity
	)

Граф вызовов:

Граф вызова функции:

◆ mbuf_insert()

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

Граф вызовов:

Граф вызова функции:

◆ mbuf_remove()

void mbuf_remove	(	struct mbuf *	,
		size_t	data_size
	)

Граф вызовов:

Граф вызова функции:

◆ mbuf_resize()

void mbuf_resize	(	struct mbuf *	,
		size_t	new_size
	)

Граф вызовов:

Граф вызова функции:

◆ mbuf_trim()

void mbuf_trim ( struct mbuf * )

Граф вызовов:

Граф вызова функции:

◆ MD5_Final()

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

◆ MD5_Init()

void MD5_Init ( MD5_CTX * c )

Граф вызова функции:

◆ MD5_Update()

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

Граф вызовов:

Граф вызова функции:

◆ mg_add_sock()

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

Граф вызовов:

Граф вызова функции:

◆ mg_add_sock_opt()

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

Граф вызовов:

Граф вызова функции:

◆ mg_asprintf()

int mg_asprintf	(	char **	buf,
		size_t	size,
		const char *	fmt,
			...
	)

Граф вызовов:

Граф вызова функции:

◆ mg_avprintf()

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

Граф вызова функции:

◆ mg_base64_decode()

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

Граф вызовов:

◆ mg_base64_encode()

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

Граф вызовов:

Граф вызова функции:

◆ mg_basic_auth_header()

void mg_basic_auth_header	(	const char *	user,
		const char *	pass,
		struct mbuf *	buf
	)

Граф вызовов:

Граф вызова функции:

◆ mg_bind()

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

Граф вызовов:

Граф вызова функции:

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

Граф вызовов:

Граф вызова функции:

◆ mg_casecmp()

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

Граф вызовов:

Граф вызова функции:

◆ mg_check_ip_acl()

int mg_check_ip_acl	(	const char *	acl,
		uint32_t	remote_ip
	)

Граф вызовов:

Граф вызова функции:

◆ mg_conn_addr_to_str()

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

Граф вызовов:

Граф вызова функции:

◆ mg_connect()

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

Граф вызовов:

Граф вызова функции:

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

Граф вызовов:

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

Граф вызовов:

Граф вызова функции:

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

Граф вызовов:

Граф вызова функции:

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

Граф вызовов:

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

Граф вызовов:

Граф вызова функции:

◆ mg_dns_copy_questions()

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

Граф вызовов:

Граф вызова функции:

◆ mg_dns_encode_name()

int mg_dns_encode_name	(	struct mbuf *	io,
		const char *	name,
		size_t	len
	)

Граф вызовов:

Граф вызова функции:

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

Граф вызовов:

Граф вызова функции:

◆ mg_dns_insert_header()

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

Граф вызовов:

Граф вызова функции:

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

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

Граф вызовов:

Граф вызова функции:

◆ mg_dns_uncompress_name()

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

Граф вызова функции:

◆ mg_find_iface()

struct mg_iface* mg_find_iface	(	struct mg_mgr *	mgr,
		struct mg_iface_vtable *	vtable,
		struct mg_iface *	from
	)

Граф вызовов:

Граф вызова функции:

◆ mg_get_http_basic_auth()

int mg_get_http_basic_auth	(	struct http_message *	hm,
		char *	user,
		size_t	user_len,
		char *	pass,
		size_t	pass_len
	)

Граф вызовов:

Граф вызова функции:

◆ mg_get_http_header()

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

Граф вызовов:

Граф вызова функции:

◆ mg_get_http_var()

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

Граф вызовов:

Граф вызова функции:

◆ mg_http_check_digest_auth()

int mg_http_check_digest_auth	(	struct http_message *	hm,
		const char *	auth_domain,
		FILE *	fp
	)

Граф вызова функции:

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

Граф вызова функции:

◆ mg_http_parse_header()

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

Граф вызова функции:

◆ mg_http_send_error()

void mg_http_send_error	(	struct mg_connection *	nc,
		int	code,
		const char *	reason
	)

Граф вызовов:

Граф вызова функции:

◆ mg_http_send_redirect()

void mg_http_send_redirect	(	struct mg_connection *	nc,
		int	status_code,
		const struct mg_str	location,
		const struct mg_str	extra_headers
	)

Граф вызовов:

◆ mg_if_accept_new_conn()

struct mg_connection* mg_if_accept_new_conn ( struct mg_connection * lc )

Граф вызовов:

Граф вызова функции:

◆ mg_if_accept_tcp_cb()

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

Граф вызовов:

Граф вызова функции:

◆ mg_if_connect_cb()

void mg_if_connect_cb	(	struct mg_connection *	nc,
		int	err
	)

Граф вызовов:

Граф вызова функции:

◆ mg_if_create_iface()

struct mg_iface* mg_if_create_iface	(	struct mg_iface_vtable *	vtable,
		struct mg_mgr *	mgr
	)

Граф вызова функции:

◆ mg_if_poll()

void mg_if_poll	(	struct mg_connection *	nc,
		time_t	now
	)

Граф вызовов:

Граф вызова функции:

◆ mg_if_recv_tcp_cb()

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

Граф вызовов:

Граф вызова функции:

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

Граф вызовов:

Граф вызова функции:

◆ mg_if_sent_cb()

void mg_if_sent_cb	(	struct mg_connection *	nc,
		int	num_sent
	)

Граф вызовов:

Граф вызова функции:

◆ mg_if_timer()

void mg_if_timer	(	struct mg_connection *	c,
		double	now
	)

Граф вызовов:

Граф вызова функции:

◆ mg_is_big_endian()

int mg_is_big_endian ( void )

◆ mg_match_prefix()

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

Граф вызовов:

Граф вызова функции:

◆ mg_match_prefix_n()

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

Граф вызовов:

Граф вызова функции:

◆ mg_mbuf_append_base64()

void mg_mbuf_append_base64	(	struct mbuf *	mbuf,
		const void *	data,
		size_t	len
	)

Граф вызовов:

◆ mg_mbuf_append_base64_putc()

void mg_mbuf_append_base64_putc	(	char	ch,
		void *	user_data
	)

Граф вызовов:

Граф вызова функции:

◆ mg_mgr_free()

void mg_mgr_free ( struct mg_mgr * )

Граф вызовов:

Граф вызова функции:

◆ mg_mgr_init()

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

Граф вызовов:

Граф вызова функции:

◆ mg_mgr_init_opt()

void mg_mgr_init_opt	(	struct mg_mgr *	mgr,
		void *	user_data,
		struct mg_mgr_init_opts	opts
	)

Граф вызовов:

Граф вызова функции:

◆ mg_mgr_poll()

time_t mg_mgr_poll	(	struct mg_mgr *	,
		int	milli
	)

Граф вызова функции:

◆ mg_mk_str()

struct mg_str mg_mk_str ( const char * s )

Граф вызова функции:

◆ mg_mk_str_n()

struct mg_str mg_mk_str_n	(	const char *	s,
		size_t	len
	)

Граф вызовов:

◆ mg_mqtt_connack()

void mg_mqtt_connack	(	struct mg_connection *	nc,
		uint8_t	return_code
	)

Граф вызовов:

Граф вызова функции:

◆ mg_mqtt_disconnect()

void mg_mqtt_disconnect ( struct mg_connection * nc )

Граф вызовов:

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

Граф вызова функции:

◆ mg_mqtt_ping()

void mg_mqtt_ping ( struct mg_connection * nc )

Граф вызовов:

◆ mg_mqtt_pong()

void mg_mqtt_pong ( struct mg_connection * nc )

Граф вызовов:

◆ mg_mqtt_puback()

void mg_mqtt_puback	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Граф вызовов:

◆ mg_mqtt_pubcomp()

void mg_mqtt_pubcomp	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Граф вызовов:

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

Граф вызовов:

Граф вызова функции:

◆ mg_mqtt_pubrec()

void mg_mqtt_pubrec	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Граф вызовов:

◆ mg_mqtt_pubrel()

void mg_mqtt_pubrel	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Граф вызовов:

◆ mg_mqtt_suback()

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

Граф вызовов:

Граф вызова функции:

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

Граф вызовов:

◆ mg_mqtt_unsuback()

void mg_mqtt_unsuback	(	struct mg_connection *	nc,
		uint16_t	message_id
	)

Граф вызовов:

◆ mg_mqtt_unsubscribe()

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

Граф вызовов:

◆ mg_ncasecmp()

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

Граф вызовов:

Граф вызова функции:

◆ mg_next()

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

Граф вызова функции:

◆ mg_next_comma_list_entry()

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

Граф вызова функции:

◆ mg_normalize_uri_path()

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

Граф вызовов:

Граф вызова функции:

◆ mg_parse_dns()

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

Граф вызовов:

Граф вызова функции:

◆ mg_parse_http()

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

Граф вызовов:

Граф вызова функции:

◆ mg_parse_http_basic_auth()

int mg_parse_http_basic_auth	(	struct mg_str *	hdr,
		char *	user,
		size_t	user_len,
		char *	pass,
		size_t	pass_len
	)

Граф вызовов:

Граф вызова функции:

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

Граф вызовов:

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

Граф вызовов:

◆ mg_printf()

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

Граф вызовов:

Граф вызова функции:

◆ mg_printf_html_escape()

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

Граф вызовов:

◆ mg_printf_http_chunk()

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

Граф вызовов:

Граф вызова функции:

◆ mg_printf_websocket_frame()

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

Граф вызовов:

◆ mg_register_http_endpoint()

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

Граф вызовов:

◆ mg_resolve_async()

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

Граф вызовов:

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

Граф вызовов:

Граф вызова функции:

◆ mg_resolve_from_hosts_file()

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

Граф вызова функции:

◆ mg_send()

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

Граф вызовов:

Граф вызова функции:

◆ mg_send_dns_query()

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

Граф вызовов:

Граф вызова функции:

◆ mg_send_head()

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

Граф вызовов:

Граф вызова функции:

◆ mg_send_http_chunk()

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

Граф вызовов:

Граф вызова функции:

◆ mg_send_mqtt_handshake()

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

Граф вызовов:

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

Граф вызовов:

Граф вызова функции:

◆ mg_send_response_line()

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

Граф вызовов:

Граф вызова функции:

◆ mg_send_websocket_frame()

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

Граф вызовов:

Граф вызова функции:

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

Граф вызовов:

Граф вызова функции:

◆ mg_send_websocket_handshake()

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

Граф вызовов:

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

Граф вызовов:

Граф вызова функции:

◆ mg_send_websocket_handshake3()

void mg_send_websocket_handshake3	(	struct mg_connection *	nc,
		const char *	path,
		const char *	host,
		const char *	protocol,
		const char *	extra_headers,
		const char *	user,
		const char *	pass
	)