diff options
Diffstat (limited to 'src/VBox/Runtime/r3/win')
68 files changed, 24635 insertions, 0 deletions
diff --git a/src/VBox/Runtime/r3/win/Makefile.kup b/src/VBox/Runtime/r3/win/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/Runtime/r3/win/Makefile.kup diff --git a/src/VBox/Runtime/r3/win/RTCrStoreCreateSnapshotById-win.cpp b/src/VBox/Runtime/r3/win/RTCrStoreCreateSnapshotById-win.cpp new file mode 100644 index 00000000..81481067 --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTCrStoreCreateSnapshotById-win.cpp @@ -0,0 +1,169 @@ +/* $Id: RTCrStoreCreateSnapshotById-win.cpp $ */ +/** @file + * IPRT - RTCrStoreCreateSnapshotById, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/crypto/store.h> +#include "internal/iprt.h" + +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/once.h> +#include <iprt/ldr.h> + +#include <iprt/win/windows.h> + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef HCERTSTORE (WINAPI *PFNCERTOPENSTORE)(PCSTR pszStoreProvider, DWORD dwEncodingType, HCRYPTPROV_LEGACY hCryptProv, + DWORD dwFlags, const void *pvParam); +typedef BOOL (WINAPI *PFNCERTCLOSESTORE)(HCERTSTORE hCertStore, DWORD dwFlags); +typedef PCCERT_CONTEXT (WINAPI *PFNCERTENUMCERTIFICATESINSTORE)(HCERTSTORE hCertStore, PCCERT_CONTEXT pPrevCertContext); + + + +static int rtCrStoreAddCertsFromNative(RTCRSTORE hStore, DWORD fStore, PCRTUTF16 pwszStoreName, + PFNCERTOPENSTORE pfnOpenStore, PFNCERTCLOSESTORE pfnCloseStore, + PFNCERTENUMCERTIFICATESINSTORE pfnEnumCerts, int rc, PRTERRINFO pErrInfo) +{ + DWORD fOpenStore = CERT_STORE_OPEN_EXISTING_FLAG | CERT_STORE_READONLY_FLAG; + HCERTSTORE hNativeStore = pfnOpenStore(CERT_STORE_PROV_SYSTEM_W, PKCS_7_ASN_ENCODING | X509_ASN_ENCODING, + NULL /* hCryptProv = default */, fStore | fOpenStore, pwszStoreName); + if (hStore) + { + PCCERT_CONTEXT pCurCtx = NULL; + while ((pCurCtx = pfnEnumCerts(hNativeStore, pCurCtx)) != NULL) + { + if (pCurCtx->dwCertEncodingType & X509_ASN_ENCODING) + { + RTERRINFOSTATIC StaticErrInfo; + RTASN1CURSORPRIMARY PrimaryCursor; + RTAsn1CursorInitPrimary(&PrimaryCursor, pCurCtx->pbCertEncoded, pCurCtx->cbCertEncoded, + RTErrInfoInitStatic(&StaticErrInfo), + &g_RTAsn1DefaultAllocator, RTASN1CURSOR_FLAGS_DER, "CurCtx"); + RTCRX509CERTIFICATE MyCert; + int rc2 = RTCrX509Certificate_DecodeAsn1(&PrimaryCursor.Cursor, 0, &MyCert, "Cert"); + if (RT_SUCCESS(rc2)) + { + rc2 = RTCrStoreCertAddEncoded(hStore, RTCRCERTCTX_F_ENC_X509_DER | RTCRCERTCTX_F_ADD_IF_NOT_FOUND, + pCurCtx->pbCertEncoded, pCurCtx->cbCertEncoded, + RTErrInfoInitStatic(&StaticErrInfo)); + RTCrX509Certificate_Delete(&MyCert); + } + if (RT_FAILURE(rc2)) + { + if (RTErrInfoIsSet(&StaticErrInfo.Core)) + RTErrInfoAddF(pErrInfo, -rc2, " %s", StaticErrInfo.Core.pszMsg); + else + RTErrInfoAddF(pErrInfo, -rc2, " %Rrc adding cert", rc2); + rc = -rc2; + } + } + } + pfnCloseStore(hNativeStore, CERT_CLOSE_STORE_CHECK_FLAG); + } + else + { + DWORD uLastErr = GetLastError(); + if (uLastErr != ERROR_FILE_NOT_FOUND) + rc = RTErrInfoAddF(pErrInfo, -RTErrConvertFromWin32(uLastErr), + " CertOpenStore(%#x,'%ls') failed: %u", fStore, pwszStoreName); + } + return rc; +} + + + +RTDECL(int) RTCrStoreCreateSnapshotById(PRTCRSTORE phStore, RTCRSTOREID enmStoreId, PRTERRINFO pErrInfo) +{ + AssertReturn(enmStoreId > RTCRSTOREID_INVALID && enmStoreId < RTCRSTOREID_END, VERR_INVALID_PARAMETER); + + /* + * Create an empty in-memory store. + */ + RTCRSTORE hStore; + int rc = RTCrStoreCreateInMem(&hStore, 128); + if (RT_SUCCESS(rc)) + { + *phStore = hStore; + + /* + * Resolve the APIs we need to do this job. + */ + RTLDRMOD hLdrMod; + int rc2 = RTLdrLoadSystem("crypt32.dll", false /*NoUnload*/, &hLdrMod); + if (RT_SUCCESS(rc2)) + { + PFNCERTOPENSTORE pfnOpenStore = NULL; + rc2 = RTLdrGetSymbol(hLdrMod, "CertOpenStore", (void **)&pfnOpenStore); + + PFNCERTCLOSESTORE pfnCloseStore = NULL; + if (RT_SUCCESS(rc2)) + rc2 = RTLdrGetSymbol(hLdrMod, "CertCloseStore", (void **)&pfnCloseStore); + + PFNCERTENUMCERTIFICATESINSTORE pfnEnumCerts = NULL; + if (RT_SUCCESS(rc2)) + rc2 = RTLdrGetSymbol(hLdrMod, "CertEnumCertificatesInStore", (void **)&pfnEnumCerts); + if (RT_SUCCESS(rc2)) + { + /* + * Do the work. + */ + switch (enmStoreId) + { + case RTCRSTOREID_USER_TRUSTED_CAS_AND_CERTIFICATES: + case RTCRSTOREID_SYSTEM_TRUSTED_CAS_AND_CERTIFICATES: + { + DWORD fStore = enmStoreId == RTCRSTOREID_USER_TRUSTED_CAS_AND_CERTIFICATES + ? CERT_SYSTEM_STORE_CURRENT_USER : CERT_SYSTEM_STORE_LOCAL_MACHINE; + static PCRTUTF16 const s_apwszStores[] = { L"AuthRoot", L"CA", L"MY", L"Root" }; + for (uint32_t i = 0; i < RT_ELEMENTS(s_apwszStores); i++) + rc = rtCrStoreAddCertsFromNative(hStore, fStore, s_apwszStores[i], pfnOpenStore, pfnCloseStore, + pfnEnumCerts, rc, pErrInfo); + break; + } + + default: + AssertFailed(); /* implement me */ + } + } + else + rc = RTErrInfoSetF(pErrInfo, -rc2, "Error resolving crypt32.dll APIs"); + RTLdrClose(hLdrMod); + } + else + rc = RTErrInfoSetF(pErrInfo, -rc2, "Error loading crypt32.dll"); + } + else + RTErrInfoSet(pErrInfo, rc, "RTCrStoreCreateInMem failed"); + return rc; +} +RT_EXPORT_SYMBOL(RTCrStoreCreateSnapshotById); + diff --git a/src/VBox/Runtime/r3/win/RTHandleGetStandard-win.cpp b/src/VBox/Runtime/r3/win/RTHandleGetStandard-win.cpp new file mode 100644 index 00000000..7a182859 --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTHandleGetStandard-win.cpp @@ -0,0 +1,126 @@ +/* $Id: RTHandleGetStandard-win.cpp $ */ +/** @file + * IPRT - RTHandleGetStandard, Windows. + */ + +/* + * Copyright (C) 2010-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "internal/iprt.h" +#include <iprt/handle.h> + +#include <iprt/file.h> +#include <iprt/pipe.h> +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/log.h> + +#include <iprt/win/windows.h> + +#include "internal/socket.h" /* (Needs Windows.h.) */ + + +RTDECL(int) RTHandleGetStandard(RTHANDLESTD enmStdHandle, PRTHANDLE ph) +{ + /* + * Validate and convert input. + */ + AssertPtrReturn(ph, VERR_INVALID_POINTER); + DWORD dwStdHandle; + switch (enmStdHandle) + { + case RTHANDLESTD_INPUT: dwStdHandle = STD_INPUT_HANDLE; break; + case RTHANDLESTD_OUTPUT: dwStdHandle = STD_OUTPUT_HANDLE; break; + case RTHANDLESTD_ERROR: dwStdHandle = STD_ERROR_HANDLE; break; + default: + AssertFailedReturn(VERR_INVALID_PARAMETER); + } + + /* + * Is the requested descriptor valid and which IPRT handle type does it + * best map on to? + */ + HANDLE hNative = GetStdHandle(dwStdHandle); + if (hNative == INVALID_HANDLE_VALUE) + return RTErrConvertFromWin32(GetLastError()); + + DWORD dwInfo; + if (!GetHandleInformation(hNative, &dwInfo)) + return RTErrConvertFromWin32(GetLastError()); + bool const fInherit = RT_BOOL(dwInfo & HANDLE_FLAG_INHERIT); + + RTHANDLE h; + DWORD dwType = GetFileType(hNative); + switch (dwType & ~FILE_TYPE_REMOTE) + { + default: + case FILE_TYPE_UNKNOWN: + case FILE_TYPE_CHAR: + case FILE_TYPE_DISK: + h.enmType = RTHANDLETYPE_FILE; + break; + + case FILE_TYPE_PIPE: + { + DWORD cMaxInstances; + DWORD fInfo; + if (!GetNamedPipeInfo(hNative, &fInfo, NULL, NULL, &cMaxInstances)) + h.enmType = RTHANDLETYPE_SOCKET; + else + h.enmType = RTHANDLETYPE_PIPE; + break; + } + } + + /* + * Create the IPRT handle. + */ + int rc; + switch (h.enmType) + { + case RTHANDLETYPE_FILE: + rc = RTFileFromNative(&h.u.hFile, (RTHCUINTPTR)hNative); + break; + + case RTHANDLETYPE_PIPE: + rc = RTPipeFromNative(&h.u.hPipe, (RTHCUINTPTR)hNative, + (enmStdHandle == RTHANDLESTD_INPUT ? RTPIPE_N_READ : RTPIPE_N_WRITE) + | (fInherit ? RTPIPE_N_INHERIT : 0)); + break; + + case RTHANDLETYPE_SOCKET: + rc = rtSocketCreateForNative(&h.u.hSocket, (RTHCUINTPTR)hNative); + break; + + default: /* shut up gcc */ + return VERR_INTERNAL_ERROR; + } + + if (RT_SUCCESS(rc)) + *ph = h; + + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/RTLocaleQueryNormalizedBaseLocaleName-win.cpp b/src/VBox/Runtime/r3/win/RTLocaleQueryNormalizedBaseLocaleName-win.cpp new file mode 100644 index 00000000..01dda14b --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTLocaleQueryNormalizedBaseLocaleName-win.cpp @@ -0,0 +1,106 @@ +/* $Id: RTLocaleQueryNormalizedBaseLocaleName-win.cpp $ */ +/** @file + * IPRT - RTLocaleQueryNormalizedBaseLocaleName, ring-3, Windows. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/windows.h> + +#include <iprt/locale.h> +#include "internal/iprt.h" + +#include <iprt/ctype.h> +#include <iprt/errcore.h> +#include <iprt/string.h> + + +RTDECL(int) RTLocaleQueryNormalizedBaseLocaleName(char *pszName, size_t cbName) +{ + /* + * Note! This part is duplicate of r3/generic/RTLocaleQueryNormalizedBaseLocaleName-r3-generic.cpp! + */ + char szLocale[_1K]; + int rc = RTLocaleQueryLocaleName(szLocale, sizeof(szLocale)); + if (RT_SUCCESS(rc)) + { + /* + * May return some complicated "LC_XXX=yyy;LC.." sequence if + * partially set (like IPRT does). Try get xx_YY sequence first + * because 'C' or 'POSIX' may be LC_xxx variants that haven't been + * set yet. + * + * ASSUMES complicated locale mangling is done in a certain way... + */ + const char *pszLocale = strchr(szLocale, '='); + if (!pszLocale) + pszLocale = szLocale; + else + pszLocale++; + bool fSeenC = false; + bool fSeenPOSIX = false; + do + { + const char *pszEnd = strchr(pszLocale, ';'); + + if ( RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(pszLocale) + && ( pszLocale[5] == '\0' + || RT_C_IS_PUNCT(pszLocale[5])) ) + return RTStrCopyEx(pszName, cbName, pszLocale, 5); + + if ( pszLocale[0] == 'C' + && ( pszLocale[1] == '\0' + || RT_C_IS_PUNCT(pszLocale[1])) ) + fSeenC = true; + else if ( strncmp(pszLocale, "POSIX", 5) == 0 + && ( pszLocale[5] == '\0' + || RT_C_IS_PUNCT(pszLocale[5])) ) + fSeenPOSIX = true; + + /* advance */ + pszLocale = pszEnd ? strchr(pszEnd + 1, '=') : NULL; + } while (pszLocale++); + + if (fSeenC || fSeenPOSIX) + return RTStrCopy(pszName, cbName, "C"); /* C and POSIX should be identical IIRC, so keep it simple. */ + + rc = VERR_NOT_AVAILABLE; + } + + /* + * Fallback. + */ + if ( GetLocaleInfoA(GetUserDefaultLCID(), LOCALE_SISO639LANGNAME, szLocale, sizeof(szLocale)) == 3 + && GetLocaleInfoA(GetUserDefaultLCID(), LOCALE_SISO3166CTRYNAME, &szLocale[3], sizeof(szLocale) - 4) == 3) + { + szLocale[2] = '_'; + Assert(RTLOCALE_IS_LANGUAGE2_UNDERSCORE_COUNTRY2(szLocale)); + return RTStrCopy(pszName, cbName, szLocale); + } + + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/RTLocaleQueryUserCountryCode-win.cpp b/src/VBox/Runtime/r3/win/RTLocaleQueryUserCountryCode-win.cpp new file mode 100644 index 00000000..09ae2e3e --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTLocaleQueryUserCountryCode-win.cpp @@ -0,0 +1,119 @@ +/* $Id: RTLocaleQueryUserCountryCode-win.cpp $ */ +/** @file + * IPRT - RTLocaleQueryUserCountryCode, ring-3, Windows. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/windows.h> + +#include <iprt/locale.h> +#include "internal/iprt.h" + +#include <iprt/ctype.h> +#include <iprt/errcore.h> +#include <iprt/string.h> + +#include "internal-r3-win.h" + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef GEOID (WINAPI *PFNGETUSERGEOID)(GEOCLASS); +typedef INT (WINAPI *PFNGETGEOINFOW)(GEOID,GEOTYPE,LPWSTR,INT,LANGID); + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Pointer to GetUserGeoID. */ +static PFNGETUSERGEOID g_pfnGetUserGeoID = NULL; +/** Pointer to GetGeoInfoW. */ +static PFNGETGEOINFOW g_pfnGetGeoInfoW = NULL; +/** Set if we've tried to resolve the APIs. */ +static bool volatile g_fResolvedApis = false; + + +RTDECL(int) RTLocaleQueryUserCountryCode(char pszCountryCode[3]) +{ + /* + * Get API pointers. + */ + PFNGETUSERGEOID pfnGetUserGeoID; + PFNGETGEOINFOW pfnGetGeoInfoW; + if (g_fResolvedApis) + { + pfnGetUserGeoID = g_pfnGetUserGeoID; + pfnGetGeoInfoW = g_pfnGetGeoInfoW; + } + else + { + pfnGetUserGeoID = (PFNGETUSERGEOID)GetProcAddress(g_hModKernel32, "GetUserGeoID"); + pfnGetGeoInfoW = (PFNGETGEOINFOW)GetProcAddress(g_hModKernel32, "GetGeoInfoW"); + g_pfnGetUserGeoID = pfnGetUserGeoID; + g_pfnGetGeoInfoW = pfnGetGeoInfoW; + g_fResolvedApis = true; + } + + int rc; + if ( pfnGetGeoInfoW + && pfnGetUserGeoID) + { + /* + * Call the API and retrieve the two letter ISO country code. + */ + GEOID idGeo = pfnGetUserGeoID(GEOCLASS_NATION); + if (idGeo != GEOID_NOT_AVAILABLE) + { + RTUTF16 wszName[16]; + RT_ZERO(wszName); + DWORD cwcReturned = pfnGetGeoInfoW(idGeo, GEO_ISO2, wszName, RT_ELEMENTS(wszName), LOCALE_NEUTRAL); + if ( cwcReturned >= 2 + && cwcReturned <= 3 + && wszName[2] == '\0' + && wszName[1] != '\0' + && RT_C_IS_ALPHA(wszName[1]) + && wszName[0] != '\0' + && RT_C_IS_ALPHA(wszName[0]) ) + { + pszCountryCode[0] = RT_C_TO_UPPER(wszName[0]); + pszCountryCode[1] = RT_C_TO_UPPER(wszName[1]); + pszCountryCode[2] = '\0'; + return VINF_SUCCESS; + } + AssertMsgFailed(("cwcReturned=%d err=%u wszName='%.16ls'\n", cwcReturned, GetLastError(), wszName)); + } + rc = VERR_NOT_AVAILABLE; + } + else + rc = VERR_NOT_SUPPORTED; + pszCountryCode[0] = 'Z'; + pszCountryCode[1] = 'Z'; + pszCountryCode[2] = '\0'; + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/RTLogWriteDebugger-win.cpp b/src/VBox/Runtime/r3/win/RTLogWriteDebugger-win.cpp new file mode 100644 index 00000000..ea94338a --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTLogWriteDebugger-win.cpp @@ -0,0 +1,44 @@ +/* $Id: RTLogWriteDebugger-win.cpp $ */ +/** @file + * IPRT - Log To Debugger, Win32. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/windows.h> + +#include <iprt/log.h> +#include <iprt/assert.h> + + +RTDECL(void) RTLogWriteDebugger(const char *pch, size_t cb) +{ + if (pch[cb] != '\0') + AssertBreakpoint(); + OutputDebugStringA(pch); + return; +} + diff --git a/src/VBox/Runtime/r3/win/RTSystemQueryDmiString-win.cpp b/src/VBox/Runtime/r3/win/RTSystemQueryDmiString-win.cpp new file mode 100644 index 00000000..f3e2a867 --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTSystemQueryDmiString-win.cpp @@ -0,0 +1,259 @@ +/* $Id: RTSystemQueryDmiString-win.cpp $ */ +/** @file + * IPRT - RTSystemQueryDmiString, windows ring-3. + */ + +/* + * Copyright (C) 2010-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define _WIN32_DCOM +#include <iprt/win/windows.h> +#include <WbemCli.h> + +#include <iprt/system.h> +#include "internal/iprt.h" + +#include <iprt/errcore.h> +#include <iprt/assert.h> +#include <iprt/string.h> +#include <iprt/utf16.h> + + +/** + * Initialize COM. + * + * @returns COM status code. + */ +static HRESULT rtSystemDmiWinInitialize(void) +{ + HRESULT hrc = CoInitializeEx(0, COINIT_MULTITHREADED); + if (SUCCEEDED(hrc)) + { + hrc = CoInitializeSecurity(NULL, + -1, /* COM authentication. */ + NULL, /* Which authentication services. */ + NULL, /* Reserved. */ + RPC_C_AUTHN_LEVEL_DEFAULT, /* Default authentication. */ + RPC_C_IMP_LEVEL_IMPERSONATE, /* Default impersonation. */ + NULL, /* Authentication info. */ + EOAC_NONE, /* Additional capabilities. */ + NULL); /* Reserved. */ + if (hrc == RPC_E_TOO_LATE) + hrc = S_OK; + else if (FAILED(hrc)) + CoUninitialize(); + } + return hrc; +} + + +/** + * Undo what rtSystemDmiWinInitialize did. + */ +static void rtSystemDmiWinTerminate(void) +{ + CoUninitialize(); +} + + +/** + * Convert a UTF-8 string to a BSTR. + * + * @returns BSTR pointer. + * @param psz The UTF-8 string. + */ +static BSTR rtSystemWinBstrFromUtf8(const char *psz) +{ + PRTUTF16 pwsz = NULL; + int rc = RTStrToUtf16(psz, &pwsz); + if (RT_FAILURE(rc)) + return NULL; + BSTR pBStr = SysAllocString((const OLECHAR *)pwsz); + RTUtf16Free(pwsz); + return pBStr; +} + + +/** + * Connect to the DMI server. + * + * @returns COM status code. + * @param pLocator The locator. + * @param pszServer The server name. + * @param ppServices Where to return the services interface. + */ +static HRESULT rtSystemDmiWinConnectToServer(IWbemLocator *pLocator, const char *pszServer, IWbemServices **ppServices) +{ + AssertPtr(pLocator); + AssertPtrNull(pszServer); + AssertPtr(ppServices); + + BSTR pBStrServer = rtSystemWinBstrFromUtf8(pszServer); + if (!pBStrServer) + return E_OUTOFMEMORY; + + HRESULT hrc = pLocator->ConnectServer(pBStrServer, + NULL, + NULL, + 0, + NULL, + 0, + 0, + ppServices); + if (SUCCEEDED(hrc)) + { + hrc = CoSetProxyBlanket(*ppServices, + RPC_C_AUTHN_WINNT, + RPC_C_AUTHZ_NONE, + NULL, + RPC_C_AUTHN_LEVEL_CALL, + RPC_C_IMP_LEVEL_IMPERSONATE, + NULL, + EOAC_NONE); + if (FAILED(hrc)) + (*ppServices)->Release(); + } + SysFreeString(pBStrServer); + return hrc; +} + + +RTDECL(int) RTSystemQueryDmiString(RTSYSDMISTR enmString, char *pszBuf, size_t cbBuf) +{ + AssertPtrReturn(pszBuf, VERR_INVALID_POINTER); + AssertReturn(cbBuf > 0, VERR_INVALID_PARAMETER); + *pszBuf = '\0'; + AssertReturn(enmString > RTSYSDMISTR_INVALID && enmString < RTSYSDMISTR_END, VERR_INVALID_PARAMETER); + + /* + * Figure the property name before we start. + */ + const char *pszPropName; + switch (enmString) + { + case RTSYSDMISTR_PRODUCT_NAME: pszPropName = "Name"; break; + case RTSYSDMISTR_PRODUCT_VERSION: pszPropName = "Version"; break; + case RTSYSDMISTR_PRODUCT_UUID: pszPropName = "UUID"; break; + case RTSYSDMISTR_PRODUCT_SERIAL: pszPropName = "IdentifyingNumber"; break; + case RTSYSDMISTR_MANUFACTURER: pszPropName = "Vendor"; break; + + default: + return VERR_NOT_SUPPORTED; + } + + /* + * Before we do anything with COM, we have to initialize it. + */ + bool fUninit = true; + HRESULT hrc = rtSystemDmiWinInitialize(); + if (hrc == RPC_E_CHANGED_MODE) + fUninit = false; /* don't fail if already initialized */ + else if (FAILED(hrc)) + return VERR_NOT_SUPPORTED; + + int rc = VERR_NOT_SUPPORTED; + BSTR pBstrPropName = rtSystemWinBstrFromUtf8(pszPropName); + if (pBstrPropName) + { + /* + * Instantiate the IWbemLocator, whatever that is and connect to the + * DMI serve. + */ + IWbemLocator *pLoc; + hrc = CoCreateInstance(CLSID_WbemLocator, + 0, + CLSCTX_INPROC_SERVER, + IID_IWbemLocator, + (LPVOID *)&pLoc); + if (SUCCEEDED(hrc)) + { + IWbemServices *pServices; + hrc = rtSystemDmiWinConnectToServer(pLoc, "ROOT\\CIMV2", &pServices); + if (SUCCEEDED(hrc)) + { + /* + * Enumerate whatever it is we're looking at and try get + * the desired property. + */ + BSTR pBstrFilter = rtSystemWinBstrFromUtf8("Win32_ComputerSystemProduct"); + if (pBstrFilter) + { + IEnumWbemClassObject *pEnum; + hrc = pServices->CreateInstanceEnum(pBstrFilter, 0, NULL, &pEnum); + if (SUCCEEDED(hrc)) + { + do + { + IWbemClassObject *pObj; + ULONG cObjRet; + hrc = pEnum->Next(WBEM_INFINITE, 1, &pObj, &cObjRet); + if ( SUCCEEDED(hrc) + && cObjRet >= 1) + { + VARIANT Var; + VariantInit(&Var); + hrc = pObj->Get(pBstrPropName, 0, &Var, 0, 0); + if ( SUCCEEDED(hrc) + && V_VT(&Var) == VT_BSTR) + { + /* + * Convert the BSTR to UTF-8 and copy it + * into the return buffer. + */ + char *pszValue; + rc = RTUtf16ToUtf8(Var.bstrVal, &pszValue); + if (RT_SUCCESS(rc)) + { + rc = RTStrCopy(pszBuf, cbBuf, pszValue); + RTStrFree(pszValue); + hrc = WBEM_S_FALSE; + } + } + VariantClear(&Var); + pObj->Release(); + } + } while (hrc != WBEM_S_FALSE); + + pEnum->Release(); + } + SysFreeString(pBstrFilter); + } + else + hrc = E_OUTOFMEMORY; + pServices->Release(); + } + pLoc->Release(); + } + SysFreeString(pBstrPropName); + } + else + hrc = E_OUTOFMEMORY; + if (fUninit) + rtSystemDmiWinTerminate(); + if (FAILED(hrc) && rc == VERR_NOT_SUPPORTED) + rc = VERR_NOT_SUPPORTED; + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/RTSystemQueryOSInfo-win.cpp b/src/VBox/Runtime/r3/win/RTSystemQueryOSInfo-win.cpp new file mode 100644 index 00000000..fc9e6cf4 --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTSystemQueryOSInfo-win.cpp @@ -0,0 +1,356 @@ +/* $Id: RTSystemQueryOSInfo-win.cpp $ */ +/** @file + * IPRT - RTSystemQueryOSInfo, generic stub. + */ + +/* + * Copyright (C) 2008-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "internal/iprt.h" +#include <iprt/win/windows.h> +#include <WinUser.h> + +#include "internal-r3-win.h" +#include <iprt/system.h> +#include <iprt/assert.h> +#include <iprt/ctype.h> +#include <iprt/errcore.h> +#include <iprt/string.h> +#include <iprt/utf16.h> + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ + +/** + * These are the PRODUCT_* defines found in the Vista Platform SDK and returned + * by GetProductInfo(). + * + * We define them ourselves because we don't necessarily have any Vista PSDK around. + */ +typedef enum RTWINPRODTYPE +{ + kRTWinProdType_UNDEFINED = 0x00000000, ///< An unknown product + kRTWinProdType_BUSINESS = 0x00000006, ///< Business Edition + kRTWinProdType_BUSINESS_N = 0x00000010, ///< Business Edition + kRTWinProdType_CLUSTER_SERVER = 0x00000012, ///< Cluster Server Edition + kRTWinProdType_DATACENTER_SERVER = 0x00000008, ///< Server Datacenter Edition (full installation) + kRTWinProdType_DATACENTER_SERVER_CORE = 0x0000000C, ///< Server Datacenter Edition (core installation) + kRTWinProdType_ENTERPRISE = 0x00000004, ///< Enterprise Edition + kRTWinProdType_ENTERPRISE_N = 0x0000001B, ///< Enterprise Edition + kRTWinProdType_ENTERPRISE_SERVER = 0x0000000A, ///< Server Enterprise Edition (full installation) + kRTWinProdType_ENTERPRISE_SERVER_CORE = 0x0000000E, ///< Server Enterprise Edition (core installation) + kRTWinProdType_ENTERPRISE_SERVER_IA64 = 0x0000000F, ///< Server Enterprise Edition for Itanium-based Systems + kRTWinProdType_HOME_BASIC = 0x00000002, ///< Home Basic Edition + kRTWinProdType_HOME_BASIC_N = 0x00000005, ///< Home Basic Edition + kRTWinProdType_HOME_PREMIUM = 0x00000003, ///< Home Premium Edition + kRTWinProdType_HOME_PREMIUM_N = 0x0000001A, ///< Home Premium Edition + kRTWinProdType_HOME_SERVER = 0x00000013, ///< Home Server Edition + kRTWinProdType_SERVER_FOR_SMALLBUSINESS = 0x00000018, ///< Server for Small Business Edition + kRTWinProdType_SMALLBUSINESS_SERVER = 0x00000009, ///< Small Business Server + kRTWinProdType_SMALLBUSINESS_SERVER_PREMIUM = 0x00000019, ///< Small Business Server Premium Edition + kRTWinProdType_STANDARD_SERVER = 0x00000007, ///< Server Standard Edition (full installation) + kRTWinProdType_STANDARD_SERVER_CORE = 0x0000000D, ///< Server Standard Edition (core installation) + kRTWinProdType_STARTER = 0x0000000B, ///< Starter Edition + kRTWinProdType_STORAGE_ENTERPRISE_SERVER = 0x00000017, ///< Storage Server Enterprise Edition + kRTWinProdType_STORAGE_EXPRESS_SERVER = 0x00000014, ///< Storage Server Express Edition + kRTWinProdType_STORAGE_STANDARD_SERVER = 0x00000015, ///< Storage Server Standard Edition + kRTWinProdType_STORAGE_WORKGROUP_SERVER = 0x00000016, ///< Storage Server Workgroup Edition + kRTWinProdType_ULTIMATE = 0x00000001, ///< Ultimate Edition + kRTWinProdType_ULTIMATE_N = 0x0000001C, ///< Ultimate Edition + kRTWinProdType_WEB_SERVER = 0x00000011, ///< Web Server Edition (full) + kRTWinProdType_WEB_SERVER_CORE = 0x0000001D ///< Web Server Edition (core) +} RTWINPRODTYPE; + + +/** + * Wrapper around the GetProductInfo API. + * + * @returns The vista type. + */ +static RTWINPRODTYPE rtSystemWinGetProductInfo(DWORD dwOSMajorVersion, DWORD dwOSMinorVersion, DWORD dwSpMajorVersion, DWORD dwSpMinorVersion) +{ + BOOL (WINAPI *pfnGetProductInfo)(DWORD, DWORD, DWORD, DWORD, PDWORD); + pfnGetProductInfo = (BOOL (WINAPI *)(DWORD, DWORD, DWORD, DWORD, PDWORD))GetProcAddress(GetModuleHandle("kernel32.dll"), "GetProductInfo"); + if (pfnGetProductInfo) + { + DWORD dwProductType = kRTWinProdType_UNDEFINED; + if (pfnGetProductInfo(dwOSMajorVersion, dwOSMinorVersion, dwSpMajorVersion, dwSpMinorVersion, &dwProductType)) + return (RTWINPRODTYPE)dwProductType; + } + return kRTWinProdType_UNDEFINED; +} + + + +/** + * Appends the product type if available. + * + * @param pszTmp The buffer. Assumes it's big enough. + */ +static void rtSystemWinAppendProductType(char *pszTmp) +{ + RTWINPRODTYPE enmVistaType = rtSystemWinGetProductInfo(6, 0, 0, 0); + switch (enmVistaType) + { + case kRTWinProdType_BUSINESS: strcat(pszTmp, " Business Edition"); break; + case kRTWinProdType_BUSINESS_N: strcat(pszTmp, " Business Edition"); break; + case kRTWinProdType_CLUSTER_SERVER: strcat(pszTmp, " Cluster Server Edition"); break; + case kRTWinProdType_DATACENTER_SERVER: strcat(pszTmp, " Server Datacenter Edition (full installation)"); break; + case kRTWinProdType_DATACENTER_SERVER_CORE: strcat(pszTmp, " Server Datacenter Edition (core installation)"); break; + case kRTWinProdType_ENTERPRISE: strcat(pszTmp, " Enterprise Edition"); break; + case kRTWinProdType_ENTERPRISE_N: strcat(pszTmp, " Enterprise Edition"); break; + case kRTWinProdType_ENTERPRISE_SERVER: strcat(pszTmp, " Server Enterprise Edition (full installation)"); break; + case kRTWinProdType_ENTERPRISE_SERVER_CORE: strcat(pszTmp, " Server Enterprise Edition (core installation)"); break; + case kRTWinProdType_ENTERPRISE_SERVER_IA64: strcat(pszTmp, " Server Enterprise Edition for Itanium-based Systems"); break; + case kRTWinProdType_HOME_BASIC: strcat(pszTmp, " Home Basic Edition"); break; + case kRTWinProdType_HOME_BASIC_N: strcat(pszTmp, " Home Basic Edition"); break; + case kRTWinProdType_HOME_PREMIUM: strcat(pszTmp, " Home Premium Edition"); break; + case kRTWinProdType_HOME_PREMIUM_N: strcat(pszTmp, " Home Premium Edition"); break; + case kRTWinProdType_HOME_SERVER: strcat(pszTmp, " Home Server Edition"); break; + case kRTWinProdType_SERVER_FOR_SMALLBUSINESS: strcat(pszTmp, " Server for Small Business Edition"); break; + case kRTWinProdType_SMALLBUSINESS_SERVER: strcat(pszTmp, " Small Business Server"); break; + case kRTWinProdType_SMALLBUSINESS_SERVER_PREMIUM: strcat(pszTmp, " Small Business Server Premium Edition"); break; + case kRTWinProdType_STANDARD_SERVER: strcat(pszTmp, " Server Standard Edition (full installation)"); break; + case kRTWinProdType_STANDARD_SERVER_CORE: strcat(pszTmp, " Server Standard Edition (core installation)"); break; + case kRTWinProdType_STARTER: strcat(pszTmp, " Starter Edition"); break; + case kRTWinProdType_STORAGE_ENTERPRISE_SERVER: strcat(pszTmp, " Storage Server Enterprise Edition"); break; + case kRTWinProdType_STORAGE_EXPRESS_SERVER: strcat(pszTmp, " Storage Server Express Edition"); break; + case kRTWinProdType_STORAGE_STANDARD_SERVER: strcat(pszTmp, " Storage Server Standard Edition"); break; + case kRTWinProdType_STORAGE_WORKGROUP_SERVER: strcat(pszTmp, " Storage Server Workgroup Edition"); break; + case kRTWinProdType_ULTIMATE: strcat(pszTmp, " Ultimate Edition"); break; + case kRTWinProdType_ULTIMATE_N: strcat(pszTmp, " Ultimate Edition"); break; + case kRTWinProdType_WEB_SERVER: strcat(pszTmp, " Web Server Edition (full installation)"); break; + case kRTWinProdType_WEB_SERVER_CORE: strcat(pszTmp, " Web Server Edition (core installation)"); break; + case kRTWinProdType_UNDEFINED: break; + } +} + + +/** + * Services the RTSYSOSINFO_PRODUCT, RTSYSOSINFO_RELEASE + * and RTSYSOSINFO_SERVICE_PACK requests. + * + * @returns See RTSystemQueryOSInfo. + * @param enmInfo See RTSystemQueryOSInfo. + * @param pszInfo See RTSystemQueryOSInfo. + * @param cchInfo See RTSystemQueryOSInfo. + */ +static int rtSystemWinQueryOSVersion(RTSYSOSINFO enmInfo, char *pszInfo, size_t cchInfo) +{ + /* + * Make sure it's terminated correctly in case of error. + */ + *pszInfo = '\0'; + + /* + * Check that we got the windows version at init time. + */ + AssertReturn(g_WinOsInfoEx.dwOSVersionInfoSize, VERR_WRONG_ORDER); + + /* + * Service the request. + */ + char szTmp[512]; + szTmp[0] = '\0'; + switch (enmInfo) + { + /* + * The product name. + */ + case RTSYSOSINFO_PRODUCT: + { + switch (g_enmWinVer) + { + case kRTWinOSType_95: strcpy(szTmp, "Windows 95"); break; + case kRTWinOSType_95SP1: strcpy(szTmp, "Windows 95 (Service Pack 1)"); break; + case kRTWinOSType_95OSR2: strcpy(szTmp, "Windows 95 (OSR 2)"); break; + case kRTWinOSType_98: strcpy(szTmp, "Windows 98"); break; + case kRTWinOSType_98SP1: strcpy(szTmp, "Windows 98 (Service Pack 1)"); break; + case kRTWinOSType_98SE: strcpy(szTmp, "Windows 98 (Second Edition)"); break; + case kRTWinOSType_ME: strcpy(szTmp, "Windows Me"); break; + case kRTWinOSType_NT310: strcpy(szTmp, "Windows NT 3.10"); break; + case kRTWinOSType_NT350: strcpy(szTmp, "Windows NT 3.50"); break; + case kRTWinOSType_NT351: strcpy(szTmp, "Windows NT 3.51"); break; + case kRTWinOSType_NT4: strcpy(szTmp, "Windows NT 4.0"); break; + case kRTWinOSType_2K: strcpy(szTmp, "Windows 2000"); break; + case kRTWinOSType_XP: + strcpy(szTmp, "Windows XP"); + if (g_WinOsInfoEx.wSuiteMask & VER_SUITE_PERSONAL) + strcat(szTmp, " Home"); + if ( g_WinOsInfoEx.wProductType == VER_NT_WORKSTATION + && !(g_WinOsInfoEx.wSuiteMask & VER_SUITE_PERSONAL)) + strcat(szTmp, " Professional"); +#if 0 /** @todo fixme */ + if (GetSystemMetrics(SM_MEDIACENTER)) + strcat(szTmp, " Media Center"); +#endif + break; + + case kRTWinOSType_2003: strcpy(szTmp, "Windows 2003"); break; + case kRTWinOSType_VISTA: + { + strcpy(szTmp, "Windows Vista"); + rtSystemWinAppendProductType(szTmp); + break; + } + case kRTWinOSType_2008: strcpy(szTmp, "Windows 2008"); break; + case kRTWinOSType_7: strcpy(szTmp, "Windows 7"); break; + case kRTWinOSType_2008R2: strcpy(szTmp, "Windows 2008 R2"); break; + case kRTWinOSType_8: strcpy(szTmp, "Windows 8"); break; + case kRTWinOSType_2012: strcpy(szTmp, "Windows 2012"); break; + case kRTWinOSType_81: strcpy(szTmp, "Windows 8.1"); break; + case kRTWinOSType_2012R2: strcpy(szTmp, "Windows 2012 R2"); break; + case kRTWinOSType_10: strcpy(szTmp, "Windows 10"); break; + case kRTWinOSType_2016: strcpy(szTmp, "Windows 2016"); break; + + case kRTWinOSType_NT_UNKNOWN: + RTStrPrintf(szTmp, sizeof(szTmp), "Unknown NT v%u.%u", + g_WinOsInfoEx.dwMajorVersion, g_WinOsInfoEx.dwMinorVersion); + break; + + default: + AssertFailed(); + case kRTWinOSType_UNKNOWN: + RTStrPrintf(szTmp, sizeof(szTmp), "Unknown %d v%u.%u", + g_WinOsInfoEx.dwPlatformId, g_WinOsInfoEx.dwMajorVersion, g_WinOsInfoEx.dwMinorVersion); + break; + } + break; + } + + /* + * The release. + */ + case RTSYSOSINFO_RELEASE: + { + RTStrPrintf(szTmp, sizeof(szTmp), "%u.%u.%u", + g_WinOsInfoEx.dwMajorVersion, g_WinOsInfoEx.dwMinorVersion, g_WinOsInfoEx.dwBuildNumber); + break; + } + + + /* + * Get the service pack. + */ + case RTSYSOSINFO_SERVICE_PACK: + { + if (g_WinOsInfoEx.wServicePackMajor) + { + if (g_WinOsInfoEx.wServicePackMinor) + RTStrPrintf(szTmp, sizeof(szTmp), "%u.%u", + (unsigned)g_WinOsInfoEx.wServicePackMajor, (unsigned)g_WinOsInfoEx.wServicePackMinor); + else + RTStrPrintf(szTmp, sizeof(szTmp), "%u", + (unsigned)g_WinOsInfoEx.wServicePackMajor); + } + else if (g_WinOsInfoEx.szCSDVersion[0]) + { + /* just copy the entire string. */ + char *pszTmp = szTmp; + int rc = RTUtf16ToUtf8Ex(g_WinOsInfoEx.szCSDVersion, RT_ELEMENTS(g_WinOsInfoEx.szCSDVersion), + &pszTmp, sizeof(szTmp), NULL); + if (RT_SUCCESS(rc)) + RTStrStripR(szTmp); + else + szTmp[0] = '\0'; + AssertCompile(sizeof(szTmp) > sizeof(g_WinOsInfoEx.szCSDVersion)); + } + else + { + switch (g_enmWinVer) + { + case kRTWinOSType_95SP1: strcpy(szTmp, "1"); break; + case kRTWinOSType_98SP1: strcpy(szTmp, "1"); break; + default: + break; + } + } + break; + } + + default: + AssertFatalFailed(); + } + + /* + * Copy the result to the return buffer. + */ + size_t cchTmp = strlen(szTmp); + Assert(cchTmp < sizeof(szTmp)); + if (cchTmp < cchInfo) + { + memcpy(pszInfo, szTmp, cchTmp + 1); + return VINF_SUCCESS; + } + memcpy(pszInfo, szTmp, cchInfo - 1); + pszInfo[cchInfo - 1] = '\0'; + return VERR_BUFFER_OVERFLOW; +} + + + +RTDECL(int) RTSystemQueryOSInfo(RTSYSOSINFO enmInfo, char *pszInfo, size_t cchInfo) +{ + /* + * Quick validation. + */ + AssertReturn(enmInfo > RTSYSOSINFO_INVALID && enmInfo < RTSYSOSINFO_END, VERR_INVALID_PARAMETER); + AssertPtrReturn(pszInfo, VERR_INVALID_POINTER); + if (!cchInfo) + return VERR_BUFFER_OVERFLOW; + + + /* + * Handle the request. + */ + switch (enmInfo) + { + case RTSYSOSINFO_PRODUCT: + case RTSYSOSINFO_RELEASE: + case RTSYSOSINFO_SERVICE_PACK: + return rtSystemWinQueryOSVersion(enmInfo, pszInfo, cchInfo); + + case RTSYSOSINFO_VERSION: + default: + *pszInfo = '\0'; + } + + return VERR_NOT_SUPPORTED; +} + + +RTDECL(uint32_t) RTSystemGetNtBuildNo(void) +{ + return g_WinOsInfoEx.dwBuildNumber; +} + + +RTDECL(uint64_t) RTSystemGetNtVersion(void) +{ + return RTSYSTEM_MAKE_NT_VERSION(g_WinOsInfoEx.dwMajorVersion, g_WinOsInfoEx.dwMinorVersion, g_WinOsInfoEx.dwBuildNumber); +} + diff --git a/src/VBox/Runtime/r3/win/RTSystemQueryTotalRam-win.cpp b/src/VBox/Runtime/r3/win/RTSystemQueryTotalRam-win.cpp new file mode 100644 index 00000000..9d1f12a5 --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTSystemQueryTotalRam-win.cpp @@ -0,0 +1,121 @@ +/* $Id: RTSystemQueryTotalRam-win.cpp $ */ +/** @file + * IPRT - RTSystemQueryTotalRam, windows ring-3. + */ + +/* + * Copyright (C) 2010-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/windows.h> +#include <iprt/system.h> +#include "internal/iprt.h" + +#include <iprt/errcore.h> +#include <iprt/assert.h> +#include <iprt/string.h> + +#include "internal-r3-win.h" + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +static bool volatile g_fInitialized = false; +typedef BOOL (WINAPI *PFNGLOBALMEMORYSTATUSEX)(LPMEMORYSTATUSEX); +static PFNGLOBALMEMORYSTATUSEX g_pfnGlobalMemoryStatusEx = NULL; + + +/** + * The GlobalMemoryStatusEx API is not available on older Windows version. + * + * @returns Pointer to GlobalMemoryStatusEx or NULL if not available. + */ +DECLINLINE(PFNGLOBALMEMORYSTATUSEX) rtSystemWinGetExApi(void) +{ + PFNGLOBALMEMORYSTATUSEX pfnEx; + if (g_fInitialized) + pfnEx = g_pfnGlobalMemoryStatusEx; + else + { + pfnEx = (PFNGLOBALMEMORYSTATUSEX)GetProcAddress(g_hModKernel32, "GlobalMemoryStatusEx"); + g_pfnGlobalMemoryStatusEx = pfnEx; + g_fInitialized = true; + } + return pfnEx; +} + + +RTDECL(int) RTSystemQueryTotalRam(uint64_t *pcb) +{ + AssertPtrReturn(pcb, VERR_INVALID_POINTER); + + int rc = VINF_SUCCESS; + PFNGLOBALMEMORYSTATUSEX pfnGlobalMemoryStatusEx = rtSystemWinGetExApi(); + if (pfnGlobalMemoryStatusEx) + { + MEMORYSTATUSEX MemStatus; + MemStatus.dwLength = sizeof(MemStatus); + if (pfnGlobalMemoryStatusEx(&MemStatus)) + *pcb = MemStatus.ullTotalPhys; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + { + MEMORYSTATUS MemStatus; + RT_ZERO(MemStatus); + MemStatus.dwLength = sizeof(MemStatus); + GlobalMemoryStatus(&MemStatus); + *pcb = MemStatus.dwTotalPhys; + } + return rc; +} + + +RTDECL(int) RTSystemQueryAvailableRam(uint64_t *pcb) +{ + AssertPtrReturn(pcb, VERR_INVALID_POINTER); + + int rc = VINF_SUCCESS; + PFNGLOBALMEMORYSTATUSEX pfnGlobalMemoryStatusEx = rtSystemWinGetExApi(); + if (pfnGlobalMemoryStatusEx) + { + MEMORYSTATUSEX MemStatus; + MemStatus.dwLength = sizeof(MemStatus); + if (pfnGlobalMemoryStatusEx(&MemStatus)) + *pcb = MemStatus.ullAvailPhys; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + { + MEMORYSTATUS MemStatus; + RT_ZERO(MemStatus); + MemStatus.dwLength = sizeof(MemStatus); + GlobalMemoryStatus(&MemStatus); + *pcb = MemStatus.dwAvailPhys; + } + return rc; +} diff --git a/src/VBox/Runtime/r3/win/RTSystemShutdown-win.cpp b/src/VBox/Runtime/r3/win/RTSystemShutdown-win.cpp new file mode 100644 index 00000000..369950f9 --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTSystemShutdown-win.cpp @@ -0,0 +1,173 @@ +/* $Id: RTSystemShutdown-win.cpp $ */ +/** @file + * IPRT - RTSystemShutdown, Windows. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/system.h> +#include "internal/iprt.h" + +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/string.h> +#include <iprt/utf16.h> + +#include <iprt/win/windows.h> + + +RTDECL(int) RTSystemShutdown(RTMSINTERVAL cMsDelay, uint32_t fFlags, const char *pszLogMsg) +{ + AssertPtrReturn(pszLogMsg, VERR_INVALID_POINTER); + AssertReturn(!(fFlags & ~RTSYSTEM_SHUTDOWN_VALID_MASK), VERR_INVALID_PARAMETER); + + /* + * Before we start, try grant the necessary privileges. + */ + DWORD dwErr; + HANDLE hToken = NULL; + if (OpenThreadToken(GetCurrentThread(), TOKEN_ADJUST_PRIVILEGES, TRUE /*OpenAsSelf*/, &hToken)) + dwErr = NO_ERROR; + else + { + dwErr = GetLastError(); + if (dwErr == ERROR_NO_TOKEN) + { + if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken)) + dwErr = NO_ERROR; + else + dwErr = GetLastError(); + } + } + if (dwErr == NO_ERROR) + { + union + { + TOKEN_PRIVILEGES TokenPriv; + char ab[sizeof(TOKEN_PRIVILEGES) + sizeof(LUID_AND_ATTRIBUTES)]; + } u; + u.TokenPriv.PrivilegeCount = 1; + u.TokenPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; + if (LookupPrivilegeValue(NULL /*localhost*/, SE_SHUTDOWN_NAME, &u.TokenPriv.Privileges[0].Luid)) + { + if (!AdjustTokenPrivileges(hToken, + FALSE /*DisableAllPrivileges*/, + &u.TokenPriv, + RT_UOFFSETOF(TOKEN_PRIVILEGES, Privileges[1]), + NULL, + NULL) ) + dwErr = GetLastError(); + } + else + dwErr = GetLastError(); + CloseHandle(hToken); + } + + /* + * Do some parameter conversion. + */ + PRTUTF16 pwszLogMsg; + int rc = RTStrToUtf16(pszLogMsg, &pwszLogMsg); + if (RT_FAILURE(rc)) + return rc; + DWORD cSecsTimeout = (cMsDelay + 499) / 1000; + + /* + * If we're told to power off the system, we should try use InitiateShutdownW (6.0+) + * or ExitWindowsEx (3.50) rather than InitiateSystemShutdownW, because these other + * APIs allows us to explicitly specify that we want to power off. + * + * Note! For NT version 4, 3.51, and 3.50 the system may instaed reboot since the + * x86 HALs typically didn't know how to perform a power off. + */ + bool fDone = false; + if ( (fFlags & RTSYSTEM_SHUTDOWN_ACTION_MASK) == RTSYSTEM_SHUTDOWN_POWER_OFF + || (fFlags & RTSYSTEM_SHUTDOWN_ACTION_MASK) == RTSYSTEM_SHUTDOWN_POWER_OFF_HALT) + { + /* This API has the grace period thing. */ + decltype(InitiateShutdownW) *pfnInitiateShutdownW; + pfnInitiateShutdownW = (decltype(InitiateShutdownW) *)GetProcAddress(GetModuleHandleW(L"ADVAPI32.DLL"), "InitiateShutdownW"); + if (pfnInitiateShutdownW) + { + DWORD fShutdownFlags = SHUTDOWN_POWEROFF; + if (fFlags & RTSYSTEM_SHUTDOWN_FORCE) + fShutdownFlags |= SHUTDOWN_FORCE_OTHERS | SHUTDOWN_FORCE_SELF; + DWORD fReason = SHTDN_REASON_MAJOR_OTHER | (fFlags & RTSYSTEM_SHUTDOWN_PLANNED ? SHTDN_REASON_FLAG_PLANNED : 0); + dwErr = pfnInitiateShutdownW(NULL /*pwszMachineName*/, pwszLogMsg, cSecsTimeout, fShutdownFlags, fReason); + if (dwErr == ERROR_INVALID_PARAMETER) + { + fReason &= ~SHTDN_REASON_FLAG_PLANNED; /* just in case... */ + dwErr = pfnInitiateShutdownW(NULL /*pwszMachineName*/, pwszLogMsg, cSecsTimeout, fShutdownFlags, fReason); + } + if (dwErr == ERROR_SUCCESS) + { + rc = VINF_SUCCESS; + fDone = true; + } + } + + if (!fDone) + { + /* No grace period here, too bad. */ + decltype(ExitWindowsEx) *pfnExitWindowsEx; + pfnExitWindowsEx = (decltype(ExitWindowsEx) *)GetProcAddress(GetModuleHandleW(L"USER32.DLL"), "ExitWindowsEx"); + if (pfnExitWindowsEx) + { + DWORD fExitWindows = EWX_POWEROFF | EWX_SHUTDOWN; + if (fFlags & RTSYSTEM_SHUTDOWN_FORCE) + fExitWindows |= EWX_FORCE | EWX_FORCEIFHUNG; + + if (pfnExitWindowsEx(fExitWindows, SHTDN_REASON_MAJOR_OTHER)) + fDone = true; + else if (pfnExitWindowsEx(fExitWindows & ~EWX_FORCEIFHUNG, SHTDN_REASON_MAJOR_OTHER)) + fDone = true; + } + } + } + + /* + * Fall back on the oldest API. + */ + if (!fDone) + { + BOOL fRebootAfterShutdown = (fFlags & RTSYSTEM_SHUTDOWN_ACTION_MASK) == RTSYSTEM_SHUTDOWN_REBOOT + ? TRUE : FALSE; + BOOL fForceAppsClosed = fFlags & RTSYSTEM_SHUTDOWN_FORCE ? TRUE : FALSE; + if (InitiateSystemShutdownW(NULL /*pwszMachineName = NULL = localhost*/, + pwszLogMsg, + cSecsTimeout, + fForceAppsClosed, + fRebootAfterShutdown)) + rc = (fFlags & RTSYSTEM_SHUTDOWN_ACTION_MASK) == RTSYSTEM_SHUTDOWN_HALT ? VINF_SYS_MAY_POWER_OFF : VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(dwErr); + } + + RTUtf16Free(pwszLogMsg); + return rc; +} +RT_EXPORT_SYMBOL(RTSystemShutdown); + diff --git a/src/VBox/Runtime/r3/win/RTTimeZoneGetCurrent-win.cpp b/src/VBox/Runtime/r3/win/RTTimeZoneGetCurrent-win.cpp new file mode 100644 index 00000000..9dfe24c3 --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTTimeZoneGetCurrent-win.cpp @@ -0,0 +1,107 @@ +/* $Id: RTTimeZoneGetCurrent-win.cpp $ */ +/** @file + * IPRT - RTTimeZoneGetCurrent, generic. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/time.h> +#include "internal/iprt.h" + +#include <iprt/errcore.h> +#include <iprt/env.h> +#include <iprt/string.h> +#include <iprt/utf16.h> +#include <iprt/win/windows.h> +#include "internal-r3-win.h" + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef DWORD (WINAPI *PFNGETDYNAMICTIMEZONEINFORMATION)(PDYNAMIC_TIME_ZONE_INFORMATION); + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Pointer to the GetDynamicTimeZoneInformation API if present. */ +static PFNGETDYNAMICTIMEZONEINFORMATION g_pfnGetDynamicTimeZoneInformation = NULL; +/** Flipped after we've tried to resolve g_pfnGetDynamicTimeZoneInformation. */ +static bool volatile g_fResolvedApi = false; + + +RTDECL(int) RTTimeZoneGetCurrent(char *pszName, size_t cbName) +{ + AssertPtrReturn(pszName, VERR_INVALID_POINTER); + AssertReturn(cbName > 0, VERR_BUFFER_OVERFLOW); + + /* + * Resolve API. + */ + PFNGETDYNAMICTIMEZONEINFORMATION pfnApi; + if (g_fResolvedApi) + pfnApi = g_pfnGetDynamicTimeZoneInformation; + else + { + pfnApi = (PFNGETDYNAMICTIMEZONEINFORMATION)GetProcAddress(g_hModKernel32, "GetDynamicTimeZoneInformation"); + g_pfnGetDynamicTimeZoneInformation = pfnApi; + g_fResolvedApi = true; + } + + /* + * Call the API and convert the name we get. + */ + union + { + TIME_ZONE_INFORMATION Tzi; + DYNAMIC_TIME_ZONE_INFORMATION DynTzi; + } uBuf; + RT_ZERO(uBuf); + DWORD dwRc; + PCRTUTF16 pwszSrcName; + size_t cwcSrcName; + if (pfnApi) + { + dwRc = pfnApi(&uBuf.DynTzi); + pwszSrcName = uBuf.DynTzi.TimeZoneKeyName; + cwcSrcName = RT_ELEMENTS(uBuf.DynTzi.TimeZoneKeyName); + } + else + { + /* Not sure how helpful this fallback really is... */ + dwRc = GetTimeZoneInformation(&uBuf.Tzi); + pwszSrcName = uBuf.Tzi.StandardName; + cwcSrcName = RT_ELEMENTS(uBuf.Tzi.StandardName); + } + if (dwRc != TIME_ZONE_ID_INVALID) + { + Assert(*pwszSrcName != '\0'); + return RTUtf16ToUtf8Ex(pwszSrcName, cwcSrcName, &pszName, cbName, &cbName); + } + return RTErrConvertFromWin32(GetLastError()); +} + diff --git a/src/VBox/Runtime/r3/win/RTUuidCreate-win.cpp b/src/VBox/Runtime/r3/win/RTUuidCreate-win.cpp new file mode 100644 index 00000000..0dbb7429 --- /dev/null +++ b/src/VBox/Runtime/r3/win/RTUuidCreate-win.cpp @@ -0,0 +1,72 @@ +/* $Id: RTUuidCreate-win.cpp $ */ +/** @file + * IPRT - UUID, Windows RTUuidCreate implementation. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_UUID +#include <iprt/win/windows.h> + +#include <iprt/uuid.h> +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/rand.h> + +#include "internal-r3-win.h" + + +RTDECL(int) RTUuidCreate(PRTUUID pUuid) +{ + /* + * Input validation. + */ + AssertPtrReturn(pUuid, VERR_INVALID_POINTER); + + /* + * When using the UuidCreate API shortly after boot on NT 3.1 it typcially + * hangs for a long long time while polling for some service to start. + * What then usually happens next is a failure because it couldn't figure + * out the MAC address of the NIC. So, on NT 3.1 we always use the fallback. + */ + if (g_enmWinVer != kRTWinOSType_NT310) + { + RPC_STATUS rc = UuidCreate((UUID *)pUuid); + if ( rc == RPC_S_OK + || rc == RPC_S_UUID_LOCAL_ONLY) + return VINF_SUCCESS; + AssertMsg(rc == RPC_S_UUID_NO_ADDRESS, ("UuidCreate -> %u (%#x)\n", rc, rc)); + } + + /* + * Use generic implementation as fallback (copy of RTUuidCreate-generic.cpp). + */ + RTRandBytes(pUuid, sizeof(*pUuid)); + pUuid->Gen.u8ClockSeqHiAndReserved = (pUuid->Gen.u8ClockSeqHiAndReserved & 0x3f) | 0x80; + pUuid->Gen.u16TimeHiAndVersion = (pUuid->Gen.u16TimeHiAndVersion & 0x0fff) | 0x4000; + return VINF_SUCCESS; +} + diff --git a/src/VBox/Runtime/r3/win/VBoxRT-msvcp100-win32.def b/src/VBox/Runtime/r3/win/VBoxRT-msvcp100-win32.def new file mode 100644 index 00000000..5395dc50 --- /dev/null +++ b/src/VBox/Runtime/r3/win/VBoxRT-msvcp100-win32.def @@ -0,0 +1,1678 @@ + + ??0?$_Yarn@D@std@@QAE@ABV01@@Z + ??0?$_Yarn@D@std@@QAE@PBD@Z + ??0?$_Yarn@D@std@@QAE@XZ + ??0?$basic_ios@DU?$char_traits@D@std@@@std@@IAE@XZ + ??0?$basic_ios@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z + ??0?$basic_ios@GU?$char_traits@G@std@@@std@@IAE@XZ + ??0?$basic_ios@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z + ??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@IAE@XZ + ??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z + ??0?$basic_iostream@DU?$char_traits@D@std@@@std@@QAE@$$QAV01@@Z + ??0?$basic_iostream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z + ??0?$basic_iostream@GU?$char_traits@G@std@@@std@@QAE@$$QAV01@@Z + ??0?$basic_iostream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z + ??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QAE@$$QAV01@@Z + ??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z + ??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@$$QAV01@@Z + ??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N1@Z + ??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z + ??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@W4_Uninitialized@1@@Z + ??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@$$QAV01@@Z + ??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N1@Z + ??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z + ??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@W4_Uninitialized@1@@Z + ??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@$$QAV01@@Z + ??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N1@Z + ??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z + ??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@W4_Uninitialized@1@@Z + ??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE@$$QAV01@@Z + ??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z + ??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE@W4_Uninitialized@1@_N@Z + ??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE@$$QAV01@@Z + ??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z + ??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE@W4_Uninitialized@1@_N@Z + ??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE@$$QAV01@@Z + ??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z + ??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE@W4_Uninitialized@1@_N@Z + ??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAE@ABV01@@Z + ??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAE@W4_Uninitialized@1@@Z + ??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAE@XZ + ??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAE@ABV01@@Z + ??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAE@W4_Uninitialized@1@@Z + ??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAE@XZ + ??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAE@ABV01@@Z + ??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAE@W4_Uninitialized@1@@Z + ??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAE@XZ + ??0?$codecvt@DDH@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$codecvt@DDH@std@@QAE@I@Z + ??0?$codecvt@GDH@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$codecvt@GDH@std@@QAE@I@Z + ??0?$codecvt@_WDH@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$codecvt@_WDH@std@@QAE@I@Z + ??0?$ctype@D@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$ctype@D@std@@QAE@PBF_NI@Z + ??0?$ctype@G@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$ctype@G@std@@QAE@I@Z + ??0?$ctype@_W@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$ctype@_W@std@@QAE@I@Z + ??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z + ??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z + ??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z + ??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z + ??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z + ??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z + ??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAE@PBDI@Z + ??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z + ??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAE@PBDI@Z + ??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z + ??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAE@PBDI@Z + ??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z + ??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z + ??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAE@PBDI@Z + ??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z + ??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAE@PBDI@Z + ??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z + ??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z + ??0Init@ios_base@std@@QAE@XZ + ??0_Concurrent_queue_base_v4@details@Concurrency@@IAE@I@Z + ??0_Concurrent_queue_iterator_base_v4@details@Concurrency@@IAE@ABV_Concurrent_queue_base_v4@12@@Z + ??0_Container_base12@std@@QAE@ABU01@@Z + ??0_Container_base12@std@@QAE@XZ + ??0_Init_locks@std@@QAE@XZ + ??0_Locimp@locale@std@@AAE@ABV012@@Z + ??0_Locimp@locale@std@@AAE@_N@Z + ??0_Locinfo@std@@QAE@HPBD@Z + ??0_Locinfo@std@@QAE@PBD@Z + ??0_Lockit@std@@QAE@H@Z + ??0_Lockit@std@@QAE@XZ + ??0_Mutex@std@@QAE@W4_Uninitialized@1@@Z + ??0_Mutex@std@@QAE@XZ + ??0_Runtime_object@details@Concurrency@@QAE@H@Z + ??0_Runtime_object@details@Concurrency@@QAE@XZ + ??0_Timevec@std@@QAE@ABV01@@Z + ??0_Timevec@std@@QAE@PAX@Z + ??0_UShinit@std@@QAE@XZ + ??0_Winit@std@@QAE@XZ + ??0agent@Concurrency@@QAE@AAVScheduleGroup@1@@Z + ??0agent@Concurrency@@QAE@AAVScheduler@1@@Z + ??0agent@Concurrency@@QAE@XZ + ??0codecvt_base@std@@QAE@I@Z + ??0ctype_base@std@@QAE@I@Z + ??0facet@locale@std@@IAE@I@Z + ??0id@locale@std@@QAE@I@Z + ??0ios_base@std@@IAE@XZ + ??0ios_base@std@@QAE@ABV01@@Z + ??0time_base@std@@QAE@I@Z + ??1?$_Yarn@D@std@@QAE@XZ + ??1?$basic_ios@DU?$char_traits@D@std@@@std@@UAE@XZ + ??1?$basic_ios@GU?$char_traits@G@std@@@std@@UAE@XZ + ??1?$basic_ios@_WU?$char_traits@_W@std@@@std@@UAE@XZ + ??1?$basic_iostream@DU?$char_traits@D@std@@@std@@UAE@XZ + ??1?$basic_iostream@GU?$char_traits@G@std@@@std@@UAE@XZ + ??1?$basic_iostream@_WU?$char_traits@_W@std@@@std@@UAE@XZ + ??1?$basic_istream@DU?$char_traits@D@std@@@std@@UAE@XZ + ??1?$basic_istream@GU?$char_traits@G@std@@@std@@UAE@XZ + ??1?$basic_istream@_WU?$char_traits@_W@std@@@std@@UAE@XZ + ??1?$basic_ostream@DU?$char_traits@D@std@@@std@@UAE@XZ + ??1?$basic_ostream@GU?$char_traits@G@std@@@std@@UAE@XZ + ??1?$basic_ostream@_WU?$char_traits@_W@std@@@std@@UAE@XZ + ??1?$basic_streambuf@DU?$char_traits@D@std@@@std@@UAE@XZ + ??1?$basic_streambuf@GU?$char_traits@G@std@@@std@@UAE@XZ + ??1?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UAE@XZ + ??1?$codecvt@DDH@std@@MAE@XZ + ??1?$codecvt@GDH@std@@MAE@XZ + ??1?$codecvt@_WDH@std@@MAE@XZ + ??1?$ctype@D@std@@MAE@XZ + ??1?$ctype@G@std@@MAE@XZ + ??1?$ctype@_W@std@@MAE@XZ + ??1?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ + ??1?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ + ??1?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ + ??1?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ + ??1?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ + ??1?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ + ??1?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ + ??1?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ + ??1?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ + ??1?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ + ??1?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ + ??1?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ + ??1Init@ios_base@std@@QAE@XZ + ??1_Concurrent_queue_base_v4@details@Concurrency@@MAE@XZ + ??1_Concurrent_queue_iterator_base_v4@details@Concurrency@@IAE@XZ + ??1_Concurrent_vector_base_v4@details@Concurrency@@IAE@XZ + ??1_Container_base12@std@@QAE@XZ + ??1_Init_locks@std@@QAE@XZ + ??1_Locimp@locale@std@@MAE@XZ + ??1_Locinfo@std@@QAE@XZ + ??1_Lockit@std@@QAE@XZ + ??1_Mutex@std@@QAE@XZ + ??1_Timevec@std@@QAE@XZ + ??1_UShinit@std@@QAE@XZ + ??1_Winit@std@@QAE@XZ + ??1agent@Concurrency@@UAE@XZ + ??1codecvt_base@std@@UAE@XZ + ??1ctype_base@std@@UAE@XZ + ??1facet@locale@std@@UAE@XZ + ??1ios_base@std@@UAE@XZ + ??1time_base@std@@UAE@XZ + ??4?$_Iosb@H@std@@QAEAAV01@ABV01@@Z + ??4?$_Yarn@D@std@@QAEAAV01@ABV01@@Z + ??4?$_Yarn@D@std@@QAEAAV01@PBD@Z + ??4?$basic_iostream@DU?$char_traits@D@std@@@std@@QAEAAV01@$$QAV01@@Z + ??4?$basic_iostream@GU?$char_traits@G@std@@@std@@QAEAAV01@$$QAV01@@Z + ??4?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@$$QAV01@@Z + ??4?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@$$QAV01@@Z + ??4?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@$$QAV01@@Z + ??4?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@$$QAV01@@Z + ??4?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@$$QAV01@@Z + ??4?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@$$QAV01@@Z + ??4?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@$$QAV01@@Z + ??4?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEAAV01@ABV01@@Z + ??4?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEAAV01@ABV01@@Z + ??4?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEAAV01@ABV01@@Z + ??4?$numeric_limits@C@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@D@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@E@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@F@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@G@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@H@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@I@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@J@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@K@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@M@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@N@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@O@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@_J@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@_K@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@_N@std@@QAEAAV01@ABV01@@Z + ??4?$numeric_limits@_W@std@@QAEAAV01@ABV01@@Z + ??4Init@ios_base@std@@QAEAAV012@ABV012@@Z + ??4_Container_base0@std@@QAEAAU01@ABU01@@Z + ??4_Container_base12@std@@QAEAAU01@ABU01@@Z + ??4_Init_locks@std@@QAEAAV01@ABV01@@Z + ??4_Num_base@std@@QAEAAU01@ABU01@@Z + ??4_Num_float_base@std@@QAEAAU01@ABU01@@Z + ??4_Num_int_base@std@@QAEAAU01@ABU01@@Z + ??4_Timevec@std@@QAEAAV01@ABV01@@Z + ??4_UShinit@std@@QAEAAV01@ABV01@@Z + ??4_Winit@std@@QAEAAV01@ABV01@@Z + ??4ios_base@std@@QAEAAV01@ABV01@@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAF@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAG@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAH@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAI@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAJ@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAK@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAM@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAN@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAO@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAPAX@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AA_J@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AA_K@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AA_N@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@DU?$char_traits@D@std@@@1@AAV21@@Z@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z + ??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAF@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAG@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAH@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAI@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAJ@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAK@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAM@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAN@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAO@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAPAX@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AA_J@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AA_K@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AA_N@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@GU?$char_traits@G@std@@@1@AAV21@@Z@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z + ??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAF@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAG@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAH@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAI@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAJ@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAK@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAM@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAN@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAO@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAPAX@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AA_J@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AA_K@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AA_N@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AAV21@@Z@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z + ??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@F@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@G@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@H@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@I@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@J@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@K@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@M@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@N@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@O@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@DU?$char_traits@D@std@@@1@AAV21@@Z@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@PBX@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@_J@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@_K@Z + ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@_N@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@F@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@G@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@H@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@I@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@J@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@K@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@M@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@N@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@O@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@GU?$char_traits@G@std@@@1@AAV21@@Z@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@PBX@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@_J@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@_K@Z + ??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@_N@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@F@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@G@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@H@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@I@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@J@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@K@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@M@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@N@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@O@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AAV21@@Z@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@PBX@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@_J@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@_K@Z + ??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@_N@Z + ??7ios_base@std@@QBE_NXZ + ??Bid@locale@std@@QAEIXZ + ??Bios_base@std@@QBEPAXXZ + ??_7?$basic_ios@DU?$char_traits@D@std@@@std@@6B@ + ??_7?$basic_ios@GU?$char_traits@G@std@@@std@@6B@ + ??_7?$basic_ios@_WU?$char_traits@_W@std@@@std@@6B@ + ??_7?$basic_iostream@DU?$char_traits@D@std@@@std@@6B@ + ??_7?$basic_iostream@GU?$char_traits@G@std@@@std@@6B@ + ??_7?$basic_iostream@_WU?$char_traits@_W@std@@@std@@6B@ + ??_7?$basic_istream@DU?$char_traits@D@std@@@std@@6B@ + ??_7?$basic_istream@GU?$char_traits@G@std@@@std@@6B@ + ??_7?$basic_istream@_WU?$char_traits@_W@std@@@std@@6B@ + ??_7?$basic_ostream@DU?$char_traits@D@std@@@std@@6B@ + ??_7?$basic_ostream@GU?$char_traits@G@std@@@std@@6B@ + ??_7?$basic_ostream@_WU?$char_traits@_W@std@@@std@@6B@ + ??_7?$basic_streambuf@DU?$char_traits@D@std@@@std@@6B@ + ??_7?$basic_streambuf@GU?$char_traits@G@std@@@std@@6B@ + ??_7?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@6B@ + ??_7?$codecvt@DDH@std@@6B@ + ??_7?$codecvt@GDH@std@@6B@ + ??_7?$codecvt@_WDH@std@@6B@ + ??_7?$ctype@D@std@@6B@ + ??_7?$ctype@G@std@@6B@ + ??_7?$ctype@_W@std@@6B@ + ??_7?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@ + ??_7?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@ + ??_7?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@ + ??_7?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@ + ??_7?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@ + ??_7?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@ + ??_7?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@ + ??_7?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@ + ??_7?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@ + ??_7?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@ + ??_7?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@ + ??_7?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@ + ??_7_Locimp@locale@std@@6B@ + ??_7codecvt_base@std@@6B@ + ??_7ctype_base@std@@6B@ + ??_7ios_base@std@@6B@ + ??_7time_base@std@@6B@ + ??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_istream@DU?$char_traits@D@std@@@1@@ + ??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_ostream@DU?$char_traits@D@std@@@1@@ + ??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_istream@GU?$char_traits@G@std@@@1@@ + ??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_ostream@GU?$char_traits@G@std@@@1@@ + ??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_istream@_WU?$char_traits@_W@std@@@1@@ + ??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_ostream@_WU?$char_traits@_W@std@@@1@@ + ??_8?$basic_istream@DU?$char_traits@D@std@@@std@@7B@ + ??_8?$basic_istream@GU?$char_traits@G@std@@@std@@7B@ + ??_8?$basic_istream@_WU?$char_traits@_W@std@@@std@@7B@ + ??_8?$basic_ostream@DU?$char_traits@D@std@@@std@@7B@ + ??_8?$basic_ostream@GU?$char_traits@G@std@@@std@@7B@ + ??_8?$basic_ostream@_WU?$char_traits@_W@std@@@std@@7B@ + ??_D?$basic_iostream@DU?$char_traits@D@std@@@std@@QAEXXZ + ??_D?$basic_iostream@GU?$char_traits@G@std@@@std@@QAEXXZ + ??_D?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ + ??_D?$basic_istream@DU?$char_traits@D@std@@@std@@QAEXXZ + ??_D?$basic_istream@GU?$char_traits@G@std@@@std@@QAEXXZ + ??_D?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEXXZ + ??_D?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXXZ + ??_D?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXXZ + ??_D?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ + ??_F?$codecvt@DDH@std@@QAEXXZ + ??_F?$codecvt@GDH@std@@QAEXXZ + ??_F?$codecvt@_WDH@std@@QAEXXZ + ??_F?$ctype@D@std@@QAEXXZ + ??_F?$ctype@G@std@@QAEXXZ + ??_F?$ctype@_W@std@@QAEXXZ + ??_F?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ + ??_F?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ + ??_F?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ + ??_F?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ + ??_F?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ + ??_F?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ + ??_F?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ + ??_F?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ + ??_F?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ + ??_F?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ + ??_F?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ + ??_F?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ + ??_F_Locimp@locale@std@@QAEXXZ + ??_F_Locinfo@std@@QAEXXZ + ??_F_Timevec@std@@QAEXXZ + ??_Fcodecvt_base@std@@QAEXXZ + ??_Fctype_base@std@@QAEXXZ + ??_Ffacet@locale@std@@QAEXXZ + ??_Fid@locale@std@@QAEXXZ + ??_Ftime_base@std@@QAEXXZ + ?NFS_Allocate@details@Concurrency@@YAPAXIIPAX@Z + ?NFS_Free@details@Concurrency@@YAXPAX@Z + ?NFS_GetLineSize@details@Concurrency@@YAIXZ + ?_Addcats@_Locinfo@std@@QAEAAV12@HPBD@Z + ?_Addfac@_Locimp@locale@std@@AAEXPAVfacet@23@I@Z + ?_Addstd@ios_base@std@@SAXPAV12@@Z + ?_Advance@_Concurrent_queue_iterator_base_v4@details@Concurrency@@IAEXXZ + ?_Assign@_Concurrent_queue_iterator_base_v4@details@Concurrency@@IAEXABV123@@Z + ?_Atexit@@YAXP6AXXZ@Z + ?_BADOFF@std@@3_JB + ?_C_str@?$_Yarn@D@std@@QBEPBDXZ + ?_Callfns@ios_base@std@@AAEXW4event@12@@Z + ?_Clocptr@_Locimp@locale@std@@0PAV123@A + ?_Decref@facet@locale@std@@QAEPAV123@XZ + ?_Donarrow@?$ctype@G@std@@IBEDGD@Z + ?_Donarrow@?$ctype@_W@std@@IBED_WD@Z + ?_Dowiden@?$ctype@G@std@@IBEGD@Z + ?_Dowiden@?$ctype@_W@std@@IBE_WD@Z + ?_Empty@?$_Yarn@D@std@@QBE_NXZ + ?_Ffmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAPADPADDH@Z + ?_Ffmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAPADPADDH@Z + ?_Ffmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAPADPADDH@Z + ?_Findarr@ios_base@std@@AAEAAU_Iosarray@12@H@Z + ?_Fiopen@std@@YAPAU_iobuf@@PBDHH@Z + ?_Fiopen@std@@YAPAU_iobuf@@PBGHH@Z + ?_Fiopen@std@@YAPAU_iobuf@@PB_WHH@Z + ?_Fput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBDIIII@Z + ?_Fput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBDIIII@Z + ?_Fput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBDIIII@Z + ?_GetCombinableSize@details@Concurrency@@YAIXZ + ?_GetCurrentThreadId@details@Concurrency@@YAKXZ + ?_Getcat@?$codecvt@DDH@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$codecvt@GDH@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$codecvt@_WDH@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$ctype@D@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$ctype@G@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$ctype@_W@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z + ?_Getcat@facet@locale@std@@SAIPAPBV123@PBV23@@Z + ?_Getcoll@_Locinfo@std@@QBE?AU_Collvec@@XZ + ?_Getctype@_Locinfo@std@@QBE?AU_Ctypevec@@XZ + ?_Getcvt@_Locinfo@std@@QBE?AU_Cvtvec@@XZ + ?_Getdateorder@_Locinfo@std@@QBEHXZ + ?_Getdays@_Locinfo@std@@QBEPBDXZ + ?_Getfalse@_Locinfo@std@@QBEPBDXZ + ?_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AAVios_base@2@PAH@Z + ?_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AAVios_base@2@PAH@Z + ?_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AAVios_base@2@PAH@Z + ?_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AAVios_base@2@PAH@Z + ?_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AAVios_base@2@PAH@Z + ?_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AAVios_base@2@PAH@Z + ?_Getfmt@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD@Z + ?_Getfmt@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD@Z + ?_Getfmt@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD@Z + ?_Getgloballocale@locale@std@@CAPAV_Locimp@12@XZ + ?_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1HABVlocale@2@@Z + ?_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1HABVlocale@2@@Z + ?_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1HABVlocale@2@@Z + ?_Getint@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@0HHAAH@Z + ?_Getint@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@0HHAAH@Z + ?_Getint@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@0HHAAH@Z + ?_Getlconv@_Locinfo@std@@QBEPBUlconv@@XZ + ?_Getmonths@_Locinfo@std@@QBEPBDXZ + ?_Getname@_Locinfo@std@@QBEPBDXZ + ?_Getpfirst@_Container_base12@std@@QBEPAPAU_Iterator_base12@2@XZ + ?_Getptr@_Timevec@std@@QBEPAXXZ + ?_Gettnames@_Locinfo@std@@QBE?AV_Timevec@2@XZ + ?_Gettrue@_Locinfo@std@@QBEPBDXZ + ?_Gnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBE_JXZ + ?_Gnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBE_JXZ + ?_Gnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBE_JXZ + ?_Gndec@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ + ?_Gndec@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ + ?_Gndec@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ + ?_Gninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ + ?_Gninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ + ?_Gninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ + ?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ + ?_Gnpreinc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ + ?_Gnpreinc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ + ?_Hexdig@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHDDDD@Z + ?_Hexdig@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHGGGG@Z + ?_Hexdig@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAH_W000@Z + ?_Id_cnt@id@locale@std@@0HA + ?_Ifmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAPADPADPBDH@Z + ?_Ifmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAPADPADPBDH@Z + ?_Ifmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAPADPADPBDH@Z + ?_Incref@facet@locale@std@@QAEXXZ + ?_Index@ios_base@std@@0HA + ?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAPAD0PAH001@Z + ?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXXZ + ?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAPAG0PAH001@Z + ?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXXZ + ?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPAPA_W0PAH001@Z + ?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXXZ + ?_Init@?$codecvt@DDH@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$codecvt@GDH@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$codecvt@_WDH@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$ctype@D@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$ctype@G@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$ctype@_W@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z + ?_Init@ios_base@std@@IAEXXZ + ?_Init@locale@std@@CAPAV_Locimp@12@XZ + ?_Init_cnt@Init@ios_base@std@@0HA + ?_Init_cnt@_UShinit@std@@0HA + ?_Init_cnt@_Winit@std@@0HA + ?_Init_cnt_func@Init@ios_base@std@@CAAAHXZ + ?_Init_ctor@Init@ios_base@std@@CAXPAV123@@Z + ?_Init_dtor@Init@ios_base@std@@CAXPAV123@@Z + ?_Init_locks_ctor@_Init_locks@std@@CAXPAV12@@Z + ?_Init_locks_dtor@_Init_locks@std@@CAXPAV12@@Z + ?_Internal_assign@_Concurrent_vector_base_v4@details@Concurrency@@IAEXABV123@IP6AXPAXI@ZP6AX1PBXI@Z4@Z + ?_Internal_capacity@_Concurrent_vector_base_v4@details@Concurrency@@IBEIXZ + ?_Internal_clear@_Concurrent_vector_base_v4@details@Concurrency@@IAEIP6AXPAXI@Z@Z + ?_Internal_compact@_Concurrent_vector_base_v4@details@Concurrency@@IAEPAXIPAXP6AX0I@ZP6AX0PBXI@Z@Z + ?_Internal_copy@_Concurrent_vector_base_v4@details@Concurrency@@IAEXABV123@IP6AXPAXPBXI@Z@Z + ?_Internal_empty@_Concurrent_queue_base_v4@details@Concurrency@@IBE_NXZ + ?_Internal_finish_clear@_Concurrent_queue_base_v4@details@Concurrency@@IAEXXZ + ?_Internal_grow_by@_Concurrent_vector_base_v4@details@Concurrency@@IAEIIIP6AXPAXPBXI@Z1@Z + ?_Internal_grow_to_at_least_with_result@_Concurrent_vector_base_v4@details@Concurrency@@IAEIIIP6AXPAXPBXI@Z1@Z + ?_Internal_pop_if_present@_Concurrent_queue_base_v4@details@Concurrency@@IAE_NPAX@Z + ?_Internal_push@_Concurrent_queue_base_v4@details@Concurrency@@IAEXPBX@Z + ?_Internal_push_back@_Concurrent_vector_base_v4@details@Concurrency@@IAEPAXIAAI@Z + ?_Internal_reserve@_Concurrent_vector_base_v4@details@Concurrency@@IAEXIII@Z + ?_Internal_resize@_Concurrent_vector_base_v4@details@Concurrency@@IAEXIIIP6AXPAXI@ZP6AX0PBXI@Z2@Z + ?_Internal_size@_Concurrent_queue_base_v4@details@Concurrency@@IBEIXZ + ?_Internal_swap@_Concurrent_vector_base_v4@details@Concurrency@@IAEXAAV123@@Z + ?_Internal_throw_exception@_Concurrent_queue_base_v4@details@Concurrency@@IBEXXZ + ?_Internal_throw_exception@_Concurrent_vector_base_v4@details@Concurrency@@IBEXI@Z + ?_Ios_base_dtor@ios_base@std@@CAXPAV12@@Z + ?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z + ?_Ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE_N_N@Z + ?_Ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE_N_N@Z + ?_Iput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPADI@Z + ?_Iput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPADI@Z + ?_Iput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPADI@Z + ?_Locimp_Addfac@_Locimp@locale@std@@CAXPAV123@PAVfacet@23@I@Z + ?_Locimp_ctor@_Locimp@locale@std@@CAXPAV123@ABV123@@Z + ?_Locimp_dtor@_Locimp@locale@std@@CAXPAV123@@Z + ?_Locinfo_Addcats@_Locinfo@std@@SAAAV12@PAV12@HPBD@Z + ?_Locinfo_ctor@_Locinfo@std@@SAXPAV12@HPBD@Z + ?_Locinfo_ctor@_Locinfo@std@@SAXPAV12@PBD@Z + ?_Locinfo_dtor@_Locinfo@std@@SAXPAV12@@Z + ?_Lock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UAEXXZ + ?_Lock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UAEXXZ + ?_Lock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UAEXXZ + ?_Lock@_Mutex@std@@QAEXXZ + ?_Lockit_ctor@_Lockit@std@@CAXPAV12@@Z + ?_Lockit_ctor@_Lockit@std@@CAXPAV12@H@Z + ?_Lockit_ctor@_Lockit@std@@SAXH@Z + ?_Lockit_dtor@_Lockit@std@@CAXPAV12@@Z + ?_Lockit_dtor@_Lockit@std@@SAXH@Z + ?_MP_Add@tr1@std@@YAXQA_K_K@Z + ?_MP_Get@tr1@std@@YA_KQA_K@Z + ?_MP_Mul@tr1@std@@YAXQA_K_K1@Z + ?_MP_Rem@tr1@std@@YAXQA_K_K@Z + ?_Makeloc@_Locimp@locale@std@@CAPAV123@ABV_Locinfo@3@HPAV123@PBV23@@Z + ?_Makeushloc@_Locimp@locale@std@@CAXABV_Locinfo@3@HPAV123@PBV23@@Z + ?_Makewloc@_Locimp@locale@std@@CAXABV_Locinfo@3@HPAV123@PBV23@@Z + ?_Makexloc@_Locimp@locale@std@@CAXABV_Locinfo@3@HPAV123@PBV23@@Z + ?_Mtx_delete@threads@stdext@@YAXPAX@Z + ?_Mtx_lock@threads@stdext@@YAXPAX@Z + ?_Mtx_new@threads@stdext@@YAXAAPAX@Z + ?_Mtx_unlock@threads@stdext@@YAXPAX@Z + ?_Mutex_Lock@_Mutex@std@@CAXPAV12@@Z + ?_Mutex_Unlock@_Mutex@std@@CAXPAV12@@Z + ?_Mutex_ctor@_Mutex@std@@CAXPAV12@@Z + ?_Mutex_dtor@_Mutex@std@@CAXPAV12@@Z + ?_Nomemory@std@@YAXXZ + ?_Orphan_all@_Container_base0@std@@QAEXXZ + ?_Orphan_all@_Container_base12@std@@QAEXXZ + ?_Osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXXZ + ?_Osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXXZ + ?_Osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ + ?_Pnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBE_JXZ + ?_Pnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBE_JXZ + ?_Pnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBE_JXZ + ?_Pninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ + ?_Pninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ + ?_Pninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ + ?_Ptr_cerr@std@@3PAV?$basic_ostream@DU?$char_traits@D@std@@@1@A + ?_Ptr_cin@std@@3PAV?$basic_istream@DU?$char_traits@D@std@@@1@A + ?_Ptr_clog@std@@3PAV?$basic_ostream@DU?$char_traits@D@std@@@1@A + ?_Ptr_cout@std@@3PAV?$basic_ostream@DU?$char_traits@D@std@@@1@A + ?_Ptr_wcerr@std@@3PAV?$basic_ostream@GU?$char_traits@G@std@@@1@A + ?_Ptr_wcerr@std@@3PAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@A + ?_Ptr_wcin@std@@3PAV?$basic_istream@GU?$char_traits@G@std@@@1@A + ?_Ptr_wcin@std@@3PAV?$basic_istream@_WU?$char_traits@_W@std@@@1@A + ?_Ptr_wclog@std@@3PAV?$basic_ostream@GU?$char_traits@G@std@@@1@A + ?_Ptr_wclog@std@@3PAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@A + ?_Ptr_wcout@std@@3PAV?$basic_ostream@GU?$char_traits@G@std@@@1@A + ?_Ptr_wcout@std@@3PAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@A + ?_Put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@PBDI@Z + ?_Put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@PBGI@Z + ?_Put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@PB_WI@Z + ?_Putc@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@PBDI@Z + ?_Putc@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@PBDI@Z + ?_Putc@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@PBDI@Z + ?_Putgrouped@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@PBDID@Z + ?_Putgrouped@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@PBDIG@Z + ?_Putgrouped@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@PBDI_W@Z + ?_Raise_handler@std@@3P6AXABVexception@stdext@@@ZA + ?_Random_device@tr1@std@@YAIXZ + ?_Rep@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@DI@Z + ?_Rep@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@GI@Z + ?_Rep@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@_WI@Z + ?_Rng_abort@tr1@std@@YAXPBD@Z + ?_Segment_index_of@_Concurrent_vector_base_v4@details@Concurrency@@KAII@Z + ?_Setgloballocale@locale@std@@CAXPAX@Z + ?_Swap_all@_Container_base0@std@@QAEXAAU12@@Z + ?_Swap_all@_Container_base12@std@@QAEXAAU12@@Z + ?_Sync@ios_base@std@@0_NA + ?_Tidy@?$_Yarn@D@std@@AAEXXZ + ?_Tidy@?$ctype@D@std@@IAEXXZ + ?_Tidy@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AAEXXZ + ?_Tidy@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AAEXXZ + ?_Tidy@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AAEXXZ + ?_Tidy@ios_base@std@@AAEXXZ + ?_Unlock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UAEXXZ + ?_Unlock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UAEXXZ + ?_Unlock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UAEXXZ + ?_Unlock@_Mutex@std@@QAEXXZ + ?_XLgamma@tr1@std@@YAMM@Z + ?_XLgamma@tr1@std@@YANN@Z + ?_XLgamma@tr1@std@@YAOO@Z + ?_Xbad@tr1@std@@YAXW4error_type@regex_constants@12@@Z + ?_Xfunc@tr1@std@@YAXXZ + ?_Xinvalid_argument@std@@YAXPBD@Z + ?_Xlength_error@std@@YAXPBD@Z + ?_Xmem@tr1@std@@YAXXZ + ?_Xout_of_range@std@@YAXPBD@Z + ?_Xoverflow_error@std@@YAXPBD@Z + ?_Xruntime_error@std@@YAXPBD@Z + ?always_noconv@codecvt_base@std@@QBE_NXZ + ?bad@ios_base@std@@QBE_NXZ + ?c_str@?$_Yarn@D@std@@QBEPBDXZ + ?cancel@agent@Concurrency@@QAE_NXZ + ?cerr@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A + ?cin@std@@3V?$basic_istream@DU?$char_traits@D@std@@@1@A + ?classic@locale@std@@SAABV12@XZ + ?classic_table@?$ctype@D@std@@SAPBFXZ + ?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z + ?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXI@Z + ?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXH_N@Z + ?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXI@Z + ?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXH_N@Z + ?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXI@Z + ?clear@ios_base@std@@QAEXH@Z + ?clear@ios_base@std@@QAEXH_N@Z + ?clear@ios_base@std@@QAEXI@Z + ?clog@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A + ?copyfmt@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEAAV12@ABV12@@Z + ?copyfmt@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEAAV12@ABV12@@Z + ?copyfmt@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEAAV12@ABV12@@Z + ?copyfmt@ios_base@std@@QAEAAV12@ABV12@@Z + ?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A + ?date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AW4dateorder@time_base@2@XZ + ?date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AW4dateorder@time_base@2@XZ + ?date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AW4dateorder@time_base@2@XZ + ?denorm_min@?$numeric_limits@C@std@@SACXZ + ?denorm_min@?$numeric_limits@D@std@@SADXZ + ?denorm_min@?$numeric_limits@E@std@@SAEXZ + ?denorm_min@?$numeric_limits@F@std@@SAFXZ + ?denorm_min@?$numeric_limits@G@std@@SAGXZ + ?denorm_min@?$numeric_limits@H@std@@SAHXZ + ?denorm_min@?$numeric_limits@I@std@@SAIXZ + ?denorm_min@?$numeric_limits@J@std@@SAJXZ + ?denorm_min@?$numeric_limits@K@std@@SAKXZ + ?denorm_min@?$numeric_limits@M@std@@SAMXZ + ?denorm_min@?$numeric_limits@N@std@@SANXZ + ?denorm_min@?$numeric_limits@O@std@@SAOXZ + ?denorm_min@?$numeric_limits@_J@std@@SA_JXZ + ?denorm_min@?$numeric_limits@_K@std@@SA_KXZ + ?denorm_min@?$numeric_limits@_N@std@@SA_NXZ + ?denorm_min@?$numeric_limits@_W@std@@SA_WXZ + ?digits10@?$numeric_limits@C@std@@2HB + ?digits10@?$numeric_limits@D@std@@2HB + ?digits10@?$numeric_limits@E@std@@2HB + ?digits10@?$numeric_limits@F@std@@2HB + ?digits10@?$numeric_limits@G@std@@2HB + ?digits10@?$numeric_limits@H@std@@2HB + ?digits10@?$numeric_limits@I@std@@2HB + ?digits10@?$numeric_limits@J@std@@2HB + ?digits10@?$numeric_limits@K@std@@2HB + ?digits10@?$numeric_limits@M@std@@2HB + ?digits10@?$numeric_limits@N@std@@2HB + ?digits10@?$numeric_limits@O@std@@2HB + ?digits10@?$numeric_limits@_J@std@@2HB + ?digits10@?$numeric_limits@_K@std@@2HB + ?digits10@?$numeric_limits@_N@std@@2HB + ?digits10@?$numeric_limits@_W@std@@2HB + ?digits10@_Num_base@std@@2HB + ?digits@?$numeric_limits@C@std@@2HB + ?digits@?$numeric_limits@D@std@@2HB + ?digits@?$numeric_limits@E@std@@2HB + ?digits@?$numeric_limits@F@std@@2HB + ?digits@?$numeric_limits@G@std@@2HB + ?digits@?$numeric_limits@H@std@@2HB + ?digits@?$numeric_limits@I@std@@2HB + ?digits@?$numeric_limits@J@std@@2HB + ?digits@?$numeric_limits@K@std@@2HB + ?digits@?$numeric_limits@M@std@@2HB + ?digits@?$numeric_limits@N@std@@2HB + ?digits@?$numeric_limits@O@std@@2HB + ?digits@?$numeric_limits@_J@std@@2HB + ?digits@?$numeric_limits@_K@std@@2HB + ?digits@?$numeric_limits@_N@std@@2HB + ?digits@?$numeric_limits@_W@std@@2HB + ?digits@_Num_base@std@@2HB + ?do_always_noconv@?$codecvt@GDH@std@@MBE_NXZ + ?do_always_noconv@?$codecvt@_WDH@std@@MBE_NXZ + ?do_always_noconv@codecvt_base@std@@MBE_NXZ + ?do_date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AW4dateorder@time_base@2@XZ + ?do_date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AW4dateorder@time_base@2@XZ + ?do_date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AW4dateorder@time_base@2@XZ + ?do_encoding@codecvt_base@std@@MBEHXZ + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAG@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAI@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAK@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAM@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAN@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAO@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z + ?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAG@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAI@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAK@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAM@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAN@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAO@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z + ?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAG@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAI@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAK@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAM@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAN@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAO@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z + ?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z + ?do_get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z + ?do_get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z + ?do_get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z + ?do_get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?do_in@?$codecvt@DDH@std@@MBEHAAHPBD1AAPBDPAD3AAPAD@Z + ?do_in@?$codecvt@GDH@std@@MBEHAAHPBD1AAPBDPAG3AAPAG@Z + ?do_in@?$codecvt@_WDH@std@@MBEHAAHPBD1AAPBDPA_W3AAPA_W@Z + ?do_is@?$ctype@G@std@@MBEPBGPBG0PAF@Z + ?do_is@?$ctype@G@std@@MBE_NFG@Z + ?do_is@?$ctype@_W@std@@MBEPB_WPB_W0PAF@Z + ?do_is@?$ctype@_W@std@@MBE_NF_W@Z + ?do_length@?$codecvt@DDH@std@@MBEHABHPBD1I@Z + ?do_length@?$codecvt@GDH@std@@MBEHABHPBD1I@Z + ?do_length@?$codecvt@_WDH@std@@MBEHABHPBD1I@Z + ?do_max_length@?$codecvt@GDH@std@@MBEHXZ + ?do_max_length@?$codecvt@_WDH@std@@MBEHXZ + ?do_max_length@codecvt_base@std@@MBEHXZ + ?do_narrow@?$ctype@D@std@@MBEDDD@Z + ?do_narrow@?$ctype@D@std@@MBEPBDPBD0DPAD@Z + ?do_narrow@?$ctype@G@std@@MBEDGD@Z + ?do_narrow@?$ctype@G@std@@MBEPBGPBG0DPAD@Z + ?do_narrow@?$ctype@_W@std@@MBED_WD@Z + ?do_narrow@?$ctype@_W@std@@MBEPB_WPB_W0DPAD@Z + ?do_out@?$codecvt@DDH@std@@MBEHAAHPBD1AAPBDPAD3AAPAD@Z + ?do_out@?$codecvt@GDH@std@@MBEHAAHPBG1AAPBGPAD3AAPAD@Z + ?do_out@?$codecvt@_WDH@std@@MBEHAAHPB_W1AAPB_WPAD3AAPAD@Z + ?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DJ@Z + ?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DK@Z + ?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DN@Z + ?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DO@Z + ?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBX@Z + ?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_J@Z + ?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_K@Z + ?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_N@Z + ?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GJ@Z + ?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GK@Z + ?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GN@Z + ?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GO@Z + ?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBX@Z + ?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_J@Z + ?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_K@Z + ?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_N@Z + ?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WJ@Z + ?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WK@Z + ?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WN@Z + ?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WO@Z + ?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBX@Z + ?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_J@Z + ?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_K@Z + ?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_N@Z + ?do_put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBUtm@@DD@Z + ?do_put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBUtm@@DD@Z + ?do_put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBUtm@@DD@Z + ?do_scan_is@?$ctype@G@std@@MBEPBGFPBG0@Z + ?do_scan_is@?$ctype@_W@std@@MBEPB_WFPB_W0@Z + ?do_scan_not@?$ctype@G@std@@MBEPBGFPBG0@Z + ?do_scan_not@?$ctype@_W@std@@MBEPB_WFPB_W0@Z + ?do_tolower@?$ctype@D@std@@MBEDD@Z + ?do_tolower@?$ctype@D@std@@MBEPBDPADPBD@Z + ?do_tolower@?$ctype@G@std@@MBEGG@Z + ?do_tolower@?$ctype@G@std@@MBEPBGPAGPBG@Z + ?do_tolower@?$ctype@_W@std@@MBEPB_WPA_WPB_W@Z + ?do_tolower@?$ctype@_W@std@@MBE_W_W@Z + ?do_toupper@?$ctype@D@std@@MBEDD@Z + ?do_toupper@?$ctype@D@std@@MBEPBDPADPBD@Z + ?do_toupper@?$ctype@G@std@@MBEGG@Z + ?do_toupper@?$ctype@G@std@@MBEPBGPAGPBG@Z + ?do_toupper@?$ctype@_W@std@@MBEPB_WPA_WPB_W@Z + ?do_toupper@?$ctype@_W@std@@MBE_W_W@Z + ?do_unshift@?$codecvt@DDH@std@@MBEHAAHPAD1AAPAD@Z + ?do_unshift@?$codecvt@GDH@std@@MBEHAAHPAD1AAPAD@Z + ?do_unshift@?$codecvt@_WDH@std@@MBEHAAHPAD1AAPAD@Z + ?do_widen@?$ctype@D@std@@MBEDD@Z + ?do_widen@?$ctype@D@std@@MBEPBDPBD0PAD@Z + ?do_widen@?$ctype@G@std@@MBEGD@Z + ?do_widen@?$ctype@G@std@@MBEPBDPBD0PAG@Z + ?do_widen@?$ctype@_W@std@@MBEPBDPBD0PA_W@Z + ?do_widen@?$ctype@_W@std@@MBE_WD@Z + ?done@agent@Concurrency@@IAE_NXZ + ?eback@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ + ?eback@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ + ?eback@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ + ?egptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ + ?egptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ + ?egptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ + ?empty@?$_Yarn@D@std@@QBE_NXZ + ?empty@locale@std@@SA?AV12@XZ + ?encoding@codecvt_base@std@@QBEHXZ + ?endl@std@@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@1@AAV21@@Z + ?endl@std@@YAAAV?$basic_ostream@GU?$char_traits@G@std@@@1@AAV21@@Z + ?endl@std@@YAAAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@AAV21@@Z + ?ends@std@@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@1@AAV21@@Z + ?ends@std@@YAAAV?$basic_ostream@GU?$char_traits@G@std@@@1@AAV21@@Z + ?ends@std@@YAAAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@AAV21@@Z + ?eof@ios_base@std@@QBE_NXZ + ?epptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ + ?epptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ + ?epptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ + ?epsilon@?$numeric_limits@C@std@@SACXZ + ?epsilon@?$numeric_limits@D@std@@SADXZ + ?epsilon@?$numeric_limits@E@std@@SAEXZ + ?epsilon@?$numeric_limits@F@std@@SAFXZ + ?epsilon@?$numeric_limits@G@std@@SAGXZ + ?epsilon@?$numeric_limits@H@std@@SAHXZ + ?epsilon@?$numeric_limits@I@std@@SAIXZ + ?epsilon@?$numeric_limits@J@std@@SAJXZ + ?epsilon@?$numeric_limits@K@std@@SAKXZ + ?epsilon@?$numeric_limits@M@std@@SAMXZ + ?epsilon@?$numeric_limits@N@std@@SANXZ + ?epsilon@?$numeric_limits@O@std@@SAOXZ + ?epsilon@?$numeric_limits@_J@std@@SA_JXZ + ?epsilon@?$numeric_limits@_K@std@@SA_KXZ + ?epsilon@?$numeric_limits@_N@std@@SA_NXZ + ?epsilon@?$numeric_limits@_W@std@@SA_WXZ + ?exceptions@ios_base@std@@QAEXH@Z + ?exceptions@ios_base@std@@QAEXI@Z + ?exceptions@ios_base@std@@QBEHXZ + ?fail@ios_base@std@@QBE_NXZ + ?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEDD@Z + ?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEDXZ + ?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEGG@Z + ?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEGXZ + ?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAE_W_W@Z + ?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBE_WXZ + ?flags@ios_base@std@@QAEHH@Z + ?flags@ios_base@std@@QBEHXZ + ?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@XZ + ?flush@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@XZ + ?flush@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@XZ + ?flush@std@@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@1@AAV21@@Z + ?flush@std@@YAAAV?$basic_ostream@GU?$char_traits@G@std@@@1@AAV21@@Z + ?flush@std@@YAAAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@AAV21@@Z + ?gbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXH@Z + ?gbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXH@Z + ?gbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXH@Z + ?gcount@?$basic_istream@DU?$char_traits@D@std@@@std@@QBE_JXZ + ?gcount@?$basic_istream@GU?$char_traits@G@std@@@std@@QBE_JXZ + ?gcount@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QBE_JXZ + ?generic_category@std@@YAABVerror_category@1@XZ + ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@AAD@Z + ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@AAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z + ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@AAV?$basic_streambuf@DU?$char_traits@D@std@@@2@D@Z + ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_J@Z + ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_JD@Z + ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ + ?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@AAG@Z + ?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@AAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z + ?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@AAV?$basic_streambuf@GU?$char_traits@G@std@@@2@G@Z + ?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_J@Z + ?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_JG@Z + ?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEGXZ + ?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@AAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z + ?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@AAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_W@Z + ?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@AA_W@Z + ?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J@Z + ?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J_W@Z + ?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEGXZ + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAG@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAI@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAK@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAM@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAN@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAO@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z + ?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAG@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAI@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAK@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAM@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAN@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAO@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z + ?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAG@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAI@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAK@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAM@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAN@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAO@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z + ?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z + ?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z + ?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD4@Z + ?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z + ?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBG4@Z + ?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z + ?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PB_W4@Z + ?get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z + ?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_J@Z + ?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_JD@Z + ?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_J@Z + ?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_JG@Z + ?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J@Z + ?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J_W@Z + ?getloc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QBE?AVlocale@2@XZ + ?getloc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QBE?AVlocale@2@XZ + ?getloc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QBE?AVlocale@2@XZ + ?getloc@ios_base@std@@QBE?AVlocale@2@XZ + ?global@locale@std@@SA?AV12@ABV12@@Z + ?good@ios_base@std@@QBE_NXZ + ?gptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ + ?gptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ + ?gptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ + ?has_denorm@_Num_base@std@@2W4float_denorm_style@2@B + ?has_denorm@_Num_float_base@std@@2W4float_denorm_style@2@B + ?has_denorm_loss@_Num_base@std@@2_NB + ?has_denorm_loss@_Num_float_base@std@@2_NB + ?has_infinity@_Num_base@std@@2_NB + ?has_infinity@_Num_float_base@std@@2_NB + ?has_quiet_NaN@_Num_base@std@@2_NB + ?has_quiet_NaN@_Num_float_base@std@@2_NB + ?has_signaling_NaN@_Num_base@std@@2_NB + ?has_signaling_NaN@_Num_float_base@std@@2_NB + ?id@?$codecvt@DDH@std@@2V0locale@2@A + ?id@?$codecvt@GDH@std@@2V0locale@2@A + ?id@?$codecvt@_WDH@std@@2V0locale@2@A + ?id@?$collate@D@std@@2V0locale@2@A + ?id@?$collate@G@std@@2V0locale@2@A + ?id@?$collate@_W@std@@2V0locale@2@A + ?id@?$ctype@D@std@@2V0locale@2@A + ?id@?$ctype@G@std@@2V0locale@2@A + ?id@?$ctype@_W@std@@2V0locale@2@A + ?id@?$messages@D@std@@2V0locale@2@A + ?id@?$messages@G@std@@2V0locale@2@A + ?id@?$messages@_W@std@@2V0locale@2@A + ?id@?$money_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A + ?id@?$money_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A + ?id@?$money_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A + ?id@?$money_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A + ?id@?$money_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A + ?id@?$money_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A + ?id@?$moneypunct@D$00@std@@2V0locale@2@A + ?id@?$moneypunct@D$0A@@std@@2V0locale@2@A + ?id@?$moneypunct@G$00@std@@2V0locale@2@A + ?id@?$moneypunct@G$0A@@std@@2V0locale@2@A + ?id@?$moneypunct@_W$00@std@@2V0locale@2@A + ?id@?$moneypunct@_W$0A@@std@@2V0locale@2@A + ?id@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A + ?id@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A + ?id@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A + ?id@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A + ?id@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A + ?id@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A + ?id@?$numpunct@D@std@@2V0locale@2@A + ?id@?$numpunct@G@std@@2V0locale@2@A + ?id@?$numpunct@_W@std@@2V0locale@2@A + ?id@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A + ?id@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A + ?id@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A + ?id@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A + ?id@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A + ?id@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A + ?ignore@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@_JH@Z + ?ignore@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@_JG@Z + ?ignore@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_JG@Z + ?imbue@?$basic_ios@DU?$char_traits@D@std@@@std@@QAE?AVlocale@2@ABV32@@Z + ?imbue@?$basic_ios@GU?$char_traits@G@std@@@std@@QAE?AVlocale@2@ABV32@@Z + ?imbue@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAE?AVlocale@2@ABV32@@Z + ?imbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEXABVlocale@2@@Z + ?imbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEXABVlocale@2@@Z + ?imbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEXABVlocale@2@@Z + ?imbue@ios_base@std@@QAE?AVlocale@2@ABV32@@Z + ?in@?$codecvt@DDH@std@@QBEHAAHPBD1AAPBDPAD3AAPAD@Z + ?in@?$codecvt@GDH@std@@QBEHAAHPBD1AAPBDPAG3AAPAG@Z + ?in@?$codecvt@_WDH@std@@QBEHAAHPBD1AAPBDPA_W3AAPA_W@Z + ?in_avail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE_JXZ + ?in_avail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE_JXZ + ?in_avail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE_JXZ + ?infinity@?$numeric_limits@C@std@@SACXZ + ?infinity@?$numeric_limits@D@std@@SADXZ + ?infinity@?$numeric_limits@E@std@@SAEXZ + ?infinity@?$numeric_limits@F@std@@SAFXZ + ?infinity@?$numeric_limits@G@std@@SAGXZ + ?infinity@?$numeric_limits@H@std@@SAHXZ + ?infinity@?$numeric_limits@I@std@@SAIXZ + ?infinity@?$numeric_limits@J@std@@SAJXZ + ?infinity@?$numeric_limits@K@std@@SAKXZ + ?infinity@?$numeric_limits@M@std@@SAMXZ + ?infinity@?$numeric_limits@N@std@@SANXZ + ?infinity@?$numeric_limits@O@std@@SAOXZ + ?infinity@?$numeric_limits@_J@std@@SA_JXZ + ?infinity@?$numeric_limits@_K@std@@SA_KXZ + ?infinity@?$numeric_limits@_N@std@@SA_NXZ + ?infinity@?$numeric_limits@_W@std@@SA_WXZ + ?init@?$basic_ios@DU?$char_traits@D@std@@@std@@IAEXPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@_N@Z + ?init@?$basic_ios@GU?$char_traits@G@std@@@std@@IAEXPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@_N@Z + ?init@?$basic_ios@_WU?$char_traits@_W@std@@@std@@IAEXPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_N@Z + ?intl@?$moneypunct@D$00@std@@2_NB + ?intl@?$moneypunct@D$0A@@std@@2_NB + ?intl@?$moneypunct@G$00@std@@2_NB + ?intl@?$moneypunct@G$0A@@std@@2_NB + ?intl@?$moneypunct@_W$00@std@@2_NB + ?intl@?$moneypunct@_W$0A@@std@@2_NB + ?iostream_category@std@@YAABVerror_category@1@XZ + ?ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z + ?ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE_N_N@Z + ?ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE_N_N@Z + ?is@?$ctype@D@std@@QBEPBDPBD0PAF@Z + ?is@?$ctype@D@std@@QBE_NFD@Z + ?is@?$ctype@G@std@@QBEPBGPBG0PAF@Z + ?is@?$ctype@G@std@@QBE_NFG@Z + ?is@?$ctype@_W@std@@QBEPB_WPB_W0PAF@Z + ?is@?$ctype@_W@std@@QBE_NF_W@Z + ?is_bounded@_Num_base@std@@2_NB + ?is_bounded@_Num_float_base@std@@2_NB + ?is_bounded@_Num_int_base@std@@2_NB + ?is_current_task_group_canceling@Concurrency@@YA_NXZ + ?is_exact@_Num_base@std@@2_NB + ?is_exact@_Num_float_base@std@@2_NB + ?is_exact@_Num_int_base@std@@2_NB + ?is_iec559@_Num_base@std@@2_NB + ?is_iec559@_Num_float_base@std@@2_NB + ?is_integer@_Num_base@std@@2_NB + ?is_integer@_Num_float_base@std@@2_NB + ?is_integer@_Num_int_base@std@@2_NB + ?is_modulo@?$numeric_limits@_N@std@@2_NB + ?is_modulo@_Num_base@std@@2_NB + ?is_modulo@_Num_float_base@std@@2_NB + ?is_modulo@_Num_int_base@std@@2_NB + ?is_signed@?$numeric_limits@C@std@@2_NB + ?is_signed@?$numeric_limits@D@std@@2_NB + ?is_signed@?$numeric_limits@E@std@@2_NB + ?is_signed@?$numeric_limits@F@std@@2_NB + ?is_signed@?$numeric_limits@G@std@@2_NB + ?is_signed@?$numeric_limits@H@std@@2_NB + ?is_signed@?$numeric_limits@I@std@@2_NB + ?is_signed@?$numeric_limits@J@std@@2_NB + ?is_signed@?$numeric_limits@K@std@@2_NB + ?is_signed@?$numeric_limits@_J@std@@2_NB + ?is_signed@?$numeric_limits@_K@std@@2_NB + ?is_signed@?$numeric_limits@_N@std@@2_NB + ?is_signed@?$numeric_limits@_W@std@@2_NB + ?is_signed@_Num_base@std@@2_NB + ?is_signed@_Num_float_base@std@@2_NB + ?is_specialized@_Num_base@std@@2_NB + ?is_specialized@_Num_float_base@std@@2_NB + ?is_specialized@_Num_int_base@std@@2_NB + ?isfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEXXZ + ?isfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEXXZ + ?isfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEXXZ + ?iword@ios_base@std@@QAEAAJH@Z + ?length@?$codecvt@DDH@std@@QBEHABHPBD1I@Z + ?length@?$codecvt@GDH@std@@QBEHABHPBD1I@Z + ?length@?$codecvt@_WDH@std@@QBEHABHPBD1I@Z + ?lowest@?$numeric_limits@C@std@@SACXZ + ?lowest@?$numeric_limits@D@std@@SADXZ + ?lowest@?$numeric_limits@E@std@@SAEXZ + ?lowest@?$numeric_limits@F@std@@SAFXZ + ?lowest@?$numeric_limits@G@std@@SAGXZ + ?lowest@?$numeric_limits@H@std@@SAHXZ + ?lowest@?$numeric_limits@I@std@@SAIXZ + ?lowest@?$numeric_limits@J@std@@SAJXZ + ?lowest@?$numeric_limits@K@std@@SAKXZ + ?lowest@?$numeric_limits@M@std@@SAMXZ + ?lowest@?$numeric_limits@N@std@@SANXZ + ?lowest@?$numeric_limits@O@std@@SAOXZ + ?lowest@?$numeric_limits@_J@std@@SA_JXZ + ?lowest@?$numeric_limits@_K@std@@SA_KXZ + ?lowest@?$numeric_limits@_N@std@@SA_NXZ + ?lowest@?$numeric_limits@_W@std@@SA_WXZ + ?max@?$numeric_limits@C@std@@SACXZ + ?max@?$numeric_limits@D@std@@SADXZ + ?max@?$numeric_limits@E@std@@SAEXZ + ?max@?$numeric_limits@F@std@@SAFXZ + ?max@?$numeric_limits@G@std@@SAGXZ + ?max@?$numeric_limits@H@std@@SAHXZ + ?max@?$numeric_limits@I@std@@SAIXZ + ?max@?$numeric_limits@J@std@@SAJXZ + ?max@?$numeric_limits@K@std@@SAKXZ + ?max@?$numeric_limits@M@std@@SAMXZ + ?max@?$numeric_limits@N@std@@SANXZ + ?max@?$numeric_limits@O@std@@SAOXZ + ?max@?$numeric_limits@_J@std@@SA_JXZ + ?max@?$numeric_limits@_K@std@@SA_KXZ + ?max@?$numeric_limits@_N@std@@SA_NXZ + ?max@?$numeric_limits@_W@std@@SA_WXZ + ?max_digits10@?$numeric_limits@C@std@@2HB + ?max_digits10@?$numeric_limits@D@std@@2HB + ?max_digits10@?$numeric_limits@E@std@@2HB + ?max_digits10@?$numeric_limits@F@std@@2HB + ?max_digits10@?$numeric_limits@G@std@@2HB + ?max_digits10@?$numeric_limits@H@std@@2HB + ?max_digits10@?$numeric_limits@I@std@@2HB + ?max_digits10@?$numeric_limits@J@std@@2HB + ?max_digits10@?$numeric_limits@K@std@@2HB + ?max_digits10@?$numeric_limits@M@std@@2HB + ?max_digits10@?$numeric_limits@N@std@@2HB + ?max_digits10@?$numeric_limits@O@std@@2HB + ?max_digits10@?$numeric_limits@_J@std@@2HB + ?max_digits10@?$numeric_limits@_K@std@@2HB + ?max_digits10@?$numeric_limits@_N@std@@2HB + ?max_digits10@?$numeric_limits@_W@std@@2HB + ?max_digits10@_Num_base@std@@2HB + ?max_exponent10@?$numeric_limits@M@std@@2HB + ?max_exponent10@?$numeric_limits@N@std@@2HB + ?max_exponent10@?$numeric_limits@O@std@@2HB + ?max_exponent10@_Num_base@std@@2HB + ?max_exponent@?$numeric_limits@M@std@@2HB + ?max_exponent@?$numeric_limits@N@std@@2HB + ?max_exponent@?$numeric_limits@O@std@@2HB + ?max_exponent@_Num_base@std@@2HB + ?max_length@codecvt_base@std@@QBEHXZ + ?min@?$numeric_limits@C@std@@SACXZ + ?min@?$numeric_limits@D@std@@SADXZ + ?min@?$numeric_limits@E@std@@SAEXZ + ?min@?$numeric_limits@F@std@@SAFXZ + ?min@?$numeric_limits@G@std@@SAGXZ + ?min@?$numeric_limits@H@std@@SAHXZ + ?min@?$numeric_limits@I@std@@SAIXZ + ?min@?$numeric_limits@J@std@@SAJXZ + ?min@?$numeric_limits@K@std@@SAKXZ + ?min@?$numeric_limits@M@std@@SAMXZ + ?min@?$numeric_limits@N@std@@SANXZ + ?min@?$numeric_limits@O@std@@SAOXZ + ?min@?$numeric_limits@_J@std@@SA_JXZ + ?min@?$numeric_limits@_K@std@@SA_KXZ + ?min@?$numeric_limits@_N@std@@SA_NXZ + ?min@?$numeric_limits@_W@std@@SA_WXZ + ?min_exponent10@?$numeric_limits@M@std@@2HB + ?min_exponent10@?$numeric_limits@N@std@@2HB + ?min_exponent10@?$numeric_limits@O@std@@2HB + ?min_exponent10@_Num_base@std@@2HB + ?min_exponent@?$numeric_limits@M@std@@2HB + ?min_exponent@?$numeric_limits@N@std@@2HB + ?min_exponent@?$numeric_limits@O@std@@2HB + ?min_exponent@_Num_base@std@@2HB + ?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEX$$QAV12@@Z + ?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEX$$QAV12@@Z + ?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEX$$QAV12@@Z + ?narrow@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEDDD@Z + ?narrow@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEDGD@Z + ?narrow@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBED_WD@Z + ?narrow@?$ctype@D@std@@QBEDDD@Z + ?narrow@?$ctype@D@std@@QBEPBDPBD0DPAD@Z + ?narrow@?$ctype@G@std@@QBEDGD@Z + ?narrow@?$ctype@G@std@@QBEPBGPBG0DPAD@Z + ?narrow@?$ctype@_W@std@@QBED_WD@Z + ?narrow@?$ctype@_W@std@@QBEPB_WPB_W0DPAD@Z + ?opfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE_NXZ + ?opfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE_NXZ + ?opfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE_NXZ + ?osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXXZ + ?osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXXZ + ?osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ + ?out@?$codecvt@DDH@std@@QBEHAAHPBD1AAPBDPAD3AAPAD@Z + ?out@?$codecvt@GDH@std@@QBEHAAHPBG1AAPBGPAD3AAPAD@Z + ?out@?$codecvt@_WDH@std@@QBEHAAHPB_W1AAPB_WPAD3AAPAD@Z + ?overflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHH@Z + ?overflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGG@Z + ?overflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGG@Z + ?pbackfail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHH@Z + ?pbackfail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGG@Z + ?pbackfail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGG@Z + ?pbase@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ + ?pbase@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ + ?pbase@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ + ?pbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXH@Z + ?pbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXH@Z + ?pbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXH@Z + ?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ + ?peek@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEGXZ + ?peek@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEGXZ + ?pptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ + ?pptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ + ?pptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ + ?precision@ios_base@std@@QAE_J_J@Z + ?precision@ios_base@std@@QBE_JXZ + ?pubimbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AVlocale@2@ABV32@@Z + ?pubimbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AVlocale@2@ABV32@@Z + ?pubimbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AVlocale@2@ABV32@@Z + ?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@H@2@_JHH@Z + ?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@H@2@_JII@Z + ?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@H@2@_JHH@Z + ?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@H@2@_JII@Z + ?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@H@2@_JHH@Z + ?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@H@2@_JII@Z + ?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@H@2@V32@H@Z + ?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@H@2@V32@I@Z + ?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@H@2@V32@H@Z + ?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@H@2@V32@I@Z + ?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@H@2@V32@H@Z + ?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@H@2@V32@I@Z + ?pubsetbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEPAV12@PAD_J@Z + ?pubsetbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEPAV12@PAG_J@Z + ?pubsetbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEPAV12@PA_W_J@Z + ?pubsync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ + ?pubsync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEHXZ + ?pubsync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEHXZ + ?put@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@D@Z + ?put@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@G@Z + ?put@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_W@Z + ?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DJ@Z + ?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DK@Z + ?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DN@Z + ?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DO@Z + ?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBX@Z + ?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_J@Z + ?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_K@Z + ?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_N@Z + ?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GJ@Z + ?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GK@Z + ?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GN@Z + ?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GO@Z + ?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBX@Z + ?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_J@Z + ?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_K@Z + ?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_N@Z + ?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WJ@Z + ?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WK@Z + ?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WN@Z + ?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WO@Z + ?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBX@Z + ?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_J@Z + ?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_K@Z + ?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_N@Z + ?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBUtm@@DD@Z + ?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBUtm@@PBD3@Z + ?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBUtm@@DD@Z + ?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBUtm@@PBG3@Z + ?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBUtm@@DD@Z + ?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBUtm@@PB_W4@Z + ?putback@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@D@Z + ?putback@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@G@Z + ?putback@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_W@Z + ?pword@ios_base@std@@QAEAAPAXH@Z + ?quiet_NaN@?$numeric_limits@C@std@@SACXZ + ?quiet_NaN@?$numeric_limits@D@std@@SADXZ + ?quiet_NaN@?$numeric_limits@E@std@@SAEXZ + ?quiet_NaN@?$numeric_limits@F@std@@SAFXZ + ?quiet_NaN@?$numeric_limits@G@std@@SAGXZ + ?quiet_NaN@?$numeric_limits@H@std@@SAHXZ + ?quiet_NaN@?$numeric_limits@I@std@@SAIXZ + ?quiet_NaN@?$numeric_limits@J@std@@SAJXZ + ?quiet_NaN@?$numeric_limits@K@std@@SAKXZ + ?quiet_NaN@?$numeric_limits@M@std@@SAMXZ + ?quiet_NaN@?$numeric_limits@N@std@@SANXZ + ?quiet_NaN@?$numeric_limits@O@std@@SAOXZ + ?quiet_NaN@?$numeric_limits@_J@std@@SA_JXZ + ?quiet_NaN@?$numeric_limits@_K@std@@SA_KXZ + ?quiet_NaN@?$numeric_limits@_N@std@@SA_NXZ + ?quiet_NaN@?$numeric_limits@_W@std@@SA_WXZ + ?radix@_Num_base@std@@2HB + ?radix@_Num_float_base@std@@2HB + ?radix@_Num_int_base@std@@2HB + ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@PAV32@@Z + ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ + ?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@PAV32@@Z + ?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@XZ + ?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@PAV32@@Z + ?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBEPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@XZ + ?rdstate@ios_base@std@@QBEHXZ + ?read@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_J@Z + ?read@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_J@Z + ?read@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J@Z + ?readsome@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_JPAD_J@Z + ?readsome@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE_JPAG_J@Z + ?readsome@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE_JPA_W_J@Z + ?register_callback@ios_base@std@@QAEXP6AXW4event@12@AAV12@H@ZH@Z + ?resetiosflags@std@@YA?AU?$_Smanip@H@1@H@Z + ?round_error@?$numeric_limits@C@std@@SACXZ + ?round_error@?$numeric_limits@D@std@@SADXZ + ?round_error@?$numeric_limits@E@std@@SAEXZ + ?round_error@?$numeric_limits@F@std@@SAFXZ + ?round_error@?$numeric_limits@G@std@@SAGXZ + ?round_error@?$numeric_limits@H@std@@SAHXZ + ?round_error@?$numeric_limits@I@std@@SAIXZ + ?round_error@?$numeric_limits@J@std@@SAJXZ + ?round_error@?$numeric_limits@K@std@@SAKXZ + ?round_error@?$numeric_limits@M@std@@SAMXZ + ?round_error@?$numeric_limits@N@std@@SANXZ + ?round_error@?$numeric_limits@O@std@@SAOXZ + ?round_error@?$numeric_limits@_J@std@@SA_JXZ + ?round_error@?$numeric_limits@_K@std@@SA_KXZ + ?round_error@?$numeric_limits@_N@std@@SA_NXZ + ?round_error@?$numeric_limits@_W@std@@SA_WXZ + ?round_style@_Num_base@std@@2W4float_round_style@2@B + ?round_style@_Num_float_base@std@@2W4float_round_style@2@B + ?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ + ?sbumpc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ + ?sbumpc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ + ?scan_is@?$ctype@D@std@@QBEPBDFPBD0@Z + ?scan_is@?$ctype@G@std@@QBEPBGFPBG0@Z + ?scan_is@?$ctype@_W@std@@QBEPB_WFPB_W0@Z + ?scan_not@?$ctype@D@std@@QBEPBDFPBD0@Z + ?scan_not@?$ctype@G@std@@QBEPBGFPBG0@Z + ?scan_not@?$ctype@_W@std@@QBEPB_WFPB_W0@Z + ?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@V?$fpos@H@2@@Z + ?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@_JH@Z + ?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@V?$fpos@H@2@@Z + ?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@_JH@Z + ?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@V?$fpos@H@2@@Z + ?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_JH@Z + ?seekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE?AV?$fpos@H@2@_JHH@Z + ?seekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE?AV?$fpos@H@2@_JHH@Z + ?seekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE?AV?$fpos@H@2@_JHH@Z + ?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@V?$fpos@H@2@@Z + ?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@_JH@Z + ?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@V?$fpos@H@2@@Z + ?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@_JH@Z + ?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@V?$fpos@H@2@@Z + ?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_JH@Z + ?seekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE?AV?$fpos@H@2@V32@H@Z + ?seekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE?AV?$fpos@H@2@V32@H@Z + ?seekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE?AV?$fpos@H@2@V32@H@Z + ?set_new_handler@std@@YAP6AXXZH@Z + ?set_new_handler@std@@YAP6AXXZP6AXXZ@Z + ?set_rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z + ?set_rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z + ?set_rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z + ?setbase@std@@YA?AU?$_Smanip@H@1@H@Z + ?setbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEPAV12@PAD_J@Z + ?setbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEPAV12@PAG_J@Z + ?setbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEPAV12@PA_W_J@Z + ?setf@ios_base@std@@QAEHH@Z + ?setf@ios_base@std@@QAEHHH@Z + ?setg@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAD00@Z + ?setg@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAG00@Z + ?setg@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPA_W00@Z + ?setiosflags@std@@YA?AU?$_Smanip@H@1@H@Z + ?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAD00@Z + ?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAD0@Z + ?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAG00@Z + ?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAG0@Z + ?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPA_W00@Z + ?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPA_W0@Z + ?setprecision@std@@YA?AU?$_Smanip@_J@1@_J@Z + ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z + ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXI@Z + ?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXH_N@Z + ?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXI@Z + ?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXH_N@Z + ?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXI@Z + ?setstate@ios_base@std@@QAEXH@Z + ?setstate@ios_base@std@@QAEXH_N@Z + ?setstate@ios_base@std@@QAEXI@Z + ?setw@std@@YA?AU?$_Smanip@_J@1@_J@Z + ?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ + ?sgetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ + ?sgetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ + ?sgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE_JPAD_J@Z + ?sgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE_JPAG_J@Z + ?sgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE_JPA_W_J@Z + ?showmanyc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE_JXZ + ?showmanyc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE_JXZ + ?showmanyc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE_JXZ + ?signaling_NaN@?$numeric_limits@C@std@@SACXZ + ?signaling_NaN@?$numeric_limits@D@std@@SADXZ + ?signaling_NaN@?$numeric_limits@E@std@@SAEXZ + ?signaling_NaN@?$numeric_limits@F@std@@SAFXZ + ?signaling_NaN@?$numeric_limits@G@std@@SAGXZ + ?signaling_NaN@?$numeric_limits@H@std@@SAHXZ + ?signaling_NaN@?$numeric_limits@I@std@@SAIXZ + ?signaling_NaN@?$numeric_limits@J@std@@SAJXZ + ?signaling_NaN@?$numeric_limits@K@std@@SAKXZ + ?signaling_NaN@?$numeric_limits@M@std@@SAMXZ + ?signaling_NaN@?$numeric_limits@N@std@@SANXZ + ?signaling_NaN@?$numeric_limits@O@std@@SAOXZ + ?signaling_NaN@?$numeric_limits@_J@std@@SA_JXZ + ?signaling_NaN@?$numeric_limits@_K@std@@SA_KXZ + ?signaling_NaN@?$numeric_limits@_N@std@@SA_NXZ + ?signaling_NaN@?$numeric_limits@_W@std@@SA_WXZ + ?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ + ?snextc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ + ?snextc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ + ?sputbackc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHD@Z + ?sputbackc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGG@Z + ?sputbackc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEG_W@Z + ?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHD@Z + ?sputc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGG@Z + ?sputc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEG_W@Z + ?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE_JPBD_J@Z + ?sputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE_JPBG_J@Z + ?sputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE_JPB_W_J@Z + ?start@agent@Concurrency@@QAE_NXZ + ?status@agent@Concurrency@@QAE?AW4agent_status@2@XZ + ?status_port@agent@Concurrency@@QAEPAV?$ISource@W4agent_status@Concurrency@@@2@XZ + ?stossc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEXXZ + ?stossc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEXXZ + ?stossc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEXXZ + ?sungetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ + ?sungetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ + ?sungetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ + ?swap@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_iostream@DU?$char_traits@D@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_iostream@GU?$char_traits@G@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXAAV12@@Z + ?swap@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXAAV12@@Z + ?swap@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXAAV12@@Z + ?swap@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXAAV12@@Z + ?swap@ios_base@std@@QAEXAAV12@@Z + ?sync@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ + ?sync@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEHXZ + ?sync@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEHXZ + ?sync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHXZ + ?sync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEHXZ + ?sync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEHXZ + ?sync_with_stdio@ios_base@std@@SA_N_N@Z + ?system_category@std@@YAABVerror_category@1@XZ + ?table@?$ctype@D@std@@QBEPBFXZ + ?table_size@?$ctype@D@std@@2IB + ?tellg@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@H@2@XZ + ?tellg@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@H@2@XZ + ?tellg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@H@2@XZ + ?tellp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@H@2@XZ + ?tellp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@H@2@XZ + ?tellp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@H@2@XZ + ?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEPAV?$basic_ostream@DU?$char_traits@D@std@@@2@PAV32@@Z + ?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ + ?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEPAV?$basic_ostream@GU?$char_traits@G@std@@@2@PAV32@@Z + ?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEPAV?$basic_ostream@GU?$char_traits@G@std@@@2@XZ + ?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEPAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@PAV32@@Z + ?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBEPAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@XZ + ?tinyness_before@_Num_base@std@@2_NB + ?tinyness_before@_Num_float_base@std@@2_NB + ?tolower@?$ctype@D@std@@QBEDD@Z + ?tolower@?$ctype@D@std@@QBEPBDPADPBD@Z + ?tolower@?$ctype@G@std@@QBEGG@Z + ?tolower@?$ctype@G@std@@QBEPBGPAGPBG@Z + ?tolower@?$ctype@_W@std@@QBEPB_WPA_WPB_W@Z + ?tolower@?$ctype@_W@std@@QBE_W_W@Z + ?toupper@?$ctype@D@std@@QBEDD@Z + ?toupper@?$ctype@D@std@@QBEPBDPADPBD@Z + ?toupper@?$ctype@G@std@@QBEGG@Z + ?toupper@?$ctype@G@std@@QBEPBGPAGPBG@Z + ?toupper@?$ctype@_W@std@@QBEPB_WPA_WPB_W@Z + ?toupper@?$ctype@_W@std@@QBE_W_W@Z + ?traps@_Num_base@std@@2_NB + ?traps@_Num_float_base@std@@2_NB + ?uflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHXZ + ?uflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGXZ + ?uflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGXZ + ?uncaught_exception@std@@YA_NXZ + ?underflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHXZ + ?underflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGXZ + ?underflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGXZ + ?unget@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@XZ + ?unget@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@XZ + ?unget@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@XZ + ?unsetf@ios_base@std@@QAEXH@Z + ?unshift@?$codecvt@DDH@std@@QBEHAAHPAD1AAPAD@Z + ?unshift@?$codecvt@GDH@std@@QBEHAAHPAD1AAPAD@Z + ?unshift@?$codecvt@_WDH@std@@QBEHAAHPAD1AAPAD@Z + ?wait@agent@Concurrency@@SA?AW4agent_status@2@PAV12@I@Z + ?wait_for_all@agent@Concurrency@@SAXIPAPAV12@PAW4agent_status@2@I@Z + ?wait_for_one@agent@Concurrency@@SAXIPAPAV12@AAW4agent_status@2@AAII@Z + ?wcerr@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A + ?wcerr@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A + ?wcin@std@@3V?$basic_istream@GU?$char_traits@G@std@@@1@A + ?wcin@std@@3V?$basic_istream@_WU?$char_traits@_W@std@@@1@A + ?wclog@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A + ?wclog@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A + ?wcout@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A + ?wcout@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A + ?widen@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEDD@Z + ?widen@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEGD@Z + ?widen@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBE_WD@Z + ?widen@?$ctype@D@std@@QBEDD@Z + ?widen@?$ctype@D@std@@QBEPBDPBD0PAD@Z + ?widen@?$ctype@G@std@@QBEGD@Z + ?widen@?$ctype@G@std@@QBEPBDPBD0PAG@Z + ?widen@?$ctype@_W@std@@QBEPBDPBD0PA_W@Z + ?widen@?$ctype@_W@std@@QBE_WD@Z + ?width@ios_base@std@@QAE_J_J@Z + ?width@ios_base@std@@QBE_JXZ + ?write@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@PBD_J@Z + ?write@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@PBG_J@Z + ?write@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PB_W_J@Z + ?ws@std@@YAAAV?$basic_istream@DU?$char_traits@D@std@@@1@AAV21@@Z + ?ws@std@@YAAAV?$basic_istream@GU?$char_traits@G@std@@@1@AAV21@@Z + ?ws@std@@YAAAV?$basic_istream@_WU?$char_traits@_W@std@@@1@AAV21@@Z + ?xalloc@ios_base@std@@SAHXZ + ?xsgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE_JPAD_J@Z + ?xsgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE_JPAG_J@Z + ?xsgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE_JPA_W_J@Z + ?xsputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE_JPBD_J@Z + ?xsputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE_JPBG_J@Z + ?xsputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE_JPB_W_J@Z + _Cosh + _Denorm + _Dnorm + _Dscale + _Dtest + _Eps + _Exp + _FCosh + _FDenorm + _FDnorm + _FDscale + _FDtest + _FEps + _FExp + _FInf + _FNan + _FRteps + _FSinh + _FSnan + _FXbig + _GetLocaleForCP + _Getcoll + _Getctype + _Getcvt + _Getdateorder + _Getwctype + _Getwctypes + _Hugeval + _Inf + _LCosh + _LDenorm + _LDscale + _LDtest + _LEps + _LExp + _LInf + _LNan + _LPoly + _LRteps + _LSinh + _LSnan + _LXbig + _LZero + _Mbrtowc + _Mtxdst + _Mtxinit + _Mtxlock + _Mtxunlock + _Nan + _Once + _Poly + _Rteps + _Sinh + _Snan + _Stod + _Stodx + _Stof + _Stofx + _Stold + _Stoldx + _Stoll + _Stollx + _Stolx + _Stoul + _Stoull + _Stoullx + _Stoulx + _Strcoll + _Strxfrm + _Tolower + _Toupper + _Towlower + _Towupper + _Wcrtomb + _Wcscoll + _Wcsxfrm + _Xbig + __Wcrtomb_lk + towctrans + wctrans + wctype + diff --git a/src/VBox/Runtime/r3/win/VBoxRT-msvcr100-win32.def b/src/VBox/Runtime/r3/win/VBoxRT-msvcr100-win32.def new file mode 100644 index 00000000..6317e658 --- /dev/null +++ b/src/VBox/Runtime/r3/win/VBoxRT-msvcr100-win32.def @@ -0,0 +1,1640 @@ + + ; + _except_handler4 + ;_heap_init + ;__crtExitProcess + ;_NMSG_WRITE + ;_FF_MSGBANNER + ;_cinit + ;_setenvp + ;__crtGetEnvironmentStringsA + ;_ioinit + ;_mtinit + + _initterm=my_initterm + __dllonexit=my_dllonexit + __getmainargs=my_getmainargs + __setusermatherr=my_setusermatherr + + _onexit DATA ; the one is crazy. atonexit.obj in msvcrt.lib which calls the __imp___onexit directly. + + ; MSVCR100.DLL exports + ??0?$_SpinWait@$0A@@details@Concurrency@@QAE@P6AXXZ@Z + ??0SchedulerPolicy@Concurrency@@QAA@IZZ + ??0SchedulerPolicy@Concurrency@@QAE@ABV01@@Z + ??0SchedulerPolicy@Concurrency@@QAE@XZ + ??0_NonReentrantBlockingLock@details@Concurrency@@QAE@XZ + ??0_NonReentrantPPLLock@details@Concurrency@@QAE@XZ + ??0_ReaderWriterLock@details@Concurrency@@QAE@XZ + ??0_ReentrantBlockingLock@details@Concurrency@@QAE@XZ + ??0_ReentrantLock@details@Concurrency@@QAE@XZ + ??0_ReentrantPPLLock@details@Concurrency@@QAE@XZ + ??0_Scoped_lock@_NonReentrantPPLLock@details@Concurrency@@QAE@AAV123@@Z + ??0_Scoped_lock@_ReentrantPPLLock@details@Concurrency@@QAE@AAV123@@Z + ??0_SpinLock@details@Concurrency@@QAE@ACJ@Z + ??0_TaskCollection@details@Concurrency@@QAE@XZ + ??0_Timer@details@Concurrency@@IAE@I_N@Z + ??0__non_rtti_object@std@@QAE@ABV01@@Z + ??0__non_rtti_object@std@@QAE@PBD@Z + ;fixme-not-in-libcmt.lib; ??0bad_cast@std@@AAE@PBQBD@Z + ??0bad_cast@std@@QAE@ABV01@@Z + ??0bad_cast@std@@QAE@PBD@Z + ??0bad_target@Concurrency@@QAE@PBD@Z + ??0bad_target@Concurrency@@QAE@XZ + ??0bad_typeid@std@@QAE@ABV01@@Z + ??0bad_typeid@std@@QAE@PBD@Z + ??0context_self_unblock@Concurrency@@QAE@PBD@Z + ??0context_self_unblock@Concurrency@@QAE@XZ + ??0context_unblock_unbalanced@Concurrency@@QAE@PBD@Z + ??0context_unblock_unbalanced@Concurrency@@QAE@XZ + ??0critical_section@Concurrency@@QAE@XZ + ??0default_scheduler_exists@Concurrency@@QAE@PBD@Z + ??0default_scheduler_exists@Concurrency@@QAE@XZ + ??0event@Concurrency@@QAE@XZ + ??0exception@std@@QAE@ABQBD@Z + ??0exception@std@@QAE@ABQBDH@Z + ??0exception@std@@QAE@ABV01@@Z + ??0exception@std@@QAE@XZ + ??0improper_lock@Concurrency@@QAE@PBD@Z + ??0improper_lock@Concurrency@@QAE@XZ + ??0improper_scheduler_attach@Concurrency@@QAE@PBD@Z + ??0improper_scheduler_attach@Concurrency@@QAE@XZ + ??0improper_scheduler_detach@Concurrency@@QAE@PBD@Z + ??0improper_scheduler_detach@Concurrency@@QAE@XZ + ??0improper_scheduler_reference@Concurrency@@QAE@PBD@Z + ??0improper_scheduler_reference@Concurrency@@QAE@XZ + ??0invalid_link_target@Concurrency@@QAE@PBD@Z + ??0invalid_link_target@Concurrency@@QAE@XZ + ??0invalid_multiple_scheduling@Concurrency@@QAE@PBD@Z + ??0invalid_multiple_scheduling@Concurrency@@QAE@XZ + ??0invalid_operation@Concurrency@@QAE@PBD@Z + ??0invalid_operation@Concurrency@@QAE@XZ + ??0invalid_oversubscribe_operation@Concurrency@@QAE@PBD@Z + ??0invalid_oversubscribe_operation@Concurrency@@QAE@XZ + ??0invalid_scheduler_policy_key@Concurrency@@QAE@PBD@Z + ??0invalid_scheduler_policy_key@Concurrency@@QAE@XZ + ??0invalid_scheduler_policy_thread_specification@Concurrency@@QAE@PBD@Z + ??0invalid_scheduler_policy_thread_specification@Concurrency@@QAE@XZ + ??0invalid_scheduler_policy_value@Concurrency@@QAE@PBD@Z + ??0invalid_scheduler_policy_value@Concurrency@@QAE@XZ + ??0message_not_found@Concurrency@@QAE@PBD@Z + ??0message_not_found@Concurrency@@QAE@XZ + ??0missing_wait@Concurrency@@QAE@PBD@Z + ??0missing_wait@Concurrency@@QAE@XZ + ??0nested_scheduler_missing_detach@Concurrency@@QAE@PBD@Z + ??0nested_scheduler_missing_detach@Concurrency@@QAE@XZ + ??0operation_timed_out@Concurrency@@QAE@PBD@Z + ??0operation_timed_out@Concurrency@@QAE@XZ + ??0reader_writer_lock@Concurrency@@QAE@XZ + ??0scheduler_not_attached@Concurrency@@QAE@PBD@Z + ??0scheduler_not_attached@Concurrency@@QAE@XZ + ??0scheduler_resource_allocation_error@Concurrency@@QAE@J@Z + ??0scheduler_resource_allocation_error@Concurrency@@QAE@PBDJ@Z + ??0scoped_lock@critical_section@Concurrency@@QAE@AAV12@@Z + ??0scoped_lock@reader_writer_lock@Concurrency@@QAE@AAV12@@Z + ??0scoped_lock_read@reader_writer_lock@Concurrency@@QAE@AAV12@@Z + ??0task_canceled@details@Concurrency@@QAE@PBD@Z + ??0task_canceled@details@Concurrency@@QAE@XZ + ??0unsupported_os@Concurrency@@QAE@PBD@Z + ??0unsupported_os@Concurrency@@QAE@XZ + ??1SchedulerPolicy@Concurrency@@QAE@XZ + ??1_NonReentrantBlockingLock@details@Concurrency@@QAE@XZ + ??1_ReentrantBlockingLock@details@Concurrency@@QAE@XZ + ??1_Scoped_lock@_NonReentrantPPLLock@details@Concurrency@@QAE@XZ + ??1_Scoped_lock@_ReentrantPPLLock@details@Concurrency@@QAE@XZ + ??1_SpinLock@details@Concurrency@@QAE@XZ + ??1_TaskCollection@details@Concurrency@@QAE@XZ + ??1_Timer@details@Concurrency@@IAE@XZ + ??1__non_rtti_object@std@@UAE@XZ + ??1bad_cast@std@@UAE@XZ + ??1bad_typeid@std@@UAE@XZ + ??1critical_section@Concurrency@@QAE@XZ + ??1event@Concurrency@@QAE@XZ + ??1exception@std@@UAE@XZ + ??1reader_writer_lock@Concurrency@@QAE@XZ + ??1scoped_lock@critical_section@Concurrency@@QAE@XZ + ??1scoped_lock@reader_writer_lock@Concurrency@@QAE@XZ + ??1scoped_lock_read@reader_writer_lock@Concurrency@@QAE@XZ + ??1type_info@@UAE@XZ + ??2@YAPAXI@Z + ??2@YAPAXIHPBDH@Z + ??3@YAXPAX@Z + ;fixme-not-in-libcmt.lib; ??4?$_SpinWait@$00@details@Concurrency@@QAEAAV012@ABV012@@Z + ;fixme-not-in-libcmt.lib; ??4?$_SpinWait@$0A@@details@Concurrency@@QAEAAV012@ABV012@@Z + ??4SchedulerPolicy@Concurrency@@QAEAAV01@ABV01@@Z + ??4__non_rtti_object@std@@QAEAAV01@ABV01@@Z + ??4bad_cast@std@@QAEAAV01@ABV01@@Z + ??4bad_typeid@std@@QAEAAV01@ABV01@@Z + ??4exception@std@@QAEAAV01@ABV01@@Z + ??8type_info@@QBE_NABV0@@Z + ??9type_info@@QBE_NABV0@@Z + ??_7__non_rtti_object@std@@6B@ + ??_7bad_cast@std@@6B@ + ??_7bad_typeid@std@@6B@ + ;fixme-not-in-libcmt.lib; ??_7exception@@6B@ + ??_7exception@std@@6B@ + ;fixme-not-in-libcmt.lib; ??_F?$_SpinWait@$00@details@Concurrency@@QAEXXZ + ;fixme-not-in-libcmt.lib; ??_F?$_SpinWait@$0A@@details@Concurrency@@QAEXXZ + ??_Fbad_cast@std@@QAEXXZ + ??_Fbad_typeid@std@@QAEXXZ + ??_U@YAPAXI@Z + ??_U@YAPAXIHPBDH@Z + ??_V@YAXPAX@Z + ?Alloc@Concurrency@@YAPAXI@Z + ?Block@Context@Concurrency@@SAXXZ + ?Create@CurrentScheduler@Concurrency@@SAXABVSchedulerPolicy@2@@Z + ?Create@Scheduler@Concurrency@@SAPAV12@ABVSchedulerPolicy@2@@Z + ?CreateResourceManager@Concurrency@@YAPAUIResourceManager@1@XZ + ?CreateScheduleGroup@CurrentScheduler@Concurrency@@SAPAVScheduleGroup@2@XZ + ?CurrentContext@Context@Concurrency@@SAPAV12@XZ + ?Detach@CurrentScheduler@Concurrency@@SAXXZ + ?DisableTracing@Concurrency@@YAJXZ + ?EnableTracing@Concurrency@@YAJXZ + ?Free@Concurrency@@YAXPAX@Z + ?Get@CurrentScheduler@Concurrency@@SAPAVScheduler@2@XZ + ?GetExecutionContextId@Concurrency@@YAIXZ + ?GetNumberOfVirtualProcessors@CurrentScheduler@Concurrency@@SAIXZ + ?GetOSVersion@Concurrency@@YA?AW4OSVersion@IResourceManager@1@XZ + ?GetPolicy@CurrentScheduler@Concurrency@@SA?AVSchedulerPolicy@2@XZ + ?GetPolicyValue@SchedulerPolicy@Concurrency@@QBEIW4PolicyElementKey@2@@Z + ?GetProcessorCount@Concurrency@@YAIXZ + ?GetProcessorNodeCount@Concurrency@@YAIXZ + ?GetSchedulerId@Concurrency@@YAIXZ + ?GetSharedTimerQueue@details@Concurrency@@YAPAXXZ + ?Id@Context@Concurrency@@SAIXZ + ?Id@CurrentScheduler@Concurrency@@SAIXZ + ?IsCurrentTaskCollectionCanceling@Context@Concurrency@@SA_NXZ + ?Log2@details@Concurrency@@YAKI@Z + ?Oversubscribe@Context@Concurrency@@SAX_N@Z + ?RegisterShutdownEvent@CurrentScheduler@Concurrency@@SAXPAX@Z + ?ResetDefaultSchedulerPolicy@Scheduler@Concurrency@@SAXXZ + ?ScheduleGroupId@Context@Concurrency@@SAIXZ + ?ScheduleTask@CurrentScheduler@Concurrency@@SAXP6AXPAX@Z0@Z + ?SetConcurrencyLimits@SchedulerPolicy@Concurrency@@QAEXII@Z + ?SetDefaultSchedulerPolicy@Scheduler@Concurrency@@SAXABVSchedulerPolicy@2@@Z + ?SetPolicyValue@SchedulerPolicy@Concurrency@@QAEIW4PolicyElementKey@2@I@Z + ?VirtualProcessorId@Context@Concurrency@@SAIXZ + ?Yield@Context@Concurrency@@SAXXZ + ?_Abort@_StructuredTaskCollection@details@Concurrency@@AAEXXZ + ?_Acquire@_NonReentrantBlockingLock@details@Concurrency@@QAEXXZ + ?_Acquire@_NonReentrantPPLLock@details@Concurrency@@QAEXPAX@Z + ?_Acquire@_ReentrantBlockingLock@details@Concurrency@@QAEXXZ + ?_Acquire@_ReentrantLock@details@Concurrency@@QAEXXZ + ?_Acquire@_ReentrantPPLLock@details@Concurrency@@QAEXPAX@Z + ?_AcquireRead@_ReaderWriterLock@details@Concurrency@@QAEXXZ + ?_AcquireWrite@_ReaderWriterLock@details@Concurrency@@QAEXXZ + ?_Cancel@_StructuredTaskCollection@details@Concurrency@@QAEXXZ + ?_Cancel@_TaskCollection@details@Concurrency@@QAEXXZ + ?_CheckTaskCollection@_UnrealizedChore@details@Concurrency@@IAEXXZ + ?_ConcRT_Assert@details@Concurrency@@YAXPBD0H@Z + ?_ConcRT_CoreAssert@details@Concurrency@@YAXPBD0H@Z + ?_ConcRT_DumpMessage@details@Concurrency@@YAXPB_WZZ + ?_ConcRT_Trace@details@Concurrency@@YAXHPB_WZZ + ?_Copy_str@exception@std@@AAEXPBD@Z + ?_DoYield@?$_SpinWait@$00@details@Concurrency@@IAEXXZ + ?_DoYield@?$_SpinWait@$0A@@details@Concurrency@@IAEXXZ + ?_IsCanceling@_StructuredTaskCollection@details@Concurrency@@QAE_NXZ + ?_IsCanceling@_TaskCollection@details@Concurrency@@QAE_NXZ + ?_Name_base@type_info@@CAPBDPBV1@PAU__type_info_node@@@Z + ?_Name_base_internal@type_info@@CAPBDPBV1@PAU__type_info_node@@@Z + ?_NumberOfSpins@?$_SpinWait@$00@details@Concurrency@@IAEKXZ + ?_NumberOfSpins@?$_SpinWait@$0A@@details@Concurrency@@IAEKXZ + ?_Release@_NonReentrantBlockingLock@details@Concurrency@@QAEXXZ + ?_Release@_NonReentrantPPLLock@details@Concurrency@@QAEXXZ + ?_Release@_ReentrantBlockingLock@details@Concurrency@@QAEXXZ + ?_Release@_ReentrantLock@details@Concurrency@@QAEXXZ + ?_Release@_ReentrantPPLLock@details@Concurrency@@QAEXXZ + ?_ReleaseRead@_ReaderWriterLock@details@Concurrency@@QAEXXZ + ?_ReleaseWrite@_ReaderWriterLock@details@Concurrency@@QAEXXZ + ?_Reset@?$_SpinWait@$00@details@Concurrency@@IAEXXZ + ?_Reset@?$_SpinWait@$0A@@details@Concurrency@@IAEXXZ + ?_RunAndWait@_StructuredTaskCollection@details@Concurrency@@QAG?AW4_TaskCollectionStatus@23@PAV_UnrealizedChore@23@@Z + ?_RunAndWait@_TaskCollection@details@Concurrency@@QAG?AW4_TaskCollectionStatus@23@PAV_UnrealizedChore@23@@Z + ?_Schedule@_StructuredTaskCollection@details@Concurrency@@QAEXPAV_UnrealizedChore@23@@Z + ?_Schedule@_TaskCollection@details@Concurrency@@QAEXPAV_UnrealizedChore@23@@Z + ?_SetSpinCount@?$_SpinWait@$00@details@Concurrency@@QAEXI@Z + ?_SetSpinCount@?$_SpinWait@$0A@@details@Concurrency@@QAEXI@Z + ?_ShouldSpinAgain@?$_SpinWait@$00@details@Concurrency@@IAE_NXZ + ?_ShouldSpinAgain@?$_SpinWait@$0A@@details@Concurrency@@IAE_NXZ + ?_SpinOnce@?$_SpinWait@$00@details@Concurrency@@QAE_NXZ + ?_SpinOnce@?$_SpinWait@$0A@@details@Concurrency@@QAE_NXZ + ?_SpinYield@Context@Concurrency@@SAXXZ + ?_Start@_Timer@details@Concurrency@@IAEXXZ + ?_Stop@_Timer@details@Concurrency@@IAEXXZ + ?_Tidy@exception@std@@AAEXXZ + ?_Trace_ppl_function@Concurrency@@YAXABU_GUID@@EW4ConcRT_EventType@1@@Z + ?_TryAcquire@_NonReentrantBlockingLock@details@Concurrency@@QAE_NXZ + ?_TryAcquire@_ReentrantBlockingLock@details@Concurrency@@QAE_NXZ + ?_TryAcquire@_ReentrantLock@details@Concurrency@@QAE_NXZ + ?_TryAcquireWrite@_ReaderWriterLock@details@Concurrency@@QAE_NXZ + ?_Type_info_dtor@type_info@@CAXPAV1@@Z + ?_Type_info_dtor_internal@type_info@@CAXPAV1@@Z + ?_UnderlyingYield@details@Concurrency@@YAXXZ + ?_ValidateExecute@@YAHP6GHXZ@Z + ?_ValidateRead@@YAHPBXI@Z + ?_ValidateWrite@@YAHPAXI@Z + ?_Value@_SpinCount@details@Concurrency@@SAIXZ + ?__ExceptionPtrAssign@@YAXPAXPBX@Z + ?__ExceptionPtrCompare@@YA_NPBX0@Z + ?__ExceptionPtrCopy@@YAXPAXPBX@Z + ?__ExceptionPtrCopyException@@YAXPAXPBX1@Z + ?__ExceptionPtrCreate@@YAXPAX@Z + ?__ExceptionPtrCurrentException@@YAXPAX@Z + ?__ExceptionPtrDestroy@@YAXPAX@Z + ?__ExceptionPtrRethrow@@YAXPBX@Z + __uncaught_exception + ?_inconsistency@@YAXXZ + ?_invalid_parameter@@YAXPBG00II@Z + ?_is_exception_typeof@@YAHABVtype_info@@PAU_EXCEPTION_POINTERS@@@Z + ?_name_internal_method@type_info@@QBEPBDPAU__type_info_node@@@Z + ?_open@@YAHPBDHH@Z + ?_query_new_handler@@YAP6AHI@ZXZ + ?_query_new_mode@@YAHXZ + ?_set_new_handler@@YAP6AHI@ZH@Z + ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z + ?_set_new_mode@@YAHH@Z + ?_set_se_translator@@YAP6AXIPAU_EXCEPTION_POINTERS@@@ZH@Z + ?_set_se_translator@@YAP6AXIPAU_EXCEPTION_POINTERS@@@ZP6AXI0@Z@Z + ?_sopen@@YAHPBDHHH@Z + ?_type_info_dtor_internal_method@type_info@@QAEXXZ + ?_wopen@@YAHPB_WHH@Z + ?_wsopen@@YAHPB_WHHH@Z + ?before@type_info@@QBEHABV1@@Z + ?get_error_code@scheduler_resource_allocation_error@Concurrency@@QBEJXZ + ?lock@critical_section@Concurrency@@QAEXXZ + ?lock@reader_writer_lock@Concurrency@@QAEXXZ + ?lock_read@reader_writer_lock@Concurrency@@QAEXXZ + ?name@type_info@@QBEPBDPAU__type_info_node@@@Z + ?native_handle@critical_section@Concurrency@@QAEAAV12@XZ + ?raw_name@type_info@@QBEPBDXZ + ?reset@event@Concurrency@@QAEXXZ + ?set@event@Concurrency@@QAEXXZ + ?set_new_handler@@YAP6AXXZP6AXXZ@Z + ?set_terminate@@YAP6AXXZH@Z + ?set_terminate@@YAP6AXXZP6AXXZ@Z + ?set_unexpected@@YAP6AXXZH@Z + ?set_unexpected@@YAP6AXXZP6AXXZ@Z + ?swprintf@@YAHPAGIPBGZZ + ?swprintf@@YAHPA_WIPB_WZZ + ?terminate@@YAXXZ ;fixme-causes-trouble-with-version-in-libcmt.lib; + ?try_lock@critical_section@Concurrency@@QAE_NXZ + ?try_lock@reader_writer_lock@Concurrency@@QAE_NXZ + ?try_lock_read@reader_writer_lock@Concurrency@@QAE_NXZ + ?unexpected@@YAXXZ + ?unlock@critical_section@Concurrency@@QAEXXZ + ?unlock@reader_writer_lock@Concurrency@@QAEXXZ + ?vswprintf@@YAHPA_WIPB_WPAD@Z + ?wait@Concurrency@@YAXI@Z + ?wait@event@Concurrency@@QAEII@Z + ?wait_for_multiple@event@Concurrency@@SAIPAPAV12@I_NI@Z + ?what@exception@std@@UBEPBDXZ + $I10_OUTPUT + _CIacos + _CIasin + _CIatan + _CIatan2 + _CIcos + _CIcosh + _CIexp + _CIfmod + _CIlog + _CIlog10 + _CIpow + _CIsin + _CIsinh + _CIsqrt + _CItan + _CItanh + _CRT_RTC_INIT + _CRT_RTC_INITW + _CreateFrameInfo + _CxxThrowException + _EH_prolog + _FindAndUnlinkFrame + _Getdays + _Getmonths + _Gettnames + _HUGE + _IsExceptionObjectToBeDestroyed + _NLG_Dispatch2 + _NLG_Return + _NLG_Return2 + _Strftime + _XcptFilter + __AdjustPointer + __BuildCatchObject + __BuildCatchObjectHelper + __CppXcptFilter + __CxxCallUnwindDelDtor + __CxxCallUnwindDtor + __CxxCallUnwindStdDelDtor + __CxxCallUnwindVecDtor + __CxxDetectRethrow + __CxxExceptionFilter + __CxxFrameHandler + __CxxFrameHandler2 + __CxxFrameHandler3 + __CxxLongjmpUnwind + __CxxQueryExceptionSize + __CxxRegisterExceptionObject + __CxxUnregisterExceptionObject + __DestructExceptionObject + __FrameUnwindFilter + __RTCastToVoid + __RTDynamicCast + __RTtypeid + __STRINGTOLD + __STRINGTOLD_L + __TypeMatch + ___lc_codepage_func + ___lc_collate_cp_func + ___lc_handle_func + ___mb_cur_max_func + ___mb_cur_max_l_func + ___setlc_active_func + ___unguarded_readlc_active_add_func + __argc + __argv + __badioinfo + __clean_type_info_names_internal + __control87_2 + __create_locale + __crtCompareStringA + __crtCompareStringW + __crtLCMapStringA + __crtLCMapStringW + __daylight + __doserrno + __dstbias + ___fls_getvalue@4 + ___fls_setvalue@8 + __fpecode + __free_locale + __get_current_locale + __get_flsindex + ;fixme?; __get_tlsindex + __initenv + __iob_func + __isascii + __iscsym + __iscsymf + __iswcsym + __iswcsymf + __lconv + __lconv_init + __libm_sse2_acos + __libm_sse2_acosf + __libm_sse2_asin + __libm_sse2_asinf + __libm_sse2_atan + __libm_sse2_atan2 + __libm_sse2_atanf + __libm_sse2_cos + __libm_sse2_cosf + __libm_sse2_exp + __libm_sse2_expf + __libm_sse2_log + __libm_sse2_log10 + __libm_sse2_log10f + __libm_sse2_logf + __libm_sse2_pow + __libm_sse2_powf + __libm_sse2_sin + __libm_sse2_sinf + __libm_sse2_tan + __libm_sse2_tanf + __mb_cur_max + ;fixme?; __p___argc + ;fixme?; __p___argv + ;fixme?; __p___initenv + ;fixme?; __p___mb_cur_max + ;fixme?; __p___wargv + ;fixme?; __p___winitenv + ;fixme?; __p__acmdln + ;fixme?; __p__commode + ;fixme?; __p__daylight + ;fixme?; __p__dstbias + ;fixme?; __p__environ + ;fixme?; __p__fmode + ;fixme?; __p__iob + ;fixme?; __p__mbcasemap + ;fixme?; __p__mbctype + ;fixme?; __p__pctype + ;fixme?; __p__pgmptr + ;fixme?; __p__pwctype + ;fixme?; __p__timezone + ;fixme?; __p__tzname + ;fixme?; __p__wcmdln + ;fixme?; __p__wenviron + ;fixme?; __p__wpgmptr + + __pctype_func + __pioinfo + __pwctype_func + __pxcptinfoptrs + __report_gsfailure + __set_app_type + __set_flsgetvalue + __setlc_active + ;fixme?; __setusermatherr + __strncnt + __swprintf_l + __sys_errlist + __sys_nerr + __threadhandle + __threadid + __timezone + __toascii + __tzname + __unDName + __unDNameEx + __unDNameHelper + __unguarded_readlc_active + __vswprintf_l + __wargv + __wcserror + __wcserror_s + __wcsncnt + ;fixme?; __wgetmainargs + __winitenv + _abnormal_termination + _abs64 + _access + _access_s + _acmdln + _aligned_free + _aligned_malloc + _aligned_msize + _aligned_offset_malloc + _aligned_offset_realloc + _aligned_offset_recalloc + _aligned_realloc + _aligned_recalloc + _amsg_exit + _assert + _atodbl + _atodbl_l + _atof_l + _atoflt + _atoflt_l + _atoi64 + _atoi64_l + _atoi_l + _atol_l + _atoldbl + _atoldbl_l + _beep + _beginthread + _beginthreadex + _byteswap_uint64 + _byteswap_ulong + _byteswap_ushort + _c_exit + _cabs + _callnewh + _calloc_crt + _cexit + _cgets + _cgets_s + _cgetws + _cgetws_s + _chdir + _chdrive + _chgsign + _chkesp + _chmod + _chsize + _chsize_s + _clearfp + _close + _commit + ;fixme?; _commode + _configthreadlocale + _control87 + _controlfp + _controlfp_s + _copysign + _cprintf + _cprintf_l + _cprintf_p + _cprintf_p_l + _cprintf_s + _cprintf_s_l + _cputs + _cputws + _creat + _create_locale + _crt_debugger_hook + _cscanf + _cscanf_l + _cscanf_s + _cscanf_s_l + _ctime32 + _ctime32_s + _ctime64 + _ctime64_s + _cwait + _cwprintf + _cwprintf_l + _cwprintf_p + _cwprintf_p_l + _cwprintf_s + _cwprintf_s_l + _cwscanf + _cwscanf_l + _cwscanf_s + _cwscanf_s_l + _daylight + _difftime32 + _difftime64 + _dosmaperr + _dstbias + _dup + _dup2 + _dupenv_s + _ecvt + _ecvt_s + _encoded_null + _endthread + _endthreadex + _environ + _eof + _errno + _except_handler2 + _except_handler3 + ;fixme?; _except_handler4_common + _execl + _execle + _execlp + _execlpe + _execv + _execve + _execvp + _execvpe + _exit + _expand + _fclose_nolock + _fcloseall + _fcvt + _fcvt_s + _fdopen + _fflush_nolock + _fgetchar + _fgetwc_nolock + _fgetwchar + _filbuf + _filelength + _filelengthi64 + _fileno + _findclose + _findfirst32 + _findfirst32i64 + _findfirst64 + _findfirst64i32 + _findnext32 + _findnext32i64 + _findnext64 + _findnext64i32 + _finite + _flsbuf + _flushall + ;fixme?; _fmode + _fpclass + _fpieee_flt + _fpreset + _fprintf_l + _fprintf_p + _fprintf_p_l + _fprintf_s_l + _fputchar + _fputwc_nolock + _fputwchar + _fread_nolock + _fread_nolock_s + _free_locale + _freea + _freea_s + _freefls + _fscanf_l + _fscanf_s_l + _fseek_nolock + _fseeki64 + _fseeki64_nolock + _fsopen + _fstat32 + _fstat32i64 + _fstat64 + _fstat64i32 + _ftell_nolock + _ftelli64 + _ftelli64_nolock + _ftime32 + _ftime32_s + _ftime64 + _ftime64_s + _ftol + _fullpath + _futime32 + _futime64 + _fwprintf_l + _fwprintf_p + _fwprintf_p_l + _fwprintf_s_l + _fwrite_nolock + _fwscanf_l + _fwscanf_s_l + _gcvt + _gcvt_s + _get_current_locale + _get_daylight + _get_doserrno + _get_dstbias + _get_errno + _get_fmode + _get_heap_handle + _get_invalid_parameter_handler + _get_osfhandle + _get_output_format + _get_pgmptr + _get_printf_count_output + _get_purecall_handler + _get_terminate + _get_timezone + _get_tzname + _get_unexpected + _get_wpgmptr + _getc_nolock + _getch + _getch_nolock + _getche + _getche_nolock + _getcwd + _getdcwd + _getdcwd_nolock + _getdiskfree + _getdllprocaddr + _getdrive + _getdrives + _getmaxstdio + _getmbcp + _getpid + _getptd + _getsystime + _getw + _getwch + _getwch_nolock + _getwche + _getwche_nolock + _getws + _getws_s + _global_unwind2 + _gmtime32 + _gmtime32_s + _gmtime64 + _gmtime64_s + _heapadd + _heapchk + _heapmin + _heapset + _heapused + _heapwalk + _hypot + _hypotf + _i64toa + _i64toa_s + _i64tow + _i64tow_s + _initptd + ;fixme?; _initterm + _initterm_e + _inp + _inpd + _inpw + _invalid_parameter + _invalid_parameter_noinfo + _invalid_parameter_noinfo_noreturn + _invoke_watson + _iob + _isalnum_l + _isalpha_l + _isatty + _iscntrl_l + _isctype + _isctype_l + _isdigit_l + _isgraph_l + _isleadbyte_l + _islower_l + _ismbbalnum + _ismbbalnum_l + _ismbbalpha + _ismbbalpha_l + _ismbbgraph + _ismbbgraph_l + _ismbbkalnum + _ismbbkalnum_l + _ismbbkana + _ismbbkana_l + _ismbbkprint + _ismbbkprint_l + _ismbbkpunct + _ismbbkpunct_l + _ismbblead + _ismbblead_l + _ismbbprint + _ismbbprint_l + _ismbbpunct + _ismbbpunct_l + _ismbbtrail + _ismbbtrail_l + _ismbcalnum + _ismbcalnum_l + _ismbcalpha + _ismbcalpha_l + _ismbcdigit + _ismbcdigit_l + _ismbcgraph + _ismbcgraph_l + _ismbchira + _ismbchira_l + _ismbckata + _ismbckata_l + _ismbcl0 + _ismbcl0_l + _ismbcl1 + _ismbcl1_l + _ismbcl2 + _ismbcl2_l + _ismbclegal + _ismbclegal_l + _ismbclower + _ismbclower_l + _ismbcprint + _ismbcprint_l + _ismbcpunct + _ismbcpunct_l + _ismbcspace + _ismbcspace_l + _ismbcsymbol + _ismbcsymbol_l + _ismbcupper + _ismbcupper_l + _ismbslead + _ismbslead_l + _ismbstrail + _ismbstrail_l + _isnan + _isprint_l + _ispunct_l + _isspace_l + _isupper_l + _iswalnum_l + _iswalpha_l + _iswcntrl_l + _iswcsym_l + _iswcsymf_l + _iswctype_l + _iswdigit_l + _iswgraph_l + _iswlower_l + _iswprint_l + _iswpunct_l + _iswspace_l + _iswupper_l + _iswxdigit_l + _isxdigit_l + _itoa + _itoa_s + _itow + _itow_s + _j0 + _j1 + _jn + _kbhit + _lfind + _lfind_s + _loaddll + _local_unwind2 + _local_unwind4 + _localtime32 + _localtime32_s + _localtime64 + _localtime64_s + _lock + _lock_file + _locking + _logb + _longjmpex + _lrotl + _lrotr + _lsearch + _lsearch_s + _lseek + _lseeki64 + _ltoa + _ltoa_s + _ltow + _ltow_s + _makepath + _makepath_s + _malloc_crt + _mbbtombc + _mbbtombc_l + _mbbtype + _mbbtype_l + _mbcasemap + _mbccpy + _mbccpy_l + _mbccpy_s + _mbccpy_s_l + _mbcjistojms + _mbcjistojms_l + _mbcjmstojis + _mbcjmstojis_l + _mbclen + _mbclen_l + _mbctohira + _mbctohira_l + _mbctokata + _mbctokata_l + _mbctolower + _mbctolower_l + _mbctombb + _mbctombb_l + _mbctoupper + _mbctoupper_l + _mbctype + _mblen_l + _mbsbtype + _mbsbtype_l + _mbscat_s + _mbscat_s_l + _mbschr + _mbschr_l + _mbscmp + _mbscmp_l + _mbscoll + _mbscoll_l + _mbscpy_s + _mbscpy_s_l + _mbscspn + _mbscspn_l + _mbsdec + _mbsdec_l + _mbsicmp + _mbsicmp_l + _mbsicoll + _mbsicoll_l + _mbsinc + _mbsinc_l + _mbslen + _mbslen_l + _mbslwr + _mbslwr_l + _mbslwr_s + _mbslwr_s_l + _mbsnbcat + _mbsnbcat_l + _mbsnbcat_s + _mbsnbcat_s_l + _mbsnbcmp + _mbsnbcmp_l + _mbsnbcnt + _mbsnbcnt_l + _mbsnbcoll + _mbsnbcoll_l + _mbsnbcpy + _mbsnbcpy_l + _mbsnbcpy_s + _mbsnbcpy_s_l + _mbsnbicmp + _mbsnbicmp_l + _mbsnbicoll + _mbsnbicoll_l + _mbsnbset + _mbsnbset_l + _mbsnbset_s + _mbsnbset_s_l + _mbsncat + _mbsncat_l + _mbsncat_s + _mbsncat_s_l + _mbsnccnt + _mbsnccnt_l + _mbsncmp + _mbsncmp_l + _mbsncoll + _mbsncoll_l + _mbsncpy + _mbsncpy_l + _mbsncpy_s + _mbsncpy_s_l + _mbsnextc + _mbsnextc_l + _mbsnicmp + _mbsnicmp_l + _mbsnicoll + _mbsnicoll_l + _mbsninc + _mbsninc_l + _mbsnlen + _mbsnlen_l + _mbsnset + _mbsnset_l + _mbsnset_s + _mbsnset_s_l + _mbspbrk + _mbspbrk_l + _mbsrchr + _mbsrchr_l + _mbsrev + _mbsrev_l + _mbsset + _mbsset_l + _mbsset_s + _mbsset_s_l + _mbsspn + _mbsspn_l + _mbsspnp + _mbsspnp_l + _mbsstr + _mbsstr_l + _mbstok + _mbstok_l + _mbstok_s + _mbstok_s_l + _mbstowcs_l + _mbstowcs_s_l + _mbstrlen + _mbstrlen_l + _mbstrnlen + _mbstrnlen_l + _mbsupr + _mbsupr_l + _mbsupr_s + _mbsupr_s_l + _mbtowc_l + _memccpy + _memicmp + _memicmp_l + _mkdir + _mkgmtime32 + _mkgmtime64 + _mktemp + _mktemp_s + _mktime32 + _mktime64 + _msize + _nextafter + _open + _open_osfhandle + _outp + _outpd + _outpw + _pclose + _pctype + _pgmptr + _pipe + _popen + _printf_l + _printf_p + _printf_p_l + _printf_s_l + _purecall + _putch + _putch_nolock + _putenv + _putenv_s + _putw + _putwch + _putwch_nolock + _putws + _pwctype + _read + _realloc_crt + _recalloc + _recalloc_crt + _resetstkoflw + _rmdir + _rmtmp + _rotl + _rotl64 + _rotr + _rotr64 + _scalb + _scanf_l + _scanf_s_l + _scprintf + _scprintf_l + _scprintf_p + _scprintf_p_l + _scwprintf + _scwprintf_l + _scwprintf_p + _scwprintf_p_l + _searchenv + _searchenv_s + _seh_longjmp_unwind4 + _seh_longjmp_unwind + _set_SSE2_enable + _set_abort_behavior + _set_controlfp + _set_doserrno + _set_errno + _set_error_mode + _set_fmode + _set_invalid_parameter_handler + _set_malloc_crt_max_wait + _set_output_format + _set_printf_count_output + _set_purecall_handler + _seterrormode + _setjmp + _setjmp3 + _setmaxstdio + _setmbcp + _setmode + _setsystime + _sleep + _snprintf + _snprintf_c + _snprintf_c_l + _snprintf_l + _snprintf_s + _snprintf_s_l + _snscanf + _snscanf_l + _snscanf_s + _snscanf_s_l + _snwprintf + _snwprintf_l + _snwprintf_s + _snwprintf_s_l + _snwscanf + _snwscanf_l + _snwscanf_s + _snwscanf_s_l + _sopen + _sopen_s + _spawnl + _spawnle + _spawnlp + _spawnlpe + _spawnv + _spawnve + _spawnvp + _spawnvpe + _splitpath + _splitpath_s + _sprintf_l + _sprintf_p + _sprintf_p_l + _sprintf_s_l + _sscanf_l + _sscanf_s_l + _stat32 + _stat32i64 + _stat64 + _stat64i32 + _statusfp + _statusfp2 + _strcoll_l + _strdate + _strdate_s + _strdup + _strerror + _strerror_s + _strftime_l + _stricmp + _stricmp_l + _stricoll + _stricoll_l + _strlwr + _strlwr_l + _strlwr_s + _strlwr_s_l + _strncoll + _strncoll_l + _strnicmp + _strnicmp_l + _strnicoll + _strnicoll_l + _strnset + _strnset_s + _strrev + _strset + _strset_s + _strtime + _strtime_s + _strtod_l + _strtoi64 + _strtoi64_l + _strtol_l + _strtoui64 + _strtoui64_l + _strtoul_l + _strupr + _strupr_l + _strupr_s + _strupr_s_l + _strxfrm_l + _swab + _swprintf + _swprintf_c + _swprintf_c_l + _swprintf_p + _swprintf_p_l + _swprintf_s_l + _swscanf_l + _swscanf_s_l + _sys_errlist + _sys_nerr + _tell + _telli64 + _tempnam + _time32 + _time64 + _timezone + _tolower + _tolower_l + _toupper + _toupper_l + _towlower_l + _towupper_l + _tzname + _tzset + _ui64toa + _ui64toa_s + _ui64tow + _ui64tow_s + _ultoa + _ultoa_s + _ultow + _ultow_s + _umask + _umask_s + _ungetc_nolock + _ungetch + _ungetch_nolock + _ungetwc_nolock + _ungetwch + _ungetwch_nolock + _unlink + _unloaddll + _unlock + _unlock_file + _utime32 + _utime64 + _vcprintf + _vcprintf_l + _vcprintf_p + _vcprintf_p_l + _vcprintf_s + _vcprintf_s_l + _vcwprintf + _vcwprintf_l + _vcwprintf_p + _vcwprintf_p_l + _vcwprintf_s + _vcwprintf_s_l + _vfprintf_l + _vfprintf_p + _vfprintf_p_l + _vfprintf_s_l + _vfwprintf_l + _vfwprintf_p + _vfwprintf_p_l + _vfwprintf_s_l + _vprintf_l + _vprintf_p + _vprintf_p_l + _vprintf_s_l + _vscprintf + _vscprintf_l + _vscprintf_p + _vscprintf_p_l + _vscwprintf + _vscwprintf_l + _vscwprintf_p + _vscwprintf_p_l + _vsnprintf + _vsnprintf_c + _vsnprintf_c_l + _vsnprintf_l + _vsnprintf_s + _vsnprintf_s_l + _vsnwprintf + _vsnwprintf_l + _vsnwprintf_s + _vsnwprintf_s_l + _vsprintf_l + _vsprintf_p + _vsprintf_p_l + _vsprintf_s_l + _vswprintf + _vswprintf_c + _vswprintf_c_l + _vswprintf_l + _vswprintf_p + _vswprintf_p_l + _vswprintf_s_l + _vwprintf_l + _vwprintf_p + _vwprintf_p_l + _vwprintf_s_l + _waccess + _waccess_s + _wasctime + _wasctime_s + _wassert + _wchdir + _wchmod + ;fixme?; _wcmdln + _wcreat + _wcscoll_l + _wcsdup + _wcserror + _wcserror_s + _wcsftime_l + _wcsicmp + _wcsicmp_l + _wcsicoll + _wcsicoll_l + _wcslwr + _wcslwr_l + _wcslwr_s + _wcslwr_s_l + _wcsncoll + _wcsncoll_l + _wcsnicmp + _wcsnicmp_l + _wcsnicoll + _wcsnicoll_l + _wcsnset + _wcsnset_s + _wcsrev + _wcsset + _wcsset_s + _wcstod_l + _wcstoi64 + _wcstoi64_l + _wcstol_l + _wcstombs_l + _wcstombs_s_l + _wcstoui64 + _wcstoui64_l + _wcstoul_l + _wcsupr + _wcsupr_l + _wcsupr_s + _wcsupr_s_l + _wcsxfrm_l + _wctime32 + _wctime32_s + _wctime64 + _wctime64_s + _wctomb_l + _wctomb_s_l + _wctype + _wdupenv_s + _wenviron + _wexecl + _wexecle + _wexeclp + _wexeclpe + _wexecv + _wexecve + _wexecvp + _wexecvpe + _wfdopen + _wfindfirst32 + _wfindfirst32i64 + _wfindfirst64 + _wfindfirst64i32 + _wfindnext32 + _wfindnext32i64 + _wfindnext64 + _wfindnext64i32 + _wfopen + _wfopen_s + _wfreopen + _wfreopen_s + _wfsopen + _wfullpath + _wgetcwd + _wgetdcwd + _wgetdcwd_nolock + _wgetenv + _wgetenv_s + _wmakepath + _wmakepath_s + _wmkdir + _wmktemp + _wmktemp_s + _wopen + _wperror + _wpgmptr + _wpopen + _wprintf_l + _wprintf_p + _wprintf_p_l + _wprintf_s_l + _wputenv + _wputenv_s + _wremove + _wrename + _write + _wrmdir + _wscanf_l + _wscanf_s_l + _wsearchenv + _wsearchenv_s + _wsetlocale + _wsopen + _wsopen_s + _wspawnl + _wspawnle + _wspawnlp + _wspawnlpe + _wspawnv + _wspawnve + _wspawnvp + _wspawnvpe + _wsplitpath + _wsplitpath_s + _wstat32 + _wstat32i64 + _wstat64 + _wstat64i32 + _wstrdate + _wstrdate_s + _wstrtime + _wstrtime_s + _wsystem + _wtempnam + _wtmpnam + _wtmpnam_s + _wtof + _wtof_l + _wtoi + _wtoi64 + _wtoi64_l + _wtoi_l + _wtol + _wtol_l + _wunlink + _wutime32 + _wutime64 + _y0 + _y1 + _yn + abort + abs + acos + asctime + asctime_s + asin + atan + atan2 + atexit + atof + atoi + atol + bsearch + bsearch_s + btowc + calloc + ceil + clearerr + clearerr_s + clock + cos + cosh + div + exit + exp + fabs + fclose + feof + ferror + fflush + fgetc + fgetpos + fgets + fgetwc + fgetws + floor + fmod + fopen + fopen_s + fprintf + fprintf_s + fputc + fputs + fputwc + fputws + fread + fread_s + free + freopen + freopen_s + frexp + fscanf + fscanf_s + fseek + fsetpos + ftell + fwprintf + fwprintf_s + fwrite + fwscanf + fwscanf_s + getc + getchar + getenv + getenv_s + gets + gets_s + getwc + getwchar + is_wctype + isalnum + isalpha + iscntrl + isdigit + isgraph + isleadbyte + islower + isprint + ispunct + isspace + isupper + iswalnum + iswalpha + iswascii + iswcntrl + iswctype + iswdigit + iswgraph + iswlower + iswprint + iswpunct + iswspace + iswupper + iswxdigit + isxdigit + labs + ldexp + ldiv + llabs + lldiv + localeconv + log + log10 + longjmp + malloc + mblen + mbrlen + mbrtowc + mbsrtowcs + mbsrtowcs_s + mbstowcs + mbstowcs_s + mbtowc + memchr + memcmp + memcpy + memcpy_s + memmove + memmove_s + memset + modf + perror + pow + printf + printf_s + putc + putchar + puts + putwc + putwchar + qsort + qsort_s + raise + rand + rand_s + realloc + remove + rename + rewind + scanf + scanf_s + setbuf + setlocale + setvbuf + signal + sin + sinh + sprintf + sprintf_s + sqrt + srand + sscanf + sscanf_s + strcat + strcat_s + strchr + strcmp + strcoll + strcpy + strcpy_s + strcspn + strerror + strerror_s + strftime + strlen + strncat + strncat_s + strncmp + strncpy + strncpy_s + strnlen + strpbrk + strrchr + strspn + strstr + strtod + strtok + strtok_s + strtol + strtoul + strxfrm + swprintf_s + swscanf + swscanf_s + system + tan + tanh + tmpfile + tmpfile_s + tmpnam + tmpnam_s + tolower + toupper + towlower + towupper + ungetc + ungetwc + vfprintf + vfprintf_s + vfwprintf + vfwprintf_s + vprintf + vprintf_s + vsprintf + vsprintf_s + vswprintf_s + vwprintf + vwprintf_s + wcrtomb + wcrtomb_s + wcscat + wcscat_s + wcschr + wcscmp + wcscoll + wcscpy + wcscpy_s + wcscspn + wcsftime + wcslen + wcsncat + wcsncat_s + wcsncmp + wcsncpy + wcsncpy_s + wcsnlen + wcspbrk + wcsrchr + wcsrtombs + wcsrtombs_s + wcsspn + wcsstr + wcstod + wcstok + wcstok_s + wcstol + wcstombs + wcstombs_s + wcstoul + wcsxfrm + wctob + wctomb + wctomb_s + wmemcpy_s + wmemmove_s + wprintf + wprintf_s + wscanf + wscanf_s + diff --git a/src/VBox/Runtime/r3/win/VBoxRT-openssl-1.1plus.def b/src/VBox/Runtime/r3/win/VBoxRT-openssl-1.1plus.def new file mode 100644 index 00000000..563562ce --- /dev/null +++ b/src/VBox/Runtime/r3/win/VBoxRT-openssl-1.1plus.def @@ -0,0 +1,215 @@ +; $Id: VBoxRT-openssl-1.1plus.def $ +;; @file +; IPRT - Windows OpenSSL exports we use outside VBoxRT (keep them few!). +; +; This file is appended to the architecture specific .def file. +; + +; +; Copyright (C) 2009-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + + ; ConsoleImpl.cpp uses this when VBOX_OPENSSL_FIPS is enabled. + FIPS_mode + + ; VBoxVRDP.dll - secure.cpp + BIO_free + BIO_new_file + BN_bin2bn + BN_bn2bin + BN_CTX_free + BN_CTX_new + BN_free + BN_mod_exp + BN_new + BN_num_bits + BN_set_word + EVP_PKEY_get0_RSA + i2d_X509 + MD5_Final + MD5_Init + MD5_Update + OBJ_obj2nid + PEM_read_bio_PrivateKey + PEM_read_bio_X509 + RAND_bytes + RC4 + RC4_set_key + RSA_free + RSA_generate_key_ex + RSA_get0_key + RSA_new + SHA1_Final + SHA1_Init + SHA1_Update + X509_free + X509_get_X509_PUBKEY + X509_PUBKEY_get0_param + + ; VBoxVRDP.dll - tcp_vrdp.cpp + BIO_new_socket + BIO_test_flags + OPENSSL_init_ssl + SSL_accept + SSL_CTX_free + SSL_CTX_load_verify_locations + SSL_CTX_new + SSL_CTX_set_verify + SSL_CTX_use_certificate_file + SSL_CTX_use_PrivateKey_file + SSL_free + SSL_get_certificate + SSL_new + SSL_pending + SSL_read + SSL_set_bio + SSL_set_read_ahead + SSL_write + TLSv1_server_method + X509_get_issuer_name + X509_NAME_oneline + + ; VDPluginCrypt.dll (if it wanted to use IPRT) - VDKeyStore.cpp: + EVP_aes_128_xts + EVP_aes_256_xts + EVP_CIPHER_CTX_free + EVP_CIPHER_CTX_new + EVP_DecryptFinal + EVP_DecryptInit + EVP_DecryptUpdate + EVP_EncryptFinal + EVP_EncryptInit + EVP_EncryptUpdate + EVP_MD_size + EVP_sha1 + EVP_sha256 + EVP_sha512 + PKCS5_PBKDF2_HMAC + ;exported above: RAND_bytes + + ; VDPluginCrypt.dll (if it wanted to use IPRT) - VDFilterCrypt.cpp: + ;exported above: EVP_aes_128_xts + ;exported above: EVP_aes_256_xts + ;exported above: EVP_CIPHER_CTX_free + ;exported above: EVP_CIPHER_CTX_new + ;exported above: EVP_DecryptFinal + ;exported above: EVP_DecryptInit + ;exported above: EVP_DecryptUpdate + ;exported above: EVP_EncryptFinal + ;exported above: EVP_EncryptInit + ;exported above: EVP_EncryptUpdate + ;exported above: RAND_bytes + + ; vboxwebsrv needs SSL support. + ASN1_STRING_data + ASN1_STRING_to_UTF8 + ;exported above: BIO_free + ;exported above: BIO_new_file + ;exported above: BIO_new_socket + BIO_read + BIO_write + CRYPTO_free + DH_check + DH_free + DH_generate_parameters + ERR_clear_error + ERR_error_string + ERR_error_string_n + ERR_get_error + ERR_peek_error + GENERAL_NAME_free + i2v_GENERAL_NAMES + OPENSSL_init_crypto + ;exported above: OPENSSL_init_ssl + OPENSSL_sk_num + OPENSSL_sk_pop_free + OPENSSL_sk_value + PEM_read_bio_DHparams + RAND_load_file + RAND_pseudo_bytes + RAND_seed + RAND_status + ;exported above: RSA_free + RSA_generate_key + ;exported above: SSL_accept + SSL_clear + SSL_connect + SSL_ctrl + SSL_CTX_ctrl + ;exported above: SSL_CTX_free + SSL_CTX_get_cert_store + ;exported above: SSL_CTX_load_verify_locations + ;exported above: SSL_CTX_new + SSL_CTX_set_client_CA_list + SSL_CTX_set_default_passwd_cb + SSL_CTX_set_default_passwd_cb_userdata + SSL_CTX_set_default_verify_paths + SSL_CTX_set_options + SSL_CTX_set_session_id_context + ;exported above: SSL_CTX_set_verify + SSL_CTX_set_verify_depth + SSL_CTX_use_certificate_chain_file + ;exported above: SSL_CTX_use_PrivateKey_file + ;exported above: SSL_free + SSL_get_error + SSL_get_peer_certificate + SSL_get_verify_result + SSL_get1_session + SSL_is_init_finished + SSL_load_client_CA_file + ;exported above: SSL_new + SSL_peek + ;exported above: SSL_read + SSL_SESSION_free + ;exported above: SSL_set_bio + SSL_set_session + SSL_shutdown + SSL_want + ;exported above: SSL_write + TLS_method + ;exported above: X509_free + X509_get_ext_d2i + ;exported above: X509_get_issuer_name + X509_get_subject_name + X509_load_crl_file + X509_LOOKUP_file + X509_NAME_ENTRY_get_data + X509_NAME_get_entry + X509_NAME_get_index_by_NID + ;exported above: X509_NAME_oneline + X509_STORE_add_lookup + X509_STORE_CTX_get_current_cert + X509_STORE_CTX_get_error + X509_STORE_CTX_get_error_depth + X509_STORE_CTX_set_error + X509_STORE_set1_param + X509_STORE_set_flags + X509_verify_cert_error_string + X509_VERIFY_PARAM_free + X509_VERIFY_PARAM_new + X509_VERIFY_PARAM_set_flags + X509V3_conf_free + + ; tstRTBigNum.cpp + BN_div + BN_mul + BN_mod_exp_simple + BN_ucmp + diff --git a/src/VBox/Runtime/r3/win/VBoxRT-openssl-pre-1.1.def b/src/VBox/Runtime/r3/win/VBoxRT-openssl-pre-1.1.def new file mode 100644 index 00000000..04c470ea --- /dev/null +++ b/src/VBox/Runtime/r3/win/VBoxRT-openssl-pre-1.1.def @@ -0,0 +1,243 @@ +; $Id: VBoxRT-openssl-pre-1.1.def $ +;; @file +; IPRT - Windows OpenSSL v1.0.x exports we use outside VBoxRT (keep them few!). +; +; This file is appended to the architecture specific .def file. +; + +; +; Copyright (C) 2009-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + + ; ConsoleImpl.cpp uses this when VBOX_OPENSSL_FIPS is enabled. + FIPS_mode + + ; VBoxVRDP.dll - secure.cpp + BIO_free + BIO_new_file + BN_bin2bn + BN_bn2bin + BN_CTX_free + BN_CTX_new + BN_free + BN_mod_exp + BN_new + BN_num_bits + BN_set_word + ;1.1.0: EVP_PKEY_get0_RSA + i2d_X509 + MD5_Final + MD5_Init + MD5_Update + OBJ_obj2nid + PEM_read_bio_PrivateKey + PEM_read_bio_X509 + RAND_bytes + RC4 + RC4_set_key + RSA_free + RSA_generate_key_ex + ;1.1.0: RSA_get0_key + RSA_new + SHA1_Final + SHA1_Init + SHA1_Update + X509_free + ;1.1.0: X509_get_X509_PUBKEY + X509_PUBKEY_get0_param + + ; VBoxVRDP.dll - secure.cpp - 1.0.1 additions: + BN_init + + ; VBoxVRDP.dll - tcp_vrdp.cpp + BIO_new_socket + BIO_test_flags + ;1.1.0: OPENSSL_init_ssl + SSL_accept + SSL_CTX_free + SSL_CTX_load_verify_locations + SSL_CTX_new + SSL_CTX_set_verify + SSL_CTX_use_certificate_file + SSL_CTX_use_PrivateKey_file + SSL_free + SSL_get_certificate + SSL_new + SSL_pending + SSL_read + SSL_set_bio + SSL_set_read_ahead + SSL_write + TLSv1_server_method + X509_get_issuer_name + X509_NAME_oneline + + ; VDPluginCrypt.dll (if it wanted to use IPRT) - VDKeyStore.cpp: + EVP_aes_128_xts + EVP_aes_256_xts + EVP_CIPHER_CTX_free + EVP_CIPHER_CTX_new + EVP_DecryptFinal + EVP_DecryptInit + EVP_DecryptUpdate + EVP_EncryptFinal + EVP_EncryptInit + EVP_EncryptUpdate + EVP_MD_size + EVP_sha1 + EVP_sha256 + EVP_sha512 + PKCS5_PBKDF2_HMAC + ;exported above: RAND_bytes + + ; VDPluginCrypt.dll (if it wanted to use IPRT) - VDFilterCrypt.cpp: + ;exported above: EVP_aes_128_xts + ;exported above: EVP_aes_256_xts + ;exported above: EVP_CIPHER_CTX_free + ;exported above: EVP_CIPHER_CTX_new + ;exported above: EVP_DecryptFinal + ;exported above: EVP_DecryptInit + ;exported above: EVP_DecryptUpdate + ;exported above: EVP_EncryptFinal + ;exported above: EVP_EncryptInit + ;exported above: EVP_EncryptUpdate + ;exported above: RAND_bytes + + ; vboxwebsrv needs SSL support. + ASN1_STRING_data + ASN1_STRING_to_UTF8 + ;exported above: BIO_free + ;exported above: BIO_new_file + ;exported above: BIO_new_socket + BIO_read + BIO_write + CRYPTO_free + DH_check + DH_free + DH_generate_parameters + ERR_clear_error + ERR_error_string + ERR_error_string_n + ERR_get_error + ERR_peek_error + GENERAL_NAME_free + i2v_GENERAL_NAMES + ;1.1.0: OPENSSL_init_crypto + ;exported above: OPENSSL_init_ssl + ;1.1.0: OPENSSL_sk_num + ;1.1.0: OPENSSL_sk_pop_free + ;1.1.0: OPENSSL_sk_value + PEM_read_bio_DHparams + RAND_load_file + RAND_pseudo_bytes + RAND_seed + RAND_status + ;exported above: RSA_free + RSA_generate_key + ;exported above: SSL_accept + SSL_clear + SSL_connect + SSL_ctrl + SSL_CTX_ctrl + ;exported above: SSL_CTX_free + SSL_CTX_get_cert_store + ;exported above: SSL_CTX_load_verify_locations + ;exported above: SSL_CTX_new + SSL_CTX_set_client_CA_list + SSL_CTX_set_default_passwd_cb + SSL_CTX_set_default_passwd_cb_userdata + SSL_CTX_set_default_verify_paths + ;1.1.0: SSL_CTX_set_options + SSL_CTX_set_session_id_context + ;exported above: SSL_CTX_set_verify + SSL_CTX_set_verify_depth + SSL_CTX_use_certificate_chain_file + ;exported above: SSL_CTX_use_PrivateKey_file + ;exported above: SSL_free + SSL_get_error + SSL_get_peer_certificate + SSL_get_verify_result + SSL_get1_session + ;1.1.0: SSL_is_init_finished + SSL_load_client_CA_file + ;exported above: SSL_new + SSL_peek + ;exported above: SSL_read + SSL_SESSION_free + ;exported above: SSL_set_bio + SSL_set_session + SSL_shutdown + SSL_want + ;exported above: SSL_write + ;1.1.0: TLS_method + ;exported above: X509_free + X509_get_ext_d2i + ;exported above: X509_get_issuer_name + X509_get_subject_name + X509_load_crl_file + X509_LOOKUP_file + X509_NAME_ENTRY_get_data + X509_NAME_get_entry + X509_NAME_get_index_by_NID + ;exported above: X509_NAME_oneline + X509_STORE_add_lookup + X509_STORE_CTX_get_current_cert + X509_STORE_CTX_get_error + X509_STORE_CTX_get_error_depth + X509_STORE_CTX_set_error + X509_STORE_set1_param + X509_STORE_set_flags + X509_verify_cert_error_string + X509_VERIFY_PARAM_free + X509_VERIFY_PARAM_new + X509_VERIFY_PARAM_set_flags + X509V3_conf_free + + ; vboxwebsrv - 1.0.1 additions + CRYPTO_set_dynlock_destroy_callback + CRYPTO_set_dynlock_lock_callback + CRYPTO_set_dynlock_create_callback + CRYPTO_set_locking_callback + CRYPTO_set_id_callback + CRYPTO_num_locks + ERR_remove_state + OPENSSL_add_all_algorithms_noconf + sk_value + sk_num + sk_pop_free + SSL_load_error_strings + SSL_library_init + SSL_state + SSLv23_method + + ; vboxwebsrv - 1.0.1 additions for older gsoap version. + ASN1_item_d2i + OBJ_nid2sn + X509_EXTENSION_get_object + X509_get_ext + X509_get_ext_count + X509V3_EXT_get + + ; tstRTBigNum.cpp + BN_div + BN_mul + BN_mod_exp_simple + BN_ucmp + diff --git a/src/VBox/Runtime/r3/win/VBoxRT-win32.def b/src/VBox/Runtime/r3/win/VBoxRT-win32.def new file mode 100644 index 00000000..7a5f15d8 --- /dev/null +++ b/src/VBox/Runtime/r3/win/VBoxRT-win32.def @@ -0,0 +1,44 @@ +; $Id: VBoxRT-win32.def $ +;; @file +; IPRT - Win32 ASM exports. +; + +; +; Copyright (C) 2006-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + +EXPORTS + ASMMultU64ByU32DivByU32 + + RTTimeNanoTSLegacySyncInvarNoDelta + RTTimeNanoTSLFenceSyncInvarNoDelta + RTTimeNanoTSLegacyAsyncUseApicId + RTTimeNanoTSLegacyAsyncUseRdtscp + RTTimeNanoTSLegacyAsyncUseIdtrLim + RTTimeNanoTSLegacySyncInvarWithDeltaUseApicId + RTTimeNanoTSLegacySyncInvarWithDeltaUseRdtscp + RTTimeNanoTSLegacySyncInvarWithDeltaUseIdtrLim + RTTimeNanoTSLFenceAsyncUseApicId + RTTimeNanoTSLFenceAsyncUseRdtscp + RTTimeNanoTSLFenceAsyncUseIdtrLim + RTTimeNanoTSLFenceSyncInvarWithDeltaUseApicId + RTTimeNanoTSLFenceSyncInvarWithDeltaUseRdtscp + RTTimeNanoTSLFenceSyncInvarWithDeltaUseIdtrLim + diff --git a/src/VBox/Runtime/r3/win/VBoxRT-win64.def b/src/VBox/Runtime/r3/win/VBoxRT-win64.def new file mode 100644 index 00000000..f1bd60d8 --- /dev/null +++ b/src/VBox/Runtime/r3/win/VBoxRT-win64.def @@ -0,0 +1,56 @@ +; $Id: VBoxRT-win64.def $ +;; @file +; IPRT - Win64 ASM exports. +; + +; +; Copyright (C) 2006-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + +EXPORTS + ASMAtomicBitClear + ASMAtomicBitToggle + ASMAtomicBitTestAndToggle + ASMBitFirstClear + ASMBitFirstSet + ASMAtomicReadU64 + ASMAtomicXchgU8 + ASMAtomicXchgU16 + ASMGetFlags + ASMProbeReadByte + ASMSetFlags + ASMMultU64ByU32DivByU32 + ASMNopPause + + RTTimeNanoTSLegacySyncInvarNoDelta + RTTimeNanoTSLFenceSyncInvarNoDelta + RTTimeNanoTSLegacyAsyncUseApicId + RTTimeNanoTSLegacyAsyncUseRdtscp + RTTimeNanoTSLegacyAsyncUseIdtrLim + RTTimeNanoTSLegacySyncInvarWithDeltaUseApicId + RTTimeNanoTSLegacySyncInvarWithDeltaUseRdtscp + RTTimeNanoTSLegacySyncInvarWithDeltaUseIdtrLim + RTTimeNanoTSLFenceAsyncUseApicId + RTTimeNanoTSLFenceAsyncUseRdtscp + RTTimeNanoTSLFenceAsyncUseIdtrLim + RTTimeNanoTSLFenceSyncInvarWithDeltaUseApicId + RTTimeNanoTSLFenceSyncInvarWithDeltaUseRdtscp + RTTimeNanoTSLFenceSyncInvarWithDeltaUseIdtrLim + diff --git a/src/VBox/Runtime/r3/win/alloc-win.cpp b/src/VBox/Runtime/r3/win/alloc-win.cpp new file mode 100644 index 00000000..084e588e --- /dev/null +++ b/src/VBox/Runtime/r3/win/alloc-win.cpp @@ -0,0 +1,208 @@ +/* $Id: alloc-win.cpp $ */ +/** @file + * IPRT - Memory Allocation, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +/*#define USE_VIRTUAL_ALLOC*/ +#define LOG_GROUP RTLOGGROUP_MEM +#include <iprt/win/windows.h> + +#include <iprt/alloc.h> +#include <iprt/assert.h> +#include <iprt/param.h> +#include <iprt/string.h> +#include <iprt/errcore.h> + +#ifndef USE_VIRTUAL_ALLOC +# include <malloc.h> +#endif + + +RTDECL(void *) RTMemExecAllocTag(size_t cb, const char *pszTag) RT_NO_THROW_DEF +{ + RT_NOREF_PV(pszTag); + + /* + * Allocate first. + */ + AssertMsg(cb, ("Allocating ZERO bytes is really not a good idea! Good luck with the next assertion!\n")); + cb = RT_ALIGN_Z(cb, 32); + void *pv = malloc(cb); + AssertMsg(pv, ("malloc(%d) failed!!!\n", cb)); + if (pv) + { + memset(pv, 0xcc, cb); + void *pvProt = (void *)((uintptr_t)pv & ~(uintptr_t)PAGE_OFFSET_MASK); + size_t cbProt = ((uintptr_t)pv & PAGE_OFFSET_MASK) + cb; + cbProt = RT_ALIGN_Z(cbProt, PAGE_SIZE); + DWORD fFlags = 0; + if (!VirtualProtect(pvProt, cbProt, PAGE_EXECUTE_READWRITE, &fFlags)) + { + AssertMsgFailed(("VirtualProtect(%p, %#x,,) -> lasterr=%d\n", pvProt, cbProt, GetLastError())); + free(pv); + pv = NULL; + } + } + return pv; +} + + +RTDECL(void) RTMemExecFree(void *pv, size_t cb) RT_NO_THROW_DEF +{ + RT_NOREF_PV(cb); + + if (pv) + free(pv); +} + + +RTDECL(void *) RTMemPageAllocTag(size_t cb, const char *pszTag) RT_NO_THROW_DEF +{ + RT_NOREF_PV(pszTag); + +#ifdef USE_VIRTUAL_ALLOC + void *pv = VirtualAlloc(NULL, RT_ALIGN_Z(cb, PAGE_SIZE), MEM_COMMIT, PAGE_READWRITE); +#else + void *pv = _aligned_malloc(RT_ALIGN_Z(cb, PAGE_SIZE), PAGE_SIZE); +#endif + AssertMsg(pv, ("cb=%d lasterr=%d\n", cb, GetLastError())); + return pv; +} + + +RTDECL(void *) RTMemPageAllocZTag(size_t cb, const char *pszTag) RT_NO_THROW_DEF +{ + RT_NOREF_PV(pszTag); + +#ifdef USE_VIRTUAL_ALLOC + void *pv = VirtualAlloc(NULL, RT_ALIGN_Z(cb, PAGE_SIZE), MEM_COMMIT, PAGE_READWRITE); +#else + void *pv = _aligned_malloc(RT_ALIGN_Z(cb, PAGE_SIZE), PAGE_SIZE); +#endif + if (pv) + { + memset(pv, 0, RT_ALIGN_Z(cb, PAGE_SIZE)); + return pv; + } + AssertMsgFailed(("cb=%d lasterr=%d\n", cb, GetLastError())); + return NULL; +} + + +RTDECL(void) RTMemPageFree(void *pv, size_t cb) RT_NO_THROW_DEF +{ + RT_NOREF_PV(cb); + + if (pv) + { +#ifdef USE_VIRTUAL_ALLOC + if (!VirtualFree(pv, 0, MEM_RELEASE)) + AssertMsgFailed(("pv=%p lasterr=%d\n", pv, GetLastError())); +#else + _aligned_free(pv); +#endif + } +} + + +RTDECL(int) RTMemProtect(void *pv, size_t cb, unsigned fProtect) RT_NO_THROW_DEF +{ + /* + * Validate input. + */ + if (cb == 0) + { + AssertMsgFailed(("!cb\n")); + return VERR_INVALID_PARAMETER; + } + if (fProtect & ~(RTMEM_PROT_NONE | RTMEM_PROT_READ | RTMEM_PROT_WRITE | RTMEM_PROT_EXEC)) + { + AssertMsgFailed(("fProtect=%#x\n", fProtect)); + return VERR_INVALID_PARAMETER; + } + + /* + * Convert the flags. + */ + int fProt; + Assert(!RTMEM_PROT_NONE); + switch (fProtect & (RTMEM_PROT_NONE | RTMEM_PROT_READ | RTMEM_PROT_WRITE | RTMEM_PROT_EXEC)) + { + case RTMEM_PROT_NONE: + fProt = PAGE_NOACCESS; + break; + + case RTMEM_PROT_READ: + fProt = PAGE_READONLY; + break; + + case RTMEM_PROT_READ | RTMEM_PROT_WRITE: + fProt = PAGE_READWRITE; + break; + + case RTMEM_PROT_READ | RTMEM_PROT_WRITE | RTMEM_PROT_EXEC: + fProt = PAGE_EXECUTE_READWRITE; + break; + + case RTMEM_PROT_READ | RTMEM_PROT_EXEC: + fProt = PAGE_EXECUTE_READWRITE; + break; + + case RTMEM_PROT_WRITE: + fProt = PAGE_READWRITE; + break; + + case RTMEM_PROT_WRITE | RTMEM_PROT_EXEC: + fProt = PAGE_EXECUTE_READWRITE; + break; + + case RTMEM_PROT_EXEC: + fProt = PAGE_EXECUTE_READWRITE; + break; + + /* If the compiler had any brains it would warn about this case. */ + default: + AssertMsgFailed(("fProtect=%#x\n", fProtect)); + return VERR_INTERNAL_ERROR; + } + + /* + * Align the request. + */ + cb += (uintptr_t)pv & PAGE_OFFSET_MASK; + pv = (void *)((uintptr_t)pv & ~(uintptr_t)PAGE_OFFSET_MASK); + + /* + * Change the page attributes. + */ + DWORD fFlags = 0; + if (VirtualProtect(pv, cb, fProt, &fFlags)) + return VINF_SUCCESS; + return RTErrConvertFromWin32(GetLastError()); +} + diff --git a/src/VBox/Runtime/r3/win/allocex-win.cpp b/src/VBox/Runtime/r3/win/allocex-win.cpp new file mode 100644 index 00000000..20b7c4cf --- /dev/null +++ b/src/VBox/Runtime/r3/win/allocex-win.cpp @@ -0,0 +1,123 @@ +/* $Id: allocex-win.cpp $ */ +/** @file + * IPRT - Memory Allocation, Extended Alloc Workers, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define RTMEM_NO_WRAP_TO_EF_APIS +#include <iprt/mem.h> +#include "internal/iprt.h" + +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/string.h> +#include <iprt/param.h> +#include "../allocex.h" + +#include <iprt/win/windows.h> + + +static int rtMemAllocExInRange(size_t cbAlloc, uint32_t fFlags, void **ppv, uintptr_t uAddr, uintptr_t uAddrLast) +{ + /* + * Try with every possible address hint since the possible range is very limited. + */ + DWORD fPageProt = (fFlags & RTMEMALLOCEX_FLAGS_EXEC ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE); + while (uAddr <= uAddrLast) + { + MEMORY_BASIC_INFORMATION MemInfo; + SIZE_T cbRange = VirtualQuery((void *)uAddr, &MemInfo, sizeof(MemInfo)); + AssertReturn(cbRange == sizeof(MemInfo), VERR_NOT_SUPPORTED); + Assert(MemInfo.RegionSize > 0); + + if ( MemInfo.State == MEM_FREE + && MemInfo.RegionSize >= cbAlloc) + { + void *pv = VirtualAlloc((void *)uAddr, cbAlloc, MEM_RESERVE | MEM_COMMIT, fPageProt); + if ((uintptr_t)pv == uAddr) + { + *ppv = pv; + return VINF_SUCCESS; + } + AssertStmt(!pv, VirtualFree(pv, cbAlloc, MEM_RELEASE)); + } + + /* skip ahead */ + uintptr_t uAddrNext = (uintptr_t)MemInfo.BaseAddress + MemInfo.RegionSize; + if (uAddrNext <= uAddr) + break; + uAddr += uAddrNext; + } + + return VERR_NO_MEMORY; +} + + +DECLHIDDEN(int) rtMemAllocEx16BitReach(size_t cbAlloc, uint32_t fFlags, void **ppv) +{ + cbAlloc = RT_ALIGN_Z(cbAlloc, PAGE_SIZE); + AssertReturn(cbAlloc <= _64K - PAGE_SIZE, VERR_NO_MEMORY); + + /* Seems this doesn't work on W7/64... */ + return rtMemAllocExInRange(cbAlloc, fFlags, ppv, PAGE_SIZE, _64K - cbAlloc); +} + + +DECLHIDDEN(int) rtMemAllocEx32BitReach(size_t cbAlloc, uint32_t fFlags, void **ppv) +{ + cbAlloc = RT_ALIGN_Z(cbAlloc, PAGE_SIZE); + AssertReturn(cbAlloc <= _2G+_1G, VERR_NO_MEMORY); + + /* + * Just try first. + */ + DWORD fPageProt = (fFlags & RTMEMALLOCEX_FLAGS_EXEC ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE); + void *pv = VirtualAlloc(NULL, cbAlloc, MEM_RESERVE | MEM_COMMIT, fPageProt); + if (!pv) + return VERR_NO_MEMORY; + if ((uintptr_t)pv + cbAlloc - 1 < _4G) + { + *ppv = pv; + return VINF_SUCCESS; + } + VirtualFree(pv, cbAlloc, MEM_RELEASE); + + /* + * No luck, do address scan based allocation. + */ + return rtMemAllocExInRange(cbAlloc, fFlags, ppv, _64K, _4G - cbAlloc); +} + + +DECLHIDDEN(void) rtMemFreeExYyBitReach(void *pv, size_t cb, uint32_t fFlags) +{ + RT_NOREF_PV(fFlags); + + BOOL fRc = VirtualFree(pv, cb, MEM_RELEASE); + Assert(fRc); RT_NOREF_PV(fRc); +} + diff --git a/src/VBox/Runtime/r3/win/dir-win.cpp b/src/VBox/Runtime/r3/win/dir-win.cpp new file mode 100644 index 00000000..cbeecb77 --- /dev/null +++ b/src/VBox/Runtime/r3/win/dir-win.cpp @@ -0,0 +1,159 @@ +/* $Id: dir-win.cpp $ */ +/** @file + * IPRT - Directory, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_DIR +#include <iprt/win/windows.h> + +#include <iprt/dir.h> +#include <iprt/path.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/file.h> +#include <iprt/log.h> +#include "internal/fs.h" +#include "internal/path.h" + + + +RTDECL(int) RTDirCreate(const char *pszPath, RTFMODE fMode, uint32_t fCreate) +{ + /* + * Validate the file mode. + */ + int rc; + fMode = rtFsModeNormalize(fMode, pszPath, 0); + if (rtFsModeIsValidPermissions(fMode)) + { + /* + * Convert to UTF-16. + */ + PRTUTF16 pwszString; + rc = RTPathWinFromUtf8(&pwszString, pszPath, 0 /*fFlags*/); + AssertRC(rc); + if (RT_SUCCESS(rc)) + { + /* + * Create the directory. + */ + if (CreateDirectoryW((LPCWSTR)pwszString, NULL)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + + /* + * Turn off indexing of directory through Windows Indexing Service + */ + /** @todo This FILE_ATTRIBUTE_NOT_CONTENT_INDEXED hack (for .VDI files, + * really) may cause failures on samba shares. That really sweet and + * need to be addressed differently. We shouldn't be doing this + * unless the caller actually asks for it, must less returning failure, + * for crying out loud! This is only important a couple of places in + * main, if important is the right way to put it... */ + if ( RT_SUCCESS(rc) + && !(fCreate & RTDIRCREATE_FLAGS_NOT_CONTENT_INDEXED_DONT_SET)) + { + if ( SetFileAttributesW((LPCWSTR)pwszString, FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) + || (fCreate & RTDIRCREATE_FLAGS_NOT_CONTENT_INDEXED_NOT_CRITICAL) ) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + + RTPathWinFree(pwszString); + } + } + else + { + AssertMsgFailed(("Invalid file mode! %RTfmode\n", fMode)); + rc = VERR_INVALID_FMODE; + } + + LogFlow(("RTDirCreate(%p:{%s}, %RTfmode): returns %Rrc\n", pszPath, pszPath, fMode, rc)); + return rc; +} + + +RTDECL(int) RTDirRemove(const char *pszPath) +{ + /* + * Convert to UTF-16. + */ + PRTUTF16 pwszString; + int rc = RTPathWinFromUtf8(&pwszString, pszPath, 0 /*fFlags*/); + AssertRC(rc); + if (RT_SUCCESS(rc)) + { + /* + * Remove the directory. + */ + if (RemoveDirectoryW((LPCWSTR)pwszString)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + + RTPathWinFree(pwszString); + } + + LogFlow(("RTDirRemove(%p:{%s}): returns %Rrc\n", pszPath, pszPath, rc)); + return rc; +} + + +RTDECL(int) RTDirFlush(const char *pszPath) +{ + RT_NOREF_PV(pszPath); + return VERR_NOT_SUPPORTED; +} + + +RTDECL(int) RTDirRename(const char *pszSrc, const char *pszDst, unsigned fRename) +{ + /* + * Validate input. + */ + AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER); + AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER); + AssertMsgReturn(*pszSrc, ("%p\n", pszSrc), VERR_INVALID_PARAMETER); + AssertMsgReturn(*pszDst, ("%p\n", pszDst), VERR_INVALID_PARAMETER); + AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER); + + /* + * Call the worker. + */ + int rc = rtPathWin32MoveRename(pszSrc, pszDst, + fRename & RTPATHRENAME_FLAGS_REPLACE ? MOVEFILE_REPLACE_EXISTING : 0, + RTFS_TYPE_DIRECTORY); + + LogFlow(("RTDirRename(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n", pszSrc, pszSrc, pszDst, pszDst, fRename, rc)); + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/direnum-win.cpp b/src/VBox/Runtime/r3/win/direnum-win.cpp new file mode 100644 index 00000000..8882f770 --- /dev/null +++ b/src/VBox/Runtime/r3/win/direnum-win.cpp @@ -0,0 +1,393 @@ +/* $Id: direnum-win.cpp $ */ +/** @file + * IPRT - Directory Enumeration, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_DIR +#include <iprt/win/windows.h> + +#include <iprt/dir.h> +#include <iprt/path.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/file.h> +#include <iprt/log.h> +#include "internal/fs.h" +#include "internal/dir.h" + + +size_t rtDirNativeGetStructSize(const char *pszPath) +{ + NOREF(pszPath); + return sizeof(RTDIRINTERNAL); +} + + +int rtDirNativeOpen(PRTDIRINTERNAL pDir, char *pszPathBuf, uintptr_t hRelativeDir, void *pvNativeRelative)) +{ + RT_NOREF(hRelativeDir, pvNativeRelative); + + /* + * Setup the search expression. + * + * pszPathBuf is pointing to the return 4K return buffer for the RTPathReal() + * call in rtDirOpenCommon(), so all we gota do is check that we don't overflow + * it when adding the wildcard expression. + */ + size_t cbExpr; + const char *pszExpr; + if (pDir->enmFilter == RTDIRFILTER_WINNT) + { + pszExpr = pDir->pszFilter; + cbExpr = pDir->cchFilter + 1; + } + else + { + pszExpr = "*"; + cbExpr = sizeof("*"); + } + if (pDir->cchPath + cbExpr > RTPATH_MAX) + return VERR_FILENAME_TOO_LONG; + memcpy(pszPathBuf + pDir->cchPath, pszExpr, cbExpr); + + + /* + * Attempt opening the search. + */ + PRTUTF16 pwszName; + int rc = RTPathWinFromUtf8(pwszPathBuf, &pwszName, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + pDir->hDir = FindFirstFileW((LPCWSTR)pwszName, &pDir->Data); + if (pDir->hDir != INVALID_HANDLE_VALUE) + pDir->fDataUnread = true; + else + { + DWORD dwErr = GetLastError(); + /* Theoretical case of an empty directory or more normal case of no matches. */ + if ( dwErr == ERROR_FILE_NOT_FOUND + || dwErr == ERROR_NO_MORE_FILES /* ???*/) + pDir->fDataUnread = false; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + RTPathWinFree(pwszName); + } + + return rc; +} + + +RTDECL(int) RTDirClose(PRTDIRINTERNAL pDir) +{ + /* + * Validate input. + */ + if (!pDir) + return VERR_INVALID_PARAMETER; + if (pDir->u32Magic != RTDIR_MAGIC) + { + AssertMsgFailed(("Invalid pDir=%p\n", pDir)); + return VERR_INVALID_PARAMETER; + } + + /* + * Close the handle. + */ + pDir->u32Magic++; + if (pDir->hDir != INVALID_HANDLE_VALUE) + { + BOOL fRc = FindClose(pDir->hDir); + Assert(fRc); + pDir->hDir = INVALID_HANDLE_VALUE; + } + RTStrFree(pDir->pszName); + pDir->pszName = NULL; + RTMemFree(pDir); + + return VINF_SUCCESS; +} + + +RTDECL(int) RTDirRead(RTDIR hDir, PRTDIRENTRY pDirEntry, size_t *pcbDirEntry) +{ + PPRTDIRINTERNAL pDir = hDir; + + /* + * Validate input. + */ + if (!pDir || pDir->u32Magic != RTDIR_MAGIC) + { + AssertMsgFailed(("Invalid pDir=%p\n", pDir)); + return VERR_INVALID_PARAMETER; + } + if (!pDirEntry) + { + AssertMsgFailed(("Invalid pDirEntry=%p\n", pDirEntry)); + return VERR_INVALID_PARAMETER; + } + size_t cbDirEntry = sizeof(*pDirEntry); + if (pcbDirEntry) + { + cbDirEntry = *pcbDirEntry; + if (cbDirEntry < RT_UOFFSETOF(RTDIRENTRY, szName[2])) + { + AssertMsgFailed(("Invalid *pcbDirEntry=%zu (min %zu)\n", *pcbDirEntry, RT_UOFFSETOF(RTDIRENTRY, szName[2]))); + return VERR_INVALID_PARAMETER; + } + } + + /* + * Fetch data? + */ + if (!pDir->fDataUnread) + { + RTStrFree(pDir->pszName); + pDir->pszName = NULL; + + BOOL fRc = FindNextFileW(pDir->hDir, &pDir->Data); + if (!fRc) + { + int iErr = GetLastError(); + if (pDir->hDir == INVALID_HANDLE_VALUE || iErr == ERROR_NO_MORE_FILES) + return VERR_NO_MORE_FILES; + return RTErrConvertFromWin32(iErr); + } + } + + /* + * Convert the filename to UTF-8. + */ + if (!pDir->pszName) + { + int rc = RTUtf16ToUtf8((PCRTUTF16)pDir->Data.cFileName, &pDir->pszName); + if (RT_FAILURE(rc)) + { + pDir->pszName = NULL; + return rc; + } + pDir->cchName = strlen(pDir->pszName); + } + + /* + * Check if we've got enough space to return the data. + */ + const char *pszName = pDir->pszName; + const size_t cchName = pDir->cchName; + const size_t cbRequired = RT_UOFFSETOF(RTDIRENTRY, szName[1]) + cchName; + if (pcbDirEntry) + *pcbDirEntry = cbRequired; + if (cbRequired > cbDirEntry) + return VERR_BUFFER_OVERFLOW; + + /* + * Setup the returned data. + */ + pDir->fDataUnread = false; + pDirEntry->INodeId = 0; /** @todo we can use the fileid here if we must (see GetFileInformationByHandle). */ + pDirEntry->enmType = pDir->Data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY + ? RTDIRENTRYTYPE_DIRECTORY : RTDIRENTRYTYPE_FILE; + pDirEntry->cbName = (uint16_t)cchName; + Assert(pDirEntry->cbName == cchName); + memcpy(pDirEntry->szName, pszName, cchName + 1); + + return VINF_SUCCESS; +} + + +RTDECL(int) RTDirReadEx(RTDIR hDir, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags) +{ + PPRTDIRINTERNAL pDir = hDir; + /** @todo Symlinks: Find[First|Next]FileW will return info about + the link, so RTPATH_F_FOLLOW_LINK is not handled correctly. */ + /* + * Validate input. + */ + if (!pDir || pDir->u32Magic != RTDIR_MAGIC) + { + AssertMsgFailed(("Invalid pDir=%p\n", pDir)); + return VERR_INVALID_PARAMETER; + } + if (!pDirEntry) + { + AssertMsgFailed(("Invalid pDirEntry=%p\n", pDirEntry)); + return VERR_INVALID_PARAMETER; + } + if ( enmAdditionalAttribs < RTFSOBJATTRADD_NOTHING + || enmAdditionalAttribs > RTFSOBJATTRADD_LAST) + { + AssertMsgFailed(("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs)); + return VERR_INVALID_PARAMETER; + } + AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER); + size_t cbDirEntry = sizeof(*pDirEntry); + if (pcbDirEntry) + { + cbDirEntry = *pcbDirEntry; + if (cbDirEntry < RT_UOFFSETOF(RTDIRENTRYEX, szName[2])) + { + AssertMsgFailed(("Invalid *pcbDirEntry=%zu (min %zu)\n", *pcbDirEntry, RT_UOFFSETOF(RTDIRENTRYEX, szName[2]))); + return VERR_INVALID_PARAMETER; + } + } + + /* + * Fetch data? + */ + if (!pDir->fDataUnread) + { + RTStrFree(pDir->pszName); + pDir->pszName = NULL; + + BOOL fRc = FindNextFileW(pDir->hDir, &pDir->Data); + if (!fRc) + { + int iErr = GetLastError(); + if (pDir->hDir == INVALID_HANDLE_VALUE || iErr == ERROR_NO_MORE_FILES) + return VERR_NO_MORE_FILES; + return RTErrConvertFromWin32(iErr); + } + } + + /* + * Convert the filename to UTF-8. + */ + if (!pDir->pszName) + { + int rc = RTUtf16ToUtf8((PCRTUTF16)pDir->Data.cFileName, &pDir->pszName); + if (RT_FAILURE(rc)) + { + pDir->pszName = NULL; + return rc; + } + pDir->cchName = strlen(pDir->pszName); + } + + /* + * Check if we've got enough space to return the data. + */ + const char *pszName = pDir->pszName; + const size_t cchName = pDir->cchName; + const size_t cbRequired = RT_UOFFSETOF(RTDIRENTRYEX, szName[1]) + cchName; + if (pcbDirEntry) + *pcbDirEntry = cbRequired; + if (cbRequired > cbDirEntry) + return VERR_BUFFER_OVERFLOW; + + /* + * Setup the returned data. + */ + pDir->fDataUnread = false; + pDirEntry->cbName = (uint16_t)cchName; + Assert(pDirEntry->cbName == cchName); + memcpy(pDirEntry->szName, pszName, cchName + 1); + if (pDir->Data.cAlternateFileName[0]) + { + /* copy and calc length */ + PCRTUTF16 pwszSrc = (PCRTUTF16)pDir->Data.cAlternateFileName; + PRTUTF16 pwszDst = pDirEntry->wszShortName; + uint32_t off = 0; + while (off < RT_ELEMENTS(pDirEntry->wszShortName) - 1U && pwszSrc[off]) + { + pwszDst[off] = pwszSrc[off]; + off++; + } + pDirEntry->cwcShortName = (uint16_t)off; + + /* zero the rest */ + do + pwszDst[off++] = '\0'; + while (off < RT_ELEMENTS(pDirEntry->wszShortName)); + } + else + { + memset(pDirEntry->wszShortName, 0, sizeof(pDirEntry->wszShortName)); + pDirEntry->cwcShortName = 0; + } + + pDirEntry->Info.cbObject = ((uint64_t)pDir->Data.nFileSizeHigh << 32) + | (uint64_t)pDir->Data.nFileSizeLow; + pDirEntry->Info.cbAllocated = pDirEntry->Info.cbObject; + + Assert(sizeof(uint64_t) == sizeof(pDir->Data.ftCreationTime)); + RTTimeSpecSetNtTime(&pDirEntry->Info.BirthTime, *(uint64_t *)&pDir->Data.ftCreationTime); + RTTimeSpecSetNtTime(&pDirEntry->Info.AccessTime, *(uint64_t *)&pDir->Data.ftLastAccessTime); + RTTimeSpecSetNtTime(&pDirEntry->Info.ModificationTime, *(uint64_t *)&pDir->Data.ftLastWriteTime); + pDirEntry->Info.ChangeTime = pDirEntry->Info.ModificationTime; + + pDirEntry->Info.Attr.fMode = rtFsModeFromDos((pDir->Data.dwFileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT, + pszName, cchName, pDir->Data.dwReserved0); + + /* + * Requested attributes (we cannot provide anything actually). + */ + switch (enmAdditionalAttribs) + { + case RTFSOBJATTRADD_EASIZE: + pDirEntry->Info.Attr.enmAdditional = RTFSOBJATTRADD_EASIZE; + pDirEntry->Info.Attr.u.EASize.cb = 0; + break; + + case RTFSOBJATTRADD_UNIX: + pDirEntry->Info.Attr.enmAdditional = RTFSOBJATTRADD_UNIX; + pDirEntry->Info.Attr.u.Unix.uid = ~0U; + pDirEntry->Info.Attr.u.Unix.gid = ~0U; + pDirEntry->Info.Attr.u.Unix.cHardlinks = 1; + pDirEntry->Info.Attr.u.Unix.INodeIdDevice = 0; /** @todo Use the volume serial number (see GetFileInformationByHandle). */ + pDirEntry->Info.Attr.u.Unix.INodeId = 0; /** @todo Use the fileid (see GetFileInformationByHandle). */ + pDirEntry->Info.Attr.u.Unix.fFlags = 0; + pDirEntry->Info.Attr.u.Unix.GenerationId = 0; + pDirEntry->Info.Attr.u.Unix.Device = 0; + break; + + case RTFSOBJATTRADD_NOTHING: + pDirEntry->Info.Attr.enmAdditional = RTFSOBJATTRADD_NOTHING; + break; + + case RTFSOBJATTRADD_UNIX_OWNER: + pDirEntry->Info.Attr.enmAdditional = RTFSOBJATTRADD_UNIX_OWNER; + pDirEntry->Info.Attr.u.UnixOwner.uid = ~0U; + pDirEntry->Info.Attr.u.UnixOwner.szName[0] = '\0'; /** @todo return something sensible here. */ + break; + + case RTFSOBJATTRADD_UNIX_GROUP: + pDirEntry->Info.Attr.enmAdditional = RTFSOBJATTRADD_UNIX_GROUP; + pDirEntry->Info.Attr.u.UnixGroup.gid = ~0U; + pDirEntry->Info.Attr.u.UnixGroup.szName[0] = '\0'; + break; + + default: + AssertMsgFailed(("Impossible!\n")); + return VERR_INTERNAL_ERROR; + } + + return VINF_SUCCESS; +} + diff --git a/src/VBox/Runtime/r3/win/dllmain-win.cpp b/src/VBox/Runtime/r3/win/dllmain-win.cpp new file mode 100644 index 00000000..780881d7 --- /dev/null +++ b/src/VBox/Runtime/r3/win/dllmain-win.cpp @@ -0,0 +1,77 @@ +/* $Id: dllmain-win.cpp $ */ +/** @file + * IPRT - Win32 DllMain (Ring-3). + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/windows.h> +#include <iprt/thread.h> +#include <iprt/param.h> +#include "internal/thread.h" + + + +/** + * The Dll main entry point. + */ +BOOL __stdcall DllMain(HANDLE hModule, DWORD dwReason, PVOID pvReserved) +{ + RT_NOREF_PV(pvReserved); + + switch (dwReason) + { + /* + * When attaching to a process, we'd like to make sure IPRT stays put + * and doesn't get unloaded. + */ + case DLL_PROCESS_ATTACH: + { + WCHAR wszName[RTPATH_MAX]; + SetLastError(NO_ERROR); + if ( GetModuleFileNameW((HMODULE)hModule, wszName, RT_ELEMENTS(wszName)) > 0 + && GetLastError() == NO_ERROR) + { + int cExtraLoads = 32; + while (cExtraLoads-- > 0) + LoadLibraryW(wszName); + } + break; + } + + case DLL_PROCESS_DETACH: + case DLL_THREAD_ATTACH: + default: + /* ignore */ + break; + + case DLL_THREAD_DETACH: + rtThreadNativeDetach(); + break; + } + return TRUE; +} + diff --git a/src/VBox/Runtime/r3/win/env-win.cpp b/src/VBox/Runtime/r3/win/env-win.cpp new file mode 100644 index 00000000..b8ab37e7 --- /dev/null +++ b/src/VBox/Runtime/r3/win/env-win.cpp @@ -0,0 +1,280 @@ +/* $Id: env-win.cpp $ */ +/** @file + * IPRT - Environment, Posix. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/env.h> + +#include <iprt/alloca.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/string.h> +#include <iprt/mem.h> +#include <iprt/utf16.h> + +#include <stdlib.h> +#include <errno.h> + + +RTDECL(bool) RTEnvExistsBad(const char *pszVar) +{ + return RTEnvGetBad(pszVar) != NULL; +} + + +RTDECL(bool) RTEnvExist(const char *pszVar) +{ + return RTEnvExistsBad(pszVar); +} + + +RTDECL(bool) RTEnvExistsUtf8(const char *pszVar) +{ + AssertReturn(strchr(pszVar, '=') == NULL, false); + + PRTUTF16 pwszVar; + int rc = RTStrToUtf16(pszVar, &pwszVar); + AssertRCReturn(rc, false); + bool fRet = _wgetenv(pwszVar) != NULL; + RTUtf16Free(pwszVar); + return fRet; +} + + +RTDECL(const char *) RTEnvGetBad(const char *pszVar) +{ + AssertReturn(strchr(pszVar, '=') == NULL, NULL); + return getenv(pszVar); +} + + +RTDECL(const char *) RTEnvGet(const char *pszVar) +{ + return RTEnvGetBad(pszVar); +} + +RTDECL(int) RTEnvGetUtf8(const char *pszVar, char *pszValue, size_t cbValue, size_t *pcchActual) +{ + AssertPtrReturn(pszVar, VERR_INVALID_POINTER); + AssertPtrNullReturn(pszValue, VERR_INVALID_POINTER); + AssertReturn(pszValue || !cbValue, VERR_INVALID_PARAMETER); + AssertPtrNullReturn(pcchActual, VERR_INVALID_POINTER); + AssertReturn(pcchActual || (pszValue && cbValue), VERR_INVALID_PARAMETER); + AssertReturn(strchr(pszVar, '=') == NULL, VERR_ENV_INVALID_VAR_NAME); + + if (pcchActual) + *pcchActual = 0; + + PRTUTF16 pwszVar; + int rc = RTStrToUtf16(pszVar, &pwszVar); + AssertRCReturn(rc, rc); + + /** @todo Consider _wgetenv_s or GetEnvironmentVariableW here to avoid the + * potential race with a concurrent _wputenv/_putenv. */ + PCRTUTF16 pwszValue = _wgetenv(pwszVar); + RTUtf16Free(pwszVar); + if (pwszValue) + { + if (cbValue) + rc = RTUtf16ToUtf8Ex(pwszValue, RTSTR_MAX, &pszValue, cbValue, pcchActual); + else + rc = RTUtf16CalcUtf8LenEx(pwszValue, RTSTR_MAX, pcchActual); + } + else + rc = VERR_ENV_VAR_NOT_FOUND; + return rc; +} + + +RTDECL(int) RTEnvPutBad(const char *pszVarEqualValue) +{ + /** @todo putenv is a source memory leaks. deal with this on a per system basis. */ + if (!putenv((char *)pszVarEqualValue)) + return 0; + return RTErrConvertFromErrno(errno); +} + + +RTDECL(int) RTEnvPut(const char *pszVarEqualValue) +{ + return RTEnvPutBad(pszVarEqualValue); +} + + +RTDECL(int) RTEnvPutUtf8(const char *pszVarEqualValue) +{ + PRTUTF16 pwszVarEqualValue; + int rc = RTStrToUtf16(pszVarEqualValue, &pwszVarEqualValue); + if (RT_SUCCESS(rc)) + { + if (!_wputenv(pwszVarEqualValue)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromErrno(errno); + RTUtf16Free(pwszVarEqualValue); + } + return rc; +} + + + +RTDECL(int) RTEnvSetBad(const char *pszVar, const char *pszValue) +{ + AssertMsgReturn(strchr(pszVar, '=') == NULL, ("'%s'\n", pszVar), VERR_ENV_INVALID_VAR_NAME); + + /* make a local copy and feed it to putenv. */ + const size_t cchVar = strlen(pszVar); + const size_t cchValue = strlen(pszValue); + char *pszTmp = (char *)alloca(cchVar + cchValue + 2 + !*pszValue); + memcpy(pszTmp, pszVar, cchVar); + pszTmp[cchVar] = '='; + if (*pszValue) + memcpy(pszTmp + cchVar + 1, pszValue, cchValue + 1); + else + { + pszTmp[cchVar + 1] = ' '; /* wrong, but putenv will remove it otherwise. */ + pszTmp[cchVar + 2] = '\0'; + } + + if (!putenv(pszTmp)) + return 0; + return RTErrConvertFromErrno(errno); +} + + +RTDECL(int) RTEnvSet(const char *pszVar, const char *pszValue) +{ + return RTEnvSetBad(pszVar, pszValue); +} + +RTDECL(int) RTEnvSetUtf8(const char *pszVar, const char *pszValue) +{ + AssertReturn(strchr(pszVar, '=') == NULL, VERR_ENV_INVALID_VAR_NAME); + + size_t cwcVar; + int rc = RTStrCalcUtf16LenEx(pszVar, RTSTR_MAX, &cwcVar); + if (RT_SUCCESS(rc)) + { + size_t cwcValue; + rc = RTStrCalcUtf16LenEx(pszVar, RTSTR_MAX, &cwcValue); + if (RT_SUCCESS(rc)) + { + PRTUTF16 pwszTmp = (PRTUTF16)RTMemTmpAlloc((cwcVar + 1 + cwcValue + 1) * sizeof(RTUTF16)); + if (pwszTmp) + { + rc = RTStrToUtf16Ex(pszVar, RTSTR_MAX, &pwszTmp, cwcVar + 1, NULL); + if (RT_SUCCESS(rc)) + { + PRTUTF16 pwszTmpValue = &pwszTmp[cwcVar]; + *pwszTmpValue++ = '='; + rc = RTStrToUtf16Ex(pszValue, RTSTR_MAX, &pwszTmpValue, cwcValue + 1, NULL); + if (RT_SUCCESS(rc)) + { + if (!_wputenv(pwszTmp)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromErrno(errno); + } + } + RTMemTmpFree(pwszTmp); + } + else + rc = VERR_NO_TMP_MEMORY; + } + } + return rc; +} + + +RTDECL(int) RTEnvUnsetBad(const char *pszVar) +{ + AssertReturn(strchr(pszVar, '=') == NULL, VERR_ENV_INVALID_VAR_NAME); + + /* + * Check that it exists first. + */ + if (!RTEnvExist(pszVar)) + return VINF_ENV_VAR_NOT_FOUND; + + /* + * Ok, try remove it. + */ +#ifdef RT_OS_WINDOWS + /* Use putenv(var=) since Windows does not have unsetenv(). */ + size_t cchVar = strlen(pszVar); + char *pszBuf = (char *)alloca(cchVar + 2); + memcpy(pszBuf, pszVar, cchVar); + pszBuf[cchVar] = '='; + pszBuf[cchVar + 1] = '\0'; + + if (!putenv(pszBuf)) + return VINF_SUCCESS; + +#else + /* This is the preferred function as putenv() like used above does neither work on Solaris nor on Darwin. */ + if (!unsetenv((char*)pszVar)) + return VINF_SUCCESS; +#endif + + return RTErrConvertFromErrno(errno); +} + + +RTDECL(int) RTEnvUnset(const char *pszVar) +{ + return RTEnvUnsetBad(pszVar); +} + + +RTDECL(int) RTEnvUnsetUtf8(const char *pszVar) +{ + AssertReturn(strchr(pszVar, '=') == NULL, VERR_ENV_INVALID_VAR_NAME); + + size_t cwcVar; + int rc = RTStrCalcUtf16LenEx(pszVar, RTSTR_MAX, &cwcVar); + if (RT_SUCCESS(rc)) + { + PRTUTF16 pwszTmp = (PRTUTF16)RTMemTmpAlloc((cwcVar + 1 + 1) * sizeof(RTUTF16)); + if (pwszTmp) + { + rc = RTStrToUtf16Ex(pszVar, RTSTR_MAX, &pwszTmp, cwcVar + 1, NULL); + if (RT_SUCCESS(rc)) + { + pwszTmp[cwcVar] = '='; + pwszTmp[cwcVar + 1] = '\0'; + if (!_wputenv(pwszTmp)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromErrno(errno); + } + RTMemTmpFree(pwszTmp); + } + } + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/errvars-win.cpp b/src/VBox/Runtime/r3/win/errvars-win.cpp new file mode 100644 index 00000000..df07c2bd --- /dev/null +++ b/src/VBox/Runtime/r3/win/errvars-win.cpp @@ -0,0 +1,85 @@ +/* $Id: errvars-win.cpp $ */ +/** @file + * IPRT - Save and Restore Error Variables, Windows Ring-3. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/winsock2.h> +#include <errno.h> + +#include <iprt/errcore.h> +#include "internal/iprt.h" + +#include <iprt/assert.h> +#include "internal/magics.h" +#include "internal-r3-win.h" + + + +RTDECL(PRTERRVARS) RTErrVarsSave(PRTERRVARS pVars) +{ + pVars->ai32Vars[0] = RTERRVARS_MAGIC; + pVars->ai32Vars[1] = GetLastError(); + pVars->ai32Vars[2] = g_pfnWSAGetLastError ? g_pfnWSAGetLastError() : WSANOTINITIALISED; + pVars->ai32Vars[3] = errno; + return pVars; +} + + +RTDECL(void) RTErrVarsRestore(PCRTERRVARS pVars) +{ + AssertReturnVoid(pVars->ai32Vars[0] == RTERRVARS_MAGIC); + errno = pVars->ai32Vars[3]; + if ( pVars->ai32Vars[2] != WSANOTINITIALISED + && g_pfnWSASetLastError) + g_pfnWSASetLastError(pVars->ai32Vars[2]); + SetLastError(pVars->ai32Vars[1]); +} + + +RTDECL(bool) RTErrVarsAreEqual(PCRTERRVARS pVars1, PCRTERRVARS pVars2) +{ + Assert(pVars1->ai32Vars[0] == RTERRVARS_MAGIC); + Assert(pVars2->ai32Vars[0] == RTERRVARS_MAGIC); + + return pVars1->ai32Vars[0] == pVars2->ai32Vars[0] + && pVars1->ai32Vars[1] == pVars2->ai32Vars[1] + && pVars1->ai32Vars[2] == pVars2->ai32Vars[2] + && pVars1->ai32Vars[3] == pVars2->ai32Vars[3]; +} + + +RTDECL(bool) RTErrVarsHaveChanged(PCRTERRVARS pVars) +{ + Assert(pVars->ai32Vars[0] == RTERRVARS_MAGIC); + + return pVars->ai32Vars[0] != RTERRVARS_MAGIC + || (uint32_t)pVars->ai32Vars[1] != GetLastError() + || pVars->ai32Vars[2] != (g_pfnWSAGetLastError ? g_pfnWSAGetLastError() : WSANOTINITIALISED) + || pVars->ai32Vars[3] != errno; +} + diff --git a/src/VBox/Runtime/r3/win/fileaio-win.cpp b/src/VBox/Runtime/r3/win/fileaio-win.cpp new file mode 100644 index 00000000..0f59c1eb --- /dev/null +++ b/src/VBox/Runtime/r3/win/fileaio-win.cpp @@ -0,0 +1,534 @@ +/* $Id: fileaio-win.cpp $ */ +/** @file + * IPRT - File async I/O, native implementation for the Windows host platform. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_DIR + +#include <iprt/asm.h> +#include <iprt/file.h> +#include <iprt/mem.h> +#include <iprt/assert.h> +#include <iprt/string.h> +#include <iprt/err.h> +#include <iprt/log.h> +#include "internal/fileaio.h" + +#include <iprt/win/windows.h> + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ + +/** + * Transfer direction. + */ +typedef enum TRANSFERDIRECTION +{ + TRANSFERDIRECTION_INVALID = 0, + /** Read. */ + TRANSFERDIRECTION_READ, + /** Write. */ + TRANSFERDIRECTION_WRITE, + /** The usual 32-bit hack. */ + TRANSFERDIRECTION_32BIT_HACK = 0x7fffffff +} TRANSFERDIRECTION; + +/** + * Async I/O completion context state. + */ +typedef struct RTFILEAIOCTXINTERNAL +{ + /** handle to I/O completion port. */ + HANDLE hIoCompletionPort; + /** Current number of requests pending. */ + volatile int32_t cRequests; + /** Flag whether the thread was woken up. */ + volatile bool fWokenUp; + /** Flag whether the thread is currently waiting. */ + volatile bool fWaiting; + /** Flags given during creation. */ + uint32_t fFlags; + /** Magic value (RTFILEAIOCTX_MAGIC). */ + uint32_t u32Magic; +} RTFILEAIOCTXINTERNAL; +/** Pointer to an internal context structure. */ +typedef RTFILEAIOCTXINTERNAL *PRTFILEAIOCTXINTERNAL; + +/** + * Async I/O request state. + */ +typedef struct RTFILEAIOREQINTERNAL +{ + /** Overlapped structure. */ + OVERLAPPED Overlapped; + /** Current state the request is in. */ + RTFILEAIOREQSTATE enmState; + /** The file handle. */ + HANDLE hFile; + /** Kind of transfer Read/Write. */ + TRANSFERDIRECTION enmTransferDirection; + /** Number of bytes to transfer. */ + size_t cbTransfer; + /** Pointer to the buffer. */ + void *pvBuf; + /** Opaque user data. */ + void *pvUser; + /** Flag whether the request completed. */ + bool fCompleted; + /** Number of bytes transferred successfully. */ + size_t cbTransfered; + /** Error code of the completed request. */ + int Rc; + /** Completion context we are assigned to. */ + PRTFILEAIOCTXINTERNAL pCtxInt; + /** Magic value (RTFILEAIOREQ_MAGIC). */ + uint32_t u32Magic; +} RTFILEAIOREQINTERNAL; +/** Pointer to an internal request structure. */ +typedef RTFILEAIOREQINTERNAL *PRTFILEAIOREQINTERNAL; + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Id for the wakeup event. */ +#define AIO_CONTEXT_WAKEUP_EVENT 1 +/** Converts a pointer to an OVERLAPPED structure to a internal request. */ +#define OVERLAPPED_2_RTFILEAIOREQINTERNAL(pOverlapped) ( (PRTFILEAIOREQINTERNAL)((uintptr_t)(pOverlapped) - RT_UOFFSETOF(RTFILEAIOREQINTERNAL, Overlapped)) ) + +RTR3DECL(int) RTFileAioGetLimits(PRTFILEAIOLIMITS pAioLimits) +{ + AssertPtrReturn(pAioLimits, VERR_INVALID_POINTER); + + /* No limits known. */ + pAioLimits->cReqsOutstandingMax = RTFILEAIO_UNLIMITED_REQS; + pAioLimits->cbBufferAlignment = 0; + + return VINF_SUCCESS; +} + +RTR3DECL(int) RTFileAioReqCreate(PRTFILEAIOREQ phReq) +{ + AssertPtrReturn(phReq, VERR_INVALID_POINTER); + + PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOREQINTERNAL)); + if (RT_UNLIKELY(!pReqInt)) + return VERR_NO_MEMORY; + + pReqInt->pCtxInt = NULL; + pReqInt->fCompleted = false; + pReqInt->u32Magic = RTFILEAIOREQ_MAGIC; + RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED); + + *phReq = (RTFILEAIOREQ)pReqInt; + + return VINF_SUCCESS; +} + +RTDECL(int) RTFileAioReqDestroy(RTFILEAIOREQ hReq) +{ + /* + * Validate the handle and ignore nil. + */ + if (hReq == NIL_RTFILEAIOREQ) + return VINF_SUCCESS; + PRTFILEAIOREQINTERNAL pReqInt = hReq; + RTFILEAIOREQ_VALID_RETURN(pReqInt); + RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS); + + /* + * Trash the magic and free it. + */ + ASMAtomicUoWriteU32(&pReqInt->u32Magic, ~RTFILEAIOREQ_MAGIC); + RTMemFree(pReqInt); + return VINF_SUCCESS; +} + +/** + * Worker setting up the request. + */ +DECLINLINE(int) rtFileAioReqPrepareTransfer(RTFILEAIOREQ hReq, RTFILE hFile, + TRANSFERDIRECTION enmTransferDirection, + RTFOFF off, void *pvBuf, size_t cbTransfer, + void *pvUser) +{ + /* + * Validate the input. + */ + PRTFILEAIOREQINTERNAL pReqInt = hReq; + RTFILEAIOREQ_VALID_RETURN(pReqInt); + RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS); + Assert(hFile != NIL_RTFILE); + AssertPtr(pvBuf); + Assert(off >= 0); + Assert(cbTransfer > 0); + + pReqInt->enmTransferDirection = enmTransferDirection; + pReqInt->hFile = (HANDLE)RTFileToNative(hFile); + pReqInt->Overlapped.Offset = (DWORD)(off & 0xffffffff); + pReqInt->Overlapped.OffsetHigh = (DWORD)(off >> 32); + pReqInt->cbTransfer = cbTransfer; + pReqInt->pvBuf = pvBuf; + pReqInt->pvUser = pvUser; + pReqInt->fCompleted = false; + + return VINF_SUCCESS; +} + +RTDECL(int) RTFileAioReqPrepareRead(RTFILEAIOREQ hReq, RTFILE hFile, RTFOFF off, + void *pvBuf, size_t cbRead, void *pvUser) +{ + return rtFileAioReqPrepareTransfer(hReq, hFile, TRANSFERDIRECTION_READ, + off, pvBuf, cbRead, pvUser); +} + +RTDECL(int) RTFileAioReqPrepareWrite(RTFILEAIOREQ hReq, RTFILE hFile, RTFOFF off, + void const *pvBuf, size_t cbWrite, void *pvUser) +{ + return rtFileAioReqPrepareTransfer(hReq, hFile, TRANSFERDIRECTION_WRITE, + off, (void *)pvBuf, cbWrite, pvUser); +} + +RTDECL(int) RTFileAioReqPrepareFlush(RTFILEAIOREQ hReq, RTFILE hFile, void *pvUser) +{ + PRTFILEAIOREQINTERNAL pReqInt = hReq; + RTFILEAIOREQ_VALID_RETURN(pReqInt); + RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS); + AssertReturn(hFile != NIL_RTFILE, VERR_INVALID_HANDLE); + RT_NOREF_PV(pvUser); + + return VERR_NOT_SUPPORTED; +} + +RTDECL(void *) RTFileAioReqGetUser(RTFILEAIOREQ hReq) +{ + PRTFILEAIOREQINTERNAL pReqInt = hReq; + RTFILEAIOREQ_VALID_RETURN_RC(pReqInt, NULL); + + return pReqInt->pvUser; +} + +RTDECL(int) RTFileAioReqCancel(RTFILEAIOREQ hReq) +{ + PRTFILEAIOREQINTERNAL pReqInt = hReq; + RTFILEAIOREQ_VALID_RETURN(pReqInt); + RTFILEAIOREQ_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_NOT_SUBMITTED); + + /** + * @todo r=aeichner It is not possible to cancel specific + * requests on Windows before Vista. + * CancelIo cancels all requests for a file issued by the + * calling thread and CancelIoEx which does what we need + * is only available from Vista and up. + * The solution is to return VERR_FILE_AIO_IN_PROGRESS + * if the request didn't completed yet (checked above). + * Shouldn't be a big issue because a request is normally + * only canceled if it exceeds a timeout which is quite huge. + */ + return VERR_FILE_AIO_COMPLETED; +} + +RTDECL(int) RTFileAioReqGetRC(RTFILEAIOREQ hReq, size_t *pcbTransfered) +{ + int rc = VINF_SUCCESS; + PRTFILEAIOREQINTERNAL pReqInt = hReq; + RTFILEAIOREQ_VALID_RETURN(pReqInt); + RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS); + RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, PREPARED, VERR_FILE_AIO_NOT_SUBMITTED); + + rc = pReqInt->Rc; + if (pcbTransfered && RT_SUCCESS(rc)) + *pcbTransfered = pReqInt->cbTransfered; + + return rc; +} + +RTDECL(int) RTFileAioCtxCreate(PRTFILEAIOCTX phAioCtx, uint32_t cAioReqsMax, uint32_t fFlags) +{ + PRTFILEAIOCTXINTERNAL pCtxInt; + AssertPtrReturn(phAioCtx, VERR_INVALID_POINTER); + AssertReturn(!(fFlags & ~RTFILEAIOCTX_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER); + RT_NOREF_PV(cAioReqsMax); + + pCtxInt = (PRTFILEAIOCTXINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOCTXINTERNAL)); + if (RT_UNLIKELY(!pCtxInt)) + return VERR_NO_MEMORY; + + pCtxInt->hIoCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, + NULL, + 0, + 0); + if (RT_UNLIKELY(!pCtxInt->hIoCompletionPort)) + { + RTMemFree(pCtxInt); + return VERR_NO_MEMORY; + } + + pCtxInt->fFlags = fFlags; + pCtxInt->u32Magic = RTFILEAIOCTX_MAGIC; + + *phAioCtx = (RTFILEAIOCTX)pCtxInt; + + return VINF_SUCCESS; +} + +RTDECL(int) RTFileAioCtxDestroy(RTFILEAIOCTX hAioCtx) +{ + /* Validate the handle and ignore nil. */ + if (hAioCtx == NIL_RTFILEAIOCTX) + return VINF_SUCCESS; + PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx; + RTFILEAIOCTX_VALID_RETURN(pCtxInt); + + /* Cannot destroy a busy context. */ + if (RT_UNLIKELY(pCtxInt->cRequests)) + return VERR_FILE_AIO_BUSY; + + CloseHandle(pCtxInt->hIoCompletionPort); + ASMAtomicUoWriteU32(&pCtxInt->u32Magic, RTFILEAIOCTX_MAGIC_DEAD); + RTMemFree(pCtxInt); + + return VINF_SUCCESS; +} + +RTDECL(int) RTFileAioCtxAssociateWithFile(RTFILEAIOCTX hAioCtx, RTFILE hFile) +{ + int rc = VINF_SUCCESS; + PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx; + RTFILEAIOCTX_VALID_RETURN(pCtxInt); + + HANDLE hTemp = CreateIoCompletionPort((HANDLE)RTFileToNative(hFile), pCtxInt->hIoCompletionPort, 0, 1); + if (hTemp != pCtxInt->hIoCompletionPort) + rc = RTErrConvertFromWin32(GetLastError()); + + return rc; +} + +RTDECL(uint32_t) RTFileAioCtxGetMaxReqCount(RTFILEAIOCTX hAioCtx) +{ + RT_NOREF_PV(hAioCtx); + return RTFILEAIO_UNLIMITED_REQS; +} + +RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs) +{ + /* + * Parameter validation. + */ + int rc = VINF_SUCCESS; + PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx; + RTFILEAIOCTX_VALID_RETURN(pCtxInt); + AssertReturn(cReqs > 0, VERR_INVALID_PARAMETER); + Assert(cReqs <= INT32_MAX); + AssertPtrReturn(pahReqs, VERR_INVALID_POINTER); + size_t i; + + for (i = 0; i < cReqs; i++) + { + PRTFILEAIOREQINTERNAL pReqInt = pahReqs[i]; + BOOL fSucceeded; + + Assert(pReqInt->cbTransfer == (DWORD)pReqInt->cbTransfer); + if (pReqInt->enmTransferDirection == TRANSFERDIRECTION_READ) + { + fSucceeded = ReadFile(pReqInt->hFile, pReqInt->pvBuf, + (DWORD)pReqInt->cbTransfer, NULL, + &pReqInt->Overlapped); + } + else if (pReqInt->enmTransferDirection == TRANSFERDIRECTION_WRITE) + { + fSucceeded = WriteFile(pReqInt->hFile, pReqInt->pvBuf, + (DWORD)pReqInt->cbTransfer, NULL, + &pReqInt->Overlapped); + } + else + { + fSucceeded = false; + AssertMsgFailed(("Invalid transfer direction\n")); + } + + if (RT_UNLIKELY(!fSucceeded && GetLastError() != ERROR_IO_PENDING)) + { + RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED); + rc = RTErrConvertFromWin32(GetLastError()); + pReqInt->Rc = rc; + break; + } + RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED); + } + + ASMAtomicAddS32(&pCtxInt->cRequests, (int32_t)i); + + return rc; +} + +RTDECL(int) RTFileAioCtxWait(RTFILEAIOCTX hAioCtx, size_t cMinReqs, RTMSINTERVAL cMillies, + PRTFILEAIOREQ pahReqs, size_t cReqs, uint32_t *pcReqs) +{ + /* + * Validate the parameters, making sure to always set pcReqs. + */ + AssertPtrReturn(pcReqs, VERR_INVALID_POINTER); + *pcReqs = 0; /* always set */ + PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx; + RTFILEAIOCTX_VALID_RETURN(pCtxInt); + AssertPtrReturn(pahReqs, VERR_INVALID_POINTER); + AssertReturn(cReqs != 0, VERR_INVALID_PARAMETER); + AssertReturn(cReqs >= cMinReqs, VERR_OUT_OF_RANGE); + + /* + * Can't wait if there are no requests around. + */ + if ( RT_UNLIKELY(ASMAtomicUoReadS32(&pCtxInt->cRequests) == 0) + && !(pCtxInt->fFlags & RTFILEAIOCTX_FLAGS_WAIT_WITHOUT_PENDING_REQUESTS)) + return VERR_FILE_AIO_NO_REQUEST; + + /* Wait for at least one. */ + if (!cMinReqs) + cMinReqs = 1; + + /* + * Loop until we're woken up, hit an error (incl timeout), or + * have collected the desired number of requests. + */ + int rc = VINF_SUCCESS; + int cRequestsCompleted = 0; + while ( !pCtxInt->fWokenUp + && cMinReqs > 0) + { + uint64_t StartNanoTS = 0; + DWORD dwTimeout = cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies; + DWORD cbTransfered; + LPOVERLAPPED pOverlapped; + ULONG_PTR lCompletionKey; + BOOL fSucceeded; + + if (cMillies != RT_INDEFINITE_WAIT) + StartNanoTS = RTTimeNanoTS(); + + ASMAtomicXchgBool(&pCtxInt->fWaiting, true); + fSucceeded = GetQueuedCompletionStatus(pCtxInt->hIoCompletionPort, + &cbTransfered, + &lCompletionKey, + &pOverlapped, + dwTimeout); + ASMAtomicXchgBool(&pCtxInt->fWaiting, false); + if ( !fSucceeded + && !pOverlapped) + { + /* The call failed to dequeue a completion packet, includes VERR_TIMEOUT */ + rc = RTErrConvertFromWin32(GetLastError()); + break; + } + + /* Check if we got woken up. */ + if (lCompletionKey == AIO_CONTEXT_WAKEUP_EVENT) + { + Assert(fSucceeded && !pOverlapped); + break; + } + + /* A request completed. */ + PRTFILEAIOREQINTERNAL pReqInt = OVERLAPPED_2_RTFILEAIOREQINTERNAL(pOverlapped); + AssertPtr(pReqInt); + Assert(pReqInt->u32Magic == RTFILEAIOREQ_MAGIC); + + /* Mark the request as finished. */ + RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED); + + pReqInt->cbTransfered = cbTransfered; + if (fSucceeded) + pReqInt->Rc = VINF_SUCCESS; + else + { + DWORD errCode = GetLastError(); + pReqInt->Rc = RTErrConvertFromWin32(errCode); + if (pReqInt->Rc == VERR_UNRESOLVED_ERROR) + LogRel(("AIO/win: Request %#p returned rc=%Rrc (native %u\n)", pReqInt, pReqInt->Rc, errCode)); + } + + pahReqs[cRequestsCompleted++] = (RTFILEAIOREQ)pReqInt; + + /* Update counter. */ + cMinReqs--; + + if (cMillies != RT_INDEFINITE_WAIT) + { + /* Recalculate timeout. */ + uint64_t NanoTS = RTTimeNanoTS(); + uint64_t cMilliesElapsed = (NanoTS - StartNanoTS) / 1000000; + if (cMilliesElapsed < cMillies) + cMillies -= cMilliesElapsed; + else + cMillies = 0; + } + } + + /* + * Update the context state and set the return value. + */ + *pcReqs = cRequestsCompleted; + ASMAtomicSubS32(&pCtxInt->cRequests, cRequestsCompleted); + + /* + * Clear the wakeup flag and set rc. + */ + bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUp, false); + + if ( fWokenUp + && RT_SUCCESS(rc)) + rc = VERR_INTERRUPTED; + + return rc; +} + +RTDECL(int) RTFileAioCtxWakeup(RTFILEAIOCTX hAioCtx) +{ + int rc = VINF_SUCCESS; + PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx; + RTFILEAIOCTX_VALID_RETURN(pCtxInt); + + bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUp, true); + bool fWaiting = ASMAtomicReadBool(&pCtxInt->fWaiting); + + if ( !fWokenUp + && fWaiting) + { + BOOL fSucceeded = PostQueuedCompletionStatus(pCtxInt->hIoCompletionPort, + 0, AIO_CONTEXT_WAKEUP_EVENT, + NULL); + + if (!fSucceeded) + rc = RTErrConvertFromWin32(GetLastError()); + } + + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/fileio-win.cpp b/src/VBox/Runtime/r3/win/fileio-win.cpp new file mode 100644 index 00000000..e3f6d922 --- /dev/null +++ b/src/VBox/Runtime/r3/win/fileio-win.cpp @@ -0,0 +1,1124 @@ +/* $Id: fileio-win.cpp $ */ +/** @file + * IPRT - File I/O, native implementation for the Windows host platform. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_DIR +#ifndef _WIN32_WINNT +# define _WIN32_WINNT 0x0500 +#endif +#include <iprt/nt/nt-and-windows.h> + +#include <iprt/file.h> + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/path.h> +#include <iprt/string.h> +#include <iprt/err.h> +#include <iprt/ldr.h> +#include <iprt/log.h> +#include "internal/file.h" +#include "internal/fs.h" +#include "internal/path.h" +#include "internal-r3-win.h" /* For g_enmWinVer + kRTWinOSType_XXX */ + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +typedef BOOL WINAPI FNVERIFYCONSOLEIOHANDLE(HANDLE); +typedef FNVERIFYCONSOLEIOHANDLE *PFNVERIFYCONSOLEIOHANDLE; /* No, nobody fell on the keyboard, really! */ + +/** + * This is wrapper around the ugly SetFilePointer api. + * + * It's equivalent to SetFilePointerEx which we so unfortunately cannot use because of + * it not being present in NT4 GA. + * + * @returns Success indicator. Extended error information obtainable using GetLastError(). + * @param hFile Filehandle. + * @param offSeek Offset to seek. + * @param poffNew Where to store the new file offset. NULL allowed. + * @param uMethod Seek method. (The windows one!) + */ +DECLINLINE(bool) MySetFilePointer(RTFILE hFile, uint64_t offSeek, uint64_t *poffNew, unsigned uMethod) +{ + bool fRc; + LARGE_INTEGER off; + + off.QuadPart = offSeek; +#if 1 + if (off.LowPart != INVALID_SET_FILE_POINTER) + { + off.LowPart = SetFilePointer((HANDLE)RTFileToNative(hFile), off.LowPart, &off.HighPart, uMethod); + fRc = off.LowPart != INVALID_SET_FILE_POINTER; + } + else + { + SetLastError(NO_ERROR); + off.LowPart = SetFilePointer((HANDLE)RTFileToNative(hFile), off.LowPart, &off.HighPart, uMethod); + fRc = GetLastError() == NO_ERROR; + } +#else + fRc = SetFilePointerEx((HANDLE)RTFileToNative(hFile), off, &off, uMethod); +#endif + if (fRc && poffNew) + *poffNew = off.QuadPart; + return fRc; +} + + +/** + * This is a helper to check if an attempt was made to grow a file beyond the + * limit of the filesystem. + * + * @returns true for file size limit exceeded. + * @param hFile Filehandle. + * @param offSeek Offset to seek. + * @param uMethod The seek method. + */ +DECLINLINE(bool) IsBeyondLimit(RTFILE hFile, uint64_t offSeek, unsigned uMethod) +{ + bool fIsBeyondLimit = false; + + /* + * Get the current file position and try set the new one. + * If it fails with a seek error it's because we hit the file system limit. + */ +/** @todo r=bird: I'd be very interested to know on which versions of windows and on which file systems + * this supposedly works. The fastfat sources in the latest WDK makes no limit checks during + * file seeking, only at the time of writing (and some other odd ones we cannot make use of). */ + uint64_t offCurrent; + if (MySetFilePointer(hFile, 0, &offCurrent, FILE_CURRENT)) + { + if (!MySetFilePointer(hFile, offSeek, NULL, uMethod)) + fIsBeyondLimit = GetLastError() == ERROR_SEEK; + else /* Restore file pointer on success. */ + MySetFilePointer(hFile, offCurrent, NULL, FILE_BEGIN); + } + + return fIsBeyondLimit; +} + + +RTR3DECL(int) RTFileFromNative(PRTFILE pFile, RTHCINTPTR uNative) +{ + HANDLE h = (HANDLE)uNative; + AssertCompile(sizeof(h) == sizeof(uNative)); + if (h == INVALID_HANDLE_VALUE) + { + AssertMsgFailed(("%p\n", uNative)); + *pFile = NIL_RTFILE; + return VERR_INVALID_HANDLE; + } + *pFile = (RTFILE)h; + return VINF_SUCCESS; +} + + +RTR3DECL(RTHCINTPTR) RTFileToNative(RTFILE hFile) +{ + AssertReturn(hFile != NIL_RTFILE, (RTHCINTPTR)INVALID_HANDLE_VALUE); + return (RTHCINTPTR)hFile; +} + + +RTR3DECL(int) RTFileOpen(PRTFILE pFile, const char *pszFilename, uint64_t fOpen) +{ + /* + * Validate input. + */ + if (!pFile) + { + AssertMsgFailed(("Invalid pFile\n")); + return VERR_INVALID_PARAMETER; + } + *pFile = NIL_RTFILE; + if (!pszFilename) + { + AssertMsgFailed(("Invalid pszFilename\n")); + return VERR_INVALID_PARAMETER; + } + + /* + * Merge forced open flags and validate them. + */ + int rc = rtFileRecalcAndValidateFlags(&fOpen); + if (RT_FAILURE(rc)) + return rc; + + /* + * Determine disposition, access, share mode, creation flags, and security attributes + * for the CreateFile API call. + */ + DWORD dwCreationDisposition; + switch (fOpen & RTFILE_O_ACTION_MASK) + { + case RTFILE_O_OPEN: + dwCreationDisposition = fOpen & RTFILE_O_TRUNCATE ? TRUNCATE_EXISTING : OPEN_EXISTING; + break; + case RTFILE_O_OPEN_CREATE: + dwCreationDisposition = OPEN_ALWAYS; + break; + case RTFILE_O_CREATE: + dwCreationDisposition = CREATE_NEW; + break; + case RTFILE_O_CREATE_REPLACE: + dwCreationDisposition = CREATE_ALWAYS; + break; + default: + AssertMsgFailed(("Impossible fOpen=%#llx\n", fOpen)); + return VERR_INVALID_PARAMETER; + } + + DWORD dwDesiredAccess; + switch (fOpen & RTFILE_O_ACCESS_MASK) + { + case RTFILE_O_READ: + dwDesiredAccess = FILE_GENERIC_READ; /* RTFILE_O_APPEND is ignored. */ + break; + case RTFILE_O_WRITE: + dwDesiredAccess = fOpen & RTFILE_O_APPEND + ? FILE_GENERIC_WRITE & ~FILE_WRITE_DATA + : FILE_GENERIC_WRITE; + break; + case RTFILE_O_READWRITE: + dwDesiredAccess = fOpen & RTFILE_O_APPEND + ? FILE_GENERIC_READ | (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA) + : FILE_GENERIC_READ | FILE_GENERIC_WRITE; + break; + case RTFILE_O_ATTR_ONLY: + if (fOpen & RTFILE_O_ACCESS_ATTR_MASK) + { + dwDesiredAccess = 0; + break; + } + RT_FALL_THRU(); + default: + AssertMsgFailed(("Impossible fOpen=%#llx\n", fOpen)); + return VERR_INVALID_PARAMETER; + } + if (dwCreationDisposition == TRUNCATE_EXISTING) + /* Required for truncating the file (see MSDN), it is *NOT* part of FILE_GENERIC_WRITE. */ + dwDesiredAccess |= GENERIC_WRITE; + + /* RTFileSetMode needs following rights as well. */ + switch (fOpen & RTFILE_O_ACCESS_ATTR_MASK) + { + case RTFILE_O_ACCESS_ATTR_READ: dwDesiredAccess |= FILE_READ_ATTRIBUTES | SYNCHRONIZE; break; + case RTFILE_O_ACCESS_ATTR_WRITE: dwDesiredAccess |= FILE_WRITE_ATTRIBUTES | SYNCHRONIZE; break; + case RTFILE_O_ACCESS_ATTR_READWRITE: dwDesiredAccess |= FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | SYNCHRONIZE; break; + default: + /* Attributes access is the same as the file access. */ + switch (fOpen & RTFILE_O_ACCESS_MASK) + { + case RTFILE_O_READ: dwDesiredAccess |= FILE_READ_ATTRIBUTES | SYNCHRONIZE; break; + case RTFILE_O_WRITE: dwDesiredAccess |= FILE_WRITE_ATTRIBUTES | SYNCHRONIZE; break; + case RTFILE_O_READWRITE: dwDesiredAccess |= FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | SYNCHRONIZE; break; + default: + AssertMsgFailed(("Impossible fOpen=%#llx\n", fOpen)); + return VERR_INVALID_PARAMETER; + } + } + + DWORD dwShareMode; + switch (fOpen & RTFILE_O_DENY_MASK) + { + case RTFILE_O_DENY_NONE: dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; break; + case RTFILE_O_DENY_READ: dwShareMode = FILE_SHARE_WRITE; break; + case RTFILE_O_DENY_WRITE: dwShareMode = FILE_SHARE_READ; break; + case RTFILE_O_DENY_READWRITE: dwShareMode = 0; break; + + case RTFILE_O_DENY_NOT_DELETE: dwShareMode = FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE; break; + case RTFILE_O_DENY_NOT_DELETE | RTFILE_O_DENY_READ: dwShareMode = FILE_SHARE_DELETE | FILE_SHARE_WRITE; break; + case RTFILE_O_DENY_NOT_DELETE | RTFILE_O_DENY_WRITE: dwShareMode = FILE_SHARE_DELETE | FILE_SHARE_READ; break; + case RTFILE_O_DENY_NOT_DELETE | RTFILE_O_DENY_READWRITE:dwShareMode = FILE_SHARE_DELETE; break; + default: + AssertMsgFailed(("Impossible fOpen=%#llx\n", fOpen)); + return VERR_INVALID_PARAMETER; + } + + SECURITY_ATTRIBUTES SecurityAttributes; + PSECURITY_ATTRIBUTES pSecurityAttributes = NULL; + if (fOpen & RTFILE_O_INHERIT) + { + SecurityAttributes.nLength = sizeof(SecurityAttributes); + SecurityAttributes.lpSecurityDescriptor = NULL; + SecurityAttributes.bInheritHandle = TRUE; + pSecurityAttributes = &SecurityAttributes; + } + + DWORD dwFlagsAndAttributes; + dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL; + if (fOpen & RTFILE_O_WRITE_THROUGH) + dwFlagsAndAttributes |= FILE_FLAG_WRITE_THROUGH; + if (fOpen & RTFILE_O_ASYNC_IO) + dwFlagsAndAttributes |= FILE_FLAG_OVERLAPPED; + if (fOpen & RTFILE_O_NO_CACHE) + { + dwFlagsAndAttributes |= FILE_FLAG_NO_BUFFERING; + dwDesiredAccess &= ~FILE_APPEND_DATA; + } + + /* + * Open/Create the file. + */ + PRTUTF16 pwszFilename; + rc = RTPathWinFromUtf8(&pwszFilename, pszFilename, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + HANDLE hFile = CreateFileW(pwszFilename, + dwDesiredAccess, + dwShareMode, + pSecurityAttributes, + dwCreationDisposition, + dwFlagsAndAttributes, + NULL); + if (hFile != INVALID_HANDLE_VALUE) + { + bool fCreated = dwCreationDisposition == CREATE_ALWAYS + || dwCreationDisposition == CREATE_NEW + || (dwCreationDisposition == OPEN_ALWAYS && GetLastError() == 0); + + /* + * Turn off indexing of directory through Windows Indexing Service. + */ + if ( fCreated + && (fOpen & RTFILE_O_NOT_CONTENT_INDEXED)) + { + if (!SetFileAttributesW(pwszFilename, FILE_ATTRIBUTE_NOT_CONTENT_INDEXED)) + rc = RTErrConvertFromWin32(GetLastError()); + } + /* + * Do we need to truncate the file? + */ + else if ( !fCreated + && (fOpen & (RTFILE_O_TRUNCATE | RTFILE_O_ACTION_MASK)) + == (RTFILE_O_TRUNCATE | RTFILE_O_OPEN_CREATE)) + { + if (!SetEndOfFile(hFile)) + rc = RTErrConvertFromWin32(GetLastError()); + } + if (RT_SUCCESS(rc)) + { + *pFile = (RTFILE)hFile; + Assert((HANDLE)*pFile == hFile); + RTPathWinFree(pwszFilename); + return VINF_SUCCESS; + } + + CloseHandle(hFile); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + RTPathWinFree(pwszFilename); + } + return rc; +} + + +RTR3DECL(int) RTFileOpenBitBucket(PRTFILE phFile, uint64_t fAccess) +{ + AssertReturn( fAccess == RTFILE_O_READ + || fAccess == RTFILE_O_WRITE + || fAccess == RTFILE_O_READWRITE, + VERR_INVALID_PARAMETER); + return RTFileOpen(phFile, "NUL", fAccess | RTFILE_O_DENY_NONE | RTFILE_O_OPEN); +} + + +RTR3DECL(int) RTFileClose(RTFILE hFile) +{ + if (hFile == NIL_RTFILE) + return VINF_SUCCESS; + if (CloseHandle((HANDLE)RTFileToNative(hFile))) + return VINF_SUCCESS; + return RTErrConvertFromWin32(GetLastError()); +} + + +RTFILE rtFileGetStandard(RTHANDLESTD enmStdHandle) +{ + DWORD dwStdHandle; + switch (enmStdHandle) + { + case RTHANDLESTD_INPUT: dwStdHandle = STD_INPUT_HANDLE; break; + case RTHANDLESTD_OUTPUT: dwStdHandle = STD_OUTPUT_HANDLE; break; + case RTHANDLESTD_ERROR: dwStdHandle = STD_ERROR_HANDLE; break; + default: + AssertFailedReturn(NIL_RTFILE); + } + + HANDLE hNative = GetStdHandle(dwStdHandle); + if (hNative == INVALID_HANDLE_VALUE) + return NIL_RTFILE; + + RTFILE hFile = (RTFILE)(uintptr_t)hNative; + AssertReturn((HANDLE)(uintptr_t)hFile == hNative, NIL_RTFILE); + return hFile; +} + + +RTR3DECL(int) RTFileSeek(RTFILE hFile, int64_t offSeek, unsigned uMethod, uint64_t *poffActual) +{ + static ULONG aulSeekRecode[] = + { + FILE_BEGIN, + FILE_CURRENT, + FILE_END, + }; + + /* + * Validate input. + */ + if (uMethod > RTFILE_SEEK_END) + { + AssertMsgFailed(("Invalid uMethod=%d\n", uMethod)); + return VERR_INVALID_PARAMETER; + } + + /* + * Execute the seek. + */ + if (MySetFilePointer(hFile, offSeek, poffActual, aulSeekRecode[uMethod])) + return VINF_SUCCESS; + return RTErrConvertFromWin32(GetLastError()); +} + + +RTR3DECL(int) RTFileRead(RTFILE hFile, void *pvBuf, size_t cbToRead, size_t *pcbRead) +{ + if (cbToRead <= 0) + { + if (pcbRead) + *pcbRead = 0; + return VINF_SUCCESS; + } + ULONG cbToReadAdj = (ULONG)cbToRead; + AssertReturn(cbToReadAdj == cbToRead, VERR_NUMBER_TOO_BIG); + + ULONG cbRead = 0; + if (ReadFile((HANDLE)RTFileToNative(hFile), pvBuf, cbToReadAdj, &cbRead, NULL)) + { + if (pcbRead) + /* Caller can handle partial reads. */ + *pcbRead = cbRead; + else + { + /* Caller expects everything to be read. */ + while (cbToReadAdj > cbRead) + { + ULONG cbReadPart = 0; + if (!ReadFile((HANDLE)RTFileToNative(hFile), (char*)pvBuf + cbRead, cbToReadAdj - cbRead, &cbReadPart, NULL)) + return RTErrConvertFromWin32(GetLastError()); + if (cbReadPart == 0) + return VERR_EOF; + cbRead += cbReadPart; + } + } + return VINF_SUCCESS; + } + + /* + * If it's a console, we might bump into out of memory conditions in the + * ReadConsole call. + */ + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_NOT_ENOUGH_MEMORY) + { + ULONG cbChunk = cbToReadAdj / 2; + if (cbChunk > 16*_1K) + cbChunk = 16*_1K; + else + cbChunk = RT_ALIGN_32(cbChunk, 256); + + cbRead = 0; + while (cbToReadAdj > cbRead) + { + ULONG cbToRead = RT_MIN(cbChunk, cbToReadAdj - cbRead); + ULONG cbReadPart = 0; + if (!ReadFile((HANDLE)RTFileToNative(hFile), (char *)pvBuf + cbRead, cbToRead, &cbReadPart, NULL)) + { + /* If we failed because the buffer is too big, shrink it and + try again. */ + dwErr = GetLastError(); + if ( dwErr == ERROR_NOT_ENOUGH_MEMORY + && cbChunk > 8) + { + cbChunk /= 2; + continue; + } + return RTErrConvertFromWin32(dwErr); + } + cbRead += cbReadPart; + + /* Return if the caller can handle partial reads, otherwise try + fill the buffer all the way up. */ + if (pcbRead) + { + *pcbRead = cbRead; + break; + } + if (cbReadPart == 0) + return VERR_EOF; + } + return VINF_SUCCESS; + } + + return RTErrConvertFromWin32(dwErr); +} + + +RTR3DECL(int) RTFileWrite(RTFILE hFile, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten) +{ + if (cbToWrite <= 0) + return VINF_SUCCESS; + ULONG const cbToWriteAdj = (ULONG)cbToWrite; + AssertReturn(cbToWriteAdj == cbToWrite, VERR_NUMBER_TOO_BIG); + + ULONG cbWritten = 0; + if (WriteFile((HANDLE)RTFileToNative(hFile), pvBuf, cbToWriteAdj, &cbWritten, NULL)) + { + if (pcbWritten) + /* Caller can handle partial writes. */ + *pcbWritten = RT_MIN(cbWritten, cbToWriteAdj); /* paranoia^3 */ + else + { + /* Caller expects everything to be written. */ + while (cbWritten < cbToWriteAdj) + { + ULONG cbWrittenPart = 0; + if (!WriteFile((HANDLE)RTFileToNative(hFile), (char*)pvBuf + cbWritten, + cbToWriteAdj - cbWritten, &cbWrittenPart, NULL)) + { + int rc = RTErrConvertFromWin32(GetLastError()); + if ( rc == VERR_DISK_FULL + && IsBeyondLimit(hFile, cbToWriteAdj - cbWritten, FILE_CURRENT) + ) + rc = VERR_FILE_TOO_BIG; + return rc; + } + if (cbWrittenPart == 0) + return VERR_WRITE_ERROR; + cbWritten += cbWrittenPart; + } + } + return VINF_SUCCESS; + } + + /* + * If it's a console, we might bump into out of memory conditions in the + * WriteConsole call. + */ + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_NOT_ENOUGH_MEMORY) + { + ULONG cbChunk = cbToWriteAdj / 2; + if (cbChunk > _32K) + cbChunk = _32K; + else + cbChunk = RT_ALIGN_32(cbChunk, 256); + + cbWritten = 0; + while (cbWritten < cbToWriteAdj) + { + ULONG cbToWrite = RT_MIN(cbChunk, cbToWriteAdj - cbWritten); + ULONG cbWrittenPart = 0; + if (!WriteFile((HANDLE)RTFileToNative(hFile), (const char *)pvBuf + cbWritten, cbToWrite, &cbWrittenPart, NULL)) + { + /* If we failed because the buffer is too big, shrink it and + try again. */ + dwErr = GetLastError(); + if ( dwErr == ERROR_NOT_ENOUGH_MEMORY + && cbChunk > 8) + { + cbChunk /= 2; + continue; + } + int rc = RTErrConvertFromWin32(dwErr); + if ( rc == VERR_DISK_FULL + && IsBeyondLimit(hFile, cbToWriteAdj - cbWritten, FILE_CURRENT)) + rc = VERR_FILE_TOO_BIG; + return rc; + } + cbWritten += cbWrittenPart; + + /* Return if the caller can handle partial writes, otherwise try + write out everything. */ + if (pcbWritten) + { + *pcbWritten = RT_MIN(cbWritten, cbToWriteAdj); /* paranoia^3 */ + break; + } + if (cbWrittenPart == 0) + return VERR_WRITE_ERROR; + } + return VINF_SUCCESS; + } + + int rc = RTErrConvertFromWin32(dwErr); + if ( rc == VERR_DISK_FULL + && IsBeyondLimit(hFile, cbToWriteAdj - cbWritten, FILE_CURRENT)) + rc = VERR_FILE_TOO_BIG; + return rc; +} + + +RTR3DECL(int) RTFileFlush(RTFILE hFile) +{ + if (!FlushFileBuffers((HANDLE)RTFileToNative(hFile))) + { + int rc = GetLastError(); + Log(("FlushFileBuffers failed with %d\n", rc)); + return RTErrConvertFromWin32(rc); + } + return VINF_SUCCESS; +} + + +RTR3DECL(int) RTFileSetSize(RTFILE hFile, uint64_t cbSize) +{ + /* + * Get current file pointer. + */ + int rc; + uint64_t offCurrent; + if (MySetFilePointer(hFile, 0, &offCurrent, FILE_CURRENT)) + { + /* + * Set new file pointer. + */ + if (MySetFilePointer(hFile, cbSize, NULL, FILE_BEGIN)) + { + /* set file pointer */ + if (SetEndOfFile((HANDLE)RTFileToNative(hFile))) + { + /* + * Restore file pointer and return. + * If the old pointer was beyond the new file end, ignore failure. + */ + if ( MySetFilePointer(hFile, offCurrent, NULL, FILE_BEGIN) + || offCurrent > cbSize) + return VINF_SUCCESS; + } + + /* + * Failed, try restoring the file pointer. + */ + rc = GetLastError(); + MySetFilePointer(hFile, offCurrent, NULL, FILE_BEGIN); + } + else + rc = GetLastError(); + } + else + rc = GetLastError(); + + return RTErrConvertFromWin32(rc); +} + + +RTR3DECL(int) RTFileGetSize(RTFILE hFile, uint64_t *pcbSize) +{ + /* + * GetFileSize works for most handles. + */ + ULARGE_INTEGER Size; + Size.LowPart = GetFileSize((HANDLE)RTFileToNative(hFile), &Size.HighPart); + if (Size.LowPart != INVALID_FILE_SIZE) + { + *pcbSize = Size.QuadPart; + return VINF_SUCCESS; + } + int rc = RTErrConvertFromWin32(GetLastError()); + + /* + * Could it be a volume or a disk? + */ + DISK_GEOMETRY DriveGeo; + DWORD cbDriveGeo; + if (DeviceIoControl((HANDLE)RTFileToNative(hFile), + IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, + &DriveGeo, sizeof(DriveGeo), &cbDriveGeo, NULL)) + { + if ( DriveGeo.MediaType == FixedMedia + || DriveGeo.MediaType == RemovableMedia) + { + *pcbSize = DriveGeo.Cylinders.QuadPart + * DriveGeo.TracksPerCylinder + * DriveGeo.SectorsPerTrack + * DriveGeo.BytesPerSector; + + GET_LENGTH_INFORMATION DiskLenInfo; + DWORD Ignored; + if (DeviceIoControl((HANDLE)RTFileToNative(hFile), + IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, + &DiskLenInfo, sizeof(DiskLenInfo), &Ignored, (LPOVERLAPPED)NULL)) + { + /* IOCTL_DISK_GET_LENGTH_INFO is supported -- override cbSize. */ + *pcbSize = DiskLenInfo.Length.QuadPart; + } + return VINF_SUCCESS; + } + } + + /* + * Return the GetFileSize result if not a volume/disk. + */ + return rc; +} + + +RTR3DECL(int) RTFileGetMaxSizeEx(RTFILE hFile, PRTFOFF pcbMax) +{ + /** @todo r=bird: + * We might have to make this code OS version specific... In the worse + * case, we'll have to try GetVolumeInformationByHandle on vista and fall + * back on NtQueryVolumeInformationFile(,,,, FileFsAttributeInformation) + * else where, and check for known file system names. (For LAN shares we'll + * have to figure out the remote file system.) */ + RT_NOREF_PV(hFile); RT_NOREF_PV(pcbMax); + return VERR_NOT_IMPLEMENTED; +} + + +RTR3DECL(bool) RTFileIsValid(RTFILE hFile) +{ + if (hFile != NIL_RTFILE) + { + DWORD dwType = GetFileType((HANDLE)RTFileToNative(hFile)); + switch (dwType) + { + case FILE_TYPE_CHAR: + case FILE_TYPE_DISK: + case FILE_TYPE_PIPE: + case FILE_TYPE_REMOTE: + return true; + + case FILE_TYPE_UNKNOWN: + if (GetLastError() == NO_ERROR) + return true; + break; + + default: + break; + } + } + return false; +} + + +#define LOW_DWORD(u64) ((DWORD)u64) +#define HIGH_DWORD(u64) (((DWORD *)&u64)[1]) + +RTR3DECL(int) RTFileLock(RTFILE hFile, unsigned fLock, int64_t offLock, uint64_t cbLock) +{ + Assert(offLock >= 0); + + /* Check arguments. */ + if (fLock & ~RTFILE_LOCK_MASK) + { + AssertMsgFailed(("Invalid fLock=%08X\n", fLock)); + return VERR_INVALID_PARAMETER; + } + + /* Prepare flags. */ + Assert(RTFILE_LOCK_WRITE); + DWORD dwFlags = (fLock & RTFILE_LOCK_WRITE) ? LOCKFILE_EXCLUSIVE_LOCK : 0; + Assert(RTFILE_LOCK_WAIT); + if (!(fLock & RTFILE_LOCK_WAIT)) + dwFlags |= LOCKFILE_FAIL_IMMEDIATELY; + + /* Windows structure. */ + OVERLAPPED Overlapped; + memset(&Overlapped, 0, sizeof(Overlapped)); + Overlapped.Offset = LOW_DWORD(offLock); + Overlapped.OffsetHigh = HIGH_DWORD(offLock); + + /* Note: according to Microsoft, LockFileEx API call is available starting from NT 3.5 */ + if (LockFileEx((HANDLE)RTFileToNative(hFile), dwFlags, 0, LOW_DWORD(cbLock), HIGH_DWORD(cbLock), &Overlapped)) + return VINF_SUCCESS; + + return RTErrConvertFromWin32(GetLastError()); +} + + +RTR3DECL(int) RTFileChangeLock(RTFILE hFile, unsigned fLock, int64_t offLock, uint64_t cbLock) +{ + Assert(offLock >= 0); + + /* Check arguments. */ + if (fLock & ~RTFILE_LOCK_MASK) + { + AssertMsgFailed(("Invalid fLock=%08X\n", fLock)); + return VERR_INVALID_PARAMETER; + } + + /* Remove old lock. */ + int rc = RTFileUnlock(hFile, offLock, cbLock); + if (RT_FAILURE(rc)) + return rc; + + /* Set new lock. */ + rc = RTFileLock(hFile, fLock, offLock, cbLock); + if (RT_SUCCESS(rc)) + return rc; + + /* Try to restore old lock. */ + unsigned fLockOld = (fLock & RTFILE_LOCK_WRITE) ? fLock & ~RTFILE_LOCK_WRITE : fLock | RTFILE_LOCK_WRITE; + rc = RTFileLock(hFile, fLockOld, offLock, cbLock); + if (RT_SUCCESS(rc)) + return VERR_FILE_LOCK_VIOLATION; + else + return VERR_FILE_LOCK_LOST; +} + + +RTR3DECL(int) RTFileUnlock(RTFILE hFile, int64_t offLock, uint64_t cbLock) +{ + Assert(offLock >= 0); + + if (UnlockFile((HANDLE)RTFileToNative(hFile), + LOW_DWORD(offLock), HIGH_DWORD(offLock), + LOW_DWORD(cbLock), HIGH_DWORD(cbLock))) + return VINF_SUCCESS; + + return RTErrConvertFromWin32(GetLastError()); +} + + + +RTR3DECL(int) RTFileQueryInfo(RTFILE hFile, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs) +{ + /* + * Validate input. + */ + if (hFile == NIL_RTFILE) + { + AssertMsgFailed(("Invalid hFile=%RTfile\n", hFile)); + return VERR_INVALID_PARAMETER; + } + if (!pObjInfo) + { + AssertMsgFailed(("Invalid pObjInfo=%p\n", pObjInfo)); + return VERR_INVALID_PARAMETER; + } + if ( enmAdditionalAttribs < RTFSOBJATTRADD_NOTHING + || enmAdditionalAttribs > RTFSOBJATTRADD_LAST) + { + AssertMsgFailed(("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs)); + return VERR_INVALID_PARAMETER; + } + + /* + * Query file info. + */ + HANDLE hHandle = (HANDLE)RTFileToNative(hFile); +#if 1 + uint64_t auBuf[168 / sizeof(uint64_t)]; /* Missing FILE_ALL_INFORMATION here. */ + int rc = rtPathNtQueryInfoFromHandle(hFile, auBuf, sizeof(auBuf), pObjInfo, enmAdditionalAttribs, NULL, 0); + if (RT_SUCCESS(rc)) + return rc; + + /* + * Console I/O handles make trouble here. On older windows versions they + * end up with ERROR_INVALID_HANDLE when handed to the above API, while on + * more recent ones they cause different errors to appear. + * + * Thus, we must ignore the latter and doubly verify invalid handle claims. + * We use the undocumented VerifyConsoleIoHandle to do this, falling back on + * GetFileType should it not be there. + */ + if ( rc == VERR_INVALID_HANDLE + || rc == VERR_ACCESS_DENIED + || rc == VERR_UNEXPECTED_FS_OBJ_TYPE) + { + static PFNVERIFYCONSOLEIOHANDLE s_pfnVerifyConsoleIoHandle = NULL; + static bool volatile s_fInitialized = false; + PFNVERIFYCONSOLEIOHANDLE pfnVerifyConsoleIoHandle; + if (s_fInitialized) + pfnVerifyConsoleIoHandle = s_pfnVerifyConsoleIoHandle; + else + { + pfnVerifyConsoleIoHandle = (PFNVERIFYCONSOLEIOHANDLE)RTLdrGetSystemSymbol("kernel32.dll", "VerifyConsoleIoHandle"); + ASMAtomicWriteBool(&s_fInitialized, true); + } + if ( pfnVerifyConsoleIoHandle + ? !pfnVerifyConsoleIoHandle(hHandle) + : GetFileType(hHandle) == FILE_TYPE_UNKNOWN && GetLastError() != NO_ERROR) + return VERR_INVALID_HANDLE; + } + /* + * On Windows 10 and (hopefully) 8.1 we get ERROR_INVALID_FUNCTION with console + * I/O handles and null device handles. We must ignore these just like the + * above invalid handle error. + */ + else if (rc != VERR_INVALID_FUNCTION && rc != VERR_IO_BAD_COMMAND) + return rc; + + RT_ZERO(*pObjInfo); + pObjInfo->Attr.enmAdditional = enmAdditionalAttribs; + pObjInfo->Attr.fMode = rtFsModeFromDos(RTFS_DOS_NT_DEVICE, "", 0, 0); + return VINF_SUCCESS; +#else + + BY_HANDLE_FILE_INFORMATION Data; + if (!GetFileInformationByHandle(hHandle, &Data)) + { + /* + * Console I/O handles make trouble here. On older windows versions they + * end up with ERROR_INVALID_HANDLE when handed to the above API, while on + * more recent ones they cause different errors to appear. + * + * Thus, we must ignore the latter and doubly verify invalid handle claims. + * We use the undocumented VerifyConsoleIoHandle to do this, falling back on + * GetFileType should it not be there. + */ + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_INVALID_HANDLE) + { + static PFNVERIFYCONSOLEIOHANDLE s_pfnVerifyConsoleIoHandle = NULL; + static bool volatile s_fInitialized = false; + PFNVERIFYCONSOLEIOHANDLE pfnVerifyConsoleIoHandle; + if (s_fInitialized) + pfnVerifyConsoleIoHandle = s_pfnVerifyConsoleIoHandle; + else + { + pfnVerifyConsoleIoHandle = (PFNVERIFYCONSOLEIOHANDLE)RTLdrGetSystemSymbol("kernel32.dll", "VerifyConsoleIoHandle"); + ASMAtomicWriteBool(&s_fInitialized, true); + } + if ( pfnVerifyConsoleIoHandle + ? !pfnVerifyConsoleIoHandle(hHandle) + : GetFileType(hHandle) == FILE_TYPE_UNKNOWN && GetLastError() != NO_ERROR) + return VERR_INVALID_HANDLE; + } + /* + * On Windows 10 and (hopefully) 8.1 we get ERROR_INVALID_FUNCTION with console I/O + * handles. We must ignore these just like the above invalid handle error. + */ + else if (dwErr != ERROR_INVALID_FUNCTION) + return RTErrConvertFromWin32(dwErr); + + RT_ZERO(Data); + Data.dwFileAttributes = RTFS_DOS_NT_DEVICE; + } + + /* + * Setup the returned data. + */ + pObjInfo->cbObject = ((uint64_t)Data.nFileSizeHigh << 32) + | (uint64_t)Data.nFileSizeLow; + pObjInfo->cbAllocated = pObjInfo->cbObject; + + Assert(sizeof(uint64_t) == sizeof(Data.ftCreationTime)); + RTTimeSpecSetNtTime(&pObjInfo->BirthTime, *(uint64_t *)&Data.ftCreationTime); + RTTimeSpecSetNtTime(&pObjInfo->AccessTime, *(uint64_t *)&Data.ftLastAccessTime); + RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, *(uint64_t *)&Data.ftLastWriteTime); + pObjInfo->ChangeTime = pObjInfo->ModificationTime; + + pObjInfo->Attr.fMode = rtFsModeFromDos((Data.dwFileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT, "", 0, + RTFSMODE_SYMLINK_REPARSE_TAG /* (symlink or not, doesn't usually matter here) */); + + /* + * Requested attributes (we cannot provide anything actually). + */ + switch (enmAdditionalAttribs) + { + case RTFSOBJATTRADD_NOTHING: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_NOTHING; + break; + + case RTFSOBJATTRADD_UNIX: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX; + pObjInfo->Attr.u.Unix.uid = ~0U; + pObjInfo->Attr.u.Unix.gid = ~0U; + pObjInfo->Attr.u.Unix.cHardlinks = Data.nNumberOfLinks ? Data.nNumberOfLinks : 1; + pObjInfo->Attr.u.Unix.INodeIdDevice = Data.dwVolumeSerialNumber; + pObjInfo->Attr.u.Unix.INodeId = RT_MAKE_U64(Data.nFileIndexLow, Data.nFileIndexHigh); + pObjInfo->Attr.u.Unix.fFlags = 0; + pObjInfo->Attr.u.Unix.GenerationId = 0; + pObjInfo->Attr.u.Unix.Device = 0; + break; + + case RTFSOBJATTRADD_UNIX_OWNER: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_OWNER; + pObjInfo->Attr.u.UnixOwner.uid = ~0U; + pObjInfo->Attr.u.UnixOwner.szName[0] = '\0'; /** @todo return something sensible here. */ + break; + + case RTFSOBJATTRADD_UNIX_GROUP: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_GROUP; + pObjInfo->Attr.u.UnixGroup.gid = ~0U; + pObjInfo->Attr.u.UnixGroup.szName[0] = '\0'; + break; + + case RTFSOBJATTRADD_EASIZE: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE; + pObjInfo->Attr.u.EASize.cb = 0; + break; + + default: + AssertMsgFailed(("Impossible!\n")); + return VERR_INTERNAL_ERROR; + } + + return VINF_SUCCESS; +#endif +} + + +RTR3DECL(int) RTFileSetTimes(RTFILE hFile, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + RT_NOREF_PV(pChangeTime); /* Not exposed thru the windows API we're using. */ + + if (!pAccessTime && !pModificationTime && !pBirthTime) + return VINF_SUCCESS; /* NOP */ + + FILETIME CreationTimeFT; + PFILETIME pCreationTimeFT = NULL; + if (pBirthTime) + pCreationTimeFT = RTTimeSpecGetNtFileTime(pBirthTime, &CreationTimeFT); + + FILETIME LastAccessTimeFT; + PFILETIME pLastAccessTimeFT = NULL; + if (pAccessTime) + pLastAccessTimeFT = RTTimeSpecGetNtFileTime(pAccessTime, &LastAccessTimeFT); + + FILETIME LastWriteTimeFT; + PFILETIME pLastWriteTimeFT = NULL; + if (pModificationTime) + pLastWriteTimeFT = RTTimeSpecGetNtFileTime(pModificationTime, &LastWriteTimeFT); + + int rc = VINF_SUCCESS; + if (!SetFileTime((HANDLE)RTFileToNative(hFile), pCreationTimeFT, pLastAccessTimeFT, pLastWriteTimeFT)) + { + DWORD Err = GetLastError(); + rc = RTErrConvertFromWin32(Err); + Log(("RTFileSetTimes(%RTfile, %p, %p, %p, %p): SetFileTime failed with lasterr %d (%Rrc)\n", + hFile, pAccessTime, pModificationTime, pChangeTime, pBirthTime, Err, rc)); + } + return rc; +} + + +#if 0 /* RTFileSetMode is implemented by RTFileSetMode-r3-nt.cpp */ +/* This comes from a source file with a different set of system headers (DDK) + * so it can't be declared in a common header, like internal/file.h. + */ +extern int rtFileNativeSetAttributes(HANDLE FileHandle, ULONG FileAttributes); + + +RTR3DECL(int) RTFileSetMode(RTFILE hFile, RTFMODE fMode) +{ + /* + * Normalize the mode and call the API. + */ + fMode = rtFsModeNormalize(fMode, NULL, 0); + if (!rtFsModeIsValid(fMode)) + return VERR_INVALID_PARAMETER; + + ULONG FileAttributes = (fMode & RTFS_DOS_MASK) >> RTFS_DOS_SHIFT; + int Err = rtFileNativeSetAttributes((HANDLE)hFile, FileAttributes); + if (Err != ERROR_SUCCESS) + { + int rc = RTErrConvertFromWin32(Err); + Log(("RTFileSetMode(%RTfile, %RTfmode): rtFileNativeSetAttributes (0x%08X) failed with err %d (%Rrc)\n", + hFile, fMode, FileAttributes, Err, rc)); + return rc; + } + return VINF_SUCCESS; +} +#endif + + +/* RTFileQueryFsSizes is implemented by ../nt/RTFileQueryFsSizes-nt.cpp */ + + +RTR3DECL(int) RTFileDelete(const char *pszFilename) +{ + PRTUTF16 pwszFilename; + int rc = RTPathWinFromUtf8(&pwszFilename, pszFilename, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + if (!DeleteFileW(pwszFilename)) + rc = RTErrConvertFromWin32(GetLastError()); + RTPathWinFree(pwszFilename); + } + + return rc; +} + + +RTDECL(int) RTFileRename(const char *pszSrc, const char *pszDst, unsigned fRename) +{ + /* + * Validate input. + */ + AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER); + AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER); + AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER); + + /* + * Hand it on to the worker. + */ + int rc = rtPathWin32MoveRename(pszSrc, pszDst, + fRename & RTPATHRENAME_FLAGS_REPLACE ? MOVEFILE_REPLACE_EXISTING : 0, + RTFS_TYPE_FILE); + + LogFlow(("RTFileMove(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n", + pszSrc, pszSrc, pszDst, pszDst, fRename, rc)); + return rc; + +} + + +RTDECL(int) RTFileMove(const char *pszSrc, const char *pszDst, unsigned fMove) +{ + /* + * Validate input. + */ + AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER); + AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER); + AssertMsgReturn(!(fMove & ~RTFILEMOVE_FLAGS_REPLACE), ("%#x\n", fMove), VERR_INVALID_PARAMETER); + + /* + * Hand it on to the worker. + */ + int rc = rtPathWin32MoveRename(pszSrc, pszDst, + fMove & RTFILEMOVE_FLAGS_REPLACE + ? MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING + : MOVEFILE_COPY_ALLOWED, + RTFS_TYPE_FILE); + + LogFlow(("RTFileMove(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n", + pszSrc, pszSrc, pszDst, pszDst, fMove, rc)); + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/fs-win.cpp b/src/VBox/Runtime/r3/win/fs-win.cpp new file mode 100644 index 00000000..e25ad9f2 --- /dev/null +++ b/src/VBox/Runtime/r3/win/fs-win.cpp @@ -0,0 +1,427 @@ +/* $Id: fs-win.cpp $ */ +/** @file + * IPRT - File System, Win32. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include <iprt/win/windows.h> + +#include <iprt/fs.h> +#include <iprt/path.h> +#include <iprt/string.h> +#include <iprt/param.h> +#include <iprt/err.h> +#include <iprt/log.h> +#include <iprt/assert.h> +#include "internal/fs.h" + +/* from ntdef.h */ +typedef LONG NTSTATUS; + +/* from ntddk.h */ +typedef struct _IO_STATUS_BLOCK { + union { + NTSTATUS Status; + PVOID Pointer; + }; + ULONG_PTR Information; +} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK; + +typedef enum _FSINFOCLASS { + FileFsAttributeInformation = 5, +} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS; + +/* from ntifs.h */ + +typedef struct _FILE_FS_ATTRIBUTE_INFORMATION { + ULONG FileSystemAttributes; + LONG MaximumComponentNameLength; + ULONG FileSystemNameLength; + WCHAR FileSystemName[1]; +} FILE_FS_ATTRIBUTE_INFORMATION, *PFILE_FS_ATTRIBUTE_INFORMATION; + +extern "C" NTSTATUS NTAPI NtQueryVolumeInformationFile(HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FS_INFORMATION_CLASS); + +/** + * Checks quickly if this is an correct root specification. + * Root specs ends with a slash of some kind. + * + * @returns indicator. + * @param pszFsPath Path to check. + */ +static bool rtFsIsRoot(const char *pszFsPath) +{ + /* + * UNC has exactly two slashes.. + * + * Anything else starting with slashe(s) requires + * expansion and will have to take the long road. + */ + if (RTPATH_IS_SLASH(pszFsPath[0])) + { + if ( !RTPATH_IS_SLASH(pszFsPath[1]) + || RTPATH_IS_SLASH(pszFsPath[2])) + return false; + + /* end of machine name */ + const char *pszSlash = strpbrk(pszFsPath + 2, "\\/"); + if (!pszSlash) + return false; + + /* end of service name. */ + pszSlash = strpbrk(pszSlash + 1, "\\/"); + if (!pszSlash) + return false; + + return pszSlash[1] == '\0'; + } + + /* + * Ok the other alternative is driver letter. + */ + return pszFsPath[0] >= 'A' && pszFsPath[0] <= 'Z' + && pszFsPath[1] == ':' + && RTPATH_IS_SLASH(pszFsPath[2]) + && !pszFsPath[3]; +} + + + +/** + * Finds the root of the specified volume. + * + * @returns iprt status code. + * @param pszFsPath Path within the filesystem. Verified as one byte or more. + * @param ppwszFsRoot Where to store the returned string. Free with rtFsFreeRoot(), + */ +static int rtFsGetRoot(const char *pszFsPath, PRTUTF16 *ppwszFsRoot) +{ + /* + * Do straight forward stuff first, + */ + if (rtFsIsRoot(pszFsPath)) + return RTStrToUtf16(pszFsPath, ppwszFsRoot); + + /* + * Expand and add slash (if required). + */ + char szFullPath[RTPATH_MAX]; + int rc = RTPathAbs(pszFsPath, szFullPath, sizeof(szFullPath)); + if (RT_FAILURE(rc)) + return rc; + size_t cb = strlen(szFullPath); + if (!RTPATH_IS_SLASH(szFullPath[cb - 1])) + { + AssertReturn(cb + 1 < RTPATH_MAX, VERR_FILENAME_TOO_LONG); + szFullPath[cb] = '\\'; + szFullPath[++cb] = '\0'; + } + + /* + * Convert the path. + */ + rc = RTStrToUtf16(szFullPath, ppwszFsRoot); + if (RT_FAILURE(rc)) + return rc == VERR_BUFFER_OVERFLOW ? VERR_FILENAME_TOO_LONG : rc; + + /* + * Walk the path until our proper API is happy or there is no more path left. + */ + PRTUTF16 pwszStart = *ppwszFsRoot; + if (!GetVolumeInformationW(pwszStart, NULL, 0, NULL, NULL, 0, NULL, 0)) + { + PRTUTF16 pwszEnd = pwszStart + RTUtf16Len(pwszStart); + PRTUTF16 pwszMin = pwszStart + 2; + do + { + /* Strip off the last path component. */ + while (pwszEnd-- > pwszMin) + if (RTPATH_IS_SLASH(*pwszEnd)) + break; + AssertReturn(pwszEnd >= pwszMin, VERR_INTERNAL_ERROR); /* leaks, but that's irrelevant for an internal error. */ + pwszEnd[1] = '\0'; + } while (!GetVolumeInformationW(pwszStart, NULL, 0, NULL, NULL, 0, NULL, 0)); + } + + return VINF_SUCCESS; +} + +/** + * Frees string returned by rtFsGetRoot(). + */ +static void rtFsFreeRoot(PRTUTF16 pwszFsRoot) +{ + RTUtf16Free(pwszFsRoot); +} + + +RTR3DECL(int) RTFsQuerySizes(const char *pszFsPath, RTFOFF *pcbTotal, RTFOFF *pcbFree, + uint32_t *pcbBlock, uint32_t *pcbSector) +{ + /* + * Validate & get valid root path. + */ + AssertMsgReturn(VALID_PTR(pszFsPath) && *pszFsPath, ("%p", pszFsPath), VERR_INVALID_PARAMETER); + PRTUTF16 pwszFsRoot; + int rc = rtFsGetRoot(pszFsPath, &pwszFsRoot); + if (RT_FAILURE(rc)) + return rc; + + /* + * Free and total. + */ + if (pcbTotal || pcbFree) + { + ULARGE_INTEGER cbTotal; + ULARGE_INTEGER cbFree; + if (GetDiskFreeSpaceExW(pwszFsRoot, &cbFree, &cbTotal, NULL)) + { + if (pcbTotal) + *pcbTotal = cbTotal.QuadPart; + if (pcbFree) + *pcbFree = cbFree.QuadPart; + } + else + { + DWORD Err = GetLastError(); + rc = RTErrConvertFromWin32(Err); + Log(("RTFsQuerySizes(%s,): GetDiskFreeSpaceEx failed with lasterr %d (%Rrc)\n", + pszFsPath, Err, rc)); + } + } + + /* + * Block and sector size. + */ + if ( RT_SUCCESS(rc) + && (pcbBlock || pcbSector)) + { + DWORD dwDummy1, dwDummy2; + DWORD cbSector; + DWORD cSectorsPerCluster; + if (GetDiskFreeSpaceW(pwszFsRoot, &cSectorsPerCluster, &cbSector, &dwDummy1, &dwDummy2)) + { + if (pcbBlock) + *pcbBlock = cbSector * cSectorsPerCluster; + if (pcbSector) + *pcbSector = cbSector; + } + else + { + DWORD Err = GetLastError(); + rc = RTErrConvertFromWin32(Err); + Log(("RTFsQuerySizes(%s,): GetDiskFreeSpace failed with lasterr %d (%Rrc)\n", + pszFsPath, Err, rc)); + } + } + + rtFsFreeRoot(pwszFsRoot); + return rc; +} + + +/** + * Query the serial number of a filesystem. + * + * @returns iprt status code. + * @param pszFsPath Path within the mounted filesystem. + * @param pu32Serial Where to store the serial number. + */ +RTR3DECL(int) RTFsQuerySerial(const char *pszFsPath, uint32_t *pu32Serial) +{ + /* + * Validate & get valid root path. + */ + AssertMsgReturn(VALID_PTR(pszFsPath) && *pszFsPath, ("%p", pszFsPath), VERR_INVALID_PARAMETER); + AssertMsgReturn(VALID_PTR(pu32Serial), ("%p", pu32Serial), VERR_INVALID_PARAMETER); + PRTUTF16 pwszFsRoot; + int rc = rtFsGetRoot(pszFsPath, &pwszFsRoot); + if (RT_FAILURE(rc)) + return rc; + + /* + * Do work. + */ + DWORD dwMaxName; + DWORD dwFlags; + DWORD dwSerial; + if (GetVolumeInformationW(pwszFsRoot, NULL, 0, &dwSerial, &dwMaxName, &dwFlags, NULL, 0)) + *pu32Serial = dwSerial; + else + { + DWORD Err = GetLastError(); + rc = RTErrConvertFromWin32(Err); + Log(("RTFsQuerySizes(%s,): GetDiskFreeSpaceEx failed with lasterr %d (%Rrc)\n", + pszFsPath, Err, rc)); + } + + rtFsFreeRoot(pwszFsRoot); + return rc; +} + + +/** + * Query the properties of a mounted filesystem. + * + * @returns iprt status code. + * @param pszFsPath Path within the mounted filesystem. + * @param pProperties Where to store the properties. + */ +RTR3DECL(int) RTFsQueryProperties(const char *pszFsPath, PRTFSPROPERTIES pProperties) +{ + /* + * Validate & get valid root path. + */ + AssertMsgReturn(VALID_PTR(pszFsPath) && *pszFsPath, ("%p", pszFsPath), VERR_INVALID_PARAMETER); + AssertMsgReturn(VALID_PTR(pProperties), ("%p", pProperties), VERR_INVALID_PARAMETER); + PRTUTF16 pwszFsRoot; + int rc = rtFsGetRoot(pszFsPath, &pwszFsRoot); + if (RT_FAILURE(rc)) + return rc; + + /* + * Do work. + */ + DWORD dwMaxName; + DWORD dwFlags; + DWORD dwSerial; + if (GetVolumeInformationW(pwszFsRoot, NULL, 0, &dwSerial, &dwMaxName, &dwFlags, NULL, 0)) + { + memset(pProperties, 0, sizeof(*pProperties)); + pProperties->cbMaxComponent = dwMaxName; + pProperties->fFileCompression = !!(dwFlags & FILE_FILE_COMPRESSION); + pProperties->fCompressed = !!(dwFlags & FILE_VOLUME_IS_COMPRESSED); + pProperties->fReadOnly = !!(dwFlags & FILE_READ_ONLY_VOLUME); + pProperties->fSupportsUnicode = !!(dwFlags & FILE_UNICODE_ON_DISK); + pProperties->fCaseSensitive = false; /* win32 is case preserving only */ + /** @todo r=bird: What about FILE_CASE_SENSITIVE_SEARCH ? Is this set for NTFS + * as well perchance? If so, better mention it instead of just setting + * fCaseSensitive to false. */ + pProperties->fRemote = false; /* no idea yet */ + } + else + { + DWORD Err = GetLastError(); + rc = RTErrConvertFromWin32(Err); + Log(("RTFsQuerySizes(%s,): GetVolumeInformation failed with lasterr %d (%Rrc)\n", + pszFsPath, Err, rc)); + } + + rtFsFreeRoot(pwszFsRoot); + return rc; +} + + +RTR3DECL(bool) RTFsIsCaseSensitive(const char *pszFsPath) +{ + return false; +} + + +/** + * Internal helper for comparing a WCHAR string with a char string. + * + * @returns @c true if equal, @c false if not. + * @param pwsz1 The first string. + * @param cch1 The length of the first string, in bytes. + * @param psz2 The second string. + * @param cch2 The length of the second string. + */ +static bool rtFsWinAreEqual(WCHAR const *pwsz1, size_t cch1, const char *psz2, size_t cch2) +{ + if (cch1 != cch2 * 2) + return false; + while (cch2-- > 0) + { + unsigned ch1 = *pwsz1++; + unsigned ch2 = (unsigned char)*psz2++; + if (ch1 != ch2) + return false; + } + return true; +} + + +RTR3DECL(int) RTFsQueryType(const char *pszFsPath, PRTFSTYPE penmType) +{ + *penmType = RTFSTYPE_UNKNOWN; + + AssertPtrReturn(pszFsPath, VERR_INVALID_POINTER); + AssertReturn(*pszFsPath, VERR_INVALID_PARAMETER); + + /* + * Convert the path and try open it. + */ + PRTUTF16 pwszFsPath; + int rc = RTPathWinFromUtf8(&pwszFsPath, pszFsPath, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + HANDLE hFile = CreateFileW(pwszFsPath, + GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + NULL, + OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, + NULL); + if (hFile != INVALID_HANDLE_VALUE) + { + /* + * Use the NT api directly to get the file system name. + */ + char abBuf[8192]; + IO_STATUS_BLOCK Ios; + NTSTATUS rcNt = NtQueryVolumeInformationFile(hFile, &Ios, + abBuf, sizeof(abBuf), + FileFsAttributeInformation); + if (rcNt >= 0) + { + PFILE_FS_ATTRIBUTE_INFORMATION pFsAttrInfo = (PFILE_FS_ATTRIBUTE_INFORMATION)abBuf; +#define IS_FS(szName) \ + rtFsWinAreEqual(pFsAttrInfo->FileSystemName, pFsAttrInfo->FileSystemNameLength, szName, sizeof(szName) - 1) + if (IS_FS("NTFS")) + *penmType = RTFSTYPE_NTFS; + else if (IS_FS("FAT")) + *penmType = RTFSTYPE_FAT; + else if (IS_FS("FAT32")) + *penmType = RTFSTYPE_FAT; + else if (IS_FS("EXFAT")) + *penmType = RTFSTYPE_EXFAT; + else if (IS_FS("VBoxSharedFolderFS")) + *penmType = RTFSTYPE_VBOXSHF; +#undef IS_FS + } + else + rc = RTErrConvertFromNtStatus(rcNt); + CloseHandle(hFile); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + RTPathWinFree(pwszFsPath); + } + return rc; +} diff --git a/src/VBox/Runtime/r3/win/init-win.cpp b/src/VBox/Runtime/r3/win/init-win.cpp new file mode 100644 index 00000000..c9620d4b --- /dev/null +++ b/src/VBox/Runtime/r3/win/init-win.cpp @@ -0,0 +1,801 @@ +/* $Id: init-win.cpp $ */ +/** @file + * IPRT - Init Ring-3, Windows Specific Code. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_DEFAULT +#include <iprt/nt/nt-and-windows.h> +#ifndef LOAD_LIBRARY_SEARCH_APPLICATION_DIR +# define LOAD_LIBRARY_SEARCH_APPLICATION_DIR 0x200 +# define LOAD_LIBRARY_SEARCH_SYSTEM32 0x800 +#endif + +#include "internal-r3-win.h" +#include <iprt/initterm.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/ldr.h> +#include <iprt/log.h> +#include <iprt/param.h> +#include <iprt/string.h> +#include <iprt/thread.h> +#include "../init.h" + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef VOID (WINAPI *PFNGETCURRENTTHREADSTACKLIMITS)(PULONG_PTR puLow, PULONG_PTR puHigh); +typedef LPTOP_LEVEL_EXCEPTION_FILTER (WINAPI * PFNSETUNHANDLEDEXCEPTIONFILTER)(LPTOP_LEVEL_EXCEPTION_FILTER); + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Windows DLL loader protection level. */ +DECLHIDDEN(RTR3WINLDRPROT) g_enmWinLdrProt = RTR3WINLDRPROT_NONE; +/** Our simplified windows version. */ +DECLHIDDEN(RTWINOSTYPE) g_enmWinVer = kRTWinOSType_UNKNOWN; +/** Extended windows version information. */ +DECLHIDDEN(OSVERSIONINFOEXW) g_WinOsInfoEx; + +/** The native kernel32.dll handle. */ +DECLHIDDEN(HMODULE) g_hModKernel32 = NULL; +/** GetSystemWindowsDirectoryW or GetWindowsDirectoryW (NT4). */ +DECLHIDDEN(PFNGETWINSYSDIR) g_pfnGetSystemWindowsDirectoryW = NULL; +/** The GetCurrentThreadStackLimits API. */ +static PFNGETCURRENTTHREADSTACKLIMITS g_pfnGetCurrentThreadStackLimits = NULL; +/** SetUnhandledExceptionFilter. */ +static PFNSETUNHANDLEDEXCEPTIONFILTER g_pfnSetUnhandledExceptionFilter = NULL; +/** The previous unhandled exception filter. */ +static LPTOP_LEVEL_EXCEPTION_FILTER g_pfnUnhandledXcptFilter = NULL; +/** SystemTimeToTzSpecificLocalTime. */ +decltype(SystemTimeToTzSpecificLocalTime) *g_pfnSystemTimeToTzSpecificLocalTime = NULL; + +/** The native ntdll.dll handle. */ +DECLHIDDEN(HMODULE) g_hModNtDll = NULL; +/** NtQueryFullAttributesFile */ +DECLHIDDEN(PFNNTQUERYFULLATTRIBUTESFILE) g_pfnNtQueryFullAttributesFile = NULL; +/** NtDuplicateToken (NT 3.51). */ +DECLHIDDEN(PFNNTDUPLICATETOKEN) g_pfnNtDuplicateToken = NULL; +/** NtAlertThread (NT 3.51). */ +decltype(NtAlertThread) *g_pfnNtAlertThread = NULL; + +/** Either ws2_32.dll (NT4+) or wsock32.dll (NT3.x). */ +DECLHIDDEN(HMODULE) g_hModWinSock = NULL; +/** Set if we're dealing with old winsock. */ +DECLHIDDEN(bool) g_fOldWinSock = false; +/** WSAStartup */ +DECLHIDDEN(PFNWSASTARTUP) g_pfnWSAStartup = NULL; +/** WSACleanup */ +DECLHIDDEN(PFNWSACLEANUP) g_pfnWSACleanup = NULL; +/** Pointner to WSAGetLastError (for RTErrVarsSave). */ +DECLHIDDEN(PFNWSAGETLASTERROR) g_pfnWSAGetLastError = NULL; +/** Pointner to WSASetLastError (for RTErrVarsRestore). */ +DECLHIDDEN(PFNWSASETLASTERROR) g_pfnWSASetLastError = NULL; +/** WSACreateEvent */ +DECLHIDDEN(PFNWSACREATEEVENT) g_pfnWSACreateEvent = NULL; +/** WSACloseEvent */ +DECLHIDDEN(PFNWSACLOSEEVENT) g_pfnWSACloseEvent = NULL; +/** WSASetEvent */ +DECLHIDDEN(PFNWSASETEVENT) g_pfnWSASetEvent = NULL; +/** WSAEventSelect */ +DECLHIDDEN(PFNWSAEVENTSELECT) g_pfnWSAEventSelect = NULL; +/** WSAEnumNetworkEvents */ +DECLHIDDEN(PFNWSAENUMNETWORKEVENTS) g_pfnWSAEnumNetworkEvents = NULL; +/** WSASend */ +DECLHIDDEN(PFNWSASend) g_pfnWSASend = NULL; +/** socket */ +DECLHIDDEN(PFNWINSOCKSOCKET) g_pfnsocket = NULL; +/** closesocket */ +DECLHIDDEN(PFNWINSOCKCLOSESOCKET) g_pfnclosesocket = NULL; +/** recv */ +DECLHIDDEN(PFNWINSOCKRECV) g_pfnrecv = NULL; +/** send */ +DECLHIDDEN(PFNWINSOCKSEND) g_pfnsend = NULL; +/** recvfrom */ +DECLHIDDEN(PFNWINSOCKRECVFROM) g_pfnrecvfrom = NULL; +/** sendto */ +DECLHIDDEN(PFNWINSOCKSENDTO) g_pfnsendto = NULL; +/** bind */ +DECLHIDDEN(PFNWINSOCKBIND) g_pfnbind = NULL; +/** listen */ +DECLHIDDEN(PFNWINSOCKLISTEN) g_pfnlisten = NULL; +/** accept */ +DECLHIDDEN(PFNWINSOCKACCEPT) g_pfnaccept = NULL; +/** connect */ +DECLHIDDEN(PFNWINSOCKCONNECT) g_pfnconnect = NULL; +/** shutdown */ +DECLHIDDEN(PFNWINSOCKSHUTDOWN) g_pfnshutdown = NULL; +/** getsockopt */ +DECLHIDDEN(PFNWINSOCKGETSOCKOPT) g_pfngetsockopt = NULL; +/** setsockopt */ +DECLHIDDEN(PFNWINSOCKSETSOCKOPT) g_pfnsetsockopt = NULL; +/** ioctlsocket */ +DECLHIDDEN(PFNWINSOCKIOCTLSOCKET) g_pfnioctlsocket = NULL; +/** getpeername */ +DECLHIDDEN(PFNWINSOCKGETPEERNAME) g_pfngetpeername = NULL; +/** getsockname */ +DECLHIDDEN(PFNWINSOCKGETSOCKNAME) g_pfngetsockname = NULL; +/** __WSAFDIsSet */ +DECLHIDDEN(PFNWINSOCK__WSAFDISSET) g_pfn__WSAFDIsSet = NULL; +/** select */ +DECLHIDDEN(PFNWINSOCKSELECT) g_pfnselect = NULL; +/** gethostbyname */ +DECLHIDDEN(PFNWINSOCKGETHOSTBYNAME) g_pfngethostbyname = NULL; + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static LONG CALLBACK rtR3WinUnhandledXcptFilter(PEXCEPTION_POINTERS); + + +/** + * Translates OSVERSIONINOFEX into a Windows OS type. + * + * @returns The Windows OS type. + * @param pOSInfoEx The OS info returned by Windows. + * + * @remarks This table has been assembled from Usenet postings, personal + * observations, and reading other people's code. Please feel + * free to add to it or correct it. + * <pre> + dwPlatFormID dwMajorVersion dwMinorVersion dwBuildNumber +95 1 4 0 950 +95 SP1 1 4 0 >950 && <=1080 +95 OSR2 1 4 <10 >1080 +98 1 4 10 1998 +98 SP1 1 4 10 >1998 && <2183 +98 SE 1 4 10 >=2183 +ME 1 4 90 3000 + +NT 3.51 2 3 51 1057 +NT 4 2 4 0 1381 +2000 2 5 0 2195 +XP 2 5 1 2600 +2003 2 5 2 3790 +Vista 2 6 0 + +CE 1.0 3 1 0 +CE 2.0 3 2 0 +CE 2.1 3 2 1 +CE 3.0 3 3 0 +</pre> + */ +static RTWINOSTYPE rtR3InitWinSimplifiedVersion(OSVERSIONINFOEXW const *pOSInfoEx) +{ + RTWINOSTYPE enmVer = kRTWinOSType_UNKNOWN; + BYTE const bProductType = pOSInfoEx->wProductType; + DWORD const dwPlatformId = pOSInfoEx->dwPlatformId; + DWORD const dwMinorVersion = pOSInfoEx->dwMinorVersion; + DWORD const dwMajorVersion = pOSInfoEx->dwMajorVersion; + DWORD const dwBuildNumber = pOSInfoEx->dwBuildNumber & 0xFFFF; /* Win 9x needs this. */ + + if ( dwPlatformId == VER_PLATFORM_WIN32_WINDOWS + && dwMajorVersion == 4) + { + if ( dwMinorVersion < 10 + && dwBuildNumber == 950) + enmVer = kRTWinOSType_95; + else if ( dwMinorVersion < 10 + && dwBuildNumber > 950 + && dwBuildNumber <= 1080) + enmVer = kRTWinOSType_95SP1; + else if ( dwMinorVersion < 10 + && dwBuildNumber > 1080) + enmVer = kRTWinOSType_95OSR2; + else if ( dwMinorVersion == 10 + && dwBuildNumber == 1998) + enmVer = kRTWinOSType_98; + else if ( dwMinorVersion == 10 + && dwBuildNumber > 1998 + && dwBuildNumber < 2183) + enmVer = kRTWinOSType_98SP1; + else if ( dwMinorVersion == 10 + && dwBuildNumber >= 2183) + enmVer = kRTWinOSType_98SE; + else if (dwMinorVersion == 90) + enmVer = kRTWinOSType_ME; + } + else if (dwPlatformId == VER_PLATFORM_WIN32_NT) + { + if (dwMajorVersion == 3) + { + if ( dwMinorVersion < 50) + enmVer = kRTWinOSType_NT310; + else if (dwMinorVersion == 50) + enmVer = kRTWinOSType_NT350; + else + enmVer = kRTWinOSType_NT351; + } + else if (dwMajorVersion == 4) + enmVer = kRTWinOSType_NT4; + else if (dwMajorVersion == 5) + { + if (dwMinorVersion == 0) + enmVer = kRTWinOSType_2K; + else if (dwMinorVersion == 1) + enmVer = kRTWinOSType_XP; + else + enmVer = kRTWinOSType_2003; + } + else if (dwMajorVersion == 6) + { + if (dwMinorVersion == 0) + enmVer = bProductType != VER_NT_WORKSTATION ? kRTWinOSType_2008 : kRTWinOSType_VISTA; + else if (dwMinorVersion == 1) + enmVer = bProductType != VER_NT_WORKSTATION ? kRTWinOSType_2008R2 : kRTWinOSType_7; + else if (dwMinorVersion == 2) + enmVer = bProductType != VER_NT_WORKSTATION ? kRTWinOSType_2012 : kRTWinOSType_8; + else if (dwMinorVersion == 3) + enmVer = bProductType != VER_NT_WORKSTATION ? kRTWinOSType_2012R2 : kRTWinOSType_81; + else if (dwMinorVersion == 4) + enmVer = bProductType != VER_NT_WORKSTATION ? kRTWinOSType_2016 : kRTWinOSType_10; + else + enmVer = kRTWinOSType_NT_UNKNOWN; + } + else if (dwMajorVersion == 10) + { + if (dwMinorVersion == 0) + enmVer = bProductType != VER_NT_WORKSTATION ? kRTWinOSType_2016 : kRTWinOSType_10; + else + enmVer = kRTWinOSType_NT_UNKNOWN; + } + else + enmVer = kRTWinOSType_NT_UNKNOWN; + } + + return enmVer; +} + + +/** + * Initializes the global variables related to windows version. + */ +static void rtR3InitWindowsVersion(void) +{ + Assert(g_hModNtDll != NULL); + + /* + * ASSUMES OSVERSIONINFOEX starts with the exact same layout as OSVERSIONINFO (safe). + */ + AssertCompileMembersSameSizeAndOffset(OSVERSIONINFOEX, szCSDVersion, OSVERSIONINFO, szCSDVersion); + AssertCompileMemberOffset(OSVERSIONINFOEX, wServicePackMajor, sizeof(OSVERSIONINFO)); + + /* + * Use the NT version of GetVersionExW so we don't get fooled by + * compatability shims. + */ + RT_ZERO(g_WinOsInfoEx); + g_WinOsInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW); + + LONG (__stdcall *pfnRtlGetVersion)(OSVERSIONINFOEXW *); + *(FARPROC *)&pfnRtlGetVersion = GetProcAddress(g_hModNtDll, "RtlGetVersion"); + LONG rcNt = -1; + if (pfnRtlGetVersion) + rcNt = pfnRtlGetVersion(&g_WinOsInfoEx); + if (rcNt != 0) + { + /* + * Couldn't find it or it failed, try the windows version of the API. + */ + RT_ZERO(g_WinOsInfoEx); + g_WinOsInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW); + if (!GetVersionExW((POSVERSIONINFOW)&g_WinOsInfoEx)) + { + /* + * If that didn't work either, just get the basic version bits. + */ + RT_ZERO(g_WinOsInfoEx); + g_WinOsInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW); + if (GetVersionExW((POSVERSIONINFOW)&g_WinOsInfoEx)) + Assert(g_WinOsInfoEx.dwPlatformId != VER_PLATFORM_WIN32_NT || g_WinOsInfoEx.dwMajorVersion < 5); + else + { + AssertBreakpoint(); + RT_ZERO(g_WinOsInfoEx); + } + } + } + + if (g_WinOsInfoEx.dwOSVersionInfoSize) + g_enmWinVer = rtR3InitWinSimplifiedVersion(&g_WinOsInfoEx); +} + + +/** + * Resolves the winsock error APIs. + */ +static void rtR3InitWinSockApis(void) +{ + /* + * Try get ws2_32.dll, then try load it, then finally fall back to the old + * wsock32.dll. We use RTLdrLoadSystem to the loading as it has all the fancy + * logic for safely doing that. + */ + g_hModWinSock = GetModuleHandleW(L"ws2_32.dll"); + if (g_hModWinSock == NULL) + { + RTLDRMOD hLdrMod; + int rc = RTLdrLoadSystem("ws2_32.dll", true /*fNoUnload*/, &hLdrMod); + if (RT_FAILURE(rc)) + { + rc = RTLdrLoadSystem("wsock32.dll", true /*fNoUnload*/, &hLdrMod); + if (RT_FAILURE(rc)) + { + AssertMsgFailed(("rc=%Rrc\n", rc)); + return; + } + g_fOldWinSock = true; + } + g_hModWinSock = (HMODULE)RTLdrGetNativeHandle(hLdrMod); + RTLdrClose(hLdrMod); + } + + g_pfnWSAStartup = (decltype(g_pfnWSAStartup)) GetProcAddress(g_hModWinSock, "WSAStartup"); + g_pfnWSACleanup = (decltype(g_pfnWSACleanup)) GetProcAddress(g_hModWinSock, "WSACleanup"); + g_pfnWSAGetLastError = (decltype(g_pfnWSAGetLastError)) GetProcAddress(g_hModWinSock, "WSAGetLastError"); + g_pfnWSASetLastError = (decltype(g_pfnWSASetLastError)) GetProcAddress(g_hModWinSock, "WSASetLastError"); + g_pfnWSACreateEvent = (decltype(g_pfnWSACreateEvent)) GetProcAddress(g_hModWinSock, "WSACreateEvent"); + g_pfnWSACloseEvent = (decltype(g_pfnWSACloseEvent)) GetProcAddress(g_hModWinSock, "WSACloseEvent"); + g_pfnWSASetEvent = (decltype(g_pfnWSASetEvent)) GetProcAddress(g_hModWinSock, "WSASetEvent"); + g_pfnWSAEventSelect = (decltype(g_pfnWSAEventSelect)) GetProcAddress(g_hModWinSock, "WSAEventSelect"); + g_pfnWSAEnumNetworkEvents = (decltype(g_pfnWSAEnumNetworkEvents))GetProcAddress(g_hModWinSock,"WSAEnumNetworkEvents"); + g_pfnWSASend = (decltype(g_pfnWSASend)) GetProcAddress(g_hModWinSock, "WSASend"); + g_pfnsocket = (decltype(g_pfnsocket)) GetProcAddress(g_hModWinSock, "socket"); + g_pfnclosesocket = (decltype(g_pfnclosesocket)) GetProcAddress(g_hModWinSock, "closesocket"); + g_pfnrecv = (decltype(g_pfnrecv)) GetProcAddress(g_hModWinSock, "recv"); + g_pfnsend = (decltype(g_pfnsend)) GetProcAddress(g_hModWinSock, "send"); + g_pfnrecvfrom = (decltype(g_pfnrecvfrom)) GetProcAddress(g_hModWinSock, "recvfrom"); + g_pfnsendto = (decltype(g_pfnsendto)) GetProcAddress(g_hModWinSock, "sendto"); + g_pfnbind = (decltype(g_pfnbind)) GetProcAddress(g_hModWinSock, "bind"); + g_pfnlisten = (decltype(g_pfnlisten)) GetProcAddress(g_hModWinSock, "listen"); + g_pfnaccept = (decltype(g_pfnaccept)) GetProcAddress(g_hModWinSock, "accept"); + g_pfnconnect = (decltype(g_pfnconnect)) GetProcAddress(g_hModWinSock, "connect"); + g_pfnshutdown = (decltype(g_pfnshutdown)) GetProcAddress(g_hModWinSock, "shutdown"); + g_pfngetsockopt = (decltype(g_pfngetsockopt)) GetProcAddress(g_hModWinSock, "getsockopt"); + g_pfnsetsockopt = (decltype(g_pfnsetsockopt)) GetProcAddress(g_hModWinSock, "setsockopt"); + g_pfnioctlsocket = (decltype(g_pfnioctlsocket)) GetProcAddress(g_hModWinSock, "ioctlsocket"); + g_pfngetpeername = (decltype(g_pfngetpeername)) GetProcAddress(g_hModWinSock, "getpeername"); + g_pfngetsockname = (decltype(g_pfngetsockname)) GetProcAddress(g_hModWinSock, "getsockname"); + g_pfn__WSAFDIsSet = (decltype(g_pfn__WSAFDIsSet)) GetProcAddress(g_hModWinSock, "__WSAFDIsSet"); + g_pfnselect = (decltype(g_pfnselect)) GetProcAddress(g_hModWinSock, "select"); + g_pfngethostbyname = (decltype(g_pfngethostbyname)) GetProcAddress(g_hModWinSock, "gethostbyname"); + + Assert(g_pfnWSAStartup); + Assert(g_pfnWSACleanup); + Assert(g_pfnWSAGetLastError); + Assert(g_pfnWSASetLastError); + Assert(g_pfnWSACreateEvent || g_fOldWinSock); + Assert(g_pfnWSACloseEvent || g_fOldWinSock); + Assert(g_pfnWSASetEvent || g_fOldWinSock); + Assert(g_pfnWSAEventSelect || g_fOldWinSock); + Assert(g_pfnWSAEnumNetworkEvents || g_fOldWinSock); + Assert(g_pfnWSASend || g_fOldWinSock); + Assert(g_pfnsocket); + Assert(g_pfnclosesocket); + Assert(g_pfnrecv); + Assert(g_pfnsend); + Assert(g_pfnrecvfrom); + Assert(g_pfnsendto); + Assert(g_pfnbind); + Assert(g_pfnlisten); + Assert(g_pfnaccept); + Assert(g_pfnconnect); + Assert(g_pfnshutdown); + Assert(g_pfngetsockopt); + Assert(g_pfnsetsockopt); + Assert(g_pfnioctlsocket); + Assert(g_pfngetpeername); + Assert(g_pfngetsockname); + Assert(g_pfn__WSAFDIsSet); + Assert(g_pfnselect); + Assert(g_pfngethostbyname); +} + + +static int rtR3InitNativeObtrusiveWorker(uint32_t fFlags) +{ + /* + * Disable error popups. + */ + UINT fOldErrMode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX); + SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX | fOldErrMode); + + /* + * Restrict DLL searching for the process on windows versions which allow + * us to do so. + * - The first trick works on XP SP1+ and disables the searching of the + * current directory. + * - The second trick is W7 w/ KB2533623 and W8+, it restrict the DLL + * searching to the application directory (except when + * RTR3INIT_FLAGS_STANDALONE_APP is given) and the System32 directory. + */ + int rc = VINF_SUCCESS; + + typedef BOOL (WINAPI *PFNSETDLLDIRECTORY)(LPCWSTR); + PFNSETDLLDIRECTORY pfnSetDllDir = (PFNSETDLLDIRECTORY)GetProcAddress(g_hModKernel32, "SetDllDirectoryW"); + if (pfnSetDllDir) + { + if (pfnSetDllDir(L"")) + g_enmWinLdrProt = RTR3WINLDRPROT_NO_CWD; + else + rc = VERR_INTERNAL_ERROR_3; + } + + /** @bugref{6861} Observed GUI issues on Vista (32-bit and 64-bit) when using + * SetDefaultDllDirectories. + * @bugref{8194} Try use SetDefaultDllDirectories on Vista for standalone apps + * despite potential GUI issues. */ + if ( g_enmWinVer > kRTWinOSType_VISTA + || (fFlags & RTR3INIT_FLAGS_STANDALONE_APP)) + { + typedef BOOL(WINAPI *PFNSETDEFAULTDLLDIRECTORIES)(DWORD); + PFNSETDEFAULTDLLDIRECTORIES pfnSetDefDllDirs; + pfnSetDefDllDirs = (PFNSETDEFAULTDLLDIRECTORIES)GetProcAddress(g_hModKernel32, "SetDefaultDllDirectories"); + if (pfnSetDefDllDirs) + { + DWORD fDllDirs = LOAD_LIBRARY_SEARCH_SYSTEM32; + if (!(fFlags & RTR3INIT_FLAGS_STANDALONE_APP)) + fDllDirs |= LOAD_LIBRARY_SEARCH_APPLICATION_DIR; + if (pfnSetDefDllDirs(fDllDirs)) + g_enmWinLdrProt = fDllDirs & LOAD_LIBRARY_SEARCH_APPLICATION_DIR ? RTR3WINLDRPROT_SAFE : RTR3WINLDRPROT_SAFER; + else if (RT_SUCCESS(rc)) + rc = VERR_INTERNAL_ERROR_4; + } + } + + /* + * Register an unhandled exception callback if we can. + */ + g_pfnGetCurrentThreadStackLimits = (PFNGETCURRENTTHREADSTACKLIMITS)GetProcAddress(g_hModKernel32, "GetCurrentThreadStackLimits"); + g_pfnSetUnhandledExceptionFilter = (PFNSETUNHANDLEDEXCEPTIONFILTER)GetProcAddress(g_hModKernel32, "SetUnhandledExceptionFilter"); + if (g_pfnSetUnhandledExceptionFilter && !g_pfnUnhandledXcptFilter) + { + g_pfnUnhandledXcptFilter = g_pfnSetUnhandledExceptionFilter(rtR3WinUnhandledXcptFilter); + AssertStmt(g_pfnUnhandledXcptFilter != rtR3WinUnhandledXcptFilter, g_pfnUnhandledXcptFilter = NULL); + } + + return rc; +} + + +DECLHIDDEN(int) rtR3InitNativeFirst(uint32_t fFlags) +{ + /* + * Make sure we've got the handles of the two main Windows NT dlls. + */ + g_hModKernel32 = GetModuleHandleW(L"kernel32.dll"); + if (g_hModKernel32 == NULL) + return VERR_INTERNAL_ERROR_2; + g_hModNtDll = GetModuleHandleW(L"ntdll.dll"); + if (g_hModNtDll == NULL) + return VERR_INTERNAL_ERROR_2; + + rtR3InitWindowsVersion(); + + int rc = VINF_SUCCESS; + if (!(fFlags & RTR3INIT_FLAGS_UNOBTRUSIVE)) + rc = rtR3InitNativeObtrusiveWorker(fFlags); + + /* + * Resolve some kernel32.dll APIs we may need but aren't necessarily + * present in older windows versions. + */ + g_pfnGetSystemWindowsDirectoryW = (PFNGETWINSYSDIR)GetProcAddress(g_hModKernel32, "GetSystemWindowsDirectoryW"); + if (g_pfnGetSystemWindowsDirectoryW) + g_pfnGetSystemWindowsDirectoryW = (PFNGETWINSYSDIR)GetProcAddress(g_hModKernel32, "GetWindowsDirectoryW"); + g_pfnSystemTimeToTzSpecificLocalTime = (decltype(SystemTimeToTzSpecificLocalTime) *)GetProcAddress(g_hModKernel32, "SystemTimeToTzSpecificLocalTime"); + + /* + * Resolve some ntdll.dll APIs that weren't there in early NT versions. + */ + g_pfnNtQueryFullAttributesFile = (PFNNTQUERYFULLATTRIBUTESFILE)GetProcAddress(g_hModNtDll, "NtQueryFullAttributesFile"); + g_pfnNtDuplicateToken = (PFNNTDUPLICATETOKEN)GetProcAddress( g_hModNtDll, "NtDuplicateToken"); + g_pfnNtAlertThread = (decltype(NtAlertThread) *)GetProcAddress( g_hModNtDll, "NtAlertThread"); + + /* + * Resolve the winsock error getter and setter so assertions can save those too. + */ + rtR3InitWinSockApis(); + + return rc; +} + + +DECLHIDDEN(void) rtR3InitNativeObtrusive(uint32_t fFlags) +{ + rtR3InitNativeObtrusiveWorker(fFlags); +} + + +DECLHIDDEN(int) rtR3InitNativeFinal(uint32_t fFlags) +{ + /* Nothing to do here. */ + RT_NOREF_PV(fFlags); + return VINF_SUCCESS; +} + + +/** + * Unhandled exception filter callback. + * + * Will try log stuff. + */ +static LONG CALLBACK rtR3WinUnhandledXcptFilter(PEXCEPTION_POINTERS pPtrs) +{ + /* + * Try get the logger and log exception details. + * + * Note! We'll be using RTLogLogger for now, though we should probably add + * a less deadlock prone API here and gives up pretty fast if it + * cannot get the lock... + */ + PRTLOGGER pLogger = RTLogRelGetDefaultInstance(); + if (!pLogger) + pLogger = RTLogGetDefaultInstance(); + if (pLogger) + { + RTLogLogger(pLogger, NULL, "\n!!! rtR3WinUnhandledXcptFilter caught an exception on thread %p!!!\n", RTThreadNativeSelf()); + + /* + * Dump the exception record. + */ + uintptr_t uXcptPC = 0; + PEXCEPTION_RECORD pXcptRec = RT_VALID_PTR(pPtrs) && RT_VALID_PTR(pPtrs->ExceptionRecord) ? pPtrs->ExceptionRecord : NULL; + if (pXcptRec) + { + RTLogLogger(pLogger, NULL, "\nExceptionCode=%#010x ExceptionFlags=%#010x ExceptionAddress=%p\n", + pXcptRec->ExceptionCode, pXcptRec->ExceptionFlags, pXcptRec->ExceptionAddress); + for (uint32_t i = 0; i < RT_MIN(pXcptRec->NumberParameters, EXCEPTION_MAXIMUM_PARAMETERS); i++) + RTLogLogger(pLogger, NULL, "ExceptionInformation[%d]=%p\n", i, pXcptRec->ExceptionInformation[i]); + uXcptPC = (uintptr_t)pXcptRec->ExceptionAddress; + + /* Nested? Display one level only. */ + PEXCEPTION_RECORD pNestedRec = pXcptRec->ExceptionRecord; + if (RT_VALID_PTR(pNestedRec)) + { + RTLogLogger(pLogger, NULL, "Nested: ExceptionCode=%#010x ExceptionFlags=%#010x ExceptionAddress=%p (nested %p)\n", + pNestedRec->ExceptionCode, pNestedRec->ExceptionFlags, pNestedRec->ExceptionAddress, + pNestedRec->ExceptionRecord); + for (uint32_t i = 0; i < RT_MIN(pNestedRec->NumberParameters, EXCEPTION_MAXIMUM_PARAMETERS); i++) + RTLogLogger(pLogger, NULL, "Nested: ExceptionInformation[%d]=%p\n", i, pNestedRec->ExceptionInformation[i]); + uXcptPC = (uintptr_t)pNestedRec->ExceptionAddress; + } + } + + /* + * Dump the context record. + */ + volatile char szMarker[] = "stackmarker"; + uintptr_t uXcptSP = (uintptr_t)&szMarker[0]; + PCONTEXT pXcptCtx = RT_VALID_PTR(pPtrs) && RT_VALID_PTR(pPtrs->ContextRecord) ? pPtrs->ContextRecord : NULL; + if (pXcptCtx) + { +#ifdef RT_ARCH_AMD64 + RTLogLogger(pLogger, NULL, "\ncs:rip=%04x:%016RX64\n", pXcptCtx->SegCs, pXcptCtx->Rip); + RTLogLogger(pLogger, NULL, "ss:rsp=%04x:%016RX64 rbp=%016RX64\n", pXcptCtx->SegSs, pXcptCtx->Rsp, pXcptCtx->Rbp); + RTLogLogger(pLogger, NULL, "rax=%016RX64 rcx=%016RX64 rdx=%016RX64 rbx=%016RX64\n", + pXcptCtx->Rax, pXcptCtx->Rcx, pXcptCtx->Rdx, pXcptCtx->Rbx); + RTLogLogger(pLogger, NULL, "rsi=%016RX64 rdi=%016RX64 rsp=%016RX64 rbp=%016RX64\n", + pXcptCtx->Rsi, pXcptCtx->Rdi, pXcptCtx->Rsp, pXcptCtx->Rbp); + RTLogLogger(pLogger, NULL, "r8 =%016RX64 r9 =%016RX64 r10=%016RX64 r11=%016RX64\n", + pXcptCtx->R8, pXcptCtx->R9, pXcptCtx->R10, pXcptCtx->R11); + RTLogLogger(pLogger, NULL, "r12=%016RX64 r13=%016RX64 r14=%016RX64 r15=%016RX64\n", + pXcptCtx->R12, pXcptCtx->R13, pXcptCtx->R14, pXcptCtx->R15); + RTLogLogger(pLogger, NULL, "ds=%04x es=%04x fs=%04x gs=%04x eflags=%08x\n", + pXcptCtx->SegDs, pXcptCtx->SegEs, pXcptCtx->SegFs, pXcptCtx->SegGs, pXcptCtx->EFlags); + RTLogLogger(pLogger, NULL, "p1home=%016RX64 p2home=%016RX64 pe3home=%016RX64\n", + pXcptCtx->P1Home, pXcptCtx->P2Home, pXcptCtx->P3Home); + RTLogLogger(pLogger, NULL, "p4home=%016RX64 p5home=%016RX64 pe6home=%016RX64\n", + pXcptCtx->P4Home, pXcptCtx->P5Home, pXcptCtx->P6Home); + RTLogLogger(pLogger, NULL, " LastBranchToRip=%016RX64 LastBranchFromRip=%016RX64\n", + pXcptCtx->LastBranchToRip, pXcptCtx->LastBranchFromRip); + RTLogLogger(pLogger, NULL, "LastExceptionToRip=%016RX64 LastExceptionFromRip=%016RX64\n", + pXcptCtx->LastExceptionToRip, pXcptCtx->LastExceptionFromRip); + uXcptSP = pXcptCtx->Rsp; + uXcptPC = pXcptCtx->Rip; + +#elif defined(RT_ARCH_X86) + RTLogLogger(pLogger, NULL, "\ncs:eip=%04x:%08RX32\n", pXcptCtx->SegCs, pXcptCtx->Eip); + RTLogLogger(pLogger, NULL, "ss:esp=%04x:%08RX32 ebp=%08RX32\n", pXcptCtx->SegSs, pXcptCtx->Esp, pXcptCtx->Ebp); + RTLogLogger(pLogger, NULL, "eax=%08RX32 ecx=%08RX32 edx=%08RX32 ebx=%08RX32\n", + pXcptCtx->Eax, pXcptCtx->Ecx, pXcptCtx->Edx, pXcptCtx->Ebx); + RTLogLogger(pLogger, NULL, "esi=%08RX32 edi=%08RX32 esp=%08RX32 ebp=%08RX32\n", + pXcptCtx->Esi, pXcptCtx->Edi, pXcptCtx->Esp, pXcptCtx->Ebp); + RTLogLogger(pLogger, NULL, "ds=%04x es=%04x fs=%04x gs=%04x eflags=%08x\n", + pXcptCtx->SegDs, pXcptCtx->SegEs, pXcptCtx->SegFs, pXcptCtx->SegGs, pXcptCtx->EFlags); + uXcptSP = pXcptCtx->Esp; + uXcptPC = pXcptCtx->Eip; +#endif + } + + /* + * Dump stack. + */ + uintptr_t uStack = (uintptr_t)(void *)&szMarker[0]; + uStack -= uStack & 15; + + size_t cbToDump = PAGE_SIZE - (uStack & PAGE_OFFSET_MASK); + if (cbToDump < 512) + cbToDump += PAGE_SIZE; + size_t cbToXcpt = uXcptSP - uStack; + while (cbToXcpt > cbToDump && cbToXcpt <= _16K) + cbToDump += PAGE_SIZE; + ULONG_PTR uLow = (uintptr_t)&szMarker[0]; + ULONG_PTR uHigh = (uintptr_t)&szMarker[0]; + if (g_pfnGetCurrentThreadStackLimits) + { + g_pfnGetCurrentThreadStackLimits(&uLow, &uHigh); + size_t cbToTop = RT_MAX(uLow, uHigh) - uStack; + if (cbToTop < _1M) + cbToDump = cbToTop; + } + + RTLogLogger(pLogger, NULL, "\nStack %p, dumping %#x bytes (low=%p, high=%p)\n", uStack, cbToDump, uLow, uHigh); + RTLogLogger(pLogger, NULL, "%.*RhxD\n", cbToDump, uStack); + + /* + * Try figure the thread name. + * + * Note! This involves the thread db lock, so it may deadlock, which + * is why it's at the end. + */ + RTLogLogger(pLogger, NULL, "Thread ID: %p\n", RTThreadNativeSelf()); + RTLogLogger(pLogger, NULL, "Thread name: %s\n", RTThreadSelfName()); + RTLogLogger(pLogger, NULL, "Thread IPRT: %p\n", RTThreadSelf()); + + /* + * Try dump the load information. + */ + PPEB pPeb = RTNtCurrentPeb(); + if (RT_VALID_PTR(pPeb)) + { + PPEB_LDR_DATA pLdrData = pPeb->Ldr; + if (RT_VALID_PTR(pLdrData)) + { + PLDR_DATA_TABLE_ENTRY pFound = NULL; + LIST_ENTRY * const pList = &pLdrData->InMemoryOrderModuleList; + LIST_ENTRY *pListEntry = pList->Flink; + uint32_t cLoops = 0; + RTLogLogger(pLogger, NULL, + "\nLoaded Modules:\n" + "%-*s[*] Timestamp Path\n", sizeof(void *) * 4 + 2 - 1, "Address range" + ); + while (pListEntry != pList && RT_VALID_PTR(pListEntry) && cLoops < 1024) + { + PLDR_DATA_TABLE_ENTRY pLdrEntry = RT_FROM_MEMBER(pListEntry, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks); + uint32_t const cbLength = (uint32_t)(uintptr_t)pLdrEntry->Reserved3[1]; + char chInd = ' '; + if (uXcptPC - (uintptr_t)pLdrEntry->DllBase < cbLength) + { + chInd = '*'; + pFound = pLdrEntry; + } + + if ( RT_VALID_PTR(pLdrEntry->FullDllName.Buffer) + && pLdrEntry->FullDllName.Length > 0 + && pLdrEntry->FullDllName.Length < _8K + && (pLdrEntry->FullDllName.Length & 1) == 0 + && pLdrEntry->FullDllName.Length <= pLdrEntry->FullDllName.MaximumLength) + RTLogLogger(pLogger, NULL, "%p..%p%c %08RX32 %.*ls\n", + pLdrEntry->DllBase, (uintptr_t)pLdrEntry->DllBase + cbLength - 1, chInd, + pLdrEntry->TimeDateStamp, pLdrEntry->FullDllName.Length / sizeof(RTUTF16), + pLdrEntry->FullDllName.Buffer); + else + RTLogLogger(pLogger, NULL, "%p..%p%c %08RX32 <bad or missing: %p LB %#x max %#x\n", + pLdrEntry->DllBase, (uintptr_t)pLdrEntry->DllBase + cbLength - 1, chInd, + pLdrEntry->TimeDateStamp, pLdrEntry->FullDllName.Buffer, pLdrEntry->FullDllName.Length, + pLdrEntry->FullDllName.MaximumLength); + + /* advance */ + pListEntry = pListEntry->Flink; + cLoops++; + } + + /* + * Use the above to pick out code addresses on the stack. + */ + if ( cLoops < 1024 + && uXcptSP - uStack < cbToDump) + { + RTLogLogger(pLogger, NULL, "\nPotential code addresses on the stack:\n"); + if (pFound) + { + if ( RT_VALID_PTR(pFound->FullDllName.Buffer) + && pFound->FullDllName.Length > 0 + && pFound->FullDllName.Length < _8K + && (pFound->FullDllName.Length & 1) == 0 + && pFound->FullDllName.Length <= pFound->FullDllName.MaximumLength) + RTLogLogger(pLogger, NULL, "%-*s: %p - %#010RX32 bytes into %.*ls\n", + sizeof(void *) * 2, "Xcpt PC", uXcptPC, (uint32_t)(uXcptPC - (uintptr_t)pFound->DllBase), + pFound->FullDllName.Length / sizeof(RTUTF16), pFound->FullDllName.Buffer); + else + RTLogLogger(pLogger, NULL, "%-*s: %p - %08RX32 into module at %p\n", + sizeof(void *) * 2, "Xcpt PC", uXcptPC, (uint32_t)(uXcptPC - (uintptr_t)pFound->DllBase), + pFound->DllBase); + } + + uintptr_t const *puStack = (uintptr_t const *)uXcptSP; + uintptr_t cLeft = (cbToDump - (uXcptSP - uStack)) / sizeof(uintptr_t); + while (cLeft-- > 0) + { + uintptr_t uPtr = *puStack; + if (RT_VALID_PTR(uPtr)) + { + /* Search the module table. */ + pFound = NULL; + cLoops = 0; + pListEntry = pList->Flink; + while (pListEntry != pList && RT_VALID_PTR(pListEntry) && cLoops < 1024) + { + PLDR_DATA_TABLE_ENTRY pLdrEntry = RT_FROM_MEMBER(pListEntry, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks); + uint32_t const cbLength = (uint32_t)(uintptr_t)pLdrEntry->Reserved3[1]; + if (uPtr - (uintptr_t)pLdrEntry->DllBase < cbLength) + { + pFound = pLdrEntry; + break; + } + + /* advance */ + pListEntry = pListEntry->Flink; + cLoops++; + } + + if (pFound) + { + if ( RT_VALID_PTR(pFound->FullDllName.Buffer) + && pFound->FullDllName.Length > 0 + && pFound->FullDllName.Length < _8K + && (pFound->FullDllName.Length & 1) == 0 + && pFound->FullDllName.Length <= pFound->FullDllName.MaximumLength) + RTLogLogger(pLogger, NULL, "%p: %p - %#010RX32 bytes into %.*ls\n", + puStack, uPtr, (uint32_t)(uPtr - (uintptr_t)pFound->DllBase), + pFound->FullDllName.Length / sizeof(RTUTF16), pFound->FullDllName.Buffer); + else + RTLogLogger(pLogger, NULL, "%p: %p - %08RX32 into module at %p\n", + puStack, uPtr, (uint32_t)(uPtr - (uintptr_t)pFound->DllBase), pFound->DllBase); + } + } + + puStack++; + } + } + } + } + } + + /* + * Do the default stuff, never mind us. + */ + if (g_pfnUnhandledXcptFilter) + return g_pfnUnhandledXcptFilter(pPtrs); + return EXCEPTION_CONTINUE_SEARCH; +} + diff --git a/src/VBox/Runtime/r3/win/internal-r3-win.h b/src/VBox/Runtime/r3/win/internal-r3-win.h new file mode 100644 index 00000000..e60a90e2 --- /dev/null +++ b/src/VBox/Runtime/r3/win/internal-r3-win.h @@ -0,0 +1,212 @@ +/* $Id: internal-r3-win.h $ */ +/** @file + * IPRT - some Windows OS type constants. + */ + +/* + * Copyright (C) 2013-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef IPRT_INCLUDED_SRC_r3_win_internal_r3_win_h +#define IPRT_INCLUDED_SRC_r3_win_internal_r3_win_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include "internal/iprt.h" +#include <iprt/types.h> + + +/******************************************************************************* +* Structures and Typedefs * +*******************************************************************************/ +/** + * Windows OS type as determined by rtSystemWinOSType(). + * + * @note ASSUMPTIONS are made regarding ordering. Win 9x should come first, then + * NT. The Win9x and NT versions should internally be ordered in ascending + * version/code-base order. + */ +typedef enum RTWINOSTYPE +{ + kRTWinOSType_UNKNOWN = 0, + kRTWinOSType_9XFIRST = 1, + kRTWinOSType_95 = kRTWinOSType_9XFIRST, + kRTWinOSType_95SP1, + kRTWinOSType_95OSR2, + kRTWinOSType_98, + kRTWinOSType_98SP1, + kRTWinOSType_98SE, + kRTWinOSType_ME, + kRTWinOSType_9XLAST = 99, + kRTWinOSType_NTFIRST = 100, + kRTWinOSType_NT310 = kRTWinOSType_NTFIRST, + kRTWinOSType_NT350, + kRTWinOSType_NT351, + kRTWinOSType_NT4, + kRTWinOSType_2K, /* 5.0 */ + kRTWinOSType_XP, /* 5.1 */ + kRTWinOSType_XP64, /* 5.2, workstation */ + kRTWinOSType_2003, /* 5.2 */ + kRTWinOSType_VISTA, /* 6.0, workstation */ + kRTWinOSType_2008, /* 6.0, server */ + kRTWinOSType_7, /* 6.1, workstation */ + kRTWinOSType_2008R2, /* 6.1, server */ + kRTWinOSType_8, /* 6.2, workstation */ + kRTWinOSType_2012, /* 6.2, server */ + kRTWinOSType_81, /* 6.3, workstation */ + kRTWinOSType_2012R2, /* 6.3, server */ + kRTWinOSType_10, /* 10.0, workstation */ + kRTWinOSType_2016, /* 10.0, server */ + kRTWinOSType_NT_UNKNOWN = 199, + kRTWinOSType_NT_LAST = kRTWinOSType_UNKNOWN +} RTWINOSTYPE; + +/** + * Windows loader protection level. + */ +typedef enum RTR3WINLDRPROT +{ + RTR3WINLDRPROT_INVALID = 0, + RTR3WINLDRPROT_NONE, + RTR3WINLDRPROT_NO_CWD, + RTR3WINLDRPROT_SAFE, + RTR3WINLDRPROT_SAFER +} RTR3WINLDRPROT; + + +/******************************************************************************* +* Global Variables * +*******************************************************************************/ +extern DECLHIDDEN(RTR3WINLDRPROT) g_enmWinLdrProt; +extern DECLHIDDEN(RTWINOSTYPE) g_enmWinVer; +#ifdef _WINDEF_ +extern DECLHIDDEN(OSVERSIONINFOEXW) g_WinOsInfoEx; + +extern DECLHIDDEN(HMODULE) g_hModKernel32; +typedef UINT (WINAPI *PFNGETWINSYSDIR)(LPWSTR,UINT); +extern DECLHIDDEN(PFNGETWINSYSDIR) g_pfnGetSystemWindowsDirectoryW; +extern decltype(SystemTimeToTzSpecificLocalTime) *g_pfnSystemTimeToTzSpecificLocalTime; + +extern DECLHIDDEN(HMODULE) g_hModNtDll; +typedef NTSTATUS (NTAPI *PFNNTQUERYFULLATTRIBUTESFILE)(struct _OBJECT_ATTRIBUTES *, struct _FILE_NETWORK_OPEN_INFORMATION *); +extern DECLHIDDEN(PFNNTQUERYFULLATTRIBUTESFILE) g_pfnNtQueryFullAttributesFile; +typedef NTSTATUS (NTAPI *PFNNTDUPLICATETOKEN)(HANDLE, ACCESS_MASK, struct _OBJECT_ATTRIBUTES *, BOOLEAN, TOKEN_TYPE, PHANDLE); +extern DECLHIDDEN(PFNNTDUPLICATETOKEN) g_pfnNtDuplicateToken; +#ifdef IPRT_INCLUDED_nt_nt_h +extern decltype(NtAlertThread) *g_pfnNtAlertThread; +#endif + +extern DECLHIDDEN(HMODULE) g_hModWinSock; + +/** WSAStartup */ +typedef int (WINAPI *PFNWSASTARTUP)(WORD, struct WSAData *); +/** WSACleanup */ +typedef int (WINAPI *PFNWSACLEANUP)(void); +/** WSAGetLastError */ +typedef int (WINAPI *PFNWSAGETLASTERROR)(void); +/** WSASetLastError */ +typedef int (WINAPI *PFNWSASETLASTERROR)(int); +/** WSACreateEvent */ +typedef HANDLE (WINAPI *PFNWSACREATEEVENT)(void); +/** WSASetEvent */ +typedef BOOL (WINAPI *PFNWSASETEVENT)(HANDLE); +/** WSACloseEvent */ +typedef BOOL (WINAPI *PFNWSACLOSEEVENT)(HANDLE); +/** WSAEventSelect */ +typedef BOOL (WINAPI *PFNWSAEVENTSELECT)(UINT_PTR, HANDLE, LONG); +/** WSAEnumNetworkEvents */ +typedef int (WINAPI *PFNWSAENUMNETWORKEVENTS)(UINT_PTR, HANDLE, struct _WSANETWORKEVENTS *); +/** WSASend */ +typedef int (WINAPI *PFNWSASend)(UINT_PTR, struct _WSABUF *, DWORD, LPDWORD, DWORD dwFlags, struct _OVERLAPPED *, PFNRT /*LPWSAOVERLAPPED_COMPLETION_ROUTINE*/); + +/** socket */ +typedef UINT_PTR (WINAPI *PFNWINSOCKSOCKET)(int, int, int); +/** closesocket */ +typedef int (WINAPI *PFNWINSOCKCLOSESOCKET)(UINT_PTR); +/** recv */ +typedef int (WINAPI *PFNWINSOCKRECV)(UINT_PTR, char *, int, int); +/** send */ +typedef int (WINAPI *PFNWINSOCKSEND)(UINT_PTR, const char *, int, int); +/** recvfrom */ +typedef int (WINAPI *PFNWINSOCKRECVFROM)(UINT_PTR, char *, int, int, struct sockaddr *, int *); +/** sendto */ +typedef int (WINAPI *PFNWINSOCKSENDTO)(UINT_PTR, const char *, int, int, const struct sockaddr *, int); +/** bind */ +typedef int (WINAPI *PFNWINSOCKBIND)(UINT_PTR, const struct sockaddr *, int); +/** listen */ +typedef int (WINAPI *PFNWINSOCKLISTEN)(UINT_PTR, int); +/** accept */ +typedef UINT_PTR (WINAPI *PFNWINSOCKACCEPT)(UINT_PTR, struct sockaddr *, int *); +/** connect */ +typedef int (WINAPI *PFNWINSOCKCONNECT)(UINT_PTR, const struct sockaddr *, int); +/** shutdown */ +typedef int (WINAPI *PFNWINSOCKSHUTDOWN)(UINT_PTR, int); +/** getsockopt */ +typedef int (WINAPI *PFNWINSOCKGETSOCKOPT)(UINT_PTR, int, int, char *, int *); +/** setsockopt */ +typedef int (WINAPI *PFNWINSOCKSETSOCKOPT)(UINT_PTR, int, int, const char *, int); +/** ioctlsocket */ +typedef int (WINAPI *PFNWINSOCKIOCTLSOCKET)(UINT_PTR, long, unsigned long *); +/** getpeername */ +typedef int (WINAPI *PFNWINSOCKGETPEERNAME)(UINT_PTR, struct sockaddr *, int *); +/** getsockname */ +typedef int (WINAPI *PFNWINSOCKGETSOCKNAME)(UINT_PTR, struct sockaddr *, int *); +/** __WSAFDIsSet */ +typedef int (WINAPI *PFNWINSOCK__WSAFDISSET)(UINT_PTR, struct fd_set *); +/** select */ +typedef int (WINAPI *PFNWINSOCKSELECT)(int, struct fd_set *, struct fd_set *, struct fd_set *, const struct timeval *); +/** gethostbyname */ +typedef struct hostent *(WINAPI *PFNWINSOCKGETHOSTBYNAME)(const char *); + +extern DECLHIDDEN(PFNWSASTARTUP) g_pfnWSAStartup; +extern DECLHIDDEN(PFNWSACLEANUP) g_pfnWSACleanup; +extern PFNWSAGETLASTERROR g_pfnWSAGetLastError; +extern PFNWSASETLASTERROR g_pfnWSASetLastError; +extern DECLHIDDEN(PFNWSACREATEEVENT) g_pfnWSACreateEvent; +extern DECLHIDDEN(PFNWSACLOSEEVENT) g_pfnWSACloseEvent; +extern DECLHIDDEN(PFNWSASETEVENT) g_pfnWSASetEvent; +extern DECLHIDDEN(PFNWSAEVENTSELECT) g_pfnWSAEventSelect; +extern DECLHIDDEN(PFNWSAENUMNETWORKEVENTS) g_pfnWSAEnumNetworkEvents; +extern DECLHIDDEN(PFNWSASend) g_pfnWSASend; +extern DECLHIDDEN(PFNWINSOCKSOCKET) g_pfnsocket; +extern DECLHIDDEN(PFNWINSOCKCLOSESOCKET) g_pfnclosesocket; +extern DECLHIDDEN(PFNWINSOCKRECV) g_pfnrecv; +extern DECLHIDDEN(PFNWINSOCKSEND) g_pfnsend; +extern DECLHIDDEN(PFNWINSOCKRECVFROM) g_pfnrecvfrom; +extern DECLHIDDEN(PFNWINSOCKSENDTO) g_pfnsendto; +extern DECLHIDDEN(PFNWINSOCKBIND) g_pfnbind; +extern DECLHIDDEN(PFNWINSOCKLISTEN) g_pfnlisten; +extern DECLHIDDEN(PFNWINSOCKACCEPT) g_pfnaccept; +extern DECLHIDDEN(PFNWINSOCKCONNECT) g_pfnconnect; +extern DECLHIDDEN(PFNWINSOCKSHUTDOWN) g_pfnshutdown; +extern DECLHIDDEN(PFNWINSOCKGETSOCKOPT) g_pfngetsockopt; +extern DECLHIDDEN(PFNWINSOCKSETSOCKOPT) g_pfnsetsockopt; +extern DECLHIDDEN(PFNWINSOCKIOCTLSOCKET) g_pfnioctlsocket; +extern DECLHIDDEN(PFNWINSOCKGETPEERNAME) g_pfngetpeername; +extern DECLHIDDEN(PFNWINSOCKGETSOCKNAME) g_pfngetsockname; +extern DECLHIDDEN(PFNWINSOCK__WSAFDISSET) g_pfn__WSAFDIsSet; +extern DECLHIDDEN(PFNWINSOCKSELECT) g_pfnselect; +extern DECLHIDDEN(PFNWINSOCKGETHOSTBYNAME) g_pfngethostbyname; +#endif + + +#endif /* !IPRT_INCLUDED_SRC_r3_win_internal_r3_win_h */ + diff --git a/src/VBox/Runtime/r3/win/krnlmod-win.cpp b/src/VBox/Runtime/r3/win/krnlmod-win.cpp new file mode 100644 index 00000000..e6ed8f7c --- /dev/null +++ b/src/VBox/Runtime/r3/win/krnlmod-win.cpp @@ -0,0 +1,297 @@ +/* $Id: krnlmod-win.cpp $ */ +/** @file + * IPRT - Kernel module, Windows. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_SYSTEM +#include <iprt/nt/nt.h> + +#include <iprt/krnlmod.h> +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/dir.h> +#include <iprt/errcore.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/types.h> + + +/** + * Internal kernel information record state. + */ +typedef struct RTKRNLMODINFOINT +{ + /** Reference counter. */ + volatile uint32_t cRefs; + /** Reference count for the kernel module. */ + uint32_t cRefKrnlMod; + /** Load address of the kernel module. */ + RTR0UINTPTR uLoadAddr; + /** Size of the kernel module. */ + size_t cbKrnlMod; + /** Pointer to the driver name. */ + const char *pszName; + /** Size of the name in characters including the zero terminator. */ + size_t cchFilePath; + /** Module name - variable in size. */ + char achFilePath[1]; +} RTKRNLMODINFOINT; +/** Pointer to the internal kernel module information record. */ +typedef RTKRNLMODINFOINT *PRTKRNLMODINFOINT; +/** Pointer to a const internal kernel module information record. */ +typedef const RTKRNLMODINFOINT *PCRTKRNLMODINFOINT; + + +/** + * Destroy the given kernel module information record. + * + * @returns nothing. + * @param pThis The record to destroy. + */ +static void rtKrnlModInfoDestroy(PRTKRNLMODINFOINT pThis) +{ + RTMemFree(pThis); +} + + +/** + * Queries the complete kernel modules structure and returns a pointer to it. + * + * @returns IPRT status code. + * @param ppKrnlMods Where to store the pointer to the kernel module list on success. + * Free with RTMemFree(). + */ +static int rtKrnlModWinQueryKrnlMods(PRTL_PROCESS_MODULES *ppKrnlMods) +{ + int rc = VINF_SUCCESS; + RTL_PROCESS_MODULES KrnlModsSize; + + NTSTATUS rcNt = NtQuerySystemInformation(SystemModuleInformation, &KrnlModsSize, sizeof(KrnlModsSize), NULL); + if (NT_SUCCESS(rcNt) || rcNt == STATUS_INFO_LENGTH_MISMATCH) + { + ULONG cbKrnlMods = RT_UOFFSETOF_DYN(RTL_PROCESS_MODULES, Modules[KrnlModsSize.NumberOfModules]); + PRTL_PROCESS_MODULES pKrnlMods = (PRTL_PROCESS_MODULES)RTMemAllocZ(cbKrnlMods); + if (RT_LIKELY(pKrnlMods)) + { + rcNt = NtQuerySystemInformation(SystemModuleInformation, pKrnlMods, cbKrnlMods, NULL); + if (NT_SUCCESS(rcNt)) + *ppKrnlMods = pKrnlMods; + else + rc = RTErrConvertFromNtStatus(rcNt); + } + else + rc = VERR_NO_MEMORY; + } + else + rc = RTErrConvertFromNtStatus(rcNt); + + return rc; +} + +/** + * Creates a new kernel module information record for the given module. + * + * @returns IPRT status code. + * @param pModInfo The kernel module information. + * @param phKrnlModInfo Where to store the handle to the kernel module information record + * on success. + */ +static int rtKrnlModWinInfoCreate(PRTL_PROCESS_MODULE_INFORMATION pModInfo, PRTKRNLMODINFO phKrnlModInfo) +{ + int rc = VINF_SUCCESS; + RT_NOREF2(pModInfo, phKrnlModInfo); + size_t cchFilePath = strlen((const char *)&pModInfo->FullPathName[0]) + 1; + PRTKRNLMODINFOINT pThis = (PRTKRNLMODINFOINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTKRNLMODINFOINT, achFilePath[cchFilePath])); + if (RT_LIKELY(pThis)) + { + memcpy(&pThis->achFilePath[0], &pModInfo->FullPathName[0], cchFilePath); + pThis->cchFilePath = cchFilePath; + pThis->cRefs = 1; + pThis->cbKrnlMod = pModInfo->ImageSize; + pThis->uLoadAddr = (RTR0UINTPTR)pModInfo->ImageBase; + pThis->pszName = pModInfo->OffsetToFileName >= cchFilePath + ? NULL + : pThis->achFilePath + pModInfo->OffsetToFileName; + + *phKrnlModInfo = pThis; + } + else + rc = VERR_NO_MEMORY; + + return rc; +} + + +RTDECL(int) RTKrnlModQueryLoaded(const char *pszName, bool *pfLoaded) +{ + AssertPtrReturn(pszName, VERR_INVALID_POINTER); + AssertPtrReturn(pfLoaded, VERR_INVALID_POINTER); + + int rc = VERR_NOT_IMPLEMENTED; + + return rc; +} + + +RTDECL(int) RTKrnlModLoadedQueryInfo(const char *pszName, PRTKRNLMODINFO phKrnlModInfo) +{ + AssertPtrReturn(pszName, VERR_INVALID_POINTER); + AssertPtrReturn(phKrnlModInfo, VERR_INVALID_POINTER); + + int rc = VERR_NOT_IMPLEMENTED; + + return rc; +} + + +RTDECL(uint32_t) RTKrnlModLoadedGetCount(void) +{ + uint32_t cKrnlMods = 0; + RTL_PROCESS_MODULES ProcMods; + + NTSTATUS rcNt = NtQuerySystemInformation(SystemModuleInformation, &ProcMods, sizeof(ProcMods), NULL); + if (NT_SUCCESS(rcNt) || rcNt == STATUS_INFO_LENGTH_MISMATCH) + cKrnlMods = ProcMods.NumberOfModules; + + return cKrnlMods; +} + + +RTDECL(int) RTKrnlModLoadedQueryInfoAll(PRTKRNLMODINFO pahKrnlModInfo, uint32_t cEntriesMax, + uint32_t *pcEntries) +{ + AssertReturn(VALID_PTR(pahKrnlModInfo) || cEntriesMax == 0, VERR_INVALID_PARAMETER); + + PRTL_PROCESS_MODULES pKrnlMods = NULL; + int rc = rtKrnlModWinQueryKrnlMods(&pKrnlMods); + if (RT_SUCCESS(rc)) + { + if (pKrnlMods->NumberOfModules <= cEntriesMax) + { + for (unsigned i = 0; i < pKrnlMods->NumberOfModules; i++) + { + pKrnlMods->Modules[i].FullPathName[255] = '\0'; /* Paranoia */ + rc = rtKrnlModWinInfoCreate(&pKrnlMods->Modules[i], &pahKrnlModInfo[i]); + if (RT_FAILURE(rc)) + { + while (i-- > 0) + RTKrnlModInfoRelease(pahKrnlModInfo[i]); + break; + } + } + } + else + rc = VERR_BUFFER_OVERFLOW; + + if (pcEntries) + *pcEntries = pKrnlMods->NumberOfModules; + + RTMemFree(pKrnlMods); + } + + return rc; +} + + +RTDECL(uint32_t) RTKrnlModInfoRetain(RTKRNLMODINFO hKrnlModInfo) +{ + PRTKRNLMODINFOINT pThis = hKrnlModInfo; + AssertPtrReturn(pThis, UINT32_MAX); + + uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); + AssertMsg(cRefs > 1 && cRefs < _1M, ("%#x %p\n", cRefs, pThis)); + return cRefs; +} + + +RTDECL(uint32_t) RTKrnlModInfoRelease(RTKRNLMODINFO hKrnlModInfo) +{ + PRTKRNLMODINFOINT pThis = hKrnlModInfo; + if (!pThis) + return 0; + AssertPtrReturn(pThis, UINT32_MAX); + + uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs); + AssertMsg(cRefs < _1M, ("%#x %p\n", cRefs, pThis)); + if (cRefs == 0) + rtKrnlModInfoDestroy(pThis); + return cRefs; +} + + +RTDECL(uint32_t) RTKrnlModInfoGetRefCnt(RTKRNLMODINFO hKrnlModInfo) +{ + PRTKRNLMODINFOINT pThis = hKrnlModInfo; + AssertPtrReturn(pThis, 0); + + return pThis->cRefKrnlMod; +} + + +RTDECL(const char *) RTKrnlModInfoGetName(RTKRNLMODINFO hKrnlModInfo) +{ + PRTKRNLMODINFOINT pThis = hKrnlModInfo; + AssertPtrReturn(pThis, NULL); + + return pThis->pszName; +} + + +RTDECL(const char *) RTKrnlModInfoGetFilePath(RTKRNLMODINFO hKrnlModInfo) +{ + PRTKRNLMODINFOINT pThis = hKrnlModInfo; + AssertPtrReturn(pThis, NULL); + + return &pThis->achFilePath[0]; +} + + +RTDECL(size_t) RTKrnlModInfoGetSize(RTKRNLMODINFO hKrnlModInfo) +{ + PRTKRNLMODINFOINT pThis = hKrnlModInfo; + AssertPtrReturn(pThis, 0); + + return pThis->cbKrnlMod; +} + + +RTDECL(RTR0UINTPTR) RTKrnlModInfoGetLoadAddr(RTKRNLMODINFO hKrnlModInfo) +{ + PRTKRNLMODINFOINT pThis = hKrnlModInfo; + AssertPtrReturn(pThis, 0); + + return pThis->uLoadAddr; +} + + +RTDECL(int) RTKrnlModInfoQueryRefModInfo(RTKRNLMODINFO hKrnlModInfo, uint32_t idx, + PRTKRNLMODINFO phKrnlModInfoRef) +{ + RT_NOREF3(hKrnlModInfo, idx, phKrnlModInfoRef); + return VERR_NOT_SUPPORTED; +} diff --git a/src/VBox/Runtime/r3/win/ldrNative-win.cpp b/src/VBox/Runtime/r3/win/ldrNative-win.cpp new file mode 100644 index 00000000..fc3ea025 --- /dev/null +++ b/src/VBox/Runtime/r3/win/ldrNative-win.cpp @@ -0,0 +1,316 @@ +/* $Id: ldrNative-win.cpp $ */ +/** @file + * IPRT - Binary Image Loader, Win32 native. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_LDR +#include <iprt/nt/nt-and-windows.h> + +#include <iprt/ldr.h> +#include "internal/iprt.h" + +#include <iprt/alloca.h> +#include <iprt/assert.h> +#include <iprt/ctype.h> +#include <iprt/err.h> +#include <iprt/file.h> +#include <iprt/log.h> +#include <iprt/once.h> +#include <iprt/path.h> +#include <iprt/string.h> +#include <iprt/utf16.h> + +#include "internal/ldr.h" +#include "internal-r3-win.h" + +#ifndef LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR +# define LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR UINT32_C(0x100) +# define LOAD_LIBRARY_SEARCH_APPLICATION_DIR UINT32_C(0x200) +# define LOAD_LIBRARY_SEARCH_SYSTEM32 UINT32_C(0x800) +#endif + + +DECLHIDDEN(int) rtldrNativeLoad(const char *pszFilename, uintptr_t *phHandle, uint32_t fFlags, PRTERRINFO pErrInfo) +{ + Assert(sizeof(*phHandle) >= sizeof(HMODULE)); + AssertReturn(!(fFlags & RTLDRLOAD_FLAGS_GLOBAL), VERR_INVALID_FLAGS); + AssertLogRelMsgReturn(RTPathStartsWithRoot(pszFilename), /* Relative names will still be applied to the search path. */ + ("pszFilename='%s'\n", pszFilename), + VERR_INTERNAL_ERROR_2); + AssertReleaseMsg(g_hModKernel32, + ("rtldrNativeLoad(%s,,) is called before IPRT has configured the windows loader!\n", pszFilename)); + + /* + * Convert to UTF-16 and make sure it got a .DLL suffix. + */ + /** @todo Implement long path support for native DLL loading on windows. @bugref{9248} */ + int rc; + RTUTF16 *pwszNative = NULL; + if (RTPathHasSuffix(pszFilename) || (fFlags & RTLDRLOAD_FLAGS_NO_SUFFIX)) + rc = RTStrToUtf16(pszFilename, &pwszNative); + else + { + size_t cwcAlloc; + rc = RTStrCalcUtf16LenEx(pszFilename, RTSTR_MAX, &cwcAlloc); + if (RT_SUCCESS(rc)) + { + cwcAlloc += sizeof(".DLL"); + pwszNative = RTUtf16Alloc(cwcAlloc * sizeof(RTUTF16)); + if (pwszNative) + { + size_t cwcNative; + rc = RTStrToUtf16Ex(pszFilename, RTSTR_MAX, &pwszNative, cwcAlloc, &cwcNative); + if (RT_SUCCESS(rc)) + rc = RTUtf16CopyAscii(&pwszNative[cwcNative], cwcAlloc - cwcNative, ".DLL"); + } + else + rc = VERR_NO_UTF16_MEMORY; + } + } + if (RT_SUCCESS(rc)) + { + /* Convert slashes just to be on the safe side. */ + for (size_t off = 0;; off++) + { + RTUTF16 wc = pwszNative[off]; + if (wc == '/') + pwszNative[off] = '\\'; + else if (!wc) + break; + } + + /* + * Attempt load. + */ + HMODULE hmod; + static int s_iSearchDllLoadDirSupported = 0; + if ( !(fFlags & RTLDRLOAD_FLAGS_NT_SEARCH_DLL_LOAD_DIR) + || s_iSearchDllLoadDirSupported < 0) + hmod = LoadLibraryExW(pwszNative, NULL, 0); + else + { + hmod = LoadLibraryExW(pwszNative, NULL, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32 + | LOAD_LIBRARY_SEARCH_APPLICATION_DIR); + if (s_iSearchDllLoadDirSupported == 0) + { + if (hmod != NULL || GetLastError() != ERROR_INVALID_PARAMETER) + s_iSearchDllLoadDirSupported = 1; + else + { + s_iSearchDllLoadDirSupported = -1; + hmod = LoadLibraryExW(pwszNative, NULL, 0); + } + } + } + if (hmod) + { + *phHandle = (uintptr_t)hmod; + RTUtf16Free(pwszNative); + return VINF_SUCCESS; + } + + /* + * Try figure why it failed to load. + */ + DWORD dwErr = GetLastError(); + rc = RTErrConvertFromWin32(dwErr); + rc = RTErrInfoSetF(pErrInfo, rc, "GetLastError=%u", dwErr); + } + else + rc = RTErrInfoSetF(pErrInfo, rc, "Error converting UTF-8 to UTF-16 string."); + RTUtf16Free(pwszNative); + return rc; +} + + +DECLCALLBACK(int) rtldrNativeGetSymbol(PRTLDRMODINTERNAL pMod, const char *pszSymbol, void **ppvValue) +{ + PRTLDRMODNATIVE pModNative = (PRTLDRMODNATIVE)pMod; + FARPROC pfn = GetProcAddress((HMODULE)pModNative->hNative, pszSymbol); + if (pfn) + { + *ppvValue = (void *)pfn; + return VINF_SUCCESS; + } + *ppvValue = NULL; + return RTErrConvertFromWin32(GetLastError()); +} + + +DECLCALLBACK(int) rtldrNativeClose(PRTLDRMODINTERNAL pMod) +{ + PRTLDRMODNATIVE pModNative = (PRTLDRMODNATIVE)pMod; + if ( (pModNative->fFlags & RTLDRLOAD_FLAGS_NO_UNLOAD) + || FreeLibrary((HMODULE)pModNative->hNative)) + { + pModNative->hNative = (uintptr_t)INVALID_HANDLE_VALUE; + return VINF_SUCCESS; + } + return RTErrConvertFromWin32(GetLastError()); +} + + +DECLHIDDEN(int) rtldrNativeLoadSystem(const char *pszFilename, const char *pszExt, uint32_t fFlags, PRTLDRMOD phLdrMod) +{ + AssertReleaseMsg(g_hModKernel32, + ("rtldrNativeLoadSystem(%s,,) is called before IPRT has configured the windows loader!\n", pszFilename)); + + /* + * Resolve side-by-side resolver API. + */ + static bool volatile s_fInitialized = false; + static decltype(RtlDosApplyFileIsolationRedirection_Ustr) *s_pfnApplyRedir = NULL; + if (!s_fInitialized) + { + s_pfnApplyRedir = (decltype(s_pfnApplyRedir))GetProcAddress(g_hModNtDll, + "RtlDosApplyFileIsolationRedirection_Ustr"); + ASMCompilerBarrier(); + s_fInitialized = true; + } + + /* + * We try WinSxS via undocumented NTDLL API and flal back on the System32 + * directory. No other locations are supported. + */ + int rc = VERR_TRY_AGAIN; + char szPath[RTPATH_MAX]; + char *pszPath = szPath; + + /* Get the windows system32 directory so we can sanity check the WinSxS result. */ + WCHAR wszSysDir[MAX_PATH]; + UINT cwcSysDir = GetSystemDirectoryW(wszSysDir, MAX_PATH); + if (cwcSysDir >= MAX_PATH) + return VERR_FILENAME_TOO_LONG; + + /* Try side-by-side first (see COMCTL32.DLL). */ + if (s_pfnApplyRedir) + { + size_t cwcName = 0; + RTUTF16 wszName[MAX_PATH]; + PRTUTF16 pwszName = wszName; + int rc2 = RTStrToUtf16Ex(pszFilename, RTSTR_MAX, &pwszName, RT_ELEMENTS(wszName), &cwcName); + if (RT_SUCCESS(rc2)) + { + static UNICODE_STRING const s_DefaultSuffix = RTNT_CONSTANT_UNISTR(L".dll"); + WCHAR wszPath[MAX_PATH]; + UNICODE_STRING UniStrStatic = { 0, (USHORT)sizeof(wszPath) - sizeof(WCHAR), wszPath }; + UNICODE_STRING UniStrDynamic = { 0, 0, NULL }; + PUNICODE_STRING pUniStrResult = NULL; + UNICODE_STRING UniStrName = + { (USHORT)(cwcName * sizeof(RTUTF16)), (USHORT)((cwcName + 1) * sizeof(RTUTF16)), wszName }; + + NTSTATUS rcNt = s_pfnApplyRedir(1 /*fFlags*/, + &UniStrName, + (PUNICODE_STRING)&s_DefaultSuffix, + &UniStrStatic, + &UniStrDynamic, + &pUniStrResult, + NULL /*pNewFlags*/, + NULL /*pcbFilename*/, + NULL /*pcbNeeded*/); + if (NT_SUCCESS(rcNt)) + { + /* + * Check that the resolved path has similarities to the + * system directory. + * + * ASSUMES the windows directory is a root directory and + * that both System32 and are on the same level. So, we'll + * have 2 matching components (or more if the resolver + * returns a system32 path for some reason). + */ + unsigned cMatchingComponents = 0; + size_t off = 0; + while (off < pUniStrResult->Length) + { + RTUTF16 wc1 = wszSysDir[off]; + RTUTF16 wc2 = pUniStrResult->Buffer[off]; + if (!RTPATH_IS_SLASH(wc1)) + { + if (wc1 == wc2) + off++; + else if ( wc1 < 127 + && wc2 < 127 + && RT_C_TO_LOWER(wc1) == RT_C_TO_LOWER(wc2) ) + off++; + else + break; + } + else if (RTPATH_IS_SLASH(wc2)) + { + cMatchingComponents += off > 0; + do + off++; + while ( off < pUniStrResult->Length + && RTPATH_IS_SLASH(wszSysDir[off]) + && RTPATH_IS_SLASH(pUniStrResult->Buffer[off])); + } + else + break; + } + if (cMatchingComponents >= 2) + { + pszPath = szPath; + rc2 = RTUtf16ToUtf8Ex(pUniStrResult->Buffer, pUniStrResult->Length / sizeof(RTUTF16), + &pszPath, sizeof(szPath), NULL); + if (RT_SUCCESS(rc2)) + rc = VINF_SUCCESS; + } + else + AssertMsgFailed(("%s -> '%*.ls'\n", pszFilename, pUniStrResult->Length, pUniStrResult->Buffer)); + RtlFreeUnicodeString(&UniStrDynamic); + } + } + else + AssertMsgFailed(("%Rrc\n", rc)); + } + + /* If the above didn't succeed, create a system32 path. */ + if (RT_FAILURE(rc)) + { + 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); + } + } + + /* Do the actual loading, if we were successful constructing a name. */ + if (RT_SUCCESS(rc)) + { + if (RTFileExists(szPath)) + rc = RTLdrLoadEx(szPath, phLdrMod, fFlags, NULL); + else + rc = VERR_MODULE_NOT_FOUND; + } + + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/localipc-win.cpp b/src/VBox/Runtime/r3/win/localipc-win.cpp new file mode 100644 index 00000000..e4ce5274 --- /dev/null +++ b/src/VBox/Runtime/r3/win/localipc-win.cpp @@ -0,0 +1,1645 @@ +/* $Id: localipc-win.cpp $ */ +/** @file + * IPRT - Local IPC, Windows Implementation Using Named Pipes. + */ + +/* + * Copyright (C) 2008-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_LOCALIPC +/* + * We have to force NT 5.0 here because of + * ConvertStringSecurityDescriptorToSecurityDescriptor. Note that because of + * FILE_FLAG_FIRST_PIPE_INSTANCE this code actually requires W2K SP2+. + */ +#ifndef _WIN32_WINNT +# define _WIN32_WINNT 0x0500 /* for ConvertStringSecurityDescriptorToSecurityDescriptor */ +#elif _WIN32_WINNT < 0x0500 +# undef _WIN32_WINNT +# define _WIN32_WINNT 0x0500 +#endif +#define UNICODE /* For the SDDL_ strings. */ +#include <iprt/win/windows.h> +#include <sddl.h> + +#include "internal/iprt.h" +#include <iprt/localipc.h> + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/critsect.h> +#include <iprt/ctype.h> +#include <iprt/err.h> +#include <iprt/ldr.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/param.h> +#include <iprt/string.h> +#include <iprt/thread.h> +#include <iprt/time.h> +#include <iprt/utf16.h> + +#include "internal/magics.h" +#include "internal-r3-win.h" + + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Pipe prefix string. */ +#define RTLOCALIPC_WIN_PREFIX L"\\\\.\\pipe\\IPRT-" + +/** DACL for block all network access and local users other than the creator/owner. + * + * ACE format: (ace_type;ace_flags;rights;object_guid;inherit_object_guid;account_sid) + * + * Note! FILE_GENERIC_WRITE (SDDL_FILE_WRITE) is evil here because it includes + * the FILE_CREATE_PIPE_INSTANCE(=FILE_APPEND_DATA) flag. Thus the hardcoded + * value 0x0012019b in the client ACE. The server-side still needs + * setting FILE_CREATE_PIPE_INSTANCE although. + * It expands to: + * 0x00000001 - FILE_READ_DATA + * 0x00000008 - FILE_READ_EA + * 0x00000080 - FILE_READ_ATTRIBUTES + * 0x00020000 - READ_CONTROL + * 0x00100000 - SYNCHRONIZE + * 0x00000002 - FILE_WRITE_DATA + * 0x00000010 - FILE_WRITE_EA + * 0x00000100 - FILE_WRITE_ATTRIBUTES + * = 0x0012019b (client) + * + (only for server): + * 0x00000004 - FILE_CREATE_PIPE_INSTANCE + * = 0x0012019f + * + * @todo Triple check this! + * @todo EVERYONE -> AUTHENTICATED USERS or something more appropriate? + * @todo Have trouble allowing the owner FILE_CREATE_PIPE_INSTANCE access, so for now I'm hacking + * it just to get progress - the service runs as local system. + * The CREATOR OWNER and PERSONAL SELF works (the former is only involved in inheriting + * it seems, which is why it won't work. The latter I've no idea about. Perhaps the solution + * is to go the annoying route of OpenProcessToken, QueryTokenInformation, + * ConvertSidToStringSid and then use the result... Suggestions are very welcome + */ +#define RTLOCALIPC_WIN_SDDL_BASE \ + SDDL_DACL SDDL_DELIMINATOR \ + SDDL_ACE_BEGIN SDDL_ACCESS_DENIED L";;" SDDL_GENERIC_ALL L";;;" SDDL_NETWORK SDDL_ACE_END \ + SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";;" SDDL_FILE_ALL L";;;" SDDL_LOCAL_SYSTEM SDDL_ACE_END + +#define RTLOCALIPC_WIN_SDDL_SERVER \ + RTLOCALIPC_WIN_SDDL_BASE \ + SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";;" L"0x0012019f" L";;;" SDDL_EVERYONE SDDL_ACE_END + +#define RTLOCALIPC_WIN_SDDL_CLIENT \ + RTLOCALIPC_WIN_SDDL_BASE \ + SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";;" L"0x0012019b" L";;;" SDDL_EVERYONE SDDL_ACE_END + +// SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";;" SDDL_GENERIC_ALL L";;;" SDDL_PERSONAL_SELF SDDL_ACE_END \ +// SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";CIOI;" SDDL_GENERIC_ALL L";;;" SDDL_CREATOR_OWNER SDDL_ACE_END +// SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";;" L"0x0012019b" L";;;" SDDL_EVERYONE SDDL_ACE_END +// SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";;" SDDL_FILE_ALL L";;;" SDDL_LOCAL_SYSTEM SDDL_ACE_END + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * Local IPC service instance, Windows. + */ +typedef struct RTLOCALIPCSERVERINT +{ + /** The magic (RTLOCALIPCSERVER_MAGIC). */ + uint32_t u32Magic; + /** The creation flags. */ + uint32_t fFlags; + /** Critical section protecting the structure. */ + RTCRITSECT CritSect; + /** The number of references to the instance. + * @remarks The reference counting isn't race proof. */ + uint32_t volatile cRefs; + /** Indicates that there is a pending cancel request. */ + bool volatile fCancelled; + /** The named pipe handle. */ + HANDLE hNmPipe; + /** The handle to the event object we're using for overlapped I/O. */ + HANDLE hEvent; + /** The overlapped I/O structure. */ + OVERLAPPED OverlappedIO; + /** The full pipe name (variable length). */ + RTUTF16 wszName[1]; +} RTLOCALIPCSERVERINT; +/** Pointer to a local IPC server instance (Windows). */ +typedef RTLOCALIPCSERVERINT *PRTLOCALIPCSERVERINT; + + +/** + * Local IPC session instance, Windows. + * + * This is a named pipe and we should probably merge the pipe code with this to + * save work and code duplication. + */ +typedef struct RTLOCALIPCSESSIONINT +{ + /** The magic (RTLOCALIPCSESSION_MAGIC). */ + uint32_t u32Magic; + /** Critical section protecting the structure. */ + RTCRITSECT CritSect; + /** The number of references to the instance. + * @remarks The reference counting isn't race proof. */ + uint32_t volatile cRefs; + /** Set if the zero byte read that the poll code using is pending. */ + bool fZeroByteRead; + /** Indicates that there is a pending cancel request. */ + bool volatile fCancelled; + /** Set if this is the server side, clear if the client. */ + bool fServerSide; + /** The named pipe handle. */ + HANDLE hNmPipe; + struct + { + RTTHREAD hActiveThread; + /** The handle to the event object we're using for overlapped I/O. */ + HANDLE hEvent; + /** The overlapped I/O structure. */ + OVERLAPPED OverlappedIO; + } + /** Overlapped reads. */ + Read, + /** Overlapped writes. */ + Write; +#if 0 /* Non-blocking writes are not yet supported. */ + /** Bounce buffer for writes. */ + uint8_t *pbBounceBuf; + /** Amount of used buffer space. */ + size_t cbBounceBufUsed; + /** Amount of allocated buffer space. */ + size_t cbBounceBufAlloc; +#endif + /** Buffer for the zero byte read. + * Used in RTLocalIpcSessionWaitForData(). */ + uint8_t abBuf[8]; +} RTLOCALIPCSESSIONINT; +/** Pointer to a local IPC session instance (Windows). */ +typedef RTLOCALIPCSESSIONINT *PRTLOCALIPCSESSIONINT; + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int rtLocalIpcWinCreateSession(PRTLOCALIPCSESSIONINT *ppSession, HANDLE hNmPipeSession); + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +static bool volatile g_fResolvedApis = false; +/** advapi32.dll API ConvertStringSecurityDescriptorToSecurityDescriptorW. */ +static decltype(ConvertStringSecurityDescriptorToSecurityDescriptorW) *g_pfnSSDLToSecDescW = NULL; + + +/** + * Builds and allocates the security descriptor required for securing the local pipe. + * + * @return IPRT status code. + * @param ppDesc Where to store the allocated security descriptor on success. + * Must be free'd using LocalFree(). + * @param fServer Whether it's for a server or client instance. + */ +static int rtLocalIpcServerWinAllocSecurityDescriptior(PSECURITY_DESCRIPTOR *ppDesc, bool fServer) +{ + /* + * Resolve the API the first time around. + */ + if (!g_fResolvedApis) + { + g_pfnSSDLToSecDescW = (decltype(g_pfnSSDLToSecDescW))RTLdrGetSystemSymbol("advapi32.dll", "ConvertStringSecurityDescriptorToSecurityDescriptorW"); + ASMCompilerBarrier(); + g_fResolvedApis = true; + } + + int rc; + PSECURITY_DESCRIPTOR pSecDesc = NULL; + if (g_pfnSSDLToSecDescW) + { + /* + * We'll create a security descriptor from a SDDL that denies + * access to network clients (this is local IPC after all), it + * makes some further restrictions to prevent non-authenticated + * users from screwing around. + */ + PCRTUTF16 pwszSDDL = fServer ? RTLOCALIPC_WIN_SDDL_SERVER : RTLOCALIPC_WIN_SDDL_CLIENT; + if (g_pfnSSDLToSecDescW(pwszSDDL, SDDL_REVISION_1, &pSecDesc, NULL)) + { + AssertPtr(pSecDesc); + *ppDesc = pSecDesc; + return VINF_SUCCESS; + } + + rc = RTErrConvertFromWin32(GetLastError()); + } + else + { + /* Windows OSes < W2K SP2 not supported for now, bail out. */ + /** @todo Implement me! */ + rc = VERR_NOT_SUPPORTED; + } + return rc; +} + + +/** + * Creates a named pipe instance. + * + * This is used by both RTLocalIpcServerCreate and RTLocalIpcServerListen. + * + * @return IPRT status code. + * @param phNmPipe Where to store the named pipe handle on success. + * This will be set to INVALID_HANDLE_VALUE on failure. + * @param pwszPipeName The named pipe name, full, UTF-16 encoded. + * @param fFirst Set on the first call (from RTLocalIpcServerCreate), + * otherwise clear. Governs the + * FILE_FLAG_FIRST_PIPE_INSTANCE flag. + */ +static int rtLocalIpcServerWinCreatePipeInstance(PHANDLE phNmPipe, PCRTUTF16 pwszPipeName, bool fFirst) +{ + *phNmPipe = INVALID_HANDLE_VALUE; + + PSECURITY_DESCRIPTOR pSecDesc; + int rc = rtLocalIpcServerWinAllocSecurityDescriptior(&pSecDesc, fFirst /* Server? */); + if (RT_SUCCESS(rc)) + { + SECURITY_ATTRIBUTES SecAttrs; + SecAttrs.nLength = sizeof(SECURITY_ATTRIBUTES); + SecAttrs.lpSecurityDescriptor = pSecDesc; + SecAttrs.bInheritHandle = FALSE; + + DWORD fOpenMode = PIPE_ACCESS_DUPLEX + | PIPE_WAIT + | FILE_FLAG_OVERLAPPED; + if ( fFirst + && ( g_enmWinVer >= kRTWinOSType_XP + || ( g_enmWinVer == kRTWinOSType_2K + && g_WinOsInfoEx.wServicePackMajor >= 2) ) ) + fOpenMode |= FILE_FLAG_FIRST_PIPE_INSTANCE; /* Introduced with W2K SP2 */ + + HANDLE hNmPipe = CreateNamedPipeW(pwszPipeName, /* lpName */ + fOpenMode, /* dwOpenMode */ + PIPE_TYPE_BYTE, /* dwPipeMode */ + PIPE_UNLIMITED_INSTANCES, /* nMaxInstances */ + PAGE_SIZE, /* nOutBufferSize (advisory) */ + PAGE_SIZE, /* nInBufferSize (ditto) */ + 30*1000, /* nDefaultTimeOut = 30 sec */ + &SecAttrs); /* lpSecurityAttributes */ + LocalFree(pSecDesc); + if (hNmPipe != INVALID_HANDLE_VALUE) + *phNmPipe = hNmPipe; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + + return rc; +} + + +/** + * Validates the user specified name. + * + * @returns IPRT status code. + * @param pszName The name to validate. + * @param pcwcFullName Where to return the UTF-16 length of the full name. + * @param fNative Whether it's a native name or a portable name. + */ +static int rtLocalIpcWinValidateName(const char *pszName, size_t *pcwcFullName, bool fNative) +{ + AssertPtrReturn(pszName, VERR_INVALID_POINTER); + AssertReturn(*pszName, VERR_INVALID_NAME); + + if (!fNative) + { + size_t cwcName = RT_ELEMENTS(RTLOCALIPC_WIN_PREFIX) - 1; + for (;;) + { + char ch = *pszName++; + if (!ch) + break; + AssertReturn(!RT_C_IS_CNTRL(ch), VERR_INVALID_NAME); + AssertReturn((unsigned)ch < 0x80, VERR_INVALID_NAME); + AssertReturn(ch != '\\', VERR_INVALID_NAME); + AssertReturn(ch != '/', VERR_INVALID_NAME); + cwcName++; + } + *pcwcFullName = cwcName; + } + else + { + int rc = RTStrCalcUtf16LenEx(pszName, RTSTR_MAX, pcwcFullName); + AssertRCReturn(rc, rc); + } + + return VINF_SUCCESS; +} + + +/** + * Constructs the full pipe name as UTF-16. + * + * @returns IPRT status code. + * @param pszName The user supplied name. ASSUMES reasonable length + * for now, so no long path prefixing needed. + * @param pwszFullName The output buffer. + * @param cwcFullName The output buffer size excluding the terminator. + * @param fNative Whether the user supplied name is a native or + * portable one. + */ +static int rtLocalIpcWinConstructName(const char *pszName, PRTUTF16 pwszFullName, size_t cwcFullName, bool fNative) +{ + if (!fNative) + { + static RTUTF16 const s_wszPrefix[] = RTLOCALIPC_WIN_PREFIX; + Assert(cwcFullName * sizeof(RTUTF16) > sizeof(s_wszPrefix)); + memcpy(pwszFullName, s_wszPrefix, sizeof(s_wszPrefix)); + cwcFullName -= RT_ELEMENTS(s_wszPrefix) - 1; + pwszFullName += RT_ELEMENTS(s_wszPrefix) - 1; + } + return RTStrToUtf16Ex(pszName, RTSTR_MAX, &pwszFullName, cwcFullName + 1, NULL); +} + + +RTDECL(int) RTLocalIpcServerCreate(PRTLOCALIPCSERVER phServer, const char *pszName, uint32_t fFlags) +{ + /* + * Validate parameters. + */ + AssertPtrReturn(phServer, VERR_INVALID_POINTER); + *phServer = NIL_RTLOCALIPCSERVER; + AssertReturn(!(fFlags & ~RTLOCALIPC_FLAGS_VALID_MASK), VERR_INVALID_FLAGS); + size_t cwcFullName; + int rc = rtLocalIpcWinValidateName(pszName, &cwcFullName, RT_BOOL(fFlags & RTLOCALIPC_FLAGS_NATIVE_NAME)); + if (RT_SUCCESS(rc)) + { + /* + * Allocate and initialize the instance data. + */ + size_t cbThis = RT_UOFFSETOF_DYN(RTLOCALIPCSERVERINT, wszName[cwcFullName + 1]); + PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)RTMemAllocVar(cbThis); + AssertReturn(pThis, VERR_NO_MEMORY); + + pThis->u32Magic = RTLOCALIPCSERVER_MAGIC; + pThis->cRefs = 1; /* the one we return */ + pThis->fCancelled = false; + + rc = rtLocalIpcWinConstructName(pszName, pThis->wszName, cwcFullName, RT_BOOL(fFlags & RTLOCALIPC_FLAGS_NATIVE_NAME)); + if (RT_SUCCESS(rc)) + { + rc = RTCritSectInit(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + pThis->hEvent = CreateEvent(NULL /*lpEventAttributes*/, TRUE /*bManualReset*/, + FALSE /*bInitialState*/, NULL /*lpName*/); + if (pThis->hEvent != NULL) + { + RT_ZERO(pThis->OverlappedIO); + pThis->OverlappedIO.Internal = STATUS_PENDING; + pThis->OverlappedIO.hEvent = pThis->hEvent; + + rc = rtLocalIpcServerWinCreatePipeInstance(&pThis->hNmPipe, pThis->wszName, true /* fFirst */); + if (RT_SUCCESS(rc)) + { + *phServer = pThis; + return VINF_SUCCESS; + } + + BOOL fRc = CloseHandle(pThis->hEvent); + AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + int rc2 = RTCritSectDelete(&pThis->CritSect); + AssertRC(rc2); + } + } + RTMemFree(pThis); + } + return rc; +} + + +/** + * Retains a reference to the server instance. + * + * @returns + * @param pThis The server instance. + */ +DECLINLINE(void) rtLocalIpcServerRetain(PRTLOCALIPCSERVERINT pThis) +{ + uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); + Assert(cRefs < UINT32_MAX / 2 && cRefs); NOREF(cRefs); +} + + +/** + * Call when the reference count reaches 0. + * + * Caller owns the critsect. + * + * @returns VINF_OBJECT_DESTROYED + * @param pThis The instance to destroy. + */ +DECL_NO_INLINE(static, int) rtLocalIpcServerWinDestroy(PRTLOCALIPCSERVERINT pThis) +{ + Assert(pThis->u32Magic == ~RTLOCALIPCSERVER_MAGIC); + pThis->u32Magic = ~RTLOCALIPCSERVER_MAGIC; + + BOOL fRc = CloseHandle(pThis->hNmPipe); + AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc); + pThis->hNmPipe = INVALID_HANDLE_VALUE; + + fRc = CloseHandle(pThis->hEvent); + AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc); + pThis->hEvent = NULL; + + RTCritSectLeave(&pThis->CritSect); + RTCritSectDelete(&pThis->CritSect); + + RTMemFree(pThis); + return VINF_OBJECT_DESTROYED; +} + + +/** + * Server instance destructor. + * + * @returns VINF_OBJECT_DESTROYED + * @param pThis The server instance. + */ +DECL_NO_INLINE(static, int) rtLocalIpcServerDtor(PRTLOCALIPCSERVERINT pThis) +{ + RTCritSectEnter(&pThis->CritSect); + return rtLocalIpcServerWinDestroy(pThis); +} + + +/** + * Releases a reference to the server instance. + * + * @returns VINF_SUCCESS if only release, VINF_OBJECT_DESTROYED if destroyed. + * @param pThis The server instance. + */ +DECLINLINE(int) rtLocalIpcServerRelease(PRTLOCALIPCSERVERINT pThis) +{ + uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs); + Assert(cRefs < UINT32_MAX / 2); + if (!cRefs) + return rtLocalIpcServerDtor(pThis); + return VINF_SUCCESS; +} + + +/** + * Releases a reference to the server instance and leaves the critsect. + * + * @returns VINF_SUCCESS if only release, VINF_OBJECT_DESTROYED if destroyed. + * @param pThis The server instance. + */ +DECLINLINE(int) rtLocalIpcServerReleaseAndUnlock(PRTLOCALIPCSERVERINT pThis) +{ + uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs); + Assert(cRefs < UINT32_MAX / 2); + if (!cRefs) + return rtLocalIpcServerWinDestroy(pThis); + return RTCritSectLeave(&pThis->CritSect); +} + + + +RTDECL(int) RTLocalIpcServerDestroy(RTLOCALIPCSERVER hServer) +{ + /* + * Validate input. + */ + if (hServer == NIL_RTLOCALIPCSERVER) + return VINF_SUCCESS; + PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)hServer; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSERVER_MAGIC, VERR_INVALID_HANDLE); + + /* + * Cancel any thread currently busy using the server, + * leaving the cleanup to it. + */ + AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTLOCALIPCSERVER_MAGIC, RTLOCALIPCSERVER_MAGIC), VERR_WRONG_ORDER); + + RTCritSectEnter(&pThis->CritSect); + + /* Cancel everything. */ + ASMAtomicUoWriteBool(&pThis->fCancelled, true); + if (pThis->cRefs > 1) + { + BOOL fRc = SetEvent(pThis->hEvent); + AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc); + } + + return rtLocalIpcServerReleaseAndUnlock(pThis); +} + + +RTDECL(int) RTLocalIpcServerListen(RTLOCALIPCSERVER hServer, PRTLOCALIPCSESSION phClientSession) +{ + /* + * Validate input. + */ + PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)hServer; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSERVER_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(phClientSession, VERR_INVALID_POINTER); + + /* + * Enter the critsect before inspecting the object further. + */ + int rc = RTCritSectEnter(&pThis->CritSect); + AssertRCReturn(rc, rc); + + rtLocalIpcServerRetain(pThis); + if (!pThis->fCancelled) + { + ResetEvent(pThis->hEvent); + + RTCritSectLeave(&pThis->CritSect); + + /* + * Try connect a client. We need to use overlapped I/O here because + * of the cancellation done by RTLocalIpcServerCancel and RTLocalIpcServerDestroy. + */ + SetLastError(NO_ERROR); + BOOL fRc = ConnectNamedPipe(pThis->hNmPipe, &pThis->OverlappedIO); + DWORD dwErr = fRc ? NO_ERROR : GetLastError(); + if ( !fRc + && dwErr == ERROR_IO_PENDING) + { + WaitForSingleObject(pThis->hEvent, INFINITE); + DWORD dwIgnored; + fRc = GetOverlappedResult(pThis->hNmPipe, &pThis->OverlappedIO, &dwIgnored, FALSE /* bWait*/); + dwErr = fRc ? NO_ERROR : GetLastError(); + } + + RTCritSectEnter(&pThis->CritSect); + if ( !pThis->fCancelled /* Event signalled but not cancelled? */ + && pThis->u32Magic == RTLOCALIPCSERVER_MAGIC) + { + /* + * Still alive, some error or an actual client. + * + * If it's the latter we'll have to create a new pipe instance that + * replaces the current one for the server. The current pipe instance + * will be assigned to the client session. + */ + if ( fRc + || dwErr == ERROR_PIPE_CONNECTED) + { + HANDLE hNmPipe; + rc = rtLocalIpcServerWinCreatePipeInstance(&hNmPipe, pThis->wszName, false /* fFirst */); + if (RT_SUCCESS(rc)) + { + HANDLE hNmPipeSession = pThis->hNmPipe; /* consumed */ + pThis->hNmPipe = hNmPipe; + rc = rtLocalIpcWinCreateSession(phClientSession, hNmPipeSession); + } + else + { + /* + * We failed to create a new instance for the server, disconnect + * the client and fail. Don't try service the client here. + */ + fRc = DisconnectNamedPipe(pThis->hNmPipe); + AssertMsg(fRc, ("%d\n", GetLastError())); + } + } + else + rc = RTErrConvertFromWin32(dwErr); + } + else + { + /* + * Cancelled. + * + * Cancel the overlapped io if it didn't complete (must be done + * in the this thread) or disconnect the client. + */ + Assert(pThis->fCancelled); + if ( fRc + || dwErr == ERROR_PIPE_CONNECTED) + fRc = DisconnectNamedPipe(pThis->hNmPipe); + else if (dwErr == ERROR_IO_PENDING) + fRc = CancelIo(pThis->hNmPipe); + else + fRc = TRUE; + AssertMsg(fRc, ("%d\n", GetLastError())); + rc = VERR_CANCELLED; + } + } + else + { + /*pThis->fCancelled = false; - Terrible interface idea. Add API to clear fCancelled if ever required. */ + rc = VERR_CANCELLED; + } + rtLocalIpcServerReleaseAndUnlock(pThis); + return rc; +} + + +RTDECL(int) RTLocalIpcServerCancel(RTLOCALIPCSERVER hServer) +{ + /* + * Validate input. + */ + PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)hServer; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSERVER_MAGIC, VERR_INVALID_HANDLE); + + /* + * Enter the critical section, then set the cancellation flag + * and signal the event (to wake up anyone in/at WaitForSingleObject). + */ + rtLocalIpcServerRetain(pThis); + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + ASMAtomicUoWriteBool(&pThis->fCancelled, true); + + BOOL fRc = SetEvent(pThis->hEvent); + if (fRc) + rc = VINF_SUCCESS; + else + { + DWORD dwErr = GetLastError(); + AssertMsgFailed(("dwErr=%u\n", dwErr)); + rc = RTErrConvertFromWin32(dwErr); + } + + rtLocalIpcServerReleaseAndUnlock(pThis); + } + else + rtLocalIpcServerRelease(pThis); + return rc; +} + + +/** + * Create a session instance for a new server client or a client connect. + * + * @returns IPRT status code. + * + * @param ppSession Where to store the session handle on success. + * @param hNmPipeSession The named pipe handle if server calling, + * INVALID_HANDLE_VALUE if client connect. This will + * be consumed by this session, meaning on failure to + * create the session it will be closed. + */ +static int rtLocalIpcWinCreateSession(PRTLOCALIPCSESSIONINT *ppSession, HANDLE hNmPipeSession) +{ + AssertPtr(ppSession); + + /* + * Allocate and initialize the session instance data. + */ + int rc; + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)RTMemAllocZ(sizeof(*pThis)); + if (pThis) + { + pThis->u32Magic = RTLOCALIPCSESSION_MAGIC; + pThis->cRefs = 1; /* our ref */ + pThis->fCancelled = false; + pThis->fZeroByteRead = false; + pThis->fServerSide = hNmPipeSession != INVALID_HANDLE_VALUE; + pThis->hNmPipe = hNmPipeSession; +#if 0 /* Non-blocking writes are not yet supported. */ + pThis->pbBounceBuf = NULL; + pThis->cbBounceBufAlloc = 0; + pThis->cbBounceBufUsed = 0; +#endif + rc = RTCritSectInit(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + pThis->Read.hEvent = CreateEvent(NULL /*lpEventAttributes*/, TRUE /*bManualReset*/, + FALSE /*bInitialState*/, NULL /*lpName*/); + if (pThis->Read.hEvent != NULL) + { + pThis->Read.OverlappedIO.Internal = STATUS_PENDING; + pThis->Read.OverlappedIO.hEvent = pThis->Read.hEvent; + pThis->Read.hActiveThread = NIL_RTTHREAD; + + pThis->Write.hEvent = CreateEvent(NULL /*lpEventAttributes*/, TRUE /*bManualReset*/, + FALSE /*bInitialState*/, NULL /*lpName*/); + if (pThis->Write.hEvent != NULL) + { + pThis->Write.OverlappedIO.Internal = STATUS_PENDING; + pThis->Write.OverlappedIO.hEvent = pThis->Write.hEvent; + pThis->Write.hActiveThread = NIL_RTTHREAD; + + *ppSession = pThis; + return VINF_SUCCESS; + } + + CloseHandle(pThis->Read.hEvent); + } + + /* bail out */ + rc = RTErrConvertFromWin32(GetLastError()); + RTCritSectDelete(&pThis->CritSect); + } + RTMemFree(pThis); + } + else + rc = VERR_NO_MEMORY; + + if (hNmPipeSession != INVALID_HANDLE_VALUE) + { + BOOL fRc = CloseHandle(hNmPipeSession); + AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc); + } + return rc; +} + + +RTDECL(int) RTLocalIpcSessionConnect(PRTLOCALIPCSESSION phSession, const char *pszName, uint32_t fFlags) +{ + /* + * Validate input. + */ + AssertPtrReturn(phSession, VERR_INVALID_POINTER); + AssertReturn(!(fFlags & ~RTLOCALIPC_C_FLAGS_VALID_MASK), VERR_INVALID_FLAGS); + + size_t cwcFullName; + int rc = rtLocalIpcWinValidateName(pszName, &cwcFullName, RT_BOOL(fFlags & RTLOCALIPC_C_FLAGS_NATIVE_NAME)); + if (RT_SUCCESS(rc)) + { + /* + * Create a session (shared with server client session creation). + */ + PRTLOCALIPCSESSIONINT pThis; + rc = rtLocalIpcWinCreateSession(&pThis, INVALID_HANDLE_VALUE); + if (RT_SUCCESS(rc)) + { + /* + * Try open the pipe. + */ + PSECURITY_DESCRIPTOR pSecDesc; + rc = rtLocalIpcServerWinAllocSecurityDescriptior(&pSecDesc, false /*fServer*/); + if (RT_SUCCESS(rc)) + { + PRTUTF16 pwszFullName = RTUtf16Alloc((cwcFullName + 1) * sizeof(RTUTF16)); + if (pwszFullName) + rc = rtLocalIpcWinConstructName(pszName, pwszFullName, cwcFullName, + RT_BOOL(fFlags & RTLOCALIPC_C_FLAGS_NATIVE_NAME)); + else + rc = VERR_NO_UTF16_MEMORY; + if (RT_SUCCESS(rc)) + { + SECURITY_ATTRIBUTES SecAttrs; + SecAttrs.nLength = sizeof(SECURITY_ATTRIBUTES); + SecAttrs.lpSecurityDescriptor = pSecDesc; + SecAttrs.bInheritHandle = FALSE; + + HANDLE hPipe = CreateFileW(pwszFullName, + GENERIC_READ | GENERIC_WRITE, + 0 /*no sharing*/, + &SecAttrs, + OPEN_EXISTING, + FILE_FLAG_OVERLAPPED, + NULL /*no template handle*/); + if (hPipe != INVALID_HANDLE_VALUE) + { + pThis->hNmPipe = hPipe; + + LocalFree(pSecDesc); + RTUtf16Free(pwszFullName); + + /* + * We're done! + */ + *phSession = pThis; + return VINF_SUCCESS; + } + + rc = RTErrConvertFromWin32(GetLastError()); + } + + RTUtf16Free(pwszFullName); + LocalFree(pSecDesc); + } + + /* destroy the session handle. */ + CloseHandle(pThis->Read.hEvent); + CloseHandle(pThis->Write.hEvent); + RTCritSectDelete(&pThis->CritSect); + + RTMemFree(pThis); + } + } + return rc; +} + + +/** + * Cancells all pending I/O operations, forcing the methods to return with + * VERR_CANCELLED (unless they've got actual data to return). + * + * Used by RTLocalIpcSessionCancel and RTLocalIpcSessionClose. + * + * @returns IPRT status code. + * @param pThis The client session instance. + */ +static int rtLocalIpcWinCancel(PRTLOCALIPCSESSIONINT pThis) +{ + ASMAtomicUoWriteBool(&pThis->fCancelled, true); + + /* + * Call CancelIo since this call cancels both read and write oriented operations. + */ + if ( pThis->fZeroByteRead + || pThis->Read.hActiveThread != NIL_RTTHREAD + || pThis->Write.hActiveThread != NIL_RTTHREAD) + CancelIo(pThis->hNmPipe); + + /* + * Set both event semaphores. + */ + BOOL fRc = SetEvent(pThis->Read.hEvent); + AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc); + fRc = SetEvent(pThis->Write.hEvent); + AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc); + + return VINF_SUCCESS; +} + + +/** + * Retains a reference to the session instance. + * + * @param pThis The client session instance. + */ +DECLINLINE(void) rtLocalIpcSessionRetain(PRTLOCALIPCSESSIONINT pThis) +{ + uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); + Assert(cRefs < UINT32_MAX / 2 && cRefs); NOREF(cRefs); +} + + +RTDECL(uint32_t) RTLocalIpcSessionRetain(RTLOCALIPCSESSION hSession) +{ + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession; + AssertPtrReturn(pThis, UINT32_MAX); + AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, UINT32_MAX); + + uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); + Assert(cRefs < UINT32_MAX / 2 && cRefs); + return cRefs; +} + + +/** + * Call when the reference count reaches 0. + * + * Caller owns the critsect. + * + * @returns VINF_OBJECT_DESTROYED + * @param pThis The instance to destroy. + */ +DECL_NO_INLINE(static, int) rtLocalIpcSessionWinDestroy(PRTLOCALIPCSESSIONINT pThis) +{ + BOOL fRc = CloseHandle(pThis->hNmPipe); + AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc); + pThis->hNmPipe = INVALID_HANDLE_VALUE; + + fRc = CloseHandle(pThis->Write.hEvent); + AssertMsg(fRc, ("%d\n", GetLastError())); + pThis->Write.hEvent = NULL; + + fRc = CloseHandle(pThis->Read.hEvent); + AssertMsg(fRc, ("%d\n", GetLastError())); + pThis->Read.hEvent = NULL; + + int rc2 = RTCritSectLeave(&pThis->CritSect); AssertRC(rc2); + RTCritSectDelete(&pThis->CritSect); + + RTMemFree(pThis); + return VINF_OBJECT_DESTROYED; +} + + +/** + * Releases a reference to the session instance and unlock it. + * + * @returns VINF_SUCCESS or VINF_OBJECT_DESTROYED as appropriate. + * @param pThis The session instance. + */ +DECLINLINE(int) rtLocalIpcSessionReleaseAndUnlock(PRTLOCALIPCSESSIONINT pThis) +{ + uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs); + Assert(cRefs < UINT32_MAX / 2); + if (!cRefs) + return rtLocalIpcSessionWinDestroy(pThis); + + int rc2 = RTCritSectLeave(&pThis->CritSect); AssertRC(rc2); + Log(("rtLocalIpcSessionReleaseAndUnlock: %u refs left\n", cRefs)); + return VINF_SUCCESS; +} + + +RTDECL(uint32_t) RTLocalIpcSessionRelease(RTLOCALIPCSESSION hSession) +{ + if (hSession == NIL_RTLOCALIPCSESSION) + return 0; + + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession; + AssertPtrReturn(pThis, UINT32_MAX); + AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, UINT32_MAX); + + uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs); + Assert(cRefs < UINT32_MAX / 2); + if (cRefs) + Log(("RTLocalIpcSessionRelease: %u refs left\n", cRefs)); + else + { + RTCritSectEnter(&pThis->CritSect); + rtLocalIpcSessionWinDestroy(pThis); + } + return cRefs; +} + + +RTDECL(int) RTLocalIpcSessionClose(RTLOCALIPCSESSION hSession) +{ + /* + * Validate input. + */ + if (hSession == NIL_RTLOCALIPCSESSION) + return VINF_SUCCESS; + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE); + + /* + * Invalidate the instance, cancel all outstanding I/O and drop our reference. + */ + RTCritSectEnter(&pThis->CritSect); + rtLocalIpcWinCancel(pThis); + return rtLocalIpcSessionReleaseAndUnlock(pThis); +} + + +/** + * Handles WaitForSingleObject return value when waiting for a zero byte read. + * + * The zero byte read is started by the RTLocalIpcSessionWaitForData method and + * left pending when the function times out. This saves us the problem of + * CancelIo messing with all active I/O operations and the trouble of restarting + * the zero byte read the next time the method is called. However should + * RTLocalIpcSessionRead be called after a failed RTLocalIpcSessionWaitForData + * call, the zero byte read will still be pending and it must wait for it to + * complete before the OVERLAPPEDIO structure can be reused. + * + * Thus, both functions will do WaitForSingleObject and share this routine to + * handle the outcome. + * + * @returns IPRT status code. + * @param pThis The session instance. + * @param rcWait The WaitForSingleObject return code. + */ +static int rtLocalIpcWinGetZeroReadResult(PRTLOCALIPCSESSIONINT pThis, DWORD rcWait) +{ + int rc; + DWORD cbRead = 42; + if (rcWait == WAIT_OBJECT_0) + { + if (GetOverlappedResult(pThis->hNmPipe, &pThis->Read.OverlappedIO, &cbRead, !pThis->fCancelled /*fWait*/)) + { + Assert(cbRead == 0); + rc = VINF_SUCCESS; + pThis->fZeroByteRead = false; + } + else if (pThis->fCancelled) + rc = VERR_CANCELLED; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + { + /* We try get the result here too, just in case we're lucky, but no waiting. */ + DWORD dwErr = GetLastError(); + if (GetOverlappedResult(pThis->hNmPipe, &pThis->Read.OverlappedIO, &cbRead, FALSE /*fWait*/)) + { + Assert(cbRead == 0); + rc = VINF_SUCCESS; + pThis->fZeroByteRead = false; + } + else if (rcWait == WAIT_TIMEOUT) + rc = VERR_TIMEOUT; + else if (rcWait == WAIT_ABANDONED) + rc = VERR_INVALID_HANDLE; + else + rc = RTErrConvertFromWin32(dwErr); + } + return rc; +} + + +RTDECL(int) RTLocalIpcSessionRead(RTLOCALIPCSESSION hSession, void *pvBuf, size_t cbToRead, size_t *pcbRead) +{ + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pvBuf, VERR_INVALID_POINTER); + /* pcbRead is optional. */ + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + rtLocalIpcSessionRetain(pThis); + if (pThis->Read.hActiveThread == NIL_RTTHREAD) + { + pThis->Read.hActiveThread = RTThreadSelf(); + + size_t cbTotalRead = 0; + while (cbToRead > 0) + { + DWORD cbRead = 0; + if (!pThis->fCancelled) + { + /* + * Wait for pending zero byte read, if necessary. + * Note! It cannot easily be cancelled due to concurrent current writes. + */ + if (!pThis->fZeroByteRead) + { /* likely */ } + else + { + RTCritSectLeave(&pThis->CritSect); + DWORD rcWait = WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, RT_MS_1MIN); + RTCritSectEnter(&pThis->CritSect); + + rc = rtLocalIpcWinGetZeroReadResult(pThis, rcWait); + if (RT_SUCCESS(rc) || rc == VERR_TIMEOUT) + continue; + break; + } + + /* + * Kick of a an overlapped read. It should return immediately if + * there is bytes in the buffer. If not, we'll cancel it and see + * what we get back. + */ + rc = ResetEvent(pThis->Read.OverlappedIO.hEvent); Assert(rc == TRUE); + RTCritSectLeave(&pThis->CritSect); + + if (ReadFile(pThis->hNmPipe, pvBuf, + cbToRead <= ~(DWORD)0 ? (DWORD)cbToRead : ~(DWORD)0, + &cbRead, &pThis->Read.OverlappedIO)) + { + RTCritSectEnter(&pThis->CritSect); + rc = VINF_SUCCESS; + } + else if (GetLastError() == ERROR_IO_PENDING) + { + WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, INFINITE); + + RTCritSectEnter(&pThis->CritSect); + if (GetOverlappedResult(pThis->hNmPipe, &pThis->Read.OverlappedIO, &cbRead, TRUE /*fWait*/)) + rc = VINF_SUCCESS; + else + { + if (pThis->fCancelled) + rc = VERR_CANCELLED; + else + rc = RTErrConvertFromWin32(GetLastError()); + break; + } + } + else + { + rc = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailedBreak(("%Rrc\n", rc)); + } + } + else + { + rc = VERR_CANCELLED; + break; + } + + /* Advance. */ + cbToRead -= cbRead; + cbTotalRead += cbRead; + pvBuf = (uint8_t *)pvBuf + cbRead; + } + + if (pcbRead) + { + *pcbRead = cbTotalRead; + if ( RT_FAILURE(rc) + && cbTotalRead + && rc != VERR_INVALID_POINTER) + rc = VINF_SUCCESS; + } + + pThis->Read.hActiveThread = NIL_RTTHREAD; + } + else + rc = VERR_WRONG_ORDER; + rtLocalIpcSessionReleaseAndUnlock(pThis); + } + + return rc; +} + + +RTDECL(int) RTLocalIpcSessionReadNB(RTLOCALIPCSESSION hSession, void *pvBuf, size_t cbToRead, size_t *pcbRead) +{ + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pvBuf, VERR_INVALID_POINTER); + AssertPtrReturn(pcbRead, VERR_INVALID_POINTER); + *pcbRead = 0; + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + rtLocalIpcSessionRetain(pThis); + if (pThis->Read.hActiveThread == NIL_RTTHREAD) + { + pThis->Read.hActiveThread = RTThreadSelf(); + + for (;;) + { + DWORD cbRead = 0; + if (!pThis->fCancelled) + { + /* + * Wait for pending zero byte read, if necessary. + * Note! It cannot easily be cancelled due to concurrent current writes. + */ + if (!pThis->fZeroByteRead) + { /* likely */ } + else + { + RTCritSectLeave(&pThis->CritSect); + DWORD rcWait = WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, 0); + RTCritSectEnter(&pThis->CritSect); + + rc = rtLocalIpcWinGetZeroReadResult(pThis, rcWait); + if (RT_SUCCESS(rc)) + continue; + + if (rc == VERR_TIMEOUT) + rc = VINF_TRY_AGAIN; + break; + } + + /* + * Figure out how much we can read (cannot try and cancel here + * like in the anonymous pipe code). + */ + DWORD cbAvailable; + if (PeekNamedPipe(pThis->hNmPipe, NULL, 0, NULL, &cbAvailable, NULL)) + { + if (cbAvailable == 0 || cbToRead == 0) + { + *pcbRead = 0; + rc = VINF_TRY_AGAIN; + break; + } + } + else + { + rc = RTErrConvertFromWin32(GetLastError()); + break; + } + if (cbAvailable > cbToRead) + cbAvailable = (DWORD)cbToRead; + + /* + * Kick of a an overlapped read. It should return immediately, so we + * don't really need to leave the critsect here. + */ + rc = ResetEvent(pThis->Read.OverlappedIO.hEvent); Assert(rc == TRUE); + if (ReadFile(pThis->hNmPipe, pvBuf, cbAvailable, &cbRead, &pThis->Read.OverlappedIO)) + { + *pcbRead = cbRead; + rc = VINF_SUCCESS; + } + else if (GetLastError() == ERROR_IO_PENDING) + { + DWORD rcWait = WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, 0); + if (rcWait == WAIT_TIMEOUT) + { + RTCritSectLeave(&pThis->CritSect); + rcWait = WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, INFINITE); + RTCritSectEnter(&pThis->CritSect); + } + if (GetOverlappedResult(pThis->hNmPipe, &pThis->Read.OverlappedIO, &cbRead, TRUE /*fWait*/)) + { + *pcbRead = cbRead; + rc = VINF_SUCCESS; + } + else + { + if (pThis->fCancelled) + rc = VERR_CANCELLED; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + } + else + { + rc = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailedBreak(("%Rrc\n", rc)); + } + } + else + rc = VERR_CANCELLED; + break; + } + + pThis->Read.hActiveThread = NIL_RTTHREAD; + } + else + rc = VERR_WRONG_ORDER; + rtLocalIpcSessionReleaseAndUnlock(pThis); + } + + return rc; +} + + +#if 0 /* Non-blocking writes are not yet supported. */ +/** + * Common worker for handling I/O completion. + * + * This is used by RTLocalIpcSessionClose and RTLocalIpcSessionWrite. + * + * @returns IPRT status code. + * @param pThis The pipe instance handle. + */ +static int rtLocalIpcSessionWriteCheckCompletion(PRTLOCALIPCSESSIONINT pThis) +{ + int rc; + DWORD rcWait = WaitForSingleObject(pThis->OverlappedIO.hEvent, 0); + if (rcWait == WAIT_OBJECT_0) + { + DWORD cbWritten = 0; + if (GetOverlappedResult(pThis->hNmPipe, &pThis->OverlappedIO, &cbWritten, TRUE)) + { + for (;;) + { + if (cbWritten >= pThis->cbBounceBufUsed) + { + pThis->fIOPending = false; + rc = VINF_SUCCESS; + break; + } + + /* resubmit the remainder of the buffer - can this actually happen? */ + memmove(&pThis->pbBounceBuf[0], &pThis->pbBounceBuf[cbWritten], pThis->cbBounceBufUsed - cbWritten); + rc = ResetEvent(pThis->OverlappedIO.hEvent); Assert(rc == TRUE); + if (!WriteFile(pThis->hNmPipe, pThis->pbBounceBuf, (DWORD)pThis->cbBounceBufUsed, + &cbWritten, &pThis->OverlappedIO)) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_IO_PENDING) + rc = VINF_TRY_AGAIN; + else + { + pThis->fIOPending = false; + if (dwErr == ERROR_NO_DATA) + rc = VERR_BROKEN_PIPE; + else + rc = RTErrConvertFromWin32(dwErr); + } + break; + } + Assert(cbWritten > 0); + } + } + else + { + pThis->fIOPending = false; + rc = RTErrConvertFromWin32(GetLastError()); + } + } + else if (rcWait == WAIT_TIMEOUT) + rc = VINF_TRY_AGAIN; + else + { + pThis->fIOPending = false; + if (rcWait == WAIT_ABANDONED) + rc = VERR_INVALID_HANDLE; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + return rc; +} +#endif + + +RTDECL(int) RTLocalIpcSessionWrite(RTLOCALIPCSESSION hSession, const void *pvBuf, size_t cbToWrite) +{ + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pvBuf, VERR_INVALID_POINTER); + AssertReturn(cbToWrite, VERR_INVALID_PARAMETER); + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + rtLocalIpcSessionRetain(pThis); + if (pThis->Write.hActiveThread == NIL_RTTHREAD) + { + pThis->Write.hActiveThread = RTThreadSelf(); + + /* + * Try write everything. No bounce buffering necessary. + */ + size_t cbTotalWritten = 0; + while (cbToWrite > 0) + { + DWORD cbWritten = 0; + if (!pThis->fCancelled) + { + BOOL fRc = ResetEvent(pThis->Write.OverlappedIO.hEvent); Assert(fRc == TRUE); + RTCritSectLeave(&pThis->CritSect); + + DWORD const cbToWriteInThisIteration = cbToWrite <= ~(DWORD)0 ? (DWORD)cbToWrite : ~(DWORD)0; + fRc = WriteFile(pThis->hNmPipe, pvBuf, cbToWriteInThisIteration, &cbWritten, &pThis->Write.OverlappedIO); + if (fRc) + rc = VINF_SUCCESS; + else + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_IO_PENDING) + { + DWORD rcWait = WaitForSingleObject(pThis->Write.OverlappedIO.hEvent, INFINITE); + if (rcWait == WAIT_OBJECT_0) + { + if (GetOverlappedResult(pThis->hNmPipe, &pThis->Write.OverlappedIO, &cbWritten, TRUE /*fWait*/)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else if (rcWait == WAIT_TIMEOUT) + rc = VERR_TIMEOUT; + else if (rcWait == WAIT_ABANDONED) + rc = VERR_INVALID_HANDLE; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else if (dwErr == ERROR_NO_DATA) + rc = VERR_BROKEN_PIPE; + else + rc = RTErrConvertFromWin32(dwErr); + } + + if (cbWritten > cbToWriteInThisIteration) /* paranoia^3 */ + cbWritten = cbToWriteInThisIteration; + + RTCritSectEnter(&pThis->CritSect); + if (RT_FAILURE(rc)) + break; + } + else + { + rc = VERR_CANCELLED; + break; + } + + /* Advance. */ + pvBuf = (char const *)pvBuf + cbWritten; + cbTotalWritten += cbWritten; + cbToWrite -= cbWritten; + } + + pThis->Write.hActiveThread = NIL_RTTHREAD; + } + else + rc = VERR_WRONG_ORDER; + rtLocalIpcSessionReleaseAndUnlock(pThis); + } + + return rc; +} + + +RTDECL(int) RTLocalIpcSessionFlush(RTLOCALIPCSESSION hSession) +{ + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE); + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + if (pThis->Write.hActiveThread == NIL_RTTHREAD) + { + /* No flushing on Windows needed since RTLocalIpcSessionWrite will block until + * all data was written (or an error occurred). */ + /** @todo r=bird: above comment is misinformed. + * Implement this as soon as we want an explicit asynchronous version of + * RTLocalIpcSessionWrite on Windows. */ + rc = VINF_SUCCESS; + } + else + rc = VERR_WRONG_ORDER; + RTCritSectLeave(&pThis->CritSect); + } + return rc; +} + + +RTDECL(int) RTLocalIpcSessionWaitForData(RTLOCALIPCSESSION hSession, uint32_t cMillies) +{ + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE); + + uint64_t const msStart = RTTimeMilliTS(); + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + rtLocalIpcSessionRetain(pThis); + if (pThis->Read.hActiveThread == NIL_RTTHREAD) + { + pThis->Read.hActiveThread = RTThreadSelf(); + + /* + * Wait loop. + */ + for (unsigned iLoop = 0;; iLoop++) + { + /* + * Check for cancellation before we continue. + */ + if (!pThis->fCancelled) + { /* likely */ } + else + { + rc = VERR_CANCELLED; + break; + } + + /* + * Prep something we can wait on. + */ + HANDLE hWait = INVALID_HANDLE_VALUE; + if (pThis->fZeroByteRead) + hWait = pThis->Read.OverlappedIO.hEvent; + else + { + /* Peek at the pipe buffer and see how many bytes it contains. */ + DWORD cbAvailable; + if ( PeekNamedPipe(pThis->hNmPipe, NULL, 0, NULL, &cbAvailable, NULL) + && cbAvailable) + { + rc = VINF_SUCCESS; + break; + } + + /* Start a zero byte read operation that we can wait on. */ + if (cMillies == 0) + { + rc = VERR_TIMEOUT; + break; + } + BOOL fRc = ResetEvent(pThis->Read.OverlappedIO.hEvent); Assert(fRc == TRUE); NOREF(fRc); + DWORD cbRead = 0; + if (ReadFile(pThis->hNmPipe, pThis->abBuf, 0 /*cbToRead*/, &cbRead, &pThis->Read.OverlappedIO)) + { + rc = VINF_SUCCESS; + if (iLoop > 10) + RTThreadYield(); + } + else if (GetLastError() == ERROR_IO_PENDING) + { + pThis->fZeroByteRead = true; + hWait = pThis->Read.OverlappedIO.hEvent; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + if (RT_FAILURE(rc)) + break; + } + + /* + * Check for timeout. + */ + DWORD cMsMaxWait = INFINITE; /* (MSC maybe used uninitialized) */ + if (cMillies == RT_INDEFINITE_WAIT) + cMsMaxWait = INFINITE; + else if ( hWait != INVALID_HANDLE_VALUE + || iLoop > 10) + { + uint64_t cMsElapsed = RTTimeMilliTS() - msStart; + if (cMsElapsed <= cMillies) + cMsMaxWait = cMillies - (uint32_t)cMsElapsed; + else if (iLoop == 0) + cMsMaxWait = cMillies ? 1 : 0; + else + { + rc = VERR_TIMEOUT; + break; + } + } + + /* + * Wait and collect the result. + */ + if (hWait != INVALID_HANDLE_VALUE) + { + RTCritSectLeave(&pThis->CritSect); + + DWORD rcWait = WaitForSingleObject(hWait, cMsMaxWait); + + int rc2 = RTCritSectEnter(&pThis->CritSect); + AssertRC(rc2); + + rc = rtLocalIpcWinGetZeroReadResult(pThis, rcWait); + break; + } + } + + pThis->Read.hActiveThread = NIL_RTTHREAD; + } + + rtLocalIpcSessionReleaseAndUnlock(pThis); + } + + return rc; +} + + +RTDECL(int) RTLocalIpcSessionCancel(RTLOCALIPCSESSION hSession) +{ + PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE); + + /* + * Enter the critical section, then set the cancellation flag + * and signal the event (to wake up anyone in/at WaitForSingleObject). + */ + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + rtLocalIpcSessionRetain(pThis); + rc = rtLocalIpcWinCancel(pThis); + rtLocalIpcSessionReleaseAndUnlock(pThis); + } + + return rc; +} + + +RTDECL(int) RTLocalIpcSessionQueryProcess(RTLOCALIPCSESSION hSession, PRTPROCESS pProcess) +{ + RT_NOREF_PV(hSession); RT_NOREF_PV(pProcess); + return VERR_NOT_SUPPORTED; +} + + +RTDECL(int) RTLocalIpcSessionQueryUserId(RTLOCALIPCSESSION hSession, PRTUID pUid) +{ + RT_NOREF_PV(hSession); RT_NOREF_PV(pUid); + return VERR_NOT_SUPPORTED; +} + + +RTDECL(int) RTLocalIpcSessionQueryGroupId(RTLOCALIPCSESSION hSession, PRTGID pGid) +{ + RT_NOREF_PV(hSession); RT_NOREF_PV(pGid); + return VERR_NOT_SUPPORTED; +} + diff --git a/src/VBox/Runtime/r3/win/mp-win.cpp b/src/VBox/Runtime/r3/win/mp-win.cpp new file mode 100644 index 00000000..94a75099 --- /dev/null +++ b/src/VBox/Runtime/r3/win/mp-win.cpp @@ -0,0 +1,811 @@ +/* $Id: mp-win.cpp $ */ +/** @file + * IPRT - Multiprocessor, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_SYSTEM +#include <iprt/win/windows.h> + +#include <iprt/mp.h> +#include "internal/iprt.h" + +#include <iprt/assert.h> +#include <iprt/cpuset.h> +#include <iprt/ldr.h> +#include <iprt/mem.h> +#include <iprt/once.h> +#include <iprt/param.h> +#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64) +# include <iprt/asm-amd64-x86.h> +#endif +#if defined(VBOX) && !defined(IN_GUEST) && !defined(IN_RT_STATIC) +# include <VBox/sup.h> +# define IPRT_WITH_GIP_MP_INFO +#else +# undef IPRT_WITH_GIP_MP_INFO +#endif + +#include "internal-r3-win.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** @def RTMPWIN_UPDATE_GIP_GLOBALS + * Does lazy (re-)initialization using information provieded by GIP. */ +#ifdef IPRT_WITH_GIP_MP_INFO +# define RTMPWIN_UPDATE_GIP_GLOBALS() \ + do { RTMPWIN_UPDATE_GIP_GLOBALS_AND_GET_PGIP(); } while (0) +#else +# define RTMPWIN_UPDATE_GIP_GLOBALS() do { } while (0) +#endif + +/** @def RTMPWIN_UPDATE_GIP_GLOBALS_AND_GET_PGIP + * Does lazy (re-)initialization using information provieded by GIP and + * declare and initalize a pGip local variable. */ +#ifdef IPRT_WITH_GIP_MP_INFO +#define RTMPWIN_UPDATE_GIP_GLOBALS_AND_GET_PGIP() \ + PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage; \ + if (pGip) \ + { \ + if ( pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC \ + && RTOnce(&g_MpInitOnceGip, rtMpWinInitOnceGip, NULL) == VINF_SUCCESS) \ + { \ + if (g_cRtMpWinActiveCpus >= pGip->cOnlineCpus) \ + { /* likely */ } \ + else \ + rtMpWinRefreshGip(); \ + } \ + else \ + pGip = NULL; \ + } else do { } while (0) +#else +# define RTMPWIN_UPDATE_GIP_GLOBALS_AND_GET_PGIP() do { } while (0) +#endif + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Initialize once. */ +static RTONCE g_MpInitOnce = RTONCE_INITIALIZER; +#ifdef IPRT_WITH_GIP_MP_INFO +/** Initialize once using GIP. */ +static RTONCE g_MpInitOnceGip = RTONCE_INITIALIZER; +#endif + +static decltype(GetMaximumProcessorCount) *g_pfnGetMaximumProcessorCount; +//static decltype(GetActiveProcessorCount) *g_pfnGetActiveProcessorCount; +static decltype(GetCurrentProcessorNumber) *g_pfnGetCurrentProcessorNumber; +static decltype(GetCurrentProcessorNumberEx) *g_pfnGetCurrentProcessorNumberEx; +static decltype(GetLogicalProcessorInformation) *g_pfnGetLogicalProcessorInformation; +static decltype(GetLogicalProcessorInformationEx) *g_pfnGetLogicalProcessorInformationEx; + + +/** The required buffer size for getting group relations. */ +static uint32_t g_cbRtMpWinGrpRelBuf; +/** The max number of CPUs (RTMpGetCount). */ +static uint32_t g_cRtMpWinMaxCpus; +/** The max number of CPU cores (RTMpGetCoreCount). */ +static uint32_t g_cRtMpWinMaxCpuCores; +/** The max number of groups. */ +static uint32_t g_cRtMpWinMaxCpuGroups; +/** The number of active CPUs the last time we checked. */ +static uint32_t volatile g_cRtMpWinActiveCpus; +/** Static per group info. + * @remarks With RTCPUSET_MAX_CPUS as 256, this takes up 33KB. + * @sa g_aRtMpNtCpuGroups */ +static struct +{ + /** The max CPUs in the group. */ + uint16_t cMaxCpus; + /** The number of active CPUs at the time of initialization. */ + uint16_t cActiveCpus; + /** CPU set indexes for each CPU in the group. */ + int16_t aidxCpuSetMembers[64]; +} g_aRtMpWinCpuGroups[RTCPUSET_MAX_CPUS]; +/** Maps CPU set indexes to RTCPUID. + * @sa g_aidRtMpNtByCpuSetIdx */ +RTCPUID g_aidRtMpWinByCpuSetIdx[RTCPUSET_MAX_CPUS]; + + +/** + * @callback_method_impl{FNRTONCE, + * Resolves dynamic imports and initializes globals.} + */ +static DECLCALLBACK(int32_t) rtMpWinInitOnce(void *pvUser) +{ + RT_NOREF(pvUser); + + Assert(g_WinOsInfoEx.dwOSVersionInfoSize != 0); + Assert(g_hModKernel32 != NULL); + + /* + * Resolve dynamic APIs. + */ +#define RESOLVE_API(a_szMod, a_FnName) \ + do { \ + RT_CONCAT(g_pfn,a_FnName) = (decltype(a_FnName) *)GetProcAddress(g_hModKernel32, #a_FnName); \ + } while (0) + RESOLVE_API("kernel32.dll", GetMaximumProcessorCount); + //RESOLVE_API("kernel32.dll", GetActiveProcessorCount); - slow :/ + RESOLVE_API("kernel32.dll", GetCurrentProcessorNumber); + RESOLVE_API("kernel32.dll", GetCurrentProcessorNumberEx); + RESOLVE_API("kernel32.dll", GetLogicalProcessorInformation); + RESOLVE_API("kernel32.dll", GetLogicalProcessorInformationEx); + + /* + * Reset globals. + */ + for (unsigned i = 0; i < RT_ELEMENTS(g_aidRtMpWinByCpuSetIdx); i++) + g_aidRtMpWinByCpuSetIdx[i] = NIL_RTCPUID; + for (unsigned idxGroup = 0; idxGroup < RT_ELEMENTS(g_aRtMpWinCpuGroups); idxGroup++) + { + g_aRtMpWinCpuGroups[idxGroup].cMaxCpus = 0; + g_aRtMpWinCpuGroups[idxGroup].cActiveCpus = 0; + for (unsigned idxMember = 0; idxMember < RT_ELEMENTS(g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers); idxMember++) + g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers[idxMember] = -1; + } + + /* + * Query group information, partitioning CPU IDs and CPU set indexes. + * + * We ASSUME the GroupInfo index is the same as the group number. + * + * We CANNOT ASSUME that the kernel CPU indexes are assigned in any given + * way, though they usually are in group order by active processor. So, + * we do that to avoid trouble. We must use information provided thru GIP + * if we want the kernel CPU set indexes. Even there, the inactive CPUs + * wont have sensible indexes. Sigh. + * + * We try to assign IDs to inactive CPUs in the same manner as mp-r0drv-nt.cpp + * + * Note! We will die (AssertFatal) if there are too many processors! + */ + union + { + SYSTEM_INFO SysInfo; + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Info; + uint8_t abPaddingG[ sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX) + + sizeof(PROCESSOR_GROUP_INFO) * RTCPUSET_MAX_CPUS]; + uint8_t abPaddingC[ sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX) + + (sizeof(PROCESSOR_RELATIONSHIP) + sizeof(GROUP_AFFINITY)) + * RTCPUSET_MAX_CPUS]; + } uBuf; + if (g_pfnGetLogicalProcessorInformationEx) + { + /* Query the information. */ + DWORD cbData = sizeof(uBuf); + AssertFatalMsg(g_pfnGetLogicalProcessorInformationEx(RelationGroup, &uBuf.Info, &cbData) != FALSE, + ("last error = %u, cbData = %u (in %u)\n", GetLastError(), cbData, sizeof(uBuf))); + AssertFatalMsg(uBuf.Info.Relationship == RelationGroup, + ("Relationship = %u, expected %u!\n", uBuf.Info.Relationship, RelationGroup)); + AssertFatalMsg(uBuf.Info.Group.MaximumGroupCount <= RT_ELEMENTS(g_aRtMpWinCpuGroups), + ("MaximumGroupCount is %u, we only support up to %u!\n", + uBuf.Info.Group.MaximumGroupCount, RT_ELEMENTS(g_aRtMpWinCpuGroups))); + + AssertMsg(uBuf.Info.Group.MaximumGroupCount == uBuf.Info.Group.ActiveGroupCount, /* 2nd assumption mentioned above. */ + ("%u vs %u\n", uBuf.Info.Group.MaximumGroupCount, uBuf.Info.Group.ActiveGroupCount)); + AssertFatal(uBuf.Info.Group.MaximumGroupCount >= uBuf.Info.Group.ActiveGroupCount); + + g_cRtMpWinMaxCpuGroups = uBuf.Info.Group.MaximumGroupCount; + + /* Count max cpus (see mp-r0drv0-nt.cpp) why we don't use GetMaximumProcessorCount(ALL). */ + uint32_t idxGroup; + g_cRtMpWinMaxCpus = 0; + for (idxGroup = 0; idxGroup < uBuf.Info.Group.ActiveGroupCount; idxGroup++) + g_cRtMpWinMaxCpus += uBuf.Info.Group.GroupInfo[idxGroup].MaximumProcessorCount; + + /* Process the active groups. */ + uint32_t cActive = 0; + uint32_t cInactive = 0; + uint32_t idxCpu = 0; + uint32_t idxCpuSetNextInactive = g_cRtMpWinMaxCpus - 1; + for (idxGroup = 0; idxGroup < uBuf.Info.Group.ActiveGroupCount; idxGroup++) + { + PROCESSOR_GROUP_INFO const *pGroupInfo = &uBuf.Info.Group.GroupInfo[idxGroup]; + g_aRtMpWinCpuGroups[idxGroup].cMaxCpus = pGroupInfo->MaximumProcessorCount; + g_aRtMpWinCpuGroups[idxGroup].cActiveCpus = pGroupInfo->ActiveProcessorCount; + for (uint32_t idxMember = 0; idxMember < pGroupInfo->MaximumProcessorCount; idxMember++) + { + if (pGroupInfo->ActiveProcessorMask & RT_BIT_64(idxMember)) + { + g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers[idxMember] = idxCpu; + g_aidRtMpWinByCpuSetIdx[idxCpu] = idxCpu; + idxCpu++; + cActive++; + } + else + { + if (idxCpuSetNextInactive >= idxCpu) + { + g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers[idxMember] = idxCpuSetNextInactive; + g_aidRtMpWinByCpuSetIdx[idxCpuSetNextInactive] = idxCpuSetNextInactive; + idxCpuSetNextInactive--; + } + cInactive++; + } + } + } + g_cRtMpWinActiveCpus = cActive; + Assert(cActive + cInactive <= g_cRtMpWinMaxCpus); + Assert(idxCpu <= idxCpuSetNextInactive + 1); + Assert(idxCpu <= g_cRtMpWinMaxCpus); + + /* Just in case the 2nd assumption doesn't hold true and there are inactive groups. */ + for (; idxGroup < uBuf.Info.Group.MaximumGroupCount; idxGroup++) + { + DWORD cMaxMembers = g_pfnGetMaximumProcessorCount(idxGroup); + g_aRtMpWinCpuGroups[idxGroup].cMaxCpus = cMaxMembers; + g_aRtMpWinCpuGroups[idxGroup].cActiveCpus = 0; + for (uint32_t idxMember = 0; idxMember < cMaxMembers; idxMember++) + { + if (idxCpuSetNextInactive >= idxCpu) + { + g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers[idxMember] = idxCpuSetNextInactive; + g_aidRtMpWinByCpuSetIdx[idxCpuSetNextInactive] = idxCpuSetNextInactive; + idxCpuSetNextInactive--; + } + cInactive++; + } + } + Assert(cActive + cInactive <= g_cRtMpWinMaxCpus); + Assert(idxCpu <= idxCpuSetNextInactive + 1); + } + else + { + /* Legacy: */ + GetSystemInfo(&uBuf.SysInfo); + g_cRtMpWinMaxCpuGroups = 1; + g_cRtMpWinMaxCpus = uBuf.SysInfo.dwNumberOfProcessors; + g_aRtMpWinCpuGroups[0].cMaxCpus = uBuf.SysInfo.dwNumberOfProcessors; + g_aRtMpWinCpuGroups[0].cActiveCpus = uBuf.SysInfo.dwNumberOfProcessors; + + for (uint32_t idxMember = 0; idxMember < uBuf.SysInfo.dwNumberOfProcessors; idxMember++) + { + g_aRtMpWinCpuGroups[0].aidxCpuSetMembers[idxMember] = idxMember; + g_aidRtMpWinByCpuSetIdx[idxMember] = idxMember; + } + } + + AssertFatalMsg(g_cRtMpWinMaxCpus <= RTCPUSET_MAX_CPUS, + ("g_cRtMpWinMaxCpus=%u (%#x); RTCPUSET_MAX_CPUS=%u\n", g_cRtMpWinMaxCpus, g_cRtMpWinMaxCpus, RTCPUSET_MAX_CPUS)); + + g_cbRtMpWinGrpRelBuf = sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX) + + (g_cRtMpWinMaxCpuGroups + 2) * sizeof(PROCESSOR_GROUP_INFO); + + /* + * Get information about cores. + * + * Note! This will only give us info about active processors according to + * MSDN, we'll just have to hope that CPUs aren't hotplugged after we + * initialize here (or that the API consumers doesn't care too much). + */ + /** @todo A hot CPU plug event would be nice. */ + g_cRtMpWinMaxCpuCores = g_cRtMpWinMaxCpus; + if (g_pfnGetLogicalProcessorInformationEx) + { + /* Query the information. */ + DWORD cbData = sizeof(uBuf); + AssertFatalMsg(g_pfnGetLogicalProcessorInformationEx(RelationProcessorCore, &uBuf.Info, &cbData) != FALSE, + ("last error = %u, cbData = %u (in %u)\n", GetLastError(), cbData, sizeof(uBuf))); + g_cRtMpWinMaxCpuCores = 0; + for (uint32_t off = 0; off < cbData; ) + { + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *pCur = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *)&uBuf.abPaddingG[off]; + AssertFatalMsg(pCur->Relationship == RelationProcessorCore, + ("off = %#x, Relationship = %u, expected %u!\n", off, pCur->Relationship, RelationProcessorCore)); + g_cRtMpWinMaxCpuCores++; + off += pCur->Size; + } + +#if ARCH_BITS == 32 + if (g_cRtMpWinMaxCpuCores > g_cRtMpWinMaxCpus) + { + /** @todo WOW64 trouble where the emulation environment has folded the high + * processor masks (63..32) into the low (31..0), hiding some + * processors from us. Currently we don't deal with that. */ + g_cRtMpWinMaxCpuCores = g_cRtMpWinMaxCpus; + } + else + AssertStmt(g_cRtMpWinMaxCpuCores > 0, g_cRtMpWinMaxCpuCores = g_cRtMpWinMaxCpus); +#else + AssertStmt(g_cRtMpWinMaxCpuCores > 0 && g_cRtMpWinMaxCpuCores <= g_cRtMpWinMaxCpus, + g_cRtMpWinMaxCpuCores = g_cRtMpWinMaxCpus); +#endif + } + else + { + /* + * Sadly, on XP and Server 2003, even if the API is present, it does not tell us + * how many physical cores there are (any package will look like a single core). + * That is worse than not using the API at all, so just skip it unless it's Vista+. + */ + if ( g_pfnGetLogicalProcessorInformation + && g_WinOsInfoEx.dwPlatformId == VER_PLATFORM_WIN32_NT + && g_WinOsInfoEx.dwMajorVersion >= 6) + { + /* Query the info. */ + DWORD cbSysProcInfo = _4K; + PSYSTEM_LOGICAL_PROCESSOR_INFORMATION paSysInfo = NULL; + BOOL fRc = FALSE; + do + { + cbSysProcInfo = RT_ALIGN_32(cbSysProcInfo, 256); + void *pv = RTMemRealloc(paSysInfo, cbSysProcInfo); + if (!pv) + break; + paSysInfo = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)pv; + fRc = g_pfnGetLogicalProcessorInformation(paSysInfo, &cbSysProcInfo); + } while (!fRc && GetLastError() == ERROR_INSUFFICIENT_BUFFER); + if (fRc) + { + /* Count the cores in the result. */ + g_cRtMpWinMaxCpuCores = 0; + uint32_t i = cbSysProcInfo / sizeof(paSysInfo[0]); + while (i-- > 0) + if (paSysInfo[i].Relationship == RelationProcessorCore) + g_cRtMpWinMaxCpuCores++; + + AssertStmt(g_cRtMpWinMaxCpuCores > 0 && g_cRtMpWinMaxCpuCores <= g_cRtMpWinMaxCpus, + g_cRtMpWinMaxCpuCores = g_cRtMpWinMaxCpus); + } + RTMemFree(paSysInfo); + } + } + + return VINF_SUCCESS; +} + + +#ifdef IPRT_WITH_GIP_MP_INFO +/** + * @callback_method_impl{FNRTONCE, Updates globals with information from GIP.} + */ +static DECLCALLBACK(int32_t) rtMpWinInitOnceGip(void *pvUser) +{ + RT_NOREF(pvUser); + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + + PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage; + if ( pGip + && pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC) + { + /* + * Update globals. + */ + if (g_cRtMpWinMaxCpus != pGip->cPossibleCpus) + g_cRtMpWinMaxCpus = pGip->cPossibleCpus; + if (g_cRtMpWinActiveCpus != pGip->cOnlineCpus) + g_cRtMpWinActiveCpus = pGip->cOnlineCpus; + Assert(g_cRtMpWinMaxCpuGroups == pGip->cPossibleCpuGroups); + if (g_cRtMpWinMaxCpuGroups != pGip->cPossibleCpuGroups) + { + g_cRtMpWinMaxCpuGroups = pGip->cPossibleCpuGroups; + g_cbRtMpWinGrpRelBuf = sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX) + + (g_cRtMpWinMaxCpuGroups + 2) * sizeof(PROCESSOR_GROUP_INFO); + } + + /* + * Update CPU set IDs. + */ + for (unsigned i = g_cRtMpWinMaxCpus; i < RT_ELEMENTS(g_aidRtMpWinByCpuSetIdx); i++) + g_aidRtMpWinByCpuSetIdx[i] = NIL_RTCPUID; + + unsigned const cbGip = pGip->cPages * PAGE_SIZE; + for (uint32_t idxGroup = 0; idxGroup < g_cRtMpWinMaxCpus; idxGroup++) + { + uint32_t idxMember; + unsigned offCpuGroup = pGip->aoffCpuGroup[idxGroup]; + if (offCpuGroup < cbGip) + { + PSUPGIPCPUGROUP pGipCpuGrp = (PSUPGIPCPUGROUP)((uintptr_t)pGip + offCpuGroup); + uint32_t cMaxMembers = pGipCpuGrp->cMaxMembers; + AssertStmt(cMaxMembers < RT_ELEMENTS(g_aRtMpWinCpuGroups[0].aidxCpuSetMembers), + cMaxMembers = RT_ELEMENTS(g_aRtMpWinCpuGroups[0].aidxCpuSetMembers)); + g_aRtMpWinCpuGroups[idxGroup].cMaxCpus = cMaxMembers; + g_aRtMpWinCpuGroups[idxGroup].cActiveCpus = RT_MIN(pGipCpuGrp->cMembers, cMaxMembers); + + for (idxMember = 0; idxMember < cMaxMembers; idxMember++) + { + int16_t idxSet = pGipCpuGrp->aiCpuSetIdxs[idxMember]; + g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers[idxMember] = idxSet; + if ((unsigned)idxSet < RT_ELEMENTS(g_aidRtMpWinByCpuSetIdx)) +# ifdef IPRT_WITH_RTCPUID_AS_GROUP_AND_NUMBER + g_aidRtMpWinByCpuSetIdx[idxSet] = RTMPCPUID_FROM_GROUP_AND_NUMBER(idxGroup, idxMember); +# else + g_aidRtMpWinByCpuSetIdx[idxSet] = idxSet; +# endif + } + } + else + idxMember = 0; + for (; idxMember < RT_ELEMENTS(g_aRtMpWinCpuGroups[0].aidxCpuSetMembers); idxMember++) + g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers[idxMember] = -1; + } + } + + return VINF_SUCCESS; +} + + +/** + * Refreshes globals from GIP after one or more CPUs were added. + * + * There are potential races here. We might race other threads and we may race + * more CPUs being added. + */ +static void rtMpWinRefreshGip(void) +{ + PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage; + if ( pGip + && pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC) + { + /* + * Since CPUs cannot be removed, we only have to update the IDs and + * indexes of CPUs that we think are inactive and the group member counts. + */ + for (;;) + { + unsigned const cbGip = pGip->cPages * PAGE_SIZE; + uint32_t const cGipActiveCpus = pGip->cOnlineCpus; + uint32_t const cMyActiveCpus = ASMAtomicReadU32(&g_cRtMpWinActiveCpus); + ASMCompilerBarrier(); + + for (uint32_t idxGroup = 0; idxGroup < g_cRtMpWinMaxCpus; idxGroup++) + { + unsigned offCpuGroup = pGip->aoffCpuGroup[idxGroup]; + if (offCpuGroup < cbGip) + { + PSUPGIPCPUGROUP pGipCpuGrp = (PSUPGIPCPUGROUP)((uintptr_t)pGip + offCpuGroup); + uint32_t cMaxMembers = pGipCpuGrp->cMaxMembers; + AssertStmt(cMaxMembers < RT_ELEMENTS(g_aRtMpWinCpuGroups[0].aidxCpuSetMembers), + cMaxMembers = RT_ELEMENTS(g_aRtMpWinCpuGroups[0].aidxCpuSetMembers)); + for (uint32_t idxMember = g_aRtMpWinCpuGroups[idxGroup].cActiveCpus; idxMember < cMaxMembers; idxMember++) + { + int16_t idxSet = pGipCpuGrp->aiCpuSetIdxs[idxMember]; + g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers[idxMember] = idxSet; + if ((unsigned)idxSet < RT_ELEMENTS(g_aidRtMpWinByCpuSetIdx)) +# ifdef IPRT_WITH_RTCPUID_AS_GROUP_AND_NUMBER + g_aidRtMpWinByCpuSetIdx[idxSet] = RTMPCPUID_FROM_GROUP_AND_NUMBER(idxGroup, idxMember); +# else + g_aidRtMpWinByCpuSetIdx[idxSet] = idxSet; +# endif + } + g_aRtMpWinCpuGroups[idxGroup].cMaxCpus = RT_MIN(pGipCpuGrp->cMembers, cMaxMembers); + g_aRtMpWinCpuGroups[idxGroup].cActiveCpus = RT_MIN(pGipCpuGrp->cMembers, cMaxMembers); + } + else + Assert(g_aRtMpWinCpuGroups[idxGroup].cActiveCpus == 0); + } + + ASMCompilerBarrier(); + if (cGipActiveCpus == pGip->cOnlineCpus) + if (ASMAtomicCmpXchgU32(&g_cRtMpWinActiveCpus, cGipActiveCpus, cMyActiveCpus)) + break; + } + } +} + +#endif /* IPRT_WITH_GIP_MP_INFO */ + + +/* + * Conversion between CPU ID and set index. + */ + +RTDECL(int) RTMpCpuIdToSetIndex(RTCPUID idCpu) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + +#ifdef IPRT_WITH_RTCPUID_AS_GROUP_AND_NUMBER + if (idCpu != NIL_RTCPUID) + return RTMpSetIndexFromCpuGroupMember(rtMpCpuIdGetGroup(idCpu), rtMpCpuIdGetGroupMember(idCpu)); + return -1; + +#else + /* 1:1 mapping, just do range checking. */ + return idCpu < g_cRtMpWinMaxCpus ? idCpu : -1; +#endif +} + + +RTDECL(RTCPUID) RTMpCpuIdFromSetIndex(int iCpu) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + + if ((unsigned)iCpu < RT_ELEMENTS(g_aidRtMpWinByCpuSetIdx)) + { + RTCPUID idCpu = g_aidRtMpWinByCpuSetIdx[iCpu]; + +#if defined(IPRT_WITH_RTCPUID_AS_GROUP_AND_NUMBER) && defined(RT_STRICT) + /* Check the correctness of the mapping table. */ + RTCPUID idCpuGip = NIL_RTCPUID; + if ( pGip + && (unsigned)iCpu < RT_ELEMENTS(pGip->aiCpuFromCpuSetIdx)) + { + unsigned idxSupCpu = pGip->aiCpuFromCpuSetIdx[idxGuess]; + if (idxSupCpu < pGip->cCpus) + if (pGip->aCPUs[idxSupCpu].enmState != SUPGIPCPUSTATE_INVALID) + idCpuGip = pGip->aCPUs[idxSupCpu].idCpu; + } + AssertMsg(idCpu == idCpuGip, ("table:%#x gip:%#x\n", idCpu, idCpuGip)); +#endif + + return idCpu; + } + return NIL_RTCPUID; +} + + +RTDECL(int) RTMpSetIndexFromCpuGroupMember(uint32_t idxGroup, uint32_t idxMember) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + + if (idxGroup < g_cRtMpWinMaxCpuGroups) + if (idxMember < g_aRtMpWinCpuGroups[idxGroup].cMaxCpus) + return g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers[idxMember]; + return -1; +} + + +RTDECL(uint32_t) RTMpGetCpuGroupCounts(uint32_t idxGroup, uint32_t *pcActive) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + + if (idxGroup < g_cRtMpWinMaxCpuGroups) + { + if (pcActive) + *pcActive = g_aRtMpWinCpuGroups[idxGroup].cActiveCpus; + return g_aRtMpWinCpuGroups[idxGroup].cMaxCpus; + } + if (pcActive) + *pcActive = 0; + return 0; +} + + +RTDECL(uint32_t) RTMpGetMaxCpuGroupCount(void) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + + return g_cRtMpWinMaxCpuGroups; +} + + + +/* + * Get current CPU. + */ + +RTDECL(RTCPUID) RTMpCpuId(void) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + + PROCESSOR_NUMBER ProcNum; + ProcNum.Group = 0; + ProcNum.Number = 0xff; + if (g_pfnGetCurrentProcessorNumberEx) + g_pfnGetCurrentProcessorNumberEx(&ProcNum); + else if (g_pfnGetCurrentProcessorNumber) + { + DWORD iCpu = g_pfnGetCurrentProcessorNumber(); + Assert(iCpu < g_cRtMpWinMaxCpus); + ProcNum.Number = iCpu; + } + else + { +#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64) + ProcNum.Number = ASMGetApicId(); +#else +# error "Not ported to this architecture." + return NIL_RTCPUID; +#endif + } + +#ifdef IPRT_WITH_RTCPUID_AS_GROUP_AND_NUMBER + return RTMPCPUID_FROM_GROUP_AND_NUMBER(ProcNum.Group, ProcNum.Number); +#else + return RTMpSetIndexFromCpuGroupMember(ProcNum.Group, ProcNum.Number); +#endif +} + + +/* + * Possible CPUs and cores. + */ + +RTDECL(RTCPUID) RTMpGetMaxCpuId(void) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + +#ifdef IPRT_WITH_RTCPUID_AS_GROUP_AND_NUMBER + return RTMPCPUID_FROM_GROUP_AND_NUMBER(g_cRtMpWinMaxCpuGroups - 1, + g_aRtMpWinCpuGroups[g_cRtMpWinMaxCpuGroups - 1].cMaxCpus - 1); +#else + return g_cRtMpWinMaxCpus - 1; +#endif +} + + +RTDECL(bool) RTMpIsCpuPossible(RTCPUID idCpu) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + + /* Any CPU between 0 and g_cRtMpWinMaxCpus are possible. */ + return idCpu < g_cRtMpWinMaxCpus; +} + + +RTDECL(PRTCPUSET) RTMpGetSet(PRTCPUSET pSet) +{ + RTCPUID iCpu = RTMpGetCount(); + RTCpuSetEmpty(pSet); + while (iCpu-- > 0) + RTCpuSetAddByIndex(pSet, iCpu); + return pSet; +} + + +RTDECL(RTCPUID) RTMpGetCount(void) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + + return g_cRtMpWinMaxCpus; +} + + +RTDECL(RTCPUID) RTMpGetCoreCount(void) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + RTMPWIN_UPDATE_GIP_GLOBALS(); + + return g_cRtMpWinMaxCpuCores; +} + + +/* + * Online CPUs and cores. + */ + +RTDECL(PRTCPUSET) RTMpGetOnlineSet(PRTCPUSET pSet) +{ + RTOnce(&g_MpInitOnce, rtMpWinInitOnce, NULL); + +#ifdef IPRT_WITH_GIP_MP_INFO + RTMPWIN_UPDATE_GIP_GLOBALS_AND_GET_PGIP(); + if (pGip) + { + *pSet = pGip->OnlineCpuSet; + return pSet; + } +#endif + + if (g_pfnGetLogicalProcessorInformationEx) + { + /* + * Get the group relation info. + * + * In addition to the ASSUMPTIONS that are documented in rtMpWinInitOnce, + * we ASSUME that PROCESSOR_GROUP_INFO::MaximumProcessorCount gives the + * active processor mask width. + */ + /** @todo this is not correct for WOW64 */ + DWORD cbInfo = g_cbRtMpWinGrpRelBuf; + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *pInfo = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *)alloca(cbInfo); + AssertFatalMsg(g_pfnGetLogicalProcessorInformationEx(RelationGroup, pInfo, &cbInfo) != FALSE, + ("last error = %u, cbInfo = %u (in %u)\n", GetLastError(), cbInfo, g_cbRtMpWinGrpRelBuf)); + AssertFatalMsg(pInfo->Relationship == RelationGroup, + ("Relationship = %u, expected %u!\n", pInfo->Relationship, RelationGroup)); + AssertFatalMsg(pInfo->Group.MaximumGroupCount == g_cRtMpWinMaxCpuGroups, + ("MaximumGroupCount is %u, expected %u!\n", pInfo->Group.MaximumGroupCount, g_cRtMpWinMaxCpuGroups)); + + RTCpuSetEmpty(pSet); + for (uint32_t idxGroup = 0; idxGroup < pInfo->Group.MaximumGroupCount; idxGroup++) + { + Assert(pInfo->Group.GroupInfo[idxGroup].MaximumProcessorCount == g_aRtMpWinCpuGroups[idxGroup].cMaxCpus); + Assert(pInfo->Group.GroupInfo[idxGroup].ActiveProcessorCount <= g_aRtMpWinCpuGroups[idxGroup].cMaxCpus); + + KAFFINITY fActive = pInfo->Group.GroupInfo[idxGroup].ActiveProcessorMask; + if (fActive != 0) + { +#ifdef RT_STRICT + uint32_t cMembersLeft = pInfo->Group.GroupInfo[idxGroup].ActiveProcessorCount; +#endif + int const cMembers = g_aRtMpWinCpuGroups[idxGroup].cMaxCpus; + for (int idxMember = 0; idxMember < cMembers; idxMember++) + { + if (fActive & 1) + { +#ifdef RT_STRICT + cMembersLeft--; +#endif + RTCpuSetAddByIndex(pSet, g_aRtMpWinCpuGroups[idxGroup].aidxCpuSetMembers[idxMember]); + fActive >>= 1; + if (!fActive) + break; + } + else + { + fActive >>= 1; + } + } + Assert(cMembersLeft == 0); + } + else + Assert(pInfo->Group.GroupInfo[idxGroup].ActiveProcessorCount == 0); + } + + return pSet; + } + + /* + * Legacy fallback code. + */ + SYSTEM_INFO SysInfo; + GetSystemInfo(&SysInfo); + return RTCpuSetFromU64(pSet, SysInfo.dwActiveProcessorMask); +} + + +RTDECL(bool) RTMpIsCpuOnline(RTCPUID idCpu) +{ + RTCPUSET Set; + return RTCpuSetIsMember(RTMpGetOnlineSet(&Set), idCpu); +} + + +RTDECL(RTCPUID) RTMpGetOnlineCount(void) +{ +#ifdef IPRT_WITH_GIP_MP_INFO + RTMPWIN_UPDATE_GIP_GLOBALS_AND_GET_PGIP(); + if (pGip) + return pGip->cOnlineCpus; +#endif + + RTCPUSET Set; + RTMpGetOnlineSet(&Set); + return RTCpuSetCount(&Set); +} + + +RTDECL(RTCPUID) RTMpGetOnlineCoreCount(void) +{ + /** @todo this isn't entirely correct, but whatever. */ + return RTMpGetCoreCount(); +} + diff --git a/src/VBox/Runtime/r3/win/ntdll-mini-implib.def b/src/VBox/Runtime/r3/win/ntdll-mini-implib.def new file mode 100644 index 00000000..aa17932b --- /dev/null +++ b/src/VBox/Runtime/r3/win/ntdll-mini-implib.def @@ -0,0 +1,149 @@ +; $Id: ntdll-mini-implib.def $ +;; @file +; IPRT - Minimal NTDLL import library defintion file. +; + +; +; Copyright (C) 2010-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + +LIBRARY ntdll.dll +EXPORTS + ; Exported name - The name x86 name sought by the linker. + ; - This needs to be defined as a symbol, we generate assembly. + + CsrClientCallServer ;;= _CsrClientCallServer@16 + + NtAlertThread ;;= _NtAlertThread@4 + NtAllocateVirtualMemory ;;= _NtAllocateVirtualMemory@24 + NtClearEvent ;;= _NtClearEvent@4 + NtClose ;;= _NtClose@4 + NtCreateEvent ;;= _NtCreateEvent@20 + NtCreateFile ;;= _NtCreateFile@44 + NtCreateSection ;;= _NtCreateSection@28 + NtCreateSymbolicLinkObject ;;= _NtCreateSymbolicLinkObject@16 + NtDelayExecution ;;= _NtDelayExecution@8 + NtDeviceIoControlFile ;;= _NtDeviceIoControlFile@40 + NtDuplicateObject ;;= _NtDuplicateObject@28 + NtEnumerateKey ;;= _NtEnumerateKey@24 + NtFlushBuffersFile ;;= _NtFlushBuffersFile@8 + NtFlushVirtualMemory ;;= _NtFlushVirtualMemory@16 + NtFreeVirtualMemory ;;= _NtFreeVirtualMemory@16 + NtGetContextThread ;;= _NtGetContextThread@8 + NtMapViewOfSection ;;= _NtMapViewOfSection@40 + NtOpenDirectoryObject ;;= _NtOpenDirectoryObject@12 + NtOpenEvent ;;= _NtOpenEvent@12 + NtOpenKey ;;= _NtOpenKey@12 + NtOpenProcess ;;= _NtOpenProcess@16 + NtOpenProcessToken ;;= _NtOpenProcessToken@12 + NtOpenSymbolicLinkObject ;;= _NtOpenSymbolicLinkObject@12 + NtOpenThread ;;= _NtOpenThread@16 + NtOpenThreadToken ;;= _NtOpenThreadToken@16 + NtProtectVirtualMemory ;;= _NtProtectVirtualMemory@20 + NtQueryAttributesFile ;;= _NtQueryAttributesFile@8 + NtQueryDirectoryFile ;;= _NtQueryDirectoryFile@44 + NtQueryDirectoryObject ;;= _NtQueryDirectoryObject@28 + NtQueryFullAttributesFile ;;= _NtQueryFullAttributesFile@8 + NtQueryEvent ;;= _NtQueryEvent@20 + NtQueryInformationFile ;;= _NtQueryInformationFile@20 + NtQueryInformationProcess ;;= _NtQueryInformationProcess@20 + NtQueryInformationThread ;;= _NtQueryInformationThread@20 + NtQueryInformationToken ;;= _NtQueryInformationToken@20 + NtQueryKey ;;= _NtQueryKey@20 + NtQueryObject ;;= _NtQueryObject@20 + NtQuerySection ;;= _NtQuerySection@20 + NtQuerySecurityObject ;;= _NtQuerySecurityObject@20 + NtQuerySymbolicLinkObject ;;= _NtQuerySymbolicLinkObject@12 + NtQuerySystemInformation ;;= _NtQuerySystemInformation@16 + NtQueryTimerResolution ;;= _NtQueryTimerResolution@12 + NtQueryValueKey ;;= _NtQueryValueKey@24 + NtQueryVirtualMemory ;;= _NtQueryVirtualMemory@24 + NtQueryVolumeInformationFile ;;= _NtQueryVolumeInformationFile@20 + NtReadFile ;;= _NtReadFile@36 + NtReadVirtualMemory ;;= _NtReadVirtualMemory@20 + NtResetEvent ;;= _NtResetEvent@8 + NtResumeProcess ;;= _NtResumeProcess@4 + NtResumeThread ;;= _NtResumeThread@8 + NtSetContextThread ;;= _NtSetContextThread@8 + NtSetEvent ;;= _NtSetEvent@8 + NtSetInformationFile ;;= _NtSetInformationFile@20 + NtSetInformationObject ;;= _NtSetInformationObject@16 + NtSetInformationProcess ;;= _NtSetInformationProcess@16 + NtSetInformationThread ;;= _NtSetInformationThread@16 + NtSetTimerResolution ;;= _NtSetTimerResolution@12 + NtSuspendProcess ;;= _NtSuspendProcess@4 + NtSuspendThread ;;= _NtSuspendThread@8 + NtTerminateProcess ;;= _NtTerminateProcess@8 + NtTerminateThread ;;= _NtTerminateThread@8 + NtUnmapViewOfSection ;;= _NtUnmapViewOfSection@8 + NtWaitForMultipleObjects ;;= _NtWaitForMultipleObjects@20 + NtWaitForSingleObject ;;= _NtWaitForSingleObject@12 + NtWriteFile ;;= _NtWriteFile@36 + NtWriteVirtualMemory ;;= _NtWriteVirtualMemory@20 + NtYieldExecution ;;= _NtYieldExecution@0 + + LdrInitializeThunk ;;= _LdrInitializeThunk@12 + LdrRegisterDllNotification ;;= _LdrRegisterDllNotification@16 + LdrLoadDll ;;= _LdrLoadDll@16 + LdrUnloadDll ;;= _LdrUnloadDll@4 + LdrGetDllHandle ;;= _LdrGetDllHandle@16 + LdrGetDllHandleEx ;;= _LdrGetDllHandleEx@20 + LdrGetDllHandleByMapping ;;= _LdrGetDllHandleByMapping@8 + LdrGetDllHandleByName ;;= _LdrGetDllHandleByName@12 + LdrAddRefDll ;;= _LdrAddRefDll@8 + LdrGetProcedureAddress ;;= _LdrGetProcedureAddress@12 + LdrGetProcedureAddressEx ;;= _LdrGetProcedureAddressEx@16 + LdrLockLoaderLock ;;= _LdrLockLoaderLock@12 + LdrUnlockLoaderLock ;;= _LdrUnlockLoaderLock@8 + + RtlAddAccessAllowedAce ;;= _RtlAddAccessAllowedAce@16 + RtlAddAccessDeniedAce ;;= _RtlAddAccessDeniedAce@16 + RtlAllocateHeap ;;= _RtlAllocateHeap@12 + RtlCompactHeap ;;= _RtlCompactHeap@8 + RtlCopySid ;;= _RtlCopySid@12 + RtlCreateAcl ;;= _RtlCreateAcl@12 + RtlCreateHeap ;;= _RtlCreateHeap@24 + RtlCreateProcessParameters ;;= _RtlCreateProcessParameters@40 + RtlCreateSecurityDescriptor ;;= _RtlCreateSecurityDescriptor@8 + RtlCreateUserProcess ;;= _RtlCreateUserProcess@40 + RtlCreateUserThread ;;= _RtlCreateUserThread@40 + RtlDestroyProcessParameters ;;= _RtlDestroyProcessParameters@4 + RtlDosApplyFileIsolationRedirection_Ustr ;;= _RtlDosApplyFileIsolationRedirection_Ustr@36 + RtlEqualSid ;;= _RtlEqualSid@8 + RtlExitUserProcess ;;= _RtlExitUserProcess@4 + RtlExitUserThread ;;= _RtlExitUserThread@4 + RtlExpandEnvironmentStrings_U ;;= _RtlExpandEnvironmentStrings_U@16 + RtlFreeHeap ;;= _RtlFreeHeap@12 + RtlFreeUnicodeString ;;= _RtlFreeUnicodeString@4 + RtlGetLastNtStatus ;;= _RtlGetLastNtStatus@0 + RtlGetLastWin32Error ;;= _RtlGetLastWin32Error@0 + RtlGetVersion ;;= _RtlGetVersion@4 + RtlInitializeSid ;;= _RtlInitializeSid@12 + RtlNtStatusToDosError ;;= _RtlNtStatusToDosError@4 + RtlReAllocateHeap ;;= _RtlReAllocateHeap@16 + RtlRestoreLastWin32Error ;;= _RtlRestoreLastWin32Error@4 + RtlSetDaclSecurityDescriptor ;;= _RtlSetDaclSecurityDescriptor@16 + RtlSetLastWin32Error ;;= _RtlSetLastWin32Error@4 + RtlSetLastWin32ErrorAndNtStatusFromNtStatus ;;= _RtlSetLastWin32ErrorAndNtStatusFromNtStatus@4 + RtlSizeHeap ;;= _RtlSizeHeap@12 + RtlSubAuthoritySid ;;= _RtlSubAuthoritySid@8 + RtlQueryPerformanceCounter ;;= _RtlQueryPerformanceCounter@4 + RtlGetSystemTimePrecise ;;= _RtlGetSystemTimePrecise@0 + diff --git a/src/VBox/Runtime/r3/win/path-win.cpp b/src/VBox/Runtime/r3/win/path-win.cpp new file mode 100644 index 00000000..84bbf130 --- /dev/null +++ b/src/VBox/Runtime/r3/win/path-win.cpp @@ -0,0 +1,739 @@ +/* $Id: path-win.cpp $ */ +/** @file + * IPRT - Path manipulation. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_PATH +#include <iprt/win/windows.h> +#include <iprt/win/shlobj.h> + +#include <iprt/path.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/ldr.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/param.h> +#include <iprt/string.h> +#include <iprt/time.h> +#include <iprt/utf16.h> +#include "internal/path.h" +#include "internal/fs.h" + +/* Needed for lazy loading SHGetFolderPathW in RTPathUserDocuments(). */ +typedef HRESULT WINAPI FNSHGETFOLDERPATHW(HWND, int, HANDLE, DWORD, LPWSTR); +typedef FNSHGETFOLDERPATHW *PFNSHGETFOLDERPATHW; + +/** + * Get the real (no symlinks, no . or .. components) path, must exist. + * + * @returns iprt status code. + * @param pszPath The path to resolve. + * @param pszRealPath Where to store the real path. + * @param cchRealPath Size of the buffer. + */ +RTDECL(int) RTPathReal(const char *pszPath, char *pszRealPath, size_t cchRealPath) +{ + /* + * Convert to UTF-16, call Win32 APIs, convert back. + */ + PRTUTF16 pwszPath; + int rc = RTPathWinFromUtf8(&pwszPath, pszPath, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + LPWSTR lpFile; + WCHAR wsz[RTPATH_MAX]; + rc = GetFullPathNameW((LPCWSTR)pwszPath, RT_ELEMENTS(wsz), &wsz[0], &lpFile); + if (rc > 0 && rc < RT_ELEMENTS(wsz)) + { + /* Check that it exists. (Use RTPathAbs() to just resolve the name.) */ + DWORD dwAttr = GetFileAttributesW(wsz); + if (dwAttr != INVALID_FILE_ATTRIBUTES) + rc = RTUtf16ToUtf8Ex((PRTUTF16)&wsz[0], RTSTR_MAX, &pszRealPath, cchRealPath, NULL); + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else if (rc <= 0) + rc = RTErrConvertFromWin32(GetLastError()); + else + rc = VERR_FILENAME_TOO_LONG; + + RTPathWinFree(pwszPath); + } + return rc; +} + +#if 0 +/** + * Get the absolute path (no symlinks, no . or .. components), doesn't have to exit. + * + * @returns iprt status code. + * @param pszPath The path to resolve. + * @param pszAbsPath Where to store the absolute path. + * @param cchAbsPath Size of the buffer. + */ +RTDECL(int) RTPathAbs(const char *pszPath, char *pszAbsPath, size_t cchAbsPath) +{ + /* + * Validation. + */ + AssertPtr(pszAbsPath); + AssertPtr(pszPath); + if (RT_UNLIKELY(!*pszPath)) + return VERR_INVALID_PARAMETER; + + /* + * Convert to UTF-16, call Win32 API, convert back. + */ + LPWSTR pwszPath; + int rc = RTStrToUtf16(pszPath, &pwszPath); + if (!RT_SUCCESS(rc)) + return (rc); + + LPWSTR pwszFile; /* Ignored */ + RTUTF16 wsz[RTPATH_MAX]; + rc = GetFullPathNameW(pwszPath, RT_ELEMENTS(wsz), &wsz[0], &pwszFile); + if (rc > 0 && rc < RT_ELEMENTS(wsz)) + { + size_t cch; + rc = RTUtf16ToUtf8Ex(&wsz[0], RTSTR_MAX, &pszAbsPath, cchAbsPath, &cch); + if (RT_SUCCESS(rc)) + { +# if 1 /** @todo This code is completely bonkers. */ + /* + * Remove trailing slash if the path may be pointing to a directory. + * (See posix variant.) + */ + if ( cch > 1 + && RTPATH_IS_SLASH(pszAbsPath[cch - 1]) + && !RTPATH_IS_VOLSEP(pszAbsPath[cch - 2]) + && !RTPATH_IS_SLASH(pszAbsPath[cch - 2])) + pszAbsPath[cch - 1] = '\0'; +# endif + } + } + else if (rc <= 0) + rc = RTErrConvertFromWin32(GetLastError()); + else + rc = VERR_FILENAME_TOO_LONG; + + RTUtf16Free(pwszPath); + return rc; +} +#endif + + +/** + * Gets the user home directory. + * + * @returns iprt status code. + * @param pszPath Buffer where to store the path. + * @param cchPath Buffer size in bytes. + */ +RTDECL(int) RTPathUserHome(char *pszPath, size_t cchPath) +{ + /* + * Validate input + */ + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn(cchPath, VERR_INVALID_PARAMETER); + + RTUTF16 wszPath[RTPATH_MAX]; + bool fValidFolderPath = false; + + /* + * Try with Windows XP+ functionality first. + */ + RTLDRMOD hShell32; + int rc = RTLdrLoadSystem("Shell32.dll", true /*fNoUnload*/, &hShell32); + if (RT_SUCCESS(rc)) + { + PFNSHGETFOLDERPATHW pfnSHGetFolderPathW; + rc = RTLdrGetSymbol(hShell32, "SHGetFolderPathW", (void**)&pfnSHGetFolderPathW); + if (RT_SUCCESS(rc)) + { + HRESULT hrc = pfnSHGetFolderPathW(0, CSIDL_PROFILE, NULL, SHGFP_TYPE_CURRENT, wszPath); + fValidFolderPath = (hrc == S_OK); + } + RTLdrClose(hShell32); + } + + DWORD dwAttr; + if ( !fValidFolderPath + || (dwAttr = GetFileAttributesW(&wszPath[0])) == INVALID_FILE_ATTRIBUTES + || !(dwAttr & FILE_ATTRIBUTE_DIRECTORY)) + { + /* + * Fall back to Windows specific environment variables. HOME is not used. + */ + if ( !GetEnvironmentVariableW(L"USERPROFILE", &wszPath[0], RTPATH_MAX) + || (dwAttr = GetFileAttributesW(&wszPath[0])) == INVALID_FILE_ATTRIBUTES + || !(dwAttr & FILE_ATTRIBUTE_DIRECTORY)) + { + /* %HOMEDRIVE%%HOMEPATH% */ + if (!GetEnvironmentVariableW(L"HOMEDRIVE", &wszPath[0], RTPATH_MAX)) + return VERR_PATH_NOT_FOUND; + size_t const cwc = RTUtf16Len(&wszPath[0]); + if ( !GetEnvironmentVariableW(L"HOMEPATH", &wszPath[cwc], RTPATH_MAX - (DWORD)cwc) + || (dwAttr = GetFileAttributesW(&wszPath[0])) == INVALID_FILE_ATTRIBUTES + || !(dwAttr & FILE_ATTRIBUTE_DIRECTORY)) + return VERR_PATH_NOT_FOUND; + } + } + + /* + * Convert and return. + */ + return RTUtf16ToUtf8Ex(&wszPath[0], RTSTR_MAX, &pszPath, cchPath, NULL); +} + + +RTDECL(int) RTPathUserDocuments(char *pszPath, size_t cchPath) +{ + /* + * Validate input + */ + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn(cchPath, VERR_INVALID_PARAMETER); + + RTLDRMOD hShell32; + int rc = RTLdrLoadSystem("Shell32.dll", true /*fNoUnload*/, &hShell32); + if (RT_SUCCESS(rc)) + { + PFNSHGETFOLDERPATHW pfnSHGetFolderPathW; + rc = RTLdrGetSymbol(hShell32, "SHGetFolderPathW", (void**)&pfnSHGetFolderPathW); + if (RT_SUCCESS(rc)) + { + RTUTF16 wszPath[RTPATH_MAX]; + HRESULT hrc = pfnSHGetFolderPathW(0, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, wszPath); + if ( hrc == S_OK /* Found */ + || hrc == S_FALSE) /* Found, but doesn't exist */ + { + /* + * Convert and return. + */ + RTLdrClose(hShell32); + return RTUtf16ToUtf8Ex(&wszPath[0], RTSTR_MAX, &pszPath, cchPath, NULL); + } + } + RTLdrClose(hShell32); + } + return VERR_PATH_NOT_FOUND; +} + + +#if 0 /* use nt version of this */ + +RTR3DECL(int) RTPathQueryInfo(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs) +{ + return RTPathQueryInfoEx(pszPath, pObjInfo, enmAdditionalAttribs, RTPATH_F_ON_LINK); +} +#endif +#if 0 + + +RTR3DECL(int) RTPathQueryInfoEx(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags) +{ + /* + * Validate input. + */ + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn(*pszPath, VERR_INVALID_PARAMETER); + AssertPtrReturn(pObjInfo, VERR_INVALID_POINTER); + AssertMsgReturn( enmAdditionalAttribs >= RTFSOBJATTRADD_NOTHING + && enmAdditionalAttribs <= RTFSOBJATTRADD_LAST, + ("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs), + VERR_INVALID_PARAMETER); + AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER); + + /* + * Query file info. + */ + uint32_t uReparseTag = RTFSMODE_SYMLINK_REPARSE_TAG; + WIN32_FILE_ATTRIBUTE_DATA Data; + PRTUTF16 pwszPath; + int rc = RTStrToUtf16(pszPath, &pwszPath); + if (RT_FAILURE(rc)) + return rc; + if (!GetFileAttributesExW(pwszPath, GetFileExInfoStandard, &Data)) + { + /* Fallback to FindFileFirst in case of sharing violation. */ + if (GetLastError() == ERROR_SHARING_VIOLATION) + { + WIN32_FIND_DATAW FindData; + HANDLE hDir = FindFirstFileW(pwszPath, &FindData); + if (hDir == INVALID_HANDLE_VALUE) + { + rc = RTErrConvertFromWin32(GetLastError()); + RTUtf16Free(pwszPath); + return rc; + } + FindClose(hDir); + + Data.dwFileAttributes = FindData.dwFileAttributes; + Data.ftCreationTime = FindData.ftCreationTime; + Data.ftLastAccessTime = FindData.ftLastAccessTime; + Data.ftLastWriteTime = FindData.ftLastWriteTime; + Data.nFileSizeHigh = FindData.nFileSizeHigh; + Data.nFileSizeLow = FindData.nFileSizeLow; + uReparseTag = FindData.dwReserved0; + } + else + { + rc = RTErrConvertFromWin32(GetLastError()); + RTUtf16Free(pwszPath); + return rc; + } + } + + /* + * Getting the information for the link target is a bit annoying and + * subject to the same access violation mess as above.. :/ + */ + /** @todo we're too lazy wrt to error paths here... */ + if ( (Data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) + && ((fFlags & RTPATH_F_FOLLOW_LINK) || uReparseTag != RTFSMODE_SYMLINK_REPARSE_TAG)) + { + HANDLE hFinal = CreateFileW(pwszPath, + GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + NULL, + OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, + NULL); + if (hFinal != INVALID_HANDLE_VALUE) + { + BY_HANDLE_FILE_INFORMATION FileData; + if (GetFileInformationByHandle(hFinal, &FileData)) + { + Data.dwFileAttributes = FileData.dwFileAttributes; + Data.ftCreationTime = FileData.ftCreationTime; + Data.ftLastAccessTime = FileData.ftLastAccessTime; + Data.ftLastWriteTime = FileData.ftLastWriteTime; + Data.nFileSizeHigh = FileData.nFileSizeHigh; + Data.nFileSizeLow = FileData.nFileSizeLow; + uReparseTag = 0; + } + CloseHandle(hFinal); + } + else if (GetLastError() != ERROR_SHARING_VIOLATION) + { + rc = RTErrConvertFromWin32(GetLastError()); + RTUtf16Free(pwszPath); + return rc; + } + } + + RTUtf16Free(pwszPath); + + /* + * Setup the returned data. + */ + pObjInfo->cbObject = ((uint64_t)Data.nFileSizeHigh << 32) + | (uint64_t)Data.nFileSizeLow; + pObjInfo->cbAllocated = pObjInfo->cbObject; + + Assert(sizeof(uint64_t) == sizeof(Data.ftCreationTime)); + RTTimeSpecSetNtTime(&pObjInfo->BirthTime, *(uint64_t *)&Data.ftCreationTime); + RTTimeSpecSetNtTime(&pObjInfo->AccessTime, *(uint64_t *)&Data.ftLastAccessTime); + RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, *(uint64_t *)&Data.ftLastWriteTime); + pObjInfo->ChangeTime = pObjInfo->ModificationTime; + + pObjInfo->Attr.fMode = rtFsModeFromDos((Data.dwFileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT, + pszPath, strlen(pszPath), uReparseTag); + + /* + * Requested attributes (we cannot provide anything actually). + */ + switch (enmAdditionalAttribs) + { + case RTFSOBJATTRADD_NOTHING: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_NOTHING; + break; + + case RTFSOBJATTRADD_UNIX: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX; + pObjInfo->Attr.u.Unix.uid = ~0U; + pObjInfo->Attr.u.Unix.gid = ~0U; + pObjInfo->Attr.u.Unix.cHardlinks = 1; + pObjInfo->Attr.u.Unix.INodeIdDevice = 0; /** @todo use volume serial number */ + pObjInfo->Attr.u.Unix.INodeId = 0; /** @todo use fileid (see GetFileInformationByHandle). */ + pObjInfo->Attr.u.Unix.fFlags = 0; + pObjInfo->Attr.u.Unix.GenerationId = 0; + pObjInfo->Attr.u.Unix.Device = 0; + break; + + case RTFSOBJATTRADD_UNIX_OWNER: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_OWNER; + pObjInfo->Attr.u.UnixOwner.uid = ~0U; + pObjInfo->Attr.u.UnixOwner.szName[0] = '\0'; /** @todo return something sensible here. */ + break; + + case RTFSOBJATTRADD_UNIX_GROUP: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX_GROUP; + pObjInfo->Attr.u.UnixGroup.gid = ~0U; + pObjInfo->Attr.u.UnixGroup.szName[0] = '\0'; + break; + + case RTFSOBJATTRADD_EASIZE: + pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE; + pObjInfo->Attr.u.EASize.cb = 0; + break; + + default: + AssertMsgFailed(("Impossible!\n")); + return VERR_INTERNAL_ERROR; + } + + return VINF_SUCCESS; +} + +#endif /* using NT version*/ + + +RTR3DECL(int) RTPathSetTimes(const char *pszPath, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + return RTPathSetTimesEx(pszPath, pAccessTime, pModificationTime, pChangeTime, pBirthTime, RTPATH_F_ON_LINK); +} + + +RTR3DECL(int) RTPathSetTimesEx(const char *pszPath, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime, uint32_t fFlags) +{ + /* + * Validate input. + */ + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn(*pszPath, VERR_INVALID_PARAMETER); + AssertPtrNullReturn(pAccessTime, VERR_INVALID_POINTER); + AssertPtrNullReturn(pModificationTime, VERR_INVALID_POINTER); + AssertPtrNullReturn(pChangeTime, VERR_INVALID_POINTER); + AssertPtrNullReturn(pBirthTime, VERR_INVALID_POINTER); + AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER); + + /* + * Convert the path. + */ + PRTUTF16 pwszPath; + int rc = RTPathWinFromUtf8(&pwszPath, pszPath, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + HANDLE hFile; + if (fFlags & RTPATH_F_FOLLOW_LINK) + hFile = CreateFileW(pwszPath, + FILE_WRITE_ATTRIBUTES, /* dwDesiredAccess */ + FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE, /* dwShareMode */ + NULL, /* security attribs */ + OPEN_EXISTING, /* dwCreationDisposition */ + FILE_FLAG_BACKUP_SEMANTICS | FILE_ATTRIBUTE_NORMAL, + NULL); + else + { +/** @todo Symlink: Test RTPathSetTimesEx on Windows. (The code is disabled + * because it's not tested yet.) */ +#if 0 //def FILE_FLAG_OPEN_REPARSE_POINT + hFile = CreateFileW(pwszPath, + FILE_WRITE_ATTRIBUTES, /* dwDesiredAccess */ + FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE, /* dwShareMode */ + NULL, /* security attribs */ + OPEN_EXISTING, /* dwCreationDisposition */ + FILE_FLAG_BACKUP_SEMANTICS | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OPEN_REPARSE_POINT, + NULL); + + if (hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_INVALID_PARAMETER) +#endif + hFile = CreateFileW(pwszPath, + FILE_WRITE_ATTRIBUTES, /* dwDesiredAccess */ + FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE, /* dwShareMode */ + NULL, /* security attribs */ + OPEN_EXISTING, /* dwCreationDisposition */ + FILE_FLAG_BACKUP_SEMANTICS | FILE_ATTRIBUTE_NORMAL, + NULL); + } + if (hFile != INVALID_HANDLE_VALUE) + { + /* + * Check if it's a no-op. + */ + if (!pAccessTime && !pModificationTime && !pBirthTime) + rc = VINF_SUCCESS; /* NOP */ + else + { + /* + * Convert the input and call the API. + */ + FILETIME CreationTimeFT; + PFILETIME pCreationTimeFT = NULL; + if (pBirthTime) + pCreationTimeFT = RTTimeSpecGetNtFileTime(pBirthTime, &CreationTimeFT); + + FILETIME LastAccessTimeFT; + PFILETIME pLastAccessTimeFT = NULL; + if (pAccessTime) + pLastAccessTimeFT = RTTimeSpecGetNtFileTime(pAccessTime, &LastAccessTimeFT); + + FILETIME LastWriteTimeFT; + PFILETIME pLastWriteTimeFT = NULL; + if (pModificationTime) + pLastWriteTimeFT = RTTimeSpecGetNtFileTime(pModificationTime, &LastWriteTimeFT); + + if (SetFileTime(hFile, pCreationTimeFT, pLastAccessTimeFT, pLastWriteTimeFT)) + rc = VINF_SUCCESS; + else + { + DWORD Err = GetLastError(); + rc = RTErrConvertFromWin32(Err); + Log(("RTPathSetTimes('%s', %p, %p, %p, %p): SetFileTime failed with lasterr %d (%Rrc)\n", + pszPath, pAccessTime, pModificationTime, pChangeTime, pBirthTime, Err, rc)); + } + } + BOOL fRc = CloseHandle(hFile); Assert(fRc); NOREF(fRc); + } + else + { + DWORD Err = GetLastError(); + rc = RTErrConvertFromWin32(Err); + Log(("RTPathSetTimes('%s',,,,): failed with %Rrc and lasterr=%u\n", pszPath, rc, Err)); + } + + RTPathWinFree(pwszPath); + } + + LogFlow(("RTPathSetTimes(%p:{%s}, %p:{%RDtimespec}, %p:{%RDtimespec}, %p:{%RDtimespec}, %p:{%RDtimespec}): return %Rrc\n", + pszPath, pszPath, pAccessTime, pAccessTime, pModificationTime, pModificationTime, + pChangeTime, pChangeTime, pBirthTime, pBirthTime)); + return rc; +} + + + + +/** + * Internal worker for RTFileRename and RTFileMove. + * + * @returns iprt status code. + * @param pszSrc The source filename. + * @param pszDst The destination filename. + * @param fFlags The windows MoveFileEx flags. + * @param fFileType The filetype. We use the RTFMODE filetypes here. If it's 0, + * anything goes. If it's RTFS_TYPE_DIRECTORY we'll check that the + * source is a directory. If Its RTFS_TYPE_FILE we'll check that it's + * not a directory (we are NOT checking whether it's a file). + */ +DECLHIDDEN(int) rtPathWin32MoveRename(const char *pszSrc, const char *pszDst, uint32_t fFlags, RTFMODE fFileType) +{ + /* + * Convert the strings. + */ + PRTUTF16 pwszSrc; + int rc = RTPathWinFromUtf8(&pwszSrc, pszSrc, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + PRTUTF16 pwszDst; + rc = RTPathWinFromUtf8(&pwszDst, pszDst, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + /* + * Check object type if requested. + * This is open to race conditions. + */ + if (fFileType) + { + DWORD dwAttr = GetFileAttributesW(pwszSrc); + if (dwAttr == INVALID_FILE_ATTRIBUTES) + rc = RTErrConvertFromWin32(GetLastError()); + else if (RTFS_IS_DIRECTORY(fFileType)) + rc = dwAttr & FILE_ATTRIBUTE_DIRECTORY ? VINF_SUCCESS : VERR_NOT_A_DIRECTORY; + else + rc = dwAttr & FILE_ATTRIBUTE_DIRECTORY ? VERR_IS_A_DIRECTORY : VINF_SUCCESS; + } + if (RT_SUCCESS(rc)) + { + if (MoveFileExW(pwszSrc, pwszDst, fFlags)) + rc = VINF_SUCCESS; + else + { + DWORD Err = GetLastError(); + rc = RTErrConvertFromWin32(Err); + Log(("MoveFileExW('%s', '%s', %#x, %RTfmode): fails with rc=%Rrc & lasterr=%d\n", + pszSrc, pszDst, fFlags, fFileType, rc, Err)); + } + } + RTPathWinFree(pwszDst); + } + RTPathWinFree(pwszSrc); + } + return rc; +} + + +RTR3DECL(int) RTPathRename(const char *pszSrc, const char *pszDst, unsigned fRename) +{ + /* + * Validate input. + */ + AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER); + AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER); + AssertMsgReturn(*pszSrc, ("%p\n", pszSrc), VERR_INVALID_PARAMETER); + AssertMsgReturn(*pszDst, ("%p\n", pszDst), VERR_INVALID_PARAMETER); + AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER); + + /* + * Call the worker. + */ + int rc = rtPathWin32MoveRename(pszSrc, pszDst, fRename & RTPATHRENAME_FLAGS_REPLACE ? MOVEFILE_REPLACE_EXISTING : 0, 0); + + LogFlow(("RTPathRename(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n", pszSrc, pszSrc, pszDst, pszDst, fRename, rc)); + return rc; +} + + +RTR3DECL(int) RTPathUnlink(const char *pszPath, uint32_t fUnlink) +{ + RT_NOREF_PV(pszPath); RT_NOREF_PV(fUnlink); + return VERR_NOT_IMPLEMENTED; +} + + +RTDECL(bool) RTPathExists(const char *pszPath) +{ + return RTPathExistsEx(pszPath, RTPATH_F_FOLLOW_LINK); +} + + +RTDECL(bool) RTPathExistsEx(const char *pszPath, uint32_t fFlags) +{ + /* + * Validate input. + */ + AssertPtrReturn(pszPath, false); + AssertReturn(*pszPath, false); + Assert(RTPATH_F_IS_VALID(fFlags, 0)); + + /* + * Try query file info. + */ + DWORD dwAttr; + PRTUTF16 pwszPath; + int rc = RTPathWinFromUtf8(&pwszPath, pszPath, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + dwAttr = GetFileAttributesW(pwszPath); + RTPathWinFree(pwszPath); + } + else + dwAttr = INVALID_FILE_ATTRIBUTES; + if (dwAttr == INVALID_FILE_ATTRIBUTES) + return false; + +#ifdef FILE_ATTRIBUTE_REPARSE_POINT + if ( (fFlags & RTPATH_F_FOLLOW_LINK) + && (dwAttr & FILE_ATTRIBUTE_REPARSE_POINT)) + { + AssertFailed(); + /** @todo Symlinks: RTPathExists+RTPathExistsEx is misbehaving on symbolic + * links on Windows. */ + } +#endif + + return true; +} + + +RTDECL(int) RTPathGetCurrent(char *pszPath, size_t cchPath) +{ + int rc; + + /* + * GetCurrentDirectory may in some cases omit the drive letter, according + * to MSDN, thus the GetFullPathName call. + */ + RTUTF16 wszCurPath[RTPATH_MAX]; + if (GetCurrentDirectoryW(RTPATH_MAX, wszCurPath)) + { + RTUTF16 wszFullPath[RTPATH_MAX]; + if (GetFullPathNameW(wszCurPath, RTPATH_MAX, wszFullPath, NULL)) + rc = RTUtf16ToUtf8Ex(&wszFullPath[0], RTSTR_MAX, &pszPath, cchPath, NULL); + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + return rc; +} + + +RTDECL(int) RTPathSetCurrent(const char *pszPath) +{ + /* + * Validate input. + */ + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn(*pszPath, VERR_INVALID_PARAMETER); + + /* + * This interface is almost identical to the Windows API. + */ + PRTUTF16 pwszPath; + int rc = RTPathWinFromUtf8(&pwszPath, pszPath, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + /** @todo improve the slash stripping a bit? */ + size_t cwc = RTUtf16Len(pwszPath); + if ( cwc >= 2 + && ( pwszPath[cwc - 1] == L'/' + || pwszPath[cwc - 1] == L'\\') + && pwszPath[cwc - 2] != ':') + pwszPath[cwc - 1] = L'\0'; + + if (!SetCurrentDirectoryW(pwszPath)) + rc = RTErrConvertFromWin32(GetLastError()); + + RTPathWinFree(pwszPath); + } + return rc; +} + + +RTDECL(int) RTPathGetCurrentOnDrive(char chDrive, char *pszPath, size_t cbPath) +{ + WCHAR wszInput[4]; + wszInput[0] = chDrive; + wszInput[1] = ':'; + wszInput[2] = '\0'; + + int rc; + RTUTF16 wszFullPath[RTPATH_MAX]; + if (GetFullPathNameW(wszInput, RTPATH_MAX, wszFullPath, NULL)) + rc = RTUtf16ToUtf8Ex(&wszFullPath[0], RTSTR_MAX, &pszPath, cbPath, NULL); + else + rc = RTErrConvertFromWin32(GetLastError()); + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/pathint-win.cpp b/src/VBox/Runtime/r3/win/pathint-win.cpp new file mode 100644 index 00000000..dff349ea --- /dev/null +++ b/src/VBox/Runtime/r3/win/pathint-win.cpp @@ -0,0 +1,194 @@ +/* $Id: pathint-win.cpp $ */ +/** @file + * IPRT - Windows, Internal Path stuff. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include <iprt/path.h> + +#include <iprt/assert.h> +#include <iprt/ctype.h> +#include <iprt/errcore.h> +#include <iprt/string.h> +#include <iprt/utf16.h> + +#include <iprt/nt/nt-and-windows.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The max number of non-null characters we pass to an Win32 API. + * You would think that MAX_PATH gives this length, however CreateDirectoryW was + * found to fail on Windows 10 (1803++) if given a perfectly formed path argument + * of 248 or more characters. Same when going thru UNC. + * + * So, to be conservative, we put the max number of characters in a non-\\?\ + * path to 243, not counting the terminator. + */ +#define ACTUAL_MAX_PATH 243 + + +DECL_NO_INLINE(static, bool) rtPathWinTryConvertToAbs(PRTUTF16 *ppwszPath) +{ + RTUTF16 wszFullPath[MAX_PATH + 1]; + DWORD cwcFull = GetFullPathNameW(*ppwszPath, MAX_PATH + 1, wszFullPath, NULL); + if (cwcFull <= ACTUAL_MAX_PATH) + { + RTUtf16Free(*ppwszPath); + PRTUTF16 const pwszCopy = RTUtf16Dup(wszFullPath); + *ppwszPath = pwszCopy; + if (pwszCopy) + return true; + } + return false; +} + + +RTDECL(int) RTPathWinFromUtf8(PRTUTF16 *ppwszPath, const char *pszPath, uint32_t fFlags) +{ + Assert(fFlags == 0); + RT_NOREF(fFlags); + + /* + * Do a straight conversion first. + */ + *ppwszPath = NULL; + size_t cwcResult = 0; + int rc = RTStrToUtf16Ex(pszPath, RTSTR_MAX, ppwszPath, 0, &cwcResult); + if (RT_SUCCESS(rc)) + { + /* + * Check the resulting length. This is straight forward for absolute + * paths, but gets complicated for relative ones. + */ + if (cwcResult <= ACTUAL_MAX_PATH) + { + if (RT_C_IS_ALPHA(pszPath[0]) && pszPath[1] == ':') + { + if (RTPATH_IS_SLASH(pszPath[2])) + return VINF_SUCCESS; + + /* Drive relative path. Found no simple way of getting the current + path of a drive, so we try convert it to an absolute path and see + how that works out. It is what the API we're calling will have to + do anyway, so this should perform just as well. */ + if (rtPathWinTryConvertToAbs(ppwszPath)) + return VINF_SUCCESS; + } + else if (RTPATH_IS_SLASH(pszPath[0])) + { + if ( RTPATH_IS_SLASH(pszPath[1]) + && !RTPATH_IS_SLASH(pszPath[2]) + && pszPath[2] != '\0') + { + /* Passthru prefix '\\?\' is fine. */ + if ( pszPath[2] == '?' + && !RTPATH_IS_SLASH(pszPath[3])) + return VINF_SUCCESS; + + /* UNC requires a longer prefix ('\??\UNC\' instead of '\??\'), so + subtract 3 chars from the max limit to be on the safe side. */ + if (cwcResult <= ACTUAL_MAX_PATH - 3) + return VINF_SUCCESS; + } + else + { + /* Drive relative. Win32 will prepend a two letter drive specification. */ + if (cwcResult <= ACTUAL_MAX_PATH - 2) + return VINF_SUCCESS; + } + } + else + { + /* Relative to CWD. We can use the API to get it's current length. + Any race conditions here is entirely the caller's problem. */ + size_t cwcCwd = GetCurrentDirectoryW(0, NULL); + if (cwcCwd + cwcResult <= ACTUAL_MAX_PATH - 1) + return VINF_SUCCESS; + } + } + /* + * We're good if the caller already supplied the passthru/length prefix: '\\?\' + */ + else if ( pszPath[1] == '?' + && RTPATH_IS_SLASH(pszPath[3]) + && RTPATH_IS_SLASH(pszPath[1]) + && RTPATH_IS_SLASH(pszPath[0])) + return VINF_SUCCESS; + + /* + * Long path requiring \\?\ prefixing. + * + * We piggy back on the NT conversion here and ASSUME RTUtf16Free is the right + * way to free the result. + */ + RTUtf16Free(*ppwszPath); + *ppwszPath = NULL; + + struct _UNICODE_STRING NtName = { 0, 0, NULL }; + HANDLE hRootDir = NULL; + rc = RTNtPathFromWinUtf8(&NtName, &hRootDir, pszPath); + if (RT_SUCCESS(rc)) + { + /* No root dir handle. */ + if (hRootDir == NULL) + { + /* Convert the NT '\??\' prefix to a win32 passthru prefix '\\?\' */ + if ( NtName.Buffer[0] == '\\' + && NtName.Buffer[1] == '?' + && NtName.Buffer[2] == '?' + && NtName.Buffer[3] == '\\') + { + NtName.Buffer[1] = '\\'; + + /* Zero termination paranoia. */ + if (NtName.Buffer[NtName.Length / sizeof(RTUTF16)] == '\0') + { + *ppwszPath = NtName.Buffer; + return VINF_SUCCESS; + } + AssertMsgFailed(("Length=%u %.*ls\n", NtName.Length, NtName.Length / sizeof(RTUTF16), NtName.Buffer)); + } + else + AssertMsgFailed(("%ls\n", NtName.Buffer)); + } + else + AssertMsgFailed(("%s\n", pszPath)); + RTNtPathFree(&NtName, &hRootDir); + } + } + return rc; +} + + +RTDECL(void) RTPathWinFree(PRTUTF16 pwszPath) +{ + RTUtf16Free(pwszPath); +} + diff --git a/src/VBox/Runtime/r3/win/pipe-win.cpp b/src/VBox/Runtime/r3/win/pipe-win.cpp new file mode 100644 index 00000000..44db3a62 --- /dev/null +++ b/src/VBox/Runtime/r3/win/pipe-win.cpp @@ -0,0 +1,1448 @@ +/* $Id: pipe-win.cpp $ */ +/** @file + * IPRT - Anonymous Pipes, Windows Implementation. + */ + +/* + * Copyright (C) 2010-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/windows.h> + +#include <iprt/pipe.h> +#include "internal/iprt.h" + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/critsect.h> +#include <iprt/err.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/poll.h> +#include <iprt/process.h> +#include <iprt/thread.h> +#include <iprt/time.h> +#include "internal/pipe.h" +#include "internal/magics.h" +#include "internal-r3-win.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The pipe buffer size we prefer. */ +#define RTPIPE_NT_SIZE _64K + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef struct RTPIPEINTERNAL +{ + /** Magic value (RTPIPE_MAGIC). */ + uint32_t u32Magic; + /** The pipe handle. */ + HANDLE hPipe; + /** Set if this is the read end, clear if it's the write end. */ + bool fRead; + /** Set if there is already pending I/O. */ + bool fIOPending; + /** Set if the zero byte read that the poll code using is pending. */ + bool fZeroByteRead; + /** Set if the pipe is broken. */ + bool fBrokenPipe; + /** Set if we've promised that the handle is writable. */ + bool fPromisedWritable; + /** Set if created inheritable. */ + bool fCreatedInheritable; + /** Usage counter. */ + uint32_t cUsers; + /** The overlapped I/O structure we use. */ + OVERLAPPED Overlapped; + /** Bounce buffer for writes. */ + uint8_t *pbBounceBuf; + /** Amount of used buffer space. */ + size_t cbBounceBufUsed; + /** Amount of allocated buffer space. */ + size_t cbBounceBufAlloc; + /** The handle of the poll set currently polling on this pipe. + * We can only have one poller at the time (lazy bird). */ + RTPOLLSET hPollSet; + /** Critical section protecting the above members. + * (Taking the lazy/simple approach.) */ + RTCRITSECT CritSect; + /** Buffer for the zero byte read. */ + uint8_t abBuf[8]; +} RTPIPEINTERNAL; + + +/* from ntdef.h */ +typedef LONG NTSTATUS; + +/* from ntddk.h */ +typedef struct _IO_STATUS_BLOCK { + union { + NTSTATUS Status; + PVOID Pointer; + }; + ULONG_PTR Information; +} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK; + +typedef enum _FILE_INFORMATION_CLASS { + FilePipeInformation = 23, + FilePipeLocalInformation = 24, + FilePipeRemoteInformation = 25, +} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS; + +/* from ntifs.h */ +typedef struct _FILE_PIPE_LOCAL_INFORMATION { + ULONG NamedPipeType; + ULONG NamedPipeConfiguration; + ULONG MaximumInstances; + ULONG CurrentInstances; + ULONG InboundQuota; + ULONG ReadDataAvailable; + ULONG OutboundQuota; + ULONG WriteQuotaAvailable; + ULONG NamedPipeState; + ULONG NamedPipeEnd; +} FILE_PIPE_LOCAL_INFORMATION, *PFILE_PIPE_LOCAL_INFORMATION; + +#define FILE_PIPE_DISCONNECTED_STATE 0x00000001U +#define FILE_PIPE_LISTENING_STATE 0x00000002U +#define FILE_PIPE_CONNECTED_STATE 0x00000003U +#define FILE_PIPE_CLOSING_STATE 0x00000004U + +#define FILE_PIPE_INBOUND 0x00000000U +#define FILE_PIPE_OUTBOUND 0x00000001U +#define FILE_PIPE_FULL_DUPLEX 0x00000002U + +#define FILE_PIPE_CLIENT_END 0x00000000U +#define FILE_PIPE_SERVER_END 0x00000001U + +extern "C" NTSYSAPI NTSTATUS WINAPI NtQueryInformationFile(HANDLE, PIO_STATUS_BLOCK, PVOID, LONG, FILE_INFORMATION_CLASS); + + +/** + * Wrapper for getting FILE_PIPE_LOCAL_INFORMATION via the NT API. + * + * @returns Success indicator (true/false). + * @param pThis The pipe. + * @param pInfo The info structure. + */ +static bool rtPipeQueryNtInfo(RTPIPEINTERNAL *pThis, FILE_PIPE_LOCAL_INFORMATION *pInfo) +{ + IO_STATUS_BLOCK Ios; + RT_ZERO(Ios); + RT_ZERO(*pInfo); + NTSTATUS rcNt = NtQueryInformationFile(pThis->hPipe, &Ios, pInfo, sizeof(*pInfo), FilePipeLocalInformation); + return rcNt >= 0; +} + + +RTDECL(int) RTPipeCreate(PRTPIPE phPipeRead, PRTPIPE phPipeWrite, uint32_t fFlags) +{ + AssertPtrReturn(phPipeRead, VERR_INVALID_POINTER); + AssertPtrReturn(phPipeWrite, VERR_INVALID_POINTER); + AssertReturn(!(fFlags & ~RTPIPE_C_VALID_MASK), VERR_INVALID_PARAMETER); + + /* + * Create the read end of the pipe. + */ + DWORD dwErr; + HANDLE hPipeR; + HANDLE hPipeW; + int rc; + for (;;) + { + static volatile uint32_t g_iNextPipe = 0; + char szName[128]; + RTStrPrintf(szName, sizeof(szName), "\\\\.\\pipe\\iprt-pipe-%u-%u", RTProcSelf(), ASMAtomicIncU32(&g_iNextPipe)); + + SECURITY_ATTRIBUTES SecurityAttributes; + PSECURITY_ATTRIBUTES pSecurityAttributes = NULL; + if (fFlags & RTPIPE_C_INHERIT_READ) + { + SecurityAttributes.nLength = sizeof(SecurityAttributes); + SecurityAttributes.lpSecurityDescriptor = NULL; + SecurityAttributes.bInheritHandle = TRUE; + pSecurityAttributes = &SecurityAttributes; + } + + DWORD dwOpenMode = PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED; +#ifdef FILE_FLAG_FIRST_PIPE_INSTANCE + dwOpenMode |= FILE_FLAG_FIRST_PIPE_INSTANCE; +#endif + + DWORD dwPipeMode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT; +#ifdef PIPE_REJECT_REMOTE_CLIENTS + dwPipeMode |= PIPE_REJECT_REMOTE_CLIENTS; +#endif + + hPipeR = CreateNamedPipeA(szName, dwOpenMode, dwPipeMode, 1 /*nMaxInstances*/, RTPIPE_NT_SIZE, RTPIPE_NT_SIZE, + NMPWAIT_USE_DEFAULT_WAIT, pSecurityAttributes); +#ifdef PIPE_REJECT_REMOTE_CLIENTS + if (hPipeR == INVALID_HANDLE_VALUE && GetLastError() == ERROR_INVALID_PARAMETER) + { + dwPipeMode &= ~PIPE_REJECT_REMOTE_CLIENTS; + hPipeR = CreateNamedPipeA(szName, dwOpenMode, dwPipeMode, 1 /*nMaxInstances*/, RTPIPE_NT_SIZE, RTPIPE_NT_SIZE, + NMPWAIT_USE_DEFAULT_WAIT, pSecurityAttributes); + } +#endif +#ifdef FILE_FLAG_FIRST_PIPE_INSTANCE + if (hPipeR == INVALID_HANDLE_VALUE && GetLastError() == ERROR_INVALID_PARAMETER) + { + dwOpenMode &= ~FILE_FLAG_FIRST_PIPE_INSTANCE; + hPipeR = CreateNamedPipeA(szName, dwOpenMode, dwPipeMode, 1 /*nMaxInstances*/, RTPIPE_NT_SIZE, RTPIPE_NT_SIZE, + NMPWAIT_USE_DEFAULT_WAIT, pSecurityAttributes); + } +#endif + if (hPipeR != INVALID_HANDLE_VALUE) + { + /* + * Connect to the pipe (the write end). + * We add FILE_READ_ATTRIBUTES here to make sure we can query the + * pipe state later on. + */ + pSecurityAttributes = NULL; + if (fFlags & RTPIPE_C_INHERIT_WRITE) + { + SecurityAttributes.nLength = sizeof(SecurityAttributes); + SecurityAttributes.lpSecurityDescriptor = NULL; + SecurityAttributes.bInheritHandle = TRUE; + pSecurityAttributes = &SecurityAttributes; + } + + hPipeW = CreateFileA(szName, + GENERIC_WRITE | FILE_READ_ATTRIBUTES /*dwDesiredAccess*/, + 0 /*dwShareMode*/, + pSecurityAttributes, + OPEN_EXISTING /* dwCreationDisposition */, + FILE_FLAG_OVERLAPPED /*dwFlagsAndAttributes*/, + NULL /*hTemplateFile*/); + if (hPipeW != INVALID_HANDLE_VALUE) + break; + dwErr = GetLastError(); + CloseHandle(hPipeR); + } + else + dwErr = GetLastError(); + if ( dwErr != ERROR_PIPE_BUSY /* already exist - compatible */ + && dwErr != ERROR_ACCESS_DENIED /* already exist - incompatible */) + return RTErrConvertFromWin32(dwErr); + /* else: try again with a new name */ + } + + /* + * Create the two handles. + */ + RTPIPEINTERNAL *pThisR = (RTPIPEINTERNAL *)RTMemAllocZ(sizeof(RTPIPEINTERNAL)); + if (pThisR) + { + RTPIPEINTERNAL *pThisW = (RTPIPEINTERNAL *)RTMemAllocZ(sizeof(RTPIPEINTERNAL)); + if (pThisW) + { + rc = RTCritSectInit(&pThisR->CritSect); + if (RT_SUCCESS(rc)) + { + rc = RTCritSectInit(&pThisW->CritSect); + if (RT_SUCCESS(rc)) + { + pThisR->Overlapped.hEvent = CreateEvent(NULL, TRUE /*fManualReset*/, + TRUE /*fInitialState*/, NULL /*pName*/); + if (pThisR->Overlapped.hEvent != NULL) + { + pThisW->Overlapped.hEvent = CreateEvent(NULL, TRUE /*fManualReset*/, + TRUE /*fInitialState*/, NULL /*pName*/); + if (pThisW->Overlapped.hEvent != NULL) + { + pThisR->u32Magic = RTPIPE_MAGIC; + pThisW->u32Magic = RTPIPE_MAGIC; + pThisR->hPipe = hPipeR; + pThisW->hPipe = hPipeW; + pThisR->fRead = true; + pThisW->fRead = false; + //pThisR->fIOPending = false; + //pThisW->fIOPending = false; + //pThisR->fZeroByteRead = false; + //pThisW->fZeroByteRead = false; + //pThisR->fBrokenPipe = false; + //pThisW->fBrokenPipe = false; + //pThisW->fPromisedWritable = false; + //pThisR->fPromisedWritable = false; + pThisW->fCreatedInheritable = RT_BOOL(fFlags & RTPIPE_C_INHERIT_WRITE); + pThisR->fCreatedInheritable = RT_BOOL(fFlags & RTPIPE_C_INHERIT_READ); + //pThisR->cUsers = 0; + //pThisW->cUsers = 0; + //pThisR->pbBounceBuf = NULL; + //pThisW->pbBounceBuf = NULL; + //pThisR->cbBounceBufUsed = 0; + //pThisW->cbBounceBufUsed = 0; + //pThisR->cbBounceBufAlloc = 0; + //pThisW->cbBounceBufAlloc = 0; + pThisR->hPollSet = NIL_RTPOLLSET; + pThisW->hPollSet = NIL_RTPOLLSET; + + *phPipeRead = pThisR; + *phPipeWrite = pThisW; + return VINF_SUCCESS; + } + CloseHandle(pThisR->Overlapped.hEvent); + } + RTCritSectDelete(&pThisW->CritSect); + } + RTCritSectDelete(&pThisR->CritSect); + } + RTMemFree(pThisW); + } + else + rc = VERR_NO_MEMORY; + RTMemFree(pThisR); + } + else + rc = VERR_NO_MEMORY; + + CloseHandle(hPipeR); + CloseHandle(hPipeW); + return rc; +} + + +/** + * Common worker for handling I/O completion. + * + * This is used by RTPipeClose, RTPipeWrite and RTPipeWriteBlocking. + * + * @returns IPRT status code. + * @param pThis The pipe instance handle. + */ +static int rtPipeWriteCheckCompletion(RTPIPEINTERNAL *pThis) +{ + int rc; + DWORD dwRc = WaitForSingleObject(pThis->Overlapped.hEvent, 0); + if (dwRc == WAIT_OBJECT_0) + { + DWORD cbWritten = 0; + if (GetOverlappedResult(pThis->hPipe, &pThis->Overlapped, &cbWritten, TRUE)) + { + for (;;) + { + if (cbWritten >= pThis->cbBounceBufUsed) + { + pThis->fIOPending = false; + rc = VINF_SUCCESS; + break; + } + + /* resubmit the remainder of the buffer - can this actually happen? */ + memmove(&pThis->pbBounceBuf[0], &pThis->pbBounceBuf[cbWritten], pThis->cbBounceBufUsed - cbWritten); + rc = ResetEvent(pThis->Overlapped.hEvent); Assert(rc == TRUE); + if (!WriteFile(pThis->hPipe, pThis->pbBounceBuf, (DWORD)pThis->cbBounceBufUsed, + &cbWritten, &pThis->Overlapped)) + { + if (GetLastError() == ERROR_IO_PENDING) + rc = VINF_TRY_AGAIN; + else + { + pThis->fIOPending = false; + if (GetLastError() == ERROR_NO_DATA) + rc = VERR_BROKEN_PIPE; + else + rc = RTErrConvertFromWin32(GetLastError()); + if (rc == VERR_BROKEN_PIPE) + pThis->fBrokenPipe = true; + } + break; + } + Assert(cbWritten > 0); + } + } + else + { + pThis->fIOPending = false; + rc = RTErrConvertFromWin32(GetLastError()); + } + } + else if (dwRc == WAIT_TIMEOUT) + rc = VINF_TRY_AGAIN; + else + { + pThis->fIOPending = false; + if (dwRc == WAIT_ABANDONED) + rc = VERR_INVALID_HANDLE; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + return rc; +} + + + +RTDECL(int) RTPipeClose(RTPIPE hPipe) +{ + RTPIPEINTERNAL *pThis = hPipe; + if (pThis == NIL_RTPIPE) + return VINF_SUCCESS; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); + + /* + * Do the cleanup. + */ + AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTPIPE_MAGIC, RTPIPE_MAGIC), VERR_INVALID_HANDLE); + RTCritSectEnter(&pThis->CritSect); + Assert(pThis->cUsers == 0); + + if (!pThis->fRead && pThis->fIOPending) + rtPipeWriteCheckCompletion(pThis); + + CloseHandle(pThis->hPipe); + pThis->hPipe = INVALID_HANDLE_VALUE; + + CloseHandle(pThis->Overlapped.hEvent); + pThis->Overlapped.hEvent = NULL; + + RTMemFree(pThis->pbBounceBuf); + pThis->pbBounceBuf = NULL; + + RTCritSectLeave(&pThis->CritSect); + RTCritSectDelete(&pThis->CritSect); + + RTMemFree(pThis); + + return VINF_SUCCESS; +} + + +RTDECL(int) RTPipeFromNative(PRTPIPE phPipe, RTHCINTPTR hNativePipe, uint32_t fFlags) +{ + AssertPtrReturn(phPipe, VERR_INVALID_POINTER); + AssertReturn(!(fFlags & ~RTPIPE_N_VALID_MASK), VERR_INVALID_PARAMETER); + AssertReturn(!!(fFlags & RTPIPE_N_READ) != !!(fFlags & RTPIPE_N_WRITE), VERR_INVALID_PARAMETER); + + /* + * Get and validate the pipe handle info. + */ + HANDLE hNative = (HANDLE)hNativePipe; + AssertReturn(GetFileType(hNative) == FILE_TYPE_PIPE, VERR_INVALID_HANDLE); + + DWORD cMaxInstances; + DWORD fInfo; + if (!GetNamedPipeInfo(hNative, &fInfo, NULL, NULL, &cMaxInstances)) + return RTErrConvertFromWin32(GetLastError()); + AssertReturn(!(fInfo & PIPE_TYPE_MESSAGE), VERR_INVALID_HANDLE); + AssertReturn(cMaxInstances == 1, VERR_INVALID_HANDLE); + + DWORD cInstances; + DWORD fState; + if (!GetNamedPipeHandleState(hNative, &fState, &cInstances, NULL, NULL, NULL, 0)) + return RTErrConvertFromWin32(GetLastError()); + AssertReturn(!(fState & PIPE_NOWAIT), VERR_INVALID_HANDLE); + AssertReturn(!(fState & PIPE_READMODE_MESSAGE), VERR_INVALID_HANDLE); + AssertReturn(cInstances <= 1, VERR_INVALID_HANDLE); + + /* + * Looks kind of OK, create a handle so we can try rtPipeQueryNtInfo on it + * and see if we need to duplicate it to make that call work. + */ + RTPIPEINTERNAL *pThis = (RTPIPEINTERNAL *)RTMemAllocZ(sizeof(RTPIPEINTERNAL)); + if (!pThis) + return VERR_NO_MEMORY; + int rc = RTCritSectInit(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + pThis->Overlapped.hEvent = CreateEvent(NULL, TRUE /*fManualReset*/, + TRUE /*fInitialState*/, NULL /*pName*/); + if (pThis->Overlapped.hEvent != NULL) + { + pThis->u32Magic = RTPIPE_MAGIC; + pThis->hPipe = hNative; + pThis->fRead = !!(fFlags & RTPIPE_N_READ); + //pThis->fIOPending = false; + //pThis->fZeroByteRead = false; + //pThis->fBrokenPipe = false; + //pThis->fPromisedWritable = false; + pThis->fCreatedInheritable = RT_BOOL(fFlags & RTPIPE_N_INHERIT); + //pThis->cUsers = 0; + //pThis->pbBounceBuf = NULL; + //pThis->cbBounceBufUsed = 0; + //pThis->cbBounceBufAlloc = 0; + pThis->hPollSet = NIL_RTPOLLSET; + + HANDLE hNative2 = INVALID_HANDLE_VALUE; + FILE_PIPE_LOCAL_INFORMATION Info; + RT_ZERO(Info); + if ( g_enmWinVer != kRTWinOSType_NT310 + && rtPipeQueryNtInfo(pThis, &Info)) + rc = VINF_SUCCESS; + else + { + if (DuplicateHandle(GetCurrentProcess() /*hSrcProcess*/, hNative /*hSrcHandle*/, + GetCurrentProcess() /*hDstProcess*/, &hNative2 /*phDstHandle*/, + pThis->fRead ? GENERIC_READ : GENERIC_WRITE | FILE_READ_ATTRIBUTES /*dwDesiredAccess*/, + !!(fFlags & RTPIPE_N_INHERIT) /*fInheritHandle*/, + 0 /*dwOptions*/)) + { + pThis->hPipe = hNative2; + if (rtPipeQueryNtInfo(pThis, &Info)) + rc = VINF_SUCCESS; + else + { + rc = VERR_ACCESS_DENIED; + CloseHandle(hNative2); + } + } + else + hNative2 = INVALID_HANDLE_VALUE; + } + if (RT_SUCCESS(rc)) + { + /* + * Verify the pipe state and correct the inheritability. + */ + AssertStmt( Info.NamedPipeState == FILE_PIPE_CONNECTED_STATE + || Info.NamedPipeState == FILE_PIPE_CLOSING_STATE + || Info.NamedPipeState == FILE_PIPE_DISCONNECTED_STATE, + VERR_INVALID_HANDLE); + AssertStmt( Info.NamedPipeConfiguration + == ( Info.NamedPipeEnd == FILE_PIPE_SERVER_END + ? (pThis->fRead ? FILE_PIPE_INBOUND : FILE_PIPE_OUTBOUND) + : (pThis->fRead ? FILE_PIPE_OUTBOUND : FILE_PIPE_INBOUND) ) + || Info.NamedPipeConfiguration == FILE_PIPE_FULL_DUPLEX, + VERR_INVALID_HANDLE); + if ( RT_SUCCESS(rc) + && hNative2 == INVALID_HANDLE_VALUE + && !SetHandleInformation(hNative, + HANDLE_FLAG_INHERIT /*dwMask*/, + fFlags & RTPIPE_N_INHERIT ? HANDLE_FLAG_INHERIT : 0)) + { + rc = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailed(("%Rrc\n", rc)); + } + if (RT_SUCCESS(rc)) + { + /* + * Ok, we're good! If we replaced the handle, make sure it's not a standard + * handle if we think we need to close it. + */ + if (hNative2 != INVALID_HANDLE_VALUE) + { + if ( hNative != GetStdHandle(STD_INPUT_HANDLE) + && hNative != GetStdHandle(STD_OUTPUT_HANDLE) + && hNative != GetStdHandle(STD_ERROR_HANDLE)) + CloseHandle(hNative); + } + *phPipe = pThis; + return VINF_SUCCESS; + } + } + + /* Bail out. */ + if (hNative2 != INVALID_HANDLE_VALUE) + CloseHandle(hNative2); + CloseHandle(pThis->Overlapped.hEvent); + } + RTCritSectDelete(&pThis->CritSect); + } + RTMemFree(pThis); + return rc; +} + + +RTDECL(RTHCINTPTR) RTPipeToNative(RTPIPE hPipe) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, -1); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, -1); + + return (RTHCINTPTR)pThis->hPipe; +} + + +RTDECL(int) RTPipeGetCreationInheritability(RTPIPE hPipe) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, false); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, false); + + return pThis->fCreatedInheritable; +} + + +RTDECL(int) RTPipeRead(RTPIPE hPipe, void *pvBuf, size_t cbToRead, size_t *pcbRead) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(pThis->fRead, VERR_ACCESS_DENIED); + AssertPtr(pcbRead); + AssertPtr(pvBuf); + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + /* No concurrent readers, sorry. */ + if (pThis->cUsers == 0) + { + pThis->cUsers++; + + /* + * Kick of a an overlapped read. It should return immediately if + * there is bytes in the buffer. If not, we'll cancel it and see + * what we get back. + */ + rc = ResetEvent(pThis->Overlapped.hEvent); Assert(rc == TRUE); + DWORD cbRead = 0; + if ( cbToRead == 0 + || ReadFile(pThis->hPipe, pvBuf, + cbToRead <= ~(DWORD)0 ? (DWORD)cbToRead : ~(DWORD)0, + &cbRead, &pThis->Overlapped)) + { + *pcbRead = cbRead; + rc = VINF_SUCCESS; + } + else if (GetLastError() == ERROR_IO_PENDING) + { + pThis->fIOPending = true; + RTCritSectLeave(&pThis->CritSect); + + if (!CancelIo(pThis->hPipe)) + WaitForSingleObject(pThis->Overlapped.hEvent, INFINITE); + if (GetOverlappedResult(pThis->hPipe, &pThis->Overlapped, &cbRead, TRUE /*fWait*/)) + { + *pcbRead = cbRead; + rc = VINF_SUCCESS; + } + else if (GetLastError() == ERROR_OPERATION_ABORTED) + { + *pcbRead = 0; + rc = VINF_TRY_AGAIN; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + RTCritSectEnter(&pThis->CritSect); + pThis->fIOPending = false; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + if (rc == VERR_BROKEN_PIPE) + pThis->fBrokenPipe = true; + + pThis->cUsers--; + } + else + rc = VERR_WRONG_ORDER; + RTCritSectLeave(&pThis->CritSect); + } + return rc; +} + + +RTDECL(int) RTPipeReadBlocking(RTPIPE hPipe, void *pvBuf, size_t cbToRead, size_t *pcbRead) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(pThis->fRead, VERR_ACCESS_DENIED); + AssertPtr(pvBuf); + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + /* No concurrent readers, sorry. */ + if (pThis->cUsers == 0) + { + pThis->cUsers++; + + size_t cbTotalRead = 0; + while (cbToRead > 0) + { + /* + * Kick of a an overlapped read. It should return immediately if + * there is bytes in the buffer. If not, we'll cancel it and see + * what we get back. + */ + rc = ResetEvent(pThis->Overlapped.hEvent); Assert(rc == TRUE); + DWORD cbRead = 0; + pThis->fIOPending = true; + RTCritSectLeave(&pThis->CritSect); + + if (ReadFile(pThis->hPipe, pvBuf, + cbToRead <= ~(DWORD)0 ? (DWORD)cbToRead : ~(DWORD)0, + &cbRead, &pThis->Overlapped)) + rc = VINF_SUCCESS; + else if (GetLastError() == ERROR_IO_PENDING) + { + WaitForSingleObject(pThis->Overlapped.hEvent, INFINITE); + if (GetOverlappedResult(pThis->hPipe, &pThis->Overlapped, &cbRead, TRUE /*fWait*/)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + RTCritSectEnter(&pThis->CritSect); + pThis->fIOPending = false; + if (RT_FAILURE(rc)) + break; + + /* advance */ + cbToRead -= cbRead; + cbTotalRead += cbRead; + pvBuf = (uint8_t *)pvBuf + cbRead; + } + + if (rc == VERR_BROKEN_PIPE) + pThis->fBrokenPipe = true; + + if (pcbRead) + { + *pcbRead = cbTotalRead; + if ( RT_FAILURE(rc) + && cbTotalRead + && rc != VERR_INVALID_POINTER) + rc = VINF_SUCCESS; + } + + pThis->cUsers--; + } + else + rc = VERR_WRONG_ORDER; + RTCritSectLeave(&pThis->CritSect); + } + return rc; +} + + +RTDECL(int) RTPipeWrite(RTPIPE hPipe, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(!pThis->fRead, VERR_ACCESS_DENIED); + AssertPtr(pcbWritten); + AssertPtr(pvBuf); + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + /* No concurrent writers, sorry. */ + if (pThis->cUsers == 0) + { + pThis->cUsers++; + + /* If I/O is pending, check if it has completed. */ + if (pThis->fIOPending) + rc = rtPipeWriteCheckCompletion(pThis); + else + rc = VINF_SUCCESS; + if (rc == VINF_SUCCESS) + { + Assert(!pThis->fIOPending); + + /* Adjust the number of bytes to write to fit into the current + buffer quota, unless we've promised stuff in RTPipeSelectOne. + WriteQuotaAvailable better not be zero when it shouldn't!! */ + FILE_PIPE_LOCAL_INFORMATION Info; + if ( !pThis->fPromisedWritable + && cbToWrite > 0 + && rtPipeQueryNtInfo(pThis, &Info)) + { + if (Info.NamedPipeState == FILE_PIPE_CLOSING_STATE) + rc = VERR_BROKEN_PIPE; + /** @todo fixme: To get the pipe writing support to work the + * block below needs to be commented out until a + * way is found to address the problem of the incorrectly + * set field Info.WriteQuotaAvailable. */ +#if 0 + else if ( cbToWrite >= Info.WriteQuotaAvailable + && Info.OutboundQuota != 0 + && (Info.WriteQuotaAvailable || pThis->cbBounceBufAlloc) + ) + { + cbToWrite = Info.WriteQuotaAvailable; + if (!cbToWrite) + rc = VINF_TRY_AGAIN; + } +#endif + } + pThis->fPromisedWritable = false; + + /* Do the bounce buffering. */ + if ( pThis->cbBounceBufAlloc < cbToWrite + && pThis->cbBounceBufAlloc < RTPIPE_NT_SIZE) + { + if (cbToWrite > RTPIPE_NT_SIZE) + cbToWrite = RTPIPE_NT_SIZE; + void *pv = RTMemRealloc(pThis->pbBounceBuf, RT_ALIGN_Z(cbToWrite, _1K)); + if (pv) + { + pThis->pbBounceBuf = (uint8_t *)pv; + pThis->cbBounceBufAlloc = RT_ALIGN_Z(cbToWrite, _1K); + } + else + rc = VERR_NO_MEMORY; + } + else if (cbToWrite > RTPIPE_NT_SIZE) + cbToWrite = RTPIPE_NT_SIZE; + if (RT_SUCCESS(rc) && cbToWrite) + { + memcpy(pThis->pbBounceBuf, pvBuf, cbToWrite); + pThis->cbBounceBufUsed = (uint32_t)cbToWrite; + + /* Submit the write. */ + rc = ResetEvent(pThis->Overlapped.hEvent); Assert(rc == TRUE); + DWORD cbWritten = 0; + if (WriteFile(pThis->hPipe, pThis->pbBounceBuf, (DWORD)pThis->cbBounceBufUsed, + &cbWritten, &pThis->Overlapped)) + { + *pcbWritten = RT_MIN(cbWritten, cbToWrite); /* paranoia^3 */ + rc = VINF_SUCCESS; + } + else if (GetLastError() == ERROR_IO_PENDING) + { + *pcbWritten = cbToWrite; + pThis->fIOPending = true; + rc = VINF_SUCCESS; + } + else if (GetLastError() == ERROR_NO_DATA) + rc = VERR_BROKEN_PIPE; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else if (RT_SUCCESS(rc)) + *pcbWritten = 0; + } + else if (RT_SUCCESS(rc)) + *pcbWritten = 0; + + if (rc == VERR_BROKEN_PIPE) + pThis->fBrokenPipe = true; + + pThis->cUsers--; + } + else + rc = VERR_WRONG_ORDER; + RTCritSectLeave(&pThis->CritSect); + } + return rc; +} + + +RTDECL(int) RTPipeWriteBlocking(RTPIPE hPipe, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(!pThis->fRead, VERR_ACCESS_DENIED); + AssertPtr(pvBuf); + AssertPtrNull(pcbWritten); + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_SUCCESS(rc)) + { + /* No concurrent writers, sorry. */ + if (pThis->cUsers == 0) + { + pThis->cUsers++; + + /* + * If I/O is pending, wait for it to complete. + */ + if (pThis->fIOPending) + { + rc = rtPipeWriteCheckCompletion(pThis); + while (rc == VINF_TRY_AGAIN) + { + Assert(pThis->fIOPending); + HANDLE hEvent = pThis->Overlapped.hEvent; + RTCritSectLeave(&pThis->CritSect); + WaitForSingleObject(hEvent, INFINITE); + RTCritSectEnter(&pThis->CritSect); + } + } + if (RT_SUCCESS(rc)) + { + Assert(!pThis->fIOPending); + pThis->fPromisedWritable = false; + + /* + * Try write everything. + * No bounce buffering, cUsers protects us. + */ + size_t cbTotalWritten = 0; + while (cbToWrite > 0) + { + rc = ResetEvent(pThis->Overlapped.hEvent); Assert(rc == TRUE); + pThis->fIOPending = true; + RTCritSectLeave(&pThis->CritSect); + + DWORD cbWritten = 0; + DWORD const cbToWriteInThisIteration = cbToWrite <= ~(DWORD)0 ? (DWORD)cbToWrite : ~(DWORD)0; + if (WriteFile(pThis->hPipe, pvBuf, cbToWriteInThisIteration, &cbWritten, &pThis->Overlapped)) + rc = VINF_SUCCESS; + else if (GetLastError() == ERROR_IO_PENDING) + { + WaitForSingleObject(pThis->Overlapped.hEvent, INFINITE); + if (GetOverlappedResult(pThis->hPipe, &pThis->Overlapped, &cbWritten, TRUE /*fWait*/)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else if (GetLastError() == ERROR_NO_DATA) + rc = VERR_BROKEN_PIPE; + else + rc = RTErrConvertFromWin32(GetLastError()); + + RTCritSectEnter(&pThis->CritSect); + pThis->fIOPending = false; + if (RT_FAILURE(rc)) + break; + + /* advance */ + if (cbWritten > cbToWriteInThisIteration) /* paranoia^3 */ + cbWritten = cbToWriteInThisIteration; + pvBuf = (char const *)pvBuf + cbWritten; + cbTotalWritten += cbWritten; + cbToWrite -= cbWritten; + } + + if (pcbWritten) + { + *pcbWritten = cbTotalWritten; + if ( RT_FAILURE(rc) + && cbTotalWritten + && rc != VERR_INVALID_POINTER) + rc = VINF_SUCCESS; + } + } + + if (rc == VERR_BROKEN_PIPE) + pThis->fBrokenPipe = true; + + pThis->cUsers--; + } + else + rc = VERR_WRONG_ORDER; + RTCritSectLeave(&pThis->CritSect); + } + return rc; + +#if 0 /** @todo r=bird: What's this? */ + int rc = rtPipeTryBlocking(pThis); + if (RT_SUCCESS(rc)) + { + size_t cbTotalWritten = 0; + while (cbToWrite > 0) + { + ssize_t cbWritten = write(pThis->fd, pvBuf, RT_MIN(cbToWrite, SSIZE_MAX)); + if (cbWritten < 0) + { + rc = RTErrConvertFromErrno(errno); + break; + } + + /* advance */ + pvBuf = (char const *)pvBuf + cbWritten; + cbTotalWritten += cbWritten; + cbToWrite -= cbWritten; + } + + if (pcbWritten) + { + *pcbWritten = cbTotalWritten; + if ( RT_FAILURE(rc) + && cbTotalWritten + && rc != VERR_INVALID_POINTER) + rc = VINF_SUCCESS; + } + + ASMAtomicDecU32(&pThis->u32State); + } + return rc; +#endif +} + + +RTDECL(int) RTPipeFlush(RTPIPE hPipe) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(!pThis->fRead, VERR_ACCESS_DENIED); + + if (!FlushFileBuffers(pThis->hPipe)) + { + int rc = RTErrConvertFromWin32(GetLastError()); + if (rc == VERR_BROKEN_PIPE) + pThis->fBrokenPipe = true; + return rc; + } + return VINF_SUCCESS; +} + + +RTDECL(int) RTPipeSelectOne(RTPIPE hPipe, RTMSINTERVAL cMillies) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); + + uint64_t const StartMsTS = RTTimeMilliTS(); + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_FAILURE(rc)) + return rc; + for (unsigned iLoop = 0;; iLoop++) + { + HANDLE hWait = INVALID_HANDLE_VALUE; + if (pThis->fRead) + { + if (pThis->fIOPending) + hWait = pThis->Overlapped.hEvent; + else + { + /* Peek at the pipe buffer and see how many bytes it contains. */ + DWORD cbAvailable; + if ( PeekNamedPipe(pThis->hPipe, NULL, 0, NULL, &cbAvailable, NULL) + && cbAvailable > 0) + { + rc = VINF_SUCCESS; + break; + } + + /* Start a zero byte read operation that we can wait on. */ + if (cMillies == 0) + { + rc = VERR_TIMEOUT; + break; + } + AssertBreakStmt(pThis->cUsers == 0, rc = VERR_INTERNAL_ERROR_5); + rc = ResetEvent(pThis->Overlapped.hEvent); Assert(rc == TRUE); + DWORD cbRead = 0; + if (ReadFile(pThis->hPipe, pThis->abBuf, 0, &cbRead, &pThis->Overlapped)) + { + rc = VINF_SUCCESS; + if (iLoop > 10) + RTThreadYield(); + } + else if (GetLastError() == ERROR_IO_PENDING) + { + pThis->cUsers++; + pThis->fIOPending = true; + pThis->fZeroByteRead = true; + hWait = pThis->Overlapped.hEvent; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + } + else + { + if (pThis->fIOPending) + { + rc = rtPipeWriteCheckCompletion(pThis); + if (RT_FAILURE(rc)) + break; + } + if (pThis->fIOPending) + hWait = pThis->Overlapped.hEvent; + else + { + FILE_PIPE_LOCAL_INFORMATION Info; + if (rtPipeQueryNtInfo(pThis, &Info)) + { + /* Check for broken pipe. */ + if (Info.NamedPipeState == FILE_PIPE_CLOSING_STATE) + { + rc = VERR_BROKEN_PIPE; + break; + } + /* Check for available write buffer space. */ + else if (Info.WriteQuotaAvailable > 0) + { + pThis->fPromisedWritable = false; + rc = VINF_SUCCESS; + break; + } + /* delayed buffer alloc or timeout: phony promise + later: See if we still can associate a semaphore with + the pipe, like on OS/2. */ + else if ( Info.OutboundQuota == 0 + || cMillies) + { + pThis->fPromisedWritable = true; + rc = VINF_SUCCESS; + break; + } + } + else + { + pThis->fPromisedWritable = true; + rc = VINF_SUCCESS; + break; + } + } + } + if (RT_FAILURE(rc)) + break; + + /* + * Check for timeout. + */ + DWORD cMsMaxWait = INFINITE; + if ( cMillies != RT_INDEFINITE_WAIT + && ( hWait != INVALID_HANDLE_VALUE + || iLoop > 10) + ) + { + uint64_t cElapsed = RTTimeMilliTS() - StartMsTS; + if (cElapsed >= cMillies) + { + rc = VERR_TIMEOUT; + break; + } + cMsMaxWait = cMillies - (uint32_t)cElapsed; + } + + /* + * Wait. + */ + if (hWait != INVALID_HANDLE_VALUE) + { + RTCritSectLeave(&pThis->CritSect); + + DWORD dwRc = WaitForSingleObject(hWait, cMsMaxWait); + if (dwRc == WAIT_OBJECT_0) + rc = VINF_SUCCESS; + else if (dwRc == WAIT_TIMEOUT) + rc = VERR_TIMEOUT; + else if (dwRc == WAIT_ABANDONED) + rc = VERR_INVALID_HANDLE; + else + rc = RTErrConvertFromWin32(GetLastError()); + if ( RT_FAILURE(rc) + && pThis->u32Magic != RTPIPE_MAGIC) + return rc; + + RTCritSectEnter(&pThis->CritSect); + if (pThis->fZeroByteRead) + { + pThis->cUsers--; + pThis->fIOPending = false; + if (rc != VINF_SUCCESS) + CancelIo(pThis->hPipe); + DWORD cbRead = 0; + GetOverlappedResult(pThis->hPipe, &pThis->Overlapped, &cbRead, TRUE /*fWait*/); + } + if (RT_FAILURE(rc)) + break; + } + } + + if (rc == VERR_BROKEN_PIPE) + pThis->fBrokenPipe = true; + + RTCritSectLeave(&pThis->CritSect); + return rc; +} + + +RTDECL(int) RTPipeQueryReadable(RTPIPE hPipe, size_t *pcbReadable) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(pThis->fRead, VERR_PIPE_NOT_READ); + AssertPtrReturn(pcbReadable, VERR_INVALID_POINTER); + + int rc = RTCritSectEnter(&pThis->CritSect); + if (RT_FAILURE(rc)) + return rc; + + DWORD cbAvailable = 0; + if (PeekNamedPipe(pThis->hPipe, NULL, 0, NULL, &cbAvailable, NULL)) + *pcbReadable = cbAvailable; + else + rc = RTErrConvertFromWin32(GetLastError()); + + RTCritSectLeave(&pThis->CritSect); + return rc; +} + + +RTDECL(int) RTPipeQueryInfo(RTPIPE hPipe, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, 0); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, 0); + + int rc = RTCritSectEnter(&pThis->CritSect); + AssertRCReturn(rc, 0); + + rtPipeFakeQueryInfo(pObjInfo, enmAddAttr, pThis->fRead); + + FILE_PIPE_LOCAL_INFORMATION Info; + if (rtPipeQueryNtInfo(pThis, &Info)) + { + pObjInfo->cbAllocated = pThis->fRead ? Info.InboundQuota : Info.OutboundQuota; + pObjInfo->cbObject = pThis->fRead ? Info.ReadDataAvailable : Info.WriteQuotaAvailable; + } + + RTCritSectLeave(&pThis->CritSect); + return VINF_SUCCESS; +} + + +int rtPipePollGetHandle(RTPIPE hPipe, uint32_t fEvents, PRTHCINTPTR phNative) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); + + AssertReturn(!(fEvents & RTPOLL_EVT_READ) || pThis->fRead, VERR_INVALID_PARAMETER); + AssertReturn(!(fEvents & RTPOLL_EVT_WRITE) || !pThis->fRead, VERR_INVALID_PARAMETER); + + /* Later: Try register an event handle with the pipe like on OS/2, there is + a file control for doing this obviously intended for the OS/2 subsys. + The question is whether this still exists on Vista and W7. */ + *phNative = (RTHCINTPTR)pThis->Overlapped.hEvent; + return VINF_SUCCESS; +} + + +/** + * Checks for pending events. + * + * @returns Event mask or 0. + * @param pThis The pipe handle. + * @param fEvents The desired events. + */ +static uint32_t rtPipePollCheck(RTPIPEINTERNAL *pThis, uint32_t fEvents) +{ + uint32_t fRetEvents = 0; + if (pThis->fBrokenPipe) + fRetEvents |= RTPOLL_EVT_ERROR; + else if (pThis->fRead) + { + if (!pThis->fIOPending) + { + DWORD cbAvailable; + if (PeekNamedPipe(pThis->hPipe, NULL, 0, NULL, &cbAvailable, NULL)) + { + if ( (fEvents & RTPOLL_EVT_READ) + && cbAvailable > 0) + fRetEvents |= RTPOLL_EVT_READ; + } + else + { + if (GetLastError() == ERROR_BROKEN_PIPE) + pThis->fBrokenPipe = true; + fRetEvents |= RTPOLL_EVT_ERROR; + } + } + } + else + { + if (pThis->fIOPending) + { + rtPipeWriteCheckCompletion(pThis); + if (pThis->fBrokenPipe) + fRetEvents |= RTPOLL_EVT_ERROR; + } + if ( !pThis->fIOPending + && !fRetEvents) + { + FILE_PIPE_LOCAL_INFORMATION Info; + if (rtPipeQueryNtInfo(pThis, &Info)) + { + /* Check for broken pipe. */ + if (Info.NamedPipeState == FILE_PIPE_CLOSING_STATE) + { + fRetEvents = RTPOLL_EVT_ERROR; + pThis->fBrokenPipe = true; + } + + /* Check if there is available buffer space. */ + if ( !fRetEvents + && (fEvents & RTPOLL_EVT_WRITE) + && ( Info.WriteQuotaAvailable > 0 + || Info.OutboundQuota == 0) + ) + fRetEvents |= RTPOLL_EVT_WRITE; + } + else if (fEvents & RTPOLL_EVT_WRITE) + fRetEvents |= RTPOLL_EVT_WRITE; + } + } + + return fRetEvents; +} + + +/** + * Internal RTPoll helper that polls the pipe handle and, if @a fNoWait is + * clear, starts whatever actions we've got running during the poll call. + * + * @returns 0 if no pending events, actions initiated if @a fNoWait is clear. + * Event mask (in @a fEvents) and no actions if the handle is ready + * already. + * UINT32_MAX (asserted) if the pipe handle is busy in I/O or a + * different poll set. + * + * @param hPipe The pipe handle. + * @param hPollSet The poll set handle (for access checks). + * @param fEvents The events we're polling for. + * @param fFinalEntry Set if this is the final entry for this handle + * in this poll set. This can be used for dealing + * with duplicate entries. + * @param fNoWait Set if it's a zero-wait poll call. Clear if + * we'll wait for an event to occur. + */ +uint32_t rtPipePollStart(RTPIPE hPipe, RTPOLLSET hPollSet, uint32_t fEvents, bool fFinalEntry, bool fNoWait) +{ + /** @todo All this polling code could be optimized to make fewer system + * calls; like for instance the ResetEvent calls. */ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, UINT32_MAX); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, UINT32_MAX); + RT_NOREF_PV(fFinalEntry); + + int rc = RTCritSectEnter(&pThis->CritSect); + AssertRCReturn(rc, UINT32_MAX); + + /* Check that this is the only current use of this pipe. */ + uint32_t fRetEvents; + if ( pThis->cUsers == 0 + || pThis->hPollSet == hPollSet) + { + /* Check what the current events are. */ + fRetEvents = rtPipePollCheck(pThis, fEvents); + if ( !fRetEvents + && !fNoWait) + { + /* Make sure the event semaphore has been reset. */ + if (!pThis->fIOPending) + { + rc = ResetEvent(pThis->Overlapped.hEvent); + Assert(rc == TRUE); + } + + /* Kick off the zero byte read thing if applicable. */ + if ( !pThis->fIOPending + && pThis->fRead + && (fEvents & RTPOLL_EVT_READ) + ) + { + DWORD cbRead = 0; + if (ReadFile(pThis->hPipe, pThis->abBuf, 0, &cbRead, &pThis->Overlapped)) + fRetEvents = rtPipePollCheck(pThis, fEvents); + else if (GetLastError() == ERROR_IO_PENDING) + { + pThis->fIOPending = true; + pThis->fZeroByteRead = true; + } + else + fRetEvents = RTPOLL_EVT_ERROR; + } + + /* If we're still set for the waiting, record the poll set and + mark the pipe used. */ + if (!fRetEvents) + { + pThis->cUsers++; + pThis->hPollSet = hPollSet; + } + } + } + else + { + AssertFailed(); + fRetEvents = UINT32_MAX; + } + + RTCritSectLeave(&pThis->CritSect); + return fRetEvents; +} + + +/** + * Called after a WaitForMultipleObjects returned in order to check for pending + * events and stop whatever actions that rtPipePollStart() initiated. + * + * @returns Event mask or 0. + * + * @param hPipe The pipe handle. + * @param fEvents The events we're polling for. + * @param fFinalEntry Set if this is the final entry for this handle + * in this poll set. This can be used for dealing + * with duplicate entries. Only keep in mind that + * this method is called in reverse order, so the + * first call will have this set (when the entire + * set was processed). + * @param fHarvestEvents Set if we should check for pending events. + */ +uint32_t rtPipePollDone(RTPIPE hPipe, uint32_t fEvents, bool fFinalEntry, bool fHarvestEvents) +{ + RTPIPEINTERNAL *pThis = hPipe; + AssertPtrReturn(pThis, 0); + AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, 0); + RT_NOREF_PV(fFinalEntry); + RT_NOREF_PV(fHarvestEvents); + + int rc = RTCritSectEnter(&pThis->CritSect); + AssertRCReturn(rc, 0); + + Assert(pThis->cUsers > 0); + + + /* Cancel the zero byte read. */ + uint32_t fRetEvents = 0; + if (pThis->fZeroByteRead) + { + CancelIo(pThis->hPipe); + DWORD cbRead = 0; + if ( !GetOverlappedResult(pThis->hPipe, &pThis->Overlapped, &cbRead, TRUE /*fWait*/) + && GetLastError() != ERROR_OPERATION_ABORTED) + fRetEvents = RTPOLL_EVT_ERROR; + + pThis->fIOPending = false; + pThis->fZeroByteRead = false; + } + + /* harvest events. */ + fRetEvents |= rtPipePollCheck(pThis, fEvents); + + /* update counters. */ + pThis->cUsers--; + /** @todo This isn't sane, or is it? See OS/2 impl. */ + if (!pThis->cUsers) + pThis->hPollSet = NIL_RTPOLLSET; + + RTCritSectLeave(&pThis->CritSect); + return fRetEvents; +} + diff --git a/src/VBox/Runtime/r3/win/process-win.cpp b/src/VBox/Runtime/r3/win/process-win.cpp new file mode 100644 index 00000000..a3d57d3e --- /dev/null +++ b/src/VBox/Runtime/r3/win/process-win.cpp @@ -0,0 +1,2675 @@ +/* $Id: process-win.cpp $ */ +/** @file + * IPRT - Process, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_PROCESS +#include <iprt/asm.h> /* hack */ + +#include <iprt/nt/nt-and-windows.h> +#include <Userenv.h> +#include <tlhelp32.h> +#include <process.h> +#include <errno.h> +#include <Strsafe.h> +#include <LsaLookup.h> +#include <Lmcons.h> + +#define _NTDEF_ /* Prevents redefining (P)UNICODE_STRING. */ +#include <Ntsecapi.h> + +#include <iprt/process.h> +#include "internal-r3-win.h" + +#include <iprt/assert.h> +#include <iprt/critsect.h> +#include <iprt/file.h> +#include <iprt/err.h> +#include <iprt/env.h> +#include <iprt/getopt.h> +#include <iprt/initterm.h> +#include <iprt/ldr.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/once.h> +#include <iprt/path.h> +#include <iprt/pipe.h> +#include <iprt/string.h> +#include <iprt/socket.h> +#include <iprt/utf16.h> + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/* kernel32.dll: */ +//typedef DWORD (WINAPI *PFNWTSGETACTIVECONSOLESESSIONID)(VOID); +typedef HANDLE (WINAPI *PFNCREATETOOLHELP32SNAPSHOT)(DWORD, DWORD); +typedef BOOL (WINAPI *PFNPROCESS32FIRST)(HANDLE, LPPROCESSENTRY32); +typedef BOOL (WINAPI *PFNPROCESS32FIRSTW)(HANDLE, LPPROCESSENTRY32W); +typedef BOOL (WINAPI *PFNPROCESS32NEXT)(HANDLE, LPPROCESSENTRY32); +typedef BOOL (WINAPI *PFNPROCESS32NEXTW)(HANDLE, LPPROCESSENTRY32W); + +/* psapi.dll: */ +typedef BOOL (WINAPI *PFNENUMPROCESSES)(LPDWORD, DWORD, LPDWORD); +typedef DWORD (WINAPI *PFNGETMODULEBASENAME)(HANDLE, HMODULE, LPTSTR, DWORD); + +/* advapi32.dll: */ +typedef BOOL (WINAPI *PFNCREATEPROCESSWITHLOGON)(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPCWSTR, LPWSTR, DWORD, + LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION); +typedef NTSTATUS (NTAPI *PFNLSALOOKUPNAMES2)(LSA_HANDLE, ULONG, ULONG, PLSA_UNICODE_STRING, + PLSA_REFERENCED_DOMAIN_LIST*, PLSA_TRANSLATED_SID2*); + +/* userenv.dll: */ +typedef BOOL (WINAPI *PFNCREATEENVIRONMENTBLOCK)(LPVOID *, HANDLE, BOOL); +typedef BOOL (WINAPI *PFNPFNDESTROYENVIRONMENTBLOCK)(LPVOID); +typedef BOOL (WINAPI *PFNLOADUSERPROFILEW)(HANDLE, LPPROFILEINFOW); +typedef BOOL (WINAPI *PFNUNLOADUSERPROFILE)(HANDLE, HANDLE); + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Init once structure. */ +static RTONCE g_rtProcWinInitOnce = RTONCE_INITIALIZER; +/** Critical section protecting the process array. */ +static RTCRITSECT g_CritSect; +/** The number of processes in the array. */ +static uint32_t g_cProcesses; +/** The current allocation size. */ +static uint32_t g_cProcessesAlloc; +/** Array containing the live or non-reaped child processes. */ +static struct RTPROCWINENTRY +{ + /** The process ID. */ + ULONG_PTR pid; + /** The process handle. */ + HANDLE hProcess; +} *g_paProcesses; + +/** Structure for storing a user's account info. + * Must be free'd with rtProcWinFreeAccountInfo(). */ +typedef struct RTPROCWINACCOUNTINFO +{ + /** User name. */ + PRTUTF16 pwszUserName; + /** Domain this account is tied to. Can be NULL if no domain is being used. */ + PRTUTF16 pwszDomain; +} RTPROCWINACCOUNTINFO, *PRTPROCWINACCOUNTINFO; + +/** @name userenv.dll imports (we don't unload it). + * They're all optional. So in addition to using g_rtProcWinResolveOnce, the + * caller must also check if any of the necessary APIs are NULL pointers. + * @{ */ +/** Init once structure for run-as-user functions we need. */ +static RTONCE g_rtProcWinResolveOnce = RTONCE_INITIALIZER; +/* kernel32.dll: */ +static PFNCREATETOOLHELP32SNAPSHOT g_pfnCreateToolhelp32Snapshot = NULL; +static PFNPROCESS32FIRST g_pfnProcess32First = NULL; +static PFNPROCESS32NEXT g_pfnProcess32Next = NULL; +static PFNPROCESS32FIRSTW g_pfnProcess32FirstW = NULL; +static PFNPROCESS32NEXTW g_pfnProcess32NextW = NULL; +/* psapi.dll: */ +static PFNGETMODULEBASENAME g_pfnGetModuleBaseName = NULL; +static PFNENUMPROCESSES g_pfnEnumProcesses = NULL; +/* advapi32.dll: */ +static PFNCREATEPROCESSWITHLOGON g_pfnCreateProcessWithLogonW = NULL; +static PFNLSALOOKUPNAMES2 g_pfnLsaLookupNames2 = NULL; +static decltype(LogonUserW) *g_pfnLogonUserW = NULL; +static decltype(CreateProcessAsUserW) *g_pfnCreateProcessAsUserW = NULL; +static decltype(LsaNtStatusToWinError) *g_pfnLsaNtStatusToWinError = NULL; +/* user32.dll: */ +static decltype(OpenWindowStationW) *g_pfnOpenWindowStationW = NULL; +static decltype(CloseWindowStation) *g_pfnCloseWindowStation = NULL; +/* userenv.dll: */ +static PFNCREATEENVIRONMENTBLOCK g_pfnCreateEnvironmentBlock = NULL; +static PFNPFNDESTROYENVIRONMENTBLOCK g_pfnDestroyEnvironmentBlock = NULL; +static PFNLOADUSERPROFILEW g_pfnLoadUserProfileW = NULL; +static PFNUNLOADUSERPROFILE g_pfnUnloadUserProfile = NULL; +/** @} */ + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int rtProcWinFindExe(uint32_t fFlags, RTENV hEnv, const char *pszExec, PRTUTF16 *ppwszExec); +static int rtProcWinCreateEnvBlockAndFindExe(uint32_t fFlags, RTENV hEnv, const char *pszExec, + PRTUTF16 *ppwszzBlock, PRTUTF16 *ppwszExec); + + +/** + * Clean up the globals. + * + * @param enmReason Ignored. + * @param iStatus Ignored. + * @param pvUser Ignored. + */ +static DECLCALLBACK(void) rtProcWinTerm(RTTERMREASON enmReason, int32_t iStatus, void *pvUser) +{ + NOREF(pvUser); NOREF(iStatus); NOREF(enmReason); + + RTCritSectDelete(&g_CritSect); + + size_t i = g_cProcesses; + while (i-- > 0) + { + CloseHandle(g_paProcesses[i].hProcess); + g_paProcesses[i].hProcess = NULL; + } + RTMemFree(g_paProcesses); + + g_paProcesses = NULL; + g_cProcesses = 0; + g_cProcessesAlloc = 0; +} + + +/** + * Initialize the globals. + * + * @returns IPRT status code. + * @param pvUser Ignored. + */ +static DECLCALLBACK(int32_t) rtProcWinInitOnce(void *pvUser) +{ + NOREF(pvUser); + + g_cProcesses = 0; + g_cProcessesAlloc = 0; + g_paProcesses = NULL; + int rc = RTCritSectInit(&g_CritSect); + if (RT_SUCCESS(rc)) + { + /** @todo init once, terminate once - this is a generic thing which should + * have some kind of static and simpler setup! */ + rc = RTTermRegisterCallback(rtProcWinTerm, NULL); + if (RT_SUCCESS(rc)) + return rc; + RTCritSectDelete(&g_CritSect); + } + return rc; +} + + +/** + * Gets the process handle for a process from g_paProcesses. + * + * @returns Process handle if found, NULL if not. + * @param pid The process to remove (pid). + */ +static HANDLE rtProcWinFindPid(RTPROCESS pid) +{ + HANDLE hProcess = NULL; + + RTCritSectEnter(&g_CritSect); + uint32_t i = g_cProcesses; + while (i-- > 0) + if (g_paProcesses[i].pid == pid) + { + hProcess = g_paProcesses[i].hProcess; + break; + } + RTCritSectLeave(&g_CritSect); + + return hProcess; +} + + +/** + * Removes a process from g_paProcesses and closes the process handle. + * + * @param pid The process to remove (pid). + */ +static void rtProcWinRemovePid(RTPROCESS pid) +{ + RTCritSectEnter(&g_CritSect); + uint32_t i = g_cProcesses; + while (i-- > 0) + if (g_paProcesses[i].pid == pid) + { + HANDLE hProcess = g_paProcesses[i].hProcess; + + g_cProcesses--; + uint32_t cToMove = g_cProcesses - i; + if (cToMove) + memmove(&g_paProcesses[i], &g_paProcesses[i + 1], cToMove * sizeof(g_paProcesses[0])); + + RTCritSectLeave(&g_CritSect); + CloseHandle(hProcess); + return; + } + RTCritSectLeave(&g_CritSect); +} + + +/** + * Adds a process to g_paProcesses. + * + * @returns IPRT status code. + * @param pid The process id. + * @param hProcess The process handle. + */ +static int rtProcWinAddPid(RTPROCESS pid, HANDLE hProcess) +{ + RTCritSectEnter(&g_CritSect); + + uint32_t i = g_cProcesses; + if (i >= g_cProcessesAlloc) + { + void *pvNew = RTMemRealloc(g_paProcesses, (i + 16) * sizeof(g_paProcesses[0])); + if (RT_UNLIKELY(!pvNew)) + { + RTCritSectLeave(&g_CritSect); + return VERR_NO_MEMORY; + } + g_paProcesses = (struct RTPROCWINENTRY *)pvNew; + g_cProcessesAlloc = i + 16; + } + + g_paProcesses[i].pid = pid; + g_paProcesses[i].hProcess = hProcess; + g_cProcesses = i + 1; + + RTCritSectLeave(&g_CritSect); + return VINF_SUCCESS; +} + + +/** + * Initialize the import APIs for run-as-user and special environment support. + * + * @returns IPRT status code. + * @param pvUser Ignored. + */ +static DECLCALLBACK(int) rtProcWinResolveOnce(void *pvUser) +{ + int rc; + RTLDRMOD hMod; + RT_NOREF_PV(pvUser); + + /* + * kernel32.dll APIs introduced after NT4. + */ + g_pfnCreateToolhelp32Snapshot = (PFNCREATETOOLHELP32SNAPSHOT)GetProcAddress(g_hModKernel32, "CreateToolhelp32Snapshot"); + g_pfnProcess32First = (PFNPROCESS32FIRST )GetProcAddress(g_hModKernel32, "Process32First"); + g_pfnProcess32FirstW = (PFNPROCESS32FIRSTW )GetProcAddress(g_hModKernel32, "Process32FirstW"); + g_pfnProcess32Next = (PFNPROCESS32NEXT )GetProcAddress(g_hModKernel32, "Process32Next"); + g_pfnProcess32NextW = (PFNPROCESS32NEXTW )GetProcAddress(g_hModKernel32, "Process32NextW"); + + /* + * psapi.dll APIs, if none of the above are available. + */ + if ( !g_pfnCreateToolhelp32Snapshot + || !g_pfnProcess32First + || !g_pfnProcess32Next) + { + Assert(!g_pfnCreateToolhelp32Snapshot && !g_pfnProcess32First && !g_pfnProcess32Next); + + rc = RTLdrLoadSystem("psapi.dll", true /*fNoUnload*/, &hMod); + if (RT_SUCCESS(rc)) + { + rc = RTLdrGetSymbol(hMod, "GetModuleBaseName", (void **)&g_pfnGetModuleBaseName); + AssertStmt(RT_SUCCESS(rc), g_pfnGetModuleBaseName = NULL); + + rc = RTLdrGetSymbol(hMod, "EnumProcesses", (void **)&g_pfnEnumProcesses); + AssertStmt(RT_SUCCESS(rc), g_pfnEnumProcesses = NULL); + + RTLdrClose(hMod); + } + } + + /* + * advapi32.dll APIs. + */ + rc = RTLdrLoadSystem("advapi32.dll", true /*fNoUnload*/, &hMod); + if (RT_SUCCESS(rc)) + { + rc = RTLdrGetSymbol(hMod, "CreateProcessWithLogonW", (void **)&g_pfnCreateProcessWithLogonW); + if (RT_FAILURE(rc)) { g_pfnCreateProcessWithLogonW = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT4); } + + rc = RTLdrGetSymbol(hMod, "LsaLookupNames2", (void **)&g_pfnLsaLookupNames2); + if (RT_FAILURE(rc)) { g_pfnLsaLookupNames2 = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT4); } + + rc = RTLdrGetSymbol(hMod, "LogonUserW", (void **)&g_pfnLogonUserW); + if (RT_FAILURE(rc)) { g_pfnLogonUserW = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT350); } + + rc = RTLdrGetSymbol(hMod, "CreateProcessAsUserW", (void **)&g_pfnCreateProcessAsUserW); + if (RT_FAILURE(rc)) { g_pfnCreateProcessAsUserW = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT350); } + + rc = RTLdrGetSymbol(hMod, "LsaNtStatusToWinError", (void **)&g_pfnLsaNtStatusToWinError); + if (RT_FAILURE(rc)) { g_pfnLsaNtStatusToWinError = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT350); } + + RTLdrClose(hMod); + } + + /* + * user32.dll APIs. + */ + rc = RTLdrLoadSystem("user32.dll", true /*fNoUnload*/, &hMod); + if (RT_SUCCESS(rc)) + { + rc = RTLdrGetSymbol(hMod, "OpenWindowStationW", (void **)&g_pfnOpenWindowStationW); + if (RT_FAILURE(rc)) { g_pfnOpenWindowStationW = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT310); } + + rc = RTLdrGetSymbol(hMod, "CloseWindowStation", (void **)&g_pfnCloseWindowStation); + if (RT_FAILURE(rc)) { g_pfnCloseWindowStation = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT310); } + + RTLdrClose(hMod); + } + + /* + * userenv.dll APIs. + */ + rc = RTLdrLoadSystem("userenv.dll", true /*fNoUnload*/, &hMod); + if (RT_SUCCESS(rc)) + { + rc = RTLdrGetSymbol(hMod, "LoadUserProfileW", (void **)&g_pfnLoadUserProfileW); + if (RT_FAILURE(rc)) { g_pfnLoadUserProfileW = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT4); } + + rc = RTLdrGetSymbol(hMod, "UnloadUserProfile", (void **)&g_pfnUnloadUserProfile); + if (RT_FAILURE(rc)) { g_pfnUnloadUserProfile = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT4); } + + rc = RTLdrGetSymbol(hMod, "CreateEnvironmentBlock", (void **)&g_pfnCreateEnvironmentBlock); + if (RT_FAILURE(rc)) { g_pfnCreateEnvironmentBlock = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT4); } + + rc = RTLdrGetSymbol(hMod, "DestroyEnvironmentBlock", (void **)&g_pfnDestroyEnvironmentBlock); + if (RT_FAILURE(rc)) { g_pfnDestroyEnvironmentBlock = NULL; Assert(g_enmWinVer <= kRTWinOSType_NT4); } + + RTLdrClose(hMod); + } + + return VINF_SUCCESS; +} + + +RTR3DECL(int) RTProcCreate(const char *pszExec, const char * const *papszArgs, RTENV Env, unsigned fFlags, PRTPROCESS pProcess) +{ + return RTProcCreateEx(pszExec, papszArgs, Env, fFlags, + NULL, NULL, NULL, /* standard handles */ + NULL /*pszAsUser*/, NULL /* pszPassword*/, + pProcess); +} + + +/** + * Get the process token of the process indicated by @a dwPID if the @a pSid + * matches. + * + * @returns IPRT status code. + * @param dwPid The process identifier. + * @param pSid The secure identifier of the user. + * @param phToken Where to return the a duplicate of the process token + * handle on success. (The caller closes it.) + */ +static int rtProcWinGetProcessTokenHandle(DWORD dwPid, PSID pSid, PHANDLE phToken) +{ + AssertPtr(pSid); + AssertPtr(phToken); + + int rc; + HANDLE hProc = OpenProcess(MAXIMUM_ALLOWED, TRUE, dwPid); + if (hProc != NULL) + { + HANDLE hTokenProc; + if (OpenProcessToken(hProc, + TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY | TOKEN_DUPLICATE + | TOKEN_ASSIGN_PRIMARY | TOKEN_ADJUST_SESSIONID | TOKEN_READ | TOKEN_WRITE, + &hTokenProc)) + { + SetLastError(NO_ERROR); + DWORD dwSize = 0; + BOOL fRc = GetTokenInformation(hTokenProc, TokenUser, NULL, 0, &dwSize); + DWORD dwErr = GetLastError(); + if ( !fRc + && dwErr == ERROR_INSUFFICIENT_BUFFER + && dwSize > 0) + { + PTOKEN_USER pTokenUser = (PTOKEN_USER)RTMemTmpAllocZ(dwSize); + if (pTokenUser) + { + if (GetTokenInformation(hTokenProc, TokenUser, pTokenUser, dwSize, &dwSize)) + { + if ( IsValidSid(pTokenUser->User.Sid) + && EqualSid(pTokenUser->User.Sid, pSid)) + { + /* + * The following NT call is for v3.51 and does the equivalent of: + * DuplicateTokenEx(hTokenProc, MAXIMUM_ALLOWED, NULL, + * SecurityIdentification, TokenPrimary, phToken); + */ + if (g_pfnNtDuplicateToken) + { + SECURITY_QUALITY_OF_SERVICE SecQoS; + SecQoS.Length = sizeof(SecQoS); + SecQoS.ImpersonationLevel = SecurityIdentification; + SecQoS.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING; + SecQoS.EffectiveOnly = FALSE; + + OBJECT_ATTRIBUTES ObjAttr; + InitializeObjectAttributes(&ObjAttr, NULL /*Name*/, 0 /*OBJ_XXX*/, NULL /*Root*/, NULL /*SecDesc*/); + ObjAttr.SecurityQualityOfService = &SecQoS; + + NTSTATUS rcNt = g_pfnNtDuplicateToken(hTokenProc, MAXIMUM_ALLOWED, &ObjAttr, FALSE, + TokenPrimary, phToken); + if (NT_SUCCESS(rcNt)) + { + /* + * So we found the process instance which belongs to the user we want to + * to run our new process under. This duplicated token will be used for + * the actual CreateProcessAsUserW() call then. + */ + rc = VINF_SUCCESS; + } + else + rc = RTErrConvertFromNtStatus(rcNt); + + } + else + rc = VERR_SYMBOL_NOT_FOUND; /** @todo do we really need to duplicate the token? */ + } + else + rc = VERR_NOT_FOUND; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + RTMemTmpFree(pTokenUser); + } + else + rc = VERR_NO_MEMORY; + } + else if (fRc || dwErr == NO_ERROR) + rc = VERR_IPE_UNEXPECTED_STATUS; + else + rc = RTErrConvertFromWin32(dwErr); + CloseHandle(hTokenProc); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + CloseHandle(hProc); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + return rc; +} + + +/** + * Fallback method for rtProcWinFindTokenByProcess that uses the older NT4 + * PSAPI.DLL API. + * + * @returns Success indicator. + * @param papszNames The process candidates, in prioritized order. + * @param pSid The secure identifier of the user. + * @param phToken Where to return the token handle - duplicate, + * caller closes it on success. + * + * @remarks NT4 needs a copy of "PSAPI.dll" (redistributed by Microsoft and not + * part of the OS) in order to get a lookup. If we don't have this DLL + * we are not able to get a token and therefore no UI will be visible. + */ +static bool rtProcWinFindTokenByProcessAndPsApi(const char * const *papszNames, PSID pSid, PHANDLE phToken) +{ + /* + * Load PSAPI.DLL and resolve the two symbols we need. + */ + if ( !g_pfnGetModuleBaseName + || !g_pfnEnumProcesses) + return false; + + /* + * Get a list of PID. We retry if it looks like there are more PIDs + * to be returned than what we supplied buffer space for. + */ + bool fFound = false; + int rc = VINF_SUCCESS; + DWORD cbPidsAllocated = 4096; + DWORD cbPidsReturned = 0; /* (MSC maybe used uninitialized) */ + DWORD *paPids; + for (;;) + { + paPids = (DWORD *)RTMemTmpAlloc(cbPidsAllocated); + AssertBreakStmt(paPids, rc = VERR_NO_TMP_MEMORY); + cbPidsReturned = 0; + if (!g_pfnEnumProcesses(paPids, cbPidsAllocated, &cbPidsReturned)) + { + rc = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailedBreak(("%Rrc\n", rc)); + } + if ( cbPidsReturned < cbPidsAllocated + || cbPidsAllocated >= _512K) + break; + RTMemTmpFree(paPids); + cbPidsAllocated *= 2; + } + if (RT_SUCCESS(rc)) + { + /* + * Search for the process. + * + * We ASSUME that the caller won't be specifying any names longer + * than RTPATH_MAX. + */ + DWORD cbProcName = RTPATH_MAX; + char *pszProcName = (char *)RTMemTmpAlloc(RTPATH_MAX); + if (pszProcName) + { + for (size_t i = 0; papszNames[i] && !fFound; i++) + { + const DWORD cPids = cbPidsReturned / sizeof(DWORD); + for (DWORD iPid = 0; iPid < cPids && !fFound; iPid++) + { + HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, paPids[iPid]); + if (hProc) + { + *pszProcName = '\0'; + DWORD cbRet = g_pfnGetModuleBaseName(hProc, 0 /*hModule = exe */, pszProcName, cbProcName); + if ( cbRet > 0 + && _stricmp(pszProcName, papszNames[i]) == 0 + && RT_SUCCESS(rtProcWinGetProcessTokenHandle(paPids[iPid], pSid, phToken))) + fFound = true; + CloseHandle(hProc); + } + } + } + RTMemTmpFree(pszProcName); + } + else + rc = VERR_NO_TMP_MEMORY; + } + RTMemTmpFree(paPids); + + return fFound; +} + + +/** + * Finds a one of the processes in @a papszNames running with user @a pSid and + * returns a duplicate handle to its token. + * + * @returns Success indicator. + * @param papszNames The process candidates, in prioritized order. + * @param pSid The secure identifier of the user. + * @param phToken Where to return the token handle - duplicate, + * caller closes it on success. + */ +static bool rtProcWinFindTokenByProcess(const char * const *papszNames, PSID pSid, PHANDLE phToken) +{ + AssertPtr(papszNames); + AssertPtr(pSid); + AssertPtr(phToken); + + bool fFound = false; + + /* + * On modern systems (W2K+) try the Toolhelp32 API first; this is more stable + * and reliable. Fallback to EnumProcess on NT4. + */ + bool fFallback = true; + if (g_pfnProcess32Next && g_pfnProcess32First && g_pfnCreateToolhelp32Snapshot) + { + HANDLE hSnap = g_pfnCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); + Assert(hSnap != INVALID_HANDLE_VALUE); + if (hSnap != INVALID_HANDLE_VALUE) + { + fFallback = false; + for (size_t i = 0; papszNames[i] && !fFound; i++) + { + PROCESSENTRY32 ProcEntry; + ProcEntry.dwSize = sizeof(PROCESSENTRY32); +/** @todo use W APIs here. */ + if (g_pfnProcess32First(hSnap, &ProcEntry)) + { + do + { + if (_stricmp(ProcEntry.szExeFile, papszNames[i]) == 0) + { + int rc = rtProcWinGetProcessTokenHandle(ProcEntry.th32ProcessID, pSid, phToken); + if (RT_SUCCESS(rc)) + { + fFound = true; + break; + } + } + } while (g_pfnProcess32Next(hSnap, &ProcEntry)); + } +#ifdef RT_STRICT + else + { + DWORD dwErr = GetLastError(); + AssertMsgFailed(("dwErr=%u (%x)\n", dwErr, dwErr)); + } +#endif + } + CloseHandle(hSnap); + } + } + + /* If we couldn't take a process snapshot for some reason or another, fall + back on the NT4 compatible API. */ + if (fFallback) + fFound = rtProcWinFindTokenByProcessAndPsApi(papszNames, pSid, phToken); + return fFound; +} + + +/** + * Logs on a specified user and returns its primary token. + * + * @returns IPRT status code. + * @param pwszUser User name. A domain name can be specified (as part of a UPN, User Principal Name), + * e.g. "joedoe@example.com". + * @param pwszPassword Password. + * @param phToken Pointer to store the logon token. + */ +static int rtProcWinUserLogon(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, HANDLE *phToken) +{ + AssertPtrReturn(pwszUser, VERR_INVALID_POINTER); + AssertPtrReturn(pwszPassword, VERR_INVALID_POINTER); + AssertPtrReturn(phToken, VERR_INVALID_POINTER); + if (!g_pfnLogonUserW) + return VERR_NOT_SUPPORTED; + + /* + * Because we have to deal with http://support.microsoft.com/kb/245683 + * for NULL domain names when running on NT4 here, pass an empty string if so. + * However, passing FQDNs should work! + * + * The SE_TCB_NAME (Policy: Act as part of the operating system) right + * is required on older windows versions (NT4, W2K, possibly XP). + */ + PCRTUTF16 pwszDomainNone = g_enmWinVer < kRTWinOSType_2K ? L"" /* NT4 and older */ : NULL /* Windows 2000 and up */; + BOOL fRc = g_pfnLogonUserW(pwszUser, + /* The domain always is passed as part of the UPN (user name). */ + pwszDomainNone, + pwszPassword, + LOGON32_LOGON_INTERACTIVE, + LOGON32_PROVIDER_DEFAULT, + phToken); + if (fRc) + return VINF_SUCCESS; + + DWORD dwErr = GetLastError(); + int rc = dwErr == ERROR_PRIVILEGE_NOT_HELD ? VERR_PROC_TCB_PRIV_NOT_HELD : RTErrConvertFromWin32(dwErr); + if (rc == VERR_UNRESOLVED_ERROR) + LogRelFunc(("dwErr=%u (%#x), rc=%Rrc\n", dwErr, dwErr, rc)); + return rc; +} + + +/** + * Returns the environment to use for the child process. + * + * This implements the RTPROC_FLAGS_ENV_CHANGE_RECORD and environment related + * parts of RTPROC_FLAGS_PROFILE. + * + * @returns IPRT status code. + * @param hToken The user token to use if RTPROC_FLAGS_PROFILE is given. + * The caller must have loaded profile for this. + * @param hEnv The environment passed in by the RTProcCreateEx caller. + * @param fFlags The process creation flags passed in by the + * RTProcCreateEx caller (RTPROC_FLAGS_XXX). + * @param phEnv Where to return the environment to use. This can either + * be a newly created environment block or @a hEnv. In the + * former case, the caller must destroy it. + */ +static int rtProcWinCreateEnvFromToken(HANDLE hToken, RTENV hEnv, uint32_t fFlags, PRTENV phEnv) +{ + int rc; + + /* + * Query the environment from the user profile associated with the token if + * the caller has specified it directly or indirectly. + */ + if ( (fFlags & RTPROC_FLAGS_PROFILE) + && ( hEnv == RTENV_DEFAULT + || (fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD)) ) + { + if (g_pfnCreateEnvironmentBlock && g_pfnDestroyEnvironmentBlock) + { + LPVOID pvEnvBlockProfile = NULL; + if (g_pfnCreateEnvironmentBlock(&pvEnvBlockProfile, hToken, FALSE /* Don't inherit from parent. */)) + { + rc = RTEnvCloneUtf16Block(phEnv, (PCRTUTF16)pvEnvBlockProfile, 0 /*fFlags*/); + if ( (fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD) + && RT_SUCCESS(rc) + && hEnv != RTENV_DEFAULT) + { + rc = RTEnvApplyChanges(*phEnv, hEnv); + if (RT_FAILURE(rc)) + RTEnvDestroy(*phEnv); + } + g_pfnDestroyEnvironmentBlock(pvEnvBlockProfile); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + rc = VERR_SYMBOL_NOT_FOUND; + } + /* + * We we've got an incoming change record, combine it with the default environment. + */ + else if (hEnv != RTENV_DEFAULT && (fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD)) + { + rc = RTEnvClone(phEnv, RTENV_DEFAULT); + if (RT_SUCCESS(rc)) + { + rc = RTEnvApplyChanges(*phEnv, hEnv); + if (RT_FAILURE(rc)) + RTEnvDestroy(*phEnv); + } + } + /* + * Otherwise we can return the incoming environment directly. + */ + else + { + *phEnv = hEnv; + rc = VINF_SUCCESS; + } + + return rc; +} + + +/** + * Figures which privilege we're missing for success application of + * CreateProcessAsUserW. + * + * @returns IPRT error status. + */ +static int rtProcWinFigureWhichPrivilegeNotHeld2(void) +{ + HANDLE hToken; + if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, &hToken)) + { + static struct + { + const char *pszName; + int rc; + } const s_aPrivileges[] = + { + { SE_TCB_NAME, VERR_PROC_TCB_PRIV_NOT_HELD }, + { SE_ASSIGNPRIMARYTOKEN_NAME, VERR_PROC_APT_PRIV_NOT_HELD }, + { SE_INCREASE_QUOTA_NAME, VERR_PROC_IQ_PRIV_NOT_HELD }, + }; + for (uint32_t i = 0; i < RT_ELEMENTS(s_aPrivileges); i++) + { + union + { + TOKEN_PRIVILEGES TokPriv; + char abAlloced[sizeof(TOKEN_PRIVILEGES) + sizeof(LUID_AND_ATTRIBUTES)]; + } uNew, uOld; + uNew.TokPriv.PrivilegeCount = 1; + uNew.TokPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; + AssertContinue(LookupPrivilegeValue(NULL, s_aPrivileges[i].pszName, &uNew.TokPriv.Privileges[0].Luid)); + uOld = uNew; + SetLastError(NO_ERROR); + DWORD cbActual = RT_UOFFSETOF(TOKEN_PRIVILEGES, Privileges[1]); + AdjustTokenPrivileges(hToken, FALSE /*fDisableAllPrivileges*/, &uNew.TokPriv, cbActual, &uOld.TokPriv, &cbActual); + if (GetLastError() != NO_ERROR) + { + CloseHandle(hToken); + return s_aPrivileges[i].rc; + } + if (uOld.TokPriv.Privileges[0].Attributes == 0) + AdjustTokenPrivileges(hToken, FALSE /*fDisableAllPrivileges*/, &uOld.TokPriv, 0, NULL, NULL); + } + AssertFailed(); + CloseHandle(hToken); + } + else + AssertFailed(); + return VERR_PRIVILEGE_NOT_HELD; +} + +#if 0 /* debug code */ + +static char *rtProcWinSidToString(char *psz, PSID pSid) +{ + char *pszRet = psz; + + *psz++ = 'S'; + *psz++ = '-'; + *psz++ = '1'; + *psz++ = '-'; + + PISID pISid = (PISID)pSid; + + psz += RTStrFormatU32(psz, 32, RT_MAKE_U32_FROM_U8(pISid->IdentifierAuthority.Value[5], + pISid->IdentifierAuthority.Value[4], + pISid->IdentifierAuthority.Value[3], + pISid->IdentifierAuthority.Value[2]), + 10, 0, 0, 0); + for (unsigned i = 0; i < pISid->SubAuthorityCount; i++) + { + *psz++ = '-'; + psz += RTStrFormatU32(psz, 32, pISid->SubAuthority[i], 10, 0, 0, 0); + } + *psz++ = '\0'; + return pszRet; +} + +static void rtProcWinLogAcl(PACL pAcl) +{ + if (!pAcl) + RTAssertMsg2("ACL is NULL\n"); + else + { + RTAssertMsg2("AceCount=%d AclSize=%#x AclRevision=%d\n", pAcl->AceCount, pAcl->AclSize, pAcl->AclRevision); + for (uint32_t i = 0; i < pAcl->AceCount; i++) + { + PACE_HEADER pAceHdr = NULL; + if (GetAce(pAcl, i, (PVOID *)&pAceHdr)) + { + RTAssertMsg2(" ACE[%u]: Flags=%#x Type=%#x Size=%#x", i, pAceHdr->AceFlags, pAceHdr->AceType, pAceHdr->AceSize); + char szTmp[256]; + if (pAceHdr->AceType == ACCESS_ALLOWED_ACE_TYPE) + RTAssertMsg2(" Mask=%#x %s\n", ((ACCESS_ALLOWED_ACE *)pAceHdr)->Mask, + rtProcWinSidToString(szTmp, &((ACCESS_ALLOWED_ACE *)pAceHdr)->SidStart)); + else + RTAssertMsg2(" ACE[%u]: Flags=%#x Type=%#x Size=%#x\n", i, pAceHdr->AceFlags, pAceHdr->AceType, pAceHdr->AceSize); + } + } + } +} + +static bool rtProcWinLogSecAttr(HANDLE hUserObj) +{ + /* + * Get the security descriptor for the user interface object. + */ + uint32_t cbSecDesc = _64K; + PSECURITY_DESCRIPTOR pSecDesc = (PSECURITY_DESCRIPTOR)RTMemTmpAlloc(cbSecDesc); + SECURITY_INFORMATION SecInfo = DACL_SECURITY_INFORMATION; + DWORD cbNeeded; + AssertReturn(pSecDesc, false); + if (!GetUserObjectSecurity(hUserObj, &SecInfo, pSecDesc, cbSecDesc, &cbNeeded)) + { + RTMemTmpFree(pSecDesc); + AssertReturn(GetLastError() == ERROR_INSUFFICIENT_BUFFER, false); + cbSecDesc = cbNeeded + 128; + pSecDesc = (PSECURITY_DESCRIPTOR)RTMemTmpAlloc(cbSecDesc); + AssertReturn(pSecDesc, false); + if (!GetUserObjectSecurity(hUserObj, &SecInfo, pSecDesc, cbSecDesc, &cbNeeded)) + { + RTMemTmpFree(pSecDesc); + AssertFailedReturn(false); + } + } + + /* + * Get the discretionary access control list (if we have one). + */ + BOOL fDaclDefaulted; + BOOL fDaclPresent; + PACL pDacl; + if (GetSecurityDescriptorDacl(pSecDesc, &fDaclPresent, &pDacl, &fDaclDefaulted)) + rtProcWinLogAcl(pDacl); + else + RTAssertMsg2("GetSecurityDescriptorDacl failed\n"); + + RTMemFree(pSecDesc); + return true; +} + +#endif /* debug */ + +/** + * Get the user SID from a token. + * + * @returns Pointer to the SID on success. Free by calling RTMemFree. + * @param hToken The token.. + */ +static PSID rtProcWinGetTokenUserSid(HANDLE hToken) +{ + /* + * Get the groups associated with the token. We just try a size first then + * reallocates if it's insufficient. + */ + DWORD cbUser = _1K; + PTOKEN_USER pUser = (PTOKEN_USER)RTMemTmpAlloc(cbUser); + AssertReturn(pUser, NULL); + DWORD cbNeeded = 0; + if (!GetTokenInformation(hToken, TokenUser, pUser, cbUser, &cbNeeded)) + { + RTMemTmpFree(pUser); + AssertReturn(GetLastError() == ERROR_INSUFFICIENT_BUFFER, NULL); + cbUser = cbNeeded + 128; + pUser = (PTOKEN_USER)RTMemTmpAlloc(cbUser); + AssertReturn(pUser, NULL); + if (!GetTokenInformation(hToken, TokenUser, pUser, cbUser, &cbNeeded)) + { + RTMemTmpFree(pUser); + AssertFailedReturn(NULL); + } + } + + DWORD cbSid = GetLengthSid(pUser->User.Sid); + PSID pSidRet = RTMemDup(pUser->User.Sid, cbSid); + Assert(pSidRet); + RTMemTmpFree(pUser); + return pSidRet; +} + + +#if 0 /* not used */ +/** + * Get the login SID from a token. + * + * @returns Pointer to the SID on success. Free by calling RTMemFree. + * @param hToken The token.. + */ +static PSID rtProcWinGetTokenLogonSid(HANDLE hToken) +{ + /* + * Get the groups associated with the token. We just try a size first then + * reallocates if it's insufficient. + */ + DWORD cbGroups = _1K; + PTOKEN_GROUPS pGroups = (PTOKEN_GROUPS)RTMemTmpAlloc(cbGroups); + AssertReturn(pGroups, NULL); + DWORD cbNeeded = 0; + if (!GetTokenInformation(hToken, TokenGroups, pGroups, cbGroups, &cbNeeded)) + { + RTMemTmpFree(pGroups); + AssertReturn(GetLastError() == ERROR_INSUFFICIENT_BUFFER, NULL); + cbGroups = cbNeeded + 128; + pGroups = (PTOKEN_GROUPS)RTMemTmpAlloc(cbGroups); + AssertReturn(pGroups, NULL); + if (!GetTokenInformation(hToken, TokenGroups, pGroups, cbGroups, &cbNeeded)) + { + RTMemTmpFree(pGroups); + AssertFailedReturn(NULL); + } + } + + /* + * Locate the logon sid. + */ + PSID pSidRet = NULL; + uint32_t i = pGroups->GroupCount; + while (i-- > 0) + if ((pGroups->Groups[i].Attributes & SE_GROUP_LOGON_ID) == SE_GROUP_LOGON_ID) + { + DWORD cbSid = GetLengthSid(pGroups->Groups[i].Sid); + pSidRet = RTMemDup(pGroups->Groups[i].Sid, cbSid); + break; + } + + RTMemTmpFree(pGroups); + Assert(pSidRet); + return pSidRet; +} +#endif /* unused */ + + +/** + * Retrieves the DACL security descriptor of the give GUI object. + * + * @returns Pointer to the security descriptor. + * @param hUserObj The GUI object handle. + * @param pcbSecDesc Where to return the size of the security descriptor. + * @param ppDacl Where to return the DACL pointer. + * @param pfDaclPresent Where to return the DACL-present indicator. + * @param pDaclSizeInfo Where to return the DACL size information. + */ +static PSECURITY_DESCRIPTOR rtProcWinGetUserObjDacl(HANDLE hUserObj, uint32_t *pcbSecDesc, PACL *ppDacl, + BOOL *pfDaclPresent, ACL_SIZE_INFORMATION *pDaclSizeInfo) +{ + /* + * Get the security descriptor for the user interface object. + */ + uint32_t cbSecDesc = _1K; + PSECURITY_DESCRIPTOR pSecDesc = (PSECURITY_DESCRIPTOR)RTMemTmpAlloc(cbSecDesc); + SECURITY_INFORMATION SecInfo = DACL_SECURITY_INFORMATION; + DWORD cbNeeded; + AssertReturn(pSecDesc, NULL); + if (!GetUserObjectSecurity(hUserObj, &SecInfo, pSecDesc, cbSecDesc, &cbNeeded)) + { + RTMemTmpFree(pSecDesc); + AssertReturn(GetLastError() == ERROR_INSUFFICIENT_BUFFER, NULL); + cbSecDesc = cbNeeded + 128; + pSecDesc = (PSECURITY_DESCRIPTOR)RTMemTmpAlloc(cbSecDesc); + AssertReturn(pSecDesc, NULL); + if (!GetUserObjectSecurity(hUserObj, &SecInfo, pSecDesc, cbSecDesc, &cbNeeded)) + { + RTMemTmpFree(pSecDesc); + AssertFailedReturn(NULL); + } + } + *pcbSecDesc = cbNeeded; + + /* + * Get the discretionary access control list (if we have one). + */ + BOOL fDaclDefaulted; + if (GetSecurityDescriptorDacl(pSecDesc, pfDaclPresent, ppDacl, &fDaclDefaulted)) + { + RT_ZERO(*pDaclSizeInfo); + pDaclSizeInfo->AclBytesInUse = sizeof(ACL); + if ( !*ppDacl + || GetAclInformation(*ppDacl, pDaclSizeInfo, sizeof(*pDaclSizeInfo), AclSizeInformation)) + return pSecDesc; + AssertFailed(); + } + else + AssertFailed(); + RTMemTmpFree(pSecDesc); + return NULL; +} + + +/** + * Copy ACEs from one ACL to another. + * + * @returns true on success, false on failure. + * @param pDst The destination ACL. + * @param pSrc The source ACL. + * @param cAces The number of ACEs to copy. + */ +static bool rtProcWinCopyAces(PACL pDst, PACL pSrc, uint32_t cAces) +{ + for (uint32_t i = 0; i < cAces; i++) + { + PACE_HEADER pAceHdr; + AssertReturn(GetAce(pSrc, i, (PVOID *)&pAceHdr), false); + AssertReturn(AddAce(pDst, ACL_REVISION, MAXDWORD, pAceHdr, pAceHdr->AceSize), false); + } + return true; +} + + +/** + * Adds an access-allowed access control entry to an ACL. + * + * @returns true on success, false on failure. + * @param pDstAcl The ACL. + * @param fAceFlags The ACE flags. + * @param fMask The ACE access mask. + * @param pSid The SID to go with the ACE. + * @param cbSid The size of the SID. + */ +static bool rtProcWinAddAccessAllowedAce(PACL pDstAcl, uint32_t fAceFlags, uint32_t fMask, PSID pSid, uint32_t cbSid) +{ + struct + { + ACCESS_ALLOWED_ACE Core; + DWORD abPadding[128]; /* More than enough, AFAIK. */ + } AceBuf; + RT_ZERO(AceBuf); + uint32_t const cbAllowedAce = RT_UOFFSETOF(ACCESS_ALLOWED_ACE, SidStart) + cbSid; + AssertReturn(cbAllowedAce <= sizeof(AceBuf), false); + + AceBuf.Core.Header.AceSize = cbAllowedAce; + AceBuf.Core.Header.AceType = ACCESS_ALLOWED_ACE_TYPE; + AceBuf.Core.Header.AceFlags = fAceFlags; + AceBuf.Core.Mask = fMask; + AssertReturn(CopySid(cbSid, &AceBuf.Core.SidStart, pSid), false); + + uint32_t i = pDstAcl->AceCount; + while (i-- > 0) + { + PACE_HEADER pAceHdr; + AssertContinue(GetAce(pDstAcl, i, (PVOID *)&pAceHdr)); + if ( pAceHdr->AceSize == cbAllowedAce + && memcmp(pAceHdr, &AceBuf.Core, cbAllowedAce) == 0) + return true; + + } + AssertMsgReturn(AddAce(pDstAcl, ACL_REVISION, MAXDWORD, &AceBuf.Core, cbAllowedAce), ("%u\n", GetLastError()), false); + return true; +} + + +/** All window station rights we know about */ +#define MY_WINSTATION_ALL_RIGHTS ( WINSTA_ACCESSCLIPBOARD | WINSTA_ACCESSGLOBALATOMS | WINSTA_CREATEDESKTOP \ + | WINSTA_ENUMDESKTOPS | WINSTA_ENUMERATE | WINSTA_EXITWINDOWS | WINSTA_READATTRIBUTES \ + | WINSTA_READSCREEN | WINSTA_WRITEATTRIBUTES | DELETE | READ_CONTROL | WRITE_DAC | WRITE_OWNER ) +/** All desktop rights we know about */ +#define MY_DESKTOP_ALL_RIGHTS ( DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW | DESKTOP_ENUMERATE | DESKTOP_HOOKCONTROL \ + | DESKTOP_JOURNALPLAYBACK | DESKTOP_JOURNALRECORD | DESKTOP_READOBJECTS \ + | DESKTOP_SWITCHDESKTOP | DESKTOP_WRITEOBJECTS | DELETE | READ_CONTROL | WRITE_DAC \ + | WRITE_OWNER ) +/** Generic rights. */ +#define MY_GENERIC_ALL_RIGHTS ( GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL ) + + +/** + * Grants the given SID full access to the given window station. + * + * @returns true on success, false on failure. + * @param hWinStation The window station. + * @param pSid The SID. + */ +static bool rtProcWinAddSidToWinStation(HWINSTA hWinStation, PSID pSid) +{ + bool fRet = false; + + /* + * Get the current DACL. + */ + uint32_t cbSecDesc; + PACL pDacl; + ACL_SIZE_INFORMATION DaclSizeInfo; + BOOL fDaclPresent; + PSECURITY_DESCRIPTOR pSecDesc = rtProcWinGetUserObjDacl(hWinStation, &cbSecDesc, &pDacl, &fDaclPresent, &DaclSizeInfo); + if (pSecDesc) + { + /* + * Create a new DACL. This will contain two extra ACEs. + */ + PSECURITY_DESCRIPTOR pNewSecDesc = (PSECURITY_DESCRIPTOR)RTMemTmpAlloc(cbSecDesc); + if ( pNewSecDesc + && InitializeSecurityDescriptor(pNewSecDesc, SECURITY_DESCRIPTOR_REVISION)) + { + uint32_t const cbSid = GetLengthSid(pSid); + uint32_t const cbNewDacl = DaclSizeInfo.AclBytesInUse + (sizeof(ACCESS_ALLOWED_ACE) + cbSid) * 2; + PACL pNewDacl = (PACL)RTMemTmpAlloc(cbNewDacl); + if ( pNewDacl + && InitializeAcl(pNewDacl, cbNewDacl, ACL_REVISION) + && rtProcWinCopyAces(pNewDacl, pDacl, fDaclPresent ? DaclSizeInfo.AceCount : 0)) + { + /* + * Add the two new SID ACEs. + */ + if ( rtProcWinAddAccessAllowedAce(pNewDacl, CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE, + MY_GENERIC_ALL_RIGHTS, pSid, cbSid) + && rtProcWinAddAccessAllowedAce(pNewDacl, NO_PROPAGATE_INHERIT_ACE, MY_WINSTATION_ALL_RIGHTS, pSid, cbSid)) + { + /* + * Now mate the new DECL with the security descriptor and set it. + */ + if (SetSecurityDescriptorDacl(pNewSecDesc, TRUE /*fDaclPresent*/, pNewDacl, FALSE /*fDaclDefaulted*/)) + { + SECURITY_INFORMATION SecInfo = DACL_SECURITY_INFORMATION; + if (SetUserObjectSecurity(hWinStation, &SecInfo, pNewSecDesc)) + fRet = true; + else + AssertFailed(); + } + else + AssertFailed(); + } + else + AssertFailed(); + } + else + AssertFailed(); + RTMemTmpFree(pNewDacl); + } + else + AssertFailed(); + RTMemTmpFree(pNewSecDesc); + RTMemTmpFree(pSecDesc); + } + return fRet; +} + + +/** + * Grants the given SID full access to the given desktop. + * + * @returns true on success, false on failure. + * @param hDesktop The desktop handle. + * @param pSid The SID. + */ +static bool rtProcWinAddSidToDesktop(HDESK hDesktop, PSID pSid) +{ + bool fRet = false; + + /* + * Get the current DACL. + */ + uint32_t cbSecDesc; + PACL pDacl; + ACL_SIZE_INFORMATION DaclSizeInfo; + BOOL fDaclPresent; + PSECURITY_DESCRIPTOR pSecDesc = rtProcWinGetUserObjDacl(hDesktop, &cbSecDesc, &pDacl, &fDaclPresent, &DaclSizeInfo); + if (pSecDesc) + { + /* + * Create a new DACL. This will contain one extra ACE. + */ + PSECURITY_DESCRIPTOR pNewSecDesc = (PSECURITY_DESCRIPTOR)RTMemTmpAlloc(cbSecDesc); + if ( pNewSecDesc + && InitializeSecurityDescriptor(pNewSecDesc, SECURITY_DESCRIPTOR_REVISION)) + { + uint32_t const cbSid = GetLengthSid(pSid); + uint32_t const cbNewDacl = DaclSizeInfo.AclBytesInUse + (sizeof(ACCESS_ALLOWED_ACE) + cbSid) * 1; + PACL pNewDacl = (PACL)RTMemTmpAlloc(cbNewDacl); + if ( pNewDacl + && InitializeAcl(pNewDacl, cbNewDacl, ACL_REVISION) + && rtProcWinCopyAces(pNewDacl, pDacl, fDaclPresent ? DaclSizeInfo.AceCount : 0)) + { + /* + * Add the new SID ACE. + */ + if (rtProcWinAddAccessAllowedAce(pNewDacl, 0 /*fAceFlags*/, MY_DESKTOP_ALL_RIGHTS, pSid, cbSid)) + { + /* + * Now mate the new DECL with the security descriptor and set it. + */ + if (SetSecurityDescriptorDacl(pNewSecDesc, TRUE /*fDaclPresent*/, pNewDacl, FALSE /*fDaclDefaulted*/)) + { + SECURITY_INFORMATION SecInfo = DACL_SECURITY_INFORMATION; + if (SetUserObjectSecurity(hDesktop, &SecInfo, pNewSecDesc)) + fRet = true; + else + AssertFailed(); + } + else + AssertFailed(); + } + else + AssertFailed(); + } + else + AssertFailed(); + RTMemTmpFree(pNewDacl); + } + else + AssertFailed(); + RTMemTmpFree(pNewSecDesc); + RTMemTmpFree(pSecDesc); + } + return fRet; +} + + +/** + * Preps the window station and desktop for the new app. + * + * EXPERIMENTAL. Thus no return code. + * + * @param hTokenToUse The access token of the new process. + * @param pStartupInfo The startup info (we'll change lpDesktop, maybe). + * @param phWinStationOld Where to return an window station handle to restore. + * Pass this to SetProcessWindowStation if not NULL. + */ +static void rtProcWinStationPrep(HANDLE hTokenToUse, STARTUPINFOW *pStartupInfo, HWINSTA *phWinStationOld) +{ + /** @todo Always mess with the interactive one? Maybe it's not there... */ + *phWinStationOld = GetProcessWindowStation(); + HWINSTA hWinStation0; + if (g_pfnOpenWindowStationW) + hWinStation0 = g_pfnOpenWindowStationW(L"winsta0", FALSE /*fInherit*/, READ_CONTROL | WRITE_DAC); + else + hWinStation0 = OpenWindowStationA("winsta0", FALSE /*fInherit*/, READ_CONTROL | WRITE_DAC); /* (for NT3.1) */ + if (hWinStation0) + { + if (SetProcessWindowStation(hWinStation0)) + { + HDESK hDesktop = OpenDesktop("default", 0 /*fFlags*/, FALSE /*fInherit*/, + READ_CONTROL | WRITE_DAC | DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS); + if (hDesktop) + { + /*PSID pSid = rtProcWinGetTokenLogonSid(hTokenToUse); - Better to use the user SID. Avoid overflowing the ACL. */ + PSID pSid = rtProcWinGetTokenUserSid(hTokenToUse); + if (pSid) + { + if ( rtProcWinAddSidToWinStation(hWinStation0, pSid) + && rtProcWinAddSidToDesktop(hDesktop, pSid)) + { + pStartupInfo->lpDesktop = L"winsta0\\default"; + } + RTMemFree(pSid); + } + CloseDesktop(hDesktop); + } + else + AssertFailed(); + } + else + AssertFailed(); + if (g_pfnCloseWindowStation) + g_pfnCloseWindowStation(hWinStation0); + } + else + AssertFailed(); +} + + +/** + * Extracts the user name + domain from a given UPN (User Principal Name, "joedoe@example.com") or + * Down-Level Logon Name format ("example.com\\joedoe") string. + * + * @return IPRT status code. + * @param pwszString Pointer to string to extract the account info from. + * @param pAccountInfo Where to store the parsed account info. + * Must be free'd with rtProcWinFreeAccountInfo(). + */ +static int rtProcWinParseAccountInfo(PRTUTF16 pwszString, PRTPROCWINACCOUNTINFO pAccountInfo) +{ + AssertPtrReturn(pwszString, VERR_INVALID_POINTER); + AssertPtrReturn(pAccountInfo, VERR_INVALID_POINTER); + + /* + * Note: UPN handling is defined in RFC 822. We only implement very rudimentary parsing for the user + * name and domain fields though. + */ + char *pszString; + int rc = RTUtf16ToUtf8(pwszString, &pszString); + if (RT_SUCCESS(rc)) + { + do + { + /* UPN or FQDN handling needed? */ + /** @todo Add more validation here as needed. Regular expressions would be nice. */ + char *pszDelim = strchr(pszString, '@'); + if (pszDelim) /* UPN name? */ + { + rc = RTStrToUtf16Ex(pszString, pszDelim - pszString, &pAccountInfo->pwszUserName, 0, NULL); + if (RT_FAILURE(rc)) + break; + + rc = RTStrToUtf16Ex(pszDelim + 1, RTSTR_MAX, &pAccountInfo->pwszDomain, 0, NULL); + if (RT_FAILURE(rc)) + break; + } + else if (pszDelim = strchr(pszString, '\\')) /* FQDN name? */ + { + rc = RTStrToUtf16Ex(pszString, pszDelim - pszString, &pAccountInfo->pwszDomain, 0, NULL); + if (RT_FAILURE(rc)) + break; + + rc = RTStrToUtf16Ex(pszDelim + 1, RTSTR_MAX, &pAccountInfo->pwszUserName, 0, NULL); + if (RT_FAILURE(rc)) + break; + } + else + rc = VERR_NOT_SUPPORTED; + + } while (0); + + RTStrFree(pszString); + } + +#ifdef DEBUG + LogRelFunc(("Name : %ls\n", pAccountInfo->pwszUserName)); + LogRelFunc(("Domain: %ls\n", pAccountInfo->pwszDomain)); +#endif + + if (RT_FAILURE(rc)) + LogRelFunc(("Parsing \"%ls\" failed with rc=%Rrc\n", pwszString, rc)); + return rc; +} + + +static void rtProcWinFreeAccountInfo(PRTPROCWINACCOUNTINFO pAccountInfo) +{ + if (!pAccountInfo) + return; + + if (pAccountInfo->pwszUserName) + { + RTUtf16Free(pAccountInfo->pwszUserName); + pAccountInfo->pwszUserName = NULL; + } + + if (pAccountInfo->pwszDomain) + { + RTUtf16Free(pAccountInfo->pwszDomain); + pAccountInfo->pwszDomain = NULL; + } +} + + +/** + * Method \#2. + */ +static int rtProcWinCreateAsUser2(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 *ppwszExec, PRTUTF16 pwszCmdLine, + RTENV hEnv, DWORD dwCreationFlags, + STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo, + uint32_t fFlags, const char *pszExec) +{ + /* + * So if we want to start a process from a service (RTPROC_FLAGS_SERVICE), + * we have to do the following: + * - Check the credentials supplied and get the user SID. + * - If valid get the correct Explorer/VBoxTray instance corresponding to that + * user. This of course is only possible if that user is logged in (over + * physical console or terminal services). + * - If we found the user's Explorer/VBoxTray app, use and modify the token to + * use it in order to allow the newly started process to access the user's + * desktop. If there's no Explorer/VBoxTray app we cannot display the started + * process (but run it without UI). + * + * The following restrictions apply: + * - A process only can show its UI when the user the process should run + * under is logged in (has a desktop). + * - We do not want to display a process of user A run on the desktop + * of user B on multi session systems. + * + * The following rights are needed in order to use LogonUserW and + * CreateProcessAsUserW, so the local policy has to be modified to: + * - SE_TCB_NAME = Act as part of the operating system + * - SE_ASSIGNPRIMARYTOKEN_NAME = Create/replace a (process) token object + * - SE_INCREASE_QUOTA_NAME = Increase quotas + * + * We may fail here with ERROR_PRIVILEGE_NOT_HELD. + */ + DWORD dwErr = NO_ERROR; + HANDLE hTokenLogon = INVALID_HANDLE_VALUE; + int rc = rtProcWinUserLogon(pwszUser, pwszPassword, &hTokenLogon); + if (RT_SUCCESS(rc)) + { + DWORD fRc; + bool fFound = false; + HANDLE hTokenUserDesktop = INVALID_HANDLE_VALUE; + + /* + * If the SERVICE flag is specified, we do something rather ugly to + * make things work at all. We search for a known desktop process + * belonging to the user, grab its token and use it for launching + * the new process. That way the process will have desktop access. + */ + if (fFlags & RTPROC_FLAGS_SERVICE) + { + PSID pSid = NULL; + + /* Try query the SID and domain sizes first. */ + DWORD cbSid = 0; /* Must be zero to query size! */ + DWORD cwcDomain = 0; + SID_NAME_USE SidNameUse = SidTypeUser; + fRc = LookupAccountNameW(NULL, pwszUser, NULL, &cbSid, NULL, &cwcDomain, &SidNameUse); + if (!fRc) + { + dwErr = GetLastError(); + + /* + * The errors ERROR_TRUSTED_DOMAIN_FAILURE and ERROR_TRUSTED_RELATIONSHIP_FAILURE + * can happen if an ADC (Active Domain Controller) is offline or not reachable. + * + * Try to handle these errors gracefully by asking the local LSA cache of the + * client OS instead then. For this to work, the desired user must have at + * least logged in once at that client -- otherwise there will be no cached + * authentication available and this fallback will fail. + */ + if ( g_pfnLsaLookupNames2 /* >= Windows XP */ + && ( dwErr == ERROR_TRUSTED_DOMAIN_FAILURE + || dwErr == ERROR_TRUSTED_RELATIONSHIP_FAILURE)) + { + LSA_OBJECT_ATTRIBUTES objAttr; + RT_ZERO(objAttr); + objAttr.Length = sizeof(LSA_OBJECT_ATTRIBUTES); + + LSA_HANDLE lsahPolicy; + NTSTATUS ntSts = LsaOpenPolicy(NULL, &objAttr, POLICY_LOOKUP_NAMES, &lsahPolicy); + if (ntSts == STATUS_SUCCESS) + { + RTPROCWINACCOUNTINFO accountInfo; + RT_ZERO(accountInfo); + rc = rtProcWinParseAccountInfo(pwszUser, &accountInfo); + AssertRC(rc); + AssertPtr(accountInfo.pwszUserName); + + LSA_UNICODE_STRING lsaUser; + lsaUser.Buffer = accountInfo.pwszUserName; + lsaUser.Length = (USHORT)(RTUtf16Len(accountInfo.pwszUserName) * sizeof(WCHAR)); + lsaUser.MaximumLength = lsaUser.Length; + + PLSA_REFERENCED_DOMAIN_LIST pDomainList = NULL; + PLSA_TRANSLATED_SID2 pTranslatedSids = NULL; + ntSts = g_pfnLsaLookupNames2(lsahPolicy, 0 /* Flags */, + 1 /* Number of users to lookup */, + &lsaUser, &pDomainList, &pTranslatedSids); + if (ntSts == STATUS_SUCCESS) + { + AssertPtr(pDomainList); + AssertPtr(pTranslatedSids); +# ifdef DEBUG + LogRelFunc(("LsaLookupNames2: cDomains=%u, DomainIndex=%ld, SidUse=%ld\n", + pDomainList->Entries, pTranslatedSids[0].DomainIndex, pTranslatedSids[0].Use)); +# endif + Assert(pTranslatedSids[0].Use == SidTypeUser); + + if (pDomainList->Entries) + { + AssertPtr(pDomainList->Domains); + LogRelFunc(("LsaLookupNames2: Domain=%ls\n", + pDomainList->Domains[pTranslatedSids[0].DomainIndex].Name.Buffer)); + } + + cbSid = GetLengthSid(pTranslatedSids->Sid) + 16; + Assert(cbSid); + pSid = (PSID)RTMemAllocZ(cbSid); + if (!CopySid(cbSid, pSid, pTranslatedSids->Sid)) + { + dwErr = GetLastError(); + LogRelFunc(("CopySid failed with: %ld\n", dwErr)); + rc = dwErr != NO_ERROR ? RTErrConvertFromWin32(dwErr) : VERR_INTERNAL_ERROR_2; + } + } + else if (g_pfnLsaNtStatusToWinError) + { + dwErr = g_pfnLsaNtStatusToWinError(ntSts); + LogRelFunc(("LsaLookupNames2 failed with: %ld\n", dwErr)); + rc = dwErr != NO_ERROR ? RTErrConvertFromWin32(dwErr) : VERR_INTERNAL_ERROR_2; + } + else + { + LogRelFunc(("LsaLookupNames2 failed with: %#x\n", ntSts)); + rc = RTErrConvertFromNtStatus(ntSts); + } + + if (pDomainList) + { + LsaFreeMemory(pDomainList); + pDomainList = NULL; + } + if (pTranslatedSids) + { + LsaFreeMemory(pTranslatedSids); + pTranslatedSids = NULL; + } + + rtProcWinFreeAccountInfo(&accountInfo); + LsaClose(lsahPolicy); + } + else if (g_pfnLsaNtStatusToWinError) + { + dwErr = g_pfnLsaNtStatusToWinError(ntSts); + LogRelFunc(("LsaOpenPolicy failed with: %ld\n", dwErr)); + rc = dwErr != NO_ERROR ? RTErrConvertFromWin32(dwErr) : VERR_INTERNAL_ERROR_3; + } + else + { + LogRelFunc(("LsaOpenPolicy failed with: %#x\n", ntSts)); + rc = RTErrConvertFromNtStatus(ntSts); + } + + /* Note: pSid will be free'd down below. */ + } + else if (dwErr == ERROR_INSUFFICIENT_BUFFER) + { + /* Allocate memory for the LookupAccountNameW output buffers and do it for real. */ + cbSid = fRc && cbSid != 0 ? cbSid + 16 : _1K; + pSid = (PSID)RTMemAllocZ(cbSid); + if (pSid) + { + cwcDomain = fRc ? cwcDomain + 2 : _4K; + PRTUTF16 pwszDomain = (PRTUTF16)RTMemAllocZ(cwcDomain * sizeof(RTUTF16)); + if (pwszDomain) + { + /* Note: Just pass in the UPN (User Principal Name), e.g. someone@example.com */ + if (!LookupAccountNameW(NULL /*lpSystemName*/, pwszUser, pSid, &cbSid, pwszDomain, &cwcDomain, + &SidNameUse)) + { + dwErr = GetLastError(); + LogRelFunc(("LookupAccountNameW(2) failed with: %ld\n", dwErr)); + rc = dwErr != NO_ERROR ? RTErrConvertFromWin32(dwErr) : VERR_INTERNAL_ERROR_4; + } + + RTMemFree(pwszDomain); + } + else + rc = VERR_NO_MEMORY; + + /* Note: pSid will be free'd down below. */ + } + else + rc = VERR_NO_MEMORY; + } + else + { + LogRelFunc(("LookupAccountNameW(1) failed with: %ld\n", dwErr)); + rc = dwErr != NO_ERROR ? RTErrConvertFromWin32(dwErr) : VERR_INTERNAL_ERROR_2; + } + } + + if (pSid) + { + if (IsValidSid(pSid)) + { + /* Array of process names we want to look for. */ + static const char * const s_papszProcNames[] = + { +#ifdef VBOX /* The explorer entry is a fallback in case GA aren't installed. */ + { "VBoxTray.exe" }, +#endif + { "explorer.exe" }, + NULL + }; + fFound = rtProcWinFindTokenByProcess(s_papszProcNames, pSid, &hTokenUserDesktop); + dwErr = 0; + } + else + { + dwErr = GetLastError(); + LogRelFunc(("SID is invalid: %ld\n", dwErr)); + rc = dwErr != NO_ERROR ? RTErrConvertFromWin32(dwErr) : VERR_INTERNAL_ERROR_3; + } + + RTMemFree(pSid); + } + } + /* else: !RTPROC_FLAGS_SERVICE: Nothing to do here right now. */ + +#if 0 + /* + * If we make LogonUserW to return an impersonation token, enable this + * to convert it into a primary token. + */ + if (!fFound && detect-impersonation-token) + { + HANDLE hNewToken; + if (DuplicateTokenEx(hTokenLogon, MAXIMUM_ALLOWED, NULL /*SecurityAttribs*/, + SecurityIdentification, TokenPrimary, &hNewToken)) + { + CloseHandle(hTokenLogon); + hTokenLogon = hNewToken; + } + else + AssertMsgFailed(("%d\n", GetLastError())); + } +#endif + + if (RT_SUCCESS(rc)) + { + /* + * If we didn't find a matching VBoxTray, just use the token we got + * above from LogonUserW(). This enables us to at least run processes + * with desktop interaction without UI. + */ + HANDLE hTokenToUse = fFound ? hTokenUserDesktop : hTokenLogon; + if ( !(fFlags & RTPROC_FLAGS_PROFILE) + || (g_pfnUnloadUserProfile && g_pfnLoadUserProfileW) ) + { + /* + * Load the profile, if requested. (Must be done prior to + * creating the enviornment.) + */ + PROFILEINFOW ProfileInfo; + RT_ZERO(ProfileInfo); + if (fFlags & RTPROC_FLAGS_PROFILE) + { + ProfileInfo.dwSize = sizeof(ProfileInfo); + ProfileInfo.lpUserName = pwszUser; + ProfileInfo.dwFlags = PI_NOUI; /* Prevents the display of profile error messages. */ + + if (!g_pfnLoadUserProfileW(hTokenToUse, &ProfileInfo)) + rc = RTErrConvertFromWin32(GetLastError()); + } + if (RT_SUCCESS(rc)) + { + /* + * Create the environment. + */ + RTENV hEnvFinal; + rc = rtProcWinCreateEnvFromToken(hTokenToUse, hEnv, fFlags, &hEnvFinal); + if (RT_SUCCESS(rc)) + { + PRTUTF16 pwszzBlock; + rc = RTEnvQueryUtf16Block(hEnvFinal, &pwszzBlock); + if (RT_SUCCESS(rc)) + { + rc = rtProcWinFindExe(fFlags, hEnv, pszExec, ppwszExec); + if (RT_SUCCESS(rc)) + { + HWINSTA hOldWinStation = NULL; + if ( !fFound + && g_enmWinVer <= kRTWinOSType_NT4) /** @todo test newer versions... */ + rtProcWinStationPrep(hTokenToUse, pStartupInfo, &hOldWinStation); + + /* + * Useful KB articles: + * http://support.microsoft.com/kb/165194/ + * http://support.microsoft.com/kb/184802/ + * http://support.microsoft.com/kb/327618/ + */ + if (g_pfnCreateProcessAsUserW) + { + fRc = g_pfnCreateProcessAsUserW(hTokenToUse, + *ppwszExec, + pwszCmdLine, + NULL, /* pProcessAttributes */ + NULL, /* pThreadAttributes */ + TRUE, /* fInheritHandles */ + dwCreationFlags, + /** @todo Warn about exceeding 8192 bytes + * on XP and up. */ + pwszzBlock, /* lpEnvironment */ + NULL, /* pCurrentDirectory */ + pStartupInfo, + pProcInfo); + if (fRc) + rc = VINF_SUCCESS; + else + { + dwErr = GetLastError(); + if (dwErr == ERROR_PRIVILEGE_NOT_HELD) + rc = rtProcWinFigureWhichPrivilegeNotHeld2(); + else + rc = RTErrConvertFromWin32(dwErr); + } + } + else + rc = VERR_NOT_SUPPORTED; + + if (hOldWinStation) + SetProcessWindowStation(hOldWinStation); + } + RTEnvFreeUtf16Block(pwszzBlock); + } + + if (hEnvFinal != hEnv) + RTEnvDestroy(hEnvFinal); + } + + if ((fFlags & RTPROC_FLAGS_PROFILE) && ProfileInfo.hProfile) + { + fRc = g_pfnUnloadUserProfile(hTokenToUse, ProfileInfo.hProfile); +#ifdef RT_STRICT + if (!fRc) + { + DWORD dwErr2 = GetLastError(); + AssertMsgFailed(("Unloading user profile failed with error %u (%#x) - Are all handles closed? (dwErr=%u)", + dwErr2, dwErr2, dwErr)); + } +#endif + } + } + } + else + rc = VERR_SYMBOL_NOT_FOUND; + } /* Account lookup succeeded? */ + + if (hTokenUserDesktop != INVALID_HANDLE_VALUE) + CloseHandle(hTokenUserDesktop); + if (hTokenLogon != INVALID_HANDLE_VALUE) + CloseHandle(hTokenLogon); + + if (rc == VERR_UNRESOLVED_ERROR) + LogRelFunc(("dwErr=%u (%#x), rc=%Rrc\n", dwErr, dwErr, rc)); + } + + return rc; +} + + +/** + * Plants a standard handle into a child process on older windows versions. + * + * This is only needed when using CreateProcessWithLogonW on older windows + * versions. It would appear that newer versions of windows does this for us. + * + * @param hSrcHandle The source handle. + * @param hDstProcess The child process handle. + * @param offProcParamMember The offset to RTL_USER_PROCESS_PARAMETERS. + * @param ppvDstProcParamCache Where where cached the address of + * RTL_USER_PROCESS_PARAMETERS in the child. + */ +static void rtProcWinDupStdHandleIntoChild(HANDLE hSrcHandle, HANDLE hDstProcess, uint32_t offProcParamMember, + PVOID *ppvDstProcParamCache) +{ + if (hSrcHandle != NULL && hSrcHandle != INVALID_HANDLE_VALUE) + { + HANDLE hDstHandle; + if (DuplicateHandle(GetCurrentProcess(), hSrcHandle, hDstProcess, &hDstHandle, + 0 /*IgnoredDesiredAccess*/, FALSE /*fInherit*/, DUPLICATE_SAME_ACCESS)) + { + if (hSrcHandle == hDstHandle) + return; + + if (!*ppvDstProcParamCache) + { + PROCESS_BASIC_INFORMATION BasicInfo; + ULONG cbIgn; + NTSTATUS rcNt = NtQueryInformationProcess(hDstProcess, ProcessBasicInformation, + &BasicInfo, sizeof(BasicInfo), &cbIgn); + if (NT_SUCCESS(rcNt)) + { + SIZE_T cbCopied = 0; + if (!ReadProcessMemory(hDstProcess, + (char *)BasicInfo.PebBaseAddress + RT_UOFFSETOF(PEB_COMMON, ProcessParameters), + ppvDstProcParamCache, sizeof(*ppvDstProcParamCache), &cbCopied)) + { + AssertMsgFailed(("PebBaseAddress=%p %d\n", BasicInfo.PebBaseAddress, GetLastError())); + *ppvDstProcParamCache = NULL; + } + } + else + AssertMsgFailed(("rcNt=%#x\n", rcNt)); + } + if (*ppvDstProcParamCache) + { + if (WriteProcessMemory(hDstProcess, (char *)*ppvDstProcParamCache + offProcParamMember, + &hDstHandle, sizeof(hDstHandle), NULL)) + return; + } + + /* + * Close the handle. + */ + HANDLE hSrcHandle2; + if (DuplicateHandle(hDstProcess, hDstHandle, GetCurrentProcess(), &hSrcHandle2, + 0 /*IgnoredDesiredAccess*/, FALSE /*fInherit*/, DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE)) + CloseHandle(hSrcHandle2); + else + AssertMsgFailed(("hDstHandle=%p %u\n", hDstHandle, GetLastError())); + } + else + AssertMsg(GetLastError() == ERROR_INVALID_PARAMETER, ("%u\n", GetLastError())); + } +} + + +/** + * Method \#1. + * + * This method requires Windows 2000 or later. It may fail if the process is + * running under the SYSTEM account (like a service, ERROR_ACCESS_DENIED) on + * newer platforms (however, this works on W2K!). + */ +static int rtProcWinCreateAsUser1(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 *ppwszExec, PRTUTF16 pwszCmdLine, + RTENV hEnv, DWORD dwCreationFlags, + STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo, + uint32_t fFlags, const char *pszExec) +{ + /* The CreateProcessWithLogonW API was introduced with W2K and later. It uses a service + for launching the process. */ + if (!g_pfnCreateProcessWithLogonW) + return VERR_SYMBOL_NOT_FOUND; + + /* + * Create the environment block and find the executable first. + * + * We try to skip this when RTPROC_FLAGS_PROFILE is set so we can sidestep + * potential missing TCB privilege issues when calling UserLogonW. At least + * NT4 and W2K requires the trusted code base (TCB) privilege for logon use. + * Passing pwszzBlock=NULL and LOGON_WITH_PROFILE means the child process + * gets the environment specified by the user profile. + */ + int rc; + PRTUTF16 pwszzBlock = NULL; + + /* Eliminating the path search flags simplifies things a little. */ + if ( (fFlags & RTPROC_FLAGS_SEARCH_PATH) + && (RTPathHasPath(pszExec) || RTPathExists(pszExec))) + fFlags &= ~RTPROC_FLAGS_SEARCH_PATH; + + /* + * No profile is simple, as is a user specified environment (no change record). + */ + if ( !(fFlags & RTPROC_FLAGS_PROFILE) + || ( !(fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD) + && hEnv != RTENV_DEFAULT)) + rc = rtProcWinCreateEnvBlockAndFindExe(fFlags, hEnv, pszExec, &pwszzBlock, ppwszExec); + /* + * Default profile environment without changes or path searching we leave + * to the service that implements the API. + */ + else if ( hEnv == RTENV_DEFAULT + && !(fFlags & (RTPROC_FLAGS_ENV_CHANGE_RECORD | RTPROC_FLAGS_SEARCH_PATH))) + { + pwszzBlock = NULL; + rc = VINF_SUCCESS; + } + /* + * Otherwise, we need to get the user profile environment. + */ + else + { + RTENV hEnvToUse = NIL_RTENV; + HANDLE hTokenLogon = INVALID_HANDLE_VALUE; + rc = rtProcWinUserLogon(pwszUser, pwszPassword, &hTokenLogon); + if (RT_SUCCESS(rc)) + { + /* CreateEnvFromToken docs says we should load the profile, though + we haven't observed any difference when not doing it. Maybe it's + only an issue with roaming profiles or something similar... */ + PROFILEINFOW ProfileInfo; + RT_ZERO(ProfileInfo); + ProfileInfo.dwSize = sizeof(ProfileInfo); + ProfileInfo.lpUserName = pwszUser; + ProfileInfo.dwFlags = PI_NOUI; /* Prevents the display of profile error messages. */ + + if (g_pfnLoadUserProfileW(hTokenLogon, &ProfileInfo)) + { + /* + * Do what we need to do. Don't keep any temp environment object. + */ + rc = rtProcWinCreateEnvFromToken(hTokenLogon, hEnv, fFlags, &hEnvToUse); + if (RT_SUCCESS(rc)) + { + rc = rtProcWinFindExe(fFlags, hEnv, pszExec, ppwszExec); + if (RT_SUCCESS(rc)) + rc = RTEnvQueryUtf16Block(hEnvToUse, &pwszzBlock); + if (hEnvToUse != hEnv) + RTEnvDestroy(hEnvToUse); + } + + if (!g_pfnUnloadUserProfile(hTokenLogon, ProfileInfo.hProfile)) + AssertFailed(); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + if (hTokenLogon != INVALID_HANDLE_VALUE) + CloseHandle(hTokenLogon); + } + } + if (RT_SUCCESS(rc)) + { + /* + * Create the process. + */ + Assert(!(dwCreationFlags & CREATE_SUSPENDED)); + bool const fCreatedSuspended = g_enmWinVer < kRTWinOSType_XP; + BOOL fRc = g_pfnCreateProcessWithLogonW(pwszUser, + NULL, /* lpDomain*/ + pwszPassword, + fFlags & RTPROC_FLAGS_PROFILE ? 1 /*LOGON_WITH_ PROFILE*/ : 0, + *ppwszExec, + pwszCmdLine, + dwCreationFlags | (fCreatedSuspended ? CREATE_SUSPENDED : 0), + pwszzBlock, + NULL, /* pCurrentDirectory */ + pStartupInfo, + pProcInfo); + if (fRc) + { + if (!fCreatedSuspended) + rc = VINF_SUCCESS; + else + { + /* + * Duplicate standard handles into the child process, we ignore failures here as it's + * legal to have bad standard handle values and we cannot dup console I/O handles.* + */ + PVOID pvDstProcParamCache = NULL; + rtProcWinDupStdHandleIntoChild(pStartupInfo->hStdInput, pProcInfo->hProcess, + RT_UOFFSETOF(RTL_USER_PROCESS_PARAMETERS, StandardInput), &pvDstProcParamCache); + rtProcWinDupStdHandleIntoChild(pStartupInfo->hStdOutput, pProcInfo->hProcess, + RT_UOFFSETOF(RTL_USER_PROCESS_PARAMETERS, StandardOutput), &pvDstProcParamCache); + rtProcWinDupStdHandleIntoChild(pStartupInfo->hStdError, pProcInfo->hProcess, + RT_UOFFSETOF(RTL_USER_PROCESS_PARAMETERS, StandardError), &pvDstProcParamCache); + + if (ResumeThread(pProcInfo->hThread) != ~(DWORD)0) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + if (RT_FAILURE(rc)) + { + TerminateProcess(pProcInfo->hProcess, 127); + CloseHandle(pProcInfo->hThread); + CloseHandle(pProcInfo->hProcess); + } + } + } + else + { + DWORD dwErr = GetLastError(); + rc = RTErrConvertFromWin32(dwErr); + if (rc == VERR_UNRESOLVED_ERROR) + LogRelFunc(("CreateProcessWithLogonW (%p) failed: dwErr=%u (%#x), rc=%Rrc\n", + g_pfnCreateProcessWithLogonW, dwErr, dwErr, rc)); + } + if (pwszzBlock) + RTEnvFreeUtf16Block(pwszzBlock); + } + return rc; +} + + +static int rtProcWinCreateAsUser(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 *ppwszExec, PRTUTF16 pwszCmdLine, + RTENV hEnv, DWORD dwCreationFlags, + STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo, + uint32_t fFlags, const char *pszExec) +{ + /* + * If we run as a service CreateProcessWithLogon will fail, so don't even + * try it (because of Local System context). This method is very slow on W2K. + */ + if (!(fFlags & RTPROC_FLAGS_SERVICE)) + { + int rc = rtProcWinCreateAsUser1(pwszUser, pwszPassword, ppwszExec, pwszCmdLine, + hEnv, dwCreationFlags, pStartupInfo, pProcInfo, fFlags, pszExec); + if (RT_SUCCESS(rc)) + return rc; + } + return rtProcWinCreateAsUser2(pwszUser, pwszPassword, ppwszExec, pwszCmdLine, + hEnv, dwCreationFlags, pStartupInfo, pProcInfo, fFlags, pszExec); +} + + +/** + * RTPathTraverseList callback used by rtProcWinFindExe to locate the + * executable. + */ +static DECLCALLBACK(int) rtPathFindExec(char const *pchPath, size_t cchPath, void *pvUser1, void *pvUser2) +{ + const char *pszExec = (const char *)pvUser1; + char *pszRealExec = (char *)pvUser2; + int rc = RTPathJoinEx(pszRealExec, RTPATH_MAX, pchPath, cchPath, pszExec, RTSTR_MAX); + if (RT_FAILURE(rc)) + return rc; + if (RTFileExists(pszRealExec)) + return VINF_SUCCESS; + return VERR_TRY_AGAIN; +} + + +/** + * Locate the executable file if necessary. + * + * @returns IPRT status code. + * @param pszExec The UTF-8 executable string passed in by the user. + * @param fFlags The process creation flags pass in by the user. + * @param hEnv The environment to get the path variabel from. + * @param ppwszExec Pointer to the variable pointing to the UTF-16 + * converted string. If we find something, the current + * pointer will be free (RTUtf16Free) and + * replaced by a new one. + */ +static int rtProcWinFindExe(uint32_t fFlags, RTENV hEnv, const char *pszExec, PRTUTF16 *ppwszExec) +{ + /* + * Return immediately if we're not asked to search, or if the file has a + * path already or if it actually exists in the current directory. + */ + if ( !(fFlags & RTPROC_FLAGS_SEARCH_PATH) + || RTPathHavePath(pszExec) + || RTPathExists(pszExec) ) + return VINF_SUCCESS; + + /* + * Search the Path or PATH variable for the file. + */ + char *pszPath; + if (RTEnvExistEx(hEnv, "PATH")) + pszPath = RTEnvDupEx(hEnv, "PATH"); + else if (RTEnvExistEx(hEnv, "Path")) + pszPath = RTEnvDupEx(hEnv, "Path"); + else + return VERR_FILE_NOT_FOUND; + + char szRealExec[RTPATH_MAX]; + int rc = RTPathTraverseList(pszPath, ';', rtPathFindExec, (void *)pszExec, &szRealExec[0]); + RTStrFree(pszPath); + if (RT_SUCCESS(rc)) + { + /* + * Replace the executable string. + */ + RTPathWinFree(*ppwszExec); + *ppwszExec = NULL; + rc = RTPathWinFromUtf8(ppwszExec, szRealExec, 0 /*fFlags*/); + } + else if (rc == VERR_END_OF_STRING) + rc = VERR_FILE_NOT_FOUND; + return rc; +} + + +/** + * Creates the UTF-16 environment block and, if necessary, find the executable. + * + * @returns IPRT status code. + * @param fFlags The process creation flags pass in by the user. + * @param hEnv The environment handle passed by the user. + * @param pszExec See rtProcWinFindExe. + * @param ppwszzBlock Where RTEnvQueryUtf16Block returns the block. + * @param ppwszExec See rtProcWinFindExe. + */ +static int rtProcWinCreateEnvBlockAndFindExe(uint32_t fFlags, RTENV hEnv, const char *pszExec, + PRTUTF16 *ppwszzBlock, PRTUTF16 *ppwszExec) +{ + int rc; + + /* + * In most cases, we just need to convert the incoming enviornment to a + * UTF-16 environment block. + */ + RTENV hEnvToUse = NIL_RTENV; /* (MSC maybe used uninitialized) */ + if ( !(fFlags & (RTPROC_FLAGS_PROFILE | RTPROC_FLAGS_ENV_CHANGE_RECORD)) + || (hEnv == RTENV_DEFAULT && !(fFlags & RTPROC_FLAGS_PROFILE)) + || (hEnv != RTENV_DEFAULT && !(fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD)) ) + { + hEnvToUse = hEnv; + rc = VINF_SUCCESS; + } + else if (fFlags & RTPROC_FLAGS_PROFILE) + { + /* + * We need to get the profile environment for the current user. + */ + Assert((fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD) || hEnv == RTENV_DEFAULT); + AssertReturn(g_pfnCreateEnvironmentBlock && g_pfnDestroyEnvironmentBlock, VERR_SYMBOL_NOT_FOUND); + AssertReturn(g_pfnLoadUserProfileW && g_pfnUnloadUserProfile, VERR_SYMBOL_NOT_FOUND); + HANDLE hToken; + if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE, &hToken)) + { + rc = rtProcWinCreateEnvFromToken(hToken, hEnv, fFlags, &hEnvToUse); + CloseHandle(hToken); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + { + /* + * Apply hEnv as a change record on top of the default environment. + */ + Assert(fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD); + rc = RTEnvClone(&hEnvToUse, RTENV_DEFAULT); + if (RT_SUCCESS(rc)) + { + rc = RTEnvApplyChanges(hEnvToUse, hEnv); + if (RT_FAILURE(rc)) + RTEnvDestroy(hEnvToUse); + } + } + if (RT_SUCCESS(rc)) + { + /* + * Query the UTF-16 environment block and locate the executable (if needed). + */ + rc = RTEnvQueryUtf16Block(hEnvToUse, ppwszzBlock); + if (RT_SUCCESS(rc)) + rc = rtProcWinFindExe(fFlags, hEnvToUse, pszExec, ppwszExec); + + if (hEnvToUse != hEnv) + RTEnvDestroy(hEnvToUse); + } + + return rc; +} + + +RTR3DECL(int) RTProcCreateEx(const char *pszExec, const char * const *papszArgs, RTENV hEnv, uint32_t fFlags, + PCRTHANDLE phStdIn, PCRTHANDLE phStdOut, PCRTHANDLE phStdErr, const char *pszAsUser, + const char *pszPassword, PRTPROCESS phProcess) +{ + /* + * Input validation + */ + AssertPtrReturn(pszExec, VERR_INVALID_POINTER); + AssertReturn(*pszExec, VERR_INVALID_PARAMETER); + AssertReturn(!(fFlags & ~RTPROC_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER); + AssertReturn(!(fFlags & RTPROC_FLAGS_DETACHED) || !phProcess, VERR_INVALID_PARAMETER); + AssertReturn(hEnv != NIL_RTENV, VERR_INVALID_PARAMETER); + AssertPtrReturn(papszArgs, VERR_INVALID_PARAMETER); + AssertPtrNullReturn(pszAsUser, VERR_INVALID_POINTER); + AssertReturn(!pszAsUser || *pszAsUser, VERR_INVALID_PARAMETER); + AssertReturn(!pszPassword || pszAsUser, VERR_INVALID_PARAMETER); + AssertPtrNullReturn(pszPassword, VERR_INVALID_POINTER); + + /* + * Initialize the globals. + */ + int rc = RTOnce(&g_rtProcWinInitOnce, rtProcWinInitOnce, NULL); + AssertRCReturn(rc, rc); + if (pszAsUser || (fFlags & (RTPROC_FLAGS_PROFILE | RTPROC_FLAGS_SERVICE))) + { + rc = RTOnce(&g_rtProcWinResolveOnce, rtProcWinResolveOnce, NULL); + AssertRCReturn(rc, rc); + } + + /* + * Get the file descriptors for the handles we've been passed. + * + * It seems there is no point in trying to convince a child process's CRT + * that any of the standard file handles is non-TEXT. So, we don't... + */ + STARTUPINFOW StartupInfo; + RT_ZERO(StartupInfo); + StartupInfo.cb = sizeof(StartupInfo); + StartupInfo.dwFlags = STARTF_USESTDHANDLES; +#if 1 /* The CRT should keep the standard handles up to date. */ + StartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE); + StartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); + StartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE); +#else + StartupInfo.hStdInput = _get_osfhandle(0); + StartupInfo.hStdOutput = _get_osfhandle(1); + StartupInfo.hStdError = _get_osfhandle(2); +#endif + /* If we want to have a hidden process (e.g. not visible to + * to the user) use the STARTUPINFO flags. */ + if (fFlags & RTPROC_FLAGS_HIDDEN) + { + StartupInfo.dwFlags |= STARTF_USESHOWWINDOW; + StartupInfo.wShowWindow = SW_HIDE; + } + + PCRTHANDLE paHandles[3] = { phStdIn, phStdOut, phStdErr }; + HANDLE *aphStds[3] = { &StartupInfo.hStdInput, &StartupInfo.hStdOutput, &StartupInfo.hStdError }; + DWORD afInhStds[3] = { 0xffffffff, 0xffffffff, 0xffffffff }; + HANDLE ahStdDups[3] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE }; + for (int i = 0; i < 3; i++) + { + if (paHandles[i]) + { + AssertPtrReturn(paHandles[i], VERR_INVALID_POINTER); + switch (paHandles[i]->enmType) + { + case RTHANDLETYPE_FILE: + { + HANDLE hNativeFile = paHandles[i]->u.hFile != NIL_RTFILE + ? (HANDLE)RTFileToNative(paHandles[i]->u.hFile) + : INVALID_HANDLE_VALUE; + if ( hNativeFile == *aphStds[i] + && g_enmWinVer == kRTWinOSType_NT310) + continue; + *aphStds[i] = hNativeFile; + break; + } + + case RTHANDLETYPE_PIPE: + *aphStds[i] = paHandles[i]->u.hPipe != NIL_RTPIPE + ? (HANDLE)RTPipeToNative(paHandles[i]->u.hPipe) + : INVALID_HANDLE_VALUE; + if ( g_enmWinVer == kRTWinOSType_NT310 + && *aphStds[i] == INVALID_HANDLE_VALUE) + { + AssertMsgReturn(RTPipeGetCreationInheritability(paHandles[i]->u.hPipe), ("%Rrc %p\n", rc, *aphStds[i]), + VERR_INVALID_STATE); + continue; + } + break; + + case RTHANDLETYPE_SOCKET: + *aphStds[i] = paHandles[i]->u.hSocket != NIL_RTSOCKET + ? (HANDLE)RTSocketToNative(paHandles[i]->u.hSocket) + : INVALID_HANDLE_VALUE; + break; + + default: + AssertMsgFailedReturn(("%d: %d\n", i, paHandles[i]->enmType), VERR_INVALID_PARAMETER); + } + + /* Get the inheritability of the handle. */ + if (*aphStds[i] != INVALID_HANDLE_VALUE) + { + if (g_enmWinVer == kRTWinOSType_NT310) + afInhStds[i] = 0; /* No handle info on NT 3.1, so ASSUME it is not inheritable. */ + else if (!GetHandleInformation(*aphStds[i], &afInhStds[i])) + { + rc = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailedReturn(("%Rrc aphStds[%d] => %p paHandles[%d]={%d,%p}\n", + rc, i, *aphStds[i], i, paHandles[i]->enmType, paHandles[i]->u.uInt), + rc); + } + } + } + } + + /* + * Set the inheritability any handles we're handing the child. + * + * Note! On NT 3.1 there is no SetHandleInformation, so we have to duplicate + * the handles to make sure they are inherited by the child. + */ + rc = VINF_SUCCESS; + for (int i = 0; i < 3; i++) + if ( (afInhStds[i] != 0xffffffff) + && !(afInhStds[i] & HANDLE_FLAG_INHERIT)) + { + if (g_enmWinVer == kRTWinOSType_NT310) + { + if (DuplicateHandle(GetCurrentProcess(), *aphStds[i], GetCurrentProcess(), &ahStdDups[i], + i == 0 ? GENERIC_READ : GENERIC_WRITE, TRUE /*fInheritHandle*/, DUPLICATE_SAME_ACCESS)) + *aphStds[i] = ahStdDups[i]; + else + { + rc = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailedBreak(("%Rrc aphStds[%u] => %p\n", rc, i, *aphStds[i])); + } + } + else if (!SetHandleInformation(*aphStds[i], HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) + { + rc = RTErrConvertFromWin32(GetLastError()); + if (rc == VERR_INVALID_FUNCTION && g_enmWinVer == kRTWinOSType_NT310) + rc = VINF_SUCCESS; + else + AssertMsgFailedBreak(("%Rrc aphStds[%u] => %p\n", rc, i, *aphStds[i])); + } + } + + /* + * Create the command line and convert the executable name. + */ + PRTUTF16 pwszCmdLine = NULL; /* Shut up, MSC! */ + if (RT_SUCCESS(rc)) + rc = RTGetOptArgvToUtf16String(&pwszCmdLine, papszArgs, + !(fFlags & RTPROC_FLAGS_UNQUOTED_ARGS) + ? RTGETOPTARGV_CNV_QUOTE_MS_CRT : RTGETOPTARGV_CNV_UNQUOTED); + if (RT_SUCCESS(rc)) + { + PRTUTF16 pwszExec; + rc = RTPathWinFromUtf8(&pwszExec, pszExec, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + /* + * Get going... + */ + PROCESS_INFORMATION ProcInfo; + RT_ZERO(ProcInfo); + DWORD dwCreationFlags = CREATE_UNICODE_ENVIRONMENT; + if (fFlags & RTPROC_FLAGS_DETACHED) + dwCreationFlags |= DETACHED_PROCESS; + if (fFlags & RTPROC_FLAGS_NO_WINDOW) + dwCreationFlags |= CREATE_NO_WINDOW; + + /* + * Only use the normal CreateProcess stuff if we have no user name + * and we are not running from a (Windows) service. Otherwise use + * the more advanced version in rtProcWinCreateAsUser(). + */ + if ( pszAsUser == NULL + && !(fFlags & RTPROC_FLAGS_SERVICE)) + { + /* Create the environment block first. */ + PRTUTF16 pwszzBlock; + rc = rtProcWinCreateEnvBlockAndFindExe(fFlags, hEnv, pszExec, &pwszzBlock, &pwszExec); + if (RT_SUCCESS(rc)) + { + if (CreateProcessW(pwszExec, + pwszCmdLine, + NULL, /* pProcessAttributes */ + NULL, /* pThreadAttributes */ + TRUE, /* fInheritHandles */ + dwCreationFlags, + pwszzBlock, + NULL, /* pCurrentDirectory */ + &StartupInfo, + &ProcInfo)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + RTEnvFreeUtf16Block(pwszzBlock); + } + } + else + { + /* + * Convert the additional parameters and use a helper + * function to do the actual work. + */ + PRTUTF16 pwszUser; + rc = RTStrToUtf16(pszAsUser, &pwszUser); + if (RT_SUCCESS(rc)) + { + PRTUTF16 pwszPassword; + rc = RTStrToUtf16(pszPassword ? pszPassword : "", &pwszPassword); + if (RT_SUCCESS(rc)) + { + rc = rtProcWinCreateAsUser(pwszUser, pwszPassword, + &pwszExec, pwszCmdLine, hEnv, dwCreationFlags, + &StartupInfo, &ProcInfo, fFlags, pszExec); + + if (pwszPassword && *pwszPassword) + RTMemWipeThoroughly(pwszPassword, RTUtf16Len(pwszPassword), 5); + RTUtf16Free(pwszPassword); + } + RTUtf16Free(pwszUser); + } + } + if (RT_SUCCESS(rc)) + { + CloseHandle(ProcInfo.hThread); + if (phProcess) + { + /* + * Add the process to the child process list so + * RTProcWait can reuse and close the process handle. + */ + rtProcWinAddPid(ProcInfo.dwProcessId, ProcInfo.hProcess); + *phProcess = ProcInfo.dwProcessId; + } + else + CloseHandle(ProcInfo.hProcess); + rc = VINF_SUCCESS; + } + RTPathWinFree(pwszExec); + } + RTUtf16Free(pwszCmdLine); + } + + if (g_enmWinVer != kRTWinOSType_NT310) + { + /* Undo any handle inherit changes. */ + for (int i = 0; i < 3; i++) + if ( (afInhStds[i] != 0xffffffff) + && !(afInhStds[i] & HANDLE_FLAG_INHERIT)) + { + if ( !SetHandleInformation(*aphStds[i], HANDLE_FLAG_INHERIT, 0) + && ( GetLastError() != ERROR_INVALID_FUNCTION + || g_enmWinVer != kRTWinOSType_NT310) ) + AssertMsgFailed(("%Rrc %p\n", RTErrConvertFromWin32(GetLastError()), *aphStds[i])); + } + } + else + { + /* Close handles duplicated for correct inheritance. */ + for (int i = 0; i < 3; i++) + if (ahStdDups[i] != INVALID_HANDLE_VALUE) + CloseHandle(ahStdDups[i]); + } + + return rc; +} + + + +RTR3DECL(int) RTProcWait(RTPROCESS Process, unsigned fFlags, PRTPROCSTATUS pProcStatus) +{ + AssertReturn(!(fFlags & ~(RTPROCWAIT_FLAGS_BLOCK | RTPROCWAIT_FLAGS_NOBLOCK)), VERR_INVALID_PARAMETER); + int rc = RTOnce(&g_rtProcWinInitOnce, rtProcWinInitOnce, NULL); + AssertRCReturn(rc, rc); + + /* + * Try find the process among the ones we've spawned, otherwise, attempt + * opening the specified process. + */ + HANDLE hOpenedProc = NULL; + HANDLE hProcess = rtProcWinFindPid(Process); + if (hProcess == NULL) + { + hProcess = hOpenedProc = OpenProcess(PROCESS_QUERY_INFORMATION | SYNCHRONIZE, FALSE, Process); + if (hProcess == NULL) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_INVALID_PARAMETER) + return VERR_PROCESS_NOT_FOUND; + return RTErrConvertFromWin32(dwErr); + } + } + + /* + * Wait for it to terminate. + */ + DWORD Millies = fFlags == RTPROCWAIT_FLAGS_BLOCK ? INFINITE : 0; + DWORD WaitRc = WaitForSingleObjectEx(hProcess, Millies, TRUE); + while (WaitRc == WAIT_IO_COMPLETION) + WaitRc = WaitForSingleObjectEx(hProcess, Millies, TRUE); + switch (WaitRc) + { + /* + * It has terminated. + */ + case WAIT_OBJECT_0: + { + DWORD dwExitCode; + if (GetExitCodeProcess(hProcess, &dwExitCode)) + { + /** @todo the exit code can be special statuses. */ + if (pProcStatus) + { + pProcStatus->enmReason = RTPROCEXITREASON_NORMAL; + pProcStatus->iStatus = (int)dwExitCode; + } + if (hOpenedProc == NULL) + rtProcWinRemovePid(Process); + rc = VINF_SUCCESS; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + break; + } + + /* + * It hasn't terminated just yet. + */ + case WAIT_TIMEOUT: + rc = VERR_PROCESS_RUNNING; + break; + + /* + * Something went wrong... + */ + case WAIT_FAILED: + rc = RTErrConvertFromWin32(GetLastError()); + break; + + case WAIT_ABANDONED: + AssertFailed(); + rc = VERR_GENERAL_FAILURE; + break; + + default: + AssertMsgFailed(("WaitRc=%RU32\n", WaitRc)); + rc = VERR_GENERAL_FAILURE; + break; + } + + if (hOpenedProc != NULL) + CloseHandle(hOpenedProc); + return rc; +} + + +RTR3DECL(int) RTProcWaitNoResume(RTPROCESS Process, unsigned fFlags, PRTPROCSTATUS pProcStatus) +{ + /** @todo this isn't quite right. */ + return RTProcWait(Process, fFlags, pProcStatus); +} + + +RTR3DECL(int) RTProcTerminate(RTPROCESS Process) +{ + if (Process == NIL_RTPROCESS) + return VINF_SUCCESS; + + int rc = RTOnce(&g_rtProcWinInitOnce, rtProcWinInitOnce, NULL); + AssertRCReturn(rc, rc); + + /* + * Try find the process among the ones we've spawned, otherwise, attempt + * opening the specified process. + */ + HANDLE hProcess = rtProcWinFindPid(Process); + if (hProcess != NULL) + { + if (!TerminateProcess(hProcess, 127)) + rc = RTErrConvertFromWin32(GetLastError()); + } + else + { + hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, Process); + if (hProcess != NULL) + { + BOOL fRc = TerminateProcess(hProcess, 127); + DWORD dwErr = GetLastError(); + CloseHandle(hProcess); + if (!fRc) + rc = RTErrConvertFromWin32(dwErr); + } + } + return rc; +} + + +RTR3DECL(uint64_t) RTProcGetAffinityMask(void) +{ + DWORD_PTR dwProcessAffinityMask = 0xffffffff; + DWORD_PTR dwSystemAffinityMask; + + BOOL fRc = GetProcessAffinityMask(GetCurrentProcess(), &dwProcessAffinityMask, &dwSystemAffinityMask); + Assert(fRc); NOREF(fRc); + + return dwProcessAffinityMask; +} + + +RTR3DECL(int) RTProcQueryUsername(RTPROCESS hProcess, char *pszUser, size_t cbUser, size_t *pcbUser) +{ + AssertReturn( (pszUser && cbUser > 0) + || (!pszUser && !cbUser), VERR_INVALID_PARAMETER); + AssertReturn(pcbUser || pszUser, VERR_INVALID_PARAMETER); + + int rc; + if ( hProcess == NIL_RTPROCESS + || hProcess == RTProcSelf()) + { + RTUTF16 wszUsername[UNLEN + 1]; + DWORD cwcUsername = RT_ELEMENTS(wszUsername); + if (GetUserNameW(&wszUsername[0], &cwcUsername)) + { + if (pszUser) + { + rc = RTUtf16ToUtf8Ex(wszUsername, cwcUsername, &pszUser, cbUser, pcbUser); + if (pcbUser) + *pcbUser += 1; + } + else + { + *pcbUser = RTUtf16CalcUtf8Len(wszUsername) + 1; + rc = VERR_BUFFER_OVERFLOW; + } + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + rc = VERR_NOT_SUPPORTED; + return rc; +} + + +RTR3DECL(int) RTProcQueryUsernameA(RTPROCESS hProcess, char **ppszUser) +{ + AssertPtrReturn(ppszUser, VERR_INVALID_POINTER); + int rc; + if ( hProcess == NIL_RTPROCESS + || hProcess == RTProcSelf()) + { + RTUTF16 wszUsername[UNLEN + 1]; + DWORD cwcUsername = RT_ELEMENTS(wszUsername); + if (GetUserNameW(&wszUsername[0], &cwcUsername)) + rc = RTUtf16ToUtf8(wszUsername, ppszUser); + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + rc = VERR_NOT_SUPPORTED; + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/rtProcInitExePath-win.cpp b/src/VBox/Runtime/r3/win/rtProcInitExePath-win.cpp new file mode 100644 index 00000000..f5012df6 --- /dev/null +++ b/src/VBox/Runtime/r3/win/rtProcInitExePath-win.cpp @@ -0,0 +1,62 @@ +/* $Id: rtProcInitExePath-win.cpp $ */ +/** @file + * IPRT - rtProcInitName, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_PROCESS +#include <iprt/win/windows.h> + +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/path.h> +#include <iprt/param.h> +#include <iprt/string.h> +#include <iprt/utf16.h> +#include "internal/process.h" + + +DECLHIDDEN(int) rtProcInitExePath(char *pszPath, size_t cchPath) +{ + /* + * Query the image name from the dynamic linker, convert and return it. + */ + WCHAR wsz[RTPATH_MAX]; + HMODULE hExe = GetModuleHandle(NULL); + if (GetModuleFileNameW(hExe, wsz, RTPATH_MAX)) + { + int rc = RTUtf16ToUtf8Ex(wsz, RTSTR_MAX, &pszPath, cchPath, NULL); + AssertRCReturn(rc, rc); + return VINF_SUCCESS; + } + + DWORD err = GetLastError(); + int rc = RTErrConvertFromWin32(err); + AssertMsgFailed(("%Rrc %d\n", rc, err)); + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/sched-win.cpp b/src/VBox/Runtime/r3/win/sched-win.cpp new file mode 100644 index 00000000..2b7dba02 --- /dev/null +++ b/src/VBox/Runtime/r3/win/sched-win.cpp @@ -0,0 +1,342 @@ +/* $Id: sched-win.cpp $ */ +/** @file + * IPRT - Scheduling, Win32. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +/** @def WIN32_SCHED_ENABLED + * Enables the priority scheme. */ +#define WIN32_SCHED_ENABLED + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_THREAD +#include <iprt/win/windows.h> + +#include <iprt/thread.h> +#include <iprt/log.h> +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include "internal/sched.h" +#include "internal/thread.h" + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * Configuration of one priority. + */ +typedef struct +{ + /** The priority. */ + RTPROCPRIORITY enmPriority; + /** The name of this priority. */ + const char *pszName; + /** The Win32 process priority class. If ANY_PROCESS_PRIORITY_CLASS the + * process priority class is left unchanged. */ + DWORD dwProcessPriorityClass; + /** Array scheduler attributes corresponding to each of the thread types. */ + struct + { + /** For sanity include the array index. */ + RTTHREADTYPE enmType; + /** The Win32 thread priority. */ + int iThreadPriority; + } aTypes[RTTHREADTYPE_END]; +} PROCPRIORITY; + +/** Matches any process priority class. */ +#define ANY_PROCESS_PRIORITY_CLASS (~0U) + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** + * Array of static priority configurations. + */ +static const PROCPRIORITY g_aPriorities[] = +{ + { + RTPROCPRIORITY_FLAT, "Flat", ANY_PROCESS_PRIORITY_CLASS, + { + { RTTHREADTYPE_INVALID, ~0 }, + { RTTHREADTYPE_INFREQUENT_POLLER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MAIN_HEAVY_WORKER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_EMULATION, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_DEFAULT, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_GUI, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MAIN_WORKER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_VRDP_IO, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_DEBUGGER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MSG_PUMP, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_IO, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_TIMER, THREAD_PRIORITY_NORMAL } + } + }, + { + RTPROCPRIORITY_LOW, "Low - Below Normal", BELOW_NORMAL_PRIORITY_CLASS, + { + { RTTHREADTYPE_INVALID, ~0 }, + { RTTHREADTYPE_INFREQUENT_POLLER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_MAIN_HEAVY_WORKER, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_EMULATION, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_DEFAULT, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_GUI, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MAIN_WORKER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_VRDP_IO, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_DEBUGGER, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_MSG_PUMP, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_IO, THREAD_PRIORITY_HIGHEST }, + { RTTHREADTYPE_TIMER, THREAD_PRIORITY_HIGHEST } + } + }, + { + RTPROCPRIORITY_LOW, "Low", ANY_PROCESS_PRIORITY_CLASS, + { + { RTTHREADTYPE_INVALID, ~0 }, + { RTTHREADTYPE_INFREQUENT_POLLER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_MAIN_HEAVY_WORKER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_EMULATION, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_DEFAULT, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_GUI, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_MAIN_WORKER, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_VRDP_IO, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_DEBUGGER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MSG_PUMP, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_IO, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_TIMER, THREAD_PRIORITY_NORMAL } + } + }, + { + RTPROCPRIORITY_NORMAL, "Normal - Normal", NORMAL_PRIORITY_CLASS, + { + { RTTHREADTYPE_INVALID, ~0 }, + { RTTHREADTYPE_INFREQUENT_POLLER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_MAIN_HEAVY_WORKER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_EMULATION, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_DEFAULT, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_GUI, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MAIN_WORKER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_VRDP_IO, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_DEBUGGER, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_MSG_PUMP, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_IO, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_TIMER, THREAD_PRIORITY_HIGHEST } + } + }, + { + RTPROCPRIORITY_NORMAL, "Normal", ANY_PROCESS_PRIORITY_CLASS, + { + { RTTHREADTYPE_INVALID, ~0 }, + { RTTHREADTYPE_INFREQUENT_POLLER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_MAIN_HEAVY_WORKER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_EMULATION, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_DEFAULT, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_GUI, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MAIN_WORKER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_VRDP_IO, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_DEBUGGER, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_MSG_PUMP, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_IO, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_TIMER, THREAD_PRIORITY_HIGHEST } + } + }, + { + RTPROCPRIORITY_HIGH, "High - High", HIGH_PRIORITY_CLASS, + { + { RTTHREADTYPE_INVALID, ~0 }, + { RTTHREADTYPE_INFREQUENT_POLLER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_MAIN_HEAVY_WORKER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_EMULATION, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_DEFAULT, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_GUI, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MAIN_WORKER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_VRDP_IO, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_DEBUGGER, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_MSG_PUMP, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_IO, THREAD_PRIORITY_HIGHEST }, + { RTTHREADTYPE_TIMER, THREAD_PRIORITY_HIGHEST } + } + }, + { + RTPROCPRIORITY_HIGH, "High - Above Normal", ABOVE_NORMAL_PRIORITY_CLASS, + { + { RTTHREADTYPE_INVALID, ~0 }, + { RTTHREADTYPE_INFREQUENT_POLLER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_MAIN_HEAVY_WORKER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_EMULATION, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_DEFAULT, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_GUI, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MAIN_WORKER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_VRDP_IO, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_DEBUGGER, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_MSG_PUMP, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_IO, THREAD_PRIORITY_HIGHEST }, + { RTTHREADTYPE_TIMER, THREAD_PRIORITY_HIGHEST } + } + }, + { + RTPROCPRIORITY_HIGH, "High", ANY_PROCESS_PRIORITY_CLASS, + { + { RTTHREADTYPE_INVALID, ~0 }, + { RTTHREADTYPE_INFREQUENT_POLLER, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_MAIN_HEAVY_WORKER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_EMULATION, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_DEFAULT, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_GUI, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_MAIN_WORKER, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_VRDP_IO, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_DEBUGGER, THREAD_PRIORITY_HIGHEST }, + { RTTHREADTYPE_MSG_PUMP, THREAD_PRIORITY_HIGHEST }, + { RTTHREADTYPE_IO, THREAD_PRIORITY_HIGHEST }, + { RTTHREADTYPE_TIMER, THREAD_PRIORITY_HIGHEST } + } + } +}; + +/** + * The dynamic default priority configuration. + * + * This can be recalulated at runtime depending on what the + * system allow us to do. Presently we don't do this as it's + * generally not a bit issue on Win32 hosts. + */ +static PROCPRIORITY g_aDefaultPriority = +{ + RTPROCPRIORITY_LOW, "Default", ANY_PROCESS_PRIORITY_CLASS, + { + { RTTHREADTYPE_INVALID, ~0 }, + { RTTHREADTYPE_INFREQUENT_POLLER, THREAD_PRIORITY_LOWEST }, + { RTTHREADTYPE_MAIN_HEAVY_WORKER, THREAD_PRIORITY_BELOW_NORMAL }, + { RTTHREADTYPE_EMULATION, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_DEFAULT, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_GUI, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_MAIN_WORKER, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_VRDP_IO, THREAD_PRIORITY_NORMAL }, + { RTTHREADTYPE_DEBUGGER, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_MSG_PUMP, THREAD_PRIORITY_ABOVE_NORMAL }, + { RTTHREADTYPE_IO, THREAD_PRIORITY_HIGHEST }, + { RTTHREADTYPE_TIMER, THREAD_PRIORITY_HIGHEST } + } +}; + + +/** Pointer to the current priority configuration. */ +static const PROCPRIORITY *g_pProcessPriority = &g_aDefaultPriority; + + +/** + * Calculate the scheduling properties for all the threads in the default + * process priority, assuming the current thread have the type enmType. + * + * @returns iprt status code. + * @param enmType The thread type to be assumed for the current thread. + */ +DECLHIDDEN(int) rtSchedNativeCalcDefaultPriority(RTTHREADTYPE enmType) +{ + Assert(enmType > RTTHREADTYPE_INVALID && enmType < RTTHREADTYPE_END); RT_NOREF_PV(enmType); + return VINF_SUCCESS; +} + + +/** + * Validates and sets the process priority. + * This will check that all rtThreadNativeSetPriority() will success for all the + * thread types when applied to the current thread. + * + * @returns iprt status code. + * @param enmPriority The priority to validate and set. + * @remark Located in sched. + */ +DECLHIDDEN(int) rtProcNativeSetPriority(RTPROCPRIORITY enmPriority) +{ + Assert(enmPriority > RTPROCPRIORITY_INVALID && enmPriority < RTPROCPRIORITY_LAST); RT_NOREF_PV(enmPriority); + + if (enmPriority == RTPROCPRIORITY_DEFAULT) + { + g_pProcessPriority = &g_aDefaultPriority; + return VINF_SUCCESS; + } + + for (size_t i = 0; i < RT_ELEMENTS(g_aPriorities); i++) + if ( g_aPriorities[i].enmPriority == enmPriority + && g_aPriorities[i].dwProcessPriorityClass == ANY_PROCESS_PRIORITY_CLASS) + { + g_pProcessPriority = &g_aPriorities[i]; + return VINF_SUCCESS; + } + + AssertFailedReturn(VERR_INTERNAL_ERROR); +} + + +/** + * Gets the win32 thread handle. + * + * @returns Valid win32 handle for the specified thread. + * @param pThread The thread. + */ +DECLINLINE(HANDLE) rtThreadNativeGetHandle(PRTTHREADINT pThread) +{ + if ((uintptr_t)pThread->Core.Key == GetCurrentThreadId()) + return GetCurrentThread(); + return (HANDLE)pThread->hThread; +} + + +/** + * Sets the priority of the thread according to the thread type + * and current process priority. + * + * The RTTHREADINT::enmType member has not yet been updated and will be updated by + * the caller on a successful return. + * + * @returns iprt status code. + * @param pThread The thread in question. + * @param enmType The thread type. + * @remark Located in sched. + */ +DECLHIDDEN(int) rtThreadNativeSetPriority(PRTTHREADINT pThread, RTTHREADTYPE enmType) +{ + Assert(enmType > RTTHREADTYPE_INVALID && enmType < RTTHREADTYPE_END); + AssertMsg(g_pProcessPriority && g_pProcessPriority->aTypes[enmType].enmType == enmType, + ("enmType=%d entry=%d\n", enmType, g_pProcessPriority->aTypes[enmType].enmType)); + +#ifdef WIN32_SCHED_ENABLED + if (SetThreadPriority(rtThreadNativeGetHandle(pThread), g_pProcessPriority->aTypes[enmType].iThreadPriority)) + return VINF_SUCCESS; + + DWORD dwLastError = GetLastError(); + int rc = RTErrConvertFromWin32(dwLastError); + AssertMsgFailed(("SetThreadPriority(%p, %d) failed, dwLastError=%d rc=%Rrc\n", + rtThreadNativeGetHandle(pThread), g_pProcessPriority->aTypes[enmType].iThreadPriority, dwLastError, rc)); + return rc; +#else + return VINF_SUCCESS; +#endif +} + diff --git a/src/VBox/Runtime/r3/win/semevent-win.cpp b/src/VBox/Runtime/r3/win/semevent-win.cpp new file mode 100644 index 00000000..1e700c21 --- /dev/null +++ b/src/VBox/Runtime/r3/win/semevent-win.cpp @@ -0,0 +1,305 @@ +/* $Id: semevent-win.cpp $ */ +/** @file + * IPRT - Event Semaphore, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_SEMAPHORE +#include <iprt/win/windows.h> + +#include <iprt/semaphore.h> +#include "internal/iprt.h" + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/lockvalidator.h> +#include <iprt/mem.h> +#include <iprt/thread.h> +#include "internal/magics.h" +#include "internal/mem.h" +#include "internal/strict.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +struct RTSEMEVENTINTERNAL +{ + /** Magic value (RTSEMEVENT_MAGIC). */ + uint32_t u32Magic; + /** The event handle. */ + HANDLE hev; +#ifdef RTSEMEVENT_STRICT + /** Signallers. */ + RTLOCKVALRECSHRD Signallers; + /** Indicates that lock validation should be performed. */ + bool volatile fEverHadSignallers; +#endif + /** The creation flags. */ + uint32_t fFlags; +}; + + + +RTDECL(int) RTSemEventCreate(PRTSEMEVENT phEventSem) +{ + return RTSemEventCreateEx(phEventSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL); +} + + +RTDECL(int) RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...) +{ + AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER); + Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL)); + + struct RTSEMEVENTINTERNAL *pThis; + if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)) + pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(*pThis)); + else + pThis = (struct RTSEMEVENTINTERNAL *)rtMemBaseAlloc(sizeof(*pThis)); + if (!pThis) + return VERR_NO_MEMORY; + + /* + * Create the semaphore. + * (Auto reset, not signaled, private event object.) + */ + pThis->hev = CreateEvent(NULL, FALSE, FALSE, NULL); + if (pThis->hev != NULL) /* not INVALID_HANDLE_VALUE */ + { + pThis->u32Magic = RTSEMEVENT_MAGIC; + pThis->fFlags = fFlags; +#ifdef RTSEMEVENT_STRICT + if (!pszNameFmt) + { + static uint32_t volatile s_iSemEventAnon = 0; + RTLockValidatorRecSharedInit(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis, + true /*fSignaller*/, !(fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL), + "RTSemEvent-%u", ASMAtomicIncU32(&s_iSemEventAnon) - 1); + } + else + { + va_list va; + va_start(va, pszNameFmt); + RTLockValidatorRecSharedInitV(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis, + true /*fSignaller*/, !(fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL), + pszNameFmt, va); + va_end(va); + } + pThis->fEverHadSignallers = false; +#else + RT_NOREF_PV(hClass); RT_NOREF_PV(pszNameFmt); +#endif + + *phEventSem = pThis; + return VINF_SUCCESS; + } + + DWORD dwErr = GetLastError(); + if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)) + RTMemFree(pThis); + else + rtMemBaseFree(pThis); + return RTErrConvertFromWin32(dwErr); +} + + +RTDECL(int) RTSemEventDestroy(RTSEMEVENT hEventSem) +{ + struct RTSEMEVENTINTERNAL *pThis = hEventSem; + if (pThis == NIL_RTSEMEVENT) + return VINF_SUCCESS; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, VERR_INVALID_HANDLE); + + /* + * Invalidate the handle and close the semaphore. + */ + int rc = VINF_SUCCESS; + AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTSEMEVENT_MAGIC, RTSEMEVENT_MAGIC), VERR_INVALID_HANDLE); + if (CloseHandle(pThis->hev)) + { +#ifdef RTSEMEVENT_STRICT + RTLockValidatorRecSharedDelete(&pThis->Signallers); +#endif + if (!(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)) + RTMemFree(pThis); + else + rtMemBaseFree(pThis); + } + else + { + DWORD dwErr = GetLastError(); + rc = RTErrConvertFromWin32(dwErr); + AssertMsgFailed(("Destroy hEventSem %p failed, lasterr=%u (%Rrc)\n", pThis, dwErr, rc)); + /* Leak it. */ + } + + return rc; +} + + +RTDECL(int) RTSemEventSignal(RTSEMEVENT hEventSem) +{ + /* + * Validate input. + */ + struct RTSEMEVENTINTERNAL *pThis = hEventSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, VERR_INVALID_HANDLE); + +#ifdef RTSEMEVENT_STRICT + if (pThis->fEverHadSignallers) + { + int rc9 = RTLockValidatorRecSharedCheckSignaller(&pThis->Signallers, NIL_RTTHREAD); + if (RT_FAILURE(rc9)) + return rc9; + } +#endif + + /* + * Signal the object. + */ + if (SetEvent(pThis->hev)) + return VINF_SUCCESS; + DWORD dwErr = GetLastError(); + AssertMsgFailed(("Signaling hEventSem %p failed, lasterr=%d\n", pThis, dwErr)); + return RTErrConvertFromWin32(dwErr); +} + + +/** Goto avoidance. */ +DECL_FORCE_INLINE(int) rtSemEventWaitHandleStatus(struct RTSEMEVENTINTERNAL *pThis, DWORD rc) +{ + switch (rc) + { + case WAIT_OBJECT_0: return VINF_SUCCESS; + case WAIT_TIMEOUT: return VERR_TIMEOUT; + case WAIT_IO_COMPLETION: return VERR_INTERRUPTED; + case WAIT_ABANDONED: return VERR_SEM_OWNER_DIED; + default: + AssertMsgFailed(("%u\n", rc)); + case WAIT_FAILED: + { + int rc2 = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailed(("Wait on hEventSem %p failed, rc=%d lasterr=%d\n", pThis, rc, GetLastError())); + if (rc2) + return rc2; + + AssertMsgFailed(("WaitForSingleObject(event) -> rc=%d while converted lasterr=%d\n", rc, rc2)); + RT_NOREF_PV(pThis); + return VERR_INTERNAL_ERROR; + } + } +} + + +#undef RTSemEventWaitNoResume +RTDECL(int) RTSemEventWaitNoResume(RTSEMEVENT hEventSem, RTMSINTERVAL cMillies) +{ + /* + * Validate input. + */ + struct RTSEMEVENTINTERNAL *pThis = hEventSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, VERR_INVALID_HANDLE); + + /* + * Wait for condition. + */ +#ifdef RTSEMEVENT_STRICT + RTTHREAD hThreadSelf = !(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) + ? RTThreadSelfAutoAdopt() + : RTThreadSelf(); + if (pThis->fEverHadSignallers) + { + DWORD rc = WaitForSingleObjectEx(pThis->hev, + 0 /*Timeout*/, + TRUE /*fAlertable*/); + if (rc != WAIT_TIMEOUT || cMillies == 0) + return rtSemEventWaitHandleStatus(pThis, rc); + int rc9 = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, NULL /*pSrcPos*/, false, + cMillies, RTTHREADSTATE_EVENT, true); + if (RT_FAILURE(rc9)) + return rc9; + } +#else + RTTHREAD hThreadSelf = RTThreadSelf(); +#endif + RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT, true); + DWORD rc = WaitForSingleObjectEx(pThis->hev, + cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies, + TRUE /*fAlertable*/); + RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT); + return rtSemEventWaitHandleStatus(pThis, rc); +} + + +RTDECL(void) RTSemEventSetSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread) +{ +#ifdef RTSEMEVENT_STRICT + struct RTSEMEVENTINTERNAL *pThis = hEventSem; + AssertPtrReturnVoid(pThis); + AssertReturnVoid(pThis->u32Magic == RTSEMEVENT_MAGIC); + + ASMAtomicWriteBool(&pThis->fEverHadSignallers, true); + RTLockValidatorRecSharedResetOwner(&pThis->Signallers, hThread, NULL); +#else + RT_NOREF_PV(hEventSem); RT_NOREF_PV(hThread); +#endif +} + + +RTDECL(void) RTSemEventAddSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread) +{ +#ifdef RTSEMEVENT_STRICT + struct RTSEMEVENTINTERNAL *pThis = hEventSem; + AssertPtrReturnVoid(pThis); + AssertReturnVoid(pThis->u32Magic == RTSEMEVENT_MAGIC); + + ASMAtomicWriteBool(&pThis->fEverHadSignallers, true); + RTLockValidatorRecSharedAddOwner(&pThis->Signallers, hThread, NULL); +#else + RT_NOREF_PV(hEventSem); RT_NOREF_PV(hThread); +#endif +} + + +RTDECL(void) RTSemEventRemoveSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread) +{ +#ifdef RTSEMEVENT_STRICT + struct RTSEMEVENTINTERNAL *pThis = hEventSem; + AssertPtrReturnVoid(pThis); + AssertReturnVoid(pThis->u32Magic == RTSEMEVENT_MAGIC); + + RTLockValidatorRecSharedRemoveOwner(&pThis->Signallers, hThread); +#else + RT_NOREF_PV(hEventSem); RT_NOREF_PV(hThread); +#endif +} + diff --git a/src/VBox/Runtime/r3/win/semeventmulti-win.cpp b/src/VBox/Runtime/r3/win/semeventmulti-win.cpp new file mode 100644 index 00000000..b609e9ed --- /dev/null +++ b/src/VBox/Runtime/r3/win/semeventmulti-win.cpp @@ -0,0 +1,379 @@ +/* $Id: semeventmulti-win.cpp $ */ +/** @file + * IPRT - Multiple Release Event Semaphore, Windows. + * + * @remarks This file is identical to semevent-win.cpp except for the 2nd + * CreateEvent parameter, the reset function and the "Multi" infix. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_SEMAPHORE +#include <iprt/win/windows.h> + +#include <iprt/semaphore.h> +#include "internal/iprt.h" + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/lockvalidator.h> +#include <iprt/mem.h> +#include <iprt/thread.h> +#include <iprt/time.h> +#include "internal/magics.h" +#include "internal/strict.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +struct RTSEMEVENTMULTIINTERNAL +{ + /** Magic value (RTSEMEVENTMULTI_MAGIC). */ + uint32_t u32Magic; + /** The event handle. */ + HANDLE hev; +#ifdef RTSEMEVENT_STRICT + /** Signallers. */ + RTLOCKVALRECSHRD Signallers; + /** Indicates that lock validation should be performed. */ + bool volatile fEverHadSignallers; +#endif +}; + + + +RTDECL(int) RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem) +{ + return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL); +} + + +RTDECL(int) RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass, + const char *pszNameFmt, ...) +{ + AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER); + + struct RTSEMEVENTMULTIINTERNAL *pThis = (struct RTSEMEVENTMULTIINTERNAL *)RTMemAlloc(sizeof(*pThis)); + if (!pThis) + return VERR_NO_MEMORY; + + /* + * Create the semaphore. + * (Manual reset, not signaled, private event object.) + */ + pThis->hev = CreateEvent(NULL, TRUE, FALSE, NULL); + if (pThis->hev != NULL) /* not INVALID_HANDLE_VALUE */ + { + pThis->u32Magic = RTSEMEVENTMULTI_MAGIC; +#ifdef RTSEMEVENT_STRICT + if (!pszNameFmt) + { + static uint32_t volatile s_iSemEventMultiAnon = 0; + RTLockValidatorRecSharedInit(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis, + true /*fSignaller*/, !(fFlags & RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), + "RTSemEventMulti-%u", ASMAtomicIncU32(&s_iSemEventMultiAnon) - 1); + } + else + { + va_list va; + va_start(va, pszNameFmt); + RTLockValidatorRecSharedInitV(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis, + true /*fSignaller*/, !(fFlags & RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), + pszNameFmt, va); + va_end(va); + } + pThis->fEverHadSignallers = false; +#else + RT_NOREF_PV(hClass); RT_NOREF_PV(pszNameFmt); +#endif + + *phEventMultiSem = pThis; + return VINF_SUCCESS; + } + + DWORD dwErr = GetLastError(); + RTMemFree(pThis); + return RTErrConvertFromWin32(dwErr); +} + + +RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem) +{ + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + if (pThis == NIL_RTSEMEVENT) /* don't bitch */ + return VINF_SUCCESS; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE); + + /* + * Invalidate the handle and close the semaphore. + */ + int rc = VINF_SUCCESS; + AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTSEMEVENTMULTI_MAGIC, RTSEMEVENTMULTI_MAGIC), VERR_INVALID_HANDLE); + if (CloseHandle(pThis->hev)) + { +#ifdef RTSEMEVENT_STRICT + RTLockValidatorRecSharedDelete(&pThis->Signallers); +#endif + RTMemFree(pThis); + } + else + { + DWORD dwErr = GetLastError(); + rc = RTErrConvertFromWin32(dwErr); + AssertMsgFailed(("Destroy hEventMultiSem %p failed, lasterr=%u (%Rrc)\n", pThis, dwErr, rc)); + /* Leak it. */ + } + + return rc; +} + + +RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem) +{ + /* + * Validate input. + */ + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE); + +#ifdef RTSEMEVENT_STRICT + if (pThis->fEverHadSignallers) + { + int rc9 = RTLockValidatorRecSharedCheckSignaller(&pThis->Signallers, NIL_RTTHREAD); + if (RT_FAILURE(rc9)) + return rc9; + } +#endif + + /* + * Signal the object. + */ + if (SetEvent(pThis->hev)) + return VINF_SUCCESS; + DWORD dwErr = GetLastError(); + AssertMsgFailed(("Signaling hEventMultiSem %p failed, lasterr=%d\n", pThis, dwErr)); + return RTErrConvertFromWin32(dwErr); +} + + +RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem) +{ + /* + * Validate input. + */ + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE); + + /* + * Reset the object. + */ + if (ResetEvent(pThis->hev)) + return VINF_SUCCESS; + DWORD dwErr = GetLastError(); + AssertMsgFailed(("Resetting hEventMultiSem %p failed, lasterr=%d\n", pThis, dwErr)); + return RTErrConvertFromWin32(dwErr); +} + + +/** Goto avoidance. */ +DECL_FORCE_INLINE(int) +rtSemEventWaitHandleStatus(struct RTSEMEVENTMULTIINTERNAL *pThis, uint32_t fFlags, DWORD rc) +{ + switch (rc) + { + case WAIT_OBJECT_0: return VINF_SUCCESS; + case WAIT_TIMEOUT: return VERR_TIMEOUT; + case WAIT_IO_COMPLETION: return fFlags & RTSEMWAIT_FLAGS_RESUME ? VERR_TIMEOUT : VERR_INTERRUPTED; + case WAIT_ABANDONED: return VERR_SEM_OWNER_DIED; + default: + AssertMsgFailed(("%u\n", rc)); + case WAIT_FAILED: + { + int rc2 = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailed(("Wait on hEventMultiSem %p failed, rc=%d lasterr=%d\n", pThis, rc, GetLastError())); + if (rc2) + return rc2; + + AssertMsgFailed(("WaitForSingleObject(event) -> rc=%d while converted lasterr=%d\n", rc, rc2)); + RT_NOREF_PV(pThis); + return VERR_INTERNAL_ERROR; + } + } +} + + +DECLINLINE(int) rtSemEventMultiWinWait(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout, + PCRTLOCKVALSRCPOS pSrcPos) +{ + /* + * Validate input. + */ + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER); + + /* + * Convert the timeout to a millisecond count. + */ + uint64_t uAbsDeadline; + DWORD dwMsTimeout; + if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE) + { + dwMsTimeout = INFINITE; + uAbsDeadline = UINT64_MAX; + } + else + { + if (fFlags & RTSEMWAIT_FLAGS_NANOSECS) + uTimeout = uTimeout < UINT64_MAX - UINT32_C(1000000) / 2 + ? (uTimeout + UINT32_C(1000000) / 2) / UINT32_C(1000000) + : UINT64_MAX / UINT32_C(1000000); + if (fFlags & RTSEMWAIT_FLAGS_ABSOLUTE) + { + uAbsDeadline = uTimeout; + uint64_t u64Now = RTTimeSystemMilliTS(); + if (u64Now < uTimeout) + uTimeout -= u64Now; + else + uTimeout = 0; + } + else if (fFlags & RTSEMWAIT_FLAGS_RESUME) + uAbsDeadline = RTTimeSystemMilliTS() + uTimeout; + else + uAbsDeadline = UINT64_MAX; + + dwMsTimeout = uTimeout < UINT32_MAX + ? (DWORD)uTimeout + : INFINITE; + } + + /* + * Do the wait. + */ + DWORD rc; +#ifdef RTSEMEVENT_STRICT + RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt(); + if (pThis->fEverHadSignallers) + { + do + rc = WaitForSingleObjectEx(pThis->hev, 0 /*Timeout*/, TRUE /*fAlertable*/); + while (rc == WAIT_IO_COMPLETION && (fFlags & RTSEMWAIT_FLAGS_RESUME)); + if (rc != WAIT_TIMEOUT || dwMsTimeout == 0) + return rtSemEventWaitHandleStatus(pThis, fFlags, rc); + int rc9 = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, pSrcPos, false, + dwMsTimeout, RTTHREADSTATE_EVENT_MULTI, true); + if (RT_FAILURE(rc9)) + return rc9; + } +#else + RTTHREAD hThreadSelf = RTThreadSelf(); + RT_NOREF_PV(pSrcPos); +#endif + RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT_MULTI, true); + rc = WaitForSingleObjectEx(pThis->hev, dwMsTimeout, TRUE /*fAlertable*/); + if (rc == WAIT_IO_COMPLETION && (fFlags & RTSEMWAIT_FLAGS_RESUME)) + { + while ( rc == WAIT_IO_COMPLETION + && RTTimeSystemMilliTS() < uAbsDeadline) + rc = WaitForSingleObjectEx(pThis->hev, dwMsTimeout, TRUE /*fAlertable*/); + + } + RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT_MULTI); + return rtSemEventWaitHandleStatus(pThis, fFlags, rc); +} + + + +#undef RTSemEventMultiWaitEx +RTDECL(int) RTSemEventMultiWaitEx(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout) +{ +#ifndef RTSEMEVENT_STRICT + return rtSemEventMultiWinWait(hEventMultiSem, fFlags, uTimeout, NULL); +#else + RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API(); + return rtSemEventMultiWinWait(hEventMultiSem, fFlags, uTimeout, &SrcPos); +#endif +} + + +RTDECL(int) RTSemEventMultiWaitExDebug(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout, + RTHCUINTPTR uId, RT_SRC_POS_DECL) +{ + RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API(); + return rtSemEventMultiWinWait(hEventMultiSem, fFlags, uTimeout, &SrcPos); +} + + + +RTDECL(void) RTSemEventMultiSetSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +#ifdef RTSEMEVENT_STRICT + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturnVoid(pThis); + AssertReturnVoid(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC); + + ASMAtomicWriteBool(&pThis->fEverHadSignallers, true); + RTLockValidatorRecSharedResetOwner(&pThis->Signallers, hThread, NULL); +#else + RT_NOREF_PV(hEventMultiSem); RT_NOREF_PV(hThread); +#endif +} + + +RTDECL(void) RTSemEventMultiAddSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +#ifdef RTSEMEVENT_STRICT + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturnVoid(pThis); + AssertReturnVoid(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC); + + ASMAtomicWriteBool(&pThis->fEverHadSignallers, true); + RTLockValidatorRecSharedAddOwner(&pThis->Signallers, hThread, NULL); +#else + RT_NOREF_PV(hEventMultiSem); RT_NOREF_PV(hThread); +#endif +} + + +RTDECL(void) RTSemEventMultiRemoveSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +#ifdef RTSEMEVENT_STRICT + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturnVoid(pThis); + AssertReturnVoid(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC); + + RTLockValidatorRecSharedRemoveOwner(&pThis->Signallers, hThread); +#else + RT_NOREF_PV(hEventMultiSem); RT_NOREF_PV(hThread); +#endif +} + diff --git a/src/VBox/Runtime/r3/win/semmutex-win.cpp b/src/VBox/Runtime/r3/win/semmutex-win.cpp new file mode 100644 index 00000000..f99589d0 --- /dev/null +++ b/src/VBox/Runtime/r3/win/semmutex-win.cpp @@ -0,0 +1,346 @@ +/* $Id: semmutex-win.cpp $ */ +/** @file + * IPRT - Mutex Semaphores, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_SEMAPHORE +#include <iprt/win/windows.h> + +#include <iprt/semaphore.h> +#include "internal/iprt.h" + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/lockvalidator.h> +#include <iprt/mem.h> +#include <iprt/thread.h> +#include "internal/magics.h" +#include "internal/strict.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Posix internal representation of a Mutex semaphore. */ +struct RTSEMMUTEXINTERNAL +{ + /** Magic value (RTSEMMUTEX_MAGIC). */ + uint32_t u32Magic; + /** Recursion count. */ + uint32_t volatile cRecursions; + /** The owner thread. */ + RTNATIVETHREAD volatile hNativeOwner; + /** The mutex handle. */ + HANDLE hMtx; +#ifdef RTSEMMUTEX_STRICT + /** Lock validator record associated with this mutex. */ + RTLOCKVALRECEXCL ValidatorRec; +#endif +}; + + + +#undef RTSemMutexCreate +RTDECL(int) RTSemMutexCreate(PRTSEMMUTEX phMutexSem) +{ + return RTSemMutexCreateEx(phMutexSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, NULL); +} + + +RTDECL(int) RTSemMutexCreateEx(PRTSEMMUTEX phMutexSem, uint32_t fFlags, + RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...) +{ + AssertReturn(!(fFlags & ~RTSEMMUTEX_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER); + + /* + * Create the semaphore. + */ + int rc; + HANDLE hMtx = CreateMutex(NULL, FALSE, NULL); + if (hMtx) + { + RTSEMMUTEXINTERNAL *pThis = (RTSEMMUTEXINTERNAL *)RTMemAlloc(sizeof(*pThis)); + if (pThis) + { + pThis->u32Magic = RTSEMMUTEX_MAGIC; + pThis->hMtx = hMtx; + pThis->hNativeOwner = NIL_RTNATIVETHREAD; + pThis->cRecursions = 0; +#ifdef RTSEMMUTEX_STRICT + if (!pszNameFmt) + { + static uint32_t volatile s_iMutexAnon = 0; + RTLockValidatorRecExclInit(&pThis->ValidatorRec, hClass, uSubClass, pThis, + !(fFlags & RTSEMMUTEX_FLAGS_NO_LOCK_VAL), + "RTSemMutex-%u", ASMAtomicIncU32(&s_iMutexAnon) - 1); + } + else + { + va_list va; + va_start(va, pszNameFmt); + RTLockValidatorRecExclInitV(&pThis->ValidatorRec, hClass, uSubClass, pThis, + !(fFlags & RTSEMMUTEX_FLAGS_NO_LOCK_VAL), pszNameFmt, va); + va_end(va); + } +#else + RT_NOREF_PV(hClass); RT_NOREF_PV(uSubClass); RT_NOREF_PV(pszNameFmt); +#endif + *phMutexSem = pThis; + return VINF_SUCCESS; + } + + rc = VERR_NO_MEMORY; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + return rc; +} + + +RTDECL(int) RTSemMutexDestroy(RTSEMMUTEX hMutexSem) +{ + /* + * Validate. + */ + RTSEMMUTEXINTERNAL *pThis = hMutexSem; + if (pThis == NIL_RTSEMMUTEX) + return VINF_SUCCESS; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE); + + /* + * Close semaphore handle. + */ + AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, RTSEMMUTEX_MAGIC_DEAD, RTSEMMUTEX_MAGIC), VERR_INVALID_HANDLE); + HANDLE hMtx = pThis->hMtx; + ASMAtomicWritePtr(&pThis->hMtx, INVALID_HANDLE_VALUE); + + int rc = VINF_SUCCESS; + if (!CloseHandle(hMtx)) + { + rc = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailed(("%p rc=%d lasterr=%d\n", pThis->hMtx, rc, GetLastError())); + } + +#ifdef RTSEMMUTEX_STRICT + RTLockValidatorRecExclDelete(&pThis->ValidatorRec); +#endif + RTMemFree(pThis); + return rc; +} + + +RTDECL(uint32_t) RTSemMutexSetSubClass(RTSEMMUTEX hMutexSem, uint32_t uSubClass) +{ +#ifdef RTSEMMUTEX_STRICT + /* + * Validate. + */ + RTSEMMUTEXINTERNAL *pThis = hMutexSem; + AssertPtrReturn(pThis, RTLOCKVAL_SUB_CLASS_INVALID); + AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, RTLOCKVAL_SUB_CLASS_INVALID); + + return RTLockValidatorRecExclSetSubClass(&pThis->ValidatorRec, uSubClass); +#else + RT_NOREF_PV(hMutexSem); RT_NOREF_PV(uSubClass); + return RTLOCKVAL_SUB_CLASS_INVALID; +#endif +} + + +/** + * Internal worker for RTSemMutexRequestNoResume and it's debug companion. + * + * @returns Same as RTSEmMutexRequestNoResume + * @param hMutexSem The mutex handle. + * @param cMillies The number of milliseconds to wait. + * @param pSrcPos The source position of the caller. + */ +DECL_FORCE_INLINE(int) rtSemMutexRequestNoResume(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, PCRTLOCKVALSRCPOS pSrcPos) +{ + /* + * Validate. + */ + RTSEMMUTEXINTERNAL *pThis = hMutexSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE); + + /* + * Check for recursive entry. + */ + RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf(); + RTNATIVETHREAD hNativeOwner; + ASMAtomicReadHandle(&pThis->hNativeOwner, &hNativeOwner); + if (hNativeOwner == hNativeSelf) + { +#ifdef RTSEMMUTEX_STRICT + int rc9 = RTLockValidatorRecExclRecursion(&pThis->ValidatorRec, pSrcPos); + if (RT_FAILURE(rc9)) + return rc9; +#endif + ASMAtomicIncU32(&pThis->cRecursions); + return VINF_SUCCESS; + } + + /* + * Lock mutex semaphore. + */ + RTTHREAD hThreadSelf = NIL_RTTHREAD; + if (cMillies > 0) + { +#ifdef RTSEMMUTEX_STRICT + hThreadSelf = RTThreadSelfAutoAdopt(); + int rc9 = RTLockValidatorRecExclCheckOrderAndBlocking(&pThis->ValidatorRec, hThreadSelf, pSrcPos, true, + cMillies, RTTHREADSTATE_MUTEX, true); + if (RT_FAILURE(rc9)) + return rc9; +#else + hThreadSelf = RTThreadSelf(); + RTThreadBlocking(hThreadSelf, RTTHREADSTATE_MUTEX, true); + RT_NOREF_PV(pSrcPos); +#endif + } + DWORD rc = WaitForSingleObjectEx(pThis->hMtx, + cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies, + TRUE /*fAlertable*/); + RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_MUTEX); + switch (rc) + { + case WAIT_OBJECT_0: +#ifdef RTSEMMUTEX_STRICT + RTLockValidatorRecExclSetOwner(&pThis->ValidatorRec, hThreadSelf, pSrcPos, true); +#endif + ASMAtomicWriteHandle(&pThis->hNativeOwner, hNativeSelf); + ASMAtomicWriteU32(&pThis->cRecursions, 1); + return VINF_SUCCESS; + + case WAIT_TIMEOUT: return VERR_TIMEOUT; + case WAIT_IO_COMPLETION: return VERR_INTERRUPTED; + case WAIT_ABANDONED: return VERR_SEM_OWNER_DIED; + default: + AssertMsgFailed(("%u\n", rc)); + case WAIT_FAILED: + { + int rc2 = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailed(("Wait on hMutexSem %p failed, rc=%d lasterr=%d\n", hMutexSem, rc, GetLastError())); + if (rc2 != VINF_SUCCESS) + return rc2; + + AssertMsgFailed(("WaitForSingleObject(event) -> rc=%d while converted lasterr=%d\n", rc, rc2)); + return VERR_INTERNAL_ERROR; + } + } +} + + +#undef RTSemMutexRequestNoResume +RTDECL(int) RTSemMutexRequestNoResume(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies) +{ +#ifndef RTSEMMUTEX_STRICT + return rtSemMutexRequestNoResume(hMutexSem, cMillies, NULL); +#else + RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API(); + return rtSemMutexRequestNoResume(hMutexSem, cMillies, &SrcPos); +#endif +} + + +RTDECL(int) RTSemMutexRequestNoResumeDebug(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL) +{ + RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API(); + return rtSemMutexRequestNoResume(hMutexSem, cMillies, &SrcPos); +} + + +RTDECL(int) RTSemMutexRelease(RTSEMMUTEX hMutexSem) +{ + /* + * Validate. + */ + RTSEMMUTEXINTERNAL *pThis = hMutexSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE); + + /* + * Check ownership and recursions. + */ + RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf(); + RTNATIVETHREAD hNativeOwner; + ASMAtomicReadHandle(&pThis->hNativeOwner, &hNativeOwner); + if (RT_UNLIKELY(hNativeOwner != hNativeSelf)) + { + AssertMsgFailed(("Not owner of mutex %p!! hNativeSelf=%RTntrd Owner=%RTntrd cRecursions=%d\n", + pThis, hNativeSelf, hNativeOwner, pThis->cRecursions)); + return VERR_NOT_OWNER; + } + if (pThis->cRecursions > 1) + { +#ifdef RTSEMMUTEX_STRICT + int rc9 = RTLockValidatorRecExclUnwind(&pThis->ValidatorRec); + if (RT_FAILURE(rc9)) + return rc9; +#endif + ASMAtomicDecU32(&pThis->cRecursions); + return VINF_SUCCESS; + } + + /* + * Unlock mutex semaphore. + */ +#ifdef RTSEMMUTEX_STRICT + int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorRec, false); + if (RT_FAILURE(rc9)) + return rc9; +#endif + ASMAtomicWriteU32(&pThis->cRecursions, 0); + ASMAtomicWriteHandle(&pThis->hNativeOwner, NIL_RTNATIVETHREAD); + + if (ReleaseMutex(pThis->hMtx)) + return VINF_SUCCESS; + + int rc = RTErrConvertFromWin32(GetLastError()); + AssertMsgFailed(("%p/%p, rc=%Rrc lasterr=%d\n", pThis, pThis->hMtx, rc, GetLastError())); + return rc; +} + + +RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutexSem) +{ + /* + * Validate. + */ + RTSEMMUTEXINTERNAL *pThis = hMutexSem; + AssertPtrReturn(pThis, false); + AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, false); + + RTNATIVETHREAD hNativeOwner; + ASMAtomicReadHandle(&pThis->hNativeOwner, &hNativeOwner); + return hNativeOwner != NIL_RTNATIVETHREAD; +} + diff --git a/src/VBox/Runtime/r3/win/serialport-win.cpp b/src/VBox/Runtime/r3/win/serialport-win.cpp new file mode 100644 index 00000000..ba479207 --- /dev/null +++ b/src/VBox/Runtime/r3/win/serialport-win.cpp @@ -0,0 +1,959 @@ +/* $Id: serialport-win.cpp $ */ +/** @file + * IPRT - Serial Port API, Windows Implementation. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/serialport.h> +#include "internal/iprt.h" + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/cdefs.h> +#include <iprt/errcore.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/thread.h> +#include <iprt/time.h> +#include "internal/magics.h" + +#include <iprt/win/windows.h> + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ + +/** + * Internal serial port state. + */ +typedef struct RTSERIALPORTINTERNAL +{ + /** Magic value (RTSERIALPORT_MAGIC). */ + uint32_t u32Magic; + /** Flags given while opening the serial port. */ + uint32_t fOpenFlags; + /** The device handle. */ + HANDLE hDev; + /** The overlapped write structure. */ + OVERLAPPED OverlappedWrite; + /** The overlapped read structure. */ + OVERLAPPED OverlappedRead; + /** The overlapped I/O structure when waiting on events. */ + OVERLAPPED OverlappedEvt; + /** The event handle to wait on for the overlapped event operations of the device. */ + HANDLE hEvtDev; + /** The event handle to wait on for the overlapped write operations of the device. */ + HANDLE hEvtWrite; + /** The event handle to wait on for the overlapped read operations of the device. */ + HANDLE hEvtRead; + /** The event handle to wait on for waking up waiting threads externally. */ + HANDLE hEvtIntr; + /** Events currently waited for. */ + uint32_t fEvtMask; + /** Flag whether a write is currently pending. */ + bool fWritePending; + /** Bounce buffer for writes. */ + uint8_t *pbBounceBuf; + /** Amount of used buffer space. */ + size_t cbBounceBufUsed; + /** Amount of allocated buffer space. */ + size_t cbBounceBufAlloc; + /** The current active port config. */ + DCB PortCfg; +} RTSERIALPORTINTERNAL; +/** Pointer to the internal serial port state. */ +typedef RTSERIALPORTINTERNAL *PRTSERIALPORTINTERNAL; + + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The pipe buffer size we prefer. */ +#define RTSERIALPORT_NT_SIZE _32K + + + +/********************************************************************************************************************************* +* Global variables * +*********************************************************************************************************************************/ + + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ + +/** + * Updatest the current event mask to wait for. + * + * @returns IPRT status code. + * @param pThis The internal serial port instance data. + * @param fEvtMask The new event mask to change to. + */ +static int rtSerialPortWinUpdateEvtMask(PRTSERIALPORTINTERNAL pThis, uint32_t fEvtMask) +{ + DWORD dwEvtMask = EV_ERR; + + if (fEvtMask & RTSERIALPORT_EVT_F_DATA_RX) + dwEvtMask |= EV_RXCHAR; + if (fEvtMask & RTSERIALPORT_EVT_F_DATA_TX) + dwEvtMask |= EV_TXEMPTY; + if (fEvtMask & RTSERIALPORT_EVT_F_BREAK_DETECTED) + dwEvtMask |= EV_BREAK; + if (fEvtMask & RTSERIALPORT_EVT_F_STATUS_LINE_CHANGED) + dwEvtMask |= EV_CTS | EV_DSR | EV_RING | EV_RLSD; + + int rc = VINF_SUCCESS; + if (!SetCommMask(pThis->hDev, dwEvtMask)) + rc = RTErrConvertFromWin32(GetLastError()); + else + pThis->fEvtMask = fEvtMask; + + return rc; +} + + +/** + * Tries to set the default config on the given serial port. + * + * @returns IPRT status code. + * @param pThis The internal serial port instance data. + */ +static int rtSerialPortSetDefaultCfg(PRTSERIALPORTINTERNAL pThis) +{ + if (!PurgeComm(pThis->hDev, PURGE_RXABORT | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_TXCLEAR)) + return RTErrConvertFromWin32(GetLastError()); + + pThis->PortCfg.DCBlength = sizeof(pThis->PortCfg); + if (!GetCommState(pThis->hDev, &pThis->PortCfg)) + return RTErrConvertFromWin32(GetLastError()); + + pThis->PortCfg.BaudRate = CBR_9600; + pThis->PortCfg.fBinary = TRUE; + pThis->PortCfg.fParity = TRUE; + pThis->PortCfg.fDtrControl = DTR_CONTROL_DISABLE; + pThis->PortCfg.ByteSize = 8; + pThis->PortCfg.Parity = NOPARITY; + + int rc = VINF_SUCCESS; + if (!SetCommState(pThis->hDev, &pThis->PortCfg)) + rc = RTErrConvertFromWin32(GetLastError()); + + if (RT_SUCCESS(rc)) + { + /* + * Set timeouts for non blocking mode. + * See https://docs.microsoft.com/en-us/windows/desktop/api/winbase/ns-winbase-_commtimeouts . + */ + COMMTIMEOUTS ComTimeouts; + RT_ZERO(ComTimeouts); + ComTimeouts.ReadIntervalTimeout = MAXDWORD; + if (!SetCommTimeouts(pThis->hDev, &ComTimeouts)) + rc = RTErrConvertFromWin32(GetLastError()); + } + + return rc; +} + + +/** + * Common worker for handling I/O completion. + * + * This is used by RTSerialPortClose, RTSerialPortWrite and RTPipeSerialPortNB. + * + * @returns IPRT status code. + * @param pThis The pipe instance handle. + */ +static int rtSerialPortWriteCheckCompletion(PRTSERIALPORTINTERNAL pThis) +{ + int rc = VINF_SUCCESS; + DWORD dwRc = WaitForSingleObject(pThis->OverlappedWrite.hEvent, 0); + if (dwRc == WAIT_OBJECT_0) + { + DWORD cbWritten = 0; + if (GetOverlappedResult(pThis->hDev, &pThis->OverlappedWrite, &cbWritten, TRUE)) + { + for (;;) + { + if (cbWritten >= pThis->cbBounceBufUsed) + { + pThis->fWritePending = false; + rc = VINF_SUCCESS; + break; + } + + /* resubmit the remainder of the buffer - can this actually happen? */ + memmove(&pThis->pbBounceBuf[0], &pThis->pbBounceBuf[cbWritten], pThis->cbBounceBufUsed - cbWritten); + rc = ResetEvent(pThis->OverlappedWrite.hEvent); Assert(rc == TRUE); + if (!WriteFile(pThis->hDev, pThis->pbBounceBuf, (DWORD)pThis->cbBounceBufUsed, + &cbWritten, &pThis->OverlappedWrite)) + { + if (GetLastError() == ERROR_IO_PENDING) + rc = VINF_TRY_AGAIN; + else + { + pThis->fWritePending = false; + rc = RTErrConvertFromWin32(GetLastError()); + } + break; + } + Assert(cbWritten > 0); + } + } + else + { + pThis->fWritePending = false; + rc = RTErrConvertFromWin32(GetLastError()); + } + } + else if (dwRc == WAIT_TIMEOUT) + rc = VINF_TRY_AGAIN; + else + { + pThis->fWritePending = false; + if (dwRc == WAIT_ABANDONED) + rc = VERR_INVALID_HANDLE; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + return rc; +} + + +RTDECL(int) RTSerialPortOpen(PRTSERIALPORT phSerialPort, const char *pszPortAddress, uint32_t fFlags) +{ + AssertPtrReturn(phSerialPort, VERR_INVALID_POINTER); + AssertReturn(VALID_PTR(pszPortAddress) && *pszPortAddress != '\0', VERR_INVALID_PARAMETER); + AssertReturn(!(fFlags & ~RTSERIALPORT_OPEN_F_VALID_MASK), VERR_INVALID_PARAMETER); + AssertReturn((fFlags & RTSERIALPORT_OPEN_F_READ) || (fFlags & RTSERIALPORT_OPEN_F_WRITE), + VERR_INVALID_PARAMETER); + + int rc = VINF_SUCCESS; + PRTSERIALPORTINTERNAL pThis = (PRTSERIALPORTINTERNAL)RTMemAllocZ(sizeof(*pThis)); + if (pThis) + { + pThis->u32Magic = RTSERIALPORT_MAGIC; + pThis->fOpenFlags = fFlags; + pThis->fEvtMask = 0; + pThis->fWritePending = false; + pThis->pbBounceBuf = NULL; + pThis->cbBounceBufUsed = 0; + pThis->cbBounceBufAlloc = 0; + RT_ZERO(pThis->OverlappedEvt); + RT_ZERO(pThis->OverlappedWrite); + RT_ZERO(pThis->OverlappedRead); + pThis->hEvtDev = CreateEvent(NULL, TRUE, FALSE, NULL); + if (pThis->hEvtDev) + { + pThis->OverlappedEvt.hEvent = pThis->hEvtDev, + pThis->hEvtIntr = CreateEvent(NULL, FALSE, FALSE, NULL); + if (pThis->hEvtIntr) + { + pThis->hEvtWrite = CreateEvent(NULL, TRUE, TRUE, NULL); + if (pThis->hEvtWrite) + { + pThis->OverlappedWrite.hEvent = pThis->hEvtWrite; + pThis->hEvtRead = CreateEvent(NULL, TRUE, TRUE, NULL); + if (pThis->hEvtRead) + { + pThis->OverlappedRead.hEvent = pThis->hEvtRead; + DWORD fWinFlags = 0; + + if (fFlags & RTSERIALPORT_OPEN_F_WRITE) + fWinFlags |= GENERIC_WRITE; + if (fFlags & RTSERIALPORT_OPEN_F_READ) + fWinFlags |= GENERIC_READ; + + pThis->hDev = CreateFile(pszPortAddress, + fWinFlags, + 0, /* Must be opened with exclusive access. */ + NULL, /* No SECURITY_ATTRIBUTES structure. */ + OPEN_EXISTING, /* Must use OPEN_EXISTING. */ + FILE_FLAG_OVERLAPPED, /* Overlapped I/O. */ + NULL); + if (pThis->hDev) + { + rc = rtSerialPortSetDefaultCfg(pThis); + if (RT_SUCCESS(rc)) + { + *phSerialPort = pThis; + return rc; + } + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + CloseHandle(pThis->hEvtRead); + } + + CloseHandle(pThis->hEvtWrite); + } + + CloseHandle(pThis->hEvtIntr); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + CloseHandle(pThis->hEvtDev); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + RTMemFree(pThis); + } + else + rc = VERR_NO_MEMORY; + + return rc; +} + + +RTDECL(int) RTSerialPortClose(RTSERIALPORT hSerialPort) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + if (pThis == NIL_RTSERIALPORT) + return VINF_SUCCESS; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + + /* + * Do the cleanup. + */ + AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, RTSERIALPORT_MAGIC_DEAD, RTSERIALPORT_MAGIC), VERR_INVALID_HANDLE); + + if (pThis->fWritePending) + rtSerialPortWriteCheckCompletion(pThis); + + CloseHandle(pThis->hDev); + CloseHandle(pThis->hEvtDev); + CloseHandle(pThis->hEvtWrite); + CloseHandle(pThis->hEvtRead); + CloseHandle(pThis->hEvtIntr); + pThis->hDev = NULL; + pThis->hEvtDev = NULL; + pThis->hEvtWrite = NULL; + pThis->hEvtRead = NULL; + pThis->hEvtIntr = NULL; + RTMemFree(pThis); + return VINF_SUCCESS; +} + + +RTDECL(RTHCINTPTR) RTSerialPortToNative(RTSERIALPORT hSerialPort) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, -1); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, -1); + + return (RTHCINTPTR)pThis->hDev; +} + + +RTDECL(int) RTSerialPortRead(RTSERIALPORT hSerialPort, void *pvBuf, size_t cbToRead, size_t *pcbRead) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pvBuf, VERR_INVALID_POINTER); + AssertReturn(cbToRead > 0, VERR_INVALID_PARAMETER); + + /* + * Kick of an overlapped read. + */ + int rc = VINF_SUCCESS; + uint8_t *pbBuf = (uint8_t *)pvBuf; + + while ( cbToRead > 0 + && RT_SUCCESS(rc)) + { + BOOL fSucc = ResetEvent(pThis->OverlappedRead.hEvent); Assert(fSucc == TRUE); RT_NOREF(fSucc); + DWORD cbRead = 0; + if (ReadFile(pThis->hDev, pbBuf, + cbToRead <= ~(DWORD)0 ? (DWORD)cbToRead : ~(DWORD)0, + &cbRead, &pThis->OverlappedRead)) + { + if (pcbRead) + { + *pcbRead = cbRead; + break; + } + rc = VINF_SUCCESS; + } + else if (GetLastError() == ERROR_IO_PENDING) + { + DWORD dwWait = WaitForSingleObject(pThis->OverlappedRead.hEvent, INFINITE); + if (dwWait == WAIT_OBJECT_0) + { + if (GetOverlappedResult(pThis->hDev, &pThis->OverlappedRead, &cbRead, TRUE /*fWait*/)) + { + if (pcbRead) + { + *pcbRead = cbRead; + break; + } + rc = VINF_SUCCESS; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + { + Assert(dwWait == WAIT_FAILED); + rc = RTErrConvertFromWin32(GetLastError()); + } + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + if (RT_SUCCESS(rc)) + { + cbToRead -= cbRead; + pbBuf += cbRead; + } + } + + return rc; +} + + +RTDECL(int) RTSerialPortReadNB(RTSERIALPORT hSerialPort, void *pvBuf, size_t cbToRead, size_t *pcbRead) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pvBuf, VERR_INVALID_POINTER); + AssertReturn(cbToRead > 0, VERR_INVALID_PARAMETER); + AssertPtrReturn(pcbRead, VERR_INVALID_POINTER); + + *pcbRead = 0; + + /* Check whether there is data waiting in the input queue. */ + int rc = VINF_SUCCESS; + COMSTAT ComStat; RT_ZERO(ComStat); + if (ClearCommError(pThis->hDev, NULL, &ComStat)) + { + if (ComStat.cbInQue > 0) + { + DWORD dwToRead = RT_MIN(ComStat.cbInQue, (DWORD)cbToRead); + /* Kick of an overlapped read. It should return immediately */ + BOOL fSucc = ResetEvent(pThis->OverlappedRead.hEvent); Assert(fSucc == TRUE); RT_NOREF(fSucc); + DWORD cbRead = 0; + if ( cbToRead == 0 + || ReadFile(pThis->hDev, pvBuf, dwToRead, + &cbRead, &pThis->OverlappedRead)) + *pcbRead = cbRead; + else if (GetLastError() == ERROR_IO_PENDING) + { + /* This shouldn't actually happen, so turn this into a synchronous read. */ + if (GetOverlappedResult(pThis->hDev, &pThis->OverlappedRead, &cbRead, TRUE /*fWait*/)) + *pcbRead = cbRead; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + rc = VINF_TRY_AGAIN; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + return rc; +} + + +RTDECL(int) RTSerialPortWrite(RTSERIALPORT hSerialPort, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pvBuf, VERR_INVALID_POINTER); + AssertReturn(cbToWrite > 0, VERR_INVALID_PARAMETER); + + /* If I/O is pending, check if it has completed. */ + int rc = VINF_SUCCESS; + if (pThis->fWritePending) + rc = rtSerialPortWriteCheckCompletion(pThis); + if (rc == VINF_SUCCESS) + { + const uint8_t *pbBuf = (const uint8_t *)pvBuf; + + while ( cbToWrite > 0 + && RT_SUCCESS(rc)) + { + BOOL fSucc = ResetEvent(pThis->OverlappedWrite.hEvent); Assert(fSucc == TRUE); RT_NOREF(fSucc); + DWORD cbWritten = 0; + if (WriteFile(pThis->hDev, pbBuf, + cbToWrite <= ~(DWORD)0 ? (DWORD)cbToWrite : ~(DWORD)0, + &cbWritten, &pThis->OverlappedWrite)) + { + if (pcbWritten) + { + *pcbWritten = cbWritten; + break; + } + rc = VINF_SUCCESS; + } + else if (GetLastError() == ERROR_IO_PENDING) + { + DWORD dwWait = WaitForSingleObject(pThis->OverlappedWrite.hEvent, INFINITE); + if (dwWait == WAIT_OBJECT_0) + { + if (GetOverlappedResult(pThis->hDev, &pThis->OverlappedWrite, &cbWritten, TRUE /*fWait*/)) + { + if (pcbWritten) + { + *pcbWritten = cbWritten; + break; + } + rc = VINF_SUCCESS; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + { + Assert(dwWait == WAIT_FAILED); + rc = RTErrConvertFromWin32(GetLastError()); + } + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + if (RT_SUCCESS(rc)) + { + cbToWrite -= cbWritten; + pbBuf += cbWritten; + } + } + } + + return rc; +} + + +RTDECL(int) RTSerialPortWriteNB(RTSERIALPORT hSerialPort, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pvBuf, VERR_INVALID_POINTER); + AssertReturn(cbToWrite > 0, VERR_INVALID_PARAMETER); + AssertPtrReturn(pcbWritten, VERR_INVALID_POINTER); + + /* If I/O is pending, check if it has completed. */ + int rc = VINF_SUCCESS; + if (pThis->fWritePending) + rc = rtSerialPortWriteCheckCompletion(pThis); + if (rc == VINF_SUCCESS) + { + Assert(!pThis->fWritePending); + + /* Do the bounce buffering. */ + if ( pThis->cbBounceBufAlloc < cbToWrite + && pThis->cbBounceBufAlloc < RTSERIALPORT_NT_SIZE) + { + if (cbToWrite > RTSERIALPORT_NT_SIZE) + cbToWrite = RTSERIALPORT_NT_SIZE; + void *pv = RTMemRealloc(pThis->pbBounceBuf, RT_ALIGN_Z(cbToWrite, _1K)); + if (pv) + { + pThis->pbBounceBuf = (uint8_t *)pv; + pThis->cbBounceBufAlloc = RT_ALIGN_Z(cbToWrite, _1K); + } + else + rc = VERR_NO_MEMORY; + } + else if (cbToWrite > RTSERIALPORT_NT_SIZE) + cbToWrite = RTSERIALPORT_NT_SIZE; + if (RT_SUCCESS(rc) && cbToWrite) + { + memcpy(pThis->pbBounceBuf, pvBuf, cbToWrite); + pThis->cbBounceBufUsed = (uint32_t)cbToWrite; + + /* Submit the write. */ + rc = ResetEvent(pThis->OverlappedWrite.hEvent); Assert(rc == TRUE); + DWORD cbWritten = 0; + if (WriteFile(pThis->hDev, pThis->pbBounceBuf, (DWORD)pThis->cbBounceBufUsed, + &cbWritten, &pThis->OverlappedWrite)) + { + *pcbWritten = RT_MIN(cbWritten, cbToWrite); /* paranoia^3 */ + rc = VINF_SUCCESS; + } + else if (GetLastError() == ERROR_IO_PENDING) + { + *pcbWritten = cbToWrite; + pThis->fWritePending = true; + rc = VINF_SUCCESS; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else if (RT_SUCCESS(rc)) + *pcbWritten = 0; + } + else if (RT_SUCCESS(rc)) + *pcbWritten = 0; + + return rc; +} + + +RTDECL(int) RTSerialPortCfgQueryCurrent(RTSERIALPORT hSerialPort, PRTSERIALPORTCFG pCfg) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + + pCfg->uBaudRate = pThis->PortCfg.BaudRate; + switch (pThis->PortCfg.Parity) + { + case NOPARITY: + pCfg->enmParity = RTSERIALPORTPARITY_NONE; + break; + case EVENPARITY: + pCfg->enmParity = RTSERIALPORTPARITY_EVEN; + break; + case ODDPARITY: + pCfg->enmParity = RTSERIALPORTPARITY_ODD; + break; + case MARKPARITY: + pCfg->enmParity = RTSERIALPORTPARITY_MARK; + break; + case SPACEPARITY: + pCfg->enmParity = RTSERIALPORTPARITY_SPACE; + break; + default: + AssertFailed(); + return VERR_INTERNAL_ERROR; + } + + switch (pThis->PortCfg.ByteSize) + { + case 5: + pCfg->enmDataBitCount = RTSERIALPORTDATABITS_5BITS; + break; + case 6: + pCfg->enmDataBitCount = RTSERIALPORTDATABITS_6BITS; + break; + case 7: + pCfg->enmDataBitCount = RTSERIALPORTDATABITS_7BITS; + break; + case 8: + pCfg->enmDataBitCount = RTSERIALPORTDATABITS_8BITS; + break; + default: + AssertFailed(); + return VERR_INTERNAL_ERROR; + } + + switch (pThis->PortCfg.StopBits) + { + case ONESTOPBIT: + pCfg->enmStopBitCount = RTSERIALPORTSTOPBITS_ONE; + break; + case ONE5STOPBITS: + pCfg->enmStopBitCount = RTSERIALPORTSTOPBITS_ONEPOINTFIVE; + break; + case TWOSTOPBITS: + pCfg->enmStopBitCount = RTSERIALPORTSTOPBITS_TWO; + break; + default: + AssertFailed(); + return VERR_INTERNAL_ERROR; + } + + return VINF_SUCCESS; +} + + +RTDECL(int) RTSerialPortCfgSet(RTSERIALPORT hSerialPort, PCRTSERIALPORTCFG pCfg, PRTERRINFO pErrInfo) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + + RT_NOREF(pErrInfo); + + DCB DcbNew; + memcpy(&DcbNew, &pThis->PortCfg, sizeof(DcbNew)); + DcbNew.BaudRate = pCfg->uBaudRate; + + switch (pCfg->enmParity) + { + case RTSERIALPORTPARITY_NONE: + DcbNew.Parity = NOPARITY; + break; + case RTSERIALPORTPARITY_EVEN: + DcbNew.Parity = EVENPARITY; + break; + case RTSERIALPORTPARITY_ODD: + DcbNew.Parity = ODDPARITY; + break; + case RTSERIALPORTPARITY_MARK: + DcbNew.Parity = MARKPARITY; + break; + case RTSERIALPORTPARITY_SPACE: + DcbNew.Parity = SPACEPARITY; + break; + default: + AssertFailedReturn(VERR_INVALID_PARAMETER); + } + + switch (pCfg->enmDataBitCount) + { + case RTSERIALPORTDATABITS_5BITS: + DcbNew.ByteSize = 5; + break; + case RTSERIALPORTDATABITS_6BITS: + DcbNew.ByteSize = 6; + break; + case RTSERIALPORTDATABITS_7BITS: + DcbNew.ByteSize = 7; + break; + case RTSERIALPORTDATABITS_8BITS: + DcbNew.ByteSize = 8; + break; + default: + AssertFailedReturn(VERR_INVALID_PARAMETER); + } + + switch (pCfg->enmStopBitCount) + { + case RTSERIALPORTSTOPBITS_ONE: + DcbNew.StopBits = ONESTOPBIT; + break; + case RTSERIALPORTSTOPBITS_ONEPOINTFIVE: + AssertReturn(pCfg->enmDataBitCount == RTSERIALPORTDATABITS_5BITS, VERR_INVALID_PARAMETER); + DcbNew.StopBits = ONE5STOPBITS; + break; + case RTSERIALPORTSTOPBITS_TWO: + AssertReturn(pCfg->enmDataBitCount != RTSERIALPORTDATABITS_5BITS, VERR_INVALID_PARAMETER); + DcbNew.StopBits = TWOSTOPBITS; + break; + default: + AssertFailedReturn(VERR_INVALID_PARAMETER); + } + + int rc = VINF_SUCCESS; + if (!SetCommState(pThis->hDev, &DcbNew)) + rc = RTErrConvertFromWin32(GetLastError()); + else + memcpy(&pThis->PortCfg, &DcbNew, sizeof(DcbNew)); + + return rc; +} + + +RTDECL(int) RTSerialPortEvtPoll(RTSERIALPORT hSerialPort, uint32_t fEvtMask, uint32_t *pfEvtsRecv, + RTMSINTERVAL msTimeout) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(!(fEvtMask & ~RTSERIALPORT_EVT_F_VALID_MASK), VERR_INVALID_PARAMETER); + AssertPtrReturn(pfEvtsRecv, VERR_INVALID_POINTER); + + *pfEvtsRecv = 0; + + int rc = VINF_SUCCESS; + if (fEvtMask != pThis->fEvtMask) + rc = rtSerialPortWinUpdateEvtMask(pThis, fEvtMask); + + /* + * EV_RXCHAR is triggered only if a byte is received after the event mask is set, + * not if there is already something in the input buffer. Thatswhy we check the input + * buffer for any stored data and the output buffer whether it is empty and return + * the appropriate flags. + */ + if (RT_SUCCESS(rc)) + { + COMSTAT ComStat; RT_ZERO(ComStat); + if (!ClearCommError(pThis->hDev, NULL, &ComStat)) + return RTErrConvertFromWin32(GetLastError()); + + /* Check whether data is already waiting in the input buffer. */ + if ( (fEvtMask & RTSERIALPORT_EVT_F_DATA_RX) + && ComStat.cbInQue > 0) + *pfEvtsRecv |= RTSERIALPORT_EVT_F_DATA_RX; + + /* Check whether the output buffer is empty. */ + if ( (fEvtMask & RTSERIALPORT_EVT_F_DATA_TX) + && ComStat.cbOutQue == 0) + *pfEvtsRecv |= RTSERIALPORT_EVT_F_DATA_TX; + + /* Return if there is at least one event. */ + if (*pfEvtsRecv != 0) + return VINF_SUCCESS; + } + + if (RT_SUCCESS(rc)) + { + DWORD dwEventMask = 0; + HANDLE ahWait[2]; + ahWait[0] = pThis->hEvtDev; + ahWait[1] = pThis->hEvtIntr; + + RT_ZERO(pThis->OverlappedEvt); + pThis->OverlappedEvt.hEvent = pThis->hEvtDev; + + if (!WaitCommEvent(pThis->hDev, &dwEventMask, &pThis->OverlappedEvt)) + { + DWORD dwRet = GetLastError(); + if (dwRet == ERROR_IO_PENDING) + { + dwRet = WaitForMultipleObjects(2, ahWait, FALSE, msTimeout == RT_INDEFINITE_WAIT ? INFINITE : msTimeout); + if (dwRet == WAIT_TIMEOUT) + rc = VERR_TIMEOUT; + else if (dwRet == WAIT_FAILED) + rc = RTErrConvertFromWin32(GetLastError()); + else if (dwRet != WAIT_OBJECT_0) + rc = VERR_INTERRUPTED; + } + else + rc = RTErrConvertFromWin32(dwRet); + } + + if (RT_SUCCESS(rc)) + { + /* Check the event */ + if (dwEventMask & EV_RXCHAR) + *pfEvtsRecv |= RTSERIALPORT_EVT_F_DATA_RX; + if (dwEventMask & EV_TXEMPTY) + { + if (pThis->fWritePending) + { + rc = rtSerialPortWriteCheckCompletion(pThis); + if (rc == VINF_SUCCESS) + *pfEvtsRecv |= RTSERIALPORT_EVT_F_DATA_TX; + else + rc = VINF_SUCCESS; + } + else + *pfEvtsRecv |= RTSERIALPORT_EVT_F_DATA_TX; + } + if (dwEventMask & EV_BREAK) + *pfEvtsRecv |= RTSERIALPORT_EVT_F_BREAK_DETECTED; + if (dwEventMask & (EV_CTS | EV_DSR | EV_RING | EV_RLSD)) + *pfEvtsRecv |= RTSERIALPORT_EVT_F_STATUS_LINE_CHANGED; + } + } + + return rc; +} + + +RTDECL(int) RTSerialPortEvtPollInterrupt(RTSERIALPORT hSerialPort) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + + if (!SetEvent(pThis->hEvtIntr)) + return RTErrConvertFromWin32(GetLastError()); + + return VINF_SUCCESS; +} + + +RTDECL(int) RTSerialPortChgBreakCondition(RTSERIALPORT hSerialPort, bool fSet) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + + BOOL fSucc = FALSE; + if (fSet) + fSucc = SetCommBreak(pThis->hDev); + else + fSucc = ClearCommBreak(pThis->hDev); + + int rc = VINF_SUCCESS; + if (!fSucc) + rc = RTErrConvertFromWin32(GetLastError()); + + return rc; +} + + +RTDECL(int) RTSerialPortChgStatusLines(RTSERIALPORT hSerialPort, uint32_t fClear, uint32_t fSet) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + + BOOL fSucc = TRUE; + if (fSet & RTSERIALPORT_CHG_STS_LINES_F_DTR) + fSucc = EscapeCommFunction(pThis->hDev, SETDTR); + if ( fSucc + && (fSet & RTSERIALPORT_CHG_STS_LINES_F_RTS)) + fSucc = EscapeCommFunction(pThis->hDev, SETRTS); + + if ( fSucc + && (fClear & RTSERIALPORT_CHG_STS_LINES_F_DTR)) + fSucc = EscapeCommFunction(pThis->hDev, CLRDTR); + if ( fSucc + && (fClear & RTSERIALPORT_CHG_STS_LINES_F_RTS)) + fSucc = EscapeCommFunction(pThis->hDev, CLRRTS); + + int rc = VINF_SUCCESS; + if (!fSucc) + rc = RTErrConvertFromWin32(GetLastError()); + + return rc; +} + + +RTDECL(int) RTSerialPortQueryStatusLines(RTSERIALPORT hSerialPort, uint32_t *pfStsLines) +{ + PRTSERIALPORTINTERNAL pThis = hSerialPort; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pfStsLines, VERR_INVALID_POINTER); + + *pfStsLines = 0; + + int rc = VINF_SUCCESS; + DWORD fStsLinesQueried = 0; + + /* Get the new state */ + if (GetCommModemStatus(pThis->hDev, &fStsLinesQueried)) + { + *pfStsLines |= (fStsLinesQueried & MS_RLSD_ON) ? RTSERIALPORT_STS_LINE_DCD : 0; + *pfStsLines |= (fStsLinesQueried & MS_RING_ON) ? RTSERIALPORT_STS_LINE_RI : 0; + *pfStsLines |= (fStsLinesQueried & MS_DSR_ON) ? RTSERIALPORT_STS_LINE_DSR : 0; + *pfStsLines |= (fStsLinesQueried & MS_CTS_ON) ? RTSERIALPORT_STS_LINE_CTS : 0; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/shmem-win.cpp b/src/VBox/Runtime/r3/win/shmem-win.cpp new file mode 100644 index 00000000..797d41e5 --- /dev/null +++ b/src/VBox/Runtime/r3/win/shmem-win.cpp @@ -0,0 +1,454 @@ +/* $Id: shmem-win.cpp $ */ +/** @file + * IPRT - Named shared memory object, Windows Implementation. + */ + +/* + * Copyright (C) 2018-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/nt/nt-and-windows.h> + +#include <iprt/shmem.h> +#include "internal/iprt.h" + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/cdefs.h> +#include <iprt/err.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/utf16.h> +#include "internal/magics.h" +#include "internal/path.h" +#include "internal-r3-win.h" /* For g_enmWinVer + kRTWinOSType_XXX */ + +/* + * Define values ourselves in case the compiling host is too old. + * See https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-createfilemappinga + * for when these were introduced. + */ +#ifndef PAGE_EXECUTE_READ +# define PAGE_EXECUTE_READ 0x20 +#endif +#ifndef PAGE_EXECUTE_READWRITE +# define PAGE_EXECUTE_READWRITE 0x40 +#endif +#ifndef PAGE_EXECUTE_WRITECOPY +# define PAGE_EXECUTE_WRITECOPY 0x80 +#endif +#ifndef FILE_MAP_EXECUTE +# define FILE_MAP_EXECUTE 0x20 +#endif + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ + +/** + * Shared memory object mapping descriptor. + */ +typedef struct RTSHMEMMAPPINGDESC +{ + /** Number of references held to this mapping, 0 if the descriptor is free. */ + volatile uint32_t cMappings; + /** Pointer to the region mapping. */ + void *pvMapping; + /** Start offset */ + size_t offRegion; + /** Size of the region. */ + size_t cbRegion; + /** Access flags for this region .*/ + uint32_t fFlags; +} RTSHMEMMAPPINGDESC; +/** Pointer to a shared memory object mapping descriptor. */ +typedef RTSHMEMMAPPINGDESC *PRTSHMEMMAPPINGDESC; +/** Pointer to a constant shared memory object mapping descriptor. */ +typedef const RTSHMEMMAPPINGDESC *PCRTSHMEMMAPPINGDESC; + + +/** + * Internal shared memory object state. + */ +typedef struct RTSHMEMINT +{ + /** Magic value (RTSHMEM_MAGIC). */ + uint32_t u32Magic; + /** Flag whether this instance created the named shared memory object. */ + bool fCreate; + /** Handle to the underlying mapping object. */ + HANDLE hShmObj; + /** Size of the mapping object in bytes. */ + size_t cbMax; + /** Overall number of mappings active for this shared memory object. */ + volatile uint32_t cMappings; + /** Maximum number of mapping descriptors allocated. */ + uint32_t cMappingDescsMax; + /** Number of mapping descriptors used. */ + volatile uint32_t cMappingDescsUsed; + /** Array of mapping descriptors - variable in size. */ + RTSHMEMMAPPINGDESC aMappingDescs[1]; +} RTSHMEMINT; +/** Pointer to the internal shared memory object state. */ +typedef RTSHMEMINT *PRTSHMEMINT; + + + + +/** + * Returns a mapping descriptor matching the given region properties or NULL if none was found. + * + * @returns Pointer to the matching mapping descriptor or NULL if not found. + * @param pThis Pointer to the shared memory object instance. + * @param offRegion Offset into the shared memory object to start mapping at. + * @param cbRegion Size of the region to map. + * @param fFlags Desired properties of the mapped region, combination of RTSHMEM_MAP_F_* defines. + */ +DECLINLINE(PRTSHMEMMAPPINGDESC) rtShMemMappingDescFindByProp(PRTSHMEMINT pThis, size_t offRegion, size_t cbRegion, uint32_t fFlags) +{ + for (uint32_t i = 0; i < pThis->cMappingDescsMax; i++) + { + if ( pThis->aMappingDescs[i].offRegion == offRegion + && pThis->aMappingDescs[i].cbRegion == cbRegion + && pThis->aMappingDescs[i].fFlags == fFlags) + return &pThis->aMappingDescs[i]; + } + + return NULL; +} + + +RTDECL(int) RTShMemOpen(PRTSHMEM phShMem, const char *pszName, uint32_t fFlags, size_t cbMax, uint32_t cMappingsHint) +{ + AssertPtrReturn(phShMem, VERR_INVALID_PARAMETER); + AssertPtrReturn(pszName, VERR_INVALID_PARAMETER); + AssertReturn(!(fFlags & ~RTSHMEM_O_F_VALID_MASK), VERR_INVALID_PARAMETER); + AssertReturn(cMappingsHint < 64, VERR_OUT_OF_RANGE); + AssertReturn(cbMax > 0 || !(fFlags & RTSHMEM_O_F_CREATE), VERR_NOT_SUPPORTED); + + if (fFlags & RTSHMEM_O_F_TRUNCATE) + return VERR_NOT_SUPPORTED; + + /* + * The executable access was introduced with Windows XP SP2 and Windows Server 2003 SP1, + * PAGE_EXECUTE_WRITECOPY was not available until Windows Vista SP1. + * Allow execute mappings only starting from Windows 7 to keep the checks simple here (lazy coder). + */ + if ( (fFlags & RTSHMEM_O_F_MAYBE_EXEC) + && g_enmWinVer < kRTWinOSType_7) + return VERR_NOT_SUPPORTED; + + cMappingsHint = cMappingsHint == 0 ? 5 : cMappingsHint; + int rc = VINF_SUCCESS; + PRTSHMEMINT pThis = (PRTSHMEMINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTSHMEMINT, aMappingDescs[cMappingsHint])); + if (RT_LIKELY(pThis)) + { + pThis->u32Magic = RTSHMEM_MAGIC; + /*pThis->fCreate = false; */ + /*pThis->cMappings = 0; */ + pThis->cMappingDescsMax = cMappingsHint; + /*pThis->cMappingDescsUsed = 0; */ + /* Construct the filename, always use the local namespace, global requires special privileges. */ + char szName[RTPATH_MAX]; + ssize_t cch = RTStrPrintf2(&szName[0], sizeof(szName), "Local\\%s", pszName); + if (cch > 0) + { + PRTUTF16 pwszName = NULL; + rc = RTStrToUtf16Ex(&szName[0], RTSTR_MAX, &pwszName, 0, NULL); + if (RT_SUCCESS(rc)) + { + if (fFlags & RTSHMEM_O_F_CREATE) + { +#if HC_ARCH_BITS == 64 + DWORD dwSzMaxHigh = cbMax >> 32; +#elif HC_ARCH_BITS == 32 + DWORD dwSzMaxHigh = 0; +#else +# error "Port me" +#endif + DWORD dwSzMaxLow = cbMax & UINT32_C(0xffffffff); + DWORD fProt = 0; + + if (fFlags & RTSHMEM_O_F_MAYBE_EXEC) + { + if ((fFlags & RTSHMEM_O_F_READWRITE) == RTSHMEM_O_F_READ) + fProt |= PAGE_EXECUTE_READ; + else + fProt |= PAGE_EXECUTE_READWRITE; + } + else + { + if ((fFlags & RTSHMEM_O_F_READWRITE) == RTSHMEM_O_F_READ) + fProt |= PAGE_READONLY; + else + fProt |= PAGE_READWRITE; + } + pThis->hShmObj = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, fProt, + dwSzMaxHigh, dwSzMaxLow, pwszName); + } + else + { + DWORD fProt = SECTION_QUERY; + if (fFlags & RTSHMEM_O_F_MAYBE_EXEC) + fProt |= FILE_MAP_EXECUTE; + if (fFlags & RTSHMEM_O_F_READ) + fProt |= FILE_MAP_READ; + if (fFlags & RTSHMEM_O_F_WRITE) + fProt |= FILE_MAP_WRITE; + + pThis->hShmObj = OpenFileMappingW(fProt, FALSE, pwszName); + } + RTUtf16Free(pwszName); + if (pThis->hShmObj != NULL) + { + *phShMem = pThis; + return VINF_SUCCESS; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + } + else + rc = VERR_BUFFER_OVERFLOW; + + RTMemFree(pThis); + } + else + rc = VERR_NO_MEMORY; + + return rc; +} + + +RTDECL(int) RTShMemClose(RTSHMEM hShMem) +{ + PRTSHMEMINT pThis = hShMem; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSHMEM_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(!pThis->cMappings, VERR_INVALID_STATE); + + int rc = VINF_SUCCESS; + if (CloseHandle(pThis->hShmObj)) + { + pThis->u32Magic = RTSHMEM_MAGIC_DEAD; + RTMemFree(pThis); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + return rc; +} + + +RTDECL(uint32_t) RTShMemRefCount(RTSHMEM hShMem) +{ + PRTSHMEMINT pThis = hShMem; + AssertPtrReturn(pThis, 0); + AssertReturn(pThis->u32Magic == RTSHMEM_MAGIC, 0); + + return pThis->cMappings; +} + + +RTDECL(int) RTShMemSetSize(RTSHMEM hShMem, size_t cbMem) +{ + PRTSHMEMINT pThis = hShMem; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSHMEM_MAGIC, VERR_INVALID_HANDLE); + AssertReturn(!pThis->cMappings, VERR_INVALID_STATE); + AssertReturn(cbMem, VERR_NOT_SUPPORTED); + + return VERR_NOT_SUPPORTED; +} + + +RTDECL(int) RTShMemQuerySize(RTSHMEM hShMem, size_t *pcbMem) +{ + PRTSHMEMINT pThis = hShMem; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSHMEM_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pcbMem, VERR_INVALID_PARAMETER); + + int rc = VINF_SUCCESS; + SECTION_BASIC_INFORMATION SecInf; + SIZE_T cbRet; + NTSTATUS rcNt = NtQuerySection(pThis->hShmObj, SectionBasicInformation, &SecInf, sizeof(SecInf), &cbRet); + if (NT_SUCCESS(rcNt)) + { + AssertReturn(cbRet == sizeof(SecInf), VERR_INTERNAL_ERROR); +#if HC_ARCH_BITS == 32 + AssertReturn(SecInf.MaximumSize.HighPart == 0, VERR_INTERNAL_ERROR_2); + *pcbMem = SecInf.MaximumSize.LowPart; +#elif HC_ARCH_BITS == 64 + *pcbMem = SecInf.MaximumSize.QuadPart; +#else +# error "Port me" +#endif + } + else + rc = RTErrConvertFromNtStatus(rcNt); + + return rc; +} + + +RTDECL(int) RTShMemMapRegion(RTSHMEM hShMem, size_t offRegion, size_t cbRegion, uint32_t fFlags, void **ppv) +{ + PRTSHMEMINT pThis = hShMem; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSHMEM_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(ppv, VERR_INVALID_PARAMETER); + AssertReturn(!(fFlags & ~RTSHMEM_MAP_F_VALID_MASK), VERR_INVALID_PARAMETER); + + /* See comment in RTShMemOpen(). */ + if ( (fFlags & RTSHMEM_MAP_F_EXEC) + && g_enmWinVer < kRTWinOSType_7) + return VERR_NOT_SUPPORTED; + + /* Try to find a mapping with compatible parameters first. */ + PRTSHMEMMAPPINGDESC pMappingDesc = NULL; + for (uint32_t iTry = 0; iTry < 10; iTry++) + { + pMappingDesc = rtShMemMappingDescFindByProp(pThis, offRegion, cbRegion, fFlags); + if (!pMappingDesc) + break; + + /* Increase the mapping count and check that the region is still accessible by us. */ + if ( ASMAtomicIncU32(&pMappingDesc->cMappings) > 1 + && pMappingDesc->offRegion == offRegion + && pMappingDesc->cbRegion == cbRegion + && pMappingDesc->fFlags == fFlags) + break; + /* Mapping was freed inbetween, next round. */ + } + + int rc = VINF_SUCCESS; + if (!pMappingDesc) + { + /* Find an empty region descriptor and map the region. */ + for (uint32_t i = 0; i < pThis->cMappingDescsMax && !pMappingDesc; i++) + { + if (!pThis->aMappingDescs[i].cMappings) + { + pMappingDesc = &pThis->aMappingDescs[i]; + + /* Try to grab this one. */ + if (ASMAtomicIncU32(&pMappingDesc->cMappings) == 1) + break; + + /* Somebody raced us, drop reference and continue. */ + ASMAtomicDecU32(&pMappingDesc->cMappings); + pMappingDesc = NULL; + } + } + + if (RT_LIKELY(pMappingDesc)) + { + /* Try to map it. */ + DWORD fProt = 0; + DWORD offLow = offRegion & UINT32_C(0xffffffff); +#if HC_ARCH_BITS == 64 + DWORD offHigh = offRegion >> 32; +#elif HC_ARCH_BITS == 32 + DWORD offHigh = 0; +#else +# error "Port me" +#endif + if (fFlags & RTSHMEM_MAP_F_READ) + fProt |= FILE_MAP_READ; + if (fFlags & RTSHMEM_MAP_F_WRITE) + fProt |= FILE_MAP_WRITE; + if (fFlags & RTSHMEM_MAP_F_EXEC) + fProt |= FILE_MAP_EXECUTE; + if (fFlags & RTSHMEM_MAP_F_COW) + fProt |= FILE_MAP_COPY; + + void *pv = MapViewOfFile(pThis->hShmObj, fProt, offHigh, offLow, cbRegion); + if (pv != NULL) + { + pMappingDesc->pvMapping = pv; + pMappingDesc->offRegion = offRegion; + pMappingDesc->cbRegion = cbRegion; + pMappingDesc->fFlags = fFlags; + } + else + { + rc = RTErrConvertFromWin32(GetLastError()); + ASMAtomicDecU32(&pMappingDesc->cMappings); + } + } + else + rc = VERR_SHMEM_MAXIMUM_MAPPINGS_REACHED; + } + + if (RT_SUCCESS(rc)) + { + *ppv = pMappingDesc->pvMapping; + ASMAtomicIncU32(&pThis->cMappings); + } + + return rc; +} + + +RTDECL(int) RTShMemUnmapRegion(RTSHMEM hShMem, void *pv) +{ + PRTSHMEMINT pThis = hShMem; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertReturn(pThis->u32Magic == RTSHMEM_MAGIC, VERR_INVALID_HANDLE); + AssertPtrReturn(pv, VERR_INVALID_PARAMETER); + + /* Find the mapping descriptor by the given region address. */ + PRTSHMEMMAPPINGDESC pMappingDesc = NULL; + for (uint32_t i = 0; i < pThis->cMappingDescsMax && !pMappingDesc; i++) + { + if (pThis->aMappingDescs[i].pvMapping == pv) + { + pMappingDesc = &pThis->aMappingDescs[i]; + break; + } + } + + AssertPtrReturn(pMappingDesc, VERR_INVALID_PARAMETER); + + int rc = VINF_SUCCESS; + if (!ASMAtomicDecU32(&pMappingDesc->cMappings)) + { + /* Last mapping of this region was unmapped, so do the real unmapping now. */ + if (UnmapViewOfFile(pv)) + { + ASMAtomicDecU32(&pThis->cMappingDescsUsed); + ASMAtomicDecU32(&pThis->cMappings); + } + else + { + ASMAtomicIncU32(&pMappingDesc->cMappings); + rc = RTErrConvertFromWin32(GetLastError()); + } + } + + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/symlink-win.cpp b/src/VBox/Runtime/r3/win/symlink-win.cpp new file mode 100644 index 00000000..b5939e08 --- /dev/null +++ b/src/VBox/Runtime/r3/win/symlink-win.cpp @@ -0,0 +1,357 @@ +/* $Id: symlink-win.cpp $ */ +/** @file + * IPRT - Symbolic Links, Windows. + */ + +/* + * Copyright (C) 2010-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_SYMLINK +#include <iprt/win/windows.h> + +#include <iprt/symlink.h> +#include "internal-r3-win.h" + +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/log.h> +#include <iprt/path.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/utf16.h> +#include "internal/path.h" + + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef struct MY_REPARSE_DATA_BUFFER +{ + ULONG ReparseTag; +#define MY_IO_REPARSE_TAG_SYMLINK 0xa000000c +#define MY_IO_REPARSE_TAG_MOUNT_POINT 0xa0000003 + + USHORT ReparseDataLength; + USHORT Reserved; + union + { + struct + { + USHORT SubstituteNameOffset; + USHORT SubstituteNameLength; + USHORT PrintNameOffset; + USHORT PrintNameLength; + ULONG Flags; +#define MY_SYMLINK_FLAG_RELATIVE 1 + WCHAR PathBuffer[1]; + } SymbolicLinkReparseBuffer; + struct + { + USHORT SubstituteNameOffset; + USHORT SubstituteNameLength; + USHORT PrintNameOffset; + USHORT PrintNameLength; + WCHAR PathBuffer[1]; + } MountPointReparseBuffer; + struct + { + UCHAR DataBuffer[1]; + } GenericReparseBuffer; + }; +} MY_REPARSE_DATA_BUFFER; +#define MY_FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS) + + +RTDECL(bool) RTSymlinkExists(const char *pszSymlink) +{ + bool fRc = false; + RTFSOBJINFO ObjInfo; + int rc = RTPathQueryInfoEx(pszSymlink, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK); + if (RT_SUCCESS(rc)) + fRc = RTFS_IS_SYMLINK(ObjInfo.Attr.fMode); + + LogFlow(("RTSymlinkExists(%p={%s}): returns %RTbool\n", pszSymlink, pszSymlink, fRc)); + return fRc; +} + + +RTDECL(bool) RTSymlinkIsDangling(const char *pszSymlink) +{ + bool fRc = false; + RTFSOBJINFO ObjInfo; + int rc = RTPathQueryInfoEx(pszSymlink, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK); + if (RT_SUCCESS(rc)) + { + fRc = RTFS_IS_SYMLINK(ObjInfo.Attr.fMode); + if (fRc) + { + rc = RTPathQueryInfoEx(pszSymlink, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK); + fRc = !RT_SUCCESS_NP(rc); + } + } + + LogFlow(("RTSymlinkIsDangling(%p={%s}): returns %RTbool\n", pszSymlink, pszSymlink, fRc)); + return fRc; +} + + +RTDECL(int) RTSymlinkCreate(const char *pszSymlink, const char *pszTarget, RTSYMLINKTYPE enmType, uint32_t fCreate) +{ + /* + * Validate the input. + */ + AssertReturn(enmType > RTSYMLINKTYPE_INVALID && enmType < RTSYMLINKTYPE_END, VERR_INVALID_PARAMETER); + AssertPtrReturn(pszSymlink, VERR_INVALID_POINTER); + AssertPtrReturn(pszTarget, VERR_INVALID_POINTER); + RT_NOREF_PV(fCreate); + + /* + * Resolve the API. + */ + typedef BOOLEAN (WINAPI *PFNCREATESYMBOLICLINKW)(LPCWSTR, LPCWSTR, DWORD); + static PFNCREATESYMBOLICLINKW s_pfnCreateSymbolicLinkW = NULL; + static bool s_fTried = FALSE; + if (!s_fTried) + { + PFNCREATESYMBOLICLINKW pfn = (PFNCREATESYMBOLICLINKW)GetProcAddress(g_hModKernel32, "CreateSymbolicLinkW"); + if (pfn) + s_pfnCreateSymbolicLinkW = pfn; + s_fTried = true; + } + if (!s_pfnCreateSymbolicLinkW) + { + LogFlow(("RTSymlinkCreate(%p={%s}, %p={%s}, %d, %#x): returns VERR_NOT_SUPPORTED - Windows API not found\n", + pszSymlink, pszSymlink, pszTarget, pszTarget, enmType, fCreate)); + return VERR_NOT_SUPPORTED; + } + + /* + * Convert the paths. + */ + PRTUTF16 pwszNativeSymlink; + int rc = RTPathWinFromUtf8(&pwszNativeSymlink, pszSymlink, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + PRTUTF16 pwszNativeTarget; + rc = RTPathWinFromUtf8(&pwszNativeTarget, pszTarget, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + /* The link target path must use backslashes to work reliably. */ + RTUTF16 wc; + PRTUTF16 pwsz = pwszNativeTarget; + while ((wc = *pwsz) != '\0') + { + if (wc == '/') + *pwsz = '\\'; + pwsz++; + } + + /* + * Massage the target path, determin the link type. + */ + size_t cchTarget = strlen(pszTarget); + size_t cchVolSpecTarget = rtPathVolumeSpecLen(pszTarget); +#if 0 /* looks like this isn't needed after all. That makes everything much simper :-) */ + if ( cchTarget > RT_MIN(cchVolSpecTarget, 1) + && RTPATH_IS_SLASH(pszTarget[cchTarget - 1])) + { + size_t cwcNativeTarget = RTUtf16Len(pwszNativeTarget); + size_t offFromEnd = 1; + while ( offFromEnd < cchTarget + && cchTarget - offFromEnd >= cchVolSpecTarget + && RTPATH_IS_SLASH(pszTarget[cchTarget - offFromEnd])) + { + Assert(offFromEnd < cwcNativeTarget); + pwszNativeTarget[cwcNativeTarget - offFromEnd] = 0; + offFromEnd++; + } + } +#endif + + if (enmType == RTSYMLINKTYPE_UNKNOWN) + { + if ( cchTarget > cchVolSpecTarget + && RTPATH_IS_SLASH(pszTarget[cchTarget - 1])) + enmType = RTSYMLINKTYPE_DIR; + else if (cchVolSpecTarget) + { + /** @todo this is subject to sharing violations. */ + DWORD dwAttr = GetFileAttributesW(pwszNativeTarget); + if ( dwAttr != INVALID_FILE_ATTRIBUTES + && (dwAttr & FILE_ATTRIBUTE_DIRECTORY)) + enmType = RTSYMLINKTYPE_DIR; + } + else + { + /** @todo Join the symlink directory with the target and + * look up the attributes on that. -lazy bird. */ + } + } + + /* + * Create the link. + */ + if (s_pfnCreateSymbolicLinkW(pwszNativeSymlink, pwszNativeTarget, enmType == RTSYMLINKTYPE_DIR)) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + + RTPathWinFree(pwszNativeTarget); + } + RTPathWinFree(pwszNativeSymlink); + } + + LogFlow(("RTSymlinkCreate(%p={%s}, %p={%s}, %d, %#x): returns %Rrc\n", pszSymlink, pszSymlink, pszTarget, pszTarget, enmType, fCreate, rc)); + return rc; +} + + +RTDECL(int) RTSymlinkDelete(const char *pszSymlink, uint32_t fDelete) +{ + RT_NOREF_PV(fDelete); + + /* + * Convert the path. + */ + PRTUTF16 pwszNativeSymlink; + int rc = RTPathWinFromUtf8(&pwszNativeSymlink, pszSymlink, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + /* + * We have to use different APIs depending on whether this is a + * directory or file link. This means we're subject to one more race + * than on posix at the moment. We could probably avoid this though, + * if we wanted to go talk with the native API layer below Win32... + */ + DWORD dwAttr = GetFileAttributesW(pwszNativeSymlink); + if (dwAttr != INVALID_FILE_ATTRIBUTES) + { + if (dwAttr & FILE_ATTRIBUTE_REPARSE_POINT) + { + BOOL fRc; + if (dwAttr & FILE_ATTRIBUTE_DIRECTORY) + fRc = RemoveDirectoryW(pwszNativeSymlink); + else + fRc = DeleteFileW(pwszNativeSymlink); + if (fRc) + rc = VINF_SUCCESS; + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + rc = VERR_NOT_SYMLINK; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + RTPathWinFree(pwszNativeSymlink); + } + + LogFlow(("RTSymlinkDelete(%p={%s}, %#x): returns %Rrc\n", pszSymlink, pszSymlink, fDelete, rc)); + return rc; +} + + +RTDECL(int) RTSymlinkRead(const char *pszSymlink, char *pszTarget, size_t cbTarget, uint32_t fRead) +{ + RT_NOREF_PV(fRead); + + char *pszMyTarget; + int rc = RTSymlinkReadA(pszSymlink, &pszMyTarget); + if (RT_SUCCESS(rc)) + { + rc = RTStrCopy(pszTarget, cbTarget, pszMyTarget); + RTStrFree(pszMyTarget); + } + LogFlow(("RTSymlinkRead(%p={%s}): returns %Rrc\n", pszSymlink, pszSymlink, rc)); + return rc; +} + + +RTDECL(int) RTSymlinkReadA(const char *pszSymlink, char **ppszTarget) +{ + AssertPtr(ppszTarget); + PRTUTF16 pwszNativeSymlink; + int rc = RTPathWinFromUtf8(&pwszNativeSymlink, pszSymlink, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + HANDLE hSymlink = CreateFileW(pwszNativeSymlink, + GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + NULL, + OPEN_EXISTING, + FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, + NULL); + if (hSymlink != INVALID_HANDLE_VALUE) + { + DWORD cbReturned = 0; + union + { + MY_REPARSE_DATA_BUFFER Buf; + uint8_t abBuf[16*_1K + sizeof(WCHAR)]; + } u; + if (DeviceIoControl(hSymlink, + MY_FSCTL_GET_REPARSE_POINT, + NULL /*pInBuffer */, + 0 /*cbInBuffer */, + &u.Buf, + sizeof(u) - sizeof(WCHAR), + &cbReturned, + NULL /*pOverlapped*/)) + { + if (u.Buf.ReparseTag == MY_IO_REPARSE_TAG_SYMLINK) + { + PWCHAR pwszTarget = &u.Buf.SymbolicLinkReparseBuffer.PathBuffer[0]; + pwszTarget += u.Buf.SymbolicLinkReparseBuffer.SubstituteNameOffset / 2; + pwszTarget[u.Buf.SymbolicLinkReparseBuffer.SubstituteNameLength / 2] = 0; + if ( !(u.Buf.SymbolicLinkReparseBuffer.Flags & MY_SYMLINK_FLAG_RELATIVE) + && pwszTarget[0] == '\\' + && pwszTarget[1] == '?' + && pwszTarget[2] == '?' + && pwszTarget[3] == '\\' + && pwszTarget[4] != 0 + ) + pwszTarget += 4; + rc = RTUtf16ToUtf8(pwszTarget, ppszTarget); + } + else + rc = VERR_NOT_SYMLINK; + } + else + rc = RTErrConvertFromWin32(GetLastError()); + CloseHandle(hSymlink); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + RTPathWinFree(pwszNativeSymlink); + } + + if (RT_SUCCESS(rc)) + LogFlow(("RTSymlinkReadA(%p={%s},%p): returns %Rrc *ppszTarget=%p:{%s}\n", pszSymlink, pszSymlink, ppszTarget, rc, *ppszTarget, *ppszTarget)); + else + LogFlow(("RTSymlinkReadA(%p={%s},%p): returns %Rrc\n", pszSymlink, pszSymlink, ppszTarget, rc)); + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/thread-win.cpp b/src/VBox/Runtime/r3/win/thread-win.cpp new file mode 100644 index 00000000..a01537e6 --- /dev/null +++ b/src/VBox/Runtime/r3/win/thread-win.cpp @@ -0,0 +1,421 @@ +/* $Id: thread-win.cpp $ */ +/** @file + * IPRT - Threads, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_THREAD +#include <iprt/nt/nt-and-windows.h> + +#include <errno.h> +#include <process.h> + +#include <iprt/thread.h> +#include "internal/iprt.h" + +#include <iprt/asm-amd64-x86.h> +#include <iprt/assert.h> +#include <iprt/cpuset.h> +#include <iprt/err.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include "internal/thread.h" +#include "internal-r3-win.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The TLS index allocated for storing the RTTHREADINT pointer. */ +static DWORD g_dwSelfTLS = TLS_OUT_OF_INDEXES; + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static unsigned __stdcall rtThreadNativeMain(void *pvArgs); +static void rtThreadWinTellDebuggerThreadName(uint32_t idThread, const char *pszName); + + +DECLHIDDEN(int) rtThreadNativeInit(void) +{ + g_dwSelfTLS = TlsAlloc(); + if (g_dwSelfTLS == TLS_OUT_OF_INDEXES) + return VERR_NO_TLS_FOR_SELF; + return VINF_SUCCESS; +} + + +DECLHIDDEN(void) rtThreadNativeReInitObtrusive(void) +{ + /* nothing to do here. */ +} + + +DECLHIDDEN(void) rtThreadNativeDetach(void) +{ + /* + * Deal with alien threads. + */ + PRTTHREADINT pThread = (PRTTHREADINT)TlsGetValue(g_dwSelfTLS); + if ( pThread + && (pThread->fIntFlags & RTTHREADINT_FLAGS_ALIEN)) + { + rtThreadTerminate(pThread, 0); + TlsSetValue(g_dwSelfTLS, NULL); + } +} + + +DECLHIDDEN(void) rtThreadNativeDestroy(PRTTHREADINT pThread) +{ + if (pThread == (PRTTHREADINT)TlsGetValue(g_dwSelfTLS)) + TlsSetValue(g_dwSelfTLS, NULL); + + if ((HANDLE)pThread->hThread != INVALID_HANDLE_VALUE) + { + CloseHandle((HANDLE)pThread->hThread); + pThread->hThread = (uintptr_t)INVALID_HANDLE_VALUE; + } +} + + +DECLHIDDEN(int) rtThreadNativeAdopt(PRTTHREADINT pThread) +{ + if (!TlsSetValue(g_dwSelfTLS, pThread)) + return VERR_FAILED_TO_SET_SELF_TLS; + if (IsDebuggerPresent()) + rtThreadWinTellDebuggerThreadName(GetCurrentThreadId(), pThread->szName); + return VINF_SUCCESS; +} + + +DECLHIDDEN(void) rtThreadNativeInformDebugger(PRTTHREADINT pThread) +{ + rtThreadWinTellDebuggerThreadName((uint32_t)(uintptr_t)pThread->Core.Key, pThread->szName); +} + + +/** + * Communicates the thread name to the debugger, if we're begin debugged that + * is. + * + * See http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx for debugger + * interface details. + * + * @param idThread The thread ID. UINT32_MAX for current thread. + * @param pszName The name. + */ +static void rtThreadWinTellDebuggerThreadName(uint32_t idThread, const char *pszName) +{ + struct + { + uint32_t uType; + const char *pszName; + uint32_t idThread; + uint32_t fFlags; + } Pkg = { 0x1000, pszName, idThread, 0 }; + __try + { + RaiseException(0x406d1388, 0, sizeof(Pkg)/sizeof(ULONG_PTR), (ULONG_PTR *)&Pkg); + } + __except(EXCEPTION_CONTINUE_EXECUTION) + { + + } +} + + +/** + * Bitch about dangling COM and OLE references, dispose of them + * afterwards so we don't end up deadlocked somewhere below + * OLE32!DllMain. + */ +static void rtThreadNativeUninitComAndOle(void) +{ +#if 1 /* experimental code */ + /* + * Read the counters. + */ + struct MySOleTlsData + { + void *apvReserved0[2]; /**< x86=0x00 W7/64=0x00 */ + DWORD adwReserved0[3]; /**< x86=0x08 W7/64=0x10 */ + void *apvReserved1[1]; /**< x86=0x14 W7/64=0x20 */ + DWORD cComInits; /**< x86=0x18 W7/64=0x28 */ + DWORD cOleInits; /**< x86=0x1c W7/64=0x2c */ + DWORD dwReserved1; /**< x86=0x20 W7/64=0x30 */ + void *apvReserved2[4]; /**< x86=0x24 W7/64=0x38 */ + DWORD adwReserved2[1]; /**< x86=0x34 W7/64=0x58 */ + void *pvCurrentCtx; /**< x86=0x38 W7/64=0x60 */ + IUnknown *pCallState; /**< x86=0x3c W7/64=0x68 */ + } *pOleTlsData = NULL; /* outside the try/except for debugging */ + DWORD cComInits = 0; + DWORD cOleInits = 0; + __try + { + void *pvTeb = NtCurrentTeb(); +# ifdef RT_ARCH_AMD64 + pOleTlsData = *(struct MySOleTlsData **)((uintptr_t)pvTeb + 0x1758); /*TEB.ReservedForOle*/ +# elif RT_ARCH_X86 + pOleTlsData = *(struct MySOleTlsData **)((uintptr_t)pvTeb + 0x0f80); /*TEB.ReservedForOle*/ +# else +# error "Port me!" +# endif + if (pOleTlsData) + { + cComInits = pOleTlsData->cComInits; + cOleInits = pOleTlsData->cOleInits; + } + } + __except(EXCEPTION_EXECUTE_HANDLER) + { + AssertFailedReturnVoid(); + } + + /* + * Assert sanity. If any of these breaks, the structure layout above is + * probably not correct any longer. + */ + AssertMsgReturnVoid(cComInits < 1000, ("%u (%#x)\n", cComInits, cComInits)); + AssertMsgReturnVoid(cOleInits < 1000, ("%u (%#x)\n", cOleInits, cOleInits)); + AssertMsgReturnVoid(cComInits >= cOleInits, ("cComInits=%#x cOleInits=%#x\n", cComInits, cOleInits)); + + /* + * Do the uninitializing. + */ + if (cComInits) + { + AssertMsgFailed(("cComInits=%u (%#x) cOleInits=%u (%#x) - dangling COM/OLE inits!\n", + cComInits, cComInits, cOleInits, cOleInits)); + + HMODULE hOle32 = GetModuleHandle("ole32.dll"); + AssertReturnVoid(hOle32 != NULL); + + typedef void (WINAPI *PFNOLEUNINITIALIZE)(void); + PFNOLEUNINITIALIZE pfnOleUninitialize = (PFNOLEUNINITIALIZE)GetProcAddress(hOle32, "OleUninitialize"); + AssertReturnVoid(pfnOleUninitialize); + + typedef void (WINAPI *PFNCOUNINITIALIZE)(void); + PFNCOUNINITIALIZE pfnCoUninitialize = (PFNCOUNINITIALIZE)GetProcAddress(hOle32, "CoUninitialize"); + AssertReturnVoid(pfnCoUninitialize); + + while (cOleInits-- > 0) + { + pfnOleUninitialize(); + cComInits--; + } + + while (cComInits-- > 0) + pfnCoUninitialize(); + } +#endif +} + + +/** + * Wrapper which unpacks the param stuff and calls thread function. + */ +static unsigned __stdcall rtThreadNativeMain(void *pvArgs) +{ + DWORD dwThreadId = GetCurrentThreadId(); + PRTTHREADINT pThread = (PRTTHREADINT)pvArgs; + + if (!TlsSetValue(g_dwSelfTLS, pThread)) + AssertReleaseMsgFailed(("failed to set self TLS. lasterr=%d thread '%s'\n", GetLastError(), pThread->szName)); + if (IsDebuggerPresent()) + rtThreadWinTellDebuggerThreadName(dwThreadId, &pThread->szName[0]); + + int rc = rtThreadMain(pThread, dwThreadId, &pThread->szName[0]); + + TlsSetValue(g_dwSelfTLS, NULL); + rtThreadNativeUninitComAndOle(); + _endthreadex(rc); + return rc; +} + + +DECLHIDDEN(int) rtThreadNativeCreate(PRTTHREADINT pThread, PRTNATIVETHREAD pNativeThread) +{ + AssertReturn(pThread->cbStack < ~(unsigned)0, VERR_INVALID_PARAMETER); + + /* + * Create the thread. + */ + pThread->hThread = (uintptr_t)INVALID_HANDLE_VALUE; + unsigned uThreadId = 0; + uintptr_t hThread = _beginthreadex(NULL, (unsigned)pThread->cbStack, rtThreadNativeMain, pThread, 0, &uThreadId); + if (hThread != 0 && hThread != ~0U) + { + pThread->hThread = hThread; + *pNativeThread = uThreadId; + return VINF_SUCCESS; + } + return RTErrConvertFromErrno(errno); +} + + +DECLHIDDEN(bool) rtThreadNativeIsAliveKludge(PRTTHREADINT pThread) +{ + PPEB_COMMON pPeb = NtCurrentPeb(); + if (!pPeb || !pPeb->Ldr || !pPeb->Ldr->ShutdownInProgress) + return true; + DWORD rcWait = WaitForSingleObject((HANDLE)pThread->hThread, 0); + return rcWait != WAIT_OBJECT_0; +} + + +RTDECL(RTTHREAD) RTThreadSelf(void) +{ + PRTTHREADINT pThread = (PRTTHREADINT)TlsGetValue(g_dwSelfTLS); + /** @todo import alien threads ? */ + return pThread; +} + + +#if 0 /* noone is using this ... */ +/** + * Returns the processor number the current thread was running on during this call + * + * @returns processor nr + */ +static int rtThreadGetCurrentProcessorNumber(void) +{ + static bool fInitialized = false; + static DWORD (WINAPI *pfnGetCurrentProcessorNumber)(void) = NULL; + if (!fInitialized) + { + HMODULE hmodKernel32 = GetModuleHandle("kernel32.dll"); + if (hmodKernel32) + pfnGetCurrentProcessorNumber = (DWORD (WINAPI*)(void))GetProcAddress(hmodKernel32, "GetCurrentProcessorNumber"); + fInitialized = true; + } + if (pfnGetCurrentProcessorNumber) + return pfnGetCurrentProcessorNumber(); + return -1; +} +#endif + + +RTR3DECL(int) RTThreadSetAffinity(PCRTCPUSET pCpuSet) +{ + DWORD_PTR fNewMask = pCpuSet ? RTCpuSetToU64(pCpuSet) : ~(DWORD_PTR)0; + DWORD_PTR dwRet = SetThreadAffinityMask(GetCurrentThread(), fNewMask); + if (dwRet) + return VINF_SUCCESS; + + int iLastError = GetLastError(); + AssertMsgFailed(("SetThreadAffinityMask failed, LastError=%d\n", iLastError)); + return RTErrConvertFromWin32(iLastError); +} + + +RTR3DECL(int) RTThreadGetAffinity(PRTCPUSET pCpuSet) +{ + /* + * Haven't found no query api, but the set api returns the old mask, so let's use that. + */ + DWORD_PTR dwIgnored; + DWORD_PTR dwProcAff = 0; + if (GetProcessAffinityMask(GetCurrentProcess(), &dwProcAff, &dwIgnored)) + { + HANDLE hThread = GetCurrentThread(); + DWORD_PTR dwRet = SetThreadAffinityMask(hThread, dwProcAff); + if (dwRet) + { + DWORD_PTR dwSet = SetThreadAffinityMask(hThread, dwRet); + Assert(dwSet == dwProcAff); NOREF(dwRet); + + RTCpuSetFromU64(pCpuSet, (uint64_t)dwSet); + return VINF_SUCCESS; + } + } + + int iLastError = GetLastError(); + AssertMsgFailed(("SetThreadAffinityMask or GetProcessAffinityMask failed, LastError=%d\n", iLastError)); + return RTErrConvertFromWin32(iLastError); +} + + +RTR3DECL(int) RTThreadGetExecutionTimeMilli(uint64_t *pKernelTime, uint64_t *pUserTime) +{ + uint64_t u64CreationTime, u64ExitTime, u64KernelTime, u64UserTime; + + if (GetThreadTimes(GetCurrentThread(), (LPFILETIME)&u64CreationTime, (LPFILETIME)&u64ExitTime, (LPFILETIME)&u64KernelTime, (LPFILETIME)&u64UserTime)) + { + *pKernelTime = u64KernelTime / 10000; /* GetThreadTimes returns time in 100 ns units */ + *pUserTime = u64UserTime / 10000; /* GetThreadTimes returns time in 100 ns units */ + return VINF_SUCCESS; + } + + int iLastError = GetLastError(); + AssertMsgFailed(("GetThreadTimes failed, LastError=%d\n", iLastError)); + return RTErrConvertFromWin32(iLastError); +} + + +/** + * Gets the native thread handle for a IPRT thread. + * + * @returns The thread handle. INVALID_HANDLE_VALUE on failure. + * @param hThread The IPRT thread handle. + * + * @note Windows only. + * @note Only valid after parent returns from the thread creation call. + */ +RTDECL(uintptr_t) RTThreadGetNativeHandle(RTTHREAD hThread) +{ + PRTTHREADINT pThread = rtThreadGet(hThread); + if (pThread) + { + uintptr_t hHandle = pThread->hThread; + rtThreadRelease(pThread); + return hHandle; + } + return (uintptr_t)INVALID_HANDLE_VALUE; +} +RT_EXPORT_SYMBOL(RTThreadGetNativeHandle); + + +RTDECL(int) RTThreadPoke(RTTHREAD hThread) +{ + AssertReturn(hThread != RTThreadSelf(), VERR_INVALID_PARAMETER); + if (g_pfnNtAlertThread) + { + PRTTHREADINT pThread = rtThreadGet(hThread); + AssertReturn(pThread, VERR_INVALID_HANDLE); + + NTSTATUS rcNt = g_pfnNtAlertThread((HANDLE)pThread->hThread); + + rtThreadRelease(pThread); + if (NT_SUCCESS(rcNt)) + return VINF_SUCCESS; + return RTErrConvertFromNtStatus(rcNt); + } + return VERR_NOT_IMPLEMENTED; +} + diff --git a/src/VBox/Runtime/r3/win/thread2-win.cpp b/src/VBox/Runtime/r3/win/thread2-win.cpp new file mode 100644 index 00000000..3290fc24 --- /dev/null +++ b/src/VBox/Runtime/r3/win/thread2-win.cpp @@ -0,0 +1,74 @@ +/* $Id: thread2-win.cpp $ */ +/** @file + * IPRT - Threads part 2, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_THREAD +#include <iprt/win/windows.h> + +#include <iprt/thread.h> +#include "internal/iprt.h" + +#include <iprt/asm-amd64-x86.h> +#include <iprt/errcore.h> +#include <iprt/log.h> +#include "internal/thread.h" + + +RTDECL(RTNATIVETHREAD) RTThreadNativeSelf(void) +{ + return (RTNATIVETHREAD)GetCurrentThreadId(); +} + + +RTR3DECL(int) RTThreadSleep(RTMSINTERVAL cMillies) +{ + LogFlow(("RTThreadSleep: cMillies=%d\n", cMillies)); + Sleep(cMillies); + LogFlow(("RTThreadSleep: returning %Rrc (cMillies=%d)\n", VINF_SUCCESS, cMillies)); + return VINF_SUCCESS; +} + + +RTR3DECL(int) RTThreadSleepNoLog(RTMSINTERVAL cMillies) +{ + Sleep(cMillies); + return VINF_SUCCESS; +} + + +RTR3DECL(bool) RTThreadYield(void) +{ + uint64_t u64TS = ASMReadTSC(); + Sleep(0); + u64TS = ASMReadTSC() - u64TS; + bool fRc = u64TS > 1500; + LogFlow(("RTThreadYield: returning %d (%llu ticks)\n", fRc, u64TS)); + return fRc; +} + diff --git a/src/VBox/Runtime/r3/win/time-win.cpp b/src/VBox/Runtime/r3/win/time-win.cpp new file mode 100644 index 00000000..54d1cb5f --- /dev/null +++ b/src/VBox/Runtime/r3/win/time-win.cpp @@ -0,0 +1,199 @@ +/* $Id: time-win.cpp $ */ +/** @file + * IPRT - Time, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_TIME +#include <iprt/nt/nt-and-windows.h> + +#include <iprt/time.h> +#include "internal/iprt.h" + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include "internal/time.h" +#include "internal-r3-win.h" + +/* + * Note! The selected time source be the exact same one as we use in kernel land! + */ +//#define USE_TICK_COUNT +//#define USE_PERFORMANCE_COUNTER +//# define USE_FILE_TIME +//#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64) +# define USE_INTERRUPT_TIME +//#else +//# define USE_TICK_COUNT +//#endif + + + +DECLINLINE(uint64_t) rtTimeGetSystemNanoTS(void) +{ +#if defined USE_TICK_COUNT + /* + * This would work if it didn't flip over every 49 (or so) days. + */ + return (uint64_t)GetTickCount() * RT_NS_1MS_64; + +#elif defined USE_PERFORMANCE_COUNTER + /* + * Slow and not derived from InterruptTime. + */ + static LARGE_INTEGER llFreq; + static unsigned uMult; + if (!llFreq.QuadPart) + { + if (!QueryPerformanceFrequency(&llFreq)) + return (uint64_t)GetTickCount() * RT_NS_1MS_64; + llFreq.QuadPart /= 1000; + uMult = 1000000; /* no math genius, but this seemed to help avoiding floating point. */ + } + + LARGE_INTEGER ll; + if (QueryPerformanceCounter(&ll)) + return (ll.QuadPart * uMult) / llFreq.QuadPart; + return (uint64_t)GetTickCount() * RT_NS_1MS_64; + +#elif defined USE_FILE_TIME + /* + * This is SystemTime not InterruptTime. + */ + uint64_t u64; /* manual say larger integer, should be safe to assume it's the same. */ + GetSystemTimeAsFileTime((LPFILETIME)&u64); + return u64 * 100; + +#elif defined USE_INTERRUPT_TIME + /* + * Use interrupt time if we can (not possible on NT 3.1). + * Note! We cannot entirely depend on g_enmWinVer here as we're likely to + * get called before IPRT is initialized. Ditto g_hModNtDll. + */ + static PFNRTLGETINTERRUPTTIMEPRECISE s_pfnRtlGetInterruptTimePrecise = NULL; + static int volatile s_iCanUseUserSharedData = -1; + int iCanUseUserSharedData = s_iCanUseUserSharedData; + if (iCanUseUserSharedData != -1) + { /* likely */ } + else + { + /* We may be called before g_enmWinVer has been initialized. */ + if (g_enmWinVer != kRTWinOSType_UNKNOWN) + iCanUseUserSharedData = g_enmWinVer > kRTWinOSType_NT310; + else + { + DWORD dwVer = GetVersion(); + iCanUseUserSharedData = (dwVer & 0xff) != 3 || ((dwVer >> 8) & 0xff) >= 50; + } + if (iCanUseUserSharedData != 0) + { + FARPROC pfn = GetProcAddress(g_hModNtDll ? g_hModNtDll : GetModuleHandleW(L"ntdll"), "RtlGetInterruptTimePrecise"); + if (pfn != NULL) + { + ASMAtomicWritePtr(&s_pfnRtlGetInterruptTimePrecise, pfn); + iCanUseUserSharedData = 42; + } + } + s_iCanUseUserSharedData = iCanUseUserSharedData; + } + + if (iCanUseUserSharedData != 0) + { + LARGE_INTEGER Time; + if (iCanUseUserSharedData == 42) + { + uint64_t iIgnored; + Time.QuadPart = s_pfnRtlGetInterruptTimePrecise(&iIgnored); + } + else + { + PKUSER_SHARED_DATA pUserSharedData = (PKUSER_SHARED_DATA)MM_SHARED_USER_DATA_VA; + do + { + Time.HighPart = pUserSharedData->InterruptTime.High1Time; + Time.LowPart = pUserSharedData->InterruptTime.LowPart; + } while (pUserSharedData->InterruptTime.High2Time != Time.HighPart); + } + + return (uint64_t)Time.QuadPart * 100; + } + + return (uint64_t)GetTickCount() * RT_NS_1MS_64; + +#else +# error "Must select a method bright guy!" +#endif +} + + +RTDECL(uint64_t) RTTimeSystemNanoTS(void) +{ + return rtTimeGetSystemNanoTS(); +} + + +RTDECL(uint64_t) RTTimeSystemMilliTS(void) +{ + return rtTimeGetSystemNanoTS() / RT_NS_1MS; +} + + +RTDECL(PRTTIMESPEC) RTTimeNow(PRTTIMESPEC pTime) +{ + uint64_t u64; + AssertCompile(sizeof(u64) == sizeof(FILETIME)); + GetSystemTimeAsFileTime((LPFILETIME)&u64); + return RTTimeSpecSetNtTime(pTime, u64); +} + + +RTDECL(PRTTIMESPEC) RTTimeLocalNow(PRTTIMESPEC pTime) +{ + uint64_t u64; + AssertCompile(sizeof(u64) == sizeof(FILETIME)); + GetSystemTimeAsFileTime((LPFILETIME)&u64); + uint64_t u64Local; + if (!FileTimeToLocalFileTime((FILETIME const *)&u64, (LPFILETIME)&u64Local)) + u64Local = u64; + return RTTimeSpecSetNtTime(pTime, u64Local); +} + + +RTDECL(int64_t) RTTimeLocalDeltaNano(void) +{ + /* + * UTC = local + Tzi.Bias; + * The bias is given in minutes. + */ + TIME_ZONE_INFORMATION Tzi; + Tzi.Bias = 0; + if (GetTimeZoneInformation(&Tzi) != TIME_ZONE_ID_INVALID) + return -(int64_t)Tzi.Bias * 60 * RT_NS_1SEC_64; + return 0; +} + diff --git a/src/VBox/Runtime/r3/win/time2-win.cpp b/src/VBox/Runtime/r3/win/time2-win.cpp new file mode 100644 index 00000000..511c6577 --- /dev/null +++ b/src/VBox/Runtime/r3/win/time2-win.cpp @@ -0,0 +1,154 @@ +/* $Id: time2-win.cpp $ */ +/** @file + * IPRT - Time, Windows. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_TIME +#include <iprt/win/windows.h> + +#include <iprt/time.h> +#include "internal/iprt.h" + +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include "internal/time.h" + +#include "internal-r3-win.h" + + +RTDECL(int) RTTimeSet(PCRTTIMESPEC pTime) +{ + FILETIME FileTime; + SYSTEMTIME SysTime; + if (FileTimeToSystemTime(RTTimeSpecGetNtFileTime(pTime, &FileTime), &SysTime)) + { + if (SetSystemTime(&SysTime)) + return VINF_SUCCESS; + } + return RTErrConvertFromWin32(GetLastError()); +} + + +RTDECL(PRTTIME) RTTimeLocalExplode(PRTTIME pTime, PCRTTIMESPEC pTimeSpec) +{ + RTTIMESPEC LocalTime; + if (g_pfnSystemTimeToTzSpecificLocalTime) + { + /* + * FileTimeToLocalFileTime does not do the right thing, so we'll have + * to convert to system time and SystemTimeToTzSpecificLocalTime instead. + * + * Note! FileTimeToSystemTime drops resoultion down to milliseconds, thus + * we have to do the offUTC calculation using milliseconds and adjust + * u32Nanosecons by sub milliseconds digits. + */ + SYSTEMTIME SystemTimeIn; + FILETIME FileTime; + if (FileTimeToSystemTime(RTTimeSpecGetNtFileTime(pTimeSpec, &FileTime), &SystemTimeIn)) + { + SYSTEMTIME SystemTimeOut; + if (g_pfnSystemTimeToTzSpecificLocalTime(NULL /* use current TZI */, &SystemTimeIn, &SystemTimeOut)) + { + if (SystemTimeToFileTime(&SystemTimeOut, &FileTime)) + { + RTTimeSpecSetNtFileTime(&LocalTime, &FileTime); + pTime = RTTimeExplode(pTime, &LocalTime); + if (pTime) + { + pTime->fFlags = (pTime->fFlags & ~RTTIME_FLAGS_TYPE_MASK) | RTTIME_FLAGS_TYPE_LOCAL; + pTime->offUTC = (RTTimeSpecGetMilli(&LocalTime) - RTTimeSpecGetMilli(pTimeSpec)) / RT_MS_1MIN; + pTime->u32Nanosecond += RTTimeSpecGetNano(pTimeSpec) % RT_NS_1MS; + } + return pTime; + } + } + } + } + + /* + * The fallback is to use the current offset. + * (A better fallback would be to use the offset of the same time of the year.) + */ + LocalTime = *pTimeSpec; + int64_t cNsUtcOffset = RTTimeLocalDeltaNano(); + RTTimeSpecAddNano(&LocalTime, cNsUtcOffset); + pTime = RTTimeExplode(pTime, &LocalTime); + if (pTime) + { + pTime->fFlags = (pTime->fFlags & ~RTTIME_FLAGS_TYPE_MASK) | RTTIME_FLAGS_TYPE_LOCAL; + pTime->offUTC = cNsUtcOffset / RT_NS_1MIN; + } + return pTime; +} + + +/** + * Gets the delta between UTC and local time at the given time. + * + * @code + * RTTIMESPEC LocalTime; + * RTTimeNow(&LocalTime); + * RTTimeSpecAddNano(&LocalTime, RTTimeLocalDeltaNanoFor(&LocalTime)); + * @endcode + * + * @param pTimeSpec The time spec giving the time to get the delta for. + * @returns Returns the nanosecond delta between UTC and local time. + */ +RTDECL(int64_t) RTTimeLocalDeltaNanoFor(PCRTTIMESPEC pTimeSpec) +{ + RTTIMESPEC LocalTime; + if (g_pfnSystemTimeToTzSpecificLocalTime) + { + /* + * FileTimeToLocalFileTime does not do the right thing, so we'll have + * to convert to system time and SystemTimeToTzSpecificLocalTime instead. + * + * Note! FileTimeToSystemTime drops resoultion down to milliseconds, thus + * we have to do the offUTC calculation using milliseconds and adjust + * u32Nanosecons by sub milliseconds digits. + */ + SYSTEMTIME SystemTimeIn; + FILETIME FileTime; + if (FileTimeToSystemTime(RTTimeSpecGetNtFileTime(pTimeSpec, &FileTime), &SystemTimeIn)) + { + SYSTEMTIME SystemTimeOut; + if (g_pfnSystemTimeToTzSpecificLocalTime(NULL /* use current TZI */, &SystemTimeIn, &SystemTimeOut)) + { + if (SystemTimeToFileTime(&SystemTimeOut, &FileTime)) + { + RTTimeSpecSetNtFileTime(&LocalTime, &FileTime); + + return (RTTimeSpecGetMilli(&LocalTime) - RTTimeSpecGetMilli(pTimeSpec)) * RT_NS_1MS; + } + } + } + } + + return RTTimeLocalDeltaNano(); +} + diff --git a/src/VBox/Runtime/r3/win/timer-win.cpp b/src/VBox/Runtime/r3/win/timer-win.cpp new file mode 100644 index 00000000..0bfb459b --- /dev/null +++ b/src/VBox/Runtime/r3/win/timer-win.cpp @@ -0,0 +1,460 @@ +/* $Id: timer-win.cpp $ */ +/** @file + * IPRT - Timer. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/* Which code to use is determined here... + * + * The default is to use wait on NT timers directly with no APC since this + * is supposed to give the shortest kernel code paths. + * + * The USE_APC variation will do as above except that an APC routine is + * handling the callback action. + * + * The USE_WINMM version will use the NT timer wrappers in WinMM which may + * result in some 0.1% better correctness in number of delivered ticks. However, + * this codepath have more overhead (it uses APC among other things), and I'm not + * quite sure if it's actually any more correct. + * + * The USE_CATCH_UP will play catch up when the timer lags behind. However this + * requires a monotonous time source. + * + * The default mode which we are using is using relative periods of time and thus + * will never suffer from errors in the time source. Neither will it try catch up + * missed ticks. This suits our current purposes best I'd say. + */ +#undef USE_APC +#undef USE_WINMM +#undef USE_CATCH_UP + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_TIMER +#define _WIN32_WINNT 0x0500 +#include <iprt/win/windows.h> + +#include <iprt/timer.h> +#ifdef USE_CATCH_UP +# include <iprt/time.h> +#endif +#include <iprt/alloc.h> +#include <iprt/assert.h> +#include <iprt/thread.h> +#include <iprt/log.h> +#include <iprt/asm.h> +#include <iprt/semaphore.h> +#include <iprt/err.h> +#include "internal/magics.h" + +RT_C_DECLS_BEGIN +/* from sysinternals. */ +NTSYSAPI LONG NTAPI NtSetTimerResolution(IN ULONG DesiredResolution, IN BOOLEAN SetResolution, OUT PULONG CurrentResolution); +NTSYSAPI LONG NTAPI NtQueryTimerResolution(OUT PULONG MaximumResolution, OUT PULONG MinimumResolution, OUT PULONG CurrentResolution); +RT_C_DECLS_END + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * The internal representation of a timer handle. + */ +typedef struct RTTIMER +{ + /** Magic. + * This is RTTIMER_MAGIC, but changes to something else before the timer + * is destroyed to indicate clearly that thread should exit. */ + volatile uint32_t u32Magic; + /** User argument. */ + void *pvUser; + /** Callback. */ + PFNRTTIMER pfnTimer; + /** The current tick. */ + uint64_t iTick; + /** The interval. */ + unsigned uMilliesInterval; +#ifdef USE_WINMM + /** Win32 timer id. */ + UINT TimerId; +#else + /** Time handle. */ + HANDLE hTimer; +# ifdef USE_APC + /** Handle to wait on. */ + HANDLE hevWait; +# endif + /** USE_CATCH_UP: ns time of the next tick. + * !USE_CATCH_UP: -uMilliesInterval * 10000 */ + LARGE_INTEGER llNext; + /** The thread handle of the timer thread. */ + RTTHREAD Thread; + /** The error/status of the timer. + * Initially -1, set to 0 when the timer have been successfully started, and + * to errno on failure in starting the timer. */ + volatile int iError; +#endif +} RTTIMER; + + + +#ifdef USE_WINMM +/** + * Win32 callback wrapper. + */ +static void CALLBACK rttimerCallback(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) +{ + PRTTIMER pTimer = (PRTTIMER)(void *)dwUser; + Assert(pTimer->TimerId == uTimerID); + pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pTimer->iTick); + NOREF(uMsg); NOREF(dw1); NOREF(dw2); NOREF(uTimerID); +} +#else /* !USE_WINMM */ + +#ifdef USE_APC +/** + * Async callback. + * + * @param lpArgToCompletionRoutine Pointer to our timer structure. + */ +VOID CALLBACK rttimerAPCProc(LPVOID lpArgToCompletionRoutine, DWORD dwTimerLowValue, DWORD dwTimerHighValue) +{ + PRTTIMER pTimer = (PRTTIMER)lpArgToCompletionRoutine; + + /* + * Check if we're begin destroyed. + */ + if (pTimer->u32Magic != RTTIMER_MAGIC) + return; + + /* + * Callback the handler. + */ + pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pTimer->iTick); + + /* + * Rearm the timer handler. + */ +#ifdef USE_CATCH_UP + pTimer->llNext.QuadPart += (int64_t)pTimer->uMilliesInterval * 10000; + LARGE_INTEGER ll; + ll.QuadPart = RTTimeNanoTS() - pTimer->llNext.QuadPart; + if (ll.QuadPart < -500000) + ll.QuadPart = ll.QuadPart / 100; + else + ll.QuadPart = -500000 / 100; /* need to catch up, do a minimum wait of 0.5ms. */ +#else + LARGE_INTEGER ll = pTimer->llNext; +#endif + BOOL frc = SetWaitableTimer(pTimer->hTimer, &ll, 0, rttimerAPCProc, pTimer, FALSE); + AssertMsg(frc || pTimer->u32Magic != RTTIMER_MAGIC, ("last error %d\n", GetLastError())); +} +#endif /* USE_APC */ + +/** + * Timer thread. + */ +static DECLCALLBACK(int) rttimerCallback(RTTHREAD Thread, void *pvArg) +{ + PRTTIMER pTimer = (PRTTIMER)(void *)pvArg; + Assert(pTimer->u32Magic == RTTIMER_MAGIC); + + /* + * Bounce our priority up quite a bit. + */ + if ( !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL) + /*&& !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST)*/) + { + int rc = GetLastError(); + AssertMsgFailed(("Failed to set priority class lasterror %d.\n", rc)); + pTimer->iError = RTErrConvertFromWin32(rc); + return rc; + } + + /* + * Start the waitable timer. + */ + +#ifdef USE_CATCH_UP + const int64_t NSInterval = (int64_t)pTimer->uMilliesInterval * 1000000; + pTimer->llNext.QuadPart = RTTimeNanoTS() + NSInterval; +#else + pTimer->llNext.QuadPart = -(int64_t)pTimer->uMilliesInterval * 10000; +#endif + LARGE_INTEGER ll; + ll.QuadPart = -(int64_t)pTimer->uMilliesInterval * 10000; +#ifdef USE_APC + if (!SetWaitableTimer(pTimer->hTimer, &ll, 0, rttimerAPCProc, pTimer, FALSE)) +#else + if (!SetWaitableTimer(pTimer->hTimer, &ll, 0, NULL, NULL, FALSE)) +#endif + { + int rc = GetLastError(); + AssertMsgFailed(("Failed to set timer, lasterr %d.\n", rc)); + pTimer->iError = RTErrConvertFromWin32(rc); + RTThreadUserSignal(Thread); + return rc; + } + + /* + * Wait for the semaphore to be posted. + */ + RTThreadUserSignal(Thread); + for (;pTimer->u32Magic == RTTIMER_MAGIC;) + { +#ifdef USE_APC + int rc = WaitForSingleObjectEx(pTimer->hevWait, INFINITE, TRUE); + if (rc != WAIT_OBJECT_0 && rc != WAIT_IO_COMPLETION) +#else + int rc = WaitForSingleObjectEx(pTimer->hTimer, INFINITE, FALSE); + if (pTimer->u32Magic != RTTIMER_MAGIC) + break; + if (rc == WAIT_OBJECT_0) + { + /* + * Callback the handler. + */ + pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pTimer->iTick); + + /* + * Rearm the timer handler. + */ +# ifdef USE_CATCH_UP + pTimer->llNext.QuadPart += NSInterval; + LARGE_INTEGER ll; + ll.QuadPart = RTTimeNanoTS() - pTimer->llNext.QuadPart; + if (ll.QuadPart < -500000) + ll.QuadPart = ll.QuadPart / 100; + else + ll.QuadPart = -500000 / 100; /* need to catch up, do a minimum wait of 0.5ms. */ +# else + LARGE_INTEGER ll = pTimer->llNext; +# endif + BOOL fRc = SetWaitableTimer(pTimer->hTimer, &ll, 0, NULL, NULL, FALSE); + AssertMsg(fRc || pTimer->u32Magic != RTTIMER_MAGIC, ("last error %d\n", GetLastError())); NOREF(fRc); + } + else +#endif + { + /* + * We failed during wait, so just signal the destructor and exit. + */ + int rc2 = GetLastError(); + RTThreadUserSignal(Thread); + AssertMsgFailed(("Wait on hTimer failed, rc=%d lasterr=%d\n", rc, rc2)); NOREF(rc2); + return -1; + } + } + + /* + * Exit. + */ + RTThreadUserSignal(Thread); + return 0; +} +#endif /* !USE_WINMM */ + + +RTDECL(int) RTTimerCreate(PRTTIMER *ppTimer, unsigned uMilliesInterval, PFNRTTIMER pfnTimer, void *pvUser) +{ +#ifndef USE_WINMM + /* + * On windows we'll have to set the timer resolution before + * we start the timer. + */ + ULONG ulMax = UINT32_MAX; + ULONG ulMin = UINT32_MAX; + ULONG ulCur = UINT32_MAX; + NtQueryTimerResolution(&ulMax, &ulMin, &ulCur); + Log(("NtQueryTimerResolution -> ulMax=%lu00ns ulMin=%lu00ns ulCur=%lu00ns\n", ulMax, ulMin, ulCur)); + if (ulCur > ulMin && ulCur > 10000 /* = 1ms */) + { + if (NtSetTimerResolution(10000, TRUE, &ulCur) >= 0) + Log(("Changed timer resolution to 1ms.\n")); + else if (NtSetTimerResolution(20000, TRUE, &ulCur) >= 0) + Log(("Changed timer resolution to 2ms.\n")); + else if (NtSetTimerResolution(40000, TRUE, &ulCur) >= 0) + Log(("Changed timer resolution to 4ms.\n")); + else if (ulMin <= 50000 && NtSetTimerResolution(ulMin, TRUE, &ulCur) >= 0) + Log(("Changed timer resolution to %lu *100ns.\n", ulMin)); + else + { + AssertMsgFailed(("Failed to configure timer resolution!\n")); + return VERR_INTERNAL_ERROR; + } + } +#endif /* !USE_WINN */ + + /* + * Create new timer. + */ + int rc = VERR_IPE_UNINITIALIZED_STATUS; + PRTTIMER pTimer = (PRTTIMER)RTMemAlloc(sizeof(*pTimer)); + if (pTimer) + { + pTimer->u32Magic = RTTIMER_MAGIC; + pTimer->pvUser = pvUser; + pTimer->pfnTimer = pfnTimer; + pTimer->iTick = 0; + pTimer->uMilliesInterval = uMilliesInterval; +#ifdef USE_WINMM + /* sync kill doesn't work. */ + pTimer->TimerId = timeSetEvent(uMilliesInterval, 0, rttimerCallback, (DWORD_PTR)pTimer, TIME_PERIODIC | TIME_CALLBACK_FUNCTION); + if (pTimer->TimerId) + { + ULONG ulMax = UINT32_MAX; + ULONG ulMin = UINT32_MAX; + ULONG ulCur = UINT32_MAX; + NtQueryTimerResolution(&ulMax, &ulMin, &ulCur); + Log(("NtQueryTimerResolution -> ulMax=%lu00ns ulMin=%lu00ns ulCur=%lu00ns\n", ulMax, ulMin, ulCur)); + + *ppTimer = pTimer; + return VINF_SUCCESS; + } + rc = VERR_INVALID_PARAMETER; + +#else /* !USE_WINMM */ + + /* + * Create Win32 event semaphore. + */ + pTimer->iError = 0; + pTimer->hTimer = CreateWaitableTimer(NULL, TRUE, NULL); + if (pTimer->hTimer) + { +#ifdef USE_APC + /* + * Create wait semaphore. + */ + pTimer->hevWait = CreateEvent(NULL, FALSE, FALSE, NULL); + if (pTimer->hevWait) +#endif + { + /* + * Kick off the timer thread. + */ + rc = RTThreadCreate(&pTimer->Thread, rttimerCallback, pTimer, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "Timer"); + if (RT_SUCCESS(rc)) + { + /* + * Wait for the timer to successfully create the timer + * If we don't get a response in 10 secs, then we assume we're screwed. + */ + rc = RTThreadUserWait(pTimer->Thread, 10000); + if (RT_SUCCESS(rc)) + { + rc = pTimer->iError; + if (RT_SUCCESS(rc)) + { + *ppTimer = pTimer; + return VINF_SUCCESS; + } + } + ASMAtomicXchgU32(&pTimer->u32Magic, RTTIMER_MAGIC + 1); + RTThreadWait(pTimer->Thread, 250, NULL); + CancelWaitableTimer(pTimer->hTimer); + } +#ifdef USE_APC + CloseHandle(pTimer->hevWait); +#endif + } + CloseHandle(pTimer->hTimer); + } +#endif /* !USE_WINMM */ + + AssertMsgFailed(("Failed to create timer uMilliesInterval=%d. rc=%d\n", uMilliesInterval, rc)); + RTMemFree(pTimer); + } + else + rc = VERR_NO_MEMORY; + return rc; +} + + +RTR3DECL(int) RTTimerDestroy(PRTTIMER pTimer) +{ + /* NULL is ok. */ + if (!pTimer) + return VINF_SUCCESS; + + /* + * Validate handle first. + */ + int rc; + if ( VALID_PTR(pTimer) + && pTimer->u32Magic == RTTIMER_MAGIC) + { +#ifdef USE_WINMM + /* + * Kill the timer and exit. + */ + rc = timeKillEvent(pTimer->TimerId); + AssertMsg(rc == TIMERR_NOERROR, ("timeKillEvent -> %d\n", rc)); + ASMAtomicXchgU32(&pTimer->u32Magic, RTTIMER_MAGIC + 1); + RTThreadSleep(1); + +#else /* !USE_WINMM */ + + /* + * Signal that we want the thread to exit. + */ + ASMAtomicXchgU32(&pTimer->u32Magic, RTTIMER_MAGIC + 1); +#ifdef USE_APC + SetEvent(pTimer->hevWait); + CloseHandle(pTimer->hevWait); + rc = CancelWaitableTimer(pTimer->hTimer); + AssertMsg(rc, ("CancelWaitableTimer lasterr=%d\n", GetLastError())); +#else + LARGE_INTEGER ll = {0}; + ll.LowPart = 100; + rc = SetWaitableTimer(pTimer->hTimer, &ll, 0, NULL, NULL, FALSE); + AssertMsg(rc, ("CancelWaitableTimer lasterr=%d\n", GetLastError())); +#endif + + /* + * Wait for the thread to exit. + * And if it don't wanna exit, we'll get kill it. + */ + rc = RTThreadWait(pTimer->Thread, 1000, NULL); + if (RT_FAILURE(rc)) + TerminateThread((HANDLE)RTThreadGetNative(pTimer->Thread), UINT32_MAX); + + /* + * Free resource. + */ + rc = CloseHandle(pTimer->hTimer); + AssertMsg(rc, ("CloseHandle lasterr=%d\n", GetLastError())); + +#endif /* !USE_WINMM */ + RTMemFree(pTimer); + return rc; + } + + rc = VERR_INVALID_HANDLE; + AssertMsgFailed(("Failed to destroy timer %p. rc=%d\n", pTimer, rc)); + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/tls-win.cpp b/src/VBox/Runtime/r3/win/tls-win.cpp new file mode 100644 index 00000000..f50c6073 --- /dev/null +++ b/src/VBox/Runtime/r3/win/tls-win.cpp @@ -0,0 +1,104 @@ +/* $Id: tls-win.cpp $ */ +/** @file + * IPRT - Thread Local Storage (TLS), Win32. + */ + +/* + * Copyright (C) 2008-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_THREAD +#include <iprt/win/windows.h> + +#include <iprt/thread.h> +#include <iprt/log.h> +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include "internal/thread.h" + + +AssertCompile(sizeof(RTTLS) >= sizeof(DWORD)); + + +RTR3DECL(RTTLS) RTTlsAlloc(void) +{ + DWORD iTls = TlsAlloc(); + return iTls != TLS_OUT_OF_INDEXES ? (RTTLS)iTls : NIL_RTTLS; +} + + +RTR3DECL(int) RTTlsAllocEx(PRTTLS piTls, PFNRTTLSDTOR pfnDestructor) +{ + AssertReturn(!pfnDestructor, VERR_NOT_SUPPORTED); + DWORD iTls = TlsAlloc(); + if (iTls != TLS_OUT_OF_INDEXES) + { + Assert((RTTLS)iTls != NIL_RTTLS); + *piTls = (RTTLS)iTls; + Assert((DWORD)*piTls == iTls); + return VINF_SUCCESS; + } + + return VERR_NO_MEMORY; +} + + +RTR3DECL(int) RTTlsFree(RTTLS iTls) +{ + if (iTls == NIL_RTTLS) + return VINF_SUCCESS; + if (TlsFree((DWORD)iTls)) + return VINF_SUCCESS; + return RTErrConvertFromWin32(GetLastError()); +} + + +RTR3DECL(void *) RTTlsGet(RTTLS iTls) +{ + return TlsGetValue((DWORD)iTls); +} + + +RTR3DECL(int) RTTlsGetEx(RTTLS iTls, void **ppvValue) +{ + void *pv = TlsGetValue((DWORD)iTls); + if (pv) + { + *ppvValue = pv; + return VINF_SUCCESS; + } + + /* TlsGetValue always updates last error */ + *ppvValue = NULL; + return RTErrConvertFromWin32(GetLastError()); +} + + +RTR3DECL(int) RTTlsSet(RTTLS iTls, void *pvValue) +{ + if (TlsSetValue((DWORD)iTls, pvValue)) + return VINF_SUCCESS; + return RTErrConvertFromWin32(GetLastError()); +} + diff --git a/src/VBox/Runtime/r3/win/utf16locale-win.cpp b/src/VBox/Runtime/r3/win/utf16locale-win.cpp new file mode 100644 index 00000000..f11cfb18 --- /dev/null +++ b/src/VBox/Runtime/r3/win/utf16locale-win.cpp @@ -0,0 +1,48 @@ +/* $Id: utf16locale-win.cpp $ */ +/** @file + * IPRT - UTF-16 Locale Specific Manipulation, Win32. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_UTF16 +#include <iprt/win/windows.h> + +#include <iprt/utf16.h> + + +RTDECL(int) RTUtf16LocaleICmp(PCRTUTF16 pusz1, PCRTUTF16 pusz2) +{ + if (pusz1 == pusz2) + return 0; + if (pusz1 == NULL) + return -1; + if (pusz2 == NULL) + return 1; + + return CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE, pusz1, -1, pusz2, -1) - 2; +} + diff --git a/src/VBox/Runtime/r3/win/utf8-win.cpp b/src/VBox/Runtime/r3/win/utf8-win.cpp new file mode 100644 index 00000000..097c20f2 --- /dev/null +++ b/src/VBox/Runtime/r3/win/utf8-win.cpp @@ -0,0 +1,172 @@ +/* $Id: utf8-win.cpp $ */ +/** @file + * IPRT - UTF8 helpers. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_UTF8 +#include <iprt/win/windows.h> + +#include <iprt/string.h> +#include <iprt/alloc.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/utf16.h> + + +RTR3DECL(int) RTStrUtf8ToCurrentCPTag(char **ppszString, const char *pszString, const char *pszTag) +{ + Assert(ppszString); + Assert(pszString); + + /* + * Check for zero length input string. + */ + if (!*pszString) + { + *ppszString = (char *)RTMemTmpAllocZTag(sizeof(char), pszTag); + if (*ppszString) + return VINF_SUCCESS; + return VERR_NO_TMP_MEMORY; + } + + *ppszString = NULL; + + /* + * Convert to wide char first. + */ + PRTUTF16 pwszString = NULL; + int rc = RTStrToUtf16(pszString, &pwszString); + if (RT_FAILURE(rc)) + return rc; + + /* + * First calc result string length. + */ + int cbResult = WideCharToMultiByte(CP_ACP, 0, pwszString, -1, NULL, 0, NULL, NULL); + if (cbResult > 0) + { + /* + * Alloc space for result buffer. + */ + LPSTR lpString = (LPSTR)RTMemTmpAllocTag(cbResult, pszTag); + if (lpString) + { + /* + * Do the translation. + */ + if (WideCharToMultiByte(CP_ACP, 0, pwszString, -1, lpString, cbResult, NULL, NULL) > 0) + { + /* ok */ + *ppszString = lpString; + RTMemTmpFree(pwszString); + return VINF_SUCCESS; + } + + /* translation error */ + int iLastErr = GetLastError(); + AssertMsgFailed(("Unicode to ACP translation failed. lasterr=%d\n", iLastErr)); + rc = RTErrConvertFromWin32(iLastErr); + } + else + rc = VERR_NO_TMP_MEMORY; + RTMemTmpFree(lpString); + } + else + { + /* translation error */ + int iLastErr = GetLastError(); + AssertMsgFailed(("Unicode to ACP translation failed lasterr=%d\n", iLastErr)); + rc = RTErrConvertFromWin32(iLastErr); + } + RTMemTmpFree(pwszString); + return rc; +} + + +RTR3DECL(int) RTStrCurrentCPToUtf8Tag(char **ppszString, const char *pszString, const char *pszTag) +{ + Assert(ppszString); + Assert(pszString); + *ppszString = NULL; + + /** @todo is there a quicker way? Currently: ACP -> UTF-16 -> UTF-8 */ + + size_t cch = strlen(pszString); + if (cch <= 0) + { + /* zero length string passed. */ + *ppszString = (char *)RTMemTmpAllocZTag(sizeof(char), pszTag); + if (*ppszString) + return VINF_SUCCESS; + return VERR_NO_TMP_MEMORY; + } + + /* + * First calc result string length. + */ + int rc; + int cwc = MultiByteToWideChar(CP_ACP, 0, pszString, -1, NULL, 0); + if (cwc > 0) + { + /* + * Alloc space for result buffer. + */ + PRTUTF16 pwszString = (PRTUTF16)RTMemTmpAlloc(cwc * sizeof(RTUTF16)); + if (pwszString) + { + /* + * Do the translation. + */ + if (MultiByteToWideChar(CP_ACP, 0, pszString, -1, pwszString, cwc) > 0) + { + /* + * Now we got UTF-16, convert it to UTF-8 + */ + rc = RTUtf16ToUtf8(pwszString, ppszString); + RTMemTmpFree(pwszString); + return rc; + } + RTMemTmpFree(pwszString); + /* translation error */ + int iLastErr = GetLastError(); + AssertMsgFailed(("ACP to Unicode translation failed. lasterr=%d\n", iLastErr)); + rc = RTErrConvertFromWin32(iLastErr); + } + else + rc = VERR_NO_TMP_MEMORY; + } + else + { + /* translation error */ + int iLastErr = GetLastError(); + AssertMsgFailed(("Unicode to ACP translation failed lasterr=%d\n", iLastErr)); + rc = RTErrConvertFromWin32(iLastErr); + } + return rc; +} + diff --git a/src/VBox/Runtime/r3/win/uuid-win.cpp b/src/VBox/Runtime/r3/win/uuid-win.cpp new file mode 100644 index 00000000..65528fee --- /dev/null +++ b/src/VBox/Runtime/r3/win/uuid-win.cpp @@ -0,0 +1,185 @@ +/* $Id: uuid-win.cpp $ */ +/** @file + * IPRT - UUID, Windows implementation. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_UUID +#include <iprt/win/windows.h> + +#include <iprt/uuid.h> +#include <iprt/assert.h> +#include <iprt/string.h> +#include <iprt/errcore.h> + + +RTDECL(int) RTUuidClear(PRTUUID pUuid) +{ + /* check params */ + AssertPtrReturn(pUuid, VERR_INVALID_POINTER); + + return RTErrConvertFromWin32(UuidCreateNil((UUID *)pUuid)); +} + + +RTDECL(bool) RTUuidIsNull(PCRTUUID pUuid) +{ + /* check params */ + AssertPtrReturn(pUuid, true); + + RPC_STATUS status; + return !!UuidIsNil((UUID *)pUuid, &status); +} + + +RTDECL(int) RTUuidCompare(PCRTUUID pUuid1, PCRTUUID pUuid2) +{ + /* + * Special cases. + */ + if (pUuid1 == pUuid2) + return 0; + if (!pUuid1) + return RTUuidIsNull(pUuid2) ? 0 : -1; + if (!pUuid2) + return RTUuidIsNull(pUuid1) ? 0 : 1; + AssertPtrReturn(pUuid1, -1); + AssertPtrReturn(pUuid2, 1); + + /* + * Hand the rest to the Windows API. + */ + RPC_STATUS status; + return UuidCompare((UUID *)pUuid1, (UUID *)pUuid2, &status); +} + + +RTDECL(int) RTUuidCompareStr(PCRTUUID pUuid1, const char *pszString2) +{ + /* check params */ + AssertPtrReturn(pUuid1, -1); + AssertPtrReturn(pszString2, 1); + + /* + * Try convert the string to a UUID and then compare the two. + */ + RTUUID Uuid2; + int rc = RTUuidFromStr(&Uuid2, pszString2); + AssertRCReturn(rc, 1); + + return RTUuidCompare(pUuid1, &Uuid2); +} + + +RTDECL(int) RTUuidCompare2Strs(const char *pszString1, const char *pszString2) +{ + RTUUID Uuid1; + RTUUID Uuid2; + int rc; + + /* check params */ + AssertPtrReturn(pszString1, -1); + AssertPtrReturn(pszString2, 1); + + /* + * Try convert the strings to UUIDs and then compare them. + */ + rc = RTUuidFromStr(&Uuid1, pszString1); + AssertRCReturn(rc, -1); + + rc = RTUuidFromStr(&Uuid2, pszString2); + AssertRCReturn(rc, 1); + + return RTUuidCompare(&Uuid1, &Uuid2); +} + + +RTDECL(int) RTUuidToStr(PCRTUUID pUuid, char *pszString, size_t cchString) +{ + /* check params */ + AssertPtrReturn(pUuid, VERR_INVALID_POINTER); + AssertPtrReturn(pszString, VERR_INVALID_POINTER); + AssertReturn(cchString >= RTUUID_STR_LENGTH, VERR_INVALID_PARAMETER); + + /* + * Try convert it. + * + * The API allocates a new string buffer for us, so we can do our own + * buffer overflow handling. + */ + RPC_STATUS Status; + unsigned char *pszTmpStr = NULL; +#ifdef RPC_UNICODE_SUPPORTED + /* always use ASCII version! */ + Status = UuidToStringA((UUID *)pUuid, &pszTmpStr); +#else + Status = UuidToString((UUID *)pUuid, &pszTmpStr); +#endif + if (Status != RPC_S_OK) + return RTErrConvertFromWin32(Status); + + /* copy it. */ + int rc = VINF_SUCCESS; + size_t cchTmpStr = strlen((char *)pszTmpStr); + if (cchTmpStr < cchString) + memcpy(pszString, pszTmpStr, cchTmpStr + 1); + else + { + AssertFailed(); + rc = ERROR_BUFFER_OVERFLOW; + } + + /* free buffer */ +#ifdef RPC_UNICODE_SUPPORTED + /* always use ASCII version! */ + RpcStringFreeA(&pszTmpStr); +#else + RpcStringFree(&pszTmpStr); +#endif + + /* all done */ + return rc; +} + + +RTDECL(int) RTUuidFromStr(PRTUUID pUuid, const char *pszString) +{ + /* check params */ + AssertPtrReturn(pUuid, VERR_INVALID_POINTER); + AssertPtrReturn(pszString, VERR_INVALID_POINTER); + + RPC_STATUS rc; +#ifdef RPC_UNICODE_SUPPORTED + /* always use ASCII version! */ + rc = UuidFromStringA((unsigned char *)pszString, (UUID *)pUuid); +#else + rc = UuidFromString((unsigned char *)pszString, (UUID *)pUuid); +#endif + + return RTErrConvertFromWin32(rc); +} + diff --git a/src/VBox/Runtime/r3/win/vcc100-fakes.h b/src/VBox/Runtime/r3/win/vcc100-fakes.h new file mode 100644 index 00000000..be9a8f2d --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-fakes.h @@ -0,0 +1,131 @@ +/* $Id: vcc100-fakes.h $ */ +/** @file + * IPRT - Common macros for the Visual C++ 2010+ CRT import fakes. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef IPRT_INCLUDED_SRC_r3_win_vcc100_fakes_h +#define IPRT_INCLUDED_SRC_r3_win_vcc100_fakes_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#ifdef RT_STRICT +# include <stdio.h> /* _snprintf */ +#endif + + +/** @def MY_ASSERT + * We use a special assertion macro here to avoid dragging in IPRT bits in + * places which cannot handle it (direct GA 3D bits or something like that). + * + * Turns out snprintf is off limits too. Needs Locale info and runs out of + * stack + */ +#ifdef RT_STRICT +# if 1 +# define MY_ASSERT(a_Expr, g_szMsg) \ + do { \ + if ((a_Expr)) \ + { /*likely*/ } \ + else \ + { \ + OutputDebugStringA("Assertion failed on line " RT_XSTR(__LINE__) ": " RT_XSTR(a_Expr) "\n"); \ + OutputDebugStringA("Assertion message: " g_szMsg "\n"); \ + RT_BREAKPOINT(); \ + } \ + } while (0) +# else +# define MY_ASSERT(a_Expr, ...) \ + do { \ + if ((a_Expr)) \ + { /*likely*/ } \ + else \ + { \ + char szTmp[256]; \ + _snprintf(szTmp, sizeof(szTmp), "Assertion failed on line %u in '%s': %s", __LINE__, __PRETTY_FUNCTION__, #a_Expr); \ + OutputDebugStringA(szTmp); \ + _snprintf(szTmp, sizeof(szTmp), __VA_ARGS__); \ + OutputDebugStringA(szTmp); \ + RT_BREAKPOINT(); \ + } \ + } while (0) +# endif +#else +# define MY_ASSERT(a_Expr, ...) do { } while (0) +#endif + + +/** Dynamically resolves an NTDLL API we need. */ +#define RESOLVE_NTDLL_API(ApiNm) \ + static bool volatile s_fInitialized##ApiNm = false; \ + static decltype(ApiNm) *s_pfn##ApiNm = NULL; \ + decltype(ApiNm) *pfn##ApiNm; \ + if (s_fInitialized##ApiNm) \ + pfn##ApiNm = s_pfn##ApiNm; \ + else \ + { \ + pfn##ApiNm = (decltype(pfn##ApiNm))GetProcAddress(GetModuleHandleW(L"ntdll"), #ApiNm); \ + s_pfn##ApiNm = pfn##ApiNm; \ + s_fInitialized##ApiNm = true; \ + } do {} while (0) + + +/** Declare a kernel32 API. + * @note We are not exporting them as that causes duplicate symbol troubles in + * the OpenGL bits. */ +#define DECL_KERNEL32(a_Type) extern "C" a_Type WINAPI + + +/** Ignore comments. */ +#define COMMENT(a_Text) + +/** Used for MAKE_IMPORT_ENTRY when declaring external g_pfnXxxx variables. */ +#define DECLARE_FUNCTION_POINTER(a_Name, a_cb) extern "C" decltype(a_Name) *RT_CONCAT(g_pfn, a_Name); + +/** Used in the InitFakes method to decl are uCurVersion used by assertion. */ +#ifdef RT_STRICT +# define CURRENT_VERSION_VARIABLE() \ + unsigned uCurVersion = GetVersion(); \ + uCurVersion = ((uCurVersion & 0xff) << 8) | ((uCurVersion >> 8) & 0xff) +#else +# define CURRENT_VERSION_VARIABLE() (void)0 +#endif + + +/** Used for MAKE_IMPORT_ENTRY when resolving an import. */ +#define RESOLVE_IMPORT(a_uMajorVer, a_uMinorVer, a_Name, a_cb) \ + do { \ + FARPROC pfnApi = GetProcAddress(hmod, #a_Name); \ + if (pfnApi) \ + RT_CONCAT(g_pfn, a_Name) = (decltype(a_Name) *)pfnApi; \ + else \ + { \ + MY_ASSERT(uCurVersion < (((a_uMajorVer) << 8) | (a_uMinorVer)), #a_Name); \ + RT_CONCAT(g_pfn, a_Name) = RT_CONCAT(Fake_,a_Name); \ + } \ + } while (0); + + +#endif /* !IPRT_INCLUDED_SRC_r3_win_vcc100_fakes_h */ + diff --git a/src/VBox/Runtime/r3/win/vcc100-fakes.mac b/src/VBox/Runtime/r3/win/vcc100-fakes.mac new file mode 100644 index 00000000..f54a832f --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-fakes.mac @@ -0,0 +1,66 @@ +; $Id: vcc100-fakes.mac $ +;; @file +; IPRT - Common macros for the Visual C++ 2010+ CRT import fakes. +; + +; +; Copyright (C) 2006-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + + +%include "iprt/asmdefs.mac" + +%ifndef RT_ARCH_X86 + %error "This is x86 only code. +%endif + + +;; +; Fakes an API import table entry. +; +; @param 1 The function name +; @param 2 Number of bytes of parameters for x86. +%macro MAKE_IMPORT_ENTRY_INTERNAL 2 + +BEGINDATA +extern _FakeResolve_ %+ FAKE_MODULE_NAME + +extern _Fake_ %+ %1 %+ @ %+ %2 +global __imp__ %+ %1 %+ @ %+ %2 ; The import address table (IAT) entry name. +__imp__ %+ %1 %+ @ %+ %2: +global _g_pfn %+ %1 ; C accessible label. +_g_pfn %+ %1: + dd FakeLazyInit_ %+ %1 + +BEGINCODE +FakeLazyInit_ %+ %1: + pusha + call _FakeResolve_ %+ FAKE_MODULE_NAME + popa +global _ %+ %1 %+ @ %+ %2 ; The imported function stub. +_ %+ %1 %+ @ %+ %2: + jmp [_g_pfn %+ %1] + + +%endmacro + +%define MAKE_IMPORT_ENTRY(a_uMajorVer, a_uMinorVer, a_Name, a_cbParams) MAKE_IMPORT_ENTRY_INTERNAL a_Name, a_cbParams +%define COMMENT(a_Text) + diff --git a/src/VBox/Runtime/r3/win/vcc100-kernel32-fakes.cpp b/src/VBox/Runtime/r3/win/vcc100-kernel32-fakes.cpp new file mode 100644 index 00000000..97e17545 --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-kernel32-fakes.cpp @@ -0,0 +1,620 @@ +/* $Id: vcc100-kernel32-fakes.cpp $ */ +/** @file + * IPRT - Tricks to make the Visual C++ 2010 CRT work on NT4, W2K and XP. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/cdefs.h> +#include <iprt/types.h> +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/string.h> +#ifdef DEBUG +# include <stdio.h> /* _snprintf */ +#endif + +#ifndef RT_ARCH_X86 +# error "This code is X86 only" +#endif + +#include <iprt/nt/nt-and-windows.h> + +#include "vcc100-fakes.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +#ifndef HEAP_STANDARD +# define HEAP_STANDARD 0 +#endif + + +/** Declare a kernel32 API. + * @note We are not exporting them as that causes duplicate symbol troubles in + * the OpenGL bits. */ +#define DECL_KERNEL32(a_Type) extern "C" a_Type WINAPI + + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +static volatile bool g_fInitialized = false; +#define MAKE_IMPORT_ENTRY(a_uMajorVer, a_uMinorVer, a_Name, a_cb) DECLARE_FUNCTION_POINTER(a_Name, a_cb) +#include "vcc100-kernel32-fakes.h" + + + +DECL_KERNEL32(PVOID) Fake_DecodePointer(PVOID pvEncoded) +{ + return pvEncoded; +} + + +DECL_KERNEL32(PVOID) Fake_EncodePointer(PVOID pvNative) +{ + return pvNative; +} + + +DECL_KERNEL32(BOOL) Fake_InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION pCritSect, DWORD cSpin) +{ + RT_NOREF(cSpin); + InitializeCriticalSection(pCritSect); + return TRUE; +} + + +DECL_KERNEL32(BOOL) Fake_HeapSetInformation(HANDLE hHeap, HEAP_INFORMATION_CLASS enmInfoClass, PVOID pvBuf, SIZE_T cbBuf) +{ + RT_NOREF(hHeap); + if (enmInfoClass == HeapCompatibilityInformation) + { + if ( cbBuf != sizeof(ULONG) + || !pvBuf + || *(PULONG)pvBuf == HEAP_STANDARD + ) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + return TRUE; + } + + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; +} + + +DECL_KERNEL32(BOOL) Fake_HeapQueryInformation(HANDLE hHeap, HEAP_INFORMATION_CLASS enmInfoClass, + PVOID pvBuf, SIZE_T cbBuf, PSIZE_T pcbRet) +{ + RT_NOREF(hHeap); + if (enmInfoClass == HeapCompatibilityInformation) + { + *pcbRet = sizeof(ULONG); + if (cbBuf < sizeof(ULONG) || !pvBuf) + { + SetLastError(ERROR_INSUFFICIENT_BUFFER); + return FALSE; + } + *(PULONG)pvBuf = HEAP_STANDARD; + return TRUE; + } + + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; +} + + +/* These are used by INTEL\mt_obj\Timer.obj: */ + +DECL_KERNEL32(HANDLE) Fake_CreateTimerQueue(void) +{ + SetLastError(ERROR_NOT_SUPPORTED); + return NULL; +} + +DECL_KERNEL32(BOOL) Fake_CreateTimerQueueTimer(PHANDLE phTimer, HANDLE hTimerQueue, WAITORTIMERCALLBACK pfnCallback, PVOID pvUser, + DWORD msDueTime, DWORD msPeriod, ULONG fFlags) +{ + NOREF(phTimer); NOREF(hTimerQueue); NOREF(pfnCallback); NOREF(pvUser); NOREF(msDueTime); NOREF(msPeriod); NOREF(fFlags); + SetLastError(ERROR_NOT_SUPPORTED); + return FALSE; +} + +DECL_KERNEL32(BOOL) Fake_DeleteTimerQueueTimer(HANDLE hTimerQueue, HANDLE hTimer, HANDLE hEvtCompletion) +{ + NOREF(hTimerQueue); NOREF(hTimer); NOREF(hEvtCompletion); + SetLastError(ERROR_NOT_SUPPORTED); + return FALSE; +} + +/* This is used by several APIs. */ + +DECL_KERNEL32(VOID) Fake_InitializeSListHead(PSLIST_HEADER pHead) +{ + pHead->Alignment = 0; +} + + +DECL_KERNEL32(PSLIST_ENTRY) Fake_InterlockedFlushSList(PSLIST_HEADER pHead) +{ + PSLIST_ENTRY pRet = NULL; + if (pHead->Next.Next) + { + for (;;) + { + SLIST_HEADER OldHead = *pHead; + SLIST_HEADER NewHead; + NewHead.Alignment = 0; + NewHead.Sequence = OldHead.Sequence + 1; + if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment)) + { + pRet = OldHead.Next.Next; + break; + } + } + } + return pRet; +} + +DECL_KERNEL32(PSLIST_ENTRY) Fake_InterlockedPopEntrySList(PSLIST_HEADER pHead) +{ + PSLIST_ENTRY pRet = NULL; + for (;;) + { + SLIST_HEADER OldHead = *pHead; + pRet = OldHead.Next.Next; + if (pRet) + { + SLIST_HEADER NewHead; + __try + { + NewHead.Next.Next = pRet->Next; + } + __except(EXCEPTION_EXECUTE_HANDLER) + { + continue; + } + NewHead.Depth = OldHead.Depth - 1; + NewHead.Sequence = OldHead.Sequence + 1; + if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment)) + break; + } + else + break; + } + return pRet; +} + +DECL_KERNEL32(PSLIST_ENTRY) Fake_InterlockedPushEntrySList(PSLIST_HEADER pHead, PSLIST_ENTRY pEntry) +{ + PSLIST_ENTRY pRet = NULL; + for (;;) + { + SLIST_HEADER OldHead = *pHead; + pRet = OldHead.Next.Next; + pEntry->Next = pRet; + SLIST_HEADER NewHead; + NewHead.Next.Next = pEntry; + NewHead.Depth = OldHead.Depth + 1; + NewHead.Sequence = OldHead.Sequence + 1; + if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment)) + break; + } + return pRet; +} + +DECL_KERNEL32(WORD) Fake_QueryDepthSList(PSLIST_HEADER pHead) +{ + return pHead->Depth; +} + + +/* curl drags these in: */ +DECL_KERNEL32(BOOL) Fake_VerifyVersionInfoA(LPOSVERSIONINFOEXA pInfo, DWORD fTypeMask, DWORDLONG fConditionMask) +{ + OSVERSIONINFOEXA VerInfo; + RT_ZERO(VerInfo); + VerInfo.dwOSVersionInfoSize = sizeof(VerInfo); + if (!GetVersionExA((OSVERSIONINFO *)&VerInfo)) + { + RT_ZERO(VerInfo); + VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + BOOL fRet = GetVersionExA((OSVERSIONINFO *)&VerInfo); + if (fRet) + { /* likely */ } + else + { + MY_ASSERT(false, "VerifyVersionInfoA: #1"); + return FALSE; + } + } + + BOOL fRet = TRUE; + for (unsigned i = 0; i < 8 && fRet; i++) + if (fTypeMask & RT_BIT_32(i)) + { + uint32_t uLeft, uRight; + switch (RT_BIT_32(i)) + { +#define MY_CASE(a_Num, a_Member) case a_Num: uLeft = VerInfo.a_Member; uRight = pInfo->a_Member; break + MY_CASE(VER_MINORVERSION, dwMinorVersion); + MY_CASE(VER_MAJORVERSION, dwMajorVersion); + MY_CASE(VER_BUILDNUMBER, dwBuildNumber); + MY_CASE(VER_PLATFORMID, dwPlatformId); + MY_CASE(VER_SERVICEPACKMINOR, wServicePackMinor); + MY_CASE(VER_SERVICEPACKMAJOR, wServicePackMinor); + MY_CASE(VER_SUITENAME, wSuiteMask); + MY_CASE(VER_PRODUCT_TYPE, wProductType); +#undef MY_CASE + default: uLeft = uRight = 0; MY_ASSERT(false, "VerifyVersionInfoA: #2"); + } + switch ((uint8_t)(fConditionMask >> (i*8))) + { + case VER_EQUAL: fRet = uLeft == uRight; break; + case VER_GREATER: fRet = uLeft > uRight; break; + case VER_GREATER_EQUAL: fRet = uLeft >= uRight; break; + case VER_LESS: fRet = uLeft < uRight; break; + case VER_LESS_EQUAL: fRet = uLeft <= uRight; break; + case VER_AND: fRet = (uLeft & uRight) == uRight; break; + case VER_OR: fRet = (uLeft & uRight) != 0; break; + default: fRet = FALSE; MY_ASSERT(false, "VerifyVersionInfoA: #3"); break; + } + } + + return fRet; +} + + +DECL_KERNEL32(ULONGLONG) Fake_VerSetConditionMask(ULONGLONG fConditionMask, DWORD fTypeMask, BYTE bOperator) +{ + for (unsigned i = 0; i < 8; i++) + if (fTypeMask & RT_BIT_32(i)) + { + uint64_t fMask = UINT64_C(0xff) << (i*8); + fConditionMask &= ~fMask; + fConditionMask |= (uint64_t)bOperator << (i*8); + + } + return fConditionMask; +} + + +/* + * NT 3.51 stuff. + */ + +DECL_KERNEL32(BOOL) Fake_IsProcessorFeaturePresent(DWORD enmProcessorFeature) +{ + /* Could make more of an effort here... */ + RT_NOREF(enmProcessorFeature); + return FALSE; +} + + +DECL_KERNEL32(BOOL) Fake_CancelIo(HANDLE hHandle) +{ + /* All NT versions the NTDLL API this corresponds to. */ + RESOLVE_NTDLL_API(NtCancelIoFile); + if (pfnNtCancelIoFile) + { + IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER; + NTSTATUS rcNt = pfnNtCancelIoFile(hHandle, &Ios); + if (RT_SUCCESS(rcNt)) + return TRUE; + if (rcNt == STATUS_INVALID_HANDLE) + SetLastError(ERROR_INVALID_HANDLE); + else + SetLastError(ERROR_INVALID_FUNCTION); + } + else + SetLastError(ERROR_NOT_SUPPORTED); + return FALSE; +} + + +/* + * NT 3.50 stuff. + */ + +DECL_KERNEL32(BOOL) Fake_IsDebuggerPresent(VOID) +{ + /* Fallback: */ + return FALSE; +} + + +DECL_KERNEL32(VOID) Fake_GetSystemTimeAsFileTime(LPFILETIME pTime) +{ + DWORD dwVersion = GetVersion(); + if ( (dwVersion & 0xff) > 3 + || ( (dwVersion & 0xff) == 3 + && ((dwVersion >> 8) & 0xff) >= 50) ) + { + PKUSER_SHARED_DATA pUsd = (PKUSER_SHARED_DATA)MM_SHARED_USER_DATA_VA; + + /* use interrupt time */ + LARGE_INTEGER Time; + do + { + Time.HighPart = pUsd->SystemTime.High1Time; + Time.LowPart = pUsd->SystemTime.LowPart; + } while (pUsd->SystemTime.High2Time != Time.HighPart); + + pTime->dwHighDateTime = Time.HighPart; + pTime->dwLowDateTime = Time.LowPart; + } + else + { + /* NT 3.1 didn't have a KUSER_SHARED_DATA nor a GetSystemTimeAsFileTime export. */ + SYSTEMTIME SystemTime; + GetSystemTime(&SystemTime); + BOOL fRet = SystemTimeToFileTime(&SystemTime, pTime); + if (fRet) + { /* likely */ } + else + { + MY_ASSERT(false, "GetSystemTimeAsFileTime: #2"); + pTime->dwHighDateTime = 0; + pTime->dwLowDateTime = 0; + } + } +} + + +/* + * NT 3.1 stuff. + */ + +DECL_KERNEL32(BOOL) Fake_GetVersionExA(LPOSVERSIONINFOA pInfo) +{ + DWORD dwVersion = GetVersion(); + + /* Common fields: */ + pInfo->dwMajorVersion = dwVersion & 0xff; + pInfo->dwMinorVersion = (dwVersion >> 8) & 0xff; + if (!(dwVersion & RT_BIT_32(31))) + pInfo->dwBuildNumber = dwVersion >> 16; + else + pInfo->dwBuildNumber = 511; + pInfo->dwPlatformId = VER_PLATFORM_WIN32_NT; +/** @todo get CSD from registry. */ + pInfo->szCSDVersion[0] = '\0'; + + /* OSVERSIONINFOEX fields: */ + if (pInfo->dwOSVersionInfoSize > sizeof((*pInfo))) + { + LPOSVERSIONINFOEXA pInfoEx = (LPOSVERSIONINFOEXA)pInfo; + if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXA, wServicePackMinor)) + { + pInfoEx->wServicePackMajor = 0; + pInfoEx->wServicePackMinor = 0; + } + if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXA, wSuiteMask)) + pInfoEx->wSuiteMask = 0; + if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXA, wProductType)) + pInfoEx->wProductType = VER_NT_WORKSTATION; + if (pInfoEx->wReserved > RT_UOFFSETOF(OSVERSIONINFOEXA, wProductType)) + pInfoEx->wReserved = 0; + } + + return TRUE; +} + + +DECL_KERNEL32(BOOL) Fake_GetVersionExW(LPOSVERSIONINFOW pInfo) +{ + DWORD dwVersion = GetVersion(); + + /* Common fields: */ + pInfo->dwMajorVersion = dwVersion & 0xff; + pInfo->dwMinorVersion = (dwVersion >> 8) & 0xff; + if (!(dwVersion & RT_BIT_32(31))) + pInfo->dwBuildNumber = dwVersion >> 16; + else + pInfo->dwBuildNumber = 511; + pInfo->dwPlatformId = VER_PLATFORM_WIN32_NT; +/** @todo get CSD from registry. */ + pInfo->szCSDVersion[0] = '\0'; + + /* OSVERSIONINFOEX fields: */ + if (pInfo->dwOSVersionInfoSize > sizeof((*pInfo))) + { + LPOSVERSIONINFOEXW pInfoEx = (LPOSVERSIONINFOEXW)pInfo; + if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXW, wServicePackMinor)) + { + pInfoEx->wServicePackMajor = 0; + pInfoEx->wServicePackMinor = 0; + } + if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXW, wSuiteMask)) + pInfoEx->wSuiteMask = 0; + if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXW, wProductType)) + pInfoEx->wProductType = VER_NT_WORKSTATION; + if (pInfoEx->wReserved > RT_UOFFSETOF(OSVERSIONINFOEXW, wProductType)) + pInfoEx->wReserved = 0; + } + + return TRUE; +} + + +DECL_KERNEL32(LPWCH) Fake_GetEnvironmentStringsW(void) +{ + /* + * Environment is ANSI in NT 3.1. We should only be here for NT 3.1. + * For now, don't try do a perfect job converting it, just do it. + */ + char *pszzEnv = (char *)RTNtCurrentPeb()->ProcessParameters->Environment; + size_t offEnv = 0; + while (pszzEnv[offEnv] != '\0') + { + size_t cchLen = strlen(&pszzEnv[offEnv]); + offEnv += cchLen + 1; + } + size_t const cchEnv = offEnv + 1; + + PRTUTF16 pwszzEnv = (PRTUTF16)HeapAlloc(GetProcessHeap(), 0, cchEnv * sizeof(RTUTF16)); + if (!pwszzEnv) + return NULL; + for (offEnv = 0; offEnv < cchEnv; offEnv++) + { + unsigned char ch = pwszzEnv[offEnv]; + if (!(ch & 0x80)) + pwszzEnv[offEnv] = ch; + else + pwszzEnv[offEnv] = '_'; + } + return pwszzEnv; +} + + +DECL_KERNEL32(BOOL) Fake_FreeEnvironmentStringsW(LPWCH pwszzEnv) +{ + if (pwszzEnv) + HeapFree(GetProcessHeap(), 0, pwszzEnv); + return TRUE; +} + + +DECL_KERNEL32(int) Fake_GetLocaleInfoA(LCID idLocale, LCTYPE enmType, LPSTR pData, int cchData) +{ + NOREF(idLocale); NOREF(enmType); NOREF(pData); NOREF(cchData); + //MY_ASSERT(false, "GetLocaleInfoA: idLocale=%#x enmType=%#x cchData=%#x", idLocale, enmType, cchData); + MY_ASSERT(false, "GetLocaleInfoA"); + SetLastError(ERROR_NOT_SUPPORTED); + return 0; +} + + +DECL_KERNEL32(BOOL) Fake_EnumSystemLocalesA(LOCALE_ENUMPROCA pfnCallback, DWORD fFlags) +{ + NOREF(pfnCallback); NOREF(fFlags); + //MY_ASSERT(false, "EnumSystemLocalesA: pfnCallback=%p fFlags=%#x", pfnCallback, fFlags); + MY_ASSERT(false, "EnumSystemLocalesA"); + SetLastError(ERROR_NOT_SUPPORTED); + return FALSE; +} + + +DECL_KERNEL32(BOOL) Fake_IsValidLocale(LCID idLocale, DWORD fFlags) +{ + NOREF(idLocale); NOREF(fFlags); + //MY_ASSERT(false, "IsValidLocale: idLocale fFlags=%#x", idLocale, fFlags); + MY_ASSERT(false, "IsValidLocale"); + SetLastError(ERROR_NOT_SUPPORTED); + return FALSE; +} + + +DECL_KERNEL32(DWORD_PTR) Fake_SetThreadAffinityMask(HANDLE hThread, DWORD_PTR fAffinityMask) +{ + SYSTEM_INFO SysInfo; + GetSystemInfo(&SysInfo); + //MY_ASSERT(false, "SetThreadAffinityMask: hThread=%p fAffinityMask=%p SysInfo.dwActiveProcessorMask=%p", + // hThread, fAffinityMask, SysInfo.dwActiveProcessorMask); + MY_ASSERT(false, "SetThreadAffinityMask"); + if ( SysInfo.dwActiveProcessorMask == fAffinityMask + || fAffinityMask == ~(DWORD_PTR)0) + return fAffinityMask; + + SetLastError(ERROR_NOT_SUPPORTED); + RT_NOREF(hThread); + return 0; +} + + +DECL_KERNEL32(BOOL) Fake_GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR pfProcessAffinityMask, PDWORD_PTR pfSystemAffinityMask) +{ + SYSTEM_INFO SysInfo; + GetSystemInfo(&SysInfo); + //MY_ASSERT(false, "GetProcessAffinityMask: SysInfo.dwActiveProcessorMask=%p", SysInfo.dwActiveProcessorMask); + MY_ASSERT(false, "GetProcessAffinityMask"); + if (pfProcessAffinityMask) + *pfProcessAffinityMask = SysInfo.dwActiveProcessorMask; + if (pfSystemAffinityMask) + *pfSystemAffinityMask = SysInfo.dwActiveProcessorMask; + RT_NOREF(hProcess); + return TRUE; +} + + +DECL_KERNEL32(BOOL) Fake_GetHandleInformation(HANDLE hObject, DWORD *pfFlags) +{ + OBJECT_HANDLE_FLAG_INFORMATION Info = { 0, 0 }; + DWORD cbRet = sizeof(Info); + NTSTATUS rcNt = NtQueryObject(hObject, ObjectHandleFlagInformation, &Info, sizeof(Info), &cbRet); + if (NT_SUCCESS(rcNt)) + { + *pfFlags = (Info.Inherit ? HANDLE_FLAG_INHERIT : 0) + | (Info.ProtectFromClose ? HANDLE_FLAG_PROTECT_FROM_CLOSE : 0); + return TRUE; + } + *pfFlags = 0; + //MY_ASSERT(rcNt == STATUS_INVALID_HANDLE, "rcNt=%#x", rcNt); + MY_ASSERT(rcNt == STATUS_INVALID_HANDLE || rcNt == STATUS_INVALID_INFO_CLASS, "GetHandleInformation"); + SetLastError(rcNt == STATUS_INVALID_HANDLE ? ERROR_INVALID_HANDLE : ERROR_INVALID_FUNCTION); /* see also process-win.cpp */ + return FALSE; +} + + +DECL_KERNEL32(BOOL) Fake_SetHandleInformation(HANDLE hObject, DWORD fMask, DWORD fFlags) +{ + NOREF(hObject); NOREF(fMask); NOREF(fFlags); + SetLastError(ERROR_INVALID_FUNCTION); + return FALSE; +} + + + +/** + * Resolves all the APIs ones and for all, updating the fake IAT entries. + */ +DECLASM(void) FakeResolve_kernel32(void) +{ + CURRENT_VERSION_VARIABLE(); + + HMODULE hmod = GetModuleHandleW(L"kernel32"); + MY_ASSERT(hmod != NULL, "kernel32"); + +#undef MAKE_IMPORT_ENTRY +#define MAKE_IMPORT_ENTRY(a_uMajorVer, a_uMinorVer, a_Name, a_cb) RESOLVE_IMPORT(a_uMajorVer, a_uMinorVer, a_Name, a_cb) +#include "vcc100-kernel32-fakes.h" + + g_fInitialized = true; +} + + +/* Dummy to force dragging in this object in the link, so the linker + won't accidentally use the symbols from kernel32. */ +extern "C" int vcc100_kernel32_fakes_cpp(void) +{ + return 42; +} + diff --git a/src/VBox/Runtime/r3/win/vcc100-kernel32-fakes.h b/src/VBox/Runtime/r3/win/vcc100-kernel32-fakes.h new file mode 100644 index 00000000..d82fbf3b --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-kernel32-fakes.h @@ -0,0 +1,40 @@ + +COMMENT("XP SP2 / W2K3 SP1") +MAKE_IMPORT_ENTRY(6,0, DecodePointer, 4) +MAKE_IMPORT_ENTRY(6,0, EncodePointer, 4) +COMMENT("XP") +MAKE_IMPORT_ENTRY(5,1, HeapSetInformation, 16) +MAKE_IMPORT_ENTRY(5,1, HeapQueryInformation, 20) +MAKE_IMPORT_ENTRY(5,1, InitializeSListHead, 4) +MAKE_IMPORT_ENTRY(5,1, InterlockedFlushSList, 4) +MAKE_IMPORT_ENTRY(5,1, InterlockedPopEntrySList, 4) +MAKE_IMPORT_ENTRY(5,1, InterlockedPushEntrySList, 8) +MAKE_IMPORT_ENTRY(5,1, QueryDepthSList, 4) +COMMENT("W2K") +MAKE_IMPORT_ENTRY(5,0, CreateTimerQueue, 0) +MAKE_IMPORT_ENTRY(5,0, CreateTimerQueueTimer, 28) +MAKE_IMPORT_ENTRY(5,0, DeleteTimerQueueTimer, 12) +MAKE_IMPORT_ENTRY(5,0, VerSetConditionMask, 16) +COMMENT("NT 4 SP4+") +MAKE_IMPORT_ENTRY(5,0, VerifyVersionInfoA, 16) +COMMENT("NT 4 SP3+") +MAKE_IMPORT_ENTRY(5,0, InitializeCriticalSectionAndSpinCount, 8) +COMMENT("NT 3.51") +MAKE_IMPORT_ENTRY(4,0, IsProcessorFeaturePresent, 4) +MAKE_IMPORT_ENTRY(4,0, CancelIo, 4) +COMMENT("NT 3.50") +MAKE_IMPORT_ENTRY(3,51, IsDebuggerPresent, 0) +MAKE_IMPORT_ENTRY(3,51, GetSystemTimeAsFileTime, 4) +COMMENT("NT 3.1") +MAKE_IMPORT_ENTRY(3,50, GetVersionExA, 4) +MAKE_IMPORT_ENTRY(3,50, GetVersionExW, 4) +MAKE_IMPORT_ENTRY(3,50, GetEnvironmentStringsW, 0) +MAKE_IMPORT_ENTRY(3,50, FreeEnvironmentStringsW, 4) +MAKE_IMPORT_ENTRY(3,50, GetLocaleInfoA, 16) +MAKE_IMPORT_ENTRY(3,50, EnumSystemLocalesA, 8) +MAKE_IMPORT_ENTRY(3,50, IsValidLocale, 8) +MAKE_IMPORT_ENTRY(3,50, SetThreadAffinityMask, 8) +MAKE_IMPORT_ENTRY(3,50, GetProcessAffinityMask, 12) +MAKE_IMPORT_ENTRY(3,50, GetHandleInformation, 8) +MAKE_IMPORT_ENTRY(3,50, SetHandleInformation, 12) + diff --git a/src/VBox/Runtime/r3/win/vcc100-kernel32-fakesA.asm b/src/VBox/Runtime/r3/win/vcc100-kernel32-fakesA.asm new file mode 100644 index 00000000..6f885dca --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-kernel32-fakesA.asm @@ -0,0 +1,36 @@ +; $Id: vcc100-kernel32-fakesA.asm $ +;; @file +; IPRT - Wrappers for kernel32 APIs missing in NT4 and earlier. +; + +; +; Copyright (C) 2006-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + + +%include "vcc100-fakes.mac" + +%define FAKE_MODULE_NAME kernel32 + +BEGINDATA +GLOBALNAME vcc100_kernel32_fakes_asm + +%include "vcc100-kernel32-fakes.h" + diff --git a/src/VBox/Runtime/r3/win/vcc100-msvcrt-fakes.cpp b/src/VBox/Runtime/r3/win/vcc100-msvcrt-fakes.cpp new file mode 100644 index 00000000..e19155d2 --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-msvcrt-fakes.cpp @@ -0,0 +1,82 @@ +/* $Id: vcc100-msvcrt-fakes.cpp $ */ +/** @file + * IPRT - Tricks to make the Visual C++ 2010 CRT work on NT4, W2K and XP. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/assert.h> +#include <stdlib.h> + + +#ifndef RT_ARCH_X86 +# error "This code is X86 only" +#endif + + + +/* This one is static in libcmt, fortunately no rocket science. */ +extern "C" void __cdecl my_initterm(PFNRT *papfnStart, PFNRT *papfnEnd) +{ + for (; (uintptr_t)papfnStart < (uintptr_t)papfnEnd; papfnStart++) + if (*papfnStart) + (*papfnStart)(); +} + +extern "C" PFNRT __cdecl my_dllonexit(PFNRT pfnToAdd, PFNRT **ppapfnStart, PFNRT **ppapfnEnd) +{ + /* This is _very_ crude, but it'll probably do for our purposes... */ + size_t cItems = *ppapfnEnd - *ppapfnStart; + *ppapfnStart = (PFNRT *)realloc(*ppapfnStart, (cItems + 1) * sizeof(**ppapfnStart)); + (*ppapfnStart)[cItems] = pfnToAdd; + *ppapfnEnd = &(*ppapfnStart)[cItems + 1]; + return pfnToAdd; +} + +extern "C" int _newmode; +extern "C" int __cdecl __setargv(void); +extern "C" int __cdecl _setargv(void); + +extern "C" int __cdecl my_getmainargs(int *pcArgs, char ***ppapszArgs, char ***ppapszEnv, int fDoWildcardExp, int *pfNewMode) +{ + _newmode = *pfNewMode; + + Assert(!fDoWildcardExp); + int rc = _setargv(); + if (rc >= 0) + { + *pcArgs = __argc; + *ppapszArgs = __argv; + *ppapszEnv = _environ; + } + return rc; +} + +extern "C" void __cdecl my_setusermatherr(PFNRT pfnIgnore) +{ + /* pure stub. */ +} + diff --git a/src/VBox/Runtime/r3/win/vcc100-ntdll-fakes.cpp b/src/VBox/Runtime/r3/win/vcc100-ntdll-fakes.cpp new file mode 100644 index 00000000..1439c5eb --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-ntdll-fakes.cpp @@ -0,0 +1,74 @@ +/* $Id: vcc100-ntdll-fakes.cpp $ */ +/** @file + * IPRT - Tricks to make the Visual C++ 2010 CRT work on NT4, W2K and XP - NTDLL.DLL. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/cdefs.h> +#include <iprt/types.h> + +#ifndef RT_ARCH_X86 +# error "This code is X86 only" +#endif + +#include <iprt/win/windows.h> + + + +/** Dynamically resolves an kernel32 API. */ +#define RESOLVE_ME(ApiNm) \ + static bool volatile s_fInitialized = false; \ + static decltype(ApiNm) *s_pfnApi = NULL; \ + decltype(ApiNm) *pfnApi; \ + if (s_fInitialized) \ + pfnApi = s_pfnApi; \ + else \ + { \ + pfnApi = (decltype(pfnApi))GetProcAddress(GetModuleHandleW(L"ntdll.dll"), #ApiNm); \ + s_pfnApi = pfnApi; \ + s_fInitialized = true; \ + } do {} while (0) \ + + +extern "C" +__declspec(dllexport) +ULONG WINAPI RtlGetLastWin32Error(VOID) +{ + RESOLVE_ME(RtlGetLastWin32Error); + if (pfnApi) + return pfnApi(); + return GetLastError(); +} + + +/* Dummy to force dragging in this object in the link, so the linker + won't accidentally use the symbols from kernel32. */ +extern "C" int vcc100_ntdll_fakes_cpp(void) +{ + return 42; +} + diff --git a/src/VBox/Runtime/r3/win/vcc100-ntdll-fakesA.asm b/src/VBox/Runtime/r3/win/vcc100-ntdll-fakesA.asm new file mode 100644 index 00000000..83072912 --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-ntdll-fakesA.asm @@ -0,0 +1,47 @@ +; $Id: vcc100-ntdll-fakesA.asm $ +;; @file +; IPRT - Wrappers for ntdll APIs misisng NT4. +; + +; +; Copyright (C) 2006-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + +%include "iprt/asmdefs.mac" + +%ifndef RT_ARCH_X86 + %error "This is x86 only code. +%endif + + +%macro MAKE_IMPORT_ENTRY 2 +extern _ %+ %1 %+ @ %+ %2 +global __imp__ %+ %1 %+ @ %+ %2 +__imp__ %+ %1 %+ @ %+ %2: + dd _ %+ %1 %+ @ %+ %2 + +%endmacro + + +BEGINDATA +GLOBALNAME vcc100_ntdll_fakes_asm + +MAKE_IMPORT_ENTRY RtlGetLastWin32Error, 0 + diff --git a/src/VBox/Runtime/r3/win/vcc100-shell32-fakes.cpp b/src/VBox/Runtime/r3/win/vcc100-shell32-fakes.cpp new file mode 100644 index 00000000..42581b8f --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-shell32-fakes.cpp @@ -0,0 +1,93 @@ +/* $Id: vcc100-shell32-fakes.cpp $ */ +/** @file + * IPRT - Tricks to make the Visual C++ 2010 CRT work on NT4, W2K and XP. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define RT_NO_STRICT /* Minimal deps so that it works on NT 3.51 too. */ +#include <iprt/types.h> +#include <iprt/assert.h> +#include <iprt/string.h> + +#ifndef RT_ARCH_X86 +# error "This code is X86 only" +#endif + +#define CommandLineToArgvW Ignore_CommandLineToArgvW + +#include <iprt/nt/nt-and-windows.h> + +#undef CommandLineToArgvW + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Dynamically resolves an kernel32 API. */ +#define RESOLVE_ME(ApiNm) \ + static decltype(ShellExecuteW) * volatile s_pfnInitialized = NULL; \ + static decltype(ApiNm) *s_pfnApi = NULL; \ + decltype(ApiNm) *pfnApi; \ + if (s_pfnInitialized) \ + pfnApi = s_pfnApi; \ + else \ + { \ + pfnApi = (decltype(pfnApi))GetProcAddress(GetModuleHandleW(L"shell32"), #ApiNm); \ + s_pfnApi = pfnApi; \ + s_pfnInitialized = ShellExecuteW; /* ensures shell32 is loaded */ \ + } do {} while (0) + + +/** Declare a shell32 API. + * @note We are not exporting them as that causes duplicate symbol troubles in + * the OpenGL bits. */ +#define DECL_SHELL32(a_Type) extern "C" a_Type WINAPI + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ + + +DECL_SHELL32(LPWSTR *) CommandLineToArgvW(LPCWSTR pwszCmdLine, int *pcArgs) +{ + RESOLVE_ME(CommandLineToArgvW); + if (pfnApi) + return pfnApi(pwszCmdLine, pcArgs); + + *pcArgs = 0; + return NULL; +} + + +/* Dummy to force dragging in this object in the link, so the linker + won't accidentally use the symbols from shell32. */ +extern "C" int vcc100_shell32_fakes_cpp(void) +{ + return 42; +} + diff --git a/src/VBox/Runtime/r3/win/vcc100-shell32-fakesA.asm b/src/VBox/Runtime/r3/win/vcc100-shell32-fakesA.asm new file mode 100644 index 00000000..029b9a6f --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-shell32-fakesA.asm @@ -0,0 +1,49 @@ +; $Id: vcc100-shell32-fakesA.asm $ +;; @file +; IPRT - Wrappers for shell32 APIs missing in NT 4 and earlier. +; + +; +; Copyright (C) 2006-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + + +%include "iprt/asmdefs.mac" + +%ifndef RT_ARCH_X86 + %error "This is x86 only code. +%endif + + +%macro MAKE_IMPORT_ENTRY 2 +extern _ %+ %1 %+ @ %+ %2 +global __imp__ %+ %1 %+ @ %+ %2 +__imp__ %+ %1 %+ @ %+ %2: + dd _ %+ %1 %+ @ %+ %2 + +%endmacro + + +BEGINDATA +GLOBALNAME vcc100_shell32_fakes_asm + +; NT 3.1 +MAKE_IMPORT_ENTRY CommandLineToArgvW, 8 + diff --git a/src/VBox/Runtime/r3/win/vcc100-ws2_32-fakes.cpp b/src/VBox/Runtime/r3/win/vcc100-ws2_32-fakes.cpp new file mode 100644 index 00000000..4be5f3d3 --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-ws2_32-fakes.cpp @@ -0,0 +1,103 @@ +/* $Id: vcc100-ws2_32-fakes.cpp $ */ +/** @file + * IPRT - Tricks to make the Visual C++ 2010 CRT work on NT4, W2K and XP - WS2_32.DLL. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/cdefs.h> +#include <iprt/types.h> +#include <iprt/asm.h> +#include <iprt/string.h> + +#ifndef RT_ARCH_X86 +# error "This code is X86 only" +#endif + +#define getaddrinfo Ignore_getaddrinfo +#define freeaddrinfo Ignore_freeaddrinfo + +#include <iprt/win/winsock2.h> +#include <iprt/win/ws2tcpip.h> + +#undef getaddrinfo +#undef freeaddrinfo + + +/** Dynamically resolves an kernel32 API. */ +#define RESOLVE_ME(ApiNm) \ + static bool volatile s_fInitialized = false; \ + static decltype(ApiNm) *s_pfnApi = NULL; \ + decltype(ApiNm) *pfnApi; \ + if (s_fInitialized) \ + pfnApi = s_pfnApi; \ + else \ + { \ + pfnApi = (decltype(pfnApi))GetProcAddress(GetModuleHandleW(L"wc2_32.dll"), #ApiNm); \ + s_pfnApi = pfnApi; \ + s_fInitialized = true; \ + } do {} while (0) \ + + +extern "C" +__declspec(dllexport) +int WINAPI getaddrinfo(const char *pszNodeName, const char *pszServiceName, const struct addrinfo *pHints, + struct addrinfo **ppResults) +{ + RESOLVE_ME(getaddrinfo); + if (pfnApi) + return pfnApi(pszNodeName, pszServiceName, pHints, ppResults); + + /** @todo fallback */ + WSASetLastError(WSAEAFNOSUPPORT); + return WSAEAFNOSUPPORT; +} + + + +extern "C" +__declspec(dllexport) +void WINAPI freeaddrinfo(struct addrinfo *pResults) +{ + RESOLVE_ME(freeaddrinfo); + if (pfnApi) + pfnApi(pResults); + else + { + Assert(!pResults); + /** @todo fallback */ + } +} + + + +/* Dummy to force dragging in this object in the link, so the linker + won't accidentally use the symbols from kernel32. */ +extern "C" int vcc100_ws2_32_fakes_cpp(void) +{ + return 42; +} + diff --git a/src/VBox/Runtime/r3/win/vcc100-ws2_32-fakesA.asm b/src/VBox/Runtime/r3/win/vcc100-ws2_32-fakesA.asm new file mode 100644 index 00000000..2ede29a4 --- /dev/null +++ b/src/VBox/Runtime/r3/win/vcc100-ws2_32-fakesA.asm @@ -0,0 +1,48 @@ +; $Id: vcc100-ws2_32-fakesA.asm $ +;; @file +; IPRT - Wrappers for ws2_32 APIs misisng NT4. +; + +; +; Copyright (C) 2006-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + +%include "iprt/asmdefs.mac" + +%ifndef RT_ARCH_X86 + %error "This is x86 only code. +%endif + + +%macro MAKE_IMPORT_ENTRY 2 +extern _ %+ %1 %+ @ %+ %2 +global __imp__ %+ %1 %+ @ %+ %2 +__imp__ %+ %1 %+ @ %+ %2: + dd _ %+ %1 %+ @ %+ %2 + +%endmacro + + +BEGINDATA +GLOBALNAME vcc100_ws2_32_fakes_asm + +MAKE_IMPORT_ENTRY getaddrinfo, 16 +MAKE_IMPORT_ENTRY freeaddrinfo, 4 + |