#include "mongoose614.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <limits.h>
#include <stddef.h>
#include <sys/time.h>
#include <assert.h>
#include <ctype.h>
#include <stdlib.h>
#include <signal.h>
#include <reent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <inc/hw_types.h>
#include <inc/hw_memmap.h>
#include <driverlib/prcm.h>
#include <driverlib/rom.h>
#include <driverlib/rom_map.h>
#include <driverlib/uart.h>
#include <driverlib/utils.h>
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Clock.h>
#include <errno.h>
#include <oslib/osi.h>
#include <stdint.h>
#include <lwip/init.h>
#include <lwip/pbuf.h>
#include <lwip/tcp.h>
#include <lwip/tcpip.h>
#include <lwip/tcp_impl.h>
#include <lwip/udp.h>

Include dependency graph for mongoose614.cxx:

Classes
struct	ctl_msg

union	char64long16

struct	mg_q_msg

struct	mg_lwip_conn_state

struct	mg_lwip_if_connect_tcp_ctx

struct	mg_lwip_if_listen_ctx

struct	mg_lwip_tcp_write_ctx

struct	udp_sendto_ctx

struct	tcp_recved_ctx

struct	mg_ev_mgr_lwip_signal

struct	mg_ev_mgr_lwip_data

Macros
#define	CS_MONGOOSE_SRC_INTERNAL_H_

#define	MBUF_REALLOC MG_REALLOC

#define	MBUF_FREE MG_FREE

#define	MG_SET_PTRPTR(_ptr, _v)

#define	MG_INTERNAL static

#define	MG_CTL_MSG_MESSAGE_SIZE 8192

#define	MIN(a, b) ((a) < (b) ? (a) : (b))

#define	CS_COMMON_MG_MEM_H_

#define	MG_MALLOC malloc

#define	MG_CALLOC calloc

#define	MG_REALLOC realloc

#define	MG_FREE free

#define	NUM_UPPERCASES ('Z' - 'A' + 1)

#define	NUM_LETTERS (NUM_UPPERCASES * 2)

#define	NUM_DIGITS ('9' - '0' + 1)

#define	BASE64_ENCODE_BODY

#define	BASE64_OUT(ch)

#define	BASE64_FLUSH()

#define	CS_COMMON_CS_DBG_H_

#define	CS_ENABLE_DEBUG 0

#define	CS_LOG_PREFIX_LEN 24

#define	CS_LOG_ENABLE_TS_DIFF 0

#define	LOG(l, x)

#define	DBG(x)

#define	CS_COMMON_CS_DIRENT_H_

#define	CS_COMMON_CS_ENDIAN_H_

#define	F1(x, y, z) (z ^ (x & (y ^ z)))

#define	F2(x, y, z) F1(z, x, y)

#define	F3(x, y, z) (x ^ y ^ z)

#define	F4(x, y, z) (y ^ (x \| ~z))

#define	MD5STEP(f, w, x, y, z, data, s) (w += f(x, y, z) + data, w = w << s \| w >> (32 - s), w += x)

#define	SHA1HANDSOFF

#define	rol(value, bits) (((value) << (bits)) \| ((value) >> (32 - (bits))))

#define	blk(i)

#define	R0(v, w, x, y, z, i)

#define	R1(v, w, x, y, z, i)

#define	R2(v, w, x, y, z, i)

#define	R3(v, w, x, y, z, i)

#define	R4(v, w, x, y, z, i)

#define	C_DISABLE_BUILTIN_SNPRINTF 0

#define	C_SNPRINTF_APPEND_CHAR(ch)

#define	C_SNPRINTF_FLAG_ZERO 1

#define	MG_MAX_HOST_LEN 200

#define	MG_TCP_IO_SIZE 1460

#define	MG_UDP_IO_SIZE 1460

#define	MG_COPY_COMMON_CONNECTION_OPTIONS(dst, src) memcpy(dst, src, sizeof(*dst));

#define	_MG_ALLOWED_CONNECT_FLAGS_MASK

#define	_MG_CALLBACK_MODIFIABLE_FLAGS_MASK

#define	intptr_t long

#define	CS_MONGOOSE_SRC_NET_IF_SOCKET_H_

#define	MG_ENABLE_NET_IF_SOCKET MG_NET_IF == MG_NET_IF_SOCKET

#define	CS_MONGOOSE_SRC_NET_IF_SOCKS_H_

#define	MG_NULL_IFACE_VTABLE

#define	_MG_F_FD_CAN_READ 1

#define	_MG_F_FD_CAN_WRITE 1 << 1

#define	_MG_F_FD_ERROR 1 << 2

#define	MG_SOCKET_IFACE_VTABLE

#define	MAX(a, b) ((a) > (b) ? (a) : (b))

#define	CONSOLE_UART UARTA0_BASE

#define	CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_

#define	CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_

#define	MG_ENABLE_NET_IF_SIMPLELINK MG_NET_IF == MG_NET_IF_SIMPLELINK

#define	MG_TCP_RECV_BUFFER_SIZE 1024

#define	MG_UDP_RECV_BUFFER_SIZE 1500

#define	_MG_F_FD_CAN_READ 1

#define	_MG_F_FD_CAN_WRITE 1 << 1

#define	_MG_F_FD_ERROR 1 << 2

#define	MG_SL_IFACE_VTABLE

#define	CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_

#define	MG_ENABLE_NET_IF_LWIP_LOW_LEVEL MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL

#define	ip_2_ip4(addr) (addr)

#define	TCP_NEW tcp_new

#define	TCP_BIND tcp_bind

#define	UDP_BIND udp_bind

#define	IPADDR_NTOA ipaddr_ntoa

#define	SET_ADDR(dst, src) (dst)->sin.sin_addr.s_addr = ip_2_ip4(src)->addr

#define	mgos_lock()

#define	mgos_unlock()

#define	MG_LWIP_IFACE_VTABLE

#define	MG_SIG_QUEUE_LEN 32

#define	CS_COMMON_PLATFORMS_PIC32_NET_IF_H_

#define	MG_ENABLE_NET_IF_PIC32 MG_NET_IF == MG_NET_IF_PIC32

#define	MG_PIC32_IFACE_VTABLE

Typedefs
typedef int	cs_dirent_dummy

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	mg_q_msg_type { MG_Q_MSG_CB }

enum	mg_sig_type { MG_SIG_CONNECT_RESULT = 1 , MG_SIG_RECV = 2 , MG_SIG_CLOSE_CONN = 3 , MG_SIG_TOMBSTONE = 4 , MG_SIG_ACCEPT = 5 }

Functions
MG_INTERNAL struct mg_connection *	mg_do_connect (struct mg_connection nc, int proto, union socket_address sa)

MG_INTERNAL int	mg_parse_address (const char str, union socket_address sa, int proto, char host, size_t host_len)

MG_INTERNAL void	mg_call (struct mg_connection nc, mg_event_handler_t ev_handler, void user_data, int ev, void *ev_data)

void	mg_forward (struct mg_connection from, struct mg_connection to)

MG_INTERNAL void	mg_add_conn (struct mg_mgr mgr, struct mg_connection c)

MG_INTERNAL void	mg_remove_conn (struct mg_connection *c)

MG_INTERNAL struct mg_connection *	mg_create_connection (struct mg_mgr *mgr, mg_event_handler_t callback, struct mg_add_sock_opts opts)

MG_INTERNAL int	mg_get_errno (void)

MG_INTERNAL void	mg_close_conn (struct mg_connection *conn)

static void	cs_base64_emit_code (struct cs_base64_ctx *ctx, int v)

static void	cs_base64_emit_chunk (struct cs_base64_ctx *ctx)

void	cs_base64_init (struct cs_base64_ctx ctx, cs_base64_putc_t b64_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)

static unsigned char	from_b64 (unsigned char ch)

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

void	cs_log_set_level (enum cs_log_level level)

void	cs_log_set_file_level (const char *file_level)

int	cs_log_print_prefix (enum cs_log_level level, const char *fname, int line)

double	cs_time (void) WEAK

double	cs_timegm (const struct tm *tm)

static void	byteReverse (unsigned char *buf, unsigned longs)

void	cs_md5_init (cs_md5_ctx *ctx)

static void	cs_md5_transform (uint32_t buf[4], uint32_t const in[16])

void	cs_md5_update (cs_md5_ctx ctx, const unsigned char buf, size_t len)

void	cs_md5_final (unsigned char digest[16], cs_md5_ctx *ctx)

static uint32_t	blk0 (union char64long16 *block, int i)

void	cs_sha1_transform (uint32_t state[5], const unsigned char buffer[64])

void	cs_sha1_init (cs_sha1_ctx *context)

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

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

void	cs_hmac_sha1 (const unsigned char key, size_t keylen, const unsigned char data, size_t datalen, unsigned char out[20])

void	mbuf_init (struct mbuf *mbuf, size_t initial_size) WEAK

void	mbuf_free (struct mbuf *mbuf) WEAK

void	mbuf_resize (struct mbuf *a, size_t new_size) WEAK

void	mbuf_trim (struct mbuf *mbuf) WEAK

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

size_t	mbuf_append (struct mbuf a, const void buf, size_t len) WEAK

size_t	mbuf_append_and_free (struct mbuf a, void buf, size_t len) WEAK

void	mbuf_remove (struct mbuf *mb, size_t n) WEAK

void	mbuf_clear (struct mbuf *mb) WEAK

void	mbuf_move (struct mbuf from, struct mbuf to) WEAK

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

struct mg_str	mg_mk_str (const char *s) WEAK

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

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

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

static struct mg_str	mg_strdup_common (const struct mg_str s, int nul_terminate)

struct mg_str	mg_strdup (const struct mg_str s) WEAK

struct mg_str	mg_strdup_nul (const struct mg_str s) WEAK

const char *	mg_strchr (const struct mg_str s, int c) WEAK

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

int	mg_strncmp (const struct mg_str, const struct mg_str, size_t n) WEAK

void	mg_strfree (struct mg_str *s) WEAK

const char *	mg_strstr (const struct mg_str haystack, const struct mg_str needle) WEAK

struct mg_str	mg_strstrip (struct mg_str s) WEAK

int	mg_str_starts_with (struct mg_str s, struct mg_str prefix) WEAK

size_t	c_strnlen (const char *s, size_t maxlen) WEAK

static int	c_itoa (char *buf, size_t buf_size, int64_t num, int base, int flags, int field_width)

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

int	c_snprintf (char buf, size_t buf_size, const char fmt,...) WEAK

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

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

static int	fourbit (int ch)

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

static int	str_util_lowercase (const char *s)

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

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

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

const char *	mg_next_comma_list_entry (const char , struct mg_str , struct mg_str *) WEAK

struct mg_str	mg_next_comma_list_entry_n (struct mg_str list, struct mg_str val, struct mg_str eq_val) WEAK

size_t	mg_match_prefix_n (const struct mg_str, const struct mg_str) WEAK

size_t	mg_match_prefix (const char , int, const char ) WEAK

MG_INTERNAL void	mg_timer (struct mg_connection *c, double now)

MG_INTERNAL size_t	recv_avail_size (struct mg_connection *conn, size_t max)

static int	mg_do_recv (struct mg_connection *nc)

int	mg_if_poll (struct mg_connection *nc, double now)

void	mg_destroy_conn (struct mg_connection *conn, int destroy_if)

void	mg_mgr_init (struct mg_mgr m, void user_data)

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

void	mg_mgr_free (struct mg_mgr *m)

int	mg_mgr_poll (struct mg_mgr *m, int timeout_ms)

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

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

MG_INTERNAL struct mg_connection *	mg_create_connection_base (struct mg_mgr *mgr, mg_event_handler_t callback, struct mg_add_sock_opts opts)

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_send (struct mg_connection nc, const void buf, int len)

static int	mg_recv_tcp (struct mg_connection nc, char buf, size_t len)

static int	mg_recv_udp (struct mg_connection nc, char buf, size_t len)

void	mg_if_can_recv_cb (struct mg_connection *nc)

void	mg_if_can_send_cb (struct mg_connection *nc)

void	mg_if_connect_cb (struct mg_connection *nc, int err)

struct mg_connection *	mg_connect (struct mg_mgr mgr, const char address, MG_CB(mg_event_handler_t callback, void *user_data))

struct mg_connection *	mg_connect_opt (struct mg_mgr mgr, const char address, MG_CB(mg_event_handler_t callback, void *user_data), struct mg_connect_opts opts)

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

struct mg_connection *	mg_bind_opt (struct mg_mgr mgr, const char address, MG_CB(mg_event_handler_t callback, void *user_data), struct mg_bind_opts opts)

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

static int	isbyte (int n)

static int	parse_net (const char spec, uint32_t net, uint32_t *mask)

int	mg_check_ip_acl (const char *acl, uint32_t remote_ip)

double	mg_set_timer (struct mg_connection *c, double timestamp)

void	mg_sock_set (struct mg_connection *nc, sock_t sock)

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

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

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

double	mg_time (void)

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

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

double	mg_mgr_min_timer (const struct mg_mgr *mgr)

static void	mg_null_if_connect_tcp (struct mg_connection c, const union socket_address sa)

static void	mg_null_if_connect_udp (struct mg_connection *c)

static int	mg_null_if_listen_tcp (struct mg_connection c, union socket_address sa)

static int	mg_null_if_listen_udp (struct mg_connection c, union socket_address sa)

static int	mg_null_if_tcp_send (struct mg_connection c, const void buf, size_t len)

static int	mg_null_if_udp_send (struct mg_connection c, const void buf, size_t len)

int	mg_null_if_tcp_recv (struct mg_connection c, void buf, size_t len)

int	mg_null_if_udp_recv (struct mg_connection c, void buf, size_t len, union socket_address sa, size_t sa_len)

static int	mg_null_if_create_conn (struct mg_connection *c)

static void	mg_null_if_destroy_conn (struct mg_connection *c)

static void	mg_null_if_sock_set (struct mg_connection *c, sock_t sock)

static void	mg_null_if_init (struct mg_iface *iface)

static void	mg_null_if_free (struct mg_iface *iface)

static void	mg_null_if_add_conn (struct mg_connection *c)

static void	mg_null_if_remove_conn (struct mg_connection *c)

static time_t	mg_null_if_poll (struct mg_iface *iface, int timeout_ms)

static void	mg_null_if_get_conn_addr (struct mg_connection c, int remote, union socket_address sa)

static sock_t	mg_open_listening_socket (union socket_address *sa, int type, int proto)

void	mg_set_non_blocking_mode (sock_t sock)

static int	mg_is_error (void)

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

void	mg_socket_if_connect_udp (struct mg_connection *nc)

int	mg_socket_if_listen_tcp (struct mg_connection nc, union socket_address sa)

static int	mg_socket_if_listen_udp (struct mg_connection nc, union socket_address sa)

static int	mg_socket_if_tcp_send (struct mg_connection nc, const void buf, size_t len)

static int	mg_socket_if_udp_send (struct mg_connection nc, const void buf, size_t len)

static int	mg_socket_if_tcp_recv (struct mg_connection nc, void buf, size_t len)

static int	mg_socket_if_udp_recv (struct mg_connection nc, void buf, size_t len, union socket_address sa, size_t sa_len)

int	mg_socket_if_create_conn (struct mg_connection *nc)

void	mg_socket_if_destroy_conn (struct mg_connection *nc)

static int	mg_accept_conn (struct mg_connection *lc)

void	mg_mgr_handle_conn (struct mg_connection *nc, int fd_flags, double now)

void	mg_socket_if_sock_set (struct mg_connection *nc, sock_t sock)

void	mg_socket_if_init (struct mg_iface *iface)

void	mg_socket_if_free (struct mg_iface *iface)

void	mg_socket_if_add_conn (struct mg_connection *nc)

void	mg_socket_if_remove_conn (struct mg_connection *nc)

void	mg_add_to_set (sock_t sock, fd_set set, sock_t max_fd)

time_t	mg_socket_if_poll (struct mg_iface *iface, int timeout_ms)

static void	mg_sock_get_addr (sock_t sock, int remote, union socket_address *sa)

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

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

static void	parse_uri_component (const char *p, const char end, const char seps, struct mg_str res)

int	mg_parse_uri (const 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)

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

const char *	mg_skip (const char s, const char end, const char delims, struct mg_str v)

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

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

void	mg_set_close_on_exec (sock_t sock)

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

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

int	mg_is_big_endian (void)

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 struct mg_str user, const struct mg_str pass, struct mbuf *buf)

struct mg_str	mg_url_encode_opt (const struct mg_str src, const struct mg_str safe, unsigned int flags)

struct mg_str	mg_url_encode (const struct mg_str src)

void	fprint_str (FILE fp, const char str)

void	_exit (int status)

void	_not_implemented (const char *what)

int	_kill (int pid, int sig)

int	_getpid ()

int	_isatty (int fd)

int	gettimeofday (struct timeval tp, void tzp)

const char *	inet_ntop (int af, const void src, char dst, socklen_t size)

char *	inet_ntoa (struct in_addr n)

int	inet_pton (int af, const char src, void dst)

static void	mg_task (void *arg)

bool	mg_start_task (int priority, int stack_size, mg_init_cb mg_init)

void	mg_run_in_task (void(cb)(struct mg_mgr mgr, void arg), void cb_arg)

static sock_t	mg_open_listening_socket (struct mg_connection nc, union socket_address sa, int type, int proto)

static int	mg_is_error (int n)

static void	mg_sl_if_connect_tcp (struct mg_connection nc, const union socket_address sa)

static void	mg_sl_if_connect_udp (struct mg_connection *nc)

static int	mg_sl_if_listen_tcp (struct mg_connection nc, union socket_address sa)

static int	mg_sl_if_listen_udp (struct mg_connection nc, union socket_address sa)

static int	mg_sl_if_tcp_send (struct mg_connection nc, const void buf, size_t len)

static int	mg_sl_if_udp_send (struct mg_connection nc, const void buf, size_t len)

static int	mg_sl_if_tcp_recv (struct mg_connection nc, void buf, size_t len)

static int	mg_sl_if_udp_recv (struct mg_connection nc, void buf, size_t len, union socket_address sa, size_t sa_len)

static int	mg_sl_if_create_conn (struct mg_connection *nc)

void	mg_sl_if_destroy_conn (struct mg_connection *nc)

void	mg_sl_if_sock_set (struct mg_connection *nc, sock_t sock)

void	mg_sl_if_init (struct mg_iface *iface)

void	mg_sl_if_free (struct mg_iface *iface)

void	mg_sl_if_add_conn (struct mg_connection *nc)

void	mg_sl_if_remove_conn (struct mg_connection *nc)

time_t	mg_sl_if_poll (struct mg_iface *iface, int timeout_ms)

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

void	sl_restart_cb (struct mg_mgr *mgr)

void	mg_lwip_post_signal (enum mg_sig_type sig, struct mg_connection *nc)

void	mg_lwip_mgr_schedule_poll (struct mg_mgr *mgr)

void	mg_lwip_if_init (struct mg_iface *iface)

void	mg_lwip_if_free (struct mg_iface *iface)

void	mg_lwip_if_add_conn (struct mg_connection *nc)

void	mg_lwip_if_remove_conn (struct mg_connection *nc)

time_t	mg_lwip_if_poll (struct mg_iface *iface, int timeout_ms)

static void	mg_lwip_recv_common (struct mg_connection nc, struct pbuf p)

static err_t	mg_lwip_tcp_conn_cb (void arg, struct tcp_pcb tpcb, err_t err)

static void	mg_lwip_tcp_error_cb (void *arg, err_t err)

static err_t	mg_lwip_tcp_recv_cb (void arg, struct tcp_pcb tpcb, struct pbuf *p, err_t err)

static err_t	mg_lwip_tcp_sent_cb (void arg, struct tcp_pcb tpcb, u16_t num_sent)

static void	mg_lwip_if_connect_tcp_tcpip (void *arg)

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

static void	mg_lwip_udp_recv_cb (void arg, struct udp_pcb pcb, struct pbuf p, ip_addr_t addr, u16_t port)

static int	mg_lwip_if_udp_recv (struct mg_connection nc, void buf, size_t len, union socket_address sa, size_t sa_len)

static void	mg_lwip_if_connect_udp_tcpip (void *arg)

void	mg_lwip_if_connect_udp (struct mg_connection *nc)

static void	tcp_close_tcpip (void *arg)

void	mg_lwip_handle_accept (struct mg_connection *nc)

static err_t	mg_lwip_accept_cb (void arg, struct tcp_pcb newtpcb, err_t err)

static void	mg_lwip_if_listen_tcp_tcpip (void *arg)

int	mg_lwip_if_listen_tcp (struct mg_connection nc, union socket_address sa)

static void	mg_lwip_if_listen_udp_tcpip (void *arg)

int	mg_lwip_if_listen_udp (struct mg_connection nc, union socket_address sa)

static void	tcp_output_tcpip (void *arg)

static void	mg_lwip_tcp_write_tcpip (void *arg)

int	mg_lwip_if_tcp_send (struct mg_connection nc, const void buf, size_t len)

static void	udp_sendto_tcpip (void *arg)

static int	mg_lwip_if_udp_send (struct mg_connection nc, const void data, size_t len)

static int	mg_lwip_if_can_send (struct mg_connection nc, struct mg_lwip_conn_state cs)

void	tcp_recved_tcpip (void *arg)

static int	mg_lwip_if_tcp_recv (struct mg_connection nc, void buf, size_t len)

int	mg_lwip_if_create_conn (struct mg_connection *nc)

static void	udp_remove_tcpip (void *arg)

void	mg_lwip_if_destroy_conn (struct mg_connection *nc)

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

void	mg_lwip_if_sock_set (struct mg_connection *nc, sock_t sock)

void	mg_ev_mgr_lwip_process_signals (struct mg_mgr *mgr)

int	mg_pic32_if_create_conn (struct mg_connection *nc)

void	mg_pic32_if_recved (struct mg_connection *nc, size_t len)

void	mg_pic32_if_add_conn (struct mg_connection *nc)

void	mg_pic32_if_init (struct mg_iface *iface)

void	mg_pic32_if_free (struct mg_iface *iface)

void	mg_pic32_if_remove_conn (struct mg_connection *nc)

void	mg_pic32_if_destroy_conn (struct mg_connection *nc)

int	mg_pic32_if_listen_udp (struct mg_connection nc, union socket_address sa)

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

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

int	mg_pic32_if_listen_tcp (struct mg_connection nc, union socket_address sa)

static void	mg_handle_send (struct mg_connection *nc)

static void	mg_handle_recv (struct mg_connection *nc)

time_t	mg_pic32_if_poll (struct mg_iface *iface, int timeout_ms)

void	mg_pic32_if_sock_set (struct mg_connection *nc, sock_t sock)

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

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

void	mg_pic32_if_connect_udp (struct mg_connection *nc)

Variables
void (	test_malloc )(size_t size)

void (	test_calloc )(size_t count, size_t size)

enum cs_log_level	cs_log_level

enum cs_log_level cs_log_level	WEAK

const struct mg_iface_vtable	mg_socket_iface_vtable = MG_SOCKET_IFACE_VTABLE

const struct mg_iface_vtable	mg_default_iface_vtable = MG_NULL_IFACE_VTABLE

const struct mg_iface_vtable *	mg_ifaces []

int	mg_num_ifaces = (int) (sizeof(mg_ifaces) / sizeof(mg_ifaces[0]))

const struct mg_iface_vtable	mg_null_iface_vtable = MG_NULL_IFACE_VTABLE

static OsiMsgQ_t	s_mg_q

const struct mg_iface_vtable	mg_simplelink_iface_vtable = MG_SL_IFACE_VTABLE

