/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2001-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * sock_test.c.  Implementing a CLI for inetboot testing.
 */
#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>
#include "socket_impl.h"
#include "socket_inet.h"
#include <sys/socket.h>
#include <sys/sysmacros.h>
#include <netinet/in_systm.h>
#include <sys/promif.h>
#include <sys/salib.h>
#include <ctype.h>
#include <errno.h>
#include <netinet/in.h>
#include "tcp_inet.h"
#include "ipv4.h"
#include <netinet/tcp.h>

static int atoi(const char *);
static int st_accept(void);
static int st_bind(void);
static int st_connect(void);
static int st_echo(void);
static int st_getsockname(void);
static int st_getsockopt(void);
static int st_get_addr_and_port(in_addr_t *, unsigned short *);
static int st_get_buf_and_cnt(char **, int *);
static int st_listen(void);
static int st_match_option(char *, int *, int *);
static int st_send(void);
static int st_sendto(void);
static int st_recv(void);
static int st_recvfrom(void);
static int st_set_addr(void);
static int st_set_netmask(void);
static int st_set_router(void);
static int st_setsockopt(void);
static int st_socket(void);
static int st_sock_close(void);
static int st_tcp_tw_report(void);
static int st_toggle_promiscuous(void);
static int st_use_obp(void);

/* Wrapper for socket calls. */
static int st_local_accept(int, struct sockaddr *, socklen_t *);
static int st_local_bind(int, const struct sockaddr *, socklen_t);
static int st_local_connect(int,  const  struct  sockaddr  *, socklen_t);
static int st_local_getsockname(int, struct sockaddr *, socklen_t *);
static int st_local_getsockopt(int, int, int, void *, socklen_t *);
static int st_local_listen(int, int);
static int st_local_recv(int, void *, size_t, int);
static int st_local_recvfrom(int, void *, size_t, int, struct sockaddr *,
	socklen_t *);
static int st_local_send(int, const void *, size_t, int);
static int st_local_sendto(int, const void *, size_t, int,
	const struct sockaddr *, socklen_t);
static int st_local_setsockopt(int, int, int, const void *, socklen_t);
static int st_local_socket(int, int, int);
static int st_local_socket_close(int);

struct sock_test_cmd_s {
	char *st_cmd;
	int (*st_fn)(void);
};

static struct sock_test_cmd_s st_cmds[] = {
	{ "set_addr", st_set_addr},
	{ "set_netmask", st_set_netmask},
	{ "set_router", st_set_router},
	{ "socket", st_socket },
	{ "bind", st_bind },
	{ "accept", st_accept },
	{ "connect", st_connect },
	{ "listen", st_listen },
	{ "send", st_send },
	{ "sendto", st_sendto },
	{ "recv", st_recv },
	{ "recvfrom", st_recvfrom },
	{ "setsockopt", st_setsockopt },
	{ "getsockopt", st_getsockopt },
	{ "getsockname", st_getsockname },
	{ "close", st_sock_close },
	{ "echo", st_echo },
	{ "toggle_promiscous", st_toggle_promiscuous},
	{ "use_obp", st_use_obp},
	{ "tcp_tw_report", st_tcp_tw_report},
	{ NULL, NULL }
};

struct so_option_string_s {
	char *so_name;
	int so_opt;
	int so_opt_level;
} so_option_array[] = {
	{ "rcvtimeo", SO_RCVTIMEO, SOL_SOCKET },
	{ "dontroute", SO_DONTROUTE, SOL_SOCKET },
	{ "reuseaddr", SO_REUSEADDR, SOL_SOCKET },
	{ "rcvbuf", SO_RCVBUF, SOL_SOCKET },
	{ "sndbuf", SO_SNDBUF, SOL_SOCKET },
	{ NULL, 0 }
};

#define	NO_OPENED_SOCKET	-1

/* Right now, we only allow one socket at one time. */
static int g_sock_fd = NO_OPENED_SOCKET;
static int save_g_sock_fd = NO_OPENED_SOCKET;

/* Boolean to decide if OBP network routines should be used. */
static boolean_t use_obp = B_FALSE;


