Subversion Repositories openrisc

//==========================================================================

//

//      src/sys/netinet/udp_usrreq.c

//

//==========================================================================

//####BSDCOPYRIGHTBEGIN####

//

// -------------------------------------------

//

// Portions of this software may have been derived from OpenBSD, 

// FreeBSD or other sources, and are covered by the appropriate

// copyright disclaimers included herein.

//

// Portions created by Red Hat are

// Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.

//

// -------------------------------------------

//

//####BSDCOPYRIGHTEND####

//==========================================================================

/*

 * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995

 *      The Regents of the University of California.  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. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *      This product includes software developed by the University of

 *      California, Berkeley and its contributors.

 * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.

 *

 *      @(#)udp_usrreq.c        8.6 (Berkeley) 5/23/95

 * $FreeBSD: src/sys/netinet/udp_usrreq.c,v 1.64.2.13 2001/08/08 18:59:54 ghelmer Exp $

 */

#include <sys/param.h>

#include <sys/malloc.h>

#include <sys/mbuf.h>

#include <sys/domain.h>

#include <sys/protosw.h>

#include <sys/socket.h>

#include <sys/socketvar.h>

#include <net/if.h>

#include <net/route.h>

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#ifdef INET6

#include <netinet/ip6.h>

#endif

#include <netinet/in_pcb.h>

#include <netinet/in_var.h>

#include <netinet/ip_var.h>

#ifdef INET6

#include <netinet6/ip6_var.h>

#endif

#include <netinet/ip_icmp.h>

#include <netinet/icmp_var.h>

#include <netinet/udp.h>

#include <netinet/udp_var.h>

#ifdef IPSEC

#include <netinet6/ipsec.h>

#endif /*IPSEC*/

/*

 * UDP protocol implementation.

 * Per RFC 768, August, 1980.

 */

#ifndef COMPAT_42

int     udpcksum = 1;

#else

int     udpcksum = 0;            /* XXX */

#endif

int     log_in_vain = 0;

static int      blackhole = 0;

struct  inpcbhead udb;          /* from udp_var.h */

#define udb6    udb  /* for KAME src sync over BSD*'s */

struct  inpcbinfo udbinfo;

#ifndef UDBHASHSIZE

#define UDBHASHSIZE 16

#endif

struct  udpstat udpstat;        /* from udp_var.h */

static struct   sockaddr_in udp_in = { sizeof(udp_in), AF_INET };

#ifdef INET6

struct udp_in6 {

        struct sockaddr_in6     uin6_sin;

        u_char                  uin6_init_done : 1;

} udp_in6 = {

        { sizeof(udp_in6.uin6_sin), AF_INET6 },

};

struct udp_ip6 {

        struct ip6_hdr          uip6_ip6;

        u_char                  uip6_init_done : 1;

} udp_ip6;

#endif /* INET6 */

static void udp_append __P((struct inpcb *last, struct ip *ip,

                            struct mbuf *n, int off));

#ifdef INET6

static void ip_2_ip6_hdr __P((struct ip6_hdr *ip6, struct ip *ip));

#endif

static int udp_detach __P((struct socket *so));

static  int udp_output __P((struct inpcb *, struct mbuf *, struct sockaddr *,

                            struct mbuf *, struct proc *));

void

udp_init()

{

        LIST_INIT(&udb);

        udbinfo.listhead = &udb;

        udbinfo.hashbase = hashinit(UDBHASHSIZE, M_PCB, &udbinfo.hashmask);

        udbinfo.porthashbase = hashinit(UDBHASHSIZE, M_PCB,

                                        &udbinfo.porthashmask);

        udbinfo.ipi_zone = zinit("udpcb", sizeof(struct inpcb), maxsockets,

                                 ZONE_INTERRUPT, 0);

}

void

udp_input(m, off)

        register struct mbuf *m;

        int off;

