public void CreateFromStringListTest()
{
var r = new[] { "5", "5", "5", "5" };
var h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Concatenated, CharSet.Ansi, 7);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(16));
Assert.That(h.ToStringEnum(CharSet.Ansi, 7), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items);
h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Concatenated, CharSet.Unicode, 7);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(25));
Assert.That(h.ToStringEnum(CharSet.Unicode, 7), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items);
h = SafeCoTaskMemHandle.CreateFromStringList(r);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(18));
Assert.That(h.ToString(-1), Is.EqualTo("5"));
Assert.That(h.ToStringEnum(), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items);
h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Packed, CharSet.Ansi, 7);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(7 + IntPtr.Size + r.Length * (2 + IntPtr.Size)));
Assert.That(h.ToStringEnum(4, CharSet.Ansi, 7), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items);
h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Packed, CharSet.Unicode, 7);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(7 + IntPtr.Size + r.Length * (4 + IntPtr.Size)));
Assert.That(h.ToStringEnum(4, CharSet.Unicode, 7), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items);
h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Packed);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(IntPtr.Size + r.Length * (4 + IntPtr.Size)));
Assert.That(h.ToStringEnum(4, CharSet.Unicode), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items);
h = SafeCoTaskMemHandle.CreateFromStringList(null);
Assert.That((int)h.Size, Is.EqualTo(Extensions.StringHelper.GetCharSize()));
}
public void EncryptTest()
{
byte[] rgbPlaintext = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
byte[] rgbIV = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
byte[] rgbAES128Key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
var err = BCryptOpenAlgorithmProvider(out var hAlg, StandardAlgorithmId.BCRYPT_AES_ALGORITHM);
Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS));
var cbKeyObject = BCryptGetProperty <uint>(hAlg, BCrypt.PropertyName.BCRYPT_OBJECT_LENGTH);
Assert.That(cbKeyObject, Is.GreaterThan(0));
var cbBlockLen = BCryptGetProperty <uint>(hAlg, BCrypt.PropertyName.BCRYPT_BLOCK_LENGTH);
Assert.That(cbBlockLen, Is.GreaterThan(0));
Assert.That(cbBlockLen, Is.LessThanOrEqualTo(rgbIV.Length));
var cm = System.Text.Encoding.Unicode.GetBytes(ChainingMode.BCRYPT_CHAIN_MODE_CBC);
err = BCryptSetProperty(hAlg, BCrypt.PropertyName.BCRYPT_CHAINING_MODE, cm, (uint)cm.Length);
Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS));
var pbKeyObject = new SafeCoTaskMemHandle((int)cbKeyObject);
err = BCryptGenerateSymmetricKey(hAlg, out var hKey, pbKeyObject, cbKeyObject, rgbAES128Key, (uint)rgbAES128Key.Length, 0);
Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS));
err = BCryptExportKey(hKey, default, BlobType.BCRYPT_OPAQUE_KEY_BLOB, IntPtr.Zero, 0, out var cbBlob);
public void CreateHashTest()
{
var err = BCryptOpenAlgorithmProvider(out var hAlg, StandardAlgorithmId.BCRYPT_SHA256_ALGORITHM);
Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS));
var cbHashObject = BCryptGetProperty <uint>(hAlg, BCrypt.PropertyName.BCRYPT_OBJECT_LENGTH);
Assert.That(cbHashObject, Is.GreaterThan(0));
var cbHash = BCryptGetProperty <uint>(hAlg, BCrypt.PropertyName.BCRYPT_HASH_LENGTH);
Assert.That(cbHash, Is.GreaterThan(0));
var pbHashObject = new SafeHeapBlock((int)cbHashObject);
var pbHash = new SafeHeapBlock((int)cbHash);
err = BCryptCreateHash(hAlg, out var hHash, pbHashObject, cbHashObject);
Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS));
var pbDupHashObj = new SafeCoTaskMemHandle((int)cbHashObject);
err = BCryptDuplicateHash(hHash, out var hDupHash, pbDupHashObj, cbHashObject);
Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS));
var rgbMsg = new byte[] { 0x61, 0x62, 0x63 };
err = BCryptHashData(hHash, rgbMsg, (uint)rgbMsg.Length, 0);
Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS));
err = BCryptFinishHash(hHash, pbHash, cbHash);
Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS));
}
public static IEnumerable <INHERITED_FROM> GetInheritanceSource(string objectName, ResourceType objectType,
SECURITY_INFORMATION securityInfo, bool container, IntPtr pAcl, ref GENERIC_MAPPING pGenericMapping)
{
var objSize = Marshal.SizeOf(typeof(INHERITED_FROM));
var aceCount = GetAceCount(pAcl);
using (var pInherit = new SafeCoTaskMemHandle(objSize * (int)aceCount))
{
var hr = 0;
try
{
hr = AdvApi32.GetInheritanceSource(objectName, objectType, securityInfo, container, null, 0, pAcl, IntPtr.Zero, ref pGenericMapping, (IntPtr)pInherit);
if (hr != 0)
{
throw new System.ComponentModel.Win32Exception(hr);
}
return(pInherit.ToIEnum <INHERITED_FROM>((int)aceCount));
}
finally
{
if (hr != 0)
{
FreeInheritedFromArray((IntPtr)pInherit, (ushort)aceCount, IntPtr.Zero);
}
}
}
}
public void CreateFromListTest()
{
var r = new[] { 5, 5, 5, 5 };
var h = SafeCoTaskMemHandle.CreateFromList(r, r.Length);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(Marshal.SizeOf(typeof(int)) * r.Length));
Assert.That(h.ToStructure <int>(), Is.EqualTo(5));
Assert.That(h.ToEnumerable <int>(4), Has.Exactly(4).EqualTo(5).And.Exactly(4).Items);
var d = new[] { new RECT(1, 1, 1, 1), new RECT(2, 2, 2, 2) };
h = SafeCoTaskMemHandle.CreateFromList(d, d.Length);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(Marshal.SizeOf(typeof(RECT)) * d.Length));
Assert.That(h.ToStructure <RECT>().X, Is.EqualTo(1));
Assert.That(h.ToArray <RECT>(2), Has.Exactly(2).Items);
var p = new[] { new PRECT(1, 1, 1, 1), new PRECT(2, 2, 2, 2) };
h = SafeCoTaskMemHandle.CreateFromList(p);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(Marshal.SizeOf(typeof(PRECT)) * p.Length));
Assert.That(h.ToArray <RECT>(2), Has.Exactly(2).Items);
Assert.That(() => SafeCoTaskMemHandle.CreateFromList(new[] { "X" }), Throws.ArgumentException);
}
public void SafeArrayScopedAccessTest()
{
var psa = SafeArrayCreateVector(VARTYPE.VT_I4, 0, 5);
{
/*for (int i = 0; i < 5; i++)
* {
* var p = new SafeCoTaskMemHandle(16);
* Marshal.GetNativeVariantForObject(i, (IntPtr)p);
* Assert.That(SafeArrayPutElement(psa, new[] { i }, (IntPtr)p).Succeeded);
* }*/
using (var d = new SafeArrayScopedAccessData(psa))
{
//var a = d.Data.ToArray<int>(5);
//Assert.That(a, Is.EquivalentTo(new long[] {0, 1, 2, 3, 4}));
d.Data.Write(new[] { 0, 1, 2, 3, 4 });
}
for (var i = 0; i < 5; i++)
{
var p = new SafeCoTaskMemHandle(16);
Assert.That(SafeArrayGetElement(psa, new[] { i }, (IntPtr)p).Succeeded);
var oi = p.ToStructure <int>();
Assert.That(oi, Is.EqualTo(i));
}
}
psa.Dispose();
}
public void TestEx()
{
const string fn = @"c:\windows\explorer.exe";
var sz = GetFileVersionInfoSizeEx(FILE_VER_GET.FILE_VER_GET_LOCALISED, fn, out _);
Assert.NotZero(sz);
using var mem = new SafeCoTaskMemHandle(sz);
Assert.That(GetFileVersionInfoEx(FILE_VER_GET.FILE_VER_GET_LOCALISED, fn, 0, mem.Size, mem), ResultIs.Successful);
Assert.That(VerQueryValue(mem, "\\", out var ptr, out var ptrLen), ResultIs.Successful);
var ffi = ptr.ToStructure<VS_FIXEDFILEINFO>(ptrLen);
ffi.WriteValues();
Assert.That(VerQueryValue(mem, @"\VarFileInfo\Translation", out ptr, out ptrLen), ResultIs.Successful);
Assert.That(ptrLen, Is.GreaterThanOrEqualTo(4));
var langcp = ptr.ToStructure<uint>(ptrLen);
var lookup = $"\\StringFileInfo\\{Macros.LOWORD(langcp):X4}{Macros.HIWORD(langcp):X4}\\";
GetStringVal("Comments");
GetStringVal("CompanyName");
GetStringVal("FileDescription");
GetStringVal("FileVersion");
GetStringVal("InternalName");
GetStringVal("LegalCopyright");
GetStringVal("ProductName");
GetStringVal("ProductVersion");
void GetStringVal(string val)
{
if (VerQueryValue(mem, lookup + val, out ptr, out ptrLen))
TestContext.WriteLine(StringHelper.GetString(ptr, CharSet.Auto));
}
}
public void GetThemeTimingFunctionTest()
{
var buf = new SafeCoTaskMemHandle(100);
var hr = GetThemeTimingFunction(hbt, 1, (IntPtr)buf, (uint)buf.Size, out var sz);
// Can't test this as there are no properties that return a value.
Assert.That(hr.Failed);
}
/// <summary>
/// Sets the specified window attribute through the Desktop Window Manager (DWM).
/// </summary>
/// <param name="window">The window.</param>
/// <param name="attribute">The attribute.</param>
/// <param name="value">The value.</param>
public static void SetWindowAttribute <T>(this IWin32Window window, SetWindowAttr attribute, T value) where T : struct
{
if (window == null)
{
throw new ArgumentNullException(nameof(window));
}
using (var ptr = SafeCoTaskMemHandle.AllocCoTaskMemStruct <T>(value))
DwmSetWindowAttribute(window.Handle, (DWMWINDOWATTRIBUTE)attribute, (IntPtr)ptr, ptr.Size);
}
/// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
public void Dispose()
{
if (buffer is null)
{
return;
}
buffer.Zero();
buffer = null;
}
public void SafeCoTaskMemHandleTest4()
{
var h = new SafeCoTaskMemHandle("0123456789");
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(11 * Marshal.SystemDefaultCharSize));
h.Dispose();
Assert.That(h.IsClosed && h.IsInvalid);
}
public void SafeCoTaskMemHandleTest2()
{
var h = new SafeCoTaskMemHandle(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(10));
h.Dispose();
Assert.That(h.IsClosed && h.IsInvalid);
}
public void SafeCoTaskMemHandleTest3()
{
var h = new SafeCoTaskMemHandle(new[] { (IntPtr)1, (IntPtr)2, (IntPtr)3, (IntPtr)4, (IntPtr)5 });
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(5 * IntPtr.Size));
h.Dispose();
Assert.That(h.IsClosed && h.IsInvalid);
}
public void CreateFromStructureTest()
{
var r = new RECT(5, 5, 5, 5);
var h = SafeCoTaskMemHandle.CreateFromStructure(r);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(Marshal.SizeOf(typeof(RECT))));
Assert.That(h.ToStructure <RECT>().X, Is.EqualTo(5));
}
public void SafeCoTaskMemHandleTest1()
{
var h = new SafeCoTaskMemHandle(Marshal.AllocCoTaskMem(5), 5);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(5));
h.Dispose();
Assert.That(h.IsClosed && h.IsInvalid);
}
public void Dhcpv6RequestParamsTest()
{
using var pparam = new SafeCoTaskMemStruct <DHCPV6CAPI_PARAMS>(new DHCPV6CAPI_PARAMS { OptionId = DHCPV6_OPTION_ID.DHCPV6_OPTION_CLIENTID });
var recdParams = new DHCPV6CAPI_PARAMS_ARRAY {
nParams = 1, Params = pparam
};
uint sz = 1000;
using var mem = new SafeCoTaskMemHandle(sz);
Assert.That(Dhcpv6RequestParams(false, default, DhcpTests.adp.Id, IntPtr.Zero, recdParams, mem, ref sz), ResultIs.Successful);
public void GetAdaptersInfoTest()
{
uint len = 15000;
var mem = new SafeCoTaskMemHandle((int)len);
#pragma warning disable CS0618 // Type or member is obsolete
Assert.That(GetAdaptersInfo((IntPtr)mem, ref len), Is.Zero);
Assert.That(((IntPtr)mem).LinkedListToIEnum <IP_ADAPTER_INFO>(i => i.Next), Is.Not.Empty);
#pragma warning restore CS0618 // Type or member is obsolete
}
public void ResizeTest()
{
var h = new SafeCoTaskMemHandle(5);
Assert.That(!h.IsClosed && !h.IsInvalid && h.Size == 5);
var ptr = (IntPtr)h;
h.Size = 50;
Assert.That(!h.IsClosed && !h.IsInvalid && h.Size == 50 && (IntPtr)h != ptr);
}
/// <summary>Sets the tab stops in a multiline edit control. When text is copied to the control, any tab character in the text causes space to be generated up to the next tab stop.</summary>
/// <param name="textBox">The text box.</param>
/// <param name="tabs">An array of unsigned integers specifying the tab stops, in dialog template units. If this parameter is not supplied, default tab stops are set at every 32 dialog template units. If a single value is provided, this value is the distance between all tab stops, in dialog template units. If two or more values are provided, each value represents a tab stop in dialog template units.</param>
public static void SetTabStops(this TextBox textBox, params uint[] tabs)
{
if (tabs == null)
{
tabs = new uint[0];
}
using (var ptr = SafeCoTaskMemHandle.CreateFromList(tabs))
SendMessage(textBox.Handle, (uint)EditMessage.EM_SETTABSTOPS, (IntPtr)tabs.Length, (IntPtr)ptr);
textBox.Invalidate();
}
public AutomaticJumpListSample()
{
InitializeComponent();
// From wWinMain
var mem = SafeCoTaskMemHandle.CreateFromStructure <uint>();
var memSz = (uint)mem.Size;
var fRecentSelected = SHGetValue(HKEY.HKEY_CURRENT_USER, REGPATH_SAMPLE, REGVAL_RECENTCATEGORY, out _, mem, ref memSz).Succeeded ? mem.ToStructure <uint>() != 0 : true;
SetCategory(fRecentSelected);
}
private void ElevatePrivileges(string[] privs)
{
var newPriv = new PTOKEN_PRIVILEGES(Array.ConvertAll(privs, s => new LUID_AND_ATTRIBUTES(LUID.FromName(s), PrivilegeAttributes.SE_PRIVILEGE_ENABLED)));
prevState = PTOKEN_PRIVILEGES.GetAllocatedAndEmptyInstance();
if (!AdjustTokenPrivileges(tok, false, newPriv, prevState.Size, prevState, out var retLen))
{
Win32Error.ThrowLastError();
}
prevState.Size = (int)retLen;
}
/// <summary>
/// Gets the specified window attribute from the Desktop Window Manager (DWM).
/// </summary>
/// <typeparam name="T">Return type. Must match the attribute.</typeparam>
/// <param name="window">The window.</param>
/// <param name="attribute">The attribute.</param>
/// <returns>Value of the windows attribute.</returns>
public static T GetWindowAttribute <T>(this IWin32Window window, GetWindowAttr attribute) where T : struct
{
if (window == null)
{
throw new ArgumentNullException(nameof(window));
}
using (var ptr = SafeCoTaskMemHandle.AllocCoTaskMem <T>())
{
DwmGetWindowAttribute(window.Handle, (DWMWINDOWATTRIBUTE)attribute, (IntPtr)ptr, ptr.Size);
return(ptr.ToStructure <T>());
}
}
public static void AdjustPrivileges(this SafeTokenHandle hObj, SafeCoTaskMemHandle privileges)
{
if (privileges == null || privileges.IsInvalid)
{
return;
}
uint retLen = 0;
if (!AdjustTokenPrivileges(hObj, false, privileges, (uint)privileges.Size, SafeCoTaskMemHandle.Null, ref retLen))
{
throw new Win32Exception();
}
}
public void DhcpRequestParamsTest()
{
var sendParams = default(DHCPCAPI_PARAMS_ARRAY);
using var pparam = new SafeCoTaskMemStruct <DHCPAPI_PARAMS>(new DHCPAPI_PARAMS { OptionId = DHCP_OPTION_ID.OPTION_SUBNET_MASK });
//using var pparam = new SafeCoTaskMemStruct<DHCPAPI_PARAMS>(new DHCPAPI_PARAMS { OptionId = DHCP_OPTION_ID.OPTION_HOST_NAME });
var reqParams = new DHCPCAPI_PARAMS_ARRAY {
nParams = 1, Params = pparam
};
uint sz = 1000;
using var mem = new SafeCoTaskMemHandle(sz);
Assert.That(DhcpRequestParams(DHCPCAPI_REQUEST.DHCPCAPI_REQUEST_SYNCHRONOUS, default, adp.Id, IntPtr.Zero, sendParams, reqParams, mem, ref sz, null), ResultIs.Successful);
static unsafe int Main()
{
HRESULT hr = HRESULT.S_OK;
IntPtr[] rgParaEKU = { szOID_PKIX_KP_EMAIL_PROTECTION };
var EKUCriteria = new CERT_SELECT_CRITERIA
{
dwType = CertSelectBy.CERT_SELECT_BY_ENHKEY_USAGE,
cPara = (uint)rgParaEKU.Length,
};
fixed(IntPtr *pArr = rgParaEKU)
EKUCriteria.ppPara = (IntPtr)(void *)pArr;
var bDigSig = (byte)CertKeyUsage.CERT_DIGITAL_SIGNATURE_KEY_USAGE; // in byte 0
var pDigSig = &bDigSig;
var extDigSig = new CERT_EXTENSION
{
Value = new CRYPTOAPI_BLOB {
cbData = 1, pbData = (IntPtr)pDigSig
}
};
using var pExtDigSig = SafeCoTaskMemHandle.CreateFromStructure(extDigSig);
IntPtr[] rgParaKU = { pExtDigSig };
var KUCriteria = new CERT_SELECT_CRITERIA
{
dwType = CertSelectBy.CERT_SELECT_BY_KEY_USAGE,
cPara = (uint)rgParaKU.Length
};
fixed(IntPtr *pArr = rgParaKU)
KUCriteria.ppPara = (IntPtr)(void *)pArr;
CERT_SELECT_CRITERIA[] rgCriteriaFilter = { EKUCriteria, KUCriteria };
using var hStore = CertOpenStore(CertStoreProvider.CERT_STORE_PROV_SYSTEM, 0, default,
CertStoreFlags.CERT_SYSTEM_STORE_CURRENT_USER, "MY");
if (hStore.IsInvalid)
{
hr = (HRESULT)Win32Error.GetLastError();
goto CleanUp;
}
Console.Write("Looking for certificates in MY store ...\n");
if (!CertSelectCertificateChains(default, CertSelection.CERT_SELECT_TRUSTED_ROOT | CertSelection.CERT_SELECT_HAS_PRIVATE_KEY, default,
private SafeCoTaskMemHandle CreateHeifWriter()
{
var writerHandle = SafeCoTaskMemHandle.Allocate(MarshalHelper.SizeOf <heif_writer>());
unsafe
{
var writer = (heif_writer *)writerHandle.DangerousGetHandle();
writer->heif_writer_version = 1;
writer->write = Marshal.GetFunctionPointerForDelegate(this.writeDelegate);
}
return(writerHandle);
}
static int Main(string[] args)
{
if (args.Length != 1)
{
Console.Write("Usage: \n");
Console.Write("> regfs.exe <Virtualization Root Path> \n");
return(-1);
}
// args[1] should be the path to the virtualization root.
string rootPath = args[0];
// Specify the notifications that we want ProjFS to send to us. Everywhere under the virtualization
// root we want ProjFS to tell us when files have been opened, when they're about to be renamed,
// and when they're about to be deleted.
PRJ_NOTIFICATION_MAPPING[] notificationMappings = new[] { new PRJ_NOTIFICATION_MAPPING {
NotificationRoot = "",
NotificationBitMask = PRJ_NOTIFY_TYPES.PRJ_NOTIFY_FILE_OPENED | PRJ_NOTIFY_TYPES.PRJ_NOTIFY_PRE_RENAME | PRJ_NOTIFY_TYPES.PRJ_NOTIFY_PRE_DELETE
} };
// Store the notification mapping we set up into a start options structure. We leave all the
// other options at their defaults.
using var mem = SafeCoTaskMemHandle.CreateFromList(notificationMappings);
PRJ_STARTVIRTUALIZING_OPTIONS opts = new PRJ_STARTVIRTUALIZING_OPTIONS
{
NotificationMappings = mem,
NotificationMappingsCount = 1
};
// Start the provider using the options we set up.
RegfsProvider provider = new RegfsProvider();
var hr = provider.Start(rootPath, opts);
if (hr.Failed)
{
Console.Write("Failed to start virtualization instance: 0x{0:X8}\n", hr);
return(-1);
}
Console.Write("RegFS is running at virtualization root [{0}]\n", rootPath);
Console.Write("Press Enter to stop the provider...");
Console.ReadKey();
provider.Stop();
return(0);
}
public void WNetGetResourceParentTest()
{
uint sz = 1;
var lnr = new NETRESOURCE(remSh + shDir, null, prov);
var ptr = new SafeCoTaskMemHandle((int)sz);
Assert.That(WNetGetResourceParent(lnr, (IntPtr)ptr, ref sz), Is.EqualTo(Win32Error.ERROR_MORE_DATA));
ptr.Size = (int)sz;
WNetGetResourceParent(lnr, (IntPtr)ptr, ref sz).ThrowIfFailed();
var nrp = ptr.ToStructure <NETRESOURCE>();
Assert.That((int)nrp.dwUsage, Is.Not.Zero);
Assert.That(nrp.lpRemoteName, Is.EqualTo(remSh));
}
public WriterErrors()
{
this.successMessage = null;
this.writeErrorMessage = null;
try
{
this.successMessage = SafeCoTaskMemHandle.FromStringAnsi("Success");
this.writeErrorMessage = SafeCoTaskMemHandle.FromStringAnsi("Write error");
}
catch (Exception)
{
DisposableUtil.Free(ref this.successMessage);
throw;
}
}
public void WNetGetResourceInformationTest()
{
uint sz = 1;
var lnr = new NETRESOURCE(remSh + shDir);
var ptr = new SafeCoTaskMemHandle((int)sz);
Assert.That(WNetGetResourceInformation(lnr, (IntPtr)ptr, ref sz, out var _), Is.EqualTo(Win32Error.ERROR_MORE_DATA));
ptr.Size = (int)sz;
WNetGetResourceInformation(lnr, (IntPtr)ptr, ref sz, out var sys).ThrowIfFailed();
var rnr = ptr.ToStructure <NETRESOURCE>();
Assert.That((int)rnr.dwUsage, Is.Not.Zero);
Assert.That(rnr.lpRemoteName, Is.EqualTo(remSh));
Assert.That(sys, Is.Not.EqualTo(IntPtr.Zero));
}
