Wrap socket error handling with SetLastError and IsInterrupted internal functions which can properly treat Windows and POSIX errors.

[ovyalov]

Summary

Populate Error object either with errno or WSAGetLastError() in case of Windows.
We'll still need to fix Error::AsCString to call FormatMessage for Windows errors but at least with this CL we can report about socket errors on Windows with meaningful code and message like "unknown error".

[clayborg]

Looks good.

[zturner]

Looks ok. I'm wondering at what point we should break the Socket class up into a SocketWindows and SocketPosix variants. Seems like soon, the number of ifdefs keeps growing. Not suggesting you should do this now though, just thinking out loud.

source/Host/common/Socket.cpp

598

Indentation is messed up here.

640

Messed up here too.

[ovyalov]

In D8939#154230, @zturner wrote:

Looks ok. I'm wondering at what point we should break the Socket class up into a SocketWindows and SocketPosix variants. Seems like soon, the number of ifdefs keeps growing. Not suggesting you should do this now though, just thinking out loud.

Agree - we'll need to do this soon.

source/Host/common/Socket.cpp

598

Fixed.

640

Fixed.

[ovyalov]

Fixed indentation.

[ovyalov]

AFFECTED FILES

/lldb/trunk/source/Host/common/Socket.cpp

USERS

ovyalov (Author)

http://reviews.llvm.org/rL234559

source/Host/common/Socket.cpp

#ifdef SOCK_CLOEXEC
     if (!child_processes_inherit) {
         flags |= SOCK_CLOEXEC;
     }
     return ::accept4 (sockfd, addr, addrlen, flags);
 #else
     return ::accept (sockfd, addr, addrlen);
 #endif
 }
+
+void SetLastError(Error &error)
+{
+#if defined(_WIN32)
+    error.SetError(::WSAGetLastError(), lldb::eErrorTypeWin32);
+#else
+    error.SetErrorToErrno();
+#endif
+}
+
+bool IsInterrupted()
+{
+#if defined(_WIN32)
+    return ::WSAGetLastError() == WSAEINTR;
+#else
+    return errno == EINTR;
+#endif
+}
+
 }
 
 Socket::Socket(NativeSocket socket, SocketProtocol protocol, bool should_close)
     : IOObject(eFDTypeSocket, should_close)
     , m_protocol(protocol)
     , m_socket(socket)
 {
 
Error Socket::TcpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket)
     int32_t port = INT32_MIN;
     if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, &error))
         return error;
 
     // Create the socket
     sock = CreateSocket (AF_INET, SOCK_STREAM, IPPROTO_TCP, child_processes_inherit);
     if (sock == kInvalidSocketValue)
     {
-        // TODO: On Windows, use WSAGetLastError().
-        error.SetErrorToErrno();
+        SetLastError (error);
         return error;
     }
 
     // Since they both refer to the same socket descriptor, arbitrarily choose the send socket to
     // be the owner.
     final_socket.reset(new Socket(sock, ProtocolTcp, true));
 
     // Enable local address reuse
Error Socket::TcpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket)
     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 (AF_INET, host_str.c_str(), &sa.sin_addr);
         if (inet_pton_result <= 0)
         {
-            // TODO: On Windows, use WSAGetLastError()
             if (inet_pton_result == -1)
-                error.SetErrorToErrno();
+                SetLastError(error);
             else
                 error.SetErrorStringWithFormat("invalid host string: '%s'", host_str.c_str());
 
             return error;
         }
     }
 
     if (-1 == ::connect (sock, (const struct sockaddr *)&sa, sizeof(sa)))
     {
-        // TODO: On Windows, use WSAGetLastError()
-        error.SetErrorToErrno();
+        SetLastError (error);
         return error;
     }
 
     // Keep our TCP packets coming without any delays.
     final_socket->SetOption(IPPROTO_TCP, TCP_NODELAY, 1);
     error.Clear();
     socket = final_socket.release();
     return error;
