int recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, int *fromlen)
{ struct SocketSettings *lss;
StdFileDes *fp = _lx_fhfromfd(s);
int rc;
switch (lss=_lx_get_socket_settings(),lss->lx_network_type) {
case LX_AS225:
rc = SOCK_recvfrom(fp->lx_sock,buf,len,flags, from, fromlen);
break;
case LX_AMITCP:
rc = TCP_RecvFrom(fp->lx_sock,buf,len,flags, from, fromlen);
break;
default:
rc = -1;
break;
}
return rc;
}
void* JASTS_SEARCH_proc(void *para)
{
int ret;
fd_set read_set;
struct timeval timeout;
char dst_ip[20],mine_ip[20];
int dst_port,mine_port;
char buff[1024];
char msg[1024];
Jast_t *jast=NULL;
JastSession_t *session=NULL;
const char *format="JAST/1.0 200 OK\r\n"\
"Location: %s:%d\r\n"\
"\r\n";
pthread_detach(pthread_self());
printf("JAST server enter!!!!!!!!\n");
server_fd=SOCK_udp_init(JAST_DISCOVERY_SPORT,JAST_SOCK_TIMEOUT);
if(server_fd < JAST_RET_FAIL) return NULL;
#ifndef JAST_USE_BROADCAST
if(SOCK_add_membership(server_fd,JAST_MULTICAST_ADDR) < JAST_RET_FAIL) return NULL;
system("route add -net 224.0.0.0 netmask 224.0.0.0 dev eth0");
#endif
do {
FD_ZERO(&read_set);
FD_SET(server_fd,&read_set);
timeout.tv_sec = 0;
timeout.tv_usec = 1000*50;
ret = select(server_fd + 1,&read_set,NULL,NULL,&timeout);
if(ret < 0){
printf("JAST server select failed!\n");
return NULL;
}else if(ret == 0){
// timeout
//printf("select timeout!!\n");
}else{
if(FD_ISSET(server_fd,&read_set) == true){
ret = SOCK_recvfrom(server_fd,dst_ip,&dst_port,buff,sizeof(buff));
if(ret < 0) return NULL;
buff[ret]=0;
VLOG(VLOG_DEBUG,"recv %d ok,recv data:\n%s\n",ret,buff);
if(memcmp(buff,"DISCOVERY * JAST/1.0",strlen("DISCOVERY * JAST/1.0"))==0){
printf("Discovery from %s:%d!\n",dst_ip,dst_port);
// send response
//SOCK_getsockname(server_fd,mine_ip);
SOCK_gethostname(mine_ip);
// init a jast session
if((session=JAST_session_find(dst_ip)) == NULL){
mine_port = g_JastServerPort;
sprintf(msg,format,mine_ip,mine_port);
g_JastServerPort++;
//
printf("add new session\n",dst_ip,dst_port);
jast=JAST_server_init(dst_ip,mine_port);
if(jast == NULL) return NULL;
session=JAST_session_add(dst_ip,jast->sock,jast);
if(session == NULL) return NULL;
}else{
jast = (Jast_t *)session->data.context;
jast->bLogin = false;
//
sprintf(msg,format,jast->ip_me,jast->port_me);
printf("session:%s exist!!!\n",dst_ip);
}
VLOG(VLOG_DEBUG2,"ack:\n%s\n",msg);
ret = SOCK_sendto(server_fd,dst_ip,dst_port,msg,strlen(msg));
if( ret == JAST_RET_FAIL) break;
}
}else{
printf("JAST select:something wrong!\n");
return NULL;
}
}
} while (m_toggle);
printf("JAST server exit!!!!!!!!\n");
return (void *)1;
}
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::SendRecvHelper( CLR_RT_StackFrame& stack, bool fSend, bool fAddress )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_RT_HeapBlock* socket = stack.Arg0().Dereference();
CLR_INT32 handle;
CLR_RT_HeapBlock_Array* arrData = stack.Arg1().DereferenceArray();
CLR_UINT32 offset = stack.Arg2().NumericByRef().u4;
CLR_UINT32 count = stack.Arg3().NumericByRef().u4;
CLR_INT32 flags = stack.Arg4().NumericByRef().s4;
CLR_INT32 timeout_ms = stack.ArgN(5).NumericByRef().s4;
CLR_RT_HeapBlock hbTimeout;
CLR_INT64* timeout;
CLR_UINT8* buf;
bool fRes = true;
CLR_INT32 totReadWrite;
CLR_INT32 ret = 0;
FAULT_ON_NULL(socket);
handle = socket[ FIELD__m_Handle ].NumericByRef().s4;
FAULT_ON_NULL(arrData);
if(offset + count > arrData->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_INDEX_OUT_OF_RANGE);
/* Because we could have been a rescheduled call due to a prior call that would have blocked, we need to see
* if our handle has been shutdown before continuing. */
if (handle == DISPOSED_HANDLE)
{
ThrowError( stack, CLR_E_OBJECT_DISPOSED );
TINYCLR_SET_AND_LEAVE (CLR_E_PROCESS_EXCEPTION);
}
hbTimeout.SetInteger( timeout_ms );
TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout ));
//
// Push "totReadWrite" onto the eval stack.
//
if(stack.m_customState == 1)
{
stack.PushValueI4( 0 );
stack.m_customState = 2;
}
totReadWrite = stack.m_evalStack[ 1 ].NumericByRef().s4;
buf = arrData->GetElement( offset + totReadWrite );
count -= totReadWrite;
while(count > 0)
{
CLR_INT32 bytes = 0;
// first make sure we have data to read or ability to write
while(fRes)
{
ret = Helper__SelectSocket( handle, fSend ? 1 : 0 );
if(ret != 0) break;
// non-blocking - allow other threads to run while we wait for handle activity
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_Socket, fRes ));
}
// timeout expired
if(!fRes)
{
ret = SOCK_SOCKET_ERROR;
ThrowError( stack, SOCK_ETIMEDOUT );
TINYCLR_SET_AND_LEAVE( CLR_E_PROCESS_EXCEPTION );
}
// socket is in the excepted state, so let's bail out
if(SOCK_SOCKET_ERROR == ret)
{
break;
}
if(fAddress)
{
struct SOCK_sockaddr addr;
CLR_UINT32 addrLen = sizeof(addr);
CLR_RT_HeapBlock& blkAddr = stack.ArgN( 6 );
if(fSend)
{
TINYCLR_CHECK_HRESULT(MarshalSockAddress( &addr, addrLen, blkAddr ));
bytes = SOCK_sendto( handle, (const char*)buf, count, flags, &addr, addrLen );
}
else
{
CLR_RT_HeapBlock* pBlkAddr = blkAddr.Dereference();
TINYCLR_CHECK_HRESULT(MarshalSockAddress( &addr, addrLen, *pBlkAddr ));
bytes = SOCK_recvfrom( handle, (char*)buf, count, flags, &addr, (int*)&addrLen );
if(bytes != SOCK_SOCKET_ERROR)
{
TINYCLR_CHECK_HRESULT(MarshalSockAddress( blkAddr, &addr, addrLen ));
}
}
}
else
{
if(fSend)
{
bytes = SOCK_send( handle, (const char*)buf, count, flags );
}
else
{
bytes = SOCK_recv( handle, (char*)buf, count, flags );
}
}
// send/recv/sendto/recvfrom failed
if(bytes == SOCK_SOCKET_ERROR)
{
CLR_INT32 err = SOCK_getlasterror();
if(err != SOCK_EWOULDBLOCK)
{
ret = SOCK_SOCKET_ERROR;
break;
}
continue;
}
// zero recv bytes indicates the handle has been closed.
else if(!fSend && (bytes == 0))
{
break;
}
buf += bytes;
totReadWrite += bytes;
count -= bytes;
stack.m_evalStack[ 1 ].NumericByRef().s4 = totReadWrite;
// receive returns immediately after receiving bytes.
if(!fSend && (totReadWrite > 0))
{
break;
}
}
stack.PopValue(); // totReadWrite
stack.PopValue(); // Timeout
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, ret ));
stack.SetResult_I4( totReadWrite );
TINYCLR_NOCLEANUP();
}
