#include "loop.h"
#if NLOOP > 0
#if NLOOP != 1
#error "More than one loopback interface is not supported."
#endif
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/mcache.h>
#include <sys/sysctl.h>
#include <net/if.h>
#include <net/if_types.h>
#include <net/route.h>
#include <net/bpf.h>
#include <sys/malloc.h>
#if INET
#include <netinet/in.h>
#include <netinet/in_var.h>
#endif
#if INET6
#if !INET
#include <netinet/in.h>
#endif
#include <netinet6/in6_var.h>
#include <netinet/ip6.h>
#endif
#include <net/dlil.h>
#include <net/kpi_protocol.h>
#if CONFIG_MACF_NET
#include <security/mac_framework.h>
#endif
#include <pexpert/pexpert.h>
#define LOMTU 16384
#define LOSNDQ_MAXLEN 256
#define LO_BPF_TAP_OUT(_m) { \
if (lo_statics[0].bpf_callback != NULL) { \
bpf_tap_out(lo_ifp, DLT_NULL, _m, \
&((struct loopback_header *)_m->m_pkthdr.pkt_hdr)-> \
protocol, sizeof (u_int32_t)); \
} \
}
#define LO_BPF_TAP_OUT_MULTI(_m) { \
if (lo_statics[0].bpf_callback != NULL) { \
struct mbuf *_n; \
for (_n = _m; _n != NULL; _n = _n->m_nextpkt) \
LO_BPF_TAP_OUT(_n); \
} \
}
struct lo_statics_str {
int bpf_mode;
bpf_packet_func bpf_callback;
};
static struct lo_statics_str lo_statics[NLOOP];
static int lo_txstart = 0;
struct ifnet *lo_ifp = NULL;
struct loopback_header {
protocol_family_t protocol;
};
void loopattach(void);
static errno_t lo_demux(struct ifnet *, struct mbuf *, char *,
protocol_family_t *);
static errno_t
lo_framer(struct ifnet *, struct mbuf **, const struct sockaddr *,
const char *, const char *, u_int32_t *, u_int32_t *);
static errno_t lo_add_proto(struct ifnet *, protocol_family_t,
const struct ifnet_demux_desc *, u_int32_t);
static errno_t lo_del_proto(struct ifnet *, protocol_family_t);
static int lo_output(struct ifnet *, struct mbuf *);
static errno_t lo_pre_enqueue(struct ifnet *, struct mbuf *);
static void lo_start(struct ifnet *);
static errno_t lo_pre_output(struct ifnet *, protocol_family_t, struct mbuf **,
const struct sockaddr *, void *, char *, char *);
static errno_t lo_input(struct ifnet *, protocol_family_t, struct mbuf *);
static void lo_rtrequest(int, struct rtentry *, struct sockaddr *);
static errno_t lo_ioctl(struct ifnet *, u_long, void *);
static errno_t lo_attach_proto(struct ifnet *, protocol_family_t);
static void lo_reg_if_mods(void);
static errno_t lo_set_bpf_tap(struct ifnet *, bpf_tap_mode, bpf_packet_func);
static int sysctl_dequeue_max SYSCTL_HANDLER_ARGS;
static int sysctl_sched_model SYSCTL_HANDLER_ARGS;
static int sysctl_dequeue_scidx SYSCTL_HANDLER_ARGS;
SYSCTL_DECL(_net_link);
SYSCTL_NODE(_net_link, OID_AUTO, loopback, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
"loopback interface");
#define LO_BW_SLEEP 10
static u_int32_t lo_bw_sleep_usec = LO_BW_SLEEP;
SYSCTL_UINT(_net_link_loopback, OID_AUTO, bw_sleep_usec,
CTLFLAG_RW | CTLFLAG_LOCKED, &lo_bw_sleep_usec, LO_BW_SLEEP, "");
static u_int32_t lo_bw_measure = 0;
SYSCTL_UINT(_net_link_loopback, OID_AUTO, bw_measure,
CTLFLAG_RW | CTLFLAG_LOCKED, &lo_bw_measure, 0, "");
static u_int32_t lo_dequeue_max = LOSNDQ_MAXLEN;
SYSCTL_PROC(_net_link_loopback, OID_AUTO, max_dequeue,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &lo_dequeue_max, LOSNDQ_MAXLEN,
sysctl_dequeue_max, "I", "Maximum number of packets dequeued at a time");
static u_int32_t lo_sched_model = IFNET_SCHED_MODEL_NORMAL;
SYSCTL_PROC(_net_link_loopback, OID_AUTO, sched_model,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &lo_sched_model,
IFNET_SCHED_MODEL_NORMAL, sysctl_sched_model, "I", "Scheduling model");
static u_int32_t lo_dequeue_sc = MBUF_SC_BE;
static int lo_dequeue_scidx = MBUF_SCIDX(MBUF_SC_BE);
SYSCTL_PROC(_net_link_loopback, OID_AUTO, dequeue_sc,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &lo_dequeue_scidx,
MBUF_SC_BE, sysctl_dequeue_scidx, "I", "Dequeue a specific SC index");
static errno_t
lo_demux(struct ifnet *ifp, struct mbuf *m, char *frame_header,
protocol_family_t *protocol_family)
{
#pragma unused(ifp, m)
struct loopback_header *header =
(struct loopback_header *)(void *)frame_header;
*protocol_family = header->protocol;
return (0);
}
static errno_t
lo_framer(struct ifnet *ifp, struct mbuf **m, const struct sockaddr *dest,
const char *dest_linkaddr, const char *frame_type,
u_int32_t *prepend_len, u_int32_t *postpend_len)
{
#pragma unused(ifp, dest, dest_linkaddr)
struct loopback_header *header;
M_PREPEND(*m, sizeof (struct loopback_header), M_WAITOK, 1);
if (*m == NULL) {
return (EJUSTRETURN);
}
if (prepend_len != NULL)
*prepend_len = sizeof (struct loopback_header);
if (postpend_len != NULL)
*postpend_len = 0;
header = mtod(*m, struct loopback_header *);
bcopy(frame_type, &header->protocol, sizeof (u_int32_t));
return (0);
}
static errno_t
lo_add_proto(struct ifnet *interface, protocol_family_t protocol_family,
const struct ifnet_demux_desc *demux_array, u_int32_t demux_count)
{
#pragma unused(interface, protocol_family, demux_array, demux_count)
return (0);
}
static errno_t
lo_del_proto(struct ifnet *ifp, protocol_family_t protocol)
{
#pragma unused(ifp, protocol)
return (0);
}
static int
lo_output(struct ifnet *ifp, struct mbuf *m_list)
{
struct mbuf *m, *m_tail = NULL;
struct ifnet_stat_increment_param s;
u_int32_t cnt = 0, len = 0;
bzero(&s, sizeof(s));
for (m = m_list; m; m = m->m_nextpkt) {
VERIFY(m->m_flags & M_PKTHDR);
cnt++;
len += m->m_pkthdr.len;
if (m->m_pkthdr.rcvif == NULL)
m->m_pkthdr.rcvif = ifp;
m->m_pkthdr.pkt_flags |= PKTF_LOOP;
m->m_pkthdr.pkt_hdr = mtod(m, char *);
m->m_pkthdr.csum_data = 0xffff;
m->m_pkthdr.csum_flags =
CSUM_DATA_VALID | CSUM_PSEUDO_HDR |
CSUM_IP_CHECKED | CSUM_IP_VALID;
m_adj(m, sizeof (struct loopback_header));
LO_BPF_TAP_OUT(m);
if (m->m_nextpkt == NULL) {
m_tail = m;
}
}
s.packets_in = cnt;
s.packets_out = cnt;
s.bytes_in = len;
s.bytes_out = len;
return (ifnet_input_extended(ifp, m_list, m_tail, &s));
}
static errno_t
lo_pre_enqueue(struct ifnet *ifp, struct mbuf *m0)
{
struct mbuf *m = m0, *n;
int error = 0;
while (m != NULL) {
VERIFY(m->m_flags & M_PKTHDR);
n = m->m_nextpkt;
m->m_nextpkt = NULL;
if (m->m_pkthdr.rcvif == NULL)
m->m_pkthdr.rcvif = ifp;
m->m_pkthdr.pkt_flags |= PKTF_LOOP;
m->m_pkthdr.pkt_hdr = mtod(m, char *);
m->m_pkthdr.csum_data = 0xffff;
m->m_pkthdr.csum_flags =
CSUM_DATA_VALID | CSUM_PSEUDO_HDR |
CSUM_IP_CHECKED | CSUM_IP_VALID;
m_adj(m, sizeof (struct loopback_header));
(void) ifnet_enqueue(ifp, m);
m = n;
}
return (error);
}
static void
lo_start(struct ifnet *ifp)
{
struct ifnet_stat_increment_param s;
bzero(&s, sizeof (s));
for (;;) {
struct mbuf *m = NULL, *m_tail = NULL;
u_int32_t cnt, len = 0;
int sleep_chan = 0;
struct timespec ts;
if (lo_sched_model == IFNET_SCHED_MODEL_NORMAL) {
if (ifnet_dequeue_multi(ifp, lo_dequeue_max, &m,
&m_tail, &cnt, &len) != 0)
break;
} else {
if (ifnet_dequeue_service_class_multi(ifp,
lo_dequeue_sc, lo_dequeue_max, &m,
&m_tail, &cnt, &len) != 0)
break;
}
LO_BPF_TAP_OUT_MULTI(m);
if (lo_bw_measure) {
if (cnt >= if_bw_measure_size)
ifnet_transmit_burst_start(ifp, m);
if (lo_bw_sleep_usec > 0) {
bzero(&ts, sizeof(ts));
ts.tv_nsec = (lo_bw_sleep_usec << 10) * cnt;
(void) msleep(&sleep_chan, NULL,
PSOCK, "lo_start", &ts);
}
if (cnt >= if_bw_measure_size)
ifnet_transmit_burst_end(ifp, m_tail);
}
s.packets_in = cnt;
s.packets_out = cnt;
s.bytes_in = len;
s.bytes_out = len;
(void) ifnet_input_extended(ifp, m, m_tail, &s);
}
}
static errno_t
lo_pre_output(struct ifnet *ifp, protocol_family_t protocol_family,
struct mbuf **m, const struct sockaddr *dst, void *route, char *frame_type,
char *dst_addr)
{
#pragma unused(ifp, dst, dst_addr)
struct rtentry *rt = route;
VERIFY((*m)->m_flags & M_PKTHDR);
(*m)->m_flags |= M_LOOP;
if (rt != NULL) {
u_int32_t rt_flags = rt->rt_flags;
if (rt_flags & (RTF_REJECT | RTF_BLACKHOLE)) {
if (rt_flags & RTF_BLACKHOLE) {
m_freem(*m);
return (EJUSTRETURN);
} else {
return ((rt_flags & RTF_HOST) ?
EHOSTUNREACH : ENETUNREACH);
}
}
}
bcopy(&protocol_family, frame_type, sizeof (protocol_family));
return (0);
}
static errno_t
lo_input(struct ifnet *ifp, protocol_family_t protocol_family, struct mbuf *m)
{
#pragma unused(ifp, protocol_family)
if (proto_input(protocol_family, m) != 0)
m_freem(m);
return (0);
}
static void
lo_rtrequest(int cmd, struct rtentry *rt, struct sockaddr *sa)
{
#pragma unused(cmd, sa)
if (rt != NULL) {
RT_LOCK_ASSERT_HELD(rt);
rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu;
rt->rt_rmx.rmx_recvpipe = rt->rt_rmx.rmx_sendpipe = 3 * LOMTU;
}
}
static errno_t
lo_ioctl(struct ifnet *ifp, u_long cmd, void *data)
{
int error = 0;
switch (cmd) {
case SIOCSIFADDR: {
struct ifaddr *ifa = data;
ifnet_set_flags(ifp, IFF_UP|IFF_RUNNING, IFF_UP|IFF_RUNNING);
IFA_LOCK_SPIN(ifa);
ifa->ifa_rtrequest = lo_rtrequest;
IFA_UNLOCK(ifa);
break;
}
case SIOCADDMULTI:
case SIOCDELMULTI: {
struct ifreq *ifr = data;
if (ifr == NULL) {
error = EAFNOSUPPORT;
break;
}
switch (ifr->ifr_addr.sa_family) {
#if INET
case AF_INET:
break;
#endif
#if INET6
case AF_INET6:
break;
#endif
default:
error = EAFNOSUPPORT;
break;
}
break;
}
case SIOCSIFMTU: {
struct ifreq *ifr = data;
bcopy(&ifr->ifr_mtu, &ifp->if_mtu, sizeof (int));
break;
}
case SIOCSIFFLAGS:
break;
default:
error = EOPNOTSUPP;
break;
}
return (error);
}
#endif
static errno_t
lo_attach_proto(struct ifnet *ifp, protocol_family_t protocol_family)
{
struct ifnet_attach_proto_param_v2 proto;
errno_t result = 0;
bzero(&proto, sizeof (proto));
proto.input = lo_input;
proto.pre_output = lo_pre_output;
result = ifnet_attach_protocol_v2(ifp, protocol_family, &proto);
if (result && result != EEXIST) {
printf("lo_attach_proto: ifnet_attach_protocol for %u "
"returned=%d\n", protocol_family, result);
}
return (result);
}
static void
lo_reg_if_mods(void)
{
int error;
if ((error = proto_register_plumber(PF_INET,
APPLE_IF_FAM_LOOPBACK, lo_attach_proto, NULL)) != 0)
printf("proto_register_plumber failed for AF_INET "
"error=%d\n", error);
if ((error = proto_register_plumber(PF_INET6,
APPLE_IF_FAM_LOOPBACK, lo_attach_proto, NULL)) != 0)
printf("proto_register_plumber failed for AF_INET6 "
"error=%d\n", error);
}
static errno_t
lo_set_bpf_tap(struct ifnet *ifp, bpf_tap_mode mode,
bpf_packet_func bpf_callback)
{
VERIFY(ifp == lo_ifp);
lo_statics[0].bpf_mode = mode;
switch (mode) {
case BPF_TAP_DISABLE:
case BPF_TAP_INPUT:
lo_statics[0].bpf_callback = NULL;
break;
case BPF_TAP_OUTPUT:
case BPF_TAP_INPUT_OUTPUT:
lo_statics[0].bpf_callback = bpf_callback;
break;
}
return (0);
}
void
loopattach(void)
{
struct ifnet_init_eparams lo_init;
errno_t result = 0;
PE_parse_boot_argn("lo_txstart", &lo_txstart, sizeof (lo_txstart));
lo_reg_if_mods();
lo_statics[0].bpf_callback = NULL;
lo_statics[0].bpf_mode = BPF_TAP_DISABLE;
bzero(&lo_init, sizeof (lo_init));
lo_init.ver = IFNET_INIT_CURRENT_VERSION;
lo_init.len = sizeof (lo_init);
lo_init.sndq_maxlen = LOSNDQ_MAXLEN;
if (lo_txstart) {
lo_init.flags = 0;
lo_init.pre_enqueue = lo_pre_enqueue;
lo_init.start = lo_start;
lo_init.output_sched_model = lo_sched_model;
} else {
lo_init.flags = IFNET_INIT_LEGACY;
lo_init.output = lo_output;
}
lo_init.name = "lo";
lo_init.unit = 0;
lo_init.family = IFNET_FAMILY_LOOPBACK;
lo_init.type = IFT_LOOP;
lo_init.demux = lo_demux;
lo_init.add_proto = lo_add_proto;
lo_init.del_proto = lo_del_proto;
lo_init.framer_extended = lo_framer;
lo_init.softc = &lo_statics[0];
lo_init.ioctl = lo_ioctl;
lo_init.set_bpf_tap = lo_set_bpf_tap;
result = ifnet_allocate_extended(&lo_init, &lo_ifp);
if (result != 0) {
panic("%s: couldn't allocate loopback ifnet (%d)\n",
__func__, result);
}
ifnet_set_mtu(lo_ifp, LOMTU);
ifnet_set_flags(lo_ifp, IFF_LOOPBACK | IFF_MULTICAST,
IFF_LOOPBACK | IFF_MULTICAST);
ifnet_set_offload(lo_ifp,
IFNET_CSUM_IP | IFNET_CSUM_TCP | IFNET_CSUM_UDP |
IFNET_CSUM_TCPIPV6 | IFNET_CSUM_UDPIPV6 | IFNET_IPV6_FRAGMENT |
IFNET_CSUM_FRAGMENT | IFNET_IP_FRAGMENT | IFNET_MULTIPAGES);
ifnet_set_hdrlen(lo_ifp, sizeof (struct loopback_header));
ifnet_set_eflags(lo_ifp, IFEF_SENDLIST, IFEF_SENDLIST);
#if CONFIG_MACF_NET
mac_ifnet_label_init(ifp);
#endif
result = ifnet_attach(lo_ifp, NULL);
if (result != 0) {
panic("%s: couldn't attach loopback ifnet (%d)\n",
__func__, result);
}
bpfattach(lo_ifp, DLT_NULL, sizeof (u_int32_t));
}
static int
sysctl_dequeue_max SYSCTL_HANDLER_ARGS
{
#pragma unused(arg1, arg2)
u_int32_t i;
int err;
i = lo_dequeue_max;
err = sysctl_handle_int(oidp, &i, 0, req);
if (err != 0 || req->newptr == USER_ADDR_NULL)
return (err);
if (i < 1)
i = 1;
else if (i > LOSNDQ_MAXLEN)
i = LOSNDQ_MAXLEN;
lo_dequeue_max = i;
return (err);
}
static int
sysctl_sched_model SYSCTL_HANDLER_ARGS
{
#pragma unused(arg1, arg2)
u_int32_t i;
int err;
i = lo_sched_model;
err = sysctl_handle_int(oidp, &i, 0, req);
if (err != 0 || req->newptr == USER_ADDR_NULL)
return (err);
switch (i) {
case IFNET_SCHED_MODEL_NORMAL:
case IFNET_SCHED_MODEL_DRIVER_MANAGED:
break;
default:
err = EINVAL;
break;
}
if (err == 0 && (err = ifnet_set_output_sched_model(lo_ifp, i)) == 0)
lo_sched_model = i;
return (err);
}
static int
sysctl_dequeue_scidx SYSCTL_HANDLER_ARGS
{
#pragma unused(arg1, arg2)
u_int32_t i;
int err;
i = lo_dequeue_scidx;
err = sysctl_handle_int(oidp, &i, 0, req);
if (err != 0 || req->newptr == USER_ADDR_NULL)
return (err);
if (!MBUF_VALID_SCIDX(i))
return (EINVAL);
if (lo_sched_model != IFNET_SCHED_MODEL_DRIVER_MANAGED)
return (ENODEV);
lo_dequeue_sc = m_service_class_from_idx(i);
lo_dequeue_scidx = MBUF_SCIDX(lo_dequeue_sc);
return (err);
}