Use new nomenclature for enums in the code (see #522)

src/civetweb.c

@@ -2132,21 +2132,21 @@ 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_LIST, NULL},
-    {"put_delete_auth_file", CONFIG_TYPE_FILE, NULL},
-    {"cgi_interpreter", CONFIG_TYPE_FILE, 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_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},
+    {"cgi_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.cgi$|**.pl$|**.php$"},
+    {"cgi_environment", MG_CONFIG_TYPE_STRING_LIST, NULL},
+    {"put_delete_auth_file", MG_CONFIG_TYPE_FILE, NULL},
+    {"cgi_interpreter", MG_CONFIG_TYPE_FILE, NULL},
+    {"protect_uri", MG_CONFIG_TYPE_STRING_LIST, NULL},
+    {"authentication_domain", MG_CONFIG_TYPE_STRING, "mydomain.com"},
+    {"enable_auth_domain_check", MG_CONFIG_TYPE_BOOLEAN, "yes"},
+    {"ssi_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.shtml$|**.shtm$"},
+    {"throttle", MG_CONFIG_TYPE_STRING_LIST, NULL},
+    {"access_log_file", MG_CONFIG_TYPE_FILE, NULL},
+    {"enable_directory_listing", MG_CONFIG_TYPE_BOOLEAN, "yes"},
+    {"error_log_file", MG_CONFIG_TYPE_FILE, NULL},
+    {"global_auth_file", MG_CONFIG_TYPE_FILE, NULL},
     {"index_files",
-     CONFIG_TYPE_STRING_LIST,
+     MG_CONFIG_TYPE_STRING_LIST,
 #ifdef USE_LUA
      "index.xhtml,index.html,index.htm,"
      "index.lp,index.lsp,index.lua,index.cgi,"
@@ -2154,79 +2154,79 @@ static struct mg_option config_options[] = {
 #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_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_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},
+    {"enable_keep_alive", MG_CONFIG_TYPE_BOOLEAN, "no"},
+    {"access_control_list", MG_CONFIG_TYPE_STRING_LIST, NULL},
+    {"extra_mime_types", MG_CONFIG_TYPE_STRING_LIST, NULL},
+    {"listening_ports", MG_CONFIG_TYPE_STRING_LIST, "8080"},
+    {"document_root", MG_CONFIG_TYPE_DIRECTORY, NULL},
+    {"ssl_certificate", MG_CONFIG_TYPE_FILE, NULL},
+    {"ssl_certificate_chain", MG_CONFIG_TYPE_FILE, NULL},
+    {"num_threads", MG_CONFIG_TYPE_NUMBER, "50"},
+    {"run_as_user", MG_CONFIG_TYPE_STRING, NULL},
+    {"url_rewrite_patterns", MG_CONFIG_TYPE_STRING_LIST, NULL},
+    {"hide_files_patterns", MG_CONFIG_TYPE_EXT_PATTERN, NULL},
+    {"request_timeout_ms", MG_CONFIG_TYPE_NUMBER, "30000"},
+    {"keep_alive_timeout_ms", MG_CONFIG_TYPE_NUMBER, "500"},
+    {"linger_timeout_ms", MG_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"},
-    {"ssl_default_verify_paths", CONFIG_TYPE_BOOLEAN, "yes"},
-    {"ssl_cipher_list", CONFIG_TYPE_STRING, NULL},
-    {"ssl_protocol_version", CONFIG_TYPE_NUMBER, "0"},
-    {"ssl_short_trust", CONFIG_TYPE_BOOLEAN, "no"},
+    {"ssl_verify_peer", MG_CONFIG_TYPE_BOOLEAN, "no"},
+
+    {"ssl_ca_path", MG_CONFIG_TYPE_DIRECTORY, NULL},
+    {"ssl_ca_file", MG_CONFIG_TYPE_FILE, NULL},
+    {"ssl_verify_depth", MG_CONFIG_TYPE_NUMBER, "9"},
+    {"ssl_default_verify_paths", MG_CONFIG_TYPE_BOOLEAN, "yes"},
+    {"ssl_cipher_list", MG_CONFIG_TYPE_STRING, NULL},
+    {"ssl_protocol_version", MG_CONFIG_TYPE_NUMBER, "0"},
+    {"ssl_short_trust", MG_CONFIG_TYPE_BOOLEAN, "no"},
 #if defined(USE_WEBSOCKET)
-    {"websocket_timeout_ms", CONFIG_TYPE_NUMBER, "30000"},
+    {"websocket_timeout_ms", MG_CONFIG_TYPE_NUMBER, "30000"},
 #endif
-    {"decode_url", CONFIG_TYPE_BOOLEAN, "yes"},
+    {"decode_url", MG_CONFIG_TYPE_BOOLEAN, "yes"},
 
 #if defined(USE_LUA)
-    {"lua_preload_file", CONFIG_TYPE_FILE, NULL},
-    {"lua_script_pattern", CONFIG_TYPE_EXT_PATTERN, "**.lua$"},
-    {"lua_server_page_pattern", CONFIG_TYPE_EXT_PATTERN, "**.lp$|**.lsp$"},
+    {"lua_preload_file", MG_CONFIG_TYPE_FILE, NULL},
+    {"lua_script_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.lua$"},
+    {"lua_server_page_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.lp$|**.lsp$"},
 #endif
 #if defined(USE_DUKTAPE)
     /* The support for duktape is still in alpha version state.
      * The name of this config option might change. */
-    {"duktape_script_pattern", CONFIG_TYPE_EXT_PATTERN, "**.ssjs$"},
+    {"duktape_script_pattern", MG_CONFIG_TYPE_EXT_PATTERN, "**.ssjs$"},
 #endif
 
 #if defined(USE_WEBSOCKET)
-    {"websocket_root", CONFIG_TYPE_DIRECTORY, NULL},
+    {"websocket_root", MG_CONFIG_TYPE_DIRECTORY, NULL},
 #endif
 #if defined(USE_LUA) && defined(USE_WEBSOCKET)
-    {"lua_websocket_pattern", CONFIG_TYPE_EXT_PATTERN, "**.lua$"},
+    {"lua_websocket_pattern", MG_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"},
+    {"access_control_allow_origin", MG_CONFIG_TYPE_STRING, "*"},
+    {"access_control_allow_methods", MG_CONFIG_TYPE_STRING, "*"},
+    {"access_control_allow_headers", MG_CONFIG_TYPE_STRING, "*"},
+    {"error_pages", MG_CONFIG_TYPE_DIRECTORY, NULL},
+    {"tcp_nodelay", MG_CONFIG_TYPE_NUMBER, "0"},
 #if !defined(NO_CACHING)
-    {"static_file_max_age", CONFIG_TYPE_NUMBER, "3600"},
+    {"static_file_max_age", MG_CONFIG_TYPE_NUMBER, "3600"},
 #endif
 #if !defined(NO_SSL)
-    {"strict_transport_security_max_age", CONFIG_TYPE_NUMBER, NULL},
+    {"strict_transport_security_max_age", MG_CONFIG_TYPE_NUMBER, NULL},
 #endif
 #if defined(__linux__)
-    {"allow_sendfile_call", CONFIG_TYPE_BOOLEAN, "yes"},
+    {"allow_sendfile_call", MG_CONFIG_TYPE_BOOLEAN, "yes"},
 #endif
 #if defined(_WIN32)
-    {"case_sensitive", CONFIG_TYPE_BOOLEAN, "no"},
+    {"case_sensitive", MG_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},
+    {"lua_background_script", MG_CONFIG_TYPE_FILE, NULL},
+    {"lua_background_script_params", MG_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"},
+    {"additional_header", MG_CONFIG_TYPE_STRING_MULTILINE, NULL},
+    {"max_request_size", MG_CONFIG_TYPE_NUMBER, "16384"},
+    {"allow_index_script_resource", MG_CONFIG_TYPE_BOOLEAN, "no"},
 
-    {NULL, CONFIG_TYPE_UNKNOWN, NULL}};
+    {NULL, MG_CONFIG_TYPE_UNKNOWN, NULL}};
 
 
 /* Check if the config_options and the corresponding enum have compatible
@@ -11375,7 +11375,7 @@ read_websocket(struct mg_connection *conn,
 			}
 
 			if (exit_by_callback
-			    || ((mop & 0xf) == WEBSOCKET_OPCODE_CONNECTION_CLOSE)) {
+                || ((mop & 0xf) == MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE)) {
 				/* Opcode == 8, connection close */
 				break;
 			}
@@ -18036,7 +18036,7 @@ mg_init_library(unsigned features)
 				mg_ssl_initialized = 1;
 			} else {
 				(void)ebuf;
-				/* TODO: print error */
+				DEBUG_TRACE("Initializing SSL failed: %s", ebuf);
 				features_inited &= ~(2u);
 			}
 		} else {

src/handle_form.inl

@@ -40,7 +40,7 @@ url_encoded_field_found(const struct mg_connection *conn,
 	    mg_url_decode(key, (int)key_len, key_dec, (int)sizeof(key_dec), 1);
 
 	if (((size_t)key_dec_len >= (size_t)sizeof(key_dec)) || (key_dec_len < 0)) {
-		return FORM_FIELD_STORAGE_SKIP;
+        return MG_FORM_FIELD_STORAGE_SKIP;
 	}
 
 	if (filename) {
@@ -54,7 +54,7 @@ url_encoded_field_found(const struct mg_connection *conn,
 		    || (filename_dec_len < 0)) {
 			/* Log error message and skip this field. */
 			mg_cry(conn, "%s: Cannot decode filename", __func__);
-			return FORM_FIELD_STORAGE_SKIP;
+            return MG_FORM_FIELD_STORAGE_SKIP;
 		}
 	} else {
 		filename_dec[0] = 0;
@@ -63,16 +63,16 @@ url_encoded_field_found(const struct mg_connection *conn,
 	ret =
 	    fdh->field_found(key_dec, filename_dec, path, path_len, fdh->user_data);
 
-	if ((ret & 0xF) == FORM_FIELD_STORAGE_GET) {
+    if ((ret & 0xF) == MG_FORM_FIELD_STORAGE_GET) {
 		if (fdh->field_get == NULL) {
 			mg_cry(conn, "%s: Function \"Get\" not available", __func__);
-			return FORM_FIELD_STORAGE_SKIP;
+            return MG_FORM_FIELD_STORAGE_SKIP;
 		}
 	}
-	if ((ret & 0xF) == FORM_FIELD_STORAGE_STORE) {
+    if ((ret & 0xF) == MG_FORM_FIELD_STORAGE_STORE) {
 		if (fdh->field_store == NULL) {
 			mg_cry(conn, "%s: Function \"Store\" not available", __func__);
-			return FORM_FIELD_STORAGE_SKIP;
+            return MG_FORM_FIELD_STORAGE_SKIP;
 		}
 	}
 
@@ -99,7 +99,7 @@ url_encoded_field_get(const struct mg_connection *conn,
 		       "%s: Not enough memory (required: %lu)",
 		       __func__,
 		       (unsigned long)(value_len + 1));
-		return FORM_FIELD_STORAGE_ABORT;
+        return MG_FORM_FIELD_STORAGE_ABORT;
 	}
 
 	mg_url_decode(key, (int)key_len, key_dec, (int)sizeof(key_dec), 1);
@@ -232,14 +232,16 @@ mg_handle_form_request(struct mg_connection *conn,
 
 			/* In every "field_found" callback we ask what to do with the
 			 * data ("field_storage"). This could be:
-			 * FORM_FIELD_STORAGE_SKIP (0) ... ignore the value of this field
-			 * FORM_FIELD_STORAGE_GET (1) ... read the data and call the get
-			 *                              callback function
-			 * FORM_FIELD_STORAGE_STORE (2) ... store the data in a file
-			 * FORM_FIELD_STORAGE_READ (3) ... let the user read the data
-			 *                               (for parsing long data on the fly)
-			 *                               (currently not implemented)
-			 * FORM_FIELD_STORAGE_ABORT (flag) ... stop parsing
+             * MG_FORM_FIELD_STORAGE_SKIP (0):
+             *   ignore the value of this field
+             * MG_FORM_FIELD_STORAGE_GET (1):
+             *   read the data and call the get callback function
+             * MG_FORM_FIELD_STORAGE_STORE (2):
+             *   store the data in a file
+             * MG_FORM_FIELD_STORAGE_READ (3):
+             *   let the user read the data (for parsing long data on the fly)
+             * MG_FORM_FIELD_STORAGE_ABORT (flag):
+             *   stop parsing
 			 */
 			memset(path, 0, sizeof(path));
 			field_count++;
@@ -262,12 +264,12 @@ mg_handle_form_request(struct mg_connection *conn,
 				next = val + vallen;
 			}
 
-			if (field_storage == FORM_FIELD_STORAGE_GET) {
+            if (field_storage == MG_FORM_FIELD_STORAGE_GET) {
 				/* Call callback */
 				url_encoded_field_get(
 				    conn, data, (size_t)keylen, val, (size_t)vallen, fdh);
 			}
-			if (field_storage == FORM_FIELD_STORAGE_STORE) {
+            if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
 				/* Store the content to a file */
 				if (mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &fstore) == 0) {
 					fstore.access.fp = NULL;
@@ -306,7 +308,7 @@ mg_handle_form_request(struct mg_connection *conn,
 				}
 			}
 
-			/* if (field_storage == FORM_FIELD_STORAGE_READ) { */
+            /* if (field_storage == MG_FORM_FIELD_STORAGE_READ) { */
 			/* The idea of "field_storage=read" is to let the API user read
 			 * data chunk by chunk and to some data processing on the fly.
 			 * This should avoid the need to store data in the server:
@@ -319,8 +321,8 @@ mg_handle_form_request(struct mg_connection *conn,
 			 */
 			/* } */
 
-			if ((field_storage & FORM_FIELD_STORAGE_ABORT)
-			    == FORM_FIELD_STORAGE_ABORT) {
+            if ((field_storage & MG_FORM_FIELD_STORAGE_ABORT)
+                == MG_FORM_FIELD_STORAGE_ABORT) {
 				/* Stop parsing the request */
 				break;
 			}
@@ -397,13 +399,13 @@ mg_handle_form_request(struct mg_connection *conn,
 			                                        sizeof(path) - 1,
 			                                        fdh);
 
-			if ((field_storage & FORM_FIELD_STORAGE_ABORT)
-			    == FORM_FIELD_STORAGE_ABORT) {
+            if ((field_storage & MG_FORM_FIELD_STORAGE_ABORT)
+                == MG_FORM_FIELD_STORAGE_ABORT) {
 				/* Stop parsing the request */
 				break;
 			}
 
-			if (field_storage == FORM_FIELD_STORAGE_STORE) {
+            if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
 				if (mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &fstore) == 0) {
 					fstore.access.fp = NULL;
 				}
@@ -426,7 +428,7 @@ mg_handle_form_request(struct mg_connection *conn,
 					next = val + vallen;
 				}
 
-				if (field_storage == FORM_FIELD_STORAGE_GET) {
+                if (field_storage == MG_FORM_FIELD_STORAGE_GET) {
 #if 0
 					if (!end_of_key_value_pair_found && !all_data_read) {
 						/* This callback will deliver partial contents */
@@ -806,7 +808,7 @@ mg_handle_form_request(struct mg_connection *conn,
 			                       boundary,
 			                       bl);
 
-			if (field_storage == FORM_FIELD_STORAGE_STORE) {
+            if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
 				/* Store the content to a file */
 				if (mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &fstore) == 0) {
 					fstore.access.fp = NULL;
@@ -828,7 +830,7 @@ mg_handle_form_request(struct mg_connection *conn,
 				 * in the buffer. */
 				towrite -= bl + 4;
 
-				if (field_storage == FORM_FIELD_STORAGE_GET) {
+                if (field_storage == MG_FORM_FIELD_STORAGE_GET) {
 					unencoded_field_get(conn,
 					                    ((get_block > 0) ? NULL : nbeg),
 					                    ((get_block > 0)
@@ -840,7 +842,7 @@ mg_handle_form_request(struct mg_connection *conn,
 					get_block++;
 				}
 
-				if (field_storage == FORM_FIELD_STORAGE_STORE) {
+                if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
 					if (fstore.access.fp) {
 
 						/* Store the content of the buffer. */
@@ -884,7 +886,7 @@ mg_handle_form_request(struct mg_connection *conn,
 
 			towrite = (size_t)(next - hend);
 
-			if (field_storage == FORM_FIELD_STORAGE_GET) {
+            if (field_storage == MG_FORM_FIELD_STORAGE_GET) {
 				/* Call callback */
 				unencoded_field_get(conn,
 				                    ((get_block > 0) ? NULL : nbeg),
@@ -895,7 +897,7 @@ mg_handle_form_request(struct mg_connection *conn,
 				                    fdh);
 			}
 
-			if (field_storage == FORM_FIELD_STORAGE_STORE) {
+            if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
 
 				if (fstore.access.fp) {
 					n = (size_t)fwrite(hend, 1, towrite, fstore.access.fp);
@@ -924,8 +926,8 @@ mg_handle_form_request(struct mg_connection *conn,
 				}
 			}
 
-			if ((field_storage & FORM_FIELD_STORAGE_ABORT)
-			    == FORM_FIELD_STORAGE_ABORT) {
+            if ((field_storage & MG_FORM_FIELD_STORAGE_ABORT)
+                == MG_FORM_FIELD_STORAGE_ABORT) {
 				/* Stop parsing the request */
 				break;
 			}

src/main.c

@@ -175,10 +175,10 @@ static struct tuser_data
 enum { OPTION_TITLE, OPTION_ICON, OPTION_WEBPAGE, NUM_MAIN_OPTIONS };
 
 static struct mg_option main_config_options[] = {
-    {"title", CONFIG_TYPE_STRING, NULL},
-    {"icon", CONFIG_TYPE_STRING, NULL},
-    {"website", CONFIG_TYPE_STRING, NULL},
-    {NULL, CONFIG_TYPE_UNKNOWN, NULL}};
+    {"title", MG_CONFIG_TYPE_STRING, NULL},
+    {"icon", MG_CONFIG_TYPE_STRING, NULL},
+    {"website", MG_CONFIG_TYPE_STRING, NULL},
+    {NULL, MG_CONFIG_TYPE_UNKNOWN, NULL}};
 
 
 static void WINCDECL
@@ -241,6 +241,8 @@ show_usage_and_exit(const char *exeName)
 	fprintf(stderr, "  Start server with a set of options:\n");
 	fprintf(stderr, "    %s [config_file]\n", exeName);
 	fprintf(stderr, "    %s [-option value ...]\n", exeName);
+	fprintf(stderr, "  Run as client:\n");
+	fprintf(stderr, "    %s -C\n", exeName);
 	fprintf(stderr, "  Show system information:\n");
 	fprintf(stderr, "    %s -I\n", exeName);
 	fprintf(stderr, "  Add user/change password:\n");
@@ -277,7 +279,7 @@ show_usage_and_exit(const char *exeName)
 
 #if defined(_WIN32) || defined(USE_COCOA)
 static const char *config_file_top_comment =
-    "# Civetweb web server configuration file.\n"
+    "# CivetWeb web server configuration file.\n"
     "# For detailed description of every option, visit\n"
     "# https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md\n"
     "# Lines starting with '#' and empty lines are ignored.\n"
@@ -527,47 +529,47 @@ set_option(char **options, const char *name, const char *value)
 		}
 	}
 
-	type = CONFIG_TYPE_UNKNOWN;
+    type = MG_CONFIG_TYPE_UNKNOWN;
 	for (i = 0; default_options[i].name != NULL; i++) {
 		if (!strcmp(default_options[i].name, name)) {
 			type = default_options[i].type;
 		}
 	}
 	switch (type) {
-	case CONFIG_TYPE_UNKNOWN:
+    case MG_CONFIG_TYPE_UNKNOWN:
 		/* unknown option */
 		return 0;
-	case CONFIG_TYPE_NUMBER:
+    case MG_CONFIG_TYPE_NUMBER:
 		/* integer number >= 0, e.g. number of threads */
 		if (atol(value) < 0) {
 			/* invalid number */
 			return 0;
 		}
 		break;
-	case CONFIG_TYPE_STRING:
+    case MG_CONFIG_TYPE_STRING:
 		/* any text */
 		break;
-	case CONFIG_TYPE_STRING_LIST:
+    case MG_CONFIG_TYPE_STRING_LIST:
 		/* list of text items, separated by , */
 		multi_sep = ",";
 		break;
-	case CONFIG_TYPE_STRING_MULTILINE:
+    case MG_CONFIG_TYPE_STRING_MULTILINE:
 		/* lines of text, separated by carriage return line feed */
 		multi_sep = "\r\n";
 		break;
-	case CONFIG_TYPE_BOOLEAN:
+    case MG_CONFIG_TYPE_BOOLEAN:
 		/* boolean value, yes or no */
 		if ((0 != strcmp(value, "yes")) && (0 != strcmp(value, "no"))) {
 			/* invalid boolean */
 			return 0;
 		}
 		break;
-	case CONFIG_TYPE_FILE:
-	case CONFIG_TYPE_DIRECTORY:
+    case MG_CONFIG_TYPE_FILE:
+    case MG_CONFIG_TYPE_DIRECTORY:
 		/* TODO (low): check this option when it is set, instead of calling
 		 * verify_existence later */
 		break;
-	case CONFIG_TYPE_EXT_PATTERN:
+    case MG_CONFIG_TYPE_EXT_PATTERN:
 		/* list of patterns, separated by | */
 		multi_sep = "|";
 		break;
@@ -988,6 +990,25 @@ finished:
 #endif
 
 
+static int
+run_client(const char *url)
+{
+	int is_ssl = 0;
+	if (!strncmp(url, "http://", 7)) {
+		url += 7;
+	} else if (!strncmp(url, "https://", 8)) {
+		url += 8;
+		is_ssl = 1;
+	} else {
+		fprintf(stderr, "URL must start with http:// or https://\n");
+		return 0;
+	}
+
+
+	return 1;
+}
+
+
 static void
 start_civetweb(int argc, char *argv[])
 {
@@ -1033,6 +1054,15 @@ start_civetweb(int argc, char *argv[])
 		         : EXIT_FAILURE);
 	}
 
+	/* Client mode */
+	if (argc > 1 && !strcmp(argv[1], "-C")) {
+		if (argc != 3) {
+			show_usage_and_exit(argv[0]);
+		}
+
+		exit(run_client(argv[2]) ? EXIT_SUCCESS : EXIT_FAILURE);
+	}
+
 	/* Call Lua with additional CivetWeb specific Lua functions, if -L option
 	 * is specified */
 	if (argc > 1 && !strcmp(argv[1], "-L")) {

src/mod_lua.inl

@@ -1362,7 +1362,7 @@ lwebsock_write(lua_State *L)
 	if (num_args == 1) {
 		/* just one text: send it to all client */
 		if (lua_isstring(L, 1)) {
-			opcode = WEBSOCKET_OPCODE_TEXT;
+            opcode = MG_WEBSOCKET_OPCODE_TEXT;
 		}
 	} else if (num_args == 2) {
 		if (lua_isnumber(L, 1)) {
@@ -1372,21 +1372,21 @@ lwebsock_write(lua_State *L)
 			/* opcode string and message text */
 			str = lua_tostring(L, 1);
 			if (!mg_strncasecmp(str, "text", 4))
-				opcode = WEBSOCKET_OPCODE_TEXT;
+                opcode = MG_WEBSOCKET_OPCODE_TEXT;
 			else if (!mg_strncasecmp(str, "bin", 3))
-				opcode = WEBSOCKET_OPCODE_BINARY;
+                opcode = MG_WEBSOCKET_OPCODE_BINARY;
 			else if (!mg_strncasecmp(str, "close", 5))
-				opcode = WEBSOCKET_OPCODE_CONNECTION_CLOSE;
+                opcode = MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE;
 			else if (!mg_strncasecmp(str, "ping", 4))
-				opcode = WEBSOCKET_OPCODE_PING;
+                opcode = MG_WEBSOCKET_OPCODE_PING;
 			else if (!mg_strncasecmp(str, "pong", 4))
-				opcode = WEBSOCKET_OPCODE_PONG;
+                opcode = MG_WEBSOCKET_OPCODE_PONG;
 			else if (!mg_strncasecmp(str, "cont", 4))
-				opcode = WEBSOCKET_OPCODE_CONTINUATION;
+                opcode = MG_WEBSOCKET_OPCODE_CONTINUATION;
 		} else if (lua_isuserdata(L, 1)) {
 			/* client id and message text */
 			client = (struct mg_connection *)lua_touserdata(L, 1);
-			opcode = WEBSOCKET_OPCODE_TEXT;
+            opcode = MG_WEBSOCKET_OPCODE_TEXT;
 		}
 	} else if (num_args == 3) {
 		if (lua_isuserdata(L, 1)) {
@@ -1398,17 +1398,17 @@ lwebsock_write(lua_State *L)
 				/* client id, opcode string and message text */
 				str = lua_tostring(L, 2);
 				if (!mg_strncasecmp(str, "text", 4))
-					opcode = WEBSOCKET_OPCODE_TEXT;
+                    opcode = MG_WEBSOCKET_OPCODE_TEXT;
 				else if (!mg_strncasecmp(str, "bin", 3))
-					opcode = WEBSOCKET_OPCODE_BINARY;
+                    opcode = MG_WEBSOCKET_OPCODE_BINARY;
 				else if (!mg_strncasecmp(str, "close", 5))
-					opcode = WEBSOCKET_OPCODE_CONNECTION_CLOSE;
+                    opcode = MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE;
 				else if (!mg_strncasecmp(str, "ping", 4))
-					opcode = WEBSOCKET_OPCODE_PING;
+                    opcode = MG_WEBSOCKET_OPCODE_PING;
 				else if (!mg_strncasecmp(str, "pong", 4))
-					opcode = WEBSOCKET_OPCODE_PONG;
+                    opcode = MG_WEBSOCKET_OPCODE_PONG;
 				else if (!mg_strncasecmp(str, "cont", 4))
-					opcode = WEBSOCKET_OPCODE_CONTINUATION;
+                    opcode = MG_WEBSOCKET_OPCODE_CONTINUATION;
 			}
 		}
 	}