// SPDX-License-Identifier: AGPL-1.0-only
// Copyright (C) 2018 Ludvig Strigeus <info@tunsafe.com>. All Rights Reserved.
#include "stdafx.h"
#include "wireguard_config.h"
#include "network_win32_api.h"
#include "network_win32_dnsblock.h"
#include <Commctrl.h>
#include <stdlib.h>
#include <assert.h>
#include <malloc.h>
#include <stddef.h>
#include "resource.h"
#include <string.h>
#include <Richedit.h>
#include <vector>
#include <Iphlpapi.h>
#include <assert.h>
#include <shldisp.h>
#include <shlobj.h>
#include <exdisp.h>
#include "tunsafe_endian.h"
#include "util.h"
#include <atlbase.h>
#include <algorithm>
#include "crypto/curve25519-donna.h"
#include "service_win32.h"
#include "util_win32.h"

#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "rpcrt4.lib")
#pragma comment(lib,"comctl32.lib")
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")

void InitCpuFeatures();
void PrintCpuFeatures();
void Benchmark();
static const char *GetCurrentConfigTitle(char *buf, size_t max_size);
static char *PrintMB(char *buf, int64 bytes);
static void LoadConfigFile(const char *filename, bool save, bool force_start);
static void SetCurrentConfigFilename(const char *filename);
static void CreateLocalOrRemoteBackend(bool remote);
static void UpdateGraphReq();

#pragma warning(disable: 4200)

static bool g_is_connected_to_server;
static bool g_notified_connected_server;
static HWND g_ui_window;
static HICON g_icons[2];
static bool g_minimize_on_connect;

static bool g_ui_visible;
static char *g_current_filename;
static HINSTANCE g_hinstance;
static TunsafeBackend *g_backend;
static TunsafeBackend::Delegate *g_backend_delegate;
static const char *g_cmdline_filename;
static bool g_first_state_msg;
static bool g_is_limited_uac_account;
static bool g_is_tunsafe_service_running;
static bool g_disable_connect_on_start;
static bool g_not_first_status_msg; 
static HANDLE g_runonce_mutex;
static int g_startup_flags;
static HKEY g_reg_key;
static HKEY g_hklm_reg_key;
static HKEY g_hklm_readonly_reg_key;
static HWND hwndPaintBox, hwndStatus, hwndGraphBox, hwndTab, hwndAdvancedBox, hwndEdit;
static WgProcessorStats g_processor_stats;
static int g_large_fonts;
static TunsafeBackend::StatusCode g_status_code;
static UINT g_message_taskbar_created;
static int g_current_tab;
static bool wm_dropfiles_recursive;
static bool g_has_icon;
static int g_selected_graph_type;
static RECT comborect;
static HBITMAP arrowbitmap;
static uint32 g_timestamp_of_exit_menuloop;
enum UpdateIconWhy {
  UIW_NONE = 0,
  UIW_STOPPED_WORKING_FAIL = 1,
  UIW_START = 2,
};
static void UpdateIcon(UpdateIconWhy error);


int RescaleDpi(int size) {
  return (g_large_fonts == 96) ? size : size * g_large_fonts / 96;
}

RECT RescaleDpiRect(const RECT &r) {
  RECT rr = r;
  if (g_large_fonts != 96) {
    rr.left = rr.left * g_large_fonts / 96;
    rr.top = rr.top * g_large_fonts / 96;
    rr.right = rr.right * g_large_fonts / 96;
    rr.bottom = rr.bottom * g_large_fonts / 96;
  }
  return rr;
}

static void SetUiVisibility(bool visible) {
  g_ui_visible = visible;
  ShowWindow(g_ui_window, visible ? SW_SHOW : SW_HIDE);
  g_backend->RequestStats(visible);
  UpdateGraphReq();
}

static bool GetConfigFullName(const char *basename, char *fullname, size_t fullname_size) {
  size_t len = strlen(basename);

  if (FindFilenameComponent(basename)[0]) {
    if (len >= fullname_size)
      return false;
    memcpy(fullname, basename, len + 1);
    return true;
  }
  size_t clen = GetConfigPath(fullname, fullname_size);
  if (clen == 0 || clen + len >= fullname_size)
    return false;
  memcpy(fullname + clen, basename, (len + 1) * sizeof(fullname[0]));
  return true;
}


void StopTunsafeBackend(UpdateIconWhy why) {
  if (g_backend->is_started()) {
    g_backend->Stop();
    if (g_is_connected_to_server)
      RINFO("Disconnected");
    g_is_connected_to_server = false;
    UpdateIcon(why);
    RegWriteInt(g_reg_key, "IsConnected", 0);
  }
}

const char *print_ip(char buf[kSizeOfAddress], in_addr_t ip) {
  snprintf(buf, kSizeOfAddress, "%d.%d.%d.%d", (ip >> 24) & 0xff, (ip >> 16) & 0xff, (ip >> 8) & 0xff, (ip >> 0) & 0xff);
  return buf;
}

void StartTunsafeBackend(UpdateIconWhy reason) {
  if (!*g_current_filename)
    return;

  // recreate service connection
  if (g_backend->status() == TunsafeBackend::kErrorServiceLost)
    CreateLocalOrRemoteBackend(g_backend->is_remote());

  if (g_backend->is_remote() && !EnsureValidConfigPath(g_current_filename)) {
    RERROR("The config file needs to be in the Config-directory. Maybe the TunSafe\r\n   process doesn't match with the running service. Try selecting 'Don't Use a Service'.");
    StopTunsafeBackend(UIW_NONE);
    return;
  }
  g_notified_connected_server = false;
  g_is_connected_to_server = false;
  g_backend->Start(g_current_filename);
  RegWriteInt(g_reg_key, "IsConnected", 1);
}

static void InvalidatePaintbox() {
  InvalidateRect(hwndPaintBox, NULL, FALSE);
}

class MyBackendDelegate : public TunsafeBackend::Delegate {
public:
  virtual void OnGraphAvailable() {
    InvalidateRect(hwndGraphBox, NULL, FALSE);
  }

  virtual void OnGetStats(const WgProcessorStats &stats) {
    g_processor_stats = stats;
    InvalidatePaintbox();

    char buf[64];
    uint32 mbs_in = (uint32)(stats.tun_bytes_out_per_second * (1.0 / 1250));
    uint32 gb_in = (uint32)(stats.tun_bytes_out * (1.0 / (1024 * 1024 * 1024 / 100)));

    snprintf(buf, ARRAYSIZE(buf), "D: %d.%.2d Mbps (%d.%.2d GB)", mbs_in / 100, mbs_in % 100, gb_in / 100, gb_in % 100);
    SendMessage(hwndStatus, SB_SETTEXT, 1, (LPARAM)buf);

    uint32 mbs_out = (uint32)(stats.tun_bytes_in_per_second * (1.0 / 1250));
    uint32 gb_out = (uint32)(stats.tun_bytes_in * (1.0 / (1024 * 1024 * 1024 / 100)));

    snprintf(buf, ARRAYSIZE(buf), "U: %d.%.2d Mbps (%d.%.2d GB)", mbs_out / 100, mbs_out % 100, gb_out / 100, gb_out % 100);
    SendMessage(hwndStatus, SB_SETTEXT, 2, (LPARAM)buf);

    InvalidateRect(hwndAdvancedBox, NULL, FALSE);
  }

  virtual void OnLogLine(const char **s) {
    CHARRANGE cr;
    cr.cpMin = -1;
    cr.cpMax = -1;
    // hwnd = rich edit hwnd
    SendMessage(hwndEdit, EM_EXSETSEL, 0, (LPARAM)&cr);
    SendMessage(hwndEdit, EM_REPLACESEL, 0, (LPARAM)*s);
  }

  virtual void OnStateChanged() {
    if (!g_first_state_msg) {
      g_first_state_msg = true;
      char fullname[1024];

      const char *filename = g_cmdline_filename;
      if (filename) {
        if (GetConfigFullName(filename, fullname, sizeof(fullname)))
          SetCurrentConfigFilename(fullname);
      } else {
        std::string currconfig = g_backend->GetConfigFileName();
        if (currconfig.empty()) {
          char *conf = RegReadStr(g_reg_key, "ConfigFile", "TunSafe.conf");
          if (GetConfigFullName(conf, fullname, sizeof(fullname)))
            SetCurrentConfigFilename(fullname);
          free(conf);
        } else {
          SetCurrentConfigFilename(currconfig.c_str());
        }
      }

      if (filename != NULL || !(g_startup_flags & kStartupFlag_BackgroundService) && !g_disable_connect_on_start && RegReadInt(g_reg_key, "IsConnected", 0)) {
        StartTunsafeBackend(UIW_START);
      } else {
        if (!g_backend->is_started())
          RINFO("Press Connect to initiate a connection to the WireGuard server.");
      }
    }

    bool running = g_backend->is_started();
    SetDlgItemText(g_ui_window, ID_START, running ? "Re&connect" : "&Connect");
    InvalidatePaintbox();
    EnableWindow(GetDlgItem(g_ui_window, ID_STOP), running);
  }

