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.138 and 1.138.2.1

version 1.138, 2005/04/29 13:06:23

version 1.138.2.1, 2006/06/21 15:11:02

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

#include <netinet/udp.h>

#include <netinet/udp_var.h>

#ifdef IPSEC_NAT_T

#include <netinet6/ipsec.h>

#include <netinet6/esp.h>

#endif

#ifdef INET6

#include <netinet/ip6.h>

#include <netinet/icmp6.h>

#include <netinet6/ip6_var.h>

#include <netinet6/in6_pcb.h>

#include <netinet6/udp6_var.h>

#include <netinet6/scope6_var.h>

#endif

#ifndef INET6

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

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

#ifdef FAST_IPSEC

#include <netipsec/ipsec.h>

#include <netipsec/ipsec_var.h> /* XXX ipsecstat namespace */

#include <netipsec/esp.h>

#ifdef INET6

#include <netipsec/ipsec6.h>

#endif

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

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

#ifdef IPSEC

#include <netinet6/ipsec.h>

#include <netinet6/esp.h>

#include <netkey/key.h>

#endif /*IPSEC*/

Line 146 int udpcksum = 1;

Line 144 int udpcksum = 1;

#else

int udpcksum = 0; /* XXX */

#endif

int udp_do_loopback_cksum = 0;

struct inpcbtable udbtable;

struct udpstat udpstat;

#ifdef INET

#ifdef IPSEC_NAT_T

static int udp4_espinudp (struct mbuf *, int, struct sockaddr *,

static int udp4_espinudp (struct mbuf **, int, struct sockaddr *,

struct socket *);

#endif

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

struct socket *);

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

struct mbuf *, int);

struct mbuf **, int);

static int udp4_input_checksum(struct mbuf *, const struct udphdr *, int, int);

#endif

#ifdef INET6

Line 186 struct mowner udp_tx_mowner = { "udp", "

Line 185 struct mowner udp_tx_mowner = { "udp", "

#ifdef UDP_CSUM_COUNTERS

#include <sys/device.h>

#if defined(INET)

struct evcnt udp_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "udp", "hwcsum bad");

struct evcnt udp_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

Line 195 struct evcnt udp_hwcsum_data = EVCNT_INI

struct evcnt udp_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "udp", "swcsum");

#define UDP_CSUM_COUNTER_INCR(ev) (ev)->ev_count++

EVCNT_ATTACH_STATIC(udp_hwcsum_bad);

EVCNT_ATTACH_STATIC(udp_hwcsum_ok);

EVCNT_ATTACH_STATIC(udp_hwcsum_data);

EVCNT_ATTACH_STATIC(udp_swcsum);

#endif /* defined(INET) */

#if defined(INET6)

struct evcnt udp6_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "udp6", "hwcsum bad");

struct evcnt udp6_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "udp6", "hwcsum ok");

struct evcnt udp6_hwcsum_data = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "udp6", "hwcsum data");

struct evcnt udp6_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "udp6", "swcsum");

EVCNT_ATTACH_STATIC(udp6_hwcsum_bad);

EVCNT_ATTACH_STATIC(udp6_hwcsum_ok);

EVCNT_ATTACH_STATIC(udp6_hwcsum_data);

EVCNT_ATTACH_STATIC(udp6_swcsum);

#endif /* defined(INET6) */

#define UDP_CSUM_COUNTER_INCR(ev) (ev)->ev_count++

#else

Line 382 udp_input(struct mbuf *m, ...)

Line 399 udp_input(struct mbuf *m, ...)

bcopy(&ip->ip_dst, &dst.sin_addr, sizeof(dst.sin_addr));

dst.sin_port = uh->uh_dport;

n = udp4_realinput(&src, &dst, m, iphlen);

if ((n = udp4_realinput(&src, &dst, &m, iphlen)) == -1) {

udpstat.udps_hdrops++;

return;

}

#ifdef INET6

