void SocketCloseForOSEvent(int* fd)
{
int tempFd = *fd;
if ( tempFd < 0 )
return;
*fd = -1;
mico_delete_event_fd(tempFd);
}
void localTcpClient_thread(void *inFd)
{
OSStatus err;
int clientFd = *(int *)inFd;
uint8_t *inDataBuffer = NULL;
int len;
int len_temp;
fd_set readfds;
fd_set writeSet;
struct timeval_t t;
int eventFd = -1;
mico_queue_t queue;
socket_msg_t *msg;
int sent_len, errno;
inDataBuffer = malloc(wlanBufferLen);
require_action(inDataBuffer, exit, err = kNoMemoryErr);
err = socket_queue_create(context, &queue);
require_noerr( err, exit );
eventFd = mico_create_event_fd(queue);
if (eventFd < 0) {
server_log("create event fd error");
goto exit_with_queue;
}
t.tv_sec = 4;
t.tv_usec = 0;
while(1){
FD_ZERO(&readfds);
FD_SET(clientFd, &readfds);
FD_SET(eventFd, &readfds);
select(24, &readfds, NULL, NULL, &t);
/* send UART data */
if (FD_ISSET( eventFd, &readfds )) { // have data and can write
FD_ZERO(&writeSet );
FD_SET(clientFd, &writeSet );
t.tv_usec = 100*1000; // max wait 100ms.
select(1, NULL, &writeSet, NULL, &t);
if((FD_ISSET( clientFd, &writeSet )) &&
(kNoErr == mico_rtos_pop_from_queue( &queue, &msg, 0))) {
sent_len = write(clientFd, msg->data, msg->len);
if (sent_len <= 0) {
len = sizeof(errno);
getsockopt(clientFd, SOL_SOCKET, SO_ERROR, &errno, &len);
socket_msg_free(msg);
server_log("write error, fd: %d, errno %d", clientFd, errno );
if (errno != ENOMEM) {
goto exit_with_queue;
}
} else {
socket_msg_free(msg);
}
}
}
/*Read data from tcp clients and process these data using HA protocol */
if (FD_ISSET(clientFd, &readfds)) {
len = recv(clientFd, inDataBuffer, wlanBufferLen, 0);
len_temp=len;
tcp_date_num+=len;
require_action_quiet(len>0, exit_with_queue, err = kConnectionErr);
// sppWlanCommandProcess(inDataBuffer, &len, clientFd, context);
// MicoUartSend(MFG_TEST, inDataBuffer, len_temp);//wcz wcz_add
}
}
exit_with_queue:
len = sizeof(errno);
getsockopt(clientFd, SOL_SOCKET, SO_ERROR, &errno, &len);
server_log("Exit: Client exit with err = %d, socket errno %d", err, errno);
if (eventFd >= 0) {
mico_delete_event_fd(eventFd);
}
socket_queue_delete(context, &queue);
exit:
SocketClose(&clientFd);
if(inDataBuffer) free(inDataBuffer);
mico_rtos_delete_thread(NULL);
return;
}
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;
fd_set writeSet;
char ipstr[16];
struct timeval_t t;
int remoteTcpClient_fd = -1;
uint8_t *inDataBuffer = NULL;
int eventFd = -1;
mico_queue_t queue;
socket_msg_t *msg;
LinkStatusTypeDef wifi_link;
int sent_len, errno;
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);
err = micoWlanGetLinkStatus( &wifi_link );
require_noerr( err, exit );
if( wifi_link.is_connected == true )
_wifiConnected = true;
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);
client_log("Remote server connected at port: %d, fd: %d", Context->flashContentInRam.appConfig.remoteServerPort,
remoteTcpClient_fd);
err = socket_queue_create(Context, &queue);
require_noerr( err, exit );
eventFd = mico_create_event_fd(queue);
if (eventFd < 0) {
client_log("create event fd error");
socket_queue_delete(Context, &queue);
goto ReConnWithDelay;
}
}else{
FD_ZERO(&readfds);
FD_SET(remoteTcpClient_fd, &readfds);
FD_SET(eventFd, &readfds);
FD_ZERO(&writeSet );
FD_SET(remoteTcpClient_fd, &writeSet );
t.tv_sec = 4;
t.tv_usec = 0;
select(1, &readfds, &writeSet, NULL, &t);
/* send UART data */
if ((FD_ISSET( eventFd, &readfds )) && (FD_ISSET(remoteTcpClient_fd, &writeSet ))) {// have data and can write
if (kNoErr == mico_rtos_pop_from_queue( &queue, &msg, 0)) {
sent_len = write(remoteTcpClient_fd, msg->data, msg->len);
if (sent_len <= 0) {
len = sizeof(errno);
getsockopt(remoteTcpClient_fd, SOL_SOCKET, SO_ERROR, &errno, &len);
socket_msg_free(msg);
if (errno != ENOMEM) {
client_log("write error, fd: %d, errno %d", remoteTcpClient_fd,errno );
goto ReConnWithDelay;
}
} else {
socket_msg_free(msg);
}
}
}
/*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);
goto ReConnWithDelay;
}
sppWlanCommandProcess(inDataBuffer, &len, remoteTcpClient_fd, Context);
}
Continue:
continue;
ReConnWithDelay:
if (eventFd >= 0) {
mico_delete_event_fd(eventFd);
eventFd = -1;
socket_queue_delete(Context, &queue);
}
if(remoteTcpClient_fd != -1){
SocketClose(&remoteTcpClient_fd);
}
sleep(CLOUD_RETRY);
}
}
exit:
if(inDataBuffer) free(inDataBuffer);
client_log("Exit: Remote TCP client exit with err = %d", err);
mico_rtos_delete_thread(NULL);
return;
}