  virtual void OnStatusCode(TunsafeBackend::StatusCode status) override {
    g_status_code = status;
    if (TunsafeBackend::IsPermanentError(status)) {
      UpdateIcon(g_is_connected_to_server ? UIW_STOPPED_WORKING_FAIL : UIW_NONE);
      InvalidatePaintbox();
      return;
    }
    bool is_connected = (status == TunsafeBackend::kStatusConnected);
    if (is_connected && g_minimize_on_connect) {
      g_minimize_on_connect = false;
      SetUiVisibility(false);
    }

    bool not_first = g_not_first_status_msg;
    g_not_first_status_msg = true;

    if (is_connected != g_is_connected_to_server) {
      g_is_connected_to_server = is_connected;
      // avoid showing a notice if service is already connected
      if (is_connected > not_first && (g_startup_flags & kStartupFlag_BackgroundService))
        g_notified_connected_server = true;
      UpdateIcon(UIW_NONE);
      InvalidatePaintbox();
    }
  }

  virtual void OnClearLog() override {
    SetWindowText(hwndEdit, "");
  }
};

static MyBackendDelegate my_procdel;

static void CreateLocalOrRemoteBackend(bool remote) {
  delete g_backend;

  g_first_state_msg = false;

  if (!remote) {
    g_backend = CreateNativeTunsafeBackend(g_backend_delegate);
  } else {
    RINFO("Connecting to the TunSafe Service...");
    g_backend = CreateTunsafeServiceClient(g_backend_delegate);
  }

  g_backend->RequestStats(g_ui_visible);
}

static char *PrintMB(char *buf, int64 bytes) {
  char *bo = buf;
  if (bytes < 0) {
    *buf++ = '-';
    bytes = -bytes;
  }
  int64 big = bytes / (1024*1024);
  int little = bytes % (1024*1024);
  if (bytes < 10*1024*1024) {
    // X.XXX
    snprintf(buf, 64, "%lld.%.3d MB", big, 1000 * little / (1024*1024));
  } else if (bytes < 100*1024*1024) {
    // XX.XX
    snprintf(buf, 64, "%lld.%.2d MB", big, 100 * little / (1024*1024));
  } else {
    // XX.X
    snprintf(buf, 64, "%lld.%.1d MB", big, 10 * little / (1024*1024));
  }
  return bo;
}

static void UpdateIcon(UpdateIconWhy why) {
  NOTIFYICONDATA nid;
  memset(&nid, 0, sizeof(nid));
  nid.cbSize = sizeof(nid);
  nid.hWnd = g_ui_window;
  nid.uID = 1;
  nid.uVersion = NOTIFYICON_VERSION;
  nid.uCallbackMessage = WM_USER + 1;
  nid.uFlags = NIF_MESSAGE | NIF_TIP | NIF_ICON;
  nid.hIcon = g_icons[g_is_connected_to_server ? 0 : 1];
  
  char buf[kSizeOfAddress];
  char namebuf[128];
  if (g_is_connected_to_server) {
    snprintf(nid.szTip, sizeof(nid.szTip), "TunSafe [%s - %s]", GetCurrentConfigTitle(namebuf, sizeof(namebuf)), print_ip(buf, g_backend->GetIP()));
    if (!g_notified_connected_server) {
      g_notified_connected_server = true;
      nid.uFlags |= NIF_INFO;
      snprintf(nid.szInfoTitle, sizeof(nid.szInfoTitle), "Connected to: %s", namebuf);
      snprintf(nid.szInfo, sizeof(nid.szInfo), "IP: %s", buf);
      nid.uTimeout = 5000;
      nid.dwInfoFlags = NIIF_INFO;
    }
  } else {
    g_notified_connected_server = false;
    snprintf(nid.szTip, sizeof(nid.szTip), "TunSafe [%s]", "Disconnected");

    if (why == UIW_STOPPED_WORKING_FAIL) {
      nid.uFlags |= NIF_INFO;
      strcpy(nid.szInfoTitle, "Disconnected!");
      strcpy(nid.szInfo, "There was a problem with the connection. You are now disconnected.");
      nid.uTimeout = 5000;
      nid.dwInfoFlags = NIIF_ERROR;
    }
  }
  Shell_NotifyIcon(g_has_icon ? NIM_MODIFY : NIM_ADD, &nid);

  SendMessage(g_ui_window, WM_SETICON, ICON_SMALL, (LPARAM)g_icons[g_is_connected_to_server ? 0 : 1]);

  g_has_icon = true;
}

static void RemoveIcon() {
  if (g_has_icon) {
    NOTIFYICONDATA nid;
    memset(&nid, 0, sizeof(nid));
    nid.cbSize = sizeof(nid);
    nid.hWnd = g_ui_window;
    nid.uID = 1;
    Shell_NotifyIcon(NIM_DELETE, &nid);
  }
}

#define MAX_CONFIG_FILES 1024
#define ID_POPUP_CONFIG_FILE 10000
char *config_filenames[MAX_CONFIG_FILES];
uint8 config_filenames_indent[MAX_CONFIG_FILES];

static char *StripConfExtension(const char *src, char *target, size_t size) {
  size_t len = strlen(src);
  if (len >= 5 && memcmp(src + len - 5, ".conf", 5) == 0)
    len -= 5;

  len = std::min(len, size - 1);
  target[len] = 0;
  memcpy(target, src, len);
  return target;
}

static const char *GetCurrentConfigTitle(char *target, size_t size) {
  const char *ll = FindFilenameComponent(g_current_filename);
  return StripConfExtension(ll, target, size);
}

static void SetCurrentConfigFilename(const char *filename) {
  str_set(&g_current_filename, filename);
  char namebuf[64];
  char *f = str_cat_alloc("TunSafe - ", GetCurrentConfigTitle(namebuf, sizeof(namebuf)));
  SetWindowText(g_ui_window, f);
  free(f);

  InvalidateRect(hwndPaintBox, NULL, FALSE);
}


static void LoadConfigFile(const char *filename, bool save, bool force_start) {
  SetCurrentConfigFilename(filename);

  if (force_start || g_backend->is_started())
    StartTunsafeBackend(UIW_START);

  if (save)
    RegWriteStr(g_reg_key, "ConfigFile", filename);
}

class ConfigMenuBuilder {
public:
  ConfigMenuBuilder();
 
  void Recurse();

  int depth_;
  int nfiles_;
  size_t bufpos_;
  WIN32_FIND_DATA wfd_;
  char buf_[1024];
};

ConfigMenuBuilder::ConfigMenuBuilder() 
    : nfiles_(0), depth_(0) {
  if (!GetConfigFullName("", buf_, sizeof(buf_)))
    bufpos_ = sizeof(buf_);
  else
    bufpos_ = strlen(buf_);
}

