internal extern static uint IcmpSendEcho2 (SafeCloseIcmpHandle icmpHandle, SafeWaitHandle Event, IntPtr apcRoutine, IntPtr apcContext,
uint ipAddress, [In] SafeLocalFree data, ushort dataSize, ref IPOptions options, SafeLocalFree replyBuffer, uint replySize, uint timeout);
internal extern static uint GetNetworkParams(SafeLocalFree pFixedInfo,ref uint pOutBufLen);
internal extern static uint GetPerAdapterInfo(uint IfIndex,SafeLocalFree pPerAdapterInfo,ref uint pOutBufLen);
internal extern static uint GetUdpTable(SafeLocalFree pUdpTable, ref uint dwOutBufLen, bool order);
internal extern static uint GetExtendedUdpTable(SafeLocalFree pUdpTable, ref uint dwOutBufLen, bool order,
uint IPVersion, UdpTableClass tableClass, uint reserved);
internal static extern uint HttpSendResponseEntityBody(CriticalHandle requestQueueHandle, ulong requestId, uint flags, ushort entityChunkCount, HTTP_DATA_CHUNK* pEntityChunks, uint* pBytesSent, SafeLocalFree pRequestBuffer, uint requestBufferLength, NativeOverlapped* pOverlapped, void* pLogData);
//cancel pending async requests, close the handles
private void InternalDispose () {
disposeRequested = true;
if (Interlocked.CompareExchange(ref status, Disposed, Free) != Free)
{
// Already disposed, or Finish will call Dispose again once Free
return;
}
if (handlePingV4 != null) {
handlePingV4.Close ();
handlePingV4 = null;
}
if (handlePingV6 != null) {
handlePingV6.Close ();
handlePingV6 = null;
}
UnregisterWaitHandle();
if (pingEvent != null) {
pingEvent.Close();
pingEvent = null;
}
if (replyBuffer != null) {
replyBuffer.Close();
replyBuffer = null;
}
if (asyncFinished != null) {
asyncFinished.Close();
asyncFinished = null;
}
}
internal static extern uint GetExtendedTcpTable(SafeLocalFree pTcpTable, ref uint dwOutBufLen, bool order, uint IPVersion, TcpTableClass tableClass, uint reserved);
internal static extern uint GetTcpTable(SafeLocalFree pTcpTable, ref uint dwOutBufLen, bool order);
public override unsafe void Write(byte[] buffer, int offset, int size)
{
if (Logging.On)
{
Logging.Enter(Logging.HttpListener, this, "Write", "");
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if ((offset < 0) || (offset > buffer.Length))
{
throw new ArgumentOutOfRangeException("offset");
}
if ((size < 0) || (size > (buffer.Length - offset)))
{
throw new ArgumentOutOfRangeException("size");
}
UnsafeNclNativeMethods.HttpApi.HTTP_FLAGS flags = this.ComputeLeftToWrite();
if (this.m_Closed || ((size == 0) && (this.m_LeftToWrite != 0L)))
{
if (Logging.On)
{
Logging.Exit(Logging.HttpListener, this, "Write", "");
}
}
else
{
uint num;
if ((this.m_LeftToWrite >= 0L) && (size > this.m_LeftToWrite))
{
throw new ProtocolViolationException(SR.GetString("net_entitytoobig"));
}
uint dataWritten = (uint)size;
SafeLocalFree free = null;
IntPtr zero = IntPtr.Zero;
bool sentHeaders = this.m_HttpContext.Response.SentHeaders;
try
{
if (size == 0)
{
num = this.m_HttpContext.Response.SendHeaders(null, null, flags);
}
else
{
try
{
byte[] buffer2;
if (((buffer2 = buffer) == null) || (buffer2.Length == 0))
{
numRef = null;
goto Label_0109;
}
fixed(byte *numRef = buffer2)
{
byte *numPtr;
Label_0109:
numPtr = numRef;
if (this.m_HttpContext.Response.BoundaryType == BoundaryType.Chunked)
{
string str = size.ToString("x", CultureInfo.InvariantCulture);
dataWritten += (uint)(str.Length + 4);
free = SafeLocalFree.LocalAlloc((int)dataWritten);
zero = free.DangerousGetHandle();
for (int i = 0; i < str.Length; i++)
{
Marshal.WriteByte(zero, i, (byte)str[i]);
}
Marshal.WriteInt16(zero, str.Length, (short)0xa0d);
Marshal.Copy(buffer, offset, IntPtrHelper.Add(zero, str.Length + 2), size);
Marshal.WriteInt16(zero, ((int)dataWritten) - 2, (short)0xa0d);
numPtr = (byte *)zero;
offset = 0;
}
UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK pDataChunk = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK {
DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory,
pBuffer = numPtr + offset,
BufferLength = dataWritten
};
flags |= (this.m_LeftToWrite == size) ? UnsafeNclNativeMethods.HttpApi.HTTP_FLAGS.NONE : UnsafeNclNativeMethods.HttpApi.HTTP_FLAGS.HTTP_SEND_RESPONSE_FLAG_MORE_DATA;
if (!sentHeaders)
{
num = this.m_HttpContext.Response.SendHeaders(&pDataChunk, null, flags);
}
else
{
num = UnsafeNclNativeMethods.HttpApi.HttpSendResponseEntityBody(this.m_HttpContext.RequestQueueHandle, this.m_HttpContext.RequestId, (uint)flags, 1, &pDataChunk, null, SafeLocalFree.Zero, 0, null, null);
if (this.m_HttpContext.Listener.IgnoreWriteExceptions)
{
num = 0;
}
}
}
}
finally
{
numRef = null;
}
}
}
finally
{
if (free != null)
{
free.Close();
}
}
switch (num)
{
case 0:
case 0x26:
this.UpdateAfterWrite(dataWritten);
if (Logging.On)
{
Logging.Dump(Logging.HttpListener, this, "Write", buffer, offset, (int)dataWritten);
}
if (Logging.On)
{
Logging.Exit(Logging.HttpListener, this, "Write", "");
}
return;
}
Exception e = new HttpListenerException((int)num);
if (Logging.On)
{
Logging.Exception(Logging.HttpListener, this, "Write", e);
}
this.m_HttpContext.Abort();
throw e;
}
}
internal static extern uint GetAdaptersInfo(SafeLocalFree pAdapterInfo, ref uint pOutBufLen);
// release the unmanaged memory after ping completion
void FreeUnmanagedStructures () {
if (requestBuffer != null) {
requestBuffer.Close();
requestBuffer = null;
}
}
// copies sendbuffer into unmanaged memory for async icmpsendecho apis
private unsafe void SetUnmanagedStructures (byte[] buffer) {
requestBuffer = SafeLocalFree.LocalAlloc(buffer.Length);
byte* dst = (byte*)requestBuffer.DangerousGetHandle();
for (int i = 0; i < buffer.Length; ++i)
{
dst[i] = buffer[i];
}
}
// internal method responsible for sending echo request on win2k and higher
private PingReply InternalSend (IPAddress address, byte[] buffer, int timeout, PingOptions options, bool async) {
ipv6 = (address.AddressFamily == AddressFamily.InterNetworkV6)?true:false;
sendSize = buffer.Length;
//get and cache correct handle
if (!ipv6 && handlePingV4 == null) {
handlePingV4 = UnsafeNetInfoNativeMethods.IcmpCreateFile ();
if (handlePingV4.IsInvalid) {
handlePingV4 = null;
throw new Win32Exception(); // Gets last error
}
}
else if (ipv6 && handlePingV6 == null) {
handlePingV6 = UnsafeNetInfoNativeMethods.Icmp6CreateFile();
if (handlePingV6.IsInvalid) {
handlePingV6 = null;
throw new Win32Exception(); // Gets last error
}
}
//setup the options
IPOptions ipOptions = new IPOptions (options);
//setup the reply buffer
if (replyBuffer == null) {
replyBuffer = SafeLocalFree.LocalAlloc (MaxUdpPacket);
}
//queue the event
int error;
try
{
if (async) {
if (pingEvent == null)
pingEvent = new ManualResetEvent (false);
else
pingEvent.Reset();
registeredWait = ThreadPool.RegisterWaitForSingleObject (pingEvent, new WaitOrTimerCallback (PingCallback), this, -1, true);
}
//Copy user dfata into the native world
SetUnmanagedStructures (buffer);
if (!ipv6) {
if (async) {
error = (int)UnsafeNetInfoNativeMethods.IcmpSendEcho2 (handlePingV4, pingEvent.SafeWaitHandle, IntPtr.Zero, IntPtr.Zero, (uint)address.m_Address, requestBuffer, (ushort)buffer.Length, ref ipOptions, replyBuffer, MaxUdpPacket, (uint)timeout);
}
else{
error = (int)UnsafeNetInfoNativeMethods.IcmpSendEcho2 (handlePingV4, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, (uint)address.m_Address, requestBuffer, (ushort)buffer.Length, ref ipOptions, replyBuffer, MaxUdpPacket, (uint)timeout);
}
}
else {
IPEndPoint ep = new IPEndPoint (address, 0);
SocketAddress remoteAddr = ep.Serialize ();
byte[] sourceAddr = new byte[28];
if(async){
error = (int)UnsafeNetInfoNativeMethods.Icmp6SendEcho2 (handlePingV6, pingEvent.SafeWaitHandle, IntPtr.Zero, IntPtr.Zero, sourceAddr, remoteAddr.m_Buffer, requestBuffer, (ushort)buffer.Length, ref ipOptions, replyBuffer, MaxUdpPacket, (uint)timeout);
}
else{
error = (int)UnsafeNetInfoNativeMethods.Icmp6SendEcho2 (handlePingV6, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, sourceAddr, remoteAddr.m_Buffer, requestBuffer, (ushort)buffer.Length, ref ipOptions, replyBuffer, MaxUdpPacket, (uint)timeout);
}
}
}
catch
{
UnregisterWaitHandle();
throw;
}
//need this if something is bogus.
if (error == 0) {
error = (int)Marshal.GetLastWin32Error();
// Only skip Async IO Pending error value
if (async && error == UnsafeNclNativeMethods.ErrorCodes.ERROR_IO_PENDING)
return null; // Expected async return value
// Cleanup
FreeUnmanagedStructures();
UnregisterWaitHandle();
if (async // No IPStatus async errors
|| error < (int)IPStatus.DestinationNetworkUnreachable // Min
|| error > (int)IPStatus.DestinationScopeMismatch) // Max // Out of IPStatus range
throw new Win32Exception(error);
return new PingReply((IPStatus)error); // Synchronous IPStatus errors
}
if (async) {
return null;
}
FreeUnmanagedStructures ();
//return the reply
PingReply reply;
if (ipv6) {
Icmp6EchoReply icmp6Reply = (Icmp6EchoReply)Marshal.PtrToStructure(replyBuffer.DangerousGetHandle(), typeof(Icmp6EchoReply));
reply = new PingReply(icmp6Reply, replyBuffer.DangerousGetHandle(), sendSize);
}
else {
IcmpEchoReply icmpReply = (IcmpEchoReply)Marshal.PtrToStructure(replyBuffer.DangerousGetHandle(), typeof(IcmpEchoReply));
reply = new PingReply(icmpReply);
}
// IcmpEchoReply still has an unsafe IntPtr reference into replybuffer
// and replybuffer was being freed prematurely by the GC, causing AccessViolationExceptions.
GC.KeepAlive(replyBuffer);
return reply;
}
internal extern static uint Icmp6SendEcho2 (SafeCloseIcmpHandle icmpHandle, IntPtr Event, IntPtr apcRoutine, IntPtr apcContext,
byte[] sourceSocketAddress, byte[] destSocketAddress, [In] SafeLocalFree data, ushort dataSize, ref IPOptions options, SafeLocalFree replyBuffer, uint replySize, uint timeout);
public override void Write(byte[] buffer, int offset, int size)
{
if (Logging.On)
{
Logging.Enter(Logging.HttpListener, this, "Write", "");
}
GlobalLog.Print("HttpResponseStream#" + ValidationHelper.HashString(this) + "::Write() buffer.Length:" + buffer.Length + " size:" + size + " offset:" + offset);
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (offset < 0 || offset > buffer.Length)
{
throw new ArgumentOutOfRangeException("offset");
}
if (size < 0 || size > buffer.Length - offset)
{
throw new ArgumentOutOfRangeException("size");
}
UnsafeNclNativeMethods.HttpApi.HTTP_FLAGS flags = ComputeLeftToWrite();
if (m_Closed || (size == 0 && m_LeftToWrite != 0))
{
if (Logging.On)
{
Logging.Exit(Logging.HttpListener, this, "Write", "");
}
return;
}
if (m_LeftToWrite >= 0 && size > m_LeftToWrite)
{
throw new ProtocolViolationException(SR.GetString(SR.net_entitytoobig));
}
uint statusCode;
uint dataToWrite = (uint)size;
SafeLocalFree bufferAsIntPtr = null;
IntPtr pBufferAsIntPtr = IntPtr.Zero;
bool sentHeaders = m_HttpContext.Response.SentHeaders;
try {
if (size == 0)
{
statusCode = m_HttpContext.Response.SendHeaders(null, null, flags, false);
}
else
{
fixed(byte *pDataBuffer = buffer)
{
byte *pBuffer = pDataBuffer;
if (m_HttpContext.Response.BoundaryType == BoundaryType.Chunked)
{
//
string chunkHeader = size.ToString("x", CultureInfo.InvariantCulture);
dataToWrite = dataToWrite + (uint)(chunkHeader.Length + 4);
bufferAsIntPtr = SafeLocalFree.LocalAlloc((int)dataToWrite);
pBufferAsIntPtr = bufferAsIntPtr.DangerousGetHandle();
for (int i = 0; i < chunkHeader.Length; i++)
{
Marshal.WriteByte(pBufferAsIntPtr, i, (byte)chunkHeader[i]);
}
Marshal.WriteInt16(pBufferAsIntPtr, chunkHeader.Length, 0x0A0D);
Marshal.Copy(buffer, offset, IntPtrHelper.Add(pBufferAsIntPtr, chunkHeader.Length + 2), size);
Marshal.WriteInt16(pBufferAsIntPtr, (int)(dataToWrite - 2), 0x0A0D);
pBuffer = (byte *)pBufferAsIntPtr;
offset = 0;
}
UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK dataChunk = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK();
dataChunk.DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory;
dataChunk.pBuffer = (byte *)(pBuffer + offset);
dataChunk.BufferLength = dataToWrite;
flags |= m_LeftToWrite == size ? UnsafeNclNativeMethods.HttpApi.HTTP_FLAGS.NONE : UnsafeNclNativeMethods.HttpApi.HTTP_FLAGS.HTTP_SEND_RESPONSE_FLAG_MORE_DATA;
if (!sentHeaders)
{
statusCode = m_HttpContext.Response.SendHeaders(&dataChunk, null, flags, false);
}
else
{
GlobalLog.Print("HttpResponseStream#" + ValidationHelper.HashString(this) + "::Write() calling UnsafeNclNativeMethods.HttpApi.HttpSendResponseEntityBody");
statusCode =
UnsafeNclNativeMethods.HttpApi.HttpSendResponseEntityBody(
m_HttpContext.RequestQueueHandle,
m_HttpContext.RequestId,
(uint)flags,
1,
&dataChunk,
null,
SafeLocalFree.Zero,
0,
null,
null);
GlobalLog.Print("HttpResponseStream#" + ValidationHelper.HashString(this) + "::Write() call to UnsafeNclNativeMethods.HttpApi.HttpSendResponseEntityBody returned:" + statusCode);
if (m_HttpContext.Listener.IgnoreWriteExceptions)
{
GlobalLog.Print("HttpResponseStream#" + ValidationHelper.HashString(this) + "::Write() suppressing error");
statusCode = UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS;
}
}
}
}
}
finally {
if (bufferAsIntPtr != null)
{
// free unmanaged buffer
bufferAsIntPtr.Close();
}
}
if (statusCode != UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS && statusCode != UnsafeNclNativeMethods.ErrorCodes.ERROR_HANDLE_EOF)
{
Exception exception = new HttpListenerException((int)statusCode);
if (Logging.On)
{
Logging.Exception(Logging.HttpListener, this, "Write", exception);
}
m_Closed = true;
m_HttpContext.Abort();
throw exception;
}
UpdateAfterWrite(dataToWrite);
if (Logging.On)
{
Logging.Dump(Logging.HttpListener, this, "Write", buffer, offset, (int)dataToWrite);
}
if (Logging.On)
{
Logging.Exit(Logging.HttpListener, this, "Write", "");
}
}
internal static extern uint HttpSendHttpResponse(CriticalHandle requestQueueHandle, ulong requestId, uint flags, HTTP_RESPONSE* pHttpResponse, void* pCachePolicy, uint* pBytesSent, SafeLocalFree pRequestBuffer, uint requestBufferLength, NativeOverlapped* pOverlapped, void* pLogData);
internal extern static uint GetAdaptersAddresses(
AddressFamily family,
uint flags,
IntPtr pReserved,
SafeLocalFree adapterAddresses,
ref uint outBufLen);
internal static extern uint HttpSendResponseEntityBody2(CriticalHandle requestQueueHandle, ulong requestId, uint flags, ushort entityChunkCount, IntPtr pEntityChunks, out uint pBytesSent, SafeLocalFree pRequestBuffer, uint requestBufferLength, SafeHandle pOverlapped, IntPtr pLogData);
private static IPAddress[] GetLocalAddresses()
{
IPAddress[] addressArray;
if (!ComNetOS.IsPostWin2K)
{
ArrayList list2 = new ArrayList(0x10);
int num5 = 0;
SafeLocalFree pAdapterInfo = null;
uint pOutBufLen = 0;
uint adaptersInfo = UnsafeNetInfoNativeMethods.GetAdaptersInfo(SafeLocalFree.Zero, ref pOutBufLen);
while (adaptersInfo == 0x6f)
{
try
{
pAdapterInfo = SafeLocalFree.LocalAlloc((int)pOutBufLen);
adaptersInfo = UnsafeNetInfoNativeMethods.GetAdaptersInfo(pAdapterInfo, ref pOutBufLen);
if (adaptersInfo == 0)
{
IpAdapterInfo info = (IpAdapterInfo)Marshal.PtrToStructure(pAdapterInfo.DangerousGetHandle(), typeof(IpAdapterInfo));
while (true)
{
IPAddressCollection addresss = info.ipAddressList.ToIPAddressCollection();
num5 += addresss.Count;
list2.Add(addresss);
if (info.Next == IntPtr.Zero)
{
break;
}
info = (IpAdapterInfo)Marshal.PtrToStructure(info.Next, typeof(IpAdapterInfo));
}
}
continue;
}
finally
{
if (pAdapterInfo != null)
{
pAdapterInfo.Close();
}
}
}
if ((adaptersInfo != 0) && (adaptersInfo != 0xe8))
{
throw new NetworkInformationException((int)adaptersInfo);
}
addressArray = new IPAddress[num5];
uint num8 = 0;
foreach (IPAddressCollection addresss2 in list2)
{
foreach (IPAddress address in addresss2)
{
addressArray[num8++] = address;
}
}
return(addressArray);
}
ArrayList list = new ArrayList(0x10);
int num = 0;
SafeLocalFree adapterAddresses = null;
GetAdaptersAddressesFlags flags = GetAdaptersAddressesFlags.SkipFriendlyName | GetAdaptersAddressesFlags.SkipDnsServer | GetAdaptersAddressesFlags.SkipMulticast | GetAdaptersAddressesFlags.SkipAnycast;
uint outBufLen = 0;
uint num3 = UnsafeNetInfoNativeMethods.GetAdaptersAddresses(AddressFamily.Unspecified, (uint)flags, IntPtr.Zero, SafeLocalFree.Zero, ref outBufLen);
while (num3 == 0x6f)
{
try
{
adapterAddresses = SafeLocalFree.LocalAlloc((int)outBufLen);
num3 = UnsafeNetInfoNativeMethods.GetAdaptersAddresses(AddressFamily.Unspecified, (uint)flags, IntPtr.Zero, adapterAddresses, ref outBufLen);
if (num3 != 0)
{
continue;
}
IpAdapterAddresses addresses = (IpAdapterAddresses)Marshal.PtrToStructure(adapterAddresses.DangerousGetHandle(), typeof(IpAdapterAddresses));
Label_0075:
if (addresses.FirstUnicastAddress != IntPtr.Zero)
{
UnicastIPAddressInformationCollection informations = SystemUnicastIPAddressInformation.ToAddressInformationCollection(addresses.FirstUnicastAddress);
num += informations.Count;
list.Add(informations);
}
if (!(addresses.next == IntPtr.Zero))
{
addresses = (IpAdapterAddresses)Marshal.PtrToStructure(addresses.next, typeof(IpAdapterAddresses));
goto Label_0075;
}
continue;
}
finally
{
if (adapterAddresses != null)
{
adapterAddresses.Close();
}
adapterAddresses = null;
}
}
if ((num3 != 0) && (num3 != 0xe8))
{
throw new NetworkInformationException((int)num3);
}
addressArray = new IPAddress[num];
uint num4 = 0;
foreach (UnicastIPAddressInformationCollection informations2 in list)
{
foreach (IPAddressInformation information in informations2)
{
addressArray[num4++] = information.Address;
}
}
return(addressArray);
}