src/sys/netinet/udp_usrreq.c - diff

Return to udp_usrreq.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/udp_usrreq.c between version 1.52.2.3 and 1.53

version 1.52.2.3, 2001/02/11 19:17:19

version 1.53, 1999/12/13 15:17:21

Line 65

#include "opt_ipsec.h"

#include "opt_ipkdb.h"

#include "ipkdb.h"

#include <sys/param.h>

#include <sys/malloc.h>

Line 79

Line 80

#include <sys/proc.h>

#include <sys/domain.h>

#include <uvm/uvm_extern.h>

#include <vm/vm.h>

#include <sys/sysctl.h>

#include <net/if.h>

Line 115

Line 116

#ifdef IPSEC

#include <netinet6/ipsec.h>

#include <netkey/key.h>

#include <netkey/key_debug.h>

#endif /*IPSEC*/

#ifdef IPKDB

#include <ipkdb/ipkdb.h>

#endif

* UDP protocol implementation.

* Per RFC 768, August, 1980.

Line 131 int udpcksum = 1;

Line 129 int udpcksum = 1;

int udpcksum = 0; /* XXX */

#endif

#ifdef INET

static void udp4_sendup __P((struct mbuf *, int, struct sockaddr *,

struct socket *));

static int udp4_realinput __P((struct sockaddr_in *, struct sockaddr_in *,

struct mbuf *, int));

#endif

#ifdef INET6

static void udp6_sendup __P((struct mbuf *, int, struct sockaddr *,

struct socket *));

