bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)
{
proxyType proxy;
// no proxy needed
if (!GetProxy(addrDest.GetNetwork(), proxy))
return ConnectSocketDirectly(addrDest, hSocketRet, nTimeout);
SOCKET hSocket = INVALID_SOCKET;
// first connect to proxy server
if (!ConnectSocketDirectly(proxy.first, hSocket, nTimeout))
return false;
// do socks negotiation
switch (proxy.second) {
case 4:
if (!Socks4(addrDest, hSocket))
return false;
break;
case 5:
if (!Socks5(addrDest.ToStringIP(), addrDest.GetPort(), hSocket))
return false;
break;
default:
closesocket(hSocket);
return false;
}
hSocketRet = hSocket;
return true;
}
void SctpSocket::OnException()
{
if (Connecting())
{
#ifdef ENABLE_SOCKS4
if (Socks4())
OnSocks4ConnectFailed();
else
#endif
if (GetConnectionRetry() == -1 ||
(GetConnectionRetry() &&
GetConnectionRetries() < GetConnectionRetry() ))
{
// even though the connection failed at once, only retry after
// the connection timeout
// should we even try to connect again, when CheckConnect returns
// false it's because of a connection error - not a timeout...
}
else
{
SetConnecting(false); // tnx snibbe
SetCloseAndDelete();
OnConnectFailed();
}
return;
}
// %! exception doesn't always mean something bad happened, this code should be reworked
// errno valid here?
int err = SoError();
Handler().LogError(this, "exception on select", err, StrError(err), LOG_LEVEL_FATAL);
SetCloseAndDelete();
}
void SctpSocket::OnWrite()
{
if (Connecting())
{
int err = SoError();
// don't reset connecting flag on error here, we want the OnConnectFailed timeout later on
/// \todo add to read fd_set here
if (!err) // ok
{
Set(!IsDisableRead(), false);
SetConnecting(false);
SetCallOnConnect();
return;
}
Handler().LogError(this, "sctp: connect failed", err, StrError(err), LOG_LEVEL_FATAL);
Set(false, false); // no more monitoring because connection failed
// failed
#ifdef ENABLE_SOCKS4
if (Socks4())
{
OnSocks4ConnectFailed();
return;
}
#endif
if (GetConnectionRetry() == -1 ||
(GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) )
{
// even though the connection failed at once, only retry after
// the connection timeout.
// should we even try to connect again, when CheckConnect returns
// false it's because of a connection error - not a timeout...
return;
}
SetConnecting(false);
SetCloseAndDelete( true );
/// \todo state reason why connect failed
OnConnectFailed();
return;
}
}
void SctpSocket::OnConnectTimeout()
{
Handler().LogError(this, "connect", -1, "connect timeout", LOG_LEVEL_FATAL);
#ifdef ENABLE_SOCKS4
if (Socks4())
{
OnSocks4ConnectFailed();
// retry direct connection
}
else
#endif
if (GetConnectionRetry() == -1 ||
(GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) )
{
IncreaseConnectionRetries();
// ask socket via OnConnectRetry callback if we should continue trying
if (OnConnectRetry())
{
SetRetryClientConnect();
}
else
{
SetCloseAndDelete( true );
/// \todo state reason why connect failed
OnConnectFailed();
}
}
else
{
SetCloseAndDelete(true);
/// \todo state reason why connect failed
OnConnectFailed();
}
//
SetConnecting(false);
}
bool TcpSocket::Open(SocketAddress& ad,SocketAddress& bind_ad,bool skip_socks)
{
if (!ad.IsValid())
{
Handler().LogError(this, "Open", 0, "Invalid SocketAddress", LOG_LEVEL_FATAL);
SetCloseAndDelete();
return false;
}
if (Handler().GetCount() >= Handler().MaxCount())
{
Handler().LogError(this, "Open", 0, "no space left for more sockets", LOG_LEVEL_FATAL);
SetCloseAndDelete();
return false;
}
SetConnecting(false);
#ifdef ENABLE_SOCKS4
SetSocks4(false);
#endif
// check for pooling
#ifdef ENABLE_POOL
if (Handler().PoolEnabled())
{
ISocketHandler::PoolSocket *pools = Handler().FindConnection(SOCK_STREAM, "tcp", ad);
if (pools)
{
CopyConnection( pools );
delete pools;
SetIsClient();
SetCallOnConnect(); // ISocketHandler must call OnConnect
Handler().LogError(this, "SetCallOnConnect", 0, "Found pooled connection", LOG_LEVEL_INFO);
return true;
}
}
#endif
// if not, create new connection
SOCKET s = CreateSocket(ad.GetFamily(), SOCK_STREAM, "tcp");
if (s == INVALID_SOCKET)
{
return false;
}
// socket must be nonblocking for async connect
if (!SetNonblocking(true, s))
{
SetCloseAndDelete();
closesocket(s);
return false;
}
#ifdef ENABLE_POOL
SetIsClient(); // client because we connect
#endif
SetClientRemoteAddress(ad);
int n = 0;
if (bind_ad.GetPort() != 0)
{
bind(s, bind_ad, bind_ad);
}
#ifdef ENABLE_SOCKS4
if (!skip_socks && GetSocks4Host() && GetSocks4Port())
{
Ipv4Address sa(GetSocks4Host(), GetSocks4Port());
{
std::string sockshost;
Utility::l2ip(GetSocks4Host(), sockshost);
Handler().LogError(this, "Open", 0, "Connecting to socks4 server @ " + sockshost + ":" +
Utility::l2string(GetSocks4Port()), LOG_LEVEL_INFO);
}
SetSocks4();
n = connect(s, sa, sa);
SetRemoteAddress(sa);
}
else
#endif
{
n = connect(s, ad, ad);
SetRemoteAddress(ad);
}
if (n == -1)
{
// check error code that means a connect is in progress
#ifdef _WIN32
if (Errno == WSAEWOULDBLOCK)
#else
if (Errno == EINPROGRESS)
#endif
{
Attach(s);
SetConnecting( true ); // this flag will control fd_set's
}
else
#ifdef ENABLE_SOCKS4
if (Socks4() && Handler().Socks4TryDirect() ) // retry
{
closesocket(s);
return Open(ad, true);
}
else
#endif
#ifdef ENABLE_RECONNECT
if (Reconnect())
{
Handler().LogError(this, "connect: failed, reconnect pending", Errno, StrError(Errno), LOG_LEVEL_INFO);
Attach(s);
SetConnecting( true ); // this flag will control fd_set's
}
else
#endif
{
Handler().LogError(this, "connect: failed", Errno, StrError(Errno), LOG_LEVEL_FATAL);
SetCloseAndDelete();
closesocket(s);
return false;
}
}
else
{
Attach(s);
SetCallOnConnect(); // ISocketHandler must call OnConnect
}
// 'true' means connected or connecting(not yet connected)
// 'false' means something failed
return true; //!Connecting();
}