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 #ifndef WX_PRECOMP
  24 #endif
  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
  34 #include "wx/defs.h"
  35 #include "wx/object.h"
  36
  37 #if defined(__WXMAC__)
  38 #include "/wx/mac/macsock.h"
  39 #endif
  40
  41 #if defined(__WINDOWS__)
  42 #include <winsock.h>
  43 #endif // __WINDOWS__
  44
  45 #if defined(__UNIX__)
  46 #ifdef VMS
  47 #include <socket.h>
  48 #include <in.h>
  49 #else
  50 #include <sys/types.h>
  51 #include <sys/socket.h>
  52 #include <netinet/in.h>
  53 #include <arpa/inet.h>
  54 #endif
  55 #include <unistd.h>
  56 #include <netdb.h>
  57
  58 #endif // __UNIX__
  59
  60 #include "wx/sckaddr.h"
  61
  62 #define CHECK_ADDRTYPE(var, type)
  63
  64 #if !USE_SHARED_LIBRARY
  65 IMPLEMENT_ABSTRACT_CLASS(wxSockAddress, wxObject)
  66 IMPLEMENT_DYNAMIC_CLASS(wxIPV4address, wxSockAddress)
  67 #ifdef ENABLE_IPV6
  68 IMPLEMENT_DYNAMIC_CLASS(wxIPV6address, wxSockAddress)
  69 #endif
  70 #ifdef __UNIX__
  71 IMPLEMENT_DYNAMIC_CLASS(wxUNIXaddress, wxSockAddress)
  72 #endif
  73 #endif
  74
  75 wxIPV4address::wxIPV4address()
  76 {
  77   m_addr = new sockaddr_in;
  78   Clear();
  79 }
  80
  81 wxIPV4address::~wxIPV4address()
  82 {
  83 }
  84
  85 int wxIPV4address::SockAddrLen()
  86 {
  87   return sizeof(*m_addr);
  88 }
  89
  90 int wxIPV4address::GetFamily()
  91 {
  92   return AF_INET;
  93 }
  94
  95 void wxIPV4address::Clear()
  96 {
  97   memset(m_addr, 0, sizeof(*m_addr));
  98   m_addr->sin_family = AF_INET;
  99   m_addr->sin_addr.s_addr = INADDR_ANY;
 100 }
 101
 102 /*
 103 const wxSockAddress& wxIPV4address::operator =(const wxSockAddress& addr)
 104 {
 105   wxIPV4address *ip_addr = (wxIPV4address *)&addr;
 106   CHECK_ADDRTYPE(addr, wxIPV4address);
 107   m_addr = ip_addr->m_addr;
 108   return *this;
 109 }
 110 */
 111
 112 bool wxIPV4address::Hostname(const wxString& name)
 113 {
 114   struct hostent *theHostent;
 115   struct in_addr *addr;
 116
 117   if (name.IsNull())
 118     return FALSE;
 119
 120   if (!name.IsNumber()) {
 121     if ((theHostent = gethostbyname(name.GetData())) == 0) {
 122       return FALSE;
 123     }
 124   } else {
 125 #ifdef __WXMAC__
 126     long len_addr = inet_addr(name.GetData()).s_addr ;
 127 #else
 128     long len_addr = inet_addr(name.GetData());
 129 #endif
 130     if (len_addr == -1)
 131       return FALSE;
 132     m_addr->sin_addr.s_addr = len_addr;
 133     return TRUE;
 134   }
 135
 136   addr = (struct in_addr *) *(theHostent->h_addr_list);
 137
 138   m_addr->sin_addr.s_addr = addr[0].s_addr;
 139   return TRUE;
 140 }
 141
 142 bool wxIPV4address::Hostname(unsigned long addr)
 143 {
 144   m_addr->sin_addr.s_addr = htonl(addr);
 145   return TRUE;
 146 }
 147
 148 bool wxIPV4address::Service(const wxString& name)
 149 {
 150   struct servent *theServent;
 151
 152   if (name.IsNull())
 153     return FALSE;
 154
 155   if (!name.IsNumber()) {
 156     if ((theServent = getservbyname(name, "tcp")) == 0)
 157       return FALSE;
 158   } else {
 159     if ((theServent = getservbyport(atoi(name), "tcp")) == 0) {
 160       m_addr->sin_port = htons(atoi(name));
 161       return TRUE;
 162     }
 163   }
 164
 165   m_addr->sin_port = theServent->s_port;
 166   return TRUE;
 167 }
 168
 169 bool wxIPV4address::Service(unsigned short port)
 170 {
 171   m_addr->sin_port = htons(port);
 172   return TRUE;
 173 }
 174
 175 bool wxIPV4address::LocalHost()
 176 {
 177   static char buf[256];
 178
 179   if (gethostname(buf, sizeof(buf)) < 0)
 180     return Hostname("localhost");
 181   else
 182     return Hostname(buf);
 183 }
 184
 185 wxString wxIPV4address::Hostname()
 186 {
 187   struct hostent *h_ent;
 188
 189   h_ent = gethostbyaddr((char *)&(m_addr->sin_addr), sizeof(m_addr->sin_addr),
 190                         GetFamily());
 191   return wxString(h_ent->h_name);
 192 }
 193
 194 unsigned short wxIPV4address::Service()
 195 {
 196   return ntohs(m_addr->sin_port);
 197 }
 198
 199 void wxIPV4address::Build(struct sockaddr *&addr, size_t& len)
 200 {
 201   addr = (struct sockaddr *)m_addr;
 202   len = sizeof(*m_addr);
 203 }
 204
 205 void wxIPV4address::Disassemble(struct sockaddr *addr, size_t len)
 206 {
 207   if (len != sizeof(*m_addr))
 208     return;
 209   *m_addr = *(struct sockaddr_in *)addr;
 210 }
 211
 212 #ifdef IPV6_ENABLE
 213
 214 wxIPV6address::wxIPV6address()
 215 {
 216   m_addr = new sockaddr_in6;
 217   Clear();
 218 }
 219
 220 wxIPV6address::~wxIPV6address()
 221 {
 222 }
 223
 224 int wxIPV6address::SockAddrLen()
 225 {
 226   return sizeof(*m_addr);
 227 }
 228
 229 int wxIPV6address::GetFamily()
 230 {
 231   return AF_INET6;
 232 }
 233
 234 void wxIPV6address::Clear()
 235 {
 236   memset(m_addr, 0, sizeof(*m_addr));
 237   m_addr->sin6_family = AF_INET6;
 238   m_addr->sin6_addr.s_addr = INADDR_ANY;
 239 }
 240
 241 /*
 242 const wxSockAddress& wxIPV6address::operator =(const wxSockAddress& addr)
 243 {
 244   wxIPV6address *ip_addr = (wxIPV6address *)&addr;
 245
 246   CHECK_ADDRTYPE(addr, wxIPV6address);
 247   m_addr = ip_addr->m_addr;
 248   return *this;
 249 }
 250 */
 251
 252 bool wxIPV6address::Hostname(const wxString& name)
 253 {
 254   struct hostent *theHostent;
 255   struct in_addr *addr;
 256
 257   if (name.IsNull())
 258     return FALSE;
 259
 260   if (!name.IsNumber()) {
 261     hostent = gethostbyname2((char*) name, AF_INET6);
 262     if (!theHostent)
 263       return FALSE;
 264   } else {
 265     // Don't how to do
 266     return FALSE;
 267   }
 268
 269   addr = (struct in6_addr *) *(theHostent->h_addr_list);
 270
 271   m_addr->sin6_addr.s6_addr = addr[0].s6_addr;
 272   return TRUE;
 273 }
 274
 275 bool wxIPV6address::Hostname(unsigned char addr[16])
 276 {
 277   m_addr->sin6_addr.s6_addr = addr;
 278   return TRUE;
 279 }
 280
 281 bool wxIPV6address::Service(const char *name)
 282 {
 283   struct servent *theServent;
 284
 285   if (!name || !strlen(name))
 286     return FALSE;
 287
 288   if (!isdigit(*name)) {
 289     if ((theServent = getservbyname((char*) name, "tcp")) == 0)
 290       return FALSE;
 291   } else {
 292     if ((theServent = getservbyport(atoi(name), "tcp")) == 0) {
 293       m_addr->sin_port = htons(atoi(name));
 294       return TRUE;
 295     }
 296   }
 297
 298   m_addr->sin_port = theServent->s_port;
 299   return TRUE;
 300 }
 301
 302 bool wxIPV6address::Service(unsigned short port)
 303 {
 304   m_addr->sin_port = htons(port);
 305   return TRUE;
 306 }
 307
 308 bool wxIPV6address::LocalHost()
 309 {
 310   static char buf[256];
 311
 312   if (gethostname(buf, sizeof(buf)) < 0)
 313     return Hostname("localhost");
 314   else
 315     return Hostname(buf);
 316 }
 317
 318 const wxString& wxIPV6address::Hostname()
 319 {
 320   struct hostent *h_ent;
 321
 322   h_ent = gethostbyaddr((char *)&(m_addr->sin_addr), sizeof(m_addr->sin_addr),
 323                         GetFamily());
 324   return wxString(h_ent->h_name);
 325 }
 326
 327 unsigned short wxIPV6address::Service()
 328 {
 329   return ntohs(m_addr->sin_port);
 330 }
 331
 332 void wxIPV6address::Build(struct sockaddr& *addr, size_t& len)
 333 {
 334   len = sizeof(*m_addr);
 335   addr = m_addr;
 336 }
 337
 338 void wxIPV6address::Disassemble(struct sockaddr& *addr, size_t len)
 339 {
 340   if (len != sizeof(*m_addr))
 341     return;
 342   *m_addr = *(struct sockaddr_in6 *)addr;
 343 }
 344
 345 #endif
 346
 347 #ifdef __UNIX__
 348 #include <sys/un.h>
 349
 350 wxUNIXaddress::wxUNIXaddress()
 351 {
 352   m_addr = new sockaddr_un;
 353   Clear();
 354 }
 355
 356 wxUNIXaddress::~wxUNIXaddress()
 357 {
 358 }
 359
 360 int wxUNIXaddress::SockAddrLen()
 361 {
 362   return sizeof(*m_addr);
 363 }
 364
 365 int wxUNIXaddress::GetFamily()
 366 {
 367   return AF_UNIX;
 368 }
 369
 370 void wxUNIXaddress::Clear()
 371 {
 372   memset(m_addr, 0, sizeof(m_addr));
 373   m_addr->sun_family = AF_UNIX;
 374 }
 375
 376 /*
 377 const wxSockAddress& wxUNIXaddress::operator =(const wxSockAddress& addr)
 378 {
 379   wxUNIXaddress *unx_addr = (wxUNIXaddress *)&addr;
 380   CHECK_ADDRTYPE(addr, wxUNIXaddress);
 381   m_addr = unx_addr->m_addr;
 382   return *this;
 383 }
 384 */
 385
 386 void wxUNIXaddress::Filename(const wxString& fname)
 387 {
 388   sprintf(m_addr->sun_path, "%s", WXSTRINGCAST fname);
 389 }
 390
 391 wxString wxUNIXaddress::Filename()
 392 {
 393   return wxString(m_addr->sun_path);
 394 }
 395
 396 void wxUNIXaddress::Build(struct sockaddr*& addr, size_t& len)
 397 {
 398   addr = (struct sockaddr *)m_addr;
 399   len = sizeof(*m_addr);
 400 }
 401
 402 void wxUNIXaddress::Disassemble(struct sockaddr *addr, size_t len)
 403 {
 404   if (len != sizeof(*m_addr))
 405     return;
 406   *m_addr = *(struct sockaddr_un *)addr;
 407 }
 408 #endif