path: root/build-aux/speedo/w32/g4wihelp.c

/* g4wihelp.c - NSIS Helper DLL used with gpg4win.
 * Copyright (C) 2005, 2023 g10 Code GmbH
 * Copyright (C) 2001 Justin Frankel
 * Copyright (C) 2016, 2017 Intevation GmbH
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any
 * damages arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any
 * purpose, including commercial applications, and to alter it and
 * redistribute it freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must
 *    not claim that you wrote the original software. If you use this
 *    software in a product, an acknowledgment in the product
 *    documentation would be appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must
 *    not be misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source
 *    distribution.
 ************************************************************
 * The code for the splash screen has been taken from the Splash
 * plugin of the NSIS 2.04 distribution.  That code comes without
 * explicit copyright notices in tyhe source files or author names, it
 * seems that it has been written by Justin Frankel; not sure about
 * the year, though. [wk 2005-11-28]
 *
 * Fixed some compiler warnings. [wk 2014-02-24].
 * Merged code from GnuPG version.  [wk 2023-04-24].
 *
 * Compile time macros:
 *  ENABLE_SLIDE_SHOW :: Define for Gpg4win.
 */

#include <windows.h>
#include <stdio.h>
#include <tlhelp32.h>
#include <psapi.h>
#include <stdio.h>
#include <string.h>
#include "exdll.h"

/* We keep some code here for documentation reasons.  That code has not
 * yet been converted to the Unicode NSIS plugin API. */
/* #define ENABLE_SOUND_GADGET 1   */
/* #define ENABLE_SPLASH_GADGET 1   */
/* #define ENABLE_SERVICE_MANAGEMENT 1   */


static HINSTANCE g_hInstance; /* Our Instance. */
static HWND g_hwndParent;     /* Handle of parent window or NULL. */
static HBITMAP g_hbm;         /* Handle of the splash image. */
static int sleepint;          /* Milliseconds to show the spals image. */

#ifdef ENABLE_SLIDE_SHOW
void
slide_stop(HWND hwndParent, int string_size, TCHAR *variables, stack_t **stacktop);
#endif

/* Standard entry point for DLLs. */
int WINAPI
DllMain (HANDLE hinst, DWORD reason, LPVOID reserved)
{
   if (reason == DLL_PROCESS_ATTACH)
     g_hInstance = hinst;
   else if (reason == DLL_PROCESS_DETACH)
     {
#ifdef ENABLE_SLIDE_SHOW
       slide_stop (NULL, 0, NULL, NULL);
#endif
     }
   return TRUE;
}



/* Dummy function for testing. */
void __declspec(dllexport)
dummy (HWND hwndParent, int string_size, LPTSTR variables,
       stack_t **stacktop, extra_parameters_t *extra)
{
  g_hwndParent = hwndParent;

  EXDLL_INIT();

  // note if you want parameters from the stack, pop them off in order.
  // i.e. if you are called via exdll::myFunction file.dat poop.dat
  // calling popstring() the first time would give you file.dat,
  // and the second time would give you poop.dat.
  // you should empty the stack of your parameters, and ONLY your
  // parameters.

  /* Let's dump the variables.  */
  {
    char line[512];
    char *p;
    const unsigned char *s = (void*)g_variables;
    int i,j;

    for (i=0; i < string_size* __INST_LAST; i+=32, s += 32)
      {
        for (j=0; j < 32; j++)
          if (s[j])
            break;
        if (j != 32)
          {
            p = line;
            *p = 0;
            snprintf (p, 10, "%05x: ", i);
            p += strlen (p);
            for (j=0; j < 32; j++)
              {
                snprintf (p, 10, "%02x", s[j]);
                p += strlen (p);
              }
            strcat (p, " |");
            p += strlen (p);
            for (j=0; j < 32; j++)
              {
                if (s[j] >= 32 && s[j] < 127)
                  *p = s[j];
                else
                  *p = '.';
                p++;
              }
            strcat (p, "|");
            OutputDebugStringA (line);
          }
      }
  }


  {
    wchar_t buf[1024];

    swprintf(buf, 1024,
             L"stringsize=%d\r\n$0=%s\r\n$1=%s\r\n$R0=%s\r\n$R1=%s\r\n",
            string_size,
            getuservariable(INST_0),
            getuservariable(INST_1),
            getuservariable(INST_R0),
            getuservariable(INST_R1));
    MessageBoxW(g_hwndParent,buf,0,MB_OK);

    swprintf (buf, 1024,
             L"autoclose    =%d\r\n"
             "all_user_var =%d\r\n"
             "exec_error   =%d\r\n"
             "abort        =%d\r\n"
             "exec_reboot  =%d\r\n"
             "reboot_called=%d\r\n"
	     "api_version  =%d\r\n"
             "silent       =%d\r\n"
             "instdir_error=%d\r\n"
             "rtl          =%d\r\n"
             "errlvl       =%d\r\n",
             extra->exec_flags->autoclose,
             extra->exec_flags->all_user_var,
             extra->exec_flags->exec_error,
             extra->exec_flags->abort,
             extra->exec_flags->exec_reboot,
             extra->exec_flags->reboot_called,
             extra->exec_flags->plugin_api_version,
             extra->exec_flags->silent,
             extra->exec_flags->instdir_error,
             extra->exec_flags->rtl,
             extra->exec_flags->errlvl);
    MessageBoxW(g_hwndParent,buf,0,MB_OK);
  }
}



