Deleted Added
sdiff udiff text old ( 130611 ) new ( 130613 )
full compact
1/* $FreeBSD: head/sys/contrib/pf/net/pf_if.c 130613 2004-06-16 23:24:02Z mlaier $ */
2/* $OpenBSD: pf_if.c,v 1.11 2004/03/15 11:38:23 cedric 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

--- 16 unchanged lines hidden (view full) ---

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#if defined(__FreeBSD__)
35#include "opt_inet.h"
36#include "opt_inet6.h"
37#endif
38
39#include <sys/param.h>
40#include <sys/systm.h>
41#ifdef __FreeBSD__
42#include <sys/malloc.h>
43#endif
44#include <sys/mbuf.h>
45#include <sys/filio.h>
46#include <sys/socket.h>
47#include <sys/socketvar.h>
48#include <sys/kernel.h>
49#ifndef __FreeBSD__
50#include <sys/device.h>
51#endif
52#include <sys/time.h>
53
54#include <net/if.h>
55#include <net/if_types.h>
56
57#include <netinet/in.h>
58#include <netinet/in_var.h>
59#include <netinet/in_systm.h>

--- 11 unchanged lines hidden (view full) ---

71 if ((flags & ~(oklist)) & \
72 PFI_FLAG_ALLMASK) \
73 return (EINVAL); \
74 } while (0)
75
76#define senderr(e) do { rv = (e); goto _bad; } while (0)
77
78struct pfi_kif **pfi_index2kif;
68struct pfi_kif *pfi_self;
79struct pfi_kif *pfi_self, *pfi_dummy;
80int pfi_indexlim;
81struct pfi_ifhead pfi_ifs;
82struct pfi_statehead pfi_statehead;
83int pfi_ifcnt;
84#ifdef __FreeBSD__
85uma_zone_t pfi_addr_pl;
86#else
87struct pool pfi_addr_pl;
88#endif
89long pfi_update = 1;
90struct pfr_addr *pfi_buffer;
91int pfi_buffer_cnt;
92int pfi_buffer_max;
93char pfi_reserved_anchor[PF_ANCHOR_NAME_SIZE] =
94 PF_RESERVED_ANCHOR;
95char pfi_interface_ruleset[PF_RULESET_NAME_SIZE] =
96 PF_INTERFACE_RULESET;
97#ifdef __FreeBSD__
98eventhandler_tag pfi_clone_cookie = NULL;
99eventhandler_tag pfi_attach_cookie = NULL;
100eventhandler_tag pfi_detach_cookie = NULL;
101#endif
102
103void pfi_dynaddr_update(void *);
104void pfi_kifaddr_update(void *);
105void pfi_table_update(struct pfr_ktable *, struct pfi_kif *,
106 int, int);
107void pfi_instance_add(struct ifnet *, int, int);
108void pfi_address_add(struct sockaddr *, int, int);
109int pfi_if_compare(struct pfi_kif *, struct pfi_kif *);
110struct pfi_kif *pfi_if_create(const char *, struct pfi_kif *, int);
111void pfi_copy_group(char *, const char *, int);
112void pfi_dynamic_drivers(void);
113void pfi_newgroup(const char *, int);
114int pfi_skip_if(const char *, struct pfi_kif *, int);
115int pfi_unmask(void *);
116void pfi_dohooks(struct pfi_kif *);
117#ifdef __FreeBSD__
118void pfi_kifaddr_update_event(void *, struct ifnet *);
119void pfi_attach_clone_event(void * __unused, struct if_clone *);
120void pfi_attach_ifnet_event(void * __unused, struct ifnet *);
121void pfi_detach_ifnet_event(void * __unused, struct ifnet *);
122#endif
123
124RB_PROTOTYPE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare);
125RB_GENERATE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare);
126
127#define PFI_DYNAMIC_BUSES { "pcmcia", "cardbus", "uhub" }
128#define PFI_BUFFER_MAX 0x10000
129#ifdef __FreeBSD__
130MALLOC_DEFINE(PFI_MTYPE, "pf_if", "pf interface table");
131#else
132#define PFI_MTYPE M_IFADDR
133#endif
134
135void
136pfi_initialize(void)
137{
138#ifdef __FreeBSD__
139 struct ifnet *ifp;
140#endif
141
142 if (pfi_self != NULL) /* already initialized */
143 return;
144
145 TAILQ_INIT(&pfi_statehead);
146#ifndef __FreeBSD__
147 pool_init(&pfi_addr_pl, sizeof(struct pfi_dynaddr), 0, 0, 0,
148 "pfiaddrpl", &pool_allocator_nointr);
149#endif
150 pfi_buffer_max = 64;
151 pfi_buffer = malloc(pfi_buffer_max * sizeof(*pfi_buffer),
152 PFI_MTYPE, M_WAITOK);
153 pfi_self = pfi_if_create("self", NULL, PFI_IFLAG_GROUP);
154 pfi_dynamic_drivers();
155#ifdef __FreeBSD__
156 PF_LOCK();
157 IFNET_RLOCK();
158 TAILQ_FOREACH(ifp, &ifnet, if_link)
159 if (ifp->if_dunit != IF_DUNIT_NONE) {
160 IFNET_RUNLOCK();
161 pfi_attach_ifnet(ifp);
162 IFNET_RLOCK();
163 }
164 IFNET_RUNLOCK();
165 PF_UNLOCK();
166 pfi_dummy = pfi_if_create("notyet", pfi_self,
167 PFI_IFLAG_GROUP | PFI_IFLAG_DYNAMIC);
168 pfi_attach_cookie = EVENTHANDLER_REGISTER(ifnet_arrival_event,
169 pfi_attach_ifnet_event, NULL, EVENTHANDLER_PRI_ANY);
170 pfi_detach_cookie = EVENTHANDLER_REGISTER(ifnet_departure_event,
171 pfi_detach_ifnet_event, NULL, EVENTHANDLER_PRI_ANY);
172 pfi_clone_cookie = EVENTHANDLER_REGISTER(if_clone_event,
173 pfi_attach_clone_event, NULL, EVENTHANDLER_PRI_ANY);
174#endif
175}
176
177#ifdef __FreeBSD__
178void
179pfi_cleanup(void)
180{
181 struct pfi_kif *p, key;
182 struct ifnet *ifp;
183
184 PF_ASSERT(MA_OWNED);
185 PF_UNLOCK();
186
187 EVENTHANDLER_DEREGISTER(ifnet_arrival_event, pfi_attach_cookie);
188 EVENTHANDLER_DEREGISTER(ifnet_departure_event, pfi_detach_cookie);
189 EVENTHANDLER_DEREGISTER(if_clone_event, pfi_clone_cookie);
190
191 IFNET_RLOCK();
192 /* release PFI_IFLAG_INSTANCE */
193 TAILQ_FOREACH(ifp, &ifnet, if_link) {
194 strlcpy(key.pfik_name, ifp->if_xname, sizeof(key.pfik_name));
195 p = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
196 if (p != NULL) {
197 PF_LOCK();
198 pfi_detach_ifnet(ifp);
199 PF_UNLOCK();
200 }
201 }
202 IFNET_RUNLOCK();
203
204 PF_LOCK();
205 /* XXX clear all other interface group */
206 while ((p = RB_MIN(pfi_ifhead, &pfi_ifs))) {
207 RB_REMOVE(pfi_ifhead, &pfi_ifs, p);
208
209 free(p->pfik_ah_head, PFI_MTYPE);
210 free(p, PFI_MTYPE);
211 }
212 free(pfi_index2kif, PFI_MTYPE);
213 free(pfi_buffer, PFI_MTYPE);
214 pfi_index2kif = NULL;
215 pfi_buffer = NULL;
216 pfi_self = NULL;
217}
218
219/*
220 * Wrapper functions for FreeBSD eventhandler
221 */
222void
223pfi_kifaddr_update_event(void *arg, struct ifnet *ifp)
224{
225 struct pfi_kif *p = arg;
226
227 PF_LOCK();
228 /*
229 * Check to see if it is 'our' interface as we do not have per
230 * interface hooks and thus get an update for every interface.
231 */
232 if (p && p->pfik_ifp == ifp)
233 pfi_kifaddr_update(p);
234 PF_UNLOCK();
235}
236
237void
238pfi_attach_clone_event(void *arg __unused, struct if_clone *ifc)
239{
240 PF_LOCK();
241 pfi_attach_clone(ifc);
242 PF_UNLOCK();
243}
244
245void
246pfi_attach_ifnet_event(void *arg __unused, struct ifnet *ifp)
247{
248 PF_LOCK();
249 if (ifp->if_dunit != IF_DUNIT_NONE)
250 pfi_attach_ifnet(ifp);
251 PF_UNLOCK();
252}
253
254void
255pfi_detach_ifnet_event(void *arg __unused, struct ifnet *ifp)
256{
257 PF_LOCK();
258 pfi_detach_ifnet(ifp);
259 PF_UNLOCK();
260}
261#endif /* __FreeBSD__ */
262
263void
264pfi_attach_clone(struct if_clone *ifc)
265{
266 pfi_initialize();
267 pfi_newgroup(ifc->ifc_name, PFI_IFLAG_CLONABLE);
268}
269
270void
271pfi_attach_ifnet(struct ifnet *ifp)
272{
273 struct pfi_kif *p, *q, key;
274 int s;
275#ifdef __FreeBSD__
276 int realname;
277#endif
278
279 pfi_initialize();
280 s = splsoftnet();
281 pfi_update++;
282 if (ifp->if_index >= pfi_indexlim) {
283 /*
284 * grow pfi_index2kif, similar to ifindex2ifnet code in if.c
285 */

--- 4 unchanged lines hidden (view full) ---

290 if (pfi_indexlim == 0)
291 pfi_indexlim = 64;
292 while (ifp->if_index >= pfi_indexlim)
293 pfi_indexlim <<= 1;
294
295 m = oldlim * sizeof(struct pfi_kif *);
296 mp = pfi_index2kif;
297 n = pfi_indexlim * sizeof(struct pfi_kif *);
298#ifdef __FreeBSD__
299 np = malloc(n, PFI_MTYPE, M_NOWAIT);
300#else
301 np = malloc(n, PFI_MTYPE, M_DONTWAIT);
302#endif
303 if (np == NULL)
304 panic("pfi_attach_ifnet: "
305 "cannot allocate translation table");
306 bzero(np, n);
307 if (mp != NULL)
308 bcopy(mp, np, m);
309 pfi_index2kif = np;
310 if (mp != NULL)
311 free(mp, PFI_MTYPE);
312 }
313
314 strlcpy(key.pfik_name, ifp->if_xname, sizeof(key.pfik_name));
315 p = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
316#ifdef __FreeBSD__
317 /* some additional trickery for placeholders */
318 if ((p == NULL) || (p->pfik_parent == pfi_dummy)) {
319 /* are we looking at a renamed instance or not? */
320 pfi_copy_group(key.pfik_name, ifp->if_xname,
321 sizeof(key.pfik_name));
322 realname = (strncmp(key.pfik_name, ifp->if_dname,
323 sizeof(key.pfik_name)) == 0);
324 /* add group */
325 /* we can change if_xname, hence use if_dname as group id */
326 pfi_copy_group(key.pfik_name, ifp->if_dname,
327 sizeof(key.pfik_name));
328 q = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
329 if (q == NULL)
330 q = pfi_if_create(key.pfik_name, pfi_self,
331 PFI_IFLAG_GROUP|PFI_IFLAG_DYNAMIC);
332 else if (q->pfik_parent == pfi_dummy) {
333 q->pfik_parent = pfi_self;
334 q->pfik_flags = (PFI_IFLAG_GROUP | PFI_IFLAG_DYNAMIC);
335 }
336 if (q == NULL)
337 panic("pfi_attach_ifnet: "
338 "cannot allocate '%s' group", key.pfik_name);
339
340 /* add/modify interface */
341 if (p == NULL)
342 p = pfi_if_create(ifp->if_xname, q,
343 realname?PFI_IFLAG_INSTANCE:PFI_IFLAG_PLACEHOLDER);
344 else {
345 /* remove from the dummy group */
346 /* XXX: copy stats? We should not have any!!! */
347 pfi_dummy->pfik_delcnt++;
348 TAILQ_REMOVE(&pfi_dummy->pfik_grouphead, p,
349 pfik_instances);
350 /* move to the right group */
351 p->pfik_parent = q;
352 q->pfik_addcnt++;
353 TAILQ_INSERT_TAIL(&q->pfik_grouphead, p,
354 pfik_instances);
355 if (realname) {
356 p->pfik_flags &= ~PFI_IFLAG_PLACEHOLDER;
357 p->pfik_flags |= PFI_IFLAG_INSTANCE;
358 }
359 }
360 if (p == NULL)
361 panic("pfi_attach_ifnet: "
362 "cannot allocate '%s' interface", ifp->if_xname);
363#else
364 if (p == NULL) {
365 /* add group */
366 pfi_copy_group(key.pfik_name, ifp->if_xname,
367 sizeof(key.pfik_name));
368 q = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
369 if (q == NULL)
370 q = pfi_if_create(key.pfik_name, pfi_self, PFI_IFLAG_GROUP);
371 else if (q->pfik_parent == pfi_dummy) {
372 q->pfik_parent = pfi_self;
373 q->pfik_flags = (PFI_IFLAG_GROUP | PFI_IFLAG_DYNAMIC);
374 }
375 if (q == NULL)
376 panic("pfi_attach_ifnet: "
377 "cannot allocate '%s' group", key.pfik_name);
378
379 /* add interface */
380 p = pfi_if_create(ifp->if_xname, q, PFI_IFLAG_INSTANCE);
381 if (p == NULL)
382 panic("pfi_attach_ifnet: "
383 "cannot allocate '%s' interface", ifp->if_xname);
384#endif
385 } else
386 q = p->pfik_parent;
387 p->pfik_ifp = ifp;
388 p->pfik_flags |= PFI_IFLAG_ATTACHED;
389#ifdef __FreeBSD__
390 PF_UNLOCK();
391 p->pfik_ah_cookie = EVENTHANDLER_REGISTER(ifaddr_event,
392 pfi_kifaddr_update_event, p, EVENTHANDLER_PRI_ANY);
393 PF_LOCK();
394#else
395 p->pfik_ah_cookie =
396 hook_establish(ifp->if_addrhooks, 1, pfi_kifaddr_update, p);
397#endif
398 pfi_index2kif[ifp->if_index] = p;
399 pfi_dohooks(p);
400 splx(s);
401}
402
403void
404pfi_detach_ifnet(struct ifnet *ifp)
405{

--- 5 unchanged lines hidden (view full) ---

411 s = splsoftnet();
412 pfi_update++;
413 p = RB_FIND(pfi_ifhead, &pfi_ifs, &key);
414 if (p == NULL) {
415 printf("pfi_detach_ifnet: cannot find %s", ifp->if_xname);
416 splx(s);
417 return;
418 }
419#ifdef __FreeBSD__
420 PF_UNLOCK();
421 EVENTHANDLER_DEREGISTER(ifaddr_event, p->pfik_ah_cookie);
422 PF_LOCK();
423#else
424 hook_disestablish(p->pfik_ifp->if_addrhooks, p->pfik_ah_cookie);
425#endif
426 q = p->pfik_parent;
427 p->pfik_ifp = NULL;
428 p->pfik_flags &= ~PFI_IFLAG_ATTACHED;
429 pfi_index2kif[ifp->if_index] = NULL;
430 pfi_dohooks(p);
431 pfi_maybe_destroy(p);
432 splx(s);
433}

--- 4 unchanged lines hidden (view full) ---

438 struct pfi_kif *p, *q, key;
439 int s;
440
441 s = splsoftnet();
442 p = pfi_lookup_if(name);
443 if (p == NULL) {
444 pfi_copy_group(key.pfik_name, name, sizeof(key.pfik_name));
445 q = pfi_lookup_if(key.pfik_name);
446#ifdef __FreeBSD__
447 if ((q != NULL) && (q->pfik_parent != pfi_dummy))
448 p = pfi_if_create(name, q, PFI_IFLAG_INSTANCE);
449 else {
450 if (pfi_dummy == NULL)
451 panic("no 'notyet' dummy group");
452 p = pfi_if_create(name, pfi_dummy,
453 PFI_IFLAG_PLACEHOLDER);
454 }
455#else
456 if (q != NULL)
457 p = pfi_if_create(name, q, PFI_IFLAG_INSTANCE);
458#endif
459 }
460 splx(s);
461 return (p);
462}
463
464struct pfi_kif *
465pfi_attach_rule(const char *name)
466{

--- 221 unchanged lines hidden (view full) ---

688 if (pfi_buffer_cnt >= pfi_buffer_max) {
689 int new_max = pfi_buffer_max * 2;
690
691 if (new_max > PFI_BUFFER_MAX) {
692 printf("pfi_address_add: address buffer full (%d/%d)\n",
693 pfi_buffer_cnt, PFI_BUFFER_MAX);
694 return;
695 }
696#ifdef __FreeBSD__
697 p = malloc(new_max * sizeof(*pfi_buffer), PFI_MTYPE,
698 M_NOWAIT);
699#else
700 p = malloc(new_max * sizeof(*pfi_buffer), PFI_MTYPE,
701 M_DONTWAIT);
702#endif
703 if (p == NULL) {
704 printf("pfi_address_add: no memory to grow buffer "
705 "(%d/%d)\n", pfi_buffer_cnt, PFI_BUFFER_MAX);
706 return;
707 }
708 memcpy(pfi_buffer, p, pfi_buffer_cnt * sizeof(*pfi_buffer));
709 /* no need to zero buffer */
710 free(pfi_buffer, PFI_MTYPE);

--- 67 unchanged lines hidden (view full) ---

778 return (strncmp(p->pfik_name, q->pfik_name, IFNAMSIZ));
779}
780
781struct pfi_kif *
782pfi_if_create(const char *name, struct pfi_kif *q, int flags)
783{
784 struct pfi_kif *p;
785
786#ifdef __FreeBSD__
787 p = malloc(sizeof(*p), PFI_MTYPE, M_NOWAIT);
788#else
789 p = malloc(sizeof(*p), PFI_MTYPE, M_DONTWAIT);
790#endif
791 if (p == NULL)
792 return (NULL);
793 bzero(p, sizeof(*p));
794#ifdef __FreeBSD__
795 p->pfik_ah_head = malloc(sizeof(*p->pfik_ah_head), PFI_MTYPE,
796 M_NOWAIT);
797#else
798 p->pfik_ah_head = malloc(sizeof(*p->pfik_ah_head), PFI_MTYPE,
799 M_DONTWAIT);
800#endif
801 if (p->pfik_ah_head == NULL) {
802 free(p, PFI_MTYPE);
803 return (NULL);
804 }
805 bzero(p->pfik_ah_head, sizeof(*p->pfik_ah_head));
806 TAILQ_INIT(p->pfik_ah_head);
807 TAILQ_INIT(&p->pfik_grouphead);
808 strlcpy(p->pfik_name, name, sizeof(p->pfik_name));
809 RB_INIT(&p->pfik_lan_ext);
810 RB_INIT(&p->pfik_ext_gwy);
811 p->pfik_flags = flags;
812 p->pfik_parent = q;
813#ifdef __FreeBSD__
814 p->pfik_tzero = time_second;
815#else
816 p->pfik_tzero = time.tv_sec;
817#endif
818
819 RB_INSERT(pfi_ifhead, &pfi_ifs, p);
820 if (q != NULL) {
821 q->pfik_addcnt++;
822 TAILQ_INSERT_TAIL(&q->pfik_grouphead, p, pfik_instances);
823 }
824 pfi_ifcnt++;
825 return (p);
826}
827
828int
829pfi_maybe_destroy(struct pfi_kif *p)
830{
831 int i, j, k, s;
832 struct pfi_kif *q = p->pfik_parent;
833
834 if ((p->pfik_flags & (PFI_IFLAG_ATTACHED | PFI_IFLAG_GROUP)) ||
835 p->pfik_rules > 0 || p->pfik_states > 0)
836#ifdef __FreeBSD__
837 if (!(p->pfik_flags & PFI_IFLAG_PLACEHOLDER))
838#endif
839 return (0);
840
841 s = splsoftnet();
842 if (q != NULL) {
843 for (i = 0; i < 2; i++)
844 for (j = 0; j < 2; j++)
845 for (k = 0; k < 2; k++) {
846 q->pfik_bytes[i][j][k] +=
847 p->pfik_bytes[i][j][k];
848 q->pfik_packets[i][j][k] +=
849 p->pfik_packets[i][j][k];
850#ifdef __FreeBSD__
851 /* clear stats in case we return to the dummy group */
852 p->pfik_bytes[i][j][k] = 0;
853 p->pfik_packets[i][j][k] = 0;
854#endif
855 }
856 q->pfik_delcnt++;
857 TAILQ_REMOVE(&q->pfik_grouphead, p, pfik_instances);
858 }
859#ifdef __FreeBSD__
860 if (p->pfik_rules > 0 || p->pfik_states > 0) {
861 /* move back to the dummy group */
862 p->pfik_parent = pfi_dummy;
863 pfi_dummy->pfik_addcnt++;
864 TAILQ_INSERT_TAIL(&pfi_dummy->pfik_grouphead, p,
865 pfik_instances);
866 return (0);
867 }
868#endif
869 pfi_ifcnt--;
870 RB_REMOVE(pfi_ifhead, &pfi_ifs, p);
871 splx(s);
872
873 free(p->pfik_ah_head, PFI_MTYPE);
874 free(p, PFI_MTYPE);
875 return (1);
876}

--- 7 unchanged lines hidden (view full) ---

884 }
885 if (m > 0)
886 *p++ = '\0';
887}
888
889void
890pfi_dynamic_drivers(void)
891{
892#ifdef __FreeBSD__
893 struct ifnet *ifp;
894
895/*
896 * For FreeBSD basically every interface is "dynamic" as we can unload
897 * modules e.g.
898 */
899
900 IFNET_RLOCK();
901 TAILQ_FOREACH(ifp, &ifnet, if_link) {
902 if (ifp->if_dunit == IF_DUNIT_NONE)
903 continue;
904 pfi_newgroup(ifp->if_dname, PFI_IFLAG_DYNAMIC);
905 }
906 IFNET_RUNLOCK();
907#else
908 char *buses[] = PFI_DYNAMIC_BUSES;
909 int nbuses = sizeof(buses)/sizeof(buses[0]);
910 int enabled[sizeof(buses)/sizeof(buses[0])];
911 struct device *dev;
912 struct cfdata *cf;
913 struct cfdriver *drv;
914 short *p;
915 int i;

--- 19 unchanged lines hidden (view full) ---

935 break;
936 if (i < nbuses) {
937 pfi_newgroup(cf->cf_driver->cd_name,
938 PFI_IFLAG_DYNAMIC);
939 break;
940 }
941 }
942 }
943#endif
944}
945
946void
947pfi_newgroup(const char *name, int flags)
948{
949 struct pfi_kif *p;
950
951 p = pfi_lookup_if(name);

--- 32 unchanged lines hidden (view full) ---

984 splx(s);
985}
986
987int
988pfi_clr_istats(const char *name, int *nzero, int flags)
989{
990 struct pfi_kif *p;
991 int n = 0, s;
992#ifdef __FreeBSD__
993 long tzero = time_second;
994#else
995 long tzero = time.tv_sec;
996#endif
997
998 s = splsoftnet();
999 ACCEPT_FLAGS(PFI_FLAG_GROUP|PFI_FLAG_INSTANCE);
1000 RB_FOREACH(p, pfi_ifhead, &pfi_ifs) {
1001 if (pfi_skip_if(name, p, flags))
1002 continue;
1003 bzero(p->pfik_packets, sizeof(p->pfik_packets));
1004 bzero(p->pfik_bytes, sizeof(p->pfik_bytes));

--- 6 unchanged lines hidden (view full) ---

1011 return (0);
1012}
1013
1014int
1015pfi_get_ifaces(const char *name, struct pfi_if *buf, int *size, int flags)
1016{
1017 struct pfi_kif *p;
1018 int s, n = 0;
1019#ifdef __FreeBSD__
1020 int ec;
1021#endif
1022
1023 ACCEPT_FLAGS(PFI_FLAG_GROUP|PFI_FLAG_INSTANCE);
1024 s = splsoftnet();
1025 RB_FOREACH(p, pfi_ifhead, &pfi_ifs) {
1026 if (pfi_skip_if(name, p, flags))
1027 continue;
1028 if (*size > n++) {
1029 if (!p->pfik_tzero)
1030 p->pfik_tzero = boottime.tv_sec;
1031#ifdef __FreeBSD__
1032 PF_COPYOUT(p, buf++, sizeof(*buf), ec);
1033 if (ec) {
1034#else
1035 if (copyout(p, buf++, sizeof(*buf))) {
1036#endif
1037 splx(s);
1038 return (EFAULT);
1039 }
1040 }
1041 }
1042 splx(s);
1043 *size = n;
1044 return (0);

--- 87 unchanged lines hidden ---