OpenSolaris_b135/stand/lib/sock/sock_test.c
/*
* 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);
}