void __declspec(dllexport)
runonce (HWND hwndParent, int string_size, LPTSTR variables,
         stack_t **stacktop, extra_parameters_t *extra)
{
  LPCWSTR result;

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  CreateMutexW (NULL, 0, getuservariable(INST_R0));
  result = GetLastError ()? L"1" : L"0";
  setuservariable (INST_R0, result);
}



#ifdef ENABLE_SOUND_GADGET
void __declspec(dllexport)
playsound (HWND hwndParent, int string_size, char *variables,
           stack_t **stacktop, extra_parameters_t *extra)
{
  char fname[MAX_PATH];

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  if (popstring(fname, sizeof fname))
    return;
  PlaySound (fname, NULL, SND_ASYNC|SND_FILENAME|SND_NODEFAULT);
}


void __declspec(dllexport)
stopsound (HWND hwndParent, int string_size, char *variables,
           stack_t **stacktop, extra_parameters_t *extra)
{
  g_hwndParent = hwndParent;
  EXDLL_INIT();
  PlaySound (NULL, NULL, 0);
}
#endif /*ENABLE_SOUND_GADGET*/


#ifdef ENABLE_SPLASH_GADGET
/* Windows procedure to control the splashimage.  This one pauses the
   execution until the sleep time is over or the user closes this
   windows. */
static LRESULT CALLBACK
splash_wndproc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  LRESULT result = 0;

  switch (uMsg)
    {
    case WM_CREATE:
      {
        BITMAP bm;
        RECT vp;

        GetObject(g_hbm, sizeof(bm), (LPSTR)&bm);
        SystemParametersInfo(SPI_GETWORKAREA, 0, &vp, 0);
        SetWindowLong(hwnd,GWL_STYLE,0);
        SetWindowPos(hwnd,NULL,
                     vp.left+(vp.right-vp.left-bm.bmWidth)/2,
                     vp.top+(vp.bottom-vp.top-bm.bmHeight)/2,
                     bm.bmWidth,bm.bmHeight,
                     SWP_NOZORDER);
        ShowWindow(hwnd,SW_SHOW);
        SetTimer(hwnd,1,sleepint,NULL);
      }
      break;

    case WM_PAINT:
      {
        PAINTSTRUCT ps;
        RECT r;
        HDC curdc=BeginPaint(hwnd,&ps);
        HDC hdc=CreateCompatibleDC(curdc);
        HBITMAP oldbm;
        GetClientRect(hwnd,&r);
        oldbm=(HBITMAP)SelectObject(hdc,g_hbm);
        BitBlt(curdc,r.left,r.top,r.right-r.left,r.bottom-r.top,
               hdc,0,0,SRCCOPY);
        SelectObject(hdc,oldbm);
        DeleteDC(hdc);
        EndPaint(hwnd,&ps);
      }
      break;

    case WM_CLOSE:
      break;

    case WM_TIMER:
    case WM_LBUTTONDOWN:
      DestroyWindow(hwnd);
      /*(fall through)*/
    default:
      result =  DefWindowProc (hwnd, uMsg, wParam, lParam);
    }

  return result;
}