void ConfigMenuBuilder::Recurse() {
  if (bufpos_ >= sizeof(buf_) - 4)
    return;
  memcpy(buf_ + bufpos_, "*.*", 4);
  HANDLE handle = FindFirstFile(buf_, &wfd_);
  if (handle != INVALID_HANDLE_VALUE) {
    do {
      if (wfd_.cFileName[0] == '.')
        continue;

      size_t len = strlen(wfd_.cFileName);
      if (bufpos_ + len >= sizeof(buf_) - 1)
        continue;
      size_t old_bufpos = bufpos_;
      memcpy(buf_ + bufpos_, wfd_.cFileName, len + 1);
      bufpos_ = bufpos_ + len + 1;
      config_filenames_indent[nfiles_] = depth_ + !!(wfd_.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
      str_set(&config_filenames[nfiles_], buf_);
      nfiles_++;
      if (nfiles_ == MAX_CONFIG_FILES)
        break;
      if (wfd_.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
        buf_[bufpos_ - 1] = '\\';
        depth_++;
        if (depth_ < 16)
          Recurse();
        depth_--;
        if (nfiles_ == MAX_CONFIG_FILES)
          break;
      }
      bufpos_ = old_bufpos;
    } while (FindNextFile(handle, &wfd_));
    FindClose(handle);
  }
}


static int AddToAvailableFilesPopup(HMENU menu, int max_num_items, bool is_settings) {
  ConfigMenuBuilder menu_builder;
  HMENU where[16] = {0};

  menu_builder.Recurse();

  bool is_connected = g_backend->is_started();
  uint32 last_indent = 0;
  where[0] = menu;

  for (int i = 0; i < menu_builder.nfiles_; i++) {
    uint32 indent = config_filenames_indent[i];
    if (indent > last_indent) {
      HMENU n = CreatePopupMenu();
      where[indent] = n;
      AppendMenu(where[last_indent], MF_POPUP, (UINT_PTR)n, FindFilenameComponent(config_filenames[i]));
    } else {
      bool selected_item = (strcmp(g_current_filename, config_filenames[i]) == 0);
      AppendMenu(where[indent], (selected_item && is_connected) ?
          MF_CHECKED : 0, ID_POPUP_CONFIG_FILE + i,
          StripConfExtension(
            FindFilenameComponent(config_filenames[i]), menu_builder.buf_, sizeof(menu_builder.buf_)));
      if (selected_item)
        SetMenuDefaultItem(where[indent], ID_POPUP_CONFIG_FILE + i, MF_BYCOMMAND);
    }
    last_indent = indent;
  }

  if (menu_builder.nfiles_ == 0)
    AppendMenu(menu, MF_GRAYED | MF_DISABLED, 0, "(no config files found)");

  return menu_builder.nfiles_;
}

static void ShowSettingsMenu(HWND wnd) {
  HMENU menu = CreatePopupMenu();

  AddToAvailableFilesPopup(menu, 10, true);

  //POINT pt;
  //GetCursorPos(&pt);

  RECT r = GetParentRect(GetDlgItem(g_ui_window, ID_START));

  RECT r2 = GetParentRect(hwndPaintBox);

  POINT pt = {r2.left, r.bottom};

  ClientToScreen(g_ui_window, &pt);




  int rv = TrackPopupMenu(menu, 0, pt.x, pt.y, 0, wnd, NULL);
  DestroyMenu(menu);
}

static bool HasReadWriteAccess(const char *filename) {
  HANDLE fileH = CreateFile(filename,
                            GENERIC_READ | GENERIC_WRITE,
                            FILE_SHARE_READ | FILE_SHARE_WRITE, // For Exclusive access
                            0,
                            OPEN_EXISTING,
                            FILE_ATTRIBUTE_NORMAL,
                            NULL);
  if (fileH != INVALID_HANDLE_VALUE) {
    CloseHandle(fileH);
    return true;
  }
  return false;
}

static void OpenEditor() {
  SHELLEXECUTEINFO shinfo = {0};
  shinfo.hwnd = g_ui_window;
  shinfo.cbSize = sizeof(shinfo);
  shinfo.nShow = SW_SHOWNORMAL;

  if (g_current_filename[0]) {
    if (!HasReadWriteAccess(g_current_filename)) {
      // Need to runas admin
      char buf[1024];
      if (!ExpandEnvironmentStrings("%windir%\\system32\\notepad.exe", buf, sizeof(buf)))
        return;
      shinfo.lpFile = buf;
      char *filename = str_cat_alloc("\"", g_current_filename, "\"");
      shinfo.lpParameters = filename;
      shinfo.lpVerb = "runas";
      ShellExecuteEx(&shinfo);
      free(filename);
    } else {
      shinfo.fMask = SEE_MASK_CLASSNAME;
      shinfo.lpFile = g_current_filename;
      shinfo.lpParameters = "";
      shinfo.lpClass = ".txt";
      ShellExecuteEx(&shinfo);
    }
  }
}

static void BrowseFiles() {
  char buf[MAX_PATH];
  if (GetConfigFullName("", buf, ARRAYSIZE(buf))) {
    size_t l = strlen(buf);
    buf[l - 1] = 0;
    ShellExecuteFromExplorer(buf, NULL, NULL, "explore");
  }
}

bool ImportFile(const char *s, bool silent = false) {
  char buf[1024];
  char mesg[1024];
  size_t filesize;
  const char *last = FindFilenameComponent(s);
  uint8 *filedata = NULL;
  bool rv = false;
  int filerv;

  if (!*last || !GetConfigFullName(last, buf, ARRAYSIZE(buf)) || _stricmp(buf, s) == 0)
    goto out;

  filedata = LoadFileSane(s, &filesize);
  if (!filedata)
    goto out;

  if (!silent) {
    if (FileExists(buf)) {
      snprintf(mesg, ARRAYSIZE(mesg), "A file already exists with the name '%s' in the configuration folder. Do you want to overwrite it?", last);
      if (MessageBoxA(g_ui_window, mesg, "TunSafe", MB_OKCANCEL | MB_ICONEXCLAMATION) != IDOK)
        goto out;
    } else {
      snprintf(mesg, ARRAYSIZE(mesg), "Do you want to import '%s' into TunSafe?", last);
      if (MessageBoxA(g_ui_window, mesg, "TunSafe", MB_OKCANCEL | MB_ICONQUESTION) != IDOK)
        goto out;
    }
  }

  filerv = WriteOutFile(buf, filedata, filesize);
  
  // elevate?
  if (filerv == kWriteOutFile_AccessError && g_is_limited_uac_account) {
    char *args = str_cat_alloc("--import \"", s, "\"");
    rv = RunProcessAsAdminWithArgs(args, true);
    free(args);
    return rv;
  }

  rv = (filerv == kWriteOutFile_Ok);
  if (!rv)
    DeleteFileA(buf);

out:
  free(filedata);

  if (!silent) {
    if (rv)
      LoadConfigFile(buf, true, false);
    else
      MessageBoxA(g_ui_window, "There was a problem importing the file.", "TunSafe", MB_ICONEXCLAMATION);
  }
  return !rv;
}

void ShowUI(HWND hWnd) {
  SetUiVisibility(true);
  BringWindowToTop(hWnd);
  SetForegroundWindow(hWnd);
}

void HandleDroppedFiles(HWND wnd, HDROP hdrop) {
  char buf[MAX_PATH];
  if (DragQueryFile(hdrop, -1, NULL, 0) == 1) {
    if (DragQueryFile(hdrop, 0, buf, ARRAYSIZE(buf))) {
      SetForegroundWindow(wnd);
      ImportFile(buf);
    }
  }
  DragFinish(hdrop);
}

void BrowseFile(HWND wnd) {
  char szFile[1024];

  // open a file name
  OPENFILENAME ofn = {0};
  ofn.lStructSize = sizeof(ofn);
  ofn.hwndOwner = g_ui_window;
  ofn.lpstrFile = szFile;
  ofn.lpstrFile[0] = '\0';
  ofn.nMaxFile = sizeof(szFile);
  ofn.lpstrFilter = "Config Files (*.conf)\0*.conf\0";
  ofn.nFilterIndex = 1;
  ofn.lpstrFileTitle = NULL;
  ofn.nMaxFileTitle = 0;
  ofn.lpstrInitialDir = NULL;
  ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
  if (GetOpenFileName(&ofn))
    ImportFile(szFile);
}

static const uint8 kCurve25519Basepoint[32] = {9};

static void SetKeyBox(HWND wnd, int ctr, uint8 buf[32]) {
  uint8 *privs = base64_encode(buf, 32, NULL);
  SetDlgItemText(wnd, ctr, (char*)privs);
  free(privs);
}

static INT_PTR WINAPI KeyPairDlgProc(HWND hWnd, UINT message, WPARAM wParam,
                              LPARAM lParam) {
  switch (message) {
  case WM_INITDIALOG:
    return TRUE;
  case WM_CLOSE:
    EndDialog(hWnd, 0);
    return TRUE;
  case WM_COMMAND:
    switch (wParam) {
    case IDCANCEL:
      EndDialog(hWnd, 0);
      return TRUE;
    case IDC_PRIVATE_KEY | (EN_CHANGE << 16) : {
      char buf[128];
      uint8 pub[32];
      uint8 priv[32];
      buf[0] = 0;
      size_t len = GetDlgItemText(hWnd, IDC_PRIVATE_KEY, buf, sizeof(buf));
      size_t olen = 32;
      if (base64_decode((uint8*)buf, len, priv, &olen) && olen == 32) {
        curve25519_donna(pub, priv, kCurve25519Basepoint);
        SetKeyBox(hWnd, IDC_PUBLIC_KEY, pub);
      } else {
        SetDlgItemText(hWnd, IDC_PUBLIC_KEY, "(Invalid Private Key)");
      }

      return TRUE;
    }
    case IDRAND: {
      uint8 priv[32];
      uint8 pub[32];
      OsGetRandomBytes(priv, 32);
      curve25519_normalize(priv);
      curve25519_donna(pub, priv, kCurve25519Basepoint);
      SetKeyBox(hWnd, IDC_PRIVATE_KEY, priv);
      SetKeyBox(hWnd, IDC_PUBLIC_KEY, pub);
      return TRUE;
    }
    }
  }
  return FALSE;
}

static void SetStartupFlags(int new_flags) {
  // Determine whether to autorun or not.
  bool autorun = (new_flags & kStartupFlag_MinimizeToTrayWhenWindowsStarts) ||
                 !(new_flags & kStartupFlag_BackgroundService) && (new_flags & kStartupFlag_ConnectWhenWindowsStarts);

  // Update the autorun key.
  HKEY hkey;
  LSTATUS result;
  result = RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_WRITE, &hkey);
  if (result == 0) {
    if (autorun) {
      wchar_t buf[512 + 32];
      buf[0] = '"';
      DWORD len = GetModuleFileNameW(NULL, buf + 1, 512);
      if (len < 512) {
        memcpy(buf + len + 1, L"\" --autostart", sizeof(wchar_t) * 14);
        result = RegSetValueExW(hkey, L"TunSafe", NULL, REG_SZ, (BYTE*)buf, (DWORD)(len + 15) * sizeof(wchar_t));
      } else {
        RERROR("Unable to add to startup list, filename too long.");
      }
    } else {
      RegDeleteValueW(hkey, L"TunSafe");
    }
    RegCloseKey(hkey);
  }
  if (result != 0)
    RERROR("Unable to modify startup list, error code = 0x%x", (int)result);

  RegWriteInt(g_reg_key, "StartupFlags", new_flags);

  bool was_started = g_backend && g_backend->is_started();
  bool recreate_backend = false;

  if (!!(new_flags & (kStartupFlag_BackgroundService | kStartupFlag_ForegroundService))) {
    // Want to run as a service - make sure service is installed and running.
    if (!IsTunsafeServiceRunning()) {
      g_backend->Stop();
      RINFO("Starting TunSafe service...");
      InstallTunSafeWindowsService();
      recreate_backend = true;
    }
} else {
    if (IsTunSafeServiceInstalled()) {
      g_backend->Stop();
      g_backend->Teardown();

      RINFO("Removing TunSafe service...");
      // Don't want to run as a service - Make sure we delete the service.
      if (g_is_limited_uac_account) {
        // Need to stop this early so service process is able to open.
        CloseHandle(g_runonce_mutex);
        if (!RunProcessAsAdminWithArgs("--delete-service-and-start", false)) {
          RINFO("Unable to stop and remove service");
          uint32 m = kStartupFlag_BackgroundService | kStartupFlag_ForegroundService;
          new_flags = (g_startup_flags & m) | (new_flags & ~m);
        } else {
          PostQuitMessage(0);
          return;
        }
      } else {
        if (!UninstallTunSafeWindowsService()) {
          RINFO("Unable to stop and remove service");
          uint32 m = kStartupFlag_BackgroundService | kStartupFlag_ForegroundService;
          new_flags = (g_startup_flags & m) | (new_flags & ~m);
        }
      }
      recreate_backend = true;
    }
  }
  if (recreate_backend) {
    CreateLocalOrRemoteBackend(!!(new_flags & (kStartupFlag_BackgroundService | kStartupFlag_ForegroundService)));
    if (was_started)
      StartTunsafeBackend(UIW_START);
  }
  g_startup_flags = new_flags;
  g_backend->SetServiceStartupFlags(g_startup_flags);
}

