![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dlil_ethersubr.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_ethersubr.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) 1982, 1989, 1993
24: * The Regents of the University of California. All rights reserved.
25: *
26: * Redistribution and use in source and binary forms, with or without
27: * modification, are permitted provided that the following conditions
28: * are met:
29: * 1. Redistributions of source code must retain the above copyright
30: * notice, this list of conditions and the following disclaimer.
31: * 2. Redistributions in binary form must reproduce the above copyright
32: * notice, this list of conditions and the following disclaimer in the
33: * documentation and/or other materials provided with the distribution.
34: * 3. All advertising materials mentioning features or use of this software
35: * must display the following acknowledgement:
36: * This product includes software developed by the University of
37: * California, Berkeley and its contributors.
38: * 4. Neither the name of the University nor the names of its contributors
39: * may be used to endorse or promote products derived from this software
40: * without specific prior written permission.
41: *
42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 THE REGENTS 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: */
55:
56:
57:
58: #include <sys/param.h>
59: #include <sys/systm.h>
60: #include <sys/kernel.h>
61: #include <sys/malloc.h>
62: #include <sys/mbuf.h>
63: #include <sys/socket.h>
64: #include <sys/sockio.h>
65: #include <sys/sysctl.h>
66:
67: #include <net/if.h>
68: #include <net/netisr.h>
69: #include <net/route.h>
70: #include <net/if_llc.h>
71: #include <net/if_dl.h>
72: #include <net/if_types.h>
73: #include <net/ndrv.h>
74:
75: #if INET
76: #include <netinet/in.h>
77: #include <netinet/in_var.h>
78: #include <netinet/if_ether.h>
79: #include <netinet/in_systm.h>
80: #include <netinet/ip.h>
81: #endif
82:
83:
84: #include <sys/socketvar.h>
85: #include <net/if_blue.h>
86:
87: #include <net/dlil.h>
88:
89:
90: #if LLC && CCITT
91: extern struct ifqueue pkintrq;
92: #endif
93:
94: /* General stuff from if_ethersubr.c - may not need some of it */
95:
96: #include <netat/at_pat.h>
97: #if NETAT
98: extern struct ifqueue atalkintrq;
99: #endif
100:
101:
102: #if BRIDGE
103: #include <net/bridge.h>
104: #endif
105:
106: /* #include "vlan.h" */
107: #if NVLAN > 0
108: #include <net/if_vlan_var.h>
109: #endif /* NVLAN > 0 */
110:
111:
112: extern struct ifnet_blue *blue_if;
113: extern struct mbuf *splitter_input(struct mbuf *, struct ifnet *);
114:
115: static u_long lo_dlt = 0;
116: static ivedonethis = 0;
117: static int ether_resolvemulti __P((struct ifnet *, struct sockaddr **,
118: struct sockaddr *));
119: u_char etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
120:
121: #define IFP2AC(IFP) ((struct arpcom *)IFP)
122:
123: /* This stuff is new */
124:
125: #define DB_HEADER_SIZE 20
126: struct en_desc {
127: short total_len;
128: u_short ethertype;
129: u_long dl_tag;
130: struct ifnet *ifp;
131: struct if_proto *proto;
132: u_long proto_id_length;
133: u_long proto_id_data[8]; /* probably less - proto-id and bitmasks */
134: };
135:
136: #define LITMUS_SIZE 16
137: #define ETHER_DESC_BLK_SIZE 50
138: #define MAX_INTERFACES 50
139:
140: /*
141: * Statics for demux module
142: */
143:
144: struct ether_desc_blk_str {
145: u_long n_blocks;
146: u_long *block_ptr;
147: };
148:
149: static struct ether_desc_blk_str ether_desc_blk[MAX_INTERFACES];
150: static u_long litmus_mask[LITMUS_SIZE];
151: static u_long litmus_length = 0;
152:
153:
154: /*
155: * Temp static for protocol registration XXX
156: */
157:
158: #define MAX_EN_COUNT 30
159:
160: static struct if_proto *en_array[MAX_EN_COUNT];
161:
162: /*
163: * This could be done below in-line with heavy casting, but the pointer arithmetic is
164: * prone to error.
165: */
166:
167: static
168: int desc_in_bounds(block, current_ptr, offset_length)
169: u_int block;
170: char *current_ptr;
171: u_long offset_length;
172: {
173: u_long end_of_block;
174: u_long current_ptr_tmp;
175:
176: current_ptr_tmp = (u_long) current_ptr;
177: end_of_block = (u_long) ether_desc_blk[block].block_ptr;
178: end_of_block += (ETHER_DESC_BLK_SIZE * ether_desc_blk[block].n_blocks);
179: if ((current_ptr_tmp + offset_length) < end_of_block)
180: return 1;
181: else
182: return 0;
183: }
184:
185:
186: /*
187: * Release all descriptor entries owned by this dl_tag (there may be several).
188: * Setting the dl_tag to 0 releases the entry. Eventually we should compact-out
189: * the unused entries.
190: */
191: static
192: int ether_del_proto(struct if_proto *proto, u_long dl_tag)
193: {
194: char *current_ptr = (char *) ether_desc_blk[proto->ifp->family_cookie].block_ptr;
195: struct en_desc *ed;
196: int i;
197: int found = 0;
198:
199: ed = (struct en_desc *) current_ptr;
200:
201: while(ed->total_len) {
202: if (ed->dl_tag == dl_tag) {
203: found = 1;
204: ed->dl_tag = 0;
205: }
206:
207: current_ptr += ed->total_len;
208: ed = (struct en_desc *) current_ptr;
209: }
210:
211: if (found) {
212: for (i=0; i < MAX_EN_COUNT; i++)
213: if (en_array[i] == proto) {
214: en_array[i] = 0;
215: break;
216: }
217:
218: return 0;
219: }
220: else
221: return ENOENT;
222: }
223:
224:
225:
226: static
227: int ether_add_proto(struct ddesc_head_str *desc_head, struct if_proto *proto, u_long dl_tag)
228: {
229: char *current_ptr;
230: struct dlil_demux_desc *desc;
231: u_long id_length; /* IN LONGWORDS!!! */
232: struct en_desc *ed;
233: u_long *bitmask;
234: u_long *proto_id;
235: int i;
236: short total_length;
237: u_long block_count;
238: u_long *tmp;
239:
240: for (i=0; i < MAX_EN_COUNT; i++)
241: if (en_array[i] == 0) {
242: en_array[i] = proto;
243: break;
244: }
245:
246: if (i == MAX_EN_COUNT) {
247: printf("WARNING: ether_add_proto -- Too many attachments\n");
248: return ENOMEM;
249: }
250:
251: TAILQ_FOREACH(desc, desc_head, next) {
252: switch (desc->type)
253: {
254: case DLIL_DESC_RAW:
255: id_length = desc->variants.bitmask.proto_id_length;
256: break;
257:
258: case DLIL_DESC_802_2:
259: id_length = 1;
260: break;
261:
262: case DLIL_DESC_802_2_SNAP:
263: id_length = 2;
264: break;
265:
266: default:
267: return EINVAL;
268: }
269:
270: restart:
271: block_count = ether_desc_blk[proto->ifp->family_cookie].n_blocks;
272: current_ptr = (char *) ether_desc_blk[proto->ifp->family_cookie].block_ptr;
273: ed = (struct en_desc *) current_ptr;
274: total_length = ((id_length << 2) * 2) + DB_HEADER_SIZE;
275:
276: while ((ed->total_len) && (desc_in_bounds(proto->ifp->family_cookie,
277: current_ptr, total_length))) {
278: if ((ed->dl_tag == 0) && (total_length <= ed->total_len))
279: break;
280: else
281: current_ptr += *(short *)current_ptr;
282:
283: ed = (struct en_desc *) current_ptr;
284: }
285:
286: if (!desc_in_bounds(proto->ifp->family_cookie, current_ptr, total_length)) {
287:
288: tmp = _MALLOC((ETHER_DESC_BLK_SIZE * (block_count + 1)),
289: M_IFADDR, M_NOWAIT);
290: if (tmp == 0) {
291: /*
292: * Remove any previous descriptors set in the call.
293: */
294: ether_del_proto(proto, dl_tag);
295: return ENOMEM;
296: }
297:
298: bzero(tmp, ETHER_DESC_BLK_SIZE * (block_count + 1));
299: bcopy(ether_desc_blk[proto->ifp->family_cookie].block_ptr,
300: tmp, (ETHER_DESC_BLK_SIZE * block_count));
301: FREE(ether_desc_blk[proto->ifp->family_cookie].block_ptr, M_IFADDR);
302: ether_desc_blk[proto->ifp->family_cookie].n_blocks = block_count + 1;
303: ether_desc_blk[proto->ifp->family_cookie].block_ptr = tmp;
304: goto restart;
305: }
306:
307: if (ed->total_len == 0)
308: ed->total_len = total_length;
309: ed->ethertype = *((u_short *) desc->native_type);
310:
311: ed->dl_tag = dl_tag;
312: ed->proto = proto;
313: ed->proto_id_length = id_length;
314: ed->ifp = proto->ifp;
315:
316: switch (desc->type)
317: {
318: case DLIL_DESC_RAW:
319: bcopy(desc->variants.bitmask.proto_id, &ed->proto_id_data[0], (id_length << 2) );
320: bcopy(desc->variants.bitmask.proto_id_mask, &ed->proto_id_data[id_length],
321: (id_length << 2));
322: break;
323:
324: case DLIL_DESC_802_2:
325: ed->proto_id_data[0] = 0;
326: bcopy(&desc->variants.desc_802_2, &ed->proto_id_data[0], 3);
327: ed->proto_id_data[1] = 0xffffff00;
328: break;
329:
330: case DLIL_DESC_802_2_SNAP:
331: /* XXX Add verification of fixed values here */
332:
333: ed->proto_id_data[0] = 0;
334: ed->proto_id_data[1] = 0;
335: bcopy(&desc->variants.desc_802_2_SNAP, &ed->proto_id_data[0], 8);
336: ed->proto_id_data[2] = 0xffffffff;
337: ed->proto_id_data[3] = 0xffffffff;;
338: break;
339: }
340:
341: if (id_length) {
342: proto_id = (u_long *) &ed->proto_id_data[0];
343: bitmask = (u_long *) &ed->proto_id_data[id_length];
344: for (i=0; i < (id_length); i++) {
345: litmus_mask[i] &= bitmask[i];
346: litmus_mask[i] &= proto_id[i];
347: }
348: if (id_length > litmus_length)
349: litmus_length = id_length;
350: }
351: }
352:
353: return 0;
354: }
355:
356:
357: static
358: int ether_shutdown()
359: {
360: return 0;
361: }
362:
363:
364:
365:
366: /*
367: * Process a received Ethernet packet;
368: * the packet is in the mbuf chain m without
369: * the ether header, which is provided separately.
370: */
371: int
372: new_ether_input(m, frame_header, ifp, dl_tag, sync_ok)
373: struct mbuf *m;
374: char *frame_header;
375: struct ifnet *ifp;
376: u_long dl_tag;
377: int sync_ok;
378:
379: {
380: register struct ether_header *eh = (struct ether_header *) frame_header;
381: register struct ifqueue *inq=0;
382: u_short ether_type;
383: int s;
384: u_int16_t ptype = -1;
385: unsigned char buf[18];
386:
387: #if ISO || LLC || NETAT
388: register struct llc *l;
389: #endif
390:
391:
392: #if DLIL_BLUEBOX
393:
394: /*
395: * Y-adapter input processing:
396: * - Don't split if coming from a dummy if
397: * - If coming from a real if, if splitting enabled,
398: * then filter the incoming packet
399: */
400: if (ifp != (struct ifnet *)blue_if)
401: { /* Is splitter turned on? */
402: if (ifp->if_flags&IFF_SPLITTER)
403: { m->m_data -= sizeof(struct ether_header);
404: m->m_len += sizeof (struct ether_header);
405: m->m_pkthdr.len += sizeof(struct ether_header);
406: /*
407: * Check to see if destined for BlueBox or Rhapsody
408: * If NULL return, mbuf's been consumed by the BlueBox.
409: * Otherwise, send on to Rhapsody
410: */
411: if ((m = splitter_input(m, ifp)) == NULL)
412: return EJUSTRETURN;
413: m->m_data += sizeof(struct ether_header);
414: m->m_len -= sizeof (struct ether_header);
415: m->m_pkthdr.len -= sizeof(struct ether_header);
416: }
417: } else
418: { /* Get the "real" IF */
419: ifp = ((struct ndrv_cb *)(blue_if->ifb_so->so_pcb))->nd_if;
420: m->m_pkthdr.rcvif = ifp;
421: blue_if->pkts_looped_b2r++;
422: }
423:
424: #endif
425: if ((ifp->if_flags & IFF_UP) == 0) {
426: m_freem(m);
427: return EJUSTRETURN;
428: }
429:
430: ifp->if_lastchange = time;
431:
432: if (eh->ether_dhost[0] & 1) {
433: if (bcmp((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
434: sizeof(etherbroadcastaddr)) == 0)
435: m->m_flags |= M_BCAST;
436: else
437: m->m_flags |= M_MCAST;
438: }
439: if (m->m_flags & (M_BCAST|M_MCAST))
440: ifp->if_imcasts++;
441:
442: ether_type = ntohs(eh->ether_type);
443:
444: #if NVLAN > 0
445: if (ether_type == vlan_proto) {
446: if (vlan_input(eh, m) < 0)
447: ifp->if_data.ifi_noproto++;
448: return EJUSTRETURN;
449: }
450: #endif /* NVLAN > 0 */
451:
452: switch (ether_type) {
453: #if INET
454: case ETHERTYPE_IP:
455: if (ipflow_fastforward(m))
456: return EJUSTRETURN;
457: ptype = mtod(m, struct ip *)->ip_p;
458: if ((sync_ok == 0) ||
459: (ptype != IPPROTO_TCP && ptype != IPPROTO_UDP)) {
460: schednetisr(NETISR_IP);
461: }
462:
463: inq = &ipintrq;
464: break;
465:
466: case ETHERTYPE_ARP:
467: schednetisr(NETISR_ARP);
468: inq = &arpintrq;
469: break;
470: #endif
471:
472: default: {
473: #if NETAT
474: if (ether_type > ETHERMTU)
475: return ENOENT;
476: l = mtod(m, struct llc *);
477: switch (l->llc_dsap) {
478: case LLC_SNAP_LSAP:
479:
480: /* Temporary hack: check for AppleTalk and AARP packets */
481: /* WARNING we're checking only on the "ether_type" (the 2 bytes
482: * of the SNAP header. This shouldn't be a big deal,
483: * AppleTalk pat_input is making sure we have the right packets
484: * because it needs to discrimante AARP from EtherTalk packets.
485: */
486:
487: if (l->llc_ssap == LLC_SNAP_LSAP &&
488: l->llc_un.type_snap.control == 0x03) {
489:
490: #ifdef APPLETALK_DEBUG
491: printf("new_ether_input: SNAP Cntrol type=0x%x Src=%s\n",
492: l->llc_un.type_snap.ether_type,
493: ether_sprintf(buf, &eh->ether_shost));
494: printf(" Dst=%s\n",
495: ether_sprintf(buf, &eh->ether_dhost));
496: #endif /* APPLETALK_DEBUG */
497:
498: if ((l->llc_un.type_snap.ether_type == 0x809B) ||
499: (l->llc_un.type_snap.ether_type == 0x80F3)) {
500:
501:
502: /*
503: * note: for AppleTalk we need to pass the enet header of the
504: * packet up stack. To do so, we made sure in that the FULL packet
505: * is copied in the mbuf by the mace driver, and only the m_data and
506: * length have been shifted to make IP and the other guys happy.
507: */
508:
509: m->m_data -= sizeof(*eh);
510: m->m_len += sizeof(*eh);
511: m->m_pkthdr.len += sizeof(*eh);
512: #ifdef APPLETALK_DEBUG
513: l == (struct llc *)(eh+1);
514: if (l->llc_un.type_snap.ether_type == 0x80F3) {
515: kprintf("new_ether_input: RCV AppleTalk type=0x%x Src=%s\n",
516: l->llc_un.type_snap.ether_type,
517: ether_sprintf(buf, &eh->ether_shost));
518: kprintf(" Dst=%s\n",
519: ether_sprintf(buf, &eh->ether_dhost));
520: }
521: #endif /* APPLETALK_DEBUG */
522: schednetisr(NETISR_APPLETALK);
523: inq = &atalkintrq ;
524:
525: break;
526: }
527: }
528:
529: break;
530:
531:
532: default:
533: return ENOENT;
534: }
535:
536: #else /*NETAT*/
537: return ENOENT;
538: #endif /* NETAT */
539:
540: }
541: }
542:
543: if (inq == 0)
544: return ENOENT;
545:
546: s = splimp();
547: if (IF_QFULL(inq)) {
548: IF_DROP(inq);
549: m_freem(m);
550: splx(s);
551: return EJUSTRETURN;
552: } else
553: IF_ENQUEUE(inq, m);
554: splx(s);
555:
556: if ((sync_ok) &&
557: (ptype == IPPROTO_TCP || ptype == IPPROTO_UDP)) {
558: extern void ipintr(void);
559:
560: s = splnet();
561: ipintr();
562: splx(s);
563: }
564:
565: return 0;
566: }
567:
568:
569:
570:
571: int ether_demux(ifp, m, frame_header, proto)
572: struct ifnet *ifp;
573: struct mbuf *m;
574: char *frame_header;
575: struct if_proto **proto;
576:
577: {
578: register struct ether_header *eh = (struct ether_header *)frame_header;
579: u_short ether_type;
580: char *current_ptr = (char *) ether_desc_blk[ifp->family_cookie].block_ptr;
581: struct dlil_demux_desc *desc;
582: register u_long temp;
583: u_long *data;
584: register struct if_proto *ifproto;
585: u_long i;
586: struct en_desc *ed;
587:
588:
589: if (eh->ether_dhost[0] & 1) {
590: if (bcmp((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
591: sizeof(etherbroadcastaddr)) == 0)
592: m->m_flags |= M_BCAST;
593: else
594: m->m_flags |= M_MCAST;
595: }
596:
597: ether_type = ntohs(eh->ether_type);
598:
599: /*
600: * Search through the connected protocols for a match.
601: */
602:
603:
604: data = mtod(m, u_long *);
605: ed = (struct en_desc *) current_ptr;
606: while (desc_in_bounds(ifp->family_cookie, current_ptr, DB_HEADER_SIZE)) {
607: if (ed->total_len == 0)
608: break;
609:
610: if ((ed->dl_tag != 0) && (ed->ifp == ifp) &&
611: ((ed->ethertype == ntohs(eh->ether_type)) || (ed->ethertype == 0))) {
612: if (ed->proto_id_length) {
613: for (i=0; i < (ed->proto_id_length); i++) {
614: temp = ntohs(data[i]) & ed->proto_id_data[ed->proto_id_length + i];
615: if ((temp ^ ed->proto_id_data[i]))
616: break;
617: }
618:
619: if (i >= (ed->proto_id_length)) {
620: *proto = ed->proto;
621: return 0;
622: }
623: }
624: else {
625: *proto = ed->proto;
626: return 0;
627: }
628: }
629: current_ptr += ed->total_len;
630: ed = (struct en_desc *) current_ptr;
631: }
632:
633: /*
634: kprintf("ether_demux - No match for <%x><%x><%x><%x><%x><%x><%x<%x>\n",
635: eh->ether_type,data[0], data[1], data[2], data[3], data[4],data[5],data[6]);
636: */
637:
638: return ENOENT;
639: }
640:
641:
642:
643: /*
644: * Ethernet output routine.
645: * Encapsulate a packet of type family for the local net.
646: * Use trailer local net encapsulation if enough data in first
647: * packet leaves a multiple of 512 bytes of data in remainder.
648: * Assumes that ifp is actually pointer to arpcom structure.
649: */
650: int
651: ether_frameout(ifp, m, ndest, edst, ether_type)
652: register struct ifnet *ifp;
653: struct mbuf **m;
654: struct sockaddr *ndest;
655: char *edst;
656: char *ether_type;
657: {
658: register struct ether_header *eh;
659: int hlen; /* link layer header lenght */
660: struct arpcom *ac = IFP2AC(ifp);
661:
662:
663: hlen = ETHER_HDR_LEN;
664:
665: /*
666: * If a simplex interface, and the packet is being sent to our
667: * Ethernet address or a broadcast address, loopback a copy.
668: * XXX To make a simplex device behave exactly like a duplex
669: * device, we should copy in the case of sending to our own
670: * ethernet address (thus letting the original actually appear
671: * on the wire). However, we don't do that here for security
672: * reasons and compatibility with the original behavior.
673: */
674: if ((ifp->if_flags & IFF_SIMPLEX) &&
675: ((*m)->m_flags & M_LOOP)) {
676: if (lo_dlt == 0)
677: dlil_find_dltag(APPLE_IF_FAM_LOOPBACK, 0, PF_INET, &lo_dlt);
678:
679: if (lo_dlt) {
680: if ((*m)->m_flags & M_BCAST) {
681: struct mbuf *n = m_copy(*m, 0, (int)M_COPYALL);
682: dlil_output(lo_dlt, n, 0, ndest, 0);
683: }
684: else
685: {
686: if (bcmp(edst, ac->ac_enaddr, ETHER_ADDR_LEN) == 0) {
687: dlil_output(lo_dlt, *m, 0, ndest, 0);
688: return EJUSTRETURN;
689: }
690: }
691: }
692: }
693:
694:
695: /*
696: * Add local net header. If no space in first mbuf,
697: * allocate another.
698: */
699: M_PREPEND(*m, sizeof (struct ether_header), M_DONTWAIT);
700: if (*m == 0) {
701: return (EJUSTRETURN);
702: }
703:
704:
705: eh = mtod(*m, struct ether_header *);
706: (void)memcpy(&eh->ether_type, ether_type,
707: sizeof(eh->ether_type));
708: (void)memcpy(eh->ether_dhost, edst, 6);
709: (void)memcpy(eh->ether_shost, ac->ac_enaddr,
710: sizeof(eh->ether_shost));
711:
712: #if DLIL_BLUEBOX
713: /*
714: * We're already to send. Let's check for the blue box...
715: */
716: if (ifp->if_flags&IFF_SPLITTER)
717: {
718: (*m)->m_flags |= 0x10;
719: if ((*m = splitter_input(*m, ifp)) == NULL)
720: return EJUSTRETURN;
721: else
722: return (0);
723: }
724: else
725: #endif
726: return 0;
727: }
728:
729:
730: static
731: int ether_add_if(struct ifnet *ifp)
732: {
733: u_long i;
734:
735: ifp->if_framer = ether_frameout;
736: ifp->if_demux = ether_demux;
737:
738: for (i=0; i < MAX_INTERFACES; i++)
739: if (ether_desc_blk[i].n_blocks == 0)
740: break;
741:
742: if (i == MAX_INTERFACES)
743: return EOVERFLOW;
744:
745: ether_desc_blk[i].block_ptr = _MALLOC(ETHER_DESC_BLK_SIZE, M_IFADDR, M_NOWAIT);
746: if (ether_desc_blk[i].block_ptr == 0)
747: return ENOMEM;
748:
749: ether_desc_blk[i].n_blocks = 1;
750: bzero(ether_desc_blk[i].block_ptr, ETHER_DESC_BLK_SIZE);
751:
752: ifp->family_cookie = i;
753:
754: return 0;
755: }
756:
757: static
758: int ether_del_if(struct ifnet *ifp)
759: {
760: if ((ifp->family_cookie < MAX_INTERFACES) &&
761: (ether_desc_blk[ifp->family_cookie].n_blocks)) {
762: FREE(ether_desc_blk[ifp->family_cookie].block_ptr, M_IFADDR);
763: ether_desc_blk[ifp->family_cookie].n_blocks = 0;
764: return 0;
765: }
766: else
767: return ENOENT;
768: }
769:
770:
771:
772:
773: int
774: ether_pre_output(ifp, m0, dst_netaddr, route, type, edst, dl_tag )
775: struct ifnet *ifp;
776: struct mbuf **m0;
777: struct sockaddr *dst_netaddr;
778: caddr_t route;
779: char *type;
780: char *edst;
781: u_long dl_tag;
782: {
783: struct rtentry *rt0 = (struct rtentry *) route;
784: int s;
785: register struct mbuf *m = *m0;
786: register struct rtentry *rt;
787: register struct ether_header *eh;
788: int off, len = m->m_pkthdr.len;
789: int hlen; /* link layer header lenght */
790: struct arpcom *ac = IFP2AC(ifp);
791:
792:
793:
794: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
795: return ENETDOWN;
796:
797: rt = rt0;
798: if (rt) {
799: if ((rt->rt_flags & RTF_UP) == 0) {
800: rt0 = rt = rtalloc1(dst_netaddr, 1, 0UL);
801: if (rt0)
802: rt->rt_refcnt--;
803: else
804: return EHOSTUNREACH;
805: }
806:
807: if (rt->rt_flags & RTF_GATEWAY) {
808: if (rt->rt_gwroute == 0)
809: goto lookup;
810: if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
811: rtfree(rt); rt = rt0;
812: lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1,
813: 0UL);
814: if ((rt = rt->rt_gwroute) == 0)
815: return (EHOSTUNREACH);
816: }
817: }
818:
819:
820: if (rt->rt_flags & RTF_REJECT)
821: if (rt->rt_rmx.rmx_expire == 0 ||
822: time_second < rt->rt_rmx.rmx_expire)
823: return (rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
824: }
825:
826: hlen = ETHER_HDR_LEN;
827:
828: /*
829: * Tell ether_frameout it's ok to loop packet unless negated below.
830: */
831: m->m_flags |= M_LOOP;
832:
833: switch (dst_netaddr->sa_family) {
834:
835: #if INET
836: case AF_INET:
837: if (!arpresolve(ac, rt, m, dst_netaddr, edst, rt0))
838: return (EJUSTRETURN); /* if not yet resolved */
839: off = m->m_pkthdr.len - m->m_len;
840: *(u_short *)type = htons(ETHERTYPE_IP);
841: break;
842: #endif
843:
844: case AF_UNSPEC:
845: m->m_flags &= ~M_LOOP;
846: eh = (struct ether_header *)dst_netaddr->sa_data;
847: (void)memcpy(edst, eh->ether_dhost, 6);
848: *(u_short *)type = eh->ether_type;
849: break;
850:
851: #if NETAT
852: case AF_APPLETALK:
853: {
854: eh = (struct ether_header *)dst_netaddr->sa_data;
855: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, 6);
856:
857: *(u_short *)type = m->m_pkthdr.len;
858: }
859: break;
860:
861: #endif /* NETAT */
862:
863: default:
864: kprintf("%s%d: can't handle af%d\n", ifp->if_name, ifp->if_unit,
865: dst_netaddr->sa_family);
866:
867: return EAFNOSUPPORT;
868: }
869:
870: return (0);
871: }
872:
873:
874:
875:
876:
877: int
878: ether_ioctl(dl_tag, ifp, command, data)
879: u_long dl_tag;
880: struct ifnet *ifp;
881: int command;
882: caddr_t data;
883: {
884: struct ifaddr *ifa = (struct ifaddr *) data;
885: struct ifreq *ifr = (struct ifreq *) data;
886: int error = 0;
887: boolean_t funnel_state;
888:
889: funnel_state = thread_set_funneled(TRUE);
890:
891: switch (command) {
892: case SIOCSIFADDR:
893: ifp->if_flags |= IFF_UP;
894:
895: switch (ifa->ifa_addr->sa_family) {
896:
897: case AF_INET:
898:
899: if (ifp->if_init)
900: ifp->if_init(ifp->if_softc); /* before arpwhohas */
901:
902:
903: arp_ifinit(IFP2AC(ifp), ifa);
904:
905: break;
906:
907: default:
908: break;
909: }
910:
911: break;
912:
913: case SIOCGIFADDR:
914: {
915: struct sockaddr *sa;
916:
917: sa = (struct sockaddr *) & ifr->ifr_data;
918: bcopy(IFP2AC(ifp)->ac_enaddr,
919: (caddr_t) sa->sa_data, ETHER_ADDR_LEN);
920: }
921: break;
922:
923: case SIOCSIFMTU:
924: /*
925: * Set the interface MTU.
926: */
927: if (ifr->ifr_mtu > ETHERMTU) {
928: error = EINVAL;
929: } else {
930: ifp->if_mtu = ifr->ifr_mtu;
931: }
932: break;
933: }
934:
935: (void) thread_set_funneled(funnel_state);
936:
937: return (error);
938: }
939:
940:
941:
942:
943: /*
944: * Y-adapter filter check
945: * The rules here:
946: * For Rhap: return 1
947: * For Both: return 0
948: * Not for Rhap: return -1
949: * Multicast/Broadcast => For Both
950: * Atalk address registered
951: * filter matches => For Rhap else Not For Rhap
952: * IP address registered
953: * filter matches => For Rhap else Not For Rhap
954: * For Rhap
955: * Note this is *not* a general filter mechanism in that we know
956: * what we *could* be looking for.
957: * WARNING: this is a big-endian routine.
958: * Note: ARP and AARP packets are implicitly accepted for "both"
959: */
960: int
961: Filter_check(struct mbuf **m0)
962: { register struct BlueFilter *bf;
963: register unsigned char *p;
964: register unsigned short *s;
965: register unsigned long *l;
966: int total, flags;
967: struct mbuf *m;
968: extern struct mbuf *m_pullup(struct mbuf *, int);
969: extern void kprintf( const char *, ...);
970: #define FILTER_LEN 32
971:
972: m = *m0;
973: flags = m->m_flags;
974: if (FILTER_LEN > m->m_pkthdr.len)
975: return(1);
976: while ((FILTER_LEN > m->m_len) && m->m_next) {
977: total = m->m_len + (m->m_next)->m_len;
978: if ((m = m_pullup(m, min(FILTER_LEN, total))) == 0)
979: return(-1);
980: }
981: *m0 = m;
982:
983: p = mtod(m, unsigned char *); /* Point to destination media addr */
984: if (p[0] & 0x01) /* Multicast/broadcast */
985: return(0);
986: s = (unsigned short *)p;
987: bf = &RhapFilter[BFS_ATALK];
988: #if 0
989: kprintf("!PKT: %x, %x, %x\n", s[6], s[7], s[8]);
990: #endif
991:
992: if (bf->BF_flags) /* Filtering Appletalk */
993: {
994: l = (unsigned long *)&s[8];
995: #if 0
996: kprintf("!AT: %x, %x, %x, %x, %x, %x\n", s[6], s[7],
997: *l, s[10], s[13], p[30]);
998: #endif
999: if (s[6] <= ETHERMTU)
1000: { if (s[7] == 0xaaaa) /* Could be Atalk */
1001: { /* Verify SNAP header */
1002: if (*l == 0x03080007 && s[10] == 0x809b)
1003: { if (s[13] == bf->BF_address &&
1004: p[30] == bf->BF_node)
1005: return(1);
1006: } else if (*l == 0x03000000 && s[10] == 0x80f3)
1007: /* AARP pkts aren't net-addressed */
1008: return(0);
1009: return(0);
1010: } else /* Not for us? */
1011: return(0);
1012: } /* Fall through */
1013: } /* Fall through */
1014: bf++; /* Look for IP next */
1015: if (bf->BF_flags) /* Filtering IP */
1016: {
1017: l = (unsigned long *)&s[15];
1018: #if 0
1019: kprintf("!IP: %x, %x\n", s[6], *l);
1020: #endif
1021: if (s[6] > ETHERMTU)
1022: { if (s[6] == 0x800) /* Is IP */
1023: { /* Verify IP address */
1024: if (*l == bf->BF_address)
1025: return(1);
1026: else /* Not for us */
1027: return(0);
1028: } else if (s[6] == 0x806)
1029: /* ARP pkts aren't net-addressed */
1030: return(0);
1031: }
1032: }
1033: return(0); /* No filters => Accept */
1034: }
1035:
1036:
1037:
1038: int ether_family_init()
1039: {
1040:
1041: int i;
1042:
1043: if (ivedonethis)
1044: return 0;
1045:
1046: ivedonethis = 1;
1047:
1048:
1049: if (dlil_reg_if_modules(APPLE_IF_FAM_ETHERNET, ether_add_if, ether_del_if,
1050: ether_add_proto, ether_del_proto,
1051: ether_shutdown)) {
1052: printf("WARNING: ether_family_init -- Can't register if family modules\n");
1053: return EIO;
1054: }
1055:
1056: for (i=0; i < (LITMUS_SIZE/4); i++)
1057: litmus_mask[i] = 0xffffffff;
1058:
1059: for (i=0; i < MAX_EN_COUNT; i++)
1060: en_array[i] = (struct if_proto *) 0;
1061:
1062: for (i=0; i < MAX_INTERFACES; i++)
1063: ether_desc_blk[i].n_blocks = 0;
1064:
1065: return 0;
1066: }
1067:
1068:
1069:
1070: u_long ether_attach_inet(struct ifnet *ifp)
1071: {
1072: struct dlil_proto_reg_str reg;
1073: struct dlil_demux_desc desc;
1074: struct dlil_demux_desc desc2;
1075: u_long ip_dl_tag=0;
1076: u_short en_native=ETHERTYPE_IP;
1077: u_short arp_native=ETHERTYPE_ARP;
1078: int stat;
1079: int i;
1080:
1081:
1082: for (i=0; i < MAX_EN_COUNT; i++)
1083: if ((en_array[i]) && (en_array[i]->ifp == ifp) &&
1084: (en_array[i]->protocol_family == PF_INET)) {
1085: return en_array[i]->dl_tag;
1086: }
1087:
1088: TAILQ_INIT(®.demux_desc_head);
1089: desc.type = DLIL_DESC_RAW;
1090: desc.variants.bitmask.proto_id_length = 0;
1091: desc.variants.bitmask.proto_id = 0;
1092: desc.variants.bitmask.proto_id_mask = 0;
1093: desc.native_type = (char *) &en_native;
1094: TAILQ_INSERT_TAIL(®.demux_desc_head, &desc, next);
1095: reg.interface_family = ifp->if_family;
1096: reg.unit_number = ifp->if_unit;
1097: reg.input = new_ether_input;
1098: reg.pre_output = ether_pre_output;
1099: reg.event = 0;
1100: reg.offer = 0;
1101: reg.ioctl = ether_ioctl;
1102: reg.default_proto = 1;
1103: reg.protocol_family = PF_INET;
1104:
1105: desc2 = desc;
1106: desc2.native_type = (char *) &arp_native;
1107: TAILQ_INSERT_TAIL(®.demux_desc_head, &desc2, next);
1108:
1109: stat = dlil_attach_protocol(®, &ip_dl_tag);
1110: if (stat) {
1111: printf("WARNING: ether_attach_inet can't attach ip to interface\n");
1112: return stat;
1113: }
1114:
1115: return ip_dl_tag;
1116: }
1117:
1118: void ether_attach_at(struct ifnet *ifp, u_long *at_dl_tag, u_long *aarp_dl_tag)
1119: {
1120: struct dlil_proto_reg_str reg;
1121: struct dlil_demux_desc desc;
1122: struct dlil_demux_desc desc2;
1123: u_short native = 0; /* 802.2 frames use a length here */
1124: int stat;
1125:
1126: TAILQ_INIT(®.demux_desc_head);
1127: desc.type = DLIL_DESC_802_2_SNAP;
1128: desc.variants.desc_802_2_SNAP.dsap = LLC_SNAP_LSAP;
1129: desc.variants.desc_802_2_SNAP.ssap = LLC_SNAP_LSAP;
1130: desc.variants.desc_802_2_SNAP.control_code = 0x03;
1131: desc.variants.desc_802_2_SNAP.org[0] = 0x08;
1132: desc.variants.desc_802_2_SNAP.org[1] = 0x00;
1133: desc.variants.desc_802_2_SNAP.org[2] = 0x07;
1134: desc.variants.desc_802_2_SNAP.protocol_type = 0x809B;
1135: desc.native_type = (char *) &native;
1136: TAILQ_INSERT_TAIL(®.demux_desc_head, &desc, next);
1137: reg.interface_family = ifp->if_family;
1138: reg.unit_number = ifp->if_unit;
1139: reg.input = new_ether_input;
1140: reg.pre_output = ether_pre_output;
1141: reg.event = 0;
1142: reg.offer = 0;
1143: reg.ioctl = ether_ioctl;
1144: reg.default_proto = 0;
1145: reg.protocol_family = PF_APPLETALK;
1146:
1147: desc2 = desc;
1148: desc2.variants.desc_802_2_SNAP.protocol_type = 0x80F3;
1149: desc2.variants.desc_802_2_SNAP.org[0] = 0;
1150: desc2.variants.desc_802_2_SNAP.org[1] = 0;
1151: desc2.variants.desc_802_2_SNAP.org[2] = 0;
1152:
1153: TAILQ_INSERT_TAIL(®.demux_desc_head, &desc2, next);
1154:
1155: stat = dlil_attach_protocol(®, at_dl_tag);
1156: if (stat) {
1157: printf("WARNING: ether_attach_at can't attach at to interface\n");
1158: return;
1159: }
1160:
1161: *aarp_dl_tag = *at_dl_tag;
1162:
1163: } /* ether_attach_at */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.