{

        int iphlen = off;

        register struct ip *ip;

        register struct udphdr *uh;

        register struct inpcb *inp;

        struct mbuf *opts = 0;

#ifdef INET6

        struct ip6_recvpktopts opts6;

#endif 

        int len;

        struct ip save_ip;

        struct sockaddr *append_sa;

        udpstat.udps_ipackets++;

#ifdef INET6

        bzero(&opts6, sizeof(opts6));

#endif

        /*

         * Strip IP options, if any; should skip this,

         * make available to user, and use on returned packets,

         * but we don't yet have a way to check the checksum

         * with options still present.

         */

        if (iphlen > sizeof (struct ip)) {

                ip_stripoptions(m, (struct mbuf *)0);

                iphlen = sizeof(struct ip);

        }

        /*

         * Get IP and UDP header together in first mbuf.

         */

        ip = mtod(m, struct ip *);

#ifndef PULLDOWN_TEST

        if (m->m_len < iphlen + sizeof(struct udphdr)) {

                if ((m = m_pullup(m, iphlen + sizeof(struct udphdr))) == 0) {

                        udpstat.udps_hdrops++;

                        return;

                }

                ip = mtod(m, struct ip *);

        }

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

#else

        IP6_EXTHDR_GET(uh, struct udphdr *, m, iphlen, sizeof(struct udphdr));

        if (!uh) {

                udpstat.udps_hdrops++;

                return;

        }

#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_short)uh->uh_ulen);

        if (ip->ip_len != len) {

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

                        udpstat.udps_badlen++;

                        goto bad;

                }

                m_adj(m, len - ip->ip_len);

                /* ip->ip_len = len; */

        }

        /*

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

         * for sending an ICMP error message in response.

         */

        save_ip = *ip;

        /*

         * Checksum extended UDP header and data.

         */

        if (uh->uh_sum) {

                if (m->m_pkthdr.csum_flags & CSUM_DATA_VALID) {

                        if (m->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR)

                                uh->uh_sum = m->m_pkthdr.csum_data;

                        else

                                uh->uh_sum = in_pseudo(ip->ip_src.s_addr,

                                    ip->ip_dst.s_addr, htonl((u_short)len +

                                    m->m_pkthdr.csum_data + IPPROTO_UDP));

                        uh->uh_sum ^= 0xffff;

                } else {

                        char b[9];

                        bcopy(((struct ipovly *)ip)->ih_x1, b, 9);

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

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

                        uh->uh_sum = in_cksum(m, len + sizeof (struct ip));

                        bcopy(b, ((struct ipovly *)ip)->ih_x1, 9);

                }

                if (uh->uh_sum) {

                        udpstat.udps_badsum++;

                        m_freem(m);

                        return;

                }

        } else

                udpstat.udps_nosum++;

        if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) ||

            in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) {

                struct inpcb *last;

                /*

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

                 * for which the local and remote addresses and ports match

                 * those of the incoming datagram.  This allows more than

                 * one process to receive multi/broadcasts on the same port.

                 * (This really ought to be done for unicast datagrams as

                 * well, but that would cause problems with existing

                 * applications that open both address-specific sockets and

                 * a wildcard socket listening to the same port -- they would

                 * end up receiving duplicates of every unicast datagram.

                 * Those applications open the multiple sockets to overcome an

                 * inadequacy of the UDP socket interface, but for backwards

                 * compatibility we avoid the problem here rather than

                 * fixing the interface.  Maybe 4.5BSD will remedy this?)

                 */

                /*

                 * Construct sockaddr format source address.

                 */

                udp_in.sin_port = uh->uh_sport;

                udp_in.sin_addr = ip->ip_src;

                /*

                 * Locate pcb(s) for datagram.

                 * (Algorithm copied from raw_intr().)

                 */

                last = NULL;

#ifdef INET6

                udp_in6.uin6_init_done = udp_ip6.uip6_init_done = 0;

#endif

                LIST_FOREACH(inp, &udb, inp_list) {

#ifdef INET6

                        if ((inp->inp_vflag & INP_IPV4) == 0)

                                continue;

#endif

                        if (inp->inp_lport != uh->uh_dport)

                                continue;

                        if (inp->inp_laddr.s_addr != INADDR_ANY) {

                                if (inp->inp_laddr.s_addr !=

                                    ip->ip_dst.s_addr)

                                        continue;

                        }

                        if (inp->inp_faddr.s_addr != INADDR_ANY) {

                                if (inp->inp_faddr.s_addr !=

                                    ip->ip_src.s_addr ||

                                    inp->inp_fport != uh->uh_sport)

                                        continue;

                        }

                        if (last != NULL) {

                                struct mbuf *n;

#ifdef IPSEC

                                /* check AH/ESP integrity. */

                                if (ipsec4_in_reject_so(m, last->inp_socket))

                                        ipsecstat.in_polvio++;

                                        /* do not inject data to pcb */

                                else

#endif /*IPSEC*/

                                if ((n = m_copy(m, 0, M_COPYALL)) != NULL)

                                        udp_append(last, ip, n,

                                                   iphlen +

                                                   sizeof(struct udphdr));

                        }

                        last = inp;

                        /*

                         * Don't look for additional matches if this one does

                         * not have either the SO_REUSEPORT or SO_REUSEADDR

                         * socket options set.  This heuristic avoids searching

                         * through all pcbs in the common case of a non-shared

                         * port.  It * assumes that an application will never

                         * clear these options after setting them.

                         */

                        if ((last->inp_socket->so_options&(SO_REUSEPORT|SO_REUSEADDR)) == 0)

                                break;

                }

                if (last == NULL) {

                        /*

                         * No matching pcb found; discard datagram.

                         * (No need to send an ICMP Port Unreachable

                         * for a broadcast or multicast datgram.)

                         */

                        udpstat.udps_noportbcast++;

                        goto bad;

                }

#ifdef IPSEC

                /* check AH/ESP integrity. */

                if (ipsec4_in_reject_so(m, last->inp_socket)) {

                        ipsecstat.in_polvio++;

                        goto bad;

                }

#endif /*IPSEC*/

                udp_append(last, ip, m, iphlen + sizeof(struct udphdr));

                return;

        }

        /*

         * Locate pcb for datagram.

         */

        inp = in_pcblookup_hash(&udbinfo, ip->ip_src, uh->uh_sport,

            ip->ip_dst, uh->uh_dport, 1, m->m_pkthdr.rcvif);

        if (inp == NULL) {

                if (log_in_vain) {

                        char buf[4*sizeof "123"];

                        strcpy(buf, inet_ntoa(ip->ip_dst));

                        log(LOG_INFO,

                            "Connection attempt to UDP %s:%d from %s:%d\n",

                            buf, ntohs(uh->uh_dport), inet_ntoa(ip->ip_src),

                            ntohs(uh->uh_sport));

                }

                udpstat.udps_noport++;

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

                        udpstat.udps_noportbcast++;

                        goto bad;

                }