/* Display a splash screen.  Call as

     g4wihelp::showsplash SLEEP FNAME

   With SLEEP being the time in milliseconds to show the splashscreen
   and FNAME the complete filename of the image.  As of now only BMP
   is supported.
*/
void __declspec(dllexport)
showsplash (HWND hwndParent, int string_size, char *variables,
           stack_t **stacktop, extra_parameters_t *extra)
{
  static WNDCLASS wc;
  char sleepstr[30];
  char fname[MAX_PATH];
  int err = 0;
  char *p;
  char classname[] = "_sp";

  g_hwndParent = hwndParent;
  EXDLL_INIT();
  if (popstring(sleepstr, sizeof sleepstr))
    err = 1;
  if (popstring(fname, sizeof fname))
    err = 1;
  if (err)
    return;

  if (!*fname)
    return; /* Nothing to do. */

  for (sleepint=0, p=sleepstr; *p >= '0' && *p <= '9'; p++)
    {
      sleepint *= 10;
      sleepint += *p - '0';
    }
  if (sleepint <= 0)
    return; /* Nothing to do. */

  wc.lpfnWndProc = splash_wndproc;
  wc.hInstance = g_hInstance;
  wc.hCursor = LoadCursor(NULL,IDC_ARROW);
  wc.lpszClassName = classname;
  if (!RegisterClass(&wc))
    return; /* Error. */

  g_hbm = LoadImage (NULL, fname, IMAGE_BITMAP,
                     0, 0 , LR_CREATEDIBSECTION|LR_LOADFROMFILE);
  if (g_hbm)
    {
      MSG msg;
      HWND hwnd;

      hwnd = CreateWindowEx (WS_EX_TOOLWINDOW, classname, classname,
                             0, 0, 0, 0, 0, (HWND)hwndParent, NULL,
                             g_hInstance, NULL);

      while (IsWindow(hwnd) && GetMessage ( &msg, hwnd, 0, 0))
        {
          DispatchMessage (&msg);
        }

      DeleteObject (g_hbm);
      g_hbm = NULL;
    }
  UnregisterClass (classname, g_hInstance);
}
#endif /*ENABLE_SPLASH_GADGET*/


#ifdef ENABLE_SERVICE_MANAGEMENT
/* Use this to report unexpected errors.  FIXME: This is really not
   very descriptive.  */
void
service_error (const char *str)
{
  char buf[1024];
  snprintf (buf, sizeof (buf), "error: %s: ec=%d\r\n", str,
	    GetLastError ());
  MessageBox(g_hwndParent, buf, 0, MB_OK);

  setuservariable (INST_R0, "1");
}


void __declspec(dllexport)
service_create (HWND hwndParent, int string_size, char *variables,
		 stack_t **stacktop, extra_parameters_t *extra)
{
  SC_HANDLE sc;
  SC_HANDLE service;
  const char *result = NULL;
  char service_name[256];
  char display_name[256];
  char program[256];
  int err = 0;

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  /* The expected stack layout: service_name, display_name, program.  */
  if (popstring (service_name, sizeof (service_name)))
    err = 1;
  if (!err && popstring (display_name, sizeof (display_name)))
    err = 1;
  if (!err && popstring (program, sizeof (program)))
    err = 1;
  if (err)
    {
      setuservariable (INST_R0, "1");
      return;
    }

  sc = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);
  if (sc == NULL)
    {
      service_error ("OpenSCManager");
      return;
    }

  service = CreateService (sc, service_name, display_name,
			   SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
			   /* Use SERVICE_DEMAND_START for testing.
			      FIXME: Currently not configurable by caller.  */
			   SERVICE_AUTO_START,
			   SERVICE_ERROR_NORMAL, program,
			   NULL, NULL, NULL,
			   /* FIXME: Currently not configurable by caller.  */
			   /* FIXME: LocalService or NetworkService
			      don't work for dirmngr right now.  NOTE!
			      If you change it here, you also should
			      adjust make-msi.pl for the msi
			      installer.  In the future, this should
			      be an argument to the function and then
			      the make-msi.pl script can extract it
			      from the invocation.  */
			   NULL /* "NT AUTHORITY\\LocalService" */,
			   NULL);
  if (service == NULL)
    {
      service_error ("CreateService");
      CloseServiceHandle (sc);
      return;
    }
  CloseServiceHandle (service);

  result = GetLastError () ? "1":"0";
  setuservariable (INST_R0, result);
  return;
}


/* Requires g_hwndParent to be set!  */
SC_HANDLE
service_lookup (char *service_name)
{
  SC_HANDLE sc;
  SC_HANDLE service;

  sc = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);
  if (sc == NULL)
    {
      service_error ("OpenSCManager");
      return NULL;
    }
  service = OpenService (sc, service_name, SC_MANAGER_ALL_ACCESS);
  if (service == NULL)
    {
      /* Fail silently here.  */
      CloseServiceHandle (sc);
      return NULL;
    }
  CloseServiceHandle (sc);
  return service;
}