/*
 * The following routines are wrappers for the real socket routines.  The
 * boolean use_obp is used to decide whether the real socket routines is
 * called or the "equivalent" OBP provided routines should be called.
 */
static int
st_local_socket(int domain, int type, int protocol)
{
	if (!use_obp) {
		return (socket(domain, type, protocol));
	} else {
		return (0);
	}
}

static int
st_local_socket_close(int sd)
{
	if (!use_obp) {
		return (socket_close(sd));
	} else {
		return (0);
	}
}

static int
st_local_accept(int sd, struct sockaddr *addr, socklen_t *addr_len)
{
	if (!use_obp) {
		return (accept(sd, addr, addr_len));
	} else {
		return (0);
	}
}

static int
st_local_bind(int sd, const struct sockaddr *name, socklen_t namelen)
{
	if (!use_obp) {
		return (bind(sd, name, namelen));
	} else {
		return (0);
	}
}

static int
st_local_connect(int sd,  const struct sockaddr *addr, socklen_t addr_len)
{
	if (!use_obp) {
		return (connect(sd, addr, addr_len));
	} else {
		return (0);
	}
}

static int
st_local_listen(int sd,  int backlog)
{
	if (!use_obp) {
		return (listen(sd, backlog));
	} else {
		return (0);
	}
}

static int
st_local_send(int sd, const void *msg, size_t len, int flags)
{
	if (!use_obp) {
		return (send(sd, msg, len, flags));
	} else {
		return (0);
	}
}

static int
st_local_sendto(int sd, const void *msg, size_t len, int flags,
    const struct sockaddr *to, socklen_t tolen)
{
	if (!use_obp) {
		return (sendto(sd, msg, len, flags, to, tolen));
	} else {
		return (0);
	}
}

static int
st_local_recv(int sd, void *buf, size_t len, int flags)
{
	if (!use_obp) {
		return (recv(sd, buf, len, flags));
	} else {
		return (0);
	}
}

static int
st_local_recvfrom(int sd, void *buf, size_t len, int flags,
    struct sockaddr *from, socklen_t *fromlen)
{
	if (!use_obp) {
		return (recvfrom(sd, buf, len, flags, from, fromlen));
	} else {
		return (0);
	}
}

static int
st_local_getsockname(int sd, struct sockaddr *name, socklen_t *namelen)
{
	if (!use_obp) {
		return (getsockname(sd, name, namelen));
	} else {
		return (0);
	}
}


static int
st_local_getsockopt(int sd, int level, int option, void *optval,
    socklen_t *optlen)
{
	if (!use_obp) {
		return (getsockopt(sd, level, option, optval, optlen));
	} else {
		return (0);
	}
}

static int
st_local_setsockopt(int sd, int level, int option, const void *optval,
    socklen_t optlen)
{
	if (!use_obp) {
		return (setsockopt(sd, level, option, optval, optlen));
	} else {
		return (0);
	}
}

static int
atoi(const char *p)
{
	int n;
	int c = *p++, neg = 0;

	while (isspace(c)) {
		c = *p++;
	}
	if (!isdigit(c)) {
		switch (c) {
		case '-':
			neg++;
			/* FALLTHROUGH */
		case '+':
			c = *p++;
		}
	}
	for (n = 0; isdigit(c); c = *p++) {
		n *= 10; /* two steps to avoid unnecessary overflow */
		n += '0' - c; /* accum neg to avoid surprises at MAX */
	}
	return (neg ? n : -n);
}

int
st_interpret(char *buf)
{
	char *cmd;
	int i;

	if ((cmd = strtok(buf, " ")) == NULL)
		return (-1);

	for (i = 0; st_cmds[i].st_cmd != NULL; i++) {
		if (strcmp(cmd, st_cmds[i].st_cmd) == 0) {
			return (st_cmds[i].st_fn());
		}
	}
	printf("! Unknown command: %s\n", cmd);
	return (-1);
}