#ifdef ICMP_BANDLIM

                if (badport_bandlim(BANDLIM_ICMP_UNREACH) < 0)

                        goto bad;

#endif

                if (blackhole)

                        goto bad;

                *ip = save_ip;

                ip->ip_len += iphlen;

                icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT, 0, 0);

                return;

        }

#ifdef IPSEC

        if (ipsec4_in_reject_so(m, inp->inp_socket)) {

                ipsecstat.in_polvio++;

                goto bad;

        }

#endif /*IPSEC*/

        /*

         * Construct sockaddr format source address.

         * Stuff source address and datagram in user buffer.

         */

        udp_in.sin_port = uh->uh_sport;

        udp_in.sin_addr = ip->ip_src;

        if (inp->inp_flags & INP_CONTROLOPTS

            || inp->inp_socket->so_options & SO_TIMESTAMP) {

#ifdef INET6

                if (inp->inp_vflag & INP_IPV6) {

                        int savedflags;

                        ip_2_ip6_hdr(&udp_ip6.uip6_ip6, ip);

                        savedflags = inp->inp_flags;

                        inp->inp_flags &= ~INP_UNMAPPABLEOPTS;

                        ip6_savecontrol(inp, &udp_ip6.uip6_ip6, m,

                                        &opts6, NULL);

                        inp->inp_flags = savedflags;

                } else

#endif

                ip_savecontrol(inp, &opts, ip, m);

        }

        m_adj(m, iphlen + sizeof(struct udphdr));

