tws_if_main.cpp

// Copyright (c) 2011-2012 Ger Hobbelt
// Parts of this file are Copyright (c) 2004-2012 Sergey Lyubka
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// 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.


/*
 * Mongoose-based server app which interfaces with a TWS station and displays data in HTML form,
 * suitable for loading by, for example, 64-bit Excel 2010, using web queries.
 */

#include "system-includes.h"

#include "tws_backend.h"
#include "mongoose_utils.h"
#include "mongoose_event_handler.h"
#include "app_manager.h"

#include "mongoose/win32/resource.h"


#include <upskirt/src/markdown.h>
#include <upskirt/html/html.h>


using namespace upskirt;




#define MAX_OPTIONS (1 + 27 /* NUM_OPTIONS */ * 3 /* once as defaults, once from config file, once from command line */)
#define MAX_CONF_FILE_LINE_SIZE (8 * 1024)

static volatile int exit_flag = 0;
static char server_name[40];          // Set by init_server_name()
static char config_file[PATH_MAX];    // Set by process_command_line_arguments()
static struct mg_context *ctx = NULL; // Set by start_mongoose()

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

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

static const char *default_options[] = {
    "document_root",         "./html",
    "listening_ports",       "8081",                         // "8081,8082s"
    //"ssl_certificate",     "ssl_cert.pem",
    "num_threads",           "5",
    "error_log_file",        "./log/%Y/%m/tws_ib_if_srv-%Y%m%d.%H-IP-%[s]-%[p]-error.log",
    "access_log_file",       "./log/%Y/%m/tws_ib_if_srv-%Y%m%d.%H-IP-%[s]-%[p]-access.log",
    "index_files",           "default.html",
    "ssi_pattern",           "**.html$|**.htm|**.shtml$|**.shtm$",
    "enable_keep_alive",     "yes",
    "keep_alive_timeout",    "5",
    //"ssi_marker",          "{!--#,}",

    // set up our own worker thread which talks to TWS:
    "tws_ip_address",        "127.0.0.1",
    "tws_ip_port",           "6789",
    "tws_connect_id",        "7",

    "tws_poll_delay",        "10", // unit: milliseconds
    "tws_reconnect_delay",   "10000", // unit: milliseconds

    "tws_log_traffic",       "true",
    "tws_traffic_log_file",  "./log/TWS-IO/%Y/%m/%Y%m%d.%H%M%S-%[U].log",

    "database_file",         "./ib_tws_if.hamsterdb",

	"gists_document_root",   "./",

    NULL
};

static app_manager mgr;


#if defined(_WIN32)
static int error_dialog_shown_previously = 0;
#endif

void die(const char *fmt, ...) {
    va_list ap;
    char msg[200];

    va_start(ap, fmt);
    vsnprintf(msg, sizeof(msg), fmt, ap);
    va_end(ap);

#if defined(_WIN32)
    if (!error_dialog_shown_previously)
    {
        MessageBoxA(NULL, msg, "Error", MB_OK);
        error_dialog_shown_previously = 1;
    }
#else
    fprintf(stderr, "%s\n", msg);
#endif

    exit(EXIT_FAILURE);
}

static void show_usage_and_exit(const struct mg_context *ctx) {
    const char **names;
    int i;

    fprintf(stderr, "Mongoose version %s (c) Sergey Lyubka\n", mg_version());
    fprintf(stderr, "Usage:\n");
    fprintf(stderr, "  mongoose -A <htpasswd_file> <realm> <user> <passwd>\n");
    fprintf(stderr, "  mongoose <config_file>\n");
    fprintf(stderr, "  mongoose [-option value ...]\n");
    fprintf(stderr, "OPTIONS:\n");

    names = mg_get_valid_option_names();
    for (i = 0; names[i] != NULL; i += MG_ENTRIES_PER_CONFIG_OPTION) {
        fprintf(stderr, "  %s%s %s (default: \"%s\")\n",
            (names[i][0] ? "-" : "  "),
            names[i], names[i + 1], names[i + 2] == NULL ? "" : names[i + 2]);
    }
    fprintf(stderr, "See  http://code.google.com/p/mongoose/wiki/MongooseManual"
        " for more details.\n");
    fprintf(stderr, "Example:\n  mongoose -s cert.pem -p 80,443s -d no\n");
    exit(EXIT_FAILURE);
}