static int
st_socket(void)
{
	char *type;

	if ((type = strtok(NULL, " ")) == NULL) {
		printf("! usage: socket type\n");
		return (-1);
	}
	if (g_sock_fd != NO_OPENED_SOCKET) {
		printf("! Cannot open more than 1 socket\n");
		return (-1);
	}

	if (strcmp(type, "stream") == 0) {
		if ((g_sock_fd = st_local_socket(AF_INET, SOCK_STREAM,
		    0)) < 0) {
			printf("! Error in opening TCP socket: %d\n", errno);
			return (-1);
		} else {
			printf("@ TCP socket opened\n");
		}
	} else if (strcmp(type, "dgram") == 0) {
		if ((g_sock_fd = st_local_socket(AF_INET, SOCK_DGRAM,
		    0)) < 0) {
			printf("! Error in opening UDP socket: %d\n", errno);
			return (-1);
		} else {
			printf("@ UDP socket opened\n");
		}
	} else if (strcmp(type, "raw") == 0) {
		if ((g_sock_fd = st_local_socket(AF_INET, SOCK_RAW, 0)) < 0) {
			printf("! Error in opening RAW socket: %d\n", errno);
			return (-1);
		} else {
			printf("@ RAW socket opened\n");
		}
	} else {
		printf("! Unknown socket type: %s\n", type);
		return (-1);
	}

	return (0);
}

static int
st_set_addr(void)
{
	char *tmp;
	struct in_addr addr;

	tmp = strtok(NULL, " ");
	if (tmp == NULL) {
		printf("! No address given\n");
		return (-1);
	}
	if ((addr.s_addr = inet_addr(tmp)) == (uint32_t)-1) {
		printf("! Malformed address\n");
		return (-1);
	}

	ipv4_setipaddr(&addr);
	printf("@ IP address %s set\n", inet_ntoa(addr));

	return (0);
}

static int
st_set_netmask(void)
{
	char *tmp;
	struct in_addr addr;

	tmp = strtok(NULL, " ");
	if (tmp == NULL) {
		printf("! No netmask given\n");
		return (-1);
	}
	if ((addr.s_addr = inet_addr(tmp)) == (uint32_t)-1) {
		printf("! Malformed netmask\n");
		return (-1);
	}

	ipv4_setnetmask(&addr);
	printf("@ Netmask %s set\n", inet_ntoa(addr));

	return (0);
}

static int
st_set_router(void)
{
	char *tmp;
	struct in_addr addr;

	tmp = strtok(NULL, " ");
	if (tmp == NULL) {
		printf("! No router address given\n");
		return (-1);
	}
	if ((addr.s_addr = inet_addr(tmp)) == (uint32_t)-1) {
		printf("! Malformed router address\n");
		return (-1);
	}

	ipv4_setdefaultrouter(&addr);
	if (ipv4_route(IPV4_ADD_ROUTE, RT_DEFAULT, NULL, &addr) < 0) {
		printf("! Cannot add default route\n");
	} else {
		printf("@ Default router %s set\n", inet_ntoa(addr));
	}

	return (0);
}

static int
st_get_addr_and_port(in_addr_t *addr, unsigned short *port)
{
	char *tmp;

	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}

	tmp = strtok(NULL, "/");
	if (tmp == NULL) {
		printf("! No address given\n");
		return (-1);
	}
	if ((*addr = inet_addr(tmp)) == (uint32_t)-1) {
		printf("! Malformed address\n");
		return (-1);
	}

	tmp = strtok(NULL, " ");
	if (tmp == NULL) {
		printf("! No port given\n");
		return (-1);
	}
	*port = htons(atoi(tmp));

	return (0);
}

static int
st_bind(void)
{
	struct sockaddr_in local_addr;

	if (st_get_addr_and_port(&(local_addr.sin_addr.s_addr),
	    &(local_addr.sin_port)) < 0) {
		return (-1);
	}

	local_addr.sin_family = AF_INET;
	if (st_local_bind(g_sock_fd, (struct sockaddr *)&local_addr,
	    sizeof (local_addr)) < 0) {
		printf("! Bind failed: %d\n", errno);
		return (-1);
	}
	printf("@ Socket bound to %s/%d\n", inet_ntoa(local_addr.sin_addr),
	    ntohs(local_addr.sin_port));
	return (0);
}

