/*
* Copyright (c) 2010-2011, Red Hat, Inc.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND RED HAT, INC. DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL RED HAT, INC. BE LIABLE
* FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Author: Jan Friesse <jfriesse@redhat.com>
*/
#define __STDC_LIMIT_MACROS
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <err.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "addrfunc.h"
#include "omping.h"
#include "cli.h"
#include "logging.h"
static void conv_list_addrs(struct ai_list *ai_list, int ip_ver);
static void conv_local_addr(struct ai_list *ai_list, struct ai_item *ai_local,
const struct ifaddrs *ifa_local, int ip_ver, struct ai_item *local_addr, int *single_addr);
static int conv_params_ipbc(struct ai_item *ipbc_addr, const char *ipbc_addr_s,
const char *port_s, const struct ifaddrs *ifa_local);
static void conv_params_mcast(int ip_ver, struct ai_item *mcast_addr, const char *mcast_addr_s,
const char *port_s);
static int parse_remote_addrs(int argc, char * const argv[], const char *port, int ip_ver,
struct ai_list *ai_list);
static int return_ip_ver(int ip_ver, const char *mcast_addr, const char *port,
struct ai_list *ai_list);
static void show_version(void);
static void usage();
/*
* Parse command line.
* argc and argv are passed from main function. local_ifname will be allocated and filled by name
* of local ethernet interface. ip_ver will be filled by forced ip version or will
* be 0. mcast_addr will be filled by requested mcast address or will be NULL. Port will be filled
* by requested port (string value) or will be NULL. ai_list will be initialized and requested
* hostnames will be stored there. ttl is pointer where user set TTL or default TTL will be stored.
* single_addr is boolean set if only one remote address is entered. quiet is flag for quiet mode.
* cont_stat is flag for enable continuous statistic. timeout_time is number of miliseconds after
* which client exits regardless to number of received/sent packets. wait_for_finish_time is number
* of miliseconds to wait before exit to allow other nodes not to screw up final statistics.
* dup_buf_items is number of items which should be stored in duplicate packet detection buffer.
* Default is MIN_DUP_BUF_ITEMS for intervals > 1, or DUP_BUF_SECS value divided by ping interval
* in seconds or 0, which is used for disabling duplicate detection. rate_limit_time is maximum
* time between two received packets. sndbuf_size is size of socket buffer to allocate for sending
* packets. rcvbuf_size is size of socket buffer to allocate for receiving packets. Both
* sndbuf_size and rcvbuf_size are set to 0 if user doesn't supply option. send_count_queries is by
* default set to 0, but may be overwritten by user and it means that after sending that number of
* queries, client is put to stop state. auto_exit is boolean variable which is enabled by default
* and can be disabled by -E option. If auto_exit is enabled, loop will end if every client is in
* STOP state.
*/
int
cli_parse(struct ai_list *ai_list, int argc, char * const argv[], char **local_ifname, int *ip_ver,
struct ai_item *local_addr, int *wait_time, enum sf_transport_method *transport_method,
struct ai_item *mcast_addr, uint16_t *port, uint8_t *ttl, int *single_addr, int *quiet,
int *cont_stat, int *timeout_time, int *wait_for_finish_time, int *dup_buf_items,
int *rate_limit_time, int *sndbuf_size, int *rcvbuf_size, uint64_t *send_count_queries,
int *auto_exit, enum omping_op_mode *op_mode)
{
struct ai_item *ai_item;
struct ifaddrs *ifa_list, *ifa_local;
char *ep;
char *mcast_addr_s;
const char *port_s;
double numd;
int ch;
int force;
int num;
int res;
int rate_limit_time_set;
int show_ver;
int wait_for_finish_time_set;
unsigned int ifa_flags;
*auto_exit = 1;
*cont_stat = 0;
*dup_buf_items = MIN_DUP_BUF_ITEMS;
*ip_ver = 0;
*local_ifname = NULL;
mcast_addr_s = NULL;
*op_mode = OMPING_OP_MODE_NORMAL;
*quiet = 0;
*send_count_queries = 0;
*sndbuf_size = 0;
*single_addr = 0;
*rate_limit_time = 0;
*rcvbuf_size = 0;
*timeout_time = 0;
*ttl = DEFAULT_TTL;
*transport_method = SF_TM_ASM;
*wait_time = DEFAULT_WAIT_TIME;
*wait_for_finish_time = 0;
force = 0;
ifa_flags = IFF_MULTICAST;
port_s = DEFAULT_PORT_S;
rate_limit_time_set = 0;
show_ver = 0;
wait_for_finish_time_set = 0;
logging_set_verbose(0);
while ((ch = getopt(argc, argv, "46CDEFqVvc:i:M:m:O:p:R:r:S:T:t:w:")) != -1) {
switch (ch) {
case '4':
*ip_ver = 4;
break;
case '6':
*ip_ver = 6;
break;
case 'C':
(*cont_stat)++;
break;
case 'D':
*dup_buf_items = 0;
break;
case 'E':
*auto_exit = 0;
break;
case 'F':
force++;
break;
case 'q':
(*quiet)++;
break;
case 'V':
show_ver++;
break;
case 'v':
logging_set_verbose(logging_get_verbose() + 1);
break;
case 'c':
numd = strtod(optarg, &ep);
if (numd < 1 || *ep != '\0' || numd >= ((uint64_t)~0)) {
warnx("illegal number, -c argument -- %s", optarg);
goto error_usage_exit;
}
*send_count_queries= (uint64_t)numd;
break;
case 'i':
numd = strtod(optarg, &ep);
if (numd < 0 || *ep != '\0' || numd * 1000 > INT32_MAX) {
warnx("illegal number, -i argument -- %s", optarg);
goto error_usage_exit;
}
*wait_time = (int)(numd * 1000.0);
break;
case 'M':
if (strcmp(optarg, "asm") == 0) {
*transport_method = SF_TM_ASM;
ifa_flags = IFF_MULTICAST;
} else if (strcmp(optarg, "ssm") == 0 && sf_is_ssm_supported()) {
*transport_method = SF_TM_SSM;
ifa_flags = IFF_MULTICAST;
} else if (strcmp(optarg, "ipbc") == 0 && sf_is_ipbc_supported()) {
*transport_method = SF_TM_IPBC;
ifa_flags = IFF_BROADCAST;
} else {
warnx("illegal parameter, -M argument -- %s", optarg);
goto error_usage_exit;
}
break;
case 'm':
mcast_addr_s = optarg;
break;
case 'O':
if (strcmp(optarg, "normal") == 0) {
*op_mode = OMPING_OP_MODE_NORMAL;
/*
* Temporarily disabled
*
} else if (strcmp(optarg, "server") == 0) {
*op_mode = OMPING_OP_MODE_SERVER;
*/
} else if (strcmp(optarg, "client") == 0) {
*op_mode = OMPING_OP_MODE_CLIENT;
} else {
warnx("illegal parameter, -O argument -- %s", optarg);
goto error_usage_exit;
}
break;
case 'p':
port_s = optarg;
break;
case 'R':
numd = strtod(optarg, &ep);
if (numd < MIN_RCVBUF_SIZE || *ep != '\0' || numd > INT32_MAX) {
warnx("illegal number, -R argument -- %s", optarg);
goto error_usage_exit;
}
*rcvbuf_size = (int)numd;
break;
case 'r':
numd = strtod(optarg, &ep);
if (numd < 0 || *ep != '\0' || numd * 1000 > INT32_MAX) {
warnx("illegal number, -r argument -- %s", optarg);
goto error_usage_exit;
}
*rate_limit_time = (int)(numd * 1000.0);
rate_limit_time_set = 1;
break;
case 'S':
numd = strtod(optarg, &ep);
if (numd < MIN_SNDBUF_SIZE || *ep != '\0' || numd > INT32_MAX) {
warnx("illegal number, -S argument -- %s", optarg);
goto error_usage_exit;
}
*sndbuf_size = (int)numd;
break;
case 't':
num = strtol(optarg, &ep, 10);
if (num <= 0 || num > ((uint8_t)~0) || *ep != '\0') {
warnx("illegal number, -t argument -- %s", optarg);
goto error_usage_exit;
}
*ttl = num;
break;
case 'T':
numd = strtod(optarg, &ep);
if (numd < 0 || *ep != '\0' || numd * 1000 > INT32_MAX) {
warnx("illegal number, -T argument -- %s", optarg);
goto error_usage_exit;
}
*timeout_time = (int)(numd * 1000.0);
break;
case 'w':
numd = strtod(optarg, &ep);
if ((numd < 0 && numd != -1) || *ep != '\0' || numd * 1000 > INT32_MAX) {
warnx("illegal number, -w argument -- %s", optarg);
goto error_usage_exit;
}
wait_for_finish_time_set = 1;
*wait_for_finish_time = (int)(numd * 1000.0);
break;
case '?':
goto error_usage_exit;
/* NOTREACHED */
break;
}
}
argc -= optind;
argv += optind;
/*
* Param checking
*/
if (show_ver == 1) {
show_version();
exit(0);
}
if (show_ver > 1) {
if (*op_mode != OMPING_OP_MODE_NORMAL) {
warnx("op_mode must be set to normal for remote version display.");
goto error_usage_exit;
}
*op_mode = OMPING_OP_MODE_SHOW_VERSION;
}
if (force < 1) {
if (*wait_time < DEFAULT_WAIT_TIME) {
warnx("illegal nmber, -i argument %u ms < %u ms. Use -F to force.",
*wait_time, DEFAULT_WAIT_TIME);
goto error_usage_exit;
}
if (*ttl < DEFAULT_TTL) {
warnx("illegal nmber, -t argument %u < %u. Use -F to force.",
*ttl, DEFAULT_TTL);
goto error_usage_exit;
}
}
if (force < 2) {
if (*wait_time == 0) {
warnx("illegal nmber, -i argument %u ms < 1 ms. Use -FF to force.",
*wait_time);
goto error_usage_exit;
}
}
if (*transport_method == SF_TM_IPBC) {
if (*ip_ver == 6) {
warnx("illegal transport method, -M argument ipbc is mutually exclusive "
"with -6 option");
goto error_usage_exit;
}
*ip_ver = 4;
}
/*
* Computed params
*/
if (!wait_for_finish_time_set) {
*wait_for_finish_time = *wait_time * DEFAULT_WFF_TIME_MUL;
if (*wait_for_finish_time < DEFAULT_WAIT_TIME) {
*wait_for_finish_time = DEFAULT_WAIT_TIME;
}
}
if (*wait_time == 0) {
*dup_buf_items = 0;
} else {
/*
* + 1 is for eliminate trucate errors
*/
*dup_buf_items = ((DUP_BUF_SECS * 1000) / *wait_time) + 1;
if (*dup_buf_items < MIN_DUP_BUF_ITEMS) {
*dup_buf_items = MIN_DUP_BUF_ITEMS;
}
}
if (!rate_limit_time_set) {
*rate_limit_time = *wait_time;
}
TAILQ_INIT(ai_list);
parse_remote_addrs(argc, argv, port_s, *ip_ver, ai_list);
*ip_ver = return_ip_ver(*ip_ver, mcast_addr_s, port_s, ai_list);
if (af_find_local_ai(ai_list, ip_ver, &ifa_list, &ifa_local, &ai_item, ifa_flags) < 0) {
errx(1, "Can't find local address in arguments");
}
/*
* Change ai_list to struct of sockaddr_storage(s)
*/
conv_list_addrs(ai_list, *ip_ver);
/*
* Find local addr and copy that. Also remove that from list
*/
conv_local_addr(ai_list, ai_item, ifa_local, *ip_ver, local_addr, single_addr);
/*
* Store local ifname
*/
*local_ifname = strdup(ifa_local->ifa_name);
if (*local_ifname == NULL) {
errx(1, "Can't alloc memory");
}
switch (*transport_method) {
case SF_TM_ASM:
case SF_TM_SSM:
/*
* Convert mcast addr to something useful
*/
conv_params_mcast(*ip_ver, mcast_addr, mcast_addr_s, port_s);
break;
case SF_TM_IPBC:
/*
* Convert broadcast addr to something useful
*/
res = conv_params_ipbc(mcast_addr, mcast_addr_s, port_s, ifa_local);
if (res == -1) {
warnx("illegal broadcast address, -M argument doesn't match with local"
" broadcast address");
goto error_usage_exit;
}
break;
}
/*
* Assign port from mcast_addr
*/
*port = af_sa_port(AF_CAST_SA(&mcast_addr->sas));
freeifaddrs(ifa_list);
return (0);
error_usage_exit:
usage();
exit(1);
/* NOTREACHED */
return (-1);
}
/*
* Convert list of addrs of addrinfo to list of addrs of sockaddr_storage. This function will also
* correctly free addrinfo(s) in list.
*/
static void
conv_list_addrs(struct ai_list *ai_list, int ip_ver)
{
struct sockaddr_storage tmp_sas;
struct addrinfo *ai_i;
struct ai_item *ai_item_i;
char *hn;
TAILQ_FOREACH(ai_item_i, ai_list, entries) {
hn = (char *)malloc(strlen(ai_item_i->host_name) + 1);
if (hn == NULL) {
errx(1, "Can't alloc memory");
}
memcpy(hn, ai_item_i->host_name, strlen(ai_item_i->host_name) + 1);
ai_item_i->host_name = hn;
for (ai_i = ai_item_i->ai; ai_i != NULL; ai_i = ai_i->ai_next) {
if (af_ai_supported_ipv(ai_i) == ip_ver) {
memset(&tmp_sas, 0, sizeof(tmp_sas));
memcpy(&tmp_sas, ai_i->ai_addr, ai_i->ai_addrlen);
freeaddrinfo(ai_item_i->ai);
memcpy(&ai_item_i->sas, &tmp_sas, sizeof(tmp_sas));
break;
}
}
}
}
/*
* Convert ifa_local addr to local_addr. If only one remote_host is entered, single_addr is set, if
* not then ai_local is freed and removed from list.
*/
static void
conv_local_addr(struct ai_list *ai_list, struct ai_item *ai_local,
const struct ifaddrs *ifa_local, int ip_ver, struct ai_item *local_addr, int *single_addr)
{
size_t addr_len;
uint16_t port;
switch (ifa_local->ifa_addr->sa_family) {
case AF_INET:
addr_len = sizeof(struct sockaddr_in);
port = ((struct sockaddr_in *)&ai_local->sas)->sin_port;
break;
case AF_INET6:
addr_len = sizeof(struct sockaddr_in6);
port = ((struct sockaddr_in6 *)&ai_local->sas)->sin6_port;
break;
default:
DEBUG_PRINTF("Internal program error");
err(1, "Internal program error");
break;
}
memcpy(&local_addr->sas, ifa_local->ifa_addr, addr_len);
local_addr->host_name = strdup(ai_local->host_name);
if (local_addr->host_name == NULL) {
err(1, "Can't alloc memory");
/* NOTREACHED */
}
switch (ifa_local->ifa_addr->sa_family) {
case AF_INET:
((struct sockaddr_in *)&local_addr->sas)->sin_port = port;
break;
case AF_INET6:
((struct sockaddr_in6 *)&local_addr->sas)->sin6_port = port;
break;
default:
DEBUG_PRINTF("Internal program error");
err(1, "Internal program error");
break;
}
*single_addr = (TAILQ_NEXT(TAILQ_FIRST(ai_list), entries) == NULL);
if (!*single_addr) {
TAILQ_REMOVE(ai_list, ai_local, entries);
free(ai_local->host_name);
free(ai_local);
}
}
/*
* Convert ipbc_addr_s to ipbc_addr ai_item.
* Function returns 0 on success, -1 if given broadcast address is not same as local interface one.
*/
static int
conv_params_ipbc(struct ai_item *ipbc_addr, const char *ipbc_addr_s, const char *port_s,
const struct ifaddrs *ifa_local)
{
struct addrinfo *ai_res, *ai_i;
char ifa_ipbc_addr_s[INET6_ADDRSTRLEN];
int ip_ver;
ip_ver = 4;
if (ifa_local->ifa_broadaddr == NULL) {
errx(1, "selected local interface isn't broadcast aware");
}
if (ipbc_addr_s == NULL) {
af_sa_to_str(ifa_local->ifa_broadaddr, ifa_ipbc_addr_s);
ipbc_addr_s = ifa_ipbc_addr_s;
}
ipbc_addr->host_name = (char *)malloc(strlen(ipbc_addr_s) + 1);
if (ipbc_addr->host_name == NULL) {
errx(1, "Can't alloc memory");
}
memcpy(ipbc_addr->host_name, ipbc_addr_s, strlen(ipbc_addr_s) + 1);
ai_res = af_host_to_ai(ipbc_addr_s, port_s, ip_ver);
for (ai_i = ai_res; ai_i != NULL; ai_i = ai_i->ai_next) {
if (af_ai_supported_ipv(ai_i) == ip_ver) {
memcpy(&ipbc_addr->sas, ai_i->ai_addr, ai_i->ai_addrlen);
break;
}
}
if (ai_i == NULL) {
DEBUG_PRINTF("Internal program error");
err(1, "Internal program error");
}
freeaddrinfo(ai_res);
/*
* Test if interface broadcast addr is same as returned broadcast addr
*/
if (!af_sockaddr_eq(ifa_local->ifa_broadaddr, AF_CAST_SA(&ipbc_addr->sas))) {
return (-1);
}
return (0);
}
/*
* Convert mcast_addr_s to mcast_addr ai_item
*/
static void
conv_params_mcast(int ip_ver, struct ai_item *mcast_addr, const char *mcast_addr_s,
const char *port_s)
{
struct addrinfo *ai_res, *ai_i;
if (mcast_addr_s == NULL) {
switch (ip_ver) {
case 4:
mcast_addr_s = DEFAULT_MCAST4_ADDR;
break;
case 6:
mcast_addr_s = DEFAULT_MCAST6_ADDR;
break;
default:
DEBUG_PRINTF("Internal program error");
err(1, "Internal program error");
break;
}
}
mcast_addr->host_name = (char *)malloc(strlen(mcast_addr_s) + 1);
if (mcast_addr->host_name == NULL) {
errx(1, "Can't alloc memory");
}
memcpy(mcast_addr->host_name, mcast_addr_s, strlen(mcast_addr_s) + 1);
ai_res = af_host_to_ai(mcast_addr_s, port_s, ip_ver);
for (ai_i = ai_res; ai_i != NULL; ai_i = ai_i->ai_next) {
if (af_ai_supported_ipv(ai_i) == ip_ver) {
memcpy(&mcast_addr->sas, ai_i->ai_addr, ai_i->ai_addrlen);
break;
}
}
if (ai_i == NULL) {
DEBUG_PRINTF("Internal program error");
err(1, "Internal program error");
}
freeaddrinfo(ai_res);
/*
* Test if addr is really multicast
*/
if (!af_is_sa_mcast(AF_CAST_SA(&mcast_addr->sas))) {
errx(1, "Given address %s is not valid multicast address", mcast_addr_s);
}
}
/*
* Parse remote addresses. Return list of addresses taken from cli
*/
static int
parse_remote_addrs(int argc, char * const argv[], const char *port, int ip_ver,
struct ai_list *ai_list)
{
struct addrinfo *ai_res;
struct ai_item *ai_item;
int no_ai;
int i;
no_ai = 0;
for (i = 0; i < argc; i++) {
ai_res = af_host_to_ai(argv[i], port, ip_ver);
if (!af_is_ai_in_list(ai_res, ai_list)) {
if (af_ai_deep_is_loopback(ai_res)) {
errx(1,"Address %s looks like loopback. Loopback ping is not "
"supported", argv[i]);
}
ai_item = (struct ai_item *)malloc(sizeof(struct ai_item));
if (ai_item == NULL) {
errx(1, "Can't alloc memory");
}
memset(ai_item, 0, sizeof(struct ai_item));
ai_item->ai = ai_res;
ai_item->host_name = argv[i];
TAILQ_INSERT_TAIL(ai_list, ai_item, entries);
DEBUG_PRINTF("new address \"%s\" added to list (position %d)", argv[i],
no_ai);
no_ai++;
} else {
freeaddrinfo(ai_res);
}
}
if (no_ai < 1) {
warnx("at least one remote addresses should be specified");
usage();
exit(1);
}
return (no_ai);
}
/*
* Return ip version to use. Algorithm is following:
* - If user forced ip version, we will return that one.
* - If user entered mcast addr, we will look, what it supports
* - if only one version is supported, we will return that version
* - otherwise walk addresses and find out, what they support
* - test if every addresses support all versions.
* - If not, test that version for every other addresses
* - if all of them support that version -> return that version
* - if not -> return error
* - otherwise return 0 (item in find_local_addrinfo will be used but preferably ipv6)
*/
static int
return_ip_ver(int ip_ver, const char *mcast_addr, const char *port, struct ai_list *ai_list)
{
struct addrinfo *ai_res;
struct ai_item *aip;
int mcast_ipver;
int ipver_res, ipver_res2;
if (ip_ver != 0) {
DEBUG_PRINTF("user forced forced ip_ver is %d, using that", ip_ver);
return (ip_ver);
}
if (mcast_addr != NULL) {
ai_res = af_host_to_ai(mcast_addr, port, ip_ver);
mcast_ipver = af_ai_deep_supported_ipv(ai_res);
DEBUG2_PRINTF("mcast_ipver for %s is %d", mcast_addr, mcast_ipver);
freeaddrinfo(ai_res);
if (mcast_ipver == -1) {
errx(1, "Mcast address %s doesn't support ipv4 or ipv6", mcast_addr);
}
if (mcast_ipver != 0) {
DEBUG_PRINTF("mcast address for %s supports only ipv%d, using that",
mcast_addr, mcast_ipver);
/*
* Walk thru all addresses to find out, what it supports
*/
TAILQ_FOREACH(aip, ai_list, entries) {
ipver_res = af_ai_deep_supported_ipv(aip->ai);
DEBUG2_PRINTF("ipver for %s is %d", aip->host_name, ipver_res);
if (ipver_res == -1) {
errx(1, "Host %s doesn't support ipv4 or ipv6",
aip->host_name);
}
if (ipver_res != 0 && ipver_res != mcast_ipver) {
errx(1, "Multicast address is ipv%d but host %s supports"
" only ipv%d", mcast_ipver, aip->host_name, ipver_res);
}
}
return (mcast_ipver);
}
}
ipver_res = 0;
/*
* Walk thru all addresses to find out, what it supports
*/
TAILQ_FOREACH(aip, ai_list, entries) {
ipver_res = af_ai_deep_supported_ipv(aip->ai);
DEBUG2_PRINTF("ipver for %s is %d", aip->host_name, ipver_res);
if (ipver_res == -1) {
errx(1, "Host %s doesn't support ipv4 or ipv6", aip->host_name);
}
if (ipver_res != 0) {
break;
}
}
if (ipver_res == 0) {
/*
* Every address support every version
*/
DEBUG_PRINTF("Every address support all IP versions");
return (0);
}
if (ipver_res != 0) {
/*
* Host supports only one version.
* Test availability for that version on all hosts
*/
TAILQ_FOREACH(aip, ai_list, entries) {
ipver_res2 = af_ai_deep_supported_ipv(aip->ai);
DEBUG2_PRINTF("ipver for %s is %d", aip->host_name, ipver_res2);
if (ipver_res2 == -1) {
errx(1, "Host %s doesn't support ipv4 or ipv6", aip->host_name);
}
if (ipver_res2 != 0 && ipver_res2 != ipver_res) {
/*
* Host doesn't support ip version of other members
*/
errx(1, "Host %s doesn't support IP version %d", aip->host_name,
ipver_res);
}
}
}
DEBUG_PRINTF("Every address support ipv%d", ipver_res);
return (ipver_res);
}
/*
* Show application version
*/
static void
show_version(void)
{
printf("%s version %s\n", PROGRAM_NAME, PROGRAM_VERSION);
}
/*
* Display application ussage
*/
static void
usage()
{
printf("usage: %s [-46CDEFqVv] [-c count] [-i interval] [-M transport_method]\n",
PROGRAM_NAME);
printf("%14s[-m mcast_addr] [-O op_mode] [-p port] [-R rcvbuf] [-r rate_limit]\n", "");
printf("%14s[-S sndbuf] [-T timeout] [-t ttl] [-w wait_time] remote_addr...\n", "");
}