Line 145 static int in6_mcmatch __P((struct in6pc

Line 141 static int in6_mcmatch __P((struct in6pc

static int udp6_realinput __P((int, struct sockaddr_in6 *,

struct sockaddr_in6 *, struct mbuf *, int));

#endif

#ifdef INET

static void udp_notify __P((struct inpcb *, int));

#endif

#ifndef UDBHASHSIZE

#define UDBHASHSIZE 128

Line 158 void

Line 152 void

udp_init()

{

#ifdef INET

in_pcbinit(&udbtable, udbhashsize, udbhashsize);

#endif

}

#ifndef UDP6

#ifdef INET

void

#if __STDC__

udp_input(struct mbuf *m, ...)

Line 228 udp_input(m, va_alist)

Line 218 udp_input(m, va_alist)

}

#endif

/* destination port of 0 is illegal, based on RFC768. */

if (uh->uh_dport == 0)

goto bad;

* Make mbuf data length reflect UDP length.

* If not enough data to reflect UDP length, drop.

len = ntohs((u_int16_t)uh->uh_ulen);

if (ip->ip_len != iphlen + len) {

if (ip->ip_len < iphlen + len || len < sizeof(struct udphdr)) {

if (ip->ip_len < iphlen + len) {

udpstat.udps_badlen++;

goto bad;

}

Line 249 udp_input(m, va_alist)

Line 235 udp_input(m, va_alist)

* Checksum extended UDP header and data.

if (uh->uh_sum) {

#ifndef PULLDOWN_TEST

struct ip save_ip;

* Save a copy of the IP header in case we want restore it

* for sending an ICMP error message in response.

save_ip = *ip;

bzero(((struct ipovly *)ip)->ih_x1,

sizeof ((struct ipovly *)ip)->ih_x1);

((struct ipovly *)ip)->ih_len = uh->uh_ulen;

if (in_cksum(m, len + sizeof (struct ip)) != 0) {

udpstat.udps_badsum++;

m_freem(m);

return;

}

*ip = save_ip;

#else

if (in4_cksum(m, IPPROTO_UDP, iphlen, len) != 0) {

udpstat.udps_badsum++;

m_freem(m);

return;

}

#endif

}

/* construct source and dst sockaddrs. */

Line 293 udp_input(m, va_alist)

Line 300 udp_input(m, va_alist)

#endif

if (n == 0) {

udpstat.udps_noport++;

if (m->m_flags & (M_BCAST | M_MCAST)) {

udpstat.udps_noportbcast++;

goto bad;

}

udpstat.udps_noport++;

#if NIPKDB > 0

#ifdef IPKDB

if (checkipkdb(&ip->ip_src, uh->uh_sport, uh->uh_dport,

m, iphlen + sizeof(struct udphdr),

m->m_pkthdr.len - iphlen - sizeof(struct udphdr))) {

Line 317 bad:

Line 324 bad:

if (m)

m_freem(m);

}

#endif

#ifdef INET6

int

Line 361 udp6_input(mp, offp, proto)

Line 367 udp6_input(mp, offp, proto)

}

#endif

ulen = ntohs((u_short)uh->uh_ulen);

* RFC2675 section 4: jumbograms will have 0 in the UDP header field,

* iff payload length > 0xffff.

if (ulen == 0 && plen > 0xffff)

ulen = plen;

Line 373 udp6_input(mp, offp, proto)

Line 375 udp6_input(mp, offp, proto)

goto bad;

}

/* destination port of 0 is illegal, based on RFC768. */

if (uh->uh_dport == 0)

goto bad;

/* Be proactive about malicious use of IPv4 mapped address */

if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||

IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {

/* XXX stat */

goto bad;

}

* Checksum extended UDP header and data.

Line 401 udp6_input(mp, offp, proto)

Line 392 udp6_input(mp, offp, proto)

bzero(&src, sizeof(src));

src.sin6_family = AF_INET6;

src.sin6_len = sizeof(struct sockaddr_in6);

/* KAME hack: recover scopeid */

bcopy(&ip6->ip6_src, &src.sin6_addr, sizeof(src.sin6_addr));

(void)in6_recoverscope(&src, &ip6->ip6_src, m->m_pkthdr.rcvif);

if (IN6_IS_SCOPE_LINKLOCAL(&src.sin6_addr))

src.sin6_addr.s6_addr16[1] = 0;

if (m->m_pkthdr.rcvif) {

if (IN6_IS_SCOPE_LINKLOCAL(&src.sin6_addr))

src.sin6_scope_id = m->m_pkthdr.rcvif->if_index;

else

src.sin6_scope_id = 0;

}

src.sin6_port = uh->uh_sport;

bzero(&dst, sizeof(dst));

dst.sin6_family = AF_INET6;

dst.sin6_len = sizeof(struct sockaddr_in6);

/* KAME hack: recover scopeid */

bcopy(&ip6->ip6_dst, &dst.sin6_addr, sizeof(dst.sin6_addr));

(void)in6_recoverscope(&dst, &ip6->ip6_dst, m->m_pkthdr.rcvif);

if (IN6_IS_SCOPE_LINKLOCAL(&dst.sin6_addr))

dst.sin6_addr.s6_addr16[1] = 0;

if (m->m_pkthdr.rcvif) {

if (IN6_IS_SCOPE_LINKLOCAL(&dst.sin6_addr))

dst.sin6_scope_id = m->m_pkthdr.rcvif->if_index;

else

dst.sin6_scope_id = 0;

}

dst.sin6_port = uh->uh_dport;

if (udp6_realinput(AF_INET6, &src, &dst, m, off) == 0) {

udp6stat.udp6s_noport++;

if (m->m_flags & M_MCAST) {

udp6stat.udp6s_noportmcast++;

goto bad;

}

udp6stat.udp6s_noport++;

icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT, 0);

m = NULL;

}

Line 428 bad:

Line 433 bad:

}

#endif

#ifdef INET

static void

udp4_sendup(m, off, src, so)

struct mbuf *m;

Line 483 udp4_sendup(m, off, src, so)

Line 487 udp4_sendup(m, off, src, so)

sorwakeup(so);

}

#endif

#ifdef INET6

static void

Line 530 udp6_sendup(m, off, src, so)

Line 533 udp6_sendup(m, off, src, so)

}

#endif

#ifdef INET

static int

udp4_realinput(src, dst, m, off)

struct sockaddr_in *src;

Line 554 udp4_realinput(src, dst, m, off)

Line 556 udp4_realinput(src, dst, m, off)

dst4 = &dst->sin_addr;

dport = &dst->sin_port;

