civetweb/src/main.c

/* Copyright (c) 2013-2021 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.
 */

#if defined(_WIN32)

#if !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS /* Disable deprecation warning in VS2005 */
#endif
#if !defined(_CRT_SECURE_NO_DEPRECATE)
#define _CRT_SECURE_NO_DEPRECATE
#endif
#if defined(WIN32_LEAN_AND_MEAN)
#undef WIN32_LEAN_AND_MEAN /* Required for some functions (tray icons, ...) */
#endif

#else

#if defined(__clang__) /* GCC does not (yet) support this pragma */
/* We must set some flags for the headers we include. These flags
 * are reserved ids according to C99, so we need to disable a
 * warning for that. */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreserved-id-macro"
#endif
#if !defined(_XOPEN_SOURCE)
#define _XOPEN_SOURCE 600 /* For PATH_MAX on linux */
/* This should also be sufficient for "realpath", according to
 * http://man7.org/linux/man-pages/man3/realpath.3.html, but in
 * reality it does not seem to work. */
/* In case this causes a problem, disable the warning:
 * #pragma GCC diagnostic ignored "-Wimplicit-function-declaration"
 * #pragma clang diagnostic ignored "-Wimplicit-function-declaration"
 */
#endif
#endif

#if !defined(IGNORE_UNUSED_RESULT)
#define IGNORE_UNUSED_RESULT(a) ((void)((a) && 1))
#endif

#if defined(__cplusplus) && (__cplusplus >= 201103L)
#define NO_RETURN [[noreturn]]
#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
#define NO_RETURN _Noreturn
#elif defined(__GNUC__)
#define NO_RETURN __attribute((noreturn))
#else
#define NO_RETURN
#endif

/* Use same defines as in civetweb.c before including system headers. */
#if !defined(_LARGEFILE_SOURCE)
#define _LARGEFILE_SOURCE /* For fseeko(), ftello() */
#endif
#if !defined(_FILE_OFFSET_BITS)
#define _FILE_OFFSET_BITS 64 /* Use 64-bit file offsets by default */
#endif
#if !defined(__STDC_FORMAT_MACROS)
#define __STDC_FORMAT_MACROS /* <inttypes.h> wants this for C++ */
#endif
#if !defined(__STDC_LIMIT_MACROS)
#define __STDC_LIMIT_MACROS /* C++ wants that for INT64_MAX */
#endif

#if defined(__clang__)
/* Enable reserved-id-macro warning again. */
#pragma GCC diagnostic pop
#endif

#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#include "civetweb.h"

#undef printf
#define printf                                                                 \
	DO_NOT_USE_THIS_FUNCTION__USE_fprintf /* Required for unit testing */

#if defined(_WIN32) /* WINDOWS include block */
#if !defined(_WIN32_WINNT)
#define _WIN32_WINNT 0x0501 /* for tdm-gcc so we can use getconsolewindow */
#endif
#undef UNICODE
#include <io.h>
#include <shlobj.h>
#include <windows.h>
#include <winsvc.h>

#define getcwd(a, b) (_getcwd(a, b))
#if !defined(__MINGW32__)
extern char *_getcwd(char *buf, size_t size);
#endif

#if !defined(PATH_MAX)
#define PATH_MAX MAX_PATH
#endif

#if !defined(S_ISDIR)
#define S_ISDIR(x) ((x)&_S_IFDIR)
#endif

#define DIRSEP '\\'
#define snprintf _snprintf
#define vsnprintf _vsnprintf
#define sleep(x) (Sleep((x)*1000))
#define WINCDECL __cdecl
#define abs_path(rel, abs, abs_size) (_fullpath((abs), (rel), (abs_size)))

#else /* defined(_WIN32) - WINDOWS / UNIX include                              \
         block */

#include <sys/utsname.h>
#include <sys/wait.h>
#include <unistd.h>

#define DIRSEP '/'
#define WINCDECL
#define abs_path(rel, abs, abs_size) (realpath((rel), (abs)))

#endif /* defined(_WIN32) - WINDOWS / UNIX include                             \
          block */

#if !defined(DEBUG_ASSERT)
#if defined(DEBUG)

#if defined(_MSC_VER)
/* DEBUG_ASSERT has some const conditions */
#pragma warning(disable : 4127)
#endif