/* Returns status.  */
void __declspec(dllexport)
service_query (HWND hwndParent, int string_size, char *variables,
	       stack_t **stacktop, extra_parameters_t *extra)
{
  SC_HANDLE service;
  const char *result = NULL;
  char service_name[256];
  int err = 0;
  SERVICE_STATUS status;

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  /* The expected stack layout: service_name argc [argv].  */
  if (popstring (service_name, sizeof (service_name)))
    err = 1;
  if (err)
    {
      setuservariable (INST_R0, "ERROR");
      return;
    }

  service = service_lookup (service_name);
  if (service == NULL)
  if (err == 0)
    {
      setuservariable (INST_R0, "MISSING");
      return;
    }

  err = QueryServiceStatus (service, &status);
  if (err == 0)
    {
      setuservariable (INST_R0, "ERROR");
      CloseServiceHandle (service);
      return;
    }
  CloseServiceHandle (service);

  switch (status.dwCurrentState)
    {
    case SERVICE_START_PENDING:
      result = "START_PENDING";
      break;
    case SERVICE_RUNNING:
      result = "RUNNING";
      break;
    case SERVICE_PAUSE_PENDING:
      result = "PAUSE_PENDING";
      break;
    case SERVICE_PAUSED:
      result = "PAUSED";
      break;
    case SERVICE_CONTINUE_PENDING:
      result = "CONTINUE_PENDING";
      break;
    case SERVICE_STOP_PENDING:
      result = "STOP_PENDING";
      break;
    case SERVICE_STOPPED:
      result = "STOPPED";
      break;
    default:
      result = "UNKNOWN";
    }
  setuservariable (INST_R0, result);
  return;
}


void __declspec(dllexport)
service_start (HWND hwndParent, int string_size, char *variables,
	       stack_t **stacktop, extra_parameters_t *extra)
{
  SC_HANDLE service;
  const char *result = NULL;
  char service_name[256];
  char argc_str[256];
#define NR_ARGS 10
#define ARG_MAX 256
  char argv_str[NR_ARGS][ARG_MAX];
  const char *argv[NR_ARGS + 1];
  int argc;
  int i;
  int err = 0;

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  /* The expected stack layout: service_name argc [argv].  */
  if (popstring (service_name, sizeof (service_name)))
    err = 1;
  if (!err && popstring (argc_str, sizeof (argc_str)))
    err = 1;
  if (!err)
    {
      argc = atoi (argc_str);
      for (i = 0; i < argc; i++)
	{
	  if (popstring (argv_str[i], ARG_MAX))
	    {
	      err = 1;
	      break;
	    }
	  argv[i] = argv_str[i];
	}
      argv[i] = NULL;
    }
  if (err)
    {
      setuservariable (INST_R0, "1");
      return;
    }

  service = service_lookup (service_name);
  if (service == NULL)
    return;

  err = StartService (service, argc, argc == 0 ? NULL : argv);
  if (err == 0)
    {
      service_error ("StartService");
      CloseServiceHandle (service);
      return;
    }
  CloseServiceHandle (service);

  setuservariable (INST_R0, "0");
  return;
}


void __declspec(dllexport)
service_stop (HWND hwndParent, int string_size, char *variables,
	      stack_t **stacktop, extra_parameters_t *extra)
{
  SC_HANDLE service;
  const char *result = NULL;
  char service_name[256];
  int err = 0;
  SERVICE_STATUS status;
  DWORD timeout = 10000;	/* 10 seconds.  */
  DWORD start_time;

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  /* The expected stack layout: service_name argc [argv].  */
  if (popstring (service_name, sizeof (service_name)))
    err = 1;
  if (err)
    {
      setuservariable (INST_R0, "1");
      return;
    }

  service = service_lookup (service_name);
  if (service == NULL)
    return;

  err = QueryServiceStatus (service, &status);
  if (err == 0)
    {
      service_error ("QueryService");
      CloseServiceHandle (service);
      return;
    }

  if (status.dwCurrentState != SERVICE_STOPPED
      && status.dwCurrentState != SERVICE_STOP_PENDING)
    {
      err = ControlService (service, SERVICE_CONTROL_STOP, &status);
      if (err == 0)
	{
	  service_error ("ControlService");
	  CloseServiceHandle (service);
	  return;
	}
    }

  start_time = GetTickCount ();
  while (status.dwCurrentState != SERVICE_STOPPED)
    {
      Sleep (1000);	/* One second.  */
      if (!QueryServiceStatus (service, &status))
	{
	  service_error ("QueryService");
	  CloseServiceHandle (service);
	  return;
	}
      if (status.dwCurrentState == SERVICE_STOPPED)
	break;

      if (GetTickCount () - start_time > timeout)
	{
	  char buf[1024];
	  snprintf (buf, sizeof (buf),
		    "time out waiting for service %s to stop\r\n",
		    service_name);
	  MessageBox (g_hwndParent, buf, 0, MB_OK);
	  setuservariable (INST_R0, "1");
	  return;
	}
    }
  CloseServiceHandle (service);
  setuservariable (INST_R0, "0");
  return;
}


