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