http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/df353561/thirdparty/civetweb-1.10/include/civetweb.h ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/include/civetweb.h b/thirdparty/civetweb-1.10/include/civetweb.h new file mode 100644 index 0000000..b0f5ee7 --- /dev/null +++ b/thirdparty/civetweb-1.10/include/civetweb.h @@ -0,0 +1,1367 @@ +/* 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 + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef CIVETWEB_HEADER_INCLUDED +#define CIVETWEB_HEADER_INCLUDED + +#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) +#if defined(CIVETWEB_DLL_EXPORTS) +#define CIVETWEB_API __declspec(dllexport) +#elif defined(CIVETWEB_DLL_IMPORTS) +#define CIVETWEB_API __declspec(dllimport) +#else +#define CIVETWEB_API +#endif +#elif __GNUC__ >= 4 +#define CIVETWEB_API __attribute__((visibility("default"))) +#else +#define CIVETWEB_API +#endif +#endif + +#include <stdio.h> +#include <stddef.h> + +#ifdef __cplusplus +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 */ + const char *request_uri; /* URL-decoded URI (absolute or relative, + * as in the request) */ + const char *local_uri; /* URL-decoded URI (relative). Can be NULL + * if the request_uri does not address a + * resource at the server host. */ +#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 + */ +#endif + + long long content_length; /* Length (in bytes) of the request body, + can be -1 if no length was given. */ + int remote_port; /* Client's port */ + int is_ssl; /* 1 if SSL-ed, 0 if not */ + void *user_data; /* User data pointer passed to mg_start() */ + void *conn_data; /* Connection-specific user data */ + + int num_headers; /* Number of HTTP headers */ + struct mg_header + 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; +}; + + +/* This structure needs to be passed to mg_start(), to let civetweb know + which callbacks to invoke. For a detailed description, see + https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md */ +struct mg_callbacks { + /* Called when civetweb has received new HTTP request. + If the callback returns one, it must process the request + by sending valid HTTP headers and a body. Civetweb will not do + any further processing. Otherwise it must return zero. + Note that since V1.7 the "begin_request" function is called + before an authorization check. If an authorization check is + required, use a request_handler instead. + Return value: + 0: civetweb will process the request itself. In this case, + the callback must not send any data to the client. + 1-999: callback already processed the request. Civetweb will + not send any data after the callback returned. The + return code is stored as a HTTP status code for the + access log. */ + int (*begin_request)(struct mg_connection *); + + /* Called when civetweb has finished processing request. */ + void (*end_request)(const struct mg_connection *, int reply_status_code); + + /* Called when civetweb is about to log a message. If callback returns + non-zero, civetweb does not log anything. */ + int (*log_message)(const struct mg_connection *, const char *message); + + /* Called when civetweb is about to log access. If callback returns + non-zero, civetweb does not log anything. */ + int (*log_access)(const struct mg_connection *, const char *message); + + /* Called when civetweb initializes SSL library. + Parameters: + user_data: parameter user_data passed when starting the server. + Return value: + 0: civetweb will set up the SSL certificate. + 1: civetweb assumes the callback already set up the certificate. + -1: initializing ssl fails. */ + int (*init_ssl)(void *ssl_context, void *user_data); + +#if defined(MG_LEGACY_INTERFACE) + /* Called when websocket request is received, before websocket handshake. + Return value: + 0: civetweb proceeds with websocket handshake. + 1: connection is closed immediately. + This callback is deprecated: Use mg_set_websocket_handler instead. */ + int (*websocket_connect)(const struct mg_connection *); + + /* Called when websocket handshake is successfully completed, and + connection is ready for data exchange. + This callback is deprecated: Use mg_set_websocket_handler instead. */ + void (*websocket_ready)(struct mg_connection *); + + /* Called when data frame has been received from the client. + Parameters: + bits: first byte of the websocket frame, see websocket RFC at + http://tools.ietf.org/html/rfc6455, section 5.2 + data, data_len: payload, with mask (if any) already applied. + Return value: + 1: keep this websocket connection open. + 0: close this websocket connection. + This callback is deprecated: Use mg_set_websocket_handler instead. */ + int (*websocket_data)(struct mg_connection *, + int bits, + char *data, + size_t data_len); +#endif /* MG_LEGACY_INTERFACE */ + + /* Called when civetweb is closing a connection. The per-context mutex is + 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. + + 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: + path: Full path to the file to open. + data_len: Placeholder for the file size, if file is served from + memory. + Return value: + NULL: do not serve file from memory, proceed with normal file open. + non-NULL: pointer to the file contents in memory. data_len must be + 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. + Parameters: + lua_context: "lua_State *" pointer. */ + void (*init_lua)(const struct mg_connection *, void *lua_context); + +#if defined(MG_LEGACY_INTERFACE) + /* Called when civetweb has uploaded a file to a temporary directory as a + result of mg_upload() call. + Note that mg_upload is deprecated. Use mg_handle_form_request instead. + Parameters: + file_name: full path name to the uploaded file. */ + void (*upload)(struct mg_connection *, const char *file_name); +#endif + + /* Called when civetweb is about to send HTTP error to the client. + Implementing this callback allows to create custom error pages. + Parameters: + status: HTTP error status code. + Return value: + 1: run civetweb error handler. + 0: callback already handled the error. */ + int (*http_error)(struct mg_connection *, int status); + + /* Called after civetweb context has been created, before requests + are processed. + Parameters: + ctx: context handle */ + void (*init_context)(const struct mg_context *ctx); + + /* Called when a new worker thread is initialized. + Parameters: + ctx: context handle + thread_type: + 0 indicates the master thread + 1 indicates a worker thread handling client connections + 2 indicates an internal helper thread (timer thread) + */ + void (*init_thread)(const struct mg_context *ctx, int thread_type); + + /* Called when civetweb context is deleted. + 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); +}; + + +/* Start web server. + + Parameters: + callbacks: mg_callbacks structure with user-defined callbacks. + options: NULL terminated list of option_name, option_value pairs that + specify Civetweb configuration parameters. + + Side-effects: on UNIX, ignores SIGCHLD and SIGPIPE signals. If custom + processing is required for these, signal handlers must be set up + after calling mg_start(). + + + Example: + const char *options[] = { + "document_root", "/var/www", + "listening_ports", "80,443s", + NULL + }; + struct mg_context *ctx = mg_start(&my_func, NULL, options); + + Refer to https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md + for the list of valid option and their possible values. + + Return: + web server context, or NULL on error. */ +CIVETWEB_API struct mg_context *mg_start(const struct mg_callbacks *callbacks, + void *user_data, + const char **configuration_options); + + +/* Stop the web server. + + Must be called last, when an application wants to stop the web server and + release all associated resources. This function blocks until all Civetweb + threads are stopped. Context pointer becomes invalid. */ +CIVETWEB_API void mg_stop(struct mg_context *); + + +/* mg_request_handler + + Called when a new request comes in. This callback is URI based + and configured with mg_set_request_handler(). + + Parameters: + conn: current connection information. + cbdata: the callback data configured with mg_set_request_handler(). + Returns: + 0: the handler could not handle the request, so fall through. + 1 - 999: the handler processed the request. The return code is + stored as a HTTP status code for the access log. */ +typedef int (*mg_request_handler)(struct mg_connection *conn, void *cbdata); + + +/* mg_set_request_handler + + Sets or removes a URI mapping for a request handler. + This function uses mg_lock_context internally. + + URI's are ordered and prefixed URI's are supported. For example, + consider two URIs: /a/b and /a + /a matches /a + /a/b matches /a/b + /a/c matches /a + + Parameters: + 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). + 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, + mg_request_handler handler, + void *cbdata); + + +/* Callback types for websocket handlers in C/C++. + + mg_websocket_connect_handler + Is called when the client intends to establish a websocket connection, + before websocket handshake. + Return value: + 0: civetweb proceeds with websocket handshake. + 1: connection is closed immediately. + + mg_websocket_ready_handler + Is called when websocket handshake is successfully completed, and + connection is ready for data exchange. + + mg_websocket_data_handler + Is called when a data frame has been received from the client. + Parameters: + bits: first byte of the websocket frame, see websocket RFC at + http://tools.ietf.org/html/rfc6455, section 5.2 + data, data_len: payload, with mask (if any) already applied. + Return value: + 1: keep this websocket connection open. + 0: close this websocket connection. + + mg_connection_close_handler + Is called, when the connection is closed.*/ +typedef int (*mg_websocket_connect_handler)(const struct mg_connection *, + void *); +typedef void (*mg_websocket_ready_handler)(struct mg_connection *, void *); +typedef int (*mg_websocket_data_handler)(struct mg_connection *, + int, + char *, + size_t, + void *); +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 + + 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(struct mg_context *ctx, + const char *uri, + 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_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 + + Callback function definition for mg_set_auth_handler + + Parameters: + conn: current connection information. + cbdata: the callback data configured with mg_set_request_handler(). + Returns: + 0: access denied + 1: access granted + */ +typedef int (*mg_authorization_handler)(struct mg_connection *conn, + void *cbdata); + + +/* mg_set_auth_handler + + Sets or removes a URI mapping for an authorization handler. + This function works similar to mg_set_request_handler - see there. */ +CIVETWEB_API void mg_set_auth_handler(struct mg_context *ctx, + const char *uri, + mg_authorization_handler handler, + void *cbdata); + + +/* Get the value of particular configuration parameter. + The value returned is read-only. Civetweb does not allow changing + configuration at run time. + If given parameter name is not valid, NULL is returned. For valid + names, return value is guaranteed to be non-NULL. If parameter is not + set, zero-length string is returned. */ +CIVETWEB_API const char *mg_get_option(const struct mg_context *ctx, + const char *name); + + +/* Get context from connection. */ +CIVETWEB_API struct mg_context * +mg_get_context(const struct mg_connection *conn); + + +/* Get user data passed to mg_start from context. */ +CIVETWEB_API void *mg_get_user_data(const struct mg_context *ctx); + + +/* Set user data for the current connection. */ +CIVETWEB_API void mg_set_user_connection_data(struct mg_connection *conn, + void *data); + + +/* Get user data set for the current connection. */ +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 + number of entries in the array equals to number_of_options x 2. + Array is NULL terminated. */ +/* Deprecated: Use mg_get_valid_options instead. */ +CIVETWEB_API const char **mg_get_valid_option_names(void); +#endif + + +struct mg_option { + const char *name; + int type; + const char *default_value; +}; + +/* Old nomenclature */ +enum { + CONFIG_TYPE_UNKNOWN = 0x0, + CONFIG_TYPE_NUMBER = 0x1, + CONFIG_TYPE_STRING = 0x2, + CONFIG_TYPE_FILE = 0x3, + CONFIG_TYPE_DIRECTORY = 0x4, + CONFIG_TYPE_BOOLEAN = 0x5, + 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. + The array is terminated by a NULL name option. */ +CIVETWEB_API const struct mg_option *mg_get_valid_options(void); + + +struct mg_server_ports { + int protocol; /* 1 = IPv4, 2 = IPv6, 3 = both */ + int port; /* port number */ + int is_ssl; /* https port: 0 = no, 1 = yes */ + int is_redirect; /* redirect all requests: 0 = no, 1 = yes */ + int _reserved1; + int _reserved2; + int _reserved3; + int _reserved4; +}; + + +/* Get the list of ports that civetweb is listening on. + The parameter size is the size of the ports array in elements. + The caller is responsibility to allocate the required memory. + This function returns the number of struct mg_server_ports elements + filled in, or <0 in case of an error. */ +CIVETWEB_API int mg_get_server_ports(const struct mg_context *ctx, + int size, + 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. + * + * 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 *realm, + const char *user, + const char *password); + + +/* 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 *); + + +/* 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 + -1 on error + >0 number of bytes written on success */ +CIVETWEB_API int mg_write(struct mg_connection *, const void *buf, size_t len); + + +/* Send data to a websocket client wrapped in a websocket frame. Uses + mg_lock_connection to ensure that the transmission is not interrupted, + i.e., when the application is proactively communicating and responding to + a request simultaneously. + + Send data to a websocket client wrapped in a websocket frame. + This function is available when civetweb is compiled with -DUSE_WEBSOCKET + + Return: + 0 when the connection has been closed + -1 on error + >0 number of bytes written on success */ +CIVETWEB_API int mg_websocket_write(struct mg_connection *conn, + int opcode, + const char *data, + size_t data_len); + + +/* Send data to a websocket server wrapped in a masked websocket frame. Uses + mg_lock_connection to ensure that the transmission is not interrupted, + i.e., when the application is proactively communicating and responding to + a request simultaneously. + + Send data to a websocket server wrapped in a masked websocket frame. + This function is available when civetweb is compiled with -DUSE_WEBSOCKET + + Return: + 0 when the connection has been closed + -1 on error + >0 number of bytes written on success */ +CIVETWEB_API int mg_websocket_client_write(struct mg_connection *conn, + int opcode, + const char *data, + size_t data_len); + + +/* Blocks until unique access is obtained to this connection. Intended for use + with websockets only. + Invoke this before mg_write or mg_printf when communicating with a + websocket if your code has server-initiated communication as well as + communication in direct response to a message. */ +CIVETWEB_API void mg_lock_connection(struct mg_connection *conn); +CIVETWEB_API void mg_unlock_connection(struct mg_connection *conn); + + +#if defined(MG_LEGACY_INTERFACE) +#define mg_lock mg_lock_connection +#define mg_unlock mg_unlock_connection +#endif + + +/* Lock server context. This lock may be used to protect resources + that are shared between different connection/worker threads. */ +CIVETWEB_API void mg_lock_context(struct mg_context *ctx); +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, + WEBSOCKET_OPCODE_BINARY = 0x2, + WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8, + WEBSOCKET_OPCODE_PING = 0x9, + 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 +#if defined(_MSC_VER) && _MSC_VER >= 1400 +#include <sal.h> +#if defined(_MSC_VER) && _MSC_VER > 1400 +#define PRINTF_FORMAT_STRING(s) _Printf_format_string_ s +#else +#define PRINTF_FORMAT_STRING(s) __format_string s +#endif +#else +#define PRINTF_FORMAT_STRING(s) s +#endif + +#ifdef __GNUC__ +#define PRINTF_ARGS(x, y) __attribute__((format(printf, x, y))) +#else +#define PRINTF_ARGS(x, y) +#endif + + +/* Send data to the client using printf() semantics. + Works exactly like mg_write(), but allows to do message formatting. */ +CIVETWEB_API int mg_printf(struct mg_connection *, + PRINTF_FORMAT_STRING(const char *fmt), + ...) 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_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 store it in a file "path". + Return: + < 0 Error + >= 0 Number of bytes stored in file "path". +*/ + + +/* Read data from the remote end, return number of bytes read. + Return: + 0 connection has been closed by peer. No more data could be read. + < 0 read error. No more data could be read from the connection. + > 0 number of bytes read into the buffer. */ +CIVETWEB_API int mg_read(struct mg_connection *, void *buf, size_t len); + + +/* Get the value of particular HTTP header. + + This is a helper function. It traverses request_info->http_headers array, + and if the header is present in the array, returns its value. If it is + not present, NULL is returned. */ +CIVETWEB_API const char *mg_get_header(const struct mg_connection *, + const char *name); + + +/* Get a value of particular form variable. + + Parameters: + data: pointer to form-uri-encoded buffer. This could be either POST data, + or request_info.query_string. + data_len: length of the encoded data. + var_name: variable name to decode from the buffer + dst: destination buffer for the decoded variable + dst_len: length of the destination buffer + + Return: + On success, length of the decoded variable. + On error: + -1 (variable not found). + -2 (destination buffer is NULL, zero length or too small to hold the + decoded variable). + + Destination buffer is guaranteed to be '\0' - terminated if it is not + NULL or zero length. */ +CIVETWEB_API int mg_get_var(const char *data, + size_t data_len, + const char *var_name, + char *dst, + size_t dst_len); + + +/* Get a value of particular form variable. + + Parameters: + data: pointer to form-uri-encoded buffer. This could be either POST data, + or request_info.query_string. + data_len: length of the encoded data. + var_name: variable name to decode from the buffer + dst: destination buffer for the decoded variable + dst_len: length of the destination buffer + occurrence: which occurrence of the variable, 0 is the first, 1 the + second... + this makes it possible to parse a query like + b=x&a=y&a=z which will have occurrence values b:0, a:0 and a:1 + + Return: + On success, length of the decoded variable. + On error: + -1 (variable not found). + -2 (destination buffer is NULL, zero length or too small to hold the + decoded variable). + + Destination buffer is guaranteed to be '\0' - terminated if it is not + NULL or zero length. */ +CIVETWEB_API int mg_get_var2(const char *data, + size_t data_len, + const char *var_name, + char *dst, + size_t dst_len, + size_t occurrence); + + +/* Fetch value of certain cookie variable into the destination buffer. + + Destination buffer is guaranteed to be '\0' - terminated. In case of + failure, dst[0] == '\0'. Note that RFC allows many occurrences of the same + parameter. This function returns only first occurrence. + + Return: + On success, value length. + On error: + -1 (either "Cookie:" header is not present at all or the requested + parameter is not found). + -2 (destination buffer is NULL, zero length or too small to hold the + value). */ +CIVETWEB_API int mg_get_cookie(const char *cookie, + const char *var_name, + char *buf, + size_t buf_len); + + +/* Download data from the remote web server. + host: host name to connect to, e.g. "foo.com", or "10.12.40.1". + port: port number, e.g. 80. + use_ssl: wether to use SSL connection. + error_buffer, error_buffer_size: error message placeholder. + request_fmt,...: HTTP request. + Return: + On success, valid pointer to the new connection, suitable for mg_read(). + On error, NULL. error_buffer contains error message. + Example: + char ebuf[100]; + struct mg_connection *conn; + conn = mg_download("google.com", 80, 0, ebuf, sizeof(ebuf), + "%s", "GET / HTTP/1.0\r\nHost: google.com\r\n\r\n"); + */ +CIVETWEB_API struct mg_connection * +mg_download(const char *host, + int port, + int use_ssl, + char *error_buffer, + size_t error_buffer_size, + PRINTF_FORMAT_STRING(const char *request_fmt), + ...) PRINTF_ARGS(6, 7); + + +/* Close the connection opened by mg_download(). */ +CIVETWEB_API void mg_close_connection(struct mg_connection *conn); + + +#if defined(MG_LEGACY_INTERFACE) +/* File upload functionality. Each uploaded file gets saved into a temporary + file and MG_UPLOAD event is sent. + Return number of uploaded files. + Deprecated: Use mg_handle_form_request instead. */ +CIVETWEB_API int mg_upload(struct mg_connection *conn, + const char *destination_dir); +#endif + + +/* This structure contains callback functions for handling form fields. + It is used as an argument to mg_handle_form_request. */ +struct mg_form_data_handler { + /* This callback function is called, if a new field has been found. + * The return value of this callback is used to define how the field + * should be processed. + * + * Parameters: + * key: Name of the field ("name" property of the HTML input field). + * filename: Name of a file to upload, at the client computer. + * Only set for input fields of type "file", otherwise NULL. + * path: Output parameter: File name (incl. path) to store the file + * at the server computer. Only used if FORM_FIELD_STORAGE_STORE + * is returned by this callback. Existing files will be + * overwritten. + * pathlen: Length of the buffer for path. + * user_data: Value of the member user_data of mg_form_data_handler + * + * Return value: + * The callback must return the intended storage for this field + * (See FORM_FIELD_STORAGE_*). + */ + int (*field_found)(const char *key, + const char *filename, + char *path, + size_t pathlen, + void *user_data); + + /* If the "field_found" callback returned FORM_FIELD_STORAGE_GET, + * this callback will receive the field data. + * + * Parameters: + * key: Name of the field ("name" property of the HTML input field). + * value: Value of the input field. + * user_data: Value of the member user_data of mg_form_data_handler + * + * Return value: + * TODO: Needs to be defined. + */ + int (*field_get)(const char *key, + const char *value, + size_t valuelen, + void *user_data); + + /* If the "field_found" callback returned FORM_FIELD_STORAGE_STORE, + * the data will be stored into a file. If the file has been written + * successfully, this callback will be called. This callback will + * not be called for only partially uploaded files. The + * mg_handle_form_request function will either store the file completely + * and call this callback, or it will remove any partial content and + * not call this callback function. + * + * Parameters: + * path: Path of the file stored at the server. + * file_size: Size of the stored file in bytes. + * user_data: Value of the member user_data of mg_form_data_handler + * + * Return value: + * TODO: Needs to be defined. + */ + int (*field_store)(const char *path, long long file_size, void *user_data); + + /* User supplied argument, passed to all callback functions. */ + void *user_data; +}; + + +/* 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. */ + FORM_FIELD_STORAGE_SKIP = 0x0, + /* Get the field value. */ + FORM_FIELD_STORAGE_GET = 0x1, + /* Store the field value into a file. */ + FORM_FIELD_STORAGE_STORE = 0x2, + /* Stop parsing this request. Skip the remaining fields. */ + 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. + * Note: It is possible that several fields are already handled successfully + * (e.g., stored into files), before the request handling is stopped with an + * error. In this case a number < 0 is returned as well. + * In any case, it is the duty of the caller to remove files once they are + * no longer required. */ +CIVETWEB_API int mg_handle_form_request(struct mg_connection *conn, + struct mg_form_data_handler *fdh); + + +/* Convenience function -- create detached thread. + Return: 0 on success, non-0 on error. */ +typedef void *(*mg_thread_func_t)(void *); +CIVETWEB_API int mg_start_thread(mg_thread_func_t f, void *p); + + +/* Return builtin mime type for the given file name. + For unrecognized extensions, "text/plain" is returned. */ +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(const struct mg_connection *conn, int response_code); + + +/* Return CivetWeb version. */ +CIVETWEB_API const char *mg_version(void); + + +/* URL-decode input buffer into destination buffer. + 0-terminate the destination buffer. + form-url-encoded data differs from URI encoding in a way that it + uses '+' as character for space, see RFC 1866 section 8.2.1 + http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt + Return: length of the decoded data, or -1 if dst buffer is too small. */ +CIVETWEB_API int mg_url_decode(const char *src, + int src_len, + char *dst, + int dst_len, + int is_form_url_encoded); + + +/* URL-encode input buffer into destination buffer. + returns the length of the resulting buffer or -1 + is the buffer is too small. */ +CIVETWEB_API int mg_url_encode(const char *src, char *dst, size_t dst_len); + + +/* MD5 hash given strings. + Buffer 'buf' must be 33 bytes long. Varargs is a NULL terminated list of + ASCIIz strings. When function returns, buf will contain human-readable + MD5 hash. Example: + char buf[33]; + mg_md5(buf, "aa", "bb", NULL); */ +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 (not used for sending data, but to get perameters) + fmt: format string without the line return + ...: variable argument list + Example: + mg_cry(conn,"i like %s", "logging"); */ +CIVETWEB_API void mg_cry(const struct mg_connection *conn, + PRINTF_FORMAT_STRING(const char *fmt), + ...) PRINTF_ARGS(2, 3); + + +/* utility methods to compare two buffers, case insensitive. */ +CIVETWEB_API int mg_strcasecmp(const char *s1, const char *s2); +CIVETWEB_API int mg_strncasecmp(const char *s1, const char *s2, size_t len); + + +/* Connect to a websocket as a client + Parameters: + host: host to connect to, i.e. "echo.websocket.org" or "192.168.1.1" or + "localhost" + port: server port + use_ssl: make a secure connection to server + error_buffer, error_buffer_size: buffer for an error message + path: server path you are trying to connect to, i.e. if connection to + localhost/app, path should be "/app" + origin: value of the Origin HTTP header + data_func: callback that should be used when data is received from the + server + user_data: user supplied argument + + Return: + On success, valid mg_connection object. + On error, NULL. Se error_buffer for details. +*/ +CIVETWEB_API struct mg_connection * +mg_connect_websocket_client(const char *host, + int port, + int use_ssl, + char *error_buffer, + size_t error_buffer_size, + const char *path, + const char *origin, + mg_websocket_data_handler data_func, + mg_websocket_close_handler close_func, + void *user_data); + + +/* Connect to a TCP server as a client (can be used to connect to a HTTP server) + Parameters: + host: host to connect to, i.e. "www.wikipedia.org" or "192.168.1.1" or + "localhost" + port: server port + use_ssl: make a secure connection to server + error_buffer, error_buffer_size: buffer for an error message + + Return: + On success, valid mg_connection object. + On error, NULL. Se error_buffer for details. +*/ +CIVETWEB_API struct mg_connection *mg_connect_client(const char *host, + int port, + int use_ssl, + char *error_buffer, + size_t error_buffer_size); + + +struct mg_client_options { + const char *host; + int port; + const char *client_cert; + const char *server_cert; + /* TODO: add more data */ +}; + + +CIVETWEB_API struct mg_connection * +mg_connect_client_secure(const struct mg_client_options *client_options, + char *error_buffer, + size_t error_buffer_size); + + +enum { TIMEOUT_INFINITE = -1 }; +enum { MG_TIMEOUT_INFINITE = -1 }; + +/* Wait for a response from the server + Parameters: + conn: connection + ebuf, ebuf_len: error message placeholder. + timeout: time to wait for a response in milliseconds (if < 0 then wait + forever) + + Return: + On success, >= 0 + On error/timeout, < 0 +*/ +CIVETWEB_API int mg_get_response(struct mg_connection *conn, + char *ebuf, + size_t ebuf_len, + int timeout); + + +/* 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) + 8 support IPv6 (USE_IPV6 set) + 16 support WebSocket (USE_WEBSOCKET set) + 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) + 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, 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 */ + +#endif /* CIVETWEB_HEADER_INCLUDED */
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/df353561/thirdparty/civetweb-1.10/mingw.cmd ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/mingw.cmd b/thirdparty/civetweb-1.10/mingw.cmd new file mode 100644 index 0000000..4b26215 --- /dev/null +++ b/thirdparty/civetweb-1.10/mingw.cmd @@ -0,0 +1,884 @@ +:: Make sure the extensions are enabled +@verify other 2>nul +@setlocal EnableExtensions EnableDelayedExpansion +@if errorlevel 1 ( + @call :print_usage "Failed to enable extensions" + @exit /b 1 +) + +::Change the code page to unicode +@chcp 65001 1>nul 2>nul +@if errorlevel 1 ( + @call :print_usage "Failed to change the code page to unicode" + @exit /b 1 +) + +:: Set up some global variables +@set "script_name=%~nx0" +@set "script_folder=%~dp0" +@set "script_folder=%script_folder:~0,-1%" +@set "dependency_path=%TEMP%\mingw-build-dependencies" + +:: Check the command line parameters +@set logging_level=1 +:options_loop +@if [%1] == [] goto :options_parsed +@set "arg=%~1" +@set one=%arg:~0,1% +@set two=%arg:~0,2% +@set three=%arg:~0,3% +@if /i [%arg%] == [/?] ( + @call :print_usage "Downloads a specific version of MinGW" + @exit /b 0 +) +@if /i [%arg%] == [/q] set quiet=true +@if /i [%two%] == [/v] @if /i not [%three%] == [/ve] @call :verbosity "!arg!" +@if /i [%arg%] == [/version] set "version=%~2" & shift +@if /i [%arg%] == [/arch] set "arch=%~2" & shift +@if /i [%arg%] == [/exceptions] set "exceptions=%~2" & shift +@if /i [%arg%] == [/threading] set "threading=%~2" & shift +@if /i [%arg%] == [/revision] set "revision=%~2" & shift +@if /i not [!one!] == [/] ( + if not defined output_path ( + set output_path=!arg! + ) else ( + @call :print_usage "Too many output locations: !output_path! !arg!" ^ + "There should only be one output location" + @exit /b 1 + ) +) +@shift +@goto :options_loop +:options_parsed +@if defined quiet set logging_level=0 +@if not defined output_path set "output_path=%script_folder%\mingw-builds" +@set "output_path=%output_path:/=\%" + +:: Set up the logging +@set "log_folder=%output_path%\logs" +@call :iso8601 timestamp +@set "log_path=%log_folder%\%timestamp%.log" +@set log_keep=10 + +:: Get default architecture +@if not defined arch @call :architecture arch + +:: Only keep a certain amount of logs +@set /a "log_keep=log_keep-1" +@if not exist %log_folder% @mkdir %log_folder% +@for /f "skip=%log_keep%" %%f in ('dir /b /o-D /tc %log_folder%') do @( + @call :log 4 "Removing old log file %log_folder%\%%f" + del %log_folder%\%%f +) + +:: Set up some more global variables +@call :windows_version win_ver win_ver_major win_ver_minor win_ver_rev +@call :script_source script_source +@if [%script_source%] == [explorer] ( + set /a "logging_level=logging_level+1" +) + +:: Execute the main function +@call :main "%arch%" "%version%" "%threading%" "%exceptions%" "%revision%" +@if errorlevel 1 ( + @call :log 0 "Failed to download MinGW" + @call :log 0 "View the log at %log_path%" + @exit /b 1 +) + +:: Stop the script if the user double clicked +@if [%script_source%] == [explorer] ( + pause +) + +@endlocal +@goto :eof + +:: -------------------------- Functions start here ---------------------------- + +:main - Main function that performs the download +:: %1 - Target architecture +:: %2 - Version of MinGW to get [optional] +:: %3 - Threading model [optional] +:: %4 - Exception model [optional] +:: %5 - Package revision [optional] +@setlocal +@call :log 6 +@call :log 2 "Welcome to the MinGW download script" +@call :log 6 "------------------------------------" +@call :log 6 +@call :log 2 "This script downloads a specific version of MinGW" +@set "arch=%~1" +@if "%arch%" == "" @exit /b 1 +@set "version=%~2" +@set "threading=%~3" +@set "exceptions=%~4" +@set "revision=%~5" +@call :log 3 "arch = %arch%" +@call :log 3 "version = %version%" +@call :log 3 "exceptions = %exceptions%" +@call :log 3 "threading = %threading%" +@call :log 3 "revision = %revision%" +@call :repository repo +@if errorlevel 1 ( + @call :log 0 "Failed to get the MinGW-builds repository information" + @exit /b 1 +) +@call :resolve slug url "%repo%" "%arch%" "%version%" "%threading%" "%exceptions%" "%revision%" +@if errorlevel 1 ( + @call :log 0 "Failed to resolve the correct URL of MinGW" + @exit /b 1 +) +@call :unpack compiler_path "%url%" "%output_path%\mingw\%slug%" +@if errorlevel 1 ( + @call :log 0 "Failed to unpack the MinGW archive" + @exit /b 1 +) +@rmdir /s /q "%dependency_path%" +@echo.%compiler_path% +@endlocal +@goto :eof + +:repository - Gets the MinGW-builds repository +:: %1 - The return variable for the repository file path +@verify other 2>nul +@setlocal EnableDelayedExpansion +@if errorlevel 1 ( + @call :log 0 "Failed to enable extensions" + @exit /b 1 +) +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@call :log 7 +@call :log 2 "Getting MinGW repository information" +@set "url=http://downloads.sourceforge.net/project/mingw-w64/Toolchains targetting Win32/Personal Builds/mingw-builds/installer/repository.txt" +@call :log 6 +@call :log 1 "Downloading MinGW repository" +@set "file_path=%dependency_path%\mingw-repository.txt" +@call :download "%url%" "%file_path%" +@if errorlevel 1 ( + @call :log 0 "Failed to download the MinGW repository information" + @exit /b 1 +) +@set "repository_path=%dependency_path%\repository.txt" +@del "%repository_path%" 2>nul +@for /f "delims=| tokens=1-6,*" %%a in (%file_path%) do @( + @set "version=%%~a" + @set "version=!version: =!" + @set "arch=%%~b" + @set "arch=!arch: =!" + @set "threading=%%~c" + @set "threading=!threading: =!" + @set "exceptions=%%~d" + @set "exceptions=!exceptions: =!" + @set "revision=%%~e" + @set "revision=!revision: =!" + @set "revision=!revision:rev=!" + @set "url=%%~f" + @set "url=!url:%%20= !" + @for /l %%a in (1,1,32) do @if "!url:~-1!" == " " set url=!url:~0,-1! + @echo !arch!^|!version!^|!threading!^|!exceptions!^|!revision!^|!url!>> "%repository_path%" +) +@del "%file_path%" 2>nul +@endlocal & set "%var%=%repository_path%" +@goto :eof + +:resolve - Gets the MinGW-builds repository +:: %1 - The return variable for the MinGW slug +:: %2 - The return variable for the MinGW URL +:: %3 - The repository information to use +:: %4 - Target architecture +:: %5 - Version of MinGW to get [optional] +:: %6 - Threading model [optional] +:: %7 - Exception model [optional] +:: %8 - Package revision [optional] +@setlocal +@set "slug_var=%~1" +@if "%slug_var%" == "" @exit /b 1 +@set "url_var=%~2" +@if "%url_var%" == "" @exit /b 1 +@set "repository=%~3" +@if "%repository%" == "" @exit /b 1 +@set "arch=%~4" +@if "%arch%" == "" @exit /b 1 +@call :resolve_version version "%repository%" "%arch%" "%~5" +@if errorlevel 1 @exit /b 1 +@call :resolve_threading threading "%repository%" "%arch%" "%version%" "%~6" +@if errorlevel 1 @exit /b 1 +@call :resolve_exceptions exceptions "%repository%" "%arch%" "%version%" "%threading%" "%~7" +@if errorlevel 1 @exit /b 1 +@call :resolve_revision revision "%repository%" "%arch%" "%version%" "%threading%" "%exceptions%" "%~8" +@if errorlevel 1 @exit /b 1 +@call :log 3 "Finding URL" +@for /f "delims=| tokens=1-6" %%a in (%repository%) do @( + @if "%arch%" == "%%a" ( + @if "%version%" == "%%b" ( + @if "%threading%" == "%%c" ( + @if "%exceptions%" == "%%d" ( + @if "%revision%" == "%%e" ( + @set "url=%%f" +) ) ) ) ) ) +@if "%url%" == "" ( + @call :log 0 "Failed to resolve URL" + @exit /b 1 +) +@set slug=gcc-%version%-%arch%-%threading%-%exceptions%-rev%revision% +@call :log 2 "Resolved slug: %slug%" +@call :log 2 "Resolved url: %url%" +@endlocal & set "%slug_var%=%slug%" & set "%url_var%=%url%" +@goto :eof + +:unpack - Unpacks the MinGW archive +:: %1 - The return variable name for the compiler path +:: %2 - The filepath or URL of the archive +:: %3 - The folder to unpack to +@verify other 2>nul +@setlocal EnableDelayedExpansion +@if errorlevel 1 ( + @call :log 0 "Failed to enable extensions" + @exit /b 1 +) +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@set "archive_path=%~2" +@if "%archive_path%" == "" @exit /b 1 +@set "folder_path=%~3" +@if "%folder_path%" == "" @exit /b 1 +@set "compiler_path=%folder_path%\bin" +@if exist "%compiler_path%" goto :unpack_done +@call :log 7 +@call :log 2 "Unpacking MinGW archive" +@set "http=%archive_path:~0,4%" +@if "%http%" == "http" ( + @set "url=%archive_path%" + @for /f %%a in ("!url: =-!") do @set "file_name=%%~na" + @for /f %%a in ("!url: =-!") do @set "file_ext=%%~xa" + @set "archive_path=%dependency_path%\!file_name!!file_ext!" + @if not exist "!archive_path!" ( + @call :log 6 + @call :log 1 "Downloading MinGW archive" + @call :download "!url!" "!archive_path!" + @if errorlevel 1 ( + @del "!archive_path!" 2>nul + @call :log 0 "Failed to download: !file_name!!file_ext!" + @exit /b 1 + ) + ) +) +@if not exist "%archive_path%" ( + @call :log 0 "The archive did not exist to unpack: %archive_path%" + @exit /b 1 +) +@for /f %%a in ("%archive_path: =-%") do @set "file_name=%%~na" +@for /f %%a in ("%archive_path: =-%") do @set "file_ext=%%~xa" +@call :log 6 +@call :log 1 "Unpacking MinGW %file_name%%file_ext%" +@call :find_sevenzip sevenzip_executable +@if errorlevel 1 ( + @call :log 0 "Need 7zip to unpack the MinGW archive" + @exit /b 1 +) +@call :iso8601 iso8601 +@for /f %%a in ("%folder_path%") do @set "tmp_path=%%~dpatmp-%iso8601%" +@"%sevenzip_executable%" x -y "-o%tmp_path%" "%archive_path%" > nul +@if errorlevel 1 ( + @rmdir /s /q "%folder_path%" + @call :log 0 "Failed to unpack the MinGW archive" + @exit /b 1 +) +@set "expected_path=%tmp_path%\mingw64" +@if not exist "%expected_path%" ( + @set "expected_path=%tmp_path%\mingw32" +) +@move /y "%expected_path%" "%folder_path%" > nul +@if errorlevel 1 ( + @rmdir /s /q "%tmp_path%" 2>nul + @call :log 0 "Failed to move MinGW folder" + @call :log 0 "%expected_path%" + @call :log 0 "%folder_path%" + @exit /b 1 +) +@rmdir /s /q %tmp_path% +@set "compiler_path=%folder_path%\bin" +:unpack_done +@if not exist "%compiler_path%\gcc.exe" ( + @call :log 0 "Failed to find gcc: %compiler_path%" + @exit /b 1 +) +@endlocal & set "%var%=%compiler_path%" +@goto :eof + +:find_sevenzip - Finds (or downloads) the 7zip executable +:: %1 - The return variable for the 7zip executable path +@setlocal +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@call :log 2 "Finding 7zip" +@call :find_in_path sevenzip_executable 7z.exe +@if not errorlevel 1 goto :find_sevenzip_done +@call :find_in_path sevenzip_executable 7za.exe +@if not errorlevel 1 goto :find_sevenzip_done +@set checksum=2FAC454A90AE96021F4FFC607D4C00F8 +@set "url=http://7-zip.org/a/7za920.zip"; +@for /f %%a in ("%url: =-%") do @set "file_name=%%~na" +@for /f %%a in ("%url: =-%") do @set "file_ext=%%~xa" +@set "archive_path=%dependency_path%\%file_name%%file_ext%" +@if not exist "%archive_path%" ( + @call :log 6 + @call :log 1 "Downloading 7zip archive" + @call :download "%url%" "%archive_path%" %checksum% + @if errorlevel 1 ( + @del "%archive_path%" 2>nul + @call :log 0 "Failed to download: %file_name%%file_ext%" + @exit /b 1 + ) +) +@set "sevenzip_path=%dependency_path%\sevenzip" +@if not exist "%sevenzip_path%" ( + @call :unzip "%archive_path%" "%sevenzip_path%" + @if errorlevel 1 ( + @call :log 0 "Failed to unzip the7zip archive" + @exit /b 1 + ) +) +@set "sevenzip_executable=%sevenzip_path%\7za.exe" +@if not exist "%sevenzip_executable%" ( + @call :log 0 "Failed to find unpacked 7zip: %sevenzip_executable%" + @exit /b 1 +) +:find_sevenzip_done +@call :log 2 "Found 7zip: %sevenzip_executable%" +@endlocal & set "%var%=%sevenzip_executable%" +@goto :eof + +:unzip - Unzips a .zip archive +:: %1 - The archive to unzip +:: %2 - The location to unzip to +@setlocal +@set "archive_path=%~1" +@if "%archive_path%" == "" @exit /b 1 +@set "folder_path=%~2" +@if "%folder_path%" == "" @exit /b 1 +@for /f %%a in ("%archive_path: =-%") do @set "file_name=%%~na" +@for /f %%a in ("%archive_path: =-%") do @set "file_ext=%%~xa" +@call :log 2 "Unzipping: %file_name%%file_ext%" +@call :iso8601 iso8601 +@set "log_path=%temp%\unzip-%iso8601%-%file_name%.log" +@powershell ^ + Add-Type -assembly "system.io.compression.filesystem"; ^ + [io.compression.zipfile]::ExtractToDirectory(^ + '%archive_path%', '%folder_path%') 2>"%log_path%" +@if errorlevel 1 ( + @call :log 0 "Failed to unzip: %file_name%%file_ext%" + @call :log_append "%log_path%" + @exit /b 1 +) +@endlocal +@goto :eof + +:resolve_version - Gets the version of the MinGW compiler +:: %1 - The return variable for the version +:: %2 - The repository information to use +:: %3 - The architecture of the compiler +:: %4 - Version of MinGW to get [optional] +@verify other 2>nul +@setlocal EnableDelayedExpansion +@if errorlevel 1 ( + @call :log 0 "Failed to enable extensions" + @exit /b 1 +) +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@set "repository=%~2" +@if "%repository%" == "" @exit /b 1 +@set "arch=%~3" +@if "%arch%" == "" @exit /b 1 +@set "version=%~4" +@if not "%version%" == "" goto :resolve_version_done +:: Find the latest version +@call :log 3 "Finding latest version" +@set version=0.0.0 +@for /f "delims=| tokens=1-6" %%a in (%repository%) do @( + @if "%arch%" == "%%a" ( + @call :version_compare result "%version%" "%%b" + @if errorlevel 1 ( + @call :log 0 "Failed to compare versions: %version% %%a" + @exit /b 1 + ) + @if !result! lss 0 set version=%%b + ) +) +:resolve_version_done +@if "%version%" == "" ( + @call :log 0 "Failed to resolve latest version number" + @exit /b 1 +) +@call :log 2 "Resolved version: %version%" +@endlocal & set "%var%=%version%" +@goto :eof + +:resolve_threading - Gets the threading model of the MinGW compiler +:: %1 - The return variable for the threading model +:: %2 - The repository information to use +:: %3 - The architecture of the compiler +:: %4 - The version of the compiler +:: %5 - threading model of MinGW to use [optional] +@verify other 2>nul +@setlocal EnableDelayedExpansion +@if errorlevel 1 ( + @call :log 0 "Failed to enable extensions" + @exit /b 1 +) +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@set "repository=%~2" +@if "%repository%" == "" @exit /b 1 +@set "arch=%~3" +@if "%arch%" == "" @exit /b 1 +@set "version=%~4" +@if "%version%" == "" @exit /b 1 +@set "threading=%~5" +@if not "%threading%" == "" goto :resolve_threading_done +@call :log 3 "Finding best threading model" +@for /f "delims=| tokens=1-6" %%a in (%repository%) do @( + @if "%arch%" == "%%a" ( + @if "%version%" == "%%b" ( + @if not defined threading ( + @set "threading=%%c" + ) + @if "%%c" == "posix" ( + @set "threading=%%c" +) ) ) ) +:resolve_threading_done +@if "%threading%" == "" ( + @call :log 0 "Failed to resolve the best threading model" + @exit /b 1 +) +@call :log 2 "Resolved threading model: %threading%" +@endlocal & set "%var%=%threading%" +@goto :eof + +:resolve_exceptions - Gets the exception model of the MinGW compiler +:: %1 - The return variable for the exception model +:: %2 - The repository information to use +:: %3 - The architecture of the compiler +:: %4 - The version of the compiler +:: %4 - The threading model of the compiler +:: %5 - exception model of MinGW to use [optional] +@verify other 2>nul +@setlocal EnableDelayedExpansion +@if errorlevel 1 ( + @call :log 0 "Failed to enable extensions" + @exit /b 1 +) +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@set "repository=%~2" +@if "%repository%" == "" @exit /b 1 +@set "arch=%~3" +@if "%arch%" == "" @exit /b 1 +@set "version=%~4" +@if "%version%" == "" @exit /b 1 +@set "threading=%~5" +@if "%threading%" == "" @exit /b 1 +@set "exceptions=%~6" +@if not "%exceptions%" == "" goto :resolve_exceptions_done +@call :log 3 "Finding best exception model" +@for /f "delims=| tokens=1-6" %%a in (%repository%) do @( + @if "%arch%" == "%%a" ( + @if "%version%" == "%%b" ( + @if "%threading%" == "%%c" ( + @if not defined exceptions ( + @set "exceptions=%%d" + ) + @if "%%d" == "dwarf" ( + @set "exceptions=%%d" + ) + @if "%%d" == "seh" ( + @set "exceptions=%%d" +) ) ) ) ) +:resolve_exceptions_done +@if "%exceptions%" == "" ( + @call :log 0 "Failed to resolve the best exception model" + @exit /b 1 +) +@call :log 2 "Resolved exception model: %exceptions%" +@endlocal & set "%var%=%exceptions%" +@goto :eof + +:resolve_revision - Gets the revision of the MinGW compiler +:: %1 - The return variable for the revision +:: %2 - The repository information to use +:: %3 - The architecture of the compiler +:: %4 - The version of the compiler +:: %4 - The threading model of the compiler +:: %4 - The exception model of the compiler +:: %5 - revision of the MinGW package to use [optional] +@verify other 2>nul +@setlocal EnableDelayedExpansion +@if errorlevel 1 ( + @call :log 0 "Failed to enable extensions" + @exit /b 1 +) +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@set "repository=%~2" +@if "%repository%" == "" @exit /b 1 +@set "arch=%~3" +@if "%arch%" == "" @exit /b 1 +@set "version=%~4" +@if "%version%" == "" @exit /b 1 +@set "threading=%~5" +@if "%threading%" == "" @exit /b 1 +@set "exceptions=%~6" +@if "%exceptions%" == "" @exit /b 1 +@set "revision=%~7" +@if not "%revision%" == "" goto :resolve_revision_done +@call :log 3 "Finding latest revision" +@for /f "delims=| tokens=1-6" %%a in (%repository%) do @( + @if "%arch%" == "%%a" ( + @if "%version%" == "%%b" ( + @if "%threading%" == "%%c" ( + @if "%exceptions%" == "%%d" ( + @if "%%e" gtr "%revision%" ( + @set "revision=%%e" +) ) ) ) ) ) +:resolve_revision_done +@if "%revision%" == "" ( + @call :log 0 "Failed to resolve latest revision" + @exit /b 1 +) +@call :log 2 "Resolved revision: %revision%" +@endlocal & set "%var%=%revision%" +@goto :eof + +:version_compare - Compares two semantic version numbers +:: %1 - The return variable: +:: - < 0 : if %2 < %3 +:: - 0 : if %2 == %3 +:: - > 0 : if %2 > %3 +:: %2 - The first version to compare +:: %3 - The second version to compare +@setlocal +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@set "lhs=%~2" +@if "%lhs%" == "" @exit /b 1 +@set "rhs=%~3" +@if "%lhs%" == "" @exit /b 1 +@set result=0 +@for /f "delims=. tokens=1-6" %%a in ("%lhs%.%rhs%") do @( + @if %%a lss %%d ( + set result=-1 + goto :version_compare_done + ) else ( + @if %%a gtr %%d ( + set result=1 + goto :version_compare_done + ) else ( + @if %%b lss %%e ( + set result=-1 + goto :version_compare_done + ) else ( + @if %%b gtr %%e ( + set result=1 + goto :version_compare_done + ) else ( + @if %%c lss %%f ( + set result=-1 + goto :version_compare_done + ) else ( + @if %%c gtr %%f ( + set result=1 + goto :version_compare_done + ) + ) + ) + ) + ) + ) +) +:version_compare_done +@endlocal & set "%var%=%result%" +@goto :eof + +:print_usage - Prints the usage of the script +:: %* - message to print, each argument on it's own line +@setlocal +@for %%a in (%*) do @echo.%%~a +@echo. +@echo.build [/?][/v[v...]^|/q][/version][/arch a][/threading t] +@echo. [/exceptions e][/revision r] location +@echo. +@echo. /version v The version of MinGW to download +@echo. /arch a The target architecture [i686^|x86_64] +@echo. /threading t +@echo. Threading model to use [posix^|win32] +@echo. /exceptions e +@echo. Exception model to use [sjlj^|seh^|dwarf] +@echo. /revision e Revision of the release to use +@echo. /v Sets the output to be more verbose +@echo. /v[v...] Extra verbosity, /vv, /vvv, etc +@echo. /q Quiets the output +@echo. /? Shows this usage message +@echo. +@endlocal +@goto :eof + +:script_source - Determines if the script was ran from the cli or explorer +:: %1 - The return variable [cli|explorer] +@verify other 2>nul +@setlocal EnableDelayedExpansion +@if errorlevel 1 ( + @call :log 0 "Failed to enable extensions" + @exit /b 1 +) +@call :log 3 "Attempting to detect the script source" +@echo "The invocation command was: '%cmdcmdline%'" >> %log_path% +@for /f "tokens=1-3,*" %%a in ("%cmdcmdline%") do @( + set cmd=%%~a + set arg1=%%~b + set arg2=%%~c + set rest=%%~d +) +@set quote=" +@if "!arg2:~0,1!" equ "!quote!" ( + if "!arg2:~-1!" neq "!quote!" ( + set "arg2=!arg2:~1!" + ) +) +@call :log 4 "cmd = %cmd%" +@call :log 4 "arg1 = %arg1%" +@call :log 4 "arg2 = %arg2%" +@call :log 4 "rest = %rest%" +@call :log 4 "src = %~f0" +@if /i "%arg2%" == "call" ( + set script_source=cli +) else ( + @if /i "%arg1%" == "/c" ( + set script_source=explorer + ) else ( + set script_source=cli + ) +) +@call :log 3 "The script was invoked from %script_source%" +@endlocal & set "%~1=%script_source%" +@goto :eof + +:architecture - Finds the system architecture +:: %1 - The return variable [i686|x86_64] +@setlocal +@call :log 3 "Determining the processor architecture" +@set "key=HKLM\System\CurrentControlSet\Control\Session Manager\Environment" +@set "var=PROCESSOR_ARCHITECTURE" +@for /f "skip=2 tokens=2,*" %%a in ('reg query "%key%" /v "%var%"') do @set "arch=%%b" +@if "%arch%" == "AMD64" set arch=x86_64 +@if "%arch%" == "x64" set arch=i686 +@call :log 4 "arch = %arch%" +@endlocal & set "%~1=%arch%" +@goto :eof + +:md5 - Gets the MD5 checksum for a file +:: %1 - The hash +:: %2 - The file path +@setlocal +@set "var=%~1" +@set "file_path=%~2" +@if "%var%" == "" @exit /b 1 +@if "%file_path%" == "" @exit /b 1 +@if not exist "%file_path%" @exit /b 1 +@for /f "skip=3 tokens=1,*" %%a in ('powershell Get-FileHash -Algorithm MD5 "'%file_path%'"') do @set hash=%%b +@if not defined hash ( + @call :log 6 + @call :log 0 "Failed to get MD5 hash for %file_path%" + @exit /b 1 +) +@endlocal & set "%var%=%hash: =%" +@goto :eof + +:windows_version - Checks the windows version +:: %1 - The windows version +:: %2 - The major version number return variable +:: %3 - The minor version number return variable +:: %4 - The revision version number return variable +@setlocal +@call :log 3 "Retrieving the Windows version" +@for /f "tokens=2 delims=[]" %%x in ('ver') do @set win_ver=%%x +@set win_ver=%win_ver:Version =% +@set win_ver_major=%win_ver:~0,1% +@set win_ver_minor=%win_ver:~2,1% +@set win_ver_rev=%win_ver:~4% +@call :log 4 "win_ver = %win_ver%" +@endlocal & set "%~1=%win_ver%" ^ + & set "%~2=%win_ver_major%" ^ + & set "%~3=%win_ver_minor%" ^ + & set "%~4=%win_ver_rev%" +@goto :eof + +:find_in_path - Finds a program of file in the PATH +:: %1 - return variable of the file path +@setlocal +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@set "file=%~2" +@if "%file%" == "" @exit /b 1 +@call :log 3 "Searching PATH for %file%" +@for %%x in ("%file%") do @set "file_path=%%~f$PATH:x" +@if not defined file_path @exit /b 1 +@endlocal & set "%var%=%file_path%" +@goto :eof + +:log_append - Appends another file into the current logging file +:: %1 - the file_path to the file to concatenate +@setlocal +@set "file_path=%~1" +@if "%file_path%" == "" @exit /b 1 +@call :log 3 "Appending to log: %file_path%" +@call :iso8601 iso8601 +@set temp_log=%temp%\append-%iso8601%.log +@call :log 4 "Using temp file %temp_log%" +@type "%log_path%" "%file_path%" > "%temp_log%" 2>nul +@move /y "%temp_log%" "%log_path%" 1>nul +@del "%file_path% 2>nul +@del "%temp_log% 2>nul +@endlocal +@goto :eof + +:iso8601 - Returns the current time in ISO8601 format +:: %1 - the return variable +:: %2 - format [extended|basic*] +:: iso8601 - contains the resulting timestamp +@setlocal +@wmic Alias /? >NUL 2>&1 || @exit /b 1 +@set "var=%~1" +@if "%var%" == "" @exit /b 1 +@set "format=%~2" +@if "%format%" == "" set format=basic +@for /F "skip=1 tokens=1-6" %%g IN ('wmic Path Win32_UTCTime Get Day^,Hour^,Minute^,Month^,Second^,Year /Format:table') do @( + @if "%%~l"=="" goto :iso8601_done + @set "yyyy=%%l" + @set "mm=00%%j" + @set "dd=00%%g" + @set "hour=00%%h" + @set "minute=00%%i" + @set "seconds=00%%k" +) +:iso8601_done +@set mm=%mm:~-2% +@set dd=%dd:~-2% +@set hour=%hour:~-2% +@set minute=%minute:~-2% +@set seconds=%seconds:~-2% +@if /i [%format%] == [extended] ( + set iso8601=%yyyy%-%mm%-%dd%T%hour%:%minute%:%seconds%Z +) else ( + if /i [%format%] == [basic] ( + set iso8601=%yyyy%%mm%%dd%T%hour%%minute%%seconds%Z + ) else ( + @exit /b 1 + ) +) +@set iso8601=%iso8601: =0% +@endlocal & set %var%=%iso8601% +@goto :eof + +:verbosity - Processes the verbosity parameter '/v[v...] +:: %1 - verbosity given on the command line +:: logging_level - set to the number of v's +@setlocal +@set logging_level=0 +@set verbosity=%~1 +:verbosity_loop +@set verbosity=%verbosity:~1% +@if not [%verbosity%] == [] @( + set /a "logging_level=logging_level+1" + goto verbosity_loop +) +@endlocal & set logging_level=%logging_level% +@goto :eof + +:log - Logs a message, depending on verbosity +:: %1 - level +:: [0-4] for CLI logging +:: [5-9] for GUI logging +:: %2 - message to print +@setlocal +@set "level=%~1" +@set "msg=%~2" +@if "%log_folder%" == "" ( + echo Logging was used to early in the script, log_folder isn't set yet + goto :eof +) +@if "%log_path%" == "" ( + echo Logging was used to early in the script, log_path isn't set yet + goto :eof +) +@if not exist "%log_folder%" mkdir "%log_folder%" +@if not exist "%log_path%" echo. 1>nul 2>"%log_path%" +@echo.%msg% >> "%log_path%" +@if %level% geq 5 ( + @if [%script_source%] == [explorer] ( + set /a "level=level-5" + ) else ( + @goto :eof + ) +) +@if "%logging_level%" == "" ( + echo Logging was used to early in the script, logging_level isn't set yet + goto :eof +) +@if %logging_level% geq %level% echo.%msg% 1>&2 +@endlocal +@goto :eof + +:download - Downloads a file from the internet +:: %1 - the url of the file to download +:: %2 - the file to download to +:: %3 - the MD5 checksum of the file (optional) +@setlocal EnableDelayedExpansion +@if errorlevel 1 ( + @call :print_usage "Failed to enable extensions" + @exit /b 1 +) +@set "url=%~1" +@set "file_path=%~2" +@set "checksum=%~3" +@for %%a in (%file_path%) do @set dir_path=%%~dpa +@for %%a in (%file_path%) do @set file_name=%%~nxa +@if "%url%" == "" @exit /b 1 +@if "%file_path%" == "" @exit /b 1 +@if "%dir_path%" == "" @exit /b 1 +@if "%file_name%" == "" @exit /b 1 +@if not exist "%dir_path%" mkdir "%dir_path%" +@call :log 2 "Downloading %url%" +@call :iso8601 iso8601 +@set "temp_path=%temp%\download-%iso8601%-%file_name%" +@set "log_path=%temp%\download-%iso8601%-log-%file_name%" +@call :log 4 "Using temp file %temp_path%" +@powershell Invoke-WebRequest "'%url%'" ^ + -OutFile "'%temp_path%'" ^ + -UserAgent [Microsoft.PowerShell.Commands.PSUserAgent]::IE ^ + 1>nul 2>"%log_path%" +@if errorlevel 1 ( + @call :log 0 "Failed to download %url%" + @call :log_append "%log_path%" + @exit /b 1 +) +@if [%checksum%] neq [] ( + @call :log 4 "Checking %checksum% against %temp_path%" + @call :md5 hash "%temp_path%" + if "!hash!" neq "%checksum%" ( + @call :log 0 "Failed to match checksum: %temp_path%" + @call :log 0 "Hash : !hash!" + @call :log 0 "Checksum: %checksum%" + @exit /b 1 + ) else ( + @call :log 3 "Checksum matched: %temp_path%" + @call :log 3 "Hash : !hash!" + @call :log 3 "Checksum: %checksum%" + ) +) +@call :log 4 "Renaming %temp_path% to %file_path%" +@move /y "%temp_path%" "%file_path%" 1>nul +@endlocal +@goto :eof http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/df353561/thirdparty/civetweb-1.10/resources/Info.plist ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/resources/Info.plist b/thirdparty/civetweb-1.10/resources/Info.plist new file mode 100644 index 0000000..f02e19a --- /dev/null +++ b/thirdparty/civetweb-1.10/resources/Info.plist @@ -0,0 +1,21 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd";> +<plist version="1.0"> +<dict> + <key>CFBundleExecutable</key> <string>Civetweb</string> + <key>CFBundlePackageType</key> <string>APPL</string> + <key>CFBundleTypeRole</key> <string>None</string> + <key>CFBundleIconFile</key> <string>civetweb</string> + <key>CFBundleIconFiles</key> <array> + <string>civetweb_16x16.png</string> + <string>civetweb_22x22.png</string> + <string>civetweb_32x32.png</string> + <string>civetweb_64x64.png</string> + </array> + <key>LSUIElement</key> <true/> + <key>RunAtLoad</key> <true/> + <key>Label</key> <string>com.nofacepress.civetweb</string> + <key>ProgramArguments</key> <array> </array> + <key>KeepAlive</key> <true/> +</dict> +</plist> http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/df353561/thirdparty/civetweb-1.10/resources/Makefile.in-duktape ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/resources/Makefile.in-duktape b/thirdparty/civetweb-1.10/resources/Makefile.in-duktape new file mode 100644 index 0000000..3a53f2e --- /dev/null +++ b/thirdparty/civetweb-1.10/resources/Makefile.in-duktape @@ -0,0 +1,77 @@ +# +# Copyright (c) 2015-2017 the Civetweb developers +# +# License http://opensource.org/licenses/mit-license.php MIT License +# + +ifndef WITH_DUKTAPE + $(error WITH_DUKTAPE is not defined) +endif + +# 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), 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 + +ifneq ($(DUKTAPE_VERSION_KNOWN), 1) + $(error Duktape: Unknwon version - $(WITH_DUKTAPE_VERSION)) +endif + + +# Add flags for all Duktape versions +DUKTAPE_CFLAGS += -I$(DUKTAPE_DIR) -DUSE_DUKTAPE + +ifneq ($(TARGET_OS),WIN32) +# DUKTAPE_CFLAGS += +endif + +ifdef WITH_DUKTAPE_SHARED + + DUKTAPE_SOURCE_FILES = + + $(info Duktape: using dynamic linking) + +else + + DUKTAPE_SOURCE_FILES = duktape.c + +ifeq ($(WITH_DUKTAPE_VERSION), 104) +# DUKTAPE_SOURCE_FILES += ... TODO ... +endif + + $(info Duktape: using static library) + +endif + +DUKTAPE_SOURCES = $(addprefix $(DUKTAPE_DIR)/, $(DUKTAPE_SOURCE_FILES)) +DUKTAPE_OBJECTS = $(DUKTAPE_SOURCES:.c=.o) + +OBJECTS += $(DUKTAPE_OBJECTS) +CFLAGS += $(DUKTAPE_CFLAGS) +SOURCE_DIRS = $(DUKTAPE_DIR) +BUILD_DIRS += $(BUILD_DIR)/$(DUKTAPE_DIR) + http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/df353561/thirdparty/civetweb-1.10/resources/Makefile.in-lua ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/resources/Makefile.in-lua b/thirdparty/civetweb-1.10/resources/Makefile.in-lua new file mode 100644 index 0000000..e91d019 --- /dev/null +++ b/thirdparty/civetweb-1.10/resources/Makefile.in-lua @@ -0,0 +1,149 @@ +# +# Copyright (c) 2013 No Face Press, LLC +# Copyright (c) 2014-2017 the Civetweb developers +# +# License http://opensource.org/licenses/mit-license.php MIT License +# + +ifndef WITH_LUA + $(error WITH_LUA is not defined) +endif + +# Lua Default version is 502 +WITH_LUA_VERSION ?= 502 +LUA_VERSION_KNOWN = 0 + +# Select src and header according to the Lua version +ifeq ($(WITH_LUA_VERSION), 501) + $(info Lua: Using version 5.1.5) + LUA_DIR = src/third_party/lua-5.1.5/src + LUA_SHARED_LIB_FLAG = -llua5.1 + LUA_CFLAGS = -DLUA_VERSION_MAKEFILE=501 + LUA_VERSION_KNOWN = 1 +endif +ifeq ($(WITH_LUA_VERSION), 502) + $(info Lua: Using version 5.2.4) + LUA_DIR = src/third_party/lua-5.2.4/src + LUA_SHARED_LIB_FLAG = -llua5.2 + LUA_CFLAGS = -DLUA_VERSION_MAKEFILE=502 + LUA_VERSION_KNOWN = 1 +endif +ifeq ($(WITH_LUA_VERSION), 503) + $(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 +endif + +ifneq ($(LUA_VERSION_KNOWN), 1) + $(error Lua: Unknwon version - $(WITH_LUA_VERSION)) +endif + + +# Add flags for all Lua versions +LUA_CFLAGS += -I$(LUA_DIR) -DLUA_COMPAT_ALL -DUSE_LUA + +ifneq ($(TARGET_OS),WIN32) + LUA_CFLAGS += -DLUA_USE_POSIX -DLUA_USE_DLOPEN +endif + +ifdef WITH_LUA_SHARED + + LUA_SOURCE_FILES = + + $(info Lua: using dynamic linking) + +else + + LUA_SOURCE_FILES = lapi.c \ + lauxlib.c \ + lbaselib.c \ + lcode.c \ + ldblib.c \ + ldebug.c \ + ldo.c \ + ldump.c \ + lfunc.c \ + lgc.c \ + linit.c \ + liolib.c \ + llex.c \ + lmathlib.c \ + lmem.c \ + loadlib.c \ + lobject.c \ + lopcodes.c \ + loslib.c \ + lparser.c \ + lstate.c \ + lstring.c \ + lstrlib.c \ + ltable.c \ + ltablib.c \ + ltm.c \ + lundump.c \ + lvm.c \ + lzio.c + +ifeq ($(WITH_LUA_VERSION), 502) + LUA_SOURCE_FILES += lbitlib.c \ + lcorolib.c \ + lctype.c +endif +ifeq ($(WITH_LUA_VERSION), 503) + LUA_SOURCE_FILES += lbitlib.c \ + lcorolib.c \ + lctype.c \ + lutf8lib.c +endif + + $(info Lua: using static library) + +endif + +LUA_SOURCES = $(addprefix $(LUA_DIR)/, $(LUA_SOURCE_FILES)) +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) + SQLITE_DIR = src/third_party + SQLITE_SOURCE_FILES = sqlite3.c lsqlite3.c + SQLITE_SOURCES = $(addprefix $(SQLITE_DIR)/, $(SQLITE_SOURCE_FILES)) + SQLITE_OBJECTS = $(SQLITE_SOURCES:.c=.o) + SQLITE_CFLAGS = -I$(SQLITE_DIR) -DTHREADSAFE=1 -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_FTS3_PARENTHESIS + OBJECTS += $(SQLITE_OBJECTS) + CFLAGS += $(SQLITE_CFLAGS) + CFLAGS += -DUSE_LUA_SQLITE3 + #SOURCE_DIRS = $(SQLITE_DIR) +endif + + +LFS_DIR = src/third_party +LFS_SOURCE_FILES = lfs.c +LFS_SOURCES = $(addprefix $(LFS_DIR)/, $(LFS_SOURCE_FILES)) +LFS_OBJECTS = $(LFS_SOURCES:.c=.o) +LFS_CFLAGS = -I$(LFS_DIR) +OBJECTS += $(LFS_OBJECTS) +CFLAGS += $(LFS_CFLAGS) +CFLAGS += -DUSE_LUA_FILE_SYSTEM +#SOURCE_DIRS = $(LFS_DIR) + + +ifneq ($(WITH_LUA_VERSION), 501) + LXML_DIR = src/third_party + LXML_SOURCE_FILES = LuaXML_lib.c + LXML_SOURCES = $(addprefix $(LXML_DIR)/, $(LXML_SOURCE_FILES)) + LXML_OBJECTS = $(LXML_SOURCES:.c=.o) + LXML_CFLAGS = -I$(LXML_DIR) + OBJECTS += $(LXML_OBJECTS) + CFLAGS += $(LXML_CFLAGS) + CFLAGS += -DUSE_LUA_LUAXML + #SOURCE_DIRS = $(LXML_DIR) +endif + http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/df353561/thirdparty/civetweb-1.10/resources/Makefile.in-os ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/resources/Makefile.in-os b/thirdparty/civetweb-1.10/resources/Makefile.in-os new file mode 100644 index 0000000..a759134 --- /dev/null +++ b/thirdparty/civetweb-1.10/resources/Makefile.in-os @@ -0,0 +1,23 @@ +# +# Copyright (c) 2013 No Face Press, LLC +# License http://opensource.org/licenses/mit-license.php MIT License +# + +# Override this using TARGET_OS=LINUX on the command line +ifeq ($(TARGET_OS),) + ifeq ($(OS),Windows_NT) + TARGET_OS = WIN32 + else + UNAME_S := $(shell uname -s) + ifeq ($(UNAME_S),Linux) + TARGET_OS = LINUX + else + ifeq ($(UNAME_S),Darwin) + TARGET_OS = OSX + else + TARGET_OS = BSD + endif + endif + endif +endif +
