src/common/sckaddr.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/sckaddr.cpp
   3 // Purpose:     Network address manager
   4 // Author:      Guilhem Lavaux
   5 // Created:     26/04/97
   6 // Modified by: Vadim Zeitlin to use wxSockAddressImpl on 2008-12-28
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1997, 1998 Guilhem Lavaux
   9 //              (c) 2008 Vadim Zeitlin
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // ============================================================================
  14 // declarations
  15 // ============================================================================
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 // For compilers that support precompilation, includes "wx.h".
  22 #include "wx/wxprec.h"
  23
  24 #ifdef __BORLANDC__
  25     #pragma hdrstop
  26 #endif
  27
  28 #if wxUSE_SOCKETS
  29
  30 #ifndef WX_PRECOMP
  31     #include "wx/object.h"
  32     #include "wx/log.h"
  33     #include "wx/intl.h"
  34
  35     #include <stdio.h>
  36     #include <stdlib.h>
  37     #include <ctype.h>
  38
  39     #if !defined(__MWERKS__)
  40         #include <memory.h>
  41     #endif
  42 #endif // !WX_PRECOMP
  43
  44 #include "wx/socket.h"
  45 #include "wx/sckaddr.h"
  46 #include "wx/private/socket.h"
  47 #include "wx/private/sckaddr.h"
  48
  49 #include <errno.h>
  50
  51 #ifdef __UNIX__
  52     #include <netdb.h>
  53     #include <arpa/inet.h>
  54 #endif // __UNIX__
  55
  56 #ifndef INADDR_NONE
  57     #define INADDR_NONE INADDR_ANY
  58 #endif
  59
  60 // ----------------------------------------------------------------------------
  61 // wxRTTI macros
  62 // ----------------------------------------------------------------------------
  63
  64 IMPLEMENT_ABSTRACT_CLASS(wxSockAddress, wxObject)
  65 IMPLEMENT_ABSTRACT_CLASS(wxIPaddress, wxSockAddress)
  66 IMPLEMENT_DYNAMIC_CLASS(wxIPV4address, wxIPaddress)
  67 #if wxUSE_IPV6
  68 IMPLEMENT_DYNAMIC_CLASS(wxIPV6address, wxIPaddress)
  69 #endif
  70 #if defined(__UNIX__) && !defined(__WINDOWS__) && !defined(__WINE__)
  71 IMPLEMENT_DYNAMIC_CLASS(wxUNIXaddress, wxSockAddress)
  72 #endif
  73
  74 // ============================================================================
  75 // implementation of thread-safe/reentrant functions if they're missing
  76 // ============================================================================
  77
  78 // TODO: use POSIX getaddrinfo() (also available in Winsock 2) for simplicity
  79 //       and to use the same code for IPv4 and IPv6 support
  80
  81 #ifdef __WXMSW__
  82     #define HAVE_INET_ADDR
  83
  84     #define HAVE_GETHOSTBYNAME
  85     #define HAVE_GETSERVBYNAME
  86
  87     // under MSW getxxxbyname() functions are MT-safe (but not reentrant) so
  88     // we don't need to serialize calls to them
  89     #define wxHAS_MT_SAFE_GETBY_FUNCS
  90
  91     #if wxUSE_IPV6
  92         // this header does dynamic dispatching of getaddrinfo/freeaddrinfo()
  93         // by implementing them in its own code if the system versions are not
  94         // available (as is the case for anything < XP)
  95         //
  96         // NB: if this is not available for the other compilers (so far tested
  97         //      with MSVC only) we should just use wxDynamicLibrary "manually"
  98         #ifdef __VISUALC__
  99             // disable a warning occurring in Microsoft own version of this file
 100             #pragma warning(disable:4706)
 101         #endif
 102         #include <wspiapi.h>
 103         #ifdef __VISUALC__
 104             #pragma warning(default:4706)
 105         #endif
 106     #endif
 107 #endif // __WXMSW__
 108
 109 // we assume that we have gethostbyaddr_r() if and only if we have
 110 // gethostbyname_r() and that it uses the similar conventions to it (see
 111 // comment in configure)
 112 #define HAVE_GETHOSTBYADDR HAVE_GETHOSTBYNAME
 113 #ifdef HAVE_FUNC_GETHOSTBYNAME_R_3
 114     #define HAVE_FUNC_GETHOSTBYADDR_R_3
 115 #endif
 116 #ifdef HAVE_FUNC_GETHOSTBYNAME_R_5
 117     #define HAVE_FUNC_GETHOSTBYADDR_R_5
 118 #endif
 119 #ifdef HAVE_FUNC_GETHOSTBYNAME_R_6
 120     #define HAVE_FUNC_GETHOSTBYADDR_R_6
 121 #endif
 122
 123 // the _r functions need the extra buffer parameter but unfortunately its type
 124 // differs between different systems and for the systems which use opaque
 125 // structs for it (at least AIX and OpenBSD) it must be zero-filled before
 126 // being passed to the system functions
 127 #ifdef HAVE_FUNC_GETHOSTBYNAME_R_3
 128     struct wxGethostBuf : hostent_data
 129     {
 130         wxGethostBuf()
 131         {
 132             memset(this, 0, sizeof(hostent_data));
 133         }
 134     };
 135 #else
 136     typedef char wxGethostBuf[1024];
 137 #endif
 138
 139 #ifdef HAVE_FUNC_GETSERVBYNAME_R_4
 140     struct wxGetservBuf : servent_data
 141     {
 142         wxGethostBuf()
 143         {
 144             memset(this, 0, sizeof(servent_data));
 145         }
 146     };
 147 #else
 148     typedef char wxGetservBuf[1024];
 149 #endif
 150
 151 #if defined(wxHAS_MT_SAFE_GETBY_FUNCS) || !wxUSE_THREADS
 152     #define wxLOCK_GETBY_MUTEX(name)
 153 #else // may need mutexes to protect getxxxbyxxx() calls
 154     #if defined(HAVE_GETHOSTBYNAME) || \
 155         defined(HAVE_GETHOSTBYADDR) || \
 156         defined(HAVE_GETSERVBYNAME)
 157         #include "wx/thread.h"
 158
 159         namespace
 160         {
 161             // these mutexes are used to serialize
 162             wxMutex nameLock,   // gethostbyname()
 163                     addrLock,   // gethostbyaddr()
 164                     servLock;   // getservbyname()
 165         }
 166
 167         #define wxLOCK_GETBY_MUTEX(name) wxMutexLocker locker(name ## Lock)
 168     #endif // we don't have _r functions
 169 #endif // wxUSE_THREADS
 170
 171 namespace
 172 {
 173
 174 #if defined(HAVE_GETHOSTBYNAME)
 175 hostent *deepCopyHostent(hostent *h,
 176                          const hostent *he,
 177                          char *buffer,
 178                          int size,
 179                          int *err)
 180 {
 181     /* copy old structure */
 182     memcpy(h, he, sizeof(hostent));
 183
 184     /* copy name */
 185     int len = strlen(h->h_name);
 186     if (len > size)
 187     {
 188         *err = ENOMEM;
 189         return NULL;
 190     }
 191     memcpy(buffer, h->h_name, len);
 192     buffer[len] = '\0';
 193     h->h_name = buffer;
 194
 195     /* track position in the buffer */
 196     int pos = len + 1;
 197
 198     /* reuse len to store address length */
 199     len = h->h_length;
 200
 201     /* ensure pointer alignment */
 202     unsigned int misalign = sizeof(char *) - pos%sizeof(char *);
 203     if(misalign < sizeof(char *))
 204         pos += misalign;
 205
 206     /* leave space for pointer list */
 207     char **p = h->h_addr_list, **q;
 208     char **h_addr_list = (char **)(buffer + pos);
 209     while(*(p++) != 0)
 210         pos += sizeof(char *);
 211
 212     /* copy addresses and fill new pointer list */
 213     for (p = h->h_addr_list, q = h_addr_list; *p != 0; p++, q++)
 214     {
 215         if (size < pos + len)
 216         {
 217             *err = ENOMEM;
 218             return NULL;
 219         }
 220         memcpy(buffer + pos, *p, len); /* copy content */
 221         *q = buffer + pos; /* set copied pointer to copied content */
 222         pos += len;
 223     }
 224     *++q = 0; /* null terminate the pointer list */
 225     h->h_addr_list = h_addr_list; /* copy pointer to pointers */
 226
 227     /* ensure word alignment of pointers */
 228     misalign = sizeof(char *) - pos%sizeof(char *);
 229     if(misalign < sizeof(char *))
 230         pos += misalign;
 231
 232     /* leave space for pointer list */
 233     p = h->h_aliases;
 234     char **h_aliases = (char **)(buffer + pos);
 235     while(*(p++) != 0)
 236         pos += sizeof(char *);
 237
 238     /* copy aliases and fill new pointer list */
 239     for (p = h->h_aliases, q = h_aliases; *p != 0; p++, q++)
 240     {
 241         len = strlen(*p);
 242         if (size <= pos + len)
 243         {
 244             *err = ENOMEM;
 245             return NULL;
 246         }
 247         memcpy(buffer + pos, *p, len); /* copy content */
 248         buffer[pos + len] = '\0';
 249         *q = buffer + pos; /* set copied pointer to copied content */
 250         pos += len + 1;
 251     }
 252     *++q = 0; /* null terminate the pointer list */
 253     h->h_aliases = h_aliases; /* copy pointer to pointers */
 254
 255     return h;
 256 }
 257 #endif // HAVE_GETHOSTBYNAME
 258
 259 hostent *wxGethostbyname_r(const char *hostname,
 260                            hostent *h,
 261                            wxGethostBuf buffer,
 262                            int size,
 263                            int *err)
 264 {
 265     hostent *he;
 266 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
 267     gethostbyname_r(hostname, h, buffer, size, &he, err);
 268 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
 269     he = gethostbyname_r(hostname, h, buffer, size, err);
 270 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
 271     he = gethostbyname_r(hostname, h,  &buffer);
 272     *err = h_errno;
 273 #elif defined(HAVE_GETHOSTBYNAME)
 274     wxLOCK_GETBY_MUTEX(name);
 275
 276     he = gethostbyname(hostname);
 277     *err = h_errno;
 278
 279     if ( he )
 280         he = deepCopyHostent(h, he, buffer, size, err);
 281 #else
 282     #error "No gethostbyname[_r]()"
 283 #endif
 284
 285     return he;
 286 }
 287
 288 hostent *wxGethostbyaddr_r(const char *addr_buf,
 289                            int buf_size,
 290                            int proto,
 291                            hostent *h,
 292                            wxGethostBuf buffer,
 293                            int size,
 294                            int *err)
 295 {
 296     hostent *he;
 297 #if defined(HAVE_FUNC_GETHOSTBYADDR_R_6)
 298     gethostbyaddr_r(addr_buf, buf_size, proto, h, buffer, size, &he, err);
 299 #elif defined(HAVE_FUNC_GETHOSTBYADDR_R_5)
 300     he = gethostbyaddr_r(addr_buf, buf_size, proto, h, buffer, size, err);
 301 #elif defined(HAVE_FUNC_GETHOSTBYADDR_R_3)
 302     he = gethostbyaddr_r(addr_buf, buf_size, proto, h, buffer);
 303     *err = h_errno;
 304 #elif defined(HAVE_GETHOSTBYADDR)
 305     wxLOCK_GETBY_MUTEX(addr);
 306
 307     he = gethostbyaddr(addr_buf, buf_size, proto);
 308     *err = h_errno;
 309
 310     if ( he )
 311         he = deepCopyHostent(h, he, buffer, size, err);
 312 #else
 313     #error "No gethostbyaddr[_r]()"
 314 #endif
 315
 316     return he;
 317 }
 318
 319 #if defined(HAVE_GETSERVBYNAME)
 320 servent *deepCopyServent(servent *s,
 321                          servent *se,
 322                          char *buffer,
 323                          int size)
 324 {
 325     /* copy plain old structure */
 326     memcpy(s, se, sizeof(servent));
 327
 328     /* copy name */
 329     int len = strlen(s->s_name);
 330     if (len >= size)
 331     {
 332         return NULL;
 333     }
 334     memcpy(buffer, s->s_name, len);
 335     buffer[len] = '\0';
 336     s->s_name = buffer;
 337
 338     /* track position in the buffer */
 339     int pos = len + 1;
 340
 341     /* copy protocol */
 342     len = strlen(s->s_proto);
 343     if (pos + len >= size)
 344     {
 345         return NULL;
 346     }
 347     memcpy(buffer + pos, s->s_proto, len);
 348     buffer[pos + len] = '\0';
 349     s->s_proto = buffer + pos;
 350
 351     /* track position in the buffer */
 352     pos += len + 1;
 353
 354     /* ensure pointer alignment */
 355     unsigned int misalign = sizeof(char *) - pos%sizeof(char *);
 356     if(misalign < sizeof(char *))
 357         pos += misalign;
 358
 359     /* leave space for pointer list */
 360     char **p = s->s_aliases, **q;
 361     char **s_aliases = (char **)(buffer + pos);
 362     while(*(p++) != 0)
 363         pos += sizeof(char *);
 364
 365     /* copy addresses and fill new pointer list */
 366     for (p = s->s_aliases, q = s_aliases; *p != 0; p++, q++){
 367         len = strlen(*p);
 368         if (size <= pos + len)
 369         {
 370             return NULL;
 371         }
 372         memcpy(buffer + pos, *p, len); /* copy content */
 373         buffer[pos + len] = '\0';
 374         *q = buffer + pos; /* set copied pointer to copied content */
 375         pos += len + 1;
 376     }
 377     *++q = 0; /* null terminate the pointer list */
 378     s->s_aliases = s_aliases; /* copy pointer to pointers */
 379     return s;
 380 }
 381 #endif // HAVE_GETSERVBYNAME
 382
 383 servent *wxGetservbyname_r(const char *port,
 384                            const char *protocol,
 385                            servent *serv,
 386                            wxGetservBuf& buffer,
 387                            int size)
 388 {
 389     servent *se;
 390 #if defined(HAVE_FUNC_GETSERVBYNAME_R_6)
 391     getservbyname_r(port, protocol, serv, buffer, size, &se);
 392 #elif defined(HAVE_FUNC_GETSERVBYNAME_R_5)
 393     se = getservbyname_r(port, protocol, serv, buffer, size);
 394 #elif defined(HAVE_FUNC_GETSERVBYNAME_R_4)
 395     if ( getservbyname_r(port, protocol, serv, &buffer) != 0 )
 396         return NULL;
 397 #elif defined(HAVE_GETSERVBYNAME)
 398     wxLOCK_GETBY_MUTEX(serv);
 399
 400     se = getservbyname(port, protocol);
 401     if ( se )
 402         se = deepCopyServent(serv, se, buffer, size);
 403 #else
 404     #error "No getservbyname[_r]()"
 405 #endif
 406     return se;
 407 }
 408
 409 } // anonymous namespace
 410
 411 // ============================================================================
 412 // wxSockAddressImpl implementation
 413 // ============================================================================
 414
 415 // FIXME-VC6: helper macros to call Alloc/Get() hiding the ugly dummy argument
 416 #define ALLOC(T) Alloc(static_cast<T *>(NULL))
 417 #define GET(T) Get(static_cast<T *>(NULL))
 418
 419 // ----------------------------------------------------------------------------
 420 // INET or INET6 address family
 421 // ----------------------------------------------------------------------------
 422
 423 wxString wxSockAddressImpl::GetHostName() const
 424 {
 425     const void *addrbuf;
 426     int addrbuflen;
 427
 428 #if wxUSE_IPV6
 429     if ( m_family == FAMILY_INET6 )
 430     {
 431         sockaddr_in6 * const addr6 = GET(sockaddr_in6);
 432         addrbuf = &addr6->sin6_addr;
 433         addrbuflen = sizeof(addr6->sin6_addr);
 434     }
 435     else
 436 #endif // wxUSE_IPV6
 437     {
 438         sockaddr_in * const addr = GET(sockaddr_in);
 439         if ( !addr )
 440             return wxString();
 441
 442         addrbuf = &addr->sin_addr;
 443         addrbuflen = sizeof(addr->sin_addr);
 444     }
 445
 446     hostent he;
 447     wxGethostBuf buffer;
 448     int err;
 449     if ( !wxGethostbyaddr_r
 450           (
 451             static_cast<const char *>(addrbuf),
 452             addrbuflen,
 453             m_family,
 454             &he,
 455             buffer,
 456             sizeof(buffer),
 457             &err
 458           ) )
 459     {
 460         return wxString();
 461     }
 462
 463     return wxString::FromUTF8(he.h_name);
 464 }
 465
 466 bool wxSockAddressImpl::SetPortName(const wxString& name, const char *protocol)
 467 {
 468     // test whether it's a number first
 469     unsigned long port;
 470     if ( name.ToULong(&port) )
 471     {
 472         if ( port > 65535 )
 473             return false;
 474     }
 475     else // it's a service name
 476     {
 477         wxGetservBuf buffer;
 478         servent se;
 479         if ( !wxGetservbyname_r(name.utf8_str(), protocol, &se,
 480                                 buffer, sizeof(buffer)) )
 481             return false;
 482
 483         // s_port is in network byte order and SetPort() uses the host byte
 484         // order and we prefer to reuse it from here instead of assigning to
 485         // sin_port directly
 486         port = ntohs(se.s_port);
 487     }
 488
 489     return SetPort(port);
 490 }
 491
 492 // ----------------------------------------------------------------------------
 493 // INET address family
 494 // ----------------------------------------------------------------------------
 495
 496 void wxSockAddressImpl::CreateINET()
 497 {
 498     wxASSERT_MSG( Is(FAMILY_UNSPEC), "recreating address as different type?" );
 499
 500     m_family = FAMILY_INET;
 501     sockaddr_in * const addr = ALLOC(sockaddr_in);
 502     addr->sin_family = FAMILY_INET;
 503 }
 504
 505 bool wxSockAddressImpl::SetHostName4(const wxString& name)
 506 {
 507     sockaddr_in * const addr = GET(sockaddr_in);
 508     if ( !addr )
 509         return false;
 510
 511     const wxScopedCharBuffer namebuf(name.utf8_str());
 512
 513     // first check if this is an address in quad dotted notation
 514 #if defined(HAVE_INET_ATON)
 515     if ( inet_aton(namebuf, &addr->sin_addr) )
 516         return true;
 517 #elif defined(HAVE_INET_ADDR)
 518     addr->sin_addr.s_addr = inet_addr(namebuf);
 519     if ( addr->sin_addr.s_addr != INADDR_NONE )
 520         return true;
 521 #else
 522     #error "Neither inet_aton() nor inet_addr() is available?"
 523 #endif
 524
 525     // it's a host name, resolve it
 526     hostent he;
 527     wxGethostBuf buffer;
 528     int err;
 529     if ( !wxGethostbyname_r(namebuf, &he, buffer, sizeof(buffer), &err) )
 530         return false;
 531
 532     addr->sin_addr.s_addr = ((in_addr *)he.h_addr)->s_addr;
 533     return true;
 534 }
 535
 536 bool wxSockAddressImpl::GetHostAddress(wxUint32 *address) const
 537 {
 538     sockaddr_in * const addr = GET(sockaddr_in);
 539     if ( !addr )
 540         return false;
 541
 542     *address = ntohl(addr->sin_addr.s_addr);
 543
 544     return true;
 545 }
 546
 547 bool wxSockAddressImpl::SetHostAddress(wxUint32 address)
 548 {
 549     sockaddr_in * const addr = GET(sockaddr_in);
 550     if ( !addr )
 551         return false;
 552
 553     addr->sin_addr.s_addr = htonl(address);
 554
 555     return true;
 556 }
 557
 558 wxUint16 wxSockAddressImpl::GetPort4() const
 559 {
 560     sockaddr_in * const addr = GET(sockaddr_in);
 561     if ( !addr )
 562         return 0;
 563
 564     return ntohs(addr->sin_port);
 565 }
 566
 567 bool wxSockAddressImpl::SetPort4(wxUint16 port)
 568 {
 569     sockaddr_in * const addr = GET(sockaddr_in);
 570     if ( !addr )
 571         return false;
 572
 573     addr->sin_port = htons(port);
 574
 575     return true;
 576 }
 577
 578 #if wxUSE_IPV6
 579
 580 // ----------------------------------------------------------------------------
 581 // INET6 address family
 582 // ----------------------------------------------------------------------------
 583
 584 void wxSockAddressImpl::CreateINET6()
 585 {
 586     wxASSERT_MSG( Is(FAMILY_UNSPEC), "recreating address as different type?" );
 587
 588     m_family = FAMILY_INET6;
 589     sockaddr_in6 * const addr = ALLOC(sockaddr_in6);
 590     addr->sin6_family = FAMILY_INET6;
 591 }
 592
 593 bool wxSockAddressImpl::SetHostName6(const wxString& hostname)
 594 {
 595     sockaddr_in6 * const addr = GET(sockaddr_in6);
 596     if ( !addr )
 597         return false;
 598
 599     addrinfo hints;
 600     memset(&hints, 0, sizeof(hints));
 601     hints.ai_family = AF_INET6;
 602
 603     addrinfo *info = NULL;
 604     int rc = getaddrinfo(hostname.utf8_str(), NULL, &hints, &info);
 605     if ( rc )
 606     {
 607         // use gai_strerror()?
 608         return false;
 609     }
 610
 611     wxCHECK_MSG( info, false, "should have info on success" );
 612
 613     wxASSERT_MSG( int(info->ai_addrlen) == m_len, "unexpected address length" );
 614
 615     memcpy(addr, info->ai_addr, info->ai_addrlen);
 616     freeaddrinfo(info);
 617
 618     return true;
 619 }
 620
 621 bool wxSockAddressImpl::GetHostAddress(in6_addr *address) const
 622 {
 623     sockaddr_in6 * const addr = GET(sockaddr_in6);
 624     if ( !addr )
 625         return false;
 626
 627     *address = addr->sin6_addr;
 628
 629     return true;
 630 }
 631
 632 bool wxSockAddressImpl::SetHostAddress(const in6_addr& address)
 633 {
 634     sockaddr_in6 * const addr = GET(sockaddr_in6);
 635     if ( !addr )
 636         return false;
 637
 638     addr->sin6_addr = address;
 639
 640     return true;
 641 }
 642
 643 wxUint16 wxSockAddressImpl::GetPort6() const
 644 {
 645     sockaddr_in6 * const addr = GET(sockaddr_in6);
 646     if ( !addr )
 647         return 0;
 648
 649     return ntohs(addr->sin6_port);
 650 }
 651
 652 bool wxSockAddressImpl::SetPort6(wxUint16 port)
 653 {
 654     sockaddr_in6 * const addr = GET(sockaddr_in6);
 655     if ( !addr )
 656         return false;
 657
 658     addr->sin6_port = htons(port);
 659
 660     return true;
 661 }
 662
 663 bool wxSockAddressImpl::SetToAnyAddress6()
 664 {
 665     static const in6_addr any = IN6ADDR_ANY_INIT;
 666
 667     return SetHostAddress(any);
 668 }
 669
 670 #endif // wxUSE_IPV6
 671
 672 #ifdef wxHAS_UNIX_DOMAIN_SOCKETS
 673
 674 // ----------------------------------------------------------------------------
 675 // Unix address family
 676 // ----------------------------------------------------------------------------
 677
 678 #ifndef UNIX_PATH_MAX
 679     #define UNIX_PATH_MAX (WXSIZEOF(((sockaddr_un *)NULL)->sun_path))
 680 #endif
 681
 682 void wxSockAddressImpl::CreateUnix()
 683 {
 684     wxASSERT_MSG( Is(FAMILY_UNSPEC), "recreating address as different type?" );
 685
 686     m_family = FAMILY_UNIX;
 687     sockaddr_un * const addr = ALLOC(sockaddr_un);
 688     addr->sun_family = FAMILY_UNIX;
 689     addr->sun_path[0] = '\0';
 690 }
 691
 692 bool wxSockAddressImpl::SetPath(const wxString& path)
 693 {
 694     sockaddr_un * const addr = GET(sockaddr_un);
 695     if ( !addr )
 696         return false;
 697
 698     const wxScopedCharBuffer buf(path.utf8_str());
 699     if ( strlen(buf) >= UNIX_PATH_MAX )
 700         return false;
 701
 702     wxStrlcpy(addr->sun_path, buf, UNIX_PATH_MAX);
 703
 704     return true;
 705 }
 706
 707 wxString wxSockAddressImpl::GetPath() const
 708 {
 709     sockaddr_un * const addr = GET(sockaddr_un);
 710     if ( !addr )
 711         return wxString();
 712
 713     return wxString::FromUTF8(addr->sun_path);
 714 }
 715
 716 #endif // wxHAS_UNIX_DOMAIN_SOCKETS
 717
 718 #undef GET
 719 #undef ALLOC
 720
 721 // ----------------------------------------------------------------------------
 722 // wxSockAddress
 723 // ----------------------------------------------------------------------------
 724
 725 const sockaddr *wxSockAddress::GetAddressData() const
 726 {
 727     return GetAddress().GetAddr();
 728 }
 729
 730 int wxSockAddress::GetAddressDataLen() const
 731 {
 732     return GetAddress().GetLen();
 733 }
 734
 735 void wxSockAddress::Init()
 736 {
 737     if ( !wxSocketBase::IsInitialized() )
 738     {
 739         // we must do it before using any socket functions
 740         (void)wxSocketBase::Initialize();
 741     }
 742 }
 743
 744 wxSockAddress::wxSockAddress()
 745 {
 746     Init();
 747
 748     m_impl = new wxSockAddressImpl();
 749 }
 750
 751 wxSockAddress::wxSockAddress(const wxSockAddress& other)
 752     : wxObject()
 753 {
 754     Init();
 755
 756     m_impl = new wxSockAddressImpl(*other.m_impl);
 757 }
 758
 759 wxSockAddress::~wxSockAddress()
 760 {
 761     delete m_impl;
 762 }
 763
 764 void wxSockAddress::SetAddress(const wxSockAddressImpl& address)
 765 {
 766     if ( &address != m_impl )
 767     {
 768         delete m_impl;
 769         m_impl = new wxSockAddressImpl(address);
 770     }
 771 }
 772
 773 wxSockAddress& wxSockAddress::operator=(const wxSockAddress& addr)
 774 {
 775     SetAddress(addr.GetAddress());
 776
 777     return *this;
 778 }
 779
 780 void wxSockAddress::Clear()
 781 {
 782     m_impl->Clear();
 783 }
 784
 785 // ----------------------------------------------------------------------------
 786 // wxIPaddress
 787 // ----------------------------------------------------------------------------
 788
 789 wxSockAddressImpl& wxIPaddress::GetImpl()
 790 {
 791     if ( m_impl->GetFamily() == wxSockAddressImpl::FAMILY_UNSPEC )
 792         m_impl->CreateINET();
 793
 794     return *m_impl;
 795 }
 796
 797 bool wxIPaddress::Hostname(const wxString& name)
 798 {
 799     wxCHECK_MSG( !name.empty(), false, "empty host name is invalid" );
 800
 801     m_origHostname = name;
 802
 803     return GetImpl().SetHostName(name);
 804 }
 805
 806 bool wxIPaddress::Service(const wxString& name)
 807 {
 808     return GetImpl().SetPortName(name, "tcp");
 809 }
 810
 811 bool wxIPaddress::Service(unsigned short port)
 812 {
 813     return GetImpl().SetPort(port);
 814 }
 815
 816 bool wxIPaddress::LocalHost()
 817 {
 818     return Hostname("localhost");
 819 }
 820
 821 wxString wxIPaddress::Hostname() const
 822 {
 823     return GetImpl().GetHostName();
 824 }
 825
 826 unsigned short wxIPaddress::Service() const
 827 {
 828     return GetImpl().GetPort();
 829 }
 830
 831 bool wxIPaddress::operator==(const wxIPaddress& addr) const
 832 {
 833     return Hostname().Cmp(addr.Hostname()) == 0 &&
 834            Service() == addr.Service();
 835 }
 836
 837 bool wxIPaddress::AnyAddress()
 838 {
 839     return GetImpl().SetToAnyAddress();
 840 }
 841
 842 // ----------------------------------------------------------------------------
 843 // wxIPV4address
 844 // ----------------------------------------------------------------------------
 845
 846 void wxIPV4address::DoInitImpl()
 847 {
 848     m_impl->CreateINET();
 849 }
 850
 851 bool wxIPV4address::Hostname(unsigned long addr)
 852 {
 853     if ( !GetImpl().SetHostAddress(addr) )
 854     {
 855         m_origHostname.clear();
 856         return false;
 857     }
 858
 859     m_origHostname = Hostname();
 860     return true;
 861 }
 862
 863 bool wxIPV4address::IsLocalHost() const
 864 {
 865     return Hostname() == "localhost" || IPAddress() == "127.0.0.1";
 866 }
 867
 868 wxString wxIPV4address::IPAddress() const
 869 {
 870     wxUint32 addr;
 871     if ( !GetImpl().GetHostAddress(&addr) )
 872         return wxString();
 873
 874     return wxString::Format
 875            (
 876             "%lu.%lu.%lu.%lu",
 877             (addr >> 24) & 0xff,
 878             (addr >> 16) & 0xff,
 879             (addr >> 8) & 0xff,
 880             addr & 0xff
 881            );
 882 }
 883
 884 bool wxIPV4address::BroadcastAddress()
 885 {
 886     return GetImpl().SetToBroadcastAddress();
 887 }
 888
 889 #if wxUSE_IPV6
 890
 891 // ---------------------------------------------------------------------------
 892 // wxIPV6address
 893 // ---------------------------------------------------------------------------
 894
 895 void wxIPV6address::DoInitImpl()
 896 {
 897     m_impl->CreateINET6();
 898 }
 899
 900 bool wxIPV6address::Hostname(unsigned char addr[16])
 901 {
 902     unsigned short wk[8];
 903     for ( int i = 0; i < 8; ++i )
 904     {
 905         wk[i] = addr[2*i];
 906         wk[i] <<= 8;
 907         wk[i] |= addr[2*i+1];
 908     }
 909
 910     return Hostname
 911            (
 912                 wxString::Format
 913                 (
 914                  "%x:%x:%x:%x:%x:%x:%x:%x",
 915                  wk[0], wk[1], wk[2], wk[3], wk[4], wk[5], wk[6], wk[7]
 916                 )
 917            );
 918 }
 919
 920 bool wxIPV6address::IsLocalHost() const
 921 {
 922     if ( Hostname() == "localhost" )
 923         return true;
 924
 925     wxString addr = IPAddress();
 926     return addr == wxT("::1") ||
 927                 addr == wxT("0:0:0:0:0:0:0:1") ||
 928                     addr == wxT("::ffff:127.0.0.1");
 929 }
 930
 931 wxString wxIPV6address::IPAddress() const
 932 {
 933     union
 934     {
 935         in6_addr addr6;
 936         wxUint8 bytes[16];
 937     } u;
 938
 939     if ( !GetImpl().GetHostAddress(&u.addr6) )
 940         return wxString();
 941
 942     const wxUint8 * const addr = u.bytes;
 943
 944     wxUint16 words[8];
 945     int i,
 946         prefix_zero_count = 0;
 947     for ( i = 0; i < 8; ++i )
 948     {
 949         words[i] = addr[i*2];
 950         words[i] <<= 8;
 951         words[i] |= addr[i*2+1];
 952         if ( i == prefix_zero_count && words[i] == 0 )
 953             ++prefix_zero_count;
 954     }
 955
 956     wxString result;
 957     if ( prefix_zero_count == 8 )
 958     {
 959         result = wxT( "::" );
 960     }
 961     else if ( prefix_zero_count == 6 && words[5] == 0xFFFF )
 962     {
 963         // IPv4 mapped
 964         result.Printf("::ffff:%d.%d.%d.%d",
 965                       addr[12], addr[13], addr[14], addr[15]);
 966     }
 967     else // general case
 968     {
 969         result = ":";
 970         for ( i = prefix_zero_count; i < 8; ++i )
 971         {
 972             result += wxString::Format(":%x", words[i]);
 973         }
 974     }
 975
 976     return result;
 977 }
 978
 979 #endif // wxUSE_IPV6
 980
 981 #ifdef wxHAS_UNIX_DOMAIN_SOCKETS
 982
 983 // ---------------------------------------------------------------------------
 984 // wxUNIXaddress
 985 // ---------------------------------------------------------------------------
 986
 987 wxSockAddressImpl& wxUNIXaddress::GetUNIX()
 988 {
 989     if ( m_impl->GetFamily() == wxSockAddressImpl::FAMILY_UNSPEC )
 990         m_impl->CreateUnix();
 991
 992     return *m_impl;
 993 }
 994
 995 void wxUNIXaddress::Filename(const wxString& fname)
 996 {
 997     GetUNIX().SetPath(fname);
 998 }
 999
1000 wxString wxUNIXaddress::Filename() const
1001 {
1002     return GetUNIX().GetPath();
1003 }
1004
1005 #endif // wxHAS_UNIX_DOMAIN_SOCKETS
1006
1007 #endif // wxUSE_SOCKETS