src/common/sckaddr.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/sckaddr.cpp
   3 // Purpose:     Network address manager
   4 // Author:      Guilhem Lavaux
   5 // Modified by:
   6 // Created:     26/04/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1997, 1998 Guilhem Lavaux
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_SOCKETS
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/object.h"
  23     #include "wx/log.h"
  24     #include "wx/intl.h"
  25
  26     #include <stdio.h>
  27     #include <stdlib.h>
  28     #include <ctype.h>
  29
  30     #if !defined(__MWERKS__) && !defined(__SALFORDC__)
  31         #include <memory.h>
  32     #endif
  33 #endif // !WX_PRECOMP
  34
  35 #include "wx/gsocket.h"
  36 #include "wx/socket.h"
  37 #include "wx/sckaddr.h"
  38
  39 IMPLEMENT_ABSTRACT_CLASS(wxSockAddress, wxObject)
  40 IMPLEMENT_ABSTRACT_CLASS(wxIPaddress, wxSockAddress)
  41 IMPLEMENT_DYNAMIC_CLASS(wxIPV4address, wxIPaddress)
  42 #if wxUSE_IPV6
  43 IMPLEMENT_DYNAMIC_CLASS(wxIPV6address, wxIPaddress)
  44 #endif
  45 #if defined(__UNIX__) && !defined(__WINDOWS__) && !defined(__WINE__) && (!defined(__WXMAC__) || defined(__DARWIN__))
  46 IMPLEMENT_DYNAMIC_CLASS(wxUNIXaddress, wxSockAddress)
  47 #endif
  48
  49 // ---------------------------------------------------------------------------
  50 // wxSockAddress
  51 // ---------------------------------------------------------------------------
  52
  53 void wxSockAddress::Init()
  54 {
  55     if ( !wxSocketBase::IsInitialized() )
  56     {
  57         // we must do it before using GAddress_XXX functions
  58         (void)wxSocketBase::Initialize();
  59     }
  60 }
  61
  62 wxSockAddress::wxSockAddress()
  63 {
  64     Init();
  65
  66     m_address = GAddress_new();
  67 }
  68
  69 wxSockAddress::wxSockAddress(const wxSockAddress& other)
  70     : wxObject()
  71 {
  72     Init();
  73
  74     m_address = GAddress_copy(other.m_address);
  75 }
  76
  77 wxSockAddress::~wxSockAddress()
  78 {
  79   GAddress_destroy(m_address);
  80 }
  81
  82 void wxSockAddress::SetAddress(GAddress *address)
  83 {
  84     if ( address != m_address )
  85     {
  86         GAddress_destroy(m_address);
  87         m_address = GAddress_copy(address);
  88     }
  89 }
  90
  91 wxSockAddress& wxSockAddress::operator=(const wxSockAddress& addr)
  92 {
  93   SetAddress(addr.GetAddress());
  94   return *this;
  95 }
  96
  97 void wxSockAddress::Clear()
  98 {
  99   GAddress_destroy(m_address);
 100   m_address = GAddress_new();
 101 }
 102
 103 // ---------------------------------------------------------------------------
 104 // wxIPaddress
 105 // ---------------------------------------------------------------------------
 106
 107 wxIPaddress::wxIPaddress()
 108             : wxSockAddress()
 109 {
 110 }
 111
 112 wxIPaddress::wxIPaddress(const wxIPaddress& other)
 113             : wxSockAddress(other)
 114 {
 115 }
 116
 117 wxIPaddress::~wxIPaddress()
 118 {
 119 }
 120
 121 // ---------------------------------------------------------------------------
 122 // wxIPV4address
 123 // ---------------------------------------------------------------------------
 124
 125 wxIPV4address::wxIPV4address()
 126              : wxIPaddress()
 127 {
 128 }
 129
 130 wxIPV4address::wxIPV4address(const wxIPV4address& other)
 131              : wxIPaddress(other)
 132 {
 133 }
 134
 135 wxIPV4address::~wxIPV4address()
 136 {
 137 }
 138
 139 bool wxIPV4address::Hostname(const wxString& name)
 140 {
 141   // Some people are sometimes fool.
 142   if (name.empty())
 143   {
 144     wxLogWarning( _("Trying to solve a NULL hostname: giving up") );
 145     return false;
 146   }
 147   m_origHostname = name;
 148   return (GAddress_INET_SetHostName(m_address, name.mb_str()) == GSOCK_NOERROR);
 149 }
 150
 151 bool wxIPV4address::Hostname(unsigned long addr)
 152 {
 153   bool rv = (GAddress_INET_SetHostAddress(m_address, addr) == GSOCK_NOERROR);
 154   if (rv)
 155       m_origHostname = Hostname();
 156   else
 157       m_origHostname = wxEmptyString;
 158   return rv;
 159 }
 160
 161 bool wxIPV4address::Service(const wxString& name)
 162 {
 163   return (GAddress_INET_SetPortName(m_address, name.mb_str(), "tcp") == GSOCK_NOERROR);
 164 }
 165
 166 bool wxIPV4address::Service(unsigned short port)
 167 {
 168   return (GAddress_INET_SetPort(m_address, port) == GSOCK_NOERROR);
 169 }
 170
 171 bool wxIPV4address::LocalHost()
 172 {
 173   return (GAddress_INET_SetHostName(m_address, "localhost") == GSOCK_NOERROR);
 174 }
 175
 176 bool wxIPV4address::IsLocalHost() const
 177 {
 178   return (Hostname() == wxT("localhost") || IPAddress() == wxT("127.0.0.1"));
 179 }
 180
 181 bool wxIPV4address::AnyAddress()
 182 {
 183   return (GAddress_INET_SetAnyAddress(m_address) == GSOCK_NOERROR);
 184 }
 185
 186 wxString wxIPV4address::Hostname() const
 187 {
 188    char hostname[1024];
 189
 190    hostname[0] = 0;
 191    GAddress_INET_GetHostName(m_address, hostname, 1024);
 192    return wxString::FromAscii(hostname);
 193 }
 194
 195 unsigned short wxIPV4address::Service() const
 196 {
 197   return GAddress_INET_GetPort(m_address);
 198 }
 199
 200 wxSockAddress *wxIPV4address::Clone() const
 201 {
 202     wxIPV4address *addr = new wxIPV4address(*this);
 203     addr->m_origHostname = m_origHostname;
 204     return addr;
 205 }
 206
 207 wxString wxIPV4address::IPAddress() const
 208 {
 209     unsigned long raw =  GAddress_INET_GetHostAddress(m_address);
 210     return wxString::Format(_T("%lu.%lu.%lu.%lu"),
 211                 (raw>>24) & 0xff,
 212                 (raw>>16) & 0xff,
 213                 (raw>>8) & 0xff,
 214                 raw & 0xff
 215         );
 216 }
 217
 218 bool wxIPV4address::operator==(const wxIPV4address& addr) const
 219 {
 220     return Hostname().Cmp(addr.Hostname()) == 0 &&
 221            Service() == addr.Service();
 222 }
 223
 224 #if wxUSE_IPV6
 225 // ---------------------------------------------------------------------------
 226 // wxIPV6address
 227 // ---------------------------------------------------------------------------
 228
 229 wxIPV6address::wxIPV6address()
 230   : wxIPaddress()
 231 {
 232 }
 233
 234 wxIPV6address::wxIPV6address(const wxIPV6address& other)
 235              : wxIPaddress(other)
 236 {
 237 }
 238
 239 wxIPV6address::~wxIPV6address()
 240 {
 241 }
 242
 243 bool wxIPV6address::Hostname(const wxString& name)
 244 {
 245   if (name.empty())
 246   {
 247     wxLogWarning( _("Trying to solve a NULL hostname: giving up") );
 248     return false;
 249   }
 250   return (GAddress_INET_SetHostName(m_address, name.mb_str()) == GSOCK_NOERROR);
 251 }
 252
 253 bool wxIPV6address::Hostname(unsigned char[16] WXUNUSED(addr))
 254 {
 255   return true;
 256 }
 257
 258 bool wxIPV6address::Service(const wxString& name)
 259 {
 260   return (GAddress_INET_SetPortName(m_address, name.mb_str(), "tcp") == GSOCK_NOERROR);
 261 }
 262
 263 bool wxIPV6address::Service(unsigned short port)
 264 {
 265   return (GAddress_INET_SetPort(m_address, port) == GSOCK_NOERROR);
 266 }
 267
 268 bool wxIPV6address::LocalHost()
 269 {
 270   return (GAddress_INET_SetHostName(m_address, "localhost") == GSOCK_NOERROR);
 271 }
 272
 273 bool wxIPV6address::IsLocalHost() const
 274 {
 275   return (Hostname() == wxT("localhost") || IPAddress() == wxT("127.0.0.1"));
 276 }
 277
 278 bool wxIPV6address::AnyAddress()
 279 {
 280   return (GAddress_INET_SetAnyAddress(m_address) == GSOCK_NOERROR);
 281 }
 282
 283 wxString wxIPV6address::IPAddress() const
 284 {
 285     unsigned long raw =  GAddress_INET_GetHostAddress(m_address);
 286     return wxString::Format(
 287         _T("%u.%u.%u.%u"),
 288         (unsigned char)((raw>>24) & 0xff),
 289         (unsigned char)((raw>>16) & 0xff),
 290         (unsigned char)((raw>>8) & 0xff),
 291         (unsigned char)(raw & 0xff)
 292         );
 293 }
 294
 295 wxString wxIPV6address::Hostname() const
 296 {
 297    char hostname[1024];
 298
 299    hostname[0] = 0;
 300    GAddress_INET_GetHostName(m_address, hostname, 1024);
 301    return wxString::FromAscii(hostname);
 302 }
 303
 304 unsigned short wxIPV6address::Service() const
 305 {
 306   return GAddress_INET_GetPort(m_address);
 307 }
 308
 309 #endif // wxUSE_IPV6
 310
 311 #if defined(__UNIX__) && !defined(__WINDOWS__) && !defined(__WINE__) && (!defined(__WXMAC__) || defined(__DARWIN__))
 312
 313 // ---------------------------------------------------------------------------
 314 // wxUNIXaddress
 315 // ---------------------------------------------------------------------------
 316
 317 wxUNIXaddress::wxUNIXaddress()
 318              : wxSockAddress()
 319 {
 320 }
 321
 322 wxUNIXaddress::wxUNIXaddress(const wxUNIXaddress& other)
 323              : wxSockAddress(other)
 324 {
 325 }
 326
 327 wxUNIXaddress::~wxUNIXaddress()
 328 {
 329 }
 330
 331 void wxUNIXaddress::Filename(const wxString& fname)
 332 {
 333   GAddress_UNIX_SetPath(m_address, fname.fn_str());
 334 }
 335
 336 wxString wxUNIXaddress::Filename()
 337 {
 338   char path[1024];
 339
 340   path[0] = 0;
 341   GAddress_UNIX_GetPath(m_address, path, 1024);
 342
 343   return wxString::FromAscii(path);
 344 }
 345
 346 #endif // __UNIX__
 347
 348 #endif
 349   // wxUSE_SOCKETS