internal unsafe static string ConvertToManaged(IntPtr bstr)
{
if (IntPtr.Zero == bstr)
{
return(null);
}
uint num = Win32Native.SysStringByteLen(bstr);
StubHelpers.CheckStringLength(num);
string text;
if (num == 1U)
{
text = string.FastAllocateString(0);
}
else
{
text = new string((char *)((void *)bstr), 0, (int)(num / 2U));
}
if ((num & 1U) == 1U)
{
text.SetTrailByte(((byte *)bstr.ToPointer())[num - 1U]);
}
return(text);
}
protected override void DestroyCore()
{
if (m_owned)
{
StubHelpers.SafeHandleRelease(m_handle);
}
}
internal unsafe static IntPtr ConvertToNative(string strManaged, bool fBestFit, bool fThrowOnUnmappableChar, ref int cch)
{
if (strManaged == null)
{
return(IntPtr.Zero);
}
cch = strManaged.Length;
StubHelpers.CheckStringLength(cch);
int cb = 4 + (cch + 1) * Marshal.SystemMaxDBCSCharSize;
byte *ptr = (byte *)((void *)Marshal.AllocCoTaskMem(cb));
int * ptr2 = (int *)ptr;
ptr += 4;
if (cch == 0)
{
*ptr = 0;
*ptr2 = 0;
}
else
{
int num;
byte[] src = AnsiCharMarshaler.DoAnsiConversion(strManaged, fBestFit, fThrowOnUnmappableChar, out num);
Buffer.Memcpy(ptr, 0, src, 0, num);
ptr[num] = 0;
*ptr2 = num;
}
return(new IntPtr((void *)ptr));
}
// Token: 0x0600421E RID: 16926 RVA: 0x000F5A28 File Offset: 0x000F3C28
internal static Exception GetCOMHRExceptionObject_WinRT(int hr, IntPtr pCPCMD, object pThis)
{
Exception ex = StubHelpers.InternalGetCOMHRExceptionObject(hr, pCPCMD, pThis, true);
ex.InternalPreserveStackTrace();
return(ex);
}
// Token: 0x0600421B RID: 16923 RVA: 0x000F59EC File Offset: 0x000F3BEC
internal static Exception GetHRExceptionObject(int hr)
{
Exception ex = StubHelpers.InternalGetHRExceptionObject(hr);
ex.InternalPreserveStackTrace();
return(ex);
}
internal unsafe static IntPtr ConvertToNative(int flags, string strManaged, IntPtr pNativeBuffer)
{
if (strManaged == null)
{
return(IntPtr.Zero);
}
StubHelpers.CheckStringLength(strManaged.Length);
byte *ptr = (byte *)((void *)pNativeBuffer);
int num;
if (ptr != null || Marshal.SystemMaxDBCSCharSize == 1)
{
num = (strManaged.Length + 1) * Marshal.SystemMaxDBCSCharSize;
if (ptr == null)
{
ptr = (byte *)((void *)Marshal.AllocCoTaskMem(num + 1));
}
num = strManaged.ConvertToAnsi(ptr, num + 1, (flags & 255) != 0, flags >> 8 != 0);
}
else
{
byte[] src = AnsiCharMarshaler.DoAnsiConversion(strManaged, (flags & 255) != 0, flags >> 8 != 0, out num);
ptr = (byte *)((void *)Marshal.AllocCoTaskMem(num + 2));
Buffer.Memcpy(ptr, 0, src, 0, num);
}
ptr[num] = 0;
ptr[num + 1] = 0;
return((IntPtr)((void *)ptr));
}
internal unsafe void ConvertToManaged(object pManagedHome, IntPtr pNativeHome)
{
switch (this.backPropAction)
{
case AsAnyMarshaler.BackPropAction.Array:
MngdNativeArrayMarshaler.ConvertContentsToManaged(this.pvArrayMarshaler, ref pManagedHome, new IntPtr((void *)(&pNativeHome)));
return;
case AsAnyMarshaler.BackPropAction.Layout:
StubHelpers.FmtClassUpdateCLRInternal(pManagedHome, (byte *)pNativeHome.ToPointer());
return;
case AsAnyMarshaler.BackPropAction.StringBuilderAnsi:
{
sbyte *newBuffer = (sbyte *)pNativeHome.ToPointer();
((StringBuilder)pManagedHome).ReplaceBufferAnsiInternal(newBuffer, Win32Native.lstrlenA(pNativeHome));
return;
}
case AsAnyMarshaler.BackPropAction.StringBuilderUnicode:
{
char *newBuffer2 = (char *)pNativeHome.ToPointer();
((StringBuilder)pManagedHome).ReplaceBufferInternal(newBuffer2, Win32Native.lstrlenW(pNativeHome));
return;
}
default:
return;
}
}
internal unsafe static string ConvertToManaged(IntPtr cstr)
{
if (IntPtr.Zero == cstr)
{
return(null);
}
int byteLength = StubHelpers.strlen((sbyte *)((void *)cstr));
return(string.CreateStringFromEncoding((byte *)((void *)cstr), byteLength, Encoding.UTF8));
}
public void Destroy()
{
for (int i = this.m_list.Count - 1; i >= 0; i--)
{
if (this.m_list[i].m_owned)
{
StubHelpers.SafeHandleRelease(this.m_list[i].m_handle);
}
}
}
internal unsafe void ConvertToManaged(object pManagedHome, IntPtr pNativeHome)
{
switch (backPropAction)
{
case BackPropAction.Array:
{
MngdNativeArrayMarshaler.ConvertContentsToManaged(
pvArrayMarshaler,
ref pManagedHome,
new IntPtr(&pNativeHome));
break;
}
case BackPropAction.Layout:
{
StubHelpers.FmtClassUpdateCLRInternal(pManagedHome, (byte *)pNativeHome);
break;
}
case BackPropAction.StringBuilderAnsi:
{
int length;
if (pNativeHome == IntPtr.Zero)
{
length = 0;
}
else
{
length = string.strlen((byte *)pNativeHome);
}
((StringBuilder)pManagedHome).ReplaceBufferAnsiInternal((sbyte *)pNativeHome, length);
break;
}
case BackPropAction.StringBuilderUnicode:
{
int length;
if (pNativeHome == IntPtr.Zero)
{
length = 0;
}
else
{
length = string.wcslen((char *)pNativeHome);
}
((StringBuilder)pManagedHome).ReplaceBufferInternal((char *)pNativeHome, length);
break;
}
// nothing to do for BackPropAction.None
}
}
internal static IntPtr AddToCleanupList(ref CleanupWorkList pCleanupWorkList, SafeHandle handle)
{
if (pCleanupWorkList == null)
{
pCleanupWorkList = new CleanupWorkList();
}
CleanupWorkListElement cleanupWorkListElement = new CleanupWorkListElement(handle);
pCleanupWorkList.Add(cleanupWorkListElement);
return(StubHelpers.SafeHandleAddRef(handle, ref cleanupWorkListElement.m_owned));
}
internal static unsafe IntPtr ConvertSafeHandleToNative(SafeHandle?handle, ref CleanupWorkListElement?cleanupWorkList)
{
if (Unsafe.IsNullRef(ref cleanupWorkList))
{
throw new InvalidOperationException(SR.Interop_Marshal_SafeHandle_InvalidOperation);
}
ArgumentNullException.ThrowIfNull(handle);
return(StubHelpers.AddToCleanupList(ref cleanupWorkList, handle));
}
internal void ClearNative(IntPtr pNativeHome)
{
if (pNativeHome != IntPtr.Zero)
{
if (this.layoutType != null)
{
Marshal.DestroyStructure(pNativeHome, this.layoutType);
}
Win32Native.CoTaskMemFree(pNativeHome);
}
StubHelpers.DestroyCleanupList(ref this.cleanupWorkList);
}
internal unsafe static void ConvertToManaged(StringBuilder sb, IntPtr pNative)
{
int num = StubHelpers.strlen((sbyte *)((void *)pNative));
int num2 = Encoding.UTF8.GetCharCount((byte *)((void *)pNative), num);
char[] array = new char[num2 + 1];
array[num2] = '\0';
fixed(char *ptr = array)
{
num2 = Encoding.UTF8.GetChars((byte *)((void *)pNative), num, ptr, num2);
sb.ReplaceBufferInternal(ptr, num2);
}
}
internal void ClearNative(IntPtr pNativeHome)
{
if (pNativeHome != IntPtr.Zero)
{
if (layoutType != null)
{
// this must happen regardless of BackPropAction
Marshal.DestroyStructure(pNativeHome, layoutType);
}
Marshal.FreeCoTaskMem(pNativeHome);
}
StubHelpers.DestroyCleanupList(ref cleanupWorkList);
}
internal static Exception ConvertToManaged(int hr)
{
if (!Environment.IsWinRTSupported)
{
throw new PlatformNotSupportedException(Environment.GetResourceString("PlatformNotSupported_WinRT"));
}
Exception result = null;
if (hr < 0)
{
result = StubHelpers.InternalGetCOMHRExceptionObject(hr, IntPtr.Zero, null, true);
}
return(result);
}
private unsafe IntPtr ConvertLayoutToNative(object pManagedHome, int dwFlags)
{
int cb = Marshal.SizeOfHelper(pManagedHome.GetType(), false);
IntPtr result = Marshal.AllocCoTaskMem(cb);
if (AsAnyMarshaler.IsIn(dwFlags))
{
StubHelpers.FmtClassUpdateNativeInternal(pManagedHome, (byte *)result.ToPointer(), ref this.cleanupWorkList);
}
if (AsAnyMarshaler.IsOut(dwFlags))
{
this.backPropAction = AsAnyMarshaler.BackPropAction.Layout;
}
this.layoutType = pManagedHome.GetType();
return(result);
}
private static IntPtr ConvertStringToNative(string pManagedHome, int dwFlags)
{
IntPtr intPtr;
if (AsAnyMarshaler.IsAnsi(dwFlags))
{
intPtr = CSTRMarshaler.ConvertToNative(dwFlags & 65535, pManagedHome, IntPtr.Zero);
}
else
{
StubHelpers.CheckStringLength(pManagedHome.Length);
int num = (pManagedHome.Length + 1) * 2;
intPtr = Marshal.AllocCoTaskMem(num);
string.InternalCopy(pManagedHome, intPtr, num);
}
return(intPtr);
}
private unsafe IntPtr ConvertStringBuilderToNative(StringBuilder pManagedHome, int dwFlags)
{
IntPtr intPtr;
if (AsAnyMarshaler.IsAnsi(dwFlags))
{
StubHelpers.CheckStringLength(pManagedHome.Capacity);
int num = pManagedHome.Capacity * Marshal.SystemMaxDBCSCharSize + 4;
intPtr = Marshal.AllocCoTaskMem(num);
byte *ptr = (byte *)((void *)intPtr);
*(ptr + num - 3) = 0;
*(ptr + num - 2) = 0;
*(ptr + num - 1) = 0;
if (AsAnyMarshaler.IsIn(dwFlags))
{
int num2;
byte[] src = AnsiCharMarshaler.DoAnsiConversion(pManagedHome.ToString(), AsAnyMarshaler.IsBestFit(dwFlags), AsAnyMarshaler.IsThrowOn(dwFlags), out num2);
Buffer.Memcpy(ptr, 0, src, 0, num2);
ptr[num2] = 0;
}
if (AsAnyMarshaler.IsOut(dwFlags))
{
this.backPropAction = AsAnyMarshaler.BackPropAction.StringBuilderAnsi;
}
}
else
{
int num3 = pManagedHome.Capacity * 2 + 4;
intPtr = Marshal.AllocCoTaskMem(num3);
byte *ptr2 = (byte *)((void *)intPtr);
*(ptr2 + num3 - 1) = 0;
*(ptr2 + num3 - 2) = 0;
if (AsAnyMarshaler.IsIn(dwFlags))
{
int num4 = pManagedHome.Length * 2;
pManagedHome.InternalCopy(intPtr, num4);
ptr2[num4] = 0;
(ptr2 + num4)[1] = 0;
}
if (AsAnyMarshaler.IsOut(dwFlags))
{
this.backPropAction = AsAnyMarshaler.BackPropAction.StringBuilderUnicode;
}
}
return(intPtr);
}
internal static IntPtr ConvertToNative(int flags, string strManaged)
{
if (strManaged == null)
{
return(IntPtr.Zero);
}
int length = strManaged.Length;
StubHelpers.CheckStringLength(length);
byte[] str = null;
int len = 0;
if (length > 0)
{
str = AnsiCharMarshaler.DoAnsiConversion(strManaged, (flags & 255) != 0, flags >> 8 != 0, out len);
}
return(Win32Native.SysAllocStringByteLen(str, (uint)len));
}
internal unsafe static IntPtr ConvertToNative(string strManaged, IntPtr pNativeBuffer)
{
if (strManaged == null)
{
return(IntPtr.Zero);
}
StubHelpers.CheckStringLength(strManaged.Length);
byte b;
bool flag = strManaged.TryGetTrailByte(out b);
uint num = (uint)(strManaged.Length * 2);
if (flag)
{
num += 1U;
}
byte *ptr;
if (pNativeBuffer != IntPtr.Zero)
{
*(int *)pNativeBuffer.ToPointer() = (int)num;
ptr = (byte *)pNativeBuffer.ToPointer() + 4;
}
else
{
ptr = (byte *)Win32Native.SysAllocStringByteLen(null, num).ToPointer();
}
fixed(string text = strManaged)
{
char *ptr2 = text;
if (ptr2 != null)
{
ptr2 += RuntimeHelpers.OffsetToStringData / 2;
}
Buffer.Memcpy(ptr, (byte *)ptr2, (strManaged.Length + 1) * 2);
}
if (flag)
{
ptr[num - 1U] = b;
}
return((IntPtr)((void *)ptr));
}
internal static unsafe string?ConvertToManaged(IntPtr bstr)
{
if (IntPtr.Zero == bstr)
{
return(null);
}
else
{
uint length = Marshal.SysStringByteLen(bstr);
// Intentionally checking the number of bytes not characters to match the behavior
// of ML marshalers. This prevents roundtripping of very large strings as the check
// in the managed->native direction is done on String length but considering that
// it's completely moot on 32-bit and not expected to be important on 64-bit either,
// the ability to catch random garbage in the BSTR's length field outweighs this
// restriction. If an ordinary null-terminated string is passed instead of a BSTR,
// chances are that the length field - possibly being unallocated memory - contains
// a heap fill pattern that will have the highest bit set, caught by the check.
StubHelpers.CheckStringLength(length);
string ret;
if (length == 1)
{
// In the empty string case, we need to use FastAllocateString rather than the
// String .ctor, since newing up a 0 sized string will always return String.Empty.
// When we marshal that out as a bstr, it can wind up getting modified which
// corrupts string.Empty.
ret = string.FastAllocateString(0);
}
else
{
ret = new string((char *)bstr, 0, (int)(length / 2));
}
if ((length & 1) == 1)
{
// odd-sized strings need to have the trailing byte saved in their sync block
ret.SetTrailByte(((byte *)bstr)[length - 1]);
}
return(ret);
}
}
private unsafe IntPtr ConvertLayoutToNative(object pManagedHome, int dwFlags)
{
// Note that the following call will not throw exception if the type
// of pManagedHome is not marshalable. That's intentional because we
// want to maintain the original behavior where this was indicated
// by TypeLoadException during the actual field marshaling.
int allocSize = Marshal.SizeOfHelper(pManagedHome.GetType(), false);
IntPtr pNativeHome = Marshal.AllocCoTaskMem(allocSize);
// marshal the object as class with layout (UnmanagedType.LPStruct)
if (IsIn(dwFlags))
{
StubHelpers.FmtClassUpdateNativeInternal(pManagedHome, (byte *)pNativeHome, ref cleanupWorkList);
}
if (IsOut(dwFlags))
{
backPropAction = BackPropAction.Layout;
}
layoutType = pManagedHome.GetType();
return(pNativeHome);
}
internal unsafe static IntPtr ConvertToNative(int flags, string strManaged, IntPtr pNativeBuffer)
{
if (strManaged == null)
{
return(IntPtr.Zero);
}
StubHelpers.CheckStringLength(strManaged.Length);
byte *ptr = (byte *)((void *)pNativeBuffer);
int num;
if (ptr != null)
{
num = (strManaged.Length + 1) * 3;
num = strManaged.GetBytesFromEncoding(ptr, num, Encoding.UTF8);
}
else
{
num = Encoding.UTF8.GetByteCount(strManaged);
ptr = (byte *)((void *)Marshal.AllocCoTaskMem(num + 1));
strManaged.GetBytesFromEncoding(ptr, num, Encoding.UTF8);
}
ptr[num] = 0;
return((IntPtr)((void *)ptr));
}
public IntPtr AddRef()
{
// element.m_owned will be true iff the AddRef succeeded
return(StubHelpers.SafeHandleAddRef(m_handle, ref m_owned));
}
// Token: 0x06004233 RID: 16947 RVA: 0x000F5AB8 File Offset: 0x000F3CB8
internal static void CheckStringLength(int length)
{
StubHelpers.CheckStringLength((uint)length);
}
private unsafe IntPtr ConvertStringBuilderToNative(StringBuilder pManagedHome, int dwFlags)
{
IntPtr pNativeHome;
// P/Invoke can be used to call Win32 apis that don't strictly follow CLR in/out semantics and thus may
// leave garbage in the buffer in circumstances that we can't detect. To prevent us from crashing when
// converting the contents back to managed, put a hidden NULL terminator past the end of the official buffer.
// Unmanaged layout:
// +====================================+
// | Extra hidden NULL |
// +====================================+ \
// | | |
// | [Converted] NULL-terminated string | |- buffer that the target may change
// | | |
// +====================================+ / <-- native home
// Cache StringBuilder capacity and length to ensure we don't allocate a certain amount of
// native memory and then walk beyond its end if the StringBuilder concurrently grows erroneously.
int pManagedHomeCapacity = pManagedHome.Capacity;
int pManagedHomeLength = pManagedHome.Length;
if (pManagedHomeLength > pManagedHomeCapacity)
{
ThrowHelper.ThrowInvalidOperationException();
}
// Note that StringBuilder.Capacity is the number of characters NOT including any terminators.
if (IsAnsi(dwFlags))
{
StubHelpers.CheckStringLength(pManagedHomeCapacity);
// marshal the object as Ansi string (UnmanagedType.LPStr)
int allocSize = checked ((pManagedHomeCapacity * Marshal.SystemMaxDBCSCharSize) + 4);
pNativeHome = Marshal.AllocCoTaskMem(allocSize);
byte *ptr = (byte *)pNativeHome;
*(ptr + allocSize - 3) = 0;
*(ptr + allocSize - 2) = 0;
*(ptr + allocSize - 1) = 0;
if (IsIn(dwFlags))
{
int length = Marshal.StringToAnsiString(pManagedHome.ToString(),
ptr, allocSize,
IsBestFit(dwFlags),
IsThrowOn(dwFlags));
Debug.Assert(length < allocSize, "Expected a length less than the allocated size");
}
if (IsOut(dwFlags))
{
backPropAction = BackPropAction.StringBuilderAnsi;
}
}
else
{
// marshal the object as Unicode string (UnmanagedType.LPWStr)
int allocSize = checked ((pManagedHomeCapacity * 2) + 4);
pNativeHome = Marshal.AllocCoTaskMem(allocSize);
byte *ptr = (byte *)pNativeHome;
*(ptr + allocSize - 1) = 0;
*(ptr + allocSize - 2) = 0;
if (IsIn(dwFlags))
{
pManagedHome.InternalCopy(pNativeHome, pManagedHomeLength);
// null-terminate the native string
int length = pManagedHomeLength * 2;
*(ptr + length + 0) = 0;
*(ptr + length + 1) = 0;
}
if (IsOut(dwFlags))
{
backPropAction = BackPropAction.StringBuilderUnicode;
}
}
return(pNativeHome);
}
