![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to udp_usrreq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netinet|
Return to udp_usrreq.c CVS log | Up to [Apple XNU] / XNU / bsd / netinet |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995 ! 24: * The Regents of the University of California. All rights reserved. ! 25: * ! 26: * Redistribution and use in source and binary forms, with or without ! 27: * modification, are permitted provided that the following conditions ! 28: * are met: ! 29: * 1. Redistributions of source code must retain the above copyright ! 30: * notice, this list of conditions and the following disclaimer. ! 31: * 2. Redistributions in binary form must reproduce the above copyright ! 32: * notice, this list of conditions and the following disclaimer in the ! 33: * documentation and/or other materials provided with the distribution. ! 34: * 3. All advertising materials mentioning features or use of this software ! 35: * must display the following acknowledgement: ! 36: * This product includes software developed by the University of ! 37: * California, Berkeley and its contributors. ! 38: * 4. Neither the name of the University nor the names of its contributors ! 39: * may be used to endorse or promote products derived from this software ! 40: * without specific prior written permission. ! 41: * ! 42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 52: * SUCH DAMAGE. ! 53: * ! 54: * @(#)udp_usrreq.c 8.6 (Berkeley) 5/23/95 ! 55: */ ! 56: ! 57: #include <sys/param.h> ! 58: #include <sys/systm.h> ! 59: #include <sys/kernel.h> ! 60: #include <sys/malloc.h> ! 61: #include <sys/mbuf.h> ! 62: #include <sys/protosw.h> ! 63: #include <sys/socket.h> ! 64: #include <sys/socketvar.h> ! 65: #include <sys/sysctl.h> ! 66: #include <sys/syslog.h> ! 67: ! 68: #if ISFB31 ! 69: #include <vm/vm_zone.h> ! 70: #endif ! 71: ! 72: ! 73: #include <net/if.h> ! 74: #include <net/route.h> ! 75: ! 76: #include <netinet/in.h> ! 77: #include <netinet/in_systm.h> ! 78: #include <netinet/ip.h> ! 79: #include <netinet/in_pcb.h> ! 80: #include <netinet/in_var.h> ! 81: #include <netinet/ip_var.h> ! 82: #include <netinet/ip_icmp.h> ! 83: #include <netinet/icmp_var.h> ! 84: #include <netinet/udp.h> ! 85: #include <netinet/udp_var.h> ! 86: ! 87: #define __STDC__ 1 ! 88: /* ! 89: * UDP protocol implementation. ! 90: * Per RFC 768, August, 1980. ! 91: */ ! 92: #ifndef COMPAT_42 ! 93: static int udpcksum = 1; ! 94: #else ! 95: static int udpcksum = 0; /* XXX */ ! 96: #endif ! 97: SYSCTL_INT(_net_inet_udp, UDPCTL_CHECKSUM, checksum, CTLFLAG_RW, ! 98: &udpcksum, 0, ""); ! 99: ! 100: static int log_in_vain = 0; ! 101: SYSCTL_INT(_net_inet_udp, OID_AUTO, log_in_vain, CTLFLAG_RW, ! 102: &log_in_vain, 0, ""); ! 103: ! 104: static struct inpcbhead udb; /* from udp_var.h */ ! 105: struct inpcbinfo udbinfo; ! 106: ! 107: #ifndef UDBHASHSIZE ! 108: #define UDBHASHSIZE 16 ! 109: #endif ! 110: ! 111: static struct udpstat udpstat; /* from udp_var.h */ ! 112: SYSCTL_STRUCT(_net_inet_udp, UDPCTL_STATS, stats, CTLFLAG_RD, ! 113: &udpstat, udpstat, ""); ! 114: ! 115: static struct sockaddr_in udp_in = { sizeof(udp_in), AF_INET }; ! 116: ! 117: static int udp_output __P((struct inpcb *, struct mbuf *, struct sockaddr *, ! 118: struct mbuf *, struct proc *)); ! 119: static void udp_notify __P((struct inpcb *, int)); ! 120: ! 121: void ! 122: udp_init() ! 123: { ! 124: vm_size_t str_size; ! 125: int stat; ! 126: u_char fake_owner; ! 127: struct in_addr laddr; ! 128: struct in_addr faddr; ! 129: u_short lport; ! 130: ! 131: LIST_INIT(&udb); ! 132: udbinfo.listhead = &udb; ! 133: udbinfo.hashbase = hashinit(UDBHASHSIZE, M_PCB, &udbinfo.hashmask); ! 134: udbinfo.porthashbase = hashinit(UDBHASHSIZE, M_PCB, ! 135: &udbinfo.porthashmask); ! 136: #if ISFB31 ! 137: udbinfo.ipi_zone = zinit("udpcb", sizeof(struct inpcb), maxsockets, ! 138: ZONE_INTERRUPT, 0); ! 139: #else ! 140: str_size = (vm_size_t) sizeof(struct inpcb); ! 141: udbinfo.ipi_zone = (void *) zinit(str_size, 80000*str_size, 8192, "inpcb_zone"); ! 142: #endif ! 143: ! 144: udbinfo.last_pcb = 0; ! 145: in_pcb_nat_init(&udbinfo, AF_INET, IPPROTO_UDP, SOCK_DGRAM); ! 146: ! 147: #if 0 ! 148: stat = in_pcb_new_share_client(&udbinfo, &fake_owner); ! 149: kprintf("udp_init in_pcb_new_share_client - stat = %d\n", stat); ! 150: ! 151: laddr.s_addr = 0x11646464; ! 152: faddr.s_addr = 0x11646465; ! 153: ! 154: lport = 1500; ! 155: in_pcb_grab_port(&udbinfo, 0, laddr, &lport, faddr, 1600, 0, fake_owner); ! 156: kprintf("udp_init in_pcb_grab_port - stat = %d\n", stat); ! 157: ! 158: stat = in_pcb_rem_share_client(&udbinfo, fake_owner); ! 159: kprintf("udp_init in_pcb_rem_share_client - stat = %d\n", stat); ! 160: ! 161: stat = in_pcb_new_share_client(&udbinfo, &fake_owner); ! 162: kprintf("udp_init in_pcb_new_share_client(2) - stat = %d\n", stat); ! 163: ! 164: laddr.s_addr = 0x11646464; ! 165: faddr.s_addr = 0x11646465; ! 166: ! 167: lport = 1500; ! 168: stat = in_pcb_grab_port(&udbinfo, 0, laddr, &lport, faddr, 1600, 0, fake_owner); ! 169: kprintf("udp_init in_pcb_grab_port(2) - stat = %d\n", stat); ! 170: #endif ! 171: } ! 172: ! 173: void ! 174: udp_input(m, iphlen) ! 175: register struct mbuf *m; ! 176: int iphlen; ! 177: { ! 178: register struct ip *ip; ! 179: register struct udphdr *uh; ! 180: register struct inpcb *inp; ! 181: struct mbuf *opts = 0; ! 182: int len; ! 183: struct ip save_ip; ! 184: ! 185: udpstat.udps_ipackets++; ! 186: ! 187: /* ! 188: * Strip IP options, if any; should skip this, ! 189: * make available to user, and use on returned packets, ! 190: * but we don't yet have a way to check the checksum ! 191: * with options still present. ! 192: */ ! 193: if (iphlen > sizeof (struct ip)) { ! 194: ip_stripoptions(m, (struct mbuf *)0); ! 195: iphlen = sizeof(struct ip); ! 196: } ! 197: ! 198: /* ! 199: * Get IP and UDP header together in first mbuf. ! 200: */ ! 201: ip = mtod(m, struct ip *); ! 202: if (m->m_len < iphlen + sizeof(struct udphdr)) { ! 203: if ((m = m_pullup(m, iphlen + sizeof(struct udphdr))) == 0) { ! 204: udpstat.udps_hdrops++; ! 205: return; ! 206: } ! 207: ip = mtod(m, struct ip *); ! 208: } ! 209: uh = (struct udphdr *)((caddr_t)ip + iphlen); ! 210: ! 211: /* ! 212: * Make mbuf data length reflect UDP length. ! 213: * If not enough data to reflect UDP length, drop. ! 214: */ ! 215: len = ntohs((u_short)uh->uh_ulen); ! 216: if (ip->ip_len != len) { ! 217: if (len > ip->ip_len || len < sizeof(struct udphdr)) { ! 218: udpstat.udps_badlen++; ! 219: goto bad; ! 220: } ! 221: m_adj(m, len - ip->ip_len); ! 222: /* ip->ip_len = len; */ ! 223: } ! 224: /* ! 225: * Save a copy of the IP header in case we want restore it ! 226: * for sending an ICMP error message in response. ! 227: */ ! 228: save_ip = *ip; ! 229: ! 230: /* ! 231: * Checksum extended UDP header and data. ! 232: */ ! 233: if (uh->uh_sum) { ! 234: bzero(((struct ipovly *)ip)->ih_x1, 9); ! 235: ((struct ipovly *)ip)->ih_len = uh->uh_ulen; ! 236: uh->uh_sum = in_cksum(m, len + sizeof (struct ip)); ! 237: if (uh->uh_sum) { ! 238: udpstat.udps_badsum++; ! 239: m_freem(m); ! 240: return; ! 241: } ! 242: } ! 243: ! 244: if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) || ! 245: in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) { ! 246: struct inpcb *last; ! 247: /* ! 248: * Deliver a multicast or broadcast datagram to *all* sockets ! 249: * for which the local and remote addresses and ports match ! 250: * those of the incoming datagram. This allows more than ! 251: * one process to receive multi/broadcasts on the same port. ! 252: * (This really ought to be done for unicast datagrams as ! 253: * well, but that would cause problems with existing ! 254: * applications that open both address-specific sockets and ! 255: * a wildcard socket listening to the same port -- they would ! 256: * end up receiving duplicates of every unicast datagram. ! 257: * Those applications open the multiple sockets to overcome an ! 258: * inadequacy of the UDP socket interface, but for backwards ! 259: * compatibility we avoid the problem here rather than ! 260: * fixing the interface. Maybe 4.5BSD will remedy this?) ! 261: */ ! 262: ! 263: /* ! 264: * Construct sockaddr format source address. ! 265: */ ! 266: udp_in.sin_port = uh->uh_sport; ! 267: udp_in.sin_addr = ip->ip_src; ! 268: m->m_len -= sizeof (struct udpiphdr); ! 269: m->m_data += sizeof (struct udpiphdr); ! 270: /* ! 271: * Locate pcb(s) for datagram. ! 272: * (Algorithm copied from raw_intr().) ! 273: */ ! 274: last = NULL; ! 275: for (inp = udb.lh_first; inp != NULL; inp = inp->inp_list.le_next) { ! 276: if (inp->inp_lport != uh->uh_dport) ! 277: continue; ! 278: if (inp->inp_laddr.s_addr != INADDR_ANY) { ! 279: if (inp->inp_laddr.s_addr != ! 280: ip->ip_dst.s_addr) ! 281: continue; ! 282: } ! 283: if (inp->inp_faddr.s_addr != INADDR_ANY) { ! 284: if (inp->inp_faddr.s_addr != ! 285: ip->ip_src.s_addr || ! 286: inp->inp_fport != uh->uh_sport) ! 287: continue; ! 288: } ! 289: ! 290: if (last != NULL) { ! 291: struct mbuf *n; ! 292: ! 293: if ((n = m_copy(m, 0, M_COPYALL)) != NULL) { ! 294: if (last->inp_flags & INP_CONTROLOPTS ! 295: || last->inp_socket->so_options & SO_TIMESTAMP) ! 296: ip_savecontrol(last, &opts, ip, n); ! 297: if (sbappendaddr(&last->inp_socket->so_rcv, ! 298: (struct sockaddr *)&udp_in, ! 299: n, opts) == 0) { ! 300: m_freem(n); ! 301: if (opts) ! 302: m_freem(opts); ! 303: udpstat.udps_fullsock++; ! 304: } else ! 305: sorwakeup(last->inp_socket); ! 306: opts = 0; ! 307: } ! 308: } ! 309: last = inp; ! 310: /* ! 311: * Don't look for additional matches if this one does ! 312: * not have either the SO_REUSEPORT or SO_REUSEADDR ! 313: * socket options set. This heuristic avoids searching ! 314: * through all pcbs in the common case of a non-shared ! 315: * port. It * assumes that an application will never ! 316: * clear these options after setting them. ! 317: */ ! 318: if ((last->inp_socket->so_options&(SO_REUSEPORT|SO_REUSEADDR)) == 0) ! 319: break; ! 320: } ! 321: ! 322: if (last == NULL) { ! 323: /* ! 324: * No matching pcb found; discard datagram. ! 325: * (No need to send an ICMP Port Unreachable ! 326: * for a broadcast or multicast datgram.) ! 327: */ ! 328: udpstat.udps_noportbcast++; ! 329: goto bad; ! 330: } ! 331: if (last->inp_flags & INP_CONTROLOPTS ! 332: || last->inp_socket->so_options & SO_TIMESTAMP) ! 333: ip_savecontrol(last, &opts, ip, m); ! 334: if (sbappendaddr(&last->inp_socket->so_rcv, ! 335: (struct sockaddr *)&udp_in, ! 336: m, opts) == 0) { ! 337: udpstat.udps_fullsock++; ! 338: goto bad; ! 339: } ! 340: sorwakeup(last->inp_socket); ! 341: return; ! 342: } ! 343: /* ! 344: * Locate pcb for datagram. ! 345: */ ! 346: inp = in_pcblookup_hash(&udbinfo, ip->ip_src, uh->uh_sport, ! 347: ip->ip_dst, uh->uh_dport, 1); ! 348: if (inp == NULL) { ! 349: if (log_in_vain) { ! 350: char buf[4*sizeof "123"]; ! 351: ! 352: strcpy(buf, inet_ntoa(ip->ip_dst)); ! 353: log(LOG_INFO, ! 354: "Connection attempt to UDP %s:%d from %s:%d\n", ! 355: buf, ntohs(uh->uh_dport), inet_ntoa(ip->ip_src), ! 356: ntohs(uh->uh_sport)); ! 357: } ! 358: udpstat.udps_noport++; ! 359: if (m->m_flags & (M_BCAST | M_MCAST)) { ! 360: udpstat.udps_noportbcast++; ! 361: goto bad; ! 362: } ! 363: *ip = save_ip; ! 364: #if ICMP_BANDLIM ! 365: if (badport_bandlim(0) < 0) ! 366: goto bad; ! 367: #endif ! 368: icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT, 0, 0); ! 369: return; ! 370: } ! 371: ! 372: /* ! 373: * Construct sockaddr format source address. ! 374: * Stuff source address and datagram in user buffer. ! 375: */ ! 376: udp_in.sin_port = uh->uh_sport; ! 377: udp_in.sin_addr = ip->ip_src; ! 378: if (inp->inp_flags & INP_CONTROLOPTS ! 379: || inp->inp_socket->so_options & SO_TIMESTAMP) ! 380: ip_savecontrol(inp, &opts, ip, m); ! 381: iphlen += sizeof(struct udphdr); ! 382: m->m_len -= iphlen; ! 383: m->m_pkthdr.len -= iphlen; ! 384: m->m_data += iphlen; ! 385: if (sbappendaddr(&inp->inp_socket->so_rcv, (struct sockaddr *)&udp_in, ! 386: m, opts) == 0) { ! 387: udpstat.udps_fullsock++; ! 388: goto bad; ! 389: } ! 390: sorwakeup(inp->inp_socket); ! 391: return; ! 392: bad: ! 393: m_freem(m); ! 394: if (opts) ! 395: m_freem(opts); ! 396: } ! 397: ! 398: /* ! 399: * Notify a udp user of an asynchronous error; ! 400: * just wake up so that he can collect error status. ! 401: */ ! 402: static void ! 403: udp_notify(inp, errno) ! 404: register struct inpcb *inp; ! 405: int errno; ! 406: { ! 407: inp->inp_socket->so_error = errno; ! 408: sorwakeup(inp->inp_socket); ! 409: sowwakeup(inp->inp_socket); ! 410: } ! 411: ! 412: void ! 413: udp_ctlinput(cmd, sa, vip) ! 414: int cmd; ! 415: struct sockaddr *sa; ! 416: void *vip; ! 417: { ! 418: register struct ip *ip = vip; ! 419: register struct udphdr *uh; ! 420: ! 421: if (!PRC_IS_REDIRECT(cmd) && ! 422: ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0)) ! 423: return; ! 424: if (ip) { ! 425: uh = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2)); ! 426: in_pcbnotify(&udb, sa, uh->uh_dport, ip->ip_src, uh->uh_sport, ! 427: cmd, udp_notify); ! 428: } else ! 429: in_pcbnotify(&udb, sa, 0, zeroin_addr, 0, cmd, udp_notify); ! 430: } ! 431: ! 432: ! 433: static int ! 434: udp_pcblist SYSCTL_HANDLER_ARGS ! 435: { ! 436: int error, i, n, s; ! 437: struct inpcb *inp, **inp_list; ! 438: inp_gen_t gencnt; ! 439: struct xinpgen xig; ! 440: ! 441: /* ! 442: * The process of preparing the TCB list is too time-consuming and ! 443: * resource-intensive to repeat twice on every request. ! 444: */ ! 445: if (req->oldptr == 0) { ! 446: n = udbinfo.ipi_count; ! 447: req->oldidx = 2 * (sizeof xig) ! 448: + (n + n/8) * sizeof(struct xinpcb); ! 449: return 0; ! 450: } ! 451: ! 452: if (req->newptr != 0) ! 453: return EPERM; ! 454: ! 455: /* ! 456: * OK, now we're committed to doing something. ! 457: */ ! 458: s = splnet(); ! 459: gencnt = udbinfo.ipi_gencnt; ! 460: n = udbinfo.ipi_count; ! 461: splx(s); ! 462: ! 463: xig.xig_len = sizeof xig; ! 464: xig.xig_count = n; ! 465: xig.xig_gen = gencnt; ! 466: xig.xig_sogen = so_gencnt; ! 467: error = SYSCTL_OUT(req, &xig, sizeof xig); ! 468: if (error) ! 469: return error; ! 470: ! 471: inp_list = _MALLOC(n * sizeof *inp_list, M_TEMP, M_WAITOK); ! 472: if (inp_list == 0) { ! 473: return ENOMEM; ! 474: } ! 475: s = splnet(); ! 476: for (inp = udbinfo.listhead->lh_first, i = 0; inp && i < n; ! 477: inp = inp->inp_list.le_next) { ! 478: if (inp->inp_gencnt <= gencnt) ! 479: inp_list[i++] = inp; ! 480: } ! 481: splx(s); ! 482: n = i; ! 483: ! 484: error = 0; ! 485: for (i = 0; i < n; i++) { ! 486: inp = inp_list[i]; ! 487: if (inp->inp_gencnt <= gencnt) { ! 488: struct xinpcb xi; ! 489: xi.xi_len = sizeof xi; ! 490: /* XXX should avoid extra copy */ ! 491: bcopy(inp, &xi.xi_inp, sizeof *inp); ! 492: if (inp->inp_socket) ! 493: sotoxsocket(inp->inp_socket, &xi.xi_socket); ! 494: error = SYSCTL_OUT(req, &xi, sizeof xi); ! 495: } ! 496: } ! 497: if (!error) { ! 498: /* ! 499: * Give the user an updated idea of our state. ! 500: * If the generation differs from what we told ! 501: * her before, she knows that something happened ! 502: * while we were processing this request, and it ! 503: * might be necessary to retry. ! 504: */ ! 505: s = splnet(); ! 506: xig.xig_gen = udbinfo.ipi_gencnt; ! 507: xig.xig_sogen = so_gencnt; ! 508: xig.xig_count = udbinfo.ipi_count; ! 509: splx(s); ! 510: error = SYSCTL_OUT(req, &xig, sizeof xig); ! 511: } ! 512: FREE(inp_list, M_TEMP); ! 513: return error; ! 514: } ! 515: ! 516: SYSCTL_PROC(_net_inet_udp, UDPCTL_PCBLIST, pcblist, CTLFLAG_RD, 0, 0, ! 517: udp_pcblist, "S,xinpcb", "List of active UDP sockets"); ! 518: ! 519: ! 520: ! 521: static int ! 522: udp_output(inp, m, addr, control, p) ! 523: register struct inpcb *inp; ! 524: register struct mbuf *m; ! 525: struct sockaddr *addr; ! 526: struct mbuf *control; ! 527: struct proc *p; ! 528: { ! 529: register struct udpiphdr *ui; ! 530: register int len = m->m_pkthdr.len; ! 531: struct in_addr laddr; ! 532: int s = 0, error = 0; ! 533: ! 534: if (control) ! 535: m_freem(control); /* XXX */ ! 536: ! 537: if (len + sizeof(struct udpiphdr) > IP_MAXPACKET) { ! 538: error = EMSGSIZE; ! 539: goto release; ! 540: } ! 541: ! 542: if (addr) { ! 543: laddr = inp->inp_laddr; ! 544: if (inp->inp_faddr.s_addr != INADDR_ANY) { ! 545: error = EISCONN; ! 546: goto release; ! 547: } ! 548: /* ! 549: * Must block input while temporarily connected. ! 550: */ ! 551: s = splnet(); ! 552: error = in_pcbconnect(inp, addr, p); ! 553: if (error) { ! 554: splx(s); ! 555: goto release; ! 556: } ! 557: } else { ! 558: if (inp->inp_faddr.s_addr == INADDR_ANY) { ! 559: error = ENOTCONN; ! 560: goto release; ! 561: } ! 562: } ! 563: /* ! 564: * Calculate data length and get a mbuf ! 565: * for UDP and IP headers. ! 566: */ ! 567: M_PREPEND(m, sizeof(struct udpiphdr), M_DONTWAIT); ! 568: if (m == 0) { ! 569: error = ENOBUFS; ! 570: if (addr) ! 571: splx(s); ! 572: goto release; ! 573: } ! 574: ! 575: /* ! 576: * Fill in mbuf with extended UDP header ! 577: * and addresses and length put into network format. ! 578: */ ! 579: ui = mtod(m, struct udpiphdr *); ! 580: bzero(ui->ui_x1, sizeof(ui->ui_x1)); ! 581: ui->ui_pr = IPPROTO_UDP; ! 582: ui->ui_len = htons((u_short)len + sizeof (struct udphdr)); ! 583: ui->ui_src = inp->inp_laddr; ! 584: ui->ui_dst = inp->inp_faddr; ! 585: ui->ui_sport = inp->inp_lport; ! 586: ui->ui_dport = inp->inp_fport; ! 587: ui->ui_ulen = ui->ui_len; ! 588: ! 589: /* ! 590: * Stuff checksum and output datagram. ! 591: */ ! 592: ui->ui_sum = 0; ! 593: if (udpcksum) { ! 594: if ((ui->ui_sum = in_cksum(m, sizeof (struct udpiphdr) + len)) == 0) ! 595: ui->ui_sum = 0xffff; ! 596: } ! 597: ((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len; ! 598: ((struct ip *)ui)->ip_ttl = inp->inp_ip_ttl; /* XXX */ ! 599: ((struct ip *)ui)->ip_tos = inp->inp_ip_tos; /* XXX */ ! 600: udpstat.udps_opackets++; ! 601: error = ip_output(m, inp->inp_options, &inp->inp_route, ! 602: inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST), ! 603: inp->inp_moptions); ! 604: ! 605: if (addr) { ! 606: in_pcbdisconnect(inp); ! 607: inp->inp_laddr = laddr; /* XXX rehash? */ ! 608: splx(s); ! 609: } ! 610: return (error); ! 611: ! 612: release: ! 613: m_freem(m); ! 614: return (error); ! 615: } ! 616: ! 617: static u_long udp_sendspace = 9216; /* really max datagram size */ ! 618: /* 40 1K datagrams */ ! 619: SYSCTL_INT(_net_inet_udp, UDPCTL_MAXDGRAM, maxdgram, CTLFLAG_RW, ! 620: &udp_sendspace, 0, ""); ! 621: ! 622: static u_long udp_recvspace = 40 * (1024 + sizeof(struct sockaddr_in)); ! 623: SYSCTL_INT(_net_inet_udp, UDPCTL_RECVSPACE, recvspace, CTLFLAG_RW, ! 624: &udp_recvspace, 0, ""); ! 625: ! 626: static int ! 627: udp_abort(struct socket *so) ! 628: { ! 629: struct inpcb *inp; ! 630: int s; ! 631: ! 632: inp = sotoinpcb(so); ! 633: if (inp == 0) ! 634: return EINVAL; /* ??? possible? panic instead? */ ! 635: soisdisconnected(so); ! 636: s = splnet(); ! 637: in_pcbdetach(inp); ! 638: splx(s); ! 639: return 0; ! 640: } ! 641: ! 642: static int ! 643: udp_attach(struct socket *so, int proto, struct proc *p) ! 644: { ! 645: struct inpcb *inp; ! 646: int s, error; ! 647: ! 648: inp = sotoinpcb(so); ! 649: if (inp != 0) ! 650: return EINVAL; ! 651: ! 652: s = splnet(); ! 653: error = in_pcballoc(so, &udbinfo, p); ! 654: splx(s); ! 655: if (error) ! 656: return error; ! 657: error = soreserve(so, udp_sendspace, udp_recvspace); ! 658: if (error) ! 659: return error; ! 660: ((struct inpcb *) so->so_pcb)->inp_ip_ttl = ip_defttl; ! 661: return 0; ! 662: } ! 663: ! 664: static int ! 665: udp_bind(struct socket *so, struct sockaddr *nam, struct proc *p) ! 666: { ! 667: struct inpcb *inp; ! 668: int s, error; ! 669: ! 670: inp = sotoinpcb(so); ! 671: if (inp == 0) ! 672: return EINVAL; ! 673: s = splnet(); ! 674: error = in_pcbbind(inp, nam, p); ! 675: splx(s); ! 676: return error; ! 677: } ! 678: ! 679: static int ! 680: udp_connect(struct socket *so, struct sockaddr *nam, struct proc *p) ! 681: { ! 682: struct inpcb *inp; ! 683: int s, error; ! 684: ! 685: inp = sotoinpcb(so); ! 686: if (inp == 0) ! 687: return EINVAL; ! 688: if (inp->inp_faddr.s_addr != INADDR_ANY) ! 689: return EISCONN; ! 690: s = splnet(); ! 691: error = in_pcbconnect(inp, nam, p); ! 692: splx(s); ! 693: if (error == 0) ! 694: soisconnected(so); ! 695: return error; ! 696: } ! 697: ! 698: static int ! 699: udp_detach(struct socket *so) ! 700: { ! 701: struct inpcb *inp; ! 702: int s; ! 703: ! 704: inp = sotoinpcb(so); ! 705: if (inp == 0) ! 706: return EINVAL; ! 707: s = splnet(); ! 708: in_pcbdetach(inp); ! 709: splx(s); ! 710: return 0; ! 711: } ! 712: ! 713: static int ! 714: udp_disconnect(struct socket *so) ! 715: { ! 716: struct inpcb *inp; ! 717: int s; ! 718: ! 719: inp = sotoinpcb(so); ! 720: if (inp == 0) ! 721: return EINVAL; ! 722: if (inp->inp_faddr.s_addr == INADDR_ANY) ! 723: return ENOTCONN; ! 724: ! 725: s = splnet(); ! 726: in_pcbdisconnect(inp); ! 727: inp->inp_laddr.s_addr = INADDR_ANY; ! 728: splx(s); ! 729: so->so_state &= ~SS_ISCONNECTED; /* XXX */ ! 730: return 0; ! 731: } ! 732: ! 733: static int ! 734: udp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, ! 735: struct mbuf *control, struct proc *p) ! 736: { ! 737: struct inpcb *inp; ! 738: ! 739: inp = sotoinpcb(so); ! 740: if (inp == 0) { ! 741: m_freem(m); ! 742: return EINVAL; ! 743: } ! 744: return udp_output(inp, m, addr, control, p); ! 745: } ! 746: ! 747: static int ! 748: udp_shutdown(struct socket *so) ! 749: { ! 750: struct inpcb *inp; ! 751: ! 752: inp = sotoinpcb(so); ! 753: if (inp == 0) ! 754: return EINVAL; ! 755: socantsendmore(so); ! 756: return 0; ! 757: } ! 758: ! 759: struct pr_usrreqs udp_usrreqs = { ! 760: udp_abort, pru_accept_notsupp, udp_attach, udp_bind, udp_connect, ! 761: pru_connect2_notsupp, in_control, udp_detach, udp_disconnect, ! 762: pru_listen_notsupp, in_setpeeraddr, pru_rcvd_notsupp, ! 763: pru_rcvoob_notsupp, udp_send, pru_sense_null, udp_shutdown, ! 764: in_setsockaddr, sosend, soreceive, sopoll ! 765: }; ! 766:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.