Merge tag 'upstream/2.4.0'

Upstream version 2.4.0

1 files changed, 891 insertions, 731 deletions

diff --git a/src/openvpn/win32.c b/src/openvpn/win32.c
index 00bc7ac..e26f54d 100644
--- a/src/openvpn/win32.c
+++ b/src/openvpn/win32.c
@@ -5,7 +5,7 @@
  *             packet encryption, packet authentication, and
  *             packet compression.
  *
- *  Copyright (C) 2002-2010 OpenVPN Technologies, Inc. <sales@openvpn.net>
+ *  Copyright (C) 2002-2017 OpenVPN Technologies, Inc. <sales@openvpn.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2
@@ -97,100 +97,112 @@ struct semaphore netcmd_semaphore; /* GLOBAL */
 static char *win_sys_path = NULL; /* GLOBAL */
 
 void
-init_win32 (void)
+init_win32(void)
 {
-  if (WSAStartup(0x0101, &wsa_state))
+    if (WSAStartup(0x0101, &wsa_state))
     {
-      msg (M_ERR, "WSAStartup failed");
+        msg(M_ERR, "WSAStartup failed");
     }
-  window_title_clear (&window_title);
-  win32_signal_clear (&win32_signal);
+    window_title_clear(&window_title);
+    win32_signal_clear(&win32_signal);
 }
 
 void
-uninit_win32 (void)
+uninit_win32(void)
 {
-  netcmd_semaphore_close ();
-  if (pause_exit_enabled)
-    {
-      if (win32_signal.mode == WSO_MODE_UNDEF)
-	{
-	  struct win32_signal w;
-	  win32_signal_open (&w, WSO_FORCE_CONSOLE, NULL, false);
-	  win32_pause (&w);
-	  win32_signal_close (&w);
-	}
-      else
-	win32_pause (&win32_signal);
-    }
-  window_title_restore (&window_title);
-  win32_signal_close (&win32_signal);
-  WSACleanup ();
-  free (win_sys_path);
+    netcmd_semaphore_close();
+    if (pause_exit_enabled)
+    {
+        if (win32_signal.mode == WSO_MODE_UNDEF)
+        {
+            struct win32_signal w;
+            win32_signal_open(&w, WSO_FORCE_CONSOLE, NULL, false);
+            win32_pause(&w);
+            win32_signal_close(&w);
+        }
+        else
+        {
+            win32_pause(&win32_signal);
+        }
+    }
+    window_title_restore(&window_title);
+    win32_signal_close(&win32_signal);
+    WSACleanup();
+    free(win_sys_path);
 }
 
 void
-set_pause_exit_win32 (void)
+set_pause_exit_win32(void)
 {
-  pause_exit_enabled = true;
+    pause_exit_enabled = true;
 }
 
 bool
-init_security_attributes_allow_all (struct security_attributes *obj)
+init_security_attributes_allow_all(struct security_attributes *obj)
 {
-  CLEAR (*obj);
+    CLEAR(*obj);
 
-  obj->sa.nLength = sizeof (SECURITY_ATTRIBUTES);
-  obj->sa.lpSecurityDescriptor = &obj->sd;
-  obj->sa.bInheritHandle = FALSE;
-  if (!InitializeSecurityDescriptor (&obj->sd, SECURITY_DESCRIPTOR_REVISION))
-    return false;
-  if (!SetSecurityDescriptorDacl (&obj->sd, TRUE, NULL, FALSE))
-    return false;
-  return true;
+    obj->sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+    obj->sa.lpSecurityDescriptor = &obj->sd;
+    obj->sa.bInheritHandle = FALSE;
+    if (!InitializeSecurityDescriptor(&obj->sd, SECURITY_DESCRIPTOR_REVISION))
+    {
+        return false;
+    }
+    if (!SetSecurityDescriptorDacl(&obj->sd, TRUE, NULL, FALSE))
+    {
+        return false;
+    }
+    return true;
 }
 
 void
-overlapped_io_init (struct overlapped_io *o,
-		    const struct frame *frame,
-		    BOOL event_state,
-		    bool tuntap_buffer) /* if true: tuntap buffer, if false: socket buffer */
+overlapped_io_init(struct overlapped_io *o,
+                   const struct frame *frame,
+                   BOOL event_state,
+                   bool tuntap_buffer)  /* if true: tuntap buffer, if false: socket buffer */
 {
-  CLEAR (*o);
+    CLEAR(*o);
 
-  /* manual reset event, initially set according to event_state */
-  o->overlapped.hEvent = CreateEvent (NULL, TRUE, event_state, NULL);
-  if (o->overlapped.hEvent == NULL)
-    msg (M_ERR, "Error: overlapped_io_init: CreateEvent failed");
+    /* manual reset event, initially set according to event_state */
+    o->overlapped.hEvent = CreateEvent(NULL, TRUE, event_state, NULL);
+    if (o->overlapped.hEvent == NULL)
+    {
+        msg(M_ERR, "Error: overlapped_io_init: CreateEvent failed");
+    }
 
-  /* allocate buffer for overlapped I/O */
-  alloc_buf_sock_tun (&o->buf_init, frame, tuntap_buffer, 0);
+    /* allocate buffer for overlapped I/O */
+    alloc_buf_sock_tun(&o->buf_init, frame, tuntap_buffer, 0);
 }
 
 void
-overlapped_io_close (struct overlapped_io *o)
+overlapped_io_close(struct overlapped_io *o)
 {
-  if (o->overlapped.hEvent)
+    if (o->overlapped.hEvent)
     {
-      if (!CloseHandle (o->overlapped.hEvent))
-	msg (M_WARN | M_ERRNO, "Warning: CloseHandle failed on overlapped I/O event object");
+        if (!CloseHandle(o->overlapped.hEvent))
+        {
+            msg(M_WARN | M_ERRNO, "Warning: CloseHandle failed on overlapped I/O event object");
+        }
     }
-  free_buf (&o->buf_init);
+    free_buf(&o->buf_init);
 }
 
 char *
-overlapped_io_state_ascii (const struct overlapped_io *o)
+overlapped_io_state_ascii(const struct overlapped_io *o)
 {
-  switch (o->iostate)
+    switch (o->iostate)
     {
-    case IOSTATE_INITIAL:
-      return "0";
-    case IOSTATE_QUEUED:
-      return "Q";
-    case IOSTATE_IMMEDIATE_RETURN:
-      return "1";
+        case IOSTATE_INITIAL:
+            return "0";
+
+        case IOSTATE_QUEUED:
+            return "Q";
+
+        case IOSTATE_IMMEDIATE_RETURN:
+            return "1";
     }
-  return "?";
+    return "?";
 }
 
 /*
@@ -198,79 +210,99 @@ overlapped_io_state_ascii (const struct overlapped_io *o)
  */
 
 void
-init_net_event_win32 (struct rw_handle *event, long network_events, socket_descriptor_t sd, unsigned int flags)
+init_net_event_win32(struct rw_handle *event, long network_events, socket_descriptor_t sd, unsigned int flags)
 {
-  /* manual reset events, initially set to unsignaled */
+    /* manual reset events, initially set to unsignaled */
 
-  /* initialize write event */
-  if (!(flags & NE32_PERSIST_EVENT) || !event->write)
+    /* initialize write event */
+    if (!(flags & NE32_PERSIST_EVENT) || !event->write)
     {
-      if (flags & NE32_WRITE_EVENT)
-	{
-	  event->write = CreateEvent (NULL, TRUE, FALSE, NULL);
-	  if (event->write == NULL)
-	    msg (M_ERR, "Error: init_net_event_win32: CreateEvent (write) failed");
-	}
-      else
-	event->write = NULL;
+        if (flags & NE32_WRITE_EVENT)
+        {
+            event->write = CreateEvent(NULL, TRUE, FALSE, NULL);
+            if (event->write == NULL)
+            {
+                msg(M_ERR, "Error: init_net_event_win32: CreateEvent (write) failed");
+            }
+        }
+        else
+        {
+            event->write = NULL;
+        }
     }
 
-  /* initialize read event */
-  if (!(flags & NE32_PERSIST_EVENT) || !event->read)
+    /* initialize read event */
+    if (!(flags & NE32_PERSIST_EVENT) || !event->read)
     {
-      event->read = CreateEvent (NULL, TRUE, FALSE, NULL);
-      if (event->read == NULL)
-	msg (M_ERR, "Error: init_net_event_win32: CreateEvent (read) failed");
+        event->read = CreateEvent(NULL, TRUE, FALSE, NULL);
+        if (event->read == NULL)
+        {
+            msg(M_ERR, "Error: init_net_event_win32: CreateEvent (read) failed");
+        }
+    }
+
+    /* setup network events to change read event state */
+    if (WSAEventSelect(sd, event->read, network_events) != 0)
+    {
+        msg(M_FATAL | M_ERRNO, "Error: init_net_event_win32: WSAEventSelect call failed");
     }
-  
-  /* setup network events to change read event state */
-  if (WSAEventSelect (sd, event->read, network_events) != 0)
-    msg (M_FATAL | M_ERRNO, "Error: init_net_event_win32: WSAEventSelect call failed");
 }
 
 long