static void verify_document_root(const char *root) {
    struct mgstat st;
    char buf[PATH_MAX];

    getcwd(buf, sizeof(buf));
    if (mg_stat(root, &st) != 0 || !st.is_directory) {
        die("Invalid root directory: [%s]: %s; current directory = [%s]", root, mg_strerror(errno), buf);
    }
}


static void set_option(char **options, const char *name, const char *value) {
    int i;

    if (mg_get_option_long_name(name))
        name = mg_get_option_long_name(name);

    for (i = 0; i < MAX_OPTIONS * 2; i += 2) {
        // replace option value when it was set before: command line overrules config file, which overrules global defaults.
        if (options[i] == NULL) {
            options[i] = mg_strdup(name);
            options[i + 1] = mg_strdup(value);
            break;
        } else if (strcmp(options[i], name) == 0) {
            free(options[i + 1]);
            options[i + 1] = mg_strdup(value);
            break;
        }
    }

    if (i > MAX_OPTIONS * 2 - 2) {
        die("Too many options specified");
    }
}

static void process_command_line_arguments(char *argv[], char **options) {
  char line[MAX_CONF_FILE_LINE_SIZE], opt[sizeof(line)], val[sizeof(line)], *p;
    FILE *fp = NULL;
    size_t i;
    int line_no = 0;

    options[0] = NULL;

    // Should we use a config file ?
    if (argv[1] != NULL && argv[2] == NULL) {
        snprintf(config_file, sizeof(config_file), "%s", argv[1]);
    } else if ((p = strrchr(argv[0], DIRSEP)) == NULL) {
        // No command line flags specified. Look where binary lives
        snprintf(config_file, sizeof(config_file), "%s", CONFIG_FILE);
    } else {
        snprintf(config_file, sizeof(config_file), "%.*s%c%s",
            (int) (p - argv[0]), argv[0], DIRSEP, CONFIG_FILE);
    }

    fp = mg_fopen(config_file, "r");

    // If config file was set in command line and open failed, exit
    if (argv[1] != NULL && argv[2] == NULL && fp == NULL) {
        die("Cannot open config file %s: %s", config_file, mg_strerror(errno));
    }

    // use the default values for starters (so that all options have a known reasonable value):
    for (i = 0; default_options[i]; i += 2) {
        set_option(options, default_options[i], default_options[i+1]);
    }

    // Load config file settings first
    if (fp != NULL) {
        fprintf(stderr, "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 (with optional, ignored, whitespace) and comments
            if (line[0] == '#')
                continue;

            switch (sscanf(line, "%s %[^\r\n#]", opt, val))
            {
            case 0:
                // empty line!
                continue;

            case 2:
                set_option(options, opt, val);
                continue;

            default:
                die("%s: line %d is invalid", config_file, line_no);
                break;
            }
        }

        (void) mg_fclose(fp);
    }

    // Now handle command line flags. They override config file / default settings.
    for (i = 1; argv[i] != NULL; i += 2) {
        if (argv[i][0] != '-' || argv[i + 1] == NULL) {
            show_usage_and_exit(ctx);
        }
        set_option(options, &argv[i][1], argv[i + 1]);
    }
}

static void init_server_name(void) {
    snprintf(server_name, sizeof(server_name), "Mongoose web server v%s",
        mg_version());
}


static int report_markdown_failure(struct mg_connection *conn, int is_inline_production, int response_code, const char *fmt, ...)
{
    va_list args;

    if (is_inline_production)
    {
        mg_printf(conn, "<h1 style=\"color: red;\">Error: %d - %s</h1>\n", response_code, mg_get_response_code_text(response_code));
        va_start(args, fmt);
        mg_vprintf(conn, fmt, args);
        va_end(args);
    }
    else
    {
        va_start(args, fmt);
        mg_vsend_http_error(conn, response_code, NULL, fmt, args);
        va_end(args);
    }
    return -1;
}


