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