/*----------------------------------------------------------------------*
rtp_net_is_connected
*----------------------------------------------------------------------*/
unsigned rtp_net_is_connected (RTP_SOCKET sockHandle)
{
struct sockaddr_in peerAddr;
int peerLen;
#ifdef DO_IFACE_CHECK
while (IP_IFaceIsReady() == 0) {
OS_Delay(100);
}
#endif
peerLen = sizeof(peerAddr);
memset(&peerAddr, 0, peerLen);
if (getpeername ((int) sockHandle, (struct sockaddr *) &peerAddr, &peerLen) == 0)
{
/* this is necessary but not sufficient; now check to make sure the other
side hasn't shutdown sending data to us */
fd_set tempSet;
long selectTime=0;
int result;
IP_FD_ZERO(&tempSet);
IP_FD_SET((int) sockHandle, &tempSet);
// check the socket for ready-to-read
result = select(&tempSet, 0, 0, selectTime);
if (result != -1)
{
unsigned char tempBuffer[1];
if (!IP_FD_ISSET((int) sockHandle, &tempSet))
{
// if we would block, then there is no problem; if the other
// side has shut down its end of the connection, we would
// return immediately with an error code
return (1);
}
// find out whether this means that:
// 1. there is data in the buffer from the other side
// 2. the connection has been closed
result = recv ((int) sockHandle, tempBuffer, 1, MSG_PEEK);
if (result == 1)
{
// there is data
return (1);
}
if (result == -1)
{
return (1);
}
}
}
return (0);
}
void _fd_set_to_rtp (RTP_FD_SET *rtp, fd_set *set)
{
int index;
rtp->fdCount = 0;
/* This could definitely be optimized by making it less portable and using
fd_set->__fds_bits. */
for (index = 0; index < FD_SETSIZE && rtp->fdCount < RTP_FD_SET_MAX; index++)
{
if (IP_FD_ISSET (index, set))
{
rtp->fdArray[rtp->fdCount] = index;
rtp->fdCount++;
}
}
}
/*
*===========================================================================
* ipl2tps
*===========================================================================
* Description:
* Parameters:
* Returns:
*
*/
IP_STATIC
IPCOM_PROCESS(ipl2tps)
{
Ip_fd ipd_fd = IP_INVALID_SOCKET;
Ip_bool ipd_init = 0;
#ifdef IPPPP_USE_PPPL2TP
Ip_fd ipl2tp_ppp_ipc_recv_fd = IP_INVALID_SOCKET;
#endif
ipcom_proc_init();
#ifdef IPPPP_USE_PPPL2TP
if ((ipl2tp_ppp_ipc_recv_fd = ipppp_pppl2tp_pkt_que_open()) == IP_INVALID_SOCKET)
{
ipcom_printf("Cannot allocate data packet output socket, errno: %d"IP_LF, ipcom_errno);
goto leave;
}
#endif
/* Get socket */
if ((udp_fd = ipcom_socket(IP_AF_INET, IP_SOCK_DGRAM, IP_IPPROTO_UDP)) < 0)
{
ipcom_printf("Cannot allocate socket, errno: %d"IP_LF,
ipcom_errno);
goto leave;
}
else
{
union Ip_sockaddr_union uaddr;
/* Bind to L2TP port */
ipcom_memset(&uaddr, 0, sizeof(uaddr));
uaddr.sin.sin_family = IP_AF_INET;
uaddr.sin.sin_addr.s_addr = IP_INADDR_ANY;
uaddr.sin.sin_port = ip_htons(IPL2TP_PORT_NUMBER);
uaddr.sin.sin_len = sizeof(struct Ip_sockaddr_in);
if (ipcom_bind(udp_fd, &uaddr.sa, sizeof(struct Ip_sockaddr_in)) < 0)
{
ipcom_printf("Cannot bind socket, errno: %d"IP_LF,
ipcom_errno);
ipcom_socketclose(udp_fd);
goto leave;
}
}
/* Get socket */
if ((ip_fd = ipcom_socket(IP_AF_INET, IP_SOCK_RAW, IP_IPPROTO_L2TP)) < 0)
{
ipcom_printf("Cannot allocate socket, errno: %d"IP_LF,
ipcom_errno);
ipcom_socketclose(udp_fd);
goto leave;
}
/* Init IPD */
if (ipd_init == 0 &&
ipcom_ipd_init("ipl2tp", IPCOM_SUCCESS, &ipd_fd) != IPCOM_SUCCESS)
{
ipcom_printf("Cannot initialize ipd: %s"IP_LF,
ipcom_strerror(ipcom_errno));
goto leave;
}
ipd_init = 1;
/* Enter read loop (never return) */
for (;;)
{
Ip_fd_set fds;
Ipl2tp_example_fd_entry_t *fd;
int fd_max;
struct Ip_timeval tv;
int ret;
IP_FD_ZERO(&fds);
IP_FD_SET(udp_fd, &fds);
IP_FD_SET(ip_fd, &fds);
IP_FD_SET(ipd_fd, &fds);
fd_max = IP_MAX(udp_fd, ip_fd);
fd_max = IP_MAX(fd_max, ipd_fd);
#ifdef IPPPP_USE_PPPL2TP
IP_FD_SET(ipl2tp_ppp_ipc_recv_fd, &fds);
fd_max = IP_MAX(fd_max, ipl2tp_ppp_ipc_recv_fd);
#endif
fd = IPCOM_LIST_FIRST(&ipl2tp_example_fds);
while (fd != IP_NULL)
{
Ipl2tp_example_fd_entry_t *nfd = IPCOM_LIST_NEXT(&fd->next);
if (fd->data != IP_NULL)
{
IP_FD_SET(fd->fd, &fds);
fd_max = IP_MAX(fd_max, fd->fd);
}
else
{
ipcom_list_remove(&fd->next);
ipcom_socketclose(fd->fd);
ipcom_free(fd);
}
fd = nfd;
}
tv.tv_sec = 0;
tv.tv_usec = 10000;
if ((ret = ipcom_socketselect(fd_max + 1, &fds, IP_NULL, IP_NULL, &tv)) > 0)
{
union Ip_sockaddr_union uaddr;
int length;
Ip_u8 *buffer;
if (IP_FD_ISSET(ipd_fd, &fds))
{
int event;
event = ipcom_ipd_input(ipd_fd);
if (event == IPCOM_IPD_EVENT_RECONFIGURE)
goto leave;
}
#ifdef IPPPP_USE_PPPL2TP
if (IP_FD_ISSET(ipl2tp_ppp_ipc_recv_fd, &fds))
{
Ipppp_pppl2tp_pkt_que_entry que_entry;
Ipcom_netif *netif;
Ipcom_pkt *pkt;
char addrstr[IP_INET_ADDRSTRLEN];
/* Read message and feed it to L2TP main input */
if (ipppp_pppl2tp_pkt_que_recv(&que_entry, &uaddr) == IPCOM_SUCCESS)
{
if ((que_entry.netif == IP_NULL) ||
(que_entry.pkt == IP_NULL))
{
ipcom_printf("ipl2tps: L2TPv2 pkt from %s:%d contains null ptr(s)."IP_LF,
ipcom_inet_ntop(IP_AF_INET, &uaddr.sin.sin_addr, addrstr, sizeof(addrstr)),
ipcom_ntohs(uaddr.sin.sin_port));
}
else
{
pkt = que_entry.pkt;
netif = que_entry.netif;
ipppp_pppl2tp_output(netif, pkt);
}
}
else
ipcom_printf("ipl2tps: PPP pkt recv failed."IP_LF);
}
#endif /* IPPPP_USE_PPPL2TP */
if (IP_FD_ISSET(udp_fd, &fds))
{
/* Read message and feed it to L2TP main input */
if ((length = ipl2tp_l2tp_read(udp_fd, &buffer, &uaddr)) > 0)
{
ipl2tp_api_l2tp_input(buffer,
buffer + HEADER_SPACE,
(Ip_u16)length,
&uaddr,
IPL2TP_ATTR_TRANSPORT_UDP);
/* Free buffer if not in PPP output queue */
if (ipl2tp_buffer_free)
{
ipl2tp_cache_free(buffer);
}
}
}
if (IP_FD_ISSET(ip_fd, &fds))
{
/* Read message and feed it to L2TP main input */
if ((length = ipl2tp_l2tp_read(ip_fd, &buffer, &uaddr)) > 0)
{
/* Remove the IP header before invoking */
ipl2tp_api_l2tp_input(buffer,
buffer + HEADER_SPACE + 20,
(Ip_u16)(length - 20),
&uaddr,
IPL2TP_ATTR_TRANSPORT_IP);
/* Free buffer if not in PPP output queue */
if (ipl2tp_buffer_free)
{
ipl2tp_cache_free(buffer);
}
}
}
fd = IPCOM_LIST_FIRST(&ipl2tp_example_fds);
while (fd != IP_NULL)
{
Ipl2tp_example_fd_entry_t *nfd = IPCOM_LIST_NEXT(&fd->next);
if (fd->data!= IP_NULL && IP_FD_ISSET(fd->fd, &fds))
{
/* Read message and feed it to L2TP main input */
if ((length = ipl2tp_l2tp_read(fd->fd, &buffer, &uaddr)) > 0)
{
if (fd->data != IP_NULL)
{
(*fd->data) (fd,
buffer,
buffer + HEADER_SPACE,
length);
}
/* Free buffer if not in PPP output queue */
if (ipl2tp_buffer_free)
{
ipl2tp_cache_free(buffer);
}
}
}
fd = nfd;
}
}
else if (ret < 0)
{
ipcom_printf("select error"IP_LF);
}
}
leave:
/* Have to call ipd init if not done yet */
if (ipd_init == 0 &&
ipcom_ipd_init("ipl2tp", IPCOM_ERR_FAILED, &ipd_fd) == IPCOM_SUCCESS)
{
ipd_init = 1;
}
if (ipd_init != 0)
{
(void)ipcom_ipd_exit("ipl2tp", ipd_fd);
}
ipcom_proc_exit();
}
/*
*===========================================================================
* ipcom_cmd_sockperf_run
*===========================================================================
* Description: Sends/receives data.
* Parameters:
* Returns:
*/
IP_STATIC void
ipcom_cmd_sockperf_run(Ipcom_cmd_sockperf_t *cmd)
{
struct Ip_timeval tmo = { 0, 0 };
struct Ip_timeval *ptmo;
struct Ip_timeval start;
struct Ip_timeval stop;
Ip_u32 i;
Ip_u32 c;
int num_ready;
Ip_fd *s = cmd->sock_array;
Ip_u32 total_bytes_to_send = cmd->num_buf * cmd->buf_len;
Ip_u32 finished_sockets = 0;
Ip_u32 total_bytes_read = 0;
Ip_ssize_t bytes;
Ip_fd_set read_set;
int send_flags = (cmd->transmit && cmd->receive) ? IP_MSG_DONTWAIT : 0;
if (cmd->transmit)
ipcom_printf("sockperf-t: send buffer is %u"IP_LF, cmd->sendbuf_size);
if (cmd->receive)
ipcom_printf("sockperf-r: receive buffer is %u"IP_LF, cmd->sendbuf_size);
for (i = 0; i < cmd->num_sock; i++)
{
int on = 1;
if (ipcom_setsockopt(s[i],
IP_SOL_SOCKET,
IP_SO_REUSEADDR,
&on,
sizeof(on)) < 0)
{
ipcom_printf("sockperf-c: setsockopt IP_SO_REUSEADDR failed : %s"IP_LF,
ipcom_strerror(ipcom_errno));
return;
}
if (ipcom_setsockopt(s[i],
IP_SOL_SOCKET,
IP_SO_SNDBUF,
&cmd->sendbuf_size,
sizeof(cmd->sendbuf_size)) < 0)
{
ipcom_printf("sockperf-c: setsockopt IP_SO_SNDBUF failed : %s"IP_LF,
ipcom_strerror(ipcom_errno));
return;
}
if (ipcom_setsockopt(s[i],
IP_SOL_SOCKET,
IP_SO_RCVBUF,
&cmd->recvbuf_size,
sizeof(cmd->recvbuf_size)) < 0)
{
ipcom_printf("sockperf-c: setsockopt IP_SO_SNDBUF failed : %s"IP_LF,
ipcom_strerror(ipcom_errno));
return;
}
}
if (cmd->receive)
{
IP_FD_ZERO(&cmd->read_set);
cmd->width = s[0];
IP_FD_SET(s[0], &cmd->read_set);
for (i = 1; i < cmd->num_sock; i++)
if (s[i] != IP_INVALID_SOCKET)
{
cmd->width = IP_MAX(cmd->width, s[i]);
IP_FD_SET(s[i], &cmd->read_set);
}
}
ipcom_microtime(&start);
while ((cmd->transmit && total_bytes_to_send)
|| (cmd->receive && finished_sockets < cmd->num_sock))
{
if (cmd->transmit && total_bytes_to_send)
{
for (i = 0; i < cmd->num_sock; i++)
{
if (cmd->testpattern)
{
/* Test patter is "[B|E|D]xxxxxx ", B = first 8 byte in buffer, E = last 8 bytes, D = all other */
for (c = 0; c < cmd->buf_len; c += 8)
ipcom_sprintf(cmd->buf + c, "%c%06ld ",
c == 0 ? '>' : (c >= cmd->buf_len - 8 ? '<' : '#'),
cmd->send_pattern[i]++ % 1000000);
}
bytes = ipcom_send(s[i],
cmd->buf,
IP_MIN(cmd->buf_len, total_bytes_to_send),
send_flags);
if (bytes < 0 && ipcom_errno == IP_ERRNO_EWOULDBLOCK)
(void)ipcom_sleep(0);
else
{
if (bytes < 0)
{
ipcom_printf("sockperf-t: send failed : %s"IP_LF,
ipcom_strerror(ipcom_errno));
return;
}
total_bytes_to_send -= bytes;
}
}
if (cmd->receive && total_bytes_to_send == 0)
for (i = 0; i < cmd->num_sock; i++)
if (ipcom_shutdown(s[i], IP_SHUT_WR) < 0)
{
ipcom_printf("sockperf-t: shutdown failed: %s"IP_LF,
ipcom_strerror(ipcom_errno));
return;
}
}
if (cmd->receive)
{
ptmo = IP_NULL;
while (finished_sockets < cmd->num_sock)
{
read_set = cmd->read_set;
num_ready = ipcom_socketselect(cmd->width + 1, &read_set, IP_NULL, IP_NULL, ptmo);
if (num_ready == 0)
break;
if (num_ready < 0)
{
ipcom_printf("sockperf-r: select failed: %s"IP_LF,
ipcom_strerror(ipcom_errno));
return;
}
for (i = 0; i < cmd->num_sock; i++)
{
if (IP_FD_ISSET(s[i], &read_set))
{
bytes = ipcom_recv(s[i], cmd->buf, cmd->buf_len, 0);
if (bytes < 0)
{
ipcom_printf("sockperf-r: recv failed: %s"IP_LF,
ipcom_strerror(ipcom_errno));
return;
}
if (cmd->testpattern)
{
if (cmd->echo)
ipcom_cmd_sockperf_echo_buf(cmd->buf, bytes, cmd->recv_pattern[i]);
for (c = 0; c < (Ip_u32)bytes; c += 8)
{
if (cmd->buf[c] != '#' && cmd->buf[c] != '>' && cmd->buf[c] != '<')
{
ipcom_printf("\nsockperf-r: test pattern error, expected B, D or E found %c(%d) offset %ld"IP_LF,
cmd->buf[c], (int)cmd->buf[c], c);
ipcom_cmd_sockperf_echo_buf(cmd->buf, bytes, 0);
return;
}
if (ipcom_atoi(cmd->buf + c + 1) != (int)(cmd->recv_pattern[i]++ % 1000000))
{
ipcom_printf("\nsockperf-r: test pattern error, was %d should be %ld offset %ld"IP_LF,
ipcom_atoi(cmd->buf + c + 1), (cmd->recv_pattern[i] - 1) % 1000000, c);
ipcom_cmd_sockperf_echo_buf(cmd->buf, bytes, 0);
return;
}
}
}
if (bytes > 0)
total_bytes_read += bytes;
else
{
finished_sockets++;
IP_FD_CLR(s[i], &cmd->read_set);
}
}
}
if (cmd->transmit && total_bytes_to_send)
ptmo = &tmo;
}
}
}
ipcom_microtime(&stop);
if (cmd->transmit)
ipcom_printf("sockperf-t: %lu bytes sent in %ld ms (%lu kbyte/s)"IP_LF,
cmd->num_buf * cmd->buf_len,
ipcom_cmd_sockperf_tv_to_msec(&start, &stop),
cmd->num_buf * cmd->buf_len / (Ip_u32)ipcom_cmd_sockperf_tv_to_msec(&start, &stop) * 1000 / 1024);
if (cmd->receive)
ipcom_printf("sockperf-r: %lu bytes read in %ld ms (%lu kbyte/s)"IP_LF,
total_bytes_read,
ipcom_cmd_sockperf_tv_to_msec(&start, &stop),
total_bytes_read / (Ip_u32)ipcom_cmd_sockperf_tv_to_msec(&start, &stop) * 1000 / 1024);
}