enum {
  kTab_Logs = 0,
  kTab_Charts = 1,
  kTab_Advanced = 2,
};

static void UpdateGraphReq() {
  if (g_backend && (g_current_tab != 1 || !g_ui_visible))
    g_backend->GetGraph(0);
}

static void UpdateTabSelection() {
  int tab = TabCtrl_GetCurSel(hwndTab);
  HWND wnd = g_ui_window;
  g_current_tab = tab;
  ShowWindow(hwndEdit, (tab == kTab_Logs) ? SW_SHOW : SW_HIDE);
  ShowWindow(hwndGraphBox, (tab == kTab_Charts) ? SW_SHOW : SW_HIDE);
  ShowWindow(hwndAdvancedBox, (tab == kTab_Advanced) ? SW_SHOW : SW_HIDE);
  UpdateGraphReq();
}

struct WindowSizingItem {
  uint16 id;
  uint16 edges;
};

enum {
  WSI_LEFT = 1,
  WSI_RIGHT = 2,
  WSI_TOP = 4,
  WSI_BOTTOM = 8,
};

static const WindowSizingItem kWindowSizing[] = {
  {ID_START,WSI_LEFT | WSI_RIGHT},
  {ID_STOP,WSI_LEFT | WSI_RIGHT},
  {ID_EDITCONF,WSI_LEFT | WSI_RIGHT},
  {IDC_PAINTBOX,WSI_RIGHT},
  {IDC_TAB, WSI_RIGHT | WSI_BOTTOM},
};

static void HandleWindowSizing() {
  RECT wr;

  GetClientRect(g_ui_window, &wr);

  static int g_orig_w, g_orig_h;
  static RECT g_orig_rects[ARRAYSIZE(kWindowSizing)];

  if (g_orig_w == 0) {
    g_orig_w = wr.right;
    g_orig_h = wr.bottom;
    for (size_t i = 0; i < ARRAYSIZE(kWindowSizing); i++) {
      const WindowSizingItem *it = &kWindowSizing[i];
      g_orig_rects[i] = GetParentRect(GetDlgItem(g_ui_window, it->id));
    }
  }

  int dx = wr.right - g_orig_w;
  int dy = wr.bottom - g_orig_h;

  if (dx|dy) {
    HDWP dwp = BeginDeferWindowPos(10), dwp_next;
    for (size_t i = 0; i < ARRAYSIZE(kWindowSizing); i++) {
      const WindowSizingItem *it = &kWindowSizing[i];
      HWND wnd = GetDlgItem(g_ui_window, it->id);
      RECT r = g_orig_rects[i];
      if (it->edges & WSI_LEFT) r.left += dx;
      if (it->edges & WSI_RIGHT) r.right += dx;
      if (it->edges & WSI_TOP) r.top += dy;
      if (it->edges & WSI_BOTTOM) r.bottom += dy;
      if (r.right < r.left) r.right = r.left;
      if (r.bottom < r.top) r.bottom = r.top;
      dwp_next = DeferWindowPos(dwp, wnd, NULL, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_NOZORDER | SWP_NOREPOSITION | SWP_NOACTIVATE);
      dwp = dwp_next ? dwp_next : dwp;
    }
    EndDeferWindowPos(dwp);
  }

  RECT rect = GetParentRect(hwndTab);
  TabCtrl_AdjustRect(hwndTab, false, &rect);
  MoveWindow(hwndEdit, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, TRUE);
  MoveWindow(hwndGraphBox, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, TRUE);
  MoveWindow(hwndAdvancedBox, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, TRUE);

  int parts[3] = {
    (int)(wr.right * 0.2f),
    (int)(wr.right * 0.6f),
    (int)-1,
  };

  SendMessage(hwndStatus, SB_SETPARTS, 3, (LPARAM)parts);
  SendMessage(hwndStatus, WM_SIZE, 0, 0);
  InvalidateRect(hwndStatus, NULL, TRUE);
}

static void HandleClickedItem(HWND hWnd, int wParam) {
  if (wParam >= ID_POPUP_CONFIG_FILE && wParam < ID_POPUP_CONFIG_FILE + MAX_CONFIG_FILES) {
    const char *new_conf = config_filenames[wParam - ID_POPUP_CONFIG_FILE];
    if (!new_conf)
      return;

    if (strcmp(new_conf, g_current_filename) == 0 && g_backend->is_started()) {
      StopTunsafeBackend(UIW_NONE);
    } else {
      LoadConfigFile(new_conf, true, GetAsyncKeyState(VK_SHIFT) >= 0);
    }

    return;
  }
  switch (wParam) {
  case ID_START: StartTunsafeBackend(UIW_START); break;
  case ID_STOP:  StopTunsafeBackend(UIW_NONE); break;
  case ID_EXIT:  PostQuitMessage(0); break;
  case ID_MORE_BUTTON: ShowSettingsMenu(hWnd); break;
  case IDSETT_WEB_PAGE: ShellExecute(g_ui_window, NULL, "https://tunsafe.com/", NULL, NULL, 0); break;
  case IDSETT_OPENSOURCE: ShellExecute(g_ui_window, NULL, "https://tunsafe.com/open-source", NULL, NULL, 0); break;
  case ID_EDITCONF: OpenEditor(); break;
  case IDSETT_BROWSE_FILES:BrowseFiles(); break;
  case IDSETT_OPEN_FILE: BrowseFile(hWnd); break;
  case IDSETT_ABOUT:
    MessageBoxA(g_ui_window, TUNSAFE_VERSION_STRING "\r\n\r\nCopyright © 2018, Ludvig Strigeus\r\n\r\nThanks for choosing TunSafe!\r\n\r\nThis version was built on " __DATE__ " " __TIME__, "About TunSafe", MB_ICONINFORMATION);
    break;
  case IDSETT_KEYPAIR:
    DialogBox(g_hinstance, MAKEINTRESOURCE(IDD_DIALOG2), hWnd, &KeyPairDlgProc);
    break;
  case IDSETT_BLOCKINTERNET_OFF:
  case IDSETT_BLOCKINTERNET_ROUTE:
  case IDSETT_BLOCKINTERNET_FIREWALL:
  case IDSETT_BLOCKINTERNET_BOTH:
  {
    InternetBlockState old_state = g_backend->GetInternetBlockState(NULL);
    InternetBlockState new_state = (InternetBlockState)(wParam - IDSETT_BLOCKINTERNET_OFF);

    if (old_state == kBlockInternet_Off && new_state != kBlockInternet_Off) {
      if (MessageBoxA(g_ui_window, "Warning! All Internet traffic will be blocked until you restart your computer. Only traffic through TunSafe will be allowed.\r\n\r\nThe blocking is activated the next time you connect to a VPN server.\r\n\r\nDo you want to continue?", "TunSafe", MB_ICONWARNING | MB_OKCANCEL) == IDCANCEL)
        return;
    }

    g_backend->SetInternetBlockState(new_state);

    if ((~old_state & new_state) && g_backend->is_started())
      StartTunsafeBackend(UIW_START);
    return;
  }
  case IDSETT_SERVICE_OFF:
  case IDSETT_SERVICE_FOREGROUND:
  case IDSETT_SERVICE_BACKGROUND:
    SetStartupFlags((int)((g_startup_flags & ~3) + wParam - IDSETT_SERVICE_OFF));
    break;
  case IDSETT_SERVICE_CONNECT_AUTO:
    SetStartupFlags(g_startup_flags ^ kStartupFlag_ConnectWhenWindowsStarts);
    break;
  case IDSETT_SERVICE_MINIMIZE_AUTO:
    SetStartupFlags(g_startup_flags ^ kStartupFlag_MinimizeToTrayWhenWindowsStarts);
    break;

  case IDSETT_PREPOST:
  {
    if (!g_hklm_reg_key) {
      if (!RunProcessAsAdminWithArgs(g_allow_pre_post ? "--set-allow-pre-post 0" : "--set-allow-pre-post 1", true))
        MessageBox(g_ui_window, "You need to run TunSafe as an Administrator to be able to change this setting.", "TunSafe", MB_ICONWARNING);
      g_allow_pre_post = RegReadInt(g_hklm_readonly_reg_key, "AllowPrePost", 0) != 0;
      return;
    }
    g_allow_pre_post = !g_allow_pre_post;
    RegWriteInt(g_hklm_reg_key, "AllowPrePost", g_allow_pre_post);
    return;
  }
  }
}

