ifc
struct ifconf ifc;
ifc.ifc_len = *lenp;
ifc.ifc_buf = buf;
ret = ioctl (s, SIOCGIFCONF, (char *)&ifc);
*lenp = ifc.ifc_len;
if (olen != ifc.ifc_len || omod != i) {
t, ifc.ifc_len, i);
olen = ifc.ifc_len;
struct ifconf ifc;
ifc.ifc_len = t;
ifc.ifc_buf = buffer;
i = ioctl (sock, SIOCGIFCONF, (char *) &ifc);
ifr = ifc.ifc_req;
for (len = ifc.ifc_len; len; len -= sizeof ifreq) {
struct ifconf ifc;
ifc.ifc_len = sizeof (buf);
ifc.ifc_buf = buf;
if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) {
struct ifconf ifc;
ifc.ifc_len = GIFCONF_BUFSIZE;
ifc.ifc_buf = buf;
if (ioctl(sock, SIOCGIFCONF, (char *)&ifc) < 0) {
ifr = ifc.ifc_req;
for (i = 0, n = ifc.ifc_len/sizeof (struct ifreq); n > 0; n--, ifr++) {
struct ifconf ifc;
ifc.ifc_len = sizeof(ibuf);
ifc.ifc_buf = (caddr_t) ibuf;
if (ioctl(fd, SIOCGIFCONF, (char *) &ifc) < 0 ||
ifc.ifc_len < sizeof(struct ifreq)) {
ifend = (struct ifreq *) ((char *) ibuf + ifc.ifc_len);
struct ifconf ifc;
ifc.ifc_len = sizeof ibuf;
ifc.ifc_buf = (caddr_t)ibuf;
if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
ifc.ifc_len < sizeof(struct ifreq)) {
ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);
struct l_ifconf *ifc;
struct ifconf *ifc;
ifc = arg;
ifc->ifc_len += sizeof(struct l_ifreq);
struct l_ifconf ifc;
struct ifconf ifc;
error = copyin(uifc, &ifc, sizeof(ifc));
if (PTRIN(ifc.ifc_buf) == NULL) {
ifc.ifc_len = 0;
if_foreach(linux_ifconf_ifnet_cb, &ifc);
return (copyout(&ifc, uifc, sizeof(ifc)));
if (ifc.ifc_len <= 0)
if (ifc.ifc_len <= cbs.max_len) {
cbs.max_len = ifc.ifc_len;
ifc.ifc_len = cbs.valid_len;
error = copyout(sbuf_data(sb), PTRIN(ifc.ifc_buf), ifc.ifc_len);
error = copyout(&ifc, uifc, sizeof(ifc));
t4_cloner_match(struct if_clone *ifc, const char *name)
t4_cloner_create(struct if_clone *ifc, char *name, size_t len, caddr_t params)
t4_cloner_destroy(struct if_clone *ifc, if_t ifp)
struct isp_fc_device *ifc = (struct isp_fc_device *) addr;
if (ifc->loopid >= MAX_FC_TARG) {
lp = &FCPARAM(isp, ifc->chan)->portdb[ifc->loopid];
ifc->role = (lp->prli_word3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
ifc->loopid = lp->handle;
ifc->portid = lp->portid;
ifc->node_wwn = lp->node_wwn;
ifc->port_wwn = lp->port_wwn;
wg_clone_create(struct if_clone *ifc, char *name, size_t len,
wg_clone_destroy(struct if_clone *ifc, if_t ifp, uint32_t flags)
static int wg_clone_create(struct if_clone *ifc, char *name, size_t len,
static int wg_clone_destroy(struct if_clone *ifc, if_t ifp,
struct ifconf ifc;
thunk.ifc.ifc_len = ifc32->ifc_len;
thunk.ifc.ifc_buf = PTRIN(ifc32->ifc_buf);
data = (caddr_t)&thunk.ifc;
ifc32->ifc_len = thunk.ifc.ifc_len;
struct ifconf *ifc = (struct ifconf *)data;
if (ifc->ifc_len <= 0)
if (ifc->ifc_len <= max_len) {
max_len = ifc->ifc_len;
ifc->ifc_len = valid_len;
error = copyout(sbuf_data(sb), ifc->ifc_req, ifc->ifc_len);
bridge_clone_create(struct if_clone *ifc, char *name, size_t len,
bridge_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
static void if_clone_free(struct if_clone *ifc);
static int if_clone_createif_nl(struct if_clone *ifc, const char *name,
static int ifc_simple_match(struct if_clone *ifc, const char *name);
static int ifc_handle_unit(struct if_clone *ifc, char *name, size_t len, int *punit);
static int ifc_simple_create_wrapper(struct if_clone *ifc, char *name, size_t maxlen,
static int ifc_advanced_create_wrapper(struct if_clone *ifc, char *name, size_t maxlen,
#define IF_CLONE_LOCK_INIT(ifc) \
mtx_init(&(ifc)->ifc_mtx, "if_clone lock", NULL, MTX_DEF)
#define IF_CLONE_LOCK_DESTROY(ifc) mtx_destroy(&(ifc)->ifc_mtx)
#define IF_CLONE_LOCK_ASSERT(ifc) mtx_assert(&(ifc)->ifc_mtx, MA_OWNED)
#define IF_CLONE_LOCK(ifc) mtx_lock(&(ifc)->ifc_mtx)
#define IF_CLONE_UNLOCK(ifc) mtx_unlock(&(ifc)->ifc_mtx)
#define IF_CLONE_ADDREF(ifc) \
IF_CLONE_LOCK(ifc); \
IF_CLONE_ADDREF_LOCKED(ifc); \
IF_CLONE_UNLOCK(ifc); \
#define IF_CLONE_ADDREF_LOCKED(ifc) \
IF_CLONE_LOCK_ASSERT(ifc); \
KASSERT((ifc)->ifc_refcnt >= 0, \
("negative refcnt %ld", (ifc)->ifc_refcnt)); \
(ifc)->ifc_refcnt++; \
#define IF_CLONE_REMREF(ifc) \
IF_CLONE_LOCK(ifc); \
IF_CLONE_REMREF_LOCKED(ifc); \
#define IF_CLONE_REMREF_LOCKED(ifc) \
IF_CLONE_LOCK_ASSERT(ifc); \
KASSERT((ifc)->ifc_refcnt > 0, \
("bogus refcnt %ld", (ifc)->ifc_refcnt)); \
if (--(ifc)->ifc_refcnt == 0) { \
IF_CLONE_UNLOCK(ifc); \
if_clone_free(ifc); \
IF_CLONE_UNLOCK(ifc); \
struct if_clone *ifc = ifc_find_cloner_match(name);
if (ifc == NULL)
int error = if_clone_createif_nl(ifc, name, &ifd_new);
struct if_clone *ifc = ifc_find_cloner_match(name);
if (ifc == NULL) {
ifd->error = if_clone_createif_nl(ifc, name, ifd);
struct if_clone *ifc = ifc_find_cloner(ifp->if_dname);
if (ifc == NULL) {
ifd->error = (*ifc->modify_nl)(ifp, ifd);
struct if_clone *ifc = ifc_find_cloner(ifp->if_dname);
if (ifc == NULL)
(*ifc->dump_nl)(ifp, nw);
ifc_create_ifp_nl_default(struct if_clone *ifc, char *name, size_t len,
return ((*ifc->ifc_create)(ifc, name, len, &ifd_new, &ifd->ifp));
ifc_link_ifp(struct if_clone *ifc, struct ifnet *ifp)
if_addgroup(ifp, ifc->ifc_name);
IF_CLONE_LOCK(ifc);
IFC_IFLIST_INSERT(ifc, ifp);
IF_CLONE_UNLOCK(ifc);
if_clone_addif(struct if_clone *ifc, struct ifnet *ifp)
ifc_link_ifp(ifc, ifp);
ifc_unlink_ifp(struct if_clone *ifc, struct ifnet *ifp)
IF_CLONE_LOCK(ifc);
LIST_FOREACH(ifcifp, &ifc->ifc_iflist, if_clones) {
IFC_IFLIST_REMOVE(ifc, ifp);
IF_CLONE_UNLOCK(ifc);
if_delgroup(ifp, ifc->ifc_name);
struct if_clone *ifc;
LIST_FOREACH(ifc, &V_if_cloners, ifc_list) {
if (ifc->ifc_match(ifc, name))
return (ifc);
struct if_clone *ifc;
LIST_FOREACH(ifc, &V_if_cloners, ifc_list) {
if (strcmp(ifc->ifc_name, name) == 0) {
return (ifc);
struct if_clone *ifc = ifc_find_cloner(name);
return (ifc);
if_clone_createif_nl(struct if_clone *ifc, const char *ifname, struct ifc_data_nl *ifd)
if (ifc->ifc_flags & IFC_F_AUTOUNIT) {
if ((error = ifc_handle_unit(ifc, name, sizeof(name), &ifd->unit)) != 0)
error = (*ifc->create_nl)(ifc, name, sizeof(name), ifd);
error = ifc_create_ifp_nl_default(ifc, name, sizeof(name), ifd);
if (ifc->ifc_flags & IFC_F_AUTOUNIT)
ifc_free_unit(ifc, ifd->unit);
if_clone_addif(ifc, ifd->ifp);
error = (*ifc->modify_nl)(ifd->ifp, ifd);
struct if_clone *ifc;
ifc = ifc_find_cloner_in_vnet(ifp->if_dname, ifp->if_home_vnet);
if (ifc == NULL) {
err = if_clone_destroyif(ifc, ifp);
if_clone_destroyif_flags(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
if (!ifc_unlink_ifp(ifc, ifp)) {
err = (*ifc->ifc_destroy)(ifc, ifp, flags);
ifc_link_ifp(ifc, ifp);
else if (ifc->ifc_flags & IFC_F_AUTOUNIT)
ifc_free_unit(ifc, unit);
if_clone_destroyif(struct if_clone *ifc, struct ifnet *ifp)
err = if_clone_destroyif_flags(ifc, ifp, 0);
struct if_clone *ifc;
ifc = malloc(sizeof(struct if_clone), M_CLONE, M_WAITOK | M_ZERO);
strncpy(ifc->ifc_name, name, IFCLOSIZ-1);
IF_CLONE_LOCK_INIT(ifc);
IF_CLONE_ADDREF(ifc);
ifc->ifc_maxunit = maxunit;
ifc->ifc_unrhdr = new_unrhdr(0, ifc->ifc_maxunit, &ifc->ifc_mtx);
LIST_INIT(&ifc->ifc_iflist);
ifc->create_nl = ifc_create_ifp_nl_default;
ifc->modify_nl = ifc_modify_ifp_nl_default;
ifc->dump_nl = ifc_dump_ifp_nl_default;
return (ifc);
if_clone_attach(struct if_clone *ifc)
if (strcmp(ifc->ifc_name, ifc1->ifc_name) == 0) {
IF_CLONE_REMREF(ifc);
LIST_INSERT_HEAD(&V_if_cloners, ifc, ifc_list);
struct if_clone *ifc;
ifc = if_clone_alloc(name, maxunit);
ifc->ifc_match = req->match_f != NULL ? req->match_f : ifc_simple_match;
ifc->ifc_create = req->create_f;
ifc->ifc_destroy = req->destroy_f;
ifc->ifc_flags = (req->flags & IFC_F_AUTOUNIT);
ifc->create_nl = req2->create_nl_f;
ifc->modify_nl = req2->modify_nl_f;
ifc->dump_nl = req2->dump_nl_f;
ifc->dump_nl = ifc_dump_ifp_nl_default;
if (if_clone_attach(ifc) != 0)
EVENTHANDLER_INVOKE(if_clone_event, ifc);
return (ifc);
ifc_detach_cloner(struct if_clone *ifc)
if_clone_detach(ifc);
ifc_advanced_create_wrapper(struct if_clone *ifc, char *name, size_t maxlen,
int error = ifc->ifca_create(ifc, name, maxlen, ifc_data->params);
ifc_advanced_destroy_wrapper(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
if (ifc->ifca_destroy == NULL)
return (ifc->ifca_destroy(ifc, ifp));
struct if_clone *ifc;
ifc = if_clone_alloc(name, maxunit ? maxunit : IF_MAXUNIT);
ifc->ifc_match = match;
ifc->ifc_create = ifc_advanced_create_wrapper;
ifc->ifc_destroy = ifc_advanced_destroy_wrapper;
ifc->ifca_destroy = destroy;
ifc->ifca_create = create;
if (if_clone_attach(ifc) != 0)
EVENTHANDLER_INVOKE(if_clone_event, ifc);
return (ifc);
ifc_simple_create_wrapper(struct if_clone *ifc, char *name, size_t maxlen,
int error = ifc->ifcs_create(ifc, unit, ifc_data->params);
ifc_simple_destroy_wrapper(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
if (ifp->if_dunit < ifc->ifcs_minifs && (flags & IFC_F_FORCE) == 0)
ifc->ifcs_destroy(ifp);
struct if_clone *ifc;
ifc = if_clone_alloc(name, IF_MAXUNIT);
ifc->ifc_match = ifc_simple_match;
ifc->ifc_create = ifc_simple_create_wrapper;
ifc->ifc_destroy = ifc_simple_destroy_wrapper;
ifc->ifcs_create = create;
ifc->ifcs_destroy = destroy;
ifc->ifcs_minifs = minifs;
ifc->ifc_flags = IFC_F_AUTOUNIT;
if (if_clone_attach(ifc) != 0)
snprintf(name, IFNAMSIZ, "%s%d", ifc->ifc_name, unit);
error = if_clone_createif_nl(ifc, name, &ifd);
EVENTHANDLER_INVOKE(if_clone_event, ifc);
return (ifc);
if_clone_detach(struct if_clone *ifc)
LIST_REMOVE(ifc, ifc_list);
while (!LIST_EMPTY(&ifc->ifc_iflist))
if_clone_destroyif_flags(ifc, LIST_FIRST(&ifc->ifc_iflist), IFC_F_FORCE);
IF_CLONE_REMREF(ifc);
if_clone_free(struct if_clone *ifc)
KASSERT(LIST_EMPTY(&ifc->ifc_iflist),
IF_CLONE_LOCK_DESTROY(ifc);
delete_unrhdr(ifc->ifc_unrhdr);
free(ifc, M_CLONE);
struct if_clone *ifc;
for (ifc = LIST_FIRST(&V_if_cloners), buf = outbuf;
ifc != NULL && count != 0;
ifc = LIST_NEXT(ifc, ifc_list), count--, buf += IFNAMSIZ) {
strlcpy(buf, ifc->ifc_name, IFNAMSIZ);
struct if_clone *ifc;
LIST_FOREACH(ifc, &V_if_cloners, ifc_list) {
IF_CLONE_LOCK(ifc);
LIST_FOREACH(ifcifp, &ifc->ifc_iflist, if_clones) {
strncpy(ifc_name, ifc->ifc_name, IFCLOSIZ-1);
IF_CLONE_UNLOCK(ifc);
LIST_FOREACH(ifc, &V_if_cloners, ifc_list)
if (strcmp(ifc->ifc_name, ifc_name) == 0)
if (ifc != NULL)
ifc_alloc_unit_specific(struct if_clone *ifc, int *unit)
if (*unit > ifc->ifc_maxunit)
if (alloc_unr_specific(ifc->ifc_unrhdr, *unit) == -1)
snprintf(name, IFNAMSIZ, "%s%d", ifc->ifc_name, *unit);
free_unr(ifc->ifc_unrhdr, *unit);
IF_CLONE_ADDREF(ifc);
ifc_alloc_unit_next(struct if_clone *ifc, int *unit)
*unit = alloc_unr(ifc->ifc_unrhdr);
free_unr(ifc->ifc_unrhdr, *unit);
error = ifc_alloc_unit_specific(ifc, unit);
ifc_alloc_unit(struct if_clone *ifc, int *unit)
return (ifc_alloc_unit_next(ifc, unit));
return (ifc_alloc_unit_specific(ifc, unit));
ifc_free_unit(struct if_clone *ifc, int unit)
free_unr(ifc->ifc_unrhdr, unit);
IF_CLONE_REMREF(ifc);
ifc_simple_match(struct if_clone *ifc, const char *name)
for (cp = name, i = 0; i < strlen(ifc->ifc_name); i++, cp++) {
if (ifc->ifc_name[i] != *cp)
ifc_handle_unit(struct if_clone *ifc, char *name, size_t len, int *punit)
err = ifc_alloc_unit(ifc, &unit);
void ifc_detach_cloner(struct if_clone *ifc);
void ifc_link_ifp(struct if_clone *ifc, struct ifnet *ifp);
bool ifc_unlink_ifp(struct if_clone *ifc, struct ifnet *ifp);
typedef int ifc_match_f(struct if_clone *ifc, const char *name);
typedef int ifc_create_f(struct if_clone *ifc, char *name, size_t maxlen,
typedef int ifc_destroy_f(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags);
typedef int ifc_create_nl_f(struct if_clone *ifc, char *name, size_t maxlen,
disc_clone_create(struct if_clone *ifc, int unit, caddr_t params)
edsc_clone_create(struct if_clone *ifc, int unit, caddr_t params)
enc_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
enc_clone_create(struct if_clone *ifc, char *name, size_t len,
epair_clone_match(struct if_clone *ifc, const char *name)
epair_clone_add(struct if_clone *ifc, struct epair_softc *scb)
if_clone_addif(ifc, ifp);
epair_alloc_sc(struct if_clone *ifc)
epair_handle_unit(struct if_clone *ifc, char *name, size_t len, int *punit)
error = ifc_alloc_unit(ifc, &unit);
ifc_free_unit(ifc, unit);
epair_clone_create(struct if_clone *ifc, char *name, size_t len,
error = epair_handle_unit(ifc, name, len, &unit);
sca = epair_alloc_sc(ifc);
scb = epair_alloc_sc(ifc);
epair_clone_add(ifc, scb);
epair_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
error = if_clone_destroyif(ifc, oifp);
ifc_free_unit(ifc, unit);
geneve_clone_create_nl(struct if_clone *ifc, char *name, size_t len,
return (geneve_clone_create(ifc, name, len, &ifd_new, &ifd->ifp));
geneve_clone_create(struct if_clone *ifc, char *name, size_t len,
geneve_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
gif_clone_create(struct if_clone *ifc, int unit, caddr_t params)
gre_clone_create_nl(struct if_clone *ifc, char *name, size_t len,
return (gre_clone_create(ifc, name, len, &ifd_new, &ifd->ifp));
gre_clone_create(struct if_clone *ifc, char *name, size_t len,
gre_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
ipsec_clone_create(struct if_clone *ifc, int unit, caddr_t params)
lagg_clone_create(struct if_clone *ifc, char *name, size_t len,
lagg_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
lo_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
lo_clone_create(struct if_clone *ifc, char *name, size_t len,
me_clone_create(struct if_clone *ifc, int unit, caddr_t params)
ovpn_clone_match(struct if_clone *ifc, const char *name)
ovpn_clone_create(struct if_clone *ifc, char *name, size_t len,
error = ifc_alloc_unit(ifc, &unit);
ifc_free_unit(ifc, unit);
ovpn_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
ifc_free_unit(ifc, unit);
stf_clone_match(struct if_clone *ifc, const char *name)
stf_clone_create(struct if_clone *ifc, char *name, size_t len,
err = ifc_alloc_unit(ifc, &unit);
stf_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
ifc_free_unit(ifc, STFUNIT);
static int tun_clone_match(struct if_clone *ifc, const char *name);
static int tap_clone_match(struct if_clone *ifc, const char *name);
static int vmnet_clone_match(struct if_clone *ifc, const char *name);
tun_clone_match(struct if_clone *ifc, const char *name)
tap_clone_match(struct if_clone *ifc, const char *name)
vmnet_clone_match(struct if_clone *ifc, const char *name)
tun_clone_create(struct if_clone *ifc, char *name, size_t len,
tun_clone_destroy(struct if_clone *ifc __unused, struct ifnet *ifp, uint32_t flags)
vlan_clone_match(struct if_clone *ifc, const char *name)
vlan_clone_create(struct if_clone *ifc, char *name, size_t len,
error = ifc_alloc_unit(ifc, &unit);
ifc_free_unit(ifc, unit);
vlan_clone_create_nl(struct if_clone *ifc, char *name, size_t len,
error = vlan_clone_create(ifc, name, len, &ifd_new, &ifd->ifp);
vlan_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
ifc_free_unit(ifc, unit);
static int vlan_clone_create_nl(struct if_clone *ifc, char *name, size_t len,
vxlan_clone_create(struct if_clone *ifc, char *name, size_t len,
vxlan_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
wlan_clone_create(struct if_clone *ifc, char *name, size_t len,
wlan_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
pflog_clone_create(struct if_clone *ifc, char *name, size_t maxlen,
pflog_clone_destroy(ifc, ifp, IFC_F_FORCE);
pflog_clone_destroy(struct if_clone *ifc, struct ifnet *ifp, uint32_t flags)
pfsync_clone_create(struct if_clone *ifc, int unit, caddr_t param)
const struct libusb_interface *ifc;
ifc = &cfg->interface[0];
if (ifc->num_altsetting != 0) {
d = &ifc->altsetting[0];
tobeadv(struct riprt *rrt, struct ifc *ifcp)
struct ifc *ifac_ifc; /* back pointer */
struct ifc *ifcp, *ic;
static struct ifc **index2ifc;
static struct ifc *loopifcp = NULL; /* pointing to loopback */
sendrequest(struct ifc *ifcp)
riprequest(struct ifc *ifcp,
struct ifc *ifcp;
if ((ifcp = MALLOC(struct ifc)) == NULL) {
struct ifc *ifcp,
struct ifc *ifcp;
struct ifc *ifcp, *ic;
static void ripsend(struct ifc *, struct sockaddr_in6 *, int);
rt_deladdr(struct ifc *ifcp,
static int out_filter(struct riprt *, struct ifc *);
static int ifconfig1(const char *, const struct sockaddr *, struct ifc *, int);
static int rt_deladdr(struct ifc *, const struct sockaddr_in6 *,
ifrt(struct ifc *ifcp, int again)
static int ifrt(struct ifc *, int);
static void ifrt_p2p(struct ifc *, int);
static void ifdump0(FILE *, const struct ifc *);
ifrt_p2p(struct ifc *ifcp, int again)
static void riprequest(struct ifc *, struct netinfo6 *, int,
static void ripflush(struct ifc *, struct sockaddr_in6 *, int, struct netinfo6 *np);
static void sendrequest(struct ifc *);
static int addroute(struct riprt *, const struct in6_addr *, struct ifc *);
static int tobeadv(struct riprt *, struct ifc *);
static struct ifac *ifa_match(const struct ifc *, const struct in6_addr *, int);
static struct ifc *ifc_find(char *);
static struct iff *iff_find(struct ifc *, int);
static void setindex2ifc(int, struct ifc *);
struct ifc *ifcp;
struct ifc *ifcp)
struct ifc *ifcp;
ifdump0(FILE *dump, const struct ifc *ifcp)
struct ifc *ifcp;
ifa_match(const struct ifc *ifcp,
static struct ifc *
struct ifc *ifcp;
iff_find(struct ifc *ifcp, int type)
setindex2ifc(int idx, struct ifc *ifcp)
struct ifc **p;
index2ifc = (struct ifc **)
p = (struct ifc **)realloc(index2ifc,
struct ifc *ifcp;
ripflush(struct ifc *ifcp, struct sockaddr_in6 *sin6, int nrt, struct netinfo6 *np)
ripsend(struct ifc *ifcp, struct sockaddr_in6 *sin6, int flag)
TAILQ_ENTRY(ifc) ifc_next;
out_filter(struct riprt *rrt, struct ifc *ifcp)
static TAILQ_HEAD(, ifc) ifc_head = TAILQ_HEAD_INITIALIZER(ifc_head);
struct ifconf ifc;
ifc.ifc_len = sizeof(ibuf);
ifc.ifc_buf = (caddr_t)ibuf;
if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
ifc.ifc_len < (int)sizeof(struct ifreq)) {
ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);