void TCPSocket::Write(const char* buffer, size_t bufferLen)
{
if (tls.get())
{
tls->Write(buffer, bufferLen);
return;
}
size_t written = 0;
ssize_t result;
while (bufferLen - written > 0)
{
while ((result = write(socket, buffer + written, bufferLen - written)) < 0)
{
boost::this_thread::interruption_point();
if (errno != EINTR)
{
if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ETIMEDOUT)
throw TimeoutError();
else
throw NetworkSystemError(errno);
}
}
boost::this_thread::interruption_point();
written += result;
}
}
void TCPSocket::Accept(TCPListener& listener)
{
struct sockaddr_storage addrStor;
socklen_t addrLen = sizeof(addrStor);
struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addrStor);
int socket;
while ((socket = accept(listener.Socket(), addr, &addrLen)) < 0)
{
boost::this_thread::interruption_point();
if (errno != EINTR)
{
if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ETIMEDOUT)
throw TimeoutError();
else
throw NetworkSystemError(errno);
}
}
auto socketGuard = util::MakeScopeError([&socket]() { close(socket); }); (void) socketGuard;
boost::this_thread::interruption_point();
PopulateRemoteEndpoint(socket);
PopulateLocalEndpoint(socket);
std::lock_guard<std::mutex> lock(socketMutex);
this->socket = socket;
}
void
ebbrt::SimpleRemoteHashTable::HandleTimeout(unsigned op_id)
{
auto it = promise_map_.find(op_id);
if (it != promise_map_.end()) {
it->second.SetException(make_exception_ptr(TimeoutError()));
promise_map_.erase(it);
}
}
void Error::translate(RemoteDB::Error e)
{
switch(e.code())
{
//case SUCCESS : return "NoError";
case NOIMPL : throw NotImplementedError(e);
case INVALID : throw InvalidError(e);
case LOGIC : throw LogicError(e);
case TIMEOUT : throw TimeoutError(e);
case INTERNAL: throw InternalError(e);
case NETWORK : throw NetworkError(e);
case EMISC : throw MiscError(e);
default : throw Error(e);
}
}
void TCPSocket::Connect(const Endpoint& remoteEndpoint, const Endpoint* localEndpoint)
{
assert(socket < 0);
int socket = ::socket(static_cast<int>(remoteEndpoint.Family()), SOCK_STREAM, 0);
if (socket < 0) throw NetworkSystemError(errno);
auto socketGuard = util::MakeScopeError([&socket]() { close(socket); }); (void) socketGuard;
int optVal = 1;
setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &optVal, sizeof(optVal));
SetTimeout(socket);
if (localEndpoint)
{
socklen_t addrLen = localEndpoint->Length();
struct sockaddr_storage addrStor;
memcpy(&addrStor, localEndpoint->Addr(), addrLen);
struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addrStor);
if (bind(socket, addr, addrLen) < 0)
{
int errno_ = errno;
throw util::net::NetworkSystemError(errno_);
}
}
while (connect(socket, remoteEndpoint.Addr(), remoteEndpoint.Length()) < 0)
{
boost::this_thread::interruption_point();
if (errno != EINTR)
{
int errno_ = errno;
if (errno_ == EWOULDBLOCK || errno_ == EAGAIN || errno_ == ETIMEDOUT)
throw TimeoutError();
else
throw NetworkSystemError(errno_);
}
}
boost::this_thread::interruption_point();
PopulateRemoteEndpoint(socket);
PopulateLocalEndpoint(socket);
std::lock_guard<std::mutex> lock(socketMutex);
this->socket = socket;
}
size_t TCPSocket::Read(char* buffer, size_t bufferSize)
{
if (tls.get()) return tls->Read(buffer, bufferSize);
ssize_t result;
while ((result = read(socket, buffer, bufferSize)) < 0)
{
boost::this_thread::interruption_point();
if (errno != EINTR)
{
if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ETIMEDOUT)
throw TimeoutError();
else
throw NetworkSystemError(errno);
}
}
boost::this_thread::interruption_point();
if (!result) throw EndOfStream();
return result;
}
void TLSSocket::EvaluateResult(int result)
{
switch (SSL_get_error(session, result))
{
case SSL_ERROR_WANT_READ :
case SSL_ERROR_WANT_WRITE :
{
break;
}
case SSL_ERROR_SSL :
{
throw TLSProtocolError();
}
case SSL_ERROR_ZERO_RETURN :
{
throw EndOfStream();
}
case SSL_ERROR_SYSCALL :
{
int error = ERR_get_error();
if (error) throw TLSProtocolError();
else if (!result) throw EndOfStream();
else if (result == -1)
{
if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ETIMEDOUT)
throw TimeoutError();
else
throw TLSSystemError(errno);
}
}
default :
{
throw TLSError();
}
}
}