#define DEBUG_ASSERT(cond)                                                     \
	do {                                                                       \
		if (!(cond)) {                                                         \
			fprintf(stderr, "ASSERTION FAILED: %s", #cond);                    \
			exit(2); /* Exit with error */                                     \
		}                                                                      \
	} while (0)

#else
#define DEBUG_ASSERT(cond)
#endif /* DEBUG */
#endif

#if !defined(PATH_MAX)
#define PATH_MAX (1024)
#endif

#define MAX_OPTIONS (50)
#define MAX_CONF_FILE_LINE_SIZE (8 * 1024)

struct tuser_data {
	char *first_message;
};


/* Exit flag for the main loop (read and writen by different threads, thus
 * volatile). */
volatile int g_exit_flag = 0; /* 0 = continue running main loop */


static char g_server_base_name[40]; /* Set by init_server_name() */

static const char *g_server_name; /* Default from init_server_name,
                                   * updated later from the server config */
static const char *g_icon_name;   /* Default from init_server_name,
                                   * updated later from the server config */
static const char *g_website;     /* Default from init_server_name,
                                   * updated later from the server config */
static int g_num_add_domains;     /* Default from init_server_name,
                                   * updated later from the server config */
static const char **g_add_domain; /* Default from init_server_name,
                                   * updated later from the server config */
static int g_hide_tray = 0;       /* Default = do not hide (0),
                                   * updated later from the server config */

static char *g_system_info; /* Set by init_system_info() */
static char g_config_file_name[PATH_MAX] =
    ""; /* Set by
         *  process_command_line_arguments() */

static struct mg_context *g_ctx; /* Set by start_civetweb() */
static struct tuser_data
    g_user_data; /* Passed to mg_start() by start_civetweb() */

#if !defined(CONFIG_FILE)
#define CONFIG_FILE "civetweb.conf"
#endif /* !CONFIG_FILE */

#if !defined(PASSWORDS_FILE_NAME)
#define PASSWORDS_FILE_NAME ".htpasswd"
#endif

/* backup config file */
#if !defined(CONFIG_FILE2) && defined(__linux__)
#define CONFIG_FILE2 "/usr/local/etc/civetweb.conf"
#endif

enum {
	OPTION_TITLE,
	OPTION_ICON,
	OPTION_WEBPAGE,
	OPTION_ADD_DOMAIN,
	OPTION_HIDE_TRAY,
#if defined(DAEMONIZE)
	ENABLE_DAEMONIZE,
#endif

	NUM_MAIN_OPTIONS
};

static struct mg_option main_config_options[] = {
    {"title", MG_CONFIG_TYPE_STRING, NULL},
    {"icon", MG_CONFIG_TYPE_STRING, NULL},
    {"website", MG_CONFIG_TYPE_STRING, NULL},
    {"add_domain", MG_CONFIG_TYPE_STRING_LIST, NULL},
    {"hide_tray", MG_CONFIG_TYPE_BOOLEAN, NULL},
#if defined(DAEMONIZE)
    {"daemonize", MG_CONFIG_TYPE_BOOLEAN, "no"},
#endif

    {NULL, MG_CONFIG_TYPE_UNKNOWN, NULL}};


static void WINCDECL
signal_handler(int sig_num)
{
	g_exit_flag = sig_num;
}


static NO_RETURN void
die(const char *fmt, ...)
{
	va_list ap;
	char msg[512] = "";

	va_start(ap, fmt);
	(void)vsnprintf(msg, sizeof(msg) - 1, fmt, ap);
	msg[sizeof(msg) - 1] = 0;
	va_end(ap);

#if defined(_WIN32)
	MessageBox(NULL, msg, "Error", MB_OK);
#else
	fprintf(stderr, "%s\n", msg);
#endif

	exit(EXIT_FAILURE);
}


static void
warn(const char *fmt, ...)
{
	va_list ap;
	char msg[512] = "";

	va_start(ap, fmt);
	(void)vsnprintf(msg, sizeof(msg) - 1, fmt, ap);
	msg[sizeof(msg) - 1] = 0;
	va_end(ap);

#if defined(_WIN32)
	MessageBox(NULL, msg, "Warning", MB_OK);
#else
	fprintf(stderr, "%s\n", msg);
#endif
}


#if defined(WIN32)
static int MakeConsole(void);
#endif


static void
show_server_name(void)
{
#if defined(BUILD_DATE)
	const char *bd = BUILD_DATE;
#else
	const char *bd = __DATE__;
#endif
#if defined(WIN32)
	(void)MakeConsole();
#endif

	fprintf(stderr, "CivetWeb v%s, built on %s\n", mg_version(), bd);
}


static NO_RETURN void
show_usage_and_exit(const char *exeName)
{
	const struct mg_option *options;
	int i;

	if (exeName == 0 || *exeName == 0) {
		exeName = "civetweb";
	}

	show_server_name();

	fprintf(stderr, "\nUsage:\n");
	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 url\n", exeName);
	fprintf(stderr, "  Show system information:\n");
	fprintf(stderr, "    %s -I\n", exeName);
	fprintf(stderr, "  Add user/change password:\n");
	fprintf(stderr,
	        "    %s -A <htpasswd_file> <realm> <user> <passwd>\n",
	        exeName);
	fprintf(stderr, "  Remove user:\n");
	fprintf(stderr, "    %s -R <htpasswd_file> <realm> <user>\n", exeName);
	fprintf(stderr, "\nOPTIONS:\n");

	options = mg_get_valid_options();
	for (i = 0; options[i].name != NULL; i++) {
		fprintf(stderr,
		        "  -%s %s\n",
		        options[i].name,
		        ((options[i].default_value == NULL)
		             ? "<empty>"
		             : options[i].default_value));
	}

	options = main_config_options;
	for (i = 0; options[i].name != NULL; i++) {
		fprintf(stderr,
		        "  -%s %s\n",
		        options[i].name,
		        ((options[i].default_value == NULL)
		             ? "<empty>"
		             : options[i].default_value));
	}

	exit(EXIT_FAILURE);
}


#if defined(_WIN32) || defined(USE_COCOA) || defined(MAIN_C_UNIT_TEST)
static const char *config_file_top_comment =
    "# 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"
    "# To make changes, remove leading '#', modify option values,\n"
    "# save this file and then restart CivetWeb.\n\n";

static const char *
get_url_to_first_open_port(const struct mg_context *ctx)
{
	static char url[128];

#define MAX_PORT_COUNT (32)

	struct mg_server_port ports[MAX_PORT_COUNT];
	int portNum = mg_get_server_ports(ctx, MAX_PORT_COUNT, ports);
	int i;

	memset(url, 0, sizeof(url));

	/* Prefer IPv4 http, ignore redirects */
	for (i = 0; i < portNum; i++) {
		if ((ports[i].protocol == 1) && (ports[i].is_redirect == 0)
		    && (ports[i].is_ssl == 0)) {
			snprintf(url, sizeof(url), "http://localhost:%d/", ports[i].port);
			return url;
		}
	}
	/* Use IPv4 https */
	for (i = 0; i < portNum; i++) {
		if ((ports[i].protocol == 1) && (ports[i].is_redirect == 0)
		    && (ports[i].is_ssl == 1)) {
			snprintf(url, sizeof(url), "https://localhost:%d/", ports[i].port);
			return url;
		}
	}
	/* Try IPv6 http, ignore redirects */
	if (portNum > 0) {
		snprintf(url,
		         sizeof(url),
		         "%s://localhost:%d/",
		         (ports[0].is_ssl ? "https" : "http"),
		         ports[0].port);
	}

#undef MAX_PORT_COUNT

	return url;
}


#if defined(ENABLE_CREATE_CONFIG_FILE) || defined(MAIN_C_UNIT_TEST)
static void
create_config_file(const struct mg_context *ctx, const char *path)
{
	const struct mg_option *options;
	const char *value;
	FILE *fp;
	int i;

	/* Create config file if it is not present yet */
	if ((fp = fopen(path, "r")) != NULL) {
		fclose(fp);
	} else if ((fp = fopen(path, "a+")) != NULL) {
		fprintf(fp, "%s", config_file_top_comment);
		options = mg_get_valid_options();
		for (i = 0; options[i].name != NULL; i++) {
			value = mg_get_option(ctx, options[i].name);
			fprintf(fp,
			        "# %s %s\n",
			        options[i].name,
			        value ? value : "<value>");
		}
		fclose(fp);
	}
}
#endif
#endif


static char *
sdup(const char *str)
{
	size_t len;
	char *p;

	len = strlen(str) + 1;
	p = (char *)malloc(len);

	if (p == NULL) {
		die("Cannot allocate %u bytes", (unsigned)len);
	}

	memcpy(p, str, len);
	return p;
}


#if 0 /* Unused code from "string duplicate with escape" */
static unsigned
hex2dec(char x)
{
    if ((x >= '0') && (x <= '9')) {
        return (unsigned)x - (unsigned)'0';
    }
    if ((x >= 'A') && (x <= 'F')) {
        return (unsigned)x - (unsigned)'A' + 10u;
    }
    if ((x >= 'a') && (x <= 'f')) {
        return (unsigned)x - (unsigned)'a' + 10u;
    }
    return 0;
}


static char *
sdupesc(const char *str)
{
	char *p = sdup(str);

	if (p) {
		char *d = p;
		while ((d = strchr(d, '\\')) != NULL) {
			switch (d[1]) {
			case 'a':
				d[0] = '\a';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case 'b':
				d[0] = '\b';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case 'e':
				d[0] = 27;
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case 'f':
				d[0] = '\f';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case 'n':
				d[0] = '\n';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case 'r':
				d[0] = '\r';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case 't':
				d[0] = '\t';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case 'u':
				if (isxdigit(d[2]) && isxdigit(d[3]) && isxdigit(d[4])
				    && isxdigit(d[5])) {
					unsigned short u = (unsigned short)(hex2dec(d[2]) * 4096
					                                    + hex2dec(d[3]) * 256
					                                    + hex2dec(d[4]) * 16
					                                    + hex2dec(d[5]));
					char mbc[16];
					int mbl = wctomb(mbc, (wchar_t)u);
					if ((mbl > 0) && (mbl < 6)) {
						memcpy(d, mbc, (unsigned)mbl);
						memmove(d + mbl, d + 6, strlen(d + 5));
						/* Advance mbl characters (+1 is below) */
						d += (mbl - 1);
					} else {
						/* Invalid multi byte character */
						/* TODO: define what to do */
					}
				} else {
					/* Invalid esc sequence */
					/* TODO: define what to do */
				}
				break;
			case 'v':
				d[0] = '\v';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case 'x':
				if (isxdigit(d[2]) && isxdigit(d[3])) {
					d[0] = (char)((unsigned char)(hex2dec(d[2]) * 16
					                              + hex2dec(d[3])));
					memmove(d + 1, d + 4, strlen(d + 3));
				} else {
					/* Invalid esc sequence */
					/* TODO: define what to do */
				}
				break;
			case 'z':
				d[0] = 0;
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case '\\':
				d[0] = '\\';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case '\'':
				d[0] = '\'';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case '\"':
				d[0] = '\"';
				memmove(d + 1, d + 2, strlen(d + 1));
				break;
			case 0:
				if (d == p) {
					/* Line is only \ */
					free(p);
					return NULL;
				}
			/* no break */
			default:
				/* invalid ESC sequence */
				/* TODO: define what to do */
				break;
			}

			/* Advance to next character */
			d++;
		}
	}
	return p;
}
#endif


static const char *
get_option(char **options, const char *option_name)
{
	int i = 0;
	const char *opt_value = NULL;

	/* TODO (low, api makeover): options should be an array of key-value-pairs,
	 * like
	 *     struct {const char * key, const char * value} options[]
	 * but it currently is an array with
	 *     options[2*i] = key, options[2*i + 1] = value
	 * (probably with a MG_LEGACY_INTERFACE definition)
	 */
	while (options[2 * i] != NULL) {
		if (strcmp(options[2 * i], option_name) == 0) {
			opt_value = options[2 * i + 1];
			break;
		}
		i++;
	}
	return opt_value;
}


static int
set_option(char **options, const char *name, const char *value)
{
	int i, type;
	const struct mg_option *default_options = mg_get_valid_options();
	const char *multi_sep = NULL;

	for (i = 0; main_config_options[i].name != NULL; i++) {
		/* These options are evaluated by main.c, not civetweb.c.
		 * Do not add it to options, and return OK */
		if (!strcmp(name, main_config_options[OPTION_TITLE].name)) {
			g_server_name = sdup(value);
			return 1;
		}
		if (!strcmp(name, main_config_options[OPTION_ICON].name)) {

			g_icon_name = sdup(value);
			return 1;
		}
		if (!strcmp(name, main_config_options[OPTION_WEBPAGE].name)) {
			g_website = sdup(value);
			return 1;
		}
		if (!strcmp(name, main_config_options[OPTION_HIDE_TRAY].name)) {
			if (!strcmp(value, "yes")) {
				g_hide_tray = 1;
			} else if (!strcmp(value, "no")) {
				g_hide_tray = 0;
			}
			return 1;
		}
		if (!strcmp(name, main_config_options[OPTION_ADD_DOMAIN].name)) {
			if (g_num_add_domains > 0) {
				g_add_domain = (const char **)realloc(
				    (void *)g_add_domain,
				    sizeof(char *) * ((unsigned)g_num_add_domains + 1u));
				if (!g_add_domain) {
					die("Out of memory");
				}
				g_add_domain[g_num_add_domains] = sdup(value);
				g_num_add_domains++;
			} else {
				g_add_domain = (const char **)malloc(sizeof(char *));
				if (!g_add_domain) {
					die("Out of memory");
				}
				g_add_domain[0] = sdup(value);
				g_num_add_domains = 1;
			}
			return 1;
		}
	}

	/* Not an option of main.c, so check if it is a CivetWeb server option */
	type = MG_CONFIG_TYPE_UNKNOWN; /* type "unknown" means "option not found" */
	for (i = 0; default_options[i].name != NULL; i++) {
		if (!strcmp(default_options[i].name, name)) {
			type = default_options[i].type;
			break; /* no need to search for another option */
		}
	}

	switch (type) {

	case MG_CONFIG_TYPE_UNKNOWN:
		/* unknown option */
		return 0; /* return error */

	case MG_CONFIG_TYPE_NUMBER:
		/* integer number >= 0, e.g. number of threads */
		{
			char *chk = 0;
			unsigned long num = strtoul(value, &chk, 10);
			(void)num; /* do not check value, only syntax */
			if ((chk == NULL) || (*chk != 0) || (chk == value)) {
				/* invalid number */
				return 0;
			}
		}
		break;

	case MG_CONFIG_TYPE_STRING:
		/* any text */
		break;

	case MG_CONFIG_TYPE_STRING_LIST:
		/* list of text items, separated by , */
		multi_sep = ",";
		break;

	case MG_CONFIG_TYPE_STRING_MULTILINE:
		/* lines of text, separated by carriage return line feed */
		multi_sep = "\r\n";
		break;

	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 MG_CONFIG_TYPE_YES_NO_OPTIONAL:
		/* boolean value, yes or no */
		if ((0 != strcmp(value, "yes")) && (0 != strcmp(value, "no"))
		    && (0 != strcmp(value, "optional"))) {
			/* invalid boolean */
			return 0;
		}
		break;

	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 MG_CONFIG_TYPE_EXT_PATTERN:
		/* list of patterns, separated by | */
		multi_sep = "|";
		break;

	default:
		die("Unknown option type - option %s", name);
	}

	for (i = 0; i < MAX_OPTIONS; i++) {
		if (options[2 * i] == NULL) {
			/* Option not set yet. Add new option */
			options[2 * i] = sdup(name);
			options[2 * i + 1] = sdup(value);
			options[2 * i + 2] = NULL;
			break;
		} else if (!strcmp(options[2 * i], name)) {
			if (multi_sep) {
				/* Option already set. Append new value. */
				char *s =
				    (char *)malloc(strlen(options[2 * i + 1])
				                   + strlen(multi_sep) + strlen(value) + 1);
				if (!s) {
					die("Out of memory");
				}
				sprintf(s, "%s%s%s", options[2 * i + 1], multi_sep, value);
				free(options[2 * i + 1]);
				options[2 * i + 1] = s;
			} else {
				/* Option already set. Overwrite */
				free(options[2 * i + 1]);
				options[2 * i + 1] = sdup(value);
			}
			break;
		}
	}

	if (i == MAX_OPTIONS) {
		die("Too many options specified");
	}

	if (options[2 * i] == NULL) {
		die("Out of memory");
	}
	if (options[2 * i + 1] == NULL) {
		die("Illegal escape sequence, or out of memory");
	}

	/* option set correctly */
	return 1;
}


static int
read_config_file(const char *config_file, char **options)
{
	char line[MAX_CONF_FILE_LINE_SIZE], *p;
	FILE *fp = NULL;
	size_t i, j, line_no = 0;

	/* Open the config file */
	fp = fopen(config_file, "r");
	if (fp == NULL) {
		/* Failed to open the file. Keep errno for the caller. */
		return 0;
	}

	/* Load config file settings first */
	fprintf(stdout, "Loading config file %s\n", config_file);

	/* Loop over the lines in config file */
	while (fgets(line, sizeof(line), fp) != NULL) {

		if (!line_no && !memcmp(line, "\xEF\xBB\xBF", 3)) {
			/* strip UTF-8 BOM */
			p = line + 3;
		} else {
			p = line;
		}
		line_no++;

		/* Ignore empty lines and comments */
		for (i = 0; isspace((unsigned char)p[i]);)
			i++;
		if (p[i] == '#' || p[i] == '\0') {
			continue;
		}

		/* Skip spaces, \r and \n at the end of the line */
		for (j = strlen(p); (j > 0)
		                    && (isspace((unsigned char)p[j - 1])
		                        || iscntrl((unsigned char)p[j - 1]));)
			p[--j] = 0;

		/* Find the space character between option name and value */
		for (j = i; !isspace((unsigned char)p[j]) && (p[j] != 0);)
			j++;

		/* Terminate the string - then the string at (p+i) contains the
		 * option name */
		p[j] = 0;
		j++;

		/* Trim additional spaces between option name and value - then
		 * (p+j) contains the option value */
		while (isspace((unsigned char)p[j])) {
			j++;
		}

		/* Set option */
		if (!set_option(options, p + i, p + j)) {
			fprintf(stderr,
			        "%s: line %d is invalid, ignoring it:\n %s",
			        config_file,
			        (int)line_no,
			        p);
		}
	}

	(void)fclose(fp);

	return 1;
}


static void
process_command_line_arguments(int argc, char *argv[], char **options)
{
	char *p;
	size_t i, cmd_line_opts_start = 1;
#if defined(CONFIG_FILE2)
	FILE *fp = NULL;
#endif

	/* Should we use a config file ? */
	if ((argc > 1) && (argv[1] != NULL) && (argv[1][0] != '-')
	    && (argv[1][0] != 0)) {
		/* The first command line parameter is a config file name. */
		snprintf(g_config_file_name,
		         sizeof(g_config_file_name) - 1,
		         "%s",
		         argv[1]);
		cmd_line_opts_start = 2;
	} else if ((p = strrchr(argv[0], DIRSEP)) == NULL) {
		/* No config file set. No path in arg[0] found.
		 * Use default file name in the current path. */
		snprintf(g_config_file_name,
		         sizeof(g_config_file_name) - 1,
		         "%s",
		         CONFIG_FILE);
	} else {
		/* No config file set. Path to exe found in arg[0].
		 * Use default file name next to the executable. */
		snprintf(g_config_file_name,
		         sizeof(g_config_file_name) - 1,
		         "%.*s%c%s",
		         (int)(p - argv[0]),
		         argv[0],
		         DIRSEP,
		         CONFIG_FILE);
	}
	g_config_file_name[sizeof(g_config_file_name) - 1] = 0;

#if defined(CONFIG_FILE2)
	fp = fopen(g_config_file_name, "r");

	/* try alternate config file */
	if (fp == NULL) {
		fp = fopen(CONFIG_FILE2, "r");
		if (fp != NULL) {
			strcpy(g_config_file_name, CONFIG_FILE2);
		}
	}
	if (fp != NULL) {
		fclose(fp);
	}
#endif

	/* read all configurations from a config file */
	if (0 == read_config_file(g_config_file_name, options)) {
		if (cmd_line_opts_start == 2) {
			/* If config file was set in command line and open failed, die. */
			/* Errno will still hold the error from fopen. */
			die("Cannot open config file %s: %s",
			    g_config_file_name,
			    strerror(errno));
		}
		/* Otherwise: CivetWeb can work without a config file */
	}

	/* If we're under MacOS and started by launchd, then the second
	   argument is process serial number, -psn_.....
	   In this case, don't process arguments at all. */
	if (argv[1] == NULL || memcmp(argv[1], "-psn_", 5) != 0) {
		/* Handle command line flags.
		   They override config file and default settings. */
		for (i = cmd_line_opts_start; argv[i] != NULL; i += 2) {
			if (argv[i][0] != '-' || argv[i + 1] == NULL) {
				show_usage_and_exit(argv[0]);
			}
			if (!set_option(options, &argv[i][1], argv[i + 1])) {
				fprintf(
				    stderr,
				    "command line option is invalid, ignoring it:\n %s %s\n",
				    argv[i],
				    argv[i + 1]);
			}
		}
	}
}


static void
init_system_info(void)
{
	int len = mg_get_system_info(NULL, 0);
	if (len > 0) {
		g_system_info = (char *)malloc((unsigned)len + 1);
		(void)mg_get_system_info(g_system_info, len + 1);
	} else {
		g_system_info = sdup("Not available");
	}
}


static void
init_server_name(void)
{
	DEBUG_ASSERT(sizeof(main_config_options) / sizeof(main_config_options[0])
	             == NUM_MAIN_OPTIONS + 1);
	DEBUG_ASSERT((strlen(mg_version()) + 12) < sizeof(g_server_base_name));
	snprintf(g_server_base_name,
	         sizeof(g_server_base_name),
	         "CivetWeb V%s",
	         mg_version());
	g_server_name = g_server_base_name;
	g_icon_name = NULL;
	g_website = "http://civetweb.github.io/civetweb/";
	g_num_add_domains = 0;
	g_add_domain = NULL;
}


static void
free_system_info(void)
{
	free(g_system_info);
}


static int
log_message(const struct mg_connection *conn, const char *message)
{
	const struct mg_context *ctx = mg_get_context(conn);
	struct tuser_data *ud = (struct tuser_data *)mg_get_user_data(ctx);

	fprintf(stderr, "%s\n", message);

	if (ud->first_message == NULL) {
		ud->first_message = sdup(message);
	}

	return 0;
}


static int
is_path_absolute(const char *path)
{
#if defined(_WIN32)
	return path != NULL
	       && ((path[0] == '\\' && path[1] == '\\') || /* UNC path, e.g.
	                                                      \\server\dir */
	           (isalpha((unsigned char)path[0]) && path[1] == ':'
	            && path[2] == '\\')); /* E.g. X:\dir */
#else
	return path != NULL && path[0] == '/';
#endif
}


static int
verify_existence(char **options, const char *option_name, int must_be_dir)
{
	struct stat st;
	const char *path = get_option(options, option_name);

#if defined(_WIN32)
	wchar_t wbuf[1024];
	char mbbuf[1024];
	int len;

	if (path) {
		memset(wbuf, 0, sizeof(wbuf));
		memset(mbbuf, 0, sizeof(mbbuf));
		len = MultiByteToWideChar(
		    CP_UTF8, 0, path, -1, wbuf, sizeof(wbuf) / sizeof(wbuf[0]) - 1);
		wcstombs(mbbuf, wbuf, sizeof(mbbuf) - 1);
		path = mbbuf;
		(void)len;
	}
#endif

	if (path != NULL
	    && (stat(path, &st) != 0
	        || ((S_ISDIR(st.st_mode) ? 1 : 0) != must_be_dir))) {
		warn("Invalid path for %s: [%s]: (%s). Make sure that path is either "
		     "absolute, or it is relative to civetweb executable.",
		     option_name,
		     path,
		     strerror(errno));
		return 0;
	}
	return 1;
}


static void
set_absolute_path(char *options[],
                  const char *option_name,
                  const char *path_to_civetweb_exe)
{
	char path[PATH_MAX] = "", absolute[PATH_MAX] = "";
	const char *option_value;
	const char *p;

	/* Check whether option is already set */
	option_value = get_option(options, option_name);

	/* If option is already set and it is an absolute path,
	   leave it as it is -- it's already absolute. */
	if (option_value != NULL && !is_path_absolute(option_value)) {
		/* Not absolute. Use the directory where civetweb executable lives
		   be the relative directory for everything.
		   Extract civetweb executable directory into path. */
		if ((p = strrchr(path_to_civetweb_exe, DIRSEP)) == NULL) {
			IGNORE_UNUSED_RESULT(getcwd(path, sizeof(path)));
		} else {
			snprintf(path,
			         sizeof(path) - 1,
			         "%.*s",
			         (int)(p - path_to_civetweb_exe),
			         path_to_civetweb_exe);
			path[sizeof(path) - 1] = 0;
		}

		strncat(path, "/", sizeof(path) - strlen(path) - 1);
		strncat(path, option_value, sizeof(path) - strlen(path) - 1);

		/* Absolutize the path, and set the option */
		IGNORE_UNUSED_RESULT(abs_path(path, absolute, sizeof(absolute)));
		set_option(options, option_name, absolute);
	}
}


#if defined(USE_LUA)

#include "civetweb_private_lua.h"

#endif


#if defined(USE_DUKTAPE)

#include "duktape.h"

static int
run_duktape(const char *file_name)
{
	duk_context *ctx = NULL;

	ctx = duk_create_heap_default();
	if (!ctx) {
		fprintf(stderr, "Failed to create a Duktape heap.\n");
		goto finished;
	}

	if (duk_peval_file(ctx, file_name) != 0) {
		fprintf(stderr, "%s\n", duk_safe_to_string(ctx, -1));
		goto finished;
	}
	duk_pop(ctx); /* ignore result */

finished:
	duk_destroy_heap(ctx);

	return 0;
}
#endif


#if defined(__MINGW32__) || defined(__MINGW64__)
/* For __MINGW32/64_MAJOR/MINOR_VERSION define */
#include <_mingw.h>
#endif


static int
run_client(const char *url_arg)
{
	/* connection data */
	char *url = sdup(url_arg); /* OOM will cause program to exit */
	char *host;
	char *resource;
	int is_ssl = 0;
	unsigned long port = 0;
	size_t sep;
	char *endp = 0;
	char empty[] = "";

	/* connection object */
	struct mg_connection *conn;
	char ebuf[1024] = {0};

#if 0 /* Unreachable code, since sdup will never return NULL */
    /* Check out of memory */
    if (!url) {
        fprintf(stderr, "Out of memory\n");
        return 0;
    }
#endif

	/* Check parameter */
	if (!strncmp(url, "http://", 7)) {
		host = url + 7;
		port = 80;
	} else if (!strncmp(url, "https://", 8)) {
		host = url + 8;
		is_ssl = 1;
		port = 443;
	} else {
		fprintf(stderr, "URL must start with http:// or https://\n");
		free(url);
		return 0;
	}
	if ((host[0] <= 32) || (host[0] > 126) || (host[0] == '/')
	    || (host[0] == ':')) {
		fprintf(stderr, "Invalid host\n");
		free(url);
		return 0;
	}

	sep = strcspn(host, "/:");
	switch (host[sep]) {
	case 0:
		resource = empty;
		break;
	case '/':
		host[sep] = 0;
		resource = host + sep + 1;
		break;
	case ':':
		host[sep] = 0;
		port = strtoul(host + sep + 1, &endp, 10);
		if (!endp || (*endp != '/' && *endp != 0) || (port < 1)
		    || (port > 0xFFFF)) {
			fprintf(stderr, "Invalid port\n");
			free(url);
			return 0;
		}
		if (*endp) {
			*endp = 0;
			resource = endp + 1;
		} else {
			resource = empty;
		}
		break;
	default:
		fprintf(stderr, "Syntax error\n");
		free(url);
		return 0;
	}

	fprintf(stdout, "Protocol: %s\n", is_ssl ? "https" : "http");
	fprintf(stdout, "Host: %s\n", host);
	fprintf(stdout, "Port: %lu\n", port);
	fprintf(stdout, "Resource: %s\n", resource);

	/* Initialize library */
	if (is_ssl) {
		mg_init_library(MG_FEATURES_TLS);
	} else {
		mg_init_library(MG_FEATURES_DEFAULT);
	}

	/* Connect to host */
	conn = mg_connect_client(host, (int)port, is_ssl, ebuf, sizeof(ebuf));
	if (conn) {
		/* Connecting to server worked */
		char buf[1024] = {0};
		int ret;

		fprintf(stdout, "Connected to %s\n", host);

		/* Send GET request */
		mg_printf(conn,
		          "GET /%s HTTP/1.1\r\n"
		          "Host: %s\r\n"
		          "Connection: close\r\n"
		          "\r\n",
		          resource,
		          host);

		/* Wait for server to respond with a HTTP header */
		ret = mg_get_response(conn, ebuf, sizeof(ebuf), 10000);

		if (ret >= 0) {
			const struct mg_response_info *ri = mg_get_response_info(conn);

			fprintf(stdout,
			        "Response info: %i %s\n",
			        ri->status_code,
			        ri->status_text);

			/* Respond reader read. Read body (if any) */
			ret = mg_read(conn, buf, sizeof(buf));
			while (ret > 0) {
				fwrite(buf, 1, (unsigned)ret, stdout);
				ret = mg_read(conn, buf, sizeof(buf));
			}

			fprintf(stdout, "Closing connection to %s\n", host);

		} else {
			/* Server did not reply to HTTP request */
			fprintf(stderr, "Got no response from %s:\n%s\n", host, ebuf);
		}
		mg_close_connection(conn);

	} else {
		/* Connecting to server failed */
		fprintf(stderr, "Error connecting to %s:\n%s\n", host, ebuf);
	}

	/* Free memory and exit library */
	free(url);
	mg_exit_library();
	return 1;
}


static int
sanitize_options(char *options[] /* server options */,
                 const char *arg0 /* argv[0] */)
{
	int ok = 1;
	/* Make sure we have absolute paths for files and directories */
	set_absolute_path(options, "document_root", arg0);
	set_absolute_path(options, "put_delete_auth_file", arg0);
	set_absolute_path(options, "cgi_interpreter", arg0);
	set_absolute_path(options, "access_log_file", arg0);
	set_absolute_path(options, "error_log_file", arg0);
	set_absolute_path(options, "global_auth_file", arg0);
#if defined(USE_LUA)
	set_absolute_path(options, "lua_preload_file", arg0);
#endif
	set_absolute_path(options, "ssl_certificate", arg0);

	/* Make extra verification for certain options */
	if (!verify_existence(options, "document_root", 1))
		ok = 0;
	if (!verify_existence(options, "cgi_interpreter", 0))
		ok = 0;
	if (!verify_existence(options, "ssl_certificate", 0))
		ok = 0;
	if (!verify_existence(options, "ssl_ca_path", 1))
		ok = 0;
	if (!verify_existence(options, "ssl_ca_file", 0))
		ok = 0;
#if defined(USE_LUA)
	if (!verify_existence(options, "lua_preload_file", 0))
		ok = 0;
#endif
	return ok;
}


static void
start_civetweb(int argc, char *argv[])
{
	struct mg_callbacks callbacks;
	char *options[2 * MAX_OPTIONS + 1];
	int i;

	/* Start option -I:
	 * Show system information and exit
	 * This is very useful for diagnosis. */
	if (argc > 1 && !strcmp(argv[1], "-I")) {

#if defined(WIN32)
		(void)MakeConsole();
#endif
		fprintf(stdout,
		        "\n%s (%s)\n%s\n",
		        g_server_base_name,
		        g_server_name,
		        g_system_info);

		exit(EXIT_SUCCESS);
	}

	/* Edit passwords file: Add user or change password, if -A option is
	 * specified */
	if (argc > 1 && !strcmp(argv[1], "-A")) {
		if (argc != 6) {
			show_usage_and_exit(argv[0]);
		}
		exit(mg_modify_passwords_file(argv[2], argv[3], argv[4], argv[5])
		         ? EXIT_SUCCESS
		         : EXIT_FAILURE);
	}

	/* Edit passwords file: Remove user, if -R option is specified */
	if (argc > 1 && !strcmp(argv[1], "-R")) {
		if (argc != 5) {
			show_usage_and_exit(argv[0]);
		}
		exit(mg_modify_passwords_file(argv[2], argv[3], argv[4], NULL)
		         ? EXIT_SUCCESS
		         : 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")) {

#if defined(USE_LUA)
		if (argc != 3) {
			show_usage_and_exit(argv[0]);
		}
#if defined(WIN32)
		(void)MakeConsole();
#endif
		exit(run_lua(argv[2]));
#else
		show_server_name();
		fprintf(stderr, "\nError: Lua support not enabled\n");
		exit(EXIT_FAILURE);
#endif
	}

	/* Call Duktape, if -E option is specified */
	if (argc > 1 && !strcmp(argv[1], "-E")) {

#if defined(USE_DUKTAPE)
		if (argc != 3) {
			show_usage_and_exit(argv[0]);
		}
#if defined(WIN32)
		(void)MakeConsole();
#endif
		exit(run_duktape(argv[2]));
#else
		show_server_name();
		fprintf(stderr, "\nError: Ecmascript support not enabled\n");
		exit(EXIT_FAILURE);
#endif
	}

	/* Show usage if -h or --help options are specified */
	if (argc == 2
	    && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-H")
	        || !strcmp(argv[1], "--help"))) {
		show_usage_and_exit(argv[0]);
	}

	/* Initialize options structure */
	memset(options, 0, sizeof(options));
	set_option(options, "document_root", ".");

	/* Update config based on command line arguments */
	process_command_line_arguments(argc, argv, options);

	i = sanitize_options(options, argv[0]);
	if (!i) {
		die("Invalid options");
	}

	/* Setup signal handler: quit on Ctrl-C */
	signal(SIGTERM, signal_handler);
	signal(SIGINT, signal_handler);

#if defined(DAEMONIZE)
	/* Daemonize */
	for (i = 0; options[i] != NULL; i++) {
		if (strcmp(options[i], "daemonize") == 0) {
			if (options[i + 1] != NULL) {
				if (mg_strcasecmp(options[i + 1], "yes") == 0) {
					fprintf(stdout, "daemonize.\n");
					if (daemon(0, 0) != 0) {
						fprintf(stdout, "Faild to daemonize main process.\n");
						exit(EXIT_FAILURE);
					}
					FILE *fp;
					if ((fp = fopen(PID_FILE, "w")) == 0) {
						fprintf(stdout, "Can not open %s.\n", PID_FILE);
						exit(EXIT_FAILURE);
					}
					fprintf(fp, "%d", getpid());
					fclose(fp);
				}
			}
			break;
		}
	}
#endif

	/* Initialize user data */
	memset(&g_user_data, 0, sizeof(g_user_data));

	/* Start Civetweb */
	memset(&callbacks, 0, sizeof(callbacks));
	callbacks.log_message = &log_message;
	g_ctx = mg_start(&callbacks, &g_user_data, (const char **)options);

	/* mg_start copies all options to an internal buffer.
	 * The options data field here is not required anymore. */
	for (i = 0; options[i] != NULL; i++) {
		free(options[i]);
	}

	/* If mg_start fails, it returns NULL */
	if (g_ctx == NULL) {
		die("Failed to start %s:\n%s",
		    g_server_name,
		    ((g_user_data.first_message == NULL) ? "unknown reason"
		                                         : g_user_data.first_message));
		/* TODO: Edit file g_config_file_name */
	}

#if defined(MG_EXPERIMENTAL_INTERFACES)
	for (i = 0; i < g_num_add_domains; i++) {

		int j;
		memset(options, 0, sizeof(options));
		set_option(options, "document_root", ".");

		if (0 == read_config_file(g_add_domain[i], options)) {
			die("Cannot open config file %s: %s",
			    g_add_domain[i],
			    strerror(errno));
		}

		j = sanitize_options(options, argv[0]);
		if (!j) {
			die("Invalid options");
		}

		j = mg_start_domain(g_ctx, (const char **)options);
		if (j < 0) {
			die("Error loading domain file %s: %i", g_add_domain[i], j);
		} else {
			fprintf(stdout, "Domain file %s loaded\n", g_add_domain[i]);
		}

		for (j = 0; options[j] != NULL; j++) {
			free(options[j]);
		}
	}
#endif
}


static void
stop_civetweb(void)
{
	mg_stop(g_ctx);
	free(g_user_data.first_message);
	g_user_data.first_message = NULL;
}


#if defined(_WIN32)
/* Win32 has a small GUI.
 * Define some GUI elements and Windows message handlers. */

enum {
	ID_ICON = 100,
	ID_QUIT,
	ID_SETTINGS,
	ID_SEPARATOR,
	ID_INSTALL_SERVICE,
	ID_REMOVE_SERVICE,
	ID_STATIC,
	ID_GROUP,
	ID_PASSWORD,
	ID_SAVE,
	ID_RESET_DEFAULTS,
	ID_RESET_FILE,
	ID_RESET_ACTIVE,
	ID_STATUS,
	ID_CONNECT,
	ID_ADD_USER,
	ID_ADD_USER_NAME,
	ID_ADD_USER_REALM,
	ID_INPUT_LINE,
	ID_SYSINFO,
	ID_WEBSITE,

	/* All dynamically created text boxes for options have IDs starting from
   ID_CONTROLS, incremented by one. */
	ID_CONTROLS = 200,

	/* Text boxes for files have "..." buttons to open file browser. These
   buttons have IDs that are ID_FILE_BUTTONS_DELTA higher than associated
   text box ID. */
	ID_FILE_BUTTONS_DELTA = 1000
};


static HICON hIcon;
static SERVICE_STATUS ss;
static SERVICE_STATUS_HANDLE hStatus;
static const char *service_magic_argument = "--";
static NOTIFYICONDATA TrayIcon;
static UINT msg_taskbar_created;

static void WINAPI
ControlHandler(DWORD code)
{
	if (code == SERVICE_CONTROL_STOP || code == SERVICE_CONTROL_SHUTDOWN) {
		ss.dwWin32ExitCode = 0;
		ss.dwCurrentState = SERVICE_STOPPED;
	}
	SetServiceStatus(hStatus, &ss);
}


static void WINAPI
ServiceMain(void)
{
	ss.dwServiceType = SERVICE_WIN32;
	ss.dwCurrentState = SERVICE_RUNNING;
	ss.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;

	hStatus = RegisterServiceCtrlHandler(g_server_name, ControlHandler);
	SetServiceStatus(hStatus, &ss);

	while (ss.dwCurrentState == SERVICE_RUNNING) {
		Sleep(1000);
	}
	stop_civetweb();

	ss.dwCurrentState = SERVICE_STOPPED;
	ss.dwWin32ExitCode = (DWORD)-1;
	SetServiceStatus(hStatus, &ss);
}


static void
show_error(void)
{
	char buf[256];
	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
	              NULL,
	              GetLastError(),
	              MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
	              buf,
	              sizeof(buf),
	              NULL);
	MessageBox(NULL, buf, "Error", MB_OK);
}