void __declspec(dllexport)
service_delete (HWND hwndParent, int string_size, char *variables,
		stack_t **stacktop, extra_parameters_t *extra)
{
  SC_HANDLE service;
  const char *result = NULL;
  char service_name[256];
  int err = 0;

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  /* The expected stack layout: service_name argc [argv].  */
  if (popstring (service_name, sizeof (service_name)))
    err = 1;
  if (err)
    {
      setuservariable (INST_R0, "1");
      return;
    }

  service = service_lookup (service_name);
  if (service == NULL)
    return;

  err = DeleteService (service);
  if (err == 0)
    {
      service_error ("DeleteService");
      CloseServiceHandle (service);
      return;
    }
  CloseServiceHandle (service);

  setuservariable (INST_R0, "0");
  return;
}
#endif /*ENABLE_SERVICE_MANAGEMENT*/


/* Extract config file parameters.  FIXME: Not particularly robust.
   We expect some reasonable formatting.  The parser below is very
   limited.  It expects a command line option /c=FILE or /C=FILE,
   where FILE must be enclosed in double-quotes if it contains spaces.
   That file should contain a single section [gpg4win] and KEY=VALUE
   pairs for each additional configuration file to install.  Comments
   are supported only on lines by themselves.  VALUE can be quoted in
   double-quotes, but does not need to be, unless it has whitespace at
   the beginning or end.  KEY can, for example, be "gpg.conf" (without
   the quotes).  */
void
config_init (char **keys, char **values, int max)
{
  /* First, parse the command line.  */
  LPCWSTR wcmdline;
  char *cmdline;
  char *begin = NULL;
  char *end = NULL;
  char mark;
  char *fname;
  char *ptr;
  FILE *conf;

  *keys = NULL;
  *values = NULL;

  cmdline = malloc (4096);
  if (!cmdline)
    return;

  wcmdline = getuservariable (INST_CMDLINE);
  *cmdline = 0;
  WideCharToMultiByte(CP_ACP, 0, wcmdline, -1, cmdline, 4095, NULL, NULL);
  if (!*cmdline)
    return;

  mark = (*cmdline == '"') ? (cmdline++, '"') : ' ';
  while (*cmdline && *cmdline != mark)
    cmdline++;
  if (mark == '"' && *cmdline)
    cmdline++;
  while (*cmdline && *cmdline == ' ')
    cmdline++;

  while (*cmdline)
    {
      /* We are at the beginning of a new argument.  */
      if (cmdline[0] == '/' && (cmdline[1] == 'C' || cmdline[1] == 'c')
	  && cmdline[2] == '=')
	{
	  cmdline += 3;
	  begin = cmdline;
	}

      while (*cmdline && *cmdline != ' ')
	{
	  /* Skip over quoted parts.  */
	  if (*cmdline == '"')
	    {
	      cmdline++;
	      while (*cmdline && *cmdline != '"')
		cmdline++;
	      if (*cmdline)
		cmdline++;
	    }
	  else
	    cmdline++;
	}
      if (begin && !end)
	{
	  end = cmdline - 1;
	  break;
	}
      while (*cmdline && *cmdline == ' ')
	cmdline++;
    }

  if (!begin || begin > end)
    return;

  /* Strip quotes.  */
  if (*begin == '"' && *end == '"')
    {
      begin++;
      end--;
    }
  if (begin > end)
    return;

  fname = malloc (end - begin + 2);
  if (!fname)
    return;

  ptr = fname;
  while (begin <= end)
    *(ptr++) = *(begin++);
  *ptr = '\0';

  conf = fopen (fname, "r");
  free (fname);
  free (cmdline);
  if (!conf)
    return;

  while (max - 1 > 0)
    {
      char line[256];
      char *ptr2;

      if (fgets (line, sizeof (line), conf) == NULL)
	break;
      ptr = &line[strlen (line)];
      while (ptr > line && (ptr[-1] == '\n' || ptr[-1] == '\r'
			    || ptr[-1] == ' ' || ptr[-1] == '\t'))
	ptr--;
      *ptr = '\0';

      ptr = line;
      while (*ptr && (*ptr == ' ' || *ptr == '\t'))
	ptr++;
      /* Ignore comment lines.  */
      /* FIXME: Ignore section markers.  */
      if (*ptr == '\0' || *ptr == ';' || *ptr == '[')
	continue;
      begin = ptr;
      while (*ptr && *ptr != '=' && *ptr != ' ' && *ptr != '\t')
	ptr++;
      end = ptr - 1;
      while (*ptr && (*ptr == ' ' || *ptr == '\t'))
	ptr++;
      if (*ptr != '=')
	continue;
      ptr++;

      if (begin > end)
	continue;

      /* We found a key.  */
      *keys = malloc (end - begin + 2);
      if (!keys)
	return;
      ptr2 = *keys;
      while (begin <= end)
	*(ptr2++) = *(begin++);
      *ptr2 = '\0';

      *values = NULL;

      while (*ptr && (*ptr == ' ' || *ptr == '\t'))
	ptr++;
      begin = ptr;
      /* In this case, end points to the byte after the value, which
	 is OK because that is '\0'.  */
      end = &line[strlen (line)];
      if (begin > end)
	begin = end;

      /* Strip quotes.  */
      if (*begin == '"' && end[-1] == '"')
	{
	  begin++;
	  end--;
	  *end = '\0';
	}
      if (begin > end)
	return;

      *values = malloc (end - begin + 1);
      ptr2 = *values;
      while (begin <= end)
	*(ptr2++) = *(begin++);

      keys++;
      values++;
      max--;
    }

  fclose (conf);
  *keys = NULL;
  *values = NULL;
}


