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(); }