mirror of git://git.gnupg.org/gnupg.git
1324 lines
31 KiB
C
1324 lines
31 KiB
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);
|
||
}
|