[PATCH] Mongoose HTTPd from 3.2 to 3.9 (last commit before MIT -> GPL)
Nick Withers
nick.withers at anu.edu.au
Thu Nov 7 06:59:06 UTC 2013
Hey all,
The following patch updates the Mongoose HTTP server from 3.2 to 3.9, at
the last point before the MIT -> GPL license change (going off the
author's confirmation at https://groups.google.com/forum/#!
topic/mongoose-users/aafbOnHonkI ).
____
>From 76c451c9d101068dee796b715d2201d6956b0347 Mon Sep 17 00:00:00 2001
From: Nick Withers <nick.withers at anu.edu.au>
Date: Thu, 7 Nov 2013 17:46:54 +1100
Subject: [PATCH] Update to Mongoose 3.9 at the last point before the MIT ->
GPL license change
[See https://groups.google.com/forum/#!topic/mongoose-users/aafbOnHonkI regarding license change]
The RTEMS patches described in the following emails and made to the previous Mongoose base have been applied:
- http://www.rtems.org/pipermail/rtems-devel/2012-July/001345.html
- http://www.rtems.org/pipermail/rtems-devel/2012-July/001343.html
- http://www.rtems.org/pipermail/rtems-devel/2012-July/001346.html (except to mongoose.1, see below)
...as well as a patch very similar to that discussed at http://forums.bannister.org/ubbthreads.php?ubb=showflat&topic=7600&gonew=1 to provide poll() (which might be able to go away soon, with incoming RTEMS poll() support)
mongoose.1 appears to have been removed from the upstream distribution.
Note that the short form of options (e.g., "u" instead of "run_as_user") are no longer available (upstream)
---
cpukit/mghttpd/mongoose.1 | 183 ---
cpukit/mghttpd/mongoose.c | 3503 ++++++++++++++++++++++++++++++---------------
cpukit/mghttpd/mongoose.h | 290 +++-
3 files changed, 2572 insertions(+), 1404 deletions(-)
delete mode 100644 cpukit/mghttpd/mongoose.1
diff --git a/cpukit/mghttpd/mongoose.1 b/cpukit/mghttpd/mongoose.1
deleted file mode 100644
index 0d37585..0000000
--- a/cpukit/mghttpd/mongoose.1
+++ /dev/null
@@ -1,183 +0,0 @@
-.\" Process this file with
-.\" groff -man -Tascii mongoose.1
-.\" $Id: mongoose.1,v 1.12 2008/11/29 15:32:42 drozd Exp $
-.Dd Aug 31, 2010
-.Dt mongoose 1
-.Sh NAME
-.Nm mongoose
-.Nd lightweight web server
-.Sh SYNOPSIS
-.Nm
-.Op Ar config_file
-.Op Ar OPTIONS
-.Nm
-.Fl A Ar htpasswd_file domain_name user_name password
-.Sh DESCRIPTION
-.Nm
-is small, fast and easy to use web server with CGI, SSL, MD5 authorization,
-and basic SSI support.
-.Pp
-.Nm
-does not detach from terminal, and uses current working directory
-as the web root, unless
-.Fl r
-option is specified.
-It is possible to specify multiple ports to listen on. For example, to make
-mongoose listen on HTTP port 80 and HTTPS port 443, one should start it as:
-.Nm
-.Fl s Ar cert.pem Fl p Ar 80,443s
-.Pp
-Unlike other web servers,
-.Nm
-does not require CGI scripts be put in a special directory. CGI scripts can
-be anywhere. CGI (and SSI) files are recognized by the file name pattern.
-.Nm
-uses shell-like glob patterns with the following syntax:
-.Bl -tag -compact -width indent
-.It **
-Matches everything
-.It *
-Matches everything but slash character, '/'
-.It ?
-Matches any character
-.It $
-Matches the end of the string
-.It |
-Matches if pattern on the left side or the right side matches. Pattern on the
-left side is matched first
-.El
-All other characters in the pattern match themselves.
-.Pp
-If no arguments are given,
-.Nm
-searches for a configuration file called "mongoose.conf" in the same directory
-where mongoose binary is located. Alternatively, a file name could be
-specified in the command line. Format of the configuration file is the same
-as for the command line options except that each option must be specified
-on a separate line, leading dashes for option names must be omitted.
-Lines beginning with '#' and empty lines are ignored.
-.Pp
-.Sh OPTIONS
-.Bl -tag -width indent
-.It Fl A Ar htpasswd_file domain_name user_name password
-Add/edit user's password in the passwords file. Deleting users can be done
-with any text editor. Functionality is similar to Apache's
-.Ic htdigest
-utility.
-.It Fl C Ar cgi_pattern
-All files that fully match cgi_pattern are treated as CGI.
-Default pattern allows CGI files be
-anywhere. To restrict CGIs to certain directory, use e.g. "-C /cgi-bin/**.cgi".
-Default: "**.cgi$|**.pl$|**.php$"
-.It Fl E Ar cgi_environment
-Extra environment variables to be passed to the CGI script in addition to
-standard ones. The list must be comma-separated list of X=Y pairs, like this:
-"VARIABLE1=VALUE1,VARIABLE2=VALUE2". Default: ""
-.It Fl G Ar put_delete_passwords_file
-PUT and DELETE passwords file. This must be specified if PUT or
-DELETE methods are used. Default: ""
-.It Fl I Ar cgi_interpreter
-Use
-.Ar cgi_interpreter
-as a CGI interpreter for all CGI scripts regardless script extension.
-Mongoose decides which interpreter to use by looking at
-the first line of a CGI script. Default: "".
-.It Fl M Ar max_request_size
-Maximum HTTP request size in bytes. Default: "16384"
-.It Fl P Ar protect_uri
-Comma separated list of URI=PATH pairs, specifying that given URIs
-must be protected with respected password files. Default: ""
-.It Fl R Ar authentication_domain
-Authorization realm. Default: "mydomain.com"
-.It Fl S Ar ssi_pattern
-All files that fully match ssi_pattern are treated as SSI.
-Unknown SSI directives are silently ignored. Currently, two SSI directives
-are supported, "include" and "exec". Default: "**.shtml$|**.shtm$"
-.It Fl a Ar access_log_file
-Access log file. Default: "", no logging is done.
-.It Fl d Ar enable_directory_listing
-Enable/disable directory listing. Default: "yes"
-.It Fl e Ar error_log_file
-Error log file. Default: "", no errors are logged.
-.It Fl g Ar global_passwords_file
-Location of a global passwords file. If set, per-directory .htpasswd files are
-ignored, and all requests must be authorised against that file. Default: ""
-.It Fl i Ar index_files
-Comma-separated list of files to be treated as directory index files.
-Default: "index.html,index.htm,index.cgi"
-.It Fl l Ar access_control_list
-Specify access control list (ACL). ACL is a comma separated list
-of IP subnets, each subnet is prepended by '-' or '+' sign. Plus means allow,
-minus means deny. If subnet mask is
-omitted, like "-1.2.3.4", then it means single IP address. Mask may vary
-from 0 to 32 inclusive. On each request, full list is traversed, and
-last match wins. Default setting is to allow all. For example, to allow only
-192.168/16 subnet to connect, run "mongoose -0.0.0.0/0,+192.168/16".
-Default: ""
-.It Fl m Ar extra_mime_types
-Extra mime types to recognize, in form
-"extension1=type1,extension2=type2,...". Extension must include dot.
-Example: "mongoose -m .cpp=plain/text,.java=plain/text". Default: ""
-.It Fl p Ar listening_ports
-Comma-separated list of ports to listen on. If the port is SSL, a letter 's'
-must be appeneded, for example, "-p 80,443s" will open port 80 and port 443,
-and connections on port 443 will be SSL-ed. It is possible to specify an
-IP address to bind to. In this case, an IP address and a colon must be
-prepended to the port number. For example, to bind to a loopback interface
-on port 80 and to all interfaces on HTTPS port 443, use
-"mongoose -p 127.0.0.1:80,443s". Default: "8080"
-.It Fl r Ar document_root
-Location of the WWW root directory. Default: "."
-.It Fl s Ar ssl_certificate
-Location of SSL certificate file. Default: ""
-.It Fl t Ar num_threads
-Number of worker threads to start. Default: "10"
-.It Fl u Ar run_as_user
-Switch to given user's credentials after startup. Default: ""
-.It Fl w Ar url_rewrite_patterns
-Comma-separated list of URL rewrites in the form of
-"pattern=substitution,..." If the "pattern" matches some prefix
-of the requested URL, then matched prefix gets substituted with "substitution".
-For example, "-w /config=/etc,**.doc|**.rtf=/path/to/cgi-bin/handle_doc.cgi"
-will serve all URLs that start with "/config" from the "/etc" directory, and
-call handle_doc.cgi script for .doc and .rtf file requests. If some pattern
-matches, no further matching/substitution is performed
-(first matching pattern wins). Use full paths in substitutions. Default: ""
-.It Fl x Ar thread_stack_size
-Use the given amount of stack for each thread. Default: ""
-.It Fl y Ar thread_priority
-Use the given priority for all posix threads. If this option is used without the
-thread_policy option, the systems default scheduling policy will be used for the
-threads instead of inheriting the policy of the creating thread. Default: ""
-.It Fl z Ar thread_policy
-Select the posix scheduling policy for the threads. Possible Values are 's' for
-sporadic (not on all systems available), 'r' for round robin, 'f' for fifo or
-'o' for other scheduling strategie. If this option is used without the
-thread_priority option, the systems default priority will be used for the
-threads instead of inheriting the priority of the creating thread. Default: ""
-.El
-.Pp
-.Sh EMBEDDING
-.Nm
-was designed to be embeddable into C/C++ applications. Since the
-source code is contained in single C file, it is fairly easy to embed it
-and follow the updates. Please refer to http://code.google.com/p/mongoose
-for details.
-.Pp
-.Sh EXAMPLES
-.Bl -tag -width indent
-.It Nm Fl r Ar /var/www Fl s Ar /etc/cert.pem Fl p Ar 8080,8043s
-Start serving files from /var/www. Listen on port 8080 for HTTP, and 8043
-for HTTPS connections. Use /etc/cert.pem as SSL certificate file.
-.It Nm Fl l Ar -0.0.0.0/0,+10.0.0.0/8,+1.2.3.4
-Deny connections from everywhere, allow only IP address 1.2.3.4 and
-all IP addresses from 10.0.0.0/8 subnet to connect.
-.It Nm Fl w Ar **=/usr/bin/script.cgi
-Invoke /usr/bin/script.cgi for every incoming request, regardless of the URL.
-.El
-.Pp
-.Sh COPYRIGHT
-.Nm
-is licensed under the terms of the MIT license.
-.Sh AUTHOR
-.An Sergey Lyubka Aq valenok at gmail.com .
diff --git a/cpukit/mghttpd/mongoose.c b/cpukit/mghttpd/mongoose.c
index d28d8a7..8541ad7 100644
--- a/cpukit/mghttpd/mongoose.c
+++ b/cpukit/mghttpd/mongoose.c
@@ -1,4 +1,4 @@
-// Copyright (c) 2004-2011 Sergey Lyubka
+// Copyright (c) 2004-2013 Sergey Lyubka
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
@@ -19,7 +19,7 @@
// THE SOFTWARE.
#if HAVE_CONFIG_H
- #include "config.h"
+#include "config.h"
#endif
#if defined(__rtems__)
@@ -28,14 +28,31 @@
#endif // __rtems__
#if defined(_WIN32)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS // Disable deprecation warning in VS2005
+#endif
#else
+#ifdef __linux__
#define _XOPEN_SOURCE 600 // For flockfile() on Linux
+#endif
#define _LARGEFILE_SOURCE // Enable 64-bit file offsets
#define __STDC_FORMAT_MACROS // <inttypes.h> wants this for C++
#define __STDC_LIMIT_MACROS // C++ wants that for INT64_MAX
#endif
+#if defined (_MSC_VER)
+// conditional expression is constant: introduced by FD_SET(..)
+#pragma warning (disable : 4127)
+// non-constant aggregate initializer: issued due to missing C99 support
+#pragma warning (disable : 4204)
+#endif
+
+// Disable WIN32_LEAN_AND_MEAN.
+// This makes windows.h always include winsock2.h
+#ifdef WIN32_LEAN_AND_MEAN
+#undef WIN32_LEAN_AND_MEAN
+#endif
+
#if defined(__SYMBIAN32__)
#define NO_SSL // SSL is not supported
#define NO_CGI // CGI is not supported
@@ -61,6 +78,7 @@
#include <stdio.h>
#if defined(_WIN32) && !defined(__SYMBIAN32__) // Windows specific
+#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0400 // To make it link in VS2005
#include <windows.h>
@@ -73,12 +91,9 @@
#include <direct.h>
#include <io.h>
#else // _WIN32_WCE
-#include <winsock2.h>
-#include <ws2tcpip.h>
#define NO_CGI // WinCE has no pipes
typedef long off_t;
-#define BUFSIZ 4096
#define errno GetLastError()
#define strerror(x) _ultoa(x, (char *) _alloca(sizeof(x) *3 ), 10)
@@ -97,9 +112,9 @@ typedef long off_t;
#if defined(_MSC_VER) && _MSC_VER < 1300
#define STRX(x) #x
#define STR(x) STRX(x)
-#define __func__ "line " STR(__LINE__)
-#define strtoull(x, y, z) strtoul(x, y, z)
-#define strtoll(x, y, z) strtol(x, y, z)
+#define __func__ __FILE__ ":" STR(__LINE__)
+#define strtoull(x, y, z) (unsigned __int64) _atoi64(x)
+#define strtoll(x, y, z) _atoi64(x)
#else
#define __func__ __FUNCTION__
#define strtoull(x, y, z) _strtoui64(x, y, z)
@@ -110,8 +125,6 @@ typedef long off_t;
#define NO_SOCKLEN_T
#define SSL_LIB "ssleay32.dll"
#define CRYPTO_LIB "libeay32.dll"
-#define DIRSEP '\\'
-#define IS_DIRSEP_CHAR(c) ((c) == '/' || (c) == '\\')
#define O_NONBLOCK 0
#if !defined(EWOULDBLOCK)
#define EWOULDBLOCK WSAEWOULDBLOCK
@@ -125,18 +138,28 @@ typedef long off_t;
#define vsnprintf _vsnprintf
#define mg_sleep(x) Sleep(x)
-#define pipe(x) _pipe(x, BUFSIZ, _O_BINARY)
+#define pipe(x) _pipe(x, MG_BUF_LEN, _O_BINARY)
+#ifndef popen
#define popen(x, y) _popen(x, y)
+#endif
+#ifndef pclose
#define pclose(x) _pclose(x)
+#endif
#define close(x) _close(x)
#define dlsym(x,y) GetProcAddress((HINSTANCE) (x), (y))
#define RTLD_LAZY 0
-#define fseeko(x, y, z) fseek((x), (y), (z))
+#define fseeko(x, y, z) _lseeki64(_fileno(x), (y), (z))
#define fdopen(x, y) _fdopen((x), (y))
#define write(x, y, z) _write((x), (y), (unsigned) z)
#define read(x, y, z) _read((x), (y), (unsigned) z)
#define flockfile(x) EnterCriticalSection(&global_log_file_lock)
#define funlockfile(x) LeaveCriticalSection(&global_log_file_lock)
+#define sleep(x) Sleep((x) * 1000)
+#define rmdir(x) _rmdir(x)
+
+#if !defined(va_copy)
+#define va_copy(x, y) x = y
+#endif // !va_copy MINGW #defines va_copy
#if !defined(fileno)
#define fileno(x) _fileno(x)
@@ -147,14 +170,11 @@ typedef struct {HANDLE signal, broadcast;} pthread_cond_t;
typedef DWORD pthread_t;
#define pid_t HANDLE // MINGW typedefs pid_t to int. Using #define here.
-struct timespec {
- long tv_nsec;
- long tv_sec;
-};
-
static int pthread_mutex_lock(pthread_mutex_t *);
static int pthread_mutex_unlock(pthread_mutex_t *);
-static FILE *mg_fopen(const char *path, const char *mode);
+static void to_unicode(const char *path, wchar_t *wbuf, size_t wbuf_len);
+struct file;
+static char *mg_fgets(char *buf, size_t size, struct file *filep, char **p);
#if defined(HAVE_STDINT)
#include <stdint.h>
@@ -177,10 +197,18 @@ typedef struct DIR {
struct dirent result;
} DIR;
+
+// Mark required libraries
+#ifdef _MSC_VER
+#pragma comment(lib, "Ws2_32.lib")
+#endif
+
#else // UNIX specific
#include <sys/wait.h>
#include <sys/socket.h>
-#include <sys/select.h>
+#ifdef HAVE_POLL
+#include <sys/poll.h>
+#endif
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
@@ -206,16 +234,12 @@ typedef struct DIR {
#define CRYPTO_LIB "libcrypto.so"
#endif
#endif
-#define DIRSEP '/'
-#define IS_DIRSEP_CHAR(c) ((c) == '/')
#ifndef O_BINARY
#define O_BINARY 0
#endif // O_BINARY
#define closesocket(a) close(a)
-#define mg_fopen(x, y) fopen(x, y)
#define mg_mkdir(x, y) mkdir(x, y)
#define mg_remove(x) remove(x)
-#define mg_rename(x, y) rename(x, y)
#define mg_sleep(x) usleep((x) * 1000)
#define ERRNO errno
#define INVALID_SOCKET (-1)
@@ -225,12 +249,23 @@ typedef int SOCKET;
#endif // End of Windows and UNIX specific includes
+#ifndef HAVE_POLL
+struct pollfd {
+ SOCKET fd;
+ short events;
+ short revents;
+};
+#define POLLIN 1
+#endif
+
#include "mongoose.h"
-#define MONGOOSE_VERSION "3.2"
+#define MONGOOSE_VERSION "3.9"
#define PASSWORDS_FILE_NAME ".htpasswd"
#define CGI_ENVIRONMENT_SIZE 4096
#define MAX_CGI_ENVIR_VARS 64
+#define MG_BUF_LEN 8192
+#define MAX_REQUEST_SIZE 16384
#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
#ifdef _WIN32
@@ -240,6 +275,10 @@ static pthread_t pthread_self(void) {
}
#endif // _WIN32
+#ifdef DEBUG_TRACE
+#undef DEBUG_TRACE
+#define DEBUG_TRACE(x)
+#else
#if defined(DEBUG)
#define DEBUG_TRACE(x) do { \
flockfile(stdout); \
@@ -254,57 +293,45 @@ static pthread_t pthread_self(void) {
#else
#define DEBUG_TRACE(x)
#endif // DEBUG
+#endif // DEBUG_TRACE
// Darwin prior to 7.0 and Win32 do not have socklen_t
#ifdef NO_SOCKLEN_T
typedef int socklen_t;
#endif // NO_SOCKLEN_T
+#define _DARWIN_UNLIMITED_SELECT
+
+#define IP_ADDR_STR_LEN 50 // IPv6 hex string is 46 chars
#if !defined(MSG_NOSIGNAL)
#define MSG_NOSIGNAL 0
#endif
-typedef void * (*mg_thread_func_t)(void *);
+#if !defined(SOMAXCONN)
+#define SOMAXCONN 100
+#endif
+
+#if !defined(PATH_MAX)
+#define PATH_MAX 4096
+#endif
+
+// Size of the accepted socket queue
+#if !defined(MGSQLEN)
+#define MGSQLEN 20
+#endif
static const char *http_500_error = "Internal Server Error";
-// Snatched from OpenSSL includes. I put the prototypes here to be independent
-// from the OpenSSL source installation. Having this, mongoose + SSL can be
-// built on any system with binary SSL libraries installed.
+#if defined(NO_SSL_DL)
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#else
+// SSL loaded dynamically from DLL.
+// I put the prototypes here to be independent from OpenSSL source installation.
typedef struct ssl_st SSL;
typedef struct ssl_method_st SSL_METHOD;
typedef struct ssl_ctx_st SSL_CTX;
-#define SSL_ERROR_WANT_READ 2
-#define SSL_ERROR_WANT_WRITE 3
-#define SSL_FILETYPE_PEM 1
-#define CRYPTO_LOCK 1
-
-#if defined(NO_SSL_DL)
-extern void SSL_free(SSL *);
-extern int SSL_accept(SSL *);
-extern int SSL_connect(SSL *);
-extern int SSL_read(SSL *, void *, int);
-extern int SSL_write(SSL *, const void *, int);
-extern int SSL_get_error(const SSL *, int);
-extern int SSL_set_fd(SSL *, int);
-extern SSL *SSL_new(SSL_CTX *);
-extern SSL_CTX *SSL_CTX_new(SSL_METHOD *);
-extern SSL_METHOD *SSLv23_server_method(void);
-extern int SSL_library_init(void);
-extern void SSL_load_error_strings(void);
-extern int SSL_CTX_use_PrivateKey_file(SSL_CTX *, const char *, int);
-extern int SSL_CTX_use_certificate_file(SSL_CTX *, const char *, int);
-extern int SSL_CTX_use_certificate_chain_file(SSL_CTX *, const char *);
-extern void SSL_CTX_set_default_passwd_cb(SSL_CTX *, mg_callback_t);
-extern void SSL_CTX_free(SSL_CTX *);
-extern unsigned long ERR_get_error(void);
-extern char *ERR_error_string(unsigned long, char *);
-extern int CRYPTO_num_locks(void);
-extern void CRYPTO_set_locking_callback(void (*)(int, int, const char *, int));
-extern void CRYPTO_set_id_callback(unsigned long (*)(void));
-#else
-// Dynamically loaded SSL functionality
struct ssl_func {
const char *name; // SSL function name
void (*ptr)(void); // Function pointer
@@ -331,6 +358,10 @@ struct ssl_func {
#define SSL_load_error_strings (* (void (*)(void)) ssl_sw[15].ptr)
#define SSL_CTX_use_certificate_chain_file \
(* (int (*)(SSL_CTX *, const char *)) ssl_sw[16].ptr)
+#define SSLv23_client_method (* (SSL_METHOD * (*)(void)) ssl_sw[17].ptr)
+#define SSL_pending (* (int (*)(SSL *)) ssl_sw[18].ptr)
+#define SSL_CTX_set_verify (* (void (*)(SSL_CTX *, int, int)) ssl_sw[19].ptr)
+#define SSL_shutdown (* (int (*)(SSL *)) ssl_sw[20].ptr)
#define CRYPTO_num_locks (* (int (*)(void)) crypto_sw[0].ptr)
#define CRYPTO_set_locking_callback \
@@ -362,6 +393,10 @@ static struct ssl_func ssl_sw[] = {
{"SSL_CTX_free", NULL},
{"SSL_load_error_strings", NULL},
{"SSL_CTX_use_certificate_chain_file", NULL},
+ {"SSLv23_client_method", NULL},
+ {"SSL_pending", NULL},
+ {"SSL_CTX_set_verify", NULL},
+ {"SSL_shutdown", NULL},
{NULL, NULL}
};
@@ -399,83 +434,90 @@ struct vec {
size_t len;
};
-// Structure used by mg_stat() function. Uses 64 bit file length.
-struct mgstat {
- int is_directory; // Directory marker
- int64_t size; // File size
- time_t mtime; // Modification time
+struct file {
+ int is_directory;
+ time_t modification_time;
+ int64_t size;
+ FILE *fp;
+ const char *membuf; // Non-NULL if file data is in memory
+ // set to 1 if the content is gzipped
+ // in which case we need a content-encoding: gzip header
+ int gzipped;
};
+#define STRUCT_FILE_INITIALIZER {0, 0, 0, NULL, NULL, 0}
// Describes listening socket, or socket which was accept()-ed by the master
// thread and queued for future handling by the worker thread.
struct socket {
- struct socket *next; // Linkage
SOCKET sock; // Listening socket
union usa lsa; // Local socket address
union usa rsa; // Remote socket address
- int is_ssl; // Is socket SSL-ed
+ unsigned is_ssl:1; // Is port SSL-ed
+ unsigned ssl_redir:1; // Is port supposed to redirect everything to SSL port
};
+// NOTE(lsm): this enum shoulds be in sync with the config_options below.
enum {
CGI_EXTENSIONS, CGI_ENVIRONMENT, PUT_DELETE_PASSWORDS_FILE, CGI_INTERPRETER,
- PROTECT_URI, AUTHENTICATION_DOMAIN, SSI_EXTENSIONS, ACCESS_LOG_FILE,
- SSL_CHAIN_FILE, ENABLE_DIRECTORY_LISTING, ERROR_LOG_FILE,
- GLOBAL_PASSWORDS_FILE, INDEX_FILES,
- ENABLE_KEEP_ALIVE, ACCESS_CONTROL_LIST, MAX_REQUEST_SIZE,
- EXTRA_MIME_TYPES, LISTENING_PORTS,
- DOCUMENT_ROOT, SSL_CERTIFICATE, NUM_THREADS, RUN_AS_USER, REWRITE,
+ PROTECT_URI, AUTHENTICATION_DOMAIN, SSI_EXTENSIONS, THROTTLE,
+ ACCESS_LOG_FILE, ENABLE_DIRECTORY_LISTING, ERROR_LOG_FILE,
+ GLOBAL_PASSWORDS_FILE, INDEX_FILES, ENABLE_KEEP_ALIVE, ACCESS_CONTROL_LIST,
+ EXTRA_MIME_TYPES, LISTENING_PORTS, DOCUMENT_ROOT, SSL_CERTIFICATE,
+ NUM_THREADS, RUN_AS_USER, REWRITE, HIDE_FILES, REQUEST_TIMEOUT,
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_POLICY,
NUM_OPTIONS
};
static const char *config_options[] = {
- "C", "cgi_pattern", "**.cgi$|**.pl$|**.php$",
- "E", "cgi_environment", NULL,
- "G", "put_delete_passwords_file", NULL,
- "I", "cgi_interpreter", NULL,
- "P", "protect_uri", NULL,
- "R", "authentication_domain", "mydomain.com",
- "S", "ssi_pattern", "**.shtml$|**.shtm$",
- "a", "access_log_file", NULL,
- "c", "ssl_chain_file", NULL,
- "d", "enable_directory_listing", "yes",
- "e", "error_log_file", NULL,
- "g", "global_passwords_file", NULL,
- "i", "index_files", "index.html,index.htm,index.cgi,index.shtml,index.php",
- "k", "enable_keep_alive", "no",
- "l", "access_control_list", NULL,
- "M", "max_request_size", "16384",
- "m", "extra_mime_types", NULL,
- "p", "listening_ports", "8080",
- "r", "document_root", ".",
- "s", "ssl_certificate", NULL,
- "t", "num_threads", "10",
- "u", "run_as_user", NULL,
- "w", "url_rewrite_patterns", NULL,
- "x", "thread_stack_size", NULL,
- "y", "thread_priority", NULL,
- "z", "thread_policy", NULL,
+ "cgi_pattern", "**.cgi$|**.pl$|**.php$",
+ "cgi_environment", NULL,
+ "put_delete_auth_file", NULL,
+ "cgi_interpreter", NULL,
+ "protect_uri", NULL,
+ "authentication_domain", "mydomain.com",
+ "ssi_pattern", "**.shtml$|**.shtm$",
+ "throttle", NULL,
+ "access_log_file", NULL,
+ "enable_directory_listing", "yes",
+ "error_log_file", NULL,
+ "global_auth_file", NULL,
+ "index_files",
+ "index.html,index.htm,index.cgi,index.shtml,index.php,index.lp",
+ "enable_keep_alive", "no",
+ "access_control_list", NULL,
+ "extra_mime_types", NULL,
+ "listening_ports", "8080",
+ "document_root", NULL,
+ "ssl_certificate", NULL,
+ "num_threads", "50",
+ "run_as_user", NULL,
+ "url_rewrite_patterns", NULL,
+ "hide_files_patterns", NULL,
+ "request_timeout_ms", "30000",
+ "thread_stack_size", NULL,
+ "thread_priority", NULL,
+ "thread_policy", NULL,
NULL
};
-#define ENTRIES_PER_CONFIG_OPTION 3
struct mg_context {
- volatile int stop_flag; // Should we stop event loop
- SSL_CTX *ssl_ctx; // SSL context
- char *config[NUM_OPTIONS]; // Mongoose configuration parameters
- mg_callback_t user_callback; // User-defined callback function
- void *user_data; // User-defined data
+ volatile int stop_flag; // Should we stop event loop
+ SSL_CTX *ssl_ctx; // SSL context
+ char *config[NUM_OPTIONS]; // Mongoose configuration parameters
+ struct mg_callbacks callbacks; // User-defined callback function
+ void *user_data; // User-defined data
struct socket *listening_sockets;
+ int num_listening_sockets;
volatile int num_threads; // Number of threads
pthread_mutex_t mutex; // Protects (max|num)_threads
pthread_cond_t cond; // Condvar for tracking workers terminations
- struct socket queue[20]; // Accepted sockets
+ struct socket queue[MGSQLEN]; // Accepted sockets
volatile int sq_head; // Head of the socket queue
volatile int sq_tail; // Tail of the socket queue
- pthread_cond_t sq_full; // Singaled when socket is produced
+ pthread_cond_t sq_full; // Signaled when socket is produced
pthread_cond_t sq_empty; // Signaled when socket is consumed
};
@@ -483,36 +525,79 @@ struct mg_connection {
struct mg_request_info request_info;
struct mg_context *ctx;
SSL *ssl; // SSL descriptor
+ SSL_CTX *client_ssl_ctx; // SSL context for client connections
struct socket client; // Connected client
- time_t birth_time; // Time connection was accepted
+ time_t birth_time; // Time when request was received
int64_t num_bytes_sent; // Total bytes sent to client
int64_t content_len; // Content-Length header value
- int64_t consumed_content; // How many bytes of content is already read
+ int64_t consumed_content; // How many bytes of content have been read
char *buf; // Buffer for received data
char *path_info; // PATH_INFO part of the URL
int must_close; // 1 if connection must be closed
int buf_size; // Buffer size
int request_len; // Size of the request + headers in a buffer
int data_len; // Total size of data in a buffer
+ int status_code; // HTTP reply status code, e.g. 200
+ int throttle; // Throttling, bytes/sec. <= 0 means no throttle
+ time_t last_throttle_time; // Last time throttled data was sent
+ int64_t last_throttle_bytes;// Bytes sent this second
+};
+
+// Directory entry
+struct de {
+ struct mg_connection *conn;
+ char *file_name;
+ struct file file;
};
const char **mg_get_valid_option_names(void) {
return config_options;
}
-static void *call_user(struct mg_connection *conn, enum mg_event event) {
- conn->request_info.user_data = conn->ctx->user_data;
- return conn->ctx->user_callback == NULL ? NULL :
- conn->ctx->user_callback(event, conn, &conn->request_info);
+static int is_file_in_memory(struct mg_connection *conn, const char *path,
+ struct file *filep) {
+ size_t size = 0;
+ if ((filep->membuf = conn->ctx->callbacks.open_file == NULL ? NULL :
+ conn->ctx->callbacks.open_file(conn, path, &size)) != NULL) {
+ // NOTE: override filep->size only on success. Otherwise, it might break
+ // constructs like if (!mg_stat() || !mg_fopen()) ...
+ filep->size = size;
+ }
+ return filep->membuf != NULL;
+}
+
+static int is_file_opened(const struct file *filep) {
+ return filep->membuf != NULL || filep->fp != NULL;
+}
+
+static int mg_fopen(struct mg_connection *conn, const char *path,
+ const char *mode, struct file *filep) {
+ if (!is_file_in_memory(conn, path, filep)) {
+#ifdef _WIN32
+ wchar_t wbuf[PATH_MAX], wmode[20];
+ to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
+ MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, ARRAY_SIZE(wmode));
+ filep->fp = _wfopen(wbuf, wmode);
+#else
+ filep->fp = fopen(path, mode);
+#endif
+ }
+
+ return is_file_opened(filep);
+}
+
+static void mg_fclose(struct file *filep) {
+ if (filep != NULL && filep->fp != NULL) {
+ fclose(filep->fp);
+ }
}
static int get_option_index(const char *name) {
int i;
- for (i = 0; config_options[i] != NULL; i += ENTRIES_PER_CONFIG_OPTION) {
- if (strcmp(config_options[i], name) == 0 ||
- strcmp(config_options[i + 1], name) == 0) {
- return i / ENTRIES_PER_CONFIG_OPTION;
+ for (i = 0; config_options[i * 2] != NULL; i++) {
+ if (strcmp(config_options[i * 2], name) == 0) {
+ return i;
}
}
return -1;
@@ -544,9 +629,12 @@ static void sockaddr_to_string(char *buf, size_t len,
#endif
}
+static void cry(struct mg_connection *conn,
+ PRINTF_FORMAT_STRING(const char *fmt), ...) PRINTF_ARGS(2, 3);
+
// Print error message to the opened error log stream.
static void cry(struct mg_connection *conn, const char *fmt, ...) {
- char buf[BUFSIZ], src_addr[20];
+ char buf[MG_BUF_LEN], src_addr[IP_ADDR_STR_LEN];
va_list ap;
FILE *fp;
time_t timestamp;
@@ -558,10 +646,10 @@ static void cry(struct mg_connection *conn, const char *fmt, ...) {
// Do not lock when getting the callback value, here and below.
// I suppose this is fine, since function cannot disappear in the
// same way string option can.
- conn->request_info.log_message = buf;
- if (call_user(conn, MG_EVENT_LOG) == NULL) {
- fp = conn->ctx->config[ERROR_LOG_FILE] == NULL ? NULL :
- mg_fopen(conn->ctx->config[ERROR_LOG_FILE], "a+");
+ if (conn->ctx->callbacks.log_message == NULL ||
+ conn->ctx->callbacks.log_message(conn, buf) == 0) {
+ fp = conn->ctx == NULL || conn->ctx->config[ERROR_LOG_FILE] == NULL ? NULL :
+ fopen(conn->ctx->config[ERROR_LOG_FILE], "a+");
if (fp != NULL) {
flockfile(fp);
@@ -576,15 +664,12 @@ static void cry(struct mg_connection *conn, const char *fmt, ...) {
conn->request_info.uri);
}
- (void) fprintf(fp, "%s", buf);
+ fprintf(fp, "%s", buf);
fputc('\n', fp);
funlockfile(fp);
- if (fp != stderr) {
- fclose(fp);
- }
+ fclose(fp);
}
}
- conn->request_info.log_message = NULL;
}
// Return fake connection structure. Used for logging, if connection
@@ -599,6 +684,10 @@ const char *mg_version(void) {
return MONGOOSE_VERSION;
}
+struct mg_request_info *mg_get_request_info(struct mg_connection *conn) {
+ return &conn->request_info;
+}
+
static void mg_strlcpy(register char *dst, register const char *src, size_t n) {
for (; *src != '\0' && n > 1; n--) {
*dst++ = *src++;
@@ -645,7 +734,19 @@ static char * mg_strdup(const char *str) {
return mg_strndup(str, strlen(str));
}
-// Like snprintf(), but never returns negative value, or the value
+static const char *mg_strcasestr(const char *big_str, const char *small_str) {
+ int i, big_len = strlen(big_str), small_len = strlen(small_str);
+
+ for (i = 0; i <= big_len - small_len; i++) {
+ if (mg_strncasecmp(big_str + i, small_str, small_len) == 0) {
+ return big_str + i;
+ }
+ }
+
+ return NULL;
+}
+
+// Like snprintf(), but never returns negative value, or a value
// that is larger than a supplied buffer.
// Thanks to Adam Zeldis to pointing snprintf()-caused vulnerability
// in his audit report.
@@ -672,6 +773,10 @@ static int mg_vsnprintf(struct mg_connection *conn, char *buf, size_t buflen,
}
static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
+ PRINTF_FORMAT_STRING(const char *fmt), ...)
+ PRINTF_ARGS(4, 5);
+
+static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
const char *fmt, ...) {
va_list ap;
int n;
@@ -684,10 +789,11 @@ static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
}
// Skip the characters until one of the delimiters characters found.
-// 0-terminate resulting word. Skip the delimiter and following whitespaces if any.
+// 0-terminate resulting word. Skip the delimiter and following whitespaces.
// Advance pointer to buffer to the next word. Return found 0-terminated word.
// Delimiters can be quoted with quotechar.
-static char *skip_quoted(char **buf, const char *delimiters, const char *whitespace, char quotechar) {
+static char *skip_quoted(char **buf, const char *delimiters,
+ const char *whitespace, char quotechar) {
char *p, *begin_word, *end_word, *end_whitespace;
begin_word = *buf;
@@ -699,6 +805,7 @@ static char *skip_quoted(char **buf, const char *delimiters, const char *whitesp
while (*p == quotechar) {
// If there is anything beyond end_word, copy it
if (*end_word == '\0') {
+
*p = '\0';
break;
} else {
@@ -751,8 +858,8 @@ const char *mg_get_header(const struct mg_connection *conn, const char *name) {
return get_header(&conn->request_info, name);
}
-// A helper function for traversing comma separated list of values.
-// It returns a list pointer shifted to the next value, of NULL if the end
+// A helper function for traversing a comma separated list of values.
+// It returns a list pointer shifted to the next value, or NULL if the end
// of the list found.
// Value is stored in val vector. If value has form "x=y", then eq_val
// vector is initialized to point to the "y" part, and val vector length
@@ -790,6 +897,7 @@ static const char *next_option(const char *list, struct vec *val,
return list;
}
+// Perform case-insensitive match of string against pattern
static int match_prefix(const char *pattern, int pattern_len, const char *str) {
const char *or_str;
int i, j, len, res;
@@ -811,9 +919,9 @@ static int match_prefix(const char *pattern, int pattern_len, const char *str) {
i++;
if (pattern[i] == '*') {
i++;
- len = strlen(str + j);
+ len = (int) strlen(str + j);
} else {
- len = strcspn(str + j, "/");
+ len = (int) strcspn(str + j, "/");
}
if (i == pattern_len) {
return j + len;
@@ -822,7 +930,7 @@ static int match_prefix(const char *pattern, int pattern_len, const char *str) {
res = match_prefix(pattern + i, pattern_len - i, str + j + len);
} while (res == -1 && len-- > 0);
return res == -1 ? -1 : j + res + len;
- } else if (pattern[i] != str[j]) {
+ } else if (lowercase(&pattern[i]) != lowercase(&str[j])) {
return -1;
}
}
@@ -836,7 +944,7 @@ static int should_keep_alive(const struct mg_connection *conn) {
const char *http_version = conn->request_info.http_version;
const char *header = mg_get_header(conn, "Connection");
if (conn->must_close ||
- conn->request_info.status_code == 401 ||
+ conn->status_code == 401 ||
mg_strcasecmp(conn->ctx->config[ENABLE_KEEP_ALIVE], "yes") != 0 ||
(header != NULL && mg_strcasecmp(header, "keep-alive") != 0) ||
(header == NULL && http_version && strcmp(http_version, "1.1"))) {
@@ -849,22 +957,25 @@ static const char *suggest_connection_header(const struct mg_connection *conn) {
return should_keep_alive(conn) ? "keep-alive" : "close";
}
+static void send_http_error(struct mg_connection *, int, const char *,
+ PRINTF_FORMAT_STRING(const char *fmt), ...)
+ PRINTF_ARGS(4, 5);
+
+
static void send_http_error(struct mg_connection *conn, int status,
const char *reason, const char *fmt, ...) {
- char buf[BUFSIZ];
+ char buf[MG_BUF_LEN];
va_list ap;
- int len;
-
- conn->request_info.status_code = status;
+ int len = 0;
- if (call_user(conn, MG_HTTP_ERROR) == NULL) {
+ conn->status_code = status;
+ if (conn->ctx->callbacks.http_error == NULL ||
+ conn->ctx->callbacks.http_error(conn, status)) {
buf[0] = '\0';
- len = 0;
// Errors 1xx, 204 and 304 MUST NOT send a body
if (status > 199 && status != 204 && status != 304) {
len = mg_snprintf(conn, buf, sizeof(buf), "Error %d: %s", status, reason);
- cry(conn, "%s", buf);
buf[len++] = '\n';
va_start(ap, fmt);
@@ -874,7 +985,6 @@ static void send_http_error(struct mg_connection *conn, int status,
DEBUG_TRACE(("[%s]", buf));
mg_printf(conn, "HTTP/1.1 %d %s\r\n"
- "Content-Type: text/plain\r\n"
"Content-Length: %d\r\n"
"Connection: %s\r\n\r\n", status, reason, len,
suggest_connection_header(conn));
@@ -884,7 +994,7 @@ static void send_http_error(struct mg_connection *conn, int status,
#if defined(_WIN32) && !defined(__SYMBIAN32__)
static int pthread_mutex_init(pthread_mutex_t *mutex, void *unused) {
- unused = NULL;
+ (void) unused;
*mutex = CreateMutex(NULL, FALSE, NULL);
return *mutex == NULL ? -1 : 0;
}
@@ -902,7 +1012,7 @@ static int pthread_mutex_unlock(pthread_mutex_t *mutex) {
}
static int pthread_cond_init(pthread_cond_t *cv, const void *unused) {
- unused = NULL;
+ (void) unused;
cv->signal = CreateEvent(NULL, FALSE, FALSE, NULL);
cv->broadcast = CreateEvent(NULL, TRUE, FALSE, NULL);
return cv->signal != NULL && cv->broadcast != NULL ? 0 : -1;
@@ -947,39 +1057,19 @@ static void change_slashes_to_backslashes(char *path) {
// Encode 'path' which is assumed UTF-8 string, into UNICODE string.
// wbuf and wbuf_len is a target buffer and its length.
static void to_unicode(const char *path, wchar_t *wbuf, size_t wbuf_len) {
- char buf[PATH_MAX], buf2[PATH_MAX], *p;
+ char buf[PATH_MAX], buf2[PATH_MAX];
mg_strlcpy(buf, path, sizeof(buf));
change_slashes_to_backslashes(buf);
- // Point p to the end of the file name
- p = buf + strlen(buf) - 1;
-
- // Trim trailing backslash character
- while (p > buf && *p == '\\' && p[-1] != ':') {
- *p-- = '\0';
- }
-
- // Protect from CGI code disclosure.
- // This is very nasty hole. Windows happily opens files with
- // some garbage in the end of file name. So fopen("a.cgi ", "r")
- // actually opens "a.cgi", and does not return an error!
- if (*p == 0x20 || // No space at the end
- (*p == 0x2e && p > buf) || // No '.' but allow '.' as full path
- *p == 0x2b || // No '+'
- (*p & ~0x7f)) { // And generally no non-ascii chars
- (void) fprintf(stderr, "Rejecting suspicious path: [%s]", buf);
+ // Convert to Unicode and back. If doubly-converted string does not
+ // match the original, something is fishy, reject.
+ memset(wbuf, 0, wbuf_len * sizeof(wchar_t));
+ MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int) wbuf_len);
+ WideCharToMultiByte(CP_UTF8, 0, wbuf, (int) wbuf_len, buf2, sizeof(buf2),
+ NULL, NULL);
+ if (strcmp(buf, buf2) != 0) {
wbuf[0] = L'\0';
- } else {
- // Convert to Unicode and back. If doubly-converted string does not
- // match the original, something is fishy, reject.
- memset(wbuf, 0, wbuf_len * sizeof(wchar_t));
- MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int) wbuf_len);
- WideCharToMultiByte(CP_UTF8, 0, wbuf, (int) wbuf_len, buf2, sizeof(buf2),
- NULL, NULL);
- if (strcmp(buf, buf2) != 0) {
- wbuf[0] = L'\0';
- }
}
}
@@ -1039,43 +1129,39 @@ static size_t strftime(char *dst, size_t dst_size, const char *fmt,
}
#endif
-static int mg_rename(const char* oldname, const char* newname) {
- wchar_t woldbuf[PATH_MAX];
- wchar_t wnewbuf[PATH_MAX];
-
- to_unicode(oldname, woldbuf, ARRAY_SIZE(woldbuf));
- to_unicode(newname, wnewbuf, ARRAY_SIZE(wnewbuf));
-
- return MoveFileW(woldbuf, wnewbuf) ? 0 : -1;
-}
-
-
-static FILE *mg_fopen(const char *path, const char *mode) {
- wchar_t wbuf[PATH_MAX], wmode[20];
-
- to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
- MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, ARRAY_SIZE(wmode));
-
- return _wfopen(wbuf, wmode);
+// Windows happily opens files with some garbage at the end of file name.
+// For example, fopen("a.cgi ", "r") on Windows successfully opens
+// "a.cgi", despite one would expect an error back.
+// This function returns non-0 if path ends with some garbage.
+static int path_cannot_disclose_cgi(const char *path) {
+ static const char *allowed_last_characters = "_-";
+ int last = path[strlen(path) - 1];
+ return isalnum(last) || strchr(allowed_last_characters, last) != NULL;
}
-static int mg_stat(const char *path, struct mgstat *stp) {
- int ok = -1; // Error
+static int mg_stat(struct mg_connection *conn, const char *path,
+ struct file *filep) {
wchar_t wbuf[PATH_MAX];
WIN32_FILE_ATTRIBUTE_DATA info;
- to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
-
- if (GetFileAttributesExW(wbuf, GetFileExInfoStandard, &info) != 0) {
- stp->size = MAKEUQUAD(info.nFileSizeLow, info.nFileSizeHigh);
- stp->mtime = SYS2UNIX_TIME(info.ftLastWriteTime.dwLowDateTime,
- info.ftLastWriteTime.dwHighDateTime);
- stp->is_directory =
- info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
- ok = 0; // Success
+ if (!is_file_in_memory(conn, path, filep)) {
+ to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
+ if (GetFileAttributesExW(wbuf, GetFileExInfoStandard, &info) != 0) {
+ filep->size = MAKEUQUAD(info.nFileSizeLow, info.nFileSizeHigh);
+ filep->modification_time = SYS2UNIX_TIME(
+ info.ftLastWriteTime.dwLowDateTime,
+ info.ftLastWriteTime.dwHighDateTime);
+ filep->is_directory = info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
+ // If file name is fishy, reset the file structure and return error.
+ // Note it is important to reset, not just return the error, cause
+ // functions like is_file_opened() check the struct.
+ if (!filep->is_directory && !path_cannot_disclose_cgi(path)) {
+ memset(filep, 0, sizeof(*filep));
+ }
+ }
}
- return ok;
+ return filep->membuf != NULL || filep->modification_time != 0;
}
static int mg_remove(const char *path) {
@@ -1088,11 +1174,11 @@ static int mg_mkdir(const char *path, int mode) {
char buf[PATH_MAX];
wchar_t wbuf[PATH_MAX];
- mode = 0; // Unused
+ (void) mode;
mg_strlcpy(buf, path, sizeof(buf));
change_slashes_to_backslashes(buf);
- (void) MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, sizeof(wbuf));
+ (void) MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, ARRAY_SIZE(wbuf));
return CreateDirectoryW(wbuf, NULL) ? 0 : -1;
}
@@ -1165,15 +1251,17 @@ static struct dirent *readdir(DIR *dir) {
return result;
}
-#define set_close_on_exec(fd) // No FD_CLOEXEC on Windows
+static void set_close_on_exec(SOCKET sock) {
+ (void) SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0);
+}
-static int start_thread(struct mg_context *ctx, mg_thread_func_t f, void *p) {
- return _beginthread((void (__cdecl *)(void *)) f, 0, p) == -1L ? -1 : 0;
+int mg_start_thread(mg_thread_func_t f, void *p) {
+ return (long)_beginthread((void (__cdecl *)(void *)) f, 0, p) == -1L ? -1 : 0;
}
static HANDLE dlopen(const char *dll_name, int flags) {
wchar_t wbuf[PATH_MAX];
- flags = 0; // Unused
+ (void) flags;
to_unicode(dll_name, wbuf, ARRAY_SIZE(wbuf));
return LoadLibraryW(wbuf);
}
@@ -1186,60 +1274,75 @@ static int kill(pid_t pid, int sig_num) {
return 0;
}
+static void trim_trailing_whitespaces(char *s) {
+ char *e = s + strlen(s) - 1;
+ while (e > s && isspace(* (unsigned char *) e)) {
+ *e-- = '\0';
+ }
+}
+
static pid_t spawn_process(struct mg_connection *conn, const char *prog,
- char *envblk, char *envp[], int fd_stdin,
- int fd_stdout, const char *dir) {
+ char *envblk, char *envp[], int fdin,
+ int fdout, const char *dir) {
HANDLE me;
- char *p, *interp, cmdline[PATH_MAX], buf[PATH_MAX];
- FILE *fp;
- STARTUPINFOA si = { sizeof(si) };
+ char *p, *interp, full_interp[PATH_MAX], full_dir[PATH_MAX],
+ cmdline[PATH_MAX], buf[PATH_MAX];
+ struct file file = STRUCT_FILE_INITIALIZER;
+ STARTUPINFOA si;
PROCESS_INFORMATION pi = { 0 };
- envp = NULL; // Unused
+ (void) envp;
+
+ memset(&si, 0, sizeof(si));
+ si.cb = sizeof(si);
// TODO(lsm): redirect CGI errors to the error log file
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.wShowWindow = SW_HIDE;
me = GetCurrentProcess();
- (void) DuplicateHandle(me, (HANDLE) _get_osfhandle(fd_stdin), me,
- &si.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS);
- (void) DuplicateHandle(me, (HANDLE) _get_osfhandle(fd_stdout), me,
- &si.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+ DuplicateHandle(me, (HANDLE) _get_osfhandle(fdin), me,
+ &si.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+ DuplicateHandle(me, (HANDLE) _get_osfhandle(fdout), me,
+ &si.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS);
// If CGI file is a script, try to read the interpreter line
interp = conn->ctx->config[CGI_INTERPRETER];
if (interp == NULL) {
- buf[2] = '\0';
- mg_snprintf(conn, cmdline, sizeof(cmdline), "%s%c%s", dir, DIRSEP, prog);
- if ((fp = fopen(cmdline, "r")) != NULL) {
- (void) fgets(buf, sizeof(buf), fp);
- if (buf[0] != '#' || buf[1] != '!') {
- // First line does not start with "#!". Do not set interpreter.
- buf[2] = '\0';
- } else {
- // Trim whitespaces in interpreter name
- for (p = &buf[strlen(buf) - 1]; p > buf && isspace(*p); p--) {
- *p = '\0';
- }
- }
- (void) fclose(fp);
+ buf[0] = buf[1] = '\0';
+
+ // Read the first line of the script into the buffer
+ snprintf(cmdline, sizeof(cmdline), "%s%c%s", dir, '/', prog);
+ if (mg_fopen(conn, cmdline, "r", &file)) {
+ p = (char *) file.membuf;
+ mg_fgets(buf, sizeof(buf), &file, &p);
+ mg_fclose(&file);
+ buf[sizeof(buf) - 1] = '\0';
+ }
+
+ if (buf[0] == '#' && buf[1] == '!') {
+ trim_trailing_whitespaces(buf + 2);
+ } else {
+ buf[2] = '\0';
}
interp = buf + 2;
}
- (void) mg_snprintf(conn, cmdline, sizeof(cmdline), "%s%s%s%c%s",
- interp, interp[0] == '\0' ? "" : " ", dir, DIRSEP, prog);
+ if (interp[0] != '\0') {
+ GetFullPathNameA(interp, sizeof(full_interp), full_interp, NULL);
+ interp = full_interp;
+ }
+ GetFullPathNameA(dir, sizeof(full_dir), full_dir, NULL);
+
+ mg_snprintf(conn, cmdline, sizeof(cmdline), "%s%s\"%s\\%s\"",
+ interp, interp[0] == '\0' ? "" : " ", full_dir, prog);
DEBUG_TRACE(("Running [%s]", cmdline));
if (CreateProcessA(NULL, cmdline, NULL, NULL, TRUE,
- CREATE_NEW_PROCESS_GROUP, envblk, dir, &si, &pi) == 0) {
- cry(conn, "%s: CreateProcess(%s): %d",
+ CREATE_NEW_PROCESS_GROUP, envblk, NULL, &si, &pi) == 0) {
+ cry(conn, "%s: CreateProcess(%s): %ld",
__func__, cmdline, ERRNO);
pi.hProcess = (pid_t) -1;
- } else {
- (void) close(fd_stdin);
- (void) close(fd_stdout);
}
(void) CloseHandle(si.hStdOutput);
@@ -1256,31 +1359,30 @@ static int set_non_blocking_mode(SOCKET sock) {
}
#else
-static int mg_stat(const char *path, struct mgstat *stp) {
+static int mg_stat(struct mg_connection *conn, const char *path,
+ struct file *filep) {
struct stat st;
- int ok;
- if (stat(path, &st) == 0) {
- ok = 0;
- stp->size = st.st_size;
- stp->mtime = st.st_mtime;
- stp->is_directory = S_ISDIR(st.st_mode);
+ if (!is_file_in_memory(conn, path, filep) && !stat(path, &st)) {
+ filep->size = st.st_size;
+ filep->modification_time = st.st_mtime;
+ filep->is_directory = S_ISDIR(st.st_mode);
} else {
- ok = -1;
+ filep->modification_time = (time_t) 0;
}
- return ok;
+ return filep->membuf != NULL || filep->modification_time != (time_t) 0;
}
static void set_close_on_exec(int fd) {
- (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
+ fcntl(fd, F_SETFD, FD_CLOEXEC);
}
-static int start_thread(struct mg_context *ctx, mg_thread_func_t func,
- void *param) {
+int mg_start_thread(mg_thread_func_t func, void *param) {
pthread_t thread_id;
pthread_attr_t attr;
- int retval;
+ int result;
+ struct mg_context* ctx = param;
char* stacksize = ctx->config[THREAD_STACK_SIZE];
char* priority = ctx->config[THREAD_PRIORITY];
char* policy = ctx->config[THREAD_POLICY];
@@ -1288,8 +1390,12 @@ static int start_thread(struct mg_context *ctx, mg_thread_func_t func,
(void) pthread_attr_init(&attr);
(void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- // TODO(lsm): figure out why mongoose dies on Linux if next line is enabled
- // (void) pthread_attr_setstacksize(&attr, sizeof(struct mg_connection) * 5);
+
+#if USE_STACK_SIZE > 1
+ // Compile-time option to control stack size, e.g. -DUSE_STACK_SIZE=16384; Can be overridden
+ if (stacksize == NULL)
+ (void) pthread_attr_setstacksize(&attr, USE_STACK_SIZE);
+#endif
if (stacksize != NULL) {
size_t size = atoi(stacksize);
@@ -1337,21 +1443,20 @@ static int start_thread(struct mg_context *ctx, mg_thread_func_t func,
(void) pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
}
- if ((retval = pthread_create(&thread_id, &attr, func, param)) != 0) {
- cry(fc(ctx), "%s: %s", __func__, strerror(retval));
- }
+ result = pthread_create(&thread_id, &attr, func, param);
+ pthread_attr_destroy(&attr);
- return retval;
+ return result;
}
#ifndef NO_CGI
static pid_t spawn_process(struct mg_connection *conn, const char *prog,
- char *envblk, char *envp[], int fd_stdin,
- int fd_stdout, const char *dir) {
+ char *envblk, char *envp[], int fdin,
+ int fdout, const char *dir) {
pid_t pid;
const char *interp;
- envblk = NULL; // Unused
+ (void) envblk;
if ((pid = fork()) == -1) {
// Parent
@@ -1360,16 +1465,22 @@ static pid_t spawn_process(struct mg_connection *conn, const char *prog,
// Child
if (chdir(dir) != 0) {
cry(conn, "%s: chdir(%s): %s", __func__, dir, strerror(ERRNO));
- } else if (dup2(fd_stdin, 0) == -1) {
- cry(conn, "%s: dup2(%d, 0): %s", __func__, fd_stdin, strerror(ERRNO));
- } else if (dup2(fd_stdout, 1) == -1) {
- cry(conn, "%s: dup2(%d, 1): %s", __func__, fd_stdout, strerror(ERRNO));
+ } else if (dup2(fdin, 0) == -1) {
+ cry(conn, "%s: dup2(%d, 0): %s", __func__, fdin, strerror(ERRNO));
+ } else if (dup2(fdout, 1) == -1) {
+ cry(conn, "%s: dup2(%d, 1): %s", __func__, fdout, strerror(ERRNO));
} else {
- (void) dup2(fd_stdout, 2);
- (void) close(fd_stdin);
- (void) close(fd_stdout);
+ // Not redirecting stderr to stdout, to avoid output being littered
+ // with the error messages.
+ (void) close(fdin);
+ (void) close(fdout);
+
+ // After exec, all signal handlers are restored to their default values,
+ // with one exception of SIGCHLD. According to POSIX.1-2001 and Linux's
+ // implementation, SIGCHLD's handler will leave unchanged after exec
+ // if it was set to be ignored. Restore it to default action.
+ signal(SIGCHLD, SIG_DFL);
- // Execute CGI program. No need to lock: new process
interp = conn->ctx->config[CGI_INTERPRETER];
if (interp == NULL) {
(void) execle(prog, prog, NULL, envp);
@@ -1381,10 +1492,6 @@ static pid_t spawn_process(struct mg_connection *conn, const char *prog,
}
}
exit(EXIT_FAILURE);
- } else {
- // Parent. Close stdio descriptors
- (void) close(fd_stdin);
- (void) close(fd_stdout);
}
return pid;
@@ -1401,6 +1508,38 @@ static int set_non_blocking_mode(SOCKET sock) {
}
#endif // _WIN32
+#ifndef HAVE_POLL
+static int poll(struct pollfd *pfd, int n, int milliseconds) {
+ struct timeval tv;
+ fd_set set;
+ int i, result;
+ SOCKET maxfd = 0;
+
+ tv.tv_sec = milliseconds / 1000;
+ tv.tv_usec = (milliseconds % 1000) * 1000;
+ FD_ZERO(&set);
+
+ for (i = 0; i < n; i++) {
+ FD_SET((SOCKET) pfd[i].fd, &set);
+ pfd[i].revents = 0;
+
+ if (pfd[i].fd > maxfd) {
+ maxfd = pfd[i].fd;
+ }
+ }
+
+ if ((result = select(maxfd + 1, &set, NULL, NULL, &tv)) > 0) {
+ for (i = 0; i < n; i++) {
+ if (FD_ISSET(pfd[i].fd, &set)) {
+ pfd[i].revents = POLLIN;
+ }
+ }
+ }
+
+ return result;
+}
+#endif // HAVE_POLL
+
// Write data to the IO channel - opened file descriptor, socket or SSL
// descriptor. Return number of bytes written.
static int64_t push(FILE *fp, SOCKET sock, SSL *ssl, const char *buf,
@@ -1408,23 +1547,27 @@ static int64_t push(FILE *fp, SOCKET sock, SSL *ssl, const char *buf,
int64_t sent;
int n, k;
+ (void) ssl; // Get rid of warning
sent = 0;
while (sent < len) {
// How many bytes we send in this iteration
k = len - sent > INT_MAX ? INT_MAX : (int) (len - sent);
+#ifndef NO_SSL
if (ssl != NULL) {
n = SSL_write(ssl, buf + sent, k);
- } else if (fp != NULL) {
- n = fwrite(buf + sent, 1, (size_t) k, fp);
+ } else
+#endif
+ if (fp != NULL) {
+ n = (int) fwrite(buf + sent, 1, (size_t) k, fp);
if (ferror(fp))
n = -1;
} else {
n = send(sock, buf + sent, (size_t) k, MSG_NOSIGNAL);
}
- if (n < 0)
+ if (n <= 0)
break;
sent += n;
@@ -1434,21 +1577,41 @@ static int64_t push(FILE *fp, SOCKET sock, SSL *ssl, const char *buf,
}
// Read from IO channel - opened file descriptor, socket, or SSL descriptor.
-// Return number of bytes read.
-static int pull(FILE *fp, SOCKET sock, SSL *ssl, char *buf, int len) {
+// Return negative value on error, or number of bytes read on success.
+static int pull(FILE *fp, struct mg_connection *conn, char *buf, int len) {
int nread;
- if (ssl != NULL) {
- nread = SSL_read(ssl, buf, len);
- } else if (fp != NULL) {
+ if (fp != NULL) {
// Use read() instead of fread(), because if we're reading from the CGI
// pipe, fread() may block until IO buffer is filled up. We cannot afford
// to block and must pass all read bytes immediately to the client.
nread = read(fileno(fp), buf, (size_t) len);
- if (ferror(fp))
- nread = -1;
+#ifndef NO_SSL
+ } else if (conn->ssl != NULL) {
+ nread = SSL_read(conn->ssl, buf, len);
+#endif
} else {
- nread = recv(sock, buf, (size_t) len, 0);
+ nread = recv(conn->client.sock, buf, (size_t) len, 0);
+ }
+
+ return conn->ctx->stop_flag ? -1 : nread;
+}
+
+static int pull_all(FILE *fp, struct mg_connection *conn, char *buf, int len) {
+ int n, nread = 0;
+
+ while (len > 0 && conn->ctx->stop_flag == 0) {
+ n = pull(fp, conn, buf + nread, len);
+ if (n < 0) {
+ nread = n; // Propagate the error
+ break;
+ } else if (n == 0) {
+ break; // No more data to read
+ } else {
+ conn->consumed_content += n;
+ nread += n;
+ len -= n;
+ }
}
return nread;
@@ -1456,84 +1619,158 @@ static int pull(FILE *fp, SOCKET sock, SSL *ssl, char *buf, int len) {
int mg_read(struct mg_connection *conn, void *buf, size_t len) {
int n, buffered_len, nread;
- const char *buffered;
+ const char *body;
+
+ // If Content-Length is not set, read until socket is closed
+ if (conn->consumed_content == 0 && conn->content_len == 0) {
+ conn->content_len = INT64_MAX;
+ conn->must_close = 1;
+ }
- assert((conn->content_len == -1 && conn->consumed_content == 0) ||
- conn->consumed_content <= conn->content_len);
- DEBUG_TRACE(("%p %zu %lld %lld", buf, len,
- conn->content_len, conn->consumed_content));
nread = 0;
if (conn->consumed_content < conn->content_len) {
-
// Adjust number of bytes to read.
int64_t to_read = conn->content_len - conn->consumed_content;
if (to_read < (int64_t) len) {
- len = (int) to_read;
+ len = (size_t) to_read;
}
- // How many bytes of data we have buffered in the request buffer?
- buffered = conn->buf + conn->request_len + conn->consumed_content;
- buffered_len = conn->data_len - conn->request_len;
- assert(buffered_len >= 0);
-
- // Return buffered data back if we haven't done that yet.
- if (conn->consumed_content < (int64_t) buffered_len) {
- buffered_len -= (int) conn->consumed_content;
+ // Return buffered data
+ body = conn->buf + conn->request_len + conn->consumed_content;
+ buffered_len = &conn->buf[conn->data_len] - body;
+ if (buffered_len > 0) {
if (len < (size_t) buffered_len) {
- buffered_len = len;
+ buffered_len = (int) len;
}
- memcpy(buf, buffered, (size_t)buffered_len);
+ memcpy(buf, body, (size_t) buffered_len);
len -= buffered_len;
- buf = (char *) buf + buffered_len;
conn->consumed_content += buffered_len;
- nread = buffered_len;
+ nread += buffered_len;
+ buf = (char *) buf + buffered_len;
}
// We have returned all buffered data. Read new data from the remote socket.
- while (len > 0) {
- n = pull(NULL, conn->client.sock, conn->ssl, (char *) buf, (int) len);
- if (n <= 0) {
- break;
- }
- buf = (char *) buf + n;
- conn->consumed_content += n;
- nread += n;
- len -= n;
- }
+ n = pull_all(NULL, conn, (char *) buf, (int) len);
+ nread = n >= 0 ? nread + n : n;
}
return nread;
}
int mg_write(struct mg_connection *conn, const void *buf, size_t len) {
- return (int) push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
- (int64_t) len);
+ 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;
}
-int mg_printf(struct mg_connection *conn, const char *fmt, ...) {
- char buf[BUFSIZ];
+// Alternative alloc_vprintf() for non-compliant C runtimes
+static int alloc_vprintf2(char **buf, const char *fmt, va_list ap) {
+ va_list ap_copy;
+ int size = MG_BUF_LEN;
+ int len = -1;
+
+ *buf = NULL;
+ while (len == -1) {
+ if (*buf) free(*buf);
+ *buf = malloc(size *= 4);
+ if (!*buf) break;
+ va_copy(ap_copy, ap);
+ len = vsnprintf(*buf, size, fmt, ap_copy);
+ }
+
+ return len;
+}
+
+// Print message to buffer. If buffer is large enough to hold the message,
+// return buffer. If buffer is to small, allocate large enough buffer on heap,
+// and return allocated buffer.
+static int alloc_vprintf(char **buf, size_t size, const char *fmt, va_list ap) {
+ va_list ap_copy;
int len;
- va_list ap;
- va_start(ap, fmt);
- len = mg_vsnprintf(conn, buf, sizeof(buf), fmt, ap);
- va_end(ap);
+ // Windows is not standard-compliant, and vsnprintf() returns -1 if
+ // buffer is too small. Also, older versions of msvcrt.dll do not have
+ // _vscprintf(). However, if size is 0, vsnprintf() behaves correctly.
+ // Therefore, we make two passes: on first pass, get required message length.
+ // On second pass, actually print the message.
+ va_copy(ap_copy, ap);
+ len = vsnprintf(NULL, 0, fmt, ap_copy);
+
+ if (len < 0) {
+ // C runtime is not standard compliant, vsnprintf() returned -1.
+ // Switch to alternative code path that uses incremental allocations.
+ va_copy(ap_copy, ap);
+ len = alloc_vprintf2(buf, fmt, ap);
+ } else if (len > (int) size &&
+ (size = len + 1) > 0 &&
+ (*buf = (char *) malloc(size)) == NULL) {
+ len = -1; // Allocation failed, mark failure
+ } else {
+ va_copy(ap_copy, ap);
+ vsnprintf(*buf, size, fmt, ap_copy);
+ }
+
+ return len;
+}
+
+int mg_vprintf(struct mg_connection *conn, const char *fmt, va_list ap) {
+ char mem[MG_BUF_LEN], *buf = mem;
+ int len;
+
+ if ((len = alloc_vprintf(&buf, sizeof(mem), fmt, ap)) > 0) {
+ len = mg_write(conn, buf, (size_t) len);
+ }
+ if (buf != mem && buf != NULL) {
+ free(buf);
+ }
+
+ return len;
+}
- return mg_write(conn, buf, (size_t)len);
+int mg_printf(struct mg_connection *conn, const char *fmt, ...) {
+ va_list ap;
+ va_start(ap, fmt);
+ return mg_vprintf(conn, fmt, ap);
}
-// URL-decode input buffer into destination buffer.
-// 0-terminate the destination buffer. Return the length of decoded data.
-// form-url-encoded data differs from URI encoding in a way that it
-// uses '+' as character for space, see RFC 1866 section 8.2.1
-// http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt
-static size_t url_decode(const char *src, size_t src_len, char *dst,
- size_t dst_len, int is_form_url_encoded) {
- size_t i, j;
- int a, b;
+int mg_url_decode(const char *src, int src_len, char *dst,
+ int dst_len, int is_form_url_encoded) {
+ 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] == '%' &&
+ 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));
@@ -1549,139 +1786,160 @@ static size_t url_decode(const char *src, size_t src_len, char *dst,
dst[j] = '\0'; // Null-terminate the destination
- return j;
+ return i >= src_len ? j : -1;
}
-// Scan given buffer and fetch the value of the given variable.
-// It can be specified in query string, or in the POST data.
-// Return NULL if the variable not found, or allocated 0-terminated value.
-// It is caller's responsibility to free the returned value.
-int mg_get_var(const char *buf, size_t buf_len, const char *name,
+int mg_get_var(const char *data, size_t data_len, const char *name,
char *dst, size_t dst_len) {
const char *p, *e, *s;
- size_t name_len, len;
-
- name_len = strlen(name);
- e = buf + buf_len;
- len = -1;
- dst[0] = '\0';
-
- // buf is "var1=val1&var2=val2...". Find variable first
- for (p = buf; p != NULL && p + name_len < e; p++) {
- if ((p == buf || p[-1] == '&') && p[name_len] == '=' &&
- !mg_strncasecmp(name, p, name_len)) {
+ size_t name_len;
+ int len;
- // Point p to variable value
- p += name_len + 1;
+ 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);
- // 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);
- // Decode variable into destination buffer
- if ((size_t) (s - p) < dst_len) {
- len = 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;
}
- break;
}
}
return len;
}
-int mg_get_cookie(const struct mg_connection *conn, const char *cookie_name,
+int mg_get_cookie(const char *cookie_header, const char *var_name,
char *dst, size_t dst_size) {
const char *s, *p, *end;
int name_len, len = -1;
- dst[0] = '\0';
- if ((s = mg_get_header(conn, "Cookie")) == NULL) {
- return 0;
- }
-
- name_len = strlen(cookie_name);
- end = s + strlen(s);
-
- for (; (s = strstr(s, cookie_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) + 1;
- mg_strlcpy(dst, s, (size_t)len);
+ 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;
}
- break;
}
-
+ }
return len;
}
-static int convert_uri_to_file_name(struct mg_connection *conn, char *buf,
- size_t buf_len, struct mgstat *st) {
+static void convert_uri_to_file_name(struct mg_connection *conn, char *buf,
+ size_t buf_len, struct file *filep) {
struct vec a, b;
- const char *rewrite, *uri = conn->request_info.uri;
+ const char *rewrite, *uri = conn->request_info.uri,
+ *root = conn->ctx->config[DOCUMENT_ROOT];
char *p;
- int match_len, stat_result;
+ int match_len;
+ char gz_path[PATH_MAX];
+ char const* accept_encoding;
- buf_len--; // This is because memmove() for PATH_INFO may shift part
- // of the path one byte on the right.
- mg_snprintf(conn, buf, buf_len, "%s%s", conn->ctx->config[DOCUMENT_ROOT],
- uri);
+ // Using buf_len - 1 because memmove() for PATH_INFO may shift part
+ // of the path one byte on the right.
+ // If document_root is NULL, leave the file empty.
+ mg_snprintf(conn, buf, buf_len - 1, "%s%s",
+ root == NULL ? "" : root,
+ root == NULL ? "" : uri);
rewrite = conn->ctx->config[REWRITE];
while ((rewrite = next_option(rewrite, &a, &b)) != NULL) {
if ((match_len = match_prefix(a.ptr, a.len, uri)) > 0) {
- mg_snprintf(conn, buf, buf_len, "%.*s%s", b.len, b.ptr, uri + match_len);
+ mg_snprintf(conn, buf, buf_len - 1, "%.*s%s", (int) b.len, b.ptr,
+ uri + match_len);
break;
}
}
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
- //change_slashes_to_backslashes(buf);
-#endif // _WIN32
-
- if ((stat_result = mg_stat(buf, st)) != 0) {
- // Support PATH_INFO for CGI scripts.
- for (p = buf + strlen(buf); p > buf + 1; p--) {
- if (*p == '/') {
- *p = '\0';
- if (match_prefix(conn->ctx->config[CGI_EXTENSIONS],
- strlen(conn->ctx->config[CGI_EXTENSIONS]), buf) > 0 &&
- (stat_result = mg_stat(buf, st)) == 0) {
- // Shift PATH_INFO block one character right, e.g.
- // "/x.cgi/foo/bar\x00" => "/x.cgi\x00/foo/bar\x00"
- // conn->path_info is pointing to the local variable "path" declared
- // in handle_request(), so PATH_INFO not valid after
- // handle_request returns.
- conn->path_info = p + 1;
- memmove(p + 2, p + 1, strlen(p + 1) + 1); // +1 is for trailing \0
- p[1] = '/';
- break;
- } else {
- *p = '/';
- stat_result = -1;
- }
+ if (mg_stat(conn, buf, filep)) return;
+
+ // if we can't find the actual file, look for the file
+ // with the same name but a .gz extension. If we find it,
+ // use that and set the gzipped flag in the file struct
+ // to indicate that the response need to have the content-
+ // encoding: gzip header
+ // we can only do this if the browser declares support
+ if ((accept_encoding = mg_get_header(conn, "Accept-Encoding")) != NULL) {
+ if (strstr(accept_encoding,"gzip") != NULL) {
+ snprintf(gz_path, sizeof(gz_path), "%s.gz", buf);
+ if (mg_stat(conn, gz_path, filep)) {
+ filep->gzipped = 1;
+ return;
}
}
}
- return stat_result;
-}
-
-static int sslize(struct mg_connection *conn, int (*func)(SSL *)) {
- return (conn->ssl = SSL_new(conn->ctx->ssl_ctx)) != NULL &&
- SSL_set_fd(conn->ssl, conn->client.sock) == 1 &&
- func(conn->ssl) == 1;
+ // Support PATH_INFO for CGI scripts.
+ for (p = buf + strlen(buf); p > buf + 1; p--) {
+ if (*p == '/') {
+ *p = '\0';
+ if (match_prefix(conn->ctx->config[CGI_EXTENSIONS],
+ strlen(conn->ctx->config[CGI_EXTENSIONS]), buf) > 0 &&
+ mg_stat(conn, buf, filep)) {
+ // Shift PATH_INFO block one character right, e.g.
+ // "/x.cgi/foo/bar\x00" => "/x.cgi\x00/foo/bar\x00"
+ // conn->path_info is pointing to the local variable "path" declared
+ // in handle_request(), so PATH_INFO is not valid after
+ // handle_request returns.
+ conn->path_info = p + 1;
+ memmove(p + 2, p + 1, strlen(p + 1) + 1); // +1 is for trailing \0
+ p[1] = '/';
+ break;
+ } else {
+ *p = '/';
+ }
+ }
+ }
}
// Check whether full request is buffered. Return:
@@ -1692,12 +1950,13 @@ static int get_request_len(const char *buf, int buflen) {
const char *s, *e;
int len = 0;
- DEBUG_TRACE(("buf: %p, len: %d", buf, buflen));
for (s = buf, e = s + buflen - 1; len <= 0 && s < e; s++)
// Control characters are not allowed but >=128 is.
if (!isprint(* (const unsigned char *) s) && *s != '\r' &&
*s != '\n' && * (const unsigned char *) s < 128) {
len = -1;
+ break; // [i_a] abort scan as soon as one malformed character is found;
+ // don't let subsequent \r\n\r\n win us over anyhow
} else if (s[0] == '\n' && s[1] == '\n') {
len = (int) (s - buf) + 2;
} else if (s[0] == '\n' && &s[1] < e &&
@@ -1719,6 +1978,10 @@ static int get_month_index(const char *s) {
return -1;
}
+static int num_leap_years(int year) {
+ return year / 4 - year / 100 + year / 400;
+}
+
// Parse UTC date-time string, and return the corresponding time_t value.
static time_t parse_date_string(const char *datetime) {
static const unsigned short days_before_month[] = {
@@ -1738,8 +2001,8 @@ static time_t parse_date_string(const char *datetime) {
&day, month_str, &year, &hour, &minute, &second) == 6)) &&
year > 1970 &&
(month = get_month_index(month_str)) != -1) {
+ leap_days = num_leap_years(year) - num_leap_years(1970);
year -= 1970;
- leap_days = year / 4 - year / 100 + year / 400;
days = year * 365 + days_before_month[month] + (day - 1) + leap_days;
result = days * 24 * 3600 + hour * 3600 + minute * 60 + second;
}
@@ -1754,15 +2017,16 @@ static void remove_double_dots_and_double_slashes(char *s) {
while (*s != '\0') {
*p++ = *s++;
- if (IS_DIRSEP_CHAR(s[-1])) {
- // Skip all following slashes and backslashes
- while (IS_DIRSEP_CHAR(s[0])) {
- s++;
- }
-
- // Skip all double-dots
- while (*s == '.' && s[1] == '.') {
- s += 2;
+ if (s[-1] == '/' || s[-1] == '\\') {
+ // Skip all following slashes, backslashes and double-dots
+ while (s[0] != '\0') {
+ if (s[0] == '/' || s[0] == '\\') {
+ s++;
+ } else if (s[0] == '.' && s[1] == '.') {
+ s += 2;
+ } else {
+ break;
+ }
}
}
}
@@ -1773,58 +2037,81 @@ static const struct {
const char *extension;
size_t ext_len;
const char *mime_type;
- size_t mime_type_len;
} builtin_mime_types[] = {
- {".html", 5, "text/html", 9},
- {".htm", 4, "text/html", 9},
- {".shtm", 5, "text/html", 9},
- {".shtml", 6, "text/html", 9},
- {".css", 4, "text/css", 8},
- {".js", 3, "application/x-javascript", 24},
- {".ico", 4, "image/x-icon", 12},
- {".gif", 4, "image/gif", 9},
- {".jpg", 4, "image/jpeg", 10},
- {".jpeg", 5, "image/jpeg", 10},
- {".png", 4, "image/png", 9},
- {".svg", 4, "image/svg+xml", 13},
- {".torrent", 8, "application/x-bittorrent", 24},
- {".wav", 4, "audio/x-wav", 11},
- {".mp3", 4, "audio/x-mp3", 11},
- {".mid", 4, "audio/mid", 9},
- {".m3u", 4, "audio/x-mpegurl", 15},
- {".ram", 4, "audio/x-pn-realaudio", 20},
- {".xml", 4, "text/xml", 8},
- {".xslt", 5, "application/xml", 15},
- {".ra", 3, "audio/x-pn-realaudio", 20},
- {".doc", 4, "application/msword", 19},
- {".exe", 4, "application/octet-stream", 24},
- {".zip", 4, "application/x-zip-compressed", 28},
- {".xls", 4, "application/excel", 17},
- {".tgz", 4, "application/x-tar-gz", 20},
- {".tar", 4, "application/x-tar", 17},
- {".gz", 3, "application/x-gunzip", 20},
- {".arj", 4, "application/x-arj-compressed", 28},
- {".rar", 4, "application/x-arj-compressed", 28},
- {".rtf", 4, "application/rtf", 15},
- {".pdf", 4, "application/pdf", 15},
- {".swf", 4, "application/x-shockwave-flash",29},
- {".mpg", 4, "video/mpeg", 10},
- {".mpeg", 5, "video/mpeg", 10},
- {".mp4", 4, "video/mp4", 9},
- {".m4v", 4, "video/x-m4v", 11},
- {".asf", 4, "video/x-ms-asf", 14},
- {".avi", 4, "video/x-msvideo", 15},
- {".bmp", 4, "image/bmp", 9},
- {NULL, 0, NULL, 0}
+ {".html", 5, "text/html"},
+ {".htm", 4, "text/html"},
+ {".shtm", 5, "text/html"},
+ {".shtml", 6, "text/html"},
+ {".css", 4, "text/css"},
+ {".js", 3, "application/x-javascript"},
+ {".ico", 4, "image/x-icon"},
+ {".gif", 4, "image/gif"},
+ {".jpg", 4, "image/jpeg"},
+ {".jpeg", 5, "image/jpeg"},
+ {".png", 4, "image/png"},
+ {".svg", 4, "image/svg+xml"},
+ {".txt", 4, "text/plain"},
+ {".torrent", 8, "application/x-bittorrent"},
+ {".wav", 4, "audio/x-wav"},
+ {".mp3", 4, "audio/x-mp3"},
+ {".mid", 4, "audio/mid"},
+ {".m3u", 4, "audio/x-mpegurl"},
+ {".ogg", 4, "audio/ogg"},
+ {".ram", 4, "audio/x-pn-realaudio"},
+ {".xml", 4, "text/xml"},
+ {".json", 5, "text/json"},
+ {".xslt", 5, "application/xml"},
+ {".xsl", 4, "application/xml"},
+ {".ra", 3, "audio/x-pn-realaudio"},
+ {".doc", 4, "application/msword"},
+ {".exe", 4, "application/octet-stream"},
+ {".zip", 4, "application/x-zip-compressed"},
+ {".xls", 4, "application/excel"},
+ {".tgz", 4, "application/x-tar-gz"},
+ {".tar", 4, "application/x-tar"},
+ {".gz", 3, "application/x-gunzip"},
+ {".arj", 4, "application/x-arj-compressed"},
+ {".rar", 4, "application/x-arj-compressed"},
+ {".rtf", 4, "application/rtf"},
+ {".pdf", 4, "application/pdf"},
+ {".swf", 4, "application/x-shockwave-flash"},
+ {".mpg", 4, "video/mpeg"},
+ {".webm", 5, "video/webm"},
+ {".mpeg", 5, "video/mpeg"},
+ {".mov", 4, "video/quicktime"},
+ {".mp4", 4, "video/mp4"},
+ {".m4v", 4, "video/x-m4v"},
+ {".asf", 4, "video/x-ms-asf"},
+ {".avi", 4, "video/x-msvideo"},
+ {".bmp", 4, "image/bmp"},
+ {".ttf", 4, "application/x-font-ttf"},
+ {NULL, 0, NULL}
};
+const char *mg_get_builtin_mime_type(const char *path) {
+ 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";
+}
+
// Look at the "path" extension and figure what mime type it has.
// Store mime type in the vector.
static void get_mime_type(struct mg_context *ctx, const char *path,
struct vec *vec) {
struct vec ext_vec, mime_vec;
const char *list, *ext;
- size_t i, path_len;
+ size_t path_len;
path_len = strlen(path);
@@ -1840,20 +2127,13 @@ static void get_mime_type(struct mg_context *ctx, const char *path,
}
}
- // Now scan built-in mime types
- 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) {
- vec->ptr = builtin_mime_types[i].mime_type;
- vec->len = builtin_mime_types[i].mime_type_len;
- return;
- }
- }
+ vec->ptr = mg_get_builtin_mime_type(path);
+ vec->len = strlen(vec->ptr);
+}
- // Nothing found. Fall back to "text/plain"
- vec->ptr = "text/plain";
- vec->len = 10;
+static int is_big_endian(void) {
+ static const int n = 1;
+ return ((char *) &n)[0] == 0;
}
#ifndef HAVE_MD5
@@ -1863,19 +2143,19 @@ typedef struct MD5Context {
unsigned char in[64];
} MD5_CTX;
-#if defined(__BYTE_ORDER) && (__BYTE_ORDER == 1234)
-#define byteReverse(buf, len) // Do nothing
-#else
static void byteReverse(unsigned char *buf, unsigned longs) {
uint32_t t;
- do {
- t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
- ((unsigned) buf[1] << 8 | buf[0]);
- *(uint32_t *) buf = t;
- buf += 4;
- } while (--longs);
+
+ // Forrest: MD5 expect LITTLE_ENDIAN, swap if BIG_ENDIAN
+ if (is_big_endian()) {
+ do {
+ t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
+ ((unsigned) buf[1] << 8 | buf[0]);
+ * (uint32_t *) buf = t;
+ buf += 4;
+ } while (--longs);
+ }
}
-#endif
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
@@ -2018,6 +2298,7 @@ static void MD5Update(MD5_CTX *ctx, unsigned char const *buf, unsigned len) {
static void MD5Final(unsigned char digest[16], MD5_CTX *ctx) {
unsigned count;
unsigned char *p;
+ uint32_t *a;
count = (ctx->bits[0] >> 3) & 0x3F;
@@ -2034,8 +2315,9 @@ static void MD5Final(unsigned char digest[16], MD5_CTX *ctx) {
}
byteReverse(ctx->in, 14);
- ((uint32_t *) ctx->in)[14] = ctx->bits[0];
- ((uint32_t *) ctx->in)[15] = ctx->bits[1];
+ a = (uint32_t *)ctx->in;
+ a[14] = ctx->bits[0];
+ a[15] = ctx->bits[1];
MD5Transform(ctx->buf, (uint32_t *) ctx->in);
byteReverse((unsigned char *) ctx->buf, 4);
@@ -2056,8 +2338,8 @@ static void bin2str(char *to, const unsigned char *p, size_t len) {
*to = '\0';
}
-// Return stringified MD5 hash for list of vectors. Buffer must be 33 bytes.
-void mg_md5(char *buf, ...) {
+// Return stringified MD5 hash for list of strings. Buffer must be 33 bytes.
+char *mg_md5(char buf[33], ...) {
unsigned char hash[16];
const char *p;
va_list ap;
@@ -2073,6 +2355,7 @@ void mg_md5(char *buf, ...) {
MD5Final(hash, &ctx);
bin2str(buf, hash, sizeof(hash));
+ return buf;
}
// Check the user's password, return 1 if OK
@@ -2105,34 +2388,32 @@ static int check_password(const char *method, const char *ha1, const char *uri,
// Use the global passwords file, if specified by auth_gpass option,
// or search for .htpasswd in the requested directory.
-static FILE *open_auth_file(struct mg_connection *conn, const char *path) {
- struct mg_context *ctx = conn->ctx;
+static void open_auth_file(struct mg_connection *conn, const char *path,
+ struct file *filep) {
char name[PATH_MAX];
- const char *p, *e;
- struct mgstat st;
- FILE *fp;
+ const char *p, *e, *gpass = conn->ctx->config[GLOBAL_PASSWORDS_FILE];
+ struct file file = STRUCT_FILE_INITIALIZER;
- if (ctx->config[GLOBAL_PASSWORDS_FILE] != NULL) {
+ if (gpass != NULL) {
// Use global passwords file
- fp = mg_fopen(ctx->config[GLOBAL_PASSWORDS_FILE], "r");
- if (fp == NULL)
- cry(fc(ctx), "fopen(%s): %s",
- ctx->config[GLOBAL_PASSWORDS_FILE], strerror(ERRNO));
- } else if (!mg_stat(path, &st) && st.is_directory) {
- (void) mg_snprintf(conn, name, sizeof(name), "%s%c%s",
- path, DIRSEP, PASSWORDS_FILE_NAME);
- fp = mg_fopen(name, "r");
+ if (!mg_fopen(conn, gpass, "r", filep)) {
+ cry(conn, "fopen(%s): %s", gpass, strerror(ERRNO));
+ }
+ // Important: using local struct file to test path for is_directory flag.
+ // If filep is used, mg_stat() makes it appear as if auth file was opened.
+ } else if (mg_stat(conn, path, &file) && file.is_directory) {
+ mg_snprintf(conn, name, sizeof(name), "%s%c%s",
+ path, '/', PASSWORDS_FILE_NAME);
+ mg_fopen(conn, name, "r", filep);
} else {
// Try to find .htpasswd in requested directory.
for (p = path, e = p + strlen(p) - 1; e > p; e--)
- if (IS_DIRSEP_CHAR(*e))
+ if (e[0] == '/')
break;
- (void) mg_snprintf(conn, name, sizeof(name), "%.*s%c%s",
- (int) (e - p), p, DIRSEP, PASSWORDS_FILE_NAME);
- fp = mg_fopen(name, "r");
+ mg_snprintf(conn, name, sizeof(name), "%.*s%c%s",
+ (int) (e - p), p, '/', PASSWORDS_FILE_NAME);
+ mg_fopen(conn, name, "r", filep);
}
-
- return fp;
}
// Parsed Authorization header
@@ -2140,11 +2421,13 @@ struct ah {
char *user, *uri, *cnonce, *response, *qop, *nc, *nonce;
};
+// Return 1 on success. Always initializes the ah structure.
static int parse_auth_header(struct mg_connection *conn, char *buf,
size_t buf_size, struct ah *ah) {
char *name, *value, *s;
const char *auth_header;
+ (void) memset(ah, 0, sizeof(*ah));
if ((auth_header = mg_get_header(conn, "Authorization")) == NULL ||
mg_strncasecmp(auth_header, "Digest ", 7) != 0) {
return 0;
@@ -2152,9 +2435,7 @@ static int parse_auth_header(struct mg_connection *conn, char *buf,
// Make modifiable copy of the auth header
(void) mg_strlcpy(buf, auth_header + 7, buf_size);
-
s = buf;
- (void) memset(ah, 0, sizeof(*ah));
// Parse authorization header
for (;;) {
@@ -2204,27 +2485,51 @@ static int parse_auth_header(struct mg_connection *conn, char *buf,
return 1;
}
+static char *mg_fgets(char *buf, size_t size, struct file *filep, char **p) {
+ char *eof;
+ size_t len;
+ char *memend;
+
+ if (filep->membuf != NULL && *p != NULL) {
+ memend = (char *) &filep->membuf[filep->size];
+ eof = (char *) memchr(*p, '\n', memend - *p); // Search for \n from p till the end of stream
+ if (eof != NULL) {
+ eof += 1; // Include \n
+ } else {
+ eof = memend; // Copy remaining data
+ }
+ len = (size_t) (eof - *p) > size - 1 ? size - 1 : (size_t) (eof - *p);
+ memcpy(buf, *p, len);
+ buf[len] = '\0';
+ *p += len;
+ return len ? eof : NULL;
+ } else if (filep->fp != NULL) {
+ return fgets(buf, size, filep->fp);
+ } else {
+ return NULL;
+ }
+}
+
// Authorize against the opened passwords file. Return 1 if authorized.
-static int authorize(struct mg_connection *conn, FILE *fp) {
+static int authorize(struct mg_connection *conn, struct file *filep) {
struct ah ah;
- char line[256], f_user[256], ha1[256], f_domain[256], buf[BUFSIZ];
+ char line[256], f_user[256], ha1[256], f_domain[256], buf[MG_BUF_LEN], *p;
if (!parse_auth_header(conn, buf, sizeof(buf), &ah)) {
return 0;
}
// Loop over passwords file
- while (fgets(line, sizeof(line), fp) != NULL) {
+ p = (char *) filep->membuf;
+ while (mg_fgets(line, sizeof(line), filep, &p) != NULL) {
if (sscanf(line, "%[^:]:%[^:]:%s", f_user, f_domain, ha1) != 3) {
continue;
}
if (!strcmp(ah.user, f_user) &&
!strcmp(conn->ctx->config[AUTHENTICATION_DOMAIN], f_domain))
- return check_password(
- conn->request_info.request_method,
- ha1, ah.uri, ah.nonce, ah.nc, ah.cnonce, ah.qop,
- ah.response);
+ return check_password(conn->request_info.request_method, ha1, ah.uri,
+ ah.nonce, ah.nc, ah.cnonce, ah.qop, ah.response);
}
return 0;
@@ -2232,60 +2537,55 @@ static int authorize(struct mg_connection *conn, FILE *fp) {
// Return 1 if request is authorised, 0 otherwise.
static int check_authorization(struct mg_connection *conn, const char *path) {
- FILE *fp;
char fname[PATH_MAX];
struct vec uri_vec, filename_vec;
const char *list;
- int authorized;
-
- fp = NULL;
- authorized = 1;
+ struct file file = STRUCT_FILE_INITIALIZER;
+ int authorized = 1;
list = conn->ctx->config[PROTECT_URI];
while ((list = next_option(list, &uri_vec, &filename_vec)) != NULL) {
if (!memcmp(conn->request_info.uri, uri_vec.ptr, uri_vec.len)) {
- (void) mg_snprintf(conn, fname, sizeof(fname), "%.*s",
- filename_vec.len, filename_vec.ptr);
- if ((fp = mg_fopen(fname, "r")) == NULL) {
+ mg_snprintf(conn, fname, sizeof(fname), "%.*s",
+ (int) filename_vec.len, filename_vec.ptr);
+ if (!mg_fopen(conn, fname, "r", &file)) {
cry(conn, "%s: cannot open %s: %s", __func__, fname, strerror(errno));
}
break;
}
}
- if (fp == NULL) {
- fp = open_auth_file(conn, path);
+ if (!is_file_opened(&file)) {
+ open_auth_file(conn, path, &file);
}
- if (fp != NULL) {
- authorized = authorize(conn, fp);
- (void) fclose(fp);
+ if (is_file_opened(&file)) {
+ authorized = authorize(conn, &file);
+ mg_fclose(&file);
}
return authorized;
}
static void send_authorization_request(struct mg_connection *conn) {
- conn->request_info.status_code = 401;
- (void) mg_printf(conn,
- "HTTP/1.1 401 Unauthorized\r\n"
- "Content-Length: 0\r\n"
- "WWW-Authenticate: Digest qop=\"auth\", "
- "realm=\"%s\", nonce=\"%lu\"\r\n\r\n",
- conn->ctx->config[AUTHENTICATION_DOMAIN],
- (unsigned long) time(NULL));
+ conn->status_code = 401;
+ mg_printf(conn,
+ "HTTP/1.1 401 Unauthorized\r\n"
+ "Content-Length: 0\r\n"
+ "WWW-Authenticate: Digest qop=\"auth\", "
+ "realm=\"%s\", nonce=\"%lu\"\r\n\r\n",
+ conn->ctx->config[AUTHENTICATION_DOMAIN],
+ (unsigned long) time(NULL));
}
static int is_authorized_for_put(struct mg_connection *conn) {
- FILE *fp;
+ struct file file = STRUCT_FILE_INITIALIZER;
+ const char *passfile = conn->ctx->config[PUT_DELETE_PASSWORDS_FILE];
int ret = 0;
- fp = conn->ctx->config[PUT_DELETE_PASSWORDS_FILE] == NULL ? NULL :
- mg_fopen(conn->ctx->config[PUT_DELETE_PASSWORDS_FILE], "r");
-
- if (fp != NULL) {
- ret = authorize(conn, fp);
- (void) fclose(fp);
+ if (passfile != NULL && mg_fopen(conn, passfile, "r", &file)) {
+ ret = authorize(conn, &file);
+ mg_fclose(&file);
}
return ret;
@@ -2308,14 +2608,14 @@ int mg_modify_passwords_file(const char *fname, const char *domain,
(void) snprintf(tmp, sizeof(tmp), "%s.tmp", fname);
// Create the file if does not exist
- if ((fp = mg_fopen(fname, "a+")) != NULL) {
+ if ((fp = fopen(fname, "a+")) != NULL) {
(void) fclose(fp);
}
// Open the given file and temporary file
- if ((fp = mg_fopen(fname, "r")) == NULL) {
+ if ((fp = fopen(fname, "r")) == NULL) {
return 0;
- } else if ((fp2 = mg_fopen(tmp, "w+")) == NULL) {
+ } else if ((fp2 = fopen(tmp, "w+")) == NULL) {
fclose(fp);
return 0;
}
@@ -2333,34 +2633,60 @@ int mg_modify_passwords_file(const char *fname, const char *domain,
fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
}
} else {
- (void) fprintf(fp2, "%s", line);
+ fprintf(fp2, "%s", line);
}
}
// If new user, just add it
if (!found && pass != NULL) {
mg_md5(ha1, user, ":", domain, ":", pass, NULL);
- (void) fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
+ fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
}
// Close files
- (void) fclose(fp);
- (void) fclose(fp2);
+ fclose(fp);
+ fclose(fp2);
// Put the temp file in place of real file
- (void) mg_remove(fname);
- (void) mg_rename(tmp, fname);
+ remove(fname);
+ rename(tmp, fname);
return 1;
}
-struct de {
- struct mg_connection *conn;
- char *file_name;
- struct mgstat st;
-};
+static SOCKET conn2(const char *host, int port, int use_ssl,
+ char *ebuf, size_t ebuf_len) {
+ struct sockaddr_in sin;
+ struct hostent *he;
+ SOCKET sock = INVALID_SOCKET;
+
+ if (host == NULL) {
+ snprintf(ebuf, ebuf_len, "%s", "NULL host");
+ } else if (use_ssl && SSLv23_client_method == NULL) {
+ snprintf(ebuf, ebuf_len, "%s", "SSL is not initialized");
+ // TODO(lsm): use something threadsafe instead of gethostbyname()
+ } else if ((he = gethostbyname(host)) == NULL) {
+ snprintf(ebuf, ebuf_len, "gethostbyname(%s): %s", host, strerror(ERRNO));
+ } else if ((sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
+ snprintf(ebuf, ebuf_len, "socket(): %s", strerror(ERRNO));
+ } else {
+ set_close_on_exec(sock);
+ sin.sin_family = AF_INET;
+ sin.sin_port = htons((uint16_t) port);
+ sin.sin_addr = * (struct in_addr *) he->h_addr_list[0];
+ if (connect(sock, (struct sockaddr *) &sin, sizeof(sin)) != 0) {
+ snprintf(ebuf, ebuf_len, "connect(%s:%d): %s",
+ host, port, strerror(ERRNO));
+ closesocket(sock);
+ sock = INVALID_SOCKET;
+ }
+ }
+ return sock;
+}
+
-static void url_encode(const char *src, char *dst, size_t dst_len) {
+
+void mg_url_encode(const char *src, char *dst, size_t dst_len) {
static const char *dont_escape = "._-$,;~()";
static const char *hex = "0123456789abcdef";
const char *end = dst + dst_len - 1;
@@ -2383,32 +2709,32 @@ static void url_encode(const char *src, char *dst, size_t dst_len) {
static void print_dir_entry(struct de *de) {
char size[64], mod[64], href[PATH_MAX];
- if (de->st.is_directory) {
- (void) mg_snprintf(de->conn, size, sizeof(size), "%s", "[DIRECTORY]");
+ if (de->file.is_directory) {
+ mg_snprintf(de->conn, size, sizeof(size), "%s", "[DIRECTORY]");
} else {
// We use (signed) cast below because MSVC 6 compiler cannot
// convert unsigned __int64 to double. Sigh.
- if (de->st.size < 1024) {
- (void) mg_snprintf(de->conn, size, sizeof(size),
- "%lu", (unsigned long) de->st.size);
- } else if (de->st.size < 1024 * 1024) {
- (void) mg_snprintf(de->conn, size, sizeof(size),
- "%.1fk", (double) de->st.size / 1024.0);
- } else if (de->st.size < 1024 * 1024 * 1024) {
- (void) mg_snprintf(de->conn, size, sizeof(size),
- "%.1fM", (double) de->st.size / 1048576);
+ if (de->file.size < 1024) {
+ mg_snprintf(de->conn, size, sizeof(size), "%d", (int) de->file.size);
+ } else if (de->file.size < 0x100000) {
+ mg_snprintf(de->conn, size, sizeof(size),
+ "%.1fk", (double) de->file.size / 1024.0);
+ } else if (de->file.size < 0x40000000) {
+ mg_snprintf(de->conn, size, sizeof(size),
+ "%.1fM", (double) de->file.size / 1048576);
} else {
- (void) mg_snprintf(de->conn, size, sizeof(size),
- "%.1fG", (double) de->st.size / 1073741824);
+ mg_snprintf(de->conn, size, sizeof(size),
+ "%.1fG", (double) de->file.size / 1073741824);
}
}
- (void) strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", localtime(&de->st.mtime));
- url_encode(de->file_name, href, sizeof(href));
+ strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M",
+ localtime(&de->file.modification_time));
+ mg_url_encode(de->file_name, href, sizeof(href));
de->conn->num_bytes_sent += mg_printf(de->conn,
"<tr><td><a href=\"%s%s%s\">%s%s</a></td>"
"<td> %s</td><td> %s</td></tr>\n",
- de->conn->request_info.uri, href, de->st.is_directory ? "/" : "",
- de->file_name, de->st.is_directory ? "/" : "", mod, size);
+ de->conn->request_info.uri, href, de->file.is_directory ? "/" : "",
+ de->file_name, de->file.is_directory ? "/" : "", mod, size);
}
// This function is called from send_directory() and used for
@@ -2424,23 +2750,30 @@ static int WINCDECL compare_dir_entries(const void *p1, const void *p2) {
query_string = "na";
}
- if (a->st.is_directory && !b->st.is_directory) {
+ if (a->file.is_directory && !b->file.is_directory) {
return -1; // Always put directories on top
- } else if (!a->st.is_directory && b->st.is_directory) {
+ } else if (!a->file.is_directory && b->file.is_directory) {
return 1; // Always put directories on top
} else if (*query_string == 'n') {
cmp_result = strcmp(a->file_name, b->file_name);
} else if (*query_string == 's') {
- cmp_result = a->st.size == b->st.size ? 0 :
- a->st.size > b->st.size ? 1 : -1;
+ cmp_result = a->file.size == b->file.size ? 0 :
+ a->file.size > b->file.size ? 1 : -1;
} else if (*query_string == 'd') {
- cmp_result = a->st.mtime == b->st.mtime ? 0 :
- a->st.mtime > b->st.mtime ? 1 : -1;
+ cmp_result = a->file.modification_time == b->file.modification_time ? 0 :
+ a->file.modification_time > b->file.modification_time ? 1 : -1;
}
return query_string[1] == 'd' ? -cmp_result : cmp_result;
}
+static int must_hide_file(struct mg_connection *conn, const char *path) {
+ const char *pw_pattern = "**" PASSWORDS_FILE_NAME "$";
+ const char *pattern = conn->ctx->config[HIDE_FILES];
+ return match_prefix(pw_pattern, strlen(pw_pattern), path) > 0 ||
+ (pattern != NULL && match_prefix(pattern, strlen(pattern), path) > 0);
+}
+
static int scan_directory(struct mg_connection *conn, const char *dir,
void *data, void (*cb)(struct de *, void *)) {
char path[PATH_MAX];
@@ -2454,24 +2787,24 @@ static int scan_directory(struct mg_connection *conn, const char *dir,
de.conn = conn;
while ((dp = readdir(dirp)) != NULL) {
- // Do not show current dir and passwords file
+ // Do not show current dir and hidden files
if (!strcmp(dp->d_name, ".") ||
!strcmp(dp->d_name, "..") ||
- !strcmp(dp->d_name, PASSWORDS_FILE_NAME))
+ must_hide_file(conn, dp->d_name)) {
continue;
+ }
- mg_snprintf(conn, path, sizeof(path), "%s%c%s", dir, DIRSEP, dp->d_name);
+ mg_snprintf(conn, path, sizeof(path), "%s%c%s", dir, '/', dp->d_name);
// If we don't memset stat structure to zero, mtime will have
// garbage and strftime() will segfault later on in
// print_dir_entry(). memset is required only if mg_stat()
// fails. For more details, see
// http://code.google.com/p/mongoose/issues/detail?id=79
- if (mg_stat(path, &de.st) != 0) {
- memset(&de.st, 0, sizeof(de.st));
- }
- de.file_name = dp->d_name;
+ memset(&de.file, 0, sizeof(de.file));
+ mg_stat(conn, path, &de.file);
+ de.file_name = dp->d_name;
cb(&de, data);
}
(void) closedir(dirp);
@@ -2479,26 +2812,79 @@ static int scan_directory(struct mg_connection *conn, const char *dir,
return 1;
}
+static int remove_directory(struct mg_connection *conn, const char *dir) {
+ char path[PATH_MAX];
+ struct dirent *dp;
+ DIR *dirp;
+ struct de de;
+
+ if ((dirp = opendir(dir)) == NULL) {
+ return 0;
+ } else {
+ de.conn = conn;
+
+ while ((dp = readdir(dirp)) != NULL) {
+ // Do not show current dir (but show hidden files as they will also be removed)
+ if (!strcmp(dp->d_name, ".") ||
+ !strcmp(dp->d_name, "..")) {
+ continue;
+ }
+
+ mg_snprintf(conn, path, sizeof(path), "%s%c%s", dir, '/', dp->d_name);
+
+ // If we don't memset stat structure to zero, mtime will have
+ // garbage and strftime() will segfault later on in
+ // print_dir_entry(). memset is required only if mg_stat()
+ // fails. For more details, see
+ // http://code.google.com/p/mongoose/issues/detail?id=79
+ memset(&de.file, 0, sizeof(de.file));
+ mg_stat(conn, path, &de.file);
+ if(de.file.modification_time) {
+ if(de.file.is_directory) {
+ remove_directory(conn, path);
+ } else {
+ mg_remove(path);
+ }
+ }
+
+ }
+ (void) closedir(dirp);
+
+ rmdir(dir);
+ }
+
+ return 1;
+}
+
struct dir_scan_data {
struct de *entries;
int num_entries;
int arr_size;
};
+// Behaves like realloc(), but frees original pointer on failure
+static void *realloc2(void *ptr, size_t size) {
+ void *new_ptr = realloc(ptr, size);
+ if (new_ptr == NULL) {
+ free(ptr);
+ }
+ return new_ptr;
+}
+
static void dir_scan_callback(struct de *de, void *data) {
struct dir_scan_data *dsd = (struct dir_scan_data *) data;
if (dsd->entries == NULL || dsd->num_entries >= dsd->arr_size) {
dsd->arr_size *= 2;
- dsd->entries = (struct de *) realloc(dsd->entries, dsd->arr_size *
- sizeof(dsd->entries[0]));
+ dsd->entries = (struct de *) realloc2(dsd->entries, dsd->arr_size *
+ sizeof(dsd->entries[0]));
}
if (dsd->entries == NULL) {
// TODO(lsm): propagate an error to the caller
dsd->num_entries = 0;
} else {
dsd->entries[dsd->num_entries].file_name = mg_strdup(de->file_name);
- dsd->entries[dsd->num_entries].st = de->st;
+ dsd->entries[dsd->num_entries].file = de->file;
dsd->entries[dsd->num_entries].conn = de->conn;
dsd->num_entries++;
}
@@ -2551,31 +2937,46 @@ static void handle_directory_request(struct mg_connection *conn,
free(data.entries);
conn->num_bytes_sent += mg_printf(conn, "%s", "</table></body></html>");
- conn->request_info.status_code = 200;
+ conn->status_code = 200;
}
// Send len bytes from the opened file to the client.
-static void send_file_data(struct mg_connection *conn, FILE *fp, int64_t len) {
- char buf[BUFSIZ];
+static void send_file_data(struct mg_connection *conn, struct file *filep,
+ int64_t offset, int64_t len) {
+ char buf[MG_BUF_LEN];
int to_read, num_read, num_written;
- while (len > 0) {
- // Calculate how much to read from the file in the buffer
- to_read = sizeof(buf);
- if ((int64_t) to_read > len)
- to_read = (int) len;
+ // Sanity check the offset
+ offset = offset < 0 ? 0 : offset > filep->size ? filep->size : offset;
- // Read from file, exit the loop on error
- if ((num_read = fread(buf, 1, (size_t)to_read, fp)) == 0)
- break;
+ if (len > 0 && filep->membuf != NULL && filep->size > 0) {
+ if (len > filep->size - offset) {
+ len = filep->size - offset;
+ }
+ mg_write(conn, filep->membuf + offset, (size_t) len);
+ } else if (len > 0 && filep->fp != NULL) {
+ fseeko(filep->fp, offset, SEEK_SET);
+ while (len > 0) {
+ // Calculate how much to read from the file in the buffer
+ to_read = sizeof(buf);
+ if ((int64_t) to_read > len) {
+ to_read = (int) len;
+ }
- // Send read bytes to the client, exit the loop on error
- if ((num_written = mg_write(conn, buf, (size_t)num_read)) != num_read)
- break;
+ // Read from file, exit the loop on error
+ if ((num_read = fread(buf, 1, (size_t) to_read, filep->fp)) <= 0) {
+ break;
+ }
+
+ // Send read bytes to the client, exit the loop on error
+ if ((num_written = mg_write(conn, buf, (size_t) num_read)) != num_read) {
+ break;
+ }
- // Both read and were successful, adjust counters
- conn->num_bytes_sent += num_written;
- len -= num_written;
+ // Both read and were successful, adjust counters
+ conn->num_bytes_sent += num_written;
+ len -= num_written;
+ }
}
}
@@ -2587,73 +2988,103 @@ static void gmt_time_string(char *buf, size_t buf_len, time_t *t) {
strftime(buf, buf_len, "%a, %d %b %Y %H:%M:%S GMT", gmtime(t));
}
+static void construct_etag(char *buf, size_t buf_len,
+ const struct file *filep) {
+ snprintf(buf, buf_len, "\"%lx.%" INT64_FMT "\"",
+ (unsigned long) filep->modification_time, filep->size);
+}
+
+static void fclose_on_exec(struct file *filep) {
+ if (filep != NULL && filep->fp != NULL) {
+#ifndef _WIN32
+ fcntl(fileno(filep->fp), F_SETFD, FD_CLOEXEC);
+#endif
+ }
+}
+
static void handle_file_request(struct mg_connection *conn, const char *path,
- struct mgstat *stp) {
+ struct file *filep) {
char date[64], lm[64], etag[64], range[64];
const char *msg = "OK", *hdr;
time_t curtime = time(NULL);
int64_t cl, r1, r2;
struct vec mime_vec;
- FILE *fp;
int n;
+ char gz_path[PATH_MAX];
+ char const* encoding = "";
get_mime_type(conn->ctx, path, &mime_vec);
- cl = stp->size;
- conn->request_info.status_code = 200;
+ cl = filep->size;
+ conn->status_code = 200;
range[0] = '\0';
- if ((fp = mg_fopen(path, "rb")) == NULL) {
+ // if this file is in fact a pre-gzipped file, rewrite its filename
+ // it's important to rewrite the filename after resolving
+ // the mime type from it, to preserve the actual file's type
+ if (filep->gzipped) {
+ snprintf(gz_path, sizeof(gz_path), "%s.gz", path);
+ path = gz_path;
+ encoding = "Content-Encoding: gzip\r\n";
+ }
+
+ if (!mg_fopen(conn, path, "rb", filep)) {
send_http_error(conn, 500, http_500_error,
- "fopen(%s): %s", path, strerror(ERRNO));
+ "fopen(%s): %s", path, strerror(ERRNO));
return;
}
- set_close_on_exec(fileno(fp));
+
+ fclose_on_exec(filep);
// If Range: header specified, act accordingly
r1 = r2 = 0;
hdr = mg_get_header(conn, "Range");
- if (hdr != NULL && (n = parse_range_header(hdr, &r1, &r2)) > 0) {
- conn->request_info.status_code = 206;
- (void) fseeko(fp, (off_t) r1, SEEK_SET);
- cl = n == 2 ? r2 - r1 + 1: cl - r1;
- (void) mg_snprintf(conn, range, sizeof(range),
- "Content-Range: bytes "
- "%" INT64_FMT "-%"
- INT64_FMT "/%" INT64_FMT "\r\n",
- r1, r1 + cl - 1, stp->size);
+ if (hdr != NULL && (n = parse_range_header(hdr, &r1, &r2)) > 0 &&
+ r1 >= 0 && r2 >= 0) {
+ // actually, range requests don't play well with a pre-gzipped
+ // file (since the range is specified in the uncmpressed space)
+ if (filep->gzipped) {
+ send_http_error(conn, 501, "Not Implemented", "range requests in gzipped files are not supported");
+ return;
+ }
+ conn->status_code = 206;
+ cl = n == 2 ? (r2 > cl ? cl : r2) - r1 + 1: cl - r1;
+ mg_snprintf(conn, range, sizeof(range),
+ "Content-Range: bytes "
+ "%" INT64_FMT "-%"
+ INT64_FMT "/%" INT64_FMT "\r\n",
+ r1, r1 + cl - 1, filep->size);
msg = "Partial Content";
}
// Prepare Etag, Date, Last-Modified headers. Must be in UTC, according to
// http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3
gmt_time_string(date, sizeof(date), &curtime);
- gmt_time_string(lm, sizeof(lm), &stp->mtime);
- (void) mg_snprintf(conn, etag, sizeof(etag), "%lx.%lx",
- (unsigned long) stp->mtime, (unsigned long) stp->size);
+ gmt_time_string(lm, sizeof(lm), &filep->modification_time);
+ construct_etag(etag, sizeof(etag), filep);
(void) mg_printf(conn,
"HTTP/1.1 %d %s\r\n"
"Date: %s\r\n"
"Last-Modified: %s\r\n"
- "Etag: \"%s\"\r\n"
+ "Etag: %s\r\n"
"Content-Type: %.*s\r\n"
"Content-Length: %" INT64_FMT "\r\n"
"Connection: %s\r\n"
"Accept-Ranges: bytes\r\n"
- "%s\r\n",
- conn->request_info.status_code, msg, date, lm, etag, (int) mime_vec.len,
- mime_vec.ptr, cl, suggest_connection_header(conn), range);
+ "%s%s\r\n",
+ conn->status_code, msg, date, lm, etag, (int) mime_vec.len,
+ mime_vec.ptr, cl, suggest_connection_header(conn), range, encoding);
if (strcmp(conn->request_info.request_method, "HEAD") != 0) {
- send_file_data(conn, fp, cl);
+ send_file_data(conn, filep, r1, cl);
}
- (void) fclose(fp);
+ mg_fclose(filep);
}
void mg_send_file(struct mg_connection *conn, const char *path) {
- struct mgstat st;
- if (mg_stat(path, &st) == 0) {
- handle_file_request(conn, path, &st);
+ struct file file = STRUCT_FILE_INITIALIZER;
+ if (mg_stat(conn, path, &file)) {
+ handle_file_request(conn, path, &file);
} else {
send_http_error(conn, 404, "Not Found", "%s", "File not found");
}
@@ -2678,30 +3109,45 @@ static int is_valid_http_method(const char *method) {
return !strcmp(method, "GET") || !strcmp(method, "POST") ||
!strcmp(method, "HEAD") || !strcmp(method, "CONNECT") ||
!strcmp(method, "PUT") || !strcmp(method, "DELETE") ||
- !strcmp(method, "OPTIONS") || !strcmp(method, "PROPFIND");
+ !strcmp(method, "OPTIONS") || !strcmp(method, "PROPFIND")
+ || !strcmp(method, "MKCOL")
+ ;
}
// Parse HTTP request, fill in mg_request_info structure.
-static int parse_http_request(char *buf, struct mg_request_info *ri) {
- int status = 0;
-
- // RFC says that all initial whitespaces should be ingored
- while (*buf != '\0' && isspace(* (unsigned char *) buf)) {
- buf++;
- }
-
- ri->request_method = skip(&buf, " ");
- ri->uri = skip(&buf, " ");
- ri->http_version = skip(&buf, "\r\n");
-
- if (is_valid_http_method(ri->request_method) &&
- strncmp(ri->http_version, "HTTP/", 5) == 0) {
- ri->http_version += 5; // Skip "HTTP/"
- parse_http_headers(&buf, ri);
- status = 1;
+// This function modifies the buffer by NUL-terminating
+// HTTP request components, header names and header values.
+static int parse_http_message(char *buf, int len, struct mg_request_info *ri) {
+ int is_request, request_length = get_request_len(buf, len);
+ if (request_length > 0) {
+ // Reset attributes. DO NOT TOUCH is_ssl, remote_ip, remote_port
+ ri->remote_user = ri->request_method = ri->uri = ri->http_version = NULL;
+ ri->num_headers = 0;
+
+ buf[request_length - 1] = '\0';
+
+ // RFC says that all initial whitespaces should be ingored
+ while (*buf != '\0' && isspace(* (unsigned char *) buf)) {
+ buf++;
+ }
+ ri->request_method = skip(&buf, " ");
+ ri->uri = skip(&buf, " ");
+ ri->http_version = skip(&buf, "\r\n");
+
+ // HTTP message could be either HTTP request or HTTP response, e.g.
+ // "GET / HTTP/1.0 ...." or "HTTP/1.0 200 OK ..."
+ is_request = is_valid_http_method(ri->request_method);
+ if ((is_request && memcmp(ri->http_version, "HTTP/", 5) != 0) ||
+ (!is_request && memcmp(ri->request_method, "HTTP/", 5) != 0)) {
+ request_length = -1;
+ } else {
+ if (is_request) {
+ ri->http_version += 5;
+ }
+ parse_http_headers(&buf, ri);
+ }
}
-
- return status;
+ return request_length;
}
// Keep reading the input (either opened file descriptor fd, or socket sock,
@@ -2709,28 +3155,29 @@ static int parse_http_request(char *buf, struct mg_request_info *ri) {
// buffer (which marks the end of HTTP request). Buffer buf may already
// have some data. The length of the data is stored in nread.
// Upon every read operation, increase nread by the number of bytes read.
-static int read_request(FILE *fp, SOCKET sock, SSL *ssl, char *buf, int bufsiz,
- int *nread) {
+static int read_request(FILE *fp, struct mg_connection *conn,
+ char *buf, int bufsiz, int *nread) {
int request_len, n = 0;
- do {
+ request_len = get_request_len(buf, *nread);
+ while (conn->ctx->stop_flag == 0 &&
+ *nread < bufsiz && request_len == 0 &&
+ (n = pull(fp, conn, buf + *nread, bufsiz - *nread)) > 0) {
+ *nread += n;
+ assert(*nread <= bufsiz);
request_len = get_request_len(buf, *nread);
- if (request_len == 0 &&
- (n = pull(fp, sock, ssl, buf + *nread, bufsiz - *nread)) > 0) {
- *nread += n;
- }
- } while (*nread < bufsiz && request_len == 0 && n > 0);
+ }
- return request_len;
+ return request_len <= 0 && n <= 0 ? -1 : request_len;
}
// For given directory path, substitute it to valid index file.
// Return 0 if index file has been found, -1 if not found.
// If the file is found, it's stats is returned in stp.
static int substitute_index_file(struct mg_connection *conn, char *path,
- size_t path_len, struct mgstat *stp) {
+ size_t path_len, struct file *filep) {
const char *list = conn->ctx->config[INDEX_FILES];
- struct mgstat st;
+ struct file file = STRUCT_FILE_INITIALIZER;
struct vec filename_vec;
size_t n = strlen(path);
int found = 0;
@@ -2738,10 +3185,10 @@ static int substitute_index_file(struct mg_connection *conn, char *path,
// The 'path' given to us points to the directory. Remove all trailing
// directory separator characters from the end of the path, and
// then append single directory separator character.
- while (n > 0 && IS_DIRSEP_CHAR(path[n - 1])) {
+ while (n > 0 && path[n - 1] == '/') {
n--;
}
- path[n] = DIRSEP;
+ path[n] = '/';
// Traverse index files list. For each entry, append it to the given
// path and see if the file exists. If it exists, break the loop
@@ -2752,12 +3199,12 @@ static int substitute_index_file(struct mg_connection *conn, char *path,
continue;
// Prepare full path to the index file
- (void) mg_strlcpy(path + n + 1, filename_vec.ptr, filename_vec.len + 1);
+ mg_strlcpy(path + n + 1, filename_vec.ptr, filename_vec.len + 1);
// Does it exist?
- if (mg_stat(path, &st) == 0) {
+ if (mg_stat(conn, path, &file)) {
// Yes it does, break the loop
- *stp = st;
+ *filep = file;
found = 1;
break;
}
@@ -2773,31 +3220,35 @@ static int substitute_index_file(struct mg_connection *conn, char *path,
// Return True if we should reply 304 Not Modified.
static int is_not_modified(const struct mg_connection *conn,
- const struct mgstat *stp) {
+ const struct file *filep) {
+ char etag[64];
const char *ims = mg_get_header(conn, "If-Modified-Since");
- return ims != NULL && stp->mtime <= parse_date_string(ims);
+ const char *inm = mg_get_header(conn, "If-None-Match");
+ construct_etag(etag, sizeof(etag), filep);
+ return (inm != NULL && !mg_strcasecmp(etag, inm)) ||
+ (ims != NULL && filep->modification_time <= parse_date_string(ims));
}
static int forward_body_data(struct mg_connection *conn, FILE *fp,
SOCKET sock, SSL *ssl) {
- const char *expect, *buffered;
- char buf[BUFSIZ];
+ const char *expect, *body;
+ char buf[MG_BUF_LEN];
int to_read, nread, buffered_len, success = 0;
expect = mg_get_header(conn, "Expect");
assert(fp != NULL);
if (conn->content_len == -1) {
- send_http_error(conn, 411, "Length Required", "");
+ send_http_error(conn, 411, "Length Required", "%s", "");
} else if (expect != NULL && mg_strcasecmp(expect, "100-continue")) {
- send_http_error(conn, 417, "Expectation Failed", "");
+ send_http_error(conn, 417, "Expectation Failed", "%s", "");
} else {
if (expect != NULL) {
(void) mg_printf(conn, "%s", "HTTP/1.1 100 Continue\r\n\r\n");
}
- buffered = conn->buf + conn->request_len;
- buffered_len = conn->data_len - conn->request_len;
+ body = conn->buf + conn->request_len + conn->consumed_content;
+ buffered_len = &conn->buf[conn->data_len] - body;
assert(buffered_len >= 0);
assert(conn->consumed_content == 0);
@@ -2805,16 +3256,17 @@ static int forward_body_data(struct mg_connection *conn, FILE *fp,
if ((int64_t) buffered_len > conn->content_len) {
buffered_len = (int) conn->content_len;
}
- push(fp, sock, ssl, buffered, (int64_t) buffered_len);
+ push(fp, sock, ssl, body, (int64_t) buffered_len);
conn->consumed_content += buffered_len;
}
+ nread = 0;
while (conn->consumed_content < conn->content_len) {
to_read = sizeof(buf);
if ((int64_t) to_read > conn->content_len - conn->consumed_content) {
to_read = (int) (conn->content_len - conn->consumed_content);
}
- nread = pull(NULL, conn->client.sock, conn->ssl, buf, to_read);
+ nread = pull(NULL, conn, buf, to_read);
if (nread <= 0 || push(fp, sock, ssl, buf, nread) != nread) {
break;
}
@@ -2822,12 +3274,12 @@ static int forward_body_data(struct mg_connection *conn, FILE *fp,
}
if (conn->consumed_content == conn->content_len) {
- success = 1;
+ success = nread >= 0;
}
// Each error code path in this function must send an error
if (!success) {
- send_http_error(conn, 577, http_500_error, "");
+ send_http_error(conn, 577, http_500_error, "%s", "");
}
}
@@ -2851,6 +3303,10 @@ struct cgi_env_block {
int nvars; // Number of variables
};
+static char *addenv(struct cgi_env_block *block,
+ PRINTF_FORMAT_STRING(const char *fmt), ...)
+ PRINTF_ARGS(2, 3);
+
// Append VARIABLE=VALUE\0 string to the buffer, and add a respective
// pointer into the vars array.
static char *addenv(struct cgi_env_block *block, const char *fmt, ...) {
@@ -2871,12 +3327,14 @@ static char *addenv(struct cgi_env_block *block, const char *fmt, ...) {
va_end(ap);
// Make sure we do not overflow buffer and the envp array
- if (n > 0 && n < space &&
+ if (n > 0 && n + 1 < space &&
block->nvars < (int) ARRAY_SIZE(block->vars) - 2) {
// Append a pointer to the added string into the envp array
- block->vars[block->nvars++] = block->buf + block->len;
+ block->vars[block->nvars++] = added;
// Bump up used length counter. Include \0 terminator
block->len += n + 1;
+ } else {
+ cry(block->conn, "%s: CGI env buffer truncated for [%s]", __func__, fmt);
}
return added;
@@ -2887,7 +3345,7 @@ static void prepare_cgi_environment(struct mg_connection *conn,
struct cgi_env_block *blk) {
const char *s, *slash;
struct vec var_vec;
- char *p, src_addr[20];
+ char *p, src_addr[IP_ADDR_STR_LEN];
int i;
blk->len = blk->nvars = 0;
@@ -2897,6 +3355,7 @@ static void prepare_cgi_environment(struct mg_connection *conn,
addenv(blk, "SERVER_NAME=%s", conn->ctx->config[AUTHENTICATION_DOMAIN]);
addenv(blk, "SERVER_ROOT=%s", conn->ctx->config[DOCUMENT_ROOT]);
addenv(blk, "DOCUMENT_ROOT=%s", conn->ctx->config[DOCUMENT_ROOT]);
+ addenv(blk, "SERVER_SOFTWARE=%s/%s", "Mongoose", mg_version());
// Prepare the environment block
addenv(blk, "%s", "GATEWAY_INTERFACE=CGI/1.1");
@@ -2916,7 +3375,7 @@ static void prepare_cgi_environment(struct mg_connection *conn,
slash = strrchr(conn->request_info.uri, '/');
if ((s = strrchr(prog, '/')) == NULL)
s = prog;
- addenv(blk, "SCRIPT_NAME=%.*s%s", slash - conn->request_info.uri,
+ addenv(blk, "SCRIPT_NAME=%.*s%s", (int) (slash - conn->request_info.uri),
conn->request_info.uri, s);
addenv(blk, "SCRIPT_FILENAME=%s", prog);
@@ -2949,6 +3408,12 @@ static void prepare_cgi_environment(struct mg_connection *conn,
if ((s = getenv("SystemDrive")) != NULL) {
addenv(blk, "SystemDrive=%s", s);
}
+ if ((s = getenv("ProgramFiles")) != NULL) {
+ addenv(blk, "ProgramFiles=%s", s);
+ }
+ if ((s = getenv("ProgramFiles(x86)")) != NULL) {
+ addenv(blk, "ProgramFiles(x86)=%s", s);
+ }
#else
if ((s = getenv("LD_LIBRARY_PATH")) != NULL)
addenv(blk, "LD_LIBRARY_PATH=%s", s);
@@ -2979,7 +3444,7 @@ static void prepare_cgi_environment(struct mg_connection *conn,
// Add user-specified variables
s = conn->ctx->config[CGI_ENVIRONMENT];
while ((s = next_option(s, &var_vec, NULL)) != NULL) {
- addenv(blk, "%.*s", var_vec.len, var_vec.ptr);
+ addenv(blk, "%.*s", (int) var_vec.len, var_vec.ptr);
}
blk->vars[blk->nvars++] = NULL;
@@ -2991,13 +3456,14 @@ static void prepare_cgi_environment(struct mg_connection *conn,
}
static void handle_cgi_request(struct mg_connection *conn, const char *prog) {
- int headers_len, data_len, i, fd_stdin[2], fd_stdout[2];
+ int headers_len, data_len, i, fdin[2], fdout[2];
const char *status, *status_text;
char buf[16384], *pbuf, dir[PATH_MAX], *p;
struct mg_request_info ri;
struct cgi_env_block blk;
- FILE *in, *out;
- pid_t pid;
+ FILE *in = NULL, *out = NULL;
+ struct file fout = STRUCT_FILE_INITIALIZER;
+ pid_t pid = (pid_t) -1;
prepare_cgi_environment(conn, prog, &blk);
@@ -3005,39 +3471,51 @@ static void handle_cgi_request(struct mg_connection *conn, const char *prog) {
// directory containing executable program, 'p' must point to the
// executable program name relative to 'dir'.
(void) mg_snprintf(conn, dir, sizeof(dir), "%s", prog);
- if ((p = strrchr(dir, DIRSEP)) != NULL) {
+ if ((p = strrchr(dir, '/')) != NULL) {
*p++ = '\0';
} else {
dir[0] = '.', dir[1] = '\0';
p = (char *) prog;
}
- pid = (pid_t) -1;
- fd_stdin[0] = fd_stdin[1] = fd_stdout[0] = fd_stdout[1] = -1;
- in = out = NULL;
-
- if (pipe(fd_stdin) != 0 || pipe(fd_stdout) != 0) {
+ if (pipe(fdin) != 0 || pipe(fdout) != 0) {
send_http_error(conn, 500, http_500_error,
"Cannot create CGI pipe: %s", strerror(ERRNO));
goto done;
- } else if ((pid = spawn_process(conn, p, blk.buf, blk.vars,
- fd_stdin[0], fd_stdout[1], dir)) == (pid_t) -1) {
- goto done;
- } else if ((in = fdopen(fd_stdin[1], "wb")) == NULL ||
- (out = fdopen(fd_stdout[0], "rb")) == NULL) {
+ }
+
+ pid = spawn_process(conn, p, blk.buf, blk.vars, fdin[0], fdout[1], dir);
+ if (pid == (pid_t) -1) {
send_http_error(conn, 500, http_500_error,
- "fopen: %s", strerror(ERRNO));
+ "Cannot spawn CGI process [%s]: %s", prog, strerror(ERRNO));
goto done;
}
- setbuf(in, NULL);
- setbuf(out, NULL);
+ // Make sure child closes all pipe descriptors. It must dup them to 0,1
+ set_close_on_exec(fdin[0]);
+ set_close_on_exec(fdin[1]);
+ set_close_on_exec(fdout[0]);
+ set_close_on_exec(fdout[1]);
- // spawn_process() must close those!
+ // Parent closes only one side of the pipes.
// If we don't mark them as closed, close() attempt before
// return from this function throws an exception on Windows.
// Windows does not like when closed descriptor is closed again.
- fd_stdin[0] = fd_stdout[1] = -1;
+ (void) close(fdin[0]);
+ (void) close(fdout[1]);
+ fdin[0] = fdout[1] = -1;
+
+
+ if ((in = fdopen(fdin[1], "wb")) == NULL ||
+ (out = fdopen(fdout[0], "rb")) == NULL) {
+ send_http_error(conn, 500, http_500_error,
+ "fopen: %s", strerror(ERRNO));
+ goto done;
+ }
+
+ setbuf(in, NULL);
+ setbuf(out, NULL);
+ fout.fp = out;
// Send POST data to the CGI process if needed
if (!strcmp(conn->request_info.request_method, "POST") &&
@@ -3045,17 +3523,22 @@ static void handle_cgi_request(struct mg_connection *conn, const char *prog) {
goto done;
}
+ // Close so child gets an EOF.
+ fclose(in);
+ in = NULL;
+ fdin[1] = -1;
+
// Now read CGI reply into a buffer. We need to set correct
// status code, thus we need to see all HTTP headers first.
// Do not send anything back to client, until we buffer in all
// HTTP headers.
data_len = 0;
- headers_len = read_request(out, INVALID_SOCKET, NULL,
- buf, sizeof(buf), &data_len);
+ headers_len = read_request(out, conn, buf, sizeof(buf), &data_len);
if (headers_len <= 0) {
send_http_error(conn, 500, http_500_error,
- "CGI program sent malformed HTTP headers: [%.*s]",
- data_len, buf);
+ "CGI program sent malformed or too big (>%u bytes) "
+ "HTTP headers: [%.*s]",
+ (unsigned) sizeof(buf), data_len, buf);
goto done;
}
pbuf = buf;
@@ -3065,21 +3548,21 @@ static void handle_cgi_request(struct mg_connection *conn, const char *prog) {
// Make up and send the status line
status_text = "OK";
if ((status = get_header(&ri, "Status")) != NULL) {
- conn->request_info.status_code = atoi(status);
+ conn->status_code = atoi(status);
status_text = status;
while (isdigit(* (unsigned char *) status_text) || *status_text == ' ') {
status_text++;
}
} else if (get_header(&ri, "Location") != NULL) {
- conn->request_info.status_code = 302;
+ conn->status_code = 302;
} else {
- conn->request_info.status_code = 200;
+ conn->status_code = 200;
}
if (get_header(&ri, "Connection") != NULL &&
!mg_strcasecmp(get_header(&ri, "Connection"), "keep-alive")) {
conn->must_close = 1;
}
- (void) mg_printf(conn, "HTTP/1.1 %d %s\r\n", conn->request_info.status_code,
+ (void) mg_printf(conn, "HTTP/1.1 %d %s\r\n", conn->status_code,
status_text);
// Send headers
@@ -3087,36 +3570,36 @@ static void handle_cgi_request(struct mg_connection *conn, const char *prog) {
mg_printf(conn, "%s: %s\r\n",
ri.http_headers[i].name, ri.http_headers[i].value);
}
- (void) mg_write(conn, "\r\n", 2);
+ mg_write(conn, "\r\n", 2);
- // Send chunk of data that may be read after the headers
+ // Send chunk of data that may have been read after the headers
conn->num_bytes_sent += mg_write(conn, buf + headers_len,
(size_t)(data_len - headers_len));
// Read the rest of CGI output and send to the client
- send_file_data(conn, out, INT64_MAX);
+ send_file_data(conn, &fout, 0, INT64_MAX);
done:
if (pid != (pid_t) -1) {
kill(pid, SIGKILL);
}
- if (fd_stdin[0] != -1) {
- (void) close(fd_stdin[0]);
+ if (fdin[0] != -1) {
+ close(fdin[0]);
}
- if (fd_stdout[1] != -1) {
- (void) close(fd_stdout[1]);
+ if (fdout[1] != -1) {
+ close(fdout[1]);
}
if (in != NULL) {
- (void) fclose(in);
- } else if (fd_stdin[1] != -1) {
- (void) close(fd_stdin[1]);
+ fclose(in);
+ } else if (fdin[1] != -1) {
+ close(fdin[1]);
}
if (out != NULL) {
- (void) fclose(out);
- } else if (fd_stdout[0] != -1) {
- (void) close(fd_stdout[0]);
+ fclose(out);
+ } else if (fdout[0] != -1) {
+ close(fdout[0]);
}
}
#endif // !NO_CGI
@@ -3124,13 +3607,13 @@ done:
// For a given PUT path, create all intermediate subdirectories
// for given path. Return 0 if the path itself is a directory,
// or -1 on error, 1 if OK.
-static int put_dir(const char *path) {
+static int put_dir(struct mg_connection *conn, const char *path) {
char buf[PATH_MAX];
const char *s, *p;
- struct mgstat st;
+ struct file file = STRUCT_FILE_INITIALIZER;
int len, res = 1;
- for (s = p = path + 2; (p = strchr(s, DIRSEP)) != NULL; s = ++p) {
+ for (s = p = path + 2; (p = strchr(s, '/')) != NULL; s = ++p) {
len = p - path;
if (len >= (int) sizeof(buf)) {
res = -1;
@@ -3141,7 +3624,7 @@ static int put_dir(const char *path) {
// Try to create intermediate directory
DEBUG_TRACE(("mkdir(%s)", buf));
- if (mg_stat(buf, &st) == -1 && mg_mkdir(buf, 0755) != 0) {
+ if (!mg_stat(conn, buf, &file) && mg_mkdir(buf, 0755) != 0) {
res = -1;
break;
}
@@ -3155,60 +3638,103 @@ static int put_dir(const char *path) {
return res;
}
+static void mkcol(struct mg_connection *conn, const char *path) {
+ int rc, body_len;
+ struct de de;
+ memset(&de.file, 0, sizeof(de.file));
+ mg_stat(conn, path, &de.file);
+
+ if(de.file.modification_time) {
+ send_http_error(conn, 405, "Method Not Allowed",
+ "mkcol(%s): %s", path, strerror(ERRNO));
+ return;
+ }
+
+ body_len = conn->data_len - conn->request_len;
+ if(body_len > 0) {
+ send_http_error(conn, 415, "Unsupported media type",
+ "mkcol(%s): %s", path, strerror(ERRNO));
+ return;
+ }
+
+ rc = mg_mkdir(path, 0755);
+
+ if (rc == 0) {
+ conn->status_code = 201;
+ mg_printf(conn, "HTTP/1.1 %d Created\r\n\r\n", conn->status_code);
+ } else if (rc == -1) {
+ if(errno == EEXIST)
+ send_http_error(conn, 405, "Method Not Allowed",
+ "mkcol(%s): %s", path, strerror(ERRNO));
+ else if(errno == EACCES)
+ send_http_error(conn, 403, "Forbidden",
+ "mkcol(%s): %s", path, strerror(ERRNO));
+ else if(errno == ENOENT)
+ send_http_error(conn, 409, "Conflict",
+ "mkcol(%s): %s", path, strerror(ERRNO));
+ else
+ send_http_error(conn, 500, http_500_error,
+ "fopen(%s): %s", path, strerror(ERRNO));
+ }
+}
+
static void put_file(struct mg_connection *conn, const char *path) {
- struct mgstat st;
+ struct file file = STRUCT_FILE_INITIALIZER;
const char *range;
int64_t r1, r2;
- FILE *fp;
int rc;
- conn->request_info.status_code = mg_stat(path, &st) == 0 ? 200 : 201;
+ conn->status_code = mg_stat(conn, path, &file) ? 200 : 201;
- if ((rc = put_dir(path)) == 0) {
- mg_printf(conn, "HTTP/1.1 %d OK\r\n\r\n", conn->request_info.status_code);
+ if ((rc = put_dir(conn, path)) == 0) {
+ mg_printf(conn, "HTTP/1.1 %d OK\r\n\r\n", conn->status_code);
} else if (rc == -1) {
send_http_error(conn, 500, http_500_error,
- "put_dir(%s): %s", path, strerror(ERRNO));
- } else if ((fp = mg_fopen(path, "wb+")) == NULL) {
+ "put_dir(%s): %s", path, strerror(ERRNO));
+ } else if (!mg_fopen(conn, path, "wb+", &file) || file.fp == NULL) {
+ mg_fclose(&file);
send_http_error(conn, 500, http_500_error,
- "fopen(%s): %s", path, strerror(ERRNO));
+ "fopen(%s): %s", path, strerror(ERRNO));
} else {
- set_close_on_exec(fileno(fp));
+ fclose_on_exec(&file);
range = mg_get_header(conn, "Content-Range");
r1 = r2 = 0;
if (range != NULL && parse_range_header(range, &r1, &r2) > 0) {
- conn->request_info.status_code = 206;
- // TODO(lsm): handle seek error
- (void) fseeko(fp, (off_t) r1, SEEK_SET);
+ conn->status_code = 206;
+ fseeko(file.fp, r1, SEEK_SET);
}
- if (forward_body_data(conn, fp, INVALID_SOCKET, NULL))
- (void) mg_printf(conn, "HTTP/1.1 %d OK\r\n\r\n",
- conn->request_info.status_code);
- (void) fclose(fp);
+ if (!forward_body_data(conn, file.fp, INVALID_SOCKET, NULL)) {
+ conn->status_code = 500;
+ }
+ mg_printf(conn, "HTTP/1.1 %d OK\r\nContent-Length: 0\r\n\r\n",
+ conn->status_code);
+ mg_fclose(&file);
}
}
-static void send_ssi_file(struct mg_connection *, const char *, FILE *, int);
+static void send_ssi_file(struct mg_connection *, const char *,
+ struct file *, int);
static void do_ssi_include(struct mg_connection *conn, const char *ssi,
char *tag, int include_level) {
- char file_name[BUFSIZ], path[PATH_MAX], *p;
- FILE *fp;
+ char file_name[MG_BUF_LEN], path[PATH_MAX], *p;
+ struct file file = STRUCT_FILE_INITIALIZER;
// sscanf() is safe here, since send_ssi_file() also uses buffer
- // of size BUFSIZ to get the tag. So strlen(tag) is always < BUFSIZ.
+ // of size MG_BUF_LEN to get the tag. So strlen(tag) is always < MG_BUF_LEN.
if (sscanf(tag, " virtual=\"%[^\"]\"", file_name) == 1) {
// File name is relative to the webserver root
(void) mg_snprintf(conn, path, sizeof(path), "%s%c%s",
- conn->ctx->config[DOCUMENT_ROOT], DIRSEP, file_name);
- } else if (sscanf(tag, " file=\"%[^\"]\"", file_name) == 1) {
+ conn->ctx->config[DOCUMENT_ROOT], '/', file_name);
+ } else if (sscanf(tag, " abspath=\"%[^\"]\"", file_name) == 1) {
// File name is relative to the webserver working directory
// or it is absolute system path
(void) mg_snprintf(conn, path, sizeof(path), "%s", file_name);
- } else if (sscanf(tag, " \"%[^\"]\"", file_name) == 1) {
+ } else if (sscanf(tag, " file=\"%[^\"]\"", file_name) == 1 ||
+ sscanf(tag, " \"%[^\"]\"", file_name) == 1) {
// File name is relative to the currect document
(void) mg_snprintf(conn, path, sizeof(path), "%s", ssi);
- if ((p = strrchr(path, DIRSEP)) != NULL) {
+ if ((p = strrchr(path, '/')) != NULL) {
p[1] = '\0';
}
(void) mg_snprintf(conn, path + strlen(path),
@@ -3218,51 +3744,59 @@ static void do_ssi_include(struct mg_connection *conn, const char *ssi,
return;
}
- if ((fp = mg_fopen(path, "rb")) == NULL) {
+ if (!mg_fopen(conn, path, "rb", &file)) {
cry(conn, "Cannot open SSI #include: [%s]: fopen(%s): %s",
tag, path, strerror(ERRNO));
} else {
- set_close_on_exec(fileno(fp));
+ fclose_on_exec(&file);
if (match_prefix(conn->ctx->config[SSI_EXTENSIONS],
strlen(conn->ctx->config[SSI_EXTENSIONS]), path) > 0) {
- send_ssi_file(conn, path, fp, include_level + 1);
+ send_ssi_file(conn, path, &file, include_level + 1);
} else {
- send_file_data(conn, fp, INT64_MAX);
+ send_file_data(conn, &file, 0, INT64_MAX);
}
- (void) fclose(fp);
+ mg_fclose(&file);
}
}
#if !defined(NO_POPEN)
static void do_ssi_exec(struct mg_connection *conn, char *tag) {
- char cmd[BUFSIZ];
- FILE *fp;
+ char cmd[MG_BUF_LEN];
+ struct file file = STRUCT_FILE_INITIALIZER;
if (sscanf(tag, " \"%[^\"]\"", cmd) != 1) {
cry(conn, "Bad SSI #exec: [%s]", tag);
- } else if ((fp = popen(cmd, "r")) == NULL) {
+ } else if ((file.fp = popen(cmd, "r")) == NULL) {
cry(conn, "Cannot SSI #exec: [%s]: %s", cmd, strerror(ERRNO));
} else {
- send_file_data(conn, fp, INT64_MAX);
- (void) pclose(fp);
+ send_file_data(conn, &file, 0, INT64_MAX);
+ pclose(file.fp);
}
}
#endif // !NO_POPEN
+static int mg_fgetc(struct file *filep, int offset) {
+ if (filep->membuf != NULL && offset >=0 && offset < filep->size) {
+ return ((unsigned char *) filep->membuf)[offset];
+ } else if (filep->fp != NULL) {
+ return fgetc(filep->fp);
+ } else {
+ return EOF;
+ }
+}
+
static void send_ssi_file(struct mg_connection *conn, const char *path,
- FILE *fp, int include_level) {
- char buf[BUFSIZ];
- int ch, len, in_ssi_tag;
+ struct file *filep, int include_level) {
+ char buf[MG_BUF_LEN];
+ int ch, offset, len, in_ssi_tag;
if (include_level > 10) {
cry(conn, "SSI #include level is too deep (%s)", path);
return;
}
- in_ssi_tag = 0;
- len = 0;
-
- while ((ch = fgetc(fp)) != EOF) {
+ in_ssi_tag = len = offset = 0;
+ while ((ch = mg_fgetc(filep, offset)) != EOF) {
if (in_ssi_tag && ch == '>') {
in_ssi_tag = 0;
buf[len++] = (char) ch;
@@ -3270,7 +3804,7 @@ static void send_ssi_file(struct mg_connection *conn, const char *path,
assert(len <= (int) sizeof(buf));
if (len < 6 || memcmp(buf, "<!--#", 5) != 0) {
// Not an SSI tag, pass it
- (void) mg_write(conn, buf, (size_t)len);
+ (void) mg_write(conn, buf, (size_t) len);
} else {
if (!memcmp(buf + 5, "include", 7)) {
do_ssi_include(conn, path, buf + 12, include_level);
@@ -3295,14 +3829,14 @@ static void send_ssi_file(struct mg_connection *conn, const char *path,
} else if (ch == '<') {
in_ssi_tag = 1;
if (len > 0) {
- (void) mg_write(conn, buf, (size_t)len);
+ mg_write(conn, buf, (size_t) len);
}
len = 0;
buf[len++] = ch & 0xff;
} else {
buf[len++] = ch & 0xff;
if (len == (int) sizeof(buf)) {
- (void) mg_write(conn, buf, (size_t)len);
+ mg_write(conn, buf, (size_t) len);
len = 0;
}
}
@@ -3310,42 +3844,41 @@ static void send_ssi_file(struct mg_connection *conn, const char *path,
// Send the rest of buffered data
if (len > 0) {
- (void) mg_write(conn, buf, (size_t)len);
+ mg_write(conn, buf, (size_t) len);
}
}
static void handle_ssi_file_request(struct mg_connection *conn,
const char *path) {
- FILE *fp;
+ struct file file = STRUCT_FILE_INITIALIZER;
- if ((fp = mg_fopen(path, "rb")) == NULL) {
+ if (!mg_fopen(conn, path, "rb", &file)) {
send_http_error(conn, 500, http_500_error, "fopen(%s): %s", path,
strerror(ERRNO));
} else {
conn->must_close = 1;
- set_close_on_exec(fileno(fp));
+ fclose_on_exec(&file);
mg_printf(conn, "HTTP/1.1 200 OK\r\n"
"Content-Type: text/html\r\nConnection: %s\r\n\r\n",
suggest_connection_header(conn));
- send_ssi_file(conn, path, fp, 0);
- (void) fclose(fp);
+ send_ssi_file(conn, path, &file, 0);
+ mg_fclose(&file);
}
}
static void send_options(struct mg_connection *conn) {
- conn->request_info.status_code = 200;
+ conn->status_code = 200;
- (void) mg_printf(conn,
- "HTTP/1.1 200 OK\r\n"
- "Allow: GET, POST, HEAD, CONNECT, PUT, DELETE, OPTIONS\r\n"
- "DAV: 1\r\n\r\n");
+ mg_printf(conn, "%s", "HTTP/1.1 200 OK\r\n"
+ "Allow: GET, POST, HEAD, CONNECT, PUT, DELETE, OPTIONS, PROPFIND, MKCOL\r\n"
+ "DAV: 1\r\n\r\n");
}
// Writes PROPFIND properties for a collection element
static void print_props(struct mg_connection *conn, const char* uri,
- struct mgstat* st) {
+ struct file *filep) {
char mtime[64];
- gmt_time_string(mtime, sizeof(mtime), &st->mtime);
+ gmt_time_string(mtime, sizeof(mtime), &filep->modification_time);
conn->num_bytes_sent += mg_printf(conn,
"<d:response>"
"<d:href>%s</d:href>"
@@ -3359,25 +3892,27 @@ static void print_props(struct mg_connection *conn, const char* uri,
"</d:propstat>"
"</d:response>\n",
uri,
- st->is_directory ? "<d:collection/>" : "",
- st->size,
+ filep->is_directory ? "<d:collection/>" : "",
+ filep->size,
mtime);
}
static void print_dav_dir_entry(struct de *de, void *data) {
char href[PATH_MAX];
+ char href_encoded[PATH_MAX];
struct mg_connection *conn = (struct mg_connection *) data;
mg_snprintf(conn, href, sizeof(href), "%s%s",
conn->request_info.uri, de->file_name);
- print_props(conn, href, &de->st);
+ mg_url_encode(href, href_encoded, PATH_MAX-1);
+ print_props(conn, href_encoded, &de->file);
}
-static void handle_propfind(struct mg_connection *conn, const char* path,
- struct mgstat* st) {
+static void handle_propfind(struct mg_connection *conn, const char *path,
+ struct file *filep) {
const char *depth = mg_get_header(conn, "Depth");
conn->must_close = 1;
- conn->request_info.status_code = 207;
+ conn->status_code = 207;
mg_printf(conn, "HTTP/1.1 207 Multi-Status\r\n"
"Connection: close\r\n"
"Content-Type: text/xml; charset=utf-8\r\n\r\n");
@@ -3387,10 +3922,10 @@ static void handle_propfind(struct mg_connection *conn, const char* path,
"<d:multistatus xmlns:d='DAV:'>\n");
// Print properties for the requested resource itself
- print_props(conn, conn->request_info.uri, st);
+ print_props(conn, conn->request_info.uri, filep);
// If it is a directory, print directory entries too if Depth is not 0
- if (st->is_directory &&
+ if (filep->is_directory &&
!mg_strcasecmp(conn->ctx->config[ENABLE_DIRECTORY_LISTING], "yes") &&
(depth == NULL || strcmp(depth, "0") != 0)) {
scan_directory(conn, path, conn, &print_dav_dir_entry);
@@ -3399,6 +3934,556 @@ static void handle_propfind(struct mg_connection *conn, const char* path,
conn->num_bytes_sent += mg_printf(conn, "%s\n", "</d:multistatus>");
}
+#if defined(USE_WEBSOCKET)
+
+// START OF SHA-1 code
+// Copyright(c) By Steve Reid <steve at edmweb.com>
+#define SHA1HANDSOFF
+#if defined(__sun)
+#include "solarisfixes.h"
+#endif
+
+union char64long16 { unsigned char c[64]; uint32_t l[16]; };
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+static uint32_t blk0(union char64long16 *block, int i) {
+ // Forrest: SHA expect BIG_ENDIAN, swap if LITTLE_ENDIAN
+ if (!is_big_endian()) {
+ block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) |
+ (rol(block->l[i], 8) & 0x00FF00FF);
+ }
+ return block->l[i];
+}
+
+#define blk(i) (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))
+#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(block, i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
+#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
+
+typedef struct {
+ uint32_t state[5];
+ uint32_t count[2];
+ unsigned char buffer[64];
+} SHA1_CTX;
+
+static void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]) {
+ 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;
+ a = b = c = d = e = 0;
+ memset(block, '\0', sizeof(block));
+}
+
+static void SHA1Init(SHA1_CTX* context) {
+ context->state[0] = 0x67452301;
+ context->state[1] = 0xEFCDAB89;
+ context->state[2] = 0x98BADCFE;
+ context->state[3] = 0x10325476;
+ context->state[4] = 0xC3D2E1F0;
+ context->count[0] = context->count[1] = 0;
+}
+
+static void SHA1Update(SHA1_CTX* context, const unsigned char* data,
+ uint32_t len) {
+ uint32_t i, j;
+
+ j = context->count[0];
+ if ((context->count[0] += len << 3) < j)
+ context->count[1]++;
+ context->count[1] += (len>>29);
+ j = (j >> 3) & 63;
+ if ((j + len) > 63) {
+ memcpy(&context->buffer[j], data, (i = 64-j));
+ SHA1Transform(context->state, context->buffer);
+ for ( ; i + 63 < len; i += 64) {
+ SHA1Transform(context->state, &data[i]);
+ }
+ j = 0;
+ }
+ else i = 0;
+ memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+static void SHA1Final(unsigned char digest[20], SHA1_CTX* context) {
+ unsigned i;
+ unsigned char finalcount[8], c;
+
+ for (i = 0; i < 8; i++) {
+ finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
+ >> ((3-(i & 3)) * 8) ) & 255);
+ }
+ c = 0200;
+ SHA1Update(context, &c, 1);
+ while ((context->count[0] & 504) != 448) {
+ c = 0000;
+ SHA1Update(context, &c, 1);
+ }
+ SHA1Update(context, finalcount, 8);
+ for (i = 0; i < 20; i++) {
+ digest[i] = (unsigned char)
+ ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
+ }
+ memset(context, '\0', sizeof(*context));
+ memset(&finalcount, '\0', sizeof(finalcount));
+}
+// END OF SHA1 CODE
+
+static void base64_encode(const unsigned char *src, int src_len, char *dst) {
+ 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];
+
+ dst[j++] = b64[a >> 2];
+ dst[j++] = b64[((a & 3) << 4) | (b >> 4)];
+ if (i + 1 < src_len) {
+ dst[j++] = b64[(b & 15) << 2 | (c >> 6)];
+ }
+ if (i + 2 < src_len) {
+ dst[j++] = b64[c & 63];
+ }
+ }
+ while (j % 4 != 0) {
+ dst[j++] = '=';
+ }
+ dst[j++] = '\0';
+}
+
+static void send_websocket_handshake(struct mg_connection *conn) {
+ static const char *magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+ char buf[100], sha[20], b64_sha[sizeof(sha) * 2];
+ SHA1_CTX sha_ctx;
+
+ mg_snprintf(conn, buf, sizeof(buf), "%s%s",
+ mg_get_header(conn, "Sec-WebSocket-Key"), magic);
+ SHA1Init(&sha_ctx);
+ SHA1Update(&sha_ctx, (unsigned char *) buf, strlen(buf));
+ SHA1Final((unsigned char *) sha, &sha_ctx);
+ base64_encode((unsigned char *) sha, sizeof(sha), b64_sha);
+ mg_printf(conn, "%s%s%s",
+ "HTTP/1.1 101 Switching Protocols\r\n"
+ "Upgrade: websocket\r\n"
+ "Connection: Upgrade\r\n"
+ "Sec-WebSocket-Accept: ", b64_sha, "\r\n\r\n");
+}
+
+static void read_websocket(struct mg_connection *conn) {
+ // Pointer to the beginning of the portion of the incoming websocket message
+ // queue. The original websocket upgrade request is never removed,
+ // so the queue begins after it.
+ unsigned char *buf = (unsigned char *) conn->buf + conn->request_len;
+ int bits, n, stop = 0;
+ size_t i, len, mask_len, data_len, header_len, body_len;
+ // data points to the place where the message is stored when passed to the
+ // websocket_data callback. This is either mem on the stack,
+ // or a dynamically allocated buffer if it is too large.
+ char mem[4 * 1024], mask[4], *data;
+
+ assert(conn->content_len == 0);
+
+ // Loop continuously, reading messages from the socket, invoking the callback,
+ // and waiting repeatedly until an error occurs.
+ while (!stop) {
+ header_len = 0;
+ // body_len is the length of the entire queue in bytes
+ // len is the length of the current message
+ // data_len is the length of the current message's data payload
+ // header_len is the length of the current message's header
+ if ((body_len = conn->data_len - conn->request_len) >= 2) {
+ len = buf[1] & 127;
+ mask_len = buf[1] & 128 ? 4 : 0;
+ if (len < 126 && body_len >= mask_len) {
+ data_len = len;
+ header_len = 2 + mask_len;
+ } else if (len == 126 && body_len >= 4 + mask_len) {
+ header_len = 4 + mask_len;
+ data_len = ((((int) buf[2]) << 8) + buf[3]);
+ } else if (body_len >= 10 + mask_len) {
+ header_len = 10 + mask_len;
+ data_len = (((uint64_t) htonl(* (uint32_t *) &buf[2])) << 32) +
+ htonl(* (uint32_t *) &buf[6]);
+ }
+ }
+
+ // Data layout is as follows:
+ // conn->buf buf
+ // v v frame1 | frame2
+ // |---------------------|----------------|--------------|-------
+ // | |<--header_len-->|<--data_len-->|
+ // |<-conn->request_len->|<-----body_len----------->|
+ // |<-------------------conn->data_len------------->|
+
+ if (header_len > 0) {
+ // Allocate space to hold websocket payload
+ data = mem;
+ if (data_len > sizeof(mem) && (data = malloc(data_len)) == NULL) {
+ // Allocation failed, exit the loop and then close the connection
+ // TODO: notify user about the failure
+ break;
+ }
+
+ // Save mask and bits, otherwise it may be clobbered by memmove below
+ bits = buf[0];
+ memcpy(mask, buf + header_len - mask_len, mask_len);
+
+ // Read frame payload into the allocated buffer.
+ assert(body_len >= header_len);
+ if (data_len + header_len > body_len) {
+ len = body_len - header_len;
+ memcpy(data, buf + header_len, len);
+ // TODO: handle pull error
+ pull_all(NULL, conn, data + len, data_len - len);
+ conn->data_len = conn->request_len;
+ } else {
+ len = data_len + header_len;
+ memcpy(data, buf + header_len, data_len);
+ memmove(buf, buf + len, body_len - len);
+ conn->data_len -= len;
+ }
+
+ // Apply mask if necessary
+ if (mask_len > 0) {
+ for (i = 0; i < data_len; i++) {
+ data[i] ^= mask[i % 4];
+ }
+ }
+
+ // Exit the loop if callback signalled to exit,
+ // or "connection close" opcode received.
+ if ((bits & WEBSOCKET_OPCODE_CONNECTION_CLOSE) ||
+ (conn->ctx->callbacks.websocket_data != NULL &&
+ !conn->ctx->callbacks.websocket_data(conn, bits, data, data_len))) {
+ stop = 1;
+ }
+
+ if (data != mem) {
+ free(data);
+ }
+ // Not breaking the loop, process next websocket frame.
+ } else {
+ // Buffering websocket request
+ if ((n = pull(NULL, conn, conn->buf + conn->data_len,
+ conn->buf_size - conn->data_len)) <= 0) {
+ break;
+ }
+ conn->data_len += n;
+ }
+ }
+}
+
+int mg_websocket_write(struct mg_connection* conn, int opcode,
+ const char *data, size_t data_len) {
+ unsigned char *copy;
+ size_t copy_len = 0;
+ int retval = -1;
+
+ if ((copy = (unsigned char *) malloc(data_len + 10)) == NULL) {
+ return -1;
+ }
+
+ copy[0] = 0x80 + (opcode & 0x0f);
+
+ // Frame format: http://tools.ietf.org/html/rfc6455#section-5.2
+ if (data_len < 126) {
+ // Inline 7-bit length field
+ copy[1] = data_len;
+ memcpy(copy + 2, data, data_len);
+ copy_len = 2 + data_len;
+ } else if (data_len <= 0xFFFF) {
+ // 16-bit length field
+ copy[1] = 126;
+ * (uint16_t *) (copy + 2) = htons(data_len);
+ memcpy(copy + 4, data, data_len);
+ copy_len = 4 + data_len;
+ } else {
+ // 64-bit length field
+ copy[1] = 127;
+ * (uint32_t *) (copy + 2) = htonl((uint64_t) data_len >> 32);
+ * (uint32_t *) (copy + 6) = htonl(data_len & 0xffffffff);
+ memcpy(copy + 10, data, data_len);
+ copy_len = 10 + data_len;
+ }
+
+ // Not thread safe
+ if (copy_len > 0) {
+ retval = mg_write(conn, copy, copy_len);
+ }
+ free(copy);
+
+ return retval;
+}
+
+static void handle_websocket_request(struct mg_connection *conn) {
+ const char *version = mg_get_header(conn, "Sec-WebSocket-Version");
+ if (version == NULL || strcmp(version, "13") != 0) {
+ send_http_error(conn, 426, "Upgrade Required", "%s", "Upgrade Required");
+ } else if (conn->ctx->callbacks.websocket_connect != NULL &&
+ conn->ctx->callbacks.websocket_connect(conn) != 0) {
+ // Callback has returned non-zero, do not proceed with handshake
+ } else {
+ send_websocket_handshake(conn);
+ if (conn->ctx->callbacks.websocket_ready != NULL) {
+ conn->ctx->callbacks.websocket_ready(conn);
+ }
+ read_websocket(conn);
+ }
+}
+
+static int is_websocket_request(const struct mg_connection *conn) {
+ const char *host, *upgrade, *connection, *version, *key;
+
+ host = mg_get_header(conn, "Host");
+ upgrade = mg_get_header(conn, "Upgrade");
+ connection = mg_get_header(conn, "Connection");
+ key = mg_get_header(conn, "Sec-WebSocket-Key");
+ version = mg_get_header(conn, "Sec-WebSocket-Version");
+
+ return host != NULL && upgrade != NULL && connection != NULL &&
+ key != NULL && version != NULL &&
+ mg_strcasestr(upgrade, "websocket") != NULL &&
+ mg_strcasestr(connection, "Upgrade") != NULL;
+}
+#endif // !USE_WEBSOCKET
+
+static int isbyte(int n) {
+ return n >= 0 && n <= 255;
+}
+
+static int parse_net(const char *spec, uint32_t *net, uint32_t *mask) {
+ 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;
+}
+
+static int set_throttle(const char *spec, uint32_t remote_ip, const char *uri) {
+ int throttle = 0;
+ struct vec vec, val;
+ uint32_t net, mask;
+ char mult;
+ double v;
+
+ while ((spec = next_option(spec, &vec, &val)) != NULL) {
+ mult = ',';
+ if (sscanf(val.ptr, "%lf%c", &v, &mult) < 1 || v < 0 ||
+ (lowercase(&mult) != 'k' && lowercase(&mult) != 'm' && mult != ',')) {
+ continue;
+ }
+ v *= lowercase(&mult) == 'k' ? 1024 : lowercase(&mult) == 'm' ? 1048576 : 1;
+ if (vec.len == 1 && vec.ptr[0] == '*') {
+ throttle = (int) v;
+ } else if (parse_net(vec.ptr, &net, &mask) > 0) {
+ if ((remote_ip & mask) == net) {
+ throttle = (int) v;
+ }
+ } else if (match_prefix(vec.ptr, vec.len, uri) > 0) {
+ throttle = (int) v;
+ }
+ }
+
+ return throttle;
+}
+
+static uint32_t get_remote_ip(const struct mg_connection *conn) {
+ return ntohl(* (uint32_t *) &conn->client.rsa.sin.sin_addr);
+}
+
+#ifdef USE_LUA
+#include "mod_lua.c"
+#endif // USE_LUA
+
+int mg_upload(struct mg_connection *conn, const char *destination_dir) {
+ const char *content_type_header, *boundary_start;
+ char buf[MG_BUF_LEN], path[PATH_MAX], fname[1024], boundary[100], *s;
+ FILE *fp;
+ int bl, n, i, j, headers_len, boundary_len, eof,
+ len = 0, num_uploaded_files = 0;
+
+ // 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 num_uploaded_files;
+ }
+
+ boundary_len = strlen(boundary);
+ bl = boundary_len + 4; // \r\n--<boundary>
+ for (;;) {
+ // Pull in headers
+ assert(len >= 0 && len <= (int) sizeof(buf));
+ while ((n = mg_read(conn, buf + len, sizeof(buf) - len)) > 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;
+
+ // 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, sizeof(path), "%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;
+ }
+ } while (!eof && (n = mg_read(conn, buf + len, sizeof(buf) - len)) > 0);
+ fclose(fp);
+ if (eof) {
+ num_uploaded_files++;
+ if (conn->ctx->callbacks.upload != NULL) {
+ conn->ctx->callbacks.upload(conn, path);
+ }
+ }
+ }
+
+ return num_uploaded_files;
+}
+
+static int is_put_or_delete_request(const struct mg_connection *conn) {
+ const char *s = conn->request_info.request_method;
+ return s != NULL && (!strcmp(s, "PUT") ||
+ !strcmp(s, "DELETE") ||
+ !strcmp(s, "MKCOL"));
+}
+
+static int get_first_ssl_listener_index(const struct mg_context *ctx) {
+ int i, index = -1;
+ for (i = 0; index == -1 && i < ctx->num_listening_sockets; i++) {
+ index = ctx->listening_sockets[i].is_ssl ? i : -1;
+ }
+ return index;
+}
+
+static void redirect_to_https_port(struct mg_connection *conn, int ssl_index) {
+ char host[1025];
+ const char *host_header;
+
+ if ((host_header = mg_get_header(conn, "Host")) == NULL ||
+ sscanf(host_header, "%1024[^:]", host) == 0) {
+ // Cannot get host from the Host: header. Fallback to our IP address.
+ sockaddr_to_string(host, sizeof(host), &conn->client.lsa);
+ }
+
+ mg_printf(conn, "HTTP/1.1 302 Found\r\nLocation: https://%s:%d%s\r\n\r\n",
+ host, (int) ntohs(conn->ctx->listening_sockets[ssl_index].
+ lsa.sin.sin_port), conn->request_info.uri);
+}
+
// This is the heart of the Mongoose's logic.
// This function is called when the request is read, parsed and validated,
// and Mongoose must decide what action to take: serve a file, or
@@ -3406,64 +4491,94 @@ static void handle_propfind(struct mg_connection *conn, const char* path,
static void handle_request(struct mg_connection *conn) {
struct mg_request_info *ri = &conn->request_info;
char path[PATH_MAX];
- int stat_result, uri_len;
- struct mgstat st;
+ int uri_len, ssl_index;
+ struct file file = STRUCT_FILE_INITIALIZER;
if ((conn->request_info.query_string = strchr(ri->uri, '?')) != NULL) {
- * conn->request_info.query_string++ = '\0';
+ * ((char *) conn->request_info.query_string++) = '\0';
}
- uri_len = strlen(ri->uri);
- url_decode(ri->uri, (size_t)uri_len, ri->uri, (size_t)(uri_len + 1), 0);
- remove_double_dots_and_double_slashes(ri->uri);
- stat_result = convert_uri_to_file_name(conn, path, sizeof(path), &st);
+ uri_len = (int) strlen(ri->uri);
+ mg_url_decode(ri->uri, uri_len, (char *) ri->uri, uri_len + 1, 0);
+ remove_double_dots_and_double_slashes((char *) ri->uri);
+ convert_uri_to_file_name(conn, path, sizeof(path), &file);
+ conn->throttle = set_throttle(conn->ctx->config[THROTTLE],
+ get_remote_ip(conn), ri->uri);
DEBUG_TRACE(("%s", ri->uri));
- if (!check_authorization(conn, path)) {
+ // Perform redirect and auth checks before calling begin_request() handler.
+ // Otherwise, begin_request() would need to perform auth checks and redirects.
+ if (!conn->client.is_ssl && conn->client.ssl_redir &&
+ (ssl_index = get_first_ssl_listener_index(conn->ctx)) > -1) {
+ redirect_to_https_port(conn, ssl_index);
+ } else if (!is_put_or_delete_request(conn) &&
+ !check_authorization(conn, path)) {
send_authorization_request(conn);
- } else if (call_user(conn, MG_NEW_REQUEST) != NULL) {
+ } else if (conn->ctx->callbacks.begin_request != NULL &&
+ conn->ctx->callbacks.begin_request(conn)) {
// Do nothing, callback has served the request
+#if defined(USE_WEBSOCKET)
+ } else if (is_websocket_request(conn)) {
+ handle_websocket_request(conn);
+#endif
} else if (!strcmp(ri->request_method, "OPTIONS")) {
send_options(conn);
- } else if (strstr(path, PASSWORDS_FILE_NAME)) {
- // Do not allow to view passwords files
- send_http_error(conn, 403, "Forbidden", "Access Forbidden");
} else if (conn->ctx->config[DOCUMENT_ROOT] == NULL) {
send_http_error(conn, 404, "Not Found", "Not Found");
- } else if ((!strcmp(ri->request_method, "PUT") ||
- !strcmp(ri->request_method, "DELETE")) &&
- (conn->ctx->config[PUT_DELETE_PASSWORDS_FILE] == NULL ||
- !is_authorized_for_put(conn))) {
+ } else if (is_put_or_delete_request(conn) &&
+ (is_authorized_for_put(conn) != 1)) {
send_authorization_request(conn);
} else if (!strcmp(ri->request_method, "PUT")) {
put_file(conn, path);
+ } else if (!strcmp(ri->request_method, "MKCOL")) {
+ mkcol(conn, path);
} else if (!strcmp(ri->request_method, "DELETE")) {
- if (mg_remove(path) == 0) {
- send_http_error(conn, 200, "OK", "");
- } else {
- send_http_error(conn, 500, http_500_error, "remove(%s): %s", path,
- strerror(ERRNO));
- }
- } else if (stat_result != 0) {
+ struct de de;
+ memset(&de.file, 0, sizeof(de.file));
+ if(!mg_stat(conn, path, &de.file)) {
+ send_http_error(conn, 404, "Not Found", "%s", "File not found");
+ } else {
+ if(de.file.modification_time) {
+ if(de.file.is_directory) {
+ remove_directory(conn, path);
+ send_http_error(conn, 204, "No Content", "%s", "");
+ } else if (mg_remove(path) == 0) {
+ send_http_error(conn, 204, "No Content", "%s", "");
+ } else {
+ send_http_error(conn, 423, "Locked", "remove(%s): %s", path,
+ strerror(ERRNO));
+ }
+ }
+ else {
+ send_http_error(conn, 500, http_500_error, "remove(%s): %s", path,
+ strerror(ERRNO));
+ }
+ }
+ } else if ((file.membuf == NULL && file.modification_time == (time_t) 0) ||
+ must_hide_file(conn, path)) {
send_http_error(conn, 404, "Not Found", "%s", "File not found");
- } else if (st.is_directory && ri->uri[uri_len - 1] != '/') {
- (void) mg_printf(conn,
- "HTTP/1.1 301 Moved Permanently\r\n"
- "Location: %s/\r\n\r\n", ri->uri);
+ } else if (file.is_directory && ri->uri[uri_len - 1] != '/') {
+ mg_printf(conn, "HTTP/1.1 301 Moved Permanently\r\n"
+ "Location: %s/\r\n\r\n", ri->uri);
} else if (!strcmp(ri->request_method, "PROPFIND")) {
- handle_propfind(conn, path, &st);
- } else if (st.is_directory &&
- !substitute_index_file(conn, path, sizeof(path), &st)) {
+ handle_propfind(conn, path, &file);
+ } else if (file.is_directory &&
+ !substitute_index_file(conn, path, sizeof(path), &file)) {
if (!mg_strcasecmp(conn->ctx->config[ENABLE_DIRECTORY_LISTING], "yes")) {
handle_directory_request(conn, path);
} else {
send_http_error(conn, 403, "Directory Listing Denied",
"Directory listing denied");
}
+#ifdef USE_LUA
+ } else if (match_prefix("**.lp$", 6, path) > 0) {
+ handle_lsp_request(conn, path, &file, NULL);
+#endif
#if !defined(NO_CGI)
} else if (match_prefix(conn->ctx->config[CGI_EXTENSIONS],
strlen(conn->ctx->config[CGI_EXTENSIONS]),
path) > 0) {
if (strcmp(ri->request_method, "POST") &&
+ strcmp(ri->request_method, "HEAD") &&
strcmp(ri->request_method, "GET")) {
send_http_error(conn, 501, "Not Implemented",
"Method %s is not implemented", ri->request_method);
@@ -3475,104 +4590,113 @@ static void handle_request(struct mg_connection *conn) {
strlen(conn->ctx->config[SSI_EXTENSIONS]),
path) > 0) {
handle_ssi_file_request(conn, path);
- } else if (is_not_modified(conn, &st)) {
- send_http_error(conn, 304, "Not Modified", "");
+ } else if (is_not_modified(conn, &file)) {
+ send_http_error(conn, 304, "Not Modified", "%s", "");
} else {
- handle_file_request(conn, path, &st);
+ handle_file_request(conn, path, &file);
}
}
static void close_all_listening_sockets(struct mg_context *ctx) {
- struct socket *sp, *tmp;
- for (sp = ctx->listening_sockets; sp != NULL; sp = tmp) {
- tmp = sp->next;
- (void) closesocket(sp->sock);
- free(sp);
+ int i;
+ for (i = 0; i < ctx->num_listening_sockets; i++) {
+ closesocket(ctx->listening_sockets[i].sock);
}
+ free(ctx->listening_sockets);
+}
+
+static int is_valid_port(unsigned int port) {
+ return port > 0 && port < 0xffff;
}
// Valid listening port specification is: [ip_address:]port[s]
-// Examples: 80, 443s, 127.0.0.1:3128,1.2.3.4:8080s
+// Examples: 80, 443s, 127.0.0.1:3128, 1.2.3.4:8080s
// TODO(lsm): add parsing of the IPv6 address
static int parse_port_string(const struct vec *vec, struct socket *so) {
- int a, b, c, d, port, len;
+ unsigned int a, b, c, d, ch, len, port;
+#if defined(USE_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(so, 0, sizeof(*so));
+ so->lsa.sin.sin_family = AF_INET;
- if (sscanf(vec->ptr, "%d.%d.%d.%d:%d%n", &a, &b, &c, &d, &port, &len) == 5) {
- // Bind to a specific IPv4 address
+ if (sscanf(vec->ptr, "%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
so->lsa.sin.sin_addr.s_addr = htonl((a << 24) | (b << 16) | (c << 8) | d);
- } else if (sscanf(vec->ptr, "%d%n", &port, &len) != 1 ||
- len <= 0 ||
- len > (int) vec->len ||
- (vec->ptr[len] && vec->ptr[len] != 's' && vec->ptr[len] != ',')) {
- return 0;
- }
-
- so->is_ssl = vec->ptr[len] == 's';
+ so->lsa.sin.sin_port = htons((uint16_t) port);
#if defined(USE_IPV6)
- so->lsa.sin6.sin6_family = AF_INET6;
- so->lsa.sin6.sin6_port = htons((uint16_t) port);
-#else
- so->lsa.sin.sin_family = AF_INET;
- so->lsa.sin.sin_port = htons((uint16_t) port);
+
+ } else if (sscanf(vec->ptr, "[%49[^]]]:%d%n", buf, &port, &len) == 2 &&
+ inet_pton(AF_INET6, buf, &so->lsa.sin6.sin6_addr)) {
+ // IPv6 address, e.g. [3ffe:2a00:100:7031::1]:8080
+ so->lsa.sin6.sin6_family = AF_INET6;
+ so->lsa.sin6.sin6_port = htons((uint16_t) port);
#endif
+ } else if (sscanf(vec->ptr, "%u%n", &port, &len) == 1) {
+ // If only port is specified, bind to IPv4, INADDR_ANY
+ so->lsa.sin.sin_port = htons((uint16_t) port);
+ } else {
+ port = len = 0; // Parsing failure. Make port invalid.
+ }
- return 1;
+ ch = vec->ptr[len]; // Next character after the port number
+ so->is_ssl = ch == 's';
+ so->ssl_redir = ch == 'r';
+
+ // Make sure the port is valid and vector ends with 's', 'r' or ','
+ return is_valid_port(port) &&
+ (ch == '\0' || ch == 's' || ch == 'r' || ch == ',');
}
static int set_ports_option(struct mg_context *ctx) {
const char *list = ctx->config[LISTENING_PORTS];
int on = 1, success = 1;
- SOCKET sock;
+#if defined(USE_IPV6)
+ int off = 0;
+#endif
struct vec vec;
- struct socket so, *listener;
+ struct socket so, *ptr;
while (success && (list = next_option(list, &vec, NULL)) != NULL) {
if (!parse_port_string(&vec, &so)) {
cry(fc(ctx), "%s: %.*s: invalid port spec. Expecting list of: %s",
- __func__, vec.len, vec.ptr, "[IP_ADDRESS:]PORT[s|p]");
+ __func__, (int) vec.len, vec.ptr, "[IP_ADDRESS:]PORT[s|r]");
success = 0;
} else if (so.is_ssl && ctx->ssl_ctx == NULL) {
cry(fc(ctx), "Cannot add SSL socket, is -ssl_certificate option set?");
success = 0;
- } else if ((sock = socket(so.lsa.sa.sa_family, SOCK_STREAM, 6)) ==
+ } else if ((so.sock = socket(so.lsa.sa.sa_family, SOCK_STREAM, 6)) ==
INVALID_SOCKET ||
-#if !defined(_WIN32)
// On Windows, SO_REUSEADDR is recommended only for
// broadcast UDP sockets
- setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on,
- sizeof(on)) != 0 ||
-#endif // !_WIN32
- // Set TCP keep-alive. This is needed because if HTTP-level
- // keep-alive is enabled, and client resets the connection,
- // server won't get TCP FIN or RST and will keep the connection
- // open forever. With TCP keep-alive, next keep-alive
- // handshake will figure out that the client is down and
- // will close the server end.
- // Thanks to Igor Klopov who suggested the patch.
- setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *) &on,
- sizeof(on)) != 0 ||
- bind(sock, &so.lsa.sa, sizeof(so.lsa)) != 0 ||
- listen(sock, 100) != 0) {
- closesocket(sock);
- cry(fc(ctx), "%s: cannot bind to %.*s: %s", __func__,
- vec.len, vec.ptr, strerror(ERRNO));
+ setsockopt(so.sock, SOL_SOCKET, SO_REUSEADDR,
+ (void *) &on, sizeof(on)) != 0 ||
+#if defined(USE_IPV6)
+ (so.lsa.sa.sa_family == AF_INET6 &&
+ setsockopt(so.sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *) &off,
+ sizeof(off)) != 0) ||
+#endif
+ bind(so.sock, &so.lsa.sa, so.lsa.sa.sa_family == AF_INET ?
+ sizeof(so.lsa.sin) : sizeof(so.lsa)) != 0 ||
+ listen(so.sock, SOMAXCONN) != 0) {
+ cry(fc(ctx), "%s: cannot bind to %.*s: %d (%s)", __func__,
+ (int) vec.len, vec.ptr, ERRNO, strerror(errno));
+ closesocket(so.sock);
success = 0;
- } else if ((listener = (struct socket *)
- calloc(1, sizeof(*listener))) == NULL) {
- closesocket(sock);
- cry(fc(ctx), "%s: %s", __func__, strerror(ERRNO));
+ } else if ((ptr = (struct socket *) realloc(ctx->listening_sockets,
+ (ctx->num_listening_sockets + 1) *
+ sizeof(ctx->listening_sockets[0]))) == NULL) {
+ closesocket(so.sock);
success = 0;
} else {
- *listener = so;
- listener->sock = sock;
- set_close_on_exec(listener->sock);
- listener->next = ctx->listening_sockets;
- ctx->listening_sockets = listener;
+ set_close_on_exec(so.sock);
+ ctx->listening_sockets = ptr;
+ ctx->listening_sockets[ctx->num_listening_sockets] = so;
+ ctx->num_listening_sockets++;
}
}
@@ -3597,10 +4721,10 @@ static void log_header(const struct mg_connection *conn, const char *header,
static void log_access(const struct mg_connection *conn) {
const struct mg_request_info *ri;
FILE *fp;
- char date[64], src_addr[20];
+ char date[64], src_addr[IP_ADDR_STR_LEN];
fp = conn->ctx->config[ACCESS_LOG_FILE] == NULL ? NULL :
- mg_fopen(conn->ctx->config[ACCESS_LOG_FILE], "a+");
+ fopen(conn->ctx->config[ACCESS_LOG_FILE], "a+");
if (fp == NULL)
return;
@@ -3616,7 +4740,7 @@ static void log_access(const struct mg_connection *conn) {
src_addr, ri->remote_user == NULL ? "-" : ri->remote_user, date,
ri->request_method ? ri->request_method : "-",
ri->uri ? ri->uri : "-", ri->http_version,
- conn->request_info.status_code, conn->num_bytes_sent);
+ conn->status_code, conn->num_bytes_sent);
log_header(conn, "Referer", fp);
log_header(conn, "User-Agent", fp);
fputc('\n', fp);
@@ -3626,51 +4750,26 @@ static void log_access(const struct mg_connection *conn) {
fclose(fp);
}
-static int isbyte(int n) {
- return n >= 0 && n <= 255;
-}
-
// Verify given socket address against the ACL.
// Return -1 if ACL is malformed, 0 if address is disallowed, 1 if allowed.
-static int check_acl(struct mg_context *ctx, const union usa *usa) {
- int a, b, c, d, n, mask, allowed;
- char flag;
- uint32_t acl_subnet, acl_mask, remote_ip;
+static int check_acl(struct mg_context *ctx, uint32_t remote_ip) {
+ int allowed, flag;
+ uint32_t net, mask;
struct vec vec;
const char *list = ctx->config[ACCESS_CONTROL_LIST];
- if (list == NULL) {
- return 1;
- }
-
- (void) memcpy(&remote_ip, &usa->sin.sin_addr, sizeof(remote_ip));
-
// If any ACL is set, deny by default
- allowed = '-';
+ allowed = list == NULL ? '+' : '-';
while ((list = next_option(list, &vec, NULL)) != NULL) {
- mask = 32;
-
- if (sscanf(vec.ptr, "%c%d.%d.%d.%d%n", &flag, &a, &b, &c, &d, &n) != 5) {
+ flag = vec.ptr[0];
+ if ((flag != '+' && flag != '-') ||
+ parse_net(&vec.ptr[1], &net, &mask) == 0) {
cry(fc(ctx), "%s: subnet must be [+|-]x.x.x.x[/x]", __func__);
return -1;
- } else if (flag != '+' && flag != '-') {
- cry(fc(ctx), "%s: flag must be + or -: [%s]", __func__, vec.ptr);
- return -1;
- } else if (!isbyte(a)||!isbyte(b)||!isbyte(c)||!isbyte(d)) {
- cry(fc(ctx), "%s: bad ip address: [%s]", __func__, vec.ptr);
- return -1;
- } else if (sscanf(vec.ptr + n, "/%d", &mask) == 0) {
- // Do nothing, no mask specified
- } else if (mask < 0 || mask > 32) {
- cry(fc(ctx), "%s: bad subnet mask: %d [%s]", __func__, n, vec.ptr);
- return -1;
}
- acl_subnet = (a << 24) | (b << 16) | (c << 8) | d;
- acl_mask = mask ? 0xffffffffU << (32 - mask) : 0;
-
- if (acl_subnet == (ntohl(remote_ip) & acl_mask)) {
+ if (net == (remote_ip & mask)) {
allowed = flag;
}
}
@@ -3678,13 +4777,6 @@ static int check_acl(struct mg_context *ctx, const union usa *usa) {
return allowed == '+';
}
-static void add_to_set(SOCKET fd, fd_set *set, int *max_fd) {
- FD_SET(fd, set);
- if (fd > (SOCKET) *max_fd) {
- *max_fd = (int) fd;
- }
-}
-
#if !defined(_WIN32)
static int set_uid_option(struct mg_context *ctx) {
struct passwd *pw;
@@ -3712,6 +4804,12 @@ static int set_uid_option(struct mg_context *ctx) {
#if !defined(NO_SSL)
static pthread_mutex_t *ssl_mutexes;
+static int sslize(struct mg_connection *conn, SSL_CTX *s, int (*func)(SSL *)) {
+ return (conn->ssl = SSL_new(s)) != NULL &&
+ SSL_set_fd(conn->ssl, conn->client.sock) == 1 &&
+ func(conn->ssl) == 1;
+}
+
// Return OpenSSL error message
static const char *ssl_error(void) {
unsigned long err;
@@ -3721,10 +4819,10 @@ static const char *ssl_error(void) {
static void ssl_locking_callback(int mode, int mutex_num, const char *file,
int line) {
- line = 0; // Unused
- file = NULL; // Unused
+ (void) line;
+ (void) file;
- if (mode & CRYPTO_LOCK) {
+ if (mode & 1) { // 1 is CRYPTO_LOCK
(void) pthread_mutex_lock(&ssl_mutexes[mutex_num]);
} else {
(void) pthread_mutex_unlock(&ssl_mutexes[mutex_num]);
@@ -3770,13 +4868,13 @@ static int load_dll(struct mg_context *ctx, const char *dll_name,
// Dynamically load SSL library. Set up ctx->ssl_ctx pointer.
static int set_ssl_option(struct mg_context *ctx) {
- struct mg_request_info request_info;
- SSL_CTX *CTX;
int i, size;
- const char *pem = ctx->config[SSL_CERTIFICATE];
- const char *chain = ctx->config[SSL_CHAIN_FILE];
+ const char *pem;
- if (pem == NULL) {
+ // If PEM file is not specified and the init_ssl callback
+ // is not specified, skip SSL initialization.
+ if ((pem = ctx->config[SSL_CERTIFICATE]) == NULL &&
+ ctx->callbacks.init_ssl == NULL) {
return 1;
}
@@ -3787,33 +4885,27 @@ static int set_ssl_option(struct mg_context *ctx) {
}
#endif // NO_SSL_DL
- // Initialize SSL crap
+ // Initialize SSL library
SSL_library_init();
SSL_load_error_strings();
- if ((CTX = SSL_CTX_new(SSLv23_server_method())) == NULL) {
- cry(fc(ctx), "SSL_CTX_new error: %s", ssl_error());
- } else if (ctx->user_callback != NULL) {
- memset(&request_info, 0, sizeof(request_info));
- request_info.user_data = ctx->user_data;
- ctx->user_callback(MG_INIT_SSL, (struct mg_connection *) CTX,
- &request_info);
+ if ((ctx->ssl_ctx = SSL_CTX_new(SSLv23_server_method())) == NULL) {
+ cry(fc(ctx), "SSL_CTX_new (server) error: %s", ssl_error());
+ return 0;
}
- if (CTX != NULL && SSL_CTX_use_certificate_file(CTX, pem,
- SSL_FILETYPE_PEM) == 0) {
+ // If user callback returned non-NULL, that means that user callback has
+ // set up certificate itself. In this case, skip sertificate setting.
+ if ((ctx->callbacks.init_ssl == NULL ||
+ !ctx->callbacks.init_ssl(ctx->ssl_ctx, ctx->user_data)) &&
+ (SSL_CTX_use_certificate_file(ctx->ssl_ctx, pem, 1) == 0 ||
+ SSL_CTX_use_PrivateKey_file(ctx->ssl_ctx, pem, 1) == 0)) {
cry(fc(ctx), "%s: cannot open %s: %s", __func__, pem, ssl_error());
return 0;
- } else if (CTX != NULL && SSL_CTX_use_PrivateKey_file(CTX, pem,
- SSL_FILETYPE_PEM) == 0) {
- cry(fc(ctx), "%s: cannot open %s: %s", NULL, pem, ssl_error());
- return 0;
}
- if (CTX != NULL && chain != NULL &&
- SSL_CTX_use_certificate_chain_file(CTX, chain) == 0) {
- cry(fc(ctx), "%s: cannot open %s: %s", NULL, chain, ssl_error());
- return 0;
+ if (pem != NULL) {
+ (void) SSL_CTX_use_certificate_chain_file(ctx->ssl_ctx, pem);
}
// Initialize locking callbacks, needed for thread safety.
@@ -3831,9 +4923,6 @@ static int set_ssl_option(struct mg_context *ctx) {
CRYPTO_set_locking_callback(&ssl_locking_callback);
CRYPTO_set_id_callback(&ssl_id_callback);
- // Done with everything. Save the context.
- ctx->ssl_ctx = CTX;
-
return 1;
}
@@ -3851,90 +4940,124 @@ static void uninitialize_ssl(struct mg_context *ctx) {
#endif // !NO_SSL
static int set_gpass_option(struct mg_context *ctx) {
- struct mgstat mgstat;
+ struct file file = STRUCT_FILE_INITIALIZER;
const char *path = ctx->config[GLOBAL_PASSWORDS_FILE];
- return path == NULL || mg_stat(path, &mgstat) == 0;
+ if (path != NULL && !mg_stat(fc(ctx), path, &file)) {
+ cry(fc(ctx), "Cannot open %s: %s", path, strerror(ERRNO));
+ return 0;
+ }
+ return 1;
}
static int set_acl_option(struct mg_context *ctx) {
- union usa fake;
- return check_acl(ctx, &fake) != -1;
+ return check_acl(ctx, (uint32_t) 0x7f000001UL) != -1;
}
static void reset_per_request_attributes(struct mg_connection *conn) {
- struct mg_request_info *ri = &conn->request_info;
-
- // Reset request info attributes. DO NOT TOUCH is_ssl, remote_ip, remote_port
- ri->remote_user = ri->request_method = ri->uri = ri->http_version =
- conn->path_info = NULL;
- ri->num_headers = 0;
- ri->status_code = -1;
-
+ conn->path_info = NULL;
conn->num_bytes_sent = conn->consumed_content = 0;
- conn->content_len = -1;
- conn->request_len = conn->data_len = 0;
- conn->must_close = 0;
+ conn->status_code = -1;
+ conn->must_close = conn->request_len = conn->throttle = 0;
}
-static void close_socket_gracefully(SOCKET sock) {
- char buf[BUFSIZ];
- struct linger linger;
+static void close_socket_gracefully(struct mg_connection *conn) {
+#if defined(_WIN32)
+ char buf[MG_BUF_LEN];
int n;
+#endif
+ struct linger linger;
// Set linger option to avoid socket hanging out after close. This prevent
// ephemeral port exhaust problem under high QPS.
linger.l_onoff = 1;
linger.l_linger = 1;
- setsockopt(sock, SOL_SOCKET, SO_LINGER, (void *) &linger, sizeof(linger));
+ setsockopt(conn->client.sock, SOL_SOCKET, SO_LINGER,
+ (char *) &linger, sizeof(linger));
// Send FIN to the client
- (void) shutdown(sock, SHUT_WR);
- set_non_blocking_mode(sock);
+ shutdown(conn->client.sock, SHUT_WR);
+ set_non_blocking_mode(conn->client.sock);
- // Read and discard pending data. If we do not do that and close the
+#if defined(_WIN32)
+ // Read and discard pending incoming data. If we do not do that and close the
// socket, the data in the send buffer may be discarded. This
// behaviour is seen on Windows, when client keeps sending data
- // when server decide to close the connection; then when client
+ // when server decides to close the connection; then when client
// does recv() it gets no data back.
do {
- n = pull(NULL, sock, NULL, buf, sizeof(buf));
+ n = pull(NULL, conn, buf, sizeof(buf));
} while (n > 0);
+#endif
// Now we know that our FIN is ACK-ed, safe to close
- (void) closesocket(sock);
+ closesocket(conn->client.sock);
}
static void close_connection(struct mg_connection *conn) {
- if (conn->ssl) {
+ conn->must_close = 1;
+
+#ifndef NO_SSL
+ if (conn->ssl != NULL) {
+ // Run SSL_shutdown twice to ensure completly close SSL connection
+ SSL_shutdown(conn->ssl);
SSL_free(conn->ssl);
conn->ssl = NULL;
}
-
+#endif
if (conn->client.sock != INVALID_SOCKET) {
- close_socket_gracefully(conn->client.sock);
+ close_socket_gracefully(conn);
+ conn->client.sock = INVALID_SOCKET;
}
}
-static void discard_current_request_from_buffer(struct mg_connection *conn) {
- char *buffered;
- int buffered_len, body_len;
+void mg_close_connection(struct mg_connection *conn) {
+#ifndef NO_SSL
+ if (conn->client_ssl_ctx != NULL) {
+ SSL_CTX_free((SSL_CTX *) conn->client_ssl_ctx);
+ }
+#endif
+ close_connection(conn);
+ free(conn);
+}
- buffered = conn->buf + conn->request_len;
- buffered_len = conn->data_len - conn->request_len;
- assert(buffered_len >= 0);
+struct mg_connection *mg_connect(const char *host, int port, int use_ssl,
+ char *ebuf, size_t ebuf_len) {
+ static struct mg_context fake_ctx;
+ struct mg_connection *conn = NULL;
+ SOCKET sock;
- if (conn->content_len <= 0) {
- // Protect from negative Content-Length, too
- body_len = 0;
- } else if (conn->content_len < (int64_t) buffered_len) {
- body_len = (int) conn->content_len;
+ if ((sock = conn2(host, port, use_ssl, ebuf, ebuf_len)) == INVALID_SOCKET) {
+ } else if ((conn = (struct mg_connection *)
+ calloc(1, sizeof(*conn) + MAX_REQUEST_SIZE)) == NULL) {
+ snprintf(ebuf, ebuf_len, "calloc(): %s", strerror(ERRNO));
+ closesocket(sock);
+#ifndef NO_SSL
+ } else if (use_ssl && (conn->client_ssl_ctx =
+ SSL_CTX_new(SSLv23_client_method())) == NULL) {
+ snprintf(ebuf, ebuf_len, "SSL_CTX_new error");
+ closesocket(sock);
+ free(conn);
+ conn = NULL;
+#endif // NO_SSL
} else {
- body_len = buffered_len;
+ socklen_t len = sizeof(struct sockaddr);
+ conn->buf_size = MAX_REQUEST_SIZE;
+ conn->buf = (char *) (conn + 1);
+ conn->ctx = &fake_ctx;
+ conn->client.sock = sock;
+ getsockname(sock, &conn->client.rsa.sa, &len);
+ conn->client.is_ssl = use_ssl;
+#ifndef NO_SSL
+ if (use_ssl) {
+ // SSL_CTX_set_verify call is needed to switch off server certificate
+ // checking, which is off by default in OpenSSL and on in yaSSL.
+ SSL_CTX_set_verify(conn->client_ssl_ctx, 0, 0);
+ sslize(conn, conn->client_ssl_ctx, SSL_connect);
+ }
+#endif
}
- conn->data_len -= conn->request_len + body_len;
- memmove(conn->buf, conn->buf + conn->request_len + body_len,
- (size_t) conn->data_len);
+ return conn;
}
static int is_valid_uri(const char *uri) {
@@ -3943,53 +5066,114 @@ static int is_valid_uri(const char *uri) {
return uri[0] == '/' || (uri[0] == '*' && uri[1] == '\0');
}
+static int getreq(struct mg_connection *conn, char *ebuf, size_t ebuf_len) {
+ const char *cl;
+
+ ebuf[0] = '\0';
+ reset_per_request_attributes(conn);
+ conn->request_len = read_request(NULL, conn, conn->buf, conn->buf_size,
+ &conn->data_len);
+ assert(conn->request_len < 0 || conn->data_len >= conn->request_len);
+
+ if (conn->request_len == 0 && conn->data_len == conn->buf_size) {
+ snprintf(ebuf, ebuf_len, "%s", "Request Too Large");
+ } else if (conn->request_len <= 0) {
+ snprintf(ebuf, ebuf_len, "%s", "Client closed connection");
+ } else if (parse_http_message(conn->buf, conn->buf_size,
+ &conn->request_info) <= 0) {
+ snprintf(ebuf, ebuf_len, "Bad request: [%.*s]", conn->data_len, conn->buf);
+ } else {
+ // Request is valid
+ if ((cl = get_header(&conn->request_info, "Content-Length")) != NULL) {
+ conn->content_len = strtoll(cl, NULL, 10);
+ } else if (!mg_strcasecmp(conn->request_info.request_method, "POST") ||
+ !mg_strcasecmp(conn->request_info.request_method, "PUT")) {
+ conn->content_len = -1;
+ } else {
+ conn->content_len = 0;
+ }
+ conn->birth_time = time(NULL);
+ }
+ return ebuf[0] == '\0';
+}
+
+struct mg_connection *mg_download(const char *host, int port, int use_ssl,
+ char *ebuf, size_t ebuf_len,
+ const char *fmt, ...) {
+ struct mg_connection *conn;
+ va_list ap;
+
+ va_start(ap, fmt);
+ ebuf[0] = '\0';
+ if ((conn = mg_connect(host, port, use_ssl, ebuf, ebuf_len)) == NULL) {
+ } else if (mg_vprintf(conn, fmt, ap) <= 0) {
+ snprintf(ebuf, ebuf_len, "%s", "Error sending request");
+ } else {
+ getreq(conn, ebuf, ebuf_len);
+ }
+ if (ebuf[0] != '\0' && conn != NULL) {
+ mg_close_connection(conn);
+ conn = NULL;
+ }
+
+ return conn;
+}
+
static void process_new_connection(struct mg_connection *conn) {
struct mg_request_info *ri = &conn->request_info;
- int keep_alive_enabled;
- const char *cl;
+ int keep_alive_enabled, keep_alive, discard_len;
+ char ebuf[100];
keep_alive_enabled = !strcmp(conn->ctx->config[ENABLE_KEEP_ALIVE], "yes");
+ keep_alive = 0;
+ // Important: on new connection, reset the receiving buffer. Credit goes
+ // to crule42.
+ conn->data_len = 0;
do {
- reset_per_request_attributes(conn);
- conn->request_len = read_request(NULL, conn->client.sock, conn->ssl,
- conn->buf, conn->buf_size,
- &conn->data_len);
- assert(conn->data_len >= conn->request_len);
- if (conn->request_len == 0 && conn->data_len == conn->buf_size) {
- send_http_error(conn, 413, "Request Too Large", "");
- return;
- } if (conn->request_len <= 0) {
- return; // Remote end closed the connection
- }
-
- // Nul-terminate the request cause parse_http_request() uses sscanf
- conn->buf[conn->request_len - 1] = '\0';
- if (!parse_http_request(conn->buf, ri) || !is_valid_uri(ri->uri)) {
- // Do not put garbage in the access log, just send it back to the client
- send_http_error(conn, 400, "Bad Request",
- "Cannot parse HTTP request: [%.*s]", conn->data_len, conn->buf);
+ if (!getreq(conn, ebuf, sizeof(ebuf))) {
+ send_http_error(conn, 500, "Server Error", "%s", ebuf);
+ conn->must_close = 1;
+ } else if (!is_valid_uri(conn->request_info.uri)) {
+ snprintf(ebuf, sizeof(ebuf), "Invalid URI: [%s]", ri->uri);
+ send_http_error(conn, 400, "Bad Request", "%s", ebuf);
} else if (strcmp(ri->http_version, "1.0") &&
strcmp(ri->http_version, "1.1")) {
- // Request seems valid, but HTTP version is strange
- send_http_error(conn, 505, "HTTP version not supported", "");
- log_access(conn);
- } else {
- // Request is valid, handle it
- cl = get_header(ri, "Content-Length");
- conn->content_len = cl == NULL ? -1 : strtoll(cl, NULL, 10);
- conn->birth_time = time(NULL);
+ snprintf(ebuf, sizeof(ebuf), "Bad HTTP version: [%s]", ri->http_version);
+ send_http_error(conn, 505, "Bad HTTP version", "%s", ebuf);
+ }
+
+ if (ebuf[0] == '\0') {
handle_request(conn);
- call_user(conn, MG_REQUEST_COMPLETE);
+ if (conn->ctx->callbacks.end_request != NULL) {
+ conn->ctx->callbacks.end_request(conn, conn->status_code);
+ }
log_access(conn);
- discard_current_request_from_buffer(conn);
}
if (ri->remote_user != NULL) {
free((void *) ri->remote_user);
+ // Important! When having connections with and without auth
+ // would cause double free and then crash
+ ri->remote_user = NULL;
}
- } while (conn->ctx->stop_flag == 0 &&
- keep_alive_enabled &&
- should_keep_alive(conn));
+
+ // NOTE(lsm): order is important here. should_keep_alive() call
+ // is using parsed request, which will be invalid after memmove's below.
+ // Therefore, memorize should_keep_alive() result now for later use
+ // in loop exit condition.
+ keep_alive = conn->ctx->stop_flag == 0 && keep_alive_enabled &&
+ conn->content_len >= 0 && should_keep_alive(conn);
+
+ // Discard all buffered data for this request
+ discard_len = conn->content_len >= 0 && conn->request_len > 0 &&
+ conn->request_len + conn->content_len < (int64_t) conn->data_len ?
+ (int) (conn->request_len + conn->content_len) : conn->data_len;
+ assert(discard_len >= 0);
+ memmove(conn->buf, conn->buf + discard_len, conn->data_len - discard_len);
+ conn->data_len -= discard_len;
+ assert(conn->data_len >= 0);
+ assert(conn->data_len <= conn->buf_size);
+ } while (keep_alive);
}
// Worker threads take accepted socket from the queue
@@ -4022,42 +5206,46 @@ static int consume_socket(struct mg_context *ctx, struct socket *sp) {
return !ctx->stop_flag;
}
-static void worker_thread(struct mg_context *ctx) {
+static void *worker_thread(void *thread_func_param) {
+ struct mg_context *ctx = (struct mg_context *) thread_func_param;
struct mg_connection *conn;
- int buf_size = atoi(ctx->config[MAX_REQUEST_SIZE]);
- conn = (struct mg_connection *) calloc(1, sizeof(*conn) + buf_size);
+ conn = (struct mg_connection *) calloc(1, sizeof(*conn) + MAX_REQUEST_SIZE);
if (conn == NULL) {
cry(fc(ctx), "%s", "Cannot create new connection struct, OOM");
- return;
- }
- conn->buf_size = buf_size;
- conn->buf = (char *) (conn + 1);
-
- // Call consume_socket() even when ctx->stop_flag > 0, to let it signal
- // sq_empty condvar to wake up the master waiting in produce_socket()
- while (consume_socket(ctx, &conn->client)) {
- conn->birth_time = time(NULL);
+ } else {
+ conn->buf_size = MAX_REQUEST_SIZE;
+ conn->buf = (char *) (conn + 1);
conn->ctx = ctx;
+ conn->request_info.user_data = ctx->user_data;
- // Fill in IP, port info early so even if SSL setup below fails,
- // error handler would have the corresponding info.
- // Thanks to Johannes Winkelmann for the patch.
- // TODO(lsm): Fix IPv6 case
- conn->request_info.remote_port = ntohs(conn->client.rsa.sin.sin_port);
- memcpy(&conn->request_info.remote_ip,
- &conn->client.rsa.sin.sin_addr.s_addr, 4);
- conn->request_info.remote_ip = ntohl(conn->request_info.remote_ip);
- conn->request_info.is_ssl = conn->client.is_ssl;
-
- if (!conn->client.is_ssl ||
- (conn->client.is_ssl && sslize(conn, SSL_accept))) {
- process_new_connection(conn);
- }
+ // Call consume_socket() even when ctx->stop_flag > 0, to let it signal
+ // sq_empty condvar to wake up the master waiting in produce_socket()
+ while (consume_socket(ctx, &conn->client)) {
+ conn->birth_time = time(NULL);
- close_connection(conn);
+ // Fill in IP, port info early so even if SSL setup below fails,
+ // error handler would have the corresponding info.
+ // Thanks to Johannes Winkelmann for the patch.
+ // TODO(lsm): Fix IPv6 case
+ conn->request_info.remote_port = ntohs(conn->client.rsa.sin.sin_port);
+ memcpy(&conn->request_info.remote_ip,
+ &conn->client.rsa.sin.sin_addr.s_addr, 4);
+ conn->request_info.remote_ip = ntohl(conn->request_info.remote_ip);
+ conn->request_info.is_ssl = conn->client.is_ssl;
+
+ if (!conn->client.is_ssl
+#ifndef NO_SSL
+ || sslize(conn, conn->ctx->ssl_ctx, SSL_accept)
+#endif
+ ) {
+ process_new_connection(conn);
+ }
+
+ close_connection(conn);
+ }
+ free(conn);
}
- free(conn);
// Signal master that we're done with connection and exiting
(void) pthread_mutex_lock(&ctx->mutex);
@@ -4067,6 +5255,7 @@ static void worker_thread(struct mg_context *ctx) {
(void) pthread_mutex_unlock(&ctx->mutex);
DEBUG_TRACE(("exiting"));
+ return NULL;
}
// Master thread adds accepted socket to a queue
@@ -4090,75 +5279,85 @@ static void produce_socket(struct mg_context *ctx, const struct socket *sp) {
(void) pthread_mutex_unlock(&ctx->mutex);
}
-static void accept_new_connection(const struct socket *listener,
- struct mg_context *ctx) {
- struct socket accepted;
- char src_addr[20];
- socklen_t len;
- int allowed;
-
- len = sizeof(accepted.rsa);
- accepted.lsa = listener->lsa;
- accepted.sock = accept(listener->sock, &accepted.rsa.sa, &len);
- if (accepted.sock != INVALID_SOCKET) {
- allowed = check_acl(ctx, &accepted.rsa);
- if (allowed) {
- // Put accepted socket structure into the queue
- DEBUG_TRACE(("accepted socket %d", accepted.sock));
- accepted.is_ssl = listener->is_ssl;
- produce_socket(ctx, &accepted);
- } else {
- sockaddr_to_string(src_addr, sizeof(src_addr), &accepted.rsa);
- cry(fc(ctx), "%s: %s is not allowed to connect", __func__, src_addr);
- (void) closesocket(accepted.sock);
- }
- }
+static int set_sock_timeout(SOCKET sock, int milliseconds) {
+#ifdef _WIN32
+ DWORD t = milliseconds;
+#else
+ struct timeval t;
+ t.tv_sec = milliseconds / 1000;
+ t.tv_usec = (milliseconds * 1000) % 1000000;
+#endif
+ return setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *) &t, sizeof(t)) ||
+ setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (void *) &t, sizeof(t));
}
-static void master_thread(struct mg_context *ctx) {
- fd_set read_set;
- struct timeval tv;
- struct socket *sp;
- int max_fd;
+static void accept_new_connection(const struct socket *listener,
+ struct mg_context *ctx) {
+ struct socket so;
+ char src_addr[IP_ADDR_STR_LEN];
+ socklen_t len = sizeof(so.rsa);
+ int on = 1;
+
+ if ((so.sock = accept(listener->sock, &so.rsa.sa, &len)) == INVALID_SOCKET) {
+ } else if (!check_acl(ctx, ntohl(* (uint32_t *) &so.rsa.sin.sin_addr))) {
+ sockaddr_to_string(src_addr, sizeof(src_addr), &so.rsa);
+ cry(fc(ctx), "%s: %s is not allowed to connect", __func__, src_addr);
+ closesocket(so.sock);
+ } else {
+ // Put so socket structure into the queue
+ DEBUG_TRACE(("Accepted socket %d", (int) so.sock));
+ set_close_on_exec(so.sock);
+ so.is_ssl = listener->is_ssl;
+ so.ssl_redir = listener->ssl_redir;
+ getsockname(so.sock, &so.lsa.sa, &len);
+ // Set TCP keep-alive. This is needed because if HTTP-level keep-alive
+ // is enabled, and client resets the connection, server won't get
+ // TCP FIN or RST and will keep the connection open forever. With TCP
+ // keep-alive, next keep-alive handshake will figure out that the client
+ // is down and will close the server end.
+ // Thanks to Igor Klopov who suggested the patch.
+ setsockopt(so.sock, SOL_SOCKET, SO_KEEPALIVE, (void *) &on, sizeof(on));
+ set_sock_timeout(so.sock, atoi(ctx->config[REQUEST_TIMEOUT]));
+ produce_socket(ctx, &so);
+ }
+}
+
+static void *master_thread(void *thread_func_param) {
+ struct mg_context *ctx = (struct mg_context *) thread_func_param;
+ struct pollfd *pfd;
+ int i;
// Increase priority of the master thread
#if defined(_WIN32)
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
#endif
-
+
#if defined(ISSUE_317)
struct sched_param sched_param;
sched_param.sched_priority = sched_get_priority_max(SCHED_RR);
pthread_setschedparam(pthread_self(), SCHED_RR, &sched_param);
#endif
- while (ctx->stop_flag == 0) {
- FD_ZERO(&read_set);
- max_fd = -1;
-
- // Add listening sockets to the read set
- for (sp = ctx->listening_sockets; sp != NULL; sp = sp->next) {
- add_to_set(sp->sock, &read_set, &max_fd);
+ pfd = (struct pollfd *) calloc(ctx->num_listening_sockets, sizeof(pfd[0]));
+ while (pfd != NULL && ctx->stop_flag == 0) {
+ for (i = 0; i < ctx->num_listening_sockets; i++) {
+ pfd[i].fd = ctx->listening_sockets[i].sock;
+ pfd[i].events = POLLIN;
}
- tv.tv_sec = 0;
- tv.tv_usec = 200 * 1000;
-
- if (select(max_fd + 1, &read_set, NULL, NULL, &tv) < 0) {
-#ifdef _WIN32
- // On windows, if read_set and write_set are empty,
- // select() returns "Invalid parameter" error
- // (at least on my Windows XP Pro). So in this case, we sleep here.
- mg_sleep(1000);
-#endif // _WIN32
- } else {
- for (sp = ctx->listening_sockets; sp != NULL; sp = sp->next) {
- if (ctx->stop_flag == 0 && FD_ISSET(sp->sock, &read_set)) {
- accept_new_connection(sp, ctx);
+ if (poll(pfd, ctx->num_listening_sockets, 200) > 0) {
+ for (i = 0; i < ctx->num_listening_sockets; i++) {
+ // NOTE(lsm): on QNX, poll() returns POLLRDNORM after the
+ // successfull poll, and POLLIN is defined as (POLLRDNORM | POLLRDBAND)
+ // Therefore, we're checking pfd[i].revents & POLLIN, not
+ // pfd[i].revents == POLLIN.
+ if (ctx->stop_flag == 0 && (pfd[i].revents & POLLIN)) {
+ accept_new_connection(&ctx->listening_sockets[i], ctx);
}
}
}
}
+ free(pfd);
DEBUG_TRACE(("stopping workers"));
// Stop signal received: somebody called mg_stop. Quit.
@@ -4183,11 +5382,13 @@ static void master_thread(struct mg_context *ctx) {
#if !defined(NO_SSL)
uninitialize_ssl(ctx);
#endif
+ DEBUG_TRACE(("exiting"));
- // Signal mg_stop() that we're done
+ // Signal mg_stop() that we're done.
+ // WARNING: This must be the very last thing this
+ // thread does, as ctx becomes invalid after this line.
ctx->stop_flag = 2;
-
- DEBUG_TRACE(("exiting"));
+ return NULL;
}
static void free_context(struct mg_context *ctx) {
@@ -4199,13 +5400,14 @@ static void free_context(struct mg_context *ctx) {
free(ctx->config[i]);
}
+#ifndef NO_SSL
// Deallocate SSL context
if (ctx->ssl_ctx != NULL) {
SSL_CTX_free(ctx->ssl_ctx);
}
-#ifndef NO_SSL
if (ssl_mutexes != NULL) {
free(ssl_mutexes);
+ ssl_mutexes = NULL;
}
#endif // !NO_SSL
@@ -4218,7 +5420,7 @@ void mg_stop(struct mg_context *ctx) {
// Wait until mg_fini() stops
while (ctx->stop_flag != 2) {
- mg_sleep(10);
+ (void) mg_sleep(10);
}
free_context(ctx);
@@ -4227,7 +5429,8 @@ void mg_stop(struct mg_context *ctx) {
#endif // _WIN32
}
-struct mg_context *mg_start(mg_callback_t user_callback, void *user_data,
+struct mg_context *mg_start(const struct mg_callbacks *callbacks,
+ void *user_data,
const char **options) {
struct mg_context *ctx;
const char *name, *value, *default_value;
@@ -4241,8 +5444,10 @@ struct mg_context *mg_start(mg_callback_t user_callback, void *user_data,
// Allocate context and initialize reasonable general case defaults.
// TODO(lsm): do proper error handling here.
- ctx = (struct mg_context *) calloc(1, sizeof(*ctx));
- ctx->user_callback = user_callback;
+ if ((ctx = (struct mg_context *) calloc(1, sizeof(*ctx))) == NULL) {
+ return NULL;
+ }
+ ctx->callbacks = *callbacks;
ctx->user_data = user_data;
while (options && (name = *options++) != NULL) {
@@ -4256,20 +5461,18 @@ struct mg_context *mg_start(mg_callback_t user_callback, void *user_data,
return NULL;
}
if (ctx->config[i] != NULL) {
- cry(fc(ctx), "%s: duplicate option", name);
+ 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 * ENTRIES_PER_CONFIG_OPTION] != NULL; i++) {
- default_value = config_options[i * ENTRIES_PER_CONFIG_OPTION + 2];
+ 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);
- DEBUG_TRACE(("Setting default: [%s] -> [%s]",
- config_options[i * ENTRIES_PER_CONFIG_OPTION + 1],
- default_value));
}
}
@@ -4302,12 +5505,12 @@ struct mg_context *mg_start(mg_callback_t user_callback, void *user_data,
(void) pthread_cond_init(&ctx->sq_full, NULL);
// Start master (listening) thread
- start_thread(ctx, (mg_thread_func_t) master_thread, ctx);
+ mg_start_thread(master_thread, ctx);
// Start worker threads
for (i = 0; i < atoi(ctx->config[NUM_THREADS]); i++) {
- if (start_thread(ctx, (mg_thread_func_t) worker_thread, ctx) != 0) {
- cry(fc(ctx), "Cannot start worker thread: %d", ERRNO);
+ if (mg_start_thread(worker_thread, ctx) != 0) {
+ cry(fc(ctx), "Cannot start worker thread: %ld", (long) ERRNO);
} else {
ctx->num_threads++;
}
diff --git a/cpukit/mghttpd/mongoose.h b/cpukit/mghttpd/mongoose.h
index c130fe7..ad7c40f 100644
--- a/cpukit/mghttpd/mongoose.h
+++ b/cpukit/mghttpd/mongoose.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2004-2011 Sergey Lyubka
+// Copyright (c) 2004-2012 Sergey Lyubka
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
@@ -21,6 +21,7 @@
#ifndef MONGOOSE_HEADER_INCLUDED
#define MONGOOSE_HEADER_INCLUDED
+#include <stdio.h>
#include <stddef.h>
#ifdef __cplusplus
@@ -33,59 +34,102 @@ struct mg_connection; // Handle for the individual connection
// This structure contains information about the HTTP request.
struct mg_request_info {
- void *user_data; // User-defined pointer passed to mg_start()
- char *request_method; // "GET", "POST", etc
- char *uri; // URL-decoded URI
- char *http_version; // E.g. "1.0", "1.1"
- char *query_string; // URL part after '?' (not including '?') or NULL
- char *remote_user; // Authenticated user, or NULL if no auth used
- char *log_message; // Mongoose error log message, MG_EVENT_LOG only
- long remote_ip; // Client's IP address
- int remote_port; // Client's port
- int status_code; // HTTP reply status code, e.g. 200
- int is_ssl; // 1 if SSL-ed, 0 if not
- int num_headers; // Number of headers
+ const char *request_method; // "GET", "POST", etc
+ const char *uri; // URL-decoded URI
+ const char *http_version; // E.g. "1.0", "1.1"
+ const char *query_string; // URL part after '?', not including '?', or NULL
+ const char *remote_user; // Authenticated user, or NULL if no auth used
+ long remote_ip; // Client's IP address
+ int remote_port; // Client's port
+ int is_ssl; // 1 if SSL-ed, 0 if not
+ void *user_data; // User data pointer passed to mg_start()
+ void *conn_data; // Connection-specific user data
+
+ int num_headers; // Number of HTTP headers
struct mg_header {
- char *name; // HTTP header name
- char *value; // HTTP header value
- } http_headers[64]; // Maximum 64 headers
+ const char *name; // HTTP header name
+ const char *value; // HTTP header value
+ } http_headers[64]; // Maximum 64 headers
};
-// Various events on which user-defined function is called by Mongoose.
-enum mg_event {
- MG_NEW_REQUEST, // New HTTP request has arrived from the client
- MG_HTTP_ERROR, // HTTP error must be returned to the client
- MG_EVENT_LOG, // Mongoose logs an event, request_info.log_message
- MG_INIT_SSL, // Mongoose initializes SSL. Instead of mg_connection *,
- // SSL context is passed to the callback function.
- MG_REQUEST_COMPLETE // Mongoose has finished handling the request
-};
-
-// Prototype for the user-defined function. Mongoose calls this function
-// on every MG_* event.
-//
-// Parameters:
-// event: which event has been triggered.
-// conn: opaque connection handler. Could be used to read, write data to the
-// client, etc. See functions below that have "mg_connection *" arg.
-// request_info: Information about HTTP request.
-//
-// Return:
-// If handler returns non-NULL, that means that handler has processed the
-// request by sending appropriate HTTP reply to the client. Mongoose treats
-// the request as served.
-// If handler returns NULL, that means that handler has not processed
-// the request. Handler must not send any data to the client in this case.
-// Mongoose proceeds with request handling as if nothing happened.
-typedef void * (*mg_callback_t)(enum mg_event event,
- struct mg_connection *conn,
- const struct mg_request_info *request_info);
+// This structure needs to be passed to mg_start(), to let mongoose know
+// which callbacks to invoke. For detailed description, see
+// https://github.com/valenok/mongoose/blob/master/UserManual.md
+struct mg_callbacks {
+ // Called when mongoose has received new HTTP request.
+ // If callback returns non-zero,
+ // callback must process the request by sending valid HTTP headers and body,
+ // and mongoose will not do any further processing.
+ // If callback returns 0, mongoose processes the request itself. In this case,
+ // callback must not send any data to the client.
+ int (*begin_request)(struct mg_connection *);
+
+ // Called when mongoose has finished processing request.
+ void (*end_request)(const struct mg_connection *, int reply_status_code);
+
+ // Called when mongoose is about to log a message. If callback returns
+ // non-zero, mongoose does not log anything.
+ int (*log_message)(const struct mg_connection *, const char *message);
+
+ // Called when mongoose initializes SSL library.
+ int (*init_ssl)(void *ssl_context, void *user_data);
+
+ // Called when websocket request is received, before websocket handshake.
+ // If callback returns 0, mongoose proceeds with handshake, otherwise
+ // cinnection is closed immediately.
+ int (*websocket_connect)(const struct mg_connection *);
+
+ // Called when websocket handshake is successfully completed, and
+ // connection is ready for data exchange.
+ void (*websocket_ready)(struct mg_connection *);
+
+ // Called when data frame has been received from the client.
+ // Parameters:
+ // bits: first byte of the websocket frame, see websocket RFC at
+ // http://tools.ietf.org/html/rfc6455, section 5.2
+ // data, data_len: payload, with mask (if any) already applied.
+ // Return value:
+ // non-0: keep this websocket connection opened.
+ // 0: close this websocket connection.
+ int (*websocket_data)(struct mg_connection *, int bits,
+ char *data, size_t data_len);
+
+ // Called when mongoose tries to open a file. Used to intercept file open
+ // calls, and serve file data from memory instead.
+ // Parameters:
+ // path: Full path to the file to open.
+ // data_len: Placeholder for the file size, if file is served from memory.
+ // Return value:
+ // NULL: do not serve file from memory, proceed with normal file open.
+ // non-NULL: pointer to the file contents in memory. data_len must be
+ // initilized with the size of the memory block.
+ const char * (*open_file)(const struct mg_connection *,
+ const char *path, size_t *data_len);
+
+ // Called when mongoose is about to serve Lua server page (.lp file), if
+ // Lua support is enabled.
+ // Parameters:
+ // lua_context: "lua_State *" pointer.
+ void (*init_lua)(struct mg_connection *, void *lua_context);
+
+ // Called when mongoose has uploaded a file to a temporary directory as a
+ // result of mg_upload() call.
+ // Parameters:
+ // file_file: full path name to the uploaded file.
+ void (*upload)(struct mg_connection *, const char *file_name);
+
+ // Called when mongoose is about to send HTTP error to the client.
+ // Implementing this callback allows to create custom error pages.
+ // Parameters:
+ // status: HTTP error status code.
+ int (*http_error)(struct mg_connection *, int status);
+};
// Start web server.
//
// Parameters:
-// callback: user defined event handling function or NULL.
+// callbacks: mg_callbacks structure with user-defined callbacks.
// options: NULL terminated list of option_name, option_value pairs that
// specify Mongoose configuration parameters.
//
@@ -102,13 +146,14 @@ typedef void * (*mg_callback_t)(enum mg_event event,
// };
// struct mg_context *ctx = mg_start(&my_func, NULL, options);
//
-// Please refer to http://code.google.com/p/mongoose/wiki/MongooseManual
+// Refer to https://github.com/valenok/mongoose/blob/master/UserManual.md
// for the list of valid option and their possible values.
//
// Return:
// web server context, or NULL on error.
-struct mg_context *mg_start(mg_callback_t callback, void *user_data,
- const char **options);
+struct mg_context *mg_start(const struct mg_callbacks *callbacks,
+ void *user_data,
+ const char **configuration_options);
// Stop the web server.
@@ -129,7 +174,8 @@ const char *mg_get_option(const struct mg_context *ctx, const char *name);
// Return array of strings that represent valid configuration options.
-// For each option, a short name, long name, and default value is returned.
+// For each option, option name and default value is returned, i.e. the
+// number of entries in the array equals to number_of_options x 2.
// Array is NULL terminated.
const char **mg_get_valid_option_names(void);
@@ -151,21 +197,65 @@ int mg_modify_passwords_file(const char *passwords_file_name,
const char *user,
const char *password);
+
+// Return information associated with the request.
+struct mg_request_info *mg_get_request_info(struct mg_connection *);
+
+
// Send data to the client.
+// Return:
+// 0 when the connection has been closed
+// -1 on error
+// >0 number of bytes written on success
int mg_write(struct mg_connection *, const void *buf, size_t len);
-// Send data to the browser using printf() semantics.
+// Send data to a websocket client wrapped in a websocket frame.
+// It is unsafe to read/write to this connection from another thread.
+// This function is available when mongoose is compiled with -DUSE_WEBSOCKET
//
-// Works exactly like mg_write(), but allows to do message formatting. Note
-// that mg_printf() uses internal buffer of size BUFSIZ defined in <stdio.h>
-// (8 KiB on most Linux systems) as temporary message storage for formatting.
-// Do not print data that is bigger than that, otherwise it will be truncated.
-int mg_printf(struct mg_connection *, const char *fmt, ...)
+// Return:
+// 0 when the connection has been closed
+// -1 on error
+// >0 number of bytes written on success
+int mg_websocket_write(struct mg_connection* conn, int opcode,
+ const char *data, size_t data_len);
+
+// Opcodes, from http://tools.ietf.org/html/rfc6455
+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
+};
+
+
+// Macros for enabling compiler-specific checks for printf-like arguments.
+#undef PRINTF_FORMAT_STRING
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+#include <sal.h>
+#if defined(_MSC_VER) && _MSC_VER > 1400
+#define PRINTF_FORMAT_STRING(s) _Printf_format_string_ s
+#else
+#define PRINTF_FORMAT_STRING(s) __format_string s
+#endif
+#else
+#define PRINTF_FORMAT_STRING(s) s
+#endif
+
#ifdef __GNUC__
-__attribute__((format(printf, 2, 3)))
+#define PRINTF_ARGS(x, y) __attribute__((format(printf, x, y)))
+#else
+#define PRINTF_ARGS(x, y)
#endif
-;
+
+// Send data to the client using printf() semantics.
+//
+// Works exactly like mg_write(), but allows to do message formatting.
+int mg_printf(struct mg_connection *,
+ PRINTF_FORMAT_STRING(const char *fmt), ...) PRINTF_ARGS(2, 3);
// Send contents of the entire file together with HTTP headers.
@@ -173,6 +263,10 @@ void mg_send_file(struct mg_connection *conn, const char *path);
// Read data from the remote end, return number of bytes read.
+// Return:
+// 0 connection has been closed by peer. No more data could be read.
+// < 0 read error. No more data could be read from the connection.
+// > 0 number of bytes read into the buffer.
int mg_read(struct mg_connection *, void *buf, size_t len);
@@ -191,17 +285,20 @@ const char *mg_get_header(const struct mg_connection *, const char *name);
// or request_info.query_string.
// data_len: length of the encoded data.
// var_name: variable name to decode from the buffer
-// buf: destination buffer for the decoded variable
-// buf_len: length of the destination buffer
+// dst: destination buffer for the decoded variable
+// dst_len: length of the destination buffer
//
// Return:
// On success, length of the decoded variable.
-// On error, -1 (variable not found, or destination buffer is too small).
+// On error:
+// -1 (variable not found).
+// -2 (destination buffer is NULL, zero length or too small to hold the
+// decoded variable).
//
-// Destination buffer is guaranteed to be '\0' - terminated. In case of
-// failure, dst[0] == '\0'.
+// Destination buffer is guaranteed to be '\0' - terminated if it is not
+// NULL or zero length.
int mg_get_var(const char *data, size_t data_len,
- const char *var_name, char *buf, size_t buf_len);
+ const char *var_name, char *dst, size_t dst_len);
// Fetch value of certain cookie variable into the destination buffer.
//
@@ -211,24 +308,75 @@ int mg_get_var(const char *data, size_t data_len,
//
// Return:
// On success, value length.
-// On error, 0 (either "Cookie:" header is not present at all, or the
-// requested parameter is not found, or destination buffer is too small
-// to hold the value).
-int mg_get_cookie(const struct mg_connection *,
- const char *cookie_name, char *buf, size_t buf_len);
+// On error:
+// -1 (either "Cookie:" header is not present at all or the requested
+// parameter is not found).
+// -2 (destination buffer is NULL, zero length or too small to hold the
+// value).
+int mg_get_cookie(const char *cookie, const char *var_name,
+ char *buf, size_t buf_len);
+
+
+// Download data from the remote web server.
+// host: host name to connect to, e.g. "foo.com", or "10.12.40.1".
+// port: port number, e.g. 80.
+// use_ssl: wether to use SSL connection.
+// error_buffer, error_buffer_size: error message placeholder.
+// request_fmt,...: HTTP request.
+// Return:
+// On success, valid pointer to the new connection, suitable for mg_read().
+// On error, NULL. error_buffer contains error message.
+// Example:
+// char ebuf[100];
+// struct mg_connection *conn;
+// conn = mg_download("google.com", 80, 0, ebuf, sizeof(ebuf),
+// "%s", "GET / HTTP/1.0\r\nHost: google.com\r\n\r\n");
+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, 7);
+
+
+// Close the connection opened by mg_download().
+void mg_close_connection(struct mg_connection *conn);
+
+
+// File upload functionality. Each uploaded file gets saved into a temporary
+// file and MG_UPLOAD event is sent.
+// Return number of uploaded files.
+int mg_upload(struct mg_connection *conn, const char *destination_dir);
+
+
+// Convenience function -- create detached thread.
+// Return: 0 on success, non-0 on error.
+typedef void * (*mg_thread_func_t)(void *);
+int mg_start_thread(mg_thread_func_t f, void *p);
+
+
+// Return builtin mime type for the given file name.
+// For unrecognized extensions, "text/plain" is returned.
+const char *mg_get_builtin_mime_type(const char *file_name);
// Return Mongoose version.
const char *mg_version(void);
+// URL-decode input buffer into destination buffer.
+// 0-terminate the destination buffer.
+// form-url-encoded data differs from URI encoding in a way that it
+// uses '+' as character for space, see RFC 1866 section 8.2.1
+// http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt
+// Return: length of the decoded data, or -1 if dst buffer is too small.
+int mg_url_decode(const char *src, int src_len, char *dst,
+ int dst_len, int is_form_url_encoded);
// MD5 hash given strings.
// Buffer 'buf' must be 33 bytes long. Varargs is a NULL terminated list of
-// asciiz strings. When function returns, buf will contain human-readable
+// ASCIIz strings. When function returns, buf will contain human-readable
// MD5 hash. Example:
// char buf[33];
// mg_md5(buf, "aa", "bb", NULL);
-void mg_md5(char *buf, ...);
+char *mg_md5(char buf[33], ...);
#ifdef __cplusplus
--
1.8.4.2
____
Anyone keen to commit it? Perhaps killing the man page isn't the way to
go?
My personal motivation is that I want to use (or at least, investigate)
WebSockets, which aren't supported by Mongoose 3.2.
--
Nick Withers
Embedded Systems Programmer
Room 2.26, Building 57
Department of Nuclear Physics
Research School of Physics and Engineering
The Australian National University (CRICOS: 00120C)
eMail: nick.withers at anu.edu.au
Phone: +61 2 6125 2091
Mobile: +61 414 397 446
More information about the devel
mailing list