| version 1.85, 2001/10/15 09:51:15 |
version 1.86, 2001/10/24 06:04:08 |
|
|
| #endif /* UDP_CSUM_COUNTERS */ |
#endif /* UDP_CSUM_COUNTERS */ |
| } |
} |
| |
|
| #ifndef UDP6 |
|
| #ifdef INET |
#ifdef INET |
| void |
void |
| #if __STDC__ |
#if __STDC__ |
|
|
| } |
} |
| #endif |
#endif |
| |
|
| #else /*UDP6*/ |
|
| |
|
| void |
|
| #if __STDC__ |
|
| udp_input(struct mbuf *m, ...) |
|
| #else |
|
| udp_input(m, va_alist) |
|
| struct mbuf *m; |
|
| va_dcl |
|
| #endif |
|
| { |
|
| int proto; |
|
| struct ip *ip; |
|
| struct udphdr *uh; |
|
| struct inpcb *inp; |
|
| struct mbuf *opts = 0; |
|
| int len; |
|
| struct ip save_ip; |
|
| int iphlen; |
|
| va_list ap; |
|
| struct sockaddr_in udpsrc; |
|
| struct sockaddr *sa; |
|
| |
|
| va_start(ap, m); |
|
| iphlen = va_arg(ap, int); |
|
| proto = va_arg(ap, int); |
|
| va_end(ap); |
|
| |
|
| udpstat.udps_ipackets++; |
|
| |
|
| /* |
|
| * 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 *); |
|
| 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); |
|
| |
|
| /* 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)) { |
|
| udpstat.udps_badlen++; |
|
| goto bad; |
|
| } |
|
| m_adj(m, iphlen + len - ip->ip_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) { |
|
| switch (m->m_pkthdr.csum_flags & |
|
| ((m->m_pkthdr.rcvif->if_csum_flags & M_CSUM_UDPv4) | |
|
| M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) { |
|
| case M_CSUM_UDPv4|M_CSUM_TCP_UDP_BAD: |
|
| UDP_CSUM_COUNTER_INCR(&udp_hwcsum_bad); |
|
| goto badcsum; |
|
| |
|
| case M_CSUM_UDPv4|M_CSUM_DATA: |
|
| UDP_CSUM_COUNTER_INCR(&udp_hwcsum_data); |
|
| if ((m->m_pkthdr.csum_data ^ 0xffff) != 0) |
|
| goto badcsum; |
|
| break; |
|
| |
|
| case M_CSUM_UDPv4: |
|
| /* Checksum was okay. */ |
|
| UDP_CSUM_COUNTER_INCR(&udp_hwcsum_ok); |
|
| break; |
|
| |
|
| default: |
|
| /* Need to compute it ourselves. */ |
|
| UDP_CSUM_COUNTER_INCR(&udp_swcsum); |
|
| 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) |
|
| goto badcsum; |
|
| break; |
|
| } |
|
| } |
|
| |
|
| /* |
|
| * Construct sockaddr format source address. |
|
| */ |
|
| udpsrc.sin_family = AF_INET; |
|
| udpsrc.sin_len = sizeof(struct sockaddr_in); |
|
| udpsrc.sin_addr = ip->ip_src; |
|
| udpsrc.sin_port = uh->uh_sport; |
|
| bzero((caddr_t)udpsrc.sin_zero, sizeof(udpsrc.sin_zero)); |
|
| |
|
| if (IN_MULTICAST(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?) |
|
| */ |
|
| |
|
| iphlen += sizeof(struct udphdr); |
|
| /* |
|
| * KAME note: usually we drop udpiphdr from mbuf here. |
|
| * we need udpiphdr for IPsec processing so we do that later. |
|
| */ |
|
| /* |
|
| * Locate pcb(s) for datagram. |
|
| * (Algorithm copied from raw_intr().) |
|
| */ |
|
| last = NULL; |
|
| for (inp = udbtable.inpt_queue.cqh_first; |
|
| inp != (struct inpcb *)&udbtable.inpt_queue; |
|
| inp = inp->inp_queue.cqe_next) { |
|
| if (inp->inp_lport != uh->uh_dport) |
|
| continue; |
|
| if (!in_nullhost(inp->inp_laddr)) { |
|
| if (!in_hosteq(inp->inp_laddr, ip->ip_dst)) |
|
| continue; |
|
| } |
|
| if (!in_nullhost(inp->inp_faddr)) { |
|
| if (!in_hosteq(inp->inp_faddr, ip->ip_src) || |
|
| inp->inp_fport != uh->uh_sport) |
|
| continue; |
|
| } |
|
| |
|
| if (last != NULL) { |
|
| struct mbuf *n; |
|
| |
|
| #ifdef IPSEC |
|
| /* check AH/ESP integrity. */ |
|
| if (last != NULL && ipsec4_in_reject(m, last)) { |
|
| ipsecstat.in_polvio++; |
|
| /* do not inject data to pcb */ |
|
| } else |
|
| #endif /*IPSEC*/ |
|
| if ((n = m_copy(m, 0, M_COPYALL)) != NULL) { |
|
| if (last->inp_flags & INP_CONTROLOPTS |
|
| || last->inp_socket->so_options & |
|
| SO_TIMESTAMP) { |
|
| ip_savecontrol(last, &opts, |
|
| ip, n); |
|
| } |
|
| m_adj(n, iphlen); |
|
| sa = (struct sockaddr *)&udpsrc; |
|
| if (sbappendaddr( |
|
| &last->inp_socket->so_rcv, |
|
| sa, n, opts) == 0) { |
|
| m_freem(n); |
|
| if (opts) |
|
| m_freem(opts); |
|
| udpstat.udps_fullsock++; |
|
| } else |
|
| sorwakeup(last->inp_socket); |
|
| opts = 0; |
|
| } |
|
| } |
|
| 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 (last != NULL && ipsec4_in_reject(m, last)) { |
|
| ipsecstat.in_polvio++; |
|
| goto bad; |
|
| } |
|
| #endif /*IPSEC*/ |
|
| if (last->inp_flags & INP_CONTROLOPTS || |
|
| last->inp_socket->so_options & SO_TIMESTAMP) |
|
| ip_savecontrol(last, &opts, ip, m); |
|
| m->m_len -= iphlen; |
|
| m->m_pkthdr.len -= iphlen; |
|
| m->m_data += iphlen; |
|
| sa = (struct sockaddr *)&udpsrc; |
|
| if (sbappendaddr(&last->inp_socket->so_rcv, sa, m, opts) == 0) { |
|
| udpstat.udps_fullsock++; |
|
| goto bad; |
|
| } |
|
| sorwakeup(last->inp_socket); |
|
| return; |
|
| } |
|
| /* |
|
| * Locate pcb for datagram. |
|
| */ |
|
| inp = in_pcblookup_connect(&udbtable, ip->ip_src, uh->uh_sport, |
|
| ip->ip_dst, uh->uh_dport); |
|
| if (inp == 0) { |
|
| ++udpstat.udps_pcbhashmiss; |
|
| inp = in_pcblookup_bind(&udbtable, ip->ip_dst, uh->uh_dport); |
|
| if (inp == 0) { |
|
| if (m->m_flags & (M_BCAST | M_MCAST)) { |
|
| udpstat.udps_noportbcast++; |
|
| goto bad; |
|
| } |
|
| udpstat.udps_noport++; |
|
| *ip = save_ip; |
|
| #ifdef IPKDB |
|
| if (checkipkdb(&ip->ip_src, |
|
| uh->uh_sport, |
|
| uh->uh_dport, |
|
| m, |
|
| iphlen + sizeof(struct udphdr), |
|
| len - sizeof(struct udphdr))) |
|
| /* It was a debugger connect packet, just drop it now */ |
|
| goto bad; |
|
| #endif |
|
| icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT, 0, 0); |
|
| return; |
|
| } |
|
| } |
|
| #ifdef IPSEC |
|
| if (inp != NULL && ipsec4_in_reject(m, inp)) { |
|
| ipsecstat.in_polvio++; |
|
| goto bad; |
|
| } |
|
| #endif /*IPSEC*/ |
|
| |
|
| /* |
|
| * Stuff source address and datagram in user buffer. |
|
| */ |
|
| if (inp->inp_flags & INP_CONTROLOPTS || |
|
| inp->inp_socket->so_options & SO_TIMESTAMP) |
|
| ip_savecontrol(inp, &opts, ip, m); |
|
| iphlen += sizeof(struct udphdr); |
|
| m->m_len -= iphlen; |
|
| m->m_pkthdr.len -= iphlen; |
|
| m->m_data += iphlen; |
|
| sa = (struct sockaddr *)&udpsrc; |
|
| if (sbappendaddr(&inp->inp_socket->so_rcv, sa, m, opts) == 0) { |
|
| udpstat.udps_fullsock++; |
|
| goto bad; |
|
| } |
|
| sorwakeup(inp->inp_socket); |
|
| return; |
|
| bad: |
|
| m_freem(m); |
|
| if (opts) |
|
| m_freem(opts); |
|
| return; |
|
| |
|
| badcsum: |
|
| udpstat.udps_badsum++; |
|
| m_freem(m); |
|
| } |
|
| #endif /*UDP6*/ |
|
| |
|
| #ifdef INET |
#ifdef INET |
| /* |
/* |
| * Notify a udp user of an asynchronous error; |
* Notify a udp user of an asynchronous error; |
![[BACK]](/icons/back.gif){kind=icon}
Return to udp_usrreq.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / netinet