static void clear_int(OsNetworkHandle* aHandle)
{
char buffer[1];
int bytes = lwip_recv(aHandle->iIntSocket, buffer, 1, 0);
if ( bytes != 1 )
exit(-1);
}
// ret -1 = error, ret 0 = disconnected
int32_t MTD_FLASHMEM Socket::peek(void *buffer, uint32_t maxLength, bool nowait) {
int32_t flags = MSG_PEEK | (nowait ? MSG_DONTWAIT : 0);
int32_t bytesRecv = lwip_recv(m_socket, buffer, maxLength, flags);
if (maxLength > 0 && !nowait)
m_connected = (bytesRecv > 0);
return bytesRecv;
}
// ret -1 = error, ret 0 = disconnected
int32_t MTD_FLASHMEM Socket::peek(void* buffer, uint32_t maxLength)
{
int32_t bytesRecv = lwip_recv(m_socket, buffer, maxLength, MSG_PEEK);
if (maxLength > 0)
m_connected = (bytesRecv > 0);
return bytesRecv;
}
ssize_t zts_recv(int fd, void *buf, size_t len, int flags)
{
if (!buf) {
return ZTS_ERR_INVALID_ARG;
}
return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_recv(fd, buf, len, flags);
}
static void
mc_event_thread_call_local(mc_event_thread_callback_f callback, void *closure, uint32_t flags)
{
int s;
struct sockaddr_in sin;
mc_local_event_t ev;
int fl;
if ((s = lwip_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
return;
fl = lwip_fcntl(s, F_GETFL, 0);
lwip_fcntl(s, F_SETFL, fl | O_NONBLOCK);
sin.sin_family = AF_INET;
sin.sin_port = htons(MC_LOCAL_EVENT_PORT);
sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
ev.callback = callback;
ev.closure = closure;
ev.flags = flags;
#if USE_SEMAPHORE
mc_task_init(&ev);
#endif
lwip_sendto(s, &ev, sizeof(ev), 0, (struct sockaddr *)&sin, sizeof(sin));
#if !USE_SEMAPHORE
if (!(flags & MC_CALL_ASYNC))
lwip_recv(s, &ev, sizeof(ev), 0);
#endif
lwip_close(s);
#if USE_SEMAPHORE
if (!(flags & MC_CALL_ASYNC)) {
mc_task_sleep(&ev);
mc_task_fin(&ev);
}
#endif
}
static void SC_Recv(__SYSCALL_PARAM_BLOCK* pspb)
{
pspb->lpRetValue = (LPVOID)lwip_recv(
(INT)PARAM(0),
(void*)PARAM(1),
(size_t)PARAM(2),
(INT)PARAM(3)
);
}
int Socket::Receive(void* buf, int bufLen)
{
int n = lwip_recv(socket_->fd, buf, bufLen, 0);
if (n < 0 && errno == EWOULDBLOCK)
return 0;
else if (n == 0)
return -1;
return n;
}
/*
* 读 socket
*/
static ssize_t socket_read(void *ctx, file_t *file, void *buf, size_t len)
{
privinfo_t *priv = ctx;
if (priv == NULL) {
seterrno(EINVAL);
return -1;
}
if (atomic_read(&priv->select.flags) & VFS_FILE_ERROR) {
seterrno(EIO);
return -1;
}
return lwip_recv(priv->sock_fd, buf, len, 0);
}
int32_t OsNetworkReceive(THandle aHandle, uint8_t* aBuffer, uint32_t aBytes)
{
if ( OsNetworkHandle_IsInterrupted(aHandle) )
return -1;
LOGFUNCIN();
if ( local_select(aHandle, LS_READ, LS_FOREVER) == -1 )
return -1;
size_t bytes = lwip_recv ( HANDLE_TO_SOCKET(aHandle), (void*) aBuffer, (size_t) aBytes, 0);
LOGFUNCOUT();
return bytes;
}
void UdpReceiveData()
{
int nbytes;
for(int i=0;i<MAX_NUM_OF_SOCKETS;i++){
if(sockList[i] != (-1)){
nbytes=lwip_recv(sockList[i], buffer, sizeof(buffer),MSG_DONTWAIT);
if (nbytes>0){
if(cbkFuncList[i] != NULL)
{
cbkFuncList[i](buffer, nbytes);
}
}
}
}
}
int LWIP_SOCKETS_Driver::Recv(SOCK_SOCKET socket, char* buf, int len, int flags)
{
NATIVE_PROFILE_PAL_NETWORK();
int nativeFlag;
switch (flags)
{
case SOCKET_READ_PEEK_OPTION:
nativeFlag = MSG_PEEK;
break;
default:
nativeFlag = flags;
break;
}
return lwip_recv(socket,(void*)buf, len, nativeFlag);
}
static void receive_udp(void *pvParameters) {
int lSocket;
struct sockaddr_in sLocalAddr, sDestAddr;
int nbytes;
int i;
lSocket = lwip_socket(AF_INET, SOCK_DGRAM, 0);
if(lSocket != 0) {
printf("ERROR \r\n");
}
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
memset((char *)&sDestAddr, 0, sizeof(sDestAddr));
/*Destination*/
sDestAddr.sin_family = AF_INET;
sDestAddr.sin_len = sizeof(sDestAddr);
sDestAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
sDestAddr.sin_port = htons(8080);
/*Source*/
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY); //inet_addr("192.168.4.1");
sLocalAddr.sin_port = htons(8080);
int err = lwip_bind(lSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr));
if(err != 0) {
printf("ERROR \r\n");
}
while (1) {
nbytes=lwip_recv(lSocket, buffer, sizeof(buffer),8);
if (nbytes>0) {
//lwip_sendto(lSocket, buffer, nbytes, 0, (struct sockaddr *)&sDestAddr, sizeof(sDestAddr));
char * dat = malloc(nbytes);
memcpy(dat, buffer, nbytes);
dat[nbytes] = 0;
my_event_t ev;
ev.event_type = EVT_DATA;
ev.data = dat;
ev.len = nbytes;
xQueueSend(mainqueue, &ev, 0);
}
}
lwip_close(lSocket);
}
//--------------------------------------------------------------
int recv_noblock(int sock, u8 *buf, int bsize)
{
int r;
fd_set rfd;
FD_ZERO(&rfd);
FD_SET(sock, &rfd);
r = lwip_select(sock+1, &rfd, NULL, NULL, NULL);
if (r < 0)
return -1;
// receive the packet
r = lwip_recv(sock, buf, bsize, 0);
if (r < 0)
return -2;
return r;
}
int recvall(int sockfd, unsigned char *recv_buf, int len, int flags){
int bytes_recvd = 0;
int n;
/* loop as long as there are data to send */
while(bytes_recvd < len){
if((n = lwip_recv(sockfd, recv_buf + bytes_recvd,
len - bytes_recvd, flags)) < 0){
fprintf(stderr, "%s: lwip_recv error\n", __FUNCTION__);
return ERROR;
}
/* Client closed connection */
if(n == 0)
return 0;
bytes_recvd += n;
}
return bytes_recvd;
}
static int receiveCallback(WOLFSSL* ssl, char *buf, int sz, void *ctx)
{
int fd = *(int*)ctx;
int result;
(void)ssl;
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
if (lwip_select(FD_SETSIZE, &rfds, NULL, NULL, NULL) < 0)
{
result = -1;
}
else
{
result = lwip_recv(fd, buf, sz, 0);
}
return result;
}
END_TEST
static void test_sockets_allfunctions_basic_domain(int domain)
{
int s, s2, s3, ret;
struct sockaddr_storage addr, addr2;
socklen_t addrlen, addr2len;
char buf[4];
/* listen socket */
s = lwip_socket(domain, SOCK_STREAM, 0);
fail_unless(s >= 0);
ret = lwip_listen(s, 0);
fail_unless(ret == 0);
addrlen = sizeof(addr);
ret = lwip_getsockname(s, (struct sockaddr*)&addr, &addrlen);
fail_unless(ret == 0);
s2 = test_sockets_alloc_socket_nonblocking(domain, SOCK_STREAM);
fail_unless(s2 >= 0);
/* nonblocking connect s2 to s (but use loopback address) */
if (domain == AF_INET) {
#if LWIP_IPV4
struct sockaddr_in *addr4 = (struct sockaddr_in *)&addr;
addr4->sin_addr.s_addr = PP_HTONL(INADDR_LOOPBACK);
#endif
} else {
#if LWIP_IPV6
struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr;
struct in6_addr lo6 = IN6ADDR_LOOPBACK_INIT;
addr6->sin6_addr = lo6;
#endif
}
ret = lwip_connect(s2, (struct sockaddr*)&addr, addrlen);
fail_unless(ret == -1);
fail_unless(errno == EINPROGRESS);
ret = lwip_connect(s2, (struct sockaddr*)&addr, addrlen);
fail_unless(ret == -1);
fail_unless(errno == EALREADY);
while(tcpip_thread_poll_one());
s3 = lwip_accept(s, (struct sockaddr*)&addr2, &addr2len);
fail_unless(s3 >= 0);
ret = lwip_connect(s2, (struct sockaddr*)&addr, addrlen);
fail_unless(ret == -1);
fail_unless(errno == EISCONN);
/* write from server to client */
ret = write(s3, "test", 4);
fail_unless(ret == 4);
ret = lwip_shutdown(s3, SHUT_WR);
fail_unless(ret == 0);
while(tcpip_thread_poll_one());
ret = lwip_recv(s2, buf, 3, MSG_PEEK);
fail_unless(ret == 3);
ret = lwip_recv(s2, buf, 3, MSG_PEEK);
fail_unless(ret == 3);
ret = lwip_read(s2, buf, 4);
fail_unless(ret == 4);
ret = lwip_read(s2, buf, 1);
fail_unless(ret == 0);
ret = lwip_read(s2, buf, 1);
fail_unless(ret == -1);
ret = lwip_write(s2, "foo", 3);
fail_unless(ret == 3);
ret = lwip_close(s2);
fail_unless(ret == 0);
while(tcpip_thread_poll_one());
/* read one byte more than available to check handling FIN */
ret = lwip_read(s3, buf, 4);
fail_unless(ret == 3);
ret = lwip_read(s3, buf, 1);
fail_unless(ret == 0);
ret = lwip_read(s3, buf, 1);
fail_unless(ret == -1);
while(tcpip_thread_poll_one());
ret = lwip_close(s);
fail_unless(ret == 0);
ret = lwip_close(s3);
fail_unless(ret == 0);
}
static void
serve_thread(uint32_t a) {
struct st_args *args = (struct st_args *)a;
union Nsipc *req = args->req;
int r;
switch (args->reqno) {
case NSREQ_ACCEPT:
{
struct Nsret_accept ret;
r = lwip_accept(req->accept.req_s, &ret.ret_addr,
&ret.ret_addrlen);
memmove(req, &ret, sizeof ret);
break;
}
case NSREQ_BIND:
r = lwip_bind(req->bind.req_s, &req->bind.req_name,
req->bind.req_namelen);
break;
case NSREQ_SHUTDOWN:
r = lwip_shutdown(req->shutdown.req_s, req->shutdown.req_how);
break;
case NSREQ_CLOSE:
r = lwip_close(req->close.req_s);
break;
case NSREQ_CONNECT:
r = lwip_connect(req->connect.req_s, &req->connect.req_name,
req->connect.req_namelen);
break;
case NSREQ_LISTEN:
r = lwip_listen(req->listen.req_s, req->listen.req_backlog);
break;
case NSREQ_RECV:
// Note that we read the request fields before we
// overwrite it with the response data.
r = lwip_recv(req->recv.req_s, req->recvRet.ret_buf,
req->recv.req_len, req->recv.req_flags);
break;
case NSREQ_SEND:
r = lwip_send(req->send.req_s, &req->send.req_buf,
req->send.req_size, req->send.req_flags);
break;
case NSREQ_SOCKET:
r = lwip_socket(req->socket.req_domain, req->socket.req_type,
req->socket.req_protocol);
break;
case NSREQ_INPUT:
jif_input(&nif, (void *)&req->pkt);
r = 0;
break;
default:
cprintf("Invalid request code %d from %08x\n", args->whom, args->req);
r = -E_INVAL;
break;
}
if (r == -1) {
char buf[100];
snprintf(buf, sizeof buf, "ns req type %d", args->reqno);
perror(buf);
}
if (args->reqno != NSREQ_INPUT)
ipc_send(args->whom, r, 0, 0);
put_buffer(args->req);
sys_page_unmap(0, (void*) args->req);
free(args);
}
ssize_t recv(int sockfd, void *buf, size_t len, int flags)
{
struct fdtab_entry *e = fdtab_get(sockfd);
switch(e->type) {
case FDTAB_TYPE_UNIX_SOCKET:
{
struct _unix_socket *us = e->handle;
// XXX: Don't support flags
assert(flags == 0);
thread_mutex_lock(&us->mutex);
if(us->passive
|| us->u.active.mode != _UNIX_SOCKET_MODE_CONNECTED) {
errno = ENOTCONN;
thread_mutex_unlock(&us->mutex);
return -1;
}
if(us->recv_buf_valid == 0) {
// No more data
if(us->nonblocking) {
errno = EAGAIN;
thread_mutex_unlock(&us->mutex);
return -1;
} else {
struct waitset ws;
errval_t err;
waitset_init(&ws);
err = us->u.active.binding->change_waitset
(us->u.active.binding, &ws);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "change_waitset");
}
while(us->recv_buf_valid == 0) {
err = event_dispatch(&ws);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "waitset_destroy");
}
}
// XXX: Assume it was on the default waitset
err = us->u.active.binding->change_waitset
(us->u.active.binding, get_default_waitset());
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "change_waitset");
}
err = waitset_destroy(&ws);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "waitset_destroy");
}
}
}
size_t recved = 0;
while(recved < len && us->recv_list != NULL) {
struct _unix_socket_recv *usr = us->recv_list;
size_t consume = MIN(len - recved, usr->size - usr->consumed);
memcpy(buf + recved, &usr->msg[usr->consumed], consume);
usr->consumed += consume;
us->recv_buf_valid -= consume;
recved += consume;
if(usr->consumed == usr->size) {
us->recv_list = usr->next;
if(us->recv_list == NULL) {
us->recv_list_end = NULL;
}
free(usr->msg);
free(usr);
} else {
assert(recved == len);
}
}
thread_mutex_unlock(&us->mutex);
return recved;
}
case FDTAB_TYPE_LWIP_SOCKET:
lwip_mutex_lock();
ssize_t ret = lwip_recv(e->fd, buf, len, flags);
lwip_mutex_unlock();
return ret;
case FDTAB_TYPE_AVAILABLE:
errno = EBADF;
return -1;
default:
errno = ENOTSOCK;
return -1;
}
}
void usart_tx_thread_entry(void *p)
{
fd_set readset;
struct timeval timeout;
int fd_max;
timeout.tv_sec = 0; // second.
timeout.tv_usec = 100*1000; //wait micro second.
while( 1 )
{
int i;
// prepare select fd.
FD_ZERO(&readset);
fd_max = 0;
for( i = 0 ; i < SOCKET_LIST_SIZE ; i++ )
{
if( socket_list[i].used )
{
if( fd_max < socket_list[i].socket )
fd_max = socket_list[i].socket;
FD_SET(socket_list[i].socket,&readset);
}
}
// no connection.
if( fd_max == 0 )
{
rt_thread_delay(1); // delay 10ms.
continue;
}
if( lwip_select(fd_max+1,&readset,NULL,0,&timeout) == 0 )
continue;
for( i = 0 ; i < SOCKET_LIST_SIZE ; i++ )
{
rt_err_t ret;
// NOTE: we can take tx semaphore here means that the DMA buffer is not in use.
// We must NOT write the DMA buffer until notified to be used.
rt_sem_take(&tx1_sem,RT_WAITING_FOREVER);
rt_sem_take(&tx2_sem,RT_WAITING_FOREVER);
// Timeout 100ms.
ret = rt_mutex_take(&(socket_list[i].mu_sock),10);
if( ret == -RT_ETIMEOUT )
{
rt_kprintf("Taking mu_sock timeout.\n");
rt_sem_release(&tx2_sem);
rt_sem_release(&tx1_sem);
continue;
}
if( socket_list[i].used && FD_ISSET(socket_list[i].socket,&readset) )
{
unsigned short dataLen = lwip_recv(socket_list[i].socket,tx_buf,TX_BUF_SIZE,MSG_DONTWAIT);
if( dataLen > 0 )
{
usart_bytes_sent += dataLen;
usart_led_flash();
dev_uart1->write(dev_uart1,0,tx_buf,dataLen);
dev_uart2->write(dev_uart2,0,tx_buf,dataLen);
// we have sent data to usart.
rt_mutex_release(&(socket_list[i].mu_sock));
continue;
}
else
{
lwip_close(socket_list[i].socket);
socket_list[i].used = 0;
rt_kprintf("recv failed or FIN recv, close socket.\n");
}
}
rt_mutex_release(&(socket_list[i].mu_sock));
rt_sem_release(&tx2_sem);
rt_sem_release(&tx1_sem);
}
}
}
static void echo_run()
{
int lSocket;
struct sockaddr_in sLocalAddr;
lSocket = lwip_socket(AF_INET, SOCK_STREAM, 0);
if (lSocket < 0) {
puts("lSocket < 0");
return;
}
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_addr.s_addr = 0L; //htonl(IP_ADDR_ANY);
sLocalAddr.sin_port = 23;
if (lwip_bind(lSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)) < 0) {
lwip_close(lSocket);
puts("bind failed");
return;
}
if ( lwip_listen(lSocket, 20) != 0 ) {
lwip_close(lSocket);
puts("listen failed");
return;
}
while (1) {
int clientfd;
struct sockaddr_in client_addr;
int addrlen=sizeof(client_addr);
char buffer[1024];
int nbytes;
clientfd = lwip_accept(lSocket, (struct sockaddr*)&client_addr, (socklen_t *)&addrlen);
if (clientfd > 0) {
puts("Accepted Echo Connection");
/*
int flags = fcntl(clientfd, F_GETFL, 0);
printf("flags = %d\n", flags);
fcntl(clientfd, F_SETFL, flags | O_NONBLOCK);
flags = fcntl(clientfd, F_GETFL, 0);
if ((flags & O_NONBLOCK) == O_NONBLOCK) {
printf("it's nonblocking");
}
else {
printf("it's blocking.");
}
*/
struct timeval tv;
tv.tv_sec = 500;
tv.tv_usec = 500;
setsockopt(clientfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv,sizeof(struct timeval));
do {
nbytes = lwip_recv(clientfd, buffer, sizeof(buffer),0);
if (nbytes > 0)
lwip_send(clientfd, buffer, nbytes, 0);
else
lwip_send(clientfd, "#", 1, 0);
} while (nbytes != 0);
puts("Closing connection.");
lwip_close(clientfd);
}
}
lwip_close(lSocket);
puts("Socked closed.");
}
ssize_t recv(int sockfd, void *buf, size_t len, int flags)
{
int sock = socket_for_fd(sockfd);
return lwip_recv(sock, buf, len, flags);
}
void vBasicSocketsCommandInterpreterTask( void *pvParameters )
{
long lSocket, lClientFd, lBytes, lAddrLen = sizeof( struct sockaddr_in ), lInputIndex;
struct sockaddr_in sLocalAddr;
struct sockaddr_in client_addr;
const char *pcWelcomeMessage = "FreeRTOS command server - connection accepted.\r\nType Help to view a list of registered commands.\r\n\r\n>";
char cInChar;
static char cInputString[ cmdMAX_INPUT_SIZE ], cOutputString[ cmdMAX_OUTPUT_SIZE ];
portBASE_TYPE xReturned;
extern void vRegisterSampleCLICommands( void );
( void ) pvParameters;
/* Register the standard CLI commands. */
vRegisterSampleCLICommands();
lSocket = lwip_socket(AF_INET, SOCK_STREAM, 0);
if( lSocket >= 0 )
{
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY);
sLocalAddr.sin_port = ntohs( ( ( unsigned short ) 23 ) );
if( lwip_bind( lSocket, ( struct sockaddr *) &sLocalAddr, sizeof( sLocalAddr ) ) < 0 )
{
lwip_close( lSocket );
vTaskDelete( NULL );
}
if( lwip_listen( lSocket, 20 ) != 0 )
{
lwip_close( lSocket );
vTaskDelete( NULL );
}
for( ;; )
{
lClientFd = lwip_accept(lSocket, ( struct sockaddr * ) &client_addr, ( u32_t * ) &lAddrLen );
if( lClientFd > 0L )
{
lwip_send( lClientFd, pcWelcomeMessage, strlen( ( const char * ) pcWelcomeMessage ), 0 );
lInputIndex = 0;
memset( cInputString, 0x00, cmdMAX_INPUT_SIZE );
do
{
lBytes = lwip_recv( lClientFd, &cInChar, sizeof( cInChar ), 0 );
if( lBytes > 0L )
{
if( cInChar == '\n' )
{
/* The input string has been terminated. Was the
input a quit command? */
if( strcmp( "quit", ( const char * ) cInputString ) == 0 )
{
/* Set lBytes to 0 to close the connection. */
lBytes = 0L;
}
else
{
/* The input string was not a quit command.
Pass the string to the command interpreter. */
do
{
/* Get the next output string from the command interpreter. */
xReturned = FreeRTOS_CLIProcessCommand( cInputString, cOutputString, cmdMAX_INPUT_SIZE );
lwip_send( lClientFd, cOutputString, strlen( ( const char * ) cOutputString ), 0 );
} while( xReturned != pdFALSE );
/* All the strings generated by the input
command have been sent. Clear the input
string ready to receive the next command. */
lInputIndex = 0;
memset( cInputString, 0x00, cmdMAX_INPUT_SIZE );
lwip_send( lClientFd, "\r\n>", strlen( "\r\n>" ), 0 );
}
}
else
{
if( cInChar == '\r' )
{
/* Ignore the character. */
}
else if( cInChar == '\b' )
{
/* Backspace was pressed. Erase the last
character in the string - if any. */
if( lInputIndex > 0 )
{
lInputIndex--;
cInputString[ lInputIndex ] = '\0';
}
}
else
{
/* A character was entered. Add it to the string
entered so far. When a \n is entered the complete
string will be passed to the command interpreter. */
if( lInputIndex < cmdMAX_INPUT_SIZE )
{
cInputString[ lInputIndex ] = cInChar;
lInputIndex++;
}
}
}
}
} while( lBytes > 0L );
lwip_close( lClientFd );
}
}
}
/* Will only get here if a listening socket could not be created. */
vTaskDelete( NULL );
}
int recv(int s, void *mem, size_t len, int flags) {
BT_HANDLE hSocket = (BT_HANDLE)s;
return lwip_recv(hSocket->socket, mem, len, flags);
}
int lwip_read(int s, void *mem, int len) {
return lwip_recv(s, mem, len, 0);
}
static BT_s32 socket_read(BT_HANDLE hSocket, BT_u32 ulFlags, BT_u32 ulSize, void *pBuffer) {
return lwip_recv(hSocket->socket, pBuffer, ulSize, ulFlags);
//return BT_ERR_GENERIC;
}
static void socketTcpRead(uint16 sockNr)
{
BufReq_ReturnType result;
switch (SocketAdminList[sockNr].SocketConnectionRef->AutosarConnectorType) {
case SOAD_AUTOSAR_CONNECTOR_PDUR:
if (SocketAdminList[sockNr].SocketRouteRef != NULL) {
int nBytes;
PduInfoType pduInfo;
// pi_printf("infor: tcp read\r\n");
if (SoAd_BufferGet(SOAD_RX_BUFFER_SIZE, &pduInfo.SduDataPtr)) {
nBytes = lwip_recv(SocketAdminList[sockNr].ConnectionHandle, pduInfo.SduDataPtr, SOAD_RX_BUFFER_SIZE, MSG_PEEK);
// pi_printf("infor: peek data "); mini_uart_sendDec(nBytes); pi_printf("\r\n");
SoAd_SocketStatusCheck(sockNr, SocketAdminList[sockNr].ConnectionHandle);
if ((nBytes > 0) && (nBytes >= SocketAdminList[sockNr].SocketRouteRef->DestinationSduLength)) {
if (!SocketAdminList[sockNr].SocketConnectionRef->PduProvideBufferEnable) {
// IF-type
// pi_printf(" infor: plan to read\r\n");
pduInfo.SduLength = lwip_recv(SocketAdminList[sockNr].ConnectionHandle, pduInfo.SduDataPtr, SocketAdminList[sockNr].SocketRouteRef->DestinationSduLength, 0);
// pi_printf(" infor: value = "); mini_uart_sendDec(*pduInfo.SduDataPtr); pi_printf("\r\n");
New_Data_Flag = true;
(void)PduR_SoAdIfRxIndication(SocketAdminList[sockNr].SocketRouteRef->DestinationPduId, &pduInfo);
} else {
// TP-type
PduLengthType len;
result = PduR_SoAdTpStartOfReception(SocketAdminList[sockNr].SocketRouteRef->DestinationPduId, SocketAdminList[sockNr].SocketRouteRef->DestinationSduLength, &len);
if (result == BUFREQ_OK && len>0) {
pduInfo.SduLength = SocketAdminList[sockNr].SocketRouteRef->DestinationSduLength;
nBytes = lwip_recv(SocketAdminList[sockNr].SocketHandle, pduInfo.SduDataPtr, SocketAdminList[sockNr].SocketRouteRef->DestinationSduLength,0);
/* Let pdur copy received data */
if(len < SocketAdminList[sockNr].SocketRouteRef->DestinationSduLength)
{
PduInfoType pduInfoChunk;
PduLengthType lenToSend = SocketAdminList[sockNr].SocketRouteRef->DestinationSduLength;
/* We need to copy in smaller parts */
pduInfoChunk.SduDataPtr = pduInfo.SduDataPtr;
while(lenToSend > 0)
{
if(lenToSend >= len){
PduR_SoAdTpCopyRxData(SocketAdminList[sockNr].SocketRouteRef->DestinationPduId, &pduInfoChunk, &len);
lenToSend -= len;
}else{
PduR_SoAdTpCopyRxData(SocketAdminList[sockNr].SocketRouteRef->DestinationPduId, &pduInfoChunk, &lenToSend);
lenToSend = 0;
}
}
}else{
PduR_SoAdTpCopyRxData(SocketAdminList[sockNr].SocketRouteRef->DestinationPduId, &pduInfo, &len);
}
/* Finished reception */
(void)PduR_SoAdTpRxIndication(SocketAdminList[sockNr].SocketRouteRef->DestinationPduId, NTFRSLT_OK);
} else if (result != BUFREQ_BUSY) {
DET_REPORTERROR(MODULE_ID_SOAD, 0, SOAD_SOCKET_TCP_READ_ID, SOAD_E_UL_RXBUFF);
}
}
}
SoAd_BufferFree(pduInfo.SduDataPtr);
} else {
// No buffer available: continue poll() Report error SOAD_E_UPPERBUFF to DEM
// DET_REPORTERROR(MODULE_ID_SOAD, 0, SOAD_SOCKET_TCP_READ_ID, SOAD_E_UPPERBUFF);
(void)PduR_SoAdTpRxIndication(SocketAdminList[sockNr].SocketRouteRef->DestinationPduId, NTFRSLT_E_NO_BUFFER);
}
} else {
DET_REPORTERROR(MODULE_ID_SOAD, 0, SOAD_SOCKET_TCP_READ_ID, SOAD_E_CONFIG_INVALID);
}
break; // SOAD_AUTOSAR_CONNECTOR_PDUR
case SOAD_AUTOSAR_CONNECTOR_DOIP:
DoIp_HandleTcpRx(sockNr);
break; // SOAD_AUTOSAR_CONNECTOR_DOIP
default:
DET_REPORTERROR(MODULE_ID_SOAD, 0, SOAD_SOCKET_TCP_READ_ID, SOAD_E_NOCONNECTOR);
break;
}
}
END_TEST
START_TEST(test_sockets_recv_after_rst)
{
int sl, sact;
int spass = -1;
int ret;
struct sockaddr_in sa_listen;
const u16_t port = 1234;
int arg;
const char txbuf[] = "something";
char rxbuf[16];
struct lwip_sock *sact_sock;
int err;
LWIP_UNUSED_ARG(_i);
fail_unless(test_sockets_get_used_count() == 0);
memset(&sa_listen, 0, sizeof(sa_listen));
sa_listen.sin_family = AF_INET;
sa_listen.sin_port = PP_HTONS(port);
sa_listen.sin_addr.s_addr = PP_HTONL(INADDR_LOOPBACK);
/* set up the listener */
sl = lwip_socket(AF_INET, SOCK_STREAM, 0);
fail_unless(sl >= 0);
fail_unless(test_sockets_get_used_count() == 0);
ret = lwip_bind(sl, (struct sockaddr *)&sa_listen, sizeof(sa_listen));
fail_unless(ret == 0);
ret = lwip_listen(sl, 0);
fail_unless(ret == 0);
/* set up the client */
sact = lwip_socket(AF_INET, SOCK_STREAM, 0);
fail_unless(sact >= 0);
fail_unless(test_sockets_get_used_count() == 0);
/* set the client to nonblocking to simplify this test */
arg = 1;
ret = lwip_ioctl(sact, FIONBIO, &arg);
fail_unless(ret == 0);
/* connect */
do {
ret = lwip_connect(sact, (struct sockaddr *)&sa_listen, sizeof(sa_listen));
err = errno;
fail_unless((ret == 0) || (ret == -1));
if (ret != 0) {
if (err == EISCONN) {
/* Although this is not valid, use EISCONN as an indicator for successful connection.
This marks us as "connect phase is done". On error, we would either have a different
errno code or "send" fails later... -> good enough for this test. */
ret = 0;
} else {
fail_unless(err == EINPROGRESS);
if (err != EINPROGRESS) {
goto cleanup;
}
/* we're in progress: little side check: test for EALREADY */
ret = lwip_connect(sact, (struct sockaddr *)&sa_listen, sizeof(sa_listen));
err = errno;
fail_unless(ret == -1);
fail_unless(err == EALREADY);
if ((ret != -1) || (err != EALREADY)) {
goto cleanup;
}
}
tcpip_thread_poll_one();
tcpip_thread_poll_one();
tcpip_thread_poll_one();
tcpip_thread_poll_one();
}
} while (ret != 0);
fail_unless(ret == 0);
/* accept the server connection part */
spass = lwip_accept(sl, NULL, NULL);
fail_unless(spass >= 0);
/* write data from client */
ret = lwip_send(sact, txbuf, sizeof(txbuf), 0);
fail_unless(ret == sizeof(txbuf));
tcpip_thread_poll_one();
tcpip_thread_poll_one();
/* issue RST (This is a HACK, don't try this in your own app!) */
sact_sock = lwip_socket_dbg_get_socket(sact);
fail_unless(sact_sock != NULL);
if (sact_sock != NULL) {
struct netconn *sact_conn = sact_sock->conn;
fail_unless(sact_conn != NULL);
if (sact_conn != NULL) {
struct tcp_pcb *pcb = sact_conn->pcb.tcp;
fail_unless(pcb != NULL);
if (pcb != NULL) {
tcp_rst(pcb, pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
pcb->local_port, pcb->remote_port);
}
}
}
tcpip_thread_poll_one();
tcpip_thread_poll_one();
/* expect to receive data first */
ret = lwip_recv(spass, rxbuf, sizeof(rxbuf), 0);
fail_unless(ret > 0);
tcpip_thread_poll_one();
tcpip_thread_poll_one();
/* expect to receive RST indication */
ret = lwip_recv(spass, rxbuf, sizeof(rxbuf), 0);
fail_unless(ret == -1);
err = errno;
fail_unless(err == ECONNRESET);
tcpip_thread_poll_one();
tcpip_thread_poll_one();
/* expect to receive ENOTCONN indication */
ret = lwip_recv(spass, rxbuf, sizeof(rxbuf), 0);
fail_unless(ret == -1);
err = errno;
fail_unless(err == ENOTCONN);
tcpip_thread_poll_one();
tcpip_thread_poll_one();
/* expect to receive ENOTCONN indication */
ret = lwip_recv(spass, rxbuf, sizeof(rxbuf), 0);
fail_unless(ret == -1);
err = errno;
fail_unless(err == ENOTCONN);
tcpip_thread_poll_one();
tcpip_thread_poll_one();
cleanup:
ret = lwip_close(sl);
fail_unless(ret == 0);
ret = lwip_close(sact);
fail_unless(ret == 0);
if (spass >= 0) {
ret = lwip_close(spass);
fail_unless(ret == 0);
}
}
