version 1.77, 1999/01/11 22:35:06 |
version 1.101, 2000/02/17 10:59:35 |
|
|
/* $NetBSD$ */ |
/* $NetBSD$ */ |
|
|
|
/* |
|
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. |
|
* All rights reserved. |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions |
|
* are met: |
|
* 1. Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* 2. Redistributions in binary form must reproduce the above copyright |
|
* notice, this list of conditions and the following disclaimer in the |
|
* documentation and/or other materials provided with the distribution. |
|
* 3. Neither the name of the project nor the names of its contributors |
|
* may be used to endorse or promote products derived from this software |
|
* without specific prior written permission. |
|
* |
|
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND |
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE |
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|
* SUCH DAMAGE. |
|
*/ |
|
|
/*- |
/*- |
* Copyright (c) 1998 The NetBSD Foundation, Inc. |
* Copyright (c) 1998 The NetBSD Foundation, Inc. |
* All rights reserved. |
* All rights reserved. |
|
|
|
|
#include "opt_gateway.h" |
#include "opt_gateway.h" |
#include "opt_pfil_hooks.h" |
#include "opt_pfil_hooks.h" |
|
#include "opt_ipsec.h" |
#include "opt_mrouting.h" |
#include "opt_mrouting.h" |
|
|
#include <sys/param.h> |
#include <sys/param.h> |
|
|
#include <netinet/in_var.h> |
#include <netinet/in_var.h> |
#include <netinet/ip_var.h> |
#include <netinet/ip_var.h> |
#include <netinet/ip_icmp.h> |
#include <netinet/ip_icmp.h> |
|
/* just for gif_ttl */ |
|
#include <netinet/in_gif.h> |
|
#include "gif.h" |
|
|
|
#ifdef IPSEC |
|
#include <netinet6/ipsec.h> |
|
#include <netkey/key.h> |
|
#include <netkey/key_debug.h> |
|
#endif |
|
|
#ifndef IPFORWARDING |
#ifndef IPFORWARDING |
#ifdef GATEWAY |
#ifdef GATEWAY |
Line 155 int ipprintfs = 0; |
|
Line 194 int ipprintfs = 0; |
|
struct rttimer_queue *ip_mtudisc_timeout_q = NULL; |
struct rttimer_queue *ip_mtudisc_timeout_q = NULL; |
|
|
extern struct domain inetdomain; |
extern struct domain inetdomain; |
extern struct protosw inetsw[]; |
|
u_char ip_protox[IPPROTO_MAX]; |
|
int ipqmaxlen = IFQ_MAXLEN; |
int ipqmaxlen = IFQ_MAXLEN; |
struct in_ifaddrhead in_ifaddr; |
struct in_ifaddrhead in_ifaddr; |
struct in_ifaddrhashhead *in_ifaddrhashtbl; |
struct in_ifaddrhashhead *in_ifaddrhashtbl; |
Line 278 struct sockaddr_in ipaddr = { sizeof(ipa |
|
Line 315 struct sockaddr_in ipaddr = { sizeof(ipa |
|
struct route ipforward_rt; |
struct route ipforward_rt; |
|
|
/* |
/* |
|
* IP software interrupt routine |
|
*/ |
|
void |
|
ipintr() |
|
{ |
|
int s; |
|
struct mbuf *m; |
|
|
|
while (1) { |
|
s = splimp(); |
|
IF_DEQUEUE(&ipintrq, m); |
|
splx(s); |
|
if (m == 0) |
|
return; |
|
ip_input(m); |
|
} |
|
} |
|
|
|
/* |
* Ip input routine. Checksum and byte swap header. If fragmented |
* Ip input routine. Checksum and byte swap header. If fragmented |
* try to reassemble. Process options. Pass to next level. |
* try to reassemble. Process options. Pass to next level. |
*/ |
*/ |
void |
void |
ipintr() |
ip_input(struct mbuf *m) |
{ |
{ |
register struct ip *ip = NULL; |
register struct ip *ip = NULL; |
register struct mbuf *m; |
|
register struct ipq *fp; |
register struct ipq *fp; |
register struct in_ifaddr *ia; |
register struct in_ifaddr *ia; |
register struct ifaddr *ifa; |
register struct ifaddr *ifa; |
struct ipqent *ipqe; |
struct ipqent *ipqe; |
int hlen = 0, mff, len, s; |
int hlen = 0, mff, len; |
|
int downmatch; |
#ifdef PFIL_HOOKS |
#ifdef PFIL_HOOKS |
struct packet_filter_hook *pfh; |
struct packet_filter_hook *pfh; |
struct mbuf *m0; |
struct mbuf *m0; |
int rv; |
int rv; |
#endif /* PFIL_HOOKS */ |
#endif /* PFIL_HOOKS */ |
|
|
next: |
|
/* |
|
* Get next datagram off input queue and get IP header |
|
* in first mbuf. |
|
*/ |
|
s = splimp(); |
|
IF_DEQUEUE(&ipintrq, m); |
|
splx(s); |
|
if (m == 0) |
|
return; |
|
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
if ((m->m_flags & M_PKTHDR) == 0) |
if ((m->m_flags & M_PKTHDR) == 0) |
panic("ipintr no HDR"); |
panic("ipintr no HDR"); |
#endif |
#endif |
|
#ifdef IPSEC |
|
/* |
|
* should the inner packet be considered authentic? |
|
* see comment in ah4_input(). |
|
*/ |
|
if (m) { |
|
m->m_flags &= ~M_AUTHIPHDR; |
|
m->m_flags &= ~M_AUTHIPDGM; |
|
} |
|
#endif |
/* |
/* |
* If no IP addresses have been set yet but the interfaces |
* If no IP addresses have been set yet but the interfaces |
* are receiving, can't do anything with incoming packets yet. |
* are receiving, can't do anything with incoming packets yet. |
|
|
if (m->m_len < sizeof (struct ip) && |
if (m->m_len < sizeof (struct ip) && |
(m = m_pullup(m, sizeof (struct ip))) == 0) { |
(m = m_pullup(m, sizeof (struct ip))) == 0) { |
ipstat.ips_toosmall++; |
ipstat.ips_toosmall++; |
goto next; |
return; |
} |
} |
ip = mtod(m, struct ip *); |
ip = mtod(m, struct ip *); |
if (ip->ip_v != IPVERSION) { |
if (ip->ip_v != IPVERSION) { |
|
|
if (hlen > m->m_len) { |
if (hlen > m->m_len) { |
if ((m = m_pullup(m, hlen)) == 0) { |
if ((m = m_pullup(m, hlen)) == 0) { |
ipstat.ips_badhlen++; |
ipstat.ips_badhlen++; |
goto next; |
return; |
} |
} |
ip = mtod(m, struct ip *); |
ip = mtod(m, struct ip *); |
} |
} |
if ((ip->ip_sum = in_cksum(m, hlen)) != 0) { |
|
|
/* |
|
* RFC1122: packets with a multicast source address are |
|
* not allowed. |
|
*/ |
|
if (IN_MULTICAST(ip->ip_src.s_addr)) { |
|
/* XXX stat */ |
|
goto bad; |
|
} |
|
|
|
if (in_cksum(m, hlen) != 0) { |
ipstat.ips_badsum++; |
ipstat.ips_badsum++; |
goto bad; |
goto bad; |
} |
} |
|
|
* Convert fields to host representation. |
* Convert fields to host representation. |
*/ |
*/ |
NTOHS(ip->ip_len); |
NTOHS(ip->ip_len); |
NTOHS(ip->ip_id); |
|
NTOHS(ip->ip_off); |
NTOHS(ip->ip_off); |
len = ip->ip_len; |
len = ip->ip_len; |
|
|
/* |
/* |
|
* Check for additional length bogosity |
|
*/ |
|
if (len < hlen) { |
|
ipstat.ips_badlen++; |
|
goto bad; |
|
} |
|
|
|
/* |
* Check that the amount of data in the buffers |
* Check that the amount of data in the buffers |
* is as at least much as the IP header would have us expect. |
* is as at least much as the IP header would have us expect. |
* Trim mbufs if longer than we expect. |
* Trim mbufs if longer than we expect. |
|
|
m_adj(m, len - m->m_pkthdr.len); |
m_adj(m, len - m->m_pkthdr.len); |
} |
} |
|
|
|
#ifdef IPSEC |
|
/* ipflow (IP fast fowarding) is not compatible with IPsec. */ |
|
m->m_flags &= ~M_CANFASTFWD; |
|
#else |
/* |
/* |
* Assume that we can create a fast-forward IP flow entry |
* Assume that we can create a fast-forward IP flow entry |
* based on this packet. |
* based on this packet. |
*/ |
*/ |
m->m_flags |= M_CANFASTFWD; |
m->m_flags |= M_CANFASTFWD; |
|
#endif |
|
|
#ifdef PFIL_HOOKS |
#ifdef PFIL_HOOKS |
/* |
/* |
|
|
* in the list may have previously cleared it. |
* in the list may have previously cleared it. |
*/ |
*/ |
m0 = m; |
m0 = m; |
for (pfh = pfil_hook_get(PFIL_IN); pfh; pfh = pfh->pfil_link.tqe_next) |
pfh = pfil_hook_get(PFIL_IN, &inetsw[ip_protox[IPPROTO_IP]]); |
|
for (; pfh; pfh = pfh->pfil_link.tqe_next) |
if (pfh->pfil_func) { |
if (pfh->pfil_func) { |
rv = pfh->pfil_func(ip, hlen, m->m_pkthdr.rcvif, 0, &m0); |
rv = pfh->pfil_func(ip, hlen, |
|
m->m_pkthdr.rcvif, 0, &m0); |
if (rv) |
if (rv) |
goto next; |
return; |
m = m0; |
m = m0; |
if (m == NULL) |
if (m == NULL) |
goto next; |
return; |
ip = mtod(m, struct ip *); |
ip = mtod(m, struct ip *); |
} |
} |
#endif /* PFIL_HOOKS */ |
#endif /* PFIL_HOOKS */ |
|
|
*/ |
*/ |
ip_nhops = 0; /* for source routed packets */ |
ip_nhops = 0; /* for source routed packets */ |
if (hlen > sizeof (struct ip) && ip_dooptions(m)) |
if (hlen > sizeof (struct ip) && ip_dooptions(m)) |
goto next; |
return; |
|
|
/* |
/* |
* Check our list of addresses, to see if the packet is for us. |
* Check our list of addresses, to see if the packet is for us. |
*/ |
* |
INADDR_TO_IA(ip->ip_dst, ia); |
* Traditional 4.4BSD did not consult IFF_UP at all. |
if (ia != NULL) goto ours; |
* The behavior here is to treat addresses on !IFF_UP interface |
|
* as not mine. |
|
*/ |
|
downmatch = 0; |
|
for (ia = IN_IFADDR_HASH(ip->ip_dst.s_addr).lh_first; |
|
ia != NULL; |
|
ia = ia->ia_hash.le_next) { |
|
if (in_hosteq(ia->ia_addr.sin_addr, ip->ip_dst)) { |
|
if ((ia->ia_ifp->if_flags & IFF_UP) != 0) |
|
break; |
|
else |
|
downmatch++; |
|
} |
|
} |
|
if (ia != NULL) |
|
goto ours; |
if (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST) { |
if (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST) { |
for (ifa = m->m_pkthdr.rcvif->if_addrlist.tqh_first; |
for (ifa = m->m_pkthdr.rcvif->if_addrlist.tqh_first; |
ifa != NULL; ifa = ifa->ifa_list.tqe_next) { |
ifa != NULL; ifa = ifa->ifa_list.tqe_next) { |
|
|
if (m->m_flags & M_EXT) { |
if (m->m_flags & M_EXT) { |
if ((m = m_pullup(m, hlen)) == 0) { |
if ((m = m_pullup(m, hlen)) == 0) { |
ipstat.ips_toosmall++; |
ipstat.ips_toosmall++; |
goto next; |
return; |
} |
} |
ip = mtod(m, struct ip *); |
ip = mtod(m, struct ip *); |
} |
} |
|
|
* as expected when ip_mforward() is called from |
* as expected when ip_mforward() is called from |
* ip_output().) |
* ip_output().) |
*/ |
*/ |
ip->ip_id = htons(ip->ip_id); |
|
if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) { |
if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) { |
ipstat.ips_cantforward++; |
ipstat.ips_cantforward++; |
m_freem(m); |
m_freem(m); |
goto next; |
return; |
} |
} |
ip->ip_id = ntohs(ip->ip_id); |
|
|
|
/* |
/* |
* The process-level routing demon needs to receive |
* The process-level routing demon needs to receive |
|
|
if (inm == NULL) { |
if (inm == NULL) { |
ipstat.ips_cantforward++; |
ipstat.ips_cantforward++; |
m_freem(m); |
m_freem(m); |
goto next; |
return; |
} |
} |
goto ours; |
goto ours; |
} |
} |
|
|
if (ipforwarding == 0) { |
if (ipforwarding == 0) { |
ipstat.ips_cantforward++; |
ipstat.ips_cantforward++; |
m_freem(m); |
m_freem(m); |
} else |
} else { |
|
/* |
|
* If ip_dst matched any of my address on !IFF_UP interface, |
|
* and there's no IFF_UP interface that matches ip_dst, |
|
* send icmp unreach. Forwarding it will result in in-kernel |
|
* forwarding loop till TTL goes to 0. |
|
*/ |
|
if (downmatch) { |
|
icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0); |
|
ipstat.ips_cantforward++; |
|
return; |
|
} |
ip_forward(m, 0); |
ip_forward(m, 0); |
goto next; |
} |
|
return; |
|
|
ours: |
ours: |
/* |
/* |
|
|
m = ip_reass(ipqe, fp); |
m = ip_reass(ipqe, fp); |
if (m == 0) { |
if (m == 0) { |
IPQ_UNLOCK(); |
IPQ_UNLOCK(); |
goto next; |
return; |
} |
} |
ipstat.ips_reassembled++; |
ipstat.ips_reassembled++; |
ip = mtod(m, struct ip *); |
ip = mtod(m, struct ip *); |
hlen = ip->ip_hl << 2; |
hlen = ip->ip_hl << 2; |
|
ip->ip_len += hlen; |
} else |
} else |
if (fp) |
if (fp) |
ip_freef(fp); |
ip_freef(fp); |
IPQ_UNLOCK(); |
IPQ_UNLOCK(); |
} else |
} |
ip->ip_len -= hlen; |
|
|
|
/* |
/* |
* Switch out to protocol's input routine. |
* Switch out to protocol's input routine. |
*/ |
*/ |
|
#if IFA_STATS |
|
ia->ia_ifa.ifa_data.ifad_inbytes += ip->ip_len; |
|
#endif |
ipstat.ips_delivered++; |
ipstat.ips_delivered++; |
(*inetsw[ip_protox[ip->ip_p]].pr_input)(m, hlen); |
{ |
goto next; |
int off = hlen, nh = ip->ip_p; |
|
|
|
(*inetsw[ip_protox[nh]].pr_input)(m, off, nh); |
|
return; |
|
} |
bad: |
bad: |
m_freem(m); |
m_freem(m); |
goto next; |
|
} |
} |
|
|
/* |
/* |
|
|
* Make header visible. |
* Make header visible. |
*/ |
*/ |
ip->ip_len = next; |
ip->ip_len = next; |
|
ip->ip_ttl = 0; /* xxx */ |
|
ip->ip_sum = 0; |
ip->ip_src = fp->ipq_src; |
ip->ip_src = fp->ipq_src; |
ip->ip_dst = fp->ipq_dst; |
ip->ip_dst = fp->ipq_dst; |
LIST_REMOVE(fp, ipq_q); |
LIST_REMOVE(fp, ipq_q); |
|
Line 1024 ip_dooptions(m) |
|
*/ |
*/ |
bcopy((caddr_t)(cp + off), (caddr_t)&ipaddr.sin_addr, |
bcopy((caddr_t)(cp + off), (caddr_t)&ipaddr.sin_addr, |
sizeof(ipaddr.sin_addr)); |
sizeof(ipaddr.sin_addr)); |
if (opt == IPOPT_SSRR) { |
if (opt == IPOPT_SSRR) |
#define INA struct in_ifaddr * |
ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr))); |
#define SA struct sockaddr * |
else |
ia = (INA)ifa_ifwithladdr((SA)&ipaddr); |
|
} else |
|
ia = ip_rtaddr(ipaddr.sin_addr); |
ia = ip_rtaddr(ipaddr.sin_addr); |
if (ia == 0) { |
if (ia == 0) { |
type = ICMP_UNREACH; |
type = ICMP_UNREACH; |
|
Line 1060 ip_dooptions(m) |
|
* locate outgoing interface; if we're the destination, |
* locate outgoing interface; if we're the destination, |
* use the incoming interface (should be same). |
* use the incoming interface (should be same). |
*/ |
*/ |
if ((ia = (INA)ifa_ifwithaddr((SA)&ipaddr)) == 0 && |
if ((ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr)))) |
(ia = ip_rtaddr(ipaddr.sin_addr)) == 0) { |
== NULL && |
|
(ia = ip_rtaddr(ipaddr.sin_addr)) == NULL) { |
type = ICMP_UNREACH; |
type = ICMP_UNREACH; |
code = ICMP_UNREACH_HOST; |
code = ICMP_UNREACH_HOST; |
goto bad; |
goto bad; |
|
Line 1093 ip_dooptions(m) |
|
sizeof(struct in_addr) > ipt->ipt_len) |
sizeof(struct in_addr) > ipt->ipt_len) |
goto bad; |
goto bad; |
ipaddr.sin_addr = dst; |
ipaddr.sin_addr = dst; |
ia = (INA)ifaof_ifpforaddr((SA)&ipaddr, |
ia = ifatoia(ifaof_ifpforaddr(sintosa(&ipaddr), |
m->m_pkthdr.rcvif); |
m->m_pkthdr.rcvif)); |
if (ia == 0) |
if (ia == 0) |
continue; |
continue; |
bcopy((caddr_t)&ia->ia_addr.sin_addr, |
bcopy((caddr_t)&ia->ia_addr.sin_addr, |
|
Line 1108 ip_dooptions(m) |
|
goto bad; |
goto bad; |
bcopy((caddr_t)sin, (caddr_t)&ipaddr.sin_addr, |
bcopy((caddr_t)sin, (caddr_t)&ipaddr.sin_addr, |
sizeof(struct in_addr)); |
sizeof(struct in_addr)); |
if (ifa_ifwithaddr((SA)&ipaddr) == 0) |
if (ifatoia(ifa_ifwithaddr(sintosa(&ipaddr))) |
|
== NULL) |
continue; |
continue; |
ipt->ipt_ptr += sizeof(struct in_addr); |
ipt->ipt_ptr += sizeof(struct in_addr); |
break; |
break; |
Line 1021 ip_dooptions(m) |
|
Line 1134 ip_dooptions(m) |
|
} |
} |
return (0); |
return (0); |
bad: |
bad: |
ip->ip_len -= ip->ip_hl << 2; /* XXX icmp_error adds in hdr length */ |
|
icmp_error(m, type, code, 0, 0); |
icmp_error(m, type, code, 0, 0); |
ipstat.ips_badoptions++; |
ipstat.ips_badoptions++; |
return (1); |
return (1); |
Line 1070 save_rte(option, dst) |
|
Line 1182 save_rte(option, dst) |
|
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
if (ipprintfs) |
if (ipprintfs) |
printf("save_rte: olen %d\n", olen); |
printf("save_rte: olen %d\n", olen); |
#endif |
#endif /* 0 */ |
if (olen > sizeof(ip_srcrt) - (1 + sizeof(dst))) |
if (olen > sizeof(ip_srcrt) - (1 + sizeof(dst))) |
return; |
return; |
bcopy((caddr_t)option, (caddr_t)ip_srcrt.srcopt, olen); |
bcopy((caddr_t)option, (caddr_t)ip_srcrt.srcopt, olen); |
Line 1164 ip_stripoptions(m, mopt) |
|
Line 1276 ip_stripoptions(m, mopt) |
|
register caddr_t opts; |
register caddr_t opts; |
int olen; |
int olen; |
|
|
olen = (ip->ip_hl<<2) - sizeof (struct ip); |
olen = (ip->ip_hl << 2) - sizeof (struct ip); |
opts = (caddr_t)(ip + 1); |
opts = (caddr_t)(ip + 1); |
i = m->m_len - (sizeof (struct ip) + olen); |
i = m->m_len - (sizeof (struct ip) + olen); |
bcopy(opts + olen, opts, (unsigned)i); |
bcopy(opts + olen, opts, (unsigned)i); |
m->m_len -= olen; |
m->m_len -= olen; |
if (m->m_flags & M_PKTHDR) |
if (m->m_flags & M_PKTHDR) |
m->m_pkthdr.len -= olen; |
m->m_pkthdr.len -= olen; |
ip->ip_hl = sizeof(struct ip) >> 2; |
ip->ip_len -= olen; |
|
ip->ip_hl = sizeof (struct ip) >> 2; |
} |
} |
|
|
int inetctlerrmap[PRC_NCMDS] = { |
int inetctlerrmap[PRC_NCMDS] = { |
Line 1209 ip_forward(m, srcrt) |
|
Line 1322 ip_forward(m, srcrt) |
|
struct mbuf *mcopy; |
struct mbuf *mcopy; |
n_long dest; |
n_long dest; |
struct ifnet *destifp; |
struct ifnet *destifp; |
|
#ifdef IPSEC |
|
struct ifnet dummyifp; |
|
#endif |
|
|
dest = 0; |
dest = 0; |
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
Line 1217 ip_forward(m, srcrt) |
|
Line 1333 ip_forward(m, srcrt) |
|
ntohl(ip->ip_src.s_addr), |
ntohl(ip->ip_src.s_addr), |
ntohl(ip->ip_dst.s_addr), ip->ip_ttl); |
ntohl(ip->ip_dst.s_addr), ip->ip_ttl); |
#endif |
#endif |
if (m->m_flags & M_BCAST || in_canforward(ip->ip_dst) == 0) { |
if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) { |
ipstat.ips_cantforward++; |
ipstat.ips_cantforward++; |
m_freem(m); |
m_freem(m); |
return; |
return; |
Line 1286 ip_forward(m, srcrt) |
|
Line 1402 ip_forward(m, srcrt) |
|
} |
} |
} |
} |
|
|
|
#ifdef IPSEC |
|
m->m_pkthdr.rcvif = NULL; |
|
#endif /*IPSEC*/ |
error = ip_output(m, (struct mbuf *)0, &ipforward_rt, |
error = ip_output(m, (struct mbuf *)0, &ipforward_rt, |
(IP_FORWARDING | (ip_directedbcast ? IP_ALLOWBROADCAST : 0)), 0); |
(IP_FORWARDING | (ip_directedbcast ? IP_ALLOWBROADCAST : 0)), 0); |
if (error) |
if (error) |
Line 1327 ip_forward(m, srcrt) |
|
Line 1446 ip_forward(m, srcrt) |
|
case EMSGSIZE: |
case EMSGSIZE: |
type = ICMP_UNREACH; |
type = ICMP_UNREACH; |
code = ICMP_UNREACH_NEEDFRAG; |
code = ICMP_UNREACH_NEEDFRAG; |
|
#ifndef IPSEC |
if (ipforward_rt.ro_rt) |
if (ipforward_rt.ro_rt) |
destifp = ipforward_rt.ro_rt->rt_ifp; |
destifp = ipforward_rt.ro_rt->rt_ifp; |
|
#else |
|
/* |
|
* If the packet is routed over IPsec tunnel, tell the |
|
* originator the tunnel MTU. |
|
* tunnel MTU = if MTU - sizeof(IP) - ESP/AH hdrsiz |
|
* XXX quickhack!!! |
|
*/ |
|
if (ipforward_rt.ro_rt) { |
|
struct secpolicy *sp; |
|
int ipsecerror; |
|
size_t ipsechdr; |
|
struct route *ro; |
|
|
|
sp = ipsec4_getpolicybyaddr(mcopy, |
|
IPSEC_DIR_OUTBOUND, |
|
IP_FORWARDING, |
|
&ipsecerror); |
|
|
|
if (sp == NULL) |
|
destifp = ipforward_rt.ro_rt->rt_ifp; |
|
else { |
|
/* count IPsec header size */ |
|
ipsechdr = ipsec4_hdrsiz(mcopy, |
|
IPSEC_DIR_OUTBOUND, |
|
NULL); |
|
|
|
/* |
|
* find the correct route for outer IPv4 |
|
* header, compute tunnel MTU. |
|
* |
|
* XXX BUG ALERT |
|
* The "dummyifp" code relies upon the fact |
|
* that icmp_error() touches only ifp->if_mtu. |
|
*/ |
|
/*XXX*/ |
|
destifp = NULL; |
|
if (sp->req != NULL |
|
&& sp->req->sav != NULL |
|
&& sp->req->sav->sah != NULL) { |
|
ro = &sp->req->sav->sah->sa_route; |
|
if (ro->ro_rt && ro->ro_rt->rt_ifp) { |
|
dummyifp.if_mtu = |
|
ro->ro_rt->rt_ifp->if_mtu; |
|
dummyifp.if_mtu -= ipsechdr; |
|
destifp = &dummyifp; |
|
} |
|
} |
|
|
|
key_freesp(sp); |
|
} |
|
} |
|
#endif /*IPSEC*/ |
ipstat.ips_cantfrag++; |
ipstat.ips_cantfrag++; |
break; |
break; |
|
|
Line 1409 ip_sysctl(name, namelen, oldp, oldlenp, |
|
Line 1581 ip_sysctl(name, namelen, oldp, oldlenp, |
|
void *newp; |
void *newp; |
size_t newlen; |
size_t newlen; |
{ |
{ |
extern int subnetsarelocal; |
extern int subnetsarelocal, hostzeroisbroadcast; |
|
|
int error, old; |
int error, old; |
|
|
Line 1501 ip_sysctl(name, namelen, oldp, oldlenp, |
|
Line 1673 ip_sysctl(name, namelen, oldp, oldlenp, |
|
return (error); |
return (error); |
} |
} |
#endif |
#endif |
|
case IPCTL_HOSTZEROBROADCAST: |
|
return (sysctl_int(oldp, oldlenp, newp, newlen, |
|
&hostzeroisbroadcast)); |
|
#if NGIF > 0 |
|
case IPCTL_GIF_TTL: |
|
return(sysctl_int(oldp, oldlenp, newp, newlen, |
|
&ip_gif_ttl)); |
|
#endif |
|
|
default: |
default: |
return (EOPNOTSUPP); |
return (EOPNOTSUPP); |
} |
} |