X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/2df7be7f2cca699a02ee0c9ce69de9bfe6b0922f..bf9ce2abdf465110ca83469c1b336b056ae8ec72:/src/common/sckaddr.cpp diff --git a/src/common/sckaddr.cpp b/src/common/sckaddr.cpp index ab9a1f78c6..dd801147b3 100644 --- a/src/common/sckaddr.cpp +++ b/src/common/sckaddr.cpp @@ -1,425 +1,410 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: sckaddr.cpp +// Name: src/common/sckaddr.cpp // Purpose: Network address manager // Author: Guilhem Lavaux // Modified by: // Created: 26/04/97 // RCS-ID: $Id$ // Copyright: (c) 1997, 1998 Guilhem Lavaux -// Licence: wxWindows license +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ - #pragma implementation "sckaddr.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" #ifdef __BORLANDC__ - #pragma hdrstop + #pragma hdrstop #endif #if wxUSE_SOCKETS #ifndef WX_PRECOMP -#endif + #include "wx/object.h" + #include "wx/log.h" + #include "wx/intl.h" -#include -#include -#include + #include + #include + #include -#if !defined(__MWERKS__) && !defined(__SALFORDC__) -#include -#endif + #if !defined(__MWERKS__) + #include + #endif +#endif // !WX_PRECOMP -#include "wx/defs.h" -#include "wx/object.h" +#include "wx/gsocket.h" +#include "wx/socket.h" +#include "wx/sckaddr.h" -#if defined(__WXMAC__) -#include "/wx/mac/macsock.h" +IMPLEMENT_ABSTRACT_CLASS(wxSockAddress, wxObject) +IMPLEMENT_ABSTRACT_CLASS(wxIPaddress, wxSockAddress) +IMPLEMENT_DYNAMIC_CLASS(wxIPV4address, wxIPaddress) +#if wxUSE_IPV6 +IMPLEMENT_DYNAMIC_CLASS(wxIPV6address, wxIPaddress) #endif - -#if defined(__WINDOWS__) -#include -#endif // __WINDOWS__ - -#if defined(__UNIX__) -#ifdef VMS -#include -#include -#else -#include -#include -#include -#include +#if defined(__UNIX__) && !defined(__WINDOWS__) && !defined(__WINE__) +IMPLEMENT_DYNAMIC_CLASS(wxUNIXaddress, wxSockAddress) #endif -#include -#include -#ifdef __SUN__ -extern "C" +// --------------------------------------------------------------------------- +// wxSockAddress +// --------------------------------------------------------------------------- + +void wxSockAddress::Init() { - struct hostent *gethostbyname(const char *name); - int gethostname(char *name, int namelen); -}; -#endif + if ( !wxSocketBase::IsInitialized() ) + { + // we must do it before using GAddress_XXX functions + (void)wxSocketBase::Initialize(); + } +} -#endif // __UNIX__ +wxSockAddress::wxSockAddress() +{ + Init(); -#include "wx/sckaddr.h" + m_address = GAddress_new(); +} -#define CHECK_ADDRTYPE(var, type) +wxSockAddress::wxSockAddress(const wxSockAddress& other) + : wxObject() +{ + Init(); -#if !USE_SHARED_LIBRARY -IMPLEMENT_ABSTRACT_CLASS(wxSockAddress, wxObject) -IMPLEMENT_DYNAMIC_CLASS(wxIPV4address, wxSockAddress) -#ifdef ENABLE_IPV6 -IMPLEMENT_DYNAMIC_CLASS(wxIPV6address, wxSockAddress) -#endif -#ifdef __UNIX__ -IMPLEMENT_DYNAMIC_CLASS(wxUNIXaddress, wxSockAddress) -#endif -#endif + m_address = GAddress_copy(other.m_address); +} -wxIPV4address::wxIPV4address() +wxSockAddress::~wxSockAddress() { - m_addr = new sockaddr_in; - Clear(); + GAddress_destroy(m_address); } -wxIPV4address::~wxIPV4address() +void wxSockAddress::SetAddress(GAddress *address) { + if ( address != m_address ) + { + GAddress_destroy(m_address); + m_address = GAddress_copy(address); + } } -int wxIPV4address::SockAddrLen() +wxSockAddress& wxSockAddress::operator=(const wxSockAddress& addr) { - return sizeof(*m_addr); + SetAddress(addr.GetAddress()); + return *this; } -int wxIPV4address::GetFamily() +void wxSockAddress::Clear() { - return AF_INET; + GAddress_destroy(m_address); + m_address = GAddress_new(); } -void wxIPV4address::Clear() +// --------------------------------------------------------------------------- +// wxIPaddress +// --------------------------------------------------------------------------- + +wxIPaddress::wxIPaddress() + : wxSockAddress() { - memset(m_addr, 0, sizeof(*m_addr)); - m_addr->sin_family = AF_INET; - m_addr->sin_addr.s_addr = INADDR_ANY; } -/* -const wxSockAddress& wxIPV4address::operator =(const wxSockAddress& addr) +wxIPaddress::wxIPaddress(const wxIPaddress& other) + : wxSockAddress(other) { - wxIPV4address *ip_addr = (wxIPV4address *)&addr; - CHECK_ADDRTYPE(addr, wxIPV4address); - m_addr = ip_addr->m_addr; - return *this; } -*/ -bool wxIPV4address::Hostname(const wxString& name) +wxIPaddress::~wxIPaddress() { - struct hostent *theHostent; - struct in_addr *addr; - - if (name.IsNull()) - return FALSE; - - if (!name.IsNumber()) { - if ((theHostent = gethostbyname(name.fn_str())) == 0) { - return FALSE; - } - } else { -#ifdef __WXMAC__ - long len_addr = inet_addr(name.fn_str()).s_addr ; -#else - long len_addr = inet_addr(name.fn_str()); -#endif - if (len_addr == -1) - return FALSE; - m_addr->sin_addr.s_addr = len_addr; - return TRUE; - } +} + +// --------------------------------------------------------------------------- +// wxIPV4address +// --------------------------------------------------------------------------- + +wxIPV4address::wxIPV4address() + : wxIPaddress() +{ +} + +wxIPV4address::wxIPV4address(const wxIPV4address& other) + : wxIPaddress(other) +{ +} - addr = (struct in_addr *) *(theHostent->h_addr_list); +wxIPV4address::~wxIPV4address() +{ +} - m_addr->sin_addr.s_addr = addr[0].s_addr; - return TRUE; +bool wxIPV4address::Hostname(const wxString& name) +{ + // Some people are sometimes fool. + if (name.empty()) + { + wxLogWarning( _("Trying to solve a NULL hostname: giving up") ); + return false; + } + m_origHostname = name; + return (GAddress_INET_SetHostName(m_address, name.mb_str()) == GSOCK_NOERROR); } bool wxIPV4address::Hostname(unsigned long addr) { - m_addr->sin_addr.s_addr = htonl(addr); - return TRUE; + bool rv = (GAddress_INET_SetHostAddress(m_address, addr) == GSOCK_NOERROR); + if (rv) + m_origHostname = Hostname(); + else + m_origHostname = wxEmptyString; + return rv; } bool wxIPV4address::Service(const wxString& name) { - struct servent *theServent; - - if (name.IsNull()) - return FALSE; - - if (!name.IsNumber()) { - if ((theServent = getservbyname(name.fn_str(), "tcp")) == 0) - return FALSE; - } else { - if ((theServent = getservbyport(wxAtoi(name), "tcp")) == 0) { - m_addr->sin_port = htons(wxAtoi(name)); - return TRUE; - } - } - - m_addr->sin_port = theServent->s_port; - return TRUE; + return (GAddress_INET_SetPortName(m_address, name.mb_str(), "tcp") == GSOCK_NOERROR); } bool wxIPV4address::Service(unsigned short port) { - m_addr->sin_port = htons(port); - return TRUE; + return (GAddress_INET_SetPort(m_address, port) == GSOCK_NOERROR); } bool wxIPV4address::LocalHost() { - static char buf[256]; - - if (gethostname(buf, sizeof(buf)) < 0) - return Hostname("localhost"); - else - return Hostname(buf); + return (GAddress_INET_SetHostName(m_address, "localhost") == GSOCK_NOERROR); } -wxString wxIPV4address::Hostname() +bool wxIPV4address::IsLocalHost() const { - struct hostent *h_ent; - - h_ent = gethostbyaddr((char *)&(m_addr->sin_addr), sizeof(m_addr->sin_addr), - GetFamily()); - - if (!h_ent) - return wxString(""); - else - return wxString(h_ent->h_name); + return (Hostname() == wxT("localhost") || IPAddress() == wxT("127.0.0.1")); } -unsigned short wxIPV4address::Service() +bool wxIPV4address::BroadcastAddress() { - return ntohs(m_addr->sin_port); + return (GAddress_INET_SetBroadcastAddress(m_address) == GSOCK_NOERROR); } -void wxIPV4address::Build(struct sockaddr *&addr, size_t& len) +bool wxIPV4address::AnyAddress() { - addr = (struct sockaddr *)m_addr; - len = sizeof(*m_addr); + return (GAddress_INET_SetAnyAddress(m_address) == GSOCK_NOERROR); } -void wxIPV4address::Disassemble(struct sockaddr *addr, size_t len) +wxString wxIPV4address::Hostname() const { - if (len != sizeof(*m_addr)) - return; - *m_addr = *(struct sockaddr_in *)addr; -} + char hostname[1024]; -#ifdef IPV6_ENABLE + hostname[0] = 0; + GAddress_INET_GetHostName(m_address, hostname, 1024); + return wxString::FromAscii(hostname); +} -wxIPV6address::wxIPV6address() +unsigned short wxIPV4address::Service() const { - m_addr = new sockaddr_in6; - Clear(); + return GAddress_INET_GetPort(m_address); } -wxIPV6address::~wxIPV6address() +wxSockAddress *wxIPV4address::Clone() const { + wxIPV4address *addr = new wxIPV4address(*this); + addr->m_origHostname = m_origHostname; + return addr; } -int wxIPV6address::SockAddrLen() +wxString wxIPV4address::IPAddress() const { - return sizeof(*m_addr); + unsigned long raw = GAddress_INET_GetHostAddress(m_address); + return wxString::Format(_T("%lu.%lu.%lu.%lu"), + (raw>>24) & 0xff, + (raw>>16) & 0xff, + (raw>>8) & 0xff, + raw & 0xff + ); } -int wxIPV6address::GetFamily() +bool wxIPV4address::operator==(const wxIPV4address& addr) const { - return AF_INET6; + return Hostname().Cmp(addr.Hostname()) == 0 && + Service() == addr.Service(); } -void wxIPV6address::Clear() -{ - memset(m_addr, 0, sizeof(*m_addr)); - m_addr->sin6_family = AF_INET6; - m_addr->sin6_addr.s_addr = INADDR_ANY; +#if wxUSE_IPV6 +// --------------------------------------------------------------------------- +// wxIPV6address +// --------------------------------------------------------------------------- + +wxIPV6address::wxIPV6address() + : wxIPaddress() +{ } -/* -const wxSockAddress& wxIPV6address::operator =(const wxSockAddress& addr) +wxIPV6address::wxIPV6address(const wxIPV6address& other) + : wxIPaddress(other), m_origHostname(other.m_origHostname) { - wxIPV6address *ip_addr = (wxIPV6address *)&addr; +} - CHECK_ADDRTYPE(addr, wxIPV6address); - m_addr = ip_addr->m_addr; - return *this; +wxIPV6address::~wxIPV6address() +{ } -*/ bool wxIPV6address::Hostname(const wxString& name) { - struct hostent *theHostent; - struct in_addr *addr; - - if (name.IsNull()) - return FALSE; - - if (!name.IsNumber()) { - hostent = gethostbyname2((char*) name, AF_INET6); - if (!theHostent) - return FALSE; - } else { - // Don't how to do - return FALSE; + if (name.empty()) + { + wxLogWarning( _("Trying to solve a NULL hostname: giving up") ); + return false; } - - addr = (struct in6_addr *) *(theHostent->h_addr_list); - - m_addr->sin6_addr.s6_addr = addr[0].s6_addr; - return TRUE; + m_origHostname = name; + return (GAddress_INET6_SetHostName(m_address, name.mb_str()) == GSOCK_NOERROR); } bool wxIPV6address::Hostname(unsigned char addr[16]) { - m_addr->sin6_addr.s6_addr = addr; - return TRUE; + wxString name; + unsigned short wk[8]; + for ( int i = 0; i < 8; ++i ) + { + wk[i] = addr[2*i]; + wk[i] <<= 8; + wk[i] |= addr[2*i+1]; + } + name.Printf("%x:%x:%x:%x:%x:%x:%x:%x", + wk[0], wk[1], wk[2], wk[3], wk[4], wk[5], wk[6], wk[7]); + return Hostname(name); } -bool wxIPV6address::Service(const char *name) +bool wxIPV6address::Service(const wxString& name) { - struct servent *theServent; - - if (!name || !strlen(name)) - return FALSE; - - if (!isdigit(*name)) { - if ((theServent = getservbyname((char*) name, "tcp")) == 0) - return FALSE; - } else { - if ((theServent = getservbyport(atoi(name), "tcp")) == 0) { - m_addr->sin_port = htons(atoi(name)); - return TRUE; - } - } - - m_addr->sin_port = theServent->s_port; - return TRUE; + return (GAddress_INET6_SetPortName(m_address, name.mb_str(), "tcp") == GSOCK_NOERROR); } bool wxIPV6address::Service(unsigned short port) { - m_addr->sin_port = htons(port); - return TRUE; + return (GAddress_INET6_SetPort(m_address, port) == GSOCK_NOERROR); } bool wxIPV6address::LocalHost() { - static char buf[256]; - - if (gethostname(buf, sizeof(buf)) < 0) - return Hostname("localhost"); - else - return Hostname(buf); + return (GAddress_INET6_SetHostName(m_address, "localhost") == GSOCK_NOERROR); } -const wxString& wxIPV6address::Hostname() +bool wxIPV6address::IsLocalHost() const { - struct hostent *h_ent; + if ( Hostname() == "localhost" ) + return true; - h_ent = gethostbyaddr((char *)&(m_addr->sin_addr), sizeof(m_addr->sin_addr), - GetFamily()); - return wxString(h_ent->h_name); + wxString addr = IPAddress(); + return addr == wxT("::1") || + addr == wxT("0:0:0:0:0:0:0:1") || + addr == wxT("::ffff:127.0.0.1"); } -unsigned short wxIPV6address::Service() +bool wxIPV6address::BroadcastAddress() { - return ntohs(m_addr->sin_port); + wxFAIL_MSG( "not implemented" ); + + return false; } -void wxIPV6address::Build(struct sockaddr& *addr, size_t& len) +bool wxIPV6address::AnyAddress() { - len = sizeof(*m_addr); - addr = m_addr; + return (GAddress_INET6_SetAnyAddress(m_address) == GSOCK_NOERROR); } -void wxIPV6address::Disassemble(struct sockaddr& *addr, size_t len) +wxString wxIPV6address::IPAddress() const { - if (len != sizeof(*m_addr)) - return; - *m_addr = *(struct sockaddr_in6 *)addr; -} + unsigned char addr[16]; + GAddress_INET6_GetHostAddress(m_address,(in6_addr*)addr); -#endif + wxUint16 words[8]; + int i, + prefix_zero_count = 0; + for ( i = 0; i < 8; ++i ) + { + words[i] = addr[i*2]; + words[i] <<= 8; + words[i] |= addr[i*2+1]; + if ( i == prefix_zero_count && words[i] == 0 ) + ++prefix_zero_count; + } -#ifdef __UNIX__ -#include + wxString result; + if ( prefix_zero_count == 8 ) + { + result = wxT( "::" ); + } + else if ( prefix_zero_count == 6 && words[5] == 0xFFFF ) + { + // IPv4 mapped + result.Printf("::ffff:%d.%d.%d.%d", + addr[12], addr[13], addr[14], addr[15]); + } + else // general case + { + result = ":"; + for ( i = prefix_zero_count; i < 8; ++i ) + { + result += wxString::Format(":%x", words[i]); + } + } -wxUNIXaddress::wxUNIXaddress() -{ - m_addr = new sockaddr_un; - Clear(); + return result; } -wxUNIXaddress::~wxUNIXaddress() +wxString wxIPV6address::Hostname() const { + char hostname[1024]; + hostname[0] = 0; + + if ( GAddress_INET6_GetHostName(m_address, + hostname, + WXSIZEOF(hostname)) != GSOCK_NOERROR ) + return wxEmptyString; + + return wxString::FromAscii(hostname); } -int wxUNIXaddress::SockAddrLen() +unsigned short wxIPV6address::Service() const { - return sizeof(*m_addr); + return GAddress_INET6_GetPort(m_address); } -int wxUNIXaddress::GetFamily() +#endif // wxUSE_IPV6 + +#if defined(__UNIX__) && !defined(__WINDOWS__) && !defined(__WINE__) + +// --------------------------------------------------------------------------- +// wxUNIXaddress +// --------------------------------------------------------------------------- + +wxUNIXaddress::wxUNIXaddress() + : wxSockAddress() { - return AF_UNIX; } -void wxUNIXaddress::Clear() +wxUNIXaddress::wxUNIXaddress(const wxUNIXaddress& other) + : wxSockAddress(other) { - memset(m_addr, 0, sizeof(m_addr)); - m_addr->sun_family = AF_UNIX; } -/* -const wxSockAddress& wxUNIXaddress::operator =(const wxSockAddress& addr) +wxUNIXaddress::~wxUNIXaddress() { - wxUNIXaddress *unx_addr = (wxUNIXaddress *)&addr; - CHECK_ADDRTYPE(addr, wxUNIXaddress); - m_addr = unx_addr->m_addr; - return *this; } -*/ void wxUNIXaddress::Filename(const wxString& fname) { - sprintf(m_addr->sun_path, "%s", MBSTRINGCAST fname.mb_str()); + GAddress_UNIX_SetPath(m_address, fname.fn_str()); } wxString wxUNIXaddress::Filename() { - return wxString(m_addr->sun_path); -} + char path[1024]; -void wxUNIXaddress::Build(struct sockaddr*& addr, size_t& len) -{ - addr = (struct sockaddr *)m_addr; - len = sizeof(*m_addr); -} + path[0] = 0; + GAddress_UNIX_GetPath(m_address, path, 1024); -void wxUNIXaddress::Disassemble(struct sockaddr *addr, size_t len) -{ - if (len != sizeof(*m_addr)) - return; - *m_addr = *(struct sockaddr_un *)addr; + return wxString::FromAscii(path); } -#endif -#endif +#endif // __UNIX__ + +#endif // wxUSE_SOCKETS