IPEndPoint.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Net / System / Net / IPEndPoint.cs / 1305376 / IPEndPoint.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Net { 
    using System.Net.Sockets; 
    using System.Globalization;
 
    /// 
    ///    
    ///       Provides an IP address.
    ///     
    /// 
    [Serializable] 
    public class IPEndPoint : EndPoint { 
        /// 
        ///     
        ///       Specifies the minimum acceptable value for the 
        ///       property.
        ///    
        ///  
        public const int MinPort = 0x00000000;
        ///  
        ///     
        ///       Specifies the maximum acceptable value for the 
        ///       property. 
        ///    
        /// 
        public const int MaxPort = 0x0000FFFF;
 
        private IPAddress m_Address;
        private int m_Port; 
 
        internal const int AnyPort = MinPort;
 
        internal static IPEndPoint Any     = new IPEndPoint(IPAddress.Any, AnyPort);
        internal static IPEndPoint IPv6Any = new IPEndPoint(IPAddress.IPv6Any,AnyPort);

 
        /// 
        ///    [To be supplied.] 
        ///  
        public override AddressFamily AddressFamily {
            get { 
                //
                // IPv6 Changes: Always delegate this to the address we are
                //               wrapping.
                // 
                return m_Address.AddressFamily;
            } 
        } 

        ///  
        ///    Creates a new instance of the IPEndPoint class with the specified address and
        ///       port.
        /// 
        public IPEndPoint(long address, int port) { 
            if (!ValidationHelper.ValidateTcpPort(port)) {
                throw new ArgumentOutOfRangeException("port"); 
            } 
            m_Port = port;
            m_Address = new IPAddress(address); 
        }

        /// 
        ///    Creates a new instance of the IPEndPoint class with the specified address and port. 
        /// 
        public IPEndPoint(IPAddress address, int port) { 
            if (address==null) { 
                throw new ArgumentNullException("address");
            } 
            if (!ValidationHelper.ValidateTcpPort(port)) {
                throw new ArgumentOutOfRangeException("port");
            }
            m_Port = port; 
            m_Address = address;
        } 
 
        /// 
        ///     
        ///       Gets or sets the IP address.
        ///    
        /// 
        public IPAddress Address { 
            get {
                return m_Address; 
            } 
            set {
                m_Address = value; 
            }
        }

        ///  
        ///    
        ///       Gets or sets the port. 
        ///     
        /// 
        public int Port { 
            get {
                return m_Port;
            }
            set { 
                if (!ValidationHelper.ValidateTcpPort(value)) {
                    throw new ArgumentOutOfRangeException("value"); 
                } 
                m_Port = value;
            } 
        }


        ///  
        ///    [To be supplied.]
        ///  
        public override string ToString() { 
            string format;
            if (m_Address.AddressFamily == AddressFamily.InterNetworkV6) 
                format = "[{0}]:{1}";
            else
                format = "{0}:{1}";
            return String.Format(format, m_Address.ToString(), Port.ToString(NumberFormatInfo.InvariantInfo)); 
        }
 
        ///  
        ///    [To be supplied.]
        ///  
        public override SocketAddress Serialize() {
            if ( m_Address.AddressFamily == AddressFamily.InterNetworkV6 ) {
                //
                // IPv6 Changes: create a new SocketAddress that is large enough for an 
                //               IPv6 address and then pack the address into it.
                // 
                SocketAddress socketAddress = new SocketAddress(this.AddressFamily, SocketAddress.IPv6AddressSize); 
                //
                // populate it 
                //
                int port = this.Port;
                socketAddress[2] = (byte)(port>> 8);
                socketAddress[3] = (byte)port; 
                //
                // Note: No handling for Flow Information 
                // 
                socketAddress[4]  = (byte)0;
                socketAddress[5]  = (byte)0; 
                socketAddress[6]  = (byte)0;
                socketAddress[7]  = (byte)0;
                //
                // Scope serialization 
                //
                long scope = this.Address.ScopeId; 
 
                socketAddress[24] = (byte)scope;
                socketAddress[25] = (byte)(scope >> 8); 
                socketAddress[26] = (byte)(scope >> 16);
                socketAddress[27] = (byte)(scope >> 24);
                //
                // Address serialization 
                //
                byte[] addressBytes = this.Address.GetAddressBytes(); 
 
                for ( int i = 0; i < addressBytes.Length; i++ ) {
                    socketAddress[8 + i] = addressBytes[i]; 
                }

                GlobalLog.Print("IPEndPoint::Serialize(IPv6): " + this.ToString() );
 
                //
                // return it 
                // 
                return socketAddress;
            } 
            else
            {
                //
                // create a new SocketAddress 
                //
                SocketAddress socketAddress = new SocketAddress(m_Address.AddressFamily, SocketAddress.IPv4AddressSize); 
                // 
                // populate it
                // 
                socketAddress[2] = unchecked((byte)(this.Port>> 8));
                socketAddress[3] = unchecked((byte)(this.Port    ));

                socketAddress[4] = unchecked((byte)(this.Address.m_Address    )); 
                socketAddress[5] = unchecked((byte)(this.Address.m_Address>> 8));
                socketAddress[6] = unchecked((byte)(this.Address.m_Address>>16)); 
                socketAddress[7] = unchecked((byte)(this.Address.m_Address>>24)); 

                GlobalLog.Print("IPEndPoint::Serialize: " + this.ToString() ); 

                //
                // return it
                // 
                return socketAddress;
            } 
        } 

        ///  
        ///    [To be supplied.]
        /// 
        public override EndPoint Create(SocketAddress socketAddress) {
            // 
            // validate SocketAddress
            // 
            if (socketAddress.Family != this.AddressFamily) { 
                throw new ArgumentException(SR.GetString(SR.net_InvalidAddressFamily, socketAddress.Family.ToString(), this.GetType().FullName, this.AddressFamily.ToString()), "socketAddress");
            } 
            if (socketAddress.Size<8) {
                throw new ArgumentException(SR.GetString(SR.net_InvalidSocketAddressSize, socketAddress.GetType().FullName, this.GetType().FullName), "socketAddress");
            }
 
            if ( this.AddressFamily == AddressFamily.InterNetworkV6 ) {
                // 
                // IPv6 Changes: Extract the IPv6 Address information from the socket address 
                //
                byte[] addr = new byte[IPAddress.IPv6AddressBytes]; 
                for (int i = 0; i < addr.Length; i++)
                {
                    addr[i] = socketAddress[i + 8];
                } 
                //
                // Port 
                // 
                int port = (int)((socketAddress[2]<<8 & 0xFF00) | (socketAddress[3]));
                // 
                // Scope
                //
                long scope = (long)((socketAddress[27] << 24) +
                                    (socketAddress[26] << 16) + 
                                    (socketAddress[25] << 8 ) +
                                    (socketAddress[24])); 
 
                IPEndPoint created = new IPEndPoint(new IPAddress(addr,scope),port);
 
                GlobalLog.Print("IPEndPoint::Create IPv6: " + this.ToString() + " -> " + created.ToString() );

                return created;
            } 
            else
            { 
 
                //
                // strip out of SocketAddress information on the EndPoint 
                //
                int port = (int)(
                        (socketAddress[2]<<8 & 0xFF00) |
                        (socketAddress[3]) 
                        );
 
                long address = (long)( 
                        (socketAddress[4]     & 0x000000FF) |
                        (socketAddress[5]<<8  & 0x0000FF00) | 
                        (socketAddress[6]<<16 & 0x00FF0000) |
                        (socketAddress[7]<<24)
                        ) & 0x00000000FFFFFFFF;
 
                IPEndPoint created = new IPEndPoint(address, port);
 
                GlobalLog.Print("IPEndPoint::Create: " + this.ToString() + " -> " + created.ToString() ); 

                // 
                // return it
                //
                return created;
            } 
        }
 
 
        //UEUE
        public override bool Equals(object comparand) { 
            if (!(comparand is IPEndPoint)) {
                return false;
            }
            return ((IPEndPoint)comparand).m_Address.Equals(m_Address) && ((IPEndPoint)comparand).m_Port==m_Port; 
        }
 
        //UEUE 
        public override int GetHashCode() {
            return m_Address.GetHashCode() ^ m_Port; 
        }

        // For security, we need to be able to take an IPEndPoint and make a copy that's immutable and not derived.
        internal IPEndPoint Snapshot() 
        {
            return new IPEndPoint(Address.Snapshot(), Port); 
        } 
    } // class IPEndPoint
} // namespace System.Net 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
IPEndPoint.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
