char *telnet_logincmd(char *cmd,int len,struct vdehiststat *st)
{
int histstatus=vdehist_getstatus(st);
int termfd=vdehist_gettermfd(st);
switch (histstatus) {
case HIST_NOCMD:
while (cmd[len-1] == '\n')
cmd[--len]=0;
if (strcmp(cmd,"admin") != 0) {
lwip_write(termfd,"login incorrect\r\n\r\nLogin: "******"Password: "******"\r\nlogin incorrect\r\n\r\nPassword: "******"logout";
} else {
int newfn;
int flags;
int mgmtfd;
vdehist_setstatus(st,HIST_COMMAND);
mgmtfd=openextravdem();
if (mgmtfd >= 0) {
vdehist_setmgmtfd(st,mgmtfd);
flags = fcntl(mgmtfd, F_GETFL);
flags |= O_NONBLOCK;
fcntl(mgmtfd, F_SETFL, flags);
newfn=addpfd(mgmtfd,telnet_vdedata);
status[newfn]=st;
} else
return "logout";
lwip_write(termfd,"\r\n",2);
lwip_write(termfd,prompt,strlen(prompt));
}
}
return NULL;
}
int zts_write(int fd, const void *buf, size_t len)
{
if (!buf || len <= 0) {
return ZTS_ERR_INVALID_ARG;
}
return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_write(fd, buf, len);
}
int write(int fd, const void *buf, size_t nbytes)
{
if (fd < 0 || fd >= NOFILE) {
fd = EBADF;
return -1;
}
switch (files[fd].type) {
case FTYPE_SAVEFILE: {
int ret = 0, tot = nbytes;
while (nbytes > 0) {
ret = xencons_ring_send(files[fd].cons.dev, (char *)buf, nbytes);
nbytes -= ret;
buf = (char *)buf + ret;
}
return tot - nbytes;
}
case FTYPE_CONSOLE:
console_print(files[fd].cons.dev, (char *)buf, nbytes);
return nbytes;
#ifdef HAVE_LWIP
case FTYPE_SOCKET:
return lwip_write(files[fd].socket.fd, (void*) buf, nbytes);
#endif
case FTYPE_TAP:
netfront_xmit(files[fd].tap.dev, (void*) buf, nbytes);
return nbytes;
default:
break;
}
printk("write(%d): Bad descriptor\n", fd);
errno = EBADF;
return -1;
}
static void SC_Write(__SYSCALL_PARAM_BLOCK* pspb)
{
pspb->lpRetValue = (LPVOID)lwip_write(
(INT)PARAM(0),
(const void*)PARAM(1),
(size_t)PARAM(2)
);
}
void telnetaccept(int fn,int fd,int vdefd)
{
struct sockaddr_in cli_addr;
int newsockfd;
unsigned int clilen;
int newfn;
clilen = sizeof(cli_addr);
newsockfd = lwip_accept(fd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0) {
printlog(LOG_ERR,"telnet accept err: %s",strerror(errno));
}
newfn=addpfd(newsockfd,telnetdata);
status[newfn]=vdehist_new(newsockfd,-1);
lwip_write(newsockfd,banner,strlen(banner));
lwip_write(newsockfd,"\r\nLogin: ",9);
}
/* dynamically generate 404 response:
* this inserts the original request string in betwween the notfound_header & footer strings
*/
int do_404(int sd, char *req, int rlen)
{
int len, hlen;
int BUFSIZE = 1024;
char buf[BUFSIZE];
len = strlen(notfound_header) + strlen(notfound_footer) + rlen;
hlen = generate_http_header(buf, "html", len);
if (lwip_write(sd, buf, hlen) != hlen) {
xil_printf("error writing http header to socket\r\n");
xil_printf("http header = %s\n\r", buf);
return -1;
}
lwip_write(sd, notfound_header, strlen(notfound_header));
lwip_write(sd, req, rlen);
lwip_write(sd, notfound_footer, strlen(notfound_footer));
return 0;
}
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 do_http_post(int sd, char *req, int rlen)
{
int BUFSIZE = 1024;
char buf[BUFSIZE];
int len = 0, n;
char *p;
if (lwip_write(sd, buf, len) != len) {
//xil_printf("error writing http POST response to socket\r\n");
//xil_printf("http header = %s\r\n", buf);
return -1;
}
return 0;
}
int lwip_writev(int s, struct iovec *vector, int count)
{
int totsize=0;
int i;
int pos;
char *temp_buf;
int ret;
/* Check for invalid parameter */
if (count < 0 || count > UIO_MAXIOV) {
set_errno(EINVAL);
return -1;
}
/* FIX: check overflow of totsize and set EINVAL */
for (i=0; i<count; i++)
totsize += vector[i].iov_len;
LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_writev(%d, %p, %d), iovec totlen=$d\n", s, vector, count, totsize));
if (totsize == 0)
return 0;
temp_buf = mem_malloc(totsize);
if (temp_buf == NULL) {
set_errno(ENOMEM);
return -1;
}
/* Copy in iovec buffers in the private buffer */
i = 0;
pos = 0;
while (pos < totsize) {
memcpy( &temp_buf[pos], vector[i].iov_base, vector[i].iov_len);
i++;
pos += vector[i].iov_len;
}
ret = lwip_write(s, temp_buf, totsize);
mem_free(temp_buf);
return ret;
}
int write(int fd, const void *buf, size_t nbytes)
{
switch (files[fd].type) {
case FTYPE_SAVEFILE: {
int ret = 0, tot = nbytes;
while (nbytes > 0) {
ret = xencons_ring_send(files[fd].cons.dev, (char *)buf, nbytes);
nbytes -= ret;
buf = (char *)buf + ret;
}
return tot - nbytes;
}
case FTYPE_CONSOLE:
console_print(files[fd].cons.dev, (char *)buf, nbytes);
return nbytes;
#ifdef HAVE_LWIP
case FTYPE_SOCKET:
return lwip_write(files[fd].socket.fd, (void*) buf, nbytes);
#endif
#ifdef CONFIG_NETFRONT
case FTYPE_TAP:
netfront_xmit(files[fd].tap.dev, (void*) buf, nbytes);
return nbytes;
#endif
#ifdef CONFIG_BLKFRONT
case FTYPE_BLK:
return blkfront_posix_write(fd, buf, nbytes);
#endif
#ifdef CONFIG_TPMFRONT
case FTYPE_TPMFRONT:
return tpmfront_posix_write(fd, buf, nbytes);
#endif
#ifdef CONFIG_TPM_TIS
case FTYPE_TPM_TIS:
return tpm_tis_posix_write(fd, buf, nbytes);
#endif
default:
break;
}
printk("write(%d): Bad descriptor\n", fd);
errno = EBADF;
return -1;
}
BST_IP_ERR_T BST_IP_BsdSend( BST_FD_T fd, BST_UINT8* pData, BST_UINT16 usLength )
{
BST_INT32 lRtnVal;
if( !BST_IP_IsBsdFdValid(fd) )
{
return BST_IP_ERR_MEM;
}
if( BST_NULL_PTR == pData )
{
return BST_IP_ERR_MEM;
}
lRtnVal = (BST_IP_ERR_T)lwip_write( fd.lFd, pData, usLength );
if (lRtnVal < 0)
{
BST_RLS_LOG1( "BST_IP_BsdSend Err No. is %d", lRtnVal );
return lRtnVal;
}
return BST_IP_ERR_OK;
}
static msg_t socket_stream_put(void *ip, uint8_t b) {
return lwip_write(((SocketStream*) ip)->fd, &b, sizeof(b));
}
/**************************************************************
* void chargen_thread(void *arg)
*
* chargen task. This server will wait for connections on well
* known TCP port number: 19. For every connection, the server will
* write as much data as possible to the tcp port.
**************************************************************/
static void chargen_thread(void *arg)
{
int listenfd;
struct sockaddr_in chargen_saddr;
fd_set readset;
fd_set writeset;
int i, maxfdp1;
struct charcb *p_charcb;
/* First acquire our socket for listening for connections */
listenfd = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
LWIP_ASSERT("chargen_thread(): Socket create failed.", listenfd >= 0);
memset(&chargen_saddr, 0, sizeof(chargen_saddr));
chargen_saddr.sin_family = AF_INET;
chargen_saddr.sin_addr.s_addr = htonl(INADDR_ANY);
chargen_saddr.sin_port = htons(19); // Chargen server port
if (lwip_bind(listenfd, (struct sockaddr *) &chargen_saddr, sizeof(chargen_saddr)) == -1)
LWIP_ASSERT("chargen_thread(): Socket bind failed.", 0);
/* Put socket into listening mode */
if (lwip_listen(listenfd, MAX_SERV) == -1)
LWIP_ASSERT("chargen_thread(): Listen failed.", 0);
/* Wait forever for network input: This could be connections or data */
for (;;) {
maxfdp1 = listenfd+1;
/* Determine what sockets need to be in readset */
FD_ZERO(&readset);
FD_ZERO(&writeset);
FD_SET(listenfd, &readset);
for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next) {
if (maxfdp1 < p_charcb->socket + 1)
maxfdp1 = p_charcb->socket + 1;
FD_SET(p_charcb->socket, &readset);
FD_SET(p_charcb->socket, &writeset);
}
/* Wait for data or a new connection */
i = lwip_select(maxfdp1, &readset, &writeset, 0, 0);
if (i == 0) continue;
/* At least one descriptor is ready */
if (FD_ISSET(listenfd, &readset)) {
/* We have a new connection request!!! */
/* Lets create a new control block */
p_charcb = (struct charcb *)rt_calloc(1, sizeof(struct charcb));
if (p_charcb) {
p_charcb->socket = lwip_accept(listenfd,
(struct sockaddr *) &p_charcb->cliaddr,
&p_charcb->clilen);
if (p_charcb->socket < 0)
rt_free(p_charcb);
else {
/* Keep this tecb in our list */
p_charcb->next = charcb_list;
charcb_list = p_charcb;
p_charcb->nextchar = 0x21;
}
} else {
/* No memory to accept connection. Just accept and then close */
int sock;
struct sockaddr cliaddr;
socklen_t clilen;
sock = lwip_accept(listenfd, &cliaddr, &clilen);
if (sock >= 0)
lwip_close(sock);
}
}
/* Go through list of connected clients and process data */
for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next) {
if (FD_ISSET(p_charcb->socket, &readset)) {
/* This socket is ready for reading. This could be because someone typed
* some characters or it could be because the socket is now closed. Try reading
* some data to see. */
if (do_read(p_charcb) < 0)
break;
}
if (FD_ISSET(p_charcb->socket, &writeset)) {
char line[80];
char setchar = p_charcb->nextchar;
for( i = 0; i < 59; i++) {
line[i] = setchar;
if (++setchar == 0x7f)
setchar = 0x21;
}
line[i] = 0;
strcat(line, "\n\r");
if (lwip_write(p_charcb->socket, line, strlen(line)) < 0) {
close_chargen(p_charcb);
break;
}
if (++p_charcb->nextchar == 0x7f)
p_charcb->nextchar = 0x21;
}
}
}
}
/* ------------------------------------------------------------------------------------------------------
* 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);
}
}
/* respond for a file GET request */
int do_http_get(int sd, char *req, int rlen) {
char *response;
size_t response_size;
FILE *stream = open_memstream(&response, &response_size);
/* *****************
* HTTP header
* *****************/
char http_header[1024]; // Chose this size randomly, it's more than enough
generate_http_header(http_header, "html", 0);
fprintf(stream, "%s", http_header);
/* *****************
* HTML head
* *****************/
fprintf(stream, "<HTML>\n");
fprintf(stream, "<HEAD>\n");
fprintf(stream, "<META HTTP-EQUIV=""refresh"" CONTENT=""10; URL=192.168.1.99"">\n");
fprintf(stream, "<STYLE>\n");
fprintf(stream, "table, th, td { border: 1px solid black; border-collapse: collapse; }\n");
fprintf(stream, "th, td { padding: 4px; }\n");
fprintf(stream, "</STYLE>\n");
fprintf(stream, "</HEAD>\n");
/* ***********************
* System status
* ***********************/
char *pagefmt = "<BODY>\n<CENTER><B>Xilinx VC707 System Status (10 s refresh)</B></CENTER><BR>\n"
"Uptime: %d s<BR>"
"Temperature = %0.1f C<BR>\n"
"INT Voltage = %0.1f V<BR>\n"
"AUX Voltage = %0.1f V<BR>\n"
"BRAM Voltage = %0.1f V<BR>\n<HR>";
fprintf(stream,pagefmt,procStatus.uptime,procStatus.v7temp,procStatus.v7vCCINT,procStatus.v7vCCAUX,procStatus.v7vBRAM);
#ifdef POLL_UPOD_TEMPS
/* *******************
* uPod status
* *******************/
fprintf(stream, "<CENTER><B>uPod Status</B></CENTER><BR>\n");
generate_upod_table(stream);
fprintf(stream, "<HR>\n");
#endif
/* *******************
* Bit error rates
* *******************/
fprintf(stream, "<CENTER><B>Eyescan Data</B></CENTER><BR>\n");
int ch_to_display = parse_channel(req);
generate_central_ber_table(stream, ch_to_display);
fprintf(stream, "<br><br>\n");
fprintf(stream, "<form action=\"\" method=\"get\"> View Channel: <input type=\"text\" size=3 name=\"ch\" value=\"%d\"> <input type=\"submit\" value=\"Submit\"><br>", ch_to_display);
fprintf(stream, "<br><br>\n");
generate_eyescan_table(stream, ch_to_display);
fprintf(stream, "<HR>\n");
/* ***********************
* Close HTML, send data
* ***********************/
fprintf(stream,"</BODY>\n</HTML>\n");
fflush(stream);
// xil_printf("%s\n", response); //DEBUG
int w;
if ((w = lwip_write(sd, response, response_size)) < 0 ) {
xil_printf("error writing web page to socket\r\n");
xil_printf("attempted to lwip_write %d bytes, actual bytes written = %d\r\n", response_size, w);
return -4;
}
fclose(stream);
free(response);
return 0;
}
int write(int s, const void *dataptr, size_t size) {
BT_HANDLE hSocket = (BT_HANDLE)s;
return lwip_write(hSocket->socket, dataptr, size);
}
int socket_write(int sock, const void* buf, size_t length)
{
return lwip_write(sock, buf, length);
}
/** 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");
}
static size_t socket_stream_write(void *ip, const uint8_t *bp, size_t n) {
return lwip_write(((SocketStream*) ip)->fd, bp, n);
}
/** 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");
}
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);
}