-reset_net_event_win32 (struct rw_handle *event, socket_descriptor_t sd)
+reset_net_event_win32(struct rw_handle *event, socket_descriptor_t sd)
 {
-  WSANETWORKEVENTS wne;  
-  if (WSAEnumNetworkEvents (sd, event->read, &wne) != 0)
+    WSANETWORKEVENTS wne;
+    if (WSAEnumNetworkEvents(sd, event->read, &wne) != 0)
+    {
+        msg(M_FATAL | M_ERRNO, "Error: reset_net_event_win32: WSAEnumNetworkEvents call failed");
+        return 0; /* NOTREACHED */
+    }
+    else
     {
-      msg (M_FATAL | M_ERRNO, "Error: reset_net_event_win32: WSAEnumNetworkEvents call failed");
-      return 0; /* NOTREACHED */
+        return wne.lNetworkEvents;
     }
-  else
-    return wne.lNetworkEvents;
 }
 
 void
-close_net_event_win32 (struct rw_handle *event, socket_descriptor_t sd, unsigned int flags)
+close_net_event_win32(struct rw_handle *event, socket_descriptor_t sd, unsigned int flags)
 {
-  if (event->read)
-    {
-      if (socket_defined (sd))
-	{
-	  if (WSAEventSelect (sd, event->read, 0) != 0)
-	    msg (M_WARN | M_ERRNO, "Warning: close_net_event_win32: WSAEventSelect call failed");
-	}
-      if (!ResetEvent (event->read))
-	msg (M_WARN | M_ERRNO, "Warning: ResetEvent (read) failed in close_net_event_win32");
-      if (!(flags & NE32_PERSIST_EVENT))
-	{
-	  if (!CloseHandle (event->read))
-	    msg (M_WARN | M_ERRNO, "Warning: CloseHandle (read) failed in close_net_event_win32");
-	  event->read = NULL;
-	}
-    }
-
-  if (event->write)
-    {
-      if (!ResetEvent (event->write))
-	msg (M_WARN | M_ERRNO, "Warning: ResetEvent (write) failed in close_net_event_win32");
-      if (!(flags & NE32_PERSIST_EVENT))
-	{
-	  if (!CloseHandle (event->write))
-	    msg (M_WARN | M_ERRNO, "Warning: CloseHandle (write) failed in close_net_event_win32");
-	  event->write = NULL;
-	}
+    if (event->read)
+    {
+        if (socket_defined(sd))
+        {
+            if (WSAEventSelect(sd, event->read, 0) != 0)
+            {
+                msg(M_WARN | M_ERRNO, "Warning: close_net_event_win32: WSAEventSelect call failed");
+            }
+        }
+        if (!ResetEvent(event->read))
+        {
+            msg(M_WARN | M_ERRNO, "Warning: ResetEvent (read) failed in close_net_event_win32");
+        }
+        if (!(flags & NE32_PERSIST_EVENT))
+        {
+            if (!CloseHandle(event->read))
+            {
+                msg(M_WARN | M_ERRNO, "Warning: CloseHandle (read) failed in close_net_event_win32");
+            }
+            event->read = NULL;
+        }
+    }
+
+    if (event->write)
+    {
+        if (!ResetEvent(event->write))
+        {
+            msg(M_WARN | M_ERRNO, "Warning: ResetEvent (write) failed in close_net_event_win32");
+        }
+        if (!(flags & NE32_PERSIST_EVENT))
+        {
+            if (!CloseHandle(event->write))
+            {
+                msg(M_WARN | M_ERRNO, "Warning: CloseHandle (write) failed in close_net_event_win32");
+            }
+            event->write = NULL;
+        }
     }
 }
 
@@ -279,54 +311,64 @@ close_net_event_win32 (struct rw_handle *event, socket_descriptor_t sd, unsigned
  */
 
 void
-net_event_win32_init (struct net_event_win32 *ne)
+net_event_win32_init(struct net_event_win32 *ne)
 {
-  CLEAR (*ne);
-  ne->sd = SOCKET_UNDEFINED;
+    CLEAR(*ne);
+    ne->sd = SOCKET_UNDEFINED;
 }
 
 void
-net_event_win32_start (struct net_event_win32 *ne, long network_events, socket_descriptor_t sd)
+net_event_win32_start(struct net_event_win32 *ne, long network_events, socket_descriptor_t sd)
 {
-  ASSERT (!socket_defined (ne->sd));
-  ne->sd = sd;
-  ne->event_mask = 0;
-  init_net_event_win32 (&ne->handle, network_events, sd, NE32_PERSIST_EVENT|NE32_WRITE_EVENT);
+    ASSERT(!socket_defined(ne->sd));
+    ne->sd = sd;
+    ne->event_mask = 0;
+    init_net_event_win32(&ne->handle, network_events, sd, NE32_PERSIST_EVENT|NE32_WRITE_EVENT);
 }
 
 void
-net_event_win32_reset_write (struct net_event_win32 *ne)
+net_event_win32_reset_write(struct net_event_win32 *ne)
 {
-  BOOL status;
-  if (ne->event_mask & FD_WRITE)
-    status = SetEvent (ne->handle.write);
-  else
-    status = ResetEvent (ne->handle.write);
-  if (!status)
-    msg (M_WARN | M_ERRNO, "Warning: SetEvent/ResetEvent failed in net_event_win32_reset_write");
+    BOOL status;
+    if (ne->event_mask & FD_WRITE)
+    {
+        status = SetEvent(ne->handle.write);
+    }
+    else
+    {
+        status = ResetEvent(ne->handle.write);
+    }
+    if (!status)
+    {
+        msg(M_WARN | M_ERRNO, "Warning: SetEvent/ResetEvent failed in net_event_win32_reset_write");
+    }
 }
 
 void
-net_event_win32_reset (struct net_event_win32 *ne)
+net_event_win32_reset(struct net_event_win32 *ne)
 {
-  ne->event_mask |= reset_net_event_win32 (&ne->handle, ne->sd);
+    ne->event_mask |= reset_net_event_win32(&ne->handle, ne->sd);
 }
 
 void
-net_event_win32_stop (struct net_event_win32 *ne)
+net_event_win32_stop(struct net_event_win32 *ne)
 {
-  if (net_event_win32_defined (ne))
-    close_net_event_win32 (&ne->handle, ne->sd, NE32_PERSIST_EVENT);
-  ne->sd = SOCKET_UNDEFINED;
-  ne->event_mask = 0;
+    if (net_event_win32_defined(ne))
+    {
+        close_net_event_win32(&ne->handle, ne->sd, NE32_PERSIST_EVENT);
+    }
+    ne->sd = SOCKET_UNDEFINED;
+    ne->event_mask = 0;
 }
 
 void
-net_event_win32_close (struct net_event_win32 *ne)
+net_event_win32_close(struct net_event_win32 *ne)
 {
-  if (net_event_win32_defined (ne))
-    close_net_event_win32 (&ne->handle, ne->sd, 0);
-  net_event_win32_init (ne);
+    if (net_event_win32_defined(ne))
+    {
+        close_net_event_win32(&ne->handle, ne->sd, 0);
+    }
+    net_event_win32_init(ne);
 }
 
 /*
@@ -340,19 +382,23 @@ net_event_win32_close (struct net_event_win32 *ne)
 static void
 win_trigger_event(struct win32_signal *ws)
 {
-  if (ws->mode == WSO_MODE_SERVICE && HANDLE_DEFINED(ws->in.read))
-    SetEvent (ws->in.read);
-  else /* generate a key-press event */
+    if (ws->mode == WSO_MODE_SERVICE && HANDLE_DEFINED(ws->in.read))
     {
-      DWORD tmp;
-      INPUT_RECORD ir;
-      HANDLE stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
-
-      CLEAR(ir);
-      ir.EventType = KEY_EVENT;
-      ir.Event.KeyEvent.bKeyDown = true;
-      if (!stdin_handle || !WriteConsoleInput(stdin_handle, &ir, 1, &tmp))
-        msg(M_WARN|M_ERRNO, "WARN: win_trigger_event: WriteConsoleInput");
+        SetEvent(ws->in.read);
+    }
+    else /* generate a key-press event */
+    {
+        DWORD tmp;
+        INPUT_RECORD ir;
+        HANDLE stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
+
+        CLEAR(ir);
+        ir.EventType = KEY_EVENT;
+        ir.Event.KeyEvent.bKeyDown = true;
+        if (!stdin_handle || !WriteConsoleInput(stdin_handle, &ir, 1, &tmp))
+        {
+            msg(M_WARN|M_ERRNO, "WARN: win_trigger_event: WriteConsoleInput");
+        }
     }
 }
 
@@ -360,372 +406,429 @@ win_trigger_event(struct win32_signal *ws)
  * Callback to handle console ctrl events
  */
 static bool WINAPI
-win_ctrl_handler (DWORD signum)
+win_ctrl_handler(DWORD signum)
 {
-  msg(D_LOW, "win_ctrl_handler: signal received (code=%lu)", (unsigned long) signum);
-
-  if (siginfo_static.signal_received == SIGTERM)
-     return true;
-
-  switch (signum)
-    {
-    case CTRL_C_EVENT:
-    case CTRL_BREAK_EVENT:
-      throw_signal(SIGTERM);
-      /* trigget the win32_signal to interrupt the event loop */
-      win_trigger_event(&win32_signal);
-      return true;
-      break;
-    default:
-      msg(D_LOW, "win_ctrl_handler: signal (code=%lu) not handled", (unsigned long) signum);
-      break;
-    }
-  /* pass all other signals to the next handler */
-  return false;
+    msg(D_LOW, "win_ctrl_handler: signal received (code=%lu)", (unsigned long) signum);
+
+    if (siginfo_static.signal_received == SIGTERM)
+    {
+        return true;
+    }
+
+    switch (signum)
+    {
+        case CTRL_C_EVENT:
+        case CTRL_BREAK_EVENT:
+            throw_signal(SIGTERM);
+            /* trigget the win32_signal to interrupt the event loop */
+            win_trigger_event(&win32_signal);
+            return true;
+            break;
+
+        default:
+            msg(D_LOW, "win_ctrl_handler: signal (code=%lu) not handled", (unsigned long) signum);
+            break;
+    }
+    /* pass all other signals to the next handler */
+    return false;
 }
 
 void
-win32_signal_clear (struct win32_signal *ws)
+win32_signal_clear(struct win32_signal *ws)
 {
-  CLEAR (*ws);
+    CLEAR(*ws);
 }
 
 void
-win32_signal_open (struct win32_signal *ws,
-		   int force,
-		   const char *exit_event_name,
-		   bool exit_event_initial_state)
+win32_signal_open(struct win32_signal *ws,
+                  int force,
+                  const char *exit_event_name,
+                  bool exit_event_initial_state)
 {
-  CLEAR (*ws);
-
-  ws->mode = WSO_MODE_UNDEF;
-  ws->in.read = INVALID_HANDLE_VALUE;
-  ws->in.write = INVALID_HANDLE_VALUE;
-  ws->console_mode_save = 0;
-  ws->console_mode_save_defined = false;
-
-  if (force == WSO_NOFORCE || force == WSO_FORCE_CONSOLE)
-    {
-      /*
-       * Try to open console.
-       */
-      ws->in.read = GetStdHandle (STD_INPUT_HANDLE);
-      if (ws->in.read != INVALID_HANDLE_VALUE)
-	{
-	  if (GetConsoleMode (ws->in.read, &ws->console_mode_save))
-	    {
-	      /* running on a console */
-	      const DWORD new_console_mode = ws->console_mode_save
-		& ~(ENABLE_WINDOW_INPUT
-		    | ENABLE_PROCESSED_INPUT
-		    | ENABLE_LINE_INPUT
-		    | ENABLE_ECHO_INPUT 
-		    | ENABLE_MOUSE_INPUT);
-
-	      if (new_console_mode != ws->console_mode_save)
-		{
-		  if (!SetConsoleMode (ws->in.read, new_console_mode))
-		    msg (M_ERR, "Error: win32_signal_open: SetConsoleMode failed");
-		  ws->console_mode_save_defined = true;
-		}
-	      ws->mode = WSO_MODE_CONSOLE;
-	    }
-	  else
-	    ws->in.read = INVALID_HANDLE_VALUE; /* probably running as a service */
-	}
-    }
-
-  /*
-   * If console open failed, assume we are running
-   * as a service.
-   */
-  if ((force == WSO_NOFORCE || force == WSO_FORCE_SERVICE)
-      && !HANDLE_DEFINED (ws->in.read) && exit_event_name)
-    {
-      struct security_attributes sa;
-
-      if (!init_security_attributes_allow_all (&sa))
-	msg (M_ERR, "Error: win32_signal_open: init SA failed");
-
-      ws->in.read = CreateEvent (&sa.sa,
-				 TRUE,
-				 exit_event_initial_state ? TRUE : FALSE,
-				 exit_event_name);
-      if (ws->in.read == NULL)
-	{
-	  msg (M_WARN|M_ERRNO, "NOTE: CreateEvent '%s' failed", exit_event_name);
-	}
-      else
-	{
-	  if (WaitForSingleObject (ws->in.read, 0) != WAIT_TIMEOUT)
-	    msg (M_FATAL, "ERROR: Exit Event ('%s') is signaled", exit_event_name);
-	  else
-	    ws->mode = WSO_MODE_SERVICE;
-	}
+    CLEAR(*ws);
+
+    ws->mode = WSO_MODE_UNDEF;
+    ws->in.read = INVALID_HANDLE_VALUE;
+    ws->in.write = INVALID_HANDLE_VALUE;
+    ws->console_mode_save = 0;
+    ws->console_mode_save_defined = false;
+
+    if (force == WSO_NOFORCE || force == WSO_FORCE_CONSOLE)
+    {
+        /*
+         * Try to open console.
+         */
+        ws->in.read = GetStdHandle(STD_INPUT_HANDLE);
+        if (ws->in.read != INVALID_HANDLE_VALUE)
+        {
+            if (GetConsoleMode(ws->in.read, &ws->console_mode_save))
+            {
+                /* running on a console */
+                const DWORD new_console_mode = ws->console_mode_save
+                                               & ~(ENABLE_WINDOW_INPUT
+                                                   | ENABLE_PROCESSED_INPUT
+                                                   | ENABLE_LINE_INPUT
+                                                   | ENABLE_ECHO_INPUT
+                                                   | ENABLE_MOUSE_INPUT);
+
+                if (new_console_mode != ws->console_mode_save)
+                {
+                    if (!SetConsoleMode(ws->in.read, new_console_mode))
+                    {
+                        msg(M_ERR, "Error: win32_signal_open: SetConsoleMode failed");
+                    }
+                    ws->console_mode_save_defined = true;
+                }
+                ws->mode = WSO_MODE_CONSOLE;
+            }
+            else
+            {
+                ws->in.read = INVALID_HANDLE_VALUE; /* probably running as a service */
+            }
+        }
+    }
+
+    /*
+     * If console open failed, assume we are running
+     * as a service.
+     */
+    if ((force == WSO_NOFORCE || force == WSO_FORCE_SERVICE)
+        && !HANDLE_DEFINED(ws->in.read) && exit_event_name)
+    {
+        struct security_attributes sa;
+
+        if (!init_security_attributes_allow_all(&sa))
+        {
+            msg(M_ERR, "Error: win32_signal_open: init SA failed");
+        }
+
+        ws->in.read = CreateEvent(&sa.sa,
+                                  TRUE,
+                                  exit_event_initial_state ? TRUE : FALSE,
+                                  exit_event_name);
+        if (ws->in.read == NULL)
+        {
+            msg(M_WARN|M_ERRNO, "NOTE: CreateEvent '%s' failed", exit_event_name);
+        }
+        else
+        {
+            if (WaitForSingleObject(ws->in.read, 0) != WAIT_TIMEOUT)
+            {
+                msg(M_FATAL, "ERROR: Exit Event ('%s') is signaled", exit_event_name);
+            }
+            else
+            {
+                ws->mode = WSO_MODE_SERVICE;
+            }
+        }
     }
     /* set the ctrl handler in both console and service modes */
-    if (!SetConsoleCtrlHandler ((PHANDLER_ROUTINE) win_ctrl_handler, true))
-       msg (M_WARN|M_ERRNO, "WARN: SetConsoleCtrlHandler failed");
+    if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE) win_ctrl_handler, true))
+    {
+        msg(M_WARN|M_ERRNO, "WARN: SetConsoleCtrlHandler failed");
+    }
 }
 
 static bool