char *
config_lookup (char *key)
{
#define MAX_KEYS 128
  static int initialised = 0;
  static char *keys[MAX_KEYS];
  static char *values[MAX_KEYS];
  int i;

  if (initialised == 0)
    {
      initialised = 1;
      config_init (keys, values, MAX_KEYS);

#if 0
      MessageBox(g_hwndParent, "Configuration File:", 0, MB_OK);
      i = 0;
      while (keys[i])
	{
	  char buf[256];
	  sprintf (buf, "%s=%s\r\n", keys[i], values[i]);
	  MessageBox (g_hwndParent, buf, 0, MB_OK);
	  i++;
	}
#endif
    }

  i = 0;
  while (keys[i])
    {
      if (!strcmp (keys[i], key))
	return values[i];
      i++;
    }

  return NULL;
}


void __declspec(dllexport)
config_fetch (HWND hwndParent, int string_size, LPTSTR variables,
	      stack_t **stacktop, extra_parameters_t *extra)
{
  char key[256];
  int err = 0;
  char *value;

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  /* The expected stack layout: key.  */
  if (PopStringNA (key, sizeof (key)))
    err = 1;
  if (err)
    {
      setuservariable (INST_R0, L"");
      return;
    }

  value = config_lookup (key);

  SetUserVariableA (INST_R0, value == NULL ? "" : value);
  return;
}


void __declspec(dllexport)
config_fetch_bool (HWND hwndParent, int string_size, LPTSTR variables,
		   stack_t **stacktop, extra_parameters_t *extra)
{
  char key[256];
  int err = 0;
  char *value;
  int result;

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  /* The expected stack layout: key.  */
  if (PopStringNA (key, sizeof (key)))
    err = 1;
  if (err)
    {
      setuservariable (INST_R0, L"");
      return;
    }

  value = config_lookup (key);
  if (value == NULL || *value == '\0')
    {
      setuservariable (INST_R0, L"");
      return;
    }

  result = 0;
  if (!strcasecmp (value, "true")
      || !strcasecmp (value, "yes")
      || atoi (value) != 0)
    result = 1;

  SetUserVariableA (INST_R0, result == 0 ? "0" : "1");
  return;
}


/* Return a string from the Win32 Registry or NULL in case of error.
   Caller must release the return value.  A NULL for root is an alias
   for HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE in turn.  */
