To see a page from the CookieHandler handler click cookie
"); + mg_printf(conn, + "To see a page from the PostResponser handler click post response
"); + mg_printf(conn, + "To see an example for parsing files on the fly click form (form for " + "uploading files)
"); #ifdef USE_WEBSOCKET mg_printf(conn, - "To test websocket handler click "
+ " To test the websocket handler click "
"websocket To test the authentication handler click "
+ "auth To exit click exit The actual uri is %s The actual uri is %s The request was:This is the A handler!!!
");
mg_printf(conn, "\n");
@@ -111,7 +129,9 @@ AHandler(struct mg_connection *conn, void *cbdata)
int
ABHandler(struct mg_connection *conn, void *cbdata)
{
- mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
+ mg_printf(conn,
+ "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: "
+ "close\r\n\r\n");
mg_printf(conn, "");
mg_printf(conn, "This is the AB handler!!!
");
mg_printf(conn, "\n");
@@ -125,10 +145,12 @@ BXHandler(struct mg_connection *conn, void *cbdata)
/* Handler may access the request info using mg_get_request_info */
const struct mg_request_info *req_info = mg_get_request_info(conn);
- mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
+ mg_printf(conn,
+ "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: "
+ "close\r\n\r\n");
mg_printf(conn, "");
mg_printf(conn, "This is the BX handler %p!!!
", cbdata);
- mg_printf(conn, "This is the Foo handler!!!
");
mg_printf(conn,
"%s %s HTTP/%s
The actual uri is %s
", req_info->uri); + mg_printf(conn, "The actual uri is %s
", req_info->local_uri); if (first_str[0] == 0) { mg_printf(conn, "This is the first time, you opened this page
"); @@ -313,10 +467,138 @@ CookieHandler(struct mg_connection *conn, void *cbdata) } +int +PostResponser(struct mg_connection *conn, void *cbdata) +{ + long long r_total = 0; + int r, s; + + char buf[2048]; + + const struct mg_request_info *ri = mg_get_request_info(conn); + + if (strcmp(ri->request_method, "POST")) { + char buf[1024]; + int ret = mg_get_request_link(conn, buf, sizeof(buf)); + + mg_printf(conn, + "HTTP/1.1 405 Method Not Allowed\r\nConnection: close\r\n"); + mg_printf(conn, "Content-Type: text/plain\r\n\r\n"); + mg_printf(conn, + "%s method not allowed in the POST handler\n", + ri->request_method); + if (ret >= 0) { + mg_printf(conn, + "use a web tool to send a POST request to %s\n", + buf); + } + return 1; + } + + if (ri->content_length >= 0) { + /* We know the content length in advance */ + } else { + /* We must read until we find the end (chunked encoding + * or connection close), indicated my mg_read returning 0 */ + } + + mg_printf(conn, + "HTTP/1.1 200 OK\r\nConnection: " + "close\r\nTransfer-Encoding: chunked\r\n"); + mg_printf(conn, "Content-Type: text/plain\r\n\r\n"); + + r = mg_read(conn, buf, sizeof(buf)); + while (r > 0) { + r_total += r; + s = mg_send_chunk(conn, buf, r); + if (r != s) { + /* Send error */ + break; + } + r = mg_read(conn, buf, sizeof(buf)); + } + mg_printf(conn, "0\r\n"); + + return 1; +} + + +int +AuthStartHandler(struct mg_connection *conn, void *cbdata) +{ + static unsigned long long firstload = 0; + const char *passfile = "password_example_file.txt"; + const char *realm = "password_example"; + const char *user = "user"; + char passwd[64]; + + if (firstload == 0) { + + /* Set a random password (4 digit number - bad idea from a security + * point of view, but this is an API demo, not a security tutorial), + * and store it in some directory within the document root (extremely + * bad idea, but this is still not a security tutorial). + * The reason we create a new password every time the server starts + * is just for demonstration - we don't want the browser to store the + * password, so when we repeat the test we start with a new password. + */ + firstload = (unsigned long long)time(NULL); + sprintf(passwd, "%04u", (unsigned int)(firstload % 10000)); + mg_modify_passwords_file(passfile, realm, user, passwd); + + /* Just tell the user the new password generated for this test. */ + mg_printf(conn, + "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: " + "close\r\n\r\n"); + + mg_printf(conn, "\n"); + mg_printf(conn, "\n\n"); + mg_printf(conn, "\n"); + mg_printf(conn, "The first time you visit this page, it's free!
\n"); + mg_printf(conn, + "Next time, use username \"%s\" and password \"%s\"
\n", + user, + passwd); + mg_printf(conn, "\n\n"); + + return 1; + } + + if (mg_check_digest_access_authentication(conn, realm, passfile) <= 0) { + /* No valid authorization */ + mg_send_digest_access_authentication_request(conn, realm); + return 1; + } + + mg_printf(conn, + "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: " + "close\r\n\r\n"); + + mg_printf(conn, "\n"); + mg_printf(conn, "\n\n"); + mg_printf(conn, "\n"); + mg_printf(conn, "This is the password protected contents
\n"); + mg_printf(conn, "\n\n"); + + return 1; +} + + int WebSocketStartHandler(struct mg_connection *conn, void *cbdata) { - mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); + mg_printf(conn, + "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: " + "close\r\n\r\n"); mg_printf(conn, "\n"); mg_printf(conn, "\n\n"); @@ -437,7 +719,31 @@ WebsocketDataHandler(struct mg_connection *conn, ASSERT(client->conn == conn); ASSERT(client->state >= 1); - fprintf(stdout, "Websocket got data:\r\n"); + fprintf(stdout, "Websocket got %lu bytes of ", (unsigned long)len); + switch (((unsigned char)bits) & 0x0F) { + case WEBSOCKET_OPCODE_CONTINUATION: + fprintf(stdout, "continuation"); + break; + case WEBSOCKET_OPCODE_TEXT: + fprintf(stdout, "text"); + break; + case WEBSOCKET_OPCODE_BINARY: + fprintf(stdout, "binary"); + break; + case WEBSOCKET_OPCODE_CONNECTION_CLOSE: + fprintf(stdout, "close"); + break; + case WEBSOCKET_OPCODE_PING: + fprintf(stdout, "ping"); + break; + case WEBSOCKET_OPCODE_PONG: + fprintf(stdout, "pong"); + break; + default: + fprintf(stdout, "unknown(%1xh)", ((unsigned char)bits) & 0x0F); + break; + } + fprintf(stdout, " data:\r\n"); fwrite(data, len, 1, stdout); fprintf(stdout, "\r\n\r\n"); @@ -486,26 +792,129 @@ InformWebsockets(struct mg_context *ctx) #endif +#ifdef USE_SSL_DH +#include "openssl/ssl.h" +#include "openssl/dh.h" +#include "openssl/ec.h" +#include "openssl/evp.h" +#include "openssl/ecdsa.h" + +DH * +get_dh2236() +{ + static unsigned char dh2236_p[] = { + 0x0E, 0x97, 0x6E, 0x6A, 0x88, 0x84, 0xD2, 0xD7, 0x55, 0x6A, 0x17, 0xB7, + 0x81, 0x9A, 0x98, 0xBC, 0x7E, 0xD1, 0x6A, 0x44, 0xB1, 0x18, 0xE6, 0x25, + 0x3A, 0x62, 0x35, 0xF0, 0x41, 0x91, 0xE2, 0x16, 0x43, 0x9D, 0x8F, 0x7D, + 0x5D, 0xDA, 0x85, 0x47, 0x25, 0xC4, 0xBA, 0x68, 0x0A, 0x87, 0xDC, 0x2C, + 0x33, 0xF9, 0x75, 0x65, 0x17, 0xCB, 0x8B, 0x80, 0xFE, 0xE0, 0xA8, 0xAF, + 0xC7, 0x9E, 0x82, 0xBE, 0x6F, 0x1F, 0x00, 0x04, 0xBD, 0x69, 0x50, 0x8D, + 0x9C, 0x3C, 0x41, 0x69, 0x21, 0x4E, 0x86, 0xC8, 0x2B, 0xCC, 0x07, 0x4D, + 0xCF, 0xE4, 0xA2, 0x90, 0x8F, 0x66, 0xA9, 0xEF, 0xF7, 0xFC, 0x6F, 0x5F, + 0x06, 0x22, 0x00, 0xCB, 0xCB, 0xC3, 0x98, 0x3F, 0x06, 0xB9, 0xEC, 0x48, + 0x3B, 0x70, 0x6E, 0x94, 0xE9, 0x16, 0xE1, 0xB7, 0x63, 0x2E, 0xAB, 0xB2, + 0xF3, 0x84, 0xB5, 0x3D, 0xD7, 0x74, 0xF1, 0x6A, 0xD1, 0xEF, 0xE8, 0x04, + 0x18, 0x76, 0xD2, 0xD6, 0xB0, 0xB7, 0x71, 0xB6, 0x12, 0x8F, 0xD1, 0x33, + 0xAB, 0x49, 0xAB, 0x09, 0x97, 0x35, 0x9D, 0x4B, 0xBB, 0x54, 0x22, 0x6E, + 0x1A, 0x33, 0x18, 0x02, 0x8A, 0xF4, 0x7C, 0x0A, 0xCE, 0x89, 0x75, 0x2D, + 0x10, 0x68, 0x25, 0xA9, 0x6E, 0xCD, 0x97, 0x49, 0xED, 0xAE, 0xE6, 0xA7, + 0xB0, 0x07, 0x26, 0x25, 0x60, 0x15, 0x2B, 0x65, 0x88, 0x17, 0xF2, 0x5D, + 0x2C, 0xF6, 0x2A, 0x7A, 0x8C, 0xAD, 0xB6, 0x0A, 0xA2, 0x57, 0xB0, 0xC1, + 0x0E, 0x5C, 0xA8, 0xA1, 0x96, 0x58, 0x9A, 0x2B, 0xD4, 0xC0, 0x8A, 0xCF, + 0x91, 0x25, 0x94, 0xB4, 0x14, 0xA7, 0xE4, 0xE2, 0x1B, 0x64, 0x5F, 0xD2, + 0xCA, 0x70, 0x46, 0xD0, 0x2C, 0x95, 0x6B, 0x9A, 0xFB, 0x83, 0xF9, 0x76, + 0xE6, 0xD4, 0xA4, 0xA1, 0x2B, 0x2F, 0xF5, 0x1D, 0xE4, 0x06, 0xAF, 0x7D, + 0x22, 0xF3, 0x04, 0x30, 0x2E, 0x4C, 0x64, 0x12, 0x5B, 0xB0, 0x55, 0x3E, + 0xC0, 0x5E, 0x56, 0xCB, 0x99, 0xBC, 0xA8, 0xD9, 0x23, 0xF5, 0x57, 0x40, + 0xF0, 0x52, 0x85, 0x9B, + }; + static unsigned char dh2236_g[] = { + 0x02, + }; + DH *dh; + + if ((dh = DH_new()) == NULL) + return (NULL); + dh->p = BN_bin2bn(dh2236_p, sizeof(dh2236_p), NULL); + dh->g = BN_bin2bn(dh2236_g, sizeof(dh2236_g), NULL); + if ((dh->p == NULL) || (dh->g == NULL)) { + DH_free(dh); + return (NULL); + } + return (dh); +} +#endif + + +#ifndef NO_SSL +int +init_ssl(void *ssl_context, void *user_data) +{ + /* Add application specific SSL initialization */ + struct ssl_ctx_st *ctx = (struct ssl_ctx_st *)ssl_context; + +#ifdef USE_SSL_DH + /* example from https://github.com/civetweb/civetweb/issues/347 */ + DH *dh = get_dh2236(); + if (!dh) + return -1; + if (1 != SSL_CTX_set_tmp_dh(ctx, dh)) + return -1; + DH_free(dh); + + EC_KEY *ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1); + if (!ecdh) + return -1; + if (1 != SSL_CTX_set_tmp_ecdh(ctx, ecdh)) + return -1; + EC_KEY_free(ecdh); + + printf("ECDH ciphers initialized\n"); +#endif + return 0; +} +#endif + + +int +log_message(const struct mg_connection *conn, const char *message) +{ + puts(message); + return 1; +} + + int main(int argc, char *argv[]) { - const char *options[] = {"document_root", - DOCUMENT_ROOT, - "listening_ports", - PORT, - "request_timeout_ms", - "10000", - "error_log_file", - "error.log", + const char *options[] = { + "document_root", + DOCUMENT_ROOT, + "listening_ports", + PORT, + "request_timeout_ms", + "10000", + "error_log_file", + "error.log", #ifdef USE_WEBSOCKET - "websocket_timeout_ms", - "3600000", + "websocket_timeout_ms", + "3600000", #endif #ifndef NO_SSL - "ssl_certificate", - "../../resources/cert/server.pem", + "ssl_certificate", + "../../resources/cert/server.pem", + "ssl_protocol_version", + "3", + "ssl_cipher_list", +#ifdef USE_SSL_DH + "ECDHE-RSA-AES256-GCM-SHA384:DES-CBC3-SHA:AES128-SHA:AES128-GCM-SHA256", +#else + "DES-CBC3-SHA:AES128-SHA:AES128-GCM-SHA256", #endif - 0}; +#endif + "enable_auth_domain_check", + "no", + 0}; struct mg_callbacks callbacks; struct mg_context *ctx; struct mg_server_ports ports[32]; @@ -544,8 +953,18 @@ main(int argc, char *argv[]) /* Start CivetWeb web server */ memset(&callbacks, 0, sizeof(callbacks)); +#ifndef NO_SSL + callbacks.init_ssl = init_ssl; +#endif + callbacks.log_message = log_message; ctx = mg_start(&callbacks, 0, options); + /* Check return value: */ + if (ctx == NULL) { + fprintf(stderr, "Cannot start CivetWeb - mg_start failed.\n"); + return EXIT_FAILURE; + } + /* Add handler EXAMPLE_URI, to explain the example */ mg_set_request_handler(ctx, EXAMPLE_URI, ExampleHandler, 0); mg_set_request_handler(ctx, EXIT_URI, ExitHandler, 0); @@ -577,12 +996,29 @@ main(int argc, char *argv[]) FormHandler, (void *)0); + /* Add a file upload handler for parsing files on the fly */ + mg_set_request_handler(ctx, + "/on_the_fly_form", + FileUploadForm, + (void *)"/on_the_fly_form.md5.callback"); + mg_set_request_handler(ctx, + "/on_the_fly_form.md5.callback", + CheckSumHandler, + (void *)0); + /* Add handler for /cookie example */ mg_set_request_handler(ctx, "/cookie", CookieHandler, 0); + /* Add handler for /postresponse example */ + mg_set_request_handler(ctx, "/postresponse", PostResponser, 0); + /* Add HTTP site to open a websocket connection */ mg_set_request_handler(ctx, "/websocket", WebSocketStartHandler, 0); + /* Add HTTP site with auth */ + mg_set_request_handler(ctx, "/auth", AuthStartHandler, 0); + + #ifdef USE_WEBSOCKET /* WS site for the websocket connection */ mg_set_websocket_handler(ctx, diff --git a/ceph/src/civetweb/examples/embedded_cpp/embedded_cpp.cpp b/ceph/src/civetweb/examples/embedded_cpp/embedded_cpp.cpp index 979004262..d45a573cf 100644 --- a/ceph/src/civetweb/examples/embedded_cpp/embedded_cpp.cpp +++ b/ceph/src/civetweb/examples/embedded_cpp/embedded_cpp.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2014 the Civetweb developers +/* Copyright (c) 2013-2017 the Civetweb developers * Copyright (c) 2013 No Face Press, LLC * License http://opensource.org/licenses/mit-license.php MIT License */ @@ -6,9 +6,10 @@ // Simple example program on how to use Embedded C++ interface. #include "CivetServer.h" +#includeTo see a page from the *.foo handler click here
\r\n"); + mg_printf(conn, + "To see a page from the WebSocket handler click here
\r\n"); mg_printf(conn, "To exit click here
\r\n", EXIT_URI); @@ -136,7 +140,7 @@ class FooHandler : public CivetHandler mg_printf(conn, "The request was:
%s %s HTTP/%s\n", req_info->request_method, - req_info->uri, + req_info->request_uri, req_info->http_version); mg_printf(conn, "\n"); @@ -161,7 +165,7 @@ class FooHandler : public CivetHandler mg_printf(conn, "
The request was:
%s %s HTTP/%s\n", req_info->request_method, - req_info->uri, + req_info->request_uri, req_info->http_version); mg_printf(conn, "
Content Length: %li
\n", (long)tlen); mg_printf(conn, "\n");
@@ -176,7 +180,7 @@ class FooHandler : public CivetHandler
break;
}
wlen = mg_write(conn, buf, (size_t)rlen);
- if (rlen != rlen) {
+ if (wlen != rlen) {
break;
}
nlen += wlen;
@@ -202,9 +206,32 @@ class FooHandler : public CivetHandler
char buf[1024];
int fail = 0;
+#ifdef _WIN32
_snprintf(buf, sizeof(buf), "D:\\somewhere\\%s\\%s", req_info->remote_user, req_info->local_uri);
- buf[sizeof(buf)-1] = 0; /* TODO: check overflow */
- f = fopen_recursive(buf, "wb");
+ buf[sizeof(buf)-1] = 0;
+ if (strlen(buf)>255) {
+ /* Windows will not work with path > 260 (MAX_PATH), unless we use
+ * the unicode API. However, this is just an example code: A real
+ * code will probably never store anything to D:\\somewhere and
+ * must be adapted to the specific needs anyhow. */
+ fail = 1;
+ f = NULL;
+ } else {
+ f = fopen_recursive(buf, "wb");
+ }
+#else
+ snprintf(buf, sizeof(buf), "~/somewhere/%s/%s", req_info->remote_user, req_info->local_uri);
+ buf[sizeof(buf)-1] = 0;
+ if (strlen(buf)>1020) {
+ /* The string is too long and probably truncated. Make sure an
+ * UTF-8 string is never truncated between the UTF-8 code bytes.
+ * This example code must be adapted to the specific needs. */
+ fail = 1;
+ f = NULL;
+ } else {
+ f = fopen_recursive(buf, "w");
+ }
+#endif
if (!f) {
fail = 1;
@@ -220,7 +247,7 @@ class FooHandler : public CivetHandler
break;
}
wlen = fwrite(buf, 1, (size_t)rlen, f);
- if (rlen != rlen) {
+ if (wlen != rlen) {
fail = 1;
break;
}
@@ -234,19 +261,110 @@ class FooHandler : public CivetHandler
"HTTP/1.1 409 Conflict\r\n"
"Content-Type: text/plain\r\n"
"Connection: close\r\n\r\n");
- MessageBeep(MB_ICONERROR);
} else {
mg_printf(conn,
"HTTP/1.1 201 Created\r\n"
"Content-Type: text/plain\r\n"
"Connection: close\r\n\r\n");
- MessageBeep(MB_OK);
}
return true;
}
};
+class WsStartHandler : public CivetHandler
+{
+ public:
+ bool
+ handleGet(CivetServer *server, struct mg_connection *conn)
+ {
+
+ mg_printf(conn,
+ "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: "
+ "close\r\n\r\n");
+
+ mg_printf(conn, "\n");
+ mg_printf(conn, "\n\n");
+ mg_printf(conn, "\n");
+ mg_printf(conn, "Embedded websocket example \n");
+
+#ifdef USE_WEBSOCKET
+ /* mg_printf(conn, "\n"); ... xhtml style */
+ mg_printf(conn, "\n");
+ mg_printf(conn, "\n\n");
+ mg_printf(
+ conn,
+ "No websocket connection yet\n");
+#else
+ mg_printf(conn, "\n\n");
+ mg_printf(conn, "Example not compiled with USE_WEBSOCKET\n");
+#endif
+ mg_printf(conn, "\n\n");
+
+ return 1;
+}
+};
+
+
+#ifdef USE_WEBSOCKET
+class WebSocketHandler : public CivetWebSocketHandler {
+
+ virtual bool handleConnection(CivetServer *server,
+ const struct mg_connection *conn) {
+ printf("WS connected\n");
+ return true;
+ }
+
+ virtual void handleReadyState(CivetServer *server,
+ struct mg_connection *conn) {
+ printf("WS ready\n");
+
+ const char *text = "Hello from the websocket ready handler";
+ mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, text, strlen(text));
+ }
+
+ virtual bool handleData(CivetServer *server,
+ struct mg_connection *conn,
+ int bits,
+ char *data,
+ size_t data_len) {
+ printf("WS got %lu bytes: ", (long unsigned)data_len);
+ fwrite(data, 1, data_len, stdout);
+ printf("\n");
+
+ mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, data, data_len);
+ return (data_len<4);
+ }
+
+ virtual void handleClose(CivetServer *server,
+ const struct mg_connection *conn) {
+ printf("WS closed\n");
+ }
+};
+#endif
+
int
main(int argc, char *argv[])
@@ -260,7 +378,7 @@ main(int argc, char *argv[])
}
// CivetServer server(options); // <-- C style start
- CivetServer server(cpp_options); // <-- C++ style start
+ CivetServer server(cpp_options); // <-- C++ style start
ExampleHandler h_ex;
server.addHandler(EXAMPLE_URI, h_ex);
@@ -274,10 +392,29 @@ main(int argc, char *argv[])
ABHandler h_ab;
server.addHandler("/a/b", h_ab);
+ WsStartHandler h_ws;
+ server.addHandler("/ws", h_ws);
+
+#ifdef NO_FILES
+ /* This handler will handle "everything else", including
+ * requests to files. If this handler is installed,
+ * NO_FILES should be set. */
FooHandler h_foo;
server.addHandler("", h_foo);
+ printf("See a page from the \"all\" handler at http://localhost:%s/\n", PORT);
+#else
+ FooHandler h_foo;
+ server.addHandler("**.foo", h_foo);
printf("Browse files at http://localhost:%s/\n", PORT);
+#endif
+
+#ifdef USE_WEBSOCKET
+ WebSocketHandler h_websocket;
+ server.addWebSocketHandler("/websocket", h_websocket);
+ printf("Run websocket example at http://localhost:%s/ws\n", PORT);
+#endif
+
printf("Run example at http://localhost:%s%s\n", PORT, EXAMPLE_URI);
printf("Exit at http://localhost:%s%s\n", PORT, EXIT_URI);
diff --git a/ceph/src/civetweb/examples/https/README.md b/ceph/src/civetweb/examples/https/README.md
new file mode 100644
index 000000000..7b18b4724
--- /dev/null
+++ b/ceph/src/civetweb/examples/https/README.md
@@ -0,0 +1,15 @@
+HTTPS Server configuration example
+====
+
+This directory contains an example [`civetweb.conf`](civetweb.conf) configuration file for a secure HTTPS server. You can run a HTTPS server without most of the options there - only `ssl_certificate` and one port (e.g., `443s`) in `listening_ports` is required. The default settings will work, but not comply with up to date security standards. It is somewhat debatable what "up to date security" means - you can use the following web sites to run tests:
+
+- https://securityheaders.io
+- https://www.htbridge.com/ssl
+- https://www.htbridge.com/websec
+- https://www.ssllabs.com/ssltest/analyze.html / https://www.qualys.com/forms/freescan/
+- probably there are some more ... let me know!
+
+Instructions to run the test and to adapt the configuration can be found [`civetweb.conf`](civetweb.conf). You can test this configuration directly with the standalone server, or you can take the settings and add it into your embedding code.
+
+Note: I do not take any warranty or liability for this configuration, or for the content of any linked web site.
+
diff --git a/ceph/src/civetweb/examples/https/civetweb.conf b/ceph/src/civetweb/examples/https/civetweb.conf
new file mode 100644
index 000000000..cd10eddab
--- /dev/null
+++ b/ceph/src/civetweb/examples/https/civetweb.conf
@@ -0,0 +1,86 @@
+# Instructions to run (on Linux) to reproduce test results:
+#
+# 1) copy civetweb executable here (examples/https directory)
+# 2) sudo ./civetweb
+#
+# Instructions to adapt to your own server:
+#
+# 1) generate your own server cert
+# 2) generate at least one backup server cert
+# in case you want a self signed cert, you can use the script
+# in resources/cert for both steps
+# 3) copy the content of the *.pin files into the Public-Key-Pins
+# header config (the base64 encoded certificate hash)
+# 4) set the document root, and all other required http server settings
+# 5) Run the tests from the three websites below. They will tell you
+# also what clients are compatible with your settings. The settings
+# here are very strict and lock out most older clients/browsers.
+# You will find some hints for fine tuning there as well.
+# 6) If you know all your clients, and give them client certificates in
+# advance, you can significantly improve security by setting
+# "ssl_verify_peer" to "yes" and specifying a client cert (directory)
+# using "ssl_ca_file/path". This will lock out all clients without a
+# proper certificate. Don't use it for your public home page, but
+# consider it for your private remote access server.
+# 7) run civetweb, like above - or better create your own start script
+# You are welcome to share your thoughts and experience on GitHub
+# (or Google groups) - see README.md in CivetWeb main directory
+
+# Don't run as super user, switch back to a regular user
+run_as_user user
+
+# The standard HTTP port 80 should redirect to the standard HTTPS port 443
+listening_ports 80r,443s
+
+# Don't forget to set the document root and domain
+#document_root tdb
+#authentication_domain mydomain.com
+
+# Set the a certificate
+ssl_certificate ../../resources/cert/server.pem
+
+# Require a client cert for your private server (see above)
+#ssl_verify_peer yes
+#ssl_ca_file ../../resources/cert/client.pem
+
+# Enforce TLS1.2 and some strong cipher(s)
+ssl_protocol_version 4
+ssl_cipher_list ECDH+AESGCM+AES256:!aNULL:!MD5:!DSS
+
+# Tell all browsers to access this site only as HTTPS for the next 180 days
+strict_transport_security_max_age 15552000
+
+# Set some HTTP security header, see https://securityheaders.io
+additional_header Content-Security-Policy: script-src 'self'
+additional_header X-Frame-Options: SAMEORIGIN
+additional_header X-Xss-Protection: 1; mode=block
+additional_header X-Content-Type-Options: nosniff
+additional_header Referrer-Policy: same-origin
+additional_header Public-Key-Pins: pin-sha256="uz1UTAPen+xb+UoQqkVlEx4H653LbMjfRJcZx5OrjbI="; pin-sha256="pf3px1MBPmlTGAPoiHWqaSJ9L9Z+DKfwgsU7LfLnmsk="; max-age=7776000
+#additional_header Expect-CT: max-age=86400,report-uri="https://mydomain.com/report"
+
+
+# Ratings from 2017-09-03 (tests performed later may require more
+# strict security settings)
+#
+# Headers rated A+ from https://securityheaders.io/
+#
+# SSL rated B from https://www.htbridge.com/ssl when using a self signed
+# certificate, but no other weaknesses for modern browsers.
+# Site remarks some older TLS versions and some weaker ciphers are not
+# supported (but that's accessibility, not security).
+#
+# HTTPS rated A+ from https://www.htbridge.com/websec/ when using a self
+# signed certificate, generated with make_certs.sh in resources/cert/
+# and adding the server.pin and server_bkup.pin content into the
+# Public-Key-Pins header above.
+#
+# A rating of "T / If trust issues are ignored: A" (ignoring self-signed cert)
+# from https://www.ssllabs.com/ssltest/, https://www.qualys.com/forms/freescan/
+# (Note: this test is runs with reverse DNS name, while all others use the
+# IP address).
+#
+# Note: This settings are very strict and prevent some older but still common
+# versions of major browsers to access this site. The test web sites will give
+# you an overview. Test, before you use this settings.
+
diff --git a/ceph/src/civetweb/format.bat b/ceph/src/civetweb/format.bat
old mode 100644
new mode 100755
index 35e8a626a..e1ce64094
--- a/ceph/src/civetweb/format.bat
+++ b/ceph/src/civetweb/format.bat
@@ -4,6 +4,7 @@ clang-format -i src/main.c
clang-format -i src/CivetServer.cpp
clang-format -i src/civetweb_private_lua.h
clang-format -i src/md5.inl
+clang-format -i src/sha1.inl
clang-format -i src/mod_lua.inl
clang-format -i src/mod_duktape.inl
clang-format -i src/timer.inl
@@ -24,6 +25,8 @@ clang-format -i test/private_exe.h
clang-format -i test/private_exe.c
clang-format -i test/shared.h
clang-format -i test/shared.c
+clang-format -i test/timertest.h
+clang-format -i test/timertest.c
clang-format -i test/civetweb_check.h
clang-format -i test/main.c
diff --git a/ceph/src/civetweb/include/CivetServer.h b/ceph/src/civetweb/include/CivetServer.h
index ee15ae302..2da1096d8 100644
--- a/ceph/src/civetweb/include/CivetServer.h
+++ b/ceph/src/civetweb/include/CivetServer.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2014 the Civetweb developers
+/* Copyright (c) 2013-2017 the Civetweb developers
* Copyright (c) 2013 No Face Press, LLC
*
* License http://opensource.org/licenses/mit-license.php MIT License
@@ -227,9 +227,11 @@ class CIVETWEB_API CivetServer
* @throws CivetException
*/
CivetServer(const char **options,
- const struct CivetCallbacks *callbacks = 0);
+ const struct CivetCallbacks *callbacks = 0,
+ const void *UserContext = 0);
CivetServer(std::vector options,
- const struct CivetCallbacks *callbacks = 0);
+ const struct CivetCallbacks *callbacks = 0,
+ const void *UserContext = 0);
/**
* Destructor
@@ -531,6 +533,14 @@ class CIVETWEB_API CivetServer
std::string &dst,
bool append = false);
+ // generic user context which can be set/read,
+ // the server does nothing with this apart from keep it.
+ const void *
+ getUserContext() const
+ {
+ return UserContext;
+ }
+
protected:
class CivetConnection
{
@@ -545,6 +555,10 @@ class CIVETWEB_API CivetServer
struct mg_context *context;
std::map connections;
+ // generic user context which can be set/read,
+ // the server does nothing with this apart from keep it.
+ const void *UserContext;
+
private:
/**
* requestHandler(struct mg_connection *, void *cbdata)
diff --git a/ceph/src/civetweb/include/civetweb.h b/ceph/src/civetweb/include/civetweb.h
index db1848991..6ddde4f2f 100644
--- a/ceph/src/civetweb/include/civetweb.h
+++ b/ceph/src/civetweb/include/civetweb.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2016 the Civetweb developers
+/* Copyright (c) 2013-2017 the Civetweb developers
* Copyright (c) 2004-2013 Sergey Lyubka
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -23,7 +23,11 @@
#ifndef CIVETWEB_HEADER_INCLUDED
#define CIVETWEB_HEADER_INCLUDED
-#define CIVETWEB_VERSION "1.8"
+#define CIVETWEB_VERSION "1.10"
+#define CIVETWEB_VERSION_MAJOR (1)
+#define CIVETWEB_VERSION_MINOR (10)
+#define CIVETWEB_VERSION_PATCH (0)
+#define CIVETWEB_VERSION_RELEASED
#ifndef CIVETWEB_API
#if defined(_WIN32)
@@ -49,10 +53,38 @@ extern "C" {
#endif /* __cplusplus */
+/* Initialize this library. This should be called once before any other
+ * function from this library. This function is not guaranteed to be
+ * thread safe.
+ * Parameters:
+ * features: bit mask for features to be initialized.
+ * Return value:
+ * initialized features
+ * 0: error
+ */
+CIVETWEB_API unsigned mg_init_library(unsigned features);
+
+
+/* Un-initialize this library.
+ * Return value:
+ * 0: error
+ */
+CIVETWEB_API unsigned mg_exit_library(void);
+
+
struct mg_context; /* Handle for the HTTP service itself */
struct mg_connection; /* Handle for the individual connection */
+/* Maximum number of headers */
+#define MG_MAX_HEADERS (64)
+
+struct mg_header {
+ const char *name; /* HTTP header name */
+ const char *value; /* HTTP header value */
+};
+
+
/* This structure contains information about the HTTP request. */
struct mg_request_info {
const char *request_method; /* "GET", "POST", etc */
@@ -61,13 +93,15 @@ struct mg_request_info {
const char *local_uri; /* URL-decoded URI (relative). Can be NULL
* if the request_uri does not address a
* resource at the server host. */
- const char *uri; /* Deprecated: use local_uri instead */
- 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 */
- char remote_addr[48]; /* Client's IP address as a string. */
+#if defined(MG_LEGACY_INTERFACE)
+ const char *uri; /* Deprecated: use local_uri instead */
+#endif
+ 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 */
+ char remote_addr[48]; /* Client's IP address as a string. */
#if defined(MG_LEGACY_INTERFACE)
long remote_ip; /* Client's IP address. Deprecated: use remote_addr instead
@@ -82,10 +116,47 @@ struct mg_request_info {
void *conn_data; /* Connection-specific user data */
int num_headers; /* Number of HTTP headers */
- struct mg_header {
- const char *name; /* HTTP header name */
- const char *value; /* HTTP header value */
- } http_headers[64]; /* Maximum 64 headers */
+ struct mg_header
+ http_headers[MG_MAX_HEADERS]; /* Allocate maximum headers */
+
+ struct mg_client_cert *client_cert; /* Client certificate information */
+
+ const char *acceptedWebSocketSubprotocol; /* websocket subprotocol,
+ * accepted during handshake */
+};
+
+
+/* This structure contains information about the HTTP request. */
+/* This structure may be extended in future versions. */
+struct mg_response_info {
+ int status_code; /* E.g. 200 */
+ const char *status_text; /* E.g. "OK" */
+ const char *http_version; /* E.g. "1.0", "1.1" */
+
+ long long content_length; /* Length (in bytes) of the request body,
+ can be -1 if no length was given. */
+
+ int num_headers; /* Number of HTTP headers */
+ struct mg_header
+ http_headers[MG_MAX_HEADERS]; /* Allocate maximum headers */
+};
+
+
+/* Client certificate information (part of mg_request_info) */
+/* New nomenclature. */
+struct mg_client_cert {
+ const char *subject;
+ const char *issuer;
+ const char *serial;
+ const char *finger;
+};
+
+/* Old nomenclature. */
+struct client_cert {
+ const char *subject;
+ const char *issuer;
+ const char *serial;
+ const char *finger;
};
@@ -158,13 +229,34 @@ struct mg_callbacks {
#endif /* MG_LEGACY_INTERFACE */
/* Called when civetweb is closing a connection. The per-context mutex is
- locked when this is invoked. This is primarily useful for noting when
- a websocket is closing and removing it from any application-maintained
- list of clients.
+ locked when this is invoked.
+
+ Websockets:
+ Before mg_set_websocket_handler has been added, it was primarily useful
+ for noting when a websocket is closing, and used to remove it from any
+ application-maintained list of clients.
Using this callback for websocket connections is deprecated: Use
- mg_set_websocket_handler instead. */
+ mg_set_websocket_handler instead.
+
+ Connection specific data:
+ If memory has been allocated for the connection specific user data
+ (mg_request_info->conn_data, mg_get_user_connection_data),
+ this is the last chance to free it.
+ */
void (*connection_close)(const struct mg_connection *);
+#if defined(MG_USE_OPEN_FILE)
+ /* Note: The "file in memory" feature is a deletion candidate, since
+ * it complicates the code, and does not add any value compared to
+ * "mg_add_request_handler".
+ * See this discussion thread:
+ * https://groups.google.com/forum/#!topic/civetweb/h9HT4CmeYqI
+ * If you disagree, if there is any situation this is indeed useful
+ * and cannot trivially be replaced by another existing feature,
+ * please contribute to this discussion during the next 3 month
+ * (till end of April 2017), otherwise this feature might be dropped
+ * in future releases. */
+
/* Called when civetweb tries to open a file. Used to intercept file open
calls, and serve file data from memory instead.
Parameters:
@@ -174,10 +266,11 @@ struct mg_callbacks {
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. */
+ initialized with the size of the memory block. */
const char *(*open_file)(const struct mg_connection *,
const char *path,
size_t *data_len);
+#endif
/* Called when civetweb is about to serve Lua server page, if
Lua support is enabled.
@@ -223,6 +316,21 @@ struct mg_callbacks {
Parameters:
ctx: context handle */
void (*exit_context)(const struct mg_context *ctx);
+
+ /* Called when initializing a new connection object.
+ * Can be used to initialize the connection specific user data
+ * (mg_request_info->conn_data, mg_get_user_connection_data).
+ * When the callback is called, it is not yet known if a
+ * valid HTTP(S) request will be made.
+ * Parameters:
+ * conn: not yet fully initialized connection object
+ * conn_data: output parameter, set to initialize the
+ * connection specific user data
+ * Return value:
+ * must be 0
+ * Otherwise, the result is undefined
+ */
+ int (*init_connection)(const struct mg_connection *conn, void **conn_data);
};
@@ -294,11 +402,10 @@ typedef int (*mg_request_handler)(struct mg_connection *conn, void *cbdata);
ctx: server context
uri: the URI (exact or pattern) for the handler
handler: the callback handler to use when the URI is requested.
- If NULL, an already registered handler for this URI will be
- removed.
- The URI used to remove a handler must match exactly the one used
- to
- register it (not only a pattern match).
+ If NULL, an already registered handler for this URI will
+ be removed.
+ The URI used to remove a handler must match exactly the
+ one used to register it (not only a pattern match).
cbdata: the callback data to give to the handler when it is called. */
CIVETWEB_API void mg_set_request_handler(struct mg_context *ctx,
const char *uri,
@@ -342,6 +449,14 @@ typedef int (*mg_websocket_data_handler)(struct mg_connection *,
typedef void (*mg_websocket_close_handler)(const struct mg_connection *,
void *);
+/* struct mg_websocket_subprotocols
+ *
+ * List of accepted subprotocols
+ */
+struct mg_websocket_subprotocols {
+ int nb_subprotocols;
+ char **subprotocols;
+};
/* mg_set_websocket_handler
@@ -356,10 +471,24 @@ mg_set_websocket_handler(struct mg_context *ctx,
mg_websocket_close_handler close_handler,
void *cbdata);
+/* mg_set_websocket_handler
+
+ Set or remove handler functions for websocket connections.
+ This function works similar to mg_set_request_handler - see there. */
+CIVETWEB_API void mg_set_websocket_handler_with_subprotocols(
+ struct mg_context *ctx,
+ const char *uri,
+ struct mg_websocket_subprotocols *subprotocols,
+ mg_websocket_connect_handler connect_handler,
+ mg_websocket_ready_handler ready_handler,
+ mg_websocket_data_handler data_handler,
+ mg_websocket_close_handler close_handler,
+ void *cbdata);
+
/* mg_authorization_handler
- Some description here
+ Callback function definition for mg_set_auth_handler
Parameters:
conn: current connection information.
@@ -411,6 +540,19 @@ CIVETWEB_API void *
mg_get_user_connection_data(const struct mg_connection *conn);
+/* Get a formatted link corresponding to the current request
+
+ Parameters:
+ conn: current connection information.
+ buf: string buffer (out)
+ buflen: length of the string buffer
+ Returns:
+ <0: error
+ >=0: ok */
+CIVETWEB_API int
+mg_get_request_link(const struct mg_connection *conn, char *buf, size_t buflen);
+
+
#if defined(MG_LEGACY_INTERFACE)
/* Return array of strings that represent valid configuration options.
For each option, option name and default value is returned, i.e. the
@@ -427,7 +569,7 @@ struct mg_option {
const char *default_value;
};
-
+/* Old nomenclature */
enum {
CONFIG_TYPE_UNKNOWN = 0x0,
CONFIG_TYPE_NUMBER = 0x1,
@@ -435,9 +577,23 @@ enum {
CONFIG_TYPE_FILE = 0x3,
CONFIG_TYPE_DIRECTORY = 0x4,
CONFIG_TYPE_BOOLEAN = 0x5,
- CONFIG_TYPE_EXT_PATTERN = 0x6
+ CONFIG_TYPE_EXT_PATTERN = 0x6,
+ CONFIG_TYPE_STRING_LIST = 0x7,
+ CONFIG_TYPE_STRING_MULTILINE = 0x8
};
+/* New nomenclature */
+enum {
+ MG_CONFIG_TYPE_UNKNOWN = 0x0,
+ MG_CONFIG_TYPE_NUMBER = 0x1,
+ MG_CONFIG_TYPE_STRING = 0x2,
+ MG_CONFIG_TYPE_FILE = 0x3,
+ MG_CONFIG_TYPE_DIRECTORY = 0x4,
+ MG_CONFIG_TYPE_BOOLEAN = 0x5,
+ MG_CONFIG_TYPE_EXT_PATTERN = 0x6,
+ MG_CONFIG_TYPE_STRING_LIST = 0x7,
+ MG_CONFIG_TYPE_STRING_MULTILINE = 0x8
+};
/* Return array of struct mg_option, representing all valid configuration
options of civetweb.c.
@@ -467,30 +623,45 @@ CIVETWEB_API int mg_get_server_ports(const struct mg_context *ctx,
struct mg_server_ports *ports);
+#if defined(MG_LEGACY_INTERFACE)
/* Deprecated: Use mg_get_server_ports instead. */
CIVETWEB_API size_t
mg_get_ports(const struct mg_context *ctx, size_t size, int *ports, int *ssl);
+#endif
/* Add, edit or delete the entry in the passwords file.
-
- This function allows an application to manipulate .htpasswd files on the
- fly by adding, deleting and changing user records. This is one of the
- several ways of implementing authentication on the server side. For another,
- cookie-based way please refer to the examples/chat in the source tree.
-
- If password is not NULL, entry is added (or modified if already exists).
- If password is NULL, entry is deleted.
-
- Return:
- 1 on success, 0 on error. */
+ *
+ * This function allows an application to manipulate .htpasswd files on the
+ * fly by adding, deleting and changing user records. This is one of the
+ * several ways of implementing authentication on the server side. For another,
+ * cookie-based way please refer to the examples/chat in the source tree.
+ *
+ * Parameter:
+ * passwords_file_name: Path and name of a file storing multiple passwords
+ * realm: HTTP authentication realm (authentication domain) name
+ * user: User name
+ * password:
+ * If password is not NULL, entry modified or added.
+ * If password is NULL, entry is deleted.
+ *
+ * Return:
+ * 1 on success, 0 on error.
+ */
CIVETWEB_API int mg_modify_passwords_file(const char *passwords_file_name,
- const char *domain,
+ const char *realm,
const char *user,
const char *password);
-/* Return information associated with the request. */
+/* Return information associated with the request.
+ * Use this function to implement a server and get data about a request
+ * from a HTTP/HTTPS client.
+ * Note: Before CivetWeb 1.10, this function could be used to read
+ * a response from a server, when implementing a client, although the
+ * values were never returned in appropriate mg_request_info elements.
+ * It is strongly advised to use mg_get_response_info for clients.
+ */
CIVETWEB_API const struct mg_request_info *
mg_get_request_info(const struct mg_connection *);
@@ -498,6 +669,13 @@ mg_get_request_info(const struct mg_connection *);
CIVETWEB_API struct sockaddr *
mg_get_local_addr(struct mg_connection *);
+/* Return information associated with a HTTP/HTTPS response.
+ * Use this function in a client, to check the response from
+ * the server. */
+CIVETWEB_API const struct mg_response_info *
+mg_get_response_info(const struct mg_connection *);
+
+
/* Send data to the client.
Return:
0 when the connection has been closed
@@ -564,6 +742,7 @@ CIVETWEB_API void mg_unlock_context(struct mg_context *ctx);
/* Opcodes, from http://tools.ietf.org/html/rfc6455 */
+/* Old nomenclature */
enum {
WEBSOCKET_OPCODE_CONTINUATION = 0x0,
WEBSOCKET_OPCODE_TEXT = 0x1,
@@ -573,6 +752,15 @@ enum {
WEBSOCKET_OPCODE_PONG = 0xa
};
+/* New nomenclature */
+enum {
+ MG_WEBSOCKET_OPCODE_CONTINUATION = 0x0,
+ MG_WEBSOCKET_OPCODE_TEXT = 0x1,
+ MG_WEBSOCKET_OPCODE_BINARY = 0x2,
+ MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8,
+ MG_WEBSOCKET_OPCODE_PING = 0x9,
+ MG_WEBSOCKET_OPCODE_PONG = 0xa
+};
/* Macros for enabling compiler-specific checks for printf-like arguments. */
#undef PRINTF_FORMAT_STRING
@@ -601,24 +789,97 @@ CIVETWEB_API int mg_printf(struct mg_connection *,
...) PRINTF_ARGS(2, 3);
+/* Send a part of the message body, if chunked transfer encoding is set.
+ * Only use this function after sending a complete HTTP request or response
+ * header with "Transfer-Encoding: chunked" set. */
+CIVETWEB_API int mg_send_chunk(struct mg_connection *conn,
+ const char *chunk,
+ unsigned int chunk_len);
+
+
/* Send contents of the entire file together with HTTP headers. */
CIVETWEB_API void mg_send_file(struct mg_connection *conn, const char *path);
+
+/* Send HTTP error reply. */
+CIVETWEB_API void mg_send_http_error(struct mg_connection *conn,
+ int status_code,
+ PRINTF_FORMAT_STRING(const char *fmt),
+ ...) PRINTF_ARGS(3, 4);
+
+
+/* Send HTTP digest access authentication request.
+ * Browsers will send a user name and password in their next request, showing
+ * an authentication dialog if the password is not stored.
+ * Parameters:
+ * conn: Current connection handle.
+ * realm: Authentication realm. If NULL is supplied, the sever domain
+ * set in the authentication_domain configuration is used.
+ * Return:
+ * < 0 Error
+ */
+CIVETWEB_API int
+mg_send_digest_access_authentication_request(struct mg_connection *conn,
+ const char *realm);
+
+
+/* Check if the current request has a valid authentication token set.
+ * A file is used to provide a list of valid user names, realms and
+ * password hashes. The file can be created and modified using the
+ * mg_modify_passwords_file API function.
+ * Parameters:
+ * conn: Current connection handle.
+ * realm: Authentication realm. If NULL is supplied, the sever domain
+ * set in the authentication_domain configuration is used.
+ * filename: Path and name of a file storing multiple password hashes.
+ * Return:
+ * > 0 Valid authentication
+ * 0 Invalid authentication
+ * < 0 Error (all values < 0 should be considered as invalid
+ * authentication, future error codes will have negative
+ * numbers)
+ * -1 Parameter error
+ * -2 File not found
+ */
+CIVETWEB_API int
+mg_check_digest_access_authentication(struct mg_connection *conn,
+ const char *realm,
+ const char *filename);
+
+
+/* Send contents of the entire file together with HTTP headers.
+ * Parameters:
+ * conn: Current connection handle.
+ * path: Full path to the file to send.
+ * mime_type: Content-Type for file. NULL will cause the type to be
+ * looked up by the file extension.
+ */
+CIVETWEB_API void mg_send_mime_file(struct mg_connection *conn,
+ const char *path,
+ const char *mime_type);
+
+
/* Send contents of the entire file together with HTTP headers.
Parameters:
conn: Current connection information.
path: Full path to the file to send.
mime_type: Content-Type for file. NULL will cause the type to be
looked up by the file extension.
+ additional_headers: Additional custom header fields appended to the header.
+ Each header should start with an X-, to ensure it is
+ not included twice.
+ NULL does not append anything.
*/
-CIVETWEB_API void mg_send_mime_file(struct mg_connection *conn,
- const char *path,
- const char *mime_type);
+CIVETWEB_API void mg_send_mime_file2(struct mg_connection *conn,
+ const char *path,
+ const char *mime_type,
+ const char *additional_headers);
+
/* Store body data into a file. */
CIVETWEB_API long long mg_store_body(struct mg_connection *conn,
const char *path);
-/* Read entire request body and stor it in a file "path".
+/* Read entire request body and store it in a file "path".
Return:
< 0 Error
>= 0 Number of bytes stored in file "path".
@@ -826,6 +1087,7 @@ struct mg_form_data_handler {
/* Return values definition for the "field_found" callback in
* mg_form_data_handler. */
+/* Old nomenclature */
enum {
/* Skip this field (neither get nor store it). Continue with the
* next field. */
@@ -838,6 +1100,18 @@ enum {
FORM_FIELD_STORAGE_ABORT = 0x10
};
+/* New nomenclature */
+enum {
+ /* Skip this field (neither get nor store it). Continue with the
+ * next field. */
+ MG_FORM_FIELD_STORAGE_SKIP = 0x0,
+ /* Get the field value. */
+ MG_FORM_FIELD_STORAGE_GET = 0x1,
+ /* Store the field value into a file. */
+ MG_FORM_FIELD_STORAGE_STORE = 0x2,
+ /* Stop parsing this request. Skip the remaining fields. */
+ MG_FORM_FIELD_STORAGE_ABORT = 0x10
+};
/* Process form data.
* Returns the number of fields handled, or < 0 in case of an error.
@@ -862,8 +1136,8 @@ CIVETWEB_API const char *mg_get_builtin_mime_type(const char *file_name);
/* Get text representation of HTTP status code. */
-CIVETWEB_API const char *mg_get_response_code_text(struct mg_connection *conn,
- int response_code);
+CIVETWEB_API const char *
+mg_get_response_code_text(const struct mg_connection *conn, int response_code);
/* Return CivetWeb version. */
@@ -900,7 +1174,7 @@ CIVETWEB_API char *mg_md5(char buf[33], ...);
/* Print error message to the opened error log stream.
This utilizes the provided logging configuration.
- conn: connection
+ conn: connection (not used for sending data, but to get perameters)
fmt: format string without the line return
...: variable argument list
Example:
@@ -910,15 +1184,12 @@ CIVETWEB_API void mg_cry(const struct mg_connection *conn,
...) PRINTF_ARGS(2, 3);
-/* utility methods to compare two buffers, case incensitive. */
+/* utility methods to compare two buffers, case insensitive. */
CIVETWEB_API int mg_strcasecmp(const char *s1, const char *s2);
-
-/* set connection's http status */
-CIVETWEB_API void mg_set_http_status(struct mg_connection *conn, int status);
-
-/* utility method to compare two buffers, case incensitive. */
CIVETWEB_API int mg_strncasecmp(const char *s1, const char *s2, size_t len);
+ /* set connection's http status */
+CIVETWEB_API void mg_set_http_status(struct mg_connection *conn, int status);
/* Connect to a websocket as a client
Parameters:
@@ -986,7 +1257,7 @@ mg_connect_client_secure(const struct mg_client_options *client_options,
enum { TIMEOUT_INFINITE = -1 };
-
+enum { MG_TIMEOUT_INFINITE = -1 };
/* Wait for a response from the server
Parameters:
@@ -1005,9 +1276,16 @@ CIVETWEB_API int mg_get_response(struct mg_connection *conn,
int timeout);
-/* Check which features where set when civetweb has been compiled.
+/* Check which features where set when the civetweb library has been compiled.
+ The function explicitly addresses compile time defines used when building
+ the library - it does not mean, the feature has been initialized using a
+ mg_init_library call.
+ mg_check_feature can be called anytime, even before mg_init_library has
+ been called.
+
Parameters:
feature: specifies which feature should be checked
+ The value is a bit mask. The individual bits are defined as:
1 serve files (NO_FILES not set)
2 support HTTPS (NO_SSL not set)
4 support CGI (NO_CGI not set)
@@ -1016,15 +1294,77 @@ CIVETWEB_API int mg_get_response(struct mg_connection *conn,
32 support Lua scripts and Lua server pages (USE_LUA is set)
64 support server side JavaScript (USE_DUKTAPE is set)
128 support caching (NO_CACHING not set)
- The result is undefined for all other feature values.
+ 256 support server statistics (USE_SERVER_STATS is set)
+ The result is undefined, if bits are set that do not represent a
+ defined feature (currently: feature >= 512).
+ The result is undefined, if no bit is set (feature == 0).
Return:
- If feature is available > 0
- If feature is not available = 0
+ If feature is available, the corresponding bit is set
+ If feature is not available, the bit is 0
*/
CIVETWEB_API unsigned mg_check_feature(unsigned feature);
+/* Get information on the system. Useful for support requests.
+ Parameters:
+ buffer: Store system information as string here.
+ buflen: Length of buffer (including a byte required for a terminating 0).
+ Return:
+ Available size of system information, exluding a terminating 0.
+ The information is complete, if the return value is smaller than buflen.
+ The result is a JSON formatted string, the exact content may vary.
+ Note:
+ It is possible to determine the required buflen, by first calling this
+ function with buffer = NULL and buflen = NULL. The required buflen is
+ one byte more than the returned value.
+*/
+CIVETWEB_API int mg_get_system_info(char *buffer, int buflen);
+
+
+/* Get context information. Useful for server diagnosis.
+ Parameters:
+ ctx: Context handle
+ buffer: Store context information here.
+ buflen: Length of buffer (including a byte required for a terminating 0).
+ Return:
+ Available size of system information, exluding a terminating 0.
+ The information is complete, if the return value is smaller than buflen.
+ The result is a JSON formatted string, the exact content may vary.
+ Note:
+ It is possible to determine the required buflen, by first calling this
+ function with buffer = NULL and buflen = NULL. The required buflen is
+ one byte more than the returned value. However, since the available
+ context information changes, you should allocate a few bytes more.
+*/
+CIVETWEB_API int
+mg_get_context_info(const struct mg_context *ctx, char *buffer, int buflen);
+
+
+#ifdef MG_EXPERIMENTAL_INTERFACES
+/* Get connection information. Useful for server diagnosis.
+ Parameters:
+ ctx: Context handle
+ idx: Connection index
+ buffer: Store context information here.
+ buflen: Length of buffer (including a byte required for a terminating 0).
+ Return:
+ Available size of system information, exluding a terminating 0.
+ The information is complete, if the return value is smaller than buflen.
+ The result is a JSON formatted string, the exact content may vary.
+ Note:
+ It is possible to determine the required buflen, by first calling this
+ function with buffer = NULL and buflen = NULL. The required buflen is
+ one byte more than the returned value. However, since the available
+ context information changes, you should allocate a few bytes more.
+*/
+CIVETWEB_API int mg_get_connection_info(const struct mg_context *ctx,
+ int idx,
+ char *buffer,
+ int buflen);
+#endif
+
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
diff --git a/ceph/src/civetweb/resources/Makefile.in-duktape b/ceph/src/civetweb/resources/Makefile.in-duktape
index d7ad5cd1b..3a53f2e3d 100644
--- a/ceph/src/civetweb/resources/Makefile.in-duktape
+++ b/ceph/src/civetweb/resources/Makefile.in-duktape
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2015 the Civetweb developers
+# Copyright (c) 2015-2017 the Civetweb developers
#
# License http://opensource.org/licenses/mit-license.php MIT License
#
@@ -8,16 +8,32 @@ ifndef WITH_DUKTAPE
$(error WITH_DUKTAPE is not defined)
endif
-# Duktape default version is 1.3.0 (103)
-WITH_DUKTAPE_VERSION ?= 103
+# Duktape default version is 1.5.2 (105)
+WITH_DUKTAPE_VERSION ?= 105
DUKTAPE_VERSION_KNOWN = 0
# Select src and header according to the Duktape version
-ifeq ($(WITH_DUKTAPE_VERSION), 103)
- $(info Duktape: Using version 1.3.0)
- DUKTAPE_DIR = src/third_party/duktape-1.3.0/src
- DUKTAPE_SHARED_LIB_FLAG = -lduktape1.3
- DUKTAPE_CFLAGS = -DDUKTAPE_VERSION_MAKEFILE=501
+ifeq ($(WITH_DUKTAPE_VERSION), 105)
+ $(info Duktape: Using version 1.5.2)
+ DUKTAPE_DIR = src/third_party/duktape-1.5.2/src
+ DUKTAPE_SHARED_LIB_FLAG = -lduktape1.5
+ DUKTAPE_CFLAGS = -DDUKTAPE_VERSION_MAKEFILE=105
+ DUKTAPE_VERSION_KNOWN = 1
+endif
+
+ifeq ($(WITH_DUKTAPE_VERSION), 108)
+ $(info Duktape: Using version 1.8.0)
+ DUKTAPE_DIR = src/third_party/duktape-1.8.0/src
+ DUKTAPE_SHARED_LIB_FLAG = -lduktape1.8
+ DUKTAPE_CFLAGS = -DDUKTAPE_VERSION_MAKEFILE=108
+ DUKTAPE_VERSION_KNOWN = 1
+endif
+
+ifeq ($(WITH_DUKTAPE_VERSION), 201)
+ $(info Duktape: Using version 2.1.1)
+ DUKTAPE_DIR = src/third_party/duktape-2.1.1/src
+ DUKTAPE_SHARED_LIB_FLAG = -lduktape2.1
+ DUKTAPE_CFLAGS = -DDUKTAPE_VERSION_MAKEFILE=201
DUKTAPE_VERSION_KNOWN = 1
endif
@@ -44,7 +60,7 @@ else
DUKTAPE_SOURCE_FILES = duktape.c
ifeq ($(WITH_DUKTAPE_VERSION), 104)
-# DUKTAPE_SOURCE_FILES +=
+# DUKTAPE_SOURCE_FILES += ... TODO ...
endif
$(info Duktape: using static library)
@@ -57,4 +73,5 @@ DUKTAPE_OBJECTS = $(DUKTAPE_SOURCES:.c=.o)
OBJECTS += $(DUKTAPE_OBJECTS)
CFLAGS += $(DUKTAPE_CFLAGS)
SOURCE_DIRS = $(DUKTAPE_DIR)
+BUILD_DIRS += $(BUILD_DIR)/$(DUKTAPE_DIR)
diff --git a/ceph/src/civetweb/resources/Makefile.in-lua b/ceph/src/civetweb/resources/Makefile.in-lua
index 52474781e..e91d019c9 100644
--- a/ceph/src/civetweb/resources/Makefile.in-lua
+++ b/ceph/src/civetweb/resources/Makefile.in-lua
@@ -1,6 +1,6 @@
#
# Copyright (c) 2013 No Face Press, LLC
-# Copyright (c) 2014-2015 the Civetweb developers
+# Copyright (c) 2014-2017 the Civetweb developers
#
# License http://opensource.org/licenses/mit-license.php MIT License
#
@@ -29,8 +29,8 @@ ifeq ($(WITH_LUA_VERSION), 502)
LUA_VERSION_KNOWN = 1
endif
ifeq ($(WITH_LUA_VERSION), 503)
- $(info Lua: Using version 5.3.1)
- LUA_DIR = src/third_party/lua-5.3.1/src
+ $(info Lua: Using version 5.3.3)
+ LUA_DIR = src/third_party/lua-5.3.3/src
LUA_SHARED_LIB_FLAG = -llua5.3
LUA_CFLAGS = -DLUA_COMPAT_5_2 -DLUA_VERSION_MAKEFILE=503
LUA_VERSION_KNOWN = 1
@@ -108,6 +108,7 @@ LUA_OBJECTS = $(LUA_SOURCES:.c=.o)
OBJECTS += $(LUA_OBJECTS)
CFLAGS += $(LUA_CFLAGS)
SOURCE_DIRS = $(LUA_DIR)
+BUILD_DIRS += $(BUILD_DIR)/$(LUA_DIR)
ifneq ($(WITH_LUA_VERSION), 501)
diff --git a/ceph/src/civetweb/resources/Makefile.in-os b/ceph/src/civetweb/resources/Makefile.in-os
index 9ad113276..a75913486 100644
--- a/ceph/src/civetweb/resources/Makefile.in-os
+++ b/ceph/src/civetweb/resources/Makefile.in-os
@@ -20,3 +20,4 @@ ifeq ($(TARGET_OS),)
endif
endif
endif
+
diff --git a/ceph/src/civetweb/resources/cert/client.crt b/ceph/src/civetweb/resources/cert/client.crt
index d6cd7ef8e..f6bbdd868 100644
--- a/ceph/src/civetweb/resources/cert/client.crt
+++ b/ceph/src/civetweb/resources/cert/client.crt
@@ -1,14 +1,19 @@
-----BEGIN CERTIFICATE-----
-MIICOTCCAaICCQCXNPrLNIw8IDANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJ4
-eDELMAkGA1UECAwCeHgxCzAJBgNVBAcMAnh4MQswCQYDVQQKDAJ4eDELMAkGA1UE
-CwwCeHgxCzAJBgNVBAMMAnh4MREwDwYJKoZIhvcNAQkBFgJ4eDAeFw0xNTEwMjUy
-MzMxNDJaFw0yNTEwMjIyMzMxNDJaMGExCzAJBgNVBAYTAnh4MQswCQYDVQQIDAJ4
-eDELMAkGA1UEBwwCeHgxCzAJBgNVBAoMAnh4MQswCQYDVQQLDAJ4eDELMAkGA1UE
-AwwCeHgxETAPBgkqhkiG9w0BCQEWAnh4MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB
-iQKBgQDGwWIIU2KUEufa0Ga5lnm7I8cX4LPRIFX4zL3g1Kuw27eRaJWJLz3Y97oi
-m0fUmhhKJoEFDxj9U4UbXZWMxzH5F8RfupUu+9yDqTWjTRaUQiM/C7dSPEevfqNP
-zBoERPrMzm9W5d8Ke04vpUzk0duoE6vyNQVECroNlHY7R4zQjwIDAQABMA0GCSqG
-SIb3DQEBCwUAA4GBAKZiZ2+sYJWFnQcfqcDJBwrbTo98SSxfryPmeVQSuM8AXC4I
-baX+fqkatdFidDBl96Aq8pDfqeAz+gqRoJ+Dx7opn5/b0WcB0lD+v25x+nO8g4z7
-HBzpVtvRTkC7dGase72csnqvyWm1xTSiHNRIghl0kZy8wb6V9GmJsHxBoKWN
+MIIDBjCCAe4CCQCFpskbTEyGpTANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJB
+VTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
+cyBQdHkgTHRkMB4XDTE3MDkwMzE5MjIwNVoXDTI3MDkwMTE5MjIwNVowRTELMAkG
+A1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0
+IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+ANyFUuYxv/uexSr/K9aSmcnEcylNH4S3NdlvMwFvW3XFqAV05tV6HnPnSELEk6t3
+8aMDUGKDBrrjwsVK6+S7OyrkioXeB9dWldHbqD7o3MkIM3sUxUtaR6x0RMZ+sIX4
+XpE0xULcip1bG0etP4Z2frEP2IOOValQcm4SCnKYZJyTr/oR31NmlIPU/47s74U6
+rqwwUE92bzvf1jGeUHEn7IAgSJNIUBNsOIdRQAMBuTJIAmG2qawXaetjLi/NBwNS
+d0OX2v3o9SrA+ZhQYpPG5xp3B3ncHgVvmhmp7hUdlYbiemcUHn18hZjxPVZLbtY8
+gQldrWyMZkVabSZjuIH3IKcCAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAUZsxxYVK
+l0tH8E0FCnRJTvG6gjOeiqJRIk7Mmg+hfFZK/ewqBixxg1OBM/xmPXfnI/ULRz74
+UMXnyDIsGakzrFDqWqPt3xots35yHHo2ZkVao6gV4qx0Reu86qeN5iRvG0EjoGMD
+7XRaw56E0XhvMBJW1CiUg944HSw4ptJli0dJCYa+P9s1Fop3lA0d9+dwKMKUyCDr
+yBz4XjyO9jXSQC/t0fkxC4gHhdH/ZaAq0Lem6Xxc40ZwoVc1+dHWFxn8d6L/RYvb
+16gOuw6s2Xt9h2K8OFKzehOgNZAkI2oUELRFUx9Wc8/Bcl6uEkBmPHRqeX5l35jo
+ztBrpAEsCy0cGg==
-----END CERTIFICATE-----
diff --git a/ceph/src/civetweb/resources/cert/client.csr b/ceph/src/civetweb/resources/cert/client.csr
index 8c5dbdce6..beb846694 100644
--- a/ceph/src/civetweb/resources/cert/client.csr
+++ b/ceph/src/civetweb/resources/cert/client.csr
@@ -1,11 +1,16 @@
-----BEGIN CERTIFICATE REQUEST-----
-MIIBoTCCAQoCAQAwYTELMAkGA1UEBhMCeHgxCzAJBgNVBAgMAnh4MQswCQYDVQQH
-DAJ4eDELMAkGA1UECgwCeHgxCzAJBgNVBAsMAnh4MQswCQYDVQQDDAJ4eDERMA8G
-CSqGSIb3DQEJARYCeHgwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMbBYghT
-YpQS59rQZrmWebsjxxfgs9EgVfjMveDUq7Dbt5FolYkvPdj3uiKbR9SaGEomgQUP
-GP1ThRtdlYzHMfkXxF+6lS773IOpNaNNFpRCIz8Lt1I8R69+o0/MGgRE+szOb1bl
-3wp7Ti+lTOTR26gTq/I1BUQKug2UdjtHjNCPAgMBAAGgADANBgkqhkiG9w0BAQsF
-AAOBgQCVJKEisDii5qFbV75rOGF+tTChv3c051pWerl8U42s/MQ3jhzNb8+i7f2n
-Kn4yZU3u91xtAruAoKFPSnFpgQKyBRv57g5eM03nrUUImZcRT5Kkf4YsqRMsZ2yH
-MYk6QbTrJwibUoqEUUFgv0n5ONUBoEvhzZr0K9KZ3DLyIg1rpQ==
+MIICijCCAXICAQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUx
+ITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBANyFUuYxv/uexSr/K9aSmcnEcylNH4S3NdlvMwFv
+W3XFqAV05tV6HnPnSELEk6t38aMDUGKDBrrjwsVK6+S7OyrkioXeB9dWldHbqD7o
+3MkIM3sUxUtaR6x0RMZ+sIX4XpE0xULcip1bG0etP4Z2frEP2IOOValQcm4SCnKY
+ZJyTr/oR31NmlIPU/47s74U6rqwwUE92bzvf1jGeUHEn7IAgSJNIUBNsOIdRQAMB
+uTJIAmG2qawXaetjLi/NBwNSd0OX2v3o9SrA+ZhQYpPG5xp3B3ncHgVvmhmp7hUd
+lYbiemcUHn18hZjxPVZLbtY8gQldrWyMZkVabSZjuIH3IKcCAwEAAaAAMA0GCSqG
+SIb3DQEBCwUAA4IBAQB/bapQm4nxXA01msL6nkjiVaeh/mj8Cr8sPFtQXVu+hxl9
+mjbisxDXwPhiFOiTlokQkINf+RMxQsVNr2y/sGZrSMimabwODDXnPpyir4b2WOWp
+VQQWbgnMVnvgKsjBpLLDr8VnLBiQ3mED+2QV0bxxJSgvvEuiZx/BlCgiu77D/8kj
+XUY/CXIBi00fIYigpRRdv2WtMQjtQe2fCSZZKOWu2ZWu2o24kEk28x5LO/WaJ4Ft
+lUHFOIp/wkKz/US4mbdQaD0bsg7MirAyGrCmZIHqQDhdDWq+o/brI7N/8yOk3qwc
+qPGkr9PYIPnuzZwStLJlPxKGXjCA40HpdmWA0kyc
-----END CERTIFICATE REQUEST-----
diff --git a/ceph/src/civetweb/resources/cert/client.key b/ceph/src/civetweb/resources/cert/client.key
index ea9e739b7..f041acc0c 100644
--- a/ceph/src/civetweb/resources/cert/client.key
+++ b/ceph/src/civetweb/resources/cert/client.key
@@ -1,15 +1,27 @@
-----BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQDGwWIIU2KUEufa0Ga5lnm7I8cX4LPRIFX4zL3g1Kuw27eRaJWJ
-Lz3Y97oim0fUmhhKJoEFDxj9U4UbXZWMxzH5F8RfupUu+9yDqTWjTRaUQiM/C7dS
-PEevfqNPzBoERPrMzm9W5d8Ke04vpUzk0duoE6vyNQVECroNlHY7R4zQjwIDAQAB
-AoGAUPrNxHKlAYvKZ77te8QxiOwE3FezLAuuu5Y/7vD3mzGKU3Z3JtPWsSYN8ret
-xpOaPev+OV9zYRO8ce/pVNh8JTcvywU9SaaxzrMVIq+8rOfM8oCXwpKr7FqV6fO3
-a9JzofV6A2x3mzWqyixRVSGBWTC3Oc5+uaTX5pmJvMFgKLECQQDxFopXbhgPUVtQ
-Wa5onj3qDtYsuJALBDaHDV7nSoQySZpHn1DS/w1n+INOuwkXXfMzqdRDKGDh5VVe
-5rF1k1nVAkEA0wyI7aXYIJuYli5fCN6bwGQTwmwoWbyDDE+VkZlMUm8KhIzdnFjP
-j9+ntNshNYyKf6H9XqxuizNyiLyiWl+u0wJAXLWgSXLKycktZj62dQC1Kna+IcBv
-k+zw0wpvPl5Ha9cl/vji6eCu1RaZ2ALQwi2cwndCavjyGKxKIg5wm5goaQJAc4dC
-EW0ecUMbdOJvbWiGM/vUgTI5qF20EvIhuvECwYE9ba+6xBItlOFmaW8mr6x+SD3B
-d6jGXnbMNKOl7/i+twJBANIFBVZBal85Wn0V5MJFDWLB1vPSxXwb4OBwVD+j52H7
-YwpRbUn3/4CkiagDPdzio80WkWdkqpGZoVyDUpZi5Fg=
+MIIEpAIBAAKCAQEA3IVS5jG/+57FKv8r1pKZycRzKU0fhLc12W8zAW9bdcWoBXTm
+1Xoec+dIQsSTq3fxowNQYoMGuuPCxUrr5Ls7KuSKhd4H11aV0duoPujcyQgzexTF
+S1pHrHRExn6whfhekTTFQtyKnVsbR60/hnZ+sQ/Yg45VqVBybhIKcphknJOv+hHf
+U2aUg9T/juzvhTqurDBQT3ZvO9/WMZ5QcSfsgCBIk0hQE2w4h1FAAwG5MkgCYbap
+rBdp62MuL80HA1J3Q5fa/ej1KsD5mFBik8bnGncHedweBW+aGanuFR2VhuJ6ZxQe
+fXyFmPE9Vktu1jyBCV2tbIxmRVptJmO4gfcgpwIDAQABAoIBAEpiBlZzTYi4Q1V/
+gO/9vzYZt6akxw7jJZzUL2Y6g6U0KLq+deZoLMF3sB4lZJIgATe1NHYmMCz2Coq1
+/N/Ib+rF8Bu7ivWN1TdWWmft8Bs3UvYfSXVjXG3FQjWaIjzuTCe6nxcwgOkXBBqn
+S5g1fAKJj8TATBCyfAa4uyFwWe+eGRs0W9pOMP8eU0EtvTer34rSU4L/LG3d7UcI
+upm/0T5QeLqv6Htv8UbHNQto701vJQVdWLavALMXGfGO112yTSz7OpitKpBEYDrV
+3+781zYm8AKkFIsRMXVK2HiBEF43zIrnNuoozsKpps/tZdlv9VqCSJ4hIaHm9mxJ
+3zMN3OECgYEA8dr5w68jTLrthDZ2qOG/6tZw9fMfXoF7hSUXplgxMN5Sohfr23Xm
+/IHVm7oiqhDNNZzplGyux7jB00x2/1ltOzay5mx4PMMLlsDBgiURgUwqS8C8dPVh
+0sN2RytdKGDmFP6lnKS7c15CEw1ChvdL4RwtqzjTKE0ZOK3zUY5/MykCgYEA6Wru
+Dusip4p4PA1K6eiCoC6SaqCuQCB7ZR5WPR5szAFkgoW63rNtC8S4Bl1qXXUb/v/V
+ptaVsGrqBc8/CxvCac1KCREbcyjuVWUAfw2VwdwgDbfrEieWrZNvsDs86EgB+Bo4
+Jm/cUjrFqSTJAbtvp4SYl1reax86XmCsHhNNf08CgYEApAhxd9/0IBlz+ET8K8SY
+5sy0ZouTjgRh40bqCF8uVcej4d45kGoh1Ma2Ot1+nzuwApm+7nTcAgd0JjxpRPzB
+EfUiVxfgYM2ksYVgeUVs3vXqheBdsTGwPENnmBN4Jme6BSlE573uiOu4ArXulh1p
+sG7tJoDu7hmEbqXELl9oNCkCgYEA51zWGnN3JhpakyuZ1cBhueRvvMEH9wg7Rz+K
+u4oszQmUVsu3Locqzz9uKODvTTOHTHrJi1WnifZvgNKr6pbZXYXenJ4YV01676nt
+lAIjLsTCANcMajJTaDl7u3L8LEEzsnhKr86w09Dtm3qawtzHD4Seu2eWjxelA2dP
+M4BukIECgYAn5n+HhCi5JD3I1VCX70uE5nj8alYyQ85qE57Lopmau1RyVfP4oeCt
+gMsy0o7vIF+xW1Z2yDxm+mJghOY/myDsbTGX9G8rY7PC7tWE8okjsQT5UoayFzKp
+mmvrTV8TQBVcTQqn0Jyj7T5MBnuwfioXYN9pKPQlvc4pPmHbqPi7CA==
-----END RSA PRIVATE KEY-----
diff --git a/ceph/src/civetweb/resources/cert/client.key.orig b/ceph/src/civetweb/resources/cert/client.key.orig
index 31489cdc3..6b30836ae 100644
--- a/ceph/src/civetweb/resources/cert/client.key.orig
+++ b/ceph/src/civetweb/resources/cert/client.key.orig
@@ -1,18 +1,30 @@
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
-DEK-Info: DES-EDE3-CBC,74B669EA97409DB5
+DEK-Info: DES-EDE3-CBC,161D2DE9FC3C5EE4
-U8mySuY/I28r8dygZbyHF9K5VFPekhar4zgN2p6wUyrIT9UvA0Y75VE6Pu55+FZS
-JEiR+5btbONt2Lf7z52zi8bv8cb+IJryjSoGkk9Klesmwc9qkUxtuZosdIoZKGFl
-SgSNecK7QYOu66PK4GOi47CFsKuKT4pR8A8Kt11PYTpXDNGomcsdS3DNEbpxvj7F
-/D/1V24IMu+cknL3r6wwL0stB3idwS+4Oq/JLosKHC5mB6+Pu285K6/NWUo5FqLy
-WgzCWzFzzQy3vBce30HOf2gCUJ++2JKoBa8wdj06ei0OTz6oFWAvftv1fTen6cyW
-LG5uAmNPpv4PmtTpOtNJtd8VFpShxiCbYm772MXiDRNiLL9iMsS9OtgTkxHyqRqr
-i8RRKzZCFzf4+xTGxO6GkkFV0/W/PM+TnvFWoWOviCjJJOFGwrQAUzRFce3UAU8V
-sSmvnE0mGvREQAUiw15onGaHKT/ivzFFutgghrcrjpGH55j/zp5gxD+WDeDqAgNA
-RPk0l63D9CrjyTuyTX1H35V1+EZ9YYP5tZ3wGn6i3WCC3WjHqDg5EZHRprjvPw7p
-rfurs33qHUon42aM1G/dJ+jtn4993RdCvCztxW6aBp+nLEEROMA/0HCZJeM9lE7L
-nWAy+jkn/6wRoATa01fEPHozju0HQhCrPcxjrJ8tIVgI1iEL2xw7STlvo6BZcnP2
-oGLMiEk5gmHCOonh+taLkFhKP+F0cSZJlJcmEr6YYzhh7FoR+sKEb2Cx2n2ySuhv
-LYh1Wn4T0Xmau7OFX2Pc+d5zBaW6lYn/ZUw8GbaDqNd3sT/UICC0Ww==
+U+3WYIvh4n4cJouZXJkuPMUucnymOWME9ZPBs3CzbWao/HSYS7tEh0gUMb6VtkQo
+zq/jQUO2aecWC3+LPZlkUGGWwCU3OCgyFW9xiMRduzKhbPUig+4k9aeKki5RypmR
+XFnn/W5ddJSHTVgQI0hF7ZxvC86ldBkCHzSwkKyL8dwBNouXyMgl4PfaZ90N3/pZ
+jBnuqbwF1EN0V6OYo3QSxsifpu2M62a229yW9U0/vV7bkGgyqTbtV6V6ny5+IWn+
+r99bb+hS1SSt5VVuHfNKh06ww0Mc7bSfeyVcdgoT5ltftsRWEA1Au5DfS+nhztVf
+0l/yiMTm60x61WuXsbQz+4hwH7nCAMIFbBmCYbP/eqY9BIiKy9Ue7vOouTHdi7Op
+wQL/r3Wc/+IcssoExITnOBX2San6NvtC7ej+8Wf/wKOh5mTp4uT5cbdif3ifj7uo
+GmYbWNJSo0VVtl1nru9uSIbJSKVzMcDO2aVbofCGB4KUpkm+3Sw2ZnbJ6o/AVZb3
+ip7NoudU11d6KBzpyvfyFzSNfGVmtasB24BYt22vSQWJ5Ob5MQgg+zFEpGUeoq6p
+LqRaZCDqXHsofM49JEbU/32SV3JhSjfzJ9gVG+lymGZIdmYD4y+SH/6K0QtCN9cY
+7++96vAPYgKmJ6vK1N8o6owDkxQ3+FilKWanp2rwETc1RyWSg5hi62+8YllmsQXc
+3zvFXgCS+yfAKXqtHTugtb6c8o2RuPdpNtVmtncEnf3OeuP/gDbqLumzHRDQk+o1
+rgGiLsvY4MmbmS0D/c4NZ8fyBqN7d2TRHnHS6mpqgzpKHOuRPmLQ+azmf3ISY9m4
+H8ROjKqTMHUfxQRKizHPTRjtvYjk/uXBrpnDa2buPaW+m1brsiHdhruhB6QPaJGQ
+8uFFHyur5ZRMQhST/fWLmNxPX9CAsXBuKm1cPJWw+QzR8uo7bFwups1ODrLj0L0U
+ECAq343KS6aoCMoLGw4EZRHeSdrequtsaGFHMtweSxs7PJR+UVLf/JSw4f0L4Pa8
+GvY9nBGrI/uoN4H88YR1NjxLCzU5mZ3yLV4ZL9zGq1gX5ZfAr1b9i2pJI4daBFvW
+gJBSzoiN9dq4I4ZZgZ7KSTG2n2mnPPlOhAIgabwpDb2buf0GrZYhgby78Vwy3bdb
+Yk8ToEvLnKzDH8P4JjClIVC7R+bfH1uUO+uDRYZBlpkzc0+HgagW0vt9xZpWrdOm
+DJeZ7/ciCbD+90b1mc8xkPgegKjvrMfEMk81GEGhv28FpIbEAX9nuA4UaQHI58s/
+tgQ3kThVrlJCC/77teNMubcIWycV8ufm4NgDeGtmIP47Z9Vdrv+VFv0hib3hch9M
+7lIJX0aSVRHhEFi6QquQmTlvEB/Z8T640k9ZGiTgkGEFrEh6nnGeiLP+WJodLd/u
+CKkx3KLEi8T90dsPhyo852o+oKOFMA/nEGEOBE7VcgOGkZ2NTBOerVZrBp6T0PGi
+0x2A32YDMjeI19CdsvxgIq7wj9wXuWDXAFV2Ond75XwM4CnGSKefh+Z82ZlfnmNf
+GyKsUSn0Nno58y5LLzXw06E4Wp4WtQcw4KiiaEYA6s92RAsoslY6XqdYSeSvtSz2
-----END RSA PRIVATE KEY-----
diff --git a/ceph/src/civetweb/resources/cert/client.pem b/ceph/src/civetweb/resources/cert/client.pem
index 331fd708e..6974c4c81 100644
--- a/ceph/src/civetweb/resources/cert/client.pem
+++ b/ceph/src/civetweb/resources/cert/client.pem
@@ -1,29 +1,46 @@
-----BEGIN CERTIFICATE-----
-MIICOTCCAaICCQCXNPrLNIw8IDANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJ4
-eDELMAkGA1UECAwCeHgxCzAJBgNVBAcMAnh4MQswCQYDVQQKDAJ4eDELMAkGA1UE
-CwwCeHgxCzAJBgNVBAMMAnh4MREwDwYJKoZIhvcNAQkBFgJ4eDAeFw0xNTEwMjUy
-MzMxNDJaFw0yNTEwMjIyMzMxNDJaMGExCzAJBgNVBAYTAnh4MQswCQYDVQQIDAJ4
-eDELMAkGA1UEBwwCeHgxCzAJBgNVBAoMAnh4MQswCQYDVQQLDAJ4eDELMAkGA1UE
-AwwCeHgxETAPBgkqhkiG9w0BCQEWAnh4MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB
-iQKBgQDGwWIIU2KUEufa0Ga5lnm7I8cX4LPRIFX4zL3g1Kuw27eRaJWJLz3Y97oi
-m0fUmhhKJoEFDxj9U4UbXZWMxzH5F8RfupUu+9yDqTWjTRaUQiM/C7dSPEevfqNP
-zBoERPrMzm9W5d8Ke04vpUzk0duoE6vyNQVECroNlHY7R4zQjwIDAQABMA0GCSqG
-SIb3DQEBCwUAA4GBAKZiZ2+sYJWFnQcfqcDJBwrbTo98SSxfryPmeVQSuM8AXC4I
-baX+fqkatdFidDBl96Aq8pDfqeAz+gqRoJ+Dx7opn5/b0WcB0lD+v25x+nO8g4z7
-HBzpVtvRTkC7dGase72csnqvyWm1xTSiHNRIghl0kZy8wb6V9GmJsHxBoKWN
+MIIDBjCCAe4CCQCFpskbTEyGpTANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJB
+VTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
+cyBQdHkgTHRkMB4XDTE3MDkwMzE5MjIwNVoXDTI3MDkwMTE5MjIwNVowRTELMAkG
+A1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0
+IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+ANyFUuYxv/uexSr/K9aSmcnEcylNH4S3NdlvMwFvW3XFqAV05tV6HnPnSELEk6t3
+8aMDUGKDBrrjwsVK6+S7OyrkioXeB9dWldHbqD7o3MkIM3sUxUtaR6x0RMZ+sIX4
+XpE0xULcip1bG0etP4Z2frEP2IOOValQcm4SCnKYZJyTr/oR31NmlIPU/47s74U6
+rqwwUE92bzvf1jGeUHEn7IAgSJNIUBNsOIdRQAMBuTJIAmG2qawXaetjLi/NBwNS
+d0OX2v3o9SrA+ZhQYpPG5xp3B3ncHgVvmhmp7hUdlYbiemcUHn18hZjxPVZLbtY8
+gQldrWyMZkVabSZjuIH3IKcCAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAUZsxxYVK
+l0tH8E0FCnRJTvG6gjOeiqJRIk7Mmg+hfFZK/ewqBixxg1OBM/xmPXfnI/ULRz74
+UMXnyDIsGakzrFDqWqPt3xots35yHHo2ZkVao6gV4qx0Reu86qeN5iRvG0EjoGMD
+7XRaw56E0XhvMBJW1CiUg944HSw4ptJli0dJCYa+P9s1Fop3lA0d9+dwKMKUyCDr
+yBz4XjyO9jXSQC/t0fkxC4gHhdH/ZaAq0Lem6Xxc40ZwoVc1+dHWFxn8d6L/RYvb
+16gOuw6s2Xt9h2K8OFKzehOgNZAkI2oUELRFUx9Wc8/Bcl6uEkBmPHRqeX5l35jo
+ztBrpAEsCy0cGg==
-----END CERTIFICATE-----
-----BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQDGwWIIU2KUEufa0Ga5lnm7I8cX4LPRIFX4zL3g1Kuw27eRaJWJ
-Lz3Y97oim0fUmhhKJoEFDxj9U4UbXZWMxzH5F8RfupUu+9yDqTWjTRaUQiM/C7dS
-PEevfqNPzBoERPrMzm9W5d8Ke04vpUzk0duoE6vyNQVECroNlHY7R4zQjwIDAQAB
-AoGAUPrNxHKlAYvKZ77te8QxiOwE3FezLAuuu5Y/7vD3mzGKU3Z3JtPWsSYN8ret
-xpOaPev+OV9zYRO8ce/pVNh8JTcvywU9SaaxzrMVIq+8rOfM8oCXwpKr7FqV6fO3
-a9JzofV6A2x3mzWqyixRVSGBWTC3Oc5+uaTX5pmJvMFgKLECQQDxFopXbhgPUVtQ
-Wa5onj3qDtYsuJALBDaHDV7nSoQySZpHn1DS/w1n+INOuwkXXfMzqdRDKGDh5VVe
-5rF1k1nVAkEA0wyI7aXYIJuYli5fCN6bwGQTwmwoWbyDDE+VkZlMUm8KhIzdnFjP
-j9+ntNshNYyKf6H9XqxuizNyiLyiWl+u0wJAXLWgSXLKycktZj62dQC1Kna+IcBv
-k+zw0wpvPl5Ha9cl/vji6eCu1RaZ2ALQwi2cwndCavjyGKxKIg5wm5goaQJAc4dC
-EW0ecUMbdOJvbWiGM/vUgTI5qF20EvIhuvECwYE9ba+6xBItlOFmaW8mr6x+SD3B
-d6jGXnbMNKOl7/i+twJBANIFBVZBal85Wn0V5MJFDWLB1vPSxXwb4OBwVD+j52H7
-YwpRbUn3/4CkiagDPdzio80WkWdkqpGZoVyDUpZi5Fg=
+MIIEpAIBAAKCAQEA3IVS5jG/+57FKv8r1pKZycRzKU0fhLc12W8zAW9bdcWoBXTm
+1Xoec+dIQsSTq3fxowNQYoMGuuPCxUrr5Ls7KuSKhd4H11aV0duoPujcyQgzexTF
+S1pHrHRExn6whfhekTTFQtyKnVsbR60/hnZ+sQ/Yg45VqVBybhIKcphknJOv+hHf
+U2aUg9T/juzvhTqurDBQT3ZvO9/WMZ5QcSfsgCBIk0hQE2w4h1FAAwG5MkgCYbap
+rBdp62MuL80HA1J3Q5fa/ej1KsD5mFBik8bnGncHedweBW+aGanuFR2VhuJ6ZxQe
+fXyFmPE9Vktu1jyBCV2tbIxmRVptJmO4gfcgpwIDAQABAoIBAEpiBlZzTYi4Q1V/
+gO/9vzYZt6akxw7jJZzUL2Y6g6U0KLq+deZoLMF3sB4lZJIgATe1NHYmMCz2Coq1
+/N/Ib+rF8Bu7ivWN1TdWWmft8Bs3UvYfSXVjXG3FQjWaIjzuTCe6nxcwgOkXBBqn
+S5g1fAKJj8TATBCyfAa4uyFwWe+eGRs0W9pOMP8eU0EtvTer34rSU4L/LG3d7UcI
+upm/0T5QeLqv6Htv8UbHNQto701vJQVdWLavALMXGfGO112yTSz7OpitKpBEYDrV
+3+781zYm8AKkFIsRMXVK2HiBEF43zIrnNuoozsKpps/tZdlv9VqCSJ4hIaHm9mxJ
+3zMN3OECgYEA8dr5w68jTLrthDZ2qOG/6tZw9fMfXoF7hSUXplgxMN5Sohfr23Xm
+/IHVm7oiqhDNNZzplGyux7jB00x2/1ltOzay5mx4PMMLlsDBgiURgUwqS8C8dPVh
+0sN2RytdKGDmFP6lnKS7c15CEw1ChvdL4RwtqzjTKE0ZOK3zUY5/MykCgYEA6Wru
+Dusip4p4PA1K6eiCoC6SaqCuQCB7ZR5WPR5szAFkgoW63rNtC8S4Bl1qXXUb/v/V
+ptaVsGrqBc8/CxvCac1KCREbcyjuVWUAfw2VwdwgDbfrEieWrZNvsDs86EgB+Bo4
+Jm/cUjrFqSTJAbtvp4SYl1reax86XmCsHhNNf08CgYEApAhxd9/0IBlz+ET8K8SY
+5sy0ZouTjgRh40bqCF8uVcej4d45kGoh1Ma2Ot1+nzuwApm+7nTcAgd0JjxpRPzB
+EfUiVxfgYM2ksYVgeUVs3vXqheBdsTGwPENnmBN4Jme6BSlE573uiOu4ArXulh1p
+sG7tJoDu7hmEbqXELl9oNCkCgYEA51zWGnN3JhpakyuZ1cBhueRvvMEH9wg7Rz+K
+u4oszQmUVsu3Locqzz9uKODvTTOHTHrJi1WnifZvgNKr6pbZXYXenJ4YV01676nt
+lAIjLsTCANcMajJTaDl7u3L8LEEzsnhKr86w09Dtm3qawtzHD4Seu2eWjxelA2dP
+M4BukIECgYAn5n+HhCi5JD3I1VCX70uE5nj8alYyQ85qE57Lopmau1RyVfP4oeCt
+gMsy0o7vIF+xW1Z2yDxm+mJghOY/myDsbTGX9G8rY7PC7tWE8okjsQT5UoayFzKp
+mmvrTV8TQBVcTQqn0Jyj7T5MBnuwfioXYN9pKPQlvc4pPmHbqPi7CA==
-----END RSA PRIVATE KEY-----
diff --git a/ceph/src/civetweb/resources/cert/client.pfx b/ceph/src/civetweb/resources/cert/client.pfx
index 5797f2355..601b3d51a 100644
Binary files a/ceph/src/civetweb/resources/cert/client.pfx and b/ceph/src/civetweb/resources/cert/client.pfx differ
diff --git a/ceph/src/civetweb/resources/cert/make_certs b/ceph/src/civetweb/resources/cert/make_certs
deleted file mode 100644
index 1dcf32b02..000000000
--- a/ceph/src/civetweb/resources/cert/make_certs
+++ /dev/null
@@ -1,31 +0,0 @@
-#using "pass" for every password
-
-openssl genrsa -des3 -out client.key 1024
-openssl req -new -key client.key -out client.csr
-
-cp client.key client.key.orig
-
-openssl rsa -in client.key.orig -out client.key
-
-openssl x509 -req -days 3650 -in client.csr -signkey client.key -out client.crt
-
-cp client.crt client.pem
-cat client.key >> client.pem
-
-openssl pkcs12 -export -inkey client.key -in client.pem -name ClientName -out client.pfx
-
-
-
-openssl genrsa -des3 -out server.key 1024
-openssl req -new -key server.key -out server.csr
-
-cp server.key server.key.orig
-
-openssl rsa -in server.key.orig -out server.key
-
-openssl x509 -req -days 3650 -in server.csr -signkey server.key -out server.crt
-
-cp server.crt server.pem
-cat server.key >> server.pem
-
-openssl pkcs12 -export -inkey server.key -in server.pem -name ServerName -out server.pfx
diff --git a/ceph/src/civetweb/resources/cert/make_certs.bat b/ceph/src/civetweb/resources/cert/make_certs.bat
new file mode 100644
index 000000000..66a091d37
--- /dev/null
+++ b/ceph/src/civetweb/resources/cert/make_certs.bat
@@ -0,0 +1,55 @@
+@echo off
+REM We need admin rights, otherwise the random state cannot be written
+REM Thanks to http://stackoverflow.com/a/10052222/1531708
+
+:: BatchGotAdmin
+:-------------------------------------
+REM --> Check for permissions
+ IF "%PROCESSOR_ARCHITECTURE%" EQU "amd64" (
+>nul 2>&1 "%SYSTEMROOT%\SysWOW64\cacls.exe" "%SYSTEMROOT%\SysWOW64\config\system"
+) ELSE (
+>nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system"
+)
+
+REM --> If error flag set, we do not have admin.
+if '%errorlevel%' NEQ '0' (
+ echo Requesting administrative privileges...
+ goto UACPrompt
+) else ( goto gotAdmin )
+
+:UACPrompt
+ echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs"
+ set params = %*:"=""
+ echo UAC.ShellExecute "cmd.exe", "/c ""%~s0"" %params%", "", "runas", 1 >> "%temp%\getadmin.vbs"
+
+ "%temp%\getadmin.vbs"
+ del "%temp%\getadmin.vbs"
+ exit /B
+
+:gotAdmin
+ pushd "%CD%"
+ CD /D "%~dp0"
+:--------------------------------------
+
+del server.*
+
+c:\OpenSSL-Win32\bin\openssl.exe genrsa -des3 -out server.key 4096
+
+c:\OpenSSL-Win32\bin\openssl.exe req -sha256 -new -key server.key -out server.csr -utf8
+
+copy server.key server.key.orig
+
+c:\OpenSSL-Win32\bin\openssl.exe rsa -in server.key.orig -out server.key
+
+echo [ v3_ca ] > server.ext.txt
+echo [ req ] >> server.ext.txt
+echo req_extensions = my_extensions >> server.ext.txt
+echo [ my_extensions ] >> server.ext.txt
+echo extendedKeyUsage=serverAuth >> server.ext.txt
+echo crlDistributionPoints=URI:http://localhost/crl.pem >> server.ext.txt
+
+c:\OpenSSL-Win32\bin\openssl.exe x509 -req -days 365 -extensions v3_ca -extfile server.ext.txt -in server.csr -signkey server.key -out server.crt
+
+copy server.crt server.pem
+
+type server.key >> server.pem
diff --git a/ceph/src/civetweb/resources/cert/make_certs.sh b/ceph/src/civetweb/resources/cert/make_certs.sh
new file mode 100644
index 000000000..b4b6714cc
--- /dev/null
+++ b/ceph/src/civetweb/resources/cert/make_certs.sh
@@ -0,0 +1,64 @@
+#!/bin/sh
+#using "pass" for every password
+
+echo "Generating client certificate ..."
+
+openssl genrsa -des3 -out client.key 2048
+openssl req -new -key client.key -out client.csr
+
+cp client.key client.key.orig
+
+openssl rsa -in client.key.orig -out client.key
+
+openssl x509 -req -days 3650 -in client.csr -signkey client.key -out client.crt
+
+cp client.crt client.pem
+cat client.key >> client.pem
+
+openssl pkcs12 -export -inkey client.key -in client.pem -name ClientName -out client.pfx
+
+
+echo "Generating first server certificate ..."
+
+openssl genrsa -des3 -out server.key 2048
+openssl req -new -key server.key -out server.csr
+
+cp server.key server.key.orig
+
+openssl rsa -in server.key.orig -out server.key
+
+openssl x509 -req -days 3650 -in server.csr -signkey server.key -out server.crt
+
+cp server.crt server.pem
+cat server.key >> server.pem
+
+openssl pkcs12 -export -inkey server.key -in server.pem -name ServerName -out server.pfx
+
+echo "First server certificate hash for Public-Key-Pins header:"
+
+openssl x509 -pubkey < server.crt | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | base64 > server.pin
+
+cat server.pin
+
+echo "Generating backup server certificate ..."
+
+openssl genrsa -des3 -out server_bkup.key 2048
+openssl req -new -key server_bkup.key -out server_bkup.csr
+
+cp server_bkup.key server_bkup.key.orig
+
+openssl rsa -in server_bkup.key.orig -out server_bkup.key
+
+openssl x509 -req -days 3650 -in server_bkup.csr -signkey server_bkup.key -out server_bkup.crt
+
+cp server_bkup.crt server_bkup.pem
+cat server_bkup.key >> server_bkup.pem
+
+openssl pkcs12 -export -inkey server_bkup.key -in server_bkup.pem -name ServerName -out server_bkup.pfx
+
+echo "Backup server certificate hash for Public-Key-Pins header:"
+
+openssl x509 -pubkey < server_bkup.crt | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | base64 > server_bkup.pin
+
+cat server_bkup.pin
+
diff --git a/ceph/src/civetweb/resources/cert/server.crt b/ceph/src/civetweb/resources/cert/server.crt
index e74e1830b..a13fa015a 100644
--- a/ceph/src/civetweb/resources/cert/server.crt
+++ b/ceph/src/civetweb/resources/cert/server.crt
@@ -1,14 +1,19 @@
-----BEGIN CERTIFICATE-----
-MIICOTCCAaICCQCWJSBNug1UmTANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJ4
-eDELMAkGA1UECAwCeHgxCzAJBgNVBAcMAnh4MQswCQYDVQQKDAJ4eDELMAkGA1UE
-CwwCeHgxCzAJBgNVBAMMAnh4MREwDwYJKoZIhvcNAQkBFgJ4eDAeFw0xNTEwMjUy
-MzMyMTVaFw0yNTEwMjIyMzMyMTVaMGExCzAJBgNVBAYTAnh4MQswCQYDVQQIDAJ4
-eDELMAkGA1UEBwwCeHgxCzAJBgNVBAoMAnh4MQswCQYDVQQLDAJ4eDELMAkGA1UE
-AwwCeHgxETAPBgkqhkiG9w0BCQEWAnh4MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB
-iQKBgQC+v2d4ye8BgDGncvuCNnJoyt0lcdEiwriGkW7+6eU8CTwgdJGmVZreI9Xo
-lDufzcPGtcu5El1XdwlzcaNB+iQuJfXqodvkbw43A80sWtDZuaLVbS9xAr+2mEqC
-g4/JYKRDy80y3RZ60S2qvB5jhKb1gjobLe69VXU+aifZtI6LGwIDAQABMA0GCSqG
-SIb3DQEBCwUAA4GBAHGVbKEyEIHUYZGGTzmKdQjdeomycKqh0/lgN4LUOFZLpUIb
-Ic26ZAWL3x571i05qz90AFUXEx30o0aVRYjvtSDyIlID4Niz9Cy8s8vNIDSocEAG
-bzBQ9xgFYjMEcgm2ROkzE6xdyxNOHkPA4jXjqgQknyvtkHcPE7mpv7faZXFz
+MIIDBjCCAe4CCQDDIH/hK1C0BjANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJB
+VTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
+cyBQdHkgTHRkMB4XDTE3MDkwMzE5MjIyOVoXDTI3MDkwMTE5MjIyOVowRTELMAkG
+A1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0
+IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+ALUmHEoJcebkUOyqEAhH2OdEuTTk8AxjjVvq9B1dXjlf/dvxGnZX2InScGCJA9Uy
+kO1XI8nLXKAGl6OL9jDt/0K3/oFLedDLtZf1qE+kEBuaqAgL+VVAPqwtQZcyCoI9
+zx777I1tPUOl1Q1ass3T7lYsTN8QADmW5zjJn4MJPMQ55qoQUL7HVQR4VJ/ELAXu
+xGkQlJFBY5q0Qq6buN102D2upNKXKpDYYPc0OgyJ73fR2+rzQapc52QD4Oh6cbD8
+Fh5Vh/qGNMckh1cQsVm6fRtlkoUqxANZk58rqkEwOuk04p7vlnVvZTidOng7G2nW
+1n7YQXCycI+JhofCqOqT9x8CAwEAATANBgkqhkiG9w0BAQsFAAOCAQEATx5GZCxU
+KKQCDsafzAwoodbjRlpsJhvdCBGpgMrFTPyQo7BNF/E2XyVCDXbCmbxTRlhFafJG
+Loj/73toGkU8+1qUIy/Fffsmeh9YCyMlA2bE+85ccMCVKgCIEx0+fa6Au6/Ref7/
+n7vN/9deJzxWUaNbP26LNq3prbuIbKN6WFNT5mR8HLTmP3O45sqy1jwOZgSwvbgH
+bhugE4tSsKghMV5rUgiMhGIrEakFH+1LCZjQh+ojcWWEWyVk3QTQMmSd6tAZf4pb
+/Y1GuN6DAiLfzbabUQZCeQ1iZcgrwIOGHWJUPAf+BTPcFLlR3k/kYA9lrqvra7ln
+dFIuUv3YzfenfA==
-----END CERTIFICATE-----
diff --git a/ceph/src/civetweb/resources/cert/server.csr b/ceph/src/civetweb/resources/cert/server.csr
index 7b74b8679..fe5f3fc80 100644
--- a/ceph/src/civetweb/resources/cert/server.csr
+++ b/ceph/src/civetweb/resources/cert/server.csr
@@ -1,11 +1,16 @@
-----BEGIN CERTIFICATE REQUEST-----
-MIIBoTCCAQoCAQAwYTELMAkGA1UEBhMCeHgxCzAJBgNVBAgMAnh4MQswCQYDVQQH
-DAJ4eDELMAkGA1UECgwCeHgxCzAJBgNVBAsMAnh4MQswCQYDVQQDDAJ4eDERMA8G
-CSqGSIb3DQEJARYCeHgwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAL6/Z3jJ
-7wGAMady+4I2cmjK3SVx0SLCuIaRbv7p5TwJPCB0kaZVmt4j1eiUO5/Nw8a1y7kS
-XVd3CXNxo0H6JC4l9eqh2+RvDjcDzSxa0Nm5otVtL3ECv7aYSoKDj8lgpEPLzTLd
-FnrRLaq8HmOEpvWCOhst7r1VdT5qJ9m0josbAgMBAAGgADANBgkqhkiG9w0BAQsF
-AAOBgQC3a+xFpygFx3Guq9XRZSbkNX2BlktaKD45qU51E0Ayt75T8iXnpeJV2Y1z
-2zjJBPWePdsa6vvHl/gx5oCyHfr8Vzs7AIojtcbKltWesdoJMuhbhPC7434vnYYm
-fFXzVcrfuCx6V9YGlbgtGYmItUxyvkmML00XRO7+MJy64aQiCg==
+MIICijCCAXICAQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUx
+ITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBALUmHEoJcebkUOyqEAhH2OdEuTTk8AxjjVvq9B1d
+Xjlf/dvxGnZX2InScGCJA9UykO1XI8nLXKAGl6OL9jDt/0K3/oFLedDLtZf1qE+k
+EBuaqAgL+VVAPqwtQZcyCoI9zx777I1tPUOl1Q1ass3T7lYsTN8QADmW5zjJn4MJ
+PMQ55qoQUL7HVQR4VJ/ELAXuxGkQlJFBY5q0Qq6buN102D2upNKXKpDYYPc0OgyJ
+73fR2+rzQapc52QD4Oh6cbD8Fh5Vh/qGNMckh1cQsVm6fRtlkoUqxANZk58rqkEw
+Ouk04p7vlnVvZTidOng7G2nW1n7YQXCycI+JhofCqOqT9x8CAwEAAaAAMA0GCSqG
+SIb3DQEBCwUAA4IBAQCbJgy8LBoI+XCliwPGVM+ZuxEVuR15iaUSX7epuKb4jvyC
+y2+YQnNyxLkK8Bu2z9uxXUBbmhqXNiXZd7/SnbTR9MGMq3vyYg6Ggypo24DWez04
+tFaUiLJZsKVoVM6DP3zwpaKKSSJILU2GbNQKW87PHIPSdmAEh+gFD2Uy5sFrvuFJ
+LtHfIMMAhMSoEMjmjaLI7N4GVgFhGEr5q5HGpLuAU8cKGyKPkIkSyYN5Ott4u22d
+rpASF3TXfCJJ0YiM84U86rhZ0BrMqrVtw8r3uj+4G7hrE92eBU+DDn1D8jWzbyVc
+6dlTZaknMeJqsQe2/vq+T5P2yl+/39TnlvDO+cS2
-----END CERTIFICATE REQUEST-----
diff --git a/ceph/src/civetweb/resources/cert/server.key b/ceph/src/civetweb/resources/cert/server.key
index 596659fbf..bd010effb 100644
--- a/ceph/src/civetweb/resources/cert/server.key
+++ b/ceph/src/civetweb/resources/cert/server.key
@@ -1,15 +1,27 @@
-----BEGIN RSA PRIVATE KEY-----
-MIICXgIBAAKBgQC+v2d4ye8BgDGncvuCNnJoyt0lcdEiwriGkW7+6eU8CTwgdJGm
-VZreI9XolDufzcPGtcu5El1XdwlzcaNB+iQuJfXqodvkbw43A80sWtDZuaLVbS9x
-Ar+2mEqCg4/JYKRDy80y3RZ60S2qvB5jhKb1gjobLe69VXU+aifZtI6LGwIDAQAB
-AoGBAJkeyzASYhNBVhrGWZGopWTr3GSPnkOaLkiP/JsTJVpxS1v+V2E//Obvu2pN
-fCOHKO6dxyEU1es9ek+63EQ9ScaCaaZtqyi8NcttRTXYFcXwl7OZx6DnKSIa7mZA
-Z1HFzpZAlCqbh3gf1gGeMlJWEK+qxiDkBXq+pGWeOS2BzPDhAkEA6yHbw/YUmFCa
-ng1+EPBCkUTCJudiexnPQF+xlhgW68i11V4W5pLpXYt1PfN1qzw57+VgS+lowGIr
-Y4BuRWGciwJBAM+tI88SnygdGZUFCp3FQK4/+QUH7tkJvqmhiW0gaIo8yxRzbK7e
-wqV3csy4ov9LYH7kVvFE82VvUIpA4f3izbECQH4EY3gfBuKrMHLM4GfLnKGmrDeV
-gx5essjZgJ/kwUQVCf8UsklZK2FLQMa3GLVxTcvYr0eADPgupPpq9q6QpgkCQQCt
-ksFGFgNN7JxwD4mi+bUorjE8Qjgf0GQ5tNh+i8K0H0GAs0QYF/jJgT9C2eLpyx84
-jzIXbxCbK+E93CLGJuTRAkEA4LdI5JSUMX4IxVHSsfsHYT4kP3XmONlDW/TzWfK2
-jyDiFOS7lfIe08zeSxdxdpF4y9Y1eGKOjls5y5u7KtV2ug==
+MIIEpAIBAAKCAQEAtSYcSglx5uRQ7KoQCEfY50S5NOTwDGONW+r0HV1eOV/92/Ea
+dlfYidJwYIkD1TKQ7VcjyctcoAaXo4v2MO3/Qrf+gUt50Mu1l/WoT6QQG5qoCAv5
+VUA+rC1BlzIKgj3PHvvsjW09Q6XVDVqyzdPuVixM3xAAOZbnOMmfgwk8xDnmqhBQ
+vsdVBHhUn8QsBe7EaRCUkUFjmrRCrpu43XTYPa6k0pcqkNhg9zQ6DInvd9Hb6vNB
+qlznZAPg6HpxsPwWHlWH+oY0xySHVxCxWbp9G2WShSrEA1mTnyuqQTA66TTinu+W
+dW9lOJ06eDsbadbWfthBcLJwj4mGh8Ko6pP3HwIDAQABAoIBAGgaacGGogW+Cl+n
+8CTCHX3y+bjTJL0J7S/426eQg9jXOI3QhpOiMlgqLtjbhO9d6vnqzS9oBmgUwcqE
+YcyGyd5u3P0zAeOjXk3hKIP0Vil2/L/7GaQLkrjiHUKlyHJG0SQORUiVkdKxl7nf
++Mfe1qaBOQAsMuTluyXggSIOCfT+FdHoi6nr/+Nugyx7e/UrZ3GWHVbh8KXOlvHh
+kETfcI6KUkWKtE+YJx9w89Bjh8TBvU0nkOntR11T2SMNllyIS9nND8pqa7QPz3N0
+Ag/iN4Wh8S5f4Nn4GccAOtIORuYuw9Pmt1E9dFWEna1fGztBHlClFQPOLUhZ+/zR
+MfQV5bkCgYEA3pQTLZ5ldX1Kvg5sYw63wwewr147R0pav6AoJ8HTnWGqi5y485CX
+uKE/IcJseidG9FmkO7rfexQaBtW9eW0GCVru416VSP9g2r1iUu0ViaqctYt7ZacE
+UEI+g4FmaXHyn1CKTjJXgUAdoDbtlyHwLmLmNt+B3zKGa1lPIb5MwdMCgYEA0Fl7
+VCTnmdyFH8m/bK76uW7SgkYmKYd5AvDr2QFCSqY3tdZh2VIukoUPmheCFq0kpDc0
++eT680rF/m6CCu+00nM6v/3TNARRANeQ2G73kTPpyiphE+ttKCBQ/tke3TcHQA85
+7cI6bfkMonyKi0JRdLs4QEWf86Avr6p6JKdQWgUCgYEA3oAT8+SF9D89umRcwWFz
+HcnQPF7sz0VrFmiZ+7RtQMTjYhFXalQ+91hp7euX2TzuV1JNNVCIG1dq9S4x7PKp
+uCxo5m4kugZg4gm0AsXyY95kLa+zuViOnVS7fWab5Aj+y3gN6kG07AYWF5URSaWp
+nhVLocso3uB5M1LiIg9EV/UCgYBNrN6Wyz9xFE6pQDzWlxGwakme+eomV3RdDVbQ
+S3DchcWFTEykicgFJghgCV2deKWNd2uPsreAVqMkLSzcSOuf/gesJkREQ0uzxaoh
+lpVDlBgYH96bX40NhabMrEOec3KHhmWxZ1UDRPNZ7JZ2Pp5Bp77b71knqdO9aRAq
+dBo3xQKBgQCnxheQbozuzPO/6nixAng1GP1GuuB2bVb4e5Z0+0dt2RfI8+MSqnSL
+q9Yr2+p/fJFkVthrOUYwJkMf7ujhK2uNCJ7aKmwHPSIRztNV3UDGFd9wgpj3Pebx
+36ahCvDzidTEG+EEra6zPJ1An3KEbPsfXwcy1NVEZ/kFQyzczL0AOw==
-----END RSA PRIVATE KEY-----
diff --git a/ceph/src/civetweb/resources/cert/server.key.orig b/ceph/src/civetweb/resources/cert/server.key.orig
index 7260533ec..e99f08e8f 100644
--- a/ceph/src/civetweb/resources/cert/server.key.orig
+++ b/ceph/src/civetweb/resources/cert/server.key.orig
@@ -1,18 +1,30 @@
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
-DEK-Info: DES-EDE3-CBC,6BB8D380C900AA8B
+DEK-Info: DES-EDE3-CBC,9D77FEDB1409D1BC
-+p0gAY1fa9vtz8lmaTgJClsSVhD9Aw/SL0raL8w90e3yYFnT948s5xLPxoz+c3V1
-CkdWcatZO72G1VVOlg1NyjYmujBntkvMF4DiAGAg9l/u19wrvYNINurb86uPsZ2P
-9S6SlEzIkuRDdnJXXwT/bpgEYoTVIpOQYMjzIcdYbseaYhy7n9uZCXQLgXChjiuf
-LNbArHcB5tJC8QK9DCv4iEV6U8udSd85gs2xs4dBs4dz2jpgD3GLpSMd6+LNSNOV
-AqWZM6Xa0PtM9Mlz2JkX+misfY5wR2lqs2z6f6JFIZsLjr3buqUJVNXRTcSLZ7A2
-e/RgE8wC3VVX9ij+7yh3dBKNorJF1nLcSkfTt22OXyppbwIwHKI1RYPc6a6GNZEW
-ecZlnuHueUc62e8L8lm6dPtJ5Z4SR6hBBqPOBxNxgEGvt7Gc3jPO7SkqmXatVJ2k
-S3HI2umA0f3grolkeJGXlaabRb0z+C13nvBSEDog2Sg2uFu3gwEOXsCfI+EaOghp
-earIkirAlasVtFGKwUn0eMVLBrsxvr1yz6y7PnY63kTVkh2JPoOQ/hCO+9bfdIvS
-7Sa+pbL29OXSNnt/WDsErKcMTPPAstuz0an1Q7dA7G+3FW7UsLWbYh5sMklHiG8L
-u5NC4M4/+oqq0Bv/rYROOSmIc7XRbZ38hep2ML9WHC/zdMssSph4lY/TnMNGqSQ/
-wyRmuT0VmLBQFlFvO41YD97yJD5uEsu+dMH0fsfIJ36U2T1YmJEJU5YOfpE/iGdf
-2LuFKRU0TMfwiosxi1Geef6RC/9ADaIuda6aIvfMheAZ7b8Xy3vuvQ==
+uC330C4tHeQ7HAGqwIlcTtZia9xbCwMAkUn/PJxdsRqk+vZ3NcheeWdSbq9BMioM
+06Vl0DtlhfAr4kF/IDhRCkUsLafPFaiDoAiSjZx9xOoCpSdJTe8W19vq6bf9nE1t
+WKLR7Ot73E5Qinzpon0ewqia3bDgAgZsE4o99HmXKHghlSPV2we6ROMWn3QfoEfE
+tTCIhDrgsrCobrMtDdlzTe6FHACc5nrVloq9LCynuoig2/W1eGS0WVPWMMuo09Qn
+UQbjANNSfZcSWZTg1ynCqk74W1X/0hPo2/FpEPIV3K4ZykKbqgB4HIerZ/sJO2LF
+g5KtRBtyqj/OsTs+v8i2eEtMYEbz17oJfgL8e2R+AD8QKWjEWrgS5R71LrCgX+v3
++lOANQi+xIaz45h6StnH52Yl+4iQ4KyaKquJ7ZKRJDfKw41SOSAYCUIkm9AGIqN2
+/WHxfDCaJEN4da890AwmEtzIlVf5TRcJYRpCtxP4kNihrjjQddV+LYdg09nMgcoZ
+zVk5eXLh6cg0KzKTDbM3AUmedmrj6R+diyE8zkJKKfStJcejhjTB8KxAIsg+JFFj
+tnWUv6dHfPq/K3qbMGqJyuST9pjW9xBiIbscc4HOLmfpJHcClYEbDgPbAqnDp8p9
+nAkI1LFqwpix7rKvFsqWgt8B9TCrxdUqKnDYUNXt/9C1o8ZR8muaH1Jpp8xCjve3
+XpTAMj9HVE/pRkySn8YHvehnMK9+UdCy1sO4RoF5qn881sgetDIoZ/825u4erDVf
+Az20D0TZ9wBz+BG0MW8DxdOJmKjpW2ew0RlkG9mcMvKvkcl0XbKFqpF1ZqNQxMTt
+Gw1Ef5Hu9j+ijpBKb/4Pk7xeC6OaYdu9NxzYQtpC5aCKXwca8VlykBlPFGrN3eBV
+wrsQ+aEv+Cf0bziGHPhili5eNRW8F53LqKF9WdmAAHdOPNZR5PHL8FudNRV77pcY
+0bXiY3cHD/YnUpXWZYqU3qDabwtExugImYzLrVg+BSZROwvUYwgKmcrTpx6lJjcv
+ntoC26QVKAHhnaclBjGZKl0Q+pYZwR0TxEMPiKLe47TBcYTwj8GNrLk1Lf/VJcaz
+lntXsqVjCkwT7cFYfeb8XOvBlrTYQA0LlEHbTn9VTwRiM5O2JB0nzoC2q8LXlzki
+wC5AECcUhzh2zpVuLB/FttxPT37a3ibJBkX0UHf7CsPoR/FnEYKL6Bytp6bovUYy
+Ed3L/DWdGCB0+tMX0+GBcaxAz/Fqe++Hp9FvZx+ob6k86FC50x2lRPRk3jZmmcCp
+W1mub0DK1Pbdh2cutmutbqXF5R2bWpK9lRb5jiSJuQPODTLS5TQjnwVYmqv9qszv
+lnJ54HtfrMfKIEqE9mzBfJ4agsHXG2HLrsmRzF6jflleeJddLKqJJ7U8sGjwlJAS
+0NIKtWmw5kpRKStbLDX+uGuWLQfM4ITX33fIRlujvbeJcFwtmM4i4sJC1yYYOvLQ
+aHV46KNkTVYouKMpJVvGWfXfcV90gbD3pYtkN8YAjswtWoQAnOLFwFJrM0HORkpU
+173uMGgOA/EoBhS0XQd6k1+y00JPGky8GSWUEPKDoqX/uZl8POO7VcbAtV41Wkq8
-----END RSA PRIVATE KEY-----
diff --git a/ceph/src/civetweb/resources/cert/server.pem b/ceph/src/civetweb/resources/cert/server.pem
index f48a239d9..9a0027c17 100644
--- a/ceph/src/civetweb/resources/cert/server.pem
+++ b/ceph/src/civetweb/resources/cert/server.pem
@@ -1,29 +1,46 @@
-----BEGIN CERTIFICATE-----
-MIICOTCCAaICCQCWJSBNug1UmTANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJ4
-eDELMAkGA1UECAwCeHgxCzAJBgNVBAcMAnh4MQswCQYDVQQKDAJ4eDELMAkGA1UE
-CwwCeHgxCzAJBgNVBAMMAnh4MREwDwYJKoZIhvcNAQkBFgJ4eDAeFw0xNTEwMjUy
-MzMyMTVaFw0yNTEwMjIyMzMyMTVaMGExCzAJBgNVBAYTAnh4MQswCQYDVQQIDAJ4
-eDELMAkGA1UEBwwCeHgxCzAJBgNVBAoMAnh4MQswCQYDVQQLDAJ4eDELMAkGA1UE
-AwwCeHgxETAPBgkqhkiG9w0BCQEWAnh4MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB
-iQKBgQC+v2d4ye8BgDGncvuCNnJoyt0lcdEiwriGkW7+6eU8CTwgdJGmVZreI9Xo
-lDufzcPGtcu5El1XdwlzcaNB+iQuJfXqodvkbw43A80sWtDZuaLVbS9xAr+2mEqC
-g4/JYKRDy80y3RZ60S2qvB5jhKb1gjobLe69VXU+aifZtI6LGwIDAQABMA0GCSqG
-SIb3DQEBCwUAA4GBAHGVbKEyEIHUYZGGTzmKdQjdeomycKqh0/lgN4LUOFZLpUIb
-Ic26ZAWL3x571i05qz90AFUXEx30o0aVRYjvtSDyIlID4Niz9Cy8s8vNIDSocEAG
-bzBQ9xgFYjMEcgm2ROkzE6xdyxNOHkPA4jXjqgQknyvtkHcPE7mpv7faZXFz
+MIIDBjCCAe4CCQDDIH/hK1C0BjANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJB
+VTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
+cyBQdHkgTHRkMB4XDTE3MDkwMzE5MjIyOVoXDTI3MDkwMTE5MjIyOVowRTELMAkG
+A1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0
+IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+ALUmHEoJcebkUOyqEAhH2OdEuTTk8AxjjVvq9B1dXjlf/dvxGnZX2InScGCJA9Uy
+kO1XI8nLXKAGl6OL9jDt/0K3/oFLedDLtZf1qE+kEBuaqAgL+VVAPqwtQZcyCoI9
+zx777I1tPUOl1Q1ass3T7lYsTN8QADmW5zjJn4MJPMQ55qoQUL7HVQR4VJ/ELAXu
+xGkQlJFBY5q0Qq6buN102D2upNKXKpDYYPc0OgyJ73fR2+rzQapc52QD4Oh6cbD8
+Fh5Vh/qGNMckh1cQsVm6fRtlkoUqxANZk58rqkEwOuk04p7vlnVvZTidOng7G2nW
+1n7YQXCycI+JhofCqOqT9x8CAwEAATANBgkqhkiG9w0BAQsFAAOCAQEATx5GZCxU
+KKQCDsafzAwoodbjRlpsJhvdCBGpgMrFTPyQo7BNF/E2XyVCDXbCmbxTRlhFafJG
+Loj/73toGkU8+1qUIy/Fffsmeh9YCyMlA2bE+85ccMCVKgCIEx0+fa6Au6/Ref7/
+n7vN/9deJzxWUaNbP26LNq3prbuIbKN6WFNT5mR8HLTmP3O45sqy1jwOZgSwvbgH
+bhugE4tSsKghMV5rUgiMhGIrEakFH+1LCZjQh+ojcWWEWyVk3QTQMmSd6tAZf4pb
+/Y1GuN6DAiLfzbabUQZCeQ1iZcgrwIOGHWJUPAf+BTPcFLlR3k/kYA9lrqvra7ln
+dFIuUv3YzfenfA==
-----END CERTIFICATE-----
-----BEGIN RSA PRIVATE KEY-----
-MIICXgIBAAKBgQC+v2d4ye8BgDGncvuCNnJoyt0lcdEiwriGkW7+6eU8CTwgdJGm
-VZreI9XolDufzcPGtcu5El1XdwlzcaNB+iQuJfXqodvkbw43A80sWtDZuaLVbS9x
-Ar+2mEqCg4/JYKRDy80y3RZ60S2qvB5jhKb1gjobLe69VXU+aifZtI6LGwIDAQAB
-AoGBAJkeyzASYhNBVhrGWZGopWTr3GSPnkOaLkiP/JsTJVpxS1v+V2E//Obvu2pN
-fCOHKO6dxyEU1es9ek+63EQ9ScaCaaZtqyi8NcttRTXYFcXwl7OZx6DnKSIa7mZA
-Z1HFzpZAlCqbh3gf1gGeMlJWEK+qxiDkBXq+pGWeOS2BzPDhAkEA6yHbw/YUmFCa
-ng1+EPBCkUTCJudiexnPQF+xlhgW68i11V4W5pLpXYt1PfN1qzw57+VgS+lowGIr
-Y4BuRWGciwJBAM+tI88SnygdGZUFCp3FQK4/+QUH7tkJvqmhiW0gaIo8yxRzbK7e
-wqV3csy4ov9LYH7kVvFE82VvUIpA4f3izbECQH4EY3gfBuKrMHLM4GfLnKGmrDeV
-gx5essjZgJ/kwUQVCf8UsklZK2FLQMa3GLVxTcvYr0eADPgupPpq9q6QpgkCQQCt
-ksFGFgNN7JxwD4mi+bUorjE8Qjgf0GQ5tNh+i8K0H0GAs0QYF/jJgT9C2eLpyx84
-jzIXbxCbK+E93CLGJuTRAkEA4LdI5JSUMX4IxVHSsfsHYT4kP3XmONlDW/TzWfK2
-jyDiFOS7lfIe08zeSxdxdpF4y9Y1eGKOjls5y5u7KtV2ug==
+MIIEpAIBAAKCAQEAtSYcSglx5uRQ7KoQCEfY50S5NOTwDGONW+r0HV1eOV/92/Ea
+dlfYidJwYIkD1TKQ7VcjyctcoAaXo4v2MO3/Qrf+gUt50Mu1l/WoT6QQG5qoCAv5
+VUA+rC1BlzIKgj3PHvvsjW09Q6XVDVqyzdPuVixM3xAAOZbnOMmfgwk8xDnmqhBQ
+vsdVBHhUn8QsBe7EaRCUkUFjmrRCrpu43XTYPa6k0pcqkNhg9zQ6DInvd9Hb6vNB
+qlznZAPg6HpxsPwWHlWH+oY0xySHVxCxWbp9G2WShSrEA1mTnyuqQTA66TTinu+W
+dW9lOJ06eDsbadbWfthBcLJwj4mGh8Ko6pP3HwIDAQABAoIBAGgaacGGogW+Cl+n
+8CTCHX3y+bjTJL0J7S/426eQg9jXOI3QhpOiMlgqLtjbhO9d6vnqzS9oBmgUwcqE
+YcyGyd5u3P0zAeOjXk3hKIP0Vil2/L/7GaQLkrjiHUKlyHJG0SQORUiVkdKxl7nf
++Mfe1qaBOQAsMuTluyXggSIOCfT+FdHoi6nr/+Nugyx7e/UrZ3GWHVbh8KXOlvHh
+kETfcI6KUkWKtE+YJx9w89Bjh8TBvU0nkOntR11T2SMNllyIS9nND8pqa7QPz3N0
+Ag/iN4Wh8S5f4Nn4GccAOtIORuYuw9Pmt1E9dFWEna1fGztBHlClFQPOLUhZ+/zR
+MfQV5bkCgYEA3pQTLZ5ldX1Kvg5sYw63wwewr147R0pav6AoJ8HTnWGqi5y485CX
+uKE/IcJseidG9FmkO7rfexQaBtW9eW0GCVru416VSP9g2r1iUu0ViaqctYt7ZacE
+UEI+g4FmaXHyn1CKTjJXgUAdoDbtlyHwLmLmNt+B3zKGa1lPIb5MwdMCgYEA0Fl7
+VCTnmdyFH8m/bK76uW7SgkYmKYd5AvDr2QFCSqY3tdZh2VIukoUPmheCFq0kpDc0
++eT680rF/m6CCu+00nM6v/3TNARRANeQ2G73kTPpyiphE+ttKCBQ/tke3TcHQA85
+7cI6bfkMonyKi0JRdLs4QEWf86Avr6p6JKdQWgUCgYEA3oAT8+SF9D89umRcwWFz
+HcnQPF7sz0VrFmiZ+7RtQMTjYhFXalQ+91hp7euX2TzuV1JNNVCIG1dq9S4x7PKp
+uCxo5m4kugZg4gm0AsXyY95kLa+zuViOnVS7fWab5Aj+y3gN6kG07AYWF5URSaWp
+nhVLocso3uB5M1LiIg9EV/UCgYBNrN6Wyz9xFE6pQDzWlxGwakme+eomV3RdDVbQ
+S3DchcWFTEykicgFJghgCV2deKWNd2uPsreAVqMkLSzcSOuf/gesJkREQ0uzxaoh
+lpVDlBgYH96bX40NhabMrEOec3KHhmWxZ1UDRPNZ7JZ2Pp5Bp77b71knqdO9aRAq
+dBo3xQKBgQCnxheQbozuzPO/6nixAng1GP1GuuB2bVb4e5Z0+0dt2RfI8+MSqnSL
+q9Yr2+p/fJFkVthrOUYwJkMf7ujhK2uNCJ7aKmwHPSIRztNV3UDGFd9wgpj3Pebx
+36ahCvDzidTEG+EEra6zPJ1An3KEbPsfXwcy1NVEZ/kFQyzczL0AOw==
-----END RSA PRIVATE KEY-----
diff --git a/ceph/src/civetweb/resources/cert/server.pfx b/ceph/src/civetweb/resources/cert/server.pfx
deleted file mode 100644
index e334a6a59..000000000
Binary files a/ceph/src/civetweb/resources/cert/server.pfx and /dev/null differ
diff --git a/ceph/src/civetweb/resources/cert/server.pin b/ceph/src/civetweb/resources/cert/server.pin
new file mode 100644
index 000000000..015792a47
--- /dev/null
+++ b/ceph/src/civetweb/resources/cert/server.pin
@@ -0,0 +1 @@
+uz1UTAPen+xb+UoQqkVlEx4H653LbMjfRJcZx5OrjbI=
diff --git a/ceph/src/civetweb/resources/cert/server_bkup.crt b/ceph/src/civetweb/resources/cert/server_bkup.crt
new file mode 100644
index 000000000..afe0d5dd0
--- /dev/null
+++ b/ceph/src/civetweb/resources/cert/server_bkup.crt
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDBjCCAe4CCQCFKfFGF1i10TANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJB
+VTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
+cyBQdHkgTHRkMB4XDTE3MDkwMzE5MjI1MVoXDTI3MDkwMTE5MjI1MVowRTELMAkG
+A1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0
+IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+AKTJr3PzWOR1Hrjfk9bBA7TptI1hNYVn/Xvi2GSferhJaWg69b2Li4t5/JxElESR
+8fy0lBMzQ/yaFiQb51y7Q1c+Z6xWLxk322rfy3WhU3DYiFL2sJndrDvAhmso122Z
+xVADA0cQwo520MgFYpHNBF8BcFV2IRukzVX+/nVkki05XcwfbI2y6gqCRpOSXdE9
+gCDVan3tSRbtrwKu7IHy88mL6057o82Uezpl0KesoCwb4f5oqs2vThUmXKuxu8GO
+WpZNK4JFWnTgDOJrubZvKxzzL9E85DS9aXLk6dNKBJVKPCETnYw+2ArMgXzs+JuA
+C4AhV0e6unLX9DcavZ6j7JcCAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAJJWqVuQs
+guFZG/LZPeeh1WtZr9S6R5BT4+b+PH2teVyGtClXV6KpwcLNEVWzY3qPtrFFPQI1
+uEg6cY8w1JOiCmj/IWKsiHd+IdsqsFVKL+Bmvthm3HSgA6p6ZiVCG4E67p8xwiJP
+p5EwtMM/7BdS/tHLUOe1OpNZ8XtHRVUNbzy/+JV0So7WLP9ksGb6COL/9MF0/qG4
+4XrrvpZ9FAgRC9/22QyYiQqoaegGEy4E+KHOBxRmipInsU2H8aQA2sZzQ49Zew9E
+QI2jSJTC7EeuZ0OcZawKkJY1ZtIGmOo/Q956keOLdG8cxyq6pXW3gmq1X5QBxy1M
+pZYi5eIENGE63g==
+-----END CERTIFICATE-----
diff --git a/ceph/src/civetweb/resources/cert/server_bkup.csr b/ceph/src/civetweb/resources/cert/server_bkup.csr
new file mode 100644
index 000000000..c866b57df
--- /dev/null
+++ b/ceph/src/civetweb/resources/cert/server_bkup.csr
@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIICijCCAXICAQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUx
+ITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBAKTJr3PzWOR1Hrjfk9bBA7TptI1hNYVn/Xvi2GSf
+erhJaWg69b2Li4t5/JxElESR8fy0lBMzQ/yaFiQb51y7Q1c+Z6xWLxk322rfy3Wh
+U3DYiFL2sJndrDvAhmso122ZxVADA0cQwo520MgFYpHNBF8BcFV2IRukzVX+/nVk
+ki05XcwfbI2y6gqCRpOSXdE9gCDVan3tSRbtrwKu7IHy88mL6057o82Uezpl0Kes
+oCwb4f5oqs2vThUmXKuxu8GOWpZNK4JFWnTgDOJrubZvKxzzL9E85DS9aXLk6dNK
+BJVKPCETnYw+2ArMgXzs+JuAC4AhV0e6unLX9DcavZ6j7JcCAwEAAaAAMA0GCSqG
+SIb3DQEBCwUAA4IBAQBvbql7sAA8XOwsszRUzOCLkFxfDsWJ0l5re2mGgHTEd5hc
+eDfM+Vdy8SVZX9OySdioVD6ACTse3rc1ULYn8jj1wvOd3/z/J9aUBcBACJG5D1Dl
++j+xvfhvgAGCEQn7ZMaWLFWrLs++aQ+EKbl0SypEI2rTJkyZlYSDVpa+LhqX4UOa
++RNlq1CX+85HCjBn0sWBNzhjrf3gwERRn5NfTab4FqwqGp2+s4GvbOJHrm8saMWu
+BlhcTzGGLBRKCQUHo5i9393b3oBOqtcpWPcZGhyAF1NUbYL7USnsiH6lkGReeaFi
+xy7vYmUn9j//vT64SmASG0oF+ecUF0q2W42sSqnU
+-----END CERTIFICATE REQUEST-----
diff --git a/ceph/src/civetweb/resources/cert/server_bkup.key b/ceph/src/civetweb/resources/cert/server_bkup.key
new file mode 100644
index 000000000..235c83a79
--- /dev/null
+++ b/ceph/src/civetweb/resources/cert/server_bkup.key
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEApMmvc/NY5HUeuN+T1sEDtOm0jWE1hWf9e+LYZJ96uElpaDr1
+vYuLi3n8nESURJHx/LSUEzND/JoWJBvnXLtDVz5nrFYvGTfbat/LdaFTcNiIUvaw
+md2sO8CGayjXbZnFUAMDRxDCjnbQyAVikc0EXwFwVXYhG6TNVf7+dWSSLTldzB9s
+jbLqCoJGk5Jd0T2AINVqfe1JFu2vAq7sgfLzyYvrTnujzZR7OmXQp6ygLBvh/miq
+za9OFSZcq7G7wY5alk0rgkVadOAM4mu5tm8rHPMv0TzkNL1pcuTp00oElUo8IROd
+jD7YCsyBfOz4m4ALgCFXR7q6ctf0Nxq9nqPslwIDAQABAoIBAE/B7lHIrnWk2kHQ
+tNV0hj7B/smPC0COnHmhyeqp5dPcdFAmeVpMeDYBzOo1py2pFd6h6CmC3p0cVysS
+9mBDosxPQA6BiDpEdsa7mtZMRv6PTywYilFuoTYqcOTc16gMjRu02ZlD22boyxSE
+xria6kqxf5Vdn5ipo1jEGpTnIHkSS+Y8CetCaYgcezLaXlXN3RyjF6tCHMeS3iLl
+/zY2O4avG2BM+vvDGDW2FWtZg+hN+5Yk90Qt8dFTwvWRCfYaSWfi7id91p5X0rnL
+x1G07qw18LziKJj4HZiueqbDcDOYhfcA6sd0OHcvtXfGIoeqkXxi54cIOReRhN2/
+7ib3iUECgYEA2DNH5aiwc5uqTAL9RHTnuuFwQe46onJwnBkho+xEvvdsp2Q2f7VR
+c5M17fL+Rb5gq0O4vzeegKiYpo8gKjFp3Duv9Gdc/TB9sLEEt4NQMD4shV7ihBwC
+Rjsflww45dt0mccFZp1ncDYKWHDFzdhO+WB828FPFh/5dl6S+v4Q9bUCgYEAwx+G
+XhheTMSqoKGVJ283+4bNZWUSE99wcAhx9J3FkJera030mh0OHoCn0myBjRjxOSY/
+eBH8/0YoLkGYvTdEU/tYiLIWJ/ehC0eweXiwDehb5meco6u9WCeYvyPMLErXbe3K
+BQVyfcFzva4eC3dZ7lzxmyVyKXVTYgY0Hf7biJsCgYBKHdJg/eJ3z36jDkdK55Tl
+cRFt2MCLHhZSvR7WNlIe8W1zORyhzUP+DhJn32yh9jDnpZC5JNUWoDWsq9ZIAKac
+1G1uqNytA6mjIBxQ2RhtYXMbybp3ta5l6zDaNFtxGTmw2hSU6BMk2bHUPdzhw2zX
+eudy4qM9H3sCxEs49k5UHQKBgDz7I0FRGFehtznQhg73AWYIsTSZK9cuI7O/z+2F
+SXNxE0/L40AvCHSb/NcUtkBkpS8ZNwjNhmY5hOE/+v5XwXEFwpumHKqNB7XAx/SO
+tWcDUYVmqFu2lsxwQ5qpE2xcT4u5n0OGeku3I/cJ7bXjrSWDwracM1uloVOnYK5n
+MjE1AoGAeM6Wrb0VXRq025+OEfoFis3P9S0REkkkabM9+VLRSWi63uxg2cyipxUg
+qJUThbUm1aSS1F+XWjG7vrDjWT/GQTYj9/CH3mZRflZgLUltVHEZesLwWqn15Gl/
+BDwaV6RN7F3BCSzgEfCutrfGJqxA0tx5TTcupOgwpZVakN+hm3c=
+-----END RSA PRIVATE KEY-----
diff --git a/ceph/src/civetweb/resources/cert/server_bkup.key.orig b/ceph/src/civetweb/resources/cert/server_bkup.key.orig
new file mode 100644
index 000000000..3e227f271
--- /dev/null
+++ b/ceph/src/civetweb/resources/cert/server_bkup.key.orig
@@ -0,0 +1,30 @@
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: DES-EDE3-CBC,E700A7E4CCCF78FC
+
+1/jqqjzwHWxdTvayJ+y//FTMuxZbIOT8hl4h+4zzh+/o45RHUa8n6nTI3mLSIK/i
+6yZqSaPaCiBINcLWmijbeDN73OhVL3rrum1VotcTUTA2LU0M+kLWpmcJrY5lsku2
+2voulXmLoCniup+nhnGXDWOk3jaLsMBOn3kYyVBgphwzGzKinFQnqzo/w6/2pJ/C
+iKb/GWNEuXwHkoTz7A4o1ZVVOQyx8h0klWbwjBEPB+cPE3h/bRTkJWTTy2yfCeUC
+nyRQ1BkWC6I5LLesC7gG0jsw3rcGkJnu+zNkxG43N9CkU74S/jNwktjqzKiSbO14
+SYu/NiaVLCtQTeaTeh39X8OGW4RzFbO32PVBl0jL5d8h3DpvTufbtC9BS9dADM0o
+pwCUVWiKKgApmqhFDyUpQB8ptfLewmp5ksB93NzdlPLV8vojJ7nBOrppaueXKQ6Z
+f380J3xCrVN7pTt/yT3mlvCnmb0gNhL6jAE53C112Upjmu40OBhwjGDjDXsOZBmZ
+NH0KEsLecIPgbx0W27h0j4JDdXGtI4mjFHHEnFj75We73BZ8BIlyRt7nxS+iFYNH
+hpbwuNc4dX953jwPy7CIxyms5cy4BigTv/rsgFWCxWxFcTqYkp6L3z8IC6apJDSp
+htKLzhFKjlXqP3vcwZYrAF26eOl6Pxn74853dRskAZNY5F40/7IjVb8l71tedWof
+WE5wpuXrZJd+GBeIM+plbPCnBiNSHuRzJPhLU3tsT3X70WfDxgIgM38P5uOOBLma
+hU/0wcL8+Q3HESPx5ju+5lYZBmozs5ANwMggXv0a1vBptI/kA0HeMQx52G4m1F+9
+aYRrNc+Exl901Yjn120Y6NllIk5EolsqNifDsems9sTiC91Fvh7yiYI5Pd7qCwoR
+2ssLbWda/+bgqtDXjmv4x1btWhWmbInBpCrp1YEwILlyNN6FQ/sQ8pvHtyC9+FcB
+xQ7wI0JnsCpj8E+P5C08EEgpTiUfelwYyTZLarAFMRe5HWZjgQW7+JvbiQ4Q3ZXM
+/DaYh6zGXvR4OomTqKN63i6iAckS7Uh3/XzaWbjOAxvMIgKhU7OBqDAlPvgXJh1y
+sDig2zTR603AURkWZir2OOr7XKZcqNj8lxt+BG+E6bwxdeIeEQn7f8Ef5oUmFNXQ
+o5zQwI12RDQXaBRDG/wTONrUhvc8TEM04jNGKMRPU6FlZSEF2zlTSU8/QtO56FwR
+MwhPlNUSgWgvqzFWoA4W7XWjAfYqvoVRcLjcZF2WBUJwYq4ZODNqBH+j3+Ftge9l
+wKc/9KjcurpAWbg7gq9XtwgiT8bYHcM3NSOwgnrOJ4wtukuwbLq2JjMLgFQeDAev
+NFJfbYoZ0iTyIq1WRS0MlhAwDKujDOoQLqkF41LC5Ac6RpMeR689xN18YE6b6iXp
+f93tHI+6Ru1I+2ZoGbvCPmasv3jk69C8A/StmUEcFfxmOr5qhQEVR2pIXfXKeqbE
+KCUoR4Wax42q/bDhgIOOmq+E9YsTuy4Iq5J25WDIbgWN35s0qXDm91s+aY0KtDUu
+fxGdOIHQHx10ARHUKZ6AhXSF+q5QQFy4ejlgiTMorvT0XUHmIQ82hw==
+-----END RSA PRIVATE KEY-----
diff --git a/ceph/src/civetweb/resources/cert/server_bkup.pem b/ceph/src/civetweb/resources/cert/server_bkup.pem
new file mode 100644
index 000000000..a409c1435
--- /dev/null
+++ b/ceph/src/civetweb/resources/cert/server_bkup.pem
@@ -0,0 +1,46 @@
+-----BEGIN CERTIFICATE-----
+MIIDBjCCAe4CCQCFKfFGF1i10TANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJB
+VTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
+cyBQdHkgTHRkMB4XDTE3MDkwMzE5MjI1MVoXDTI3MDkwMTE5MjI1MVowRTELMAkG
+A1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0
+IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+AKTJr3PzWOR1Hrjfk9bBA7TptI1hNYVn/Xvi2GSferhJaWg69b2Li4t5/JxElESR
+8fy0lBMzQ/yaFiQb51y7Q1c+Z6xWLxk322rfy3WhU3DYiFL2sJndrDvAhmso122Z
+xVADA0cQwo520MgFYpHNBF8BcFV2IRukzVX+/nVkki05XcwfbI2y6gqCRpOSXdE9
+gCDVan3tSRbtrwKu7IHy88mL6057o82Uezpl0KesoCwb4f5oqs2vThUmXKuxu8GO
+WpZNK4JFWnTgDOJrubZvKxzzL9E85DS9aXLk6dNKBJVKPCETnYw+2ArMgXzs+JuA
+C4AhV0e6unLX9DcavZ6j7JcCAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAJJWqVuQs
+guFZG/LZPeeh1WtZr9S6R5BT4+b+PH2teVyGtClXV6KpwcLNEVWzY3qPtrFFPQI1
+uEg6cY8w1JOiCmj/IWKsiHd+IdsqsFVKL+Bmvthm3HSgA6p6ZiVCG4E67p8xwiJP
+p5EwtMM/7BdS/tHLUOe1OpNZ8XtHRVUNbzy/+JV0So7WLP9ksGb6COL/9MF0/qG4
+4XrrvpZ9FAgRC9/22QyYiQqoaegGEy4E+KHOBxRmipInsU2H8aQA2sZzQ49Zew9E
+QI2jSJTC7EeuZ0OcZawKkJY1ZtIGmOo/Q956keOLdG8cxyq6pXW3gmq1X5QBxy1M
+pZYi5eIENGE63g==
+-----END CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEApMmvc/NY5HUeuN+T1sEDtOm0jWE1hWf9e+LYZJ96uElpaDr1
+vYuLi3n8nESURJHx/LSUEzND/JoWJBvnXLtDVz5nrFYvGTfbat/LdaFTcNiIUvaw
+md2sO8CGayjXbZnFUAMDRxDCjnbQyAVikc0EXwFwVXYhG6TNVf7+dWSSLTldzB9s
+jbLqCoJGk5Jd0T2AINVqfe1JFu2vAq7sgfLzyYvrTnujzZR7OmXQp6ygLBvh/miq
+za9OFSZcq7G7wY5alk0rgkVadOAM4mu5tm8rHPMv0TzkNL1pcuTp00oElUo8IROd
+jD7YCsyBfOz4m4ALgCFXR7q6ctf0Nxq9nqPslwIDAQABAoIBAE/B7lHIrnWk2kHQ
+tNV0hj7B/smPC0COnHmhyeqp5dPcdFAmeVpMeDYBzOo1py2pFd6h6CmC3p0cVysS
+9mBDosxPQA6BiDpEdsa7mtZMRv6PTywYilFuoTYqcOTc16gMjRu02ZlD22boyxSE
+xria6kqxf5Vdn5ipo1jEGpTnIHkSS+Y8CetCaYgcezLaXlXN3RyjF6tCHMeS3iLl
+/zY2O4avG2BM+vvDGDW2FWtZg+hN+5Yk90Qt8dFTwvWRCfYaSWfi7id91p5X0rnL
+x1G07qw18LziKJj4HZiueqbDcDOYhfcA6sd0OHcvtXfGIoeqkXxi54cIOReRhN2/
+7ib3iUECgYEA2DNH5aiwc5uqTAL9RHTnuuFwQe46onJwnBkho+xEvvdsp2Q2f7VR
+c5M17fL+Rb5gq0O4vzeegKiYpo8gKjFp3Duv9Gdc/TB9sLEEt4NQMD4shV7ihBwC
+Rjsflww45dt0mccFZp1ncDYKWHDFzdhO+WB828FPFh/5dl6S+v4Q9bUCgYEAwx+G
+XhheTMSqoKGVJ283+4bNZWUSE99wcAhx9J3FkJera030mh0OHoCn0myBjRjxOSY/
+eBH8/0YoLkGYvTdEU/tYiLIWJ/ehC0eweXiwDehb5meco6u9WCeYvyPMLErXbe3K
+BQVyfcFzva4eC3dZ7lzxmyVyKXVTYgY0Hf7biJsCgYBKHdJg/eJ3z36jDkdK55Tl
+cRFt2MCLHhZSvR7WNlIe8W1zORyhzUP+DhJn32yh9jDnpZC5JNUWoDWsq9ZIAKac
+1G1uqNytA6mjIBxQ2RhtYXMbybp3ta5l6zDaNFtxGTmw2hSU6BMk2bHUPdzhw2zX
+eudy4qM9H3sCxEs49k5UHQKBgDz7I0FRGFehtznQhg73AWYIsTSZK9cuI7O/z+2F
+SXNxE0/L40AvCHSb/NcUtkBkpS8ZNwjNhmY5hOE/+v5XwXEFwpumHKqNB7XAx/SO
+tWcDUYVmqFu2lsxwQ5qpE2xcT4u5n0OGeku3I/cJ7bXjrSWDwracM1uloVOnYK5n
+MjE1AoGAeM6Wrb0VXRq025+OEfoFis3P9S0REkkkabM9+VLRSWi63uxg2cyipxUg
+qJUThbUm1aSS1F+XWjG7vrDjWT/GQTYj9/CH3mZRflZgLUltVHEZesLwWqn15Gl/
+BDwaV6RN7F3BCSzgEfCutrfGJqxA0tx5TTcupOgwpZVakN+hm3c=
+-----END RSA PRIVATE KEY-----
diff --git a/ceph/src/civetweb/resources/cert/server_bkup.pin b/ceph/src/civetweb/resources/cert/server_bkup.pin
new file mode 100644
index 000000000..0e0561290
--- /dev/null
+++ b/ceph/src/civetweb/resources/cert/server_bkup.pin
@@ -0,0 +1 @@
+pf3px1MBPmlTGAPoiHWqaSJ9L9Z+DKfwgsU7LfLnmsk=
diff --git a/ceph/src/civetweb/resources/cleanup.lua b/ceph/src/civetweb/resources/cleanup.lua
deleted file mode 100644
index ab9557db8..000000000
--- a/ceph/src/civetweb/resources/cleanup.lua
+++ /dev/null
@@ -1,92 +0,0 @@
--- Lua script used to clean up tabs and spaces in C, CPP and H files.
--- Copyright (c) 2014, bel
--- MIT License (http://opensource.org/licenses/mit-license.php)
---
--- It can be used from the command line:
--- Call Lua5.1 or Lua5.2 + this script file + the C/CPP/H file to clean
---
--- It can be used in Visual Studio as an external tool:
--- command: Lua5.1.exe or Lua5.2.exe
--- argument: "X:\civetweb\resources\cleanup.lua" $(ItemPath)
---
-
-clean = arg[1]
-print("Cleaning " .. clean)
-
-lines = io.lines(clean)
-if not lines then
- print("Can not open file " .. clean)
- return
-end
-
-function trimright(s)
- return s:match "^(.-)%s*$"
-end
-
-local lineend = false
-local tabspace = false
-local changed = false
-local invalid = false
-local newfile = {}
-
-lineno = 0
-incmt = false
-
-for l in lines do
- lineno = lineno + 1
- local lt = trimright(l)
- if (lt ~= l) then
- lineend = true
- changed = true
- end
- local mcmt = l:find("%/%*");
- if mcmt then
- if incmt then
- print("line " .. lineno .. " nested comment")
- end
- if not (l:sub(mcmt):find("%*%/")) then
- -- multiline comment begins here
- incmt = true
- end
- elseif incmt then
- if not l:find("^%s*%*") then
- print("line " .. lineno .. " multiline comment without leading *")
- end
- if l:find("%*%/") then
- incmt = false
- end
- else
- local cmt = l:find("//")
- if (cmt) and (l:sub(cmt-5, cmt+1) ~= "http://") and (l:sub(cmt-6, cmt+1) ~= "https://") then
- print("line " .. lineno .. " has C++ comment //")
- end
- end
- local lts = lt:gsub('\t', ' ')
- if (lts ~= lt) then
- tabspace = true
- changed = true
- end
- for i=1,#lts do
- local b = string.byte(lts,i)
- if b<32 or b>=127 then
- print("Letter " .. string.byte(l,i) .. " (" .. b .. ") found in line " .. lts)
- invalid = true
- end
- end
-
- newfile[#newfile + 1] = lts
-end
-
-print("Line endings trimmed: " .. tostring(lineend))
-print("Tabs converted to spaces: " .. tostring(tabspace))
-print("Invalid characters: " .. tostring(invalid))
-
-if changed then
- local f = io.open(clean, "wb")
- for i=1,#newfile do
- f:write(newfile[i])
- f:write("\n")
- end
- f:close()
- print("File cleaned")
-end
diff --git a/ceph/src/civetweb/resources/coverity_check.sh b/ceph/src/civetweb/resources/coverity_check.sh
old mode 100644
new mode 100755
index 7cb843967..063d7c8c2
--- a/ceph/src/civetweb/resources/coverity_check.sh
+++ b/ceph/src/civetweb/resources/coverity_check.sh
@@ -1,5 +1,6 @@
#! /bin/sh
+# check if we use the correct directory
ls src/civetweb.c
if [ "$?" = "0" ]; then
echo "Building files for coverity check ..."
@@ -9,19 +10,44 @@ else
exit 1
fi
-rm -rf cov_int/
-make clean
+# remove last build
+rm -rf cov_build/
-../cov-analysis-linux64-7.6.0/bin/cov-build --dir cov-int make WITH_IPV6=1 WITH_WEBSOCKET=1 WITH_LUA_SHARED=1
+# copy files to build folder
+mkdir cov_build
+mkdir cov_build/src
+mkdir cov_build/include
+mkdir cov_build/resources
-rm civetweb_coverity_check.tgz
+cp Makefile cov_build/
+cp src/*.c cov_build/src/
+cp src/*.inl cov_build/src/
+cp include/civetweb.h cov_build/include/
+cp resources/Makefile.in-os cov_build/resources/
+
+cd cov_build
+
+# new scan build
+../../cov-analysis-linux64-8.7.0/bin/cov-build --dir cov-int make WITH_IPV6=1 WITH_WEBSOCKET=1 WITH_SERVER_STATS=1
+
+
+# pack build results for upload
tar czvf civetweb_coverity_check.tgz cov-int
+cd ..
+
+# check if the build was successful
echo
-ls -la civetweb_coverity_check.tgz
+ls -la cov_build/civetweb_coverity_check.tgz
if [ "$?" = "0" ]; then
echo "... done"
+ echo
+ echo "submit to https://scan.coverity.com/projects/bel2125-civetweb"
+ echo
+ echo "last commit was"
+ git log -n 1
+ echo
echo
else
echo "No civetweb_coverity_check.tgz file" 1>&2
@@ -29,5 +55,6 @@ else
exit 1
fi
+# return "ok"
exit 0
diff --git a/ceph/src/civetweb/src/CMakeLists.txt b/ceph/src/civetweb/src/CMakeLists.txt
index 7c561797c..a0528b287 100644
--- a/ceph/src/civetweb/src/CMakeLists.txt
+++ b/ceph/src/civetweb/src/CMakeLists.txt
@@ -39,13 +39,17 @@ if (CIVETWEB_ENABLE_WEBSOCKETS AND CIVETWEB_ENABLE_LUA AND LIBRT_FOUND)
endif()
# We need to link OpenSSL if not dynamically loading
-if (CIVETWEB_ENABLE_SLL AND NOT CIVETWEB_ENABLE_OPENSLL_DYNAMIC_LOADING)
- find_package(OpenSSL)
- target_link_libraries(c-library ${OPENSSL_LIBRARIES})
-else()
- find_package(LibDl)
- if (LIBDL_FOUND)
- target_link_libraries(c-library -ldl)
+if (CIVETWEB_ENABLE_SSL)
+ if (CIVETWEB_ENABLE_SSL_DYNAMIC_LOADING)
+ find_package(LibDl)
+ if (LIBDL_FOUND)
+ target_link_libraries(c-library -ldl)
+ endif()
+ else()
+ find_package(OpenSSL)
+ include_directories(${OPENSSL_INCLUDE_DIR})
+ message(STATUS "OpenSSL include directory: ${OPENSSL_INCLUDE_DIR}")
+ target_link_libraries(c-library ${OPENSSL_LIBRARIES})
endif()
endif()
@@ -229,12 +233,14 @@ add_executable(c-executable main.c)
set_target_properties(c-executable PROPERTIES
OUTPUT_NAME "civetweb"
)
-install(
- TARGETS c-executable
- ARCHIVE DESTINATION lib
- LIBRARY DESTINATION lib
- RUNTIME DESTINATION bin
- COMPONENT server)
+if (CIVETWEB_INSTALL_EXECUTABLE)
+ install(
+ TARGETS c-executable
+ ARCHIVE DESTINATION lib
+ LIBRARY DESTINATION lib
+ RUNTIME DESTINATION bin
+ COMPONENT server)
+endif()
if (BUILD_SHARED_LIBS)
target_compile_definitions(c-executable PRIVATE CIVETWEB_DLL_IMPORTS)
endif()
@@ -261,31 +267,31 @@ if (CIVETWEB_ENABLE_LUA)
ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib
RUNTIME DESTINATION bin
- COMPONENT lua-library)
+ COMPONENT lua-library)
endif()
# The C++ API library
if (CIVETWEB_ENABLE_CXX)
- add_library(cxx-library CivetServer.cpp)
- set_target_properties(cxx-library PROPERTIES
- OUTPUT_NAME "cxx-library"
+ add_library(civetweb-cpp CivetServer.cpp)
+ set_target_properties(civetweb-cpp PROPERTIES
+ OUTPUT_NAME "civetweb-cpp"
VERSION ${CIVETWEB_VERSION}
SOVERSION ${CIVETWEB_VERSION}
)
if (BUILD_SHARED_LIBS)
- target_compile_definitions(cxx-library PRIVATE CIVETWEB_DLL_EXPORTS)
+ target_compile_definitions(civetweb-cpp PRIVATE CIVETWEB_DLL_EXPORTS)
endif()
target_include_directories(
- cxx-library PUBLIC
+ civetweb-cpp PUBLIC
${PROJECT_SOURCE_DIR}/include)
install(
- TARGETS cxx-library
+ TARGETS civetweb-cpp
ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib
RUNTIME DESTINATION bin
- COMPONENT cxx-library)
+ COMPONENT civetweb-cpp)
install(FILES
${PROJECT_SOURCE_DIR}/include/CivetServer.h
DESTINATION include
- COMPONENT cxx-library)
+ COMPONENT civetweb-cpp)
endif()
diff --git a/ceph/src/civetweb/src/CivetServer.cpp b/ceph/src/civetweb/src/CivetServer.cpp
index d7d38a5ea..186f18b15 100644
--- a/ceph/src/civetweb/src/CivetServer.cpp
+++ b/ceph/src/civetweb/src/CivetServer.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2014 the Civetweb developers
+/* Copyright (c) 2013-2017 the Civetweb developers
* Copyright (c) 2013 No Face Press, LLC
*
* License http://opensource.org/licenses/mit-license.php MIT License
@@ -269,11 +269,14 @@ CivetCallbacks::CivetCallbacks()
}
CivetServer::CivetServer(const char **options,
- const struct CivetCallbacks *_callbacks)
+ const struct CivetCallbacks *_callbacks,
+ const void *UserContextIn)
: context(0)
{
struct CivetCallbacks callbacks;
+ UserContext = UserContextIn;
+
if (_callbacks) {
callbacks = *_callbacks;
userCloseHandler = _callbacks->connection_close;
@@ -288,11 +291,14 @@ CivetServer::CivetServer(const char **options,
}
CivetServer::CivetServer(std::vector options,
- const struct CivetCallbacks *_callbacks)
+ const struct CivetCallbacks *_callbacks,
+ const void *UserContextIn)
: context(0)
{
struct CivetCallbacks callbacks;
+ UserContext = UserContextIn;
+
if (_callbacks) {
callbacks = *_callbacks;
userCloseHandler = _callbacks->connection_close;
@@ -321,17 +327,16 @@ CivetServer::~CivetServer()
void
CivetServer::closeHandler(const struct mg_connection *conn)
{
- const struct mg_request_info *request_info = mg_get_request_info(conn);
- assert(request_info != NULL);
- CivetServer *me = (CivetServer *)(request_info->user_data);
+ CivetServer *me = (CivetServer *)mg_get_user_data(mg_get_context(conn));
assert(me != NULL);
// Happens when a request hits the server before the context is saved
if (me->context == NULL)
return;
- if (me->userCloseHandler)
+ if (me->userCloseHandler) {
me->userCloseHandler(conn);
+ }
mg_lock_context(me->context);
me->connections.erase(const_cast(conn));
mg_unlock_context(me->context);
@@ -574,11 +579,21 @@ CivetServer::urlEncode(const char *src,
std::vector
CivetServer::getListeningPorts()
{
- std::vector ports(10);
- std::vector ssl(10);
- size_t size = mg_get_ports(context, ports.size(), &ports[0], &ssl[0]);
+ std::vector ports(50);
+ std::vector server_ports(50);
+ int size = mg_get_server_ports(context,
+ (int)server_ports.size(),
+ &server_ports[0]);
+ if (size <= 0) {
+ ports.resize(0);
+ return ports;
+ }
ports.resize(size);
- ssl.resize(size);
+ server_ports.resize(size);
+ for (int i = 0; i < size; i++) {
+ ports[i] = server_ports[i].port;
+ }
+
return ports;
}
diff --git a/ceph/src/civetweb/src/civetweb.c b/ceph/src/civetweb/src/civetweb.c
index 26f1edb06..76f097ac1 100644
--- a/ceph/src/civetweb/src/civetweb.c
+++ b/ceph/src/civetweb/src/civetweb.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2016 the Civetweb developers
+/* Copyright (c) 2013-2017 the Civetweb developers
* Copyright (c) 2004-2013 Sergey Lyubka
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -20,7 +20,6 @@
* THE SOFTWARE.
*/
-
#if defined(_WIN32)
#if !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS /* Disable deprecation warning in VS2005 */
@@ -53,7 +52,7 @@
#endif
#endif
-#if defined(USE_LUA) && defined(USE_WEBSOCKET)
+#if defined(USE_LUA)
#define USE_TIMERS
#endif
@@ -95,8 +94,17 @@ mg_static_assert(sizeof(int) == 4 || sizeof(int) == 8,
mg_static_assert(sizeof(void *) == 4 || sizeof(void *) == 8,
"pointer data type size check");
mg_static_assert(sizeof(void *) >= sizeof(int), "data type size check");
-/* mg_static_assert(sizeof(size_t) == 4 || sizeof(size_t) == 8, "size_t data
- * type size check"); */
+
+
+/* Alternative queue is well tested and should be the new default */
+#ifdef NO_ALTERNATIVE_QUEUE
+#ifdef ALTERNATIVE_QUEUE
+#error "Define ALTERNATIVE_QUEUE or NO_ALTERNATIVE_QUEUE or none, but not both"
+#endif
+#else
+#define ALTERNATIVE_QUEUE
+#endif
+
/* DTL -- including winsock2.h works better if lean and mean */
#ifndef WIN32_LEAN_AND_MEAN
@@ -104,21 +112,58 @@ mg_static_assert(sizeof(void *) >= sizeof(int), "data type size check");
#endif
#if defined(__SYMBIAN32__)
+/* According to https://en.wikipedia.org/wiki/Symbian#History,
+ * Symbian is no longer maintained since 2014-01-01.
+ * Recent versions of CivetWeb are no longer tested for Symbian.
+ * It makes no sense, to support an abandoned operating system.
+ * All remaining "#ifdef __SYMBIAN__" cases will be droped from
+ * the code sooner or later.
+ */
+#pragma message \
+ "Symbian is no longer maintained. CivetWeb will drop Symbian support."
#define NO_SSL /* SSL is not supported */
#define NO_CGI /* CGI is not supported */
#define PATH_MAX FILENAME_MAX
#endif /* __SYMBIAN32__ */
+#ifndef CIVETWEB_HEADER_INCLUDED
/* Include the header file here, so the CivetWeb interface is defined for the
* entire implementation, including the following forward definitions. */
#include "civetweb.h"
+#endif
#ifndef IGNORE_UNUSED_RESULT
#define IGNORE_UNUSED_RESULT(a) ((void)((a) && 1))
#endif
+
+#if defined(__GNUC__) || defined(__MINGW32__)
+
+/* GCC unused function attribute seems fundamentally broken.
+ * Several attempts to tell the compiler "THIS FUNCTION MAY BE USED
+ * OR UNUSED" for individual functions failed.
+ * Either the compiler creates an "unused-function" warning if a
+ * function is not marked with __attribute__((unused)).
+ * On the other hand, if the function is marked with this attribute,
+ * but is used, the compiler raises a completely idiotic
+ * "used-but-marked-unused" warning - and
+ * #pragma GCC diagnostic ignored "-Wused-but-marked-unused"
+ * raises error: unknown option after ‘#pragma GCC diagnostic’.
+ * Disable this warning completely, until the GCC guys sober up
+ * again.
+ */
+
+#pragma GCC diagnostic ignored "-Wunused-function"
+
+#define FUNCTION_MAY_BE_UNUSED /* __attribute__((unused)) */
+
+#else
+#define FUNCTION_MAY_BE_UNUSED
+#endif
+
+
#ifndef _WIN32_WCE /* Some ANSI #includes are not available on Windows CE */
#include
#include
@@ -127,23 +172,52 @@ mg_static_assert(sizeof(void *) >= sizeof(int), "data type size check");
#include
#endif /* !_WIN32_WCE */
-#ifdef __MACH__
+
+#ifdef __clang__
+/* When using -Weverything, clang does not accept it's own headers
+ * in a release build configuration. Disable what is too much in
+ * -Weverything. */
+#pragma clang diagnostic ignored "-Wdisabled-macro-expansion"
+#endif
+
+#if defined(__GNUC__) || defined(__MINGW32__)
+/* Who on earth came to the conclusion, using __DATE__ should rise
+ * an "expansion of date or time macro is not reproducible"
+ * warning. That's exactly what was intended by using this macro.
+ * Just disable this nonsense warning. */
+
+/* And disabling them does not work either:
+ * #pragma clang diagnostic ignored "-Wno-error=date-time"
+ * #pragma clang diagnostic ignored "-Wdate-time"
+ * So we just have to disable ALL warnings for some lines
+ * of code.
+ */
+#endif
+
+
+#ifdef __MACH__ /* Apple OSX section */
+
+#ifdef __clang__
+#if (__clang_major__ == 3) && ((__clang_minor__ == 7) || (__clang_minor__ == 8))
+/* Avoid warnings for Xcode 7. It seems it does no longer exist in Xcode 8 */
+#pragma clang diagnostic ignored "-Wno-reserved-id-macro"
+#pragma clang diagnostic ignored "-Wno-keyword-macro"
+#endif
+#endif
#define CLOCK_MONOTONIC (1)
#define CLOCK_REALTIME (2)
+#include
#include
#include
#include
#include
#include
-
-/* clock_gettime is not implemented on OSX */
-int clock_gettime(int clk_id, struct timespec *t);
-
-int
-clock_gettime(int clk_id, struct timespec *t)
+/* clock_gettime is not implemented on OSX prior to 10.12 */
+static int
+_civet_clock_gettime(int clk_id, struct timespec *t)
{
memset(t, 0, sizeof(*t));
if (clk_id == CLOCK_REALTIME) {
@@ -183,6 +257,25 @@ clock_gettime(int clk_id, struct timespec *t)
}
return -1; /* EINVAL - Clock ID is unknown */
}
+
+/* if clock_gettime is declared, then __CLOCK_AVAILABILITY will be defined */
+#ifdef __CLOCK_AVAILABILITY
+/* If we compiled with Mac OSX 10.12 or later, then clock_gettime will be
+ * declared but it may be NULL at runtime. So we need to check before using
+ * it. */
+static int
+_civet_safe_clock_gettime(int clk_id, struct timespec *t)
+{
+ if (clock_gettime) {
+ return clock_gettime(clk_id, t);
+ }
+ return _civet_clock_gettime(clk_id, t);
+}
+#define clock_gettime _civet_safe_clock_gettime
+#else
+#define clock_gettime _civet_clock_gettime
+#endif
+
#endif
@@ -195,18 +288,31 @@ clock_gettime(int clk_id, struct timespec *t)
#include
#include
#include
+#include
+
+#ifndef INT64_MAX
+#define INT64_MAX (9223372036854775807)
+#endif
#ifndef MAX_WORKER_THREADS
#define MAX_WORKER_THREADS (1024 * 64)
#endif
-#ifndef SOCKET_TIMEOUT_QUANTUM
-#define SOCKET_TIMEOUT_QUANTUM (10000)
+
+#ifndef SOCKET_TIMEOUT_QUANTUM /* in ms */
+#define SOCKET_TIMEOUT_QUANTUM (2000)
#endif
+#define SHUTDOWN_RD (0)
+#define SHUTDOWN_WR (1)
+#define SHUTDOWN_BOTH (2)
+
mg_static_assert(MAX_WORKER_THREADS >= 1,
"worker threads must be a positive number");
+mg_static_assert(sizeof(size_t) == 4 || sizeof(size_t) == 8,
+ "size_t data type size check");
+
#if defined(_WIN32) \
&& !defined(__SYMBIAN32__) /* WINDOWS / UNIX include block */
#include
@@ -235,8 +341,9 @@ mg_static_assert(PATH_MAX >= 1, "path length must be a positive number");
#include
#include
#include
-#else /* _WIN32_WCE */
-#define NO_CGI /* WinCE has no pipes */
+#else /* _WIN32_WCE */
+#define NO_CGI /* WinCE has no pipes */
+#define NO_POPEN /* WinCE has no popen */
typedef long off_t;
@@ -291,9 +398,6 @@ typedef long off_t;
#define UINT64_FMT "I64u"
#define WINCDECL __cdecl
-#define SHUT_RD (0)
-#define SHUT_WR (1)
-#define SHUT_BOTH (2)
#define vsnprintf_impl _vsnprintf
#define access _access
#define mg_sleep(x) (Sleep(x))
@@ -308,7 +412,7 @@ typedef long off_t;
#define close(x) (_close(x))
#define dlsym(x, y) (GetProcAddress((HINSTANCE)(x), (y)))
#define RTLD_LAZY (0)
-#define fseeko(x, y, z) (_lseeki64(_fileno(x), (y), (z)) == -1 ? -1 : 0)
+#define fseeko(x, y, z) ((_lseeki64(_fileno(x), (y), (z)) == -1) ? -1 : 0)
#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))
@@ -327,8 +431,7 @@ typedef DWORD pthread_key_t;
typedef HANDLE pthread_t;
typedef struct {
CRITICAL_SECTION threadIdSec;
- int waitingthreadcount; /* The number of threads queued. */
- pthread_t *waitingthreadhdls; /* The thread handles. */
+ struct mg_workerTLS *waiting_thread; /* The chain of threads */
} pthread_cond_t;
#ifndef __clockid_t_defined
@@ -340,6 +443,13 @@ typedef DWORD clockid_t;
#ifndef CLOCK_REALTIME
#define CLOCK_REALTIME (2)
#endif
+#ifndef CLOCK_THREAD
+#define CLOCK_THREAD (3)
+#endif
+#ifndef CLOCK_PROCESS
+#define CLOCK_PROCESS (4)
+#endif
+
#if defined(_MSC_VER) && (_MSC_VER >= 1900)
#define _TIMESPEC_DEFINED
@@ -351,6 +461,106 @@ struct timespec {
};
#endif
+#if !defined(WIN_PTHREADS_TIME_H)
+#define MUST_IMPLEMENT_CLOCK_GETTIME
+#endif
+
+#ifdef MUST_IMPLEMENT_CLOCK_GETTIME
+#define clock_gettime mg_clock_gettime
+static int
+clock_gettime(clockid_t clk_id, struct timespec *tp)
+{
+ FILETIME ft;
+ ULARGE_INTEGER li, li2;
+ BOOL ok = FALSE;
+ double d;
+ static double perfcnt_per_sec = 0.0;
+
+ if (tp) {
+ memset(tp, 0, sizeof(*tp));
+
+ if (clk_id == CLOCK_REALTIME) {
+
+ /* BEGIN: CLOCK_REALTIME = wall clock (date and time) */
+ GetSystemTimeAsFileTime(&ft);
+ li.LowPart = ft.dwLowDateTime;
+ li.HighPart = ft.dwHighDateTime;
+ li.QuadPart -= 116444736000000000; /* 1.1.1970 in filedate */
+ tp->tv_sec = (time_t)(li.QuadPart / 10000000);
+ tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100;
+ ok = TRUE;
+ /* END: CLOCK_REALTIME */
+
+ } else if (clk_id == CLOCK_MONOTONIC) {
+
+ /* BEGIN: CLOCK_MONOTONIC = stopwatch (time differences) */
+ if (perfcnt_per_sec == 0.0) {
+ QueryPerformanceFrequency((LARGE_INTEGER *)&li);
+ perfcnt_per_sec = 1.0 / li.QuadPart;
+ }
+ if (perfcnt_per_sec != 0.0) {
+ QueryPerformanceCounter((LARGE_INTEGER *)&li);
+ d = li.QuadPart * perfcnt_per_sec;
+ tp->tv_sec = (time_t)d;
+ d -= tp->tv_sec;
+ tp->tv_nsec = (long)(d * 1.0E9);
+ ok = TRUE;
+ }
+ /* END: CLOCK_MONOTONIC */
+
+ } else if (clk_id == CLOCK_THREAD) {
+
+ /* BEGIN: CLOCK_THREAD = CPU usage of thread */
+ FILETIME t_create, t_exit, t_kernel, t_user;
+ if (GetThreadTimes(GetCurrentThread(),
+ &t_create,
+ &t_exit,
+ &t_kernel,
+ &t_user)) {
+ li.LowPart = t_user.dwLowDateTime;
+ li.HighPart = t_user.dwHighDateTime;
+ li2.LowPart = t_kernel.dwLowDateTime;
+ li2.HighPart = t_kernel.dwHighDateTime;
+ li.QuadPart += li2.QuadPart;
+ tp->tv_sec = (time_t)(li.QuadPart / 10000000);
+ tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100;
+ ok = TRUE;
+ }
+ /* END: CLOCK_THREAD */
+
+ } else if (clk_id == CLOCK_PROCESS) {
+
+ /* BEGIN: CLOCK_PROCESS = CPU usage of process */
+ FILETIME t_create, t_exit, t_kernel, t_user;
+ if (GetProcessTimes(GetCurrentProcess(),
+ &t_create,
+ &t_exit,
+ &t_kernel,
+ &t_user)) {
+ li.LowPart = t_user.dwLowDateTime;
+ li.HighPart = t_user.dwHighDateTime;
+ li2.LowPart = t_kernel.dwLowDateTime;
+ li2.HighPart = t_kernel.dwHighDateTime;
+ li.QuadPart += li2.QuadPart;
+ tp->tv_sec = (time_t)(li.QuadPart / 10000000);
+ tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100;
+ ok = TRUE;
+ }
+ /* END: CLOCK_PROCESS */
+
+ } else {
+
+ /* BEGIN: unknown clock */
+ /* ok = FALSE; already set by init */
+ /* END: unknown clock */
+ }
+ }
+
+ return ok ? 0 : -1;
+}
+#endif
+
+
#define pid_t HANDLE /* MINGW typedefs pid_t to int. Using #define here. */
static int pthread_mutex_lock(pthread_mutex_t *);
@@ -359,22 +569,17 @@ static void path_to_unicode(const struct mg_connection *conn,
const char *path,
wchar_t *wbuf,
size_t wbuf_len);
-struct file;
+
+/* All file operations need to be rewritten to solve #246. */
+
+#include "file_ops.inl"
+
+struct mg_file;
+
static const char *
-mg_fgets(char *buf, size_t size, struct file *filep, char **p);
+mg_fgets(char *buf, size_t size, struct mg_file *filep, char **p);
-#if defined(HAVE_STDINT)
-#include
-#else
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned __int64 uint64_t;
-typedef __int64 int64_t;
-#define INT64_MAX (9223372036854775807)
-#endif /* HAVE_STDINT */
-
/* POSIX dirent interface */
struct dirent {
char d_name[PATH_MAX];
@@ -402,8 +607,8 @@ struct pollfd {
#pragma comment(lib, "Ws2_32.lib")
#endif
-#else /* defined(_WIN32) && !defined(__SYMBIAN32__) - WINDOWS / UNIX include \
- block */
+#else /* defined(_WIN32) && !defined(__SYMBIAN32__) - \
+ WINDOWS / UNIX include block */
#include
#include
@@ -477,8 +682,8 @@ typedef int SOCKET;
#define socklen_t int
#endif /* hpux */
-#endif /* defined(_WIN32) && !defined(__SYMBIAN32__) - WINDOWS / UNIX include \
- block */
+#endif /* defined(_WIN32) && !defined(__SYMBIAN32__) - \
+ WINDOWS / UNIX include block */
/* va_copy should always be a macro, C99 and C++11 - DTL */
#ifndef va_copy
@@ -496,6 +701,8 @@ typedef int SOCKET;
static CRITICAL_SECTION global_log_file_lock;
+
+FUNCTION_MAY_BE_UNUSED
static DWORD
pthread_self(void)
{
@@ -503,6 +710,7 @@ pthread_self(void)
}
+FUNCTION_MAY_BE_UNUSED
static int
pthread_key_create(
pthread_key_t *key,
@@ -519,6 +727,7 @@ pthread_key_create(
}
+FUNCTION_MAY_BE_UNUSED
static int
pthread_key_delete(pthread_key_t key)
{
@@ -526,6 +735,7 @@ pthread_key_delete(pthread_key_t key)
}
+FUNCTION_MAY_BE_UNUSED
static int
pthread_setspecific(pthread_key_t key, void *value)
{
@@ -533,6 +743,7 @@ pthread_setspecific(pthread_key_t key, void *value)
}
+FUNCTION_MAY_BE_UNUSED
static void *
pthread_getspecific(pthread_key_t key)
{
@@ -555,83 +766,361 @@ static pthread_mutexattr_t pthread_mutex_attr;
#define MAX_CGI_ENVIR_VARS (256)
#define MG_BUF_LEN (8192)
-#ifndef MAX_REQUEST_SIZE
-#define MAX_REQUEST_SIZE (16384)
-#endif
-
-mg_static_assert(MAX_REQUEST_SIZE >= 256,
- "request size length must be a positive number");
-
#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
-#if !defined(DEBUG_TRACE)
-#if defined(DEBUG)
+
+#if defined(_WIN32_WCE)
+/* Create substitutes for POSIX functions in Win32. */
+
+#if defined(__MINGW32__)
+/* Show no warning in case system functions are not used. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif
-static void DEBUG_TRACE_FUNC(const char *func,
- unsigned line,
- PRINTF_FORMAT_STRING(const char *fmt),
- ...) PRINTF_ARGS(3, 4);
-
-static void
-DEBUG_TRACE_FUNC(const char *func, unsigned line, const char *fmt, ...)
+FUNCTION_MAY_BE_UNUSED
+static time_t
+time(time_t *ptime)
{
- va_list args;
- flockfile(stdout);
- printf("*** %lu.%p.%s.%u: ",
- (unsigned long)time(NULL),
- (void *)pthread_self(),
- func,
- line);
- va_start(args, fmt);
- vprintf(fmt, args);
- va_end(args);
- putchar('\n');
- fflush(stdout);
- funlockfile(stdout);
+ time_t t;
+ SYSTEMTIME st;
+ FILETIME ft;
+
+ GetSystemTime(&st);
+ SystemTimeToFileTime(&st, &ft);
+ t = SYS2UNIX_TIME(ft.dwLowDateTime, ft.dwHighDateTime);
+
+ if (ptime != NULL) {
+ *ptime = t;
+ }
+
+ return t;
}
-#define DEBUG_TRACE(fmt, ...) \
- DEBUG_TRACE_FUNC(__func__, __LINE__, fmt, __VA_ARGS__)
+FUNCTION_MAY_BE_UNUSED
+static struct tm *
+localtime_s(const time_t *ptime, struct tm *ptm)
+{
+ int64_t t = ((int64_t)*ptime) * RATE_DIFF + EPOCH_DIFF;
+ FILETIME ft, lft;
+ SYSTEMTIME st;
+ TIME_ZONE_INFORMATION tzinfo;
+
+ if (ptm == NULL) {
+ return NULL;
+ }
+
+ *(int64_t *)&ft = t;
+ FileTimeToLocalFileTime(&ft, &lft);
+ FileTimeToSystemTime(&lft, &st);
+ ptm->tm_year = st.wYear - 1900;
+ ptm->tm_mon = st.wMonth - 1;
+ ptm->tm_wday = st.wDayOfWeek;
+ ptm->tm_mday = st.wDay;
+ ptm->tm_hour = st.wHour;
+ ptm->tm_min = st.wMinute;
+ ptm->tm_sec = st.wSecond;
+ ptm->tm_yday = 0; /* hope nobody uses this */
+ ptm->tm_isdst =
+ (GetTimeZoneInformation(&tzinfo) == TIME_ZONE_ID_DAYLIGHT) ? 1 : 0;
+
+ return ptm;
+}
+
+
+FUNCTION_MAY_BE_UNUSED
+static struct tm *
+gmtime_s(const time_t *ptime, struct tm *ptm)
+{
+ /* FIXME(lsm): fix this. */
+ return localtime_s(ptime, ptm);
+}
+
+
+static int mg_atomic_inc(volatile int *addr);
+static struct tm tm_array[MAX_WORKER_THREADS];
+static int tm_index = 0;
+
+
+FUNCTION_MAY_BE_UNUSED
+static struct tm *
+localtime(const time_t *ptime)
+{
+ int i = mg_atomic_inc(&tm_index) % (sizeof(tm_array) / sizeof(tm_array[0]));
+ return localtime_s(ptime, tm_array + i);
+}
+
+
+FUNCTION_MAY_BE_UNUSED
+static struct tm *
+gmtime(const time_t *ptime)
+{
+ int i = mg_atomic_inc(&tm_index) % ARRAY_SIZE(tm_array);
+ return gmtime_s(ptime, tm_array + i);
+}
+
+
+FUNCTION_MAY_BE_UNUSED
+static size_t
+strftime(char *dst, size_t dst_size, const char *fmt, const struct tm *tm)
+{
+ /* TODO: (void)mg_snprintf(NULL, dst, dst_size, "implement strftime()
+ * for WinCE"); */
+ return 0;
+}
+
+#define _beginthreadex(psec, stack, func, prm, flags, ptid) \
+ (uintptr_t) CreateThread(psec, stack, func, prm, flags, ptid)
+
+#define remove(f) mg_remove(NULL, f)
+
+
+FUNCTION_MAY_BE_UNUSED
+static int
+rename(const char *a, const char *b)
+{
+ wchar_t wa[PATH_MAX];
+ wchar_t wb[PATH_MAX];
+ path_to_unicode(NULL, a, wa, ARRAY_SIZE(wa));
+ path_to_unicode(NULL, b, wb, ARRAY_SIZE(wb));
+
+ return MoveFileW(wa, wb) ? 0 : -1;
+}
+
+
+struct stat {
+ int64_t st_size;
+ time_t st_mtime;
+};
+
+
+FUNCTION_MAY_BE_UNUSED
+static int
+stat(const char *name, struct stat *st)
+{
+ wchar_t wbuf[PATH_MAX];
+ WIN32_FILE_ATTRIBUTE_DATA attr;
+ time_t creation_time, write_time;
+
+ path_to_unicode(NULL, name, wbuf, ARRAY_SIZE(wbuf));
+ memset(&attr, 0, sizeof(attr));
+
+ GetFileAttributesExW(wbuf, GetFileExInfoStandard, &attr);
+ st->st_size =
+ (((int64_t)attr.nFileSizeHigh) << 32) + (int64_t)attr.nFileSizeLow;
+
+ write_time = SYS2UNIX_TIME(attr.ftLastWriteTime.dwLowDateTime,
+ attr.ftLastWriteTime.dwHighDateTime);
+ creation_time = SYS2UNIX_TIME(attr.ftCreationTime.dwLowDateTime,
+ attr.ftCreationTime.dwHighDateTime);
+
+ if (creation_time > write_time) {
+ st->st_mtime = creation_time;
+ } else {
+ st->st_mtime = write_time;
+ }
+ return 0;
+}
+
+#define access(x, a) 1 /* not required anyway */
+
+/* WinCE-TODO: define stat, remove, rename, _rmdir, _lseeki64 */
+/* Values from errno.h in Windows SDK (Visual Studio). */
+#define EEXIST 17
+#define EACCES 13
+#define ENOENT 2
+
+#if defined(__MINGW32__)
+/* Enable unused function warning again */
+#pragma GCC diagnostic pop
+#endif
+
+#endif /* defined(_WIN32_WCE) */
+
+
+#if defined(__GNUC__) || defined(__MINGW32__)
+/* Show no warning in case system functions are not used. */
+#define GCC_VERSION \
+ (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#if GCC_VERSION >= 40500
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif /* GCC_VERSION >= 40500 */
+#endif /* defined(__GNUC__) || defined(__MINGW32__) */
+#if defined(__clang__)
+/* Show no warning in case system functions are not used. */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+static pthread_mutex_t global_lock_mutex;
+
+
+#if defined(_WIN32) && !defined(__SYMBIAN32__)
+/* Forward declaration for Windows */
+FUNCTION_MAY_BE_UNUSED
+static int pthread_mutex_lock(pthread_mutex_t *mutex);
+
+FUNCTION_MAY_BE_UNUSED
+static int pthread_mutex_unlock(pthread_mutex_t *mutex);
+#endif
+
+
+FUNCTION_MAY_BE_UNUSED
+static void
+mg_global_lock(void)
+{
+ (void)pthread_mutex_lock(&global_lock_mutex);
+}
+
+
+FUNCTION_MAY_BE_UNUSED
+static void
+mg_global_unlock(void)
+{
+ (void)pthread_mutex_unlock(&global_lock_mutex);
+}
+
+
+FUNCTION_MAY_BE_UNUSED
+static int
+mg_atomic_inc(volatile int *addr)
+{
+ int ret;
+#if defined(_WIN32) && !defined(__SYMBIAN32__) && !defined(NO_ATOMICS)
+ /* Depending on the SDK, this function uses either
+ * (volatile unsigned int *) or (volatile LONG *),
+ * so whatever you use, the other SDK is likely to raise a warning. */
+ ret = InterlockedIncrement((volatile long *)addr);
+#elif defined(__GNUC__) \
+ && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0))) \
+ && !defined(NO_ATOMICS)
+ ret = __sync_add_and_fetch(addr, 1);
#else
-#define DEBUG_TRACE(fmt, ...) \
- do { \
- } while (0)
-#endif /* DEBUG */
-#endif /* DEBUG_TRACE */
+ mg_global_lock();
+ ret = (++(*addr));
+ mg_global_unlock();
+#endif
+ return ret;
+}
-#if defined(MEMORY_DEBUGGING)
-unsigned long mg_memory_debug_blockCount = 0;
-unsigned long mg_memory_debug_totalMemUsed = 0;
+
+FUNCTION_MAY_BE_UNUSED
+static int
+mg_atomic_dec(volatile int *addr)
+{
+ int ret;
+#if defined(_WIN32) && !defined(__SYMBIAN32__) && !defined(NO_ATOMICS)
+ /* Depending on the SDK, this function uses either
+ * (volatile unsigned int *) or (volatile LONG *),
+ * so whatever you use, the other SDK is likely to raise a warning. */
+ ret = InterlockedDecrement((volatile long *)addr);
+#elif defined(__GNUC__) \
+ && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0))) \
+ && !defined(NO_ATOMICS)
+ ret = __sync_sub_and_fetch(addr, 1);
+#else
+ mg_global_lock();
+ ret = (--(*addr));
+ mg_global_unlock();
+#endif
+ return ret;
+}
+
+
+#if defined(USE_SERVER_STATS)
+static int64_t
+mg_atomic_add(volatile int64_t *addr, int64_t value)
+{
+ int64_t ret;
+#if defined(_WIN64) && !defined(__SYMBIAN32__) && !defined(NO_ATOMICS)
+ ret = InterlockedAdd64(addr, value);
+#elif defined(__GNUC__) \
+ && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0))) \
+ && !defined(NO_ATOMICS)
+ ret = __sync_add_and_fetch(addr, value);
+#else
+ mg_global_lock();
+ *addr += value;
+ ret = (*addr);
+ mg_global_unlock();
+#endif
+ return ret;
+}
+#endif
+
+
+#if defined(__GNUC__)
+/* Show no warning in case system functions are not used. */
+#if GCC_VERSION >= 40500
+#pragma GCC diagnostic pop
+#endif /* GCC_VERSION >= 40500 */
+#endif /* defined(__GNUC__) */
+#if defined(__clang__)
+/* Show no warning in case system functions are not used. */
+#pragma clang diagnostic pop
+#endif
+
+
+#if defined(USE_SERVER_STATS)
+
+struct mg_memory_stat {
+ volatile int64_t totalMemUsed;
+ volatile int64_t maxMemUsed;
+ volatile int blockCount;
+};
+
+
+static struct mg_memory_stat *get_memory_stat(struct mg_context *ctx);
static void *
-mg_malloc_ex(size_t size, const char *file, unsigned line)
+mg_malloc_ex(size_t size,
+ struct mg_context *ctx,
+ const char *file,
+ unsigned line)
{
- void *data = malloc(size + sizeof(size_t));
+ void *data = malloc(size + 2 * sizeof(uintptr_t));
void *memory = 0;
+ struct mg_memory_stat *mstat = get_memory_stat(ctx);
+
+#if defined(MEMORY_DEBUGGING)
char mallocStr[256];
+#else
+ (void)file;
+ (void)line;
+#endif
if (data) {
- *(size_t *)data = size;
- mg_memory_debug_totalMemUsed += size;
- mg_memory_debug_blockCount++;
- memory = (void *)(((char *)data) + sizeof(size_t));
+ int64_t mmem = mg_atomic_add(&mstat->totalMemUsed, (int64_t)size);
+ if (mmem > mstat->maxMemUsed) {
+ /* could use atomic compare exchange, but this
+ * seems overkill for statistics data */
+ mstat->maxMemUsed = mmem;
+ }
+
+ mg_atomic_inc(&mstat->blockCount);
+ ((uintptr_t *)data)[0] = size;
+ ((uintptr_t *)data)[1] = (uintptr_t)mstat;
+ memory = (void *)(((char *)data) + 2 * sizeof(uintptr_t));
}
+#if defined(MEMORY_DEBUGGING)
sprintf(mallocStr,
"MEM: %p %5lu alloc %7lu %4lu --- %s:%u\n",
memory,
(unsigned long)size,
- mg_memory_debug_totalMemUsed,
- mg_memory_debug_blockCount,
+ (unsigned long)mstat->totalMemUsed,
+ (unsigned long)mstat->blockCount,
file,
line);
#if defined(_WIN32)
OutputDebugStringA(mallocStr);
#else
DEBUG_TRACE("%s", mallocStr);
+#endif
#endif
return memory;
@@ -639,11 +1128,16 @@ mg_malloc_ex(size_t size, const char *file, unsigned line)
static void *
-mg_calloc_ex(size_t count, size_t size, const char *file, unsigned line)
+mg_calloc_ex(size_t count,
+ size_t size,
+ struct mg_context *ctx,
+ const char *file,
+ unsigned line)
{
- void *data = mg_malloc_ex(size * count, file, line);
+ void *data = mg_malloc_ex(size * count, ctx, file, line);
+
if (data) {
- memset(data, 0, size);
+ memset(data, 0, size * count);
}
return data;
}
@@ -652,20 +1146,29 @@ mg_calloc_ex(size_t count, size_t size, const char *file, unsigned line)
static void
mg_free_ex(void *memory, const char *file, unsigned line)
{
+ void *data = (void *)(((char *)memory) - 2 * sizeof(uintptr_t));
+
+
+#if defined(MEMORY_DEBUGGING)
char mallocStr[256];
- void *data = (void *)(((char *)memory) - sizeof(size_t));
- size_t size;
+#else
+ (void)file;
+ (void)line;
+#endif
if (memory) {
- size = *(size_t *)data;
- mg_memory_debug_totalMemUsed -= size;
- mg_memory_debug_blockCount--;
+ uintptr_t size = ((uintptr_t *)data)[0];
+ struct mg_memory_stat *mstat =
+ (struct mg_memory_stat *)(((uintptr_t *)data)[1]);
+ mg_atomic_add(&mstat->totalMemUsed, -(int64_t)size);
+ mg_atomic_dec(&mstat->blockCount);
+#if defined(MEMORY_DEBUGGING)
sprintf(mallocStr,
"MEM: %p %5lu free %7lu %4lu --- %s:%u\n",
memory,
(unsigned long)size,
- mg_memory_debug_totalMemUsed,
- mg_memory_debug_blockCount,
+ (unsigned long)mstat->totalMemUsed,
+ (unsigned long)mstat->blockCount,
file,
line);
#if defined(_WIN32)
@@ -673,34 +1176,48 @@ mg_free_ex(void *memory, const char *file, unsigned line)
#else
DEBUG_TRACE("%s", mallocStr);
#endif
-
+#endif
free(data);
}
}
static void *
-mg_realloc_ex(void *memory, size_t newsize, const char *file, unsigned line)
+mg_realloc_ex(void *memory,
+ size_t newsize,
+ struct mg_context *ctx,
+ const char *file,
+ unsigned line)
{
- char mallocStr[256];
void *data;
void *_realloc;
- size_t oldsize;
+ uintptr_t oldsize;
+
+#if defined(MEMORY_DEBUGGING)
+ char mallocStr[256];
+#else
+ (void)file;
+ (void)line;
+#endif
if (newsize) {
if (memory) {
- data = (void *)(((char *)memory) - sizeof(size_t));
- oldsize = *(size_t *)data;
- _realloc = realloc(data, newsize + sizeof(size_t));
+ /* Reallocate existing block */
+ struct mg_memory_stat *mstat;
+ data = (void *)(((char *)memory) - 2 * sizeof(uintptr_t));
+ oldsize = ((uintptr_t *)data)[0];
+ mstat = (struct mg_memory_stat *)((uintptr_t *)data)[1];
+ _realloc = realloc(data, newsize + 2 * sizeof(uintptr_t));
if (_realloc) {
data = _realloc;
- mg_memory_debug_totalMemUsed -= oldsize;
+ mg_atomic_add(&mstat->totalMemUsed, -(int64_t)oldsize);
+#if defined(MEMORY_DEBUGGING)
sprintf(mallocStr,
"MEM: %p %5lu r-free %7lu %4lu --- %s:%u\n",
memory,
(unsigned long)oldsize,
- mg_memory_debug_totalMemUsed,
- mg_memory_debug_blockCount,
+ (unsigned long)mstat->totalMemUsed,
+ (unsigned long)mstat->blockCount,
file,
line);
#if defined(_WIN32)
@@ -708,13 +1225,15 @@ mg_realloc_ex(void *memory, size_t newsize, const char *file, unsigned line)
#else
DEBUG_TRACE("%s", mallocStr);
#endif
- mg_memory_debug_totalMemUsed += newsize;
+#endif
+ mg_atomic_add(&mstat->totalMemUsed, (int64_t)newsize);
+#if defined(MEMORY_DEBUGGING)
sprintf(mallocStr,
"MEM: %p %5lu r-alloc %7lu %4lu --- %s:%u\n",
memory,
(unsigned long)newsize,
- mg_memory_debug_totalMemUsed,
- mg_memory_debug_blockCount,
+ (unsigned long)mstat->totalMemUsed,
+ (unsigned long)mstat->blockCount,
file,
line);
#if defined(_WIN32)
@@ -722,20 +1241,25 @@ mg_realloc_ex(void *memory, size_t newsize, const char *file, unsigned line)
#else
DEBUG_TRACE("%s", mallocStr);
#endif
- *(size_t *)data = newsize;
- data = (void *)(((char *)data) + sizeof(size_t));
+#endif
+ *(uintptr_t *)data = newsize;
+ data = (void *)(((char *)data) + 2 * sizeof(uintptr_t));
} else {
+#if defined(MEMORY_DEBUGGING)
#if defined(_WIN32)
OutputDebugStringA("MEM: realloc failed\n");
#else
DEBUG_TRACE("%s", "MEM: realloc failed\n");
+#endif
#endif
return _realloc;
}
} else {
- data = mg_malloc_ex(newsize, file, line);
+ /* Allocate new block */
+ data = mg_malloc_ex(newsize, ctx, file, line);
}
} else {
+ /* Free existing block */
data = 0;
mg_free_ex(memory, file, line);
}
@@ -743,12 +1267,16 @@ mg_realloc_ex(void *memory, size_t newsize, const char *file, unsigned line)
return data;
}
-#define mg_malloc(a) mg_malloc_ex(a, __FILE__, __LINE__)
-#define mg_calloc(a, b) mg_calloc_ex(a, b, __FILE__, __LINE__)
-#define mg_realloc(a, b) mg_realloc_ex(a, b, __FILE__, __LINE__)
+#define mg_malloc(a) mg_malloc_ex(a, NULL, __FILE__, __LINE__)
+#define mg_calloc(a, b) mg_calloc_ex(a, b, NULL, __FILE__, __LINE__)
+#define mg_realloc(a, b) mg_realloc_ex(a, b, NULL, __FILE__, __LINE__)
#define mg_free(a) mg_free_ex(a, __FILE__, __LINE__)
-#else
+#define mg_malloc_ctx(a, c) mg_malloc_ex(a, c, __FILE__, __LINE__)
+#define mg_calloc_ctx(a, b, c) mg_calloc_ex(a, b, c, __FILE__, __LINE__)
+#define mg_realloc_ctx(a, b, c) mg_realloc_ex(a, b, c, __FILE__, __LINE__)
+
+#else /* USE_SERVER_STATS */
static __inline void *
mg_malloc(size_t a)
@@ -774,7 +1302,12 @@ mg_free(void *a)
free(a);
}
-#endif
+#define mg_malloc_ctx(a, c) mg_malloc(a)
+#define mg_calloc_ctx(a, b, c) mg_calloc(a, b)
+#define mg_realloc_ctx(a, b, c) mg_realloc(a, b)
+#define mg_free_ctx(a, c) mg_free(a)
+
+#endif /* USE_SERVER_STATS */
static void mg_vsnprintf(const struct mg_connection *conn,
@@ -816,11 +1349,183 @@ static void mg_snprintf(const struct mg_connection *conn,
#define realloc DO_NOT_USE_THIS_FUNCTION__USE_mg_realloc
#define free DO_NOT_USE_THIS_FUNCTION__USE_mg_free
#define snprintf DO_NOT_USE_THIS_FUNCTION__USE_mg_snprintf
-#ifdef _WIN32 /* vsnprintf must not be used in any system, * \
+#ifdef _WIN32 /* vsnprintf must not be used in any system, * \ \ \ \
* but this define only works well for Windows. */
#define vsnprintf DO_NOT_USE_THIS_FUNCTION__USE_mg_vsnprintf
#endif
+
+/* mg_init_library counter */
+static int mg_init_library_called = 0;
+
+#if !defined(NO_SSL)
+static int mg_ssl_initialized = 0;
+#endif
+
+static pthread_key_t sTlsKey; /* Thread local storage index */
+static int thread_idx_max = 0;
+
+
+struct mg_workerTLS {
+ int is_master;
+ unsigned long thread_idx;
+#if defined(_WIN32) && !defined(__SYMBIAN32__)
+ HANDLE pthread_cond_helper_mutex;
+ struct mg_workerTLS *next_waiting_thread;
+#endif
+};
+
+
+#if defined(__GNUC__) || defined(__MINGW32__)
+/* Show no warning in case system functions are not used. */
+#if GCC_VERSION >= 40500
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif /* GCC_VERSION >= 40500 */
+#endif /* defined(__GNUC__) || defined(__MINGW32__) */
+#if defined(__clang__)
+/* Show no warning in case system functions are not used. */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+
+/* Get a unique thread ID as unsigned long, independent from the data type
+ * of thread IDs defined by the operating system API.
+ * If two calls to mg_current_thread_id return the same value, they calls
+ * are done from the same thread. If they return different values, they are
+ * done from different threads. (Provided this function is used in the same
+ * process context and threads are not repeatedly created and deleted, but
+ * CivetWeb does not do that).
+ * This function must match the signature required for SSL id callbacks:
+ * CRYPTO_set_id_callback
+ */
+FUNCTION_MAY_BE_UNUSED
+static unsigned long
+mg_current_thread_id(void)
+{
+#ifdef _WIN32
+ return GetCurrentThreadId();
+#else
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code"
+/* For every compiler, either "sizeof(pthread_t) > sizeof(unsigned long)"
+ * or not, so one of the two conditions will be unreachable by construction.
+ * Unfortunately the C standard does not define a way to check this at
+ * compile time, since the #if preprocessor conditions can not use the sizeof
+ * operator as an argument. */
+#endif
+
+ if (sizeof(pthread_t) > sizeof(unsigned long)) {
+ /* This is the problematic case for CRYPTO_set_id_callback:
+ * The OS pthread_t can not be cast to unsigned long. */
+ struct mg_workerTLS *tls =
+ (struct mg_workerTLS *)pthread_getspecific(sTlsKey);
+ if (tls == NULL) {
+ /* SSL called from an unknown thread: Create some thread index.
+ */
+ tls = (struct mg_workerTLS *)mg_malloc(sizeof(struct mg_workerTLS));
+ tls->is_master = -2; /* -2 means "3rd party thread" */
+ tls->thread_idx = (unsigned)mg_atomic_inc(&thread_idx_max);
+ pthread_setspecific(sTlsKey, tls);
+ }
+ return tls->thread_idx;
+ } else {
+ /* pthread_t may be any data type, so a simple cast to unsigned long
+ * can rise a warning/error, depending on the platform.
+ * Here memcpy is used as an anything-to-anything cast. */
+ unsigned long ret = 0;
+ pthread_t t = pthread_self();
+ memcpy(&ret, &t, sizeof(pthread_t));
+ return ret;
+ }
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif
+}
+
+
+FUNCTION_MAY_BE_UNUSED
+static uint64_t
+mg_get_current_time_ns(void)
+{
+ struct timespec tsnow;
+ clock_gettime(CLOCK_REALTIME, &tsnow);
+ return (((uint64_t)tsnow.tv_sec) * 1000000000) + (uint64_t)tsnow.tv_nsec;
+}
+
+
+#if defined(__GNUC__)
+/* Show no warning in case system functions are not used. */
+#if GCC_VERSION >= 40500
+#pragma GCC diagnostic pop
+#endif /* GCC_VERSION >= 40500 */
+#endif /* defined(__GNUC__) */
+#if defined(__clang__)
+/* Show no warning in case system functions are not used. */
+#pragma clang diagnostic pop
+#endif
+
+
+#if !defined(DEBUG_TRACE)
+#if defined(DEBUG)
+static void DEBUG_TRACE_FUNC(const char *func,
+ unsigned line,
+ PRINTF_FORMAT_STRING(const char *fmt),
+ ...) PRINTF_ARGS(3, 4);
+
+static void
+DEBUG_TRACE_FUNC(const char *func, unsigned line, const char *fmt, ...)
+{
+ va_list args;
+ uint64_t nsnow;
+ static uint64_t nslast;
+ struct timespec tsnow;
+
+ /* Get some operating system independent thread id */
+ unsigned long thread_id = mg_current_thread_id();
+
+ clock_gettime(CLOCK_REALTIME, &tsnow);
+ nsnow = ((uint64_t)tsnow.tv_sec) * ((uint64_t)1000000000)
+ + ((uint64_t)tsnow.tv_nsec);
+
+ if (!nslast) {
+ nslast = nsnow;
+ }
+
+ flockfile(stdout);
+ printf("*** %lu.%09lu %12" INT64_FMT " %lu %s:%u: ",
+ (unsigned long)tsnow.tv_sec,
+ (unsigned long)tsnow.tv_nsec,
+ nsnow - nslast,
+ thread_id,
+ func,
+ line);
+ va_start(args, fmt);
+ vprintf(fmt, args);
+ va_end(args);
+ putchar('\n');
+ fflush(stdout);
+ funlockfile(stdout);
+ nslast = nsnow;
+}
+
+#define DEBUG_TRACE(fmt, ...) \
+ DEBUG_TRACE_FUNC(__func__, __LINE__, fmt, __VA_ARGS__)
+
+#else
+#define DEBUG_TRACE(fmt, ...) \
+ do { \
+ } while (0)
+#endif /* DEBUG */
+#endif /* DEBUG_TRACE */
+
+
#define MD5_STATIC static
#include "md5.inl"
@@ -845,13 +1550,24 @@ typedef int socklen_t;
#define MGSQLEN (20)
#endif
+
+#if defined(NO_SSL)
+typedef struct SSL SSL; /* dummy for SSL argument to push/pull */
+typedef struct SSL_CTX SSL_CTX;
+#else
#if defined(NO_SSL_DL)
#include
#include
#include
#include
#include
+#include
+#include
+#include
+#include
+#include
#else
+
/* SSL loaded dynamically from DLL.
* I put the prototypes here to be independent from OpenSSL source
* installation. */
@@ -860,11 +1576,22 @@ typedef struct ssl_st SSL;
typedef struct ssl_method_st SSL_METHOD;
typedef struct ssl_ctx_st SSL_CTX;
typedef struct x509_store_ctx_st X509_STORE_CTX;
+typedef struct x509_name X509_NAME;
+typedef struct asn1_integer ASN1_INTEGER;
+typedef struct bignum BIGNUM;
+typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS;
+typedef struct evp_md EVP_MD;
+typedef struct x509 X509;
+
#define SSL_CTRL_OPTIONS (32)
#define SSL_CTRL_CLEAR_OPTIONS (77)
#define SSL_CTRL_SET_ECDH_AUTO (94)
+#define OPENSSL_INIT_NO_LOAD_SSL_STRINGS 0x00100000L
+#define OPENSSL_INIT_LOAD_SSL_STRINGS 0x00200000L
+#define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0x00000002L
+
#define SSL_VERIFY_NONE (0)
#define SSL_VERIFY_PEER (1)
#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT (2)
@@ -876,12 +1603,184 @@ typedef struct x509_store_ctx_st X509_STORE_CTX;
#define SSL_OP_NO_TLSv1_2 (0x08000000L)
#define SSL_OP_NO_TLSv1_1 (0x10000000L)
#define SSL_OP_SINGLE_DH_USE (0x00100000L)
+#define SSL_OP_CIPHER_SERVER_PREFERENCE (0x00400000L)
+#define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (0x00010000L)
+#define SSL_OP_NO_COMPRESSION (0x00020000L)
+
+#define SSL_CB_HANDSHAKE_START (0x10)
+#define SSL_CB_HANDSHAKE_DONE (0x20)
+
+#define SSL_ERROR_NONE (0)
+#define SSL_ERROR_SSL (1)
+#define SSL_ERROR_WANT_READ (2)
+#define SSL_ERROR_WANT_WRITE (3)
+#define SSL_ERROR_WANT_X509_LOOKUP (4)
+#define SSL_ERROR_SYSCALL (5) /* see errno */
+#define SSL_ERROR_ZERO_RETURN (6)
+#define SSL_ERROR_WANT_CONNECT (7)
+#define SSL_ERROR_WANT_ACCEPT (8)
+
struct ssl_func {
const char *name; /* SSL function name */
void (*ptr)(void); /* Function pointer */
};
+
+#ifdef OPENSSL_API_1_1
+
+#define SSL_free (*(void (*)(SSL *))ssl_sw[0].ptr)
+#define SSL_accept (*(int (*)(SSL *))ssl_sw[1].ptr)
+#define SSL_connect (*(int (*)(SSL *))ssl_sw[2].ptr)
+#define SSL_read (*(int (*)(SSL *, void *, int))ssl_sw[3].ptr)
+#define SSL_write (*(int (*)(SSL *, const void *, int))ssl_sw[4].ptr)
+#define SSL_get_error (*(int (*)(SSL *, int))ssl_sw[5].ptr)
+#define SSL_set_fd (*(int (*)(SSL *, SOCKET))ssl_sw[6].ptr)
+#define SSL_new (*(SSL * (*)(SSL_CTX *))ssl_sw[7].ptr)
+#define SSL_CTX_new (*(SSL_CTX * (*)(SSL_METHOD *))ssl_sw[8].ptr)
+#define TLS_server_method (*(SSL_METHOD * (*)(void))ssl_sw[9].ptr)
+#define OPENSSL_init_ssl \
+ (*(int (*)(uint64_t opts, \
+ const OPENSSL_INIT_SETTINGS *settings))ssl_sw[10].ptr)
+#define SSL_CTX_use_PrivateKey_file \
+ (*(int (*)(SSL_CTX *, const char *, int))ssl_sw[11].ptr)
+#define SSL_CTX_use_certificate_file \
+ (*(int (*)(SSL_CTX *, const char *, int))ssl_sw[12].ptr)
+#define SSL_CTX_set_default_passwd_cb \
+ (*(void (*)(SSL_CTX *, mg_callback_t))ssl_sw[13].ptr)
+#define SSL_CTX_free (*(void (*)(SSL_CTX *))ssl_sw[14].ptr)
+#define SSL_CTX_use_certificate_chain_file \
+ (*(int (*)(SSL_CTX *, const char *))ssl_sw[15].ptr)
+#define TLS_client_method (*(SSL_METHOD * (*)(void))ssl_sw[16].ptr)
+#define SSL_pending (*(int (*)(SSL *))ssl_sw[17].ptr)
+#define SSL_CTX_set_verify \
+ (*(void (*)(SSL_CTX *, \
+ int, \
+ int (*verify_callback)(int, X509_STORE_CTX *)))ssl_sw[18].ptr)
+#define SSL_shutdown (*(int (*)(SSL *))ssl_sw[19].ptr)
+#define SSL_CTX_load_verify_locations \
+ (*(int (*)(SSL_CTX *, const char *, const char *))ssl_sw[20].ptr)
+#define SSL_CTX_set_default_verify_paths (*(int (*)(SSL_CTX *))ssl_sw[21].ptr)
+#define SSL_CTX_set_verify_depth (*(void (*)(SSL_CTX *, int))ssl_sw[22].ptr)
+#define SSL_get_peer_certificate (*(X509 * (*)(SSL *))ssl_sw[23].ptr)
+#define SSL_get_version (*(const char *(*)(SSL *))ssl_sw[24].ptr)
+#define SSL_get_current_cipher (*(SSL_CIPHER * (*)(SSL *))ssl_sw[25].ptr)
+#define SSL_CIPHER_get_name \
+ (*(const char *(*)(const SSL_CIPHER *))ssl_sw[26].ptr)
+#define SSL_CTX_check_private_key (*(int (*)(SSL_CTX *))ssl_sw[27].ptr)
+#define SSL_CTX_set_session_id_context \
+ (*(int (*)(SSL_CTX *, const unsigned char *, unsigned int))ssl_sw[28].ptr)
+#define SSL_CTX_ctrl (*(long (*)(SSL_CTX *, int, long, void *))ssl_sw[29].ptr)
+#define SSL_CTX_set_cipher_list \
+ (*(int (*)(SSL_CTX *, const char *))ssl_sw[30].ptr)
+#define SSL_CTX_set_options \
+ (*(unsigned long (*)(SSL_CTX *, unsigned long))ssl_sw[31].ptr)
+#define SSL_CTX_set_info_callback \
+ (*(void (*)(SSL_CTX * ctx, \
+ void (*callback)(SSL * s, int, int)))ssl_sw[32].ptr)
+#define SSL_get_ex_data (*(char *(*)(SSL *, int))ssl_sw[33].ptr)
+#define SSL_set_ex_data (*(void (*)(SSL *, int, char *))ssl_sw[34].ptr)
+
+#define SSL_CTX_clear_options(ctx, op) \
+ SSL_CTX_ctrl((ctx), SSL_CTRL_CLEAR_OPTIONS, (op), NULL)
+#define SSL_CTX_set_ecdh_auto(ctx, onoff) \
+ SSL_CTX_ctrl(ctx, SSL_CTRL_SET_ECDH_AUTO, onoff, NULL)
+
+#define X509_get_notBefore(x) ((x)->cert_info->validity->notBefore)
+#define X509_get_notAfter(x) ((x)->cert_info->validity->notAfter)
+
+#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char *)arg))
+#define SSL_get_app_data(s) (SSL_get_ex_data(s, 0))
+
+#define ERR_get_error (*(unsigned long (*)(void))crypto_sw[0].ptr)
+#define ERR_error_string (*(char *(*)(unsigned long, char *))crypto_sw[1].ptr)
+#define ERR_remove_state (*(void (*)(unsigned long))crypto_sw[2].ptr)
+#define CONF_modules_unload (*(void (*)(int))crypto_sw[3].ptr)
+#define X509_free (*(void (*)(X509 *))crypto_sw[4].ptr)
+#define X509_get_subject_name (*(X509_NAME * (*)(X509 *))crypto_sw[5].ptr)
+#define X509_get_issuer_name (*(X509_NAME * (*)(X509 *))crypto_sw[6].ptr)
+#define X509_NAME_oneline \
+ (*(char *(*)(X509_NAME *, char *, int))crypto_sw[7].ptr)
+#define X509_get_serialNumber (*(ASN1_INTEGER * (*)(X509 *))crypto_sw[8].ptr)
+#define EVP_get_digestbyname \
+ (*(const EVP_MD *(*)(const char *))crypto_sw[9].ptr)
+#define EVP_Digest \
+ (*(int (*)( \
+ const void *, size_t, void *, unsigned int *, const EVP_MD *, void *)) \
+ crypto_sw[10].ptr)
+#define i2d_X509 (*(int (*)(X509 *, unsigned char **))crypto_sw[11].ptr)
+#define BN_bn2hex (*(char *(*)(const BIGNUM *a))crypto_sw[12].ptr)
+#define ASN1_INTEGER_to_BN \
+ (*(BIGNUM * (*)(const ASN1_INTEGER *ai, BIGNUM *bn))crypto_sw[13].ptr)
+#define BN_free (*(void (*)(const BIGNUM *a))crypto_sw[14].ptr)
+#define CRYPTO_free (*(void (*)(void *addr))crypto_sw[15].ptr)
+
+#define OPENSSL_free(a) CRYPTO_free(a)
+
+
+/* set_ssl_option() function updates this array.
+ * It loads SSL library dynamically and changes NULLs to the actual addresses
+ * of respective functions. The macros above (like SSL_connect()) are really
+ * just calling these functions indirectly via the pointer. */
+static struct ssl_func ssl_sw[] = {{"SSL_free", NULL},
+ {"SSL_accept", NULL},
+ {"SSL_connect", NULL},
+ {"SSL_read", NULL},
+ {"SSL_write", NULL},
+ {"SSL_get_error", NULL},
+ {"SSL_set_fd", NULL},
+ {"SSL_new", NULL},
+ {"SSL_CTX_new", NULL},
+ {"TLS_server_method", NULL},
+ {"OPENSSL_init_ssl", NULL},
+ {"SSL_CTX_use_PrivateKey_file", NULL},
+ {"SSL_CTX_use_certificate_file", NULL},
+ {"SSL_CTX_set_default_passwd_cb", NULL},
+ {"SSL_CTX_free", NULL},
+ {"SSL_CTX_use_certificate_chain_file", NULL},
+ {"TLS_client_method", NULL},
+ {"SSL_pending", NULL},
+ {"SSL_CTX_set_verify", NULL},
+ {"SSL_shutdown", NULL},
+ {"SSL_CTX_load_verify_locations", NULL},
+ {"SSL_CTX_set_default_verify_paths", NULL},
+ {"SSL_CTX_set_verify_depth", NULL},
+ {"SSL_get_peer_certificate", NULL},
+ {"SSL_get_version", NULL},
+ {"SSL_get_current_cipher", NULL},
+ {"SSL_CIPHER_get_name", NULL},
+ {"SSL_CTX_check_private_key", NULL},
+ {"SSL_CTX_set_session_id_context", NULL},
+ {"SSL_CTX_ctrl", NULL},
+ {"SSL_CTX_set_cipher_list", NULL},
+ {"SSL_CTX_set_options", NULL},
+ {"SSL_CTX_set_info_callback", NULL},
+ {"SSL_get_ex_data", NULL},
+ {"SSL_set_ex_data", NULL},
+ {NULL, NULL}};
+
+
+/* Similar array as ssl_sw. These functions could be located in different
+ * lib. */
+static struct ssl_func crypto_sw[] = {{"ERR_get_error", NULL},
+ {"ERR_error_string", NULL},
+ {"ERR_remove_state", NULL},
+ {"CONF_modules_unload", NULL},
+ {"X509_free", NULL},
+ {"X509_get_subject_name", NULL},
+ {"X509_get_issuer_name", NULL},
+ {"X509_NAME_oneline", NULL},
+ {"X509_get_serialNumber", NULL},
+ {"EVP_get_digestbyname", NULL},
+ {"EVP_Digest", NULL},
+ {"i2d_X509", NULL},
+ {"BN_bn2hex", NULL},
+ {"ASN1_INTEGER_to_BN", NULL},
+ {"BN_free", NULL},
+ {"CRYPTO_free", NULL},
+ {NULL, NULL}};
+#else
+
#define SSL_free (*(void (*)(SSL *))ssl_sw[0].ptr)
#define SSL_accept (*(int (*)(SSL *))ssl_sw[1].ptr)
#define SSL_connect (*(int (*)(SSL *))ssl_sw[2].ptr)
@@ -925,6 +1824,12 @@ struct ssl_func {
#define SSL_CTX_ctrl (*(long (*)(SSL_CTX *, int, long, void *))ssl_sw[30].ptr)
#define SSL_CTX_set_cipher_list \
(*(int (*)(SSL_CTX *, const char *))ssl_sw[31].ptr)
+#define SSL_CTX_set_info_callback \
+ (*(void (*)(SSL_CTX * ctx, \
+ void (*callback)(SSL * s, int, int)))ssl_sw[32].ptr)
+#define SSL_get_ex_data (*(char *(*)(SSL *, int))ssl_sw[33].ptr)
+#define SSL_set_ex_data (*(void (*)(SSL *, int, char *))ssl_sw[34].ptr)
+
#define SSL_CTX_set_options(ctx, op) \
SSL_CTX_ctrl((ctx), SSL_CTRL_OPTIONS, (op), NULL)
#define SSL_CTX_clear_options(ctx, op) \
@@ -932,6 +1837,13 @@ struct ssl_func {
#define SSL_CTX_set_ecdh_auto(ctx, onoff) \
SSL_CTX_ctrl(ctx, SSL_CTRL_SET_ECDH_AUTO, onoff, NULL)
+
+#define X509_get_notBefore(x) ((x)->cert_info->validity->notBefore)
+#define X509_get_notAfter(x) ((x)->cert_info->validity->notAfter)
+
+#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char *)arg))
+#define SSL_get_app_data(s) (SSL_get_ex_data(s, 0))
+
#define CRYPTO_num_locks (*(int (*)(void))crypto_sw[0].ptr)
#define CRYPTO_set_locking_callback \
(*(void (*)(void (*)(int, int, const char *, int)))crypto_sw[1].ptr)
@@ -945,7 +1857,28 @@ struct ssl_func {
#define CONF_modules_unload (*(void (*)(int))crypto_sw[8].ptr)
#define CRYPTO_cleanup_all_ex_data (*(void (*)(void))crypto_sw[9].ptr)
#define EVP_cleanup (*(void (*)(void))crypto_sw[10].ptr)
+#define X509_free (*(void (*)(X509 *))crypto_sw[11].ptr)
+#define X509_get_subject_name (*(X509_NAME * (*)(X509 *))crypto_sw[12].ptr)
+#define X509_get_issuer_name (*(X509_NAME * (*)(X509 *))crypto_sw[13].ptr)
+#define X509_NAME_oneline \
+ (*(char *(*)(X509_NAME *, char *, int))crypto_sw[14].ptr)
+#define X509_get_serialNumber (*(ASN1_INTEGER * (*)(X509 *))crypto_sw[15].ptr)
+#define i2c_ASN1_INTEGER \
+ (*(int (*)(ASN1_INTEGER *, unsigned char **))crypto_sw[16].ptr)
+#define EVP_get_digestbyname \
+ (*(const EVP_MD *(*)(const char *))crypto_sw[17].ptr)
+#define EVP_Digest \
+ (*(int (*)( \
+ const void *, size_t, void *, unsigned int *, const EVP_MD *, void *)) \
+ crypto_sw[18].ptr)
+#define i2d_X509 (*(int (*)(X509 *, unsigned char **))crypto_sw[19].ptr)
+#define BN_bn2hex (*(char *(*)(const BIGNUM *a))crypto_sw[20].ptr)
+#define ASN1_INTEGER_to_BN \
+ (*(BIGNUM * (*)(const ASN1_INTEGER *ai, BIGNUM *bn))crypto_sw[21].ptr)
+#define BN_free (*(void (*)(const BIGNUM *a))crypto_sw[22].ptr)
+#define CRYPTO_free (*(void (*)(void *addr))crypto_sw[23].ptr)
+#define OPENSSL_free(a) CRYPTO_free(a)
/* set_ssl_option() function updates this array.
* It loads SSL library dynamically and changes NULLs to the actual addresses
@@ -983,12 +1916,14 @@ static struct ssl_func ssl_sw[] = {{"SSL_free", NULL},
{"SSL_CTX_set_session_id_context", NULL},
{"SSL_CTX_ctrl", NULL},
{"SSL_CTX_set_cipher_list", NULL},
+ {"SSL_CTX_set_info_callback", NULL},
+ {"SSL_get_ex_data", NULL},
+ {"SSL_set_ex_data", NULL},
{NULL, NULL}};
/* Similar array as ssl_sw. These functions could be located in different
* lib. */
-#if !defined(NO_SSL)
static struct ssl_func crypto_sw[] = {{"CRYPTO_num_locks", NULL},
{"CRYPTO_set_locking_callback", NULL},
{"CRYPTO_set_id_callback", NULL},
@@ -1000,9 +1935,23 @@ static struct ssl_func crypto_sw[] = {{"CRYPTO_num_locks", NULL},
{"CONF_modules_unload", NULL},
{"CRYPTO_cleanup_all_ex_data", NULL},
{"EVP_cleanup", NULL},
+ {"X509_free", NULL},
+ {"X509_get_subject_name", NULL},
+ {"X509_get_issuer_name", NULL},
+ {"X509_NAME_oneline", NULL},
+ {"X509_get_serialNumber", NULL},
+ {"i2c_ASN1_INTEGER", NULL},
+ {"EVP_get_digestbyname", NULL},
+ {"EVP_Digest", NULL},
+ {"i2d_X509", NULL},
+ {"BN_bn2hex", NULL},
+ {"ASN1_INTEGER_to_BN", NULL},
+ {"BN_free", NULL},
+ {"CRYPTO_free", NULL},
{NULL, NULL}};
-#endif /* NO_SSL */
+#endif /* OPENSSL_API_1_1 */
#endif /* NO_SSL_DL */
+#endif /* NO_SSL */
#if !defined(NO_CACHING)
@@ -1020,7 +1969,8 @@ static const char *month_names[] = {"Jan",
"Dec"};
#endif /* !NO_CACHING */
-/* Unified socket address. For IPv6 support, add IPv6 address structure in the
+/* Unified socket address. For IPv6 support, add IPv6 address structure in
+ * the
* union u. */
union usa {
struct sockaddr sa;
@@ -1036,19 +1986,45 @@ struct vec {
size_t len;
};
-struct file {
+struct mg_file_stat {
+ /* File properties filled by mg_stat: */
uint64_t size;
time_t last_modified;
+ int is_directory; /* Set to 1 if mg_stat is called for a directory */
+ int is_gzipped; /* Set to 1 if the content is gzipped, in which
+ * case we need a "Content-Eencoding: gzip" header */
+ int location; /* 0 = nowhere, 1 = on disk, 2 = in memory */
+};
+
+struct mg_file_in_memory {
+ char *p;
+ uint32_t pos;
+ char mode;
+};
+
+struct mg_file_access {
+ /* File properties filled by mg_fopen: */
FILE *fp;
- const char *membuf; /* Non-NULL if file data is in memory */
- int is_directory;
- int gzipped; /* set to 1 if the content is gzipped
- * in which case we need a content-encoding: gzip header */
+ /* TODO (low): Replace "membuf" implementation by a "file in memory"
+ * support library. Use some struct mg_file_in_memory *mf; instead of
+ * membuf char pointer. */
+ const char *membuf;
+};
+
+struct mg_file {
+ struct mg_file_stat stat;
+ struct mg_file_access access;
};
#define STRUCT_FILE_INITIALIZER \
{ \
- (uint64_t)0, (time_t)0, (FILE *)NULL, (const char *)NULL, 0, 0 \
+ { \
+ (uint64_t)0, (time_t)0, 0, 0, 0 \
+ } \
+ , \
+ { \
+ (FILE *) NULL, (const char *)NULL \
+ } \
}
/* Describes listening socket, or socket which was accept()-ed by the master
@@ -1060,6 +2036,7 @@ struct socket {
unsigned char is_ssl; /* Is port SSL-ed */
unsigned char ssl_redir; /* Is port supposed to redirect everything to SSL
* port */
+ unsigned char in_use; /* Is valid */
};
/* NOTE(lsm): this enum shoulds be in sync with the config_options below. */
@@ -1084,11 +2061,14 @@ enum {
LISTENING_PORTS,
DOCUMENT_ROOT,
SSL_CERTIFICATE,
+ SSL_CERTIFICATE_CHAIN,
NUM_THREADS,
RUN_AS_USER,
- REWRITE,
+ URL_REWRITE_PATTERN,
HIDE_FILES,
REQUEST_TIMEOUT,
+ KEEP_ALIVE_TIMEOUT,
+ LINGER_TIMEOUT,
SSL_DO_VERIFY_PEER,
SSL_CA_PATH,
SSL_CA_FILE,
@@ -1097,9 +2077,11 @@ enum {
SSL_CIPHER_LIST,
SSL_PROTOCOL_VERSION,
SSL_SHORT_TRUST,
+
#if defined(USE_WEBSOCKET)
WEBSOCKET_TIMEOUT,
#endif
+
DECODE_URL,
#if defined(USE_LUA)
@@ -1117,16 +2099,36 @@ enum {
#if defined(USE_LUA) && defined(USE_WEBSOCKET)
LUA_WEBSOCKET_EXTENSIONS,
#endif
+
ACCESS_CONTROL_ALLOW_ORIGIN,
+ ACCESS_CONTROL_ALLOW_METHODS,
+ ACCESS_CONTROL_ALLOW_HEADERS,
ERROR_PAGES,
CONFIG_TCP_NODELAY, /* Prepended CONFIG_ to avoid conflict with the
- * socket option typedef TCP_NODELAY. */
+ * socket option typedef TCP_NODELAY. */
#if !defined(NO_CACHING)
STATIC_FILE_MAX_AGE,
#endif
- VALIDATE_HTTP_METHOD,
- CANONICALIZE_URL_PATH,
+#if !defined(NO_SSL)
+ STRICT_HTTPS_MAX_AGE,
+#endif
+#if defined(__linux__)
+ ALLOW_SENDFILE_CALL,
+#endif
+#if defined(_WIN32)
+ CASE_SENSITIVE_FILES,
+#endif
+#if defined(USE_LUA)
+ LUA_BACKGROUND_SCRIPT,
+ LUA_BACKGROUND_SCRIPT_PARAMS,
+#endif
+ ADDITIONAL_HEADER,
+ MAX_REQUEST_SIZE,
+ ALLOW_INDEX_SCRIPT_SUB_RES,
+ VALIDATE_HTTP_METHOD,
+ CANONICALIZE_URL_PATH,
+ ALLOW_UNICODE_IN_URLS,
NUM_OPTIONS
};
@@ -1134,38 +2136,45 @@ enum {
/* Config option name, config types, default value */
static struct mg_option config_options[] = {
{"cgi_pattern", CONFIG_TYPE_EXT_PATTERN, "**.cgi$|**.pl$|**.php$"},
- {"cgi_environment", CONFIG_TYPE_STRING, NULL},
+ {"cgi_environment", CONFIG_TYPE_STRING_LIST, NULL},
{"put_delete_auth_file", CONFIG_TYPE_FILE, NULL},
{"cgi_interpreter", CONFIG_TYPE_FILE, NULL},
- {"protect_uri", CONFIG_TYPE_STRING, NULL},
+ {"protect_uri", CONFIG_TYPE_STRING_LIST, NULL},
{"authentication_domain", CONFIG_TYPE_STRING, "mydomain.com"},
{"enable_auth_domain_check", CONFIG_TYPE_BOOLEAN, "yes"},
{"ssi_pattern", CONFIG_TYPE_EXT_PATTERN, "**.shtml$|**.shtm$"},
- {"throttle", CONFIG_TYPE_STRING, NULL},
+ {"throttle", CONFIG_TYPE_STRING_LIST, NULL},
{"access_log_file", CONFIG_TYPE_FILE, NULL},
{"enable_directory_listing", CONFIG_TYPE_BOOLEAN, "yes"},
{"error_log_file", CONFIG_TYPE_FILE, NULL},
{"global_auth_file", CONFIG_TYPE_FILE, NULL},
{"index_files",
- CONFIG_TYPE_STRING,
+ CONFIG_TYPE_STRING_LIST,
#ifdef USE_LUA
- "index.xhtml,index.html,index.htm,index.lp,index.lsp,index.lua,index.cgi,"
+ "index.xhtml,index.html,index.htm,"
+ "index.lp,index.lsp,index.lua,index.cgi,"
"index.shtml,index.php"},
#else
"index.xhtml,index.html,index.htm,index.cgi,index.shtml,index.php"},
#endif
{"enable_keep_alive", CONFIG_TYPE_BOOLEAN, "no"},
- {"access_control_list", CONFIG_TYPE_STRING, NULL},
- {"extra_mime_types", CONFIG_TYPE_STRING, NULL},
- {"listening_ports", CONFIG_TYPE_STRING, "8080"},
+ {"access_control_list", CONFIG_TYPE_STRING_LIST, NULL},
+ {"extra_mime_types", CONFIG_TYPE_STRING_LIST, NULL},
+ {"listening_ports", CONFIG_TYPE_STRING_LIST, "8080"},
{"document_root", CONFIG_TYPE_DIRECTORY, NULL},
{"ssl_certificate", CONFIG_TYPE_FILE, NULL},
+ {"ssl_certificate_chain", CONFIG_TYPE_FILE, NULL},
{"num_threads", CONFIG_TYPE_NUMBER, "50"},
{"run_as_user", CONFIG_TYPE_STRING, NULL},
- {"url_rewrite_patterns", CONFIG_TYPE_STRING, NULL},
+ {"url_rewrite_patterns", CONFIG_TYPE_STRING_LIST, NULL},
{"hide_files_patterns", CONFIG_TYPE_EXT_PATTERN, NULL},
{"request_timeout_ms", CONFIG_TYPE_NUMBER, "30000"},
+ {"keep_alive_timeout_ms", CONFIG_TYPE_NUMBER, "500"},
+ {"linger_timeout_ms", CONFIG_TYPE_NUMBER, NULL},
+
+ /* TODO(Feature): this is no longer a boolean, but yes/no/optional */
{"ssl_verify_peer", CONFIG_TYPE_BOOLEAN, "no"},
+
{"ssl_ca_path", CONFIG_TYPE_DIRECTORY, NULL},
{"ssl_ca_file", CONFIG_TYPE_FILE, NULL},
{"ssl_verify_depth", CONFIG_TYPE_NUMBER, "9"},
@@ -1196,24 +2205,45 @@ static struct mg_option config_options[] = {
{"lua_websocket_pattern", CONFIG_TYPE_EXT_PATTERN, "**.lua$"},
#endif
{"access_control_allow_origin", CONFIG_TYPE_STRING, "*"},
+ {"access_control_allow_methods", CONFIG_TYPE_STRING, "*"},
+ {"access_control_allow_headers", CONFIG_TYPE_STRING, "*"},
{"error_pages", CONFIG_TYPE_DIRECTORY, NULL},
{"tcp_nodelay", CONFIG_TYPE_NUMBER, "0"},
#if !defined(NO_CACHING)
{"static_file_max_age", CONFIG_TYPE_NUMBER, "3600"},
#endif
+#if !defined(NO_SSL)
+ {"strict_transport_security_max_age", CONFIG_TYPE_NUMBER, NULL},
+#endif
+#if defined(__linux__)
+ {"allow_sendfile_call", CONFIG_TYPE_BOOLEAN, "yes"},
+#endif
+#if defined(_WIN32)
+ {"case_sensitive", CONFIG_TYPE_BOOLEAN, "no"},
+#endif
+#if defined(USE_LUA)
+ {"lua_background_script", CONFIG_TYPE_FILE, NULL},
+ {"lua_background_script_params", CONFIG_TYPE_STRING_LIST, NULL},
+#endif
+ {"additional_header", CONFIG_TYPE_STRING_MULTILINE, NULL},
+ {"max_request_size", CONFIG_TYPE_NUMBER, "16384"},
+ {"allow_index_script_resource", CONFIG_TYPE_BOOLEAN, "no"},
{"validate_http_method", CONFIG_TYPE_BOOLEAN, "yes"},
{"canonicalize_url_path", CONFIG_TYPE_BOOLEAN, "yes"},
-
+ {"allow_unicode_in_urls", CONFIG_TYPE_BOOLEAN, "no"},
{NULL, CONFIG_TYPE_UNKNOWN, NULL}};
+
/* Check if the config_options and the corresponding enum have compatible
* sizes. */
mg_static_assert((sizeof(config_options) / sizeof(config_options[0]))
== (NUM_OPTIONS + 1),
"config_options and enum not sync");
+
enum { REQUEST_HANDLER, WEBSOCKET_HANDLER, AUTH_HANDLER };
+
struct mg_handler_info {
/* Name/Pattern of the URI. */
char *uri;
@@ -1231,6 +2261,9 @@ struct mg_handler_info {
mg_websocket_data_handler data_handler;
mg_websocket_close_handler close_handler;
+ /* accepted subprotocols for ws/wss requests. */
+ struct mg_websocket_subprotocols *subprotocols;
+
/* Handler for authorization requests */
mg_authorization_handler auth_handler;
@@ -1241,35 +2274,53 @@ struct mg_handler_info {
struct mg_handler_info *next;
};
+
+enum {
+ CONTEXT_INVALID,
+ CONTEXT_SERVER,
+ CONTEXT_HTTP_CLIENT,
+ CONTEXT_WS_CLIENT
+};
+
+
struct mg_context {
volatile int stop_flag; /* Should we stop event loop */
SSL_CTX *ssl_ctx; /* SSL context */
char *config[NUM_OPTIONS]; /* Civetweb configuration parameters */
struct mg_callbacks callbacks; /* User-defined callback function */
void *user_data; /* User-defined data */
- int context_type; /* 1 = server context, 2 = client context */
+ int context_type; /* See CONTEXT_* above */
struct socket *listening_sockets;
- in_port_t *listening_ports;
+ struct pollfd *listening_socket_fds;
unsigned int num_listening_sockets;
- volatile int
- running_worker_threads; /* Number of currently running worker threads */
pthread_mutex_t thread_mutex; /* Protects (max|num)_threads */
- pthread_cond_t thread_cond; /* Condvar for tracking workers terminations */
+#ifdef ALTERNATIVE_QUEUE
+ struct socket *client_socks;
+ void **client_wait_events;
+#else
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; /* Signaled when socket is produced */
pthread_cond_t sq_empty; /* Signaled when socket is consumed */
- pthread_t masterthreadid; /* The master thread ID */
- unsigned int
- cfg_worker_threads; /* The number of configured worker threads. */
- pthread_t *workerthreadids; /* The worker thread IDs */
+#endif
- time_t start_time; /* Server start time, used for authentication */
- uint64_t auth_nonce_mask; /* Mask for all nonce values */
+ unsigned int max_request_size; /* The max request size */
+
+ pthread_t masterthreadid; /* The master thread ID */
+ unsigned int
+ cfg_worker_threads; /* The number of configured worker threads. */
+ pthread_t *worker_threadids; /* The worker thread IDs */
+ struct mg_connection *worker_connections; /* The connection struct, pre-
+ * allocated for each worker */
+
+ time_t start_time; /* Server start time, used for authentication
+ * and for diagnstics. */
+
+ uint64_t auth_nonce_mask; /* Mask for all nonce values */
pthread_mutex_t nonce_mutex; /* Protects nonce_count */
unsigned long nonce_count; /* Used nonces, used for authentication */
@@ -1283,15 +2334,59 @@ struct mg_context {
struct mg_shared_lua_websocket_list *shared_lua_websockets;
#endif
-#ifdef USE_TIMERS
+#if defined(USE_TIMERS)
struct ttimers *timers;
#endif
+
+#if defined(USE_LUA)
+ void *lua_background_state;
+#endif
+
+#if defined(USE_SERVER_STATS)
+ int active_connections;
+ int max_connections;
+ int64_t total_connections;
+ int64_t total_requests;
+ struct mg_memory_stat ctx_memory;
+ int64_t total_data_read;
+ int64_t total_data_written;
+#endif
};
+#if defined(USE_SERVER_STATS)
+static struct mg_memory_stat mg_common_memory = {0, 0, 0};
+
+static struct mg_memory_stat *
+get_memory_stat(struct mg_context *ctx)
+{
+ if (ctx) {
+ return &(ctx->ctx_memory);
+ }
+ return &mg_common_memory;
+}
+#endif
+
+enum {
+ CONNECTION_TYPE_INVALID,
+ CONNECTION_TYPE_REQUEST,
+ CONNECTION_TYPE_RESPONSE
+};
+
struct mg_connection {
+ int connection_type; /* see CONNECTION_TYPE_* above */
+
struct mg_request_info request_info;
+ struct mg_response_info response_info;
+
struct mg_context *ctx;
+
+#if defined(USE_SERVER_STATS)
+ int conn_state; /* 0 = undef, numerical value may change in different
+ * versions. For the current definition, see
+ * mg_get_connection_info_impl */
+#endif
+
SSL *ssl; /* SSL descriptor */
SSL_CTX *client_ssl_ctx; /* SSL context for client connections */
struct socket client; /* Connected client */
@@ -1302,24 +2397,32 @@ struct mg_connection {
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 have been read */
- int is_chunked; /* Transfer-Encoding is chunked: 0=no, 1=yes:
- * data available, 2: all data read */
+ int is_chunked; /* Transfer-Encoding is chunked:
+ * 0 = not chunked,
+ * 1 = chunked, do data read yet,
+ * 2 = chunked, some data read,
+ * 3 = chunked, all data read
+ */
size_t chunk_remainder; /* Unread data from the last chunk */
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 accept_gzip; /* 1 if gzip encoding is accepted */
int in_error_handler; /* 1 if in handler for user defined error
* pages */
- int internal_error; /* 1 if an error occured while processing the
- * request */
+#if defined(USE_WEBSOCKET)
+ int in_websocket_handling; /* 1 if in read_websocket */
+#endif
+ int handled_requests; /* Number of requests handled by this connection
+ */
+ 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 */
- 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 */
pthread_mutex_t mutex; /* Used by mg_(un)lock_connection to ensure
@@ -1327,27 +2430,16 @@ struct mg_connection {
#if defined(USE_LUA) && defined(USE_WEBSOCKET)
void *lua_websocket_state; /* Lua_State for a websocket connection */
#endif
+
+ int thread_index; /* Thread index within ctx */
};
-static pthread_key_t sTlsKey; /* Thread local storage index */
-static int sTlsInit = 0;
-static int thread_idx_max = 0;
-
-
-struct mg_workerTLS {
- int is_master;
- unsigned long thread_idx;
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
- HANDLE pthread_cond_helper_mutex;
-#endif
-};
-
/* Directory entry */
struct de {
struct mg_connection *conn;
char *file_name;
- struct file file;
+ struct mg_file_stat file;
};
@@ -1358,43 +2450,6 @@ static int is_websocket_protocol(const struct mg_connection *conn);
#endif
-static int
-mg_atomic_inc(volatile int *addr)
-{
- int ret;
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
- /* Depending on the SDK, this function uses either
- * (volatile unsigned int *) or (volatile LONG *),
- * so whatever you use, the other SDK is likely to raise a warning. */
- ret = InterlockedIncrement((volatile long *)addr);
-#elif defined(__GNUC__) \
- && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0)))
- ret = __sync_add_and_fetch(addr, 1);
-#else
- ret = (++(*addr));
-#endif
- return ret;
-}
-
-
-static int
-mg_atomic_dec(volatile int *addr)
-{
- int ret;
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
- /* Depending on the SDK, this function uses either
- * (volatile unsigned int *) or (volatile LONG *),
- * so whatever you use, the other SDK is likely to raise a warning. */
- ret = InterlockedDecrement((volatile long *)addr);
-#elif defined(__GNUC__) \
- && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 0)))
- ret = __sync_sub_and_fetch(addr, 1);
-#else
- ret = (--(*addr));
-#endif
- return ret;
-}
-
#if !defined(NO_THREAD_NAME)
#if defined(_WIN32) && defined(_MSC_VER)
/* Set the thread name for debugging purposes in Visual Studio
@@ -1408,9 +2463,210 @@ typedef struct tagTHREADNAME_INFO {
DWORD dwFlags; /* Reserved for future use, must be zero. */
} THREADNAME_INFO;
#pragma pack(pop)
+
#elif defined(__linux__)
+
#include
#include
+#ifdef ALTERNATIVE_QUEUE
+#include
+#endif /* ALTERNATIVE_QUEUE */
+
+
+#if defined(ALTERNATIVE_QUEUE)
+
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code"
+/* For every system, "(sizeof(int) == sizeof(void *))" is either always
+ * true or always false. One of the two branches is unreachable in any case.
+ * Unfortunately the C standard does not define a way to check this at
+ * compile time, since the #if preprocessor conditions can not use the sizeof
+ * operator as an argument. */
+#endif
+
+#if defined(__GNUC__) || defined(__MINGW32__)
+/* GCC does not realize one branch is unreachable, so it raises some
+ * pointer cast warning within the unreachable branch.
+ */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
+#pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
+#endif
+
+
+static void *
+event_create(void)
+{
+ int evhdl = eventfd(0, EFD_CLOEXEC);
+ int *ret;
+
+ if (evhdl == -1) {
+ /* Linux uses -1 on error, Windows NULL. */
+ /* However, Linux does not return 0 on success either. */
+ return 0;
+ }
+ if (sizeof(int) == sizeof(void *)) {
+ ret = (void *)evhdl;
+ } else {
+ ret = (int *)mg_malloc(sizeof(int));
+ if (ret) {
+ *ret = evhdl;
+ } else {
+ (void)close(evhdl);
+ }
+ }
+
+ return (void *)ret;
+}
+
+
+static int
+event_wait(void *eventhdl)
+{
+ uint64_t u;
+ int evhdl, s;
+
+ if (sizeof(int) == sizeof(void *)) {
+ evhdl = (int)eventhdl;
+ } else {
+ if (!eventhdl) {
+ /* error */
+ return 0;
+ }
+ evhdl = *(int *)eventhdl;
+ }
+
+ s = (int)read(evhdl, &u, sizeof(u));
+ if (s != sizeof(uint64_t)) {
+ /* error */
+ return 0;
+ }
+ (void)u; /* the value is not required */
+ return 1;
+}
+
+
+static int
+event_signal(void *eventhdl)
+{
+ uint64_t u = 1;
+ int evhdl, s;
+
+ if (sizeof(int) == sizeof(void *)) {
+ evhdl = (int)eventhdl;
+ } else {
+ if (!eventhdl) {
+ /* error */
+ return 0;
+ }
+ evhdl = *(int *)eventhdl;
+ }
+
+ s = (int)write(evhdl, &u, sizeof(u));
+ if (s != sizeof(uint64_t)) {
+ /* error */
+ return 0;
+ }
+ return 1;
+}
+
+
+static void
+event_destroy(void *eventhdl)
+{
+ int evhdl;
+
+ if (sizeof(int) == sizeof(void *)) {
+ evhdl = (int)eventhdl;
+ close(evhdl);
+ } else {
+ if (!eventhdl) {
+ /* error */
+ return;
+ }
+ evhdl = *(int *)eventhdl;
+ close(evhdl);
+ mg_free(eventhdl);
+ }
+}
+
+
+#if defined(__GNUC__) || defined(__MINGW32__)
+#pragma GCC diagnostic pop
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif
+
+#endif
+
+
+#if !defined(__linux__) && !defined(_WIN32) && defined(ALTERNATIVE_QUEUE)
+
+struct posix_event {
+ pthread_mutex_t mutex;
+ pthread_cond_t cond;
+};
+
+
+static void *
+event_create(void)
+{
+ struct posix_event *ret = mg_malloc(sizeof(struct posix_event));
+ if (ret == 0) {
+ /* out of memory */
+ return 0;
+ }
+ if (0 != pthread_mutex_init(&(ret->mutex), NULL)) {
+ /* pthread mutex not available */
+ mg_free(ret);
+ return 0;
+ }
+ if (0 != pthread_cond_init(&(ret->cond), NULL)) {
+ /* pthread cond not available */
+ pthread_mutex_destroy(&(ret->mutex));
+ mg_free(ret);
+ return 0;
+ }
+ return (void *)ret;
+}
+
+
+static int
+event_wait(void *eventhdl)
+{
+ struct posix_event *ev = (struct posix_event *)eventhdl;
+ pthread_mutex_lock(&(ev->mutex));
+ pthread_cond_wait(&(ev->cond), &(ev->mutex));
+ pthread_mutex_unlock(&(ev->mutex));
+ return 1;
+}
+
+
+static int
+event_signal(void *eventhdl)
+{
+ struct posix_event *ev = (struct posix_event *)eventhdl;
+ pthread_mutex_lock(&(ev->mutex));
+ pthread_cond_signal(&(ev->cond));
+ pthread_mutex_unlock(&(ev->mutex));
+ return 1;
+}
+
+
+static void
+event_destroy(void *eventhdl)
+{
+ struct posix_event *ev = (struct posix_event *)eventhdl;
+ pthread_cond_destroy(&(ev->cond));
+ pthread_mutex_destroy(&(ev->mutex));
+ mg_free(ev);
+}
#endif
@@ -1487,88 +2743,206 @@ mg_get_valid_options(void)
}
+/* Do not open file (used in is_file_in_memory) */
+#define MG_FOPEN_MODE_NONE (0)
+
+/* Open file for read only access */
+#define MG_FOPEN_MODE_READ (1)
+
+/* Open file for writing, create and overwrite */
+#define MG_FOPEN_MODE_WRITE (2)
+
+/* Open file for writing, create and append */
+#define MG_FOPEN_MODE_APPEND (4)
+
+
+/* If a file is in memory, set all "stat" members and the membuf pointer of
+ * output filep and return 1, otherwise return 0 and don't modify anything.
+ */
static int
-is_file_in_memory(const struct mg_connection *conn,
- const char *path,
- struct file *filep)
+open_file_in_memory(const struct mg_connection *conn,
+ const char *path,
+ struct mg_file *filep,
+ int mode)
{
+#if defined(MG_USE_OPEN_FILE)
+
size_t size = 0;
- if (!conn || !filep) {
+ const char *buf = NULL;
+ if (!conn) {
+ return 0;
+ }
+
+ if ((mode != MG_FOPEN_MODE_NONE) && (mode != MG_FOPEN_MODE_READ)) {
return 0;
}
if (conn->ctx->callbacks.open_file) {
- filep->membuf = conn->ctx->callbacks.open_file(conn, path, &size);
- if (filep->membuf != NULL) {
- /* NOTE: override filep->size only on success. Otherwise, it might
+ buf = conn->ctx->callbacks.open_file(conn, path, &size);
+ if (buf != NULL) {
+ if (filep == NULL) {
+ /* This is a file in memory, but we cannot store the
+ * properties
+ * now.
+ * Called from "is_file_in_memory" function. */
+ return 1;
+ }
+
+ /* NOTE: override filep->size only on success. Otherwise, it
+ * might
* break constructs like if (!mg_stat() || !mg_fopen()) ... */
- filep->size = size;
+ filep->access.membuf = buf;
+ filep->access.fp = NULL;
+
+ /* Size was set by the callback */
+ filep->stat.size = size;
+
+ /* Assume the data may change during runtime by setting
+ * last_modified = now */
+ filep->stat.last_modified = time(NULL);
+
+ filep->stat.is_directory = 0;
+ filep->stat.is_gzipped = 0;
}
}
- return filep->membuf != NULL;
+ return (buf != NULL);
+
+#else
+ (void)conn;
+ (void)path;
+ (void)filep;
+ (void)mode;
+
+ return 0;
+
+#endif
}
static int
-is_file_opened(const struct file *filep)
+is_file_in_memory(const struct mg_connection *conn, const char *path)
{
- if (!filep) {
+ return open_file_in_memory(conn, path, NULL, MG_FOPEN_MODE_NONE);
+}
+
+
+static int
+is_file_opened(const struct mg_file_access *fileacc)
+{
+ if (!fileacc) {
return 0;
}
-
- return filep->membuf != NULL || filep->fp != NULL;
+ return (fileacc->membuf != NULL) || (fileacc->fp != NULL);
}
+static int mg_stat(const struct mg_connection *conn,
+ const char *path,
+ struct mg_file_stat *filep);
+
+
/* mg_fopen will open a file either in memory or on the disk.
* The input parameter path is a string in UTF-8 encoding.
- * The input parameter mode is the same as for fopen.
- * Either fp or membuf will be set in the output struct filep.
+ * The input parameter mode is MG_FOPEN_MODE_*
+ * On success, either fp or membuf will be set in the output
+ * struct file. All status members will also be set.
* The function returns 1 on success, 0 on error. */
static int
mg_fopen(const struct mg_connection *conn,
const char *path,
- const char *mode,
- struct file *filep)
+ int mode,
+ struct mg_file *filep)
{
- struct stat st;
+ int found;
if (!filep) {
return 0;
}
+ filep->access.fp = NULL;
+ filep->access.membuf = NULL;
- /* TODO (high): mg_fopen should only open a file, while mg_stat should
- * only get the file status. They should not work on different members of
- * the same structure (bad cohesion). */
- memset(filep, 0, sizeof(*filep));
+ if (!is_file_in_memory(conn, path)) {
- if (stat(path, &st) == 0) {
- filep->size = (uint64_t)(st.st_size);
- }
+ /* filep is initialized in mg_stat: all fields with memset to,
+ * some fields like size and modification date with values */
+ found = mg_stat(conn, path, &(filep->stat));
+
+ if ((mode == MG_FOPEN_MODE_READ) && (!found)) {
+ /* file does not exist and will not be created */
+ return 0;
+ }
- if (!is_file_in_memory(conn, path, filep)) {
#ifdef _WIN32
- wchar_t wbuf[PATH_MAX], wmode[20];
- path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf));
- MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, ARRAY_SIZE(wmode));
- filep->fp = _wfopen(wbuf, wmode);
+ {
+ wchar_t wbuf[PATH_MAX];
+ path_to_unicode(conn, path, wbuf, ARRAY_SIZE(wbuf));
+ switch (mode) {
+ case MG_FOPEN_MODE_READ:
+ filep->access.fp = _wfopen(wbuf, L"rb");
+ break;
+ case MG_FOPEN_MODE_WRITE:
+ filep->access.fp = _wfopen(wbuf, L"wb");
+ break;
+ case MG_FOPEN_MODE_APPEND:
+ filep->access.fp = _wfopen(wbuf, L"ab");
+ break;
+ }
+ }
#else
/* Linux et al already use unicode. No need to convert. */
- filep->fp = fopen(path, mode);
+ switch (mode) {
+ case MG_FOPEN_MODE_READ:
+ filep->access.fp = fopen(path, "r");
+ break;
+ case MG_FOPEN_MODE_WRITE:
+ filep->access.fp = fopen(path, "w");
+ break;
+ case MG_FOPEN_MODE_APPEND:
+ filep->access.fp = fopen(path, "a");
+ break;
+ }
+
#endif
+ if (!found) {
+ /* File did not exist before fopen was called.
+ * Maybe it has been created now. Get stat info
+ * like creation time now. */
+ found = mg_stat(conn, path, &(filep->stat));
+ (void)found;
+ }
+
+ /* file is on disk */
+ return (filep->access.fp != NULL);
+
+ } else {
+ /* is_file_in_memory returned true */
+ if (open_file_in_memory(conn, path, filep, mode)) {
+ /* file is in memory */
+ return (filep->access.membuf != NULL);
+ }
}
- return is_file_opened(filep);
+ /* Open failed */
+ return 0;
}
-static void
-mg_fclose(struct file *filep)
+/* return 0 on success, just like fclose */
+static int
+mg_fclose(struct mg_file_access *fileacc)
{
- if (filep != NULL && filep->fp != NULL) {
- fclose(filep->fp);
+ int ret = -1;
+ if (fileacc != NULL) {
+ if (fileacc->fp != NULL) {
+ ret = fclose(fileacc->fp);
+ } else if (fileacc->membuf != NULL) {
+ ret = 0;
+ }
+ /* reset all members of fileacc */
+ memset(fileacc, 0, sizeof(*fileacc));
}
+ return ret;
}
@@ -1667,6 +3041,9 @@ mg_vsnprintf(const struct mg_connection *conn,
int n, ok;
if (buflen == 0) {
+ if (truncated) {
+ *truncated = 1;
+ }
return;
}
@@ -1779,6 +3156,8 @@ mg_get_user_connection_data(const struct mg_connection *conn)
}
+#if defined(MG_LEGACY_INTERFACE)
+/* Deprecated: Use mg_get_server_ports instead. */
size_t
mg_get_ports(const struct mg_context *ctx, size_t size, int *ports, int *ssl)
{
@@ -1788,10 +3167,17 @@ mg_get_ports(const struct mg_context *ctx, size_t size, int *ports, int *ssl)
}
for (i = 0; i < size && i < ctx->num_listening_sockets; i++) {
ssl[i] = ctx->listening_sockets[i].is_ssl;
- ports[i] = ctx->listening_ports[i];
+ ports[i] =
+#if defined(USE_IPV6)
+ (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET6)
+ ? ntohs(ctx->listening_sockets[i].lsa.sin6.sin6_port)
+ :
+#endif
+ ntohs(ctx->listening_sockets[i].lsa.sin.sin_port);
}
return i;
}
+#endif
int
@@ -1808,13 +3194,19 @@ mg_get_server_ports(const struct mg_context *ctx,
if (!ctx) {
return -1;
}
- if (!ctx->listening_sockets || !ctx->listening_ports) {
+ if (!ctx->listening_sockets) {
return -1;
}
for (i = 0; (i < size) && (i < (int)ctx->num_listening_sockets); i++) {
- ports[cnt].port = ctx->listening_ports[i];
+ ports[cnt].port =
+#if defined(USE_IPV6)
+ (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET6)
+ ? ntohs(ctx->listening_sockets[i].lsa.sin6.sin6_port)
+ :
+#endif
+ ntohs(ctx->listening_sockets[i].lsa.sin.sin_port);
ports[cnt].is_ssl = ctx->listening_sockets[i].is_ssl;
ports[cnt].is_redirect = ctx->listening_sockets[i].ssl_redir;
@@ -1897,7 +3289,7 @@ mg_cry(const struct mg_connection *conn, const char *fmt, ...)
{
char buf[MG_BUF_LEN], src_addr[IP_ADDR_STR_LEN];
va_list ap;
- struct file fi;
+ struct mg_file fi;
time_t timestamp;
va_start(ap, fmt);
@@ -1905,6 +3297,8 @@ mg_cry(const struct mg_connection *conn, const char *fmt, ...)
va_end(ap);
buf[sizeof(buf) - 1] = 0;
+ DEBUG_TRACE("mg_cry: %s", buf);
+
if (!conn) {
puts(buf);
return;
@@ -1917,36 +3311,41 @@ mg_cry(const struct mg_connection *conn, const char *fmt, ...)
|| (conn->ctx->callbacks.log_message(conn, buf) == 0)) {
if (conn->ctx->config[ERROR_LOG_FILE] != NULL) {
- if (mg_fopen(conn, conn->ctx->config[ERROR_LOG_FILE], "a+", &fi)
- == 0) {
- fi.fp = NULL;
+ if (mg_fopen(conn,
+ conn->ctx->config[ERROR_LOG_FILE],
+ MG_FOPEN_MODE_APPEND,
+ &fi) == 0) {
+ fi.access.fp = NULL;
}
} else {
- fi.fp = NULL;
+ fi.access.fp = NULL;
}
- if (fi.fp != NULL) {
- flockfile(fi.fp);
+ if (fi.access.fp != NULL) {
+ flockfile(fi.access.fp);
timestamp = time(NULL);
sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa);
- fprintf(fi.fp,
+ fprintf(fi.access.fp,
"[%010lu] [error] [client %s] ",
(unsigned long)timestamp,
src_addr);
if (conn->request_info.request_method != NULL) {
- fprintf(fi.fp,
+ fprintf(fi.access.fp,
"%s %s: ",
conn->request_info.request_method,
- conn->request_info.request_uri);
+ conn->request_info.request_uri
+ ? conn->request_info.request_uri
+ : "");
}
- fprintf(fi.fp, "%s", buf);
- fputc('\n', fi.fp);
- fflush(fi.fp);
- funlockfile(fi.fp);
- mg_fclose(&fi);
+ fprintf(fi.access.fp, "%s", buf);
+ fputc('\n', fi.access.fp);
+ fflush(fi.access.fp);
+ funlockfile(fi.access.fp);
+ (void)mg_fclose(&fi.access); /* Ignore errors. We can't call
+ * mg_cry here anyway ;-) */
}
}
}
@@ -1954,7 +3353,7 @@ mg_cry(const struct mg_connection *conn, const char *fmt, ...)
void
mg_set_http_status(struct mg_connection *conn, int status)
{
- conn->status_code = status;
+ conn->status_code = status;
}
/* Return fake connection structure. Used for logging, if connection
@@ -1981,10 +3380,150 @@ mg_get_request_info(const struct mg_connection *conn)
if (!conn) {
return NULL;
}
+#if 1 /* TODO: deal with legacy */
+ if (conn->connection_type == CONNECTION_TYPE_RESPONSE) {
+ static char txt[16];
+ sprintf(txt, "%03i", conn->response_info.status_code);
+
+ ((struct mg_connection *)conn)->request_info.local_uri =
+ ((struct mg_connection *)conn)->request_info.request_uri =
+ txt; /* TODO: not thread safe */
+
+ ((struct mg_connection *)conn)->request_info.num_headers =
+ conn->response_info.num_headers;
+ memcpy(((struct mg_connection *)conn)->request_info.http_headers,
+ conn->response_info.http_headers,
+ sizeof(conn->response_info.http_headers));
+ } else
+#endif
+ if (conn->connection_type != CONNECTION_TYPE_REQUEST) {
+ return NULL;
+ }
return &conn->request_info;
}
+const struct mg_response_info *
+mg_get_response_info(const struct mg_connection *conn)
+{
+ if (!conn) {
+ return NULL;
+ }
+ if (conn->connection_type != CONNECTION_TYPE_RESPONSE) {
+ return NULL;
+ }
+ return &conn->response_info;
+}
+
+
+static const char *
+get_proto_name(const struct mg_connection *conn)
+{
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code"
+/* Depending on USE_WEBSOCKET and NO_SSL, some oft the protocols might be
+ * not supported. Clang raises an "unreachable code" warning for parts of ?:
+ * unreachable, but splitting into four different #ifdef clauses here is more
+ * complicated.
+ */
+#endif
+
+ const struct mg_request_info *ri = &conn->request_info;
+
+ const char *proto =
+ (is_websocket_protocol(conn) ? (ri->is_ssl ? "wss" : "ws")
+ : (ri->is_ssl ? "https" : "http"));
+
+ return proto;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}
+
+
+int
+mg_get_request_link(const struct mg_connection *conn, char *buf, size_t buflen)
+{
+ if ((buflen < 1) || (buf == 0) || (conn == 0)) {
+ return -1;
+ } else {
+
+ int truncated = 0;
+ const struct mg_request_info *ri = &conn->request_info;
+
+ const char *proto = get_proto_name(conn);
+
+ if (ri->local_uri == NULL) {
+ return -1;
+ }
+
+ if ((ri->request_uri != NULL)
+ && strcmp(ri->local_uri, ri->request_uri)) {
+ mg_snprintf(conn,
+ &truncated,
+ buf,
+ buflen,
+ "%s://%s",
+ proto,
+ ri->request_uri);
+ if (truncated) {
+ return -1;
+ }
+ return 0;
+ } else {
+
+#if defined(USE_IPV6)
+ int is_ipv6 = (conn->client.lsa.sa.sa_family == AF_INET6);
+ int port = is_ipv6 ? htons(conn->client.lsa.sin6.sin6_port)
+ : htons(conn->client.lsa.sin.sin_port);
+#else
+ int port = htons(conn->client.lsa.sin.sin_port);
+#endif
+ int def_port = ri->is_ssl ? 443 : 80;
+ int auth_domain_check_enabled =
+ conn->ctx->config[ENABLE_AUTH_DOMAIN_CHECK]
+ && (!mg_strcasecmp(conn->ctx->config[ENABLE_AUTH_DOMAIN_CHECK],
+ "yes"));
+ const char *server_domain =
+ conn->ctx->config[AUTHENTICATION_DOMAIN];
+
+ char portstr[16];
+ char server_ip[48];
+
+ if (port != def_port) {
+ sprintf(portstr, ":%u", (unsigned)port);
+ } else {
+ portstr[0] = 0;
+ }
+
+ if (!auth_domain_check_enabled || !server_domain) {
+
+ sockaddr_to_string(server_ip,
+ sizeof(server_ip),
+ &conn->client.lsa);
+
+ server_domain = server_ip;
+ }
+
+ mg_snprintf(conn,
+ &truncated,
+ buf,
+ buflen,
+ "%s://%s%s%s",
+ proto,
+ server_domain,
+ portstr,
+ ri->local_uri);
+ if (truncated) {
+ return -1;
+ }
+ return 0;
+ }
+ }
+}
+
struct sockaddr *
mg_get_local_addr(struct mg_connection *conn)
{
@@ -1994,7 +3533,8 @@ mg_get_local_addr(struct mg_connection *conn)
/* Skip the characters until one of the delimiters characters found.
* 0-terminate resulting word. Skip the delimiter and following whitespaces.
- * Advance pointer to buffer to the next word. Return found 0-terminated word.
+ * 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,
@@ -2011,7 +3551,8 @@ skip_quoted(char **buf,
if (end_word > begin_word) {
p = end_word - 1;
while (*p == quotechar) {
- /* While the delimiter is quoted, look for the next delimiter. */
+ /* While the delimiter is quoted, look for the next delimiter.
+ */
/* This happens, e.g., in calls from parse_auth_header,
* if the user name contains a " character. */
@@ -2034,7 +3575,22 @@ skip_quoted(char **buf,
if (*end_word == '\0') {
*buf = end_word;
} else {
- end_whitespace = end_word + 1 + strspn(end_word + 1, whitespace);
+
+#if defined(__GNUC__) || defined(__MINGW32__)
+/* Disable spurious conversion warning for GCC */
+#if GCC_VERSION >= 40500
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif /* GCC_VERSION >= 40500 */
+#endif /* defined(__GNUC__) || defined(__MINGW32__) */
+
+ end_whitespace = end_word + strspn(&end_word[1], whitespace) + 1;
+
+#if defined(__GNUC__) || defined(__MINGW32__)
+#if GCC_VERSION >= 40500
+#pragma GCC diagnostic pop
+#endif /* GCC_VERSION >= 40500 */
+#endif /* defined(__GNUC__) || defined(__MINGW32__) */
for (p = end_word; p < end_whitespace; p++) {
*p = '\0';
@@ -2047,25 +3603,14 @@ skip_quoted(char **buf,
}
-/* Simplified version of skip_quoted without quote char
- * and whitespace == delimiters */
-static char *
-skip(char **buf, const char *delimiters)
-{
- return skip_quoted(buf, delimiters, delimiters, 0);
-}
-
-
/* Return HTTP header value, or NULL if not found. */
static const char *
-get_header(const struct mg_request_info *ri, const char *name)
+get_header(const struct mg_header *hdr, int num_hdr, const char *name)
{
int i;
- if (ri) {
- for (i = 0; i < ri->num_headers; i++) {
- if (!mg_strcasecmp(name, ri->http_headers[i].name)) {
- return ri->http_headers[i].value;
- }
+ for (i = 0; i < num_hdr; i++) {
+ if (!mg_strcasecmp(name, hdr[i].name)) {
+ return hdr[i].value;
}
}
@@ -2073,6 +3618,29 @@ get_header(const struct mg_request_info *ri, const char *name)
}
+#if defined(USE_WEBSOCKET)
+/* Retrieve requested HTTP header multiple values, and return the number of
+ * found occurences */
+static int
+get_req_headers(const struct mg_request_info *ri,
+ const char *name,
+ const char **output,
+ int output_max_size)
+{
+ int i;
+ int cnt = 0;
+ if (ri) {
+ for (i = 0; i < ri->num_headers && cnt < output_max_size; i++) {
+ if (!mg_strcasecmp(name, ri->http_headers[i].name)) {
+ output[cnt++] = ri->http_headers[i].value;
+ }
+ }
+ }
+ return cnt;
+}
+#endif
+
+
const char *
mg_get_header(const struct mg_connection *conn, const char *name)
{
@@ -2080,7 +3648,34 @@ mg_get_header(const struct mg_connection *conn, const char *name)
return NULL;
}
- return get_header(&conn->request_info, name);
+ if (conn->connection_type == CONNECTION_TYPE_REQUEST) {
+ return get_header(conn->request_info.http_headers,
+ conn->request_info.num_headers,
+ name);
+ }
+ if (conn->connection_type == CONNECTION_TYPE_RESPONSE) {
+ return get_header(conn->response_info.http_headers,
+ conn->request_info.num_headers,
+ name);
+ }
+ return NULL;
+}
+
+
+static const char *
+get_http_version(const struct mg_connection *conn)
+{
+ if (!conn) {
+ return NULL;
+ }
+
+ if (conn->connection_type == CONNECTION_TYPE_REQUEST) {
+ return conn->request_info.http_version;
+ }
+ if (conn->connection_type == CONNECTION_TYPE_RESPONSE) {
+ return conn->response_info.http_version;
+ }
+ return NULL;
}
@@ -2098,51 +3693,53 @@ next_option(const char *list, struct vec *val, struct vec *eq_val)
reparse:
if (val == NULL || list == NULL || *list == '\0') {
/* End of the list */
- list = NULL;
+ return NULL;
+ }
+
+ /* Skip over leading LWS */
+ while (*list == ' ' || *list == '\t')
+ list++;
+
+ val->ptr = list;
+ if ((list = strchr(val->ptr, ',')) != NULL) {
+ /* Comma found. Store length and shift the list ptr */
+ val->len = ((size_t)(list - val->ptr));
+ list++;
} else {
- /* Skip over leading LWS */
- while (*list == ' ' || *list == '\t')
- list++;
+ /* This value is the last one */
+ list = val->ptr + strlen(val->ptr);
+ val->len = ((size_t)(list - val->ptr));
+ }
- val->ptr = list;
- if ((list = strchr(val->ptr, ',')) != NULL) {
- /* Comma found. Store length and shift the list ptr */
- val->len = ((size_t)(list - val->ptr));
- list++;
- } else {
- /* This value is the last one */
- list = val->ptr + strlen(val->ptr);
- val->len = ((size_t)(list - val->ptr));
- }
+ /* Adjust length for trailing LWS */
+ end = (int)val->len - 1;
+ while (end >= 0 && ((val->ptr[end] == ' ') || (val->ptr[end] == '\t')))
+ end--;
+ val->len = (size_t)(end + 1);
- /* Adjust length for trailing LWS */
- end = (int)val->len - 1;
- while (end >= 0 && (val->ptr[end] == ' ' || val->ptr[end] == '\t'))
- end--;
- val->len = (size_t)(end + 1);
+ if (val->len == 0) {
+ /* Ignore any empty entries. */
+ goto reparse;
+ }
- if (val->len == 0) {
- /* Ignore any empty entries. */
- goto reparse;
- }
-
- if (eq_val != NULL) {
- /* Value has form "x=y", adjust pointers and lengths
- * so that val points to "x", and eq_val points to "y". */
- eq_val->len = 0;
- eq_val->ptr = (const char *)memchr(val->ptr, '=', val->len);
- if (eq_val->ptr != NULL) {
- eq_val->ptr++; /* Skip over '=' character */
- eq_val->len = ((size_t)(val->ptr - eq_val->ptr)) + val->len;
- val->len = ((size_t)(eq_val->ptr - val->ptr)) - 1;
- }
+ if (eq_val != NULL) {
+ /* Value has form "x=y", adjust pointers and lengths
+ * so that val points to "x", and eq_val points to "y". */
+ eq_val->len = 0;
+ eq_val->ptr = (const char *)memchr(val->ptr, '=', val->len);
+ if (eq_val->ptr != NULL) {
+ eq_val->ptr++; /* Skip over '=' character */
+ eq_val->len = ((size_t)(val->ptr - eq_val->ptr)) + val->len;
+ val->len = ((size_t)(eq_val->ptr - val->ptr)) - 1;
}
}
return list;
}
-/* A helper function for checking if a comma separated list of values contains
+
+/* A helper function for checking if a comma separated list of values
+ * contains
* the given option (case insensitvely).
* 'header' can be NULL, in which case false is returned. */
static int
@@ -2151,8 +3748,10 @@ header_has_option(const char *header, const char *option)
struct vec opt_vec;
struct vec eq_vec;
+ /*
assert(option != NULL);
assert(option[0] != '\0');
+ */
while ((header = next_option(header, &opt_vec, &eq_vec)) != NULL) {
if (mg_strncasecmp(option, opt_vec.ptr, opt_vec.len) == 0)
@@ -2162,6 +3761,7 @@ header_has_option(const char *header, const char *option)
return 0;
}
+
/* Perform case-insensitive match of string against pattern */
static int
match_prefix(const char *pattern, size_t pattern_len, const char *str)
@@ -2172,17 +3772,17 @@ match_prefix(const char *pattern, size_t pattern_len, const char *str)
if ((or_str = (const char *)memchr(pattern, '|', pattern_len)) != NULL) {
res = match_prefix(pattern, (size_t)(or_str - pattern), str);
- return res > 0 ? res : match_prefix(or_str + 1,
- (size_t)((pattern + pattern_len)
- - (or_str + 1)),
- str);
+ return (res > 0) ? res : match_prefix(or_str + 1,
+ (size_t)((pattern + pattern_len)
+ - (or_str + 1)),
+ str);
}
- for (i = 0, j = 0; i < pattern_len; i++, j++) {
- if (pattern[i] == '?' && str[j] != '\0') {
+ for (i = 0, j = 0; (i < pattern_len); i++, j++) {
+ if ((pattern[i] == '?') && (str[j] != '\0')) {
continue;
} else if (pattern[i] == '$') {
- return str[j] == '\0' ? j : -1;
+ return (str[j] == '\0') ? j : -1;
} else if (pattern[i] == '*') {
i++;
if (pattern[i] == '*') {
@@ -2197,7 +3797,7 @@ match_prefix(const char *pattern, size_t pattern_len, const char *str)
do {
res = match_prefix(pattern + i, pattern_len - i, str + j + len);
} while (res == -1 && len-- > 0);
- return res == -1 ? -1 : j + res + len;
+ return (res == -1) ? -1 : j + res + len;
} else if (lowercase(&pattern[i]) != lowercase(&str[j])) {
return -1;
}
@@ -2212,18 +3812,38 @@ match_prefix(const char *pattern, size_t pattern_len, const char *str)
static int
should_keep_alive(const struct mg_connection *conn)
{
- if (conn != NULL) {
- const char *http_version = conn->request_info.http_version;
- const char *header = mg_get_header(conn, "Connection");
- if (conn->must_close || conn->internal_error || conn->status_code == 401
- || mg_strcasecmp(conn->ctx->config[ENABLE_KEEP_ALIVE], "yes") != 0
- || (header != NULL && !header_has_option(header, "keep-alive"))
- || (header == NULL && http_version
- && 0 != strcmp(http_version, "1.1"))) {
- return 0;
+ const char *http_version;
+ const char *header;
+
+ /* First satisfy needs of the server */
+ if ((conn == NULL) || conn->must_close) {
+ /* Close, if civetweb framework needs to close */
+ return 0;
+ }
+
+ if (mg_strcasecmp(conn->ctx->config[ENABLE_KEEP_ALIVE], "yes") != 0) {
+ /* Close, if keep alive is not enabled */
+ return 0;
+ }
+
+ /* Check explicit wish of the client */
+ header = mg_get_header(conn, "Connection");
+ if (header) {
+ /* If there is a connection header from the client, obey */
+ if (header_has_option(header, "keep-alive")) {
+ return 1;
}
+ return 0;
+ }
+
+ /* Use default of the standard */
+ http_version = get_http_version(conn);
+ if (http_version && (0 == strcmp(http_version, "1.1"))) {
+ /* HTTP 1.1 default is keep alive */
return 1;
}
+
+ /* HTTP 1.0 (and earlier) default is to close the connection */
return 0;
}
@@ -2238,16 +3858,6 @@ should_decode_url(const struct mg_connection *conn)
return (mg_strcasecmp(conn->ctx->config[DECODE_URL], "yes") == 0);
}
-static int
-should_validate_http_method(const struct mg_connection *conn)
-{
- if (!conn || !conn->ctx || !conn->ctx->config[VALIDATE_HTTP_METHOD]) {
- return 1;
- }
-
- return (mg_strcasecmp(conn->ctx->config[VALIDATE_HTTP_METHOD], "yes") == 0);
-}
-
static const char *
suggest_connection_header(const struct mg_connection *conn)
@@ -2287,7 +3897,8 @@ send_static_cache_header(struct mg_connection *conn)
* Reason: see https://www.mnot.net/blog/2007/05/15/expires_max-age */
/* See also https://www.mnot.net/cache_docs/ */
/* According to RFC 2616, Section 14.21, caching times should not exceed
- * one year. A year with 365 days corresponds to 31536000 seconds, a leap
+ * one year. A year with 365 days corresponds to 31536000 seconds, a
+ * leap
* year to 31622400 seconds. For the moment, we just send whatever has
* been configured, still the behavior for >1 year should be considered
* as undefined. */
@@ -2298,16 +3909,38 @@ send_static_cache_header(struct mg_connection *conn)
}
+static int
+send_additional_header(struct mg_connection *conn)
+{
+ int i = 0;
+ const char *header = conn->ctx->config[ADDITIONAL_HEADER];
+
+#if !defined(NO_SSL)
+ if (conn->ctx->config[STRICT_HTTPS_MAX_AGE]) {
+ int max_age = atoi(conn->ctx->config[STRICT_HTTPS_MAX_AGE]);
+ if (max_age >= 0) {
+ i += mg_printf(conn,
+ "Strict-Transport-Security: max-age=%u\r\n",
+ (unsigned)max_age);
+ }
+ }
+#endif
+
+ if (header && header[0]) {
+ i += mg_printf(conn, "%s\r\n", header);
+ }
+
+ return i;
+}
+
+
static void handle_file_based_request(struct mg_connection *conn,
const char *path,
- struct file *filep);
-
-static int
-mg_stat(struct mg_connection *conn, const char *path, struct file *filep);
+ struct mg_file *filep);
const char *
-mg_get_response_code_text(struct mg_connection *conn, int response_code)
+mg_get_response_code_text(const struct mg_connection *conn, int response_code)
{
/* See IANA HTTP status code assignment:
* http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
@@ -2338,7 +3971,8 @@ mg_get_response_code_text(struct mg_connection *conn, int response_code)
case 206:
return "Partial Content"; /* RFC2616 Section 10.2.7 */
case 207:
- return "Multi-Status"; /* RFC2518 Section 10.2, RFC4918 Section 11.1 */
+ return "Multi-Status"; /* RFC2518 Section 10.2, RFC4918 Section 11.1
+ */
case 208:
return "Already Reported"; /* RFC5842 Section 7.1 */
@@ -2397,7 +4031,8 @@ mg_get_response_code_text(struct mg_connection *conn, int response_code)
case 415:
return "Unsupported Media Type"; /* RFC2616 Section 10.4.16 */
case 416:
- return "Requested range not satisfiable"; /* RFC2616 Section 10.4.17 */
+ return "Requested range not satisfiable"; /* RFC2616 Section 10.4.17
+ */
case 417:
return "Expectation Failed"; /* RFC2616 Section 10.4.18 */
@@ -2453,7 +4088,8 @@ mg_get_response_code_text(struct mg_connection *conn, int response_code)
case 511:
return "Network Authentication Required"; /* RFC 6585, Section 6 */
- /* Other status codes, not shown in the IANA HTTP status code assignment.
+ /* Other status codes, not shown in the IANA HTTP status code
+ * assignment.
* E.g., "de facto" standards due to common use, ... */
case 418:
return "I am a teapot"; /* RFC2324 Section 2.3.2 */
@@ -2500,21 +4136,16 @@ mg_get_response_code_text(struct mg_connection *conn, int response_code)
}
-static void send_http_error(struct mg_connection *,
- int,
- PRINTF_FORMAT_STRING(const char *fmt),
- ...) PRINTF_ARGS(3, 4);
-
-static void
-send_http_error(struct mg_connection *conn, int status, const char *fmt, ...)
+void
+mg_send_http_error(struct mg_connection *conn, int status, const char *fmt, ...)
{
char buf[MG_BUF_LEN];
va_list ap;
- int len, i, page_handler_found, scope, truncated;
+ int len, i, page_handler_found, scope, truncated, has_body;
char date[64];
time_t curtime = time(NULL);
const char *error_handler = NULL;
- struct file error_page_file = STRUCT_FILE_INITIALIZER;
+ struct mg_file error_page_file = STRUCT_FILE_INITIALIZER;
const char *error_page_file_ext, *tstr;
const char *status_text = mg_get_response_code_text(conn, status);
@@ -2524,13 +4155,20 @@ send_http_error(struct mg_connection *conn, int status, const char *fmt, ...)
}
conn->status_code = status;
- if (conn->in_error_handler || conn->ctx->callbacks.http_error == NULL
+ if (conn->in_error_handler || (conn->ctx->callbacks.http_error == NULL)
|| conn->ctx->callbacks.http_error(conn, status)) {
- if (!conn->in_error_handler) {
+
+ /* Check for recursion */
+ if (conn->in_error_handler) {
+ DEBUG_TRACE(
+ "Recursion when handling error %u - fall back to default",
+ status);
+ } else {
/* Send user defined error pages, if defined */
error_handler = conn->ctx->config[ERROR_PAGES];
error_page_file_ext = conn->ctx->config[INDEX_FILES];
page_handler_found = 0;
+
if (error_handler != NULL) {
for (scope = 1; (scope <= 3) && !page_handler_found; scope++) {
switch (scope) {
@@ -2543,7 +4181,8 @@ send_http_error(struct mg_connection *conn, int status, const char *fmt, ...)
error_handler,
status);
break;
- case 2: /* Handler for error group, e.g., 5xx error handler
+ case 2: /* Handler for error group, e.g., 5xx error
+ * handler
* for all server errors (500-599) */
mg_snprintf(conn,
&truncated,
@@ -2563,9 +4202,9 @@ send_http_error(struct mg_connection *conn, int status, const char *fmt, ...)
break;
}
- /* String truncation in buf may only occur if error_handler
- * is too long. This string is from the config, not from a
- * client. */
+ /* String truncation in buf may only occur if
+ * error_handler is too long. This string is
+ * from the config, not from a client. */
(void)truncated;
len = (int)strlen(buf);
@@ -2573,14 +4212,19 @@ send_http_error(struct mg_connection *conn, int status, const char *fmt, ...)
tstr = strchr(error_page_file_ext, '.');
while (tstr) {
- for (i = 1; i < 32 && tstr[i] != 0 && tstr[i] != ',';
+ for (i = 1;
+ (i < 32) && (tstr[i] != 0) && (tstr[i] != ',');
i++)
buf[len + i - 1] = tstr[i];
buf[len + i - 1] = 0;
- if (mg_stat(conn, buf, &error_page_file)) {
+
+ if (mg_stat(conn, buf, &error_page_file.stat)) {
+ DEBUG_TRACE("Check error page %s - found", buf);
page_handler_found = 1;
break;
}
+ DEBUG_TRACE("Check error page %s - not found", buf);
+
tstr = strchr(tstr + i, '.');
}
}
@@ -2597,17 +4241,25 @@ send_http_error(struct mg_connection *conn, int status, const char *fmt, ...)
/* No custom error page. Send default error page. */
gmt_time_string(date, sizeof(date), &curtime);
+ /* Errors 1xx, 204 and 304 MUST NOT send a body */
+ has_body = ((status > 199) && (status != 204) && (status != 304));
+
conn->must_close = 1;
mg_printf(conn, "HTTP/1.1 %d %s\r\n", status, status_text);
send_no_cache_header(conn);
+ send_additional_header(conn);
+ if (has_body) {
+ mg_printf(conn,
+ "%s",
+ "Content-Type: text/plain; charset=utf-8\r\n");
+ }
mg_printf(conn,
"Date: %s\r\n"
"Connection: close\r\n\r\n",
date);
/* Errors 1xx, 204 and 304 MUST NOT send a body */
- if (status > 199 && status != 204 && status != 304) {
-
+ if (has_body) {
mg_printf(conn, "Error %d: %s\n", status, status_text);
if (fmt != NULL) {
@@ -2635,30 +4287,34 @@ send_http_error(struct mg_connection *conn, int status, const char *fmt, ...)
#endif
+FUNCTION_MAY_BE_UNUSED
static int
pthread_mutex_init(pthread_mutex_t *mutex, void *unused)
{
(void)unused;
*mutex = CreateMutex(NULL, FALSE, NULL);
- return *mutex == NULL ? -1 : 0;
+ return (*mutex == NULL) ? -1 : 0;
}
-
+FUNCTION_MAY_BE_UNUSED
static int
pthread_mutex_destroy(pthread_mutex_t *mutex)
{
- return CloseHandle(*mutex) == 0 ? -1 : 0;
+ return (CloseHandle(*mutex) == 0) ? -1 : 0;
}
+FUNCTION_MAY_BE_UNUSED
static int
pthread_mutex_lock(pthread_mutex_t *mutex)
{
- return WaitForSingleObject(*mutex, INFINITE) == WAIT_OBJECT_0 ? 0 : -1;
+ return (WaitForSingleObject(*mutex, (DWORD)INFINITE) == WAIT_OBJECT_0) ? 0
+ : -1;
}
#ifdef ENABLE_UNUSED_PTHREAD_FUNCTIONS
+FUNCTION_MAY_BE_UNUSED
static int
pthread_mutex_trylock(pthread_mutex_t *mutex)
{
@@ -2673,88 +4329,48 @@ pthread_mutex_trylock(pthread_mutex_t *mutex)
#endif
+FUNCTION_MAY_BE_UNUSED
static int
pthread_mutex_unlock(pthread_mutex_t *mutex)
{
- return ReleaseMutex(*mutex) == 0 ? -1 : 0;
+ return (ReleaseMutex(*mutex) == 0) ? -1 : 0;
}
-#ifndef WIN_PTHREADS_TIME_H
-static int
-clock_gettime(clockid_t clk_id, struct timespec *tp)
-{
- FILETIME ft;
- ULARGE_INTEGER li;
- BOOL ok = FALSE;
- double d;
- static double perfcnt_per_sec = 0.0;
-
- if (tp) {
- memset(tp, 0, sizeof(*tp));
- if (clk_id == CLOCK_REALTIME) {
- GetSystemTimeAsFileTime(&ft);
- li.LowPart = ft.dwLowDateTime;
- li.HighPart = ft.dwHighDateTime;
- li.QuadPart -= 116444736000000000; /* 1.1.1970 in filedate */
- tp->tv_sec = (time_t)(li.QuadPart / 10000000);
- tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100;
- ok = TRUE;
- } else if (clk_id == CLOCK_MONOTONIC) {
- if (perfcnt_per_sec == 0.0) {
- QueryPerformanceFrequency((LARGE_INTEGER *)&li);
- perfcnt_per_sec = 1.0 / li.QuadPart;
- }
- if (perfcnt_per_sec != 0.0) {
- QueryPerformanceCounter((LARGE_INTEGER *)&li);
- d = li.QuadPart * perfcnt_per_sec;
- tp->tv_sec = (time_t)d;
- d -= tp->tv_sec;
- tp->tv_nsec = (long)(d * 1.0E9);
- ok = TRUE;
- }
- }
- }
-
- return ok ? 0 : -1;
-}
-#endif
-
-
+FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_init(pthread_cond_t *cv, const void *unused)
{
(void)unused;
InitializeCriticalSection(&cv->threadIdSec);
- cv->waitingthreadcount = 0;
- cv->waitingthreadhdls =
- (pthread_t *)mg_calloc(MAX_WORKER_THREADS, sizeof(pthread_t));
- return (cv->waitingthreadhdls != NULL) ? 0 : -1;
+ cv->waiting_thread = NULL;
+ return 0;
}
+FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_timedwait(pthread_cond_t *cv,
pthread_mutex_t *mutex,
const struct timespec *abstime)
{
- struct mg_workerTLS *tls =
- (struct mg_workerTLS *)pthread_getspecific(sTlsKey);
+ struct mg_workerTLS **ptls,
+ *tls = (struct mg_workerTLS *)pthread_getspecific(sTlsKey);
int ok;
- struct timespec tsnow;
int64_t nsnow, nswaitabs, nswaitrel;
DWORD mswaitrel;
EnterCriticalSection(&cv->threadIdSec);
- assert(cv->waitingthreadcount < MAX_WORKER_THREADS);
- cv->waitingthreadhdls[cv->waitingthreadcount] =
- tls->pthread_cond_helper_mutex;
- cv->waitingthreadcount++;
+ /* Add this thread to cv's waiting list */
+ ptls = &cv->waiting_thread;
+ for (; *ptls != NULL; ptls = &(*ptls)->next_waiting_thread)
+ ;
+ tls->next_waiting_thread = NULL;
+ *ptls = tls;
LeaveCriticalSection(&cv->threadIdSec);
if (abstime) {
- clock_gettime(CLOCK_REALTIME, &tsnow);
- nsnow = (((int64_t)tsnow.tv_sec) * 1000000000) + tsnow.tv_nsec;
+ nsnow = mg_get_current_time_ns();
nswaitabs =
(((int64_t)abstime->tv_sec) * 1000000000) + abstime->tv_nsec;
nswaitrel = nswaitabs - nsnow;
@@ -2763,18 +4379,37 @@ pthread_cond_timedwait(pthread_cond_t *cv,
}
mswaitrel = (DWORD)(nswaitrel / 1000000);
} else {
- mswaitrel = INFINITE;
+ mswaitrel = (DWORD)INFINITE;
}
pthread_mutex_unlock(mutex);
ok = (WAIT_OBJECT_0
== WaitForSingleObject(tls->pthread_cond_helper_mutex, mswaitrel));
+ if (!ok) {
+ ok = 1;
+ EnterCriticalSection(&cv->threadIdSec);
+ ptls = &cv->waiting_thread;
+ for (; *ptls != NULL; ptls = &(*ptls)->next_waiting_thread) {
+ if (*ptls == tls) {
+ *ptls = tls->next_waiting_thread;
+ ok = 0;
+ break;
+ }
+ }
+ LeaveCriticalSection(&cv->threadIdSec);
+ if (ok) {
+ WaitForSingleObject(tls->pthread_cond_helper_mutex,
+ (DWORD)INFINITE);
+ }
+ }
+ /* This thread has been removed from cv's waiting list */
pthread_mutex_lock(mutex);
return ok ? 0 : -1;
}
+FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mutex)
{
@@ -2782,23 +4417,19 @@ pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mutex)
}
+FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_signal(pthread_cond_t *cv)
{
- int i;
HANDLE wkup = NULL;
BOOL ok = FALSE;
EnterCriticalSection(&cv->threadIdSec);
- if (cv->waitingthreadcount) {
- wkup = cv->waitingthreadhdls[0];
+ if (cv->waiting_thread) {
+ wkup = cv->waiting_thread->pthread_cond_helper_mutex;
+ cv->waiting_thread = cv->waiting_thread->next_waiting_thread;
+
ok = SetEvent(wkup);
-
- for (i = 1; i < cv->waitingthreadcount; i++) {
- cv->waitingthreadhdls[i - 1] = cv->waitingthreadhdls[i];
- }
- cv->waitingthreadcount--;
-
assert(ok);
}
LeaveCriticalSection(&cv->threadIdSec);
@@ -2807,11 +4438,12 @@ pthread_cond_signal(pthread_cond_t *cv)
}
+FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_broadcast(pthread_cond_t *cv)
{
EnterCriticalSection(&cv->threadIdSec);
- while (cv->waitingthreadcount) {
+ while (cv->waiting_thread) {
pthread_cond_signal(cv);
}
LeaveCriticalSection(&cv->threadIdSec);
@@ -2820,13 +4452,12 @@ pthread_cond_broadcast(pthread_cond_t *cv)
}
+FUNCTION_MAY_BE_UNUSED
static int
pthread_cond_destroy(pthread_cond_t *cv)
{
EnterCriticalSection(&cv->threadIdSec);
- assert(cv->waitingthreadcount == 0);
- mg_free(cv->waitingthreadhdls);
- cv->waitingthreadhdls = 0;
+ assert(cv->waiting_thread == NULL);
LeaveCriticalSection(&cv->threadIdSec);
DeleteCriticalSection(&cv->threadIdSec);
@@ -2834,6 +4465,41 @@ pthread_cond_destroy(pthread_cond_t *cv)
}
+#ifdef ALTERNATIVE_QUEUE
+FUNCTION_MAY_BE_UNUSED
+static void *
+event_create(void)
+{
+ return (void *)CreateEvent(NULL, FALSE, FALSE, NULL);
+}
+
+
+FUNCTION_MAY_BE_UNUSED
+static int
+event_wait(void *eventhdl)
+{
+ int res = WaitForSingleObject((HANDLE)eventhdl, (DWORD)INFINITE);
+ return (res == WAIT_OBJECT_0);
+}
+
+
+FUNCTION_MAY_BE_UNUSED
+static int
+event_signal(void *eventhdl)
+{
+ return (int)SetEvent((HANDLE)eventhdl);
+}
+
+
+FUNCTION_MAY_BE_UNUSED
+static void
+event_destroy(void *eventhdl)
+{
+ CloseHandle((HANDLE)eventhdl);
+}
+#endif
+
+
#if defined(__MINGW32__)
/* Enable unused function warning again */
#pragma GCC diagnostic pop
@@ -2854,7 +4520,7 @@ change_slashes_to_backslashes(char *path)
/* remove double backslash (check i > 0 to preserve UNC paths,
* like \\server\file.txt) */
if ((path[i] == '\\') && (i > 0)) {
- while (path[i + 1] == '\\' || path[i + 1] == '/') {
+ while ((path[i + 1] == '\\') || (path[i + 1] == '/')) {
(void)memmove(path + i + 1, path + i + 2, strlen(path + i + 1));
}
}
@@ -2871,7 +4537,7 @@ mg_wcscasecmp(const wchar_t *s1, const wchar_t *s2)
diff = tolower(*s1) - tolower(*s2);
s1++;
s2++;
- } while (diff == 0 && s1[-1] != '\0');
+ } while ((diff == 0) && (s1[-1] != '\0'));
return diff;
}
@@ -2903,17 +4569,25 @@ path_to_unicode(const struct mg_connection *conn,
wbuf[0] = L'\0';
}
- /* TODO: Add a configuration to switch between case sensitive and
- * case insensitive URIs for Windows server. */
- /*
+ /* Windows file systems are not case sensitive, but you can still use
+ * uppercase and lowercase letters (on all modern file systems).
+ * The server can check if the URI uses the same upper/lowercase
+ * letters an the file system, effectively making Windows servers
+ * case sensitive (like Linux servers are). It is still not possible
+ * to use two files with the same name in different cases on Windows
+ * (like /a and /A) - this would be possible in Linux.
+ * As a default, Windows is not case sensitive, but the case sensitive
+ * file name check can be activated by an additional configuration. */
if (conn) {
- if (conn->ctx->config[WINDOWS_CASE_SENSITIVE]) {
- fcompare = wcscmp;
- }
+ if (conn->ctx->config[CASE_SENSITIVE_FILES]
+ && !mg_strcasecmp(conn->ctx->config[CASE_SENSITIVE_FILES], "yes")) {
+ /* Use case sensitive compare function */
+ fcompare = wcscmp;
+ }
}
- */
(void)conn; /* conn is currently unused */
+#if !defined(_WIN32_WCE)
/* Only accept a full file path, not a Windows short (8.3) path. */
memset(wbuf2, 0, ARRAY_SIZE(wbuf2) * sizeof(wchar_t));
long_len = GetLongPathNameW(wbuf, wbuf2, ARRAY_SIZE(wbuf2) - 1);
@@ -2928,90 +4602,16 @@ path_to_unicode(const struct mg_connection *conn,
/* Short name is used. */
wbuf[0] = L'\0';
}
-}
+#else
+ (void)long_len;
+ (void)wbuf2;
+ (void)err;
-
-#if defined(_WIN32_WCE)
-/* Create substitutes for POSIX functions in Win32. */
-
-#if defined(__MINGW32__)
-/* Show no warning in case system functions are not used. */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
-#endif
-
-
-static time_t
-time(time_t *ptime)
-{
- time_t t;
- SYSTEMTIME st;
- FILETIME ft;
-
- GetSystemTime(&st);
- SystemTimeToFileTime(&st, &ft);
- t = SYS2UNIX_TIME(ft.dwLowDateTime, ft.dwHighDateTime);
-
- if (ptime != NULL) {
- *ptime = t;
+ if (strchr(path, '~')) {
+ wbuf[0] = L'\0';
}
-
- return t;
-}
-
-
-static struct tm *
-localtime(const time_t *ptime, struct tm *ptm)
-{
- int64_t t = ((int64_t)*ptime) * RATE_DIFF + EPOCH_DIFF;
- FILETIME ft, lft;
- SYSTEMTIME st;
- TIME_ZONE_INFORMATION tzinfo;
-
- if (ptm == NULL) {
- return NULL;
- }
-
- *(int64_t *)&ft = t;
- FileTimeToLocalFileTime(&ft, &lft);
- FileTimeToSystemTime(&lft, &st);
- ptm->tm_year = st.wYear - 1900;
- ptm->tm_mon = st.wMonth - 1;
- ptm->tm_wday = st.wDayOfWeek;
- ptm->tm_mday = st.wDay;
- ptm->tm_hour = st.wHour;
- ptm->tm_min = st.wMinute;
- ptm->tm_sec = st.wSecond;
- ptm->tm_yday = 0; /* hope nobody uses this */
- ptm->tm_isdst =
- GetTimeZoneInformation(&tzinfo) == TIME_ZONE_ID_DAYLIGHT ? 1 : 0;
-
- return ptm;
-}
-
-
-static struct tm *
-gmtime(const time_t *ptime, struct tm *ptm)
-{
- /* FIXME(lsm): fix this. */
- return localtime(ptime, ptm);
-}
-
-
-static size_t
-strftime(char *dst, size_t dst_size, const char *fmt, const struct tm *tm)
-{
- (void)mg_snprintf(NULL, dst, dst_size, "implement strftime() for WinCE");
- return 0;
-}
-
-
-#if defined(__MINGW32__)
-/* Enable unused function warning again */
-#pragma GCC diagnostic pop
-#endif
-
#endif
+}
/* Windows happily opens files with some garbage at the end of file name.
@@ -3028,7 +4628,9 @@ path_cannot_disclose_cgi(const char *path)
static int
-mg_stat(struct mg_connection *conn, const char *path, struct file *filep)
+mg_stat(const struct mg_connection *conn,
+ const char *path,
+ struct mg_file_stat *filep)
{
wchar_t wbuf[PATH_MAX];
WIN32_FILE_ATTRIBUTE_DATA info;
@@ -3039,14 +4641,30 @@ mg_stat(struct mg_connection *conn, const char *path, struct file *filep)
}
memset(filep, 0, sizeof(*filep));
- if (conn && is_file_in_memory(conn, path, filep)) {
+ if (conn && is_file_in_memory(conn, path)) {
/* filep->is_directory = 0; filep->gzipped = 0; .. already done by
* memset */
- filep->last_modified = time(NULL);
- /* last_modified = now ... assumes the file may change during runtime,
+
+ /* Quick fix (for 1.9.x): */
+ /* mg_stat must fill all fields, also for files in memory */
+ struct mg_file tmp_file = STRUCT_FILE_INITIALIZER;
+ open_file_in_memory(conn, path, &tmp_file, MG_FOPEN_MODE_NONE);
+ filep->size = tmp_file.stat.size;
+ filep->location = 2;
+ /* TODO: for 1.10: restructure how files in memory are handled */
+
+ /* The "file in memory" feature is a candidate for deletion.
+ * Please join the discussion at
+ * https://groups.google.com/forum/#!topic/civetweb/h9HT4CmeYqI
+ */
+
+ filep->last_modified = time(NULL); /* TODO */
+ /* last_modified = now ... assumes the file may change during
+ * runtime,
* so every mg_fopen call may return different data */
/* last_modified = conn->ctx.start_time;
- * May be used it the data does not change during runtime. This allows
+ * May be used it the data does not change during runtime. This
+ * allows
* browser caching. Since we do not know, we have to assume the file
* in memory may change. */
return 1;
@@ -3115,6 +4733,7 @@ mg_mkdir(const struct mg_connection *conn, const char *path, int mode)
/* Implementation of POSIX opendir/closedir/readdir for Windows. */
+FUNCTION_MAY_BE_UNUSED
static DIR *
mg_opendir(const struct mg_connection *conn, const char *name)
{
@@ -3144,6 +4763,7 @@ mg_opendir(const struct mg_connection *conn, const char *name)
}
+FUNCTION_MAY_BE_UNUSED
static int
mg_closedir(DIR *dir)
{
@@ -3163,6 +4783,7 @@ mg_closedir(DIR *dir)
}
+FUNCTION_MAY_BE_UNUSED
static struct dirent *
mg_readdir(DIR *dir)
{
@@ -3197,6 +4818,7 @@ mg_readdir(DIR *dir)
#ifndef HAVE_POLL
+FUNCTION_MAY_BE_UNUSED
static int
poll(struct pollfd *pfd, unsigned int n, int milliseconds)
{
@@ -3228,10 +4850,18 @@ poll(struct pollfd *pfd, unsigned int n, int milliseconds)
}
}
+ /* We should subtract the time used in select from remaining
+ * "milliseconds", in particular if called from mg_poll with a
+ * timeout quantum.
+ * Unfortunately, the remaining time is not stored in "tv" in all
+ * implementations, so the result in "tv" must be considered undefined.
+ * See http://man7.org/linux/man-pages/man2/select.2.html */
+
return result;
}
#endif /* HAVE_POLL */
+
#if defined(__MINGW32__)
/* Enable unused function warning again */
#pragma GCC diagnostic pop
@@ -3242,7 +4872,11 @@ static void
set_close_on_exec(SOCKET sock, struct mg_connection *conn /* may be null */)
{
(void)conn; /* Unused. */
+#if defined(_WIN32_WCE)
+ (void)sock;
+#else
(void)SetHandleInformation((HANDLE)(intptr_t)sock, HANDLE_FLAG_INHERIT, 0);
+#endif
}
@@ -3250,7 +4884,8 @@ int
mg_start_thread(mg_thread_func_t f, void *p)
{
#if defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)
- /* Compile-time option to control stack size, e.g. -DUSE_STACK_SIZE=16384
+ /* Compile-time option to control stack size, e.g.
+ * -DUSE_STACK_SIZE=16384
*/
return ((_beginthread((void(__cdecl *)(void *))f, USE_STACK_SIZE, p)
== ((uintptr_t)(-1L)))
@@ -3294,7 +4929,7 @@ mg_join_thread(pthread_t threadid)
DWORD dwevent;
result = -1;
- dwevent = WaitForSingleObject(threadid, INFINITE);
+ dwevent = WaitForSingleObject(threadid, (DWORD)INFINITE);
if (dwevent == WAIT_FAILED) {
DEBUG_TRACE("WaitForSingleObject() failed, error %d", ERRNO);
} else {
@@ -3307,7 +4942,8 @@ mg_join_thread(pthread_t threadid)
return result;
}
-#if !defined(NO_SSL_DL)
+#if !defined(NO_SSL_DL) && !defined(NO_SSL)
+/* If SSL is loaded dynamically, dlopen/dlclose is required. */
/* Create substitutes for POSIX functions in Win32. */
#if defined(__MINGW32__)
@@ -3317,6 +4953,7 @@ mg_join_thread(pthread_t threadid)
#endif
+FUNCTION_MAY_BE_UNUSED
static HANDLE
dlopen(const char *dll_name, int flags)
{
@@ -3327,6 +4964,7 @@ dlopen(const char *dll_name, int flags)
}
+FUNCTION_MAY_BE_UNUSED
static int
dlclose(void *handle)
{
@@ -3366,7 +5004,7 @@ static void
trim_trailing_whitespaces(char *s)
{
char *e = s + strlen(s) - 1;
- while (e > s && isspace(*(unsigned char *)e)) {
+ while ((e > s) && isspace(*(unsigned char *)e)) {
*e-- = '\0';
}
}
@@ -3386,7 +5024,7 @@ spawn_process(struct mg_connection *conn,
char *p, *interp, full_interp[PATH_MAX], full_dir[PATH_MAX],
cmdline[PATH_MAX], buf[PATH_MAX];
int truncated;
- struct file file = STRUCT_FILE_INITIALIZER;
+ struct mg_file file = STRUCT_FILE_INITIALIZER;
STARTUPINFOA si;
PROCESS_INFORMATION pi = {0};
@@ -3448,14 +5086,14 @@ spawn_process(struct mg_connection *conn,
goto spawn_cleanup;
}
- if (mg_fopen(conn, cmdline, "r", &file)) {
- p = (char *)file.membuf;
+ if (mg_fopen(conn, cmdline, MG_FOPEN_MODE_READ, &file)) {
+ p = (char *)file.access.membuf;
mg_fgets(buf, sizeof(buf), &file, &p);
- mg_fclose(&file);
+ (void)mg_fclose(&file.access); /* ignore error on read only file */
buf[sizeof(buf) - 1] = '\0';
}
- if (buf[0] == '#' && buf[1] == '!') {
+ if ((buf[0] == '#') && (buf[1] == '!')) {
trim_trailing_whitespaces(buf + 2);
} else {
buf[2] = '\0';
@@ -3524,16 +5162,24 @@ spawn_cleanup:
static int
-set_non_blocking_mode(SOCKET sock)
+set_blocking_mode(SOCKET sock)
{
- unsigned long on = 1;
- return ioctlsocket(sock, (long)FIONBIO, &on);
+ unsigned long non_blocking = 0;
+ return ioctlsocket(sock, (long)FIONBIO, &non_blocking);
}
+static int
+set_non_blocking_mode(SOCKET sock)
+{
+ unsigned long non_blocking = 1;
+ return ioctlsocket(sock, (long)FIONBIO, &non_blocking);
+}
#else
static int
-mg_stat(struct mg_connection *conn, const char *path, struct file *filep)
+mg_stat(const struct mg_connection *conn,
+ const char *path,
+ struct mg_file_stat *filep)
{
struct stat st;
if (!filep) {
@@ -3541,7 +5187,17 @@ mg_stat(struct mg_connection *conn, const char *path, struct file *filep)
}
memset(filep, 0, sizeof(*filep));
- if (conn && is_file_in_memory(conn, path, filep)) {
+ if (conn && is_file_in_memory(conn, path)) {
+
+ /* Quick fix (for 1.9.x): */
+ /* mg_stat must fill all fields, also for files in memory */
+ struct mg_file tmp_file = STRUCT_FILE_INITIALIZER;
+ open_file_in_memory(conn, path, &tmp_file, MG_FOPEN_MODE_NONE);
+ filep->size = tmp_file.stat.size;
+ filep->last_modified = time(NULL);
+ filep->location = 2;
+ /* TODO: for 1.10: restructure how files in memory are handled */
+
return 1;
}
@@ -3653,10 +5309,10 @@ spawn_process(struct mg_connection *conn,
if ((pid = fork()) == -1) {
/* Parent */
- send_http_error(conn,
- 500,
- "Error: Creating CGI process\nfork(): %s",
- strerror(ERRNO));
+ mg_send_http_error(conn,
+ 500,
+ "Error: Creating CGI process\nfork(): %s",
+ strerror(ERRNO));
} else if (pid == 0) {
/* Child */
if (chdir(dir) != 0) {
@@ -3728,14 +5384,32 @@ spawn_process(struct mg_connection *conn,
static int
set_non_blocking_mode(SOCKET sock)
{
- int flags;
-
- flags = fcntl(sock, F_GETFL, 0);
- (void)fcntl(sock, F_SETFL, flags | O_NONBLOCK);
+ int flags = fcntl(sock, F_GETFL, 0);
+ if (flags < 0) {
+ return -1;
+ }
+ if (fcntl(sock, F_SETFL, (flags | O_NONBLOCK)) < 0) {
+ return -1;
+ }
return 0;
}
-#endif /* _WIN32 */
+
+static int
+set_blocking_mode(SOCKET sock)
+{
+ int flags = fcntl(sock, F_GETFL, 0);
+ if (flags < 0) {
+ return -1;
+ }
+
+ if (fcntl(sock, F_SETFL, flags & (~(int)(O_NONBLOCK))) < 0) {
+ return -1;
+ }
+ return 0;
+}
+#endif /* _WIN32 / else */
+
/* End of initial operating system specific define block. */
@@ -3745,46 +5419,91 @@ get_random(void)
{
static uint64_t lfsr = 0; /* Linear feedback shift register */
static uint64_t lcg = 0; /* Linear congruential generator */
- struct timespec now;
-
- memset(&now, 0, sizeof(now));
- clock_gettime(CLOCK_MONOTONIC, &now);
+ uint64_t now = mg_get_current_time_ns();
if (lfsr == 0) {
/* lfsr will be only 0 if has not been initialized,
* so this code is called only once. */
- lfsr = (((uint64_t)now.tv_sec) << 21) ^ ((uint64_t)now.tv_nsec)
- ^ ((uint64_t)(ptrdiff_t)&now) ^ (((uint64_t)time(NULL)) << 33);
- lcg = (((uint64_t)now.tv_sec) << 25) + (uint64_t)now.tv_nsec
- + (uint64_t)(ptrdiff_t)&now;
+ lfsr = mg_get_current_time_ns();
+ lcg = mg_get_current_time_ns();
} else {
/* Get the next step of both random number generators. */
lfsr = (lfsr >> 1)
| ((((lfsr >> 0) ^ (lfsr >> 1) ^ (lfsr >> 3) ^ (lfsr >> 4)) & 1)
<< 63);
- lcg = lcg * 6364136223846793005 + 1442695040888963407;
+ lcg = lcg * 6364136223846793005LL + 1442695040888963407LL;
}
- /* Combining two pseudo-random number generators and a high resolution part
- * of the current server time will make it hard (impossible?) to guess the
+ /* Combining two pseudo-random number generators and a high resolution
+ * part
+ * of the current server time will make it hard (impossible?) to guess
+ * the
* next number. */
- return (lfsr ^ lcg ^ (uint64_t)now.tv_nsec);
+ return (lfsr ^ lcg ^ now);
+}
+
+
+static int
+mg_poll(struct pollfd *pfd,
+ unsigned int n,
+ int milliseconds,
+ volatile int *stop_server)
+{
+ /* Call poll, but only for a maximum time of a few seconds.
+ * This will allow to stop the server after some seconds, instead
+ * of having to wait for a long socket timeout. */
+ int ms_now = SOCKET_TIMEOUT_QUANTUM; /* Sleep quantum in ms */
+
+ do {
+ int result;
+
+ if (*stop_server) {
+ /* Shut down signal */
+ return -2;
+ }
+
+ if ((milliseconds >= 0) && (milliseconds < ms_now)) {
+ ms_now = milliseconds;
+ }
+
+ result = poll(pfd, n, ms_now);
+ if (result != 0) {
+ /* Poll returned either success (1) or error (-1).
+ * Forward both to the caller. */
+ return result;
+ }
+
+ /* Poll returned timeout (0). */
+ if (milliseconds > 0) {
+ milliseconds -= ms_now;
+ }
+
+ } while (milliseconds != 0);
+
+ /* timeout: return 0 */
+ return 0;
}
/* Write data to the IO channel - opened file descriptor, socket or SSL
- * descriptor. Return number of bytes written. */
+ * descriptor.
+ * Return value:
+ * >=0 .. number of bytes successfully written
+ * -1 .. timeout
+ * -2 .. error
+ */
static int
-push(struct mg_context *ctx,
- FILE *fp,
- SOCKET sock,
- SSL *ssl,
- const char *buf,
- int len,
- double timeout)
+push_inner(struct mg_context *ctx,
+ FILE *fp,
+ SOCKET sock,
+ SSL *ssl,
+ const char *buf,
+ int len,
+ double timeout)
{
- struct timespec start, now;
+ uint64_t start = 0, now = 0, timeout_ns = 0;
int n, err;
+ unsigned ms_wait = SOCKET_TIMEOUT_QUANTUM; /* Sleep quantum in ms */
#ifdef _WIN32
typedef int len_t;
@@ -3793,33 +5512,38 @@ push(struct mg_context *ctx,
#endif
if (timeout > 0) {
- memset(&start, 0, sizeof(start));
- memset(&now, 0, sizeof(now));
- clock_gettime(CLOCK_MONOTONIC, &start);
+ now = mg_get_current_time_ns();
+ start = now;
+ timeout_ns = (uint64_t)(timeout * 1.0E9);
}
if (ctx == NULL) {
- return -1;
+ return -2;
}
#ifdef NO_SSL
if (ssl) {
- return -1;
+ return -2;
}
#endif
- do {
+ /* Try to read until it succeeds, fails, times out, or the server
+ * shuts down. */
+ for (;;) {
#ifndef NO_SSL
if (ssl != NULL) {
n = SSL_write(ssl, buf, len);
if (n <= 0) {
err = SSL_get_error(ssl, n);
- if ((err == 5 /* SSL_ERROR_SYSCALL */) && (n == -1)) {
+ if ((err == SSL_ERROR_SYSCALL) && (n == -1)) {
err = ERRNO;
+ } else if ((err == SSL_ERROR_WANT_READ)
+ || (err == SSL_ERROR_WANT_WRITE)) {
+ n = 0;
} else {
DEBUG_TRACE("SSL_write() failed, error %d", err);
- return -1;
+ return -2;
}
} else {
err = 0;
@@ -3837,38 +5561,75 @@ push(struct mg_context *ctx,
} else {
n = (int)send(sock, buf, (len_t)len, MSG_NOSIGNAL);
err = (n < 0) ? ERRNO : 0;
+#ifdef _WIN32
+ if (err == WSAEWOULDBLOCK) {
+ err = 0;
+ n = 0;
+ }
+#else
+ if (err == EWOULDBLOCK) {
+ err = 0;
+ n = 0;
+ }
+#endif
+ if (n < 0) {
+ /* shutdown of the socket at client side */
+ return -2;
+ }
}
if (ctx->stop_flag) {
- return -1;
+ return -2;
}
- if ((n > 0) || (n == 0 && len == 0)) {
+ if ((n > 0) || ((n == 0) && (len == 0))) {
/* some data has been read, or no data was requested */
return n;
}
- if (n == 0) {
- /* shutdown of the socket at client side */
- return -1;
- }
if (n < 0) {
/* socket error - check errno */
DEBUG_TRACE("send() failed, error %d", err);
- /* TODO: error handling depending on the error code.
+ /* TODO (mid): error handling depending on the error code.
* These codes are different between Windows and Linux.
+ * Currently there is no problem with failing send calls,
+ * if there is a reproducible situation, it should be
+ * investigated in detail.
*/
- return -1;
+ return -2;
}
- /* This code is not reached in the moment.
- * ==> Fix the TODOs above first. */
+ /* Only in case n=0 (timeout), repeat calling the write function */
+
+ /* If send failed, wait before retry */
+ if (fp != NULL) {
+ /* For files, just wait a fixed time,
+ * maybe an average disk seek time. */
+ mg_sleep(ms_wait > 10 ? 10 : ms_wait);
+ } else {
+ /* For sockets, wait for the socket using poll */
+ struct pollfd pfd[1];
+ int pollres;
+
+ pfd[0].fd = sock;
+ pfd[0].events = POLLOUT;
+ pollres = mg_poll(pfd, 1, (int)(ms_wait), &(ctx->stop_flag));
+ if (ctx->stop_flag) {
+ return -2;
+ }
+ if (pollres > 0) {
+ continue;
+ }
+ }
if (timeout > 0) {
- clock_gettime(CLOCK_MONOTONIC, &now);
+ now = mg_get_current_time_ns();
+ if ((now - start) > timeout_ns) {
+ /* Timeout */
+ break;
+ }
}
-
- } while ((timeout <= 0) || (mg_difftimespec(&now, &start) <= timeout));
+ }
(void)err; /* Avoid unused warning if NO_SSL is set and DEBUG_TRACE is not
used */
@@ -3896,8 +5657,8 @@ push_all(struct mg_context *ctx,
timeout = atoi(ctx->config[REQUEST_TIMEOUT]) / 1000.0;
}
- while (len > 0 && ctx->stop_flag == 0) {
- n = push(ctx, fp, sock, ssl, buf + nwritten, (int)len, timeout);
+ while ((len > 0) && (ctx->stop_flag == 0)) {
+ n = push_inner(ctx, fp, sock, ssl, buf + nwritten, (int)len, timeout);
if (n < 0) {
if (nwritten == 0) {
nwritten = n; /* Propagate the error */
@@ -3916,106 +5677,192 @@ push_all(struct mg_context *ctx,
/* Read from IO channel - opened file descriptor, socket, or SSL descriptor.
- * Return negative value on error, or number of bytes read on success. */
+ * Return value:
+ * >=0 .. number of bytes successfully read
+ * -1 .. timeout
+ * -2 .. error
+ */
static int
-pull(FILE *fp, struct mg_connection *conn, char *buf, int len, double timeout)
+pull_inner(FILE *fp,
+ struct mg_connection *conn,
+ char *buf,
+ int len,
+ double timeout)
{
- int nread, err;
- struct timespec start, now;
+ int nread, err = 0;
#ifdef _WIN32
typedef int len_t;
#else
typedef size_t len_t;
#endif
+#ifndef NO_SSL
+ int ssl_pending;
+#endif
- if (timeout > 0) {
- memset(&start, 0, sizeof(start));
- memset(&now, 0, sizeof(now));
- clock_gettime(CLOCK_MONOTONIC, &start);
- }
+ /* We need an additional wait loop around this, because in some cases
+ * with TLSwe may get data from the socket but not from SSL_read.
+ * In this case we need to repeat at least once.
+ */
- do {
- 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 = (int)read(fileno(fp), buf, (size_t)len);
- err = (nread < 0) ? ERRNO : 0;
+ if (fp != NULL) {
+#if !defined(_WIN32_WCE)
+ /* 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 = (int)read(fileno(fp), buf, (size_t)len);
+#else
+ /* WinCE does not support CGI pipes */
+ nread = (int)fread(buf, 1, (size_t)len, fp);
+#endif
+ err = (nread < 0) ? ERRNO : 0;
+ if ((nread == 0) && (len > 0)) {
+ /* Should get data, but got EOL */
+ return -2;
+ }
#ifndef NO_SSL
- } else if (conn->ssl != NULL) {
+ } else if ((conn->ssl != NULL)
+ && ((ssl_pending = SSL_pending(conn->ssl)) > 0)) {
+ /* We already know there is no more data buffered in conn->buf
+ * but there is more available in the SSL layer. So don't poll
+ * conn->client.sock yet. */
+ if (ssl_pending > len) {
+ ssl_pending = len;
+ }
+ nread = SSL_read(conn->ssl, buf, ssl_pending);
+ if (nread <= 0) {
+ err = SSL_get_error(conn->ssl, nread);
+ if ((err == SSL_ERROR_SYSCALL) && (nread == -1)) {
+ err = ERRNO;
+ } else if ((err == SSL_ERROR_WANT_READ)
+ || (err == SSL_ERROR_WANT_WRITE)) {
+ nread = 0;
+ } else {
+ DEBUG_TRACE("SSL_read() failed, error %d", err);
+ return -1;
+ }
+ } else {
+ err = 0;
+ }
+
+ } else if (conn->ssl != NULL) {
+
+ struct pollfd pfd[1];
+ int pollres;
+
+ pfd[0].fd = conn->client.sock;
+ pfd[0].events = POLLIN;
+ pollres =
+ mg_poll(pfd, 1, (int)(timeout * 1000.0), &(conn->ctx->stop_flag));
+ if (conn->ctx->stop_flag) {
+ return -2;
+ }
+ if (pollres > 0) {
nread = SSL_read(conn->ssl, buf, len);
if (nread <= 0) {
err = SSL_get_error(conn->ssl, nread);
- if ((err == 5 /* SSL_ERROR_SYSCALL */) && (nread == -1)) {
+ if ((err == SSL_ERROR_SYSCALL) && (nread == -1)) {
err = ERRNO;
+ } else if ((err == SSL_ERROR_WANT_READ)
+ || (err == SSL_ERROR_WANT_WRITE)) {
+ nread = 0;
} else {
DEBUG_TRACE("SSL_read() failed, error %d", err);
- return -1;
+ return -2;
}
} else {
err = 0;
}
+
+ } else if (pollres < 0) {
+ /* Error */
+ return -2;
+ } else {
+ /* pollres = 0 means timeout */
+ nread = 0;
+ }
#endif
- } else {
+ } else {
+ struct pollfd pfd[1];
+ int pollres;
+
+ pfd[0].fd = conn->client.sock;
+ pfd[0].events = POLLIN;
+ pollres =
+ mg_poll(pfd, 1, (int)(timeout * 1000.0), &(conn->ctx->stop_flag));
+ if (conn->ctx->stop_flag) {
+ return -2;
+ }
+ if (pollres > 0) {
nread = (int)recv(conn->client.sock, buf, (len_t)len, 0);
err = (nread < 0) ? ERRNO : 0;
+ if (nread <= 0) {
+ /* shutdown of the socket at client side */
+ return -2;
+ }
+ } else if (pollres < 0) {
+ /* error callint poll */
+ return -2;
+ } else {
+ /* pollres = 0 means timeout */
+ nread = 0;
}
+ }
- if (conn->ctx->stop_flag) {
- return -1;
- }
+ if (conn->ctx->stop_flag) {
+ return -2;
+ }
- if ((nread > 0) || (nread == 0 && len == 0)) {
- /* some data has been read, or no data was requested */
- return nread;
- }
- if (nread == 0) {
- /* shutdown of the socket at client side */
- return -1;
- }
- if (nread < 0) {
+ if ((nread > 0) || ((nread == 0) && (len == 0))) {
+ /* some data has been read, or no data was requested */
+ return nread;
+ }
+
+ if (nread < 0) {
/* socket error - check errno */
#ifdef _WIN32
- if (err == WSAEWOULDBLOCK) {
- /* standard case if called from close_socket_gracefully */
- return -1;
- } else if (err == WSAETIMEDOUT) {
- /* timeout is handled by the while loop */
- } else {
- DEBUG_TRACE("recv() failed, error %d", err);
- return -1;
- }
+ if (err == WSAEWOULDBLOCK) {
+ /* TODO (low): check if this is still required */
+ /* standard case if called from close_socket_gracefully */
+ return -2;
+ } else if (err == WSAETIMEDOUT) {
+ /* TODO (low): check if this is still required */
+ /* timeout is handled by the while loop */
+ return 0;
+ } else if (err == WSAECONNABORTED) {
+ /* See https://www.chilkatsoft.com/p/p_299.asp */
+ return -2;
+ } else {
+ DEBUG_TRACE("recv() failed, error %d", err);
+ return -2;
+ }
#else
- /* TODO: POSIX returns either EAGAIN or EWOULDBLOCK in both cases,
- * if the timeout is reached and if the socket was set to non-
- * blocking in close_socket_gracefully, so we can not distinguish
- * here. We have to wait for the timeout in both cases for now.
- */
- if (err == EAGAIN || err == EWOULDBLOCK || err == EINTR) {
- /* EAGAIN/EWOULDBLOCK:
- * standard case if called from close_socket_gracefully
- * => should return -1 */
- /* or timeout occured
- * => the code must stay in the while loop */
+ /* TODO: POSIX returns either EAGAIN or EWOULDBLOCK in both cases,
+ * if the timeout is reached and if the socket was set to non-
+ * blocking in close_socket_gracefully, so we can not distinguish
+ * here. We have to wait for the timeout in both cases for now.
+ */
+ if ((err == EAGAIN) || (err == EWOULDBLOCK) || (err == EINTR)) {
+ /* TODO (low): check if this is still required */
+ /* EAGAIN/EWOULDBLOCK:
+ * standard case if called from close_socket_gracefully
+ * => should return -1 */
+ /* or timeout occured
+ * => the code must stay in the while loop */
- /* EINTR can be generated on a socket with a timeout set even
- * when SA_RESTART is effective for all relevant signals
- * (see signal(7)).
- * => stay in the while loop */
- } else {
- DEBUG_TRACE("recv() failed, error %d", err);
- return -1;
- }
+ /* EINTR can be generated on a socket with a timeout set even
+ * when SA_RESTART is effective for all relevant signals
+ * (see signal(7)).
+ * => stay in the while loop */
+ } else {
+ DEBUG_TRACE("recv() failed, error %d", err);
+ return -2;
+ }
#endif
- }
- if (timeout > 0) {
- clock_gettime(CLOCK_MONOTONIC, &now);
- }
- } while ((timeout <= 0) || (mg_difftimespec(&now, &start) <= timeout));
+ }
/* Timeout occured, but no data available. */
return -1;
@@ -4027,16 +5874,30 @@ pull_all(FILE *fp, struct mg_connection *conn, char *buf, int len)
{
int n, nread = 0;
double timeout = -1.0;
+ uint64_t start_time = 0, now = 0, timeout_ns = 0;
if (conn->ctx->config[REQUEST_TIMEOUT]) {
timeout = atoi(conn->ctx->config[REQUEST_TIMEOUT]) / 1000.0;
}
+ if (timeout >= 0.0) {
+ start_time = mg_get_current_time_ns();
+ timeout_ns = (uint64_t)(timeout * 1.0E9);
+ }
- while (len > 0 && conn->ctx->stop_flag == 0) {
- n = pull(fp, conn, buf + nread, len, timeout);
- if (n < 0) {
+ while ((len > 0) && (conn->ctx->stop_flag == 0)) {
+ n = pull_inner(fp, conn, buf + nread, len, timeout);
+ if (n == -2) {
if (nread == 0) {
- nread = n; /* Propagate the error */
+ nread = -1; /* Propagate the error */
+ }
+ break;
+ } else if (n == -1) {
+ /* timeout */
+ if (timeout >= 0.0) {
+ now = mg_get_current_time_ns();
+ if ((now - start_time) <= timeout_ns) {
+ continue;
+ }
}
break;
} else if (n == 0) {
@@ -4066,9 +5927,9 @@ discard_unread_request_data(struct mg_connection *conn)
to_read = sizeof(buf);
if (conn->is_chunked) {
- /* Chunked encoding: 1=chunk not read completely, 2=chunk read
+ /* Chunked encoding: 3=chunk read completely
* completely */
- while (conn->is_chunked == 1) {
+ while (conn->is_chunked != 3) {
nread = mg_read(conn, buf, to_read);
if (nread <= 0) {
break;
@@ -4097,7 +5958,7 @@ mg_read_inner(struct mg_connection *conn, void *buf, size_t len)
{
int64_t n, buffered_len, nread;
int64_t len64 =
- (int64_t)(len > INT_MAX ? INT_MAX : len); /* since the return value is
+ (int64_t)((len > INT_MAX) ? INT_MAX : len); /* since the return value is
* int, we may not read more
* bytes */
const char *body;
@@ -4106,11 +5967,19 @@ mg_read_inner(struct mg_connection *conn, void *buf, size_t len)
return 0;
}
- /* If Content-Length is not set for a PUT or POST request, read until
- * socket is closed */
- if (conn->consumed_content == 0 && conn->content_len == -1) {
- conn->content_len = INT64_MAX;
- conn->must_close = 1;
+ /* If Content-Length is not set for a request with body data
+ * (e.g., a PUT or POST request), we do not know in advance
+ * how much data should be read. */
+ if (conn->consumed_content == 0) {
+ if (conn->is_chunked == 1) {
+ conn->content_len = len64;
+ conn->is_chunked = 2;
+ } else if (conn->content_len == -1) {
+ /* The body data is completed when the connection
+ * is closed. */
+ conn->content_len = INT64_MAX;
+ conn->must_close = 1;
+ }
}
nread = 0;
@@ -4118,7 +5987,8 @@ mg_read_inner(struct mg_connection *conn, void *buf, size_t len)
/* Adjust number of bytes to read. */
int64_t left_to_read = conn->content_len - conn->consumed_content;
if (left_to_read < len64) {
- /* Do not read more than the total content length of the request.
+ /* Do not read more than the total content length of the
+ * request.
*/
len64 = left_to_read;
}
@@ -4144,7 +6014,7 @@ mg_read_inner(struct mg_connection *conn, void *buf, size_t len)
if ((n = pull_all(NULL, conn, (char *)buf, (int)len64)) >= 0) {
nread += n;
} else {
- nread = (nread > 0 ? nread : n);
+ nread = ((nread > 0) ? nread : n);
}
}
return (int)nread;
@@ -4158,7 +6028,6 @@ mg_getc(struct mg_connection *conn)
if (conn == NULL) {
return 0;
}
- conn->content_len++;
if (mg_read_inner(conn, &c, 1) <= 0) {
return (char)0;
}
@@ -4181,8 +6050,7 @@ mg_read(struct mg_connection *conn, void *buf, size_t len)
size_t all_read = 0;
while (len > 0) {
-
- if (conn->is_chunked == 2) {
+ if (conn->is_chunked == 3) {
/* No more data left to read */
return 0;
}
@@ -4197,15 +6065,24 @@ mg_read(struct mg_connection *conn, void *buf, size_t len)
conn->content_len += (int)read_now;
read_ret =
mg_read_inner(conn, (char *)buf + all_read, read_now);
- all_read += (size_t)read_ret;
- conn->chunk_remainder -= read_now;
- len -= read_now;
+ if (read_ret < 1) {
+ /* read error */
+ return -1;
+ }
+
+ all_read += (size_t)read_ret;
+ conn->chunk_remainder -= (size_t)read_ret;
+ len -= (size_t)read_ret;
if (conn->chunk_remainder == 0) {
- /* the rest of the data in the current chunk has been read
- */
- if ((mg_getc(conn) != '\r') || (mg_getc(conn) != '\n')) {
+ /* Add data bytes in the current chunk have been read,
+ * so we are expecting \r\n now. */
+ char x1, x2;
+ conn->content_len += 2;
+ x1 = mg_getc(conn);
+ x2 = mg_getc(conn);
+ if ((x1 != '\r') || (x2 != '\n')) {
/* Protocol violation */
return -1;
}
@@ -4219,20 +6096,23 @@ mg_read(struct mg_connection *conn, void *buf, size_t len)
unsigned long chunkSize = 0;
for (i = 0; i < ((int)sizeof(lenbuf) - 1); i++) {
+ conn->content_len++;
lenbuf[i] = mg_getc(conn);
- if (i > 0 && lenbuf[i] == '\r' && lenbuf[i - 1] != '\r') {
+ if ((i > 0) && (lenbuf[i] == '\r')
+ && (lenbuf[i - 1] != '\r')) {
continue;
}
- if (i > 1 && lenbuf[i] == '\n' && lenbuf[i - 1] == '\r') {
+ if ((i > 1) && (lenbuf[i] == '\n')
+ && (lenbuf[i - 1] == '\r')) {
lenbuf[i + 1] = 0;
chunkSize = strtoul(lenbuf, &end, 16);
if (chunkSize == 0) {
/* regular end of content */
- conn->is_chunked = 2;
+ conn->is_chunked = 3;
}
break;
}
- if (!isalnum(lenbuf[i])) {
+ if (!isxdigit(lenbuf[i])) {
/* illegal character for chunk length */
return -1;
}
@@ -4282,8 +6162,8 @@ mg_write(struct mg_connection *conn, const void *buf, size_t len)
(int64_t)allowed)) == allowed) {
buf = (const 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
+ 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_all(conn->ctx,
@@ -4309,10 +6189,51 @@ mg_write(struct mg_connection *conn, const void *buf, size_t len)
(const char *)buf,
(int64_t)len);
}
+ if (total > 0) {
+ conn->num_bytes_sent += total;
+ }
return (int)total;
}
+/* Send a chunk, if "Transfer-Encoding: chunked" is used */
+int
+mg_send_chunk(struct mg_connection *conn,
+ const char *chunk,
+ unsigned int chunk_len)
+{
+ char lenbuf[16];
+ size_t lenbuf_len;
+ int ret;
+ int t;
+
+ /* First store the length information in a text buffer. */
+ sprintf(lenbuf, "%x\r\n", chunk_len);
+ lenbuf_len = strlen(lenbuf);
+
+ /* Then send length information, chunk and terminating \r\n. */
+ ret = mg_write(conn, lenbuf, lenbuf_len);
+ if (ret != (int)lenbuf_len) {
+ return -1;
+ }
+ t = ret;
+
+ ret = mg_write(conn, chunk, chunk_len);
+ if (ret != (int)chunk_len) {
+ return -1;
+ }
+ t += ret;
+
+ ret = mg_write(conn, "\r\n", 2);
+ if (ret != 2) {
+ return -1;
+ }
+ t += ret;
+
+ return t;
+}
+
+
/* Alternative alloc_vprintf() for non-compliant C runtimes */
static int
alloc_vprintf2(char **buf, const char *fmt, va_list ap)
@@ -4344,7 +6265,8 @@ alloc_vprintf2(char **buf, const char *fmt, va_list ap)
/* 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,
+ * return buffer. If buffer is to small, allocate large enough buffer on
+ * heap,
* and return allocated buffer. */
static int
alloc_vprintf(char **out_buf,
@@ -4368,10 +6290,11 @@ alloc_vprintf(char **out_buf,
if (len < 0) {
/* C runtime is not standard compliant, vsnprintf() returned -1.
- * Switch to alternative code path that uses incremental allocations.
+ * Switch to alternative code path that uses incremental
+ * allocations.
*/
va_copy(ap_copy, ap);
- len = alloc_vprintf2(out_buf, fmt, ap);
+ len = alloc_vprintf2(out_buf, fmt, ap_copy);
va_end(ap_copy);
} else if ((size_t)(len) >= prealloc_size) {
@@ -4412,7 +6335,7 @@ mg_vprintf(struct mg_connection *conn, const char *fmt, va_list ap)
if ((len = alloc_vprintf(&buf, mem, sizeof(mem), fmt, ap)) > 0) {
len = mg_write(conn, buf, (size_t)len);
}
- if (buf != mem && buf != NULL) {
+ if ((buf != mem) && (buf != NULL)) {
mg_free(buf);
}
@@ -4442,17 +6365,17 @@ mg_url_decode(const char *src,
int is_form_url_encoded)
{
int i, j, a, b;
-#define HEXTOI(x) (isdigit(x) ? x - '0' : x - 'W')
+#define HEXTOI(x) (isdigit(x) ? (x - '0') : (x - 'W'))
- for (i = j = 0; i < src_len && j < dst_len - 1; i++, j++) {
- if (i < src_len - 2 && src[i] == '%'
+ for (i = j = 0; (i < src_len) && (j < (dst_len - 1)); i++, j++) {
+ if ((i < src_len - 2) && (src[i] == '%')
&& isxdigit(*(const unsigned char *)(src + i + 1))
&& isxdigit(*(const unsigned char *)(src + i + 2))) {
a = tolower(*(const unsigned char *)(src + i + 1));
b = tolower(*(const unsigned char *)(src + i + 2));
dst[j] = (char)((HEXTOI(a) << 4) | HEXTOI(b));
i += 2;
- } else if (is_form_url_encoded && src[i] == '+') {
+ } else if (is_form_url_encoded && (src[i] == '+')) {
dst[j] = ' ';
} else {
dst[j] = src[i];
@@ -4461,7 +6384,7 @@ mg_url_decode(const char *src,
dst[j] = '\0'; /* Null-terminate the destination */
- return i >= src_len ? j : -1;
+ return (i >= src_len) ? j : -1;
}
@@ -4488,9 +6411,9 @@ mg_get_var2(const char *data,
size_t name_len;
int len;
- if (dst == NULL || dst_len == 0) {
+ if ((dst == NULL) || (dst_len == 0)) {
len = -2;
- } else if (data == NULL || name == NULL || data_len == 0) {
+ } else if ((data == NULL) || (name == NULL) || (data_len == 0)) {
len = -1;
dst[0] = '\0';
} else {
@@ -4501,7 +6424,7 @@ mg_get_var2(const char *data,
/* 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] == '='
+ if (((p == data) || (p[-1] == '&')) && (p[name_len] == '=')
&& !mg_strncasecmp(name, p, name_len) && 0 == occurrence--) {
/* Point p to variable value */
p += name_len + 1;
@@ -4533,6 +6456,7 @@ mg_get_var2(const char *data,
}
+/* HCP24: some changes to compare hole var_name */
int
mg_get_cookie(const char *cookie_header,
const char *var_name,
@@ -4542,18 +6466,21 @@ mg_get_cookie(const char *cookie_header,
const char *s, *p, *end;
int name_len, len = -1;
- if (dst == NULL || dst_size == 0) {
- len = -2;
- } else if (var_name == NULL || (s = cookie_header) == NULL) {
- len = -1;
- dst[0] = '\0';
- } else {
- name_len = (int)strlen(var_name);
- end = s + strlen(s);
- dst[0] = '\0';
+ if ((dst == NULL) || (dst_size == 0)) {
+ return -2;
+ }
- for (; (s = mg_strcasestr(s, var_name)) != NULL; s += name_len) {
- if (s[name_len] == '=') {
+ dst[0] = '\0';
+ if ((var_name == NULL) || ((s = cookie_header) == NULL)) {
+ return -1;
+ }
+
+ name_len = (int)strlen(var_name);
+ end = s + strlen(s);
+ for (; (s = mg_strcasestr(s, var_name)) != NULL; s += name_len) {
+ if (s[name_len] == '=') {
+ /* HCP24: now check is it a substring or a full cookie name */
+ if ((s == cookie_header) || (s[-1] == ' ')) {
s += name_len + 1;
if ((p = strchr(s, ' ')) == NULL) {
p = end;
@@ -4561,7 +6488,7 @@ mg_get_cookie(const char *cookie_header,
if (p[-1] == ';') {
p--;
}
- if (*s == '"' && p[-1] == '"' && p > s + 1) {
+ if ((*s == '"') && (p[-1] == '"') && (p > s + 1)) {
s++;
p--;
}
@@ -4589,8 +6516,8 @@ base64_encode(const unsigned char *src, int src_len, char *dst)
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];
+ 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)];
@@ -4613,13 +6540,13 @@ base64_encode(const unsigned char *src, int src_len, char *dst)
static unsigned char
b64reverse(char letter)
{
- if (letter >= 'A' && letter <= 'Z') {
+ if ((letter >= 'A') && (letter <= 'Z')) {
return letter - 'A';
}
- if (letter >= 'a' && letter <= 'z') {
+ if ((letter >= 'a') && (letter <= 'z')) {
return letter - 'a' + 26;
}
- if (letter >= '0' && letter <= '9') {
+ if ((letter >= '0') && (letter <= '9')) {
return letter - '0' + 52;
}
if (letter == '+') {
@@ -4649,17 +6576,17 @@ base64_decode(const unsigned char *src, int src_len, char *dst, size_t *dst_len)
return i;
}
- b = b64reverse(i + 1 >= src_len ? 0 : src[i + 1]);
+ b = b64reverse(((i + 1) >= src_len) ? 0 : src[i + 1]);
if (b >= 254) {
return i + 1;
}
- c = b64reverse(i + 2 >= src_len ? 0 : src[i + 2]);
+ c = b64reverse(((i + 2) >= src_len) ? 0 : src[i + 2]);
if (c == 254) {
return i + 2;
}
- d = b64reverse(i + 3 >= src_len ? 0 : src[i + 3]);
+ d = b64reverse(((i + 3) >= src_len) ? 0 : src[i + 3]);
if (d == 254) {
return i + 3;
}
@@ -4682,25 +6609,113 @@ is_put_or_delete_method(const struct mg_connection *conn)
{
if (conn) {
const char *s = conn->request_info.request_method;
- return s != NULL && (!strcmp(s, "PUT") || !strcmp(s, "DELETE")
- || !strcmp(s, "MKCOL") || !strcmp(s, "PATCH"));
+ return (s != NULL) && (!strcmp(s, "PUT") || !strcmp(s, "DELETE")
+ || !strcmp(s, "MKCOL") || !strcmp(s, "PATCH"));
}
return 0;
}
+#if !defined(NO_FILES)
+static int
+extention_matches_script(
+ struct mg_connection *conn, /* in: request (must be valid) */
+ const char *filename /* in: filename (must be valid) */
+ )
+{
+#if !defined(NO_CGI)
+ if (match_prefix(conn->ctx->config[CGI_EXTENSIONS],
+ strlen(conn->ctx->config[CGI_EXTENSIONS]),
+ filename) > 0) {
+ return 1;
+ }
+#endif
+#if defined(USE_LUA)
+ if (match_prefix(conn->ctx->config[LUA_SCRIPT_EXTENSIONS],
+ strlen(conn->ctx->config[LUA_SCRIPT_EXTENSIONS]),
+ filename) > 0) {
+ return 1;
+ }
+#endif
+#if defined(USE_DUKTAPE)
+ if (match_prefix(conn->ctx->config[DUKTAPE_SCRIPT_EXTENSIONS],
+ strlen(conn->ctx->config[DUKTAPE_SCRIPT_EXTENSIONS]),
+ filename) > 0) {
+ return 1;
+ }
+#endif
+ /* filename and conn could be unused, if all preocessor conditions
+ * are false (no script language supported). */
+ (void)filename;
+ (void)conn;
+
+ return 0;
+}
+
+
+/* For given directory path, substitute it to valid index file.
+ * Return 1 if index file has been found, 0 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 mg_file_stat *filestat)
+{
+ const char *list = conn->ctx->config[INDEX_FILES];
+ struct vec filename_vec;
+ size_t n = strlen(path);
+ int found = 0;
+
+ /* 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) && (path[n - 1] == '/')) {
+ n--;
+ }
+ 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 */
+ while ((list = next_option(list, &filename_vec, NULL)) != NULL) {
+ /* Ignore too long entries that may overflow path buffer */
+ if (filename_vec.len > (path_len - (n + 2))) {
+ continue;
+ }
+
+ /* Prepare full path to the index file */
+ mg_strlcpy(path + n + 1, filename_vec.ptr, filename_vec.len + 1);
+
+ /* Does it exist? */
+ if (mg_stat(conn, path, filestat)) {
+ /* Yes it does, break the loop */
+ found = 1;
+ break;
+ }
+ }
+
+ /* If no index file exists, restore directory path */
+ if (!found) {
+ path[n] = '\0';
+ }
+
+ return found;
+}
+#endif
+
+
static void
-interpret_uri(struct mg_connection *conn, /* in: request (must be valid) */
- char *filename, /* out: filename */
- size_t filename_buf_len, /* in: size of filename buffer */
- struct file *filep, /* out: file structure */
- int *is_found, /* out: file is found (directly) */
- int *is_script_resource, /* out: handled by a script? */
- int *is_websocket_request, /* out: websocket connetion? */
- int *is_put_or_delete_request /* out: put/delete a file? */
+interpret_uri(struct mg_connection *conn, /* in/out: request (must be valid) */
+ char *filename, /* out: filename */
+ size_t filename_buf_len, /* in: size of filename buffer */
+ struct mg_file_stat *filestat, /* out: file status structure */
+ int *is_found, /* out: file found (directly) */
+ int *is_script_resource, /* out: handled by a script? */
+ int *is_websocket_request, /* out: websocket connetion? */
+ int *is_put_or_delete_request /* out: put/delete a file? */
)
{
-/* TODO (high): Restructure this function */
+ char const *accept_encoding;
#if !defined(NO_FILES)
const char *uri = conn->request_info.local_uri;
@@ -4709,21 +6724,27 @@ interpret_uri(struct mg_connection *conn, /* in: request (must be valid) */
struct vec a, b;
int match_len;
char gz_path[PATH_MAX];
- char const *accept_encoding;
int truncated;
-#if !defined(NO_CGI) || defined(USE_LUA)
- char *p;
+#if !defined(NO_CGI) || defined(USE_LUA) || defined(USE_DUKTAPE)
+ char *tmp_str;
+ size_t tmp_str_len, sep_pos;
+ int allow_substitute_script_subresources;
#endif
#else
(void)filename_buf_len; /* unused if NO_FILES is defined */
#endif
- memset(filep, 0, sizeof(*filep));
+ /* Step 1: Set all initially unknown outputs to zero */
+ memset(filestat, 0, sizeof(*filestat));
*filename = 0;
*is_found = 0;
*is_script_resource = 0;
+
+ /* Step 2: Check if the request attempts to modify the file system */
*is_put_or_delete_request = is_put_or_delete_method(conn);
+/* Step 3: Check if it is a websocket request, and modify the document
+ * root if required */
#if defined(USE_WEBSOCKET)
*is_websocket_request = is_websocket_protocol(conn);
#if !defined(NO_FILES)
@@ -4735,7 +6756,16 @@ interpret_uri(struct mg_connection *conn, /* in: request (must be valid) */
*is_websocket_request = 0;
#endif /* USE_WEBSOCKET */
+ /* Step 4: Check if gzip encoded response is allowed */
+ conn->accept_gzip = 0;
+ if ((accept_encoding = mg_get_header(conn, "Accept-Encoding")) != NULL) {
+ if (strstr(accept_encoding, "gzip") != NULL) {
+ conn->accept_gzip = 1;
+ }
+ }
+
#if !defined(NO_FILES)
+ /* Step 5: If there is no root directory, don't look for files. */
/* Note that root == NULL is a regular use case here. This occurs,
* if all requests are handled by callbacks, so the WEBSOCKET_ROOT
* config is not required. */
@@ -4745,9 +6775,10 @@ interpret_uri(struct mg_connection *conn, /* in: request (must be valid) */
return;
}
- /* 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. */
+ /* Step 6: Determine the local file path from the root path and the
+ * request uri. */
+ /* Using filename_buf_len - 1 because memmove() for PATH_INFO may shift
+ * part of the path one byte on the right. */
mg_snprintf(
conn, &truncated, filename, filename_buf_len - 1, "%s%s", root, uri);
@@ -4755,7 +6786,8 @@ interpret_uri(struct mg_connection *conn, /* in: request (must be valid) */
goto interpret_cleanup;
}
- rewrite = conn->ctx->config[REWRITE];
+ /* Step 7: URI rewriting */
+ rewrite = conn->ctx->config[URL_REWRITE_PATTERN];
while ((rewrite = next_option(rewrite, &a, &b)) != NULL) {
if ((match_len = match_prefix(a.ptr, a.len, uri)) > 0) {
mg_snprintf(conn,
@@ -4774,112 +6806,180 @@ interpret_uri(struct mg_connection *conn, /* in: request (must be valid) */
goto interpret_cleanup;
}
+ /* Step 8: Check if the file exists at the server */
/* Local file path and name, corresponding to requested URI
* is now stored in "filename" variable. */
- if (mg_stat(conn, filename, filep)) {
-#if !defined(NO_CGI) || defined(USE_LUA) || defined(USE_DUKTAPE)
- /* File exists. Check if it is a script type. */
- if (0
-#if !defined(NO_CGI)
- || match_prefix(conn->ctx->config[CGI_EXTENSIONS],
- strlen(conn->ctx->config[CGI_EXTENSIONS]),
- filename) > 0
-#endif
-#if defined(USE_LUA)
- || match_prefix(conn->ctx->config[LUA_SCRIPT_EXTENSIONS],
- strlen(conn->ctx->config[LUA_SCRIPT_EXTENSIONS]),
- filename) > 0
-#endif
-#if defined(USE_DUKTAPE)
- || match_prefix(conn->ctx->config[DUKTAPE_SCRIPT_EXTENSIONS],
- strlen(
- conn->ctx->config[DUKTAPE_SCRIPT_EXTENSIONS]),
- filename) > 0
-#endif
- ) {
- /* The request addresses a CGI script or a Lua script. The URI
- * corresponds to the script itself (like /path/script.cgi),
- * and there is no additional resource path
- * (like /path/script.cgi/something).
+ if (mg_stat(conn, filename, filestat)) {
+ /* 8.1: File exists. */
+ *is_found = 1;
+
+ /* 8.2: Check if it is a script type. */
+ if (extention_matches_script(conn, filename)) {
+ /* The request addresses a CGI resource, Lua script or
+ * server-side javascript.
+ * The URI corresponds to the script itself (like
+ * /path/script.cgi), and there is no additional resource
+ * path (like /path/script.cgi/something).
* Requests that modify (replace or delete) a resource, like
* PUT and DELETE requests, should replace/delete the script
* file.
* Requests that read or write from/to a resource, like GET and
* POST requests, should call the script and return the
* generated response. */
- *is_script_resource = !*is_put_or_delete_request;
+ *is_script_resource = (!*is_put_or_delete_request);
+ }
+
+ /* 8.3: If the request target is a directory, there could be
+ * a substitute file (index.html, index.cgi, ...). */
+ if (filestat->is_directory) {
+ /* Use a local copy here, since substitute_index_file will
+ * change the content of the file status */
+ struct mg_file_stat tmp_filestat;
+ memset(&tmp_filestat, 0, sizeof(tmp_filestat));
+
+ if (substitute_index_file(
+ conn, filename, filename_buf_len, &tmp_filestat)) {
+
+ /* Substitute file found. Copy stat to the output, then
+ * check if the file is a script file */
+ *filestat = tmp_filestat;
+
+ if (extention_matches_script(conn, filename)) {
+ /* Substitute file is a script file */
+ *is_script_resource = 1;
+ } else {
+ /* Substitute file is a regular file */
+ *is_script_resource = 0;
+ *is_found = (mg_stat(conn, filename, filestat) ? 1 : 0);
+ }
+ }
+ /* If there is no substitute file, the server could return
+ * a directory listing in a later step */
}
-#endif /* !defined(NO_CGI) || defined(USE_LUA) || defined(USE_DUKTAPE) */
- *is_found = 1;
return;
}
+ /* Step 9: Check for zipped files: */
/* 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) {
- mg_snprintf(
- conn, &truncated, gz_path, sizeof(gz_path), "%s.gz", filename);
+ if (conn->accept_gzip) {
+ mg_snprintf(
+ conn, &truncated, gz_path, sizeof(gz_path), "%s.gz", filename);
- if (truncated) {
- goto interpret_cleanup;
- }
+ if (truncated) {
+ goto interpret_cleanup;
+ }
- if (mg_stat(conn, gz_path, filep)) {
- if (filep) {
- filep->gzipped = 1;
- *is_found = 1;
- }
- /* Currently gz files can not be scripts. */
- return;
+ if (mg_stat(conn, gz_path, filestat)) {
+ if (filestat) {
+ filestat->is_gzipped = 1;
+ *is_found = 1;
}
+ /* Currently gz files can not be scripts. */
+ return;
}
}
#if !defined(NO_CGI) || defined(USE_LUA) || defined(USE_DUKTAPE)
+ /* Step 10: Script resources may handle sub-resources */
/* Support PATH_INFO for CGI scripts. */
- for (p = filename + strlen(filename); p > filename + 1; p--) {
- if (*p == '/') {
- *p = '\0';
- if ((0
-#if !defined(NO_CGI)
- || match_prefix(conn->ctx->config[CGI_EXTENSIONS],
- strlen(conn->ctx->config[CGI_EXTENSIONS]),
- filename) > 0
-#endif
-#if defined(USE_LUA)
- || match_prefix(conn->ctx->config[LUA_SCRIPT_EXTENSIONS],
- strlen(
- conn->ctx->config[LUA_SCRIPT_EXTENSIONS]),
- filename) > 0
-#endif
-#if defined(USE_DUKTAPE)
- || match_prefix(
- conn->ctx->config[DUKTAPE_SCRIPT_EXTENSIONS],
- strlen(conn->ctx->config[DUKTAPE_SCRIPT_EXTENSIONS]),
- filename) > 0
-#endif
- ) && mg_stat(conn, filename, 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] = '/';
- *is_script_resource = 1;
- break;
- } else {
- *p = '/';
+ tmp_str_len = strlen(filename);
+ tmp_str = (char *)mg_malloc_ctx(tmp_str_len + PATH_MAX + 1, conn->ctx);
+ if (!tmp_str) {
+ /* Out of memory */
+ goto interpret_cleanup;
+ }
+ memcpy(tmp_str, filename, tmp_str_len + 1);
+
+ /* Check config, if index scripts may have sub-resources */
+ allow_substitute_script_subresources =
+ !mg_strcasecmp(conn->ctx->config[ALLOW_INDEX_SCRIPT_SUB_RES], "yes");
+
+ sep_pos = tmp_str_len;
+ while (sep_pos > 0) {
+ sep_pos--;
+ if (tmp_str[sep_pos] == '/') {
+ int is_script = 0, does_exist = 0;
+
+ tmp_str[sep_pos] = 0;
+ if (tmp_str[0]) {
+ is_script = extention_matches_script(conn, tmp_str);
+ does_exist = mg_stat(conn, tmp_str, filestat);
}
+
+ if (does_exist && is_script) {
+ filename[sep_pos] = 0;
+ memmove(filename + sep_pos + 2,
+ filename + sep_pos + 1,
+ strlen(filename + sep_pos + 1) + 1);
+ conn->path_info = filename + sep_pos + 1;
+ filename[sep_pos + 1] = '/';
+ *is_script_resource = 1;
+ *is_found = 1;
+ break;
+ }
+
+ if (allow_substitute_script_subresources) {
+ if (substitute_index_file(
+ conn, tmp_str, tmp_str_len + PATH_MAX, filestat)) {
+
+ /* some intermediate directory has an index file */
+ if (extention_matches_script(conn, tmp_str)) {
+
+ char *tmp_str2;
+
+ DEBUG_TRACE("Substitute script %s serving path %s",
+ tmp_str,
+ filename);
+
+ /* this index file is a script */
+ tmp_str2 = mg_strdup(filename + sep_pos + 1);
+ mg_snprintf(conn,
+ &truncated,
+ filename,
+ filename_buf_len,
+ "%s//%s",
+ tmp_str,
+ tmp_str2);
+ mg_free(tmp_str2);
+
+ if (truncated) {
+ mg_free(tmp_str);
+ goto interpret_cleanup;
+ }
+ sep_pos = strlen(tmp_str);
+ filename[sep_pos] = 0;
+ conn->path_info = filename + sep_pos + 1;
+ *is_script_resource = 1;
+ *is_found = 1;
+ break;
+
+ } else {
+
+ DEBUG_TRACE("Substitute file %s serving path %s",
+ tmp_str,
+ filename);
+
+ /* non-script files will not have sub-resources */
+ filename[sep_pos] = 0;
+ conn->path_info = 0;
+ *is_script_resource = 0;
+ *is_found = 0;
+ break;
+ }
+ }
+ }
+
+ tmp_str[sep_pos] = '/';
}
}
+
+ mg_free(tmp_str);
+
#endif /* !defined(NO_CGI) || defined(USE_LUA) || defined(USE_DUKTAPE) */
#endif /* !defined(NO_FILES) */
return;
@@ -4887,7 +6987,7 @@ interpret_uri(struct mg_connection *conn, /* in: request (must be valid) */
#if !defined(NO_FILES)
/* Reset all outputs */
interpret_cleanup:
- memset(filep, 0, sizeof(*filep));
+ memset(filestat, 0, sizeof(*filestat));
*filename = 0;
*is_found = 0;
*is_script_resource = 0;
@@ -4898,38 +6998,43 @@ interpret_cleanup:
/* Check whether full request is buffered. Return:
- * -1 if request is malformed
- * 0 if request is not yet fully buffered
+ * -1 if request or response is malformed
+ * 0 if request or response is not yet fully buffered
* >0 actual request length, including last \r\n\r\n */
static int
-get_request_len(const char *buf, int buflen)
+get_http_header_len(const char *buf, int buflen)
{
- const char *s, *e;
- int len = 0;
- int in_content = 0;
+ int i;
+ for (i = 0; i < buflen; i++) {
+ /* Do an unsigned comparison in some conditions below */
+ const unsigned char c = ((const unsigned char *)buf)[i];
- for (s = buf, e = s + buflen - 1; len <= 0 && s < e; s++) {
- /* Control characters are not allowed but >=128 is. */
- if (!in_content && !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 && s[1] == '\r' && s[2] == '\n') {
- len = (int)(s - buf) + 3;
- in_content = 0;
+ if ((c < 128) && ((char)c != '\r') && ((char)c != '\n')
+ && !isprint(c)) {
+ /* abort scan as soon as one malformed character is found */
+ return -1;
}
- if (!in_content && *s == ':') {
- in_content = 1;
+ if (i < buflen - 1) {
+ if ((buf[i] == '\n') && (buf[i + 1] == '\n')) {
+ /* Two newline, no carriage return - not standard compliant,
+ * but
+ * it
+ * should be accepted */
+ return i + 2;
+ }
+ }
+
+ if (i < buflen - 3) {
+ if ((buf[i] == '\r') && (buf[i + 1] == '\n') && (buf[i + 2] == '\r')
+ && (buf[i + 3] == '\n')) {
+ /* Two \r\n - standard compliant */
+ return i + 4;
+ }
}
}
- return len;
+ return 0;
}
@@ -5014,14 +7119,18 @@ remove_double_dots_and_double_slashes(char *s)
{
char *p = s;
+ while ((s[0] == '.') && (s[1] == '.')) {
+ s++;
+ }
+
while (*s != '\0') {
*p++ = *s++;
- if (s[-1] == '/' || s[-1] == '\\') {
+ if ((s[-1] == '/') || (s[-1] == '\\')) {
/* Skip all following slashes, backslashes and double-dots */
while (s[0] != '\0') {
- if (s[0] == '/' || s[0] == '\\') {
+ if ((s[0] == '/') || (s[0] == '\\')) {
s++;
- } else if (s[0] == '.' && s[1] == '.') {
+ } else if ((s[0] == '.') && (s[1] == '.')) {
s += 2;
} else {
break;
@@ -5038,7 +7147,8 @@ static const struct {
size_t ext_len;
const char *mime_type;
} builtin_mime_types[] = {
- /* IANA registered MIME types (http://www.iana.org/assignments/media-types)
+ /* IANA registered MIME types
+ * (http://www.iana.org/assignments/media-types)
* application types */
{".doc", 4, "application/msword"},
{".eps", 4, "application/postscript"},
@@ -5144,8 +7254,8 @@ mg_get_builtin_mime_type(const char *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) {
+ 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;
}
}
@@ -5165,7 +7275,10 @@ get_mime_type(struct mg_context *ctx, const char *path, struct vec *vec)
path_len = strlen(path);
- if (ctx == NULL || vec == NULL) {
+ if ((ctx == NULL) || (vec == NULL)) {
+ if (vec != NULL) {
+ memset(vec, '\0', sizeof(struct vec));
+ }
return;
}
@@ -5201,7 +7314,8 @@ bin2str(char *to, const unsigned char *p, size_t len)
}
-/* Return stringified MD5 hash for list of strings. Buffer must be 33 bytes. */
+/* Return stringified MD5 hash for list of strings. Buffer must be 33 bytes.
+ */
char *
mg_md5(char buf[33], ...)
{
@@ -5238,9 +7352,8 @@ check_password(const char *method,
char ha2[32 + 1], expected_response[32 + 1];
/* Some of the parameters may be NULL */
- if (method == NULL || nonce == NULL || nc == NULL || cnonce == NULL
- || qop == NULL
- || response == NULL) {
+ if ((method == NULL) || (nonce == NULL) || (nc == NULL) || (cnonce == NULL)
+ || (qop == NULL) || (response == NULL)) {
return 0;
}
@@ -5271,25 +7384,30 @@ check_password(const char *method,
/* Use the global passwords file, if specified by auth_gpass option,
* or search for .htpasswd in the requested directory. */
static void
-open_auth_file(struct mg_connection *conn, const char *path, struct file *filep)
+open_auth_file(struct mg_connection *conn,
+ const char *path,
+ struct mg_file *filep)
{
- if (conn != NULL && conn->ctx != NULL) {
+ if ((conn != NULL) && (conn->ctx != NULL)) {
char name[PATH_MAX];
const char *p, *e, *gpass = conn->ctx->config[GLOBAL_PASSWORDS_FILE];
- struct file file = STRUCT_FILE_INITIALIZER;
int truncated;
if (gpass != NULL) {
/* Use global passwords file */
- if (!mg_fopen(conn, gpass, "r", filep)) {
+ if (!mg_fopen(conn, gpass, MG_FOPEN_MODE_READ, filep)) {
#ifdef DEBUG
+ /* Use mg_cry here, since gpass has been configured. */
mg_cry(conn, "fopen(%s): %s", gpass, strerror(ERRNO));
#endif
}
- /* 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) {
+ /* Important: using local struct mg_file to test path for
+ * is_directory flag. If filep is used, mg_stat() makes it
+ * appear as if auth file was opened.
+ * TODO(mid): Check if this is still required after rewriting
+ * mg_stat */
+ } else if (mg_stat(conn, path, &filep->stat)
+ && filep->stat.is_directory) {
mg_snprintf(conn,
&truncated,
name,
@@ -5298,9 +7416,12 @@ open_auth_file(struct mg_connection *conn, const char *path, struct file *filep)
path,
PASSWORDS_FILE_NAME);
- if (truncated || !mg_fopen(conn, name, "r", filep)) {
+ if (truncated || !mg_fopen(conn, name, MG_FOPEN_MODE_READ, filep)) {
#ifdef DEBUG
- mg_cry(conn, "fopen(%s): %s", name, strerror(ERRNO));
+ /* Don't use mg_cry here, but only a trace, since this is
+ * a typical case. It will occur for every directory
+ * without a password file. */
+ DEBUG_TRACE("fopen(%s): %s", name, strerror(ERRNO));
#endif
}
} else {
@@ -5319,9 +7440,12 @@ open_auth_file(struct mg_connection *conn, const char *path, struct file *filep)
p,
PASSWORDS_FILE_NAME);
- if (truncated || !mg_fopen(conn, name, "r", filep)) {
+ if (truncated || !mg_fopen(conn, name, MG_FOPEN_MODE_READ, filep)) {
#ifdef DEBUG
- mg_cry(conn, "fopen(%s): %s", name, strerror(ERRNO));
+ /* Don't use mg_cry here, but only a trace, since this is
+ * a typical case. It will occur for every directory
+ * without a password file. */
+ DEBUG_TRACE("fopen(%s): %s", name, strerror(ERRNO));
#endif
}
}
@@ -5351,7 +7475,7 @@ parse_auth_header(struct mg_connection *conn,
}
(void)memset(ah, 0, sizeof(*ah));
- if ((auth_header = mg_get_header(conn, "Authorization")) == NULL
+ if (((auth_header = mg_get_header(conn, "Authorization")) == NULL)
|| mg_strncasecmp(auth_header, "Digest ", 7) != 0) {
return 0;
}
@@ -5367,7 +7491,8 @@ parse_auth_header(struct mg_connection *conn,
s++;
}
name = skip_quoted(&s, "=", " ", 0);
- /* Value is either quote-delimited, or ends at first comma or space. */
+ /* Value is either quote-delimited, or ends at first comma or space.
+ */
if (s[0] == '\"') {
s++;
value = skip_quoted(&s, "\"", " ", '\\');
@@ -5431,6 +7556,8 @@ parse_auth_header(struct mg_connection *conn,
if (nonce >= ((uint64_t)conn->ctx->start_time + conn->ctx->nonce_count)) {
return 0;
}
+#else
+ (void)nonce;
#endif
/* CGI needs it as REMOTE_USER */
@@ -5445,7 +7572,7 @@ parse_auth_header(struct mg_connection *conn,
static const char *
-mg_fgets(char *buf, size_t size, struct file *filep, char **p)
+mg_fgets(char *buf, size_t size, struct mg_file *filep, char **p)
{
const char *eof;
size_t len;
@@ -5455,8 +7582,8 @@ mg_fgets(char *buf, size_t size, struct file *filep, char **p)
return NULL;
}
- if (filep->membuf != NULL && *p != NULL) {
- memend = (const char *)&filep->membuf[filep->size];
+ if ((filep->access.membuf != NULL) && (*p != NULL)) {
+ memend = (const char *)&filep->access.membuf[filep->stat.size];
/* Search for \n from p till the end of stream */
eof = (char *)memchr(*p, '\n', (size_t)(memend - *p));
if (eof != NULL) {
@@ -5464,43 +7591,57 @@ mg_fgets(char *buf, size_t size, struct file *filep, char **p)
} else {
eof = memend; /* Copy remaining data */
}
- len = (size_t)(eof - *p) > size - 1 ? size - 1 : (size_t)(eof - *p);
+ 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, (int)size, filep->fp);
+ } else if (filep->access.fp != NULL) {
+ return fgets(buf, (int)size, filep->access.fp);
} else {
return NULL;
}
}
+/* Define the initial recursion depth for procesesing htpasswd files that
+ * include other htpasswd
+ * (or even the same) files. It is not difficult to provide a file or files
+ * s.t. they force civetweb
+ * to infinitely recurse and then crash.
+ */
+#define INITIAL_DEPTH 9
+#if INITIAL_DEPTH <= 0
+#error Bad INITIAL_DEPTH for recursion, set to at least 1
+#endif
+
struct read_auth_file_struct {
struct mg_connection *conn;
struct ah ah;
- char *domain;
+ const char *domain;
char buf[256 + 256 + 40];
- char *f_user;
- char *f_domain;
- char *f_ha1;
+ const char *f_user;
+ const char *f_domain;
+ const char *f_ha1;
};
static int
-read_auth_file(struct file *filep, struct read_auth_file_struct *workdata)
+read_auth_file(struct mg_file *filep,
+ struct read_auth_file_struct *workdata,
+ int depth)
{
char *p;
int is_authorized = 0;
- struct file fp;
+ struct mg_file fp;
size_t l;
- if (!filep || !workdata) {
+ if (!filep || !workdata || (0 == depth)) {
return 0;
}
/* Loop over passwords file */
- p = (char *)filep->membuf;
+ p = (char *)filep->access.membuf;
while (mg_fgets(workdata->buf, sizeof(workdata->buf), filep, &p) != NULL) {
l = strlen(workdata->buf);
while (l > 0) {
@@ -5519,14 +7660,27 @@ read_auth_file(struct file *filep, struct read_auth_file_struct *workdata)
if (workdata->f_user[0] == ':') {
/* user names may not contain a ':' and may not be empty,
- * so lines starting with ':' may be used for a special purpose */
+ * so lines starting with ':' may be used for a special purpose
+ */
if (workdata->f_user[1] == '#') {
/* :# is a comment */
continue;
} else if (!strncmp(workdata->f_user + 1, "include=", 8)) {
- if (mg_fopen(workdata->conn, workdata->f_user + 9, "r", &fp)) {
- is_authorized = read_auth_file(&fp, workdata);
- mg_fclose(&fp);
+ if (mg_fopen(workdata->conn,
+ workdata->f_user + 9,
+ MG_FOPEN_MODE_READ,
+ &fp)) {
+ is_authorized = read_auth_file(&fp, workdata, depth - 1);
+ (void)mg_fclose(
+ &fp.access); /* ignore error on read only file */
+
+ /* No need to continue processing files once we have a
+ * match, since nothing will reset it back
+ * to 0.
+ */
+ if (is_authorized) {
+ return is_authorized;
+ }
} else {
mg_cry(workdata->conn,
"%s: cannot open authorization file: %s",
@@ -5552,7 +7706,7 @@ read_auth_file(struct file *filep, struct read_auth_file_struct *workdata)
workdata->buf);
continue;
}
- *(workdata->f_domain) = 0;
+ *(char *)(workdata->f_domain) = 0;
(workdata->f_domain)++;
workdata->f_ha1 = strchr(workdata->f_domain, ':');
@@ -5563,7 +7717,7 @@ read_auth_file(struct file *filep, struct read_auth_file_struct *workdata)
workdata->buf);
continue;
}
- *(workdata->f_ha1) = 0;
+ *(char *)(workdata->f_ha1) = 0;
(workdata->f_ha1)++;
if (!strcmp(workdata->ah.user, workdata->f_user)
@@ -5585,7 +7739,7 @@ read_auth_file(struct file *filep, struct read_auth_file_struct *workdata)
/* Authorize against the opened passwords file. Return 1 if authorized. */
static int
-authorize(struct mg_connection *conn, struct file *filep)
+authorize(struct mg_connection *conn, struct mg_file *filep, const char *realm)
{
struct read_auth_file_struct workdata;
char buf[MG_BUF_LEN];
@@ -5600,9 +7754,38 @@ authorize(struct mg_connection *conn, struct file *filep)
if (!parse_auth_header(conn, buf, sizeof(buf), &workdata.ah)) {
return 0;
}
- workdata.domain = conn->ctx->config[AUTHENTICATION_DOMAIN];
- return read_auth_file(filep, &workdata);
+ if (realm) {
+ workdata.domain = realm;
+ } else {
+ workdata.domain = conn->ctx->config[AUTHENTICATION_DOMAIN];
+ }
+
+ return read_auth_file(filep, &workdata, INITIAL_DEPTH);
+}
+
+
+/* Public function to check http digest authentication header */
+int
+mg_check_digest_access_authentication(struct mg_connection *conn,
+ const char *realm,
+ const char *filename)
+{
+ struct mg_file file = STRUCT_FILE_INITIALIZER;
+ int auth;
+
+ if (!conn || !filename) {
+ return -1;
+ }
+ if (!mg_fopen(conn, filename, MG_FOPEN_MODE_READ, &file)) {
+ return -2;
+ }
+
+ auth = authorize(conn, &file, realm);
+
+ mg_fclose(&file.access);
+
+ return auth;
}
@@ -5613,7 +7796,7 @@ check_authorization(struct mg_connection *conn, const char *path)
char fname[PATH_MAX];
struct vec uri_vec, filename_vec;
const char *list;
- struct file file = STRUCT_FILE_INITIALIZER;
+ struct mg_file file = STRUCT_FILE_INITIALIZER;
int authorized = 1, truncated;
if (!conn || !conn->ctx) {
@@ -5631,7 +7814,8 @@ check_authorization(struct mg_connection *conn, const char *path)
(int)filename_vec.len,
filename_vec.ptr);
- if (truncated || !mg_fopen(conn, fname, "r", &file)) {
+ if (truncated
+ || !mg_fopen(conn, fname, MG_FOPEN_MODE_READ, &file)) {
mg_cry(conn,
"%s: cannot open %s: %s",
__func__,
@@ -5642,52 +7826,70 @@ check_authorization(struct mg_connection *conn, const char *path)
}
}
- if (!is_file_opened(&file)) {
+ if (!is_file_opened(&file.access)) {
open_auth_file(conn, path, &file);
}
- if (is_file_opened(&file)) {
- authorized = authorize(conn, &file);
- mg_fclose(&file);
+ if (is_file_opened(&file.access)) {
+ authorized = authorize(conn, &file, NULL);
+ (void)mg_fclose(&file.access); /* ignore error on read only file */
}
return authorized;
}
+/* Internal function. Assumes conn is valid */
static void
-send_authorization_request(struct mg_connection *conn)
+send_authorization_request(struct mg_connection *conn, const char *realm)
{
char date[64];
time_t curtime = time(NULL);
+ uint64_t nonce = (uint64_t)(conn->ctx->start_time);
- if (conn && conn->ctx) {
- uint64_t nonce = (uint64_t)(conn->ctx->start_time);
-
- (void)pthread_mutex_lock(&conn->ctx->nonce_mutex);
- nonce += conn->ctx->nonce_count;
- ++conn->ctx->nonce_count;
- (void)pthread_mutex_unlock(&conn->ctx->nonce_mutex);
-
- nonce ^= conn->ctx->auth_nonce_mask;
- conn->status_code = 401;
- conn->must_close = 1;
-
- gmt_time_string(date, sizeof(date), &curtime);
-
- mg_printf(conn, "HTTP/1.1 401 Unauthorized\r\n");
- send_no_cache_header(conn);
- mg_printf(conn,
- "Date: %s\r\n"
- "Connection: %s\r\n"
- "Content-Length: 0\r\n"
- "WWW-Authenticate: Digest qop=\"auth\", realm=\"%s\", "
- "nonce=\"%" UINT64_FMT "\"\r\n\r\n",
- date,
- suggest_connection_header(conn),
- conn->ctx->config[AUTHENTICATION_DOMAIN],
- nonce);
+ if (!realm) {
+ realm = conn->ctx->config[AUTHENTICATION_DOMAIN];
}
+
+ (void)pthread_mutex_lock(&conn->ctx->nonce_mutex);
+ nonce += conn->ctx->nonce_count;
+ ++conn->ctx->nonce_count;
+ (void)pthread_mutex_unlock(&conn->ctx->nonce_mutex);
+
+ nonce ^= conn->ctx->auth_nonce_mask;
+ conn->status_code = 401;
+ conn->must_close = 1;
+
+ gmt_time_string(date, sizeof(date), &curtime);
+
+ mg_printf(conn, "HTTP/1.1 401 Unauthorized\r\n");
+ send_no_cache_header(conn);
+ send_additional_header(conn);
+ mg_printf(conn,
+ "Date: %s\r\n"
+ "Connection: %s\r\n"
+ "Content-Length: 0\r\n"
+ "WWW-Authenticate: Digest qop=\"auth\", realm=\"%s\", "
+ "nonce=\"%" UINT64_FMT "\"\r\n\r\n",
+ date,
+ suggest_connection_header(conn),
+ realm,
+ nonce);
+}
+
+
+/* Interface function. Parameters are provided by the user, so do
+ * at least some basic checks.
+ */
+int
+mg_send_digest_access_authentication_request(struct mg_connection *conn,
+ const char *realm)
+{
+ if (conn && conn->ctx) {
+ send_authorization_request(conn, realm);
+ return 0;
+ }
+ return -1;
}
@@ -5696,13 +7898,14 @@ static int
is_authorized_for_put(struct mg_connection *conn)
{
if (conn) {
- struct file file = STRUCT_FILE_INITIALIZER;
+ struct mg_file file = STRUCT_FILE_INITIALIZER;
const char *passfile = conn->ctx->config[PUT_DELETE_PASSWORDS_FILE];
int ret = 0;
- if (passfile != NULL && mg_fopen(conn, passfile, "r", &file)) {
- ret = authorize(conn, &file);
- mg_fclose(&file);
+ if (passfile != NULL
+ && mg_fopen(conn, passfile, MG_FOPEN_MODE_READ, &file)) {
+ ret = authorize(conn, &file, NULL);
+ (void)mg_fclose(&file.access); /* ignore error on read only file */
}
return ret;
@@ -5726,16 +7929,17 @@ mg_modify_passwords_file(const char *fname,
fp = fp2 = NULL;
/* Regard empty password as no password - remove user record. */
- if (pass != NULL && pass[0] == '\0') {
+ if ((pass != NULL) && (pass[0] == '\0')) {
pass = NULL;
}
/* Other arguments must not be empty */
- if (fname == NULL || domain == NULL || user == NULL) {
+ if ((fname == NULL) || (domain == NULL) || (user == NULL)) {
return 0;
}
- /* Using the given file format, user name and domain must not contain ':'
+ /* Using the given file format, user name and domain must not contain
+ * ':'
*/
if (strchr(user, ':') != NULL) {
return 0;
@@ -5746,7 +7950,7 @@ mg_modify_passwords_file(const char *fname,
/* Do not allow control characters like newline in user name and domain.
* Do not allow excessively long names either. */
- for (i = 0; i < 255 && user[i] != 0; i++) {
+ for (i = 0; ((i < 255) && (user[i] != 0)); i++) {
if (iscntrl(user[i])) {
return 0;
}
@@ -5754,7 +7958,7 @@ mg_modify_passwords_file(const char *fname,
if (user[i]) {
return 0;
}
- for (i = 0; i < 255 && domain[i] != 0; i++) {
+ for (i = 0; ((i < 255) && (domain[i] != 0)); i++) {
if (iscntrl(domain[i])) {
return 0;
}
@@ -5806,7 +8010,7 @@ mg_modify_passwords_file(const char *fname,
}
/* If new user, just add it */
- if (!found && pass != NULL) {
+ if (!found && (pass != NULL)) {
mg_md5(ha1, user, ":", domain, ":", pass, NULL);
fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
}
@@ -5826,7 +8030,7 @@ mg_modify_passwords_file(const char *fname,
static int
is_valid_port(unsigned long port)
{
- return port < 0xffff;
+ return (port <= 0xffff);
}
@@ -5855,7 +8059,7 @@ mg_inet_pton(int af, const char *src, void *dst, size_t dstlen)
ressave = res;
while (res) {
- if (dstlen >= res->ai_addrlen) {
+ if (dstlen >= (size_t)res->ai_addrlen) {
memcpy(dst, res->ai_addr, res->ai_addrlen);
func_ret = 1;
}
@@ -5896,7 +8100,7 @@ connect_socket(struct mg_context *ctx /* may be NULL */,
return 0;
}
- if (port < 0 || !is_valid_port((unsigned)port)) {
+ if ((port <= 0) || !is_valid_port((unsigned)port)) {
mg_snprintf(NULL,
NULL, /* No truncation check for ebuf */
ebuf,
@@ -5906,7 +8110,19 @@ connect_socket(struct mg_context *ctx /* may be NULL */,
return 0;
}
-#ifndef NO_SSL_DL
+#if !defined(NO_SSL)
+#if !defined(NO_SSL_DL)
+#ifdef OPENSSL_API_1_1
+ if (use_ssl && (TLS_client_method == NULL)) {
+ mg_snprintf(NULL,
+ NULL, /* No truncation check for ebuf */
+ ebuf,
+ ebuf_len,
+ "%s",
+ "SSL is not initialized");
+ return 0;
+ }
+#else
if (use_ssl && (SSLv23_client_method == NULL)) {
mg_snprintf(NULL,
NULL, /* No truncation check for ebuf */
@@ -5916,23 +8132,33 @@ connect_socket(struct mg_context *ctx /* may be NULL */,
"SSL is not initialized");
return 0;
}
-#endif
+
+#endif /* OPENSSL_API_1_1 */
+#else
+ (void)use_ssl;
+#endif /* NO_SSL_DL */
+#else
+ (void)use_ssl;
+#endif /* !defined(NO_SSL) */
if (mg_inet_pton(AF_INET, host, &sa->sin, sizeof(sa->sin))) {
+ sa->sin.sin_family = AF_INET;
sa->sin.sin_port = htons((uint16_t)port);
ip_ver = 4;
#ifdef USE_IPV6
} else if (mg_inet_pton(AF_INET6, host, &sa->sin6, sizeof(sa->sin6))) {
+ sa->sin6.sin6_family = AF_INET6;
sa->sin6.sin6_port = htons((uint16_t)port);
ip_ver = 6;
} else if (host[0] == '[') {
/* While getaddrinfo on Windows will work with [::1],
* getaddrinfo on Linux only works with ::1 (without []). */
size_t l = strlen(host + 1);
- char *h = l > 1 ? mg_strdup(host + 1) : NULL;
+ char *h = (l > 1) ? mg_strdup(host + 1) : NULL;
if (h) {
h[l - 1] = 0;
if (mg_inet_pton(AF_INET6, h, &sa->sin6, sizeof(sa->sin6))) {
+ sa->sin6.sin6_family = AF_INET6;
sa->sin6.sin6_port = htons((uint16_t)port);
ip_ver = 6;
}
@@ -5976,7 +8202,12 @@ connect_socket(struct mg_context *ctx /* may be NULL */,
&& (connect(*sock, (struct sockaddr *)&sa->sin, sizeof(sa->sin))
== 0)) {
/* connected with IPv4 */
- return 1;
+ if (0 == set_non_blocking_mode(*sock)) {
+ /* Ok */
+ return 1;
+ }
+ /* failed */
+ /* TODO: specific error message */
}
#ifdef USE_IPV6
@@ -5984,7 +8215,12 @@ connect_socket(struct mg_context *ctx /* may be NULL */,
&& (connect(*sock, (struct sockaddr *)&sa->sin6, sizeof(sa->sin6))
== 0)) {
/* connected with IPv6 */
- return 1;
+ if (0 == set_non_blocking_mode(*sock)) {
+ /* Ok */
+ return 1;
+ }
+ /* failed */
+ /* TODO: specific error message */
}
#endif
@@ -5999,6 +8235,7 @@ connect_socket(struct mg_context *ctx /* may be NULL */,
strerror(ERRNO));
closesocket(*sock);
*sock = INVALID_SOCKET;
+
return 0;
}
@@ -6011,9 +8248,9 @@ mg_url_encode(const char *src, char *dst, size_t dst_len)
char *pos = dst;
const char *end = dst + dst_len - 1;
- for (; *src != '\0' && pos < end; src++, pos++) {
+ for (; ((*src != '\0') && (pos < end)); src++, pos++) {
if (isalnum(*(const unsigned char *)src)
- || strchr(dont_escape, *(const unsigned char *)src) != NULL) {
+ || (strchr(dont_escape, *(const unsigned char *)src) != NULL)) {
*pos = *src;
} else if (pos + 2 < end) {
pos[0] = '%';
@@ -6029,13 +8266,21 @@ mg_url_encode(const char *src, char *dst, size_t dst_len)
return (*src == '\0') ? (int)(pos - dst) : -1;
}
+/* Return 0 on success, non-zero if an error occurs. */
-static void
+static int
print_dir_entry(struct de *de)
{
- char size[64], mod[64], href[PATH_MAX];
+ size_t hrefsize;
+ char *href;
+ char size[64], mod[64];
struct tm *tm;
+ hrefsize = PATH_MAX * 3; /* worst case */
+ href = (char *)mg_malloc(hrefsize);
+ if (href == NULL) {
+ return -1;
+ }
if (de->file.is_directory) {
mg_snprintf(de->conn,
NULL, /* Buffer is big enough */
@@ -6087,18 +8332,19 @@ print_dir_entry(struct de *de)
mg_strlcpy(mod, "01-Jan-1970 00:00", sizeof(mod));
mod[sizeof(mod) - 1] = '\0';
}
- mg_url_encode(de->file_name, href, sizeof(href));
- de->conn->num_bytes_sent +=
- mg_printf(de->conn,
- "%s%s "
- " %s %s %s%s "
+ " %s %s Index of %s "
- ""
- "Index of %s
"
- "Name "
- "Modified "
- "Size
Index of %s "
+ ""
+ "Index of %s
"
+ "Name "
+ "Modified "
+ "Size
%s "
- " %s %s %s "
+ " %s %s
");
+ mg_printf(conn, "%s", "
");
conn->status_code = 200;
}
@@ -6411,7 +8653,7 @@ handle_directory_request(struct mg_connection *conn, const char *dir)
/* Send len bytes from the opened file to the client. */
static void
send_file_data(struct mg_connection *conn,
- struct file *filep,
+ struct mg_file *filep,
int64_t offset,
int64_t len)
{
@@ -6424,23 +8666,26 @@ send_file_data(struct mg_connection *conn,
}
/* Sanity check the offset */
- size = filep->size > INT64_MAX ? INT64_MAX : (int64_t)(filep->size);
- offset = offset < 0 ? 0 : offset > size ? size : offset;
+ size = (filep->stat.size > INT64_MAX) ? INT64_MAX
+ : (int64_t)(filep->stat.size);
+ offset = (offset < 0) ? 0 : ((offset > size) ? size : offset);
- if (len > 0 && filep->membuf != NULL && size > 0) {
+ if ((len > 0) && (filep->access.membuf != NULL) && (size > 0)) {
/* file stored in memory */
if (len > size - offset) {
len = size - offset;
}
- mg_write(conn, filep->membuf + offset, (size_t)len);
- } else if (len > 0 && filep->fp != NULL) {
+ mg_write(conn, filep->access.membuf + offset, (size_t)len);
+ } else if (len > 0 && filep->access.fp != NULL) {
/* file stored on disk */
#if defined(__linux__)
/* sendfile is only available for Linux */
- if (conn->throttle == 0 && conn->ssl == 0) {
+ if ((conn->ssl == 0) && (conn->throttle == 0)
+ && (!mg_strcasecmp(conn->ctx->config[ALLOW_SENDFILE_CALL],
+ "yes"))) {
off_t sf_offs = (off_t)offset;
ssize_t sf_sent;
- int sf_file = fileno(filep->fp);
+ int sf_file = fileno(filep->access.fp);
int loop_cnt = 0;
do {
@@ -6451,7 +8696,6 @@ send_file_data(struct mg_connection *conn,
sf_sent =
sendfile(conn->client.sock, sf_file, &sf_offs, sf_tosend);
if (sf_sent > 0) {
- conn->num_bytes_sent += sf_sent;
len -= sf_sent;
offset += sf_sent;
} else if (loop_cnt == 0) {
@@ -6478,9 +8722,9 @@ send_file_data(struct mg_connection *conn,
offset = (int64_t)sf_offs;
}
#endif
- if ((offset > 0) && (fseeko(filep->fp, offset, SEEK_SET) != 0)) {
+ if ((offset > 0) && (fseeko(filep->access.fp, offset, SEEK_SET) != 0)) {
mg_cry(conn, "%s: fseeko() failed: %s", __func__, strerror(ERRNO));
- send_http_error(
+ mg_send_http_error(
conn,
500,
"%s",
@@ -6494,7 +8738,8 @@ send_file_data(struct mg_connection *conn,
}
/* Read from file, exit the loop on error */
- if ((num_read = (int)fread(buf, 1, (size_t)to_read, filep->fp))
+ if ((num_read =
+ (int)fread(buf, 1, (size_t)to_read, filep->access.fp))
<= 0) {
break;
}
@@ -6506,7 +8751,6 @@ send_file_data(struct mg_connection *conn,
}
/* Both read and were successful, adjust counters */
- conn->num_bytes_sent += num_written;
len -= num_written;
}
}
@@ -6522,22 +8766,22 @@ parse_range_header(const char *header, int64_t *a, int64_t *b)
static void
-construct_etag(char *buf, size_t buf_len, const struct file *filep)
+construct_etag(char *buf, size_t buf_len, const struct mg_file_stat *filestat)
{
- if (filep != NULL && buf != NULL) {
+ if ((filestat != NULL) && (buf != NULL)) {
mg_snprintf(NULL,
NULL, /* All calls to construct_etag use 64 byte buffer */
buf,
buf_len,
"\"%lx.%" INT64_FMT "\"",
- (unsigned long)filep->last_modified,
- filep->size);
+ (unsigned long)filestat->last_modified,
+ filestat->size);
}
}
static void
-fclose_on_exec(struct file *filep, struct mg_connection *conn)
+fclose_on_exec(struct mg_file_access *filep, struct mg_connection *conn)
{
if (filep != NULL && filep->fp != NULL) {
#ifdef _WIN32
@@ -6557,8 +8801,9 @@ fclose_on_exec(struct file *filep, struct mg_connection *conn)
static void
handle_static_file_request(struct mg_connection *conn,
const char *path,
- struct file *filep,
- const char *mime_type)
+ struct mg_file *filep,
+ const char *mime_type,
+ const char *additional_headers)
{
char date[64], lm[64], etag[64];
char range[128]; /* large enough, so there will be no overflow */
@@ -6570,8 +8815,9 @@ handle_static_file_request(struct mg_connection *conn,
char gz_path[PATH_MAX];
const char *encoding = "";
const char *cors1, *cors2, *cors3;
+ int allow_on_the_fly_compression;
- if (conn == NULL || conn->ctx == NULL || filep == NULL) {
+ if ((conn == NULL) || (conn->ctx == NULL) || (filep == NULL)) {
return;
}
@@ -6581,63 +8827,70 @@ handle_static_file_request(struct mg_connection *conn,
mime_vec.ptr = mime_type;
mime_vec.len = strlen(mime_type);
}
- if (filep->size > INT64_MAX) {
- send_http_error(conn,
- 500,
- "Error: File size is too large to send\n%" INT64_FMT,
- filep->size);
+ if (filep->stat.size > INT64_MAX) {
+ mg_send_http_error(conn,
+ 500,
+ "Error: File size is too large to send\n%" INT64_FMT,
+ filep->stat.size);
+ return;
}
- cl = (int64_t)filep->size;
+ cl = (int64_t)filep->stat.size;
conn->status_code = 200;
range[0] = '\0';
/* 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) {
+ allow_on_the_fly_compression = conn->accept_gzip;
+
+ if (filep->stat.is_gzipped) {
mg_snprintf(conn, &truncated, gz_path, sizeof(gz_path), "%s.gz", path);
if (truncated) {
- send_http_error(conn,
- 500,
- "Error: Path of zipped file too long (%s)",
- path);
+ mg_send_http_error(conn,
+ 500,
+ "Error: Path of zipped file too long (%s)",
+ path);
return;
}
path = gz_path;
encoding = "Content-Encoding: gzip\r\n";
+
+ /* File is already compressed. No "on the fly" compression. */
+ allow_on_the_fly_compression = 0;
}
- if (!mg_fopen(conn, path, "rb", filep)) {
- send_http_error(conn,
- 500,
- "Error: Cannot open file\nfopen(%s): %s",
- path,
- strerror(ERRNO));
+ if (!mg_fopen(conn, path, MG_FOPEN_MODE_READ, filep)) {
+ mg_send_http_error(conn,
+ 500,
+ "Error: Cannot open file\nfopen(%s): %s",
+ path,
+ strerror(ERRNO));
return;
}
- fclose_on_exec(filep, conn);
+ fclose_on_exec(&filep->access, conn);
/* 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 && r1 >= 0
- && r2 >= 0) {
+ 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 uncompressed space) */
- if (filep->gzipped) {
- send_http_error(
+ if (filep->stat.is_gzipped) {
+ mg_send_http_error(
conn,
- 501,
+ 416, /* 416 = Range Not Satisfiable */
"%s",
"Error: Range requests in gzipped files are not supported");
- mg_fclose(filep);
+ (void)mg_fclose(
+ &filep->access); /* ignore error on read only file */
return;
}
conn->status_code = 206;
- cl = n == 2 ? (r2 > cl ? cl : r2) - r1 + 1 : cl - r1;
+ cl = (n == 2) ? (((r2 > cl) ? cl : r2) - r1 + 1) : (cl - r1);
mg_snprintf(conn,
NULL, /* range buffer is big enough */
range,
@@ -6646,15 +8899,19 @@ handle_static_file_request(struct mg_connection *conn,
"%" INT64_FMT "-%" INT64_FMT "/%" INT64_FMT "\r\n",
r1,
r1 + cl - 1,
- filep->size);
+ filep->stat.size);
msg = "Partial Content";
+
+ /* Do not compress ranges. */
+ allow_on_the_fly_compression = 0;
}
hdr = mg_get_header(conn, "Origin");
if (hdr) {
/* Cross-origin resource sharing (CORS), see
* http://www.html5rocks.com/en/tutorials/cors/,
- * http://www.html5rocks.com/static/images/cors_server_flowchart.png -
+ * http://www.html5rocks.com/static/images/cors_server_flowchart.png
+ * -
* preflight is not supported for files. */
cors1 = "Access-Control-Allow-Origin: ";
cors2 = conn->ctx->config[ACCESS_CONTROL_ALLOW_ORIGIN];
@@ -6663,12 +8920,25 @@ handle_static_file_request(struct mg_connection *conn,
cors1 = cors2 = cors3 = "";
}
- /* Prepare Etag, Date, Last-Modified headers. Must be in UTC, according to
+ /* 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), &filep->last_modified);
- construct_etag(etag, sizeof(etag), filep);
+ gmt_time_string(lm, sizeof(lm), &filep->stat.last_modified);
+ construct_etag(etag, sizeof(etag), &filep->stat);
+ /* On the fly compression allowed */
+ if (allow_on_the_fly_compression) {
+ ;
+ /* TODO: add interface to compression module */
+ /* e.g., def from https://zlib.net/zlib_how.html */
+ /* Check license (zlib has a permissive license, but */
+ /* is still not MIT) and use dynamic binding like */
+ /* done with OpenSSL */
+ /* See #199 (https://github.com/civetweb/civetweb/issues/199) */
+ }
+
+ /* Send header */
(void)mg_printf(conn,
"HTTP/1.1 %d %s\r\n"
"%s%s%s"
@@ -6680,6 +8950,8 @@ handle_static_file_request(struct mg_connection *conn,
cors3,
date);
send_static_cache_header(conn);
+ send_additional_header(conn);
+
(void)mg_printf(conn,
"Last-Modified: %s\r\n"
"Etag: %s\r\n"
@@ -6687,7 +8959,7 @@ handle_static_file_request(struct mg_connection *conn,
"Content-Length: %" INT64_FMT "\r\n"
"Connection: %s\r\n"
"Accept-Ranges: bytes\r\n"
- "%s%s\r\n",
+ "%s%s",
lm,
etag,
(int)mime_vec.len,
@@ -6697,13 +8969,61 @@ handle_static_file_request(struct mg_connection *conn,
range,
encoding);
+ /* The previous code must not add any header starting with X- to make
+ * sure no one of the additional_headers is included twice */
+
+ if (additional_headers != NULL) {
+ (void)mg_printf(conn,
+ "%.*s\r\n\r\n",
+ (int)strlen(additional_headers),
+ additional_headers);
+ } else {
+ (void)mg_printf(conn, "\r\n");
+ }
+
if (strcmp(conn->request_info.request_method, "HEAD") != 0) {
send_file_data(conn, filep, r1, cl);
}
- mg_fclose(filep);
+ (void)mg_fclose(&filep->access); /* ignore error on read only file */
}
+#if !defined(NO_CACHING)
+static void
+handle_not_modified_static_file_request(struct mg_connection *conn,
+ struct mg_file *filep)
+{
+ char date[64], lm[64], etag[64];
+ time_t curtime = time(NULL);
+
+ if ((conn == NULL) || (filep == NULL)) {
+ return;
+ }
+ conn->status_code = 304;
+ gmt_time_string(date, sizeof(date), &curtime);
+ gmt_time_string(lm, sizeof(lm), &filep->stat.last_modified);
+ construct_etag(etag, sizeof(etag), &filep->stat);
+
+ (void)mg_printf(conn,
+ "HTTP/1.1 %d %s\r\n"
+ "Date: %s\r\n",
+ conn->status_code,
+ mg_get_response_code_text(conn, conn->status_code),
+ date);
+ send_static_cache_header(conn);
+ send_additional_header(conn);
+ (void)mg_printf(conn,
+ "Last-Modified: %s\r\n"
+ "Etag: %s\r\n"
+ "Connection: %s\r\n"
+ "\r\n",
+ lm,
+ etag,
+ suggest_connection_header(conn));
+}
+#endif
+
+
void
mg_send_file(struct mg_connection *conn, const char *path)
{
@@ -6716,26 +9036,40 @@ mg_send_mime_file(struct mg_connection *conn,
const char *path,
const char *mime_type)
{
- struct file file = STRUCT_FILE_INITIALIZER;
- if (mg_stat(conn, path, &file)) {
- if (file.is_directory) {
- if (!conn) {
- return;
- }
+ mg_send_mime_file2(conn, path, mime_type, NULL);
+}
+
+
+void
+mg_send_mime_file2(struct mg_connection *conn,
+ const char *path,
+ const char *mime_type,
+ const char *additional_headers)
+{
+ struct mg_file file = STRUCT_FILE_INITIALIZER;
+
+ if (!conn) {
+ /* No conn */
+ return;
+ }
+
+ if (mg_stat(conn, path, &file.stat)) {
+ if (file.stat.is_directory) {
if (!mg_strcasecmp(conn->ctx->config[ENABLE_DIRECTORY_LISTING],
"yes")) {
handle_directory_request(conn, path);
} else {
- send_http_error(conn,
- 403,
- "%s",
- "Error: Directory listing denied");
+ mg_send_http_error(conn,
+ 403,
+ "%s",
+ "Error: Directory listing denied");
}
} else {
- handle_static_file_request(conn, path, &file, mime_type);
+ handle_static_file_request(
+ conn, path, &file, mime_type, additional_headers);
}
} else {
- send_http_error(conn, 404, "%s", "Error: File not found");
+ mg_send_http_error(conn, 404, "%s", "Error: File not found");
}
}
@@ -6751,7 +9085,7 @@ put_dir(struct mg_connection *conn, const char *path)
{
char buf[PATH_MAX];
const char *s, *p;
- struct file file = STRUCT_FILE_INITIALIZER;
+ struct mg_file file = STRUCT_FILE_INITIALIZER;
size_t len;
int res = 1;
@@ -6767,7 +9101,7 @@ put_dir(struct mg_connection *conn, const char *path)
/* Try to create intermediate directory */
DEBUG_TRACE("mkdir(%s)", buf);
- if (!mg_stat(conn, buf, &file) && mg_mkdir(conn, buf, 0755) != 0) {
+ if (!mg_stat(conn, buf, &file.stat) && mg_mkdir(conn, buf, 0755) != 0) {
/* path does not exixt and can not be created */
res = -2;
break;
@@ -6799,7 +9133,7 @@ mg_store_body(struct mg_connection *conn, const char *path)
char buf[MG_BUF_LEN];
long long len = 0;
int ret, n;
- struct file fi;
+ struct mg_file fi;
if (conn->consumed_content != 0) {
mg_cry(conn, "%s: Contents already consumed", __func__);
@@ -6817,24 +9151,27 @@ mg_store_body(struct mg_connection *conn, const char *path)
return 0;
}
- if (mg_fopen(conn, path, "w", &fi) == 0) {
+ if (mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &fi) == 0) {
return -12;
}
ret = mg_read(conn, buf, sizeof(buf));
while (ret > 0) {
- n = (int)fwrite(buf, 1, (size_t)ret, fi.fp);
+ n = (int)fwrite(buf, 1, (size_t)ret, fi.access.fp);
if (n != ret) {
- mg_fclose(&fi);
+ (void)mg_fclose(
+ &fi.access); /* File is bad and will be removed anyway. */
remove_bad_file(conn, path);
return -13;
}
+ len += ret;
ret = mg_read(conn, buf, sizeof(buf));
}
- /* TODO: mg_fclose should return an error,
- * and every caller should check and handle it. */
- if (fclose(fi.fp) != 0) {
+ /* File is open for writing. If fclose fails, there was probably an
+ * error flushing the buffer to disk, so the file on disk might be
+ * broken. Delete it and return an error to the caller. */
+ if (mg_fclose(&fi.access) != 0) {
remove_bad_file(conn, path);
return -14;
}
@@ -6843,51 +9180,91 @@ mg_store_body(struct mg_connection *conn, const char *path)
}
-/* Parse HTTP headers from the given buffer, advance buffer to the point
- * where parsing stopped. */
-static void
-parse_http_headers(char **buf, struct mg_request_info *ri)
+/* Parse a buffer:
+ * Forward the string pointer till the end of a word, then
+ * terminate it and forward till the begin of the next word.
+ */
+static int
+skip_to_end_of_word_and_terminate(char **ppw, int eol)
{
- int i;
-
- if (!ri) {
- return;
+ /* Forward until a space is found - use isgraph here */
+ /* See http://www.cplusplus.com/reference/cctype/ */
+ while (isgraph(**ppw)) {
+ (*ppw)++;
}
- ri->num_headers = 0;
+ /* Check end of word */
+ if (eol) {
+ /* must be a end of line */
+ if ((**ppw != '\r') && (**ppw != '\n')) {
+ return -1;
+ }
+ } else {
+ /* must be a end of a word, but not a line */
+ if (**ppw != ' ') {
+ return -1;
+ }
+ }
- for (i = 0; i < (int)ARRAY_SIZE(ri->http_headers); i++) {
+ /* Terminate and forward to the next word */
+ do {
+ **ppw = 0;
+ (*ppw)++;
+ } while ((**ppw) && isspace(**ppw));
+
+ /* Check after term */
+ if (!eol) {
+ /* if it's not the end of line, there must be a next word */
+ if (!isgraph(**ppw)) {
+ return -1;
+ }
+ }
+
+ /* ok */
+ return 1;
+}
+
+
+/* Parse HTTP headers from the given buffer, advance buf pointer
+ * to the point where parsing stopped.
+ * All parameters must be valid pointers (not NULL).
+ * Return <0 on error. */
+static int
+parse_http_headers(char **buf, struct mg_header hdr[MG_MAX_HEADERS])
+{
+ int i;
+ int num_headers = 0;
+
+ for (i = 0; i < (int)MG_MAX_HEADERS; i++) {
char *dp = *buf;
- while ((*dp != ':') && (*dp != '\r') && (*dp != 0)) {
+ while ((*dp != ':') && (*dp >= 33) && (*dp <= 126)) {
dp++;
}
- if (!*dp) {
- /* neither : nor \r\n. This is not a valid field. */
+ if (dp == *buf) {
+ /* End of headers reached. */
break;
}
- if (*dp == '\r') {
- if (dp[1] == '\n') {
- /* \r\n */
- ri->http_headers[i].name = *buf;
- ri->http_headers[i].value = 0;
- *buf = dp;
- } else {
- /* stray \r. This is not valid. */
- break;
- }
- } else {
- /* (*dp == ':') */
- *dp = 0;
- ri->http_headers[i].name = *buf;
- do {
- dp++;
- } while (*dp == ' ');
-
- ri->http_headers[i].value = dp;
- *buf = strstr(dp, "\r\n");
+ if (*dp != ':') {
+ /* This is not a valid field. */
+ return -1;
}
- ri->num_headers = i + 1;
+ /* End of header key (*dp == ':') */
+ /* Truncate here and set the key name */
+ *dp = 0;
+ hdr[i].name = *buf;
+ do {
+ dp++;
+ } while (*dp == ' ');
+
+ /* The rest of the line is the value */
+ hdr[i].value = dp;
+ *buf = dp + strcspn(dp, "\r\n");
+ if (((*buf)[0] != '\r') || ((*buf)[1] != '\n')) {
+ *buf = NULL;
+ }
+
+ num_headers = i + 1;
if (*buf) {
(*buf)[0] = 0;
(*buf)[1] = 0;
@@ -6897,92 +9274,309 @@ parse_http_headers(char **buf, struct mg_request_info *ri)
break;
}
- if (*buf[0] == '\r') {
+ if ((*buf)[0] == '\r') {
/* This is the end of the header */
break;
}
}
+ return num_headers;
+}
+
+
+struct mg_http_method_info {
+ const char *name;
+ int request_has_body;
+ int response_has_body;
+ int is_safe;
+ int is_idempotent;
+ int is_cacheable;
+};
+
+
+/* https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods */
+static struct mg_http_method_info http_methods[] = {
+ /* HTTP (RFC 2616) */
+ {"GET", 0, 1, 1, 1, 1},
+ {"POST", 1, 1, 0, 0, 0},
+ {"PUT", 1, 0, 0, 1, 0},
+ {"DELETE", 0, 0, 0, 1, 0},
+ {"HEAD", 0, 0, 1, 1, 1},
+ {"OPTIONS", 0, 0, 1, 1, 0},
+ {"CONNECT", 1, 1, 0, 0, 0},
+ /* TRACE method (RFC 2616) is not supported for security reasons */
+
+ /* PATCH method (RFC 5789) */
+ {"PATCH", 1, 0, 0, 0, 0},
+ /* PATCH method only allowed for CGI/Lua/LSP and callbacks. */
+
+ /* WEBDAV (RFC 2518) */
+ {"PROPFIND", 0, 1, 1, 1, 0},
+ /* http://www.webdav.org/specs/rfc4918.html, 9.1:
+ * Some PROPFIND results MAY be cached, with care,
+ * as there is no cache validation mechanism for
+ * most properties. This method is both safe and
+ * idempotent (see Section 9.1 of [RFC2616]). */
+ {"MKCOL", 0, 0, 0, 1, 0},
+ /* http://www.webdav.org/specs/rfc4918.html, 9.1:
+ * When MKCOL is invoked without a request body,
+ * the newly created collection SHOULD have no
+ * members. A MKCOL request message may contain
+ * a message body. The precise behavior of a MKCOL
+ * request when the body is present is undefined,
+ * ... ==> We do not support MKCOL with body data.
+ * This method is idempotent, but not safe (see
+ * Section 9.1 of [RFC2616]). Responses to this
+ * method MUST NOT be cached. */
+
+ /* Unsupported WEBDAV Methods: */
+ /* PROPPATCH, COPY, MOVE, LOCK, UNLOCK (RFC 2518) */
+ /* + 11 methods from RFC 3253 */
+ /* ORDERPATCH (RFC 3648) */
+ /* ACL (RFC 3744) */
+ /* SEARCH (RFC 5323) */
+ /* + MicroSoft extensions
+ * https://msdn.microsoft.com/en-us/library/aa142917.aspx */
+
+ /* REPORT method (RFC 3253) */
+ {"REPORT", 1, 1, 1, 1, 1},
+ /* REPORT method only allowed for CGI/Lua/LSP and callbacks. */
+ /* It was defined for WEBDAV in RFC 3253, Sec. 3.6
+ * (https://tools.ietf.org/html/rfc3253#section-3.6), but seems
+ * to be useful for REST in case a "GET request with body" is
+ * required. */
+
+ {NULL, 0, 0, 0, 0, 0}
+ /* end of list */
+};
+
+
+static const struct mg_http_method_info *
+get_http_method_info(const char *method)
+{
+ /* Check if the method is known to the server. The list of all known
+ * HTTP methods can be found here at
+ * http://www.iana.org/assignments/http-methods/http-methods.xhtml
+ */
+ const struct mg_http_method_info *m = http_methods;
+
+ while (m->name) {
+ if (!strcmp(m->name, method)) {
+ return m;
+ }
+ m++;
+ }
+ return m;
}
static int
is_valid_http_method(const char *method)
{
- return !strcmp(method, "GET") /* HTTP (RFC 2616) */
- || !strcmp(method, "POST") /* HTTP (RFC 2616) */
- || !strcmp(method, "HEAD") /* HTTP (RFC 2616) */
- || !strcmp(method, "PUT") /* HTTP (RFC 2616) */
- || !strcmp(method, "DELETE") /* HTTP (RFC 2616) */
- || !strcmp(method, "OPTIONS") /* HTTP (RFC 2616) */
- /* TRACE method (RFC 2616) is not supported for security reasons */
- || !strcmp(method, "CONNECT") /* HTTP (RFC 2616) */
-
- || !strcmp(method, "PROPFIND") /* WEBDAV (RFC 2518) */
- || !strcmp(method, "MKCOL") /* WEBDAV (RFC 2518) */
-
- /* Unsupported WEBDAV Methods: */
- /* PROPPATCH, COPY, MOVE, LOCK, UNLOCK (RFC 2518) */
- /* + 11 methods from RFC 3253 */
- /* ORDERPATCH (RFC 3648) */
- /* ACL (RFC 3744) */
- /* SEARCH (RFC 5323) */
- /* + MicroSoft extensions
- * https://msdn.microsoft.com/en-us/library/aa142917.aspx */
-
- /* PATCH method only allowed for CGI/Lua/LSP and callbacks. */
- || !strcmp(method, "PATCH"); /* PATCH method (RFC 5789) */
+ return (get_http_method_info(method) != NULL);
}
/* Parse HTTP request, fill in mg_request_info structure.
* This function modifies the buffer by NUL-terminating
- * HTTP request components, header names and header values. */
+ * HTTP request components, header names and header values.
+ * Parameters:
+ * buf (in/out): pointer to the HTTP header to parse and split
+ * len (in): length of HTTP header buffer
+ * re (out): parsed header as mg_request_info
+ * buf and ri must be valid pointers (not NULL), len>0.
+ * Returns <0 on error. */
static int
-parse_http_message(int check_method,
- char *buf,
- int len,
- struct mg_request_info *ri)
+parse_http_request(int check_method, char *buf, int len, struct mg_request_info *ri)
{
- int is_request, request_length;
+ int request_length;
+ int init_skip = 0;
- if (!ri) {
+ /* Reset attributes. DO NOT TOUCH is_ssl, remote_ip, remote_addr,
+ * remote_port */
+ ri->remote_user = ri->request_method = ri->request_uri = ri->http_version =
+ NULL;
+ ri->num_headers = 0;
+
+ /* RFC says that all initial whitespaces should be ingored */
+ /* This included all leading \r and \n (isspace) */
+ /* See table: http://www.cplusplus.com/reference/cctype/ */
+ while ((len > 0) && isspace(*(unsigned char *)buf)) {
+ buf++;
+ len--;
+ init_skip++;
+ }
+
+ if (len == 0) {
+ /* Incomplete request */
return 0;
}
- request_length = get_request_len(buf, len);
-
- if (request_length > 0) {
- /* Reset attributes. DO NOT TOUCH is_ssl, remote_ip, remote_addr,
- * remote_port */
- ri->remote_user = ri->request_method = ri->request_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->request_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 =
- check_method ? is_valid_http_method(ri->request_method) : 1;
- 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);
- }
+ /* Control characters are not allowed, including zero */
+ if (iscntrl(*(unsigned char *)buf)) {
+ return -1;
}
- return request_length;
+
+ /* Find end of HTTP header */
+ request_length = get_http_header_len(buf, len);
+ if (request_length <= 0) {
+ return request_length;
+ }
+ buf[request_length - 1] = '\0';
+
+ if ((*buf == 0) || (*buf == '\r') || (*buf == '\n')) {
+ return -1;
+ }
+
+ /* The first word has to be the HTTP method */
+ ri->request_method = buf;
+
+ if (skip_to_end_of_word_and_terminate(&buf, 0) <= 0) {
+ return -1;
+ }
+
+ /* Check for a valid http method */
+ if (check_method && !is_valid_http_method(ri->request_method)) {
+ return -1;
+ }
+
+ /* The second word is the URI */
+ ri->request_uri = skip_quoted(&buf, " ", " ", 0);
+
+ /* Next would be the HTTP version */
+ ri->http_version = buf;
+
+ if (skip_to_end_of_word_and_terminate(&buf, 1) <= 0) {
+ return -1;
+ }
+
+ /* Check for a valid HTTP version key */
+ if (strncmp(ri->http_version, "HTTP/", 5) != 0) {
+ /* Invalid request */
+ return -1;
+ }
+ ri->http_version += 5;
+
+
+ /* Parse all HTTP headers */
+ ri->num_headers = parse_http_headers(&buf, ri->http_headers);
+ if (ri->num_headers < 0) {
+ /* Error while parsing headers */
+ return -1;
+ }
+
+ return request_length + init_skip;
+}
+
+
+static int
+parse_http_response(char *buf, int len, struct mg_response_info *ri)
+{
+ int response_length;
+ int init_skip = 0;
+ char *tmp, *tmp2;
+ long l;
+
+ /* Initialize elements. */
+ ri->http_version = ri->status_text = NULL;
+ ri->num_headers = ri->status_code = 0;
+
+ /* RFC says that all initial whitespaces should be ingored */
+ /* This included all leading \r and \n (isspace) */
+ /* See table: http://www.cplusplus.com/reference/cctype/ */
+ while ((len > 0) && isspace(*(unsigned char *)buf)) {
+ buf++;
+ len--;
+ init_skip++;
+ }
+
+ if (len == 0) {
+ /* Incomplete request */
+ return 0;
+ }
+
+ /* Control characters are not allowed, including zero */
+ if (iscntrl(*(unsigned char *)buf)) {
+ return -1;
+ }
+
+ /* Find end of HTTP header */
+ response_length = get_http_header_len(buf, len);
+ if (response_length <= 0) {
+ return response_length;
+ }
+ buf[response_length - 1] = '\0';
+
+
+ /* TODO: Define mg_response_info and implement parsing */
+ (void)buf;
+ (void)len;
+ (void)ri;
+
+ /* RFC says that all initial whitespaces should be ingored */
+ while ((*buf != '\0') && isspace(*(unsigned char *)buf)) {
+ buf++;
+ }
+ if ((*buf == 0) || (*buf == '\r') || (*buf == '\n')) {
+ return -1;
+ }
+
+ /* The first word is the HTTP version */
+ /* Check for a valid HTTP version key */
+ if (strncmp(buf, "HTTP/", 5) != 0) {
+ /* Invalid request */
+ return -1;
+ }
+ buf += 5;
+ if (!isgraph(buf[0])) {
+ /* Invalid request */
+ return -1;
+ }
+ ri->http_version = buf;
+
+ if (skip_to_end_of_word_and_terminate(&buf, 0) <= 0) {
+ return -1;
+ }
+
+ /* The second word is the status as a number */
+ tmp = buf;
+
+ if (skip_to_end_of_word_and_terminate(&buf, 0) <= 0) {
+ return -1;
+ }
+
+ l = strtol(tmp, &tmp2, 10);
+ if ((l < 100) || (l >= 1000) || ((tmp2 - tmp) != 3) || (*tmp2 != 0)) {
+ /* Everything else but a 3 digit code is invalid */
+ return -1;
+ }
+ ri->status_code = (int)l;
+
+ /* The rest of the line is the status text */
+ ri->status_text = buf;
+
+ /* Find end of status text */
+ /* isgraph or isspace = isprint */
+ while (isprint(*buf)) {
+ buf++;
+ }
+ if ((*buf != '\r') && (*buf != '\n')) {
+ return -1;
+ }
+ /* Terminate string and forward buf to next line */
+ do {
+ *buf = 0;
+ buf++;
+ } while ((*buf) && isspace(*buf));
+
+
+ /* Parse all HTTP headers */
+ ri->num_headers = parse_http_headers(&buf, ri->http_headers);
+ if (ri->num_headers < 0) {
+ /* Error while parsing headers */
+ return -1;
+ }
+
+ return response_length + init_skip;
}
@@ -6992,7 +9586,7 @@ parse_http_message(int check_method,
* 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,
+read_message(FILE *fp,
struct mg_connection *conn,
char *buf,
int bufsiz,
@@ -7014,103 +9608,71 @@ read_request(FILE *fp,
} else {
request_timeout = -1.0;
}
+ if (conn->handled_requests > 0) {
+ if (conn->ctx->config[KEEP_ALIVE_TIMEOUT]) {
+ request_timeout =
+ atof(conn->ctx->config[KEEP_ALIVE_TIMEOUT]) / 1000.0;
+ }
+ }
- request_len = get_request_len(buf, *nread);
+ request_len = get_http_header_len(buf, *nread);
/* first time reading from this connection */
clock_gettime(CLOCK_MONOTONIC, &last_action_time);
- while (
- (conn->ctx->stop_flag == 0) && (*nread < bufsiz) && (request_len == 0)
- && ((mg_difftimespec(&last_action_time, &(conn->req_time))
- <= request_timeout) || (request_timeout < 0))
- && ((n = pull(fp, conn, buf + *nread, bufsiz - *nread, request_timeout))
- > 0)) {
- *nread += n;
- /* assert(*nread <= bufsiz); */
- if (*nread > bufsiz) {
+ while (request_len == 0) {
+ /* Full request not yet received */
+ if (conn->ctx->stop_flag != 0) {
+ /* Server is to be stopped. */
+ return -1;
+ }
+
+ if (*nread >= bufsiz) {
+ /* Request too long */
return -2;
}
- request_len = get_request_len(buf, *nread);
- if (request_timeout > 0.0) {
+
+ n = pull_inner(
+ fp, conn, buf + *nread, bufsiz - *nread, request_timeout);
+ if (n == -2) {
+ /* Receive error */
+ return -1;
+ }
+ if (n > 0) {
+ *nread += n;
+ request_len = get_http_header_len(buf, *nread);
+ } else {
+ request_len = 0;
+ }
+
+ if ((request_len == 0) && (request_timeout >= 0)) {
+ if (mg_difftimespec(&last_action_time, &(conn->req_time))
+ > request_timeout) {
+ /* Timeout */
+ return -1;
+ }
clock_gettime(CLOCK_MONOTONIC, &last_action_time);
}
}
- return (request_len <= 0 && n <= 0) ? -1 : request_len;
+ return request_len;
}
-#if !defined(NO_FILES)
-/* For given directory path, substitute it to valid index file.
- * Return 1 if index file has been found, 0 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 file *filep)
-{
- if (conn && conn->ctx) {
- const char *list = conn->ctx->config[INDEX_FILES];
- struct file file = STRUCT_FILE_INITIALIZER;
- struct vec filename_vec;
- size_t n = strlen(path);
- int found = 0;
-
- /* 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 && path[n - 1] == '/') {
- n--;
- }
- 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 */
- while ((list = next_option(list, &filename_vec, NULL)) != NULL) {
- /* Ignore too long entries that may overflow path buffer */
- if (filename_vec.len > path_len - (n + 2)) {
- continue;
- }
-
- /* Prepare full path to the index file */
- mg_strlcpy(path + n + 1, filename_vec.ptr, filename_vec.len + 1);
-
- /* Does it exist? */
- if (mg_stat(conn, path, &file)) {
- /* Yes it does, break the loop */
- *filep = file;
- found = 1;
- break;
- }
- }
-
- /* If no index file exists, restore directory path */
- if (!found) {
- path[n] = '\0';
- }
-
- return found;
- }
- return 0;
-}
-#endif
-
#if !defined(NO_CACHING)
/* Return True if we should reply 304 Not Modified. */
static int
-is_not_modified(const struct mg_connection *conn, const struct file *filep)
+is_not_modified(const struct mg_connection *conn,
+ const struct mg_file_stat *filestat)
{
char etag[64];
const char *ims = mg_get_header(conn, "If-Modified-Since");
const char *inm = mg_get_header(conn, "If-None-Match");
- construct_etag(etag, sizeof(etag), filep);
- if (!filep) {
- return 0;
- }
- return (inm != NULL && !mg_strcasecmp(etag, inm))
- || (ims != NULL && (filep->last_modified <= parse_date_string(ims)));
+ construct_etag(etag, sizeof(etag), filestat);
+
+ return ((inm != NULL) && !mg_strcasecmp(etag, inm))
+ || ((ims != NULL)
+ && (filestat->last_modified <= parse_date_string(ims)));
}
#endif /* !NO_CACHING */
@@ -7135,23 +9697,24 @@ forward_body_data(struct mg_connection *conn, FILE *fp, SOCKET sock, SSL *ssl)
expect = mg_get_header(conn, "Expect");
/* assert(fp != NULL); */
if (!fp) {
- send_http_error(conn, 500, "%s", "Error: NULL File");
+ mg_send_http_error(conn, 500, "%s", "Error: NULL File");
return 0;
}
- if (conn->content_len == -1 && !conn->is_chunked) {
+ if ((conn->content_len == -1) && (!conn->is_chunked)) {
/* Content length is not specified by the client. */
- send_http_error(conn,
- 411,
- "%s",
- "Error: Client did not specify content length");
+ mg_send_http_error(conn,
+ 411,
+ "%s",
+ "Error: Client did not specify content length");
} else if ((expect != NULL)
&& (mg_strcasecmp(expect, "100-continue") != 0)) {
- /* Client sent an "Expect: xyz" header and xyz is not 100-continue. */
- send_http_error(conn,
- 417,
- "Error: Can not fulfill expectation %s",
- expect);
+ /* Client sent an "Expect: xyz" header and xyz is not 100-continue.
+ */
+ mg_send_http_error(conn,
+ 417,
+ "Error: Can not fulfill expectation %s",
+ expect);
} else {
if (expect != NULL) {
(void)mg_printf(conn, "%s", "HTTP/1.1 100 Continue\r\n\r\n");
@@ -7167,7 +9730,7 @@ forward_body_data(struct mg_connection *conn, FILE *fp, SOCKET sock, SSL *ssl)
/* assert(conn->consumed_content == 0); */
if ((buffered_len < 0) || (conn->consumed_content != 0)) {
- send_http_error(conn, 500, "%s", "Error: Size mismatch");
+ mg_send_http_error(conn, 500, "%s", "Error: Size mismatch");
return 0;
}
@@ -7186,11 +9749,16 @@ forward_body_data(struct mg_connection *conn, FILE *fp, SOCKET sock, SSL *ssl)
if ((int64_t)to_read > conn->content_len - conn->consumed_content) {
to_read = (int)(conn->content_len - conn->consumed_content);
}
- nread = pull(NULL, conn, buf, to_read, timeout);
- if (nread <= 0
- || push_all(conn->ctx, fp, sock, ssl, buf, nread) != nread) {
+ nread = pull_inner(NULL, conn, buf, to_read, timeout);
+ if (nread == -2) {
+ /* error */
break;
}
+ if (nread > 0) {
+ if (push_all(conn->ctx, fp, sock, ssl, buf, nread) != nread) {
+ break;
+ }
+ }
conn->consumed_content += nread;
}
@@ -7203,7 +9771,7 @@ forward_body_data(struct mg_connection *conn, FILE *fp, SOCKET sock, SSL *ssl)
/* NOTE: Maybe some data has already been sent. */
/* TODO (low): If some data has been sent, a correct error
* reply can no longer be sent, so just close the connection */
- send_http_error(conn, 500, "%s", "");
+ mg_send_http_error(conn, 500, "%s", "");
}
}
@@ -7212,10 +9780,12 @@ forward_body_data(struct mg_connection *conn, FILE *fp, SOCKET sock, SSL *ssl)
#endif
#if !defined(NO_CGI)
-/* This structure helps to create an environment for the spawned CGI program.
+/* This structure helps to create an environment for the spawned CGI
+ * program.
* Environment is an array of "VARIABLE=VALUE\0" ASCIIZ strings,
* last element must be NULL.
- * However, on Windows there is a requirement that all these VARIABLE=VALUE\0
+ * However, on Windows there is a requirement that all these
+ * VARIABLE=VALUE\0
* strings must reside in a contiguous buffer. The end of the buffer is
* marked by two '\0' characters.
* We satisfy both worlds: we create an envp array (which is vars), all
@@ -7243,7 +9813,7 @@ static void
addenv(struct cgi_environment *env, const char *fmt, ...)
{
size_t n, space;
- int truncated;
+ int truncated = 0;
char *added;
va_list ap;
@@ -7257,7 +9827,7 @@ addenv(struct cgi_environment *env, const char *fmt, ...)
if (space <= n) {
/* Allocate new buffer */
n = env->buflen + CGI_ENVIRONMENT_SIZE;
- added = (char *)mg_realloc(env->buf, n);
+ added = (char *)mg_realloc_ctx(env->buf, n, env->conn->ctx);
if (!added) {
/* Out of memory */
mg_cry(env->conn,
@@ -7306,8 +9876,9 @@ addenv(struct cgi_environment *env, const char *fmt, ...)
env->varused++;
}
+/* Return 0 on success, non-zero if an error occurs. */
-static void
+static int
prepare_cgi_environment(struct mg_connection *conn,
const char *prog,
struct cgi_environment *env)
@@ -7315,19 +9886,32 @@ prepare_cgi_environment(struct mg_connection *conn,
const char *s;
struct vec var_vec;
char *p, src_addr[IP_ADDR_STR_LEN], http_var_name[128];
- int i, truncated;
+ int i, truncated, uri_len;
- if (conn == NULL || prog == NULL || env == NULL) {
- return;
+ if ((conn == NULL) || (prog == NULL) || (env == NULL)) {
+ return -1;
}
env->conn = conn;
env->buflen = CGI_ENVIRONMENT_SIZE;
env->bufused = 0;
- env->buf = (char *)mg_malloc(env->buflen);
+ env->buf = (char *)mg_malloc_ctx(env->buflen, conn->ctx);
+ if (env->buf == NULL) {
+ mg_cry(conn,
+ "%s: Not enough memory for environmental buffer",
+ __func__);
+ return -1;
+ }
env->varlen = MAX_CGI_ENVIR_VARS;
env->varused = 0;
- env->var = (char **)mg_malloc(env->buflen * sizeof(char *));
+ env->var = (char **)mg_malloc_ctx(env->buflen * sizeof(char *), conn->ctx);
+ if (env->var == NULL) {
+ mg_cry(conn,
+ "%s: Not enough memory for environmental variables",
+ __func__);
+ mg_free(env->buf);
+ return -1;
+ }
addenv(env, "SERVER_NAME=%s", conn->ctx->config[AUTHENTICATION_DOMAIN]);
addenv(env, "SERVER_ROOT=%s", conn->ctx->config[DOCUMENT_ROOT]);
@@ -7358,11 +9942,28 @@ prepare_cgi_environment(struct mg_connection *conn,
addenv(env, "LOCAL_URI=%s", conn->request_info.local_uri);
/* SCRIPT_NAME */
- addenv(env,
- "SCRIPT_NAME=%.*s",
- (int)strlen(conn->request_info.local_uri)
- - ((conn->path_info == NULL) ? 0 : (int)strlen(conn->path_info)),
- conn->request_info.local_uri);
+ uri_len = (int)strlen(conn->request_info.local_uri);
+ if (conn->path_info == NULL) {
+ if (conn->request_info.local_uri[uri_len - 1] != '/') {
+ /* URI: /path_to_script/script.cgi */
+ addenv(env, "SCRIPT_NAME=%s", conn->request_info.local_uri);
+ } else {
+ /* URI: /path_to_script/ ... using index.cgi */
+ const char *index_file = strrchr(prog, '/');
+ if (index_file) {
+ addenv(env,
+ "SCRIPT_NAME=%s%s",
+ conn->request_info.local_uri,
+ index_file + 1);
+ }
+ }
+ } else {
+ /* URI: /path_to_script/script.cgi/path_info */
+ addenv(env,
+ "SCRIPT_NAME=%.*s",
+ uri_len - (int)strlen(conn->path_info),
+ conn->request_info.local_uri);
+ }
addenv(env, "SCRIPT_FILENAME=%s", prog);
if (conn->path_info == NULL) {
@@ -7374,7 +9975,7 @@ prepare_cgi_environment(struct mg_connection *conn,
conn->path_info);
}
- addenv(env, "HTTPS=%s", conn->ssl == NULL ? "off" : "on");
+ addenv(env, "HTTPS=%s", (conn->ssl == NULL) ? "off" : "on");
if ((s = mg_get_header(conn, "Content-Type")) != NULL) {
addenv(env, "CONTENT_TYPE=%s", s);
@@ -7468,6 +10069,8 @@ prepare_cgi_environment(struct mg_connection *conn,
env->var[env->varused] = NULL;
env->buf[env->bufused] = '\0';
+
+ return 0;
}
@@ -7483,7 +10086,7 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
struct mg_request_info ri;
struct cgi_environment blk;
FILE *in = NULL, *out = NULL, *err = NULL;
- struct file fout = STRUCT_FILE_INITIALIZER;
+ struct mg_file fout = STRUCT_FILE_INITIALIZER;
pid_t pid = (pid_t)-1;
if (conn == NULL) {
@@ -7492,7 +10095,12 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
buf = NULL;
buflen = 16384;
- prepare_cgi_environment(conn, prog, &blk);
+ i = prepare_cgi_environment(conn, prog, &blk);
+ if (i != 0) {
+ blk.buf = NULL;
+ blk.var = NULL;
+ goto done;
+ }
/* CGI must be executed in its own directory. 'dir' must point to the
* directory containing executable program, 'p' must point to the
@@ -7501,27 +10109,32 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
if (truncated) {
mg_cry(conn, "Error: CGI program \"%s\": Path too long", prog);
- send_http_error(conn, 500, "Error: %s", "CGI path too long");
+ mg_send_http_error(conn, 500, "Error: %s", "CGI path too long");
goto done;
}
if ((p = strrchr(dir, '/')) != NULL) {
*p++ = '\0';
} else {
- dir[0] = '.', dir[1] = '\0';
+ dir[0] = '.';
+ dir[1] = '\0';
p = (char *)prog;
}
- if (pipe(fdin) != 0 || pipe(fdout) != 0 || pipe(fderr) != 0) {
+ if ((pipe(fdin) != 0) || (pipe(fdout) != 0) || (pipe(fderr) != 0)) {
status = strerror(ERRNO);
mg_cry(conn,
"Error: CGI program \"%s\": Can not create CGI pipes: %s",
prog,
status);
- send_http_error(conn, 500, "Error: Cannot create CGI pipe: %s", status);
+ mg_send_http_error(conn,
+ 500,
+ "Error: Cannot create CGI pipe: %s",
+ status);
goto done;
}
+ DEBUG_TRACE("CGI: spawn %s %s\n", dir, p);
pid = spawn_process(conn, p, blk.buf, blk.var, fdin, fdout, fderr, dir);
if (pid == (pid_t)-1) {
@@ -7530,15 +10143,16 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
"Error: CGI program \"%s\": Can not spawn CGI process: %s",
prog,
status);
- send_http_error(conn,
- 500,
- "Error: Cannot spawn CGI process [%s]: %s",
- prog,
- status);
+ mg_send_http_error(conn,
+ 500,
+ "Error: Cannot spawn CGI process [%s]: %s",
+ prog,
+ status);
goto done;
}
- /* Make sure child closes all pipe descriptors. It must dup them to 0,1 */
+ /* Make sure child closes all pipe descriptors. It must dup them to 0,1
+ */
set_close_on_exec((SOCKET)fdin[0], conn); /* stdin read */
set_close_on_exec((SOCKET)fdout[1], conn); /* stdout write */
set_close_on_exec((SOCKET)fderr[1], conn); /* stderr write */
@@ -7561,10 +10175,10 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
"Error: CGI program \"%s\": Can not open stdin: %s",
prog,
status);
- send_http_error(conn,
- 500,
- "Error: CGI can not open fdin\nfopen: %s",
- status);
+ mg_send_http_error(conn,
+ 500,
+ "Error: CGI can not open fdin\nfopen: %s",
+ status);
goto done;
}
@@ -7574,10 +10188,10 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
"Error: CGI program \"%s\": Can not open stdout: %s",
prog,
status);
- send_http_error(conn,
- 500,
- "Error: CGI can not open fdout\nfopen: %s",
- status);
+ mg_send_http_error(conn,
+ 500,
+ "Error: CGI can not open fdout\nfopen: %s",
+ status);
goto done;
}
@@ -7587,19 +10201,22 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
"Error: CGI program \"%s\": Can not open stderr: %s",
prog,
status);
- send_http_error(conn,
- 500,
- "Error: CGI can not open fdout\nfopen: %s",
- status);
+ mg_send_http_error(conn,
+ 500,
+ "Error: CGI can not open fdout\nfopen: %s",
+ status);
goto done;
}
setbuf(in, NULL);
setbuf(out, NULL);
setbuf(err, NULL);
- fout.fp = out;
+ fout.access.fp = out;
+
+ if ((conn->request_info.content_length != 0) || (conn->is_chunked)) {
+ DEBUG_TRACE("CGI: send body data (%lli)\n",
+ (signed long long)conn->request_info.content_length);
- if ((conn->request_info.content_length > 0) || conn->is_chunked) {
/* This is a POST/PUT request, or another request with body data. */
if (!forward_body_data(conn, in, INVALID_SOCKET, NULL)) {
/* Error sending the body data */
@@ -7620,12 +10237,12 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
* Do not send anything back to client, until we buffer in all
* HTTP headers. */
data_len = 0;
- buf = (char *)mg_malloc(buflen);
+ buf = (char *)mg_malloc_ctx(buflen, conn->ctx);
if (buf == NULL) {
- send_http_error(conn,
- 500,
- "Error: Not enough memory for CGI buffer (%u bytes)",
- (unsigned int)buflen);
+ mg_send_http_error(conn,
+ 500,
+ "Error: Not enough memory for CGI buffer (%u bytes)",
+ (unsigned int)buflen);
mg_cry(conn,
"Error: CGI program \"%s\": Not enough memory for buffer (%u "
"bytes)",
@@ -7633,7 +10250,11 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
(unsigned int)buflen);
goto done;
}
- headers_len = read_request(out, conn, buf, (int)buflen, &data_len);
+
+ DEBUG_TRACE("CGI: %s", "wait for response");
+ headers_len = read_message(out, conn, buf, (int)buflen, &data_len);
+ DEBUG_TRACE("CGI: response: %li", (signed long)headers_len);
+
if (headers_len <= 0) {
/* Could not parse the CGI response. Check if some error message on
@@ -7646,13 +10267,13 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
prog,
i,
buf);
- send_http_error(conn,
- 500,
- "Error: CGI program \"%s\" sent error "
- "message: [%.*s]",
- prog,
- i,
- buf);
+ mg_send_http_error(conn,
+ 500,
+ "Error: CGI program \"%s\" sent error "
+ "message: [%.*s]",
+ prog,
+ i,
+ buf);
} else {
mg_cry(conn,
"Error: CGI program sent malformed or too big "
@@ -7661,39 +10282,46 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
data_len,
buf);
- send_http_error(conn,
- 500,
- "Error: CGI program sent malformed or too big "
- "(>%u bytes) HTTP headers: [%.*s]",
- (unsigned)buflen,
- data_len,
- buf);
+ mg_send_http_error(conn,
+ 500,
+ "Error: CGI program sent malformed or too big "
+ "(>%u bytes) HTTP headers: [%.*s]",
+ (unsigned)buflen,
+ data_len,
+ buf);
}
goto done;
}
+
pbuf = buf;
buf[headers_len - 1] = '\0';
- parse_http_headers(&pbuf, &ri);
+ ri.num_headers = parse_http_headers(&pbuf, ri.http_headers);
/* Make up and send the status line */
status_text = "OK";
- if ((status = get_header(&ri, "Status")) != NULL) {
+ if ((status = get_header(ri.http_headers, ri.num_headers, "Status"))
+ != NULL) {
conn->status_code = atoi(status);
status_text = status;
while (isdigit(*(const unsigned char *)status_text)
|| *status_text == ' ') {
status_text++;
}
- } else if (get_header(&ri, "Location") != NULL) {
+ } else if (get_header(ri.http_headers, ri.num_headers, "Location")
+ != NULL) {
conn->status_code = 302;
} else {
conn->status_code = 200;
}
- connection_state = get_header(&ri, "Connection");
+ connection_state =
+ get_header(ri.http_headers, ri.num_headers, "Connection");
if (!header_has_option(connection_state, "keep-alive")) {
conn->must_close = 1;
}
+
+ DEBUG_TRACE("CGI: response %u %s", conn->status_code, status_text);
+
(void)mg_printf(conn, "HTTP/1.1 %d %s\r\n", conn->status_code, status_text);
/* Send headers */
@@ -7706,12 +10334,13 @@ handle_cgi_request(struct mg_connection *conn, const char *prog)
mg_write(conn, "\r\n", 2);
/* 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));
+ 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, &fout, 0, INT64_MAX);
+ DEBUG_TRACE("CGI: %s", "all data sent");
+
done:
mg_free(blk.var);
mg_free(blk.buf);
@@ -7771,7 +10400,8 @@ mkcol(struct mg_connection *conn, const char *path)
return;
}
- /* TODO (mid): Check the send_http_error situations in this function */
+ /* TODO (mid): Check the mg_send_http_error situations in this function
+ */
memset(&de.file, 0, sizeof(de.file));
if (!mg_stat(conn, path, &de.file)) {
@@ -7783,15 +10413,17 @@ mkcol(struct mg_connection *conn, const char *path)
}
if (de.file.last_modified) {
- /* TODO (high): This check does not seem to make any sense ! */
- send_http_error(
+ /* TODO (mid): This check does not seem to make any sense ! */
+ /* TODO (mid): Add a webdav unit test first, before changing
+ * anything here. */
+ mg_send_http_error(
conn, 405, "Error: mkcol(%s): %s", path, strerror(ERRNO));
return;
}
body_len = conn->data_len - conn->request_len;
if (body_len > 0) {
- send_http_error(
+ mg_send_http_error(
conn, 415, "Error: mkcol(%s): %s", path, strerror(ERRNO));
return;
}
@@ -7807,22 +10439,24 @@ mkcol(struct mg_connection *conn, const char *path)
conn->status_code,
date);
send_static_cache_header(conn);
+ send_additional_header(conn);
mg_printf(conn,
"Content-Length: 0\r\n"
"Connection: %s\r\n\r\n",
suggest_connection_header(conn));
} else if (rc == -1) {
if (errno == EEXIST) {
- send_http_error(
+ mg_send_http_error(
conn, 405, "Error: mkcol(%s): %s", path, strerror(ERRNO));
} else if (errno == EACCES) {
- send_http_error(
+ mg_send_http_error(
conn, 403, "Error: mkcol(%s): %s", path, strerror(ERRNO));
} else if (errno == ENOENT) {
- send_http_error(
+ mg_send_http_error(
conn, 409, "Error: mkcol(%s): %s", path, strerror(ERRNO));
} else {
- send_http_error(conn, 500, "fopen(%s): %s", path, strerror(ERRNO));
+ mg_send_http_error(
+ conn, 500, "fopen(%s): %s", path, strerror(ERRNO));
}
}
}
@@ -7831,7 +10465,7 @@ mkcol(struct mg_connection *conn, const char *path)
static void
put_file(struct mg_connection *conn, const char *path)
{
- struct file file = STRUCT_FILE_INITIALIZER;
+ struct mg_file file = STRUCT_FILE_INITIALIZER;
const char *range;
int64_t r1, r2;
int rc;
@@ -7842,11 +10476,11 @@ put_file(struct mg_connection *conn, const char *path)
return;
}
- if (mg_stat(conn, path, &file)) {
+ if (mg_stat(conn, path, &file.stat)) {
/* File already exists */
conn->status_code = 200;
- if (file.is_directory) {
+ if (file.stat.is_directory) {
/* This is an already existing directory,
* so there is nothing to do for the server. */
rc = 0;
@@ -7855,13 +10489,13 @@ put_file(struct mg_connection *conn, const char *path)
/* File exists and is not a directory. */
/* Can it be replaced? */
- if (file.membuf != NULL) {
+ if (file.access.membuf != NULL) {
/* This is an "in-memory" file, that can not be replaced */
- send_http_error(
- conn,
- 405,
- "Error: Put not possible\nReplacing %s is not supported",
- path);
+ mg_send_http_error(conn,
+ 405,
+ "Error: Put not possible\nReplacing %s "
+ "is not supported",
+ path);
return;
}
@@ -7871,7 +10505,7 @@ put_file(struct mg_connection *conn, const char *path)
conn->status_code = 200;
rc = 1;
} else {
- send_http_error(
+ mg_send_http_error(
conn,
403,
"Error: Put not possible\nReplacing %s is not allowed",
@@ -7893,6 +10527,7 @@ put_file(struct mg_connection *conn, const char *path)
conn->status_code,
mg_get_response_code_text(NULL, conn->status_code));
send_no_cache_header(conn);
+ send_additional_header(conn);
mg_printf(conn,
"Date: %s\r\n"
"Content-Length: 0\r\n"
@@ -7907,65 +10542,72 @@ put_file(struct mg_connection *conn, const char *path)
if (rc == -1) {
/* put_dir returns -1 if the path is too long */
- send_http_error(conn,
- 414,
- "Error: Path too long\nput_dir(%s): %s",
- path,
- strerror(ERRNO));
+ mg_send_http_error(conn,
+ 414,
+ "Error: Path too long\nput_dir(%s): %s",
+ path,
+ strerror(ERRNO));
return;
}
if (rc == -2) {
/* put_dir returns -2 if the directory can not be created */
- send_http_error(conn,
- 500,
- "Error: Can not create directory\nput_dir(%s): %s",
- path,
- strerror(ERRNO));
+ mg_send_http_error(conn,
+ 500,
+ "Error: Can not create directory\nput_dir(%s): %s",
+ path,
+ strerror(ERRNO));
return;
}
/* A file should be created or overwritten. */
- if (!mg_fopen(conn, path, "wb+", &file) || file.fp == NULL) {
- mg_fclose(&file);
- send_http_error(conn,
- 500,
- "Error: Can not create file\nfopen(%s): %s",
- path,
- strerror(ERRNO));
+ /* Currently CivetWeb does not nead read+write access. */
+ if (!mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &file)
+ || file.access.fp == NULL) {
+ (void)mg_fclose(&file.access);
+ mg_send_http_error(conn,
+ 500,
+ "Error: Can not create file\nfopen(%s): %s",
+ path,
+ strerror(ERRNO));
return;
}
- fclose_on_exec(&file, conn);
+ fclose_on_exec(&file.access, conn);
range = mg_get_header(conn, "Content-Range");
r1 = r2 = 0;
- if (range != NULL && parse_range_header(range, &r1, &r2) > 0) {
+ if ((range != NULL) && parse_range_header(range, &r1, &r2) > 0) {
conn->status_code = 206; /* Partial content */
- fseeko(file.fp, r1, SEEK_SET);
+ fseeko(file.access.fp, r1, SEEK_SET);
}
- if (!forward_body_data(conn, file.fp, INVALID_SOCKET, NULL)) {
+ if (!forward_body_data(conn, file.access.fp, INVALID_SOCKET, NULL)) {
/* forward_body_data failed.
* The error code has already been sent to the client,
* and conn->status_code is already set. */
- mg_fclose(&file);
+ (void)mg_fclose(&file.access);
return;
}
+ if (mg_fclose(&file.access) != 0) {
+ /* fclose failed. This might have different reasons, but a likely
+ * one is "no space on disk", http 507. */
+ conn->status_code = 507;
+ }
+
gmt_time_string(date, sizeof(date), &curtime);
mg_printf(conn,
"HTTP/1.1 %d %s\r\n",
conn->status_code,
mg_get_response_code_text(NULL, conn->status_code));
send_no_cache_header(conn);
+ send_additional_header(conn);
mg_printf(conn,
"Date: %s\r\n"
"Content-Length: 0\r\n"
"Connection: %s\r\n\r\n",
date,
suggest_connection_header(conn));
-
- mg_fclose(&file);
}
@@ -7976,30 +10618,32 @@ delete_file(struct mg_connection *conn, const char *path)
memset(&de.file, 0, sizeof(de.file));
if (!mg_stat(conn, path, &de.file)) {
/* mg_stat returns 0 if the file does not exist */
- send_http_error(conn,
- 404,
- "Error: Cannot delete file\nFile %s not found",
- path);
+ mg_send_http_error(conn,
+ 404,
+ "Error: Cannot delete file\nFile %s not found",
+ path);
return;
}
- if (de.file.membuf != NULL) {
- /* the file is cached in memory */
- send_http_error(
- conn,
- 405,
- "Error: Delete not possible\nDeleting %s is not supported",
- path);
- return;
- }
+#if 0 /* Ignore if a file in memory is inside a folder */
+ if (de.access.membuf != NULL) {
+ /* the file is cached in memory */
+ mg_send_http_error(
+ conn,
+ 405,
+ "Error: Delete not possible\nDeleting %s is not supported",
+ path);
+ return;
+ }
+#endif
if (de.file.is_directory) {
if (remove_directory(conn, path)) {
/* Delete is successful: Return 204 without content. */
- send_http_error(conn, 204, "%s", "");
+ mg_send_http_error(conn, 204, "%s", "");
} else {
/* Delete is not successful: Return 500 (Server error). */
- send_http_error(conn, 500, "Error: Could not delete %s", path);
+ mg_send_http_error(conn, 500, "Error: Could not delete %s", path);
}
return;
}
@@ -8008,7 +10652,7 @@ delete_file(struct mg_connection *conn, const char *path)
* Check if write permission is granted. */
if (access(path, W_OK) != 0) {
/* File is read only */
- send_http_error(
+ mg_send_http_error(
conn,
403,
"Error: Delete not possible\nDeleting %s is not allowed",
@@ -8019,21 +10663,21 @@ delete_file(struct mg_connection *conn, const char *path)
/* Try to delete it. */
if (mg_remove(conn, path) == 0) {
/* Delete was successful: Return 204 without content. */
- send_http_error(conn, 204, "%s", "");
+ mg_send_http_error(conn, 204, "%s", "");
} else {
/* Delete not successful (file locked). */
- send_http_error(conn,
- 423,
- "Error: Cannot delete file\nremove(%s): %s",
- path,
- strerror(ERRNO));
+ mg_send_http_error(conn,
+ 423,
+ "Error: Cannot delete file\nremove(%s): %s",
+ path,
+ strerror(ERRNO));
}
}
#endif /* !NO_FILES */
static void
-send_ssi_file(struct mg_connection *, const char *, struct file *, int);
+send_ssi_file(struct mg_connection *, const char *, struct mg_file *, int);
static void
@@ -8043,7 +10687,7 @@ do_ssi_include(struct mg_connection *conn,
int include_level)
{
char file_name[MG_BUF_LEN], path[512], *p;
- struct file file = STRUCT_FILE_INITIALIZER;
+ struct mg_file file = STRUCT_FILE_INITIALIZER;
size_t len;
int truncated = 0;
@@ -8072,8 +10716,8 @@ do_ssi_include(struct mg_connection *conn,
(void)
mg_snprintf(conn, &truncated, path, sizeof(path), "%s", file_name);
- } else if (sscanf(tag, " file=\"%511[^\"]\"", file_name) == 1
- || sscanf(tag, " \"%511[^\"]\"", file_name) == 1) {
+ } else if ((sscanf(tag, " file=\"%511[^\"]\"", file_name) == 1)
+ || (sscanf(tag, " \"%511[^\"]\"", file_name) == 1)) {
/* File name is relative to the currect document */
file_name[511] = 0;
(void)mg_snprintf(conn, &truncated, path, sizeof(path), "%s", ssi);
@@ -8101,14 +10745,14 @@ do_ssi_include(struct mg_connection *conn,
return;
}
- if (!mg_fopen(conn, path, "rb", &file)) {
+ if (!mg_fopen(conn, path, MG_FOPEN_MODE_READ, &file)) {
mg_cry(conn,
"Cannot open SSI #include: [%s]: fopen(%s): %s",
tag,
path,
strerror(ERRNO));
} else {
- fclose_on_exec(&file, conn);
+ fclose_on_exec(&file.access, conn);
if (match_prefix(conn->ctx->config[SSI_EXTENSIONS],
strlen(conn->ctx->config[SSI_EXTENSIONS]),
path) > 0) {
@@ -8116,7 +10760,7 @@ do_ssi_include(struct mg_connection *conn,
} else {
send_file_data(conn, &file, 0, INT64_MAX);
}
- mg_fclose(&file);
+ (void)mg_fclose(&file.access); /* Ignore errors for readonly files */
}
}
@@ -8126,17 +10770,17 @@ static void
do_ssi_exec(struct mg_connection *conn, char *tag)
{
char cmd[1024] = "";
- struct file file = STRUCT_FILE_INITIALIZER;
+ struct mg_file file = STRUCT_FILE_INITIALIZER;
if (sscanf(tag, " \"%1023[^\"]\"", cmd) != 1) {
mg_cry(conn, "Bad SSI #exec: [%s]", tag);
} else {
cmd[1023] = 0;
- if ((file.fp = popen(cmd, "r")) == NULL) {
+ if ((file.access.fp = popen(cmd, "r")) == NULL) {
mg_cry(conn, "Cannot SSI #exec: [%s]: %s", cmd, strerror(ERRNO));
} else {
send_file_data(conn, &file, 0, INT64_MAX);
- pclose(file.fp);
+ pclose(file.access.fp);
}
}
}
@@ -8144,16 +10788,16 @@ do_ssi_exec(struct mg_connection *conn, char *tag)
static int
-mg_fgetc(struct file *filep, int offset)
+mg_fgetc(struct mg_file *filep, int offset)
{
if (filep == NULL) {
return EOF;
}
- if (filep->membuf != NULL && offset >= 0
- && ((unsigned int)(offset)) < filep->size) {
- return ((const unsigned char *)filep->membuf)[offset];
- } else if (filep->fp != NULL) {
- return fgetc(filep->fp);
+ if ((filep->access.membuf != NULL) && (offset >= 0)
+ && (((unsigned int)(offset)) < filep->stat.size)) {
+ return ((const unsigned char *)filep->access.membuf)[offset];
+ } else if (filep->access.fp != NULL) {
+ return fgetc(filep->access.fp);
} else {
return EOF;
}
@@ -8163,67 +10807,94 @@ mg_fgetc(struct file *filep, int offset)
static void
send_ssi_file(struct mg_connection *conn,
const char *path,
- struct file *filep,
+ struct mg_file *filep,
int include_level)
{
char buf[MG_BUF_LEN];
- int ch, offset, len, in_ssi_tag;
+ int ch, offset, len, in_tag, in_ssi_tag;
if (include_level > 10) {
mg_cry(conn, "SSI #include level is too deep (%s)", path);
return;
}
- 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;
- buf[len] = '\0';
- /* assert(len <= (int) sizeof(buf)); */
- if (len > (int)sizeof(buf)) {
- break;
- }
- if (len < 6 || memcmp(buf, " example 'duk' linked to shared libduktape
+#
+# $ ls -l duk
+# -rwxrwxr-x 1 duktape duktape 19407 Nov 30 15:48 duk
+#
+# $ ldd ./duk
+# linux-vdso.so.1 => (0x00007ffd5ed3c000)
+# libduktape.so.104 => /usr/local/lib/libduktape.so.104 (0x00007fb2f9753000)
+# libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007fb2f944d000)
+# libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fb2f9088000)
+# /lib64/ld-linux-x86-64.so.2 (0x00007fb2f9991000)
+#
+# Based on: http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html
+
+# Soname version must be bumped whenever a binary compatibility change occurs
+# (and should not be bumped when the library is compatible). A simple Duktape
+# convention is to set soname version to (100*MAJOR + MINOR), e.g. 104 for
+# Duktape 1.4.x, so that it gets automatically bumped for major and minor
+# releases (potentially binary incompatible), but not for patch releases.
+DUK_VERSION=10502
+SONAME_VERSION=105
+REAL_VERSION=$(SONAME_VERSION).$(DUK_VERSION)
+
+# Change to actual path for actual distribution packaging.
+INSTALL_PREFIX=/usr/local
+
+# The 'noline' variant may be more appropriate for some distributions; it
+# doesn't have #line directives in the combined source.
+DUKTAPE_SRCDIR=./src
+#DUKTAPE_SRCDIR=./src-noline
+
+.PHONY: all
+all: libduktape.so.$(REAL_VERSION) libduktaped.so.$(REAL_VERSION)
+
+# If the default duk_config.h is not suitable for the distribution, modify it
+# before compiling the shared library and copy the same, edited duk_config.h
+# to $INSTALL_PREFIX/include on installation.
+
+libduktape.so.$(REAL_VERSION):
+ gcc -shared -fPIC -Wall -Wextra -Os -Wl,-soname,libduktape.so.$(SONAME_VERSION) \
+ -o $@ $(DUKTAPE_SRCDIR)/duktape.c
+
+libduktaped.so.$(REAL_VERSION):
+ gcc -shared -fPIC -g -Wall -Wextra -Os -Wl,-soname,libduktaped.so.$(SONAME_VERSION) \
+ -o $@ $(DUKTAPE_SRCDIR)/duktape.c
+
+# Symlinks depend on platform conventions.
+.PHONY: install
+install: libduktape.so.$(REAL_VERSION) libduktaped.so.$(REAL_VERSION)
+ cp $+ $(INSTALL_PREFIX)/lib/
+ rm -f $(INSTALL_PREFIX)/lib/libduktape.so $(INSTALL_PREFIX)/lib/libduktape.so.$(SONAME_VERSION)
+ ln -s libduktape.so.$(REAL_VERSION) $(INSTALL_PREFIX)/lib/libduktape.so
+ ln -s libduktape.so.$(REAL_VERSION) $(INSTALL_PREFIX)/lib/libduktape.so.$(SONAME_VERSION)
+ rm -f $(INSTALL_PREFIX)/lib/libduktaped.so $(INSTALL_PREFIX)/lib/libduktaped.so.$(SONAME_VERSION)
+ ln -s libduktaped.so.$(REAL_VERSION) $(INSTALL_PREFIX)/lib/libduktaped.so
+ ln -s libduktaped.so.$(REAL_VERSION) $(INSTALL_PREFIX)/lib/libduktaped.so.$(SONAME_VERSION)
+ cp $(DUKTAPE_SRCDIR)/duktape.h $(DUKTAPE_SRCDIR)/duk_config.h $(INSTALL_PREFIX)/include/
+
+# Note: assumes /usr/local/include/ and /usr/local/lib/ are in include/link
+# path which may not be the case for all distributions.
+#CCOPTS=-I/usr/local/include -L/usr/local/lib
+CCOPTS=
+duk:
+ gcc $(CCOPTS) -Wall -Wextra -Os -o $@ ./examples/cmdline/duk_cmdline.c -lduktape -lm
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/README.rst b/ceph/src/civetweb/src/third_party/duktape-1.5.2/README.rst
similarity index 79%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/README.rst
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/README.rst
index 78e72b956..65311a7c7 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/README.rst
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/README.rst
@@ -61,6 +61,10 @@ This distributable contains:
* ``src/``: main Duktape library in a "single source file" format (duktape.c,
duktape.h, and duk_config.h).
+* ``src-noline/``: contains a variant of ``src/duktape.c`` with no ``#line``
+ directives which is preferable for some users. See discussion in
+ https://github.com/svaarala/duktape/pull/363.
+
* ``src-separate/``: main Duktape library in multiple files format.
* ``config/``: genconfig utility for creating duk_config.h configuration
@@ -81,7 +85,9 @@ This distributable contains:
* ``debugger/``: a debugger with a web UI, see ``debugger/README.rst`` and
https://github.com/svaarala/duktape/blob/master/doc/debugger.rst for
- details on Duktape debugger support.
+ details on Duktape debugger support. Also contains a JSON debug proxy
+ (one written in Node.js and another in DukLuv) to make talking to the
+ debug target easier.
* ``licenses/``: licensing information.
@@ -89,14 +95,15 @@ You can find release notes at:
* https://github.com/svaarala/duktape/blob/master/RELEASES.rst
-This distributable contains Duktape version 1.3.0, created from git
-commit 675165f35ea3a5bac34ff4d0a58b007cc2f442dc (v1.3.0).
+This distributable contains Duktape version 1.5.2, created from git
+commit cad34ae155acb0846545ca6bf2d29f9463b22bbb (v1.5.2).
Duktape is copyrighted by its authors (see ``AUTHORS.rst``) and licensed
-under the MIT license (see ``LICENSE.txt``). MurmurHash2 is used internally,
-it is also under the MIT license. Duktape module loader is based on the
-CommonJS module loading specification (without sharing any code), CommonJS
-is under the MIT license.
+under the MIT license (see ``LICENSE.txt``). String hashing algorithms are
+based on the algorithm from Lua (MIT license), djb2 hash, and Murmurhash2
+(MIT license). Duktape module loader is based on the CommonJS module
+loading specification (without sharing any code), CommonJS is under the
+MIT license.
Have fun!
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/config/README.rst b/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/README.rst
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/config/README.rst
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/config/README.rst
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/duk_config.h-modular-dll b/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/duk_config.h-modular-dll
new file mode 100644
index 000000000..5d5d0137c
--- /dev/null
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/duk_config.h-modular-dll
@@ -0,0 +1,3415 @@
+/*
+ * duk_config.h configuration header generated by genconfig.py.
+ *
+ * Git commit: cad34ae155acb0846545ca6bf2d29f9463b22bbb
+ * Git describe: v1.5.2
+ * Git branch: HEAD
+ *
+ * Supported platforms:
+ * - Mac OSX, iPhone, Darwin
+ * - OpenBSD
+ * - Generic BSD
+ * - Atari ST TOS
+ * - AmigaOS
+ * - Windows
+ * - Flashplayer (Crossbridge)
+ * - QNX
+ * - TI-Nspire
+ * - Emscripten
+ * - Linux
+ * - Solaris
+ * - Generic POSIX
+ * - Cygwin
+ * - Generic UNIX
+ * - Generic fallback
+ *
+ * Supported architectures:
+ * - x86
+ * - x64
+ * - x32
+ * - ARM 32-bit
+ * - ARM 64-bit
+ * - MIPS 32-bit
+ * - MIPS 64-bit
+ * - PowerPC 32-bit
+ * - PowerPC 64-bit
+ * - SPARC 32-bit
+ * - SPARC 64-bit
+ * - SuperH
+ * - Motorola 68k
+ * - Emscripten
+ * - Generic
+ *
+ * Supported compilers:
+ * - Clang
+ * - GCC
+ * - MSVC
+ * - Emscripten
+ * - TinyC
+ * - VBCC
+ * - Bruce's C compiler
+ * - Generic
+ *
+ */
+
+#if !defined(DUK_CONFIG_H_INCLUDED)
+#define DUK_CONFIG_H_INCLUDED
+
+/*
+ * Intermediate helper defines
+ */
+
+/* DLL build detection */
+#if defined(DUK_OPT_DLL_BUILD)
+#define DUK_F_DLL_BUILD
+#elif defined(DUK_OPT_NO_DLL_BUILD)
+#undef DUK_F_DLL_BUILD
+#else
+/* configured for DLL build */
+#define DUK_F_DLL_BUILD
+#endif
+
+/* Apple OSX, iOS */
+#if defined(__APPLE__)
+#define DUK_F_APPLE
+#endif
+
+/* OpenBSD */
+#if defined(__OpenBSD__) || defined(__OpenBSD)
+#define DUK_F_OPENBSD
+#endif
+
+/* NetBSD */
+#if defined(__NetBSD__) || defined(__NetBSD)
+#define DUK_F_NETBSD
+#endif
+
+/* FreeBSD */
+#if defined(__FreeBSD__) || defined(__FreeBSD)
+#define DUK_F_FREEBSD
+#endif
+
+/* BSD variant */
+#if defined(DUK_F_FREEBSD) || defined(DUK_F_NETBSD) || defined(DUK_F_OPENBSD) || \
+ defined(__bsdi__) || defined(__DragonFly__)
+#define DUK_F_BSD
+#endif
+
+/* Atari ST TOS. __TOS__ defined by PureC. No platform define in VBCC
+ * apparently, so to use with VBCC user must define __TOS__ manually.
+ */
+#if defined(__TOS__)
+#define DUK_F_TOS
+#endif
+
+/* Motorola 68K. Not defined by VBCC, so user must define one of these
+ * manually when using VBCC.
+ */
+#if defined(__m68k__) || defined(M68000) || defined(__MC68K__)
+#define DUK_F_M68K
+#endif
+
+/* AmigaOS. Neither AMIGA nor __amigaos__ is defined on VBCC, so user must
+ * define 'AMIGA' manually when using VBCC.
+ */
+#if defined(AMIGA) || defined(__amigaos__)
+#define DUK_F_AMIGAOS
+#endif
+
+/* PowerPC */
+#if defined(__powerpc) || defined(__powerpc__) || defined(__PPC__)
+#define DUK_F_PPC
+#if defined(__PPC64__) || defined(__LP64__) || defined(_LP64)
+#define DUK_F_PPC64
+#else
+#define DUK_F_PPC32
+#endif
+#endif
+
+/* Windows, both 32-bit and 64-bit */
+#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \
+ defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__)
+#define DUK_F_WINDOWS
+#if defined(_WIN64) || defined(WIN64)
+#define DUK_F_WIN64
+#else
+#define DUK_F_WIN32
+#endif
+#endif
+
+/* Flash player (e.g. Crossbridge) */
+#if defined(__FLASHPLAYER__)
+#define DUK_F_FLASHPLAYER
+#endif
+
+/* QNX */
+#if defined(__QNX__)
+#define DUK_F_QNX
+#endif
+
+/* TI-Nspire (using Ndless) */
+#if defined(_TINSPIRE)
+#define DUK_F_TINSPIRE
+#endif
+
+/* Emscripten (provided explicitly by user), improve if possible */
+#if defined(EMSCRIPTEN)
+#define DUK_F_EMSCRIPTEN
+#endif
+
+/* BCC (Bruce's C compiler): this is a "torture target" for compilation */
+#if defined(__BCC__) || defined(__BCC_VERSION__)
+#define DUK_F_BCC
+#endif
+
+/* Linux */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+#define DUK_F_LINUX
+#endif
+
+/* illumos / Solaris */
+#if defined(__sun) && defined(__SVR4)
+#define DUK_F_SUN
+#endif
+
+/* POSIX */
+#if defined(__posix)
+#define DUK_F_POSIX
+#endif
+
+/* Cygwin */
+#if defined(__CYGWIN__)
+#define DUK_F_CYGWIN
+#endif
+
+/* Generic Unix (includes Cygwin) */
+#if defined(__unix) || defined(__unix__) || defined(unix) || \
+ defined(DUK_F_LINUX) || defined(DUK_F_BSD)
+#define DUK_F_UNIX
+#endif
+
+/* stdint.h not available */
+#if defined(DUK_F_WINDOWS) && defined(_MSC_VER)
+#if (_MSC_VER < 1700)
+/* VS2012+ has stdint.h, < VS2012 does not (but it's available for download). */
+#define DUK_F_NO_STDINT_H
+#endif
+#endif
+#if !defined(DUK_F_NO_STDINT_H) && (defined(DUK_F_TOS) || defined(DUK_F_BCC))
+#define DUK_F_NO_STDINT_H
+#endif
+
+/* C++ */
+#undef DUK_F_CPP
+#if defined(__cplusplus)
+#define DUK_F_CPP
+#endif
+
+/* Intel x86 (32-bit), x64 (64-bit) or x32 (64-bit but 32-bit pointers),
+ * define only one of DUK_F_X86, DUK_F_X64, DUK_F_X32.
+ * https://sites.google.com/site/x32abi/
+ */
+#if defined(__amd64__) || defined(__amd64) || \
+ defined(__x86_64__) || defined(__x86_64) || \
+ defined(_M_X64) || defined(_M_AMD64)
+#if defined(__ILP32__) || defined(_ILP32)
+#define DUK_F_X32
+#else
+#define DUK_F_X64
+#endif
+#elif defined(i386) || defined(__i386) || defined(__i386__) || \
+ defined(__i486__) || defined(__i586__) || defined(__i686__) || \
+ defined(__IA32__) || defined(_M_IX86) || defined(__X86__) || \
+ defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__)
+#if defined(__LP64__) || defined(_LP64)
+/* This should not really happen, but would indicate x64. */
+#define DUK_F_X64
+#else
+#define DUK_F_X86
+#endif
+#endif
+
+/* ARM */
+#if defined(__arm__) || defined(__thumb__) || defined(_ARM) || defined(_M_ARM)
+#define DUK_F_ARM
+#if defined(__LP64__) || defined(_LP64) || defined(__arm64) || defined(__arm64__)
+#define DUK_F_ARM64
+#else
+#define DUK_F_ARM32
+#endif
+#endif
+
+/* MIPS. Related defines: __MIPSEB__, __MIPSEL__, __mips_isa_rev, __LP64__ */
+#if defined(__mips__) || defined(mips) || defined(_MIPS_ISA) || \
+ defined(_R3000) || defined(_R4000) || defined(_R5900) || \
+ defined(_MIPS_ISA_MIPS1) || defined(_MIPS_ISA_MIPS2) || \
+ defined(_MIPS_ISA_MIPS3) || defined(_MIPS_ISA_MIPS4) || \
+ defined(__mips) || defined(__MIPS__)
+#define DUK_F_MIPS
+#if defined(__LP64__) || defined(_LP64) || defined(__mips64) || \
+ defined(__mips64__) || defined(__mips_n64)
+#define DUK_F_MIPS64
+#else
+#define DUK_F_MIPS32
+#endif
+#endif
+
+/* SPARC */
+#if defined(sparc) || defined(__sparc) || defined(__sparc__)
+#define DUK_F_SPARC
+#if defined(__LP64__) || defined(_LP64)
+#define DUK_F_SPARC64
+#else
+#define DUK_F_SPARC32
+#endif
+#endif
+
+/* SuperH */
+#if defined(__sh__) || \
+ defined(__sh1__) || defined(__SH1__) || \
+ defined(__sh2__) || defined(__SH2__) || \
+ defined(__sh3__) || defined(__SH3__) || \
+ defined(__sh4__) || defined(__SH4__) || \
+ defined(__sh5__) || defined(__SH5__)
+#define DUK_F_SUPERH
+#endif
+
+/* Clang */
+#if defined(__clang__)
+#define DUK_F_CLANG
+#endif
+
+/* C99 or above */
+#undef DUK_F_C99
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#define DUK_F_C99
+#endif
+
+/* C++11 or above */
+#undef DUK_F_CPP11
+#if defined(__cplusplus) && (__cplusplus >= 201103L)
+#define DUK_F_CPP11
+#endif
+
+/* GCC. Clang also defines __GNUC__ so don't detect GCC if using Clang. */
+#if defined(__GNUC__) && !defined(__clang__) && !defined(DUK_F_CLANG)
+#define DUK_F_GCC
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
+/* Convenience, e.g. gcc 4.5.1 == 40501; http://stackoverflow.com/questions/6031819/emulating-gccs-builtin-unreachable */
+#define DUK_F_GCC_VERSION (__GNUC__ * 10000L + __GNUC_MINOR__ * 100L + __GNUC_PATCHLEVEL__)
+#else
+#error cannot figure out gcc version
+#endif
+#endif
+
+/* MinGW. Also GCC flags (DUK_F_GCC) are enabled now. */
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#define DUK_F_MINGW
+#endif
+
+/* MSVC */
+#if defined(_MSC_VER)
+/* MSVC preprocessor defines: http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+ * _MSC_FULL_VER includes the build number, but it has at least two formats, see e.g.
+ * BOOST_MSVC_FULL_VER in http://www.boost.org/doc/libs/1_52_0/boost/config/compiler/visualc.hpp
+ */
+#define DUK_F_MSVC
+#if defined(_MSC_FULL_VER)
+#if (_MSC_FULL_VER > 100000000)
+#define DUK_F_MSVC_FULL_VER _MSC_FULL_VER
+#else
+#define DUK_F_MSCV_FULL_VER (_MSC_FULL_VER * 10)
+#endif
+#endif
+#endif /* _MSC_VER */
+
+/* TinyC */
+#if defined(__TINYC__)
+/* http://bellard.org/tcc/tcc-doc.html#SEC9 */
+#define DUK_F_TINYC
+#endif
+
+/* VBCC */
+#if defined(__VBCC__)
+#define DUK_F_VBCC
+#endif
+
+/* Atari Mint */
+#if defined(__MINT__)
+#define DUK_F_MINT
+#endif
+
+/*
+ * Platform autodetection
+ */
+
+/* Workaround for older C++ compilers before including ,
+ * see e.g.: https://sourceware.org/bugzilla/show_bug.cgi?id=15366
+ */
+#if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS)
+#define __STDC_LIMIT_MACROS
+#endif
+#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS)
+#define __STDC_CONSTANT_MACROS
+#endif
+
+#if defined(DUK_F_APPLE)
+/* --- Mac OSX, iPhone, Darwin --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+/* http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor */
+#if TARGET_IPHONE_SIMULATOR
+#define DUK_USE_OS_STRING "iphone-sim"
+#elif TARGET_OS_IPHONE
+#define DUK_USE_OS_STRING "iphone"
+#elif TARGET_OS_MAC
+#define DUK_USE_OS_STRING "osx"
+#else
+#define DUK_USE_OS_STRING "osx-unknown"
+#endif
+
+/* Use _setjmp() on Apple by default, see GH-55. */
+#define DUK_JMPBUF_TYPE jmp_buf
+#define DUK_SETJMP(jb) _setjmp((jb))
+#define DUK_LONGJMP(jb) _longjmp((jb), 1)
+#elif defined(DUK_F_OPENBSD)
+/* --- OpenBSD --- */
+/* http://www.monkey.org/openbsd/archive/ports/0401/msg00089.html */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "openbsd"
+#elif defined(DUK_F_BSD)
+/* --- Generic BSD --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "bsd"
+#elif defined(DUK_F_TOS)
+/* --- Atari ST TOS --- */
+#define DUK_USE_DATE_NOW_TIME
+#define DUK_USE_DATE_TZO_GMTIME
+/* no parsing (not an error) */
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+
+#define DUK_USE_OS_STRING "tos"
+
+/* TOS on M68K is always big endian. */
+#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_M68K)
+#define DUK_USE_BYTEORDER 3
+#endif
+#elif defined(DUK_F_AMIGAOS)
+/* --- AmigaOS --- */
+#if defined(DUK_F_M68K)
+/* AmigaOS on M68k */
+#define DUK_USE_DATE_NOW_TIME
+#define DUK_USE_DATE_TZO_GMTIME
+/* no parsing (not an error) */
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#elif defined(DUK_F_PPC)
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#ifndef UINTPTR_MAX
+#define UINTPTR_MAX UINT_MAX
+#endif
+#else
+#error AmigaOS but not M68K/PPC, not supported now
+#endif
+
+#define DUK_USE_OS_STRING "amigaos"
+
+/* AmigaOS on M68K or PPC is always big endian. */
+#if !defined(DUK_USE_BYTEORDER) && (defined(DUK_F_M68K) || defined(DUK_F_PPC))
+#define DUK_USE_BYTEORDER 3
+#endif
+#elif defined(DUK_F_WINDOWS)
+/* --- Windows --- */
+/* Initial fix: disable secure CRT related warnings when compiling Duktape
+ * itself (must be defined before including Windows headers). Don't define
+ * for user code including duktape.h.
+ */
+#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+/* Windows 32-bit and 64-bit are currently the same. */
+/* MSVC does not have sys/param.h */
+#define DUK_USE_DATE_NOW_WINDOWS
+#define DUK_USE_DATE_TZO_WINDOWS
+/* Note: PRS and FMT are intentionally left undefined for now. This means
+ * there is no platform specific date parsing/formatting but there is still
+ * the ISO 8601 standard format.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+/* Only include when compiling Duktape to avoid polluting application build
+ * with a lot of unnecessary defines.
+ */
+#include
+#endif
+
+#define DUK_USE_OS_STRING "windows"
+
+/* On Windows, assume we're little endian. Even Itanium which has a
+ * configurable endianness runs little endian in Windows.
+ */
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#elif defined(DUK_F_FLASHPLAYER)
+/* --- Flashplayer (Crossbridge) --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "flashplayer"
+
+#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_FLASHPLAYER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#elif defined(DUK_F_QNX)
+/* --- QNX --- */
+#if defined(DUK_F_QNX) && defined(DUK_COMPILING_DUKTAPE)
+/* See: /opt/qnx650/target/qnx6/usr/include/sys/platform.h */
+#define _XOPEN_SOURCE 600
+#define _POSIX_C_SOURCE 200112L
+#endif
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "qnx"
+#elif defined(DUK_F_TINSPIRE)
+/* --- TI-Nspire --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "tinspire"
+#elif defined(DUK_F_EMSCRIPTEN)
+/* --- Emscripten --- */
+#if defined(DUK_COMPILING_DUKTAPE)
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#endif
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE /* e.g. getdate_r */
+#endif
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE /* e.g. strptime */
+#endif
+#endif /* DUK_COMPILING_DUKTAPE */
+
+#include
+#if defined(DUK_F_BCC)
+/* no endian.h */
+#else
+#include
+#endif /* DUK_F_BCC */
+#include
+#include
+#include
+#include
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+
+#define DUK_USE_OS_STRING "emscripten"
+#elif defined(DUK_F_LINUX)
+/* --- Linux --- */
+#if defined(DUK_COMPILING_DUKTAPE)
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#endif
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE /* e.g. getdate_r */
+#endif
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE /* e.g. strptime */
+#endif
+#endif /* DUK_COMPILING_DUKTAPE */
+
+#include
+#if defined(DUK_F_BCC)
+/* no endian.h or stdint.h */
+#else
+#include
+#include
+#endif /* DUK_F_BCC */
+#include
+#include
+#include
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+
+#define DUK_USE_OS_STRING "linux"
+#elif defined(DUK_F_SUN)
+/* --- Solaris --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "solaris"
+#elif defined(DUK_F_POSIX)
+/* --- Generic POSIX --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "posix"
+#elif defined(DUK_F_CYGWIN)
+/* --- Cygwin --- */
+/* don't use strptime() for now */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_JMPBUF_TYPE jmp_buf
+#define DUK_SETJMP(jb) _setjmp((jb))
+#define DUK_LONGJMP(jb) _longjmp((jb), 1)
+
+#define DUK_USE_OS_STRING "windows"
+#elif defined(DUK_F_UNIX)
+/* --- Generic UNIX --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#define DUK_USE_OS_STRING "unknown"
+#else
+/* --- Generic fallback --- */
+/* The most portable current time provider is time(), but it only has a
+ * one second resolution.
+ */
+#define DUK_USE_DATE_NOW_TIME
+
+/* The most portable way to figure out local time offset is gmtime(),
+ * but it's not thread safe so use with caution.
+ */
+#define DUK_USE_DATE_TZO_GMTIME
+
+/* Avoid custom date parsing and formatting for portability. */
+#undef DUK_USE_DATE_PRS_STRPTIME
+#undef DUK_USE_DATE_FMT_STRFTIME
+
+/* Rely on C89 headers only; time.h must be here. */
+#include
+
+#define DUK_USE_OS_STRING "unknown"
+#endif /* autodetect platform */
+
+/* Shared includes: C89 */
+#include
+#include
+#include
+#include /* varargs */
+#include
+#include /* e.g. ptrdiff_t */
+#include
+#include
+
+/* date.h is omitted, and included per platform */
+
+/* Shared includes: stdint.h is C99 */
+#if defined(DUK_F_NO_STDINT_H)
+/* stdint.h not available */
+#else
+/* Technically C99 (C++11) but found in many systems. On some systems
+ * __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS must be defined before
+ * including stdint.h (see above).
+ */
+#include
+#endif
+
+#if defined(DUK_F_CPP)
+#include /* std::exception */
+#endif
+
+/*
+ * Architecture autodetection
+ */
+
+#if defined(DUK_F_X86)
+/* --- x86 --- */
+#define DUK_USE_ARCH_STRING "x86"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+/* XXX: This is technically not guaranteed because it's possible to configure
+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 1
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_X64)
+/* --- x64 --- */
+#define DUK_USE_ARCH_STRING "x64"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+/* XXX: This is technically not guaranteed because it's possible to configure
+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 1
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_X32)
+/* --- x32 --- */
+#define DUK_USE_ARCH_STRING "x32"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+/* XXX: This is technically not guaranteed because it's possible to configure
+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 1
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_ARM32)
+/* --- ARM 32-bit --- */
+#define DUK_USE_ARCH_STRING "arm32"
+/* Byte order varies, so rely on autodetect. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 4
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_ARM64)
+/* --- ARM 64-bit --- */
+#define DUK_USE_ARCH_STRING "arm64"
+/* Byte order varies, so rely on autodetect. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_MIPS32)
+/* --- MIPS 32-bit --- */
+#define DUK_USE_ARCH_STRING "mips32"
+/* MIPS byte order varies so rely on autodetection. */
+/* Based on 'make checkalign' there are no alignment requirements on
+ * Linux MIPS except for doubles, which need align by 4. Alignment
+ * requirements vary based on target though.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 4
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_MIPS64)
+/* --- MIPS 64-bit --- */
+#define DUK_USE_ARCH_STRING "mips64"
+/* MIPS byte order varies so rely on autodetection. */
+/* Good default is a bit arbitrary because alignment requirements
+ * depend on target. See https://github.com/svaarala/duktape/issues/102.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_PPC32)
+/* --- PowerPC 32-bit --- */
+#define DUK_USE_ARCH_STRING "ppc32"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_PPC64)
+/* --- PowerPC 64-bit --- */
+#define DUK_USE_ARCH_STRING "ppc64"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_SPARC32)
+/* --- SPARC 32-bit --- */
+#define DUK_USE_ARCH_STRING "sparc32"
+/* SPARC byte order varies so rely on autodetection. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_SPARC64)
+/* --- SPARC 64-bit --- */
+#define DUK_USE_ARCH_STRING "sparc64"
+/* SPARC byte order varies so rely on autodetection. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_SUPERH)
+/* --- SuperH --- */
+#define DUK_USE_ARCH_STRING "sh"
+/* Byte order varies, rely on autodetection. */
+/* Based on 'make checkalign' there are no alignment requirements on
+ * Linux SH4, but align by 4 is probably a good basic default.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 4
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_M68K)
+/* --- Motorola 68k --- */
+#define DUK_USE_ARCH_STRING "m68k"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_EMSCRIPTEN)
+/* --- Emscripten --- */
+#define DUK_USE_ARCH_STRING "emscripten"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#else
+/* --- Generic --- */
+/* These are necessary wild guesses. */
+#define DUK_USE_ARCH_STRING "generic"
+/* Rely on autodetection for byte order, alignment, and packed tval. */
+#endif /* autodetect architecture */
+
+/*
+ * Compiler autodetection
+ */
+
+#if defined(DUK_F_CLANG)
+/* --- Clang --- */
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+/* C99 / C++11 and above: rely on va_copy() which is required. */
+#define DUK_VA_COPY(dest,src) va_copy(dest,src)
+#else
+/* Clang: assume we have __va_copy() in non-C99 mode. */
+#define DUK_VA_COPY(dest,src) __va_copy(dest,src)
+#endif
+
+#define DUK_NORETURN(decl) decl __attribute__((noreturn))
+
+#if defined(__clang__) && defined(__has_builtin)
+#if __has_builtin(__builtin_unreachable)
+#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0)
+#endif
+#endif
+
+#define DUK_USE_BRANCH_HINTS
+#define DUK_LIKELY(x) __builtin_expect((x), 1)
+#define DUK_UNLIKELY(x) __builtin_expect((x), 0)
+
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_NOINLINE __attribute__((noinline))
+#define DUK_INLINE inline
+#define DUK_ALWAYS_INLINE inline __attribute__((always_inline))
+#endif
+
+#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL extern __declspec(dllexport)
+#define DUK_EXTERNAL __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL extern __declspec(dllimport)
+#define DUK_EXTERNAL should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#else
+#define DUK_INTERNAL_DECL extern
+#define DUK_INTERNAL /*empty*/
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#else
+#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and
+ * Clang. Based on documentation it should suffice to have the attribute
+ * in the declaration only, but in practice some warnings are generated unless
+ * the attribute is also applied to the definition.
+ */
+#define DUK_INTERNAL_DECL static __attribute__ ((unused))
+#define DUK_INTERNAL static __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#endif
+#else
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden")))
+#endif
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#endif
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "clang"
+#else
+#define DUK_USE_COMPILER_STRING "clang"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#define DUK_USE_UNION_INITIALIZERS
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#undef DUK_USE_GCC_PRAGMAS
+#define DUK_USE_PACK_CLANG_ATTR
+#elif defined(DUK_F_GCC)
+/* --- GCC --- */
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+/* C99 / C++11 and above: rely on va_copy() which is required. */
+#define DUK_VA_COPY(dest,src) va_copy(dest,src)
+#else
+/* GCC: assume we have __va_copy() in non-C99 mode. */
+#define DUK_VA_COPY(dest,src) __va_copy(dest,src)
+#endif
+
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 20500L)
+/* since gcc-2.5 */
+#define DUK_NORETURN(decl) decl __attribute__((noreturn))
+#endif
+
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L)
+/* since gcc-4.5 */
+#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0)
+#endif
+
+#define DUK_USE_BRANCH_HINTS
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L)
+/* GCC: test not very accurate; enable only in relatively recent builds
+ * because of bugs in gcc-4.4 (http://lists.debian.org/debian-gcc/2010/04/msg00000.html)
+ */
+#define DUK_LIKELY(x) __builtin_expect((x), 1)
+#define DUK_UNLIKELY(x) __builtin_expect((x), 0)
+#endif
+
+#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \
+ defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 30101)
+#define DUK_NOINLINE __attribute__((noinline))
+#define DUK_INLINE inline
+#define DUK_ALWAYS_INLINE inline __attribute__((always_inline))
+#endif
+
+#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL extern __declspec(dllexport)
+#define DUK_EXTERNAL __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL extern __declspec(dllimport)
+#define DUK_EXTERNAL should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#else
+#define DUK_INTERNAL_DECL extern
+#define DUK_INTERNAL /*empty*/
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#elif defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40000)
+#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and
+ * Clang. Based on documentation it should suffice to have the attribute
+ * in the declaration only, but in practice some warnings are generated unless
+ * the attribute is also applied to the definition.
+ */
+#define DUK_INTERNAL_DECL static __attribute__ ((unused))
+#define DUK_INTERNAL static __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#endif
+#else
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden")))
+#endif
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#endif
+
+#if defined(DUK_F_MINGW)
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "mingw++"
+#else
+#define DUK_USE_COMPILER_STRING "mingw"
+#endif
+#else
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "g++"
+#else
+#define DUK_USE_COMPILER_STRING "gcc"
+#endif
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || (defined(DUK_F_CPP11) && defined(__GNUC__))
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#define DUK_USE_UNION_INITIALIZERS
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40600)
+#define DUK_USE_GCC_PRAGMAS
+#else
+#undef DUK_USE_GCC_PRAGMAS
+#endif
+
+#define DUK_USE_PACK_GCC_ATTR
+#elif defined(DUK_F_MSVC)
+/* --- MSVC --- */
+/* http://msdn.microsoft.com/en-us/library/aa235362(VS.60).aspx */
+#define DUK_NORETURN(decl) __declspec(noreturn) decl
+
+/* XXX: DUK_UNREACHABLE for msvc? */
+
+#undef DUK_USE_BRANCH_HINTS
+
+/* XXX: DUK_LIKELY, DUK_UNLIKELY for msvc? */
+/* XXX: DUK_NOINLINE, DUK_INLINE, DUK_ALWAYS_INLINE for msvc? */
+
+#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL extern __declspec(dllexport)
+#define DUK_EXTERNAL __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL extern __declspec(dllimport)
+#define DUK_EXTERNAL should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#else
+#define DUK_INTERNAL_DECL extern
+#define DUK_INTERNAL /*empty*/
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#endif
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "msvc++"
+#else
+#define DUK_USE_COMPILER_STRING "msvc"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99)
+#define DUK_USE_VARIADIC_MACROS
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+/* VS2005+ should have variadic macros even when they're not C99. */
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#undef DUK_USE_UNION_INITIALIZERS
+#if defined(_MSC_VER) && (_MSC_VER >= 1800)
+/* VS2013+ supports union initializers but there's a bug involving union-inside-struct:
+ * https://connect.microsoft.com/VisualStudio/feedback/details/805981
+ * The bug was fixed (at least) in VS2015 so check for VS2015 for now:
+ * https://blogs.msdn.microsoft.com/vcblog/2015/07/01/c-compiler-front-end-fixes-in-vs2015/
+ * Manually tested using VS2013, CL reports 18.00.31101, so enable for VS2013 too.
+ */
+#define DUK_USE_UNION_INITIALIZERS
+#endif
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#undef DUK_USE_GCC_PRAGMAS
+
+#define DUK_USE_PACK_MSVC_PRAGMA
+
+/* These have been tested from VS2008 onwards; may work in older VS versions
+ * too but not enabled by default.
+ */
+#if defined(_MSC_VER) && (_MSC_VER >= 1500)
+#define DUK_NOINLINE __declspec(noinline)
+#define DUK_INLINE __inline
+#define DUK_ALWAYS_INLINE __forceinline
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+#define DUK_SNPRINTF snprintf
+#define DUK_VSNPRINTF vsnprintf
+#else
+/* (v)snprintf() is missing before MSVC 2015. Note that _(v)snprintf() does
+ * NOT NUL terminate on truncation, but Duktape code never assumes that.
+ * http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
+ */
+#define DUK_SNPRINTF _snprintf
+#define DUK_VSNPRINTF _vsnprintf
+#endif
+#elif defined(DUK_F_EMSCRIPTEN)
+/* --- Emscripten --- */
+#define DUK_NORETURN(decl) decl __attribute__((noreturn))
+
+#if defined(__clang__) && defined(__has_builtin)
+#if __has_builtin(__builtin_unreachable)
+#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0)
+#endif
+#endif
+
+#define DUK_USE_BRANCH_HINTS
+#define DUK_LIKELY(x) __builtin_expect((x), 1)
+#define DUK_UNLIKELY(x) __builtin_expect((x), 0)
+
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_NOINLINE __attribute__((noinline))
+#define DUK_INLINE inline
+#define DUK_ALWAYS_INLINE inline __attribute__((always_inline))
+#endif
+
+#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and
+ * Clang. Based on documentation it should suffice to have the attribute
+ * in the declaration only, but in practice some warnings are generated unless
+ * the attribute is also applied to the definition.
+ */
+#define DUK_INTERNAL_DECL static __attribute__ ((unused))
+#define DUK_INTERNAL static __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#endif
+#else
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden")))
+#endif
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+
+#define DUK_USE_COMPILER_STRING "emscripten"
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#define DUK_USE_UNION_INITIALIZERS
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#undef DUK_USE_GCC_PRAGMAS
+#define DUK_USE_PACK_CLANG_ATTR
+#elif defined(DUK_F_TINYC)
+/* --- TinyC --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "tinyc++"
+#else
+#define DUK_USE_COMPILER_STRING "tinyc"
+#endif
+
+/* http://bellard.org/tcc/tcc-doc.html#SEC7 */
+#define DUK_USE_VARIADIC_MACROS
+
+#define DUK_USE_UNION_INITIALIZERS
+
+/* Most portable, wastes space */
+#define DUK_USE_FLEX_ONESIZE
+
+/* Most portable, potentially wastes space */
+#define DUK_USE_PACK_DUMMY_MEMBER
+#elif defined(DUK_F_VBCC)
+/* --- VBCC --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "vbcc-c++"
+#else
+#define DUK_USE_COMPILER_STRING "vbcc"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+/* VBCC supports C99 so check only for C99 for union initializer support.
+ * Designated union initializers would possibly work even without a C99 check.
+ */
+#undef DUK_USE_UNION_INITIALIZERS
+#if defined(DUK_F_C99)
+#define DUK_USE_UNION_INITIALIZERS
+#endif
+
+#define DUK_USE_FLEX_ZEROSIZE
+#define DUK_USE_PACK_DUMMY_MEMBER
+#elif defined(DUK_F_BCC)
+/* --- Bruce's C compiler --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "bcc++"
+#else
+#define DUK_USE_COMPILER_STRING "bcc"
+#endif
+
+/* Most portable */
+#undef DUK_USE_VARIADIC_MACROS
+
+/* Most portable, wastes space */
+#undef DUK_USE_UNION_INITIALIZERS
+
+/* Most portable, wastes space */
+#define DUK_USE_FLEX_ONESIZE
+
+/* Most portable, potentially wastes space */
+#define DUK_USE_PACK_DUMMY_MEMBER
+
+/* BCC, assume we're on x86. */
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#else
+/* --- Generic --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "generic-c++"
+#else
+#define DUK_USE_COMPILER_STRING "generic"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+/* C++ doesn't have standard designated union initializers ({ .foo = 1 }). */
+#undef DUK_USE_UNION_INITIALIZERS
+#if defined(DUK_F_C99)
+#define DUK_USE_UNION_INITIALIZERS
+#endif
+
+/* Most portable, wastes space */
+#define DUK_USE_FLEX_ONESIZE
+
+/* Most portable, potentially wastes space */
+#define DUK_USE_PACK_DUMMY_MEMBER
+#endif /* autodetect compiler */
+
+/* uclibc */
+#if defined(__UCLIBC__)
+#define DUK_F_UCLIBC
+#endif
+
+/*
+ * Wrapper typedefs and constants for integer types, also sanity check types.
+ *
+ * C99 typedefs are quite good but not always available, and we want to avoid
+ * forcibly redefining the C99 typedefs. So, there are Duktape wrappers for
+ * all C99 typedefs and Duktape code should only use these typedefs. Type
+ * detection when C99 is not supported is best effort and may end up detecting
+ * some types incorrectly.
+ *
+ * Pointer sizes are a portability problem: pointers to different types may
+ * have a different size and function pointers are very difficult to manage
+ * portably.
+ *
+ * http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types
+ *
+ * Note: there's an interesting corner case when trying to define minimum
+ * signed integer value constants which leads to the current workaround of
+ * defining e.g. -0x80000000 as (-0x7fffffffL - 1L). See doc/code-issues.txt
+ * for a longer discussion.
+ *
+ * Note: avoid typecasts and computations in macro integer constants as they
+ * can then no longer be used in macro relational expressions (such as
+ * #if DUK_SIZE_MAX < 0xffffffffUL). There is internal code which relies on
+ * being able to compare DUK_SIZE_MAX against a limit.
+ */
+
+/* XXX: add feature options to force basic types from outside? */
+
+#if !defined(INT_MAX)
+#error INT_MAX not defined
+#endif
+
+/* Check that architecture is two's complement, standard C allows e.g.
+ * INT_MIN to be -2**31+1 (instead of -2**31).
+ */
+#if defined(INT_MAX) && defined(INT_MIN)
+#if INT_MAX != -(INT_MIN + 1)
+#error platform does not seem complement of two
+#endif
+#else
+#error cannot check complement of two
+#endif
+
+/* Pointer size determination based on __WORDSIZE or architecture when
+ * that's not available.
+ */
+#if defined(DUK_F_X86) || defined(DUK_F_X32) || \
+ defined(DUK_F_M68K) || defined(DUK_F_PPC32) || \
+ defined(DUK_F_BCC) || \
+ (defined(__WORDSIZE) && (__WORDSIZE == 32))
+#define DUK_F_32BIT_PTRS
+#elif defined(DUK_F_X64) || \
+ (defined(__WORDSIZE) && (__WORDSIZE == 64))
+#define DUK_F_64BIT_PTRS
+#else
+/* not sure, not needed with C99 anyway */
+#endif
+
+/* Intermediate define for 'have inttypes.h' */
+#undef DUK_F_HAVE_INTTYPES
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+ !(defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC))
+/* vbcc + AmigaOS has C99 but no inttypes.h */
+#define DUK_F_HAVE_INTTYPES
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+/* C++11 apparently ratified stdint.h */
+#define DUK_F_HAVE_INTTYPES
+#endif
+
+/* Basic integer typedefs and limits, preferably from inttypes.h, otherwise
+ * through automatic detection.
+ */
+#if defined(DUK_F_HAVE_INTTYPES)
+/* C99 or compatible */
+
+#define DUK_F_HAVE_64BIT
+#include
+
+typedef uint8_t duk_uint8_t;
+typedef int8_t duk_int8_t;
+typedef uint16_t duk_uint16_t;
+typedef int16_t duk_int16_t;
+typedef uint32_t duk_uint32_t;
+typedef int32_t duk_int32_t;
+typedef uint64_t duk_uint64_t;
+typedef int64_t duk_int64_t;
+typedef uint_least8_t duk_uint_least8_t;
+typedef int_least8_t duk_int_least8_t;
+typedef uint_least16_t duk_uint_least16_t;
+typedef int_least16_t duk_int_least16_t;
+typedef uint_least32_t duk_uint_least32_t;
+typedef int_least32_t duk_int_least32_t;
+typedef uint_least64_t duk_uint_least64_t;
+typedef int_least64_t duk_int_least64_t;
+typedef uint_fast8_t duk_uint_fast8_t;
+typedef int_fast8_t duk_int_fast8_t;
+typedef uint_fast16_t duk_uint_fast16_t;
+typedef int_fast16_t duk_int_fast16_t;
+typedef uint_fast32_t duk_uint_fast32_t;
+typedef int_fast32_t duk_int_fast32_t;
+typedef uint_fast64_t duk_uint_fast64_t;
+typedef int_fast64_t duk_int_fast64_t;
+typedef uintptr_t duk_uintptr_t;
+typedef intptr_t duk_intptr_t;
+typedef uintmax_t duk_uintmax_t;
+typedef intmax_t duk_intmax_t;
+
+#define DUK_UINT8_MIN 0
+#define DUK_UINT8_MAX UINT8_MAX
+#define DUK_INT8_MIN INT8_MIN
+#define DUK_INT8_MAX INT8_MAX
+#define DUK_UINT_LEAST8_MIN 0
+#define DUK_UINT_LEAST8_MAX UINT_LEAST8_MAX
+#define DUK_INT_LEAST8_MIN INT_LEAST8_MIN
+#define DUK_INT_LEAST8_MAX INT_LEAST8_MAX
+#define DUK_UINT_FAST8_MIN 0
+#define DUK_UINT_FAST8_MAX UINT_FAST8_MAX
+#define DUK_INT_FAST8_MIN INT_FAST8_MIN
+#define DUK_INT_FAST8_MAX INT_FAST8_MAX
+#define DUK_UINT16_MIN 0
+#define DUK_UINT16_MAX UINT16_MAX
+#define DUK_INT16_MIN INT16_MIN
+#define DUK_INT16_MAX INT16_MAX
+#define DUK_UINT_LEAST16_MIN 0
+#define DUK_UINT_LEAST16_MAX UINT_LEAST16_MAX
+#define DUK_INT_LEAST16_MIN INT_LEAST16_MIN
+#define DUK_INT_LEAST16_MAX INT_LEAST16_MAX
+#define DUK_UINT_FAST16_MIN 0
+#define DUK_UINT_FAST16_MAX UINT_FAST16_MAX
+#define DUK_INT_FAST16_MIN INT_FAST16_MIN
+#define DUK_INT_FAST16_MAX INT_FAST16_MAX
+#define DUK_UINT32_MIN 0
+#define DUK_UINT32_MAX UINT32_MAX
+#define DUK_INT32_MIN INT32_MIN
+#define DUK_INT32_MAX INT32_MAX
+#define DUK_UINT_LEAST32_MIN 0
+#define DUK_UINT_LEAST32_MAX UINT_LEAST32_MAX
+#define DUK_INT_LEAST32_MIN INT_LEAST32_MIN
+#define DUK_INT_LEAST32_MAX INT_LEAST32_MAX
+#define DUK_UINT_FAST32_MIN 0
+#define DUK_UINT_FAST32_MAX UINT_FAST32_MAX
+#define DUK_INT_FAST32_MIN INT_FAST32_MIN
+#define DUK_INT_FAST32_MAX INT_FAST32_MAX
+#define DUK_UINT64_MIN 0
+#define DUK_UINT64_MAX UINT64_MAX
+#define DUK_INT64_MIN INT64_MIN
+#define DUK_INT64_MAX INT64_MAX
+#define DUK_UINT_LEAST64_MIN 0
+#define DUK_UINT_LEAST64_MAX UINT_LEAST64_MAX
+#define DUK_INT_LEAST64_MIN INT_LEAST64_MIN
+#define DUK_INT_LEAST64_MAX INT_LEAST64_MAX
+#define DUK_UINT_FAST64_MIN 0
+#define DUK_UINT_FAST64_MAX UINT_FAST64_MAX
+#define DUK_INT_FAST64_MIN INT_FAST64_MIN
+#define DUK_INT_FAST64_MAX INT_FAST64_MAX
+
+#define DUK_UINTPTR_MIN 0
+#define DUK_UINTPTR_MAX UINTPTR_MAX
+#define DUK_INTPTR_MIN INTPTR_MIN
+#define DUK_INTPTR_MAX INTPTR_MAX
+
+#define DUK_UINTMAX_MIN 0
+#define DUK_UINTMAX_MAX UINTMAX_MAX
+#define DUK_INTMAX_MIN INTMAX_MIN
+#define DUK_INTMAX_MAX INTMAX_MAX
+
+#define DUK_SIZE_MIN 0
+#define DUK_SIZE_MAX SIZE_MAX
+#undef DUK_SIZE_MAX_COMPUTED
+
+#else /* C99 types */
+
+/* When C99 types are not available, we use heuristic detection to get
+ * the basic 8, 16, 32, and (possibly) 64 bit types. The fast/least
+ * types are then assumed to be exactly the same for now: these could
+ * be improved per platform but C99 types are very often now available.
+ * 64-bit types are not available on all platforms; this is OK at least
+ * on 32-bit platforms.
+ *
+ * This detection code is necessarily a bit hacky and can provide typedefs
+ * and defines that won't work correctly on some exotic platform.
+ */
+
+#if (defined(CHAR_BIT) && (CHAR_BIT == 8)) || \
+ (defined(UCHAR_MAX) && (UCHAR_MAX == 255))
+typedef unsigned char duk_uint8_t;
+typedef signed char duk_int8_t;
+#else
+#error cannot detect 8-bit type
+#endif
+
+#if defined(USHRT_MAX) && (USHRT_MAX == 65535UL)
+typedef unsigned short duk_uint16_t;
+typedef signed short duk_int16_t;
+#elif defined(UINT_MAX) && (UINT_MAX == 65535UL)
+/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */
+typedef unsigned int duk_uint16_t;
+typedef signed int duk_int16_t;
+#else
+#error cannot detect 16-bit type
+#endif
+
+#if defined(UINT_MAX) && (UINT_MAX == 4294967295UL)
+typedef unsigned int duk_uint32_t;
+typedef signed int duk_int32_t;
+#elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295UL)
+/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */
+typedef unsigned long duk_uint32_t;
+typedef signed long duk_int32_t;
+#else
+#error cannot detect 32-bit type
+#endif
+
+/* 64-bit type detection is a bit tricky.
+ *
+ * ULLONG_MAX is a standard define. __LONG_LONG_MAX__ and __ULONG_LONG_MAX__
+ * are used by at least GCC (even if system headers don't provide ULLONG_MAX).
+ * Some GCC variants may provide __LONG_LONG_MAX__ but not __ULONG_LONG_MAX__.
+ *
+ * ULL / LL constants are rejected / warned about by some compilers, even if
+ * the compiler has a 64-bit type and the compiler/system headers provide an
+ * unsupported constant (ULL/LL)! Try to avoid using ULL / LL constants.
+ * As a side effect we can only check that e.g. ULONG_MAX is larger than 32
+ * bits but can't be sure it is exactly 64 bits. Self tests will catch such
+ * cases.
+ */
+#undef DUK_F_HAVE_64BIT
+#if !defined(DUK_F_HAVE_64BIT) && defined(ULONG_MAX)
+#if (ULONG_MAX > 4294967295UL)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long duk_uint64_t;
+typedef signed long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(ULLONG_MAX)
+#if (ULLONG_MAX > 4294967295UL)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long long duk_uint64_t;
+typedef signed long long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(__ULONG_LONG_MAX__)
+#if (__ULONG_LONG_MAX__ > 4294967295UL)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long long duk_uint64_t;
+typedef signed long long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(__LONG_LONG_MAX__)
+#if (__LONG_LONG_MAX__ > 2147483647L)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long long duk_uint64_t;
+typedef signed long long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && \
+ (defined(DUK_F_MINGW) || defined(DUK_F_MSVC))
+/* Both MinGW and MSVC have a 64-bit type. */
+#define DUK_F_HAVE_64BIT
+typedef unsigned long duk_uint64_t;
+typedef signed long duk_int64_t;
+#endif
+#if !defined(DUK_F_HAVE_64BIT)
+/* cannot detect 64-bit type, not always needed so don't error */
+#endif
+
+typedef duk_uint8_t duk_uint_least8_t;
+typedef duk_int8_t duk_int_least8_t;
+typedef duk_uint16_t duk_uint_least16_t;
+typedef duk_int16_t duk_int_least16_t;
+typedef duk_uint32_t duk_uint_least32_t;
+typedef duk_int32_t duk_int_least32_t;
+typedef duk_uint8_t duk_uint_fast8_t;
+typedef duk_int8_t duk_int_fast8_t;
+typedef duk_uint16_t duk_uint_fast16_t;
+typedef duk_int16_t duk_int_fast16_t;
+typedef duk_uint32_t duk_uint_fast32_t;
+typedef duk_int32_t duk_int_fast32_t;
+#if defined(DUK_F_HAVE_64BIT)
+typedef duk_uint64_t duk_uint_least64_t;
+typedef duk_int64_t duk_int_least64_t;
+typedef duk_uint64_t duk_uint_fast64_t;
+typedef duk_int64_t duk_int_fast64_t;
+#endif
+#if defined(DUK_F_HAVE_64BIT)
+typedef duk_uint64_t duk_uintmax_t;
+typedef duk_int64_t duk_intmax_t;
+#else
+typedef duk_uint32_t duk_uintmax_t;
+typedef duk_int32_t duk_intmax_t;
+#endif
+
+/* Note: the funny looking computations for signed minimum 16-bit, 32-bit, and
+ * 64-bit values are intentional as the obvious forms (e.g. -0x80000000L) are
+ * -not- portable. See code-issues.txt for a detailed discussion.
+ */
+#define DUK_UINT8_MIN 0UL
+#define DUK_UINT8_MAX 0xffUL
+#define DUK_INT8_MIN (-0x80L)
+#define DUK_INT8_MAX 0x7fL
+#define DUK_UINT_LEAST8_MIN 0UL
+#define DUK_UINT_LEAST8_MAX 0xffUL
+#define DUK_INT_LEAST8_MIN (-0x80L)
+#define DUK_INT_LEAST8_MAX 0x7fL
+#define DUK_UINT_FAST8_MIN 0UL
+#define DUK_UINT_FAST8_MAX 0xffUL
+#define DUK_INT_FAST8_MIN (-0x80L)
+#define DUK_INT_FAST8_MAX 0x7fL
+#define DUK_UINT16_MIN 0UL
+#define DUK_UINT16_MAX 0xffffUL
+#define DUK_INT16_MIN (-0x7fffL - 1L)
+#define DUK_INT16_MAX 0x7fffL
+#define DUK_UINT_LEAST16_MIN 0UL
+#define DUK_UINT_LEAST16_MAX 0xffffUL
+#define DUK_INT_LEAST16_MIN (-0x7fffL - 1L)
+#define DUK_INT_LEAST16_MAX 0x7fffL
+#define DUK_UINT_FAST16_MIN 0UL
+#define DUK_UINT_FAST16_MAX 0xffffUL
+#define DUK_INT_FAST16_MIN (-0x7fffL - 1L)
+#define DUK_INT_FAST16_MAX 0x7fffL
+#define DUK_UINT32_MIN 0UL
+#define DUK_UINT32_MAX 0xffffffffUL
+#define DUK_INT32_MIN (-0x7fffffffL - 1L)
+#define DUK_INT32_MAX 0x7fffffffL
+#define DUK_UINT_LEAST32_MIN 0UL
+#define DUK_UINT_LEAST32_MAX 0xffffffffUL
+#define DUK_INT_LEAST32_MIN (-0x7fffffffL - 1L)
+#define DUK_INT_LEAST32_MAX 0x7fffffffL
+#define DUK_UINT_FAST32_MIN 0UL
+#define DUK_UINT_FAST32_MAX 0xffffffffUL
+#define DUK_INT_FAST32_MIN (-0x7fffffffL - 1L)
+#define DUK_INT_FAST32_MAX 0x7fffffffL
+
+/* 64-bit constants. Since LL / ULL constants are not always available,
+ * use computed values. These values can't be used in preprocessor
+ * comparisons; flag them as such.
+ */
+#if defined(DUK_F_HAVE_64BIT)
+#define DUK_UINT64_MIN ((duk_uint64_t) 0)
+#define DUK_UINT64_MAX ((duk_uint64_t) -1)
+#define DUK_INT64_MIN ((duk_int64_t) (~(DUK_UINT64_MAX >> 1)))
+#define DUK_INT64_MAX ((duk_int64_t) (DUK_UINT64_MAX >> 1))
+#define DUK_UINT_LEAST64_MIN DUK_UINT64_MIN
+#define DUK_UINT_LEAST64_MAX DUK_UINT64_MAX
+#define DUK_INT_LEAST64_MIN DUK_INT64_MIN
+#define DUK_INT_LEAST64_MAX DUK_INT64_MAX
+#define DUK_UINT_FAST64_MIN DUK_UINT64_MIN
+#define DUK_UINT_FAST64_MAX DUK_UINT64_MAX
+#define DUK_INT_FAST64_MIN DUK_INT64_MIN
+#define DUK_INT_FAST64_MAX DUK_INT64_MAX
+#define DUK_UINT64_MIN_COMPUTED
+#define DUK_UINT64_MAX_COMPUTED
+#define DUK_INT64_MIN_COMPUTED
+#define DUK_INT64_MAX_COMPUTED
+#define DUK_UINT_LEAST64_MIN_COMPUTED
+#define DUK_UINT_LEAST64_MAX_COMPUTED
+#define DUK_INT_LEAST64_MIN_COMPUTED
+#define DUK_INT_LEAST64_MAX_COMPUTED
+#define DUK_UINT_FAST64_MIN_COMPUTED
+#define DUK_UINT_FAST64_MAX_COMPUTED
+#define DUK_INT_FAST64_MIN_COMPUTED
+#define DUK_INT_FAST64_MAX_COMPUTED
+#endif
+
+#if defined(DUK_F_HAVE_64BIT)
+#define DUK_UINTMAX_MIN DUK_UINT64_MIN
+#define DUK_UINTMAX_MAX DUK_UINT64_MAX
+#define DUK_INTMAX_MIN DUK_INT64_MIN
+#define DUK_INTMAX_MAX DUK_INT64_MAX
+#define DUK_UINTMAX_MIN_COMPUTED
+#define DUK_UINTMAX_MAX_COMPUTED
+#define DUK_INTMAX_MIN_COMPUTED
+#define DUK_INTMAX_MAX_COMPUTED
+#else
+#define DUK_UINTMAX_MIN 0UL
+#define DUK_UINTMAX_MAX 0xffffffffUL
+#define DUK_INTMAX_MIN (-0x7fffffffL - 1L)
+#define DUK_INTMAX_MAX 0x7fffffffL
+#endif
+
+/* This detection is not very reliable. */
+#if defined(DUK_F_32BIT_PTRS)
+typedef duk_int32_t duk_intptr_t;
+typedef duk_uint32_t duk_uintptr_t;
+#define DUK_UINTPTR_MIN DUK_UINT32_MIN
+#define DUK_UINTPTR_MAX DUK_UINT32_MAX
+#define DUK_INTPTR_MIN DUK_INT32_MIN
+#define DUK_INTPTR_MAX DUK_INT32_MAX
+#elif defined(DUK_F_64BIT_PTRS) && defined(DUK_F_HAVE_64BIT)
+typedef duk_int64_t duk_intptr_t;
+typedef duk_uint64_t duk_uintptr_t;
+#define DUK_UINTPTR_MIN DUK_UINT64_MIN
+#define DUK_UINTPTR_MAX DUK_UINT64_MAX
+#define DUK_INTPTR_MIN DUK_INT64_MIN
+#define DUK_INTPTR_MAX DUK_INT64_MAX
+#define DUK_UINTPTR_MIN_COMPUTED
+#define DUK_UINTPTR_MAX_COMPUTED
+#define DUK_INTPTR_MIN_COMPUTED
+#define DUK_INTPTR_MAX_COMPUTED
+#else
+#error cannot determine intptr type
+#endif
+
+/* SIZE_MAX may be missing so use an approximate value for it. */
+#undef DUK_SIZE_MAX_COMPUTED
+#if !defined(SIZE_MAX)
+#define DUK_SIZE_MAX_COMPUTED
+#define SIZE_MAX ((size_t) (-1))
+#endif
+#define DUK_SIZE_MIN 0
+#define DUK_SIZE_MAX SIZE_MAX
+
+#endif /* C99 types */
+
+/* A few types are assumed to always exist. */
+typedef size_t duk_size_t;
+typedef ptrdiff_t duk_ptrdiff_t;
+
+/* The best type for an "all around int" in Duktape internals is "at least
+ * 32 bit signed integer" which is most convenient. Same for unsigned type.
+ * Prefer 'int' when large enough, as it is almost always a convenient type.
+ */
+#if defined(UINT_MAX) && (UINT_MAX >= 0xffffffffUL)
+typedef int duk_int_t;
+typedef unsigned int duk_uint_t;
+#define DUK_INT_MIN INT_MIN
+#define DUK_INT_MAX INT_MAX
+#define DUK_UINT_MIN 0
+#define DUK_UINT_MAX UINT_MAX
+#else
+typedef duk_int_fast32_t duk_int_t;
+typedef duk_uint_fast32_t duk_uint_t;
+#define DUK_INT_MIN DUK_INT_FAST32_MIN
+#define DUK_INT_MAX DUK_INT_FAST32_MAX
+#define DUK_UINT_MIN DUK_UINT_FAST32_MIN
+#define DUK_UINT_MAX DUK_UINT_FAST32_MAX
+#endif
+
+/* Same as 'duk_int_t' but guaranteed to be a 'fast' variant if this
+ * distinction matters for the CPU. These types are used mainly in the
+ * executor where it might really matter.
+ */
+typedef duk_int_fast32_t duk_int_fast_t;
+typedef duk_uint_fast32_t duk_uint_fast_t;
+#define DUK_INT_FAST_MIN DUK_INT_FAST32_MIN
+#define DUK_INT_FAST_MAX DUK_INT_FAST32_MAX
+#define DUK_UINT_FAST_MIN DUK_UINT_FAST32_MIN
+#define DUK_UINT_FAST_MAX DUK_UINT_FAST32_MAX
+
+/* Small integers (16 bits or more) can fall back to the 'int' type, but
+ * have a typedef so they are marked "small" explicitly.
+ */
+typedef int duk_small_int_t;
+typedef unsigned int duk_small_uint_t;
+#define DUK_SMALL_INT_MIN INT_MIN
+#define DUK_SMALL_INT_MAX INT_MAX
+#define DUK_SMALL_UINT_MIN 0
+#define DUK_SMALL_UINT_MAX UINT_MAX
+
+/* Fast variants of small integers, again for really fast paths like the
+ * executor.
+ */
+typedef duk_int_fast16_t duk_small_int_fast_t;
+typedef duk_uint_fast16_t duk_small_uint_fast_t;
+#define DUK_SMALL_INT_FAST_MIN DUK_INT_FAST16_MIN
+#define DUK_SMALL_INT_FAST_MAX DUK_INT_FAST16_MAX
+#define DUK_SMALL_UINT_FAST_MIN DUK_UINT_FAST16_MIN
+#define DUK_SMALL_UINT_FAST_MAX DUK_UINT_FAST16_MAX
+
+/* Boolean values are represented with the platform 'int'. */
+typedef duk_small_int_t duk_bool_t;
+#define DUK_BOOL_MIN DUK_SMALL_INT_MIN
+#define DUK_BOOL_MAX DUK_SMALL_INT_MAX
+
+/* Index values must have at least 32-bit signed range. */
+typedef duk_int_t duk_idx_t;
+#define DUK_IDX_MIN DUK_INT_MIN
+#define DUK_IDX_MAX DUK_INT_MAX
+
+/* Unsigned index variant. */
+typedef duk_uint_t duk_uidx_t;
+#define DUK_UIDX_MIN DUK_UINT_MIN
+#define DUK_UIDX_MAX DUK_UINT_MAX
+
+/* Array index values, could be exact 32 bits.
+ * Currently no need for signed duk_arridx_t.
+ */
+typedef duk_uint_t duk_uarridx_t;
+#define DUK_UARRIDX_MIN DUK_UINT_MIN
+#define DUK_UARRIDX_MAX DUK_UINT_MAX
+
+/* Duktape/C function return value, platform int is enough for now to
+ * represent 0, 1, or negative error code. Must be compatible with
+ * assigning truth values (e.g. duk_ret_t rc = (foo == bar);).
+ */
+typedef duk_small_int_t duk_ret_t;
+#define DUK_RET_MIN DUK_SMALL_INT_MIN
+#define DUK_RET_MAX DUK_SMALL_INT_MAX
+
+/* Error codes are represented with platform int. High bits are used
+ * for flags and such, so 32 bits are needed.
+ */
+typedef duk_int_t duk_errcode_t;
+#define DUK_ERRCODE_MIN DUK_INT_MIN
+#define DUK_ERRCODE_MAX DUK_INT_MAX
+
+/* Codepoint type. Must be 32 bits or more because it is used also for
+ * internal codepoints. The type is signed because negative codepoints
+ * are used as internal markers (e.g. to mark EOF or missing argument).
+ * (X)UTF-8/CESU-8 encode/decode take and return an unsigned variant to
+ * ensure duk_uint32_t casts back and forth nicely. Almost everything
+ * else uses the signed one.
+ */
+typedef duk_int_t duk_codepoint_t;
+typedef duk_uint_t duk_ucodepoint_t;
+#define DUK_CODEPOINT_MIN DUK_INT_MIN
+#define DUK_CODEPOINT_MAX DUK_INT_MAX
+#define DUK_UCODEPOINT_MIN DUK_UINT_MIN
+#define DUK_UCODEPOINT_MAX DUK_UINT_MAX
+
+/* IEEE float/double typedef. */
+typedef float duk_float_t;
+typedef double duk_double_t;
+
+/* We're generally assuming that we're working on a platform with a 32-bit
+ * address space. If DUK_SIZE_MAX is a typecast value (which is necessary
+ * if SIZE_MAX is missing), the check must be avoided because the
+ * preprocessor can't do a comparison.
+ */
+#if !defined(DUK_SIZE_MAX)
+#error DUK_SIZE_MAX is undefined, probably missing SIZE_MAX
+#elif !defined(DUK_SIZE_MAX_COMPUTED)
+#if DUK_SIZE_MAX < 0xffffffffUL
+/* On some systems SIZE_MAX can be smaller than max unsigned 32-bit value
+ * which seems incorrect if size_t is (at least) an unsigned 32-bit type.
+ * However, it doesn't seem useful to error out compilation if this is the
+ * case.
+ */
+#endif
+#endif
+
+/* Type for public API calls. */
+typedef struct duk_hthread duk_context;
+
+/* Check whether we should use 64-bit integers or not.
+ *
+ * Quite incomplete now. Use 64-bit types if detected (C99 or other detection)
+ * unless they are known to be unreliable. For instance, 64-bit types are
+ * available on VBCC but seem to misbehave.
+ */
+#if defined(DUK_F_HAVE_64BIT) && !defined(DUK_F_VBCC)
+#define DUK_USE_64BIT_OPS
+#else
+#undef DUK_USE_64BIT_OPS
+#endif
+
+/*
+ * Fill-ins for platform, architecture, and compiler
+ */
+
+#if !defined(DUK_SETJMP)
+#define DUK_JMPBUF_TYPE jmp_buf
+#define DUK_SETJMP(jb) setjmp((jb))
+#define DUK_LONGJMP(jb) longjmp((jb), 1)
+#endif
+
+#if 0
+/* sigsetjmp() alternative */
+#define DUK_JMPBUF_TYPE sigjmp_buf
+#define DUK_SETJMP(jb) sigsetjmp((jb))
+#define DUK_LONGJMP(jb) siglongjmp((jb), 1)
+#endif
+
+typedef FILE duk_file;
+#if !defined(DUK_STDIN)
+#define DUK_STDIN stdin
+#endif
+#if !defined(DUK_STDOUT)
+#define DUK_STDOUT stdout
+#endif
+#if !defined(DUK_STDERR)
+#define DUK_STDERR stderr
+#endif
+
+/* Special naming to avoid conflict with e.g. DUK_FREE() in duk_heap.h
+ * (which is unfortunately named). May sometimes need replacement, e.g.
+ * some compilers don't handle zero length or NULL correctly in realloc().
+ */
+#if !defined(DUK_ANSI_MALLOC)
+#define DUK_ANSI_MALLOC malloc
+#endif
+#if !defined(DUK_ANSI_REALLOC)
+#define DUK_ANSI_REALLOC realloc
+#endif
+#if !defined(DUK_ANSI_CALLOC)
+#define DUK_ANSI_CALLOC calloc
+#endif
+#if !defined(DUK_ANSI_FREE)
+#define DUK_ANSI_FREE free
+#endif
+
+/* ANSI C (various versions) and some implementations require that the
+ * pointer arguments to memset(), memcpy(), and memmove() be valid values
+ * even when byte size is 0 (even a NULL pointer is considered invalid in
+ * this context). Zero-size operations as such are allowed, as long as their
+ * pointer arguments point to a valid memory area. The DUK_MEMSET(),
+ * DUK_MEMCPY(), and DUK_MEMMOVE() macros require this same behavior, i.e.:
+ * (1) pointers must be valid and non-NULL, (2) zero size must otherwise be
+ * allowed. If these are not fulfilled, a macro wrapper is needed.
+ *
+ * http://stackoverflow.com/questions/5243012/is-it-guaranteed-to-be-safe-to-perform-memcpy0-0-0
+ * http://lists.cs.uiuc.edu/pipermail/llvmdev/2007-October/011065.html
+ *
+ * Not sure what's the required behavior when a pointer points just past the
+ * end of a buffer, which often happens in practice (e.g. zero size memmoves).
+ * For example, if allocation size is 3, the following pointer would not
+ * technically point to a valid memory byte:
+ *
+ * <-- alloc -->
+ * | 0 | 1 | 2 | .....
+ * ^-- p=3, points after last valid byte (2)
+ */
+#if !defined(DUK_MEMCPY)
+#if defined(DUK_F_UCLIBC)
+/* Old uclibcs have a broken memcpy so use memmove instead (this is overly wide
+ * now on purpose): http://lists.uclibc.org/pipermail/uclibc-cvs/2008-October/025511.html
+ */
+#define DUK_MEMCPY memmove
+#else
+#define DUK_MEMCPY memcpy
+#endif
+#endif
+#if !defined(DUK_MEMMOVE)
+#define DUK_MEMMOVE memmove
+#endif
+#if !defined(DUK_MEMCMP)
+#define DUK_MEMCMP memcmp
+#endif
+#if !defined(DUK_MEMSET)
+#define DUK_MEMSET memset
+#endif
+#if !defined(DUK_STRLEN)
+#define DUK_STRLEN strlen
+#endif
+#if !defined(DUK_STRCMP)
+#define DUK_STRCMP strcmp
+#endif
+#if !defined(DUK_STRNCMP)
+#define DUK_STRNCMP strncmp
+#endif
+#if !defined(DUK_PRINTF)
+#define DUK_PRINTF printf
+#endif
+#if !defined(DUK_FPRINTF)
+#define DUK_FPRINTF fprintf
+#endif
+#if !defined(DUK_SPRINTF)
+#define DUK_SPRINTF sprintf
+#endif
+#if !defined(DUK_SNPRINTF)
+/* snprintf() is technically not part of C89 but usually available. */
+#define DUK_SNPRINTF snprintf
+#endif
+#if !defined(DUK_VSPRINTF)
+#define DUK_VSPRINTF vsprintf
+#endif
+#if !defined(DUK_VSNPRINTF)
+/* vsnprintf() is technically not part of C89 but usually available. */
+#define DUK_VSNPRINTF vsnprintf
+#endif
+#if !defined(DUK_SSCANF)
+#define DUK_SSCANF sscanf
+#endif
+#if !defined(DUK_VSSCANF)
+#define DUK_VSSCANF vsscanf
+#endif
+#if !defined(DUK_FOPEN)
+#define DUK_FOPEN fopen
+#endif
+#if !defined(DUK_FCLOSE)
+#define DUK_FCLOSE fclose
+#endif
+#if !defined(DUK_FREAD)
+#define DUK_FREAD fread
+#endif
+#if !defined(DUK_FWRITE)
+#define DUK_FWRITE fwrite
+#endif
+#if !defined(DUK_FSEEK)
+#define DUK_FSEEK fseek
+#endif
+#if !defined(DUK_FTELL)
+#define DUK_FTELL ftell
+#endif
+#if !defined(DUK_FFLUSH)
+#define DUK_FFLUSH fflush
+#endif
+#if !defined(DUK_FPUTC)
+#define DUK_FPUTC fputc
+#endif
+#if !defined(DUK_MEMZERO)
+#define DUK_MEMZERO(p,n) DUK_MEMSET((p), 0, (n))
+#endif
+#if !defined(DUK_ABORT)
+#define DUK_ABORT abort
+#endif
+#if !defined(DUK_EXIT)
+#define DUK_EXIT exit
+#endif
+
+#if !defined(DUK_DOUBLE_2TO32)
+#define DUK_DOUBLE_2TO32 4294967296.0
+#endif
+#if !defined(DUK_DOUBLE_2TO31)
+#define DUK_DOUBLE_2TO31 2147483648.0
+#endif
+
+#if !defined(DUK_DOUBLE_INFINITY)
+#undef DUK_USE_COMPUTED_INFINITY
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION < 40600)
+/* GCC older than 4.6: avoid overflow warnings related to using INFINITY */
+#define DUK_DOUBLE_INFINITY (__builtin_inf())
+#elif defined(INFINITY)
+#define DUK_DOUBLE_INFINITY ((double) INFINITY)
+#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC)
+#define DUK_DOUBLE_INFINITY (1.0 / 0.0)
+#else
+/* In VBCC (1.0 / 0.0) results in a warning and 0.0 instead of infinity.
+ * Use a computed infinity (initialized when a heap is created at the
+ * latest).
+ */
+#define DUK_USE_COMPUTED_INFINITY
+#define DUK_DOUBLE_INFINITY duk_computed_infinity
+#endif
+#endif
+
+#if !defined(DUK_DOUBLE_NAN)
+#undef DUK_USE_COMPUTED_NAN
+#if defined(NAN)
+#define DUK_DOUBLE_NAN NAN
+#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC)
+#define DUK_DOUBLE_NAN (0.0 / 0.0)
+#else
+/* In VBCC (0.0 / 0.0) results in a warning and 0.0 instead of NaN.
+ * In MSVC (VS2010 Express) (0.0 / 0.0) results in a compile error.
+ * Use a computed NaN (initialized when a heap is created at the
+ * latest).
+ */
+#define DUK_USE_COMPUTED_NAN
+#define DUK_DOUBLE_NAN duk_computed_nan
+#endif
+#endif
+
+/* Many platforms are missing fpclassify() and friends, so use replacements
+ * if necessary. The replacement constants (FP_NAN etc) can be anything but
+ * match Linux constants now.
+ */
+#undef DUK_USE_REPL_FPCLASSIFY
+#undef DUK_USE_REPL_SIGNBIT
+#undef DUK_USE_REPL_ISFINITE
+#undef DUK_USE_REPL_ISNAN
+#undef DUK_USE_REPL_ISINF
+
+/* Complex condition broken into separate parts. */
+#undef DUK_F_USE_REPL_ALL
+#if !(defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO) && \
+ defined(FP_SUBNORMAL) && defined(FP_NORMAL))
+/* Missing some obvious constants. */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)
+/* VBCC is missing the built-ins even in C99 mode (perhaps a header issue). */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_M68K)
+/* AmigaOS + M68K seems to have math issues even when using GCC cross
+ * compilation. Use replacements for all AmigaOS versions on M68K
+ * regardless of compiler.
+ */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_FREEBSD) && defined(DUK_F_CLANG)
+/* Placeholder fix for (detection is wider than necessary):
+ * http://llvm.org/bugs/show_bug.cgi?id=17788
+ */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_UCLIBC)
+/* At least some uclibc versions have broken floating point math. For
+ * example, fpclassify() can incorrectly classify certain NaN formats.
+ * To be safe, use replacements.
+ */
+#define DUK_F_USE_REPL_ALL
+#endif
+
+#if defined(DUK_F_USE_REPL_ALL)
+#define DUK_USE_REPL_FPCLASSIFY
+#define DUK_USE_REPL_SIGNBIT
+#define DUK_USE_REPL_ISFINITE
+#define DUK_USE_REPL_ISNAN
+#define DUK_USE_REPL_ISINF
+#define DUK_FPCLASSIFY duk_repl_fpclassify
+#define DUK_SIGNBIT duk_repl_signbit
+#define DUK_ISFINITE duk_repl_isfinite
+#define DUK_ISNAN duk_repl_isnan
+#define DUK_ISINF duk_repl_isinf
+#define DUK_FP_NAN 0
+#define DUK_FP_INFINITE 1
+#define DUK_FP_ZERO 2
+#define DUK_FP_SUBNORMAL 3
+#define DUK_FP_NORMAL 4
+#else
+#define DUK_FPCLASSIFY fpclassify
+#define DUK_SIGNBIT signbit
+#define DUK_ISFINITE isfinite
+#define DUK_ISNAN isnan
+#define DUK_ISINF isinf
+#define DUK_FP_NAN FP_NAN
+#define DUK_FP_INFINITE FP_INFINITE
+#define DUK_FP_ZERO FP_ZERO
+#define DUK_FP_SUBNORMAL FP_SUBNORMAL
+#define DUK_FP_NORMAL FP_NORMAL
+#endif
+
+#if defined(DUK_F_USE_REPL_ALL)
+#undef DUK_F_USE_REPL_ALL
+#endif
+
+/* Some math functions are C99 only. This is also an issue with some
+ * embedded environments using uclibc where uclibc has been configured
+ * not to provide some functions. For now, use replacements whenever
+ * using uclibc.
+ */
+#undef DUK_USE_MATH_FMIN
+#undef DUK_USE_MATH_FMAX
+#undef DUK_USE_MATH_ROUND
+#if defined(DUK_F_UCLIBC)
+/* uclibc may be missing these */
+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)
+/* vbcc + AmigaOS may be missing these */
+#elif defined(DUK_F_MINT)
+/* mint clib is missing these */
+#elif !defined(DUK_F_C99) && !defined(DUK_F_CPP11)
+/* build is not C99 or C++11, play it safe */
+#else
+/* C99 or C++11, no known issues */
+#define DUK_USE_MATH_FMIN
+#define DUK_USE_MATH_FMAX
+#define DUK_USE_MATH_ROUND
+#endif
+
+/* These functions don't currently need replacement but are wrapped for
+ * completeness. Because these are used as function pointers, they need
+ * to be defined as concrete C functions (not macros).
+ */
+#if !defined(DUK_FABS)
+#define DUK_FABS fabs
+#endif
+#if !defined(DUK_FMIN)
+#define DUK_FMIN fmin
+#endif
+#if !defined(DUK_FMAX)
+#define DUK_FMAX fmax
+#endif
+#if !defined(DUK_FLOOR)
+#define DUK_FLOOR floor
+#endif
+#if !defined(DUK_CEIL)
+#define DUK_CEIL ceil
+#endif
+#if !defined(DUK_FMOD)
+#define DUK_FMOD fmod
+#endif
+#if !defined(DUK_POW)
+#define DUK_POW pow
+#endif
+#if !defined(DUK_ACOS)
+#define DUK_ACOS acos
+#endif
+#if !defined(DUK_ASIN)
+#define DUK_ASIN asin
+#endif
+#if !defined(DUK_ATAN)
+#define DUK_ATAN atan
+#endif
+#if !defined(DUK_ATAN2)
+#define DUK_ATAN2 atan2
+#endif
+#if !defined(DUK_SIN)
+#define DUK_SIN sin
+#endif
+#if !defined(DUK_COS)
+#define DUK_COS cos
+#endif
+#if !defined(DUK_TAN)
+#define DUK_TAN tan
+#endif
+#if !defined(DUK_EXP)
+#define DUK_EXP exp
+#endif
+#if !defined(DUK_LOG)
+#define DUK_LOG log
+#endif
+#if !defined(DUK_SQRT)
+#define DUK_SQRT sqrt
+#endif
+
+/* NetBSD 6.0 x86 (at least) has a few problems with pow() semantics,
+ * see test-bug-netbsd-math-pow.js. Use NetBSD specific workaround.
+ * (This might be a wider problem; if so, generalize the define name.)
+ */
+#undef DUK_USE_POW_NETBSD_WORKAROUND
+#if defined(DUK_F_NETBSD)
+#define DUK_USE_POW_NETBSD_WORKAROUND
+#endif
+
+/* Rely as little as possible on compiler behavior for NaN comparison,
+ * signed zero handling, etc. Currently never activated but may be needed
+ * for broken compilers.
+ */
+#undef DUK_USE_PARANOID_MATH
+
+/* There was a curious bug where test-bi-date-canceling.js would fail e.g.
+ * on 64-bit Ubuntu, gcc-4.8.1, -m32, and no -std=c99. Some date computations
+ * using doubles would be optimized which then broke some corner case tests.
+ * The problem goes away by adding 'volatile' to the datetime computations.
+ * Not sure what the actual triggering conditions are, but using this on
+ * non-C99 systems solves the known issues and has relatively little cost
+ * on other platforms.
+ */
+#undef DUK_USE_PARANOID_DATE_COMPUTATION
+#if !defined(DUK_F_C99)
+#define DUK_USE_PARANOID_DATE_COMPUTATION
+#endif
+
+/*
+ * Byte order and double memory layout detection
+ *
+ * Endianness detection is a major portability hassle because the macros
+ * and headers are not standardized. There's even variance across UNIX
+ * platforms. Even with "standard" headers, details like underscore count
+ * varies between platforms, e.g. both __BYTE_ORDER and _BYTE_ORDER are used
+ * (Crossbridge has a single underscore, for instance).
+ *
+ * The checks below are structured with this in mind: several approaches are
+ * used, and at the end we check if any of them worked. This allows generic
+ * approaches to be tried first, and platform/compiler specific hacks tried
+ * last. As a last resort, the user can force a specific endianness, as it's
+ * not likely that automatic detection will work on the most exotic platforms.
+ *
+ * Duktape supports little and big endian machines. There's also support
+ * for a hybrid used by some ARM machines where integers are little endian
+ * but IEEE double values use a mixed order (12345678 -> 43218765). This
+ * byte order for doubles is referred to as "mixed endian".
+ */
+
+/* For custom platforms allow user to define byteorder explicitly.
+ * Since endianness headers are not standardized, this is a useful
+ * workaround for custom platforms for which endianness detection
+ * is not directly supported. Perhaps custom hardware is used and
+ * user cannot submit upstream patches.
+ */
+#if defined(DUK_OPT_FORCE_BYTEORDER)
+#undef DUK_USE_BYTEORDER
+#if (DUK_OPT_FORCE_BYTEORDER == 1)
+#define DUK_USE_BYTEORDER 1
+#elif (DUK_OPT_FORCE_BYTEORDER == 2)
+#define DUK_USE_BYTEORDER 2
+#elif (DUK_OPT_FORCE_BYTEORDER == 3)
+#define DUK_USE_BYTEORDER 3
+#else
+#error invalid DUK_OPT_FORCE_BYTEORDER value
+#endif
+#endif /* DUK_OPT_FORCE_BYTEORDER */
+
+/* GCC and Clang provide endianness defines as built-in predefines, with
+ * leading and trailing double underscores (e.g. __BYTE_ORDER__). See
+ * output of "make gccpredefs" and "make clangpredefs". Clang doesn't
+ * seem to provide __FLOAT_WORD_ORDER__; assume not mixed endian for clang.
+ * http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+ */
+#if !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__)
+#if defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define DUK_USE_BYTEORDER 1
+#elif defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define DUK_USE_BYTEORDER 2
+#elif !defined(__FLOAT_WORD_ORDER__)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 1
+#else
+/* Byte order is little endian but cannot determine IEEE double word order. */
+#endif /* float word order */
+#elif defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define DUK_USE_BYTEORDER 3
+#elif !defined(__FLOAT_WORD_ORDER__)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 3
+#else
+/* Byte order is big endian but cannot determine IEEE double word order. */
+#endif /* float word order */
+#else
+/* Cannot determine byte order; __ORDER_PDP_ENDIAN__ is related to 32-bit
+ * integer ordering and is not relevant.
+ */
+#endif /* integer byte order */
+#endif /* !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__) */
+
+/* More or less standard endianness predefines provided by header files.
+ * The ARM hybrid case is detected by assuming that __FLOAT_WORD_ORDER
+ * will be big endian, see: http://lists.mysql.com/internals/443.
+ * On some platforms some defines may be present with an empty value which
+ * causes comparisons to fail: https://github.com/svaarala/duktape/issues/453.
+ */
+#if !defined(DUK_USE_BYTEORDER)
+#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) || \
+ defined(_BYTE_ORDER) && defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN) || \
+ defined(__LITTLE_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER) && defined(__LITTLE_ENDIAN) && (__FLOAT_WORD_ORDER == __LITTLE_ENDIAN) || \
+ defined(_FLOAT_WORD_ORDER) && defined(_LITTLE_ENDIAN) && (_FLOAT_WORD_ORDER == _LITTLE_ENDIAN)
+#define DUK_USE_BYTEORDER 1
+#elif defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \
+ defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN)
+#define DUK_USE_BYTEORDER 2
+#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 1
+#else
+/* Byte order is little endian but cannot determine IEEE double word order. */
+#endif /* float word order */
+#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) || \
+ defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN) || \
+ defined(__BIG_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \
+ defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN)
+#define DUK_USE_BYTEORDER 3
+#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 3
+#else
+/* Byte order is big endian but cannot determine IEEE double word order. */
+#endif /* float word order */
+#else
+/* Cannot determine byte order. */
+#endif /* integer byte order */
+#endif /* !defined(DUK_USE_BYTEORDER) */
+
+/* QNX gcc cross compiler seems to define e.g. __LITTLEENDIAN__ or __BIGENDIAN__:
+ * $ /opt/qnx650/host/linux/x86/usr/bin/i486-pc-nto-qnx6.5.0-gcc -dM -E - > 24) | \
+ ((((duk_uint32_t) (x)) >> 8) & 0xff00UL) | \
+ ((((duk_uint32_t) (x)) << 8) & 0xff0000UL) | \
+ (((duk_uint32_t) (x)) << 24))
+#endif
+#if !defined(DUK_BSWAP16)
+#define DUK_BSWAP16(x) \
+ ((duk_uint16_t) (x) >> 8) | \
+ ((duk_uint16_t) (x) << 8)
+#endif
+
+/* DUK_USE_VARIADIC_MACROS: required from compilers, so no fill-in. */
+/* DUK_USE_UNION_INITIALIZERS: required from compilers, so no fill-in. */
+
+#if !(defined(DUK_USE_FLEX_C99) || defined(DUK_USE_FLEX_ZEROSIZE) || defined(DUK_USE_FLEX_ONESIZE))
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE /* Not standard but common enough */
+#endif
+#endif
+
+#if !(defined(DUK_USE_PACK_GCC_ATTR) || defined(DUK_USE_PACK_CLANG_ATTR) || \
+ defined(DUK_USE_PACK_MSVC_PRAGMA) || defined(DUK_USE_PACK_DUMMY_MEMBER))
+#define DUK_USE_PACK_DUMMY_MEMBER
+#endif
+
+#if 0 /* not defined by default */
+#undef DUK_USE_GCC_PRAGMAS
+#endif
+
+/* Workaround for GH-323: avoid inlining control when compiling from
+ * multiple sources, as it causes compiler portability trouble.
+ */
+#if !defined(DUK_SINGLE_FILE)
+#undef DUK_NOINLINE
+#undef DUK_INLINE
+#undef DUK_ALWAYS_INLINE
+#define DUK_NOINLINE /*nop*/
+#define DUK_INLINE /*nop*/
+#define DUK_ALWAYS_INLINE /*nop*/
+#endif
+
+/*
+ * Check whether or not a packed duk_tval representation is possible.
+ * What's basically required is that pointers are 32-bit values
+ * (sizeof(void *) == 4). Best effort check, not always accurate.
+ * If guess goes wrong, crashes may result; self tests also verify
+ * the guess.
+ */
+
+/* Explicit marker needed; may be 'defined', 'undefined, 'or 'not provided'. */
+#if !defined(DUK_F_PACKED_TVAL_PROVIDED)
+#undef DUK_F_PACKED_TVAL_POSSIBLE
+
+/* Strict C99 case: DUK_UINTPTR_MAX (= UINTPTR_MAX) should be very reliable */
+#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX)
+#if (DUK_UINTPTR_MAX <= 0xffffffffUL)
+#define DUK_F_PACKED_TVAL_POSSIBLE
+#endif
+#endif
+
+/* Non-C99 case, still relying on DUK_UINTPTR_MAX, as long as it is not a computed value */
+#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED)
+#if (DUK_UINTPTR_MAX <= 0xffffffffUL)
+#define DUK_F_PACKED_TVAL_POSSIBLE
+#endif
+#endif
+
+/* DUK_SIZE_MAX (= SIZE_MAX) is often reliable */
+#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_SIZE_MAX) && !defined(DUK_SIZE_MAX_COMPUTED)
+#if (DUK_SIZE_MAX <= 0xffffffffUL)
+#define DUK_F_PACKED_TVAL_POSSIBLE
+#endif
+#endif
+
+#undef DUK_USE_PACKED_TVAL
+#if defined(DUK_F_PACKED_TVAL_POSSIBLE)
+#define DUK_USE_PACKED_TVAL
+#endif
+
+#undef DUK_F_PACKED_TVAL_POSSIBLE
+#endif /* DUK_F_PACKED_TVAL_PROVIDED */
+
+/* Feature option forcing. */
+#if defined(DUK_OPT_NO_PACKED_TVAL)
+#undef DUK_USE_PACKED_TVAL
+#elif defined(DUK_OPT_PACKED_TVAL)
+#undef DUK_USE_PACKED_TVAL
+#define DUK_USE_PACKED_TVAL
+#endif
+/* Object property allocation layout has implications for memory and code
+ * footprint and generated code size/speed. The best layout also depends
+ * on whether the platform has alignment requirements or benefits from
+ * having mostly aligned accesses.
+ */
+#undef DUK_USE_HOBJECT_LAYOUT_1
+#undef DUK_USE_HOBJECT_LAYOUT_2
+#undef DUK_USE_HOBJECT_LAYOUT_3
+#if (DUK_USE_ALIGN_BY == 1)
+/* On platforms without any alignment issues, layout 1 is preferable
+ * because it compiles to slightly less code and provides direct access
+ * to property keys.
+ */
+#define DUK_USE_HOBJECT_LAYOUT_1
+#else
+/* On other platforms use layout 2, which requires some padding but
+ * is a bit more natural than layout 3 in ordering the entries. Layout
+ * 3 is currently not used.
+ */
+#define DUK_USE_HOBJECT_LAYOUT_2
+#endif
+
+/* GCC/clang inaccurate math would break compliance and probably duk_tval,
+ * so refuse to compile. Relax this if -ffast-math is tested to work.
+ */
+#if defined(__FAST_MATH__)
+#error __FAST_MATH__ defined, refusing to compile
+#endif
+
+/*
+ * Autogenerated defaults
+ */
+
+#undef DUK_USE_ASSERTIONS
+#define DUK_USE_AUGMENT_ERROR_CREATE
+#define DUK_USE_AUGMENT_ERROR_THROW
+#define DUK_USE_AVOID_PLATFORM_FUNCPTRS
+#define DUK_USE_BASE64_FASTPATH
+#define DUK_USE_BROWSER_LIKE
+#define DUK_USE_BUFFEROBJECT_SUPPORT
+#undef DUK_USE_BUFLEN16
+#define DUK_USE_BUILTIN_INITJS
+#define DUK_USE_BYTECODE_DUMP_SUPPORT
+#define DUK_USE_COMMONJS_MODULES
+#define DUK_USE_COMPILER_RECLIMIT 2500
+#undef DUK_USE_CPP_EXCEPTIONS
+#undef DUK_USE_DATAPTR16
+#undef DUK_USE_DATAPTR_DEC16
+#undef DUK_USE_DATAPTR_ENC16
+#undef DUK_USE_DATE_FORMAT_STRING
+#undef DUK_USE_DATE_GET_LOCAL_TZOFFSET
+#undef DUK_USE_DATE_GET_NOW
+#undef DUK_USE_DATE_PARSE_STRING
+#undef DUK_USE_DATE_PRS_GETDATE
+#undef DUK_USE_DDDPRINT
+#undef DUK_USE_DDPRINT
+#undef DUK_USE_DEBUG
+#undef DUK_USE_DEBUGGER_DUMPHEAP
+#undef DUK_USE_DEBUGGER_FWD_LOGGING
+#undef DUK_USE_DEBUGGER_FWD_PRINTALERT
+#undef DUK_USE_DEBUGGER_INSPECT
+#undef DUK_USE_DEBUGGER_PAUSE_UNCAUGHT
+#undef DUK_USE_DEBUGGER_SUPPORT
+#define DUK_USE_DEBUGGER_THROW_NOTIFY
+#undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE
+#define DUK_USE_DEBUG_BUFSIZE 65536L
+#define DUK_USE_DOUBLE_LINKED_HEAP
+#undef DUK_USE_DPRINT
+#undef DUK_USE_DPRINT_COLORS
+#undef DUK_USE_DPRINT_RDTSC
+#define DUK_USE_ERRCREATE
+#define DUK_USE_ERRTHROW
+#define DUK_USE_ES6_OBJECT_PROTO_PROPERTY
+#define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF
+#define DUK_USE_ES6_PROXY
+#define DUK_USE_ES6_REGEXP_BRACES
+#define DUK_USE_ESBC_LIMITS
+#define DUK_USE_ESBC_MAX_BYTES 2147418112L
+#define DUK_USE_ESBC_MAX_LINENUMBER 2147418112L
+#undef DUK_USE_EXEC_FUN_LOCAL
+#undef DUK_USE_EXEC_INDIRECT_BOUND_CHECK
+#undef DUK_USE_EXEC_TIMEOUT_CHECK
+#undef DUK_USE_EXPLICIT_NULL_INIT
+#undef DUK_USE_EXTSTR_FREE
+#undef DUK_USE_EXTSTR_INTERN_CHECK
+#undef DUK_USE_FASTINT
+#define DUK_USE_FAST_REFCOUNT_DEFAULT
+#define DUK_USE_FILE_IO
+#undef DUK_USE_FUNCPTR16
+#undef DUK_USE_FUNCPTR_DEC16
+#undef DUK_USE_FUNCPTR_ENC16
+#undef DUK_USE_GC_TORTURE
+#undef DUK_USE_HEAPPTR16
+#undef DUK_USE_HEAPPTR_DEC16
+#undef DUK_USE_HEAPPTR_ENC16
+#define DUK_USE_HEX_FASTPATH
+#define DUK_USE_HOBJECT_HASH_PART
+#define DUK_USE_HSTRING_CLEN
+#undef DUK_USE_HSTRING_EXTDATA
+#define DUK_USE_IDCHAR_FASTPATH
+#undef DUK_USE_INTERRUPT_COUNTER
+#undef DUK_USE_INTERRUPT_DEBUG_FIXUP
+#define DUK_USE_JC
+#define DUK_USE_JSON_DECNUMBER_FASTPATH
+#define DUK_USE_JSON_DECSTRING_FASTPATH
+#define DUK_USE_JSON_DEC_RECLIMIT 1000
+#define DUK_USE_JSON_EATWHITE_FASTPATH
+#define DUK_USE_JSON_ENC_RECLIMIT 1000
+#define DUK_USE_JSON_QUOTESTRING_FASTPATH
+#undef DUK_USE_JSON_STRINGIFY_FASTPATH
+#define DUK_USE_JX
+#define DUK_USE_LEXER_SLIDING_WINDOW
+#undef DUK_USE_LIGHTFUNC_BUILTINS
+#undef DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE
+#define DUK_USE_MARK_AND_SWEEP
+#define DUK_USE_MARK_AND_SWEEP_RECLIMIT 256
+#define DUK_USE_MATH_BUILTIN
+#define DUK_USE_MS_STRINGTABLE_RESIZE
+#define DUK_USE_NATIVE_CALL_RECLIMIT 1000
+#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER
+#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER
+#define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
+#undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
+#undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY
+#define DUK_USE_NONSTD_FUNC_STMT
+#define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT
+#define DUK_USE_NONSTD_JSON_ESC_U2028_U2029
+#define DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE
+#define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT
+#define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT
+#undef DUK_USE_OBJSIZES16
+#define DUK_USE_OCTAL_SUPPORT
+#define DUK_USE_PANIC_ABORT
+#undef DUK_USE_PANIC_EXIT
+#undef DUK_USE_PANIC_HANDLER
+#undef DUK_USE_PANIC_SEGFAULT
+#undef DUK_USE_PARANOID_ERRORS
+#define DUK_USE_PC2LINE
+#undef DUK_USE_PREFER_SIZE
+#define DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS
+#undef DUK_USE_REFCOUNT16
+#define DUK_USE_REFERENCE_COUNTING
+#undef DUK_USE_REFZERO_FINALIZER_TORTURE
+#undef DUK_USE_REGEXP_CANON_WORKAROUND
+#define DUK_USE_REGEXP_COMPILER_RECLIMIT 10000
+#define DUK_USE_REGEXP_EXECUTOR_RECLIMIT 10000
+#define DUK_USE_REGEXP_SUPPORT
+#undef DUK_USE_ROM_GLOBAL_CLONE
+#undef DUK_USE_ROM_GLOBAL_INHERIT
+#undef DUK_USE_ROM_OBJECTS
+#define DUK_USE_ROM_PTRCOMP_FIRST 63488L
+#undef DUK_USE_ROM_STRINGS
+#define DUK_USE_SECTION_B
+#undef DUK_USE_SELF_TESTS
+#undef DUK_USE_SHUFFLE_TORTURE
+#define DUK_USE_SOURCE_NONBMP
+#undef DUK_USE_STRHASH16
+#undef DUK_USE_STRHASH_DENSE
+#define DUK_USE_STRHASH_SKIP_SHIFT 5
+#define DUK_USE_STRICT_DECL
+#undef DUK_USE_STRICT_UTF8_SOURCE
+#undef DUK_USE_STRLEN16
+#undef DUK_USE_STRTAB_CHAIN
+#undef DUK_USE_STRTAB_CHAIN_SIZE
+#define DUK_USE_STRTAB_PROBE
+#define DUK_USE_TAILCALL
+#define DUK_USE_TARGET_INFO "unknown"
+#define DUK_USE_TRACEBACKS
+#define DUK_USE_TRACEBACK_DEPTH 10
+#define DUK_USE_USER_DECLARE() /* no user declarations */
+#undef DUK_USE_USER_INITJS
+#undef DUK_USE_VALSTACK_UNSAFE
+#define DUK_USE_VERBOSE_ERRORS
+#define DUK_USE_VERBOSE_EXECUTOR_ERRORS
+#define DUK_USE_VOLUNTARY_GC
+#define DUK_USE_ZERO_BUFFER_DATA
+
+/*
+ * Alternative customization header
+ *
+ * If you want to modify the final DUK_USE_xxx flags directly (without
+ * using the available DUK_OPT_xxx flags), define DUK_OPT_HAVE_CUSTOM_H
+ * and tweak the final flags there.
+ */
+
+#if defined(DUK_OPT_HAVE_CUSTOM_H)
+#include "duk_custom.h"
+#endif
+
+/*
+ * You may add overriding #define/#undef directives below for
+ * customization. You of course cannot un-#include or un-typedef
+ * anything; these require direct changes above.
+ */
+
+/* __OVERRIDE_DEFINES__ */
+
+/*
+ * Date provider selection
+ *
+ * User may define DUK_USE_DATE_GET_NOW() etc directly, in which case we'll
+ * rely on an external provider. If this is not done, revert to previous
+ * behavior and use Unix/Windows built-in provider.
+ */
+
+#if defined(DUK_COMPILING_DUKTAPE)
+
+#if defined(DUK_USE_DATE_GET_NOW)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_NOW_GETTIMEOFDAY)
+#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_gettimeofday((ctx))
+#elif defined(DUK_USE_DATE_NOW_TIME)
+#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_time((ctx))
+#elif defined(DUK_USE_DATE_NOW_WINDOWS)
+#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_windows((ctx))
+#else
+#error no provider for DUK_USE_DATE_GET_NOW()
+#endif
+
+#if defined(DUK_USE_DATE_GET_LOCAL_TZOFFSET)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_TZO_GMTIME_R) || defined(DUK_USE_DATE_TZO_GMTIME)
+#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_gmtime((d))
+#elif defined(DUK_USE_DATE_TZO_WINDOWS)
+#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_windows((d))
+#else
+#error no provider for DUK_USE_DATE_GET_LOCAL_TZOFFSET()
+#endif
+
+#if defined(DUK_USE_DATE_PARSE_STRING)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_PRS_STRPTIME)
+#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_strptime((ctx), (str))
+#elif defined(DUK_USE_DATE_PRS_GETDATE)
+#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_getdate((ctx), (str))
+#else
+/* No provider for DUK_USE_DATE_PARSE_STRING(), fall back to ISO 8601 only. */
+#endif
+
+#if defined(DUK_USE_DATE_FORMAT_STRING)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_FMT_STRFTIME)
+#define DUK_USE_DATE_FORMAT_STRING(ctx,parts,tzoffset,flags) \
+ duk_bi_date_format_parts_strftime((ctx), (parts), (tzoffset), (flags))
+#else
+/* No provider for DUK_USE_DATE_FORMAT_STRING(), fall back to ISO 8601 only. */
+#endif
+
+#endif /* DUK_COMPILING_DUKTAPE */
+
+/*
+ * Checks for legacy feature options (DUK_OPT_xxx)
+ */
+
+#if defined(DUK_OPT_ASSERTIONS)
+#error unsupported legacy feature option DUK_OPT_ASSERTIONS used, consider options: DUK_USE_ASSERTIONS
+#endif
+#if defined(DUK_OPT_BUFFEROBJECT_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_BUFFEROBJECT_SUPPORT used
+#endif
+#if defined(DUK_OPT_BUFLEN16)
+#error unsupported legacy feature option DUK_OPT_BUFLEN16 used
+#endif
+#if defined(DUK_OPT_DATAPTR16)
+#error unsupported legacy feature option DUK_OPT_DATAPTR16 used
+#endif
+#if defined(DUK_OPT_DATAPTR_DEC16)
+#error unsupported legacy feature option DUK_OPT_DATAPTR_DEC16 used
+#endif
+#if defined(DUK_OPT_DATAPTR_ENC16)
+#error unsupported legacy feature option DUK_OPT_DATAPTR_ENC16 used
+#endif
+#if defined(DUK_OPT_DDDPRINT)
+#error unsupported legacy feature option DUK_OPT_DDDPRINT used
+#endif
+#if defined(DUK_OPT_DDPRINT)
+#error unsupported legacy feature option DUK_OPT_DDPRINT used
+#endif
+#if defined(DUK_OPT_DEBUG)
+#error unsupported legacy feature option DUK_OPT_DEBUG used
+#endif
+#if defined(DUK_OPT_DEBUGGER_DUMPHEAP)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_DUMPHEAP used
+#endif
+#if defined(DUK_OPT_DEBUGGER_FWD_LOGGING)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_LOGGING used
+#endif
+#if defined(DUK_OPT_DEBUGGER_FWD_PRINTALERT)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_PRINTALERT used
+#endif
+#if defined(DUK_OPT_DEBUGGER_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_SUPPORT used
+#endif
+#if defined(DUK_OPT_DEBUGGER_TRANSPORT_TORTURE)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_TRANSPORT_TORTURE used
+#endif
+#if defined(DUK_OPT_DEBUG_BUFSIZE)
+#error unsupported legacy feature option DUK_OPT_DEBUG_BUFSIZE used
+#endif
+#if defined(DUK_OPT_DECLARE)
+#error unsupported legacy feature option DUK_OPT_DECLARE used
+#endif
+#if defined(DUK_OPT_DEEP_C_STACK)
+#error unsupported legacy feature option DUK_OPT_DEEP_C_STACK used
+#endif
+#if defined(DUK_OPT_DLL_BUILD)
+#error unsupported legacy feature option DUK_OPT_DLL_BUILD used
+#endif
+#if defined(DUK_OPT_DPRINT)
+#error unsupported legacy feature option DUK_OPT_DPRINT used
+#endif
+#if defined(DUK_OPT_DPRINT_COLORS)
+#error unsupported legacy feature option DUK_OPT_DPRINT_COLORS used
+#endif
+#if defined(DUK_OPT_DPRINT_RDTSC)
+#error unsupported legacy feature option DUK_OPT_DPRINT_RDTSC used
+#endif
+#if defined(DUK_OPT_EXEC_TIMEOUT_CHECK)
+#error unsupported legacy feature option DUK_OPT_EXEC_TIMEOUT_CHECK used
+#endif
+#if defined(DUK_OPT_EXTERNAL_STRINGS)
+#error unsupported legacy feature option DUK_OPT_EXTERNAL_STRINGS used, consider options: DUK_USE_HSTRING_EXTDATA
+#endif
+#if defined(DUK_OPT_EXTSTR_FREE)
+#error unsupported legacy feature option DUK_OPT_EXTSTR_FREE used
+#endif
+#if defined(DUK_OPT_EXTSTR_INTERN_CHECK)
+#error unsupported legacy feature option DUK_OPT_EXTSTR_INTERN_CHECK used
+#endif
+#if defined(DUK_OPT_FASTINT)
+#error unsupported legacy feature option DUK_OPT_FASTINT used, consider options: DUK_USE_FASTINT
+#endif
+#if defined(DUK_OPT_FORCE_ALIGN)
+#error unsupported legacy feature option DUK_OPT_FORCE_ALIGN used
+#endif
+#if defined(DUK_OPT_FORCE_BYTEORDER)
+#error unsupported legacy feature option DUK_OPT_FORCE_BYTEORDER used
+#endif
+#if defined(DUK_OPT_FUNCPTR16)
+#error unsupported legacy feature option DUK_OPT_FUNCPTR16 used
+#endif
+#if defined(DUK_OPT_FUNCPTR_DEC16)
+#error unsupported legacy feature option DUK_OPT_FUNCPTR_DEC16 used
+#endif
+#if defined(DUK_OPT_FUNCPTR_ENC16)
+#error unsupported legacy feature option DUK_OPT_FUNCPTR_ENC16 used
+#endif
+#if defined(DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY used
+#endif
+#if defined(DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY used
+#endif
+#if defined(DUK_OPT_GC_TORTURE)
+#error unsupported legacy feature option DUK_OPT_GC_TORTURE used
+#endif
+#if defined(DUK_OPT_HAVE_CUSTOM_H)
+#error unsupported legacy feature option DUK_OPT_HAVE_CUSTOM_H used
+#endif
+#if defined(DUK_OPT_HEAPPTR16)
+#error unsupported legacy feature option DUK_OPT_HEAPPTR16 used
+#endif
+#if defined(DUK_OPT_HEAPPTR_DEC16)
+#error unsupported legacy feature option DUK_OPT_HEAPPTR_DEC16 used
+#endif
+#if defined(DUK_OPT_HEAPPTR_ENC16)
+#error unsupported legacy feature option DUK_OPT_HEAPPTR_ENC16 used
+#endif
+#if defined(DUK_OPT_INTERRUPT_COUNTER)
+#error unsupported legacy feature option DUK_OPT_INTERRUPT_COUNTER used
+#endif
+#if defined(DUK_OPT_JSON_STRINGIFY_FASTPATH)
+#error unsupported legacy feature option DUK_OPT_JSON_STRINGIFY_FASTPATH used
+#endif
+#if defined(DUK_OPT_LIGHTFUNC_BUILTINS)
+#error unsupported legacy feature option DUK_OPT_LIGHTFUNC_BUILTINS used
+#endif
+#if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY used
+#endif
+#if defined(DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY used
+#endif
+#if defined(DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT)
+#error unsupported legacy feature option DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT used
+#endif
+#if defined(DUK_OPT_NO_AUGMENT_ERRORS)
+#error unsupported legacy feature option DUK_OPT_NO_AUGMENT_ERRORS used
+#endif
+#if defined(DUK_OPT_NO_BROWSER_LIKE)
+#error unsupported legacy feature option DUK_OPT_NO_BROWSER_LIKE used
+#endif
+#if defined(DUK_OPT_NO_BUFFEROBJECT_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_BUFFEROBJECT_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_BYTECODE_DUMP_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_BYTECODE_DUMP_SUPPORT used, consider options: DUK_USE_BYTECODE_DUMP_SUPPORT
+#endif
+#if defined(DUK_OPT_NO_COMMONJS_MODULES)
+#error unsupported legacy feature option DUK_OPT_NO_COMMONJS_MODULES used
+#endif
+#if defined(DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY used
+#endif
+#if defined(DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF)
+#error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF used
+#endif
+#if defined(DUK_OPT_NO_ES6_PROXY)
+#error unsupported legacy feature option DUK_OPT_NO_ES6_PROXY used
+#endif
+#if defined(DUK_OPT_NO_FILE_IO)
+#error unsupported legacy feature option DUK_OPT_NO_FILE_IO used, consider options: DUK_USE_FILE_IO
+#endif
+#if defined(DUK_OPT_NO_FUNC_STMT)
+#error unsupported legacy feature option DUK_OPT_NO_FUNC_STMT used
+#endif
+#if defined(DUK_OPT_NO_JC)
+#error unsupported legacy feature option DUK_OPT_NO_JC used
+#endif
+#if defined(DUK_OPT_NO_JSONC)
+#error unsupported legacy feature option DUK_OPT_NO_JSONC used
+#endif
+#if defined(DUK_OPT_NO_JSONX)
+#error unsupported legacy feature option DUK_OPT_NO_JSONX used
+#endif
+#if defined(DUK_OPT_NO_JX)
+#error unsupported legacy feature option DUK_OPT_NO_JX used
+#endif
+#if defined(DUK_OPT_NO_MARK_AND_SWEEP)
+#error unsupported legacy feature option DUK_OPT_NO_MARK_AND_SWEEP used
+#endif
+#if defined(DUK_OPT_NO_MS_STRINGTABLE_RESIZE)
+#error unsupported legacy feature option DUK_OPT_NO_MS_STRINGTABLE_RESIZE used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_FUNC_STMT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_FUNC_STMT used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029 used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT used
+#endif
+#if defined(DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY used
+#endif
+#if defined(DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF)
+#error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF used
+#endif
+#if defined(DUK_OPT_NO_OCTAL_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_OCTAL_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_PACKED_TVAL)
+#error unsupported legacy feature option DUK_OPT_NO_PACKED_TVAL used
+#endif
+#if defined(DUK_OPT_NO_PC2LINE)
+#error unsupported legacy feature option DUK_OPT_NO_PC2LINE used
+#endif
+#if defined(DUK_OPT_NO_REFERENCE_COUNTING)
+#error unsupported legacy feature option DUK_OPT_NO_REFERENCE_COUNTING used, consider options: DUK_USE_REFERENCE_COUNTING
+#endif
+#if defined(DUK_OPT_NO_REGEXP_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_REGEXP_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_SECTION_B)
+#error unsupported legacy feature option DUK_OPT_NO_SECTION_B used
+#endif
+#if defined(DUK_OPT_NO_SOURCE_NONBMP)
+#error unsupported legacy feature option DUK_OPT_NO_SOURCE_NONBMP used
+#endif
+#if defined(DUK_OPT_NO_STRICT_DECL)
+#error unsupported legacy feature option DUK_OPT_NO_STRICT_DECL used
+#endif
+#if defined(DUK_OPT_NO_TRACEBACKS)
+#error unsupported legacy feature option DUK_OPT_NO_TRACEBACKS used
+#endif
+#if defined(DUK_OPT_NO_VERBOSE_ERRORS)
+#error unsupported legacy feature option DUK_OPT_NO_VERBOSE_ERRORS used
+#endif
+#if defined(DUK_OPT_NO_VOLUNTARY_GC)
+#error unsupported legacy feature option DUK_OPT_NO_VOLUNTARY_GC used
+#endif
+#if defined(DUK_OPT_NO_ZERO_BUFFER_DATA)
+#error unsupported legacy feature option DUK_OPT_NO_ZERO_BUFFER_DATA used
+#endif
+#if defined(DUK_OPT_OBJSIZES16)
+#error unsupported legacy feature option DUK_OPT_OBJSIZES16 used
+#endif
+#if defined(DUK_OPT_PANIC_HANDLER)
+#error unsupported legacy feature option DUK_OPT_PANIC_HANDLER used
+#endif
+#if defined(DUK_OPT_REFCOUNT16)
+#error unsupported legacy feature option DUK_OPT_REFCOUNT16 used
+#endif
+#if defined(DUK_OPT_SEGFAULT_ON_PANIC)
+#error unsupported legacy feature option DUK_OPT_SEGFAULT_ON_PANIC used
+#endif
+#if defined(DUK_OPT_SELF_TESTS)
+#error unsupported legacy feature option DUK_OPT_SELF_TESTS used
+#endif
+#if defined(DUK_OPT_SETJMP)
+#error unsupported legacy feature option DUK_OPT_SETJMP used
+#endif
+#if defined(DUK_OPT_SHUFFLE_TORTURE)
+#error unsupported legacy feature option DUK_OPT_SHUFFLE_TORTURE used
+#endif
+#if defined(DUK_OPT_SIGSETJMP)
+#error unsupported legacy feature option DUK_OPT_SIGSETJMP used
+#endif
+#if defined(DUK_OPT_STRHASH16)
+#error unsupported legacy feature option DUK_OPT_STRHASH16 used
+#endif
+#if defined(DUK_OPT_STRICT_UTF8_SOURCE)
+#error unsupported legacy feature option DUK_OPT_STRICT_UTF8_SOURCE used
+#endif
+#if defined(DUK_OPT_STRLEN16)
+#error unsupported legacy feature option DUK_OPT_STRLEN16 used
+#endif
+#if defined(DUK_OPT_STRTAB_CHAIN)
+#error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN used
+#endif
+#if defined(DUK_OPT_STRTAB_CHAIN_SIZE)
+#error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN_SIZE used
+#endif
+#if defined(DUK_OPT_TARGET_INFO)
+#error unsupported legacy feature option DUK_OPT_TARGET_INFO used
+#endif
+#if defined(DUK_OPT_TRACEBACK_DEPTH)
+#error unsupported legacy feature option DUK_OPT_TRACEBACK_DEPTH used
+#endif
+#if defined(DUK_OPT_UNDERSCORE_SETJMP)
+#error unsupported legacy feature option DUK_OPT_UNDERSCORE_SETJMP used
+#endif
+#if defined(DUK_OPT_USER_INITJS)
+#error unsupported legacy feature option DUK_OPT_USER_INITJS used
+#endif
+
+/*
+ * Checks for config option consistency (DUK_USE_xxx)
+ */
+
+#if defined(DUK_USE_32BIT_PTRS)
+#error unsupported config option used (option has been removed): DUK_USE_32BIT_PTRS
+#endif
+#if defined(DUK_USE_ALIGN_4)
+#error unsupported config option used (option has been removed): DUK_USE_ALIGN_4
+#endif
+#if defined(DUK_USE_ALIGN_8)
+#error unsupported config option used (option has been removed): DUK_USE_ALIGN_8
+#endif
+#if defined(DUK_USE_BYTEORDER_FORCED)
+#error unsupported config option used (option has been removed): DUK_USE_BYTEORDER_FORCED
+#endif
+#if defined(DUK_USE_DATAPTR_DEC16) && !defined(DUK_USE_DATAPTR16)
+#error config option DUK_USE_DATAPTR_DEC16 requires option DUK_USE_DATAPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_DATAPTR_ENC16) && !defined(DUK_USE_DATAPTR16)
+#error config option DUK_USE_DATAPTR_ENC16 requires option DUK_USE_DATAPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_DEBUGGER_SUPPORT) && !defined(DUK_USE_INTERRUPT_COUNTER)
+#error config option DUK_USE_DEBUGGER_SUPPORT requires option DUK_USE_INTERRUPT_COUNTER (which is missing)
+#endif
+#if defined(DUK_USE_DEEP_C_STACK)
+#error unsupported config option used (option has been removed): DUK_USE_DEEP_C_STACK
+#endif
+#if defined(DUK_USE_DOUBLE_BE)
+#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_BE
+#endif
+#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_LE)
+#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_LE (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_ME)
+#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_ME (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_LE)
+#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_LE
+#endif
+#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_BE)
+#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_BE (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_ME)
+#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_ME (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_ME)
+#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_ME
+#endif
+#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_LE)
+#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_LE (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_BE)
+#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_BE (which is also defined)
+#endif
+#if defined(DUK_USE_DPRINT) && !defined(DUK_USE_DEBUG)
+#error config option DUK_USE_DPRINT requires option DUK_USE_DEBUG (which is missing)
+#endif
+#if defined(DUK_USE_ESBC_MAX_BYTES) && !defined(DUK_USE_ESBC_LIMITS)
+#error config option DUK_USE_ESBC_MAX_BYTES requires option DUK_USE_ESBC_LIMITS (which is missing)
+#endif
+#if defined(DUK_USE_ESBC_MAX_LINENUMBER) && !defined(DUK_USE_ESBC_LIMITS)
+#error config option DUK_USE_ESBC_MAX_LINENUMBER requires option DUK_USE_ESBC_LIMITS (which is missing)
+#endif
+#if defined(DUK_USE_EXEC_TIMEOUT_CHECK) && !defined(DUK_USE_INTERRUPT_COUNTER)
+#error config option DUK_USE_EXEC_TIMEOUT_CHECK requires option DUK_USE_INTERRUPT_COUNTER (which is missing)
+#endif
+#if defined(DUK_USE_EXTSTR_FREE) && !defined(DUK_USE_HSTRING_EXTDATA)
+#error config option DUK_USE_EXTSTR_FREE requires option DUK_USE_HSTRING_EXTDATA (which is missing)
+#endif
+#if defined(DUK_USE_EXTSTR_INTERN_CHECK) && !defined(DUK_USE_HSTRING_EXTDATA)
+#error config option DUK_USE_EXTSTR_INTERN_CHECK requires option DUK_USE_HSTRING_EXTDATA (which is missing)
+#endif
+#if defined(DUK_USE_FULL_TVAL)
+#error unsupported config option used (option has been removed): DUK_USE_FULL_TVAL
+#endif
+#if defined(DUK_USE_FUNCPTR_DEC16) && !defined(DUK_USE_FUNCPTR16)
+#error config option DUK_USE_FUNCPTR_DEC16 requires option DUK_USE_FUNCPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_FUNCPTR_ENC16) && !defined(DUK_USE_FUNCPTR16)
+#error config option DUK_USE_FUNCPTR_ENC16 requires option DUK_USE_FUNCPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS)
+#error unsupported config option used (option has been removed): DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS
+#endif
+#if defined(DUK_USE_HEAPPTR16) && defined(DUK_USE_DEBUG)
+#error config option DUK_USE_HEAPPTR16 conflicts with option DUK_USE_DEBUG (which is also defined)
+#endif
+#if defined(DUK_USE_HEAPPTR_DEC16) && !defined(DUK_USE_HEAPPTR16)
+#error config option DUK_USE_HEAPPTR_DEC16 requires option DUK_USE_HEAPPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_HEAPPTR_ENC16) && !defined(DUK_USE_HEAPPTR16)
+#error config option DUK_USE_HEAPPTR_ENC16 requires option DUK_USE_HEAPPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_INTEGER_BE)
+#error unsupported config option used (option has been removed): DUK_USE_INTEGER_BE
+#endif
+#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_LE)
+#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_LE (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_ME)
+#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_ME (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_LE)
+#error unsupported config option used (option has been removed): DUK_USE_INTEGER_LE
+#endif
+#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_BE)
+#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_BE (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_ME)
+#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_ME (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_ME)
+#error unsupported config option used (option has been removed): DUK_USE_INTEGER_ME
+#endif
+#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_LE)
+#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_LE (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_BE)
+#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_BE (which is also defined)
+#endif
+#if defined(DUK_USE_NO_DOUBLE_ALIASING_SELFTEST)
+#error unsupported config option used (option has been removed): DUK_USE_NO_DOUBLE_ALIASING_SELFTEST
+#endif
+#if defined(DUK_USE_PACKED_TVAL_POSSIBLE)
+#error unsupported config option used (option has been removed): DUK_USE_PACKED_TVAL_POSSIBLE
+#endif
+#if defined(DUK_USE_RDTSC)
+#error unsupported config option used (option has been removed): DUK_USE_RDTSC
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_STRINGS)
+#error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_STRINGS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_OBJECTS)
+#error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_OBJECTS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_CLONE) && defined(DUK_USE_ROM_GLOBAL_INHERIT)
+#error config option DUK_USE_ROM_GLOBAL_CLONE conflicts with option DUK_USE_ROM_GLOBAL_INHERIT (which is also defined)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_STRINGS)
+#error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_STRINGS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_OBJECTS)
+#error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_OBJECTS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && defined(DUK_USE_ROM_GLOBAL_CLONE)
+#error config option DUK_USE_ROM_GLOBAL_INHERIT conflicts with option DUK_USE_ROM_GLOBAL_CLONE (which is also defined)
+#endif
+#if defined(DUK_USE_ROM_OBJECTS) && !defined(DUK_USE_ROM_STRINGS)
+#error config option DUK_USE_ROM_OBJECTS requires option DUK_USE_ROM_STRINGS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_STRINGS) && !defined(DUK_USE_ROM_OBJECTS)
+#error config option DUK_USE_ROM_STRINGS requires option DUK_USE_ROM_OBJECTS (which is missing)
+#endif
+#if defined(DUK_USE_SETJMP)
+#error unsupported config option used (option has been removed): DUK_USE_SETJMP
+#endif
+#if defined(DUK_USE_SIGSETJMP)
+#error unsupported config option used (option has been removed): DUK_USE_SIGSETJMP
+#endif
+#if defined(DUK_USE_STRTAB_CHAIN_SIZE) && !defined(DUK_USE_STRTAB_CHAIN)
+#error config option DUK_USE_STRTAB_CHAIN_SIZE requires option DUK_USE_STRTAB_CHAIN (which is missing)
+#endif
+#if defined(DUK_USE_TAILCALL) && defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
+#error config option DUK_USE_TAILCALL conflicts with option DUK_USE_NONSTD_FUNC_CALLER_PROPERTY (which is also defined)
+#endif
+#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE)
+#error unsupported config option used (option has been removed): DUK_USE_UNALIGNED_ACCESSES_POSSIBLE
+#endif
+#if defined(DUK_USE_UNDERSCORE_SETJMP)
+#error unsupported config option used (option has been removed): DUK_USE_UNDERSCORE_SETJMP
+#endif
+
+#if defined(DUK_USE_CPP_EXCEPTIONS) && !defined(__cplusplus)
+#error DUK_USE_CPP_EXCEPTIONS enabled but not compiling with a C++ compiler
+#endif
+
+/*
+ * Convert DUK_USE_BYTEORDER, from whatever source, into currently used
+ * internal defines. If detection failed, #error out.
+ */
+
+#if defined(DUK_USE_BYTEORDER)
+#if (DUK_USE_BYTEORDER == 1)
+#define DUK_USE_INTEGER_LE
+#define DUK_USE_DOUBLE_LE
+#elif (DUK_USE_BYTEORDER == 2)
+#define DUK_USE_INTEGER_LE /* integer endianness is little on purpose */
+#define DUK_USE_DOUBLE_ME
+#elif (DUK_USE_BYTEORDER == 3)
+#define DUK_USE_INTEGER_BE
+#define DUK_USE_DOUBLE_BE
+#else
+#error unsupported: byte order invalid
+#endif /* byte order */
+#else
+#error unsupported: byte order detection failed
+#endif /* defined(DUK_USE_BYTEORDER) */
+
+#endif /* DUK_CONFIG_H_INCLUDED */
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/duk_config.h-modular-static b/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/duk_config.h-modular-static
new file mode 100644
index 000000000..b2b5a38a4
--- /dev/null
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/duk_config.h-modular-static
@@ -0,0 +1,3415 @@
+/*
+ * duk_config.h configuration header generated by genconfig.py.
+ *
+ * Git commit: cad34ae155acb0846545ca6bf2d29f9463b22bbb
+ * Git describe: v1.5.2
+ * Git branch: HEAD
+ *
+ * Supported platforms:
+ * - Mac OSX, iPhone, Darwin
+ * - OpenBSD
+ * - Generic BSD
+ * - Atari ST TOS
+ * - AmigaOS
+ * - Windows
+ * - Flashplayer (Crossbridge)
+ * - QNX
+ * - TI-Nspire
+ * - Emscripten
+ * - Linux
+ * - Solaris
+ * - Generic POSIX
+ * - Cygwin
+ * - Generic UNIX
+ * - Generic fallback
+ *
+ * Supported architectures:
+ * - x86
+ * - x64
+ * - x32
+ * - ARM 32-bit
+ * - ARM 64-bit
+ * - MIPS 32-bit
+ * - MIPS 64-bit
+ * - PowerPC 32-bit
+ * - PowerPC 64-bit
+ * - SPARC 32-bit
+ * - SPARC 64-bit
+ * - SuperH
+ * - Motorola 68k
+ * - Emscripten
+ * - Generic
+ *
+ * Supported compilers:
+ * - Clang
+ * - GCC
+ * - MSVC
+ * - Emscripten
+ * - TinyC
+ * - VBCC
+ * - Bruce's C compiler
+ * - Generic
+ *
+ */
+
+#if !defined(DUK_CONFIG_H_INCLUDED)
+#define DUK_CONFIG_H_INCLUDED
+
+/*
+ * Intermediate helper defines
+ */
+
+/* DLL build detection */
+#if defined(DUK_OPT_DLL_BUILD)
+#define DUK_F_DLL_BUILD
+#elif defined(DUK_OPT_NO_DLL_BUILD)
+#undef DUK_F_DLL_BUILD
+#else
+/* not configured for DLL build */
+#undef DUK_F_DLL_BUILD
+#endif
+
+/* Apple OSX, iOS */
+#if defined(__APPLE__)
+#define DUK_F_APPLE
+#endif
+
+/* OpenBSD */
+#if defined(__OpenBSD__) || defined(__OpenBSD)
+#define DUK_F_OPENBSD
+#endif
+
+/* NetBSD */
+#if defined(__NetBSD__) || defined(__NetBSD)
+#define DUK_F_NETBSD
+#endif
+
+/* FreeBSD */
+#if defined(__FreeBSD__) || defined(__FreeBSD)
+#define DUK_F_FREEBSD
+#endif
+
+/* BSD variant */
+#if defined(DUK_F_FREEBSD) || defined(DUK_F_NETBSD) || defined(DUK_F_OPENBSD) || \
+ defined(__bsdi__) || defined(__DragonFly__)
+#define DUK_F_BSD
+#endif
+
+/* Atari ST TOS. __TOS__ defined by PureC. No platform define in VBCC
+ * apparently, so to use with VBCC user must define __TOS__ manually.
+ */
+#if defined(__TOS__)
+#define DUK_F_TOS
+#endif
+
+/* Motorola 68K. Not defined by VBCC, so user must define one of these
+ * manually when using VBCC.
+ */
+#if defined(__m68k__) || defined(M68000) || defined(__MC68K__)
+#define DUK_F_M68K
+#endif
+
+/* AmigaOS. Neither AMIGA nor __amigaos__ is defined on VBCC, so user must
+ * define 'AMIGA' manually when using VBCC.
+ */
+#if defined(AMIGA) || defined(__amigaos__)
+#define DUK_F_AMIGAOS
+#endif
+
+/* PowerPC */
+#if defined(__powerpc) || defined(__powerpc__) || defined(__PPC__)
+#define DUK_F_PPC
+#if defined(__PPC64__) || defined(__LP64__) || defined(_LP64)
+#define DUK_F_PPC64
+#else
+#define DUK_F_PPC32
+#endif
+#endif
+
+/* Windows, both 32-bit and 64-bit */
+#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \
+ defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__)
+#define DUK_F_WINDOWS
+#if defined(_WIN64) || defined(WIN64)
+#define DUK_F_WIN64
+#else
+#define DUK_F_WIN32
+#endif
+#endif
+
+/* Flash player (e.g. Crossbridge) */
+#if defined(__FLASHPLAYER__)
+#define DUK_F_FLASHPLAYER
+#endif
+
+/* QNX */
+#if defined(__QNX__)
+#define DUK_F_QNX
+#endif
+
+/* TI-Nspire (using Ndless) */
+#if defined(_TINSPIRE)
+#define DUK_F_TINSPIRE
+#endif
+
+/* Emscripten (provided explicitly by user), improve if possible */
+#if defined(EMSCRIPTEN)
+#define DUK_F_EMSCRIPTEN
+#endif
+
+/* BCC (Bruce's C compiler): this is a "torture target" for compilation */
+#if defined(__BCC__) || defined(__BCC_VERSION__)
+#define DUK_F_BCC
+#endif
+
+/* Linux */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+#define DUK_F_LINUX
+#endif
+
+/* illumos / Solaris */
+#if defined(__sun) && defined(__SVR4)
+#define DUK_F_SUN
+#endif
+
+/* POSIX */
+#if defined(__posix)
+#define DUK_F_POSIX
+#endif
+
+/* Cygwin */
+#if defined(__CYGWIN__)
+#define DUK_F_CYGWIN
+#endif
+
+/* Generic Unix (includes Cygwin) */
+#if defined(__unix) || defined(__unix__) || defined(unix) || \
+ defined(DUK_F_LINUX) || defined(DUK_F_BSD)
+#define DUK_F_UNIX
+#endif
+
+/* stdint.h not available */
+#if defined(DUK_F_WINDOWS) && defined(_MSC_VER)
+#if (_MSC_VER < 1700)
+/* VS2012+ has stdint.h, < VS2012 does not (but it's available for download). */
+#define DUK_F_NO_STDINT_H
+#endif
+#endif
+#if !defined(DUK_F_NO_STDINT_H) && (defined(DUK_F_TOS) || defined(DUK_F_BCC))
+#define DUK_F_NO_STDINT_H
+#endif
+
+/* C++ */
+#undef DUK_F_CPP
+#if defined(__cplusplus)
+#define DUK_F_CPP
+#endif
+
+/* Intel x86 (32-bit), x64 (64-bit) or x32 (64-bit but 32-bit pointers),
+ * define only one of DUK_F_X86, DUK_F_X64, DUK_F_X32.
+ * https://sites.google.com/site/x32abi/
+ */
+#if defined(__amd64__) || defined(__amd64) || \
+ defined(__x86_64__) || defined(__x86_64) || \
+ defined(_M_X64) || defined(_M_AMD64)
+#if defined(__ILP32__) || defined(_ILP32)
+#define DUK_F_X32
+#else
+#define DUK_F_X64
+#endif
+#elif defined(i386) || defined(__i386) || defined(__i386__) || \
+ defined(__i486__) || defined(__i586__) || defined(__i686__) || \
+ defined(__IA32__) || defined(_M_IX86) || defined(__X86__) || \
+ defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__)
+#if defined(__LP64__) || defined(_LP64)
+/* This should not really happen, but would indicate x64. */
+#define DUK_F_X64
+#else
+#define DUK_F_X86
+#endif
+#endif
+
+/* ARM */
+#if defined(__arm__) || defined(__thumb__) || defined(_ARM) || defined(_M_ARM)
+#define DUK_F_ARM
+#if defined(__LP64__) || defined(_LP64) || defined(__arm64) || defined(__arm64__)
+#define DUK_F_ARM64
+#else
+#define DUK_F_ARM32
+#endif
+#endif
+
+/* MIPS. Related defines: __MIPSEB__, __MIPSEL__, __mips_isa_rev, __LP64__ */
+#if defined(__mips__) || defined(mips) || defined(_MIPS_ISA) || \
+ defined(_R3000) || defined(_R4000) || defined(_R5900) || \
+ defined(_MIPS_ISA_MIPS1) || defined(_MIPS_ISA_MIPS2) || \
+ defined(_MIPS_ISA_MIPS3) || defined(_MIPS_ISA_MIPS4) || \
+ defined(__mips) || defined(__MIPS__)
+#define DUK_F_MIPS
+#if defined(__LP64__) || defined(_LP64) || defined(__mips64) || \
+ defined(__mips64__) || defined(__mips_n64)
+#define DUK_F_MIPS64
+#else
+#define DUK_F_MIPS32
+#endif
+#endif
+
+/* SPARC */
+#if defined(sparc) || defined(__sparc) || defined(__sparc__)
+#define DUK_F_SPARC
+#if defined(__LP64__) || defined(_LP64)
+#define DUK_F_SPARC64
+#else
+#define DUK_F_SPARC32
+#endif
+#endif
+
+/* SuperH */
+#if defined(__sh__) || \
+ defined(__sh1__) || defined(__SH1__) || \
+ defined(__sh2__) || defined(__SH2__) || \
+ defined(__sh3__) || defined(__SH3__) || \
+ defined(__sh4__) || defined(__SH4__) || \
+ defined(__sh5__) || defined(__SH5__)
+#define DUK_F_SUPERH
+#endif
+
+/* Clang */
+#if defined(__clang__)
+#define DUK_F_CLANG
+#endif
+
+/* C99 or above */
+#undef DUK_F_C99
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#define DUK_F_C99
+#endif
+
+/* C++11 or above */
+#undef DUK_F_CPP11
+#if defined(__cplusplus) && (__cplusplus >= 201103L)
+#define DUK_F_CPP11
+#endif
+
+/* GCC. Clang also defines __GNUC__ so don't detect GCC if using Clang. */
+#if defined(__GNUC__) && !defined(__clang__) && !defined(DUK_F_CLANG)
+#define DUK_F_GCC
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
+/* Convenience, e.g. gcc 4.5.1 == 40501; http://stackoverflow.com/questions/6031819/emulating-gccs-builtin-unreachable */
+#define DUK_F_GCC_VERSION (__GNUC__ * 10000L + __GNUC_MINOR__ * 100L + __GNUC_PATCHLEVEL__)
+#else
+#error cannot figure out gcc version
+#endif
+#endif
+
+/* MinGW. Also GCC flags (DUK_F_GCC) are enabled now. */
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#define DUK_F_MINGW
+#endif
+
+/* MSVC */
+#if defined(_MSC_VER)
+/* MSVC preprocessor defines: http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+ * _MSC_FULL_VER includes the build number, but it has at least two formats, see e.g.
+ * BOOST_MSVC_FULL_VER in http://www.boost.org/doc/libs/1_52_0/boost/config/compiler/visualc.hpp
+ */
+#define DUK_F_MSVC
+#if defined(_MSC_FULL_VER)
+#if (_MSC_FULL_VER > 100000000)
+#define DUK_F_MSVC_FULL_VER _MSC_FULL_VER
+#else
+#define DUK_F_MSCV_FULL_VER (_MSC_FULL_VER * 10)
+#endif
+#endif
+#endif /* _MSC_VER */
+
+/* TinyC */
+#if defined(__TINYC__)
+/* http://bellard.org/tcc/tcc-doc.html#SEC9 */
+#define DUK_F_TINYC
+#endif
+
+/* VBCC */
+#if defined(__VBCC__)
+#define DUK_F_VBCC
+#endif
+
+/* Atari Mint */
+#if defined(__MINT__)
+#define DUK_F_MINT
+#endif
+
+/*
+ * Platform autodetection
+ */
+
+/* Workaround for older C++ compilers before including ,
+ * see e.g.: https://sourceware.org/bugzilla/show_bug.cgi?id=15366
+ */
+#if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS)
+#define __STDC_LIMIT_MACROS
+#endif
+#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS)
+#define __STDC_CONSTANT_MACROS
+#endif
+
+#if defined(DUK_F_APPLE)
+/* --- Mac OSX, iPhone, Darwin --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+/* http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor */
+#if TARGET_IPHONE_SIMULATOR
+#define DUK_USE_OS_STRING "iphone-sim"
+#elif TARGET_OS_IPHONE
+#define DUK_USE_OS_STRING "iphone"
+#elif TARGET_OS_MAC
+#define DUK_USE_OS_STRING "osx"
+#else
+#define DUK_USE_OS_STRING "osx-unknown"
+#endif
+
+/* Use _setjmp() on Apple by default, see GH-55. */
+#define DUK_JMPBUF_TYPE jmp_buf
+#define DUK_SETJMP(jb) _setjmp((jb))
+#define DUK_LONGJMP(jb) _longjmp((jb), 1)
+#elif defined(DUK_F_OPENBSD)
+/* --- OpenBSD --- */
+/* http://www.monkey.org/openbsd/archive/ports/0401/msg00089.html */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "openbsd"
+#elif defined(DUK_F_BSD)
+/* --- Generic BSD --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "bsd"
+#elif defined(DUK_F_TOS)
+/* --- Atari ST TOS --- */
+#define DUK_USE_DATE_NOW_TIME
+#define DUK_USE_DATE_TZO_GMTIME
+/* no parsing (not an error) */
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+
+#define DUK_USE_OS_STRING "tos"
+
+/* TOS on M68K is always big endian. */
+#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_M68K)
+#define DUK_USE_BYTEORDER 3
+#endif
+#elif defined(DUK_F_AMIGAOS)
+/* --- AmigaOS --- */
+#if defined(DUK_F_M68K)
+/* AmigaOS on M68k */
+#define DUK_USE_DATE_NOW_TIME
+#define DUK_USE_DATE_TZO_GMTIME
+/* no parsing (not an error) */
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#elif defined(DUK_F_PPC)
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#ifndef UINTPTR_MAX
+#define UINTPTR_MAX UINT_MAX
+#endif
+#else
+#error AmigaOS but not M68K/PPC, not supported now
+#endif
+
+#define DUK_USE_OS_STRING "amigaos"
+
+/* AmigaOS on M68K or PPC is always big endian. */
+#if !defined(DUK_USE_BYTEORDER) && (defined(DUK_F_M68K) || defined(DUK_F_PPC))
+#define DUK_USE_BYTEORDER 3
+#endif
+#elif defined(DUK_F_WINDOWS)
+/* --- Windows --- */
+/* Initial fix: disable secure CRT related warnings when compiling Duktape
+ * itself (must be defined before including Windows headers). Don't define
+ * for user code including duktape.h.
+ */
+#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+/* Windows 32-bit and 64-bit are currently the same. */
+/* MSVC does not have sys/param.h */
+#define DUK_USE_DATE_NOW_WINDOWS
+#define DUK_USE_DATE_TZO_WINDOWS
+/* Note: PRS and FMT are intentionally left undefined for now. This means
+ * there is no platform specific date parsing/formatting but there is still
+ * the ISO 8601 standard format.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+/* Only include when compiling Duktape to avoid polluting application build
+ * with a lot of unnecessary defines.
+ */
+#include
+#endif
+
+#define DUK_USE_OS_STRING "windows"
+
+/* On Windows, assume we're little endian. Even Itanium which has a
+ * configurable endianness runs little endian in Windows.
+ */
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#elif defined(DUK_F_FLASHPLAYER)
+/* --- Flashplayer (Crossbridge) --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "flashplayer"
+
+#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_FLASHPLAYER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#elif defined(DUK_F_QNX)
+/* --- QNX --- */
+#if defined(DUK_F_QNX) && defined(DUK_COMPILING_DUKTAPE)
+/* See: /opt/qnx650/target/qnx6/usr/include/sys/platform.h */
+#define _XOPEN_SOURCE 600
+#define _POSIX_C_SOURCE 200112L
+#endif
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "qnx"
+#elif defined(DUK_F_TINSPIRE)
+/* --- TI-Nspire --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "tinspire"
+#elif defined(DUK_F_EMSCRIPTEN)
+/* --- Emscripten --- */
+#if defined(DUK_COMPILING_DUKTAPE)
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#endif
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE /* e.g. getdate_r */
+#endif
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE /* e.g. strptime */
+#endif
+#endif /* DUK_COMPILING_DUKTAPE */
+
+#include
+#if defined(DUK_F_BCC)
+/* no endian.h */
+#else
+#include
+#endif /* DUK_F_BCC */
+#include
+#include
+#include
+#include
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+
+#define DUK_USE_OS_STRING "emscripten"
+#elif defined(DUK_F_LINUX)
+/* --- Linux --- */
+#if defined(DUK_COMPILING_DUKTAPE)
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#endif
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE /* e.g. getdate_r */
+#endif
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE /* e.g. strptime */
+#endif
+#endif /* DUK_COMPILING_DUKTAPE */
+
+#include
+#if defined(DUK_F_BCC)
+/* no endian.h or stdint.h */
+#else
+#include
+#include
+#endif /* DUK_F_BCC */
+#include
+#include
+#include
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+
+#define DUK_USE_OS_STRING "linux"
+#elif defined(DUK_F_SUN)
+/* --- Solaris --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "solaris"
+#elif defined(DUK_F_POSIX)
+/* --- Generic POSIX --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_USE_OS_STRING "posix"
+#elif defined(DUK_F_CYGWIN)
+/* --- Cygwin --- */
+/* don't use strptime() for now */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#include
+#include
+#include
+
+#define DUK_JMPBUF_TYPE jmp_buf
+#define DUK_SETJMP(jb) _setjmp((jb))
+#define DUK_LONGJMP(jb) _longjmp((jb), 1)
+
+#define DUK_USE_OS_STRING "windows"
+#elif defined(DUK_F_UNIX)
+/* --- Generic UNIX --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include
+#include
+#define DUK_USE_OS_STRING "unknown"
+#else
+/* --- Generic fallback --- */
+/* The most portable current time provider is time(), but it only has a
+ * one second resolution.
+ */
+#define DUK_USE_DATE_NOW_TIME
+
+/* The most portable way to figure out local time offset is gmtime(),
+ * but it's not thread safe so use with caution.
+ */
+#define DUK_USE_DATE_TZO_GMTIME
+
+/* Avoid custom date parsing and formatting for portability. */
+#undef DUK_USE_DATE_PRS_STRPTIME
+#undef DUK_USE_DATE_FMT_STRFTIME
+
+/* Rely on C89 headers only; time.h must be here. */
+#include
+
+#define DUK_USE_OS_STRING "unknown"
+#endif /* autodetect platform */
+
+/* Shared includes: C89 */
+#include
+#include
+#include
+#include /* varargs */
+#include
+#include /* e.g. ptrdiff_t */
+#include
+#include
+
+/* date.h is omitted, and included per platform */
+
+/* Shared includes: stdint.h is C99 */
+#if defined(DUK_F_NO_STDINT_H)
+/* stdint.h not available */
+#else
+/* Technically C99 (C++11) but found in many systems. On some systems
+ * __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS must be defined before
+ * including stdint.h (see above).
+ */
+#include
+#endif
+
+#if defined(DUK_F_CPP)
+#include /* std::exception */
+#endif
+
+/*
+ * Architecture autodetection
+ */
+
+#if defined(DUK_F_X86)
+/* --- x86 --- */
+#define DUK_USE_ARCH_STRING "x86"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+/* XXX: This is technically not guaranteed because it's possible to configure
+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 1
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_X64)
+/* --- x64 --- */
+#define DUK_USE_ARCH_STRING "x64"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+/* XXX: This is technically not guaranteed because it's possible to configure
+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 1
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_X32)
+/* --- x32 --- */
+#define DUK_USE_ARCH_STRING "x32"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+/* XXX: This is technically not guaranteed because it's possible to configure
+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 1
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_ARM32)
+/* --- ARM 32-bit --- */
+#define DUK_USE_ARCH_STRING "arm32"
+/* Byte order varies, so rely on autodetect. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 4
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_ARM64)
+/* --- ARM 64-bit --- */
+#define DUK_USE_ARCH_STRING "arm64"
+/* Byte order varies, so rely on autodetect. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_MIPS32)
+/* --- MIPS 32-bit --- */
+#define DUK_USE_ARCH_STRING "mips32"
+/* MIPS byte order varies so rely on autodetection. */
+/* Based on 'make checkalign' there are no alignment requirements on
+ * Linux MIPS except for doubles, which need align by 4. Alignment
+ * requirements vary based on target though.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 4
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_MIPS64)
+/* --- MIPS 64-bit --- */
+#define DUK_USE_ARCH_STRING "mips64"
+/* MIPS byte order varies so rely on autodetection. */
+/* Good default is a bit arbitrary because alignment requirements
+ * depend on target. See https://github.com/svaarala/duktape/issues/102.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_PPC32)
+/* --- PowerPC 32-bit --- */
+#define DUK_USE_ARCH_STRING "ppc32"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_PPC64)
+/* --- PowerPC 64-bit --- */
+#define DUK_USE_ARCH_STRING "ppc64"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_SPARC32)
+/* --- SPARC 32-bit --- */
+#define DUK_USE_ARCH_STRING "sparc32"
+/* SPARC byte order varies so rely on autodetection. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_SPARC64)
+/* --- SPARC 64-bit --- */
+#define DUK_USE_ARCH_STRING "sparc64"
+/* SPARC byte order varies so rely on autodetection. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_SUPERH)
+/* --- SuperH --- */
+#define DUK_USE_ARCH_STRING "sh"
+/* Byte order varies, rely on autodetection. */
+/* Based on 'make checkalign' there are no alignment requirements on
+ * Linux SH4, but align by 4 is probably a good basic default.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 4
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_M68K)
+/* --- Motorola 68k --- */
+#define DUK_USE_ARCH_STRING "m68k"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_EMSCRIPTEN)
+/* --- Emscripten --- */
+#define DUK_USE_ARCH_STRING "emscripten"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#else
+/* --- Generic --- */
+/* These are necessary wild guesses. */
+#define DUK_USE_ARCH_STRING "generic"
+/* Rely on autodetection for byte order, alignment, and packed tval. */
+#endif /* autodetect architecture */
+
+/*
+ * Compiler autodetection
+ */
+
+#if defined(DUK_F_CLANG)
+/* --- Clang --- */
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+/* C99 / C++11 and above: rely on va_copy() which is required. */
+#define DUK_VA_COPY(dest,src) va_copy(dest,src)
+#else
+/* Clang: assume we have __va_copy() in non-C99 mode. */
+#define DUK_VA_COPY(dest,src) __va_copy(dest,src)
+#endif
+
+#define DUK_NORETURN(decl) decl __attribute__((noreturn))
+
+#if defined(__clang__) && defined(__has_builtin)
+#if __has_builtin(__builtin_unreachable)
+#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0)
+#endif
+#endif
+
+#define DUK_USE_BRANCH_HINTS
+#define DUK_LIKELY(x) __builtin_expect((x), 1)
+#define DUK_UNLIKELY(x) __builtin_expect((x), 0)
+
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_NOINLINE __attribute__((noinline))
+#define DUK_INLINE inline
+#define DUK_ALWAYS_INLINE inline __attribute__((always_inline))
+#endif
+
+#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL extern __declspec(dllexport)
+#define DUK_EXTERNAL __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL extern __declspec(dllimport)
+#define DUK_EXTERNAL should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#else
+#define DUK_INTERNAL_DECL extern
+#define DUK_INTERNAL /*empty*/
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#else
+#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and
+ * Clang. Based on documentation it should suffice to have the attribute
+ * in the declaration only, but in practice some warnings are generated unless
+ * the attribute is also applied to the definition.
+ */
+#define DUK_INTERNAL_DECL static __attribute__ ((unused))
+#define DUK_INTERNAL static __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#endif
+#else
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden")))
+#endif
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#endif
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "clang"
+#else
+#define DUK_USE_COMPILER_STRING "clang"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#define DUK_USE_UNION_INITIALIZERS
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#undef DUK_USE_GCC_PRAGMAS
+#define DUK_USE_PACK_CLANG_ATTR
+#elif defined(DUK_F_GCC)
+/* --- GCC --- */
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+/* C99 / C++11 and above: rely on va_copy() which is required. */
+#define DUK_VA_COPY(dest,src) va_copy(dest,src)
+#else
+/* GCC: assume we have __va_copy() in non-C99 mode. */
+#define DUK_VA_COPY(dest,src) __va_copy(dest,src)
+#endif
+
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 20500L)
+/* since gcc-2.5 */
+#define DUK_NORETURN(decl) decl __attribute__((noreturn))
+#endif
+
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L)
+/* since gcc-4.5 */
+#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0)
+#endif
+
+#define DUK_USE_BRANCH_HINTS
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L)
+/* GCC: test not very accurate; enable only in relatively recent builds
+ * because of bugs in gcc-4.4 (http://lists.debian.org/debian-gcc/2010/04/msg00000.html)
+ */
+#define DUK_LIKELY(x) __builtin_expect((x), 1)
+#define DUK_UNLIKELY(x) __builtin_expect((x), 0)
+#endif
+
+#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \
+ defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 30101)
+#define DUK_NOINLINE __attribute__((noinline))
+#define DUK_INLINE inline
+#define DUK_ALWAYS_INLINE inline __attribute__((always_inline))
+#endif
+
+#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL extern __declspec(dllexport)
+#define DUK_EXTERNAL __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL extern __declspec(dllimport)
+#define DUK_EXTERNAL should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#else
+#define DUK_INTERNAL_DECL extern
+#define DUK_INTERNAL /*empty*/
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#elif defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40000)
+#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and
+ * Clang. Based on documentation it should suffice to have the attribute
+ * in the declaration only, but in practice some warnings are generated unless
+ * the attribute is also applied to the definition.
+ */
+#define DUK_INTERNAL_DECL static __attribute__ ((unused))
+#define DUK_INTERNAL static __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#endif
+#else
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden")))
+#endif
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#endif
+
+#if defined(DUK_F_MINGW)
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "mingw++"
+#else
+#define DUK_USE_COMPILER_STRING "mingw"
+#endif
+#else
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "g++"
+#else
+#define DUK_USE_COMPILER_STRING "gcc"
+#endif
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || (defined(DUK_F_CPP11) && defined(__GNUC__))
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#define DUK_USE_UNION_INITIALIZERS
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40600)
+#define DUK_USE_GCC_PRAGMAS
+#else
+#undef DUK_USE_GCC_PRAGMAS
+#endif
+
+#define DUK_USE_PACK_GCC_ATTR
+#elif defined(DUK_F_MSVC)
+/* --- MSVC --- */
+/* http://msdn.microsoft.com/en-us/library/aa235362(VS.60).aspx */
+#define DUK_NORETURN(decl) __declspec(noreturn) decl
+
+/* XXX: DUK_UNREACHABLE for msvc? */
+
+#undef DUK_USE_BRANCH_HINTS
+
+/* XXX: DUK_LIKELY, DUK_UNLIKELY for msvc? */
+/* XXX: DUK_NOINLINE, DUK_INLINE, DUK_ALWAYS_INLINE for msvc? */
+
+#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL extern __declspec(dllexport)
+#define DUK_EXTERNAL __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL extern __declspec(dllimport)
+#define DUK_EXTERNAL should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#else
+#define DUK_INTERNAL_DECL extern
+#define DUK_INTERNAL /*empty*/
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+#endif
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "msvc++"
+#else
+#define DUK_USE_COMPILER_STRING "msvc"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99)
+#define DUK_USE_VARIADIC_MACROS
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+/* VS2005+ should have variadic macros even when they're not C99. */
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#undef DUK_USE_UNION_INITIALIZERS
+#if defined(_MSC_VER) && (_MSC_VER >= 1800)
+/* VS2013+ supports union initializers but there's a bug involving union-inside-struct:
+ * https://connect.microsoft.com/VisualStudio/feedback/details/805981
+ * The bug was fixed (at least) in VS2015 so check for VS2015 for now:
+ * https://blogs.msdn.microsoft.com/vcblog/2015/07/01/c-compiler-front-end-fixes-in-vs2015/
+ * Manually tested using VS2013, CL reports 18.00.31101, so enable for VS2013 too.
+ */
+#define DUK_USE_UNION_INITIALIZERS
+#endif
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#undef DUK_USE_GCC_PRAGMAS
+
+#define DUK_USE_PACK_MSVC_PRAGMA
+
+/* These have been tested from VS2008 onwards; may work in older VS versions
+ * too but not enabled by default.
+ */
+#if defined(_MSC_VER) && (_MSC_VER >= 1500)
+#define DUK_NOINLINE __declspec(noinline)
+#define DUK_INLINE __inline
+#define DUK_ALWAYS_INLINE __forceinline
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+#define DUK_SNPRINTF snprintf
+#define DUK_VSNPRINTF vsnprintf
+#else
+/* (v)snprintf() is missing before MSVC 2015. Note that _(v)snprintf() does
+ * NOT NUL terminate on truncation, but Duktape code never assumes that.
+ * http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
+ */
+#define DUK_SNPRINTF _snprintf
+#define DUK_VSNPRINTF _vsnprintf
+#endif
+#elif defined(DUK_F_EMSCRIPTEN)
+/* --- Emscripten --- */
+#define DUK_NORETURN(decl) decl __attribute__((noreturn))
+
+#if defined(__clang__) && defined(__has_builtin)
+#if __has_builtin(__builtin_unreachable)
+#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0)
+#endif
+#endif
+
+#define DUK_USE_BRANCH_HINTS
+#define DUK_LIKELY(x) __builtin_expect((x), 1)
+#define DUK_UNLIKELY(x) __builtin_expect((x), 0)
+
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_NOINLINE __attribute__((noinline))
+#define DUK_INLINE inline
+#define DUK_ALWAYS_INLINE inline __attribute__((always_inline))
+#endif
+
+#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and
+ * Clang. Based on documentation it should suffice to have the attribute
+ * in the declaration only, but in practice some warnings are generated unless
+ * the attribute is also applied to the definition.
+ */
+#define DUK_INTERNAL_DECL static __attribute__ ((unused))
+#define DUK_INTERNAL static __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL static
+#define DUK_INTERNAL static
+#endif
+#else
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL __attribute__ ((visibility("hidden")))
+#endif
+#endif
+#define DUK_LOCAL_DECL static
+#define DUK_LOCAL static
+
+#define DUK_USE_COMPILER_STRING "emscripten"
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#define DUK_USE_UNION_INITIALIZERS
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#undef DUK_USE_GCC_PRAGMAS
+#define DUK_USE_PACK_CLANG_ATTR
+#elif defined(DUK_F_TINYC)
+/* --- TinyC --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "tinyc++"
+#else
+#define DUK_USE_COMPILER_STRING "tinyc"
+#endif
+
+/* http://bellard.org/tcc/tcc-doc.html#SEC7 */
+#define DUK_USE_VARIADIC_MACROS
+
+#define DUK_USE_UNION_INITIALIZERS
+
+/* Most portable, wastes space */
+#define DUK_USE_FLEX_ONESIZE
+
+/* Most portable, potentially wastes space */
+#define DUK_USE_PACK_DUMMY_MEMBER
+#elif defined(DUK_F_VBCC)
+/* --- VBCC --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "vbcc-c++"
+#else
+#define DUK_USE_COMPILER_STRING "vbcc"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+/* VBCC supports C99 so check only for C99 for union initializer support.
+ * Designated union initializers would possibly work even without a C99 check.
+ */
+#undef DUK_USE_UNION_INITIALIZERS
+#if defined(DUK_F_C99)
+#define DUK_USE_UNION_INITIALIZERS
+#endif
+
+#define DUK_USE_FLEX_ZEROSIZE
+#define DUK_USE_PACK_DUMMY_MEMBER
+#elif defined(DUK_F_BCC)
+/* --- Bruce's C compiler --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "bcc++"
+#else
+#define DUK_USE_COMPILER_STRING "bcc"
+#endif
+
+/* Most portable */
+#undef DUK_USE_VARIADIC_MACROS
+
+/* Most portable, wastes space */
+#undef DUK_USE_UNION_INITIALIZERS
+
+/* Most portable, wastes space */
+#define DUK_USE_FLEX_ONESIZE
+
+/* Most portable, potentially wastes space */
+#define DUK_USE_PACK_DUMMY_MEMBER
+
+/* BCC, assume we're on x86. */
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#else
+/* --- Generic --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "generic-c++"
+#else
+#define DUK_USE_COMPILER_STRING "generic"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+/* C++ doesn't have standard designated union initializers ({ .foo = 1 }). */
+#undef DUK_USE_UNION_INITIALIZERS
+#if defined(DUK_F_C99)
+#define DUK_USE_UNION_INITIALIZERS
+#endif
+
+/* Most portable, wastes space */
+#define DUK_USE_FLEX_ONESIZE
+
+/* Most portable, potentially wastes space */
+#define DUK_USE_PACK_DUMMY_MEMBER
+#endif /* autodetect compiler */
+
+/* uclibc */
+#if defined(__UCLIBC__)
+#define DUK_F_UCLIBC
+#endif
+
+/*
+ * Wrapper typedefs and constants for integer types, also sanity check types.
+ *
+ * C99 typedefs are quite good but not always available, and we want to avoid
+ * forcibly redefining the C99 typedefs. So, there are Duktape wrappers for
+ * all C99 typedefs and Duktape code should only use these typedefs. Type
+ * detection when C99 is not supported is best effort and may end up detecting
+ * some types incorrectly.
+ *
+ * Pointer sizes are a portability problem: pointers to different types may
+ * have a different size and function pointers are very difficult to manage
+ * portably.
+ *
+ * http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types
+ *
+ * Note: there's an interesting corner case when trying to define minimum
+ * signed integer value constants which leads to the current workaround of
+ * defining e.g. -0x80000000 as (-0x7fffffffL - 1L). See doc/code-issues.txt
+ * for a longer discussion.
+ *
+ * Note: avoid typecasts and computations in macro integer constants as they
+ * can then no longer be used in macro relational expressions (such as
+ * #if DUK_SIZE_MAX < 0xffffffffUL). There is internal code which relies on
+ * being able to compare DUK_SIZE_MAX against a limit.
+ */
+
+/* XXX: add feature options to force basic types from outside? */
+
+#if !defined(INT_MAX)
+#error INT_MAX not defined
+#endif
+
+/* Check that architecture is two's complement, standard C allows e.g.
+ * INT_MIN to be -2**31+1 (instead of -2**31).
+ */
+#if defined(INT_MAX) && defined(INT_MIN)
+#if INT_MAX != -(INT_MIN + 1)
+#error platform does not seem complement of two
+#endif
+#else
+#error cannot check complement of two
+#endif
+
+/* Pointer size determination based on __WORDSIZE or architecture when
+ * that's not available.
+ */
+#if defined(DUK_F_X86) || defined(DUK_F_X32) || \
+ defined(DUK_F_M68K) || defined(DUK_F_PPC32) || \
+ defined(DUK_F_BCC) || \
+ (defined(__WORDSIZE) && (__WORDSIZE == 32))
+#define DUK_F_32BIT_PTRS
+#elif defined(DUK_F_X64) || \
+ (defined(__WORDSIZE) && (__WORDSIZE == 64))
+#define DUK_F_64BIT_PTRS
+#else
+/* not sure, not needed with C99 anyway */
+#endif
+
+/* Intermediate define for 'have inttypes.h' */
+#undef DUK_F_HAVE_INTTYPES
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+ !(defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC))
+/* vbcc + AmigaOS has C99 but no inttypes.h */
+#define DUK_F_HAVE_INTTYPES
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+/* C++11 apparently ratified stdint.h */
+#define DUK_F_HAVE_INTTYPES
+#endif
+
+/* Basic integer typedefs and limits, preferably from inttypes.h, otherwise
+ * through automatic detection.
+ */
+#if defined(DUK_F_HAVE_INTTYPES)
+/* C99 or compatible */
+
+#define DUK_F_HAVE_64BIT
+#include
+
+typedef uint8_t duk_uint8_t;
+typedef int8_t duk_int8_t;
+typedef uint16_t duk_uint16_t;
+typedef int16_t duk_int16_t;
+typedef uint32_t duk_uint32_t;
+typedef int32_t duk_int32_t;
+typedef uint64_t duk_uint64_t;
+typedef int64_t duk_int64_t;
+typedef uint_least8_t duk_uint_least8_t;
+typedef int_least8_t duk_int_least8_t;
+typedef uint_least16_t duk_uint_least16_t;
+typedef int_least16_t duk_int_least16_t;
+typedef uint_least32_t duk_uint_least32_t;
+typedef int_least32_t duk_int_least32_t;
+typedef uint_least64_t duk_uint_least64_t;
+typedef int_least64_t duk_int_least64_t;
+typedef uint_fast8_t duk_uint_fast8_t;
+typedef int_fast8_t duk_int_fast8_t;
+typedef uint_fast16_t duk_uint_fast16_t;
+typedef int_fast16_t duk_int_fast16_t;
+typedef uint_fast32_t duk_uint_fast32_t;
+typedef int_fast32_t duk_int_fast32_t;
+typedef uint_fast64_t duk_uint_fast64_t;
+typedef int_fast64_t duk_int_fast64_t;
+typedef uintptr_t duk_uintptr_t;
+typedef intptr_t duk_intptr_t;
+typedef uintmax_t duk_uintmax_t;
+typedef intmax_t duk_intmax_t;
+
+#define DUK_UINT8_MIN 0
+#define DUK_UINT8_MAX UINT8_MAX
+#define DUK_INT8_MIN INT8_MIN
+#define DUK_INT8_MAX INT8_MAX
+#define DUK_UINT_LEAST8_MIN 0
+#define DUK_UINT_LEAST8_MAX UINT_LEAST8_MAX
+#define DUK_INT_LEAST8_MIN INT_LEAST8_MIN
+#define DUK_INT_LEAST8_MAX INT_LEAST8_MAX
+#define DUK_UINT_FAST8_MIN 0
+#define DUK_UINT_FAST8_MAX UINT_FAST8_MAX
+#define DUK_INT_FAST8_MIN INT_FAST8_MIN
+#define DUK_INT_FAST8_MAX INT_FAST8_MAX
+#define DUK_UINT16_MIN 0
+#define DUK_UINT16_MAX UINT16_MAX
+#define DUK_INT16_MIN INT16_MIN
+#define DUK_INT16_MAX INT16_MAX
+#define DUK_UINT_LEAST16_MIN 0
+#define DUK_UINT_LEAST16_MAX UINT_LEAST16_MAX
+#define DUK_INT_LEAST16_MIN INT_LEAST16_MIN
+#define DUK_INT_LEAST16_MAX INT_LEAST16_MAX
+#define DUK_UINT_FAST16_MIN 0
+#define DUK_UINT_FAST16_MAX UINT_FAST16_MAX
+#define DUK_INT_FAST16_MIN INT_FAST16_MIN
+#define DUK_INT_FAST16_MAX INT_FAST16_MAX
+#define DUK_UINT32_MIN 0
+#define DUK_UINT32_MAX UINT32_MAX
+#define DUK_INT32_MIN INT32_MIN
+#define DUK_INT32_MAX INT32_MAX
+#define DUK_UINT_LEAST32_MIN 0
+#define DUK_UINT_LEAST32_MAX UINT_LEAST32_MAX
+#define DUK_INT_LEAST32_MIN INT_LEAST32_MIN
+#define DUK_INT_LEAST32_MAX INT_LEAST32_MAX
+#define DUK_UINT_FAST32_MIN 0
+#define DUK_UINT_FAST32_MAX UINT_FAST32_MAX
+#define DUK_INT_FAST32_MIN INT_FAST32_MIN
+#define DUK_INT_FAST32_MAX INT_FAST32_MAX
+#define DUK_UINT64_MIN 0
+#define DUK_UINT64_MAX UINT64_MAX
+#define DUK_INT64_MIN INT64_MIN
+#define DUK_INT64_MAX INT64_MAX
+#define DUK_UINT_LEAST64_MIN 0
+#define DUK_UINT_LEAST64_MAX UINT_LEAST64_MAX
+#define DUK_INT_LEAST64_MIN INT_LEAST64_MIN
+#define DUK_INT_LEAST64_MAX INT_LEAST64_MAX
+#define DUK_UINT_FAST64_MIN 0
+#define DUK_UINT_FAST64_MAX UINT_FAST64_MAX
+#define DUK_INT_FAST64_MIN INT_FAST64_MIN
+#define DUK_INT_FAST64_MAX INT_FAST64_MAX
+
+#define DUK_UINTPTR_MIN 0
+#define DUK_UINTPTR_MAX UINTPTR_MAX
+#define DUK_INTPTR_MIN INTPTR_MIN
+#define DUK_INTPTR_MAX INTPTR_MAX
+
+#define DUK_UINTMAX_MIN 0
+#define DUK_UINTMAX_MAX UINTMAX_MAX
+#define DUK_INTMAX_MIN INTMAX_MIN
+#define DUK_INTMAX_MAX INTMAX_MAX
+
+#define DUK_SIZE_MIN 0
+#define DUK_SIZE_MAX SIZE_MAX
+#undef DUK_SIZE_MAX_COMPUTED
+
+#else /* C99 types */
+
+/* When C99 types are not available, we use heuristic detection to get
+ * the basic 8, 16, 32, and (possibly) 64 bit types. The fast/least
+ * types are then assumed to be exactly the same for now: these could
+ * be improved per platform but C99 types are very often now available.
+ * 64-bit types are not available on all platforms; this is OK at least
+ * on 32-bit platforms.
+ *
+ * This detection code is necessarily a bit hacky and can provide typedefs
+ * and defines that won't work correctly on some exotic platform.
+ */
+
+#if (defined(CHAR_BIT) && (CHAR_BIT == 8)) || \
+ (defined(UCHAR_MAX) && (UCHAR_MAX == 255))
+typedef unsigned char duk_uint8_t;
+typedef signed char duk_int8_t;
+#else
+#error cannot detect 8-bit type
+#endif
+
+#if defined(USHRT_MAX) && (USHRT_MAX == 65535UL)
+typedef unsigned short duk_uint16_t;
+typedef signed short duk_int16_t;
+#elif defined(UINT_MAX) && (UINT_MAX == 65535UL)
+/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */
+typedef unsigned int duk_uint16_t;
+typedef signed int duk_int16_t;
+#else
+#error cannot detect 16-bit type
+#endif
+
+#if defined(UINT_MAX) && (UINT_MAX == 4294967295UL)
+typedef unsigned int duk_uint32_t;
+typedef signed int duk_int32_t;
+#elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295UL)
+/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */
+typedef unsigned long duk_uint32_t;
+typedef signed long duk_int32_t;
+#else
+#error cannot detect 32-bit type
+#endif
+
+/* 64-bit type detection is a bit tricky.
+ *
+ * ULLONG_MAX is a standard define. __LONG_LONG_MAX__ and __ULONG_LONG_MAX__
+ * are used by at least GCC (even if system headers don't provide ULLONG_MAX).
+ * Some GCC variants may provide __LONG_LONG_MAX__ but not __ULONG_LONG_MAX__.
+ *
+ * ULL / LL constants are rejected / warned about by some compilers, even if
+ * the compiler has a 64-bit type and the compiler/system headers provide an
+ * unsupported constant (ULL/LL)! Try to avoid using ULL / LL constants.
+ * As a side effect we can only check that e.g. ULONG_MAX is larger than 32
+ * bits but can't be sure it is exactly 64 bits. Self tests will catch such
+ * cases.
+ */
+#undef DUK_F_HAVE_64BIT
+#if !defined(DUK_F_HAVE_64BIT) && defined(ULONG_MAX)
+#if (ULONG_MAX > 4294967295UL)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long duk_uint64_t;
+typedef signed long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(ULLONG_MAX)
+#if (ULLONG_MAX > 4294967295UL)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long long duk_uint64_t;
+typedef signed long long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(__ULONG_LONG_MAX__)
+#if (__ULONG_LONG_MAX__ > 4294967295UL)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long long duk_uint64_t;
+typedef signed long long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(__LONG_LONG_MAX__)
+#if (__LONG_LONG_MAX__ > 2147483647L)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long long duk_uint64_t;
+typedef signed long long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && \
+ (defined(DUK_F_MINGW) || defined(DUK_F_MSVC))
+/* Both MinGW and MSVC have a 64-bit type. */
+#define DUK_F_HAVE_64BIT
+typedef unsigned long duk_uint64_t;
+typedef signed long duk_int64_t;
+#endif
+#if !defined(DUK_F_HAVE_64BIT)
+/* cannot detect 64-bit type, not always needed so don't error */
+#endif
+
+typedef duk_uint8_t duk_uint_least8_t;
+typedef duk_int8_t duk_int_least8_t;
+typedef duk_uint16_t duk_uint_least16_t;
+typedef duk_int16_t duk_int_least16_t;
+typedef duk_uint32_t duk_uint_least32_t;
+typedef duk_int32_t duk_int_least32_t;
+typedef duk_uint8_t duk_uint_fast8_t;
+typedef duk_int8_t duk_int_fast8_t;
+typedef duk_uint16_t duk_uint_fast16_t;
+typedef duk_int16_t duk_int_fast16_t;
+typedef duk_uint32_t duk_uint_fast32_t;
+typedef duk_int32_t duk_int_fast32_t;
+#if defined(DUK_F_HAVE_64BIT)
+typedef duk_uint64_t duk_uint_least64_t;
+typedef duk_int64_t duk_int_least64_t;
+typedef duk_uint64_t duk_uint_fast64_t;
+typedef duk_int64_t duk_int_fast64_t;
+#endif
+#if defined(DUK_F_HAVE_64BIT)
+typedef duk_uint64_t duk_uintmax_t;
+typedef duk_int64_t duk_intmax_t;
+#else
+typedef duk_uint32_t duk_uintmax_t;
+typedef duk_int32_t duk_intmax_t;
+#endif
+
+/* Note: the funny looking computations for signed minimum 16-bit, 32-bit, and
+ * 64-bit values are intentional as the obvious forms (e.g. -0x80000000L) are
+ * -not- portable. See code-issues.txt for a detailed discussion.
+ */
+#define DUK_UINT8_MIN 0UL
+#define DUK_UINT8_MAX 0xffUL
+#define DUK_INT8_MIN (-0x80L)
+#define DUK_INT8_MAX 0x7fL
+#define DUK_UINT_LEAST8_MIN 0UL
+#define DUK_UINT_LEAST8_MAX 0xffUL
+#define DUK_INT_LEAST8_MIN (-0x80L)
+#define DUK_INT_LEAST8_MAX 0x7fL
+#define DUK_UINT_FAST8_MIN 0UL
+#define DUK_UINT_FAST8_MAX 0xffUL
+#define DUK_INT_FAST8_MIN (-0x80L)
+#define DUK_INT_FAST8_MAX 0x7fL
+#define DUK_UINT16_MIN 0UL
+#define DUK_UINT16_MAX 0xffffUL
+#define DUK_INT16_MIN (-0x7fffL - 1L)
+#define DUK_INT16_MAX 0x7fffL
+#define DUK_UINT_LEAST16_MIN 0UL
+#define DUK_UINT_LEAST16_MAX 0xffffUL
+#define DUK_INT_LEAST16_MIN (-0x7fffL - 1L)
+#define DUK_INT_LEAST16_MAX 0x7fffL
+#define DUK_UINT_FAST16_MIN 0UL
+#define DUK_UINT_FAST16_MAX 0xffffUL
+#define DUK_INT_FAST16_MIN (-0x7fffL - 1L)
+#define DUK_INT_FAST16_MAX 0x7fffL
+#define DUK_UINT32_MIN 0UL
+#define DUK_UINT32_MAX 0xffffffffUL
+#define DUK_INT32_MIN (-0x7fffffffL - 1L)
+#define DUK_INT32_MAX 0x7fffffffL
+#define DUK_UINT_LEAST32_MIN 0UL
+#define DUK_UINT_LEAST32_MAX 0xffffffffUL
+#define DUK_INT_LEAST32_MIN (-0x7fffffffL - 1L)
+#define DUK_INT_LEAST32_MAX 0x7fffffffL
+#define DUK_UINT_FAST32_MIN 0UL
+#define DUK_UINT_FAST32_MAX 0xffffffffUL
+#define DUK_INT_FAST32_MIN (-0x7fffffffL - 1L)
+#define DUK_INT_FAST32_MAX 0x7fffffffL
+
+/* 64-bit constants. Since LL / ULL constants are not always available,
+ * use computed values. These values can't be used in preprocessor
+ * comparisons; flag them as such.
+ */
+#if defined(DUK_F_HAVE_64BIT)
+#define DUK_UINT64_MIN ((duk_uint64_t) 0)
+#define DUK_UINT64_MAX ((duk_uint64_t) -1)
+#define DUK_INT64_MIN ((duk_int64_t) (~(DUK_UINT64_MAX >> 1)))
+#define DUK_INT64_MAX ((duk_int64_t) (DUK_UINT64_MAX >> 1))
+#define DUK_UINT_LEAST64_MIN DUK_UINT64_MIN
+#define DUK_UINT_LEAST64_MAX DUK_UINT64_MAX
+#define DUK_INT_LEAST64_MIN DUK_INT64_MIN
+#define DUK_INT_LEAST64_MAX DUK_INT64_MAX
+#define DUK_UINT_FAST64_MIN DUK_UINT64_MIN
+#define DUK_UINT_FAST64_MAX DUK_UINT64_MAX
+#define DUK_INT_FAST64_MIN DUK_INT64_MIN
+#define DUK_INT_FAST64_MAX DUK_INT64_MAX
+#define DUK_UINT64_MIN_COMPUTED
+#define DUK_UINT64_MAX_COMPUTED
+#define DUK_INT64_MIN_COMPUTED
+#define DUK_INT64_MAX_COMPUTED
+#define DUK_UINT_LEAST64_MIN_COMPUTED
+#define DUK_UINT_LEAST64_MAX_COMPUTED
+#define DUK_INT_LEAST64_MIN_COMPUTED
+#define DUK_INT_LEAST64_MAX_COMPUTED
+#define DUK_UINT_FAST64_MIN_COMPUTED
+#define DUK_UINT_FAST64_MAX_COMPUTED
+#define DUK_INT_FAST64_MIN_COMPUTED
+#define DUK_INT_FAST64_MAX_COMPUTED
+#endif
+
+#if defined(DUK_F_HAVE_64BIT)
+#define DUK_UINTMAX_MIN DUK_UINT64_MIN
+#define DUK_UINTMAX_MAX DUK_UINT64_MAX
+#define DUK_INTMAX_MIN DUK_INT64_MIN
+#define DUK_INTMAX_MAX DUK_INT64_MAX
+#define DUK_UINTMAX_MIN_COMPUTED
+#define DUK_UINTMAX_MAX_COMPUTED
+#define DUK_INTMAX_MIN_COMPUTED
+#define DUK_INTMAX_MAX_COMPUTED
+#else
+#define DUK_UINTMAX_MIN 0UL
+#define DUK_UINTMAX_MAX 0xffffffffUL
+#define DUK_INTMAX_MIN (-0x7fffffffL - 1L)
+#define DUK_INTMAX_MAX 0x7fffffffL
+#endif
+
+/* This detection is not very reliable. */
+#if defined(DUK_F_32BIT_PTRS)
+typedef duk_int32_t duk_intptr_t;
+typedef duk_uint32_t duk_uintptr_t;
+#define DUK_UINTPTR_MIN DUK_UINT32_MIN
+#define DUK_UINTPTR_MAX DUK_UINT32_MAX
+#define DUK_INTPTR_MIN DUK_INT32_MIN
+#define DUK_INTPTR_MAX DUK_INT32_MAX
+#elif defined(DUK_F_64BIT_PTRS) && defined(DUK_F_HAVE_64BIT)
+typedef duk_int64_t duk_intptr_t;
+typedef duk_uint64_t duk_uintptr_t;
+#define DUK_UINTPTR_MIN DUK_UINT64_MIN
+#define DUK_UINTPTR_MAX DUK_UINT64_MAX
+#define DUK_INTPTR_MIN DUK_INT64_MIN
+#define DUK_INTPTR_MAX DUK_INT64_MAX
+#define DUK_UINTPTR_MIN_COMPUTED
+#define DUK_UINTPTR_MAX_COMPUTED
+#define DUK_INTPTR_MIN_COMPUTED
+#define DUK_INTPTR_MAX_COMPUTED
+#else
+#error cannot determine intptr type
+#endif
+
+/* SIZE_MAX may be missing so use an approximate value for it. */
+#undef DUK_SIZE_MAX_COMPUTED
+#if !defined(SIZE_MAX)
+#define DUK_SIZE_MAX_COMPUTED
+#define SIZE_MAX ((size_t) (-1))
+#endif
+#define DUK_SIZE_MIN 0
+#define DUK_SIZE_MAX SIZE_MAX
+
+#endif /* C99 types */
+
+/* A few types are assumed to always exist. */
+typedef size_t duk_size_t;
+typedef ptrdiff_t duk_ptrdiff_t;
+
+/* The best type for an "all around int" in Duktape internals is "at least
+ * 32 bit signed integer" which is most convenient. Same for unsigned type.
+ * Prefer 'int' when large enough, as it is almost always a convenient type.
+ */
+#if defined(UINT_MAX) && (UINT_MAX >= 0xffffffffUL)
+typedef int duk_int_t;
+typedef unsigned int duk_uint_t;
+#define DUK_INT_MIN INT_MIN
+#define DUK_INT_MAX INT_MAX
+#define DUK_UINT_MIN 0
+#define DUK_UINT_MAX UINT_MAX
+#else
+typedef duk_int_fast32_t duk_int_t;
+typedef duk_uint_fast32_t duk_uint_t;
+#define DUK_INT_MIN DUK_INT_FAST32_MIN
+#define DUK_INT_MAX DUK_INT_FAST32_MAX
+#define DUK_UINT_MIN DUK_UINT_FAST32_MIN
+#define DUK_UINT_MAX DUK_UINT_FAST32_MAX
+#endif
+
+/* Same as 'duk_int_t' but guaranteed to be a 'fast' variant if this
+ * distinction matters for the CPU. These types are used mainly in the
+ * executor where it might really matter.
+ */
+typedef duk_int_fast32_t duk_int_fast_t;
+typedef duk_uint_fast32_t duk_uint_fast_t;
+#define DUK_INT_FAST_MIN DUK_INT_FAST32_MIN
+#define DUK_INT_FAST_MAX DUK_INT_FAST32_MAX
+#define DUK_UINT_FAST_MIN DUK_UINT_FAST32_MIN
+#define DUK_UINT_FAST_MAX DUK_UINT_FAST32_MAX
+
+/* Small integers (16 bits or more) can fall back to the 'int' type, but
+ * have a typedef so they are marked "small" explicitly.
+ */
+typedef int duk_small_int_t;
+typedef unsigned int duk_small_uint_t;
+#define DUK_SMALL_INT_MIN INT_MIN
+#define DUK_SMALL_INT_MAX INT_MAX
+#define DUK_SMALL_UINT_MIN 0
+#define DUK_SMALL_UINT_MAX UINT_MAX
+
+/* Fast variants of small integers, again for really fast paths like the
+ * executor.
+ */
+typedef duk_int_fast16_t duk_small_int_fast_t;
+typedef duk_uint_fast16_t duk_small_uint_fast_t;
+#define DUK_SMALL_INT_FAST_MIN DUK_INT_FAST16_MIN
+#define DUK_SMALL_INT_FAST_MAX DUK_INT_FAST16_MAX
+#define DUK_SMALL_UINT_FAST_MIN DUK_UINT_FAST16_MIN
+#define DUK_SMALL_UINT_FAST_MAX DUK_UINT_FAST16_MAX
+
+/* Boolean values are represented with the platform 'int'. */
+typedef duk_small_int_t duk_bool_t;
+#define DUK_BOOL_MIN DUK_SMALL_INT_MIN
+#define DUK_BOOL_MAX DUK_SMALL_INT_MAX
+
+/* Index values must have at least 32-bit signed range. */
+typedef duk_int_t duk_idx_t;
+#define DUK_IDX_MIN DUK_INT_MIN
+#define DUK_IDX_MAX DUK_INT_MAX
+
+/* Unsigned index variant. */
+typedef duk_uint_t duk_uidx_t;
+#define DUK_UIDX_MIN DUK_UINT_MIN
+#define DUK_UIDX_MAX DUK_UINT_MAX
+
+/* Array index values, could be exact 32 bits.
+ * Currently no need for signed duk_arridx_t.
+ */
+typedef duk_uint_t duk_uarridx_t;
+#define DUK_UARRIDX_MIN DUK_UINT_MIN
+#define DUK_UARRIDX_MAX DUK_UINT_MAX
+
+/* Duktape/C function return value, platform int is enough for now to
+ * represent 0, 1, or negative error code. Must be compatible with
+ * assigning truth values (e.g. duk_ret_t rc = (foo == bar);).
+ */
+typedef duk_small_int_t duk_ret_t;
+#define DUK_RET_MIN DUK_SMALL_INT_MIN
+#define DUK_RET_MAX DUK_SMALL_INT_MAX
+
+/* Error codes are represented with platform int. High bits are used
+ * for flags and such, so 32 bits are needed.
+ */
+typedef duk_int_t duk_errcode_t;
+#define DUK_ERRCODE_MIN DUK_INT_MIN
+#define DUK_ERRCODE_MAX DUK_INT_MAX
+
+/* Codepoint type. Must be 32 bits or more because it is used also for
+ * internal codepoints. The type is signed because negative codepoints
+ * are used as internal markers (e.g. to mark EOF or missing argument).
+ * (X)UTF-8/CESU-8 encode/decode take and return an unsigned variant to
+ * ensure duk_uint32_t casts back and forth nicely. Almost everything
+ * else uses the signed one.
+ */
+typedef duk_int_t duk_codepoint_t;
+typedef duk_uint_t duk_ucodepoint_t;
+#define DUK_CODEPOINT_MIN DUK_INT_MIN
+#define DUK_CODEPOINT_MAX DUK_INT_MAX
+#define DUK_UCODEPOINT_MIN DUK_UINT_MIN
+#define DUK_UCODEPOINT_MAX DUK_UINT_MAX
+
+/* IEEE float/double typedef. */
+typedef float duk_float_t;
+typedef double duk_double_t;
+
+/* We're generally assuming that we're working on a platform with a 32-bit
+ * address space. If DUK_SIZE_MAX is a typecast value (which is necessary
+ * if SIZE_MAX is missing), the check must be avoided because the
+ * preprocessor can't do a comparison.
+ */
+#if !defined(DUK_SIZE_MAX)
+#error DUK_SIZE_MAX is undefined, probably missing SIZE_MAX
+#elif !defined(DUK_SIZE_MAX_COMPUTED)
+#if DUK_SIZE_MAX < 0xffffffffUL
+/* On some systems SIZE_MAX can be smaller than max unsigned 32-bit value
+ * which seems incorrect if size_t is (at least) an unsigned 32-bit type.
+ * However, it doesn't seem useful to error out compilation if this is the
+ * case.
+ */
+#endif
+#endif
+
+/* Type for public API calls. */
+typedef struct duk_hthread duk_context;
+
+/* Check whether we should use 64-bit integers or not.
+ *
+ * Quite incomplete now. Use 64-bit types if detected (C99 or other detection)
+ * unless they are known to be unreliable. For instance, 64-bit types are
+ * available on VBCC but seem to misbehave.
+ */
+#if defined(DUK_F_HAVE_64BIT) && !defined(DUK_F_VBCC)
+#define DUK_USE_64BIT_OPS
+#else
+#undef DUK_USE_64BIT_OPS
+#endif
+
+/*
+ * Fill-ins for platform, architecture, and compiler
+ */
+
+#if !defined(DUK_SETJMP)
+#define DUK_JMPBUF_TYPE jmp_buf
+#define DUK_SETJMP(jb) setjmp((jb))
+#define DUK_LONGJMP(jb) longjmp((jb), 1)
+#endif
+
+#if 0
+/* sigsetjmp() alternative */
+#define DUK_JMPBUF_TYPE sigjmp_buf
+#define DUK_SETJMP(jb) sigsetjmp((jb))
+#define DUK_LONGJMP(jb) siglongjmp((jb), 1)
+#endif
+
+typedef FILE duk_file;
+#if !defined(DUK_STDIN)
+#define DUK_STDIN stdin
+#endif
+#if !defined(DUK_STDOUT)
+#define DUK_STDOUT stdout
+#endif
+#if !defined(DUK_STDERR)
+#define DUK_STDERR stderr
+#endif
+
+/* Special naming to avoid conflict with e.g. DUK_FREE() in duk_heap.h
+ * (which is unfortunately named). May sometimes need replacement, e.g.
+ * some compilers don't handle zero length or NULL correctly in realloc().
+ */
+#if !defined(DUK_ANSI_MALLOC)
+#define DUK_ANSI_MALLOC malloc
+#endif
+#if !defined(DUK_ANSI_REALLOC)
+#define DUK_ANSI_REALLOC realloc
+#endif
+#if !defined(DUK_ANSI_CALLOC)
+#define DUK_ANSI_CALLOC calloc
+#endif
+#if !defined(DUK_ANSI_FREE)
+#define DUK_ANSI_FREE free
+#endif
+
+/* ANSI C (various versions) and some implementations require that the
+ * pointer arguments to memset(), memcpy(), and memmove() be valid values
+ * even when byte size is 0 (even a NULL pointer is considered invalid in
+ * this context). Zero-size operations as such are allowed, as long as their
+ * pointer arguments point to a valid memory area. The DUK_MEMSET(),
+ * DUK_MEMCPY(), and DUK_MEMMOVE() macros require this same behavior, i.e.:
+ * (1) pointers must be valid and non-NULL, (2) zero size must otherwise be
+ * allowed. If these are not fulfilled, a macro wrapper is needed.
+ *
+ * http://stackoverflow.com/questions/5243012/is-it-guaranteed-to-be-safe-to-perform-memcpy0-0-0
+ * http://lists.cs.uiuc.edu/pipermail/llvmdev/2007-October/011065.html
+ *
+ * Not sure what's the required behavior when a pointer points just past the
+ * end of a buffer, which often happens in practice (e.g. zero size memmoves).
+ * For example, if allocation size is 3, the following pointer would not
+ * technically point to a valid memory byte:
+ *
+ * <-- alloc -->
+ * | 0 | 1 | 2 | .....
+ * ^-- p=3, points after last valid byte (2)
+ */
+#if !defined(DUK_MEMCPY)
+#if defined(DUK_F_UCLIBC)
+/* Old uclibcs have a broken memcpy so use memmove instead (this is overly wide
+ * now on purpose): http://lists.uclibc.org/pipermail/uclibc-cvs/2008-October/025511.html
+ */
+#define DUK_MEMCPY memmove
+#else
+#define DUK_MEMCPY memcpy
+#endif
+#endif
+#if !defined(DUK_MEMMOVE)
+#define DUK_MEMMOVE memmove
+#endif
+#if !defined(DUK_MEMCMP)
+#define DUK_MEMCMP memcmp
+#endif
+#if !defined(DUK_MEMSET)
+#define DUK_MEMSET memset
+#endif
+#if !defined(DUK_STRLEN)
+#define DUK_STRLEN strlen
+#endif
+#if !defined(DUK_STRCMP)
+#define DUK_STRCMP strcmp
+#endif
+#if !defined(DUK_STRNCMP)
+#define DUK_STRNCMP strncmp
+#endif
+#if !defined(DUK_PRINTF)
+#define DUK_PRINTF printf
+#endif
+#if !defined(DUK_FPRINTF)
+#define DUK_FPRINTF fprintf
+#endif
+#if !defined(DUK_SPRINTF)
+#define DUK_SPRINTF sprintf
+#endif
+#if !defined(DUK_SNPRINTF)
+/* snprintf() is technically not part of C89 but usually available. */
+#define DUK_SNPRINTF snprintf
+#endif
+#if !defined(DUK_VSPRINTF)
+#define DUK_VSPRINTF vsprintf
+#endif
+#if !defined(DUK_VSNPRINTF)
+/* vsnprintf() is technically not part of C89 but usually available. */
+#define DUK_VSNPRINTF vsnprintf
+#endif
+#if !defined(DUK_SSCANF)
+#define DUK_SSCANF sscanf
+#endif
+#if !defined(DUK_VSSCANF)
+#define DUK_VSSCANF vsscanf
+#endif
+#if !defined(DUK_FOPEN)
+#define DUK_FOPEN fopen
+#endif
+#if !defined(DUK_FCLOSE)
+#define DUK_FCLOSE fclose
+#endif
+#if !defined(DUK_FREAD)
+#define DUK_FREAD fread
+#endif
+#if !defined(DUK_FWRITE)
+#define DUK_FWRITE fwrite
+#endif
+#if !defined(DUK_FSEEK)
+#define DUK_FSEEK fseek
+#endif
+#if !defined(DUK_FTELL)
+#define DUK_FTELL ftell
+#endif
+#if !defined(DUK_FFLUSH)
+#define DUK_FFLUSH fflush
+#endif
+#if !defined(DUK_FPUTC)
+#define DUK_FPUTC fputc
+#endif
+#if !defined(DUK_MEMZERO)
+#define DUK_MEMZERO(p,n) DUK_MEMSET((p), 0, (n))
+#endif
+#if !defined(DUK_ABORT)
+#define DUK_ABORT abort
+#endif
+#if !defined(DUK_EXIT)
+#define DUK_EXIT exit
+#endif
+
+#if !defined(DUK_DOUBLE_2TO32)
+#define DUK_DOUBLE_2TO32 4294967296.0
+#endif
+#if !defined(DUK_DOUBLE_2TO31)
+#define DUK_DOUBLE_2TO31 2147483648.0
+#endif
+
+#if !defined(DUK_DOUBLE_INFINITY)
+#undef DUK_USE_COMPUTED_INFINITY
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION < 40600)
+/* GCC older than 4.6: avoid overflow warnings related to using INFINITY */
+#define DUK_DOUBLE_INFINITY (__builtin_inf())
+#elif defined(INFINITY)
+#define DUK_DOUBLE_INFINITY ((double) INFINITY)
+#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC)
+#define DUK_DOUBLE_INFINITY (1.0 / 0.0)
+#else
+/* In VBCC (1.0 / 0.0) results in a warning and 0.0 instead of infinity.
+ * Use a computed infinity (initialized when a heap is created at the
+ * latest).
+ */
+#define DUK_USE_COMPUTED_INFINITY
+#define DUK_DOUBLE_INFINITY duk_computed_infinity
+#endif
+#endif
+
+#if !defined(DUK_DOUBLE_NAN)
+#undef DUK_USE_COMPUTED_NAN
+#if defined(NAN)
+#define DUK_DOUBLE_NAN NAN
+#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC)
+#define DUK_DOUBLE_NAN (0.0 / 0.0)
+#else
+/* In VBCC (0.0 / 0.0) results in a warning and 0.0 instead of NaN.
+ * In MSVC (VS2010 Express) (0.0 / 0.0) results in a compile error.
+ * Use a computed NaN (initialized when a heap is created at the
+ * latest).
+ */
+#define DUK_USE_COMPUTED_NAN
+#define DUK_DOUBLE_NAN duk_computed_nan
+#endif
+#endif
+
+/* Many platforms are missing fpclassify() and friends, so use replacements
+ * if necessary. The replacement constants (FP_NAN etc) can be anything but
+ * match Linux constants now.
+ */
+#undef DUK_USE_REPL_FPCLASSIFY
+#undef DUK_USE_REPL_SIGNBIT
+#undef DUK_USE_REPL_ISFINITE
+#undef DUK_USE_REPL_ISNAN
+#undef DUK_USE_REPL_ISINF
+
+/* Complex condition broken into separate parts. */
+#undef DUK_F_USE_REPL_ALL
+#if !(defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO) && \
+ defined(FP_SUBNORMAL) && defined(FP_NORMAL))
+/* Missing some obvious constants. */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)
+/* VBCC is missing the built-ins even in C99 mode (perhaps a header issue). */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_M68K)
+/* AmigaOS + M68K seems to have math issues even when using GCC cross
+ * compilation. Use replacements for all AmigaOS versions on M68K
+ * regardless of compiler.
+ */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_FREEBSD) && defined(DUK_F_CLANG)
+/* Placeholder fix for (detection is wider than necessary):
+ * http://llvm.org/bugs/show_bug.cgi?id=17788
+ */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_UCLIBC)
+/* At least some uclibc versions have broken floating point math. For
+ * example, fpclassify() can incorrectly classify certain NaN formats.
+ * To be safe, use replacements.
+ */
+#define DUK_F_USE_REPL_ALL
+#endif
+
+#if defined(DUK_F_USE_REPL_ALL)
+#define DUK_USE_REPL_FPCLASSIFY
+#define DUK_USE_REPL_SIGNBIT
+#define DUK_USE_REPL_ISFINITE
+#define DUK_USE_REPL_ISNAN
+#define DUK_USE_REPL_ISINF
+#define DUK_FPCLASSIFY duk_repl_fpclassify
+#define DUK_SIGNBIT duk_repl_signbit
+#define DUK_ISFINITE duk_repl_isfinite
+#define DUK_ISNAN duk_repl_isnan
+#define DUK_ISINF duk_repl_isinf
+#define DUK_FP_NAN 0
+#define DUK_FP_INFINITE 1
+#define DUK_FP_ZERO 2
+#define DUK_FP_SUBNORMAL 3
+#define DUK_FP_NORMAL 4
+#else
+#define DUK_FPCLASSIFY fpclassify
+#define DUK_SIGNBIT signbit
+#define DUK_ISFINITE isfinite
+#define DUK_ISNAN isnan
+#define DUK_ISINF isinf
+#define DUK_FP_NAN FP_NAN
+#define DUK_FP_INFINITE FP_INFINITE
+#define DUK_FP_ZERO FP_ZERO
+#define DUK_FP_SUBNORMAL FP_SUBNORMAL
+#define DUK_FP_NORMAL FP_NORMAL
+#endif
+
+#if defined(DUK_F_USE_REPL_ALL)
+#undef DUK_F_USE_REPL_ALL
+#endif
+
+/* Some math functions are C99 only. This is also an issue with some
+ * embedded environments using uclibc where uclibc has been configured
+ * not to provide some functions. For now, use replacements whenever
+ * using uclibc.
+ */
+#undef DUK_USE_MATH_FMIN
+#undef DUK_USE_MATH_FMAX
+#undef DUK_USE_MATH_ROUND
+#if defined(DUK_F_UCLIBC)
+/* uclibc may be missing these */
+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)
+/* vbcc + AmigaOS may be missing these */
+#elif defined(DUK_F_MINT)
+/* mint clib is missing these */
+#elif !defined(DUK_F_C99) && !defined(DUK_F_CPP11)
+/* build is not C99 or C++11, play it safe */
+#else
+/* C99 or C++11, no known issues */
+#define DUK_USE_MATH_FMIN
+#define DUK_USE_MATH_FMAX
+#define DUK_USE_MATH_ROUND
+#endif
+
+/* These functions don't currently need replacement but are wrapped for
+ * completeness. Because these are used as function pointers, they need
+ * to be defined as concrete C functions (not macros).
+ */
+#if !defined(DUK_FABS)
+#define DUK_FABS fabs
+#endif
+#if !defined(DUK_FMIN)
+#define DUK_FMIN fmin
+#endif
+#if !defined(DUK_FMAX)
+#define DUK_FMAX fmax
+#endif
+#if !defined(DUK_FLOOR)
+#define DUK_FLOOR floor
+#endif
+#if !defined(DUK_CEIL)
+#define DUK_CEIL ceil
+#endif
+#if !defined(DUK_FMOD)
+#define DUK_FMOD fmod
+#endif
+#if !defined(DUK_POW)
+#define DUK_POW pow
+#endif
+#if !defined(DUK_ACOS)
+#define DUK_ACOS acos
+#endif
+#if !defined(DUK_ASIN)
+#define DUK_ASIN asin
+#endif
+#if !defined(DUK_ATAN)
+#define DUK_ATAN atan
+#endif
+#if !defined(DUK_ATAN2)
+#define DUK_ATAN2 atan2
+#endif
+#if !defined(DUK_SIN)
+#define DUK_SIN sin
+#endif
+#if !defined(DUK_COS)
+#define DUK_COS cos
+#endif
+#if !defined(DUK_TAN)
+#define DUK_TAN tan
+#endif
+#if !defined(DUK_EXP)
+#define DUK_EXP exp
+#endif
+#if !defined(DUK_LOG)
+#define DUK_LOG log
+#endif
+#if !defined(DUK_SQRT)
+#define DUK_SQRT sqrt
+#endif
+
+/* NetBSD 6.0 x86 (at least) has a few problems with pow() semantics,
+ * see test-bug-netbsd-math-pow.js. Use NetBSD specific workaround.
+ * (This might be a wider problem; if so, generalize the define name.)
+ */
+#undef DUK_USE_POW_NETBSD_WORKAROUND
+#if defined(DUK_F_NETBSD)
+#define DUK_USE_POW_NETBSD_WORKAROUND
+#endif
+
+/* Rely as little as possible on compiler behavior for NaN comparison,
+ * signed zero handling, etc. Currently never activated but may be needed
+ * for broken compilers.
+ */
+#undef DUK_USE_PARANOID_MATH
+
+/* There was a curious bug where test-bi-date-canceling.js would fail e.g.
+ * on 64-bit Ubuntu, gcc-4.8.1, -m32, and no -std=c99. Some date computations
+ * using doubles would be optimized which then broke some corner case tests.
+ * The problem goes away by adding 'volatile' to the datetime computations.
+ * Not sure what the actual triggering conditions are, but using this on
+ * non-C99 systems solves the known issues and has relatively little cost
+ * on other platforms.
+ */
+#undef DUK_USE_PARANOID_DATE_COMPUTATION
+#if !defined(DUK_F_C99)
+#define DUK_USE_PARANOID_DATE_COMPUTATION
+#endif
+
+/*
+ * Byte order and double memory layout detection
+ *
+ * Endianness detection is a major portability hassle because the macros
+ * and headers are not standardized. There's even variance across UNIX
+ * platforms. Even with "standard" headers, details like underscore count
+ * varies between platforms, e.g. both __BYTE_ORDER and _BYTE_ORDER are used
+ * (Crossbridge has a single underscore, for instance).
+ *
+ * The checks below are structured with this in mind: several approaches are
+ * used, and at the end we check if any of them worked. This allows generic
+ * approaches to be tried first, and platform/compiler specific hacks tried
+ * last. As a last resort, the user can force a specific endianness, as it's
+ * not likely that automatic detection will work on the most exotic platforms.
+ *
+ * Duktape supports little and big endian machines. There's also support
+ * for a hybrid used by some ARM machines where integers are little endian
+ * but IEEE double values use a mixed order (12345678 -> 43218765). This
+ * byte order for doubles is referred to as "mixed endian".
+ */
+
+/* For custom platforms allow user to define byteorder explicitly.
+ * Since endianness headers are not standardized, this is a useful
+ * workaround for custom platforms for which endianness detection
+ * is not directly supported. Perhaps custom hardware is used and
+ * user cannot submit upstream patches.
+ */
+#if defined(DUK_OPT_FORCE_BYTEORDER)
+#undef DUK_USE_BYTEORDER
+#if (DUK_OPT_FORCE_BYTEORDER == 1)
+#define DUK_USE_BYTEORDER 1
+#elif (DUK_OPT_FORCE_BYTEORDER == 2)
+#define DUK_USE_BYTEORDER 2
+#elif (DUK_OPT_FORCE_BYTEORDER == 3)
+#define DUK_USE_BYTEORDER 3
+#else
+#error invalid DUK_OPT_FORCE_BYTEORDER value
+#endif
+#endif /* DUK_OPT_FORCE_BYTEORDER */
+
+/* GCC and Clang provide endianness defines as built-in predefines, with
+ * leading and trailing double underscores (e.g. __BYTE_ORDER__). See
+ * output of "make gccpredefs" and "make clangpredefs". Clang doesn't
+ * seem to provide __FLOAT_WORD_ORDER__; assume not mixed endian for clang.
+ * http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+ */
+#if !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__)
+#if defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define DUK_USE_BYTEORDER 1
+#elif defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define DUK_USE_BYTEORDER 2
+#elif !defined(__FLOAT_WORD_ORDER__)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 1
+#else
+/* Byte order is little endian but cannot determine IEEE double word order. */
+#endif /* float word order */
+#elif defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define DUK_USE_BYTEORDER 3
+#elif !defined(__FLOAT_WORD_ORDER__)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 3
+#else
+/* Byte order is big endian but cannot determine IEEE double word order. */
+#endif /* float word order */
+#else
+/* Cannot determine byte order; __ORDER_PDP_ENDIAN__ is related to 32-bit
+ * integer ordering and is not relevant.
+ */
+#endif /* integer byte order */
+#endif /* !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__) */
+
+/* More or less standard endianness predefines provided by header files.
+ * The ARM hybrid case is detected by assuming that __FLOAT_WORD_ORDER
+ * will be big endian, see: http://lists.mysql.com/internals/443.
+ * On some platforms some defines may be present with an empty value which
+ * causes comparisons to fail: https://github.com/svaarala/duktape/issues/453.
+ */
+#if !defined(DUK_USE_BYTEORDER)
+#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) || \
+ defined(_BYTE_ORDER) && defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN) || \
+ defined(__LITTLE_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER) && defined(__LITTLE_ENDIAN) && (__FLOAT_WORD_ORDER == __LITTLE_ENDIAN) || \
+ defined(_FLOAT_WORD_ORDER) && defined(_LITTLE_ENDIAN) && (_FLOAT_WORD_ORDER == _LITTLE_ENDIAN)
+#define DUK_USE_BYTEORDER 1
+#elif defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \
+ defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN)
+#define DUK_USE_BYTEORDER 2
+#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 1
+#else
+/* Byte order is little endian but cannot determine IEEE double word order. */
+#endif /* float word order */
+#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) || \
+ defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN) || \
+ defined(__BIG_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \
+ defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN)
+#define DUK_USE_BYTEORDER 3
+#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 3
+#else
+/* Byte order is big endian but cannot determine IEEE double word order. */
+#endif /* float word order */
+#else
+/* Cannot determine byte order. */
+#endif /* integer byte order */
+#endif /* !defined(DUK_USE_BYTEORDER) */
+
+/* QNX gcc cross compiler seems to define e.g. __LITTLEENDIAN__ or __BIGENDIAN__:
+ * $ /opt/qnx650/host/linux/x86/usr/bin/i486-pc-nto-qnx6.5.0-gcc -dM -E - > 24) | \
+ ((((duk_uint32_t) (x)) >> 8) & 0xff00UL) | \
+ ((((duk_uint32_t) (x)) << 8) & 0xff0000UL) | \
+ (((duk_uint32_t) (x)) << 24))
+#endif
+#if !defined(DUK_BSWAP16)
+#define DUK_BSWAP16(x) \
+ ((duk_uint16_t) (x) >> 8) | \
+ ((duk_uint16_t) (x) << 8)
+#endif
+
+/* DUK_USE_VARIADIC_MACROS: required from compilers, so no fill-in. */
+/* DUK_USE_UNION_INITIALIZERS: required from compilers, so no fill-in. */
+
+#if !(defined(DUK_USE_FLEX_C99) || defined(DUK_USE_FLEX_ZEROSIZE) || defined(DUK_USE_FLEX_ONESIZE))
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE /* Not standard but common enough */
+#endif
+#endif
+
+#if !(defined(DUK_USE_PACK_GCC_ATTR) || defined(DUK_USE_PACK_CLANG_ATTR) || \
+ defined(DUK_USE_PACK_MSVC_PRAGMA) || defined(DUK_USE_PACK_DUMMY_MEMBER))
+#define DUK_USE_PACK_DUMMY_MEMBER
+#endif
+
+#if 0 /* not defined by default */
+#undef DUK_USE_GCC_PRAGMAS
+#endif
+
+/* Workaround for GH-323: avoid inlining control when compiling from
+ * multiple sources, as it causes compiler portability trouble.
+ */
+#if !defined(DUK_SINGLE_FILE)
+#undef DUK_NOINLINE
+#undef DUK_INLINE
+#undef DUK_ALWAYS_INLINE
+#define DUK_NOINLINE /*nop*/
+#define DUK_INLINE /*nop*/
+#define DUK_ALWAYS_INLINE /*nop*/
+#endif
+
+/*
+ * Check whether or not a packed duk_tval representation is possible.
+ * What's basically required is that pointers are 32-bit values
+ * (sizeof(void *) == 4). Best effort check, not always accurate.
+ * If guess goes wrong, crashes may result; self tests also verify
+ * the guess.
+ */
+
+/* Explicit marker needed; may be 'defined', 'undefined, 'or 'not provided'. */
+#if !defined(DUK_F_PACKED_TVAL_PROVIDED)
+#undef DUK_F_PACKED_TVAL_POSSIBLE
+
+/* Strict C99 case: DUK_UINTPTR_MAX (= UINTPTR_MAX) should be very reliable */
+#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX)
+#if (DUK_UINTPTR_MAX <= 0xffffffffUL)
+#define DUK_F_PACKED_TVAL_POSSIBLE
+#endif
+#endif
+
+/* Non-C99 case, still relying on DUK_UINTPTR_MAX, as long as it is not a computed value */
+#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED)
+#if (DUK_UINTPTR_MAX <= 0xffffffffUL)
+#define DUK_F_PACKED_TVAL_POSSIBLE
+#endif
+#endif
+
+/* DUK_SIZE_MAX (= SIZE_MAX) is often reliable */
+#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_SIZE_MAX) && !defined(DUK_SIZE_MAX_COMPUTED)
+#if (DUK_SIZE_MAX <= 0xffffffffUL)
+#define DUK_F_PACKED_TVAL_POSSIBLE
+#endif
+#endif
+
+#undef DUK_USE_PACKED_TVAL
+#if defined(DUK_F_PACKED_TVAL_POSSIBLE)
+#define DUK_USE_PACKED_TVAL
+#endif
+
+#undef DUK_F_PACKED_TVAL_POSSIBLE
+#endif /* DUK_F_PACKED_TVAL_PROVIDED */
+
+/* Feature option forcing. */
+#if defined(DUK_OPT_NO_PACKED_TVAL)
+#undef DUK_USE_PACKED_TVAL
+#elif defined(DUK_OPT_PACKED_TVAL)
+#undef DUK_USE_PACKED_TVAL
+#define DUK_USE_PACKED_TVAL
+#endif
+/* Object property allocation layout has implications for memory and code
+ * footprint and generated code size/speed. The best layout also depends
+ * on whether the platform has alignment requirements or benefits from
+ * having mostly aligned accesses.
+ */
+#undef DUK_USE_HOBJECT_LAYOUT_1
+#undef DUK_USE_HOBJECT_LAYOUT_2
+#undef DUK_USE_HOBJECT_LAYOUT_3
+#if (DUK_USE_ALIGN_BY == 1)
+/* On platforms without any alignment issues, layout 1 is preferable
+ * because it compiles to slightly less code and provides direct access
+ * to property keys.
+ */
+#define DUK_USE_HOBJECT_LAYOUT_1
+#else
+/* On other platforms use layout 2, which requires some padding but
+ * is a bit more natural than layout 3 in ordering the entries. Layout
+ * 3 is currently not used.
+ */
+#define DUK_USE_HOBJECT_LAYOUT_2
+#endif
+
+/* GCC/clang inaccurate math would break compliance and probably duk_tval,
+ * so refuse to compile. Relax this if -ffast-math is tested to work.
+ */
+#if defined(__FAST_MATH__)
+#error __FAST_MATH__ defined, refusing to compile
+#endif
+
+/*
+ * Autogenerated defaults
+ */
+
+#undef DUK_USE_ASSERTIONS
+#define DUK_USE_AUGMENT_ERROR_CREATE
+#define DUK_USE_AUGMENT_ERROR_THROW
+#define DUK_USE_AVOID_PLATFORM_FUNCPTRS
+#define DUK_USE_BASE64_FASTPATH
+#define DUK_USE_BROWSER_LIKE
+#define DUK_USE_BUFFEROBJECT_SUPPORT
+#undef DUK_USE_BUFLEN16
+#define DUK_USE_BUILTIN_INITJS
+#define DUK_USE_BYTECODE_DUMP_SUPPORT
+#define DUK_USE_COMMONJS_MODULES
+#define DUK_USE_COMPILER_RECLIMIT 2500
+#undef DUK_USE_CPP_EXCEPTIONS
+#undef DUK_USE_DATAPTR16
+#undef DUK_USE_DATAPTR_DEC16
+#undef DUK_USE_DATAPTR_ENC16
+#undef DUK_USE_DATE_FORMAT_STRING
+#undef DUK_USE_DATE_GET_LOCAL_TZOFFSET
+#undef DUK_USE_DATE_GET_NOW
+#undef DUK_USE_DATE_PARSE_STRING
+#undef DUK_USE_DATE_PRS_GETDATE
+#undef DUK_USE_DDDPRINT
+#undef DUK_USE_DDPRINT
+#undef DUK_USE_DEBUG
+#undef DUK_USE_DEBUGGER_DUMPHEAP
+#undef DUK_USE_DEBUGGER_FWD_LOGGING
+#undef DUK_USE_DEBUGGER_FWD_PRINTALERT
+#undef DUK_USE_DEBUGGER_INSPECT
+#undef DUK_USE_DEBUGGER_PAUSE_UNCAUGHT
+#undef DUK_USE_DEBUGGER_SUPPORT
+#define DUK_USE_DEBUGGER_THROW_NOTIFY
+#undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE
+#define DUK_USE_DEBUG_BUFSIZE 65536L
+#define DUK_USE_DOUBLE_LINKED_HEAP
+#undef DUK_USE_DPRINT
+#undef DUK_USE_DPRINT_COLORS
+#undef DUK_USE_DPRINT_RDTSC
+#define DUK_USE_ERRCREATE
+#define DUK_USE_ERRTHROW
+#define DUK_USE_ES6_OBJECT_PROTO_PROPERTY
+#define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF
+#define DUK_USE_ES6_PROXY
+#define DUK_USE_ES6_REGEXP_BRACES
+#define DUK_USE_ESBC_LIMITS
+#define DUK_USE_ESBC_MAX_BYTES 2147418112L
+#define DUK_USE_ESBC_MAX_LINENUMBER 2147418112L
+#undef DUK_USE_EXEC_FUN_LOCAL
+#undef DUK_USE_EXEC_INDIRECT_BOUND_CHECK
+#undef DUK_USE_EXEC_TIMEOUT_CHECK
+#undef DUK_USE_EXPLICIT_NULL_INIT
+#undef DUK_USE_EXTSTR_FREE
+#undef DUK_USE_EXTSTR_INTERN_CHECK
+#undef DUK_USE_FASTINT
+#define DUK_USE_FAST_REFCOUNT_DEFAULT
+#define DUK_USE_FILE_IO
+#undef DUK_USE_FUNCPTR16
+#undef DUK_USE_FUNCPTR_DEC16
+#undef DUK_USE_FUNCPTR_ENC16
+#undef DUK_USE_GC_TORTURE
+#undef DUK_USE_HEAPPTR16
+#undef DUK_USE_HEAPPTR_DEC16
+#undef DUK_USE_HEAPPTR_ENC16
+#define DUK_USE_HEX_FASTPATH
+#define DUK_USE_HOBJECT_HASH_PART
+#define DUK_USE_HSTRING_CLEN
+#undef DUK_USE_HSTRING_EXTDATA
+#define DUK_USE_IDCHAR_FASTPATH
+#undef DUK_USE_INTERRUPT_COUNTER
+#undef DUK_USE_INTERRUPT_DEBUG_FIXUP
+#define DUK_USE_JC
+#define DUK_USE_JSON_DECNUMBER_FASTPATH
+#define DUK_USE_JSON_DECSTRING_FASTPATH
+#define DUK_USE_JSON_DEC_RECLIMIT 1000
+#define DUK_USE_JSON_EATWHITE_FASTPATH
+#define DUK_USE_JSON_ENC_RECLIMIT 1000
+#define DUK_USE_JSON_QUOTESTRING_FASTPATH
+#undef DUK_USE_JSON_STRINGIFY_FASTPATH
+#define DUK_USE_JX
+#define DUK_USE_LEXER_SLIDING_WINDOW
+#undef DUK_USE_LIGHTFUNC_BUILTINS
+#undef DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE
+#define DUK_USE_MARK_AND_SWEEP
+#define DUK_USE_MARK_AND_SWEEP_RECLIMIT 256
+#define DUK_USE_MATH_BUILTIN
+#define DUK_USE_MS_STRINGTABLE_RESIZE
+#define DUK_USE_NATIVE_CALL_RECLIMIT 1000
+#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER
+#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER
+#define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
+#undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
+#undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY
+#define DUK_USE_NONSTD_FUNC_STMT
+#define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT
+#define DUK_USE_NONSTD_JSON_ESC_U2028_U2029
+#define DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE
+#define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT
+#define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT
+#undef DUK_USE_OBJSIZES16
+#define DUK_USE_OCTAL_SUPPORT
+#define DUK_USE_PANIC_ABORT
+#undef DUK_USE_PANIC_EXIT
+#undef DUK_USE_PANIC_HANDLER
+#undef DUK_USE_PANIC_SEGFAULT
+#undef DUK_USE_PARANOID_ERRORS
+#define DUK_USE_PC2LINE
+#undef DUK_USE_PREFER_SIZE
+#define DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS
+#undef DUK_USE_REFCOUNT16
+#define DUK_USE_REFERENCE_COUNTING
+#undef DUK_USE_REFZERO_FINALIZER_TORTURE
+#undef DUK_USE_REGEXP_CANON_WORKAROUND
+#define DUK_USE_REGEXP_COMPILER_RECLIMIT 10000
+#define DUK_USE_REGEXP_EXECUTOR_RECLIMIT 10000
+#define DUK_USE_REGEXP_SUPPORT
+#undef DUK_USE_ROM_GLOBAL_CLONE
+#undef DUK_USE_ROM_GLOBAL_INHERIT
+#undef DUK_USE_ROM_OBJECTS
+#define DUK_USE_ROM_PTRCOMP_FIRST 63488L
+#undef DUK_USE_ROM_STRINGS
+#define DUK_USE_SECTION_B
+#undef DUK_USE_SELF_TESTS
+#undef DUK_USE_SHUFFLE_TORTURE
+#define DUK_USE_SOURCE_NONBMP
+#undef DUK_USE_STRHASH16
+#undef DUK_USE_STRHASH_DENSE
+#define DUK_USE_STRHASH_SKIP_SHIFT 5
+#define DUK_USE_STRICT_DECL
+#undef DUK_USE_STRICT_UTF8_SOURCE
+#undef DUK_USE_STRLEN16
+#undef DUK_USE_STRTAB_CHAIN
+#undef DUK_USE_STRTAB_CHAIN_SIZE
+#define DUK_USE_STRTAB_PROBE
+#define DUK_USE_TAILCALL
+#define DUK_USE_TARGET_INFO "unknown"
+#define DUK_USE_TRACEBACKS
+#define DUK_USE_TRACEBACK_DEPTH 10
+#define DUK_USE_USER_DECLARE() /* no user declarations */
+#undef DUK_USE_USER_INITJS
+#undef DUK_USE_VALSTACK_UNSAFE
+#define DUK_USE_VERBOSE_ERRORS
+#define DUK_USE_VERBOSE_EXECUTOR_ERRORS
+#define DUK_USE_VOLUNTARY_GC
+#define DUK_USE_ZERO_BUFFER_DATA
+
+/*
+ * Alternative customization header
+ *
+ * If you want to modify the final DUK_USE_xxx flags directly (without
+ * using the available DUK_OPT_xxx flags), define DUK_OPT_HAVE_CUSTOM_H
+ * and tweak the final flags there.
+ */
+
+#if defined(DUK_OPT_HAVE_CUSTOM_H)
+#include "duk_custom.h"
+#endif
+
+/*
+ * You may add overriding #define/#undef directives below for
+ * customization. You of course cannot un-#include or un-typedef
+ * anything; these require direct changes above.
+ */
+
+/* __OVERRIDE_DEFINES__ */
+
+/*
+ * Date provider selection
+ *
+ * User may define DUK_USE_DATE_GET_NOW() etc directly, in which case we'll
+ * rely on an external provider. If this is not done, revert to previous
+ * behavior and use Unix/Windows built-in provider.
+ */
+
+#if defined(DUK_COMPILING_DUKTAPE)
+
+#if defined(DUK_USE_DATE_GET_NOW)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_NOW_GETTIMEOFDAY)
+#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_gettimeofday((ctx))
+#elif defined(DUK_USE_DATE_NOW_TIME)
+#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_time((ctx))
+#elif defined(DUK_USE_DATE_NOW_WINDOWS)
+#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_windows((ctx))
+#else
+#error no provider for DUK_USE_DATE_GET_NOW()
+#endif
+
+#if defined(DUK_USE_DATE_GET_LOCAL_TZOFFSET)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_TZO_GMTIME_R) || defined(DUK_USE_DATE_TZO_GMTIME)
+#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_gmtime((d))
+#elif defined(DUK_USE_DATE_TZO_WINDOWS)
+#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_windows((d))
+#else
+#error no provider for DUK_USE_DATE_GET_LOCAL_TZOFFSET()
+#endif
+
+#if defined(DUK_USE_DATE_PARSE_STRING)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_PRS_STRPTIME)
+#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_strptime((ctx), (str))
+#elif defined(DUK_USE_DATE_PRS_GETDATE)
+#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_getdate((ctx), (str))
+#else
+/* No provider for DUK_USE_DATE_PARSE_STRING(), fall back to ISO 8601 only. */
+#endif
+
+#if defined(DUK_USE_DATE_FORMAT_STRING)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_FMT_STRFTIME)
+#define DUK_USE_DATE_FORMAT_STRING(ctx,parts,tzoffset,flags) \
+ duk_bi_date_format_parts_strftime((ctx), (parts), (tzoffset), (flags))
+#else
+/* No provider for DUK_USE_DATE_FORMAT_STRING(), fall back to ISO 8601 only. */
+#endif
+
+#endif /* DUK_COMPILING_DUKTAPE */
+
+/*
+ * Checks for legacy feature options (DUK_OPT_xxx)
+ */
+
+#if defined(DUK_OPT_ASSERTIONS)
+#error unsupported legacy feature option DUK_OPT_ASSERTIONS used, consider options: DUK_USE_ASSERTIONS
+#endif
+#if defined(DUK_OPT_BUFFEROBJECT_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_BUFFEROBJECT_SUPPORT used
+#endif
+#if defined(DUK_OPT_BUFLEN16)
+#error unsupported legacy feature option DUK_OPT_BUFLEN16 used
+#endif
+#if defined(DUK_OPT_DATAPTR16)
+#error unsupported legacy feature option DUK_OPT_DATAPTR16 used
+#endif
+#if defined(DUK_OPT_DATAPTR_DEC16)
+#error unsupported legacy feature option DUK_OPT_DATAPTR_DEC16 used
+#endif
+#if defined(DUK_OPT_DATAPTR_ENC16)
+#error unsupported legacy feature option DUK_OPT_DATAPTR_ENC16 used
+#endif
+#if defined(DUK_OPT_DDDPRINT)
+#error unsupported legacy feature option DUK_OPT_DDDPRINT used
+#endif
+#if defined(DUK_OPT_DDPRINT)
+#error unsupported legacy feature option DUK_OPT_DDPRINT used
+#endif
+#if defined(DUK_OPT_DEBUG)
+#error unsupported legacy feature option DUK_OPT_DEBUG used
+#endif
+#if defined(DUK_OPT_DEBUGGER_DUMPHEAP)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_DUMPHEAP used
+#endif
+#if defined(DUK_OPT_DEBUGGER_FWD_LOGGING)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_LOGGING used
+#endif
+#if defined(DUK_OPT_DEBUGGER_FWD_PRINTALERT)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_PRINTALERT used
+#endif
+#if defined(DUK_OPT_DEBUGGER_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_SUPPORT used
+#endif
+#if defined(DUK_OPT_DEBUGGER_TRANSPORT_TORTURE)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_TRANSPORT_TORTURE used
+#endif
+#if defined(DUK_OPT_DEBUG_BUFSIZE)
+#error unsupported legacy feature option DUK_OPT_DEBUG_BUFSIZE used
+#endif
+#if defined(DUK_OPT_DECLARE)
+#error unsupported legacy feature option DUK_OPT_DECLARE used
+#endif
+#if defined(DUK_OPT_DEEP_C_STACK)
+#error unsupported legacy feature option DUK_OPT_DEEP_C_STACK used
+#endif
+#if defined(DUK_OPT_DLL_BUILD)
+#error unsupported legacy feature option DUK_OPT_DLL_BUILD used
+#endif
+#if defined(DUK_OPT_DPRINT)
+#error unsupported legacy feature option DUK_OPT_DPRINT used
+#endif
+#if defined(DUK_OPT_DPRINT_COLORS)
+#error unsupported legacy feature option DUK_OPT_DPRINT_COLORS used
+#endif
+#if defined(DUK_OPT_DPRINT_RDTSC)
+#error unsupported legacy feature option DUK_OPT_DPRINT_RDTSC used
+#endif
+#if defined(DUK_OPT_EXEC_TIMEOUT_CHECK)
+#error unsupported legacy feature option DUK_OPT_EXEC_TIMEOUT_CHECK used
+#endif
+#if defined(DUK_OPT_EXTERNAL_STRINGS)
+#error unsupported legacy feature option DUK_OPT_EXTERNAL_STRINGS used, consider options: DUK_USE_HSTRING_EXTDATA
+#endif
+#if defined(DUK_OPT_EXTSTR_FREE)
+#error unsupported legacy feature option DUK_OPT_EXTSTR_FREE used
+#endif
+#if defined(DUK_OPT_EXTSTR_INTERN_CHECK)
+#error unsupported legacy feature option DUK_OPT_EXTSTR_INTERN_CHECK used
+#endif
+#if defined(DUK_OPT_FASTINT)
+#error unsupported legacy feature option DUK_OPT_FASTINT used, consider options: DUK_USE_FASTINT
+#endif
+#if defined(DUK_OPT_FORCE_ALIGN)
+#error unsupported legacy feature option DUK_OPT_FORCE_ALIGN used
+#endif
+#if defined(DUK_OPT_FORCE_BYTEORDER)
+#error unsupported legacy feature option DUK_OPT_FORCE_BYTEORDER used
+#endif
+#if defined(DUK_OPT_FUNCPTR16)
+#error unsupported legacy feature option DUK_OPT_FUNCPTR16 used
+#endif
+#if defined(DUK_OPT_FUNCPTR_DEC16)
+#error unsupported legacy feature option DUK_OPT_FUNCPTR_DEC16 used
+#endif
+#if defined(DUK_OPT_FUNCPTR_ENC16)
+#error unsupported legacy feature option DUK_OPT_FUNCPTR_ENC16 used
+#endif
+#if defined(DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY used
+#endif
+#if defined(DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY used
+#endif
+#if defined(DUK_OPT_GC_TORTURE)
+#error unsupported legacy feature option DUK_OPT_GC_TORTURE used
+#endif
+#if defined(DUK_OPT_HAVE_CUSTOM_H)
+#error unsupported legacy feature option DUK_OPT_HAVE_CUSTOM_H used
+#endif
+#if defined(DUK_OPT_HEAPPTR16)
+#error unsupported legacy feature option DUK_OPT_HEAPPTR16 used
+#endif
+#if defined(DUK_OPT_HEAPPTR_DEC16)
+#error unsupported legacy feature option DUK_OPT_HEAPPTR_DEC16 used
+#endif
+#if defined(DUK_OPT_HEAPPTR_ENC16)
+#error unsupported legacy feature option DUK_OPT_HEAPPTR_ENC16 used
+#endif
+#if defined(DUK_OPT_INTERRUPT_COUNTER)
+#error unsupported legacy feature option DUK_OPT_INTERRUPT_COUNTER used
+#endif
+#if defined(DUK_OPT_JSON_STRINGIFY_FASTPATH)
+#error unsupported legacy feature option DUK_OPT_JSON_STRINGIFY_FASTPATH used
+#endif
+#if defined(DUK_OPT_LIGHTFUNC_BUILTINS)
+#error unsupported legacy feature option DUK_OPT_LIGHTFUNC_BUILTINS used
+#endif
+#if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY used
+#endif
+#if defined(DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY used
+#endif
+#if defined(DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT)
+#error unsupported legacy feature option DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT used
+#endif
+#if defined(DUK_OPT_NO_AUGMENT_ERRORS)
+#error unsupported legacy feature option DUK_OPT_NO_AUGMENT_ERRORS used
+#endif
+#if defined(DUK_OPT_NO_BROWSER_LIKE)
+#error unsupported legacy feature option DUK_OPT_NO_BROWSER_LIKE used
+#endif
+#if defined(DUK_OPT_NO_BUFFEROBJECT_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_BUFFEROBJECT_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_BYTECODE_DUMP_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_BYTECODE_DUMP_SUPPORT used, consider options: DUK_USE_BYTECODE_DUMP_SUPPORT
+#endif
+#if defined(DUK_OPT_NO_COMMONJS_MODULES)
+#error unsupported legacy feature option DUK_OPT_NO_COMMONJS_MODULES used
+#endif
+#if defined(DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY used
+#endif
+#if defined(DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF)
+#error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF used
+#endif
+#if defined(DUK_OPT_NO_ES6_PROXY)
+#error unsupported legacy feature option DUK_OPT_NO_ES6_PROXY used
+#endif
+#if defined(DUK_OPT_NO_FILE_IO)
+#error unsupported legacy feature option DUK_OPT_NO_FILE_IO used, consider options: DUK_USE_FILE_IO
+#endif
+#if defined(DUK_OPT_NO_FUNC_STMT)
+#error unsupported legacy feature option DUK_OPT_NO_FUNC_STMT used
+#endif
+#if defined(DUK_OPT_NO_JC)
+#error unsupported legacy feature option DUK_OPT_NO_JC used
+#endif
+#if defined(DUK_OPT_NO_JSONC)
+#error unsupported legacy feature option DUK_OPT_NO_JSONC used
+#endif
+#if defined(DUK_OPT_NO_JSONX)
+#error unsupported legacy feature option DUK_OPT_NO_JSONX used
+#endif
+#if defined(DUK_OPT_NO_JX)
+#error unsupported legacy feature option DUK_OPT_NO_JX used
+#endif
+#if defined(DUK_OPT_NO_MARK_AND_SWEEP)
+#error unsupported legacy feature option DUK_OPT_NO_MARK_AND_SWEEP used
+#endif
+#if defined(DUK_OPT_NO_MS_STRINGTABLE_RESIZE)
+#error unsupported legacy feature option DUK_OPT_NO_MS_STRINGTABLE_RESIZE used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_FUNC_STMT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_FUNC_STMT used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029 used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT used
+#endif
+#if defined(DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY used
+#endif
+#if defined(DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF)
+#error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF used
+#endif
+#if defined(DUK_OPT_NO_OCTAL_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_OCTAL_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_PACKED_TVAL)
+#error unsupported legacy feature option DUK_OPT_NO_PACKED_TVAL used
+#endif
+#if defined(DUK_OPT_NO_PC2LINE)
+#error unsupported legacy feature option DUK_OPT_NO_PC2LINE used
+#endif
+#if defined(DUK_OPT_NO_REFERENCE_COUNTING)
+#error unsupported legacy feature option DUK_OPT_NO_REFERENCE_COUNTING used, consider options: DUK_USE_REFERENCE_COUNTING
+#endif
+#if defined(DUK_OPT_NO_REGEXP_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_REGEXP_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_SECTION_B)
+#error unsupported legacy feature option DUK_OPT_NO_SECTION_B used
+#endif
+#if defined(DUK_OPT_NO_SOURCE_NONBMP)
+#error unsupported legacy feature option DUK_OPT_NO_SOURCE_NONBMP used
+#endif
+#if defined(DUK_OPT_NO_STRICT_DECL)
+#error unsupported legacy feature option DUK_OPT_NO_STRICT_DECL used
+#endif
+#if defined(DUK_OPT_NO_TRACEBACKS)
+#error unsupported legacy feature option DUK_OPT_NO_TRACEBACKS used
+#endif
+#if defined(DUK_OPT_NO_VERBOSE_ERRORS)
+#error unsupported legacy feature option DUK_OPT_NO_VERBOSE_ERRORS used
+#endif
+#if defined(DUK_OPT_NO_VOLUNTARY_GC)
+#error unsupported legacy feature option DUK_OPT_NO_VOLUNTARY_GC used
+#endif
+#if defined(DUK_OPT_NO_ZERO_BUFFER_DATA)
+#error unsupported legacy feature option DUK_OPT_NO_ZERO_BUFFER_DATA used
+#endif
+#if defined(DUK_OPT_OBJSIZES16)
+#error unsupported legacy feature option DUK_OPT_OBJSIZES16 used
+#endif
+#if defined(DUK_OPT_PANIC_HANDLER)
+#error unsupported legacy feature option DUK_OPT_PANIC_HANDLER used
+#endif
+#if defined(DUK_OPT_REFCOUNT16)
+#error unsupported legacy feature option DUK_OPT_REFCOUNT16 used
+#endif
+#if defined(DUK_OPT_SEGFAULT_ON_PANIC)
+#error unsupported legacy feature option DUK_OPT_SEGFAULT_ON_PANIC used
+#endif
+#if defined(DUK_OPT_SELF_TESTS)
+#error unsupported legacy feature option DUK_OPT_SELF_TESTS used
+#endif
+#if defined(DUK_OPT_SETJMP)
+#error unsupported legacy feature option DUK_OPT_SETJMP used
+#endif
+#if defined(DUK_OPT_SHUFFLE_TORTURE)
+#error unsupported legacy feature option DUK_OPT_SHUFFLE_TORTURE used
+#endif
+#if defined(DUK_OPT_SIGSETJMP)
+#error unsupported legacy feature option DUK_OPT_SIGSETJMP used
+#endif
+#if defined(DUK_OPT_STRHASH16)
+#error unsupported legacy feature option DUK_OPT_STRHASH16 used
+#endif
+#if defined(DUK_OPT_STRICT_UTF8_SOURCE)
+#error unsupported legacy feature option DUK_OPT_STRICT_UTF8_SOURCE used
+#endif
+#if defined(DUK_OPT_STRLEN16)
+#error unsupported legacy feature option DUK_OPT_STRLEN16 used
+#endif
+#if defined(DUK_OPT_STRTAB_CHAIN)
+#error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN used
+#endif
+#if defined(DUK_OPT_STRTAB_CHAIN_SIZE)
+#error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN_SIZE used
+#endif
+#if defined(DUK_OPT_TARGET_INFO)
+#error unsupported legacy feature option DUK_OPT_TARGET_INFO used
+#endif
+#if defined(DUK_OPT_TRACEBACK_DEPTH)
+#error unsupported legacy feature option DUK_OPT_TRACEBACK_DEPTH used
+#endif
+#if defined(DUK_OPT_UNDERSCORE_SETJMP)
+#error unsupported legacy feature option DUK_OPT_UNDERSCORE_SETJMP used
+#endif
+#if defined(DUK_OPT_USER_INITJS)
+#error unsupported legacy feature option DUK_OPT_USER_INITJS used
+#endif
+
+/*
+ * Checks for config option consistency (DUK_USE_xxx)
+ */
+
+#if defined(DUK_USE_32BIT_PTRS)
+#error unsupported config option used (option has been removed): DUK_USE_32BIT_PTRS
+#endif
+#if defined(DUK_USE_ALIGN_4)
+#error unsupported config option used (option has been removed): DUK_USE_ALIGN_4
+#endif
+#if defined(DUK_USE_ALIGN_8)
+#error unsupported config option used (option has been removed): DUK_USE_ALIGN_8
+#endif
+#if defined(DUK_USE_BYTEORDER_FORCED)
+#error unsupported config option used (option has been removed): DUK_USE_BYTEORDER_FORCED
+#endif
+#if defined(DUK_USE_DATAPTR_DEC16) && !defined(DUK_USE_DATAPTR16)
+#error config option DUK_USE_DATAPTR_DEC16 requires option DUK_USE_DATAPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_DATAPTR_ENC16) && !defined(DUK_USE_DATAPTR16)
+#error config option DUK_USE_DATAPTR_ENC16 requires option DUK_USE_DATAPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_DEBUGGER_SUPPORT) && !defined(DUK_USE_INTERRUPT_COUNTER)
+#error config option DUK_USE_DEBUGGER_SUPPORT requires option DUK_USE_INTERRUPT_COUNTER (which is missing)
+#endif
+#if defined(DUK_USE_DEEP_C_STACK)
+#error unsupported config option used (option has been removed): DUK_USE_DEEP_C_STACK
+#endif
+#if defined(DUK_USE_DOUBLE_BE)
+#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_BE
+#endif
+#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_LE)
+#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_LE (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_ME)
+#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_ME (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_LE)
+#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_LE
+#endif
+#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_BE)
+#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_BE (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_ME)
+#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_ME (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_ME)
+#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_ME
+#endif
+#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_LE)
+#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_LE (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_BE)
+#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_BE (which is also defined)
+#endif
+#if defined(DUK_USE_DPRINT) && !defined(DUK_USE_DEBUG)
+#error config option DUK_USE_DPRINT requires option DUK_USE_DEBUG (which is missing)
+#endif
+#if defined(DUK_USE_ESBC_MAX_BYTES) && !defined(DUK_USE_ESBC_LIMITS)
+#error config option DUK_USE_ESBC_MAX_BYTES requires option DUK_USE_ESBC_LIMITS (which is missing)
+#endif
+#if defined(DUK_USE_ESBC_MAX_LINENUMBER) && !defined(DUK_USE_ESBC_LIMITS)
+#error config option DUK_USE_ESBC_MAX_LINENUMBER requires option DUK_USE_ESBC_LIMITS (which is missing)
+#endif
+#if defined(DUK_USE_EXEC_TIMEOUT_CHECK) && !defined(DUK_USE_INTERRUPT_COUNTER)
+#error config option DUK_USE_EXEC_TIMEOUT_CHECK requires option DUK_USE_INTERRUPT_COUNTER (which is missing)
+#endif
+#if defined(DUK_USE_EXTSTR_FREE) && !defined(DUK_USE_HSTRING_EXTDATA)
+#error config option DUK_USE_EXTSTR_FREE requires option DUK_USE_HSTRING_EXTDATA (which is missing)
+#endif
+#if defined(DUK_USE_EXTSTR_INTERN_CHECK) && !defined(DUK_USE_HSTRING_EXTDATA)
+#error config option DUK_USE_EXTSTR_INTERN_CHECK requires option DUK_USE_HSTRING_EXTDATA (which is missing)
+#endif
+#if defined(DUK_USE_FULL_TVAL)
+#error unsupported config option used (option has been removed): DUK_USE_FULL_TVAL
+#endif
+#if defined(DUK_USE_FUNCPTR_DEC16) && !defined(DUK_USE_FUNCPTR16)
+#error config option DUK_USE_FUNCPTR_DEC16 requires option DUK_USE_FUNCPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_FUNCPTR_ENC16) && !defined(DUK_USE_FUNCPTR16)
+#error config option DUK_USE_FUNCPTR_ENC16 requires option DUK_USE_FUNCPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS)
+#error unsupported config option used (option has been removed): DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS
+#endif
+#if defined(DUK_USE_HEAPPTR16) && defined(DUK_USE_DEBUG)
+#error config option DUK_USE_HEAPPTR16 conflicts with option DUK_USE_DEBUG (which is also defined)
+#endif
+#if defined(DUK_USE_HEAPPTR_DEC16) && !defined(DUK_USE_HEAPPTR16)
+#error config option DUK_USE_HEAPPTR_DEC16 requires option DUK_USE_HEAPPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_HEAPPTR_ENC16) && !defined(DUK_USE_HEAPPTR16)
+#error config option DUK_USE_HEAPPTR_ENC16 requires option DUK_USE_HEAPPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_INTEGER_BE)
+#error unsupported config option used (option has been removed): DUK_USE_INTEGER_BE
+#endif
+#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_LE)
+#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_LE (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_ME)
+#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_ME (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_LE)
+#error unsupported config option used (option has been removed): DUK_USE_INTEGER_LE
+#endif
+#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_BE)
+#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_BE (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_ME)
+#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_ME (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_ME)
+#error unsupported config option used (option has been removed): DUK_USE_INTEGER_ME
+#endif
+#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_LE)
+#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_LE (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_BE)
+#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_BE (which is also defined)
+#endif
+#if defined(DUK_USE_NO_DOUBLE_ALIASING_SELFTEST)
+#error unsupported config option used (option has been removed): DUK_USE_NO_DOUBLE_ALIASING_SELFTEST
+#endif
+#if defined(DUK_USE_PACKED_TVAL_POSSIBLE)
+#error unsupported config option used (option has been removed): DUK_USE_PACKED_TVAL_POSSIBLE
+#endif
+#if defined(DUK_USE_RDTSC)
+#error unsupported config option used (option has been removed): DUK_USE_RDTSC
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_STRINGS)
+#error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_STRINGS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_OBJECTS)
+#error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_OBJECTS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_CLONE) && defined(DUK_USE_ROM_GLOBAL_INHERIT)
+#error config option DUK_USE_ROM_GLOBAL_CLONE conflicts with option DUK_USE_ROM_GLOBAL_INHERIT (which is also defined)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_STRINGS)
+#error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_STRINGS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_OBJECTS)
+#error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_OBJECTS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && defined(DUK_USE_ROM_GLOBAL_CLONE)
+#error config option DUK_USE_ROM_GLOBAL_INHERIT conflicts with option DUK_USE_ROM_GLOBAL_CLONE (which is also defined)
+#endif
+#if defined(DUK_USE_ROM_OBJECTS) && !defined(DUK_USE_ROM_STRINGS)
+#error config option DUK_USE_ROM_OBJECTS requires option DUK_USE_ROM_STRINGS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_STRINGS) && !defined(DUK_USE_ROM_OBJECTS)
+#error config option DUK_USE_ROM_STRINGS requires option DUK_USE_ROM_OBJECTS (which is missing)
+#endif
+#if defined(DUK_USE_SETJMP)
+#error unsupported config option used (option has been removed): DUK_USE_SETJMP
+#endif
+#if defined(DUK_USE_SIGSETJMP)
+#error unsupported config option used (option has been removed): DUK_USE_SIGSETJMP
+#endif
+#if defined(DUK_USE_STRTAB_CHAIN_SIZE) && !defined(DUK_USE_STRTAB_CHAIN)
+#error config option DUK_USE_STRTAB_CHAIN_SIZE requires option DUK_USE_STRTAB_CHAIN (which is missing)
+#endif
+#if defined(DUK_USE_TAILCALL) && defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
+#error config option DUK_USE_TAILCALL conflicts with option DUK_USE_NONSTD_FUNC_CALLER_PROPERTY (which is also defined)
+#endif
+#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE)
+#error unsupported config option used (option has been removed): DUK_USE_UNALIGNED_ACCESSES_POSSIBLE
+#endif
+#if defined(DUK_USE_UNDERSCORE_SETJMP)
+#error unsupported config option used (option has been removed): DUK_USE_UNDERSCORE_SETJMP
+#endif
+
+#if defined(DUK_USE_CPP_EXCEPTIONS) && !defined(__cplusplus)
+#error DUK_USE_CPP_EXCEPTIONS enabled but not compiling with a C++ compiler
+#endif
+
+/*
+ * Convert DUK_USE_BYTEORDER, from whatever source, into currently used
+ * internal defines. If detection failed, #error out.
+ */
+
+#if defined(DUK_USE_BYTEORDER)
+#if (DUK_USE_BYTEORDER == 1)
+#define DUK_USE_INTEGER_LE
+#define DUK_USE_DOUBLE_LE
+#elif (DUK_USE_BYTEORDER == 2)
+#define DUK_USE_INTEGER_LE /* integer endianness is little on purpose */
+#define DUK_USE_DOUBLE_ME
+#elif (DUK_USE_BYTEORDER == 3)
+#define DUK_USE_INTEGER_BE
+#define DUK_USE_DOUBLE_BE
+#else
+#error unsupported: byte order invalid
+#endif /* byte order */
+#else
+#error unsupported: byte order detection failed
+#endif /* defined(DUK_USE_BYTEORDER) */
+
+#endif /* DUK_CONFIG_H_INCLUDED */
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/config/genconfig.py b/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/genconfig.py
similarity index 64%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/config/genconfig.py
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/config/genconfig.py
index 778705e67..9c996481a 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/config/genconfig.py
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/genconfig.py
@@ -1,9 +1,9 @@
-#!/usr/bin/python
+#!/usr/bin/env python2
#
# Process Duktape option metadata and produce various useful outputs:
#
-# - duk_config.h matching Duktape 1.x feature option model (DUK_OPT_xxx)
-# - duk_config.h for a selected platform, compiler, forced options, etc.
+# - duk_config.h with specific or autodetected platform, compiler, and
+# architecture; forced options; sanity checks; etc
# - option documentation for Duktape 1.x feature options (DUK_OPT_xxx)
# - option documentation for Duktape 1.x/2.x config options (DUK_USE_xxx)
#
@@ -15,9 +15,10 @@
# Instead, the goal is to allow the metadata to be extended, or to provide
# a reasonable starting point for manual duk_config.h tweaking.
#
-# NOTE: For Duktape 1.3 release the main goal is to autogenerate a Duktape
-# 1.2 compatible "autodetect" header from snippets. Other outputs are still
-# experimental.
+# For Duktape 1.3 release the main goal was to autogenerate a Duktape 1.2
+# compatible "autodetect" header from legacy snippets, with other outputs
+# being experimental. For Duktape 1.4 duk_config.h is always created from
+# modular sources.
#
import os
@@ -30,7 +31,10 @@ import tarfile
import tempfile
import atexit
import shutil
-import StringIO
+try:
+ from StringIO import StringIO
+except ImportError:
+ from io import StringIO
#
# Globals holding scanned metadata, helper snippets, etc
@@ -56,6 +60,7 @@ allowed_use_meta_keys = [
'feature_enables',
'feature_disables',
'feature_snippet',
+ 'feature_no_default',
'related_feature_defines',
'introduced',
'deprecated',
@@ -113,33 +118,28 @@ assumed_provides = {
}
# Platform files must provide at least these (additional checks
-# in validate_platform_file()).
+# in validate_platform_file()). Fill-ins provide missing optionals.
platform_required_provides = [
- 'DUK_USE_OS_STRING',
- 'DUK_SETJMP', 'DUK_LONGJMP',
+ 'DUK_USE_OS_STRING' # must be #define'd
]
# Architecture files must provide at least these (additional checks
-# in validate_architecture_file()).
+# in validate_architecture_file()). Fill-ins provide missing optionals.
architecture_required_provides = [
- 'DUK_USE_ARCH_STRING',
- 'DUK_USE_ALIGN_BY', 'DUK_USE_UNALIGNED_ACCESSES_POSSIBLE', 'DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS',
- 'DUK_USE_PACKED_TVAL', 'DUK_USE_PACKED_TVAL_POSSIBLE'
+ 'DUK_USE_ARCH_STRING'
]
# Compiler files must provide at least these (additional checks
-# in validate_compiler_file()).
+# in validate_compiler_file()). Fill-ins provide missing optionals.
compiler_required_provides = [
- # XXX: incomplete, maybe a generic fill-in for missing stuff because
- # there's quite a lot of required compiler defines.
+ # Compilers need a lot of defines; missing defines are automatically
+ # filled in with defaults (which are mostly compiler independent), so
+ # the requires define list is not very large.
- 'DUK_USE_COMPILER_STRING',
-
- 'DUK_EXTERNAL_DECL', 'DUK_EXTERNAL',
- 'DUK_INTERNAL_DECL', 'DUK_INTERNAL',
- 'DUK_LOCAL_DECL', 'DUK_LOCAL',
-
- 'DUK_FILE_MACRO', 'DUK_LINE_MACRO', 'DUK_FUNC_MACRO'
+ 'DUK_USE_COMPILER_STRING', # must be #define'd
+ 'DUK_USE_BRANCH_HINTS', # may be #undef'd, as long as provided
+ 'DUK_USE_VARIADIC_MACROS', # may be #undef'd, as long as provided
+ 'DUK_USE_UNION_INITIALIZERS' # may be #undef'd, as long as provided
]
#
@@ -149,7 +149,7 @@ compiler_required_provides = [
def get_auto_delete_tempdir():
tmpdir = tempfile.mkdtemp(suffix='-genconfig')
def _f(dirname):
- print 'Deleting temporary directory: %r' % dirname
+ #print('Deleting temporary directory: %r' % dirname)
if os.path.isdir(dirname) and '-genconfig' in dirname:
shutil.rmtree(dirname)
atexit.register(_f, tmpdir)
@@ -163,6 +163,7 @@ def strip_comments_from_lines(lines):
# Comment contents are stripped of any DUK_ prefixed text to avoid
# incorrect requires/provides detection. Other comment text is kept;
# in particular a "/* redefine */" comment must remain intact here.
+ # (The 'redefine' hack is not actively needed now.)
#
# Avoid Python 2.6 vs. Python 2.7 argument differences.
@@ -212,12 +213,9 @@ class Snippet:
# matters and this is not handled now.)
#
# Also, some snippets may #undef/#define another define but
- # they don't "provide" the define as such. For example,
- # DUK_F_CLANG.h.in undefines DUK_F_GCC defines if clang is
- # detected: DUK_F_CLANG.h.in is considered to require
- # DUK_F_GCC but doesn't provide it. Such redefinitions are
- # marked "/* redefine */" in the snippets. They're best
- # avoided, of course.
+ # they don't "provide" the define as such. Such redefinitions
+ # are marked "/* redefine */" in the snippets. They're best
+ # avoided (and not currently needed in Duktape 1.4.0).
if autoscan_provides:
m = re_line_provides.match(line)
@@ -251,7 +249,15 @@ class Snippet:
for line in f:
if line[-1] == '\n':
line = line[:-1]
- lines.append(line)
+ if line[:8] == '#snippet':
+ m = re.match(r'#snippet\s+"(.*?)"', line)
+ # XXX: better plumbing for lookup path
+ sub_fn = os.path.normpath(os.path.join(filename, '..', '..', 'header-snippets', m.group(1)))
+ #print('#snippet ' + sub_fn)
+ sn = Snippet.fromFile(sub_fn)
+ lines += sn.lines
+ else:
+ lines.append(line)
return Snippet(lines, autoscan_requires=True, autoscan_provides=True)
fromFile = classmethod(fromFile)
@@ -302,10 +308,12 @@ class FileBuilder:
def snippet_relative(self, fn):
sn = Snippet.fromFile(os.path.join(self.base_dir, fn))
self.vals.append(sn)
+ return sn
- def snippet_absolute(fn):
+ def snippet_absolute(self, fn):
sn = Snippet.fromFile(fn)
self.vals.append(sn)
+ return sn
def cpp_error(self, msg):
# XXX: assume no newlines etc
@@ -326,6 +334,9 @@ class FileBuilder:
else:
self.cpp_warning(msg)
+ def chdr_comment_line(self, msg):
+ self.vals.append(Snippet([ '/* %s */' % msg ]))
+
def chdr_block_heading(self, msg):
lines = []
lines.append('')
@@ -381,7 +392,7 @@ def fill_dependencies_for_snippets(snippets, idx_deps):
found = True # at least one other node provides 'k'
if not found:
- #print 'Resolving %r' % k
+ #print('Resolving %r' % k)
resolved.append(k)
# Find a header snippet which provides the missing define.
@@ -448,7 +459,8 @@ def fill_dependencies_for_snippets(snippets, idx_deps):
# print(repr(graph))
# print(repr(snlist))
- print 'Resolved helper defines: %r' % resolved
+# print('Resolved helper defines: %r' % resolved)
+ print('Resolved %d helper defines' % len(resolved))
def serialize_snippet_list(snippets):
ret = []
@@ -563,7 +575,7 @@ def scan_tags_meta(filename):
with open(filename, 'rb') as f:
tags_meta = yaml.load(f)
-def scan_snippets(dirname):
+def scan_helper_snippets(dirname): # DUK_F_xxx snippets
global helper_snippets
helper_snippets = []
@@ -573,33 +585,64 @@ def scan_snippets(dirname):
#print('Autoscanning snippet: %s' % fn)
helper_snippets.append(Snippet.fromFile(os.path.join(dirname, fn)))
+def get_opt_defs(removed=True, deprecated=True, unused=True):
+ ret = []
+ for doc in opt_defs_list:
+ # XXX: aware of target version
+ if removed == False and doc.get('removed', None) is not None:
+ continue
+ if deprecated == False and doc.get('deprecated', None) is not None:
+ continue
+ if unused == False and doc.get('unused', False) == True:
+ continue
+ ret.append(doc)
+ return ret
+
+def get_use_defs(removed=True, deprecated=True, unused=True):
+ ret = []
+ for doc in use_defs_list:
+ # XXX: aware of target version
+ if removed == False and doc.get('removed', None) is not None:
+ continue
+ if deprecated == False and doc.get('deprecated', None) is not None:
+ continue
+ if unused == False and doc.get('unused', False) == True:
+ continue
+ ret.append(doc)
+ return ret
+
def validate_platform_file(filename):
sn = Snippet.fromFile(filename)
- # XXX: move required provides/defines into metadata only
for req in platform_required_provides:
if req not in sn.provides:
raise Exception('Platform %s is missing %s' % (filename, req))
- if not ('DUK_USE_SETJMP' in sn.provides or 'DUK_USE_UNDERSCORE_SETJMP' in sn.provides or
- 'DUK_USE_SIGSETJMP' in sn.provides):
- raise Exception('Platform %s is missing a setjmp provider' % filename)
+ # DUK_SETJMP, DUK_LONGJMP, DUK_JMPBUF_TYPE are optional, fill-in
+ # provides if none defined.
def validate_architecture_file(filename):
sn = Snippet.fromFile(filename)
- # XXX: move required provides/defines into metadata only
for req in architecture_required_provides:
if req not in sn.provides:
raise Exception('Architecture %s is missing %s' % (filename, req))
+ # Byte order and alignment defines are allowed to be missing,
+ # a fill-in will handle them. This is necessary because for
+ # some architecture byte order and/or alignment may vary between
+ # targets and may be software configurable.
+
+ # XXX: require automatic detection to be signaled?
+ # e.g. define DUK_USE_ALIGN_BY -1
+ # define DUK_USE_BYTE_ORDER -1
+
def validate_compiler_file(filename):
sn = Snippet.fromFile(filename)
- # XXX: move required provides/defines into metadata only
for req in compiler_required_provides:
if req not in sn.provides:
- raise Exception('Architecture %s is missing %s' % (filename, req))
+ raise Exception('Compiler %s is missing %s' % (filename, req))
def get_tag_title(tag):
meta = tags_meta.get(tag, None)
@@ -739,10 +782,12 @@ def generate_option_documentation(opts, opt_list=None, rst_title=None, include_d
return ret.join()
def generate_feature_option_documentation(opts):
- return generate_option_documentation(opts, opt_list=opt_defs_list, rst_title='Duktape feature options', include_default=False)
+ defs = get_opt_defs()
+ return generate_option_documentation(opts, opt_list=defs, rst_title='Duktape feature options', include_default=False)
def generate_config_option_documentation(opts):
- return generate_option_documentation(opts, opt_list=use_defs_list, rst_title='Duktape config options', include_default=True)
+ defs = get_use_defs()
+ return generate_option_documentation(opts, opt_list=defs, rst_title='Duktape config options', include_default=True)
#
# Helpers for duk_config.h generation
@@ -753,15 +798,16 @@ def get_forced_options(opts):
# overridden by a more specific one).
forced_opts = {}
for val in opts.force_options_yaml:
- doc = yaml.load(StringIO.StringIO(val))
+ doc = yaml.load(StringIO(val))
for k in doc.keys():
if use_defs.has_key(k):
pass # key is known
else:
- print 'WARNING: option override key %s not defined in metadata, ignoring' % k
+ print('WARNING: option override key %s not defined in metadata, ignoring' % k)
forced_opts[k] = doc[k] # shallow copy
- print 'Overrides: %s' % json.dumps(forced_opts)
+ if len(forced_opts.keys()) > 0:
+ print('Overrides: %s' % json.dumps(forced_opts))
return forced_opts
@@ -771,9 +817,10 @@ def emit_default_from_config_meta(ret, doc, forced_opts, undef_done):
defname = doc['define']
defval = forced_opts.get(defname, doc['default'])
- if defval == True:
+ # NOTE: careful with Python equality, e.g. "0 == False" is true.
+ if isinstance(defval, bool) and defval == True:
ret.line('#define ' + defname)
- elif defval == False:
+ elif isinstance(defval, bool) and defval == False:
if not undef_done:
ret.line('#undef ' + defname)
else:
@@ -802,12 +849,13 @@ def emit_default_from_config_meta(ret, doc, forced_opts, undef_done):
# options which will be removed in Duktape 2.x.
def add_legacy_feature_option_checks(opts, ret):
ret.chdr_block_heading('Checks for legacy feature options (DUK_OPT_xxx)')
+ ret.empty()
defs = []
- for doc in opt_defs_list:
+ for doc in get_opt_defs():
if doc['define'] not in defs:
defs.append(doc['define'])
- for doc in use_defs_list:
+ for doc in get_opt_defs():
for dname in doc.get('related_feature_defines', []):
if dname not in defs:
defs.append(dname)
@@ -815,10 +863,9 @@ def add_legacy_feature_option_checks(opts, ret):
for optname in defs:
suggested = []
- for doc in use_defs_list:
+ for doc in get_use_defs():
if optname in doc.get('related_feature_defines', []):
suggested.append(doc['define'])
- ret.empty()
ret.line('#if defined(%s)' % optname)
if len(suggested) > 0:
ret.cpp_warning_or_error('unsupported legacy feature option %s used, consider options: %s' % (optname, ', '.join(suggested)), opts.sanity_strict)
@@ -832,9 +879,10 @@ def add_legacy_feature_option_checks(opts, ret):
# options, e.g. inconsistent options, invalid option values.
def add_config_option_checks(opts, ret):
ret.chdr_block_heading('Checks for config option consistency (DUK_USE_xxx)')
+ ret.empty()
defs = []
- for doc in use_defs_list:
+ for doc in get_use_defs():
if doc['define'] not in defs:
defs.append(doc['define'])
defs.sort()
@@ -846,29 +894,27 @@ def add_config_option_checks(opts, ret):
# XXX: more checks
if doc.get('removed', None) is not None:
- ret.empty()
ret.line('#if defined(%s)' % dname)
ret.cpp_warning_or_error('unsupported config option used (option has been removed): %s' % dname, opts.sanity_strict)
ret.line('#endif')
elif doc.get('deprecated', None) is not None:
- ret.empty()
ret.line('#if defined(%s)' % dname)
ret.cpp_warning_or_error('unsupported config option used (option has been deprecated): %s' % dname, opts.sanity_strict)
ret.line('#endif')
for req in doc.get('requires', []):
- ret.empty()
ret.line('#if defined(%s) && !defined(%s)' % (dname, req))
ret.cpp_warning_or_error('config option %s requires option %s (which is missing)' % (dname, req), opts.sanity_strict)
ret.line('#endif')
for req in doc.get('conflicts', []):
- ret.empty()
ret.line('#if defined(%s) && defined(%s)' % (dname, req))
ret.cpp_warning_or_error('config option %s conflicts with option %s (which is also defined)' % (dname, req), opts.sanity_strict)
ret.line('#endif')
ret.empty()
+ ret.snippet_relative('cpp_exception_sanity.h.in')
+ ret.empty()
# Add a header snippet for providing a __OVERRIDE_DEFINES__ section.
def add_override_defines_section(opts, ret):
@@ -884,10 +930,10 @@ def add_override_defines_section(opts, ret):
# Add automatic DUK_OPT_XXX and DUK_OPT_NO_XXX handling for backwards
# compatibility with Duktape 1.2 and before.
-def add_feature_option_handling(opts, ret, forced_opts):
+def add_feature_option_handling(opts, ret, forced_opts, already_provided_keys):
ret.chdr_block_heading('Feature option handling')
- for doc in use_defs_list:
+ for doc in get_use_defs(removed=False, deprecated=False, unused=False):
# If a related feature option exists, it can be used to force
# enable/disable the target feature. If neither feature option
# (DUK_OPT_xxx or DUK_OPT_NO_xxx) is given, revert to default.
@@ -919,7 +965,18 @@ def add_feature_option_handling(opts, ret, forced_opts):
ret.line('#undef %s' % config_define)
ret.line('#else')
undef_done = False
- emit_default_from_config_meta(ret, doc, forced_opts, undef_done)
+
+ # For some options like DUK_OPT_PACKED_TVAL the default comes
+ # from platform definition.
+ if doc.get('feature_no_default', False):
+ print('Skip default for option %s' % config_define)
+ ret.line('/* Already provided above */')
+ elif already_provided_keys.has_key(config_define):
+ # This is a fallback in case config option metadata is wrong.
+ print('Skip default for option %s (already provided but not flagged in metadata!)' % config_define)
+ ret.line('/* Already provided above */')
+ else:
+ emit_default_from_config_meta(ret, doc, forced_opts, undef_done)
ret.line('#endif')
elif doc.has_key('feature_snippet'):
ret.lines(doc['feature_snippet'])
@@ -939,7 +996,7 @@ def add_duk_active_defines_macro(ret):
ret.chdr_block_heading('DUK_ACTIVE_DEFINES macro (development only)')
idx = 0
- for doc in use_defs_list:
+ for doc in get_use_defs():
defname = doc['define']
ret.line('#if defined(%s)' % defname)
@@ -960,250 +1017,21 @@ def add_duk_active_defines_macro(ret):
# duk_config.h generation
#
-# Generate the default duk_config.h which provides automatic detection of
-# platform, compiler, architecture, and features for major platforms.
-# Use manually written monolithic header snippets from Duktape 1.2 for
-# generating the header. This header is Duktape 1.2 compatible and supports
-# DUK_OPT_xxx feature options. Later on the DUK_OPT_xxx options will be
-# removed and users can override DUK_USE_xxx flags directly by modifying
-# duk_config.h or by generating a new header using genconfig.
-def generate_autodetect_duk_config_header(opts, meta_dir):
- ret = FileBuilder(base_dir=os.path.join(meta_dir, 'header-snippets'), \
- use_cpp_warning=opts.use_cpp_warning)
-
- forced_opts = get_forced_options(opts)
-
- ret.snippet_relative('comment_prologue.h.in')
- ret.empty()
-
- ret.line('#ifndef DUK_CONFIG_H_INCLUDED')
- ret.line('#define DUK_CONFIG_H_INCLUDED')
- ret.empty()
-
- # Compiler features, processor/architecture, OS, compiler
- ret.snippet_relative('compiler_features.h.in')
- ret.empty()
- ret.snippet_relative('rdtsc.h.in') # XXX: move downwards
- ret.empty()
- ret.snippet_relative('platform1.h.in')
- ret.empty()
-
- # Feature selection, system include, Date provider
- # Most #include statements are here
- ret.snippet_relative('platform2.h.in')
- ret.empty()
- ret.snippet_relative('ullconsts.h.in')
- ret.empty()
- ret.snippet_relative('libc.h.in')
- ret.empty()
-
- # Number types
- ret.snippet_relative('types1.h.in')
- ret.line('#if defined(DUK_F_HAVE_INTTYPES)')
- ret.line('/* C99 or compatible */')
- ret.empty()
- ret.snippet_relative('types_c99.h.in')
- ret.empty()
- ret.line('#else /* C99 types */')
- ret.empty()
- ret.snippet_relative('types_legacy.h.in')
- ret.empty()
- ret.line('#endif /* C99 types */')
- ret.empty()
- ret.snippet_relative('types2.h.in')
- ret.empty()
- ret.snippet_relative('64bitops.h.in')
- ret.empty()
-
- # Alignment
- ret.snippet_relative('alignment.h.in')
- ret.empty()
-
- # Object layout
- ret.snippet_relative('object_layout.h.in')
- ret.empty()
-
- # Byte order
- ret.snippet_relative('byteorder.h.in')
- ret.empty()
-
- # Packed duk_tval
- ret.snippet_relative('packed_tval.h.in')
- ret.empty()
-
- # Detect 'fast math'
- ret.snippet_relative('reject_fast_math.h.in')
- ret.empty()
-
- # IEEE double constants
- ret.snippet_relative('double_const.h.in')
- ret.empty()
-
- # Math and other ANSI replacements, NetBSD workaround, paranoid math, paranoid Date
- ret.snippet_relative('repl_math.h.in')
- ret.empty()
- ret.snippet_relative('paranoid_date.h.in')
- ret.empty()
- ret.snippet_relative('repl_ansi.h.in')
- ret.empty()
-
- # Platform function pointers
- ret.snippet_relative('platform_funcptr.h.in')
- ret.empty()
-
- # General compiler stuff
- ret.snippet_relative('stringify.h.in')
- ret.empty()
- ret.snippet_relative('segfault.h.in')
- ret.empty()
- ret.snippet_relative('unreferenced.h.in')
- ret.empty()
- ret.snippet_relative('noreturn.h.in')
- ret.empty()
- ret.snippet_relative('unreachable.h.in')
- ret.empty()
- ret.snippet_relative('likely.h.in')
- ret.empty()
- ret.snippet_relative('inline.h.in')
- ret.empty()
- ret.snippet_relative('visibility.h.in')
- ret.empty()
- ret.snippet_relative('file_line_func.h.in')
- ret.empty()
- ret.snippet_relative('byteswap.h.in')
- ret.empty()
-
- # Arhitecture, OS, and compiler strings
- ret.snippet_relative('arch_string.h.in')
- ret.empty()
- ret.snippet_relative('os_string.h.in')
- ret.empty()
- ret.snippet_relative('compiler_string.h.in')
- ret.empty()
-
- # Target info
- ret.snippet_relative('target_info.h.in')
- ret.empty()
-
- # Longjmp handling
- ret.snippet_relative('longjmp.h.in')
- ret.empty()
-
- # Unsorted flags, contains almost all actual Duktape-specific
- # but platform independent features
- ret.snippet_relative('unsorted_flags.h.in')
- ret.empty()
-
- # User declarations
- ret.snippet_relative('user_declare.h.in')
- ret.empty()
-
- # Emit forced options. If a corresponding option is already defined
- # by a snippet above, #undef it first.
-
- tmp = Snippet(ret.join().split('\n'))
- first_forced = True
- for doc in use_defs_list:
- defname = doc['define']
-
- if doc.get('removed', None) is not None and opts.omit_removed_config_options:
- continue
- if doc.get('deprecated', None) is not None and opts.omit_deprecated_config_options:
- continue
- if doc.get('unused', False) == True and opts.omit_unused_config_options:
- continue
- if not forced_opts.has_key(defname):
- continue
-
- if not doc.has_key('default'):
- raise Exception('config option %s is missing default value' % defname)
-
- if first_forced:
- ret.chdr_block_heading('Forced options')
- first_forced = False
-
- undef_done = False
- if tmp.provides.has_key(defname):
- ret.line('#undef ' + defname)
- undef_done = True
-
- emit_default_from_config_meta(ret, doc, forced_opts, undef_done)
-
- ret.empty()
-
- # If manually-edited snippets don't #define or #undef a certain
- # config option, emit a default value here. This is useful to
- # fill-in for new config options not covered by manual snippets
- # (which is intentional).
-
- tmp = Snippet(ret.join().split('\n'))
- need = {}
- for doc in use_defs_list:
- if doc.get('removed', None) is not None: # XXX: check version
- continue
- need[doc['define']] = True
- for k in tmp.provides.keys():
- if need.has_key(k):
- del need[k]
- need_keys = sorted(need.keys())
-
- if len(need_keys) > 0:
- ret.chdr_block_heading('Autogenerated defaults')
-
- for k in need_keys:
- #print('config option %s not covered by manual snippets, emitting default automatically' % k)
- emit_default_from_config_meta(ret, use_defs[k], {}, False)
-
- ret.empty()
-
- ret.snippet_relative('custom_header.h.in')
- ret.empty()
-
- if len(opts.fixup_header_lines) > 0:
- ret.chdr_block_heading('Fixups')
- for line in opts.fixup_header_lines:
- ret.line(line)
- ret.empty()
-
- add_override_defines_section(opts, ret)
-
- # Date provider snippet is after custom header and overrides, so that
- # the user may define e.g. DUK_USE_DATE_NOW_GETTIMEOFDAY in their
- # custom header.
- ret.snippet_relative('date_provider.h.in')
- ret.empty()
-
- # Sanity checks
- # XXX: use autogenerated sanity checks instead
- ret.snippet_relative('sanity.h.in')
- ret.empty()
-
- if opts.emit_legacy_feature_check:
- # XXX: this doesn't really make sense for the autodetect
- # header yet, because sanity.h.in already covers these.
- add_legacy_feature_option_checks(opts, ret)
- if opts.emit_config_sanity_check:
- add_config_option_checks(opts, ret)
- if opts.add_active_defines_macro:
- add_duk_active_defines_macro(ret)
-
- ret.line('#endif /* DUK_CONFIG_H_INCLUDED */')
- ret.empty() # for trailing newline
- return remove_duplicate_newlines(ret.join())
-
# Generate a duk_config.h where platform, architecture, and compiler are
-# all either autodetected or specified by user. When autodetection is
-# used, the generated header is based on modular snippets and metadata to
-# be more easily maintainable than manually edited monolithic snippets.
+# all either autodetected or specified by user.
#
-# This approach will replace the legacy autodetect header in Duktape 1.4,
-# and most likely the separate barebones header also.
+# Autodetection is based on a configured list of supported platforms,
+# architectures, and compilers. For example, platforms.yaml defines the
+# supported platforms and provides a helper define (DUK_F_xxx) to use for
+# detecting that platform, and names the header snippet to provide the
+# platform-specific definitions. Necessary dependencies (DUK_F_xxx) are
+# automatically pulled in.
#
-# The generated header is Duktape 1.2 compatible for now, and supports
-# DUK_OPT_xxx feature options. Later on the DUK_OPT_xxx options will be
-# removed and user code overrides DUK_USE_xxx flags directly by modifying
-# duk_config.h manually or by generating a new header using genconfig.
-def generate_autodetect_duk_config_header_modular(opts, meta_dir):
+# Automatic "fill ins" are used for mandatory platform, architecture, and
+# compiler defines which have a reasonable portable default. This reduces
+# e.g. compiler-specific define count because there are a lot compiler
+# macros which have a good default.
+def generate_duk_config_header(opts, meta_dir):
ret = FileBuilder(base_dir=os.path.join(meta_dir, 'header-snippets'), \
use_cpp_warning=opts.use_cpp_warning)
@@ -1219,11 +1047,15 @@ def generate_autodetect_duk_config_header_modular(opts, meta_dir):
with open(os.path.join(meta_dir, 'compilers.yaml'), 'rb') as f:
compilers = yaml.load(f)
+ # XXX: indicate feature option support, sanity checks enabled, etc
+ # in general summary of options, perhaps genconfig command line?
+
ret.line('/*')
- ret.line(' * duk_config.h autodetect header generated by genconfig.py.')
+ ret.line(' * duk_config.h configuration header generated by genconfig.py.')
ret.line(' *')
ret.line(' * Git commit: %s' % opts.git_commit or 'n/a')
ret.line(' * Git describe: %s' % opts.git_describe or 'n/a')
+ ret.line(' * Git branch: %s' % opts.git_branch or 'n/a')
ret.line(' *')
if opts.platform is not None:
ret.line(' * Platform: ' + opts.platform)
@@ -1248,13 +1080,35 @@ def generate_autodetect_duk_config_header_modular(opts, meta_dir):
ret.line(' *')
ret.line(' */')
ret.empty()
- ret.line('#ifndef DUK_CONFIG_H_INCLUDED')
+ ret.line('#if !defined(DUK_CONFIG_H_INCLUDED)')
ret.line('#define DUK_CONFIG_H_INCLUDED')
ret.empty()
ret.chdr_block_heading('Intermediate helper defines')
- idx_deps = len(ret.vals) # position where to emit dependencies
+ # DLL build affects visibility attributes on Windows but unfortunately
+ # cannot be detected automatically from preprocessor defines or such.
+ # DLL build status is hidden behind DUK_F_DLL_BUILD and there are two
+ # ways for that to be set:
+ #
+ # - Duktape 1.3 backwards compatible DUK_OPT_DLL_BUILD
+ # - Genconfig --dll option
+ ret.chdr_comment_line('DLL build detection')
+ ret.line('#if defined(DUK_OPT_DLL_BUILD)')
+ ret.line('#define DUK_F_DLL_BUILD')
+ ret.line('#elif defined(DUK_OPT_NO_DLL_BUILD)')
+ ret.line('#undef DUK_F_DLL_BUILD')
+ ret.line('#else')
+ if opts.dll:
+ ret.line('/* configured for DLL build */')
+ ret.line('#define DUK_F_DLL_BUILD')
+ else:
+ ret.line('/* not configured for DLL build */')
+ ret.line('#undef DUK_F_DLL_BUILD')
+ ret.line('#endif')
+ ret.empty()
+
+ idx_deps = len(ret.vals) # position where to emit DUK_F_xxx dependencies
# Feature selection, system include, Date provider
# Most #include statements are here
@@ -1267,8 +1121,9 @@ def generate_autodetect_duk_config_header_modular(opts, meta_dir):
# XXX: better to lookup platforms metadata
include = 'platform_%s.h.in' % opts.platform
- validate_platform_file(os.path.join(meta_dir, 'header-snippets', include))
- ret.snippet_relative(include)
+ abs_fn = os.path.join(meta_dir, 'platforms', include)
+ validate_platform_file(abs_fn)
+ ret.snippet_absolute(abs_fn)
else:
ret.chdr_block_heading('Platform autodetection')
@@ -1278,7 +1133,9 @@ def generate_autodetect_duk_config_header_modular(opts, meta_dir):
for idx, platf in enumerate(platforms['autodetect']):
check = platf.get('check', None)
include = platf['include']
- validate_platform_file(os.path.join(meta_dir, 'header-snippets', include))
+ abs_fn = os.path.join(meta_dir, 'platforms', include)
+
+ validate_platform_file(abs_fn)
if idx == 0:
ret.line('#if defined(%s)' % check)
@@ -1287,26 +1144,43 @@ def generate_autodetect_duk_config_header_modular(opts, meta_dir):
ret.line('#else')
else:
ret.line('#elif defined(%s)' % check)
- ret.snippet_relative(include)
+ ret.line('/* --- %s --- */' % platf.get('name', '???'))
+ ret.snippet_absolute(abs_fn)
ret.line('#endif /* autodetect platform */')
+ ret.empty()
ret.snippet_relative('platform_sharedincludes.h.in')
ret.empty()
+ byteorder_provided_by_all = True # byteorder provided by all architecture files
+ alignment_provided_by_all = True # alignment provided by all architecture files
+ packedtval_provided_by_all = True # packed tval provided by all architecture files
+
if opts.architecture is not None:
ret.chdr_block_heading('Architecture: ' + opts.architecture)
# XXX: better to lookup architectures metadata
include = 'architecture_%s.h.in' % opts.architecture
- validate_architecture_file(os.path.join(meta_dir, 'header-snippets', include))
- ret.snippet_relative(include)
+ abs_fn = os.path.join(meta_dir, 'architectures', include)
+ validate_architecture_file(abs_fn)
+ sn = ret.snippet_absolute(abs_fn)
+ if not sn.provides.get('DUK_USE_BYTEORDER', False):
+ byteorder_provided_by_all = False
+ if not sn.provides.get('DUK_USE_ALIGN_BY', False):
+ alignment_provided_by_all = False
+ if sn.provides.get('DUK_USE_PACKED_TVAL', False):
+ ret.line('#define DUK_F_PACKED_TVAL_PROVIDED') # signal to fillin
+ else:
+ packedtval_provided_by_all = False
else:
ret.chdr_block_heading('Architecture autodetection')
for idx, arch in enumerate(architectures['autodetect']):
check = arch.get('check', None)
include = arch['include']
- validate_architecture_file(os.path.join(meta_dir, 'header-snippets', include))
+ abs_fn = os.path.join(meta_dir, 'architectures', include)
+
+ validate_architecture_file(abs_fn)
if idx == 0:
ret.line('#if defined(%s)' % check)
@@ -1315,23 +1189,37 @@ def generate_autodetect_duk_config_header_modular(opts, meta_dir):
ret.line('#else')
else:
ret.line('#elif defined(%s)' % check)
- ret.snippet_relative(include)
+ ret.line('/* --- %s --- */' % arch.get('name', '???'))
+ sn = ret.snippet_absolute(abs_fn)
+ if not sn.provides.get('DUK_USE_BYTEORDER', False):
+ byteorder_provided_by_all = False
+ if not sn.provides.get('DUK_USE_ALIGN_BY', False):
+ alignment_provided_by_all = False
+ if sn.provides.get('DUK_USE_PACKED_TVAL', False):
+ ret.line('#define DUK_F_PACKED_TVAL_PROVIDED') # signal to fillin
+ else:
+ packedtval_provided_by_all = False
ret.line('#endif /* autodetect architecture */')
+ ret.empty()
+
if opts.compiler is not None:
ret.chdr_block_heading('Compiler: ' + opts.compiler)
# XXX: better to lookup compilers metadata
include = 'compiler_%s.h.in' % opts.compiler
- validate_compiler_file(os.path.join(meta_dir, 'header-snippets', include))
- ret.snippet_relative(include)
+ abs_fn = os.path.join(meta_dir, 'compilers', include)
+ validate_compiler_file(abs_fn)
+ sn = ret.snippet_absolute(abs_fn)
else:
ret.chdr_block_heading('Compiler autodetection')
for idx, comp in enumerate(compilers['autodetect']):
check = comp.get('check', None)
include = comp['include']
- validate_compiler_file(os.path.join(meta_dir, 'header-snippets', include))
+ abs_fn = os.path.join(meta_dir, 'compilers', include)
+
+ validate_compiler_file(abs_fn)
if idx == 0:
ret.line('#if defined(%s)' % check)
@@ -1340,143 +1228,95 @@ def generate_autodetect_duk_config_header_modular(opts, meta_dir):
ret.line('#else')
else:
ret.line('#elif defined(%s)' % check)
- ret.snippet_relative(include)
+ ret.line('/* --- %s --- */' % comp.get('name', '???'))
+ sn = ret.snippet_absolute(abs_fn)
ret.line('#endif /* autodetect compiler */')
- # FIXME: The snippets below have some conflicts with the platform,
- # architecture, and compiler snippets files included above. These
- # need to be resolved so that (a) each define is only provided from
- # one place or (b) the latter definition is a "fill-in" which is
- # only used when a certain define is missing from e.g. a compiler
- # snippet (useful for e.g. compiler defines which have sane, standard
- # defaults).
-
- # FIXME: __uclibc__ needs stdlib.h, but it really is the only exception
- ret.snippet_relative('libc.h.in')
ret.empty()
+ # DUK_F_UCLIBC is special because __UCLIBC__ is provided by an #include
+ # file, so the check must happen after platform includes. It'd be nice
+ # for this to be automatic (e.g. DUK_F_UCLIBC.h.in could indicate the
+ # dependency somehow).
+
+ ret.snippet_absolute(os.path.join(meta_dir, 'helper-snippets', 'DUK_F_UCLIBC.h.in'))
+ ret.empty()
+
+ # XXX: platform/compiler could provide types; if so, need some signaling
+ # defines like DUK_F_TYPEDEFS_DEFINED
+
# Number types
- ret.snippet_relative('types1.h.in')
- ret.line('#if defined(DUK_F_HAVE_INTTYPES)')
- ret.line('/* C99 or compatible */')
- ret.empty()
- ret.snippet_relative('types_c99.h.in')
- ret.empty()
- ret.line('#else /* C99 types */')
- ret.empty()
- ret.snippet_relative('types_legacy.h.in')
- ret.empty()
- ret.line('#endif /* C99 types */')
- ret.empty()
+ if opts.c99_types_only:
+ ret.snippet_relative('types1.h.in')
+ ret.line('/* C99 types assumed */')
+ ret.snippet_relative('types_c99.h.in')
+ ret.empty()
+ else:
+ ret.snippet_relative('types1.h.in')
+ ret.line('#if defined(DUK_F_HAVE_INTTYPES)')
+ ret.line('/* C99 or compatible */')
+ ret.empty()
+ ret.snippet_relative('types_c99.h.in')
+ ret.empty()
+ ret.line('#else /* C99 types */')
+ ret.empty()
+ ret.snippet_relative('types_legacy.h.in')
+ ret.empty()
+ ret.line('#endif /* C99 types */')
+ ret.empty()
ret.snippet_relative('types2.h.in')
ret.empty()
ret.snippet_relative('64bitops.h.in')
ret.empty()
- # Alignment
- ret.snippet_relative('alignment.h.in')
+ # Platform, architecture, compiler fillins. These are after all
+ # detection so that e.g. DUK_SPRINTF() can be provided by platform
+ # or compiler before trying a fill-in.
+
+ ret.chdr_block_heading('Fill-ins for platform, architecture, and compiler')
+
+ ret.snippet_relative('platform_fillins.h.in')
ret.empty()
+ ret.snippet_relative('architecture_fillins.h.in')
+ if not byteorder_provided_by_all:
+ ret.empty()
+ ret.snippet_relative('byteorder_fillin.h.in')
+ if not alignment_provided_by_all:
+ ret.empty()
+ ret.snippet_relative('alignment_fillin.h.in')
+ ret.empty()
+ ret.snippet_relative('compiler_fillins.h.in')
+ ret.empty()
+ ret.snippet_relative('inline_workaround.h.in')
+ ret.empty()
+ if not packedtval_provided_by_all:
+ ret.empty()
+ ret.snippet_relative('packed_tval_fillin.h.in')
# Object layout
ret.snippet_relative('object_layout.h.in')
ret.empty()
- # Byte order
- # FIXME: from the architecture snippet
- ret.snippet_relative('byteorder.h.in')
- ret.empty()
-
- # Packed duk_tval
- # FIXME: from the architecture snippet
- ret.snippet_relative('packed_tval.h.in')
- ret.empty()
-
- # Detect 'fast math'
+ # Detect and reject 'fast math'
ret.snippet_relative('reject_fast_math.h.in')
ret.empty()
- # IEEE double constants
- # FIXME: these should maybe be 'fill-ins' if previous headers
- # didn't provide something
- ret.snippet_relative('double_const.h.in')
- ret.empty()
-
- # Math and other ANSI replacements, NetBSD workaround, paranoid math, paranoid Date
- ret.snippet_relative('repl_math.h.in')
- ret.empty()
- ret.snippet_relative('paranoid_date.h.in')
- ret.empty()
- ret.snippet_relative('repl_ansi.h.in')
- ret.empty()
-
- # Platform function pointers
- ret.snippet_relative('platform_funcptr.h.in')
- ret.empty()
-
- # General compiler stuff
- ret.snippet_relative('stringify.h.in')
- ret.empty()
- ret.snippet_relative('segfault.h.in')
- ret.empty()
- ret.snippet_relative('unreferenced.h.in')
- ret.empty()
- ret.snippet_relative('noreturn.h.in')
- ret.empty()
- ret.snippet_relative('unreachable.h.in')
- ret.empty()
- ret.snippet_relative('likely.h.in')
- ret.empty()
- ret.snippet_relative('inline.h.in')
- ret.empty()
- ret.snippet_relative('visibility.h.in')
- ret.empty()
- ret.snippet_relative('file_line_func.h.in')
- ret.empty()
- ret.snippet_relative('byteswap.h.in')
- ret.empty()
-
- # These come directly from platform, architecture, and compiler
- # snippets.
- #ret.snippet_relative('arch_string.h.in')
- #ret.empty()
- #ret.snippet_relative('os_string.h.in')
- #ret.empty()
- #ret.snippet_relative('compiler_string.h.in')
- #ret.empty()
- #ret.snippet_relative('longjmp.h.in')
- #ret.empty()
-
- # Target info
- ret.snippet_relative('target_info.h.in')
- ret.empty()
-
# Automatic DUK_OPT_xxx feature option handling
- # FIXME: platform setjmp/longjmp defines now conflict with this
- if True:
- # Unsorted flags, contains almost all actual Duktape-specific
- # but platform independent features
- #ret.snippet_relative('unsorted_flags.h.in')
- #ret.empty()
-
- add_feature_option_handling(opts, ret, forced_opts)
-
- ret.snippet_relative('user_declare.h.in')
- ret.empty()
+ if opts.support_feature_options:
+ print('Autogenerating feature option (DUK_OPT_xxx) support')
+ tmp = Snippet(ret.join().split('\n'))
+ add_feature_option_handling(opts, ret, forced_opts, tmp.provides)
# Emit forced options. If a corresponding option is already defined
# by a snippet above, #undef it first.
tmp = Snippet(ret.join().split('\n'))
first_forced = True
- for doc in use_defs_list:
+ for doc in get_use_defs(removed=not opts.omit_removed_config_options,
+ deprecated=not opts.omit_deprecated_config_options,
+ unused=not opts.omit_unused_config_options):
defname = doc['define']
- if doc.get('removed', None) is not None and opts.omit_removed_config_options:
- continue
- if doc.get('deprecated', None) is not None and opts.omit_deprecated_config_options:
- continue
- if doc.get('unused', False) == True and opts.omit_unused_config_options:
- continue
if not forced_opts.has_key(defname):
continue
@@ -1503,9 +1343,7 @@ def generate_autodetect_duk_config_header_modular(opts, meta_dir):
tmp = Snippet(ret.join().split('\n'))
need = {}
- for doc in use_defs_list:
- if doc.get('removed', None) is not None: # XXX: check version
- continue
+ for doc in get_use_defs(removed=False):
need[doc['define']] = True
for k in tmp.provides.keys():
if need.has_key(k):
@@ -1540,189 +1378,23 @@ def generate_autodetect_duk_config_header_modular(opts, meta_dir):
ret.fill_dependencies_for_snippets(idx_deps)
- # FIXME: use autogenerated sanity instead of sanity.h.in
-
- ret.snippet_relative('sanity.h.in')
- ret.empty()
-
if opts.emit_legacy_feature_check:
- # FIXME: this doesn't really make sense for the autodetect header yet
add_legacy_feature_option_checks(opts, ret)
if opts.emit_config_sanity_check:
add_config_option_checks(opts, ret)
if opts.add_active_defines_macro:
add_duk_active_defines_macro(ret)
+ # Derived defines (DUK_USE_INTEGER_LE, etc) from DUK_USE_BYTEORDER.
+ # Duktape internals currently rely on the derived defines. This is
+ # after sanity checks because the derived defines are marked removed.
+ ret.snippet_relative('byteorder_derived.h.in')
+ ret.empty()
+
ret.line('#endif /* DUK_CONFIG_H_INCLUDED */')
ret.empty() # for trailing newline
return remove_duplicate_newlines(ret.join())
-# Generate a barebones duk_config.h header for a specific platform, architecture,
-# and compiler. The header won't do automatic feature detection and does not
-# support DUK_OPT_xxx feature options (which will be removed in Duktape 2.x).
-# Users can then modify this barebones header for very exotic platforms and manage
-# the needed changes either as a YAML file or by appending a fixup header snippet.
-#
-# XXX: to be replaced by generate_modular_duk_config_header().
-def generate_barebones_duk_config_header(opts, meta_dir):
- ret = FileBuilder(base_dir=os.path.join(meta_dir, 'header-snippets'), \
- use_cpp_warning=opts.use_cpp_warning)
-
- # XXX: Provide more defines from YAML config files so that such
- # defines can be overridden more conveniently (e.g. DUK_COS).
-
- forced_opts = get_forced_options(opts)
-
- ret.line('/*')
- ret.line(' * duk_config.h generated by genconfig.py for:')
- ret.line(' * platform: %s' % opts.platform)
- ret.line(' * compiler: %s' % opts.compiler)
- ret.line(' * architecture: %s' % opts.architecture)
- ret.line(' *')
- ret.line(' * Git commit: %s' % opts.git_commit or 'n/a')
- ret.line(' * Git describe: %s' % opts.git_describe or 'n/a')
- ret.line(' */')
- ret.empty()
- ret.line('#ifndef DUK_CONFIG_H_INCLUDED')
- ret.line('#define DUK_CONFIG_H_INCLUDED')
-
- ret.chdr_block_heading('Intermediate helper defines')
-
- idx_deps = len(ret.vals) # position where to emit dependencies
-
- ret.chdr_block_heading('Platform headers and typedefs')
-
- if opts.platform is None:
- raise Exception('no platform specified')
-
- fn = 'platform_%s.h.in' % opts.platform
- ret.snippet_relative(fn)
- ret.empty()
- ret.snippet_relative('types_c99.h.in') # XXX: C99 typedefs forced for now
- ret.snippet_relative('types2.h.in') # XXX: boilerplate type stuff
-
- ret.chdr_block_heading('Platform features')
-
- # XXX: double constants
- # XXX: replacement functions
- # XXX: inherit definitions (like '#define DUK_FFLUSH fflush') from a
- # generic set of defaults, allow platform configs to override
-
- ret.snippet_relative('platform_generic.h.in')
-
- ret.chdr_block_heading('Compiler features')
-
- if opts.compiler is None:
- raise Exception('no compiler specified')
-
- fn = 'compiler_%s.h.in' % opts.compiler
- ret.snippet_relative(fn)
-
- # noreturn, vacopy, etc
- # visibility attributes
-
- ret.chdr_block_heading('Architecture features')
-
- if opts.architecture is None:
- raise Exception('no architecture specified')
-
- fn = 'architecture_%s.h.in' % opts.architecture
- ret.snippet_relative(fn)
-
- ret.chdr_block_heading('Config options')
-
- tags = get_tag_list_with_preferred_order(header_tag_order)
-
- handled = {}
-
- # Mark all defines 'provided' by the snippets so far as handled.
- # For example, if the system header provides a DUK_USE_OS_STRING,
- # we won't emit it again below with its default value (but will
- # emit an override value if specified).
-
- for sn in ret.vals:
- for k in sn.provides.keys():
- handled[k] = True
-
- for tag in tags:
- ret.line('/* ' + get_tag_title(tag) + ' */')
-
- for doc in use_defs_list:
- defname = doc['define']
-
- if doc.get('removed', None) is not None and opts.omit_removed_config_options:
- continue
- if doc.get('deprecated', None) is not None and opts.omit_deprecated_config_options:
- continue
- if doc.get('unused', False) == True and opts.omit_unused_config_options:
- continue
-
- if tag != doc['tags'][0]: # sort under primary tag
- continue
-
- if not doc.has_key('default'):
- raise Exception('config option %s is missing default value' % defname)
-
- undef_done = False
-
- if handled.has_key(defname):
- defval = forced_opts.get(defname, None)
- if defval is None:
- ret.line('/* %s already emitted above */' % defname)
- continue
-
- # Define already emitted by snippets above but
- # an explicit override wants to redefine it.
- # Undef first and then use shared handler to
- # setup the forced value.
- ret.line('#undef ' + defname)
- undef_done = True
-
- # FIXME: macro args; DUK_USE_USER_DECLARE vs. DUK_USE_USER_DECLARE()
- # vs. DUK_USE_USER_DECLARE(x,y)
-
- handled[defname] = True
- emit_default_from_config_meta(ret, doc, forced_opts, undef_done)
-
- ret.empty()
-
- if len(opts.fixup_header_lines) > 0:
- ret.chdr_block_heading('Fixups')
- for line in opts.fixup_header_lines:
- ret.line(line)
-
- add_override_defines_section(opts, ret)
-
- # Date provider snippet is after custom header and overrides, so that
- # the user may define e.g. DUK_USE_DATE_NOW_GETTIMEOFDAY in their
- # custom header.
- ret.empty()
- ret.snippet_relative('date_provider.h.in')
- ret.empty()
-
- ret.fill_dependencies_for_snippets(idx_deps)
-
- # XXX: ensure no define is unhandled at the end
-
- # Check for presence of legacy feature options (DUK_OPT_xxx),
- # and consistency of final DUK_USE_xxx options.
- #
- # These could also be emitted into Duktape source code, but it's
- # probably better that the checks can be easily disabled from
- # duk_config.h.
-
- if opts.emit_legacy_feature_check:
- add_legacy_feature_option_checks(opts, ret)
- if opts.emit_config_sanity_check:
- add_config_option_checks(opts, ret)
- if opts.add_active_defines_macro:
- add_duk_active_defines_macro(ret)
-
- ret.line('#endif /* DUK_CONFIG_H_INCLUDED */')
- ret.empty() # for trailing newline
-
- return remove_duplicate_newlines(serialize_snippet_list(ret.vals)) # XXX: refactor into FileBuilder
-
#
# Main
#
@@ -1766,8 +1438,7 @@ def main():
fixup_header_lines.append(line)
commands = [
- 'autodetect-header',
- 'barebones-header',
+ 'duk-config-header',
'feature-documentation',
'config-documentation'
]
@@ -1776,12 +1447,15 @@ def main():
description='Generate a duk_config.h or config option documentation based on config metadata.',
epilog='COMMAND can be one of: ' + ', '.join(commands) + '.'
)
+
parser.add_option('--metadata', dest='metadata', default=None, help='metadata directory or metadata tar.gz file')
parser.add_option('--output', dest='output', default=None, help='output filename for C header or RST documentation file')
parser.add_option('--platform', dest='platform', default=None, help='platform (for "barebones-header" command)')
parser.add_option('--compiler', dest='compiler', default=None, help='compiler (for "barebones-header" command)')
parser.add_option('--architecture', dest='architecture', default=None, help='architecture (for "barebones-header" command)')
- parser.add_option('--dll', dest='dll', action='store_true', default=False, help='dll build of Duktape, affects symbol visibility macros especially on Windows') # FIXME: unimplemented
+ parser.add_option('--c99-types-only', dest='c99_types_only', action='store_true', default=False, help='assume C99 types, no legacy type detection')
+ parser.add_option('--dll', dest='dll', action='store_true', default=False, help='dll build of Duktape, affects symbol visibility macros especially on Windows')
+ parser.add_option('--support-feature-options', dest='support_feature_options', action='store_true', default=False, help='support DUK_OPT_xxx feature options in duk_config.h')
parser.add_option('--emit-legacy-feature-check', dest='emit_legacy_feature_check', action='store_true', default=False, help='emit preprocessor checks to reject legacy feature options (DUK_OPT_xxx)')
parser.add_option('--emit-config-sanity-check', dest='emit_config_sanity_check', action='store_true', default=False, help='emit preprocessor checks for config option consistency (DUK_OPT_xxx)')
parser.add_option('--omit-removed-config-options', dest='omit_removed_config_options', action='store_true', default=False, help='omit removed config options from generated headers')
@@ -1800,6 +1474,7 @@ def main():
parser.add_option('--use-cpp-warning', dest='use_cpp_warning', action='store_true', default=False, help='emit a (non-portable) #warning when appropriate')
parser.add_option('--git-commit', dest='git_commit', default=None, help='git commit hash to be included in header comments')
parser.add_option('--git-describe', dest='git_describe', default=None, help='git describe string to be included in header comments')
+ parser.add_option('--git-branch', dest='git_branch', default=None, help='git branch string to be included in header comments')
(opts, args) = parser.parse_args()
meta_dir = opts.metadata
@@ -1811,50 +1486,40 @@ def main():
if opts.metadata is not None and os.path.isdir(opts.metadata):
meta_dir = opts.metadata
- print 'Using metadata directory: %r' % meta_dir
+ metadata_src_text = 'Using metadata directory: %r' % meta_dir
elif opts.metadata is not None and os.path.isfile(opts.metadata) and tarfile.is_tarfile(opts.metadata):
meta_dir = get_auto_delete_tempdir()
tar = tarfile.open(name=opts.metadata, mode='r:*')
tar.extractall(path=meta_dir)
- print 'Using metadata tar file %r, unpacked to directory: %r' % (opts.metadata, meta_dir)
+ metadata_src_text = 'Using metadata tar file %r, unpacked to directory: %r' % (opts.metadata, meta_dir)
else:
raise Exception('metadata source must be a directory or a tar.gz file')
- scan_snippets(os.path.join(meta_dir, 'header-snippets'))
+ scan_helper_snippets(os.path.join(meta_dir, 'helper-snippets'))
scan_use_defs(os.path.join(meta_dir, 'config-options'))
scan_opt_defs(os.path.join(meta_dir, 'feature-options'))
scan_use_tags()
scan_tags_meta(os.path.join(meta_dir, 'tags.yaml'))
- print('Scanned %d DUK_OPT_xxx, %d DUK_USE_XXX, %d helper snippets' % \
- (len(opt_defs.keys()), len(use_defs.keys()), len(helper_snippets)))
+ print('%s, scanned %d DUK_OPT_xxx, %d DUK_USE_XXX, %d helper snippets' % \
+ (metadata_src_text, len(opt_defs.keys()), len(use_defs.keys()), len(helper_snippets)))
#print('Tags: %r' % use_tags_list)
if len(args) == 0:
raise Exception('missing command')
cmd = args[0]
+ # Compatibility with Duktape 1.3
if cmd == 'autodetect-header':
- cmd = 'autodetect-header-legacy'
+ cmd = 'duk-config-header'
+ if cmd == 'barebones-header':
+ cmd = 'duk-config-header'
- if cmd == 'autodetect-header-legacy':
- # Generate a duk_config.h similar to Duktape 1.2 feature detection,
- # based on manually written monolithic snippets.
- # To be replaced by modular header.
- result = generate_autodetect_duk_config_header(opts, meta_dir)
- with open(opts.output, 'wb') as f:
- f.write(result)
- elif cmd == 'autodetect-header-modular':
- # Generate a duk_config.h similar to Duktape 1.2 feature detection.
- # Platform, architecture, and compiler can each be either autodetected
- # or specified by user. Generated header is based on modular snippets
- # rather than a monolithic platform detection header.
- result = generate_autodetect_duk_config_header_modular(opts, meta_dir)
- with open(opts.output, 'wb') as f:
- f.write(result)
- elif cmd == 'barebones-header':
- # Generate a duk_config.h with default options for a specific platform,
- # compiler, and architecture.
- result = generate_barebones_duk_config_header(opts, meta_dir)
+ if cmd == 'duk-config-header':
+ # Generate a duk_config.h header with platform, compiler, and
+ # architecture either autodetected (default) or specified by
+ # user. Support for autogenerated DUK_OPT_xxx flags is also
+ # selected by user.
+ result = generate_duk_config_header(opts, meta_dir)
with open(opts.output, 'wb') as f:
f.write(result)
elif cmd == 'feature-documentation':
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/genconfig_metadata.tar.gz b/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/genconfig_metadata.tar.gz
new file mode 100644
index 000000000..c34b2ef10
Binary files /dev/null and b/ceph/src/civetweb/src/third_party/duktape-1.5.2/config/genconfig_metadata.tar.gz differ
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/Makefile b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/Makefile
similarity index 69%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/Makefile
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/Makefile
index a85bc012b..50740b549 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/Makefile
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/Makefile
@@ -1,4 +1,5 @@
NODE:=$(shell which nodejs node | head -1)
+DUKLUV:=dukluv
# Try to get a useful default --source-dirs which works both in the Duktape
# repo and in the distributable. We don't want to add '..' because it would
@@ -14,11 +15,23 @@ all: run
.PHONY: run
run: node_modules static/socket.io-1.2.0.js static/jquery-1.11.1.min.js static/reset.css static/jquery-ui.min.js static/jquery-ui.min.css static/images
- $(NODE) duk_debug.js --source-dirs=$(SOURCEDIRS)
+ "$(NODE)" duk_debug.js --source-dirs=$(SOURCEDIRS)
+
+rundebug: node_modules static/socket.io-1.2.0.js static/jquery-1.11.1.min.js static/reset.css static/jquery-ui.min.js static/jquery-ui.min.css static/images
+ "$(NODE)" duk_debug.js --source-dirs=$(SOURCEDIRS) --verbose --log-messages /tmp/dukdebug-messages --dump-debug-pretty /tmp/dukdebug-pretty
+
+.PHONY: runproxynodejs
+runproxynodejs: node_modules static/socket.io-1.2.0.js static/jquery-1.11.1.min.js static/reset.css static/jquery-ui.min.js static/jquery-ui.min.css static/images
+ @echo "Running Node.js based debug proxy"
+ "$(NODE)" duk_debug.js --json-proxy
+
+.PHONY: runproxydukluv
+runproxydukluv: duk_debug_meta.json
+ @echo "Running Dukluv based debug proxy (you may need to edit DUKLUV in the Makefile)"
+ "$(DUKLUV)" duk_debug_proxy.js --log-level 2 --metadata duk_debug_meta.json --readable-numbers
.PHONY: runproxy
-runproxy: node_modules static/socket.io-1.2.0.js static/jquery-1.11.1.min.js static/reset.css static/jquery-ui.min.js static/jquery-ui.min.css static/images
- $(NODE) duk_debug.js --json-proxy
+runproxy: runproxydukluv
.PHONY: clean
clean:
@@ -35,12 +48,20 @@ clean:
@rm -f jquery-ui-1.11.2.zip
@rm -rf jquery-ui-1.11.2
@rm -rf node_modules
+ @rm -f duk_debug_meta.json
node_modules:
npm install
+duk_debug_meta.json:
+ python merge_debug_meta.py --output $@ \
+ --class-names duk_classnames.yaml \
+ --opcodes duk_opcodes.yaml \
+ --debug-commands duk_debugcommands.yaml \
+ --debug-errors duk_debugerrors.yaml
+
static/socket.io-1.2.0.js:
- wget -O $@ https://cdn.socket.io/socket.io-1.2.0.js
+ wget -O $@ http://cdn.socket.io/socket.io-1.2.0.js
static/jquery-1.11.1.min.js:
wget -O $@ http://code.jquery.com/jquery-1.11.1.min.js
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/README.rst b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/README.rst
similarity index 59%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/README.rst
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/README.rst
index 8a82d65dc..f60b3506a 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/README.rst
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/README.rst
@@ -6,7 +6,8 @@ Overview
========
Debugger web UI which connects to the Duktape command line tool or any other
-target supporting the example TCP transport (``examples/debug-trans-socket``).
+target supporting the example TCP transport (``examples/debug-trans-socket``)
+on Unix and Windows.
Also provides a JSON debug proxy with a JSON mapping for the Duktape debug
protocol.
@@ -24,7 +25,7 @@ Some prerequisites:
the required packages.
Compile Duktape command line tool with debugger support (for further options
-see ``doc/feature-options.rst``):
+see http://wiki.duktape.org/FeatureOptions.html):
* ``DUK_OPT_DEBUGGER_SUPPORT``
@@ -75,10 +76,125 @@ web UI.
Using the JSON debug proxy
==========================
-A JSON debug proxy is also provided by ``duk_debug.js``::
+There are two JSON debug proxy implementations: one implemented in DukLuv
+and another in Node.js.
- # Same prerequisites as above
- $ make runproxy
+DukLuv JSON proxy
+-----------------
+
+DukLuv (https://github.com/creationix/dukluv) is a small and portable event
+loop based on LibUV and Duktape with MIT license (like Duktape). As such it's
+easy to embed in a custom debug client: you just include the DukLuv executable
+and the JSON proxy source file in your debug client.
+
+Install DukLuv:
+
+* Ensure ``cmake`` is installed
+
+* ``git clone https://github.com/creationix/dukluv.git``
+
+* ``git submodule init; git submodule update``
+
+* ``make``
+
+* Binary should appear in:
+
+ - ``./build/dukluv`` on Linux
+
+ - ``.\build\Debug\dukluv.exe`` on Windows
+
+Run the proxy::
+
+ # Using Makefile; autogenerates duk_debug_meta.json
+ # (You may need to edit DUKLUV in Makefile to point to your DukLuv)
+ $ make runproxydukluv
+
+ # Manually: see "dukluv duk_debug_proxy.js --help" for help
+ $ .../path/to/dukluv duk_debug_proxy.js
+
+Start Duktape command line (or whatever your target is)::
+
+ $ cd /tests/ecmascript/
+ $ ../../duk --debugger test-dev-mandel2-func.js
+
+Now connect to the proxy using e.g. telnet::
+
+ $ telnet localhost 9093
+
+The proxy will then connect to the target and you can start issuing commands::
+
+ $ telnet localhost 9093
+ Trying 127.0.0.1...
+ Connected to localhost.
+ Escape character is '^]'.
+ {"notify":"_TargetConnecting","args":["127.0.0.1",9091]}
+ {"notify":"_TargetConnected","args":["1 10499 v1.4.0-140-gc9a6c7c duk command built from Duktape repo"]}
+ {"notify":"Status","command":1,"args":[1,"test-dev-mandel2-func.js","global",58,0]}
+ {"request":"BasicInfo"}
+ {"reply":true,"args":[10499,"v1.4.0-140-gc9a6c7c","duk command built from Duktape repo",1]}
+ {"request":"Eval","args":["print('Hello world!'); 123;"]}
+ {"notify":"Print","command":2,"args":["Hello world!\n"]}
+ {"reply":true,"args":[0,{"type":"number","data":"405ec00000000000"}]}
+ [...]
+
+The proxy log provides dumps both JSON and dvalue binary traffic which is
+quite useful in development::
+
+ $ make runproxydukluv
+ Running Dukluv based debug proxy
+ "dukluv" duk_debug_proxy.js --log-level 2 --metadata duk_debug_meta.json
+ 2016-02-17T13:59:42.308Z INF Proxy: Read proxy metadata from duk_debug_meta.json
+ 2016-02-17T13:59:42.325Z INF Proxy: Listening for incoming JSON debug connection on 0.0.0.0:9093, target is 127.0.0.1:9091
+ 2016-02-17T13:59:47.994Z INF Proxy: JSON proxy client connected
+ 2016-02-17T13:59:47.994Z INF Proxy: Connecting to debug target at 127.0.0.1:9091
+ 2016-02-17T13:59:47.994Z INF Proxy: PROXY --> CLIENT: {"notify":"_TargetConnecting","args":["127.0.0.1",9091]}
+ 2016-02-17T13:59:47.994Z INF Proxy: Connected to debug target at 127.0.0.1:9091
+ 2016-02-17T13:59:48.003Z INF Proxy: PROXY --> CLIENT: {"notify":"_TargetConnected","args":["1 10499 v1.4.0-140-gc9a6c7c duk command built from Duktape repo"]}
+ 2016-02-17T13:59:48.003Z INF Proxy: Target handshake: {"line":"1 10499 v1.4.0-140-gc9a6c7c duk command built from Duktape repo","protocolVersion":1,"text":"10499 v1.4.0-140-gc9a6c7c duk command built from Duktape repo","dukVersion":"1","dukGitDescribe":"10499","targetString":"v1.4.0-140-gc9a6c7c"}
+ 2016-02-17T13:59:48.151Z INF Proxy: PROXY <-- TARGET: |04|
+ 2016-02-17T13:59:48.152Z INF Proxy: PROXY <-- TARGET: |81|
+ 2016-02-17T13:59:48.152Z INF Proxy: PROXY <-- TARGET: |81|
+ 2016-02-17T13:59:48.160Z INF Proxy: PROXY <-- TARGET: |78746573742d6465762d6d616e64656c322d66756e632e6a73|
+ 2016-02-17T13:59:48.161Z INF Proxy: PROXY <-- TARGET: |66676c6f62616c|
+ 2016-02-17T13:59:48.165Z INF Proxy: PROXY <-- TARGET: |ba|
+ 2016-02-17T13:59:48.165Z INF Proxy: PROXY <-- TARGET: |80|
+ 2016-02-17T13:59:48.165Z INF Proxy: PROXY <-- TARGET: |00|
+ 2016-02-17T13:59:48.165Z INF Proxy: PROXY --> CLIENT: {"notify":"Status","command":1,"args":[1,"test-dev-mandel2-func.js","global",58,0]}
+ 2016-02-17T13:59:51.289Z INF Proxy: PROXY <-- CLIENT: {"request":"BasicInfo"}
+ 2016-02-17T13:59:51.289Z INF Proxy: PROXY --> TARGET: |01|
+ 2016-02-17T13:59:51.289Z INF Proxy: PROXY --> TARGET: |90|
+ 2016-02-17T13:59:51.289Z INF Proxy: PROXY --> TARGET: |00|
+ 2016-02-17T13:59:51.291Z INF Proxy: PROXY <-- TARGET: |02|
+ 2016-02-17T13:59:51.291Z INF Proxy: PROXY <-- TARGET: |e903|
+ 2016-02-17T13:59:51.292Z INF Proxy: PROXY <-- TARGET: |7376312e342e302d3134302d6763396136633763|
+ 2016-02-17T13:59:51.293Z INF Proxy: PROXY <-- TARGET: |12002364756b20636f6d6d616e64206275696c742066726f6d2044756b74617065207265706f|
+ 2016-02-17T13:59:51.293Z INF Proxy: PROXY <-- TARGET: |81|
+ 2016-02-17T13:59:51.293Z INF Proxy: PROXY <-- TARGET: |00|
+ 2016-02-17T13:59:51.293Z INF Proxy: PROXY --> CLIENT: {"reply":true,"args":[10499,"v1.4.0-140-gc9a6c7c","duk command built from Duktape repo",1]}
+ 2016-02-17T14:00:06.105Z INF Proxy: PROXY <-- CLIENT: {"request":"Eval","args":["print('Hello world!'); 123;"]}
+ 2016-02-17T14:00:06.105Z INF Proxy: PROXY --> TARGET: |01|
+ 2016-02-17T14:00:06.105Z INF Proxy: PROXY --> TARGET: |9e|
+ 2016-02-17T14:00:06.105Z INF Proxy: PROXY --> TARGET: |7b7072696e74282748656c6c6f20776f726c642127293b203132333b|
+ 2016-02-17T14:00:06.105Z INF Proxy: PROXY --> TARGET: |00|
+ 2016-02-17T14:00:06.167Z INF Proxy: PROXY <-- TARGET: |04|
+ 2016-02-17T14:00:06.167Z INF Proxy: PROXY <-- TARGET: |82|
+ 2016-02-17T14:00:06.167Z INF Proxy: PROXY <-- TARGET: |6d48656c6c6f20776f726c64210a|
+ 2016-02-17T14:00:06.168Z INF Proxy: PROXY <-- TARGET: |00|
+ 2016-02-17T14:00:06.168Z INF Proxy: PROXY --> CLIENT: {"notify":"Print","command":2,"args":["Hello world!\n"]}
+ 2016-02-17T14:00:06.171Z INF Proxy: PROXY <-- TARGET: |02|
+ 2016-02-17T14:00:06.171Z INF Proxy: PROXY <-- TARGET: |80|
+ 2016-02-17T14:00:06.173Z INF Proxy: PROXY <-- TARGET: |1a405ec00000000000|
+ 2016-02-17T14:00:06.173Z INF Proxy: PROXY <-- TARGET: |00|
+ 2016-02-17T14:00:06.174Z INF Proxy: PROXY --> CLIENT: {"reply":true,"args":[0,{"type":"number","data":"405ec00000000000"}]}
+ [...]
+
+Node.js JSON proxy
+------------------
+
+A Node.js-based JSON debug proxy is also provided by ``duk_debug.js``::
+
+ # Same prerequisites as for running the debug client
+ $ make runproxynodejs
Start Duktape command line (or whatever your target is)::
@@ -94,7 +210,7 @@ readability and are not part of the stream::
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
- <-- {"notify":"_Connected","args":["1 10199 v1.1.0-275-gbd4d610-dirty duk command built from Duktape repo"]}
+ <-- {"notify":"_TargetConnected","args":["1 10199 v1.1.0-275-gbd4d610-dirty duk command built from Duktape repo"]}
<-- {"notify":"Status","command":1,"args":[1,"test-dev-mandel2-func.js","global",58,0]}
--> {"request":"BasicInfo"}
<-- {"reply":true,"args":[10199,"v1.1.0-275-gbd4d610-dirty","duk command built from Duktape repo",1]}
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_classnames.yaml b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_classnames.yaml
new file mode 100644
index 000000000..9fd5098a5
--- /dev/null
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_classnames.yaml
@@ -0,0 +1,32 @@
+# Must match C header.
+class_names:
+ - unused
+ - Arguments
+ - Array
+ - Boolean
+ - Date
+ - Error
+ - Function
+ - JSON
+ - Math
+ - Number
+ - Object
+ - RegExp
+ - String
+ - global
+ - ObjEnv
+ - DecEnv
+ - Buffer
+ - Pointer
+ - Thread
+ - ArrayBuffer
+ - DataView
+ - Int8Array
+ - Uint8Array
+ - Uint8ClampedArray
+ - Int16Array
+ - Uint16Array
+ - Int32Array
+ - Uint32Array
+ - Float32Array
+ - Float64Array
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/duk_debug.js b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debug.js
similarity index 95%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/duk_debug.js
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debug.js
index 5a294095b..ab0623fa7 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/duk_debug.js
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debug.js
@@ -53,6 +53,8 @@ var CMD_STATUS = 0x01;
var CMD_PRINT = 0x02;
var CMD_ALERT = 0x03;
var CMD_LOG = 0x04;
+var CMD_THROW = 0x05;
+var CMD_DETACHING = 0x06;
// Commands initiated by the debug client (= us)
var CMD_BASICINFO = 0x10;
@@ -89,11 +91,16 @@ var DVAL_NFY = { type: 'nfy' };
// String map for commands (debug dumping). A single map works (instead of
// separate maps for each direction) because command numbers don't currently
-// overlap.
-var debugCommandNames = yaml.load('duk_debugcommands.yaml');
-
-// Map debug command names to numbers.
-var debugCommandNumbers = {};
+// overlap. So merge the YAML metadata.
+var debugCommandMeta = yaml.load('duk_debugcommands.yaml');
+var debugCommandNames = []; // list of command names, merged client/target
+debugCommandMeta.target_commands.forEach(function (k, i) {
+ debugCommandNames[i] = k;
+});
+debugCommandMeta.client_commands.forEach(function (k, i) { // override
+ debugCommandNames[i] = k;
+});
+var debugCommandNumbers = {}; // map from (merged) command name to number
debugCommandNames.forEach(function (k, i) {
debugCommandNumbers[k] = i;
});
@@ -104,10 +111,11 @@ var DUK_HTYPE_OBJECT = 2;
var DUK_HTYPE_BUFFER = 3;
// Duktape internal class numbers, must match C headers
-var dukClassNames = yaml.load('duk_classnames.yaml');
+var dukClassNameMeta = yaml.load('duk_classnames.yaml');
+var dukClassNames = dukClassNameMeta.class_names;
// Bytecode opcode/extraop metadata
-var dukOpcodes = yaml.load('duk_opcodes.yaml')
+var dukOpcodes = yaml.load('duk_opcodes.yaml');
if (dukOpcodes.opcodes.length != 64) {
throw new Error('opcode metadata length incorrect');
}
@@ -158,7 +166,7 @@ function writeDebugStringToBuffer(str, buf, off) {
var i, n;
for (i = 0, n = str.length; i < n; i++) {
- buf[off + i] = str.charCodeAt(i) & 0xff;
+ buf[off + i] = str.charCodeAt(i) & 0xff; // truncate higher bits
}
}
@@ -193,11 +201,11 @@ function prettyDebugValue(x) {
* and signed zeroes properly.
*/
function prettyUiNumber(x) {
- if (x === 1/0) { return 'Infinity'; }
- if (x === -1/0) { return '-Infinity'; }
+ if (x === 1 / 0) { return 'Infinity'; }
+ if (x === -1 / 0) { return '-Infinity'; }
if (Number.isNaN(x)) { return 'NaN'; }
- if (x === 0 && 1/x > 0) { return '0'; }
- if (x === 0 && 1/x < 0) { return '-0'; }
+ if (x === 0 && 1 / x > 0) { return '0'; }
+ if (x === 0 && 1 / x < 0) { return '-0'; }
return x.toString();
}
@@ -425,7 +433,7 @@ RateLimited.prototype.trigger = function () {
function SourceFileManager(directories) {
this.directories = directories;
- this.extensions = { '.js': true, '.jsm': true };
+ this.extensions = { '.js': true, '.jsm': true };
this.files;
}
@@ -713,12 +721,12 @@ function DebugProtocolParser(inputStream,
if (buf.length >= 9) {
v = new Buffer(8);
buf.copy(v, 0, 1, 9);
- v = { type: 'number', data: v.toString('hex') }
+ v = { type: 'number', data: v.toString('hex') };
if (_this.readableNumberValue) {
- // The _value key should not be used programmatically,
+ // The value key should not be used programmatically,
// it is just there to make the dumps more readable.
- v._value = buf.readDoubleBE(1);
+ v.value = buf.readDoubleBE(1);
}
consume(9);
}
@@ -1067,7 +1075,7 @@ Debugger.prototype.decodeBytecodeFromBuffer = function (buf, consts, funcs) {
comments = [];
if (op.args) {
for (j = 0, m = op.args.length; j < m; j++) {
- switch(op.args[j]) {
+ switch (op.args[j]) {
case 'A_R': args.push('r' + ((ins >>> 6) & 0xff)); break;
case 'A_RI': args.push('r' + ((ins >>> 6) & 0xff) + '(indirect)'); break;
case 'A_C': args.push('c' + ((ins >>> 6) & 0xff)); break;
@@ -1204,30 +1212,30 @@ Debugger.prototype.sendBasicInfoRequest = function () {
});
};
-Debugger.prototype.sendGetVarRequest = function (varname) {
+Debugger.prototype.sendGetVarRequest = function (varname, level) {
var _this = this;
- return this.sendRequest([ DVAL_REQ, CMD_GETVAR, varname, DVAL_EOM ]).then(function (msg) {
+ return this.sendRequest([ DVAL_REQ, CMD_GETVAR, varname, (typeof level === 'number' ? level : -1), DVAL_EOM ]).then(function (msg) {
return { found: msg[1] === 1, value: msg[2] };
});
};
-Debugger.prototype.sendPutVarRequest = function (varname, varvalue) {
+Debugger.prototype.sendPutVarRequest = function (varname, varvalue, level) {
var _this = this;
- return this.sendRequest([ DVAL_REQ, CMD_PUTVAR, varname, varvalue, DVAL_EOM ]);
+ return this.sendRequest([ DVAL_REQ, CMD_PUTVAR, varname, varvalue, (typeof level === 'number' ? level : -1), DVAL_EOM ]);
};
Debugger.prototype.sendInvalidCommandTestRequest = function () {
// Intentional invalid command
var _this = this;
return this.sendRequest([ DVAL_REQ, 0xdeadbeef, DVAL_EOM ]);
-}
+};
Debugger.prototype.sendStatusRequest = function () {
// Send a status request to trigger a status notify, result is ignored:
// target sends a status notify instead of a meaningful reply
var _this = this;
return this.sendRequest([ DVAL_REQ, CMD_TRIGGERSTATUS, DVAL_EOM ]);
-}
+};
Debugger.prototype.sendBreakpointListRequest = function () {
var _this = this;
@@ -1245,9 +1253,9 @@ Debugger.prototype.sendBreakpointListRequest = function () {
});
};
-Debugger.prototype.sendGetLocalsRequest = function () {
+Debugger.prototype.sendGetLocalsRequest = function (level) {
var _this = this;
- return this.sendRequest([ DVAL_REQ, CMD_GETLOCALS, DVAL_EOM ]).then(function (msg) {
+ return this.sendRequest([ DVAL_REQ, CMD_GETLOCALS, (typeof level === 'number' ? level : -1), DVAL_EOM ]).then(function (msg) {
var i;
var locals = [];
@@ -1308,9 +1316,9 @@ Debugger.prototype.sendResumeRequest = function () {
return this.sendRequest([ DVAL_REQ, CMD_RESUME, DVAL_EOM ]);
};
-Debugger.prototype.sendEvalRequest = function (evalInput) {
+Debugger.prototype.sendEvalRequest = function (evalInput, level) {
var _this = this;
- return this.sendRequest([ DVAL_REQ, CMD_EVAL, evalInput, DVAL_EOM ]).then(function (msg) {
+ return this.sendRequest([ DVAL_REQ, CMD_EVAL, evalInput, (typeof level === 'number' ? level : -1), DVAL_EOM ]).then(function (msg) {
return { error: msg[1] === 1 /*error*/, value: msg[2] };
});
};
@@ -1402,6 +1410,7 @@ Debugger.prototype.sendGetBytecodeRequest = function () {
var bcode;
var preformatted;
var ret;
+ var idxPreformattedInstructions;
//console.log(JSON.stringify(msg));
@@ -1431,6 +1440,7 @@ Debugger.prototype.sendGetBytecodeRequest = function () {
preformatted.push('; c' + i + ' ' + JSON.stringify(v));
});
preformatted.push('');
+ idxPreformattedInstructions = preformatted.length;
bcode.forEach(function (v) {
preformatted.push(v.str);
});
@@ -1440,7 +1450,8 @@ Debugger.prototype.sendGetBytecodeRequest = function () {
constants: consts,
functions: funcs,
bytecode: bcode,
- preformatted: preformatted
+ preformatted: preformatted,
+ idxPreformattedInstructions: idxPreformattedInstructions
};
return ret;
@@ -1696,9 +1707,15 @@ Debugger.prototype.processDebugMessage = function (msg) {
this.uiMessage('alert', prettyUiStringUnquoted(msg[2], UI_MESSAGE_CLIPLEN));
} else if (msg[1] === CMD_LOG) {
this.uiMessage({ type: 'log', level: msg[2], message: prettyUiStringUnquoted(msg[3], UI_MESSAGE_CLIPLEN) });
+ } else if (msg[1] === CMD_THROW) {
+ this.uiMessage({ type: 'throw', fatal: msg[2], message: (msg[2] ? 'UNCAUGHT: ' : 'THROW: ') + prettyUiStringUnquoted(msg[3], UI_MESSAGE_CLIPLEN), fileName: msg[4], lineNumber: msg[5] });
+ } else if (msg[1] === CMD_DETACHING) {
+ this.uiMessage({ type: 'detaching', reason: msg[2], message: 'DETACH: ' + (msg.length >= 5 ? prettyUiStringUnquoted(msg[3]) : 'detaching') });
} else {
- console.log('Unknown notify, dropping connection: ' + prettyDebugMessage(msg));
- this.targetStream.destroy();
+ // Ignore unknown notify messages
+ console.log('Unknown notify, ignoring: ' + prettyDebugMessage(msg));
+
+ //this.targetStream.destroy();
}
} else {
console.log('Invalid initial dvalue, dropping connection: ' + prettyDebugMessage(msg));
@@ -1733,7 +1750,7 @@ Debugger.prototype.run = function () {
// while a previous request is pending. The flag-based approach is
// quite awkward. Rework to use promises.
- switch(sendRound) {
+ switch (sendRound) {
case 0:
if (!statusPending) {
statusPending = true;
@@ -1946,14 +1963,18 @@ DebugWebServer.prototype.handleNewSocketIoConnection = function (socket) {
// msg.input is a proper Unicode strings here, and needs to be
// converted into a protocol string (U+0000...U+00FF).
var input = stringToDebugString(msg.input);
- _this.dbg.sendEvalRequest(input).then(function (v) {
+ _this.dbg.sendEvalRequest(input, msg.level).then(function (v) {
socket.emit('eval-result', { error: v.error, result: prettyUiDebugValue(v.value, EVAL_CLIPLEN) });
});
// An eval call quite possibly changes the local variables so always
- // re-read locals afterwards. We don't need to wait for eval() to
+ // re-read locals afterwards. We don't need to wait for Eval to
// complete here; the requests will pipeline automatically and be
// executed in order.
+
+ // XXX: move this to the web UI so that the UI can control what
+ // locals are listed (or perhaps show locals for all levels with
+ // an expandable tree view).
_this.dbg.sendGetLocalsRequest();
});
@@ -1961,7 +1982,7 @@ DebugWebServer.prototype.handleNewSocketIoConnection = function (socket) {
// msg.varname is a proper Unicode strings here, and needs to be
// converted into a protocol string (U+0000...U+00FF).
var varname = stringToDebugString(msg.varname);
- _this.dbg.sendGetVarRequest(varname)
+ _this.dbg.sendGetVarRequest(varname, msg.level)
.then(function (v) {
socket.emit('getvar-result', { found: v.found, result: prettyUiDebugValue(v.value, GETVAR_CLIPLEN) });
});
@@ -1979,15 +2000,17 @@ DebugWebServer.prototype.handleNewSocketIoConnection = function (socket) {
varvalue = stringToDebugString(msg.varvalue);
}
- _this.dbg.sendPutVarRequest(varname, varvalue)
+ _this.dbg.sendPutVarRequest(varname, varvalue, msg.level)
.then(function (v) {
console.log('putvar done'); // XXX: signal success to UI?
});
// A PutVar call quite possibly changes the local variables so always
- // re-read locals afterwards. We don't need to wait for eval() to
+ // re-read locals afterwards. We don't need to wait for PutVar to
// complete here; the requests will pipeline automatically and be
// executed in order.
+
+ // XXX: make the client do this?
_this.dbg.sendGetLocalsRequest();
});
@@ -2143,14 +2166,16 @@ function DebugProxy(serverPort) {
this.dval_err = formatDebugValue(DVAL_ERR);
}
-DebugProxy.prototype.determineCommandNumber = function (cmdString, cmdNumber) {
+DebugProxy.prototype.determineCommandNumber = function (cmdName, cmdNumber) {
var ret;
- if (typeof cmdString === 'string') {
- ret = debugCommandNumbers[cmdString];
+ if (typeof cmdName === 'string') {
+ ret = debugCommandNumbers[cmdName];
+ } else if (typeof cmdName === 'number') {
+ ret = cmdName;
}
ret = ret || cmdNumber;
if (typeof ret !== 'number') {
- throw Error('cannot figure out command number for "' + cmdString + '" (' + cmdNumber + ')');
+ throw Error('cannot figure out command number for "' + cmdName + '" (' + cmdNumber + ')');
}
return ret;
};
@@ -2282,7 +2307,7 @@ DebugProxy.prototype.connectToTarget = function () {
null // console logging is done at a higher level to match request/response
);
- // Don't add a '_value' key to numbers.
+ // Don't add a 'value' key to numbers.
this.inputParser.readableNumberValue = false;
this.inputParser.on('transport-close', function () {
@@ -2310,7 +2335,7 @@ DebugProxy.prototype.connectToTarget = function () {
console.log('Debug version identification:', msg.versionIdentification);
_this.writeJson({
- notify: '_Connected',
+ notify: '_TargetConnected',
args: [ msg.versionIdentification ] // raw identification string
});
@@ -2326,9 +2351,9 @@ DebugProxy.prototype.connectToTarget = function () {
if (typeof msg[0] !== 'object' || msg[0] === null) {
throw new Error('unexpected initial dvalue: ' + msg[0]);
- } else if (msg.type === 'eom') {
+ } else if (msg[0].type === 'eom') {
throw new Error('unexpected initial dvalue: ' + msg[0]);
- } else if (msg.type === 'req') {
+ } else if (msg[0].type === 'req') {
if (typeof msg[1] !== 'number') {
throw new Error('unexpected request command number: ' + msg[1]);
}
@@ -2336,19 +2361,19 @@ DebugProxy.prototype.connectToTarget = function () {
request: _this.commandNumberToString(msg[1]),
command: msg[1],
args: msg.slice(2, msg.length - 1)
- }
+ };
_this.writeJson(t);
} else if (msg[0].type === 'rep') {
t = {
reply: true,
args: msg.slice(1, msg.length - 1)
- }
+ };
_this.writeJson(t);
} else if (msg[0].type === 'err') {
t = {
error: true,
args: msg.slice(1, msg.length - 1)
- }
+ };
_this.writeJson(t);
} else if (msg[0].type === 'nfy') {
if (typeof msg[1] !== 'number') {
@@ -2358,7 +2383,7 @@ DebugProxy.prototype.connectToTarget = function () {
notify: _this.commandNumberToString(msg[1]),
command: msg[1],
args: msg.slice(2, msg.length - 1)
- }
+ };
_this.writeJson(t);
} else {
throw new Error('unexpected initial dvalue: ' + msg[0]);
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debug_meta.json b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debug_meta.json
new file mode 100644
index 000000000..41de1c2f8
--- /dev/null
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debug_meta.json
@@ -0,0 +1,1497 @@
+{
+ "opcodes": [
+ {
+ "args": [
+ "A_R",
+ "BC_R"
+ ],
+ "name": "LDREG"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_R"
+ ],
+ "name": "STREG"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_C"
+ ],
+ "name": "LDCONST"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_LDINT"
+ ],
+ "name": "LDINT"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_LDINTX"
+ ],
+ "name": "LDINTX"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_R",
+ "C_I"
+ ],
+ "name": "MPUTOBJ"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RI",
+ "C_I"
+ ],
+ "name": "MPUTOBJI"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_R",
+ "C_I"
+ ],
+ "name": "MPUTARR"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RI",
+ "C_I"
+ ],
+ "name": "MPUTARRI"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_I"
+ ],
+ "name": "NEW"
+ },
+ {
+ "args": [
+ "B_RI",
+ "C_I"
+ ],
+ "name": "NEWI"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "REGEXP"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_R"
+ ],
+ "name": "CSREG"
+ },
+ {
+ "args": [
+ "A_RI",
+ "B_R"
+ ],
+ "name": "CSREGI"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_C"
+ ],
+ "name": "GETVAR"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_C"
+ ],
+ "name": "PUTVAR"
+ },
+ {
+ "args": [
+ "A_H",
+ "B_RC",
+ "C_RC"
+ ],
+ "flags": [
+ {
+ "mask": 64,
+ "name": "writable"
+ },
+ {
+ "mask": 128,
+ "name": "enumerable"
+ },
+ {
+ "mask": 256,
+ "name": "configurable"
+ },
+ {
+ "mask": 512,
+ "name": "accessor"
+ },
+ {
+ "mask": 1024,
+ "name": "undef_value"
+ },
+ {
+ "mask": 2048,
+ "name": "func_decl"
+ }
+ ],
+ "name": "DECLVAR"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC"
+ ],
+ "name": "DELVAR"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC"
+ ],
+ "name": "CSVAR"
+ },
+ {
+ "args": [
+ "A_RI",
+ "B_RC"
+ ],
+ "name": "CSVARI"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_I"
+ ],
+ "name": "CLOSURE"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "GETPROP"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "PUTPROP"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_R",
+ "C_RC"
+ ],
+ "name": "DELPROP"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_R",
+ "C_RC"
+ ],
+ "name": "CSPROP"
+ },
+ {
+ "args": [
+ "A_RI",
+ "B_R",
+ "C_RC"
+ ],
+ "name": "CSPROPI"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "ADD"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "SUB"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "MUL"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "DIV"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "MOD"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "BAND"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "BOR"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "BXOR"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "BASL"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "BLSR"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "BASR"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "EQ"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "NEQ"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "SEQ"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "SNEQ"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "GT"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "GE"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "LT"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "LE"
+ },
+ {
+ "args": [
+ "A_B",
+ "B_RC"
+ ],
+ "name": "IF"
+ },
+ {
+ "args": [
+ "ABC_JUMP"
+ ],
+ "name": "JUMP"
+ },
+ {
+ "args": [
+ "A_H",
+ "B_RC"
+ ],
+ "flags": [
+ {
+ "mask": 64,
+ "name": "have_retval"
+ }
+ ],
+ "name": "RETURN"
+ },
+ {
+ "args": [
+ "A_H",
+ "B_R",
+ "C_I"
+ ],
+ "flags": [
+ {
+ "mask": 64,
+ "name": "tailcall"
+ },
+ {
+ "mask": 128,
+ "name": "evalcall"
+ }
+ ],
+ "name": "CALL"
+ },
+ {
+ "args": [
+ "A_H",
+ "B_RI",
+ "C_I"
+ ],
+ "name": "CALLI"
+ },
+ {
+ "args": [
+ "A_H",
+ "BC_R"
+ ],
+ "flags": [
+ {
+ "mask": 64,
+ "name": "have_catch"
+ },
+ {
+ "mask": 128,
+ "name": "have_finally"
+ },
+ {
+ "mask": 256,
+ "name": "catch_binding"
+ },
+ {
+ "mask": 512,
+ "name": "with_binding"
+ }
+ ],
+ "name": "TRYCATCH"
+ },
+ {
+ "name": "EXTRA",
+ "extra": true
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_R"
+ ],
+ "name": "PREINCR"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_R"
+ ],
+ "name": "PREDECR"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_R"
+ ],
+ "name": "POSTINCR"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_R"
+ ],
+ "name": "POSTDECR"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_C"
+ ],
+ "name": "PREINCV"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_C"
+ ],
+ "name": "PREDECV"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_C"
+ ],
+ "name": "POSTINCV"
+ },
+ {
+ "args": [
+ "A_R",
+ "BC_C"
+ ],
+ "name": "POSTDECV"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "PREINCP"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "PREDECP"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "POSTINCP"
+ },
+ {
+ "args": [
+ "A_R",
+ "B_RC",
+ "C_RC"
+ ],
+ "name": "POSTDECP"
+ }
+ ],
+ "client_commands": [
+ "Reserved_0",
+ "Status",
+ "Print",
+ "Alert",
+ "Log",
+ "Throw",
+ "Detaching",
+ "AppNotify"
+ ],
+ "extra": [
+ {
+ "name": "NOP"
+ },
+ {
+ "args": [
+ "BC_I"
+ ],
+ "name": "INVALID"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "LDTHIS"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "LDUNDEF"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "LDNULL"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "LDTRUE"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "LDFALSE"
+ },
+ {
+ "args": [
+ "B_R"
+ ],
+ "name": "NEWOBJ"
+ },
+ {
+ "args": [
+ "B_R"
+ ],
+ "name": "NEWARR"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_R"
+ ],
+ "name": "SETALEN"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "TYPEOF"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_RC"
+ ],
+ "name": "TYPEOFID"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_R"
+ ],
+ "name": "INITENUM"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_R"
+ ],
+ "name": "NEXTENUM"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_R"
+ ],
+ "name": "INITSET"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_RI"
+ ],
+ "name": "INITSETI"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_RI"
+ ],
+ "name": "INITGET"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_RI"
+ ],
+ "name": "INITGETI"
+ },
+ {
+ "name": "ENDTRY"
+ },
+ {
+ "name": "ENDCATCH"
+ },
+ {
+ "name": "ENDFIN"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "THROW"
+ },
+ {
+ "name": "INVLHS"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "UNM"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "UNP"
+ },
+ {
+ "name": "DEBUGGER"
+ },
+ {
+ "args": [
+ "BC_I"
+ ],
+ "name": "BREAK"
+ },
+ {
+ "args": [
+ "BC_I"
+ ],
+ "name": "CONTINUE"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "BNOT"
+ },
+ {
+ "args": [
+ "BC_R"
+ ],
+ "name": "LNOT"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_RC"
+ ],
+ "name": "INSTOF"
+ },
+ {
+ "args": [
+ "B_R",
+ "C_RC"
+ ],
+ "name": "IN"
+ },
+ {
+ "args": [
+ "BC_I"
+ ],
+ "name": "LABEL"
+ },
+ {
+ "args": [
+ "BC_I"
+ ],
+ "name": "ENDLABEL"
+ },
+ {
+ "name": "EXTRA34"
+ },
+ {
+ "name": "EXTRA35"
+ },
+ {
+ "name": "EXTRA36"
+ },
+ {
+ "name": "EXTRA37"
+ },
+ {
+ "name": "EXTRA38"
+ },
+ {
+ "name": "EXTRA39"
+ },
+ {
+ "name": "EXTRA40"
+ },
+ {
+ "name": "EXTRA41"
+ },
+ {
+ "name": "EXTRA42"
+ },
+ {
+ "name": "EXTRA43"
+ },
+ {
+ "name": "EXTRA44"
+ },
+ {
+ "name": "EXTRA45"
+ },
+ {
+ "name": "EXTRA46"
+ },
+ {
+ "name": "EXTRA47"
+ },
+ {
+ "name": "EXTRA48"
+ },
+ {
+ "name": "EXTRA49"
+ },
+ {
+ "name": "EXTRA50"
+ },
+ {
+ "name": "EXTRA51"
+ },
+ {
+ "name": "EXTRA52"
+ },
+ {
+ "name": "EXTRA53"
+ },
+ {
+ "name": "EXTRA54"
+ },
+ {
+ "name": "EXTRA55"
+ },
+ {
+ "name": "EXTRA56"
+ },
+ {
+ "name": "EXTRA57"
+ },
+ {
+ "name": "EXTRA58"
+ },
+ {
+ "name": "EXTRA59"
+ },
+ {
+ "name": "EXTRA60"
+ },
+ {
+ "name": "EXTRA61"
+ },
+ {
+ "name": "EXTRA62"
+ },
+ {
+ "name": "EXTRA63"
+ },
+ {
+ "name": "EXTRA64"
+ },
+ {
+ "name": "EXTRA65"
+ },
+ {
+ "name": "EXTRA66"
+ },
+ {
+ "name": "EXTRA67"
+ },
+ {
+ "name": "EXTRA68"
+ },
+ {
+ "name": "EXTRA69"
+ },
+ {
+ "name": "EXTRA70"
+ },
+ {
+ "name": "EXTRA71"
+ },
+ {
+ "name": "EXTRA72"
+ },
+ {
+ "name": "EXTRA73"
+ },
+ {
+ "name": "EXTRA74"
+ },
+ {
+ "name": "EXTRA75"
+ },
+ {
+ "name": "EXTRA76"
+ },
+ {
+ "name": "EXTRA77"
+ },
+ {
+ "name": "EXTRA78"
+ },
+ {
+ "name": "EXTRA79"
+ },
+ {
+ "name": "EXTRA80"
+ },
+ {
+ "name": "EXTRA81"
+ },
+ {
+ "name": "EXTRA82"
+ },
+ {
+ "name": "EXTRA83"
+ },
+ {
+ "name": "EXTRA84"
+ },
+ {
+ "name": "EXTRA85"
+ },
+ {
+ "name": "EXTRA86"
+ },
+ {
+ "name": "EXTRA87"
+ },
+ {
+ "name": "EXTRA88"
+ },
+ {
+ "name": "EXTRA89"
+ },
+ {
+ "name": "EXTRA90"
+ },
+ {
+ "name": "EXTRA91"
+ },
+ {
+ "name": "EXTRA92"
+ },
+ {
+ "name": "EXTRA93"
+ },
+ {
+ "name": "EXTRA94"
+ },
+ {
+ "name": "EXTRA95"
+ },
+ {
+ "name": "EXTRA96"
+ },
+ {
+ "name": "EXTRA97"
+ },
+ {
+ "name": "EXTRA98"
+ },
+ {
+ "name": "EXTRA99"
+ },
+ {
+ "name": "EXTRA100"
+ },
+ {
+ "name": "EXTRA101"
+ },
+ {
+ "name": "EXTRA102"
+ },
+ {
+ "name": "EXTRA103"
+ },
+ {
+ "name": "EXTRA104"
+ },
+ {
+ "name": "EXTRA105"
+ },
+ {
+ "name": "EXTRA106"
+ },
+ {
+ "name": "EXTRA107"
+ },
+ {
+ "name": "EXTRA108"
+ },
+ {
+ "name": "EXTRA109"
+ },
+ {
+ "name": "EXTRA110"
+ },
+ {
+ "name": "EXTRA111"
+ },
+ {
+ "name": "EXTRA112"
+ },
+ {
+ "name": "EXTRA113"
+ },
+ {
+ "name": "EXTRA114"
+ },
+ {
+ "name": "EXTRA115"
+ },
+ {
+ "name": "EXTRA116"
+ },
+ {
+ "name": "EXTRA117"
+ },
+ {
+ "name": "EXTRA118"
+ },
+ {
+ "name": "EXTRA119"
+ },
+ {
+ "name": "EXTRA120"
+ },
+ {
+ "name": "EXTRA121"
+ },
+ {
+ "name": "EXTRA122"
+ },
+ {
+ "name": "EXTRA123"
+ },
+ {
+ "name": "EXTRA124"
+ },
+ {
+ "name": "EXTRA125"
+ },
+ {
+ "name": "EXTRA126"
+ },
+ {
+ "name": "EXTRA127"
+ },
+ {
+ "name": "EXTRA128"
+ },
+ {
+ "name": "EXTRA129"
+ },
+ {
+ "name": "EXTRA130"
+ },
+ {
+ "name": "EXTRA131"
+ },
+ {
+ "name": "EXTRA132"
+ },
+ {
+ "name": "EXTRA133"
+ },
+ {
+ "name": "EXTRA134"
+ },
+ {
+ "name": "EXTRA135"
+ },
+ {
+ "name": "EXTRA136"
+ },
+ {
+ "name": "EXTRA137"
+ },
+ {
+ "name": "EXTRA138"
+ },
+ {
+ "name": "EXTRA139"
+ },
+ {
+ "name": "EXTRA140"
+ },
+ {
+ "name": "EXTRA141"
+ },
+ {
+ "name": "EXTRA142"
+ },
+ {
+ "name": "EXTRA143"
+ },
+ {
+ "name": "EXTRA144"
+ },
+ {
+ "name": "EXTRA145"
+ },
+ {
+ "name": "EXTRA146"
+ },
+ {
+ "name": "EXTRA147"
+ },
+ {
+ "name": "EXTRA148"
+ },
+ {
+ "name": "EXTRA149"
+ },
+ {
+ "name": "EXTRA150"
+ },
+ {
+ "name": "EXTRA151"
+ },
+ {
+ "name": "EXTRA152"
+ },
+ {
+ "name": "EXTRA153"
+ },
+ {
+ "name": "EXTRA154"
+ },
+ {
+ "name": "EXTRA155"
+ },
+ {
+ "name": "EXTRA156"
+ },
+ {
+ "name": "EXTRA157"
+ },
+ {
+ "name": "EXTRA158"
+ },
+ {
+ "name": "EXTRA159"
+ },
+ {
+ "name": "EXTRA160"
+ },
+ {
+ "name": "EXTRA161"
+ },
+ {
+ "name": "EXTRA162"
+ },
+ {
+ "name": "EXTRA163"
+ },
+ {
+ "name": "EXTRA164"
+ },
+ {
+ "name": "EXTRA165"
+ },
+ {
+ "name": "EXTRA166"
+ },
+ {
+ "name": "EXTRA167"
+ },
+ {
+ "name": "EXTRA168"
+ },
+ {
+ "name": "EXTRA169"
+ },
+ {
+ "name": "EXTRA170"
+ },
+ {
+ "name": "EXTRA171"
+ },
+ {
+ "name": "EXTRA172"
+ },
+ {
+ "name": "EXTRA173"
+ },
+ {
+ "name": "EXTRA174"
+ },
+ {
+ "name": "EXTRA175"
+ },
+ {
+ "name": "EXTRA176"
+ },
+ {
+ "name": "EXTRA177"
+ },
+ {
+ "name": "EXTRA178"
+ },
+ {
+ "name": "EXTRA179"
+ },
+ {
+ "name": "EXTRA180"
+ },
+ {
+ "name": "EXTRA181"
+ },
+ {
+ "name": "EXTRA182"
+ },
+ {
+ "name": "EXTRA183"
+ },
+ {
+ "name": "EXTRA184"
+ },
+ {
+ "name": "EXTRA185"
+ },
+ {
+ "name": "EXTRA186"
+ },
+ {
+ "name": "EXTRA187"
+ },
+ {
+ "name": "EXTRA188"
+ },
+ {
+ "name": "EXTRA189"
+ },
+ {
+ "name": "EXTRA190"
+ },
+ {
+ "name": "EXTRA191"
+ },
+ {
+ "name": "EXTRA192"
+ },
+ {
+ "name": "EXTRA193"
+ },
+ {
+ "name": "EXTRA194"
+ },
+ {
+ "name": "EXTRA195"
+ },
+ {
+ "name": "EXTRA196"
+ },
+ {
+ "name": "EXTRA197"
+ },
+ {
+ "name": "EXTRA198"
+ },
+ {
+ "name": "EXTRA199"
+ },
+ {
+ "name": "EXTRA200"
+ },
+ {
+ "name": "EXTRA201"
+ },
+ {
+ "name": "EXTRA202"
+ },
+ {
+ "name": "EXTRA203"
+ },
+ {
+ "name": "EXTRA204"
+ },
+ {
+ "name": "EXTRA205"
+ },
+ {
+ "name": "EXTRA206"
+ },
+ {
+ "name": "EXTRA207"
+ },
+ {
+ "name": "EXTRA208"
+ },
+ {
+ "name": "EXTRA209"
+ },
+ {
+ "name": "EXTRA210"
+ },
+ {
+ "name": "EXTRA211"
+ },
+ {
+ "name": "EXTRA212"
+ },
+ {
+ "name": "EXTRA213"
+ },
+ {
+ "name": "EXTRA214"
+ },
+ {
+ "name": "EXTRA215"
+ },
+ {
+ "name": "EXTRA216"
+ },
+ {
+ "name": "EXTRA217"
+ },
+ {
+ "name": "EXTRA218"
+ },
+ {
+ "name": "EXTRA219"
+ },
+ {
+ "name": "EXTRA220"
+ },
+ {
+ "name": "EXTRA221"
+ },
+ {
+ "name": "EXTRA222"
+ },
+ {
+ "name": "EXTRA223"
+ },
+ {
+ "name": "EXTRA224"
+ },
+ {
+ "name": "EXTRA225"
+ },
+ {
+ "name": "EXTRA226"
+ },
+ {
+ "name": "EXTRA227"
+ },
+ {
+ "name": "EXTRA228"
+ },
+ {
+ "name": "EXTRA229"
+ },
+ {
+ "name": "EXTRA230"
+ },
+ {
+ "name": "EXTRA231"
+ },
+ {
+ "name": "EXTRA232"
+ },
+ {
+ "name": "EXTRA233"
+ },
+ {
+ "name": "EXTRA234"
+ },
+ {
+ "name": "EXTRA235"
+ },
+ {
+ "name": "EXTRA236"
+ },
+ {
+ "name": "EXTRA237"
+ },
+ {
+ "name": "EXTRA238"
+ },
+ {
+ "name": "EXTRA239"
+ },
+ {
+ "name": "EXTRA240"
+ },
+ {
+ "name": "EXTRA241"
+ },
+ {
+ "name": "EXTRA242"
+ },
+ {
+ "name": "EXTRA243"
+ },
+ {
+ "name": "EXTRA244"
+ },
+ {
+ "name": "EXTRA245"
+ },
+ {
+ "name": "EXTRA246"
+ },
+ {
+ "name": "EXTRA247"
+ },
+ {
+ "name": "EXTRA248"
+ },
+ {
+ "name": "EXTRA249"
+ },
+ {
+ "name": "EXTRA250"
+ },
+ {
+ "name": "EXTRA251"
+ },
+ {
+ "name": "EXTRA252"
+ },
+ {
+ "name": "EXTRA253"
+ },
+ {
+ "name": "EXTRA254"
+ },
+ {
+ "name": "EXTRA255"
+ }
+ ],
+ "target_commands": [
+ "Reserved_0",
+ "Reserved_1",
+ "Reserved_2",
+ "Reserved_3",
+ "Reserved_4",
+ "Reserved_5",
+ "Reserved_6",
+ "Reserved_7",
+ "Reserved_8",
+ "Reserved_9",
+ "Reserved_10",
+ "Reserved_11",
+ "Reserved_12",
+ "Reserved_13",
+ "Reserved_14",
+ "Reserved_15",
+ "BasicInfo",
+ "TriggerStatus",
+ "Pause",
+ "Resume",
+ "StepInto",
+ "StepOver",
+ "StepOut",
+ "ListBreak",
+ "AddBreak",
+ "DelBreak",
+ "GetVar",
+ "PutVar",
+ "GetCallStack",
+ "GetLocals",
+ "Eval",
+ "Detach",
+ "DumpHeap",
+ "GetBytecode",
+ "AppRequest",
+ "GetHeapObjInfo",
+ "GetObjPropDesc",
+ "GetObjPropDescRange"
+ ],
+ "error_codes": [
+ "Unknown",
+ "UnsupportedCommand",
+ "TooMany",
+ "NotFound",
+ "ApplicationError"
+ ],
+ "class_names": [
+ "unused",
+ "Arguments",
+ "Array",
+ "Boolean",
+ "Date",
+ "Error",
+ "Function",
+ "JSON",
+ "Math",
+ "Number",
+ "Object",
+ "RegExp",
+ "String",
+ "global",
+ "ObjEnv",
+ "DecEnv",
+ "Buffer",
+ "Pointer",
+ "Thread",
+ "ArrayBuffer",
+ "DataView",
+ "Int8Array",
+ "Uint8Array",
+ "Uint8ClampedArray",
+ "Int16Array",
+ "Uint16Array",
+ "Int32Array",
+ "Uint32Array",
+ "Float32Array",
+ "Float64Array"
+ ]
+}
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debug_proxy.js b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debug_proxy.js
new file mode 100644
index 000000000..10ba6145d
--- /dev/null
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debug_proxy.js
@@ -0,0 +1,1029 @@
+/*
+ * JSON debug proxy written in DukLuv
+ *
+ * This single file JSON debug proxy implementation is an alternative to the
+ * Node.js-based proxy in duk_debug.js. DukLuv is a much smaller dependency
+ * than Node.js so embedding DukLuv in a debug client is easier.
+ */
+
+'use strict';
+
+// XXX: Code assumes uv.write() will write fully. This is not necessarily
+// true; should add support for partial writes (or at least failing when
+// a partial write occurs).
+
+var log = new Duktape.Logger('Proxy'); // default logger
+//log.l = 0; // enable debug and trace logging
+
+/*
+ * Config
+ */
+
+var serverHost = '0.0.0.0';
+var serverPort = 9093;
+var targetHost = '127.0.0.1';
+var targetPort = 9091;
+var singleConnection = false;
+var readableNumberValue = false;
+var lenientJsonParse = false;
+var jxParse = false;
+var metadataFile = null;
+var metadata = {};
+var TORTURE = false; // for manual testing of binary/json parsing robustness
+
+/*
+ * Detect missing 'var' declarations
+ */
+
+// Prevent new bindings on global object. This detects missing 'var'
+// declarations, e.g. "x = 123;" in a function without declaring it.
+var global = new Function('return this;')();
+log.debug('Preventing extensions on global object');
+log.debug('Global is extensible:', Object.isExtensible(global));
+Object.preventExtensions(global);
+log.debug('Global is extensible:', Object.isExtensible(global));
+
+/*
+ * Misc helpers
+ */
+
+function plainBufferCopy(typedarray) {
+ // This is still pretty awkward in Duktape 1.4.x.
+ // Argument may be a "slice" and we want a copy of the slice
+ // (not the full underlying buffer).
+
+ var u8 = new Uint8Array(typedarray.length);
+ u8.set(typedarray); // make a copy, ensuring there's no slice offset
+ return Duktape.Buffer(u8); // get underlying plain buffer
+}
+
+function isObject(x) {
+ // Note that typeof null === 'object'.
+ return (typeof x === 'object' && x !== null);
+}
+
+function readFully(filename, cb) {
+ uv.fs_open(metadataFile, 'r', 0, function (handle, err) {
+ var fileOff = 0;
+ var data = new Uint8Array(256);
+ var dataOff = 0;
+
+ if (err) {
+ return cb(null, err);
+ }
+ function readCb(buf, err) {
+ var res;
+ var newData;
+
+ log.debug('Read callback:', buf.length, err);
+ if (err) {
+ uv.fs_close(handle);
+ return cb(null, err);
+ }
+ if (buf.length == 0) {
+ uv.fs_close(handle);
+ res = new Uint8Array(dataOff);
+ res.set(data.subarray(0, dataOff));
+ res = Duktape.Buffer(res); // plain buffer
+ log.debug('Read', res.length, 'bytes from', filename);
+ return cb(res, null);
+ }
+ while (data.length - dataOff < buf.length) {
+ log.debug('Resize file read buffer:', data.length, '->', data.length * 2);
+ newData = new Uint8Array(data.length * 2);
+ newData.set(data);
+ data = newData;
+ }
+ data.set(new Uint8Array(buf), dataOff);
+ dataOff += buf.length;
+ fileOff += buf.length;
+ uv.fs_read(handle, 4096, fileOff, readCb);
+ }
+ uv.fs_read(handle, 4096, fileOff, readCb);
+ });
+}
+
+/*
+ * JSON proxy server
+ *
+ * Accepts an incoming JSON proxy client and connects to a debug target,
+ * tying the two connections together. Supports both a single connection
+ * and a persistent mode.
+ */
+
+function JsonProxyServer(host, port) {
+ this.name = 'JsonProxyServer';
+ this.handle = uv.new_tcp();
+ uv.tcp_bind(this.handle, host, port);
+ uv.listen(this.handle, 128, this.onConnection.bind(this));
+}
+
+JsonProxyServer.prototype.onConnection = function onConnection(err) {
+ if (err) {
+ log.error('JSON proxy onConnection error:', err);
+ return;
+ }
+ log.info('JSON proxy client connected'); // XXX: it'd be nice to log remote peer host:port
+
+ var jsonSock = new JsonConnHandler(this);
+ var targSock = new TargetConnHandler(this);
+ jsonSock.targetHandler = targSock;
+ targSock.jsonHandler = jsonSock;
+ uv.accept(this.handle, jsonSock.handle);
+
+ log.info('Connecting to debug target at', targetHost + ':' + targetPort);
+ jsonSock.writeJson({ notify: '_TargetConnecting', args: [ targetHost, targetPort ] });
+ uv.tcp_connect(targSock.handle, targetHost, targetPort, targSock.onConnect.bind(targSock));
+
+ if (singleConnection) {
+ log.info('Single connection mode, stop listening for more connections');
+ uv.shutdown(this.handle);
+ uv.read_stop(this.handle); // unnecessary but just in case
+ uv.close(this.handle);
+ this.handle = null;
+ }
+};
+
+JsonProxyServer.prototype.onProxyClientDisconnected = function onProxyClientDisconnected() {
+ // When this is invoked the proxy connection and the target connection
+ // have both been closed.
+ if (singleConnection) {
+ log.info('Proxy connection finished (single connection mode: we should be exiting now)');
+ } else {
+ log.info('Proxy connection finished (persistent mode: wait for more connections)');
+ }
+};
+
+/*
+ * JSON connection handler
+ */
+
+function JsonConnHandler(server) {
+ var i, n;
+
+ this.name = 'JsonConnHandler';
+ this.server = server;
+ this.handle = uv.new_tcp();
+ this.incoming = new Uint8Array(4096);
+ this.incomingOffset = 0;
+ this.targetHandler = null;
+
+ this.commandNumberLookup = {};
+ if (metadata && metadata.target_commands) {
+ for (i = 0, n = metadata.target_commands.length; i < n; i++) {
+ this.commandNumberLookup[metadata.target_commands[i]] = i;
+ }
+ }
+}
+
+JsonConnHandler.prototype.finish = function finish(msg) {
+ var args;
+
+ if (!this.handle) {
+ log.info('JsonConnHandler already disconnected, ignore finish()');
+ return;
+ }
+ log.info('JsonConnHandler finished:', msg);
+ try {
+ args = msg ? [ msg ] : void 0;
+ this.writeJson({ notify: '_Disconnecting', args: args });
+ } catch (e) {
+ log.info('Failed to write _Disconnecting notify, ignoring:', e);
+ }
+ uv.shutdown(this.handle);
+ uv.read_stop(this.handle);
+ uv.close(this.handle);
+ this.handle = null;
+
+ this.targetHandler.finish(msg); // disconnect target too (if not already disconnected)
+
+ this.server.onProxyClientDisconnected();
+};
+
+JsonConnHandler.prototype.onRead = function onRead(err, data) {
+ var newIncoming;
+ var msg;
+ var errmsg;
+ var tmpBuf;
+
+ log.trace('Received data from JSON socket, err:', err, 'data length:', data ? data.length : 'null');
+
+ if (err) {
+ errmsg = 'Error reading data from JSON debug client: ' + err;
+ this.finish(errmsg);
+ return;
+ }
+ if (data) {
+ // Feed the data one byte at a time when torture testing.
+ if (TORTURE && data.length > 1) {
+ for (var i = 0; i < data.length; i++) {
+ tmpBuf = Duktape.Buffer(1);
+ tmpBuf[0] = data[i];
+ this.onRead(null, tmpBuf);
+ }
+ return;
+ }
+
+ // Receive data into 'incoming', resizing as necessary.
+ while (data.length > this.incoming.length - this.incomingOffset) {
+ newIncoming = new Uint8Array(this.incoming.length * 1.3 + 16);
+ newIncoming.set(this.incoming);
+ this.incoming = newIncoming;
+ log.debug('Resize incoming JSON buffer to ' + this.incoming.length);
+ }
+ this.incoming.set(new Uint8Array(data), this.incomingOffset);
+ this.incomingOffset += data.length;
+
+ // Trial parse JSON message(s).
+ while (true) {
+ msg = this.trialParseJsonMessage();
+ if (!msg) {
+ break;
+ }
+ try {
+ this.dispatchJsonMessage(msg);
+ } catch (e) {
+ errmsg = 'JSON message dispatch failed: ' + e;
+ this.writeJson({ notify: '_Error', args: [ errmsg ] });
+ if (lenientJsonParse) {
+ log.warn('JSON message dispatch failed (lenient mode, ignoring):', e);
+ } else {
+ log.warn('JSON message dispatch failed (dropping connection):', e);
+ this.finish(errmsg);
+ }
+ }
+ }
+ } else {
+ this.finish('JSON proxy client disconnected');
+ }
+};
+
+JsonConnHandler.prototype.writeJson = function writeJson(msg) {
+ log.info('PROXY --> CLIENT:', JSON.stringify(msg));
+ if (this.handle) {
+ uv.write(this.handle, JSON.stringify(msg) + '\n');
+ }
+};
+
+JsonConnHandler.prototype.handleDebugMessage = function handleDebugMessage(dvalues) {
+ var msg = {};
+ var idx = 0;
+ var cmd;
+
+ if (dvalues.length <= 0) {
+ throw new Error('invalid dvalues list: length <= 0');
+ }
+ var x = dvalues[idx++];
+ if (!isObject(x)) {
+ throw new Error('invalid initial dvalue: ' + Duktape.enc('jx', dvalues));
+ }
+ if (x.type === 'req') {
+ cmd = dvalues[idx++];
+ if (typeof cmd !== 'number') {
+ throw new Error('invalid command: ' + Duktape.enc('jx', cmd));
+ }
+ msg.request = this.determineCommandName(cmd) || true;
+ msg.command = cmd;
+ } else if (x.type === 'rep') {
+ msg.reply = true;
+ } else if (x.type === 'err') {
+ msg.error = true;
+ } else if (x.type === 'nfy') {
+ cmd = dvalues[idx++];
+ if (typeof cmd !== 'number') {
+ throw new Error('invalid command: ' + Duktape.enc('jx', cmd));
+ }
+ msg.notify = this.determineCommandName(cmd) || true;
+ msg.command = cmd;
+ } else {
+ throw new Error('invalid initial dvalue: ' + Duktape.enc('jx', dvalues));
+ }
+
+ for (; idx < dvalues.length - 1; idx++) {
+ if (!msg.args) {
+ msg.args = [];
+ }
+ msg.args.push(dvalues[idx]);
+ }
+
+ if (!isObject(dvalues[idx]) || dvalues[idx].type !== 'eom') {
+ throw new Error('invalid final dvalue: ' + Duktape.enc('jx', dvalues));
+ }
+
+ this.writeJson(msg);
+};
+
+JsonConnHandler.prototype.determineCommandName = function determineCommandName(cmd) {
+ if (!(metadata && metadata.client_commands)) {
+ return;
+ }
+ return metadata.client_commands[cmd];
+};
+
+JsonConnHandler.prototype.trialParseJsonMessage = function trialParseJsonMessage() {
+ var buf = this.incoming;
+ var avail = this.incomingOffset;
+ var i;
+ var msg, str, errmsg;
+
+ for (i = 0; i < avail; i++) {
+ if (buf[i] == 0x0a) {
+ str = String(plainBufferCopy(buf.subarray(0, i)));
+ try {
+ if (jxParse) {
+ msg = Duktape.dec('jx', str);
+ } else {
+ msg = JSON.parse(str);
+ }
+ } catch (e) {
+ // In lenient mode if JSON parse fails just send back an _Error
+ // and ignore the line (useful for initial development).
+ //
+ // In non-lenient mode drop the connection here; if the failed line
+ // was a request the client is expecting a reply/error message back
+ // (otherwise it may go out of sync) but we can't send a synthetic
+ // one (as we can't parse the request).
+ errmsg = 'JSON parse failed for: ' + JSON.stringify(str) + ': ' + e;
+ this.writeJson({ notify: '_Error', args: [ errmsg ] });
+ if (lenientJsonParse) {
+ log.warn('JSON parse failed (lenient mode, ignoring):', e);
+ } else {
+ log.warn('JSON parse failed (dropping connection):', e);
+ this.finish(errmsg);
+ }
+ }
+
+ this.incoming.set(this.incoming.subarray(i + 1));
+ this.incomingOffset -= i + 1;
+ return msg;
+ }
+ }
+};
+
+JsonConnHandler.prototype.dispatchJsonMessage = function dispatchJsonMessage(msg) {
+ var cmd;
+ var dvalues = [];
+ var i, n;
+
+ log.info('PROXY <-- CLIENT:', JSON.stringify(msg));
+
+ // Parse message type, determine initial marker for binary message.
+ if (msg.request) {
+ cmd = this.determineCommandNumber(msg.request, msg.command);
+ dvalues.push(new Uint8Array([ 0x01 ]));
+ dvalues.push(this.encodeJsonDvalue(cmd));
+ } else if (msg.reply) {
+ dvalues.push(new Uint8Array([ 0x02 ]));
+ } else if (msg.notify) {
+ cmd = this.determineCommandNumber(msg.notify, msg.command);
+ dvalues.push(new Uint8Array([ 0x04 ]));
+ dvalues.push(this.encodeJsonDvalue(cmd));
+ } else if (msg.error) {
+ dvalues.push(new Uint8Array([ 0x03 ]));
+ } else {
+ throw new Error('invalid input JSON message: ' + JSON.stringify(msg));
+ }
+
+ // Encode arguments into dvalues.
+ for (i = 0, n = (msg.args ? msg.args.length : 0); i < n; i++) {
+ dvalues.push(this.encodeJsonDvalue(msg.args[i]));
+ }
+
+ // Add an EOM, and write out the dvalues to the debug target.
+ dvalues.push(new Uint8Array([ 0x00 ]));
+ for (i = 0, n = dvalues.length; i < n; i++) {
+ this.targetHandler.writeBinary(dvalues[i]);
+ }
+};
+
+JsonConnHandler.prototype.determineCommandNumber = function determineCommandNumber(name, val) {
+ var res;
+
+ if (typeof name === 'string') {
+ res = this.commandNumberLookup[name];
+ if (!res) {
+ log.info('Unknown command name: ' + name + ', command number: ' + val);
+ }
+ } else if (typeof name === 'number') {
+ res = name;
+ } else if (name !== true) {
+ throw new Error('invalid command name (must be string, number, or "true"): ' + name);
+ }
+ if (typeof res === 'undefined' && typeof val === 'undefined') {
+ throw new Error('cannot determine command number from name: ' + name);
+ }
+ if (typeof val !== 'number' && typeof val !== 'undefined') {
+ throw new Error('invalid command number: ' + val);
+ }
+ res = res || val;
+ return res;
+};
+
+JsonConnHandler.prototype.writeDebugStringToBuffer = function writeDebugStringToBuffer(v, buf, off) {
+ var i, n;
+
+ for (i = 0, n = v.length; i < n; i++) {
+ buf[off + i] = v.charCodeAt(i) & 0xff; // truncate higher bits
+ }
+};
+
+JsonConnHandler.prototype.encodeJsonDvalue = function encodeJsonDvalue(v) {
+ var buf, dec, len, dv;
+
+ if (isObject(v)) {
+ if (v.type === 'eom') {
+ return new Uint8Array([ 0x00 ]);
+ } else if (v.type === 'req') {
+ return new Uint8Array([ 0x01 ]);
+ } else if (v.type === 'rep') {
+ return new Uint8Array([ 0x02 ]);
+ } else if (v.type === 'err') {
+ return new Uint8Array([ 0x03 ]);
+ } else if (v.type === 'nfy') {
+ return new Uint8Array([ 0x04 ]);
+ } else if (v.type === 'unused') {
+ return new Uint8Array([ 0x15 ]);
+ } else if (v.type === 'undefined') {
+ return new Uint8Array([ 0x16 ]);
+ } else if (v.type === 'number') {
+ dec = Duktape.dec('hex', v.data);
+ len = dec.length;
+ if (len !== 8) {
+ throw new TypeError('value cannot be converted to dvalue: ' + JSON.stringify(v));
+ }
+ buf = new Uint8Array(1 + len);
+ buf[0] = 0x1a;
+ buf.set(new Uint8Array(dec), 1);
+ return buf;
+ } else if (v.type === 'buffer') {
+ dec = Duktape.dec('hex', v.data);
+ len = dec.length;
+ if (len <= 0xffff) {
+ buf = new Uint8Array(3 + len);
+ buf[0] = 0x14;
+ buf[1] = (len >> 8) & 0xff;
+ buf[2] = (len >> 0) & 0xff;
+ buf.set(new Uint8Arrau(dec), 3);
+ return buf;
+ } else {
+ buf = new Uint8Array(5 + len);
+ buf[0] = 0x13;
+ buf[1] = (len >> 24) & 0xff;
+ buf[2] = (len >> 16) & 0xff;
+ buf[3] = (len >> 8) & 0xff;
+ buf[4] = (len >> 0) & 0xff;
+ buf.set(new Uint8Array(dec), 5);
+ return buf;
+ }
+ } else if (v.type === 'object') {
+ dec = Duktape.dec('hex', v.pointer);
+ len = dec.length;
+ buf = new Uint8Array(3 + len);
+ buf[0] = 0x1b;
+ buf[1] = v.class;
+ buf[2] = len;
+ buf.set(new Uint8Array(dec), 3);
+ return buf;
+ } else if (v.type === 'pointer') {
+ dec = Duktape.dec('hex', v.pointer);
+ len = dec.length;
+ buf = new Uint8Array(2 + len);
+ buf[0] = 0x1c;
+ buf[1] = len;
+ buf.set(new Uint8Array(dec), 2);
+ return buf;
+ } else if (v.type === 'lightfunc') {
+ dec = Duktape.dec('hex', v.pointer);
+ len = dec.length;
+ buf = new Uint8Array(4 + len);
+ buf[0] = 0x1d;
+ buf[1] = (v.flags >> 8) & 0xff;
+ buf[2] = v.flags & 0xff;
+ buf[3] = len;
+ buf.set(new Uint8Array(dec), 4);
+ return buf;
+ } else if (v.type === 'heapptr') {
+ dec = Duktape.dec('hex', v.pointer);
+ len = dec.length;
+ buf = new Uint8Array(2 + len);
+ buf[0] = 0x1e;
+ buf[1] = len;
+ buf.set(new Uint8Array(dec), 2);
+ return buf;
+ }
+ } else if (v === null) {
+ return new Uint8Array([ 0x17 ]);
+ } else if (typeof v === 'boolean') {
+ return new Uint8Array([ v ? 0x18 : 0x19 ]);
+ } else if (typeof v === 'number') {
+ if (Math.floor(v) === v && /* whole */
+ (v !== 0 || 1 / v > 0) && /* not negative zero */
+ v >= -0x80000000 && v <= 0x7fffffff) {
+ // Represented signed 32-bit integers as plain integers.
+ // Debugger code expects this for all fields that are not
+ // duk_tval representations (e.g. command numbers and such).
+ if (v >= 0x00 && v <= 0x3f) {
+ return new Uint8Array([ 0x80 + v ]);
+ } else if (v >= 0x0000 && v <= 0x3fff) {
+ return new Uint8Array([ 0xc0 + (v >> 8), v & 0xff ]);
+ } else if (v >= -0x80000000 && v <= 0x7fffffff) {
+ return new Uint8Array([ 0x10,
+ (v >> 24) & 0xff,
+ (v >> 16) & 0xff,
+ (v >> 8) & 0xff,
+ (v >> 0) & 0xff ]);
+ } else {
+ throw new Error('internal error when encoding integer to dvalue: ' + v);
+ }
+ } else {
+ // Represent non-integers as IEEE double dvalues.
+ buf = new Uint8Array(1 + 8);
+ buf[0] = 0x1a;
+ new DataView(buf).setFloat64(1, v, false);
+ return buf;
+ }
+ } else if (typeof v === 'string') {
+ if (v.length < 0 || v.length > 0xffffffff) {
+ // Not possible in practice.
+ throw new TypeError('cannot convert to dvalue, invalid string length: ' + v.length);
+ }
+ if (v.length <= 0x1f) {
+ buf = new Uint8Array(1 + v.length);
+ buf[0] = 0x60 + v.length;
+ this.writeDebugStringToBuffer(v, buf, 1);
+ return buf;
+ } else if (v.length <= 0xffff) {
+ buf = new Uint8Array(3 + v.length);
+ buf[0] = 0x12;
+ buf[1] = (v.length >> 8) & 0xff;
+ buf[2] = (v.length >> 0) & 0xff;
+ this.writeDebugStringToBuffer(v, buf, 3);
+ return buf;
+ } else {
+ buf = new Uint8Array(5 + v.length);
+ buf[0] = 0x11;
+ buf[1] = (v.length >> 24) & 0xff;
+ buf[2] = (v.length >> 16) & 0xff;
+ buf[3] = (v.length >> 8) & 0xff;
+ buf[4] = (v.length >> 0) & 0xff;
+ this.writeDebugStringToBuffer(v, buf, 5);
+ return buf;
+ }
+ }
+
+ throw new TypeError('value cannot be converted to dvalue: ' + JSON.stringify(v));
+};
+
+/*
+ * Target binary connection handler
+ */
+
+function TargetConnHandler(server) {
+ this.name = 'TargetConnHandler';
+ this.server = server;
+ this.handle = uv.new_tcp();
+ this.jsonHandler = null;
+ this.incoming = new Uint8Array(4096);
+ this.incomingOffset = 0;
+ this.dvalues = [];
+}
+
+TargetConnHandler.prototype.finish = function finish(msg) {
+ if (!this.handle) {
+ log.info('TargetConnHandler already disconnected, ignore finish()');
+ return;
+ }
+ log.info('TargetConnHandler finished:', msg);
+
+ this.jsonHandler.writeJson({ notify: '_TargetDisconnected' });
+
+ // XXX: write a notify to target?
+
+ uv.shutdown(this.handle);
+ uv.read_stop(this.handle);
+ uv.close(this.handle);
+ this.handle = null;
+
+ this.jsonHandler.finish(msg); // disconnect JSON client too (if not already disconnected)
+};
+
+TargetConnHandler.prototype.onConnect = function onConnect(err) {
+ var errmsg;
+
+ if (err) {
+ errmsg = 'Failed to connect to target: ' + err;
+ log.warn(errmsg);
+ this.jsonHandler.writeJson({ notify: '_Error', args: [ String(err) ] });
+ this.finish(errmsg);
+ return;
+ }
+
+ // Once we're connected to the target, start read both binary and JSON
+ // input. We don't want to read JSON input before this so that we can
+ // always translate incoming messages to dvalues and write them out
+ // without queueing. Any pending JSON messages will be queued by the
+ // OS instead.
+
+ log.info('Connected to debug target at', targetHost + ':' + targetPort);
+ uv.read_start(this.jsonHandler.handle, this.jsonHandler.onRead.bind(this.jsonHandler));
+ uv.read_start(this.handle, this.onRead.bind(this));
+};
+
+TargetConnHandler.prototype.writeBinary = function writeBinary(buf) {
+ var plain = plainBufferCopy(buf);
+ log.info('PROXY --> TARGET:', Duktape.enc('jx', plain));
+ if (this.handle) {
+ uv.write(this.handle, plain);
+ }
+};
+
+TargetConnHandler.prototype.onRead = function onRead(err, data) {
+ var res;
+ var errmsg;
+ var tmpBuf;
+ var newIncoming;
+
+ log.trace('Received data from target socket, err:', err, 'data length:', data ? data.length : 'null');
+
+ if (err) {
+ errmsg = 'Error reading data from debug target: ' + err;
+ this.finish(errmsg);
+ return;
+ }
+
+ if (data) {
+ // Feed the data one byte at a time when torture testing.
+ if (TORTURE && data.length > 1) {
+ for (var i = 0; i < data.length; i++) {
+ tmpBuf = Duktape.Buffer(1);
+ tmpBuf[0] = data[i];
+ this.onRead(null, tmpBuf);
+ }
+ return;
+ }
+
+ // Receive data into 'incoming', resizing as necessary.
+ while (data.length > this.incoming.length - this.incomingOffset) {
+ newIncoming = new Uint8Array(this.incoming.length * 1.3 + 16);
+ newIncoming.set(this.incoming);
+ this.incoming = newIncoming;
+ log.debug('Resize incoming binary buffer to ' + this.incoming.length);
+ }
+ this.incoming.set(new Uint8Array(data), this.incomingOffset);
+ this.incomingOffset += data.length;
+
+ // Trial parse handshake unless done.
+ if (!this.handshake) {
+ this.trialParseHandshake();
+ }
+
+ // Trial parse dvalue(s) and debug messages.
+ if (this.handshake) {
+ for (;;) {
+ res = this.trialParseDvalue();
+ if (!res) {
+ break;
+ }
+ log.trace('Got dvalue:', Duktape.enc('jx', res.dvalue));
+ this.dvalues.push(res.dvalue);
+ if (isObject(res.dvalue) && res.dvalue.type === 'eom') {
+ try {
+ this.jsonHandler.handleDebugMessage(this.dvalues);
+ this.dvalues = [];
+ } catch (e) {
+ errmsg = 'JSON message handling failed: ' + e;
+ this.jsonHandler.writeJson({ notify: '_Error', args: [ errmsg ] });
+ if (lenientJsonParse) {
+ log.warn('JSON message handling failed (lenient mode, ignoring):', e);
+ } else {
+ log.warn('JSON message handling failed (dropping connection):', e);
+ this.finish(errmsg);
+ }
+ }
+ }
+ }
+ }
+ } else {
+ log.info('Target disconnected');
+ this.finish('Target disconnected');
+ }
+};
+
+TargetConnHandler.prototype.trialParseHandshake = function trialParseHandshake() {
+ var buf = this.incoming;
+ var avail = this.incomingOffset;
+ var i;
+ var msg;
+ var m;
+ var protocolVersion;
+
+ for (i = 0; i < avail; i++) {
+ if (buf[i] == 0x0a) {
+ msg = String(plainBufferCopy(buf.subarray(0, i)));
+ this.incoming.set(this.incoming.subarray(i + 1));
+ this.incomingOffset -= i + 1;
+
+ // Generic handshake format: only relies on initial version field.
+ m = /^(\d+) (.*)$/.exec(msg) || {};
+ protocolVersion = +m[1];
+ this.handshake = {
+ line: msg,
+ protocolVersion: protocolVersion,
+ text: m[2]
+ };
+
+ // More detailed v1 handshake line.
+ if (protocolVersion === 1) {
+ m = /^(\d+) (\d+) (.*?) (.*?) (.*)$/.exec(msg) || {};
+ this.handshake.dukVersion = m[1];
+ this.handshake.dukGitDescribe = m[2];
+ this.handshake.targetString = m[3];
+ }
+
+ this.jsonHandler.writeJson({ notify: '_TargetConnected', args: [ msg ] });
+
+ log.info('Target handshake: ' + JSON.stringify(this.handshake));
+ return;
+ }
+ }
+};
+
+TargetConnHandler.prototype.bufferToDebugString = function bufferToDebugString(buf) {
+ return String.fromCharCode.apply(null, buf);
+};
+
+TargetConnHandler.prototype.trialParseDvalue = function trialParseDvalue() {
+ var _this = this;
+ var buf = this.incoming;
+ var avail = this.incomingOffset;
+ var v;
+ var gotValue = false; // explicit flag for e.g. v === undefined
+ var dv = new DataView(buf);
+ var tmp;
+ var x;
+ var len;
+
+ function consume(n) {
+ log.info('PROXY <-- TARGET:', Duktape.enc('jx', _this.incoming.subarray(0, n)));
+ _this.incoming.set(_this.incoming.subarray(n));
+ _this.incomingOffset -= n;
+ }
+
+ x = buf[0];
+ if (avail <= 0) {
+ ;
+ } else if (x >= 0xc0) {
+ // 0xc0...0xff: integers 0-16383
+ if (avail >= 2) {
+ v = ((x - 0xc0) << 8) + buf[1];
+ consume(2);
+ }
+ } else if (x >= 0x80) {
+ // 0x80...0xbf: integers 0-63
+ v = x - 0x80;
+ consume(1);
+ } else if (x >= 0x60) {
+ // 0x60...0x7f: strings with length 0-31
+ len = x - 0x60;
+ if (avail >= 1 + len) {
+ v = new Uint8Array(len);
+ v.set(buf.subarray(1, 1 + len));
+ v = this.bufferToDebugString(v);
+ consume(1 + len);
+ }
+ } else {
+ switch (x) {
+ case 0x00: consume(1); v = { type: 'eom' }; break;
+ case 0x01: consume(1); v = { type: 'req' }; break;
+ case 0x02: consume(1); v = { type: 'rep' }; break;
+ case 0x03: consume(1); v = { type: 'err' }; break;
+ case 0x04: consume(1); v = { type: 'nfy' }; break;
+ case 0x10: // 4-byte signed integer
+ if (avail >= 5) {
+ v = dv.getInt32(1, false);
+ consume(5);
+ }
+ break;
+ case 0x11: // 4-byte string
+ if (avail >= 5) {
+ len = dv.getUint32(1, false);
+ if (avail >= 5 + len) {
+ v = new Uint8Array(len);
+ v.set(buf.subarray(5, 5 + len));
+ v = this.bufferToDebugString(v);
+ consume(5 + len);
+ }
+ }
+ break;
+ case 0x12: // 2-byte string
+ if (avail >= 3) {
+ len = dv.getUint16(1, false);
+ if (avail >= 3 + len) {
+ v = new Uint8Array(len);
+ v.set(buf.subarray(3, 3 + len));
+ v = this.bufferToDebugString(v);
+ consume(3 + len);
+ }
+ }
+ break;
+ case 0x13: // 4-byte buffer
+ if (avail >= 5) {
+ len = dv.getUint32(1, false);
+ if (avail >= 5 + len) {
+ v = new Uint8Array(len);
+ v.set(buf.subarray(5, 5 + len));
+ v = { type: 'buffer', data: Duktape.enc('hex', Duktape.Buffer(v)) };
+ consume(5 + len);
+ }
+ }
+ break;
+ case 0x14: // 2-byte buffer
+ if (avail >= 3) {
+ len = dv.getUint16(1, false);
+ if (avail >= 3 + len) {
+ v = new Uint8Array(len);
+ v.set(buf.subarray(3, 3 + len));
+ v = { type: 'buffer', data: Duktape.enc('hex', Duktape.Buffer(v)) };
+ consume(3 + len);
+ }
+ }
+ break;
+ case 0x15: // unused/none
+ v = { type: 'unused' };
+ consume(1);
+ break;
+ case 0x16: // undefined
+ v = { type: 'undefined' };
+ gotValue = true; // indicate 'v' is actually set
+ consume(1);
+ break;
+ case 0x17: // null
+ v = null;
+ gotValue = true; // indicate 'v' is actually set
+ consume(1);
+ break;
+ case 0x18: // true
+ v = true;
+ consume(1);
+ break;
+ case 0x19: // false
+ v = false;
+ consume(1);
+ break;
+ case 0x1a: // number (IEEE double), big endian
+ if (avail >= 9) {
+ tmp = new Uint8Array(8);
+ tmp.set(buf.subarray(1, 9));
+ v = { type: 'number', data: Duktape.enc('hex', Duktape.Buffer(tmp)) };
+ if (readableNumberValue) {
+ // The value key should not be used programmatically,
+ // it is just there to make the dumps more readable.
+ v.value = new DataView(tmp.buffer).getFloat64(0, false);
+ }
+ consume(9);
+ }
+ break;
+ case 0x1b: // object
+ if (avail >= 3) {
+ len = buf[2];
+ if (avail >= 3 + len) {
+ v = new Uint8Array(len);
+ v.set(buf.subarray(3, 3 + len));
+ v = { type: 'object', 'class': buf[1], pointer: Duktape.enc('hex', Duktape.Buffer(v)) };
+ consume(3 + len);
+ }
+ }
+ break;
+ case 0x1c: // pointer
+ if (avail >= 2) {
+ len = buf[1];
+ if (avail >= 2 + len) {
+ v = new Uint8Array(len);
+ v.set(buf.subarray(2, 2 + len));
+ v = { type: 'pointer', pointer: Duktape.enc('hex', Duktape.Buffer(v)) };
+ consume(2 + len);
+ }
+ }
+ break;
+ case 0x1d: // lightfunc
+ if (avail >= 4) {
+ len = buf[3];
+ if (avail >= 4 + len) {
+ v = new Uint8Array(len);
+ v.set(buf.subarray(4, 4 + len));
+ v = { type: 'lightfunc', flags: dv.getUint16(1, false), pointer: Duktape.enc('hex', Duktape.Buffer(v)) };
+ consume(4 + len);
+ }
+ }
+ break;
+ case 0x1e: // heapptr
+ if (avail >= 2) {
+ len = buf[1];
+ if (avail >= 2 + len) {
+ v = new Uint8Array(len);
+ v.set(buf.subarray(2, 2 + len));
+ v = { type: 'heapptr', pointer: Duktape.enc('hex', Duktape.Buffer(v)) };
+ consume(2 + len);
+ }
+ }
+ break;
+ default:
+ throw new Error('failed parse initial byte: ' + buf[0]);
+ }
+ }
+
+ if (typeof v !== 'undefined' || gotValue) {
+ return { dvalue: v };
+ }
+};
+
+/*
+ * Main
+ */
+
+function main() {
+ var argv = typeof uv.argv === 'function' ? uv.argv() : [];
+ var i;
+ for (i = 2; i < argv.length; i++) { // skip dukluv and script name
+ if (argv[i] == '--help') {
+ print('Usage: dukluv ' + argv[1] + ' [option]+');
+ print('');
+ print(' --server-host HOST JSON proxy server listen address');
+ print(' --server-port PORT JSON proxy server listen port');
+ print(' --target-host HOST Debug target address');
+ print(' --target-port PORT Debug target port');
+ print(' --metadata FILE Proxy metadata file (usually named duk_debug_meta.json)');
+ print(' --log-level LEVEL Set log level, default is 2; 0=trace, 1=debug, 2=info, 3=warn, etc');
+ print(' --single Run a single proxy connection and exit (default: persist for multiple connections)');
+ print(' --readable-numbers Add a non-programmatic "value" key for IEEE doubles help readability');
+ print(' --lenient Ignore (with warning) invalid JSON without dropping connection');
+ print(' --jx-parse Parse JSON proxy input with JX, useful when testing manually');
+ print('');
+ return; // don't register any sockets/timers etc to exit
+ } else if (argv[i] == '--single') {
+ singleConnection = true;
+ continue;
+ } else if (argv[i] == '--readable-numbers') {
+ readableNumberValue = true;
+ continue;
+ } else if (argv[i] == '--lenient') {
+ lenientJsonParse = true;
+ continue;
+ } else if (argv[i] == '--jx-parse') {
+ jxParse = true;
+ continue;
+ }
+ if (i >= argv.length - 1) {
+ throw new Error('missing option value for ' + argv[i]);
+ }
+ if (argv[i] == '--server-host') {
+ serverHost = argv[i + 1];
+ i++;
+ } else if (argv[i] == '--server-port') {
+ serverPort = Math.floor(+argv[i + 1]);
+ i++;
+ } else if (argv[i] == '--target-host') {
+ targetHost = argv[i + 1];
+ i++;
+ } else if (argv[i] == '--target-port') {
+ targetPort = Math.floor(+argv[i + 1]);
+ i++;
+ } else if (argv[i] == '--metadata') {
+ metadataFile = argv[i + 1];
+ i++;
+ } else if (argv[i] == '--log-level') {
+ log.l = Math.floor(+argv[i + 1]);
+ i++;
+ } else {
+ throw new Error('invalid option ' + argv[i]);
+ }
+ }
+
+ function runServer() {
+ var serverSocket = new JsonProxyServer(serverHost, serverPort);
+ var connMode = singleConnection ? 'single connection mode' : 'persistent connection mode';
+ log.info('Listening for incoming JSON debug connection on ' + serverHost + ':' + serverPort +
+ ', target is ' + targetHost + ':' + targetPort + ', ' + connMode);
+ }
+
+ if (metadataFile) {
+ log.info('Read proxy metadata from', metadataFile);
+ readFully(metadataFile, function (data, err) {
+ if (err) {
+ log.error('Failed to load metadata:', err);
+ throw err;
+ }
+ try {
+ metadata = JSON.parse(String(data));
+ } catch (e) {
+ log.error('Failed to parse JSON metadata from ' + metadataFile + ': ' + e);
+ throw e;
+ }
+ runServer();
+ });
+ } else {
+ runServer();
+ }
+}
+
+main();
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debugcommands.yaml b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debugcommands.yaml
new file mode 100644
index 000000000..14555c189
--- /dev/null
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debugcommands.yaml
@@ -0,0 +1,52 @@
+# Debug request/notify command names provided by the debug client.
+# These are concretely notify names now.
+client_commands:
+ - Reserved_0
+ - Status
+ - Print
+ - Alert
+ - Log
+ - Throw
+ - Detaching
+ - AppNotify
+
+# Debug request/notify command names provided by the debug target (Duktape).
+target_commands:
+ - Reserved_0
+ - Reserved_1
+ - Reserved_2
+ - Reserved_3
+ - Reserved_4
+ - Reserved_5
+ - Reserved_6
+ - Reserved_7
+ - Reserved_8
+ - Reserved_9
+ - Reserved_10
+ - Reserved_11
+ - Reserved_12
+ - Reserved_13
+ - Reserved_14
+ - Reserved_15
+ - BasicInfo
+ - TriggerStatus
+ - Pause
+ - Resume
+ - StepInto
+ - StepOver
+ - StepOut
+ - ListBreak
+ - AddBreak
+ - DelBreak
+ - GetVar
+ - PutVar
+ - GetCallStack
+ - GetLocals
+ - Eval
+ - Detach
+ - DumpHeap
+ - GetBytecode
+ - AppRequest
+ - GetHeapObjInfo
+ - GetObjPropDesc
+ - GetObjPropDescRange
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debugerrors.yaml b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debugerrors.yaml
new file mode 100644
index 000000000..500265f7b
--- /dev/null
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_debugerrors.yaml
@@ -0,0 +1,6 @@
+error_codes:
+ - Unknown
+ - UnsupportedCommand
+ - TooMany
+ - NotFound
+ - ApplicationError
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/duk_opcodes.yaml b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_opcodes.yaml
similarity index 99%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/duk_opcodes.yaml
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_opcodes.yaml
index a82ac8cad..67dbefb75 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/duk_opcodes.yaml
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/duk_opcodes.yaml
@@ -243,8 +243,6 @@ opcodes:
- B_RC
flags:
- mask: 0x40
- name: fast_return
- - mask: 0x80
name: have_retval
- name: CALL
args:
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/merge_debug_meta.py b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/merge_debug_meta.py
new file mode 100644
index 000000000..ba9b38e3d
--- /dev/null
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/merge_debug_meta.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python2
+#
+# Merge debugger YAML metadata files and output a merged JSON metadata file.
+#
+
+import os, sys, json, yaml
+import optparse
+
+if __name__ == '__main__':
+ parser = optparse.OptionParser()
+ parser.add_option('--output', dest='output', default=None, help='output JSON filename')
+ parser.add_option('--class-names', dest='class_names', help='YAML metadata for class names')
+ parser.add_option('--debug-commands', dest='debug_commands', help='YAML metadata for debug commands')
+ parser.add_option('--debug-errors', dest='debug_errors', help='YAML metadata for debug protocol error codes')
+ parser.add_option('--opcodes', dest='opcodes', help='YAML metadata for opcodes')
+ (opts, args) = parser.parse_args()
+
+ res = {}
+ def merge(fn):
+ with open(fn, 'rb') as f:
+ doc = yaml.load(f)
+ for k in doc.keys():
+ res[k] = doc[k]
+
+ merge(opts.class_names)
+ merge(opts.debug_commands)
+ merge(opts.debug_errors)
+ merge(opts.opcodes)
+
+ with open(opts.output, 'wb') as f:
+ f.write(json.dumps(res, indent=4) + '\n')
+ print('Wrote merged debugger metadata to ' + str(opts.output))
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/package.json b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/package.json
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/package.json
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/package.json
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/static/index.html b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/static/index.html
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/static/index.html
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/static/index.html
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/static/style.css b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/static/style.css
similarity index 98%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/static/style.css
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/static/style.css
index ce8d34f60..a1059478f 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/static/style.css
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/static/style.css
@@ -358,9 +358,13 @@
margin: 10px 0 10px 0;
}
#bytecode-dialog pre {
- font: 14pt monospace;
+ font: 10pt monospace;
color: #000000;
}
+#bytecode-dialog div.highlight {
+ background: #888888;
+ color: #ffffff;
+}
#eval {
color: #000000;
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/static/webui.js b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/static/webui.js
similarity index 89%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/static/webui.js
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/static/webui.js
index e3e1cc111..d400c6c35 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/debugger/static/webui.js
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/debugger/static/webui.js
@@ -23,21 +23,24 @@ var sourceEditedLines = []; // line numbers which have been modified
var sourceUpdateInterval = null; // timer for updating source view
var sourceFetchXhr = null; // current AJAX request for fetching a source file (if any)
var forceButtonUpdate = false; // hack to reset button states
+var bytecodeDialogOpen = false; // bytecode dialog active
+var bytecodeIdxHighlight = null; // index of currently highlighted line (or null)
+var bytecodeIdxInstr = 0; // index to first line of bytecode instructions
// Execution state
-var prevState = null; // previous execution state ('paused', 'running', etc)
-var prevAttached = null; // previous debugger attached state (true, false, null)
-var currFileName = null; // current filename being executed
-var currFuncName = null; // current function name being executed
-var currLine = 0; // current line being executed
-var currPc = 0; // current bytecode PC being executed
-var currState = 0; // current execution state ('paused', 'running', 'detached', etc)
-var currAttached = false; // current debugger attached state (true or false)
-var currLocals = []; // current local variables
-var currCallstack = []; // current callstack (from top to bottom)
-var currBreakpoints = []; // current breakpoints
-var startedRunning = 0; // timestamp when last started running (if running)
- // (used to grey out the source file if running for long enough)
+var prevState = null; // previous execution state ('paused', 'running', etc)
+var prevAttached = null; // previous debugger attached state (true, false, null)
+var currFileName = null; // current filename being executed
+var currFuncName = null; // current function name being executed
+var currLine = 0; // current line being executed
+var currPc = 0; // current bytecode PC being executed
+var currState = 0; // current execution state ('paused', 'running', 'detached', etc)
+var currAttached = false; // current debugger attached state (true or false)
+var currLocals = []; // current local variables
+var currCallstack = []; // current callstack (from top to bottom)
+var currBreakpoints = []; // current breakpoints
+var startedRunning = 0; // timestamp when last started running (if running)
+ // (used to grey out the source file if running for long enough)
/*
* Helpers
@@ -99,6 +102,15 @@ function doSourceUpdate() {
}
}
+ // Bytecode dialog highlight
+ if (loadedFileExecuting && bytecodeDialogOpen && bytecodeIdxHighlight !== bytecodeIdxInstr + currPc) {
+ if (typeof bytecodeIdxHighlight === 'number') {
+ $('#bytecode-preformatted div')[bytecodeIdxHighlight].classList.remove('highlight');
+ }
+ bytecodeIdxHighlight = bytecodeIdxInstr + currPc;
+ $('#bytecode-preformatted div')[bytecodeIdxHighlight].classList.add('highlight');
+ }
+
// If no-one requested us to scroll to a specific line, finish.
if (loadedLinePending == null) {
return;
@@ -280,6 +292,11 @@ socket.on('basic-info', function (msg) {
});
socket.on('exec-status', function (msg) {
+ // Not 100% reliable if callstack has several functions of the same name
+ if (bytecodeDialogOpen && (currFileName != msg.fileName || currFuncName != msg.funcName)) {
+ socket.emit('get-bytecode', {});
+ }
+
currFileName = msg.fileName;
currFuncName = msg.funcName;
currLine = msg.line;
@@ -455,8 +472,20 @@ socket.on('getvar-result', function (msg) {
});
socket.on('bytecode', function (msg) {
- $('#bytecode-preformatted').text(msg.preformatted);
- $('#bytecode-dialog').dialog('open');
+ var elem, div;
+ var div;
+
+ elem = $('#bytecode-preformatted');
+ elem.empty();
+
+ msg.preformatted.split('\n').forEach(function (line, idx) {
+ div = $('');
+ div.text(line);
+ elem.append(div);
+ });
+
+ bytecodeIdxHighlight = null;
+ bytecodeIdxInstr = msg.idxPreformattedInstructions;
});
$('#stepinto-button').click(function () {
@@ -495,6 +524,12 @@ $('#about-button').click(function () {
});
$('#show-bytecode-button').click(function () {
+ bytecodeDialogOpen = true;
+ $('#bytecode-dialog').dialog('open');
+
+ elem = $('#bytecode-preformatted');
+ elem.empty().text('Loading bytecode...');
+
socket.emit('get-bytecode', {});
});
@@ -702,8 +737,13 @@ $(document).ready(function () {
autoOpen: false,
hide: 'fade', // puff
show: 'fade', // slide, puff
- width: 1000,
- height: 800
+ width: 700,
+ height: 600,
+ close: function () {
+ bytecodeDialogOpen = false;
+ bytecodeIdxHighlight = null;
+ bytecodeIdxInstr = 0;
+ }
});
// http://diveintohtml5.info/storage.html
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.5.2/duk_build_meta.json b/ceph/src/civetweb/src/third_party/duktape-1.5.2/duk_build_meta.json
new file mode 100644
index 000000000..c2e80bb2f
--- /dev/null
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/duk_build_meta.json
@@ -0,0 +1,1349 @@
+{
+ "builtin_strings": [
+ "Undefined",
+ "Null",
+ "Arguments",
+ "Object",
+ "Function",
+ "Array",
+ "String",
+ "Boolean",
+ "Number",
+ "Date",
+ "RegExp",
+ "Error",
+ "Math",
+ "JSON",
+ "",
+ "ArrayBuffer",
+ "DataView",
+ "Int8Array",
+ "Uint8Array",
+ "Uint8ClampedArray",
+ "Int16Array",
+ "Uint16Array",
+ "Int32Array",
+ "Uint32Array",
+ "Float32Array",
+ "Float64Array",
+ "global",
+ "ObjEnv",
+ "DecEnv",
+ "Buffer",
+ "Pointer",
+ "Thread",
+ "eval",
+ "defineProperty",
+ "value",
+ "writable",
+ "configurable",
+ "enumerable",
+ "join",
+ "toLocaleString",
+ "valueOf",
+ "toUTCString",
+ "toISOString",
+ "toGMTString",
+ "source",
+ "ignoreCase",
+ "multiline",
+ "lastIndex",
+ "(?:)",
+ "index",
+ "prototype",
+ "constructor",
+ "message",
+ "boolean",
+ "number",
+ "string",
+ "object",
+ "undefined",
+ "NaN",
+ "Infinity",
+ "-Infinity",
+ "-0",
+ ",",
+ " ",
+ "\n ",
+ "[...]",
+ "Invalid Date",
+ "arguments",
+ "callee",
+ "caller",
+ "has",
+ "get",
+ "deleteProperty",
+ "enumerate",
+ "ownKeys",
+ "setPrototypeOf",
+ "__proto__",
+ "require",
+ "id",
+ "exports",
+ "filename",
+ "toString",
+ "toJSON",
+ "type",
+ "data",
+ "length",
+ "byteLength",
+ "byteOffset",
+ "BYTES_PER_ELEMENT",
+ "set",
+ "stack",
+ "pc",
+ "lineNumber",
+ "\u00ffTracedata",
+ "name",
+ "fileName",
+ "buffer",
+ "pointer",
+ "\u00ffValue",
+ "\u00ffNext",
+ "\u00ffBytecode",
+ "\u00ffFormals",
+ "\u00ffVarmap",
+ "\u00ffLexenv",
+ "\u00ffVarenv",
+ "\u00ffSource",
+ "\u00ffPc2line",
+ "\u00ffArgs",
+ "\u00ffMap",
+ "\u00ffFinalizer",
+ "\u00ffHandler",
+ "\u00ffCallee",
+ "\u00ffThread",
+ "\u00ffRegbase",
+ "\u00ffTarget",
+ "\u00ffThis",
+ "compile",
+ "input",
+ "errCreate",
+ "errThrow",
+ "modSearch",
+ "modLoaded",
+ "env",
+ "hex",
+ "base64",
+ "jx",
+ "jc",
+ "resume",
+ "fmt",
+ "raw",
+ "trace",
+ "debug",
+ "info",
+ "warn",
+ "error",
+ "fatal",
+ "n",
+ "l",
+ "clog",
+ "toLogString",
+ "{\"_undef\":true}",
+ "{\"_nan\":true}",
+ "{\"_inf\":true}",
+ "{\"_ninf\":true}",
+ "{\"_func\":true}",
+ "{_func:true}",
+ "break",
+ "case",
+ "catch",
+ "continue",
+ "debugger",
+ "default",
+ "delete",
+ "do",
+ "else",
+ "finally",
+ "for",
+ "function",
+ "if",
+ "in",
+ "instanceof",
+ "new",
+ "return",
+ "switch",
+ "this",
+ "throw",
+ "try",
+ "typeof",
+ "var",
+ "const",
+ "void",
+ "while",
+ "with",
+ "class",
+ "enum",
+ "export",
+ "extends",
+ "import",
+ "super",
+ "null",
+ "true",
+ "false",
+ "implements",
+ "interface",
+ "let",
+ "package",
+ "private",
+ "protected",
+ "public",
+ "static",
+ "yield"
+ ],
+ "builtin_strings_base64": [
+ "VW5kZWZpbmVk",
+ "TnVsbA==",
+ "QXJndW1lbnRz",
+ "T2JqZWN0",
+ "RnVuY3Rpb24=",
+ "QXJyYXk=",
+ "U3RyaW5n",
+ "Qm9vbGVhbg==",
+ "TnVtYmVy",
+ "RGF0ZQ==",
+ "UmVnRXhw",
+ "RXJyb3I=",
+ "TWF0aA==",
+ "SlNPTg==",
+ "",
+ "QXJyYXlCdWZmZXI=",
+ "RGF0YVZpZXc=",
+ "SW50OEFycmF5",
+ "VWludDhBcnJheQ==",
+ "VWludDhDbGFtcGVkQXJyYXk=",
+ "SW50MTZBcnJheQ==",
+ "VWludDE2QXJyYXk=",
+ "SW50MzJBcnJheQ==",
+ "VWludDMyQXJyYXk=",
+ "RmxvYXQzMkFycmF5",
+ "RmxvYXQ2NEFycmF5",
+ "Z2xvYmFs",
+ "T2JqRW52",
+ "RGVjRW52",
+ "QnVmZmVy",
+ "UG9pbnRlcg==",
+ "VGhyZWFk",
+ "ZXZhbA==",
+ "ZGVmaW5lUHJvcGVydHk=",
+ "dmFsdWU=",
+ "d3JpdGFibGU=",
+ "Y29uZmlndXJhYmxl",
+ "ZW51bWVyYWJsZQ==",
+ "am9pbg==",
+ "dG9Mb2NhbGVTdHJpbmc=",
+ "dmFsdWVPZg==",
+ "dG9VVENTdHJpbmc=",
+ "dG9JU09TdHJpbmc=",
+ "dG9HTVRTdHJpbmc=",
+ "c291cmNl",
+ "aWdub3JlQ2FzZQ==",
+ "bXVsdGlsaW5l",
+ "bGFzdEluZGV4",
+ "KD86KQ==",
+ "aW5kZXg=",
+ "cHJvdG90eXBl",
+ "Y29uc3RydWN0b3I=",
+ "bWVzc2FnZQ==",
+ "Ym9vbGVhbg==",
+ "bnVtYmVy",
+ "c3RyaW5n",
+ "b2JqZWN0",
+ "dW5kZWZpbmVk",
+ "TmFO",
+ "SW5maW5pdHk=",
+ "LUluZmluaXR5",
+ "LTA=",
+ "LA==",
+ "IA==",
+ "CiAgICA=",
+ "Wy4uLl0=",
+ "SW52YWxpZCBEYXRl",
+ "YXJndW1lbnRz",
+ "Y2FsbGVl",
+ "Y2FsbGVy",
+ "aGFz",
+ "Z2V0",
+ "ZGVsZXRlUHJvcGVydHk=",
+ "ZW51bWVyYXRl",
+ "b3duS2V5cw==",
+ "c2V0UHJvdG90eXBlT2Y=",
+ "X19wcm90b19f",
+ "cmVxdWlyZQ==",
+ "aWQ=",
+ "ZXhwb3J0cw==",
+ "ZmlsZW5hbWU=",
+ "dG9TdHJpbmc=",
+ "dG9KU09O",
+ "dHlwZQ==",
+ "ZGF0YQ==",
+ "bGVuZ3Ro",
+ "Ynl0ZUxlbmd0aA==",
+ "Ynl0ZU9mZnNldA==",
+ "QllURVNfUEVSX0VMRU1FTlQ=",
+ "c2V0",
+ "c3RhY2s=",
+ "cGM=",
+ "bGluZU51bWJlcg==",
+ "/1RyYWNlZGF0YQ==",
+ "bmFtZQ==",
+ "ZmlsZU5hbWU=",
+ "YnVmZmVy",
+ "cG9pbnRlcg==",
+ "/1ZhbHVl",
+ "/05leHQ=",
+ "/0J5dGVjb2Rl",
+ "/0Zvcm1hbHM=",
+ "/1Zhcm1hcA==",
+ "/0xleGVudg==",
+ "/1ZhcmVudg==",
+ "/1NvdXJjZQ==",
+ "/1BjMmxpbmU=",
+ "/0FyZ3M=",
+ "/01hcA==",
+ "/0ZpbmFsaXplcg==",
+ "/0hhbmRsZXI=",
+ "/0NhbGxlZQ==",
+ "/1RocmVhZA==",
+ "/1JlZ2Jhc2U=",
+ "/1RhcmdldA==",
+ "/1RoaXM=",
+ "Y29tcGlsZQ==",
+ "aW5wdXQ=",
+ "ZXJyQ3JlYXRl",
+ "ZXJyVGhyb3c=",
+ "bW9kU2VhcmNo",
+ "bW9kTG9hZGVk",
+ "ZW52",
+ "aGV4",
+ "YmFzZTY0",
+ "ang=",
+ "amM=",
+ "cmVzdW1l",
+ "Zm10",
+ "cmF3",
+ "dHJhY2U=",
+ "ZGVidWc=",
+ "aW5mbw==",
+ "d2Fybg==",
+ "ZXJyb3I=",
+ "ZmF0YWw=",
+ "bg==",
+ "bA==",
+ "Y2xvZw==",
+ "dG9Mb2dTdHJpbmc=",
+ "eyJfdW5kZWYiOnRydWV9",
+ "eyJfbmFuIjp0cnVlfQ==",
+ "eyJfaW5mIjp0cnVlfQ==",
+ "eyJfbmluZiI6dHJ1ZX0=",
+ "eyJfZnVuYyI6dHJ1ZX0=",
+ "e19mdW5jOnRydWV9",
+ "YnJlYWs=",
+ "Y2FzZQ==",
+ "Y2F0Y2g=",
+ "Y29udGludWU=",
+ "ZGVidWdnZXI=",
+ "ZGVmYXVsdA==",
+ "ZGVsZXRl",
+ "ZG8=",
+ "ZWxzZQ==",
+ "ZmluYWxseQ==",
+ "Zm9y",
+ "ZnVuY3Rpb24=",
+ "aWY=",
+ "aW4=",
+ "aW5zdGFuY2VvZg==",
+ "bmV3",
+ "cmV0dXJu",
+ "c3dpdGNo",
+ "dGhpcw==",
+ "dGhyb3c=",
+ "dHJ5",
+ "dHlwZW9m",
+ "dmFy",
+ "Y29uc3Q=",
+ "dm9pZA==",
+ "d2hpbGU=",
+ "d2l0aA==",
+ "Y2xhc3M=",
+ "ZW51bQ==",
+ "ZXhwb3J0",
+ "ZXh0ZW5kcw==",
+ "aW1wb3J0",
+ "c3VwZXI=",
+ "bnVsbA==",
+ "dHJ1ZQ==",
+ "ZmFsc2U=",
+ "aW1wbGVtZW50cw==",
+ "aW50ZXJmYWNl",
+ "bGV0",
+ "cGFja2FnZQ==",
+ "cHJpdmF0ZQ==",
+ "cHJvdGVjdGVk",
+ "cHVibGlj",
+ "c3RhdGlj",
+ "eWllbGQ="
+ ],
+ "builtin_strings_info": [
+ {
+ "base64": "VW5kZWZpbmVk",
+ "define": "DUK_STRIDX_UC_UNDEFINED",
+ "plain": "Undefined"
+ },
+ {
+ "base64": "TnVsbA==",
+ "define": "DUK_STRIDX_UC_NULL",
+ "plain": "Null"
+ },
+ {
+ "base64": "QXJndW1lbnRz",
+ "define": "DUK_STRIDX_UC_ARGUMENTS",
+ "plain": "Arguments"
+ },
+ {
+ "base64": "T2JqZWN0",
+ "define": "DUK_STRIDX_UC_OBJECT",
+ "plain": "Object"
+ },
+ {
+ "base64": "RnVuY3Rpb24=",
+ "define": "DUK_STRIDX_UC_FUNCTION",
+ "plain": "Function"
+ },
+ {
+ "base64": "QXJyYXk=",
+ "define": "DUK_STRIDX_ARRAY",
+ "plain": "Array"
+ },
+ {
+ "base64": "U3RyaW5n",
+ "define": "DUK_STRIDX_UC_STRING",
+ "plain": "String"
+ },
+ {
+ "base64": "Qm9vbGVhbg==",
+ "define": "DUK_STRIDX_UC_BOOLEAN",
+ "plain": "Boolean"
+ },
+ {
+ "base64": "TnVtYmVy",
+ "define": "DUK_STRIDX_UC_NUMBER",
+ "plain": "Number"
+ },
+ {
+ "base64": "RGF0ZQ==",
+ "define": "DUK_STRIDX_DATE",
+ "plain": "Date"
+ },
+ {
+ "base64": "UmVnRXhw",
+ "define": "DUK_STRIDX_REG_EXP",
+ "plain": "RegExp"
+ },
+ {
+ "base64": "RXJyb3I=",
+ "define": "DUK_STRIDX_UC_ERROR",
+ "plain": "Error"
+ },
+ {
+ "base64": "TWF0aA==",
+ "define": "DUK_STRIDX_MATH",
+ "plain": "Math"
+ },
+ {
+ "base64": "SlNPTg==",
+ "define": "DUK_STRIDX_JSON",
+ "plain": "JSON"
+ },
+ {
+ "base64": "",
+ "define": "DUK_STRIDX_EMPTY_STRING",
+ "plain": ""
+ },
+ {
+ "base64": "QXJyYXlCdWZmZXI=",
+ "define": "DUK_STRIDX_ARRAY_BUFFER",
+ "plain": "ArrayBuffer"
+ },
+ {
+ "base64": "RGF0YVZpZXc=",
+ "define": "DUK_STRIDX_DATA_VIEW",
+ "plain": "DataView"
+ },
+ {
+ "base64": "SW50OEFycmF5",
+ "define": "DUK_STRIDX_INT8_ARRAY",
+ "plain": "Int8Array"
+ },
+ {
+ "base64": "VWludDhBcnJheQ==",
+ "define": "DUK_STRIDX_UINT8_ARRAY",
+ "plain": "Uint8Array"
+ },
+ {
+ "base64": "VWludDhDbGFtcGVkQXJyYXk=",
+ "define": "DUK_STRIDX_UINT8_CLAMPED_ARRAY",
+ "plain": "Uint8ClampedArray"
+ },
+ {
+ "base64": "SW50MTZBcnJheQ==",
+ "define": "DUK_STRIDX_INT16_ARRAY",
+ "plain": "Int16Array"
+ },
+ {
+ "base64": "VWludDE2QXJyYXk=",
+ "define": "DUK_STRIDX_UINT16_ARRAY",
+ "plain": "Uint16Array"
+ },
+ {
+ "base64": "SW50MzJBcnJheQ==",
+ "define": "DUK_STRIDX_INT32_ARRAY",
+ "plain": "Int32Array"
+ },
+ {
+ "base64": "VWludDMyQXJyYXk=",
+ "define": "DUK_STRIDX_UINT32_ARRAY",
+ "plain": "Uint32Array"
+ },
+ {
+ "base64": "RmxvYXQzMkFycmF5",
+ "define": "DUK_STRIDX_FLOAT32_ARRAY",
+ "plain": "Float32Array"
+ },
+ {
+ "base64": "RmxvYXQ2NEFycmF5",
+ "define": "DUK_STRIDX_FLOAT64_ARRAY",
+ "plain": "Float64Array"
+ },
+ {
+ "base64": "Z2xvYmFs",
+ "define": "DUK_STRIDX_GLOBAL",
+ "plain": "global"
+ },
+ {
+ "base64": "T2JqRW52",
+ "define": "DUK_STRIDX_OBJ_ENV",
+ "plain": "ObjEnv"
+ },
+ {
+ "base64": "RGVjRW52",
+ "define": "DUK_STRIDX_DEC_ENV",
+ "plain": "DecEnv"
+ },
+ {
+ "base64": "QnVmZmVy",
+ "define": "DUK_STRIDX_UC_BUFFER",
+ "plain": "Buffer"
+ },
+ {
+ "base64": "UG9pbnRlcg==",
+ "define": "DUK_STRIDX_UC_POINTER",
+ "plain": "Pointer"
+ },
+ {
+ "base64": "VGhyZWFk",
+ "define": "DUK_STRIDX_UC_THREAD",
+ "plain": "Thread"
+ },
+ {
+ "base64": "ZXZhbA==",
+ "define": "DUK_STRIDX_EVAL",
+ "plain": "eval"
+ },
+ {
+ "base64": "ZGVmaW5lUHJvcGVydHk=",
+ "define": "DUK_STRIDX_DEFINE_PROPERTY",
+ "plain": "defineProperty"
+ },
+ {
+ "base64": "dmFsdWU=",
+ "define": "DUK_STRIDX_VALUE",
+ "plain": "value"
+ },
+ {
+ "base64": "d3JpdGFibGU=",
+ "define": "DUK_STRIDX_WRITABLE",
+ "plain": "writable"
+ },
+ {
+ "base64": "Y29uZmlndXJhYmxl",
+ "define": "DUK_STRIDX_CONFIGURABLE",
+ "plain": "configurable"
+ },
+ {
+ "base64": "ZW51bWVyYWJsZQ==",
+ "define": "DUK_STRIDX_ENUMERABLE",
+ "plain": "enumerable"
+ },
+ {
+ "base64": "am9pbg==",
+ "define": "DUK_STRIDX_JOIN",
+ "plain": "join"
+ },
+ {
+ "base64": "dG9Mb2NhbGVTdHJpbmc=",
+ "define": "DUK_STRIDX_TO_LOCALE_STRING",
+ "plain": "toLocaleString"
+ },
+ {
+ "base64": "dmFsdWVPZg==",
+ "define": "DUK_STRIDX_VALUE_OF",
+ "plain": "valueOf"
+ },
+ {
+ "base64": "dG9VVENTdHJpbmc=",
+ "define": "DUK_STRIDX_TO_UTC_STRING",
+ "plain": "toUTCString"
+ },
+ {
+ "base64": "dG9JU09TdHJpbmc=",
+ "define": "DUK_STRIDX_TO_ISO_STRING",
+ "plain": "toISOString"
+ },
+ {
+ "base64": "dG9HTVRTdHJpbmc=",
+ "define": "DUK_STRIDX_TO_GMT_STRING",
+ "plain": "toGMTString"
+ },
+ {
+ "base64": "c291cmNl",
+ "define": "DUK_STRIDX_SOURCE",
+ "plain": "source"
+ },
+ {
+ "base64": "aWdub3JlQ2FzZQ==",
+ "define": "DUK_STRIDX_IGNORE_CASE",
+ "plain": "ignoreCase"
+ },
+ {
+ "base64": "bXVsdGlsaW5l",
+ "define": "DUK_STRIDX_MULTILINE",
+ "plain": "multiline"
+ },
+ {
+ "base64": "bGFzdEluZGV4",
+ "define": "DUK_STRIDX_LAST_INDEX",
+ "plain": "lastIndex"
+ },
+ {
+ "base64": "KD86KQ==",
+ "define": "DUK_STRIDX_ESCAPED_EMPTY_REGEXP",
+ "plain": "(?:)"
+ },
+ {
+ "base64": "aW5kZXg=",
+ "define": "DUK_STRIDX_INDEX",
+ "plain": "index"
+ },
+ {
+ "base64": "cHJvdG90eXBl",
+ "define": "DUK_STRIDX_PROTOTYPE",
+ "plain": "prototype"
+ },
+ {
+ "base64": "Y29uc3RydWN0b3I=",
+ "define": "DUK_STRIDX_CONSTRUCTOR",
+ "plain": "constructor"
+ },
+ {
+ "base64": "bWVzc2FnZQ==",
+ "define": "DUK_STRIDX_MESSAGE",
+ "plain": "message"
+ },
+ {
+ "base64": "Ym9vbGVhbg==",
+ "define": "DUK_STRIDX_LC_BOOLEAN",
+ "plain": "boolean"
+ },
+ {
+ "base64": "bnVtYmVy",
+ "define": "DUK_STRIDX_LC_NUMBER",
+ "plain": "number"
+ },
+ {
+ "base64": "c3RyaW5n",
+ "define": "DUK_STRIDX_LC_STRING",
+ "plain": "string"
+ },
+ {
+ "base64": "b2JqZWN0",
+ "define": "DUK_STRIDX_LC_OBJECT",
+ "plain": "object"
+ },
+ {
+ "base64": "dW5kZWZpbmVk",
+ "define": "DUK_STRIDX_LC_UNDEFINED",
+ "plain": "undefined"
+ },
+ {
+ "base64": "TmFO",
+ "define": "DUK_STRIDX_NAN",
+ "plain": "NaN"
+ },
+ {
+ "base64": "SW5maW5pdHk=",
+ "define": "DUK_STRIDX_INFINITY",
+ "plain": "Infinity"
+ },
+ {
+ "base64": "LUluZmluaXR5",
+ "define": "DUK_STRIDX_MINUS_INFINITY",
+ "plain": "-Infinity"
+ },
+ {
+ "base64": "LTA=",
+ "define": "DUK_STRIDX_MINUS_ZERO",
+ "plain": "-0"
+ },
+ {
+ "base64": "LA==",
+ "define": "DUK_STRIDX_COMMA",
+ "plain": ","
+ },
+ {
+ "base64": "IA==",
+ "define": "DUK_STRIDX_SPACE",
+ "plain": " "
+ },
+ {
+ "base64": "CiAgICA=",
+ "define": "DUK_STRIDX_NEWLINE_4SPACE",
+ "plain": "\n "
+ },
+ {
+ "base64": "Wy4uLl0=",
+ "define": "DUK_STRIDX_BRACKETED_ELLIPSIS",
+ "plain": "[...]"
+ },
+ {
+ "base64": "SW52YWxpZCBEYXRl",
+ "define": "DUK_STRIDX_INVALID_DATE",
+ "plain": "Invalid Date"
+ },
+ {
+ "base64": "YXJndW1lbnRz",
+ "define": "DUK_STRIDX_LC_ARGUMENTS",
+ "plain": "arguments"
+ },
+ {
+ "base64": "Y2FsbGVl",
+ "define": "DUK_STRIDX_CALLEE",
+ "plain": "callee"
+ },
+ {
+ "base64": "Y2FsbGVy",
+ "define": "DUK_STRIDX_CALLER",
+ "plain": "caller"
+ },
+ {
+ "base64": "aGFz",
+ "define": "DUK_STRIDX_HAS",
+ "plain": "has"
+ },
+ {
+ "base64": "Z2V0",
+ "define": "DUK_STRIDX_GET",
+ "plain": "get"
+ },
+ {
+ "base64": "ZGVsZXRlUHJvcGVydHk=",
+ "define": "DUK_STRIDX_DELETE_PROPERTY",
+ "plain": "deleteProperty"
+ },
+ {
+ "base64": "ZW51bWVyYXRl",
+ "define": "DUK_STRIDX_ENUMERATE",
+ "plain": "enumerate"
+ },
+ {
+ "base64": "b3duS2V5cw==",
+ "define": "DUK_STRIDX_OWN_KEYS",
+ "plain": "ownKeys"
+ },
+ {
+ "base64": "c2V0UHJvdG90eXBlT2Y=",
+ "define": "DUK_STRIDX_SET_PROTOTYPE_OF",
+ "plain": "setPrototypeOf"
+ },
+ {
+ "base64": "X19wcm90b19f",
+ "define": "DUK_STRIDX___PROTO__",
+ "plain": "__proto__"
+ },
+ {
+ "base64": "cmVxdWlyZQ==",
+ "define": "DUK_STRIDX_REQUIRE",
+ "plain": "require"
+ },
+ {
+ "base64": "aWQ=",
+ "define": "DUK_STRIDX_ID",
+ "plain": "id"
+ },
+ {
+ "base64": "ZXhwb3J0cw==",
+ "define": "DUK_STRIDX_EXPORTS",
+ "plain": "exports"
+ },
+ {
+ "base64": "ZmlsZW5hbWU=",
+ "define": "DUK_STRIDX_FILENAME",
+ "plain": "filename"
+ },
+ {
+ "base64": "dG9TdHJpbmc=",
+ "define": "DUK_STRIDX_TO_STRING",
+ "plain": "toString"
+ },
+ {
+ "base64": "dG9KU09O",
+ "define": "DUK_STRIDX_TO_JSON",
+ "plain": "toJSON"
+ },
+ {
+ "base64": "dHlwZQ==",
+ "define": "DUK_STRIDX_TYPE",
+ "plain": "type"
+ },
+ {
+ "base64": "ZGF0YQ==",
+ "define": "DUK_STRIDX_DATA",
+ "plain": "data"
+ },
+ {
+ "base64": "bGVuZ3Ro",
+ "define": "DUK_STRIDX_LENGTH",
+ "plain": "length"
+ },
+ {
+ "base64": "Ynl0ZUxlbmd0aA==",
+ "define": "DUK_STRIDX_BYTE_LENGTH",
+ "plain": "byteLength"
+ },
+ {
+ "base64": "Ynl0ZU9mZnNldA==",
+ "define": "DUK_STRIDX_BYTE_OFFSET",
+ "plain": "byteOffset"
+ },
+ {
+ "base64": "QllURVNfUEVSX0VMRU1FTlQ=",
+ "define": "DUK_STRIDX_BYTES_PER_ELEMENT",
+ "plain": "BYTES_PER_ELEMENT"
+ },
+ {
+ "base64": "c2V0",
+ "define": "DUK_STRIDX_SET",
+ "plain": "set"
+ },
+ {
+ "base64": "c3RhY2s=",
+ "define": "DUK_STRIDX_STACK",
+ "plain": "stack"
+ },
+ {
+ "base64": "cGM=",
+ "define": "DUK_STRIDX_PC",
+ "plain": "pc"
+ },
+ {
+ "base64": "bGluZU51bWJlcg==",
+ "define": "DUK_STRIDX_LINE_NUMBER",
+ "plain": "lineNumber"
+ },
+ {
+ "base64": "/1RyYWNlZGF0YQ==",
+ "define": "DUK_STRIDX_INT_TRACEDATA",
+ "plain": "\u00ffTracedata"
+ },
+ {
+ "base64": "bmFtZQ==",
+ "define": "DUK_STRIDX_NAME",
+ "plain": "name"
+ },
+ {
+ "base64": "ZmlsZU5hbWU=",
+ "define": "DUK_STRIDX_FILE_NAME",
+ "plain": "fileName"
+ },
+ {
+ "base64": "YnVmZmVy",
+ "define": "DUK_STRIDX_LC_BUFFER",
+ "plain": "buffer"
+ },
+ {
+ "base64": "cG9pbnRlcg==",
+ "define": "DUK_STRIDX_LC_POINTER",
+ "plain": "pointer"
+ },
+ {
+ "base64": "/1ZhbHVl",
+ "define": "DUK_STRIDX_INT_VALUE",
+ "plain": "\u00ffValue"
+ },
+ {
+ "base64": "/05leHQ=",
+ "define": "DUK_STRIDX_INT_NEXT",
+ "plain": "\u00ffNext"
+ },
+ {
+ "base64": "/0J5dGVjb2Rl",
+ "define": "DUK_STRIDX_INT_BYTECODE",
+ "plain": "\u00ffBytecode"
+ },
+ {
+ "base64": "/0Zvcm1hbHM=",
+ "define": "DUK_STRIDX_INT_FORMALS",
+ "plain": "\u00ffFormals"
+ },
+ {
+ "base64": "/1Zhcm1hcA==",
+ "define": "DUK_STRIDX_INT_VARMAP",
+ "plain": "\u00ffVarmap"
+ },
+ {
+ "base64": "/0xleGVudg==",
+ "define": "DUK_STRIDX_INT_LEXENV",
+ "plain": "\u00ffLexenv"
+ },
+ {
+ "base64": "/1ZhcmVudg==",
+ "define": "DUK_STRIDX_INT_VARENV",
+ "plain": "\u00ffVarenv"
+ },
+ {
+ "base64": "/1NvdXJjZQ==",
+ "define": "DUK_STRIDX_INT_SOURCE",
+ "plain": "\u00ffSource"
+ },
+ {
+ "base64": "/1BjMmxpbmU=",
+ "define": "DUK_STRIDX_INT_PC2LINE",
+ "plain": "\u00ffPc2line"
+ },
+ {
+ "base64": "/0FyZ3M=",
+ "define": "DUK_STRIDX_INT_ARGS",
+ "plain": "\u00ffArgs"
+ },
+ {
+ "base64": "/01hcA==",
+ "define": "DUK_STRIDX_INT_MAP",
+ "plain": "\u00ffMap"
+ },
+ {
+ "base64": "/0ZpbmFsaXplcg==",
+ "define": "DUK_STRIDX_INT_FINALIZER",
+ "plain": "\u00ffFinalizer"
+ },
+ {
+ "base64": "/0hhbmRsZXI=",
+ "define": "DUK_STRIDX_INT_HANDLER",
+ "plain": "\u00ffHandler"
+ },
+ {
+ "base64": "/0NhbGxlZQ==",
+ "define": "DUK_STRIDX_INT_CALLEE",
+ "plain": "\u00ffCallee"
+ },
+ {
+ "base64": "/1RocmVhZA==",
+ "define": "DUK_STRIDX_INT_THREAD",
+ "plain": "\u00ffThread"
+ },
+ {
+ "base64": "/1JlZ2Jhc2U=",
+ "define": "DUK_STRIDX_INT_REGBASE",
+ "plain": "\u00ffRegbase"
+ },
+ {
+ "base64": "/1RhcmdldA==",
+ "define": "DUK_STRIDX_INT_TARGET",
+ "plain": "\u00ffTarget"
+ },
+ {
+ "base64": "/1RoaXM=",
+ "define": "DUK_STRIDX_INT_THIS",
+ "plain": "\u00ffThis"
+ },
+ {
+ "base64": "Y29tcGlsZQ==",
+ "define": "DUK_STRIDX_COMPILE",
+ "plain": "compile"
+ },
+ {
+ "base64": "aW5wdXQ=",
+ "define": "DUK_STRIDX_INPUT",
+ "plain": "input"
+ },
+ {
+ "base64": "ZXJyQ3JlYXRl",
+ "define": "DUK_STRIDX_ERR_CREATE",
+ "plain": "errCreate"
+ },
+ {
+ "base64": "ZXJyVGhyb3c=",
+ "define": "DUK_STRIDX_ERR_THROW",
+ "plain": "errThrow"
+ },
+ {
+ "base64": "bW9kU2VhcmNo",
+ "define": "DUK_STRIDX_MOD_SEARCH",
+ "plain": "modSearch"
+ },
+ {
+ "base64": "bW9kTG9hZGVk",
+ "define": "DUK_STRIDX_MOD_LOADED",
+ "plain": "modLoaded"
+ },
+ {
+ "base64": "ZW52",
+ "define": "DUK_STRIDX_ENV",
+ "plain": "env"
+ },
+ {
+ "base64": "aGV4",
+ "define": "DUK_STRIDX_HEX",
+ "plain": "hex"
+ },
+ {
+ "base64": "YmFzZTY0",
+ "define": "DUK_STRIDX_BASE64",
+ "plain": "base64"
+ },
+ {
+ "base64": "ang=",
+ "define": "DUK_STRIDX_JX",
+ "plain": "jx"
+ },
+ {
+ "base64": "amM=",
+ "define": "DUK_STRIDX_JC",
+ "plain": "jc"
+ },
+ {
+ "base64": "cmVzdW1l",
+ "define": "DUK_STRIDX_RESUME",
+ "plain": "resume"
+ },
+ {
+ "base64": "Zm10",
+ "define": "DUK_STRIDX_FMT",
+ "plain": "fmt"
+ },
+ {
+ "base64": "cmF3",
+ "define": "DUK_STRIDX_RAW",
+ "plain": "raw"
+ },
+ {
+ "base64": "dHJhY2U=",
+ "define": "DUK_STRIDX_LC_TRACE",
+ "plain": "trace"
+ },
+ {
+ "base64": "ZGVidWc=",
+ "define": "DUK_STRIDX_LC_DEBUG",
+ "plain": "debug"
+ },
+ {
+ "base64": "aW5mbw==",
+ "define": "DUK_STRIDX_LC_INFO",
+ "plain": "info"
+ },
+ {
+ "base64": "d2Fybg==",
+ "define": "DUK_STRIDX_LC_WARN",
+ "plain": "warn"
+ },
+ {
+ "base64": "ZXJyb3I=",
+ "define": "DUK_STRIDX_LC_ERROR",
+ "plain": "error"
+ },
+ {
+ "base64": "ZmF0YWw=",
+ "define": "DUK_STRIDX_LC_FATAL",
+ "plain": "fatal"
+ },
+ {
+ "base64": "bg==",
+ "define": "DUK_STRIDX_LC_N",
+ "plain": "n"
+ },
+ {
+ "base64": "bA==",
+ "define": "DUK_STRIDX_LC_L",
+ "plain": "l"
+ },
+ {
+ "base64": "Y2xvZw==",
+ "define": "DUK_STRIDX_CLOG",
+ "plain": "clog"
+ },
+ {
+ "base64": "dG9Mb2dTdHJpbmc=",
+ "define": "DUK_STRIDX_TO_LOG_STRING",
+ "plain": "toLogString"
+ },
+ {
+ "base64": "eyJfdW5kZWYiOnRydWV9",
+ "define": "DUK_STRIDX_JSON_EXT_UNDEFINED",
+ "plain": "{\"_undef\":true}"
+ },
+ {
+ "base64": "eyJfbmFuIjp0cnVlfQ==",
+ "define": "DUK_STRIDX_JSON_EXT_NAN",
+ "plain": "{\"_nan\":true}"
+ },
+ {
+ "base64": "eyJfaW5mIjp0cnVlfQ==",
+ "define": "DUK_STRIDX_JSON_EXT_POSINF",
+ "plain": "{\"_inf\":true}"
+ },
+ {
+ "base64": "eyJfbmluZiI6dHJ1ZX0=",
+ "define": "DUK_STRIDX_JSON_EXT_NEGINF",
+ "plain": "{\"_ninf\":true}"
+ },
+ {
+ "base64": "eyJfZnVuYyI6dHJ1ZX0=",
+ "define": "DUK_STRIDX_JSON_EXT_FUNCTION1",
+ "plain": "{\"_func\":true}"
+ },
+ {
+ "base64": "e19mdW5jOnRydWV9",
+ "define": "DUK_STRIDX_JSON_EXT_FUNCTION2",
+ "plain": "{_func:true}"
+ },
+ {
+ "base64": "YnJlYWs=",
+ "define": "DUK_STRIDX_BREAK",
+ "plain": "break"
+ },
+ {
+ "base64": "Y2FzZQ==",
+ "define": "DUK_STRIDX_CASE",
+ "plain": "case"
+ },
+ {
+ "base64": "Y2F0Y2g=",
+ "define": "DUK_STRIDX_CATCH",
+ "plain": "catch"
+ },
+ {
+ "base64": "Y29udGludWU=",
+ "define": "DUK_STRIDX_CONTINUE",
+ "plain": "continue"
+ },
+ {
+ "base64": "ZGVidWdnZXI=",
+ "define": "DUK_STRIDX_DEBUGGER",
+ "plain": "debugger"
+ },
+ {
+ "base64": "ZGVmYXVsdA==",
+ "define": "DUK_STRIDX_DEFAULT",
+ "plain": "default"
+ },
+ {
+ "base64": "ZGVsZXRl",
+ "define": "DUK_STRIDX_DELETE",
+ "plain": "delete"
+ },
+ {
+ "base64": "ZG8=",
+ "define": "DUK_STRIDX_DO",
+ "plain": "do"
+ },
+ {
+ "base64": "ZWxzZQ==",
+ "define": "DUK_STRIDX_ELSE",
+ "plain": "else"
+ },
+ {
+ "base64": "ZmluYWxseQ==",
+ "define": "DUK_STRIDX_FINALLY",
+ "plain": "finally"
+ },
+ {
+ "base64": "Zm9y",
+ "define": "DUK_STRIDX_FOR",
+ "plain": "for"
+ },
+ {
+ "base64": "ZnVuY3Rpb24=",
+ "define": "DUK_STRIDX_LC_FUNCTION",
+ "plain": "function"
+ },
+ {
+ "base64": "aWY=",
+ "define": "DUK_STRIDX_IF",
+ "plain": "if"
+ },
+ {
+ "base64": "aW4=",
+ "define": "DUK_STRIDX_IN",
+ "plain": "in"
+ },
+ {
+ "base64": "aW5zdGFuY2VvZg==",
+ "define": "DUK_STRIDX_INSTANCEOF",
+ "plain": "instanceof"
+ },
+ {
+ "base64": "bmV3",
+ "define": "DUK_STRIDX_NEW",
+ "plain": "new"
+ },
+ {
+ "base64": "cmV0dXJu",
+ "define": "DUK_STRIDX_RETURN",
+ "plain": "return"
+ },
+ {
+ "base64": "c3dpdGNo",
+ "define": "DUK_STRIDX_SWITCH",
+ "plain": "switch"
+ },
+ {
+ "base64": "dGhpcw==",
+ "define": "DUK_STRIDX_THIS",
+ "plain": "this"
+ },
+ {
+ "base64": "dGhyb3c=",
+ "define": "DUK_STRIDX_THROW",
+ "plain": "throw"
+ },
+ {
+ "base64": "dHJ5",
+ "define": "DUK_STRIDX_TRY",
+ "plain": "try"
+ },
+ {
+ "base64": "dHlwZW9m",
+ "define": "DUK_STRIDX_TYPEOF",
+ "plain": "typeof"
+ },
+ {
+ "base64": "dmFy",
+ "define": "DUK_STRIDX_VAR",
+ "plain": "var"
+ },
+ {
+ "base64": "Y29uc3Q=",
+ "define": "DUK_STRIDX_CONST",
+ "plain": "const"
+ },
+ {
+ "base64": "dm9pZA==",
+ "define": "DUK_STRIDX_VOID",
+ "plain": "void"
+ },
+ {
+ "base64": "d2hpbGU=",
+ "define": "DUK_STRIDX_WHILE",
+ "plain": "while"
+ },
+ {
+ "base64": "d2l0aA==",
+ "define": "DUK_STRIDX_WITH",
+ "plain": "with"
+ },
+ {
+ "base64": "Y2xhc3M=",
+ "define": "DUK_STRIDX_CLASS",
+ "plain": "class"
+ },
+ {
+ "base64": "ZW51bQ==",
+ "define": "DUK_STRIDX_ENUM",
+ "plain": "enum"
+ },
+ {
+ "base64": "ZXhwb3J0",
+ "define": "DUK_STRIDX_EXPORT",
+ "plain": "export"
+ },
+ {
+ "base64": "ZXh0ZW5kcw==",
+ "define": "DUK_STRIDX_EXTENDS",
+ "plain": "extends"
+ },
+ {
+ "base64": "aW1wb3J0",
+ "define": "DUK_STRIDX_IMPORT",
+ "plain": "import"
+ },
+ {
+ "base64": "c3VwZXI=",
+ "define": "DUK_STRIDX_SUPER",
+ "plain": "super"
+ },
+ {
+ "base64": "bnVsbA==",
+ "define": "DUK_STRIDX_LC_NULL",
+ "plain": "null"
+ },
+ {
+ "base64": "dHJ1ZQ==",
+ "define": "DUK_STRIDX_TRUE",
+ "plain": "true"
+ },
+ {
+ "base64": "ZmFsc2U=",
+ "define": "DUK_STRIDX_FALSE",
+ "plain": "false"
+ },
+ {
+ "base64": "aW1wbGVtZW50cw==",
+ "define": "DUK_STRIDX_IMPLEMENTS",
+ "plain": "implements"
+ },
+ {
+ "base64": "aW50ZXJmYWNl",
+ "define": "DUK_STRIDX_INTERFACE",
+ "plain": "interface"
+ },
+ {
+ "base64": "bGV0",
+ "define": "DUK_STRIDX_LET",
+ "plain": "let"
+ },
+ {
+ "base64": "cGFja2FnZQ==",
+ "define": "DUK_STRIDX_PACKAGE",
+ "plain": "package"
+ },
+ {
+ "base64": "cHJpdmF0ZQ==",
+ "define": "DUK_STRIDX_PRIVATE",
+ "plain": "private"
+ },
+ {
+ "base64": "cHJvdGVjdGVk",
+ "define": "DUK_STRIDX_PROTECTED",
+ "plain": "protected"
+ },
+ {
+ "base64": "cHVibGlj",
+ "define": "DUK_STRIDX_PUBLIC",
+ "plain": "public"
+ },
+ {
+ "base64": "c3RhdGlj",
+ "define": "DUK_STRIDX_STATIC",
+ "plain": "static"
+ },
+ {
+ "base64": "eWllbGQ=",
+ "define": "DUK_STRIDX_YIELD",
+ "plain": "yield"
+ }
+ ],
+ "comment": "Metadata for Duktape build",
+ "duk_version": 10502,
+ "duk_version_string": "1.5.2",
+ "git_describe": "v1.5.2"
+}
\ No newline at end of file
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/README.rst b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/README.rst
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/README.rst
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/README.rst
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-hybrid/README.rst b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-hybrid/README.rst
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-hybrid/README.rst
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-hybrid/README.rst
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-hybrid/duk_alloc_hybrid.c b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-hybrid/duk_alloc_hybrid.c
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.c
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-hybrid/duk_alloc_hybrid.h b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.h
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-hybrid/duk_alloc_hybrid.h
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-hybrid/duk_alloc_hybrid.h
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/README.rst b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/README.rst
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/README.rst
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/README.rst
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/duk_alloc_logging.c b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/duk_alloc_logging.c
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/duk_alloc_logging.c
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/duk_alloc_logging.c
index 86fecc56c..a89babf92 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/duk_alloc_logging.c
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/duk_alloc_logging.c
@@ -90,8 +90,8 @@ void *duk_realloc_logging(void *udata, void *ptr, duk_size_t size) {
old_size = hdr->u.sz;
if (size == 0) {
- free((void *) hdr);
write_log("R %p %ld NULL 0\n", ptr, (long) old_size);
+ free((void *) hdr);
return NULL;
} else {
t = realloc((void *) hdr, size + sizeof(alloc_hdr));
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/duk_alloc_logging.h b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/duk_alloc_logging.h
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/duk_alloc_logging.h
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/duk_alloc_logging.h
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/log2gnuplot.py b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/log2gnuplot.py
similarity index 97%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/log2gnuplot.py
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/log2gnuplot.py
index 7562814d3..0528259dc 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-logging/log2gnuplot.py
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-logging/log2gnuplot.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/env python2
#
# Analyze allocator logs and write total-bytes-in-use after every
# operation to stdout. The output can be gnuplotted as:
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-torture/README.rst b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-torture/README.rst
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-torture/README.rst
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-torture/README.rst
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-torture/duk_alloc_torture.c b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-torture/duk_alloc_torture.c
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-torture/duk_alloc_torture.h b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.h
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/alloc-torture/duk_alloc_torture.h
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.h
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/cmdline/README.rst b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/cmdline/README.rst
similarity index 100%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/cmdline/README.rst
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/cmdline/README.rst
diff --git a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/cmdline/duk_cmdline.c b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/cmdline/duk_cmdline.c
similarity index 50%
rename from ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/cmdline/duk_cmdline.c
rename to ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/cmdline/duk_cmdline.c
index df61cdf9a..ea5af55e8 100644
--- a/ceph/src/civetweb/src/third_party/duktape-1.3.0/examples/cmdline/duk_cmdline.c
+++ b/ceph/src/civetweb/src/third_party/duktape-1.5.2/examples/cmdline/duk_cmdline.c
@@ -1,21 +1,31 @@
/*
* Command line execution tool. Useful for test cases and manual testing.
*
- * To enable readline and other fancy stuff, compile with -DDUK_CMDLINE_FANCY.
+ * To enable linenoise and other fancy stuff, compile with -DDUK_CMDLINE_FANCY.
* It is not the default to maximize portability. You can also compile in
* support for example allocators, grep for DUK_CMDLINE_*.
*/
-#ifndef DUK_CMDLINE_FANCY
-#define NO_READLINE
-#define NO_RLIMIT
-#define NO_SIGNAL
+/* Helper define to enable a feature set; can also use separate defines. */
+#if defined(DUK_CMDLINE_FANCY)
+#define DUK_CMDLINE_LINENOISE
+#define DUK_CMDLINE_LINENOISE_COMPLETION
+#define DUK_CMDLINE_RLIMIT
+#define DUK_CMDLINE_SIGNAL
#endif
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || \
defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
/* Suppress warnings about plain fopen() etc. */
#define _CRT_SECURE_NO_WARNINGS
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+/* Workaround for snprintf() missing in older MSVC versions.
+ * Note that _snprintf() may not NUL terminate the string, but
+ * this difference does not matter here as a NUL terminator is
+ * always explicitly added.
+ */
+#define snprintf _snprintf
+#endif
#endif
#define GREET_CODE(variant) \
@@ -28,30 +38,36 @@
#include
#include