-keyboard_input_available (struct win32_signal *ws)
+keyboard_input_available(struct win32_signal *ws)
 {
-  ASSERT (ws->mode == WSO_MODE_CONSOLE);
-  if (HANDLE_DEFINED (ws->in.read))
+    ASSERT(ws->mode == WSO_MODE_CONSOLE);
+    if (HANDLE_DEFINED(ws->in.read))
     {
-      DWORD n;
-      if (GetNumberOfConsoleInputEvents (ws->in.read, &n))
-	return n > 0;
+        DWORD n;
+        if (GetNumberOfConsoleInputEvents(ws->in.read, &n))
+        {
+            return n > 0;
+        }
     }
-  return false;
+    return false;
 }
 
 static unsigned int
-keyboard_ir_to_key (INPUT_RECORD *ir)
+keyboard_ir_to_key(INPUT_RECORD *ir)
 {
-  if (ir->Event.KeyEvent.uChar.AsciiChar == 0)
-    return ir->Event.KeyEvent.wVirtualScanCode;
+    if (ir->Event.KeyEvent.uChar.AsciiChar == 0)
+    {
+        return ir->Event.KeyEvent.wVirtualScanCode;
+    }
 
-  if ((ir->Event.KeyEvent.dwControlKeyState
-       & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
-      && (ir->Event.KeyEvent.wVirtualKeyCode != 18))
-    return ir->Event.KeyEvent.wVirtualScanCode * 256;
+    if ((ir->Event.KeyEvent.dwControlKeyState
+         & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
+        && (ir->Event.KeyEvent.wVirtualKeyCode != 18))
+    {
+        return ir->Event.KeyEvent.wVirtualScanCode * 256;
+    }
 
-  return ir->Event.KeyEvent.uChar.AsciiChar;
+    return ir->Event.KeyEvent.uChar.AsciiChar;
 }
 
 static unsigned int
-win32_keyboard_get (struct win32_signal *ws)
+win32_keyboard_get(struct win32_signal *ws)
 {
-  ASSERT (ws->mode == WSO_MODE_CONSOLE);
-  if (HANDLE_DEFINED (ws->in.read))
-    {
-      INPUT_RECORD ir;
-      do {
-	DWORD n;
-	if (!keyboard_input_available (ws))
-	  return 0;
-	if (!ReadConsoleInput (ws->in.read, &ir, 1, &n))
-	  return 0;
-      } while (ir.EventType != KEY_EVENT || ir.Event.KeyEvent.bKeyDown != TRUE);
-
-      return keyboard_ir_to_key (&ir);
-    }
-  else
-    return 0;
+    ASSERT(ws->mode == WSO_MODE_CONSOLE);
+    if (HANDLE_DEFINED(ws->in.read))
+    {
+        INPUT_RECORD ir;
+        do {
+            DWORD n;
+            if (!keyboard_input_available(ws))
+            {
+                return 0;
+            }
+            if (!ReadConsoleInput(ws->in.read, &ir, 1, &n))
+            {
+                return 0;
+            }
+        } while (ir.EventType != KEY_EVENT || ir.Event.KeyEvent.bKeyDown != TRUE);
+
+        return keyboard_ir_to_key(&ir);
+    }
+    else
+    {
+        return 0;
+    }
 }
 
 void
-win32_signal_close (struct win32_signal *ws)
+win32_signal_close(struct win32_signal *ws)
 {
-  if (ws->mode == WSO_MODE_SERVICE && HANDLE_DEFINED (ws->in.read))
-    CloseHandle (ws->in.read);
-  if (ws->console_mode_save_defined)
+    if (ws->mode == WSO_MODE_SERVICE && HANDLE_DEFINED(ws->in.read))
     {
-      if (!SetConsoleMode (ws->in.read, ws->console_mode_save))
-	msg (M_ERR, "Error: win32_signal_close: SetConsoleMode failed");
+        CloseHandle(ws->in.read);
     }
-  CLEAR (*ws);
+    if (ws->console_mode_save_defined)
+    {
+        if (!SetConsoleMode(ws->in.read, ws->console_mode_save))
+        {
+            msg(M_ERR, "Error: win32_signal_close: SetConsoleMode failed");
+        }
+    }
+    CLEAR(*ws);
 }
 
 /*
  * Return true if interrupt occurs in service mode.
  */
 bool
-win32_service_interrupt (struct win32_signal *ws)
+win32_service_interrupt(struct win32_signal *ws)
 {
-  if (ws->mode == WSO_MODE_SERVICE)
+    if (ws->mode == WSO_MODE_SERVICE)
     {
-      if (HANDLE_DEFINED (ws->in.read)
-	  && WaitForSingleObject (ws->in.read, 0) == WAIT_OBJECT_0)
-	return true;
+        if (HANDLE_DEFINED(ws->in.read)
+            && WaitForSingleObject(ws->in.read, 0) == WAIT_OBJECT_0)
+        {
+            return true;
+        }
     }
-  return false;
+    return false;
 }
 
 int
-win32_signal_get (struct win32_signal *ws)
+win32_signal_get(struct win32_signal *ws)
 {
-  int ret = 0;
-  if (siginfo_static.signal_received)
-    {
-      ret = siginfo_static.signal_received;
-    }
-  else
-    {
-      if (ws->mode == WSO_MODE_SERVICE)
-	{
-	  if (win32_service_interrupt (ws))
-	    ret = SIGTERM;
-	}
-      else if (ws->mode == WSO_MODE_CONSOLE)
-	{
-	  switch (win32_keyboard_get (ws))
-	    {
-	    case 0x3B: /* F1 -> USR1 */
-	      ret = SIGUSR1;
-	      break;
-	    case 0x3C: /* F2 -> USR2 */
-	      ret = SIGUSR2;
-	      break;
-	    case 0x3D: /* F3 -> HUP */
-	      ret = SIGHUP;
-	      break;
-	    case 0x3E: /* F4 -> TERM */
-	      ret = SIGTERM;
-	      break;
-           case 0x03: /* CTRL-C -> TERM */
-             ret = SIGTERM;
-             break;
-	    }
-	}
-      if (ret)
-	{
-	  siginfo_static.signal_received = ret;
-	  siginfo_static.source = SIG_SOURCE_HARD;
-	}
-    }
-  return ret;
+    int ret = 0;
+    if (siginfo_static.signal_received)
+    {
+        ret = siginfo_static.signal_received;
+    }
+    else
+    {
+        if (ws->mode == WSO_MODE_SERVICE)
+        {
+            if (win32_service_interrupt(ws))
+            {
+                ret = SIGTERM;
+            }
+        }
+        else if (ws->mode == WSO_MODE_CONSOLE)
+        {
+            switch (win32_keyboard_get(ws))
+            {
+                case 0x3B: /* F1 -> USR1 */
+                    ret = SIGUSR1;
+                    break;
+
+                case 0x3C: /* F2 -> USR2 */
+                    ret = SIGUSR2;
+                    break;
+
+                case 0x3D: /* F3 -> HUP */
+                    ret = SIGHUP;
+                    break;
+
+                case 0x3E: /* F4 -> TERM */
+                    ret = SIGTERM;
+                    break;
+
+                case 0x03: /* CTRL-C -> TERM */
+                    ret = SIGTERM;
+                    break;
+            }
+        }
+        if (ret)
+        {
+            siginfo_static.signal_received = ret;
+            siginfo_static.source = SIG_SOURCE_HARD;
+        }
+    }
+    return ret;
 }
 
 void
-win32_pause (struct win32_signal *ws)
+win32_pause(struct win32_signal *ws)
 {
-  if (ws->mode == WSO_MODE_CONSOLE && HANDLE_DEFINED (ws->in.read))
+    if (ws->mode == WSO_MODE_CONSOLE && HANDLE_DEFINED(ws->in.read))
     {
-      int status;
-      msg (M_INFO|M_NOPREFIX, "Press any key to continue...");
-      do {
-	status = WaitForSingleObject (ws->in.read, INFINITE);
-      } while (!win32_keyboard_get (ws));
+        int status;
+        msg(M_INFO|M_NOPREFIX, "Press any key to continue...");
+        do {
+            status = WaitForSingleObject(ws->in.read, INFINITE);
+        } while (!win32_keyboard_get(ws));
     }
 }
 
 /* window functions */
 
 void
-window_title_clear (struct window_title *wt)
+window_title_clear(struct window_title *wt)
 {
-  CLEAR (*wt);
+    CLEAR(*wt);
 }
 
 void
-window_title_save (struct window_title *wt)
+window_title_save(struct window_title *wt)
 {
-  if (!wt->saved)
+    if (!wt->saved)
     {
-      if (!GetConsoleTitle (wt->old_window_title, sizeof (wt->old_window_title)))
-	{
-	  wt->old_window_title[0] = 0;
-	  wt->saved = false;
-	}
-      else
-	wt->saved = true;
+        if (!GetConsoleTitle(wt->old_window_title, sizeof(wt->old_window_title)))
+        {
+            wt->old_window_title[0] = 0;
+            wt->saved = false;
+        }
+        else
+        {
+            wt->saved = true;
+        }
     }
 }
 
 void
-window_title_restore (const struct window_title *wt)
+window_title_restore(const struct window_title *wt)
 {
-  if (wt->saved)
-    SetConsoleTitle (wt->old_window_title);
+    if (wt->saved)
+    {
+        SetConsoleTitle(wt->old_window_title);
+    }
 }
 
 void
-window_title_generate (const char *title)
+window_title_generate(const char *title)
 {
-  struct gc_arena gc = gc_new ();
-  struct buffer out = alloc_buf_gc (256, &gc);
-  if (!title)
-    title = "";
-  buf_printf (&out, "[%s] " PACKAGE_NAME " " PACKAGE_VERSION " F4:EXIT F1:USR1 F2:USR2 F3:HUP", title);
-  SetConsoleTitle (BSTR (&out));
-  gc_free (&gc);
+    struct gc_arena gc = gc_new();
+    struct buffer out = alloc_buf_gc(256, &gc);
+    if (!title)
+    {
+        title = "";
+    }
+    buf_printf(&out, "[%s] " PACKAGE_NAME " " PACKAGE_VERSION " F4:EXIT F1:USR1 F2:USR2 F3:HUP", title);
+    SetConsoleTitle(BSTR(&out));
+    gc_free(&gc);
 }
 
 /* semaphore functions */
 
 void
-semaphore_clear (struct semaphore *s)
+semaphore_clear(struct semaphore *s)
 {
-  CLEAR (*s);
+    CLEAR(*s);
 }
 
 void
-semaphore_open (struct semaphore *s, const char *name)
+semaphore_open(struct semaphore *s, const char *name)
 {
-  struct security_attributes sa;
+    struct security_attributes sa;
 
-  s->locked = false;
-  s->name = name;
-  s->hand = NULL;
+    s->locked = false;
+    s->name = name;
+    s->hand = NULL;
 
-  if (init_security_attributes_allow_all (&sa))
-    s->hand = CreateSemaphore(&sa.sa, 1, 1, name);
+    if (init_security_attributes_allow_all(&sa))
+    {
+        s->hand = CreateSemaphore(&sa.sa, 1, 1, name);
+    }
 
-  if (s->hand == NULL)
-    msg (M_WARN|M_ERRNO, "WARNING: Cannot create Win32 semaphore '%s'", name);
-  else
-    dmsg (D_SEMAPHORE, "Created Win32 semaphore '%s'", s->name);
+    if (s->hand == NULL)
+    {
+        msg(M_WARN|M_ERRNO, "WARNING: Cannot create Win32 semaphore '%s'", name);
+    }
+    else
+    {
+        dmsg(D_SEMAPHORE, "Created Win32 semaphore '%s'", s->name);
+    }
 }
 
 bool
-semaphore_lock (struct semaphore *s, int timeout_milliseconds)
+semaphore_lock(struct semaphore *s, int timeout_milliseconds)
 {
-  bool ret = true;
-
-  if (s->hand)
-    {
-      DWORD status;
-      ASSERT (!s->locked);
-
-      dmsg (D_SEMAPHORE_LOW, "Attempting to lock Win32 semaphore '%s' prior to net shell command (timeout = %d sec)",
-	   s->name,
-	   timeout_milliseconds / 1000);
-      status = WaitForSingleObject (s->hand, timeout_milliseconds);
-      if (status == WAIT_FAILED)
-	msg (M_ERR, "Wait failed on Win32 semaphore '%s'", s->name);
-      ret = (status == WAIT_TIMEOUT) ? false : true;
-      if (ret)
-	{
-	  dmsg (D_SEMAPHORE, "Locked Win32 semaphore '%s'", s->name);
-	  s->locked = true;
-	}
-      else
-	{
-	  dmsg (D_SEMAPHORE, "Wait on Win32 semaphore '%s' timed out after %d milliseconds",
-	       s->name,
-	       timeout_milliseconds);
-	}
-    }
-  return ret;
+    bool ret = true;
+
+    if (s->hand)
+    {
+        DWORD status;
+        ASSERT(!s->locked);
+
+        dmsg(D_SEMAPHORE_LOW, "Attempting to lock Win32 semaphore '%s' prior to net shell command (timeout = %d sec)",
+             s->name,
+             timeout_milliseconds / 1000);
+        status = WaitForSingleObject(s->hand, timeout_milliseconds);
+        if (status == WAIT_FAILED)
+        {
+            msg(M_ERR, "Wait failed on Win32 semaphore '%s'", s->name);
+        }
+        ret = (status == WAIT_TIMEOUT) ? false : true;
+        if (ret)
+        {
+            dmsg(D_SEMAPHORE, "Locked Win32 semaphore '%s'", s->name);
+            s->locked = true;
+        }
+        else
+        {
+            dmsg(D_SEMAPHORE, "Wait on Win32 semaphore '%s' timed out after %d milliseconds",
+                 s->name,
+                 timeout_milliseconds);
+        }
+    }
+    return ret;
 }
 
 void
-semaphore_release (struct semaphore *s)
+semaphore_release(struct semaphore *s)
 {
-  if (s->hand)
+    if (s->hand)
     {
-      ASSERT (s->locked);
-      dmsg (D_SEMAPHORE, "Releasing Win32 semaphore '%s'", s->name);
-      if (!ReleaseSemaphore(s->hand, 1, NULL))
-	msg (M_WARN | M_ERRNO, "ReleaseSemaphore failed on Win32 semaphore '%s'",
-	     s->name);
-      s->locked = false;
+        ASSERT(s->locked);
+        dmsg(D_SEMAPHORE, "Releasing Win32 semaphore '%s'", s->name);
+        if (!ReleaseSemaphore(s->hand, 1, NULL))
+        {
+            msg(M_WARN | M_ERRNO, "ReleaseSemaphore failed on Win32 semaphore '%s'",
+                s->name);
+        }
+        s->locked = false;
     }
 }
 
 void
-semaphore_close (struct semaphore *s)
+semaphore_close(struct semaphore *s)
 {
-  if (s->hand)
+    if (s->hand)
     {
-      if (s->locked)
-	semaphore_release (s);
-      dmsg (D_SEMAPHORE, "Closing Win32 semaphore '%s'", s->name);
-      CloseHandle (s->hand);
-      s->hand = NULL;
+        if (s->locked)
+        {
+            semaphore_release(s);
+        }
+        dmsg(D_SEMAPHORE, "Closing Win32 semaphore '%s'", s->name);
+        CloseHandle(s->hand);
+        s->hand = NULL;
     }
 }
 
@@ -735,35 +838,39 @@ semaphore_close (struct semaphore *s)
  */
 
 void
-netcmd_semaphore_init (void)
+netcmd_semaphore_init(void)
 {
-  semaphore_open (&netcmd_semaphore, PACKAGE "_netcmd");
+    semaphore_open(&netcmd_semaphore, PACKAGE "_netcmd");
 }
 
 void
-netcmd_semaphore_close (void)
+netcmd_semaphore_close(void)
 {
-  semaphore_close (&netcmd_semaphore);
+    semaphore_close(&netcmd_semaphore);
 }
 
 void
-netcmd_semaphore_lock (void)
+netcmd_semaphore_lock(void)
 {
-  const int timeout_seconds = 600;
+    const int timeout_seconds = 600;
 
-  if (!netcmd_semaphore.hand)
-    netcmd_semaphore_init ();
+    if (!netcmd_semaphore.hand)
+    {
+        netcmd_semaphore_init();
+    }
 
-  if (!semaphore_lock (&netcmd_semaphore, timeout_seconds * 1000))
-    msg (M_FATAL, "Cannot lock net command semaphore"); 
+    if (!semaphore_lock(&netcmd_semaphore, timeout_seconds * 1000))
+    {
+        msg(M_FATAL, "Cannot lock net command semaphore");
+    }
 }
 
 void
-netcmd_semaphore_release (void)
+netcmd_semaphore_release(void)
 {
-  semaphore_release (&netcmd_semaphore);
-  /* netcmd_semaphore has max count of 1 - safe to close after release */
-  semaphore_close (&netcmd_semaphore);
+    semaphore_release(&netcmd_semaphore);
+    /* netcmd_semaphore has max count of 1 - safe to close after release */
+    semaphore_close(&netcmd_semaphore);
 }
 
 /*
@@ -778,54 +885,78 @@ netcmd_semaphore_release (void)
  */
 
 static bool
-cmp_prefix (const char *str, const bool n, const char *pre)
+cmp_prefix(const char *str, const bool n, const char *pre)
 {
-  size_t i = 0;
+    size_t i = 0;
 
-  if (!str)
-    return false;
+    if (!str)
+    {
+        return false;
+    }
 
-  while (true)
-    {
-      const int c1 = pre[i];
-      int c2 = str[i];
-      ++i;
-      if (c1 == '\0')
-	{
-	  if (n)
-	    {
-	      if (isdigit (c2))
-		c2 = str[i];
-	      else
-		return false;
-	    }
-	  return c2 == '\0' || c2 == '.';
-	}
-      else if (c2 == '\0')
-	return false;
-      if (c1 != tolower(c2))
-	return false;
+    while (true)
+    {
+        const int c1 = pre[i];
+        int c2 = str[i];
+        ++i;
+        if (c1 == '\0')
+        {
+            if (n)
+            {
+                if (isdigit(c2))
+                {
+                    c2 = str[i];
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            return c2 == '\0' || c2 == '.';
+        }
+        else if (c2 == '\0')
+        {
+            return false;
+        }
+        if (c1 != tolower(c2))
+        {
+            return false;
+        }
     }
 }
 
 bool
-win_safe_filename (const char *fn)
+win_safe_filename(const char *fn)
 {
-  if (cmp_prefix (fn, false, "con"))
-    return false;
-  if (cmp_prefix (fn, false, "prn"))
-    return false;
-  if (cmp_prefix (fn, false, "aux"))
-    return false;
-  if (cmp_prefix (fn, false, "nul"))
-    return false;
-  if (cmp_prefix (fn, true, "com"))
-    return false;
-  if (cmp_prefix (fn, true, "lpt"))
-    return false;
-  if (cmp_prefix (fn, false, "clock$"))
-    return false;
-  return true;
+    if (cmp_prefix(fn, false, "con"))
+    {
+        return false;
+    }
+    if (cmp_prefix(fn, false, "prn"))
+    {
+        return false;
+    }
+    if (cmp_prefix(fn, false, "aux"))
+    {
+        return false;
+    }
+    if (cmp_prefix(fn, false, "nul"))
+    {
+        return false;
+    }
+    if (cmp_prefix(fn, true, "com"))
+    {
+        return false;
+    }
+    if (cmp_prefix(fn, true, "lpt"))
+    {
+        return false;
+    }
+    if (cmp_prefix(fn, false, "clock$"))
+    {
+        return false;
+    }
+    return true;
 }
 
 /*
@@ -833,372 +964,397 @@ win_safe_filename (const char *fn)
  */
 
 static char *
-env_block (const struct env_set *es)
+env_block(const struct env_set *es)
 {
-  char force_path[256];
-  char *sysroot = get_win_sys_path();
-
-  if (!openvpn_snprintf(force_path, sizeof(force_path), "PATH=%s\\System32;%s;%s\\System32\\Wbem",
-                        sysroot, sysroot, sysroot))
-    msg(M_WARN, "env_block: default path truncated to %s", force_path);
-
-  if (es)
-    {
-      struct env_item *e;
-      char *ret;
-      char *p;
-      size_t nchars = 1;
-      bool path_seen = false;
-      
-      for (e = es->list; e != NULL; e = e->next)
-	nchars += strlen (e->string) + 1;
-
-      nchars += strlen(force_path)+1;
-
-      ret = (char *) malloc (nchars);
-      check_malloc_return (ret);
-
-      p = ret;
-      for (e = es->list; e != NULL; e = e->next)
-	{
-	  if (env_allowed (e->string))
-	    {
-	      strcpy (p, e->string);
-	      p += strlen (e->string) + 1;
-	    }
-	  if ( strncmp(e->string, "PATH=", 5 ) == 0 )
-	    path_seen = true;
-	}
-
-      /* make sure PATH is set */
-      if ( !path_seen )
-	{
-	  msg( M_INFO, "env_block: add %s", force_path );
-	  strcpy( p, force_path );
-	  p += strlen(force_path) + 1;
-	}
-
-      *p = '\0';
-      return ret;
-    }
-  else
-    return NULL;
+    char force_path[256];
+    char *sysroot = get_win_sys_path();
+
+    if (!openvpn_snprintf(force_path, sizeof(force_path), "PATH=%s\\System32;%s;%s\\System32\\Wbem",
+                          sysroot, sysroot, sysroot))
+    {
+        msg(M_WARN, "env_block: default path truncated to %s", force_path);
+    }
+
+    if (es)
+    {
+        struct env_item *e;
+        char *ret;
+        char *p;
+        size_t nchars = 1;
+        bool path_seen = false;
+
+        for (e = es->list; e != NULL; e = e->next)
+            nchars += strlen(e->string) + 1;
+
+        nchars += strlen(force_path)+1;
+
+        ret = (char *) malloc(nchars);
+        check_malloc_return(ret);
+
+        p = ret;
+        for (e = es->list; e != NULL; e = e->next)
+        {
+            if (env_allowed(e->string))
+            {
+                strcpy(p, e->string);
+                p += strlen(e->string) + 1;
+            }
+            if (strncmp(e->string, "PATH=", 5 ) == 0)
+            {
+                path_seen = true;
+            }
+        }
+
+        /* make sure PATH is set */
+        if (!path_seen)
+        {
+            msg( M_INFO, "env_block: add %s", force_path );
+            strcpy( p, force_path );
+            p += strlen(force_path) + 1;
+        }
+
+        *p = '\0';
+        return ret;
+    }
+    else
+    {
+        return NULL;
+    }
 }
 
 static WCHAR *
-wide_cmd_line (const struct argv *a, struct gc_arena *gc)
+wide_cmd_line(const struct argv *a, struct gc_arena *gc)
 {
-  size_t nchars = 1;
-  size_t maxlen = 0;
-  size_t i;
-  struct buffer buf;
-  char *work = NULL;
+    size_t nchars = 1;
+    size_t maxlen = 0;
+    size_t i;
+    struct buffer buf;
+    char *work = NULL;
 
-  if (!a)
-    return NULL;
+    if (!a)
+    {
+        return NULL;
+    }
 
-  for (i = 0; i < a->argc; ++i)
+    for (i = 0; i < a->argc; ++i)
     {
-      const char *arg = a->argv[i];
-      const size_t len = strlen (arg);
-      nchars += len + 3;
-      if (len > maxlen)
-	maxlen = len;
+        const char *arg = a->argv[i];
+        const size_t len = strlen(arg);
+        nchars += len + 3;
+        if (len > maxlen)
+        {
+            maxlen = len;
+        }
     }
 
-  work = gc_malloc (maxlen + 1, false, gc);
-  check_malloc_return (work);
-  buf = alloc_buf_gc (nchars, gc);
+    work = gc_malloc(maxlen + 1, false, gc);
+    check_malloc_return(work);
+    buf = alloc_buf_gc(nchars, gc);
 
-  for (i = 0; i < a->argc; ++i)
+    for (i = 0; i < a->argc; ++i)
     {
-      const char *arg = a->argv[i];
-      strcpy (work, arg);
-      string_mod (work, CC_PRINT, CC_DOUBLE_QUOTE|CC_CRLF, '_');
-      if (i)
-	buf_printf (&buf, " ");
-      if (string_class (work, CC_ANY, CC_SPACE))
-	buf_printf (&buf, "%s", work);
-      else
-	buf_printf (&buf, "\"%s\"", work);
+        const char *arg = a->argv[i];
+        strcpy(work, arg);
+        string_mod(work, CC_PRINT, CC_DOUBLE_QUOTE|CC_CRLF, '_');
+        if (i)
+        {
+            buf_printf(&buf, " ");
+        }
+        if (string_class(work, CC_ANY, CC_SPACE))
+        {
+            buf_printf(&buf, "%s", work);
+        }
+        else
+        {
+            buf_printf(&buf, "\"%s\"", work);
+        }
     }
 
-  return wide_string (BSTR (&buf), gc);
+    return wide_string(BSTR(&buf), gc);
 }
 
 /*
  * Attempt to simulate fork/execve on Windows
  */
 int
-openvpn_execve (const struct argv *a, const struct env_set *es, const unsigned int flags)
+openvpn_execve(const struct argv *a, const struct env_set *es, const unsigned int flags)
 {
-  int ret = -1;
-  static bool exec_warn = false;
+    int ret = -1;
+    static bool exec_warn = false;
 
-  if (a && a->argv[0])
+    if (a && a->argv[0])
     {
-      if (openvpn_execve_allowed (flags))
-	{
-          struct gc_arena gc = gc_new ();
-          STARTUPINFOW start_info;
-          PROCESS_INFORMATION proc_info;
+        if (openvpn_execve_allowed(flags))
+        {
+            struct gc_arena gc = gc_new();
+            STARTUPINFOW start_info;
+            PROCESS_INFORMATION proc_info;
 
-          char *env = env_block (es);
-          WCHAR *cl = wide_cmd_line (a, &gc);
-          WCHAR *cmd = wide_string (a->argv[0], &gc);
+            char *env = env_block(es);
+            WCHAR *cl = wide_cmd_line(a, &gc);
+            WCHAR *cmd = wide_string(a->argv[0], &gc);
 
-          /* this allows console programs to run, and is ignored otherwise */
-          DWORD proc_flags = CREATE_NO_WINDOW;
+            /* this allows console programs to run, and is ignored otherwise */
+            DWORD proc_flags = CREATE_NO_WINDOW;
 
-          CLEAR (start_info);
-          CLEAR (proc_info);
+            CLEAR(start_info);
+            CLEAR(proc_info);
 
-          /* fill in STARTUPINFO struct */
-          GetStartupInfoW(&start_info);
-          start_info.cb = sizeof(start_info);
-          start_info.dwFlags = STARTF_USESHOWWINDOW;
-          start_info.wShowWindow = SW_HIDE;
+            /* fill in STARTUPINFO struct */
+            GetStartupInfoW(&start_info);
+            start_info.cb = sizeof(start_info);
+            start_info.dwFlags = STARTF_USESHOWWINDOW;
+            start_info.wShowWindow = SW_HIDE;
 
-          if (CreateProcessW (cmd, cl, NULL, NULL, FALSE, proc_flags, env, NULL, &start_info, &proc_info))
+            if (CreateProcessW(cmd, cl, NULL, NULL, FALSE, proc_flags, env, NULL, &start_info, &proc_info))
             {
-              DWORD exit_status = 0;
-              CloseHandle (proc_info.hThread);
-              WaitForSingleObject (proc_info.hProcess, INFINITE);
-              if (GetExitCodeProcess (proc_info.hProcess, &exit_status))
-                ret = (int)exit_status;
-              else
-                msg (M_WARN|M_ERRNO, "openvpn_execve: GetExitCodeProcess %S failed", cmd);
-              CloseHandle (proc_info.hProcess);
+                DWORD exit_status = 0;
+                CloseHandle(proc_info.hThread);
+                WaitForSingleObject(proc_info.hProcess, INFINITE);
+                if (GetExitCodeProcess(proc_info.hProcess, &exit_status))
+                {
+                    ret = (int)exit_status;
+                }
+                else
+                {
+                    msg(M_WARN|M_ERRNO, "openvpn_execve: GetExitCodeProcess %S failed", cmd);
+                }
+                CloseHandle(proc_info.hProcess);
             }
-          else
+            else
             {
-              msg (M_WARN|M_ERRNO, "openvpn_execve: CreateProcess %S failed", cmd);
+                msg(M_WARN|M_ERRNO, "openvpn_execve: CreateProcess %S failed", cmd);
             }
-          free (env);
-          gc_free (&gc);
+            free(env);
+            gc_free(&gc);
+        }
+        else if (!exec_warn && (script_security < SSEC_SCRIPTS))
+        {
+            msg(M_WARN, SCRIPT_SECURITY_WARNING);
+            exec_warn = true;
         }
-      else if (!exec_warn && (script_security < SSEC_SCRIPTS))
-	{
-	  msg (M_WARN, SCRIPT_SECURITY_WARNING);
-          exec_warn = true;
-	}
     }
-  else
+    else
     {
-      msg (M_WARN, "openvpn_execve: called with empty argv");
+        msg(M_WARN, "openvpn_execve: called with empty argv");
     }
-  return ret;
+    return ret;
 }
 
 WCHAR *
-wide_string (const char* utf8, struct gc_arena *gc)
+wide_string(const char *utf8, struct gc_arena *gc)
 {
-  int n = MultiByteToWideChar (CP_UTF8, 0, utf8, -1, NULL, 0);
-  WCHAR *ucs16 = gc_malloc (n * sizeof (WCHAR), false, gc);
-  MultiByteToWideChar (CP_UTF8, 0, utf8, -1, ucs16, n);
-  return ucs16;
+    int n = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
+    WCHAR *ucs16 = gc_malloc(n * sizeof(WCHAR), false, gc);
+    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, ucs16, n);
+    return ucs16;
 }
 
 /*
  * call ourself in another process
  */
 void
-fork_to_self (const char *cmdline)
+fork_to_self(const char *cmdline)
 {
-  STARTUPINFO start_info;
-  PROCESS_INFORMATION proc_info;
-  char self_exe[256];
-  char *cl = string_alloc (cmdline, NULL);
-  DWORD status;
-
-  CLEAR (start_info);
-  CLEAR (proc_info);
-  CLEAR (self_exe);
-
-  status = GetModuleFileName (NULL, self_exe, sizeof(self_exe));
-  if (status == 0 || status == sizeof(self_exe))
+    STARTUPINFO start_info;
+    PROCESS_INFORMATION proc_info;
+    char self_exe[256];
+    char *cl = string_alloc(cmdline, NULL);
+    DWORD status;
+
+    CLEAR(start_info);
+    CLEAR(proc_info);
+    CLEAR(self_exe);
+
+    status = GetModuleFileName(NULL, self_exe, sizeof(self_exe));
+    if (status == 0 || status == sizeof(self_exe))
     {
-      msg (M_WARN|M_ERRNO, "fork_to_self: CreateProcess failed: cannot get module name via GetModuleFileName");
-      goto done;
+        msg(M_WARN|M_ERRNO, "fork_to_self: CreateProcess failed: cannot get module name via GetModuleFileName");
+        goto done;
     }
 
-  /* fill in STARTUPINFO struct */
-  GetStartupInfo(&start_info);
-  start_info.cb = sizeof(start_info);
-  start_info.dwFlags = STARTF_USESHOWWINDOW;
-  start_info.wShowWindow = SW_HIDE;
+    /* fill in STARTUPINFO struct */
+    GetStartupInfo(&start_info);
+    start_info.cb = sizeof(start_info);
+    start_info.dwFlags = STARTF_USESHOWWINDOW;
+    start_info.wShowWindow = SW_HIDE;
 
-  if (CreateProcess (self_exe, cl, NULL, NULL, FALSE, 0, NULL, NULL, &start_info, &proc_info))
+    if (CreateProcess(self_exe, cl, NULL, NULL, FALSE, 0, NULL, NULL, &start_info, &proc_info))
     {
-      CloseHandle (proc_info.hThread);
-      CloseHandle (proc_info.hProcess);
+        CloseHandle(proc_info.hThread);
+        CloseHandle(proc_info.hProcess);
     }
-  else
+    else
     {
-      msg (M_WARN|M_ERRNO, "fork_to_self: CreateProcess failed: %s", cmdline);
+        msg(M_WARN|M_ERRNO, "fork_to_self: CreateProcess failed: %s", cmdline);
     }
 
- done:
-  free (cl);
+done:
+    free(cl);
 }
 
 char *
-get_win_sys_path (void)
+get_win_sys_path(void)
 {
-  ASSERT (win_sys_path);
-  return win_sys_path;
+    ASSERT(win_sys_path);
+    return win_sys_path;
 }
 
 void
-set_win_sys_path (const char *newpath, struct env_set *es)
+set_win_sys_path(const char *newpath, struct env_set *es)
 {
-  free (win_sys_path);
-  win_sys_path = string_alloc (newpath, NULL);
-  setenv_str (es, SYS_PATH_ENV_VAR_NAME, win_sys_path); /* route.exe needs this */
+    free(win_sys_path);
+    win_sys_path = string_alloc(newpath, NULL);
+    setenv_str(es, SYS_PATH_ENV_VAR_NAME, win_sys_path); /* route.exe needs this */
 }
 
 void
-set_win_sys_path_via_env (struct env_set *es)
+set_win_sys_path_via_env(struct env_set *es)
 {
-  char buf[256];
-  DWORD status = GetEnvironmentVariable (SYS_PATH_ENV_VAR_NAME, buf, sizeof(buf));
-  if (!status)
-    msg (M_ERR, "Cannot find environmental variable %s", SYS_PATH_ENV_VAR_NAME);
-  if (status > sizeof (buf) - 1)
-    msg (M_FATAL, "String overflow attempting to read environmental variable %s", SYS_PATH_ENV_VAR_NAME);
-  set_win_sys_path (buf, es);
+    char buf[256];
+    DWORD status = GetEnvironmentVariable(SYS_PATH_ENV_VAR_NAME, buf, sizeof(buf));
+    if (!status)
+    {
+        msg(M_ERR, "Cannot find environmental variable %s", SYS_PATH_ENV_VAR_NAME);
+    }
+    if (status > sizeof(buf) - 1)
+    {
+        msg(M_FATAL, "String overflow attempting to read environmental variable %s", SYS_PATH_ENV_VAR_NAME);
+    }
+    set_win_sys_path(buf, es);
 }
 
 
 const char *
 win_get_tempdir()
 {
-  static char tmpdir[MAX_PATH];
-  WCHAR wtmpdir[MAX_PATH];
+    static char tmpdir[MAX_PATH];
+    WCHAR wtmpdir[MAX_PATH];
 
-  if (!GetTempPathW(_countof(wtmpdir), wtmpdir))
+    if (!GetTempPathW(_countof(wtmpdir), wtmpdir))
     {
-      /* Warn if we can't find a valid temporary directory, which should
-       * be unlikely.
-       */
-      msg (M_WARN, "Could not find a suitable temporary directory."
-          " (GetTempPath() failed).  Consider using --tmp-dir");
-      return NULL;
+        /* Warn if we can't find a valid temporary directory, which should
+         * be unlikely.
+         */
+        msg(M_WARN, "Could not find a suitable temporary directory."
+            " (GetTempPath() failed).  Consider using --tmp-dir");
+        return NULL;
     }
 
-  if (WideCharToMultiByte (CP_UTF8, 0, wtmpdir, -1, NULL, 0, NULL, NULL) > sizeof (tmpdir))
+    if (WideCharToMultiByte(CP_UTF8, 0, wtmpdir, -1, NULL, 0, NULL, NULL) > sizeof(tmpdir))
     {
-      msg (M_WARN, "Could not get temporary directory. Path is too long."
-          "  Consider using --tmp-dir");
-      return NULL;
+        msg(M_WARN, "Could not get temporary directory. Path is too long."
+            "  Consider using --tmp-dir");
+        return NULL;
     }
 
-  WideCharToMultiByte (CP_UTF8, 0, wtmpdir, -1, tmpdir, sizeof (tmpdir), NULL, NULL);
-  return tmpdir;
+    WideCharToMultiByte(CP_UTF8, 0, wtmpdir, -1, tmpdir, sizeof(tmpdir), NULL, NULL);
+    return tmpdir;
 }
 
 static bool
-win_block_dns_service (bool add, int index, const HANDLE pipe)
+win_block_dns_service(bool add, int index, const HANDLE pipe)
 {
-  DWORD len;
-  bool ret = false;
-  ack_message_t ack;
-  struct gc_arena gc = gc_new ();
-
-  block_dns_message_t data = {
-    .header = {
-      (add ? msg_add_block_dns : msg_del_block_dns),
-      sizeof (block_dns_message_t),
-      0 },
-    .iface = { .index = index, .name = "" }
-  };
-
-  if (!WriteFile (pipe, &data, sizeof (data), &len, NULL) ||
-      !ReadFile (pipe, &ack, sizeof (ack), &len, NULL))
+    DWORD len;
+    bool ret = false;
+    ack_message_t ack;
+    struct gc_arena gc = gc_new();
+
+    block_dns_message_t data = {
+        .header = {
+            (add ? msg_add_block_dns : msg_del_block_dns),
+            sizeof(block_dns_message_t),
+            0
+        },
+        .iface = { .index = index, .name = "" }
+    };
+
+    if (!WriteFile(pipe, &data, sizeof(data), &len, NULL)
+        || !ReadFile(pipe, &ack, sizeof(ack), &len, NULL))
     {
-      msg (M_WARN, "Block_DNS: could not talk to service: %s [%lu]",
-           strerror_win32 (GetLastError (), &gc), GetLastError ());
-      goto out;
+        msg(M_WARN, "Block_DNS: could not talk to service: %s [%lu]",
+            strerror_win32(GetLastError(), &gc), GetLastError());
+        goto out;
     }
 
-  if (ack.error_number != NO_ERROR)
+    if (ack.error_number != NO_ERROR)
     {
-      msg (M_WARN, "Block_DNS: %s block dns filters using service failed: %s [status=0x%x if_index=%d]",
-           (add ? "adding" : "deleting"), strerror_win32 (ack.error_number, &gc),
-           ack.error_number, data.iface.index);
-      goto out;
+        msg(M_WARN, "Block_DNS: %s block dns filters using service failed: %s [status=0x%x if_index=%d]",
+            (add ? "adding" : "deleting"), strerror_win32(ack.error_number, &gc),
+            ack.error_number, data.iface.index);
+        goto out;
     }
 
-  ret = true;
-  msg (M_INFO, "%s outside dns using service succeeded.", (add ? "Blocking" : "Unblocking"));
+    ret = true;
+    msg(M_INFO, "%s outside dns using service succeeded.", (add ? "Blocking" : "Unblocking"));
 out:
-  gc_free (&gc);
-  return ret;
+    gc_free(&gc);
+    return ret;
 }
 
 static void
-block_dns_msg_handler (DWORD err, const char *msg)
+block_dns_msg_handler(DWORD err, const char *msg)
 {
-  struct gc_arena gc = gc_new ();
+    struct gc_arena gc = gc_new();
 
-  if (err == 0)
+    if (err == 0)
     {
-      msg (M_INFO, "%s", msg);
+        msg(M_INFO, "%s", msg);
     }
-  else
+    else
     {
-      msg (M_WARN, "Error in add_block_dns_filters(): %s : %s [status=0x%lx]",
-           msg, strerror_win32 (err, &gc), err);
+        msg(M_WARN, "Error in add_block_dns_filters(): %s : %s [status=0x%lx]",
+            msg, strerror_win32(err, &gc), err);
     }
 
-  gc_free (&gc);
+    gc_free(&gc);
 }
 
 bool
-win_wfp_block_dns (const NET_IFINDEX index, const HANDLE msg_channel)
+win_wfp_block_dns(const NET_IFINDEX index, const HANDLE msg_channel)
 {
-  WCHAR openvpnpath[MAX_PATH];
-  bool ret = false;
-  DWORD status;
+    WCHAR openvpnpath[MAX_PATH];
+    bool ret = false;
+    DWORD status;
 
-  if (msg_channel)
+    if (msg_channel)
     {
-      dmsg (D_LOW, "Using service to add block dns filters");
-      ret = win_block_dns_service (true, index, msg_channel);
-      goto out;
+        dmsg(D_LOW, "Using service to add block dns filters");
+        ret = win_block_dns_service(true, index, msg_channel);
+        goto out;
     }
 
-  status = GetModuleFileNameW (NULL, openvpnpath, sizeof(openvpnpath));
-  if (status == 0 || status == sizeof(openvpnpath))
+    status = GetModuleFileNameW(NULL, openvpnpath, sizeof(openvpnpath));
+    if (status == 0 || status == sizeof(openvpnpath))
     {
-      msg (M_WARN|M_ERRNO, "block_dns: cannot get executable path");
-      goto out;
+        msg(M_WARN|M_ERRNO, "block_dns: cannot get executable path");
+        goto out;
     }
 
-  status = add_block_dns_filters (&m_hEngineHandle, index, openvpnpath,
-                                 block_dns_msg_handler);
-  ret = (status == 0);
+    status = add_block_dns_filters(&m_hEngineHandle, index, openvpnpath,
+                                   block_dns_msg_handler);
+    ret = (status == 0);
 
 out:
 
-  return ret;
+    return ret;
 }
 
 bool
 win_wfp_uninit(const HANDLE msg_channel)
 {
-    dmsg (D_LOW, "Uninitializing WFP");
+    dmsg(D_LOW, "Uninitializing WFP");
 
     if (msg_channel)
-      {
-        msg (D_LOW, "Using service to delete block dns filters");
-        win_block_dns_service (false, -1, msg_channel);
-      }
+    {
+        msg(D_LOW, "Using service to delete block dns filters");
+        win_block_dns_service(false, -1, msg_channel);
+    }
     else
-      {
-        delete_block_dns_filters (m_hEngineHandle);
+    {
+        delete_block_dns_filters(m_hEngineHandle);
         m_hEngineHandle = NULL;
-      }
+    }
 
     return true;
 }
@@ -1208,7 +1364,7 @@ win32_version_info()
 {
     if (!IsWindowsXPOrGreater())
     {
-        msg (M_FATAL, "Error: Windows version must be XP or greater.");
+        msg(M_FATAL, "Error: Windows version must be XP or greater.");
     }
 
     if (!IsWindowsVistaOrGreater())
@@ -1235,13 +1391,13 @@ bool
 win32_is_64bit()
 {
 #if defined(_WIN64)
-    return true;  // 64-bit programs run only on Win64
+    return true;  /* 64-bit programs run only on Win64 */
 #elif defined(_WIN32)
-    // 32-bit programs run on both 32-bit and 64-bit Windows
+    /* 32-bit programs run on both 32-bit and 64-bit Windows */
     BOOL f64 = FALSE;
     return IsWow64Process(GetCurrentProcess(), &f64) && f64;
-#else
-    return false; // Win64 does not support Win16
+#else  /* if defined(_WIN64) */
+    return false; /* Win64 does not support Win16 */
 #endif
 }
 
@@ -1249,31 +1405,35 @@ const char *
 win32_version_string(struct gc_arena *gc, bool add_name)
 {
     int version = win32_version_info();
-    struct buffer out = alloc_buf_gc (256, gc);
+    struct buffer out = alloc_buf_gc(256, gc);
 
     switch (version)
     {
         case WIN_XP:
-            buf_printf (&out, "5.1%s", add_name ? " (Windows XP)" : "");
+            buf_printf(&out, "5.1%s", add_name ? " (Windows XP)" : "");
             break;
+
         case WIN_VISTA:
-            buf_printf (&out, "6.0%s", add_name ? " (Windows Vista)" : "");
+            buf_printf(&out, "6.0%s", add_name ? " (Windows Vista)" : "");
             break;
+
         case WIN_7:
-            buf_printf (&out, "6.1%s", add_name ? " (Windows 7)" : "");
+            buf_printf(&out, "6.1%s", add_name ? " (Windows 7)" : "");
             break;
+
         case WIN_8:
-            buf_printf (&out, "6.2%s", add_name ? " (Windows 8 or greater)" : "");
+            buf_printf(&out, "6.2%s", add_name ? " (Windows 8 or greater)" : "");
             break;
+
         default:
-            msg (M_NONFATAL, "Unknown Windows version: %d", version);
-            buf_printf (&out, "0.0%s", add_name ? " (unknown)" : "");
+            msg(M_NONFATAL, "Unknown Windows version: %d", version);
+            buf_printf(&out, "0.0%s", add_name ? " (unknown)" : "");
             break;
     }
 
-    buf_printf (&out, win32_is_64bit() ? " 64bit" : " 32bit");
+    buf_printf(&out, win32_is_64bit() ? " 64bit" : " 32bit");
 
     return (const char *)out.data;
 }
 
-#endif
+#endif /* ifdef _WIN32 */