Logo
~Sockets~
~Examples~
~Contact~


Ipv4Address.cpp

Go to the documentation of this file.
00001 
00006 /*
00007 Copyright (C) 2007  Anders Hedstrom
00008 
00009 This program is free software; you can redistribute it and/or
00010 modify it under the terms of the GNU General Public License
00011 as published by the Free Software Foundation; either version 2
00012 of the License, or (at your option) any later version.
00013 
00014 This program is distributed in the hope that it will be useful,
00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017 GNU General Public License for more details.
00018 
00019 You should have received a copy of the GNU General Public License
00020 along with this program; if not, write to the Free Software
00021 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00022 */
00023 #include "Ipv4Address.h"
00024 #include "Utility.h"
00025 #include "Parse.h"
00026 #ifndef _WIN32
00027 #include <netdb.h>
00028 #endif
00029 
00030 
00031 #ifdef SOCKETS_NAMESPACE
00032 namespace SOCKETS_NAMESPACE {
00033 #endif
00034 
00035 
00036 
00037 Ipv4Address::Ipv4Address(port_t port) : m_valid(true)
00038 {
00039         memset(&m_addr, 0, sizeof(m_addr));
00040         m_addr.sin_family = AF_INET;
00041         m_addr.sin_port = htons( port );
00042 }
00043 
00044 
00045 Ipv4Address::Ipv4Address(ipaddr_t a,port_t port) : m_valid(true)
00046 {
00047         memset(&m_addr, 0, sizeof(m_addr));
00048         m_addr.sin_family = AF_INET;
00049         m_addr.sin_port = htons( port );
00050         memcpy(&m_addr.sin_addr, &a, sizeof(struct in_addr));
00051 }
00052 
00053 
00054 Ipv4Address::Ipv4Address(struct in_addr& 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         m_addr.sin_addr = a;
00060 }
00061 
00062 
00063 Ipv4Address::Ipv4Address(const std::string& host,port_t port) : m_valid(false)
00064 {
00065         memset(&m_addr, 0, sizeof(m_addr));
00066         m_addr.sin_family = AF_INET;
00067         m_addr.sin_port = htons( port );
00068         {
00069                 ipaddr_t a;
00070                 if (Utility::u2ip(host, a))
00071                 {
00072                         memcpy(&m_addr.sin_addr, &a, sizeof(struct in_addr));
00073                         m_valid = true;
00074                 }
00075         }
00076 }
00077 
00078 
00079 Ipv4Address::Ipv4Address(struct sockaddr_in& sa)
00080 {
00081         m_addr = sa;
00082         m_valid = sa.sin_family == AF_INET;
00083 }
00084 
00085 
00086 Ipv4Address::~Ipv4Address()
00087 {
00088 }
00089 
00090 
00091 Ipv4Address::operator struct sockaddr *()
00092 {
00093         return (struct sockaddr *)&m_addr;
00094 }
00095 
00096 
00097 Ipv4Address::operator socklen_t()
00098 {
00099         return sizeof(struct sockaddr_in);
00100 }
00101 
00102 
00103 void Ipv4Address::SetPort(port_t port)
00104 {
00105         m_addr.sin_port = htons( port );
00106 }
00107 
00108 
00109 port_t Ipv4Address::GetPort()
00110 {
00111         return ntohs( m_addr.sin_port );
00112 }
00113 
00114 
00115 bool Ipv4Address::Resolve(const std::string& hostname,struct in_addr& a)
00116 {
00117         struct sockaddr_in sa;
00118         memset(&a, 0, sizeof(a));
00119         if (Utility::isipv4(hostname))
00120         {
00121                 if (!Utility::u2ip(hostname, sa, AI_NUMERICHOST))
00122                         return false;
00123                 a = sa.sin_addr;
00124                 return true;
00125         }
00126         if (!Utility::u2ip(hostname, sa))
00127                 return false;
00128         a = sa.sin_addr;
00129         return true;
00130 }
00131 
00132 
00133 bool Ipv4Address::Reverse(struct in_addr& a,std::string& name)
00134 {
00135         struct sockaddr_in sa;
00136         memset(&sa, 0, sizeof(sa));
00137         sa.sin_family = AF_INET;
00138         sa.sin_addr = a;
00139         return Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name);
00140 }
00141 
00142 
00143 std::string Ipv4Address::Convert(bool include_port)
00144 {
00145         if (include_port)
00146                 return Convert(m_addr.sin_addr) + ":" + Utility::l2string(GetPort());
00147         return Convert(m_addr.sin_addr);
00148 }
00149 
00150 
00151 std::string Ipv4Address::Convert(struct in_addr& a)
00152 {
00153         struct sockaddr_in sa;
00154         memset(&sa, 0, sizeof(sa));
00155         sa.sin_family = AF_INET;
00156         sa.sin_addr = a;
00157         std::string name;
00158         Utility::reverse((struct sockaddr *)&sa, sizeof(sa), name, NI_NUMERICHOST);
00159         return name;
00160 }
00161 
00162 
00163 void Ipv4Address::SetAddress(struct sockaddr *sa)
00164 {
00165         memcpy(&m_addr, sa, sizeof(struct sockaddr_in));
00166 }
00167 
00168 
00169 int Ipv4Address::GetFamily()
00170 {
00171         return m_addr.sin_family;
00172 }
00173 
00174 
00175 bool Ipv4Address::IsValid()
00176 {
00177         return m_valid;
00178 }
00179 
00180 
00181 bool Ipv4Address::operator==(SocketAddress& a)
00182 {
00183         if (a.GetFamily() != GetFamily())
00184                 return false;
00185         if ((socklen_t)a != sizeof(m_addr))
00186                 return false;
00187         struct sockaddr *sa = a;
00188         struct sockaddr_in *p = (struct sockaddr_in *)sa;
00189         if (p -> sin_port != m_addr.sin_port)
00190                 return false;
00191         if (memcmp(&p -> sin_addr, &m_addr.sin_addr, 4))
00192                 return false;
00193         return true;
00194 }
00195 
00196 
00197 std::auto_ptr<SocketAddress> Ipv4Address::GetCopy()
00198 {
00199         return std::auto_ptr<SocketAddress>(new Ipv4Address(m_addr));
00200 }
00201 
00202 
00203 std::string Ipv4Address::Reverse()
00204 {
00205         std::string tmp;
00206         Reverse(m_addr.sin_addr, tmp);
00207         return tmp;
00208 }
00209 
00210 
00211 #ifdef SOCKETS_NAMESPACE
00212 } // namespace SOCKETS_NAMESPACE {
00213 #endif
Page, code, and content Copyright (C) 2007 by Anders Hedström
Generated for C++ Sockets by  doxygen 1.4.4