static void
save_config(HWND hDlg, FILE *fp)
{
	char value[2000] = "";
	const char *default_value;
	const struct mg_option *options;
	int i, id;

	fprintf(fp, "%s", config_file_top_comment);
	options = mg_get_valid_options();
	for (i = 0; options[i].name != NULL; i++) {
		id = ID_CONTROLS + i;
		if (options[i].type == MG_CONFIG_TYPE_BOOLEAN) {
			snprintf(value,
			         sizeof(value) - 1,
			         "%s",
			         IsDlgButtonChecked(hDlg, id) ? "yes" : "no");
			value[sizeof(value) - 1] = 0;
		} else {
			GetDlgItemText(hDlg, id, value, sizeof(value));
		}
		default_value =
		    options[i].default_value == NULL ? "" : options[i].default_value;
		/* If value is the same as default, skip it */
		if (strcmp(value, default_value) != 0) {
			fprintf(fp, "%s %s\n", options[i].name, value);
		}
	}
}


/* LPARAM pointer passed to WM_INITDIALOG */
struct dlg_proc_param {
	int guard;
	HWND hWnd;
	const char *name;
	char *buffer;
	unsigned buflen;
	int idRetry;
	BOOL (*fRetry)(struct dlg_proc_param *data);
};

struct dlg_header_param {
	/* https://docs.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-dlgtemplate
	 */
	DLGTEMPLATE dlg_template; /* 18 bytes */
	WORD menu, dlg_class;
	wchar_t caption[1];
	WORD fontsize;
	wchar_t fontface[7]; /* L"Tahoma" = 6 characters + terminating zero */
};

