src/sys/netinet/ip_input.c - diff

Return to ip_input.c CVS log

Up to [cvs.NetBSD.org] / src / sys / netinet

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/netinet/ip_input.c between version 1.319.4.10 and 1.334

version 1.319.4.10, 2017/08/28 17:53:12

version 1.334, 2016/07/06 05:27:52

Line 95 __KERNEL_RCSID(0, "$NetBSD$");

#ifdef _KERNEL_OPT

#include "opt_inet.h"

#include "opt_compat_netbsd.h"

#include "opt_gateway.h"

#include "opt_ipsec.h"

#include "opt_mrouting.h"

#include "opt_mbuftrace.h"

#include "opt_inet_csum.h"

#include "opt_net_mpsafe.h"

#endif

#include "arp.h"

Line 173 __KERNEL_RCSID(0, "$NetBSD$");

#define IPMTUDISCTIMEOUT (10 * 60) /* as per RFC 1191 */

#endif

#ifdef COMPAT_50

#include <compat/sys/time.h>

#include <compat/sys/socket.h>

#endif

* Note: DIRECTED_BROADCAST is handled this way so that previous

* configuration using this option will Just Work.

Line 220 pfil_head_t * inet_pfil_hook __read_mo

Line 225 pfil_head_t * inet_pfil_hook __read_mo

ipid_state_t * ip_ids __read_mostly;

percpu_t * ipstat_percpu __read_mostly;

static percpu_t *ipforward_rt_percpu __cacheline_aligned;

static struct route ipforward_rt __cacheline_aligned;

uint16_t ip_id;

Line 247 EVCNT_ATTACH_STATIC(ip_swcsum);

Line 252 EVCNT_ATTACH_STATIC(ip_swcsum);

#endif /* INET_CSUM_COUNTERS */

* Used to save the IP options in case a protocol wants to respond

* We need to save the IP options in case a protocol wants to respond

* to an incoming packet over the same route if the packet got here

* using IP source routing. This allows connection establishment and

* maintenance when the remote end is on a network that is not known

* to us.

struct ip_srcrt {

int isr_nhops; /* number of hops */

static int ip_nhops = 0;

struct in_addr isr_dst; /* final destination */

char isr_nop; /* one NOP to align */

static struct ip_srcrt {

char isr_hdr[IPOPT_OFFSET + 1]; /* OPTVAL, OLEN & OFFSET */

struct in_addr dst; /* final destination */

struct in_addr isr_routes[MAX_IPOPTLEN/sizeof(struct in_addr)];

char nop; /* one NOP to align */

};

char srcopt[IPOPT_OFFSET + 1]; /* OPTVAL, OLEN and OFFSET */

struct in_addr route[MAX_IPOPTLEN/sizeof(struct in_addr)];

} ip_srcrt;

static int ip_drainwanted;

static void save_rte(struct mbuf *, u_char *, struct in_addr);

struct sockaddr_in ipaddr = {

.sin_len = sizeof(ipaddr),

.sin_family = AF_INET,

};

static void save_rte(u_char *, struct in_addr);

#ifdef MBUFTRACE

struct mowner ip_rx_mowner = MOWNER_INIT("internet", "rx");

Line 274 static void ipintr(void *);

Line 286 static void ipintr(void *);

static void ip_input(struct mbuf *);

static void ip_forward(struct mbuf *, int, struct ifnet *);

static bool ip_dooptions(struct mbuf *);

static struct in_ifaddr *ip_rtaddr(struct in_addr, struct psref *);

static struct in_ifaddr *ip_rtaddr(struct in_addr);

static void sysctl_net_inet_ip_setup(struct sysctllog **);

