static bool _mPerfRunServer(const char* listen, const struct mArguments* args, const struct PerfOpts* perfOpts) {
SocketSubsystemInit();
Socket server = SocketOpenTCP(7216, NULL);
if (SOCKET_FAILED(server)) {
SocketSubsystemDeinit();
return false;
}
if (SOCKET_FAILED(SocketListen(server, 0))) {
SocketClose(server);
SocketSubsystemDeinit();
return false;
}
_socket = SocketAccept(server, NULL);
if (perfOpts->csv) {
const char* header = "game_code,frames,duration,renderer\n";
SocketSend(_socket, header, strlen(header));
}
char path[PATH_MAX];
while (SocketRecv(_socket, path, sizeof(path)) > 0) {
char* nl = strchr(path, '\n');
if (nl == path) {
break;
}
if (nl) {
nl[0] = '\0';
}
if (!_mPerfRunCore(path, args, perfOpts)) {
break;
}
}
SocketClose(_socket);
SocketClose(server);
SocketSubsystemDeinit();
return true;
}
/**
Performs an HTTP POST operation to the path at the address / port specified. The actual post contents
are found read from a given buffer and the result is returned in the same buffer.
@param address The IP address of the server to post to.
@param port The port on the server you're connecting to. Usually 80 for HTTP.
@param hostname A string specifying the name of the host to connect to. When connecting to a server
that does shared hosting, this will specify who to connect with.
@param path The path on the server to post to.
@param buffer A pointer to the buffer to write from and read back into.
@param buffer_length An integer specifying the number of bytes to write.
@param buffer_size An integer specifying the actual size of the buffer.
@return status.
\par Example
\code
// we'll post a test message to www.makingthings.com/post/path
int addr = IP_ADDRESS( 72, 249, 53, 185); // makingthings.com is 72.249.53.185
int bufLength = 100;
char myBuffer[bufLength];
sprintf( myBuffer, "A test message to post" );
int result = WebClient_Post( addr, 80, "www.makingthings.com", "/post/path",
myBuffer, strlen("A test message to post"), bufLength );
\endcode
*/
int WebClient_Post( int address, int port, char* hostname, char* path, char* buffer, int buffer_length, int buffer_size )
{
char* b = WebClient_InternalBuffer;
int buffer_read = 0;
int wrote = 0;
void* s = Socket( address, port );
if ( s != NULL )
{
int send_len = snprintf( b, WEBCLIENT_INTERNAL_BUFFER_SIZE,
"POST %s HTTP/1.1\r\n%s%s%sContent-Type: text/plain\r\nContent-Length: %d\r\n\r\n",
path,
( hostname != NULL ) ? "Host: " : "",
( hostname != NULL ) ? hostname : "",
( hostname != NULL ) ? "\r\n" : "",
buffer_length );
if ( send_len > WEBCLIENT_INTERNAL_BUFFER_SIZE )
{
SocketClose( s );
return CONTROLLER_ERROR_INSUFFICIENT_RESOURCES;
}
wrote = SocketWrite( s, b, send_len );
if ( wrote == 0 )
{
SocketClose( s );
return CONTROLLER_ERROR_WRITE_FAILED;
}
SocketWrite( s, buffer, buffer_length );
int content_length = 0;
int b_len;
while ( ( b_len = SocketReadLine( s, b, WEBCLIENT_INTERNAL_BUFFER_SIZE ) ) )
{
if ( strncmp( b, "\r\n", 2 ) == 0 )
break;
if ( strncmp( b, "Content-Length", 14 ) == 0 )
content_length = atoi( &b[ 16 ] );
}
if ( content_length > 0 && b_len > 0 )
{
char* bp = buffer;
while ( ( b_len = SocketRead( s, bp, buffer_size - buffer_read ) ) )
{
buffer_read += b_len;
bp += b_len;
if ( buffer_read >= content_length )
break;
}
}
SocketClose( s );
return buffer_read;
}
else
return CONTROLLER_ERROR_BAD_ADDRESS;
}
OSStatus _FTCRespondInComingMessage(int fd, HTTPHeader_t* inHeader, mico_Context_t * const inContext)
{
OSStatus err = kUnknownErr;
const char * value;
size_t valueSize;
easylink_log_trace();
switch(inHeader->statusCode){
case kStatusAccept:
easylink_log("Easylink server accepted!");
err = kNoErr;
goto exit;
break;
case kStatusOK:
easylink_log("Easylink server respond status OK!");
err = HTTPGetHeaderField( inHeader->buf, inHeader->len, "Content-Type", NULL, NULL, &value, &valueSize, NULL );
require_noerr(err, exit);
if( strnicmpx( value, valueSize, kMIMEType_JSON ) == 0 ){
easylink_log("Receive JSON config data!");
err = ConfigIncommingJsonMessage( inHeader->extraDataPtr, inContext);
SocketClose(&fd);
inContext->micoStatus.sys_state = eState_Software_Reset;
require(inContext->micoStatus.sys_state_change_sem, exit);
mico_rtos_set_semaphore(&inContext->micoStatus.sys_state_change_sem);
}else if(strnicmpx( value, valueSize, kMIMEType_MXCHIP_OTA ) == 0){
easylink_log("Receive OTA data!");
mico_rtos_lock_mutex(&inContext->flashContentInRam_mutex);
memset(&inContext->flashContentInRam.bootTable, 0, sizeof(boot_table_t));
inContext->flashContentInRam.bootTable.length = inHeader->contentLength;
inContext->flashContentInRam.bootTable.start_address = UPDATE_START_ADDRESS;
inContext->flashContentInRam.bootTable.type = 'A';
inContext->flashContentInRam.bootTable.upgrade_type = 'U';
inContext->flashContentInRam.micoSystemConfig.easyLinkEnable = false;
MICOUpdateConfiguration(inContext);
mico_rtos_unlock_mutex(&inContext->flashContentInRam_mutex);
SocketClose(&fd);
inContext->micoStatus.sys_state = eState_Software_Reset;
require(inContext->micoStatus.sys_state_change_sem, exit);
mico_rtos_set_semaphore(&inContext->micoStatus.sys_state_change_sem);
}else{
return kUnsupportedDataErr;
}
err = kNoErr;
goto exit;
break;
default:
goto exit;
}
exit:
return err;
}
/*---------------------------------------------------
send SNTP data
---------------------------------------------------*/
void SNTPSend(HWND hwndSNTP, unsigned long serveraddr)
{
struct sockaddr_in serversockaddr;
struct NTP_Packet NTP_Send;
unsigned int sntpver;
HOSTTIME ht;
// request notification of events
if(WSAAsyncSelect(m_socket, hwndSNTP, WSOCK_SELECT, FD_READ)
== SOCKET_ERROR)
{
SocketClose(hwndSNTP, "WSAAsyncSelect() failed");
PostMessage(hwndSNTP, SNTPM_ERROR, 0, 0);
return;
}
// set IP address and port
serversockaddr.sin_family = AF_INET;
serversockaddr.sin_addr.s_addr = serveraddr;
serversockaddr.sin_port = htons((unsigned short)m_port);
memset(serversockaddr.sin_zero,(int)0,sizeof(serversockaddr.sin_zero));
// init a packet
memset(&NTP_Send, 0, sizeof(struct NTP_Packet));
// NTP/SNTP version number = 4
// Mode = 3 (client)
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |LI | VN |Mode | Stratum | Poll | Precision |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
sntpver = GetMyRegLong(m_section, "SNTPVer", 4);
NTP_Send.Control_Byte = (BYTE)(((sntpver&0x7) << 3) | 3);
GetRealSystemTimeAsFileTime((FILETIME*)&ht);
// save tickcount
m_dwTickCountOnSend = timeGetTime();
HostTimeToNTPTime(&ht, &NTP_Send.transmit_timestamp);
// send a packet
if(sendto(m_socket, (const char *)&NTP_Send, sizeof(NTP_Send), 0,
(struct sockaddr *)&serversockaddr,
sizeof(serversockaddr)) == SOCKET_ERROR)
{
SocketClose(hwndSNTP, "sendto() failed");
PostMessage(hwndSNTP, SNTPM_ERROR, 0, 0);
return;
}
SetTimer(hwndSNTP, IDTIMER_MAIN, m_nTimeOut, NULL);
}
void
process_message (void)
{
int bytes, pos = 4;
long scount;
if (!SocketReadable (sock))
return;
GetSocketError (sock);
if ((bytes = DgramReceiveAny (sock, (char *) ibuffer, BUFFERSIZE)) <= 0)
{
if (errno == EAGAIN || errno == EWOULDBLOCK || bytes >= 0)
{
GetSocketError (sock);
return;
}
CQuit ("Can't receive server's message\n");
SocketClose (sock);
}
GETLONG (ibuffer, scount);
csetrrcount (scount);
while (pos + 2 < bytes)
{
int size;
GETSHORT (ibuffer + pos, size);
if (pos + size <= bytes)
{
ctable[ibuffer[pos + 2]].func ((ibuffer + pos + 3), size - 3);
}
pos += size;
}
}
/*---------------------------------------------------
called when the window received WSOCK_GETHOST.
get IP address and send data.
---------------------------------------------------*/
void OnGetHost(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
struct hostent *pHostEnt;
unsigned long serveraddr;
if(g_hGetHost == NULL) return;
// success ?
if(WSAGETASYNCERROR(lParam) != 0)
{
SocketClose(hwnd, "failed to get IP address");
return;
}
// valid handle ?
if(g_hGetHost != (HANDLE)wParam) return;
// get IP address
pHostEnt = (struct hostent *)g_pGetHost;
serveraddr = *((unsigned long *)((pHostEnt->h_addr_list)[0]));
free(g_pGetHost); g_pGetHost = NULL;
g_hGetHost = NULL;
// send data
SNTPSend(hwnd, serveraddr);
}
bool GDBStubListen(struct GDBStub* stub, int port, const struct Address* bindAddress) {
if (!SOCKET_FAILED(stub->socket)) {
GDBStubShutdown(stub);
}
stub->socket = SocketOpenTCP(port, bindAddress);
if (SOCKET_FAILED(stub->socket)) {
mLOG(DEBUGGER, ERROR, "Couldn't open socket");
return false;
}
if (!SocketSetBlocking(stub->socket, false)) {
goto cleanup;
}
int err = SocketListen(stub->socket, 1);
if (err) {
goto cleanup;
}
return true;
cleanup:
mLOG(DEBUGGER, ERROR, "Couldn't listen on port");
SocketClose(stub->socket);
stub->socket = INVALID_SOCKET;
return false;
}
/*------------------------------------------------
called when main window received WM_TIMER
--------------------------------------------------*/
void OnTimerSNTP(HWND hwnd)
{
char msg[80];
wsprintf(msg, "timeout (%04d)", GetTickCount() - m_dwTickCountOnSend);
SocketClose(hwnd, msg);
PostMessage(hwnd, SNTPM_ERROR, 0, 0);
}
int main ()
{
int s = SocketOpen ("vcan0", 1000, 1000);
struct FrameBag bag;
int yes = 0;
gettimeofday (&t1, NULL);
gettimeofday (&t2, NULL);
while ( t2.tv_sec - t1.tv_sec < 1 )
{
if ( SocketRead (s, &bag, 1, 700) > 0
&& bag.Frame.can_id == 0x111
&& bag.Frame.can_dlc == 5
&& bag.Frame.data[0] == 1
&& bag.Frame.data[1] == 2
&& bag.Frame.data[2] == 3
&& bag.Frame.data[3] == 4
&& bag.Frame.data[4] == 5 )
{
yes = 1;
break;
}
gettimeofday (&t2, NULL);
}
SocketClose (s);
if (yes)
printf ("Тесты пройдены.\n");
else
printf ("\n ~~~ !!!!!- ^ТЕСТ ЗАВАЛЕН^ -!!!! ~~~ \n\n");
return yes ? 0 : -1;
}
void GDBStubShutdown(struct GDBStub* stub) {
GDBStubHangup(stub);
if (!SOCKET_FAILED(stub->socket)) {
SocketClose(stub->socket);
stub->socket = INVALID_SOCKET;
}
}
////////////////////////////////////////////////////////////
/// Destroy all users
////////////////////////////////////////////////////////////
bool UsersDestroy()
{
struct UserData * Iterator = UserList.First;
// Remove all users
while (Iterator != NULL)
{
struct UserData * TempUser = Iterator;
Iterator = Iterator->Next;
// Close the socket
MutexLock(&TempUser->MutexData);
SocketClose(&TempUser->Connection.Socket);
MutexUnlock(&TempUser->MutexData);
// Destroy the mutex
MutexDestroy(&TempUser->MutexData);
// Free it
free(TempUser);
TempUser = NULL;
}
return true;
}
/*---------------------------------------------------
send SNTP data
---------------------------------------------------*/
void SNTPSend(HWND hwnd, unsigned long serveraddr)
{
struct sockaddr_in serversockaddr;
struct NTP_Packet NTP_Send;
unsigned int sntpver;
unsigned int Control_Word;
// request notification of events
if(WSAAsyncSelect(g_socket, hwnd, WSOCK_SELECT, FD_READ) == SOCKET_ERROR)
{
SocketClose(hwnd, "WSAAsyncSelect() failed");
return;
}
// set IP address and port
serversockaddr.sin_family = AF_INET;
serversockaddr.sin_addr.s_addr = serveraddr;
serversockaddr.sin_port = htons((unsigned short)g_port);
memset(serversockaddr.sin_zero,(int)0,sizeof(serversockaddr.sin_zero));
// init a packet
memset(&NTP_Send, 0, sizeof(struct NTP_Packet));
// NTP/SNTP version number = 4
// Mode = 3 (client)
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |LI | VN |Mode | Stratum | Poll | Precision |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
sntpver = GetMyRegLong("SNTP", "SNTPVer", 4);
Control_Word = (sntpver << 27) | (3 << 24);
NTP_Send.Control_Word = htonl(Control_Word);
// send a packet
if(sendto(g_socket, (const char *)&NTP_Send, sizeof(NTP_Send), 0,
(struct sockaddr *)&serversockaddr,
sizeof(serversockaddr)) == SOCKET_ERROR)
{
SocketClose(hwnd, "sendto() failed");
return;
}
// save tickcount
dwTickCountOnSend = GetTickCount();
bSendingData = TRUE;
}
static void
quit (unsigned char *message, int size)
{
printf ("Uninitializing:%s\n", (char *) message);
SocketClose (sock);
quited = 1;
exit (0);
}
OSStatus stopEasyLink( mico_Context_t * const inContext)
{
(void)inContext;
micoWlanStopEasyLink();
if(easylinkClient_fd != -1)
SocketClose(&easylinkClient_fd);
return kNoErr;
}
void EClientSocket::eDisconnect()
{
if ( m_fd >= 0 )
// close socket
SocketClose( m_fd);
m_fd = -1;
eDisconnectBase();
}
void GDBStubHangup(struct GDBStub* stub) {
if (!SOCKET_FAILED(stub->connection)) {
SocketClose(stub->connection);
stub->connection = INVALID_SOCKET;
}
if (stub->d.state == DEBUGGER_PAUSED) {
stub->d.state = DEBUGGER_RUNNING;
}
}
/*-------------------------------------------
clean up
---------------------------------------------*/
void EndSNTP(HWND hwndMain)
{
SocketClose(hwndMain, NULL);
if(m_hRASAPI) FreeLibrary(m_hRASAPI);
m_hRASAPI = NULL;
WSACleanup();
}
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;
}
////////////////////////////////////////////////////////////
/// Remove user from the list
////////////////////////////////////////////////////////////
void UserRemove(struct UserData * User)
{
if (UserContains(User))
{
struct UserData * UserPtr;
// Remove from the list
MutexLock(&User->MutexData);
// Update the previous node
if (User->Previous == NULL)
{
MutexLock(&UserList.First->MutexData);
UserPtr = UserList.First;
UserList.First = User->Next;
}
else
{
MutexLock(&User->Previous->Next->MutexData);
UserPtr = User->Previous->Next;
User->Previous->Next = User->Next;
}
MutexUnlock(&UserPtr->MutexData);
// Update the next node
if (User->Next == NULL)
{
MutexLock(&UserList.Last->MutexData);
UserPtr = UserList.Last;
UserList.Last = User->Previous;
}
else
{
MutexLock(&User->Next->Previous->MutexData);
UserPtr = User->Next->Previous;
User->Next->Previous = User->Previous;
}
MutexUnlock(&UserPtr->MutexData);
// Close the socket
SocketClose(&User->Connection.Socket);
// Unlock the mutex
MutexUnlock(&User->MutexData);
// Destroy the mutex
MutexDestroy(&User->MutexData);
// Delete it
free(User);
User = NULL;
}
}
void CSockWrap::Reopen(bool bForceClose)
{
if (ISSOCKHANDLE(m_hSocket) && bForceClose) SocketClose(m_hSocket);
if (!ISSOCKHANDLE(m_hSocket) )
{
m_hSocket=SocketOpen(m_tcpudp);
}
}
void EPosixClientSocket::eDisconnect()
{
if ( m_fd >= 0 )
// close socket
SocketClose( m_fd);
m_fd = -1;
// uninitialize Winsock DLL (only for Windows)
SocketsDestroy();
eDisconnectBase();
}
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 );
}
int ConnKill(TConn *c)
{
/* sanity */
if (!c) {
return FALSE;
}
c->timeout_time = 0;
c->connected = FALSE;
return SocketClose(&c->socket);
}
/*-------------------------------------------
called from main window procedure.
clean up
---------------------------------------------*/
void EndSyncTime(HWND hwnd)
{
hwnd = GetDlgItem(hwnd, 1);
SocketClose(hwnd, NULL);
if(hRASAPI) FreeLibrary(hRASAPI);
hRASAPI = NULL;
WSACleanup();
}
/*---------------------------------------------------
called when the window received WSOCK_SELECT.
receive SNTP data and set time.
---------------------------------------------------*/
void OnReceive(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
struct sockaddr_in serversockaddr;
struct NTP_Packet NTP_Recv;
int sockaddr_Size;
if(g_socket == -1) return;
if(WSAGETSELECTERROR(lParam))
{
SocketClose(hwnd, "failed to receive");
return;
}
if(g_socket != (int)wParam ||
WSAGETSELECTEVENT(lParam) != FD_READ) return;
// receive data
sockaddr_Size = sizeof(serversockaddr);
if(recvfrom(g_socket, (char *)&NTP_Recv, sizeof(NTP_Recv), 0,
(struct sockaddr *)&serversockaddr, &sockaddr_Size) == SOCKET_ERROR)
{
SocketClose(hwnd, "recvfrom() failed");
return;
}
// if Leap Indicator is 3
/*
if(ntohl(NTP_Recv.Control_Word) >> 30 == 3)
{
SocketClose(hwnd, "server is unhealthy");
return;
}
*/
// set system time
SynchronizeSystemTime(ntohl(NTP_Recv.transmit_timestamp_seconds),
ntohl(NTP_Recv.transmit_timestamp_fractions));
// close socket
SocketClose(hwnd, 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;
}
static int _exitServer( const char * msg )
{
_debug( msg ) ;
crypt_buffer_uninit( &_clean_on_exit.ctx ) ;
SocketClose( &_clean_on_exit.s ) ;
memset( _clean_on_exit.buffer,'\0',_clean_on_exit.buffer_length ) ;
free( _clean_on_exit.buffer ) ;
return 1 ;
}
void
csendbuffer ()
{
int result;
if (timeout)
{
timeout--;
if (!timeout)
{
cflushreliable ();
timeout = WAITTIME;
}
}
if (!obufferpos)
return;
PUTLONG ((obuffer), rpos);
falied = 0;
GetSocketError (sock);
/*if (!(rand()%2)) *//*Emulate internet :)))))) */
if ((result = DgramSend (sock, servername, port,
(char *) obuffer, obufferpos + 4)) <= 0)
{
if (errno == EAGAIN || errno == EWOULDBLOCK || result >= 0)
{
GetSocketError (sock);
falied = 1;
if (timeout == WAITTIME)
timeout = 1;
}
else
{
perror ("Can't send message to server\n");
SocketClose (socket_c);
SocketClose (sock);
exit(-1);
}
}
obufferpos = 0;
}
/*---------------------------------------------------
called when the window received WSOCK_SELECT.
receive SNTP data and set time.
---------------------------------------------------*/
void OnReceive(HWND hwndSNTP, WPARAM wParam, LPARAM lParam)
{
struct sockaddr_in serversockaddr;
struct NTP_Packet NTP_Recv;
int sockaddr_Size;
if(m_socket == INVALID_SOCKET) return;
if(WSAGETSELECTERROR(lParam))
{
SocketClose(hwndSNTP, "failed to receive");
return;
}
if(m_socket != (SOCKET)wParam ||
WSAGETSELECTEVENT(lParam) != FD_READ) return;
// receive data
m_dwTickCountOnRecv = timeGetTime();
sockaddr_Size = sizeof(serversockaddr);
if(recvfrom(m_socket, (char *)&NTP_Recv, sizeof(NTP_Recv), 0,
(struct sockaddr *)&serversockaddr, &sockaddr_Size) == SOCKET_ERROR)
{
SocketClose(hwndSNTP, "recvfrom() failed");
return;
}
// if Leap Indicator is 3
if((NTP_Recv.Control_Byte >> 6) == 3)
{
SocketClose(hwndSNTP, "server is unhealthy");
return;
}
// set system time
SynchronizeSystemTime(hwndSNTP, &NTP_Recv);
// close socket
SocketClose(hwndSNTP, NULL);
}
