void
eco_ifattach(struct ifnet *ifp, const uint8_t *lla)
{
struct ecocom *ec = (void *)ifp;
ifp->if_type = IFT_ECONET;
ifp->if_addrlen = ECO_ADDR_LEN;
ifp->if_hdrlen = ECO_HDR_LEN;
ifp->if_dlt = DLT_ECONET;
ifp->if_mtu = ECO_MTU;
ifp->if_output = eco_output;
ifp->if_input = eco_input;
ifp->if_start = eco_start;
ifp->if_ioctl = eco_ioctl;
/* ifp->if_baudrate...; */
if_set_sadl(ifp, lla, ECO_ADDR_LEN, FALSE);
ifp->if_broadcastaddr = eco_broadcastaddr;
LIST_INIT(&ec->ec_retries);
bpf_attach(ifp, ifp->if_dlt, ECO_HDR_LEN);
}
static int
mpls_clone_create(struct if_clone *ifc, int unit)
{
struct mpls_softc *sc;
atomic_inc_uint(&mpls_count);
sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
if_initname(&sc->sc_if, ifc->ifc_name, unit);
sc->sc_if.if_softc = sc;
sc->sc_if.if_type = IFT_MPLS;
sc->sc_if.if_addrlen = 0;
sc->sc_if.if_hdrlen = sizeof(union mpls_shim);
sc->sc_if.if_dlt = DLT_NULL;
sc->sc_if.if_mtu = 1500;
sc->sc_if.if_flags = 0;
sc->sc_if._if_input = mpls_input;
sc->sc_if.if_output = mpls_output;
sc->sc_if.if_ioctl = mpls_ioctl;
if_attach(&sc->sc_if);
if_alloc_sadl(&sc->sc_if);
bpf_attach(&sc->sc_if, DLT_NULL, sizeof(uint32_t));
return 0;
}
static void
tunattach0(struct tun_softc *tp)
{
struct ifnet *ifp;
ifp = &tp->tun_if;
ifp->if_softc = tp;
ifp->if_mtu = TUNMTU;
ifp->if_ioctl = tun_ioctl;
ifp->if_output = tun_output;
#ifdef ALTQ
ifp->if_start = tunstart;
#endif
ifp->if_flags = IFF_POINTOPOINT;
ifp->if_type = IFT_TUNNEL;
ifp->if_snd.ifq_maxlen = ifqmaxlen;
ifp->if_collisions = 0;
ifp->if_ierrors = 0;
ifp->if_oerrors = 0;
ifp->if_ipackets = 0;
ifp->if_opackets = 0;
ifp->if_ibytes = 0;
ifp->if_obytes = 0;
ifp->if_dlt = DLT_NULL;
IFQ_SET_READY(&ifp->if_snd);
if_attach(ifp);
if_alloc_sadl(ifp);
bpf_attach(ifp, DLT_NULL, sizeof(uint32_t));
}
void
gifattach0(struct gif_softc *sc)
{
sc->encap_cookie4 = sc->encap_cookie6 = NULL;
sc->gif_if.if_addrlen = 0;
sc->gif_if.if_mtu = GIF_MTU;
sc->gif_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
sc->gif_if.if_ioctl = gif_ioctl;
sc->gif_if.if_output = gif_output;
sc->gif_if.if_type = IFT_GIF;
sc->gif_if.if_dlt = DLT_NULL;
sc->gif_if.if_softc = sc;
IFQ_SET_READY(&sc->gif_if.if_snd);
if_attach(&sc->gif_if);
if_alloc_sadl(&sc->gif_if);
bpf_attach(&sc->gif_if, DLT_NULL, sizeof(u_int));
}
int
pflog_clone_create(struct if_clone *ifc, int unit)
{
struct ifnet *ifp;
struct pflog_softc *pflogif;
int s;
if (unit >= PFLOGIFS_MAX)
return (EINVAL);
if ((pflogif = malloc(sizeof(*pflogif), M_DEVBUF, M_NOWAIT|M_ZERO)) == NULL)
return (ENOMEM);
pflogif->sc_unit = unit;
ifp = &pflogif->sc_if;
snprintf(ifp->if_xname, sizeof ifp->if_xname, "pflog%d", unit);
ifp->if_softc = pflogif;
ifp->if_mtu = PFLOGMTU;
ifp->if_ioctl = pflogioctl;
ifp->if_output = pflogoutput;
ifp->if_start = pflogstart;
ifp->if_type = IFT_PFLOG;
#ifndef __NetBSD__
ifp->if_snd.ifq_maxlen = ifqmaxlen;
#endif /* !__NetBSD__ */
ifp->if_hdrlen = PFLOG_HDRLEN;
if_attach(ifp);
if_alloc_sadl(ifp);
#ifdef __NetBSD__
bpf_attach(ifp, DLT_PFLOG, PFLOG_HDRLEN);
#else
bpfattach(&pflogif->sc_if.if_bpf, ifp, DLT_PFLOG, PFLOG_HDRLEN);
#endif /* !__NetBSD__ */
s = splnet();
LIST_INSERT_HEAD(&pflogif_list, pflogif, sc_list);
pflogifs[unit] = ifp;
splx(s);
return (0);
}
static int
faith_clone_create(struct if_clone *ifc, int unit)
{
struct ifnet *ifp;
ifp = if_alloc(IFT_FAITH);
if_initname(ifp, ifc->ifc_name, unit);
ifp->if_mtu = FAITHMTU;
/* Change to BROADCAST experimentaly to announce its prefix. */
ifp->if_flags = /* IFF_LOOPBACK */ IFF_BROADCAST | IFF_MULTICAST;
ifp->if_ioctl = faithioctl;
ifp->if_output = faithoutput;
ifp->if_type = IFT_FAITH;
ifp->if_hdrlen = 0;
ifp->if_addrlen = 0;
ifp->if_dlt = DLT_NULL;
if_attach(ifp);
if_alloc_sadl(ifp);
bpf_attach(ifp, DLT_NULL, sizeof(u_int));
return (0);
}
static int
loop_clone_create(struct if_clone *ifc, int unit)
{
struct ifnet *ifp;
ifp = if_alloc(IFT_LOOP);
if_initname(ifp, ifc->ifc_name, unit);
ifp->if_mtu = LOMTU;
ifp->if_flags = IFF_LOOPBACK | IFF_MULTICAST | IFF_RUNNING;
ifp->if_extflags = IFEF_OUTPUT_MPSAFE;
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;
if_attach(ifp);
if_alloc_sadl(ifp);
bpf_attach(ifp, DLT_NULL, sizeof(u_int));
#ifdef MBUFTRACE
ifp->if_mowner = malloc(sizeof(struct mowner), M_DEVBUF,
M_WAITOK | M_ZERO);
strlcpy(ifp->if_mowner->mo_name, ifp->if_xname,
sizeof(ifp->if_mowner->mo_name));
MOWNER_ATTACH(ifp->if_mowner);
#endif
return (0);
}
int vboxNetAdpOsCreate(PVBOXNETADP pThis, PCRTMAC pMACAddress)
{
int rc;
struct ifnet_init_params Params;
RTUUID uuid;
struct sockaddr_dl mac;
pThis->u.s.hEvtDetached = NIL_RTSEMEVENT;
rc = RTSemEventCreate(&pThis->u.s.hEvtDetached);
if (RT_FAILURE(rc))
{
printf("vboxNetAdpOsCreate: failed to create semaphore (rc=%d).\n", rc);
return rc;
}
pThis->u.s.nTapMode = BPF_MODE_DISABLED;
mac.sdl_len = sizeof(mac);
mac.sdl_family = AF_LINK;
mac.sdl_alen = ETHER_ADDR_LEN;
mac.sdl_nlen = 0;
mac.sdl_slen = 0;
memcpy(LLADDR(&mac), pMACAddress->au8, mac.sdl_alen);
RTStrPrintf(pThis->szName, VBOXNETADP_MAX_NAME_LEN, "%s%d", VBOXNETADP_NAME, pThis->iUnit);
vboxNetAdpDarwinComposeUUID(pThis, &uuid);
Params.uniqueid = uuid.au8;
Params.uniqueid_len = sizeof(uuid);
Params.name = VBOXNETADP_NAME;
Params.unit = pThis->iUnit;
Params.family = IFNET_FAMILY_ETHERNET;
Params.type = IFT_ETHER;
Params.output = vboxNetAdpDarwinOutput;
Params.demux = vboxNetAdpDarwinDemux;
Params.add_proto = vboxNetAdpDarwinAddProto;
Params.del_proto = vboxNetAdpDarwinDelProto;
Params.check_multi = ether_check_multi;
Params.framer = ether_frameout;
Params.softc = pThis;
Params.ioctl = (ifnet_ioctl_func)ether_ioctl;
Params.set_bpf_tap = NULL;
Params.detach = vboxNetAdpDarwinDetach;
Params.event = NULL;
Params.broadcast_addr = "\xFF\xFF\xFF\xFF\xFF\xFF";
Params.broadcast_len = ETHER_ADDR_LEN;
errno_t err = ifnet_allocate(&Params, &pThis->u.s.pIface);
if (!err)
{
err = ifnet_attach(pThis->u.s.pIface, &mac);
if (!err)
{
err = bpf_attach(pThis->u.s.pIface, DLT_EN10MB, ETHER_HDR_LEN,
vboxNetAdpDarwinBpfSend, vboxNetAdpDarwinBpfTap);
if (err)
{
LogRel(("vboxnetadp: bpf_attach failed with %d\n", err));
}
err = ifnet_set_flags(pThis->u.s.pIface, IFF_RUNNING | IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST, 0xFFFF);
if (!err)
{
ifnet_set_mtu(pThis->u.s.pIface, VBOXNETADP_MTU);
return VINF_SUCCESS;
}
else
Log(("vboxNetAdpDarwinRegisterDevice: Failed to set flags (err=%d).\n", err));
ifnet_detach(pThis->u.s.pIface);
}
else
Log(("vboxNetAdpDarwinRegisterDevice: Failed to attach to interface (err=%d).\n", err));
ifnet_release(pThis->u.s.pIface);
}
else
Log(("vboxNetAdpDarwinRegisterDevice: Failed to allocate interface (err=%d).\n", err));
RTSemEventDestroy(pThis->u.s.hEvtDetached);
pThis->u.s.hEvtDetached = NIL_RTSEMEVENT;
return RTErrConvertFromErrno(err);
}
/*
* Attach an interface to bpf. driverp is a pointer to a (struct bpf_if *)
* in the driver's softc; dlt is the link layer type; hdrlen is the fixed
* size of the link header (variable length headers not yet supported).
*/
void
bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
{
bpf_attach(ifp, dlt, hdrlen, NULL, NULL);
}