static int
st_listen(void)
{
	char *tmp;

	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}
	if ((tmp = strtok(NULL, " ")) == NULL) {
		printf("! No backlog given\n");
		return (-1);
	}
	if (st_local_listen(g_sock_fd, atoi(tmp)) < 0) {
		printf("! Listen failed: %d\n", errno);
		return (-1);
	}
	printf("@ Listen succeeded\n");
	return (0);
}

static int
st_accept(void)
{
	struct sockaddr_in addr;
	socklen_t addr_len;
	int sd;

	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}
	addr_len = sizeof (struct sockaddr_in);
	if ((sd = st_local_accept(g_sock_fd, (struct sockaddr *)&addr,
	    &addr_len)) < 0) {
		printf("! Accept failed: %d\n", errno);
		return (-1);
	}
	printf("@ Accept succeeded from %s:%d.  Socket descriptor saved\n",
	    inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
	save_g_sock_fd = g_sock_fd;
	g_sock_fd = sd;
	return (0);
}

static int
st_connect(void)
{
	struct sockaddr_in peer_addr;

	if (st_get_addr_and_port(&(peer_addr.sin_addr.s_addr),
	    &(peer_addr.sin_port)) < 0) {
		return (-1);
	}

	peer_addr.sin_family = AF_INET;
	if (st_local_connect(g_sock_fd, (struct sockaddr *)&peer_addr,
	    sizeof (peer_addr)) < 0) {
		printf("! Connect failed: %d\n", errno);
		return (-1);
	}
	printf("@ Socket connected to %s/%d\n", inet_ntoa(peer_addr.sin_addr),
	    ntohs(peer_addr.sin_port));

	return (0);
}

static int
st_get_buf_and_cnt(char **buf, int *send_cnt)
{
	char *cnt;

	if ((*buf = strtok(NULL, " ")) == NULL) {
		printf("! No send buffer\n");
		return (-1);
	}
	if ((cnt = strtok(NULL, " ")) == NULL) {
		printf("! Missing send length\n");
		return (-1);
	}

	if ((*send_cnt = atoi(cnt)) < 0) {
		printf("! Invalid send count\n");
		return (-1);
	}
	return (0);
}

static int
st_send(void)
{
	char *buf;
	int send_cnt;

	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}

	if (st_get_buf_and_cnt(&buf, &send_cnt) < 0)
		return (-1);

	if ((send_cnt = st_local_send(g_sock_fd, buf, send_cnt, 0)) < 0) {
		printf("! Send failed: %d\n", errno);
		return (-1);
	}
	printf("@ Send %d bytes\n", send_cnt);

	return (0);
}

static int
st_sendto(void)
{
	struct sockaddr_in peer_addr;
	char *buf;
	int send_cnt;

	if (st_get_addr_and_port(&(peer_addr.sin_addr.s_addr),
	    &(peer_addr.sin_port)) < 0) {
		return (-1);
	}
	peer_addr.sin_family = AF_INET;

	if (st_get_buf_and_cnt(&buf, &send_cnt) < 0)
		return (-1);

	if ((send_cnt = st_local_sendto(g_sock_fd, buf, send_cnt, 0,
	    (struct sockaddr *)&peer_addr, sizeof (peer_addr))) < 0) {
		printf("! Sendto failed: %d\n", errno);
		return (-1);
	}
	printf("@ Send %d bytes\n", send_cnt);

	return (0);
}

static int
st_recv(void)
{
	char *tmp;
	char *buf;
	int buf_len, ret;

	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}

	if ((tmp = strtok(NULL, " ")) == NULL) {
		printf("! No buffer len given\n");
		return (-1);
	}
	buf_len = atoi(tmp);

	if ((buf = bkmem_zalloc(buf_len)) == NULL) {
		printf("! Cannot allocate buffer: %d\n", errno);
		return (-1);
	}
	if ((ret = st_local_recv(g_sock_fd, buf, buf_len, 0)) <= 0) {
		if (ret == 0) {
			printf("@ EOF received: %d\n", errno);
			return (0);
		}
		printf("! Cannot recv: %d\n", errno);
		return (-1);
	}
	printf("@ Bytes received: %d\n", ret);
	hexdump(buf, ret);
	bkmem_free(buf, buf_len);
	return (0);
}

