/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2010 Apple Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License"). You may not use this file except in compliance with the
- * License. Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
*
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
*
- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
/*
* Copyright (c) 1982, 1986, 1988, 1993
*
* @(#)ip_icmp.c 8.2 (Berkeley) 1/4/94
*/
+/*
+ * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
+ * support for mandatory and extensible security protections. This notice
+ * is included in support of clause 2.2 (b) of the Apple Public License,
+ * Version 2.0.
+ */
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/sysctl.h>
+#include <machine/endian.h>
+
#include <net/if.h>
#include <net/route.h>
#include <netinet/ip_icmp.h>
#include <netinet/ip_var.h>
#include <netinet/icmp_var.h>
+#include <netinet/tcp.h>
+#include <netinet/tcp_fsm.h>
+#include <netinet/tcp_seq.h>
+#include <netinet/tcp_timer.h>
+#include <netinet/tcp_var.h>
+#include <netinet/tcpip.h>
#if IPSEC
#include <netinet6/ipsec.h>
#include <net/if_types.h>
#endif
+ /* XXX This one should go in sys/mbuf.h. It is used to avoid that
+ * a firewall-generated packet loops forever through the firewall.
+ */
+#ifndef M_SKIP_FIREWALL
+#define M_SKIP_FIREWALL 0x4000
+#endif
+
+#if CONFIG_MACF_NET
+#include <security/mac_framework.h>
+#endif /* MAC_NET */
+
+
/*
* ICMP routines: error generation, receive packet processing, and
* routines to turnaround packets back to the originator, and
* host table maintenance routines.
*/
-static struct icmpstat icmpstat;
-SYSCTL_STRUCT(_net_inet_icmp, ICMPCTL_STATS, stats, CTLFLAG_RD,
+struct icmpstat icmpstat;
+SYSCTL_STRUCT(_net_inet_icmp, ICMPCTL_STATS, stats, CTLFLAG_RD | CTLFLAG_LOCKED,
&icmpstat, icmpstat, "");
static int icmpmaskrepl = 0;
-SYSCTL_INT(_net_inet_icmp, ICMPCTL_MASKREPL, maskrepl, CTLFLAG_RW,
+SYSCTL_INT(_net_inet_icmp, ICMPCTL_MASKREPL, maskrepl, CTLFLAG_RW | CTLFLAG_LOCKED,
&icmpmaskrepl, 0, "");
+static int icmptimestamp = 0;
+SYSCTL_INT(_net_inet_icmp, ICMPCTL_TIMESTAMP, timestamp, CTLFLAG_RW | CTLFLAG_LOCKED,
+ &icmptimestamp, 0, "");
+
+static int drop_redirect = 0;
+SYSCTL_INT(_net_inet_icmp, OID_AUTO, drop_redirect, CTLFLAG_RW | CTLFLAG_LOCKED,
+ &drop_redirect, 0, "");
+
+static int log_redirect = 0;
+SYSCTL_INT(_net_inet_icmp, OID_AUTO, log_redirect, CTLFLAG_RW | CTLFLAG_LOCKED,
+ &log_redirect, 0, "");
+
#if ICMP_BANDLIM
/*
* variable content is -1 and read-only.
*/
-static int icmplim = 100;
-SYSCTL_INT(_net_inet_icmp, ICMPCTL_ICMPLIM, icmplim, CTLFLAG_RW,
+static int icmplim = 250;
+SYSCTL_INT(_net_inet_icmp, ICMPCTL_ICMPLIM, icmplim, CTLFLAG_RW | CTLFLAG_LOCKED,
&icmplim, 0, "");
#else
static int icmplim = -1;
-SYSCTL_INT(_net_inet_icmp, ICMPCTL_ICMPLIM, icmplim, CTLFLAG_RD,
+SYSCTL_INT(_net_inet_icmp, ICMPCTL_ICMPLIM, icmplim, CTLFLAG_RD | CTLFLAG_LOCKED,
&icmplim, 0, "");
#endif
* ICMP broadcast echo sysctl
*/
-static int icmpbmcastecho = 0;
-SYSCTL_INT(_net_inet_icmp, OID_AUTO, bmcastecho, CTLFLAG_RW, &icmpbmcastecho,
- 0, "");
+static int icmpbmcastecho = 1;
+SYSCTL_INT(_net_inet_icmp, OID_AUTO, bmcastecho, CTLFLAG_RW | CTLFLAG_LOCKED,
+ &icmpbmcastecho, 0, "");
#if ICMPPRINTFS
int icmpprintfs = 0;
#endif
-static void icmp_reflect __P((struct mbuf *));
-static void icmp_send __P((struct mbuf *, struct mbuf *));
-int ip_next_mtu __P((int, int));
+static void icmp_reflect(struct mbuf *);
+static void icmp_send(struct mbuf *, struct mbuf *);
extern struct protosw inetsw[];
* in response to bad packet ip.
*/
void
-icmp_error(n, type, code, dest, destifp)
- struct mbuf *n;
- int type, code;
- n_long dest;
- struct ifnet *destifp;
+icmp_error(
+ struct mbuf *n,
+ int type,
+ int code,
+ n_long dest,
+ u_int32_t nextmtu)
{
- register struct ip *oip = mtod(n, struct ip *), *nip;
- register unsigned oiplen = IP_VHL_HL(oip->ip_vhl) << 2;
- register struct icmp *icp;
- register struct mbuf *m;
+ struct ip *oip = mtod(n, struct ip *), *nip;
+ unsigned oiplen = IP_VHL_HL(oip->ip_vhl) << 2;
+ struct icmp *icp;
+ struct mbuf *m;
unsigned icmplen;
#if ICMPPRINTFS
if (type != ICMP_REDIRECT)
icmpstat.icps_error++;
/*
- * Don't send error if the original packet was encrypted.
* Don't send error if not the first fragment of message.
* Don't error if the old packet protocol was ICMP
* error message, only known informational types.
*/
- if (n->m_flags & M_DECRYPTED)
- goto freeit;
if (oip->ip_off &~ (IP_MF|IP_DF))
goto freeit;
if (oip->ip_p == IPPROTO_ICMP && type != ICMP_REDIRECT &&
/*
* First, formulate icmp message
*/
- m = m_gethdr(M_DONTWAIT, MT_HEADER);
+ m = m_gethdr(M_DONTWAIT, MT_HEADER); /* MAC-OK */
if (m == NULL)
goto freeit;
- icmplen = oiplen + min(8, oip->ip_len);
+
+ if (n->m_flags & M_SKIP_FIREWALL) {
+ /* set M_SKIP_FIREWALL to skip firewall check, since we're called from firewall */
+ m->m_flags |= M_SKIP_FIREWALL;
+ }
+
+#if CONFIG_MACF_NET
+ mac_mbuf_label_associate_netlayer(n, m);
+#endif
+ icmplen = min(oiplen + 8, oip->ip_len);
+ if (icmplen < sizeof(struct ip)) {
+ printf("icmp_error: bad length\n");
+ m_free(m);
+ goto freeit;
+ }
m->m_len = icmplen + ICMP_MINLEN;
MH_ALIGN(m, m->m_len);
icp = mtod(m, struct icmp *);
icp->icmp_pptr = code;
code = 0;
} else if (type == ICMP_UNREACH &&
- code == ICMP_UNREACH_NEEDFRAG && destifp) {
- icp->icmp_nextmtu = htons(destifp->if_mtu);
+ code == ICMP_UNREACH_NEEDFRAG && nextmtu != 0) {
+ icp->icmp_nextmtu = htons(nextmtu);
}
}
icp->icmp_code = code;
- bcopy((caddr_t)oip, (caddr_t)&icp->icmp_ip, icmplen);
+ m_copydata(n, 0, icmplen, (caddr_t)&icp->icmp_ip);
nip = &icp->icmp_ip;
- nip->ip_len = htons((u_short)(nip->ip_len + oiplen));
+ /*
+ * Convert fields to network representation.
+ */
+#if BYTE_ORDER != BIG_ENDIAN
+ HTONS(nip->ip_len);
+ HTONS(nip->ip_off);
+#endif
/*
* Now, copy old ip header (without options)
* in front of icmp message.
m->m_len += sizeof(struct ip);
m->m_pkthdr.len = m->m_len;
m->m_pkthdr.rcvif = n->m_pkthdr.rcvif;
- m->m_pkthdr.aux = NULL; /* for IPsec */
nip = mtod(m, struct ip *);
bcopy((caddr_t)oip, (caddr_t)nip, sizeof(struct ip));
nip->ip_len = m->m_len;
m_freem(n);
}
-static struct sockaddr_in icmpsrc = { sizeof (struct sockaddr_in), AF_INET };
-static struct sockaddr_in icmpdst = { sizeof (struct sockaddr_in), AF_INET };
-static struct sockaddr_in icmpgw = { sizeof (struct sockaddr_in), AF_INET };
+static struct sockaddr_in icmpsrc = { sizeof (struct sockaddr_in), AF_INET,
+ 0 , { 0 }, { 0,0,0,0,0,0,0,0 } };
+static struct sockaddr_in icmpdst = { sizeof (struct sockaddr_in), AF_INET,
+ 0 , { 0 }, { 0,0,0,0,0,0,0,0 } };
+static struct sockaddr_in icmpgw = { sizeof (struct sockaddr_in), AF_INET,
+ 0 , { 0 }, { 0,0,0,0,0,0,0,0 } };
/*
* Process a received ICMP message.
*/
void
-icmp_input(m, hlen)
- register struct mbuf *m;
- int hlen;
+icmp_input(struct mbuf *m, int hlen)
{
- register struct icmp *icp;
- register struct ip *ip = mtod(m, struct ip *);
+ struct icmp *icp;
+ struct ip *ip = mtod(m, struct ip *);
int icmplen = ip->ip_len;
- register int i;
+ int i;
struct in_ifaddr *ia;
- void (*ctlfunc) __P((int, struct sockaddr *, void *));
+ void (*ctlfunc)(int, struct sockaddr *, void *);
int code;
/*
*/
#if ICMPPRINTFS
if (icmpprintfs) {
- char buf[4 * sizeof "123"];
- strcpy(buf, inet_ntoa(ip->ip_src));
+ char buf[MAX_IPv4_STR_LEN];
+ char ipv4str[MAX_IPv4_STR_LEN];
+
printf("icmp_input from %s to %s, len %d\n",
- buf, inet_ntoa(ip->ip_dst), icmplen);
+ inet_ntop(AF_INET, &ip->ip_src, buf, sizeof(buf)),
+ inet_ntop(AF_INET, &ip->ip_dst, ipv4str, sizeof(ipv4str)),
+ icmplen);
}
#endif
if (icmplen < ICMP_MINLEN) {
icp->icmp_code);
#endif
-#if IPSEC
- /* drop it if it does not match the policy */
- /* XXX Is there meaning of check in here ? */
- if (ipsec4_in_reject(m, NULL)) {
- ipsecstat.in_polvio++;
- goto freeit;
- }
-#endif
-
/*
* Message type specific processing.
*/
switch (code) {
case ICMP_UNREACH_NET:
case ICMP_UNREACH_HOST:
- case ICMP_UNREACH_PROTOCOL:
- case ICMP_UNREACH_PORT:
case ICMP_UNREACH_SRCFAIL:
- code += PRC_UNREACH_NET;
+ case ICMP_UNREACH_NET_UNKNOWN:
+ case ICMP_UNREACH_HOST_UNKNOWN:
+ case ICMP_UNREACH_ISOLATED:
+ case ICMP_UNREACH_TOSNET:
+ case ICMP_UNREACH_TOSHOST:
+ case ICMP_UNREACH_HOST_PRECEDENCE:
+ case ICMP_UNREACH_PRECEDENCE_CUTOFF:
+ code = PRC_UNREACH_NET;
break;
case ICMP_UNREACH_NEEDFRAG:
code = PRC_MSGSIZE;
break;
- case ICMP_UNREACH_NET_UNKNOWN:
- case ICMP_UNREACH_NET_PROHIB:
- case ICMP_UNREACH_TOSNET:
- code = PRC_UNREACH_NET;
+ /*
+ * RFC 1122, Sections 3.2.2.1 and 4.2.3.9.
+ * Treat subcodes 2,3 as immediate RST
+ */
+ case ICMP_UNREACH_PROTOCOL:
+ case ICMP_UNREACH_PORT:
+ code = PRC_UNREACH_PORT;
break;
- case ICMP_UNREACH_HOST_UNKNOWN:
- case ICMP_UNREACH_ISOLATED:
+ case ICMP_UNREACH_NET_PROHIB:
case ICMP_UNREACH_HOST_PROHIB:
- case ICMP_UNREACH_TOSHOST:
- code = PRC_UNREACH_HOST;
- break;
-
case ICMP_UNREACH_FILTER_PROHIB:
- case ICMP_UNREACH_HOST_PRECEDENCE:
- case ICMP_UNREACH_PRECEDENCE_CUTOFF:
- code = PRC_UNREACH_PORT;
+ code = PRC_UNREACH_ADMIN_PROHIB;
break;
default:
icmpstat.icps_badlen++;
goto freeit;
}
+
+#if BYTE_ORDER != BIG_ENDIAN
NTOHS(icp->icmp_ip.ip_len);
+#endif
+
/* Discard ICMP's in response to multicast packets */
if (IN_MULTICAST(ntohl(icp->icmp_ip.ip_dst.s_addr)))
goto badcode;
printf("deliver to protocol %d\n", icp->icmp_ip.ip_p);
#endif
icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
-#if 1
- /*
- * MTU discovery:
- * If we got a needfrag and there is a host route to the
- * original destination, and the MTU is not locked, then
- * set the MTU in the route to the suggested new value
- * (if given) and then notify as usual. The ULPs will
- * notice that the MTU has changed and adapt accordingly.
- * If no new MTU was suggested, then we guess a new one
- * less than the current value. If the new MTU is
- * unreasonably small (arbitrarily set at 296), then
- * we reset the MTU to the interface value and enable the
- * lock bit, indicating that we are no longer doing MTU
- * discovery.
- */
- if (code == PRC_MSGSIZE) {
- struct rtentry *rt;
- int mtu;
-
- rt = rtalloc1((struct sockaddr *)&icmpsrc, 0,
- RTF_CLONING | RTF_PRCLONING);
- if (rt && (rt->rt_flags & RTF_HOST)
- && !(rt->rt_rmx.rmx_locks & RTV_MTU)) {
- mtu = ntohs(icp->icmp_nextmtu);
- if (!mtu)
- mtu = ip_next_mtu(rt->rt_rmx.rmx_mtu,
- 1);
-#if DEBUG_MTUDISC
- printf("MTU for %s reduced to %d\n",
- inet_ntoa(icmpsrc.sin_addr), mtu);
-#endif
- if (mtu < 296) {
- /* rt->rt_rmx.rmx_mtu =
- rt->rt_ifp->if_mtu; */
- rt->rt_rmx.rmx_locks |= RTV_MTU;
- } else if (rt->rt_rmx.rmx_mtu > mtu) {
- rt->rt_rmx.rmx_mtu = mtu;
- }
- }
- if (rt)
- RTFREE(rt);
- }
-#endif
/*
* XXX if the packet contains [IPv4 AH TCP], we can't make a
* notification to TCP layer.
break;
}
icp->icmp_type = ICMP_ECHOREPLY;
- goto reflect;
+#if ICMP_BANDLIM
+ if (badport_bandlim(BANDLIM_ICMP_ECHO) < 0)
+ goto freeit;
+ else
+#endif
+ goto reflect;
case ICMP_TSTAMP:
+
+ if (icmptimestamp == 0)
+ break;
+
if (!icmpbmcastecho
&& (m->m_flags & (M_MCAST | M_BCAST)) != 0) {
icmpstat.icps_bmcasttstamp++;
icp->icmp_type = ICMP_TSTAMPREPLY;
icp->icmp_rtime = iptime();
icp->icmp_ttime = icp->icmp_rtime; /* bogus, do later! */
- goto reflect;
+#if ICMP_BANDLIM
+ if (badport_bandlim(BANDLIM_ICMP_TSTAMP) < 0)
+ goto freeit;
+ else
+#endif
+ goto reflect;
case ICMP_MASKREQ:
#define satosin(sa) ((struct sockaddr_in *)(sa))
(struct sockaddr *)&icmpdst, m->m_pkthdr.rcvif);
if (ia == 0)
break;
- if (ia->ia_ifp == 0)
+ IFA_LOCK(&ia->ia_ifa);
+ if (ia->ia_ifp == 0) {
+ IFA_UNLOCK(&ia->ia_ifa);
+ IFA_REMREF(&ia->ia_ifa);
+ ia = NULL;
break;
+ }
icp->icmp_type = ICMP_MASKREPLY;
icp->icmp_mask = ia->ia_sockmask.sin_addr.s_addr;
if (ip->ip_src.s_addr == 0) {
else if (ia->ia_ifp->if_flags & IFF_POINTOPOINT)
ip->ip_src = satosin(&ia->ia_dstaddr)->sin_addr;
}
+ IFA_UNLOCK(&ia->ia_ifa);
+ IFA_REMREF(&ia->ia_ifa);
reflect:
ip->ip_len += hlen; /* since ip_input deducts this */
icmpstat.icps_reflect++;
return;
case ICMP_REDIRECT:
+ if (log_redirect) {
+ u_int32_t src, dst, gw;
+
+ src = ntohl(ip->ip_src.s_addr);
+ dst = ntohl(icp->icmp_ip.ip_dst.s_addr);
+ gw = ntohl(icp->icmp_gwaddr.s_addr);
+ printf("icmp redirect from %d.%d.%d.%d: "
+ "%d.%d.%d.%d => %d.%d.%d.%d\n",
+ (int)(src >> 24), (int)((src >> 16) & 0xff),
+ (int)((src >> 8) & 0xff), (int)(src & 0xff),
+ (int)(dst >> 24), (int)((dst >> 16) & 0xff),
+ (int)((dst >> 8) & 0xff), (int)(dst & 0xff),
+ (int)(gw >> 24), (int)((gw >> 16) & 0xff),
+ (int)((gw >> 8) & 0xff), (int)(gw & 0xff));
+ }
+ if (drop_redirect)
+ break;
if (code > 3)
goto badcode;
if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp) ||
icmpdst.sin_addr = icp->icmp_gwaddr;
#if ICMPPRINTFS
if (icmpprintfs) {
- char buf[4 * sizeof "123"];
- strcpy(buf, inet_ntoa(icp->icmp_ip.ip_dst));
+ char buf[MAX_IPv4_STR_LEN];
printf("redirect dst %s to %s\n",
- buf, inet_ntoa(icp->icmp_gwaddr));
+ inet_ntop(AF_INET, &icp->icmp_ip.ip_dst, buf, sizeof(buf)),
+ inet_ntop(AF_INET, &icp->icmp_gwaddr, ipv4str,
+ sizeof(ipv4str)));
}
#endif
icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
- rtredirect((struct sockaddr *)&icmpsrc,
- (struct sockaddr *)&icmpdst,
- (struct sockaddr *)0, RTF_GATEWAY | RTF_HOST,
- (struct sockaddr *)&icmpgw, (struct rtentry **)0);
+ rtredirect(m->m_pkthdr.rcvif, (struct sockaddr *)&icmpsrc,
+ (struct sockaddr *)&icmpdst, NULL, RTF_GATEWAY | RTF_HOST,
+ (struct sockaddr *)&icmpgw, NULL);
pfctlinput(PRC_REDIRECT_HOST, (struct sockaddr *)&icmpsrc);
#if IPSEC
key_sa_routechange((struct sockaddr *)&icmpsrc);
* Reflect the ip packet back to the source
*/
static void
-icmp_reflect(m)
- struct mbuf *m;
+icmp_reflect(struct mbuf *m)
{
- register struct ip *ip = mtod(m, struct ip *);
- register struct in_ifaddr *ia;
+ struct ip *ip = mtod(m, struct ip *);
+ struct in_ifaddr *ia;
struct in_addr t;
- struct mbuf *opts = 0;
+ struct mbuf *opts = NULL;
int optlen = (IP_VHL_HL(ip->ip_vhl) << 2) - sizeof(struct ip);
if (!in_canforward(ip->ip_src) &&
* or anonymous), use the address which corresponds
* to the incoming interface.
*/
+ lck_rw_lock_shared(in_ifaddr_rwlock);
+ TAILQ_FOREACH(ia, INADDR_HASH(t.s_addr), ia_hash) {
+ IFA_LOCK(&ia->ia_ifa);
+ if (t.s_addr == IA_SIN(ia)->sin_addr.s_addr) {
+ IFA_ADDREF_LOCKED(&ia->ia_ifa);
+ IFA_UNLOCK(&ia->ia_ifa);
+ goto match;
+ }
+ IFA_UNLOCK(&ia->ia_ifa);
+ }
+ /*
+ * Slow path; check for broadcast addresses. Find a source
+ * IP address to use when replying to the broadcast request;
+ * let IP handle the source interface selection work.
+ */
for (ia = in_ifaddrhead.tqh_first; ia; ia = ia->ia_link.tqe_next) {
- if (t.s_addr == IA_SIN(ia)->sin_addr.s_addr)
- break;
+ IFA_LOCK(&ia->ia_ifa);
if (ia->ia_ifp && (ia->ia_ifp->if_flags & IFF_BROADCAST) &&
- t.s_addr == satosin(&ia->ia_broadaddr)->sin_addr.s_addr)
+ t.s_addr == satosin(&ia->ia_broadaddr)->sin_addr.s_addr) {
+ IFA_ADDREF_LOCKED(&ia->ia_ifa);
+ IFA_UNLOCK(&ia->ia_ifa);
break;
+ }
+ IFA_UNLOCK(&ia->ia_ifa);
}
+match:
+ lck_rw_done(in_ifaddr_rwlock);
icmpdst.sin_addr = t;
if ((ia == (struct in_ifaddr *)0) && m->m_pkthdr.rcvif)
ia = (struct in_ifaddr *)ifaof_ifpforaddr(
* The following happens if the packet was not addressed to us,
* and was received on an interface with no IP address.
*/
- if (ia == (struct in_ifaddr *)0)
+ if (ia == (struct in_ifaddr *)0) {
+ lck_rw_lock_shared(in_ifaddr_rwlock);
ia = in_ifaddrhead.tqh_first;
+ if (ia == (struct in_ifaddr *)0) {/* no address yet, bail out */
+ lck_rw_done(in_ifaddr_rwlock);
+ m_freem(m);
+ goto done;
+ }
+ IFA_ADDREF(&ia->ia_ifa);
+ lck_rw_done(in_ifaddr_rwlock);
+ }
+#if CONFIG_MACF_NET
+ mac_netinet_icmp_reply(m);
+#endif
+ IFA_LOCK_SPIN(&ia->ia_ifa);
t = IA_SIN(ia)->sin_addr;
+ IFA_UNLOCK(&ia->ia_ifa);
ip->ip_src = t;
- ip->ip_ttl = MAXTTL;
+ ip->ip_ttl = ip_defttl;
+ IFA_REMREF(&ia->ia_ifa);
+ ia = NULL;
if (optlen > 0) {
- register u_char *cp;
+ u_char *cp;
int opt, cnt;
u_int len;
*/
cp = (u_char *) (ip + 1);
if ((opts = ip_srcroute()) == 0 &&
- (opts = m_gethdr(M_DONTWAIT, MT_HEADER))) {
+ (opts = m_gethdr(M_DONTWAIT, MT_HEADER))) { /* MAC-OK */
opts->m_len = sizeof(struct in_addr);
mtod(opts, struct in_addr *)->s_addr = 0;
}
break;
len = cp[IPOPT_OLEN];
if (len < IPOPT_OLEN + sizeof(*cp) ||
- len > cnt)
+ len > cnt)
break;
}
/*
* after supplying a checksum.
*/
static void
-icmp_send(m, opts)
- register struct mbuf *m;
- struct mbuf *opts;
+icmp_send(struct mbuf *m, struct mbuf *opts)
{
- register struct ip *ip = mtod(m, struct ip *);
- register int hlen;
- register struct icmp *icp;
+ struct ip *ip = mtod(m, struct ip *);
+ int hlen;
+ struct icmp *icp;
struct route ro;
+ struct ip_out_args ipoa = { IFSCOPE_NONE, 0 };
+
+ if ((m->m_flags & M_PKTHDR) && m->m_pkthdr.rcvif != NULL)
+ ipoa.ipoa_boundif = m->m_pkthdr.rcvif->if_index;
hlen = IP_VHL_HL(ip->ip_vhl) << 2;
m->m_data += hlen;
icp->icmp_cksum = in_cksum(m, ip->ip_len - hlen);
m->m_data -= hlen;
m->m_len += hlen;
- m->m_pkthdr.rcvif = (struct ifnet *)0;
- m->m_pkthdr.aux = NULL;
+ m->m_pkthdr.rcvif = NULL;
m->m_pkthdr.csum_data = 0;
m->m_pkthdr.csum_flags = 0;
#if ICMPPRINTFS
if (icmpprintfs) {
- char buf[4 * sizeof "123"];
- strcpy(buf, inet_ntoa(ip->ip_dst));
+ char buf[MAX_IPv4_STR_LEN];
+ char ipv4str[MAX_IPv4_STR_LEN];
+
printf("icmp_send dst %s src %s\n",
- buf, inet_ntoa(ip->ip_src));
+ inet_ntop(AF_INET, &ip->ip_dst, buf, sizeof(buf)),
+ inet_ntop(AF_INET, &ip->ip_src, ipv4str, sizeof(ipv4str)));
}
#endif
bzero(&ro, sizeof ro);
-
-#ifdef IPSEC
- ipsec_setsocket(m, NULL);
-#endif /*IPSEC*/
- (void) ip_output(m, opts, &ro, 0, NULL);
+ (void) ip_output(m, opts, &ro, IP_OUTARGS, NULL, &ipoa);
if (ro.ro_rt)
- RTFREE(ro.ro_rt);
+ rtfree(ro.ro_rt);
}
n_time
-iptime()
+iptime(void)
{
struct timeval atv;
- u_long t;
+ u_int32_t t;
microtime(&atv);
t = (atv.tv_sec % (24*60*60)) * 1000 + atv.tv_usec / 1000;
* given current value MTU. If DIR is less than zero, a larger plateau
* is returned; otherwise, a smaller value is returned.
*/
-/* static */ int
-ip_next_mtu(mtu, dir)
- int mtu;
- int dir;
+int
+ip_next_mtu(int mtu, int dir)
{
static int mtutab[] = {
65535, 32000, 17914, 8166, 4352, 2002, 1492, 1006, 508, 296,
int
badport_bandlim(int which)
{
- static int lticks[2];
- static int lpackets[2];
- int dticks;
+ static struct timeval lticks[BANDLIM_MAX + 1];
+ static int lpackets[BANDLIM_MAX + 1];
+ struct timeval time;
+ int secs;
+
+ const char *bandlimittype[] = {
+ "Limiting icmp unreach response",
+ "Limiting icmp ping response",
+ "Limiting icmp tstamp response",
+ "Limiting closed port RST response",
+ "Limiting open port RST response"
+ };
/*
* Return ok status if feature disabled or argument out of
* ranage.
*/
- if (icmplim <= 0 || which >= 2 || which < 0)
+ if (icmplim <= 0 || which > BANDLIM_MAX || which < 0)
return(0);
- dticks = ticks - lticks[which];
+ getmicrouptime(&time);
+
+ secs = time.tv_sec - lticks[which].tv_sec ;
+
/*
- * reset stats when cumulative dt exceeds one second.
+ * reset stats when cumulative delta exceeds one second.
*/
- if ((unsigned int)dticks > hz) {
+ if ((secs > 1) || (secs == 1 && (lticks[which].tv_usec > time.tv_usec))) {
if (lpackets[which] > icmplim) {
- printf("icmp-response bandwidth limit %d/%d pps\n",
+ printf("%s from %d to %d packets per second\n",
+ bandlimittype[which],
lpackets[which],
icmplim
);
}
- lticks[which] = ticks;
+ lticks[which].tv_sec = time.tv_sec;
+ lticks[which].tv_usec = time.tv_usec;
lpackets[which] = 0;
}
#endif
+#if __APPLE__
+
+/*
+ * Non-privileged ICMP socket operations
+ * - send ICMP echo request
+ * - all ICMP
+ * - limited socket options
+ */
+
+#include <netinet/ip_icmp.h>
+#include <netinet/in_pcb.h>
+
+extern struct domain inetdomain;
+extern u_int32_t rip_sendspace;
+extern u_int32_t rip_recvspace;
+extern struct inpcbinfo ripcbinfo;
+
+int rip_abort(struct socket *);
+int rip_bind(struct socket *, struct sockaddr *, struct proc *);
+int rip_connect(struct socket *, struct sockaddr *, struct proc *);
+int rip_detach(struct socket *);
+int rip_disconnect(struct socket *);
+int rip_shutdown(struct socket *);
+
+__private_extern__ int icmp_dgram_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, struct mbuf *control, struct proc *p);
+__private_extern__ int icmp_dgram_attach(struct socket *so, int proto, struct proc *p);
+__private_extern__ int icmp_dgram_ctloutput(struct socket *so, struct sockopt *sopt);
+
+__private_extern__ struct pr_usrreqs icmp_dgram_usrreqs = {
+ rip_abort, pru_accept_notsupp, icmp_dgram_attach, rip_bind, rip_connect,
+ pru_connect2_notsupp, in_control, rip_detach, rip_disconnect,
+ pru_listen_notsupp, in_setpeeraddr, pru_rcvd_notsupp,
+ pru_rcvoob_notsupp, icmp_dgram_send, pru_sense_null, rip_shutdown,
+ in_setsockaddr, sosend, soreceive, pru_sopoll_notsupp
+};
+
+/* Like rip_attach but without root privilege enforcement */
+__private_extern__ int
+icmp_dgram_attach(struct socket *so, __unused int proto, struct proc *p)
+{
+ struct inpcb *inp;
+ int error;
+
+ inp = sotoinpcb(so);
+ if (inp)
+ panic("icmp_dgram_attach");
+
+ error = soreserve(so, rip_sendspace, rip_recvspace);
+ if (error)
+ return error;
+ error = in_pcballoc(so, &ripcbinfo, p);
+ if (error)
+ return error;
+ inp = (struct inpcb *)so->so_pcb;
+ inp->inp_vflag |= INP_IPV4;
+ inp->inp_ip_p = IPPROTO_ICMP;
+ inp->inp_ip_ttl = ip_defttl;
+ return 0;
+}
+
+/*
+ * Raw IP socket option processing.
+ */
+__private_extern__ int
+icmp_dgram_ctloutput(struct socket *so, struct sockopt *sopt)
+{
+ int error;
+
+ if (sopt->sopt_level != IPPROTO_IP)
+ return (EINVAL);
+
+ switch (sopt->sopt_name) {
+ case IP_OPTIONS:
+ case IP_HDRINCL:
+ case IP_TOS:
+ case IP_TTL:
+ case IP_RECVOPTS:
+ case IP_RECVRETOPTS:
+ case IP_RECVDSTADDR:
+ case IP_RETOPTS:
+ case IP_MULTICAST_IF:
+ case IP_MULTICAST_IFINDEX:
+ case IP_MULTICAST_TTL:
+ case IP_MULTICAST_LOOP:
+ case IP_ADD_MEMBERSHIP:
+ case IP_DROP_MEMBERSHIP:
+ case IP_MULTICAST_VIF:
+ case IP_PORTRANGE:
+ case IP_RECVIF:
+ case IP_IPSEC_POLICY:
+#if defined(NFAITH) && NFAITH > 0
+ case IP_FAITH:
+#endif
+ case IP_STRIPHDR:
+ case IP_RECVTTL:
+ case IP_BOUND_IF:
+#if CONFIG_FORCE_OUT_IFP
+ case IP_FORCE_OUT_IFP:
+#endif
+ case IP_NO_IFT_CELLULAR:
+ error = rip_ctloutput(so, sopt);
+ break;
+
+ default:
+ error = EINVAL;
+ break;
+ }
+
+ return (error);
+}
+
+__private_extern__ int
+icmp_dgram_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
+ struct mbuf *control, struct proc *p)
+{
+ struct ip *ip;
+ struct inpcb *inp = sotoinpcb(so);
+ int hlen;
+ struct icmp *icp;
+ struct in_ifaddr *ia = NULL;
+ int icmplen;
+
+ if ((inp->inp_flags & INP_HDRINCL) != 0) {
+ /*
+ * This is not raw IP, we liberal only for fields TOS, id and TTL
+ */
+ ip = mtod(m, struct ip *);
+
+ hlen = IP_VHL_HL(ip->ip_vhl) << 2;
+ /* Some sanity checks */
+ if (m->m_pkthdr.len < hlen + ICMP_MINLEN) {
+ goto bad;
+ }
+ /* Only IPv4 */
+ if (IP_VHL_V(ip->ip_vhl) != 4)
+ goto bad;
+ if (hlen < 20 || hlen > 40 || ip->ip_len != m->m_pkthdr.len)
+ goto bad;
+ /* Bogus fragments can tie up peer resources */
+ if ((ip->ip_off & ~IP_DF) != 0)
+ goto bad;
+ /* Allow only ICMP even for user provided IP header */
+ if (ip->ip_p != IPPROTO_ICMP)
+ goto bad;
+ /* To prevent spoofing, specified source address must be one of ours */
+ if (ip->ip_src.s_addr != INADDR_ANY) {
+ socket_unlock(so, 0);
+ lck_rw_lock_shared(in_ifaddr_rwlock);
+ if (TAILQ_EMPTY(&in_ifaddrhead)) {
+ lck_rw_done(in_ifaddr_rwlock);
+ socket_lock(so, 0);
+ goto bad;
+ }
+ TAILQ_FOREACH(ia, INADDR_HASH(ip->ip_src.s_addr),
+ ia_hash) {
+ IFA_LOCK(&ia->ia_ifa);
+ if (IA_SIN(ia)->sin_addr.s_addr ==
+ ip->ip_src.s_addr) {
+ IFA_UNLOCK(&ia->ia_ifa);
+ lck_rw_done(in_ifaddr_rwlock);
+ socket_lock(so, 0);
+ goto ours;
+ }
+ IFA_UNLOCK(&ia->ia_ifa);
+ }
+ lck_rw_done(in_ifaddr_rwlock);
+ socket_lock(so, 0);
+ goto bad;
+ }
+ours:
+ /* Do not trust we got a valid checksum */
+ ip->ip_sum = 0;
+
+ icp = (struct icmp *)(((char *)m->m_data) + hlen);
+ icmplen = m->m_pkthdr.len - hlen;
+ } else {
+ if ((icmplen = m->m_pkthdr.len) < ICMP_MINLEN) {
+ goto bad;
+ }
+ icp = mtod(m, struct icmp *);
+ }
+ /*
+ * Allow only to send request types with code 0
+ */
+ if (icp->icmp_code != 0)
+ goto bad;
+ switch (icp->icmp_type) {
+ case ICMP_ECHO:
+ break;
+ case ICMP_TSTAMP:
+ if (icmplen != 20)
+ goto bad;
+ break;
+ case ICMP_MASKREQ:
+ if (icmplen != 12)
+ goto bad;
+ break;
+ default:
+ goto bad;
+ }
+ return rip_send(so, flags, m, nam, control, p);
+bad:
+ m_freem(m);
+ return EINVAL;
+}
+#endif /* __APPLE__ */
projects / apple / xnu.git / blobdiff