static struct in_ifaddr *ip_match_our_address(struct ifnet *, struct ip *,

Line 282 static struct in_ifaddr *ip_match_our_ad

Line 294 static struct in_ifaddr *ip_match_our_ad

static struct in_ifaddr *ip_match_our_address_broadcast(struct ifnet *,

struct ip *);

#ifdef NET_MPSAFE

/* XXX: Not yet enabled. */

#define SOFTNET_LOCK() mutex_enter(softnet_lock)

#define SOFTNET_UNLOCK() mutex_exit(softnet_lock)

#else

#define SOFTNET_LOCK() KASSERT(mutex_owned(softnet_lock))

#define SOFTNET_UNLOCK() KASSERT(mutex_owned(softnet_lock))

#endif

* IP initialization: fill in IP protocol switch table.

Line 322 ip_init(void)

Line 330 ip_init(void)

ip_ids = ip_id_init();

ip_id = time_uptime & 0xfffff;

ip_mtudisc_timeout_q = rt_timer_queue_create(ip_mtudisc_timeout);

#ifdef GATEWAY

ipflow_init();

#endif

Line 336 ip_init(void)

Line 345 ip_init(void)

#endif /* MBUFTRACE */

ipstat_percpu = percpu_alloc(sizeof(uint64_t) * IP_NSTATS);

ipforward_rt_percpu = percpu_alloc(sizeof(struct route));

ip_mtudisc_timeout_q = rt_timer_queue_create(ip_mtudisc_timeout);

}

static struct in_ifaddr *

