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.130 and 1.140

version 1.130, 2005/02/12 12:31:07

version 1.140, 2005/08/10 13:05:17

Line 146 int udpcksum = 1;

#else

int udpcksum = 0; /* XXX */

#endif

int udp_do_loopback_cksum = 0;

struct inpcbtable udbtable;

struct udpstat udpstat;

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

Line 186 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 196 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 443 static int

Line 460 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 450 udp6_input_checksum(struct mbuf *m, cons

Line 472 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 932 udp_ctlinput(int cmd, struct sockaddr *s

Line 979 udp_ctlinput(int cmd, struct sockaddr *s

}

int

udp_ctloutput(op, so, level, optname, mp)

int op;

struct socket *so;

int level, optname;

Line 982 udp_ctloutput(op, so, level, optname, mp

Line 1029 udp_ctloutput(op, so, level, optname, mp

error = EINVAL;

goto end;

}

switch(*mtod(m, int *)) {

#ifdef IPSEC_NAT_T

case 0:

Line 993 udp_ctloutput(op, so, level, optname, mp

Line 1040 udp_ctloutput(op, so, level, optname, mp

inp->inp_flags &= ~INP_ESPINUDP_ALL;

inp->inp_flags |= INP_ESPINUDP;

break;

case UDP_ENCAP_ESPINUDP_NON_IKE:

inp->inp_flags &= ~INP_ESPINUDP_ALL;

inp->inp_flags |= INP_ESPINUDP_NON_IKE;

Line 1017 udp_ctloutput(op, so, level, optname, mp

Line 1064 udp_ctloutput(op, so, level, optname, mp

error = EINVAL;

goto end;

break;

}

end:

splx(s);

return error;

}

int

udp_output(struct mbuf *m, ...)

Line 1080 udp_output(struct mbuf *m, ...)

Line 1127 udp_output(struct mbuf *m, ...)

* XXX Cache pseudo-header checksum part for

* XXX "connected" UDP sockets.

* Maybe skip checksums on loopback interfaces.

ui->ui_sum = in_cksum_phdr(ui->ui_src.s_addr,

ui->ui_dst.s_addr, htons((u_int16_t)len +

sizeof(struct udphdr) + IPPROTO_UDP));

if (__predict_true(ro->ro_rt == NULL ||

m->m_pkthdr.csum_flags = M_CSUM_UDPv4;

!(ro->ro_rt->rt_ifp->if_flags &

IFF_LOOPBACK) ||

udp_do_loopback_cksum))

m->m_pkthdr.csum_flags = M_CSUM_UDPv4;

else

m->m_pkthdr.csum_flags = 0;

m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);

} else

ui->ui_sum = 0;

Line 1334 SYSCTL_SETUP(sysctl_net_inet_udp_setup,

Line 1374 SYSCTL_SETUP(sysctl_net_inet_udp_setup,

NULL, 0, &udp_do_loopback_cksum, 0,

CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_LOOPBACKCKSUM,

CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT,

CTLTYPE_STRUCT, "pcblist",

SYSCTL_DESCR("UDP protocol control block list"),

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 1358 udp4_espinudp(m, off, src, so)

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

size_t iphdrlen;

struct ip *ip;

struct mbuf *n;

struct m_tag *tag;

struct udphdr *udphdr;

u_int16_t sport, dport;

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

* The longest case is: UDP + non ESP marker + ESP

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

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

}

len = m->m_len - off;

data = mtod(m, caddr_t) + off;

inp = sotoinpcb(so);

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

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

return 1;

}

* Check that the payload is long enough to hold

* an ESP header and compute the length of encapsulation

* header to remove

if (inp->inp_flags & INP_ESPINUDP) {

u_int32_t *st = (u_int32_t *)data;

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

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

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

|| (*st != 0))

return 0; /* Normal UDP processing */

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

}

* Get the UDP ports. They are handled in network

* order everywhere in IPSEC_NAT_T code.

udphdr = (struct udphdr *)(data - skip);

sport = udphdr->uh_sport;

dport = udphdr->uh_dport;

* Remove the UDP header (and possibly the non ESP marker)

* IP header lendth is iphdrlen

* Before:

* <--- off --->

* +----+------+-----+

* | IP | UDP | ESP |

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

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

ip->ip_p = IPPROTO_ESP;

* Copy the mbuf to avoid multiple free, as both

* esp4_input (which we call) and udp_input (which

* called us) free the mbuf.

if ((n = m_dup(m, 0, M_COPYALL, M_DONTWAIT)) == NULL) {

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

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

return 0;

}

* Add a PACKET_TAG_IPSEC_NAT_T_PORT tag to remember

* the source UDP port. This is required if we want

* to select the right SPD for multiple hosts behind

* same NAT

if ((tag = m_tag_get(PACKET_TAG_IPSEC_NAT_T_PORTS,

sizeof(sport) + sizeof(dport), M_DONTWAIT)) == NULL) {

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

m_freem(n);

return 0;

}

((u_int16_t *)(tag + 1))[0] = sport;

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

m_tag_prepend(n, tag);

esp4_input(n, iphdrlen);

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

CVSweb <webmaster@jp.NetBSD.org>