const struct mg_iface_vtable	mg_lwip_iface_vtable = MG_LWIP_IFACE_VTABLE

const struct mg_iface_vtable	mg_pic32_iface_vtable = MG_PIC32_IFACE_VTABLE

Macro Definition Documentation

◆ _MG_ALLOWED_CONNECT_FLAGS_MASK

#define _MG_ALLOWED_CONNECT_FLAGS_MASK

Value:

MG_F_USER_6 | MG_F_WEBSOCKET_NO_DEFRAG | MG_F_ENABLE_BROADCAST)

MG_F_USER_6

#define MG_F_USER_6

Definition mongoose6.h:1298

MG_F_USER_2

#define MG_F_USER_2

Definition mongoose6.h:1294

MG_F_USER_4

#define MG_F_USER_4

Definition mongoose6.h:1296

MG_F_WEBSOCKET_NO_DEFRAG

#define MG_F_WEBSOCKET_NO_DEFRAG

Definition mongoose6.h:1290

MG_F_USER_1

#define MG_F_USER_1

Definition mongoose6.h:1293

MG_F_USER_5

#define MG_F_USER_5

Definition mongoose6.h:1297

MG_F_USER_3

#define MG_F_USER_3

Definition mongoose6.h:1295

MG_F_ENABLE_BROADCAST

#define MG_F_ENABLE_BROADCAST

Definition mongoose614.h:3966

Definition at line 2402 of file mongoose614.cxx.

◆ _MG_CALLBACK_MODIFIABLE_FLAGS_MASK

#define _MG_CALLBACK_MODIFIABLE_FLAGS_MASK

Value:

  (MG_F_USER_1 | MG_F_USER_2 | MG_F_USER_3 | MG_F_USER_4 | MG_F_USER_5 | \
   MG_F_USER_6 | MG_F_WEBSOCKET_NO_DEFRAG | MG_F_SEND_AND_CLOSE |        \
   MG_F_CLOSE_IMMEDIATELY | MG_F_IS_WEBSOCKET | MG_F_DELETE_CHUNK)

Definition at line 2406 of file mongoose614.cxx.

◆ _MG_F_FD_CAN_READ [1/2]

#define _MG_F_FD_CAN_READ 1

Definition at line 4034 of file mongoose614.cxx.

◆ _MG_F_FD_CAN_READ [2/2]

#define _MG_F_FD_CAN_READ 1

Definition at line 4034 of file mongoose614.cxx.

◆ _MG_F_FD_CAN_WRITE [1/2]

#define _MG_F_FD_CAN_WRITE 1 << 1

Definition at line 4035 of file mongoose614.cxx.

◆ _MG_F_FD_CAN_WRITE [2/2]

#define _MG_F_FD_CAN_WRITE 1 << 1

Definition at line 4035 of file mongoose614.cxx.

◆ _MG_F_FD_ERROR [1/2]

#define _MG_F_FD_ERROR 1 << 2

Definition at line 4036 of file mongoose614.cxx.

◆ _MG_F_FD_ERROR [2/2]

#define _MG_F_FD_ERROR 1 << 2

Definition at line 4036 of file mongoose614.cxx.

◆ BASE64_ENCODE_BODY

#define BASE64_ENCODE_BODY

Value:

  static const char *b64 =                                                \
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; \
  int i, j, a, b, c;                                                      \
                                                                          \
  for (i = j = 0; i < src_len; i += 3) {                                  \
    a = src[i];                                                           \
    b = i + 1 >= src_len ? 0 : src[i + 1];                                \
    c = i + 2 >= src_len ? 0 : src[i + 2];                                \
                                                                          \
    BASE64_OUT(b64[a >> 2]);                                              \
    BASE64_OUT(b64[((a & 3) << 4) | (b >> 4)]);                           \
    if (i + 1 < src_len) {                                                \
      BASE64_OUT(b64[(b & 15) << 2 | (c >> 6)]);                          \
    }                                                                     \
    if (i + 2 < src_len) {                                                \
      BASE64_OUT(b64[c & 63]);                                            \
    }                                                                     \
  }                                                                       \
                                                                          \
  while (j % 4 != 0) {                                                    \
    BASE64_OUT('=');                                                      \
  }                                                                       \
  BASE64_FLUSH()

Definition at line 311 of file mongoose614.cxx.

                                       {                                  \
    a = src[i];                                                           \
    b = i + 1 >= src_len ? 0 : src[i + 1];                                \
    c = i + 2 >= src_len ? 0 : src[i + 2];                                \
                                                                          \
    BASE64_OUT(b64[a >> 2]);                                              \
    BASE64_OUT(b64[((a & 3) << 4) | (b >> 4)]);                           \
    if (i + 1 < src_len) {                                                \
      BASE64_OUT(b64[(b & 15) << 2 | (c >> 6)]);                          \
    }                                                                     \
    if (i + 2 < src_len) {                                                \
      BASE64_OUT(b64[c & 63]);                                            \
    }                                                                     \
  }                                                                       \
                                                                          \
  while (j % 4 != 0) {                                                    \
    BASE64_OUT('=');                                                      \
  }                                                                       \
  BASE64_FLUSH()

◆ BASE64_FLUSH

#define BASE64_FLUSH ( )

Value:

  do {                 \
    dst[j++] = '\0';   \
  } while (0)

Definition at line 341 of file mongoose614.cxx.

     {                 \
    dst[j++] = '\0';   \
  } while (0)

◆ BASE64_OUT

#define BASE64_OUT ( ch )

Value:

  do {                 \
    dst[j++] = (ch);   \
  } while (0)

Definition at line 336 of file mongoose614.cxx.

     {                 \
    dst[j++] = (ch);   \
  } while (0)

◆ blk

#define blk ( i )

Value:

  (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \
                              block->l[(i + 2) & 15] ^ block->l[i & 15],     \
                          1))

Definition at line 1294 of file mongoose614.cxx.

◆ C_DISABLE_BUILTIN_SNPRINTF

#define C_DISABLE_BUILTIN_SNPRINTF 0

Definition at line 1854 of file mongoose614.cxx.

◆ C_SNPRINTF_APPEND_CHAR

#define C_SNPRINTF_APPEND_CHAR ( ch )

Value:

  do {                                   \
    if (i < (int) buf_size) buf[i] = ch; \
    i++;                                 \
  } while (0)

Definition at line 1867 of file mongoose614.cxx.

     {                                   \
    if (i < (int) buf_size) buf[i] = ch; \
    i++;                                 \
  } while (0)

◆ C_SNPRINTF_FLAG_ZERO

#define C_SNPRINTF_FLAG_ZERO 1

Definition at line 1873 of file mongoose614.cxx.

◆ CONSOLE_UART

#define CONSOLE_UART UARTA0_BASE

Definition at line 13352 of file mongoose614.cxx.

◆ CS_COMMON_CS_DBG_H_

#define CS_COMMON_CS_DBG_H_

Definition at line 453 of file mongoose614.cxx.

◆ CS_COMMON_CS_DIRENT_H_

#define CS_COMMON_CS_DIRENT_H_

Definition at line 750 of file mongoose614.cxx.

◆ CS_COMMON_CS_ENDIAN_H_

#define CS_COMMON_CS_ENDIAN_H_

Definition at line 1013 of file mongoose614.cxx.

◆ CS_COMMON_MG_MEM_H_

#define CS_COMMON_MG_MEM_H_

Definition at line 185 of file mongoose614.cxx.

◆ CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_

#define CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_

Definition at line 15141 of file mongoose614.cxx.

◆ CS_COMMON_PLATFORMS_PIC32_NET_IF_H_

#define CS_COMMON_PLATFORMS_PIC32_NET_IF_H_

Definition at line 16191 of file mongoose614.cxx.

◆ CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_

#define CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_

Definition at line 13512 of file mongoose614.cxx.

◆ CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_

#define CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_

Definition at line 14412 of file mongoose614.cxx.

◆ CS_ENABLE_DEBUG

#define CS_ENABLE_DEBUG 0

Definition at line 462 of file mongoose614.cxx.

◆ CS_LOG_ENABLE_TS_DIFF

#define CS_LOG_ENABLE_TS_DIFF 0

Definition at line 470 of file mongoose614.cxx.

◆ CS_LOG_PREFIX_LEN

#define CS_LOG_PREFIX_LEN 24

Definition at line 466 of file mongoose614.cxx.

◆ CS_MONGOOSE_SRC_INTERNAL_H_

#define CS_MONGOOSE_SRC_INTERNAL_H_

Definition at line 11 of file mongoose614.cxx.

◆ CS_MONGOOSE_SRC_NET_IF_SOCKET_H_

#define CS_MONGOOSE_SRC_NET_IF_SOCKET_H_

Definition at line 3575 of file mongoose614.cxx.

◆ CS_MONGOOSE_SRC_NET_IF_SOCKS_H_

#define CS_MONGOOSE_SRC_NET_IF_SOCKS_H_

Definition at line 3603 of file mongoose614.cxx.

◆ DBG

#define DBG ( x )

Definition at line 574 of file mongoose614.cxx.

◆ F1

#define F1	(	x,
		y,
		z
	)	(z ^ (x & (y ^ z)))

Definition at line 1082 of file mongoose614.cxx.

◆ F2

#define F2	(	x,
		y,
		z
	)	F1(z, x, y)

Definition at line 1083 of file mongoose614.cxx.

◆ F3

#define F3	(	x,
		y,
		z
	)	(x ^ y ^ z)

Definition at line 1084 of file mongoose614.cxx.

◆ F4

#define F4	(	x,
		y,
		z
	)	(y ^ (x \| ~z))

Definition at line 1085 of file mongoose614.cxx.

◆ intptr_t

#define intptr_t long

Definition at line 2412 of file mongoose614.cxx.

◆ ip_2_ip4

#define ip_2_ip4 ( addr ) (addr)

Definition at line 15233 of file mongoose614.cxx.

◆ IPADDR_NTOA

#define IPADDR_NTOA ipaddr_ntoa

Definition at line 15253 of file mongoose614.cxx.

◆ LOG

#define LOG	(	l,
		x
	)

Definition at line 573 of file mongoose614.cxx.

◆ MAX

#define MAX	(	a,
		b
	)	((a) > (b) ? (a) : (b))

Definition at line 10465 of file mongoose614.cxx.

◆ MBUF_FREE

#define MBUF_FREE MG_FREE

Definition at line 20 of file mongoose614.cxx.

◆ MBUF_REALLOC

#define MBUF_REALLOC MG_REALLOC

Definition at line 16 of file mongoose614.cxx.

◆ MD5STEP

#define MD5STEP	(	f,
		w,
		x,
		y,
		z,
		data,
		s
	)	(w += f(x, y, z) + data, w = w << s \| w >> (32 - s), w += x)

Definition at line 1087 of file mongoose614.cxx.

◆ MG_CALLOC

#define MG_CALLOC calloc

Definition at line 196 of file mongoose614.cxx.

◆ MG_COPY_COMMON_CONNECTION_OPTIONS

#define MG_COPY_COMMON_CONNECTION_OPTIONS	(	dst,
		src
	)	memcpy(dst, src, sizeof(*dst));

Definition at line 2398 of file mongoose614.cxx.

◆ MG_CTL_MSG_MESSAGE_SIZE

#define MG_CTL_MSG_MESSAGE_SIZE 8192

Definition at line 42 of file mongoose614.cxx.

◆ MG_ENABLE_NET_IF_LWIP_LOW_LEVEL

#define MG_ENABLE_NET_IF_LWIP_LOW_LEVEL MG_NET_IF == MG_NET_IF_LWIP_LOW_LEVEL

Definition at line 15144 of file mongoose614.cxx.

◆ MG_ENABLE_NET_IF_PIC32

#define MG_ENABLE_NET_IF_PIC32 MG_NET_IF == MG_NET_IF_PIC32

Definition at line 16200 of file mongoose614.cxx.

◆ MG_ENABLE_NET_IF_SIMPLELINK

#define MG_ENABLE_NET_IF_SIMPLELINK MG_NET_IF == MG_NET_IF_SIMPLELINK

Definition at line 14421 of file mongoose614.cxx.

◆ MG_ENABLE_NET_IF_SOCKET

#define MG_ENABLE_NET_IF_SOCKET MG_NET_IF == MG_NET_IF_SOCKET

Definition at line 3584 of file mongoose614.cxx.

◆ MG_FREE

#define MG_FREE free

Definition at line 204 of file mongoose614.cxx.

◆ MG_INTERNAL

#define MG_INTERNAL static

Definition at line 29 of file mongoose614.cxx.

◆ MG_LWIP_IFACE_VTABLE

#define MG_LWIP_IFACE_VTABLE

Value:

  {                                                                   \
    mg_lwip_if_init,                                                  \
    mg_lwip_if_free,                                                  \
    mg_lwip_if_add_conn,                                              \
    mg_lwip_if_remove_conn,                                           \
    mg_lwip_if_poll,                                                  \
    mg_lwip_if_listen_tcp,                                            \
    mg_lwip_if_listen_udp,                                            \
    mg_lwip_if_connect_tcp,                                           \
    mg_lwip_if_connect_udp,                                           \
    mg_lwip_if_tcp_send,                                              \
    mg_lwip_if_udp_send,                                              \
    mg_lwip_if_tcp_recv,                                              \
    mg_lwip_if_udp_recv,                                              \
    mg_lwip_if_create_conn,                                           \
    mg_lwip_if_destroy_conn,                                          \
    mg_lwip_if_sock_set,                                              \
    mg_lwip_if_get_conn_addr,                                         \
  }

Definition at line 15881 of file mongoose614.cxx.

  {                                                                   \
    mg_lwip_if_init,                                                  \
    mg_lwip_if_free,                                                  \
    mg_lwip_if_add_conn,                                              \
    mg_lwip_if_remove_conn,                                           \
    mg_lwip_if_poll,                                                  \
    mg_lwip_if_listen_tcp,                                            \
    mg_lwip_if_listen_udp,                                            \
    mg_lwip_if_connect_tcp,                                           \
    mg_lwip_if_connect_udp,                                           \
    mg_lwip_if_tcp_send,                                              \
    mg_lwip_if_udp_send,                                              \
    mg_lwip_if_tcp_recv,                                              \
    mg_lwip_if_udp_recv,                                              \
    mg_lwip_if_create_conn,                                           \
    mg_lwip_if_destroy_conn,                                          \
    mg_lwip_if_sock_set,                                              \
    mg_lwip_if_get_conn_addr,                                         \
  }

◆ MG_MALLOC

#define MG_MALLOC malloc

Definition at line 192 of file mongoose614.cxx.

◆ MG_MAX_HOST_LEN

#define MG_MAX_HOST_LEN 200

Definition at line 2389 of file mongoose614.cxx.

◆ MG_NULL_IFACE_VTABLE

#define MG_NULL_IFACE_VTABLE

Value:

  {                                                                            \
    mg_null_if_init, mg_null_if_free, mg_null_if_add_conn,                     \
        mg_null_if_remove_conn, mg_null_if_poll, mg_null_if_listen_tcp,        \
        mg_null_if_listen_udp, mg_null_if_connect_tcp, mg_null_if_connect_udp, \
        mg_null_if_tcp_send, mg_null_if_udp_send, mg_null_if_tcp_recv,         \
        mg_null_if_udp_recv, mg_null_if_create_conn, mg_null_if_destroy_conn,  \
        mg_null_if_sock_set, mg_null_if_get_conn_addr,                         \
  }

Definition at line 3804 of file mongoose614.cxx.

  {                                                                            \
    mg_null_if_init, mg_null_if_free, mg_null_if_add_conn,                     \
        mg_null_if_remove_conn, mg_null_if_poll, mg_null_if_listen_tcp,        \
        mg_null_if_listen_udp, mg_null_if_connect_tcp, mg_null_if_connect_udp, \
        mg_null_if_tcp_send, mg_null_if_udp_send, mg_null_if_tcp_recv,         \
        mg_null_if_udp_recv, mg_null_if_create_conn, mg_null_if_destroy_conn,  \
        mg_null_if_sock_set, mg_null_if_get_conn_addr,                         \
  }

◆ MG_PIC32_IFACE_VTABLE

#define MG_PIC32_IFACE_VTABLE

Value:

  {                                                             \
    mg_pic32_if_init,                                           \
    mg_pic32_if_free,                                           \
    mg_pic32_if_add_conn,                                       \
    mg_pic32_if_remove_conn,                                    \
    mg_pic32_if_poll,                                           \
    mg_pic32_if_listen_tcp,                                     \
    mg_pic32_if_listen_udp,                                     \
    mg_pic32_if_connect_tcp,                                    \
    mg_pic32_if_connect_udp,                                    \
    mg_pic32_if_tcp_send,                                       \
    mg_pic32_if_udp_send,                                       \
    mg_pic32_if_recved,                                         \
    mg_pic32_if_create_conn,                                    \
    mg_pic32_if_destroy_conn,                                   \
    mg_pic32_if_sock_set,                                       \
    mg_pic32_if_get_conn_addr,                                  \
  }

Definition at line 16490 of file mongoose614.cxx.

  {                                                             \
    mg_pic32_if_init,                                           \
    mg_pic32_if_free,                                           \
    mg_pic32_if_add_conn,                                       \
    mg_pic32_if_remove_conn,                                    \
    mg_pic32_if_poll,                                           \
    mg_pic32_if_listen_tcp,                                     \
    mg_pic32_if_listen_udp,                                     \
    mg_pic32_if_connect_tcp,                                    \
    mg_pic32_if_connect_udp,                                    \
    mg_pic32_if_tcp_send,                                       \
    mg_pic32_if_udp_send,                                       \
    mg_pic32_if_recved,                                         \
    mg_pic32_if_create_conn,                                    \
    mg_pic32_if_destroy_conn,                                   \
    mg_pic32_if_sock_set,                                       \
    mg_pic32_if_get_conn_addr,                                  \
  }

◆ MG_REALLOC

#define MG_REALLOC realloc

Definition at line 200 of file mongoose614.cxx.

◆ MG_SET_PTRPTR

#define MG_SET_PTRPTR	(	_ptr,
		_v
	)

Value:

  do {                          \
    if (_ptr) *(_ptr) = _v;     \
  } while (0)

Definition at line 23 of file mongoose614.cxx.

     {                          \
    if (_ptr) *(_ptr) = _v;     \
  } while (0)

◆ MG_SIG_QUEUE_LEN

#define MG_SIG_QUEUE_LEN 32

Definition at line 15932 of file mongoose614.cxx.

◆ MG_SL_IFACE_VTABLE

#define MG_SL_IFACE_VTABLE

Value:

  {                                                                     \
    mg_sl_if_init,                                                      \
    mg_sl_if_free,                                                      \
    mg_sl_if_add_conn,                                                  \
    mg_sl_if_remove_conn,                                               \
    mg_sl_if_poll,                                                      \
    mg_sl_if_listen_tcp,                                                \
    mg_sl_if_listen_udp,                                                \
    mg_sl_if_connect_tcp,                                               \
    mg_sl_if_connect_udp,                                               \
    mg_sl_if_tcp_send,                                                  \
    mg_sl_if_udp_send,                                                  \
    mg_sl_if_tcp_recv,                                                  \
    mg_sl_if_udp_recv,                                                  \
    mg_sl_if_create_conn,                                               \
    mg_sl_if_destroy_conn,                                              \
    mg_sl_if_sock_set,                                                  \
    mg_sl_if_get_conn_addr,                                             \
  }

Definition at line 14838 of file mongoose614.cxx.

  {                                                                     \
    mg_sl_if_init,                                                      \
    mg_sl_if_free,                                                      \
    mg_sl_if_add_conn,                                                  \
    mg_sl_if_remove_conn,                                               \
    mg_sl_if_poll,                                                      \
    mg_sl_if_listen_tcp,                                                \
    mg_sl_if_listen_udp,                                                \
    mg_sl_if_connect_tcp,                                               \
    mg_sl_if_connect_udp,                                               \
    mg_sl_if_tcp_send,                                                  \
    mg_sl_if_udp_send,                                                  \
    mg_sl_if_tcp_recv,                                                  \
    mg_sl_if_udp_recv,                                                  \
    mg_sl_if_create_conn,                                               \
    mg_sl_if_destroy_conn,                                              \
    mg_sl_if_sock_set,                                                  \
    mg_sl_if_get_conn_addr,                                             \
  }

◆ MG_SOCKET_IFACE_VTABLE

#define MG_SOCKET_IFACE_VTABLE

Value:

  {                                                                     \
    mg_socket_if_init,                                                  \
    mg_socket_if_free,                                                  \
    mg_socket_if_add_conn,                                              \
    mg_socket_if_remove_conn,                                           \
    mg_socket_if_poll,                                                  \
    mg_socket_if_listen_tcp,                                            \
    mg_socket_if_listen_udp,                                            \
    mg_socket_if_connect_tcp,                                           \
    mg_socket_if_connect_udp,                                           \
    mg_socket_if_tcp_send,                                              \
    mg_socket_if_udp_send,                                              \
    mg_socket_if_tcp_recv,                                              \
    mg_socket_if_udp_recv,                                              \
    mg_socket_if_create_conn,                                           \
    mg_socket_if_destroy_conn,                                          \
    mg_socket_if_sock_set,                                              \
    mg_socket_if_get_conn_addr,                                         \
  }

Definition at line 4376 of file mongoose614.cxx.

  {                                                                     \
    mg_socket_if_init,                                                  \
    mg_socket_if_free,                                                  \
    mg_socket_if_add_conn,                                              \
    mg_socket_if_remove_conn,                                           \
    mg_socket_if_poll,                                                  \
    mg_socket_if_listen_tcp,                                            \
    mg_socket_if_listen_udp,                                            \
    mg_socket_if_connect_tcp,                                           \
    mg_socket_if_connect_udp,                                           \
    mg_socket_if_tcp_send,                                              \
    mg_socket_if_udp_send,                                              \
    mg_socket_if_tcp_recv,                                              \
    mg_socket_if_udp_recv,                                              \
    mg_socket_if_create_conn,                                           \
    mg_socket_if_destroy_conn,                                          \
    mg_socket_if_sock_set,                                              \
    mg_socket_if_get_conn_addr,                                         \
  }

◆ MG_TCP_IO_SIZE

#define MG_TCP_IO_SIZE 1460

Definition at line 2392 of file mongoose614.cxx.

◆ MG_TCP_RECV_BUFFER_SIZE

#define MG_TCP_RECV_BUFFER_SIZE 1024

Definition at line 14458 of file mongoose614.cxx.

◆ MG_UDP_IO_SIZE

#define MG_UDP_IO_SIZE 1460

Definition at line 2395 of file mongoose614.cxx.

◆ MG_UDP_RECV_BUFFER_SIZE

#define MG_UDP_RECV_BUFFER_SIZE 1500

Definition at line 14459 of file mongoose614.cxx.

◆ mgos_lock

#define mgos_lock ( )

Definition at line 15272 of file mongoose614.cxx.

◆ mgos_unlock

#define mgos_unlock ( )

Definition at line 15273 of file mongoose614.cxx.

◆ MIN

#define MIN	(	a,
		b
	)	((a) < (b) ? (a) : (b))

Definition at line 85 of file mongoose614.cxx.

◆ NUM_DIGITS

#define NUM_DIGITS ('9' - '0' + 1)

Definition at line 244 of file mongoose614.cxx.

◆ NUM_LETTERS

#define NUM_LETTERS (NUM_UPPERCASES * 2)

Definition at line 243 of file mongoose614.cxx.

◆ NUM_UPPERCASES

#define NUM_UPPERCASES ('Z' - 'A' + 1)

Definition at line 242 of file mongoose614.cxx.

◆ R0