if (IN_MULTICAST(dst4->s_addr) ||

if (IN_MULTICAST(src4->s_addr) ||

in_broadcast(*dst4, m->m_pkthdr.rcvif)) {

struct inpcb *last;

Line 575 udp4_realinput(src, dst, m, off)

Line 577 udp4_realinput(src, dst, m, off)

* KAME note: usually we drop udpiphdr from mbuf here.

* we need udpiphdr for IPsec processing so we do that later.

* we need udpiphdr for iPsec processing so we do that later.

* Locate pcb(s) for datagram.

Line 620 udp4_realinput(src, dst, m, off)

Line 622 udp4_realinput(src, dst, m, off)

* (No need to send an ICMP Port Unreachable

* for a broadcast or multicast datgram.)

udpstat.udps_noport++;

udpstat.udps_noportbcast++;

goto bad;

}

Line 636 udp4_realinput(src, dst, m, off)

Line 639 udp4_realinput(src, dst, m, off)

#if 0

struct mbuf *n;

udpstat.udps_noport++;

if (m->m_flags & (M_BCAST | M_MCAST)) {

udpstat.udps_noportbcast++;

goto bad;

}

udpstat.udps_noport++;

#if NIPKDB > 0

#ifdef IPKDB

if (checkipkdb(src4, *sport, *dport, m, off,

m->m_pkthdr.len - off)) {

Line 667 udp4_realinput(src, dst, m, off)

Line 670 udp4_realinput(src, dst, m, off)

bad:

return rcvcnt;

}

#endif

#ifdef INET6

static int

in6_mcmatch(in6p, ia6, ifp)

struct in6pcb *in6p;

struct in6_addr *ia6;

struct ifnet *ifp;

{

struct ip6_moptions *im6o = in6p->in6p_moptions;

Line 704 udp6_realinput(af, src, dst, m, off)

Line 706 udp6_realinput(af, src, dst, m, off)

u_int16_t *sport, *dport;

int rcvcnt;

struct in6_addr *src6, *dst6;

struct in_addr *dst4;

struct in_addr *src4;

struct in6pcb *in6p;

rcvcnt = 0;

Line 719 udp6_realinput(af, src, dst, m, off)

Line 721 udp6_realinput(af, src, dst, m, off)

sport = &src->sin6_port;

dst6 = &dst->sin6_addr;

dport = &dst->sin6_port;

dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr32[12];

src4 = (struct in_addr *)&src->sin6_addr.s6_addr32[12];

if (IN6_IS_ADDR_MULTICAST(dst6)

|| (af == AF_INET && IN_MULTICAST(dst4->s_addr))) {

|| (af == AF_INET && IN_MULTICAST(src4->s_addr))) {

struct in6pcb *last;

* Deliver a multicast or broadcast datagram to *all* sockets

Line 742 udp6_realinput(af, src, dst, m, off)

Line 744 udp6_realinput(af, src, dst, m, off)

* KAME note: usually we drop udpiphdr from mbuf here.

* we need udpiphdr for IPsec processing so we do that later.

* we need udpiphdr for iPsec processing so we do that later.

* Locate pcb(s) for datagram.

Line 756 udp6_realinput(af, src, dst, m, off)

Line 758 udp6_realinput(af, src, dst, m, off)

&& !in6_mcmatch(in6p, dst6, m->m_pkthdr.rcvif))

continue;

}

#ifndef INET6_BINDV6ONLY

else {

if (IN6_IS_ADDR_V4MAPPED(dst6)

&& (in6p->in6p_flags & IN6P_BINDV6ONLY))

continue;

}

#endif

if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {

if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, src6)

|| in6p->in6p_fport != *sport)

continue;

}

#ifndef INET6_BINDV6ONLY

else {

if (IN6_IS_ADDR_V4MAPPED(src6)

&& (in6p->in6p_flags & IN6P_BINDV6ONLY))

continue;

}

#endif

last = in6p;

