int PhysicalSocket::RecvFrom(void* buffer, size_t length, SocketAddress* out_addr)
{
sockaddr_storage addr_storage;
socklen_t addr_len = sizeof(addr_storage);
sockaddr* addr = reinterpret_cast<sockaddr*>(&addr_storage);
int received = (int)::recvfrom(s_, static_cast<char*>(buffer), static_cast<int>(length), 0, addr, &addr_len);
UpdateLastError();
if ((received >= 0) && (out_addr != NULL))
SocketAddressFromSockAddrStorage(addr_storage, out_addr);
int error = GetError();
bool success = (received >= 0) || IsBlockingError(error);
if (udp_ || success)
{
enabled_events_ |= DE_READ;
}
if (!success)
{
printf("Error = %d.\n", error);
}
return received;
}
int PhysicalSocket::DoConnect(const SocketAddress& connect_addr)
{
if ((s_ == INVALID_SOCKET) && !Create(connect_addr.family(), SOCK_STREAM))
{
return SOCKET_ERROR;
}
sockaddr_storage addr_storage;
size_t len = connect_addr.ToSockAddrStorage(&addr_storage);
sockaddr* addr = reinterpret_cast<sockaddr*>(&addr_storage);
int err = ::connect(s_, addr, static_cast<int>(len));
UpdateLastError();
if (err == 0)
{
state_ = CS_CONNECTED;
}
else if (IsBlockingError(GetError()))
{
state_ = CS_CONNECTING;
enabled_events_ |= DE_CONNECT;
}
else
{
return SOCKET_ERROR;
}
enabled_events_ |= DE_READ | DE_WRITE;
return 0;
}
// AutoDetectProxy Slots
void OnProxyDetectionComplete(SignalThread* thread) {
ASSERT(detect_ == thread);
Attach(factory_->CreateProxySocket(detect_->proxy(), type_));
detect_->Release();
detect_ = NULL;
if (0 == AsyncSocketAdapter::Connect(remote_)) {
SignalConnectEvent(this);
} else if (!IsBlockingError(socket_->GetError())) {
SignalCloseEvent(this, socket_->GetError());
}
}
int PhysicalSocket::Send(const void* pv, size_t cb)
{
int sent = (int)::send(s_, reinterpret_cast<const char *>(pv), (int)cb,0);
UpdateLastError();
MaybeRemapSendError();
if ((sent < 0) && IsBlockingError(GetError())) {
enabled_events_ |= DE_WRITE;
}
return sent;
}
int PhysicalSocket::SendTo(const void* buffer, size_t length, const SocketAddress& addr)
{
sockaddr_storage saddr;
size_t len = addr.ToSockAddrStorage(&saddr);
int sent = (int)::sendto(s_, static_cast<const char *>(buffer), static_cast<int>(length),
0,
reinterpret_cast<sockaddr*>(&saddr), static_cast<int>(len));
UpdateLastError();
MaybeRemapSendError();
if ((sent < 0) && IsBlockingError(GetError()))
{
enabled_events_ |= DE_WRITE;
}
return sent;
}
int PhysicalSocket::Recv(void* buffer, size_t length)
{
int received = (int)::recv(s_, static_cast<char*>(buffer), static_cast<int>(length), 0);
if ((received == 0) && (length != 0))
{
printf("EOF from socket; deferring close event");
enabled_events_ |= DE_READ;
SetError(EWOULDBLOCK);
return SOCKET_ERROR;
}
UpdateLastError();
int error = GetError();
bool success = (received >= 0) || IsBlockingError(error);
if (udp_ || success) {
enabled_events_ |= DE_READ;
}
if (!success) {
printf("Error = %d.\n", error);
}
return received;
}
