// DHM - Nerve
void I_ShutdownNetwork( void ) {
if ( globalNetworking && gameLocal != NULL ) {
int curPlayer = DoomLib::GetPlayer();
for (int player = 0; player < gameLocal->Interface.GetNumPlayers(); ++player)
{
DoomLib::SetPlayer( player );
if ( IsValidSocket( ::g->insocket ) ) {
I_Printf( "[-] Shut down insocket for player %d\n", DoomLib::GetPlayer() );
shutdown( ::g->insocket, SHUT_RDWR );
socketclose( ::g->insocket );
}
if ( IsValidSocket( ::g->sendsocket ) ) {
I_Printf( "[-] Shut down sendsocket for player %d\n", DoomLib::GetPlayer() );
shutdown( ::g->sendsocket, SHUT_RDWR );
socketclose( ::g->sendsocket );
}
}
DoomLib::SetPlayer(curPlayer);
globalNetworking = false;
}
}
/**
* @brief Accept an incoming connection on a listening socket.
* @param[in] listener_handle Listening socket.
* @param[out] socket_handle Received socket connection.
* @param[in] name Address of received socket.
* @return Result code.
*/
tSIRF_RESULT SIRF_PAL_NET_Accept( tSIRF_SOCKET listener_handle,
tSIRF_SOCKET *socket_handle,
tSIRF_SOCKADDR *name,
tSIRF_UINT32 security)
{
int result;
int namelen = sizeof(tSIRF_SOCKADDR);
DEBUGCHK( socket_handle );
*socket_handle = SIRF_PAL_NET_INVALID_SOCKET;
if (SIRF_PAL_NET_SECURITY_NONE != security)
{
return SIRF_PAL_NET_SECURITY_NOT_SUPPORTED;
}
do
{
result = accept(listener_handle, (struct sockaddr*)name, (name ? &namelen : NULL) );
} while ( 0 > result && EINTR == errno );
if (IsValidSocket(result))
{
*socket_handle = result;
}
return 0 < result ? SIRF_SUCCESS : SIRF_PAL_NET_ERROR;
} /* SIRF_PAL_NET_Accept() */
//发送函数
bool CServerSocketItem::SendData(WORD wMainCmdID, WORD wSubCmdID, WORD wRountID)
{
//效验状态
if (m_bCloseIng==true) return false;
if (m_wRountID!=wRountID) return false;
if (m_dwRecvPacketCount==0) return false;
if (IsValidSocket()==false) return false;
//寻找发送结构
COverLappedSend * pOverLappedSend=GetSendOverLapped();
ASSERT(pOverLappedSend!=NULL);
if (pOverLappedSend==NULL) return false;
//构造数据
CMD_Head * pHead=(CMD_Head *)pOverLappedSend->m_cbBuffer;
pHead->CommandInfo.wMainCmdID=wMainCmdID;
pHead->CommandInfo.wSubCmdID=wSubCmdID;
WORD wSendSize=EncryptBuffer(pOverLappedSend->m_cbBuffer,sizeof(CMD_Head),sizeof(pOverLappedSend->m_cbBuffer));
pOverLappedSend->m_WSABuffer.len=wSendSize;
//发送数据
if (m_OverLappedSendActive.GetCount()==1)
{
DWORD dwThancferred=0;
int iRetCode=WSASend(m_hSocket,&pOverLappedSend->m_WSABuffer,1,&dwThancferred,0,&pOverLappedSend->m_OverLapped,NULL);
if ((iRetCode==SOCKET_ERROR)&&(WSAGetLastError()!=WSA_IO_PENDING))
{
OnSendCompleted(pOverLappedSend,0L);
return false;
}
}
return true;
}
void homeKitListener_thread(void *inContext)
{
ha_log_trace();
OSStatus err = kUnknownErr;
int j;
Context = inContext;
struct sockaddr_t addr;
int sockaddr_t_size;
fd_set readfds;
char ip_address[16];
int homeKitlistener_fd = -1;
//HKSetPassword (password, strlen(password));
HKSetVerifier(verifier, sizeof(verifier), salt, sizeof(salt));
Context->appStatus.haPairSetupRunning = false;
HKCharacteristicInit(inContext);
/*Establish a TCP server fd that accept the tcp clients connections*/
homeKitlistener_fd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
require_action(IsValidSocket( homeKitlistener_fd ), exit, err = kNoResourcesErr );
addr.s_ip = INADDR_ANY;
addr.s_port = HA_SERVER_PORT;
err = bind(homeKitlistener_fd, &addr, sizeof(addr));
require_noerr( err, exit );
err = listen(homeKitlistener_fd, 0);
require_noerr( err, exit );
ha_log("HomeKit Server established at port: %d, fd: %d", HA_SERVER_PORT, homeKitlistener_fd);
while(1){
FD_ZERO(&readfds);
FD_SET(homeKitlistener_fd, &readfds);
select(1, &readfds, NULL, NULL, NULL);
/*Check tcp connection requests */
if(FD_ISSET(homeKitlistener_fd, &readfds)){
sockaddr_t_size = sizeof(struct sockaddr_t);
j = accept(homeKitlistener_fd, &addr, &sockaddr_t_size);
if (j > 0) {
inet_ntoa(ip_address, addr.s_ip );
ha_log("HomeKit Client %s:%d connected, fd: %d", ip_address, addr.s_port, j);
ha_log("memory>>>>>>>>: %d", mico_memory_info()->free_memory);
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "HomeKit Client", homeKitClient_thread, 0x1000, &j);
if(err != kNoErr){
ha_log("HomeKit Client for fd %d create failed", j);
SocketClose(&j);
}
}
}
}
exit:
ha_log("Exit: HomeKit Server exit with err = %d", err);
mico_rtos_delete_thread(NULL);
return;
}
void localTcpServer_thread(void *inContext)
{
server_log_trace();
OSStatus err = kUnknownErr;
int i, j;
Context = inContext;
struct sockaddr_t addr;
int sockaddr_t_size;
fd_set readfds;
char ip_address[16];
int localTcpListener_fd = -1;
for(i=0; i < MAX_Local_Client_Num; i++)
Context->appStatus.loopBack_PortList[i] = 0;
/*Establish a TCP server fd that accept the tcp clients connections*/
localTcpListener_fd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
require_action(IsValidSocket( localTcpListener_fd ), exit, err = kNoResourcesErr );
addr.s_ip = INADDR_ANY;
addr.s_port = Context->flashContentInRam.appConfig.localServerPort;
err = bind(localTcpListener_fd, &addr, sizeof(addr));
require_noerr( err, exit );
err = listen(localTcpListener_fd, 0);
require_noerr( err, exit );
server_log("Server established at port: %d, fd: %d", Context->flashContentInRam.appConfig.localServerPort, localTcpListener_fd);
FD_ZERO(&readfds);
FD_SET(localTcpListener_fd, &readfds);
while(1){
select(1, &readfds, NULL, NULL, NULL);
/*Check tcp connection requests */
if(FD_ISSET(localTcpListener_fd, &readfds)){
sockaddr_t_size = sizeof(struct sockaddr_t);
j = accept(localTcpListener_fd, &addr, &sockaddr_t_size);
if (j > 0) {
inet_ntoa(ip_address, addr.s_ip );
server_log("Client %s:%d connected, fd: %d", ip_address, addr.s_port, j);
if(kNoErr != mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "Local Clients", localTcpClient_thread, 0x500, &j) )
SocketClose(&j);
}
}
}
exit:
server_log("Exit: Local controller exit with err = %d", err);
mico_rtos_delete_thread(NULL);
return;
}
/* TCP server listener thread */
void tcp_server_thread( void *arg )
{
OSStatus err = kNoErr;
struct sockaddr_t server_addr,client_addr;
socklen_t sockaddr_t_size = sizeof( client_addr );
char client_ip_str[16];
int tcp_listen_fd = -1, client_fd = -1;
fd_set readfds;
tcp_listen_fd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
require_action(IsValidSocket( tcp_listen_fd ), exit, err = kNoResourcesErr );
server_addr.s_ip = INADDR_ANY; /* Accept conenction request on all network interface */
server_addr.s_port = SERVER_PORT;/* Server listen on port: 20000 */
err = bind( tcp_listen_fd, &server_addr, sizeof( server_addr ) );
require_noerr( err, exit );
err = listen( tcp_listen_fd, 0);
require_noerr( err, exit );
while(1)
{
FD_ZERO( &readfds );
FD_SET( tcp_listen_fd, &readfds );
require( select(1, &readfds, NULL, NULL, NULL) >= 0, exit );
if(FD_ISSET(tcp_listen_fd, &readfds)){
client_fd = accept( tcp_listen_fd, &client_addr, &sockaddr_t_size );
if( IsValidSocket( client_fd ) ) {
inet_ntoa( client_ip_str, client_addr.s_ip );
tcp_server_log( "TCP Client %s:%d connected, fd: %d", client_ip_str, client_addr.s_port, client_fd );
if ( kNoErr != mico_rtos_create_thread( NULL, MICO_APPLICATION_PRIORITY, "TCP Clients", tcp_client_thread, 0x800, (void *)client_fd ) )
SocketClose( &client_fd );
}
}
}
exit:
if( err != kNoErr ) tcp_server_log( "Server listerner thread exit with err: %d", err );
SocketClose( &tcp_listen_fd );
mico_rtos_delete_thread(NULL );
}
void fogCloudConfigServer_listener_thread(void *inContext)
{
fogcloud_config_log_trace();
OSStatus err = kUnknownErr;
int j;
Context = inContext;
struct sockaddr_t addr;
int sockaddr_t_size;
fd_set readfds;
char ip_address[16];
int localConfiglistener_fd = -1;
/*Establish a TCP server fd that accept the tcp clients connections*/
localConfiglistener_fd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
require_action(IsValidSocket( localConfiglistener_fd ), exit, err = kNoResourcesErr );
addr.s_ip = INADDR_ANY;
addr.s_port = FOGCLOUD_CONFIG_SERVER_PORT;
err = bind(localConfiglistener_fd, &addr, sizeof(addr));
require_noerr( err, exit );
err = listen(localConfiglistener_fd, 0);
require_noerr( err, exit );
fogcloud_config_log("fogCloud Config Server established at port: %d, fd: %d",
FOGCLOUD_CONFIG_SERVER_PORT, localConfiglistener_fd);
while(1){
if(false == fog_config_server_running){
break;
}
FD_ZERO(&readfds);
FD_SET(localConfiglistener_fd, &readfds);
select(1, &readfds, NULL, NULL, NULL);
/*Check tcp connection requests */
if(FD_ISSET(localConfiglistener_fd, &readfds)){
sockaddr_t_size = sizeof(struct sockaddr_t);
j = accept(localConfiglistener_fd, &addr, &sockaddr_t_size);
if (j > 0) {
inet_ntoa(ip_address, addr.s_ip );
fogcloud_config_log("fogCloud Config Client %s:%d connected, fd: %d", ip_address, addr.s_port, j);
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "fog_client",
fogCloudConfigClient_thread, STACK_SIZE_FOGCLOUD_CONFIG_CLIENT_THREAD, &j);
}
}
}
exit:
fogcloud_config_log("Exit: Fog config Server exit with err = %d", err);
SocketClose(&localConfiglistener_fd);
mico_rtos_delete_thread(NULL);
return;
}
//
// UDPsocket
//
int UDPsocket (void)
{
int s;
// allocate a socket
s = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if ( !IsValidSocket( s ) ) {
int err = GetLastSocketError();
I_Error( "can't create socket, error %d", err );
}
return s;
}
/*create udp socket*/
void udp_unicast_thread(void *arg)
{
UNUSED_PARAMETER(arg);
OSStatus err;
struct sockaddr_t addr;
fd_set readfds;
socklen_t addrLen = sizeof(addr);
int udp_fd = -1 , len;
char ip_address[16];
uint8_t *buf = NULL;
buf = malloc(1024);
require_action(buf, exit, err = kNoMemoryErr);
/*Establish a UDP port to receive any data sent to this port*/
udp_fd = socket( AF_INET, SOCK_DGRM, IPPROTO_UDP );
require_action( IsValidSocket( udp_fd ), exit, err = kNoResourcesErr );
addr.s_ip = INADDR_ANY;/*local ip address*/
addr.s_port = LOCAL_UDP_PORT;/*20000*/
err = bind( udp_fd, &addr, sizeof(addr) );
require_noerr( err, exit );
udp_unicast_log("Open local UDP port %d", LOCAL_UDP_PORT);
while(1)
{
FD_ZERO(&readfds);
FD_SET(udp_fd, &readfds);
require_action( select(udp_fd + 1, &readfds, NULL, NULL, NULL) >= 0, exit, err = kConnectionErr );
/*Read data from udp and send data back */
if (FD_ISSET( udp_fd, &readfds ))
{
len = recvfrom(udp_fd, buf, 1024, 0, &addr, &addrLen);
require_action( len >= 0, exit, err = kConnectionErr );
inet_ntoa( ip_address, addr.s_ip );
udp_unicast_log( "udp recv from %s:%d, len:%d", ip_address,addr.s_port, len );
sendto( udp_fd, buf, len, 0, &addr, sizeof(struct sockaddr_t) );
}
}
exit:
if( err != kNoErr )
udp_unicast_log("UDP thread exit with err: %d", err);
if( buf != NULL ) free(buf);
mico_rtos_delete_thread(NULL);
}
void tcp_server_thread(void *inContext)
{
OSStatus err;
int j;
struct sockaddr_t addr;
int sockaddr_t_size;
fd_set readfds;
char ip_address[16];
int tcp_listener_fd = -1;
/*Establish a TCP server fd that accept the tcp clients connections*/
tcp_listener_fd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
require_action(IsValidSocket( tcp_listener_fd ), exit, err = kNoResourcesErr );
addr.s_ip = INADDR_ANY;
addr.s_port = tcp_server_port;
err = bind(tcp_listener_fd, &addr, sizeof(addr));
require_noerr( err, exit );
err = listen(tcp_listener_fd, 0);
require_noerr( err, exit );
tcp_server_log("Server established at port: %d, fd: %d", addr.s_port, tcp_listener_fd);
while(1){
FD_ZERO(&readfds);
FD_SET(tcp_listener_fd, &readfds);
select(1, &readfds, NULL, NULL, NULL);
/*Check tcp connection requests */
if(FD_ISSET(tcp_listener_fd, &readfds)){
sockaddr_t_size = sizeof(struct sockaddr_t);
j = accept(tcp_listener_fd, &addr, &sockaddr_t_size);
if (j > 0) {
inet_ntoa(ip_address, addr.s_ip );
tcp_server_log("Client %s:%d connected, fd: %d", ip_address, addr.s_port, j);
if(kNoErr != mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "Local Clients", tcp_server_client_thread, 0x800, &j) )
SocketClose(&j);
}
}
}
exit:
tcp_server_log("Exit: Local controller exit with err = %d", err);
mico_rtos_delete_thread(NULL);
return;
}
//绑定对象
DWORD CServerSocketItem::Attach(SOCKET hSocket, DWORD dwClientAddr)
{
//效验数据
ASSERT(dwClientAddr!=0);
ASSERT(m_bRecvIng==false);
ASSERT(IsValidSocket()==false);
ASSERT(hSocket!=INVALID_SOCKET);
//设置变量
m_bNotify=false;
m_bRecvIng=false;
m_bCloseIng=false;
m_hSocket=hSocket;
m_dwClientAddr=dwClientAddr;
m_dwRecvTickCount=GetTickCount();
m_dwConnectTime=(DWORD)time(NULL);
//发送通知
m_pIServerSocketItemSink->OnSocketAcceptEvent(this);
return GetIdentifierID();
}
void tcp_client_thread(void *inContext)
{
OSStatus err;
struct sockaddr_t addr;
struct timeval_t t;
fd_set readfds;
int tcp_fd = -1 , len;
char *buf;
buf = (char*)malloc(BUF_LEN);
require_action(buf, exit, err = kNoMemoryErr);
while(1)
{
if ( tcp_fd == -1 )
{
tcp_fd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
require_action(IsValidSocket( tcp_fd ), exit, err = kNoResourcesErr );
addr.s_ip = inet_addr(tcp_remote_ip);
addr.s_port = tcp_remote_port;
err = connect(tcp_fd, &addr, sizeof(addr));
require_noerr_quiet(err, ReConnWithDelay);
tcp_client_log("Remote server connected at port: %d, fd: %d", addr.s_port, tcp_fd);
}
else
{
/*Check status on erery sockets */
FD_ZERO(&readfds);
FD_SET(tcp_fd, &readfds);
t.tv_sec = 4;
t.tv_usec = 0;
select(1, &readfds, NULL, NULL, &t);
/*recv wlan data using remote client fd*/
if (FD_ISSET( tcp_fd, &readfds ))
{
len = recv(tcp_fd, buf, BUF_LEN, 0);
if( len <= 0) {
tcp_client_log("Remote client closed, fd: %d", tcp_fd);
goto ReConnWithDelay;
}
tcp_client_log("[tcp_rec][%d] = %.*s", len, len, buf);
sendto(tcp_fd, buf, len, 0, &addr, sizeof(struct sockaddr_t));
}
continue;
ReConnWithDelay:
if(tcp_fd != -1){
SocketClose(&tcp_fd);
}
tcp_client_log("Connect to %s failed! Reconnect in 5 sec...", tcp_remote_ip);
sleep( 5 );
}
}
exit:
mico_rtos_delete_thread(NULL);
}
static void ak_discovery_thread(void *arg)
{
UNUSED_PARAMETER( arg );
OSStatus err;
struct sockaddr_t addr;
socklen_t addr_len = sizeof(addr);
struct timeval_t t;
int udp_fd = -1 ;
fd_set readfds;
char *buf = NULL;
ssize_t len = 0;
int ret;
buf = (char*)malloc( 1024 );
require_action( buf, exit, err = kNoMemoryErr );
/*Establish a UDP port to receive any data sent to this port*/
udp_fd = socket( AF_INET, SOCK_DGRM, IPPROTO_UDP );
require_action( IsValidSocket( udp_fd ), exit, err = kNoResourcesErr );
addr.s_ip = INADDR_ANY;
addr.s_port = LOCAL_UDP_PORT;
err = bind(udp_fd, &addr, sizeof(addr));
require_noerr( err, exit );
t.tv_sec = 5;
t.tv_usec = 0;
while(1)
{
//udp_broadcast_log( "broadcast now!" );
FD_ZERO( &readfds );
FD_SET( udp_fd, &readfds );
require_action( select( udp_fd + 1, &readfds, NULL, NULL, &t) >= 0, exit, err = kConnectionErr );
/* recv wlan data, and send back */
if( FD_ISSET( udp_fd, &readfds ) )
{
memset(buf, 0x0, 1024);
len = recvfrom( udp_fd, buf, 1024, 0, &addr, &addr_len);
require_action( len >= 0, exit, err = kConnectionErr );
airkiss_log("Airkiss discover request received, length=%d", len);
ret = airkiss_lan_recv(buf, len, &akconf);
switch (ret){
case AIRKISS_LAN_SSDP_REQ:
len = 1024;
ret = airkiss_lan_pack(AIRKISS_LAN_SSDP_RESP_CMD, _appid, _deviceid, 0, 0, buf, (unsigned short *)&len, &akconf);
require_action( ret == AIRKISS_LAN_PAKE_READY, exit, err = kMalformedErr );
len = sendto( udp_fd, buf, len, 0, &addr, sizeof(addr) );
require_action( len >= 0, exit, err = kConnectionErr );
break;
default:
airkiss_log("Pack is not ssdq req!");
break;
}
}
if(_started == false)
goto exit;
}
exit:
if( err != kNoErr )
airkiss_log("Airkiss discover thread exit with err: %d", err);
if(buf) free(buf);
SocketClose( &udp_fd );
mico_rtos_delete_thread(NULL);
}
void localTcpClient_thread(void *inFd)
{
OSStatus err;
int i;
int indexForPortTable;
int clientFd = *(int *)inFd;
int currentRecved = 0;
int clientLoopBackFd = -1;
uint8_t *inDataBuffer = NULL;
uint8_t *outDataBuffer = NULL;
int len;
struct sockaddr_t addr;
fd_set readfds;
struct timeval_t t;
inDataBuffer = malloc(wlanBufferLen);
require_action(inDataBuffer, exit, err = kNoMemoryErr);
outDataBuffer = malloc(wlanBufferLen);
require_action(outDataBuffer, exit, err = kNoMemoryErr);
for(i=0; i < MAX_Local_Client_Num; i++) {
if( Context->appStatus.loopBack_PortList[i] == 0 ){
Context->appStatus.loopBack_PortList[i] = loopBackPortTable[clientFd];
indexForPortTable = i;
break;
}
}
/*Loopback fd, recv data from other thread */
clientLoopBackFd = socket( AF_INET, SOCK_DGRM, IPPROTO_UDP );
require_action(IsValidSocket( clientLoopBackFd ), exit, err = kNoResourcesErr );
addr.s_ip = IPADDR_LOOPBACK;
addr.s_port = Context->appStatus.loopBack_PortList[indexForPortTable];
err = bind( clientLoopBackFd, &addr, sizeof(addr) );
require_noerr( err, exit );
t.tv_sec = 4;
t.tv_usec = 0;
while(1){
FD_ZERO(&readfds);
FD_SET(clientFd, &readfds);
FD_SET(clientLoopBackFd, &readfds);
select(1, &readfds, NULL, NULL, &t);
/*recv UART data using loopback fd*/
if (FD_ISSET( clientLoopBackFd, &readfds )) {
len = recv( clientLoopBackFd, outDataBuffer, wlanBufferLen, 0 );
SocketSend( clientFd, outDataBuffer, len );
}
/*Read data from tcp clients and process these data using HA protocol */
if (FD_ISSET(clientFd, &readfds)) {
len = recv(clientFd, inDataBuffer+currentRecved, wlanBufferLen-currentRecved, 0);
require_action_quiet(len>0, exit, err = kConnectionErr);
currentRecved += len;
haWlanCommandProcess(inDataBuffer, ¤tRecved, clientFd, Context);
}
}
exit:
server_log("Exit: Client exit with err = %d", err);
Context->appStatus.loopBack_PortList[indexForPortTable] = 0;
if(clientLoopBackFd != -1)
SocketClose(&clientLoopBackFd);
SocketClose(&clientFd);
if(inDataBuffer) free(inDataBuffer);
if(outDataBuffer) free(outDataBuffer);
mico_rtos_delete_thread(NULL);
return;
}
void NTPClient_thread(void *arg)
{
ntp_log_trace();
OSStatus err = kUnknownErr;
UNUSED_PARAMETER( arg );
int Ntp_fd = -1;
fd_set readfds;
struct timeval_t t ;
struct sockaddr_t addr;
socklen_t addrLen;
char ipstr[16];
unsigned int trans_sec, current;
struct NtpPacket outpacket ,inpacket;
struct tm *currentTime;
mico_rtc_time_t time;
LinkStatusTypeDef wifi_link;
int contry = 0;
/* Regisist notifications */
err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)ntpNotify_WifiStatusHandler, NULL );
require_noerr( err, exit );
memset(&outpacket,0x0,sizeof(outpacket));
memset(&inpacket,0x0,sizeof(inpacket));
outpacket.flags = NTP_Flags;
outpacket.stratum = NTP_Stratum;
outpacket.poll = NTP_Poll;
outpacket.precision = NTP_Precision;
outpacket.root_delay = NTP_Root_Delay;
outpacket.root_dispersion = NTP_Root_Dispersion;
err = micoWlanGetLinkStatus( &wifi_link );
require_noerr( err, exit );
if( wifi_link.is_connected == true )
_wifiConnected = true;
if(_wifiConnected == false)
mico_rtos_get_semaphore(&_wifiConnected_sem, MICO_WAIT_FOREVER);
Ntp_fd = socket(AF_INET, SOCK_DGRM, IPPROTO_UDP);
require_action(IsValidSocket( Ntp_fd ), exit, err = kNoResourcesErr );
addr.s_ip = INADDR_ANY;
addr.s_port = 45000;
err = bind(Ntp_fd, &addr, sizeof(addr));
err = kNoErr;
require_noerr(err, exit);
contry=0;
while(1) {
//err = gethostbyname((char *)NTP_Server, (uint8_t *)ipstr, 16);
err = gethostbyname(NTP_Server, (uint8_t *)ipstr, 16);
contry+=1;
if (contry > 4) { require_noerr(err, exit); }
else { require_noerr(err, ReConnWithDelay); }
ntp_log("NTP server address: %s",ipstr);
break;
ReConnWithDelay:
mico_thread_sleep(5);
}
addr.s_ip = inet_addr(ipstr);
addr.s_port = NTP_Port;
t.tv_sec = 5;
t.tv_usec = 0;
while(1) {
require_action(sendto(Ntp_fd, &outpacket,sizeof(outpacket), 0, &addr, sizeof(addr)), exit, err = kNotWritableErr);
FD_ZERO(&readfds);
FD_SET(Ntp_fd, &readfds);
select(1, &readfds, NULL, NULL, &t);
if(FD_ISSET(Ntp_fd, &readfds))
{
require_action(recvfrom(Ntp_fd, &inpacket, sizeof(struct NtpPacket), 0, &addr, &addrLen)>=0, exit, err = kNotReadableErr);
trans_sec = inpacket.trans_ts_sec;
trans_sec = ntohl(trans_sec);
current = trans_sec - UNIX_OFFSET + (ntp_time_zone*3600);
ntp_log("Time Synchronised, %s, tz=%d, from %s\n\r",asctime(gmtime(¤t)),ntp_time_zone, NTP_Server);
//currentTime = localtime(¤t);
currentTime = gmtime(¤t);
time.sec = currentTime->tm_sec;
time.min = currentTime->tm_min ;
time.hr = currentTime->tm_hour;
time.date = currentTime->tm_mday;
time.weekday = currentTime->tm_wday;
time.month = currentTime->tm_mon + 1;
time.year = (currentTime->tm_year + 1900)%100;
MicoRtcSetTime( &time );
goto exit;
}
}
exit:
if( err!=kNoErr )ntp_log("Exit: NTP client exit with err = %d", err);
mico_system_notify_remove( mico_notify_WIFI_STATUS_CHANGED, (void *)ntpNotify_WifiStatusHandler );
if(_wifiConnected_sem) mico_rtos_deinit_semaphore(&_wifiConnected_sem);
SocketClose(&Ntp_fd);
mico_rtos_delete_thread(NULL);
return;
}
void NTPClient_thread(void *inContext)
{
ntp_log_trace();
OSStatus err = kUnknownErr;
mico_Context_t *Context = inContext;
int Ntp_fd = -1;
fd_set readfds;
struct timeval_t t ;
struct sockaddr_t addr;
socklen_t addrLen;
char ipstr[16];
unsigned int trans_sec, current;
struct NtpPacket outpacket ,inpacket;
socklen_t sockLen;
char timeString[40];
/* Regisist notifications */
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)ntpNotify_WifiStatusHandler );
require_noerr( err, exit );
memset(&outpacket,0x0,sizeof(outpacket));
memset(&inpacket,0x0,sizeof(inpacket));
outpacket.flags = NTP_Flags;
outpacket.stratum = NTP_Stratum;
outpacket.poll = NTP_Poll;
outpacket.precision = NTP_Precision;
outpacket.root_delay = NTP_Root_Delay;
outpacket.root_dispersion = NTP_Root_Dispersion;
if(_wifiConnected == false){
mico_rtos_get_semaphore(&_wifiConnected_sem, MICO_WAIT_FOREVER);
mico_thread_msleep(50);
}
Ntp_fd = socket(AF_INET, SOCK_DGRM, IPPROTO_UDP);
require_action(IsValidSocket( Ntp_fd ), exit, err = kNoResourcesErr );
addr.s_ip = INADDR_ANY;
addr.s_port = 45000;
err = bind(Ntp_fd, &addr, sizeof(addr));
err = kNoErr;
require_noerr(err, exit);
while(1) {
err = gethostbyname(NTP_Server, (uint8_t *)ipstr, 16);
require_noerr(err, ReConnWithDelay);
ntp_log("NTP server address: %s",ipstr);
break;
ReConnWithDelay:
mico_thread_sleep(5);
}
addr.s_ip = inet_addr(ipstr);
addr.s_port = NTP_Port;
t.tv_sec = 5;
t.tv_usec = 0;
while(1) {
require_action(sendto(Ntp_fd, &outpacket,sizeof(outpacket), 0, &addr, sizeof(addr)), exit, err = kNotWritableErr);
FD_ZERO(&readfds);
FD_SET(Ntp_fd, &readfds);
select(1, &readfds, NULL, NULL, &t);
if(FD_ISSET(Ntp_fd, &readfds))
{
require_action(recvfrom(Ntp_fd, &inpacket, sizeof(struct NtpPacket), 0, &addr, &addrLen)>=0, exit, err = kNotReadableErr);
trans_sec = inpacket.trans_ts_sec;
trans_sec = ntohl(trans_sec);
current = trans_sec - UNIX_OFFSET;
ntp_log("Time Synchronoused, %s",asctime(localtime(¤t)));
PlatformRTCWrite( localtime(¤t) );
goto exit;
}
}
exit:
if( err!=kNoErr )ntp_log("Exit: NTP client exit with err = %d", err);
MICORemoveNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)ntpNotify_WifiStatusHandler );
if(_wifiConnected_sem) mico_rtos_deinit_semaphore(&_wifiConnected_sem);
SocketClose(&Ntp_fd);
mico_rtos_delete_thread(NULL);
return;
}
bool cServerHandleImpl::Listen(UInt16 a_Port)
{
// Make sure the cNetwork internals are innitialized:
cNetworkSingleton::Get();
// Set up the main socket:
// It should listen on IPv6 with IPv4 fallback, when available; IPv4 when IPv6 is not available.
bool NeedsTwoSockets = false;
int err;
evutil_socket_t MainSock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
if (!IsValidSocket(MainSock))
{
// Failed to create IPv6 socket, create an IPv4 one instead:
err = EVUTIL_SOCKET_ERROR();
LOGD("Failed to create IPv6 MainSock: %d (%s)", err, evutil_socket_error_to_string(err));
MainSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (!IsValidSocket(MainSock))
{
m_ErrorCode = EVUTIL_SOCKET_ERROR();
Printf(m_ErrorMsg, "Cannot create socket for port %d: %s", a_Port, evutil_socket_error_to_string(m_ErrorCode));
return false;
}
// Allow the port to be reused right after the socket closes:
if (evutil_make_listen_socket_reuseable(MainSock) != 0)
{
m_ErrorCode = EVUTIL_SOCKET_ERROR();
Printf(m_ErrorMsg, "Port %d cannot be made reusable: %d (%s). Restarting the server might not work.",
a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode)
);
LOG("%s", m_ErrorMsg.c_str());
}
// Bind to all interfaces:
sockaddr_in name;
memset(&name, 0, sizeof(name));
name.sin_family = AF_INET;
name.sin_port = ntohs(a_Port);
if (bind(MainSock, reinterpret_cast<const sockaddr *>(&name), sizeof(name)) != 0)
{
m_ErrorCode = EVUTIL_SOCKET_ERROR();
Printf(m_ErrorMsg, "Cannot bind IPv4 socket to port %d: %s", a_Port, evutil_socket_error_to_string(m_ErrorCode));
evutil_closesocket(MainSock);
return false;
}
}
else
{
// IPv6 socket created, switch it into "dualstack" mode:
UInt32 Zero = 0;
#ifdef _WIN32
// WinXP doesn't support this feature, so if the setting fails, create another socket later on:
int res = setsockopt(MainSock, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char *>(&Zero), sizeof(Zero));
err = EVUTIL_SOCKET_ERROR();
NeedsTwoSockets = ((res == SOCKET_ERROR) && (err == WSAENOPROTOOPT));
#else
setsockopt(MainSock, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char *>(&Zero), sizeof(Zero));
#endif
// Allow the port to be reused right after the socket closes:
if (evutil_make_listen_socket_reuseable(MainSock) != 0)
{
m_ErrorCode = EVUTIL_SOCKET_ERROR();
Printf(m_ErrorMsg, "Port %d cannot be made reusable: %d (%s). Restarting the server might not work.",
a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode)
);
LOG("%s", m_ErrorMsg.c_str());
}
// Bind to all interfaces:
sockaddr_in6 name;
memset(&name, 0, sizeof(name));
name.sin6_family = AF_INET6;
name.sin6_port = ntohs(a_Port);
if (bind(MainSock, reinterpret_cast<const sockaddr *>(&name), sizeof(name)) != 0)
{
m_ErrorCode = EVUTIL_SOCKET_ERROR();
Printf(m_ErrorMsg, "Cannot bind IPv6 socket to port %d: %d (%s)", a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode));
evutil_closesocket(MainSock);
return false;
}
}
if (evutil_make_socket_nonblocking(MainSock) != 0)
{
m_ErrorCode = EVUTIL_SOCKET_ERROR();
Printf(m_ErrorMsg, "Cannot make socket on port %d non-blocking: %d (%s)", a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode));
evutil_closesocket(MainSock);
return false;
}
if (listen(MainSock, 0) != 0)
{
m_ErrorCode = EVUTIL_SOCKET_ERROR();
Printf(m_ErrorMsg, "Cannot listen on port %d: %d (%s)", a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode));
evutil_closesocket(MainSock);
return false;
}
m_ConnListener = evconnlistener_new(cNetworkSingleton::Get().GetEventBase(), Callback, this, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 0, MainSock);
m_IsListening = true;
if (!NeedsTwoSockets)
{
return true;
}
// If a secondary socket is required (WinXP dual-stack), create it here:
LOGD("Creating a second socket for IPv4");
evutil_socket_t SecondSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (!IsValidSocket(SecondSock))
{
err = EVUTIL_SOCKET_ERROR();
LOGD("socket(AF_INET, ...) failed for secondary socket: %d, %s", err, evutil_socket_error_to_string(err));
return true; // Report as success, the primary socket is working
}
// Allow the port to be reused right after the socket closes:
if (evutil_make_listen_socket_reuseable(SecondSock) != 0)
{
m_ErrorCode = EVUTIL_SOCKET_ERROR();
Printf(m_ErrorMsg, "Port %d cannot be made reusable (second socket): %d (%s). Restarting the server might not work.",
a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode)
);
LOG("%s", m_ErrorMsg.c_str());
}
// Make the secondary socket nonblocking:
if (evutil_make_socket_nonblocking(SecondSock) != 0)
{
err = EVUTIL_SOCKET_ERROR();
LOGD("evutil_make_socket_nonblocking() failed for secondary socket: %d, %s", err, evutil_socket_error_to_string(err));
evutil_closesocket(SecondSock);
return true; // Report as success, the primary socket is working
}
// Bind to all IPv4 interfaces:
sockaddr_in name;
memset(&name, 0, sizeof(name));
name.sin_family = AF_INET;
name.sin_port = ntohs(a_Port);
if (bind(SecondSock, reinterpret_cast<const sockaddr *>(&name), sizeof(name)) != 0)
{
err = EVUTIL_SOCKET_ERROR();
LOGD("Cannot bind secondary socket to port %d: %d (%s)", a_Port, err, evutil_socket_error_to_string(err));
evutil_closesocket(SecondSock);
return true; // Report as success, the primary socket is working
}
if (listen(SecondSock, 0) != 0)
{
err = EVUTIL_SOCKET_ERROR();
LOGD("Cannot listen on secondary socket on port %d: %d (%s)", a_Port, err, evutil_socket_error_to_string(err));
evutil_closesocket(SecondSock);
return true; // Report as success, the primary socket is working
}
m_SecondaryConnListener = evconnlistener_new(cNetworkSingleton::Get().GetEventBase(), Callback, this, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 0, SecondSock);
return true;
}
void remoteTcpClient_thread(void *inContext)
{
client_log_trace();
OSStatus err = kUnknownErr;
int len;
mico_Context_t *Context = inContext;
struct sockaddr_t addr;
fd_set readfds;
char ipstr[16];
struct timeval_t t;
int remoteTcpClient_loopBack_fd = -1;
int remoteTcpClient_fd = -1;
uint8_t *inDataBuffer = NULL;
uint8_t *outDataBuffer = NULL;
mico_rtos_init_semaphore(&_wifiConnected_sem, 1);
/* Regisist notifications */
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)clientNotify_WifiStatusHandler );
require_noerr( err, exit );
inDataBuffer = malloc(wlanBufferLen);
require_action(inDataBuffer, exit, err = kNoMemoryErr);
outDataBuffer = malloc(wlanBufferLen);
require_action(inDataBuffer, exit, err = kNoMemoryErr);
/*Loopback fd, recv data from other thread */
remoteTcpClient_loopBack_fd = socket( AF_INET, SOCK_DGRM, IPPROTO_UDP );
require_action(IsValidSocket( remoteTcpClient_loopBack_fd ), exit, err = kNoResourcesErr );
addr.s_ip = IPADDR_LOOPBACK;
addr.s_port = REMOTE_TCP_CLIENT_LOOPBACK_PORT;
err = bind( remoteTcpClient_loopBack_fd, &addr, sizeof(addr) );
require_noerr( err, exit );
t.tv_sec = 4;
t.tv_usec = 0;
while(1) {
if(remoteTcpClient_fd == -1 ) {
if(_wifiConnected == false){
require_action_quiet(mico_rtos_get_semaphore(&_wifiConnected_sem, 200000) == kNoErr, Continue, err = kTimeoutErr);
}
err = gethostbyname((char *)Context->flashContentInRam.appConfig.remoteServerDomain, (uint8_t *)ipstr, 16);
require_noerr(err, ReConnWithDelay);
remoteTcpClient_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
addr.s_ip = inet_addr(ipstr);
addr.s_port = Context->flashContentInRam.appConfig.remoteServerPort;
err = connect(remoteTcpClient_fd, &addr, sizeof(addr));
require_noerr_quiet(err, ReConnWithDelay);
Context->appStatus.isRemoteConnected = true;
client_log("Remote server connected at port: %d, fd: %d", Context->flashContentInRam.appConfig.remoteServerPort,
remoteTcpClient_fd);
}else{
FD_ZERO(&readfds);
FD_SET(remoteTcpClient_fd, &readfds);
FD_SET(remoteTcpClient_loopBack_fd, &readfds);
select(1, &readfds, NULL, NULL, &t);
/*recv UART data using loopback fd*/
if (FD_ISSET( remoteTcpClient_loopBack_fd, &readfds) ) {
len = recv( remoteTcpClient_loopBack_fd, outDataBuffer, wlanBufferLen, 0 );
SocketSend( remoteTcpClient_fd, outDataBuffer, len );
}
/*recv wlan data using remote client fd*/
if (FD_ISSET(remoteTcpClient_fd, &readfds)) {
len = recv(remoteTcpClient_fd, inDataBuffer, wlanBufferLen, 0);
if(len <= 0) {
client_log("Remote client closed, fd: %d", remoteTcpClient_fd);
Context->appStatus.isRemoteConnected = false;
goto ReConnWithDelay;
}
sppWlanCommandProcess(inDataBuffer, &len, remoteTcpClient_fd, Context);
}
Continue:
continue;
ReConnWithDelay:
if(remoteTcpClient_fd != -1){
SocketClose(&remoteTcpClient_fd);
}
sleep(CLOUD_RETRY);
}
}
exit:
if(inDataBuffer) free(inDataBuffer);
if(outDataBuffer) free(outDataBuffer);
if(remoteTcpClient_loopBack_fd != -1)
SocketClose(&remoteTcpClient_loopBack_fd);
client_log("Exit: Remote TCP client exit with err = %d", err);
mico_rtos_delete_thread(NULL);
return;
}
void mico_mfg_test(mico_Context_t *inContext)
{
network_InitTypeDef_adv_st wNetConfig;
int testCommandFd, scanFd;
uint8_t *buf = NULL;
int recvLength = -1;
fd_set readfds;
struct timeval_t t;
struct sockaddr_t addr;
socklen_t addrLen;
mico_uart_config_t uart_config;
volatile ring_buffer_t rx_buffer;
volatile uint8_t * rx_data;
OSStatus err;
buf = malloc(1500);
require_action(buf, exit, err = kNoMemoryErr);
rx_data = malloc(2048);
require_action(rx_data, exit, err = kNoMemoryErr);
/* Connect to a predefined Wlan */
memset( &wNetConfig, 0x0, sizeof(network_InitTypeDef_adv_st) );
strncpy( (char*)wNetConfig.ap_info.ssid, "William Xu", maxSsidLen );
wNetConfig.ap_info.security = SECURITY_TYPE_AUTO;
memcpy( wNetConfig.key, "mx099555", maxKeyLen );
wNetConfig.key_len = strlen( "mx099555" );
wNetConfig.dhcpMode = DHCP_Client;
wNetConfig.wifi_retry_interval = 100;
micoWlanStartAdv(&wNetConfig);
/* Initialize UART interface */
uart_config.baud_rate = 115200;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, 2048 );
MicoUartInitialize( UART_FOR_APP, &uart_config, (ring_buffer_t *)&rx_buffer );
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "MFG UART Recv", uartRecvMfg_thread, 0x300, (void*)inContext );
/* Initialize UDP interface */
t.tv_sec = 5;
t.tv_usec = 0;
scanFd = socket(AF_INET, SOCK_DGRM, IPPROTO_UDP);
require_action(IsValidSocket( scanFd ), exit, err = kNoResourcesErr );
addr.s_port = 23230;
addr.s_ip = INADDR_ANY;
err = bind(scanFd, &addr, sizeof(addr));
require_noerr(err, exit);
testCommandFd = socket(AF_INET, SOCK_DGRM, IPPROTO_UDP);
require_action(IsValidSocket( testCommandFd ), exit, err = kNoResourcesErr );
addr.s_port = 23231;
addr.s_ip = INADDR_ANY;
err = bind(testCommandFd, &addr, sizeof(addr));
require_noerr(err, exit);
while(1) {
/*Check status on erery sockets on bonjour query */
FD_ZERO( &readfds );
FD_SET( testCommandFd, &readfds );
FD_SET( scanFd, &readfds );
select( 1, &readfds, NULL, NULL, &t );
/* Scan and return MAC address */
if (FD_ISSET(scanFd, &readfds)) {
recvLength = recvfrom(scanFd, buf, 1500, 0, &addr, &addrLen);
sendto(scanFd, inContext->micoStatus.mac, sizeof(inContext->micoStatus.mac), 0, &addr, addrLen);
}
/* Recv UDP data and send to COM */
if (FD_ISSET(testCommandFd, &readfds)) {
recvLength = recvfrom(testCommandFd, buf, 1500, 0, &addr, &addrLen);
MicoUartSend(UART_FOR_APP, buf, recvLength);
}
}
exit:
if(buf) free(buf);
}
/**
* @brief Create a socket of the specified type.
* @param socket_handle[out] Handle to the socket.
* @param socket_type[in] Type of socket to create.
* @return Result code.
*/
tSIRF_RESULT SIRF_PAL_NET_CreateSocket( tSIRF_SOCKET *socket_handle,
tSIRF_UINT32 socket_type )
{
char opt_c;
int result = 0;
DEBUGCHK(socket_handle);
*socket_handle = (tSIRF_SOCKET)socket(AF_INET, SOCK_STREAM, 0);
if (!IsValidSocket(*socket_handle))
{
DEBUGMSG(1,(DEBUGTXT("socket() failed, errno=%d\n"), errno));
*socket_handle = SIRF_PAL_NET_INVALID_SOCKET;
return SIRF_PAL_NET_ERROR;
}
/* Set all socket options here: */
switch (socket_type)
{
case SIRF_PAL_NET_SOCKET_TYPE_BLOCKING:
/* Sockets are blocking by default */
break;
case SIRF_PAL_NET_SOCKET_TYPE_DEFAULT:
{
do
{
result = fcntl( *socket_handle, F_SETFL, O_NONBLOCK );
} while (result!=0 && errno==EINTR);
if (0<result)
{
DEBUGMSG(1,(DEBUGTXT("fcntl() failed, errno=%d\n"), errno));
}
break;
}
default:
return SIRF_PAL_NET_ERROR;
}
opt_c = 1;
result = setsockopt(*socket_handle,
SOL_SOCKET,
SO_REUSEADDR,
(char*)&opt_c,
sizeof(opt_c));
if (0!=result)
{
DEBUGMSG(1,(DEBUGTXT("setsockopt() failed, errno=%d\n"), errno));
SIRF_PAL_NET_CloseSocket(*socket_handle);
return SIRF_PAL_NET_ERROR;
}
opt_c = 1;
result = setsockopt(*socket_handle,
SOL_SOCKET,
SO_DONTLINGER,
(char*)&opt_c,
sizeof(opt_c));
if (0!=result)
{
DEBUGMSG(1,(DEBUGTXT("setsockopt() failed, errno=%d\n"), errno));
SIRF_PAL_NET_CloseSocket(*socket_handle);
return SIRF_PAL_NET_ERROR;
}
opt_c = 1;
result = setsockopt(*socket_handle,
IPPROTO_TCP,
TCP_NODELAY,
(char*)&opt_c,
sizeof(opt_c));
if (0!=result)
{
DEBUGMSG(1,(DEBUGTXT("setsockopt() failed, errno=%d\n"), errno));
SIRF_PAL_NET_CloseSocket(*socket_handle);
return SIRF_PAL_NET_ERROR;
}
return SIRF_SUCCESS;
} /* SIRF_PAL_NET_CreateSocket() */
