/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <rpc/rpc.h>
#include <rpcsvc/spray.h>
#include <sys/poll.h>

enum clnt_stat sprayproc_spray_1nd(/*argp, clnt*/);

#define	DEFBYTES	100000	/* default numbers of bytes to send */
#define	MAXPACKETLEN	1514
#define	SPRAYOVERHEAD	86	/* size of rpc packet when size=0 */

static void slp(int usecs);
static void usage(void);

int
main(int argc, char *argv[])
{
	int		c;
	extern char	*optarg;
	extern int	optind;
	register CLIENT *clnt;
	unsigned int	i;
	int		delay = 0;
	unsigned int	psec, bsec;
	int		buf[SPRAYMAX/4];
	char		msgbuf[256];
	unsigned int	lnth, cnt;
	sprayarr	arr;
	spraycumul	cumul;
	spraycumul	*co;
	char		*host = NULL;
	char		*type;

	if (argc < 2)
		usage();

	cnt = 0;
	lnth = SPRAYOVERHEAD;
	type = "netpath";
	while (optind < argc) {
		if (argv[optind][0] == '-') {
			if ((c = getopt(argc, argv, "d:c:t:l:")) == EOF) {
				break;
			}
			switch (c) {
				case 'd':
					delay = atoi(optarg);
					break;
				case 'c':
					cnt = (unsigned int) atoi(optarg);
					break;
				case 't':
					type = optarg;
					break;
				case 'l':
					lnth = (unsigned int) atoi(optarg);
					break;
				default:
					usage();
			}
		} else {
			host = argv[optind++];
		}
	}
	if (host == NULL)
		usage();
	clnt = clnt_create(host, SPRAYPROG, SPRAYVERS, type);
	if (clnt == (CLIENT *)NULL) {
		sprintf(msgbuf, "spray: cannot clnt_create %s:%s", host, type);
		clnt_pcreateerror(msgbuf);
		exit(1);
	}
	if (cnt == 0)
		cnt = DEFBYTES/lnth;
	if (lnth < SPRAYOVERHEAD)
		lnth = SPRAYOVERHEAD;
	else if (lnth >= SPRAYMAX)
		lnth = SPRAYMAX;
	if (lnth <= MAXPACKETLEN && lnth % 4 != 2)
		lnth = ((lnth + 5) / 4) * 4 - 2;
	arr.sprayarr_len = lnth - SPRAYOVERHEAD;
	arr.sprayarr_val = (char *)buf;
	printf("sending %u packets of length %u to %s ...", cnt, lnth, host);
	fflush(stdout);
	if (sprayproc_clear_1(NULL, clnt) == NULL) {
		clnt_perror(clnt, "SPRAYPROC_CLEAR ");
		exit(1);
	}
	for (i = 0; i < cnt; i++) {
		sprayproc_spray_1nd(&arr, clnt);
		if (delay > 0)
			slp(delay);
	}
	if ((co = sprayproc_get_1(NULL, clnt)) == NULL) {
		clnt_perror(clnt, "SPRAYPROC_GET ");
		exit(1);
	}
	cumul = *co;
	if (cumul.counter < cnt)
		printf("\n\t%d packets (%.3f%%) dropped by %s\n",
		    cnt - cumul.counter,
		    100.0 * (cnt - cumul.counter)/cnt, host);
	else
		printf("\n\tno packets dropped by %s\n", host);
	psec = (1000000.0 * cumul.counter) /
	    (1000000.0 * cumul.clock.sec + cumul.clock.usec);
	bsec = (lnth * 1000000.0 * cumul.counter) /
	    (1000000.0 * cumul.clock.sec + cumul.clock.usec);
	printf("\t%u packets/sec, %u bytes/sec\n", psec, bsec);
	exit(0);
	/* NOTREACHED */
}

/*
 * A special call, where the TIMEOUT is 0. So, every call times-out.
 */
static struct timeval TIMEOUT = { 0, 0 };

enum clnt_stat
sprayproc_spray_1nd(sprayarr *argp, CLIENT *clnt)
{
	return (clnt_call(clnt, SPRAYPROC_SPRAY, xdr_sprayarr, (caddr_t)argp,
	    xdr_void, NULL, TIMEOUT));
}

/* A cheap milliseconds sleep call */
static void
slp(int usecs)
{
	static struct pollfd pfds[1] = {
		0, POLLIN, 0
	};
	pfds[0].fd = fileno(stdout);
	poll(pfds, 1, usecs/1000);
}

static void
usage()
{
	printf("spray host [-t nettype] [-l lnth] [-c cnt] [-d delay]\n");
	exit(1);
}