int socket_connect(int sock, const char* host, int port)
{
int result;
int timeout;
struct hostent *server_host;
struct sockaddr_in server_addr;
server_host = gethostbyname(host);
if (server_host == RT_NULL)
{
rt_kprintf("unknow host: %s\n", host);
return -1;
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
server_addr.sin_addr = *((struct in_addr *)server_host->h_addr);
rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
result = lwip_connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
/* set recv timeout */
timeout = 3000; /* 3 seconds */
lwip_setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
return result;
}
BST_IP_ERR_T BST_IP_BsdConnect( BST_FD_T fd, BST_ARG_T Arg, BST_IP_SOCKET_ADD_T *pAdd )
{
struct sockaddr_in stRemoteAddr;
if( !BST_IP_IsBsdFdValid(fd) )
{
return BST_IP_ERR_MEM;
}
if( BST_NULL_PTR == pAdd )
{
return BST_IP_ERR_MEM;
}
stRemoteAddr.sin_len = BST_OS_SIZEOF(stRemoteAddr);
stRemoteAddr.sin_family = AF_INET;
stRemoteAddr.sin_port = htons( pAdd->usRemotePort );
BST_IP_GetU32Addr( stRemoteAddr.sin_addr.s_addr,
pAdd->aucRemoteIp[3],
pAdd->aucRemoteIp[2],
pAdd->aucRemoteIp[1],
pAdd->aucRemoteIp[0] );
return (BST_IP_ERR_T)lwip_connect( fd.lFd,
(struct sockaddr*)&stRemoteAddr,
BST_OS_SIZEOF(stRemoteAddr) );
}
bool TLSConnection::connect(const char *host)
{
if (init_socket(SOCK_STREAM) < 0)
return false;
if (set_address(host, HTTPS_PORT) != 0)
return false;
if (lwip_connect(_sock_fd, (const struct sockaddr *) &_remoteHost, sizeof(_remoteHost)) < 0) {
close();
return false;
}
if(ssl_ctx_new(&_ssl_ctx, 0, SSL_DEFAULT_CLNT_SESS) != &_ssl_ctx)
return false;
_ssl.ssl_ctx = &_ssl_ctx;
if(ssl_client_new(&_ssl, _sock_fd, NULL, 0) == NULL) {
close();
return false;
}
if(_ssl.hs_status != SSL_OK) {
close();
return false;
}
_is_connected = true;
return true;
}
int sys_connect(int fd, const struct sockaddr* addr, socklen_t addrlen) {
#if CONFIG_NETWORK
return lwip_connect(fd - TASK_FD_COUNT, addr, addrlen);
#endif
errno = ENOSYS;
return -1;
});
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
int sock = socket_for_fd(sockfd);
int ret = lwip_connect(sock, addr, addrlen);
if (ret == 0)
mark_connected(sockfd, 1);
return ret;
}
int zts_connect(int fd, const struct sockaddr *addr, socklen_t addrlen)
{
if (!addr) {
return ZTS_ERR_INVALID_ARG;
}
if (addrlen > (int)sizeof(struct sockaddr_storage) || addrlen < (int)sizeof(struct sockaddr_in)) {
return ZTS_ERR_INVALID_ARG;
}
return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_connect(fd, addr, addrlen);
}
int LWIP_SOCKETS_Driver::Connect(SOCK_SOCKET socket, const SOCK_sockaddr* address, int addressLen)
{
NATIVE_PROFILE_PAL_NETWORK();
sockaddr_in addr;
SOCK_SOCKADDR_TO_SOCKADDR(address, addr, &addressLen);
return lwip_connect(socket, (sockaddr*)&addr, addressLen);
}
int socket_connect_addr(int sock, uint32_t addr, int port)
{
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
server_addr.sin_addr.s_addr = addr;
rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
return lwip_connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
}
int32_t mcs_tcp_init(void (*mcs_tcp_callback)(char *))
{
int s;
int c;
int ret;
struct sockaddr_in addr;
int count = 0;
int rcv_len, rlen;
int32_t mcs_ret = MCS_TCP_DISCONNECT;
/* Setting the TCP ip */
if (HTTPCLIENT_OK != getInitialTCPIP()) {
return MCS_TCP_INIT_ERROR;
}
/* command buffer */
char cmd_buf [50]= {0};
strcat(cmd_buf, DEVICEID);
strcat(cmd_buf, ",");
strcat(cmd_buf, DEVICEKEY);
strcat(cmd_buf, ",0");
mcs_tcp_connect:
os_memset(&addr, 0, sizeof(addr));
addr.sin_len = sizeof(addr);
addr.sin_family = AF_INET;
addr.sin_port = htons(SOCK_TCP_SRV_PORT);
addr.sin_addr.s_addr =inet_addr(TCP_ip);
/* create the socket */
s = lwip_socket(AF_INET, SOCK_STREAM, 0);
if (s < 0) {
mcs_ret = MCS_TCP_SOCKET_INIT_ERROR;
printf("tcp client create fail 0\n");
goto idle;
}
ret = lwip_connect(s, (struct sockaddr *)&addr, sizeof(addr));
if (ret < 0) {
lwip_close(s);
printf("tcp client connect fail 1\n");
goto mcs_tcp_connect;
}
/* timer */
void tcpTimerCallback( TimerHandle_t pxTimer ) {
ret = lwip_write(s, cmd_buf, sizeof(cmd_buf));
}
int Socket::Connect(const std::string& addr, const std::string& port)
{
int rc;
struct sockaddr_in serv_addr;
memset( &serv_addr, 0, sizeof(struct sockaddr_in) );
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr( addr.c_str() );
serv_addr.sin_port = htons(atoi(port.c_str()));
rc = lwip_connect( socket_->fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr) );
if (rc < 0 && errno == EINPROGRESS)
rc = 0;
return WaitForConnect();
}
/**
Open a new TCP socket.
Be sure to close any sockets you open - otherwise, you won't be able to open any new ones.
@param address The IP address to connect to - use the IP_ADDRESS macro if needed.
@param port The port to connect on.
@return A handle to the new socket, or -1 if it failed to connect.
\b Example
\code
int sock = tcpOpen(IP_ADDRESS(192, 168, 0, 210), 11101);
if (sock > -1) {
// then we got a good connection
// ...reading & writing...
tcpClose(sock); // make sure to close it if we connected
}
\endcode
*/
int tcpOpen(int address, int port)
{
int sock = lwip_socket(0, SOCK_STREAM, IPPROTO_TCP);
if (sock >= 0) {
struct sockaddr_in to = {
.sin_family = AF_INET,
.sin_addr.s_addr = address,
.sin_port = htons(port)
};
if (lwip_connect(sock, (const struct sockaddr*)&to, sizeof(to)) != 0) {
lwip_close(sock);
sock = -1;
}
}
return sock;
}
void buttonConnectPressed(void* source) {
struct sockaddr_in addr;
int ret;
((button_t*)source)->hasBeenAcknowledged = 1;
setStatus(CONNECTING);
if (!isConnected) {
memset(&addr, 0, sizeof(addr));
addr.sin_len = sizeof(addr);
addr.sin_family = AF_INET;
addr.sin_port = PP_HTONS(SOCK_TARGET_PORT);
addr.sin_addr.s_addr = inet_addr(SOCK_TARGET_HOST);
socket_in = lwip_socket(AF_INET, SOCK_STREAM, 0);
if ((ret = lwip_connect(socket_in, (struct sockaddr*)&addr, sizeof(addr))) == 0) {
isConnected = 1;
executeCommand(IDENT);
executeCommand(END_IDENT);
setStatus(CONNECTED);
}
else {
isConnected = 0;
setStatus(DISCONNECTED);
}
}
else {
if ((ret = lwip_close(socket_in)) == 0) {
setStatus(DISCONNECTED);
isConnected = 0;
resetBoards();
setVersion(NULL);
}
}
refreshBoards();
}
int32_t OsNetworkConnect(THandle aHandle, TIpAddress aAddress, uint16_t aPort, uint32_t aTimeoutMs)
{
if ( OsNetworkHandle_IsInterrupted(aHandle) )
return -1;
LOGFUNCIN();
struct sockaddr_in s;
s.sin_family = AF_INET;
s.sin_port = htons(aPort);
s.sin_addr.s_addr = aAddress;
int err;
setNonBlocking(aHandle, 1);
err = lwip_connect ( HANDLE_TO_SOCKET(aHandle), (struct sockaddr*) &s, sizeof(s) );
setNonBlocking(aHandle, 0);
if ( err == 0 )
return 0;
if ( errno != EINPROGRESS )
{
// error!
return -1;
}
if ( local_select(aHandle, LS_WRITE, aTimeoutMs) < 0 )
{
return -1;
}
LOGFUNCOUT();
return 0;
}
static void test_sockets_msgapi_udp(int domain)
{
int s, i, ret;
struct sockaddr_storage addr_storage;
socklen_t addr_size;
struct iovec riovs[4];
struct msghdr rmsg;
u8_t rcv_buf[4];
struct iovec siovs[4];
struct msghdr smsg;
u8_t snd_buf[4] = {0xDE, 0xAD, 0xBE, 0xEF};
/* initialize IO vectors with data */
for (i = 0; i < 4; i++) {
siovs[i].iov_base = &snd_buf[i];
siovs[i].iov_len = sizeof(u8_t);
riovs[i].iov_base = &rcv_buf[i];
riovs[i].iov_len = sizeof(u8_t);
}
test_sockets_init_loopback_addr(domain, &addr_storage, &addr_size);
s = test_sockets_alloc_socket_nonblocking(domain, SOCK_DGRAM);
fail_unless(s >= 0);
ret = lwip_bind(s, (struct sockaddr*)&addr_storage, addr_size);
fail_unless(ret == 0);
/* Update addr with epehermal port */
ret = lwip_getsockname(s, (struct sockaddr*)&addr_storage, &addr_size);
fail_unless(ret == 0);
switch(domain) {
#if LWIP_IPV6
case AF_INET6:
fail_unless(addr_size == sizeof(struct sockaddr_in6));
break;
#endif /* LWIP_IPV6 */
#if LWIP_IPV4
case AF_INET:
fail_unless(addr_size == sizeof(struct sockaddr_in));
break;
#endif /* LWIP_IPV6 */
default:
fail();
break;
}
/* send and receive the datagram in 4 pieces */
memset(&smsg, 0, sizeof(smsg));
smsg.msg_iov = siovs;
smsg.msg_iovlen = 4;
memset(&rmsg, 0, sizeof(rmsg));
rmsg.msg_iov = riovs;
rmsg.msg_iovlen = 4;
/* perform a sendmsg with remote host (self) */
smsg.msg_name = &addr_storage;
smsg.msg_namelen = addr_size;
test_sockets_msgapi_udp_send_recv_loop(s, &smsg, &rmsg);
/* Connect to self, allowing us to not pass message name */
ret = lwip_connect(s, (struct sockaddr*)&addr_storage, addr_size);
fail_unless(ret == 0);
smsg.msg_name = NULL;
smsg.msg_namelen = 0;
test_sockets_msgapi_udp_send_recv_loop(s, &smsg, &rmsg);
ret = lwip_close(s);
fail_unless(ret == 0);
}
/** This is an example function that tests
more than one thread being active in select. */
static void
sockex_testtwoselects(void *arg)
{
int s1;
int s2;
int ret;
struct sockaddr_in addr;
size_t len;
err_t lwiperr;
struct sockex_select_helper h1, h2, h3, h4;
LWIP_UNUSED_ARG(arg);
/* set up address to connect to */
memset(&addr, 0, sizeof(addr));
addr.sin_len = sizeof(addr);
addr.sin_family = AF_INET;
addr.sin_port = PP_HTONS(SOCK_TARGET_PORT);
addr.sin_addr.s_addr = inet_addr(SOCK_TARGET_HOST);
/* create the sockets */
s1 = lwip_socket(AF_INET, SOCK_STREAM, 0);
LWIP_ASSERT("s1 >= 0", s1 >= 0);
s2 = lwip_socket(AF_INET, SOCK_STREAM, 0);
LWIP_ASSERT("s2 >= 0", s2 >= 0);
/* connect, should succeed */
ret = lwip_connect(s1, (struct sockaddr*)&addr, sizeof(addr));
LWIP_ASSERT("ret == 0", ret == 0);
ret = lwip_connect(s2, (struct sockaddr*)&addr, sizeof(addr));
LWIP_ASSERT("ret == 0", ret == 0);
/* write the start of a GET request */
#define SNDSTR1 "G"
len = strlen(SNDSTR1);
ret = lwip_write(s1, SNDSTR1, len);
LWIP_ASSERT("ret == len", ret == (int)len);
ret = lwip_write(s2, SNDSTR1, len);
LWIP_ASSERT("ret == len", ret == (int)len);
h1.wait_read = 1;
h1.wait_write = 1;
h1.wait_err = 1;
h1.expect_read = 0;
h1.expect_write = 0;
h1.expect_err = 0;
lwiperr = sys_sem_new(&h1.sem, 0);
LWIP_ASSERT("lwiperr == ERR_OK", lwiperr == ERR_OK);
h1.socket = s1;
h1.wait_ms = 500;
h2 = h1;
lwiperr = sys_sem_new(&h2.sem, 0);
LWIP_ASSERT("lwiperr == ERR_OK", lwiperr == ERR_OK);
h2.socket = s2;
h2.wait_ms = 1000;
h3 = h1;
lwiperr = sys_sem_new(&h3.sem, 0);
LWIP_ASSERT("lwiperr == ERR_OK", lwiperr == ERR_OK);
h3.socket = s2;
h3.wait_ms = 1500;
h4 = h1;
lwiperr = sys_sem_new(&h4.sem, 0);
LWIP_ASSERT("lwiperr == ERR_OK", lwiperr == ERR_OK);
h4.socket = s2;
h4.wait_ms = 2000;
/* select: all sockets should time out if the other side is a good HTTP server */
sys_thread_new("sockex_select_waiter1", sockex_select_waiter, &h2, 0, 0);
sys_msleep(100);
sys_thread_new("sockex_select_waiter2", sockex_select_waiter, &h1, 0, 0);
sys_msleep(100);
sys_thread_new("sockex_select_waiter2", sockex_select_waiter, &h4, 0, 0);
sys_msleep(100);
sys_thread_new("sockex_select_waiter2", sockex_select_waiter, &h3, 0, 0);
sys_sem_wait(&h1.sem);
sys_sem_wait(&h2.sem);
sys_sem_wait(&h3.sem);
sys_sem_wait(&h4.sem);
/* close */
ret = lwip_close(s1);
LWIP_ASSERT("ret == 0", ret == 0);
ret = lwip_close(s2);
LWIP_ASSERT("ret == 0", ret == 0);
printf("sockex_testtwoselects finished successfully\n");
}
/** This is an example function that tests
blocking- and nonblocking connect. */
static void
sockex_nonblocking_connect(void *arg)
{
int s;
int ret;
u32_t opt;
struct sockaddr_in addr;
fd_set readset;
fd_set writeset;
fd_set errset;
struct timeval tv;
u32_t ticks_a, ticks_b;
int err;
LWIP_UNUSED_ARG(arg);
/* set up address to connect to */
memset(&addr, 0, sizeof(addr));
addr.sin_len = sizeof(addr);
addr.sin_family = AF_INET;
addr.sin_port = PP_HTONS(SOCK_TARGET_PORT);
addr.sin_addr.s_addr = inet_addr(SOCK_TARGET_HOST);
/* first try blocking: */
/* create the socket */
s = lwip_socket(AF_INET, SOCK_STREAM, 0);
LWIP_ASSERT("s >= 0", s >= 0);
/* connect */
ret = lwip_connect(s, (struct sockaddr*)&addr, sizeof(addr));
/* should succeed */
LWIP_ASSERT("ret == 0", ret == 0);
/* write something */
ret = lwip_write(s, "test", 4);
LWIP_ASSERT("ret == 4", ret == 4);
/* close */
ret = lwip_close(s);
LWIP_ASSERT("ret == 0", ret == 0);
/* now try nonblocking and close before being connected */
/* create the socket */
s = lwip_socket(AF_INET, SOCK_STREAM, 0);
LWIP_ASSERT("s >= 0", s >= 0);
/* nonblocking */
opt = lwip_fcntl(s, F_GETFL, 0);
LWIP_ASSERT("ret != -1", ret != -1);
opt |= O_NONBLOCK;
ret = lwip_fcntl(s, F_SETFL, opt);
LWIP_ASSERT("ret != -1", ret != -1);
/* connect */
ret = lwip_connect(s, (struct sockaddr*)&addr, sizeof(addr));
/* should have an error: "inprogress" */
LWIP_ASSERT("ret == -1", ret == -1);
err = errno;
LWIP_ASSERT("errno == EINPROGRESS", err == EINPROGRESS);
/* close */
ret = lwip_close(s);
LWIP_ASSERT("ret == 0", ret == 0);
/* try to close again, should fail with EBADF */
ret = lwip_close(s);
LWIP_ASSERT("ret == -1", ret == -1);
err = errno;
LWIP_ASSERT("errno == EBADF", err == EBADF);
printf("closing socket in nonblocking connect succeeded\n");
/* now try nonblocking, connect should succeed:
this test only works if it is fast enough, i.e. no breakpoints, please! */
/* create the socket */
s = lwip_socket(AF_INET, SOCK_STREAM, 0);
LWIP_ASSERT("s >= 0", s >= 0);
/* nonblocking */
opt = 1;
ret = lwip_ioctl(s, FIONBIO, &opt);
LWIP_ASSERT("ret == 0", ret == 0);
/* connect */
ret = lwip_connect(s, (struct sockaddr*)&addr, sizeof(addr));
/* should have an error: "inprogress" */
LWIP_ASSERT("ret == -1", ret == -1);
err = errno;
LWIP_ASSERT("errno == EINPROGRESS", err == EINPROGRESS);
/* write should fail, too */
ret = lwip_write(s, "test", 4);
LWIP_ASSERT("ret == -1", ret == -1);
err = errno;
LWIP_ASSERT("errno == EINPROGRESS", err == EINPROGRESS);
FD_ZERO(&readset);
FD_SET(s, &readset);
FD_ZERO(&writeset);
FD_SET(s, &writeset);
FD_ZERO(&errset);
FD_SET(s, &errset);
tv.tv_sec = 0;
tv.tv_usec = 0;
/* select without waiting should fail */
ret = lwip_select(s + 1, &readset, &writeset, &errset, &tv);
LWIP_ASSERT("ret == 0", ret == 0);
LWIP_ASSERT("!FD_ISSET(s, &writeset)", !FD_ISSET(s, &writeset));
LWIP_ASSERT("!FD_ISSET(s, &readset)", !FD_ISSET(s, &readset));
LWIP_ASSERT("!FD_ISSET(s, &errset)", !FD_ISSET(s, &errset));
FD_ZERO(&readset);
FD_SET(s, &readset);
FD_ZERO(&writeset);
FD_SET(s, &writeset);
FD_ZERO(&errset);
FD_SET(s, &errset);
ticks_a = sys_now();
/* select with waiting should succeed */
ret = lwip_select(s + 1, &readset, &writeset, &errset, NULL);
ticks_b = sys_now();
LWIP_ASSERT("ret == 1", ret == 1);
LWIP_ASSERT("FD_ISSET(s, &writeset)", FD_ISSET(s, &writeset));
LWIP_ASSERT("!FD_ISSET(s, &readset)", !FD_ISSET(s, &readset));
LWIP_ASSERT("!FD_ISSET(s, &errset)", !FD_ISSET(s, &errset));
/* now write should succeed */
ret = lwip_write(s, "test", 4);
LWIP_ASSERT("ret == 4", ret == 4);
/* close */
ret = lwip_close(s);
LWIP_ASSERT("ret == 0", ret == 0);
printf("select() needed %d ticks to return writable\n", ticks_b - ticks_a);
/* now try nonblocking to invalid address:
this test only works if it is fast enough, i.e. no breakpoints, please! */
/* create the socket */
s = lwip_socket(AF_INET, SOCK_STREAM, 0);
LWIP_ASSERT("s >= 0", s >= 0);
/* nonblocking */
opt = 1;
ret = lwip_ioctl(s, FIONBIO, &opt);
LWIP_ASSERT("ret == 0", ret == 0);
addr.sin_addr.s_addr++;
/* connect */
ret = lwip_connect(s, (struct sockaddr*)&addr, sizeof(addr));
/* should have an error: "inprogress" */
LWIP_ASSERT("ret == -1", ret == -1);
err = errno;
LWIP_ASSERT("errno == EINPROGRESS", err == EINPROGRESS);
/* write should fail, too */
ret = lwip_write(s, "test", 4);
LWIP_ASSERT("ret == -1", ret == -1);
err = errno;
LWIP_ASSERT("errno == EINPROGRESS", err == EINPROGRESS);
FD_ZERO(&readset);
FD_SET(s, &readset);
FD_ZERO(&writeset);
FD_SET(s, &writeset);
FD_ZERO(&errset);
FD_SET(s, &errset);
tv.tv_sec = 0;
tv.tv_usec = 0;
/* select without waiting should fail */
ret = lwip_select(s + 1, &readset, &writeset, &errset, &tv);
LWIP_ASSERT("ret == 0", ret == 0);
FD_ZERO(&readset);
FD_SET(s, &readset);
FD_ZERO(&writeset);
FD_SET(s, &writeset);
FD_ZERO(&errset);
FD_SET(s, &errset);
ticks_a = sys_now();
/* select with waiting should eventually succeed and return errset! */
ret = lwip_select(s + 1, &readset, &writeset, &errset, NULL);
ticks_b = sys_now();
LWIP_ASSERT("ret > 0", ret > 0);
LWIP_ASSERT("FD_ISSET(s, &errset)", FD_ISSET(s, &errset));
LWIP_ASSERT("!FD_ISSET(s, &readset)", !FD_ISSET(s, &readset));
LWIP_ASSERT("!FD_ISSET(s, &writeset)", !FD_ISSET(s, &writeset));
/* close */
ret = lwip_close(s);
LWIP_ASSERT("ret == 0", ret == 0);
printf("select() needed %d ticks to return error\n", ticks_b - ticks_a);
printf("all tests done, thread ending\n");
}
/** This is an example function that tests
the recv function (timeout etc.). */
static void
sockex_testrecv(void *arg)
{
int s;
int ret;
int err;
int opt;
struct sockaddr_in addr;
size_t len;
char rxbuf[1024];
fd_set readset;
fd_set errset;
struct timeval tv;
LWIP_UNUSED_ARG(arg);
/* set up address to connect to */
memset(&addr, 0, sizeof(addr));
addr.sin_len = sizeof(addr);
addr.sin_family = AF_INET;
addr.sin_port = PP_HTONS(SOCK_TARGET_PORT);
addr.sin_addr.s_addr = inet_addr(SOCK_TARGET_HOST);
/* first try blocking: */
/* create the socket */
s = lwip_socket(AF_INET, SOCK_STREAM, 0);
LWIP_ASSERT("s >= 0", s >= 0);
/* connect */
ret = lwip_connect(s, (struct sockaddr*)&addr, sizeof(addr));
/* should succeed */
LWIP_ASSERT("ret == 0", ret == 0);
/* set recv timeout (100 ms) */
opt = 100;
ret = lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &opt, sizeof(int));
LWIP_ASSERT("ret == 0", ret == 0);
/* write the start of a GET request */
#define SNDSTR1 "G"
len = strlen(SNDSTR1);
ret = lwip_write(s, SNDSTR1, len);
LWIP_ASSERT("ret == len", ret == (int)len);
/* should time out if the other side is a good HTTP server */
ret = lwip_read(s, rxbuf, 1);
LWIP_ASSERT("ret == -1", ret == -1);
err = errno;
LWIP_ASSERT("errno == EAGAIN", err == EAGAIN);
/* write the rest of a GET request */
#define SNDSTR2 "ET / HTTP_1.1\r\n\r\n"
len = strlen(SNDSTR2);
ret = lwip_write(s, SNDSTR2, len);
LWIP_ASSERT("ret == len", ret == (int)len);
/* wait a while: should be enough for the server to send a response */
sys_msleep(1000);
/* should not time out but receive a response */
ret = lwip_read(s, rxbuf, 1024);
LWIP_ASSERT("ret > 0", ret > 0);
/* now select should directly return because the socket is readable */
FD_ZERO(&readset);
FD_ZERO(&errset);
FD_SET(s, &readset);
FD_SET(s, &errset);
tv.tv_sec = 10;
tv.tv_usec = 0;
ret = lwip_select(s + 1, &readset, NULL, &errset, &tv);
LWIP_ASSERT("ret == 1", ret == 1);
LWIP_ASSERT("!FD_ISSET(s, &errset)", !FD_ISSET(s, &errset));
LWIP_ASSERT("FD_ISSET(s, &readset)", FD_ISSET(s, &readset));
/* should not time out but receive a response */
ret = lwip_read(s, rxbuf, 1024);
/* might receive a second packet for HTTP/1.1 servers */
if (ret > 0) {
/* should return 0: closed */
ret = lwip_read(s, rxbuf, 1024);
LWIP_ASSERT("ret == 0", ret == 0);
}
/* close */
ret = lwip_close(s);
LWIP_ASSERT("ret == 0", ret == 0);
printf("sockex_testrecv finished successfully\n");
}
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);
}
}
void net_connect_thread_entry(void *p)
{
int i,already_connected;
unsigned char *info = getServersInfo();
int servNum = RBIGU2(info);
if( !((getWorkingMode() == TCP_CLIENT) || (getWorkingMode() == TCP_AUTO)) )
return;
if( servNum == 0 )
return;
// Do some valid check.
if( servNum > MAX_SERVER_NUMBER )
{
rt_kprintf("Server number > %d, internal error!\n",MAX_SERVER_NUMBER);
return;
}
info += 2; // point to first url (if exists).
for( i = 0; i < servNum; i++ )
{
if( strlen((char*)info) >= URL_LEN )
{
rt_kprintf("url too long, internal error");
return;
}
info+=(URL_LEN+2);
}
// Now, we finished validation.
info = getServersInfo()+2; // re-point to first URL.
while(1)
{
int i,sock_index;
unsigned char *purl;
unsigned short port;
struct ip_addr ipaddr;
err_t err;
for( i = 0; i < servNum; i++ )
{
int optval;
int tmpsock;
struct sockaddr_in tmpaddr;
purl = info + i*(URL_LEN+PORT_LEN);
port = RBIGU2(purl+URL_LEN);
// check if ip address string such as "1.2.3.4"
ipaddr.addr = inet_addr((char*)purl);
if( ipaddr.addr != INADDR_NONE )
goto CONNECT;
// it may be an real url.
err = netconn_gethostbyname((char*)purl,&ipaddr);
if( err == ERR_OK )
goto CONNECT;
// now, we failed to get host by name.
continue;
CONNECT:
// first, we should check if we have already connected.
already_connected = 0;
for( sock_index = 0 ; sock_index < SOCKET_LIST_SIZE ; sock_index++ )
{
// we should wait here.
rt_mutex_take(&(socket_list[sock_index].mu_sock),RT_WAITING_FOREVER);
if( (socket_list[sock_index].used) &&
(ipaddr.addr == socket_list[sock_index].cliaddr.sin_addr.s_addr) &&
(htons(port) == socket_list[sock_index].cliaddr.sin_port) )
{
already_connected = 1;
rt_mutex_release(&(socket_list[sock_index].mu_sock));
break;
}
rt_mutex_release(&(socket_list[sock_index].mu_sock));
}
if( already_connected )
{
rt_kprintf("Already connected.\n");
continue;
}
// Now, we create a connection first.
// set keepalive.
optval = 1;
tmpsock = lwip_socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if( tmpsock < 0 )
{
rt_kprintf("Can not alloc socket!\n");
continue;
}
lwip_setsockopt(tmpsock,SOL_SOCKET,SO_KEEPALIVE,&optval,sizeof(optval));
tmpaddr.sin_family = AF_INET;
tmpaddr.sin_port = htons(port);
tmpaddr.sin_addr.s_addr = ipaddr.addr;
rt_memset(&(tmpaddr.sin_zero),0,sizeof(tmpaddr.sin_zero));
if (lwip_connect(tmpsock,(struct sockaddr *)&(tmpaddr),sizeof(tmpaddr)) == -1)
{
rt_kprintf("Connect error!\n");
lwip_close(tmpsock);
continue;
}
// connect successfully.
rt_kprintf("Connected to server OK\n");
// now we should find an empty slot to store the socket.
for( sock_index = 0 ; sock_index < SOCKET_LIST_SIZE ; sock_index++ )
{
// we don't wait here.
rt_err_t ret = rt_mutex_take(&(socket_list[sock_index].mu_sock),RT_WAITING_NO);
if( ret == -RT_ETIMEOUT )
continue;
// mutex has been taken.
if( socket_list[sock_index].used )
{
rt_mutex_release(&(socket_list[sock_index].mu_sock));
continue;
}
// it's an empty slot.
socket_list[sock_index].socket = tmpsock;
socket_list[sock_index].cliaddr = tmpaddr;
socket_list[sock_index].used = 1;
rt_mutex_release(&(socket_list[sock_index].mu_sock));
break;
}
// can not find any slot?
if( sock_index == SOCKET_LIST_SIZE )
{
rt_kprintf("No space to store socket, close!\n");
lwip_close(tmpsock);
}
} //for
//sleep for a while.
rt_thread_delay(RT_TICK_PER_SECOND*5);
} //while
}
/* ------------------------------------------------------------------------------------------------------
* sockex_nonblocking_connect()
*
* Description : tests socket blocking and nonblocking connect.
*
* Argument(s) : none.
*
*/
void sockex_nonblocking_connect(void *arg)
{
int ret;
struct sockaddr_in addr;
fd_set readset;
fd_set writeset;
fd_set errset;
struct timeval tv;
LWIP_UNUSED_ARG(arg);
memset(&addr, 0, sizeof(addr)); /* set up address to connect to */
addr.sin_len = sizeof(addr);
addr.sin_family = AF_INET;
addr.sin_port = PP_HTONS(SOCK_TARGET_PORT);
addr.sin_addr.s_addr = inet_addr(SOCK_TARGET_HOST);
socket_state = SOCKET_NEW;
for(;;)
{
if(g_bNetStatus == NETS_LOCIP) /* IP is setted.*/
{
switch(socket_state)
{
case SOCKET_NEW:
{
s = lwip_socket(AF_INET, SOCK_STREAM, 0);
socket_state = SOCKET_CON;
break;
}
case SOCKET_CON:
{
unsigned int ip;
ret = lwip_connect(s, (struct sockaddr*)&addr, sizeof(addr));
LWIP_ASSERT("ret == 0", ret == 0);
if(ret < 0)
{
lwip_close(s);
socket_state = SOCKET_NEW;
OSTimeDly(2);
RS232printf("socket connect failed.\n");
break;
}
ip = lwIPLocalIPAddrGet();
NetDisplayIPAddress(ip); /* Socket updata IP address.*/
socket_state = SOCKET_IDIE;
}
case SOCKET_IDIE:
{
INT8U *msg;
INT8U err;
msg = (INT8U *)OSMboxPend(NET_RfMbox, 0, &err); /* Waiting socket writing data.*/
if(err != OS_ERR_NONE)
break;
ret = lwip_write(s, msg, 6);
if(ret < 0)
{
lwip_close(s);
socket_state = SOCKET_CON;
}
}
break;
case SOCKET_CHECK:
// TODO: Check socket connecting.
FD_ZERO(&readset);
FD_SET(s, &readset);
FD_ZERO(&writeset);
FD_SET(s, &writeset);
FD_ZERO(&errset);
FD_SET(s, &errset);
tv.tv_sec = 3;
tv.tv_usec = 0; /* Set time out 3s, 函数立即返回*/
ret = lwip_select(s+1, &readset, &writeset, &errset, &tv);
if(ret == 0)
{
RS232printf("socket check timeout.\n");
lwip_close(s);
socket_state = SOCKET_CON; /* Reconnect socket.*/
}
if(FD_ISSET(s, &writeset) == 0) /* If socket couldn't write.*/
{
RS232printf("socket write test error.\n");
lwip_close(s);
socket_state = SOCKET_CON; /* Reconnect socket.*/
}
ret = lwip_write(s, "test", 6);
if(ret < 0)
{
lwip_close(s);
socket_state = SOCKET_CON;
}
OSTimeDly(2000);
break;
default:
break;
}
}
OSTimeDly(2);
}
}
static void test_sockets_msgapi_tcp(int domain)
{
#define BUF_SZ (TCP_SND_BUF/4)
#define TOTAL_DATA_SZ (BUF_SZ*8) /* ~(TCP_SND_BUF*2) that accounts for integer rounding */
#define NEED_TRAILER (BUF_SZ % 4 != 0)
int listnr, s1, s2, i, ret, opt;
int bytes_written, bytes_read;
struct sockaddr_storage addr_storage;
socklen_t addr_size;
struct iovec siovs[8];
struct msghdr smsg;
u8_t * snd_buf;
struct iovec riovs[5];
struct iovec riovs_tmp[5];
struct msghdr rmsg;
u8_t * rcv_buf;
int rcv_off;
int rcv_trailer = 0;
u8_t val;
test_sockets_init_loopback_addr(domain, &addr_storage, &addr_size);
listnr = test_sockets_alloc_socket_nonblocking(domain, SOCK_STREAM);
fail_unless(listnr >= 0);
s1 = test_sockets_alloc_socket_nonblocking(domain, SOCK_STREAM);
fail_unless(s1 >= 0);
/* setup a listener socket on loopback with ephemeral port */
ret = lwip_bind(listnr, (struct sockaddr*)&addr_storage, addr_size);
fail_unless(ret == 0);
ret = lwip_listen(listnr, 0);
fail_unless(ret == 0);
/* update address with ephemeral port */
ret = lwip_getsockname(listnr, (struct sockaddr*)&addr_storage, &addr_size);
fail_unless(ret == 0);
/* connect, won't complete until we accept it */
ret = lwip_connect(s1, (struct sockaddr*)&addr_storage, addr_size);
fail_unless(ret == -1);
fail_unless(errno == EINPROGRESS);
while (tcpip_thread_poll_one());
/* accept, creating the other side of the connection */
s2 = lwip_accept(listnr, NULL, NULL);
fail_unless(s2 >= 0);
/* double check s1 is connected */
ret = lwip_connect(s1, (struct sockaddr*)&addr_storage, addr_size);
fail_unless(ret == -1);
fail_unless(errno == EISCONN);
/* set s2 to non-blocking, not inherited from listener */
opt = lwip_fcntl(s2, F_GETFL, 0);
fail_unless(opt == 6);
opt = O_NONBLOCK;
ret = lwip_fcntl(s2, F_SETFL, opt);
fail_unless(ret == 0);
/* we are done with listener, close it */
ret = lwip_close(listnr);
fail_unless(ret == 0);
/* allocate a buffer for a stream of incrementing hex (0x00..0xFF) which we will use
to create an input vector set that is larger than the TCP's send buffer. This will
force execution of the partial IO vector send case */
snd_buf = (u8_t*)mem_malloc(BUF_SZ);
val = 0x00;
fail_unless(snd_buf != NULL);
for (i = 0; i < BUF_SZ; i++,val++) {
snd_buf[i] = val;
}
/* send the buffer 8 times in one message, equating to TOTAL_DATA_SZ */
for (i = 0; i < 8; i++) {
siovs[i].iov_base = snd_buf;
siovs[i].iov_len = BUF_SZ;
}
/* allocate a receive buffer, same size as snd_buf for easy verification */
rcv_buf = (u8_t*)mem_calloc(1, BUF_SZ);
fail_unless(rcv_buf != NULL);
/* split across iovs */
for (i = 0; i < 4; i++) {
riovs[i].iov_base = &rcv_buf[i*(BUF_SZ/4)];
riovs[i].iov_len = BUF_SZ/4;
}
/* handling trailing bytes if buffer doesn't evenly divide by 4 */
#if NEED_TRAILER
if ((BUF_SZ % 4) != 0) {
riovs[5].iov_base = &rcv_buf[4*(BUF_SZ/4)];
riovs[5].iov_len = BUF_SZ - (4*(BUF_SZ/4));
rcv_trailer = 1;
}
#endif /* NEED_TRAILER */
/* we use a copy of riovs since we'll be modifying base and len during
receiving. This gives us an easy way to reset the iovs for next recvmsg */
memcpy(riovs_tmp, riovs, sizeof(riovs));
memset(&smsg, 0, sizeof(smsg));
smsg.msg_iov = siovs;
smsg.msg_iovlen = 8;
memset(&rmsg, 0, sizeof(rmsg));
rmsg.msg_iov = riovs_tmp;
rmsg.msg_iovlen = (rcv_trailer ? 5 : 4);
bytes_written = 0;
bytes_read = 0;
rcv_off = 0;
while (bytes_written < TOTAL_DATA_SZ && (bytes_read < TOTAL_DATA_SZ)) {
/* send data */
if (bytes_written < TOTAL_DATA_SZ) {
ret = lwip_sendmsg(s1, &smsg, 0);
/* note: since we always receive after sending, there will be open
space in the send buffer */
fail_unless(ret > 0);
bytes_written += ret;
if (bytes_written < TOTAL_DATA_SZ) {
test_sockets_msgapi_update_iovs(&smsg, (size_t)ret);
}
}
while (tcpip_thread_poll_one());
/* receive and verify data */
do {
if (bytes_read < TOTAL_DATA_SZ) {
ret = lwip_recvmsg(s2, &rmsg, 0);
fail_unless(ret > 0 || (ret == -1 && errno == EWOULDBLOCK));
if (ret > 0) {
rcv_off += ret;
/* we have received a full buffer */
if (rcv_off == BUF_SZ) {
/* note: since iovs are just pointers, compare underlying buf */
fail_unless(!memcmp(snd_buf, rcv_buf, BUF_SZ));
bytes_read += BUF_SZ;
/* reset receive state for next buffer */
rcv_off = 0;
memset(rcv_buf, 0, BUF_SZ);
memcpy(riovs_tmp, riovs, sizeof(riovs));
rmsg.msg_iov = riovs_tmp;
rmsg.msg_iovlen = (rcv_trailer ? 5 : 4);
} else { /* partial read */
test_sockets_msgapi_update_iovs(&rmsg, (size_t)ret);
}
}
} else {
break;
}
} while(ret > 0);
}
ret = lwip_close(s1);
fail_unless(ret == 0);
ret = lwip_close(s2);
fail_unless(ret == 0);
mem_free(snd_buf);
mem_free(rcv_buf);
}
int WolfSSLConnection::connect(const char* host, const int port)
{
int result;
if(sslContext == NULL)
{
LogError("NULL SSL context\r\n");
result = __LINE__;
}
else
{
if (init_socket(SOCK_STREAM) < 0)
{
LogError("init_socket failed\r\n");
result = __LINE__;
}
else
{
if (set_address(host, port) != 0)
{
LogError("set_address failed\r\n");
result = __LINE__;
}
else if (lwip_connect(_sock_fd, (const struct sockaddr *) &_remoteHost, sizeof(_remoteHost)) < 0)
{
close();
LogError("lwip_connect failed\r\n");
result = __LINE__;
}
else
{
wolfSSL_SetIOSend(sslContext, &sendCallback);
wolfSSL_SetIORecv(sslContext, &receiveCallback);
ssl = wolfSSL_new(sslContext);
if(ssl == NULL)
{
LogError("wolfssl new error\r\n");
result = __LINE__;
}
else
{
wolfSSL_set_fd(ssl, _sock_fd);
result = wolfSSL_connect(ssl);
if (result != SSL_SUCCESS)
{
LogError("wolfssl connect error=%d\r\n", result);
result = __LINE__;
}
else
{
result = 0;
isConnected = true;
}
}
}
}
}
return result;
};
int connect(int s, const struct sockaddr *name, socklen_t namelen) {
BT_HANDLE hSocket = (BT_HANDLE)s;
return lwip_connect(hSocket->socket, name, namelen);
}
static void SC_Connect(__SYSCALL_PARAM_BLOCK* pspb)
{
pspb->lpRetValue = (LPVOID)lwip_connect((INT)PARAM(0),(const struct sockaddr *)PARAM(1),(socklen_t)PARAM(2));
}
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);
}
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);
}