/* complete data required to create a dialog including child elements */
struct dlg_complete {
	struct dlg_header_param header;
	/* TODO: if sizeof(header)%4 is not 0, add some filling bytes here */
	BYTE elements[4096 * 2];
	int used;
};


static void
FillDialogHeader(struct dlg_complete *dlg, const short width)
{
	memset(dlg, 0, sizeof(*dlg));

	dlg->header.dlg_template.style = WS_CAPTION | WS_POPUP | WS_SYSMENU
	                                 | WS_VISIBLE | DS_SETFONT | DS_CENTER
	                                 | WS_DLGFRAME;
	dlg->header.dlg_template.dwExtendedStyle = WS_EX_TOOLWINDOW;
	dlg->header.dlg_template.cdit = 0;
	dlg->header.dlg_template.x = 0; /* ignored by DS_CENTER */
	dlg->header.dlg_template.y = 0; /* ignored by DS_CENTER */
	dlg->header.dlg_template.cx = width;
	dlg->header.dlg_template.cy =
	    0; /* to be calculated after adding elements */
	dlg->header.menu = 0;
	dlg->header.dlg_class = 0;
	dlg->header.caption[0] = (wchar_t)0;
	dlg->header.fontsize = 8;
	wcscpy(dlg->header.fontface, L"Tahoma");

	/* counting used bytes */
	dlg->used = 0;
}


