1 | /* |
2 | * Copyright (c) 2016 Apple Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | /* |
29 | * Copyright (c) 2004 Luigi Rizzo, Alessandro Cerri. All rights reserved. |
30 | * Copyright (c) 2004-2008 Qing Li. All rights reserved. |
31 | * Copyright (c) 2008 Kip Macy. All rights reserved. |
32 | * |
33 | * Redistribution and use in source and binary forms, with or without |
34 | * modification, are permitted provided that the following conditions |
35 | * are met: |
36 | * 1. Redistributions of source code must retain the above copyright |
37 | * notice, this list of conditions and the following disclaimer. |
38 | * 2. Redistributions in binary form must reproduce the above copyright |
39 | * notice, this list of conditions and the following disclaimer in the |
40 | * documentation and/or other materials provided with the distribution. |
41 | * |
42 | * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
43 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
44 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
45 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE |
46 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
47 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
48 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
49 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
50 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
51 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
52 | * SUCH DAMAGE. |
53 | */ |
54 | #include <sys/cdefs.h> |
55 | #include <sys/param.h> |
56 | #include <sys/systm.h> |
57 | #include <sys/malloc.h> |
58 | #include <sys/mbuf.h> |
59 | #include <sys/syslog.h> |
60 | #include <sys/sysctl.h> |
61 | #include <sys/socket.h> |
62 | #include <sys/kernel.h> |
63 | #include <kern/queue.h> |
64 | #include <kern/locks.h> |
65 | |
66 | #include <netinet/in.h> |
67 | #include <net/if_llatbl.h> |
68 | #include <net/if.h> |
69 | #include <net/if_dl.h> |
70 | #include <net/if_var.h> |
71 | #include <net/dlil.h> |
72 | #include <net/route.h> |
73 | #include <netinet/if_ether.h> |
74 | #include <netinet6/in6_var.h> |
75 | #include <netinet6/nd6.h> |
76 | |
77 | MALLOC_DEFINE(M_LLTABLE, "lltable" , "link level address tables" ); |
78 | |
79 | static SLIST_HEAD(, lltable) lltables = SLIST_HEAD_INITIALIZER(lltables); |
80 | |
81 | static lck_grp_attr_t *lltable_rwlock_grp_attr; |
82 | static lck_grp_t *lltable_rwlock_grp; |
83 | static lck_attr_t *lltable_rwlock_attr; |
84 | |
85 | static lck_grp_attr_t *lle_lock_grp_attr = NULL; |
86 | lck_grp_t *lle_lock_grp = NULL; |
87 | lck_attr_t *lle_lock_attr = NULL; |
88 | |
89 | decl_lck_rw_data(, lltable_rwlock_data); |
90 | lck_rw_t *lltable_rwlock = &lltable_rwlock_data; |
91 | |
92 | #if 0 |
93 | static void lltable_unlink(struct lltable *llt); |
94 | #endif |
95 | static void llentries_unlink(struct lltable *llt, struct llentries *head); |
96 | |
97 | static void htable_unlink_entry(struct llentry *lle); |
98 | static void htable_link_entry(struct lltable *llt, struct llentry *lle); |
99 | static int htable_foreach_lle(struct lltable *llt, llt_foreach_cb_t *f, |
100 | void *farg); |
101 | |
102 | void |
103 | lltable_glbl_init() |
104 | { |
105 | lltable_rwlock_grp_attr = lck_grp_attr_alloc_init(); |
106 | lltable_rwlock_grp = lck_grp_alloc_init("lltable_rwlock" , |
107 | lltable_rwlock_grp_attr); |
108 | lltable_rwlock_attr = lck_attr_alloc_init(); |
109 | lck_rw_init(lltable_rwlock, lltable_rwlock_grp, |
110 | lltable_rwlock_attr); |
111 | |
112 | lle_lock_grp_attr = lck_grp_attr_alloc_init(); |
113 | lle_lock_grp = lck_grp_alloc_init("lle locks" , lle_lock_grp_attr); |
114 | lle_lock_attr = lck_attr_alloc_init(); |
115 | } |
116 | |
117 | /* |
118 | * Dump lle state for a specific address family. |
119 | */ |
120 | static int |
121 | lltable_dump_af(struct lltable *llt, struct sysctl_req *wr) |
122 | { |
123 | int error; |
124 | |
125 | LLTABLE_LOCK_ASSERT(); |
126 | |
127 | if (llt->llt_ifp->if_flags & IFF_LOOPBACK) |
128 | return (0); |
129 | error = 0; |
130 | |
131 | IF_AFDATA_RLOCK(llt->llt_ifp, llt->llt_af); |
132 | error = lltable_foreach_lle(llt, |
133 | (llt_foreach_cb_t *)llt->llt_dump_entry, wr); |
134 | IF_AFDATA_RUNLOCK(llt->llt_ifp, llt->llt_af); |
135 | |
136 | return (error); |
137 | } |
138 | |
139 | /* |
140 | * Dump arp state for a specific address family. |
141 | */ |
142 | int |
143 | lltable_sysctl_dumparp(int af, struct sysctl_req *wr) |
144 | { |
145 | struct lltable *llt = NULL; |
146 | int error = 0; |
147 | |
148 | LLTABLE_RLOCK(); |
149 | SLIST_FOREACH(llt, &lltables, llt_link) { |
150 | if (llt->llt_af == af) { |
151 | error = lltable_dump_af(llt, wr); |
152 | if (error != 0) |
153 | goto done; |
154 | } |
155 | } |
156 | done: |
157 | LLTABLE_RUNLOCK(); |
158 | return (error); |
159 | } |
160 | |
161 | /* |
162 | * Common function helpers for chained hash table. |
163 | */ |
164 | |
165 | /* |
166 | * Runs specified callback for each entry in @llt. |
167 | * Caller does the locking. |
168 | * |
169 | */ |
170 | static int |
171 | htable_foreach_lle(struct lltable *llt, llt_foreach_cb_t *f, void *farg) |
172 | { |
173 | struct llentry *lle, *next; |
174 | int i, error; |
175 | |
176 | error = 0; |
177 | |
178 | for (i = 0; i < llt->llt_hsize; i++) { |
179 | LIST_FOREACH_SAFE(lle, &llt->lle_head[i], lle_next, next) { |
180 | error = f(llt, lle, farg); |
181 | if (error != 0) |
182 | break; |
183 | } |
184 | } |
185 | |
186 | return (error); |
187 | } |
188 | |
189 | static void |
190 | htable_link_entry(struct lltable *llt, struct llentry *lle) |
191 | { |
192 | struct llentries *lleh; |
193 | uint32_t hashidx; |
194 | |
195 | if ((lle->la_flags & LLE_LINKED) != 0) |
196 | return; |
197 | |
198 | IF_AFDATA_WLOCK_ASSERT(llt->llt_ifp, llt->llt_af); |
199 | |
200 | hashidx = llt->llt_hash(lle, llt->llt_hsize); |
201 | lleh = &llt->lle_head[hashidx]; |
202 | |
203 | lle->lle_tbl = llt; |
204 | lle->lle_head = lleh; |
205 | lle->la_flags |= LLE_LINKED; |
206 | LIST_INSERT_HEAD(lleh, lle, lle_next); |
207 | } |
208 | |
209 | static void |
210 | htable_unlink_entry(struct llentry *lle) |
211 | { |
212 | if ((lle->la_flags & LLE_LINKED) != 0) { |
213 | IF_AFDATA_WLOCK_ASSERT(lle->lle_tbl->llt_ifp, lle->lle_tbl->llt_af); |
214 | LIST_REMOVE(lle, lle_next); |
215 | lle->la_flags &= ~(LLE_VALID | LLE_LINKED); |
216 | #if 0 |
217 | lle->lle_tbl = NULL; |
218 | lle->lle_head = NULL; |
219 | #endif |
220 | } |
221 | } |
222 | |
223 | struct prefix_match_data { |
224 | const struct sockaddr *addr; |
225 | const struct sockaddr *mask; |
226 | struct llentries dchain; |
227 | u_int flags; |
228 | }; |
229 | |
230 | static int |
231 | htable_prefix_free_cb(struct lltable *llt, struct llentry *lle, void *farg) |
232 | { |
233 | struct prefix_match_data *pmd; |
234 | |
235 | pmd = (struct prefix_match_data *)farg; |
236 | |
237 | if (llt->llt_match_prefix(pmd->addr, pmd->mask, pmd->flags, lle)) { |
238 | LLE_WLOCK(lle); |
239 | LIST_INSERT_HEAD(&pmd->dchain, lle, lle_chain); |
240 | } |
241 | |
242 | return (0); |
243 | } |
244 | |
245 | static void |
246 | htable_prefix_free(struct lltable *llt, const struct sockaddr *addr, |
247 | const struct sockaddr *mask, u_int flags) |
248 | { |
249 | struct llentry *lle, *next; |
250 | struct prefix_match_data pmd; |
251 | |
252 | bzero(&pmd, sizeof(pmd)); |
253 | pmd.addr = addr; |
254 | pmd.mask = mask; |
255 | pmd.flags = flags; |
256 | LIST_INIT(&pmd.dchain); |
257 | |
258 | IF_AFDATA_WLOCK(llt->llt_ifp, llt->llt_af); |
259 | /* Push matching lles to chain */ |
260 | lltable_foreach_lle(llt, htable_prefix_free_cb, &pmd); |
261 | |
262 | llentries_unlink(llt, &pmd.dchain); |
263 | IF_AFDATA_WUNLOCK(llt->llt_ifp, llt->llt_af); |
264 | |
265 | LIST_FOREACH_SAFE(lle, &pmd.dchain, lle_chain, next) |
266 | lltable_free_entry(llt, lle); |
267 | } |
268 | |
269 | static void |
270 | htable_free_tbl(struct lltable *llt) |
271 | { |
272 | |
273 | FREE(llt->lle_head, M_LLTABLE); |
274 | FREE(llt, M_LLTABLE); |
275 | } |
276 | |
277 | static void |
278 | llentries_unlink(struct lltable *llt, struct llentries *head) |
279 | { |
280 | struct llentry *lle, *next; |
281 | |
282 | LIST_FOREACH_SAFE(lle, head, lle_chain, next) |
283 | llt->llt_unlink_entry(lle); |
284 | } |
285 | |
286 | /* |
287 | * Helper function used to drop all mbufs in hold queue. |
288 | * |
289 | * Returns the number of held packets, if any, that were dropped. |
290 | */ |
291 | size_t |
292 | lltable_drop_entry_queue(struct llentry *lle) |
293 | { |
294 | size_t pkts_dropped; |
295 | struct mbuf *next; |
296 | |
297 | LLE_WLOCK_ASSERT(lle); |
298 | |
299 | pkts_dropped = 0; |
300 | while ((lle->la_numheld > 0) && (lle->la_hold != NULL)) { |
301 | next = lle->la_hold->m_nextpkt; |
302 | m_freem(lle->la_hold); |
303 | lle->la_hold = next; |
304 | lle->la_numheld--; |
305 | pkts_dropped++; |
306 | } |
307 | |
308 | KASSERT(lle->la_numheld == 0, |
309 | ("%s: la_numheld %d > 0, pkts_droped %zd" , __func__, |
310 | lle->la_numheld, pkts_dropped)); |
311 | |
312 | return (pkts_dropped); |
313 | } |
314 | |
315 | void |
316 | lltable_set_entry_addr(struct ifnet *ifp, struct llentry *lle, |
317 | const char *ll_addr) |
318 | { |
319 | bcopy(ll_addr, &lle->ll_addr, ifp->if_addrlen); |
320 | lle->la_flags |= LLE_VALID; |
321 | lle->r_flags |= RLLE_VALID; |
322 | } |
323 | |
324 | #if 0 |
325 | /* |
326 | * XXX The following is related to a change to cache destination layer 2 |
327 | * header cached in the entry instead of just the destination mac address |
328 | * Right now leaving this code out and just storing the destination's mac |
329 | * information. |
330 | */ |
331 | /* |
332 | * Tries to update @lle link-level address. |
333 | * Since update requires AFDATA WLOCK, function |
334 | * drops @lle lock, acquires AFDATA lock and then acquires |
335 | * @lle lock to maintain lock order. |
336 | * |
337 | * Returns 1 on success. |
338 | */ |
339 | int |
340 | lltable_try_set_entry_addr(struct ifnet *ifp, struct llentry *lle, |
341 | const char *linkhdr, size_t linkhdrsize, int lladdr_off) |
342 | { |
343 | /* Perform real LLE update */ |
344 | /* use afdata WLOCK to update fields */ |
345 | LLE_WLOCK_ASSERT(lle); |
346 | LLE_ADDREF(lle); |
347 | LLE_WUNLOCK(lle); |
348 | IF_AFDATA_WLOCK(ifp, lle->lle_tbl->llt_af); |
349 | LLE_WLOCK(lle); |
350 | |
351 | /* |
352 | * Since we droppped LLE lock, other thread might have deleted |
353 | * this lle. Check and return |
354 | */ |
355 | if ((lle->la_flags & LLE_DELETED) != 0) { |
356 | IF_AFDATA_WUNLOCK(ifp, lle->lle_tbl->llt_af); |
357 | LLE_FREE_LOCKED(lle); |
358 | return (0); |
359 | } |
360 | |
361 | /* Update data */ |
362 | lltable_set_entry_addr(ifp, lle, linkhdr, linkhdrsize, lladdr_off); |
363 | |
364 | IF_AFDATA_WUNLOCK(ifp, lle->lle_tbl->llt_af); |
365 | |
366 | LLE_REMREF(lle); |
367 | |
368 | return (1); |
369 | } |
370 | |
371 | /* |
372 | * Helper function used to pre-compute full/partial link-layer |
373 | * header data suitable for feeding into if_output(). |
374 | */ |
375 | int |
376 | lltable_calc_llheader(struct ifnet *ifp, int family, char *lladdr, |
377 | char *buf, size_t *bufsize, int *lladdr_off) |
378 | { |
379 | struct if_encap_req ereq; |
380 | int error; |
381 | |
382 | bzero(buf, *bufsize); |
383 | bzero(&ereq, sizeof(ereq)); |
384 | ereq.buf = buf; |
385 | ereq.bufsize = *bufsize; |
386 | ereq.rtype = IFENCAP_LL; |
387 | ereq.family = family; |
388 | ereq.lladdr = lladdr; |
389 | ereq.lladdr_len = ifp->if_addrlen; |
390 | error = ifp->if_requestencap(ifp, &ereq); |
391 | if (error == 0) { |
392 | *bufsize = ereq.bufsize; |
393 | *lladdr_off = ereq.lladdr_off; |
394 | } |
395 | |
396 | return (error); |
397 | } |
398 | |
399 | /* |
400 | * Update link-layer header for given @lle after |
401 | * interface lladdr was changed. |
402 | */ |
403 | static int |
404 | llentry_update_ifaddr(struct lltable *llt, struct llentry *lle, void *farg) |
405 | { |
406 | struct ifnet *ifp; |
407 | u_char linkhdr[LLE_MAX_LINKHDR]; |
408 | size_t linkhdrsize; |
409 | u_char *lladdr; |
410 | int lladdr_off; |
411 | |
412 | ifp = (struct ifnet *)farg; |
413 | |
414 | lladdr = (void *)lle->ll_addr; |
415 | |
416 | LLE_WLOCK(lle); |
417 | if ((lle->la_flags & LLE_VALID) == 0) { |
418 | LLE_WUNLOCK(lle); |
419 | return (0); |
420 | } |
421 | |
422 | if ((lle->la_flags & LLE_IFADDR) != 0) |
423 | lladdr = (void *)IF_LLADDR(ifp); |
424 | |
425 | linkhdrsize = sizeof(linkhdr); |
426 | lltable_calc_llheader(ifp, llt->llt_af, (void *)lladdr, (void *)linkhdr, &linkhdrsize, |
427 | &lladdr_off); |
428 | memcpy(lle->r_linkdata, linkhdr, linkhdrsize); |
429 | LLE_WUNLOCK(lle); |
430 | |
431 | return (0); |
432 | } |
433 | |
434 | /* |
435 | * Update all calculated headers for given @llt |
436 | */ |
437 | void |
438 | lltable_update_ifaddr(struct lltable *llt) |
439 | { |
440 | |
441 | if (llt->llt_ifp->if_flags & IFF_LOOPBACK) |
442 | return; |
443 | |
444 | IF_AFDATA_WLOCK(llt->llt_ifp, llt->llt_af); |
445 | lltable_foreach_lle(llt, llentry_update_ifaddr, llt->llt_ifp); |
446 | IF_AFDATA_WUNLOCK(llt->llt_ifp, llt->llt_af); |
447 | } |
448 | #endif |
449 | |
450 | /* |
451 | * |
452 | * Performs generic cleanup routines and frees lle. |
453 | * |
454 | * Called for non-linked entries, with callouts and |
455 | * other AF-specific cleanups performed. |
456 | * |
457 | * @lle must be passed WLOCK'ed |
458 | * |
459 | * Returns the number of held packets, if any, that were dropped. |
460 | */ |
461 | size_t |
462 | llentry_free(struct llentry *lle) |
463 | { |
464 | size_t pkts_dropped; |
465 | |
466 | LLE_WLOCK_ASSERT(lle); |
467 | |
468 | KASSERT((lle->la_flags & LLE_LINKED) == 0, ("freeing linked lle" )); |
469 | |
470 | pkts_dropped = lltable_drop_entry_queue(lle); |
471 | |
472 | LLE_FREE_LOCKED(lle); |
473 | |
474 | return (pkts_dropped); |
475 | } |
476 | |
477 | /* |
478 | * (al)locate an llentry for address dst (equivalent to rtalloc for new-arp). |
479 | * |
480 | * If found the llentry * is returned referenced and unlocked. |
481 | */ |
482 | struct llentry * |
483 | llentry_alloc(struct ifnet *ifp, struct lltable *lt, |
484 | struct sockaddr_storage *dst) |
485 | { |
486 | struct llentry *la, *la_tmp; |
487 | |
488 | IF_AFDATA_RLOCK(ifp, lt->llt_af); |
489 | la = lla_lookup(lt, LLE_EXCLUSIVE, (struct sockaddr *)dst); |
490 | IF_AFDATA_RUNLOCK(ifp, lt->llt_af); |
491 | |
492 | if (la != NULL) { |
493 | LLE_ADDREF(la); |
494 | LLE_WUNLOCK(la); |
495 | return (la); |
496 | } |
497 | |
498 | if ((ifp->if_flags & IFF_NOARP) == 0) { |
499 | la = lltable_alloc_entry(lt, 0, (struct sockaddr *)dst); |
500 | if (la == NULL) |
501 | return (NULL); |
502 | IF_AFDATA_WLOCK(ifp, lt->llt_af); |
503 | LLE_WLOCK(la); |
504 | /* Prefer any existing LLE over newly-created one */ |
505 | la_tmp = lla_lookup(lt, LLE_EXCLUSIVE, (struct sockaddr *)dst); |
506 | if (la_tmp == NULL) |
507 | lltable_link_entry(lt, la); |
508 | IF_AFDATA_WUNLOCK(ifp, lt->llt_af); |
509 | if (la_tmp != NULL) { |
510 | lltable_free_entry(lt, la); |
511 | la = la_tmp; |
512 | } |
513 | LLE_ADDREF(la); |
514 | LLE_WUNLOCK(la); |
515 | } |
516 | |
517 | return (la); |
518 | } |
519 | |
520 | /* |
521 | * Free all entries from given table and free itself. |
522 | */ |
523 | |
524 | static int |
525 | lltable_free_cb(struct lltable *llt, struct llentry *lle, void *farg) |
526 | { |
527 | #pragma unused(llt) |
528 | struct llentries *dchain; |
529 | |
530 | dchain = (struct llentries *)farg; |
531 | |
532 | LLE_WLOCK(lle); |
533 | LIST_INSERT_HEAD(dchain, lle, lle_chain); |
534 | |
535 | return (0); |
536 | } |
537 | |
538 | /* |
539 | * Free all entries from given table and free itself. |
540 | */ |
541 | void |
542 | lltable_free(struct lltable *llt) |
543 | { |
544 | struct llentry *lle, *next; |
545 | struct llentries dchain; |
546 | |
547 | KASSERT(llt != NULL, ("%s: llt is NULL" , __func__)); |
548 | |
549 | //lltable_unlink(llt); |
550 | |
551 | LIST_INIT(&dchain); |
552 | IF_AFDATA_WLOCK(llt->llt_ifp, llt->llt_af); |
553 | /* Push all lles to @dchain */ |
554 | lltable_foreach_lle(llt, lltable_free_cb, &dchain); |
555 | llentries_unlink(llt, &dchain); |
556 | IF_AFDATA_WUNLOCK(llt->llt_ifp, llt->llt_af); |
557 | |
558 | LIST_FOREACH_SAFE(lle, &dchain, lle_chain, next) { |
559 | #if 0 |
560 | if (thread_call_cancel(lle->lle_timer) == TRUE) |
561 | LLE_REMREF(lle); |
562 | #endif |
563 | llentry_free(lle); |
564 | } |
565 | |
566 | /* XXX We recycle network interfaces so we only purge */ |
567 | /* llt->llt_free_tbl(llt); */ |
568 | } |
569 | |
570 | #if 0 |
571 | void |
572 | lltable_drain(int af) |
573 | { |
574 | struct lltable *llt; |
575 | struct llentry *lle; |
576 | register int i; |
577 | |
578 | LLTABLE_RLOCK(); |
579 | SLIST_FOREACH(llt, &lltables, llt_link) { |
580 | if (llt->llt_af != af) |
581 | continue; |
582 | |
583 | for (i=0; i < llt->llt_hsize; i++) { |
584 | LIST_FOREACH(lle, &llt->lle_head[i], lle_next) { |
585 | LLE_WLOCK(lle); |
586 | if (lle->la_hold) { |
587 | m_freem(lle->la_hold); |
588 | lle->la_hold = NULL; |
589 | } |
590 | LLE_WUNLOCK(lle); |
591 | } |
592 | } |
593 | } |
594 | LLTABLE_RUNLOCK(); |
595 | } |
596 | #endif |
597 | |
598 | /* |
599 | * Deletes an address from given lltable. |
600 | * Used for userland interaction to remove |
601 | * individual entries. Skips entries added by OS. |
602 | */ |
603 | int |
604 | lltable_delete_addr(struct lltable *llt, u_int flags, |
605 | const struct sockaddr *l3addr) |
606 | { |
607 | struct llentry *lle; |
608 | struct ifnet *ifp; |
609 | |
610 | ifp = llt->llt_ifp; |
611 | IF_AFDATA_WLOCK(ifp, llt->llt_af); |
612 | lle = lla_lookup(llt, LLE_EXCLUSIVE, l3addr); |
613 | |
614 | if (lle == NULL) { |
615 | IF_AFDATA_WUNLOCK(ifp, llt->llt_af); |
616 | return (ENOENT); |
617 | } |
618 | if ((lle->la_flags & LLE_IFADDR) != 0 && (flags & LLE_IFADDR) == 0) { |
619 | IF_AFDATA_WUNLOCK(ifp, llt->llt_af); |
620 | LLE_WUNLOCK(lle); |
621 | return (EPERM); |
622 | } |
623 | |
624 | lltable_unlink_entry(llt, lle); |
625 | IF_AFDATA_WUNLOCK(ifp, llt->llt_af); |
626 | |
627 | llt->llt_delete_entry(llt, lle); |
628 | |
629 | return (0); |
630 | } |
631 | |
632 | void |
633 | lltable_prefix_free(int af, struct sockaddr *addr, struct sockaddr *mask, |
634 | u_int flags) |
635 | { |
636 | struct lltable *llt; |
637 | |
638 | LLTABLE_RLOCK(); |
639 | SLIST_FOREACH(llt, &lltables, llt_link) { |
640 | if (llt->llt_af != af) |
641 | continue; |
642 | |
643 | llt->llt_prefix_free(llt, addr, mask, flags); |
644 | } |
645 | LLTABLE_RUNLOCK(); |
646 | } |
647 | |
648 | struct lltable * |
649 | lltable_allocate_htbl(uint32_t hsize) |
650 | { |
651 | struct lltable *llt; |
652 | int i; |
653 | |
654 | MALLOC(llt, struct lltable *, sizeof(struct lltable), M_LLTABLE, M_WAITOK | M_ZERO); |
655 | llt->llt_hsize = hsize; |
656 | MALLOC(llt->lle_head, struct llentries *, sizeof(struct llentries) * hsize, |
657 | M_LLTABLE, M_WAITOK | M_ZERO); |
658 | |
659 | for (i = 0; i < llt->llt_hsize; i++) |
660 | LIST_INIT(&llt->lle_head[i]); |
661 | |
662 | /* Set some default callbacks */ |
663 | llt->llt_link_entry = htable_link_entry; |
664 | llt->llt_unlink_entry = htable_unlink_entry; |
665 | llt->llt_prefix_free = htable_prefix_free; |
666 | llt->llt_foreach_entry = htable_foreach_lle; |
667 | llt->llt_free_tbl = htable_free_tbl; |
668 | |
669 | return (llt); |
670 | } |
671 | |
672 | /* |
673 | * Links lltable to global llt list. |
674 | */ |
675 | void |
676 | lltable_link(struct lltable *llt) |
677 | { |
678 | LLTABLE_WLOCK(); |
679 | SLIST_INSERT_HEAD(&lltables, llt, llt_link); |
680 | LLTABLE_WUNLOCK(); |
681 | } |
682 | |
683 | #if 0 |
684 | static void |
685 | lltable_unlink(struct lltable *llt) |
686 | { |
687 | LLTABLE_WLOCK(); |
688 | SLIST_REMOVE(&lltables, llt, lltable, llt_link); |
689 | LLTABLE_WUNLOCK(); |
690 | } |
691 | #endif |
692 | |
693 | /* |
694 | * External methods used by lltable consumers |
695 | */ |
696 | |
697 | int |
698 | lltable_foreach_lle(struct lltable *llt, llt_foreach_cb_t *f, void *farg) |
699 | { |
700 | return (llt->llt_foreach_entry(llt, f, farg)); |
701 | } |
702 | |
703 | struct llentry * |
704 | lltable_alloc_entry(struct lltable *llt, u_int flags, |
705 | const struct sockaddr *l3addr) |
706 | { |
707 | return (llt->llt_alloc_entry(llt, flags, l3addr)); |
708 | } |
709 | |
710 | void |
711 | lltable_free_entry(struct lltable *llt, struct llentry *lle) |
712 | { |
713 | llt->llt_free_entry(llt, lle); |
714 | } |
715 | |
716 | void |
717 | lltable_link_entry(struct lltable *llt, struct llentry *lle) |
718 | { |
719 | llt->llt_link_entry(llt, lle); |
720 | } |
721 | |
722 | void |
723 | lltable_unlink_entry(struct lltable *llt, struct llentry *lle) |
724 | { |
725 | llt->llt_unlink_entry(lle); |
726 | } |
727 | |
728 | void |
729 | lltable_fill_sa_entry(const struct llentry *lle, struct sockaddr *sa) |
730 | { |
731 | struct lltable *llt; |
732 | |
733 | llt = lle->lle_tbl; |
734 | llt->llt_fill_sa_entry(lle, sa); |
735 | } |
736 | |
737 | struct ifnet * |
738 | lltable_get_ifp(const struct lltable *llt) |
739 | { |
740 | return (llt->llt_ifp); |
741 | } |
742 | |
743 | int |
744 | lltable_get_af(const struct lltable *llt) |
745 | { |
746 | return (llt->llt_af); |
747 | } |
748 | |
749 | #define ifnet_byindex(index) ifindex2ifnet[(index)] |
750 | |
751 | /* |
752 | * Called in route_output when rtm_flags contains RTF_LLDATA. |
753 | */ |
754 | int |
755 | lla_rt_output(struct rt_msghdr *rtm, struct rt_addrinfo *info) |
756 | { |
757 | struct sockaddr_dl *dl = |
758 | (struct sockaddr_dl *)(void *)info->rti_info[RTAX_GATEWAY]; |
759 | struct sockaddr *dst = (struct sockaddr *)info->rti_info[RTAX_DST]; |
760 | struct ifnet *ifp; |
761 | struct lltable *llt; |
762 | struct llentry *lle, *lle_tmp; |
763 | u_int laflags = 0; |
764 | int error; |
765 | |
766 | KASSERT(dl != NULL && dl->sdl_family == AF_LINK, |
767 | ("%s: invalid dl\n" , __func__)); |
768 | |
769 | ifp = ifnet_byindex(dl->sdl_index); |
770 | if (ifp == NULL) { |
771 | log(LOG_INFO, "%s: invalid ifp (sdl_index %d)\n" , |
772 | __func__, dl->sdl_index); |
773 | return EINVAL; |
774 | } |
775 | |
776 | /* XXX linked list may be too expensive */ |
777 | LLTABLE_RLOCK(); |
778 | SLIST_FOREACH(llt, &lltables, llt_link) { |
779 | if (llt->llt_af == dst->sa_family && |
780 | llt->llt_ifp == ifp) |
781 | break; |
782 | } |
783 | LLTABLE_RUNLOCK(); |
784 | KASSERT(llt != NULL, ("Yep, ugly hacks are bad\n" )); |
785 | |
786 | error = 0; |
787 | |
788 | switch (rtm->rtm_type) { |
789 | case RTM_ADD: |
790 | /* Add static LLE */ |
791 | laflags = 0; |
792 | if (rtm->rtm_rmx.rmx_expire == 0) |
793 | laflags = LLE_STATIC; |
794 | lle = lltable_alloc_entry(llt, laflags, dst); |
795 | if (lle == NULL) |
796 | return (ENOMEM); |
797 | #if 0 |
798 | linkhdrsize = sizeof(linkhdr); |
799 | if (lltable_calc_llheader(ifp, dst->sa_family, LLADDR(dl), |
800 | (void *)linkhdr, &linkhdrsize, &lladdr_off) != 0) |
801 | return (EINVAL); |
802 | #endif |
803 | lltable_set_entry_addr(ifp, lle, LLADDR(dl)); |
804 | |
805 | if (rtm->rtm_flags & RTF_ANNOUNCE) |
806 | lle->la_flags |= LLE_PUB; |
807 | lle->la_expire = rtm->rtm_rmx.rmx_expire; |
808 | |
809 | laflags = lle->la_flags; |
810 | |
811 | /* Try to link new entry */ |
812 | lle_tmp = NULL; |
813 | IF_AFDATA_WLOCK(ifp, llt->llt_af); |
814 | LLE_WLOCK(lle); |
815 | lle_tmp = lla_lookup(llt, LLE_EXCLUSIVE, dst); |
816 | if (lle_tmp != NULL) { |
817 | /* Check if we are trying to replace immutable entry */ |
818 | if ((lle_tmp->la_flags & LLE_IFADDR) != 0) { |
819 | IF_AFDATA_WUNLOCK(ifp, llt->llt_af); |
820 | LLE_WUNLOCK(lle_tmp); |
821 | lltable_free_entry(llt, lle); |
822 | return (EPERM); |
823 | } |
824 | /* Unlink existing entry from table */ |
825 | lltable_unlink_entry(llt, lle_tmp); |
826 | } |
827 | lltable_link_entry(llt, lle); |
828 | IF_AFDATA_WUNLOCK(ifp, llt->llt_af); |
829 | |
830 | if (lle_tmp != NULL) { |
831 | EVENTHANDLER_INVOKE(NULL, lle_event, lle_tmp, LLENTRY_EXPIRED); |
832 | lltable_free_entry(llt, lle_tmp); |
833 | } |
834 | |
835 | /* |
836 | * By invoking LLE handler here we might get |
837 | * two events on static LLE entry insertion |
838 | * in routing socket. However, since we might have |
839 | * other subscribers we need to generate this event. |
840 | */ |
841 | EVENTHANDLER_INVOKE(NULL, lle_event, lle, LLENTRY_RESOLVED); |
842 | LLE_WUNLOCK(lle); |
843 | #ifdef INET |
844 | /* gratuitous ARP */ |
845 | if ((laflags & LLE_PUB) && dst->sa_family == AF_INET) |
846 | dlil_send_arp(ifp, ARPOP_REQUEST, NULL, dst, NULL, dst, 0); |
847 | #endif |
848 | |
849 | break; |
850 | |
851 | case RTM_DELETE: |
852 | return (lltable_delete_addr(llt, 0, dst)); |
853 | |
854 | default: |
855 | error = EINVAL; |
856 | } |
857 | |
858 | return (error); |
859 | } |
860 | |
861 | |