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::BroadcastAddress()
 182 {
 183   return (GAddress_INET_SetBroadcastAddress(m_address) == GSOCK_NOERROR);
 184 }
 185
 186 bool wxIPV4address::AnyAddress()
 187 {
 188   return (GAddress_INET_SetAnyAddress(m_address) == GSOCK_NOERROR);
 189 }
 190
 191 wxString wxIPV4address::Hostname() const
 192 {
 193    char hostname[1024];
 194
 195    hostname[0] = 0;
 196    GAddress_INET_GetHostName(m_address, hostname, 1024);
 197    return wxString::FromAscii(hostname);
 198 }
 199
 200 unsigned short wxIPV4address::Service() const
 201 {
 202   return GAddress_INET_GetPort(m_address);
 203 }
 204
 205 wxSockAddress *wxIPV4address::Clone() const
 206 {
 207     wxIPV4address *addr = new wxIPV4address(*this);
 208     addr->m_origHostname = m_origHostname;
 209     return addr;
 210 }
 211
 212 wxString wxIPV4address::IPAddress() const
 213 {
 214     unsigned long raw =  GAddress_INET_GetHostAddress(m_address);
 215     return wxString::Format(_T("%lu.%lu.%lu.%lu"),
 216                 (raw>>24) & 0xff,
 217                 (raw>>16) & 0xff,
 218                 (raw>>8) & 0xff,
 219                 raw & 0xff
 220         );
 221 }
 222
 223 bool wxIPV4address::operator==(const wxIPV4address& addr) const
 224 {
 225     return Hostname().Cmp(addr.Hostname()) == 0 &&
 226            Service() == addr.Service();
 227 }
 228
 229 #if wxUSE_IPV6
 230 // ---------------------------------------------------------------------------
 231 // wxIPV6address
 232 // ---------------------------------------------------------------------------
 233
 234 wxIPV6address::wxIPV6address()
 235   : wxIPaddress()
 236 {
 237 }
 238
 239 wxIPV6address::wxIPV6address(const wxIPV6address& other)
 240              : wxIPaddress(other)
 241 {
 242 }
 243
 244 wxIPV6address::~wxIPV6address()
 245 {
 246 }
 247
 248 bool wxIPV6address::Hostname(const wxString& name)
 249 {
 250   if (name.empty())
 251   {
 252     wxLogWarning( _("Trying to solve a NULL hostname: giving up") );
 253     return false;
 254   }
 255   return (GAddress_INET_SetHostName(m_address, name.mb_str()) == GSOCK_NOERROR);
 256 }
 257
 258 bool wxIPV6address::Hostname(unsigned char[16] WXUNUSED(addr))
 259 {
 260   return true;
 261 }
 262
 263 bool wxIPV6address::Service(const wxString& name)
 264 {
 265   return (GAddress_INET_SetPortName(m_address, name.mb_str(), "tcp") == GSOCK_NOERROR);
 266 }
 267
 268 bool wxIPV6address::Service(unsigned short port)
 269 {
 270   return (GAddress_INET_SetPort(m_address, port) == GSOCK_NOERROR);
 271 }
 272
 273 bool wxIPV6address::LocalHost()
 274 {
 275   return (GAddress_INET_SetHostName(m_address, "localhost") == GSOCK_NOERROR);
 276 }
 277
 278 bool wxIPV6address::IsLocalHost() const
 279 {
 280   return (Hostname() == wxT("localhost") || IPAddress() == wxT("127.0.0.1"));
 281 }
 282
 283 bool wxIPV6address::BroadcastAddress()
 284 {
 285   return (GAddress_INET_SetBroadcastAddress(m_address) == GSOCK_NOERROR);
 286 }
 287
 288 bool wxIPV6address::AnyAddress()
 289 {
 290   return (GAddress_INET_SetAnyAddress(m_address) == GSOCK_NOERROR);
 291 }
 292
 293 wxString wxIPV6address::IPAddress() const
 294 {
 295     unsigned long raw =  GAddress_INET_GetHostAddress(m_address);
 296     return wxString::Format(
 297         _T("%u.%u.%u.%u"),
 298         (unsigned char)((raw>>24) & 0xff),
 299         (unsigned char)((raw>>16) & 0xff),
 300         (unsigned char)((raw>>8) & 0xff),
 301         (unsigned char)(raw & 0xff)
 302         );
 303 }
 304
 305 wxString wxIPV6address::Hostname() const
 306 {
 307    char hostname[1024];
 308
 309    hostname[0] = 0;
 310    GAddress_INET_GetHostName(m_address, hostname, 1024);
 311    return wxString::FromAscii(hostname);
 312 }
 313
 314 unsigned short wxIPV6address::Service() const
 315 {
 316   return GAddress_INET_GetPort(m_address);
 317 }
 318
 319 #endif // wxUSE_IPV6
 320
 321 #if defined(__UNIX__) && !defined(__WINDOWS__) && !defined(__WINE__) && (!defined(__WXMAC__) || defined(__DARWIN__))
 322
 323 // ---------------------------------------------------------------------------
 324 // wxUNIXaddress
 325 // ---------------------------------------------------------------------------
 326
 327 wxUNIXaddress::wxUNIXaddress()
 328              : wxSockAddress()
 329 {
 330 }
 331
 332 wxUNIXaddress::wxUNIXaddress(const wxUNIXaddress& other)
 333              : wxSockAddress(other)
 334 {
 335 }
 336
 337 wxUNIXaddress::~wxUNIXaddress()
 338 {
 339 }
 340
 341 void wxUNIXaddress::Filename(const wxString& fname)
 342 {
 343   GAddress_UNIX_SetPath(m_address, fname.fn_str());
 344 }
 345
 346 wxString wxUNIXaddress::Filename()
 347 {
 348   char path[1024];
 349
 350   path[0] = 0;
 351   GAddress_UNIX_GetPath(m_address, path, 1024);
 352
 353   return wxString::FromAscii(path);
 354 }
 355
 356 #endif // __UNIX__
 357
 358 #endif
 359   // wxUSE_SOCKETS