HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::BindConnectHelper( CLR_RT_StackFrame& stack, bool fBind )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_RT_HeapBlock* socket = stack.Arg0().Dereference();
CLR_INT32 handle;
SOCK_sockaddr addr;
CLR_UINT32 addrLen = sizeof(addr);
CLR_INT32 ret;
bool fThrowOnWouldBlock = false;
FAULT_ON_NULL(socket);
handle = socket[ FIELD__m_Handle ].NumericByRef().s4;
TINYCLR_CHECK_HRESULT(MarshalSockAddress( &addr, addrLen, stack.Arg1() ));
if(fBind)
{
ret = SOCK_bind( handle, &addr, addrLen );
}
else
{
ret = SOCK_connect( handle, &addr, addrLen );
fThrowOnWouldBlock = (stack.Arg2().NumericByRefConst().s4 != 0);
if(!fThrowOnWouldBlock && SOCK_getlasterror() == SOCK_EWOULDBLOCK)
{
TINYCLR_SET_AND_LEAVE(S_OK);
}
}
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, ret ));
TINYCLR_NOCLEANUP();
}
INT32 SNTPClient::Connect()
{
SOCK_SOCKET timeSocket = SOCK_SOCKET_ERROR;
INT32 sockErr = 0;
UINT32 usedServer = 0;
// look up outstdanding queries for this set of servers
OutstandingQuery* query = FindOutstandingConnection(m_ipAddressPrimary, m_ipAddressAlternate);
if(query != NULL)
{
//
// signal failed queries
//
if(query->IsOld())
{
query->Dispose();
query = NULL;
}
else
{
//
// resume old connection
//
timeSocket = query->GetSocket();
}
}
if(timeSocket == SOCK_SOCKET_ERROR)
{
//
// new connection
//
timeSocket = SOCK_socket(SOCK_AF_INET, SOCK_SOCK_DGRAM, SOCK_IPPROTO_UDP);
if(timeSocket == SOCK_SOCKET_ERROR)
{
sockErr = SOCK_getlasterror();
return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr);
}
SOCK_sockaddr addr;
SOCK_sockaddr_in* dst = (SOCK_sockaddr_in*)&addr;
memset(dst, 0, sizeof(SOCK_sockaddr_in));
dst->sin_family = SOCK_AF_INET;
dst->sin_port = SOCK_htons(123);
dst->sin_addr.S_un.S_addr = SOCK_htonl(m_ipAddressPrimary);
usedServer = m_ipAddressPrimary;
if(SOCK_connect(timeSocket, &addr, sizeof(addr)) == SOCK_SOCKET_ERROR && SOCK_getlasterror() != SOCK_EWOULDBLOCK)
{
if(m_ipAddressAlternate != 0)
{
usedServer = m_ipAddressAlternate;
dst->sin_addr.S_un.S_addr = SOCK_htonl(m_ipAddressAlternate);
if(SOCK_connect(timeSocket, &addr, sizeof(addr)) == SOCK_SOCKET_ERROR && SOCK_getlasterror() != SOCK_EWOULDBLOCK)
{
sockErr = SOCK_getlasterror();
SOCK_close(timeSocket);
return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr);
}
}
else
{
sockErr = SOCK_getlasterror();
SOCK_close(timeSocket);
return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr);
}
}
Initialize();
int sent = SOCK_send(timeSocket, (char*)SNTPData, sizeof(SNTPData), 0);
if(sent != sizeof(SNTPData))
{
sockErr = SOCK_getlasterror();
SOCK_close(timeSocket);
return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr);
}
}
// retry 10 times every time we stop by
INT32 retry = 10;
INT32 bytesToRead = c_SNTPDataLength;
char* buf = (char*)SNTPData;
while(retry-- > 0)
{
int read = SOCK_recv(timeSocket, buf, bytesToRead, 0);
if(read < 0 && (sockErr = SOCK_getlasterror()) != SOCK_EWOULDBLOCK)
{
SOCK_close(timeSocket);
return (sockErr == 0 ? HAL_TIMESERVICE_ERROR : sockErr);
}
else if(read > 0)
{
bytesToRead -= read;
if(bytesToRead <= 0)
{
break;
}
buf += read;
// incase we start receiving data towards the end
// of the retry limit.
retry++;
}
}
// if we could not finish reading, then cache and retry later
// if we read a part of answer, then declare failure
// in the future we could try and cope with this problem
if(bytesToRead == c_SNTPDataLength)
{
//
// if this is a new connection, get a slot
//
if(query == NULL) {
query = GetQuery(usedServer, timeSocket);
}
return HAL_TIMESERVICE_WANT_READ_WRITE;
}
else if(bytesToRead > 0 && bytesToRead < c_SNTPDataLength)
{
if(query != NULL)
query->Dispose();
return HAL_TIMESERVICE_WANT_READ_WRITE;
}
else
{
if(query != NULL)
{
query->Dispose();
query = NULL;
}
else
{
if( timeSocket != SOCK_SOCKET_ERROR )
{
SOCK_close(timeSocket);
timeSocket = SOCK_SOCKET_ERROR;
}
}
}
DestinationTimestamp = Time_GetUtcTime();
if( !IsResponseValid() )
{
if(query != NULL)
{
query->Dispose();
query = NULL;
}
else
{
if( timeSocket != SOCK_SOCKET_ERROR )
{
SOCK_close(timeSocket);
timeSocket = SOCK_SOCKET_ERROR;
}
}
return HAL_TIMESERVICE_ERROR;
}
return HAL_TIMESERVICE_SUCCESS;
}
