Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

375 lines
14 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net;
using System.Net.Sockets;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using Microsoft.Win32.SafeHandles;
static class PeerWinsock
{
[DllImport("ws2_32.dll", SetLastError = true, EntryPoint = "WSAIoctl")]
internal static extern int WSAIoctl(
[In] IntPtr socketHandle,
[In] int ioControlCode,
[In] IntPtr inBuffer,
[In] int inBufferSize,
[Out] IntPtr outBuffer,
[In] int outBufferSize,
[Out] out int bytesTransferred,
[In] IntPtr overlapped,
[In] IntPtr completionRoutine);
}
[Serializable, StructLayout(LayoutKind.Sequential)]
struct SocketAddress
{
IntPtr sockAddr;
int sockAddrLength;
public IntPtr SockAddr { get { return sockAddr; } }
public int SockAddrLength { get { return sockAddrLength; } }
public void InitializeFromCriticalAllocHandleSocketAddress(CriticalAllocHandleSocketAddress sockAddr)
{
this.sockAddr = (IntPtr)sockAddr;
this.sockAddrLength = sockAddr.Size;
}
}
[StructLayout(LayoutKind.Sequential)]
struct SocketAddressList
{
int count;
internal const int maxAddresses = 50;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = maxAddresses)]
SocketAddress[] addresses;
public SocketAddress[] Addresses { get { return addresses; } }
public int Count { get { return count; } }
public SocketAddressList(SocketAddress[] addresses, int count)
{
this.addresses = addresses;
this.count = count;
}
public static ReadOnlyCollection<IPAddress> SortAddresses(Socket socket, IPAddress listenAddress, ReadOnlyCollection<IPAddress> addresses)
{
ReadOnlyCollection<IPAddress> sortedAddresses = null;
// Skip sort if ipv6 isn't installed or if address array has a single address
if (socket == null || addresses.Count <= 1)
{
sortedAddresses = addresses;
}
else
{
CriticalAllocHandleSocketAddressList inputBuffer = null;
CriticalAllocHandleSocketAddressList outputBuffer = null;
try
{
inputBuffer = CriticalAllocHandleSocketAddressList.FromAddressList(addresses);
outputBuffer = CriticalAllocHandleSocketAddressList.FromAddressCount(0);
// Invoke ioctl to sort the addresses
int realOutputBufferSize;
int error = UnsafeNativeMethods.ERROR_SUCCESS;
int errorCode = PeerWinsock.WSAIoctl(socket.Handle,
unchecked((int)IOControlCode.AddressListSort),
(IntPtr)inputBuffer,
inputBuffer.Size,
(IntPtr)outputBuffer,
outputBuffer.Size,
out realOutputBufferSize,
IntPtr.Zero,
IntPtr.Zero);
if (errorCode == -1)
{
// Get the Win32 error code before doing anything else
error = Marshal.GetLastWin32Error();
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SocketException(error));
}
// Marshal the sorted SOCKET_ADDRESS_LIST into IPAddresses
sortedAddresses = outputBuffer.ToAddresses();
}
finally
{
if (inputBuffer != null) inputBuffer.Dispose();
if (outputBuffer != null) outputBuffer.Dispose();
}
}
return sortedAddresses;
}
}
// Type that converts from sockaddr_in6 to IPAddress and vice-versa
[Serializable, StructLayout(LayoutKind.Sequential)]
struct sockaddr_in6
{
short sin6_family;
ushort sin6_port;
uint sin6_flowinfo;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = addrByteCount)]
byte[] sin6_addr;
uint sin6_scope_id;
const int addrByteCount = 16;
// if the addr is v4-mapped-v6, 10th and 11th byte contain 0xFF. the last 4 bytes contain the ipv4 address
const int v4MapIndex = 10;
const int v4Index = v4MapIndex + 2;
public sockaddr_in6(IPAddress address)
{
if (address.AddressFamily == AddressFamily.InterNetworkV6)
{
this.sin6_addr = address.GetAddressBytes();
this.sin6_scope_id = (uint)address.ScopeId;
}
else
{
// Map v4 address to v4-mapped v6 addr (i.e., ::FFFF:XX.XX.XX.XX)
byte[] v4AddressBytes = address.GetAddressBytes();
this.sin6_addr = new byte[addrByteCount];
for (int i = 0; i < v4MapIndex; i++)
this.sin6_addr[i] = 0;
this.sin6_addr[v4MapIndex] = 0xff;
this.sin6_addr[v4MapIndex + 1] = 0xff;
for (int i = v4Index; i < addrByteCount; i++)
this.sin6_addr[i] = v4AddressBytes[i - v4Index];
this.sin6_scope_id = 0; // V4 address doesn't have a scope ID
}
this.sin6_family = (short)AddressFamily.InterNetworkV6;
this.sin6_port = 0;
this.sin6_flowinfo = 0;
}
public short Family { get { return this.sin6_family; } }
public uint FlowInfo { get { return this.sin6_flowinfo; } }
// Returns true if the address is a v4-mapped v6 address
// Adapted from ws2ipdef.w's IN6_IS_ADDR_V4MAPPED macro
private bool IsV4Mapped
{
get
{
// A v4-mapped v6 address will have the last 4 bytes contain the IPv4 address.
// The preceding 2 bytes contain 0xFFFF. All others are 0.
if (sin6_addr[v4MapIndex] != 0xff || sin6_addr[v4MapIndex + 1] != 0xff)
return false;
for (int i = 0; i < v4MapIndex; i++)
if (sin6_addr[i] != 0)
return false;
return true;
}
}
public ushort Port { get { return this.sin6_port; } }
// Converts a sockaddr_in6 to IPAddress
// A v4 mapped v6 address is converted to a v4 address
public IPAddress ToIPAddress()
{
if (!(this.sin6_family == (short)AddressFamily.InterNetworkV6))
{
throw Fx.AssertAndThrow("AddressFamily expected to be InterNetworkV6");
}
if (IsV4Mapped)
{
byte[] addr =
{
this.sin6_addr[v4Index],
this.sin6_addr[v4Index + 1],
this.sin6_addr[v4Index + 2],
this.sin6_addr[v4Index + 3]
};
return new IPAddress(addr);
}
else
{
return new IPAddress(this.sin6_addr, this.sin6_scope_id);
}
}
}
class CriticalAllocHandleSocketAddressList : CriticalAllocHandle
{
int count;
int size;
CriticalAllocHandleSocketAddress[] socketHandles;
public int Count { get { return count; } }
public int Size { get { return size; } }
public static CriticalAllocHandleSocketAddressList FromAddressList(ICollection<IPAddress> addresses)
{
if (addresses == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("addresses");
}
int count = addresses.Count;
CriticalAllocHandleSocketAddress[] socketHandles = new CriticalAllocHandleSocketAddress[SocketAddressList.maxAddresses];
SocketAddressList socketAddressList = new SocketAddressList(new SocketAddress[SocketAddressList.maxAddresses], count);
int i = 0;
foreach (IPAddress address in addresses)
{
if (i == SocketAddressList.maxAddresses) break; // due to Marshalling fixed sized array of SocketAddresses.
socketHandles[i] = CriticalAllocHandleSocketAddress.FromIPAddress(address);
socketAddressList.Addresses[i].InitializeFromCriticalAllocHandleSocketAddress(socketHandles[i]);
++i;
}
int size = Marshal.SizeOf(socketAddressList);
CriticalAllocHandleSocketAddressList result = CriticalAllocHandleSocketAddressList.FromSize(size);
result.count = count;
result.socketHandles = socketHandles;
Marshal.StructureToPtr(socketAddressList, result, false);
return result;
}
public static CriticalAllocHandleSocketAddressList FromAddressCount(int count)
{
SocketAddressList socketAddressList = new SocketAddressList(new SocketAddress[SocketAddressList.maxAddresses], 0);
int size = Marshal.SizeOf(socketAddressList);
CriticalAllocHandleSocketAddressList result = CriticalAllocHandleSocketAddressList.FromSize(size);
result.count = count;
Marshal.StructureToPtr(socketAddressList, result, false);
return result;
}
static new CriticalAllocHandleSocketAddressList FromSize(int size)
{
CriticalAllocHandleSocketAddressList result = new CriticalAllocHandleSocketAddressList();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally
{
result.SetHandle(Marshal.AllocHGlobal(size));
result.size = size;
}
return result;
}
public ReadOnlyCollection<IPAddress> ToAddresses()
{
SocketAddressList socketAddressList = (SocketAddressList)Marshal.PtrToStructure(this, typeof(SocketAddressList));
IPAddress[] addresses = new IPAddress[socketAddressList.Count];
for (int i = 0; i < addresses.Length; i++)
{
if (!(socketAddressList.Addresses[i].SockAddrLength == Marshal.SizeOf(typeof(sockaddr_in6))))
{
throw Fx.AssertAndThrow("sockAddressLength in SOCKET_ADDRESS expected to be valid");
}
sockaddr_in6 sockAddr = (sockaddr_in6)Marshal.PtrToStructure(socketAddressList.Addresses[i].SockAddr, typeof(sockaddr_in6));
addresses[i] = sockAddr.ToIPAddress();
}
return Array.AsReadOnly<IPAddress>(addresses);
}
}
class CriticalAllocHandleSocketAddress : CriticalAllocHandle
{
int size;
public int Size { get { return size; } }
public static CriticalAllocHandleSocketAddress FromIPAddress(IPAddress input)
{
if (input == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("input");
}
CriticalAllocHandleSocketAddress result = null;
int size = Marshal.SizeOf(typeof(sockaddr_in6));
result = CriticalAllocHandleSocketAddress.FromSize(size);
sockaddr_in6 sa = new sockaddr_in6(input);
Marshal.StructureToPtr(sa, (IntPtr)result, false);
return result;
}
public static new CriticalAllocHandleSocketAddress FromSize(int size)
{
CriticalAllocHandleSocketAddress result = new CriticalAllocHandleSocketAddress();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally
{
result.SetHandle(Marshal.AllocHGlobal(size));
result.size = size;
}
return result;
}
}
class CriticalAllocHandle : CriticalHandleZeroOrMinusOneIsInvalid
{
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static implicit operator IntPtr(CriticalAllocHandle safeHandle)
{
return (safeHandle != null) ? safeHandle.handle : (IntPtr)null;
}
protected override bool ReleaseHandle()
{
Marshal.FreeHGlobal(handle);
return true;
}
public static CriticalAllocHandle FromSize(int size)
{
CriticalAllocHandle result = new CriticalAllocHandle();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally
{
result.SetHandle(Marshal.AllocHGlobal(size));
}
return result;
}
}
class CriticalAllocHandleBlob : CriticalAllocHandle
{
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
public static CriticalAllocHandle FromBlob<T>(T id)
{
int size = Marshal.SizeOf(typeof(T));
CriticalAllocHandle result = CriticalAllocHandle.FromSize(size);
Marshal.StructureToPtr(id, (IntPtr)result, false);
return result;
}
}
class CriticalAllocHandleGuid : CriticalAllocHandle
{
public static CriticalAllocHandle FromGuid(Guid input)
{
int guidSize = Marshal.SizeOf(typeof(Guid));
CriticalAllocHandle result = CriticalAllocHandle.FromSize(guidSize);
Marshal.Copy(input.ToByteArray(), 0, (IntPtr)result, guidSize);
return result;
}
}
}