/*
 * 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);
}