![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to drv_dep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netat|
Return to drv_dep.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netat |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright 1994 Apple Computer, Inc.
27: * All Rights Reserved.
28: *
29: * THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF APPLE COMPUTER, INC.
30: * The copyright notice above does not evidence any actual or
31: * intended publication of such source code.
32: *
33: */
34:
35: #include <localglue.h>
36: #include <sysglue.h>
37: #include <at/appletalk.h>
38: #include <at/elap.h>
39: #include <at/at_lap.h>
40: #include <atlog.h>
41: #include <lap.h>
42: #include <at_elap.h>
43: #include <at_aarp.h>
44: #include <at_pat.h>
45: #include <routing_tables.h>
46:
47: #include <sys/socket.h>
48: #include <sys/socketvar.h>
49: #include <sys/sockio.h>
50: #include <net/if.h>
51: #include <net/if_dl.h>
52: #include <net/etherdefs.h>
53: #include <net/tokendefs.h>
54:
55: #define DSAP_SNAP 0xaa
56:
57: extern at_state_t *at_statep;
58: extern elap_specifics_t elap_specifics[];
59:
60: static llc_header_t snap_hdr_at = SNAP_HDR_AT;
61: static llc_header_t snap_hdr_aarp = SNAP_HDR_AARP;
62: static unsigned char snap_proto_ddp[5] = SNAP_PROTO_AT;
63: static unsigned char snap_proto_aarp[5] = SNAP_PROTO_AARP;
64: /* static struct etalk_addr etalk_mcast_base =
65: {0x09,0x00,0x07,0x00,0x00,0x00}; *** not used ***
66: */
67: int pktsIn, pktsOut;
68: int xpatcnt = 0;
69:
70: extern pat_unit_t pat_units[];
71:
72: #ifndef _AIX
73:
74: /* struct ifnet atalkif[1]; *** not used *** */
75: struct ifqueue atalkintrq; /* appletalk and aarp packet input queue */
76:
77: /* xxdevcnt, xxtype, xxnddp tables are no longer needed since the ifp's
78: are being initialized as a result of actions taken by the drivers.
79: There was a bug in which "xxnddp" was indexed by count in one place,
80: and unit in another place. However upon closer examination we
81: determined that "xxnddp" is no longer needed.
82: Annette DeSchon ([email protected]) 11/20/97
83: */
84:
85: short appletalk_inited = 0;
86:
87: #define FETCH_AND_ADD(x,y) (*x += y)
88:
89:
90: extern int (*sys_ATsocket )(), (*sys_ATgetmsg)(), (*sys_ATputmsg)();
91: extern int (*sys_ATPsndreq)(), (*sys_ATPsndrsp)();
92: extern int (*sys_ATPgetreq)(), (*sys_ATPgetrsp)();
93:
94: void atalk_load()
95: {
96: extern int _ATsocket(), _ATgetmsg(), _ATputmsg();
97: extern int _ATPsndreq(), _ATPsndrsp(), _ATPgetreq(), _ATPgetrsp();
98:
99: extern atlock_t ddpall_lock;
100: extern atlock_t ddpinp_lock;
101: extern atlock_t arpinp_lock;
102:
103: sys_ATsocket = _ATsocket;
104: sys_ATgetmsg = _ATgetmsg;
105: sys_ATputmsg = _ATputmsg;
106: sys_ATPsndreq = _ATPsndreq;
107: sys_ATPsndrsp = _ATPsndrsp;
108: sys_ATPgetreq = _ATPgetreq;
109: sys_ATPgetrsp = _ATPgetrsp;
110:
111: xpatcnt = 0;
112: ATLOCKINIT(ddpall_lock);
113: ATLOCKINIT(ddpinp_lock);
114: ATLOCKINIT(arpinp_lock);
115: gref_init();
116: atp_init();
117: /* adsp_init();
118: for 2225395
119: this happens in adsp_open and is undone on ADSP_UNLINK
120: */
121: } /* atalk_load */
122:
123: void atalk_unload() /* not currently used */
124: {
125: extern gbuf_t *scb_resource_m;
126: extern gbuf_t *atp_resource_m;
127:
128: sys_ATsocket = 0;
129: sys_ATgetmsg = 0;
130: sys_ATputmsg = 0;
131: sys_ATPsndreq = 0;
132: sys_ATPsndrsp = 0;
133: sys_ATPgetreq = 0;
134: sys_ATPgetrsp = 0;
135:
136: if (scb_resource_m) {
137: gbuf_freem(scb_resource_m);
138: scb_resource_m = 0;
139: }
140: if (atp_resource_m) {
141: gbuf_freem(atp_resource_m);
142: atp_resource_m = 0;
143: }
144: /* CleanupGlobals()
145: this happens on ADSP_UNLINK for 2225395 */
146: appletalk_inited = 0;
147: } /* atalk_unload */
148:
149: void appletalk_hack_start(nddp)
150: struct ifnet *nddp;
151: {
152: if (!appletalk_inited) {
153: appletalk_inited =1 ;
154: atalk_load();
155: atalkintrq.ifq_maxlen = IFQ_MAXLEN;
156: }
157:
158: /* Call to pat_attach(nddp) and the "xx" tables are no longer
159: needed since the ifp's are being initialized as a result
160: of actions taken by the drivers. AD 11/21/97 */
161: } /* appletalk_hack_start */
162:
163: /* return the unit number of this interface
164: return -1 if the interface is not found
165: */
166: /* int pat_ifpresent(name) *** not used ***
167: char *name;
168: {
169: struct ifnet *ifp;
170:
171: if (ifp = (ifunit(name)))
172: return(ifp->if_unit);
173: else
174: return(-1);
175: }
176: */
177:
178: int
179: pat_output(pat_id, mlist, dst_addr, type)
180: int pat_id;
181: gbuf_t *mlist;
182: unsigned char *dst_addr;
183: int type;
184: {
185: pat_unit_t *patp;
186: gbuf_t *m, *m_prev, *new_mlist;
187: llc_header_t *llc_header;
188:
189: struct sockaddr dst;
190:
191: /* this is for ether_output */
192:
193: dst.sa_family = AF_APPLETALK;
194: dst.sa_len = sizeof(struct etalk_addr);
195: bcopy (dst_addr, &dst.sa_data[0], dst.sa_len);
196: patp = (pat_unit_t *)&pat_units[pat_id];
197: if (patp->state != PAT_ONLINE) {
198: gbuf_freel(mlist);
199: return ENOTREADY;
200: }
201:
202: if (patp->xtype == IFTYPE_NULLTALK) {
203: gbuf_freel(mlist);
204: return 0;
205: }
206: new_mlist = 0;
207:
208: for (m = mlist; m; m = mlist) {
209: mlist = gbuf_next(m);
210: gbuf_next(m) = 0;
211:
212: gbuf_prepend(m,sizeof(llc_header_t));
213: if (m == 0) {
214: if (mlist)
215: gbuf_freel(mlist);
216: if (new_mlist)
217: gbuf_freel(new_mlist);
218: return 0;
219: }
220:
221: llc_header = (llc_header_t *)gbuf_rptr(m);
222: *llc_header = (type == AARP_AT_TYPE) ? snap_hdr_aarp : snap_hdr_at;
223:
224: m->m_pkthdr.len = gbuf_msgsize(m);
225: m->m_pkthdr.rcvif = 0;
226:
227: if (new_mlist)
228: gbuf_next(m_prev) = m;
229: else
230: new_mlist = m;
231: m_prev = m;
232: pktsOut++;
233: }
234:
235: while ((m = new_mlist) != 0) {
236: new_mlist = gbuf_next(m);
237: gbuf_next(m) = 0;
238: ((struct ifnet *)patp->nddp)->if_output((void *)patp->nddp, m, &dst, NULL);
239: }
240:
241: return 0;
242: } /* pat_output */
243:
244: int
245: pat_online (ifName, ifType)
246: char *ifName;
247: char *ifType;
248: {
249: /*###int pat_input();*/
250: int pat_id;
251: pat_unit_t *patp;
252: register struct ifaddr *ifa;
253: register struct sockaddr_dl *sdl;
254: struct ifnet *nddp;
255:
256: if ((pat_id = pat_ID(ifName)) == -1)
257: return (-1);
258: patp = &pat_units[pat_id];
259:
260: if (patp->xtype == IFTYPE_ETHERTALK) {
261: if ((nddp = ifunit(ifName)) == NULL)
262: return -1;
263: } else if (patp->xtype == IFTYPE_NULLTALK) {
264: patp->xaddrlen = 6;
265: bzero(patp->xaddr, patp->xaddrlen);
266: if (ifType)
267: *ifType = patp->xtype;
268: patp->nddp = (void *)0;
269: patp->state = PAT_ONLINE;
270: at_statep->flags |= AT_ST_IF_CHANGED;
271: return (pat_id);
272: } else
273: return -1;
274:
275: /*###********* No need to declare ourself as an if for now
276: if_attach(NULL, pat_input, 0, 0, 0,
277: if_name((void *)nddp), if_unit((void *)nddp), "AppleTalk",
278: 622, IFF_BROADCAST, NETIFCLASS_VIRTUAL, 0);
279: */
280:
281: /* if_control((void *)nddp, IFCONTROL_GETADDR, patp->xaddr); */
282:
283: for (ifa = nddp->if_addrlist; ifa; ifa = ifa->ifa_next)
284: if ((sdl = (struct sockaddr_dl *)ifa->ifa_addr) &&
285: (sdl->sdl_family == AF_LINK)) {
286: bcopy(LLADDR(sdl), patp->xaddr, 6);
287: #ifdef APPLETALK_DEBUG
288: kprintf("pat_online: our local enet address is=%s\n",
289: ether_sprintf(patp->xaddr));
290: #endif
291: break;
292: }
293:
294: patp->xaddrlen = 6;
295:
296: if (ifType)
297: *ifType = patp->xtype;
298:
299: patp->nddp = (void *)nddp;
300: patp->state = PAT_ONLINE;
301: at_statep->flags |= AT_ST_IF_CHANGED;
302:
303: return (pat_id);
304: } /* pat_online */
305:
306: void
307: pat_offline(pat_id)
308: int pat_id;
309: {
310: pat_unit_t *patp = &pat_units[pat_id];
311:
312: if (patp->state == PAT_ONLINE) {
313: /*#####
314: if (patp->xtype != IFTYPE_NULLTALK) {
315:
316: if_detach((void *)patp->nddp);
317: }
318: */
319: at_statep->flags |= AT_ST_IF_CHANGED;
320: bzero(patp, sizeof(pat_unit_t));
321: }
322: } /* pat_offline */
323:
324: int
325: pat_mcast(pat_id, control, data)
326: int pat_id;
327: int control;
328: unsigned char *data;
329: {
330: struct ifnet *nddp;
331: struct ifreq request;
332:
333: /* this is for ether_output */
334:
335: request.ifr_addr.sa_family = AF_UNSPEC;
336: request.ifr_addr.sa_len = 6; /* warning ### */
337: bcopy (data, &request.ifr_addr.sa_data[0], 6);
338:
339: nddp = (struct ifnet *)pat_units[pat_id].nddp;
340:
341: /*### LD Direct access to the ifp->if_ioctl function */
342:
343: if (nddp == 0) {
344: #ifdef APPLETALK_DEBUG
345: kprintf("pat_mcast: BAD ndpp\n");
346: #endif
347: return(-1);
348: }
349: #ifdef APPLETALK_DEBUG
350: else kprintf("pat_mcast: register multicast for ifname=%s\n", nddp->if_name);
351: #endif
352: return (*nddp->if_ioctl)(nddp, (control == PAT_REG_MCAST) ?
353: SIOCADDMULTI : SIOCDELMULTI, &request);
354: } /* pat_mcast */
355:
356: void
357: atalkintr()
358: {
359: struct mbuf *m;
360: struct ifnet *ifp;
361: int s, ret;
362:
363: next:
364: s = splimp();
365: IF_DEQUEUE(&atalkintrq, m);
366: splx(s);
367:
368: if (m == 0)
369: return;
370:
371: if ((m->m_flags & M_PKTHDR) == 0) {
372: #ifdef APPLETALK_DEBUG
373: kprintf("atalkintr: no HDR on packet received");
374: #endif
375: return;
376: }
377:
378: ifp = m->m_pkthdr.rcvif;
379:
380: /* do stuff */
381: /*
382: if (m->m_len < ENET_LLC_SIZE &&
383: (m = m_pullup(m, ENET_LLC_SIZE)) == 0) {
384: kprintf("atalkintr: packet too small\n");
385: goto next;
386: }
387: */
388:
389: ret = pat_input(NULL, ifp, m);
390: /*
391: if (ret)
392: kprintf("atalkintr: pat_input ret=%d\n", ret);
393: */
394: goto next;
395: } /* atalkintr */
396:
397:
398: int
399: pat_input(xddp, nddp, m)
400: void *xddp;
401: void *nddp;
402: gbuf_t *m;
403: {
404: #ifdef CHECK_DDPR_FLAG
405: extern int ddprunning_flag;
406: #endif
407: llc_header_t *llc_header;
408: int pat_id;
409: pat_unit_t *patp;
410: char src[6];
411: enet_header_t *enet_header = (enet_header_t *)gbuf_rptr(m);
412:
413: for (pat_id=0, patp = &pat_units[pat_id];
414: pat_id < xpatcnt; pat_id++, patp++) {
415: if ((patp->state == PAT_ONLINE) && (patp->nddp == nddp))
416: break;
417: }
418: /* if we didn't find a matching interface */
419: if (pat_id == xpatcnt) {
420: gbuf_freem(m);
421: #ifdef CHECK_DDPR_FLAG
422: FETCH_AND_ADD((atomic_p)&ddprunning_flag, -1);
423: #endif
424: return EAFNOSUPPORT;
425: }
426:
427: /* Ignore multicast packets from local station */
428: if (patp->xtype == IFTYPE_ETHERTALK) {
429: bcopy((char *)enet_header->src, src, sizeof(src));
430: /*
431: kprintf("pat_input: Packet received src addr=%s len=%x\n",
432: ether_sprintf(enet_header->src), enet_header->len);
433: */
434: /* In order to receive packets from the Blue Box, we cannot reject packets
435: whose source address matches our local address.
436: if ((enet_header->dst[0] & 1) &&
437: (bcmp(src, patp->xaddr, sizeof(src)) == 0)) {
438: #ifdef APPLETALK_DEBUG
439: kprintf("pat_input: Packet rejected: think it's a local mcast\n");
440: #endif
441: gbuf_freem(m);
442: #ifdef CHECK_DDPR_FLAG
443: FETCH_AND_ADD((atomic_p)&ddprunning_flag, -1);
444: #endif
445: return EAFNOSUPPORT;
446: }
447: */
448:
449: llc_header = (llc_header_t *)(enet_header+1);
450:
451: gbuf_rinc(m,(ENET_LLC_SIZE));
452: #ifdef CHECK_DDPR_FLAG
453: FETCH_AND_ADD((atomic_p)&ddprunning_flag, 1);
454: #endif
455: pktsIn++;
456: /*
457: kprintf("pat_input: enet_header: dest=%s LLC_PROTO= %02x%02x\n",
458: ether_sprintf(enet_header->dst),
459: llc_header->protocol[3],
460: llc_header->protocol[4]);
461: */
462:
463: if (LLC_PROTO_EQUAL(llc_header->protocol,snap_proto_aarp)) {
464: /*
465: kprintf("pat_input: Calling aarp_func dest=%s LLC_PROTO=%02x%02x\n",
466: ether_sprintf(enet_header->dst),
467: llc_header->protocol[3],
468: llc_header->protocol[4]);
469: */
470: patp->aarp_func(gbuf_rptr(m), patp->context);
471: gbuf_freem(m);
472: }
473: else if (LLC_PROTO_EQUAL(llc_header->protocol,snap_proto_ddp)) {
474: /* if we're a router take all pkts */
475: if (!ROUTING_MODE) {
476: if (patp->addr_check(gbuf_rptr(m), patp->context)
477: == AARP_ERR_NOT_OURS) {
478: /*
479: kprintf("pat_input: Packet Rejected: not for us? dest=%s LLC_PROTO= %02x%02x\n",
480: ether_sprintf(enet_header->dst),
481: llc_header->protocol[3],
482: llc_header->protocol[4]);
483: */
484: gbuf_freem(m);
485: #ifdef CHECK_DDPR_FLAG
486: FETCH_AND_ADD((atomic_p)&ddprunning_flag, -1);
487: #endif
488: return EAFNOSUPPORT;
489: }
490: }
491: gbuf_set_type(m, MSG_DATA);
492: elap_input(m, patp->context, src);
493: } else {
494: gbuf_rdec(m,(ENET_LLC_SIZE));
495:
496: #ifdef APPLETALK_DEBUG
497: kprintf("pat_input: Packet Rejected: wrong LLC_PROTO dest=%s LLC_PROTO= %02x%02x\n",
498: ether_sprintf(enet_header->dst),
499: llc_header->protocol[3],
500: llc_header->protocol[4]);
501: #endif
502: gbuf_freem(m);
503: #ifdef CHECK_DDPR_FLAG
504: FETCH_AND_ADD((atomic_p)&ddprunning_flag, -1);
505: #endif
506: return EAFNOSUPPORT;
507: }
508: }
509: #ifdef CHECK_DDPR_FLAG
510: FETCH_AND_ADD((atomic_p)&ddprunning_flag, -1);
511: #endif
512: return 0;
513: } /* pat_input */
514:
515: #else /* AIX section to end of file (not supported) */
516:
517: /* from beginning of file ... */
518: #include <sys/cdli.h>
519: #include <sys/ndd.h>
520: static struct ns_8022 elap_link; /* The SNAP header description */
521: static struct ns_user elap_user; /* The interface to the demuxer */
522:
523: int
524: pat_ifpresent(name) /* AIX */
525: char *name;
526: {
527: return (int)ifunit(name);
528: }
529:
530: int
531: pat_output(pat_id, mlist, dst_addr, type) /* AIX */
532: int pat_id;
533: gbuf_t *mlist;
534: unsigned char *dst_addr;
535: int type;
536: {
537: int len;
538: pat_unit_t *patp;
539: gbuf_t *m, *m_prev, *new_mlist, *m_temp;
540: struct ndd *nddp;
541: short size;
542: enet_header_t *enet_header;
543: llc_header_t *llc_header;
544:
545: patp = (pat_unit_t *)&pat_units[pat_id];
546: if (patp->state != PAT_ONLINE) {
547: gbuf_freel(mlist);
548: return ENOTREADY;
549: }
550:
551: if (patp->xtype == IFTYPE_NULLTALK) {
552: gbuf_freel(mlist);
553: return 0;
554: }
555:
556: nddp = (void *)patp->nddp;
557: new_mlist = 0;
558:
559: for (m = mlist; m; m = mlist) {
560: mlist = gbuf_next(m);
561: gbuf_next(m) = 0;
562:
563: gbuf_prepend(m,ENET_LLC_SIZE);
564: if (m == 0) {
565: if (mlist)
566: gbuf_freel(mlist);
567: if (new_mlist)
568: gbuf_freel(new_mlist);
569: return 0;
570: }
571:
572: enet_header = (enet_header_t *)gbuf_rptr(m);
573: bcopy(dst_addr, enet_header->dst, sizeof(enet_header->dst));
574: bcopy(patp->xaddr, enet_header->src, sizeof(enet_header->src));
575: size = gbuf_msgsize(m);
576: enet_header->len = size - sizeof(enet_header_t);
577: llc_header = (llc_header_t *)(gbuf_rptr(m)+sizeof(enet_header_t));
578: *llc_header = (type == AARP_AT_TYPE) ? snap_hdr_aarp : snap_hdr_at;
579:
580: m->m_pkthdr.len = size;
581: m->m_pkthdr.rcvif = 0;
582:
583: if (new_mlist)
584: gbuf_next(m_prev) = m;
585: else
586: new_mlist = m;
587: m_prev = m;
588: pktsOut++;
589: }
590:
591: if (new_mlist)
592: (*nddp->ndd_output)(nddp, new_mlist);
593:
594: return 0;
595: }
596:
597: int
598: pat_online (ifName, ifType) /* AIX */
599: char *ifName;
600: char *ifType;
601: {
602: void pat_input();
603: int pat_id;
604: pat_unit_t *patp;
605: struct ndd *nddp;
606: char ns_name[8];
607:
608: if ((pat_id = pat_ID(ifName)) == -1)
609: return (-1);
610: patp = &pat_units[pat_id];
611:
612: if (patp->xtype == IFTYPE_ETHERTALK) {
613: ns_name[0] = ifName[0];
614: ns_name[1] = 'n';
615: strcpy(&ns_name[2], &ifName[1]);
616: } else if (patp->xtype == IFTYPE_NULLTALK) {
617: patp->xaddrlen = 6;
618: bzero(patp->xaddr, patp->xaddrlen);
619: if (ifType)
620: *ifType = patp->xtype;
621: patp->nddp = (void *)0;
622: patp->state = PAT_ONLINE;
623: at_statep->flags |= AT_ST_IF_CHANGED;
624: return (pat_id);
625: } else
626: return -1;
627:
628: if (ns_alloc(ns_name, &nddp))
629: return -1;
630:
631: bzero(&elap_user, sizeof(elap_user));
632: elap_user.isr = pat_input;
633: elap_user.pkt_format = NS_HANDLE_HEADERS|NS_INCLUDE_MAC;
634:
635: elap_link.filtertype = NS_8022_LLC_DSAP_SNAP;
636: elap_link.orgcode[0] = 0;
637: elap_link.orgcode[2] = 0;
638: elap_link.dsap = DSAP_SNAP;
639: elap_link.ethertype = 0x80f3; /* AARP SNAP code */
640: if (ns_add_filter(nddp, &elap_link, sizeof(elap_link), &elap_user))
641: return -1;
642:
643: elap_link.orgcode[0] = 0x08;
644: elap_link.orgcode[2] = 0x07;
645: elap_link.ethertype = 0x809b; /* DDP SNAP code */
646: if (ns_add_filter(nddp, &elap_link, sizeof(elap_link), &elap_user)) {
647: elap_link.orgcode[0] = 0;
648: elap_link.orgcode[2] = 0;
649: elap_link.ethertype = 0x80f3; /* AARP SNAP code */
650: (void)ns_del_filter(nddp, &elap_link, sizeof(elap_link));
651: return -1;
652: }
653:
654: patp->xaddrlen = nddp->ndd_addrlen;
655: bcopy(nddp->ndd_physaddr, patp->xaddr, patp->xaddrlen);
656:
657: if (ifType)
658: *ifType = patp->xtype;
659:
660: patp->nddp = (void *)nddp;
661: patp->state = PAT_ONLINE;
662: at_statep->flags |= AT_ST_IF_CHANGED;
663:
664: return (pat_id);
665: }
666:
667: void
668: pat_offline(pat_id) /* AIX */
669: int pat_id;
670: {
671: pat_unit_t *patp = &pat_units[pat_id];
672:
673: if (patp->state == PAT_ONLINE) {
674: if (patp->xtype != IFTYPE_NULLTALK) {
675: elap_link.filtertype = NS_8022_LLC_DSAP_SNAP;
676: elap_link.orgcode[0] = 0;
677: elap_link.orgcode[2] = 0;
678: elap_link.dsap = DSAP_SNAP;
679: elap_link.ethertype = 0x80f3; /* AARP SNAP code */
680: (void)ns_del_filter(patp->nddp, &elap_link, sizeof(elap_link));
681: elap_link.orgcode[0] = 0x08;
682: elap_link.orgcode[2] = 0x07;
683: elap_link.ethertype = 0x809b; /* DDP SNAP code */
684: (void)ns_del_filter(patp->nddp, &elap_link, sizeof(elap_link));
685: ns_free(patp->nddp);
686: }
687: at_statep->flags |= AT_ST_IF_CHANGED;
688: bzero(patp, sizeof(pat_unit_t));
689: }
690: }
691:
692: int
693: pat_mcast(pat_id, control, data) /* AIX */
694: int pat_id;
695: int control;
696: unsigned char *data;
697: {
698: struct ndd *nddp;
699:
700: nddp = (struct ndd *)pat_units[pat_id].nddp;
701: return (*nddp->ndd_ctl)(nddp, (control == PAT_REG_MCAST) ?
702: NDD_ENABLE_ADDRESS : NDD_DISABLE_ADDRESS,
703: data, nddp->ndd_addrlen);
704: }
705:
706: void
707: pat_input(nddp, m, unused) /* AIX */
708: struct ndd *nddp;
709: gbuf_t *m;
710: void *unused;
711: {
712: extern int ddprunning_flag;
713: llc_header_t *llc_header;
714: int pat_id;
715: pat_unit_t *patp;
716: char src[6];
717: enet_header_t *enet_header = (enet_header_t *)gbuf_rptr(m);
718:
719: for (pat_id=0, patp = &pat_units[pat_id];
720: pat_id < xpatcnt; pat_id++, patp++) {
721: if ((patp->state == PAT_ONLINE) && (patp->nddp == nddp))
722: break;
723: }
724: if (pat_id == xpatcnt) {
725: gbuf_freem(m);
726: return;
727: }
728:
729: /* Ignore multicast packets from local station */
730: if (patp->xtype == IFTYPE_ETHERTALK) {
731: bcopy((char *)enet_header->src, src, sizeof(src));
732: if ((enet_header->dst[0] & 1) &&
733: (bcmp(src, patp->xaddr, sizeof(src)) == 0)) {
734: gbuf_freem(m);
735: return;
736: }
737: llc_header = (llc_header_t *)(enet_header+1);
738: }
739:
740: gbuf_rinc(m,(ENET_LLC_SIZE));
741: (void)fetch_and_add((atomic_p)&ddprunning_flag, 1);
742: pktsIn++;
743: if (LLC_PROTO_EQUAL(llc_header->protocol,snap_proto_aarp)) {
744: patp->aarp_func(gbuf_rptr(m), patp->context);
745: gbuf_freem(m);
746: } else if (LLC_PROTO_EQUAL(llc_header->protocol,snap_proto_ddp)) {
747: /* if we're a router take all pkts */
748: if (!ROUTING_MODE) {
749: if (patp->addr_check(gbuf_rptr(m), patp->context)
750: == AARP_ERR_NOT_OURS) {
751: gbuf_freem(m);
752: (void)fetch_and_add((atomic_p)&ddprunning_flag, -1);
753: return;
754: }
755: }
756: gbuf_set_type(m, MSG_DATA);
757: elap_input(m, patp->context, src);
758: } else
759: gbuf_freem(m);
760: (void)fetch_and_add((atomic_p)&ddprunning_flag, -1);
761: }
762: #endif /* AIX */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.