|
|
@@ -1,529 +0,0 @@
|
|
|
-//
|
|
|
-// System.Net.IPAddress.cs
|
|
|
-//
|
|
|
-// Author:
|
|
|
-// Miguel de Icaza ([email protected])
|
|
|
-// Lawrence Pit ([email protected])
|
|
|
-//
|
|
|
-// (C) Ximian, Inc. http://www.ximian.com
|
|
|
-//
|
|
|
-// Permission is hereby granted, free of charge, to any person obtaining
|
|
|
-// a copy of this software and associated documentation files (the
|
|
|
-// "Software"), to deal in the Software without restriction, including
|
|
|
-// without limitation the rights to use, copy, modify, merge, publish,
|
|
|
-// distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
-// permit persons to whom the Software is furnished to do so, subject to
|
|
|
-// the following conditions:
|
|
|
-//
|
|
|
-// The above copyright notice and this permission notice shall be
|
|
|
-// included in all copies or substantial portions of the Software.
|
|
|
-//
|
|
|
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
|
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
|
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
|
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
-//
|
|
|
-
|
|
|
-using System;
|
|
|
-using System.Globalization;
|
|
|
-using System.Net.Sockets;
|
|
|
-using System.Runtime.InteropServices;
|
|
|
-
|
|
|
-namespace System.Net {
|
|
|
-
|
|
|
- /// <remarks>
|
|
|
- /// Encapsulates an IP Address.
|
|
|
- /// </remarks>
|
|
|
- [Serializable]
|
|
|
- public class IPAddress {
|
|
|
- // Don't change the name of this field without also
|
|
|
- // changing socket-io.c in the runtime
|
|
|
- // The IP address is stored in little-endian order inside the int,
|
|
|
- // meaning the lower order bytes contain the netid
|
|
|
- private long m_Address;
|
|
|
- private AddressFamily m_Family;
|
|
|
- private ushort[] m_Numbers; /// ip6 Stored in network order (as ip4)
|
|
|
- private long m_ScopeId;
|
|
|
-
|
|
|
- public static readonly IPAddress Any = new IPAddress(0);
|
|
|
- public static readonly IPAddress Broadcast = IPAddress.Parse ("255.255.255.255");
|
|
|
- public static readonly IPAddress Loopback = IPAddress.Parse ("127.0.0.1");
|
|
|
- public static readonly IPAddress None = IPAddress.Parse ("255.255.255.255");
|
|
|
- public static readonly IPAddress IPv6Any = IPAddress.ParseIPV6 ("::");
|
|
|
- public static readonly IPAddress IPv6Loopback = IPAddress.ParseIPV6 ("::1");
|
|
|
- public static readonly IPAddress IPv6None = IPAddress.ParseIPV6 ("::");
|
|
|
-
|
|
|
- private static short SwapShort (short number)
|
|
|
- {
|
|
|
- return (short) ( ((number >> 8) & 0xFF) | ((number << 8) & 0xFF00) );
|
|
|
- }
|
|
|
-
|
|
|
- private static int SwapInt (int number)
|
|
|
- {
|
|
|
- return (((number >> 24) & 0xFF)
|
|
|
- | ((number >> 08) & 0xFF00)
|
|
|
- | ((number << 08) & 0xFF0000)
|
|
|
- | ((number << 24)));
|
|
|
- }
|
|
|
-
|
|
|
- private static long SwapLong(long number)
|
|
|
- {
|
|
|
- return (((number >> 56) & 0xFF)
|
|
|
- | ((number >> 40) & 0xFF00)
|
|
|
- | ((number >> 24) & 0xFF0000)
|
|
|
- | ((number >> 08) & 0xFF000000)
|
|
|
- | ((number << 08) & 0xFF00000000)
|
|
|
- | ((number << 24) & 0xFF0000000000)
|
|
|
- | ((number << 40) & 0xFF000000000000)
|
|
|
- | ((number << 56)));
|
|
|
- }
|
|
|
-
|
|
|
- public static short HostToNetworkOrder(short host) {
|
|
|
- if (!BitConverter.IsLittleEndian)
|
|
|
- return(host);
|
|
|
-
|
|
|
- return SwapShort (host);
|
|
|
- }
|
|
|
-
|
|
|
- public static int HostToNetworkOrder(int host) {
|
|
|
- if (!BitConverter.IsLittleEndian)
|
|
|
- return(host);
|
|
|
-
|
|
|
- return SwapInt (host);
|
|
|
- }
|
|
|
-
|
|
|
- public static long HostToNetworkOrder(long host) {
|
|
|
- if (!BitConverter.IsLittleEndian)
|
|
|
- return(host);
|
|
|
-
|
|
|
- return SwapLong (host);
|
|
|
- }
|
|
|
-
|
|
|
- public static short NetworkToHostOrder(short network) {
|
|
|
- if (!BitConverter.IsLittleEndian)
|
|
|
- return(network);
|
|
|
-
|
|
|
- return SwapShort (network);
|
|
|
- }
|
|
|
-
|
|
|
- public static int NetworkToHostOrder(int network) {
|
|
|
- if (!BitConverter.IsLittleEndian)
|
|
|
- return(network);
|
|
|
-
|
|
|
- return SwapInt (network);
|
|
|
- }
|
|
|
-
|
|
|
- public static long NetworkToHostOrder(long network) {
|
|
|
- if (!BitConverter.IsLittleEndian)
|
|
|
- return(network);
|
|
|
-
|
|
|
- return SwapLong (network);
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Constructor from a 32-bit constant with the address bytes in
|
|
|
- /// little-endian order (the lower order bytes contain the netid)
|
|
|
- /// </summary>
|
|
|
- public IPAddress (long newAddress)
|
|
|
- {
|
|
|
- m_Address = newAddress;
|
|
|
- m_Family = AddressFamily.InterNetwork;
|
|
|
- }
|
|
|
-
|
|
|
- public IPAddress (byte[] address)
|
|
|
- {
|
|
|
- if (address == null)
|
|
|
- throw new ArgumentNullException ("address");
|
|
|
-
|
|
|
- int len = address.Length;
|
|
|
-
|
|
|
- if (len != 16 && len != 4)
|
|
|
- throw new ArgumentException ("An invalid IP address was specified.",
|
|
|
- "address");
|
|
|
-
|
|
|
- if (len == 16) {
|
|
|
- m_Numbers = new ushort [8];
|
|
|
- Buffer.BlockCopy(address, 0, m_Numbers, 0, 16);
|
|
|
- m_Family = AddressFamily.InterNetworkV6;
|
|
|
- m_ScopeId = 0;
|
|
|
- } else {
|
|
|
- m_Address = ((uint) address [3] << 24) + (address [2] << 16) +
|
|
|
- (address [1] << 8) + address [0];
|
|
|
- m_Family = AddressFamily.InterNetwork;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- public IPAddress(byte[] address, long scopeid)
|
|
|
- {
|
|
|
- if (address == null)
|
|
|
- throw new ArgumentNullException ("address");
|
|
|
-
|
|
|
- if (address.Length != 16)
|
|
|
- throw new ArgumentException ("An invalid IP address was specified.",
|
|
|
- "address");
|
|
|
-
|
|
|
- m_Numbers = new ushort [8];
|
|
|
- Buffer.BlockCopy(address, 0, m_Numbers, 0, 16);
|
|
|
- m_Family = AddressFamily.InterNetworkV6;
|
|
|
- m_ScopeId = scopeid;
|
|
|
- }
|
|
|
-
|
|
|
- internal IPAddress(ushort[] address, long scopeId)
|
|
|
- {
|
|
|
- m_Numbers = address;
|
|
|
-
|
|
|
- for(int i=0; i<8; i++)
|
|
|
- m_Numbers[i] = (ushort)HostToNetworkOrder((short)m_Numbers[i]);
|
|
|
-
|
|
|
- m_Family = AddressFamily.InterNetworkV6;
|
|
|
- m_ScopeId = scopeId;
|
|
|
- }
|
|
|
-
|
|
|
- public static IPAddress Parse (string ipString)
|
|
|
- {
|
|
|
- if (ipString == null)
|
|
|
- throw new ArgumentNullException("ipString");
|
|
|
-
|
|
|
- IPAddress ret;
|
|
|
- if (TryParse (ipString, out ret))
|
|
|
- return ret;
|
|
|
- throw new FormatException ("An invalid IP address was specified.");
|
|
|
- }
|
|
|
-
|
|
|
- public static bool TryParse (string ipString, out IPAddress address)
|
|
|
- {
|
|
|
- if (ipString == null)
|
|
|
- {
|
|
|
- address = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- if ((address = ParseIPV4 (ipString)) == null)
|
|
|
- if ((address = ParseIPV6 (ipString)) == null)
|
|
|
- return false;
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- private static IPAddress ParseIPV4 (string ip)
|
|
|
- {
|
|
|
-
|
|
|
- int pos = ip.IndexOf (' ');
|
|
|
- if (pos != -1) {
|
|
|
- string [] nets = ip.Substring (pos + 1).Split (new char [] {'.'});
|
|
|
- if (nets.Length > 0) {
|
|
|
- string lastNet = nets [nets.Length - 1];
|
|
|
- if (lastNet.Length == 0)
|
|
|
- return null;
|
|
|
- foreach (char c in lastNet)
|
|
|
- if (!Uri.IsHexDigit (c))
|
|
|
- return null;
|
|
|
- }
|
|
|
- ip = ip.Substring (0, pos);
|
|
|
- }
|
|
|
-
|
|
|
- if (ip.Length == 0 || ip [ip.Length - 1] == '.')
|
|
|
- return null;
|
|
|
-
|
|
|
- string [] ips = ip.Split (new char [] {'.'});
|
|
|
- if (ips.Length > 4)
|
|
|
- return null;
|
|
|
-
|
|
|
- // Make the number in network order
|
|
|
- try {
|
|
|
- long a = 0;
|
|
|
- long val = 0;
|
|
|
- for (int i = 0; i < ips.Length; i++) {
|
|
|
- string subnet = ips [i];
|
|
|
- if ((3 <= subnet.Length && subnet.Length <= 4) &&
|
|
|
- (subnet [0] == '0') && (subnet [1] == 'x' || subnet [1] == 'X')) {
|
|
|
- if (subnet.Length == 3)
|
|
|
- val = (byte) Uri.FromHex (subnet [2]);
|
|
|
- else
|
|
|
- val = (byte) ((Uri.FromHex (subnet [2]) << 4) | Uri.FromHex (subnet [3]));
|
|
|
- } else if (subnet.Length == 0)
|
|
|
- return null;
|
|
|
- else if (subnet [0] == '0') {
|
|
|
- // octal
|
|
|
- val = 0;
|
|
|
- for (int j = 1; j < subnet.Length; j++) {
|
|
|
- if ('0' <= subnet [j] && subnet [j] <= '7')
|
|
|
- val = (val << 3) + subnet [j] - '0';
|
|
|
- else
|
|
|
- return null;
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- if (!Int64.TryParse (subnet, NumberStyles.None, null, out val))
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- if (i == (ips.Length - 1)) {
|
|
|
- if (i != 0 && val >= (256 << ((3 - i) * 8)))
|
|
|
- return null;
|
|
|
- else if (val > 0xffffffff)
|
|
|
- return null;
|
|
|
- i = 3;
|
|
|
- } else if (val >= 0x100)
|
|
|
- return null;
|
|
|
- for (int j = 0; val > 0; j++, val /= 0x100)
|
|
|
- a |= (val & 0xFF) << ((i - j) << 3);
|
|
|
- }
|
|
|
-
|
|
|
- return (new IPAddress (a));
|
|
|
- } catch (Exception) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- private static IPAddress ParseIPV6 (string ip)
|
|
|
- {
|
|
|
- IPv6Address newIPv6Address;
|
|
|
-
|
|
|
- if (IPv6Address.TryParse(ip, out newIPv6Address))
|
|
|
- return new IPAddress (newIPv6Address.Address, newIPv6Address.ScopeId);
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- [Obsolete("This property is obsolete. Use GetAddressBytes.")]
|
|
|
- public long Address
|
|
|
- {
|
|
|
- get {
|
|
|
- if(m_Family != AddressFamily.InterNetwork)
|
|
|
- throw new Exception("The attempted operation is not supported for the type of object referenced");
|
|
|
-
|
|
|
- return m_Address;
|
|
|
- }
|
|
|
- set {
|
|
|
- /* no need to do this test, ms.net accepts any value.
|
|
|
- if (value < 0 || value > 0x00000000FFFFFFFF)
|
|
|
- throw new ArgumentOutOfRangeException (
|
|
|
- "the address must be between 0 and 0xFFFFFFFF");
|
|
|
- */
|
|
|
-
|
|
|
- if(m_Family != AddressFamily.InterNetwork)
|
|
|
- throw new Exception("The attempted operation is not supported for the type of object referenced");
|
|
|
-
|
|
|
- m_Address = value;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- internal long InternalIPv4Address {
|
|
|
- get { return m_Address; }
|
|
|
- }
|
|
|
-
|
|
|
- public bool IsIPv6LinkLocal {
|
|
|
- get {
|
|
|
- if (m_Family == AddressFamily.InterNetwork)
|
|
|
- return false;
|
|
|
- int v = NetworkToHostOrder ((short) m_Numbers [0]) & 0xFFF0;
|
|
|
- return 0xFE80 <= v && v < 0xFEC0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- public bool IsIPv6SiteLocal {
|
|
|
- get {
|
|
|
- if (m_Family == AddressFamily.InterNetwork)
|
|
|
- return false;
|
|
|
- int v = NetworkToHostOrder ((short) m_Numbers [0]) & 0xFFF0;
|
|
|
- return 0xFEC0 <= v && v < 0xFF00;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- public bool IsIPv6Multicast {
|
|
|
- get {
|
|
|
- return m_Family != AddressFamily.InterNetwork &&
|
|
|
- ((ushort) NetworkToHostOrder ((short) m_Numbers [0]) & 0xFF00) == 0xFF00;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- public bool IsIPv6Teredo {
|
|
|
- get {
|
|
|
- return m_Family != AddressFamily.InterNetwork &&
|
|
|
- NetworkToHostOrder ((short) m_Numbers [0]) == 0x2001 &&
|
|
|
- m_Numbers[1] == 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- public long ScopeId {
|
|
|
- get {
|
|
|
- if (m_Family != AddressFamily.InterNetworkV6)
|
|
|
- throw new SocketException ((int) SocketError.OperationNotSupported);
|
|
|
-
|
|
|
- return m_ScopeId;
|
|
|
- }
|
|
|
- set {
|
|
|
- if (m_Family != AddressFamily.InterNetworkV6)
|
|
|
- throw new SocketException ((int) SocketError.OperationNotSupported);
|
|
|
- if ((value < 0) || (value > UInt32.MaxValue))
|
|
|
- throw new ArgumentOutOfRangeException ();
|
|
|
-
|
|
|
- m_ScopeId = value;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- public byte [] GetAddressBytes ()
|
|
|
- {
|
|
|
- if(m_Family == AddressFamily.InterNetworkV6) {
|
|
|
- byte [] addressBytes = new byte [16];
|
|
|
- Buffer.BlockCopy (m_Numbers, 0, addressBytes, 0, 16);
|
|
|
- return addressBytes;
|
|
|
- } else {
|
|
|
- return new byte [4] { (byte)(m_Address & 0xFF),
|
|
|
- (byte)((m_Address >> 8) & 0xFF),
|
|
|
- (byte)((m_Address >> 16) & 0xFF),
|
|
|
- (byte)(m_Address >> 24) };
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- public AddressFamily AddressFamily
|
|
|
- {
|
|
|
- get {
|
|
|
- return m_Family;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-#if NET_4_5
|
|
|
-
|
|
|
- public IPAddress MapToIPv4 ()
|
|
|
- {
|
|
|
- if (AddressFamily == AddressFamily.InterNetwork)
|
|
|
- return this;
|
|
|
- if (AddressFamily != AddressFamily.InterNetworkV6)
|
|
|
- throw new Exception ("Only AddressFamily.InterNetworkV6 can be converted to IPv4");
|
|
|
-
|
|
|
- //Test for 0000 0000 0000 0000 0000 FFFF xxxx xxxx
|
|
|
- for (int i = 0; i < 5; i++) {
|
|
|
- if (m_Numbers [i] != 0x0000)
|
|
|
- throw new Exception ("Address does not have the ::FFFF prefix");
|
|
|
- }
|
|
|
- if (m_Numbers [5] != 0xFFFF)
|
|
|
- throw new Exception ("Address does not have the ::FFFF prefix");
|
|
|
-
|
|
|
- //We've got an IPv4 address
|
|
|
- byte [] ipv4Bytes = new byte [4];
|
|
|
- Buffer.BlockCopy (m_Numbers, 12, ipv4Bytes, 0, 4);
|
|
|
- return new IPAddress (ipv4Bytes);
|
|
|
- }
|
|
|
-
|
|
|
- public IPAddress MapToIPv6 ()
|
|
|
- {
|
|
|
- if (AddressFamily == AddressFamily.InterNetworkV6)
|
|
|
- return this;
|
|
|
- if (AddressFamily != AddressFamily.InterNetwork)
|
|
|
- throw new Exception ("Only AddressFamily.InterNetworkV4 can be converted to IPv6");
|
|
|
-
|
|
|
- byte [] ipv4Bytes = GetAddressBytes ();
|
|
|
- byte [] ipv6Bytes = new byte [16] {
|
|
|
- 0,0, 0,0, 0,0, 0,0, 0,0, 0xFF,0xFF,
|
|
|
- ipv4Bytes [0], ipv4Bytes [1], ipv4Bytes [2], ipv4Bytes [3]
|
|
|
- };
|
|
|
- return new IPAddress (ipv6Bytes);
|
|
|
- }
|
|
|
-
|
|
|
-#endif
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Used to tell whether an address is a loopback.
|
|
|
- /// All IP addresses of the form 127.X.Y.Z, where X, Y, and Z are in
|
|
|
- /// the range 0-255, are loopback addresses.
|
|
|
- /// </summary>
|
|
|
- /// <param name="addr">Address to compare</param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool IsLoopback (IPAddress address)
|
|
|
- {
|
|
|
- if(address.m_Family == AddressFamily.InterNetwork)
|
|
|
- return (address.m_Address & 0xFF) == 127;
|
|
|
- else {
|
|
|
- for(int i=0; i<6; i++) {
|
|
|
- if(address.m_Numbers[i] != 0)
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- return NetworkToHostOrder((short)address.m_Numbers[7]) == 1;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Overrides System.Object.ToString to return
|
|
|
- /// this object rendered in a quad-dotted notation
|
|
|
- /// </summary>
|
|
|
- public override string ToString ()
|
|
|
- {
|
|
|
- if(m_Family == AddressFamily.InterNetwork)
|
|
|
- return ToString (m_Address);
|
|
|
- else
|
|
|
- {
|
|
|
- ushort[] numbers = m_Numbers.Clone() as ushort[];
|
|
|
-
|
|
|
- for(int i=0; i<numbers.Length; i++)
|
|
|
- numbers[i] = (ushort)NetworkToHostOrder((short)numbers[i]);
|
|
|
-
|
|
|
- IPv6Address v6 = new IPv6Address(numbers);
|
|
|
- v6.ScopeId = ScopeId;
|
|
|
- return v6.ToString();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Returns this object rendered in a quad-dotted notation
|
|
|
- /// </summary>
|
|
|
- static string ToString (long addr)
|
|
|
- {
|
|
|
- // addr is in network order
|
|
|
- return (addr & 0xff).ToString () + "." +
|
|
|
- ((addr >> 8) & 0xff).ToString () + "." +
|
|
|
- ((addr >> 16) & 0xff).ToString () + "." +
|
|
|
- ((addr >> 24) & 0xff).ToString ();
|
|
|
- }
|
|
|
-
|
|
|
- /// <returns>
|
|
|
- /// Whether both objects are equal.
|
|
|
- /// </returns>
|
|
|
- public override bool Equals (object comparand)
|
|
|
- {
|
|
|
- IPAddress otherAddr = comparand as IPAddress;
|
|
|
- if (otherAddr != null){
|
|
|
- if(AddressFamily != otherAddr.AddressFamily)
|
|
|
- return false;
|
|
|
-
|
|
|
- if(AddressFamily == AddressFamily.InterNetwork) {
|
|
|
- return m_Address == otherAddr.m_Address;
|
|
|
- } else {
|
|
|
- ushort[] vals = otherAddr.m_Numbers;
|
|
|
-
|
|
|
- for(int i=0; i<8; i++)
|
|
|
- if(m_Numbers[i] != vals[i])
|
|
|
- return false;
|
|
|
-
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- public override int GetHashCode ()
|
|
|
- {
|
|
|
- if(m_Family == AddressFamily.InterNetwork)
|
|
|
- return (int)m_Address;
|
|
|
- else
|
|
|
- return Hash (((((int) m_Numbers[0]) << 16) + m_Numbers [1]),
|
|
|
- ((((int) m_Numbers [2]) << 16) + m_Numbers [3]),
|
|
|
- ((((int) m_Numbers [4]) << 16) + m_Numbers [5]),
|
|
|
- ((((int) m_Numbers [6]) << 16) + m_Numbers [7]));
|
|
|
- }
|
|
|
-
|
|
|
- private static int Hash (int i, int j, int k, int l)
|
|
|
- {
|
|
|
- return i ^ (j << 13 | j >> 19) ^ (k << 26 | k >> 6) ^ (l << 7 | l >> 25);
|
|
|
- }
|
|
|
-
|
|
|
-#pragma warning disable 169
|
|
|
- // Added for serialization compatibility with MS.NET
|
|
|
- private int m_HashCode;
|
|
|
-#pragma warning restore
|
|
|
-
|
|
|
- }
|
|
|
-}
|