1 files changed, 181 insertions, 210 deletions

diff --git a/lldb/source/Host/common/TCPSocket.cpp b/lldb/source/Host/common/TCPSocket.cpp
index 07b0cdf..dd3cd89 100644
--- a/lldb/source/Host/common/TCPSocket.cpp
+++ b/lldb/source/Host/common/TCPSocket.cpp
@@ -24,262 +24,233 @@ using namespace lldb_private;
 namespace {
 
 const int kDomain = AF_INET;
-const int kType   = SOCK_STREAM;
-
+const int kType = SOCK_STREAM;
 }
 
 TCPSocket::TCPSocket(NativeSocket socket, bool should_close)
-    : Socket(socket, ProtocolTcp, should_close)
-{
-
-}
+    : Socket(socket, ProtocolTcp, should_close) {}
 
 TCPSocket::TCPSocket(bool child_processes_inherit, Error &error)
-    : TCPSocket(CreateSocket(kDomain, kType, IPPROTO_TCP, child_processes_inherit, error), true)
-{
-}
-
+    : TCPSocket(CreateSocket(kDomain, kType, IPPROTO_TCP,
+                             child_processes_inherit, error),
+                true) {}
 
 // Return the port number that is being used by the socket.
-uint16_t
-TCPSocket::GetLocalPortNumber() const
-{
-    if (m_socket != kInvalidSocketValue)
-    {
-        SocketAddress sock_addr;
-        socklen_t sock_addr_len = sock_addr.GetMaxLength ();
-        if (::getsockname (m_socket, sock_addr, &sock_addr_len) == 0)
-            return sock_addr.GetPort ();
-    }
-    return 0;
+uint16_t TCPSocket::GetLocalPortNumber() const {
+  if (m_socket != kInvalidSocketValue) {
+    SocketAddress sock_addr;
+    socklen_t sock_addr_len = sock_addr.GetMaxLength();
+    if (::getsockname(m_socket, sock_addr, &sock_addr_len) == 0)
+      return sock_addr.GetPort();
+  }
+  return 0;
 }
 
-std::string
-TCPSocket::GetLocalIPAddress() const
-{
-    // We bound to port zero, so we need to figure out which port we actually bound to
-    if (m_socket != kInvalidSocketValue)
-    {
-        SocketAddress sock_addr;
-        socklen_t sock_addr_len = sock_addr.GetMaxLength ();
-        if (::getsockname (m_socket, sock_addr, &sock_addr_len) == 0)
-            return sock_addr.GetIPAddress ();
-    }
-    return "";
+std::string TCPSocket::GetLocalIPAddress() const {
+  // We bound to port zero, so we need to figure out which port we actually
+  // bound to
+  if (m_socket != kInvalidSocketValue) {
+    SocketAddress sock_addr;
+    socklen_t sock_addr_len = sock_addr.GetMaxLength();
+    if (::getsockname(m_socket, sock_addr, &sock_addr_len) == 0)
+      return sock_addr.GetIPAddress();
+  }
+  return "";
 }
 
-uint16_t
-TCPSocket::GetRemotePortNumber() const
-{
-    if (m_socket != kInvalidSocketValue)
-    {
-        SocketAddress sock_addr;
-        socklen_t sock_addr_len = sock_addr.GetMaxLength ();
-        if (::getpeername (m_socket, sock_addr, &sock_addr_len) == 0)
-            return sock_addr.GetPort ();
-    }
-    return 0;
+uint16_t TCPSocket::GetRemotePortNumber() const {
+  if (m_socket != kInvalidSocketValue) {
+    SocketAddress sock_addr;
+    socklen_t sock_addr_len = sock_addr.GetMaxLength();
+    if (::getpeername(m_socket, sock_addr, &sock_addr_len) == 0)
+      return sock_addr.GetPort();
+  }
+  return 0;
 }
 
-std::string
-TCPSocket::GetRemoteIPAddress () const
-{
-    // We bound to port zero, so we need to figure out which port we actually bound to
-    if (m_socket != kInvalidSocketValue)
-    {
-        SocketAddress sock_addr;
-        socklen_t sock_addr_len = sock_addr.GetMaxLength ();
-        if (::getpeername (m_socket, sock_addr, &sock_addr_len) == 0)
-            return sock_addr.GetIPAddress ();
-    }
-    return "";
+std::string TCPSocket::GetRemoteIPAddress() const {
+  // We bound to port zero, so we need to figure out which port we actually
+  // bound to
+  if (m_socket != kInvalidSocketValue) {
+    SocketAddress sock_addr;
+    socklen_t sock_addr_len = sock_addr.GetMaxLength();
+    if (::getpeername(m_socket, sock_addr, &sock_addr_len) == 0)
+      return sock_addr.GetIPAddress();
+  }
+  return "";
 }
 
-Error
-TCPSocket::Connect(llvm::StringRef name)
-{
-    if (m_socket == kInvalidSocketValue)
-        return Error("Invalid socket");
-
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION));
-    if (log)
-        log->Printf ("TCPSocket::%s (host/port = %s)", __FUNCTION__, name.data());
-
-    Error error;
-    std::string host_str;
-    std::string port_str;
-    int32_t port = INT32_MIN;
-    if (!DecodeHostAndPort (name, host_str, port_str, port, &error))
-        return error;
-
-    struct sockaddr_in sa;
-    ::memset (&sa, 0, sizeof (sa));
-    sa.sin_family = kDomain;
-    sa.sin_port = htons (port);
-
-    int inet_pton_result = ::inet_pton (kDomain, host_str.c_str(), &sa.sin_addr);
-
-    if (inet_pton_result <= 0)
-    {
-        struct hostent *host_entry = gethostbyname (host_str.c_str());
-        if (host_entry)
-            host_str = ::inet_ntoa (*(struct in_addr *)*host_entry->h_addr_list);
-        inet_pton_result = ::inet_pton (kDomain, host_str.c_str(), &sa.sin_addr);
-        if (inet_pton_result <= 0)
-        {
-            if (inet_pton_result == -1)
-                SetLastError(error);
-            else
-                error.SetErrorStringWithFormat("invalid host string: '%s'", host_str.c_str());
-
-            return error;
-        }
-    }
+Error TCPSocket::Connect(llvm::StringRef name) {
+  if (m_socket == kInvalidSocketValue)
+    return Error("Invalid socket");
+
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
+  if (log)
+    log->Printf("TCPSocket::%s (host/port = %s)", __FUNCTION__, name.data());
 
-    if (-1 == ::connect (GetNativeSocket(), (const struct sockaddr *)&sa, sizeof(sa)))
-    {
-        SetLastError (error);
-        return error;
+  Error error;
+  std::string host_str;
+  std::string port_str;
+  int32_t port = INT32_MIN;
+  if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
+    return error;
+
+  struct sockaddr_in sa;
+  ::memset(&sa, 0, sizeof(sa));
+  sa.sin_family = kDomain;
+  sa.sin_port = htons(port);
+
+  int inet_pton_result = ::inet_pton(kDomain, host_str.c_str(), &sa.sin_addr);
+
+  if (inet_pton_result <= 0) {
+    struct hostent *host_entry = gethostbyname(host_str.c_str());
+    if (host_entry)
+      host_str = ::inet_ntoa(*(struct in_addr *)*host_entry->h_addr_list);
+    inet_pton_result = ::inet_pton(kDomain, host_str.c_str(), &sa.sin_addr);
+    if (inet_pton_result <= 0) {
+      if (inet_pton_result == -1)
+        SetLastError(error);
+      else
+        error.SetErrorStringWithFormat("invalid host string: '%s'",
+                                       host_str.c_str());
+
+      return error;
     }
+  }
 
-    // Keep our TCP packets coming without any delays.
-    SetOptionNoDelay();
-    error.Clear();
+  if (-1 ==
+      ::connect(GetNativeSocket(), (const struct sockaddr *)&sa, sizeof(sa))) {
+    SetLastError(error);
     return error;
+  }
+
+  // Keep our TCP packets coming without any delays.
+  SetOptionNoDelay();
+  error.Clear();
+  return error;
 }
 
-Error
-TCPSocket::Listen(llvm::StringRef name, int backlog)
-{
-    Error error;
+Error TCPSocket::Listen(llvm::StringRef name, int backlog) {
+  Error error;
 
-    // enable local address reuse
-    SetOptionReuseAddress();
+  // enable local address reuse
+  SetOptionReuseAddress();
 
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
-    if (log)
-        log->Printf ("TCPSocket::%s (%s)", __FUNCTION__, name.data());
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
+  if (log)
+    log->Printf("TCPSocket::%s (%s)", __FUNCTION__, name.data());
 
-    std::string host_str;
-    std::string port_str;
-    int32_t port = INT32_MIN;
-    if (!DecodeHostAndPort (name, host_str, port_str, port, &error))
-        return error;
+  std::string host_str;
+  std::string port_str;
+  int32_t port = INT32_MIN;
+  if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
+    return error;
 
-    SocketAddress bind_addr;
+  SocketAddress bind_addr;
 
-    // Only bind to the loopback address if we are expecting a connection from
-    // localhost to avoid any firewall issues.
-    const bool bind_addr_success = (host_str == "127.0.0.1") ?
-                                    bind_addr.SetToLocalhost (kDomain, port) :
-                                    bind_addr.SetToAnyAddress (kDomain, port);
+  // Only bind to the loopback address if we are expecting a connection from
+  // localhost to avoid any firewall issues.
+  const bool bind_addr_success = (host_str == "127.0.0.1")
+                                     ? bind_addr.SetToLocalhost(kDomain, port)
+                                     : bind_addr.SetToAnyAddress(kDomain, port);
 
-    if (!bind_addr_success)
-    {
-        error.SetErrorString("Failed to bind port");
-        return error;
-    }
+  if (!bind_addr_success) {
+    error.SetErrorString("Failed to bind port");
+    return error;
+  }
 
-    int err = ::bind (GetNativeSocket(), bind_addr, bind_addr.GetLength());
-    if (err != -1)
-        err = ::listen (GetNativeSocket(), backlog);
+  int err = ::bind(GetNativeSocket(), bind_addr, bind_addr.GetLength());
+  if (err != -1)
+    err = ::listen(GetNativeSocket(), backlog);
 
-    if (err == -1)
-        SetLastError (error);
+  if (err == -1)
+    SetLastError(error);
 
-    return error;
+  return error;
 }
 
-Error
-TCPSocket::Accept(llvm::StringRef name, bool child_processes_inherit, Socket *&conn_socket)
-{
-    Error error;
-    std::string host_str;
-    std::string port_str;
-    int32_t port;
-    if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
-        return error;
-
-    const sa_family_t family = kDomain;
-    const int socktype = kType;
-    const int protocol = IPPROTO_TCP;
-    SocketAddress listen_addr;
-    if (host_str.empty())
-        listen_addr.SetToLocalhost(family, port);
-    else if (host_str.compare("*") == 0)
-        listen_addr.SetToAnyAddress(family, port);
-    else
-    {
-        if (!listen_addr.getaddrinfo(host_str.c_str(), port_str.c_str(), family, socktype, protocol))
-        {
-            error.SetErrorStringWithFormat("unable to resolve hostname '%s'", host_str.c_str());
-            return error;
-        }
+Error TCPSocket::Accept(llvm::StringRef name, bool child_processes_inherit,
+                        Socket *&conn_socket) {
+  Error error;
+  std::string host_str;
+  std::string port_str;
+  int32_t port;
+  if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
+    return error;
+
+  const sa_family_t family = kDomain;
+  const int socktype = kType;
+  const int protocol = IPPROTO_TCP;
+  SocketAddress listen_addr;
+  if (host_str.empty())
+    listen_addr.SetToLocalhost(family, port);
+  else if (host_str.compare("*") == 0)
+    listen_addr.SetToAnyAddress(family, port);
+  else {
+    if (!listen_addr.getaddrinfo(host_str.c_str(), port_str.c_str(), family,
+                                 socktype, protocol)) {
+      error.SetErrorStringWithFormat("unable to resolve hostname '%s'",
+                                     host_str.c_str());
+      return error;
     }
+  }
 
-    bool accept_connection = false;
-    std::unique_ptr<TCPSocket> accepted_socket;
+  bool accept_connection = false;
+  std::unique_ptr<TCPSocket> accepted_socket;
 
-    // Loop until we are happy with our connection
-    while (!accept_connection)
-    {
-        struct sockaddr_in accept_addr;
-        ::memset (&accept_addr, 0, sizeof accept_addr);
-#if !(defined (__linux__) || defined(_WIN32))
-        accept_addr.sin_len = sizeof accept_addr;
+  // Loop until we are happy with our connection
+  while (!accept_connection) {
+    struct sockaddr_in accept_addr;
+    ::memset(&accept_addr, 0, sizeof accept_addr);
+#if !(defined(__linux__) || defined(_WIN32))
+    accept_addr.sin_len = sizeof accept_addr;
 #endif
-        socklen_t accept_addr_len = sizeof accept_addr;
+    socklen_t accept_addr_len = sizeof accept_addr;
 
-        int sock = AcceptSocket (GetNativeSocket(),
-                                 (struct sockaddr *)&accept_addr,
-                                 &accept_addr_len,
-                                 child_processes_inherit,
-                                 error);
+    int sock = AcceptSocket(GetNativeSocket(), (struct sockaddr *)&accept_addr,
+                            &accept_addr_len, child_processes_inherit, error);
 
-        if (error.Fail())
-            break;
+    if (error.Fail())
+      break;
 
-        bool is_same_addr = true;
+    bool is_same_addr = true;
 #if !(defined(__linux__) || (defined(_WIN32)))
-        is_same_addr = (accept_addr_len == listen_addr.sockaddr_in().sin_len);
+    is_same_addr = (accept_addr_len == listen_addr.sockaddr_in().sin_len);
 #endif
-        if (is_same_addr)
-            is_same_addr = (accept_addr.sin_addr.s_addr == listen_addr.sockaddr_in().sin_addr.s_addr);
-
-        if (is_same_addr || (listen_addr.sockaddr_in().sin_addr.s_addr == INADDR_ANY))
-        {
-            accept_connection = true;
-            accepted_socket.reset(new TCPSocket(sock, true));
-        }
-        else
-        {
-            const uint8_t *accept_ip = (const uint8_t *)&accept_addr.sin_addr.s_addr;
-            const uint8_t *listen_ip = (const uint8_t *)&listen_addr.sockaddr_in().sin_addr.s_addr;
-            ::fprintf (stderr, "error: rejecting incoming connection from %u.%u.%u.%u (expecting %u.%u.%u.%u)\n",
-                        accept_ip[0], accept_ip[1], accept_ip[2], accept_ip[3],
-                        listen_ip[0], listen_ip[1], listen_ip[2], listen_ip[3]);
-            accepted_socket.reset();
-        }
+    if (is_same_addr)
+      is_same_addr = (accept_addr.sin_addr.s_addr ==
+                      listen_addr.sockaddr_in().sin_addr.s_addr);
+
+    if (is_same_addr ||
+        (listen_addr.sockaddr_in().sin_addr.s_addr == INADDR_ANY)) {
+      accept_connection = true;
+      accepted_socket.reset(new TCPSocket(sock, true));
+    } else {
+      const uint8_t *accept_ip = (const uint8_t *)&accept_addr.sin_addr.s_addr;
+      const uint8_t *listen_ip =
+          (const uint8_t *)&listen_addr.sockaddr_in().sin_addr.s_addr;
+      ::fprintf(stderr, "error: rejecting incoming connection from %u.%u.%u.%u "
+                        "(expecting %u.%u.%u.%u)\n",
+                accept_ip[0], accept_ip[1], accept_ip[2], accept_ip[3],
+                listen_ip[0], listen_ip[1], listen_ip[2], listen_ip[3]);
+      accepted_socket.reset();
     }
+  }
 
-    if (!accepted_socket)
-        return error;
-
-    // Keep our TCP packets coming without any delays.
-    accepted_socket->SetOptionNoDelay();
-    error.Clear();
-    conn_socket = accepted_socket.release();
+  if (!accepted_socket)
     return error;
+
+  // Keep our TCP packets coming without any delays.
+  accepted_socket->SetOptionNoDelay();
+  error.Clear();
+  conn_socket = accepted_socket.release();
+  return error;
 }
 
-int
-TCPSocket::SetOptionNoDelay()
-{
-    return SetOption (IPPROTO_TCP, TCP_NODELAY, 1);
+int TCPSocket::SetOptionNoDelay() {
+  return SetOption(IPPROTO_TCP, TCP_NODELAY, 1);
 }
 
-int
-TCPSocket::SetOptionReuseAddress()
-{
-    return SetOption(SOL_SOCKET, SO_REUSEADDR, 1);
+int TCPSocket::SetOptionReuseAddress() {
+  return SetOption(SOL_SOCKET, SO_REUSEADDR, 1);
 }