int serve_a_markdown_page(struct mg_connection *conn, const struct mgstat *st, int is_inline_production)
{
#define SD_READ_UNIT 1024
#define SD_OUTPUT_UNIT 64

    const struct mg_request_info *ri = mg_get_request_info(conn);
    struct sd_buf *ib, *ob;
    int ret;
    unsigned int enabled_extensions = MKDEXT_TABLES | MKDEXT_FENCED_CODE | MKDEXT_EMAIL_FRIENDLY;
    unsigned int render_flags = 0; // HTML_SKIP_HTML | HTML_SKIP_STYLE | HTML_HARD_WRAP;

    struct sd_callbacks callbacks;
    struct html_renderopt options;
    struct sd_markdown *markdown;

    /* opening the file */
    FILE *in;

    assert(ri->phys_path);
    /* opening the file */
    in = mg_fopen(ri->phys_path, "r");
    if (!in)
    {
        return report_markdown_failure(conn, is_inline_production, 404, "Unable to open input file: [%s] %s", ri->uri, mg_strerror(errno));
    }

    /* reading everything */
    ib = sd_bufnew(SD_READ_UNIT);
    if (SD_BUF_OK != sd_bufgrow(ib, (size_t)st->size))
    {
        mg_fclose(in);
        sd_bufrelease(ib);
        return report_markdown_failure(conn, is_inline_production, 500, "Out of memory while loading Markdown input file: [%s]", ri->uri);
    }
    ret = fread(ib->data, 1, ib->asize, in);
    if (ret > 0)
    {
        ib->size += ret;
        mg_fclose(in);
    }
    else
    {
        mg_fclose(in);
        sd_bufrelease(ib);
        return report_markdown_failure(conn, is_inline_production, 500, "Cannot read from input file: [%s] %s", ri->uri, mg_strerror(errno));
    }

    /* performing markdown parsing */
    ob = sd_bufnew(SD_OUTPUT_UNIT);

    sdhtml_renderer(&callbacks, &options, render_flags);
    markdown = sd_markdown_new(enabled_extensions, 16, &callbacks, &options);
    if (!markdown)
    {
        sd_bufrelease(ib);
        sd_bufrelease(ob);
        return report_markdown_failure(conn, is_inline_production, 500, "Out of memory while processing Markdown input file: [%s]", ri->uri);
    }
    sd_markdown_render(ob, ib->data, ib->size, markdown);
    sd_markdown_free(markdown);

    if (!is_inline_production)
    {
        /* write the appropriate headers */
        char date[64], lm[64], etag[64], range[64];
        time_t curtime = time(NULL);
        const char *hdr;
        int64_t cl, r1, r2;
        int n;

        mg_set_response_code(conn, 200);

        cl = ob->size;

        range[0] = '\0';

#if 0
        // If Range: header specified, act accordingly
        r1 = r2 = 0;
        hdr = mg_get_header(conn, "Range");
        if (hdr != NULL && (n = parse_range_header(hdr, &r1, &r2)) > 0) {
            conn->request_info.status_code = 206;
            (void) fseeko(fp, (off_t) r1, SEEK_SET);
            cl = n == 2 ? r2 - r1 + 1: cl - r1;
            (void) mg_snprintf(conn, range, sizeof(range),
                "Content-Range: bytes "
                "%" PRId64 "-%"
                PRId64 "/%" PRId64 "\r\n",
                r1, r1 + cl - 1, stp->size);
        }
#endif

        // Prepare Etag, Date, Last-Modified headers. Must be in UTC, according to
        // http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3
        mg_gmt_time_string(date, sizeof(date), &curtime);
        mg_gmt_time_string(lm, sizeof(lm), &st->mtime);
        (void) mg_snprintf(conn, etag, sizeof(etag), "%lx.%lx", (unsigned long) st->mtime, (unsigned long) st->size);

        (void) mg_printf(conn,
            "HTTP/1.1 %d %s\r\n"
            "Date: %s\r\n"
            "Last-Modified: %s\r\n"
            "Etag: \"%s\"\r\n"
            "Content-Type: text/html\r\n"
            "Content-Length: %" PRId64 "\r\n"
            "Connection: %s\r\n"
            // "Accept-Ranges: bytes\r\n"
            "%s\r\n"
            , ri->status_code, mg_get_response_code_text(ri->status_code)
            , date, lm, etag
            , cl
            , mg_suggest_connection_header(conn)
            , range
            );
        mg_mark_end_of_header_transmission(conn);

        ret = (int)cl;
        if (strcmp(ri->request_method, "HEAD") != 0) {
            ret = mg_write(conn, ob->data, (size_t)cl);
        }
    }
    else
    {
        ret = mg_write(conn, ob->data, ob->size);
    }

    /* cleanup */
    sd_bufrelease(ib);
    sd_bufrelease(ob);

    return ret;
}

