ip_output.c revision 9383
1/* 2 * Copyright (c) 1982, 1986, 1988, 1990, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)ip_output.c 8.3 (Berkeley) 1/21/94 34 * $Id: ip_output.c,v 1.20 1995/06/13 17:51:14 wollman Exp $ 35 */ 36 37#include <sys/param.h> 38#include <sys/systm.h> 39#include <sys/malloc.h> 40#include <sys/mbuf.h> 41#include <sys/errno.h> 42#include <sys/protosw.h> 43#include <sys/socket.h> 44#include <sys/socketvar.h> 45#include <sys/queue.h> 46 47#include <net/if.h> 48#include <net/route.h> 49 50#include <netinet/in.h> 51#include <netinet/in_systm.h> 52#include <netinet/ip.h> 53#include <netinet/in_pcb.h> 54#include <netinet/in_var.h> 55#include <netinet/ip_var.h> 56 57#include <netinet/ip_fw.h> 58 59#ifdef vax 60#include <machine/mtpr.h> 61#endif 62 63u_short ip_id; 64 65static struct mbuf *ip_insertoptions __P((struct mbuf *, struct mbuf *, int *)); 66static void ip_mloopback 67 __P((struct ifnet *, struct mbuf *, struct sockaddr_in *)); 68 69/* 70 * IP output. The packet in mbuf chain m contains a skeletal IP 71 * header (with len, off, ttl, proto, tos, src, dst). 72 * The mbuf chain containing the packet will be freed. 73 * The mbuf opt, if present, will not be freed. 74 */ 75int 76ip_output(m0, opt, ro, flags, imo) 77 struct mbuf *m0; 78 struct mbuf *opt; 79 struct route *ro; 80 int flags; 81 struct ip_moptions *imo; 82{ 83 register struct ip *ip, *mhip; 84 register struct ifnet *ifp; 85 register struct mbuf *m = m0; 86 register int hlen = sizeof (struct ip); 87 int len, off, error = 0; 88 struct route iproute; 89 struct sockaddr_in *dst; 90 struct in_ifaddr *ia; 91 92#ifdef DIAGNOSTIC 93 if ((m->m_flags & M_PKTHDR) == 0) 94 panic("ip_output no HDR"); 95#endif 96 if (opt) { 97 m = ip_insertoptions(m, opt, &len); 98 hlen = len; 99 } 100 ip = mtod(m, struct ip *); 101 /* 102 * Fill in IP header. 103 */ 104 if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) { 105 ip->ip_v = IPVERSION; 106 ip->ip_off &= IP_DF; 107 ip->ip_id = htons(ip_id++); 108 ip->ip_hl = hlen >> 2; 109 ipstat.ips_localout++; 110 } else { 111 hlen = ip->ip_hl << 2; 112 } 113 /* 114 * Route packet. 115 */ 116 if (ro == 0) { 117 ro = &iproute; 118 bzero((caddr_t)ro, sizeof (*ro)); 119 } 120 dst = (struct sockaddr_in *)&ro->ro_dst; 121 /* 122 * If there is a cached route, 123 * check that it is to the same destination 124 * and is still up. If not, free it and try again. 125 */ 126 if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 || 127 dst->sin_addr.s_addr != ip->ip_dst.s_addr)) { 128 RTFREE(ro->ro_rt); 129 ro->ro_rt = (struct rtentry *)0; 130 } 131 if (ro->ro_rt == 0) { 132 dst->sin_family = AF_INET; 133 dst->sin_len = sizeof(*dst); 134 dst->sin_addr = ip->ip_dst; 135 } 136 /* 137 * If routing to interface only, 138 * short circuit routing lookup. 139 */ 140#define ifatoia(ifa) ((struct in_ifaddr *)(ifa)) 141#define sintosa(sin) ((struct sockaddr *)(sin)) 142 if (flags & IP_ROUTETOIF) { 143 if ((ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == 0 && 144 (ia = ifatoia(ifa_ifwithnet(sintosa(dst)))) == 0) { 145 ipstat.ips_noroute++; 146 error = ENETUNREACH; 147 goto bad; 148 } 149 ifp = ia->ia_ifp; 150 ip->ip_ttl = 1; 151 } else { 152 /* 153 * If this is the case, we probably don't want to allocate 154 * a protocol-cloned route since we didn't get one from the 155 * ULP. This lets TCP do its thing, while not burdening 156 * forwarding or ICMP with the overhead of cloning a route. 157 * Of course, we still want to do any cloning requested by 158 * the link layer, as this is probably required in all cases 159 * for correct operation (as it is for ARP). 160 */ 161 if (ro->ro_rt == 0) 162 rtalloc_ign(ro, RTF_PRCLONING); 163 if (ro->ro_rt == 0) { 164 ipstat.ips_noroute++; 165 error = EHOSTUNREACH; 166 goto bad; 167 } 168 ia = ifatoia(ro->ro_rt->rt_ifa); 169 ifp = ro->ro_rt->rt_ifp; 170 ro->ro_rt->rt_use++; 171 if (ro->ro_rt->rt_flags & RTF_GATEWAY) 172 dst = (struct sockaddr_in *)ro->ro_rt->rt_gateway; 173 } 174 if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) { 175 struct in_multi *inm; 176 177 m->m_flags |= M_MCAST; 178 /* 179 * IP destination address is multicast. Make sure "dst" 180 * still points to the address in "ro". (It may have been 181 * changed to point to a gateway address, above.) 182 */ 183 dst = (struct sockaddr_in *)&ro->ro_dst; 184 /* 185 * See if the caller provided any multicast options 186 */ 187 if (imo != NULL) { 188 ip->ip_ttl = imo->imo_multicast_ttl; 189 if (imo->imo_multicast_ifp != NULL) 190 ifp = imo->imo_multicast_ifp; 191 if (imo->imo_multicast_vif != -1) 192 ip->ip_src.s_addr = 193 ip_mcast_src(imo->imo_multicast_vif); 194 } else 195 ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL; 196 /* 197 * Confirm that the outgoing interface supports multicast. 198 */ 199 if ((imo == NULL) || (imo->imo_multicast_vif == -1)) { 200 if ((ifp->if_flags & IFF_MULTICAST) == 0) { 201 ipstat.ips_noroute++; 202 error = ENETUNREACH; 203 goto bad; 204 } 205 } 206 /* 207 * If source address not specified yet, use address 208 * of outgoing interface. 209 */ 210 if (ip->ip_src.s_addr == INADDR_ANY) { 211 register struct in_ifaddr *ia; 212 213 for (ia = in_ifaddr; ia; ia = ia->ia_next) 214 if (ia->ia_ifp == ifp) { 215 ip->ip_src = IA_SIN(ia)->sin_addr; 216 break; 217 } 218 } 219 220 IN_LOOKUP_MULTI(ip->ip_dst, ifp, inm); 221 if (inm != NULL && 222 (imo == NULL || imo->imo_multicast_loop)) { 223 /* 224 * If we belong to the destination multicast group 225 * on the outgoing interface, and the caller did not 226 * forbid loopback, loop back a copy. 227 */ 228 ip_mloopback(ifp, m, dst); 229 } 230 else { 231 /* 232 * If we are acting as a multicast router, perform 233 * multicast forwarding as if the packet had just 234 * arrived on the interface to which we are about 235 * to send. The multicast forwarding function 236 * recursively calls this function, using the 237 * IP_FORWARDING flag to prevent infinite recursion. 238 * 239 * Multicasts that are looped back by ip_mloopback(), 240 * above, will be forwarded by the ip_input() routine, 241 * if necessary. 242 */ 243 if (ip_mrouter && (flags & IP_FORWARDING) == 0) { 244 /* 245 * Check if rsvp daemon is running. If not, don't 246 * set ip_moptions. This ensures that the packet 247 * is multicast and not just sent down one link 248 * as prescribed by rsvpd. 249 */ 250 if (ip_rsvpd == NULL) 251 imo = NULL; 252 if (ip_mforward(ip, ifp, m, imo) != 0) { 253 m_freem(m); 254 goto done; 255 } 256 } 257 } 258 259 /* 260 * Multicasts with a time-to-live of zero may be looped- 261 * back, above, but must not be transmitted on a network. 262 * Also, multicasts addressed to the loopback interface 263 * are not sent -- the above call to ip_mloopback() will 264 * loop back a copy if this host actually belongs to the 265 * destination group on the loopback interface. 266 */ 267 if (ip->ip_ttl == 0 || ifp->if_flags & IFF_LOOPBACK) { 268 m_freem(m); 269 goto done; 270 } 271 272 goto sendit; 273 } 274#ifndef notdef 275 /* 276 * If source address not specified yet, use address 277 * of outgoing interface. 278 */ 279 if (ip->ip_src.s_addr == INADDR_ANY) 280 ip->ip_src = IA_SIN(ia)->sin_addr; 281#endif 282 /* 283 * Verify that we have any chance at all of being able to queue 284 * the packet or packet fragments 285 */ 286 if ((ifp->if_snd.ifq_len + ip->ip_len / ifp->if_mtu + 1) >= 287 ifp->if_snd.ifq_maxlen) { 288 error = ENOBUFS; 289 goto bad; 290 } 291 292 /* 293 * Look for broadcast address and 294 * and verify user is allowed to send 295 * such a packet. 296 */ 297 if (in_broadcast(dst->sin_addr, ifp)) { 298 if ((ifp->if_flags & IFF_BROADCAST) == 0) { 299 error = EADDRNOTAVAIL; 300 goto bad; 301 } 302 if ((flags & IP_ALLOWBROADCAST) == 0) { 303 error = EACCES; 304 goto bad; 305 } 306 /* don't allow broadcast messages to be fragmented */ 307 if ((u_short)ip->ip_len > ifp->if_mtu) { 308 error = EMSGSIZE; 309 goto bad; 310 } 311 m->m_flags |= M_BCAST; 312 } else 313 m->m_flags &= ~M_BCAST; 314 315sendit: 316 /* 317 * If small enough for interface, can just send directly. 318 */ 319 if ((u_short)ip->ip_len <= ifp->if_mtu) { 320 ip->ip_len = htons((u_short)ip->ip_len); 321 ip->ip_off = htons((u_short)ip->ip_off); 322 ip->ip_sum = 0; 323 ip->ip_sum = in_cksum(m, hlen); 324 error = (*ifp->if_output)(ifp, m, 325 (struct sockaddr *)dst, ro->ro_rt); 326 goto done; 327 } 328 /* 329 * Too large for interface; fragment if possible. 330 * Must be able to put at least 8 bytes per fragment. 331 */ 332 if (ip->ip_off & IP_DF) { 333 error = EMSGSIZE; 334 ipstat.ips_cantfrag++; 335 goto bad; 336 } 337 len = (ifp->if_mtu - hlen) &~ 7; 338 if (len < 8) { 339 error = EMSGSIZE; 340 goto bad; 341 } 342 343 { 344 int mhlen, firstlen = len; 345 struct mbuf **mnext = &m->m_nextpkt; 346 347 /* 348 * Loop through length of segment after first fragment, 349 * make new header and copy data of each part and link onto chain. 350 */ 351 m0 = m; 352 mhlen = sizeof (struct ip); 353 for (off = hlen + len; off < (u_short)ip->ip_len; off += len) { 354 MGETHDR(m, M_DONTWAIT, MT_HEADER); 355 if (m == 0) { 356 error = ENOBUFS; 357 ipstat.ips_odropped++; 358 goto sendorfree; 359 } 360 m->m_data += max_linkhdr; 361 mhip = mtod(m, struct ip *); 362 *mhip = *ip; 363 if (hlen > sizeof (struct ip)) { 364 mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip); 365 mhip->ip_hl = mhlen >> 2; 366 } 367 m->m_len = mhlen; 368 mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF); 369 if (ip->ip_off & IP_MF) 370 mhip->ip_off |= IP_MF; 371 if (off + len >= (u_short)ip->ip_len) 372 len = (u_short)ip->ip_len - off; 373 else 374 mhip->ip_off |= IP_MF; 375 mhip->ip_len = htons((u_short)(len + mhlen)); 376 m->m_next = m_copy(m0, off, len); 377 if (m->m_next == 0) { 378 (void) m_free(m); 379 error = ENOBUFS; /* ??? */ 380 ipstat.ips_odropped++; 381 goto sendorfree; 382 } 383 m->m_pkthdr.len = mhlen + len; 384 m->m_pkthdr.rcvif = (struct ifnet *)0; 385 mhip->ip_off = htons((u_short)mhip->ip_off); 386 mhip->ip_sum = 0; 387 mhip->ip_sum = in_cksum(m, mhlen); 388 *mnext = m; 389 mnext = &m->m_nextpkt; 390 ipstat.ips_ofragments++; 391 } 392 /* 393 * Update first fragment by trimming what's been copied out 394 * and updating header, then send each fragment (in order). 395 */ 396 m = m0; 397 m_adj(m, hlen + firstlen - (u_short)ip->ip_len); 398 m->m_pkthdr.len = hlen + firstlen; 399 ip->ip_len = htons((u_short)m->m_pkthdr.len); 400 ip->ip_off = htons((u_short)(ip->ip_off | IP_MF)); 401 ip->ip_sum = 0; 402 ip->ip_sum = in_cksum(m, hlen); 403sendorfree: 404 for (m = m0; m; m = m0) { 405 m0 = m->m_nextpkt; 406 m->m_nextpkt = 0; 407 if (error == 0) 408 error = (*ifp->if_output)(ifp, m, 409 (struct sockaddr *)dst, ro->ro_rt); 410 else 411 m_freem(m); 412 } 413 414 if (error == 0) 415 ipstat.ips_fragmented++; 416 } 417done: 418 if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt) 419 RTFREE(ro->ro_rt); 420 /* 421 * Count outgoing packet,here we count both our packets and 422 * those we forward. 423 * Here we want to convert ip_len to host byte order when counting 424 * so we set 3rd arg to 1. 425 * This is locally generated packet so it has not 426 * incoming interface. 427 */ 428 if (ip_acct_cnt_ptr!=NULL) 429 (*ip_acct_cnt_ptr)(ip,NULL,ip_acct_chain,1); 430 431 return (error); 432bad: 433 m_freem(m0); 434 goto done; 435} 436 437/* 438 * Insert IP options into preformed packet. 439 * Adjust IP destination as required for IP source routing, 440 * as indicated by a non-zero in_addr at the start of the options. 441 */ 442static struct mbuf * 443ip_insertoptions(m, opt, phlen) 444 register struct mbuf *m; 445 struct mbuf *opt; 446 int *phlen; 447{ 448 register struct ipoption *p = mtod(opt, struct ipoption *); 449 struct mbuf *n; 450 register struct ip *ip = mtod(m, struct ip *); 451 unsigned optlen; 452 453 optlen = opt->m_len - sizeof(p->ipopt_dst); 454 if (optlen + (u_short)ip->ip_len > IP_MAXPACKET) 455 return (m); /* XXX should fail */ 456 if (p->ipopt_dst.s_addr) 457 ip->ip_dst = p->ipopt_dst; 458 if (m->m_flags & M_EXT || m->m_data - optlen < m->m_pktdat) { 459 MGETHDR(n, M_DONTWAIT, MT_HEADER); 460 if (n == 0) 461 return (m); 462 n->m_pkthdr.len = m->m_pkthdr.len + optlen; 463 m->m_len -= sizeof(struct ip); 464 m->m_data += sizeof(struct ip); 465 n->m_next = m; 466 m = n; 467 m->m_len = optlen + sizeof(struct ip); 468 m->m_data += max_linkhdr; 469 (void)memcpy(mtod(m, void *), ip, sizeof(struct ip)); 470 } else { 471 m->m_data -= optlen; 472 m->m_len += optlen; 473 m->m_pkthdr.len += optlen; 474 ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip)); 475 } 476 ip = mtod(m, struct ip *); 477 (void)memcpy(ip + 1, p->ipopt_list, (unsigned)optlen); 478 *phlen = sizeof(struct ip) + optlen; 479 ip->ip_len += optlen; 480 return (m); 481} 482 483/* 484 * Copy options from ip to jp, 485 * omitting those not copied during fragmentation. 486 */ 487int 488ip_optcopy(ip, jp) 489 struct ip *ip, *jp; 490{ 491 register u_char *cp, *dp; 492 int opt, optlen, cnt; 493 494 cp = (u_char *)(ip + 1); 495 dp = (u_char *)(jp + 1); 496 cnt = (ip->ip_hl << 2) - sizeof (struct ip); 497 for (; cnt > 0; cnt -= optlen, cp += optlen) { 498 opt = cp[0]; 499 if (opt == IPOPT_EOL) 500 break; 501 if (opt == IPOPT_NOP) { 502 /* Preserve for IP mcast tunnel's LSRR alignment. */ 503 *dp++ = IPOPT_NOP; 504 optlen = 1; 505 continue; 506 } else 507 optlen = cp[IPOPT_OLEN]; 508 /* bogus lengths should have been caught by ip_dooptions */ 509 if (optlen > cnt) 510 optlen = cnt; 511 if (IPOPT_COPIED(opt)) { 512 (void)memcpy(dp, cp, (unsigned)optlen); 513 dp += optlen; 514 } 515 } 516 for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++) 517 *dp++ = IPOPT_EOL; 518 return (optlen); 519} 520 521/* 522 * IP socket option processing. 523 */ 524int 525ip_ctloutput(op, so, level, optname, mp) 526 int op; 527 struct socket *so; 528 int level, optname; 529 struct mbuf **mp; 530{ 531 register struct inpcb *inp = sotoinpcb(so); 532 register struct mbuf *m = *mp; 533 register int optval = 0; 534 int error = 0; 535 536 if (level != IPPROTO_IP) { 537 error = EINVAL; 538 if (op == PRCO_SETOPT && *mp) 539 (void) m_free(*mp); 540 } else switch (op) { 541 542 case PRCO_SETOPT: 543 switch (optname) { 544 case IP_OPTIONS: 545#ifdef notyet 546 case IP_RETOPTS: 547 return (ip_pcbopts(optname, &inp->inp_options, m)); 548#else 549 return (ip_pcbopts(&inp->inp_options, m)); 550#endif 551 552 case IP_TOS: 553 case IP_TTL: 554 case IP_RECVOPTS: 555 case IP_RECVRETOPTS: 556 case IP_RECVDSTADDR: 557 if (m == 0) 558 error = EFAULT; 559 else if (m->m_len != sizeof(int)) 560 error = EINVAL; 561 else { 562 optval = *mtod(m, int *); 563 switch (optname) { 564 565 case IP_TOS: 566 inp->inp_ip.ip_tos = optval; 567 break; 568 569 case IP_TTL: 570 inp->inp_ip.ip_ttl = optval; 571 break; 572#define OPTSET(bit) \ 573 if (optval) \ 574 inp->inp_flags |= bit; \ 575 else \ 576 inp->inp_flags &= ~bit; 577 578 case IP_RECVOPTS: 579 OPTSET(INP_RECVOPTS); 580 break; 581 582 case IP_RECVRETOPTS: 583 OPTSET(INP_RECVRETOPTS); 584 break; 585 586 case IP_RECVDSTADDR: 587 OPTSET(INP_RECVDSTADDR); 588 break; 589 } 590 } 591 break; 592#undef OPTSET 593 594 case IP_MULTICAST_IF: 595 case IP_MULTICAST_VIF: 596 case IP_MULTICAST_TTL: 597 case IP_MULTICAST_LOOP: 598 case IP_ADD_MEMBERSHIP: 599 case IP_DROP_MEMBERSHIP: 600 error = ip_setmoptions(optname, &inp->inp_moptions, m); 601 break; 602 603 default: 604 error = ENOPROTOOPT; 605 break; 606 } 607 if (m) 608 (void)m_free(m); 609 break; 610 611 case PRCO_GETOPT: 612 switch (optname) { 613 case IP_OPTIONS: 614 case IP_RETOPTS: 615 *mp = m = m_get(M_WAIT, MT_SOOPTS); 616 if (inp->inp_options) { 617 m->m_len = inp->inp_options->m_len; 618 (void)memcpy(mtod(m, void *), 619 mtod(inp->inp_options, void *), (unsigned)m->m_len); 620 } else 621 m->m_len = 0; 622 break; 623 624 case IP_TOS: 625 case IP_TTL: 626 case IP_RECVOPTS: 627 case IP_RECVRETOPTS: 628 case IP_RECVDSTADDR: 629 *mp = m = m_get(M_WAIT, MT_SOOPTS); 630 m->m_len = sizeof(int); 631 switch (optname) { 632 633 case IP_TOS: 634 optval = inp->inp_ip.ip_tos; 635 break; 636 637 case IP_TTL: 638 optval = inp->inp_ip.ip_ttl; 639 break; 640 641#define OPTBIT(bit) (inp->inp_flags & bit ? 1 : 0) 642 643 case IP_RECVOPTS: 644 optval = OPTBIT(INP_RECVOPTS); 645 break; 646 647 case IP_RECVRETOPTS: 648 optval = OPTBIT(INP_RECVRETOPTS); 649 break; 650 651 case IP_RECVDSTADDR: 652 optval = OPTBIT(INP_RECVDSTADDR); 653 break; 654 } 655 *mtod(m, int *) = optval; 656 break; 657 658 case IP_MULTICAST_IF: 659 case IP_MULTICAST_VIF: 660 case IP_MULTICAST_TTL: 661 case IP_MULTICAST_LOOP: 662 case IP_ADD_MEMBERSHIP: 663 case IP_DROP_MEMBERSHIP: 664 error = ip_getmoptions(optname, inp->inp_moptions, mp); 665 break; 666 667 default: 668 error = ENOPROTOOPT; 669 break; 670 } 671 break; 672 } 673 return (error); 674} 675 676/* 677 * Set up IP options in pcb for insertion in output packets. 678 * Store in mbuf with pointer in pcbopt, adding pseudo-option 679 * with destination address if source routed. 680 */ 681int 682#ifdef notyet 683ip_pcbopts(optname, pcbopt, m) 684 int optname; 685#else 686ip_pcbopts(pcbopt, m) 687#endif 688 struct mbuf **pcbopt; 689 register struct mbuf *m; 690{ 691 register cnt, optlen; 692 register u_char *cp; 693 u_char opt; 694 695 /* turn off any old options */ 696 if (*pcbopt) 697 (void)m_free(*pcbopt); 698 *pcbopt = 0; 699 if (m == (struct mbuf *)0 || m->m_len == 0) { 700 /* 701 * Only turning off any previous options. 702 */ 703 if (m) 704 (void)m_free(m); 705 return (0); 706 } 707 708#ifndef vax 709 if (m->m_len % sizeof(long)) 710 goto bad; 711#endif 712 /* 713 * IP first-hop destination address will be stored before 714 * actual options; move other options back 715 * and clear it when none present. 716 */ 717 if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN]) 718 goto bad; 719 cnt = m->m_len; 720 m->m_len += sizeof(struct in_addr); 721 cp = mtod(m, u_char *) + sizeof(struct in_addr); 722 ovbcopy(mtod(m, caddr_t), (caddr_t)cp, (unsigned)cnt); 723 bzero(mtod(m, caddr_t), sizeof(struct in_addr)); 724 725 for (; cnt > 0; cnt -= optlen, cp += optlen) { 726 opt = cp[IPOPT_OPTVAL]; 727 if (opt == IPOPT_EOL) 728 break; 729 if (opt == IPOPT_NOP) 730 optlen = 1; 731 else { 732 optlen = cp[IPOPT_OLEN]; 733 if (optlen <= IPOPT_OLEN || optlen > cnt) 734 goto bad; 735 } 736 switch (opt) { 737 738 default: 739 break; 740 741 case IPOPT_LSRR: 742 case IPOPT_SSRR: 743 /* 744 * user process specifies route as: 745 * ->A->B->C->D 746 * D must be our final destination (but we can't 747 * check that since we may not have connected yet). 748 * A is first hop destination, which doesn't appear in 749 * actual IP option, but is stored before the options. 750 */ 751 if (optlen < IPOPT_MINOFF - 1 + sizeof(struct in_addr)) 752 goto bad; 753 m->m_len -= sizeof(struct in_addr); 754 cnt -= sizeof(struct in_addr); 755 optlen -= sizeof(struct in_addr); 756 cp[IPOPT_OLEN] = optlen; 757 /* 758 * Move first hop before start of options. 759 */ 760 bcopy((caddr_t)&cp[IPOPT_OFFSET+1], mtod(m, caddr_t), 761 sizeof(struct in_addr)); 762 /* 763 * Then copy rest of options back 764 * to close up the deleted entry. 765 */ 766 ovbcopy((caddr_t)(&cp[IPOPT_OFFSET+1] + 767 sizeof(struct in_addr)), 768 (caddr_t)&cp[IPOPT_OFFSET+1], 769 (unsigned)cnt + sizeof(struct in_addr)); 770 break; 771 } 772 } 773 if (m->m_len > MAX_IPOPTLEN + sizeof(struct in_addr)) 774 goto bad; 775 *pcbopt = m; 776 return (0); 777 778bad: 779 (void)m_free(m); 780 return (EINVAL); 781} 782 783/* 784 * Set the IP multicast options in response to user setsockopt(). 785 */ 786int 787ip_setmoptions(optname, imop, m) 788 int optname; 789 struct ip_moptions **imop; 790 struct mbuf *m; 791{ 792 register int error = 0; 793 u_char loop; 794 register int i; 795 struct in_addr addr; 796 register struct ip_mreq *mreq; 797 register struct ifnet *ifp; 798 register struct ip_moptions *imo = *imop; 799 struct route ro; 800 register struct sockaddr_in *dst; 801 int s; 802 803 if (imo == NULL) { 804 /* 805 * No multicast option buffer attached to the pcb; 806 * allocate one and initialize to default values. 807 */ 808 imo = (struct ip_moptions*)malloc(sizeof(*imo), M_IPMOPTS, 809 M_WAITOK); 810 811 if (imo == NULL) 812 return (ENOBUFS); 813 *imop = imo; 814 imo->imo_multicast_ifp = NULL; 815 imo->imo_multicast_vif = -1; 816 imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL; 817 imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP; 818 imo->imo_num_memberships = 0; 819 } 820 821 switch (optname) { 822 /* store an index number for the vif you wanna use in the send */ 823 case IP_MULTICAST_VIF: 824 if (!legal_vif_num) { 825 error = EOPNOTSUPP; 826 break; 827 } 828 if (m == NULL || m->m_len != sizeof(int)) { 829 error = EINVAL; 830 break; 831 } 832 i = *(mtod(m, int *)); 833 if (!legal_vif_num(i) && (i != -1)) { 834 error = EINVAL; 835 break; 836 } 837 imo->imo_multicast_vif = i; 838 break; 839 840 case IP_MULTICAST_IF: 841 /* 842 * Select the interface for outgoing multicast packets. 843 */ 844 if (m == NULL || m->m_len != sizeof(struct in_addr)) { 845 error = EINVAL; 846 break; 847 } 848 addr = *(mtod(m, struct in_addr *)); 849 /* 850 * INADDR_ANY is used to remove a previous selection. 851 * When no interface is selected, a default one is 852 * chosen every time a multicast packet is sent. 853 */ 854 if (addr.s_addr == INADDR_ANY) { 855 imo->imo_multicast_ifp = NULL; 856 break; 857 } 858 /* 859 * The selected interface is identified by its local 860 * IP address. Find the interface and confirm that 861 * it supports multicasting. 862 */ 863 s = splimp(); 864 INADDR_TO_IFP(addr, ifp); 865 if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) { 866 error = EADDRNOTAVAIL; 867 break; 868 } 869 imo->imo_multicast_ifp = ifp; 870 splx(s); 871 break; 872 873 case IP_MULTICAST_TTL: 874 /* 875 * Set the IP time-to-live for outgoing multicast packets. 876 */ 877 if (m == NULL || m->m_len != 1) { 878 error = EINVAL; 879 break; 880 } 881 imo->imo_multicast_ttl = *(mtod(m, u_char *)); 882 break; 883 884 case IP_MULTICAST_LOOP: 885 /* 886 * Set the loopback flag for outgoing multicast packets. 887 * Must be zero or one. 888 */ 889 if (m == NULL || m->m_len != 1 || 890 (loop = *(mtod(m, u_char *))) > 1) { 891 error = EINVAL; 892 break; 893 } 894 imo->imo_multicast_loop = loop; 895 break; 896 897 case IP_ADD_MEMBERSHIP: 898 /* 899 * Add a multicast group membership. 900 * Group must be a valid IP multicast address. 901 */ 902 if (m == NULL || m->m_len != sizeof(struct ip_mreq)) { 903 error = EINVAL; 904 break; 905 } 906 mreq = mtod(m, struct ip_mreq *); 907 if (!IN_MULTICAST(ntohl(mreq->imr_multiaddr.s_addr))) { 908 error = EINVAL; 909 break; 910 } 911 s = splimp(); 912 /* 913 * If no interface address was provided, use the interface of 914 * the route to the given multicast address. 915 */ 916 if (mreq->imr_interface.s_addr == INADDR_ANY) { 917 bzero((caddr_t)&ro, sizeof(ro)); 918 dst = (struct sockaddr_in *)&ro.ro_dst; 919 dst->sin_len = sizeof(*dst); 920 dst->sin_family = AF_INET; 921 dst->sin_addr = mreq->imr_multiaddr; 922 rtalloc(&ro); 923 if (ro.ro_rt == NULL) { 924 error = EADDRNOTAVAIL; 925 splx(s); 926 break; 927 } 928 ifp = ro.ro_rt->rt_ifp; 929 rtfree(ro.ro_rt); 930 } 931 else { 932 INADDR_TO_IFP(mreq->imr_interface, ifp); 933 } 934 935 /* 936 * See if we found an interface, and confirm that it 937 * supports multicast. 938 */ 939 if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) { 940 error = EADDRNOTAVAIL; 941 splx(s); 942 break; 943 } 944 /* 945 * See if the membership already exists or if all the 946 * membership slots are full. 947 */ 948 for (i = 0; i < imo->imo_num_memberships; ++i) { 949 if (imo->imo_membership[i]->inm_ifp == ifp && 950 imo->imo_membership[i]->inm_addr.s_addr 951 == mreq->imr_multiaddr.s_addr) 952 break; 953 } 954 if (i < imo->imo_num_memberships) { 955 error = EADDRINUSE; 956 splx(s); 957 break; 958 } 959 if (i == IP_MAX_MEMBERSHIPS) { 960 error = ETOOMANYREFS; 961 splx(s); 962 break; 963 } 964 /* 965 * Everything looks good; add a new record to the multicast 966 * address list for the given interface. 967 */ 968 if ((imo->imo_membership[i] = 969 in_addmulti(&mreq->imr_multiaddr, ifp)) == NULL) { 970 error = ENOBUFS; 971 splx(s); 972 break; 973 } 974 ++imo->imo_num_memberships; 975 splx(s); 976 break; 977 978 case IP_DROP_MEMBERSHIP: 979 /* 980 * Drop a multicast group membership. 981 * Group must be a valid IP multicast address. 982 */ 983 if (m == NULL || m->m_len != sizeof(struct ip_mreq)) { 984 error = EINVAL; 985 break; 986 } 987 mreq = mtod(m, struct ip_mreq *); 988 if (!IN_MULTICAST(ntohl(mreq->imr_multiaddr.s_addr))) { 989 error = EINVAL; 990 break; 991 } 992 993 s = splimp(); 994 /* 995 * If an interface address was specified, get a pointer 996 * to its ifnet structure. 997 */ 998 if (mreq->imr_interface.s_addr == INADDR_ANY) 999 ifp = NULL; 1000 else { 1001 INADDR_TO_IFP(mreq->imr_interface, ifp); 1002 if (ifp == NULL) { 1003 error = EADDRNOTAVAIL; 1004 splx(s); 1005 break; 1006 } 1007 } 1008 /* 1009 * Find the membership in the membership array. 1010 */ 1011 for (i = 0; i < imo->imo_num_memberships; ++i) { 1012 if ((ifp == NULL || 1013 imo->imo_membership[i]->inm_ifp == ifp) && 1014 imo->imo_membership[i]->inm_addr.s_addr == 1015 mreq->imr_multiaddr.s_addr) 1016 break; 1017 } 1018 if (i == imo->imo_num_memberships) { 1019 error = EADDRNOTAVAIL; 1020 splx(s); 1021 break; 1022 } 1023 /* 1024 * Give up the multicast address record to which the 1025 * membership points. 1026 */ 1027 in_delmulti(imo->imo_membership[i]); 1028 /* 1029 * Remove the gap in the membership array. 1030 */ 1031 for (++i; i < imo->imo_num_memberships; ++i) 1032 imo->imo_membership[i-1] = imo->imo_membership[i]; 1033 --imo->imo_num_memberships; 1034 splx(s); 1035 break; 1036 1037 default: 1038 error = EOPNOTSUPP; 1039 break; 1040 } 1041 1042 /* 1043 * If all options have default values, no need to keep the mbuf. 1044 */ 1045 if (imo->imo_multicast_ifp == NULL && 1046 imo->imo_multicast_vif == -1 && 1047 imo->imo_multicast_ttl == IP_DEFAULT_MULTICAST_TTL && 1048 imo->imo_multicast_loop == IP_DEFAULT_MULTICAST_LOOP && 1049 imo->imo_num_memberships == 0) { 1050 free(*imop, M_IPMOPTS); 1051 *imop = NULL; 1052 } 1053 1054 return (error); 1055} 1056 1057/* 1058 * Return the IP multicast options in response to user getsockopt(). 1059 */ 1060int 1061ip_getmoptions(optname, imo, mp) 1062 int optname; 1063 register struct ip_moptions *imo; 1064 register struct mbuf **mp; 1065{ 1066 u_char *ttl; 1067 u_char *loop; 1068 struct in_addr *addr; 1069 struct in_ifaddr *ia; 1070 1071 *mp = m_get(M_WAIT, MT_SOOPTS); 1072 1073 switch (optname) { 1074 1075 case IP_MULTICAST_VIF: 1076 if (imo != NULL) 1077 *(mtod(*mp, int *)) = imo->imo_multicast_vif; 1078 else 1079 *(mtod(*mp, int *)) = -1; 1080 (*mp)->m_len = sizeof(int); 1081 return(0); 1082 1083 case IP_MULTICAST_IF: 1084 addr = mtod(*mp, struct in_addr *); 1085 (*mp)->m_len = sizeof(struct in_addr); 1086 if (imo == NULL || imo->imo_multicast_ifp == NULL) 1087 addr->s_addr = INADDR_ANY; 1088 else { 1089 IFP_TO_IA(imo->imo_multicast_ifp, ia); 1090 addr->s_addr = (ia == NULL) ? INADDR_ANY 1091 : IA_SIN(ia)->sin_addr.s_addr; 1092 } 1093 return (0); 1094 1095 case IP_MULTICAST_TTL: 1096 ttl = mtod(*mp, u_char *); 1097 (*mp)->m_len = 1; 1098 *ttl = (imo == NULL) ? IP_DEFAULT_MULTICAST_TTL 1099 : imo->imo_multicast_ttl; 1100 return (0); 1101 1102 case IP_MULTICAST_LOOP: 1103 loop = mtod(*mp, u_char *); 1104 (*mp)->m_len = 1; 1105 *loop = (imo == NULL) ? IP_DEFAULT_MULTICAST_LOOP 1106 : imo->imo_multicast_loop; 1107 return (0); 1108 1109 default: 1110 return (EOPNOTSUPP); 1111 } 1112} 1113 1114/* 1115 * Discard the IP multicast options. 1116 */ 1117void 1118ip_freemoptions(imo) 1119 register struct ip_moptions *imo; 1120{ 1121 register int i; 1122 1123 if (imo != NULL) { 1124 for (i = 0; i < imo->imo_num_memberships; ++i) 1125 in_delmulti(imo->imo_membership[i]); 1126 free(imo, M_IPMOPTS); 1127 } 1128} 1129 1130/* 1131 * Routine called from ip_output() to loop back a copy of an IP multicast 1132 * packet to the input queue of a specified interface. Note that this 1133 * calls the output routine of the loopback "driver", but with an interface 1134 * pointer that might NOT be a loopback interface -- evil, but easier than 1135 * replicating that code here. 1136 */ 1137static void 1138ip_mloopback(ifp, m, dst) 1139 struct ifnet *ifp; 1140 register struct mbuf *m; 1141 register struct sockaddr_in *dst; 1142{ 1143 register struct ip *ip; 1144 struct mbuf *copym; 1145 1146 copym = m_copy(m, 0, M_COPYALL); 1147 if (copym != NULL) { 1148 /* 1149 * We don't bother to fragment if the IP length is greater 1150 * than the interface's MTU. Can this possibly matter? 1151 */ 1152 ip = mtod(copym, struct ip *); 1153 ip->ip_len = htons((u_short)ip->ip_len); 1154 ip->ip_off = htons((u_short)ip->ip_off); 1155 ip->ip_sum = 0; 1156 ip->ip_sum = in_cksum(copym, ip->ip_hl << 2); 1157 (void) looutput(ifp, copym, (struct sockaddr *)dst, NULL); 1158 } 1159} 1160