/* Dialog proc for settings dialog */
static INT_PTR CALLBACK
SettingsDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	FILE *fp;
	int i, j;
	const char *name, *value;
	const struct mg_option *default_options = mg_get_valid_options();
	char *file_options[MAX_OPTIONS * 2 + 1] = {0};
	char *title;
	struct dlg_proc_param *pdlg_proc_param;

	switch (msg) {

	case WM_CLOSE:
		DestroyWindow(hDlg);
		break;

	case WM_COMMAND:
		switch (LOWORD(wParam)) {

		case ID_SAVE:
			EnableWindow(GetDlgItem(hDlg, ID_SAVE), FALSE);
			if ((fp = fopen(g_config_file_name, "w+")) != NULL) {
				save_config(hDlg, fp);
				fclose(fp);
				stop_civetweb();
				start_civetweb(__argc, __argv);
			}
			EnableWindow(GetDlgItem(hDlg, ID_SAVE), TRUE);
			break;

		case ID_RESET_DEFAULTS:
			for (i = 0; default_options[i].name != NULL; i++) {
				name = default_options[i].name;
				value = default_options[i].default_value == NULL
				            ? ""
				            : default_options[i].default_value;
				if (default_options[i].type == MG_CONFIG_TYPE_BOOLEAN) {
					CheckDlgButton(hDlg,
					               ID_CONTROLS + i,
					               !strcmp(value, "yes") ? BST_CHECKED
					                                     : BST_UNCHECKED);
				} else {
					SetWindowText(GetDlgItem(hDlg, ID_CONTROLS + i), value);
				}
			}
			break;

		case ID_RESET_FILE:
			read_config_file(g_config_file_name, file_options);
			for (i = 0; default_options[i].name != NULL; i++) {
				name = default_options[i].name;
				value = default_options[i].default_value;
				for (j = 0; file_options[j * 2] != NULL; j++) {
					if (!strcmp(name, file_options[j * 2])) {
						value = file_options[j * 2 + 1];
					}
				}
				if (value == NULL) {
					value = "";
				}
				if (default_options[i].type == MG_CONFIG_TYPE_BOOLEAN) {
					CheckDlgButton(hDlg,
					               ID_CONTROLS + i,
					               !strcmp(value, "yes") ? BST_CHECKED
					                                     : BST_UNCHECKED);
				} else {
					SetWindowText(GetDlgItem(hDlg, ID_CONTROLS + i), value);
				}
			}
			for (i = 0; i < MAX_OPTIONS; i++) {
				free(file_options[2 * i]);
				free(file_options[2 * i + 1]);
			}
			break;

		case ID_RESET_ACTIVE:
			for (i = 0; default_options[i].name != NULL; i++) {
				name = default_options[i].name;
				value = mg_get_option(g_ctx, name);
				if (default_options[i].type == MG_CONFIG_TYPE_BOOLEAN) {
					CheckDlgButton(hDlg,
					               ID_CONTROLS + i,
					               !strcmp(value, "yes") ? BST_CHECKED
					                                     : BST_UNCHECKED);
				} else {
					SetDlgItemText(hDlg,
					               ID_CONTROLS + i,
					               value == NULL ? "" : value);
				}
			}
			break;
		}

		for (i = 0; default_options[i].name != NULL; i++) {
			name = default_options[i].name;
			if (((default_options[i].type == MG_CONFIG_TYPE_FILE)
			     || (default_options[i].type == MG_CONFIG_TYPE_DIRECTORY))
			    && LOWORD(wParam) == ID_CONTROLS + i + ID_FILE_BUTTONS_DELTA) {

				/* Result of the Dialog: File/Folder selected by user */
				char path[PATH_MAX] = "";

				if (default_options[i].type == MG_CONFIG_TYPE_DIRECTORY) {

					BROWSEINFO bi;
					memset(&bi, 0, sizeof(bi));
					bi.hwndOwner = (HWND)hDlg;
					bi.ulFlags = BIF_RETURNONLYFSDIRS;

					/* Use option name as Window title */
					bi.lpszTitle = name;

					SHGetPathFromIDList(SHBrowseForFolder(&bi), path);

				} else {

					OPENFILENAME of;
					memset(&of, 0, sizeof(of));
					of.lStructSize = sizeof(of);
					of.hwndOwner = (HWND)hDlg;
					of.lpstrFile = path;
					of.nMaxFile = sizeof(path);
					of.lpstrInitialDir = mg_get_option(g_ctx, "document_root");
					of.Flags =
					    OFN_CREATEPROMPT | OFN_NOCHANGEDIR | OFN_HIDEREADONLY;

					/* Use option name as Window title */
					of.lpstrTitle = name;

					GetOpenFileName(&of);
				}

				if (path[0] != '\0') {
					/* Something has been choosen */
					SetWindowText(GetDlgItem(hDlg, ID_CONTROLS + i), path);
				}
			}
		}
		break;

	case WM_INITDIALOG:
		/* Store hWnd in a parameter accessible by the parent, so we can
		 * bring this window to front if required. */
		pdlg_proc_param = (struct dlg_proc_param *)lParam;
		pdlg_proc_param->hWnd = hDlg;

		/* Initialize the dialog elements */
		SendMessage(hDlg, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)hIcon);
		SendMessage(hDlg, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM)hIcon);
		title = (char *)malloc(strlen(g_server_name) + 16);
		if (title) {
			strcpy(title, g_server_name);
			strcat(title, " settings");
			SetWindowText(hDlg, title);
			free(title);
		}
		SetFocus(GetDlgItem(hDlg, ID_SAVE));

		/* Init dialog with active settings */
		SendMessage(hDlg, WM_COMMAND, ID_RESET_ACTIVE, 0);
		/* alternative: SendMessage(hDlg, WM_COMMAND, ID_RESET_FILE, 0); */
		break;

	default:
		break;
	}

	return FALSE;
}


/* Dialog proc for input dialog */
static INT_PTR CALLBACK
InputDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	static struct dlg_proc_param *inBuf = 0;
	WORD ctrlId;
	HWND hIn;

	switch (msg) {
	case WM_CLOSE:
		inBuf = 0;
		DestroyWindow(hDlg);
		break;

	case WM_COMMAND:
		ctrlId = LOWORD(wParam);
		if (ctrlId == IDOK) {
			/* Get handle of input line */
			hIn = GetDlgItem(hDlg, ID_INPUT_LINE);

			if (hIn) {
				/* Get content of input line */
				GetWindowText(hIn, inBuf->buffer, (int)inBuf->buflen);
				if (inBuf->buffer[0] != 0) {
					/* Input dialog is not empty. */
					EndDialog(hDlg, IDOK);
				}
			} else {
				/* There is no input line in this dialog. */
				EndDialog(hDlg, IDOK);
			}

		} else if (ctrlId == IDRETRY) {

			/* Get handle of input line */
			hIn = GetDlgItem(hDlg, inBuf->idRetry);

			if (hIn) {
				/* Load current string */
				GetWindowText(hIn, inBuf->buffer, (int)inBuf->buflen);
				if (inBuf->fRetry) {
					if (inBuf->fRetry(inBuf)) {
						SetWindowText(hIn, inBuf->buffer);
					}
				}
			}

		} else if (ctrlId == IDCANCEL) {
			EndDialog(hDlg, IDCANCEL);
		}
		break;

	case WM_INITDIALOG:
		/* Get handle of input line */
		hIn = GetDlgItem(hDlg, ID_INPUT_LINE);

		/* Get dialog parameters */
		inBuf = (struct dlg_proc_param *)lParam;

		/* Set dialog handle for the caller */
		inBuf->hWnd = hDlg;

		/* Set dialog name */
		SetWindowText(hDlg, inBuf->name);

		if (hIn) {
			/* This is an input dialog */
			DEBUG_ASSERT(inBuf != NULL);
			DEBUG_ASSERT((inBuf->buffer != NULL) && (inBuf->buflen != 0));
			DEBUG_ASSERT(strlen(inBuf->buffer) < inBuf->buflen);
			SendMessage(hDlg, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)hIcon);
			SendMessage(hDlg, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM)hIcon);
			SendMessage(hIn, EM_LIMITTEXT, inBuf->buflen - 1, 0);
			SetWindowText(hIn, inBuf->buffer);
			SetFocus(hIn);
		}

		break;

	default:
		break;
	}

	return FALSE;
}


static void
suggest_passwd(char *passwd)
{
	unsigned u;
	char *p;
	union {
		FILETIME ft;
		LARGE_INTEGER li;
	} num;

	/* valid characters are 32 to 126 */
	GetSystemTimeAsFileTime(&num.ft);
	num.li.HighPart |= (LONG)GetCurrentProcessId();
	p = passwd;
	while (num.li.QuadPart) {
		u = (unsigned)(num.li.QuadPart % 95);
		num.li.QuadPart -= u;
		num.li.QuadPart /= 95;
		*p = (char)(u + 32);
		p++;
	}
}


static void add_control(struct dlg_complete *dlg,
                        WORD type,
                        WORD id,
                        DWORD style,
                        short x,
                        short y,
                        short cx,
                        short cy,
                        const char *caption);


static int
get_password(const char *user,
             const char *realm,
             char *passwd,
             unsigned passwd_len)
{
	/* Parameter for size/format tuning of the dialog */
	short HEIGHT = 15;
	short WIDTH = 280;
	short LABEL_WIDTH = 90;

	/* Other variables */
	struct dlg_complete dlg;
	static struct dlg_proc_param s_dlg_proc_param;
	int ok;
	short y;

	DEBUG_ASSERT((user != NULL) && (realm != NULL) && (passwd != NULL));

	/* Only allow one instance of this dialog to be open. */
	if (s_dlg_proc_param.guard == 0) {
		memset(&s_dlg_proc_param, 0, sizeof(s_dlg_proc_param));
		s_dlg_proc_param.guard = 1;
	} else {
		SetForegroundWindow(s_dlg_proc_param.hWnd);
		return 0;
	}

	FillDialogHeader(&dlg, WIDTH);

	/* Do not open a password dialog, if the username is empty */
	if (user[0] == 0) {
		s_dlg_proc_param.guard = 0;
		return 0;
	}

	/* Create a password suggestion */
	memset(passwd, 0, passwd_len);
	suggest_passwd(passwd);

	/* Make buffer available for input dialog */
	s_dlg_proc_param.buffer = passwd;
	s_dlg_proc_param.buflen = passwd_len;

	/* Create the dialog */
	y = HEIGHT;
	add_control(&dlg,
	            0x82,
	            ID_STATIC,
	            WS_VISIBLE | WS_CHILD,
	            10,
	            y,
	            LABEL_WIDTH,
	            HEIGHT,
	            "User:");
	add_control(&dlg,
	            0x81,
	            ID_CONTROLS + 1,
	            WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
	                | ES_READONLY,
	            15 + LABEL_WIDTH,
	            y,
	            WIDTH - LABEL_WIDTH - 25,
	            HEIGHT,
	            user);

	y += HEIGHT;
	add_control(&dlg,
	            0x82,
	            ID_STATIC,
	            WS_VISIBLE | WS_CHILD,
	            10,
	            y,
	            LABEL_WIDTH,
	            HEIGHT,
	            "Realm:");
	add_control(&dlg,
	            0x81,
	            ID_CONTROLS + 2,
	            WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
	                | ES_READONLY,
	            15 + LABEL_WIDTH,
	            y,
	            WIDTH - LABEL_WIDTH - 25,
	            HEIGHT,
	            realm);

	y += HEIGHT;
	add_control(&dlg,
	            0x82,
	            ID_STATIC,
	            WS_VISIBLE | WS_CHILD,
	            10,
	            y,
	            LABEL_WIDTH,
	            HEIGHT,
	            "Password:");
	add_control(&dlg,
	            0x81,
	            ID_INPUT_LINE,
	            WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | WS_TABSTOP,
	            15 + LABEL_WIDTH,
	            y,
	            WIDTH - LABEL_WIDTH - 25,
	            HEIGHT,
	            "");

	y += (WORD)(HEIGHT * 2);
	add_control(&dlg,
	            0x80,
	            IDOK,
	            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
	            80,
	            y,
	            55,
	            12,
	            "Ok");
	add_control(&dlg,
	            0x80,
	            IDCANCEL,
	            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
	            140,
	            y,
	            55,
	            12,
	            "Cancel");

	dlg.header.dlg_template.cy = y + (WORD)(HEIGHT * 1.5);

	s_dlg_proc_param.name = "Modify password";
	s_dlg_proc_param.fRetry = NULL;

	ok = (IDOK
	      == DialogBoxIndirectParam(NULL,
	                                &dlg.header.dlg_template,
	                                NULL,
	                                InputDlgProc,
	                                (LPARAM)&s_dlg_proc_param));

	s_dlg_proc_param.hWnd = NULL;
	s_dlg_proc_param.guard = 0;

	return ok;
}


