* Copyright (C) 1999-2000

/* $NetBSD: altqstat.c,v 1.9 2021/07/24 21:31:39 andvar Exp $ */
/* $KAME: altqstat.c,v 1.8 2002/10/27 03:19:35 kjc Exp $ */
/*
* Copyright (C) 1999-2000
* Sony Computer Science Laboratories, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <sys/param.h>
#include <sys/time.h>
#include <sys/fcntl.h>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#include <err.h>
#ifndef NO_CURSES
#include <curses.h>
#endif

#include "quip_client.h"
#include "altqstat.h"

#define DEV_PATH "/dev/altq"

int qdiscfd = -1;
int show_config = 0;
double ival = 5.0;
int no_server = 0;
char *interface = NULL;
char *qdisc_name = NULL;

stat_loop_t *stat_loop;

__dead static void sig_handler(int);
static void alrm_handler(int);
__dead static void usage(void);

static void
sig_handler(int sig)
{
char buf[8192];

snprintf(buf, sizeof buf, "Exiting on signal %d\n", sig);
write(STDERR_FILENO, buf, strlen(buf));

#ifndef NO_CURSES
/* XXX signal race */
if (qdisc_name != NULL && strcmp(qdisc_name, "wfq") == 0)
endwin(); /* wfqstat uses curses */
#endif
_exit(0);
}

static void
alrm_handler(int sig)
{
/* nothing */
}

static void
usage(void)
{
fprintf(stderr, "usage: altqstat [-enrs] [-c count] [-w wait] [-i interface|-I input_interface]\n");
exit(1);
}

int
main (int argc, char **argv)
{
int ch, raw_mode = 0;
int qtype, interval;
int count = 0;
struct itimerval it;
char device[64], qname[64], input[32];

while ((ch = getopt(argc, argv, "I:c:ei:nrsw:")) != -1) {
switch (ch) {
case 'I':
snprintf(input, sizeof(input), "_%s", optarg);
interface = input;
break;
case 'c':
count = atoi(optarg);
if (count < 1)
errx(1, "Please supply a count value bigger than 0.");
break;
case 'e':
quip_echo = 1;
break;
case 'i':
interface = optarg;
break;
case 'n':
no_server = 1;
break;
case 'r':
raw_mode = 1;
quip_echo = 1;
break;
case 's':
show_config = 1;
break;
case 'w':
ival = strtod(optarg, NULL);
break;
default:
usage();
break;
}
}

signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
signal(SIGPIPE, sig_handler);
signal(SIGALRM, alrm_handler);

if (no_server == 0) {
if (quip_openserver() < 0 && interface == NULL)
errx(1, "you have to specify interface!");
}

if (raw_mode == 1) {
quip_rawmode();
quip_closeserver();
exit(0);
}

if (show_config) {
if (no_server)
errx(1, "no server (-n) can't be set for show config (-s)!");
quip_printconfig();
quip_closeserver();
exit(0);
}

interface = quip_selectinterface(interface);
if (interface == NULL)
errx(1, "no interface found!");

qtype = ifname2qdisc(interface, qname);
if (qtype == 0)
errx(1, "altq is not attached on %s!", interface);

qdisc_name = qname;

stat_loop = qdisc2stat_loop(qdisc_name);
if (stat_loop == NULL)
errx(1, "qdisc %s is not supported!", qdisc_name);

printf("%s: %s on interface %s\n",
argv[0], qdisc_name, interface);

snprintf(device, sizeof(device), "%s/%s", DEV_PATH, qdisc_name);
if ((qdiscfd = open(device, O_RDONLY)) < 0)
err(1, "can't open %s", device);

interval = (int)(ival * 1000.0);
it.it_interval.tv_sec = interval / 1000;
it.it_interval.tv_usec = interval % 1000 * 1000;
it.it_value = it.it_interval;
setitimer(ITIMER_REAL, &it, NULL);

(*stat_loop)(qdiscfd, interface, count, (int)ival);

exit(0);
}

/* calculate interval in sec */
double
calc_interval(struct timeval *cur_time, struct timeval *last_time)
{
double sec;

sec = (double)(cur_time->tv_sec - last_time->tv_sec) +
(double)(cur_time->tv_usec - last_time->tv_usec) / 1000000;
return (sec);
}

/* calculate rate in bps */
double
calc_rate(u_int64_t new_bytes, u_int64_t last_bytes, double interval)
{
double rate;

rate = (double)(new_bytes - last_bytes) * 8 / interval;
return (rate);
}

/* calculate packets in second */
double
calc_pps(u_int64_t new_pkts, u_int64_t last_pkts, double interval)
{
double pps;

pps = (double)(new_pkts - last_pkts) / interval;
return (pps);
}

#define R2S_BUFS 8
#define RATESTR_MAX 16
char *
rate2str(double rate)
{
char *buf;
static char r2sbuf[R2S_BUFS][RATESTR_MAX]; /* ring buffer */
static int idx = 0;

buf = r2sbuf[idx++];
if (idx == R2S_BUFS)
idx = 0;

if (rate == 0.0)
snprintf(buf, RATESTR_MAX, "0");
else if (rate >= 1000000.0)
snprintf(buf, RATESTR_MAX, "%.2fM", rate / 1000000.0);
else
snprintf(buf, RATESTR_MAX, "%.2fk", rate / 1000.0);
return (buf);
}