int Socket::WaitForConnect()
{
lwip_fd_set fds;
struct timeval tmo;
int error;
socklen_t len = sizeof(error);
LWIP_FD_ZERO(&fds);
LWIP_FD_SET(socket_->fd, &fds);
tmo.tv_sec = 5;
tmo.tv_usec = 0;
//log(LOG_WARN) << "waiting";
if ( lwip_select(socket_->fd+1, NULL, &fds, NULL, &tmo) <= 0)
{
return -1;
}
if ( lwip_getsockopt(socket_->fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0 ||
error > 0 )
{
return -1;
}
return 0;
}
int LWIP_SOCKETS_Driver::GetSockOpt( SOCK_SOCKET socket, int level, int optname, char* optval, int* optlen )
{
NATIVE_PROFILE_PAL_NETWORK();
int nativeLevel;
int nativeOptionName;
char* pNativeOptval = optval;
int ret;
switch(level)
{
case SOCK_IPPROTO_IP:
nativeLevel = IPPROTO_IP;
nativeOptionName = GetNativeIPOption(optname);
break;
case SOCK_IPPROTO_TCP:
nativeLevel = IPPROTO_TCP;
nativeOptionName = GetNativeTcpOption(optname);
break;
case SOCK_IPPROTO_UDP:
case SOCK_IPPROTO_ICMP:
case SOCK_IPPROTO_IGMP:
case SOCK_IPPROTO_IPV4:
case SOCK_SOL_SOCKET:
nativeLevel = SOL_SOCKET;
nativeOptionName = GetNativeSockOption(optname);
break;
default:
nativeLevel = level;
nativeOptionName = optname;
break;
}
ret = lwip_getsockopt(socket, nativeLevel, nativeOptionName, pNativeOptval, (u32_t*)optlen);
if(ret == 0)
{
switch(level)
{
case SOCK_SOL_SOCKET:
switch(optname)
{
case SOCK_SOCKO_EXCLUSIVEADDRESSUSE:
case SOCK_SOCKO_DONTLINGER:
*optval = !(*(int*)optval != 0);
break;
case SOCK_SOCKO_ACCEPTCONNECTION:
case SOCK_SOCKO_BROADCAST:
case SOCK_SOCKO_KEEPALIVE:
*optval = (*(int*)optval != 0);
break;
}
break;
}
}
return ret;
}
void SoAd_SocketStatusCheck(uint16 sockNr, int sockHandle)
{
int sockErr;
socklen_t sockErrLen = sizeof(sockErr);
lwip_getsockopt(sockHandle, SOL_SOCKET, SO_ERROR, &sockErr, &sockErrLen);
if ((sockErr != 0) && (sockErr != EWOULDBLOCK)) {
SoAd_SocketClose(sockNr);
}
}
static void SC_GetSocketOpt(__SYSCALL_PARAM_BLOCK* pspb)
{
pspb->lpRetValue = (LPVOID)lwip_getsockopt(
(INT)PARAM(0),
(int)PARAM(1),
(int)PARAM(2),
(void*)PARAM(3),
(socklen_t*)PARAM(4)
);
}
int32_t MTD_FLASHMEM Socket::getLastError() {
int32_t r = 0;
socklen_t l = sizeof(int32_t);
lwip_getsockopt(m_socket, SOL_SOCKET, SO_ERROR, (void *)&r, &l);
return r;
}
int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen) {
BT_HANDLE hSocket = (BT_HANDLE)s;
return lwip_getsockopt(hSocket->socket, level, optname, optval, optlen);
}
int getsockopt(int sockfd, int level, int optname,
void *optval, socklen_t *optlen)
{
int sock = socket_for_fd(sockfd);
return lwip_getsockopt(sock, level, optname, optval, optlen);
}
int zts_getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlen)
{
return (!_run_service || !_run_lwip_tcpip) ? ZTS_ERR_SERVICE : lwip_getsockopt(fd, level, optname, optval, optlen);
}
/** 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, opt2;
socklen_t opt2size;
struct sockaddr_in addr;
size_t len;
char rxbuf[SOCK_TARGET_MAXHTTPPAGESIZE];
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);
opt2 = 0;
opt2size = sizeof(opt2);
ret = lwip_getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &opt2, &opt2size);
LWIP_ASSERT("ret == 0", ret == 0);
LWIP_ASSERT("opt2size == sizeof(opt2)", opt2size == sizeof(opt2));
LWIP_ASSERT("opt == opt2", opt == opt2);
/* 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, SOCK_TARGET_MAXHTTPPAGESIZE);
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, SOCK_TARGET_MAXHTTPPAGESIZE);
/* might receive a second packet for HTTP/1.1 servers */
if (ret > 0) {
/* should return 0: closed */
ret = lwip_read(s, rxbuf, SOCK_TARGET_MAXHTTPPAGESIZE);
LWIP_ASSERT("ret == 0", ret == 0);
}
/* close */
ret = lwip_close(s);
LWIP_ASSERT("ret == 0", ret == 0);
printf("sockex_testrecv finished successfully\n");
}
