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 license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  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(__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 = "";
 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(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 #if 0
 185 // ---------------------------------------------------------------------------
 186 // wxIPV6address
 187 // ---------------------------------------------------------------------------
 188
 189 wxIPV6address::wxIPV6address()
 190   : wxSockAddress()
 191 {
 192 }
 193
 194 wxIPV6address::wxIPV6address(const wxIPV6address& other)
 195              : wxSockAddress(other)
 196 {
 197 }
 198
 199 wxIPV6address::~wxIPV6address()
 200 {
 201 }
 202
 203 bool wxIPV6address::Hostname(const wxString& name)
 204 {
 205   return (GAddress_INET_SetHostName(m_address, name.fn_str()) == GSOCK_NOERROR);
 206 }
 207
 208 bool wxIPV6address::Hostname(unsigned char addr[16])
 209 {
 210   return TRUE;
 211 }
 212
 213 bool wxIPV6address::Service(const char *name)
 214 {
 215   return (GAddress_INET_SetPortName(m_address, name.fn_str()) == GSOCK_NOERROR);
 216 }
 217
 218 bool wxIPV6address::Service(unsigned short port)
 219 {
 220   return (GAddress_INET_SetPort(m_address, port) == GSOCK_NOERROR);
 221 }
 222
 223 bool wxIPV6address::LocalHost()
 224 {
 225   return (GAddress_INET_SetHostName(m_address, "localhost") == GSOCK_NOERROR);
 226 }
 227
 228 const wxString& wxIPV6address::Hostname()
 229 {
 230   return wxString(GAddress_INET_GetHostName(m_address));
 231 }
 232
 233 unsigned short wxIPV6address::Service()
 234 {
 235   return GAddress_INET_GetPort(m_address);
 236 }
 237
 238 #endif // 0
 239
 240 #if defined(__UNIX__) && (!defined(__WXMAC__) || defined(__DARWIN__))
 241
 242 // ---------------------------------------------------------------------------
 243 // wxUNIXaddress
 244 // ---------------------------------------------------------------------------
 245
 246 wxUNIXaddress::wxUNIXaddress()
 247              : wxSockAddress()
 248 {
 249 }
 250
 251 wxUNIXaddress::wxUNIXaddress(const wxUNIXaddress& other)
 252              : wxSockAddress(other)
 253 {
 254 }
 255
 256 wxUNIXaddress::~wxUNIXaddress()
 257 {
 258 }
 259
 260 void wxUNIXaddress::Filename(const wxString& fname)
 261 {
 262   GAddress_UNIX_SetPath(m_address, fname.fn_str());
 263 }
 264
 265 wxString wxUNIXaddress::Filename()
 266 {
 267   char path[1024];
 268
 269   path[0] = 0;
 270   GAddress_UNIX_GetPath(m_address, path, 1024);
 271   return wxString(path);
 272 }
 273
 274 #endif // __UNIX__
 275
 276 #endif
 277   // wxUSE_SOCKETS