/*
*===========================================================================
* ipcom_enter_vxworks_shell
*===========================================================================
* Description: IP shell command to enter the VxWorks shell. The command blocks
* until the VxWorks shell exits
* Parameters: Command and arguments (not used)
* Returns: 0
*
*/
IP_GLOBAL int
ipcom_cmd_vxshell(int argc, char **argv)
{
int fd;
Ipcom_proc *proc;
Ipcom_vxshell_session_t session;
(void)argc;
(void)argv;
proc = ipcom_proc_find(ipcom_getpid(), IP_FALSE);
#ifdef IPCOM_USE_NATIVE_SOCK_API
fd = proc->shell_fd;
#else
fd = ipcom_windnet_socket_use_existing(proc->shell_fd);
#endif
ipcom_sem_create(&session.shell_exit_sem, 0);
if (shellParserControl(REMOTE_START, (Ip_u32)&session, fd, ipcom_vxworks_shell_logout_cb) == 0)
{
ipcom_sem_wait(session.shell_exit_sem);
shellParserControl(REMOTE_STOP, (Ip_u32)&session, 0, IP_NULL);
}
ipcom_sem_delete(&session.shell_exit_sem);
#ifndef IPCOM_USE_NATIVE_SOCK_API
close(fd);
#endif
return 0;
}
/*
*===========================================================================
* ipcom_random_init
*===========================================================================
* Description:
* Parameters:
* Returns:
*
*/
IP_GLOBAL Ip_err
ipcom_random_init(void)
{
struct Ip_timeval tval;
Ip_err rc = IPCOM_SUCCESS;
unsigned int deliberately_uninitialized;
/* Make sure we have some random seed at boot. Good in general and in
* particular since IPNET uses ipcom_random to generate random MAC
* addresses in the unix port. */
(void) ipcom_gettimeofday(&tval, IP_NULL);
ipcom_srandom((unsigned int)(tval.tv_sec + tval.tv_usec));
ipcom_srandom(ipcom_getpid());
ipcom_srandom(deliberately_uninitialized);
#ifdef IPCOM_USE_EGD
{
Ipcom_proc_attr attr;
ipcom_proc_attr_init(&attr);
attr.priority = IPCOM_PRIORITY_BACKGROUND;
attr.flags = IPCOM_PROC_FLAG_FP;
rc = ipcom_proc_acreate("ipcom_egd", ipcom_egd, &attr, IP_NULL);
}
#endif
return rc;
}
IP_GLOBAL void *
ipcom_shell_info_new(void)
{
Ipcom_shell_info *shell_info;
shell_info = ipcom_ipc_malloc(sizeof(Ipcom_shell_info));
if (shell_info != IP_NULL)
{
ipcom_memset(shell_info, 0, sizeof(Ipcom_shell_info));
shell_info->ppid = ipcom_getpid();
}
return shell_info;
}
/*
*===========================================================================
* ipcom_shell_add_cmd
*===========================================================================
* Description: Add a command to the list of available ipcom_shell commands
* Parameters: name : command's name
* usage : usage string
* description : description of command
* hook : function to that executes the command
* priority : na
* stack_size : the stack to be used by the process that
* executes the hook.
*
* Returns: IPCOM_SUCCESS : ok
* IPCOM_ERR_DUPLICATE : command already exists
* IPCOM_ERR_NO_MEMORY : out of memory
*
*
*/
IP_PUBLIC Ip_err
ipcom_shell_add_cmd(const char *name, const char *usage,
const char *description, Ipcom_shell_cmd_type hook,
Ip_s32 priority, Ip_s32 stack_size)
{
Ipcom_shell_cmd *cmd;
static Ipcom_once_t once = IPCOM_ONCE_INIT;
Ip_err err;
err = ipcom_once(&once, ipcom_shellcmd_init, IP_NULL);
if (err != IPCOM_SUCCESS)
return err;
/* First check if present */
cmd = ipcom_shell_find_cmd(name);
if (cmd != IP_NULL)
return IPCOM_ERR_DUPLICATE; /*!!allow duplicates for overlay. */
/* Add a new entry to the list */
cmd = (Ipcom_shell_cmd *)ipcom_malloc(sizeof(Ipcom_shell_cmd));
if (cmd == IP_NULL)
return IPCOM_ERR_NO_MEMORY;
ipcom_memset(cmd, 0, sizeof(Ipcom_shell_cmd));
ipcom_strncpy(cmd->name, name, sizeof(cmd->name)-1);
ipcom_strncpy(cmd->usage, usage, sizeof(cmd->usage)-1);
ipcom_strncpy(cmd->description, description, sizeof(cmd->description)-1);
cmd->hook = hook;
if (priority == 0 || priority == IPCOM_SHELL_PRIO_SAME)
cmd->priority = ipcom_proc_getprio(ipcom_getpid());
else
cmd->priority = priority;
cmd->stack_size = stack_size;
ipcom_list_insert_last(&ipcom_shell_cmd_head, &cmd->cmd_list);
#if defined(WRS_IPNET) && defined(IP_PORT_VXWORKS) && (IP_PORT_VXWORKS >= 65)
(void)ipcom_vxshell_add_cmd(name,
usage,
description,
hook,
priority,
stack_size);
#endif
return IPCOM_SUCCESS;
}
/*
*===========================================================================
* ipcom_cmd_ttcp
*===========================================================================
*/
int
ipcom_cmd_ttcp(int argc, char **argv)
{
/* Uninitialized variables. */
union Ip_sockaddr_union addrme;
char *host = IP_NULL; /* ptr to name of host */
int c;
Ip_u32 msec0, msec1, msecd, bpermsec, kbpersec;
Ip_fd sockfd = -1;
char *buf; /* ptr to dynamic buffer */
char *orgbuf = 0; /* the buffer to free. */
struct Ipcom_cmd_ttcp_data context;
/* misc initialized variables. */
#ifdef IPCOM_USE_TCP
union Ip_sockaddr_union frominet;
Ip_socklen_t fromlen;
int one = 1; /* for 4.3 BSD style setsockopt() */
Ip_fd oldfd; /* fd of network socket */
#endif
Ip_u32 nbytes = 0; /* bytes on net */
int trans = 1; /* 0=receive, !0=transmit mode. Default transmit! */
/* Configuration variables. */
#if defined(IP_SO_X_VR)
int vr = 0;
#endif
int buflen = 8 * 1024; /* length of buffer */
int nbuf = 2 * 1024; /* number of buffers to send in sinkmode */
int bufoffset = 0; /* align buffer to this */
int bufalign = 16; /* modulo this */
int options = 0; /* socket options */
unsigned short port = DEFAULT_PORT; /* TCP port number */
unsigned short meport = 0; /* local port, default 0. */
int sinkmode = 1; /* 0=normal I/O, !0=sink/source mode */
int verbose = 0; /* 0=print basic info, 1=print cpu rate, proc resource usage. */
int sockbufsize = -1; /* Default socket buffer size to use. */
#ifdef IP_TCP_NODELAY
int nodelay = 0; /* set TCP_NODELAY socket option. */
#endif
int enable = 1;
#ifdef TCP_OSERFC2385
char *md5opt = IP_NULL;
#endif
#ifdef IP_SO_REUSEPORT
int reuse_port = 0;
#endif
#ifdef IPCOM_TTCP_REENTRANT
union Ip_sockaddr_union addrhim;
#endif
int sock_error;
int mev = 0; /* Use event logging */
int nend = 5; /* Number of UDP end packets */
#ifdef IPCOM_CMD_TTCP_USE_ZEROCOPY_API
int zerocopy = 0;
#endif
int cpu = -1;
#ifdef IPSCTP
Ip_bool sctp_type_conflict = IP_FALSE;
#endif
/* Initialize some static data, default configuration. */
#ifdef IPCOM_USE_TCP
int proto = IP_IPPROTO_TCP;
int sock_type = IP_SOCK_STREAM;
const char *proto_as_str = "TCP";
context.udp = 0; /* Default is TCP. */
#else
int proto = IP_IPPROTO_UDP;
int sock_type = IP_SOCK_DGRAM;
const char *proto_as_str = "UDP";
context.udp = 1; /* Only UDP. */
#endif
context.b_flag = 0;
context.touchdata = 0;
context.numCalls = 0;
context.err_no = 0;
#ifdef IPCOM_USE_INET
context.family = IP_AF_INET; /* default IPv4 */
#else
context.family = IP_AF_INET6; /* default IPv6 */
#endif
context.addrsize = sizeof(struct Ip_sockaddr_in);
(void)ipcom_proc_self(); /* when called from vxworks shell, this prevents a crash */
(void)options;
/* Init some more. */
ipcom_memset(&addrhim, 0, sizeof (addrhim));
IPCOM_SA_LEN_SET(&addrhim.sin, sizeof(struct Ip_sockaddr_in));
addrhim.sin.sin_family = IP_AF_INET;
ipcom_memset(&addrme, 0, sizeof(addrme));
IPCOM_SA_LEN_SET(&addrme.sin, sizeof(struct Ip_sockaddr_in));
addrme.sin.sin_family = IP_AF_INET;
#ifdef IP_PORT_INTEGRITY
ipcom_init_libsocket();
#endif
if (argc < 2)
goto usage;
ipcom_getopt_clear();
while ((c = ipcom_getopt(argc, argv, "M:xdrstUuvBDTb:f:l:n:p:A:O:V:RP:me:a:cS")) != -1)
{
switch (c)
{
#ifdef TCP_OSERFC2385
case 'M': /* MD5 signature option */
md5opt = ip_optarg;
break;
#endif
#ifdef IPCOM_USE_INET6
case 'x':
context.family = IP_AF_INET6;
break;
#endif
case 'm':
mev = 1;
break;
case 'e':
nend = ipcom_atoi(ip_optarg);
break;
case 'B':
context.b_flag = 1;
break;
case 't':
trans = 1;
break;
case 'r':
trans = 0;
break;
#ifdef IP_SO_DEBUG
case 'd':
options |= IP_SO_DEBUG;
break;
#endif
case 'D':
#ifdef IP_TCP_NODELAY
nodelay = 1;
#else
ipcom_fprintf(ip_stderr, "ttcp: -D option ignored: IP_TCP_NODELAY socket option not supported"IP_LF);
#endif
break;
case 'n':
nbuf = ipcom_atoi(ip_optarg);
break;
case 'l':
buflen = ipcom_atoi(ip_optarg);
break;
case 's':
#ifdef IPCOM_TTCP_USE_STDIOMODE
sinkmode = !sinkmode;
#endif
break;
case 'p':
port = (unsigned short)ipcom_atoi(ip_optarg);
break;
case 'P':
meport = (unsigned short)ipcom_atoi(ip_optarg);
break;
#ifdef IPCOM_CMD_TTCP_USE_ZEROCOPY_API
case 'U':
zerocopy = 1;
/* fall through */
#endif
case 'u':
proto = IP_IPPROTO_UDP;
sock_type = IP_SOCK_DGRAM;
proto_as_str = "UDP";
context.udp = 1;
break;
case 'v':
verbose = 1;
break;
case 'A':
bufalign = ipcom_atoi(ip_optarg);
break;
case 'O':
bufoffset = ipcom_atoi(ip_optarg);
break;
case 'b':
#if defined(IP_SO_SNDBUF) || defined(IP_SO_RCVBUF)
sockbufsize = ipcom_atoi(ip_optarg);
#else
ipcom_fprintf(ip_stderr, "ttcp: -b option ignored: IP_SO_SNDBUF/IP_SO_RCVBUF socket options not supported"IP_LF);
#endif
break;
#ifdef IP_SO_REUSEPORT
case 'R':
reuse_port = 1;
break;
#endif
case 'T':
context.touchdata = 1;
break;
#if defined(IP_SO_X_VR)
case 'V':
vr = ipcom_atoi(ip_optarg);
break;
#endif
case 'a':
cpu = ipcom_atoi(ip_optarg);
break;
#ifdef IPSCTP
case 'c':
proto = IP_IPPROTO_SCTP;
sock_type = IP_SOCK_STREAM;
proto_as_str = "SCTP";
if (IP_TRUE == sctp_type_conflict)
{
ipcom_fprintf(ip_stderr, "ttcp: c/S conflict in command."IP_LF);
goto errorout;
}
sctp_type_conflict = IP_TRUE;
break;
case 'S':
proto = IP_IPPROTO_SCTP;
sock_type = IP_SOCK_SEQPACKET;
proto_as_str = "SCTP";
if (IP_TRUE == sctp_type_conflict)
{
ipcom_fprintf(ip_stderr, "ttcp: c/S conflict in command."IP_LF);
goto errorout;
}
sctp_type_conflict = IP_TRUE;
break;
#endif
default:
goto usage;
}
}
#ifndef IP_PORT_LAS
if (cpu >= 0)
{
Ip_cpu_set_t cpuset;
if (cpu < 0 || cpu >= IP_CPU_SETSIZE)
{
ipcom_fprintf(ip_stderr, "ttcp: CPU must be between #0 and #%d"IP_LF, IP_CPU_SETSIZE-1);
return -1;
}
IP_CPU_ZERO(&cpuset);
IP_CPU_SET(cpu, &cpuset);
if (ipcom_proc_cpu_affinity_set(0, &cpuset) != IPCOM_SUCCESS)
{
ipcom_fprintf(ip_stderr, "ttcp: Failed to set affinity to CPU #%d"IP_LF, cpu);
return -1;
}
}
#endif /* IP_PORT_LAS */
if(trans)
{
host = argv[ip_optind];
if (host == 0)
goto usage;
sock_error = ipcom_getsockaddrbyaddrname(context.family, IP_FALSE, host, (struct Ip_sockaddr *)&addrhim);
if(sock_error != 0)
{
ipcom_fprintf(ip_stderr, "ttcp error: ipcom_getsockaddrbyaddrname failed, errno = %d."IP_LF, sock_error);
ttcperror(&context, "unknown host");
}
addrme.sin.sin_port = ip_htons(meport);
addrhim.sin.sin_port = ip_htons(port); /* same port offset for IPv4 and IPv6 */
}
else
{
/* rcvr */
addrme.sin.sin_port = ip_htons(port);
}
#ifdef IPCOM_USE_INET6
if(context.family == IP_AF_INET6)
{
context.addrsize = sizeof(struct Ip_sockaddr_in6);
IPCOM_SA_LEN_SET(&addrme.sin6, sizeof(struct Ip_sockaddr_in6));
addrme.sin6.sin6_family = IP_AF_INET6;
IPCOM_SA_LEN_SET(&addrhim.sin6, sizeof(struct Ip_sockaddr_in6));
addrhim.sin6.sin6_family = IP_AF_INET6;
}
#endif
/* Send more than the sentinel size - UDPMINLEN. */
if(context.udp && buflen <= UDPMINLEN)
buflen = UDPMINLEN + 1;
/* Align buffer. */
if ((buf = (char *) ipcom_malloc(buflen + bufalign)) == (char *) IP_NULL)
ttcperror(&context, "malloc");
else
orgbuf = buf;
if (bufalign != 0)
buf += (bufalign - ((Ip_ptrdiff_t) buf % bufalign) + bufoffset) % bufalign;
/* Get a socket. */
if ((sockfd = ipcom_socket(context.family, sock_type, proto)) == ERR)
ttcperror(&context,"socket");
if (trans)
{
if(sockbufsize < 0)
{
if(context.udp)
sockbufsize = DEFAULT_UDP_SNDBUF;
else
sockbufsize = DEFAULT_TCP_SNDBUF;
}
ipcom_fprintf(ip_stdout, "ttcp-t: fd=%d, buflen=%d, nbuf=%d, align=%d/%d, port=%d",
sockfd, buflen, nbuf, bufalign, bufoffset, (int)port);
if (sockbufsize)
ipcom_fprintf(ip_stdout, ", sockbufsize=%d", sockbufsize);
ipcom_fprintf(ip_stdout, " %s -> %s"IP_LF, proto_as_str, host);
}
else
{
if(sockbufsize < 0)
{
if(context.udp)
sockbufsize = DEFAULT_UDP_RCVBUF;
else
sockbufsize = DEFAULT_TCP_RCVBUF;
}
ipcom_fprintf(ip_stdout, "ttcp-r: fd=%d, buflen=%d, nbuf=%d, align=%d/%d, port=%d",
sockfd, buflen, nbuf, bufalign, bufoffset, (int)port);
if (sockbufsize)
ipcom_fprintf(ip_stdout, ", sockbufsize=%d", sockbufsize);
ipcom_fprintf(ip_stdout, " %s"IP_LF, proto_as_str);
}
/* Code to open socket is moved to before the printf to get 'sockfd' right. */
mes(trans, "socket");
/* Set REUSE addr */
if(ipcom_setsockopt(sockfd, IP_SOL_SOCKET, IP_SO_REUSEADDR, (char *)&enable, sizeof (int)) == ERR)
ttcperror(&context, "setsockopt(IP_SO_REUSEADDR)");
else
mes(trans, "setsockopt(IP_SO_REUSEADDR)");
#ifdef IP_SO_REUSEPORT
/* Set REUSE port */
if(reuse_port)
{
if(ipcom_setsockopt(sockfd, IP_SOL_SOCKET, IP_SO_REUSEPORT, (char *)&reuse_port, sizeof (int)) == ERR)
ttcperror(&context, "setsockopt(IP_SO_REUSEPORT)");
else
mes(trans, "setsockopt(IP_SO_REUSEPORT)");
}
#endif
#ifdef IPCOM_USE_TCP
#ifdef TCP_OSERFC2385
if (!udp && md5opt)
{
if (ipcom_setsockopt(sockfd, IPPROTO_TCP, TCP_OSERFC2385,
md5opt, strlen(md5opt)) == ERR)
{
ttcperror(&context, "setsockopt(IP_SO_REUSEADDR)");
}
else
{
mes(trans, "setsockopt(IP_SO_REUSEADDR)");
}
}
#endif
#endif
/* Set routing table index in socket. */
#if defined(IP_SO_X_VR)
if(vr != 0)
{
if (ipcom_setsockopt(sockfd, IP_SOL_SOCKET, IP_SO_X_VR, (char *)&vr, 4) == ERR)
ttcperror(&context, "setsockopt: vr");
else
mes(trans, "setsockopt(vr)");
}
#endif
/* Bind the socket. */
if(ipcom_bind(sockfd, (struct Ip_sockaddr *)&addrme, context.addrsize) == ERR)
ttcperror(&context, "bind");
else
#ifdef IPCOM_USE_INET6
ipcom_fprintf(ip_stderr, "ttcp%s: bind %s %d"IP_LF, trans ? "-t" : "-r",
context.family == IP_AF_INET ? "IPv4" : "IPv6",
(int)ip_ntohs(addrme.sin.sin_port));
#else
{
char tmpbuf[32];
ipcom_sprintf(tmpbuf, "bind %d", ip_ntohs(addrme.sin.sin_port));
mes(trans, tmpbuf);
}
#endif
/* Adjust socker buffer size. */
#if defined(IP_SO_SNDBUF) || defined(IP_SO_RCVBUF)
if(sockbufsize)
{
if (trans)
{
if (ipcom_setsockopt(sockfd, IP_SOL_SOCKET, IP_SO_SNDBUF, (char *)&sockbufsize, sizeof sockbufsize) == ERR)
ttcperror(&context,"setsockopt: sndbuf");
else
mes(trans, "setsockopt(sndbuf)");
}
else
{
if (ipcom_setsockopt(sockfd, IP_SOL_SOCKET, IP_SO_RCVBUF, (char *)&sockbufsize, sizeof sockbufsize) == ERR)
ttcperror(&context,"setsockopt: rcvbuf");
else
mes(trans, "setsockopt(rcvbuf)");
}
}
#endif
/* If TCP we need to connect else accept to remote side. */
#ifdef IPCOM_USE_TCP
if (context.udp)
{
mes(trans, "opened");
}
else
{
/* We are the client if transmitting */
if(trans)
{
if(options)
{
if(ipcom_setsockopt(sockfd, IP_SOL_SOCKET, options, (char *)&one, sizeof (one)) == ERR)
ttcperror(&context,"setsockopt");
}
#ifdef IP_TCP_NODELAY
if(nodelay)
{
if(ipcom_setsockopt(sockfd, IP_IPPROTO_TCP, IP_TCP_NODELAY, (char *)&one, sizeof (one)) == ERR)
ttcperror(&context,"setsockopt: nodelay");
mes(trans, "nodelay");
}
#endif
if(ipcom_connect(sockfd, (struct Ip_sockaddr *)&addrhim, context.addrsize) == ERR)
ttcperror(&context,"connect");
else
mes(trans, "connect");
}
/* Otherwise, we are the TCP server and should listen for the connections. */
else
{
if(ipcom_listen(sockfd, 0) == ERR)
ttcperror(&context,"listen");
else
mes(trans, "listen");
if(options)
{
if(ipcom_setsockopt(sockfd, IP_SOL_SOCKET, options, (char *)&one, sizeof (one)) == ERR)
ttcperror(&context,"setsockopt");
}
fromlen = context.addrsize;
oldfd = sockfd;
#ifdef IPSCTP
if ((IP_SOCK_SEQPACKET == sock_type)
&& (IP_IPPROTO_SCTP == proto))
{
#define TTCP_SCTP_RCV_BUF_LEN 128
struct Ipsctp_event_subscribe events;
union Ip_sockaddr_union local_addr;
struct Ipsctp_sndrcvinfo sinfo;
Ip_u32 len = 0;
char pbuf[TTCP_SCTP_RCV_BUF_LEN];
int flags = 0;
int ret = 0;
/* set data I/O event flag */
ipcom_memset(&events, 0, sizeof(events));
events.Ipsctp_data_io_event = 1;
ret = ipcom_setsockopt(sockfd,
IP_IPPROTO_SCTP,
IPSCTP_EVENTS,
(void *)&events,
sizeof(events));
if (ERR == ret)
ttcperror(&context, "setsockopt events");
/* get the association identifier */
ipcom_memset(pbuf, 0, TTCP_SCTP_RCV_BUF_LEN);
len = sizeof(local_addr);
/* Wait for connections */
ret = ipsctp_recvmsg(sockfd,
pbuf,
TTCP_SCTP_RCV_BUF_LEN,
&local_addr.sa,
&len,
&sinfo,
&flags);
sockfd = ipsctp_peeloff(sockfd, sinfo.sinfo_assoc_id);
if (IP_SOCKERR == sockfd)
ttcperror(&context,"peeloff");
}
else
#endif
{
if((sockfd = ipcom_accept(sockfd, (struct Ip_sockaddr *)&frominet, &fromlen)) == ERR)
ttcperror(&context,"accept");
}
{
union Ip_sockaddr_union peer;
Ip_socklen_t peerlen = context.addrsize;
/* Close the mother socket. */
if(ipcom_socketclose(oldfd) == ERR)
ttcperror(&context,"close of oldfd.");
#if defined(IP_SO_RCVBUF)
/* Had to add this code in addition to the above because some stacks don't inherit
* the receive buffer size from the server socket. /Lennart Bang Enea Ose Systems 980116.
*/
if(sockbufsize)
{
if(ipcom_setsockopt(sockfd, IP_SOL_SOCKET, IP_SO_RCVBUF, (char *)&sockbufsize, sizeof sockbufsize) == ERR)
ttcperror(&context,"setsockopt: rcvbuf");
else
mes(trans, "setsockopt(rcvbuf)");
}
#endif
if(ipcom_getpeername(sockfd, (struct Ip_sockaddr *) &peer, &peerlen) == ERR)
ttcperror(&context, "getpeername");
#ifdef IPCOM_USE_INET
if(context.family == IP_AF_INET)
{
char addr[16];
ipcom_fprintf(ip_stderr, "ttcp-r: accept from %s"IP_LF,
ipcom_inet_ntop(IP_AF_INET, &peer.sin.sin_addr, addr, sizeof(addr)));
}
#endif
#ifdef IPCOM_USE_INET6
if(context.family == IP_AF_INET6)
{
char addr[40];
ipcom_fprintf(ip_stderr, "ttcp-r: accept from %s"IP_LF,
ipcom_inet_ntop(IP_AF_INET6, &peer.sin6.sin6_addr, addr, sizeof(addr)));
}
#endif
}
}
}
#endif
/* Begin the TTCP performance test. */
msec0 = get_millisec();
if (mev)
{
#if defined (IP_PORT_INTEGRITY)
#include "ipcom_integrity.h"
extern void EventLogOn(void);
#if IP_VER < 500
extern void EventLogMask(unsigned int newmask);
EventLogMask(~0);
#endif
EventLogOn();
#endif
}
if(sinkmode)
{
register int cnt;
/* Transmit side. */
if(trans)
{
pattern(buf, buflen);
if(context.udp)
{
(void) NWRITE(sockfd, buf, UDPMINLEN, &context); /* rcvr start */
ipcom_millisleep(500); /* arp time */
/* Renew the start time to not include the 500 msec sleep */
msec0 = get_millisec();
}
#ifdef IPCOM_CMD_TTCP_USE_ZEROCOPY_API
if (zerocopy)
{
while (nbuf-- && ZERONWRITE(sockfd, buflen, &context) == buflen)
nbytes += buflen;
}
else
#endif
{
while (nbuf-- && NWRITE(sockfd, buf, buflen, &context) == buflen)
nbytes += buflen;
}
if(context.udp)
(void) NWRITE(sockfd, buf, UDPMINLEN, &context); /* rcvr end */
}
/* Receive side. */
else
{
if(context.udp)
{
int going = 0;
#ifdef IPCOM_CMD_TTCP_USE_ZEROCOPY_API
if (zerocopy)
{
while ((cnt = ZeroNread(sockfd, &context)) > 0)
{
if(cnt <= UDPMINLEN)
{
if(going)
break; /* "EOF" */
going = 1;
msec0 = get_millisec();
}
else
{
nbytes += cnt;
}
}
}
else
#endif
{
while ((cnt = Nread(sockfd, buf, buflen, &context)) > 0)
{
if(cnt <= UDPMINLEN)
{
if(going)
break; /* "EOF" */
going = 1;
msec0 = get_millisec();
}
else
{
nbytes += cnt;
}
}
}
}
#ifdef IPCOM_USE_TCP
else
{
while ((cnt = Nread(sockfd, buf, buflen, &context)) > 0)
{
nbytes += cnt;
}
}
#endif
}
}
#ifdef IPCOM_TTCP_USE_STDIOMODE
/* non sinkmode. */
else
{
register int cnt;
if(trans)
{
/* Read from standard input and send to other side. */
while ((cnt = ipcom_fread(buf, buflen, 1, ip_stdin)) > 0 &&
NWRITE(sockfd, buf, cnt) == cnt)
nbytes += cnt;
}
else
{
/* Read from network and print on stdout. */
while ((cnt = Nread(sockfd, buf, buflen, &context)) > 0)
{
ipcom_fwrite(buf, cnt, 1, ip_stdout);
nbytes += cnt;
}
}
}
#endif
if (mev)
{
#if defined (IP_PORT_INTEGRITY)
extern void EventLogOff(void);
EventLogOff();
#elif defined (IP_PORT_RTCORE)
extern void ip_trace(char *what, char *file, int line, int id, void *data);
extern void ip_tracedump(void);
ip_trace("[ASSERT]", __FILE__, __LINE__, ipcom_getpid(), IP_NULL);
ip_tracedump();
#endif
}
/* Read the final time and calculate some statistics. */
msec1 = get_millisec();
msecd = msec1 - msec0;
if (msecd == 0)
msecd = 1;
bpermsec = nbytes / msecd; /* Bytes per millisecond. */
kbpersec = nbytes / 128;
kbpersec = kbpersec * 125 / msecd; /* kilobyte per sec. */
/* End of test assemble statistice. */
if(context.err_no)
{
ipcom_fprintf(ip_stdout, "ttcp%s: socket errno: %d."IP_LF, trans ? "-t" : "-r", context.err_no);
}
if(context.udp && trans)
{
int j;
for (j = 0; j < nend; j++)
{
ipcom_millisleep(100); /* Let the reading side catch up. */
(void) NWRITE(sockfd, buf, UDPMINLEN, &context); /* rcvr end */
}
}
/* Print the statistics. */
ipcom_fprintf(ip_stdout, "ttcp%s: %lu bytes in %lu milliseconds = %lu KB/sec, %lu B/msec +++"IP_LF,
trans ? "-t" : "-r", nbytes, msecd, kbpersec, bpermsec);
ipcom_fprintf(ip_stdout, "ttcp%s: %lu I/O calls, msec/call = %lu, calls/sec = %lu"IP_LF,
trans ? "-t" : "-r",
context.numCalls,
msecd / context.numCalls,
1000 * context.numCalls / msecd);
if (verbose)
ipcom_fprintf(ip_stdout, "ttcp%s: buffer address %p"IP_LF, trans ? "-t" : "-r", buf);
/* Test succeeded, goto errorout to cleanup. */
goto errorout;
/* Usage. */
usage:
ipcom_fprintf(ip_stderr,
"Usage: ttcp -t [-options] host [ < in ]"IP_LF
"ttcp -r [-options > out]"IP_LF
"Common options:"IP_LF
"-x use IPv6 instead of IPv4"IP_LF
"-l ## length of bufs read from or written to network (default 8192)"IP_LF
#ifdef IPCOM_CMD_TTCP_USE_ZEROCOPY_API
"-U use UDP and interpeak zero copy API instead of TCP"IP_LF
#endif
"-u use UDP (default is TCP)"IP_LF
#ifdef IPSCTP
"-c use SCTP STREAM type(default is TCP)"IP_LF
"-S use SCTP SEQPACKET type(default is TCP)"IP_LF
#endif
"-p ## port number to send to or listen at (default DEFAULT_PORT)"IP_LF);
ipcom_fprintf(ip_stderr,
"-s -t: source a pattern to network"IP_LF
"-r sink (discard) all data from network"IP_LF
"-e ## number of packets to end UDP transmission"IP_LF
"-m use event logging (not supported on all platforms)"IP_LF
"-A align the start of buffers to this modulus (default 16384)"IP_LF
"-O start buffers at this offset from the modulus (default 0)"IP_LF
"-v verbose: print more statistics"IP_LF
"-d set SO_DEBUG socket option (if supported)"IP_LF);
ipcom_fprintf(ip_stderr,
"-b ## set socket buffer size (if supported)"IP_LF
"Options specific to -t:"IP_LF
"-n## number of source bufs written to network (default 2048)"IP_LF
"-D don't buffer TCP writes (sets TCP_NODELAY socket option)"IP_LF
"Options specific to -r:"IP_LF
"-B for -s, only output full blocks as specified by -l (for TAR)"IP_LF
"-T \"touch\": access each byte as it's read"IP_LF
#if defined(IP_SO_X_VR)
"-V virtual router index (if supported)"IP_LF);
#endif
/* fall through to cleanup...*/
/* Free buffer and close socket if any error. */
errorout:
#ifndef IP_PORT_LAS
if (cpu >= 0)
ipcom_proc_cpu_affinity_clr(0);
#endif /* IP_PORT_LAS */
if(orgbuf)
ipcom_free(orgbuf);
if(sockfd != -1)
{
if(ipcom_socketclose(sockfd) == ERR)
ipcom_fprintf(ip_stderr, "ttcp error: close of sockfd. (line %d, errno %d)."IP_LF, __LINE__, ipcom_errno);
}
#ifdef IP_PORT_INTEGRITY
ipcom_shutdown_libsocket();
#endif
return 0;
}
/*
*===========================================================================
* ipcom_shell_run_extcmd
*===========================================================================
* Description: Starts a shell command process and delivers the command arguments
* and stdio socket to that process.
* Parameters: argc, argv - traditional command arguments
* stdio_fd - the standard input, output and error sock
* ppid - parent pid
* cmd_pid - shell command process id
*
* Returns: 1 : command process started
* 0 : not an external command
* -1 : error
*
*/
IP_PUBLIC Ip_err
ipcom_shell_run_extcmd(int argc, char **argv, Ip_fd *stdio_fd, Ip_pid_t ppid, Ip_u32 seqno, Ip_pid_t *cmd_pid, int *proc_index)
{
Ipcom_proc_attr attr;
Ipcom_ipc ipc;
Ipcom_shellcmd_info *sinfo;
Ipcom_shell_cmd *cmd = IP_NULL;
Ipcom_shell_cmd *tcmd;
Ip_err retval;
char procname[40];
Ip_u32 stack = IPCOM_PROC_STACK_DEFAULT;
Ip_pid_t pid;
pid = ipcom_getpid();
ipcom_sprintf(procname, "ipcom_sc_0x%lx_%d", (Ip_u32)pid, *proc_index);
/* Find command and max stack size (since we are reusing the process). */
if (argc > 0)
{
for (tcmd = IPCOM_LIST_FIRST(&ipcom_shell_cmd_head); tcmd; tcmd = IPCOM_LIST_NEXT(&tcmd->cmd_list))
{
stack = (Ip_u32)IP_MAX(stack, tcmd->stack_size);
if (cmd == IP_NULL && ipcom_strcmp(tcmd->name, argv[0]) == 0)
{
cmd = tcmd;
if (*cmd_pid != 0)
break;
}
}
if (cmd == IP_NULL)
return 0;
/* Start the shell_cmd process. */
if (*cmd_pid == 0)
{
ipcom_proc_attr_init(&attr);
attr.priority = (Ip_u32)cmd->priority;
attr.stacksize = stack;
attr.flags |= IPCOM_PROC_FLAG_FP;
if (ipcom_proc_acreate(procname, (Ipcom_proc_func)ipcom_shell_cmd, &attr, cmd_pid))
{
IPCOM_LOG0(ERR, "ipcom_shell_run_extcmd :: ipcom_proc_acreate() failed");
goto fail;
}
ip_assert(*cmd_pid != 0);
}
}
else
{
/* argc == 0 is used to kill the shell_cmd process. */
ip_assert(*cmd_pid != 0);
}
/* Open IPC with ipcom_shell. */
retval = ipcom_ipc_open(&ipc, procname, -1);
if (retval != IPCOM_SUCCESS)
{
IPCOM_LOG2(ERR, "ipcom_shell_run_extcmd :: ipcom_ipc_open(%s) failed, ret = %d", procname, retval);
goto fail;
}
/* Send a message to ipcom_shell. */
sinfo = ipcom_ipc_malloc(sizeof(Ipcom_shellcmd_info));
if (sinfo == IP_NULL)
{
IPCOM_LOG1(ERR, "ipcom_shell_run_extcmd :: ipcom_ipc_malloc() failed, ret = %d", retval);
goto fail;
}
/* Fill in IPC info. */
sinfo->argc = argc;
if (argc > 0)
{
sinfo->hook = cmd->hook;
sinfo->argv = argv;
sinfo->fd = *stdio_fd;
sinfo->pid = pid;
sinfo->ppid = ppid;
sinfo->seqno = seqno;
#if IPCOM_USE_FILE != IPCOM_FILE_NONE
if (ipcom_getcwd(sinfo->cwd, sizeof(sinfo->cwd)) == IP_NULL)
ipcom_memset(sinfo->cwd, 0, sizeof(sinfo->cwd));
else
sinfo->cwd[sizeof(sinfo->cwd)-1] = '\0';
#endif
sinfo->prio = cmd->priority;
}
/* Send the IPC info. */
retval = ipcom_ipc_send(&ipc, sinfo);
if (retval != IPCOM_SUCCESS)
{
IPCOM_LOG1(ERR, "ipcom_shell_run_extcmd :: ipcom_ipc_send() failed, ret = %d", retval);
ipcom_ipc_free(sinfo);
goto fail;
}
(void)ipcom_ipc_close(&ipc);
#ifdef IP_PORT_OSE5
if (argc > 0)
{
/* OSE5 has process specific sockets -> donate child fd */
ip_assert(*cmd_pid != 0);
retval = (Ip_err)efs_donate_fd(*stdio_fd, *cmd_pid);
if (retval != 0)
{
IPCOM_LOG1(ERR, "ipcom_shell_run_extcmd :: efs_donate_fd, ret = %d", retval);
goto fail;
}
}
#endif /* IP_PORT_OSE5 */
/* Wait for exit message from shell_cmd process. */
retval = ipcom_ipc_receive(IP_NULL, &sinfo, -1);
if (retval != IPCOM_SUCCESS)
{
IPCOM_LOG1(ERR, "ipcom_shell_run_extcmd :: ipcom_ipc_receive(shell_cmd) failed, ret = %d", retval);
goto fail;
}
ip_assert(argc > 0 || *(Ip_u32 *)sinfo == 1);
if (*(Ip_u32 *)sinfo == 1)
{
*cmd_pid = 0; /* shell command called ipcom_exit(). */
(*proc_index)++;
}
else
{
#ifdef IP_PORT_OSE5
*stdio_fd = efs_receive_fd(0);
if (*stdio_fd == -1)
{
IP_PANIC();
goto fail;
}
#endif
#if defined(IP_PORT_OSE) || defined(IP_PORT_OSE5)
/* Change child socket owner (A must for OSE to work due to poor ipcom_block impl). */
pid = ipcom_getpid();
if (ipcom_socketioctl(*stdio_fd, IP_SIOCSPGRP, &pid) < 0)
{
IP_PANIC2();
IPCOM_LOG1(WARNING, "ipcom_shell_run_extcmd :: ipcom_socketioctl(IP_SIOCSPGRP) failed, errno = %d", ipcom_errno);
}
#endif
}
ipcom_ipc_free(sinfo);
return 1;
fail:
if (ipcom_ipc_isopen(&ipc))
(void)ipcom_ipc_close(&ipc);
return -1;
}
/*
*===========================================================================
* ipcom_start_shell
*===========================================================================
* Description: Starts a shell process and sets up a TCP connection. The
* TCP connection is used to convey stdin and stdout data. The
* stdio proxy process and the underlaying shell process is
* terminated by closing the socket. If the shell terminates
* (e.g. if the user gives the command 'exit') the stdio proxy
* will close the TCP connection and terminate.
* Parameters:
* Returns:
*
*/
IP_PUBLIC Ip_err
ipcom_start_shell(Ip_fd *stdio_sock, Ip_fd client_fd)
{
Ip_fd mother = IP_INVALID_SOCKET;
Ip_fd shell_fd = IP_INVALID_SOCKET;
Ip_socklen_t addr_len;
Ipcom_ipc ipc;
Ipcom_shell_info *sinfo;
char procname[40];
Ip_err retval;
Ipcom_proc_attr attr;
Ip_bool ipc_opened = IP_FALSE;
Ip_pid_t ppid, shell_pid;
Ip_u16 mother_port;
static Ip_u32 seqno = 0;
struct Ip_addrinfo hints;
struct Ip_addrinfo *res = IP_NULL;
union Ip_sockaddr_union sa;
*stdio_sock = IP_INVALID_SOCKET;
sinfo = ipcom_ipc_malloc(sizeof(Ipcom_shell_info));
if (sinfo == IP_NULL)
{
IPCOM_LOG0(ERR, "ipcom_start_shell :: ipcom_ipc_malloc() failed");
goto exit;
}
addr_len = sizeof(sinfo->sa_prompt);
if (ipcom_getsockname(client_fd, (struct Ip_sockaddr *)&sinfo->sa_prompt, &addr_len) == IP_SOCKERR)
{
IPCOM_LOG1(ERR, "ipcom_start_shell :: ipcom_getsockname(client_fd) failed, errno = %d", ipcom_errno);
goto exit;
}
/* Get a tcp socket and let the stack pick a port */
ipcom_memset(&hints, 0, sizeof(hints));
hints.ai_family = sinfo->sa_prompt.sa.sa_family;
hints.ai_socktype = IP_SOCK_STREAM;
if (ipcom_getaddrinfo(IP_NULL, "0", &hints, &res) != 0)
{
IPCOM_LOG1(ERR, "ipcom_start_shell :: ipcom_getsockname(client_fd) failed, errno = %d", ipcom_errno);
goto exit;
}
mother = ipcom_socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (mother == IP_INVALID_SOCKET)
{
IPCOM_LOG1(ERR, "ipcom_start_shell :: ipcom_socket(IP_AF_INET) failed, errno = %d", ipcom_errno);
goto exit;
}
if (ipcom_bind(mother, res->ai_addr, res->ai_addrlen) == IP_SOCKERR)
{
IPCOM_LOG1(ERR, "ipcom_start_shell :: ipcom_bind(IP_AF_INET) failed, errno = %d", ipcom_errno);
goto exit;
}
/* Find out which port was assigned. */
addr_len = sizeof(sa);
if (ipcom_getsockname(mother, (struct Ip_sockaddr *)&sa, &addr_len) == IP_SOCKERR)
{
IPCOM_LOG1(ERR, "ipcom_start_shell :: ipcom_getsockname(IP_AF_INET) failed, errno = %d", ipcom_errno);
goto exit;
}
mother_port = ip_ntohs(sa.sin.sin_port);
if (ipcom_listen(mother, 1) == IP_SOCKERR)
{
IPCOM_LOG1(ERR, "ipcom_start_shell :: ipcom_listen() failed, errno = %d", ipcom_errno);
goto exit;
}
/* Create and start the shell process. */
ipcom_proc_attr_init(&attr);
#ifdef IP_PORT_VXWORKS
attr.stacksize = IPCOM_PROC_STACK_LARGE;
#else
attr.priority = IPCOM_PRIORITY_DEFAULT;
#endif /* IP_PORT_VXWORKS */
ppid = ipcom_getpid();
ipcom_sprintf(procname, "ipcom_shell_%lx_%lx", (Ip_u32)ppid, ++seqno);
if (ipcom_proc_acreate(procname, (Ipcom_proc_func)ipcom_shell, &attr, &shell_pid))
{
IPCOM_LOG0(ERR, "ipcom_start_shell :: ipcom_proc_acreate() failed");
goto exit;
}
/* Open IPC with ipcom_shell. */
retval = ipcom_ipc_open(&ipc, procname, -1);
if (retval != IPCOM_SUCCESS)
{
IPCOM_LOG2(ERR, "ipcom_start_shell :: ipcom_ipc_open(%s) failed, ret = %d", procname, retval);
goto exit;
}
ipc_opened = IP_TRUE;
/* Send a message to ipcom_shell. */
sinfo->port = mother_port;
sinfo->ppid = ppid;
sinfo->seqno = seqno;
retval = ipcom_ipc_send(&ipc, sinfo);
if (retval != IPCOM_SUCCESS)
{
IPCOM_LOG1(ERR, "ipcom_start_shell :: ipcom_ipc_send() failed, ret = %d", retval);
goto exit;
}
/* Wait for the shell process to connect */
shell_fd = ipcom_accept(mother, IP_NULL, IP_NULL);
exit:
if (mother != IP_INVALID_SOCKET)
(void)ipcom_socketclose(mother);
if (res != IP_NULL)
ipcom_freeaddrinfo(res);
if (ipc_opened)
(void)ipcom_ipc_close(&ipc);
else if (sinfo != IP_NULL)
ipcom_ipc_free(sinfo);
if (shell_fd == IP_INVALID_SOCKET)
return IPCOM_ERR_FAILED;
else
{
int enable = IP_TRUE;
*stdio_sock = shell_fd;
/* Disable Nagle (enable no delay) on this socket since it is an
interactive connection */
(void)ipcom_setsockopt(shell_fd, IP_IPPROTO_TCP, IP_TCP_NODELAY, &enable, sizeof(enable));
return IPCOM_SUCCESS;
}
}
/*
*===========================================================================
* ipcom_shell_print_prompt
*===========================================================================
* Description: Print shell prompt.
* Parameters:
* Returns: 0 = success, <0 = error code.
*
*/
IP_STATIC int
ipcom_shell_print_prompt(char *prompt_template, char *prompt_addr, int *promptlen, Ip_pid_t ppid, Ip_u32 seqno)
{
int baselen;
int ret = 0;
int buflen = 0;
char *buf;
#if IPCOM_USE_FILE != IPCOM_FILE_NONE
char *cwd;
char *base;
char cwdbuf[128];
#endif
buf = ipcom_malloc(IPCOM_STDIO_BUFSIZE);
if (buf == IP_NULL)
return -1;
for (; *prompt_template != '\0'; ++prompt_template)
{
ip_assert(buflen < (int)IPCOM_STDIO_BUFSIZE - 1);
if (*prompt_template != '\\')
{
/* 'Normal' character */
buf[buflen++] = *prompt_template;
}
else
{
/* New special character*/
switch (*++prompt_template)
{
case 'w':
/* Print current working directory */
case 'W':
#if IPCOM_USE_FILE != IPCOM_FILE_NONE
/* Print basename of the current workning directory */
cwd = ipcom_getcwd(cwdbuf, sizeof(cwdbuf));
if (cwd == IP_NULL)
{
IPCOM_LOG0(DEBUG, "ipcom_shell_print_prompt :: ipcom_getcwd() failed");
break;
}
if (*prompt_template == 'w')
base = cwd;
else
{
base = ipcom_strrchr(cwd, '/');
if (base != IP_NULL && base != cwd)
base++;
else
{
base = ipcom_strrchr(cwd, '\\');
if (base == IP_NULL)
base = cwd;
else
base++;
}
}
baselen = ipcom_strlen(base);
ipcom_memcpy(buf + buflen, base, baselen);
buflen += baselen;
#endif
break;
case 'p':
/* Print the shell process name */
{
char procname[40];
ipcom_sprintf(procname, "ipcom_shell_%lx_%lx", (Ip_u32)ppid, seqno);
baselen = ipcom_strlen(procname);
ipcom_memcpy(buf + buflen, procname, baselen);
buflen += baselen;
}
break;
case 'P':
/* Print the shell process pid */
{
char pid[14];
ipcom_sprintf(pid, "0x%lx", ipcom_getpid());
baselen = ipcom_strlen(pid);
ipcom_memcpy(buf + buflen, pid, baselen);
buflen += baselen;
}
break;
case 'i':
/* Print the IP address */
if (*prompt_addr)
{
baselen = ipcom_strlen(prompt_addr);
ipcom_memcpy(buf + buflen, prompt_addr, baselen);
buflen += baselen;
}
break;
#if IPCOM_USE_ENV != IPCOM_ENV_NONE
case 'V':
{
char vrbuf[16];
baselen = ipcom_sprintf(vrbuf, "%d", ipcom_proc_vr_get());
ipcom_memcpy(buf + buflen, vrbuf, baselen);
buflen += baselen;
}
break;
#endif
default:
/* Unknown code. */
IPCOM_LOG1(DEBUG, "ipcom_shell_print_prompt :: unknown code: %c", *prompt_template);
buf[buflen++] = '\\';
buf[buflen++] = '\\';
buf[buflen++] = *prompt_template;
break;
}
}
}
if (buflen > 0)
{
buf[buflen] = '\0';
if (promptlen != IP_NULL)
*promptlen = ipcom_strlen(buf);
ipcom_printf(buf);
}
ipcom_free(buf);
if (ret < 0)
IPCOM_LOG0(WARNING, "ipcom_shell_print_prompt :: ipcom_printf() failed");
return ret;
}
