![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dlil.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / net|
Return to dlil.c CVS log | Up to [Apple XNU] / XNU / bsd / net |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1999 Apple Computer, Inc.
24: *
25: * Data Link Inteface Layer
26: * Author: Ted Walker
27: */
28:
29:
30:
31: #include <sys/param.h>
32: #include <sys/systm.h>
33: #include <sys/kernel.h>
34: #include <sys/malloc.h>
35: #include <sys/mbuf.h>
36: #include <sys/socket.h>
37: #include <net/if_dl.h>
38: #include <net/if.h>
39: #include <net/if_var.h>
40: #include <net/dlil.h>
41:
42:
43:
44: #define MAX_DL_TAGS 50
45: #define MAX_DLIL_FILTERS 50
46: #define MAX_FRAME_TYPE_SIZE 4 /* LONGWORDS */
47: #define MAX_LINKADDR 4 /* LONGWORDS */
48: #define M_NKE M_IFADDR
49:
50: #define PFILT(x) ((struct dlil_filterq_entry *) (x))->variants.pr_filter
51: #define IFILT(x) ((struct dlil_filterq_entry *) (x))->variants.if_filter
52:
53: struct dl_tag_str {
54: struct ifnet *ifp;
55: struct if_proto *proto;
56: struct dlil_filterq_head *pr_flt_head;
57: };
58:
59:
60: struct dlil_stats_str {
61: int inject_pr_in1;
62: int inject_pr_in2;
63: int inject_pr_out1;
64: int inject_pr_out2;
65: int inject_if_in1;
66: int inject_if_in2;
67: int inject_if_out1;
68: int inject_if_out2;
69: };
70:
71:
72: struct dlil_filter_id_str {
73: int type;
74: struct dlil_filterq_head *head;
75: struct dlil_filterq_entry *filter_ptr;
76: struct ifnet *ifp;
77: struct if_proto *proto;
78: };
79:
80:
81:
82: struct if_family_str {
83: TAILQ_ENTRY(if_family_str) if_fam_next;
84: u_long if_family;
85: int refcnt;
86: int flags;
87:
88: #define DLIL_SHUTDOWN 1
89:
90: int (*add_if)(struct ifnet *ifp);
91: int (*del_if)(struct ifnet *ifp);
92: int (*add_proto)(struct ddesc_head_str *demux_desc_head,
93: struct if_proto *proto, u_long dl_tag);
94: int (*del_proto)(struct if_proto *proto, u_long dl_tag);
95: int (*shutdown)();
96: };
97:
98:
99:
100: struct dlil_stats_str dlil_stats;
101:
102: static
103: struct dlil_filter_id_str dlil_filters[MAX_DLIL_FILTERS+1];
104:
105: static
106: struct dl_tag_str dl_tag_array[MAX_DL_TAGS+1];
107:
108: static
109: TAILQ_HEAD(, if_family_str) if_family_head;
110:
111: static ifnet_inited = 0;
112:
113: /*
114: * Internal functions.
115: */
116:
117: static
118: struct if_family_str *find_family_module(u_long if_family)
119: {
120: struct if_family_str *mod = NULL;
121:
122: TAILQ_FOREACH(mod, &if_family_head, if_fam_next) {
123: if (mod->if_family == if_family)
124: break;
125: }
126:
127: return mod;
128: }
129:
130:
131: /*
132: * Public functions.
133: */
134:
135: struct ifnet *ifbyfamily(u_long family, short unit)
136: {
137: struct ifnet *ifp;
138:
139: TAILQ_FOREACH(ifp, &ifnet, if_link)
140: if ((family == ifp->if_family) &&
141: (ifp->if_unit == unit))
142: return ifp;
143:
144: return 0;
145: }
146:
147: struct if_proto *dlttoproto(dl_tag)
148: u_long dl_tag;
149: {
150: return dl_tag_array[dl_tag].proto;
151: }
152:
153:
154: u_long ifptodlt(struct ifnet *ifp, u_long proto_family)
155: {
156: struct if_proto *proto;
157: struct dlil_proto_head *tmp = (struct dlil_proto_head *) &ifp->proto_head;
158:
159:
160: TAILQ_FOREACH(proto, tmp, next)
161: if (proto->ifp == ifp)
162: if (proto->protocol_family == proto_family)
163: return proto->dl_tag;
164:
165: return 0;
166: }
167:
168:
169: int dlil_find_dltag(u_long if_family, short unit, u_long proto_family, u_long *dl_tag)
170: {
171: struct ifnet *ifp;
172:
173: ifp = ifbyfamily(if_family, unit);
174: if (!ifp)
175: return ENOENT;
176:
177: *dl_tag = ifptodlt(ifp, proto_family);
178: if (*dl_tag == 0)
179: return EPROTONOSUPPORT;
180: else
181: return 0;
182: }
183:
184:
185: int dlil_get_next_dl_tag(u_long current_tag, struct dl_tag_attr_str *next)
186: {
187: int i;
188:
189: for (i = (current_tag+1); i < MAX_DL_TAGS; i++)
190: if (dl_tag_array[i].ifp) {
191: next->dl_tag = i;
192: next->if_flags = dl_tag_array[i].ifp->if_flags;
193: next->if_unit = dl_tag_array[i].ifp->if_unit;
194: next->protocol_family = dl_tag_array[i].proto->protocol_family;
195: next->if_family = dl_tag_array[i].ifp->if_family;
196: return 0;
197: }
198:
199: /*
200: * If we got here, there are no more entries
201: */
202:
203: return ENOENT;
204: }
205:
206:
207: void
208: dlil_init()
209: {
210: int i;
211:
212: TAILQ_INIT(&if_family_head);
213: for (i=0; i < MAX_DL_TAGS; i++)
214: dl_tag_array[i].ifp = 0;
215:
216: for (i=0; i < MAX_DLIL_FILTERS; i++)
217: dlil_filters[i].type = 0;
218:
219: bzero(&dlil_stats, sizeof(dlil_stats));
220: }
221:
222:
223: u_long get_new_filter_id()
224: {
225: u_long i;
226:
227: for (i=1; i < MAX_DLIL_FILTERS; i++)
228: if (dlil_filters[i].type == 0)
229: return i;
230:
231: return 0;
232: }
233:
234:
235: int dlil_attach_interface_filter(struct ifnet *ifp,
236: struct dlil_if_flt_str *if_filter,
237: u_long *filter_id,
238: int insertion_point)
239: {
240: int s;
241: int retval;
242: struct dlil_filterq_entry *tmp_ptr;
243: struct dlil_filterq_entry *if_filt;
244: struct dlil_filterq_head *fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
245:
246:
247: MALLOC(tmp_ptr, struct dlil_filterq_entry *, sizeof(*tmp_ptr), M_NKE, M_WAITOK);
248: bcopy((caddr_t) if_filter, (caddr_t) &tmp_ptr->variants.if_filter,
249: sizeof(struct dlil_if_flt_str));
250:
251: s = splnet();
252:
253: if (insertion_point != DLIL_LAST_FILTER) {
254: TAILQ_FOREACH(if_filt, fhead, que)
255: if (insertion_point == if_filt->filter_id) {
256: TAILQ_INSERT_BEFORE(if_filt, tmp_ptr, que);
257: break;
258: }
259: }
260: else
261: TAILQ_INSERT_TAIL(fhead, tmp_ptr, que);
262:
263: if (*filter_id = get_new_filter_id()) {
264: dlil_filters[*filter_id].filter_ptr = tmp_ptr;
265: dlil_filters[*filter_id].head = (struct dlil_filterq_head *) &ifp->if_flt_head;
266: dlil_filters[*filter_id].type = DLIL_IF_FILTER;
267: dlil_filters[*filter_id].ifp = ifp;
268: tmp_ptr->filter_id = *filter_id;
269: tmp_ptr->type = DLIL_IF_FILTER;
270: retval = 0;
271: }
272: else {
273: kprintf("dlil_attach_interface_filter - can't alloc filter_id\n");
274: TAILQ_REMOVE(fhead, tmp_ptr, que);
275: FREE(tmp_ptr, M_NKE);
276: retval = EOVERFLOW;
277: }
278:
279: splx(s);
280: return retval;
281: }
282:
283:
284: int dlil_attach_protocol_filter(u_long dl_tag,
285: struct dlil_pr_flt_str *pr_filter,
286: u_long *filter_id,
287: int insertion_point)
288: {
289: struct dlil_filterq_entry *tmp_ptr;
290: struct dlil_filterq_entry *pr_filt;
291: int s;
292: int retval;
293:
294:
295: if (dl_tag > MAX_DL_TAGS)
296: return ERANGE;
297:
298: if (dl_tag_array[dl_tag].ifp == 0)
299: return ENOENT;
300:
301: MALLOC(tmp_ptr, struct dlil_filterq_entry *, sizeof(*tmp_ptr), M_NKE, M_WAITOK);
302: bcopy((caddr_t) pr_filter, (caddr_t) &tmp_ptr->variants.pr_filter,
303: sizeof(struct dlil_pr_flt_str));
304:
305:
306: s = splnet();
307: if (insertion_point != DLIL_LAST_FILTER) {
308: TAILQ_FOREACH(pr_filt, dl_tag_array[dl_tag].pr_flt_head, que)
309: if (insertion_point == pr_filt->filter_id) {
310: TAILQ_INSERT_BEFORE(pr_filt, tmp_ptr, que);
311: break;
312: }
313: }
314: else
315: TAILQ_INSERT_TAIL(dl_tag_array[dl_tag].pr_flt_head, tmp_ptr, que);
316:
317:
318: if (*filter_id = get_new_filter_id()) {
319: dlil_filters[*filter_id].filter_ptr = tmp_ptr;
320: dlil_filters[*filter_id].head = dl_tag_array[dl_tag].pr_flt_head;
321: dlil_filters[*filter_id].type = DLIL_PR_FILTER;
322: dlil_filters[*filter_id].proto = dl_tag_array[dl_tag].proto;
323: dlil_filters[*filter_id].ifp = dl_tag_array[dl_tag].ifp;
324: tmp_ptr->filter_id = *filter_id;
325: tmp_ptr->type = DLIL_PR_FILTER;
326: retval = 0;
327: }
328: else {
329: kprintf("dlil_attach_protocol_filter - can't alloc filter_id\n");
330: TAILQ_REMOVE(dl_tag_array[dl_tag].pr_flt_head, tmp_ptr, que);
331: FREE(tmp_ptr, M_NKE);
332: retval = EOVERFLOW;
333: }
334:
335: splx(s);
336: return retval;
337: }
338:
339:
340: int
341: dlil_detach_filter(u_long filter_id)
342: {
343: struct dlil_filter_id_str *flt;
344: int s;
345:
346: if (filter_id > MAX_DLIL_FILTERS) {
347: kprintf("dlil_detach_filter - Bad filter_id value %d\n", filter_id);
348: return ERANGE;
349: }
350:
351: flt = &dlil_filters[filter_id];
352: if (flt->type == 0) {
353: kprintf("dlil_detach_filter - no such filter_id %d\n", filter_id);
354: return ENOENT;
355: }
356:
357: s = splnet();
358: if (flt->type == DLIL_IF_FILTER) {
359: if (IFILT(flt->filter_ptr).filter_detach)
360: (*IFILT(flt->filter_ptr).filter_detach)(IFILT(flt->filter_ptr).cookie);
361: }
362: else {
363: if (flt->type == DLIL_PR_FILTER) {
364: if (PFILT(flt->filter_ptr).filter_detach)
365: (*PFILT(flt->filter_ptr).filter_detach)(PFILT(flt->filter_ptr).cookie);
366: }
367: }
368:
369: TAILQ_REMOVE(flt->head, flt->filter_ptr, que);
370: FREE(flt->filter_ptr, M_NKE);
371: flt->type = 0;
372: splx(s);
373: return 0;
374: }
375:
376:
377:
378:
379: int
380: dlil_input(struct ifnet *ifp, struct mbuf *m,
381: char *frame_header)
382: {
383: boolean_t funnel_state;
384: int ret;
385:
386: funnel_state = thread_set_funneled(TRUE);
387:
388: ret = dlil_input_funneled(ifp, m, frame_header);
389:
390: (void) thread_set_funneled(funnel_state);
391:
392: return(ret);
393: }
394:
395: int
396: dlil_input_funneled(struct ifnet *ifp, struct mbuf *m,
397: char *frame_header)
398: {
399: struct ifnet *orig_ifp = 0;
400: struct dlil_filterq_entry *tmp;
401: int retval;
402: struct if_proto *ifproto = 0;
403: struct if_proto *proto;
404: struct dlil_filterq_head *fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
405:
406: /*
407: * Temporary, until all drivers do this.
408: */
409:
410: ifp->if_ibytes += m->m_pkthdr.len;
411:
412:
413: /*
414: * Run interface filters
415: */
416:
417: while (orig_ifp != ifp) {
418: orig_ifp = ifp;
419:
420: TAILQ_FOREACH_REVERSE(tmp, fhead, que, dlil_filterq_head) {
421: if (IFILT(tmp).filter_if_input) {
422: retval = (*IFILT(tmp).filter_if_input)(IFILT(tmp).cookie,
423: &ifp,
424: &m,
425: &frame_header);
426: if (retval) {
427: if (retval == EJUSTRETURN)
428: return 0;
429: else {
430: m_freem(m);
431: return retval;
432: }
433: }
434: }
435:
436: if (ifp != orig_ifp)
437: break;
438: }
439: }
440:
441: ifp->if_lastchange = time;
442:
443: /*
444: * Call family demux module. If the demux module finds a match
445: * for the frame it will fill-in the ifproto pointer.
446: */
447:
448: retval = (*ifp->if_demux)(ifp, m, frame_header, &ifproto );
449:
450: if (m->m_flags & (M_BCAST|M_MCAST))
451: ifp->if_imcasts++;
452:
453: if ((retval) && (ifp->offercnt)) {
454: /*
455: * No match was found, look for any offers.
456: */
457: struct dlil_proto_head *tmp = (struct dlil_proto_head *) &ifp->proto_head;
458: TAILQ_FOREACH(proto, tmp, next) {
459: if ((proto->dl_offer) && (proto->dl_offer(m, frame_header) == 0)) {
460: ifproto = proto;
461: retval = 0;
462: break;
463: }
464: }
465: }
466:
467: if (retval) {
468: if (retval != EJUSTRETURN) {
469: m_freem(m);
470: return retval;
471: }
472: else
473: return 0;
474: }
475: else
476: if (ifproto == 0) {
477: printf("ERROR - dlil_input - if_demux didn't return an if_proto pointer\n");
478: m_freem(m);
479: return 0;
480: }
481:
482: /*
483: * Call any attached protocol filters.
484: */
485:
486: TAILQ_FOREACH_REVERSE(tmp, &ifproto->pr_flt_head, que, dlil_filterq_head) {
487: if (PFILT(tmp).filter_dl_input) {
488: retval = (*PFILT(tmp).filter_dl_input)(PFILT(tmp).cookie,
489: &m,
490: &frame_header,
491: &ifp);
492:
493: if (retval) {
494: if (retval == EJUSTRETURN)
495: return 0;
496: else {
497: m_freem(m);
498: return retval;
499: }
500: }
501: }
502: }
503:
504:
505:
506: retval = (*ifproto->dl_input)(m, frame_header,
507: ifp, ifproto->dl_tag,
508: (ifp->if_eflags & IFEF_DVR_REENTRY_OK));
509:
510: if (retval == EJUSTRETURN)
511: retval = 0;
512: else
513: if (retval)
514: m_freem(m);
515:
516: return retval;
517: }
518:
519:
520:
521: void ether_input(ifp, eh, m)
522: struct ifnet *ifp;
523: struct ether_header *eh;
524: struct mbuf *m;
525:
526: {
527: kprintf("Someone is calling ether_input!!\n");
528:
529: dlil_input(ifp, m, (char *) eh);
530: }
531:
532:
533: int
534: dlil_event(struct ifnet *ifp, struct event_msg *event)
535: {
536: return 0;
537: }
538:
539:
540:
541: int
542: dlil_output(u_long dl_tag,
543: struct mbuf *m,
544: caddr_t route,
545: struct sockaddr *dest,
546: int raw
547: )
548: {
549: char *frame_type;
550: char *dst_linkaddr;
551: struct ifnet *orig_ifp = 0;
552: struct ifnet *ifp;
553: struct if_proto *proto;
554: struct dlil_filterq_entry *tmp;
555: int retval = 0;
556: char frame_type_buffer[MAX_FRAME_TYPE_SIZE * 4];
557: char dst_linkaddr_buffer[MAX_LINKADDR * 4];
558: struct dlil_filterq_head *fhead;
559:
560:
561:
562:
563: /*
564: * Temporary hackery until all the existing protocols can become fully
565: * "dl_tag aware". Some things only have the ifp, so this handles that
566: * case for the time being.
567: */
568:
569: if (dl_tag > MAX_DL_TAGS) {
570: /* dl_tag is really an ifnet pointer! */
571:
572: ifp = (struct ifnet *) dl_tag;
573: dl_tag = ifp->if_data.default_proto;
574: if (dl_tag)
575: proto = dl_tag_array[dl_tag].proto;
576: }
577: else {
578: if ((dl_tag == 0) || (dl_tag_array[dl_tag].ifp == 0))
579: retval = ENOENT;
580: else {
581: ifp = dl_tag_array[dl_tag].ifp;
582: proto = dl_tag_array[dl_tag].proto;
583: }
584: }
585:
586: if (retval) {
587: m_freem(m);
588: return retval;
589: }
590:
591: frame_type = frame_type_buffer;
592: dst_linkaddr = dst_linkaddr_buffer;
593:
594: fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
595:
596: if ((raw == 0) && (proto->dl_pre_output)) {
597: retval = (*proto->dl_pre_output)(ifp, &m, dest, route,
598: frame_type, dst_linkaddr, dl_tag);
599: if (retval) {
600: if (retval == EJUSTRETURN)
601: return 0;
602: else {
603: m_freem(m);
604: return retval;
605: }
606: }
607: }
608:
609: /*
610: * Run any attached protocol filters.
611: */
612:
613: if (TAILQ_EMPTY(dl_tag_array[dl_tag].pr_flt_head) == 0) {
614: TAILQ_FOREACH(tmp, dl_tag_array[dl_tag].pr_flt_head, que) {
615: if (PFILT(tmp).filter_dl_output) {
616: retval = (*PFILT(tmp).filter_dl_output)(PFILT(tmp).cookie,
617: &m, &ifp, &dest, dst_linkaddr, frame_type);
618: if (retval) {
619: if (retval == EJUSTRETURN)
620: return 0;
621: else {
622: m_freem(m);
623: return retval;
624: }
625: }
626: }
627: }
628: }
629:
630:
631: /*
632: * Call framing module
633: */
634: if ((raw == 0) && (ifp->if_framer)) {
635: retval = (*ifp->if_framer)(ifp, &m, dest, dst_linkaddr, frame_type);
636: if (retval) {
637: if (retval == EJUSTRETURN)
638: return 0;
639: else
640: {
641: m_freem(m);
642: return retval;
643: }
644: }
645: }
646:
647: #if BRIDGE
648: if (do_bridge) {
649: struct mbuf *m0 = m ;
650:
651: if (m->m_pkthdr.rcvif)
652: m->m_pkthdr.rcvif = NULL ;
653: ifp = bridge_dst_lookup(m);
654: bdg_forward(&m0, ifp);
655: if (m0)
656: m_freem(m0);
657:
658: return 0;
659: }
660: #endif
661:
662:
663: /*
664: * Let interface filters (if any) do their thing ...
665: */
666:
667: fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
668: if (TAILQ_EMPTY(fhead) == 0) {
669: while (orig_ifp != ifp) {
670: orig_ifp = ifp;
671: TAILQ_FOREACH(tmp, fhead, que) {
672: if (IFILT(tmp).filter_if_output) {
673: retval = (*IFILT(tmp).filter_if_output)(IFILT(tmp).cookie,
674: &ifp,
675: &m);
676: if (retval) {
677: if (retval == EJUSTRETURN)
678: return 0;
679: else {
680: m_freem(m);
681: return retval;
682: }
683: }
684:
685: }
686:
687: if (ifp != orig_ifp)
688: break;
689: }
690: }
691: }
692:
693: /*
694: * Finally, call the driver.
695: */
696: if (m->m_hdr.mh_type == 0) {
697: printf("ERROR - dlil_output - sending free mbuf\n");
698: m_freem(m);
699: return 0;
700: }
701: /*
702: * Temporary, until all drivers do this.
703: */
704:
705: ifp->if_obytes += m->m_pkthdr.len;
706:
707: retval = (*ifp->if_output)(ifp, m);
708: if ((retval == 0) || (retval == EJUSTRETURN))
709: return 0;
710: else
711: return retval;
712: }
713:
714:
715: int
716: dlil_ioctl(u_long dl_tag,
717: struct ifnet *ifp,
718: u_long ioctl_code,
719: caddr_t ioctl_arg)
720: {
721: struct dlil_filterq_entry *tmp;
722: struct dlil_filterq_head *fhead;
723: int retval;
724:
725:
726: if (dl_tag) {
727: if (dl_tag > MAX_DL_TAGS)
728: return ERANGE;
729:
730: if (dl_tag_array[dl_tag].ifp == 0)
731: return ENOENT;
732:
733:
734: /*
735: * Run any attached protocol filters.
736: */
737: TAILQ_FOREACH(tmp, dl_tag_array[dl_tag].pr_flt_head, que) {
738: if (PFILT(tmp).filter_dl_ioctl) {
739: retval =
740: (*PFILT(tmp).filter_dl_ioctl)(PFILT(tmp).cookie,
741: dl_tag_array[dl_tag].ifp,
742: ioctl_code,
743: ioctl_arg);
744:
745: if (retval) {
746: return 0;
747: }
748: }
749: }
750:
751: if (dl_tag_array[dl_tag].proto->dl_ioctl)
752: retval = (*dl_tag_array[dl_tag].proto->dl_ioctl)(dl_tag,
753: dl_tag_array[dl_tag].ifp,
754: ioctl_code,
755: ioctl_arg);
756:
757: else
758: retval = EINVAL;
759: }
760: else {
761: if (ifp) {
762: fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
763: TAILQ_FOREACH(tmp, fhead, que) {
764: if (IFILT(tmp).filter_if_ioctl) {
765: retval = (*IFILT(tmp).filter_if_ioctl)(IFILT(tmp).cookie, ifp,
766: ioctl_code, ioctl_arg);
767: if (retval) {
768: return 0;
769: }
770: }
771: }
772: if (ifp->if_ioctl)
773: retval = (*ifp->if_ioctl)(ifp, ioctl_code, ioctl_arg);
774: else
775: return 0;
776: }
777: else
778: retval = EINVAL;
779: }
780:
781: return retval;
782: }
783:
784:
785: int
786: dlil_attach_protocol(struct dlil_proto_reg_str *proto,
787: u_long *dl_tag)
788: {
789: struct ifnet *ifp;
790: struct if_proto *ifproto;
791: u_long i;
792: struct if_family_str *if_family;
793: int error;
794: struct dlil_proto_head *tmp;
795: int s;
796:
797:
798: if ((proto->protocol_family == 0) || (proto->interface_family == 0))
799: return EINVAL;
800:
801: s = splnet();
802: if_family = find_family_module(proto->interface_family);
803: if ((!if_family) || (if_family->flags & DLIL_SHUTDOWN)) {
804: kprintf("dlil_attach_protocol -- no interface family module %d",
805: proto->interface_family);
806: splx(s);
807: return ENOENT;
808: }
809:
810: ifp = ifbyfamily(proto->interface_family, proto->unit_number);
811: if (!ifp) {
812: kprintf("dlil_attach_protocol -- no such interface %d unit %d\n",
813: proto->interface_family, proto->unit_number);
814: splx(s);
815: return ENOENT;
816: }
817:
818: if (dlil_find_dltag(proto->interface_family, proto->unit_number,
819: proto->protocol_family, &i) == 0)
820: return EEXIST;
821:
822: for (i=1; i < MAX_DL_TAGS; i++)
823: if (dl_tag_array[i].ifp == 0)
824: break;
825:
826: if (i >= MAX_DL_TAGS) {
827: splx(s);
828: return EOVERFLOW;
829: }
830:
831: /*
832: * Allocate and init a new if_proto structure
833: */
834:
835: ifproto = _MALLOC(sizeof(struct if_proto), M_IFADDR, M_NOWAIT);
836: if (!ifproto) {
837: printf("ERROR - DLIL failed if_proto allocation\n");
838: return ENOMEM;
839: }
840:
841: bzero(ifproto, sizeof(struct if_proto));
842:
843: dl_tag_array[i].ifp = ifp;
844: dl_tag_array[i].proto = ifproto;
845: dl_tag_array[i].pr_flt_head = &ifproto->pr_flt_head;
846: ifproto->dl_tag = i;
847: *dl_tag = i;
848:
849: if (proto->default_proto) {
850: if (ifp->if_data.default_proto == 0)
851: ifp->if_data.default_proto = i;
852: else
853: printf("ERROR - dlil_attach_protocol -- Attempt to attach more than one default protocol\n");
854: }
855:
856: ifproto->protocol_family = proto->protocol_family;
857: ifproto->dl_input = proto->input;
858: ifproto->dl_pre_output = proto->pre_output;
859: ifproto->dl_event = proto->event;
860: ifproto->dl_offer = proto->offer;
861: ifproto->dl_ioctl = proto->ioctl;
862: ifproto->ifp = ifp;
863: TAILQ_INIT(&ifproto->pr_flt_head);
864:
865: /*
866: * Call family module add_proto routine so it can refine the
867: * demux descriptors as it wishes.
868: */
869: error = (*if_family->add_proto)(&proto->demux_desc_head, ifproto, *dl_tag);
870: if (error) {
871: dl_tag_array[*dl_tag].ifp = 0;
872: FREE(ifproto, M_IFADDR);
873: splx(s);
874: return error;
875: }
876:
877:
878: /*
879: * Add to if_proto list for this interface
880: */
881:
882: tmp = (struct dlil_proto_head *) &ifp->proto_head;
883: TAILQ_INSERT_TAIL(tmp, ifproto, next);
884: ifp->refcnt++;
885: if (ifproto->dl_offer)
886: ifp->offercnt++;
887:
888: splx(s);
889: return 0;
890: }
891:
892:
893:
894: int
895: dlil_detach_protocol(u_long dl_tag)
896: {
897: struct ifnet *ifp;
898: struct ifnet *orig_ifp=0;
899: struct if_proto *proto;
900: struct dlil_proto_head *tmp;
901: struct if_family_str *if_family;
902: struct dlil_filterq_entry *filter;
903: int s, retval;
904: struct dlil_filterq_head *fhead;
905:
906:
907:
908: if (dl_tag > MAX_DL_TAGS)
909: return ERANGE;
910:
911: s = splnet();
912: if (dl_tag_array[dl_tag].ifp == 0) {
913: splx(s);
914: return ENOENT;
915: }
916:
917: ifp = dl_tag_array[dl_tag].ifp;
918: proto = dl_tag_array[dl_tag].proto;
919:
920: if_family = find_family_module(ifp->if_family);
921: if (if_family == NULL)
922: return ENOENT;
923:
924: tmp = (struct dlil_proto_head *) &ifp->proto_head;
925:
926: /*
927: * Call family module del_proto
928: */
929:
930: (*if_family->del_proto)(proto, dl_tag);
931:
932:
933: /*
934: * Remove and deallocate any attached protocol filters
935: */
936:
937: while (filter = TAILQ_FIRST(&proto->pr_flt_head))
938: dlil_detach_filter(filter->filter_id);
939:
940: if (proto->dl_offer)
941: ifp->offercnt--;
942:
943: dl_tag_array[dl_tag].ifp = 0;
944:
945: TAILQ_REMOVE(tmp, proto, next);
946: FREE(proto, M_IFADDR);
947:
948: if (--ifp->refcnt == 0) {
949: if (ifp->if_flags & IFF_UP)
950: printf("WARNING - dlil_detach_protocol - ifp refcnt 0, but IF still up\n");
951:
952: TAILQ_REMOVE(&ifnet, ifp, if_link);
953:
954: if (if_family->del_if)
955: (*if_family->del_if)(ifp);
956:
957:
958: fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
959: while (orig_ifp != ifp) {
960: orig_ifp = ifp;
961:
962: TAILQ_FOREACH(filter, fhead, que) {
963: if (IFILT(filter).filter_if_free) {
964: retval = (*IFILT(filter).filter_if_free)(IFILT(filter).cookie, ifp);
965: if (retval) {
966: splx(s);
967: return 0;
968: }
969: }
970: if (ifp != orig_ifp)
971: break;
972: }
973: }
974:
975: (*ifp->if_free)(ifp);
976: }
977:
978: splx(s);
979: return 0;
980: }
981:
982:
983:
984:
985:
986: int
987: dlil_if_attach(struct ifnet *ifp)
988: {
989: u_long interface_family = ifp->if_family;
990: struct if_family_str *if_family;
991: struct dlil_proto_head *tmp;
992: int stat;
993: int s;
994:
995:
996:
997: s = splnet();
998: if (ifnet_inited == 0) {
999: TAILQ_INIT(&ifnet);
1000: ifnet_inited = 1;
1001: }
1002:
1003: if_family = find_family_module(interface_family);
1004:
1005: if ((!if_family) || (if_family->flags & DLIL_SHUTDOWN)) {
1006: splx(s);
1007: kprintf("Attempt to attach interface without family module - %d\n",
1008: interface_family);
1009: return ENODEV;
1010: }
1011:
1012:
1013: /*
1014: * Call the family module to fill in the appropriate fields in the
1015: * ifnet structure.
1016: */
1017:
1018: stat = (*if_family->add_if)(ifp);
1019: if (stat) {
1020: splx(s);
1021: kprintf("dlil_if_attach -- add_if failed with %d\n", stat);
1022: return stat;
1023: }
1024:
1025: /*
1026: * Add the ifp to the interface list.
1027: */
1028:
1029: tmp = (struct dlil_proto_head *) &ifp->proto_head;
1030: TAILQ_INIT(tmp);
1031:
1032: ifp->if_data.default_proto = 0;
1033: ifp->refcnt = 1;
1034: ifp->offercnt = 0;
1035: TAILQ_INIT(&ifp->if_flt_head);
1036: old_if_attach(ifp);
1037: if_family->refcnt++;
1038:
1039: splx(s);
1040: return 0;
1041: }
1042:
1043:
1044: int
1045: dlil_if_detach(struct ifnet *ifp)
1046: {
1047: struct if_proto *proto;
1048: struct dlil_filterq_entry *if_filter;
1049: struct if_family_str *if_family;
1050: struct dlil_filterq_head *fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
1051: int s;
1052:
1053: s = splnet();
1054: if (ifp->if_flags & IFF_UP)
1055: printf("WARNING - dlil_if_detach called for UP interface\n");
1056:
1057: if_family = (struct if_family_str *) ifp->if_family;
1058:
1059: if (!if_family) {
1060: kprintf("Attempt to detach interface without family module - %s\n",
1061: ifp->if_name);
1062: splx(s);
1063: return ENODEV;
1064: }
1065:
1066: while (if_filter = TAILQ_FIRST(fhead))
1067: dlil_detach_filter(if_filter->filter_id);
1068:
1069: if (--ifp->refcnt == 0) {
1070: TAILQ_REMOVE(&ifnet, ifp, if_link);
1071:
1072: if (if_family->del_if)
1073: (*if_family->del_if)(ifp);
1074:
1075: if (--if_family->refcnt == 0) {
1076: if (if_family->shutdown)
1077: (*if_family->shutdown)();
1078:
1079: TAILQ_REMOVE(&if_family_head, if_family, if_fam_next);
1080: FREE(if_family, M_IFADDR);
1081: }
1082: splx(s);
1083: return 0;
1084: }
1085: else
1086: {
1087: splx(s);
1088: return DLIL_WAIT_FOR_FREE;
1089: }
1090: }
1091:
1092:
1093: int
1094: dlil_reg_if_modules(u_long interface_family,
1095: int (*add_if)(struct ifnet *ifp),
1096: int (*del_if)(struct ifnet *ifp),
1097: int (*add_proto)(struct ddesc_head_str *head,
1098: struct if_proto *proto, u_long dl_tag),
1099: int (*del_proto)(struct if_proto *proto, u_long dl_tag),
1100: int (*shutdown)())
1101: {
1102: struct if_family_str *if_family;
1103: int s;
1104:
1105:
1106: s = splnet();
1107: if (find_family_module(interface_family)) {
1108: kprintf("Attempt to register dlil family module more than once - %d\n",
1109: interface_family);
1110: splx(s);
1111: return EEXIST;
1112: }
1113:
1114: if ((!add_if) || (!del_if) ||
1115: (!add_proto) || (!del_proto)) {
1116: kprintf("dlil_reg_if_modules passed at least one null pointer\n");
1117: splx(s);
1118: return EINVAL;
1119: }
1120:
1121: if_family = (struct if_family_str *) _MALLOC(sizeof(struct if_family_str), M_IFADDR, M_NOWAIT);
1122: if (!if_family) {
1123: kprintf("dlil_reg_if_modules failed allocation\n");
1124: splx(s);
1125: return ENOMEM;
1126: }
1127:
1128: bzero(if_family, sizeof(struct if_family_str));
1129:
1130: if_family->if_family = interface_family;
1131: if_family->shutdown = shutdown;
1132: if_family->add_if = add_if;
1133: if_family->del_if = del_if;
1134: if_family->add_proto = add_proto;
1135: if_family->del_proto = del_proto;
1136: if_family->refcnt = 1;
1137: if_family->flags = 0;
1138:
1139: TAILQ_INSERT_TAIL(&if_family_head, if_family, if_fam_next);
1140: splx(s);
1141: return 0;
1142: }
1143:
1144: int dlil_dereg_if_modules(u_long interface_family)
1145: {
1146: struct if_family_str *if_family;
1147: int s;
1148:
1149:
1150: s = splnet();
1151: if_family = find_family_module(interface_family);
1152: if (if_family == 0) {
1153: splx(s);
1154: return ENOENT;
1155: }
1156:
1157: if (--if_family->refcnt) {
1158: if (if_family->shutdown)
1159: (*if_family->shutdown)();
1160:
1161: TAILQ_REMOVE(&if_family_head, if_family, if_fam_next);
1162: FREE(if_family, M_IFADDR);
1163: }
1164: else
1165: if_family->flags |= DLIL_SHUTDOWN;
1166:
1167: splx(s);
1168: return 0;
1169: }
1170:
1171:
1172:
1173:
1174:
1175: /*
1176: * Old if_attach no-op'ed function defined here for temporary backwards compatibility
1177: */
1178:
1179: void if_attach(ifp)
1180: struct ifnet *ifp;
1181: {
1182: dlil_if_attach(ifp);
1183: }
1184:
1185:
1186:
1187: int
1188: dlil_inject_if_input(struct mbuf *m, char *frame_header, u_long from_id)
1189: {
1190: struct ifnet *orig_ifp = 0;
1191: struct ifnet *ifp;
1192: struct if_proto *ifproto;
1193: struct if_proto *proto;
1194: struct dlil_filterq_entry *tmp;
1195: int retval = 0;
1196: struct dlil_filterq_head *fhead;
1197: int match_found;
1198:
1199:
1200: dlil_stats.inject_if_in1++;
1201: if (from_id > MAX_DLIL_FILTERS)
1202: return ERANGE;
1203:
1204: if (dlil_filters[from_id].type != DLIL_IF_FILTER)
1205: return ENOENT;
1206:
1207: ifp = dlil_filters[from_id].ifp;
1208:
1209: /*
1210: * Let interface filters (if any) do their thing ...
1211: */
1212:
1213: fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
1214: if (from_id == DLIL_NULL_FILTER)
1215: match_found = 1;
1216: else
1217: match_found = 0;
1218:
1219: if (TAILQ_EMPTY(fhead) == 0) {
1220: while (orig_ifp != ifp) {
1221: orig_ifp = ifp;
1222: TAILQ_FOREACH_REVERSE(tmp, fhead, que, dlil_filterq_head) {
1223: if ((match_found) && (IFILT(tmp).filter_if_input)) {
1224: retval = (*IFILT(tmp).filter_if_input)(IFILT(tmp).cookie,
1225: &ifp,
1226: &m,
1227: &frame_header);
1228: if (retval) {
1229: if (retval == EJUSTRETURN)
1230: return 0;
1231: else {
1232: m_freem(m);
1233: return retval;
1234: }
1235: }
1236:
1237: }
1238:
1239: if (ifp != orig_ifp)
1240: break;
1241:
1242: if (from_id == tmp->filter_id)
1243: match_found = 1;
1244: }
1245: }
1246: }
1247:
1248: ifp->if_lastchange = time;
1249:
1250: /*
1251: * Call family demux module. If the demux module finds a match
1252: * for the frame it will fill-in the ifproto pointer.
1253: */
1254:
1255: retval = (*ifp->if_demux)(ifp, m, frame_header, &ifproto );
1256:
1257: if (m->m_flags & (M_BCAST|M_MCAST))
1258: ifp->if_imcasts++;
1259:
1260: if ((retval) && (ifp->offercnt)) {
1261: /*
1262: * No match was found, look for any offers.
1263: */
1264: struct dlil_proto_head *tmp = (struct dlil_proto_head *) &ifp->proto_head;
1265: TAILQ_FOREACH(proto, tmp, next) {
1266: if ((proto->dl_offer) && (proto->dl_offer(m, frame_header) == 0)) {
1267: ifproto = proto;
1268: retval = 0;
1269: break;
1270: }
1271: }
1272: }
1273:
1274: if (retval) {
1275: if (retval != EJUSTRETURN) {
1276: m_freem(m);
1277: return retval;
1278: }
1279: else
1280: return 0;
1281: }
1282: else
1283: if (ifproto == 0) {
1284: printf("ERROR - dlil_inject_if_input -- if_demux didn't return an if_proto pointer\n");
1285: m_freem(m);
1286: return 0;
1287: }
1288:
1289: /*
1290: * Call any attached protocol filters.
1291: */
1292: TAILQ_FOREACH_REVERSE(tmp, &ifproto->pr_flt_head, que, dlil_filterq_head) {
1293: if (PFILT(tmp).filter_dl_input) {
1294: retval = (*PFILT(tmp).filter_dl_input)(PFILT(tmp).cookie,
1295: &m,
1296: &frame_header,
1297: &ifp);
1298:
1299: if (retval) {
1300: if (retval == EJUSTRETURN)
1301: return 0;
1302: else {
1303: m_freem(m);
1304: return retval;
1305: }
1306: }
1307: }
1308: }
1309:
1310:
1311:
1312: retval = (*ifproto->dl_input)(m, frame_header,
1313: ifp, ifproto->dl_tag,
1314: (ifp->if_eflags & IFEF_DVR_REENTRY_OK));
1315:
1316: dlil_stats.inject_if_in2++;
1317: if (retval == EJUSTRETURN)
1318: retval = 0;
1319: else
1320: if (retval)
1321: m_freem(m);
1322:
1323: return retval;
1324:
1325: }
1326:
1327:
1328:
1329:
1330:
1331: int
1332: dlil_inject_pr_input(struct mbuf *m, char *frame_header, u_long from_id)
1333: {
1334: struct ifnet *orig_ifp = 0;
1335: struct dlil_filterq_entry *tmp;
1336: int retval;
1337: struct if_proto *ifproto = 0;
1338: int match_found;
1339: struct ifnet *ifp;
1340:
1341:
1342: dlil_stats.inject_pr_in1++;
1343: if (from_id > MAX_DLIL_FILTERS)
1344: return ERANGE;
1345:
1346: if (dlil_filters[from_id].type != DLIL_PR_FILTER)
1347: return ENOENT;
1348:
1349: ifproto = dlil_filters[from_id].proto;
1350: ifp = dlil_filters[from_id].ifp;
1351:
1352:
1353: /*
1354: * Call any attached protocol filters.
1355: */
1356:
1357: if (from_id == DLIL_NULL_FILTER)
1358: match_found = 1;
1359: else
1360: match_found = 0;
1361: TAILQ_FOREACH_REVERSE(tmp, &ifproto->pr_flt_head, que, dlil_filterq_head) {
1362: if ((match_found) && (PFILT(tmp).filter_dl_input)) {
1363: retval = (*PFILT(tmp).filter_dl_input)(PFILT(tmp).cookie,
1364: &m,
1365: &frame_header,
1366: &ifp);
1367:
1368: if (retval) {
1369: if (retval == EJUSTRETURN)
1370: return 0;
1371: else {
1372: m_freem(m);
1373: return retval;
1374: }
1375: }
1376: }
1377:
1378: if (tmp->filter_id == from_id)
1379: match_found = 1;
1380: }
1381:
1382:
1383: retval = (*ifproto->dl_input)(m, frame_header,
1384: ifp, ifproto->dl_tag,
1385: (ifp->if_eflags & IFEF_DVR_REENTRY_OK));
1386:
1387: if (retval == EJUSTRETURN)
1388: retval = 0;
1389: else
1390: if (retval)
1391: m_freem(m);
1392:
1393: dlil_stats.inject_pr_in2++;
1394: return retval;
1395: }
1396:
1397:
1398:
1399: int
1400: dlil_inject_pr_output(struct mbuf *m,
1401: struct sockaddr *dest,
1402: int raw,
1403: char *frame_type,
1404: char *dst_linkaddr,
1405: u_long from_id)
1406: {
1407: struct ifnet *orig_ifp = 0;
1408: struct ifnet *ifp;
1409: struct dlil_filterq_entry *tmp;
1410: int retval = 0;
1411: char frame_type_buffer[MAX_FRAME_TYPE_SIZE * 4];
1412: char dst_linkaddr_buffer[MAX_LINKADDR * 4];
1413: struct dlil_filterq_head *fhead;
1414: int match_found;
1415: u_long dl_tag;
1416:
1417:
1418: dlil_stats.inject_pr_out1++;
1419: if (raw == 0) {
1420: if (frame_type)
1421: bcopy(frame_type, &frame_type_buffer[0], MAX_FRAME_TYPE_SIZE * 4);
1422: else
1423: return EINVAL;
1424:
1425: if (dst_linkaddr)
1426: bcopy(dst_linkaddr, &dst_linkaddr_buffer, MAX_LINKADDR * 4);
1427: else
1428: return EINVAL;
1429: }
1430:
1431: if (from_id > MAX_DLIL_FILTERS)
1432: return ERANGE;
1433:
1434: if (dlil_filters[from_id].type != DLIL_PR_FILTER)
1435: return ENOENT;
1436:
1437: ifp = dlil_filters[from_id].ifp;
1438: dl_tag = dlil_filters[from_id].proto->dl_tag;
1439:
1440:
1441: frame_type = frame_type_buffer;
1442: dst_linkaddr = dst_linkaddr_buffer;
1443:
1444: fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
1445:
1446: /*
1447: * Run any attached protocol filters.
1448: */
1449: if (from_id == DLIL_NULL_FILTER)
1450: match_found = 1;
1451: else
1452: match_found = 0;
1453:
1454: if (TAILQ_EMPTY(dl_tag_array[dl_tag].pr_flt_head) == 0) {
1455: TAILQ_FOREACH(tmp, dl_tag_array[dl_tag].pr_flt_head, que) {
1456: if ((match_found) && (PFILT(tmp).filter_dl_output)) {
1457: retval = (*PFILT(tmp).filter_dl_output)(PFILT(tmp).cookie,
1458: &m, &ifp, &dest, dst_linkaddr, frame_type);
1459: if (retval) {
1460: if (retval == EJUSTRETURN)
1461: return 0;
1462: else {
1463: m_freem(m);
1464: return retval;
1465: }
1466: }
1467: }
1468:
1469: if (tmp->filter_id == from_id)
1470: match_found = 1;
1471: }
1472: }
1473:
1474:
1475: /*
1476: * Call framing module
1477: */
1478: if ((raw == 0) && (ifp->if_framer)) {
1479: retval = (*ifp->if_framer)(ifp, &m, dest, dst_linkaddr, frame_type);
1480: if (retval) {
1481: if (retval == EJUSTRETURN)
1482: return 0;
1483: else
1484: {
1485: m_freem(m);
1486: return retval;
1487: }
1488: }
1489: }
1490:
1491:
1492: #if BRIDGE
1493: if (do_bridge) {
1494: struct mbuf *m0 = m ;
1495:
1496: if (m->m_pkthdr.rcvif)
1497: m->m_pkthdr.rcvif = NULL ;
1498: ifp = bridge_dst_lookup(m);
1499: bdg_forward(&m0, ifp);
1500: if (m0)
1501: m_freem(m0);
1502:
1503: return 0;
1504: }
1505: #endif
1506:
1507:
1508: /*
1509: * Let interface filters (if any) do their thing ...
1510: */
1511:
1512: fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
1513: if (TAILQ_EMPTY(fhead) == 0) {
1514: while (orig_ifp != ifp) {
1515: orig_ifp = ifp;
1516: TAILQ_FOREACH(tmp, fhead, que) {
1517: if (IFILT(tmp).filter_if_output) {
1518: retval = (*IFILT(tmp).filter_if_output)(IFILT(tmp).cookie,
1519: &ifp,
1520: &m);
1521: if (retval) {
1522: if (retval == EJUSTRETURN)
1523: return 0;
1524: else {
1525: m_freem(m);
1526: return retval;
1527: }
1528: }
1529:
1530: }
1531:
1532: if (ifp != orig_ifp)
1533: break;
1534: }
1535: }
1536: }
1537:
1538: /*
1539: * Finally, call the driver.
1540: */
1541: /*
1542: * Temporary, until all drivers do this.
1543: */
1544:
1545: ifp->if_obytes += m->m_pkthdr.len;
1546:
1547: retval = (*ifp->if_output)(ifp, m);
1548: dlil_stats.inject_pr_out2++;
1549: if ((retval == 0) || (retval == EJUSTRETURN))
1550: return 0;
1551: else
1552: return retval;
1553: }
1554:
1555:
1556: int
1557: dlil_inject_if_output(struct mbuf *m, u_long from_id)
1558: {
1559: struct ifnet *orig_ifp = 0;
1560: struct ifnet *ifp;
1561: struct dlil_filterq_entry *tmp;
1562: int retval = 0;
1563: struct dlil_filterq_head *fhead;
1564: int match_found;
1565:
1566:
1567: dlil_stats.inject_if_out1++;
1568: if (from_id > MAX_DLIL_FILTERS)
1569: return ERANGE;
1570:
1571: if (dlil_filters[from_id].type != DLIL_IF_FILTER)
1572: return ENOENT;
1573:
1574: ifp = dlil_filters[from_id].ifp;
1575:
1576: /*
1577: * Let interface filters (if any) do their thing ...
1578: */
1579:
1580: fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
1581:
1582: if (from_id == DLIL_NULL_FILTER)
1583: match_found = 1;
1584: else
1585: match_found = 0;
1586:
1587: if (TAILQ_EMPTY(fhead) == 0) {
1588: while (orig_ifp != ifp) {
1589: orig_ifp = ifp;
1590: TAILQ_FOREACH(tmp, fhead, que) {
1591: if ((match_found) && (IFILT(tmp).filter_if_output)) {
1592: retval = (*IFILT(tmp).filter_if_output)(IFILT(tmp).cookie,
1593: &ifp,
1594: &m);
1595: if (retval) {
1596: if (retval == EJUSTRETURN)
1597: return 0;
1598: else {
1599: m_freem(m);
1600: return retval;
1601: }
1602: }
1603:
1604: }
1605:
1606: if (ifp != orig_ifp)
1607: break;
1608:
1609: if (from_id == tmp->filter_id)
1610: match_found = 1;
1611: }
1612: }
1613: }
1614:
1615: /*
1616: * Finally, call the driver.
1617: */
1618: /*
1619: * Temporary, until all drivers do this.
1620: */
1621:
1622: ifp->if_obytes += m->m_pkthdr.len;
1623:
1624: retval = (*ifp->if_output)(ifp, m);
1625: dlil_stats.inject_if_out2++;
1626: if ((retval == 0) || (retval == EJUSTRETURN))
1627: return 0;
1628: else
1629: return retval;
1630: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.