#ifdef INET6

        if (inp->inp_vflag & INP_IPV6) {

                in6_sin_2_v4mapsin6(&udp_in, &udp_in6.uin6_sin);

                append_sa = (struct sockaddr *)&udp_in6;

                opts = opts6.head;

        } else

#endif

        append_sa = (struct sockaddr *)&udp_in;

        if (sbappendaddr(&inp->inp_socket->so_rcv, append_sa, m, opts) == 0) {

                udpstat.udps_fullsock++;

                goto bad;

        }

        sorwakeup(inp->inp_socket);

        return;

bad:

        m_freem(m);

        if (opts)

                m_freem(opts);

        return;

}

#ifdef INET6

static void

ip_2_ip6_hdr(ip6, ip)

        struct ip6_hdr *ip6;

        struct ip *ip;

{

        bzero(ip6, sizeof(*ip6));

        ip6->ip6_vfc = IPV6_VERSION;

        ip6->ip6_plen = ip->ip_len;

        ip6->ip6_nxt = ip->ip_p;

        ip6->ip6_hlim = ip->ip_ttl;

        ip6->ip6_src.s6_addr32[2] = ip6->ip6_dst.s6_addr32[2] =

                IPV6_ADDR_INT32_SMP;

        ip6->ip6_src.s6_addr32[3] = ip->ip_src.s_addr;

        ip6->ip6_dst.s6_addr32[3] = ip->ip_dst.s_addr;

}

#endif

/*

 * subroutine of udp_input(), mainly for source code readability.

 * caller must properly init udp_ip6 and udp_in6 beforehand.

 */

static void

udp_append(last, ip, n, off)

        struct inpcb *last;

        struct ip *ip;

        struct mbuf *n;

        int off;

{

        struct sockaddr *append_sa;

        struct mbuf *opts = 0;

#ifdef INET6

        struct ip6_recvpktopts opts6;

        bzero(&opts6, sizeof(opts6));

#endif

        if (last->inp_flags & INP_CONTROLOPTS ||

            last->inp_socket->so_options & SO_TIMESTAMP) {

#ifdef INET6

                if (last->inp_vflag & INP_IPV6) {

                        int savedflags;

                        if (udp_ip6.uip6_init_done == 0) {

                                ip_2_ip6_hdr(&udp_ip6.uip6_ip6, ip);

                                udp_ip6.uip6_init_done = 1;

                        }

                        savedflags = last->inp_flags;

                        last->inp_flags &= ~INP_UNMAPPABLEOPTS;

                        ip6_savecontrol(last, &udp_ip6.uip6_ip6, n,

                                        &opts6, NULL);

                        last->inp_flags = savedflags;

                } else

#endif

                ip_savecontrol(last, &opts, ip, n);

        }

#ifdef INET6

        if (last->inp_vflag & INP_IPV6) {

                if (udp_in6.uin6_init_done == 0) {

                        in6_sin_2_v4mapsin6(&udp_in, &udp_in6.uin6_sin);

                        udp_in6.uin6_init_done = 1;

                }

                append_sa = (struct sockaddr *)&udp_in6.uin6_sin;

                opts = opts6.head;

        } else

#endif

        append_sa = (struct sockaddr *)&udp_in;

        m_adj(n, off);

        if (sbappendaddr(&last->inp_socket->so_rcv, append_sa, n, opts) == 0) {

                m_freem(n);

                if (opts)

                        m_freem(opts);

                udpstat.udps_fullsock++;

        } else

                sorwakeup(last->inp_socket);

}

/*

 * Notify a udp user of an asynchronous error;

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

 */

void

udp_notify(inp, _errno)

        register struct inpcb *inp;

        int _errno;

{

        inp->inp_socket->so_error = _errno;

        sorwakeup(inp->inp_socket);

        sowwakeup(inp->inp_socket);

}

void

udp_ctlinput(cmd, sa, vip)

        int cmd;

        struct sockaddr *sa;

        void *vip;

