#define NTDDI_VERSION NTDDI_VISTA
#define WINVER 0x0602
#define _WIN32_WINNT 0x0602
#define WIN32_LEAN_AND_MEAN
#define _UNICODE
#define UNICODE
#define NO_SHLWAPI_STRFCNS
#define ENOTSUP 95
#define EAGAIN 11
#include <windows.h>
#include <winsock2.h>
#include <winnetwk.h>
#include <mmdeviceapi.h>
#include <endpointvolume.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <initguid.h>
#include <stdint.h>
#include <stdarg.h>
#include <wchar.h>
#include <time.h>
#include <shlobj.h>
#include <shlguid.h>
#include <strsafe.h>
#include <tlhelp32.h>
#include <shlwapi.h>
#include <shellapi.h>
DEFINE_GUID(ID_IAudioEndpointVolume, 0x5CDF2C82, 0x841E, 0x4546, 0x97, 0x22, 0x0C, 0xF7, 0x40, 0x78, 0x22, 0x9A);
DEFINE_GUID(ID_IMMDeviceEnumerator, 0xa95664d2, 0x9614, 0x4f35, 0xa7,0x46, 0xde,0x8d,0xb6,0x36,0x17,0xe6);
DEFINE_GUID(ID_MMDeviceEnumerator, 0xBCDE0395, 0xE52F, 0x467C, 0x8E, 0x3D, 0xC4, 0x57, 0x92, 0x91, 0x69, 0x2E);
#define WM_SOCKDATA (WM_APP+1)
#define BUFLEN (200)
typedef struct {
const char* path;
const char* pathIp;
const char* letter;
const char* shortcut;
const char* user;
const char* pass;
BOOL success;
} netdrive_t;
static const ssize_t KEYLEN = 16;
#define DRIVEMAX (100)
#define LOGFILELEN (300)
#define SETTINGS_FILE "B:\\OPENSLX.INI"
#define SETTINGS_FILE_W L"B:\\OPENSLX.INI"
static BOOL _debug = FALSE;
static HINSTANCE hKernel32, hShell32, hUser32;
static OSVERSIONINFO winVer;
static BOOL shareFileOk = FALSE;
static netdrive_t drives[DRIVEMAX];
static wchar_t desktopPath[MAX_PATH+1], tempPath[MAX_PATH+1], programsPath[MAX_PATH+1], windowsPath[MAX_PATH+1];
static wchar_t logFile[LOGFILELEN];
static DWORD _startTime;
#define FS_UNKNOWN (-1)
#define FS_ERROR (0)
#define FS_OK (1)
static int _folderStatus = FS_UNKNOWN; // -1 = Not handled yet, 0 = patching failed, 1 = remapped ok
#define RM_NONE (0)
#define RM_NATIVE (1)
#define RM_NATIVE_FALLBACK (2)
#define RM_VMWARE (3)
static int _remapMode = RM_NONE;
static const char* _remapHomeDrive = NULL;
static BOOL _passCreds = FALSE;
static BOOL _noHomeWarn = FALSE;
static BOOL _deletedCredentials = FALSE;
static BOOL _scriptDone = TRUE, _mountDone = TRUE; // Will be set to false if we actually wait for something...
static char *shost = NULL, *sport = NULL, *suser = NULL, *spass = NULL;
#define SCRIPTFILELEN (50)
static wchar_t _scriptFile[SCRIPTFILELEN];
struct {
BOOL documents;
BOOL downloads;
BOOL desktop;
BOOL media;
BOOL other;
} remap;
static BOOL _createMissingRemap = FALSE;
static void setPowerState();
static int setResolution();
static int optimizeForRemote();
static int muteSound(BOOL bMute);
static int setShutdownText();
static void readShareFile();
static BOOL mountNetworkShares();
static int queryPasswordDaemon();
static BOOL fileExists(wchar_t* szPath);
static BOOL folderExists(wchar_t* szPath);
static wchar_t* escapeShellArg(wchar_t* in, wchar_t *out, wchar_t *end);
static void patchUserPaths(wchar_t *letter);
static void remapViaSharedFolder();
static HRESULT createFolderShortcut(wchar_t* sTargetfile, wchar_t* sLinkfile, wchar_t* comment);
static void alog(const char *fmt, ...)
{
FILE *f = _wfopen(logFile, L"a+");
if (f == NULL) return;
time_t raw = time(NULL);
struct tm *tinf;
char buffer[80];
tinf = localtime(&raw);
strftime(buffer, 80, "%I:%M:%S ", tinf);
fputs(buffer, f);
va_list args;
va_start(args, fmt);
vfprintf(f, fmt, args);
va_end(args);
fputc('\n', f);
fclose(f);
}
static void wlog(const wchar_t *fmt, ...)
{
wchar_t wbuffer[1000];
char abuffer[1000];
va_list args;
FILE *f = _wfopen(logFile, L"a+");
if (f == NULL) return;
time_t raw = time(NULL);
struct tm *tinf;
tinf = localtime(&raw);
strftime(abuffer, 1000, "%I:%M:%S ", tinf);
fputs(abuffer, f);
va_start(args, fmt);
StringCchVPrintfW(wbuffer, 1000, fmt, args);
va_end(args);
if (WideCharToMultiByte(CP_UTF8, 0, wbuffer, -1, abuffer, 1000, NULL, NULL) == 0) {
snprintf(abuffer, 1000, "Cannot wlog: widechar to utf8 failed.");
}
fputs(abuffer, f);
fputc('\n', f);
fclose(f);
}
#define dalog(...) do { if (_debug) alog(__VA_ARGS__); } while (0)
#define dwlog(...) do { if (_debug) wlog(__VA_ARGS__); } while (0)
static void CALLBACK resetShutdown(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
static BOOL bInProc = FALSE;
if (!bInProc) {
bInProc = TRUE;
setShutdownText();
bInProc = FALSE;
}
}
static void CALLBACK tmrResolution(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
static BOOL bInProc = FALSE;
if (!bInProc) {
bInProc = TRUE;
if (setResolution() == 0) {
KillTimer(hWnd, idEvent);
}
bInProc = FALSE;
}
}
static void CALLBACK setupNetworkDrives(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
static BOOL bInProc = FALSE;
static int fails = 0;
if (bInProc || _mountDone)
return;
bInProc = TRUE;
if (!shareFileOk) {
dalog("No shareFileOk in sND");
if (_remapMode == RM_NATIVE_FALLBACK || _remapMode == RM_VMWARE) {
remapViaSharedFolder();
}
} else {
int ret = queryPasswordDaemon();
dalog("sND: qPD = %d", ret);
if (ret != 0) {
if (++fails < 10)
goto exit_func;
alog("queryPasswordDaemon returned %d", ret);
} else {
if (!mountNetworkShares()) {
if (GetTickCount() - _startTime < 30000 && ++fails < 15)
goto exit_func;
}
}
// Finished successfully or failed completely
if (_folderStatus != FS_OK && (_remapMode == RM_NATIVE_FALLBACK || _remapMode == RM_VMWARE)) {
remapViaSharedFolder();
}
}
_mountDone = TRUE;
KillTimer(hWnd, idEvent);
if (!_noHomeWarn) { // Warn if mapping failed and error is not muted
if (_folderStatus != FS_OK && shost != NULL && shost[0] == '-' && sport != NULL && sport[0] == '-') {
MessageBoxA(NULL, "Kein Home-Verzeichnis konfiguriert. Bitte nichts Wichtiges in der VM speichern, sondern z.B. einen USB-Stick verwenden, bzw. evtl. vorhandene Netzlaufwerke verwenden.", "Warnung", MB_ICONERROR);
} else if (_folderStatus == FS_ERROR) {
MessageBoxA(NULL, "Fehler beim Einbinden des Home-Verzeichnisses. Bitte nichts Wichtiges in der VM speichern, sondern z.B. einen USB-Stick verwenden.", "Warnung", MB_ICONERROR);
} else if (_folderStatus == FS_UNKNOWN) {
MessageBoxA(NULL, "Kein Home-Verzeichnis gefunden. Bitte nichts Wichtiges in der VM speichern, sondern z.B. einen USB-Stick verwenden.", "Warnung", MB_ICONERROR);
}
}
return;
exit_func:
bInProc = FALSE;
}
static inline int mapScriptVisibility(int input)
{
if (input == 0)
return SW_HIDE;
if (input == 2)
return SW_SHOWMINNOACTIVE;
return SW_SHOWNORMAL;
}
static void CALLBACK launchRunscript(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
static int fails = 0;
wchar_t params[BUFLEN] = L"";
wchar_t emptyParams[BUFLEN] = L"";
wchar_t nuser[BUFLEN] = L"";
wchar_t npass[BUFLEN] = L"";
if (_scriptDone) {
KillTimer(hWnd, idEvent);
return;
}
// Prepare credentials cmdline
if (spass == NULL) {
dalog("launchRun: No spass");
goto failure;
}
BOOL ok = TRUE;
ok = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)suser, -1, (LPWSTR)nuser, BUFLEN) > 0 && ok;
ok = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)spass, -1, (LPWSTR)npass, BUFLEN) > 0 && ok;
if (!ok) {
alog("Could not convert user/password to unicode");
goto failure;
}
// Build command line with user password
wchar_t *end = params + BUFLEN - 2;
wchar_t *ptr = params;
ptr = escapeShellArg(nuser, ptr, end);
*ptr++ = ' ';
ptr = escapeShellArg(npass, ptr, end);
*ptr = '\0';
// Build command line without password, just user
end = emptyParams + BUFLEN - 2;
ptr = emptyParams;
ptr = escapeShellArg(nuser, ptr, end);
*ptr = '\0';
if (_debug) {
wlog(L"Params are '%s'", emptyParams);
}
// Scan folder
WIN32_FIND_DATAA fdFile;
HANDLE hFind = NULL;
const char* sDir = "B:\\adminrun";
char sFile[200];
snprintf(sFile, 200, "%s\\*-*-*", sDir);
if ((hFind = FindFirstFileA(sFile, &fdFile)) != INVALID_HANDLE_VALUE) {
do {
if(strcmp(fdFile.cFileName, ".") == 0 || strcmp(fdFile.cFileName, "..") == 0)
continue;
if (fdFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
snprintf(sFile, 200, "%s\\%s", sDir, fdFile.cFileName);
wchar_t ucPath[BUFLEN];
ok = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)sFile, -1, (LPWSTR)ucPath, BUFLEN) > 0;
if (!ok) {
alog("Cannot convert %s to unicode", sFile);
continue;
}
int index, visibility, passCreds;
if (sscanf(fdFile.cFileName, "%d-%d-%d", &index, &visibility, &passCreds) < 3) {
alog("Cannot parse %s", fdFile.cFileName);
continue;
}
ShellExecuteW(NULL, L"open", ucPath, passCreds ? params : emptyParams, L"B:\\", mapScriptVisibility(visibility));
} while(FindNextFileA(hFind, &fdFile)); //Find the next file.
FindClose(hFind); //Always, Always, clean things up!
}
// Execute legacy runscript
int scriptVisibility = GetPrivateProfileIntA("openslx", "scriptVisibility", 1, SETTINGS_FILE);
int nShowCmd = mapScriptVisibility(scriptVisibility); // show window as default
ShellExecuteW(NULL, L"open", _scriptFile, _passCreds ? params : emptyParams, L"B:\\", nShowCmd);
// DONE
_scriptDone = TRUE;
return;
failure:
if (++fails > 12) {
_scriptDone = TRUE;
}
}
typedef HRESULT (*GFPTYPE)(HWND, int, HANDLE, DWORD, wchar_t*);
typedef HRESULT (*GSFTYPE)(HWND, int, ITEMIDLIST**);
typedef BOOL (*ID2PTYPE)(const ITEMIDLIST*, wchar_t*);
/**
* Load given path (CSIDL). Store in default (must be allocated to hold at least MAX_PATH+1 chars).
* If it could not be retrieved by CSIDL and envName is not NULL, it will be read from the
* environment if possible.
* fallback will be used if everything else fails.
* fallback can be NULL, in which case the fallback is empty.
*/
static void loadPath(wchar_t *dest, int csidl, wchar_t *envName, wchar_t *fallback)
{
if (hShell32 != NULL) {
GFPTYPE aGetFolderPath = (GFPTYPE)GetProcAddress(hShell32, "SHGetFolderPathW");
if (aGetFolderPath != NULL) {
if ((aGetFolderPath)(HWND_DESKTOP, csidl, NULL, SHGFP_TYPE_CURRENT, dest) == S_OK)
return;
}
// Fallback
GSFTYPE aGetSpecialFolder = (GSFTYPE)GetProcAddress(hShell32, "SHGetSpecialFolderLocation");
ID2PTYPE aPathToId = (ID2PTYPE)GetProcAddress(hShell32, "SHGetPathFromIDListW");
if (aGetSpecialFolder != NULL && aPathToId != NULL) {
ITEMIDLIST *list = NULL;
HRESULT ret1 = (aGetSpecialFolder)(HWND_DESKTOP, csidl, &list);
BOOL ret2 = FALSE;
if (ret1 == 0) {
ret2 = (aPathToId)(list, dest);
}
if (list != NULL) {
CoTaskMemFree(list);
}
if (ret2)
return;
}
}
if (envName != NULL) {
// Fallback
DWORD ret = GetEnvironmentVariableW(envName, dest, MAX_PATH+1);
if (ret > 0 && ret <= MAX_PATH)
return;
}
if (fallback != NULL) {
StringCchPrintfW(programsPath, MAX_PATH+1, fallback);
return;
}
*dest = '\0';
}
static void loadPaths()
{
// Determine a couple of default directories
// dest, id, env, fallback
loadPath(programsPath, CSIDL_PROGRAM_FILES, L"ProgramFiles", L"C:\\Program Files");
loadPath(windowsPath, CSIDL_WINDOWS, L"windir", L"C:\\WINDOWS");
loadPath(desktopPath, CSIDL_DESKTOPDIRECTORY, NULL, NULL);
if (GetTempPathW(MAX_PATH+1, tempPath) == 0) {
DWORD ret = GetEnvironmentVariableW(L"TEMP", tempPath, MAX_PATH+1);
if (ret == 0 || ret > MAX_PATH) {
tempPath[0] = 0;
}
}
//wlog(L"Programs: %s, Windows: %s, Desktop: %s, Temp: %s", programsPath, windowsPath, desktopPath, tempPath);
StringCchPrintfW(logFile, LOGFILELEN, L"%s\\%s", desktopPath, L"openslx.log");
FILE *tfh = _wfopen(logFile, L"a+");
if (tfh == NULL) {
StringCchPrintfW(logFile, LOGFILELEN, L"%s\\%s", tempPath, L"openslx.log");
tfh = _wfopen(logFile, L"a+");
}
if (tfh != NULL) {
fseek(tfh, 0, SEEK_END);
long pos = ftell(tfh);
fclose(tfh);
if (pos < 3) {
_wremove(logFile);
}
}
// Read settings from ini file
remap.documents = GetPrivateProfileIntA("remap", "documents", 1, SETTINGS_FILE) != 0;
remap.downloads = GetPrivateProfileIntA("remap", "downloads", 1, SETTINGS_FILE) != 0;
remap.desktop = GetPrivateProfileIntA("remap", "desktop", 0, SETTINGS_FILE) != 0;
remap.media = GetPrivateProfileIntA("remap", "media", 1, SETTINGS_FILE) != 0;
remap.other = GetPrivateProfileIntA("remap", "other", 0, SETTINGS_FILE) != 0;
_createMissingRemap = GetPrivateProfileIntA("openslx", "createMissingRemap", 1, SETTINGS_FILE) != 0;
_remapMode = GetPrivateProfileIntA("openslx", "remapMode", RM_NATIVE_FALLBACK, SETTINGS_FILE);
if (_remapMode == RM_NONE) {
_folderStatus = FS_OK;
}
char buffer[100];
GetPrivateProfileStringA("openslx", "homeDrive", "H:", buffer, sizeof(buffer), SETTINGS_FILE);
buffer[0] = toupper(buffer[0]);
buffer[1] = ':';
buffer[2] = '\0';
_remapHomeDrive = strdup(buffer);
// Get extension for autorun script
int bl = snprintf(buffer, sizeof(buffer), "B:\\runscript");
GetPrivateProfileStringA("openslx", "scriptExt", "", buffer + bl, sizeof(buffer) - bl, SETTINGS_FILE);
if (MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buffer, -1, (LPWSTR)_scriptFile, SCRIPTFILELEN) <= 0) {
_scriptFile[0] = '\0';
}
// Pass creds to normal runscript?
_passCreds = GetPrivateProfileIntA("openslx", "passCreds", 0, SETTINGS_FILE) != 0;
// No warning if no home directory could be mounted
_noHomeWarn = GetPrivateProfileIntA("openslx", "noHomeWarn", 0, SETTINGS_FILE) != 0;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
hKernel32 = LoadLibraryW(L"kernel32.dll");
if (hKernel32 == NULL) {
alog("Cannot load kernel32.dll");
}
hShell32 = LoadLibraryW(L"shell32.dll");
if (hShell32 == NULL) {
alog("Cannot load shell32.dll");
}
hUser32 = LoadLibraryW(L"user32.dll");
if (hUser32 == NULL) {
alog("Cannot load user32.dll");
}
winVer.dwOSVersionInfoSize = sizeof(winVer);
BOOL retVer = GetVersionEx(&winVer);
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
_startTime = GetTickCount();
loadPaths();
if (lpCmdLine != NULL && strstr(lpCmdLine, "/debug") != NULL) {
_debug = TRUE;
}
if (!_debug && GetPrivateProfileIntA("openslx", "debug", 0, SETTINGS_FILE) != 0) {
_debug = TRUE;
}
if (_debug) {
alog("Windows Version %d.%d", (int)winVer.dwMajorVersion, (int)winVer.dwMinorVersion);
}
// Mute sound?
BOOL mute = GetPrivateProfileIntA("openslx", "muteSound", 1, SETTINGS_FILE) != 0;
if (retVer && winVer.dwMajorVersion >= 6)
muteSound(mute);
// Disable screen saver as it might give the false impression that the session is securely locked
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, NULL, 0);
// Same with standby
setPowerState();
// Any network shares to mount?
readShareFile();
if (shareFileOk || _remapMode != RM_NONE) {
UINT_PTR tRet = SetTimer(NULL, 0, 1650, (TIMERPROC)&setupNetworkDrives);
dalog("init: &setupNetworkDrives");
if (tRet == 0) {
alog("Could not create timer for mounting network shares: %d", (int)GetLastError());
} else {
_mountDone = FALSE;
}
}
// Shutdown button label
if (retVer && winVer.dwMajorVersion == 6 && winVer.dwMinorVersion == 1) {
// Only on Windows 7
// Repeatedly set caption
UINT_PTR tRet = SetTimer(NULL, 0, 5230, (TIMERPROC)&resetShutdown);
if (tRet == 0) {
alog("Could not create timer for shutdown button: %d", (int)GetLastError());
}
}
// Resolution
UINT_PTR tRet;
tRet = SetTimer(NULL, 0, 211, (TIMERPROC)&tmrResolution);
if (tRet == 0) {
alog("Could not create timer for resolution setting: %d", (int)GetLastError());
}
// Runscript
tRet = SetTimer(NULL, 0, 3456, (TIMERPROC)&launchRunscript);
dalog("init: &launchRunscript");
if (tRet == 0) {
alog("Could not create timer for runscript: %d", (int)GetLastError());
} else {
_scriptDone = FALSE;
}
// Remote?
do {
char buffer[100];
GetPrivateProfileStringA("openslx", "runMode", "", buffer, sizeof(buffer), SETTINGS_FILE);
if (strcmp(buffer, "remoteaccess") == 0) {
optimizeForRemote();
}
} while (0);
// Message pump
MSG Msg;
while(GetMessage(&Msg, NULL, 0, 0) > 0) {
TranslateMessage(&Msg);
DispatchMessage(&Msg);
if (!_deletedCredentials && _mountDone && _scriptDone) {
if (spass != NULL) {
dalog("Erasing password from memory");
SecureZeroMemory(spass, strlen(spass));
_deletedCredentials = TRUE;
}
}
}
FreeLibrary(hKernel32);
FreeLibrary(hShell32);
FreeLibrary(hUser32);
return 0;
}
static BOOL fileExists(wchar_t* szPath)
{
DWORD dwAttrib = GetFileAttributesW(szPath);
return (dwAttrib != INVALID_FILE_ATTRIBUTES && (dwAttrib & FILE_ATTRIBUTE_DIRECTORY) == 0);
}
static BOOL folderExists(wchar_t* szPath)
{
DWORD dwAttrib = GetFileAttributesW(szPath);
return (dwAttrib != INVALID_FILE_ATTRIBUTES && (dwAttrib & FILE_ATTRIBUTE_DIRECTORY) != 0);
}
static wchar_t* escapeShellArg(wchar_t* in, wchar_t *out, wchar_t *end)
{
int bs;
end -= 2;
if (out >= end)
return out;
*out++ = '"';
while (*in != '\0') {
bs = 0;
while (*in == '\\' && out < end) {
bs++;
*out++ = *in++;
}
if (*in == '\0' || *in == '"') {
while (bs-- > 0 && out < end) {
*out++ = '\\';
}
if (*in == '\0') {
break;
}
}
if (*in == '"' && out < end) {
*out++ = '\\';
}
if (out < end) {
*out++ = *in++;
}
}
if (out < end) {
*out++ = '"';
}
*out = '\0';
return out;
}
static int execute(wchar_t *path, wchar_t *arguments)
{
STARTUPINFOW si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
ZeroMemory(&pi, sizeof(pi));
si.cb = sizeof(si);
if (!CreateProcessW(path, arguments, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) {
return -1;
}
while (MsgWaitForMultipleObjects(1, &pi.hProcess, FALSE, INFINITE, QS_SENDMESSAGE) == WAIT_OBJECT_0+1) {
MSG Msg;
while(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE)) {
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
}
DWORD exitCode;
BOOL ret = GetExitCodeProcess(pi.hProcess, &exitCode);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
if (!ret) {
return -2;
}
return (int)exitCode;
}
typedef EXECUTION_STATE (WINAPI *TETYPE)(EXECUTION_STATE);
static void setPowerState()
{
// Disable standby and idle-mode (this is a VM!)
if (hKernel32 == NULL || winVer.dwMajorVersion < 5 || (winVer.dwMajorVersion == 5 && winVer.dwMinorVersion < 1))
return;
TETYPE aExecState = (TETYPE)GetProcAddress(hKernel32, "SetThreadExecutionState");
if (aExecState == NULL) {
alog("Cannot get SetThreadExecutionState from kernel32.dll");
return;
}
if (winVer.dwMajorVersion >= 6) { // Vista+
(aExecState)(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED | ES_AWAYMODE_REQUIRED);
} else { // XP/2003
(aExecState)(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED);
}
}
typedef LONG (WINAPI *CDSTYPE)(LPCWSTR, PDEVMODEW, HWND, DWORD, LPVOID);
typedef BOOL (WINAPI *EDDTYPE)(LPCWSTR, DWORD, PDISPLAY_DEVICEW, DWORD);
typedef BOOL (WINAPI *EDMTYPE)(HDC, LPCRECT, MONITORENUMPROC, LPARAM);
typedef BOOL (WINAPI *GMITYPE)(HMONITOR, LPMONITORINFO);
struct resolution {
long int w, h;
};
#define MAX_SCREENS (16)
static int isResolutionFine(struct resolution *res, int nres);
static int setResWinMulti(struct resolution *res, int nres);
static int setResWinLegacy(struct resolution *res, int nres);
static int setResVMware(struct resolution *res, int nres);
static int setResolution()
{
static int nres = 0;
static struct resolution res[MAX_SCREENS];
static int callCount = -1;
callCount++;
if (nres == -1 || callCount > 10) // We've been here before and consider config invalid, or are done
return 0;
if (nres == 0) {
// use config file in floppy
char data[300] = "";
GetPrivateProfileStringA("openslx", "resolution2", "", data, sizeof(data), SETTINGS_FILE); // Multi-res, space separated
if (data[0] == '\0') {
GetPrivateProfileStringA("openslx", "resolution", "", data, sizeof(data), SETTINGS_FILE); // Fallback
}
char *pos = data, *end;
while (*pos != '\0' && nres < 16) {
res[nres].w = strtol(pos, &end, 10);
if (*end != 'x')
break;
res[nres].h = strtol(end + 1, &pos, 10);
if (*pos != '\0' && *pos != ' ')
break;
if (res[nres].w < 320 || res[nres].h < 240) {
alog("Invalid resolution in " SETTINGS_FILE ": '%s' (parsed width=%ld, height=%ld)", data, res[nres].w, res[nres].h);
continue;
}
nres++;
}
if (*pos != '\0') {
alog("Malformed resolution in " SETTINGS_FILE ": '%s'", data);
}
if (nres == 0) {
// Nothing found -- consider this success
nres = -1;
dalog("No resolution information in openslx.ini -- doing nothing");
return 0;
}
}
int check, ret;
check = isResolutionFine(res, nres);
if (check == 0)
return 0; // Yay! Save the hassle.
switch (callCount % 3) {
case 0:
// Use WinAPI first
ret = setResWinMulti(res, nres);
if (ret != ENOTSUP)
break;
// Fallthrough
case 1:
// Try vmware tools
ret = setResVMware(res, nres);
if (ret != ENOTSUP)
break;
default:
// Legacy WinAPI (single screen only)
ret = setResWinLegacy(res, nres);
if (ret == 0 && nres > 1 && callCount == 2) {
// Legacy winapi worked, but if we have more than one screen, pretend it failed
// the first time, so maybe one of the methods above will work if we call them again
// (Looking at you, VMwareResolutionSet)
ret = EAGAIN; // Fake failure
}
break;
}
if (ret == 0 && check == ENOTSUP)
return 0; // Couldn't query, attempt to set didn't yield an error -> OK
return EAGAIN; // Otherwise, regardless of attempt's return value, call again,
// in which case isResolutionFine should yield success.
}
static int isResolutionFine(struct resolution *res, int nres)
{
EDDTYPE edd = (EDDTYPE)GetProcAddress(hUser32, "EnumDisplayDevicesW");
if (edd == NULL) {
// Old Windows with no multiscreen support
DEVMODEW mode = { .dmSize = sizeof(mode) };
int query = EnumDisplaySettingsW(NULL, ENUM_CURRENT_SETTINGS, &mode);
if (query == 0) {
dalog("Could not query current resolution for old Windows.");
return ENOTSUP;
}
return res[0].w == mode.dmPelsWidth && res[0].h == mode.dmPelsHeight;
}
// Modern/multi-screen aware approach
DISPLAY_DEVICEW screen = { .cb = sizeof(screen) };
int offsets[MAX_SCREENS] = { 0 };
DWORD screenNum = 0;
// First make a list of expected offsets for our resolutions
for (int i = 1; i < nres; ++i) {
offsets[i] = offsets[i - 1] + res[i - 1].w;
}
while (edd(NULL, screenNum++, &screen, 0)) {
DEVMODEW mode = { .dmSize = sizeof(mode) };
int query = EnumDisplaySettingsW(screen.DeviceName, ENUM_CURRENT_SETTINGS, &mode);
if (query == 0 || mode.dmPelsWidth == 0)
continue; // Not active
// See if this screen matches any of the expected res+offset
BOOL found = FALSE;
for (int i = 0; i < nres; ++i) {
if (offsets[i] == mode.dmPosition.x
&& res[i].w == mode.dmPelsWidth && res[i].h == mode.dmPelsHeight) {
offsets[i] = -1; // Marker
found = TRUE;
break;
}
}
if (!found) {
dalog("Non-matching screen active (%dx%d @ %d)", mode.dmPelsWidth, mode.dmPelsHeight,
mode.dmPosition.x);
return EAGAIN;
}
}
// If all offsets are set to -1, everything matched up perfectly
for (int i = 0; i < nres; ++i) {
if (offsets[i] != -1) {
dalog("Expected screen %dx%d @ %d not found in active setup", res[i].w, res[i].h, offsets[i]);
return EAGAIN;
}
}
dalog("Current screen layout matches expected one");
return 0;
}
static BOOL foobar(HMONITOR Arg1, HDC Arg2, LPRECT Arg3, LPARAM Arg4)
{
GMITYPE gmi = (GMITYPE)GetProcAddress(hUser32, "GetMonitorInfoW");
if (gmi == NULL)
return FALSE;
MONITORINFOEXW info = { .cbSize = sizeof(info) };
if (gmi(Arg1, (LPMONITORINFO)&info) == 0)
dalog("MonitorInfo FAILED for %d", (int)Arg1);
else {
dalog("MonitorInfo for %d:", (int)Arg1);
dalog("Flags: %d", (int)info.dwFlags);
dwlog(L"Name: %s", info.szDevice);
}
return TRUE;
}
/*
* This seems to be broken with VirtualBox, and I'm not sure whether
* I'm doing something wrong here. For a dualscreen setup, this
* returns two devices, but only the first one has a monitor, i.e.
* the inner loop never runs for the second device.
* I'm still leaving this here as a starting-point for future
* changes or new virtualizers.
*/
static int setResWinMulti(struct resolution *res, int nres)
{
if (hUser32 == NULL)
return ENOTSUP;
CDSTYPE cdsEx = (CDSTYPE)GetProcAddress(hUser32, "ChangeDisplaySettingsExW");
EDDTYPE edd = (EDDTYPE)GetProcAddress(hUser32, "EnumDisplayDevicesW");
if (cdsEx == NULL || edd == NULL)
return ENOTSUP;
DISPLAY_DEVICEW ddev = { .cb = sizeof(ddev) };
int ires = 0;
int chret;
long int sx = 0;
BOOL ok = TRUE;
dalog("WinAPI multiscreen");
// XXX Debug
EDMTYPE edm = (EDMTYPE)GetProcAddress(hUser32, "EnumDisplayMonitors");
if (edm != NULL) {
edm(NULL, NULL, (MONITORENUMPROC)&foobar, 0);
dalog("End of monitor enum dump");
}
// XXX END DEBUG
DISPLAY_DEVICEW screen = { .cb = sizeof(screen) };
DWORD screenNum = 0;
while (edd(NULL, screenNum++, &screen, 0)) {
DEVMODEW mode = { .dmSize = sizeof(mode) };
int query = EnumDisplaySettingsW(screen.DeviceName, ENUM_CURRENT_SETTINGS, &mode);
if (query == 0) {
dalog("EnumDisplaySettings: Retrying with index 0");
query = EnumDisplaySettingsW(screen.DeviceName, 0, &mode);
}
mode.dmFields = 0;
if (query == 0) {
dalog("EnumDisplaySettings: Falling back to default values");
mode.dmFields |= DM_BITSPERPEL | DM_DISPLAYFREQUENCY;
mode.dmBitsPerPel = 32;
mode.dmDisplayFrequency = 60;
}
dwlog(L"%s (%s) currently %dx%d+%d+%d, %dHz, %dbpp (Query: %d)",
screen.DeviceName, screen.DeviceString,
mode.dmPelsWidth, mode.dmPelsHeight, mode.dmPosition.x, mode.dmPosition.y,
mode.dmDisplayFrequency, mode.dmBitsPerPel, query);
if (ires < nres) {
// Enable
mode.dmPelsWidth = res[ires].w;
mode.dmPelsHeight = res[ires].h;
mode.dmPosition.x = sx;
mode.dmPosition.y = 0;
sx += mode.dmPelsWidth;
mode.dmFields |= DM_PELSWIDTH | DM_PELSHEIGHT | DM_POSITION;
} else {
// Disable
mode.dmPelsWidth = mode.dmPelsHeight = 0;
mode.dmFields = DM_POSITION;
}
dwlog(L"New: %dx%d+%d+%d", mode.dmPelsWidth, mode.dmPelsHeight, mode.dmPosition.x, mode.dmPosition.y);
chret = cdsEx(screen.DeviceName, &mode, 0, (CDS_UPDATEREGISTRY | CDS_NORESET), NULL);
if (chret != DISP_CHANGE_SUCCESSFUL) {
dalog("Returned %d", chret);
ok = FALSE;
}
ires++;
screen = (DISPLAY_DEVICEW){ .cb = sizeof(DISPLAY_DEVICEW) };
}
chret = cdsEx(NULL, NULL, NULL, 0, NULL);
if (chret != DISP_CHANGE_SUCCESSFUL || !ok) {
dalog("Final multiscreen change display call failed: %d", chret);
return EAGAIN;
}
return ires >= nres ? 0 : EAGAIN; // Did we find enough (virtual) screens?
}
static int setResWinLegacy(struct resolution *res, int nres)
{
dalog("Using legacy single-screen WinAPI");
// Legacy single screen
DEVMODE mode = { .dmSize = sizeof(mode) };
// MSDN recommends to fill the struct first by querying....
int query = EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &mode);
// Then set our own desired mode
mode.dmPelsWidth = res[0].w;
mode.dmPelsHeight = res[0].h;
mode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
int ret = ChangeDisplaySettings(&mode, CDS_GLOBAL | CDS_UPDATEREGISTRY);
if (ret != DISP_CHANGE_SUCCESSFUL) {
ret = ChangeDisplaySettings(&mode, CDS_GLOBAL);
}
if (ret != DISP_CHANGE_SUCCESSFUL) {
ret = ChangeDisplaySettings(&mode, CDS_UPDATEREGISTRY);
}
if (ret != DISP_CHANGE_SUCCESSFUL) {
ret = ChangeDisplaySettings(&mode, 0);
}
if (ret != DISP_CHANGE_SUCCESSFUL) {
dalog("WinAPI Legacy: CDS: %d (should: 0), EDS: %d (should: !0) - Want: %ld * %ld",
ret, query, res[0].w, res[0].h);
return EAGAIN;
}
return 0;
}
static int setResVMware(struct resolution *res, int nres)
{
static wchar_t path[MAX_PATH] = L"";
if (path[0] == 0) {
StringCchPrintfW(path, MAX_PATH, L"%s\\VMware\\VMware Tools\\VMwareResolutionSet.exe", programsPath);
if (!fileExists(path)) {
// Strip (x86) if not found and try again
wchar_t *x86 = wcsstr(path, L" (x86)");
if (x86 != NULL) {
while ((*x86 = *(x86 + 6)) != 0) ++x86;
}
}
if (!fileExists(path)) {
char buffer[300];
WideCharToMultiByte(CP_UTF8, 0, path, -1, buffer, 300, NULL, NULL);
dalog("vmware tools not found, using winapi to set resolution (path: %s)", buffer);
return ENOTSUP;
}
} else if (!fileExists(path)) {
return ENOTSUP;
}
wchar_t cmdline[MAX_PATH];
wchar_t *pos = cmdline;
size_t rem = MAX_PATH;
long int sx = 0, i = 0;
StringCchPrintfExW(pos, rem, &pos, &rem, 0, L"VMwareResolutionSet.exe 0 %d", nres);
while (rem > 0 && i < nres) {
StringCchPrintfExW(pos, rem, &pos, &rem, 0, L" , %ld 0 %ld %ld", sx, res[i].w, res[i].h);
sx += res[i++].w;
}
dwlog(L"vmwareRS cmd: %s", cmdline);
int ret = execute(path, cmdline);
if (ret == -1) {
alog("VmwareRes: CreateProcess failed (%d)", (int)GetLastError());
} else if (ret == -2) {
alog("VmwareRes: GetExitCode failed (%d)", (int)GetLastError());
} else if (ret != 0) {
dalog("VmwareRes: Exit code: %d", ret);
} else {
return 0;
}
return EAGAIN;
}
static int optimizeForRemote()
{
LONG ret;
HKEY hKey;
ret = RegOpenKeyExW(HKEY_CURRENT_USER,
L"Control Panel\\Cursors",
0, KEY_WOW64_64KEY | KEY_READ | KEY_WRITE, &hKey);
if (ret != ERROR_SUCCESS) {
alog("Opening registry for optimizing remote access failed: %ld", (long)ret);
return 1;
}
DWORD val = 0;
ret = RegSetValueExW(hKey, L"Scheme Source", 0, REG_DWORD, (BYTE*)&val, sizeof(val));
if (ret != ERROR_SUCCESS) {
alog("Cannot set Scheme Source to 0: %ld", (long)ret);
}
static const char *keys[] = {
"AppStarting", "Arrow", "Crosshair", "Hand", "Help", "IBeam", "No", "NWPen",
"SizeAll", "SizeNESW", "SizeNS", "SizeNWSE", "SizeWE", "UpArrow", "Wait",
NULL
};
for (const char **key = keys; *key != NULL; ++key) {
ret = RegSetValueExA(hKey, *key, 0, REG_SZ, (const BYTE*)"", 1);
if (ret != ERROR_SUCCESS) {
alog("Cannot set %s to empty string", key);
}
}
RegCloseKey(hKey);
static const UINT paramsOff[] = {
SPI_SETCLIENTAREAANIMATION, SPI_SETMOUSEVANISH, SPI_SETDROPSHADOW, SPI_SETMENUFADE,
SPI_SETTOOLTIPFADE, SPI_SETTOOLTIPANIMATION, SPI_SETSELECTIONFADE, SPI_SETMENUANIMATION,
SPI_SETLISTBOXSMOOTHSCROLLING, SPI_SETCURSORSHADOW, SPI_SETCOMBOBOXANIMATION,
0
}, paramsOn[] = {
SPI_SETDISABLEOVERLAPPEDCONTENT,
0
};
for (const UINT *s = paramsOff; *s != 0; ++s) {
SystemParametersInfo(*s, 0, (PVOID)FALSE, SPIF_UPDATEINIFILE);
}
for (const UINT *s = paramsOn; *s != 0; ++s) {
SystemParametersInfo(*s, 0, (PVOID)TRUE, SPIF_UPDATEINIFILE);
}
// Try this although it needs admin perms
ANIMATIONINFO ai = { .cbSize = sizeof(ai), .iMinAnimate = 0, };
SystemParametersInfo(SPI_SETANIMATION, 0, &ai, SPIF_UPDATEINIFILE);
// Apply cursors, broadcast changes to whole system
SystemParametersInfo(SPI_SETCURSORS, 0, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
return 0;
}
static int muteSound(BOOL bMute)
{
IMMDeviceEnumerator *deviceEnumerator = NULL;
HRESULT hr = CoCreateInstance(&ID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &ID_IMMDeviceEnumerator, (LPVOID *)&deviceEnumerator);
if (hr != S_OK) {
alog("CoCreateInstance failed. Cannot mute.");
return 1;
}
//deviceEnumerator->lpVtbl->AddRef(deviceEnumerator);
IMMDevice *defaultDevice = NULL;
hr = deviceEnumerator->lpVtbl->GetDefaultAudioEndpoint(deviceEnumerator, eRender, eConsole, &defaultDevice);
if (hr != S_OK) {
alog("GetDefaultAudioEndpoint failed. Cannot mute.");
return 2;
}
//defaultDevice->lpVtbl->AddRef(defaultDevice);
//deviceEnumerator->lpVtbl->Release(deviceEnumerator);
IAudioEndpointVolume *endpointVolume = NULL;
hr = defaultDevice->lpVtbl->Activate(defaultDevice, &ID_IAudioEndpointVolume, CLSCTX_INPROC_SERVER, NULL, (LPVOID *)&endpointVolume);
if (hr != S_OK) {
alog("IMMDevice::Activate() failed. Cannot mute.");
return 3;
}
//endpointVolume->lpVtbl->AddRef(endpointVolume);
//defaultDevice->lpVtbl->Release(defaultDevice);
float targetVolume = 1;
endpointVolume->lpVtbl->SetMasterVolumeLevelScalar(endpointVolume, targetVolume, NULL);
endpointVolume->lpVtbl->SetMute(endpointVolume, bMute, NULL);
//endpointVolume->lpVtbl->Release(endpointVolume);
//CoUninitialize();
return 0;
}
static int setShutdownText()
{
HWND hMenu = FindWindowA("DV2ControlHost", NULL);
if (hMenu == NULL) return 1; // TODO: Enum all of them
HWND hPane = FindWindowExA(hMenu, NULL, "DesktopLogoffPane", NULL);
if (hMenu == NULL) return 2;
HWND hButton = FindWindowExA(hPane, NULL, "Button", NULL);
if (hButton == NULL) return 3;
if (SendMessageA(hButton, WM_SETTEXT, 0, (LPARAM)"Abmelden") != TRUE) return 4;
return 0;
}
static uint8_t *bkey1 = NULL, *bkey2 = NULL;
static char* xorString(const uint8_t* text, int len, const uint8_t* key);
static int getbin(int x);
static uint8_t* hex2bin(char *szHexString);
static char* getToken(char **ptr, BOOL doDup)
{
if (*ptr == NULL || **ptr == '\0') return NULL;
char *dest = *ptr;
while (**ptr != '\0') {
if (**ptr == '\n' || **ptr == '\r' || **ptr == '\t') {
*(*ptr)++ = '\0';
break;
}
(*ptr)++;
}
if (doDup) {
dest = strdup(dest);
}
return dest;
}
const char* uncReplaceFqdnByIp(const char* path)
{
if (path == NULL || path[0] != '\\' || path[1] != '\\')
return NULL;
const char *host = path + 2;
const char *rest = strchr(host, '\\');
if (rest == NULL || rest - host >= 200)
return NULL;
char name[201];
strncpy(name, host, rest - host);
name[rest-host] = '\0';
dalog("Trying to resolve '%s'...", name);
struct hostent *remote = gethostbyname(name);
if (remote == NULL || remote->h_addrtype != AF_INET || remote->h_addr_list[0] == 0)
return NULL;
struct in_addr addr;
addr.s_addr = *(u_long*)remote->h_addr_list[0];
char *ip = inet_ntoa(addr);
if (ip == NULL)
return NULL;
size_t len = 2 /* \\ */ + strlen(ip) /* 1.2.3.4 */ + strlen(rest) /* \path\to\share */ + 1 /* nullchar */;
char *retval = malloc(len);
snprintf(retval, len, "\\\\%s%s", ip, rest);
dalog("Turned '%s' into '%s'", path, retval);
return retval;
}
#define FREENULL(x) do { free((void*)(x)); (x) = NULL; } while (0)
static void readShareFile()
{
if (shareFileOk)
return;
memset(drives, 0, sizeof(drives));
FILE *h = fopen("B:\\shares.dat", "r");
if (h == NULL) return;
char creds[300] = "", buffer[500] = "";
char *skey1 = NULL, *skey2 = NULL;
if (fgets(creds, sizeof(creds), h) != NULL) {
char *ptr = creds;
shost = getToken(&ptr, TRUE);
sport = getToken(&ptr, TRUE);
skey1 = getToken(&ptr, FALSE);
skey2 = getToken(&ptr, FALSE);
suser = getToken(&ptr, TRUE);
}
int idx = 0;
while (fgets(buffer, sizeof(buffer), h) != NULL && idx < DRIVEMAX) {
char *ptr = buffer;
netdrive_t *d = &drives[idx];
d->path = getToken(&ptr, TRUE);
d->letter = getToken(&ptr, TRUE);
d->shortcut = getToken(&ptr, TRUE);
d->user = getToken(&ptr, TRUE);
d->pass = getToken(&ptr, TRUE);
if (d->path == NULL || d->path[0] == '\0')
goto drive_fail;
d->success = FALSE;
// Hack: For unknown reasons, with some servers mounting fails using a fqdn, but using the ip address instead succeeds.
d->pathIp = uncReplaceFqdnByIp(d->path);
//
idx++;
continue;
drive_fail:
FREENULL(d->path);
FREENULL(d->letter);
FREENULL(d->shortcut);
FREENULL(d->user);
FREENULL(d->pass);
}
fclose(h);
if (shost == NULL || sport == NULL || skey1 == NULL || skey2 == NULL || suser == NULL) {
// Credential stuff missing
dalog("Incomplete first line in shares.dat");
return;
}
if (*shost == '-' && *sport == '-') {
dalog("Demo mode detected");
shareFileOk = TRUE;
spass = malloc(1);
*spass = '\0';
return;
}
if (strlen(skey1) != KEYLEN*2 || strlen(skey2) != KEYLEN*2) // Messed up keys
return;
if (atoi(sport) < 1000 || atoi(sport) > 65535) // Invalid port
return;
bkey1 = hex2bin(skey1);
bkey2 = hex2bin(skey2);
if (bkey1 == NULL || bkey2 == NULL)
return;
shareFileOk = TRUE;
}
static void udpReceived(SOCKET sock);
LRESULT CALLBACK slxWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (uMsg != WM_SOCKDATA) {
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
// Socket event
int event = LOWORD(lParam);
int errorCode = HIWORD(lParam);
if (errorCode == 0 && event == FD_READ) {
udpReceived((SOCKET)wParam);
}
return 0;
}
static int queryPasswordDaemon()
{
// See if preconditions are met
dalog("in qPD");
if (!shareFileOk || spass != NULL)
return 0;
dalog("...");
static int wsaInit = 1337;
static SOCKET sock = INVALID_SOCKET;
static HWND sockWnd = NULL;
// Init socket stuff
if (wsaInit == 1337) {
WSADATA wsa;
wsaInit = WSAStartup(MAKEWORD(2, 2), &wsa);
}
if (wsaInit != 0)
return 2;
// Create window for socket events
if (sockWnd == NULL) {
sockWnd = CreateWindowA("STATIC", "OpenSLX mystery window", 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
if (sockWnd == NULL)
return GetLastError();
SetWindowLong(sockWnd, GWL_WNDPROC, (LONG)&slxWindowProc);
}
// Create socket
if (sock == INVALID_SOCKET) {
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock == INVALID_SOCKET)
return 3;
if (WSAAsyncSelect(sock, sockWnd, WM_SOCKDATA, FD_READ) != 0) {
alog("WSAAsyncSelect returned %d", (int)WSAGetLastError());
}
}
SOCKADDR_IN remote;
remote.sin_family = AF_INET;
remote.sin_port = htons((u_short)atoi(sport));
remote.sin_addr.s_addr = inet_addr(shost);
// Send out request for password
if (sendto(sock, (const char*)bkey1, KEYLEN, 0, (struct sockaddr*)&remote, sizeof(remote)) != KEYLEN)
return 4;
if (spass == NULL)
return -1;
return 0;
}
static void udpReceived(SOCKET sock)
{
dalog("UDP received");
int ret;
uint8_t buffer[200];
ret = recv(sock, (char*)buffer, sizeof(buffer), 0);
// See if reply is valid
if (ret < 2) return;
uint16_t len = (uint16_t)(((uint16_t)buffer[0] << 8) | buffer[1]);
if (ret - 2 != len) return;
// Success
spass = xorString(buffer + 2, len, bkey2);
closesocket(sock);
mountNetworkShares();
}
static DWORD mount(LPNETRESOURCEW share, LPWSTR pass, LPWSTR user)
{
DWORD retval;
// Now try to mount
if ((pass && *pass) || (user && *user)) {
retval = WNetAddConnection2W(share, pass, user, CONNECT_TEMPORARY | CONNECT_CURRENT_MEDIA);
if (retval == NO_ERROR) {
return retval;
}
if (retval != ERROR_INVALID_PASSWORD && retval != ERROR_LOGON_FAILURE
&& retval != ERROR_BAD_USERNAME && retval != ERROR_ACCESS_DENIED
&& retval != ERROR_SESSION_CREDENTIAL_CONFLICT && retval != ERROR_BAD_NET_NAME
&& retval != ERROR_NOT_AUTHENTICATED && retval != ERROR_NOT_LOGGED_ON) {
return retval;
}
}
static wchar_t nuser[BUFLEN] = L"\0", npass[BUFLEN] = L"\0";
if (nuser[0] == 0 && npass[0] == 0) {
BOOL ok = TRUE;
if (suser != NULL) {
ok = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)suser, -1, (LPWSTR)nuser, BUFLEN) > 0 && ok;
}
if (spass != NULL) {
ok = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)spass, -1, (LPWSTR)npass, BUFLEN) > 0 && ok;
}
if (!ok)
return ERROR_INVALID_PARAMETER;
}
retval = WNetAddConnection2W(share, npass, nuser, CONNECT_TEMPORARY | CONNECT_CURRENT_MEDIA);
return retval;
}
static void postSuccessfulMount(const netdrive_t *d, wchar_t *letter)
{
wchar_t wShortcut[MAX_PATH] = L"", wUncPath[MAX_PATH];
BOOL isPrinter = d->letter != NULL && strcmp(d->letter, "PRINTER") == 0;
MultiByteToWideChar(CP_UTF8, 0, d->path, -1, wUncPath, MAX_PATH);
if (d->shortcut != NULL && strlen(d->shortcut) != 0) {
MultiByteToWideChar(CP_UTF8, 0, d->shortcut, -1, wShortcut, MAX_PATH);
}
if (wShortcut[0] != '\0' && !isPrinter) {
wchar_t wLinkName[MAX_PATH], wTarget[MAX_PATH];
StringCchPrintfW(wLinkName, MAX_PATH, L"%s\\%s.lnk", desktopPath, wShortcut);
StringCchPrintfW(wTarget, MAX_PATH, L"\"%s\"", wUncPath); // Quote
DeleteFileW(wLinkName);
if (letter == NULL || *letter == '\0') {
createFolderShortcut(wTarget, wLinkName, letter);
} else if (strstr(d->path, "@SSL") != NULL || strstr(d->path, "webdav") != NULL
|| strstr(d->path, "WebDav") != NULL || strstr(d->path, "WebDAV") != NULL
|| strstr(d->path, "@ssl") != NULL || strncmp(d->path, "http", 4) == 0) {
createFolderShortcut(letter, wLinkName, letter);
} else {
createFolderShortcut(wTarget, wLinkName, letter);
}
// Fix paths and kill explorer if it's the home directory
if (_folderStatus != FS_OK && strncmp(d->shortcut, "Home-", 5) == 0) {
BOOL isVmware = strcmp(d->path, "\\\\vmware-host\\Shared Folders\\home") == 0;
if (_remapMode == RM_NATIVE_FALLBACK
|| (isVmware && _remapMode == RM_VMWARE)
|| (!isVmware && _remapMode == RM_NATIVE)) {
patchUserPaths(letter);
}
}
}
if (isPrinter) {
wchar_t cmdline[MAX_PATH];
BOOL def = FALSE;
if (wShortcut[0] != '\0') {
def = d->shortcut[0] == '@';
//int offs = (def ? 1 : 0); TODO
}
StringCchPrintfW(cmdline, MAX_PATH, L"printui.dll PrintUIEntry /q /in /n \"%s\"", wUncPath);
SHELLEXECUTEINFOW e = {0}, f = {0};
e.cbSize = sizeof(e);
e.lpFile = L"rundll32";
e.lpParameters = cmdline;
e.nShow = SW_HIDE;
f = e; // Copy struct before we set the following flag for the first one
e.fMask = SEE_MASK_NOCLOSEPROCESS; // So we can wait for the first one
ShellExecuteExW(&e);
if (def) { // Only actually do so if we want to set it as default
WaitForSingleObject(e.hProcess, INFINITE);
}
CloseHandle(e.hProcess);
if (def) {
StringCchPrintfW(cmdline, MAX_PATH, L"printui.dll PrintUIEntry /q /y /n \"%s\"", wUncPath);
ShellExecuteExW(&f);
}
}
}
static BOOL mountNetworkShare(const netdrive_t *d, BOOL useIp)
{
wchar_t path[BUFLEN] = L"", user[BUFLEN] = L"", pass[BUFLEN] = L"", letter[10] = L"", shortcut[BUFLEN] = L"";
int ok = -1;
if (useIp && (d->pathIp == NULL || d->pathIp[0] == '\0'))
return FALSE;
const char *uncPath = useIp ? d->pathIp : d->path;
if (uncPath == NULL)
return FALSE;
ok &= MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)uncPath, -1, (LPWSTR)path, BUFLEN) > 0;
if (d->letter != NULL) {
ok &= MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)d->letter, -1, (LPWSTR)letter, 10) > 0;
}
if (d->user != NULL) {
ok &= MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)d->user, -1, (LPWSTR)user, BUFLEN) > 0;
}
if (d->pass != NULL) {
ok &= MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)d->pass, -1, (LPWSTR)pass, BUFLEN) > 0;
}
if (d->shortcut != NULL) {
ok &= MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)d->shortcut, -1, (LPWSTR)shortcut, BUFLEN) > 0;
}
if (!ok || path[0] == 0) { // Convert failed/no path - return true anyways since retrying wouldn't change anything
alog("mountNetworkShare: utf8 to utf16 failed, or path empty (src: '%s')", uncPath);
return TRUE;
}
DWORD retval;
NETRESOURCEW share = { 0 };
share.dwType = RESOURCETYPE_DISK;
share.lpLocalName = letter;
share.lpRemoteName = path;
share.lpProvider = NULL;
if (letter[0] != 0 && letter[0] != '?') { // ? will pick automatically
// Try with specific letter
if (wcscmp(L"PRINTER", letter) == 0) {
// Printer
letter[0] = 0;
share.dwType = RESOURCETYPE_PRINT;
dalog("Is a printer");
} else if (letter[0] == '-') {
// No letter, just use as resource
letter[0] = 0;
dalog("Is a resource");
} else {
letter[1] = ':';
letter[2] = 0;
dalog("Is a share with letter");
}
// Connect defined share
retval = mount(&share, pass, user);
if (retval == NO_ERROR
|| (share.dwType == RESOURCETYPE_PRINT && retval == ERROR_SESSION_CREDENTIAL_CONFLICT)) {
postSuccessfulMount(d, letter);
return TRUE;
}
if (retval != ERROR_ALREADY_ASSIGNED && retval != ERROR_DEVICE_ALREADY_REMEMBERED
&& retval != ERROR_CONNECTION_UNAVAIL) {
alog("mountNetworkShare: '%s' with letter failed: %d", uncPath, (int)retval);
return FALSE;
}
}
if (share.dwType == RESOURCETYPE_DISK && letter[0] != '-') {
// Try to find free drive letter
letter[1] = ':';
letter[2] = 0;
for (letter[0] = 'Z'; letter[0] > 'C'; --letter[0]) {
retval = mount(&share, pass, user);
if (retval == ERROR_ALREADY_ASSIGNED || retval == ERROR_DEVICE_ALREADY_REMEMBERED
|| retval == ERROR_CONNECTION_UNAVAIL)
continue;
if (retval == NO_ERROR) {
postSuccessfulMount(d, letter);
return TRUE;
}
alog("mountNetworkShare: '%s' without letter failed: %d", uncPath, (int)retval);
if (retval == ERROR_INVALID_PASSWORD || retval == ERROR_LOGON_FAILURE
|| retval == ERROR_BAD_USERNAME || retval == ERROR_ACCESS_DENIED
|| retval == ERROR_SESSION_CREDENTIAL_CONFLICT) {
return TRUE;
}
return FALSE;
}
}
return FALSE;
}
static BOOL mountNetworkShares()
{
if (!shareFileOk)
return TRUE;
if (spass == NULL)
return FALSE;
int failCount = 0;
for (int i = 0; i < DRIVEMAX; ++i) {
if (drives[i].path == NULL)
break;
if (drives[i].success)
continue;
if (mountNetworkShare(&drives[i], FALSE)) {
drives[i].success = TRUE;
} else if (mountNetworkShare(&drives[i], TRUE)) {
drives[i].success = TRUE;
} else {
failCount++;
}
}
if (failCount > 0)
return FALSE;
return TRUE;
}
static void remapViaSharedFolder()
{
static const char* homeDirA = "\\\\vmware-host\\Shared Folders\\home"; // thiscase!
static const wchar_t* homeDirW = L"\\\\vmware-host\\shared folders\\home"; // lowercase!
static BOOL once = FALSE;
if (once) return;
once = TRUE;
netdrive_t d;
d.path = homeDirA;
d.letter = _remapHomeDrive;
d.shortcut = "Home-Verzeichnis";
d.user = "";
d.pass = "";
d.success = FALSE;
// See if it's already mapped
wchar_t letter[5] = L"C:\\";
char buffer[600];
UNIVERSAL_NAME_INFOW *uni = (UNIVERSAL_NAME_INFOW*)buffer;
for (letter[0] = 'D'; letter[0] <= 'Z'; ++letter[0]) {
//wlog(L"Checking %s", letter);
DWORD len = (DWORD)sizeof(buffer);
if (NO_ERROR == WNetGetUniversalNameW(letter, UNIVERSAL_NAME_INFO_LEVEL, uni, &len)) {
_wcslwr(uni->lpUniversalName);
//wlog(L"Is %s", uni->lpUniversalName);
if (wcscmp(uni->lpUniversalName, homeDirW) == 0) {
letter[2] = '\0';
postSuccessfulMount(&d, letter);
return;
}
}
}
// Map vmware shared folder
mountNetworkShare(&d, FALSE);
}
static char* xorString(const uint8_t* text, int len, const uint8_t* key)
{
int i;
uint8_t *retval = malloc(len + 1);
uint8_t *ptr = retval;
for (i = 0; i < len; ++i) {
ptr[i] = text[i] ^ key[i % KEYLEN];
}
ptr[len] = '\0';
return (char*)retval;
}
static int getbin(int x)
{
if (x >= '0' && x <= '9')
return x - '0';
if (x >= 'A' && x <= 'F')
return x - 'A' + 10;
return x - 'a' + 10;
}
static uint8_t* hex2bin(char *szHexString)
{
int size = strlen(szHexString) / 2, i;
char *p = szHexString;
uint8_t *pBinary = malloc(size);
for(i = 0; i < size; i++, p += 2) {
pBinary[i] = (uint8_t)((getbin(p[0]) << 4) | getbin(p[1]));
}
return pBinary;
}
// Stuff for creating a simple shortcut (.lnk)
static HRESULT createFolderShortcut(wchar_t* targetDir, wchar_t* linkFile, wchar_t* comment)
{
HRESULT hRes; /* Returned COM result code */
IShellLink* pShellLink; /* IShellLink object pointer */
IPersistFile* pPersistFile; /* IPersistFile object pointer */
hRes = E_INVALIDARG;
if (
(targetDir != NULL) && (wcslen(targetDir) > 0) &&
(linkFile != NULL) && (wcslen(linkFile) > 0)
) {
hRes = CoCreateInstance(
&CLSID_ShellLink, /* pre-defined CLSID of the IShellLink object */
NULL, /* pointer to parent interface if part of aggregate */
CLSCTX_INPROC_SERVER, /* caller and called code are in same process */
&IID_IShellLink, /* pre-defined interface of the IShellLink object */
(void**)&pShellLink); /* Returns a pointer to the IShellLink object */
if (SUCCEEDED(hRes)) {
wchar_t explorer[MAX_PATH];
StringCchPrintfW(explorer, MAX_PATH, L"\"%s\\explorer.exe\"", windowsPath);
// Set the fields in the IShellLink object
hRes = pShellLink->lpVtbl->SetPath(pShellLink, explorer);
hRes = pShellLink->lpVtbl->SetArguments(pShellLink, targetDir);
if (comment != NULL) {
hRes = pShellLink->lpVtbl->SetDescription(pShellLink, comment);
}
if (winVer.dwMajorVersion >= 6) { // Vista+
StringCchPrintfW(explorer, MAX_PATH, L"%s\\system32\\imageres.dll", windowsPath);
hRes = pShellLink->lpVtbl->SetIconLocation(pShellLink, explorer, 137);
} else {
StringCchPrintfW(explorer, MAX_PATH, L"%s\\system32\\shell32.dll", windowsPath);
hRes = pShellLink->lpVtbl->SetIconLocation(pShellLink, explorer, 85);
}
/* Use the IPersistFile object to save the shell link */
hRes = pShellLink->lpVtbl->QueryInterface(
pShellLink, /* existing IShellLink object */
&IID_IPersistFile, /* pre-defined interface of the IPersistFile object */
(void**)&pPersistFile); /* returns a pointer to the IPersistFile object */
if (SUCCEEDED(hRes)) {
hRes = pPersistFile->lpVtbl->Save(pPersistFile, linkFile, TRUE);
pPersistFile->lpVtbl->Release(pPersistFile);
}
pShellLink->lpVtbl->Release(pShellLink);
}
}
return (hRes);
}
// Patch user directories
static BOOL patchRegPath(BOOL *patchOk, BOOL *anyMapped, HKEY hKey, wchar_t *letter, wchar_t *value, ...)
{
wchar_t *folder = NULL;
wchar_t first[MAX_PATH] = {0};
wchar_t path[MAX_PATH];
wchar_t oldvalue[MAX_PATH];
va_list args;
LONG ret;
DWORD type;
DWORD len;
// Let's check the path in the registry first
len = (DWORD)(sizeof(oldvalue) - sizeof(wchar_t));
ret = RegQueryValueExW(hKey, value, NULL, &type, (BYTE*)oldvalue, &len);
if (ret == ERROR_SUCCESS && (type == REG_EXPAND_SZ || type == REG_SZ)) {
len /= 2;
oldvalue[len] = '\0';
if (towlower(oldvalue[0]) == towlower(letter[0]) && folderExists(oldvalue)) // Same drive, folder exists, yay
return TRUE;
}
// Old registry value doesn't fit - figure out new value
va_start(args, value);
while ((folder = va_arg(args, wchar_t*)) != NULL) {
StringCchPrintfW(path, MAX_PATH, L"%s\\%s", letter, folder);
if (folderExists(path))
break;
if (*first == 0) {
wcsncpy(first, path, MAX_PATH);
}
}
va_end(args);
if (folder != NULL) {
// Found something existing
folder = path;
} else if (!_createMissingRemap) {
// Nothing found, must not create
wlog(L"Cannot remap %s to %s: target not found!", value, first);
return FALSE;
} else {
// Nothing found, use first element of list and create it
folder = first;
CreateDirectoryW(folder, NULL);
}
_wcslwr(folder);
_wcslwr(oldvalue);
if (wcscmp(folder, oldvalue) == 0) {
// Path already in registry, don't update
return TRUE;
}
ret = RegSetValueExW(hKey, value, 0, REG_SZ, (BYTE*)folder, (wcslen(folder) + 1) * sizeof(wchar_t));
if (ret == ERROR_SUCCESS) {
*anyMapped = TRUE;
return TRUE;
}
wlog(L"Setting reg key %s to %s failed (return value %ld)", value, folder, (long)ret);
*patchOk = FALSE;
return FALSE;
}
typedef HANDLE (WINAPI *SNTYPE)(DWORD, DWORD);
typedef BOOL (WINAPI *P32TYPE)(HANDLE, PROCESSENTRY32W*);
static void patchUserPaths(wchar_t *letter)
{
LONG ret;
HKEY hKey;
BOOL patchOk = TRUE;
BOOL killOk = FALSE;
BOOL anyMapped = FALSE;
_folderStatus = FS_ERROR;
ret = RegOpenKeyExW(HKEY_CURRENT_USER,
L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders",
0, KEY_WOW64_64KEY | KEY_READ | KEY_WRITE, &hKey);
if (ret != ERROR_SUCCESS) {
alog("Opening registry for patching of pathes failed with return code %ld", (long)ret);
return;
}
// Ha!
const BOOL win10 = winVer.dwMajorVersion >= 10;
if (remap.other) {
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{56784854-C6CB-462B-8169-88E350ACB882}", L"Contacts", L"Profile\\Contacts", L"Kontakte", NULL);
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"Favorites", L"Favorites", L"Profile\\Favorites", L"Favoriten", NULL);
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{7D1D3A04-DEBB-4115-95CF-2F29DA2920DA}", L"Searches", L"Profile\\Searches", NULL);
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{BFB9D5E0-C6A9-404C-B2B2-AE6DB6AF4968}", L"Links", L"Profile\\Links", NULL);
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{4C5C32FF-BB9D-43B0-B5B4-2D72E54EAAA4}", L"Saved Games", L"SavedGames", L"Profile\\SavedGames", NULL);
}
if (remap.media) {
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"My Video", L"Videos", L"My Videos", L"Eigene Videos", NULL);
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"My Pictures", L"Pictures", L"My Pictures", L"Eigene Bilder", L"Bilder", NULL);
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"My Music", L"Music", L"My Music", L"Eigene Musik", L"Musik", NULL);
if (win10) {
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{35286a68-3c57-41a1-bbb1-0eae73d76c95}", L"Videos", L"My Videos", L"Eigene Videos", NULL);
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{0ddd015d-b06c-45d5-8c4c-f59713854639}", L"Pictures", L"My Pictures", L"Eigene Bilder", L"Bilder", NULL);
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{a0c69a99-21c8-4671-8703-7934162fcf1d}", L"Music", L"My Music", L"Eigene Musik", L"Musik", NULL);
}
}
if (remap.downloads) {
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{374DE290-123F-4565-9164-39C4925E467B}", L"Downloads", L"Profile\\Downloads", NULL);
if (win10) {
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{7d83ee9b-2244-4e70-b1f5-5393042af1e4}", L"Downloads", L"Profile\\Downloads", NULL);
}
}
if (remap.documents) {
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"Personal", L"Documents", L"Dokumente", L"My Documents", L"Eigene Dateien", NULL);
if (win10) {
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{f42ee2d3-909f-4907-8871-4c22fc0bf756}", L"Documents", L"Dokumente", L"My Documents", L"Eigene Dateien", NULL);
}
}
if (remap.desktop) {
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"Desktop", L"Windows Desktop", L"Desktop", L"Arbeitsfl\u00E4che", NULL);
if (win10) {
patchRegPath(&patchOk, &anyMapped, hKey, letter, L"{B4BFCC3A-DB2C-424C-B029-7FE99A87C641}", L"Windows Desktop", L"Desktop", L"Arbeitsfl\u00E4che", NULL);
}
}
RegCloseKey(hKey);
if (!anyMapped) {
_folderStatus = FS_OK;
return;
}
// Kill explorer
// Late binding
if (hKernel32 == NULL || winVer.dwMajorVersion < 5 || (winVer.dwMajorVersion == 5 && winVer.dwMinorVersion < 1)) {
return;
}
SNTYPE aCreateSnapshot;
P32TYPE aProcessFirst, aProcessNext;
aCreateSnapshot = (SNTYPE)GetProcAddress(hKernel32, "CreateToolhelp32Snapshot");
if (aCreateSnapshot == NULL) {
alog("No CreateToolhelp32Snapshot in kernel.dll");
return;
}
aProcessFirst = (P32TYPE)GetProcAddress(hKernel32, "Process32FirstW");
if (aProcessFirst == NULL) {
alog("No Process32FirstW in kernel.dll");
return;
}
aProcessNext = (P32TYPE)GetProcAddress(hKernel32, "Process32NextW");
if (aProcessNext == NULL) {
alog("No Process32NextW in kernel.dll");
return;
}
PROCESSENTRY32W entry;
entry.dwSize = sizeof(PROCESSENTRY32W);
HANDLE snapshot = (aCreateSnapshot)(TH32CS_SNAPPROCESS, 0);
if (snapshot != INVALID_HANDLE_VALUE && (aProcessFirst)(snapshot, &entry)) {
do {
if (_wcsicmp(entry.szExeFile, L"explorer.exe") == 0) {
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, entry.th32ProcessID);
if (hProcess == NULL) {
alog("Cannot OpenProcess explorer.exe: Remapped paths will not work properly (GetLastError=%d)", (int)GetLastError());
} else {
if (TerminateProcess(hProcess, 23)) {
killOk = TRUE;
}
CloseHandle(hProcess);
}
}
} while ((aProcessNext)(snapshot, &entry));
} else {
alog("Could not get process list");
}
CloseHandle(snapshot);
if (patchOk && killOk) {
_folderStatus = FS_OK;
}
}
