00001
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #include "Ipv4Address.h"
00034 #include "Utility.h"
00035 #ifndef _WIN32
00036 #include <netdb.h>
00037 #endif
00038
00039
00040 #ifdef SOCKETS_NAMESPACE
00041 namespace SOCKETS_NAMESPACE {
00042 #endif
00043
00044
00045
00046 Ipv4Address::Ipv4Address(port_t port) : m_valid(true)
00047 {
00048 memset(&m_addr, 0, sizeof(m_addr));
00049 m_addr.sin_family = AF_INET;
00050 m_addr.sin_port = htons( port );
00051 }
00052
00053
00054 Ipv4Address::Ipv4Address(ipaddr_t a,port_t port) : m_valid(true)
00055 {
00056 memset(&m_addr, 0, sizeof(m_addr));
00057 m_addr.sin_family = AF_INET;
00058 m_addr.sin_port = htons( port );
00059 memcpy(&m_addr.sin_addr, &a, sizeof(struct in_addr));
00060 }
00061
00062
00063 Ipv4Address::Ipv4Address(struct in_addr& a,port_t port) : m_valid(true)
00064 {
00065 memset(&m_addr, 0, sizeof(m_addr));
00066 m_addr.sin_family = AF_INET;
00067 m_addr.sin_port = htons( port );
00068 m_addr.sin_addr = a;
00069 }
00070
00071
00072 Ipv4Address::Ipv4Address(const std::string& host,port_t port) : m_valid(false)
00073 {
00074 memset(&m_addr, 0, sizeof(m_addr));
00075 m_addr.sin_family = AF_INET;
00076 m_addr.sin_port = htons( port );
00077 {
00078 ipaddr_t a;
00079 if (Utility::u2ip(host, a))
00080 {
00081 memcpy(&m_addr.sin_addr, &a, sizeof(struct in_addr));
00082 m_valid = true;
00083 }
00084 }
00085 }
00086
00087
00088 Ipv4Address::Ipv4Address(struct sockaddr_in& sa)
00089 {
00090 m_addr = sa;
00091 m_valid = sa.sin_family == AF_INET;
00092 }
00093
00094
00095 Ipv4Address::~Ipv4Address()
00096 {
00097 }
00098
00099
00100 Ipv4Address::operator struct sockaddr *()
00101 {
00102 return (struct sockaddr *)&m_addr;
00103 }
00104
00105
00106 Ipv4Address::operator socklen_t()
00107 {
00108 return sizeof(struct sockaddr_in);
00109 }
00110
00111
00112 void Ipv4Address::SetPort(port_t port)
00113 {
00114 m_addr.sin_port = htons( port );
00115 }
00116
00117
00118 port_t Ipv4Address::GetPort()
00119 {
00120 return ntohs( m_addr.sin_port );
00121 }
00122
00123
00124 bool Ipv4Address::Resolve(const std::string& hostname,struct in_addr& a)
00125 {
00126 struct sockaddr_in sa;
00127 memset(&a, 0, sizeof(a));
00128 if (Utility::isipv4(hostname))
00129 {
00130 if (!Utility::u2ip(hostname, sa, AI_NUMERICHOST))
00131 return false;
00132 a = sa.sin_addr;
00133 return true;
00134 }
00135 if (!Utility::u2ip(hostname, sa))
00136 return false;
00137 a = sa.sin_addr;
00138 return true;
00139 }
00140
00141
00142 bool Ipv4Address::Reverse(struct in_addr& a,std::string& name)
00143 {
00144 struct sockaddr_in sa;
00145 memset(&sa, 0, sizeof(sa));
00146 sa.sin_family = AF_INET;
00147 sa.sin_addr = a;
00148 return Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name);
00149 }
00150
00151
00152 std::string Ipv4Address::Convert(bool include_port)
00153 {
00154 if (include_port)
00155 return Convert(m_addr.sin_addr) + ":" + Utility::l2string(GetPort());
00156 return Convert(m_addr.sin_addr);
00157 }
00158
00159
00160 std::string Ipv4Address::Convert(struct in_addr& a)
00161 {
00162 struct sockaddr_in sa;
00163 memset(&sa, 0, sizeof(sa));
00164 sa.sin_family = AF_INET;
00165 sa.sin_addr = a;
00166 std::string name;
00167 Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name, NI_NUMERICHOST);
00168 return name;
00169 }
00170
00171
00172 void Ipv4Address::SetAddress(struct sockaddr *sa)
00173 {
00174 memcpy(&m_addr, sa, sizeof(struct sockaddr_in));
00175 }
00176
00177
00178 int Ipv4Address::GetFamily()
00179 {
00180 return m_addr.sin_family;
00181 }
00182
00183
00184 bool Ipv4Address::IsValid()
00185 {
00186 return m_valid;
00187 }
00188
00189
00190 bool Ipv4Address::operator==(SocketAddress& a)
00191 {
00192 if (a.GetFamily() != GetFamily())
00193 return false;
00194 if ((socklen_t)a != sizeof(m_addr))
00195 return false;
00196 struct sockaddr *sa = a;
00197 struct sockaddr_in *p = (struct sockaddr_in *)sa;
00198 if (p -> sin_port != m_addr.sin_port)
00199 return false;
00200 if (memcmp(&p -> sin_addr, &m_addr.sin_addr, 4))
00201 return false;
00202 return true;
00203 }
00204
00205
00206 std::auto_ptr<SocketAddress> Ipv4Address::GetCopy()
00207 {
00208 return std::auto_ptr<SocketAddress>(new Ipv4Address(m_addr));
00209 }
00210
00211
00212 std::string Ipv4Address::Reverse()
00213 {
00214 std::string tmp;
00215 Reverse(m_addr.sin_addr, tmp);
00216 return tmp;
00217 }
00218
00219
00220 #ifdef SOCKETS_NAMESPACE
00221 }
00222 #endif
00223