static void *event_callback(enum mg_event event, struct mg_connection *conn) {
  struct mg_context *ctx = mg_get_context(conn);
  const struct mg_request_info *request_info = mg_get_request_info(conn);

  if (event == MG_INIT0)
  {
    verify_document_root(mg_get_conn_option(conn, "document_root"));
    //return (void *)1;
  }

#if defined(_WIN32)
  if (event == MG_EVENT_LOG)
  {
	if (strcmp(request_info->log_severity, "error"))
	{
		// only log these to file; no poluting the console
		return (void *)0;
	}
	else if (!strcmp(request_info->log_severity, "error") &&
		strstr(request_info->log_message, "cannot bind to"))
    {
      if (!error_dialog_shown_previously)
      {
        MessageBoxA(NULL, request_info->log_message, "Error", MB_OK);
        error_dialog_shown_previously = 1;
      }
	}
    //return 0;
  }
#endif

  if (event == MG_SSI_INCLUDE_REQUEST || event == MG_NEW_REQUEST) {
    struct mgstat st;
    int file_found;

    assert(request_info->phys_path);
    file_found = (0 == mg_stat(request_info->phys_path, &st) && !st.is_directory);
    if (file_found) {
      // are we looking for HTML output of MarkDown file?
      if (mg_match_prefix("**.md$|**.wiki$", -1, request_info->phys_path) > 0) {
        serve_a_markdown_page(conn, &st, (event == MG_SSI_INCLUDE_REQUEST));
        return "";
      }
      return NULL; // let mongoose handle the default of 'file exists'...
    }
  }

#ifdef _WIN32
  if (event == MG_NEW_REQUEST) {
    // Send the systray icon as favicon
    if (!strcmp("/favicon.ico", request_info->uri)) {
      HMODULE module;
      HRSRC icon;
      DWORD len;
      void *data;

      module = GetModuleHandle(NULL);

      icon = FindResource(module, MAKEINTRESOURCE(IDR_FAVICON), RT_RCDATA);
      data = LockResource(LoadResource(module, icon));
      len = SizeofResource(module, icon);

      mg_set_response_code(conn, 200);

      (void) mg_printf(conn,
          "HTTP/1.1 200 OK\r\n"
          "Content-Type: image/x-icon\r\n"
          "Cache-Control: no-cache\r\n"
          "Content-Length: %u\r\n"
          "Connection: close\r\n\r\n", (unsigned int)len);
      mg_mark_end_of_header_transmission(conn);

      if (len != mg_write(conn, data, len))
      {
        mg_send_http_error(conn, 580, NULL, "not all data was written to the socket (len: %u)", (unsigned int)len); // internal error in our custom handler or client closed connection prematurely
      }
      return (void *)1;
    }
  }
#endif

  return event_handler(event, conn);
}

#if defined(_WIN32)

static BOOL WINAPI mg_win32_break_handler(DWORD signal_type)
{
  switch(signal_type)
  {
  // Handle the CTRL-C signal.
  case CTRL_C_EVENT:
  // CTRL-CLOSE: confirm that the user wants to exit.
  case CTRL_CLOSE_EVENT:
  case CTRL_BREAK_EVENT:
    exit_flag = 1000 + signal_type;
    //mg_signal_stop(ctx);
    return TRUE;

  // Pass other signals to the next handler.
  case CTRL_LOGOFF_EVENT:
  case CTRL_SHUTDOWN_EVENT:
  default:
    return FALSE;
  }
}

#endif


