#include <mach/mach_types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/protosw.h>
#include <sys/domain.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/ioctl.h>
#include <sys/sysctl.h>
#include <sys/errno.h>
#include <sys/syslog.h>
#include <sys/proc.h>
#include <kern/queue.h>
#include <net/ndrv.h>
#include <net/route.h>
#include <net/if_llc.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/ndrv_var.h>
#include <net/dlil.h>
#if INET
#include <netinet/in.h>
#include <netinet/in_var.h>
#endif
#include <netinet/if_ether.h>
static unsigned int ndrv_multi_max_count = NDRV_DMUX_MAX_DESCR;
SYSCTL_UINT(_net, OID_AUTO, ndrv_multi_max_count, CTLFLAG_RW | CTLFLAG_LOCKED,
&ndrv_multi_max_count, 0, "Number of allowed multicast addresses per NRDV socket");
static int ndrv_do_detach(struct ndrv_cb *);
static int ndrv_do_disconnect(struct ndrv_cb *);
static struct ndrv_cb *ndrv_find_inbound(struct ifnet *ifp, u_int32_t protocol_family);
static int ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt);
static int ndrv_delspec(struct ndrv_cb *);
static int ndrv_to_ifnet_demux(struct ndrv_demux_desc* ndrv, struct ifnet_demux_desc* ifdemux);
static void ndrv_handle_ifp_detach(u_int32_t family, short unit);
static int ndrv_do_add_multicast(struct ndrv_cb *np, struct sockopt *sopt);
static int ndrv_do_remove_multicast(struct ndrv_cb *np, struct sockopt *sopt);
static struct ndrv_multiaddr* ndrv_have_multicast(struct ndrv_cb *np, struct sockaddr* addr);
static void ndrv_remove_all_multicast(struct ndrv_cb *np);
static void ndrv_dominit(struct domain *);
u_int32_t ndrv_sendspace = NDRVSNDQ;
u_int32_t ndrv_recvspace = NDRVRCVQ;
TAILQ_HEAD(, ndrv_cb) ndrvl = TAILQ_HEAD_INITIALIZER(ndrvl);
static struct domain *ndrvdomain = NULL;
extern struct domain ndrvdomain_s;
#define NDRV_PROTODEMUX_COUNT 10
#if NDRV_DEMUXTYPE_ETHERTYPE != DLIL_DESC_ETYPE2
#error NDRV_DEMUXTYPE_ETHERTYPE must match DLIL_DESC_ETYPE2
#endif
#if NDRV_DEMUXTYPE_SAP != DLIL_DESC_SAP
#error NDRV_DEMUXTYPE_SAP must match DLIL_DESC_SAP
#endif
#if NDRV_DEMUXTYPE_SNAP != DLIL_DESC_SNAP
#error NDRV_DEMUXTYPE_SNAP must match DLIL_DESC_SNAP
#endif
static int
ndrv_output(struct mbuf *m, struct socket *so)
{
struct ndrv_cb *np = sotondrvcb(so);
struct ifnet *ifp = np->nd_if;
int result = 0;
#if NDRV_DEBUG
printf("NDRV output: %x, %x, %x\n", m, so, np);
#endif
if ((m->m_flags & M_PKTHDR) == 0) {
return EINVAL;
}
socket_unlock(so, 0);
result = ifnet_output_raw(ifp, np->nd_proto_family, m);
socket_lock(so, 0);
return result;
}
static errno_t
ndrv_input(
ifnet_t ifp,
protocol_family_t proto_family,
mbuf_t m,
char *frame_header)
{
struct socket *so;
struct sockaddr_dl ndrvsrc = {};
struct ndrv_cb *np;
int error = 0;
ndrvsrc.sdl_len = sizeof(struct sockaddr_dl);
ndrvsrc.sdl_family = AF_NDRV;
ndrvsrc.sdl_index = 0;
ndrvsrc.sdl_type = IFT_ETHER;
ndrvsrc.sdl_nlen = 0;
ndrvsrc.sdl_alen = 6;
ndrvsrc.sdl_slen = 0;
bcopy(frame_header, &ndrvsrc.sdl_data, 6);
m = m_prepend(m, ifnet_hdrlen(ifp), M_NOWAIT);
if (m == NULL) {
return EJUSTRETURN;
}
bcopy(frame_header, m->m_data, ifnet_hdrlen(ifp));
LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED);
lck_mtx_lock(ndrvdomain->dom_mtx);
np = ndrv_find_inbound(ifp, proto_family);
if (np == NULL) {
lck_mtx_unlock(ndrvdomain->dom_mtx);
return ENOENT;
}
so = np->nd_socket;
if (sbappendaddr(&(so->so_rcv), (struct sockaddr *)&ndrvsrc,
m, NULL, &error) != 0) {
sorwakeup(so);
}
lck_mtx_unlock(ndrvdomain->dom_mtx);
return 0;
}
static int
ndrv_attach(struct socket *so, int proto, __unused struct proc *p)
{
int error;
struct ndrv_cb *np = sotondrvcb(so);
if ((so->so_state & SS_PRIV) == 0) {
return EPERM;
}
#if NDRV_DEBUG
printf("NDRV attach: %x, %x, %x\n", so, proto, np);
#endif
if ((error = soreserve(so, ndrv_sendspace, ndrv_recvspace))) {
return error;
}
MALLOC(np, struct ndrv_cb *, sizeof(*np), M_PCB, M_WAITOK);
if (np == NULL) {
return ENOMEM;
}
so->so_pcb = (caddr_t)np;
bzero(np, sizeof(*np));
#if NDRV_DEBUG
printf("NDRV attach: %x, %x, %x\n", so, proto, np);
#endif
TAILQ_INIT(&np->nd_dlist);
np->nd_signature = NDRV_SIGNATURE;
np->nd_socket = so;
np->nd_proto.sp_family = (uint16_t)SOCK_DOM(so);
np->nd_proto.sp_protocol = (uint16_t)proto;
np->nd_if = NULL;
np->nd_proto_family = 0;
np->nd_family = 0;
np->nd_unit = 0;
LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED);
lck_mtx_lock(ndrvdomain->dom_mtx);
TAILQ_INSERT_TAIL(&ndrvl, np, nd_next);
lck_mtx_unlock(ndrvdomain->dom_mtx);
return 0;
}
static int
ndrv_detach(struct socket *so)
{
struct ndrv_cb *np = sotondrvcb(so);
if (np == 0) {
return EINVAL;
}
return ndrv_do_detach(np);
}
static int
ndrv_connect(struct socket *so, struct sockaddr *nam, __unused struct proc *p)
{
struct ndrv_cb *np = sotondrvcb(so);
if (np == 0) {
return EINVAL;
}
if (np->nd_faddr) {
return EISCONN;
}
MALLOC(np->nd_faddr, struct sockaddr_ndrv*,
nam->sa_len, M_IFADDR, M_WAITOK);
if (np->nd_faddr == NULL) {
return ENOMEM;
}
bcopy((caddr_t) nam, (caddr_t) np->nd_faddr, nam->sa_len);
soisconnected(so);
return 0;
}
static void
ndrv_event(struct ifnet *ifp, __unused protocol_family_t protocol,
const struct kev_msg *event)
{
if (event->vendor_code == KEV_VENDOR_APPLE &&
event->kev_class == KEV_NETWORK_CLASS &&
event->kev_subclass == KEV_DL_SUBCLASS &&
event->event_code == KEV_DL_IF_DETACHING) {
LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED);
lck_mtx_lock(ndrvdomain->dom_mtx);
ndrv_handle_ifp_detach(ifnet_family(ifp), ifp->if_unit);
lck_mtx_unlock(ndrvdomain->dom_mtx);
}
}
static int
ndrv_bind(struct socket *so, struct sockaddr *nam, __unused struct proc *p)
{
struct sockaddr_ndrv *sa = (struct sockaddr_ndrv *) nam;
char *dname;
struct ndrv_cb *np;
struct ifnet *ifp;
int result;
if (TAILQ_EMPTY(&ifnet_head)) {
return EADDRNOTAVAIL;
}
np = sotondrvcb(so);
if (np == 0) {
return EINVAL;
}
if (np->nd_laddr) {
return EINVAL;
}
np->nd_laddr = _MALLOC(sizeof(struct sockaddr_ndrv), M_IFADDR, M_WAITOK);
if (np->nd_laddr == NULL) {
return ENOMEM;
}
bcopy((caddr_t) sa, (caddr_t) np->nd_laddr, sizeof(struct sockaddr_ndrv));
dname = (char *) sa->snd_name;
np->nd_laddr->snd_len = sizeof(struct sockaddr_ndrv);
if (*dname == '\0') {
return EINVAL;
}
#if NDRV_DEBUG
printf("NDRV bind: %x, %x, %s\n", so, np, dname);
#endif
ifnet_head_lock_shared();
TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
if (strncmp(ifp->if_xname, dname, IFNAMSIZ) == 0) {
break;
}
}
ifnet_head_done();
if (ifp == NULL) {
return EADDRNOTAVAIL;
}
if (ifnet_family(ifp) != APPLE_IF_FAM_PPP) {
struct ifnet_attach_proto_param ndrv_proto;
result = 0;
bzero(&ndrv_proto, sizeof(ndrv_proto));
ndrv_proto.event = ndrv_event;
socket_unlock(so, 0);
result = ifnet_attach_protocol(ifp, PF_NDRV, &ndrv_proto);
socket_lock(so, 0);
if (result && result != EEXIST) {
return result;
}
np->nd_proto_family = PF_NDRV;
} else {
np->nd_proto_family = 0;
}
np->nd_if = ifp;
np->nd_family = ifnet_family(ifp);
np->nd_unit = ifp->if_unit;
return 0;
}
static int
ndrv_disconnect(struct socket *so)
{
struct ndrv_cb *np = sotondrvcb(so);
if (np == 0) {
return EINVAL;
}
if (np->nd_faddr == 0) {
return ENOTCONN;
}
ndrv_do_disconnect(np);
return 0;
}
static int
ndrv_shutdown(struct socket *so)
{
LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);
socantsendmore(so);
return 0;
}
static int
ndrv_send(struct socket *so, __unused int flags, struct mbuf *m,
__unused struct sockaddr *addr, struct mbuf *control,
__unused struct proc *p)
{
int error;
if (control != NULL) {
m_freem(control);
return EOPNOTSUPP;
}
error = ndrv_output(m, so);
m = NULL;
return error;
}
static int
ndrv_abort(struct socket *so)
{
struct ndrv_cb *np = sotondrvcb(so);
if (np == 0) {
return EINVAL;
}
ndrv_do_disconnect(np);
return 0;
}
static int
ndrv_sockaddr(struct socket *so, struct sockaddr **nam)
{
struct ndrv_cb *np = sotondrvcb(so);
int len;
if (np == 0) {
return EINVAL;
}
if (np->nd_laddr == 0) {
return EINVAL;
}
len = np->nd_laddr->snd_len;
MALLOC(*nam, struct sockaddr *, len, M_SONAME, M_WAITOK);
if (*nam == NULL) {
return ENOMEM;
}
bcopy((caddr_t)np->nd_laddr, *nam,
(unsigned)len);
return 0;
}
static int
ndrv_peeraddr(struct socket *so, struct sockaddr **nam)
{
struct ndrv_cb *np = sotondrvcb(so);
int len;
if (np == 0) {
return EINVAL;
}
if (np->nd_faddr == 0) {
return ENOTCONN;
}
len = np->nd_faddr->snd_len;
MALLOC(*nam, struct sockaddr *, len, M_SONAME, M_WAITOK);
if (*nam == NULL) {
return ENOMEM;
}
bcopy((caddr_t)np->nd_faddr, *nam,
(unsigned)len);
return 0;
}
static int
ndrv_ctloutput(struct socket *so, struct sockopt *sopt)
{
struct ndrv_cb *np = sotondrvcb(so);
int error = 0;
switch (sopt->sopt_name) {
case NDRV_DELDMXSPEC:
if (sopt->sopt_val != 0 || sopt->sopt_valsize != 0) {
return EINVAL;
}
error = ndrv_delspec(np);
break;
case NDRV_SETDMXSPEC:
error = ndrv_setspec(np, sopt);
break;
case NDRV_ADDMULTICAST:
error = ndrv_do_add_multicast(np, sopt);
break;
case NDRV_DELMULTICAST:
error = ndrv_do_remove_multicast(np, sopt);
break;
default:
error = ENOTSUP;
}
#ifdef NDRV_DEBUG
log(LOG_WARNING, "NDRV CTLOUT: %x returns %d\n", sopt->sopt_name,
error);
#endif
return error;
}
static int
ndrv_do_detach(struct ndrv_cb *np)
{
struct ndrv_cb* cur_np = NULL;
struct socket *so = np->nd_socket;
int error = 0;
struct ifnet * ifp;
#if NDRV_DEBUG
printf("NDRV detach: %x, %x\n", so, np);
#endif
ndrv_remove_all_multicast(np);
LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);
TAILQ_REMOVE(&ndrvl, np, nd_next);
ifp = np->nd_if;
if (ifp != NULL) {
u_int32_t proto_family = np->nd_proto_family;
if (proto_family != PF_NDRV && proto_family != 0) {
socket_unlock(so, 0);
ifnet_detach_protocol(ifp, proto_family);
socket_lock(so, 0);
}
LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);
TAILQ_FOREACH(cur_np, &ndrvl, nd_next) {
if (cur_np->nd_family == np->nd_family &&
cur_np->nd_unit == np->nd_unit) {
break;
}
}
if (cur_np == NULL) {
socket_unlock(so, 0);
ifnet_detach_protocol(ifp, PF_NDRV);
socket_lock(so, 0);
}
}
if (np->nd_laddr != NULL) {
FREE(np->nd_laddr, M_IFADDR);
np->nd_laddr = NULL;
}
FREE(np, M_PCB);
so->so_pcb = 0;
so->so_flags |= SOF_PCBCLEARING;
sofree(so);
return error;
}
static int
ndrv_do_disconnect(struct ndrv_cb *np)
{
struct socket * so = np->nd_socket;
#if NDRV_DEBUG
printf("NDRV disconnect: %x\n", np);
#endif
if (np->nd_faddr) {
FREE(np->nd_faddr, M_IFADDR);
np->nd_faddr = 0;
}
if (!(so->so_flags & SOF_MP_SUBFLOW) && (so->so_state & SS_NOFDREF)) {
ndrv_do_detach(np);
}
soisdisconnected(so);
return 0;
}
#if 0
void
ndrv_flushq(struct ifqueue *q)
{
struct mbuf *m;
for (;;) {
IF_DEQUEUE(q, m);
if (m == NULL) {
break;
}
IF_DROP(q);
if (m) {
m_freem(m);
}
}
}
#endif
int
ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt)
{
struct ifnet_attach_proto_param proto_param;
struct ndrv_protocol_desc ndrvSpec;
struct ndrv_demux_desc* ndrvDemux = NULL;
int error = 0;
struct socket * so = np->nd_socket;
user_addr_t user_addr;
if (np->nd_proto_family != PF_NDRV) {
return EBUSY;
}
if (np->nd_if == NULL) {
return EINVAL;
}
if (proc_is64bit(sopt->sopt_p)) {
struct ndrv_protocol_desc64 ndrvSpec64;
if (sopt->sopt_valsize != sizeof(ndrvSpec64)) {
return EINVAL;
}
error = sooptcopyin(sopt, &ndrvSpec64, sizeof(ndrvSpec64), sizeof(ndrvSpec64));
if (error != 0) {
return error;
}
ndrvSpec.version = ndrvSpec64.version;
ndrvSpec.protocol_family = ndrvSpec64.protocol_family;
ndrvSpec.demux_count = ndrvSpec64.demux_count;
user_addr = CAST_USER_ADDR_T(ndrvSpec64.demux_list);
} else {
struct ndrv_protocol_desc32 ndrvSpec32;
if (sopt->sopt_valsize != sizeof(ndrvSpec32)) {
return EINVAL;
}
error = sooptcopyin(sopt, &ndrvSpec32, sizeof(ndrvSpec32), sizeof(ndrvSpec32));
if (error != 0) {
return error;
}
ndrvSpec.version = ndrvSpec32.version;
ndrvSpec.protocol_family = ndrvSpec32.protocol_family;
ndrvSpec.demux_count = ndrvSpec32.demux_count;
user_addr = CAST_USER_ADDR_T(ndrvSpec32.demux_list);
}
if (ndrvSpec.version > NDRV_PROTOCOL_DESC_VERS) {
return ENOTSUP; } else if (ndrvSpec.version < 1) {
return EINVAL; } else if (ndrvSpec.demux_count > NDRV_PROTODEMUX_COUNT || ndrvSpec.demux_count == 0) {
return EINVAL; }
bzero(&proto_param, sizeof(proto_param));
proto_param.demux_count = ndrvSpec.demux_count;
MALLOC(ndrvDemux, struct ndrv_demux_desc*, proto_param.demux_count *
sizeof(struct ndrv_demux_desc), M_TEMP, M_WAITOK);
if (ndrvDemux == NULL) {
return ENOMEM;
}
MALLOC(proto_param.demux_array, struct ifnet_demux_desc*,
sizeof(*proto_param.demux_array) * ndrvSpec.demux_count,
M_TEMP, M_WAITOK);
if (proto_param.demux_array == NULL) {
error = ENOMEM;
}
if (error == 0) {
error = copyin(user_addr, ndrvDemux,
ndrvSpec.demux_count * sizeof(struct ndrv_demux_desc));
ndrvSpec.demux_list = ndrvDemux;
}
if (error == 0) {
u_int32_t demuxOn = 0;
proto_param.demux_count = ndrvSpec.demux_count;
proto_param.input = ndrv_input;
proto_param.event = ndrv_event;
for (demuxOn = 0; demuxOn < ndrvSpec.demux_count; demuxOn++) {
error = ndrv_to_ifnet_demux(&ndrvSpec.demux_list[demuxOn],
&proto_param.demux_array[demuxOn]);
if (error) {
break;
}
}
}
if (error == 0) {
socket_unlock(so, 0);
error = ifnet_attach_protocol(np->nd_if, ndrvSpec.protocol_family,
&proto_param);
socket_lock(so, 0);
if (error == 0) {
np->nd_proto_family = ndrvSpec.protocol_family;
}
}
if (proto_param.demux_array) {
FREE(proto_param.demux_array, M_TEMP);
}
if (ndrvDemux) {
FREE(ndrvDemux, M_TEMP);
}
return error;
}
int
ndrv_to_ifnet_demux(struct ndrv_demux_desc* ndrv, struct ifnet_demux_desc* ifdemux)
{
bzero(ifdemux, sizeof(*ifdemux));
if (ndrv->type < DLIL_DESC_ETYPE2) {
return ENOTSUP;
}
if (ndrv->length > 28) {
return EINVAL;
}
ifdemux->type = ndrv->type;
ifdemux->data = ndrv->data.other;
ifdemux->datalen = ndrv->length;
return 0;
}
int
ndrv_delspec(struct ndrv_cb *np)
{
int result = 0;
if (np->nd_proto_family == PF_NDRV ||
np->nd_proto_family == 0) {
return EINVAL;
}
result = ifnet_detach_protocol(np->nd_if, np->nd_proto_family);
np->nd_proto_family = PF_NDRV;
return result;
}
struct ndrv_cb *
ndrv_find_inbound(struct ifnet *ifp, u_int32_t protocol)
{
struct ndrv_cb* np;
LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);
if (protocol == PF_NDRV) {
return NULL;
}
TAILQ_FOREACH(np, &ndrvl, nd_next) {
if (np->nd_proto_family == protocol &&
np->nd_if == ifp) {
return np;
}
}
return NULL;
}
static void
ndrv_handle_ifp_detach(u_int32_t family, short unit)
{
struct ndrv_cb* np;
struct ifnet *ifp = NULL;
struct socket *so;
TAILQ_FOREACH(np, &ndrvl, nd_next) {
if (np->nd_family == family &&
np->nd_unit == unit) {
ifp = np->nd_if;
if (np->nd_proto_family != 0) {
ndrv_delspec(np);
}
ndrv_remove_all_multicast(np);
np->nd_if = NULL;
np->nd_unit = 0;
np->nd_family = 0;
so = np->nd_socket;
LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);
socantsendmore(so);
socantrcvmore(so);
}
}
if (ifp) {
ifnet_detach_protocol(ifp, PF_NDRV);
}
}
static int
ndrv_do_add_multicast(struct ndrv_cb *np, struct sockopt *sopt)
{
struct ndrv_multiaddr* ndrv_multi;
int result;
if (sopt->sopt_val == 0 || sopt->sopt_valsize < 2 ||
sopt->sopt_level != SOL_NDRVPROTO || sopt->sopt_valsize > SOCK_MAXADDRLEN) {
return EINVAL;
}
if (np->nd_if == NULL) {
return ENXIO;
}
if (!(np->nd_dlist_cnt < ndrv_multi_max_count)) {
return EPERM;
}
MALLOC(ndrv_multi, struct ndrv_multiaddr*, sizeof(struct ndrv_multiaddr) -
sizeof(struct sockaddr) + sopt->sopt_valsize, M_IFADDR, M_WAITOK);
if (ndrv_multi == NULL) {
return ENOMEM;
}
result = copyin(sopt->sopt_val, &ndrv_multi->addr, sopt->sopt_valsize);
if (result == 0 && sopt->sopt_valsize != ndrv_multi->addr.sa_len) {
result = EINVAL;
}
if (result == 0 && ndrv_have_multicast(np, &ndrv_multi->addr)) {
result = EEXIST;
}
if (result == 0) {
result = ifnet_add_multicast(np->nd_if, &ndrv_multi->addr,
&ndrv_multi->ifma);
}
if (result == 0) {
ndrv_multi->next = np->nd_multiaddrs;
np->nd_multiaddrs = ndrv_multi;
np->nd_dlist_cnt++;
} else {
FREE(ndrv_multi, M_IFADDR);
}
return result;
}
static int
ndrv_do_remove_multicast(struct ndrv_cb *np, struct sockopt *sopt)
{
struct sockaddr* multi_addr;
struct ndrv_multiaddr* ndrv_entry = NULL;
int result;
if (sopt->sopt_val == 0 || sopt->sopt_valsize < 2 ||
sopt->sopt_level != SOL_NDRVPROTO) {
return EINVAL;
}
if (np->nd_if == NULL || np->nd_dlist_cnt == 0) {
return ENXIO;
}
MALLOC(multi_addr, struct sockaddr*, sopt->sopt_valsize,
M_TEMP, M_WAITOK);
if (multi_addr == NULL) {
return ENOMEM;
}
result = copyin(sopt->sopt_val, multi_addr, sopt->sopt_valsize);
if (result == 0 && sopt->sopt_valsize != multi_addr->sa_len) {
result = EINVAL;
}
if (result == 0) {
ndrv_entry = ndrv_have_multicast(np, multi_addr);
if (ndrv_entry == NULL) {
result = ENOENT;
}
}
if (result == 0) {
result = ifnet_remove_multicast(ndrv_entry->ifma);
}
if (result == 0) {
struct ndrv_multiaddr* cur = np->nd_multiaddrs;
ifmaddr_release(ndrv_entry->ifma);
if (cur == ndrv_entry) {
np->nd_multiaddrs = cur->next;
} else {
for (cur = cur->next; cur != NULL; cur = cur->next) {
if (cur->next == ndrv_entry) {
cur->next = cur->next->next;
break;
}
}
}
np->nd_dlist_cnt--;
FREE(ndrv_entry, M_IFADDR);
}
FREE(multi_addr, M_TEMP);
return result;
}
static struct ndrv_multiaddr*
ndrv_have_multicast(struct ndrv_cb *np, struct sockaddr* inAddr)
{
struct ndrv_multiaddr* cur;
for (cur = np->nd_multiaddrs; cur != NULL; cur = cur->next) {
if ((inAddr->sa_len == cur->addr.sa_len) &&
(bcmp(&cur->addr, inAddr, inAddr->sa_len) == 0)) {
return cur;
}
}
return NULL;
}
static void
ndrv_remove_all_multicast(struct ndrv_cb* np)
{
struct ndrv_multiaddr* cur;
if (np->nd_if != NULL) {
while (np->nd_multiaddrs != NULL) {
cur = np->nd_multiaddrs;
np->nd_multiaddrs = cur->next;
ifnet_remove_multicast(cur->ifma);
ifmaddr_release(cur->ifma);
FREE(cur, M_IFADDR);
}
}
}
static struct pr_usrreqs ndrv_usrreqs = {
.pru_abort = ndrv_abort,
.pru_attach = ndrv_attach,
.pru_bind = ndrv_bind,
.pru_connect = ndrv_connect,
.pru_detach = ndrv_detach,
.pru_disconnect = ndrv_disconnect,
.pru_peeraddr = ndrv_peeraddr,
.pru_send = ndrv_send,
.pru_shutdown = ndrv_shutdown,
.pru_sockaddr = ndrv_sockaddr,
.pru_sosend = sosend,
.pru_soreceive = soreceive,
};
static struct protosw ndrvsw[] = {
{
.pr_type = SOCK_RAW,
.pr_protocol = NDRVPROTO_NDRV,
.pr_flags = PR_ATOMIC | PR_ADDR,
.pr_output = ndrv_output,
.pr_ctloutput = ndrv_ctloutput,
.pr_usrreqs = &ndrv_usrreqs,
}
};
static int ndrv_proto_count = (sizeof(ndrvsw) / sizeof(struct protosw));
struct domain ndrvdomain_s = {
.dom_family = PF_NDRV,
.dom_name = "NetDriver",
.dom_init = ndrv_dominit,
};
static void
ndrv_dominit(struct domain *dp)
{
struct protosw *pr;
int i;
VERIFY(!(dp->dom_flags & DOM_INITIALIZED));
VERIFY(ndrvdomain == NULL);
ndrvdomain = dp;
for (i = 0, pr = &ndrvsw[0]; i < ndrv_proto_count; i++, pr++) {
net_add_proto(pr, dp, 1);
}
}