void noahos_main(int base, void (*entry)(void), int argc, char **argv)
{
__libc_init();
main(argc, argv);
for(;;)
{
TaskTerminate(TaskSelf());
}
}
// **************************************************************************************
void netIOInit( const uint_least8_t *pIpAddr )
{
fdOpenSession( TaskSelf() );
if( !ConStrToIPN((uint_least8_t *)pIpAddr, &(gDataSrcIPN)) ) {
System_abort("FrontEndIf_init: invalid IP address of data source\n");
}
}
////////////////////////////////////////////////////
// 功能: 为音频任务申请并初始化节点
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
static PMEDIA_OBJECT MediaSrvObjCreate(void *media, char *name, int type)
{
PMEDIA_OBJECT obj;
// 输入参数检查
if(!media)
return NULL;
// 申请节点，并初始化
obj = kmalloc(sizeof(MEDIA_OBJECT));
if(obj == NULL)
return NULL;
kmemset(obj, 0x00, sizeof(MEDIA_OBJECT));
ListInit(&obj->Link);
if(MediaSrvGetCallback(type, &obj->Cb) < 0)
{
kdebug(mod_media, PRINT_ERROR, "MediaSrvGetCallback error\n");
kfree(obj);
return NULL;
}
if(((PMEDIA_TASK)media)->ExterdType == 1 && JzSrvUseMplayer() < 0)
{
kdebug(mod_media, PRINT_ERROR, "MediaSrvGetCallback error: mplayer already exist\n");
kfree(obj);
return NULL;
}
// 创建媒体任务
obj->Media = obj->Cb.MediaCreate(media);
if(obj->Media == NULL)
{
kfree(obj);
return NULL;
}
// 保存媒体名称
if(name)
{
obj->MediaInfo = kmalloc(kstrlen(name)+1);
if(obj->MediaInfo)
kstrcpy(obj->MediaInfo, name);
}
// 设置媒体任务
#if defined(STC_EXP)
obj->hTask = sTaskSelf();
#else
obj->hTask = TaskSelf();
#endif
// 返回媒体对象
return obj;
}
/*
* ======== tcpHandler ========
* Creates new Task to handle new TCP connections.
*/
Void tcpHandler(UArg arg0, UArg arg1) {
int sockfd;
int ret;
struct sockaddr_in servAddr;
Error_Block eb;
bool flag = true;
bool internal_flag = true;
int nbytes;
char *buffer;
char msg[] = "Hello from TM4C1294XL Connected Launchpad";
CYASSL* ssl = (CYASSL *) arg0;
fdOpenSession(TaskSelf());
CyaSSL_Init();
CYASSL_CTX* ctx = NULL;
ctx = CyaSSL_CTX_new(CyaTLSv1_2_client_method());
if (ctx == 0) {
System_printf("tcpHandler: CyaSSL_CTX_new error.\n");
exitApp(ctx);
}
if (CyaSSL_CTX_load_verify_buffer(ctx, ca_cert_der_2048,
sizeof(ca_cert_der_2048) / sizeof(char), SSL_FILETYPE_ASN1)
!= SSL_SUCCESS) {
System_printf("tcpHandler: Error loading ca_cert_der_2048"
" please check the cyassl/certs_test.h file.\n");
exitApp(ctx);
}
if (CyaSSL_CTX_use_certificate_buffer(ctx, client_cert_der_2048,
sizeof(client_cert_der_2048) / sizeof(char), SSL_FILETYPE_ASN1)
!= SSL_SUCCESS) {
System_printf("tcpHandler: Error loading client_cert_der_2048,"
" please check the cyassl/certs_test.h file.\n");
exitApp(ctx);
}
if (CyaSSL_CTX_use_PrivateKey_buffer(ctx, client_key_der_2048,
sizeof(client_key_der_2048) / sizeof(char), SSL_FILETYPE_ASN1)
!= SSL_SUCCESS) {
System_printf("tcpHandler: Error loading client_key_der_2048,"
" please check the cyassl/certs_test.h file.\n");
exitApp(ctx);
}
/* Init the Error_Block */
Error_init(&eb);
do {
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
System_printf("tcpHandler: socket failed\n");
Task_sleep(2000);
continue;
}
memset((char *) &servAddr, 0, sizeof(servAddr));
servAddr.sin_family = AF_INET;
servAddr.sin_port = htons(TCPPORT);
inet_aton(IP_ADDR, &servAddr.sin_addr);
ret = connect(sockfd, (struct sockaddr *) &servAddr, sizeof(servAddr));
if (ret < 0) {
fdClose((SOCKET) sockfd);
Task_sleep(2000);
continue;
}
} while (ret != 0);
if ((ssl = CyaSSL_new(ctx)) == NULL) {
System_printf("tcpHandler: CyaSSL_new error.\n");
exitApp(ctx);
}
CyaSSL_set_fd(ssl, sockfd);
ret = CyaSSL_connect(ssl);
/* Delete "TOP_LINE" and "END_LINE" for debugging. */
/* TOP_LINE
System_printf("looked for: %d.\n", SSL_SUCCESS);
System_printf("return was: %d.\n", ret);
int err;
char err_buffer[80];
err = CyaSSL_get_error(ssl, 0);
System_printf("CyaSSL error: %d\n", err);
System_printf("CyaSSL error string: %s\n", CyaSSL_ERR_error_string(err, err_buffer));
END_LINE */
if (ret == SSL_SUCCESS) {
sockfd = CyaSSL_get_fd(ssl);
/* Get a buffer to receive incoming packets. Use the default heap. */
buffer = Memory_alloc(NULL, TCPPACKETSIZE, 0, &eb);
if (buffer == NULL) {
System_printf("tcpWorker: failed to alloc memory\n");
exitApp(ctx);
}
/* Say hello to the server */
while (flag) {
if (CyaSSL_write(ssl, msg, strlen(msg)) != strlen(msg)) {
ret = CyaSSL_get_error(ssl, 0);
System_printf("Write error: %i.\n", ret);
}
while (internal_flag) {
nbytes = CyaSSL_read(ssl, (char *) buffer, TCPPACKETSIZE);
if (nbytes > 0) {
internal_flag = false;
}
}
/* success */
System_printf("Heard: \"%s\".\n", buffer);
CyaSSL_free(ssl);
fdClose((SOCKET) sockfd);
flag = false;
}
/* Free the buffer back to the heap */
Memory_free(NULL, buffer, TCPPACKETSIZE);
/*
* Since deleteTerminatedTasks is set in the cfg file,
* the Task will be deleted when the idle task runs.
*/
exitApp(ctx);
} else {
CyaSSL_free(ssl);
fdClose((SOCKET) sockfd);
System_printf("CyaSSL_connect failed.\n");
fdCloseSession(TaskSelf());
exitApp(ctx);
}
}
void netIOClose()
{
fdCloseSession( TaskSelf() );
}
/**
* \function SendLiveStreamDataPort
* \brief 使用TCP/IP协议实现H.264子码流的网络传输
* \ 默认作为服务器端，Port = 61001
* \note 除了TCP/IP的传输方式外，智能相机系统还支持H.264视频流的RTSP方式传输，其传输过程已被封装在系统内部，默认TCP/IP传输的优先级高于RTSP传输的优先级
**/
void SendLiveStreamDataPort_Another()
{
SOCKET sockThis, sockAccept;
struct sockaddr_in addrThis, addrAccept;
int nAddrLen;
int nVideoWidth = 1600, nVideoHeight = 1216;
int i;
int isValidLink = 1;
fdOpenSession( TaskSelf() );
do
{
g_pBuffsLiveStream_Another = MEM_alloc(extHeap, g_nMaxBuffsNumLiveStream_Another*sizeof(DataPoolItem), 256);
}while(g_pBuffsLiveStream_Another == 0);
memset(g_pBuffsLiveStream_Another, 0, g_nMaxBuffsNumLiveStream_Another*sizeof(DataPoolItem));
for (i = 0; i < g_nMaxBuffsNumLiveStream_Another; i++)
{
do
{
g_pBuffsLiveStream_Another[i].pBuf = MEM_alloc(extHeap, g_nMaxFrameSizeLiveStream_Another, 256);
}while(g_pBuffsLiveStream_Another[i].pBuf == 0);
}
sockThis = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if( sockThis == INVALID_SOCKET )
{
Roseek_Reset();//如果创建侦听对象失败，重启相机
}
bzero( &addrAccept, sizeof(addrAccept) );
nAddrLen = sizeof(addrAccept);
bzero( &addrThis, sizeof(addrThis) );
addrThis.sin_len = sizeof( addrThis );
addrThis.sin_family = AF_INET;
addrThis.sin_addr.s_addr = INADDR_ANY;
addrThis.sin_port = htons( 61001 );
//sockFconListen绑定
if ( bind( sockThis, (PSA) &addrThis, sizeof(addrThis) ) < 0 )
{
Roseek_Reset();//如果绑定失败，重启相机
}
//sockFconListen开始监听，同一时刻仅支持一个连接
if ( listen( sockThis, 1) < 0 ){
Roseek_Reset();//如果侦听失败，重启相机
}
//迭代循环
while( 1 )
{
sockAccept = INVALID_SOCKET;
do
{
sockAccept = accept( sockThis, (PSA)&addrAccept, &nAddrLen );
if( sockAccept == INVALID_SOCKET)
{
break;
}
sock_setTimeout(sockAccept, SO_RCVTIMEO, 3000);
sock_setTimeout(sockAccept, SO_SNDTIMEO, 3000);
g_bIsLiveStreamClientConnect_Another = TRUE;
g_IsUsedByTCPSend_Another = TRUE;
if (SafeSend(sockAccept, (Uint8*)&nVideoWidth, 4) != 4)
{
break;
}
if (SafeSend(sockAccept, (Uint8*)&nVideoHeight, 4) != 4)
{
break;
}
while( 1 )
{
if(isEncStop && g_nNumHasDataLSBuffs_Another <= 1)
{
Roseek_Start_Enc();
isEncStop = 0;
LOG_printf( &trace, "Roseek_Start_Enc!!!");
}
//等待信号灯同步
isValidLink = 1;
while (!SEM_pend( &sem_LiveStreamDataReady_Another, 5000))
{
int nRet;
struct timeval tvTimeOut;
fd_set fsVal;
FD_ZERO(&fsVal);
FD_SET(sockAccept, &fsVal);
tvTimeOut.tv_sec = 0;
tvTimeOut.tv_usec = 100;
nRet = fdSelect(0, 0, &fsVal, 0, &tvTimeOut);
if (0 == nRet || -1 == nRet)
{
isValidLink = 0;
break;
}
}
//SEM_pend( &sem_LiveStreamDataReady_Another, SYS_FOREVER );
if (!isValidLink)
{
break;
}
//判断上传哪个缓冲区内容
if (g_nNumHasDataLSBuffs_Another <= 0)
{
continue;
}
if (!isEncStop && (g_nNumHasDataLSBuffs_Another >= (g_nMaxBuffsNumLiveStream_Another-3)))
{
Roseek_Stop_Enc();
isEncStop = 1;
LOG_printf( &trace, "Roseek_Stop_Enc!!!");
}
if (g_nNumHasDataLSBuffs_Another >= (g_nMaxBuffsNumLiveStream_Another-1) && (g_pBuffsLiveStream_Another[g_nReadPosLSBuffs_Another].pBuf[8]&0x1F) != 7)
{
LOG_printf( &trace, "this frame not send!!!");
}
else
{
nDataLen = *(Uint32*)(g_pBuffsLiveStream_Another[g_nReadPosLSBuffs_Another].pBuf) + 4;
if((nSendlen = SafeSend( sockAccept, g_pBuffsLiveStream_Another[g_nReadPosLSBuffs_Another].pBuf, nDataLen)) != nDataLen)
{
LOG_printf( &trace, "send error!!!");
break;
}
}
g_nReadPosLSBuffs_Another = (++g_nReadPosLSBuffs_Another)%g_nMaxBuffsNumLiveStream_Another;
g_nNumHasDataLSBuffs_Another--;
}
}while(0);
if (sockAccept != INVALID_SOCKET)
{
fdClose(sockAccept);
sockAccept = INVALID_SOCKET;
}
g_IsUsedByTCPSend_Another = FALSE;
g_bIsLiveStreamClientConnect_Another = FALSE;
SEM_reset( &sem_LiveStreamDataReady_Another, 0 );
g_nNumHasDataLSBuffs_Another = 0;
g_nReadPosLSBuffs_Another = 0;
g_nWritePosLSBuffs_Another = 0;
if(isEncStop)
{
Roseek_Start_Enc();
isEncStop = 0;
LOG_printf( &trace, "Roseek_Start_Enc!!!");
}
}//迭代循环
}
THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
{
SOCKET_T sockfd = 0;
CYASSL_METHOD* method = 0;
CYASSL_CTX* ctx = 0;
int doDTLS = 0;
int doPSK = 0;
int outCreated = 0;
int shutDown = 0;
int useAnyAddr = 0;
word16 port = yasslPort;
int argc = ((func_args*)args)->argc;
char** argv = ((func_args*)args)->argv;
#ifdef ECHO_OUT
FILE* fout = stdout;
if (argc >= 2) {
fout = fopen(argv[1], "w");
outCreated = 1;
}
if (!fout) err_sys("can't open output file");
#endif
(void)outCreated;
(void)argc;
(void)argv;
((func_args*)args)->return_code = -1; /* error state */
#ifdef CYASSL_DTLS
doDTLS = 1;
#endif
#ifdef CYASSL_LEANPSK
doPSK = 1;
#endif
#if defined(NO_RSA) && !defined(HAVE_ECC)
doPSK = 1;
#endif
#if defined(NO_MAIN_DRIVER) && !defined(USE_WINDOWS_API) && \
!defined(CYASSL_SNIFFER) && !defined(CYASSL_MDK_SHELL) && \
!defined(TIRTOS)
port = 0;
#endif
#if defined(USE_ANY_ADDR)
useAnyAddr = 1;
#endif
#ifdef TIRTOS
fdOpenSession(TaskSelf());
#endif
tcp_listen(&sockfd, &port, useAnyAddr, doDTLS);
#if defined(CYASSL_DTLS)
method = CyaDTLSv1_server_method();
#elif !defined(NO_TLS)
method = CyaSSLv23_server_method();
#else
method = CyaSSLv3_server_method();
#endif
ctx = CyaSSL_CTX_new(method);
/* CyaSSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF); */
#if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER)
CyaSSL_CTX_set_default_passwd_cb(ctx, PasswordCallBack);
#endif
#ifndef NO_FILESYSTEM
if (doPSK == 0) {
#ifdef HAVE_NTRU
/* ntru */
if (CyaSSL_CTX_use_certificate_file(ctx, ntruCert, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
err_sys("can't load ntru cert file, "
"Please run from CyaSSL home dir");
if (CyaSSL_CTX_use_NTRUPrivateKey_file(ctx, ntruKey)
!= SSL_SUCCESS)
err_sys("can't load ntru key file, "
"Please run from CyaSSL home dir");
#elif defined(HAVE_ECC)
/* ecc */
if (CyaSSL_CTX_use_certificate_file(ctx, eccCert, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
err_sys("can't load server cert file, "
"Please run from CyaSSL home dir");
if (CyaSSL_CTX_use_PrivateKey_file(ctx, eccKey, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
err_sys("can't load server key file, "
"Please run from CyaSSL home dir");
#elif defined(NO_CERTS)
/* do nothing, just don't load cert files */
#else
/* normal */
if (CyaSSL_CTX_use_certificate_file(ctx, svrCert, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
err_sys("can't load server cert file, "
"Please run from CyaSSL home dir");
if (CyaSSL_CTX_use_PrivateKey_file(ctx, svrKey, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
err_sys("can't load server key file, "
"Please run from CyaSSL home dir");
#endif
} /* doPSK */
#elif !defined(NO_CERTS)
if (!doPSK) {
load_buffer(ctx, svrCert, CYASSL_CERT);
load_buffer(ctx, svrKey, CYASSL_KEY);
}
#endif
#if defined(CYASSL_SNIFFER) && !defined(HAVE_NTRU) && !defined(HAVE_ECC)
/* don't use EDH, can't sniff tmp keys */
CyaSSL_CTX_set_cipher_list(ctx, "AES256-SHA");
#endif
if (doPSK) {
#ifndef NO_PSK
const char *defaultCipherList;
CyaSSL_CTX_set_psk_server_callback(ctx, my_psk_server_cb);
CyaSSL_CTX_use_psk_identity_hint(ctx, "cyassl server");
#ifdef HAVE_NULL_CIPHER
defaultCipherList = "PSK-NULL-SHA256";
#else
defaultCipherList = "PSK-AES128-CBC-SHA256";
#endif
if (CyaSSL_CTX_set_cipher_list(ctx, defaultCipherList) != SSL_SUCCESS)
err_sys("server can't set cipher list 2");
#endif
}
SignalReady(args, port);
while (!shutDown) {
CYASSL* ssl = 0;
char command[SVR_COMMAND_SIZE+1];
int echoSz = 0;
int clientfd;
int firstRead = 1;
int gotFirstG = 0;
#ifndef CYASSL_DTLS
SOCKADDR_IN_T client;
socklen_t client_len = sizeof(client);
clientfd = accept(sockfd, (struct sockaddr*)&client,
(ACCEPT_THIRD_T)&client_len);
#else
clientfd = udp_read_connect(sockfd);
#endif
if (clientfd == -1) err_sys("tcp accept failed");
ssl = CyaSSL_new(ctx);
if (ssl == NULL) err_sys("SSL_new failed");
CyaSSL_set_fd(ssl, clientfd);
#if !defined(NO_FILESYSTEM) && !defined(NO_DH)
CyaSSL_SetTmpDH_file(ssl, dhParam, SSL_FILETYPE_PEM);
#elif !defined(NO_DH)
SetDH(ssl); /* will repick suites with DHE, higher than PSK */
#endif
if (CyaSSL_accept(ssl) != SSL_SUCCESS) {
printf("SSL_accept failed\n");
CyaSSL_free(ssl);
CloseSocket(clientfd);
continue;
}
#if defined(PEER_INFO)
showPeer(ssl);
#endif
while ( (echoSz = CyaSSL_read(ssl, command, sizeof(command)-1)) > 0) {
if (firstRead == 1) {
firstRead = 0; /* browser may send 1 byte 'G' to start */
if (echoSz == 1 && command[0] == 'G') {
gotFirstG = 1;
continue;
}
}
else if (gotFirstG == 1 && strncmp(command, "ET /", 4) == 0) {
strncpy(command, "GET", 4);
/* fall through to normal GET */
}
if ( strncmp(command, "quit", 4) == 0) {
printf("client sent quit command: shutting down!\n");
shutDown = 1;
break;
}
if ( strncmp(command, "break", 5) == 0) {
printf("client sent break command: closing session!\n");
break;
}
#ifdef SESSION_STATS
if ( strncmp(command, "printstats", 10) == 0) {
PrintSessionStats();
break;
}
#endif
if ( strncmp(command, "GET", 3) == 0) {
char type[] = "HTTP/1.0 200 ok\r\nContent-type:"
" text/html\r\n\r\n";
char header[] = "<html><body BGCOLOR=\"#ffffff\">\n<pre>\n";
char body[] = "greetings from CyaSSL\n";
char footer[] = "</body></html>\r\n\r\n";
strncpy(command, type, sizeof(type));
echoSz = sizeof(type) - 1;
strncpy(&command[echoSz], header, sizeof(header));
echoSz += (int)sizeof(header) - 1;
strncpy(&command[echoSz], body, sizeof(body));
echoSz += (int)sizeof(body) - 1;
strncpy(&command[echoSz], footer, sizeof(footer));
echoSz += (int)sizeof(footer);
if (CyaSSL_write(ssl, command, echoSz) != echoSz)
err_sys("SSL_write failed");
break;
}
command[echoSz] = 0;
#ifdef ECHO_OUT
fputs(command, fout);
#endif
if (CyaSSL_write(ssl, command, echoSz) != echoSz)
err_sys("SSL_write failed");
}
#ifndef CYASSL_DTLS
CyaSSL_shutdown(ssl);
#endif
CyaSSL_free(ssl);
CloseSocket(clientfd);
#ifdef CYASSL_DTLS
tcp_listen(&sockfd, &port, useAnyAddr, doDTLS);
SignalReady(args, port);
#endif
}
CloseSocket(sockfd);
CyaSSL_CTX_free(ctx);
#ifdef ECHO_OUT
if (outCreated)
fclose(fout);
#endif
((func_args*)args)->return_code = 0;
#ifdef TIRTOS
fdCloseSession(TaskSelf());
#endif
#ifndef TIRTOS
return 0;
#endif
}
/**
* \function SendFconDataPort
* \brief 使用TCP/IP协议实现FconMode的JPEG图像发送
* \ 默认作为服务器端，Port = 55000
* \
**/
void SendFconDataPort()
{
SOCKET sockFconListen, sockFconSvr;
int size,i,cnt;
Uint16 ui16Reply = 0;
Bool bClosed = FALSE;
struct sockaddr_in addr;
Bool bBreak=FALSE;
static Uint8 ui8JpgBufIndex=0;
Uint8 ui8tmp;
//为当前任务配置运行环境
fdOpenSession( TaskSelf() );
//创建侦听socket对象
sockFconListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if( sockFconListen == INVALID_SOCKET ){
Roseek_Reset();//如果创建侦听对象失败，重启相机
}
bzero( &addr, sizeof(struct sockaddr_in) );
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_len = sizeof( addr );
addr.sin_port = htons( 55000 );
//sockFconListen绑定
if ( bind( sockFconListen, (PSA) &addr, sizeof(addr) ) < 0 ){
Roseek_Reset();//如果绑定失败，重启相机
}
//sockFconListen开始监听，同一时刻仅支持一个连接
if ( listen( sockFconListen, 1) < 0 ){
Roseek_Reset();//如果侦听失败，重启相机
}
//迭代循环
while( 1 ){
size = sizeof( addr );
sockFconSvr = accept( sockFconListen, (PSA)&addr, &size );
if( sockFconSvr == INVALID_SOCKET){
//如果接受连接出错则关闭接受到的连接对象，重新尝试
fdClose(sockFconSvr);
continue;
}
g_bIsFconClientConnect = TRUE; //网络线程准备完毕
//向上位机发送MJPG图像
while( !bClosed ){
//等待信号灯同步
SEM_pend( &sem_ConDataReady, SYS_FOREVER);
//判断上传哪个缓冲区内容
bBreak = FALSE;
if(ui8JpgBufIndex==1){
ui8tmp=0;
}
else{
ui8tmp=ui8JpgBufIndex+1;
}
for( i=ui8tmp; i<ui8tmp+2; i++ ){
if( i>1 ){
if( g_JpgEncBufStruct.bJpgImgBuf_Lock[i-2] ){
ui8JpgBufIndex = i-2;
bBreak = TRUE;
break;
}
}
else{//i<=5
if( g_JpgEncBufStruct.bJpgImgBuf_Lock[i] ){
ui8JpgBufIndex = i;
bBreak = TRUE;
break;
}
}
}
if( !bBreak ){
continue;
}
if( send( sockFconSvr, g_JpgEncBufStruct.pui8JpgImgBuf[ui8JpgBufIndex], *(Uint32*)g_JpgEncBufStruct.pui8JpgImgBuf[ui8JpgBufIndex] + 4, 0 ) < 0 ){
break;
}
g_JpgEncBufStruct.bJpgImgBuf_Lock[ui8JpgBufIndex] = FALSE;
//接受回应判断是否退出发送循环，若接受到0xffff终止发送循环，否则继续发送数据
//启动后第一次执行后收到了0xffff(测试时）
i = 0;
while( i < 2 ){
cnt = recv( sockFconSvr, (char*)&ui16Reply, 2-i, 0 );
if( cnt <= 0 ){
bClosed = TRUE;
break;
}
i += cnt;
}
if( ui16Reply==0xffff ){
bClosed = TRUE;
}
}
//控制标志复位，关闭发送服务器连接，重回迭代循环等待新连接
bClosed = FALSE;
ui16Reply = 0x0000;
fdClose(sockFconSvr);
g_bIsFconClientConnect = FALSE;
g_JpgEncBufStruct.bJpgImgBuf_Lock[0] = FALSE;
g_JpgEncBufStruct.bJpgImgBuf_Lock[1] = FALSE;
SEM_reset( &sem_ConDataReady, 0 );
}//迭代循环
}
static int execute_test_case(int svr_argc, char** svr_argv,
int cli_argc, char** cli_argv,
int addNoVerify, int addNonBlocking)
{
#ifdef TIRTOS
func_args cliArgs = {0};
func_args svrArgs = {0};
cliArgs.argc = cli_argc;
cliArgs.argv = cli_argv;
svrArgs.argc = svr_argc;
svrArgs.argv = svr_argv;
#else
func_args cliArgs = {cli_argc, cli_argv, 0, NULL, NULL};
func_args svrArgs = {svr_argc, svr_argv, 0, NULL, NULL};
#endif
tcp_ready ready;
THREAD_TYPE serverThread;
char commandLine[MAX_COMMAND_SZ];
char cipherSuite[MAX_SUITE_SZ+1];
int i;
size_t added = 0;
static int tests = 1;
commandLine[0] = '\0';
for (i = 0; i < svr_argc; i++) {
added += strlen(svr_argv[i]) + 2;
if (added >= MAX_COMMAND_SZ) {
printf("server command line too long\n");
break;
}
strcat(commandLine, svr_argv[i]);
strcat(commandLine, flagSep);
}
if (IsValidCipherSuite(commandLine, cipherSuite) == 0) {
#ifdef DEBUG_SUITE_TESTS
printf("cipher suite %s not supported in build\n", cipherSuite);
#endif
return NOT_BUILT_IN;
}
#ifdef NO_OLD_TLS
if (IsOldTlsVersion(commandLine) == 1) {
#ifdef DEBUG_SUITE_TESTS
printf("protocol version on line %s is too old\n", commandLine);
#endif
return VERSION_TOO_OLD;
}
#endif
if (addNoVerify) {
printf("repeating test with client cert request off\n");
added += 4; /* -d plus space plus terminator */
if (added >= MAX_COMMAND_SZ || svr_argc >= MAX_ARGS)
printf("server command line too long\n");
else {
svr_argv[svr_argc++] = noVerifyFlag;
svrArgs.argc = svr_argc;
strcat(commandLine, noVerifyFlag);
strcat(commandLine, flagSep);
}
}
if (addNonBlocking) {
printf("repeating test with non blocking on\n");
added += 4; /* -N plus terminator */
if (added >= MAX_COMMAND_SZ || svr_argc >= MAX_ARGS)
printf("server command line too long\n");
else {
svr_argv[svr_argc++] = nonblockFlag;
svrArgs.argc = svr_argc;
strcat(commandLine, nonblockFlag);
strcat(commandLine, flagSep);
}
}
#if !defined(USE_WINDOWS_API) && !defined(TIRTOS)
/* add port 0 */
if (svr_argc + 2 > MAX_ARGS)
printf("cannot add the magic port number flag to server\n");
else
{
svr_argv[svr_argc++] = portFlag;
svr_argv[svr_argc++] = svrPort;
svrArgs.argc = svr_argc;
}
#endif
printf("trying server command line[%d]: %s\n", tests, commandLine);
commandLine[0] = '\0';
added = 0;
for (i = 0; i < cli_argc; i++) {
added += strlen(cli_argv[i]) + 2;
if (added >= MAX_COMMAND_SZ) {
printf("client command line too long\n");
break;
}
strcat(commandLine, cli_argv[i]);
strcat(commandLine, flagSep);
}
if (addNonBlocking) {
added += 4; /* -N plus space plus terminator */
if (added >= MAX_COMMAND_SZ)
printf("client command line too long\n");
else {
cli_argv[cli_argc++] = nonblockFlag;
strcat(commandLine, nonblockFlag);
strcat(commandLine, flagSep);
cliArgs.argc = cli_argc;
}
}
printf("trying client command line[%d]: %s\n", tests++, commandLine);
InitTcpReady(&ready);
#ifdef TIRTOS
fdOpenSession(TaskSelf());
#endif
/* start server */
svrArgs.signal = &ready;
start_thread(server_test, &svrArgs, &serverThread);
wait_tcp_ready(&svrArgs);
#if !defined(USE_WINDOWS_API) && !defined(TIRTOS)
if (ready.port != 0)
{
if (cli_argc + 2 > MAX_ARGS)
printf("cannot add the magic port number flag to client\n");
else {
char portNumber[8];
snprintf(portNumber, sizeof(portNumber), "%d", ready.port);
cli_argv[cli_argc++] = portFlag;
cli_argv[cli_argc++] = portNumber;
cliArgs.argc = cli_argc;
}
}
#endif
/* start client */
client_test(&cliArgs);
/* verify results */
if (cliArgs.return_code != 0) {
printf("client_test failed\n");
exit(EXIT_FAILURE);
}
join_thread(serverThread);
if (svrArgs.return_code != 0) {
printf("server_test failed\n");
exit(EXIT_FAILURE);
}
#ifdef TIRTOS
fdCloseSession(TaskSelf());
#endif
FreeTcpReady(&ready);
return 0;
}
/**
* \function UDPlistensendPort
* \brief 使用UDP协议实现广播侦听远程配置工具，并主动连接将相机IP地址告知
* \ 默认作为服务端，Port = 4502;主动连接平台时，作为客户端。
* \
**/
void UDPlistensendPort()
{
SOCKET sockUDPsendListen,sockTCPsendIP;
int clilen,len;
int label;
struct sockaddr_in sin,connaddr, clientaddr; //保存客户的地址信息
struct sockaddr pcliaddr;
ConversationHead replySem;
//为当前任务配置运行环境
fdOpenSession( TaskSelf() );
//创建侦听套接字socket对象
sockUDPsendListen = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);//创建服务器监听socket,UDP协议
if( sockUDPsendListen == INVALID_SOCKET )
{
Roseek_Reset();//如果创建侦听对象失败，重启相机
}
bzero( &sin, sizeof(struct sockaddr_in) );
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;//自动获取本机地址
sin.sin_len = sizeof( sin );
sin.sin_port= htons( UDPPORT );//指明连接服务器的端口号
//sockUDPsendListen绑定
if ( bind( sockUDPsendListen, (PSA) &sin, sizeof(sin) ) < 0 )
{
Roseek_Reset();//如果绑定失败，重启相机
}
//迭代接受控制消息
while(1)
{
label = 10;
clilen = sizeof(struct sockaddr);
//开始接收数据
bTextRecev=recvfrom(sockUDPsendListen, (char *)(&replySem), sizeof(ConversationHead), 0, (PSA)&pcliaddr,&clilen);
if( bTextRecev < sizeof(ConversationHead) )
{
continue;
}
//存储配置工具的IP
g_ConfigSetaddr= pcliaddr;
//作为客户端，创建TCP协议连接远程平台，端口4502，告知相机的IP
sockTCPsendIP = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);//创建客户端socket.TCP协议
if( sockTCPsendIP == INVALID_SOCKET )
{
Roseek_Reset();//如果创建侦听对象失败，重启相机
}
bzero( &connaddr,sizeof(struct sockaddr_in));
connaddr.sin_family = AF_INET;
connaddr.sin_addr.s_addr = INADDR_ANY;
connaddr.sin_len = sizeof( connaddr );
connaddr.sin_port = htons(0);
if (bind(sockTCPsendIP, (PSA) &connaddr,sizeof(connaddr)))
{
Roseek_Reset();//如果绑定失败，重启相机
}
bzero(&clientaddr, sizeof(struct sockaddr_in));
clientaddr.sin_family = AF_INET;
clientaddr.sin_addr = ((struct sockaddr_in*) &pcliaddr)->sin_addr;
clientaddr.sin_len = sizeof( clientaddr );
clientaddr.sin_port = htons(UDPPORT);
if(connect( sockTCPsendIP, (PSA)&clientaddr, clientaddr.sin_len)<0)
{
bTextConnect = 1;
++bTextCount;
continue;
}
else
{
bTextConnect = 0;
if(replySem.command==UDPCON)
{
//发送信息1
replySem.command = BROADCAST1;
replySem.bufsize = DEVICETYPE;//设备类型参数
len=send( sockTCPsendIP,&replySem, sizeof(replySem), 0 );
//发送信息2
replySem.command = UDPSETTIME;
replySem.bufsize = label;
len=send( sockTCPsendIP,&replySem, sizeof(replySem), 0);
fdClose(sockTCPsendIP);
if(len<0)
{
continue;
}
}
}
}//迭代循环
}
void nullsrv()
{
SOCKET stcpactive = INVALID_SOCKET;
struct sockaddr_in sin1;
struct timeval timeout; // Timeout struct for select
int size;
int cnt;
char *pBuf;
HANDLE hBuffer;
//gpioEnableGlobalInterrupt();
// Allocate the file environment for this task
fdOpenSession(TaskSelf());
TaskSleep(15000);
platform_write("Raw Eth Task Started ... \n");
// Create the main TCP listen socket
platform_write("creating main TCP listen socket\n");
int k=0;
int n=0;
IMG_STORE_REQST_TYP a;
int *data;
UInt32 time1,time2;
for(;;)
{
//time1=Clock_getTicks();
a.fps=acquire_data();
a.number=min((int)a.fps*sizeof(int),PULSE_SAMPLE*sizeof(int));
//time2=Clock_getTicks();
///platform_write("time taken for acquire data is %lu \n",(unsigned long)(time2-time1));
//time1=Clock_getTicks();
for(k=0;k<2;k++)
{
if(k==0)
data=&data_bufferA[0];
else
data=&data_bufferB[0];
//WWdis_data();
stcp = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if( stcp == INVALID_SOCKET )
{
int ret=fdError();
goto leave;
}
timeout.tv_sec = 30;
timeout.tv_usec = 0;
setsockopt( stcp, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof( timeout ) );
setsockopt( stcp, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof( timeout ) );
//timeout.tv_sec = 3;
//int opt = 1;
//setsockopt( stcp, SOL_SOCKET, SO_BLOCKING , &opt, sizeof( opt ) );
platform_write("created main TCP client socket\n");
// Set Port = 1001, leaving IP address = Any
bzero( &sin1, sizeof(struct sockaddr_in) );
sin1.sin_family = AF_INET;
sin1.sin_addr.s_addr =inet_addr(PCStaticIP);
sin1.sin_port = htons(7000);
sin1.sin_len = sizeof( sin1 );
platform_write("LLL %d \n",(sin1.sin_addr.s_addr));
//fcntl(stcp, F_SETFL, O_NONBLOCK);
//while(1)
if( connect(stcp, (struct sockaddr *) &sin1, sizeof(sin1)) < 0)
{
if (fdError() == EINPROGRESS)
{
fd_set wrsd;
struct timeval tv;
FD_ZERO(&wrsd);
FD_SET(stcp, &wrsd);
tv.tv_sec = 2;
tv.tv_usec = 0;
int ret = fdSelect((int)stcp, 0, &wrsd, 0, &tv );
if(ret>0)
{
int err, lenErr;
lenErr = sizeof(err);
ret = getsockopt(stcp, SOL_SOCKET, SO_ERROR, &err, &lenErr);
if(ret==0 && err==0)
{
platform_write("connection completed");
break;
}
else
{
platform_write("Attempting to connect again");
continue;
}
}
}
}
platform_write("completed connect \n");
a.hydrophone=k;
n=0;
n = send(stcp,&a,sizeof(a),0);
if (n < 0)
{
perror("ERROR writing to socket");
break;
}
platform_write("writing hydrophone %d,bytes %d\n",k,a.number);
n=0;
int c=0;
//platform_write("writing %s \n",data);
do
{
n = send(stcp,data,a.number-c,0);
//platform_write("writing %d bytes \n",n);
if (n < 0)
{
perror("ERROR writing to socket");
break;
}
c=c+n;
data=data+n;
}while(c<a.number);
if (n < 0)
break;
//free(orig);
int status;
HANDLE hbuffer;
n = recv(stcp, &status, sizeof(status),0);
if(status==0)
{
platform_write("Client request success\n");
}
else
{
platform_write("Client request error");
continue;
}
if( stcp != INVALID_SOCKET )
fdClose(stcp);
}
if( stcp != INVALID_SOCKET )
{
shutdown(stcp,0);
fdClose(stcp);
}
//time2=Clock_getTicks();
platform_write("time taken for data transfer is %lu \n",(unsigned long)(time2-time1));
//TaskSleep(5);fe
}
leave:
TaskSleep(5000);
// We only get here on an error - close the sockets
// if( stcp != INVALID_SOCKET )
// fdClose( stcp );
platform_write("NullSrv Fatal Error\n");
// NetworkClose((HANDLE)TaskSelf());
// This task is killed by the system - here, we block
//TaskBlock( TaskSelf() );
}