static int
st_recvfrom(void)
{
	char *tmp;
	char *buf;
	int buf_len, ret;
	struct sockaddr_in from;
	socklen_t fromlen;

	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}

	if ((tmp = strtok(NULL, " ")) == NULL) {
		printf("! No buffer len given\n");
		return (-1);
	}
	buf_len = atoi(tmp);

	if ((buf = bkmem_zalloc(buf_len)) == NULL) {
		printf("! Cannot allocate buffer: %d\n", errno);
		return (-1);
	}
	fromlen = sizeof (from);
	if ((ret = st_local_recvfrom(g_sock_fd, buf, buf_len, 0,
	    (struct sockaddr *)&from, &fromlen)) <= 0) {
		if (ret == 0) {
			printf("@ EOF received: %d\n", errno);
			return (0);
		}
		printf("! Cannot recv: %d\n", errno);
		return (-1);
	}
	printf("@ Bytes received from %s/%d: %d\n",
	    inet_ntoa(from.sin_addr), ntohs(from.sin_port), ret);
	hexdump(buf, ret);
	bkmem_free(buf, buf_len);
	return (0);
}

/*
 * To act as an echo server.  Note that it assumes the address and
 * netmask have been set.
 */
static int
st_echo(void)
{
	char *tmp;
	int listen_fd, newfd;
	int echo_port;
	struct sockaddr_in addr;
	socklen_t addr_size;
	int backlog = 20;
	char *buf;
	int buf_len, ret, snd_cnt;

	tmp = strtok(NULL, " ");
	if (tmp == NULL) {
		printf("! No echo port given\n");
		return (-1);
	}
	echo_port = atoi(tmp);
	tmp = strtok(NULL, " ");
	if (tmp == NULL) {
		printf("! No buffer size given\n");
		return (-1);
	}
	buf_len = atoi(tmp);

	/* Create local socket for echo server */
	if ((listen_fd = st_local_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		printf("! Error in opening TCP socket: %d\n", errno);
		return (-1);
	} else {
		printf("@ Local TCP socket opened\n");
	}

	/* Bind local socket */
	addr.sin_family = AF_INET;
	addr.sin_port = htons(echo_port);
	addr.sin_addr.s_addr = INADDR_ANY;

	if (st_local_bind(listen_fd, (struct sockaddr *)&addr,
	    sizeof (addr)) < 0) {
		printf("! Bind failed: %d\n", errno);
		return (-1);
	}
	if (st_local_listen(listen_fd, backlog) < 0) {
		printf("! Listen failed: %d\n", errno);
		return (-1);
	}

	addr_size = sizeof (addr);
	if ((newfd = st_local_accept(listen_fd, (struct sockaddr *)&addr,
	    &addr_size)) < 0) {
		printf("! Accept failed: %d\n", errno);
		(void) st_local_socket_close(listen_fd);
		return (-1);
	}
	printf("@ Accepted connection: %s/%d\n", inet_ntoa(addr.sin_addr),
		ntohs(addr.sin_port));
	(void) st_local_socket_close(listen_fd);

	if ((buf = bkmem_zalloc(buf_len)) == NULL) {
		printf("! Cannot allocate buffer: %d\n", errno);
		(void) st_local_socket_close(newfd);
		return (-1);
	}
	while ((ret = st_local_recv(newfd, buf, buf_len, 0)) > 0) {
		printf("@ Bytes received: %d\n", ret);
		hexdump(buf, ret);
		if ((snd_cnt = st_local_send(newfd, buf, ret, 0)) < ret) {
			printf("! Send failed: %d\n", errno);
			bkmem_free(buf, buf_len);
			return (-1);
		}
		printf("@ Sent %d bytes\n", snd_cnt);
	}
	(void) st_local_socket_close(newfd);
	if (ret < 0) {
		printf("! Cannot recv: %d\n", errno);
		bkmem_free(buf, buf_len);
		return (-1);
	} else {
		return (0);
	}
}

static int
st_match_option(char *opt_s, int *opt, int *opt_level)
{
	int i;

	for (i = 0; so_option_array[i].so_name != NULL; i++) {
		if (strcmp(so_option_array[i].so_name, opt_s) == 0) {
			*opt = so_option_array[i].so_opt;
			*opt_level = so_option_array[i].so_opt_level;
			return (0);
		}
	}
	printf("! Unknown option\n");
	return (-1);
}

static int
st_setsockopt(void)
{
	char *tmp;
	int opt, opt_level, opt_val;

	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}

	if ((tmp = strtok(NULL, " ")) == NULL) {
		printf("! No option given\n");
		return (-1);
	}
	if (st_match_option(tmp, &opt, &opt_level) < 0) {
		return (-1);
	}

	/* We only support integer option for the moment. */
	if ((tmp = strtok(NULL, " ")) == NULL) {
		printf("! No option value given\n");
		return (-1);
	}
	opt_val = atoi(tmp);

	if (st_local_setsockopt(g_sock_fd, opt_level, opt, &opt_val,
	    sizeof (int)) < 0) {
		printf("! Cannot set option: %d\n", errno);
		return (-1);
	}
	printf("@ Option set successfully\n");
	return (0);
}

