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

530 lines
19 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.NetworkInformation;
using System.Net.Sockets;
using System.Runtime;
using System.ServiceModel;
using System.Threading;
// IP address helper class for multi-homing support
class PeerIPHelper
{
public event EventHandler AddressChanged;
bool isOpen;
readonly IPAddress listenAddress; // To listen on a single IP address.
IPAddress[] localAddresses;
AddressChangeHelper addressChangeHelper;
Socket ipv6Socket;
object thisLock;
const uint Six2FourPrefix = 0x220;
const uint TeredoPrefix = 0x00000120;
const uint IsatapIdentifier = 0xfe5e0000;
enum AddressType
{
Unknown,
Teredo,
Isatap,
Six2Four
}
public PeerIPHelper()
{
Initialize();
}
public PeerIPHelper(IPAddress listenAddress)
{
if (!(listenAddress != null))
{
throw Fx.AssertAndThrow("listenAddress expected to be non-null");
}
this.listenAddress = listenAddress;
Initialize();
}
void Initialize()
{
this.localAddresses = new IPAddress[0];
this.thisLock = new object();
}
// NOTE: This is just for suites -- to skip timeout usage
internal int AddressChangeWaitTimeout
{
set { this.addressChangeHelper.Timeout = value; }
}
object ThisLock
{
get { return this.thisLock; }
}
// Compares if the specified collection matches our local cache. Return true on mismatch.
public bool AddressesChanged(ReadOnlyCollection<IPAddress> addresses)
{
bool changed = false;
lock (ThisLock)
{
if (addresses.Count != this.localAddresses.Length)
{
changed = true;
}
else
{
// If every specified addresses exist in the cache, addresses haven't changed
foreach (IPAddress address in this.localAddresses)
{
if (!addresses.Contains(address))
{
changed = true;
break;
}
}
}
}
return changed;
}
// Since scope ID of IPAddress is mutable, you want to be able to clone an IP address
public static IPAddress CloneAddress(IPAddress source, bool maskScopeId)
{
IPAddress clone = null;
if (maskScopeId || V4Address(source))
clone = new IPAddress(source.GetAddressBytes());
else
clone = new IPAddress(source.GetAddressBytes(), source.ScopeId);
return clone;
}
// Since scope ID of IPAddress is mutable, you want to be able to clone IP addresses in an array or collection
static ReadOnlyCollection<IPAddress> CloneAddresses(IPAddress[] sourceArray)
{
IPAddress[] cloneArray = new IPAddress[sourceArray.Length];
for (int i = 0; i < sourceArray.Length; i++)
{
cloneArray[i] = CloneAddress(sourceArray[i], false);
}
return new ReadOnlyCollection<IPAddress>(cloneArray);
}
public static ReadOnlyCollection<IPAddress> CloneAddresses(ReadOnlyCollection<IPAddress> sourceCollection, bool maskScopeId)
{
IPAddress[] cloneArray = new IPAddress[sourceCollection.Count];
for (int i = 0; i < sourceCollection.Count; i++)
{
cloneArray[i] = CloneAddress(sourceCollection[i], maskScopeId);
}
return new ReadOnlyCollection<IPAddress>(cloneArray);
}
// When listening on a specific IP address, creates an array containing just that address
static IPAddress[] CreateAddressArray(IPAddress address)
{
IPAddress[] addressArray = new IPAddress[1];
addressArray[0] = CloneAddress(address, false);
return addressArray;
}
public void Close()
{
if (this.isOpen)
{
lock (ThisLock)
{
if (this.isOpen)
{
this.addressChangeHelper.Unregister();
if (this.ipv6Socket != null)
{
this.ipv6Socket.Close();
}
this.isOpen = false;
this.addressChangeHelper = null;
}
}
}
}
// Retrieve the IP addresses configured on the machine.
IPAddress[] GetAddresses()
{
List<IPAddress> addresses = new List<IPAddress>();
List<IPAddress> temporaryAddresses = new List<IPAddress>();
if (this.listenAddress != null) // single local address scenario?
{
// Check if the specified address is configured
if (ValidAddress(this.listenAddress))
{
return (CreateAddressArray(this.listenAddress));
}
}
// Walk the interfaces
NetworkInterface[] networkIfs = NetworkInterface.GetAllNetworkInterfaces();
foreach (NetworkInterface networkIf in networkIfs)
{
if (!ValidInterface(networkIf))
{
continue;
}
// Process each unicast address for the interface. Pick at most one IPv4 and one IPv6 address.
// Add remaining eligible addresses on the list to surplus list. We can add these back to the list
// being returned, if there is room.
IPInterfaceProperties properties = networkIf.GetIPProperties();
if (properties != null)
{
foreach (UnicastIPAddressInformation unicastAddress in properties.UnicastAddresses)
{
if (NonTransientAddress(unicastAddress))
{
if (unicastAddress.SuffixOrigin == SuffixOrigin.Random)
temporaryAddresses.Add(unicastAddress.Address);
else
addresses.Add(unicastAddress.Address);
}
}
}
}
if (addresses.Count > 0)
return ReorderAddresses(addresses);
else
return temporaryAddresses.ToArray();
}
internal static IPAddress[] ReorderAddresses(IEnumerable<IPAddress> sourceAddresses)
{
List<IPAddress> result = new List<IPAddress>();
List<IPAddress> notAdded = new List<IPAddress>();
AddressType addressType = AddressType.Unknown;
IPAddress v4Address = null, v6Address = null, isatapAddress = null, teredoAddress = null, six2FourAddress = null;
foreach (IPAddress address in sourceAddresses)
{
if (address.AddressFamily == AddressFamily.InterNetwork)
{
if (v4Address != null)
notAdded.Add(address);
else
{
v4Address = address;
}
continue;
}
if (address.AddressFamily != AddressFamily.InterNetworkV6)
{
notAdded.Add(address);
continue;
}
if (address.IsIPv6LinkLocal || address.IsIPv6SiteLocal)
{
notAdded.Add(address);
continue;
}
addressType = GetAddressType(address);
switch (addressType)
{
case AddressType.Teredo:
{
if (teredoAddress == null)
{
teredoAddress = address;
}
else
{
notAdded.Add(address);
}
continue;
}
case AddressType.Six2Four:
{
if (six2FourAddress == null)
{
six2FourAddress = address;
}
else
{
notAdded.Add(address);
}
continue;
}
case AddressType.Isatap:
{
if (isatapAddress == null)
{
isatapAddress = address;
}
else
{
notAdded.Add(address);
}
continue;
}
default:
{
if (v6Address != null)
notAdded.Add(address);
else
{
v6Address = address;
}
continue;
}
}
}
if (six2FourAddress != null)
result.Add(six2FourAddress);
if (teredoAddress != null)
result.Add(teredoAddress);
if (isatapAddress != null)
result.Add(isatapAddress);
if (v6Address != null)
result.Add(v6Address);
if (v4Address != null)
result.Add(v4Address);
result.AddRange(notAdded);
return result.ToArray();
}
static AddressType GetAddressType(IPAddress address)
{
AddressType result = AddressType.Unknown;
byte[] bytes = address.GetAddressBytes();
if (BitConverter.ToUInt16(bytes, 0) == Six2FourPrefix)
result = AddressType.Six2Four;
else if (BitConverter.ToUInt32(bytes, 0) == TeredoPrefix)
result = AddressType.Teredo;
else if (BitConverter.ToUInt32(bytes, 8) == IsatapIdentifier)
result = AddressType.Isatap;
return result;
}
// Given an EPR, replaces its URI with the specified IP address
public static EndpointAddress GetIPEndpointAddress(EndpointAddress epr, IPAddress address)
{
EndpointAddressBuilder eprBuilder = new EndpointAddressBuilder(epr);
eprBuilder.Uri = GetIPUri(epr.Uri, address);
return eprBuilder.ToEndpointAddress();
}
// Given a hostName based URI, replaces hostName with the IP address
public static Uri GetIPUri(Uri uri, IPAddress ipAddress)
{
UriBuilder uriBuilder = new UriBuilder(uri);
if (V6Address(ipAddress) && (ipAddress.IsIPv6LinkLocal || ipAddress.IsIPv6SiteLocal))
{
// We make a copy of the IP address because scopeID will not be part of ToString() if set after IP address was created
uriBuilder.Host = new IPAddress(ipAddress.GetAddressBytes(), ipAddress.ScopeId).ToString();
}
else
{
uriBuilder.Host = ipAddress.ToString();
}
return uriBuilder.Uri;
}
// Retrieve the currently configured addresses (cached)
public ReadOnlyCollection<IPAddress> GetLocalAddresses()
{
lock (ThisLock)
{
// Return a clone of the address cache
return CloneAddresses(this.localAddresses);
}
}
// An address is valid if it is a non-transient addresss (if global, must be DNS-eligible as well)
static bool NonTransientAddress(UnicastIPAddressInformation address)
{
return (!address.IsTransient);
}
public static bool V4Address(IPAddress address)
{
return address.AddressFamily == AddressFamily.InterNetwork;
}
public static bool V6Address(IPAddress address)
{
return address.AddressFamily == AddressFamily.InterNetworkV6;
}
// Returns true if the specified address is configured on the machine
public static bool ValidAddress(IPAddress address)
{
// Walk the interfaces
NetworkInterface[] networkIfs = NetworkInterface.GetAllNetworkInterfaces();
foreach (NetworkInterface networkIf in networkIfs)
{
if (ValidInterface(networkIf))
{
IPInterfaceProperties properties = networkIf.GetIPProperties();
if (properties != null)
{
foreach (UnicastIPAddressInformation unicastAddress in properties.UnicastAddresses)
{
if (address.Equals(unicastAddress.Address))
{
return true;
}
}
}
}
}
return false;
}
static bool ValidInterface(NetworkInterface networkIf)
{
return (networkIf.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
networkIf.OperationalStatus == OperationalStatus.Up);
}
// Process the address change notification from the system and check if the addresses
// have really changed. If so, update the local cache and notify interested parties.
void OnAddressChanged()
{
bool changed = false;
IPAddress[] newAddresses = GetAddresses();
lock (ThisLock)
{
if (AddressesChanged(Array.AsReadOnly<IPAddress>(newAddresses)))
{
this.localAddresses = newAddresses;
changed = true;
}
}
if (changed)
{
EventHandler handler = AddressChanged;
if (handler != null && this.isOpen)
{
handler(this, EventArgs.Empty);
}
}
}
public void Open()
{
lock (ThisLock)
{
Fx.Assert(!this.isOpen, "Helper not expected to be open");
// Register for addr changed event and retrieve addresses from the system
this.addressChangeHelper = new AddressChangeHelper(OnAddressChanged);
this.localAddresses = GetAddresses();
if (Socket.OSSupportsIPv6)
{
this.ipv6Socket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.IP);
}
this.isOpen = true;
}
}
// Sorts the collection of addresses using sort ioctl
public ReadOnlyCollection<IPAddress> SortAddresses(ReadOnlyCollection<IPAddress> addresses)
{
ReadOnlyCollection<IPAddress> sortedAddresses = SocketAddressList.SortAddresses(this.ipv6Socket, listenAddress, addresses);
// If listening on specific address, copy the scope ID that we're listing on for the
// link and site local addresses in the sorted list (so that the connect will work)
if (this.listenAddress != null)
{
if (this.listenAddress.IsIPv6LinkLocal)
{
foreach (IPAddress address in sortedAddresses)
{
if (address.IsIPv6LinkLocal)
{
address.ScopeId = this.listenAddress.ScopeId;
}
}
}
else if (this.listenAddress.IsIPv6SiteLocal)
{
foreach (IPAddress address in sortedAddresses)
{
if (address.IsIPv6SiteLocal)
{
address.ScopeId = this.listenAddress.ScopeId;
}
}
}
}
return sortedAddresses;
}
//
// Helper class to handle system address change events. Because multiple events can be fired as a result of
// a single significant change (such as interface being enabled/disabled), we try to handle the event just
// once using the below mechanism:
// Start a timer that goes off after Timeout seconds. If get another address change event from the system
// within this timespan, reset the timer to go off after another Timeout secs. When the timer finally fires,
// the registered handlers are notified. This should minimize (but not completely eliminate -- think wireless
// DHCP interface being enabled, for instance -- this could take longer) reacting multiple times for
// a single change.
//
class AddressChangeHelper
{
public delegate void AddedChangedCallback();
// To avoid processing multiple addr change events within this time span (5 seconds)
public int Timeout = 5000;
IOThreadTimer timer;
AddedChangedCallback addressChanged;
public AddressChangeHelper(AddedChangedCallback addressChanged)
{
Fx.Assert(addressChanged != null, "addressChanged expected to be non-null");
this.addressChanged = addressChanged;
this.timer = new IOThreadTimer(new Action<object>(FireAddressChange), null, true);
NetworkChange.NetworkAddressChanged += OnAddressChange;
}
public void Unregister()
{
NetworkChange.NetworkAddressChanged -= OnAddressChange;
}
void OnAddressChange(object sender, EventArgs args)
{
this.timer.Set(Timeout);
}
// Now fire address change event to the interested parties
void FireAddressChange(object asyncState)
{
this.timer.Cancel();
this.addressChanged();
}
}
}
}