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