The Labs \ Source Viewer \ SSCLI \ System.Net \ IPEndPoint

  1. //------------------------------------------------------------------------------
  2. // <copyright file="IPEndPoint.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Net
  16. {
  17.     using System.Net.Sockets;
  18.     using System.Globalization;
  19.    
  20.     /// <devdoc>
  21.     /// <para>
  22.     /// Provides an IP address.
  23.     /// </para>
  24.     /// </devdoc>
  25.     [Serializable()]
  26.     public class IPEndPoint : EndPoint
  27.     {
  28.         /// <devdoc>
  29.         /// <para>
  30.         /// Specifies the minimum acceptable value for the <see cref='System.Net.IPEndPoint.Port'/>
  31.         /// property.
  32.         /// </para>
  33.         /// </devdoc>
  34.         public const int MinPort = 0;
  35.         /// <devdoc>
  36.         /// <para>
  37.         /// Specifies the maximum acceptable value for the <see cref='System.Net.IPEndPoint.Port'/>
  38.         /// property.
  39.         /// </para>
  40.         /// </devdoc>
  41.         public const int MaxPort = 65535;
  42.        
  43.         private IPAddress m_Address;
  44.         private int m_Port;
  45.        
  46.         internal const int AnyPort = MinPort;
  47.        
  48.         static internal IPEndPoint Any = new IPEndPoint(IPAddress.Any, AnyPort);
  49.         static internal IPEndPoint IPv6Any = new IPEndPoint(IPAddress.IPv6Any, AnyPort);
  50.        
  51.        
  52.         /// <devdoc>
  53.         /// <para>[To be supplied.]</para>
  54.         /// </devdoc>
  55.         public override AddressFamily AddressFamily {
  56. //
  57. // IPv6 Changes: Always delegate this to the address we are
  58. // wrapping.
  59. //
  60.             get { return m_Address.AddressFamily; }
  61.         }
  62.        
  63.         /// <devdoc>
  64.         /// <para>Creates a new instance of the IPEndPoint class with the specified address and
  65.         /// port.</para>
  66.         /// </devdoc>
  67.         public IPEndPoint(long address, int port)
  68.         {
  69.             if (!ValidationHelper.ValidateTcpPort(port)) {
  70.                 throw new ArgumentOutOfRangeException("port");
  71.             }
  72.             m_Port = port;
  73.             m_Address = new IPAddress(address);
  74.         }
  75.        
  76.         /// <devdoc>
  77.         /// <para>Creates a new instance of the IPEndPoint class with the specified address and port.</para>
  78.         /// </devdoc>
  79.         public IPEndPoint(IPAddress address, int port)
  80.         {
  81.             if (address == null) {
  82.                 throw new ArgumentNullException("address");
  83.             }
  84.             if (!ValidationHelper.ValidateTcpPort(port)) {
  85.                 throw new ArgumentOutOfRangeException("port");
  86.             }
  87.             m_Port = port;
  88.             m_Address = address;
  89.         }
  90.        
  91.         /// <devdoc>
  92.         /// <para>
  93.         /// Gets or sets the IP address.
  94.         /// </para>
  95.         /// </devdoc>
  96.         public IPAddress Address {
  97.             get { return m_Address; }
  98.             set { m_Address = value; }
  99.         }
  100.        
  101.         /// <devdoc>
  102.         /// <para>
  103.         /// Gets or sets the port.
  104.         /// </para>
  105.         /// </devdoc>
  106.         public int Port {
  107.             get { return m_Port; }
  108.             set {
  109.                 if (!ValidationHelper.ValidateTcpPort(value)) {
  110.                     throw new ArgumentOutOfRangeException("value");
  111.                 }
  112.                 m_Port = value;
  113.             }
  114.         }
  115.        
  116.        
  117.         /// <devdoc>
  118.         /// <para>[To be supplied.]</para>
  119.         /// </devdoc>
  120.         public override string ToString()
  121.         {
  122.             return Address.ToString() + ":" + Port.ToString(NumberFormatInfo.InvariantInfo);
  123.         }
  124.        
  125.         /// <devdoc>
  126.         /// <para>[To be supplied.]</para>
  127.         /// </devdoc>
  128.         public override SocketAddress Serialize()
  129.         {
  130.             if (m_Address.AddressFamily == AddressFamily.InterNetworkV6) {
  131.                 //
  132.                 // IPv6 Changes: create a new SocketAddress that is large enough for an
  133.                 // IPv6 address and then pack the address into it.
  134.                 //
  135.                 SocketAddress socketAddress = new SocketAddress(this.AddressFamily, SocketAddress.IPv6AddressSize);
  136.                 //
  137.                 // populate it
  138.                 //
  139.                 int port = this.Port;
  140.                 socketAddress[2] = (byte)(port >> 8);
  141.                 socketAddress[3] = (byte)port;
  142.                 //
  143.                 // Note: No handling for Flow Information
  144.                 //
  145.                 socketAddress[4] = (byte)0;
  146.                 socketAddress[5] = (byte)0;
  147.                 socketAddress[6] = (byte)0;
  148.                 socketAddress[7] = (byte)0;
  149.                 //
  150.                 // Scope serialization
  151.                 //
  152.                 long scope = this.Address.ScopeId;
  153.                
  154.                 socketAddress[24] = (byte)scope;
  155.                 socketAddress[25] = (byte)(scope >> 8);
  156.                 socketAddress[26] = (byte)(scope >> 16);
  157.                 socketAddress[27] = (byte)(scope >> 24);
  158.                 //
  159.                 // Address serialization
  160.                 //
  161.                 byte[] addressBytes = this.Address.GetAddressBytes();
  162.                
  163.                 for (int i = 0; i < addressBytes.Length; i++) {
  164.                     socketAddress[8 + i] = addressBytes[i];
  165.                 }
  166.                
  167.                 GlobalLog.Print("IPEndPoint::Serialize(IPv6): " + this.ToString());
  168.                
  169.                 //
  170.                 // return it
  171.                 //
  172.                 return socketAddress;
  173.             }
  174.             else {
  175.                 //
  176.                 // create a new SocketAddress
  177.                 //
  178.                 SocketAddress socketAddress = new SocketAddress(m_Address.AddressFamily, SocketAddress.IPv4AddressSize);
  179.                 //
  180.                 // populate it
  181.                 //
  182.                 socketAddress[2] = unchecked((byte)(this.Port >> 8));
  183.                 socketAddress[3] = unchecked((byte)(this.Port));
  184.                
  185.                 socketAddress[4] = unchecked((byte)(this.Address.m_Address));
  186.                 socketAddress[5] = unchecked((byte)(this.Address.m_Address >> 8));
  187.                 socketAddress[6] = unchecked((byte)(this.Address.m_Address >> 16));
  188.                 socketAddress[7] = unchecked((byte)(this.Address.m_Address >> 24));
  189.                
  190.                 GlobalLog.Print("IPEndPoint::Serialize: " + this.ToString());
  191.                
  192.                 //
  193.                 // return it
  194.                 //
  195.                 return socketAddress;
  196.             }
  197.         }
  198.        
  199.         /// <devdoc>
  200.         /// <para>[To be supplied.]</para>
  201.         /// </devdoc>
  202.         public override EndPoint Create(SocketAddress socketAddress)
  203.         {
  204.             //
  205.             // validate SocketAddress
  206.             //
  207.             if (socketAddress.Family != this.AddressFamily) {
  208.                 throw new ArgumentException(SR.GetString(SR.net_InvalidAddressFamily, socketAddress.Family.ToString(), this.GetType().FullName, this.AddressFamily.ToString()), "socketAddress");
  209.             }
  210.             if (socketAddress.Size < 8) {
  211.                 throw new ArgumentException(SR.GetString(SR.net_InvalidSocketAddressSize, socketAddress.GetType().FullName, this.GetType().FullName), "socketAddress");
  212.             }
  213.            
  214.             if (this.AddressFamily == AddressFamily.InterNetworkV6) {
  215.                 //
  216.                 // IPv6 Changes: Extract the IPv6 Address information from the socket address
  217.                 //
  218.                 byte[] addr = new byte[IPAddress.IPv6AddressBytes];
  219.                 for (int i = 0; i < addr.Length; i++) {
  220.                     addr[i] = socketAddress[i + 8];
  221.                 }
  222.                 //
  223.                 // Port
  224.                 //
  225.                 int port = (int)((socketAddress[2] << 8 & 65280) | (socketAddress[3]));
  226.                 //
  227.                 // Scope
  228.                 //
  229.                 long scope = (long)((socketAddress[27] << 24) + (socketAddress[26] << 16) + (socketAddress[25] << 8) + (socketAddress[24]));
  230.                
  231.                 IPEndPoint created = new IPEndPoint(new IPAddress(addr, scope), port);
  232.                
  233.                 GlobalLog.Print("IPEndPoint::Create IPv6: " + this.ToString() + " -> " + created.ToString());
  234.                
  235.                 return created;
  236.             }
  237.             else {
  238.                
  239.                 //
  240.                 // strip out of SocketAddress information on the EndPoint
  241.                 //
  242.                 int port = (int)((socketAddress[2] << 8 & 65280) | (socketAddress[3]));
  243.                
  244.                 long address = (long)((socketAddress[4] & 255) | (socketAddress[5] << 8 & 65280) | (socketAddress[6] << 16 & 16711680) | (socketAddress[7] << 24)) & 4294967295u;
  245.                
  246.                 IPEndPoint created = new IPEndPoint(address, port);
  247.                
  248.                 GlobalLog.Print("IPEndPoint::Create: " + this.ToString() + " -> " + created.ToString());
  249.                
  250.                 //
  251.                 // return it
  252.                 //
  253.                 return created;
  254.             }
  255.         }
  256.        
  257.        
  258.         //UEUE
  259.         public override bool Equals(object comparand)
  260.         {
  261.             if (!(comparand is IPEndPoint)) {
  262.                 return false;
  263.             }
  264.             return ((IPEndPoint)comparand).m_Address.Equals(m_Address) && ((IPEndPoint)comparand).m_Port == m_Port;
  265.         }
  266.        
  267.         //UEUE
  268.         public override int GetHashCode()
  269.         {
  270.             return m_Address.GetHashCode() ^ m_Port;
  271.         }
  272.        
  273.         // For security, we need to be able to take an IPEndPoint and make a copy that's immutable and not derived.
  274.         internal IPEndPoint Snapshot()
  275.         {
  276.             return new IPEndPoint(Address.Snapshot(), Port);
  277.         }
  278.     }
  279.     // class IPEndPoint
  280. }
  281. // namespace System.Net

Developer Fusion