static wchar_t *
read_w32_registry_string (HKEY root, const wchar_t *dir, const wchar_t *name)
{
  HKEY root_key;
  HKEY key_handle;
  DWORD n1, nbytes, type;
  wchar_t *result = NULL;

  root_key = root;
  if (!root_key)
    root_key = HKEY_CURRENT_USER;

  if (RegOpenKeyExW (root_key, dir, 0, KEY_READ, &key_handle))
    {
      if (root)
	return NULL; /* no need for a RegClose, so return direct */
      /* It seems to be common practise to fall back to HKLM. */
      if (RegOpenKeyExW (HKEY_LOCAL_MACHINE, dir, 0, KEY_READ, &key_handle))
	return NULL; /* still no need for a RegClose, so return direct */
    }

  nbytes = 1;
  if (RegQueryValueExW (key_handle, name, 0, NULL, NULL, &nbytes))
    {
      if (root)
        goto leave;
      /* Try to fallback to HKLM also for a missing value.  */
      RegCloseKey (key_handle);
      if (RegOpenKeyExW (HKEY_LOCAL_MACHINE, dir, 0, KEY_READ, &key_handle))
        return NULL; /* Nope.  */
      if (RegQueryValueExW (key_handle, name, 0, NULL, NULL, &nbytes))
        goto leave;
  }

  result = calloc ((n1=nbytes+1), sizeof *result);
  if (!result)
    goto leave;

  if (RegQueryValueExW (key_handle, name, 0, &type,
                        (unsigned char *)result, &n1))
    {
      free (result);
      result = NULL;
      goto leave;
    }
  result[nbytes] = 0; /* Make sure it is really a string  */

 leave:
  RegCloseKey (key_handle);
  return result;
}


/* Registry keys for PATH for HKLM and HKCU.  */
#define ENV_HK HKEY_LOCAL_MACHINE
#define ENV_REG     L"SYSTEM\\CurrentControlSet\\Control\\" \
                           "Session Manager\\Environment"
#define ENV_HK_USER HKEY_CURRENT_USER
#define ENV_REG_USER L"Environment"

/* Due to a bug in Windows7 (kb 2685893) we better put a lower limit
 * than 8191 on the maximum length of the PATH variable.  Note, that
 * depending on the used toolchain we used to had a 259 byte limit in
 * the past.
 * [wk 2023-04-24]: Can this be lifted now that we use the wchar_t API?
 */
#define PATH_LENGTH_LIMIT 2047

void __declspec(dllexport)
path_add (HWND hwndParent, int string_size, LPTSTR variables,
	  stack_t **stacktop, extra_parameters_t *extra)
{
  wchar_t dir[PATH_LENGTH_LIMIT];
  wchar_t is_user_install[2];
  wchar_t *path;
  wchar_t *path_new;
  size_t path_new_size;
  wchar_t *comp;
  const wchar_t delims[] = L";";
  int is_user;
  HKEY key_handle = 0;
  HKEY root_key;
  const wchar_t *env_reg;
  /* wchar_t *tokctx;     Context var for wcstok - not yet needed.  */

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  setuservariable (INST_R0, L"0");  /* Default return value.  */

  /* The expected stack layout: path component.  */
  if (popstringn (dir, COUNTOF (dir)))
    return;
  dir[COUNTOF(dir)-1] = 0;

  /* The expected stack layout: HKEY component.  */
  if (popstringn (is_user_install, COUNTOF (is_user_install)))
    return;
  is_user_install[COUNTOF(is_user_install)-1] = 0;

  if (!wcscmp (is_user_install, L"1"))
    {
      root_key = ENV_HK_USER;
      env_reg = ENV_REG_USER;
    }
  else
    {
      root_key = ENV_HK;
      env_reg = ENV_REG;
    }

  path = read_w32_registry_string (root_key, env_reg, L"Path");
  if (!path)
    {
      path = wcsdup (L"");
    }

  /* Old path plus semicolon plus dir plus terminating nul.  */
  path_new_size = wcslen (path) + 1 + wcslen (dir) + 1;
  if (path_new_size > PATH_LENGTH_LIMIT)
    {
      MessageBox (g_hwndParent, L"PATH env variable too big", 0, MB_OK);
      free (path);
      return;
    }

  path_new = calloc (path_new_size, sizeof *path_new);
  if (!path_new)
    {
      free (path);
      return;
    }

  wcscpy (path_new, path);
  wcscat (path_new, L";");
  wcscat (path_new, dir);

  /* Check if the directory already exists in the path.  */
  comp = wcstok (path, delims/*, &tokctx*/);
  do
    {
      /*       MessageBox (g_hwndParent, comp, 0, MB_OK); */
      if (!comp)
        break;

      if (!wcscmp (comp, dir))
	{
	  free (path);
	  free (path_new);
	  return;
	}
      comp = wcstok (NULL, delims/*, &tokctx*/);
    }
  while (comp);
  free (path);

  /* Update the path key.  */
  RegCreateKeyW (root_key, env_reg, &key_handle);
  RegSetValueEx (key_handle, L"Path", 0, REG_EXPAND_SZ,
		 (unsigned char*)path_new,
                 wcslen (path_new) * sizeof *path_new);
  RegCloseKey (key_handle);
  SetEnvironmentVariableW(L"PATH", path_new);
  free (path_new);

/*   MessageBox (g_hwndParent, "XXX 9", 0, MB_OK); */

  setuservariable (INST_R0, L"1");  /* success.  */
}


