if (ioctl(s, SIOCGETVLAN, (caddr_t)&ifr) == -1)
err(1, "SIOCGETVLAN");
bzero((char *)&vreq.vlr_parent, sizeof(vreq.vlr_parent));
vreq.vlr_tag = 0;
if (ioctl(s, SIOCSETVLAN, (caddr_t)&ifr) == -1)
err(1, "SIOCSETVLAN");
}
static struct cmd vlan_cmds[] = {
DEF_CLONE_CMD_ARG("vlan", setvlantag),
DEF_CLONE_CMD_ARG("vlandev", setvlandev),
/* NB: non-clone cmds */
DEF_CMD_ARG("vlan", setvlantag),
DEF_CMD_ARG("vlandev", setvlandev),
/* XXX For compatibility. Should become DEF_CMD() some day. */
DEF_CMD_OPTARG("-vlandev", unsetvlandev),
DEF_CMD("vlanmtu", IFCAP_VLAN_MTU, setifcap),
DEF_CMD("-vlanmtu", -IFCAP_VLAN_MTU, setifcap),
DEF_CMD("vlanhwtag", IFCAP_VLAN_HWTAGGING, setifcap),
DEF_CMD("-vlanhwtag", -IFCAP_VLAN_HWTAGGING, setifcap),
DEF_CMD("vlanhwfilter", IFCAP_VLAN_HWFILTER, setifcap),
DEF_CMD("-vlanhwfilter", -IFCAP_VLAN_HWFILTER, setifcap),
DEF_CMD("-vlanhwtso", -IFCAP_VLAN_HWTSO, setifcap),
DEF_CMD("vlanhwtso", IFCAP_VLAN_HWTSO, setifcap),
DEF_CMD("vlanhwcsum", IFCAP_VLAN_HWCSUM, setifcap),
DEF_CMD("-vlanhwcsum", -IFCAP_VLAN_HWCSUM, setifcap),
};
static struct afswtch af_vlan = {
DEF_CLONE_CMD_ARG("vxlanid", setvxlan_vni),
DEF_CLONE_CMD_ARG("vxlanlocal", setvxlan_local),
DEF_CLONE_CMD_ARG("vxlanremote", setvxlan_remote),
DEF_CLONE_CMD_ARG("vxlangroup", setvxlan_group),
DEF_CLONE_CMD_ARG("vxlanlocalport", setvxlan_local_port),
DEF_CLONE_CMD_ARG("vxlanremoteport", setvxlan_remote_port),
DEF_CLONE_CMD_ARG2("vxlanportrange", setvxlan_port_range),
DEF_CLONE_CMD_ARG("vxlantimeout", setvxlan_timeout),
DEF_CLONE_CMD_ARG("vxlanmaxaddr", setvxlan_maxaddr),
DEF_CLONE_CMD_ARG("vxlandev", setvxlan_dev),
DEF_CLONE_CMD_ARG("vxlanttl", setvxlan_ttl),
DEF_CLONE_CMD("vxlanlearn", 1, setvxlan_learn),
DEF_CLONE_CMD("-vxlanlearn", 0, setvxlan_learn),
DEF_CMD_ARG("vxlanvni", setvxlan_vni),
DEF_CMD_ARG("vxlanlocal", setvxlan_local),
DEF_CMD_ARG("vxlanremote", setvxlan_remote),
DEF_CMD_ARG("vxlangroup", setvxlan_group),
DEF_CMD_ARG("vxlanlocalport", setvxlan_local_port),
DEF_CMD_ARG("vxlanremoteport", setvxlan_remote_port),
DEF_CMD_ARG2("vxlanportrange", setvxlan_port_range),
DEF_CMD_ARG("vxlantimeout", setvxlan_timeout),
DEF_CMD_ARG("vxlanmaxaddr", setvxlan_maxaddr),
DEF_CMD_ARG("vxlandev", setvxlan_dev),
DEF_CMD_ARG("vxlanttl", setvxlan_ttl),
DEF_CMD("vxlanlearn", 1, setvxlan_learn),
DEF_CMD("-vxlanlearn", 0, setvxlan_learn),
DEF_CMD("vxlanflush", 0, setvxlan_flush),
DEF_CMD("vxlanflushall", 1, setvxlan_flush),
char *ep;
fib = strtoul(val, &ep, 0);
if (*ep != '\0' || fib > UINT_MAX) {
warn("fib %s not valid", val);
return;
}
strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
ifr.ifr_fib = fib;
if (ioctl(s, SIOCSTUNFIB, (caddr_t)&ifr) < 0)
warn("ioctl (SIOCSTUNFIB)");
}
static struct cmd fib_cmds[] = {
DEF_CMD_ARG("fib", setiffib),
DEF_CMD_ARG("tunnelfib", settunfib),
};
static struct afswtch af_fib = {
.af_name = "af_fib",
.af_af = AF_UNSPEC,
.af_other_status = fib_status,
};
static __constructor void
fib_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
size_t i;
putchar('\n');
if (verbose && ra.ra_proto == LAGG_PROTO_LACP)
printf("\t\t%s\n",
lacp_format_peer(lp, "\n\t\t "));
}
if (0 /* XXX */) {
printf("\tsupported aggregation protocols:\n");
for (i = 0; i < nitems(lpr); i++)
printf("\t\tlaggproto %s\n", lpr[i].lpr_name);
}
}
}
static struct cmd lagg_cmds[] = {
DEF_CMD_ARG("laggport", setlaggport),
DEF_CMD_ARG("-laggport", unsetlaggport),
DEF_CMD_ARG("laggproto", setlaggproto),
DEF_CMD_ARG("lagghash", setlagghash),
};
static struct afswtch af_lagg = {
.af_name = "af_lagg",
.af_af = AF_UNSPEC,
.af_other_status = lagg_status,
};
static __constructor(101) void
lagg_ctor(void)
{
size_t i;
}
for (ifg = ifgr.ifgr_groups; ifg && len >= sizeof(struct ifg_req);
ifg++) {
len -= sizeof(struct ifg_req);
printf("%s\n", ifg->ifgrq_member);
cnt++;
}
free(ifgr.ifgr_groups);
close(s);
exit(0);
}
static struct cmd group_cmds[] = {
DEF_CMD_ARG("group", setifgroup),
DEF_CMD_ARG("-group", unsetifgroup),
};
static struct afswtch af_group = {
.af_name = "af_group",
.af_af = AF_UNSPEC,
.af_other_status = getifgroups,
};
static struct option group_gopt = { "g:", "[-g groupname]", printgroup };
#ifndef __rtems__
static __constructor void
#else /* __rtems__ */
void
#endif /* __rtems__ */
group_ctor(void)
char *ep;
fib = strtoul(val, &ep, 0);
if (*ep != '\0' || fib > UINT_MAX) {
warn("fib %s not valid", val);
return;
}
strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
ifr.ifr_fib = fib;
if (ioctl(s, SIOCSIFFIB, (caddr_t)&ifr) < 0)
warn("ioctl (SIOCSIFFIB)");
}
static struct cmd fib_cmds[] = {
DEF_CMD_ARG("fib", setiffib),
};
static struct afswtch af_fib = {
.af_name = "af_fib",
.af_af = AF_UNSPEC,
.af_other_status = fib_status,
};
static __constructor void
fib_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
size_t i;
for (i = 0; i < N(fib_cmds); i++)
if (carpa[i].carpa_baddr.sin_addr.s_addr != INADDR_ANY) {
inet_ntop(AF_INET, &carpa[i].carpa_baddr.sin_addr,
baddr, sizeof(baddr));
}
printf(VHADDR_PFMT, inet_ntoa(carpa[i].carpa_addr.sin_addr),
baddr, flags);
}
if (carpa != NULL)
free(carpa);
#undef VHADDR_PFMT
}
static struct cmd carp_cmds[] = {
DEF_CMD_ARG("advbase", setcarp_advbase),
DEF_CMD_ARG("advskew", setcarp_advskew),
DEF_CMD_ARG("pass", setcarp_passwd),
DEF_CMD_ARG("vhid", setcarp_vhid),
DEF_CMD("vhaddr", 1, getcarp_vhaddr)
};
static struct afswtch af_carp = {
.af_name = "af_carp",
.af_af = AF_UNSPEC,
.af_other_status = carp_status,
};
static __constructor(101) void
carp_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
perror(val);
return;
}
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
ifr.ifr_ifru.ifru_data = (void *)label;
error = ioctl(s, SIOCSIFMAC, &ifr);
mac_free(label);
if (error == -1)
perror("setifmac");
}
static struct cmd mac_cmds[] = {
DEF_CMD_ARG("maclabel", setifmaclabel),
};
static struct afswtch af_mac = {
.af_name = "af_maclabel",
.af_af = AF_UNSPEC,
.af_other_status = maclabel_status,
};
static __constructor void
mac_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
size_t i;
for (i = 0; i < N(mac_cmds); i++)
cmd_register(&mac_cmds[i]);
DEF_CMD("-arp", IFF_NOARP, setifflags),
DEF_CMD("debug", IFF_DEBUG, setifflags),
DEF_CMD("-debug", -IFF_DEBUG, setifflags),
DEF_CMD("promisc", IFF_PPROMISC, setifflags),
DEF_CMD("-promisc", -IFF_PPROMISC, setifflags),
DEF_CMD("add", IFF_UP, notealias),
DEF_CMD("alias", IFF_UP, notealias),
DEF_CMD("-alias", -IFF_UP, notealias),
DEF_CMD("delete", -IFF_UP, notealias),
DEF_CMD("remove", -IFF_UP, notealias),
#ifdef notdef
#define EN_SWABIPS 0x1000
DEF_CMD("swabips", EN_SWABIPS, setifflags),
DEF_CMD("-swabips", -EN_SWABIPS, setifflags),
#endif
DEF_CMD_ARG("netmask", setifnetmask),
DEF_CMD_ARG("metric", setifmetric),
DEF_CMD_ARG("broadcast", setifbroadaddr),
#ifndef NO_IPX
DEF_CMD_ARG("ipdst", setifipdst),
#endif
DEF_CMD_ARG2("tunnel", settunnel),
DEF_CMD("-tunnel", 0, deletetunnel),
DEF_CMD("deletetunnel", 0, deletetunnel),
DEF_CMD("link0", IFF_LINK0, setifflags),
DEF_CMD("-link0", -IFF_LINK0, setifflags),
DEF_CMD("link1", IFF_LINK1, setifflags),
DEF_CMD("-link1", -IFF_LINK1, setifflags),
DEF_CMD("link2", IFF_LINK2, setifflags),
DEF_CMD("-link2", -IFF_LINK2, setifflags),
DEF_CMD("monitor", IFF_MONITOR, setifflags),
putchar('\n');
if (verbose && ra.ra_proto == LAGG_PROTO_LACP)
printf("\t\t%s\n",
lacp_format_peer(lp, "\n\t\t "));
}
if (0 /* XXX */) {
printf("\tsupported aggregation protocols:\n");
for (i = 0; i < (sizeof(lpr) / sizeof(lpr[0])); i++)
printf("\t\tlaggproto %s\n", lpr[i].lpr_name);
}
}
}
static struct cmd lagg_cmds[] = {
DEF_CMD_ARG("laggport", setlaggport),
DEF_CMD_ARG("-laggport", unsetlaggport),
DEF_CMD_ARG("laggproto", setlaggproto),
DEF_CMD_ARG("lagghash", setlagghash),
DEF_CMD("use_flowid", LAGG_OPT_USE_FLOWID, setlaggsetopt),
DEF_CMD("-use_flowid", -LAGG_OPT_USE_FLOWID, setlaggsetopt),
DEF_CMD("lacp_strict", LAGG_OPT_LACP_STRICT, setlaggsetopt),
DEF_CMD("-lacp_strict", -LAGG_OPT_LACP_STRICT, setlaggsetopt),
DEF_CMD("lacp_txtest", LAGG_OPT_LACP_TXTEST, setlaggsetopt),
DEF_CMD("-lacp_txtest", -LAGG_OPT_LACP_TXTEST, setlaggsetopt),
DEF_CMD("lacp_rxtest", LAGG_OPT_LACP_RXTEST, setlaggsetopt),
DEF_CMD("-lacp_rxtest", -LAGG_OPT_LACP_RXTEST, setlaggsetopt),
DEF_CMD("lacp_fast_timeout", LAGG_OPT_LACP_TIMEOUT, setlaggsetopt),
DEF_CMD("-lacp_fast_timeout", -LAGG_OPT_LACP_TIMEOUT, setlaggsetopt),
DEF_CMD_ARG("flowid_shift", setlaggflowidshift),
DEF_CMD_ARG("rr_limit", setlaggrr_limit),
printf("%s%s", seen_option++ ? "," : "",
desc->ifmt_string);
}
}
}
if (IFM_INST(ifmw) != 0)
printf(" instance %d", IFM_INST(ifmw));
}
/**********************************************************************
* ...until here.
**********************************************************************/
static struct cmd media_cmds[] = {
DEF_CMD_ARG("media", setmedia),
DEF_CMD_ARG("mode", setmediamode),
DEF_CMD_ARG("mediaopt", setmediaopt),
DEF_CMD_ARG("-mediaopt",unsetmediaopt),
DEF_CMD_ARG("inst", setmediainst),
DEF_CMD_ARG("instance", setmediainst),
};
static struct afswtch af_media = {
.af_name = "af_media",
.af_af = AF_UNSPEC,
.af_other_status = media_status,
};
static __constructor void
ifmedia_ctor(void)
{
static void
setbridge_private(const char *val, int d, int s, const struct afswtch *afp)
{
do_bridgeflag(s, val, IFBIF_PRIVATE, 1);
}
static void
unsetbridge_private(const char *val, int d, int s, const struct afswtch *afp)
{
do_bridgeflag(s, val, IFBIF_PRIVATE, 0);
}
static struct cmd bridge_cmds[] = {
DEF_CMD_ARG("addm", setbridge_add),
DEF_CMD_ARG("deletem", setbridge_delete),
DEF_CMD_ARG("discover", setbridge_discover),
DEF_CMD_ARG("-discover", unsetbridge_discover),
DEF_CMD_ARG("learn", setbridge_learn),
DEF_CMD_ARG("-learn", unsetbridge_learn),
DEF_CMD_ARG("sticky", setbridge_sticky),
DEF_CMD_ARG("-sticky", unsetbridge_sticky),
DEF_CMD_ARG("span", setbridge_span),
DEF_CMD_ARG("-span", unsetbridge_span),
DEF_CMD_ARG("stp", setbridge_stp),
DEF_CMD_ARG("-stp", unsetbridge_stp),
DEF_CMD_ARG("edge", setbridge_edge),
DEF_CMD_ARG("-edge", unsetbridge_edge),
DEF_CMD_ARG("autoedge", setbridge_autoedge),
DEF_CMD_ARG("-autoedge", unsetbridge_autoedge),
setbridge_timeout(const char *arg, int d, int s, const struct afswtch *afp)
{
struct ifbrparam param;
u_long val;
if (get_val(arg, &val) < 0 || (val & ~0xffffffff) != 0)
errx(1, "invalid value: %s", arg);
param.ifbrp_ctime = val & 0xffffffff;
if (do_cmd(s, BRDGSTO, ¶m, sizeof(param), 1) < 0)
err(1, "BRDGSTO %s", arg);
}
static struct cmd bridge_cmds[] = {
DEF_CMD_ARG("addm", setbridge_add),
DEF_CMD_ARG("deletem", setbridge_delete),
DEF_CMD_ARG("discover", setbridge_discover),
DEF_CMD_ARG("-discover", unsetbridge_discover),
DEF_CMD_ARG("learn", setbridge_learn),
DEF_CMD_ARG("-learn", unsetbridge_learn),
DEF_CMD_ARG("span", setbridge_span),
DEF_CMD_ARG("-span", unsetbridge_span),
DEF_CMD_ARG("stp", setbridge_stp),
DEF_CMD_ARG("-stp", unsetbridge_stp),
DEF_CMD("flush", 0, setbridge_flush),
DEF_CMD("flushall", 0, setbridge_flushall),
DEF_CMD_ARG2("static", setbridge_static),
DEF_CMD_ARG("deladdr", setbridge_deladdr),
DEF_CMD("addr", 1, getbridge_addr),
DEF_CMD_ARG("maxaddr", setbridge_maxaddr),
continue;
for (desc = ttos->options[i].desc;
desc->ifmt_string != NULL; desc++) {
if (ifmw & desc->ifmt_word) {
printf(" mediaopt %s", desc->ifmt_string);
}
}
}
}
/**********************************************************************
* ...until here.
**********************************************************************/
static struct cmd media_cmds[] = {
DEF_CMD_ARG("media", setmedia),
DEF_CMD_ARG("mode", setmediamode),
DEF_CMD_ARG("mediaopt", setmediaopt),
DEF_CMD_ARG("-mediaopt",unsetmediaopt),
};
static struct afswtch af_media = {
.af_name = "af_media",
.af_af = AF_UNSPEC,
.af_other_status = media_status,
};
static __constructor(101) void
ifmedia_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
int i;
}
static void
setifgrekey(const char *val, int dummy __unused, int s,
const struct afswtch *afp)
{
uint32_t grekey = atol(val);
strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
ifr.ifr_data = (caddr_t)&grekey;
if (ioctl(s, GRESKEY, (caddr_t)&ifr) < 0)
warn("ioctl (set grekey)");
}
static struct cmd gre_cmds[] = {
DEF_CMD_ARG("grekey", setifgrekey),
};
static struct afswtch af_gre = {
.af_name = "af_gre",
.af_af = AF_UNSPEC,
.af_other_status = gre_status,
};
static __constructor void
gre_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
size_t i;
for (i = 0; i < N(gre_cmds); i++)
cmd_register(&gre_cmds[i]);
}
}
/* not present, we should try to load it */
kldload(ifkind);
#endif
}
static struct cmd basic_cmds[] = {
DEF_CMD("up", IFF_UP, setifflags),
DEF_CMD("down", -IFF_UP, setifflags),
DEF_CMD("arp", -IFF_NOARP, setifflags),
DEF_CMD("-arp", IFF_NOARP, setifflags),
DEF_CMD("debug", IFF_DEBUG, setifflags),
DEF_CMD("-debug", -IFF_DEBUG, setifflags),
DEF_CMD_ARG("description", setifdescr),
DEF_CMD_ARG("descr", setifdescr),
DEF_CMD("-description", 0, unsetifdescr),
DEF_CMD("-descr", 0, unsetifdescr),
DEF_CMD("promisc", IFF_PPROMISC, setifflags),
DEF_CMD("-promisc", -IFF_PPROMISC, setifflags),
DEF_CMD("add", IFF_UP, notealias),
DEF_CMD("alias", IFF_UP, notealias),
DEF_CMD("-alias", -IFF_UP, notealias),
DEF_CMD("delete", -IFF_UP, notealias),
DEF_CMD("remove", -IFF_UP, notealias),
#ifdef notdef
#define EN_SWABIPS 0x1000
DEF_CMD("swabips", EN_SWABIPS, setifflags),
DEF_CMD("-swabips", -EN_SWABIPS, setifflags),
#endif
at_nr.nr_firstnet = /* Default range of one */
at_nr.nr_lastnet = sat->sat_addr.s_net;
printf("\tatalk %d.%d range %d-%d phase %d\n",
ntohs(sat->sat_addr.s_net), sat->sat_addr.s_node,
ntohs(at_nr.nr_firstnet), ntohs(at_nr.nr_lastnet),
at_nr.nr_phase);
if ((u_short) ntohs(at_nr.nr_firstnet) >
(u_short) ntohs(sat->sat_addr.s_net)
|| (u_short) ntohs(at_nr.nr_lastnet) <
(u_short) ntohs(sat->sat_addr.s_net))
errx(1, "AppleTalk address is not in range");
sat->sat_range.r_netrange = at_nr;
}
static struct cmd atalk_cmds[] = {
DEF_CMD_ARG("range", setatrange),
DEF_CMD_ARG("phase", setatphase),
};
static struct afswtch af_atalk = {
.af_name = "atalk",
.af_af = AF_APPLETALK,
.af_status = at_status,
.af_getaddr = at_getaddr,
.af_postproc = at_postproc,
.af_difaddr = SIOCDIFADDR,
.af_aifaddr = SIOCAIFADDR,
.af_ridreq = &at_addreq,
.af_addreq = &at_addreq,
};
uint32_t v;
v = strtoul(val, &ep, 0);
if (*ep != '\0') {
warn("Invalid reqid value %s", val);
return;
}
ifr.ifr_data = (char *)&v;
if (ioctl(s, IPSECSREQID, &ifr) == -1) {
warn("ioctl(IPSECSREQID)");
return;
}
}
static struct cmd ipsec_cmds[] = {
DEF_CMD_ARG("reqid", setreqid),
};
static struct afswtch af_ipsec = {
.af_name = "af_ipsec",
.af_af = AF_UNSPEC,
.af_other_status = ipsec_status,
};
static __constructor void
ipsec_ctor(void)
{
size_t i;
for (i = 0; i < nitems(ipsec_cmds); i++)
cmd_register(&ipsec_cmds[i]);