Error Socket::TcpListen(
     Error error;
 
     const sa_family_t family = AF_INET;
     const int socktype = SOCK_STREAM;
     const int protocol = IPPROTO_TCP;
     listen_sock = ::CreateSocket (family, socktype, protocol, child_processes_inherit);
     if (listen_sock == kInvalidSocketValue)
     {
-        error.SetErrorToErrno();
+        SetLastError (error);
         return error;
     }
 
     listen_socket.reset(new Socket(listen_sock, ProtocolTcp, true));
 
     // enable local address reuse
     listen_socket->SetOption(SOL_SOCKET, SO_REUSEADDR, 1);
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
     if (log)
         log->Printf ("Socket::TcpListen (%s)", host_and_port.data());
 
     std::string host_str;
     std::string port_str;
     int32_t port = INT32_MIN;
     if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, &error))
         return error;
 
     SocketAddress anyaddr;
     if (anyaddr.SetToAnyAddress (family, port))
     {
         int err = ::bind (listen_sock, anyaddr, anyaddr.GetLength());
         if (err == -1)
         {
-            // TODO: On Windows, use WSAGetLastError()
-            error.SetErrorToErrno();
+            SetLastError (error);
             return error;
         }
 
         err = ::listen (listen_sock, backlog);
         if (err == -1)
         {
-            // TODO: On Windows, use WSAGetLastError()
-            error.SetErrorToErrno();
+            SetLastError (error);
             return error;
         }
 
         // We were asked to listen on port zero which means we
         // must now read the actual port that was given to us
         // as port zero is a special code for "find an open port
         // for me".
         if (port == 0)
#endif
 
         int sock = Accept (this->GetNativeSocket(),
                            (struct sockaddr *)&accept_addr,
                            &accept_addr_len,
                            child_processes_inherit);
             
         if (sock == kInvalidSocketValue)
         {
-            // TODO: On Windows, use WSAGetLastError()
-            error.SetErrorToErrno();
+            SetLastError (error);
             break;
         }
     
         bool is_same_addr = true;
 #if !(defined(__linux__) || (defined(_WIN32)))
         is_same_addr = (accept_addr_len == listen_addr.sockaddr_in().sin_len);
 #endif
         if (is_same_addr)
if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, &error))
         return error;
 
     // Setup the receiving end of the UDP connection on this localhost
     // on port zero. After we bind to port zero we can read the port.
     final_recv_fd = ::CreateSocket (AF_INET, SOCK_DGRAM, 0, child_processes_inherit);
     if (final_recv_fd == kInvalidSocketValue)
     {
         // Socket creation failed...
-        // TODO: On Windows, use WSAGetLastError().
-        error.SetErrorToErrno();
+        SetLastError (error);
     }
     else
     {
         final_recv_socket.reset(new Socket(final_recv_fd, ProtocolUdp, true));
 
         // Socket was created, now lets bind to the requested port
         SocketAddress addr;
         addr.SetToAnyAddress (AF_INET, 0);
 
         if (::bind (final_recv_fd, addr, addr.GetLength()) == -1)
         {
             // Bind failed...
-            // TODO: On Windows use WSAGetLastError()
-            error.SetErrorToErrno();
+            SetLastError (error);
         }
     }
 
     assert(error.Fail() == !(final_recv_socket && final_recv_socket->IsValid()));
     if (error.Fail())
         return error;
 
     // At this point we have setup the receive port, now we need to 