void __declspec(dllexport)
path_remove (HWND hwndParent, int string_size, LPTSTR variables,
	     stack_t **stacktop, extra_parameters_t *extra)
{
  wchar_t dir[PATH_LENGTH_LIMIT];
  wchar_t is_user_install[2];
  wchar_t *path;
  wchar_t *path_new;
  size_t path_new_size;
  wchar_t *comp;
  const wchar_t delims[] = L";";
  HKEY key_handle = 0;
  int changed = 0;
  int count = 0;
  HKEY root_key;
  const wchar_t *env_reg;
  /* wchar_t *tokctx;     Context var for wcstok - not yet needed.  */

  g_hwndParent = hwndParent;
  EXDLL_INIT();

  setuservariable (INST_R0, L"0");

  /* The expected stack layout: path component.  */
  if (popstringn (dir, COUNTOF (dir)))
    return;
  dir[COUNTOF(dir)-1] = 0;

  /* The expected stack layout: HKEY component.  */
  if (popstringn (is_user_install, COUNTOF (is_user_install)))
    return;
  is_user_install[COUNTOF(is_user_install)-1] = 0;

  if (!wcscmp (is_user_install, L"1"))
    {
      root_key = ENV_HK_USER;
      env_reg = ENV_REG_USER;
    }
  else
    {
      root_key = ENV_HK;
      env_reg = ENV_REG;
    }

  path = read_w32_registry_string (root_key, env_reg, L"Path");
  if (!path)
    return;

  /* Old path plus semicolon plus dir plus terminating nul.  */
  path_new_size = wcslen (path) + 1;
  path_new = calloc (path_new_size, sizeof *path_new);
  if (!path_new)
    {
      free (path);
      return;
    }

  /* Compose the new path.  */
  comp = wcstok (path, delims/*, &tokctx*/);
  do
    {
      if (wcscmp (comp, dir))
	{
	  if (count)
	    wcscat (path_new, L";");
	  wcscat (path_new, comp);
	  count++;
	}
      else
	changed = 1;
    }
  while ((comp = wcstok (NULL, delims/*, &tokctx*/)));
  free (path);

  if (!changed)
    {
      free (path_new);
      return;
    }

  /* Set a key for our CLSID.  */
  RegCreateKeyW (root_key, env_reg, &key_handle);
  RegSetValueEx (key_handle, L"Path", 0, REG_EXPAND_SZ,
		 (unsigned char*)path_new,
                 wcslen (path_new) * sizeof *path_new);
  RegCloseKey (key_handle);
  free (path_new);

  setuservariable (INST_R0, L"1");  /* success */
}


/** @brief Kill processes with the name name.
 *
 * This function tries to kill a process using ExitProcess.
 *
 * If it does not work it does not work. No return values.
 * The intention is to make an effort to kill something during
 * installation / uninstallation.
 *
 * The function signature is explained by NSIS.
 */
void __declspec(dllexport) __cdecl KillProc(HWND hwndParent,
                                            int string_size,
                                            char *variables,
                                            stack_t **stacktop)
{
  HANDLE h;
  PROCESSENTRY32 pe32;

  if (!stacktop || !*stacktop || !(*stacktop)->text)
    {
      ERRORPRINTF ("Invalid call to KillProc.");
      return;
    }


  h = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
  if (h == INVALID_HANDLE_VALUE)
    {
      ERRORPRINTF ("Failed to create Toolhelp snapshot");
      return;
    }
  pe32.dwSize = sizeof (PROCESSENTRY32);

  if (!Process32First (h, &pe32))
    {
      ERRORPRINTF ("Failed to get first process");
      CloseHandle (h);
      return;
    }

  do
    {
      if (!wcscmp ((*stacktop)->text, pe32.szExeFile))
        {
          HANDLE hProc = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
                                      pe32.th32ProcessID);
          if (!hProc)
            {
              ERRORPRINTF ("Failed to open process handle.");
              continue;
            }
          if (!TerminateProcess (hProc, 1))
            {
              ERRORPRINTF ("Failed to terminate process.");
            }
          CloseHandle (hProc);
        }
    }
  while (Process32Next (h, &pe32));
  CloseHandle (h);
}