static void start_mongoose(int argc, char *argv[]) {
    char *options[MAX_OPTIONS * 2] = { NULL };
    int i;
    struct mg_user_class_t userdef = {
        &mgr,
        &event_callback /* event_handler */,
        &option_decode,
        &option_fill,
        &option_get
    };

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

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

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

    /* Setup signal handler: quit on Ctrl-C */
    signal(SIGTERM, signal_handler);
    signal(SIGINT, signal_handler);
    signal(SIGABRT, signal_handler);
    signal(SIGILL, signal_handler);
    signal(SIGSEGV, signal_handler);
    signal(SIGFPE, signal_handler);
    // SIGINT and SIGTERM are pretty darn useless for Win32 applications.
    // See http://msdn.microsoft.com/en-us/library/ms685049%28VS.85%29.aspx
#if defined(_WIN32)
    if (!SetConsoleCtrlHandler(mg_win32_break_handler, TRUE))
    {
        die("Failed to set up the Win32 console Ctrl-Break handler.");
    }
#endif

    /* Start Mongoose */
    ctx = mg_start(&userdef, (const char **)options);
    for (i = 0; options[i] != NULL; i++) {
        free(options[i]);
    }

    if (ctx == NULL) {
        die("Failed to start Mongoose. Maybe some options are "
            "assigned bad values?\nTry to run with '-e error_log.txt' "
            "and check error_log.txt for more information.");
    }
}

#if defined(_WIN32) && defined(MONGOOSE_AS_SERVICE)
static SERVICE_STATUS ss;
static SERVICE_STATUS_HANDLE hStatus;
static const char *service_magic_argument = "--";

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 = RegisterServiceCtrlHandlerA(server_name, ControlHandler);
    SetServiceStatus(hStatus, &ss);

    while (ss.dwCurrentState == SERVICE_RUNNING) {
        mg_sleep(1000);
    }
    mg_stop(ctx);

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

#define ID_TRAYICON 100
#define ID_QUIT 101
#define ID_EDIT_CONFIG 102
#define ID_SEPARATOR 103
#define ID_INSTALL_SERVICE 104
#define ID_REMOVE_SERVICE 105

static NOTIFYICONDATAA TrayIcon;

static void edit_config_file(struct mg_context *ctx) {
    const char **names, *value;
    FILE *fp;
    int i;
    char cmd[200];

    // Create config file if it is not present yet
    if ((fp = mg_fopen(config_file, "r")) != NULL) {
        mg_fclose(fp);
    } else if ((fp = fopen(config_file, "a+")) != NULL) {
        fprintf(fp,
            "# Mongoose web server configuration file.\n"
            "# Lines starting with '#' and empty lines are ignored.\n"
            "# For detailed description of every option, visit\n"
            "# http://code.google.com/p/mongoose/wiki/MongooseManual\n\n");
        names = mg_get_valid_option_names();
        for (i = 0; names[i] != NULL; i += MG_ENTRIES_PER_CONFIG_OPTION) {
            value = mg_get_option(ctx, names[i + 1]);
            fprintf(fp, "# %s %s\n", names[i + 1], *value ? value : "<value>");
        }
        mg_fclose(fp);
    }

    snprintf(cmd, sizeof(cmd), "notepad.exe %s", config_file);
    WinExec(cmd, SW_SHOW);
}

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

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

    if ((hSCM = OpenSCManager(NULL, NULL, action == ID_INSTALL_SERVICE ?
            GENERIC_WRITE : GENERIC_READ)) == NULL) {
    success = 0;
    show_error();
    } else if (action == ID_INSTALL_SERVICE) {
        GetModuleFileNameA(NULL, path, sizeof(path));
        strncat(path, " ", sizeof(path));
        strncat(path, service_magic_argument, sizeof(path));
        hService = CreateServiceA(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 = OpenServiceA(hSCM, service_name, DELETE)) == NULL ||
            !DeleteService(hService)) {
                show_error();
        }
    } else if ((hService = OpenServiceA(hSCM, service_name,
        SERVICE_QUERY_STATUS)) == NULL) {
            success = 0;
    }

    CloseServiceHandle(hService);
    CloseServiceHandle(hSCM);

    return success;
}

static LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam,
                                   LPARAM lParam) {
  static SERVICE_TABLE_ENTRYA service_table[] = {
    {server_name, (LPSERVICE_MAIN_FUNCTIONA) ServiceMain},
        {NULL, NULL}
    };
    int service_installed;
    char buf[200], *service_argv[] = {__argv[0], NULL};
    POINT pt;
    HMENU hMenu;

    switch (msg) {
    case WM_CREATE:
        if (__argv[1] != NULL &&
            !strcmp(__argv[1], service_magic_argument)) {
                start_mongoose(1, service_argv);
                StartServiceCtrlDispatcherA(service_table);
                exit(EXIT_SUCCESS);
        } else {
            start_mongoose(__argc, __argv);
        }
        break;
    case WM_COMMAND:
        switch (LOWORD(wParam)) {
        case ID_QUIT:
            mg_stop(ctx);
            Shell_NotifyIconA(NIM_DELETE, &TrayIcon);
          PostQuitMessage(EXIT_SUCCESS);
            break;
        case ID_EDIT_CONFIG:
            edit_config_file(ctx);
            break;
        case ID_INSTALL_SERVICE:
        case ID_REMOVE_SERVICE:
            manage_service(LOWORD(wParam));
            break;
        }
        break;
    case WM_USER:
        switch (lParam) {
        case WM_RBUTTONUP:
        case WM_LBUTTONUP:
        case WM_LBUTTONDBLCLK:
            hMenu = CreatePopupMenu();
            AppendMenuA(hMenu, MF_STRING | MF_GRAYED, ID_SEPARATOR, server_name);
            AppendMenuA(hMenu, MF_SEPARATOR, ID_SEPARATOR, "");
            service_installed = manage_service(0);
            snprintf(buf, sizeof(buf), "NT service: %s installed",
                service_installed ? "" : "not");
            AppendMenuA(hMenu, MF_STRING | MF_GRAYED, ID_SEPARATOR, buf);
            AppendMenuA(hMenu, MF_STRING | (service_installed ? MF_GRAYED : 0),
                     ID_INSTALL_SERVICE, "Install service");
            AppendMenuA(hMenu, MF_STRING | (!service_installed ? MF_GRAYED : 0),
                     ID_REMOVE_SERVICE, "Deinstall service");
            AppendMenuA(hMenu, MF_SEPARATOR, ID_SEPARATOR, "");
            AppendMenuA(hMenu, MF_STRING, ID_EDIT_CONFIG, "Edit config file");
            AppendMenuA(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;
    }

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

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR cmdline, int show) {
    WNDCLASSA cls;
    HWND hWnd;
    MSG msg;

    init_server_name();
    memset(&cls, 0, sizeof(cls));
    cls.lpfnWndProc = (WNDPROC) WindowProc;
    cls.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    cls.lpszClassName = server_name;

    RegisterClassA(&cls);
    hWnd = CreateWindowA(cls.lpszClassName, server_name, WS_OVERLAPPEDWINDOW,
        0, 0, 0, 0, NULL, NULL, NULL, NULL);
    ShowWindow(hWnd, SW_HIDE);

    TrayIcon.cbSize = sizeof(TrayIcon);
    TrayIcon.uID = ID_TRAYICON;
    TrayIcon.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
    TrayIcon.hIcon = LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON),
        IMAGE_ICON, 16, 16, 0);
    TrayIcon.hWnd = hWnd;
    snprintf(TrayIcon.szTip, sizeof(TrayIcon.szTip), "%s", server_name);
    TrayIcon.uCallbackMessage = WM_USER;
    Shell_NotifyIconA(NIM_ADD, &TrayIcon);

    while (GetMessage(&msg, hWnd, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

  // return the WM_QUIT value:
  return msg.wParam;
}
#else
int main(int argc, char *argv[]) {
    init_server_name();
    start_mongoose(argc, argv);
    printf("%s started on port(s) %s with web root [%s]\n",
        server_name, mg_get_option(ctx, "listening_ports"),
        mg_get_option(ctx, "document_root"));
    while (exit_flag == 0 && !mg_get_stop_flag(ctx)) {
        mg_sleep(100);
    }
    printf("Exiting on signal %d/%d, waiting for all threads to finish...",
        exit_flag, mg_get_stop_flag(ctx));
    fflush(stdout);
    mg_stop(ctx);
    printf(" done.\n");

    return EXIT_SUCCESS;
}
#endif /* _WIN32 */