1 /** $MirOS: src/sys/net/pf_if.c,v 1.5 2006/10/17 20:48:50 tg Exp $ */
2 /* $OpenBSD: pf_if.c,v 1.12 2004/04/28 02:43:09 pb Exp $ */
3
4 /*
5 * Copyright (c) 2001 Daniel Hartmeier
6 * Copyright (c) 2003 Cedric Berger
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * - Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * - Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer in the documentation and/or other materials provided
18 * with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
28 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/mbuf.h>
37 #include <sys/filio.h>
38 #include <sys/socket.h>
39 #include <sys/socketvar.h>
40 #include <sys/kernel.h>
41 #include <sys/device.h>
42 #include <sys/time.h>
43
44 #include <net/if.h>
45 #include <net/if_types.h>
46
47 #include <netinet/in.h>
48 #include <netinet/in_var.h>
49 #include <netinet/in_systm.h>
50 #include <netinet/ip.h>
51 #include <netinet/ip_var.h>
52
53 #include <net/pfvar.h>
54
55 #ifdef INET6
56 #include <netinet/ip6.h>
57 #endif /* INET6 */
58
59 #define ACCEPT_FLAGS(oklist) \
60 do { \
61 if ((flags & ~(oklist)) & \
62 PFI_FLAG_ALLMASK) \
63 return (EINVAL); \
64 } while (0)
65
66 #define senderr(e) do { rv = (e); goto _bad; } while (0)
67
68 struct pfi_kif **pfi_index2kif;
69 struct pfi_kif *pfi_self;
70 int pfi_indexlim;
71 struct pfi_ifhead pfi_ifs;
72 struct pfi_statehead pfi_statehead;
73 int pfi_ifcnt;
74 struct pool pfi_addr_pl;
75 long pfi_update = 1;
76 struct pfr_addr *pfi_buffer;
77 int pfi_buffer_cnt;
78 int pfi_buffer_max;
79 char pfi_reserved_anchor[PF_ANCHOR_NAME_SIZE] =
80 PF_RESERVED_ANCHOR;
81 char pfi_interface_ruleset[PF_RULESET_NAME_SIZE] =
82 PF_INTERFACE_RULESET;
83
84 void pfi_kifaddr_update(void *);
85 void pfi_table_update(struct pfr_ktable *, struct pfi_kif *,
86 int, int);
87 void pfi_instance_add(struct ifnet *, int, int);
88 void pfi_address_add(struct sockaddr *, int, int);
89 int pfi_if_compare(struct pfi_kif *, struct pfi_kif *);
90 struct pfi_kif *pfi_if_create(const char *, struct pfi_kif *, int);
91 void pfi_copy_group(char *, const char *, int);
92 void pfi_dynamic_drivers(void);
93 void pfi_newgroup(const char *, int);
94 int pfi_skip_if(const char *, struct pfi_kif *, int);
95 int pfi_unmask(void *);
96 void pfi_dohooks(struct pfi_kif *);
97
98 RB_PROTOTYPE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare);
99 RB_GENERATE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare);
100
101 #define PFI_DYNAMIC_BUSES { "pcmcia", "cardbus", "uhub" }
102 #define PFI_BUFFER_MAX 0x10000
103 #define PFI_MTYPE M_IFADDR
104
105 void
pfi_initialize(void)106 pfi_initialize(void)
107 {
108 if (pfi_self != NULL) /* already initialized */
109 return;
110
111 TAILQ_INIT(&pfi_statehead);
112 pool_init(&pfi_addr_pl, sizeof(struct pfi_dynaddr), 0, 0, 0,
113 "pfiaddrpl", &pool_allocator_nointr);
114 pfi_buffer_max = 64;
115 pfi_buffer = malloc(pfi_buffer_max * sizeof(*pfi_buffer),
116 PFI_MTYPE, M_WAITOK);
117 pfi_self = pfi_if_create("self", NULL, PFI_IFLAG_GROUP);
118 pfi_dynamic_drivers();
119 }
120
121 void
pfi_attach_clone(struct if_clone * ifc)122 pfi_attach_clone(struct if_clone *ifc)
123 {
124 pfi_initialize();
125 pfi_newgroup(ifc->ifc_name, PFI_IFLAG_CLONABLE);
126 }
127
128 void
pfi_attach_ifnet(struct ifnet * ifp)129 pfi_attach_ifnet(struct ifnet *ifp)
130 {
131 struct pfi_kif *p, *q, key;
132 int s;
133
134 pfi_initialize();
135 s = splsoftnet();
136 pfi_update++;
137 if (ifp->if_index >= pfi_indexlim) {
138 /*
139 * grow pfi_index2kif, similar to ifindex2ifnet code in if.c
140 */
141 size_t m, n, oldlim;
142 struct pfi_kif **mp, **np;
143
144 oldlim = pfi_indexlim;
145 if (pfi_indexlim == 0)
146 pfi_indexlim = 64;
147 while (ifp->if_index >= pfi_indexlim)
148 pfi_indexlim <<= 1;
149
150 m = oldlim * sizeof(struct pfi_kif *);
151 mp = pfi_index2kif;
152 n = pfi_indexlim * sizeof(struct pfi_kif *);
153 np = malloc(n, PFI_MTYPE, M_DONTWAIT);
154 if (np == NULL)
155 panic("pfi_attach_ifnet: "
156 "cannot allocate translation table");
157 bzero(np, n);
158 if (mp != NULL)
159 bcopy(mp, np, m);
160 pfi_index2kif = np;
161 if (mp != NULL)
162 free(mp, PFI_MTYPE);
163 }
164
165 strlcpy(key.pfik_name, ifp->if_xname, sizeof(key.pfik_name));
166 p = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
167 if (p == NULL) {
168 /* add group */
169 pfi_copy_group(key.pfik_name, ifp->if_xname,
170 sizeof(key.pfik_name));
171 q = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
172 if (q == NULL)
173 q = pfi_if_create(key.pfik_name, pfi_self, PFI_IFLAG_GROUP);
174 if (q == NULL)
175 panic("pfi_attach_ifnet: "
176 "cannot allocate '%s' group", key.pfik_name);
177
178 /* add interface */
179 p = pfi_if_create(ifp->if_xname, q, PFI_IFLAG_INSTANCE);
180 if (p == NULL)
181 panic("pfi_attach_ifnet: "
182 "cannot allocate '%s' interface", ifp->if_xname);
183 } else
184 q = p->pfik_parent;
185 p->pfik_ifp = ifp;
186 p->pfik_flags |= PFI_IFLAG_ATTACHED;
187 p->pfik_ah_cookie =
188 hook_establish(ifp->if_addrhooks, 1, pfi_kifaddr_update, p);
189 pfi_index2kif[ifp->if_index] = p;
190 pfi_dohooks(p);
191 splx(s);
192 }
193
194 void
pfi_detach_ifnet(struct ifnet * ifp)195 pfi_detach_ifnet(struct ifnet *ifp)
196 {
197 struct pfi_kif *p, *q, key;
198 int s;
199
200 strlcpy(key.pfik_name, ifp->if_xname, sizeof(key.pfik_name));
201
202 s = splsoftnet();
203 pfi_update++;
204 p = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
205 if (p == NULL) {
206 printf("pfi_detach_ifnet: cannot find %s", ifp->if_xname);
207 splx(s);
208 return;
209 }
210 hook_disestablish(p->pfik_ifp->if_addrhooks, p->pfik_ah_cookie);
211 q = p->pfik_parent;
212 p->pfik_ifp = NULL;
213 p->pfik_flags &= ~PFI_IFLAG_ATTACHED;
214 pfi_index2kif[ifp->if_index] = NULL;
215 pfi_dohooks(p);
216 pfi_maybe_destroy(p);
217 splx(s);
218 }
219
220 struct pfi_kif *
pfi_lookup_create(const char * name)221 pfi_lookup_create(const char *name)
222 {
223 struct pfi_kif *p, *q, key;
224 int s;
225
226 s = splsoftnet();
227 p = pfi_lookup_if(name);
228 if (p == NULL) {
229 pfi_copy_group(key.pfik_name, name, sizeof(key.pfik_name));
230 q = pfi_lookup_if(key.pfik_name);
231 if (q != NULL)
232 p = pfi_if_create(name, q, PFI_IFLAG_INSTANCE);
233 }
234 splx(s);
235 return (p);
236 }
237
238 struct pfi_kif *
pfi_attach_rule(const char * name)239 pfi_attach_rule(const char *name)
240 {
241 struct pfi_kif *p;
242
243 p = pfi_lookup_create(name);
244 if (p != NULL)
245 p->pfik_rules++;
246 return (p);
247 }
248
249 void
pfi_detach_rule(struct pfi_kif * p)250 pfi_detach_rule(struct pfi_kif *p)
251 {
252 if (p == NULL)
253 return;
254 if (p->pfik_rules > 0)
255 p->pfik_rules--;
256 else
257 printf("pfi_detach_rule: reference count at 0\n");
258 pfi_maybe_destroy(p);
259 }
260
261 void
pfi_attach_state(struct pfi_kif * p)262 pfi_attach_state(struct pfi_kif *p)
263 {
264 if (!p->pfik_states++)
265 TAILQ_INSERT_TAIL(&pfi_statehead, p, pfik_w_states);
266 }
267
268 void
pfi_detach_state(struct pfi_kif * p)269 pfi_detach_state(struct pfi_kif *p)
270 {
271 if (p == NULL)
272 return;
273 if (p->pfik_states <= 0) {
274 printf("pfi_detach_state: reference count <= 0\n");
275 return;
276 }
277 if (!--p->pfik_states)
278 TAILQ_REMOVE(&pfi_statehead, p, pfik_w_states);
279 pfi_maybe_destroy(p);
280 }
281
282 void
pfi_table_update(struct pfr_ktable * kt,struct pfi_kif * kif,int net,int flags)283 pfi_table_update(struct pfr_ktable *kt, struct pfi_kif *kif, int net, int flags)
284 {
285 int e, size2 = 0;
286 struct pfi_kif *p;
287 struct pfr_table t;
288
289 if ((kif->pfik_flags & PFI_IFLAG_INSTANCE) && kif->pfik_ifp == NULL) {
290 pfr_clr_addrs(&kt->pfrkt_t, NULL, 0);
291 return;
292 }
293 pfi_buffer_cnt = 0;
294 if ((kif->pfik_flags & PFI_IFLAG_INSTANCE))
295 pfi_instance_add(kif->pfik_ifp, net, flags);
296 else if (strcmp(kif->pfik_name, "self")) {
297 TAILQ_FOREACH(p, &kif->pfik_grouphead, pfik_instances)
298 pfi_instance_add(p->pfik_ifp, net, flags);
299 } else {
300 RB_FOREACH(p, pfi_ifhead, &pfi_ifs)
301 if (p->pfik_flags & PFI_IFLAG_INSTANCE)
302 pfi_instance_add(p->pfik_ifp, net, flags);
303 }
304 t = kt->pfrkt_t;
305 t.pfrt_flags = 0;
306 if ((e = pfr_set_addrs(&t, pfi_buffer, pfi_buffer_cnt, &size2,
307 NULL, NULL, NULL, 0)))
308 printf("pfi_table_update: cannot set %d new addresses "
309 "into table %s: %d\n", pfi_buffer_cnt, kt->pfrkt_name, e);
310 }
311
312 void
pfi_instance_add(struct ifnet * ifp,int net,int flags)313 pfi_instance_add(struct ifnet *ifp, int net, int flags)
314 {
315 struct ifaddr *ia;
316 int got4 = 0, got6 = 0;
317 int net2, af;
318
319 if (ifp == NULL)
320 return;
321 TAILQ_FOREACH(ia, &ifp->if_addrlist, ifa_list) {
322 if (ia->ifa_addr == NULL)
323 continue;
324 af = ia->ifa_addr->sa_family;
325 if (af != AF_INET && af != AF_INET6)
326 continue;
327 if ((flags & PFI_AFLAG_BROADCAST) && af == AF_INET6)
328 continue;
329 if ((flags & PFI_AFLAG_BROADCAST) &&
330 !(ifp->if_flags & IFF_BROADCAST))
331 continue;
332 if ((flags & PFI_AFLAG_PEER) &&
333 !(ifp->if_flags & IFF_POINTOPOINT))
334 continue;
335 if ((flags & PFI_AFLAG_NETWORK) && af == AF_INET6 &&
336 IN6_IS_ADDR_LINKLOCAL(
337 &((struct sockaddr_in6 *)ia->ifa_addr)->sin6_addr))
338 continue;
339 if (flags & PFI_AFLAG_NOALIAS) {
340 if (af == AF_INET && got4)
341 continue;
342 if (af == AF_INET6 && got6)
343 continue;
344 }
345 if (af == AF_INET)
346 got4 = 1;
347 else if (af == AF_INET6)
348 got6 = 1;
349 net2 = net;
350 if (net2 == 128 && (flags & PFI_AFLAG_NETWORK)) {
351 if (af == AF_INET) {
352 net2 = pfi_unmask(&((struct sockaddr_in *)
353 ia->ifa_netmask)->sin_addr);
354 } else if (af == AF_INET6) {
355 net2 = pfi_unmask(&((struct sockaddr_in6 *)
356 ia->ifa_netmask)->sin6_addr);
357 }
358 }
359 if (af == AF_INET && net2 > 32)
360 net2 = 32;
361 if (flags & PFI_AFLAG_BROADCAST)
362 pfi_address_add(ia->ifa_broadaddr, af, net2);
363 else if (flags & PFI_AFLAG_PEER)
364 pfi_address_add(ia->ifa_dstaddr, af, net2);
365 else
366 pfi_address_add(ia->ifa_addr, af, net2);
367 }
368 }
369
370 void
pfi_address_add(struct sockaddr * sa,int af,int net)371 pfi_address_add(struct sockaddr *sa, int af, int net)
372 {
373 struct pfr_addr *p;
374 int i;
375
376 if (pfi_buffer_cnt >= pfi_buffer_max) {
377 int new_max = pfi_buffer_max * 2;
378
379 if (new_max > PFI_BUFFER_MAX) {
380 printf("pfi_address_add: address buffer full (%d/%d)\n",
381 pfi_buffer_cnt, PFI_BUFFER_MAX);
382 return;
383 }
384 p = malloc(new_max * sizeof(*pfi_buffer), PFI_MTYPE,
385 M_DONTWAIT);
386 if (p == NULL) {
387 printf("pfi_address_add: no memory to grow buffer "
388 "(%d/%d)\n", pfi_buffer_cnt, PFI_BUFFER_MAX);
389 return;
390 }
391 memcpy(pfi_buffer, p, pfi_buffer_cnt * sizeof(*pfi_buffer));
392 /* no need to zero buffer */
393 free(pfi_buffer, PFI_MTYPE);
394 pfi_buffer = p;
395 pfi_buffer_max = new_max;
396 }
397 if (af == AF_INET && net > 32)
398 net = 128;
399 p = pfi_buffer + pfi_buffer_cnt++;
400 bzero(p, sizeof(*p));
401 p->pfra_af = af;
402 p->pfra_net = net;
403 if (af == AF_INET)
404 p->pfra_ip4addr = ((struct sockaddr_in *)sa)->sin_addr;
405 if (af == AF_INET6) {
406 p->pfra_ip6addr = ((struct sockaddr_in6 *)sa)->sin6_addr;
407 if (IN6_IS_ADDR_LINKLOCAL(&p->pfra_ip6addr))
408 p->pfra_ip6addr.s6_addr16[1] = 0;
409 }
410 /* mask network address bits */
411 if (net < 128)
412 ((caddr_t)p)[p->pfra_net/8] &= ~(0xFF >> (p->pfra_net%8));
413 for (i = (p->pfra_net+7)/8; i < sizeof(p->pfra_u); i++)
414 ((caddr_t)p)[i] = 0;
415 }
416
417 void
pfi_kifaddr_update(void * v)418 pfi_kifaddr_update(void *v)
419 {
420 int s;
421
422 s = splsoftnet();
423 pfi_update++;
424 pfi_dohooks(v);
425 splx(s);
426 }
427
428 int
pfi_if_compare(struct pfi_kif * p,struct pfi_kif * q)429 pfi_if_compare(struct pfi_kif *p, struct pfi_kif *q)
430 {
431 return (strncmp(p->pfik_name, q->pfik_name, IFNAMSIZ));
432 }
433
434 struct pfi_kif *
pfi_if_create(const char * name,struct pfi_kif * q,int flags)435 pfi_if_create(const char *name, struct pfi_kif *q, int flags)
436 {
437 struct pfi_kif *p;
438
439 p = malloc(sizeof(*p), PFI_MTYPE, M_DONTWAIT);
440 if (p == NULL)
441 return (NULL);
442 bzero(p, sizeof(*p));
443 p->pfik_ah_head = malloc(sizeof(*p->pfik_ah_head), PFI_MTYPE,
444 M_DONTWAIT);
445 if (p->pfik_ah_head == NULL) {
446 free(p, PFI_MTYPE);
447 return (NULL);
448 }
449 bzero(p->pfik_ah_head, sizeof(*p->pfik_ah_head));
450 TAILQ_INIT(p->pfik_ah_head);
451 TAILQ_INIT(&p->pfik_grouphead);
452 strlcpy(p->pfik_name, name, sizeof(p->pfik_name));
453 RB_INIT(&p->pfik_lan_ext);
454 RB_INIT(&p->pfik_ext_gwy);
455 p->pfik_flags = flags;
456 p->pfik_parent = q;
457 p->pfik_tzero = time.tv_sec;
458
459 RB_INSERT(pfi_ifhead, &pfi_ifs, p);
460 if (q != NULL) {
461 q->pfik_addcnt++;
462 TAILQ_INSERT_TAIL(&q->pfik_grouphead, p, pfik_instances);
463 }
464 pfi_ifcnt++;
465 return (p);
466 }
467
468 int
pfi_maybe_destroy(struct pfi_kif * p)469 pfi_maybe_destroy(struct pfi_kif *p)
470 {
471 int i, j, k, s;
472 struct pfi_kif *q = p->pfik_parent;
473
474 if ((p->pfik_flags & (PFI_IFLAG_ATTACHED | PFI_IFLAG_GROUP)) ||
475 p->pfik_rules > 0 || p->pfik_states > 0)
476 return (0);
477
478 s = splsoftnet();
479 if (q != NULL) {
480 for (i = 0; i < 2; i++)
481 for (j = 0; j < 2; j++)
482 for (k = 0; k < 2; k++) {
483 q->pfik_bytes[i][j][k] +=
484 p->pfik_bytes[i][j][k];
485 q->pfik_packets[i][j][k] +=
486 p->pfik_packets[i][j][k];
487 }
488 q->pfik_delcnt++;
489 TAILQ_REMOVE(&q->pfik_grouphead, p, pfik_instances);
490 }
491 pfi_ifcnt--;
492 RB_REMOVE(pfi_ifhead, &pfi_ifs, p);
493 splx(s);
494
495 free(p->pfik_ah_head, PFI_MTYPE);
496 free(p, PFI_MTYPE);
497 return (1);
498 }
499
500 void
pfi_copy_group(char * p,const char * q,int m)501 pfi_copy_group(char *p, const char *q, int m)
502 {
503 while (m > 1 && *q && !(*q >= '0' && *q <= '9')) {
504 *p++ = *q++;
505 m--;
506 }
507 if (m > 0)
508 *p++ = '\0';
509 }
510
511 void
pfi_dynamic_drivers(void)512 pfi_dynamic_drivers(void)
513 {
514 char *buses[] = PFI_DYNAMIC_BUSES;
515 int nbuses = sizeof(buses)/sizeof(buses[0]);
516 int enabled[sizeof(buses)/sizeof(buses[0])];
517 struct device *dev;
518 struct cfdata *cf;
519 struct cfdriver *drv;
520 short *p;
521 int i;
522
523 bzero(enabled, sizeof(enabled));
524 TAILQ_FOREACH(dev, &alldevs, dv_list) {
525 if (!(dev->dv_flags & DVF_ACTIVE))
526 continue;
527 for (i = 0; i < nbuses; i++)
528 if (!enabled[i] && !strcmp(buses[i],
529 dev->dv_cfdata->cf_driver->cd_name))
530 enabled[i] = 1;
531 }
532 for (cf = cfdata; cf->cf_driver; cf++) {
533 if (cf->cf_driver->cd_class != DV_IFNET)
534 continue;
535 for (p = cf->cf_parents; p && *p >= 0; p++) {
536 if ((drv = cfdata[*p].cf_driver) == NULL)
537 continue;
538 for (i = 0; i < nbuses; i++)
539 if (enabled[i] &&
540 !strcmp(drv->cd_name, buses[i]))
541 break;
542 if (i < nbuses) {
543 pfi_newgroup(cf->cf_driver->cd_name,
544 PFI_IFLAG_DYNAMIC);
545 break;
546 }
547 }
548 }
549 }
550
551 void
pfi_newgroup(const char * name,int flags)552 pfi_newgroup(const char *name, int flags)
553 {
554 struct pfi_kif *p;
555
556 p = pfi_lookup_if(name);
557 if (p == NULL)
558 p = pfi_if_create(name, pfi_self, PFI_IFLAG_GROUP);
559 if (p == NULL) {
560 printf("pfi_newgroup: cannot allocate '%s' group", name);
561 return;
562 }
563 p->pfik_flags |= flags;
564 }
565
566 void
pfi_fill_oldstatus(struct pf_status * pfs)567 pfi_fill_oldstatus(struct pf_status *pfs)
568 {
569 struct pfi_kif *p, key;
570 int i, j, k, s;
571
572 strlcpy(key.pfik_name, pfs->ifname, sizeof(key.pfik_name));
573 s = splsoftnet();
574 p = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
575 if (p == NULL) {
576 splx(s);
577 return;
578 }
579 bzero(pfs->pcounters, sizeof(pfs->pcounters));
580 bzero(pfs->bcounters, sizeof(pfs->bcounters));
581 for (i = 0; i < 2; i++)
582 for (j = 0; j < 2; j++)
583 for (k = 0; k < 2; k++) {
584 pfs->pcounters[i][j][k] =
585 p->pfik_packets[i][j][k];
586 pfs->bcounters[i][j] +=
587 p->pfik_bytes[i][j][k];
588 }
589 splx(s);
590 }
591
592 int
pfi_clr_istats(const char * name,int * nzero,int flags)593 pfi_clr_istats(const char *name, int *nzero, int flags)
594 {
595 struct pfi_kif *p;
596 int n = 0, s;
597 time_t tzero = time.tv_sec;
598
599 s = splsoftnet();
600 ACCEPT_FLAGS(PFI_FLAG_GROUP|PFI_FLAG_INSTANCE);
601 RB_FOREACH(p, pfi_ifhead, &pfi_ifs) {
602 if (pfi_skip_if(name, p, flags))
603 continue;
604 bzero(p->pfik_packets, sizeof(p->pfik_packets));
605 bzero(p->pfik_bytes, sizeof(p->pfik_bytes));
606 p->pfik_tzero = tzero;
607 n++;
608 }
609 splx(s);
610 if (nzero != NULL)
611 *nzero = n;
612 return (0);
613 }
614
615 int
pfi_get_ifaces(const char * name,struct pfi_if * buf,int * size,int flags)616 pfi_get_ifaces(const char *name, struct pfi_if *buf, int *size, int flags)
617 {
618 struct pfi_kif *p;
619 int s, n = 0;
620
621 ACCEPT_FLAGS(PFI_FLAG_GROUP|PFI_FLAG_INSTANCE);
622 s = splsoftnet();
623 RB_FOREACH(p, pfi_ifhead, &pfi_ifs) {
624 if (pfi_skip_if(name, p, flags))
625 continue;
626 if (*size > n++) {
627 if (!p->pfik_tzero)
628 p->pfik_tzero = boottime.tv_sec;
629 if (copyout(p, buf++, sizeof(*buf))) {
630 splx(s);
631 return (EFAULT);
632 }
633 }
634 }
635 splx(s);
636 *size = n;
637 return (0);
638 }
639
640 struct pfi_kif *
pfi_lookup_if(const char * name)641 pfi_lookup_if(const char *name)
642 {
643 struct pfi_kif *p, key;
644
645 strlcpy(key.pfik_name, name, sizeof(key.pfik_name));
646 p = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
647 return (p);
648 }
649
650 int
pfi_skip_if(const char * filter,struct pfi_kif * p,int f)651 pfi_skip_if(const char *filter, struct pfi_kif *p, int f)
652 {
653 int n;
654
655 if ((p->pfik_flags & PFI_IFLAG_GROUP) && !(f & PFI_FLAG_GROUP))
656 return (1);
657 if ((p->pfik_flags & PFI_IFLAG_INSTANCE) && !(f & PFI_FLAG_INSTANCE))
658 return (1);
659 if (filter == NULL || !*filter)
660 return (0);
661 if (!strcmp(p->pfik_name, filter))
662 return (0); /* exact match */
663 n = strlen(filter);
664 if (n < 1 || n >= IFNAMSIZ)
665 return (1); /* sanity check */
666 if (filter[n-1] >= '0' && filter[n-1] <= '9')
667 return (1); /* only do exact match in that case */
668 if (strncmp(p->pfik_name, filter, n))
669 return (1); /* prefix doesn't match */
670 return (p->pfik_name[n] < '0' || p->pfik_name[n] > '9');
671 }
672
673 /* from pf_print_state.c */
674 int
pfi_unmask(void * addr)675 pfi_unmask(void *addr)
676 {
677 struct pf_addr *m = addr;
678 int i = 31, j = 0, b = 0;
679 u_int32_t tmp;
680
681 while (j < 4 && m->addr32[j] == 0xffffffff) {
682 b += 32;
683 j++;
684 }
685 if (j < 4) {
686 tmp = ntohl(m->addr32[j]);
687 for (i = 31; tmp & (1 << i); --i)
688 b++;
689 }
690 return (b);
691 }
692
693 void
pfi_dohooks(struct pfi_kif * p)694 pfi_dohooks(struct pfi_kif *p)
695 {
696 for (; p != NULL; p = p->pfik_parent)
697 dohooks(p->pfik_ah_head, 0);
698 }
699
700 int
pfi_match_addr(struct pfi_dynaddr * dyn,struct pf_addr * a,sa_family_t af)701 pfi_match_addr(struct pfi_dynaddr *dyn, struct pf_addr *a, sa_family_t af)
702 {
703 switch (af) {
704 #ifdef INET
705 case AF_INET:
706 switch (dyn->pfid_acnt4) {
707 case 0:
708 return (0);
709 case 1:
710 return (PF_MATCHA(0, &dyn->pfid_addr4,
711 &dyn->pfid_mask4, a, AF_INET));
712 default:
713 return (pfr_match_addr(dyn->pfid_kt, a, AF_INET));
714 }
715 break;
716 #endif /* INET */
717 #ifdef INET6
718 case AF_INET6:
719 switch (dyn->pfid_acnt6) {
720 case 0:
721 return (0);
722 case 1:
723 return (PF_MATCHA(0, &dyn->pfid_addr6,
724 &dyn->pfid_mask6, a, AF_INET6));
725 default:
726 return (pfr_match_addr(dyn->pfid_kt, a, AF_INET6));
727 }
728 break;
729 #endif /* INET6 */
730 default:
731 return (0);
732 }
733 }
734