{

        struct ip *ip = vip;

        struct udphdr *uh;

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

        struct in_addr faddr;

        struct inpcb *inp;

        int s;

        faddr = ((struct sockaddr_in *)sa)->sin_addr;

        if (sa->sa_family != AF_INET || faddr.s_addr == INADDR_ANY)

                return;

        if (PRC_IS_REDIRECT(cmd)) {

                ip = 0;

                notify = in_rtchange;

        } else if (cmd == PRC_HOSTDEAD)

                ip = 0;

        else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0)

                return;

        if (ip) {

                s = splnet();

                uh = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));

                inp = in_pcblookup_hash(&udbinfo, faddr, uh->uh_dport,

                    ip->ip_src, uh->uh_sport, 0, NULL);

                if (inp != NULL && inp->inp_socket != NULL)

                        (*notify)(inp, inetctlerrmap[cmd]);

                splx(s);

        } else

                in_pcbnotifyall(&udb, faddr, inetctlerrmap[cmd], notify);

}

static int

udp_output(inp, m, addr, control, p)

        register struct inpcb *inp;

        struct mbuf *m;

        struct sockaddr *addr;

        struct mbuf *control;

        struct proc *p;

{

        register struct udpiphdr *ui;

        register int len = m->m_pkthdr.len;

        struct in_addr laddr;

        struct sockaddr_in *sin;

        int s = 0, error = 0;

        if (control)

                m_freem(control);               /* XXX */

        if (len + sizeof(struct udpiphdr) > IP_MAXPACKET) {

                error = EMSGSIZE;

                goto release;

        }

        if (addr) {

                sin = (struct sockaddr_in *)addr;

                laddr = inp->inp_laddr;

                if (inp->inp_faddr.s_addr != INADDR_ANY) {

                        error = EISCONN;

                        goto release;

                }

                /*

                 * Must block input while temporarily connected.

                 */

                s = splnet();

                error = in_pcbconnect(inp, addr, p);

                if (error) {

                        splx(s);

                        goto release;

                }

        } else {

                if (inp->inp_faddr.s_addr == INADDR_ANY) {

                        error = ENOTCONN;

                        goto release;

                }

        }

        /*

         * Calculate data length and get a mbuf

         * for UDP and IP headers.

         */

        M_PREPEND(m, sizeof(struct udpiphdr), M_DONTWAIT);

        if (m == 0) {

                error = ENOBUFS;

                if (addr)

                        splx(s);

                goto release;

        }

        /*

         * Fill in mbuf with extended UDP header

         * and addresses and length put into network format.

         */

        ui = mtod(m, struct udpiphdr *);

        bzero(ui->ui_x1, sizeof(ui->ui_x1));    /* XXX still needed? */

        ui->ui_pr = IPPROTO_UDP;

        ui->ui_src = inp->inp_laddr;

        ui->ui_dst = inp->inp_faddr;

        ui->ui_sport = inp->inp_lport;

        ui->ui_dport = inp->inp_fport;

        ui->ui_ulen = htons((u_short)len + sizeof(struct udphdr));

        /*

         * Set up checksum and output datagram.

         */

        if (udpcksum) {

                ui->ui_sum = in_pseudo(ui->ui_src.s_addr, ui->ui_dst.s_addr,

                    htons((u_short)len + sizeof(struct udphdr) + IPPROTO_UDP));

                m->m_pkthdr.csum_flags = CSUM_UDP;

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

        } else {

                ui->ui_sum = 0;

        }

        ((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;

        ((struct ip *)ui)->ip_ttl = inp->inp_ip_ttl;    /* XXX */

        ((struct ip *)ui)->ip_tos = inp->inp_ip_tos;    /* XXX */

        udpstat.udps_opackets++;

#ifdef IPSEC

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

                error = ENOBUFS;

                goto release;

        }

#endif /*IPSEC*/

        error = ip_output(m, inp->inp_options, &inp->inp_route,

            (inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST)),

            inp->inp_moptions);

        if (addr) {

                in_pcbdisconnect(inp);

                inp->inp_laddr = laddr; /* XXX rehash? */

                splx(s);

        }

        return (error);

release:

        m_freem(m);

        return (error);

}

u_long  udp_sendspace = 9216;           /* really max datagram size */