static int
st_getsockname(void)
{
	struct sockaddr_in addr;
	socklen_t len;

	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}

	len = sizeof (addr);
	if (st_local_getsockname(g_sock_fd, (struct sockaddr *)&addr,
	    &len) < 0) {
		printf("! getsockname failed: %d\n", errno);
		return (-1);
	}
	printf("@ Local socket name: %s/%d\n", inet_ntoa(addr.sin_addr),
	    ntohs(addr.sin_port));
	return (0);
}

static int
st_getsockopt(void)
{
	char *tmp;
	int opt, opt_level, opt_val;
	socklen_t opt_len;

	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}

	if ((tmp = strtok(NULL, " ")) == NULL) {
		printf("! No option given\n");
		return (-1);
	}
	if (st_match_option(tmp, &opt, &opt_level) < 0) {
		return (-1);
	}

	opt_len = sizeof (opt_val);
	if (st_local_getsockopt(g_sock_fd, opt_level, opt, &opt_val,
	    &opt_len) < 0) {
		printf("! Cannot get option: %d\n", errno);
		return (-1);
	}
	printf("@ Option value is %d\n", opt_val);
	return (-1);
}

static int
st_sock_close(void)
{
	if (g_sock_fd == NO_OPENED_SOCKET) {
		printf("! No socket opened\n");
		return (-1);
	}
	if (st_local_socket_close(g_sock_fd) < 0) {
		printf("! Error in closing socket: %d\n", errno);
		return (-1);
	}
	printf("@ Socket closed");
	if (save_g_sock_fd != NO_OPENED_SOCKET) {
		g_sock_fd = save_g_sock_fd;
		save_g_sock_fd = NO_OPENED_SOCKET;
		printf(", switching to saved socket descriptor\n");
	} else {
		g_sock_fd = NO_OPENED_SOCKET;
		printf("\n");
	}
	return (0);
}

static int
st_toggle_promiscuous(void)
{
	/* We always start with non-promiscuous mode. */
	static boolean_t promiscuous = B_FALSE;

	promiscuous = !promiscuous;
	(void) ipv4_setpromiscuous(promiscuous);
	printf("@ Setting promiscuous to %d\n", promiscuous);
	return (0);
}

static int
st_use_obp(void)
{
	if ((use_obp = !use_obp) == B_TRUE) {
		printf("@ Now using OBP routines\n");
	} else {
		printf("@ Now using socket routines\n");
	}
	return (0);
}

static int
st_tcp_tw_report(void)
{
	printf("@ TCP Time Wait report\n");
	tcp_time_wait_report();
	return (0);
}