/* Dialog proc for password dialog */
static INT_PTR CALLBACK
PasswordDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	static const char *passfile = 0;
	char domain[256], user[256], password[256];
	WORD ctrlId;
	struct dlg_proc_param *pdlg_proc_param;

	switch (msg) {
	case WM_CLOSE:
		passfile = 0;
		DestroyWindow(hDlg);
		break;

	case WM_COMMAND:
		ctrlId = LOWORD(wParam);
		if (ctrlId == ID_ADD_USER) {
			/* Add user */
			GetWindowText(GetDlgItem(hDlg, ID_ADD_USER_NAME),
			              user,
			              sizeof(user));
			GetWindowText(GetDlgItem(hDlg, ID_ADD_USER_REALM),
			              domain,
			              sizeof(domain));
			if (get_password(user, domain, password, sizeof(password))) {
				mg_modify_passwords_file(passfile, domain, user, password);
				EndDialog(hDlg, IDOK);
			}
		} else if ((ctrlId >= (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 3))
		           && (ctrlId < (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 4))) {
			/* Modify password */
			GetWindowText(GetDlgItem(hDlg, ctrlId - ID_FILE_BUTTONS_DELTA * 3),
			              user,
			              sizeof(user));
			GetWindowText(GetDlgItem(hDlg, ctrlId - ID_FILE_BUTTONS_DELTA * 2),
			              domain,
			              sizeof(domain));
			if (get_password(user, domain, password, sizeof(password))) {
				mg_modify_passwords_file(passfile, domain, user, password);
				EndDialog(hDlg, IDOK);
			}
		} else if ((ctrlId >= (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 2))
		           && (ctrlId < (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 3))) {
			/* Remove user */
			GetWindowText(GetDlgItem(hDlg, ctrlId - ID_FILE_BUTTONS_DELTA * 2),
			              user,
			              sizeof(user));
			GetWindowText(GetDlgItem(hDlg, ctrlId - ID_FILE_BUTTONS_DELTA),
			              domain,
			              sizeof(domain));
			mg_modify_passwords_file(passfile, domain, user, NULL);
			EndDialog(hDlg, IDOK);
		}
		break;

	case WM_INITDIALOG:
		pdlg_proc_param = (struct dlg_proc_param *)lParam;
		pdlg_proc_param->hWnd = hDlg;
		passfile = pdlg_proc_param->name;
		SendMessage(hDlg, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)hIcon);
		SendMessage(hDlg, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM)hIcon);
		SetWindowText(hDlg, passfile);
		SetFocus(GetDlgItem(hDlg, ID_ADD_USER_NAME));
		break;

	default:
		break;
	}

	return FALSE;
}


static void
add_control(struct dlg_complete *dlg,
            WORD type,
            WORD id,
            DWORD style,
            short x,
            short y,
            short cx,
            short cy,
            const char *caption)
{
	DLGITEMTEMPLATE *tp;
	LPWORD p;
	WORD cap_len = caption ? (WORD)strlen(caption) : 0;
	int i;
	DWORD expected_size = sizeof(DLGITEMTEMPLATE) + 4 + (cap_len + 1) * 2 + 2;

	if ((dlg->used + expected_size + /* alignment */ 16)
	    >= sizeof(dlg->elements)) {
		/* out if memory protection */
		return;
	}

	/* Add one child element */
	dlg->header.dlg_template.cdit++;

	/* align to 4 bytes */
	while (dlg->used % 4) {
		dlg->used++;
	}

	/* start with DLGITEMTEMPLATE structure */
	tp = (DLGITEMTEMPLATE *)(dlg->elements + dlg->used);
	tp->id = id;
	tp->style = style;
	tp->dwExtendedStyle = 0;
	tp->x = x;
	tp->y = y;
	tp->cx = cx;
	tp->cy = cy;
	dlg->used += sizeof(*tp);

	/* add class */
	p = (LPWORD)(dlg->elements + dlg->used);
	p[0] = 0xffff;
	p[1] = type;
	dlg->used += 2 * sizeof(*p);

	/* add title */
	p = (LPWORD)(dlg->elements + dlg->used);
	for (i = 0; i < cap_len; i++) {
		p[i] = (WCHAR)caption[i];
	}
	p[cap_len] = 0;
	dlg->used += (cap_len + 1) * sizeof(*p);

	/* align to 2 bytes */
	while (dlg->used % 2) {
		dlg->used++;
	}

	/* add creation data */
	p = (LPWORD)(dlg->elements + dlg->used);
	*p = 0;
	dlg->used += sizeof(*p);
}


static int
optioncmp(const char *o1, const char *o2)
{
	/* string compare for option names */
	while (*o1 || *o2) {
		int c1 = 256 * (int)*o1;
		int c2 = 256 * (int)*o2;
		if (isalpha(*o1))
			c1 = toupper(*o1);
		else if (*o1 == '_')
			c1 = 1;
		if (isalpha(*o2))
			c2 = toupper(*o2);
		else if (*o2 == '_')
			c2 = 1;
		if (c1 < c2)
			return -1;
		if (c1 > c2)
			return +1;
		o1++;
		o2++;
	}
	return 0;
}


static void
show_settings_dialog()
{
	/* Parameter for size/format tuning of the dialog */
	short HEIGHT = 15;
	short BORDER_WIDTH = 10;
	short BORDER_HEIGTH = BORDER_WIDTH / 2;
	short CELL_WIDTH = 125;
	short LABEL_WIDTH = 115;
	short FILE_DIALOG_BUTTON_WIDTH = 15;
	short NO_OF_COLUMNS = 3;
	short NO_OF_OPTIONS = 0;       /* to be calculated */
	short NO_OF_OPTION_SPACES = 0; /* to be calculated */
	short NO_OF_ROWS = 0;          /* to be calculated */

	/* Calculates size */
	short COLUMN_WIDTH = LABEL_WIDTH + CELL_WIDTH + BORDER_WIDTH;
	short DIALOG_WIDTH = BORDER_WIDTH + NO_OF_COLUMNS * COLUMN_WIDTH;

	/* All other variables */
	const struct mg_option *cv_options;
	DWORD style;
	WORD i, cl, nelems = 0;
	short x, y, next_cell_width, next_cell_height;
	static struct dlg_proc_param s_dlg_proc_param;
	short *option_index, *option_top, *option_bottom;
	char text[64];
	struct dlg_complete dlg;

	if (s_dlg_proc_param.guard == 0) {
		memset(&s_dlg_proc_param, 0, sizeof(s_dlg_proc_param));
		s_dlg_proc_param.guard = 1;
	} else {
		SetForegroundWindow(s_dlg_proc_param.hWnd);
		return;
	}

	FillDialogHeader(&dlg, DIALOG_WIDTH);

	/* Determine space required for input fields */
	cv_options = mg_get_valid_options();
	for (i = 0; cv_options[i].name != NULL; i++) {
		NO_OF_OPTIONS++;
		if (cv_options[i].type == MG_CONFIG_TYPE_STRING_MULTILINE) {
			/* Multiline input fields require double space */
			NO_OF_OPTION_SPACES += 2;
		} else {
			/* All other option types require single space */
			NO_OF_OPTION_SPACES++;
		}
	}
	NO_OF_ROWS = (NO_OF_OPTION_SPACES + NO_OF_COLUMNS - 1) / NO_OF_COLUMNS;

	/* All options should be displayed sorted. */
	/* First allocate some memory to store option order: The array should store
	 * 1) the option order of all options (NO_OF_OPTIONS), followed by
	 * 2) the option index for the option name displayed on top of a column
	 * 3) the option index for the option name displayed on bottom of a column
	 */
	option_index = (short *)calloc(NO_OF_OPTIONS + 2 * NO_OF_COLUMNS,
	                               sizeof(short)); /* 1 */
	if (!option_index) {
		/* unlikely case of "out of memory" */
		return;
	}
	option_top = option_index + NO_OF_OPTIONS;  /* 2 */
	option_bottom = option_top + NO_OF_COLUMNS; /* 3 */

	/* Initialize option order */
	for (i = 0; i < NO_OF_OPTIONS; i++) {
		option_index[i] = i;
	}
	/* Sort all options */
	for (;;) {
		int swapped = 0;
		for (i = 1; i < NO_OF_OPTIONS; i++) {
			if (optioncmp(cv_options[option_index[i - 1]].name,
			              cv_options[option_index[i]].name)
			    > 0) {
				short swap = option_index[i];
				option_index[i] = option_index[i - 1];
				option_index[i - 1] = swap;
				swapped = 1;
			}
		}
		if (!swapped) {
			break;
		}
	}

	/* Create input fields for all options */
	for (i = 0; i < NO_OF_OPTIONS; i++) {

		/* Get option according to option order */
		const struct mg_option *opt = &cv_options[option_index[i]];

		/* Template style for all input fields (will be modified for specific
		 * field types) */
		style = WS_CHILD | WS_VISIBLE | WS_TABSTOP;

		/* TODO: Bottom of a column must not be a MULTILINE input field.
		 * If the last input field in a column would of multi-line type
		 * (opt->type == MG_CONFIG_TYPE_STRING_MULTILINE), then
		 * skip one field (nelems++).
		 * But in this case, maybe one more ROW might be required. */

		/* Position and size of the input field (will be modified) */
		x = BORDER_WIDTH + COLUMN_WIDTH * (nelems / NO_OF_ROWS);
		y = BORDER_HEIGTH + HEIGHT + HEIGHT * (nelems % NO_OF_ROWS);
		next_cell_width = CELL_WIDTH;
		next_cell_height = HEIGHT - 3;

		/* Determine top/bottom option for every column */
		if ((nelems % NO_OF_ROWS) == 0) {
			/* Set option on top of a new column once */
			option_top[nelems / NO_OF_ROWS] = option_index[i];
		}
		/* Set/overwrite option on bottom of a column */
		option_bottom[nelems / NO_OF_ROWS] = option_index[i];

		/* Depending on option type: create suitable input field */
		if (opt->type == MG_CONFIG_TYPE_NUMBER) {
			style |= ES_NUMBER;
			cl = 0x81;
			style |= WS_BORDER | ES_AUTOHSCROLL;

		} else if (opt->type == MG_CONFIG_TYPE_BOOLEAN) {
			cl = 0x80;
			style |= BS_AUTOCHECKBOX;

		} else if ((opt->type == MG_CONFIG_TYPE_FILE)
		           || (opt->type == MG_CONFIG_TYPE_DIRECTORY)) {
			style |= WS_BORDER | ES_AUTOHSCROLL;
			cl = 0x81;

			/* Additional button for file dialog */
			add_control(&dlg,
			            0x80,
			            ID_CONTROLS + option_index[i] + ID_FILE_BUTTONS_DELTA,
			            WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
			            x + LABEL_WIDTH + CELL_WIDTH - FILE_DIALOG_BUTTON_WIDTH,
			            y,
			            FILE_DIALOG_BUTTON_WIDTH,
			            HEIGHT - 3,
			            "...");

			next_cell_width -= FILE_DIALOG_BUTTON_WIDTH + BORDER_WIDTH / 2;

		} else if (opt->type == MG_CONFIG_TYPE_STRING_MULTILINE) {

			/* Multiline input */
			cl = 0x81;
			style |= WS_BORDER | ES_AUTOHSCROLL | ES_MULTILINE | ES_WANTRETURN
			         | WS_VSCROLL | ES_AUTOVSCROLL;
			/* Add more space below */
			nelems += 1;
			next_cell_height += HEIGHT;

		} else {
			/* Standard text input field */
			cl = 0x81;
			style |= WS_BORDER | ES_AUTOHSCROLL;
		}

		/* Add label (static text) */
		add_control(&dlg,
		            0x82,
		            ID_STATIC,
		            WS_VISIBLE | WS_CHILD,
		            x,
		            y,
		            LABEL_WIDTH,
		            HEIGHT,
		            opt->name);

		/* Add input field */
		add_control(&dlg,
		            cl,
		            ID_CONTROLS + option_index[i],
		            style,
		            x + LABEL_WIDTH,
		            y,
		            next_cell_width,
		            next_cell_height,
		            "");
		nelems++;
	}

	/* "Settings" frame around all options */
	y = ((nelems + NO_OF_COLUMNS - 1) / NO_OF_COLUMNS + 1) * HEIGHT;
	for (i = 0; i < NO_OF_COLUMNS; i++) {
		sprintf(text,
		        " Settings %c - %c ",
		        cv_options[option_top[i]].name[0],
		        cv_options[option_bottom[i]].name[0]);
		add_control(&dlg,
		            0x80,
		            ID_GROUP,
		            WS_CHILD | WS_VISIBLE | BS_GROUPBOX,
		            BORDER_WIDTH / 2
		                + i * (DIALOG_WIDTH - BORDER_WIDTH) / NO_OF_COLUMNS,
		            BORDER_WIDTH / 2,
		            (DIALOG_WIDTH - BORDER_WIDTH) / NO_OF_COLUMNS,
		            y + 2,
		            text);
	}

	/* Buttons below "Settings" frame */
	y += HEIGHT;
	add_control(&dlg,
	            0x80,
	            ID_SAVE,
	            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
	            DIALOG_WIDTH - 70,
	            y,
	            65,
	            12,
	            "Save Settings");
	add_control(&dlg,
	            0x80,
	            ID_RESET_DEFAULTS,
	            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
	            DIALOG_WIDTH - 140,
	            y,
	            65,
	            12,
	            "Reset to defaults");
	add_control(&dlg,
	            0x80,
	            ID_RESET_FILE,
	            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
	            DIALOG_WIDTH - 210,
	            y,
	            65,
	            12,
	            "Reload from file");
	add_control(&dlg,
	            0x80,
	            ID_RESET_ACTIVE,
	            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
	            DIALOG_WIDTH - 280,
	            y,
	            65,
	            12,
	            "Reload active");
	add_control(&dlg,
	            0x82,
	            ID_STATIC,
	            WS_CHILD | WS_VISIBLE | WS_DISABLED,
	            5,
	            y,
	            100,
	            12,
	            g_server_base_name);

	/* Calculate total height of the dialog */
	dlg.header.dlg_template.cy = y + HEIGHT;

	s_dlg_proc_param.fRetry = NULL;

	DialogBoxIndirectParam(NULL,
	                       &dlg.header.dlg_template,
	                       NULL,
	                       SettingsDlgProc,
	                       (LPARAM)&s_dlg_proc_param);

	free(option_index);

	s_dlg_proc_param.hWnd = NULL;
	s_dlg_proc_param.guard = 0;
}


