mongoose v4 web server library

Classes
struct	mg_request_info
struct	mg_request_info::mg_header
struct	mg_event

Macros
#define	MG_REQUEST_BEGIN   1
#define	MG_REQUEST_END   2
#define	MG_HTTP_ERROR   3
#define	MG_EVENT_LOG   4
#define	MG_THREAD_BEGIN   5
#define	MG_THREAD_END   6
#define	PRINTF_FORMAT_STRING(s)   s
#define	PRINTF_ARGS(x, y)

Typedefs
typedef int(*	mg_event_handler_t) (struct mg_event *event)
typedef void *(*	mg_thread_func_t) (void *)

Enumerations
enum	{   WEBSOCKET_OPCODE_CONTINUATION = 0x0 , WEBSOCKET_OPCODE_TEXT = 0x1 , WEBSOCKET_OPCODE_BINARY = 0x2 , WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8 ,   WEBSOCKET_OPCODE_PING = 0x9 , WEBSOCKET_OPCODE_PONG = 0xa }

Functions
struct mg_context *	mg_start (const char **configuration_options, mg_event_handler_t func, void *user_data)
void	mg_stop (struct mg_context *)
void	mg_websocket_handshake (struct mg_connection *)
int	mg_websocket_read (struct mg_connection *, int *bits, char **data)
int	mg_websocket_write (struct mg_connection *conn, int opcode, const char *data, size_t data_len)
const char *	mg_get_option (const struct mg_context *ctx, const char *name)
const char **	mg_get_valid_option_names (void)
int	mg_modify_passwords_file (const char *passwords_file_name, const char *domain, const char *user, const char *password)
int	mg_write (struct mg_connection *, const void *buf, int len)
int	mg_printf (struct mg_connection *, PRINTF_FORMAT_STRING(const char *fmt),...) PRINTF_ARGS(2
int void	mg_send_file (struct mg_connection *conn, const char *path)
int	mg_read (struct mg_connection *, void *buf, int len)
const char *	mg_get_header (const struct mg_connection *, const char *name)
int	mg_get_var (const char *data, size_t data_len, const char *var_name, char *dst, size_t dst_len)
int	mg_get_cookie (const char *cookie, const char *var_name, char *buf, size_t buf_len)
struct mg_connection *	mg_download (const char *host, int port, int use_ssl, char *error_buffer, size_t error_buffer_size, PRINTF_FORMAT_STRING(const char *request_fmt),...) PRINTF_ARGS(6
struct mg_connection void	mg_close_connection (struct mg_connection *conn)
FILE *	mg_upload (struct mg_connection *conn, const char *destination_dir, char *path, int path_len)
int	mg_start_thread (mg_thread_func_t f, void *p)
const char *	mg_get_builtin_mime_type (const char *file_name)
const char *	mg_version (void)
int	mg_url_decode (const char *src, int src_len, char *dst, int dst_len, int is_form_url_encoded)
char *	mg_md5 (char buf[33],...)

Variables
const char *	mg_request_info::request_method
const char *	mg_request_info::uri
const char *	mg_request_info::http_version
const char *	mg_request_info::query_string
const char *	mg_request_info::remote_user
long	mg_request_info::remote_ip
int	mg_request_info::remote_port
int	mg_request_info::is_ssl
int	mg_request_info::num_headers
const char *	mg_request_info::mg_header::name
const char *	mg_request_info::mg_header::value
struct mg_request_info::mg_header	mg_request_info::http_headers [64]
int	mg_event::type
void *	mg_event::user_data
void *	mg_event::conn_data
void *	mg_event::event_param
struct mg_connection *	mg_event::conn
struct mg_request_info *	mg_event::request_info

Detailed Description

Macro Definition Documentation

MG_EVENT_LOG

#define MG_EVENT_LOG   4

Definition at line 58 of file mongoose4.h.

MG_HTTP_ERROR

#define MG_HTTP_ERROR   3

Definition at line 57 of file mongoose4.h.

MG_REQUEST_BEGIN

#define MG_REQUEST_BEGIN   1

Definition at line 55 of file mongoose4.h.

MG_REQUEST_END

#define MG_REQUEST_END   2

Definition at line 56 of file mongoose4.h.

MG_THREAD_BEGIN

#define MG_THREAD_BEGIN   5

Definition at line 59 of file mongoose4.h.

MG_THREAD_END

#define MG_THREAD_END   6

Definition at line 60 of file mongoose4.h.

PRINTF_ARGS

#define PRINTF_ARGS	(		x,
			y
	)

Definition at line 114 of file mongoose4.h.

PRINTF_FORMAT_STRING

#define PRINTF_FORMAT_STRING

(

s

)

s

Definition at line 108 of file mongoose4.h.

Typedef Documentation

mg_event_handler_t

typedef int(* mg_event_handler_t) (struct mg_event *event)

Definition at line 70 of file mongoose4.h.

mg_thread_func_t

typedef void *(* mg_thread_func_t) (void *)

Definition at line 218 of file mongoose4.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
WEBSOCKET_OPCODE_CONTINUATION
WEBSOCKET_OPCODE_TEXT
WEBSOCKET_OPCODE_BINARY
WEBSOCKET_OPCODE_CONNECTION_CLOSE
WEBSOCKET_OPCODE_PING
WEBSOCKET_OPCODE_PONG

Definition at line 81 of file mongoose4.h.

     {
  WEBSOCKET_OPCODE_CONTINUATION = 0x0,
  WEBSOCKET_OPCODE_TEXT = 0x1,
  WEBSOCKET_OPCODE_BINARY = 0x2,
  WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8,
  WEBSOCKET_OPCODE_PING = 0x9,
  WEBSOCKET_OPCODE_PONG = 0xa
};

Function Documentation

mg_close_connection()

struct mg_connection void mg_close_connection

(

struct mg_connection *

conn

)

Definition at line 5097 of file mongoose4.cxx.

                                                     {
#ifndef NO_SSL
  if (conn->client_ssl_ctx != NULL) {
    SSL_CTX_free((SSL_CTX *) conn->client_ssl_ctx);
  }
#endif
  close_connection(conn);
  free(conn);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mg_download()

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

mg_get_builtin_mime_type()

const char * mg_get_builtin_mime_type

(

const char *

file_name

)

Definition at line 2895 of file mongoose4.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

mg_get_cookie()

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

Definition at line 2678 of file mongoose4.cxx.

                                              {
  const char *s, *p, *end;
  int name_len, len = -1;
 
  if (dst == NULL || dst_size == 0) {
    len = -2;
  } else if (var_name == NULL || (s = cookie_header) == NULL) {
    len = -1;
    dst[0] = '\0';
  } else {
    name_len = (int) strlen(var_name);
    end = s + strlen(s);
    dst[0] = '\0';
 
    for (; (s = mg_strcasestr(s, var_name)) != NULL; s += name_len) {
      if (s[name_len] == '=') {
        s += name_len + 1;
        if ((p = strchr(s, ' ')) == NULL)
          p = end;
        if (p[-1] == ';')
          p--;
        if (*s == '"' && p[-1] == '"' && p > s + 1) {
          s++;
          p--;
        }
        if ((size_t) (p - s) < dst_size) {
          len = p - s;
          mg_strlcpy(dst, s, (size_t) len + 1);
        } else {
          len = -3;
        }
        break;
      }
    }
  }
  return len;
}

Here is the call graph for this function:

mg_get_header()

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

Definition at line 693 of file mongoose4.cxx.

                                                                              {
  return get_header(&conn->request_info, name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mg_get_option()

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

Definition at line 870 of file mongoose4.cxx.

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

Here is the call graph for this function:

mg_get_valid_option_names()

const char ** mg_get_valid_option_names

(

void

)

Definition at line 855 of file mongoose4.cxx.

                                             {
  return config_options;
}

mg_get_var()

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

Definition at line 2631 of file mongoose4.cxx.

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

Here is the call graph for this function:

mg_md5()

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

Definition at line 1090 of file mongoose4.cxx.

                                {
  unsigned char hash[16];
  const char *p;
  va_list ap;
  MD5_CTX ctx;
 
  MD5Init(&ctx);
 
  va_start(ap, buf);
  while ((p = va_arg(ap, const char *)) != NULL) {
    MD5Update(&ctx, (const unsigned char *) p, (unsigned) strlen(p));
  }
  va_end(ap);
 
  MD5Final(hash, &ctx);
  bin2str(buf, hash, sizeof(hash));
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mg_modify_passwords_file()

int mg_modify_passwords_file	(	const char *	passwords_file_name,
		const char *	domain,
		const char *	user,
		const char *	password
	)

Definition at line 1314 of file mongoose4.cxx.

                                                                 {
  int found;
  char line[512], u[512], d[512], ha1[33], tmp[PATH_MAX];
  FILE *fp, *fp2;
 
  found = 0;
  fp = fp2 = NULL;
 
  // Regard empty password as no password - remove user record.
  if (pass != NULL && pass[0] == '\0') {
    pass = NULL;
  }
 
  (void) snprintf(tmp, sizeof(tmp), "%s.tmp", fname);
 
  // Create the file if does not exist
  if ((fp = fopen(fname, "a+")) != NULL) {
    fclose(fp);
  }
 
  // Open the given file and temporary file
  if ((fp = fopen(fname, "r")) == NULL) {
    return 0;
  } else if ((fp2 = fopen(tmp, "w+")) == NULL) {
    fclose(fp);
    return 0;
  }
 
  // Copy the stuff to temporary file
  while (fgets(line, sizeof(line), fp) != NULL) {
    if (sscanf(line, "%[^:]:%[^:]:%*s", u, d) != 2) {
      continue;
    }
 
    if (!strcmp(u, user) && !strcmp(d, domain)) {
      found++;
      if (pass != NULL) {
        mg_md5(ha1, user, ":", domain, ":", pass, NULL);
        fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
      }
    } else {
      fprintf(fp2, "%s", line);
    }
  }
 
  // If new user, just add it
  if (!found && pass != NULL) {
    mg_md5(ha1, user, ":", domain, ":", pass, NULL);
    fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
  }
 
  // Close files
  fclose(fp);
  fclose(fp2);
 
  // Put the temp file in place of real file
  remove(fname);
  rename(tmp, fname);
 
  return 1;
}

Here is the call graph for this function:

mg_printf()

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

Here is the caller graph for this function:

mg_read()

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

Definition at line 2529 of file mongoose4.cxx.

                                                            {
  int n, buffered_len, nread = 0;
  int64_t left;
 
  if (conn->content_len <= 0) {
    return 0;
  }
 
  // conn->buf           body
  //    |=================|==========|===============|
  //    |<--request_len-->|                          |
  //    |<-----------data_len------->|      conn->buf + conn->buf_size
 
  // First, check for data buffered in conn->buf by read_request().
  if (len > 0 && (buffered_len = conn->data_len - conn->request_len) > 0) {
    char *body = conn->buf + conn->request_len;
    if (buffered_len > len) buffered_len = len;
    if (buffered_len > conn->content_len) buffered_len = (int)conn->content_len;
 
    memcpy(buf, body, (size_t) buffered_len);
    memmove(body, body + buffered_len,
            &conn->buf[conn->data_len] - &body[buffered_len]);
    len -= buffered_len;
    conn->data_len -= buffered_len;
    nread += buffered_len;
  }
 
  // Read data from the socket.
  if (len > 0 && (left = left_to_read(conn)) > 0) {
    if (left < len) {
      len = (int) left;
    }
    n = pull_all(NULL, conn, (char *) buf + nread, (int) len);
    nread = n >= 0 ? nread + n : n;
  }
 
  return nread;
}

Here is the call graph for this function:

mg_send_file()

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

Definition at line 3332 of file mongoose4.cxx.

                                                                {
  struct file file = STRUCT_FILE_INITIALIZER;
  if (mg_stat(path, &file)) {
    handle_file_request(conn, path, &file);
  } else {
    send_http_error(conn, 404, "Not Found", "%s", "File not found");
  }
}

Here is the call graph for this function:

mg_start()

struct mg_context * mg_start	(	const char **	configuration_options,
		mg_event_handler_t	func,
		void *	user_data
	)

Definition at line 5466 of file mongoose4.cxx.

                                             {
  struct mg_context *ctx;
  const char *name, *value, *default_value;
  int i;
 
#if defined(_WIN32) && !defined(__SYMBIAN32__)
  WSADATA data;
  WSAStartup(MAKEWORD(2,2), &data);
#endif // _WIN32
 
  // Allocate context and initialize reasonable general case defaults.
  // TODO(lsm): do proper error handling here.
  if ((ctx = (struct mg_context *) calloc(1, sizeof(*ctx))) == NULL) {
    return NULL;
  }
  ctx->event_handler = func;
  ctx->user_data = user_data;
 
  while (options && (name = *options++) != NULL) {
    if ((i = get_option_index(name)) == -1) {
      cry(fc(ctx), "Invalid option: %s", name);
      free_context(ctx);
      return NULL;
    } else if ((value = *options++) == NULL) {
      cry(fc(ctx), "%s: option value cannot be NULL", name);
      free_context(ctx);
      return NULL;
    }
    if (ctx->config[i] != NULL) {
      cry(fc(ctx), "warning: %s: duplicate option", name);
      free(ctx->config[i]);
    }
    ctx->config[i] = mg_strdup(value);
    DEBUG_TRACE(("[%s] -> [%s]", name, value));
  }
 
  // Set default value if needed
  for (i = 0; config_options[i * 2] != NULL; i++) {
    default_value = config_options[i * 2 + 1];
    if (ctx->config[i] == NULL && default_value != NULL) {
      ctx->config[i] = mg_strdup(default_value);
    }
  }
 
  // NOTE(lsm): order is important here. SSL certificates must
  // be initialized before listening ports. UID must be set last.
  if (!set_gpass_option(ctx) ||
#if !defined(NO_SSL)
      !set_ssl_option(ctx) ||
#endif
      !set_ports_option(ctx) ||
#if !defined(_WIN32)
      !set_uid_option(ctx) ||
#endif
      !set_acl_option(ctx)) {
    free_context(ctx);
    return NULL;
  }
 
#if !defined(_WIN32) && !defined(__SYMBIAN32__)
  // Ignore SIGPIPE signal, so if browser cancels the request, it
  // won't kill the whole process.
  (void) signal(SIGPIPE, SIG_IGN);
#endif // !_WIN32
 
  (void) pthread_mutex_init(&ctx->mutex, NULL);
  (void) pthread_cond_init(&ctx->cond, NULL);
  (void) pthread_cond_init(&ctx->sq_empty, NULL);
  (void) pthread_cond_init(&ctx->sq_full, NULL);
 
  // Start master (listening) thread
  mg_start_thread(master_thread, ctx);
 
  // Start worker threads
  for (i = 0; i < atoi(ctx->config[NUM_THREADS]); i++) {
    if (mg_start_thread(worker_thread, ctx) != 0) {
      cry(fc(ctx), "Cannot start worker thread: %ld", (long) ERRNO);
    } else {
      ctx->num_threads++;
    }
  }
 
  return ctx;
}

Here is the call graph for this function:

mg_start_thread()

int mg_start_thread	(	mg_thread_func_t	f,
		void *	p
	)

Definition at line 1802 of file mongoose4.cxx.

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

Here is the caller graph for this function:

mg_stop()

void mg_stop

(

struct mg_context *

ctx

)

Definition at line 5452 of file mongoose4.cxx.

                                     {
  ctx->stop_flag = 1;
 
  // Wait until mg_fini() stops
  while (ctx->stop_flag != 2) {
    (void) mg_sleep(10);
  }
  free_context(ctx);
 
#if defined(_WIN32) && !defined(__SYMBIAN32__)
  (void) WSACleanup();
#endif // _WIN32
}

Here is the call graph for this function:

mg_upload()

FILE * mg_upload	(	struct mg_connection *	conn,
		const char *	destination_dir,
		char *	path,
		int	path_len
	)

Definition at line 4543 of file mongoose4.cxx.

                                          {
  const char *content_type_header, *boundary_start;
  char *buf, fname[1024], boundary[100], *s;
  int bl, n, i, j, headers_len, boundary_len, eof, buf_len, to_read, len = 0;
  FILE *fp;
 
  // Request looks like this:
  //
  // POST /upload HTTP/1.1
  // Host: 127.0.0.1:8080
  // Content-Length: 244894
  // Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryRVr
  //
  // ------WebKitFormBoundaryRVr
  // Content-Disposition: form-data; name="file"; filename="accum.png"
  // Content-Type: image/png
  //
  //  <89>PNG
  //  <PNG DATA>
  // ------WebKitFormBoundaryRVr
 
  // Extract boundary string from the Content-Type header
  if ((content_type_header = mg_get_header(conn, "Content-Type")) == NULL ||
      (boundary_start = mg_strcasestr(content_type_header,
                                      "boundary=")) == NULL ||
      (sscanf(boundary_start, "boundary=\"%99[^\"]\"", boundary) == 0 &&
       sscanf(boundary_start, "boundary=%99s", boundary) == 0) ||
      boundary[0] == '\0') {
    return NULL;
  }
 
  boundary_len = strlen(boundary);
  bl = boundary_len + 4;  // \r\n--<boundary>
 
  //                     buf
  // conn->buf            |<--------- buf_len ------>|
  //    |=================|==========|===============|
  //    |<--request_len-->|<--len--->|               |
  //    |<-----------data_len------->|      conn->buf + conn->buf_size
 
  buf = conn->buf + conn->request_len;
  buf_len = conn->buf_size - conn->request_len;
  len = conn->data_len - conn->request_len;
 
  for (;;) {
    // Pull in headers
    assert(len >= 0 && len <= buf_len);
    to_read = buf_len - len;
    if (to_read > left_to_read(conn)) {
      to_read = (int) left_to_read(conn);
    }
    while (len < buf_len &&
           (n = pull(NULL, conn, buf + len, to_read)) > 0) {
      len += n;
    }
    if ((headers_len = get_request_len(buf, len)) <= 0) {
      break;
    }
 
    // Fetch file name.
    fname[0] = '\0';
    for (i = j = 0; i < headers_len; i++) {
      if (buf[i] == '\r' && buf[i + 1] == '\n') {
        buf[i] = buf[i + 1] = '\0';
        // TODO(lsm): don't expect filename to be the 3rd field,
        // parse the header properly instead.
        sscanf(&buf[j], "Content-Disposition: %*s %*s filename=\"%1023[^\"]",
               fname);
        j = i + 2;
      }
    }
 
    // Give up if the headers are not what we expect
    if (fname[0] == '\0') {
      break;
    }
 
    // Move data to the beginning of the buffer
    assert(len >= headers_len);
    memmove(buf, &buf[headers_len], len - headers_len);
    len -= headers_len;
    conn->data_len = conn->request_len + len;
 
    // We open the file with exclusive lock held. This guarantee us
    // there is no other thread can save into the same file simultaneously.
    fp = NULL;
 
    // Construct destination file name. Do not allow paths to have slashes.
    if ((s = strrchr(fname, '/')) == NULL &&
        (s = strrchr(fname, '\\')) == NULL) {
      s = fname;
    }
 
    // Open file in binary mode. TODO: set an exclusive lock.
    snprintf(path, path_len, "%s/%s", destination_dir, s);
    if ((fp = fopen(path, "wb")) == NULL) {
      break;
    }
 
    // Read POST data, write into file until boundary is found.
    eof = n = 0;
    do {
      len += n;
      for (i = 0; i < len - bl; i++) {
        if (!memcmp(&buf[i], "\r\n--", 4) &&
            !memcmp(&buf[i + 4], boundary, boundary_len)) {
          // Found boundary, that's the end of file data.
          fwrite(buf, 1, i, fp);
          eof = 1;
          memmove(buf, &buf[i + bl], len - (i + bl));
          len -= i + bl;
          break;
        }
      }
      if (!eof && len > bl) {
        fwrite(buf, 1, len - bl, fp);
        memmove(buf, &buf[len - bl], bl);
        len = bl;
      }
      to_read = buf_len - len;
      if (to_read > left_to_read(conn)) {
        to_read = (int) left_to_read(conn);
      }
    } while (!eof && (n = pull(NULL, conn, buf + len, to_read)) > 0);
    conn->data_len = conn->request_len + len;
 
    if (eof) {
      rewind(fp);
      return fp;
    } else {
      fclose(fp);
    }
  }
 
  return NULL;
}

Here is the call graph for this function:

mg_url_decode()

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

Definition at line 2606 of file mongoose4.cxx.

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

mg_version()

const char * mg_version

(

void

)

Definition at line 2396 of file mongoose4.cxx.

                             {
  return MONGOOSE_VERSION;
}

Here is the caller graph for this function:

mg_websocket_handshake()

void mg_websocket_handshake

(

struct mg_connection *

)

mg_websocket_read()

int mg_websocket_read	(	struct mg_connection *	,
		int *	bits,
		char **	data
	)

mg_websocket_write()

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

mg_write()

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

Definition at line 2568 of file mongoose4.cxx.

                                                                   {
  time_t now;
  int64_t n, total, allowed;
 
  if (conn->throttle > 0) {
    if ((now = time(NULL)) != conn->last_throttle_time) {
      conn->last_throttle_time = now;
      conn->last_throttle_bytes = 0;
    }
    allowed = conn->throttle - conn->last_throttle_bytes;
    if (allowed > (int64_t) len) {
      allowed = len;
    }
    if ((total = push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
                      (int64_t) allowed)) == allowed) {
      buf = (char *) buf + total;
      conn->last_throttle_bytes += total;
      while (total < (int64_t) len && conn->ctx->stop_flag == 0) {
        allowed = conn->throttle > (int64_t) len - total ?
          (int64_t) len - total : conn->throttle;
        if ((n = push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
                      (int64_t) allowed)) != allowed) {
          break;
        }
        sleep(1);
        conn->last_throttle_bytes = allowed;
        conn->last_throttle_time = time(NULL);
        buf = (char *) buf + n;
        total += n;
      }
    }
  } else {
    total = push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
                 (int64_t) len);
  }
  return (int) total;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

conn

struct mg_connection* mg_event::conn

Definition at line 66 of file mongoose4.h.

conn_data

void* mg_event::conn_data

Definition at line 63 of file mongoose4.h.

event_param

void* mg_event::event_param

Definition at line 64 of file mongoose4.h.

http_headers

struct mg_request_info::mg_header mg_request_info::http_headers[64]

http_version

const char* mg_request_info::http_version

Definition at line 39 of file mongoose4.h.

is_ssl

int mg_request_info::is_ssl

Definition at line 44 of file mongoose4.h.

name

const char* mg_request_info::mg_header::name

Definition at line 48 of file mongoose4.h.

num_headers

int mg_request_info::num_headers

Definition at line 46 of file mongoose4.h.

query_string

const char* mg_request_info::query_string

Definition at line 40 of file mongoose4.h.

remote_ip

long mg_request_info::remote_ip

Definition at line 42 of file mongoose4.h.

remote_port

int mg_request_info::remote_port

Definition at line 43 of file mongoose4.h.

remote_user

const char* mg_request_info::remote_user

Definition at line 41 of file mongoose4.h.

request_info

struct mg_request_info* mg_event::request_info

Definition at line 67 of file mongoose4.h.

request_method

const char* mg_request_info::request_method

Definition at line 37 of file mongoose4.h.

type

int mg_event::type

Definition at line 54 of file mongoose4.h.

uri

const char* mg_request_info::uri

Definition at line 38 of file mongoose4.h.

user_data

void* mg_event::user_data

Definition at line 62 of file mongoose4.h.

value

const char* mg_request_info::mg_header::value

Definition at line 49 of file mongoose4.h.