src/common/sckaddr.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13   #pragma implementation "sckaddr.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20   #pragma hdrstop
  21 #endif
  22
  23 #if wxUSE_SOCKETS
  24
  25 #ifndef WX_PRECOMP
  26     #include "wx/defs.h"
  27     #include "wx/object.h"
  28     #include "wx/log.h"
  29     #include "wx/intl.h"
  30
  31     #include <stdio.h>
  32     #include <stdlib.h>
  33     #include <ctype.h>
  34
  35     #if !defined(__MWERKS__) && !defined(__SALFORDC__)
  36         #include <memory.h>
  37     #endif
  38 #endif // !WX_PRECOMP
  39
  40 #include "wx/gsocket.h"
  41 #include "wx/socket.h"
  42 #include "wx/sckaddr.h"
  43
  44 IMPLEMENT_ABSTRACT_CLASS(wxSockAddress, wxObject)
  45 IMPLEMENT_DYNAMIC_CLASS(wxIPV4address, wxSockAddress)
  46 #ifdef ENABLE_IPV6
  47 IMPLEMENT_DYNAMIC_CLASS(wxIPV6address, wxSockAddress)
  48 #endif
  49 #if defined(__UNIX__) && !defined(__WINE__) && (!defined(__WXMAC__) || defined(__DARWIN__))
  50 IMPLEMENT_DYNAMIC_CLASS(wxUNIXaddress, wxSockAddress)
  51 #endif
  52
  53 // ---------------------------------------------------------------------------
  54 // wxIPV4address
  55 // ---------------------------------------------------------------------------
  56
  57 void wxSockAddress::Init()
  58 {
  59     if ( !wxSocketBase::IsInitialized() )
  60     {
  61         // we must do it before using GAddress_XXX functions
  62         (void)wxSocketBase::Initialize();
  63     }
  64 }
  65
  66 wxSockAddress::wxSockAddress()
  67 {
  68     Init();
  69
  70     m_address = GAddress_new();
  71 }
  72
  73 wxSockAddress::wxSockAddress(const wxSockAddress& other)
  74     : wxObject()
  75 {
  76     Init();
  77
  78     m_address = GAddress_copy(other.m_address);
  79 }
  80
  81 wxSockAddress::~wxSockAddress()
  82 {
  83   GAddress_destroy(m_address);
  84 }
  85
  86 void wxSockAddress::SetAddress(GAddress *address)
  87 {
  88   GAddress_destroy(m_address);
  89   m_address = GAddress_copy(address);
  90 }
  91
  92 wxSockAddress& wxSockAddress::operator=(const wxSockAddress& addr)
  93 {
  94   SetAddress(addr.GetAddress());
  95   return *this;
  96 }
  97
  98 void wxSockAddress::Clear()
  99 {
 100   GAddress_destroy(m_address);
 101   m_address = GAddress_new();
 102 }
 103
 104 // ---------------------------------------------------------------------------
 105 // wxIPV4address
 106 // ---------------------------------------------------------------------------
 107
 108 wxIPV4address::wxIPV4address()
 109 {
 110 }
 111
 112 wxIPV4address::wxIPV4address(const wxIPV4address& other)
 113              : wxSockAddress(other)
 114 {
 115 }
 116
 117 wxIPV4address::~wxIPV4address()
 118 {
 119 }
 120
 121 bool wxIPV4address::Hostname(const wxString& name)
 122 {
 123   // Some people are sometimes fool.
 124   if (name == wxT(""))
 125   {
 126     wxLogWarning( _("Trying to solve a NULL hostname: giving up") );
 127     return FALSE;
 128   }
 129   m_origHostname = name;
 130   return (GAddress_INET_SetHostName(m_address, name.mb_str()) == GSOCK_NOERROR);
 131 }
 132
 133 bool wxIPV4address::Hostname(unsigned long addr)
 134 {
 135   bool rv = (GAddress_INET_SetHostAddress(m_address, addr) == GSOCK_NOERROR);
 136   if (rv)
 137       m_origHostname = Hostname();
 138   else
 139       m_origHostname = wxEmptyString;
 140   return rv;
 141 }
 142
 143 bool wxIPV4address::Service(const wxString& name)
 144 {
 145   return (GAddress_INET_SetPortName(m_address, name.mb_str(), "tcp") == GSOCK_NOERROR);
 146 }
 147
 148 bool wxIPV4address::Service(unsigned short port)
 149 {
 150   return (GAddress_INET_SetPort(m_address, port) == GSOCK_NOERROR);
 151 }
 152
 153 bool wxIPV4address::LocalHost()
 154 {
 155   return (GAddress_INET_SetHostName(m_address, "localhost") == GSOCK_NOERROR);
 156 }
 157
 158 bool wxIPV4address::AnyAddress()
 159 {
 160   return (GAddress_INET_SetAnyAddress(m_address) == GSOCK_NOERROR);
 161 }
 162
 163 wxString wxIPV4address::Hostname()
 164 {
 165    char hostname[1024];
 166
 167    hostname[0] = 0;
 168    GAddress_INET_GetHostName(m_address, hostname, 1024);
 169    return wxString::FromAscii(hostname);
 170 }
 171
 172 unsigned short wxIPV4address::Service()
 173 {
 174   return GAddress_INET_GetPort(m_address);
 175 }
 176
 177 wxSockAddress *wxIPV4address::Clone() const
 178 {
 179     wxIPV4address *addr = new wxIPV4address(*this);
 180     addr->m_origHostname = m_origHostname;
 181     return addr;
 182 }
 183
 184 wxString wxIPV4address::IPAddress() const
 185 {
 186         unsigned long raw =  GAddress_INET_GetHostAddress(m_address);
 187         return wxString::Format(
 188                 _T("%u.%u.%u.%u"),
 189                 (unsigned char)(raw & 0xff),
 190                 (unsigned char)((raw>>8) & 0xff),
 191                 (unsigned char)((raw>>16) & 0xff),
 192                 (unsigned char)((raw>>24) & 0xff)
 193                 );
 194 }
 195
 196 #if 0
 197 // ---------------------------------------------------------------------------
 198 // wxIPV6address
 199 // ---------------------------------------------------------------------------
 200
 201 wxIPV6address::wxIPV6address()
 202   : wxSockAddress()
 203 {
 204 }
 205
 206 wxIPV6address::wxIPV6address(const wxIPV6address& other)
 207              : wxSockAddress(other)
 208 {
 209 }
 210
 211 wxIPV6address::~wxIPV6address()
 212 {
 213 }
 214
 215 bool wxIPV6address::Hostname(const wxString& name)
 216 {
 217   return (GAddress_INET_SetHostName(m_address, name.fn_str()) == GSOCK_NOERROR);
 218 }
 219
 220 bool wxIPV6address::Hostname(unsigned char addr[16])
 221 {
 222   return TRUE;
 223 }
 224
 225 bool wxIPV6address::Service(const char *name)
 226 {
 227   return (GAddress_INET_SetPortName(m_address, name.fn_str()) == GSOCK_NOERROR);
 228 }
 229
 230 bool wxIPV6address::Service(unsigned short port)
 231 {
 232   return (GAddress_INET_SetPort(m_address, port) == GSOCK_NOERROR);
 233 }
 234
 235 bool wxIPV6address::LocalHost()
 236 {
 237   return (GAddress_INET_SetHostName(m_address, "localhost") == GSOCK_NOERROR);
 238 }
 239
 240 const wxString& wxIPV6address::Hostname()
 241 {
 242   return wxString(GAddress_INET_GetHostName(m_address));
 243 }
 244
 245 unsigned short wxIPV6address::Service()
 246 {
 247   return GAddress_INET_GetPort(m_address);
 248 }
 249
 250 #endif // 0
 251
 252 #if defined(__UNIX__) && !defined(__WINE__) && (!defined(__WXMAC__) || defined(__DARWIN__))
 253
 254 // ---------------------------------------------------------------------------
 255 // wxUNIXaddress
 256 // ---------------------------------------------------------------------------
 257
 258 wxUNIXaddress::wxUNIXaddress()
 259              : wxSockAddress()
 260 {
 261 }
 262
 263 wxUNIXaddress::wxUNIXaddress(const wxUNIXaddress& other)
 264              : wxSockAddress(other)
 265 {
 266 }
 267
 268 wxUNIXaddress::~wxUNIXaddress()
 269 {
 270 }
 271
 272 void wxUNIXaddress::Filename(const wxString& fname)
 273 {
 274   GAddress_UNIX_SetPath(m_address, fname.fn_str());
 275 }
 276
 277 wxString wxUNIXaddress::Filename()
 278 {
 279   char path[1024];
 280
 281   path[0] = 0;
 282   GAddress_UNIX_GetPath(m_address, path, 1024);
 283
 284   return wxString::FromAscii(path);
 285 }
 286
 287 #endif // __UNIX__
 288
 289 #endif
 290   // wxUSE_SOCKETS