contrib/llvm/tools/lldb/source/Host/common/Socket.cpp

   1 //===-- Socket.cpp ----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Host/Socket.h"
  11
  12 #include "lldb/Core/Log.h"
  13 #include "lldb/Core/RegularExpression.h"
  14 #include "lldb/Host/Config.h"
  15 #include "lldb/Host/FileSystem.h"
  16 #include "lldb/Host/Host.h"
  17 #include "lldb/Host/SocketAddress.h"
  18 #include "lldb/Host/TimeValue.h"
  19 #include "lldb/Interpreter/Args.h"
  20
  21 #ifndef LLDB_DISABLE_POSIX
  22 #include <arpa/inet.h>
  23 #include <netdb.h>
  24 #include <netinet/in.h>
  25 #include <netinet/tcp.h>
  26 #include <sys/socket.h>
  27 #include <sys/un.h>
  28 #endif
  29
  30 using namespace lldb;
  31 using namespace lldb_private;
  32
  33 #if defined(_WIN32)
  34 typedef const char * set_socket_option_arg_type;
  35 typedef char * get_socket_option_arg_type;
  36 const NativeSocket Socket::kInvalidSocketValue = INVALID_SOCKET;
  37 #else // #if defined(_WIN32)
  38 typedef const void * set_socket_option_arg_type;
  39 typedef void * get_socket_option_arg_type;
  40 const NativeSocket Socket::kInvalidSocketValue = -1;
  41 #endif // #if defined(_WIN32)
  42
  43 Socket::Socket(NativeSocket socket, SocketProtocol protocol, bool should_close)
  44     : IOObject(eFDTypeSocket, should_close)
  45     , m_protocol(protocol)
  46     , m_socket(socket)
  47 {
  48
  49 }
  50
  51 Socket::~Socket()
  52 {
  53     Close();
  54 }
  55
  56 Error Socket::TcpConnect(llvm::StringRef host_and_port, Socket *&socket)
  57 {
  58     // Store the result in a unique_ptr in case we error out, the memory will get correctly freed.
  59     std::unique_ptr<Socket> final_socket;
  60     NativeSocket sock = kInvalidSocketValue;
  61     Error error;
  62
  63     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_HOST));
  64     if (log)
  65         log->Printf ("Socket::TcpConnect (host/port = %s)", host_and_port.data());
  66
  67     std::string host_str;
  68     std::string port_str;
  69     int32_t port = INT32_MIN;
  70     if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, &error))
  71         return error;
  72
  73     // Create the socket
  74     sock = ::socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
  75     if (sock == kInvalidSocketValue)
  76     {
  77         // TODO: On Windows, use WSAGetLastError().
  78         error.SetErrorToErrno();
  79         return error;
  80     }
  81
  82     // Since they both refer to the same socket descriptor, arbitrarily choose the send socket to
  83     // be the owner.
  84     final_socket.reset(new Socket(sock, ProtocolTcp, true));
  85
  86     // Enable local address reuse
  87     final_socket->SetOption(SOL_SOCKET, SO_REUSEADDR, 1);
  88
  89     struct sockaddr_in sa;
  90     ::memset (&sa, 0, sizeof (sa));
  91     sa.sin_family = AF_INET;
  92     sa.sin_port = htons (port);
  93
  94     int inet_pton_result = ::inet_pton (AF_INET, host_str.c_str(), &sa.sin_addr);
  95
  96     if (inet_pton_result <= 0)
  97     {
  98         struct hostent *host_entry = gethostbyname (host_str.c_str());
  99         if (host_entry)
 100             host_str = ::inet_ntoa (*(struct in_addr *)*host_entry->h_addr_list);
 101         inet_pton_result = ::inet_pton (AF_INET, host_str.c_str(), &sa.sin_addr);
 102         if (inet_pton_result <= 0)
 103         {
 104             // TODO: On Windows, use WSAGetLastError()
 105             if (inet_pton_result == -1)
 106                 error.SetErrorToErrno();
 107             else
 108                 error.SetErrorStringWithFormat("invalid host string: '%s'", host_str.c_str());
 109
 110             return error;
 111         }
 112     }
 113
 114     if (-1 == ::connect (sock, (const struct sockaddr *)&sa, sizeof(sa)))
 115     {
 116         // TODO: On Windows, use WSAGetLastError()
 117         error.SetErrorToErrno();
 118         return error;
 119     }
 120
 121     // Keep our TCP packets coming without any delays.
 122     final_socket->SetOption(IPPROTO_TCP, TCP_NODELAY, 1);
 123     error.Clear();
 124     socket = final_socket.release();
 125     return error;
 126 }
 127
 128 Error Socket::TcpListen(llvm::StringRef host_and_port, Socket *&socket, Predicate<uint16_t>* predicate)
 129 {
 130     std::unique_ptr<Socket> listen_socket;
 131     NativeSocket listen_sock = kInvalidSocketValue;
 132     Error error;
 133
 134     const sa_family_t family = AF_INET;
 135     const int socktype = SOCK_STREAM;
 136     const int protocol = IPPROTO_TCP;
 137     listen_sock = ::socket (family, socktype, protocol);
 138     if (listen_sock == kInvalidSocketValue)
 139     {
 140         error.SetErrorToErrno();
 141         return error;
 142     }
 143
 144     listen_socket.reset(new Socket(listen_sock, ProtocolTcp, true));
 145
 146     // enable local address reuse
 147     listen_socket->SetOption(SOL_SOCKET, SO_REUSEADDR, 1);
 148
 149     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
 150     if (log)
 151         log->Printf ("ConnectionFileDescriptor::SocketListen (%s)", host_and_port.data());
 152
 153     std::string host_str;
 154     std::string port_str;
 155     int32_t port = INT32_MIN;
 156     if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, &error))
 157         return error;
 158
 159     SocketAddress anyaddr;
 160     if (anyaddr.SetToAnyAddress (family, port))
 161     {
 162         int err = ::bind (listen_sock, anyaddr, anyaddr.GetLength());
 163         if (err == -1)
 164         {
 165             // TODO: On Windows, use WSAGetLastError()
 166             error.SetErrorToErrno();
 167             return error;
 168         }
 169
 170         err = ::listen (listen_sock, 1);
 171         if (err == -1)
 172         {
 173             // TODO: On Windows, use WSAGetLastError()
 174             error.SetErrorToErrno();
 175             return error;
 176         }
 177
 178         // We were asked to listen on port zero which means we
 179         // must now read the actual port that was given to us
 180         // as port zero is a special code for "find an open port
 181         // for me".
 182         if (port == 0)
 183             port = listen_socket->GetPortNumber();
 184
 185         // Set the port predicate since when doing a listen://<host>:<port>
 186         // it often needs to accept the incoming connection which is a blocking
 187         // system call. Allowing access to the bound port using a predicate allows
 188         // us to wait for the port predicate to be set to a non-zero value from
 189         // another thread in an efficient manor.
 190         if (predicate)
 191             predicate->SetValue(port, eBroadcastAlways);
 192
 193         socket = listen_socket.release();
 194     }
 195
 196     return error;
 197 }
 198
 199 Error Socket::BlockingAccept(llvm::StringRef host_and_port, Socket *&socket)
 200 {
 201     Error error;
 202     std::string host_str;
 203     std::string port_str;
 204     int32_t port;
 205     if (!DecodeHostAndPort(host_and_port, host_str, port_str, port, &error))
 206         return error;
 207
 208     const sa_family_t family = AF_INET;
 209     const int socktype = SOCK_STREAM;
 210     const int protocol = IPPROTO_TCP;
 211     SocketAddress listen_addr;
 212     if (host_str.empty())
 213         listen_addr.SetToLocalhost(family, port);
 214     else if (host_str.compare("*") == 0)
 215         listen_addr.SetToAnyAddress(family, port);
 216     else
 217     {
 218         if (!listen_addr.getaddrinfo(host_str.c_str(), port_str.c_str(), family, socktype, protocol))
 219         {
 220             error.SetErrorStringWithFormat("unable to resolve hostname '%s'", host_str.c_str());
 221             return error;
 222         }
 223     }
 224
 225     bool accept_connection = false;
 226     std::unique_ptr<Socket> accepted_socket;
 227
 228     // Loop until we are happy with our connection
 229     while (!accept_connection)
 230     {
 231         struct sockaddr_in accept_addr;
 232         ::memset (&accept_addr, 0, sizeof accept_addr);
 233 #if !(defined (__linux__) || defined(_WIN32))
 234         accept_addr.sin_len = sizeof accept_addr;
 235 #endif
 236         socklen_t accept_addr_len = sizeof accept_addr;
 237
 238         int sock = ::accept (this->GetNativeSocket(), (struct sockaddr *)&accept_addr, &accept_addr_len);
 239
 240         if (sock == kInvalidSocketValue)
 241         {
 242             // TODO: On Windows, use WSAGetLastError()
 243             error.SetErrorToErrno();
 244             break;
 245         }
 246
 247         bool is_same_addr = true;
 248 #if !(defined(__linux__) || (defined(_WIN32)))
 249         is_same_addr = (accept_addr_len == listen_addr.sockaddr_in().sin_len);
 250 #endif
 251         if (is_same_addr)
 252             is_same_addr = (accept_addr.sin_addr.s_addr == listen_addr.sockaddr_in().sin_addr.s_addr);
 253
 254         if (is_same_addr || (listen_addr.sockaddr_in().sin_addr.s_addr == INADDR_ANY))
 255         {
 256             accept_connection = true;
 257             // Since both sockets have the same descriptor, arbitrarily choose the send
 258             // socket to be the owner.
 259             accepted_socket.reset(new Socket(sock, ProtocolTcp, true));
 260         }
 261         else
 262         {
 263             const uint8_t *accept_ip = (const uint8_t *)&accept_addr.sin_addr.s_addr;
 264             const uint8_t *listen_ip = (const uint8_t *)&listen_addr.sockaddr_in().sin_addr.s_addr;
 265             ::fprintf (stderr, "error: rejecting incoming connection from %u.%u.%u.%u (expecting %u.%u.%u.%u)\n",
 266                         accept_ip[0], accept_ip[1], accept_ip[2], accept_ip[3],
 267                         listen_ip[0], listen_ip[1], listen_ip[2], listen_ip[3]);
 268             accepted_socket.reset();
 269         }
 270     }
 271
 272     if (!accepted_socket)
 273         return error;
 274
 275     // Keep our TCP packets coming without any delays.
 276     accepted_socket->SetOption (IPPROTO_TCP, TCP_NODELAY, 1);
 277     error.Clear();
 278     socket = accepted_socket.release();
 279     return error;
 280
 281 }
 282
 283 Error Socket::UdpConnect(llvm::StringRef host_and_port, Socket *&send_socket, Socket *&recv_socket)
 284 {
 285     std::unique_ptr<Socket> final_send_socket;
 286     std::unique_ptr<Socket> final_recv_socket;
 287     NativeSocket final_send_fd = kInvalidSocketValue;
 288     NativeSocket final_recv_fd = kInvalidSocketValue;
 289
 290     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
 291     if (log)
 292         log->Printf ("Socket::UdpConnect (host/port = %s)", host_and_port.data());
 293
 294     Error error;
 295     std::string host_str;
 296     std::string port_str;
 297     int32_t port = INT32_MIN;
 298     if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, &error))
 299         return error;
 300
 301     // Setup the receiving end of the UDP connection on this localhost
 302     // on port zero. After we bind to port zero we can read the port.
 303     final_recv_fd = ::socket (AF_INET, SOCK_DGRAM, 0);
 304     if (final_recv_fd == kInvalidSocketValue)
 305     {
 306         // Socket creation failed...
 307         // TODO: On Windows, use WSAGetLastError().
 308         error.SetErrorToErrno();
 309     }
 310     else
 311     {
 312         final_recv_socket.reset(new Socket(final_recv_fd, ProtocolUdp, true));
 313
 314         // Socket was created, now lets bind to the requested port
 315         SocketAddress addr;
 316         addr.SetToAnyAddress (AF_INET, 0);
 317
 318         if (::bind (final_recv_fd, addr, addr.GetLength()) == -1)
 319         {
 320             // Bind failed...
 321             // TODO: On Windows use WSAGetLastError()
 322             error.SetErrorToErrno();
 323         }
 324     }
 325
 326     assert(error.Fail() == !(final_recv_socket && final_recv_socket->IsValid()));
 327     if (error.Fail())
 328         return error;
 329
 330     // At this point we have setup the receive port, now we need to
 331     // setup the UDP send socket
 332
 333     struct addrinfo hints;
 334     struct addrinfo *service_info_list = NULL;
 335
 336     ::memset (&hints, 0, sizeof(hints));
 337     hints.ai_family = AF_INET;
 338     hints.ai_socktype = SOCK_DGRAM;
 339     int err = ::getaddrinfo (host_str.c_str(), port_str.c_str(), &hints, &service_info_list);
 340     if (err != 0)
 341     {
 342         error.SetErrorStringWithFormat("getaddrinfo(%s, %s, &hints, &info) returned error %i (%s)",
 343                                        host_str.c_str(),
 344                                        port_str.c_str(),
 345                                        err,
 346                                        gai_strerror(err));
 347         return error;
 348     }
 349
 350     for (struct addrinfo *service_info_ptr = service_info_list;
 351          service_info_ptr != NULL;
 352          service_info_ptr = service_info_ptr->ai_next)
 353     {
 354         final_send_fd = ::socket (service_info_ptr->ai_family,
 355                                   service_info_ptr->ai_socktype,
 356                                   service_info_ptr->ai_protocol);
 357
 358         if (final_send_fd != kInvalidSocketValue)
 359         {
 360             final_send_socket.reset(new Socket(final_send_fd, ProtocolUdp, true));
 361             final_send_socket->m_udp_send_sockaddr = service_info_ptr;
 362             break;
 363         }
 364         else
 365             continue;
 366     }
 367
 368     :: freeaddrinfo (service_info_list);
 369
 370     if (final_send_fd == kInvalidSocketValue)
 371     {
 372         // TODO: On Windows, use WSAGetLastError().
 373         error.SetErrorToErrno();
 374         return error;
 375     }
 376
 377     send_socket = final_send_socket.release();
 378     recv_socket = final_recv_socket.release();
 379     error.Clear();
 380     return error;
 381 }
 382
 383 Error Socket::UnixDomainConnect(llvm::StringRef name, Socket *&socket)
 384 {
 385     Error error;
 386 #ifndef LLDB_DISABLE_POSIX
 387     std::unique_ptr<Socket> final_socket;
 388
 389     // Open the socket that was passed in as an option
 390     struct sockaddr_un saddr_un;
 391     int fd = ::socket (AF_UNIX, SOCK_STREAM, 0);
 392     if (fd == kInvalidSocketValue)
 393     {
 394         error.SetErrorToErrno();
 395         return error;
 396     }
 397
 398     final_socket.reset(new Socket(fd, ProtocolUnixDomain, true));
 399
 400     saddr_un.sun_family = AF_UNIX;
 401     ::strncpy(saddr_un.sun_path, name.data(), sizeof(saddr_un.sun_path) - 1);
 402     saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
 403 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
 404     saddr_un.sun_len = SUN_LEN (&saddr_un);
 405 #endif
 406
 407     if (::connect (fd, (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) < 0)
 408     {
 409         error.SetErrorToErrno();
 410         return error;
 411     }
 412
 413     socket = final_socket.release();
 414 #else
 415     error.SetErrorString("Unix domain sockets are not supported on this platform.");
 416 #endif
 417     return error;
 418 }
 419
 420 Error Socket::UnixDomainAccept(llvm::StringRef name, Socket *&socket)
 421 {
 422     Error error;
 423 #ifndef LLDB_DISABLE_POSIX
 424     struct sockaddr_un saddr_un;
 425     std::unique_ptr<Socket> listen_socket;
 426     std::unique_ptr<Socket> final_socket;
 427     NativeSocket listen_fd = kInvalidSocketValue;
 428     NativeSocket socket_fd = kInvalidSocketValue;
 429
 430     listen_fd = ::socket (AF_UNIX, SOCK_STREAM, 0);
 431     if (listen_fd == kInvalidSocketValue)
 432     {
 433         error.SetErrorToErrno();
 434         return error;
 435     }
 436
 437     listen_socket.reset(new Socket(listen_fd, ProtocolUnixDomain, true));
 438
 439     saddr_un.sun_family = AF_UNIX;
 440     ::strncpy(saddr_un.sun_path, name.data(), sizeof(saddr_un.sun_path) - 1);
 441     saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
 442 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
 443     saddr_un.sun_len = SUN_LEN (&saddr_un);
 444 #endif
 445
 446     FileSystem::Unlink(name.data());
 447     bool success = false;
 448     if (::bind (listen_fd, (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) == 0)
 449     {
 450         if (::listen (listen_fd, 5) == 0)
 451         {
 452             socket_fd = ::accept (listen_fd, NULL, 0);
 453             if (socket_fd > 0)
 454             {
 455                 final_socket.reset(new Socket(socket_fd, ProtocolUnixDomain, true));
 456                 success = true;
 457             }
 458         }
 459     }
 460
 461     if (!success)
 462     {
 463         error.SetErrorToErrno();
 464         return error;
 465     }
 466     // We are done with the listen port
 467     listen_socket.reset();
 468
 469     socket = final_socket.release();
 470 #else
 471     error.SetErrorString("Unix domain sockets are not supported on this platform.");
 472 #endif
 473     return error;
 474 }
 475
 476 bool
 477 Socket::DecodeHostAndPort(llvm::StringRef host_and_port,
 478                           std::string &host_str,
 479                           std::string &port_str,
 480                           int32_t& port,
 481                           Error *error_ptr)
 482 {
 483     static RegularExpression g_regex ("([^:]+):([0-9]+)");
 484     RegularExpression::Match regex_match(2);
 485     if (g_regex.Execute (host_and_port.data(), &regex_match))
 486     {
 487         if (regex_match.GetMatchAtIndex (host_and_port.data(), 1, host_str) &&
 488             regex_match.GetMatchAtIndex (host_and_port.data(), 2, port_str))
 489         {
 490             port = Args::StringToSInt32 (port_str.c_str(), INT32_MIN);
 491             if (port != INT32_MIN)
 492             {
 493                 if (error_ptr)
 494                     error_ptr->Clear();
 495                 return true;
 496             }
 497         }
 498     }
 499
 500     // If this was unsuccessful, then check if it's simply a signed 32-bit integer, representing
 501     // a port with an empty host.
 502     host_str.clear();
 503     port_str.clear();
 504     port = Args::StringToSInt32(host_and_port.data(), INT32_MIN);
 505     if (port != INT32_MIN)
 506     {
 507         port_str = host_and_port;
 508         return true;
 509     }
 510
 511     if (error_ptr)
 512         error_ptr->SetErrorStringWithFormat("invalid host:port specification: '%s'", host_and_port.data());
 513     return false;
 514 }
 515
 516 IOObject::WaitableHandle Socket::GetWaitableHandle()
 517 {
 518     // TODO: On Windows, use WSAEventSelect
 519     return m_socket;
 520 }
 521
 522 Error Socket::Read (void *buf, size_t &num_bytes)
 523 {
 524     Error error;
 525     int bytes_received = 0;
 526     do
 527     {
 528         bytes_received = ::recv (m_socket, static_cast<char *>(buf), num_bytes, 0);
 529         // TODO: Use WSAGetLastError on windows.
 530     } while (bytes_received < 0 && errno == EINTR);
 531
 532     if (bytes_received < 0)
 533     {
 534         error.SetErrorToErrno();
 535         num_bytes = 0;
 536     }
 537     else
 538         num_bytes = bytes_received;
 539
 540     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_HOST | LIBLLDB_LOG_COMMUNICATION));
 541     if (log)
 542     {
 543         log->Printf ("%p Socket::Read() (socket = %" PRIu64 ", src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64 " (error = %s)",
 544                      static_cast<void*>(this),
 545                      static_cast<uint64_t>(m_socket),
 546                      buf,
 547                      static_cast<uint64_t>(num_bytes),
 548                      static_cast<int64_t>(bytes_received),
 549                      error.AsCString());
 550     }
 551
 552     return error;
 553 }
 554
 555 Error Socket::Write (const void *buf, size_t &num_bytes)
 556 {
 557     Error error;
 558     int bytes_sent = 0;
 559     do
 560     {
 561         if (m_protocol == ProtocolUdp)
 562         {
 563             bytes_sent = ::sendto (m_socket,
 564                                     static_cast<const char*>(buf),
 565                                     num_bytes,
 566                                     0,
 567                                     m_udp_send_sockaddr,
 568                                     m_udp_send_sockaddr.GetLength());
 569         }
 570         else
 571             bytes_sent = ::send (m_socket, static_cast<const char *>(buf), num_bytes, 0);
 572         // TODO: Use WSAGetLastError on windows.
 573     } while (bytes_sent < 0 && errno == EINTR);
 574
 575     if (bytes_sent < 0)
 576     {
 577         // TODO: On Windows, use WSAGEtLastError.
 578         error.SetErrorToErrno();
 579         num_bytes = 0;
 580     }
 581     else
 582         num_bytes = bytes_sent;
 583
 584     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_HOST));
 585     if (log)
 586     {
 587         log->Printf ("%p Socket::Write() (socket = %" PRIu64 ", src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64 " (error = %s)",
 588                         static_cast<void*>(this),
 589                         static_cast<uint64_t>(m_socket),
 590                         buf,
 591                         static_cast<uint64_t>(num_bytes),
 592                         static_cast<int64_t>(bytes_sent),
 593                         error.AsCString());
 594     }
 595
 596     return error;
 597 }
 598
 599 Error Socket::PreDisconnect()
 600 {
 601     Error error;
 602     return error;
 603 }
 604
 605 Error Socket::Close()
 606 {
 607     Error error;
 608     if (!IsValid() || !m_should_close_fd)
 609         return error;
 610
 611     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
 612     if (log)
 613         log->Printf ("%p Socket::Close (fd = %i)", static_cast<void*>(this), m_socket);
 614
 615 #if defined(_WIN32)
 616     bool success = !!closesocket(m_socket);
 617 #else
 618     bool success = !!::close (m_socket);
 619 #endif
 620     // A reference to a FD was passed in, set it to an invalid value
 621     m_socket = kInvalidSocketValue;
 622     if (!success)
 623     {
 624         // TODO: On Windows, use WSAGetLastError().
 625         error.SetErrorToErrno();
 626     }
 627
 628     return error;
 629 }
 630
 631
 632 int Socket::GetOption(int level, int option_name, int &option_value)
 633 {
 634     get_socket_option_arg_type option_value_p = reinterpret_cast<get_socket_option_arg_type>(&option_value);
 635     socklen_t option_value_size = sizeof(int);
 636         return ::getsockopt(m_socket, level, option_name, option_value_p, &option_value_size);
 637 }
 638
 639 int Socket::SetOption(int level, int option_name, int option_value)
 640 {
 641     set_socket_option_arg_type option_value_p = reinterpret_cast<get_socket_option_arg_type>(&option_value);
 642         return ::setsockopt(m_socket, level, option_name, option_value_p, sizeof(option_value));
 643 }
 644
 645 uint16_t Socket::GetPortNumber(const NativeSocket& socket)
 646 {
 647     // We bound to port zero, so we need to figure out which port we actually bound to
 648     if (socket >= 0)
 649     {
 650         SocketAddress sock_addr;
 651         socklen_t sock_addr_len = sock_addr.GetMaxLength ();
 652         if (::getsockname (socket, sock_addr, &sock_addr_len) == 0)
 653             return sock_addr.GetPort ();
 654     }
 655     return 0;
 656 }
 657
 658 // Return the port number that is being used by the socket.
 659 uint16_t Socket::GetPortNumber() const
 660 {
 661     return GetPortNumber(m_socket);
 662 }