Line 371 ip_match_our_address(struct ifnet *ifp,

Line 378 ip_match_our_address(struct ifnet *ifp,

continue;

if (checkif && ia->ia_ifp != ifp)

continue;

if ((ia->ia_ifp->if_flags & IFF_UP) != 0 &&

if ((ia->ia_ifp->if_flags & IFF_UP) != 0)

(ia->ia4_flags & IN_IFF_DETACHED) == 0)

break;

else

(*downmatch)++;

downmatch++;

}

Line 388 ip_match_our_address_broadcast(struct if

Line 394 ip_match_our_address_broadcast(struct if

struct in_ifaddr *ia = NULL;

struct ifaddr *ifa;

IFADDR_READER_FOREACH(ifa, ifp) {

IFADDR_FOREACH(ifa, ifp) {

if (ifa->ifa_addr->sa_family != AF_INET)

continue;

ia = ifatoia(ifa);

if (ia->ia4_flags & (IN_IFF_NOTREADY | IN_IFF_DETACHED))

if (ia->ia4_flags & IN_IFF_NOTREADY)

continue;

if (in_hosteq(ip->ip_dst, ia->ia_broadaddr.sin_addr) ||

in_hosteq(ip->ip_dst, ia->ia_netbroadcast) ||

Line 426 ipintr(void *arg __unused)

Line 432 ipintr(void *arg __unused)

KASSERT(cpu_softintr_p());

#ifndef NET_MPSAFE

mutex_enter(softnet_lock);

#endif

while ((m = pktq_dequeue(ip_pktq)) != NULL) {

ip_input(m);

}

#ifndef NET_MPSAFE

mutex_exit(softnet_lock);

#endif

}

Line 445 static void

Line 447 static void

ip_input(struct mbuf *m)

{

struct ip *ip = NULL;

struct in_ifaddr *ia = NULL;

struct in_ifaddr *ia;

int hlen = 0, len;

int downmatch;

int srcrt = 0;

ifnet_t *ifp;

struct psref psref;

int s;

KASSERTMSG(cpu_softintr_p(), "ip_input: not in the software "

"interrupt handler; synchronization assumptions violated");

Line 468 ip_input(struct mbuf *m)

Line 469 ip_input(struct mbuf *m)

* are receiving, can't do anything with incoming packets yet.

* Note: we pre-check without locks held.

if (IN_ADDRLIST_READER_EMPTY())

if (!TAILQ_FIRST(&in_ifaddrhead)) {

goto out;

}

IP_STATINC(IP_STAT_TOTAL);

Line 607 ip_input(struct mbuf *m)

Line 609 ip_input(struct mbuf *m)

struct in_addr odst = ip->ip_dst;

bool freed;

SOFTNET_LOCK();

freed = pfil_run_hooks(inet_pfil_hook, &m, ifp, PFIL_IN) != 0;

SOFTNET_UNLOCK();

if (freed || m == NULL) {

m = NULL;

goto out;

}

ip = mtod(m, struct ip *);

Line 639 ip_input(struct mbuf *m)

Line 642 ip_input(struct mbuf *m)

if ((*altq_input)(m, AF_INET) == 0) {

/* Packet dropped by traffic conditioner. */

SOFTNET_UNLOCK();

m = NULL;

goto out;

}

SOFTNET_UNLOCK();

Line 652 ip_input(struct mbuf *m)

Line 654 ip_input(struct mbuf *m)

* error was detected (causing an icmp message

* to be sent and the original packet to be freed).

if (hlen > sizeof (struct ip) && ip_dooptions(m)) {

ip_nhops = 0; /* for source routed packets */

m = NULL;

if (hlen > sizeof (struct ip) && ip_dooptions(m))

goto out;

}

* Check our list of addresses, to see if the packet is for us.

Line 665 ip_input(struct mbuf *m)

Line 666 ip_input(struct mbuf *m)

* or IN_IFF_NOTREADY addresses as not mine.

downmatch = 0;

s = pserialize_read_enter();

ia = ip_match_our_address(ifp, ip, &downmatch);

if (ia != NULL) {

if (ia != NULL)

pserialize_read_exit(s);

goto ours;

}

if (ifp->if_flags & IFF_BROADCAST) {

ia = ip_match_our_address_broadcast(ifp, ip);

if (ia != NULL) {

if (ia != NULL)

pserialize_read_exit(s);

goto ours;

}

pserialize_read_exit(s);

if (IN_MULTICAST(ip->ip_dst.s_addr)) {

#ifdef MROUTING

Line 752 ip_input(struct mbuf *m)

Line 747 ip_input(struct mbuf *m)

return;

}

#ifdef IPSEC

/* Check the security policy (SP) for the packet */

/* Perform IPsec, if any. */

if (ipsec_used) {

SOFTNET_LOCK();

if (ipsec4_input(m, IP_FORWARDING |

(ip_directedbcast ? IP_ALLOWBROADCAST : 0)) != 0) {

SOFTNET_UNLOCK();

goto out;

}

SOFTNET_UNLOCK();

}

#endif

ip_forward(m, srcrt, ifp);

Line 800 ours:

Line 798 ours:

if (ipsec_used &&

(inetsw[ip_protox[ip->ip_p]].pr_flags & PR_LASTHDR) != 0) {

SOFTNET_LOCK();

if (ipsec4_input(m, 0) != 0) {

SOFTNET_UNLOCK();

goto out;

}

SOFTNET_UNLOCK();

}

#endif

Line 810 ours:

Line 811 ours:

* Switch out to protocol's input routine.

#if IFA_STATS

if (ia && ip) {

if (ia && ip)

struct in_ifaddr *_ia;

ia->ia_ifa.ifa_data.ifad_inbytes += ntohs(ip->ip_len);

* Keep a reference from ip_match_our_address with psref

* is expensive, so explore ia here again.

s = pserialize_read_enter();

_ia = in_get_ia(ip->ip_dst);

_ia->ia_ifa.ifa_data.ifad_inbytes += ntohs(ip->ip_len);

pserialize_read_exit(s);

}

#endif

IP_STATINC(IP_STAT_DELIVERED);

Line 844 void

Line 836 void

ip_slowtimo(void)

{

#ifndef NET_MPSAFE

mutex_enter(softnet_lock);

KERNEL_LOCK(1, NULL);

#endif

ip_reass_slowtimo();

#ifndef NET_MPSAFE

KERNEL_UNLOCK_ONE(NULL);

mutex_exit(softnet_lock);

#endif

}

Line 886 ip_dooptions(struct mbuf *m)

Line 874 ip_dooptions(struct mbuf *m)

int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;

struct in_addr dst;

n_time ntime;

struct ifaddr *ifa = NULL;

int s;

dst = ip->ip_dst;

cp = (u_char *)(ip + 1);

Line 924 ip_dooptions(struct mbuf *m)

Line 910 ip_dooptions(struct mbuf *m)

* address is on directly accessible net.

case IPOPT_LSRR:

case IPOPT_SSRR: {

case IPOPT_SSRR:

struct psref psref;

struct sockaddr_in ipaddr = {

.sin_len = sizeof(ipaddr),

.sin_family = AF_INET,

};

if (ip_allowsrcrt == 0) {

type = ICMP_UNREACH;

code = ICMP_UNREACH_NET_PROHIB;

Line 945 ip_dooptions(struct mbuf *m)

Line 925 ip_dooptions(struct mbuf *m)

goto bad;

}

ipaddr.sin_addr = ip->ip_dst;

ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr)));

s = pserialize_read_enter();

if (ia == 0) {

ifa = ifa_ifwithaddr(sintosa(&ipaddr));

if (ifa == NULL) {

pserialize_read_exit(s);

if (opt == IPOPT_SSRR) {

type = ICMP_UNREACH;

code = ICMP_UNREACH_SRCFAIL;

Line 961 ip_dooptions(struct mbuf *m)

Line 938 ip_dooptions(struct mbuf *m)

break;

}

pserialize_read_exit(s);

off--; /* 0 origin */

if ((off + sizeof(struct in_addr)) > optlen) {

* End of source route. Should be for us.

save_rte(m, cp, ip->ip_src);

save_rte(cp, ip->ip_src);

break;

}

Line 976 ip_dooptions(struct mbuf *m)

Line 951 ip_dooptions(struct mbuf *m)

memcpy((void *)&ipaddr.sin_addr, (void *)(cp + off),

sizeof(ipaddr.sin_addr));

if (opt == IPOPT_SSRR) {

if (opt == IPOPT_SSRR)

ifa = ifa_ifwithladdr_psref(sintosa(&ipaddr),

ia = ifatoia(ifa_ifwithladdr(sintosa(&ipaddr)));

&psref);

else

if (ifa != NULL)

ia = ip_rtaddr(ipaddr.sin_addr);

ia = ifatoia(ifa);

if (ia == 0) {

else

ia = NULL;

} else {

ia = ip_rtaddr(ipaddr.sin_addr, &psref);

}

if (ia == NULL) {

type = ICMP_UNREACH;

code = ICMP_UNREACH_SRCFAIL;

goto bad;

Line 994 ip_dooptions(struct mbuf *m)

Line 963 ip_dooptions(struct mbuf *m)

ip->ip_dst = ipaddr.sin_addr;

bcopy((void *)&ia->ia_addr.sin_addr,

(void *)(cp + off), sizeof(struct in_addr));

ia4_release(ia, &psref);

cp[IPOPT_OFFSET] += sizeof(struct in_addr);

* Let ip_intr's mcast routing check handle mcast pkts

forward = !IN_MULTICAST(ip->ip_dst.s_addr);

break;

}

case IPOPT_RR: {

struct psref psref;

struct sockaddr_in ipaddr = {

.sin_len = sizeof(ipaddr),

.sin_family = AF_INET,

};

case IPOPT_RR:

if (optlen < IPOPT_OFFSET + sizeof(*cp)) {

code = &cp[IPOPT_OLEN] - (u_char *)ip;

goto bad;

Line 1030 ip_dooptions(struct mbuf *m)

Line 991 ip_dooptions(struct mbuf *m)

* locate outgoing interface; if we're the destination,

* use the incoming interface (should be same).

ifa = ifa_ifwithaddr_psref(sintosa(&ipaddr), &psref);

if ((ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr))))

if (ifa == NULL) {

== NULL &&

ia = ip_rtaddr(ipaddr.sin_addr, &psref);

(ia = ip_rtaddr(ipaddr.sin_addr)) == NULL) {

if (ia == NULL) {

type = ICMP_UNREACH;

code = ICMP_UNREACH_HOST;

goto bad;

}

} else {

ia = ifatoia(ifa);

}

bcopy((void *)&ia->ia_addr.sin_addr,

(void *)(cp + off), sizeof(struct in_addr));

ia4_release(ia, &psref);

cp[IPOPT_OFFSET] += sizeof(struct in_addr);

break;

}

case IPOPT_TS:

code = cp - (u_char *)ip;

Line 1075 ip_dooptions(struct mbuf *m)

Line 1030 ip_dooptions(struct mbuf *m)

case IPOPT_TS_TSANDADDR: {

struct ifnet *rcvif;

int _s, _ss;

int s;

struct sockaddr_in ipaddr = {

.sin_len = sizeof(ipaddr),

.sin_family = AF_INET,

};

if (ipt->ipt_ptr - 1 + sizeof(n_time) +

sizeof(struct in_addr) > ipt->ipt_len) {

Line 1088 ip_dooptions(struct mbuf *m)

Line 1039 ip_dooptions(struct mbuf *m)

goto bad;

}

ipaddr.sin_addr = dst;

_ss = pserialize_read_enter();

rcvif = m_get_rcvif(m, &s);

rcvif = m_get_rcvif(m, &_s);

ia = ifatoia(ifaof_ifpforaddr(sintosa(&ipaddr),

if (__predict_true(rcvif != NULL)) {

rcvif));

ifa = ifaof_ifpforaddr(sintosa(&ipaddr),

m_put_rcvif(rcvif, &s);

rcvif);

if (ia == 0)

}

continue;

m_put_rcvif(rcvif, &_s);

if (ifa == NULL) {

pserialize_read_exit(_ss);

break;

}

ia = ifatoia(ifa);

bcopy(&ia->ia_addr.sin_addr,

cp0, sizeof(struct in_addr));

pserialize_read_exit(_ss);

ipt->ipt_ptr += sizeof(struct in_addr);

break;

}

case IPOPT_TS_PRESPEC: {

case IPOPT_TS_PRESPEC:

struct sockaddr_in ipaddr = {

.sin_len = sizeof(ipaddr),

.sin_family = AF_INET,

};

if (ipt->ipt_ptr - 1 + sizeof(n_time) +

sizeof(struct in_addr) > ipt->ipt_len) {

code = (u_char *)&ipt->ipt_ptr -

Line 1121 ip_dooptions(struct mbuf *m)

Line 1060 ip_dooptions(struct mbuf *m)

}

memcpy(&ipaddr.sin_addr, cp0,

sizeof(struct in_addr));

s = pserialize_read_enter();

if (ifatoia(ifa_ifwithaddr(sintosa(&ipaddr)))

ifa = ifa_ifwithaddr(sintosa(&ipaddr));

== NULL)

if (ifa == NULL) {

pserialize_read_exit(s);

continue;

}

pserialize_read_exit(s);

ipt->ipt_ptr += sizeof(struct in_addr);

break;

}

default:

/* XXX can't take &ipt->ipt_flg */

Line 1147 ip_dooptions(struct mbuf *m)

Line 1081 ip_dooptions(struct mbuf *m)

}

if (forward) {

struct ifnet *rcvif;

struct psref _psref;

struct psref psref;

if (ip_forwsrcrt == 0) {

type = ICMP_UNREACH;

Line 1155 ip_dooptions(struct mbuf *m)

Line 1089 ip_dooptions(struct mbuf *m)

goto bad;

}

rcvif = m_get_rcvif_psref(m, &_psref);

rcvif = m_get_rcvif_psref(m, &psref);

if (__predict_false(rcvif == NULL)) {

type = ICMP_UNREACH;

code = ICMP_UNREACH_HOST;

goto bad;

}

ip_forward(m, 1, rcvif);

m_put_rcvif_psref(rcvif, &_psref);

m_put_rcvif_psref(rcvif, &psref);

return true;

}

return false;

Line 1177 bad:

Line 1111 bad:

* return internet address info of interface to be used to get there.

static struct in_ifaddr *

ip_rtaddr(struct in_addr dst, struct psref *psref)

ip_rtaddr(struct in_addr dst)

{

struct rtentry *rt;

union {

struct sockaddr dst;

struct sockaddr_in dst4;

} u;

struct route *ro;

sockaddr_in_init(&u.dst4, &dst, 0);

ro = percpu_getref(ipforward_rt_percpu);

SOFTNET_LOCK();

rt = rtcache_lookup(ro, &u.dst);

rt = rtcache_lookup(&ipforward_rt, &u.dst);

if (rt == NULL) {

SOFTNET_UNLOCK();

percpu_putref(ipforward_rt_percpu);

if (rt == NULL)

return NULL;

}

ia4_acquire(ifatoia(rt->rt_ifa), psref);

rtcache_unref(rt, ro);

percpu_putref(ipforward_rt_percpu);

return ifatoia(rt->rt_ifa);

}

Line 1207 ip_rtaddr(struct in_addr dst, struct psr

Line 1135 ip_rtaddr(struct in_addr dst, struct psr

* up later by ip_srcroute if the receiver is interested.

static void

save_rte(struct mbuf *m, u_char *option, struct in_addr dst)

save_rte(u_char *option, struct in_addr dst)

{

struct ip_srcrt *isr;

struct m_tag *mtag;

unsigned olen;

olen = option[IPOPT_OLEN];

if (olen > sizeof(isr->isr_hdr) + sizeof(isr->isr_routes))

if (olen > sizeof(ip_srcrt) - (1 + sizeof(dst)))

return;

memcpy((void *)ip_srcrt.srcopt, (void *)option, olen);

mtag = m_tag_get(PACKET_TAG_SRCROUTE, sizeof(*isr), M_NOWAIT);

ip_nhops = (olen - IPOPT_OFFSET - 1) / sizeof(struct in_addr);

if (mtag == NULL)

ip_srcrt.dst = dst;

return;

isr = (struct ip_srcrt *)(mtag + 1);

memcpy(isr->isr_hdr, option, olen);

isr->isr_nhops = (olen - IPOPT_OFFSET - 1) / sizeof(struct in_addr);

isr->isr_dst = dst;

m_tag_prepend(m, mtag);

}

Line 1234 save_rte(struct mbuf *m, u_char *option,

Line 1153 save_rte(struct mbuf *m, u_char *option,

* The first hop is placed before the options, will be removed later.

struct mbuf *

ip_srcroute(struct mbuf *m0)

ip_srcroute(void)

{

struct in_addr *p, *q;

struct mbuf *m;

struct ip_srcrt *isr;

struct m_tag *mtag;

mtag = m_tag_find(m0, PACKET_TAG_SRCROUTE, NULL);

if (mtag == NULL)

return NULL;

isr = (struct ip_srcrt *)(mtag + 1);

if (isr->isr_nhops == 0)

if (ip_nhops == 0)

return NULL;

m = m_get(M_DONTWAIT, MT_SOOPTS);

if (m == NULL)

if (m == 0)

return NULL;

MCLAIM(m, &inetdomain.dom_mowner);

#define OPTSIZ (sizeof(isr->isr_nop) + sizeof(isr->isr_hdr))

#define OPTSIZ (sizeof(ip_srcrt.nop) + sizeof(ip_srcrt.srcopt))

/* length is (nhops+1)*sizeof(addr) + sizeof(nop + header) */

/* length is (nhops+1)*sizeof(addr) + sizeof(nop + srcrt header) */

m->m_len = (isr->isr_nhops + 1) * sizeof(struct in_addr) + OPTSIZ;

m->m_len = ip_nhops * sizeof(struct in_addr) + sizeof(struct in_addr) +

OPTSIZ;

* First save first hop for return route

p = &(isr->isr_routes[isr->isr_nhops - 1]);

p = &ip_srcrt.route[ip_nhops - 1];

*(mtod(m, struct in_addr *)) = *p--;

* Copy option fields and padding (nop) to mbuf.

isr->isr_nop = IPOPT_NOP;

ip_srcrt.nop = IPOPT_NOP;

isr->isr_hdr[IPOPT_OFFSET] = IPOPT_MINOFF;

ip_srcrt.srcopt[IPOPT_OFFSET] = IPOPT_MINOFF;

memmove(mtod(m, char *) + sizeof(struct in_addr), &isr->isr_nop,

memmove(mtod(m, char *) + sizeof(struct in_addr), &ip_srcrt.nop,

OPTSIZ);

q = (struct in_addr *)(mtod(m, char *) +

sizeof(struct in_addr) + OPTSIZ);

Line 1279 ip_srcroute(struct mbuf *m0)

Line 1191 ip_srcroute(struct mbuf *m0)

* Record return path as an IP source route,

* reversing the path (pointers are now aligned).

while (p >= isr->isr_routes) {

while (p >= ip_srcrt.route) {

*q++ = *p--;

}

* Last hop goes to final destination.

*q = isr->isr_dst;

*q = ip_srcrt.dst;

m_tag_delete(m0, mtag);

return (m);

return m;

}

const int inetctlerrmap[PRC_NCMDS] = {

Line 1344 ip_forward(struct mbuf *m, int srcrt, st

Line 1255 ip_forward(struct mbuf *m, int srcrt, st

struct sockaddr_in dst4;

} u;

uint64_t *ips;

struct route *ro;

KASSERTMSG(cpu_softintr_p(), "ip_forward: not in the software "

"interrupt handler; synchronization assumptions violated");

Line 1366 ip_forward(struct mbuf *m, int srcrt, st

Line 1276 ip_forward(struct mbuf *m, int srcrt, st

return;

}

SOFTNET_LOCK();

if (ip->ip_ttl <= IPTTLDEC) {

icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);

SOFTNET_UNLOCK();

return;

}

sockaddr_in_init(&u.dst4, &ip->ip_dst, 0);

ro = percpu_getref(ipforward_rt_percpu);

if ((rt = rtcache_lookup(&ipforward_rt, &u.dst)) == NULL) {

rt = rtcache_lookup(ro, &u.dst);

if (rt == NULL) {

percpu_putref(ipforward_rt_percpu);

icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_NET, dest, 0);

SOFTNET_UNLOCK();

return;

}

Line 1419 ip_forward(struct mbuf *m, int srcrt, st

Line 1330 ip_forward(struct mbuf *m, int srcrt, st

code = ICMP_REDIRECT_HOST;

}

rtcache_unref(rt, ro);

error = ip_output(m, NULL, ro,

error = ip_output(m, NULL, &ipforward_rt,

(IP_FORWARDING | (ip_directedbcast ? IP_ALLOWBROADCAST : 0)),

NULL, NULL);

Line 1443 ip_forward(struct mbuf *m, int srcrt, st

Line 1353 ip_forward(struct mbuf *m, int srcrt, st

if (mcopy) {

#ifdef GATEWAY

if (mcopy->m_flags & M_CANFASTFWD)

ipflow_create(ro, mcopy);

ipflow_create(&ipforward_rt, mcopy);

#endif

m_freem(mcopy);

}

percpu_putref(ipforward_rt_percpu);

SOFTNET_UNLOCK();

return;

redirect:

error:

if (mcopy == NULL) {

percpu_putref(ipforward_rt_percpu);

SOFTNET_UNLOCK();

return;

}

Line 1477 error:

Line 1387 error:

type = ICMP_UNREACH;

code = ICMP_UNREACH_NEEDFRAG;

if ((rt = rtcache_validate(ro)) != NULL) {

if ((rt = rtcache_validate(&ipforward_rt)) != NULL)

destmtu = rt->rt_ifp->if_mtu;

rtcache_unref(rt, ro);

}

#ifdef IPSEC

if (ipsec_used)

(void)ipsec4_forward(mcopy, &destmtu);

Line 1497 error:

Line 1405 error:

if (mcopy)

m_freem(mcopy);

percpu_putref(ipforward_rt_percpu);

SOFTNET_UNLOCK();

return;

}

icmp_error(mcopy, type, code, dest, destmtu);

percpu_putref(ipforward_rt_percpu);

SOFTNET_UNLOCK();

}

void

Line 1509 ip_savecontrol(struct inpcb *inp, struct

Line 1417 ip_savecontrol(struct inpcb *inp, struct

struct mbuf *m)

{

struct socket *so = inp->inp_socket;

ifnet_t *ifp;

int inpflags = inp->inp_flags;

struct psref psref;

if (SOOPT_TIMESTAMP(so->so_options))

ifp = m_get_rcvif_psref(m, &psref);

mp = sbsavetimestamp(so->so_options, m, mp);

if (__predict_false(ifp == NULL))

return; /* XXX should report error? */

if (inpflags & INP_RECVDSTADDR) {

if (so->so_options & SO_TIMESTAMP

*mp = sbcreatecontrol(&ip->ip_dst,

#ifdef SO_OTIMESTAMP

sizeof(struct in_addr), IP_RECVDSTADDR, IPPROTO_IP);

|| so->so_options & SO_OTIMESTAMP

#endif

) {

struct timeval tv;

microtime(&tv);

#ifdef SO_OTIMESTAMP

if (so->so_options & SO_OTIMESTAMP) {

struct timeval50 tv50;

timeval_to_timeval50(&tv, &tv50);

*mp = sbcreatecontrol((void *) &tv50, sizeof(tv50),

SCM_OTIMESTAMP, SOL_SOCKET);

} else

#endif

*mp = sbcreatecontrol((void *) &tv, sizeof(tv),

SCM_TIMESTAMP, SOL_SOCKET);

if (*mp)

mp = &(*mp)->m_next;

}

if (inpflags & INP_RECVDSTADDR) {

if (inpflags & INP_RECVTTL) {

*mp = sbcreatecontrol((void *) &ip->ip_dst,

*mp = sbcreatecontrol(&ip->ip_ttl,

sizeof(struct in_addr), IP_RECVDSTADDR, IPPROTO_IP);

sizeof(uint8_t), IP_RECVTTL, IPPROTO_IP);

if (*mp)

mp = &(*mp)->m_next;

}

struct psref psref;

ifnet_t *ifp = m_get_rcvif_psref(m, &psref);

if (__predict_false(ifp == NULL)) {

#ifdef DIAGNOSTIC

printf("%s: missing receive interface\n", __func__);

#endif

return; /* XXX should report error? */

}

if (inpflags & INP_RECVPKTINFO) {

struct in_pktinfo ipi;

ipi.ipi_addr = ip->ip_src;

ipi.ipi_ifindex = ifp->if_index;

*mp = sbcreatecontrol(&ipi,

*mp = sbcreatecontrol((void *) &ipi,

sizeof(ipi), IP_RECVPKTINFO, IPPROTO_IP);

if (*mp)

mp = &(*mp)->m_next;

Line 1550 ip_savecontrol(struct inpcb *inp, struct

Line 1465 ip_savecontrol(struct inpcb *inp, struct

struct in_pktinfo ipi;

ipi.ipi_addr = ip->ip_dst;

ipi.ipi_ifindex = ifp->if_index;

*mp = sbcreatecontrol(&ipi,

*mp = sbcreatecontrol((void *) &ipi,

sizeof(ipi), IP_PKTINFO, IPPROTO_IP);

if (*mp)

mp = &(*mp)->m_next;

Line 1558 ip_savecontrol(struct inpcb *inp, struct

Line 1473 ip_savecontrol(struct inpcb *inp, struct

if (inpflags & INP_RECVIF) {

struct sockaddr_dl sdl;

sockaddr_dl_init(&sdl, sizeof(sdl), ifp->if_index, 0, NULL, 0,

sockaddr_dl_init(&sdl, sizeof(sdl), ifp ?

NULL, 0);

ifp->if_index : 0, 0, NULL, 0, NULL, 0);

*mp = sbcreatecontrol(&sdl, sdl.sdl_len, IP_RECVIF, IPPROTO_IP);

if (*mp)

mp = &(*mp)->m_next;

}

if (inpflags & INP_RECVTTL) {

*mp = sbcreatecontrol((void *) &ip->ip_ttl,

sizeof(uint8_t), IP_RECVTTL, IPPROTO_IP);

if (*mp)

mp = &(*mp)->m_next;

}

m_put_rcvif_psref(ifp, &psref);

}

Line 1603 sysctl_net_inet_ip_pmtudto(SYSCTLFN_ARGS

Line 1524 sysctl_net_inet_ip_pmtudto(SYSCTLFN_ARGS

int error, tmp;

struct sysctlnode node;

icmp_mtudisc_lock();

node = *rnode;

tmp = ip_mtudisc_timeout;

node.sysctl_data = &tmp;

error = sysctl_lookup(SYSCTLFN_CALL(&node));

if (error || newp == NULL)

goto out;

return (error);

if (tmp < 0) {

if (tmp < 0)

error = EINVAL;

return (EINVAL);

goto out;

}

mutex_enter(softnet_lock);

ip_mtudisc_timeout = tmp;

rt_timer_queue_change(ip_mtudisc_timeout_q, ip_mtudisc_timeout);

error = 0;

out:

mutex_exit(softnet_lock);

icmp_mtudisc_unlock();

return error;

return (0);

}

static int

CVSweb <webmaster@jp.NetBSD.org>