#define R0	(	v,
		w,
		x,
		y,
		z,
		i
	)

Value:

z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); \

w = rol(w, 30);

blk0

static uint32_t blk0(union char64long16 *block, int i)

Definition mongoose614.cxx:1277

Definition at line 1298 of file mongoose614.cxx.

◆ R1

#define R1	(	v,
		w,
		x,
		y,
		z,
		i
	)

Value:

z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \

w = rol(w, 30);

blk

#define blk(i)

Definition mongoose614.cxx:1294

Definition at line 1301 of file mongoose614.cxx.

◆ R2

#define R2	(	v,
		w,
		x,
		y,
		z,
		i
	)

Value:

z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \

w = rol(w, 30);

Definition at line 1304 of file mongoose614.cxx.

◆ R3

#define R3	(	v,
		w,
		x,
		y,
		z,
		i
	)

Value:

z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \

w = rol(w, 30);

Definition at line 1307 of file mongoose614.cxx.

◆ R4

#define R4	(	v,
		w,
		x,
		y,
		z,
		i
	)

Value:

z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \

w = rol(w, 30);

Definition at line 1310 of file mongoose614.cxx.

◆ rol

#define rol	(	value,
		bits
	)	(((value) << (bits)) \| ((value) >> (32 - (bits))))

Definition at line 1275 of file mongoose614.cxx.

◆ SET_ADDR

#define SET_ADDR	(	dst,
		src
	)	(dst)->sin.sin_addr.s_addr = ip_2_ip4(src)->addr

Definition at line 15254 of file mongoose614.cxx.

◆ SHA1HANDSOFF

#define SHA1HANDSOFF

Definition at line 1265 of file mongoose614.cxx.

◆ TCP_BIND

#define TCP_BIND tcp_bind

Definition at line 15251 of file mongoose614.cxx.

◆ TCP_NEW

#define TCP_NEW tcp_new

Definition at line 15250 of file mongoose614.cxx.

◆ UDP_BIND

#define UDP_BIND udp_bind

Definition at line 15252 of file mongoose614.cxx.

Typedef Documentation

◆ cs_dirent_dummy

typedef int cs_dirent_dummy

Definition at line 893 of file mongoose614.cxx.

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

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

◆ mg_q_msg_type

enum mg_q_msg_type

Enumerator
MG_Q_MSG_CB

Definition at line 14345 of file mongoose614.cxx.

                   {
  MG_Q_MSG_CB,
};

◆ mg_sig_type

enum mg_sig_type

Enumerator
MG_SIG_CONNECT_RESULT
MG_SIG_RECV
MG_SIG_CLOSE_CONN
MG_SIG_TOMBSTONE
MG_SIG_ACCEPT

Definition at line 15172 of file mongoose614.cxx.

                 {
  MG_SIG_CONNECT_RESULT = 1,
  MG_SIG_RECV = 2,
  MG_SIG_CLOSE_CONN = 3,
  MG_SIG_TOMBSTONE = 4,
  MG_SIG_ACCEPT = 5,
};

Function Documentation

◆ _exit()

void _exit ( int status )

