00001 00014 // SocketAddress.cpp -- implementation of the SocketAddress class 00015 00016 #include "SocketAddress.h" 00017 #include "IpAddress.h" 00018 00019 00021 // class SocketAddress 00022 00023 std::ostream& SocketAddress::operator<<(std::ostream& stream) const 00024 { 00025 stream << std::string("SocketAddress( "); 00026 getIpAddress().operator<<(stream); 00027 stream << std::string(", port "); 00028 // stream << getPort(); TODO: get this to wwork under GNU 00029 stream << std::string(" )"); 00030 return stream; 00031 } 00032 00033 // Set IP address to `address`. 00034 void SocketAddress::setIpAddress( const IpAddress& address ) 00035 { 00036 setIpAddress( address.toLong() ); 00037 } 00038 00039 00040 // Assign myself from `address`. 00041 SocketAddress& SocketAddress::operator=( const sockaddr_in& address ) 00042 { 00043 socketAddress = address; 00044 return *this; 00045 } 00046 00047 00048 // Assign myself from `address`. 00049 SocketAddress& SocketAddress::operator=( const SocketAddress& address ) 00050 { 00051 socketAddress = address.socketAddress; 00052 return *this; 00053 } 00054 00055 00056 // Return my IP address. 00057 IpAddress SocketAddress::getIpAddress() const 00058 { 00059 return getIpAddressAsLong(); 00060 } 00061 00062 00063 // Return the size, in bytes, of my encoded address. 00064 int SocketAddress::length() const 00065 { 00066 return sizeof( socketAddress ); 00067 } 00068 00069 00070 // Return myself as a `sockaddr_in` structure. 00071 SocketAddress::operator sockaddr_in() const 00072 { 00073 return socketAddress; 00074 } 00075 00076 00077 // Return `true` if my port is non-zero. 00078 bool SocketAddress::isDefined() const 00079 { 00080 return getPort() != 0; 00081 } 00082 00083 00084 // Return `true` if my address is IP based. 00085 bool SocketAddress::isIpAddress() const 00086 { 00087 return socketAddress.sin_family == AF_INET; 00088 } 00089 00090 00091 // Return `true` if my address is path based. 00092 bool SocketAddress::isPathAddress() const 00093 { 00094 return socketAddress.sin_family == AF_UNIX; 00095 } 00096 00097 00098 // Return my domain. 00099 short SocketAddress::getAddressFamily() const 00100 { 00101 return socketAddress.sin_family; 00102 } 00103 00104 00105 // Return `true` if my address and port are the same as `address`'s. 00106 bool SocketAddress::operator==( const SocketAddress& address ) const 00107 { 00108 return ( getPort() == address.getPort() ) && ( getIpAddressAsLong() == address.getIpAddressAsLong() ); 00109 } 00110 00111 00112 // Return `true` if I'm considered to be less than `address`. 00113 bool SocketAddress::operator<( const SocketAddress& address ) const 00114 { 00115 return ( getPort() < address.getPort() ) || ( ( getPort() == address.getPort() ) && 00116 ( getIpAddressAsLong() < address.getIpAddressAsLong() )); 00117 } 00118 00119 00120 // Construct myself to represent the port `port` on my host. 00121 SocketAddress::SocketAddress( int port ) 00122 { 00123 initialize(); 00124 setPort(port); 00125 setIpAddress( getIpAddress() ); 00126 } 00127 00128 00129 // Construct myself from the encoded IP socket address `address`. 00130 SocketAddress::SocketAddress( const sockaddr_in& address ) 00131 { 00132 socketAddress = address; 00133 } 00134 00135 00136 // Construct myself to reference the port `port=0`) at IP address`address`. 00137 SocketAddress::SocketAddress( const IpAddress& address, int port ) 00138 { 00139 initialize(); 00140 setPort( port ); 00141 setIpAddress( address ); 00142 } 00143 00144 00145 // Construct myself to be a copy of `address`. 00146 SocketAddress::SocketAddress( const SocketAddress& address ) : socketAddress( address.socketAddress ) 00147 { 00148 } 00149 00150 // Initialize my address by zeroing its data and setting its family 00151 // to `AF_INET`. 00152 void SocketAddress::initialize() // throw() 00153 { 00154 ::memset( &socketAddress, 0, sizeof(socketAddress) ); 00155 socketAddress.sin_family = AF_INET; 00156 } 00157 00158 00159 // Set my port to `port`. 00160 void SocketAddress::setPort( int port ) // throw() 00161 { 00162 socketAddress.sin_port = htons( (unsigned short) port ); 00163 } 00164 00165 00166 // Return my port number. 00167 int SocketAddress::getPort() const // throw() 00168 { 00169 return ntohs( socketAddress.sin_port ); 00170 } 00171 00172 00173 // Return my IP address in encoded form. 00174 long SocketAddress::getIpAddressAsLong() const // throw() 00175 { 00176 return ntohl( socketAddress.sin_addr.s_addr ); 00177 } 00178 00179 00180 // Set my IP address to the IP address encoded by `code`. 00181 void SocketAddress::setIpAddress( long code ) // throw() 00182 { 00183 socketAddress.sin_addr.s_addr = htonl( code ); 00184 }