/* w32-ce.h
Copyright (C) 2010 g10 Code GmbH
Copyright (C) 1991,92,97,2000,02 Free Software Foundation, Inc.
This file is part of GPGME.
GPGME is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of
the License, or (at your option) any later version.
GPGME is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this program; if not, see <https://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <gpg-error.h>
#define _WIN32_IE 0x0400 /* Required for SHGetSpecialFolderPathW. */
/* We need to include the windows stuff here prior to shlobj.h so that
we get the right winsock version. This is usually done in w32-ce.h
but that header also redefines some Windows functions which we need
to avoid unless having included shlobj.h. */
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <shlobj.h>
#include "w32-ce.h"
/* Return a malloced string encoded in UTF-8 from the wide char input
string STRING. Caller must free this value. Returns NULL and sets
ERRNO on failure. Calling this function with STRING set to NULL is
not defined. */
char *
wchar_to_utf8 (const wchar_t *string)
{
int n;
char *result;
n = WideCharToMultiByte (CP_UTF8, 0, string, -1, NULL, 0, NULL, NULL);
if (n < 0)
{
gpg_err_set_errno (EINVAL);
return NULL;
}
result = malloc (n+1);
if (!result)
return NULL;
n = WideCharToMultiByte (CP_UTF8, 0, string, -1, result, n, NULL, NULL);
if (n < 0)
{
free (result);
gpg_err_set_errno (EINVAL);
result = NULL;
}
return result;
}
/* Return a malloced wide char string from an UTF-8 encoded input
string STRING. Caller must free this value. Returns NULL and sets
ERRNO on failure. Calling this function with STRING set to NULL is
not defined. */
wchar_t *
utf8_to_wchar (const char *string)
{
int n;
size_t nbytes;
wchar_t *result;
n = MultiByteToWideChar (CP_UTF8, 0, string, -1, NULL, 0);
if (n < 0)
{
gpg_err_set_errno (EINVAL);
return NULL;
}
nbytes = (size_t)(n+1) * sizeof(*result);
if (nbytes / sizeof(*result) != (n+1))
{
gpg_err_set_errno (ENOMEM);
return NULL;
}
result = malloc (nbytes);
if (!result)
return NULL;
n = MultiByteToWideChar (CP_UTF8, 0, string, -1, result, n);
if (n < 0)
{
free (result);
gpg_err_set_errno (EINVAL);
result = NULL;
}
return result;
}
#define MAX_ENV 30
char *environ[MAX_ENV + 1];
char *
getenv (const char *name)
{
static char *past_result;
char **envp;
if (past_result)
{
free (past_result);
past_result = NULL;
}
#if 0
if (! strcmp (name, "DBUS_VERBOSE"))
return past_result = get_verbose_setting ();
else if (! strcmp (name, "HOMEPATH"))
return past_result = find_my_documents_folder ();
else if (! strcmp (name, "DBUS_DATADIR"))
return past_result = find_inst_subdir ("share");
#endif
for (envp = environ; *envp != 0; envp++)
{
const char *varp = name;
char *ep = *envp;
while (*varp == *ep && *varp != '\0')
{
++ep;
++varp;
};
if (*varp == '\0' && *ep == '=')
return ep + 1;
}
return NULL;
}
void
GetSystemTimeAsFileTime (LPFILETIME ftp)
{
SYSTEMTIME st;
GetSystemTime (&st);
SystemTimeToFileTime (&st, ftp);
}
BOOL
DeleteFileA (LPCSTR lpFileName)
{
wchar_t *filename;
BOOL result;
int err;
filename = utf8_to_wchar (lpFileName);
if (!filename)
return FALSE;
result = DeleteFileW (filename);
err = GetLastError ();
free (filename);
SetLastError (err);
return result;
}
HANDLE
CreateFileA (LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSharedMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile)
{
wchar_t *filename;
HANDLE result;
int err;
filename = utf8_to_wchar (lpFileName);
if (!filename)
return INVALID_HANDLE_VALUE;
result = CreateFileW (filename, dwDesiredAccess, dwSharedMode,
lpSecurityAttributes, dwCreationDisposition,
dwFlagsAndAttributes, hTemplateFile);
err = GetLastError ();
free (filename);
SetLastError (err);
return result;
}
BOOL
CreateProcessA (LPCSTR pszImageName, LPSTR pszCmdLine,
LPSECURITY_ATTRIBUTES psaProcess,
LPSECURITY_ATTRIBUTES psaThread, BOOL fInheritHandles,
DWORD fdwCreate, PVOID pvEnvironment, LPCSTR pszCurDir,
LPSTARTUPINFOA psiStartInfo,
LPPROCESS_INFORMATION pProcInfo)
{
wchar_t *image_name = NULL;
wchar_t *cmd_line = NULL;
BOOL result;
int err;
assert (psaProcess == NULL);
assert (psaThread == NULL);
assert (fInheritHandles == FALSE);
assert (pvEnvironment == NULL);
assert (pszCurDir == NULL);
/* psiStartInfo is generally not NULL. */
if (pszImageName)
{
image_name = utf8_to_wchar (pszImageName);
if (!image_name)
return 0;
}
if (pszCmdLine)
{
cmd_line = utf8_to_wchar (pszCmdLine);
if (!cmd_line)
{
if (image_name)
free (image_name);
return 0;
}
}
result = CreateProcessW (image_name, cmd_line, NULL, NULL, FALSE,
fdwCreate, NULL, NULL, NULL, pProcInfo);
err = GetLastError ();
free (image_name);
free (cmd_line);
SetLastError (err);
return result;
}
LONG
RegOpenKeyExA (HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions,
REGSAM samDesired, PHKEY phkResult)
{
wchar_t *subkey;
LONG result;
int err;
if (lpSubKey)
{
subkey = utf8_to_wchar (lpSubKey);
if (!subkey)
return 0;
}
else
subkey = NULL;
result = RegOpenKeyEx (hKey, subkey, ulOptions, samDesired, phkResult);
err = GetLastError ();
free (subkey);
SetLastError (err);
return result;
}
LONG WINAPI
RegQueryValueExA (HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved,
LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData)
{
wchar_t *name;
LONG err;
void *data;
DWORD data_len;
DWORD type;
if (lpValueName)
{
name = utf8_to_wchar (lpValueName);
if (!name)
return GetLastError ();
}
else
name = NULL;
data_len = 0;
err = RegQueryValueExW (hKey, name, lpReserved, lpType, NULL, &data_len);
if (err || !lpcbData)
{
free (name);
return err;
}
data = malloc (data_len + sizeof (wchar_t));
if (!data)
{
free (name);
return ERROR_NOT_ENOUGH_MEMORY;
}
err = RegQueryValueExW (hKey, name, lpReserved, &type, data, &data_len);
if (lpType)
*lpType = type;
free (name);
/* If err is ERROR_MORE_DATA, there probably was a race condition.
We can punt this to the caller just as well. */
if (err)
return err;
/* NOTE: REG_MULTI_SZ and REG_EXPAND_SZ not supported, because they
are not needed in this module. */
if (type == REG_SZ)
{
char *data_c;
int data_c_len;
/* This is valid since we allocated one more above. */
((char*)data)[data_len] = '\0';
((char*)data)[data_len + 1] = '\0';
data_c = wchar_to_utf8 ((wchar_t*) data);
if (!data_c)
return GetLastError();
data_c_len = strlen (data_c) + 1;
assert (data_c_len <= data_len + sizeof (wchar_t));
memcpy (data, data_c, data_c_len);
data_len = data_c_len;
free (data_c);
}
/* DATA and DATA_LEN now contain the result. */
if (lpData)
{
if (data_len > *lpcbData)
err = ERROR_MORE_DATA;
else
memcpy (lpData, data, data_len);
}
*lpcbData = data_len;
return err;
}
DWORD
GetTempPathA (DWORD nBufferLength, LPSTR lpBuffer)
{
wchar_t dummy[1];
DWORD len;
len = GetTempPathW (0, dummy);
if (len == 0)
return 0;
assert (len <= MAX_PATH);
/* Better be safe than sorry. MSDN doesn't say if len is with or
without terminating 0. */
len++;
{
wchar_t *buffer_w;
DWORD len_w;
char *buffer_c;
DWORD len_c;
buffer_w = malloc (sizeof (wchar_t) * len);
if (! buffer_w)
return 0;
len_w = GetTempPathW (len, buffer_w);
/* Give up if we still can't get at it. */
if (len_w == 0 || len_w >= len)
{
free (buffer_w);
return 0;
}
/* Better be really safe. */
buffer_w[len_w] = '\0';
buffer_c = wchar_to_utf8 (buffer_w);
free (buffer_w);
if (! buffer_c)
return 0;
/* strlen is correct (not _mbstrlen), because we want storage and
not string length. */
len_c = strlen (buffer_c) + 1;
if (len_c > nBufferLength)
return len_c;
strcpy (lpBuffer, buffer_c);
free (buffer_c);
return len_c - 1;
}
}
/* The symbol is named SHGetSpecialFolderPath and not
SHGetSpecialFolderPathW but shlobj.h from cegcc redefines it to *W
which is a bug. Work around it. */
#ifdef __MINGW32CE__
# undef SHGetSpecialFolderPath
#endif
BOOL
SHGetSpecialFolderPathA (HWND hwndOwner, LPSTR lpszPath, int nFolder,
BOOL fCreate)
{
wchar_t path[MAX_PATH];
char *path_c;
BOOL result;
path[0] = (wchar_t) 0;
result = SHGetSpecialFolderPath (hwndOwner, path, nFolder, fCreate);
/* Note: May return false even if succeeds. */
path[MAX_PATH - 1] = (wchar_t) 0;
path_c = wchar_to_utf8 (path);
if (! path_c)
return 0;
strncpy (lpszPath, path_c, MAX_PATH);
free (path_c);
lpszPath[MAX_PATH - 1] = '\0';
return result;
}
/* Replacement for the access function. Note that we can't use fopen
here because wince might now allow to have a shared read for an
executable; it is better to to read the file attributes.
Limitation: Only F_OK is supported.
*/
int
_gpgme_wince_access (const char *fname, int mode)
{
DWORD attr;
wchar_t *wfname;
(void)mode;
wfname = utf8_to_wchar (fname);
if (!wfname)
return -1;
attr = GetFileAttributes (wfname);
free (wfname);
if (attr == (DWORD)(-1))
{
gpg_err_set_errno (ENOENT);
return -1;
}
return 0;
}
/* Perform a binary search for KEY in BASE which has NMEMB elements
of SIZE bytes each. The comparisons are done by (*COMPAR)().
Code taken from glibc-2.6. */
void *
_gpgme_wince_bsearch (const void *key, const void *base,
size_t nmemb, size_t size,
int (*compar) (const void *, const void *))
{
size_t l, u, idx;
const void *p;
int comparison;
l = 0;
u = nmemb;
while (l < u)
{
idx = (l + u) / 2;
p = (void *) (((const char *) base) + (idx * size));
comparison = (*compar) (key, p);
if (comparison < 0)
u = idx;
else if (comparison > 0)
l = idx + 1;
else
return (void *) p;
}
return NULL;
}