for (struct addrinfo *service_info_ptr = service_info_list;
         else
             continue;
     }
 
     :: freeaddrinfo (service_info_list);
 
     if (final_send_fd == kInvalidSocketValue)
     {
-        // TODO: On Windows, use WSAGetLastError().
-        error.SetErrorToErrno();
+        SetLastError (error);
         return error;
     }
 
     send_socket = final_send_socket.release();
     recv_socket = final_recv_socket.release();
     error.Clear();
     return error;
 }
 
 Error Socket::UnixDomainConnect(llvm::StringRef name, bool child_processes_inherit, Socket *&socket)
 {
     Error error;
 #ifndef LLDB_DISABLE_POSIX
     std::unique_ptr<Socket> final_socket;
 
     // Open the socket that was passed in as an option
     struct sockaddr_un saddr_un;
     int fd = ::CreateSocket (AF_UNIX, SOCK_STREAM, 0, child_processes_inherit);
     if (fd == kInvalidSocketValue)
     {
-        error.SetErrorToErrno();
+        SetLastError (error);
         return error;
     }
 
     final_socket.reset(new Socket(fd, ProtocolUnixDomain, true));
 
     saddr_un.sun_family = AF_UNIX;
     ::strncpy(saddr_un.sun_path, name.data(), sizeof(saddr_un.sun_path) - 1);
     saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
     saddr_un.sun_len = SUN_LEN (&saddr_un);
 #endif
 
     if (::connect (fd, (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) < 0) 
     {
-        error.SetErrorToErrno();
+        SetLastError (error);
         return error;
     }
 
     socket = final_socket.release();
 #else
     error.SetErrorString("Unix domain sockets are not supported on this platform.");
 #endif
     return error;
 }
 
 Error Socket::UnixDomainAccept(llvm::StringRef name, bool child_processes_inherit, Socket *&socket)
 {
     Error error;
 #ifndef LLDB_DISABLE_POSIX
     struct sockaddr_un saddr_un;
     std::unique_ptr<Socket> listen_socket;
     std::unique_ptr<Socket> final_socket;
     NativeSocket listen_fd = kInvalidSocketValue;
     NativeSocket socket_fd = kInvalidSocketValue;
     
     listen_fd = ::CreateSocket (AF_UNIX, SOCK_STREAM, 0, child_processes_inherit);
     if (listen_fd == kInvalidSocketValue)
     {
-        error.SetErrorToErrno();
+        SetLastError (error);
         return error;
     }
 
     listen_socket.reset(new Socket(listen_fd, ProtocolUnixDomain, true));
 
     saddr_un.sun_family = AF_UNIX;
     ::strncpy(saddr_un.sun_path, name.data(), sizeof(saddr_un.sun_path) - 1);
     saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
if (::bind (listen_fd, (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) == 0)
                 final_socket.reset(new Socket(socket_fd, ProtocolUnixDomain, true));
                 success = true;
             }
         }
     }
     
     if (!success)
     {
-        error.SetErrorToErrno();
+        SetLastError (error);
         return error;
     }
     // We are done with the listen port
     listen_socket.reset();
 
     socket = final_socket.release();
 #else
     error.SetErrorString("Unix domain sockets are not supported on this platform.");

 
 Error Socket::Read (void *buf, size_t &num_bytes)
 {
     Error error;
     int bytes_received = 0;
     do
     {
         bytes_received = ::recv (m_socket, static_cast<char *>(buf), num_bytes, 0);
-        // TODO: Use WSAGetLastError on windows.
-    } while (bytes_received < 0 && errno == EINTR);
+    } while (bytes_received < 0 && IsInterrupted ());
 
     if (bytes_received < 0)
     {
-        error.SetErrorToErrno();
+        SetLastError (error);
         num_bytes = 0;
     }
     else
         num_bytes = bytes_received;
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_HOST | LIBLLDB_LOG_COMMUNICATION)); 
     if (log)
     {
do
                                     static_cast<const char*>(buf), 
                                     num_bytes, 
                                     0, 
                                     m_udp_send_sockaddr,
                                     m_udp_send_sockaddr.GetLength());
         }
         else
             bytes_sent = ::send (m_socket, static_cast<const char *>(buf), num_bytes, 0);
-        // TODO: Use WSAGetLastError on windows.
-    } while (bytes_sent < 0 && errno == EINTR);
+    } while (bytes_sent < 0 && IsInterrupted ());
 
     if (bytes_sent < 0)
     {
-        // TODO: On Windows, use WSAGEtLastError.
-        error.SetErrorToErrno();
+        SetLastError (error);
         num_bytes = 0;
     }
     else
         num_bytes = bytes_sent;
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_HOST));
     if (log)
     {
#if defined(_WIN32)
     bool success = !!closesocket(m_socket);
 #else
     bool success = !!::close (m_socket);
 #endif
     // A reference to a FD was passed in, set it to an invalid value
     m_socket = kInvalidSocketValue;
     if (!success)
     {
-        // TODO: On Windows, use WSAGetLastError().
-        error.SetErrorToErrno();
+        SetLastError (error);
     }
 
     return error;
 }
 
 
 int Socket::GetOption(int level, int option_name, int &option_value)
 {