static void
change_password_file()
{
	/* Parameter for size/format tuning of the dialog */
	short HEIGHT = 15;
	short WIDTH = 320;
	short LABEL_WIDTH = 90;

	/* Other variables */
	OPENFILENAME of;
	char path[PATH_MAX] = PASSWORDS_FILE_NAME;
	char strbuf[256], u[256], d[256];
	HWND hDlg = NULL;
	FILE *f;
	short y, nelems;
	const char *domain = mg_get_option(g_ctx, "authentication_domain");
	static struct dlg_proc_param s_dlg_proc_param;
	struct dlg_complete dlg;

	if (s_dlg_proc_param.guard == 0) {
		memset(&s_dlg_proc_param, 0, sizeof(s_dlg_proc_param));
		s_dlg_proc_param.guard = 1;
	} else {
		SetForegroundWindow(s_dlg_proc_param.hWnd);
		return;
	}

	memset(&of, 0, sizeof(of));
	of.lStructSize = sizeof(of);
	of.hwndOwner = (HWND)hDlg;
	of.lpstrFile = path;
	of.nMaxFile = sizeof(path);
	of.lpstrInitialDir = mg_get_option(g_ctx, "document_root");
	of.Flags = OFN_CREATEPROMPT | OFN_NOCHANGEDIR | OFN_HIDEREADONLY;

	if (!GetSaveFileName(&of)) {
		/* Cancel/Close by user */
		s_dlg_proc_param.guard = 0;
		return;
	}

	f = fopen(path, "a+");
	if (f) {
		fclose(f);
	} else {
		MessageBox(NULL, path, "Can not open file", MB_ICONERROR);
		s_dlg_proc_param.guard = 0;
		return;
	}

	do {
		s_dlg_proc_param.hWnd = NULL;

		FillDialogHeader(&dlg, WIDTH);

		f = fopen(path, "r+");
		if (!f) {
			MessageBox(NULL, path, "Can not open file", MB_ICONERROR);
			s_dlg_proc_param.guard = 0;
			return;
		}

		nelems = 0;
		while (fgets(strbuf, sizeof(strbuf), f)) {
			if (sscanf(strbuf, "%255[^:]:%255[^:]:%*s", u, d) != 2) {
				continue;
			}
			u[255] = 0;
			d[255] = 0;
			y = (nelems + 1) * HEIGHT + 5;
			add_control(&dlg,
			            0x80,
			            ID_CONTROLS + nelems + ID_FILE_BUTTONS_DELTA * 3,
			            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
			            10,
			            y,
			            65,
			            12,
			            "Modify password");
			add_control(&dlg,
			            0x80,
			            ID_CONTROLS + nelems + ID_FILE_BUTTONS_DELTA * 2,
			            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
			            80,
			            y,
			            55,
			            12,
			            "Remove user");
			add_control(&dlg,
			            0x81,
			            ID_CONTROLS + nelems + ID_FILE_BUTTONS_DELTA,
			            WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
			                | ES_READONLY,
			            245,
			            y,
			            60,
			            12,
			            d);
			add_control(&dlg,
			            0x81,
			            ID_CONTROLS + nelems,
			            WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
			                | ES_READONLY,
			            140,
			            y,
			            100,
			            12,
			            u);

			nelems++;
		}
		fclose(f);

		y = (nelems + 1) * HEIGHT + 10;
		add_control(&dlg,
		            0x80,
		            ID_ADD_USER,
		            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
		            80,
		            y,
		            55,
		            12,
		            "Add user");
		add_control(&dlg,
		            0x81,
		            ID_ADD_USER_NAME,
		            WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
		                | WS_TABSTOP,
		            140,
		            y,
		            100,
		            12,
		            "");
		add_control(&dlg,
		            0x81,
		            ID_ADD_USER_REALM,
		            WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
		                | WS_TABSTOP,
		            245,
		            y,
		            60,
		            12,
		            domain);

		y = (nelems + 2) * HEIGHT + 10;
		add_control(&dlg,
		            0x80,
		            ID_GROUP,
		            WS_CHILD | WS_VISIBLE | BS_GROUPBOX,
		            5,
		            5,
		            WIDTH - 10,
		            y,
		            " Users ");

		y += HEIGHT;
		add_control(&dlg,
		            0x82,
		            ID_STATIC,
		            WS_CHILD | WS_VISIBLE | WS_DISABLED,
		            5,
		            y,
		            100,
		            12,
		            g_server_base_name);

		dlg.header.dlg_template.cy = y + 20;

		s_dlg_proc_param.name = path;
		s_dlg_proc_param.fRetry = NULL;

	} while ((IDOK
	          == DialogBoxIndirectParam(NULL,
	                                    &dlg.header.dlg_template,
	                                    NULL,
	                                    PasswordDlgProc,
	                                    (LPARAM)&s_dlg_proc_param))
	         && (!g_exit_flag));

	s_dlg_proc_param.hWnd = NULL;
	s_dlg_proc_param.guard = 0;
}


static BOOL
sysinfo_reload(struct dlg_proc_param *prm)
{
	static char *buf = 0;
	int cl, rl;

	cl = mg_get_context_info(g_ctx, NULL, 0);
	free(buf);
	cl += 510;
	buf = (char *)malloc(cl + 1);
	rl = mg_get_context_info(g_ctx, buf, cl);
	if ((rl > cl) || (rl <= 0)) {
		if (g_ctx == NULL) {
			prm->buffer = "Server not running";
		} else if (rl <= 0) {
			prm->buffer = "No server statistics available";
		} else {
			prm->buffer = "Please retry";
		}
	} else {
		prm->buffer = buf;
	}

	return TRUE;
}


int
show_system_info()
{
	/* Parameter for size/format tuning of the dialog */
	short HEIGHT = 15;
	short WIDTH = 320;
	short LABEL_WIDTH = 50;

	/* Other parameters */
	int ok;
	short y;
	static struct dlg_proc_param s_dlg_proc_param;
	struct dlg_complete dlg;

	/* Only allow one instance of this dialog to be open. */
	if (s_dlg_proc_param.guard == 0) {
		memset(&s_dlg_proc_param, 0, sizeof(s_dlg_proc_param));
		s_dlg_proc_param.guard = 1;
	} else {
		SetForegroundWindow(s_dlg_proc_param.hWnd);
		return 0;
	}

	/* Create the dialog */
	FillDialogHeader(&dlg, WIDTH);

	y = HEIGHT;
	add_control(&dlg,
	            0x82,
	            ID_STATIC,
	            WS_VISIBLE | WS_CHILD,
	            10,
	            y,
	            LABEL_WIDTH,
	            HEIGHT,
	            "System Information:");
	add_control(&dlg,
	            0x81,
	            ID_CONTROLS + 1,
	            WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
	                | ES_AUTOVSCROLL | ES_MULTILINE | ES_READONLY,
	            15 + LABEL_WIDTH,
	            y,
	            WIDTH - LABEL_WIDTH - 25,
	            HEIGHT * 7,
	            g_system_info);

	y += (WORD)(HEIGHT * 8);

	add_control(&dlg,
	            0x80,
	            IDRETRY,
	            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
	            WIDTH - 10 - 55 - 10 - 55,
	            y,
	            55,
	            12,
	            "Reload");

	add_control(&dlg,
	            0x80,
	            IDOK,
	            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP,
	            WIDTH - 10 - 55,
	            y,
	            55,
	            12,
	            "Close");

	dlg.header.dlg_template.cy = y + (WORD)(HEIGHT * 1.5);

	s_dlg_proc_param.name = "System information";
	s_dlg_proc_param.fRetry = sysinfo_reload;
	s_dlg_proc_param.idRetry = ID_CONTROLS + 1; /* Reload field with this ID */

	ok = (IDOK
	      == DialogBoxIndirectParam(NULL,
	                                &dlg.header.dlg_template,
	                                NULL,
	                                InputDlgProc,
	                                (LPARAM)&s_dlg_proc_param));

	s_dlg_proc_param.hWnd = NULL;
	s_dlg_proc_param.guard = 0;

	return ok;
}


static int
manage_service(int action)
{
	const char *service_name = g_server_name;
	SC_HANDLE hSCM = NULL, hService = NULL;
	SERVICE_DESCRIPTION descr;
	char path[PATH_MAX + 20] = ""; /* Path to executable plus magic argument */
	int success = 1;

	descr.lpDescription = (LPSTR)g_server_name;

	if ((hSCM = OpenSCManager(NULL,
	                          NULL,
	                          action == ID_INSTALL_SERVICE ? GENERIC_WRITE
	                                                       : GENERIC_READ))
	    == NULL) {
		success = 0;
		show_error();
	} else if (action == ID_INSTALL_SERVICE) {
		path[sizeof(path) - 1] = 0;
		GetModuleFileName(NULL, path, sizeof(path) - 1);
		strncat(path, " ", sizeof(path) - 1 - strlen(path));
		strncat(path, service_magic_argument, sizeof(path) - 1 - strlen(path));
		hService = CreateService(hSCM,
		                         service_name,
		                         service_name,
		                         SERVICE_ALL_ACCESS,
		                         SERVICE_WIN32_OWN_PROCESS,
		                         SERVICE_AUTO_START,
		                         SERVICE_ERROR_NORMAL,
		                         path,
		                         NULL,
		                         NULL,
		                         NULL,
		                         NULL,
		                         NULL);
		if (hService) {
			ChangeServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, &descr);
		} else {
			show_error();
		}
	} else if (action == ID_REMOVE_SERVICE) {
		if ((hService = OpenService(hSCM, service_name, DELETE)) == NULL
		    || !DeleteService(hService)) {
			show_error();
		}
	} else if ((hService =
	                OpenService(hSCM, service_name, SERVICE_QUERY_STATUS))
	           == NULL) {
		success = 0;
	}

	if (hService)
		CloseServiceHandle(hService);
	if (hSCM)
		CloseServiceHandle(hSCM);

	return success;
}


static void
add_icon_to_systray(HWND hWnd)
{
	/* tray icon is entry point to the menu */
	if (!g_hide_tray) {
		TrayIcon.cbSize = sizeof(TrayIcon);
		TrayIcon.uID = ID_ICON;
		TrayIcon.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
		TrayIcon.hIcon = hIcon;
		TrayIcon.hWnd = hWnd;
		snprintf(TrayIcon.szTip, sizeof(TrayIcon.szTip), "%s", g_server_name);
		TrayIcon.uCallbackMessage = WM_USER;
		Shell_NotifyIcon(NIM_ADD, &TrayIcon);
	} else {
		TrayIcon.cbSize = 0;
	}
}


