route.c revision 1.187 1 1.187 ozaki /* $NetBSD: route.c,v 1.187 2017/01/17 07:53:06 ozaki-r Exp $ */
2 1.18 kml
3 1.18 kml /*-
4 1.106 ad * Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
5 1.18 kml * All rights reserved.
6 1.18 kml *
7 1.18 kml * This code is derived from software contributed to The NetBSD Foundation
8 1.18 kml * by Kevin M. Lahey of the Numerical Aerospace Simulation Facility,
9 1.18 kml * NASA Ames Research Center.
10 1.18 kml *
11 1.18 kml * Redistribution and use in source and binary forms, with or without
12 1.18 kml * modification, are permitted provided that the following conditions
13 1.18 kml * are met:
14 1.18 kml * 1. Redistributions of source code must retain the above copyright
15 1.18 kml * notice, this list of conditions and the following disclaimer.
16 1.18 kml * 2. Redistributions in binary form must reproduce the above copyright
17 1.18 kml * notice, this list of conditions and the following disclaimer in the
18 1.18 kml * documentation and/or other materials provided with the distribution.
19 1.18 kml *
20 1.18 kml * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 1.18 kml * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 1.18 kml * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 1.18 kml * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 1.18 kml * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 1.18 kml * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 1.18 kml * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 1.18 kml * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 1.18 kml * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 1.18 kml * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 1.18 kml * POSSIBILITY OF SUCH DAMAGE.
31 1.18 kml */
32 1.11 cgd
33 1.1 cgd /*
34 1.25 itojun * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
35 1.25 itojun * All rights reserved.
36 1.65 perry *
37 1.25 itojun * Redistribution and use in source and binary forms, with or without
38 1.25 itojun * modification, are permitted provided that the following conditions
39 1.25 itojun * are met:
40 1.25 itojun * 1. Redistributions of source code must retain the above copyright
41 1.25 itojun * notice, this list of conditions and the following disclaimer.
42 1.25 itojun * 2. Redistributions in binary form must reproduce the above copyright
43 1.25 itojun * notice, this list of conditions and the following disclaimer in the
44 1.25 itojun * documentation and/or other materials provided with the distribution.
45 1.25 itojun * 3. Neither the name of the project nor the names of its contributors
46 1.25 itojun * may be used to endorse or promote products derived from this software
47 1.25 itojun * without specific prior written permission.
48 1.65 perry *
49 1.25 itojun * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
50 1.25 itojun * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 1.25 itojun * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 1.25 itojun * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
53 1.25 itojun * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 1.25 itojun * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 1.25 itojun * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 1.25 itojun * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 1.25 itojun * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 1.25 itojun * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59 1.25 itojun * SUCH DAMAGE.
60 1.25 itojun */
61 1.25 itojun
62 1.25 itojun /*
63 1.10 mycroft * Copyright (c) 1980, 1986, 1991, 1993
64 1.10 mycroft * The Regents of the University of California. All rights reserved.
65 1.1 cgd *
66 1.1 cgd * Redistribution and use in source and binary forms, with or without
67 1.1 cgd * modification, are permitted provided that the following conditions
68 1.1 cgd * are met:
69 1.1 cgd * 1. Redistributions of source code must retain the above copyright
70 1.1 cgd * notice, this list of conditions and the following disclaimer.
71 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
72 1.1 cgd * notice, this list of conditions and the following disclaimer in the
73 1.1 cgd * documentation and/or other materials provided with the distribution.
74 1.58 agc * 3. Neither the name of the University nor the names of its contributors
75 1.1 cgd * may be used to endorse or promote products derived from this software
76 1.1 cgd * without specific prior written permission.
77 1.1 cgd *
78 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
79 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
80 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
81 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
82 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
83 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
84 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
85 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
86 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
87 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
88 1.1 cgd * SUCH DAMAGE.
89 1.1 cgd *
90 1.17 christos * @(#)route.c 8.3 (Berkeley) 1/9/95
91 1.1 cgd */
92 1.50 lukem
93 1.149 pooka #ifdef _KERNEL_OPT
94 1.136 roy #include "opt_inet.h"
95 1.90 dyoung #include "opt_route.h"
96 1.175 ozaki #include "opt_net_mpsafe.h"
97 1.149 pooka #endif
98 1.90 dyoung
99 1.50 lukem #include <sys/cdefs.h>
100 1.187 ozaki __KERNEL_RCSID(0, "$NetBSD: route.c,v 1.187 2017/01/17 07:53:06 ozaki-r Exp $");
101 1.2 cgd
102 1.5 mycroft #include <sys/param.h>
103 1.140 ozaki #ifdef RTFLUSH_DEBUG
104 1.90 dyoung #include <sys/sysctl.h>
105 1.140 ozaki #endif
106 1.5 mycroft #include <sys/systm.h>
107 1.35 thorpej #include <sys/callout.h>
108 1.5 mycroft #include <sys/proc.h>
109 1.5 mycroft #include <sys/mbuf.h>
110 1.5 mycroft #include <sys/socket.h>
111 1.5 mycroft #include <sys/socketvar.h>
112 1.5 mycroft #include <sys/domain.h>
113 1.18 kml #include <sys/kernel.h>
114 1.5 mycroft #include <sys/ioctl.h>
115 1.22 thorpej #include <sys/pool.h>
116 1.119 elad #include <sys/kauth.h>
117 1.170 ozaki #include <sys/workqueue.h>
118 1.182 ozaki #include <sys/syslog.h>
119 1.183 ozaki #include <sys/rwlock.h>
120 1.183 ozaki #include <sys/mutex.h>
121 1.183 ozaki #include <sys/cpu.h>
122 1.1 cgd
123 1.5 mycroft #include <net/if.h>
124 1.114 dyoung #include <net/if_dl.h>
125 1.5 mycroft #include <net/route.h>
126 1.1 cgd
127 1.5 mycroft #include <netinet/in.h>
128 1.5 mycroft #include <netinet/in_var.h>
129 1.1 cgd
130 1.90 dyoung #ifdef RTFLUSH_DEBUG
131 1.90 dyoung #define rtcache_debug() __predict_false(_rtcache_debug)
132 1.90 dyoung #else /* RTFLUSH_DEBUG */
133 1.90 dyoung #define rtcache_debug() 0
134 1.90 dyoung #endif /* RTFLUSH_DEBUG */
135 1.5 mycroft
136 1.183 ozaki #ifdef RT_DEBUG
137 1.183 ozaki #define RT_REFCNT_TRACE(rt) printf("%s:%d: rt=%p refcnt=%d\n", \
138 1.183 ozaki __func__, __LINE__, (rt), (rt)->rt_refcnt)
139 1.183 ozaki #else
140 1.183 ozaki #define RT_REFCNT_TRACE(rt) do {} while (0)
141 1.183 ozaki #endif
142 1.183 ozaki
143 1.183 ozaki #ifdef DEBUG
144 1.183 ozaki #define dlog(level, fmt, args...) log(level, fmt, ##args)
145 1.183 ozaki #else
146 1.183 ozaki #define dlog(level, fmt, args...) do {} while (0)
147 1.183 ozaki #endif
148 1.183 ozaki
149 1.155 ozaki struct rtstat rtstat;
150 1.1 cgd
151 1.155 ozaki static int rttrash; /* routes not in table but not freed */
152 1.1 cgd
153 1.155 ozaki static struct pool rtentry_pool;
154 1.155 ozaki static struct pool rttimer_pool;
155 1.22 thorpej
156 1.155 ozaki static struct callout rt_timer_ch; /* callout for rt_timer_timer() */
157 1.177 ozaki static struct workqueue *rt_timer_wq;
158 1.177 ozaki static struct work rt_timer_wk;
159 1.177 ozaki
160 1.177 ozaki static void rt_timer_init(void);
161 1.181 ozaki static void rt_timer_queue_remove_all(struct rttimer_queue *);
162 1.178 ozaki static void rt_timer_remove_all(struct rtentry *);
163 1.177 ozaki static void rt_timer_timer(void *);
164 1.35 thorpej
165 1.183 ozaki /*
166 1.183 ozaki * Locking notes:
167 1.183 ozaki * - The routing table is protected by a global rwlock
168 1.183 ozaki * - API: RT_RLOCK and friends
169 1.183 ozaki * - rtcaches are protected by a global rwlock
170 1.183 ozaki * - API: RTCACHE_RLOCK and friends
171 1.183 ozaki * - References to a rtentry is managed by reference counting and psref
172 1.183 ozaki * - Reference couting is used for temporal reference when a rtentry
173 1.183 ozaki * is fetched from the routing table
174 1.183 ozaki * - psref is used for temporal reference when a rtentry is fetched
175 1.183 ozaki * from a rtcache
176 1.183 ozaki * - struct route (rtcache) has struct psref, so we cannot obtain
177 1.183 ozaki * a reference twice on the same struct route
178 1.183 ozaki * - Befere destroying or updating a rtentry, we have to wait for
179 1.183 ozaki * all references left (see below for details)
180 1.183 ozaki * - APIs
181 1.183 ozaki * - An obtained rtentry via rtalloc1 or rtrequest* must be
182 1.183 ozaki * unreferenced by rt_unref
183 1.183 ozaki * - An obtained rtentry via rtcache_* must be unreferenced by
184 1.183 ozaki * rtcache_unref
185 1.183 ozaki * - TODO: once we get a lockless routing table, we should use only
186 1.183 ozaki * psref for rtentries
187 1.183 ozaki * - rtentry destruction
188 1.183 ozaki * - A rtentry is destroyed (freed) only when we call rtrequest(RTM_DELETE)
189 1.183 ozaki * - If a caller of rtrequest grabs a reference of a rtentry, the caller
190 1.183 ozaki * has a responsibility to destroy the rtentry by itself by calling
191 1.183 ozaki * rt_free
192 1.183 ozaki * - If not, rtrequest itself does that
193 1.183 ozaki * - If rt_free is called in softint, the actual destruction routine is
194 1.183 ozaki * deferred to a workqueue
195 1.183 ozaki * - rtentry update
196 1.183 ozaki * - When updating a rtentry, RTF_UPDATING flag is set
197 1.183 ozaki * - If a rtentry is set RTF_UPDATING, fetching the rtentry from
198 1.183 ozaki * the routing table or a rtcache results in either of the following
199 1.183 ozaki * cases:
200 1.183 ozaki * - if the caller runs in softint, the caller fails to fetch
201 1.183 ozaki * - otherwise, the caller waits for the update completed and retries
202 1.183 ozaki * to fetch (probably succeed to fetch for the second time)
203 1.183 ozaki */
204 1.183 ozaki
205 1.183 ozaki /*
206 1.183 ozaki * Global locks for the routing table and rtcaches.
207 1.183 ozaki * Locking order: rtcache_lock => rt_lock
208 1.183 ozaki */
209 1.183 ozaki static krwlock_t rt_lock __cacheline_aligned;
210 1.183 ozaki #ifdef NET_MPSAFE
211 1.183 ozaki #define RT_RLOCK() rw_enter(&rt_lock, RW_READER)
212 1.183 ozaki #define RT_WLOCK() rw_enter(&rt_lock, RW_WRITER)
213 1.183 ozaki #define RT_UNLOCK() rw_exit(&rt_lock)
214 1.183 ozaki #define RT_LOCKED() rw_lock_held(&rt_lock)
215 1.183 ozaki #define RT_ASSERT_WLOCK() KASSERT(rw_write_held(&rt_lock))
216 1.183 ozaki #else
217 1.183 ozaki #define RT_RLOCK() do {} while (0)
218 1.183 ozaki #define RT_WLOCK() do {} while (0)
219 1.183 ozaki #define RT_UNLOCK() do {} while (0)
220 1.183 ozaki #define RT_LOCKED() false
221 1.183 ozaki #define RT_ASSERT_WLOCK() do {} while (0)
222 1.183 ozaki #endif
223 1.183 ozaki
224 1.183 ozaki static krwlock_t rtcache_lock __cacheline_aligned;
225 1.183 ozaki #ifdef NET_MPSAFE
226 1.183 ozaki #define RTCACHE_RLOCK() rw_enter(&rtcache_lock, RW_READER)
227 1.183 ozaki #define RTCACHE_WLOCK() rw_enter(&rtcache_lock, RW_WRITER)
228 1.183 ozaki #define RTCACHE_UNLOCK() rw_exit(&rtcache_lock)
229 1.183 ozaki #define RTCACHE_ASSERT_WLOCK() KASSERT(rw_write_held(&rtcache_lock))
230 1.183 ozaki #define RTCACHE_WLOCKED() rw_write_held(&rtcache_lock)
231 1.183 ozaki #else
232 1.183 ozaki #define RTCACHE_RLOCK() do {} while (0)
233 1.183 ozaki #define RTCACHE_WLOCK() do {} while (0)
234 1.183 ozaki #define RTCACHE_UNLOCK() do {} while (0)
235 1.183 ozaki #define RTCACHE_ASSERT_WLOCK() do {} while (0)
236 1.183 ozaki #define RTCACHE_WLOCKED() false
237 1.183 ozaki #endif
238 1.183 ozaki
239 1.183 ozaki /*
240 1.183 ozaki * mutex and cv that are used to wait for references to a rtentry left
241 1.183 ozaki * before updating the rtentry.
242 1.183 ozaki */
243 1.183 ozaki static struct {
244 1.183 ozaki kmutex_t lock;
245 1.183 ozaki kcondvar_t cv;
246 1.183 ozaki bool ongoing;
247 1.183 ozaki const struct lwp *lwp;
248 1.183 ozaki } rt_update_global __cacheline_aligned;
249 1.183 ozaki
250 1.183 ozaki /*
251 1.183 ozaki * A workqueue and stuff that are used to defer the destruction routine
252 1.183 ozaki * of rtentries.
253 1.183 ozaki */
254 1.183 ozaki static struct {
255 1.183 ozaki struct workqueue *wq;
256 1.183 ozaki struct work wk;
257 1.183 ozaki kmutex_t lock;
258 1.183 ozaki struct rtentry *queue[10];
259 1.183 ozaki } rt_free_global __cacheline_aligned;
260 1.183 ozaki
261 1.183 ozaki /* psref for rtentry */
262 1.183 ozaki static struct psref_class *rt_psref_class __read_mostly;
263 1.183 ozaki
264 1.90 dyoung #ifdef RTFLUSH_DEBUG
265 1.90 dyoung static int _rtcache_debug = 0;
266 1.90 dyoung #endif /* RTFLUSH_DEBUG */
267 1.90 dyoung
268 1.119 elad static kauth_listener_t route_listener;
269 1.119 elad
270 1.60 matt static int rtdeletemsg(struct rtentry *);
271 1.144 ozaki static void rtflushall(int);
272 1.40 itojun
273 1.141 ozaki static void rt_maskedcopy(const struct sockaddr *,
274 1.141 ozaki struct sockaddr *, const struct sockaddr *);
275 1.141 ozaki
276 1.144 ozaki static void rtcache_clear(struct route *);
277 1.168 ozaki static void rtcache_clear_rtentry(int, struct rtentry *);
278 1.144 ozaki static void rtcache_invalidate(struct dom_rtlist *);
279 1.144 ozaki
280 1.183 ozaki static void rt_ref(struct rtentry *);
281 1.183 ozaki
282 1.183 ozaki static struct rtentry *
283 1.183 ozaki rtalloc1_locked(const struct sockaddr *, int, bool);
284 1.183 ozaki static struct rtentry *
285 1.183 ozaki rtcache_validate_locked(struct route *);
286 1.183 ozaki static void rtcache_free_locked(struct route *);
287 1.183 ozaki static int rtcache_setdst_locked(struct route *, const struct sockaddr *);
288 1.183 ozaki
289 1.183 ozaki static void rtcache_ref(struct rtentry *, struct route *);
290 1.183 ozaki
291 1.183 ozaki static void rt_update_wait(void);
292 1.183 ozaki
293 1.183 ozaki static bool rt_wait_ok(void);
294 1.183 ozaki static void rt_wait_refcnt(const char *, struct rtentry *, int);
295 1.183 ozaki static void rt_wait_psref(struct rtentry *);
296 1.183 ozaki
297 1.162 ozaki #ifdef DDB
298 1.162 ozaki static void db_print_sa(const struct sockaddr *);
299 1.162 ozaki static void db_print_ifa(struct ifaddr *);
300 1.162 ozaki static int db_show_rtentry(struct rtentry *, void *);
301 1.162 ozaki #endif
302 1.162 ozaki
303 1.90 dyoung #ifdef RTFLUSH_DEBUG
304 1.118 pooka static void sysctl_net_rtcache_setup(struct sysctllog **);
305 1.118 pooka static void
306 1.118 pooka sysctl_net_rtcache_setup(struct sysctllog **clog)
307 1.90 dyoung {
308 1.90 dyoung const struct sysctlnode *rnode;
309 1.90 dyoung
310 1.90 dyoung if (sysctl_createv(clog, 0, NULL, &rnode, CTLFLAG_PERMANENT,
311 1.90 dyoung CTLTYPE_NODE,
312 1.90 dyoung "rtcache", SYSCTL_DESCR("Route cache related settings"),
313 1.128 pooka NULL, 0, NULL, 0, CTL_NET, CTL_CREATE, CTL_EOL) != 0)
314 1.90 dyoung return;
315 1.90 dyoung if (sysctl_createv(clog, 0, &rnode, &rnode,
316 1.90 dyoung CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT,
317 1.90 dyoung "debug", SYSCTL_DESCR("Debug route caches"),
318 1.90 dyoung NULL, 0, &_rtcache_debug, 0, CTL_CREATE, CTL_EOL) != 0)
319 1.90 dyoung return;
320 1.90 dyoung }
321 1.90 dyoung #endif /* RTFLUSH_DEBUG */
322 1.90 dyoung
323 1.144 ozaki static inline void
324 1.144 ozaki rt_destroy(struct rtentry *rt)
325 1.144 ozaki {
326 1.144 ozaki if (rt->_rt_key != NULL)
327 1.144 ozaki sockaddr_free(rt->_rt_key);
328 1.144 ozaki if (rt->rt_gateway != NULL)
329 1.144 ozaki sockaddr_free(rt->rt_gateway);
330 1.144 ozaki if (rt_gettag(rt) != NULL)
331 1.144 ozaki sockaddr_free(rt_gettag(rt));
332 1.144 ozaki rt->_rt_key = rt->rt_gateway = rt->rt_tag = NULL;
333 1.144 ozaki }
334 1.144 ozaki
335 1.144 ozaki static inline const struct sockaddr *
336 1.144 ozaki rt_setkey(struct rtentry *rt, const struct sockaddr *key, int flags)
337 1.144 ozaki {
338 1.144 ozaki if (rt->_rt_key == key)
339 1.144 ozaki goto out;
340 1.144 ozaki
341 1.144 ozaki if (rt->_rt_key != NULL)
342 1.144 ozaki sockaddr_free(rt->_rt_key);
343 1.144 ozaki rt->_rt_key = sockaddr_dup(key, flags);
344 1.144 ozaki out:
345 1.144 ozaki rt->rt_nodes->rn_key = (const char *)rt->_rt_key;
346 1.144 ozaki return rt->_rt_key;
347 1.144 ozaki }
348 1.144 ozaki
349 1.81 joerg struct ifaddr *
350 1.81 joerg rt_get_ifa(struct rtentry *rt)
351 1.81 joerg {
352 1.81 joerg struct ifaddr *ifa;
353 1.81 joerg
354 1.81 joerg if ((ifa = rt->rt_ifa) == NULL)
355 1.81 joerg return ifa;
356 1.81 joerg else if (ifa->ifa_getifa == NULL)
357 1.81 joerg return ifa;
358 1.81 joerg #if 0
359 1.81 joerg else if (ifa->ifa_seqno != NULL && *ifa->ifa_seqno == rt->rt_ifa_seqno)
360 1.81 joerg return ifa;
361 1.81 joerg #endif
362 1.81 joerg else {
363 1.94 dyoung ifa = (*ifa->ifa_getifa)(ifa, rt_getkey(rt));
364 1.145 roy if (ifa == NULL)
365 1.145 roy return NULL;
366 1.81 joerg rt_replace_ifa(rt, ifa);
367 1.81 joerg return ifa;
368 1.81 joerg }
369 1.81 joerg }
370 1.81 joerg
371 1.80 joerg static void
372 1.80 joerg rt_set_ifa1(struct rtentry *rt, struct ifaddr *ifa)
373 1.80 joerg {
374 1.80 joerg rt->rt_ifa = ifa;
375 1.80 joerg if (ifa->ifa_seqno != NULL)
376 1.80 joerg rt->rt_ifa_seqno = *ifa->ifa_seqno;
377 1.80 joerg }
378 1.80 joerg
379 1.116 roy /*
380 1.116 roy * Is this route the connected route for the ifa?
381 1.116 roy */
382 1.116 roy static int
383 1.116 roy rt_ifa_connected(const struct rtentry *rt, const struct ifaddr *ifa)
384 1.116 roy {
385 1.116 roy const struct sockaddr *key, *dst, *odst;
386 1.116 roy struct sockaddr_storage maskeddst;
387 1.116 roy
388 1.116 roy key = rt_getkey(rt);
389 1.116 roy dst = rt->rt_flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr;
390 1.116 roy if (dst == NULL ||
391 1.116 roy dst->sa_family != key->sa_family ||
392 1.116 roy dst->sa_len != key->sa_len)
393 1.116 roy return 0;
394 1.116 roy if ((rt->rt_flags & RTF_HOST) == 0 && ifa->ifa_netmask) {
395 1.116 roy odst = dst;
396 1.116 roy dst = (struct sockaddr *)&maskeddst;
397 1.116 roy rt_maskedcopy(odst, (struct sockaddr *)&maskeddst,
398 1.116 roy ifa->ifa_netmask);
399 1.116 roy }
400 1.116 roy return (memcmp(dst, key, dst->sa_len) == 0);
401 1.116 roy }
402 1.116 roy
403 1.80 joerg void
404 1.80 joerg rt_replace_ifa(struct rtentry *rt, struct ifaddr *ifa)
405 1.80 joerg {
406 1.116 roy if (rt->rt_ifa &&
407 1.116 roy rt->rt_ifa != ifa &&
408 1.116 roy rt->rt_ifa->ifa_flags & IFA_ROUTE &&
409 1.116 roy rt_ifa_connected(rt, rt->rt_ifa))
410 1.116 roy {
411 1.116 roy RT_DPRINTF("rt->_rt_key = %p, ifa = %p, "
412 1.116 roy "replace deleted IFA_ROUTE\n",
413 1.116 roy (void *)rt->_rt_key, (void *)rt->rt_ifa);
414 1.116 roy rt->rt_ifa->ifa_flags &= ~IFA_ROUTE;
415 1.116 roy if (rt_ifa_connected(rt, ifa)) {
416 1.116 roy RT_DPRINTF("rt->_rt_key = %p, ifa = %p, "
417 1.116 roy "replace added IFA_ROUTE\n",
418 1.116 roy (void *)rt->_rt_key, (void *)ifa);
419 1.116 roy ifa->ifa_flags |= IFA_ROUTE;
420 1.116 roy }
421 1.116 roy }
422 1.116 roy
423 1.133 rmind ifaref(ifa);
424 1.133 rmind ifafree(rt->rt_ifa);
425 1.80 joerg rt_set_ifa1(rt, ifa);
426 1.80 joerg }
427 1.80 joerg
428 1.80 joerg static void
429 1.80 joerg rt_set_ifa(struct rtentry *rt, struct ifaddr *ifa)
430 1.80 joerg {
431 1.133 rmind ifaref(ifa);
432 1.80 joerg rt_set_ifa1(rt, ifa);
433 1.80 joerg }
434 1.80 joerg
435 1.119 elad static int
436 1.119 elad route_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
437 1.119 elad void *arg0, void *arg1, void *arg2, void *arg3)
438 1.119 elad {
439 1.119 elad struct rt_msghdr *rtm;
440 1.119 elad int result;
441 1.119 elad
442 1.119 elad result = KAUTH_RESULT_DEFER;
443 1.119 elad rtm = arg1;
444 1.119 elad
445 1.120 elad if (action != KAUTH_NETWORK_ROUTE)
446 1.120 elad return result;
447 1.120 elad
448 1.119 elad if (rtm->rtm_type == RTM_GET)
449 1.119 elad result = KAUTH_RESULT_ALLOW;
450 1.119 elad
451 1.119 elad return result;
452 1.119 elad }
453 1.119 elad
454 1.183 ozaki static void rt_free_work(struct work *, void *);
455 1.183 ozaki
456 1.9 mycroft void
457 1.124 matt rt_init(void)
458 1.1 cgd {
459 1.183 ozaki int error;
460 1.22 thorpej
461 1.118 pooka #ifdef RTFLUSH_DEBUG
462 1.118 pooka sysctl_net_rtcache_setup(NULL);
463 1.118 pooka #endif
464 1.118 pooka
465 1.183 ozaki mutex_init(&rt_free_global.lock, MUTEX_DEFAULT, IPL_SOFTNET);
466 1.183 ozaki rt_psref_class = psref_class_create("rtentry", IPL_SOFTNET);
467 1.183 ozaki
468 1.183 ozaki error = workqueue_create(&rt_free_global.wq, "rt_free",
469 1.183 ozaki rt_free_work, NULL, PRI_SOFTNET, IPL_SOFTNET, WQ_MPSAFE);
470 1.183 ozaki if (error)
471 1.183 ozaki panic("%s: workqueue_create failed (%d)\n", __func__, error);
472 1.183 ozaki
473 1.183 ozaki mutex_init(&rt_update_global.lock, MUTEX_DEFAULT, IPL_SOFTNET);
474 1.183 ozaki cv_init(&rt_update_global.cv, "rt_update");
475 1.183 ozaki
476 1.113 pooka pool_init(&rtentry_pool, sizeof(struct rtentry), 0, 0, 0, "rtentpl",
477 1.113 pooka NULL, IPL_SOFTNET);
478 1.113 pooka pool_init(&rttimer_pool, sizeof(struct rttimer), 0, 0, 0, "rttmrpl",
479 1.113 pooka NULL, IPL_SOFTNET);
480 1.113 pooka
481 1.10 mycroft rn_init(); /* initialize all zeroes, all ones, mask table */
482 1.125 dyoung rtbl_init();
483 1.119 elad
484 1.119 elad route_listener = kauth_listen_scope(KAUTH_SCOPE_NETWORK,
485 1.119 elad route_listener_cb, NULL);
486 1.1 cgd }
487 1.1 cgd
488 1.144 ozaki static void
489 1.82 dyoung rtflushall(int family)
490 1.82 dyoung {
491 1.90 dyoung struct domain *dom;
492 1.90 dyoung
493 1.90 dyoung if (rtcache_debug())
494 1.90 dyoung printf("%s: enter\n", __func__);
495 1.90 dyoung
496 1.90 dyoung if ((dom = pffinddomain(family)) == NULL)
497 1.90 dyoung return;
498 1.82 dyoung
499 1.183 ozaki RTCACHE_WLOCK();
500 1.105 dyoung rtcache_invalidate(&dom->dom_rtcache);
501 1.183 ozaki RTCACHE_UNLOCK();
502 1.82 dyoung }
503 1.82 dyoung
504 1.131 rmind static void
505 1.82 dyoung rtcache(struct route *ro)
506 1.82 dyoung {
507 1.90 dyoung struct domain *dom;
508 1.82 dyoung
509 1.183 ozaki RTCACHE_ASSERT_WLOCK();
510 1.183 ozaki
511 1.114 dyoung rtcache_invariants(ro);
512 1.99 dyoung KASSERT(ro->_ro_rt != NULL);
513 1.105 dyoung KASSERT(ro->ro_invalid == false);
514 1.90 dyoung KASSERT(rtcache_getdst(ro) != NULL);
515 1.82 dyoung
516 1.90 dyoung if ((dom = pffinddomain(rtcache_getdst(ro)->sa_family)) == NULL)
517 1.90 dyoung return;
518 1.90 dyoung
519 1.90 dyoung LIST_INSERT_HEAD(&dom->dom_rtcache, ro, ro_rtcache_next);
520 1.114 dyoung rtcache_invariants(ro);
521 1.82 dyoung }
522 1.82 dyoung
523 1.158 ozaki #ifdef RT_DEBUG
524 1.158 ozaki static void
525 1.158 ozaki dump_rt(const struct rtentry *rt)
526 1.158 ozaki {
527 1.158 ozaki char buf[512];
528 1.158 ozaki
529 1.158 ozaki aprint_normal("rt: ");
530 1.158 ozaki aprint_normal("p=%p ", rt);
531 1.158 ozaki if (rt->_rt_key == NULL) {
532 1.158 ozaki aprint_normal("dst=(NULL) ");
533 1.158 ozaki } else {
534 1.158 ozaki sockaddr_format(rt->_rt_key, buf, sizeof(buf));
535 1.158 ozaki aprint_normal("dst=%s ", buf);
536 1.158 ozaki }
537 1.158 ozaki if (rt->rt_gateway == NULL) {
538 1.158 ozaki aprint_normal("gw=(NULL) ");
539 1.158 ozaki } else {
540 1.158 ozaki sockaddr_format(rt->_rt_key, buf, sizeof(buf));
541 1.158 ozaki aprint_normal("gw=%s ", buf);
542 1.158 ozaki }
543 1.158 ozaki aprint_normal("flags=%x ", rt->rt_flags);
544 1.158 ozaki if (rt->rt_ifp == NULL) {
545 1.158 ozaki aprint_normal("if=(NULL) ");
546 1.158 ozaki } else {
547 1.158 ozaki aprint_normal("if=%s ", rt->rt_ifp->if_xname);
548 1.158 ozaki }
549 1.158 ozaki aprint_normal("\n");
550 1.158 ozaki }
551 1.158 ozaki #endif /* RT_DEBUG */
552 1.158 ozaki
553 1.1 cgd /*
554 1.146 ozaki * Packet routing routines. If success, refcnt of a returned rtentry
555 1.146 ozaki * will be incremented. The caller has to rtfree it by itself.
556 1.1 cgd */
557 1.1 cgd struct rtentry *
558 1.183 ozaki rtalloc1_locked(const struct sockaddr *dst, int report, bool wait_ok)
559 1.1 cgd {
560 1.158 ozaki rtbl_t *rtbl;
561 1.36 augustss struct rtentry *rt;
562 1.159 christos int s;
563 1.1 cgd
564 1.183 ozaki retry:
565 1.159 christos s = splsoftnet();
566 1.158 ozaki rtbl = rt_gettable(dst->sa_family);
567 1.159 christos if (rtbl == NULL)
568 1.158 ozaki goto miss;
569 1.158 ozaki
570 1.158 ozaki rt = rt_matchaddr(rtbl, dst);
571 1.159 christos if (rt == NULL)
572 1.158 ozaki goto miss;
573 1.159 christos
574 1.183 ozaki if (!ISSET(rt->rt_flags, RTF_UP))
575 1.183 ozaki goto miss;
576 1.183 ozaki
577 1.183 ozaki if (ISSET(rt->rt_flags, RTF_UPDATING) &&
578 1.183 ozaki /* XXX updater should be always able to acquire */
579 1.183 ozaki curlwp != rt_update_global.lwp) {
580 1.183 ozaki bool need_lock = false;
581 1.183 ozaki if (!wait_ok || !rt_wait_ok())
582 1.183 ozaki goto miss;
583 1.183 ozaki RT_UNLOCK();
584 1.183 ozaki splx(s);
585 1.183 ozaki
586 1.183 ozaki /* XXX need more proper solution */
587 1.183 ozaki if (RTCACHE_WLOCKED()) {
588 1.183 ozaki RTCACHE_UNLOCK();
589 1.183 ozaki need_lock = true;
590 1.183 ozaki }
591 1.183 ozaki
592 1.183 ozaki /* We can wait until the update is complete */
593 1.183 ozaki rt_update_wait();
594 1.183 ozaki
595 1.183 ozaki if (need_lock)
596 1.183 ozaki RTCACHE_WLOCK();
597 1.183 ozaki goto retry;
598 1.183 ozaki }
599 1.183 ozaki
600 1.183 ozaki rt_ref(rt);
601 1.183 ozaki RT_REFCNT_TRACE(rt);
602 1.158 ozaki
603 1.159 christos splx(s);
604 1.159 christos return rt;
605 1.158 ozaki miss:
606 1.159 christos rtstat.rts_unreach++;
607 1.158 ozaki if (report) {
608 1.159 christos struct rt_addrinfo info;
609 1.159 christos
610 1.160 christos memset(&info, 0, sizeof(info));
611 1.158 ozaki info.rti_info[RTAX_DST] = dst;
612 1.159 christos rt_missmsg(RTM_MISS, &info, 0, 0);
613 1.1 cgd }
614 1.1 cgd splx(s);
615 1.159 christos return NULL;
616 1.1 cgd }
617 1.1 cgd
618 1.183 ozaki struct rtentry *
619 1.183 ozaki rtalloc1(const struct sockaddr *dst, int report)
620 1.183 ozaki {
621 1.183 ozaki struct rtentry *rt;
622 1.183 ozaki
623 1.183 ozaki RT_RLOCK();
624 1.183 ozaki rt = rtalloc1_locked(dst, report, true);
625 1.183 ozaki RT_UNLOCK();
626 1.183 ozaki
627 1.183 ozaki return rt;
628 1.183 ozaki }
629 1.183 ozaki
630 1.151 ozaki static void
631 1.183 ozaki rt_ref(struct rtentry *rt)
632 1.183 ozaki {
633 1.183 ozaki
634 1.183 ozaki KASSERT(rt->rt_refcnt >= 0);
635 1.183 ozaki atomic_inc_uint(&rt->rt_refcnt);
636 1.183 ozaki }
637 1.183 ozaki
638 1.183 ozaki void
639 1.183 ozaki rt_unref(struct rtentry *rt)
640 1.183 ozaki {
641 1.183 ozaki
642 1.183 ozaki KASSERT(rt != NULL);
643 1.183 ozaki KASSERTMSG(rt->rt_refcnt > 0, "refcnt=%d", rt->rt_refcnt);
644 1.183 ozaki
645 1.183 ozaki atomic_dec_uint(&rt->rt_refcnt);
646 1.183 ozaki if (!ISSET(rt->rt_flags, RTF_UP) || ISSET(rt->rt_flags, RTF_UPDATING)) {
647 1.183 ozaki mutex_enter(&rt_free_global.lock);
648 1.183 ozaki cv_broadcast(&rt->rt_cv);
649 1.183 ozaki mutex_exit(&rt_free_global.lock);
650 1.183 ozaki }
651 1.183 ozaki }
652 1.183 ozaki
653 1.183 ozaki static bool
654 1.183 ozaki rt_wait_ok(void)
655 1.151 ozaki {
656 1.151 ozaki
657 1.183 ozaki KASSERT(!cpu_intr_p());
658 1.183 ozaki return !cpu_softintr_p();
659 1.183 ozaki }
660 1.151 ozaki
661 1.183 ozaki void
662 1.183 ozaki rt_wait_refcnt(const char *title, struct rtentry *rt, int cnt)
663 1.183 ozaki {
664 1.183 ozaki mutex_enter(&rt_free_global.lock);
665 1.183 ozaki while (rt->rt_refcnt > cnt) {
666 1.183 ozaki dlog(LOG_DEBUG, "%s: %s waiting (refcnt=%d)\n",
667 1.183 ozaki __func__, title, rt->rt_refcnt);
668 1.183 ozaki cv_wait(&rt->rt_cv, &rt_free_global.lock);
669 1.183 ozaki dlog(LOG_DEBUG, "%s: %s waited (refcnt=%d)\n",
670 1.183 ozaki __func__, title, rt->rt_refcnt);
671 1.183 ozaki }
672 1.183 ozaki mutex_exit(&rt_free_global.lock);
673 1.151 ozaki }
674 1.151 ozaki
675 1.9 mycroft void
676 1.183 ozaki rt_wait_psref(struct rtentry *rt)
677 1.183 ozaki {
678 1.183 ozaki
679 1.183 ozaki psref_target_destroy(&rt->rt_psref, rt_psref_class);
680 1.183 ozaki psref_target_init(&rt->rt_psref, rt_psref_class);
681 1.183 ozaki }
682 1.183 ozaki
683 1.183 ozaki static void
684 1.183 ozaki _rt_free(struct rtentry *rt)
685 1.1 cgd {
686 1.36 augustss struct ifaddr *ifa;
687 1.10 mycroft
688 1.183 ozaki /*
689 1.183 ozaki * Need to avoid a deadlock on rt_wait_refcnt of update
690 1.183 ozaki * and a conflict on psref_target_destroy of update.
691 1.183 ozaki */
692 1.183 ozaki rt_update_wait();
693 1.183 ozaki
694 1.183 ozaki RT_REFCNT_TRACE(rt);
695 1.183 ozaki KASSERTMSG(rt->rt_refcnt >= 0, "refcnt=%d", rt->rt_refcnt);
696 1.183 ozaki rt_wait_refcnt("free", rt, 0);
697 1.185 ozaki #ifdef NET_MPSAFE
698 1.183 ozaki psref_target_destroy(&rt->rt_psref, rt_psref_class);
699 1.185 ozaki #endif
700 1.183 ozaki
701 1.183 ozaki rt_assert_inactive(rt);
702 1.183 ozaki rttrash--;
703 1.183 ozaki ifa = rt->rt_ifa;
704 1.183 ozaki rt->rt_ifa = NULL;
705 1.183 ozaki ifafree(ifa);
706 1.183 ozaki rt->rt_ifp = NULL;
707 1.183 ozaki cv_destroy(&rt->rt_cv);
708 1.183 ozaki rt_destroy(rt);
709 1.183 ozaki pool_put(&rtentry_pool, rt);
710 1.183 ozaki }
711 1.183 ozaki
712 1.183 ozaki static void
713 1.183 ozaki rt_free_work(struct work *wk, void *arg)
714 1.183 ozaki {
715 1.183 ozaki int i;
716 1.183 ozaki struct rtentry *rt;
717 1.183 ozaki
718 1.183 ozaki restart:
719 1.183 ozaki mutex_enter(&rt_free_global.lock);
720 1.183 ozaki for (i = 0; i < sizeof(rt_free_global.queue); i++) {
721 1.183 ozaki if (rt_free_global.queue[i] == NULL)
722 1.183 ozaki continue;
723 1.183 ozaki rt = rt_free_global.queue[i];
724 1.183 ozaki rt_free_global.queue[i] = NULL;
725 1.183 ozaki mutex_exit(&rt_free_global.lock);
726 1.183 ozaki
727 1.183 ozaki atomic_dec_uint(&rt->rt_refcnt);
728 1.183 ozaki _rt_free(rt);
729 1.183 ozaki goto restart;
730 1.183 ozaki }
731 1.183 ozaki mutex_exit(&rt_free_global.lock);
732 1.183 ozaki }
733 1.183 ozaki
734 1.183 ozaki void
735 1.183 ozaki rt_free(struct rtentry *rt)
736 1.183 ozaki {
737 1.183 ozaki
738 1.132 rmind KASSERT(rt->rt_refcnt > 0);
739 1.183 ozaki if (!rt_wait_ok()) {
740 1.183 ozaki int i;
741 1.183 ozaki mutex_enter(&rt_free_global.lock);
742 1.183 ozaki for (i = 0; i < sizeof(rt_free_global.queue); i++) {
743 1.183 ozaki if (rt_free_global.queue[i] == NULL) {
744 1.183 ozaki rt_free_global.queue[i] = rt;
745 1.183 ozaki break;
746 1.183 ozaki }
747 1.183 ozaki }
748 1.183 ozaki KASSERT(i < sizeof(rt_free_global.queue));
749 1.183 ozaki rt_ref(rt);
750 1.183 ozaki mutex_exit(&rt_free_global.lock);
751 1.183 ozaki workqueue_enqueue(rt_free_global.wq, &rt_free_global.wk, NULL);
752 1.183 ozaki } else {
753 1.183 ozaki atomic_dec_uint(&rt->rt_refcnt);
754 1.183 ozaki _rt_free(rt);
755 1.183 ozaki }
756 1.183 ozaki }
757 1.183 ozaki
758 1.183 ozaki static void
759 1.183 ozaki rt_update_wait(void)
760 1.183 ozaki {
761 1.132 rmind
762 1.183 ozaki mutex_enter(&rt_update_global.lock);
763 1.183 ozaki while (rt_update_global.ongoing) {
764 1.183 ozaki dlog(LOG_DEBUG, "%s: waiting lwp=%p\n", __func__, curlwp);
765 1.183 ozaki cv_wait(&rt_update_global.cv, &rt_update_global.lock);
766 1.183 ozaki dlog(LOG_DEBUG, "%s: waited lwp=%p\n", __func__, curlwp);
767 1.1 cgd }
768 1.183 ozaki mutex_exit(&rt_update_global.lock);
769 1.183 ozaki }
770 1.183 ozaki
771 1.183 ozaki int
772 1.183 ozaki rt_update_prepare(struct rtentry *rt)
773 1.183 ozaki {
774 1.183 ozaki
775 1.183 ozaki dlog(LOG_DEBUG, "%s: updating rt=%p lwp=%p\n", __func__, rt, curlwp);
776 1.183 ozaki
777 1.183 ozaki RTCACHE_WLOCK();
778 1.183 ozaki RT_WLOCK();
779 1.183 ozaki /* If the entry is being destroyed, don't proceed the update. */
780 1.183 ozaki if (!ISSET(rt->rt_flags, RTF_UP)) {
781 1.183 ozaki RT_UNLOCK();
782 1.183 ozaki RTCACHE_UNLOCK();
783 1.183 ozaki return -1;
784 1.183 ozaki }
785 1.183 ozaki rt->rt_flags |= RTF_UPDATING;
786 1.183 ozaki RT_UNLOCK();
787 1.183 ozaki RTCACHE_UNLOCK();
788 1.183 ozaki
789 1.183 ozaki mutex_enter(&rt_update_global.lock);
790 1.183 ozaki while (rt_update_global.ongoing) {
791 1.183 ozaki dlog(LOG_DEBUG, "%s: waiting ongoing updating rt=%p lwp=%p\n",
792 1.183 ozaki __func__, rt, curlwp);
793 1.183 ozaki cv_wait(&rt_update_global.cv, &rt_update_global.lock);
794 1.183 ozaki dlog(LOG_DEBUG, "%s: waited ongoing updating rt=%p lwp=%p\n",
795 1.183 ozaki __func__, rt, curlwp);
796 1.183 ozaki }
797 1.183 ozaki rt_update_global.ongoing = true;
798 1.183 ozaki /* XXX need it to avoid rt_update_wait by updater itself. */
799 1.183 ozaki rt_update_global.lwp = curlwp;
800 1.183 ozaki mutex_exit(&rt_update_global.lock);
801 1.183 ozaki
802 1.183 ozaki rt_wait_refcnt("update", rt, 1);
803 1.183 ozaki rt_wait_psref(rt);
804 1.183 ozaki
805 1.183 ozaki return 0;
806 1.183 ozaki }
807 1.183 ozaki
808 1.183 ozaki void
809 1.183 ozaki rt_update_finish(struct rtentry *rt)
810 1.183 ozaki {
811 1.183 ozaki
812 1.183 ozaki RTCACHE_WLOCK();
813 1.183 ozaki RT_WLOCK();
814 1.183 ozaki rt->rt_flags &= ~RTF_UPDATING;
815 1.183 ozaki RT_UNLOCK();
816 1.183 ozaki RTCACHE_UNLOCK();
817 1.183 ozaki
818 1.183 ozaki mutex_enter(&rt_update_global.lock);
819 1.183 ozaki rt_update_global.ongoing = false;
820 1.183 ozaki rt_update_global.lwp = NULL;
821 1.183 ozaki cv_broadcast(&rt_update_global.cv);
822 1.183 ozaki mutex_exit(&rt_update_global.lock);
823 1.183 ozaki
824 1.183 ozaki dlog(LOG_DEBUG, "%s: updated rt=%p lwp=%p\n", __func__, rt, curlwp);
825 1.1 cgd }
826 1.1 cgd
827 1.1 cgd /*
828 1.1 cgd * Force a routing table entry to the specified
829 1.1 cgd * destination to go through the given gateway.
830 1.1 cgd * Normally called as a result of a routing redirect
831 1.1 cgd * message from the network layer.
832 1.1 cgd *
833 1.13 mycroft * N.B.: must be called at splsoftnet
834 1.1 cgd */
835 1.14 christos void
836 1.60 matt rtredirect(const struct sockaddr *dst, const struct sockaddr *gateway,
837 1.60 matt const struct sockaddr *netmask, int flags, const struct sockaddr *src,
838 1.60 matt struct rtentry **rtp)
839 1.1 cgd {
840 1.36 augustss struct rtentry *rt;
841 1.1 cgd int error = 0;
842 1.121 dyoung uint64_t *stat = NULL;
843 1.10 mycroft struct rt_addrinfo info;
844 1.10 mycroft struct ifaddr *ifa;
845 1.173 ozaki struct psref psref;
846 1.1 cgd
847 1.1 cgd /* verify the gateway is directly reachable */
848 1.173 ozaki if ((ifa = ifa_ifwithnet_psref(gateway, &psref)) == NULL) {
849 1.1 cgd error = ENETUNREACH;
850 1.8 cgd goto out;
851 1.1 cgd }
852 1.1 cgd rt = rtalloc1(dst, 0);
853 1.1 cgd /*
854 1.1 cgd * If the redirect isn't from our current router for this dst,
855 1.1 cgd * it's either old or wrong. If it redirects us to ourselves,
856 1.1 cgd * we have a routing loop, perhaps as a result of an interface
857 1.1 cgd * going down recently.
858 1.1 cgd */
859 1.10 mycroft if (!(flags & RTF_DONE) && rt &&
860 1.115 yamt (sockaddr_cmp(src, rt->rt_gateway) != 0 || rt->rt_ifa != ifa))
861 1.1 cgd error = EINVAL;
862 1.173 ozaki else {
863 1.173 ozaki int s = pserialize_read_enter();
864 1.173 ozaki struct ifaddr *_ifa;
865 1.173 ozaki
866 1.173 ozaki _ifa = ifa_ifwithaddr(gateway);
867 1.173 ozaki if (_ifa != NULL)
868 1.173 ozaki error = EHOSTUNREACH;
869 1.173 ozaki pserialize_read_exit(s);
870 1.173 ozaki }
871 1.1 cgd if (error)
872 1.1 cgd goto done;
873 1.1 cgd /*
874 1.1 cgd * Create a new entry if we just got back a wildcard entry
875 1.33 soren * or the lookup failed. This is necessary for hosts
876 1.1 cgd * which use routing redirects generated by smart gateways
877 1.1 cgd * to dynamically build the routing tables.
878 1.1 cgd */
879 1.95 dyoung if (rt == NULL || (rt_mask(rt) && rt_mask(rt)->sa_len < 2))
880 1.1 cgd goto create;
881 1.1 cgd /*
882 1.1 cgd * Don't listen to the redirect if it's
883 1.65 perry * for a route to an interface.
884 1.1 cgd */
885 1.1 cgd if (rt->rt_flags & RTF_GATEWAY) {
886 1.1 cgd if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
887 1.1 cgd /*
888 1.1 cgd * Changing from route to net => route to host.
889 1.1 cgd * Create new route, rather than smashing route to net.
890 1.1 cgd */
891 1.1 cgd create:
892 1.95 dyoung if (rt != NULL)
893 1.183 ozaki rt_unref(rt);
894 1.1 cgd flags |= RTF_GATEWAY | RTF_DYNAMIC;
895 1.122 kefren memset(&info, 0, sizeof(info));
896 1.39 itojun info.rti_info[RTAX_DST] = dst;
897 1.39 itojun info.rti_info[RTAX_GATEWAY] = gateway;
898 1.39 itojun info.rti_info[RTAX_NETMASK] = netmask;
899 1.39 itojun info.rti_ifa = ifa;
900 1.39 itojun info.rti_flags = flags;
901 1.39 itojun rt = NULL;
902 1.39 itojun error = rtrequest1(RTM_ADD, &info, &rt);
903 1.39 itojun if (rt != NULL)
904 1.39 itojun flags = rt->rt_flags;
905 1.1 cgd stat = &rtstat.rts_dynamic;
906 1.1 cgd } else {
907 1.1 cgd /*
908 1.1 cgd * Smash the current notion of the gateway to
909 1.1 cgd * this destination. Should check about netmask!!!
910 1.1 cgd */
911 1.183 ozaki /*
912 1.187 ozaki * FIXME NOMPSAFE: the rtentry is updated with the existence
913 1.183 ozaki * of refeferences of it.
914 1.183 ozaki */
915 1.164 ozaki error = rt_setgate(rt, gateway);
916 1.164 ozaki if (error == 0) {
917 1.164 ozaki rt->rt_flags |= RTF_MODIFIED;
918 1.164 ozaki flags |= RTF_MODIFIED;
919 1.164 ozaki }
920 1.10 mycroft stat = &rtstat.rts_newgateway;
921 1.1 cgd }
922 1.1 cgd } else
923 1.1 cgd error = EHOSTUNREACH;
924 1.1 cgd done:
925 1.1 cgd if (rt) {
926 1.95 dyoung if (rtp != NULL && !error)
927 1.1 cgd *rtp = rt;
928 1.1 cgd else
929 1.183 ozaki rt_unref(rt);
930 1.1 cgd }
931 1.8 cgd out:
932 1.1 cgd if (error)
933 1.1 cgd rtstat.rts_badredirect++;
934 1.8 cgd else if (stat != NULL)
935 1.8 cgd (*stat)++;
936 1.95 dyoung memset(&info, 0, sizeof(info));
937 1.10 mycroft info.rti_info[RTAX_DST] = dst;
938 1.10 mycroft info.rti_info[RTAX_GATEWAY] = gateway;
939 1.10 mycroft info.rti_info[RTAX_NETMASK] = netmask;
940 1.10 mycroft info.rti_info[RTAX_AUTHOR] = src;
941 1.10 mycroft rt_missmsg(RTM_REDIRECT, &info, flags, error);
942 1.173 ozaki ifa_release(ifa, &psref);
943 1.1 cgd }
944 1.1 cgd
945 1.1 cgd /*
946 1.146 ozaki * Delete a route and generate a message.
947 1.146 ozaki * It doesn't free a passed rt.
948 1.40 itojun */
949 1.40 itojun static int
950 1.60 matt rtdeletemsg(struct rtentry *rt)
951 1.40 itojun {
952 1.40 itojun int error;
953 1.40 itojun struct rt_addrinfo info;
954 1.180 ozaki struct rtentry *retrt;
955 1.40 itojun
956 1.40 itojun /*
957 1.40 itojun * Request the new route so that the entry is not actually
958 1.40 itojun * deleted. That will allow the information being reported to
959 1.40 itojun * be accurate (and consistent with route_output()).
960 1.40 itojun */
961 1.95 dyoung memset(&info, 0, sizeof(info));
962 1.94 dyoung info.rti_info[RTAX_DST] = rt_getkey(rt);
963 1.40 itojun info.rti_info[RTAX_NETMASK] = rt_mask(rt);
964 1.40 itojun info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
965 1.40 itojun info.rti_flags = rt->rt_flags;
966 1.180 ozaki error = rtrequest1(RTM_DELETE, &info, &retrt);
967 1.40 itojun
968 1.40 itojun rt_missmsg(RTM_DELETE, &info, info.rti_flags, error);
969 1.40 itojun
970 1.95 dyoung return error;
971 1.40 itojun }
972 1.40 itojun
973 1.1 cgd struct ifaddr *
974 1.173 ozaki ifa_ifwithroute_psref(int flags, const struct sockaddr *dst,
975 1.173 ozaki const struct sockaddr *gateway, struct psref *psref)
976 1.1 cgd {
977 1.173 ozaki struct ifaddr *ifa = NULL;
978 1.173 ozaki
979 1.1 cgd if ((flags & RTF_GATEWAY) == 0) {
980 1.1 cgd /*
981 1.1 cgd * If we are adding a route to an interface,
982 1.1 cgd * and the interface is a pt to pt link
983 1.1 cgd * we should search for the destination
984 1.1 cgd * as our clue to the interface. Otherwise
985 1.1 cgd * we can use the local address.
986 1.1 cgd */
987 1.127 christos if ((flags & RTF_HOST) && gateway->sa_family != AF_LINK)
988 1.173 ozaki ifa = ifa_ifwithdstaddr_psref(dst, psref);
989 1.68 christos if (ifa == NULL)
990 1.173 ozaki ifa = ifa_ifwithaddr_psref(gateway, psref);
991 1.1 cgd } else {
992 1.1 cgd /*
993 1.1 cgd * If we are adding a route to a remote net
994 1.1 cgd * or host, the gateway may still be on the
995 1.1 cgd * other end of a pt to pt link.
996 1.1 cgd */
997 1.173 ozaki ifa = ifa_ifwithdstaddr_psref(gateway, psref);
998 1.1 cgd }
999 1.68 christos if (ifa == NULL)
1000 1.173 ozaki ifa = ifa_ifwithnet_psref(gateway, psref);
1001 1.68 christos if (ifa == NULL) {
1002 1.173 ozaki int s;
1003 1.173 ozaki struct rtentry *rt;
1004 1.173 ozaki
1005 1.173 ozaki rt = rtalloc1(dst, 0);
1006 1.68 christos if (rt == NULL)
1007 1.68 christos return NULL;
1008 1.173 ozaki /*
1009 1.173 ozaki * Just in case. May not need to do this workaround.
1010 1.173 ozaki * Revisit when working on rtentry MP-ification.
1011 1.173 ozaki */
1012 1.173 ozaki s = pserialize_read_enter();
1013 1.173 ozaki IFADDR_READER_FOREACH(ifa, rt->rt_ifp) {
1014 1.173 ozaki if (ifa == rt->rt_ifa)
1015 1.173 ozaki break;
1016 1.173 ozaki }
1017 1.173 ozaki if (ifa != NULL)
1018 1.173 ozaki ifa_acquire(ifa, psref);
1019 1.173 ozaki pserialize_read_exit(s);
1020 1.183 ozaki rt_unref(rt);
1021 1.146 ozaki if (ifa == NULL)
1022 1.68 christos return NULL;
1023 1.1 cgd }
1024 1.1 cgd if (ifa->ifa_addr->sa_family != dst->sa_family) {
1025 1.173 ozaki struct ifaddr *nifa;
1026 1.173 ozaki int s;
1027 1.173 ozaki
1028 1.173 ozaki s = pserialize_read_enter();
1029 1.173 ozaki nifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp);
1030 1.173 ozaki if (nifa != NULL) {
1031 1.173 ozaki ifa_release(ifa, psref);
1032 1.173 ozaki ifa_acquire(nifa, psref);
1033 1.173 ozaki ifa = nifa;
1034 1.173 ozaki }
1035 1.173 ozaki pserialize_read_exit(s);
1036 1.1 cgd }
1037 1.95 dyoung return ifa;
1038 1.1 cgd }
1039 1.1 cgd
1040 1.146 ozaki /*
1041 1.146 ozaki * If it suceeds and ret_nrt isn't NULL, refcnt of ret_nrt is incremented.
1042 1.146 ozaki * The caller has to rtfree it by itself.
1043 1.146 ozaki */
1044 1.9 mycroft int
1045 1.60 matt rtrequest(int req, const struct sockaddr *dst, const struct sockaddr *gateway,
1046 1.60 matt const struct sockaddr *netmask, int flags, struct rtentry **ret_nrt)
1047 1.1 cgd {
1048 1.39 itojun struct rt_addrinfo info;
1049 1.39 itojun
1050 1.44 thorpej memset(&info, 0, sizeof(info));
1051 1.39 itojun info.rti_flags = flags;
1052 1.39 itojun info.rti_info[RTAX_DST] = dst;
1053 1.39 itojun info.rti_info[RTAX_GATEWAY] = gateway;
1054 1.39 itojun info.rti_info[RTAX_NETMASK] = netmask;
1055 1.39 itojun return rtrequest1(req, &info, ret_nrt);
1056 1.39 itojun }
1057 1.39 itojun
1058 1.146 ozaki /*
1059 1.146 ozaki * It's a utility function to add/remove a route to/from the routing table
1060 1.146 ozaki * and tell user processes the addition/removal on success.
1061 1.146 ozaki */
1062 1.146 ozaki int
1063 1.146 ozaki rtrequest_newmsg(const int req, const struct sockaddr *dst,
1064 1.146 ozaki const struct sockaddr *gateway, const struct sockaddr *netmask,
1065 1.146 ozaki const int flags)
1066 1.146 ozaki {
1067 1.146 ozaki int error;
1068 1.146 ozaki struct rtentry *ret_nrt = NULL;
1069 1.146 ozaki
1070 1.146 ozaki KASSERT(req == RTM_ADD || req == RTM_DELETE);
1071 1.146 ozaki
1072 1.146 ozaki error = rtrequest(req, dst, gateway, netmask, flags, &ret_nrt);
1073 1.146 ozaki if (error != 0)
1074 1.146 ozaki return error;
1075 1.146 ozaki
1076 1.146 ozaki KASSERT(ret_nrt != NULL);
1077 1.146 ozaki
1078 1.146 ozaki rt_newmsg(req, ret_nrt); /* tell user process */
1079 1.183 ozaki if (req == RTM_DELETE)
1080 1.183 ozaki rt_free(ret_nrt);
1081 1.183 ozaki else
1082 1.183 ozaki rt_unref(ret_nrt);
1083 1.146 ozaki
1084 1.146 ozaki return 0;
1085 1.146 ozaki }
1086 1.146 ozaki
1087 1.173 ozaki struct ifnet *
1088 1.173 ozaki rt_getifp(struct rt_addrinfo *info, struct psref *psref)
1089 1.39 itojun {
1090 1.68 christos const struct sockaddr *ifpaddr = info->rti_info[RTAX_IFP];
1091 1.39 itojun
1092 1.173 ozaki if (info->rti_ifp != NULL)
1093 1.173 ozaki return NULL;
1094 1.39 itojun /*
1095 1.39 itojun * ifp may be specified by sockaddr_dl when protocol address
1096 1.39 itojun * is ambiguous
1097 1.39 itojun */
1098 1.173 ozaki if (ifpaddr != NULL && ifpaddr->sa_family == AF_LINK) {
1099 1.173 ozaki struct ifaddr *ifa;
1100 1.173 ozaki int s = pserialize_read_enter();
1101 1.173 ozaki
1102 1.173 ozaki ifa = ifa_ifwithnet(ifpaddr);
1103 1.173 ozaki if (ifa != NULL)
1104 1.173 ozaki info->rti_ifp = if_get_byindex(ifa->ifa_ifp->if_index,
1105 1.173 ozaki psref);
1106 1.173 ozaki pserialize_read_exit(s);
1107 1.39 itojun }
1108 1.173 ozaki
1109 1.173 ozaki return info->rti_ifp;
1110 1.173 ozaki }
1111 1.173 ozaki
1112 1.173 ozaki struct ifaddr *
1113 1.173 ozaki rt_getifa(struct rt_addrinfo *info, struct psref *psref)
1114 1.173 ozaki {
1115 1.174 ozaki struct ifaddr *ifa = NULL;
1116 1.173 ozaki const struct sockaddr *dst = info->rti_info[RTAX_DST];
1117 1.173 ozaki const struct sockaddr *gateway = info->rti_info[RTAX_GATEWAY];
1118 1.173 ozaki const struct sockaddr *ifaaddr = info->rti_info[RTAX_IFA];
1119 1.173 ozaki int flags = info->rti_flags;
1120 1.173 ozaki const struct sockaddr *sa;
1121 1.173 ozaki
1122 1.173 ozaki if (info->rti_ifa == NULL && ifaaddr != NULL) {
1123 1.173 ozaki ifa = ifa_ifwithaddr_psref(ifaaddr, psref);
1124 1.173 ozaki if (ifa != NULL)
1125 1.173 ozaki goto got;
1126 1.173 ozaki }
1127 1.173 ozaki
1128 1.173 ozaki sa = ifaaddr != NULL ? ifaaddr :
1129 1.173 ozaki (gateway != NULL ? gateway : dst);
1130 1.173 ozaki if (sa != NULL && info->rti_ifp != NULL)
1131 1.173 ozaki ifa = ifaof_ifpforaddr_psref(sa, info->rti_ifp, psref);
1132 1.173 ozaki else if (dst != NULL && gateway != NULL)
1133 1.173 ozaki ifa = ifa_ifwithroute_psref(flags, dst, gateway, psref);
1134 1.173 ozaki else if (sa != NULL)
1135 1.173 ozaki ifa = ifa_ifwithroute_psref(flags, sa, sa, psref);
1136 1.173 ozaki if (ifa == NULL)
1137 1.173 ozaki return NULL;
1138 1.173 ozaki got:
1139 1.145 roy if (ifa->ifa_getifa != NULL) {
1140 1.173 ozaki /* FIXME NOMPSAFE */
1141 1.173 ozaki ifa = (*ifa->ifa_getifa)(ifa, dst);
1142 1.145 roy if (ifa == NULL)
1143 1.173 ozaki return NULL;
1144 1.173 ozaki ifa_acquire(ifa, psref);
1145 1.145 roy }
1146 1.173 ozaki info->rti_ifa = ifa;
1147 1.74 dyoung if (info->rti_ifp == NULL)
1148 1.74 dyoung info->rti_ifp = ifa->ifa_ifp;
1149 1.173 ozaki return ifa;
1150 1.39 itojun }
1151 1.39 itojun
1152 1.146 ozaki /*
1153 1.146 ozaki * If it suceeds and ret_nrt isn't NULL, refcnt of ret_nrt is incremented.
1154 1.146 ozaki * The caller has to rtfree it by itself.
1155 1.146 ozaki */
1156 1.39 itojun int
1157 1.60 matt rtrequest1(int req, struct rt_addrinfo *info, struct rtentry **ret_nrt)
1158 1.39 itojun {
1159 1.173 ozaki int s = splsoftnet(), ss;
1160 1.125 dyoung int error = 0, rc;
1161 1.158 ozaki struct rtentry *rt;
1162 1.125 dyoung rtbl_t *rtbl;
1163 1.173 ozaki struct ifaddr *ifa = NULL, *ifa2 = NULL;
1164 1.94 dyoung struct sockaddr_storage maskeddst;
1165 1.68 christos const struct sockaddr *dst = info->rti_info[RTAX_DST];
1166 1.68 christos const struct sockaddr *gateway = info->rti_info[RTAX_GATEWAY];
1167 1.68 christos const struct sockaddr *netmask = info->rti_info[RTAX_NETMASK];
1168 1.68 christos int flags = info->rti_flags;
1169 1.173 ozaki struct psref psref_ifp, psref_ifa;
1170 1.173 ozaki int bound = 0;
1171 1.173 ozaki struct ifnet *ifp = NULL;
1172 1.173 ozaki bool need_to_release_ifa = true;
1173 1.183 ozaki bool need_unlock = true;
1174 1.1 cgd #define senderr(x) { error = x ; goto bad; }
1175 1.1 cgd
1176 1.183 ozaki RT_WLOCK();
1177 1.183 ozaki
1178 1.173 ozaki bound = curlwp_bind();
1179 1.125 dyoung if ((rtbl = rt_gettable(dst->sa_family)) == NULL)
1180 1.1 cgd senderr(ESRCH);
1181 1.1 cgd if (flags & RTF_HOST)
1182 1.68 christos netmask = NULL;
1183 1.1 cgd switch (req) {
1184 1.1 cgd case RTM_DELETE:
1185 1.63 christos if (netmask) {
1186 1.94 dyoung rt_maskedcopy(dst, (struct sockaddr *)&maskeddst,
1187 1.94 dyoung netmask);
1188 1.94 dyoung dst = (struct sockaddr *)&maskeddst;
1189 1.63 christos }
1190 1.125 dyoung if ((rt = rt_lookup(rtbl, dst, netmask)) == NULL)
1191 1.41 itojun senderr(ESRCH);
1192 1.125 dyoung if ((rt = rt_deladdr(rtbl, dst, netmask)) == NULL)
1193 1.1 cgd senderr(ESRCH);
1194 1.28 erh rt->rt_flags &= ~RTF_UP;
1195 1.116 roy if ((ifa = rt->rt_ifa)) {
1196 1.116 roy if (ifa->ifa_flags & IFA_ROUTE &&
1197 1.116 roy rt_ifa_connected(rt, ifa)) {
1198 1.116 roy RT_DPRINTF("rt->_rt_key = %p, ifa = %p, "
1199 1.116 roy "deleted IFA_ROUTE\n",
1200 1.116 roy (void *)rt->_rt_key, (void *)ifa);
1201 1.116 roy ifa->ifa_flags &= ~IFA_ROUTE;
1202 1.116 roy }
1203 1.116 roy if (ifa->ifa_rtrequest)
1204 1.116 roy ifa->ifa_rtrequest(RTM_DELETE, rt, info);
1205 1.173 ozaki ifa = NULL;
1206 1.116 roy }
1207 1.1 cgd rttrash++;
1208 1.146 ozaki if (ret_nrt) {
1209 1.10 mycroft *ret_nrt = rt;
1210 1.183 ozaki rt_ref(rt);
1211 1.183 ozaki RT_REFCNT_TRACE(rt);
1212 1.183 ozaki }
1213 1.183 ozaki RT_UNLOCK();
1214 1.183 ozaki need_unlock = false;
1215 1.183 ozaki rt_timer_remove_all(rt);
1216 1.183 ozaki rtcache_clear_rtentry(dst->sa_family, rt);
1217 1.183 ozaki if (ret_nrt == NULL) {
1218 1.146 ozaki /* Adjust the refcount */
1219 1.183 ozaki rt_ref(rt);
1220 1.183 ozaki RT_REFCNT_TRACE(rt);
1221 1.183 ozaki rt_free(rt);
1222 1.10 mycroft }
1223 1.1 cgd break;
1224 1.1 cgd
1225 1.1 cgd case RTM_ADD:
1226 1.173 ozaki if (info->rti_ifa == NULL) {
1227 1.173 ozaki ifp = rt_getifp(info, &psref_ifp);
1228 1.173 ozaki ifa = rt_getifa(info, &psref_ifa);
1229 1.173 ozaki if (ifa == NULL)
1230 1.173 ozaki senderr(ENETUNREACH);
1231 1.173 ozaki } else {
1232 1.173 ozaki /* Caller should have a reference of ifa */
1233 1.173 ozaki ifa = info->rti_ifa;
1234 1.173 ozaki need_to_release_ifa = false;
1235 1.173 ozaki }
1236 1.22 thorpej rt = pool_get(&rtentry_pool, PR_NOWAIT);
1237 1.68 christos if (rt == NULL)
1238 1.1 cgd senderr(ENOBUFS);
1239 1.109 dyoung memset(rt, 0, sizeof(*rt));
1240 1.10 mycroft rt->rt_flags = RTF_UP | flags;
1241 1.18 kml LIST_INIT(&rt->rt_timer);
1242 1.163 ozaki
1243 1.110 dyoung RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1244 1.1 cgd if (netmask) {
1245 1.94 dyoung rt_maskedcopy(dst, (struct sockaddr *)&maskeddst,
1246 1.94 dyoung netmask);
1247 1.96 dyoung rt_setkey(rt, (struct sockaddr *)&maskeddst, M_NOWAIT);
1248 1.94 dyoung } else {
1249 1.96 dyoung rt_setkey(rt, dst, M_NOWAIT);
1250 1.94 dyoung }
1251 1.163 ozaki RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1252 1.163 ozaki if (rt_getkey(rt) == NULL ||
1253 1.163 ozaki rt_setgate(rt, gateway) != 0) {
1254 1.163 ozaki pool_put(&rtentry_pool, rt);
1255 1.163 ozaki senderr(ENOBUFS);
1256 1.163 ozaki }
1257 1.163 ozaki
1258 1.74 dyoung rt_set_ifa(rt, ifa);
1259 1.164 ozaki if (info->rti_info[RTAX_TAG] != NULL) {
1260 1.164 ozaki const struct sockaddr *tag;
1261 1.164 ozaki tag = rt_settag(rt, info->rti_info[RTAX_TAG]);
1262 1.164 ozaki if (tag == NULL)
1263 1.164 ozaki senderr(ENOBUFS);
1264 1.164 ozaki }
1265 1.110 dyoung RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1266 1.173 ozaki
1267 1.173 ozaki ss = pserialize_read_enter();
1268 1.173 ozaki if (info->rti_info[RTAX_IFP] != NULL) {
1269 1.173 ozaki ifa2 = ifa_ifwithnet(info->rti_info[RTAX_IFP]);
1270 1.173 ozaki if (ifa2 != NULL)
1271 1.173 ozaki rt->rt_ifp = ifa2->ifa_ifp;
1272 1.173 ozaki else
1273 1.173 ozaki rt->rt_ifp = ifa->ifa_ifp;
1274 1.173 ozaki } else
1275 1.122 kefren rt->rt_ifp = ifa->ifa_ifp;
1276 1.173 ozaki pserialize_read_exit(ss);
1277 1.183 ozaki cv_init(&rt->rt_cv, "rtentry");
1278 1.183 ozaki psref_target_init(&rt->rt_psref, rt_psref_class);
1279 1.173 ozaki
1280 1.110 dyoung RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1281 1.125 dyoung rc = rt_addaddr(rtbl, rt, netmask);
1282 1.110 dyoung RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1283 1.125 dyoung if (rc != 0) {
1284 1.173 ozaki ifafree(ifa); /* for rt_set_ifa above */
1285 1.183 ozaki cv_destroy(&rt->rt_cv);
1286 1.94 dyoung rt_destroy(rt);
1287 1.40 itojun pool_put(&rtentry_pool, rt);
1288 1.125 dyoung senderr(rc);
1289 1.27 matt }
1290 1.110 dyoung RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1291 1.1 cgd if (ifa->ifa_rtrequest)
1292 1.39 itojun ifa->ifa_rtrequest(req, rt, info);
1293 1.173 ozaki if (need_to_release_ifa)
1294 1.173 ozaki ifa_release(ifa, &psref_ifa);
1295 1.173 ozaki ifa = NULL;
1296 1.173 ozaki if_put(ifp, &psref_ifp);
1297 1.173 ozaki ifp = NULL;
1298 1.110 dyoung RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1299 1.1 cgd if (ret_nrt) {
1300 1.1 cgd *ret_nrt = rt;
1301 1.183 ozaki rt_ref(rt);
1302 1.183 ozaki RT_REFCNT_TRACE(rt);
1303 1.41 itojun }
1304 1.183 ozaki RT_UNLOCK();
1305 1.183 ozaki need_unlock = false;
1306 1.82 dyoung rtflushall(dst->sa_family);
1307 1.1 cgd break;
1308 1.92 dyoung case RTM_GET:
1309 1.94 dyoung if (netmask != NULL) {
1310 1.94 dyoung rt_maskedcopy(dst, (struct sockaddr *)&maskeddst,
1311 1.94 dyoung netmask);
1312 1.94 dyoung dst = (struct sockaddr *)&maskeddst;
1313 1.94 dyoung }
1314 1.125 dyoung if ((rt = rt_lookup(rtbl, dst, netmask)) == NULL)
1315 1.92 dyoung senderr(ESRCH);
1316 1.92 dyoung if (ret_nrt != NULL) {
1317 1.92 dyoung *ret_nrt = rt;
1318 1.183 ozaki rt_ref(rt);
1319 1.183 ozaki RT_REFCNT_TRACE(rt);
1320 1.92 dyoung }
1321 1.92 dyoung break;
1322 1.1 cgd }
1323 1.1 cgd bad:
1324 1.173 ozaki if (need_to_release_ifa)
1325 1.173 ozaki ifa_release(ifa, &psref_ifa);
1326 1.173 ozaki if_put(ifp, &psref_ifp);
1327 1.173 ozaki curlwp_bindx(bound);
1328 1.183 ozaki if (need_unlock)
1329 1.183 ozaki RT_UNLOCK();
1330 1.1 cgd splx(s);
1331 1.95 dyoung return error;
1332 1.1 cgd }
1333 1.1 cgd
1334 1.10 mycroft int
1335 1.94 dyoung rt_setgate(struct rtentry *rt, const struct sockaddr *gate)
1336 1.10 mycroft {
1337 1.176 ozaki struct sockaddr *new, *old;
1338 1.94 dyoung
1339 1.94 dyoung KASSERT(rt->_rt_key != NULL);
1340 1.110 dyoung RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1341 1.94 dyoung
1342 1.176 ozaki new = sockaddr_dup(gate, M_ZERO | M_NOWAIT);
1343 1.176 ozaki if (new == NULL)
1344 1.94 dyoung return ENOMEM;
1345 1.176 ozaki
1346 1.176 ozaki old = rt->rt_gateway;
1347 1.176 ozaki rt->rt_gateway = new;
1348 1.176 ozaki if (old != NULL)
1349 1.176 ozaki sockaddr_free(old);
1350 1.176 ozaki
1351 1.94 dyoung KASSERT(rt->_rt_key != NULL);
1352 1.110 dyoung RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1353 1.94 dyoung
1354 1.10 mycroft if (rt->rt_flags & RTF_GATEWAY) {
1355 1.183 ozaki struct rtentry *gwrt;
1356 1.183 ozaki
1357 1.183 ozaki /* XXX we cannot call rtalloc1 if holding the rt lock */
1358 1.183 ozaki if (RT_LOCKED())
1359 1.183 ozaki gwrt = rtalloc1_locked(gate, 1, false);
1360 1.183 ozaki else
1361 1.183 ozaki gwrt = rtalloc1(gate, 1);
1362 1.27 matt /*
1363 1.27 matt * If we switched gateways, grab the MTU from the new
1364 1.47 itojun * gateway route if the current MTU, if the current MTU is
1365 1.47 itojun * greater than the MTU of gateway.
1366 1.47 itojun * Note that, if the MTU of gateway is 0, we will reset the
1367 1.47 itojun * MTU of the route to run PMTUD again from scratch. XXX
1368 1.27 matt */
1369 1.166 ozaki if (gwrt != NULL) {
1370 1.166 ozaki KASSERT(gwrt->_rt_key != NULL);
1371 1.166 ozaki RT_DPRINTF("gwrt->_rt_key = %p\n", gwrt->_rt_key);
1372 1.166 ozaki if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0 &&
1373 1.166 ozaki rt->rt_rmx.rmx_mtu &&
1374 1.166 ozaki rt->rt_rmx.rmx_mtu > gwrt->rt_rmx.rmx_mtu) {
1375 1.166 ozaki rt->rt_rmx.rmx_mtu = gwrt->rt_rmx.rmx_mtu;
1376 1.166 ozaki }
1377 1.183 ozaki rt_unref(gwrt);
1378 1.27 matt }
1379 1.10 mycroft }
1380 1.94 dyoung KASSERT(rt->_rt_key != NULL);
1381 1.110 dyoung RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
1382 1.10 mycroft return 0;
1383 1.10 mycroft }
1384 1.10 mycroft
1385 1.141 ozaki static void
1386 1.60 matt rt_maskedcopy(const struct sockaddr *src, struct sockaddr *dst,
1387 1.60 matt const struct sockaddr *netmask)
1388 1.1 cgd {
1389 1.94 dyoung const char *netmaskp = &netmask->sa_data[0],
1390 1.94 dyoung *srcp = &src->sa_data[0];
1391 1.94 dyoung char *dstp = &dst->sa_data[0];
1392 1.126 christos const char *maskend = (char *)dst + MIN(netmask->sa_len, src->sa_len);
1393 1.126 christos const char *srcend = (char *)dst + src->sa_len;
1394 1.94 dyoung
1395 1.94 dyoung dst->sa_len = src->sa_len;
1396 1.94 dyoung dst->sa_family = src->sa_family;
1397 1.94 dyoung
1398 1.94 dyoung while (dstp < maskend)
1399 1.94 dyoung *dstp++ = *srcp++ & *netmaskp++;
1400 1.94 dyoung if (dstp < srcend)
1401 1.94 dyoung memset(dstp, 0, (size_t)(srcend - dstp));
1402 1.1 cgd }
1403 1.10 mycroft
1404 1.1 cgd /*
1405 1.135 roy * Inform the routing socket of a route change.
1406 1.135 roy */
1407 1.135 roy void
1408 1.154 ozaki rt_newmsg(const int cmd, const struct rtentry *rt)
1409 1.135 roy {
1410 1.135 roy struct rt_addrinfo info;
1411 1.135 roy
1412 1.135 roy memset((void *)&info, 0, sizeof(info));
1413 1.135 roy info.rti_info[RTAX_DST] = rt_getkey(rt);
1414 1.135 roy info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
1415 1.135 roy info.rti_info[RTAX_NETMASK] = rt_mask(rt);
1416 1.135 roy if (rt->rt_ifp) {
1417 1.135 roy info.rti_info[RTAX_IFP] = rt->rt_ifp->if_dl->ifa_addr;
1418 1.135 roy info.rti_info[RTAX_IFA] = rt->rt_ifa->ifa_addr;
1419 1.135 roy }
1420 1.135 roy
1421 1.135 roy rt_missmsg(cmd, &info, rt->rt_flags, 0);
1422 1.135 roy }
1423 1.135 roy
1424 1.135 roy /*
1425 1.29 sommerfe * Set up or tear down a routing table entry, normally
1426 1.1 cgd * for an interface.
1427 1.1 cgd */
1428 1.9 mycroft int
1429 1.60 matt rtinit(struct ifaddr *ifa, int cmd, int flags)
1430 1.1 cgd {
1431 1.36 augustss struct rtentry *rt;
1432 1.36 augustss struct sockaddr *dst, *odst;
1433 1.94 dyoung struct sockaddr_storage maskeddst;
1434 1.68 christos struct rtentry *nrt = NULL;
1435 1.1 cgd int error;
1436 1.39 itojun struct rt_addrinfo info;
1437 1.1 cgd
1438 1.1 cgd dst = flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr;
1439 1.1 cgd if (cmd == RTM_DELETE) {
1440 1.1 cgd if ((flags & RTF_HOST) == 0 && ifa->ifa_netmask) {
1441 1.29 sommerfe /* Delete subnet route for this interface */
1442 1.29 sommerfe odst = dst;
1443 1.94 dyoung dst = (struct sockaddr *)&maskeddst;
1444 1.29 sommerfe rt_maskedcopy(odst, dst, ifa->ifa_netmask);
1445 1.1 cgd }
1446 1.14 christos if ((rt = rtalloc1(dst, 0)) != NULL) {
1447 1.146 ozaki if (rt->rt_ifa != ifa) {
1448 1.183 ozaki rt_unref(rt);
1449 1.85 dyoung return (flags & RTF_HOST) ? EHOSTUNREACH
1450 1.85 dyoung : ENETUNREACH;
1451 1.146 ozaki }
1452 1.183 ozaki rt_unref(rt);
1453 1.1 cgd }
1454 1.1 cgd }
1455 1.44 thorpej memset(&info, 0, sizeof(info));
1456 1.39 itojun info.rti_ifa = ifa;
1457 1.39 itojun info.rti_flags = flags | ifa->ifa_flags;
1458 1.39 itojun info.rti_info[RTAX_DST] = dst;
1459 1.39 itojun info.rti_info[RTAX_GATEWAY] = ifa->ifa_addr;
1460 1.158 ozaki
1461 1.39 itojun /*
1462 1.39 itojun * XXX here, it seems that we are assuming that ifa_netmask is NULL
1463 1.39 itojun * for RTF_HOST. bsdi4 passes NULL explicitly (via intermediate
1464 1.39 itojun * variable) when RTF_HOST is 1. still not sure if i can safely
1465 1.39 itojun * change it to meet bsdi4 behavior.
1466 1.39 itojun */
1467 1.114 dyoung if (cmd != RTM_LLINFO_UPD)
1468 1.114 dyoung info.rti_info[RTAX_NETMASK] = ifa->ifa_netmask;
1469 1.114 dyoung error = rtrequest1((cmd == RTM_LLINFO_UPD) ? RTM_GET : cmd, &info,
1470 1.114 dyoung &nrt);
1471 1.153 ozaki if (error != 0)
1472 1.146 ozaki return error;
1473 1.146 ozaki
1474 1.153 ozaki rt = nrt;
1475 1.183 ozaki RT_REFCNT_TRACE(rt);
1476 1.146 ozaki switch (cmd) {
1477 1.114 dyoung case RTM_DELETE:
1478 1.146 ozaki rt_newmsg(cmd, rt);
1479 1.183 ozaki rt_free(rt);
1480 1.114 dyoung break;
1481 1.114 dyoung case RTM_LLINFO_UPD:
1482 1.114 dyoung if (cmd == RTM_LLINFO_UPD && ifa->ifa_rtrequest != NULL)
1483 1.114 dyoung ifa->ifa_rtrequest(RTM_LLINFO_UPD, rt, &info);
1484 1.146 ozaki rt_newmsg(RTM_CHANGE, rt);
1485 1.183 ozaki rt_unref(rt);
1486 1.114 dyoung break;
1487 1.114 dyoung case RTM_ADD:
1488 1.183 ozaki /*
1489 1.187 ozaki * FIXME NOMPSAFE: the rtentry is updated with the existence
1490 1.183 ozaki * of refeferences of it.
1491 1.183 ozaki */
1492 1.183 ozaki /*
1493 1.183 ozaki * XXX it looks just reverting rt_ifa replaced by ifa_rtrequest
1494 1.183 ozaki * called via rtrequest1. Can we just prevent the replacement
1495 1.183 ozaki * somehow and remove the following code? And also doesn't
1496 1.183 ozaki * calling ifa_rtrequest(RTM_ADD) replace rt_ifa again?
1497 1.183 ozaki */
1498 1.10 mycroft if (rt->rt_ifa != ifa) {
1499 1.17 christos printf("rtinit: wrong ifa (%p) was (%p)\n", ifa,
1500 1.17 christos rt->rt_ifa);
1501 1.114 dyoung if (rt->rt_ifa->ifa_rtrequest != NULL) {
1502 1.114 dyoung rt->rt_ifa->ifa_rtrequest(RTM_DELETE, rt,
1503 1.114 dyoung &info);
1504 1.114 dyoung }
1505 1.74 dyoung rt_replace_ifa(rt, ifa);
1506 1.10 mycroft rt->rt_ifp = ifa->ifa_ifp;
1507 1.114 dyoung if (ifa->ifa_rtrequest != NULL)
1508 1.114 dyoung ifa->ifa_rtrequest(RTM_ADD, rt, &info);
1509 1.10 mycroft }
1510 1.146 ozaki rt_newmsg(cmd, rt);
1511 1.183 ozaki rt_unref(rt);
1512 1.183 ozaki RT_REFCNT_TRACE(rt);
1513 1.114 dyoung break;
1514 1.1 cgd }
1515 1.85 dyoung return error;
1516 1.18 kml }
1517 1.18 kml
1518 1.136 roy /*
1519 1.136 roy * Create a local route entry for the address.
1520 1.136 roy * Announce the addition of the address and the route to the routing socket.
1521 1.136 roy */
1522 1.136 roy int
1523 1.136 roy rt_ifa_addlocal(struct ifaddr *ifa)
1524 1.136 roy {
1525 1.136 roy struct rtentry *rt;
1526 1.136 roy int e;
1527 1.136 roy
1528 1.136 roy /* If there is no loopback entry, allocate one. */
1529 1.136 roy rt = rtalloc1(ifa->ifa_addr, 0);
1530 1.158 ozaki #ifdef RT_DEBUG
1531 1.158 ozaki if (rt != NULL)
1532 1.158 ozaki dump_rt(rt);
1533 1.158 ozaki #endif
1534 1.136 roy if (rt == NULL || (rt->rt_flags & RTF_HOST) == 0 ||
1535 1.136 roy (rt->rt_ifp->if_flags & IFF_LOOPBACK) == 0)
1536 1.152 roy {
1537 1.152 roy struct rt_addrinfo info;
1538 1.152 roy struct rtentry *nrt;
1539 1.152 roy
1540 1.152 roy memset(&info, 0, sizeof(info));
1541 1.152 roy info.rti_flags = RTF_HOST | RTF_LOCAL;
1542 1.152 roy if (!(ifa->ifa_ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT)))
1543 1.158 ozaki info.rti_flags |= RTF_LLDATA;
1544 1.152 roy info.rti_info[RTAX_DST] = ifa->ifa_addr;
1545 1.152 roy info.rti_info[RTAX_GATEWAY] =
1546 1.152 roy (const struct sockaddr *)ifa->ifa_ifp->if_sadl;
1547 1.152 roy info.rti_ifa = ifa;
1548 1.152 roy nrt = NULL;
1549 1.152 roy e = rtrequest1(RTM_ADD, &info, &nrt);
1550 1.152 roy if (nrt && ifa != nrt->rt_ifa)
1551 1.152 roy rt_replace_ifa(nrt, ifa);
1552 1.152 roy rt_newaddrmsg(RTM_ADD, ifa, e, nrt);
1553 1.158 ozaki if (nrt != NULL) {
1554 1.158 ozaki #ifdef RT_DEBUG
1555 1.158 ozaki dump_rt(nrt);
1556 1.158 ozaki #endif
1557 1.183 ozaki rt_unref(nrt);
1558 1.183 ozaki RT_REFCNT_TRACE(nrt);
1559 1.158 ozaki }
1560 1.152 roy } else {
1561 1.136 roy e = 0;
1562 1.136 roy rt_newaddrmsg(RTM_NEWADDR, ifa, 0, NULL);
1563 1.136 roy }
1564 1.136 roy if (rt != NULL)
1565 1.183 ozaki rt_unref(rt);
1566 1.136 roy return e;
1567 1.136 roy }
1568 1.136 roy
1569 1.136 roy /*
1570 1.136 roy * Remove the local route entry for the address.
1571 1.136 roy * Announce the removal of the address and the route to the routing socket.
1572 1.136 roy */
1573 1.136 roy int
1574 1.136 roy rt_ifa_remlocal(struct ifaddr *ifa, struct ifaddr *alt_ifa)
1575 1.136 roy {
1576 1.136 roy struct rtentry *rt;
1577 1.136 roy int e = 0;
1578 1.136 roy
1579 1.136 roy rt = rtalloc1(ifa->ifa_addr, 0);
1580 1.136 roy
1581 1.136 roy /*
1582 1.136 roy * Before deleting, check if a corresponding loopbacked
1583 1.136 roy * host route surely exists. With this check, we can avoid
1584 1.136 roy * deleting an interface direct route whose destination is
1585 1.136 roy * the same as the address being removed. This can happen
1586 1.136 roy * when removing a subnet-router anycast address on an
1587 1.136 roy * interface attached to a shared medium.
1588 1.136 roy */
1589 1.136 roy if (rt != NULL &&
1590 1.136 roy (rt->rt_flags & RTF_HOST) &&
1591 1.136 roy (rt->rt_ifp->if_flags & IFF_LOOPBACK))
1592 1.136 roy {
1593 1.136 roy /* If we cannot replace the route's ifaddr with the equivalent
1594 1.136 roy * ifaddr of another interface, I believe it is safest to
1595 1.136 roy * delete the route.
1596 1.136 roy */
1597 1.152 roy if (alt_ifa == NULL) {
1598 1.152 roy e = rtdeletemsg(rt);
1599 1.183 ozaki if (e == 0) {
1600 1.183 ozaki rt_unref(rt);
1601 1.183 ozaki rt_free(rt);
1602 1.183 ozaki rt = NULL;
1603 1.183 ozaki }
1604 1.152 roy rt_newaddrmsg(RTM_DELADDR, ifa, 0, NULL);
1605 1.152 roy } else {
1606 1.136 roy rt_replace_ifa(rt, alt_ifa);
1607 1.136 roy rt_newmsg(RTM_CHANGE, rt);
1608 1.136 roy }
1609 1.136 roy } else
1610 1.136 roy rt_newaddrmsg(RTM_DELADDR, ifa, 0, NULL);
1611 1.136 roy if (rt != NULL)
1612 1.183 ozaki rt_unref(rt);
1613 1.136 roy return e;
1614 1.136 roy }
1615 1.136 roy
1616 1.18 kml /*
1617 1.18 kml * Route timer routines. These routes allow functions to be called
1618 1.18 kml * for various routes at any time. This is useful in supporting
1619 1.18 kml * path MTU discovery and redirect route deletion.
1620 1.18 kml *
1621 1.18 kml * This is similar to some BSDI internal functions, but it provides
1622 1.18 kml * for multiple queues for efficiency's sake...
1623 1.18 kml */
1624 1.18 kml
1625 1.18 kml LIST_HEAD(, rttimer_queue) rttimer_queue_head;
1626 1.18 kml static int rt_init_done = 0;
1627 1.18 kml
1628 1.65 perry /*
1629 1.18 kml * Some subtle order problems with domain initialization mean that
1630 1.18 kml * we cannot count on this being run from rt_init before various
1631 1.18 kml * protocol initializations are done. Therefore, we make sure
1632 1.18 kml * that this is run when the first queue is added...
1633 1.18 kml */
1634 1.18 kml
1635 1.170 ozaki static void rt_timer_work(struct work *, void *);
1636 1.170 ozaki
1637 1.177 ozaki static void
1638 1.60 matt rt_timer_init(void)
1639 1.18 kml {
1640 1.170 ozaki int error;
1641 1.170 ozaki
1642 1.18 kml assert(rt_init_done == 0);
1643 1.18 kml
1644 1.183 ozaki /* XXX should be in rt_init */
1645 1.183 ozaki rw_init(&rt_lock);
1646 1.183 ozaki rw_init(&rtcache_lock);
1647 1.183 ozaki
1648 1.18 kml LIST_INIT(&rttimer_queue_head);
1649 1.172 martin callout_init(&rt_timer_ch, CALLOUT_MPSAFE);
1650 1.170 ozaki error = workqueue_create(&rt_timer_wq, "rt_timer",
1651 1.170 ozaki rt_timer_work, NULL, PRI_SOFTNET, IPL_SOFTNET, WQ_MPSAFE);
1652 1.170 ozaki if (error)
1653 1.170 ozaki panic("%s: workqueue_create failed (%d)\n", __func__, error);
1654 1.172 martin callout_reset(&rt_timer_ch, hz, rt_timer_timer, NULL);
1655 1.18 kml rt_init_done = 1;
1656 1.18 kml }
1657 1.18 kml
1658 1.18 kml struct rttimer_queue *
1659 1.60 matt rt_timer_queue_create(u_int timeout)
1660 1.18 kml {
1661 1.18 kml struct rttimer_queue *rtq;
1662 1.18 kml
1663 1.18 kml if (rt_init_done == 0)
1664 1.18 kml rt_timer_init();
1665 1.18 kml
1666 1.18 kml R_Malloc(rtq, struct rttimer_queue *, sizeof *rtq);
1667 1.18 kml if (rtq == NULL)
1668 1.85 dyoung return NULL;
1669 1.109 dyoung memset(rtq, 0, sizeof(*rtq));
1670 1.18 kml
1671 1.18 kml rtq->rtq_timeout = timeout;
1672 1.24 thorpej TAILQ_INIT(&rtq->rtq_head);
1673 1.183 ozaki RT_WLOCK();
1674 1.18 kml LIST_INSERT_HEAD(&rttimer_queue_head, rtq, rtq_link);
1675 1.183 ozaki RT_UNLOCK();
1676 1.18 kml
1677 1.85 dyoung return rtq;
1678 1.18 kml }
1679 1.18 kml
1680 1.18 kml void
1681 1.60 matt rt_timer_queue_change(struct rttimer_queue *rtq, long timeout)
1682 1.18 kml {
1683 1.24 thorpej
1684 1.18 kml rtq->rtq_timeout = timeout;
1685 1.18 kml }
1686 1.18 kml
1687 1.177 ozaki static void
1688 1.181 ozaki rt_timer_queue_remove_all(struct rttimer_queue *rtq)
1689 1.18 kml {
1690 1.24 thorpej struct rttimer *r;
1691 1.18 kml
1692 1.183 ozaki RT_ASSERT_WLOCK();
1693 1.183 ozaki
1694 1.24 thorpej while ((r = TAILQ_FIRST(&rtq->rtq_head)) != NULL) {
1695 1.18 kml LIST_REMOVE(r, rtt_link);
1696 1.24 thorpej TAILQ_REMOVE(&rtq->rtq_head, r, rtt_next);
1697 1.183 ozaki rt_ref(r->rtt_rt); /* XXX */
1698 1.183 ozaki RT_REFCNT_TRACE(r->rtt_rt);
1699 1.183 ozaki RT_UNLOCK();
1700 1.181 ozaki (*r->rtt_func)(r->rtt_rt, r);
1701 1.22 thorpej pool_put(&rttimer_pool, r);
1702 1.183 ozaki RT_WLOCK();
1703 1.37 itojun if (rtq->rtq_count > 0)
1704 1.37 itojun rtq->rtq_count--;
1705 1.37 itojun else
1706 1.55 itojun printf("rt_timer_queue_remove_all: "
1707 1.55 itojun "rtq_count reached 0\n");
1708 1.18 kml }
1709 1.55 itojun }
1710 1.55 itojun
1711 1.55 itojun void
1712 1.181 ozaki rt_timer_queue_destroy(struct rttimer_queue *rtq)
1713 1.55 itojun {
1714 1.55 itojun
1715 1.183 ozaki RT_WLOCK();
1716 1.181 ozaki rt_timer_queue_remove_all(rtq);
1717 1.18 kml LIST_REMOVE(rtq, rtq_link);
1718 1.183 ozaki RT_UNLOCK();
1719 1.22 thorpej
1720 1.22 thorpej /*
1721 1.22 thorpej * Caller is responsible for freeing the rttimer_queue structure.
1722 1.22 thorpej */
1723 1.18 kml }
1724 1.18 kml
1725 1.37 itojun unsigned long
1726 1.60 matt rt_timer_count(struct rttimer_queue *rtq)
1727 1.37 itojun {
1728 1.37 itojun return rtq->rtq_count;
1729 1.37 itojun }
1730 1.37 itojun
1731 1.177 ozaki static void
1732 1.178 ozaki rt_timer_remove_all(struct rtentry *rt)
1733 1.18 kml {
1734 1.24 thorpej struct rttimer *r;
1735 1.18 kml
1736 1.183 ozaki RT_WLOCK();
1737 1.24 thorpej while ((r = LIST_FIRST(&rt->rt_timer)) != NULL) {
1738 1.18 kml LIST_REMOVE(r, rtt_link);
1739 1.24 thorpej TAILQ_REMOVE(&r->rtt_queue->rtq_head, r, rtt_next);
1740 1.37 itojun if (r->rtt_queue->rtq_count > 0)
1741 1.37 itojun r->rtt_queue->rtq_count--;
1742 1.37 itojun else
1743 1.37 itojun printf("rt_timer_remove_all: rtq_count reached 0\n");
1744 1.38 itojun pool_put(&rttimer_pool, r);
1745 1.18 kml }
1746 1.183 ozaki RT_UNLOCK();
1747 1.18 kml }
1748 1.18 kml
1749 1.65 perry int
1750 1.60 matt rt_timer_add(struct rtentry *rt,
1751 1.60 matt void (*func)(struct rtentry *, struct rttimer *),
1752 1.60 matt struct rttimer_queue *queue)
1753 1.18 kml {
1754 1.24 thorpej struct rttimer *r;
1755 1.18 kml
1756 1.156 ozaki KASSERT(func != NULL);
1757 1.183 ozaki RT_WLOCK();
1758 1.24 thorpej /*
1759 1.24 thorpej * If there's already a timer with this action, destroy it before
1760 1.24 thorpej * we add a new one.
1761 1.24 thorpej */
1762 1.85 dyoung LIST_FOREACH(r, &rt->rt_timer, rtt_link) {
1763 1.85 dyoung if (r->rtt_func == func)
1764 1.85 dyoung break;
1765 1.85 dyoung }
1766 1.85 dyoung if (r != NULL) {
1767 1.85 dyoung LIST_REMOVE(r, rtt_link);
1768 1.85 dyoung TAILQ_REMOVE(&r->rtt_queue->rtq_head, r, rtt_next);
1769 1.85 dyoung if (r->rtt_queue->rtq_count > 0)
1770 1.85 dyoung r->rtt_queue->rtq_count--;
1771 1.85 dyoung else
1772 1.85 dyoung printf("rt_timer_add: rtq_count reached 0\n");
1773 1.85 dyoung } else {
1774 1.85 dyoung r = pool_get(&rttimer_pool, PR_NOWAIT);
1775 1.183 ozaki if (r == NULL) {
1776 1.183 ozaki RT_UNLOCK();
1777 1.85 dyoung return ENOBUFS;
1778 1.183 ozaki }
1779 1.18 kml }
1780 1.18 kml
1781 1.85 dyoung memset(r, 0, sizeof(*r));
1782 1.24 thorpej
1783 1.24 thorpej r->rtt_rt = rt;
1784 1.70 kardel r->rtt_time = time_uptime;
1785 1.24 thorpej r->rtt_func = func;
1786 1.24 thorpej r->rtt_queue = queue;
1787 1.24 thorpej LIST_INSERT_HEAD(&rt->rt_timer, r, rtt_link);
1788 1.24 thorpej TAILQ_INSERT_TAIL(&queue->rtq_head, r, rtt_next);
1789 1.37 itojun r->rtt_queue->rtq_count++;
1790 1.65 perry
1791 1.183 ozaki RT_UNLOCK();
1792 1.183 ozaki
1793 1.95 dyoung return 0;
1794 1.18 kml }
1795 1.18 kml
1796 1.170 ozaki static void
1797 1.170 ozaki rt_timer_work(struct work *wk, void *arg)
1798 1.18 kml {
1799 1.24 thorpej struct rttimer_queue *rtq;
1800 1.24 thorpej struct rttimer *r;
1801 1.21 kml
1802 1.183 ozaki RT_WLOCK();
1803 1.85 dyoung LIST_FOREACH(rtq, &rttimer_queue_head, rtq_link) {
1804 1.24 thorpej while ((r = TAILQ_FIRST(&rtq->rtq_head)) != NULL &&
1805 1.70 kardel (r->rtt_time + rtq->rtq_timeout) < time_uptime) {
1806 1.24 thorpej LIST_REMOVE(r, rtt_link);
1807 1.24 thorpej TAILQ_REMOVE(&rtq->rtq_head, r, rtt_next);
1808 1.183 ozaki rt_ref(r->rtt_rt); /* XXX */
1809 1.183 ozaki RT_REFCNT_TRACE(r->rtt_rt);
1810 1.183 ozaki RT_UNLOCK();
1811 1.156 ozaki (*r->rtt_func)(r->rtt_rt, r);
1812 1.24 thorpej pool_put(&rttimer_pool, r);
1813 1.183 ozaki RT_WLOCK();
1814 1.37 itojun if (rtq->rtq_count > 0)
1815 1.37 itojun rtq->rtq_count--;
1816 1.37 itojun else
1817 1.37 itojun printf("rt_timer_timer: rtq_count reached 0\n");
1818 1.18 kml }
1819 1.18 kml }
1820 1.183 ozaki RT_UNLOCK();
1821 1.18 kml
1822 1.35 thorpej callout_reset(&rt_timer_ch, hz, rt_timer_timer, NULL);
1823 1.1 cgd }
1824 1.83 joerg
1825 1.177 ozaki static void
1826 1.170 ozaki rt_timer_timer(void *arg)
1827 1.170 ozaki {
1828 1.170 ozaki
1829 1.170 ozaki workqueue_enqueue(rt_timer_wq, &rt_timer_wk, NULL);
1830 1.170 ozaki }
1831 1.170 ozaki
1832 1.102 dyoung static struct rtentry *
1833 1.84 joerg _rtcache_init(struct route *ro, int flag)
1834 1.84 joerg {
1835 1.183 ozaki struct rtentry *rt;
1836 1.183 ozaki
1837 1.114 dyoung rtcache_invariants(ro);
1838 1.99 dyoung KASSERT(ro->_ro_rt == NULL);
1839 1.183 ozaki RTCACHE_ASSERT_WLOCK();
1840 1.84 joerg
1841 1.90 dyoung if (rtcache_getdst(ro) == NULL)
1842 1.102 dyoung return NULL;
1843 1.105 dyoung ro->ro_invalid = false;
1844 1.183 ozaki rt = rtalloc1(rtcache_getdst(ro), flag);
1845 1.183 ozaki if (rt != NULL && ISSET(rt->rt_flags, RTF_UP)) {
1846 1.183 ozaki ro->_ro_rt = rt;
1847 1.183 ozaki KASSERT(!ISSET(rt->rt_flags, RTF_UPDATING));
1848 1.183 ozaki rtcache_ref(rt, ro);
1849 1.183 ozaki rt_unref(rt);
1850 1.105 dyoung rtcache(ro);
1851 1.183 ozaki } else if (rt != NULL)
1852 1.183 ozaki rt_unref(rt);
1853 1.103 dyoung
1854 1.114 dyoung rtcache_invariants(ro);
1855 1.102 dyoung return ro->_ro_rt;
1856 1.84 joerg }
1857 1.84 joerg
1858 1.102 dyoung struct rtentry *
1859 1.83 joerg rtcache_init(struct route *ro)
1860 1.83 joerg {
1861 1.183 ozaki struct rtentry *rt;
1862 1.183 ozaki RTCACHE_WLOCK();
1863 1.183 ozaki rt = _rtcache_init(ro, 1);
1864 1.183 ozaki RTCACHE_UNLOCK();
1865 1.183 ozaki return rt;
1866 1.83 joerg }
1867 1.83 joerg
1868 1.102 dyoung struct rtentry *
1869 1.83 joerg rtcache_init_noclone(struct route *ro)
1870 1.83 joerg {
1871 1.183 ozaki struct rtentry *rt;
1872 1.183 ozaki RTCACHE_WLOCK();
1873 1.183 ozaki rt = _rtcache_init(ro, 0);
1874 1.183 ozaki RTCACHE_UNLOCK();
1875 1.183 ozaki return rt;
1876 1.83 joerg }
1877 1.90 dyoung
1878 1.102 dyoung struct rtentry *
1879 1.90 dyoung rtcache_update(struct route *ro, int clone)
1880 1.90 dyoung {
1881 1.183 ozaki struct rtentry *rt;
1882 1.183 ozaki RTCACHE_WLOCK();
1883 1.90 dyoung rtcache_clear(ro);
1884 1.183 ozaki rt = _rtcache_init(ro, clone);
1885 1.183 ozaki RTCACHE_UNLOCK();
1886 1.183 ozaki return rt;
1887 1.90 dyoung }
1888 1.83 joerg
1889 1.83 joerg void
1890 1.183 ozaki rtcache_copy(struct route *new_ro, struct route *old_ro)
1891 1.83 joerg {
1892 1.103 dyoung struct rtentry *rt;
1893 1.183 ozaki int ret;
1894 1.103 dyoung
1895 1.103 dyoung KASSERT(new_ro != old_ro);
1896 1.114 dyoung rtcache_invariants(new_ro);
1897 1.114 dyoung rtcache_invariants(old_ro);
1898 1.103 dyoung
1899 1.183 ozaki rt = rtcache_validate(old_ro);
1900 1.103 dyoung
1901 1.183 ozaki if (rtcache_getdst(old_ro) == NULL)
1902 1.183 ozaki goto out;
1903 1.183 ozaki ret = rtcache_setdst(new_ro, rtcache_getdst(old_ro));
1904 1.183 ozaki if (ret != 0)
1905 1.183 ozaki goto out;
1906 1.103 dyoung
1907 1.183 ozaki RTCACHE_WLOCK();
1908 1.105 dyoung new_ro->ro_invalid = false;
1909 1.103 dyoung if ((new_ro->_ro_rt = rt) != NULL)
1910 1.86 dyoung rtcache(new_ro);
1911 1.114 dyoung rtcache_invariants(new_ro);
1912 1.183 ozaki RTCACHE_UNLOCK();
1913 1.183 ozaki out:
1914 1.183 ozaki rtcache_unref(rt, old_ro);
1915 1.183 ozaki return;
1916 1.83 joerg }
1917 1.83 joerg
1918 1.105 dyoung static struct dom_rtlist invalid_routes = LIST_HEAD_INITIALIZER(dom_rtlist);
1919 1.105 dyoung
1920 1.184 ozaki #if defined(RT_DEBUG) && defined(NET_MPSAFE)
1921 1.183 ozaki static void
1922 1.183 ozaki rtcache_trace(const char *func, struct rtentry *rt, struct route *ro)
1923 1.183 ozaki {
1924 1.183 ozaki char dst[64];
1925 1.183 ozaki
1926 1.183 ozaki sockaddr_format(ro->ro_sa, dst, 64);
1927 1.183 ozaki printf("trace: %s:\tdst=%s cpu=%d lwp=%p psref=%p target=%p\n", func, dst,
1928 1.183 ozaki cpu_index(curcpu()), curlwp, &ro->ro_psref, &rt->rt_psref);
1929 1.183 ozaki }
1930 1.183 ozaki #define RTCACHE_PSREF_TRACE(rt, ro) rtcache_trace(__func__, (rt), (ro))
1931 1.183 ozaki #else
1932 1.183 ozaki #define RTCACHE_PSREF_TRACE(rt, ro) do {} while (0)
1933 1.183 ozaki #endif
1934 1.183 ozaki
1935 1.183 ozaki static void
1936 1.183 ozaki rtcache_ref(struct rtentry *rt, struct route *ro)
1937 1.183 ozaki {
1938 1.183 ozaki
1939 1.183 ozaki KASSERT(rt != NULL);
1940 1.183 ozaki
1941 1.183 ozaki #ifdef NET_MPSAFE
1942 1.183 ozaki RTCACHE_PSREF_TRACE(rt, ro);
1943 1.183 ozaki ro->ro_bound = curlwp_bind();
1944 1.183 ozaki psref_acquire(&ro->ro_psref, &rt->rt_psref, rt_psref_class);
1945 1.183 ozaki #endif
1946 1.183 ozaki }
1947 1.183 ozaki
1948 1.183 ozaki void
1949 1.183 ozaki rtcache_unref(struct rtentry *rt, struct route *ro)
1950 1.183 ozaki {
1951 1.183 ozaki
1952 1.183 ozaki if (rt == NULL)
1953 1.183 ozaki return;
1954 1.183 ozaki
1955 1.183 ozaki #ifdef NET_MPSAFE
1956 1.183 ozaki psref_release(&ro->ro_psref, &rt->rt_psref, rt_psref_class);
1957 1.183 ozaki curlwp_bindx(ro->ro_bound);
1958 1.183 ozaki RTCACHE_PSREF_TRACE(rt, ro);
1959 1.183 ozaki #endif
1960 1.183 ozaki }
1961 1.183 ozaki
1962 1.183 ozaki static struct rtentry *
1963 1.183 ozaki rtcache_validate_locked(struct route *ro)
1964 1.183 ozaki {
1965 1.183 ozaki struct rtentry *rt = NULL;
1966 1.183 ozaki
1967 1.183 ozaki retry:
1968 1.183 ozaki rt = ro->_ro_rt;
1969 1.183 ozaki rtcache_invariants(ro);
1970 1.183 ozaki
1971 1.183 ozaki if (ro->ro_invalid) {
1972 1.183 ozaki rt = NULL;
1973 1.183 ozaki goto out;
1974 1.183 ozaki }
1975 1.183 ozaki
1976 1.183 ozaki RT_RLOCK();
1977 1.183 ozaki if (rt != NULL && (rt->rt_flags & RTF_UP) != 0 && rt->rt_ifp != NULL) {
1978 1.183 ozaki if (ISSET(rt->rt_flags, RTF_UPDATING)) {
1979 1.183 ozaki if (rt_wait_ok()) {
1980 1.183 ozaki RT_UNLOCK();
1981 1.183 ozaki RTCACHE_UNLOCK();
1982 1.183 ozaki /* We can wait until the update is complete */
1983 1.183 ozaki rt_update_wait();
1984 1.183 ozaki RTCACHE_RLOCK();
1985 1.183 ozaki goto retry;
1986 1.183 ozaki } else {
1987 1.183 ozaki rt = NULL;
1988 1.183 ozaki }
1989 1.183 ozaki } else
1990 1.183 ozaki rtcache_ref(rt, ro);
1991 1.183 ozaki } else
1992 1.183 ozaki rt = NULL;
1993 1.183 ozaki RT_UNLOCK();
1994 1.183 ozaki out:
1995 1.183 ozaki return rt;
1996 1.183 ozaki }
1997 1.183 ozaki
1998 1.183 ozaki struct rtentry *
1999 1.183 ozaki rtcache_validate(struct route *ro)
2000 1.183 ozaki {
2001 1.183 ozaki struct rtentry *rt;
2002 1.183 ozaki
2003 1.183 ozaki RTCACHE_RLOCK();
2004 1.183 ozaki rt = rtcache_validate_locked(ro);
2005 1.183 ozaki RTCACHE_UNLOCK();
2006 1.183 ozaki return rt;
2007 1.183 ozaki }
2008 1.183 ozaki
2009 1.144 ozaki static void
2010 1.105 dyoung rtcache_invalidate(struct dom_rtlist *rtlist)
2011 1.83 joerg {
2012 1.105 dyoung struct route *ro;
2013 1.99 dyoung
2014 1.183 ozaki RTCACHE_ASSERT_WLOCK();
2015 1.183 ozaki
2016 1.105 dyoung while ((ro = LIST_FIRST(rtlist)) != NULL) {
2017 1.114 dyoung rtcache_invariants(ro);
2018 1.105 dyoung KASSERT(ro->_ro_rt != NULL);
2019 1.105 dyoung ro->ro_invalid = true;
2020 1.99 dyoung LIST_REMOVE(ro, ro_rtcache_next);
2021 1.105 dyoung LIST_INSERT_HEAD(&invalid_routes, ro, ro_rtcache_next);
2022 1.114 dyoung rtcache_invariants(ro);
2023 1.84 joerg }
2024 1.105 dyoung }
2025 1.105 dyoung
2026 1.144 ozaki static void
2027 1.168 ozaki rtcache_clear_rtentry(int family, struct rtentry *rt)
2028 1.168 ozaki {
2029 1.168 ozaki struct domain *dom;
2030 1.171 hannken struct route *ro, *nro;
2031 1.168 ozaki
2032 1.168 ozaki if ((dom = pffinddomain(family)) == NULL)
2033 1.168 ozaki return;
2034 1.168 ozaki
2035 1.183 ozaki RTCACHE_WLOCK();
2036 1.171 hannken LIST_FOREACH_SAFE(ro, &dom->dom_rtcache, ro_rtcache_next, nro) {
2037 1.168 ozaki if (ro->_ro_rt == rt)
2038 1.168 ozaki rtcache_clear(ro);
2039 1.168 ozaki }
2040 1.183 ozaki RTCACHE_UNLOCK();
2041 1.168 ozaki }
2042 1.168 ozaki
2043 1.168 ozaki static void
2044 1.105 dyoung rtcache_clear(struct route *ro)
2045 1.105 dyoung {
2046 1.183 ozaki
2047 1.183 ozaki RTCACHE_ASSERT_WLOCK();
2048 1.183 ozaki
2049 1.114 dyoung rtcache_invariants(ro);
2050 1.105 dyoung if (ro->_ro_rt == NULL)
2051 1.105 dyoung return;
2052 1.105 dyoung
2053 1.105 dyoung LIST_REMOVE(ro, ro_rtcache_next);
2054 1.105 dyoung
2055 1.105 dyoung ro->_ro_rt = NULL;
2056 1.114 dyoung ro->ro_invalid = false;
2057 1.114 dyoung rtcache_invariants(ro);
2058 1.83 joerg }
2059 1.83 joerg
2060 1.90 dyoung struct rtentry *
2061 1.183 ozaki rtcache_lookup2(struct route *ro, const struct sockaddr *dst,
2062 1.183 ozaki int clone, int *hitp)
2063 1.90 dyoung {
2064 1.90 dyoung const struct sockaddr *odst;
2065 1.104 dyoung struct rtentry *rt = NULL;
2066 1.90 dyoung
2067 1.183 ozaki RTCACHE_RLOCK();
2068 1.90 dyoung odst = rtcache_getdst(ro);
2069 1.183 ozaki if (odst == NULL) {
2070 1.183 ozaki RTCACHE_UNLOCK();
2071 1.183 ozaki RTCACHE_WLOCK();
2072 1.138 ozaki goto miss;
2073 1.183 ozaki }
2074 1.90 dyoung
2075 1.138 ozaki if (sockaddr_cmp(odst, dst) != 0) {
2076 1.183 ozaki RTCACHE_UNLOCK();
2077 1.183 ozaki RTCACHE_WLOCK();
2078 1.183 ozaki rtcache_free_locked(ro);
2079 1.138 ozaki goto miss;
2080 1.138 ozaki }
2081 1.138 ozaki
2082 1.183 ozaki rt = rtcache_validate_locked(ro);
2083 1.138 ozaki if (rt == NULL) {
2084 1.183 ozaki RTCACHE_UNLOCK();
2085 1.183 ozaki RTCACHE_WLOCK();
2086 1.91 dyoung rtcache_clear(ro);
2087 1.138 ozaki goto miss;
2088 1.138 ozaki }
2089 1.138 ozaki
2090 1.138 ozaki rtcache_invariants(ro);
2091 1.90 dyoung
2092 1.183 ozaki RTCACHE_UNLOCK();
2093 1.183 ozaki if (hitp != NULL)
2094 1.183 ozaki *hitp = 1;
2095 1.138 ozaki return rt;
2096 1.138 ozaki miss:
2097 1.183 ozaki if (hitp != NULL)
2098 1.183 ozaki *hitp = 0;
2099 1.183 ozaki if (rtcache_setdst_locked(ro, dst) == 0)
2100 1.138 ozaki rt = _rtcache_init(ro, clone);
2101 1.90 dyoung
2102 1.114 dyoung rtcache_invariants(ro);
2103 1.114 dyoung
2104 1.183 ozaki RTCACHE_UNLOCK();
2105 1.104 dyoung return rt;
2106 1.90 dyoung }
2107 1.90 dyoung
2108 1.183 ozaki static void
2109 1.183 ozaki rtcache_free_locked(struct route *ro)
2110 1.86 dyoung {
2111 1.183 ozaki
2112 1.183 ozaki RTCACHE_ASSERT_WLOCK();
2113 1.86 dyoung rtcache_clear(ro);
2114 1.86 dyoung if (ro->ro_sa != NULL) {
2115 1.86 dyoung sockaddr_free(ro->ro_sa);
2116 1.86 dyoung ro->ro_sa = NULL;
2117 1.86 dyoung }
2118 1.114 dyoung rtcache_invariants(ro);
2119 1.86 dyoung }
2120 1.86 dyoung
2121 1.183 ozaki void
2122 1.183 ozaki rtcache_free(struct route *ro)
2123 1.183 ozaki {
2124 1.183 ozaki
2125 1.183 ozaki RTCACHE_WLOCK();
2126 1.183 ozaki rtcache_free_locked(ro);
2127 1.183 ozaki RTCACHE_UNLOCK();
2128 1.183 ozaki }
2129 1.183 ozaki
2130 1.183 ozaki static int
2131 1.183 ozaki rtcache_setdst_locked(struct route *ro, const struct sockaddr *sa)
2132 1.83 joerg {
2133 1.90 dyoung KASSERT(sa != NULL);
2134 1.90 dyoung
2135 1.183 ozaki RTCACHE_ASSERT_WLOCK();
2136 1.183 ozaki
2137 1.114 dyoung rtcache_invariants(ro);
2138 1.142 ozaki if (ro->ro_sa != NULL) {
2139 1.142 ozaki if (ro->ro_sa->sa_family == sa->sa_family) {
2140 1.142 ozaki rtcache_clear(ro);
2141 1.142 ozaki sockaddr_copy(ro->ro_sa, ro->ro_sa->sa_len, sa);
2142 1.143 ozaki rtcache_invariants(ro);
2143 1.143 ozaki return 0;
2144 1.114 dyoung }
2145 1.143 ozaki /* free ro_sa, wrong family */
2146 1.183 ozaki rtcache_free_locked(ro);
2147 1.142 ozaki }
2148 1.90 dyoung
2149 1.107 dyoung KASSERT(ro->_ro_rt == NULL);
2150 1.107 dyoung
2151 1.134 christos if ((ro->ro_sa = sockaddr_dup(sa, M_ZERO | M_NOWAIT)) == NULL) {
2152 1.114 dyoung rtcache_invariants(ro);
2153 1.90 dyoung return ENOMEM;
2154 1.107 dyoung }
2155 1.114 dyoung rtcache_invariants(ro);
2156 1.90 dyoung return 0;
2157 1.83 joerg }
2158 1.92 dyoung
2159 1.183 ozaki int
2160 1.183 ozaki rtcache_setdst(struct route *ro, const struct sockaddr *sa)
2161 1.183 ozaki {
2162 1.183 ozaki int error;
2163 1.183 ozaki
2164 1.183 ozaki RTCACHE_WLOCK();
2165 1.183 ozaki error = rtcache_setdst_locked(ro, sa);
2166 1.183 ozaki RTCACHE_UNLOCK();
2167 1.183 ozaki
2168 1.183 ozaki return error;
2169 1.183 ozaki }
2170 1.183 ozaki
2171 1.123 kefren const struct sockaddr *
2172 1.123 kefren rt_settag(struct rtentry *rt, const struct sockaddr *tag)
2173 1.123 kefren {
2174 1.123 kefren if (rt->rt_tag != tag) {
2175 1.123 kefren if (rt->rt_tag != NULL)
2176 1.123 kefren sockaddr_free(rt->rt_tag);
2177 1.134 christos rt->rt_tag = sockaddr_dup(tag, M_ZERO | M_NOWAIT);
2178 1.123 kefren }
2179 1.169 msaitoh return rt->rt_tag;
2180 1.123 kefren }
2181 1.123 kefren
2182 1.123 kefren struct sockaddr *
2183 1.167 ozaki rt_gettag(const struct rtentry *rt)
2184 1.123 kefren {
2185 1.123 kefren return rt->rt_tag;
2186 1.123 kefren }
2187 1.162 ozaki
2188 1.165 ozaki int
2189 1.167 ozaki rt_check_reject_route(const struct rtentry *rt, const struct ifnet *ifp)
2190 1.165 ozaki {
2191 1.165 ozaki
2192 1.165 ozaki if ((rt->rt_flags & RTF_REJECT) != 0) {
2193 1.165 ozaki /* Mimic looutput */
2194 1.165 ozaki if (ifp->if_flags & IFF_LOOPBACK)
2195 1.165 ozaki return (rt->rt_flags & RTF_HOST) ?
2196 1.165 ozaki EHOSTUNREACH : ENETUNREACH;
2197 1.165 ozaki else if (rt->rt_rmx.rmx_expire == 0 ||
2198 1.165 ozaki time_uptime < rt->rt_rmx.rmx_expire)
2199 1.165 ozaki return (rt->rt_flags & RTF_GATEWAY) ?
2200 1.165 ozaki EHOSTUNREACH : EHOSTDOWN;
2201 1.165 ozaki }
2202 1.165 ozaki
2203 1.165 ozaki return 0;
2204 1.165 ozaki }
2205 1.165 ozaki
2206 1.182 ozaki void
2207 1.182 ozaki rt_delete_matched_entries(sa_family_t family, int (*f)(struct rtentry *, void *),
2208 1.182 ozaki void *v)
2209 1.182 ozaki {
2210 1.182 ozaki
2211 1.182 ozaki for (;;) {
2212 1.182 ozaki int s;
2213 1.182 ozaki int error;
2214 1.182 ozaki struct rtentry *rt, *retrt = NULL;
2215 1.182 ozaki
2216 1.183 ozaki RT_RLOCK();
2217 1.182 ozaki s = splsoftnet();
2218 1.182 ozaki rt = rtbl_search_matched_entry(family, f, v);
2219 1.182 ozaki if (rt == NULL) {
2220 1.182 ozaki splx(s);
2221 1.183 ozaki RT_UNLOCK();
2222 1.182 ozaki return;
2223 1.182 ozaki }
2224 1.182 ozaki rt->rt_refcnt++;
2225 1.182 ozaki splx(s);
2226 1.183 ozaki RT_UNLOCK();
2227 1.182 ozaki
2228 1.182 ozaki error = rtrequest(RTM_DELETE, rt_getkey(rt), rt->rt_gateway,
2229 1.182 ozaki rt_mask(rt), rt->rt_flags, &retrt);
2230 1.182 ozaki if (error == 0) {
2231 1.182 ozaki KASSERT(retrt == rt);
2232 1.182 ozaki KASSERT((retrt->rt_flags & RTF_UP) == 0);
2233 1.182 ozaki retrt->rt_ifp = NULL;
2234 1.183 ozaki rt_unref(rt);
2235 1.183 ozaki rt_free(retrt);
2236 1.182 ozaki } else if (error == ESRCH) {
2237 1.182 ozaki /* Someone deleted the entry already. */
2238 1.183 ozaki rt_unref(rt);
2239 1.182 ozaki } else {
2240 1.182 ozaki log(LOG_ERR, "%s: unable to delete rtentry @ %p, "
2241 1.182 ozaki "error = %d\n", rt->rt_ifp->if_xname, rt, error);
2242 1.182 ozaki /* XXX how to treat this case? */
2243 1.182 ozaki }
2244 1.182 ozaki }
2245 1.182 ozaki }
2246 1.182 ozaki
2247 1.183 ozaki int
2248 1.183 ozaki rt_walktree(sa_family_t family, int (*f)(struct rtentry *, void *), void *v)
2249 1.183 ozaki {
2250 1.183 ozaki int error;
2251 1.183 ozaki
2252 1.183 ozaki RT_RLOCK();
2253 1.183 ozaki error = rtbl_walktree(family, f, v);
2254 1.183 ozaki RT_UNLOCK();
2255 1.183 ozaki
2256 1.183 ozaki return error;
2257 1.183 ozaki }
2258 1.183 ozaki
2259 1.162 ozaki #ifdef DDB
2260 1.162 ozaki
2261 1.162 ozaki #include <machine/db_machdep.h>
2262 1.162 ozaki #include <ddb/db_interface.h>
2263 1.162 ozaki #include <ddb/db_output.h>
2264 1.162 ozaki
2265 1.162 ozaki #define rt_expire rt_rmx.rmx_expire
2266 1.162 ozaki
2267 1.162 ozaki static void
2268 1.162 ozaki db_print_sa(const struct sockaddr *sa)
2269 1.162 ozaki {
2270 1.162 ozaki int len;
2271 1.162 ozaki const u_char *p;
2272 1.162 ozaki
2273 1.162 ozaki if (sa == NULL) {
2274 1.162 ozaki db_printf("[NULL]");
2275 1.162 ozaki return;
2276 1.162 ozaki }
2277 1.162 ozaki
2278 1.162 ozaki p = (const u_char *)sa;
2279 1.162 ozaki len = sa->sa_len;
2280 1.162 ozaki db_printf("[");
2281 1.162 ozaki while (len > 0) {
2282 1.162 ozaki db_printf("%d", *p);
2283 1.162 ozaki p++; len--;
2284 1.162 ozaki if (len) db_printf(",");
2285 1.162 ozaki }
2286 1.162 ozaki db_printf("]\n");
2287 1.162 ozaki }
2288 1.162 ozaki
2289 1.162 ozaki static void
2290 1.162 ozaki db_print_ifa(struct ifaddr *ifa)
2291 1.162 ozaki {
2292 1.162 ozaki if (ifa == NULL)
2293 1.162 ozaki return;
2294 1.162 ozaki db_printf(" ifa_addr=");
2295 1.162 ozaki db_print_sa(ifa->ifa_addr);
2296 1.162 ozaki db_printf(" ifa_dsta=");
2297 1.162 ozaki db_print_sa(ifa->ifa_dstaddr);
2298 1.162 ozaki db_printf(" ifa_mask=");
2299 1.162 ozaki db_print_sa(ifa->ifa_netmask);
2300 1.162 ozaki db_printf(" flags=0x%x,refcnt=%d,metric=%d\n",
2301 1.162 ozaki ifa->ifa_flags,
2302 1.162 ozaki ifa->ifa_refcnt,
2303 1.162 ozaki ifa->ifa_metric);
2304 1.162 ozaki }
2305 1.162 ozaki
2306 1.162 ozaki /*
2307 1.162 ozaki * Function to pass to rt_walktree().
2308 1.162 ozaki * Return non-zero error to abort walk.
2309 1.162 ozaki */
2310 1.162 ozaki static int
2311 1.162 ozaki db_show_rtentry(struct rtentry *rt, void *w)
2312 1.162 ozaki {
2313 1.162 ozaki db_printf("rtentry=%p", rt);
2314 1.162 ozaki
2315 1.162 ozaki db_printf(" flags=0x%x refcnt=%d use=%"PRId64" expire=%"PRId64"\n",
2316 1.162 ozaki rt->rt_flags, rt->rt_refcnt,
2317 1.162 ozaki rt->rt_use, (uint64_t)rt->rt_expire);
2318 1.162 ozaki
2319 1.162 ozaki db_printf(" key="); db_print_sa(rt_getkey(rt));
2320 1.162 ozaki db_printf(" mask="); db_print_sa(rt_mask(rt));
2321 1.162 ozaki db_printf(" gw="); db_print_sa(rt->rt_gateway);
2322 1.162 ozaki
2323 1.162 ozaki db_printf(" ifp=%p ", rt->rt_ifp);
2324 1.162 ozaki if (rt->rt_ifp)
2325 1.162 ozaki db_printf("(%s)", rt->rt_ifp->if_xname);
2326 1.162 ozaki else
2327 1.162 ozaki db_printf("(NULL)");
2328 1.162 ozaki
2329 1.162 ozaki db_printf(" ifa=%p\n", rt->rt_ifa);
2330 1.162 ozaki db_print_ifa(rt->rt_ifa);
2331 1.162 ozaki
2332 1.162 ozaki db_printf(" gwroute=%p llinfo=%p\n",
2333 1.162 ozaki rt->rt_gwroute, rt->rt_llinfo);
2334 1.162 ozaki
2335 1.162 ozaki return 0;
2336 1.162 ozaki }
2337 1.162 ozaki
2338 1.162 ozaki /*
2339 1.162 ozaki * Function to print all the route trees.
2340 1.162 ozaki * Use this from ddb: "show routes"
2341 1.162 ozaki */
2342 1.162 ozaki void
2343 1.162 ozaki db_show_routes(db_expr_t addr, bool have_addr,
2344 1.162 ozaki db_expr_t count, const char *modif)
2345 1.162 ozaki {
2346 1.162 ozaki rt_walktree(AF_INET, db_show_rtentry, NULL);
2347 1.162 ozaki }
2348 1.162 ozaki #endif
2349