![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tokensr.h 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 tokensr.h 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: /* Copyright (c) 1993 NeXT Computer, Inc. All rights reserved.
23: *
24: * tokensr.h - Token-ring IEEE 802.5 source routing utility functions.
25: *
26: * We currently make these functions static inlines. These should
27: * be considered for movement to a library and made public (after
28: * sanitizing API).
29: *
30: * HISTORY
31: *
32: * 22-Jul-94 John Immordino (jimmord) at NeXT
33: * Converted static array of source routes to a hash table.
34: * Loosely coupled hash table entries to arp table entries, ie.
35: * when hash table is full, delete the first entry for which there
36: * is no arp entry before inserting the next source route.
37: *
38: * 26-Apr-94 John Immordino (jimmord) at NeXT
39: * Cleaned up. Fixed byte-swap problems, converted all addresses to
40: * character arrays, etc.
41: *
42: * 07-Apr-93 Joel Greenblatt at NeXT
43: * Created
44: *
45: */
46:
47: #ifdef DRIVER_PRIVATE
48:
49: #ifndef _TOKENSR_
50: #define _TOKENSR_
51:
52: #include <sys/socket.h>
53: #include <net/tokendefs.h>
54: #include <net/if.h>
55: #include <net/if_arp.h>
56: #include <netinet/in.h>
57: #include <netinet/if_ether.h>
58: #include <objc/hashtable.h> /* Not an Obj-C header */
59:
60: /*
61: * Virtual driver parameters
62: * Used by if_vtrXX modules
63: */
64: typedef struct {
65: int vunit;
66: int vflags;
67: int vmtu;
68: int vtokpri;
69: } vparms_t;
70:
71:
72: /*
73: * Source routing table entry
74: * Note: ipAddr must be the first element in order for our hash table
75: * code to work properly.
76: */
77: typedef struct {
78: unsigned long ipAddr; /* IP address of this entry - */
79: /* needed for our temporary */
80: /* arp table lookup scheme */
81: sroute_t ri; /* routing information field */
82: } srtable_t;
83:
84:
85: /*
86: * Encoded source-routing broadcast type (used as parameter to
87: * source routing routines).
88: */
89: typedef enum {
90: SRB_OFF, /* no source-route broadcast */
91: SRB_AR, /* all-routes broadcast */
92: SRB_SR, /* single-route broadcast */
93: SRB_INVALID /* invalid entry */
94: } srbcast_t;
95:
96: /*
97: * ARP code taken from bsd/netinet/if_ether.c. Need this in order
98: * to perform lookups of IP addresses to determine which source route
99: * entry to remove from the table. The first source route entry without
100: * a corresponding ARP entry will be removed.
101: */
102: #ifdef GATEWAY
103: #define ARPTAB_BSIZ 16 /* bucket size */
104: #define ARPTAB_NB 37 /* number of buckets */
105: #else
106: #define ARPTAB_BSIZ 9 /* bucket size */
107: #define ARPTAB_NB 19 /* number of buckets */
108: #endif
109:
110: extern struct arptab arptab[];
111:
112: #define ARPTAB_HASH(a) \
113: ((u_long)(a) % ARPTAB_NB)
114:
115: /*
116: * Change to permit multiple heterogenous interfaces to co-exist.
117: */
118: #define ARPTAB_LOOK(at,addr,ifp) { \
119: register n; \
120: at = &arptab[ARPTAB_HASH(addr) * ARPTAB_BSIZ]; \
121: for (n = 0 ; n < ARPTAB_BSIZ ; n++,at++) \
122: if (at->at_iaddr.s_addr == addr && \
123: (!(ifp) || at->at_if == (ifp))) \
124: break; \
125: if (n >= ARPTAB_BSIZ) \
126: at = 0; \
127: }
128:
129:
130: /*
131: * Initialize callers source routing table.
132: */
133: static __inline__
134: void init_src_routing(NXHashTable **sourceRouteTable)
135: {
136: extern NXHashTablePrototype SRTablePrototype;
137: *sourceRouteTable = NXCreateHashTable(SRTablePrototype, 0, NULL);
138: }
139:
140: /*
141: * Search for a source route (given a destination address).
142: */
143: static __inline__
144: sroute_t *find_sr(NXHashTable *sourceRouteTable, unsigned long idst)
145: {
146: srtable_t *sourceRouteEntry = NXHashGet(sourceRouteTable,
147: (const void *)&idst);
148: if (sourceRouteEntry) {
149: return &sourceRouteEntry->ri;
150: }
151: return NULL;
152: }
153:
154: /*
155: * Add an entry to the callers source routing table.
156: */
157: static __inline__
158: void add_sr(netif_t netif, NXHashTable *sourceRouteTable, unsigned long ipAddr,
159: sroute_t *rip, unsigned long srLimit)
160: {
161: srtable_t *sourceRouteEntry;
162: struct ifnet *ifp = (struct ifnet *)netif;
163:
164: if ((rip->rc.len > 18)|| (rip->rc.len < 2) || (rip->rc.len & 1))
165: return;
166:
167: /*
168: * See if the entry is already in the table
169: */
170: sourceRouteEntry = NXHashGet(sourceRouteTable,&ipAddr);
171: if (sourceRouteEntry) {
172: bcopy(rip, &sourceRouteEntry->ri, rip->rc.len);
173: sourceRouteEntry->ri.rc.bcast = 0; /* make non-bcast */
174: sourceRouteEntry->ri.rc.dir = ~sourceRouteEntry->ri.rc.dir;
175: return;
176: }
177:
178: /*
179: * See if there's room in the table for another entry.
180: */
181: if (NXCountHashTable(sourceRouteTable) >= srLimit) {
182: BOOL dumpedOne = NO;
183: NXHashState state = NXInitHashState(sourceRouteTable);
184:
185: /*
186: * Need to delete an entry.
187: */
188: while (NXNextHashState(sourceRouteTable, &state,
189: (void **)&sourceRouteEntry)) {
190:
191: struct arptab *at;
192:
193: /*
194: * Look for an entry without a corresponding entry in the
195: * arp table.
196: */
197: ARPTAB_LOOK(at, sourceRouteEntry->ipAddr, ifp);
198: if (at == NULL) {
199: /*
200: * Found one - try to remove it
201: */
202: sourceRouteEntry =
203: NXHashRemove(sourceRouteTable,
204: (const void *)&sourceRouteEntry->ipAddr);
205: if (sourceRouteEntry) {
206: kfree(sourceRouteEntry,sizeof(srtable_t));
207: dumpedOne = YES;
208: break;
209: }
210: }
211: }
212: if (dumpedOne == NO) {
213: printf("add_sr: source route table overflow\n");
214: return;
215: }
216: }
217:
218: sourceRouteEntry = (srtable_t *)kalloc(sizeof(srtable_t));
219:
220: sourceRouteEntry->ipAddr = ipAddr;
221: bcopy(rip, &sourceRouteEntry->ri, rip->rc.len);
222: sourceRouteEntry->ri.rc.bcast = 0; /* make non-bcast */
223: sourceRouteEntry->ri.rc.dir = ~sourceRouteEntry->ri.rc.dir;
224:
225: sourceRouteEntry =
226: NXHashInsert(sourceRouteTable,(const void *)&sourceRouteEntry->ipAddr);
227: if (sourceRouteEntry) /* shouldn't happen */
228: kfree(sourceRouteEntry,sizeof(srtable_t));
229: }
230:
231: /*
232: * Find & return the source route to the callers address.
233: */
234: static __inline__
235: void get_src_route(NXHashTable *sourceRouteTable, unsigned long idst,
236: unsigned char *da, tokenHeader_t *th)
237: {
238: sroute_t *sourceRoute;
239:
240: if (da[0] & 0x80)
241: return; /* don't handle group addresses */
242:
243: /*
244: * Find source route in srtable and copy to caller's
245: * tokenHeader_t (or turn off sri bit).
246: */
247: sourceRoute = find_sr(sourceRouteTable, idst);
248: if (sourceRoute) {
249: bcopy(sourceRoute, &th->ri, sourceRoute->rc.len);
250: th->sa[0] |= TR_RII;
251: }
252: else
253: th->sa[0] &= ~TR_RII; /* turn off source routing bit */
254: }
255:
256: /*
257: * Save the source route in the callers MAC header.
258: */
259: static __inline__
260: void save_src_route(netif_t netif, NXHashTable *sourceRouteTable,
261: unsigned long ipAddr, tokenHeader_t *th, unsigned long srLimit)
262: {
263: /*
264: * If frame has a routing field > 2 then save it (i.e. it's been
265: * thru at least one bridge).
266: */
267: if ((th->sa[0] & TR_RII) && (th->ri.rc.len > 2))
268: add_sr(netif, sourceRouteTable, ipAddr, &th->ri, srLimit);
269: }
270:
271:
272: /*
273: * Returns length of the source routing field in callers MAC header.
274: * Returns -1 if the header is invalid.
275: */
276: static __inline__
277: int get_ri_len(tokenHeader_t *th)
278: {
279: int ri_len = 0;
280: sroute_t *rif = (sroute_t *)&th->ri;
281:
282: if (th->sa[0] & 0x80) {
283: ri_len = (int)rif->rc.len;
284: if ((ri_len & 1) || (ri_len < 2) || (ri_len > 18)) {
285: ri_len = -1;
286: }
287: }
288: return ri_len;
289: }
290:
291: /*
292: * Returns the length of an 802.5 MAC header (including routing field).
293: */
294: static __inline__
295: int get_8025_hdr_len(tokenHeader_t *th)
296: {
297: int ri_len;
298:
299: ri_len = get_ri_len(th);
300: if (ri_len < 0)
301: return ri_len; // bad header
302:
303: return ri_len + MAC_HDR_MIN;
304: }
305:
306: /*
307: * Returns 1 if mac address is any type of broadcast, zero otherwise.
308: */
309: static __inline__
310: int check_mac_bcast(tokenHeader_t *th)
311: {
312: if (th->da[0] & 0x80)
313: return 1; // group address (I/G bit)
314: return 0;
315: }
316:
317: /*
318: * Build a broadcast routing field in the callers MAC header.
319: */
320: static __inline__
321: void make_sr_bcast(tokenHeader_t *th, srbcast_t type)
322: {
323: if ((type == SRB_OFF) || (type >= SRB_INVALID)) {
324: th->sa[0] &= ~TR_RII;
325: return;
326: }
327:
328: th->sa[0] |= TR_RII; /* turn on rii bit to ind. src rtng field */
329:
330: /*
331: * Build the routing control field for the requested
332: * broadcast type.
333: */
334: if (type == SRB_AR)
335: th->ri.rc.bcast = BI_AR_BCAST;
336: else
337: th->ri.rc.bcast = BI_SR_BCAST;
338:
339: th->ri.rc.len = 2;
340: th->ri.rc.dir = 0;
341: th->ri.rc.longf = LF_BCAST;
342: th->ri.rc.rsrvd = 0;
343: }
344:
345: /*
346: * Make the callers MAC header a reply to sender.
347: */
348: static __inline__
349: void make_mac_reply(tokenHeader_t *th)
350: {
351:
352: /*
353: * Copy source address to destination address. Turn off RII bit in
354: * the destination address.
355: */
356: bcopy(th->sa, th->da, sizeof(th->da));
357: th->da[0] &= ~TR_RII;
358:
359: /*
360: * Convert the source routing field to a reply (flip direction
361: * bit & turn off broadcast bits).
362: */
363: if (th->sa[0] & TR_RII) {
364: th->ri.rc.dir = ~th->ri.rc.dir;
365: th->ri.rc.bcast = 0;
366: }
367: }
368:
369:
370: #endif /* _TOKENSR_ */
371:
372: #endif /* DRIVER_PRIVATE */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.