Definition at line 13397 of file mongoose614.cxx.

                       {
  fprint_str(stderr, "_exit\n");
  /* cause an unaligned access exception, that will drop you into gdb */
  *(int *) 1 = status;
  while (1)
    ; /* avoid gcc warning because stdlib abort() has noreturn attribute */
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _getpid()

int _getpid ( )

Definition at line 13418 of file mongoose614.cxx.

              {
  fprint_str(stderr, "_getpid is not implemented\n");
  return 42;
}

Here is the call graph for this function:

◆ _isatty()

int _isatty ( int fd )

Definition at line 13423 of file mongoose614.cxx.

                    {
  /* 0, 1 and 2 are TTYs. */
  return fd < 2;
}

◆ _kill()

int _kill	(	int	pid,
		int	sig
	)

Definition at line 13411 of file mongoose614.cxx.

                            {
  (void) pid;
  (void) sig;
  _not_implemented("_kill");
  return -1;
}

Here is the call graph for this function:

◆ _not_implemented()

void _not_implemented ( const char * what )

Definition at line 13405 of file mongoose614.cxx.

                                        {
  fprint_str(stderr, what);
  fprint_str(stderr, " is not implemented\n");
  _exit(42);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ blk0()

static uint32_t blk0	(	union char64long16 *	block,
		int	i
	)

static

Definition at line 1277 of file mongoose614.cxx.

                                                       {
/* Forrest: SHA expect BIG_ENDIAN, swap if LITTLE_ENDIAN */
#if BYTE_ORDER == LITTLE_ENDIAN
  block->l[i] =
      (rol(block->l[i], 24) & 0xFF00FF00) | (rol(block->l[i], 8) & 0x00FF00FF);
#endif
  return block->l[i];
}

◆ byteReverse()

static void byteReverse	(	unsigned char *	buf,
		unsigned	longs
	)

static

Definition at line 1067 of file mongoose614.cxx.

                                                            {
/* Forrest: MD5 expect LITTLE_ENDIAN, swap if BIG_ENDIAN */
#if BYTE_ORDER == BIG_ENDIAN
  do {
    uint32_t t = (uint32_t)((unsigned) buf[3] << 8 | buf[2]) << 16 |
                 ((unsigned) buf[1] << 8 | buf[0]);
    *(uint32_t *) buf = t;
    buf += 4;
  } while (--longs);
#else
  (void) buf;
  (void) longs;
#endif
}

Here is the caller graph for this function:

◆ c_itoa()

static int c_itoa	(	char *	buf,
		size_t	buf_size,
		int64_t	num,
		int	base,
		int	flags,
		int	field_width
	)

static

Definition at line 1881 of file mongoose614.cxx.

                                   {
  char tmp[40];
  int i = 0, k = 0, neg = 0;
 
  if (num < 0) {
    neg++;
    num = -num;
  }
 
  /* Print into temporary buffer - in reverse order */
  do {
    int rem = num % base;
    if (rem < 10) {
      tmp[k++] = '0' + rem;
    } else {
      tmp[k++] = 'a' + (rem - 10);
    }
    num /= base;
  } while (num > 0);
 
  /* Zero padding */
  if (flags && C_SNPRINTF_FLAG_ZERO) {
    while (k < field_width && k < (int) sizeof(tmp) - 1) {
      tmp[k++] = '0';
    }
  }
 
  /* And sign */
  if (neg) {
    tmp[k++] = '-';
  }
 
  /* Now output */
  while (--k >= 0) {
    C_SNPRINTF_APPEND_CHAR(tmp[k]);
  }
 
  return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cs_base64_decode()

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

Definition at line 410 of file mongoose614.cxx.

                                                                               {
  unsigned char a, b, c, d;
  int orig_len = len;
  char *orig_dst = dst;
  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;
  if (dec_len != NULL) *dec_len = (dst - orig_dst);
  return orig_len - len;
}

Here is the caller graph for this function:

◆ cs_base64_emit_chunk()

static void cs_base64_emit_chunk ( struct cs_base64_ctx * ctx )

static

Definition at line 264 of file mongoose614.cxx.

                                                            {
  int a, b, c;
 
  a = ctx->chunk[0];
  b = ctx->chunk[1];
  c = ctx->chunk[2];
 
  cs_base64_emit_code(ctx, a >> 2);
  cs_base64_emit_code(ctx, ((a & 3) << 4) | (b >> 4));
  if (ctx->chunk_size > 1) {
    cs_base64_emit_code(ctx, (b & 15) << 2 | (c >> 6));
  }
  if (ctx->chunk_size > 2) {
    cs_base64_emit_code(ctx, c & 63);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cs_base64_emit_code()

static void cs_base64_emit_code	(	struct cs_base64_ctx *	ctx,
		int	v
	)

static

Definition at line 251 of file mongoose614.cxx.

                                                                  {
  if (v < NUM_UPPERCASES) {
    ctx->b64_putc(v + 'A', ctx->user_data);
  } else if (v < (NUM_LETTERS)) {
    ctx->b64_putc(v - NUM_UPPERCASES + 'a', ctx->user_data);
  } else if (v < (NUM_LETTERS + NUM_DIGITS)) {
    ctx->b64_putc(v - NUM_LETTERS + '0', ctx->user_data);
  } else {
    ctx->b64_putc(v - NUM_LETTERS - NUM_DIGITS == 0 ? '+' : '/',
                  ctx->user_data);
  }
}

Here is the caller graph for this function:

◆ cs_from_hex()

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

Definition at line 2154 of file mongoose614.cxx.

                                                      {
  size_t i;
 
  for (i = 0; i < len; i += 2) {
    *to++ = (fourbit(p[i]) << 4) + fourbit(p[i + 1]);
  }
  *to = '\0';
}

◆ cs_log_print_prefix()

int cs_log_print_prefix	(	enum cs_log_level	level,
		const char *	fname,
		int	line
	)

◆ cs_log_set_file_level()

void cs_log_set_file_level ( const char * file_level )

Definition at line 716 of file mongoose614.cxx.

                                                   {
  (void) file_level;
}

◆ cs_md5_final()

void cs_md5_final	(	unsigned char	digest[16],
		cs_md5_ctx *	ctx
	)

Definition at line 1221 of file mongoose614.cxx.

                                                             {
  unsigned count;
  unsigned char *p;
  uint32_t *a;
 
  count = (ctx->bits[0] >> 3) & 0x3F;
 
  p = ctx->in + count;
  *p++ = 0x80;
  count = 64 - 1 - count;
  if (count < 8) {
    memset(p, 0, count);
    byteReverse(ctx->in, 16);
    cs_md5_transform(ctx->buf, (uint32_t *) ctx->in);
    memset(ctx->in, 0, 56);
  } else {
    memset(p, 0, count - 8);
  }
  byteReverse(ctx->in, 14);
 
  a = (uint32_t *) ctx->in;
  a[14] = ctx->bits[0];
  a[15] = ctx->bits[1];
 
  cs_md5_transform(ctx->buf, (uint32_t *) ctx->in);
  byteReverse((unsigned char *) ctx->buf, 4);
  memcpy(digest, ctx->buf, 16);
  memset((char *) ctx, 0, sizeof(*ctx));
}

Here is the call graph for this function:

◆ cs_md5_init()

void cs_md5_init ( cs_md5_ctx * ctx )

Definition at line 1094 of file mongoose614.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;
}

◆ cs_md5_transform()

static void cs_md5_transform	(	uint32_t	buf[4],
		uint32_t const	in[16]
	)

static

Definition at line 1104 of file mongoose614.cxx.

                                                                     {
  register uint32_t a, b, c, d;
 
  a = buf[0];
  b = buf[1];
  c = buf[2];
  d = buf[3];
 
  MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
  MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
  MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
  MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
  MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
  MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
  MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
  MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
  MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
  MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
 
  MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
  MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
  MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
  MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
  MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
  MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
  MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
  MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
  MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
  MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
 
  MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
  MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
  MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
  MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
  MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
  MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
 
  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
 
  buf[0] += a;
  buf[1] += b;
  buf[2] += c;
  buf[3] += d;
}

Here is the caller graph for this function:

◆ cs_md5_update()

void cs_md5_update	(	cs_md5_ctx *	ctx,
		const unsigned char *	buf,
		size_t	len
	)

Definition at line 1186 of file mongoose614.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);
    cs_md5_transform(ctx->buf, (uint32_t *) ctx->in);
    buf += t;
    len -= t;
  }
 
  while (len >= 64) {
    memcpy(ctx->in, buf, 64);
    byteReverse(ctx->in, 16);
    cs_md5_transform(ctx->buf, (uint32_t *) ctx->in);
    buf += 64;
    len -= 64;
  }
 
  memcpy(ctx->in, buf, len);
}

◆ cs_sha1_transform()

void cs_sha1_transform	(	uint32_t	state[5],
		const unsigned char	buffer[64]
	)

Definition at line 1314 of file mongoose614.cxx.

                                                                          {
  uint32_t a, b, c, d, e;
  union char64long16 block[1];
 
  memcpy(block, buffer, 64);
  a = state[0];
  b = state[1];
  c = state[2];
  d = state[3];
  e = state[4];
  R0(a, b, c, d, e, 0);
  R0(e, a, b, c, d, 1);
  R0(d, e, a, b, c, 2);
  R0(c, d, e, a, b, 3);
  R0(b, c, d, e, a, 4);
  R0(a, b, c, d, e, 5);
  R0(e, a, b, c, d, 6);
  R0(d, e, a, b, c, 7);
  R0(c, d, e, a, b, 8);
  R0(b, c, d, e, a, 9);
  R0(a, b, c, d, e, 10);
  R0(e, a, b, c, d, 11);
  R0(d, e, a, b, c, 12);
  R0(c, d, e, a, b, 13);
  R0(b, c, d, e, a, 14);
  R0(a, b, c, d, e, 15);
  R1(e, a, b, c, d, 16);
  R1(d, e, a, b, c, 17);
  R1(c, d, e, a, b, 18);
  R1(b, c, d, e, a, 19);
  R2(a, b, c, d, e, 20);
  R2(e, a, b, c, d, 21);
  R2(d, e, a, b, c, 22);
  R2(c, d, e, a, b, 23);
  R2(b, c, d, e, a, 24);
  R2(a, b, c, d, e, 25);
  R2(e, a, b, c, d, 26);
  R2(d, e, a, b, c, 27);
  R2(c, d, e, a, b, 28);
  R2(b, c, d, e, a, 29);
  R2(a, b, c, d, e, 30);
  R2(e, a, b, c, d, 31);
  R2(d, e, a, b, c, 32);
  R2(c, d, e, a, b, 33);
  R2(b, c, d, e, a, 34);
  R2(a, b, c, d, e, 35);
  R2(e, a, b, c, d, 36);
  R2(d, e, a, b, c, 37);
  R2(c, d, e, a, b, 38);
  R2(b, c, d, e, a, 39);
  R3(a, b, c, d, e, 40);
  R3(e, a, b, c, d, 41);
  R3(d, e, a, b, c, 42);
  R3(c, d, e, a, b, 43);
  R3(b, c, d, e, a, 44);
  R3(a, b, c, d, e, 45);
  R3(e, a, b, c, d, 46);
  R3(d, e, a, b, c, 47);
  R3(c, d, e, a, b, 48);
  R3(b, c, d, e, a, 49);
  R3(a, b, c, d, e, 50);
  R3(e, a, b, c, d, 51);
  R3(d, e, a, b, c, 52);
  R3(c, d, e, a, b, 53);
  R3(b, c, d, e, a, 54);
  R3(a, b, c, d, e, 55);
  R3(e, a, b, c, d, 56);
  R3(d, e, a, b, c, 57);
  R3(c, d, e, a, b, 58);
  R3(b, c, d, e, a, 59);
  R4(a, b, c, d, e, 60);
  R4(e, a, b, c, d, 61);
  R4(d, e, a, b, c, 62);
  R4(c, d, e, a, b, 63);
  R4(b, c, d, e, a, 64);
  R4(a, b, c, d, e, 65);
  R4(e, a, b, c, d, 66);
  R4(d, e, a, b, c, 67);
  R4(c, d, e, a, b, 68);
  R4(b, c, d, e, a, 69);
  R4(a, b, c, d, e, 70);
  R4(e, a, b, c, d, 71);
  R4(d, e, a, b, c, 72);
  R4(c, d, e, a, b, 73);
  R4(b, c, d, e, a, 74);
  R4(a, b, c, d, e, 75);
  R4(e, a, b, c, d, 76);
  R4(d, e, a, b, c, 77);
  R4(c, d, e, a, b, 78);
  R4(b, c, d, e, a, 79);
  state[0] += a;
  state[1] += b;
  state[2] += c;
  state[3] += d;
  state[4] += e;
  /* Erase working structures. The order of operations is important,
   * used to ensure that compiler doesn't optimize those out. */
  memset(block, 0, sizeof(block));
  a = b = c = d = e = 0;
  (void) a;
  (void) b;
  (void) c;
  (void) d;
  (void) e;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cs_timegm()

double cs_timegm ( const struct tm * tm )

Definition at line 958 of file mongoose614.cxx.

                                      {
  /* Month-to-day offset for non-leap-years. */
  static const int month_day[12] = {0,   31,  59,  90,  120, 151,
                                    181, 212, 243, 273, 304, 334};
 
  /* Most of the calculation is easy; leap years are the main difficulty. */
  int month = tm->tm_mon % 12;
  int year = tm->tm_year + tm->tm_mon / 12;
  int year_for_leap;
  int64_t rt;
 
  if (month < 0) { /* Negative values % 12 are still negative. */
    month += 12;
    --year;
  }
 
  /* This is the number of Februaries since 1900. */
  year_for_leap = (month > 1) ? year + 1 : year;
 
  rt =
      tm->tm_sec /* Seconds */
      +
      60 *
          (tm->tm_min /* Minute = 60 seconds */
           +
           60 * (tm->tm_hour /* Hour = 60 minutes */
                 +
                 24 * (month_day[month] + tm->tm_mday - 1 /* Day = 24 hours */
                       + 365 * (year - 70)                /* Year = 365 days */
                       + (year_for_leap - 69) / 4 /* Every 4 years is leap... */
                       - (year_for_leap - 1) / 100 /* Except centuries... */
                       + (year_for_leap + 299) / 400))); /* Except 400s. */
  return rt < 0 ? -1 : (double) rt;
}

◆ fourbit()

static int fourbit ( int ch )

static

Definition at line 2142 of file mongoose614.cxx.

                           {
  if (ch >= '0' && ch <= '9') {
    return ch - '0';
  } else if (ch >= 'a' && ch <= 'f') {
    return ch - 'a' + 10;
  } else if (ch >= 'A' && ch <= 'F') {
    return ch - 'A' + 10;
  }
  return 0;
}

Here is the caller graph for this function:

◆ fprint_str()

void fprint_str	(	FILE *	fp,
		const char *	str
	)

Definition at line 13390 of file mongoose614.cxx.

                                           {
  while (*str != '\0') {
    if (*str == '\n') MAP_UARTCharPut(CONSOLE_UART, '\r');
    MAP_UARTCharPut(CONSOLE_UART, *str++);
  }
}

Here is the caller graph for this function:

◆ from_b64()

static unsigned char from_b64 ( unsigned char ch )

static

Definition at line 371 of file mongoose614.cxx.

                                                {
  /* Inverse lookup map */
  static const unsigned char tab[128] = {
      255, 255, 255, 255,
      255, 255, 255, 255, /*  0 */
      255, 255, 255, 255,
      255, 255, 255, 255, /*  8 */
      255, 255, 255, 255,
      255, 255, 255, 255, /*  16 */
      255, 255, 255, 255,
      255, 255, 255, 255, /*  24 */
      255, 255, 255, 255,
      255, 255, 255, 255, /*  32 */
      255, 255, 255, 62,
      255, 255, 255, 63, /*  40 */
      52,  53,  54,  55,
      56,  57,  58,  59, /*  48 */
      60,  61,  255, 255,
      255, 200, 255, 255, /*  56   '=' is 200, on index 61 */
      255, 0,   1,   2,
      3,   4,   5,   6, /*  64 */
      7,   8,   9,   10,
      11,  12,  13,  14, /*  72 */
      15,  16,  17,  18,
      19,  20,  21,  22, /*  80 */
      23,  24,  25,  255,
      255, 255, 255, 255, /*  88 */
      255, 26,  27,  28,
      29,  30,  31,  32, /*  96 */
      33,  34,  35,  36,
      37,  38,  39,  40, /*  104 */
      41,  42,  43,  44,
      45,  46,  47,  48, /*  112 */
      49,  50,  51,  255,
      255, 255, 255, 255, /*  120 */
  };
  return tab[ch & 127];
}

Here is the caller graph for this function:

◆ gettimeofday()

int gettimeofday	(	struct timeval *	tp,
		void *	tzp
	)

Definition at line 13454 of file mongoose614.cxx.

                                                {
  uint32_t ticks = Clock_getTicks();
  tp->tv_sec = ticks / 1000;
  tp->tv_usec = (ticks % 1000) * 1000;
  return 0;
}

Here is the caller graph for this function:

◆ inet_ntoa()

char * inet_ntoa ( struct in_addr n )

Definition at line 14313 of file mongoose614.cxx.

                                  {
  static char a[16];
  return (char *) inet_ntop(AF_INET, &n, a, sizeof(a));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inet_ntop()

const char * inet_ntop	(	int	af,
		const void *	src,
		char *	dst,
		socklen_t	size
	)

Definition at line 14300 of file mongoose614.cxx.

                                                                          {
  int res;
  struct in_addr *in = (struct in_addr *) src;
  if (af != AF_INET) {
    errno = ENOTSUP;
    return NULL;
  }
  res = snprintf(dst, size, "%lu.%lu.%lu.%lu", SL_IPV4_BYTE(in->s_addr, 0),
                 SL_IPV4_BYTE(in->s_addr, 1), SL_IPV4_BYTE(in->s_addr, 2),
                 SL_IPV4_BYTE(in->s_addr, 3));
  return res > 0 ? dst : NULL;
}

Here is the caller graph for this function:

◆ inet_pton()

int inet_pton	(	int	af,
		const char *	src,
		void *	dst
	)

Definition at line 14318 of file mongoose614.cxx.

                                                  {
  uint32_t a0, a1, a2, a3;
  uint8_t *db = (uint8_t *) dst;
  if (af != AF_INET) {
    errno = ENOTSUP;
    return 0;
  }
  if (sscanf(src, "%lu.%lu.%lu.%lu", &a0, &a1, &a2, &a3) != 4) {
    return 0;
  }
  *db = a3;
  *(db + 1) = a2;
  *(db + 2) = a1;
  *(db + 3) = a0;
  return 1;
}

Here is the caller graph for this function:

◆ isbyte()

static int isbyte ( int n )

static

Definition at line 3462 of file mongoose614.cxx.

                         {
  return n >= 0 && n <= 255;
}

Here is the caller graph for this function:

◆ mbuf_append_and_free()

size_t mbuf_append_and_free	(	struct mbuf *	a,
		void *	buf,
		size_t	len
	)

Definition at line 1628 of file mongoose614.cxx.

                                                                    {
  size_t ret;
  /* Optimization: if the buffer is currently empty,
   * take over the user-provided buffer. */
  if (a->len == 0) {
    if (a->buf != NULL) free(a->buf);
    a->buf = (char *) data;
    a->len = a->size = len;
    return len;
  }
  ret = mbuf_insert(a, a->len, data, len);
  free(data);
  return ret;
}

◆ mbuf_clear()

void mbuf_clear ( struct mbuf * mb )

Definition at line 1652 of file mongoose614.cxx.

                                 {
  mb->len = 0;
}

◆ mbuf_move()

void mbuf_move	(	struct mbuf *	from,
		struct mbuf *	to
	)

Definition at line 1657 of file mongoose614.cxx.

                                                   {
  memcpy(to, from, sizeof(*to));
  memset(from, 0, sizeof(*from));
}

◆ mg_accept_conn()

static int mg_accept_conn ( struct mg_connection * lc )

static

Definition at line 3963 of file mongoose614.cxx.

                                                    {
  struct mg_connection *nc;
  union socket_address sa;
  socklen_t sa_len = sizeof(sa);
  /* NOTE(lsm): on Windows, sock is always > FD_SETSIZE */
  sock_t sock = accept(lc->sock, &sa.sa, &sa_len);
  if (sock == INVALID_SOCKET) {
    if (mg_is_error()) {
      DBG(("%p: failed to accept: %d", lc, mg_get_errno()));
    }
    return 0;
  }
  nc = mg_if_accept_new_conn(lc);
  if (nc == NULL) {
    closesocket(sock);
    return 0;
  }
  DBG(("%p conn from %s:%d", nc, inet_ntoa(sa.sin.sin_addr),
       ntohs(sa.sin.sin_port)));
  mg_sock_set(nc, sock);
  mg_if_accept_tcp_cb(nc, &sa, sa_len);
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_add_conn()

MG_INTERNAL void mg_add_conn	(	struct mg_mgr *	mgr,
		struct mg_connection *	c
	)

Definition at line 2415 of file mongoose614.cxx.

                                                                          {
  DBG(("%p %p", mgr, c));
  c->mgr = mgr;
  c->next = mgr->active_connections;
  mgr->active_connections = c;
  c->prev = NULL;
  if (c->next != NULL) c->next->prev = c;
  if (c->sock != INVALID_SOCKET) {
    c->iface->vtable->add_conn(c);
  }
}

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_CB(mg_event_handler_t callback, void *user_data)
	)

Definition at line 3555 of file mongoose614.cxx.

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

Here is the call graph for this function:

◆ mg_add_sock_opt()

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

Definition at line 3539 of file mongoose614.cxx.

                                                                    {
#if MG_ENABLE_CALLBACK_USERDATA
  opts.user_data = user_data;
#endif
 
  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_add_to_set()

void mg_add_to_set	(	sock_t	sock,
		fd_set *	set,
		sock_t *	max_fd
	)

Definition at line 4146 of file mongoose614.cxx.

                                                             {
  if (sock != INVALID_SOCKET
#ifdef __unix__
      && sock < (sock_t) FD_SETSIZE
#endif
      ) {
    FD_SET(sock, set);
    if (*max_fd == INVALID_SOCKET || sock > *max_fd) {
      *max_fd = sock;
    }
  }
}

Here is the caller graph for this function:

◆ mg_asprintf()

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

Definition at line 2203 of file mongoose614.cxx.

                                                               {
  int ret;
  va_list ap;
  va_start(ap, fmt);
  ret = mg_avprintf(buf, size, fmt, ap);
  va_end(ap);
  return ret;
}

◆ mg_assemble_uri()

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

Definition at line 5751 of file mongoose614.cxx.

                                        {
  int result = -1;
  struct mbuf out;
  mbuf_init(&out, 0);
 
  if (scheme != NULL && scheme->len > 0) {
    mbuf_append(&out, scheme->p, scheme->len);
    mbuf_append(&out, "://", 3);
  }
 
  if (user_info != NULL && user_info->len > 0) {
    mbuf_append(&out, user_info->p, user_info->len);
    mbuf_append(&out, "@", 1);
  }
 
  if (host != NULL && host->len > 0) {
    mbuf_append(&out, host->p, host->len);
  }
 
  if (port != 0) {
    char port_str[20];
    int port_str_len = sprintf(port_str, ":%u", port);
    mbuf_append(&out, port_str, port_str_len);
  }
 
  if (path != NULL && path->len > 0) {
    if (normalize_path) {
      struct mg_str npath = mg_strdup(*path);
      if (npath.len != path->len) goto out;
      if (!mg_normalize_uri_path(path, &npath)) {
        free((void *) npath.p);
        goto out;
      }
      mbuf_append(&out, npath.p, npath.len);
      free((void *) npath.p);
    } else {
      mbuf_append(&out, path->p, path->len);
    }
  } else if (normalize_path) {
    mbuf_append(&out, "/", 1);
  }
 
  if (query != NULL && query->len > 0) {
    mbuf_append(&out, "?", 1);
    mbuf_append(&out, query->p, query->len);
  }
 
  if (fragment != NULL && fragment->len > 0) {
    mbuf_append(&out, "#", 1);
    mbuf_append(&out, fragment->p, fragment->len);
  }
 
  result = 0;
 
out:
  if (result == 0) {
    uri->p = out.buf;
    uri->len = out.len;
  } else {
    mbuf_free(&out);
    uri->p = NULL;
    uri->len = 0;
  }
  return result;
}

◆ mg_basic_auth_header()

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

Definition at line 10750 of file mongoose614.cxx.

                                            {
  const char *header_prefix = "Authorization: Basic ";
  const char *header_suffix = "\r\n";
 
  struct cs_base64_ctx ctx;
  cs_base64_init(&ctx, mg_mbuf_append_base64_putc, buf);
 
  mbuf_append(buf, header_prefix, strlen(header_prefix));
 
  cs_base64_update(&ctx, user.p, user.len);
  if (pass.len > 0) {
    cs_base64_update(&ctx, ":", 1);
    cs_base64_update(&ctx, pass.p, pass.len);
  }
  cs_base64_finish(&ctx);
  mbuf_append(buf, header_suffix, strlen(header_suffix));
}

◆ mg_bind()

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

Definition at line 3346 of file mongoose614.cxx.

                                                      {
  struct mg_bind_opts opts;
  memset(&opts, 0, sizeof(opts));
  return mg_bind_opt(srv, address, MG_CB(event_handler, user_data), 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_CB(mg_event_handler_t callback, void *user_data)	,
		struct mg_bind_opts	opts
	)

Definition at line 3354 of file mongoose614.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];
 
#if MG_ENABLE_CALLBACK_USERDATA
  opts.user_data = user_data;
#endif
 
  if (callback == NULL) {
    MG_SET_PTRPTR(opts.error_string, "handler is required");
    return NULL;
  }
 
  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;
 
#if MG_ENABLE_SSL
  DBG(("%p %s %s,%s,%s", nc, address, (opts.ssl_cert ? opts.ssl_cert : "-"),
       (opts.ssl_key ? opts.ssl_key : "-"),
       (opts.ssl_ca_cert ? opts.ssl_ca_cert : "-")));
 
  if (opts.ssl_cert != NULL || opts.ssl_ca_cert != NULL) {
    const char *err_msg = NULL;
    struct mg_ssl_if_conn_params params;
    if (nc->flags & MG_F_UDP) {
      MG_SET_PTRPTR(opts.error_string, "SSL for UDP is not supported");
      mg_destroy_conn(nc, 1 /* destroy_if */);
      return NULL;
    }
    memset(&params, 0, sizeof(params));
    params.cert = opts.ssl_cert;
    params.key = opts.ssl_key;
    params.ca_cert = opts.ssl_ca_cert;
    params.cipher_suites = opts.ssl_cipher_suites;
    if (mg_ssl_if_conn_init(nc, &params, &err_msg) != MG_SSL_OK) {
      MG_SET_PTRPTR(opts.error_string, err_msg);
      mg_destroy_conn(nc, 1 /* destroy_if */);
      return NULL;
    }
    nc->flags |= MG_F_SSL;
  }
#endif /* MG_ENABLE_SSL */
 
  if (nc->flags & MG_F_UDP) {
    rc = nc->iface->vtable->listen_udp(nc, &nc->sa);
  } else {
    rc = nc->iface->vtable->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, 1 /* destroy_if */);
    return NULL;
  }
  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_call()

MG_INTERNAL void mg_call	(	struct mg_connection *	nc,
		mg_event_handler_t	ev_handler,
		void *	user_data,
		int	ev,
		void *	ev_data
	)

Definition at line 2435 of file mongoose614.cxx.

                                        {
  if (ev_handler == NULL) {
    /*
     * If protocol handler is specified, call it. Otherwise, call user-specified
     * event handler.
     */
    ev_handler = nc->proto_handler ? nc->proto_handler : nc->handler;
  }
  if (ev != MG_EV_POLL) {
    DBG(("%p %s ev=%d ev_data=%p flags=0x%lx rmbl=%d smbl=%d", nc,
         ev_handler == nc->handler ? "user" : "proto", ev, ev_data, nc->flags,
         (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len));
  }
 
#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP
  if (nc->mgr->hexdump_file != NULL && ev != MG_EV_POLL && ev != MG_EV_RECV &&
      ev != MG_EV_SEND /* handled separately */) {
    mg_hexdump_connection(nc, nc->mgr->hexdump_file, NULL, 0, ev);
  }
#endif
  if (ev_handler != NULL) {
    unsigned long flags_before = nc->flags;
    ev_handler(nc, ev, ev_data MG_UD_ARG(user_data));
    /* Prevent user handler from fiddling with system flags. */
    if (ev_handler == nc->handler && nc->flags != flags_before) {
      nc->flags = (flags_before & ~_MG_CALLBACK_MODIFIABLE_FLAGS_MASK) |
                  (nc->flags & _MG_CALLBACK_MODIFIABLE_FLAGS_MASK);
    }
  }
  if (ev != MG_EV_POLL) nc->mgr->num_calls++;
  if (ev != MG_EV_POLL) {
    DBG(("%p after %s flags=0x%lx rmbl=%d smbl=%d", nc,
         ev_handler == nc->handler ? "user" : "proto", nc->flags,
         (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len));
  }
#if !MG_ENABLE_CALLBACK_USERDATA
  (void) user_data;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_connect()

struct mg_connection * mg_connect	(	struct mg_mgr *	mgr,
		const char *	address,
		MG_CB(mg_event_handler_t callback, void *user_data)
	)

Definition at line 3236 of file mongoose614.cxx.

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

Here is the call graph for this function:

◆ mg_connect_opt()

struct mg_connection * mg_connect_opt	(	struct mg_mgr *	mgr,
		const char *	address,
		MG_CB(mg_event_handler_t callback, void *user_data)	,
		struct mg_connect_opts	opts
	)

Definition at line 3244 of file mongoose614.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;
  }
 
  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, 1 /* destroy_if */);
    return NULL;
  }
 
  nc->flags |= opts.flags & _MG_ALLOWED_CONNECT_FLAGS_MASK;
  nc->flags |= (proto == SOCK_DGRAM) ? MG_F_UDP : 0;
#if MG_ENABLE_CALLBACK_USERDATA
  nc->user_data = user_data;
#else
  nc->user_data = opts.user_data;
#endif
 
#if MG_ENABLE_SSL
  LOG(LL_DEBUG,
      ("%p %s %s,%s,%s", nc, address, (opts.ssl_cert ? opts.ssl_cert : "-"),
       (opts.ssl_key ? opts.ssl_key : "-"),
       (opts.ssl_ca_cert ? opts.ssl_ca_cert : "-")));
 
  if (opts.ssl_cert != NULL || opts.ssl_ca_cert != NULL ||
      opts.ssl_psk_identity != NULL) {
    const char *err_msg = NULL;
    struct mg_ssl_if_conn_params params;
    if (nc->flags & MG_F_UDP) {
      MG_SET_PTRPTR(opts.error_string, "SSL for UDP is not supported");
      mg_destroy_conn(nc, 1 /* destroy_if */);
      return NULL;
    }
    memset(&params, 0, sizeof(params));
    params.cert = opts.ssl_cert;
    params.key = opts.ssl_key;
    params.ca_cert = opts.ssl_ca_cert;
    params.cipher_suites = opts.ssl_cipher_suites;
    params.psk_identity = opts.ssl_psk_identity;
    params.psk_key = opts.ssl_psk_key;
    if (opts.ssl_ca_cert != NULL) {
      if (opts.ssl_server_name != NULL) {
        if (strcmp(opts.ssl_server_name, "*") != 0) {
          params.server_name = opts.ssl_server_name;
        }
      } else if (rc == 0) { /* If it's a DNS name, use host. */
        params.server_name = host;
      }
    }
    if (mg_ssl_if_conn_init(nc, &params, &err_msg) != MG_SSL_OK) {
      MG_SET_PTRPTR(opts.error_string, err_msg);
      mg_destroy_conn(nc, 1 /* destroy_if */);
      return NULL;
    }
    nc->flags |= MG_F_SSL;
  }
#endif /* MG_ENABLE_SSL */
 
  if (rc == 0) {
#if MG_ENABLE_ASYNC_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;
    o.nameserver = opts.nameserver;
    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, 1 /* destroy_if */);
      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, 1 /* destroy_if */);
    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_create_connection()

MG_INTERNAL struct mg_connection * mg_create_connection	(	struct mg_mgr *	mgr,
		mg_event_handler_t	callback,
		struct mg_add_sock_opts	opts
	)

Definition at line 2758 of file mongoose614.cxx.

                                  {
  struct mg_connection *conn = mg_create_connection_base(mgr, callback, opts);
 
  if (conn != NULL && !conn->iface->vtable->create_conn(conn)) {
    MG_FREE(conn);
    conn = NULL;
  }
  if (conn == NULL) {
    MG_SET_PTRPTR(opts.error_string, "failed to init connection");
  }
 
  return conn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_create_connection_base()

MG_INTERNAL struct mg_connection * mg_create_connection_base	(	struct mg_mgr *	mgr,
		mg_event_handler_t	callback,
		struct mg_add_sock_opts	opts
	)

Definition at line 2731 of file mongoose614.cxx.

                                  {
  struct mg_connection *conn;
 
  if ((conn = (struct mg_connection *) MG_CALLOC(1, sizeof(*conn))) != NULL) {
    conn->sock = INVALID_SOCKET;
    conn->handler = callback;
    conn->mgr = mgr;
    conn->last_io_time = (time_t) mg_time();
    conn->iface =
        (opts.iface != NULL ? opts.iface : mgr->ifaces[MG_MAIN_IFACE]);
    conn->flags = opts.flags & _MG_ALLOWED_CONNECT_FLAGS_MASK;
    conn->user_data = opts.user_data;
    /*
     * SIZE_MAX is defined as a long long constant in
     * system headers on some platforms and so it
     * doesn't compile with pedantic ansi flags.
     */
    conn->recv_mbuf_limit = ~0;
  } else {
    MG_SET_PTRPTR(opts.error_string, "failed to create connection");
  }
 
  return conn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_destroy_conn()

void mg_destroy_conn	(	struct mg_connection *	conn,
		int	destroy_if
	)

Definition at line 2528 of file mongoose614.cxx.

                                                                 {
  if (conn->sock != INVALID_SOCKET) { /* Don't print timer-only conns */
    LOG(LL_DEBUG, ("%p 0x%lx %d", conn, conn->flags, destroy_if));
  }
  if (destroy_if) conn->iface->vtable->destroy_conn(conn);
  if (conn->proto_data != NULL && conn->proto_data_destructor != NULL) {
    conn->proto_data_destructor(conn->proto_data);
  }
#if MG_ENABLE_SSL
  mg_ssl_if_conn_free(conn);
#endif
  mbuf_free(&conn->recv_mbuf);
  mbuf_free(&conn->send_mbuf);
 
  memset(conn, 0, sizeof(*conn));
  MG_FREE(conn);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_do_connect()

MG_INTERNAL struct mg_connection * mg_do_connect	(	struct mg_connection *	nc,
		int	proto,
		union socket_address *	sa
	)

Definition at line 3155 of file mongoose614.cxx.

                                                                          {
  LOG(LL_DEBUG, ("%p %s://%s:%hu", nc, proto == SOCK_DGRAM ? "udp" : "tcp",
                 inet_ntoa(sa->sin.sin_addr), ntohs(sa->sin.sin_port)));
 
  nc->flags |= MG_F_CONNECTING;
  if (proto == SOCK_DGRAM) {
    nc->iface->vtable->connect_udp(nc);
  } else {
    nc->iface->vtable->connect_tcp(nc, sa);
  }
  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_do_recv()

static int mg_do_recv ( struct mg_connection * nc )

static

Definition at line 2940 of file mongoose614.cxx.

                                                {
  int res = 0;
  char *buf = NULL;
  size_t len = (nc->flags & MG_F_UDP ? MG_UDP_IO_SIZE : MG_TCP_IO_SIZE);
  if ((nc->flags & (MG_F_CLOSE_IMMEDIATELY | MG_F_CONNECTING)) ||
      ((nc->flags & MG_F_LISTENING) && !(nc->flags & MG_F_UDP))) {
    return -1;
  }
  do {
    len = recv_avail_size(nc, len);
    if (len == 0) {
      res = -2;
      break;
    }
    if (nc->recv_mbuf.size < nc->recv_mbuf.len + len) {
      mbuf_resize(&nc->recv_mbuf, nc->recv_mbuf.len + len);
    }
    buf = nc->recv_mbuf.buf + nc->recv_mbuf.len;
    len = nc->recv_mbuf.size - nc->recv_mbuf.len;
    if (nc->flags & MG_F_UDP) {
      res = mg_recv_udp(nc, buf, len);
    } else {
      res = mg_recv_tcp(nc, buf, len);
    }
  } while (res > 0 && !(nc->flags & (MG_F_CLOSE_IMMEDIATELY | MG_F_UDP)));
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_ev_mgr_lwip_process_signals()

void mg_ev_mgr_lwip_process_signals ( struct mg_mgr * mgr )

Definition at line 15962 of file mongoose614.cxx.

                                                        {
  struct mg_ev_mgr_lwip_data *md =
      (struct mg_ev_mgr_lwip_data *) mgr->ifaces[MG_MAIN_IFACE]->data;
  while (md->sig_queue_len > 0) {
    mgos_lock();
    int i = md->start_index;
    int sig = md->sig_queue[i].sig;
    struct mg_connection *nc = md->sig_queue[i].nc;
    struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
    md->start_index = (i + 1) % MG_SIG_QUEUE_LEN;
    md->sig_queue_len--;
    mgos_unlock();
    if (nc->iface == NULL || nc->mgr == NULL) continue;
    switch (sig) {
      case MG_SIG_CONNECT_RESULT: {
        mg_if_connect_cb(nc, cs->err);
        break;
      }
      case MG_SIG_CLOSE_CONN: {
        mg_close_conn(nc);
        break;
      }
      case MG_SIG_RECV: {
        cs->recv_pending = 0;
        mg_if_can_recv_cb(nc);
        mbuf_trim(&nc->recv_mbuf);
        break;
      }
      case MG_SIG_TOMBSTONE: {
        break;
      }
      case MG_SIG_ACCEPT: {
        mg_lwip_handle_accept(nc);
        break;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_find_iface()

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

Definition at line 3643 of file mongoose614.cxx.

                                                      {
  int i = 0;
  if (from != NULL) {
    for (i = 0; i < mgr->num_ifaces; i++) {
      if (mgr->ifaces[i] == from) {
        i++;
        break;
      }
    }
  }
 
  for (; i < mgr->num_ifaces; i++) {
    if (mgr->ifaces[i]->vtable == vtable) {
      return mgr->ifaces[i];
    }
  }
  return NULL;
}

◆ mg_forward()

void mg_forward	(	struct mg_connection *	from,
		struct mg_connection *	to
	)

Definition at line 3507 of file mongoose614.cxx.

                                                                      {
  mg_send(to, from->recv_mbuf.buf, from->recv_mbuf.len);
  mbuf_remove(&from->recv_mbuf, from->recv_mbuf.len);
}

Here is the call graph for this function:

◆ mg_get_errno()

DO_NOT_WARN_UNUSED MG_INTERNAL int mg_get_errno ( void )

Definition at line 10729 of file mongoose614.cxx.

                                                      {
#ifndef WINCE
  return errno;
#else
  /* TODO(alashkin): translate error codes? */
  return GetLastError();
#endif
}

Here is the caller graph for this function:

◆ mg_handle_recv()

static void mg_handle_recv ( struct mg_connection * nc )

static

Definition at line 16386 of file mongoose614.cxx.

                                                     {
  uint16_t bytes_read = 0;
  uint8_t *buf = NULL;
  if (nc->flags & MG_F_UDP) {
    bytes_read = TCPIP_UDP_GetIsReady((UDP_SOCKET) nc->sock);
    if (bytes_read != 0 &&
        (nc->recv_mbuf_limit == -1 ||
         nc->recv_mbuf.len + bytes_read < nc->recv_mbuf_limit)) {
      buf = (uint8_t *) MG_MALLOC(bytes_read);
      if (TCPIP_UDP_ArrayGet((UDP_SOCKET) nc->sock, buf, bytes_read) !=
          bytes_read) {
        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
        bytes_read = 0;
        MG_FREE(buf);
      }
    }
  } else {
    bytes_read = TCPIP_TCP_GetIsReady((TCP_SOCKET) nc->sock);
    if (bytes_read != 0) {
      if (nc->recv_mbuf_limit != -1 &&
          nc->recv_mbuf_limit - nc->recv_mbuf.len > bytes_read) {
        bytes_read = nc->recv_mbuf_limit - nc->recv_mbuf.len;
      }
      buf = (uint8_t *) MG_MALLOC(bytes_read);
      if (TCPIP_TCP_ArrayGet((TCP_SOCKET) nc->sock, buf, bytes_read) !=
          bytes_read) {
        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
        MG_FREE(buf);
        bytes_read = 0;
      }
    }
  }
 
  if (bytes_read != 0) {
    mg_if_recv_tcp_cb(nc, buf, bytes_read, 1 /* own */);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_handle_send()

static void mg_handle_send ( struct mg_connection * nc )

static

Definition at line 16348 of file mongoose614.cxx.

                                                     {
  uint16_t bytes_written = 0;
  if (nc->flags & MG_F_UDP) {
    if (!TCPIP_UDP_RemoteBind(
            (UDP_SOCKET) nc->sock,
            nc->sa.sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4
                                             : IP_ADDRESS_TYPE_IPV6,
            ntohs(nc->sa.sin.sin_port), (IP_MULTI_ADDRESS *) &nc->sa.sin)) {
      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
      return;
    }
    bytes_written = TCPIP_UDP_TxPutIsReady((UDP_SOCKET) nc->sock, 0);
    if (bytes_written >= nc->send_mbuf.len) {
      if (TCPIP_UDP_ArrayPut((UDP_SOCKET) nc->sock,
                             (uint8_t *) nc->send_mbuf.buf,
                             nc->send_mbuf.len) != nc->send_mbuf.len) {
        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
        bytes_written = 0;
      }
    }
  } else {
    bytes_written = TCPIP_TCP_FifoTxFreeGet((TCP_SOCKET) nc->sock);
    if (bytes_written != 0) {
      if (bytes_written > nc->send_mbuf.len) {
        bytes_written = nc->send_mbuf.len;
      }
      if (TCPIP_TCP_ArrayPut((TCP_SOCKET) nc->sock,
                             (uint8_t *) nc->send_mbuf.buf,
                             bytes_written) != bytes_written) {
        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
        bytes_written = 0;
      }
    }
  }
 
  mg_if_sent_cb(nc, bytes_written);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_if_can_recv_cb()

void mg_if_can_recv_cb ( struct mg_connection * nc )

Definition at line 2968 of file mongoose614.cxx.

                                                 {
  mg_do_recv(nc);
}

Here is the caller graph for this function:

◆ mg_if_can_send_cb()

void mg_if_can_send_cb ( struct mg_connection * nc )

Definition at line 3091 of file mongoose614.cxx.

                                                 {
  int n = 0;
  const char *buf = nc->send_mbuf.buf;
  size_t len = nc->send_mbuf.len;
 
  if (nc->flags & (MG_F_CLOSE_IMMEDIATELY | MG_F_CONNECTING)) {
    return;
  }
  if (!(nc->flags & MG_F_UDP)) {
    if (nc->flags & MG_F_LISTENING) return;
    if (len > MG_TCP_IO_SIZE) len = MG_TCP_IO_SIZE;
  }
#if MG_ENABLE_SSL
  if (nc->flags & MG_F_SSL) {
    if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) {
      if (len > 0) {
        n = mg_ssl_if_write(nc, buf, len);
        DBG(("%p -> %d bytes (SSL)", nc, n));
      }
      if (n < 0) {
        if (n == MG_SSL_WANT_WRITE) {
          nc->flags |= MG_F_WANT_WRITE;
          n = 0;
        } else {
          nc->flags |= MG_F_CLOSE_IMMEDIATELY;
        }
      } else {
        nc->flags &= ~MG_F_WANT_WRITE;
      }
    } else {
      mg_ssl_handshake(nc);
    }
  } else
#endif
      if (len > 0) {
    if (nc->flags & MG_F_UDP) {
      n = nc->iface->vtable->udp_send(nc, buf, len);
    } else {
      n = nc->iface->vtable->tcp_send(nc, buf, len);
    }
    DBG(("%p -> %d bytes", nc, n));
  }
 
#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP
  if (n > 0 && nc->mgr && nc->mgr->hexdump_file != NULL) {
    mg_hexdump_connection(nc, nc->mgr->hexdump_file, buf, n, MG_EV_SEND);
  }
#endif
  if (n < 0) {
    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
  } else if (n > 0) {
    nc->last_io_time = (time_t) mg_time();
    mbuf_remove(&nc->send_mbuf, n);
    mbuf_trim(&nc->send_mbuf);
  }
  if (n != 0) mg_call(nc, NULL, nc->user_data, MG_EV_SEND, &n);
}

Here is the caller graph for this function:

◆ mg_if_create_iface()

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

Definition at line 3634 of file mongoose614.cxx.

                                                        {
  struct mg_iface *iface = (struct mg_iface *) MG_CALLOC(1, sizeof(*iface));
  iface->mgr = mgr;
  iface->data = NULL;
  iface->vtable = vtable;
  return iface;
}

Here is the caller graph for this function:

◆ mg_if_poll()

int mg_if_poll	(	struct mg_connection *	nc,
		double	now
	)

Definition at line 2494 of file mongoose614.cxx.

                                                     {
  if (nc->flags & MG_F_CLOSE_IMMEDIATELY) {
    mg_close_conn(nc);
    return 0;
  } else if (nc->flags & MG_F_SEND_AND_CLOSE) {
    if (nc->send_mbuf.len == 0) {
      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
      mg_close_conn(nc);
      return 0;
    }
  } else if (nc->flags & MG_F_RECV_AND_CLOSE) {
    mg_close_conn(nc);
    return 0;
  }
#if MG_ENABLE_SSL
  if ((nc->flags & (MG_F_SSL | MG_F_LISTENING | MG_F_CONNECTING)) == MG_F_SSL) {
    /* SSL library may have data to be delivered to the app in its buffers,
     * drain them. */
    int recved = 0;
    do {
      if (nc->flags & (MG_F_WANT_READ | MG_F_WANT_WRITE)) break;
      if (recv_avail_size(nc, MG_TCP_IO_SIZE) <= 0) break;
      recved = mg_do_recv(nc);
    } while (recved > 0);
  }
#endif /* MG_ENABLE_SSL */
  mg_timer(nc, now);
  {
    time_t now_t = (time_t) now;
    mg_call(nc, NULL, nc->user_data, MG_EV_POLL, &now_t);
  }
  return 1;
}

Here is the caller graph for this function:

◆ mg_is_error() [1/2]

static int mg_is_error ( int n )

static

Definition at line 14475 of file mongoose614.cxx.

                              {
  return (n < 0 && n != SL_ERROR_BSD_EALREADY && n != SL_ERROR_BSD_EAGAIN);
}

◆ mg_is_error() [2/2]

static int mg_is_error ( void )

static

Definition at line 3846 of file mongoose614.cxx.

                             {
  int err = mg_get_errno();
  return err != EINPROGRESS && err != EWOULDBLOCK
#ifndef WINCE
         && err != EAGAIN && err != EINTR
#endif
#ifdef _WIN32
         && WSAGetLastError() != WSAEINTR && WSAGetLastError() != WSAEWOULDBLOCK
#endif
      ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_accept_cb()

static err_t mg_lwip_accept_cb	(	void *	arg,
		struct tcp_pcb *	newtpcb,
		err_t	err
	)

static

Definition at line 15547 of file mongoose614.cxx.

                                                                              {
  struct mg_connection *lc = (struct mg_connection *) arg, *nc;
  struct mg_lwip_conn_state *lcs, *cs;
  struct tcp_pcb_listen *lpcb;
  LOG(LL_DEBUG,
      ("%p conn %p from %s:%u", lc, newtpcb,
       IPADDR_NTOA(ipX_2_ip(&newtpcb->remote_ip)), newtpcb->remote_port));
  if (lc == NULL) {
    tcp_abort(newtpcb);
    return ERR_ABRT;
  }
  lcs = (struct mg_lwip_conn_state *) lc->sock;
  lpcb = (struct tcp_pcb_listen *) lcs->pcb.tcp;
#if TCP_LISTEN_BACKLOG
  tcp_accepted(lpcb);
#endif
  nc = mg_if_accept_new_conn(lc);
  if (nc == NULL) {
    tcp_abort(newtpcb);
    return ERR_ABRT;
  }
  cs = (struct mg_lwip_conn_state *) nc->sock;
  cs->lc = lc;
  cs->pcb.tcp = newtpcb;
  /* We need to set up callbacks before returning because data may start
   * arriving immediately. */
  tcp_arg(newtpcb, nc);
  tcp_err(newtpcb, mg_lwip_tcp_error_cb);
  tcp_sent(newtpcb, mg_lwip_tcp_sent_cb);
  tcp_recv(newtpcb, mg_lwip_tcp_recv_cb);
#if LWIP_TCP_KEEPALIVE
  mg_lwip_set_keepalive_params(nc, 60, 10, 6);
#endif
  mg_lwip_post_signal(MG_SIG_ACCEPT, nc);
  (void) err;
  (void) lpcb;
  return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_handle_accept()

void mg_lwip_handle_accept ( struct mg_connection * nc )

Definition at line 15537 of file mongoose614.cxx.

                                                     {
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  if (cs->pcb.tcp == NULL) return;
  union socket_address sa;
  struct tcp_pcb *tpcb = cs->pcb.tcp;
  SET_ADDR(&sa, &tpcb->remote_ip);
  sa.sin.sin_port = htons(tpcb->remote_port);
  mg_if_accept_tcp_cb(nc, &sa, sizeof(sa.sin));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_if_add_conn()

void mg_lwip_if_add_conn ( struct mg_connection * nc )

Definition at line 16012 of file mongoose614.cxx.

                                                   {
  (void) nc;
}

◆ mg_lwip_if_can_send()

static int mg_lwip_if_can_send	(	struct mg_connection *	nc,
		struct mg_lwip_conn_state *	cs
	)

static

Definition at line 15748 of file mongoose614.cxx.

                                                              {
  int can_send = 0;
  if (nc->send_mbuf.len > 0 || (nc->flags & MG_F_WANT_WRITE)) {
    /* We have stuff to send, but can we? */
    if (nc->flags & MG_F_UDP) {
      /* UDP is always ready for sending. */
      can_send = (cs->pcb.udp != NULL);
    } else {
      can_send = (cs->pcb.tcp != NULL && cs->pcb.tcp->snd_buf > 0);
/* See comment above. */
#if CS_PLATFORM == CS_P_ESP8266
      if (cs->pcb.tcp->unacked != NULL) can_send = 0;
#endif
    }
  }
  return can_send;
}

Here is the caller graph for this function:

◆ mg_lwip_if_connect_tcp()

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

Definition at line 15434 of file mongoose614.cxx.

                                                            {
  struct mg_lwip_if_connect_tcp_ctx ctx = {.nc = nc, .sa = sa};
  tcpip_callback(mg_lwip_if_connect_tcp_tcpip, &ctx);
}

Here is the call graph for this function:

◆ mg_lwip_if_connect_tcp_tcpip()

static void mg_lwip_if_connect_tcp_tcpip ( void * arg )

static

Definition at line 15405 of file mongoose614.cxx.

                                                    {
  struct mg_lwip_if_connect_tcp_ctx *ctx =
      (struct mg_lwip_if_connect_tcp_ctx *) arg;
  struct mg_connection *nc = ctx->nc;
  const union socket_address *sa = ctx->sa;
 
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  struct tcp_pcb *tpcb = TCP_NEW();
  cs->pcb.tcp = tpcb;
  ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr;
  u16_t port = ntohs(sa->sin.sin_port);
  tcp_arg(tpcb, nc);
  tcp_err(tpcb, mg_lwip_tcp_error_cb);
  tcp_sent(tpcb, mg_lwip_tcp_sent_cb);
  tcp_recv(tpcb, mg_lwip_tcp_recv_cb);
  cs->err = TCP_BIND(tpcb, IP_ADDR_ANY, 0 /* any port */);
  DBG(("%p tcp_bind = %d", nc, cs->err));
  if (cs->err != ERR_OK) {
    mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
    return;
  }
  cs->err = tcp_connect(tpcb, ip, port, mg_lwip_tcp_conn_cb);
  DBG(("%p tcp_connect %p = %d", nc, tpcb, cs->err));
  if (cs->err != ERR_OK) {
    mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
    return;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_if_connect_udp()

void mg_lwip_if_connect_udp ( struct mg_connection * nc )

Definition at line 15529 of file mongoose614.cxx.

                                                      {
  tcpip_callback(mg_lwip_if_connect_udp_tcpip, nc);
}

Here is the call graph for this function:

◆ mg_lwip_if_connect_udp_tcpip()

static void mg_lwip_if_connect_udp_tcpip ( void * arg )

static

Definition at line 15514 of file mongoose614.cxx.

                                                    {
  struct mg_connection *nc = (struct mg_connection *) arg;
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  struct udp_pcb *upcb = udp_new();
  cs->err = UDP_BIND(upcb, IP_ADDR_ANY, 0 /* any port */);
  DBG(("%p udp_bind %p = %d", nc, upcb, cs->err));
  if (cs->err == ERR_OK) {
    udp_recv(upcb, mg_lwip_udp_recv_cb, nc);
    cs->pcb.udp = upcb;
  } else {
    udp_remove(upcb);
  }
  mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_if_create_conn()

int mg_lwip_if_create_conn ( struct mg_connection * nc )

Definition at line 15808 of file mongoose614.cxx.

                                                     {
  struct mg_lwip_conn_state *cs =
      (struct mg_lwip_conn_state *) MG_CALLOC(1, sizeof(*cs));
  if (cs == NULL) return 0;
  cs->nc = nc;
  nc->sock = (intptr_t) cs;
  return 1;
}

◆ mg_lwip_if_destroy_conn()

void mg_lwip_if_destroy_conn ( struct mg_connection * nc )

Definition at line 15821 of file mongoose614.cxx.

                                                       {
  if (nc->sock == INVALID_SOCKET) return;
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  if (!(nc->flags & MG_F_UDP)) {
    struct tcp_pcb *tpcb = cs->pcb.tcp;
    if (tpcb != NULL) {
      tcp_arg(tpcb, NULL);
      DBG(("%p tcp_close %p", nc, tpcb));
      tcp_arg(tpcb, NULL);
      tcpip_callback(tcp_close_tcpip, tpcb);
    }
    while (cs->rx_chain != NULL) {
      struct pbuf *seg = cs->rx_chain;
      cs->rx_chain = pbuf_dechain(cs->rx_chain);
      pbuf_free(seg);
    }
    memset(cs, 0, sizeof(*cs));
    MG_FREE(cs);
  } else if (nc->listener == NULL) {
    /* Only close outgoing UDP pcb or listeners. */
    struct udp_pcb *upcb = cs->pcb.udp;
    if (upcb != NULL) {
      DBG(("%p udp_remove %p", nc, upcb));
      tcpip_callback(udp_remove_tcpip, upcb);
    }
    memset(cs, 0, sizeof(*cs));
    MG_FREE(cs);
  }
  nc->sock = INVALID_SOCKET;
}

Here is the call graph for this function:

◆ mg_lwip_if_free()

void mg_lwip_if_free ( struct mg_iface * iface )

Definition at line 16007 of file mongoose614.cxx.

                                             {
  MG_FREE(iface->data);
  iface->data = NULL;
}

◆ mg_lwip_if_get_conn_addr()

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

Definition at line 15852 of file mongoose614.cxx.

                                                        {
  memset(sa, 0, sizeof(*sa));
  if (nc == NULL || nc->sock == INVALID_SOCKET) return;
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  if (nc->flags & MG_F_UDP) {
    struct udp_pcb *upcb = cs->pcb.udp;
    if (remote) {
      memcpy(sa, &nc->sa, sizeof(*sa));
    } else if (upcb != NULL) {
      sa->sin.sin_port = htons(upcb->local_port);
      SET_ADDR(sa, &upcb->local_ip);
    }
  } else {
    struct tcp_pcb *tpcb = cs->pcb.tcp;
    if (remote) {
      memcpy(sa, &nc->sa, sizeof(*sa));
    } else if (tpcb != NULL) {
      sa->sin.sin_port = htons(tpcb->local_port);
      SET_ADDR(sa, &tpcb->local_ip);
    }
  }
}

◆ mg_lwip_if_init()

void mg_lwip_if_init ( struct mg_iface * iface )

Definition at line 16001 of file mongoose614.cxx.

                                             {
  LOG(LL_INFO, ("Mongoose %s, LwIP %u.%u.%u", MG_VERSION, LWIP_VERSION_MAJOR,
                LWIP_VERSION_MINOR, LWIP_VERSION_REVISION));
  iface->data = MG_CALLOC(1, sizeof(struct mg_ev_mgr_lwip_data));
}

◆ mg_lwip_if_listen_tcp()

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

Definition at line 15614 of file mongoose614.cxx.

                                                                              {
  struct mg_lwip_if_listen_ctx ctx = {.nc = nc, .sa = sa};
  tcpip_callback(mg_lwip_if_listen_tcp_tcpip, &ctx);
  return ctx.ret;
}

Here is the call graph for this function:

◆ mg_lwip_if_listen_tcp_tcpip()

static void mg_lwip_if_listen_tcp_tcpip ( void * arg )

static

Definition at line 15592 of file mongoose614.cxx.

                                                   {
  struct mg_lwip_if_listen_ctx *ctx = (struct mg_lwip_if_listen_ctx *) arg;
  struct mg_connection *nc = ctx->nc;
  union socket_address *sa = ctx->sa;
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  struct tcp_pcb *tpcb = TCP_NEW();
  ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr;
  u16_t port = ntohs(sa->sin.sin_port);
  cs->err = TCP_BIND(tpcb, ip, port);
  DBG(("%p tcp_bind(%s:%u) = %d", nc, IPADDR_NTOA(ip), port, cs->err));
  if (cs->err != ERR_OK) {
    tcp_close(tpcb);
    ctx->ret = -1;
    return;
  }
  tcp_arg(tpcb, nc);
  tpcb = tcp_listen(tpcb);
  cs->pcb.tcp = tpcb;
  tcp_accept(tpcb, mg_lwip_accept_cb);
  ctx->ret = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_if_listen_udp()

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

Definition at line 15640 of file mongoose614.cxx.

                                                                              {
  struct mg_lwip_if_listen_ctx ctx = {.nc = nc, .sa = sa};
  tcpip_callback(mg_lwip_if_listen_udp_tcpip, &ctx);
  return ctx.ret;
}

Here is the call graph for this function:

◆ mg_lwip_if_listen_udp_tcpip()

static void mg_lwip_if_listen_udp_tcpip ( void * arg )

static

Definition at line 15620 of file mongoose614.cxx.

                                                   {
  struct mg_lwip_if_listen_ctx *ctx = (struct mg_lwip_if_listen_ctx *) arg;
  struct mg_connection *nc = ctx->nc;
  union socket_address *sa = ctx->sa;
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  struct udp_pcb *upcb = udp_new();
  ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr;
  u16_t port = ntohs(sa->sin.sin_port);
  cs->err = UDP_BIND(upcb, ip, port);
  DBG(("%p udb_bind(%s:%u) = %d", nc, IPADDR_NTOA(ip), port, cs->err));
  if (cs->err != ERR_OK) {
    udp_remove(upcb);
    ctx->ret = -1;
  } else {
    udp_recv(upcb, mg_lwip_udp_recv_cb, nc);
    cs->pcb.udp = upcb;
    ctx->ret = 0;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_if_poll()

time_t mg_lwip_if_poll	(	struct mg_iface *	iface,
		int	timeout_ms
	)

Definition at line 16027 of file mongoose614.cxx.

                                                               {
  struct mg_mgr *mgr = iface->mgr;
  int n = 0;
  double now = mg_time();
  struct mg_connection *nc, *tmp;
  double min_timer = 0;
  int num_timers = 0;
#if 0
  DBG(("begin poll @%u", (unsigned int) (now * 1000)));
#endif
  mg_ev_mgr_lwip_process_signals(mgr);
  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
    struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
    tmp = nc->next;
    n++;
    if (!mg_if_poll(nc, now)) continue;
    if (nc->sock != INVALID_SOCKET &&
        !(nc->flags & (MG_F_UDP | MG_F_LISTENING)) && cs->pcb.tcp != NULL &&
        cs->pcb.tcp->unsent != NULL) {
      tcpip_callback(tcp_output_tcpip, cs->pcb.tcp);
    }
    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 (nc->sock != INVALID_SOCKET) {
      if (mg_lwip_if_can_send(nc, cs)) {
        mg_if_can_send_cb(nc);
        mbuf_trim(&nc->send_mbuf);
      }
      if (cs->rx_chain != NULL) {
        mg_if_can_recv_cb(nc);
      } else if (cs->draining_rx_chain) {
        /*
         * If the connection is about to close, and rx_chain is finally empty,
         * send the MG_SIG_CLOSE_CONN signal
         */
        mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc);
      }
    }
  }
#if 0
  DBG(("end poll @%u, %d conns, %d timers (min %u), next in %d ms",
       (unsigned int) (now * 1000), n, num_timers,
       (unsigned int) (min_timer * 1000), timeout_ms));
#endif
  (void) timeout_ms;
  return now;
}

Here is the call graph for this function:

◆ mg_lwip_if_remove_conn()

void mg_lwip_if_remove_conn ( struct mg_connection * nc )

Definition at line 16016 of file mongoose614.cxx.

                                                      {
  struct mg_ev_mgr_lwip_data *md =
      (struct mg_ev_mgr_lwip_data *) nc->iface->data;
  /* Walk the queue and null-out further signals for this conn. */
  for (int i = 0; i < MG_SIG_QUEUE_LEN; i++) {
    if (md->sig_queue[i].nc == nc) {
      md->sig_queue[i].sig = MG_SIG_TOMBSTONE;
    }
  }
}

◆ mg_lwip_if_sock_set()

void mg_lwip_if_sock_set	(	struct mg_connection *	nc,
		sock_t	sock
	)

Definition at line 15876 of file mongoose614.cxx.

                                                                {
  nc->sock = sock;
}

◆ mg_lwip_if_tcp_recv()

static int mg_lwip_if_tcp_recv	(	struct mg_connection *	nc,
		void *	buf,
		size_t	len
	)

static

Definition at line 15777 of file mongoose614.cxx.

                                           {
  int res = 0;
  char *bufp = buf;
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  if (nc->sock == INVALID_SOCKET) return -1;
  mgos_lock();
  while (cs->rx_chain != NULL && len > 0) {
    struct pbuf *seg = cs->rx_chain;
    size_t seg_len = (seg->len - cs->rx_offset);
    size_t copy_len = MIN(len, seg_len);
 
    pbuf_copy_partial(seg, bufp, copy_len, cs->rx_offset);
    len -= copy_len;
    res += copy_len;
    bufp += copy_len;
    cs->rx_offset += copy_len;
    if (cs->rx_offset == cs->rx_chain->len) {
      cs->rx_chain = pbuf_dechain(cs->rx_chain);
      pbuf_free(seg);
      cs->rx_offset = 0;
    }
  }
  mgos_unlock();
  if (res > 0) {
    struct tcp_recved_ctx ctx = {.tpcb = cs->pcb.tcp, .len = res};
    tcpip_callback(tcp_recved_tcpip, &ctx);
  }
  return res;
}

Here is the call graph for this function:

◆ mg_lwip_if_tcp_send()

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

Definition at line 15703 of file mongoose614.cxx.

                                                                               {
  struct mg_lwip_tcp_write_ctx ctx = {.nc = nc, .data = buf, .len = len};
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  if (nc->sock == INVALID_SOCKET) return -1;
  struct tcp_pcb *tpcb = cs->pcb.tcp;
  if (tpcb == NULL) return -1;
  if (tpcb->snd_buf <= 0) return 0;
  tcpip_callback(mg_lwip_tcp_write_tcpip, &ctx);
  return ctx.ret;
}

Here is the call graph for this function:

◆ mg_lwip_if_udp_recv()

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

static

Definition at line 15490 of file mongoose614.cxx.

                                                                         {
  /*
   * For UDP, RX chain consists of interleaved address and packet bufs:
   * Address pbuf followed by exactly one data pbuf (recv_cb took care of that).
   */
  int res = 0;
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  if (nc->sock == INVALID_SOCKET) return -1;
  mgos_lock();
  if (cs->rx_chain != NULL) {
    struct pbuf *ap = cs->rx_chain;
    struct pbuf *dp = ap->next;
    cs->rx_chain = pbuf_dechain(dp);
    res = MIN(dp->len, len);
    pbuf_copy_partial(dp, buf, res, 0);
    pbuf_free(dp);
    pbuf_copy_partial(ap, sa, MIN(*sa_len, ap->len), 0);
    pbuf_free(ap);
  }
  mgos_unlock();
  return res;
}

◆ mg_lwip_if_udp_send()

static int mg_lwip_if_udp_send	(	struct mg_connection *	nc,
		const void *	data,
		size_t	len
	)

static

Definition at line 15727 of file mongoose614.cxx.

                                           {
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  if (nc->sock == INVALID_SOCKET || cs->pcb.udp == NULL) return -1;
  struct udp_pcb *upcb = cs->pcb.udp;
  struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
#if defined(LWIP_IPV4) && LWIP_IPV4 && defined(LWIP_IPV6) && LWIP_IPV6
  ip_addr_t ip = {.u_addr.ip4.addr = nc->sa.sin.sin_addr.s_addr, .type = 0};
#else
  ip_addr_t ip = {.addr = nc->sa.sin.sin_addr.s_addr};
#endif
  u16_t port = ntohs(nc->sa.sin.sin_port);
  if (p == NULL) return 0;
  memcpy(p->payload, data, len);
  struct udp_sendto_ctx ctx = {.upcb = upcb, .p = p, .ip = &ip, .port = port};
  tcpip_callback(udp_sendto_tcpip, &ctx);
  cs->err = ctx.ret;
  pbuf_free(p);
  return (cs->err == ERR_OK ? (int) len : -2);
}

Here is the call graph for this function:

◆ mg_lwip_mgr_schedule_poll()

void mg_lwip_mgr_schedule_poll ( struct mg_mgr * mgr )

Here is the caller graph for this function:

◆ mg_lwip_post_signal()

void mg_lwip_post_signal	(	enum mg_sig_type	sig,
		struct mg_connection *	nc
	)

Definition at line 15946 of file mongoose614.cxx.

                                                                         {
  struct mg_ev_mgr_lwip_data *md =
      (struct mg_ev_mgr_lwip_data *) nc->iface->data;
  mgos_lock();
  if (md->sig_queue_len >= MG_SIG_QUEUE_LEN) {
    mgos_unlock();
    return;
  }
  int end_index = (md->start_index + md->sig_queue_len) % MG_SIG_QUEUE_LEN;
  md->sig_queue[end_index].sig = sig;
  md->sig_queue[end_index].nc = nc;
  md->sig_queue_len++;
  mg_lwip_mgr_schedule_poll(nc->mgr);
  mgos_unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_recv_common()

static void mg_lwip_recv_common	(	struct mg_connection *	nc,
		struct pbuf *	p
	)

static

Definition at line 15477 of file mongoose614.cxx.

                                                                          {
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  if (cs->rx_chain == NULL) {
    cs->rx_chain = p;
  } else {
    pbuf_chain(cs->rx_chain, p);
  }
  if (!cs->recv_pending) {
    cs->recv_pending = 1;
    mg_lwip_post_signal(MG_SIG_RECV, nc);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_tcp_conn_cb()

static err_t mg_lwip_tcp_conn_cb	(	void *	arg,
		struct tcp_pcb *	tpcb,
		err_t	err
	)

static

Definition at line 15299 of file mongoose614.cxx.

                                                                             {
  struct mg_connection *nc = (struct mg_connection *) arg;
  DBG(("%p connect to %s:%u = %d", nc, IPADDR_NTOA(ipX_2_ip(&tpcb->remote_ip)),
       tpcb->remote_port, err));
  if (nc == NULL) {
    tcp_abort(tpcb);
    return ERR_ARG;
  }
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  cs->err = err;
#if LWIP_TCP_KEEPALIVE
  if (err == 0) mg_lwip_set_keepalive_params(nc, 60, 10, 6);
#endif
  mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
  return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_tcp_error_cb()

static void mg_lwip_tcp_error_cb	(	void *	arg,
		err_t	err
	)

static

Definition at line 15316 of file mongoose614.cxx.

                                                       {
  struct mg_connection *nc = (struct mg_connection *) arg;
  DBG(("%p conn error %d", nc, err));
  if (nc == NULL || (nc->flags & MG_F_CLOSE_IMMEDIATELY)) return;
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  cs->pcb.tcp = NULL; /* Has already been deallocated */
  if (nc->flags & MG_F_CONNECTING) {
    cs->err = err;
    mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
  } else {
    mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_tcp_recv_cb()

static err_t mg_lwip_tcp_recv_cb	(	void *	arg,
		struct tcp_pcb *	tpcb,
		struct pbuf *	p,
		err_t	err
	)

static

Definition at line 15330 of file mongoose614.cxx.

                                                            {
  struct mg_connection *nc = (struct mg_connection *) arg;
  struct mg_lwip_conn_state *cs =
      (nc ? (struct mg_lwip_conn_state *) nc->sock : NULL);
  DBG(("%p %p %p %p %u %d", nc, cs, tpcb, p, (p != NULL ? p->tot_len : 0),
       err));
  if (p == NULL) {
    if (nc != NULL && !(nc->flags & MG_F_CLOSE_IMMEDIATELY)) {
      if (cs->rx_chain != NULL) {
        /*
         * rx_chain still contains non-consumed data, don't close the
         * connection
         */
        cs->draining_rx_chain = 1;
      } else {
        mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc);
      }
    } else {
      /* Tombstoned connection, do nothing. */
    }
    return ERR_OK;
  } else if (nc == NULL) {
    tcp_abort(tpcb);
    return ERR_ARG;
  }
  /*
   * If we get a chain of more than one segment at once, we need to bump
   * refcount on the subsequent bufs to make them independent.
   */
  if (p->next != NULL) {
    struct pbuf *q = p->next;
    for (; q != NULL; q = q->next) pbuf_ref(q);
  }
  mgos_lock();
  if (cs->rx_chain == NULL) {
    cs->rx_offset = 0;
  } else if (pbuf_clen(cs->rx_chain) >= 4) {
    /* ESP SDK has a limited pool of 5 pbufs. We must not hog them all or RX
     * will be completely blocked. We already have at least 4 in the chain,
     * this one is the last, so we have to make a copy and release this one. */
    struct pbuf *np = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);
    if (np != NULL) {
      pbuf_copy(np, p);
      pbuf_free(p);
      p = np;
    }
  }
  mg_lwip_recv_common(nc, p);
  mgos_unlock();
  (void) err;
  return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_tcp_sent_cb()

static err_t mg_lwip_tcp_sent_cb	(	void *	arg,
		struct tcp_pcb *	tpcb,
		u16_t	num_sent
	)

static

Definition at line 15384 of file mongoose614.cxx.

                                                 {
  struct mg_connection *nc = (struct mg_connection *) arg;
  DBG(("%p %p %u %p %p", nc, tpcb, num_sent, tpcb->unsent, tpcb->unacked));
  if (nc == NULL) return ERR_OK;
  if ((nc->flags & MG_F_SEND_AND_CLOSE) && !(nc->flags & MG_F_WANT_WRITE) &&
      nc->send_mbuf.len == 0 && tpcb->unsent == NULL && tpcb->unacked == NULL) {
    mg_lwip_post_signal(MG_SIG_CLOSE_CONN, nc);
  }
  if (nc->send_mbuf.len > 0 || (nc->flags & MG_F_WANT_WRITE)) {
    mg_lwip_mgr_schedule_poll(nc->mgr);
  }
  (void) num_sent;
  return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_tcp_write_tcpip()

static void mg_lwip_tcp_write_tcpip ( void * arg )

static

Definition at line 15657 of file mongoose614.cxx.

                                               {
  struct mg_lwip_tcp_write_ctx *ctx = (struct mg_lwip_tcp_write_ctx *) arg;
  struct mg_connection *nc = ctx->nc;
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  struct tcp_pcb *tpcb = cs->pcb.tcp;
  size_t len = MIN(tpcb->mss, MIN(ctx->len, tpcb->snd_buf));
  size_t unsent, unacked;
  if (len == 0) {
    DBG(("%p no buf avail %u %u %p %p", tpcb, tpcb->snd_buf, tpcb->snd_queuelen,
         tpcb->unsent, tpcb->unacked));
    tcpip_callback(tcp_output_tcpip, tpcb);
    ctx->ret = 0;
    return;
  }
  unsent = (tpcb->unsent != NULL ? tpcb->unsent->len : 0);
  unacked = (tpcb->unacked != NULL ? tpcb->unacked->len : 0);
/*
 * On ESP8266 we only allow one TCP segment in flight at any given time.
 * This may increase latency and reduce efficiency of tcp windowing,
 * but memory is scarce and precious on that platform so we do this to
 * reduce footprint.
 */
#if CS_PLATFORM == CS_P_ESP8266
  if (unacked > 0) {
    ctx->ret = 0;
    return;
  }
  len = MIN(len, (TCP_MSS - unsent));
#endif
  cs->err = tcp_write(tpcb, ctx->data, len, TCP_WRITE_FLAG_COPY);
  unsent = (tpcb->unsent != NULL ? tpcb->unsent->len : 0);
  unacked = (tpcb->unacked != NULL ? tpcb->unacked->len : 0);
  DBG(("%p tcp_write %u = %d, %u %u", tpcb, len, cs->err, unsent, unacked));
  if (cs->err != ERR_OK) {
    /*
     * We ignore ERR_MEM because memory will be freed up when the data is sent
     * and we'll retry.
     */
    ctx->ret = (cs->err == ERR_MEM ? 0 : -1);
    return;
  }
  ctx->ret = len;
  (void) unsent;
  (void) unacked;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_lwip_udp_recv_cb()

static void mg_lwip_udp_recv_cb	(	void *	arg,
		struct udp_pcb *	pcb,
		struct pbuf *	p,
		ip_addr_t *	addr,
		u16_t	port
	)

static

Definition at line 15448 of file mongoose614.cxx.

{
  struct mg_connection *nc = (struct mg_connection *) arg;
  DBG(("%p %s:%u %p %u %u", nc, IPADDR_NTOA(addr), port, p, p->ref, p->len));
  /* Put address in a separate pbuf and tack it onto the packet. */
  struct pbuf *sap =
      pbuf_alloc(PBUF_RAW, sizeof(union socket_address), PBUF_RAM);
  if (sap == NULL) {
    pbuf_free(p);
    return;
  }
  union socket_address *sa = (union socket_address *) sap->payload;
#if ((LWIP_VERSION_MAJOR << 8) | LWIP_VERSION_MINOR) >= 0x0105
  sa->sin.sin_addr.s_addr = ip_2_ip4(addr)->addr;
#else
  sa->sin.sin_addr.s_addr = addr->addr;
#endif
  sa->sin.sin_port = htons(port);
  /* Logic in the recv handler requires that there be exactly one data pbuf. */
  p = pbuf_coalesce(p, PBUF_RAW);
  pbuf_chain(sap, p);
  mgos_lock();
  mg_lwip_recv_common(nc, sap);
  mgos_unlock();
  (void) pcb;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_mbuf_append_base64()

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

Definition at line 10743 of file mongoose614.cxx.

                                                                            {
  struct cs_base64_ctx ctx;
  cs_base64_init(&ctx, mg_mbuf_append_base64_putc, mbuf);
  cs_base64_update(&ctx, (const char *) data, len);
  cs_base64_finish(&ctx);
}

◆ mg_mbuf_append_base64_putc()

void mg_mbuf_append_base64_putc	(	char	ch,
		void *	user_data
	)

Definition at line 10738 of file mongoose614.cxx.

                                                          {
  struct mbuf *mbuf = (struct mbuf *) user_data;
  mbuf_append(mbuf, &ch, sizeof(ch));
}

Here is the caller graph for this function:

◆ mg_mgr_handle_conn()

void mg_mgr_handle_conn	(	struct mg_connection *	nc,
		int	fd_flags,
		double	now
	)

Definition at line 4038 of file mongoose614.cxx.

                                                                            {
  int worth_logging =
      fd_flags != 0 || (nc->flags & (MG_F_WANT_READ | MG_F_WANT_WRITE));
  if (worth_logging) {
    DBG(("%p fd=%d fd_flags=%d nc_flags=0x%lx rmbl=%d smbl=%d", nc, nc->sock,
         fd_flags, nc->flags, (int) nc->recv_mbuf.len,
         (int) nc->send_mbuf.len));
  }
 
  if (!mg_if_poll(nc, now)) return;
 
  if (nc->flags & MG_F_CONNECTING) {
    if (fd_flags != 0) {
      int err = 0;
#if !defined(MG_ESP8266)
      if (!(nc->flags & MG_F_UDP)) {
        socklen_t len = sizeof(err);
        int ret =
            getsockopt(nc->sock, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
        if (ret != 0) {
          err = 1;
        } else if (err == EAGAIN || err == EWOULDBLOCK) {
          err = 0;
        }
      }
#else
      /*
       * On ESP8266 we use blocking connect.
       */
      err = nc->err;
#endif
      mg_if_connect_cb(nc, err);
    } else if (nc->err != 0) {
      mg_if_connect_cb(nc, nc->err);
    }
  }
 
  if (fd_flags & _MG_F_FD_CAN_READ) {
    if (nc->flags & MG_F_UDP) {
      mg_if_can_recv_cb(nc);
    } else {
      if (nc->flags & MG_F_LISTENING) {
        /*
         * We're not looping here, and accepting just one connection at
         * a time. The reason is that eCos does not respect non-blocking
         * flag on a listening socket and hangs in a loop.
         */
        mg_accept_conn(nc);
      } else {
        mg_if_can_recv_cb(nc);
      }
    }
  }
 
  if (fd_flags & _MG_F_FD_CAN_WRITE) mg_if_can_send_cb(nc);
 
  if (worth_logging) {
    DBG(("%p after fd=%d nc_flags=0x%lx rmbl=%d smbl=%d", nc, nc->sock,
         nc->flags, (int) nc->recv_mbuf.len, (int) nc->send_mbuf.len));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_mgr_init_opt()

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

Definition at line 2576 of file mongoose614.cxx.

                                                   {
  memset(m, 0, sizeof(*m));
#if MG_ENABLE_BROADCAST
  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
 
  {
    int i;
    if (opts.num_ifaces == 0) {
      opts.num_ifaces = mg_num_ifaces;
      opts.ifaces = mg_ifaces;
    }
    if (opts.main_iface != NULL) {
      opts.ifaces[MG_MAIN_IFACE] = opts.main_iface;
    }
    m->num_ifaces = opts.num_ifaces;
    m->ifaces =
        (struct mg_iface **) MG_MALLOC(sizeof(*m->ifaces) * opts.num_ifaces);
    for (i = 0; i < opts.num_ifaces; i++) {
      m->ifaces[i] = mg_if_create_iface(opts.ifaces[i], m);
      m->ifaces[i]->vtable->init(m->ifaces[i]);
    }
  }
  if (opts.nameserver != NULL) {
    m->nameserver = strdup(opts.nameserver);
  }
  DBG(("=================================="));
  DBG(("init mgr=%p", m));
#if MG_ENABLE_SSL
  {
    static int init_done;
    if (!init_done) {
      mg_ssl_if_init();
      init_done++;
    }
  }
#endif
}

Here is the caller graph for this function:

◆ mg_mgr_min_timer()

double mg_mgr_min_timer ( const struct mg_mgr * mgr )

Definition at line 3664 of file mongoose614.cxx.

                                                  {
  double min_timer = 0;
  struct mg_connection *nc;
  for (nc = mgr->active_connections; nc != NULL; nc = nc->next) {
    if (nc->ev_timer_time <= 0) continue;
    if (min_timer == 0 || nc->ev_timer_time < min_timer) {
      min_timer = nc->ev_timer_time;
    }
  }
  return min_timer;
}

◆ mg_mk_str_n()

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

Definition at line 1701 of file mongoose614.cxx.

                                                     {
  struct mg_str ret = {s, len};
  return ret;
}

Here is the caller graph for this function:

◆ mg_next_comma_list_entry_n()

struct mg_str mg_next_comma_list_entry_n	(	struct mg_str	list,
		struct mg_str *	val,
		struct mg_str *	eq_val
	)

Definition at line 2271 of file mongoose614.cxx.

                                                                {
  if (list.len == 0) {
    /* End of the list */
    list = mg_mk_str(NULL);
  } else {
    const char *chr = NULL;
    *val = list;
 
    if ((chr = mg_strchr(*val, ',')) != NULL) {
      /* Comma found. Store length and shift the list ptr */
      val->len = chr - val->p;
      chr++;
      list.len -= (chr - list.p);
      list.p = chr;
    } else {
      /* This value is the last one */
      list = mg_mk_str_n(list.p + list.len, 0);
    }
 
    if (eq_val != NULL) {
      /* Value has form "x=y", adjust pointers and lengths */
      /* so that val points to "x", and eq_val points to "y". */
      eq_val->len = 0;
      eq_val->p = (const char *) memchr(val->p, '=', val->len);
      if (eq_val->p != NULL) {
        eq_val->p++; /* Skip over '=' character */
        eq_val->len = val->p + val->len - eq_val->p;
        val->len = (eq_val->p - val->p) - 1;
      }
    }
  }
 
  return list;
}

Here is the caller graph for this function:

◆ mg_null_if_add_conn()

static void mg_null_if_add_conn ( struct mg_connection * c )

static

Definition at line 3775 of file mongoose614.cxx.

                                                         {
  c->sock = INVALID_SOCKET;
  c->flags |= MG_F_CLOSE_IMMEDIATELY;
}

◆ mg_null_if_connect_tcp()

static void mg_null_if_connect_tcp	(	struct mg_connection *	c,
		const union socket_address *	sa
	)

static

Definition at line 3696 of file mongoose614.cxx.

                                                                   {
  c->flags |= MG_F_CLOSE_IMMEDIATELY;
  (void) sa;
}

◆ mg_null_if_connect_udp()

static void mg_null_if_connect_udp ( struct mg_connection * c )

static

Definition at line 3702 of file mongoose614.cxx.

                                                            {
  c->flags |= MG_F_CLOSE_IMMEDIATELY;
}

◆ mg_null_if_create_conn()

static int mg_null_if_create_conn ( struct mg_connection * c )

static

Definition at line 3753 of file mongoose614.cxx.

◆ mg_null_if_destroy_conn()

static void mg_null_if_destroy_conn ( struct mg_connection * c )

static

Definition at line 3758 of file mongoose614.cxx.

                                                             {
  (void) c;
}

◆ mg_null_if_free()

static void mg_null_if_free ( struct mg_iface * iface )

static

Definition at line 3771 of file mongoose614.cxx.

                                                    {
  (void) iface;
}

◆ mg_null_if_get_conn_addr()

static void mg_null_if_get_conn_addr	(	struct mg_connection *	c,
		int	remote,
		union socket_address *	sa
	)

static

Definition at line 3797 of file mongoose614.cxx.

                                                               {
  (void) c;
  (void) remote;
  (void) sa;
}

◆ mg_null_if_init()

static void mg_null_if_init ( struct mg_iface * iface )

static

Definition at line 3767 of file mongoose614.cxx.

                                                    {
  (void) iface;
}

◆ mg_null_if_listen_tcp()

static int mg_null_if_listen_tcp	(	struct mg_connection *	c,
		union socket_address *	sa
	)

static

Definition at line 3706 of file mongoose614.cxx.

                                                           {
  (void) c;
  (void) sa;
  return -1;
}

◆ mg_null_if_listen_udp()

static int mg_null_if_listen_udp	(	struct mg_connection *	c,
		union socket_address *	sa
	)

static

Definition at line 3713 of file mongoose614.cxx.

                                                           {
  (void) c;
  (void) sa;
  return -1;
}

◆ mg_null_if_poll()

static time_t mg_null_if_poll	(	struct mg_iface *	iface,
		int	timeout_ms
	)

static

Definition at line 3784 of file mongoose614.cxx.

                                                                      {
  struct mg_mgr *mgr = iface->mgr;
  struct mg_connection *nc, *tmp;
  double now = mg_time();
  /* We basically just run timers and poll. */
  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
    tmp = nc->next;
    mg_if_poll(nc, now);
  }
  (void) timeout_ms;
  return (time_t) now;
}

Here is the call graph for this function:

◆ mg_null_if_remove_conn()

static void mg_null_if_remove_conn ( struct mg_connection * c )

static

Definition at line 3780 of file mongoose614.cxx.

                                                            {
  (void) c;
}

◆ mg_null_if_sock_set()

static void mg_null_if_sock_set	(	struct mg_connection *	c,
		sock_t	sock
	)

static

Definition at line 3762 of file mongoose614.cxx.

                                                                      {
  (void) c;
  (void) sock;
}

◆ mg_null_if_tcp_recv()

int mg_null_if_tcp_recv	(	struct mg_connection *	c,
		void *	buf,
		size_t	len
	)

Definition at line 3736 of file mongoose614.cxx.

                                                                        {
  (void) c;
  (void) buf;
  (void) len;
  return -1;
}

◆ mg_null_if_tcp_send()

static int mg_null_if_tcp_send	(	struct mg_connection *	c,
		const void *	buf,
		size_t	len
	)

static

Definition at line 3720 of file mongoose614.cxx.

                                           {
  (void) c;
  (void) buf;
  (void) len;
  return -1;
}

◆ mg_null_if_udp_recv()

int mg_null_if_udp_recv	(	struct mg_connection *	c,
		void *	buf,
		size_t	len,
		union socket_address *	sa,
		size_t *	sa_len
	)

Definition at line 3743 of file mongoose614.cxx.

                                                                  {
  (void) c;
  (void) buf;
  (void) len;
  (void) sa;
  (void) sa_len;
  return -1;
}

◆ mg_null_if_udp_send()

static int mg_null_if_udp_send	(	struct mg_connection *	c,
		const void *	buf,
		size_t	len
	)

static

Definition at line 3728 of file mongoose614.cxx.

                                           {
  (void) c;
  (void) buf;
  (void) len;
  return -1;
}

◆ mg_open_listening_socket() [1/2]

static sock_t mg_open_listening_socket	(	struct mg_connection *	nc,
		union socket_address *	sa,
		int	type,
		int	proto
	)

static

Definition at line 14600 of file mongoose614.cxx.

                                                  {
  int r;
  socklen_t sa_len =
      (sa->sa.sa_family == AF_INET) ? sizeof(sa->sin) : sizeof(sa->sin6);
  sock_t sock = sl_Socket(sa->sa.sa_family, type, proto);
  if (sock < 0) return sock;
#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK
  if ((r = sl_set_ssl_opts(sock, nc)) < 0) goto clean;
#endif
  if ((r = sl_Bind(sock, &sa->sa, sa_len)) < 0) goto clean;
  if (type != SOCK_DGRAM) {
    if ((r = sl_Listen(sock, SOMAXCONN)) < 0) goto clean;
  }
  mg_set_non_blocking_mode(sock);
clean:
  if (r < 0) {
    sl_Close(sock);
    sock = r;
  }
  return sock;
}

Here is the call graph for this function:

◆ mg_open_listening_socket() [2/2]

static sock_t mg_open_listening_socket	(	union socket_address *	sa,
		int	type,
		int	proto
	)

static

Definition at line 3988 of file mongoose614.cxx.

                                                  {
  socklen_t sa_len =
      (sa->sa.sa_family == AF_INET) ? sizeof(sa->sin) : sizeof(sa->sin6);
  sock_t sock = INVALID_SOCKET;
#if !MG_LWIP
  int on = 1;
#endif
 
  if ((sock = socket(sa->sa.sa_family, type, proto)) != INVALID_SOCKET &&
#if !MG_LWIP /* LWIP doesn't support either */
#if defined(_WIN32) && defined(SO_EXCLUSIVEADDRUSE) && !defined(WINCE)
      /* "Using SO_REUSEADDR and SO_EXCLUSIVEADDRUSE" http://goo.gl/RmrFTm */
      !setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (void *) &on,
                  sizeof(on)) &&
#endif
 
#if !defined(_WIN32) || !defined(SO_EXCLUSIVEADDRUSE)
      /*
       * SO_RESUSEADDR is not enabled on Windows because the semantics of
       * SO_REUSEADDR on UNIX and Windows is different. On Windows,
       * SO_REUSEADDR allows to bind a socket to a port without error even if
       * the port is already open by another program. This is not the behavior
       * SO_REUSEADDR was designed for, and leads to hard-to-track failure
       * scenarios. Therefore, SO_REUSEADDR was disabled on Windows unless
       * SO_EXCLUSIVEADDRUSE is supported and set on a socket.
       */
      !setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *) &on, sizeof(on)) &&
#endif
#endif /* !MG_LWIP */
 
      !bind(sock, &sa->sa, sa_len) &&
      (type == SOCK_DGRAM || listen(sock, SOMAXCONN) == 0)) {
#if !MG_LWIP
    mg_set_non_blocking_mode(sock);
    /* In case port was set to 0, get the real port number */
    (void) getsockname(sock, &sa->sa, &sa_len);
#endif
  } else if (sock != INVALID_SOCKET) {
    closesocket(sock);
    sock = INVALID_SOCKET;
  }
 
  return sock;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_parse_address()

MG_INTERNAL int mg_parse_address	(	const char *	str,
		union socket_address *	sa,
		int *	proto,
		char *	host,
		size_t	host_len
	)

Definition at line 2787 of file mongoose614.cxx.

                                                                          {
  unsigned int a, b, c, d, port = 0;
  int ch, len = 0;
#if MG_ENABLE_IPV6
  char buf[100];
#endif
 
  /*
   * MacOS needs that. If we do not zero it, subsequent bind() will fail.
   * Also, all-zeroes in the socket address means binding to all addresses
   * for both IPv4 and IPv6 (INADDR_ANY and IN6ADDR_ANY_INIT).
   */
  memset(sa, 0, sizeof(*sa));
  sa->sin.sin_family = AF_INET;
 
  *proto = SOCK_STREAM;
 
  if (strncmp(str, "udp://", 6) == 0) {
    str += 6;
    *proto = SOCK_DGRAM;
  } else if (strncmp(str, "tcp://", 6) == 0) {
    str += 6;
  }
 
  if (sscanf(str, "%u.%u.%u.%u:%u%n", &a, &b, &c, &d, &port, &len) == 5) {
    /* Bind to a specific IPv4 address, e.g. 192.168.1.5:8080 */
    sa->sin.sin_addr.s_addr =
        htonl(((uint32_t) a << 24) | ((uint32_t) b << 16) | c << 8 | d);
    sa->sin.sin_port = htons((uint16_t) port);
#if MG_ENABLE_IPV6
  } else if (sscanf(str, "[%99[^]]]:%u%n", buf, &port, &len) == 2 &&
             inet_pton(AF_INET6, buf, &sa->sin6.sin6_addr)) {
    /* IPv6 address, e.g. [3ffe:2a00:100:7031::1]:8080 */
    sa->sin6.sin6_family = AF_INET6;
    sa->sin.sin_port = htons((uint16_t) port);
#endif
#if MG_ENABLE_ASYNC_RESOLVER
  } else if (strlen(str) < host_len &&
             sscanf(str, "%[^ :]:%u%n", host, &port, &len) == 2) {
    sa->sin.sin_port = htons((uint16_t) port);
    if (mg_resolve_from_hosts_file(host, sa) != 0) {
      /*
       * if resolving from hosts file failed and the host
       * we are trying to resolve is `localhost` - we should
       * try to resolve it using `gethostbyname` and do not try
       * to resolve it via DNS server if gethostbyname has failed too
       */
      if (mg_ncasecmp(host, "localhost", 9) != 0) {
        return 0;
      }
 
#if MG_ENABLE_SYNC_RESOLVER
      if (!mg_resolve2(host, &sa->sin.sin_addr)) {
        return -1;
      }
#else
      return -1;
#endif
    }
#endif
  } else if (sscanf(str, ":%u%n", &port, &len) == 1 ||
             sscanf(str, "%u%n", &port, &len) == 1) {
    /* If only port is specified, bind to IPv4, INADDR_ANY */
    sa->sin.sin_port = htons((uint16_t) port);
  } else {
    return -1;
  }
 
  /* Required for MG_ENABLE_ASYNC_RESOLVER=0 */
  (void) host;
  (void) host_len;
 
  ch = str[len]; /* Character that follows the address */
  return port < 0xffffUL && (ch == '\0' || ch == ',' || isspace(ch)) ? len : -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_pic32_if_add_conn()

void mg_pic32_if_add_conn ( struct mg_connection * nc )

Definition at line 16242 of file mongoose614.cxx.

                                                    {
  (void) nc;
}

◆ mg_pic32_if_connect_tcp()

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

Definition at line 16475 of file mongoose614.cxx.

                                                             {
  nc->sock = TCPIP_TCP_ClientOpen(
      sa->sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4
                                    : IP_ADDRESS_TYPE_IPV6,
      ntohs(sa->sin.sin_port), (IP_MULTI_ADDRESS *) &sa->sin);
  nc->err = (nc->sock == INVALID_SOCKET) ? -1 : 0;
}

◆ mg_pic32_if_connect_udp()

void mg_pic32_if_connect_udp ( struct mg_connection * nc )

Definition at line 16484 of file mongoose614.cxx.

                                                       {
  nc->sock = TCPIP_UDP_ClientOpen(IP_ADDRESS_TYPE_ANY, 0, NULL);
  nc->err = (nc->sock == INVALID_SOCKET) ? -1 : 0;
}

◆ mg_pic32_if_create_conn()

int mg_pic32_if_create_conn ( struct mg_connection * nc )

Definition at line 16232 of file mongoose614.cxx.

                                                      {
  (void) nc;
  return 1;
}

◆ mg_pic32_if_destroy_conn()

void mg_pic32_if_destroy_conn ( struct mg_connection * nc )

Definition at line 16259 of file mongoose614.cxx.

                                                        {
  if (nc->sock == INVALID_SOCKET) return;
  /* For UDP, only close outgoing sockets or listeners. */
  if (!(nc->flags & MG_F_UDP)) {
    /* Close TCP */
    TCPIP_TCP_Close((TCP_SOCKET) nc->sock);
  } else if (nc->listener == NULL) {
    /* Only close outgoing UDP or listeners. */
    TCPIP_UDP_Close((UDP_SOCKET) nc->sock);
  }
 
  nc->sock = INVALID_SOCKET;
}

◆ mg_pic32_if_free()

void mg_pic32_if_free ( struct mg_iface * iface )

Definition at line 16251 of file mongoose614.cxx.

                                              {
  (void) iface;
}

◆ mg_pic32_if_get_conn_addr()

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

Definition at line 16470 of file mongoose614.cxx.

                                                         {
  /* TODO(alaskin): not implemented yet */
}

◆ mg_pic32_if_init()

void mg_pic32_if_init ( struct mg_iface * iface )

Definition at line 16246 of file mongoose614.cxx.

                                              {
  (void) iface;
  (void) mg_get_errno(); /* Shutup compiler */
}

Here is the call graph for this function:

◆ mg_pic32_if_listen_tcp()

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

Definition at line 16295 of file mongoose614.cxx.

                                                                               {
  nc->sock = TCPIP_TCP_ServerOpen(
      sa->sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4
                                    : IP_ADDRESS_TYPE_IPV6,
      ntohs(sa->sin.sin_port),
      sa->sin.sin_addr.s_addr == 0 ? 0 : (IP_MULTI_ADDRESS *) &sa->sin);
  memcpy(&nc->sa, sa, sizeof(*sa));
  if (nc->sock == INVALID_SOCKET) {
    return -1;
  }
  return 0;
}

◆ mg_pic32_if_listen_udp()

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

Definition at line 16273 of file mongoose614.cxx.

                                                                               {
  nc->sock = TCPIP_UDP_ServerOpen(
      sa->sin.sin_family == AF_INET ? IP_ADDRESS_TYPE_IPV4
                                    : IP_ADDRESS_TYPE_IPV6,
      ntohs(sa->sin.sin_port),
      sa->sin.sin_addr.s_addr == 0 ? 0 : (IP_MULTI_ADDRESS *) &sa->sin);
  if (nc->sock == INVALID_SOCKET) {
    return -1;
  }
  return 0;
}

◆ mg_pic32_if_poll()

time_t mg_pic32_if_poll	(	struct mg_iface *	iface,
		int	timeout_ms
	)

Definition at line 16424 of file mongoose614.cxx.

                                                                {
  struct mg_mgr *mgr = iface->mgr;
  double now = mg_time();
  struct mg_connection *nc, *tmp;
 
  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
    tmp = nc->next;
 
    if (nc->flags & MG_F_CONNECTING) {
      /* processing connections */
      if (nc->flags & MG_F_UDP ||
          TCPIP_TCP_IsConnected((TCP_SOCKET) nc->sock)) {
        mg_if_connect_cb(nc, 0);
      }
    } else if (nc->flags & MG_F_LISTENING) {
      if (TCPIP_TCP_IsConnected((TCP_SOCKET) nc->sock)) {
        /* accept new connections */
        mg_accept_conn(nc);
      }
    } else {
      if (nc->send_mbuf.len != 0) {
        mg_handle_send(nc);
      }
 
      if (nc->recv_mbuf_limit == -1 ||
          nc->recv_mbuf.len < nc->recv_mbuf_limit) {
        mg_handle_recv(nc);
      }
    }
  }
 
  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))) {
      mg_close_conn(nc);
    }
  }
 
  return now;
}

Here is the call graph for this function:

◆ mg_pic32_if_recved()

void mg_pic32_if_recved	(	struct mg_connection *	nc,
		size_t	len
	)

Definition at line 16237 of file mongoose614.cxx.

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

◆ mg_pic32_if_remove_conn()

void mg_pic32_if_remove_conn ( struct mg_connection * nc )

Definition at line 16255 of file mongoose614.cxx.

                                                       {
  (void) nc;
}

◆ mg_pic32_if_sock_set()

void mg_pic32_if_sock_set	(	struct mg_connection *	nc,
		sock_t	sock
	)

Definition at line 16466 of file mongoose614.cxx.

                                                                 {
  nc->sock = sock;
}

◆ mg_pic32_if_tcp_send()

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

Definition at line 16290 of file mongoose614.cxx.

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

Here is the call graph for this function:

◆ mg_pic32_if_udp_send()

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

Definition at line 16285 of file mongoose614.cxx.

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

Here is the call graph for this function:

◆ mg_recv_tcp()

static int mg_recv_tcp	(	struct mg_connection *	nc,
		char *	buf,
		size_t	len
	)

static

Definition at line 2972 of file mongoose614.cxx.

                                                                        {
  int n = 0;
#if MG_ENABLE_SSL
  if (nc->flags & MG_F_SSL) {
    if (nc->flags & MG_F_SSL_HANDSHAKE_DONE) {
      n = mg_ssl_if_read(nc, buf, len);
      DBG(("%p <- %d bytes (SSL)", nc, n));
      if (n < 0) {
        if (n == MG_SSL_WANT_READ) {
          nc->flags |= MG_F_WANT_READ;
          n = 0;
        } else {
          nc->flags |= MG_F_CLOSE_IMMEDIATELY;
        }
      } else if (n > 0) {
        nc->flags &= ~MG_F_WANT_READ;
      }
    } else {
      mg_ssl_handshake(nc);
    }
  } else
#endif
  {
    n = nc->iface->vtable->tcp_recv(nc, buf, len);
    DBG(("%p <- %d bytes", nc, n));
  }
  if (n > 0) {
    nc->recv_mbuf.len += n;
    nc->last_io_time = (time_t) mg_time();
#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP
    if (nc->mgr && nc->mgr->hexdump_file != NULL) {
      mg_hexdump_connection(nc, nc->mgr->hexdump_file, buf, n, MG_EV_RECV);
    }
#endif
    mbuf_trim(&nc->recv_mbuf);
    mg_call(nc, NULL, nc->user_data, MG_EV_RECV, &n);
  } else if (n < 0) {
    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
  }
  mbuf_trim(&nc->recv_mbuf);
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_recv_udp()

static int mg_recv_udp	(	struct mg_connection *	nc,
		char *	buf,
		size_t	len
	)

static

Definition at line 3015 of file mongoose614.cxx.

                                                                        {
  int n = 0;
  struct mg_connection *lc = nc;
  union socket_address sa;
  size_t sa_len = sizeof(sa);
  n = nc->iface->vtable->udp_recv(lc, buf, len, &sa, &sa_len);
  if (n < 0) {
    lc->flags |= MG_F_CLOSE_IMMEDIATELY;
    goto out;
  }
  if (nc->flags & MG_F_LISTENING) {
    /*
     * Do we have an existing connection for this source?
     * This is very inefficient for long connection lists.
     */
    lc = nc;
    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;
        /*
         * Long-lived UDP "connections" i.e. interactions that involve more
         * than one request and response are rare, most are transactional:
         * response is sent and the "connection" is closed. Or - should be.
         * But users (including ourselves) tend to forget about that part,
         * because UDP is connectionless and one does not think about
         * processing a UDP request as handling a connection that needs to be
         * closed. Thus, we begin with SEND_AND_CLOSE flag set, which should
         * be a reasonable default for most use cases, but it is possible to
         * turn it off the connection should be kept alive after processing.
         */
        nc->flags |= MG_F_SEND_AND_CLOSE;
        mg_add_conn(lc->mgr, nc);
        mg_call(nc, NULL, nc->user_data, MG_EV_ACCEPT, &nc->sa);
      }
    }
  }
  if (nc != NULL) {
    DBG(("%p <- %d bytes from %s:%d", nc, n, inet_ntoa(nc->sa.sin.sin_addr),
         ntohs(nc->sa.sin.sin_port)));
    if (nc == lc) {
      nc->recv_mbuf.len += n;
    } else {
      mbuf_append(&nc->recv_mbuf, buf, n);
    }
    mbuf_trim(&lc->recv_mbuf);
    lc->last_io_time = nc->last_io_time = (time_t) mg_time();
#if !defined(NO_LIBC) && MG_ENABLE_HEXDUMP
    if (nc->mgr && nc->mgr->hexdump_file != NULL) {
      mg_hexdump_connection(nc, nc->mgr->hexdump_file, buf, n, MG_EV_RECV);
    }
#endif
    if (n != 0) {
      mg_call(nc, NULL, nc->user_data, MG_EV_RECV, &n);
    }
  }
 
out:
  mbuf_free(&lc->recv_mbuf);
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_remove_conn()

MG_INTERNAL void mg_remove_conn ( struct mg_connection * c )

Definition at line 2427 of file mongoose614.cxx.

                                                            {
  if (conn->prev == NULL) conn->mgr->active_connections = conn->next;
  if (conn->prev) conn->prev->next = conn->next;
  if (conn->next) conn->next->prev = conn->prev;
  conn->prev = conn->next = NULL;
  conn->iface->vtable->remove_conn(conn);
}

Here is the caller graph for this function:

◆ mg_run_in_task()

void mg_run_in_task	(	void()(struct mg_mgr mgr, void *arg)	cb,
		void *	cb_arg
	)

Definition at line 14384 of file mongoose614.cxx.

                                                                             {
  struct mg_q_msg msg = {MG_Q_MSG_CB, cb, cb_arg};
  osi_MsgQWrite(&s_mg_q, &msg, OSI_NO_WAIT);
}

◆ mg_set_non_blocking_mode()

void mg_set_non_blocking_mode ( sock_t sock )

Definition at line 3836 of file mongoose614.cxx.

                                           {
#ifdef _WIN32
  unsigned long on = 1;
  ioctlsocket(sock, FIONBIO, &on);
#else
  int flags = fcntl(sock, F_GETFL, 0);
  fcntl(sock, F_SETFL, flags | O_NONBLOCK);
#endif
}

Here is the caller graph for this function:

◆ mg_sl_if_add_conn()

void mg_sl_if_add_conn ( struct mg_connection * nc )

Definition at line 14700 of file mongoose614.cxx.

                                                 {
  (void) nc;
}

◆ mg_sl_if_connect_tcp()

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

static

Definition at line 14479 of file mongoose614.cxx.

                                                                 {
  int proto = 0;
#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK
  if (nc->flags & MG_F_SSL) proto = SL_SEC_SOCKET;
#endif
  sock_t sock = sl_Socket(AF_INET, SOCK_STREAM, proto);
  if (sock < 0) {
    nc->err = sock;
    goto out;
  }
  mg_sock_set(nc, sock);
#if MG_ENABLE_SSL && MG_SSL_IF == MG_SSL_IF_SIMPLELINK
  nc->err = sl_set_ssl_opts(sock, nc);
  if (nc->err != 0) goto out;
#endif
  nc->err = sl_Connect(sock, &sa->sa, sizeof(sa->sin));
out:
  DBG(("%p to %s:%d sock %d %d err %d", nc, inet_ntoa(sa->sin.sin_addr),
       ntohs(sa->sin.sin_port), nc->sock, proto, nc->err));
}

Here is the call graph for this function:

◆ mg_sl_if_connect_udp()

static void mg_sl_if_connect_udp ( struct mg_connection * nc )

static

Definition at line 14501 of file mongoose614.cxx.

                                                           {
  sock_t sock = sl_Socket(AF_INET, SOCK_DGRAM, 0);
  if (sock < 0) {
    nc->err = sock;
    return;
  }
  mg_sock_set(nc, sock);
  nc->err = 0;
}

Here is the call graph for this function:

◆ mg_sl_if_create_conn()

static int mg_sl_if_create_conn ( struct mg_connection * nc )

static

Definition at line 14564 of file mongoose614.cxx.

                                                          {
  (void) nc;
  return 1;
}

◆ mg_sl_if_destroy_conn()

void mg_sl_if_destroy_conn ( struct mg_connection * nc )

Definition at line 14569 of file mongoose614.cxx.

                                                     {
  if (nc->sock == INVALID_SOCKET) return;
  /* For UDP, only close outgoing sockets or listeners. */
  if (!(nc->flags & MG_F_UDP) || nc->listener == NULL) {
    sl_Close(nc->sock);
  }
  nc->sock = INVALID_SOCKET;
}

◆ mg_sl_if_free()

void mg_sl_if_free ( struct mg_iface * iface )

Definition at line 14696 of file mongoose614.cxx.

                                           {
  (void) iface;
}

◆ mg_sl_if_get_conn_addr()

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

Definition at line 14804 of file mongoose614.cxx.

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

◆ mg_sl_if_init()

void mg_sl_if_init ( struct mg_iface * iface )

Definition at line 14691 of file mongoose614.cxx.

                                           {
  (void) iface;
  DBG(("%p using sl_Select()", iface->mgr));
}

◆ mg_sl_if_listen_tcp()

static int mg_sl_if_listen_tcp	(	struct mg_connection *	nc,
		union socket_address *	sa
	)

static

Definition at line 14511 of file mongoose614.cxx.

                                                         {
  int proto = 0;
  if (nc->flags & MG_F_SSL) proto = SL_SEC_SOCKET;
  sock_t sock = mg_open_listening_socket(nc, sa, SOCK_STREAM, proto);
  if (sock < 0) return sock;
  mg_sock_set(nc, sock);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_sl_if_listen_udp()

static int mg_sl_if_listen_udp	(	struct mg_connection *	nc,
		union socket_address *	sa
	)

static

Definition at line 14521 of file mongoose614.cxx.

                                                         {
  sock_t sock = mg_open_listening_socket(nc, sa, SOCK_DGRAM, 0);
  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_sl_if_poll()

time_t mg_sl_if_poll	(	struct mg_iface *	iface,
		int	timeout_ms
	)

Definition at line 14708 of file mongoose614.cxx.

                                                             {
  struct mg_mgr *mgr = iface->mgr;
  double now = mg_time();
  double min_timer;
  struct mg_connection *nc, *tmp;
  struct SlTimeval_t tv;
  SlFdSet_t read_set, write_set, err_set;
  sock_t max_fd = INVALID_SOCKET;
  int num_fds, num_ev = 0, num_timers = 0;
 
  SL_SOCKET_FD_ZERO(&read_set);
  SL_SOCKET_FD_ZERO(&write_set);
  SL_SOCKET_FD_ZERO(&err_set);
 
  /*
   * 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;
 
    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)) {
        SL_SOCKET_FD_SET(nc->sock, &read_set);
        if (max_fd == INVALID_SOCKET || nc->sock > max_fd) max_fd = nc->sock;
      }
 
      if (((nc->flags & MG_F_CONNECTING) && !(nc->flags & MG_F_WANT_READ)) ||
          (nc->send_mbuf.len > 0 && !(nc->flags & MG_F_CONNECTING))) {
        SL_SOCKET_FD_SET(nc->sock, &write_set);
        SL_SOCKET_FD_SET(nc->sock, &err_set);
        if (max_fd == INVALID_SOCKET || nc->sock > max_fd) max_fd = nc->sock;
      }
    }
 
    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;
 
  if (num_fds > 0) {
    num_ev = sl_Select((int) max_fd + 1, &read_set, &write_set, &err_set, &tv);
  }
 
  now = mg_time();
  DBG(("sl_Select @ %ld num_ev=%d of %d, timeout=%d", (long) now, num_ev,
       num_fds, timeout_ms));
 
  for (nc = mgr->active_connections; nc != NULL; nc = tmp) {
    int fd_flags = 0;
    if (nc->sock != INVALID_SOCKET) {
      if (num_ev > 0) {
        fd_flags =
            (SL_SOCKET_FD_ISSET(nc->sock, &read_set) &&
                     (!(nc->flags & MG_F_UDP) || nc->listener == NULL)
                 ? _MG_F_FD_CAN_READ
                 : 0) |
            (SL_SOCKET_FD_ISSET(nc->sock, &write_set) ? _MG_F_FD_CAN_WRITE
                                                      : 0) |
            (SL_SOCKET_FD_ISSET(nc->sock, &err_set) ? _MG_F_FD_ERROR : 0);
      }
      /* SimpleLink does not report UDP sockets as writable. */
      if (nc->flags & MG_F_UDP && nc->send_mbuf.len > 0) {
        fd_flags |= _MG_F_FD_CAN_WRITE;
      }
    }
    tmp = nc->next;
    mg_mgr_handle_conn(nc, fd_flags, now);
  }
 
  return now;
}

Here is the call graph for this function:

◆ mg_sl_if_remove_conn()

void mg_sl_if_remove_conn ( struct mg_connection * nc )

Definition at line 14704 of file mongoose614.cxx.

                                                    {
  (void) nc;
}

◆ mg_sl_if_sock_set()

void mg_sl_if_sock_set	(	struct mg_connection *	nc,
		sock_t	sock
	)

Definition at line 14685 of file mongoose614.cxx.

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

Here is the call graph for this function:

◆ mg_sl_if_tcp_recv()

static int mg_sl_if_tcp_recv	(	struct mg_connection *	nc,
		void *	buf,
		size_t	len
	)

static

Definition at line 14543 of file mongoose614.cxx.

                                                                              {
  int n = sl_Recv(nc->sock, buf, len, 0);
  if (n == 0) {
    /* Orderly shutdown of the socket, try flushing output. */
    nc->flags |= MG_F_SEND_AND_CLOSE;
  } else if (n < 0 && !mg_is_error(n)) {
    n = 0;
  }
  return n;
}

Here is the call graph for this function:

◆ mg_sl_if_tcp_send()

static int mg_sl_if_tcp_send	(	struct mg_connection *	nc,
		const void *	buf,
		size_t	len
	)

static

Definition at line 14529 of file mongoose614.cxx.

                                         {
  int n = (int) sl_Send(nc->sock, buf, len, 0);
  if (n < 0 && !mg_is_error(n)) n = 0;
  return n;
}

Here is the call graph for this function:

◆ mg_sl_if_udp_recv()

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

static

Definition at line 14554 of file mongoose614.cxx.

                                                                       {
  SlSocklen_t sa_len_t = *sa_len;
  int n = sl_RecvFrom(nc->sock, buf, MG_UDP_RECV_BUFFER_SIZE, 0,
                      (SlSockAddr_t *) sa, &sa_len_t);
  *sa_len = sa_len_t;
  if (n < 0 && !mg_is_error(n)) n = 0;
  return n;
}

Here is the call graph for this function:

◆ mg_sl_if_udp_send()

static int mg_sl_if_udp_send	(	struct mg_connection *	nc,
		const void *	buf,
		size_t	len
	)

static

Definition at line 14536 of file mongoose614.cxx.

                                         {
  int n = sl_SendTo(nc->sock, buf, len, 0, &nc->sa.sa, sizeof(nc->sa.sin));
  if (n < 0 && !mg_is_error(n)) n = 0;
  return n;
}

Here is the call graph for this function:

◆ mg_sock_get_addr()

static void mg_sock_get_addr	(	sock_t	sock,
		int	remote,
		union socket_address *	sa
	)

static

Definition at line 4349 of file mongoose614.cxx.

                                                       {
  socklen_t slen = sizeof(*sa);
  memset(sa, 0, slen);
  if (remote) {
    getpeername(sock, &sa->sa, &slen);
  } else {
    getsockname(sock, &sa->sa, &slen);
  }
}

Here is the caller graph for this function:

◆ mg_socket_if_add_conn()

void mg_socket_if_add_conn ( struct mg_connection * nc )

Definition at line 4138 of file mongoose614.cxx.

                                                     {
  (void) nc;
}

◆ mg_socket_if_connect_tcp()

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

Definition at line 3858 of file mongoose614.cxx.

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

Here is the call graph for this function:

◆ mg_socket_if_connect_udp()

void mg_socket_if_connect_udp ( struct mg_connection * nc )

Definition at line 3875 of file mongoose614.cxx.

                                                        {
  nc->sock = socket(AF_INET, SOCK_DGRAM, 0);
  if (nc->sock == INVALID_SOCKET) {
    nc->err = mg_get_errno() ? mg_get_errno() : 1;
    return;
  }
  if (nc->flags & MG_F_ENABLE_BROADCAST) {
    int optval = 1;
    if (setsockopt(nc->sock, SOL_SOCKET, SO_BROADCAST, (const char *) &optval,
                   sizeof(optval)) < 0) {
      nc->err = mg_get_errno() ? mg_get_errno() : 1;
      return;
    }
  }
  nc->err = 0;
}

Here is the call graph for this function:

◆ mg_socket_if_create_conn()

int mg_socket_if_create_conn ( struct mg_connection * nc )

Definition at line 3947 of file mongoose614.cxx.

                                                       {
  (void) nc;
  return 1;
}

◆ mg_socket_if_destroy_conn()

void mg_socket_if_destroy_conn ( struct mg_connection * nc )

Definition at line 3952 of file mongoose614.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);
  }
  nc->sock = INVALID_SOCKET;
}

◆ mg_socket_if_free()

void mg_socket_if_free ( struct mg_iface * iface )

Definition at line 4134 of file mongoose614.cxx.

                                               {
  (void) iface;
}

◆ mg_socket_if_get_conn_addr()

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

Definition at line 4366 of file mongoose614.cxx.

                                                          {
  if ((nc->flags & MG_F_UDP) && remote) {
    memcpy(sa, &nc->sa, sizeof(*sa));
    return;
  }
  mg_sock_get_addr(nc->sock, remote, sa);
}

Here is the call graph for this function:

◆ mg_socket_if_init()

void mg_socket_if_init ( struct mg_iface * iface )

Definition at line 4126 of file mongoose614.cxx.

                                               {
  (void) iface;
  DBG(("%p using select()", iface->mgr));
#if MG_ENABLE_BROADCAST
  mg_socketpair(iface->mgr->ctl, SOCK_DGRAM);
#endif
}

Here is the call graph for this function:

◆ mg_socket_if_listen_tcp()

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

Definition at line 3892 of file mongoose614.cxx.

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

Here is the call graph for this function:

◆ mg_socket_if_listen_udp()

static int mg_socket_if_listen_udp	(	struct mg_connection *	nc,
		union socket_address *	sa
	)

static

Definition at line 3903 of file mongoose614.cxx.

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

Here is the call graph for this function:

◆ mg_socket_if_poll()

time_t mg_socket_if_poll	(	struct mg_iface *	iface,
		int	timeout_ms
	)

Definition at line 4159 of file mongoose614.cxx.

                                                                 {
  struct mg_mgr *mgr = iface->mgr;
  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;
#ifdef __unix__
  int try_dup = 1;
#endif
 
  FD_ZERO(&read_set);
  FD_ZERO(&write_set);
  FD_ZERO(&err_set);
#if MG_ENABLE_BROADCAST
  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;
 
    if (nc->sock != INVALID_SOCKET) {
      num_fds++;
 
#ifdef __unix__
      /* A hack to make sure all our file descriptos fit into FD_SETSIZE. */
      if (nc->sock >= (sock_t) FD_SETSIZE && try_dup) {
        int new_sock = dup(nc->sock);
        if (new_sock >= 0) {
          if (new_sock < (sock_t) FD_SETSIZE) {
            closesocket(nc->sock);
            DBG(("new sock %d -> %d", nc->sock, new_sock));
            nc->sock = new_sock;
          } else {
            closesocket(new_sock);
            DBG(("new sock is still larger than FD_SETSIZE, disregard"));
            try_dup = 0;
          }
        } else {
          try_dup = 0;
        }
      }
#endif
 
      if (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 = (int) 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();
#if 0
  DBG(("select @ %ld num_ev=%d of %d, timeout=%d", (long) now, num_ev, num_fds,
       timeout_ms));
#endif
 
#if MG_ENABLE_BROADCAST
  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);
      }
#if MG_LWIP
      /* With LWIP socket emulation layer, we don't get write events for UDP */
      if ((nc->flags & MG_F_UDP) && nc->listener == NULL) {
        fd_flags |= _MG_F_FD_CAN_WRITE;
      }
#endif
    }
    tmp = nc->next;
    mg_mgr_handle_conn(nc, fd_flags, now);
  }
 
  return (time_t) now;
}

Here is the call graph for this function:

◆ mg_socket_if_remove_conn()

void mg_socket_if_remove_conn ( struct mg_connection * nc )

Definition at line 4142 of file mongoose614.cxx.

                                                        {
  (void) nc;
}

◆ mg_socket_if_sock_set()

void mg_socket_if_sock_set	(	struct mg_connection *	nc,
		sock_t	sock
	)

Definition at line 4119 of file mongoose614.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:

◆ mg_socket_if_tcp_recv()

static int mg_socket_if_tcp_recv	(	struct mg_connection *	nc,
		void *	buf,
		size_t	len
	)

static

Definition at line 3925 of file mongoose614.cxx.

                                             {
  int n = (int) MG_RECV_FUNC(nc->sock, buf, len, 0);
  if (n == 0) {
    /* Orderly shutdown of the socket, try flushing output. */
    nc->flags |= MG_F_SEND_AND_CLOSE;
  } else if (n < 0 && !mg_is_error()) {
    n = 0;
  }
  return n;
}

Here is the call graph for this function:

◆ mg_socket_if_tcp_send()

static int mg_socket_if_tcp_send	(	struct mg_connection *	nc,
		const void *	buf,
		size_t	len
	)

static

Definition at line 3911 of file mongoose614.cxx.

                                             {
  int n = (int) MG_SEND_FUNC(nc->sock, buf, len, 0);
  if (n < 0 && !mg_is_error()) n = 0;
  return n;
}

Here is the call graph for this function:

◆ mg_socket_if_udp_recv()

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

static

Definition at line 3937 of file mongoose614.cxx.

                                                 {
  socklen_t sa_len_st = *sa_len;
  int n = recvfrom(nc->sock, buf, len, 0, &sa->sa, &sa_len_st);
  *sa_len = sa_len_st;
  if (n < 0 && !mg_is_error()) n = 0;
  return n;
}

Here is the call graph for this function:

◆ mg_socket_if_udp_send()

static int mg_socket_if_udp_send	(	struct mg_connection *	nc,
		const void *	buf,
		size_t	len
	)

static

Definition at line 3918 of file mongoose614.cxx.

                                             {
  int n = sendto(nc->sock, buf, len, 0, &nc->sa.sa, sizeof(nc->sa.sin));
  if (n < 0 && !mg_is_error()) n = 0;
  return n;
}

Here is the call graph for this function:

◆ mg_start_task()

bool mg_start_task	(	int	priority,
		int	stack_size,
		mg_init_cb	mg_init
	)

Definition at line 14356 of file mongoose614.cxx.

                                                                     {
  if (osi_MsgQCreate(&s_mg_q, "MG", sizeof(struct mg_q_msg), 16) != OSI_OK) {
    return false;
  }
  if (osi_TaskCreate(mg_task, (const signed char *) "MG", stack_size,
                     (void *) mg_init, priority, NULL) != OSI_OK) {
    return false;
  }
  return true;
}

Here is the call graph for this function:

◆ mg_str_starts_with()

int mg_str_starts_with	(	struct mg_str	s,
		struct mg_str	prefix
	)

Definition at line 1822 of file mongoose614.cxx.

                                                              {
  const struct mg_str sp = MG_MK_STR_N(s.p, prefix.len);
  if (s.len < prefix.len) return 0;
  return (mg_strcmp(sp, prefix) == 0);
}

◆ mg_strchr()

const char * mg_strchr	(	const struct mg_str	s,
		int	c
	)

Definition at line 1752 of file mongoose614.cxx.

                                                    {
  size_t i;
  for (i = 0; i < s.len; i++) {
    if (s.p[i] == c) return &s.p[i];
  }
  return NULL;
}

Here is the caller graph for this function:

◆ mg_strcmp()

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

Definition at line 1761 of file mongoose614.cxx.

                                                                  {
  size_t i = 0;
  while (i < str1.len && i < str2.len) {
    if (str1.p[i] < str2.p[i]) return -1;
    if (str1.p[i] > str2.p[i]) return 1;
    i++;
  }
  if (i < str1.len) return 1;
  if (i < str2.len) return -1;
  return 0;
}

Here is the caller graph for this function:

◆ mg_strdup()

struct mg_str mg_strdup ( const struct mg_str s )

Definition at line 1742 of file mongoose614.cxx.

                                               {
  return mg_strdup_common(s, 0 /* NUL-terminate */);
}

Here is the caller graph for this function:

◆ mg_strdup_common()

static struct mg_str mg_strdup_common	(	const struct mg_str	s,
		int	nul_terminate
	)

static

Definition at line 1726 of file mongoose614.cxx.

                                                         {
  struct mg_str r = {NULL, 0};
  if (s.len > 0 && s.p != NULL) {
    char *sc = (char *) MG_MALLOC(s.len + (nul_terminate ? 1 : 0));
    if (sc != NULL) {
      memcpy(sc, s.p, s.len);
      if (nul_terminate) sc[s.len] = '\0';
      r.p = sc;
      r.len = s.len;
    }
  }
  return r;
}

Here is the caller graph for this function:

◆ mg_strdup_nul()

struct mg_str mg_strdup_nul ( const struct mg_str s )

Definition at line 1747 of file mongoose614.cxx.

                                                   {
  return mg_strdup_common(s, 1 /* NUL-terminate */);
}

◆ mg_strfree()

void mg_strfree ( struct mg_str * s )

Definition at line 1788 of file mongoose614.cxx.

                                  {
  char *sp = (char *) s->p;
  s->p = NULL;
  s->len = 0;
  if (sp != NULL) free(sp);
}

◆ mg_strncmp()

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

Definition at line 1774 of file mongoose614.cxx.

                                                                             {
  struct mg_str s1 = str1;
  struct mg_str s2 = str2;
 
  if (s1.len > n) {
    s1.len = n;
  }
  if (s2.len > n) {
    s2.len = n;
  }
  return mg_strcmp(s1, s2);
}

◆ mg_strstr()

const char * mg_strstr	(	const struct mg_str	haystack,
		const struct mg_str	needle
	)

Definition at line 1797 of file mongoose614.cxx.

                                                  {
  size_t i;
  if (needle.len > haystack.len) return NULL;
  for (i = 0; i <= haystack.len - needle.len; i++) {
    if (memcmp(haystack.p + i, needle.p, needle.len) == 0) {
      return haystack.p + i;
    }
  }
  return NULL;
}

◆ mg_strstrip()

struct mg_str mg_strstrip ( struct mg_str s )

Definition at line 1810 of file mongoose614.cxx.

                                           {
  while (s.len > 0 && isspace((int) *s.p)) {
    s.p++;
    s.len--;
  }
  while (s.len > 0 && isspace((int) *(s.p + s.len - 1))) {
    s.len--;
  }
  return s;
}

◆ mg_task()

static void mg_task ( void * arg )

static

Definition at line 14367 of file mongoose614.cxx.

                               {
  struct mg_mgr mgr;
  mg_init_cb mg_init = (mg_init_cb) arg;
  mg_mgr_init(&mgr, NULL);
  mg_init(&mgr);
  while (1) {
    struct mg_q_msg msg;
    mg_mgr_poll(&mgr, 1);
    if (osi_MsgQRead(&s_mg_q, &msg, 1) != OSI_OK) continue;
    switch (msg.type) {
      case MG_Q_MSG_CB: {
        msg.cb(&mgr, msg.arg);
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_timer()

MG_INTERNAL void mg_timer	(	struct mg_connection *	c,
		double	now
	)

Definition at line 2477 of file mongoose614.cxx.

                                                               {
  if (c->ev_timer_time > 0 && now >= c->ev_timer_time) {
    double old_value = c->ev_timer_time;
    c->ev_timer_time = 0;
    mg_call(c, NULL, c->user_data, MG_EV_TIMER, &old_value);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mg_url_encode()

struct mg_str mg_url_encode ( const struct mg_str src )

Definition at line 10795 of file mongoose614.cxx.

                                                     {
  return mg_url_encode_opt(src, mg_mk_str("._-$,;~()/"), 0);
}

◆ mg_url_encode_opt()

struct mg_str mg_url_encode_opt	(	const struct mg_str	src,
		const struct mg_str	safe,
		unsigned int	flags
	)

Definition at line 10769 of file mongoose614.cxx.

                                                                              {
  const char *hex =
      (flags & MG_URL_ENCODE_F_UPPERCASE_HEX ? "0123456789ABCDEF"
                                             : "0123456789abcdef");
  size_t i = 0;
  struct mbuf mb;
  mbuf_init(&mb, src.len);
 
  for (i = 0; i < src.len; i++) {
    const unsigned char c = *((const unsigned char *) src.p + i);
    if (isalnum(c) || mg_strchr(safe, c) != NULL) {
      mbuf_append(&mb, &c, 1);
    } else if (c == ' ' && (flags & MG_URL_ENCODE_F_SPACE_AS_PLUS)) {
      mbuf_append(&mb, "+", 1);
    } else {
      mbuf_append(&mb, "%", 1);
      mbuf_append(&mb, &hex[c >> 4], 1);
      mbuf_append(&mb, &hex[c & 15], 1);
    }
  }
  mbuf_append(&mb, "", 1);
  mbuf_trim(&mb);
  return mg_mk_str_n(mb.buf, mb.len - 1);
}

◆ parse_net()

static int parse_net	(	const char *	spec,
		uint32_t *	net,
		uint32_t *	mask
	)

static

Definition at line 3466 of file mongoose614.cxx.

                                                                      {
  int n, a, b, c, d, slash = 32, len = 0;
 
  if ((sscanf(spec, "%d.%d.%d.%d/%d%n", &a, &b, &c, &d, &slash, &n) == 5 ||
       sscanf(spec, "%d.%d.%d.%d%n", &a, &b, &c, &d, &n) == 4) &&
      isbyte(a) && isbyte(b) && isbyte(c) && isbyte(d) && slash >= 0 &&
      slash < 33) {
    len = n;
    *net =
        ((uint32_t) a << 24) | ((uint32_t) b << 16) | ((uint32_t) c << 8) | d;
    *mask = slash ? 0xffffffffU << (32 - slash) : 0;
  }
 
  return len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_uri_component()

static void parse_uri_component	(	const char **	p,
		const char *	end,
		const char *	seps,
		struct mg_str *	res
	)

static

Definition at line 5573 of file mongoose614.cxx.

                                                                      {
  const char *q;
  res->p = *p;
  for (; *p < end; (*p)++) {
    for (q = seps; *q != '\0'; q++) {
      if (**p == *q) break;
    }
    if (*q != '\0') break;
  }
  res->len = (*p) - res->p;
  if (*p < end) (*p)++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ recv_avail_size()

MG_INTERNAL size_t recv_avail_size	(	struct mg_connection *	conn,
		size_t	max
	)

Definition at line 2485 of file mongoose614.cxx.

                                                                           {
  size_t avail;
  if (conn->recv_mbuf_limit < conn->recv_mbuf.len) return 0;
  avail = conn->recv_mbuf_limit - conn->recv_mbuf.len;
  return avail > max ? max : avail;
}

Here is the caller graph for this function:

◆ sl_restart_cb()

void sl_restart_cb ( struct mg_mgr * mgr )

Definition at line 14812 of file mongoose614.cxx.

                                       {
  /*
   * SimpleLink has been restarted, meaning all sockets have been invalidated.
   * We try our best - we'll restart the listeners, but for outgoing
   * connections we have no option but to terminate.
   */
  struct mg_connection *nc;
  for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc)) {
    if (nc->sock == INVALID_SOCKET) continue; /* Could be a timer */
    if (nc->flags & MG_F_LISTENING) {
      DBG(("restarting %p %s:%d", nc, inet_ntoa(nc->sa.sin.sin_addr),
           ntohs(nc->sa.sin.sin_port)));
      int res = (nc->flags & MG_F_UDP ? mg_sl_if_listen_udp(nc, &nc->sa)
                                      : mg_sl_if_listen_tcp(nc, &nc->sa));
      if (res == 0) continue;
      /* Well, we tried and failed. Fall through to closing. */
    }
    nc->sock = INVALID_SOCKET;
    DBG(("terminating %p %s:%d", nc, inet_ntoa(nc->sa.sin.sin_addr),
         ntohs(nc->sa.sin.sin_port)));
    /* TODO(rojer): Outgoing UDP? */
    nc->flags |= MG_F_CLOSE_IMMEDIATELY;
  }
}

Here is the call graph for this function:

◆ str_util_lowercase()

static int str_util_lowercase ( const char * s )

static

Definition at line 2182 of file mongoose614.cxx.

                                             {
  return tolower(*(const unsigned char *) s);
}

Here is the caller graph for this function:

◆ tcp_close_tcpip()

static void tcp_close_tcpip ( void * arg )

static

Definition at line 15533 of file mongoose614.cxx.

                                       {
  tcp_close((struct tcp_pcb *) arg);
}

Here is the caller graph for this function:

◆ tcp_output_tcpip()

static void tcp_output_tcpip ( void * arg )

static

Definition at line 15653 of file mongoose614.cxx.

                                        {
  tcp_output((struct tcp_pcb *) arg);
}

Here is the caller graph for this function:

◆ tcp_recved_tcpip()

void tcp_recved_tcpip ( void * arg )

Definition at line 15772 of file mongoose614.cxx.

                                 {
  struct tcp_recved_ctx *ctx = (struct tcp_recved_ctx *) arg;
  if (ctx->tpcb != NULL) tcp_recved(ctx->tpcb, ctx->len);
}

Here is the caller graph for this function:

◆ udp_remove_tcpip()

static void udp_remove_tcpip ( void * arg )

static

Definition at line 15817 of file mongoose614.cxx.

                                        {
  udp_remove((struct udp_pcb *) arg);
}

Here is the caller graph for this function:

◆ udp_sendto_tcpip()

static void udp_sendto_tcpip ( void * arg )

static

Definition at line 15722 of file mongoose614.cxx.

                                        {
  struct udp_sendto_ctx *ctx = (struct udp_sendto_ctx *) arg;
  ctx->ret = udp_sendto(ctx->upcb, ctx->p, ctx->ip, ctx->port);
}

Here is the caller graph for this function:

Variable Documentation

◆ mg_default_iface_vtable

const struct mg_iface_vtable mg_default_iface_vtable = MG_NULL_IFACE_VTABLE

Definition at line 3817 of file mongoose614.cxx.

◆ mg_ifaces

const struct mg_iface_vtable* mg_ifaces[]

Initial value:

= {
    &mg_default_iface_vtable,
}

Definition at line 3628 of file mongoose614.cxx.

                                            {
    &mg_default_iface_vtable,
};

◆ mg_lwip_iface_vtable

const struct mg_iface_vtable mg_lwip_iface_vtable = MG_LWIP_IFACE_VTABLE

Definition at line 15903 of file mongoose614.cxx.

◆ mg_null_iface_vtable

const struct mg_iface_vtable mg_null_iface_vtable = MG_NULL_IFACE_VTABLE

Definition at line 3814 of file mongoose614.cxx.

◆ mg_num_ifaces

int mg_num_ifaces = (int) (sizeof(mg_ifaces) / sizeof(mg_ifaces[0]))

Definition at line 3632 of file mongoose614.cxx.

◆ mg_pic32_iface_vtable

const struct mg_iface_vtable mg_pic32_iface_vtable = MG_PIC32_IFACE_VTABLE

Definition at line 16511 of file mongoose614.cxx.

◆ mg_simplelink_iface_vtable

const struct mg_iface_vtable mg_simplelink_iface_vtable = MG_SL_IFACE_VTABLE

Definition at line 14860 of file mongoose614.cxx.

◆ mg_socket_iface_vtable

const struct mg_iface_vtable mg_socket_iface_vtable = MG_SOCKET_IFACE_VTABLE

Definition at line 4398 of file mongoose614.cxx.

◆ s_mg_q

OsiMsgQ_t s_mg_q

static

Definition at line 14353 of file mongoose614.cxx.

◆ test_calloc

void ( test_calloc) (size_t count, size_t size)	(	size_t	count,
		size_t	size
	)

extern

◆ test_malloc

void *(* test_malloc) (size_t size) ( size_t size )

extern

◆ WEAK

enum cs_log_level cs_log_level WEAK

Initial value:

=
 
    LL_ERROR

Definition at line 612 of file mongoose614.cxx.

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ _MG_ALLOWED_CONNECT_FLAGS_MASK

◆ _MG_CALLBACK_MODIFIABLE_FLAGS_MASK

◆ _MG_F_FD_CAN_READ [1/2]

◆ _MG_F_FD_CAN_READ [2/2]

◆ _MG_F_FD_CAN_WRITE [1/2]

◆ _MG_F_FD_CAN_WRITE [2/2]

◆ _MG_F_FD_ERROR [1/2]

◆ _MG_F_FD_ERROR [2/2]

◆ BASE64_ENCODE_BODY

◆ BASE64_FLUSH

◆ BASE64_OUT

◆ blk

◆ C_DISABLE_BUILTIN_SNPRINTF

◆ C_SNPRINTF_APPEND_CHAR

◆ C_SNPRINTF_FLAG_ZERO

◆ CONSOLE_UART

◆ CS_COMMON_CS_DBG_H_

◆ CS_COMMON_CS_DIRENT_H_

◆ CS_COMMON_CS_ENDIAN_H_

◆ CS_COMMON_MG_MEM_H_

◆ CS_COMMON_PLATFORMS_LWIP_MG_NET_IF_LWIP_H_

◆ CS_COMMON_PLATFORMS_PIC32_NET_IF_H_

◆ CS_COMMON_PLATFORMS_SIMPLELINK_SL_FS_SLFS_H_

◆ CS_COMMON_PLATFORMS_SIMPLELINK_SL_NET_IF_H_

◆ CS_ENABLE_DEBUG

◆ CS_LOG_ENABLE_TS_DIFF

◆ CS_LOG_PREFIX_LEN

◆ CS_MONGOOSE_SRC_INTERNAL_H_

◆ CS_MONGOOSE_SRC_NET_IF_SOCKET_H_

◆ CS_MONGOOSE_SRC_NET_IF_SOCKS_H_

◆ DBG

◆ F1

◆ F2

◆ F3

◆ F4

◆ intptr_t

◆ ip_2_ip4

◆ IPADDR_NTOA

◆ LOG

◆ MAX

◆ MBUF_FREE

◆ MBUF_REALLOC

◆ MD5STEP

◆ MG_CALLOC

◆ MG_COPY_COMMON_CONNECTION_OPTIONS

◆ MG_CTL_MSG_MESSAGE_SIZE

◆ MG_ENABLE_NET_IF_LWIP_LOW_LEVEL

◆ MG_ENABLE_NET_IF_PIC32

◆ MG_ENABLE_NET_IF_SIMPLELINK

◆ MG_ENABLE_NET_IF_SOCKET

◆ MG_FREE

◆ MG_INTERNAL

◆ MG_LWIP_IFACE_VTABLE

◆ MG_MALLOC

◆ MG_MAX_HOST_LEN

◆ MG_NULL_IFACE_VTABLE

◆ MG_PIC32_IFACE_VTABLE

◆ MG_REALLOC

◆ MG_SET_PTRPTR

◆ MG_SIG_QUEUE_LEN

◆ MG_SL_IFACE_VTABLE

◆ MG_SOCKET_IFACE_VTABLE

◆ MG_TCP_IO_SIZE

◆ MG_TCP_RECV_BUFFER_SIZE

◆ MG_UDP_IO_SIZE

◆ MG_UDP_RECV_BUFFER_SIZE

◆ mgos_lock

◆ mgos_unlock

◆ MIN

◆ NUM_DIGITS

◆ NUM_LETTERS

◆ NUM_UPPERCASES

◆ R0