if (IN_MULTICAST(ip->ip_dst.s_addr) || n == 0) {

struct sockaddr_in6 src6, dst6;

Line 442 static int

Line 462 static int

udp6_input_checksum(struct mbuf *m, const struct udphdr *uh, int off, int len)

{

* XXX it's better to record and check if this mbuf is

* already checked.

if (__predict_false((m->m_flags & M_LOOP) && !udp_do_loopback_cksum)) {

goto good;

}

Line 449 udp6_input_checksum(struct mbuf *m, cons

Line 474 udp6_input_checksum(struct mbuf *m, cons

udp6stat.udp6s_nosum++;

goto bad;

}

if (in6_cksum(m, IPPROTO_UDP, off, len) != 0) {

switch (m->m_pkthdr.csum_flags &

((m->m_pkthdr.rcvif->if_csum_flags_rx & M_CSUM_UDPv6) |

M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {

case M_CSUM_UDPv6|M_CSUM_TCP_UDP_BAD:

UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_bad);

udp6stat.udp6s_badsum++;

goto bad;

#if 0 /* notyet */

case M_CSUM_UDPv6|M_CSUM_DATA:

#endif

case M_CSUM_UDPv6:

/* Checksum was okay. */

UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_ok);

break;

default:

* Need to compute it ourselves. Maybe skip checksum

* on loopback interfaces.

UDP_CSUM_COUNTER_INCR(&udp6_swcsum);

if (in6_cksum(m, IPPROTO_UDP, off, len) != 0) {

udp6stat.udp6s_badsum++;

goto bad;

}

good:

Line 523 udp6_input(struct mbuf **mp, int *offp,

Line 573 udp6_input(struct mbuf **mp, int *offp,

* Construct source and dst sockaddrs.

* Note that ifindex (s6_addr16[1]) is already filled.

bzero(&src, sizeof(src));

src.sin6_family = AF_INET6;

src.sin6_len = sizeof(struct sockaddr_in6);

/* KAME hack: recover scopeid */

src.sin6_addr = ip6->ip6_src;

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

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 */

dst.sin6_addr = ip6->ip6_dst;

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

dst.sin6_port = uh->uh_dport;

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

Line 659 udp6_sendup(struct mbuf *m, int off /* o

Line 706 udp6_sendup(struct mbuf *m, int off /* o

#ifdef INET

static int

udp4_realinput(struct sockaddr_in *src, struct sockaddr_in *dst,

struct mbuf *m, int off /* offset of udphdr */)

struct mbuf **mp, int off /* offset of udphdr */)

{

u_int16_t *sport, *dport;

int rcvcnt;

struct in_addr *src4, *dst4;

struct inpcb_hdr *inph;

struct inpcb *inp;

struct mbuf *m = *mp;

rcvcnt = 0;

off += sizeof(struct udphdr); /* now, offset of payload */

Line 753 udp4_realinput(struct sockaddr_in *src,

Line 801 udp4_realinput(struct sockaddr_in *src,

if (inp->inp_flags & INP_ESPINUDP_ALL) {

struct sockaddr *sa = (struct sockaddr *)src;

if (udp4_espinudp(m, off, sa, inp->inp_socket) != 0) {

switch(udp4_espinudp(mp, off, sa, inp->inp_socket)) {

case -1: /* Error, m was freeed */

rcvcnt = -1;

goto bad;

break;

case 1: /* ESP over UDP */

rcvcnt++;

goto bad;

}

break;

/* Normal UDP processing will take place */

case 0: /* plain UDP */

default: /* Unexpected */

* Normal UDP processing will take place

* m may have changed.

m = *mp;

break;

}

#endif

Line 778 udp6_realinput(int af, struct sockaddr_i

Line 840 udp6_realinput(int af, struct sockaddr_i

{

u_int16_t sport, dport;

int rcvcnt;

struct in6_addr src6, dst6;

struct in6_addr src6, *dst6;

const struct in_addr *dst4;

struct inpcb_hdr *inph;

struct in6pcb *in6p;

Line 791 udp6_realinput(int af, struct sockaddr_i

Line 853 udp6_realinput(int af, struct sockaddr_i

if (src->sin6_family != AF_INET6 || dst->sin6_family != AF_INET6)

goto bad;

in6_embedscope(&src6, src, NULL, NULL);

src6 = src->sin6_addr;

if (sa6_recoverscope(src) != 0) {

/* XXX: should be impossible. */

goto bad;

}

sport = src->sin6_port;

in6_embedscope(&dst6, dst, NULL, NULL);

dport = dst->sin6_port;

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

dst6 = &dst->sin6_addr;

if (IN6_IS_ADDR_MULTICAST(&dst6) ||

if (IN6_IS_ADDR_MULTICAST(dst6) ||

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

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

Line 830 udp6_realinput(int af, struct sockaddr_i

Line 897 udp6_realinput(int af, struct sockaddr_i

if (in6p->in6p_lport != dport)

continue;

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

if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &dst6))

if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr,

dst6))

continue;

} else {

if (IN6_IS_ADDR_V4MAPPED(&dst6) &&

if (IN6_IS_ADDR_V4MAPPED(dst6) &&

(in6p->in6p_flags & IN6P_IPV6_V6ONLY))

continue;

}

Line 867 udp6_realinput(int af, struct sockaddr_i

Line 935 udp6_realinput(int af, struct sockaddr_i

* Locate pcb for datagram.

in6p = in6_pcblookup_connect(&udbtable, &src6, sport,

in6p = in6_pcblookup_connect(&udbtable, &src6, sport, dst6,

&dst6, dport, 0);

dport, 0);

if (in6p == 0) {

++udpstat.udps_pcbhashmiss;

in6p = in6_pcblookup_bind(&udbtable, &dst6, dport, 0);

in6p = in6_pcblookup_bind(&udbtable, dst6, dport, 0);

if (in6p == 0)

return rcvcnt;

}

Line 1108 int udp_recvspace = 40 * (1024 + sizeof(

Line 1176 int udp_recvspace = 40 * (1024 + sizeof(

/*ARGSUSED*/

int

udp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,

struct mbuf *control, struct proc *p)

struct mbuf *control, struct lwp *l)

{

struct inpcb *inp;

struct proc *p;

int s;

int error = 0;

p = l ? l->l_proc : NULL;

if (req == PRU_CONTROL)

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

(struct ifnet *)control, p));

Line 1177 udp_usrreq(struct socket *so, int req, s

Line 1247 udp_usrreq(struct socket *so, int req, s

break;

case PRU_CONNECT:

error = in_pcbconnect(inp, nam);

error = in_pcbconnect(inp, nam, p);

if (error)

break;

soisconnected(so);

Line 1219 udp_usrreq(struct socket *so, int req, s

Line 1289 udp_usrreq(struct socket *so, int req, s

error = EISCONN;

goto die;

}

error = in_pcbconnect(inp, nam);

error = in_pcbconnect(inp, nam, p);

if (error)

goto die;

} else {

Line 1333 SYSCTL_SETUP(sysctl_net_inet_udp_setup,

Line 1403 SYSCTL_SETUP(sysctl_net_inet_udp_setup,

sysctl_inpcblist, 0, &udbtable, 0,

CTL_NET, PF_INET, IPPROTO_UDP, CTL_CREATE,

CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT,

CTLTYPE_STRUCT, "stats",

SYSCTL_DESCR("UDP statistics"),

NULL, 0, &udpstat, sizeof(udpstat),

CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_STATS,

CTL_EOL);

}

#endif

Line 1341 SYSCTL_SETUP(sysctl_net_inet_udp_setup,

Line 1418 SYSCTL_SETUP(sysctl_net_inet_udp_setup,

* Returns:

* 1 if the packet was processed

* 0 if normal UDP processing should take place

* -1 if an error occurent and m was freed

static int

udp4_espinudp(m, off, src, so)

udp4_espinudp(mp, off, src, so)

struct mbuf *m;

struct mbuf **mp;

int off;

struct sockaddr *src;

struct socket *so;

Line 1360 udp4_espinudp(m, off, src, so)

Line 1438 udp4_espinudp(m, off, src, so)

struct m_tag *tag;

struct udphdr *udphdr;

u_int16_t sport, dport;

struct mbuf *m = *mp;

* Collapse the mbuf chain if the first mbuf is too short

Line 1370 udp4_espinudp(m, off, src, so)

Line 1449 udp4_espinudp(m, off, src, so)

minlen = m->m_pkthdr.len;

if (m->m_len < minlen) {

if ((m = m_pullup(m, minlen)) == NULL) {

if ((*mp = m_pullup(m, minlen)) == NULL) {

printf("udp4_espinudp: m_pullup failed\n");

return 0;

return -1;

}

m = *mp;

}

len = m->m_len - off;

Line 1400 udp4_espinudp(m, off, src, so)

Line 1480 udp4_espinudp(m, off, src, so)

}

if (inp->inp_flags & INP_ESPINUDP_NON_IKE) {

u_int64_t *st = (u_int64_t *)data;

u_int32_t *st = (u_int32_t *)data;

if ((len <= sizeof(u_int64_t) + sizeof(struct esp))

|| (*st != 0))

|| ((st[0] | st[1]) != 0))

return 0; /* Normal UDP processing */

skip = sizeof(struct udphdr) + sizeof(u_int64_t);

Line 1466 udp4_espinudp(m, off, src, so)

Line 1546 udp4_espinudp(m, off, src, so)

((u_int16_t *)(tag + 1))[1] = dport;

m_tag_prepend(n, tag);

#ifdef FAST_IPSEC

ipsec4_common_input(n, iphdrlen);

#else

esp4_input(n, iphdrlen);

#endif

/* We handled it, it shoudln't be handled by UDP */

return 1;

CVSweb <webmaster@jp.NetBSD.org>