static int
ipfw_log_clone_destroy(struct ifnet *ifp)
{
int unit;
if (ifp == NULL)
return (0);
unit = ifp->if_dunit;
if (unit < 0 || unit >= LOG_IF_MAX) {
return EINVAL;
}
if (log_if_table[unit] == NULL) {
return EINVAL;
}
LOGIF_WLOCK();
log_if_table[unit] = NULL;
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
log_if_count--;
LOGIF_WUNLOCK();
return (0);
}
static int
ipfwlog_clone_create(struct if_clone *ifc, int unit, caddr_t params)
{
struct ifnet *ifp;
ifp = if_alloc(IFT_PFLOG);
if (ifp == NULL)
return (ENOSPC);
if_initname(ifp, ipfwlogname, unit);
ifp->if_flags = IFF_UP | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_mtu = 65536;
ifp->if_ioctl = ipfw_bpf_ioctl;
ifp->if_output = ipfw_bpf_output;
ifp->if_hdrlen = PFLOG_HDRLEN;
if_attach(ifp);
bpfattach(ifp, DLT_PFLOG, PFLOG_HDRLEN);
LOGIF_WLOCK();
if (V_pflog_if != NULL) {
LOGIF_WUNLOCK();
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
return (EEXIST);
}
V_pflog_if = ifp;
LOGIF_WUNLOCK();
return (0);
}
static int
gre_clone_destroy(struct ifnet *ifp)
{
struct gre_softc *sc = ifp->if_softc;
int cpu;
#ifdef INET
if (sc->encap != NULL)
encap_detach(sc->encap);
#endif
LIST_REMOVE(sc, sc_list);
bpfdetach(ifp);
if_detach(ifp);
for (cpu = 0; cpu < netisr_ncpus; ++cpu) {
if (sc->route_pcpu[cpu].ro_rt != NULL) {
rtfree_async(sc->route_pcpu[cpu].ro_rt);
sc->route_pcpu[cpu].ro_rt = NULL;
}
}
kfree(sc->route_pcpu, M_GRE);
kfree(sc, M_GRE);
return 0;
}
int
pflog_clone_destroy(struct ifnet *ifp)
#endif
{
struct pflog_softc *pflogif = ifp->if_softc;
int s;
s = splnet();
#ifdef __FreeBSD__
PF_LOCK();
#endif
pflogifs[pflogif->sc_unit] = NULL;
LIST_REMOVE(pflogif, sc_list);
#ifdef __FreeBSD__
PF_UNLOCK();
#endif
splx(s);
#if NBPFILTER > 0
bpfdetach(ifp);
#endif
if_detach(ifp);
#ifdef __FreeBSD__
if_free(ifp);
#endif
free(pflogif, M_DEVBUF);
#ifndef __FreeBSD__
return (0);
#endif
}
static int
loop_clone_destroy(struct ifnet *ifp)
{
if (ifp == lo0ifp)
return (EPERM);
#ifdef MBUFTRACE
#ifdef T2EX
if ( ifp->if_mowner != NULL ) {
#endif
MOWNER_DETACH(ifp->if_mowner);
free(ifp->if_mowner, M_DEVBUF);
#ifdef T2EX
}
#endif
#endif
#if NBPFILTER > 0
bpfdetach(ifp);
#endif
if_detach(ifp);
free(ifp, M_DEVBUF);
return (0);
}
static int
ipfw_log_clone_destroy(struct if_clone *ifc, struct ifnet *ifp)
{
int unit;
if (ifp == NULL)
return (0);
LOGIF_WLOCK();
if (log_if != NULL && ifp == log_if)
log_if = NULL;
else {
LOGIF_WUNLOCK();
return (EINVAL);
}
LOGIF_WUNLOCK();
unit = ifp->if_dunit;
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
ifc_free_unit(ifc, unit);
return (0);
}
static int
usie_detach(device_t self)
{
struct usie_softc *sc = device_get_softc(self);
uint8_t x;
/* detach ifnet */
if (sc->sc_ifp != NULL) {
usie_if_stop(sc);
usbd_transfer_unsetup(sc->sc_if_xfer, USIE_IF_N_XFER);
bpfdetach(sc->sc_ifp);
if_detach(sc->sc_ifp);
if_free(sc->sc_ifp);
sc->sc_ifp = NULL;
}
/* detach ucom */
if (sc->sc_nucom > 0)
ucom_detach(&sc->sc_super_ucom, sc->sc_ucom);
/* stop all USB transfers */
usbd_transfer_unsetup(sc->sc_if_xfer, USIE_IF_N_XFER);
for (x = 0; x != USIE_UCOM_MAX; x++)
usbd_transfer_unsetup(sc->sc_uc_xfer[x], USIE_UC_N_XFER);
mtx_destroy(&sc->sc_mtx);
return (0);
}
static void
enc_clone_destroy(struct ifnet *ifp)
{
KASSERT(ifp != encif, ("%s: destroying encif", __func__));
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
}
static void
disc_destroy(struct disc_softc *sc)
{
bpfdetach(&sc->sc_if);
if_detach(&sc->sc_if);
free(sc, M_DISC);
}
static void
disc_clone_destroy(struct ifnet *ifp)
{
struct disc_softc *sc;
sc = ifp->if_softc;
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
free(sc, M_DISC);
}
static void
pflog_clone_destroy(struct ifnet *ifp)
{
int i;
for (i = 0; i < PFLOGIFS_MAX; i++)
if (pflogifs[i] == ifp)
pflogifs[i] = NULL;
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
}
void
usbpf_detach(struct usb_bus *ubus)
{
struct ifnet *ifp = ubus->ifp;
if (ifp != NULL) {
bpfdetach(ifp);
if_down(ifp);
if_detach(ifp);
if_free(ifp);
}
ubus->ifp = NULL;
}
static void
lo_clone_destroy(struct ifnet *ifp)
{
#ifndef VIMAGE
/* XXX: destroying lo0 will lead to panics. */
KASSERT(V_loif != ifp, ("%s: destroying lo0", __func__));
#endif
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
}
int
faith_clone_destroy(struct ifnet *ifp)
{
struct faith_softc *sc = (struct faith_softc *) ifp;
LIST_REMOVE(sc, sc_list);
bpfdetach(ifp);
if_detach(ifp);
kfree(sc, M_FAITH);
return 0;
}
static void
enc_clone_destroy(struct ifnet *ifp)
{
struct enc_softc *sc;
sc = ifp->if_softc;
KASSERT(sc == V_enc_sc, ("sc != ifp->if_softc"));
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
free(sc, M_DEVBUF);
V_enc_sc = NULL;
}
static void
ipfw_clone_destroy(struct ifnet *ifp)
{
LOGIF_WLOCK();
if (ifp->if_hdrlen == ETHER_HDR_LEN)
V_log_if = NULL;
else
V_pflog_if = NULL;
LOGIF_WUNLOCK();
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
}
static void
tun_destroy(struct tun_softc *tp)
{
struct cdev *dev;
/* Unlocked read. */
KASSERT((tp->tun_flags & TUN_OPEN) == 0,
("tununits is out of sync - unit %d", tp->tun_if.if_dunit));
dev = tp->tun_dev;
bpfdetach(&tp->tun_if);
if_detach(&tp->tun_if);
destroy_dev(dev);
mtx_destroy(&tp->tun_mtx);
free(tp, M_TUN);
}
static int
usbpf_clone_destroy(struct if_clone *ifc, struct ifnet *ifp)
{
struct usb_bus *ubus;
int unit;
ubus = ifp->if_softc;
unit = ifp->if_dunit;
ubus->ifp = NULL;
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
ifc_free_unit(ifc, unit);
return (0);
}
static void
pflog_clone_destroy(struct ifnet *ifp)
{
struct pflog_softc *sc;
sc = ifp->if_softc;
/*
* Does we really need this?
*/
IF_DRAIN(&ifp->if_snd);
bpfdetach(ifp);
if_detach(ifp);
LIST_REMOVE(sc, sc_next);
free(sc, M_PFLOG);
}
static int
gre_clone_destroy(struct ifnet *ifp)
{
struct gre_softc *sc = ifp->if_softc;
#ifdef INET
if (sc->encap != NULL)
encap_detach(sc->encap);
#endif
LIST_REMOVE(sc, sc_list);
bpfdetach(ifp);
if_detach(ifp);
kfree(sc, M_GRE);
return 0;
}
int
pflog_clone_destroy(struct ifnet *ifp)
{
struct pflog_softc *pflogif = ifp->if_softc;
int s;
s = splnet();
pflogifs[pflogif->sc_unit] = NULL;
LIST_REMOVE(pflogif, sc_list);
splx(s);
#if NBPFILTER > 0
bpfdetach(ifp);
#endif
if_detach(ifp);
free(pflogif, M_DEVBUF);
return (0);
}
static int
stf_clone_destroy(struct if_clone *ifc, struct ifnet *ifp)
{
struct stf_softc *sc = ifp->if_softc;
int err;
err = encap_detach(sc->encap_cookie);
KASSERT(err == 0, ("Unexpected error detaching encap_cookie"));
mtx_destroy(&(sc)->sc_ro_mtx);
bpfdetach(ifp);
if_detach(ifp);
if_free(ifp);
free(sc, M_STF);
ifc_free_unit(ifc, STFUNIT);
return (0);
}
void
ieee80211_ifdetach(struct ifnet *ifp)
{
struct ieee80211com *ic = (void *)ifp;
ieee80211_proto_detach(ifp);
ieee80211_crypto_detach(ifp);
ieee80211_node_detach(ifp);
#ifdef __FreeBSD__
ifmedia_removeall(&ic->ic_media);
#else
ifmedia_delete_instance(&ic->ic_media, IFM_INST_ANY);
#endif
#if NBPFILTER > 0
bpfdetach(ifp);
#endif
ether_ifdetach(ifp);
}
static void
gif_clone_destroy(struct ifnet *ifp)
{
struct gif_softc *sc;
sx_xlock(&gif_ioctl_sx);
sc = ifp->if_softc;
gif_delete_tunnel(sc);
if (ng_gif_detach_p != NULL)
(*ng_gif_detach_p)(ifp);
bpfdetach(ifp);
if_detach(ifp);
ifp->if_softc = NULL;
sx_xunlock(&gif_ioctl_sx);
GIF_WAIT();
if_free(ifp);
free(sc, M_GIF);
}
static int
loop_clone_destroy_lo0(void)
{
struct ifnet *ifp = lo0ifp;
#ifdef MBUFTRACE
if ( ifp->if_mowner != NULL ) {
MOWNER_DETACH(ifp->if_mowner);
free(ifp->if_mowner, M_DEVBUF);
}
#endif
#if NBPFILTER > 0
bpfdetach(ifp);
#endif
if_detach(ifp);
free(ifp, M_DEVBUF);
return (0);
}
void
ieee80211_ifdetach(struct ieee80211com *ic)
{
struct ifnet *ifp = ic->ic_ifp;
ieee80211_remove_vap(ic);
ieee80211_sysctl_detach(ic);
ieee80211_proto_detach(ic);
ieee80211_crypto_detach(ic);
ieee80211_node_detach(ic);
LIST_REMOVE(ic, ic_list);
ifmedia_delete_instance(&ic->ic_media, IFM_INST_ANY);
IEEE80211_BEACON_LOCK_DESTROY(ic);
#if NBPFILTER > 0
bpfdetach(ifp);
#endif
ether_ifdetach(ifp);
}
static int
uhso_detach(device_t self)
{
struct uhso_softc *sc = device_get_softc(self);
int i;
usbd_transfer_unsetup(sc->sc_xfer, 3);
usbd_transfer_unsetup(sc->sc_ctrl_xfer, UHSO_CTRL_MAX);
if (sc->sc_ttys > 0) {
ucom_detach(&sc->sc_super_ucom, sc->sc_ucom);
for (i = 0; i < sc->sc_ttys; i++) {
if (sc->sc_tty[i].ht_muxport != -1) {
usbd_transfer_unsetup(sc->sc_tty[i].ht_xfer,
UHSO_CTRL_MAX);
}
}
free(sc->sc_tty, M_USBDEV);
free(sc->sc_ucom, M_USBDEV);
}
if (sc->sc_ifp != NULL) {
callout_drain(&sc->sc_c);
free_unr(uhso_ifnet_unit, sc->sc_ifp->if_dunit);
mtx_lock(&sc->sc_mtx);
uhso_if_stop(sc);
bpfdetach(sc->sc_ifp);
if_detach(sc->sc_ifp);
if_free(sc->sc_ifp);
mtx_unlock(&sc->sc_mtx);
usbd_transfer_unsetup(sc->sc_if_xfer, UHSO_IFNET_MAX);
}
device_claim_softc(self);
uhso_free_softc(sc);
return (0);
}
static void
gif_clone_destroy(struct ifnet *ifp)
{
struct gif_softc *sc;
sx_xlock(&gif_ioctl_sx);
sc = ifp->if_softc;
gif_delete_tunnel(ifp);
GIF_LIST_LOCK();
LIST_REMOVE(sc, gif_list);
GIF_LIST_UNLOCK();
if (ng_gif_detach_p != NULL)
(*ng_gif_detach_p)(ifp);
bpfdetach(ifp);
if_detach(ifp);
ifp->if_softc = NULL;
sx_xunlock(&gif_ioctl_sx);
if_free(ifp);
GIF_LOCK_DESTROY(sc);
free(sc, M_GIF);
}
static int
loop_clone_create(struct if_clone *ifc, int unit)
{
struct ifnet *ifp;
#ifdef T2EX
int error;
#endif
ifp = if_alloc(IFT_LOOP);
#ifdef T2EX
if ( ifp == NULL ) {
error = ENOMEM;
goto err_ret0;
}
#endif
if_initname(ifp, ifc->ifc_name, unit);
ifp->if_mtu = LOMTU;
ifp->if_flags = IFF_LOOPBACK | IFF_MULTICAST | IFF_RUNNING;
ifp->if_ioctl = loioctl;
ifp->if_output = looutput;
#ifdef ALTQ
ifp->if_start = lostart;
#endif
ifp->if_type = IFT_LOOP;
ifp->if_hdrlen = 0;
ifp->if_addrlen = 0;
ifp->if_dlt = DLT_NULL;
IFQ_SET_READY(&ifp->if_snd);
if (unit == 0)
lo0ifp = ifp;
#ifndef T2EX
if_attach(ifp);
if_alloc_sadl(ifp);
#else
error = if_attach(ifp);
if ( error != 0 ) {
goto err_ret1;
}
error = if_alloc_sadl(ifp);
if ( error != 0 ) {
goto err_ret2;
}
#endif
#if NBPFILTER > 0
#ifndef T2EX
bpfattach(ifp, DLT_NULL, sizeof(u_int));
#else
error = bpfattach(ifp, DLT_NULL, sizeof(u_int));
if ( error != 0 ) {
goto err_ret3;
}
#endif
#endif
#ifdef MBUFTRACE
ifp->if_mowner = malloc(sizeof(struct mowner), M_DEVBUF,
M_WAITOK | M_ZERO);
#ifdef T2EX
if ( ifp->if_mowner == NULL ) {
error = ENOMEM;
goto err_ret4;
}
#endif
strlcpy(ifp->if_mowner->mo_name, ifp->if_xname,
sizeof(ifp->if_mowner->mo_name));
#ifndef T2EX
MOWNER_ATTACH(ifp->if_mowner);
#else
error = MOWNER_ATTACH(ifp->if_mowner);
if ( error != 0 ) {
goto err_ret5;
}
#endif
#endif
return (0);
#ifdef T2EX
#ifdef MBUFTRACE
err_ret5:
free(ifp->if_mowner, M_DEVBUF);
err_ret4:
bpfdetach(ifp);
#endif
#if NBPFILTER > 0
err_ret3:
if_free_sadl(ifp);
#endif
err_ret2:
if_detach(ifp);
err_ret1:
if_free(ifp);
err_ret0:
return error;
#endif
}
static errno_t
utun_ctl_setopt(
__unused kern_ctl_ref kctlref,
__unused u_int32_t unit,
void *unitinfo,
int opt,
void *data,
size_t len)
{
struct utun_pcb *pcb = unitinfo;
errno_t result = 0;
/* check for privileges for privileged options */
switch (opt) {
case UTUN_OPT_FLAGS:
case UTUN_OPT_EXT_IFDATA_STATS:
case UTUN_OPT_SET_DELEGATE_INTERFACE:
if (kauth_cred_issuser(kauth_cred_get()) == 0) {
return EPERM;
}
break;
}
switch (opt) {
case UTUN_OPT_FLAGS:
if (len != sizeof(u_int32_t)) {
result = EMSGSIZE;
} else {
u_int32_t old_flags = pcb->utun_flags;
pcb->utun_flags = *(u_int32_t *)data;
if (((old_flags ^ pcb->utun_flags) & UTUN_FLAGS_ENABLE_PROC_UUID)) {
// If UTUN_FLAGS_ENABLE_PROC_UUID flag changed, update bpf
bpfdetach(pcb->utun_ifp);
bpfattach(pcb->utun_ifp, DLT_NULL, UTUN_HEADER_SIZE(pcb));
}
}
break;
case UTUN_OPT_EXT_IFDATA_STATS:
if (len != sizeof(int)) {
result = EMSGSIZE;
break;
}
pcb->utun_ext_ifdata_stats = (*(int *)data) ? 1 : 0;
break;
case UTUN_OPT_INC_IFDATA_STATS_IN:
case UTUN_OPT_INC_IFDATA_STATS_OUT: {
struct utun_stats_param *utsp = (struct utun_stats_param *)data;
if (utsp == NULL || len < sizeof(struct utun_stats_param)) {
result = EINVAL;
break;
}
if (!pcb->utun_ext_ifdata_stats) {
result = EINVAL;
break;
}
if (opt == UTUN_OPT_INC_IFDATA_STATS_IN)
ifnet_stat_increment_in(pcb->utun_ifp, utsp->utsp_packets,
utsp->utsp_bytes, utsp->utsp_errors);
else
ifnet_stat_increment_out(pcb->utun_ifp, utsp->utsp_packets,
utsp->utsp_bytes, utsp->utsp_errors);
break;
}
case UTUN_OPT_SET_DELEGATE_INTERFACE: {
ifnet_t del_ifp = NULL;
char name[IFNAMSIZ];
if (len > IFNAMSIZ - 1) {
result = EMSGSIZE;
break;
}
if (len != 0) { /* if len==0, del_ifp will be NULL causing the delegate to be removed */
bcopy(data, name, len);
name[len] = 0;
result = ifnet_find_by_name(name, &del_ifp);
}
if (result == 0) {
result = ifnet_set_delegate(pcb->utun_ifp, del_ifp);
if (del_ifp)
ifnet_release(del_ifp);
}
break;
}
case UTUN_OPT_MAX_PENDING_PACKETS: {
u_int32_t max_pending_packets = 0;
if (len != sizeof(u_int32_t)) {
result = EMSGSIZE;
break;
}
max_pending_packets = *(u_int32_t *)data;
if (max_pending_packets == 0) {
result = EINVAL;
break;
}
pcb->utun_max_pending_packets = max_pending_packets;
break;
}
default: {
result = ENOPROTOOPT;
break;
}
}
return result;
}
