Transparent Demo
```language
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>
#include <ctype.h>
#include <stddef.h>
#include <stdio.h>
#include <stdint.h>
#include "osa.h"
#include "UART.h"
#include "sockets.h"
#include "ip_addr.h"
#include "netdb.h"
#include "sys.h"
#include "UART.h"
#include "teldef.h"
#include "sdk_api.h"
#undef printf
#define printf(fmt, args...) do { fatal_printf("[sdk]"fmt, ##args); } while(0)
#define sleep(x) OSATaskSleep((x) * 200)//second
#define msleep(x) OSATaskSleep((x) * 20)//100*msecond
#define _TASK_STACK_SIZE 1024*10
static UINT32 _task_stack[_TASK_STACK_SIZE/sizeof(UINT32)];
#define REMOTEIP "203.156.205.55"
#define REMOTEPORT 3355
#define RECV_MAX_BUFF 2048//3072
extern UART_Port gATUARTIntPortNum;
typedef struct
{
int fd;
char remoteIp[256];
int remotePort;
int socketType; //0:TCP 1:UDP
}socketParam;
typedef struct
{
int fd;
socketParam *sock;
}sockRcvType;
/* BEGIN: Added by v, 2020/3/16 PN:add UART data interface */
// dont't change UartSendMsg_sdk() and get_UartDataSwitch_sdk() function
extern OSMsgQRef MsgUartData_sdk;
extern void set_UartDataSwitch_sdk(BOOL flag);
extern BOOL get_UartDataSwitch_sdk(void);
/* END: Added by v, 2020/3/16 PN:add UART data interface */
static OSTaskRef _task_ref = NULL;
static OSATimerRef _timer_ref = NULL;
static OSFlagRef _flag_ref = NULL;
socketParam sockGroup = {0};
OSMsgQRef MsgqsockRcv;
static int sendcount = 0;
#define TASK_TIMER_CHANGE_FLAG_BIT 0x01
static void _timer_callback(UINT32 tmrId);
static void _task(void *ptr);
int socket_init(void *param);
void sockrcv_thread_init(void);
void sockrcv_thread(void);
static int Msg_tcp_client_recv(int fd,void *sock);
void startCheckNet_thread(void * argv);
void setSockCfn(void);
int socket_write(int sockfd, const void *data, size_t data_sz);
int uarthandle(MsgUartDataParam_sdk * apimsg);
void pre_serverhandle(int len , char *rcvdata);
// Device bootup hook before Phase1Inits.
// If you have some work to be init, you may implete it here.
// ex: you may start your task here. or do some initialize here.
extern void Phase1Inits_enter(void);
// Device bootup hook after Phase1Inits.
// If you have some work to be init, you may implete it here.
// ex: you may start your task here. or do some initialize here.
extern void Phase1Inits_exit(void);
// Device bootup hook before Phase2Inits.
// If you have some work to be init, you may implete it here.
// ex: you may start your task here. or do some initialize here.
extern void Phase2Inits_enter(void);
// Device bootup hook after Phase2Inits.
// If you have some work to be init, you may implete it here.
// ex: you may start your task here. or do some initialize here.
extern void Phase2Inits_exit(void);
void Phase1Inits_enter(void)
{
UART_IND_DISABLE_SET_FLAG(TRUE); //禁止模块的一些状态上报
}
void Phase1Inits_exit(void)
{
}
void Phase2Inits_enter(void)
{
}
void Phase2Inits_exit(void)
{
int ret;
sockrcv_thread_init();
ret = OSATimerCreate(&_timer_ref);
ASSERT(ret == OS_SUCCESS);
ret = OSATaskCreate(&_task_ref, _task_stack, _TASK_STACK_SIZE, 150, "test-task", startCheckNet_thread, NULL);
ASSERT(ret == OS_SUCCESS);
OSATimerStart(_timer_ref, 20 * 200, 20 * 200, _timer_callback, 0); // 10 seconds timer
}
extern int SendATCMDWaitResp(int sATPInd,char *in_str, int timeout, char *ok_fmt, int ok_flag,
char *err_fmt, char *out_str, int resplen);
void startCheckNet_thread(void * argv)
{
MsgUartDataParam_sdk uart_temp;
OS_STATUS osa_status;
int rcv = 0;
char at_str[32]={'\0'};
msleep(1);
sprintf(at_str, "AT^SYSINFO\r");
int ret;
char resp_str[64]={'\0'};
int ready=0;
ret = SendATCMDWaitResp(TEL_AT_CMD_ATP_10, at_str, 3, "^SYSINFO:",1,NULL, resp_str, sizeof(resp_str));
printf("%s: resp_str = %s, ret = %u\n",__FUNCTION__,resp_str,ret);
if(strstr(resp_str, "^SYSINFO: 2,3") != NULL || strstr(resp_str, "^SYSINFO: 2,2") != NULL){
ready = 1;
}
while (!ready){
sleep(1);
ret = SendATCMDWaitResp(TEL_AT_CMD_ATP_10, at_str, 3, "^SYSINFO:",1,NULL, resp_str, sizeof(resp_str));
printf("%s: resp_str = %s, ret = %u\n",__FUNCTION__,resp_str,ret);
printf("len = %u, resp_str[10] = %c, resp_str[12] = %c, resp_str[16] = %c\n",strlen(resp_str),resp_str[10],resp_str[12],resp_str[16]);
if(strstr(resp_str, "^SYSINFO: 2,3") != NULL || strstr(resp_str, "^SYSINFO: 2,2") != NULL){
ready = 1;
}
}
PRO_START:
setSockCfn();
printf("debug> %s -- %u\n",__FUNCTION__,__LINE__);
while (1) {
memset(&uart_temp,0,sizeof(MsgUartDataParam_sdk));
osa_status = OSAMsgQRecv(MsgUartData_sdk, (UINT8 *)&uart_temp, sizeof(MsgUartDataParam_sdk), OSA_SUSPEND);
printf("%s debug osa_status > -- %u\n",__FUNCTION__,osa_status);
if(OS_SUCCESS == osa_status){
if (uart_temp.UArgs){
printf("debug> %s -- %u,fd=%d, len=%u,send=%s\n",__FUNCTION__,__LINE__,sockGroup.fd,uart_temp.len,(char*)(uart_temp.UArgs));
}
//ASSERT(0);
if (0 != uarthandle(&uart_temp))
// if(-1 == rcv)
{
if(sockGroup.fd){
close(sockGroup.fd);
sockGroup.fd = 0;
}
printf(" %s -- %u, restart socket\n", __FUNCTION__,__LINE__);
set_UartDataSwitch_sdk(0);
break;
}
printf(" %s -- %u, send ok\n", __FUNCTION__,__LINE__);
}
}
goto PRO_START;
}
void setSockCfn(void)
{
printf("debug> %s -- %u\n",__FUNCTION__,__LINE__);
sockGroup.remotePort = REMOTEPORT;
memcpy(sockGroup.remoteIp,REMOTEIP,256);
printf("%s --- %d, ip=%s, port=%u\n", __FUNCTION__,__LINE__,sockGroup.remoteIp,sockGroup.remotePort);
while(socket_init(&sockGroup)){sleep(3);}
printf("%s --- %d\n",__FUNCTION__,__LINE__);
}
int socket_init(void *param)
{
struct hostent* host_entry;
int fd;
struct sockaddr_in server;
int res=-1;
OSA_STATUS osaStatus;
sockRcvType rcvType = {0};
int result = 0;
socketParam *sock = (socketParam *)param;
printf("debug> %s -- %u, socketType = %u\n",__FUNCTION__,__LINE__,sock->socketType);
if(sock->fd >0)
{
printf(" %s, create_req, previous socket not closed!\n",__FUNCTION__);
}
host_entry = gethostbyname(sock->remoteIp);
if (host_entry == NULL) {
printf("%s, socket error\n",__FUNCTION__);
return -1;
}
printf("%s[],DNS gethostbyname,Get %s ip %u.%u.%u.%u\n", __FUNCTION__,sock->remoteIp, host_entry->h_addr_list[0][0] & 0xff,
host_entry->h_addr_list[0][1] & 0xff, host_entry->h_addr_list[0][2] & 0xff, host_entry->h_addr_list[0][3] & 0xff);
fd = socket(AF_INET, SOCK_STREAM, 0);
if(fd <=0 ){
printf("%s, socket error\n",__FUNCTION__);
return -1;
}
server.sin_family = AF_INET;
server.sin_port = htons(sock->remotePort);
server.sin_addr.s_addr= * (UINT32 *) host_entry->h_addr_list[0];
//sock-connect
res = connect(fd, (struct sockaddr *)&server, sizeof(server));
if(res <0)
{
printf("%s[%u], connect error\n",__FUNCTION__,__LINE__);
return -1;
}
printf("debug> %s -- %u, fd = %u, sockGroup.fd = %u\n",__FUNCTION__,__LINE__,fd, sock->fd);
sock->fd = fd;
rcvType.fd = sock->fd;
rcvType.sock = sock;
printf("debug> %s -- %u, fd = %u, sockGroup.fd = %u\n",__FUNCTION__,__LINE__,fd, sock->fd);
set_UartDataSwitch_sdk(1);
osaStatus = OSAMsgQSend(MsgqsockRcv, sizeof(sockRcvType), (UINT8*)&rcvType, OSA_NO_SUSPEND);
if(osaStatus == OS_SUCCESS){
result = 0;
}else{
printf("%s: error!send msg failed!osaStatus - %u\n", __func__, osaStatus);
result = -1;
}
return result;
}
void sockrcv_thread_init(void)
{
printf("debug> %s -- %u\n",__FUNCTION__,__LINE__);
OS_STATUS status;
status = OSAMsgQCreate(&MsgUartData_sdk, "MsgUartData_sdk", sizeof(MsgUartDataParam_sdk), 500, OS_FIFO);
DIAG_ASSERT(status == OS_SUCCESS);
status = OSAMsgQCreate(&MsgqsockRcv, "MsgqsockRcv", sizeof(sockRcvType), 500, OS_FIFO);
DIAG_ASSERT(status == OS_SUCCESS);
sys_thread_new("sockrcv_thread", sockrcv_thread, NULL, DEFAULT_THREAD_STACKSIZE*2, 161);
}
void sockrcv_thread(void)
{
sockRcvType sock_temp;
int rcv = 0;
printf("debug> %s -- %u\n",__FUNCTION__,__LINE__);
while (1){
memset(&sock_temp,0,sizeof(sockRcvType));
OSAMsgQRecv(MsgqsockRcv, (UINT8 *)&sock_temp, sizeof(sockRcvType), OSA_SUSPEND);
printf("debug> %s -- %u, fd=%u\n",__FUNCTION__,__LINE__,sock_temp.fd);
rcv = Msg_tcp_client_recv(sock_temp.fd, (void *)&sock_temp);
if(-1 == rcv)
{
printf("debug> %s -- %u, restart socket\n",__FUNCTION__,__LINE__);
if(sockGroup.fd){
close(sockGroup.fd);
sockGroup.fd = 0;
}
}
printf("debug> %s -- %u, sock err.\n",__FUNCTION__,__LINE__);
}
}
static int Msg_tcp_client_recv(int fd,void *sock)
{
char buf[RECV_MAX_BUFF]={0};
int bytes;
fd_set master, read_fds;
struct timeval timeout;
timeout.tv_sec = 10;
timeout.tv_usec = 0;
int status;
sockRcvType *sockparam = (sockRcvType *)sock;
printf("debug> %s -- %u\n",__FUNCTION__,__LINE__);
while(1) {
FD_ZERO(&read_fds);
FD_SET(fd, &read_fds);
status = select(fd + 1, &read_fds, NULL, NULL, &timeout);
if(status < 0){
printf("socket select fail\n");
sleep(1);
continue;
}else if(status == 0){
printf("socket select timeout\n");
sleep(1);
continue;
}
if(sockGroup.fd == 0)
goto PRO_FAIL;
if(FD_ISSET(fd, &read_fds) >= 0){
memset(buf,0,RECV_MAX_BUFF);
bytes = recv(fd, buf, RECV_MAX_BUFF, 0);
if(bytes <= 0)
{
sleep(1);
goto PRO_FAIL;
}
printf("%s[], transport mode,recv data length %u,%s\n",__FUNCTION__, bytes,buf);
char *sendData = (char *)malloc(bytes+1);
ASSERT(sendData != NULL);
memcpy(sendData, buf, bytes);
sendData[bytes] = '\0';
pre_serverhandle(bytes,sendData);
}
}
PRO_FAIL:
//close(fd);
printf(" %s -- %u restart socket\n", __FUNCTION__,__LINE__);
//sockparam->sock->fd = 0;
//free(buf);
//sendIndData(TEL_AT_CMD_ATP_7, "\r\nSOCKET CLOSE\r\n", 16);
set_UartDataSwitch_sdk(0);
return -1;
}
void pre_serverhandle(int len , char *rcvdata){
printf("%s---%d, len=%d",__FUNCTION__,__LINE__,len);
//at_send_data_2uart(rcvdata, len);
send_data_2uart(gATUARTIntPortNum, rcvdata, len);
if(rcvdata)
free(rcvdata);
}
int uarthandle(MsgUartDataParam_sdk * apimsg)
{
int result = 0;
printf("apimsg->UArgs = %s, apimsg->len=%d\n",apimsg->UArgs,apimsg->len);
if(sockGroup.fd)
result = socket_write(sockGroup.fd,(void *)apimsg->UArgs,apimsg->len);
else
result = -1;
printf("%s --- %u, result=%d,sockfd=%u\n",__FUNCTION__,__LINE__,result,sockGroup.fd);
printf("%s --- %d",__FUNCTION__,__LINE__);
if(apimsg->UArgs)
free(apimsg->UArgs);
printf("%s --- %d",__FUNCTION__,__LINE__);
return result;
}
static void _timer_callback(UINT32 tmrId)
{
printf("asr_test _timer_callback\n");
if(get_UartDataSwitch_sdk())
{
printf("%s --- %d",__FUNCTION__,__LINE__);
sendcount++;
MsgUartDataParam_sdk temp = {0};
char *tempbuf = (char *)malloc(100);
memset(tempbuf, 0x0, 100);
sprintf(tempbuf, "sendcount:%d", sendcount);
temp.len = strlen(tempbuf);
temp.UArgs = (UINT8 *)tempbuf;
OSAMsgQSend(MsgUartData_sdk, sizeof(MsgUartDataParam_sdk), (UINT8*)&temp, OSA_NO_SUSPEND);
}
}
int socket_write(int sockfd, const void *data, size_t data_sz)
{
int err;
size_t cur = 0;
while (cur < data_sz) {
do {
err = write(sockfd, (const char *)data + cur, data_sz - cur);
} while (err < 0 && errno == EINTR);
if (err <= 0)
return -1;
cur += err;
}
return 0;
}
```