static INT_PTR WINAPI DlgProc(HWND hWnd, UINT message, WPARAM wParam,
                                LPARAM lParam) {

  switch (message) {
  case WM_INITDIALOG:
    SetMenu(hWnd, LoadMenu(g_hinstance, MAKEINTRESOURCE(IDR_MENU1)));
    return TRUE;
  case WM_CLOSE:
    SetUiVisibility(false);
    return TRUE;
  case WM_NOTIFY: {
    UINT idFrom = (UINT)((NMHDR*)lParam)->idFrom;
    switch (((NMHDR*)lParam)->code) {
    case TCN_SELCHANGE:
      switch (idFrom) {
      case IDC_TAB:
        UpdateTabSelection();
        return TRUE;
      }

      break;
    }
    break;
  }
  case WM_COMMAND:
    switch (HIWORD(wParam)) {
    case 0:
      HandleClickedItem(hWnd, (int)wParam);
      break;
    }
    break;
  case WM_DROPFILES:
    if (!wm_dropfiles_recursive) {
      wm_dropfiles_recursive = true;
      HandleDroppedFiles(hWnd, (HDROP)wParam);
      wm_dropfiles_recursive = false;
    }
    break;
  case WM_USER + 1:
    if (lParam == WM_RBUTTONUP) {
      HMENU menu = CreatePopupMenu();
      if (AddToAvailableFilesPopup(menu, 10, false))
        AppendMenu(menu, MF_SEPARATOR, 0, 0);

      bool active = g_backend->is_started();
      AppendMenu(menu, 0, ID_START, active ? "Re&connect" : "&Connect");
      AppendMenu(menu, active ? 0 : MF_GRAYED, ID_STOP, "&Disconnect");
      AppendMenu(menu, MF_SEPARATOR, 0, NULL);
      AppendMenu(menu, 0, ID_EXIT, "&Exit");
      POINT pt;
      GetCursorPos(&pt);

      SetForegroundWindow(hWnd);

      int rv = TrackPopupMenu(menu, 0, pt.x, pt.y, 0, hWnd, NULL);
      DestroyMenu(menu);
    } else if (lParam == WM_LBUTTONDBLCLK) {
      if (IsWindowVisible(hWnd)) {
        SetUiVisibility(false);
      } else {
        ShowUI(hWnd);
      }
    }
    return TRUE;
  case WM_USER + 2:
    g_backend_delegate->DoWork();
    return true;

  case WM_INITMENU: {
    HMENU menu = GetMenu(g_ui_window);

    CheckMenuItem(menu, IDSETT_SERVICE_CONNECT_AUTO, MF_CHECKED * !!(g_startup_flags & kStartupFlag_ConnectWhenWindowsStarts));
    CheckMenuItem(menu, IDSETT_SERVICE_MINIMIZE_AUTO, MF_CHECKED * !!(g_startup_flags & kStartupFlag_MinimizeToTrayWhenWindowsStarts));
    CheckMenuItem(menu, IDSETT_PREPOST, g_allow_pre_post ? MF_CHECKED : 0);

    bool is_activated = false;
    int value = g_backend->GetInternetBlockState(&is_activated);
    CheckMenuRadioItem(menu, IDSETT_BLOCKINTERNET_OFF, IDSETT_BLOCKINTERNET_BOTH, IDSETT_BLOCKINTERNET_OFF + value, MF_BYCOMMAND);
    CheckMenuRadioItem(menu, IDSETT_SERVICE_OFF, IDSETT_SERVICE_BACKGROUND, IDSETT_SERVICE_OFF + (g_startup_flags & 3), MF_BYCOMMAND);

    break;
  }

  case WM_SIZE:
    if (wParam == SIZE_MAXIMIZED || wParam == SIZE_RESTORED) {
      if (g_ui_window)
        HandleWindowSizing();
    }
    break;

  case WM_EXITMENULOOP:
    g_timestamp_of_exit_menuloop = GetTickCount();
    break;

  default:
    if (message == g_message_taskbar_created) {
      g_has_icon = false;
      UpdateIcon(UIW_NONE);
    }
    break;
  }
  return FALSE;
}

void PushLine(const char *s) {
  size_t l = strlen(s);
  char buf[64];
  SYSTEMTIME t;

  GetLocalTime(&t);

  snprintf(buf, sizeof(buf), "[%.2d:%.2d:%.2d] ", t.wHour, t.wMinute, t.wSecond);
  size_t tl = strlen(buf);

  char *x = (char*)malloc(tl + l + 3);
  if (!x) return;
  memcpy(x, buf, tl);
  memcpy(x + tl, s, l);
  x[l + tl] = '\r';
  x[l + tl + 1] = '\n';
  x[l + tl + 2] = '\0';
  g_backend_delegate->OnLogLine((const char**)&x);
  free(x);
}

void EnsureConfigDirCreated() {
  char fullname[1024];
  if (GetConfigFullName("", fullname, sizeof(fullname)))
    CreateDirectory(fullname, NULL);
}

void EnableControl(int wnd, bool b) {
  EnableWindow(GetDlgItem(g_ui_window, wnd), b);
}

LRESULT CALLBACK NotifyWndProc(HWND  hwnd, UINT  uMsg, WPARAM wParam, LPARAM lParam) {
  switch (uMsg) {
  case WM_USER + 10:
    if (wParam == 1) {
      PostQuitMessage(0);
      return 31337;
    } else if (wParam == 0) {
      ShowUI(g_ui_window);
      return 31337;
    }
    break;
  }
  return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

void CreateNotificationWindow() {
  WNDCLASSEX wce = {0};
  wce.cbSize = sizeof(wce);
  wce.lpfnWndProc = &NotifyWndProc;
  wce.hInstance = g_hinstance;
  wce.lpszClassName = "TunSafe-f19e092db01cbe0fb6aee132f8231e5b71c98f90";
  RegisterClassEx(&wce);
  CreateWindow("TunSafe-f19e092db01cbe0fb6aee132f8231e5b71c98f90", "TunSafe-f19e092db01cbe0fb6aee132f8231e5b71c98f90", 0, 0, 0, 0, 0, 0, 0, g_hinstance, NULL);
}

HFONT CreateBoldUiFont() {
  LOGFONT lf;
  HFONT ffont = (HFONT)SendMessage(g_ui_window, WM_GETFONT, 0, 0);
  GetObject(ffont, sizeof(lf), &lf);
  lf.lfWeight = FW_BOLD;
  HFONT font = CreateFontIndirect(&lf);
  return font;
}

void FillRectColor(HDC dc, const RECT &r, COLORREF color) {
  COLORREF old = ::SetBkColor(dc, color);
  ExtTextOut(dc, 0, 0, ETO_OPAQUE, &r, NULL, 0, NULL);
  ::SetBkColor(dc, old);
}

void DrawRectOutline(HDC dc, const RECT &r) {
  POINT points[5] = {
    {r.left, r.top},
    {r.right, r.top},
    {r.right, r.bottom},
    {r.left, r.bottom},
    {r.left, r.top}
  };
  Polyline(dc, points, 5);
}

static HFONT CreateFontHelper(int size, byte flags, const char *face, int angle = 0) {
  return CreateFontA(-RescaleDpi(size), 0, angle, angle, flags & 1 ? FW_BOLD : 0, FALSE, flags & 2 ? 1 : 0, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
                     CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, face);
}

static const char *StatusCodeToString(TunsafeBackend::StatusCode code) {
  switch (code) {
  case TunsafeBackend::kErrorInitialize:    return "Configuration Error";
  case TunsafeBackend::kErrorTunPermanent:  return "TUN Adapter Error";
  case TunsafeBackend::kErrorServiceLost:   return "Service Lost";
  case TunsafeBackend::kStatusStopped:      return "Disconnected";
  case TunsafeBackend::kStatusInitializing: return "Initializing";
  case TunsafeBackend::kStatusConnecting:   return "Connecting...";
  case TunsafeBackend::kStatusReconnecting: return "Reconnecting...";
  case TunsafeBackend::kStatusConnected:    return "Connected";
  case TunsafeBackend::kStatusTunRetrying:  return "TUN Adapter Error, retrying...";
  default:
    return "Unknown";
  }
}

static void DrawInPaintBox(HDC hdc, int w, int h) {
  RECT rect = {0, 0, w, h};
  FillRect(hdc, &rect, (HBRUSH)(COLOR_3DFACE + 1));
  
  HFONT font = CreateBoldUiFont();

  char namebuf[128];
  GetCurrentConfigTitle(namebuf, sizeof(namebuf));

  RECT btrect = GetParentRect(GetDlgItem(g_ui_window, ID_START));

  HPEN pen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_3DSHADOW));
  HBRUSH brush = GetSysColorBrush(COLOR_WINDOW);

  SelectObject(hdc, pen);
  SelectObject(hdc, brush);

  comborect = MakeRect(0, btrect.top + 1, w, btrect.bottom - 1);
  Rectangle(hdc, 0, btrect.top + 1, w, btrect.bottom - 1);

  if (arrowbitmap == NULL)
    arrowbitmap = LoadBitmap(g_hinstance, MAKEINTRESOURCE(IDB_DOWNARROW));

  int bw = RescaleDpi(6);

  HDC memdc = CreateCompatibleDC(hdc);
  SelectObject(memdc, arrowbitmap);
  StretchBlt(hdc, w - 1 - bw - 5, btrect.top + 1 + ((btrect.bottom - btrect.top - bw) >> 1), 
    bw, bw, memdc, 0, 0, 6, 6, SRCCOPY);

  int th = RescaleDpi(20);

  SelectObject(hdc, font);
  SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
  TextOut(hdc, RescaleDpi(4), btrect.top + RescaleDpi(4), namebuf, (int)strlen(namebuf));

  int y = btrect.bottom + RescaleDpi(4);

  DeleteObject(pen);

  SelectObject(hdc, (HFONT)SendMessage(g_ui_window, WM_GETFONT, 0, 0));
  SetBkColor(hdc, GetSysColor(COLOR_3DFACE));

  TunsafeBackend::StatusCode status = g_backend->status();
  my_strlcpy(namebuf, sizeof(namebuf) - 32, StatusCodeToString(status));
  if (status == TunsafeBackend::kStatusConnected || status == TunsafeBackend::kStatusReconnecting) {
    uint64 when = g_processor_stats.first_complete_handshake_timestamp;
    uint32 seconds = (when != 0) ? (uint32)((OsGetMilliseconds() - when + 500) / 1000) : 0;
    snprintf(strchr(namebuf, 0), 32, ", %.2d:%.2d:%.2d", seconds / 3600, (seconds / 60) % 60, seconds % 60);
  }
 
  int img = (status == TunsafeBackend::kStatusConnected) ? 0 :
            g_backend->is_started() && !TunsafeBackend::IsPermanentError(status) ? 1 : 2;

  static const COLORREF kDotColors[3] = {
    0x51a600,
    0x00c0c0,
    0x0000c0,
  };
  SetBkMode(hdc, TRANSPARENT);
  COLORREF oldcolor = SetTextColor(hdc, kDotColors[img]);
  HFONT oldfont = (HFONT)SelectObject(hdc, CreateFontHelper(18, 0, "Tahoma"));
  wchar_t bullet = 0x25CF;
  TextOutW(hdc, RescaleDpi(2), y - RescaleDpi(7), &bullet, 1);
  DeleteObject(SelectObject(hdc, oldfont));
  SetTextColor(hdc, oldcolor);

  TextOut(hdc, RescaleDpi(2 + 14), y, namebuf, (int)strlen(namebuf));

  y += RescaleDpi(18);

  uint32 ip = g_backend->GetIP();
  if (ip) {
    print_ip(namebuf, ip);
    TextOut(hdc, 2, y, namebuf, (int)strlen(namebuf));
  } 
  DeleteObject(font);
  DeleteDC(memdc);
}