/* Window proc for taskbar icon */
static LRESULT CALLBACK
WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{

	int service_installed;
	char buf[200];
	POINT pt;
	HMENU hMenu;

	switch (msg) {

	case WM_CREATE:
		if ((__argv[1] != NULL) && !strcmp(__argv[1], service_magic_argument)) {
			static SERVICE_TABLE_ENTRY service_table[2];
			char *service_argv[2];

			service_argv[0] = __argv[0];
			service_argv[1] = NULL;

			start_civetweb(1, service_argv);

			memset(service_table, 0, sizeof(service_table));
			service_table[0].lpServiceName = (LPSTR)g_server_name;
			service_table[0].lpServiceProc =
			    (LPSERVICE_MAIN_FUNCTION)ServiceMain;

			StartServiceCtrlDispatcher(service_table);
			exit(EXIT_SUCCESS);
		} else {
			start_civetweb(__argc, __argv);
		}
		break;

	case WM_COMMAND:
		switch (LOWORD(wParam)) {
		case ID_QUIT:
			stop_civetweb();
			if (TrayIcon.cbSize) {
				Shell_NotifyIcon(NIM_DELETE, &TrayIcon);
			}
			g_exit_flag = 1;
			PostQuitMessage(0);
			return 0;
		case ID_SETTINGS:
			show_settings_dialog();
			break;
		case ID_PASSWORD:
			change_password_file();
			break;
		case ID_SYSINFO:
			show_system_info();
			break;
		case ID_INSTALL_SERVICE:
		case ID_REMOVE_SERVICE:
			manage_service(LOWORD(wParam));
			break;
		case ID_CONNECT: {
			/* Get port from server configuration (listening_ports) and build
			 * URL from port. */
			const char *url = get_url_to_first_open_port(g_ctx);

			/* Open URL with Windows default browser */
			ShellExecute(NULL, "open", url, NULL, NULL, SW_SHOW);
		} break;
		case ID_WEBSITE:
			fprintf(stdout, "[%s]\n", g_website);
			ShellExecute(NULL, "open", g_website, NULL, NULL, SW_SHOW);
			break;
		}
		break;

	case WM_USER:
		switch (lParam) {
		case WM_RBUTTONUP:
		case WM_LBUTTONUP:
		case WM_LBUTTONDBLCLK:
			hMenu = CreatePopupMenu();
			AppendMenu(hMenu,
			           MF_STRING | MF_GRAYED,
			           ID_SEPARATOR,
			           g_server_name);
			AppendMenu(hMenu, MF_SEPARATOR, ID_SEPARATOR, "");
			service_installed = manage_service(0);
			snprintf(buf,
			         sizeof(buf) - 1,
			         "NT service: %s installed",
			         service_installed ? "" : "not");
			buf[sizeof(buf) - 1] = 0;
			AppendMenu(hMenu, MF_STRING | MF_GRAYED, ID_SEPARATOR, buf);
			AppendMenu(hMenu,
			           MF_STRING | (service_installed ? MF_GRAYED : 0),
			           ID_INSTALL_SERVICE,
			           "Install service");
			AppendMenu(hMenu,
			           MF_STRING | (!service_installed ? MF_GRAYED : 0),
			           ID_REMOVE_SERVICE,
			           "Deinstall service");
			AppendMenu(hMenu, MF_SEPARATOR, ID_SEPARATOR, "");
			AppendMenu(hMenu, MF_STRING, ID_CONNECT, "Start browser");
			AppendMenu(hMenu, MF_STRING, ID_SETTINGS, "Edit settings");
			AppendMenu(hMenu, MF_STRING, ID_PASSWORD, "Modify password file");
			AppendMenu(hMenu, MF_STRING, ID_SYSINFO, "Show system info");
			AppendMenu(hMenu, MF_STRING, ID_WEBSITE, "Visit website");
			AppendMenu(hMenu, MF_SEPARATOR, ID_SEPARATOR, "");
			AppendMenu(hMenu, MF_STRING, ID_QUIT, "Exit");
			GetCursorPos(&pt);
			SetForegroundWindow(hWnd);
			TrackPopupMenu(hMenu, 0, pt.x, pt.y, 0, hWnd, NULL);
			PostMessage(hWnd, WM_NULL, 0, 0);
			DestroyMenu(hMenu);
			break;
		}
		break;

	case WM_CLOSE:
		stop_civetweb();
		if (TrayIcon.cbSize) {
			Shell_NotifyIcon(NIM_DELETE, &TrayIcon);
		}
		g_exit_flag = 1;
		PostQuitMessage(0);
		return 0; /* We've just sent our own quit message, with proper hwnd. */

	default:
		if (msg == msg_taskbar_created) {
			add_icon_to_systray(hWnd);
		}
		break;
	}

	return DefWindowProc(hWnd, msg, wParam, lParam);
}


/* An executable with "Subsystem: Windows" does not have a Console.
 * Create one manually, if required. */
static int
MakeConsole(void)
{
	DWORD err;
	HANDLE hConWnd = GetConsoleWindow();
	int ok = 1;

	if (hConWnd == NULL) {
		if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
			FreeConsole();
			if (!AllocConsole()) {
				err = GetLastError();
				if (err == ERROR_ACCESS_DENIED) {
					ok = 0;
					MessageBox(NULL,
					           "Insufficient rights to create a console window",
					           "Error",
					           MB_ICONERROR);
				}
			}
			AttachConsole(GetCurrentProcessId());
		}

		/* Retry to get a console handle */
		hConWnd = GetConsoleWindow();

		if (hConWnd == NULL) {
			ok = 0;
		} else {
			/* Reopen console handles according to
			 * https://stackoverflow.com/questions/9020790/using-stdin-with-an-allocconsole
			 */
			if (NULL == freopen("CONIN$", "r", stdin)) {
				ok = 0;
			}
			if (NULL == freopen("CONOUT$", "w", stdout)) {
				ok = 0;
			}
			if (NULL == freopen("CONOUT$", "w", stderr)) {
				ok = 0;
			}
		}
	}

	if (hConWnd == NULL) {
		ok = 0;
	} else {
		SetConsoleTitle(g_server_name);
	}

	return ok;
}


/* main() for Windows (Subsystem: Windows). */
int WINAPI
WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR cmdline, int show)
{
	WNDCLASS cls;
	HWND hWnd;
	MSG msg;

#if defined(DEBUG)
	(void)MakeConsole();
#endif

	(void)hInst;
	(void)hPrev;
	(void)cmdline;
	(void)show;

	init_server_name();
	init_system_info();
	msg_taskbar_created = RegisterWindowMessage("TaskbarCreated");

	memset(&cls, 0, sizeof(cls));
	cls.lpfnWndProc = WindowProc;
	cls.hInstance = GetModuleHandle(NULL);
	cls.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	cls.lpszClassName = g_server_base_name;

	RegisterClass(&cls);
	hWnd = CreateWindow(cls.lpszClassName,
	                    g_server_name,
	                    WS_OVERLAPPEDWINDOW,
	                    0,
	                    0,
	                    0,
	                    0,
	                    NULL,
	                    NULL,
	                    cls.hInstance,
	                    NULL);
	ShowWindow(hWnd, SW_HIDE);

	/* Load icon for systray and other dialogs */
	if (g_icon_name) {
		hIcon = (HICON)
		    LoadImage(NULL, g_icon_name, IMAGE_ICON, 16, 16, LR_LOADFROMFILE);
	} else {
		hIcon = (HICON)LoadImage(GetModuleHandle(NULL),
		                         MAKEINTRESOURCE(ID_ICON),
		                         IMAGE_ICON,
		                         16,
		                         16,
		                         0);
	}

	add_icon_to_systray(hWnd);

	/* Message loop */
	while (GetMessage(&msg, hWnd, 0, 0) > 0) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	free_system_info();

	/* Return the WM_QUIT value. */
	return (int)msg.wParam;
}


/* main() for Windows (Subsystem: Console). */
int
main(int argc, char *argv[])
{
	(void)argc;
	(void)argv;

	return WinMain(0, 0, 0, 0);
}


#elif defined(USE_COCOA)
#import <Cocoa/Cocoa.h>

@interface Civetweb : NSObject <NSApplicationDelegate>
- (void)openBrowser;
- (void)shutDown;
@end

@implementation Civetweb
- (void)openBrowser
{
	[[NSWorkspace sharedWorkspace]
	    openURL:[NSURL URLWithString:[NSString stringWithUTF8String:
	                                               get_url_to_first_open_port(
	                                                   g_ctx)]]];
}
- (void)editConfig
{
	create_config_file(g_ctx, g_config_file_name);
	NSString *path = [NSString stringWithUTF8String:g_config_file_name];
	if (![[NSWorkspace sharedWorkspace] openFile:path
	                             withApplication:@"TextEdit"]) {
		NSAlert *alert = [[[NSAlert alloc] init] autorelease];
		[alert setAlertStyle:NSWarningAlertStyle];
		[alert setMessageText:NSLocalizedString(@"Unable to open config file.",
		                                        "")];
		[alert setInformativeText:path];
		(void)[alert runModal];
	}
}
- (void)shutDown
{
	[NSApp terminate:nil];
}
@end

int
main(int argc, char *argv[])
{
	init_server_name();
	init_system_info();
	start_civetweb(argc, argv);

	[NSAutoreleasePool new];
	[NSApplication sharedApplication];

	/* Add delegate to process menu item actions */
	Civetweb *myDelegate = [[Civetweb alloc] autorelease];
	[NSApp setDelegate:myDelegate];

	/* Run this app as agent */
	ProcessSerialNumber psn = {0, kCurrentProcess};
	TransformProcessType(&psn, kProcessTransformToBackgroundApplication);
	SetFrontProcess(&psn);

	/* Add status bar menu */
	id menu = [[NSMenu new] autorelease];

	/* Add version menu item */
	[menu
	    addItem:[[[NSMenuItem alloc]
	                /*initWithTitle:[NSString stringWithFormat:@"%s",
	                   server_name]*/
	                initWithTitle:[NSString stringWithUTF8String:g_server_name]
	                       action:@selector(noexist)
	                keyEquivalent:@""] autorelease]];

	/* Add configuration menu item */
	[menu addItem:[[[NSMenuItem alloc] initWithTitle:@"Edit configuration"
	                                          action:@selector(editConfig)
	                                   keyEquivalent:@""] autorelease]];

	/* Add connect menu item */
	[menu
	    addItem:[[[NSMenuItem alloc] initWithTitle:@"Open web root in a browser"
	                                        action:@selector(openBrowser)
	                                 keyEquivalent:@""] autorelease]];

	/* Separator */
	[menu addItem:[NSMenuItem separatorItem]];

	/* Add quit menu item */
	[menu addItem:[[[NSMenuItem alloc] initWithTitle:@"Quit"
	                                          action:@selector(shutDown)
	                                   keyEquivalent:@"q"] autorelease]];

	/* Attach menu to the status bar */
	id item = [[[NSStatusBar systemStatusBar]
	    statusItemWithLength:NSVariableStatusItemLength] retain];
	[item setHighlightMode:YES];
	[item setImage:[NSImage imageNamed:@"civetweb_22x22.png"]];
	[item setMenu:menu];

	/* Run the app */
	[NSApp activateIgnoringOtherApps:YES];
	[NSApp run];

	stop_civetweb();
	free_system_info();

	return EXIT_SUCCESS;
}

#else


/* main for Linux (and others) */
int
main(int argc, char *argv[])
{
	init_server_name();
	init_system_info();
	start_civetweb(argc, argv);
	fprintf(stdout,
	        "%s started on port(s) %s with web root [%s]\n",
	        g_server_name,
	        mg_get_option(g_ctx, "listening_ports"),
	        mg_get_option(g_ctx, "document_root"));

	while (g_exit_flag == 0) {
		sleep(1);
	}

	fprintf(stdout,
	        "Exiting on signal %d, waiting for all threads to finish...",
	        g_exit_flag);
	fflush(stdout);
	stop_civetweb();
	fprintf(stdout, "%s", " done.\n");

	free_system_info();

	return EXIT_SUCCESS;
}
#endif /* _WIN32 */
#undef printf