bool
SocketDescriptor::BindPort(unsigned port)
{
SocketAddress address = SocketAddress::MakePort4(port);
return bind(Get(), address, address.GetLength()) == 0;
}
bool SocketImpl::Connect(const SocketAddress& address, const std::chrono::seconds& timeout /*= std::chrono::seconds(0)*/)
{
if (INVALID_SOCKET == m_sockfd)
Init(AF_INET);
if (timeout.count() > 0)
SetBlocking(false);
bool bResult = false;
do
{
if (SOCKET_ERROR == connect(m_sockfd, address.GetAddress(), address.GetLength()))
{
if (timeout.count() == 0)
break;
int err = WSAGetLastError();
if (WSAEINPROGRESS != err
&& WSAEWOULDBLOCK != err
&& WSAEISCONN != err)
break;
if (!Poll(timeout, SELECT_READ | SELECT_WRITE | SELECT_ERROR))
break;
if (GetSocketError() != 0)
break;
}
bResult = true;
} while (0);
if (timeout.count() > 0)
SetBlocking(true);
return bResult;
}
bool
SocketDescriptor::Connect(const SocketAddress &address)
{
assert(address.IsDefined());
return ::connect(Get(), address, address.GetLength()) >= 0;
}
bool SocketImpl::Bind(const SocketAddress& address, bool bReuse /*= false*/)
{
if (INVALID_SOCKET == m_sockfd)
Init(AF_INET);
if (bReuse)
SetReuseAddress(true);
return bind(m_sockfd, address.GetAddress(), address.GetLength()) != SOCKET_ERROR;
}
ssize_t
SocketDescriptor::Write(const void *buffer, size_t length,
const SocketAddress &address)
{
return ::sendto(Get(), (const char *)buffer, length,
#ifdef HAVE_POSIX
#ifdef __linux__
MSG_DONTWAIT|MSG_NOSIGNAL,
#else
MSG_DONTWAIT,
#endif
#else
0,
#endif
address, address.GetLength());
}
Error UDPSocket::Connect(llvm::StringRef name, bool child_processes_inherit,
Socket *&send_socket, Socket *&recv_socket) {
std::unique_ptr<UDPSocket> final_send_socket;
std::unique_ptr<UDPSocket> final_recv_socket;
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf("UDPSocket::%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;
// 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_socket.reset(new UDPSocket(child_processes_inherit, error));
if (error.Success()) {
// Socket was created, now lets bind to the requested port
SocketAddress addr;
addr.SetToAnyAddress(AF_INET, 0);
if (::bind(final_recv_socket->GetNativeSocket(), addr, addr.GetLength()) ==
-1) {
// Bind failed...
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
// setup the UDP send socket
struct addrinfo hints;
struct addrinfo *service_info_list = nullptr;
::memset(&hints, 0, sizeof(hints));
hints.ai_family = kDomain;
hints.ai_socktype = kType;
int err = ::getaddrinfo(host_str.c_str(), port_str.c_str(), &hints,
&service_info_list);
if (err != 0) {
error.SetErrorStringWithFormat(
#if defined(_MSC_VER) && defined(UNICODE)
"getaddrinfo(%s, %s, &hints, &info) returned error %i (%S)",
#else
"getaddrinfo(%s, %s, &hints, &info) returned error %i (%s)",
#endif
host_str.c_str(), port_str.c_str(), err, gai_strerror(err));
return error;
}
for (struct addrinfo *service_info_ptr = service_info_list;
service_info_ptr != nullptr;
service_info_ptr = service_info_ptr->ai_next) {
auto send_fd = CreateSocket(
service_info_ptr->ai_family, service_info_ptr->ai_socktype,
service_info_ptr->ai_protocol, child_processes_inherit, error);
if (error.Success()) {
final_send_socket.reset(new UDPSocket(send_fd));
final_send_socket->m_send_sockaddr = service_info_ptr;
break;
} else
continue;
}
::freeaddrinfo(service_info_list);
if (!final_send_socket)
return error;
send_socket = final_send_socket.release();
recv_socket = final_recv_socket.release();
error.Clear();
return error;
}
ConnectionStatus
ConnectionFileDescriptor::ConnectUDP (const char *host_and_port, Error *error_ptr)
{
LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::ConnectUDP (host/port = %s)", this, host_and_port);
Disconnect (NULL);
m_fd_send_type = m_fd_recv_type = eFDTypeSocketUDP;
std::string host_str;
std::string port_str;
int32_t port = INT32_MIN;
if (!DecodeHostAndPort (host_and_port, host_str, port_str, port, error_ptr))
return eConnectionStatusError;
// 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.
m_fd_recv = ::socket (AF_INET, SOCK_DGRAM, 0);
if (m_fd_recv == -1)
{
// Socket creation failed...
if (error_ptr)
error_ptr->SetErrorToErrno();
}
else
{
// Socket was created, now lets bind to the requested port
SocketAddress addr;
addr.SetToLocalhost (AF_INET, 0);
if (::bind (m_fd_recv, addr, addr.GetLength()) == -1)
{
// Bind failed...
if (error_ptr)
error_ptr->SetErrorToErrno();
Disconnect (NULL);
}
}
if (m_fd_recv == -1)
return eConnectionStatusError;
// At this point we have setup the recieve port, now we need to
// setup the UDP send socket
struct addrinfo hints;
struct addrinfo *service_info_list = NULL;
::memset (&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
int err = ::getaddrinfo (host_str.c_str(), port_str.c_str(), &hints, &service_info_list);
if (err != 0)
{
if (error_ptr)
error_ptr->SetErrorStringWithFormat("getaddrinfo(%s, %s, &hints, &info) returned error %i (%s)",
host_str.c_str(),
port_str.c_str(),
err,
gai_strerror(err));
Disconnect (NULL);
return eConnectionStatusError;
}
for (struct addrinfo *service_info_ptr = service_info_list;
service_info_ptr != NULL;
service_info_ptr = service_info_ptr->ai_next)
{
m_fd_send = ::socket (service_info_ptr->ai_family,
service_info_ptr->ai_socktype,
service_info_ptr->ai_protocol);
if (m_fd_send != -1)
{
m_udp_send_sockaddr = service_info_ptr;
break;
}
else
continue;
}
:: freeaddrinfo (service_info_list);
if (m_fd_send == -1)
{
Disconnect (NULL);
return eConnectionStatusError;
}
if (error_ptr)
error_ptr->Clear();
m_should_close_fd = true;
return eConnectionStatusSuccess;
}
ConnectionStatus
ConnectionFileDescriptor::SocketListen (uint16_t listen_port_num, Error *error_ptr)
{
LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::SocketListen (port = %i)", this, listen_port_num);
Disconnect (NULL);
m_fd_send_type = m_fd_recv_type = eFDTypeSocket;
int listen_port = ::socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listen_port == -1)
{
if (error_ptr)
error_ptr->SetErrorToErrno();
return eConnectionStatusError;
}
// enable local address reuse
SetSocketOption (listen_port, SOL_SOCKET, SO_REUSEADDR, 1);
SocketAddress localhost;
if (localhost.SetToLocalhost (AF_INET, listen_port_num))
{
int err = ::bind (listen_port, localhost, localhost.GetLength());
if (err == -1)
{
if (error_ptr)
error_ptr->SetErrorToErrno();
Close (listen_port, NULL);
return eConnectionStatusError;
}
err = ::listen (listen_port, 1);
if (err == -1)
{
if (error_ptr)
error_ptr->SetErrorToErrno();
Close (listen_port, NULL);
return eConnectionStatusError;
}
m_fd_send = m_fd_recv = ::accept (listen_port, NULL, 0);
if (m_fd_send == -1)
{
if (error_ptr)
error_ptr->SetErrorToErrno();
Close (listen_port, NULL);
return eConnectionStatusError;
}
}
// We are done with the listen port
Close (listen_port, NULL);
m_should_close_fd = true;
// Keep our TCP packets coming without any delays.
SetSocketOption (m_fd_send, IPPROTO_TCP, TCP_NODELAY, 1);
if (error_ptr)
error_ptr->Clear();
return eConnectionStatusSuccess;
}
int SocketImpl::SendTo(const char* buffer, int length, const SocketAddress& address, int flags /*= 0*/)
{
assert(INVALID_SOCKET != m_sockfd);
return sendto(m_sockfd, buffer, length, flags, address.GetAddress(), address.GetLength());
}
Error Socket::UdpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&send_socket, Socket *&recv_socket)
{
std::unique_ptr<Socket> final_send_socket;
std::unique_ptr<Socket> final_recv_socket;
NativeSocket final_send_fd = kInvalidSocketValue;
NativeSocket final_recv_fd = kInvalidSocketValue;
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("Socket::UdpConnect (host/port = %s)", host_and_port.data());
Error error;
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;
// 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...
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...
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
// setup the UDP send socket
struct addrinfo hints;
struct addrinfo *service_info_list = NULL;
::memset (&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
int err = ::getaddrinfo (host_str.c_str(), port_str.c_str(), &hints, &service_info_list);
if (err != 0)
{
error.SetErrorStringWithFormat("getaddrinfo(%s, %s, &hints, &info) returned error %i (%s)",
host_str.c_str(),
port_str.c_str(),
err,
gai_strerror(err));
return error;
}
for (struct addrinfo *service_info_ptr = service_info_list;
service_info_ptr != NULL;
service_info_ptr = service_info_ptr->ai_next)
{
final_send_fd = ::CreateSocket (service_info_ptr->ai_family,
service_info_ptr->ai_socktype,
service_info_ptr->ai_protocol,
child_processes_inherit);
if (final_send_fd != kInvalidSocketValue)
{
final_send_socket.reset(new Socket(final_send_fd, ProtocolUdp, true));
final_send_socket->m_udp_send_sockaddr = service_info_ptr;
break;
}
else
continue;
}
:: freeaddrinfo (service_info_list);
if (final_send_fd == kInvalidSocketValue)
{
SetLastError (error);
return error;
}
send_socket = final_send_socket.release();
recv_socket = final_recv_socket.release();
error.Clear();
return error;
}