typedef void DrawInPaintBoxFunc(HDC dc, int w, int h);
static void HandleWmPaintPaintbox(HWND hwnd, DrawInPaintBoxFunc *func) {
  PAINTSTRUCT ps;
  BeginPaint(hwnd, &ps);

  RECT r;
  GetClientRect(hwnd, &r);

  HBITMAP bmp = CreateCompatibleBitmap(ps.hdc, r.right, r.bottom);
  HDC dc = CreateCompatibleDC(ps.hdc);
  SelectObject(dc, bmp);

  func(dc, r.right, r.bottom);

  BitBlt(ps.hdc, 0, 0, r.right, r.bottom, dc, 0, 0, SRCCOPY);
  DeleteDC(dc);
  DeleteObject(bmp);
  EndPaint(hwnd, &ps);
}

static LRESULT CALLBACK PaintBoxWndProc(HWND  hwnd, UINT  uMsg, WPARAM wParam, LPARAM lParam) {
  switch (uMsg) {
  case WM_PAINT: {
    HandleWmPaintPaintbox(hwnd, &DrawInPaintBox);
    return TRUE;
  }
  case WM_LBUTTONDOWN: {
    POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
    if (PtInRect(&comborect, pt)) {
      // Avoid showing the menu again if clicking to close.
      if (GetTickCount() - g_timestamp_of_exit_menuloop >= 50u)
        ShowSettingsMenu(g_ui_window);
    }
    return TRUE;
  }
  }
  return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

static void DrawGraph(HDC dc, const RECT *rr, StatsCollector::TimeSeries **sources, const COLORREF *colors, int num_source, const char *xcaption, const char *ycaption) {
  RECT r = *rr;
  FillRectColor(dc, r, 0xffffff);

  RECT margins = { 30, 10, -10, -15 };
  margins = RescaleDpiRect(margins);

  r.left += margins.left;
  r.top += margins.top;
  r.right += margins.right;
  r.bottom += margins.bottom;

  HPEN borderpen = CreatePen(PS_SOLID, 1, 0x808080);
  SelectObject(dc, borderpen);
  DrawRectOutline(dc, r);

  static const uint8 bits[4] = {0x70, 0, 0, 0};
  HBITMAP bmp = CreateBitmap(4, 1, 1, 1, &bits);
  HBRUSH brush = CreatePatternBrush(bmp);
  DeleteObject(bmp);

  // Draw horizontal dotted lines
  {
    SetTextColor(dc, 0x808080);
    SetBkColor(dc, 0xffffff);
    int inc = (r.bottom - r.top) >> 2;
    RECT r2 = {r.left + 1, r.top + inc * 1, r.right - 1, r.top + inc * 1 + 1};
    FillRect(dc, &r2, brush);
    r2.top += inc; r2.bottom += inc;
    FillRect(dc, &r2, brush);
    r2.top += inc; r2.bottom += inc;
    FillRect(dc, &r2, brush);
  }
  DeleteObject(brush);

  static const uint8 bits_vertical[16] = {
    0xff, 0x0, 0xff, 0,
    0xff, 0x0, 0x0, 0,
    0xff, 0x0, 0x0, 0,
    0x0, 0x0, 0x0, 0};
  bmp = CreateBitmap(1, 4, 1, 1, &bits_vertical);
  brush = CreatePatternBrush(bmp);
  DeleteObject(bmp);

  {
    // Draw vertical dotted lines 
    for (int i = 1; i < 12; i++) {
      int x = (r.right - r.left) * i / 12;
      RECT r2 = {r.left + x, r.top + 1, r.left + x + 1, r.bottom - 1};
      FillRect(dc, &r2, brush);
    }
  }

  {
    // Draw legend text
    HFONT font = CreateFontHelper(10, 0, "Tahoma");
    SelectObject(dc, font);
    SetTextColor(dc, 0x202020);
    SetBkMode(dc, TRANSPARENT);
    RECT r2 = {r.left + 1, r.bottom, r.right - 1, r.bottom + RescaleDpi(15)};
    DrawText(dc, xcaption, (int)strlen(xcaption), &r2, DT_CENTER | DT_SINGLELINE | DT_VCENTER);
    DeleteObject(font);
  }
  DeleteObject(brush);
  DeleteObject(borderpen);

  // Determine the scaling factor
  float mx = 1;
  for (size_t j = 0; j != num_source; j++) {
    const StatsCollector::TimeSeries *src = sources[j];
    for (size_t i = 0; i != src->size; i++)
      mx = max(mx, src->data[i]);
  }
  int topval = (int)(mx + 0.5f);
  // round it appropriately
  if (topval >= 500)
    topval = (topval + 99) / 100 * 100;
  else if (topval >= 200)
    topval = (topval + 49) / 50 * 50;
  else if (topval >= 50)
    topval = (topval + 9) / 10 * 10;
  else if (topval >= 20)
    topval = (topval + 4) / 5 * 5;
  if (topval > mx)
    mx = (float)topval;

  {
    RECT r2 = {r.left - RescaleDpi(30), r.top - RescaleDpi(2), r.left - RescaleDpi(2), r.bottom};
    char buf[30];
    sprintf(buf, "%d", topval);
    DrawText(dc, buf, (int)strlen(buf), &r2, DT_RIGHT | DT_SINGLELINE);
    r2.top = r.bottom - RescaleDpi(12);
    DrawText(dc, "0", 1, &r2, DT_RIGHT | DT_SINGLELINE);
  }

  float mx_f = (1.0f / mx) * (r.bottom - r.top);

  for (size_t k = 0; k != num_source; k++) {
    HPEN borderpen = CreatePen(PS_SOLID, 2, colors[k]);
    SelectObject(dc, borderpen);
    const StatsCollector::TimeSeries *src = sources[k];
    POINT *points = new POINT[src->size];
    for (size_t i = 0, j = src->shift; i != src->size; i++) {
      points[i].x = (int)(r.left + (r.right - r.left) * i / (src->size - 1));
      points[i].y = r.bottom - (int)((float)src->data[j] * mx_f);
      if (++j == src->size) j = 0;
    }
    Polyline(dc, points, src->size);
    delete points;
    DeleteObject(borderpen);
  }

  if (ycaption != NULL) {
    HFONT font = CreateFontHelper(10, 0, "Tahoma", 900);
    SelectObject(dc, font);
    TextOut(dc, r.left - RescaleDpi(18), ((r.top + r.bottom) >> 1) + RescaleDpi(12), ycaption, (int)strlen(ycaption));
    DeleteObject(font);
  }
}

static const char * const kGraphStepNames[] = {
  "1 second step",
  "5 second step",
  "30 second step",
  "5 minute step",
};

static void DrawInGraphBox(HDC hdc, int w, int h) {
  RECT r = {0, 0, w, h};
  
  static const COLORREF color[4] = {
    0x00c000,
    0xc00000,
  };
  
  LinearizedGraph *graph = g_backend->GetGraph(g_selected_graph_type);
  StatsCollector::TimeSeries *time_series_ptr[4];
  StatsCollector::TimeSeries time_series[4];

  int num_charts = 0;
  if (graph && graph->num_charts <= 4) {
    uint8 *ptr = (uint8*)(graph + 1);
    for (int i = 0; i < graph->num_charts; i++) {
      time_series_ptr[i] = &time_series[i];
      time_series[i].shift = 0;
      time_series[i].size = *(uint32*)ptr;
      time_series[i].data = (float*)(ptr + 4);
      ptr += 4 + *(uint32*)ptr * 4;
      if (ptr - (uint8*)graph > graph->total_size)
        break;
    }
    num_charts = graph->num_charts;
  }

  char buf[256];
  snprintf(buf, sizeof(buf), "Time (%s)", kGraphStepNames[g_selected_graph_type]);

  DrawGraph(hdc, &r, time_series_ptr, color, num_charts, buf, "Mbps");

  free(graph);
}

static LRESULT CALLBACK GraphBoxWndProc(HWND  hwnd, UINT  uMsg, WPARAM wParam, LPARAM lParam) {
  switch (uMsg) {
  case WM_PAINT: {
    HandleWmPaintPaintbox(hwnd, &DrawInGraphBox);
    return TRUE;
  }
  case WM_RBUTTONDOWN: {
    HMENU menu = CreatePopupMenu();
    for(int i = 0; i < ARRAYSIZE(kGraphStepNames); i++)
      AppendMenu(menu, (i == g_selected_graph_type) * MF_CHECKED, i + 1, kGraphStepNames[i]);
    POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
    ClientToScreen(hwnd, &pt);
    int rv = TrackPopupMenu(menu, TPM_NONOTIFY | TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);
    DestroyMenu(menu);
    if (rv != 0) {
      g_selected_graph_type = rv - 1;
      InvalidateRect(hwnd, NULL, FALSE);
    }
    return TRUE;
  }
  }
  return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

struct AdvancedTextInfo {
  uint16 y;
  uint8 indent;
  const char *title;
};

static const AdvancedTextInfo ADVANCED_TEXT_INFOS[] = {
#define Y 26
  {Y + 19 * 0, 66, "Public Key:"},
  {Y + 19 * 1, 66, "Endpoint:"},
  {Y + 19 * 2, 66, "Transfer:"},
  {Y + 19 * 3, 66, "Handshake:"},
  {Y + 19 * 4, 66, ""},
  {Y + 19 * 5, 66, "Overhead:"},
#undef Y
};

static char *PrintLastHandshakeAt(char buf[256], WgProcessorStats *ps) {
  char *d = buf;
  if (ps->last_complete_handshake_timestamp) {
    uint32 ago = (uint32)((OsGetMilliseconds() - ps->last_complete_handshake_timestamp + 500) / 1000);
    uint32 hours = ago / 3600;
    uint32 minutes = (ago - hours * 3600) / 60;
    uint32 seconds = (ago - hours * 3600 - minutes * 60);
    if (hours)
      d += snprintf(d, 32, hours == 1 ? "%d hour, " : "%d hours, ", hours);
    if (minutes)
      d += snprintf(d, 32, minutes == 1 ? "%d minute, " : "%d minutes, ", minutes);
    if (d == buf || seconds)
      d += snprintf(d, 32, seconds == 1 ? "%d second, " : "%d seconds, ", seconds);
    memcpy(d - 2, " ago", 5);
  } else {
    memcpy(buf, "(never)", 8);
  }
  return buf;
}

static const char *GetAdvancedInfoValue(char buffer[256], int i) {
  char tmp[64], tmp2[64];
  WgProcessorStats *ps = &g_processor_stats;
  switch (i) {
  case 0: {
    if (IsOnlyZeros(g_backend->public_key(), 32))
      return "";
    char *str = (char*)base64_encode(g_backend->public_key(), 32, NULL);
    snprintf(buffer, 256, "%s", str);
    free(str);
    return buffer;
  }
  case 1: {
    char ip[kSizeOfAddress];
    if (ps->endpoint.sin.sin_family == 0)
      return "";
    PrintIpAddr(ps->endpoint, ip);
    snprintf(buffer, 256, "%s:%d", ip, htons(ps->endpoint.sin.sin_port));
    return buffer;
  }
    
  case 2: 
    snprintf(buffer, 256, "%s in (%lld packets), %s out (%lld packets)",
             PrintMB(tmp, ps->udp_bytes_in), ps->udp_packets_in,
             PrintMB(tmp2, ps->udp_bytes_out), ps->udp_packets_out/*, udp_qsize2 - udp_qsize1, g_tun_reads*/);
    return buffer;
  case 3: return PrintLastHandshakeAt(buffer, ps);
  case 4: {
    snprintf(buffer, 256, "%d handshakes in (%d failed), %d handshakes out (%d failed)",
             ps->handshakes_in, ps->handshakes_in - ps->handshakes_in_success,
             ps->handshakes_out, ps->handshakes_out - ps->handshakes_out_success);
    return buffer;
  }
  case 5: {
    uint64 overhead_in = ps->udp_bytes_in + ps->udp_packets_in * 40 - ps->tun_bytes_out;
    uint32 overhead_in_pct = ps->tun_bytes_out ? (uint32)(overhead_in * 100000 / ps->tun_bytes_out) : 0;

    uint64 overhead_out = ps->udp_bytes_out + ps->udp_packets_out * 40 - ps->tun_bytes_in;
    uint32 overhead_out_pct = ps->tun_bytes_in ? (uint32)(overhead_out * 100000 / ps->tun_bytes_in) : 0;

    snprintf(buffer, 256, "%d.%.3d%% in, %d.%.3d%% out", overhead_in_pct / 1000, overhead_in_pct % 1000,
             overhead_out_pct / 1000, overhead_out_pct % 1000);
    return buffer;
  }
  default: return "";
  }  
}

static void DrawInAdvancedBox(HDC dc, int w, int h) {
  RECT r = {0, 0, w, h};

  FillRectColor(dc, r, 0xffffff);

  SelectObject(dc, (HFONT)SendMessage(g_ui_window, WM_GETFONT, 0, 0));
  SetTextColor(dc, GetSysColor(COLOR_WINDOWTEXT));
  SetBkColor(dc, GetSysColor(COLOR_WINDOW));

  const AdvancedTextInfo *tp = ADVANCED_TEXT_INFOS;
  char buffer[256];

  for (size_t i = 0; i != ARRAYSIZE(ADVANCED_TEXT_INFOS); i++, tp++) {
    int x = 8;

    RECT r = {x, tp->y, x + tp->indent, tp->y + 19};
    r = RescaleDpiRect(r);
    ::ExtTextOut(dc, r.left, r.top, ETO_CLIPPED | ETO_OPAQUE, &r, tp->title, (UINT)strlen(tp->title), NULL);

    const char *s = GetAdvancedInfoValue(buffer, (int)i);
    r.left = r.right;
    r.right = w;
    ::ExtTextOut(dc, r.left, r.top, ETO_CLIPPED | ETO_OPAQUE, &r, s, (UINT)strlen(s), NULL);
  }

  SetBkColor(dc, GetSysColor(COLOR_3DFACE));

  static const int grouptop[1] = { 
    2
  };
  static const char *grouptext[1] = {
    "General",
  };

  HFONT font = CreateFontHelper(12, 1, "Tahoma");
  SelectObject(dc, font);
  for (size_t i = 0; i != ARRAYSIZE(grouptext); i++) {
    RECT r = {RescaleDpi(4), RescaleDpi(grouptop[i]), w - RescaleDpi(4), RescaleDpi(grouptop[i] + 18)};
    ::ExtTextOut(dc, RescaleDpi(8), r.top + 1, ETO_CLIPPED | ETO_OPAQUE, &r, grouptext[i], (UINT)strlen(grouptext[i]), NULL);
  }
  DeleteFont(font);
}

static LRESULT CALLBACK AdvancedBoxWndProc(HWND  hwnd, UINT  uMsg, WPARAM wParam, LPARAM lParam) {
  switch (uMsg) {
  case WM_PAINT: {
    HandleWmPaintPaintbox(hwnd, &DrawInAdvancedBox);
    return TRUE;
  }
  case WM_ERASEBKGND:
    return TRUE;

  case WM_RBUTTONDOWN: {
    int x = GET_X_LPARAM(lParam), y = GET_Y_LPARAM(lParam);
    char buffer[256];

    const AdvancedTextInfo *tp = ADVANCED_TEXT_INFOS;
    for (size_t i = 0; i != ARRAYSIZE(ADVANCED_TEXT_INFOS); i++, tp++) {
      if (x >= RescaleDpi(tp->indent) && y >= RescaleDpi(tp->y) && y < RescaleDpi(tp->y + 19)) {
        HMENU menu = CreatePopupMenu();
        AppendMenu(menu, 0, 1, "Copy");
        POINT pt = {x, y};
        ClientToScreen(hwnd, &pt);
        int rv = TrackPopupMenu(menu, TPM_NONOTIFY | TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);
        DestroyMenu(menu);
        if (rv == 1)
          SetClipboardString(GetAdvancedInfoValue(buffer, (int)i));
        return TRUE;
      }
    }
    return TRUE;
  }
  }
  return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

void InitializeClass(WNDPROC wndproc, const char *name) {
  WNDCLASSEX wce = {0};
  wce.cbSize = sizeof(wce);
  wce.lpfnWndProc = wndproc;
  wce.hInstance = g_hinstance;
  wce.lpszClassName = name;
  wce.style = CS_HREDRAW | CS_VREDRAW;
  wce.hCursor = LoadCursor(NULL, IDC_ARROW);
  RegisterClassEx(&wce);
}

static bool CreateMainWindow() {
  LoadLibrary(TEXT("Riched20.dll"));
  INITCOMMONCONTROLSEX ccx;
  ccx.dwSize = sizeof(INITCOMMONCONTROLSEX);
  ccx.dwICC = ICC_TAB_CLASSES;
  InitCommonControlsEx(&ccx);

  InitializeClass(&PaintBoxWndProc, "PaintBox");
  InitializeClass(&GraphBoxWndProc, "GraphBox");
  InitializeClass(&AdvancedBoxWndProc, "AdvancedBox");

  HDC dc = GetDC(0);
  g_large_fonts = GetDeviceCaps(dc, LOGPIXELSX);
  ReleaseDC(0, dc);

  g_message_taskbar_created = RegisterWindowMessage(TEXT("TaskbarCreated"));

  g_icons[0] = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1));
  g_icons[1] = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON0));
  g_ui_window = CreateDialog(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DIALOG1), NULL, &DlgProc);

  if (!g_ui_window)
    return false;
  
  DragAcceptFiles(g_ui_window, TRUE);

  ChangeWindowMessageFilter(WM_DROPFILES, MSGFLT_ADD);
  ChangeWindowMessageFilter(WM_COPYDATA, MSGFLT_ADD);
  ChangeWindowMessageFilter(0x0049, MSGFLT_ADD);
  ChangeWindowMessageFilter(WM_USER + 10, MSGFLT_ADD);

  TCITEM tabitem;
  HWND hwnd_tab = GetDlgItem(g_ui_window, IDC_TAB);
  hwndTab = hwnd_tab;
  tabitem.mask = TCIF_TEXT;
  tabitem.pszText = "Logs";
  TabCtrl_InsertItem(hwnd_tab, 0, &tabitem);
  tabitem.pszText = "Charts";
  TabCtrl_InsertItem(hwnd_tab, 1, &tabitem);
  tabitem.pszText = "Advanced";
  TabCtrl_InsertItem(hwnd_tab, 2, &tabitem);
  SetWindowLong(hwnd_tab, GWL_EXSTYLE, GetWindowLong(hwnd_tab, GWL_EXSTYLE) | WS_EX_COMPOSITED);



  hwndEdit = GetDlgItem(g_ui_window, IDC_RICHEDIT21);
  hwndPaintBox = GetDlgItem(g_ui_window, IDC_PAINTBOX);
  hwndGraphBox = GetDlgItem(g_ui_window, IDC_GRAPHBOX);
  hwndAdvancedBox = GetDlgItem(g_ui_window, IDC_ADVANCEDBOX);

  SetWindowLong(hwndEdit, GWL_EXSTYLE, GetWindowLong(hwndEdit, GWL_EXSTYLE) &~ WS_EX_CLIENTEDGE);

  // Create the status bar.
  hwndStatus = CreateWindowEx(
      WS_EX_COMPOSITED, STATUSCLASSNAME, NULL,
      WS_CHILD | WS_VISIBLE, 0, 0, 0, 0, g_ui_window,
      (HMENU)IDC_STATUSBAR, g_hinstance, NULL);

  HandleWindowSizing();
  UpdateTabSelection();
  return true;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) {
  g_hinstance = hInstance;
  InitCpuFeatures();

  WSADATA wsaData = {0};
  WSAStartup(MAKEWORD(2, 2), &wsaData);

  bool minimize = false;
  bool is_autostart = false;
  const char *filename = NULL;

  for (int i = 1; i < __argc; i++) {
    const char *arg = __argv[i];
    if (strcmp(arg, "/minimize") == 0) {
      minimize = true;
    } else if (strcmp(arg, "/minimize_on_connect") == 0) {
      g_minimize_on_connect = true;
    } else if (strcmp(arg, "/allow_pre_post") == 0) {
      g_allow_pre_post = true;
    } else if (strcmp(arg, "--service") == 0) {
      RunProcessAsTunsafeServiceProcess();
      return 0;
    } else if (strcmp(arg, "--delete-service-and-start") == 0) {
      UninstallTunSafeWindowsService();
    } else if (strcmp(arg, "--autostart") == 0) {
      is_autostart = true;
    } else if (strcmp(arg, "--set-allow-pre-post") == 0) {
      bool want = i + 1 < __argc && atoi(__argv[i + 1]) != 0;
      RegCreateKeyEx(HKEY_LOCAL_MACHINE, "Software\\TunSafe", NULL, NULL, 0, KEY_ALL_ACCESS, NULL, &g_hklm_reg_key, NULL);
      RegWriteInt(g_hklm_reg_key, "AllowPrePost", want);
      return 0;
    } else if (strcmp(arg, "--import") == 0) {
      if (i + 1 >= __argc) return 1;
      const char *filename = __argv[i + 1];
      return ImportFile(filename, true);
    } else {
      filename = arg;
      break;
    }
  }

  SetProcessDPIAware();

  RegCreateKeyEx(HKEY_CURRENT_USER, "Software\\TunSafe", NULL, NULL, 0, KEY_ALL_ACCESS, NULL, &g_reg_key, NULL);
  RegCreateKeyEx(HKEY_LOCAL_MACHINE, "Software\\TunSafe", NULL, NULL, 0, KEY_ALL_ACCESS, NULL, &g_hklm_reg_key, NULL);
  RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\TunSafe", 0, KEY_READ, &g_hklm_readonly_reg_key);
   
  g_startup_flags = RegReadInt(g_reg_key, "StartupFlags", 0);

  if (is_autostart) {
    g_disable_connect_on_start = !(g_startup_flags & kStartupFlag_ConnectWhenWindowsStarts);
    minimize = !!(g_startup_flags & kStartupFlag_MinimizeToTrayWhenWindowsStarts);
  }

  // Check if the app is already running.
  g_runonce_mutex = CreateMutexA(0, FALSE, "TunSafe-f19e092db01cbe0fb6aee132f8231e5b71c98f90");
  if (GetLastError() == ERROR_ALREADY_EXISTS) {
    HWND window = FindWindow("TunSafe-f19e092db01cbe0fb6aee132f8231e5b71c98f90", NULL);
    DWORD_PTR result;
    if (!window || !SendMessageTimeout(window, WM_USER + 10, 0, 0, SMTO_BLOCK, 3000, &result) || result != 31337) {
      MessageBoxA(NULL, "It looks like TunSafe is already running, but not responding. Please kill the old process first.", "TunSafe", MB_ICONWARNING);
    }
    return 1;
  }

  TOKEN_ELEVATION_TYPE toktype;
  g_is_limited_uac_account = (GetProcessElevationType(&toktype) && toktype == TokenElevationTypeLimited);
  g_is_tunsafe_service_running = IsTunsafeServiceRunning();
  bool want_use_service = !!(g_startup_flags & (kStartupFlag_BackgroundService | kStartupFlag_ForegroundService));
  
  // Re-launch the process as administrator if the TunSafe service isn't running.
  if ((!g_is_tunsafe_service_running || !want_use_service) && g_is_limited_uac_account) {
    CloseHandle(g_runonce_mutex);
    if (!RestartProcessAsAdministrator())
      MessageBoxA(0, "TunSafe needs to run as Administrator unless the TunSafe Service is started.", "TunSafe", MB_ICONWARNING);
    return 0;
  }

  CreateNotificationWindow();

  g_backend_delegate = CreateTunsafeBackendDelegateThreaded(&my_procdel, []() {
    if (g_ui_window)
      PostMessage(g_ui_window, WM_USER + 2, 0, 0);
  });
  g_logger = &PushLine;

  if (!CreateMainWindow())
    return 1;

  g_current_filename = _strdup("");
  g_cmdline_filename = filename;

  if (!g_allow_pre_post && g_hklm_readonly_reg_key)
    g_allow_pre_post = RegReadInt(g_hklm_readonly_reg_key, "AllowPrePost", 0) != 0;

  // Attempt to start service...
  if (want_use_service && !g_is_tunsafe_service_running) {
    RINFO("Starting TunSafe service...");
    InstallTunSafeWindowsService();
  }

  CreateLocalOrRemoteBackend(want_use_service);

  if (!minimize) {
    SetUiVisibility(true);
  }
  UpdateIcon(UIW_NONE);
  EnsureConfigDirCreated();

  MSG msg;
  while (GetMessage(&msg, NULL, 0, 0)) {
    if (!IsDialogMessage(g_ui_window, &msg)) {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
  }

  if (!g_backend->is_remote())
    g_backend->Stop();

  delete g_backend;
  RemoveIcon();

  return 0;
}