udp6_sendup(m, off, (struct sockaddr *)src,

Line 803 udp6_realinput(af, src, dst, m, off)

Line 791 udp6_realinput(af, src, dst, m, off)

switch (af) {

case AF_INET:

udpstat.udps_noport++;

udpstat.udps_noportbcast++;

break;

case AF_INET6:

udp6stat.udp6s_noport++;

udp6stat.udp6s_noportmcast++;

break;

}

Line 827 udp6_realinput(af, src, dst, m, off)

Line 817 udp6_realinput(af, src, dst, m, off)

n = m_copy(m, 0, M_COPYALL);

switch (af) {

case AF_INET:

udpstat.udps_noport++;

if (m->m_flags & (M_BCAST | M_MCAST)) {

udpstat.udps_noportbcast++;

goto bad;

}

udpstat.udps_noport++;

if (n != NULL)

icmp_error(n, ICMP_UNREACH,

ICMP_UNREACH_PORT, 0, 0);

break;

case AF_INET6:

udp6stat.udp6s_noport++;

if (m->m_flags & M_MCAST) {

udp6stat.udp6s_noportmcast++;

goto bad;

}

udp6stat.udp6s_noport++;

if (n != NULL)

icmp6_error(n, ICMP6_DST_UNREACH,

ICMP6_DST_UNREACH_NOPORT, 0);

Line 862 bad:

Line 852 bad:

}

#endif

#else /*UDP6*/

#if 0

void

#if __STDC__

udp_input(struct mbuf *m, ...)

Line 874 udp_input(m, va_alist)

Line 863 udp_input(m, va_alist)

#endif

{

int proto;

struct ip *ip;

struct udphdr *uh;

struct inpcb *inp;

struct mbuf *opts = 0;

int len;

struct ip save_ip;

Line 916 udp_input(m, va_alist)

Line 905 udp_input(m, va_alist)

}

uh = (struct udphdr *)((caddr_t)ip + iphlen);

/* destination port of 0 is illegal, based on RFC768. */

if (uh->uh_dport == 0)

goto bad;

* Make mbuf data length reflect UDP length.

* If not enough data to reflect UDP length, drop.

len = ntohs((u_int16_t)uh->uh_ulen);

if (ip->ip_len != iphlen + len) {

if (ip->ip_len < iphlen + len || len < sizeof(struct udphdr)) {

if (ip->ip_len < iphlen + len) {

udpstat.udps_badlen++;

goto bad;

}

Line 983 udp_input(m, va_alist)

Line 968 udp_input(m, va_alist)

iphlen += sizeof(struct udphdr);

* KAME note: usually we drop udpiphdr from mbuf here.

* we need udpiphdr for IPsec processing so we do that later.

* we need udpiphdr for iPsec processing so we do that later.

* Locate pcb(s) for datagram.

Line 1055 udp_input(m, va_alist)

Line 1040 udp_input(m, va_alist)

* (No need to send an ICMP Port Unreachable

* for a broadcast or multicast datgram.)

udpstat.udps_noport++;

udpstat.udps_noportbcast++;

goto bad;

}

Line 1088 udp_input(m, va_alist)

Line 1074 udp_input(m, va_alist)

++udpstat.udps_pcbhashmiss;

inp = in_pcblookup_bind(&udbtable, ip->ip_dst, uh->uh_dport);

if (inp == 0) {

udpstat.udps_noport++;

if (m->m_flags & (M_BCAST | M_MCAST)) {

udpstat.udps_noportbcast++;

goto bad;

}

udpstat.udps_noport++;

*ip = save_ip;

#ifdef IPKDB

#if NIPKDB > 0

if (checkipkdb(&ip->ip_src,

uh->uh_sport,

uh->uh_dport,

Line 1137 bad:

Line 1123 bad:

if (opts)

m_freem(opts);

}

#endif /*UDP6*/

#endif

#ifdef INET

* Notify a udp user of an asynchronous error;

* just wake up so that he can collect error status.

static void

udp_notify(inp, errno)

struct inpcb *inp;

int errno;

{

Line 1161 udp_ctlinput(cmd, sa, v)

Line 1146 udp_ctlinput(cmd, sa, v)

struct sockaddr *sa;

void *v;

{

struct ip *ip = v;

struct udphdr *uh;

extern int inetctlerrmap[];

void (*notify) __P((struct inpcb *, int)) = udp_notify;

int errno;

Line 1199 udp_output(m, va_alist)

Line 1185 udp_output(m, va_alist)

va_dcl

#endif

{

struct inpcb *inp;

struct udpiphdr *ui;

int len = m->m_pkthdr.len;

int error = 0;

va_list ap;

Line 1256 udp_output(m, va_alist)

Line 1242 udp_output(m, va_alist)

udpstat.udps_opackets++;

#ifdef IPSEC

if (ipsec_setsocket(m, inp->inp_socket) != 0) {

m->m_pkthdr.rcvif = (struct ifnet *)inp->inp_socket;

error = ENOBUFS;

goto release;

}

#endif /*IPSEC*/

return (ip_output(m, inp->inp_options, &inp->inp_route,

Line 1283 udp_usrreq(so, req, m, nam, control, p)

Line 1266 udp_usrreq(so, req, m, nam, control, p)

struct mbuf *m, *nam, *control;

struct proc *p;

{

struct inpcb *inp;

int s;

int error = 0;

if (req == PRU_CONTROL)

return (in_control(so, (long)m, (caddr_t)nam,

(struct ifnet *)control, p));

if (req == PRU_PURGEIF) {

in_purgeif((struct ifnet *)control);

in_pcbpurgeif(&udbtable, (struct ifnet *)control);

return (0);

}

s = splsoftnet();

inp = sotoinpcb(so);

#ifdef DIAGNOSTIC

Line 1330 udp_usrreq(so, req, m, nam, control, p)

Line 1307 udp_usrreq(so, req, m, nam, control, p)

inp = sotoinpcb(so);

inp->inp_ip.ip_ttl = ip_defttl;

#ifdef IPSEC

error = ipsec_init_policy(so, &inp->inp_sp);

error = ipsec_init_policy(&inp->inp_sp);

if (error != 0) {

in_pcbdetach(inp);

break;

Line 1478 udp_sysctl(name, namelen, oldp, oldlenp,

Line 1455 udp_sysctl(name, namelen, oldp, oldlenp,

}

/* NOTREACHED */

}

#endif

CVSweb <webmaster@jp.NetBSD.org>