![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddp_aarp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netat|
Return to ddp_aarp.c CVS log | Up to [Apple XNU] / XNU / bsd / netat |
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) 1988, 1989, 1997, 1998 Apple Computer, Inc.
23: *
24: * Modified for MP, 1996 by Tuyen Nguyen
25: * Modified, March 17, 1997 by Tuyen Nguyen for MacOSX.
26: */
27:
28: /* at_aarp.c: 2.0, 1.17; 10/4/93; Apple Computer, Inc. */;
29:
30: /* This file is at_aarp.c and it contains all the routines used by AARP. This
31: * is part of the LAP layer.
32: */
33:
34: #include <sys/errno.h>
35: #include <sys/types.h>
36: #include <sys/param.h>
37: #include <machine/spl.h>
38: #include <sys/systm.h>
39: #include <sys/kernel.h>
40: #include <sys/proc.h>
41: #include <sys/filedesc.h>
42: #include <sys/fcntl.h>
43: #include <sys/mbuf.h>
44: #include <sys/ioctl.h>
45: #include <sys/malloc.h>
46: #include <sys/socket.h>
47: #include <sys/socketvar.h>
48:
49: #include <net/if.h>
50: #include <net/if_types.h>
51: #include <net/if_blue.h>
52:
53: #include <netat/sysglue.h>
54: #include <netat/appletalk.h>
55: #include <netat/ddp.h>
56: #include <netat/lap.h>
57: #include <netat/at_snmp.h>
58: #include <netat/at_pcb.h>
59: #include <netat/at_var.h>
60: #include <netat/at_aarp.h>
61: #include <netat/debug.h>
62: #include <netat/at_config.h>
63:
64: static int probing;
65: /* Following two variables are used to keep track of how many dynamic addresses
66: * we have tried out at startup.
67: */
68: int no_of_nodes_tried; /* no of node addresses we've tried
69: * so far, within a network number
70: */
71: int no_of_nets_tried; /* no. of network numbers tried
72: */
73:
74: struct etalk_addr et_zeroaddr = {
75: {0, 0, 0, 0, 0, 0}};
76:
77: aarp_amt_t probe_cb;
78: aarp_amt_array *aarp_table[IF_TOTAL_MAX];
79:
80: int aarp_init1(), aarp_init2();
81: int aarp_send_data();
82:
83: StaticProc int aarp_req_cmd_in();
84: StaticProc int aarp_resp_cmd_in();
85: StaticProc int aarp_probe_cmd_in();
86: StaticProc int aarp_send_resp();
87: StaticProc int aarp_send_req();
88: StaticProc int aarp_send_probe();
89: StaticProc aarp_amt_t *aarp_lru_entry();
90: StaticProc int aarp_glean_info();
91: StaticProc int aarp_delete_amt_info();
92: StaticProc int aarp_sched_probe();
93: StaticProc void aarp_build_pkt();
94: StaticProc int aarp_sched_req();
95: StaticProc int aarp_get_rand_node();
96: StaticProc int aarp_get_next_node();
97: StaticProc int aarp_get_rand_net();
98: atlock_t arpinp_lock;
99:
100: extern void AARPwakeup(aarp_amt_t *);
101: extern int pat_output(at_ifaddr_t *, gbuf_t *, unsigned char *, int);
102:
103: /****************************************************************************
104: * aarp_init()
105: *
106: ****************************************************************************/
107: static int is_registered = 0; /* For y-adapter */
108:
109: extern struct BlueFilter RhapFilter[];
110: #ifdef BF_if
111: extern at_register_addr(struct BlueFilter *);
112: #else
113: extern at_register_addr(struct BlueFilter *, struct ifnet *);
114: #endif
115:
116: int aarp_init1(elapp)
117: register at_ifaddr_t *elapp;
118: {
119: elapp->ifThisNode.s_net = 0;
120: elapp->ifThisNode.s_node = 0;
121:
122: if (is_registered)
123: { is_registered = 0;
124: RhapFilter[BFS_ATALK].BF_flags = 0;
125: }
126:
127: if (probing != PROBE_TENTATIVE) /* How do I set the initial probe */
128: probing = PROBE_IDLE; /* state ???*/
129: else {
130: dPrintf(D_M_AARP,D_L_ERROR,
131: ("aarp_init: error :probing == PROBE_TENTATIVE\n"));
132: return(-1);
133: }
134:
135: /* pick a random addr or start with what we have from initial_node addr */
136: if (elapp->initial_addr.s_net == 0 && elapp->initial_addr.s_node == 0) {
137: dPrintf(D_M_AARP, D_L_INFO,
138: ("aarp_init: pick up a new node number\n"));
139: aarp_get_rand_node(elapp);
140: aarp_get_rand_net(elapp);
141: }
142: probe_cb.elapp = elapp;
143: probe_cb.no_of_retries = 0;
144: probe_cb.error = 0;
145:
146: no_of_nodes_tried = 0; /* haven't tried any addresses yet */
147: no_of_nets_tried = 0;
148:
149: if (aarp_send_probe() == -1) {
150: probing = PROBE_IDLE; /* not probing any more */
151: dPrintf(D_M_AARP, D_L_ERROR,
152: ("aarp_init: aarp_send_probe returns error\n"));
153: return(-1);
154: }
155: return(ENOTREADY);
156: }
157:
158: int aarp_init2(elapp)
159: register at_ifaddr_t *elapp;
160: {
161: struct BlueFilter BF, *bf = &BF;
162:
163: if (probe_cb.error != 0) {
164: probing = PROBE_IDLE; /* not probing any more */
165: dPrintf(D_M_AARP, D_L_ERROR,
166: ("aarp_init: probe_cb.error creates error =%d\n",
167: probe_cb.error));
168: return(-1);
169: }
170:
171: if (aarp_table[elapp->ifPort])
172: bzero ((caddr_t)&aarp_table[elapp->ifPort]->et_aarp_amt[0],
173: sizeof(aarp_amt_array));
174: else
175: return(-1);
176:
177: elapp->ifThisNode = elapp->initial_addr;
178: probing = PROBE_DONE;
179:
180: /* Register our node address with the y-adapter */
181: bf->BF_flags = (BF_VALID|BF_ATALK);
182: bf->BF_address = elapp->ifThisNode.s_net;
183: bf->BF_node = elapp->ifThisNode.s_node;
184: #ifdef BF_ifp
185: bf->BF_ifp = elapp->aa_ifp;
186: #endif
187:
188: #ifdef BF_ifp
189: at_register_addr(bf);
190: #else
191: at_register_addr(bf, elapp->aa_ifp);
192: #endif
193: is_registered = 1;
194:
195: return(0);
196: }
197:
198: /*
199: * Register an appletalk address:
200: * plant the info in a filter for the Y-adapter, if enabled
201: */
202: int
203: at_register_addr(register struct BlueFilter *bf,
204: #ifndef BF_ifp
205: register struct ifnet *ifp
206: #endif
207: )
208: { register struct BlueFilter *bf1;
209: extern struct ifnet_blue *blue_if;
210: #ifdef BF_ifp
211: register struct ifnet *ifp = bf->BF_ifp;
212: #endif
213: if (blue_if != 0) {
214: bf1=&blue_if->filter[BFS_ATALK];
215: if (bf1->BF_flags & BF_VALID) {
216: kprintf("Dammit, Rodney, how can I work with all these interruptions?\n");
217: return(1);
218: }
219: *bf1 = *bf;
220: bf1->BF_flags |= BF_VALID;
221: }
222: return(0);
223: }
224:
225: /****************************************************************************
226: * aarp_rcv_pkt()
227: *
228: * remarks :
229: * (1) The caller must take care of freeing the real storage (gbuf)
230: * (2) The incoming packet is of the form {802.3, 802.2, aarp}.
231: *
232: ****************************************************************************/
233: int aarp_rcv_pkt(pkt, elapp)
234: aarp_pkt_t *pkt;
235: at_ifaddr_t *elapp;
236: {
237: switch (pkt->aarp_cmd) {
238: case AARP_REQ_CMD:
239: return (aarp_req_cmd_in (pkt, elapp));
240: case AARP_RESP_CMD:
241: return (aarp_resp_cmd_in (pkt, elapp));
242: case AARP_PROBE_CMD:
243: return (aarp_probe_cmd_in (pkt, elapp));
244: default:
245: return (-1);
246: }/* end of switch*/
247: }
248:
249: /****************************************************************************
250: * aarp_req_cmd_in()
251: *
252: ****************************************************************************/
253: StaticProc int aarp_req_cmd_in (pkt, elapp)
254: aarp_pkt_t *pkt;
255: at_ifaddr_t *elapp;
256: {
257: /*
258: kprintf("aarp_req_cmd_in: ifThisNode=%d:%d srcNode=%d:%d dstNode=%d:%d\n",
259: elapp->ifThisNode.s_net,
260: elapp->ifThisNode.s_node,
261: NET_VALUE(pkt->src_at_addr.atalk_net),
262: pkt->src_at_addr.atalk_node,
263: NET_VALUE(pkt->dest_at_addr.atalk_net),
264: pkt->dest_at_addr.atalk_node);
265: */
266: if ((probing == PROBE_DONE) &&
267: (NET_VALUE(pkt->dest_at_addr.atalk_net) == elapp->ifThisNode.s_net) &&
268: (pkt->dest_at_addr.atalk_node == elapp->ifThisNode.s_node)) {
269: if (aarp_send_resp(elapp, pkt) == -1)
270: return(-1);
271: }
272: /* now to glean some info */
273: aarp_glean_info(pkt, elapp);
274: return (0);
275: }
276:
277:
278:
279: /****************************************************************************
280: * aarp_resp_cmd_in()
281: *
282: ****************************************************************************/
283: StaticProc int aarp_resp_cmd_in (pkt, elapp)
284: aarp_pkt_t *pkt;
285: at_ifaddr_t *elapp;
286: {
287: register aarp_amt_t *amt_ptr;
288: gbuf_t *m;
289:
290: switch (probing) {
291: case PROBE_TENTATIVE :
292: if ((NET_VALUE(pkt->src_at_addr.atalk_net) ==
293: probe_cb.elapp->initial_addr.s_net) &&
294: (pkt->src_at_addr.atalk_node ==
295: probe_cb.elapp->initial_addr.s_node)) {
296:
297: /* this is a response to AARP_PROBE_CMD. There's
298: * someone out there with the address we desire
299: * for ourselves.
300: */
301: untimeout(aarp_sched_probe, 0);
302: probe_cb.no_of_retries = 0;
303: aarp_get_next_node(probe_cb.elapp);
304: no_of_nodes_tried++;
305:
306: if (no_of_nodes_tried == AARP_MAX_NODES_TRIED) {
307: aarp_get_rand_net(probe_cb.elapp);
308: aarp_get_rand_node(probe_cb.elapp);
309: no_of_nodes_tried = 0;
310: no_of_nets_tried++;
311: }
312: if (no_of_nets_tried == AARP_MAX_NETS_TRIED) {
313: /* We have tried enough nodes and nets, give up.
314: */
315: probe_cb.error = EADDRNOTAVAIL;
316: AARPwakeup(&probe_cb);
317: return(0);
318: }
319: if (aarp_send_probe() == -1) {
320: /* expecting aarp_send_probe to fill in
321: * probe_cb.error
322: */
323: AARPwakeup(&probe_cb);
324: return(-1);
325: }
326: } else {
327: /* hmmmm! got a response packet while still probing
328: * for AT address and the AT dest address doesn't
329: * match!!
330: * What should I do here?? kkkkkkkkk
331: */
332: return(-1);
333: }
334: break;
335:
336: case PROBE_DONE :
337: AMT_LOOK(amt_ptr, pkt->src_at_addr, elapp);
338: if (amt_ptr == NULL)
339: return(-1);
340: if (amt_ptr->tmo) {
341: untimeout(aarp_sched_req, amt_ptr);
342: amt_ptr->tmo = 0;
343: }
344:
345: if (amt_ptr->m == NULL) {
346: /* this may be because of a belated response to
347: * aarp reaquest. Based on an earlier response, we
348: * might have already sent the packet out, so
349: * there's nothing to send now. This is okay, no
350: * error.
351: */
352: return(0);
353: }
354: amt_ptr->dest_addr = pkt->src_addr;
355: if (FDDI_OR_TOKENRING(elapp->aa_ifp->if_type))
356: ddp_bit_reverse(&amt_ptr->dest_addr);
357: m = amt_ptr->m;
358: amt_ptr->m = NULL;
359: pat_output(amt_ptr->elapp, m,
360: (unsigned char *)&amt_ptr->dest_addr, 0);
361: break;
362: default :
363: /* probing in a weird state?? */
364: return(-1);
365: }
366: return(0);
367: }
368:
369:
370:
371: /****************************************************************************
372: * aarp_probe_cmd_in()
373: *
374: ****************************************************************************/
375: StaticProc int aarp_probe_cmd_in (pkt, elapp)
376: register aarp_pkt_t *pkt;
377: at_ifaddr_t *elapp;
378: {
379: register aarp_amt_t *amt_ptr;
380:
381: switch (probing) {
382: case PROBE_TENTATIVE :
383: if ((elapp == probe_cb.elapp) &&
384: (NET_VALUE(pkt->src_at_addr.atalk_net) ==
385: probe_cb.elapp->initial_addr.s_net) &&
386: (pkt->src_at_addr.atalk_node ==
387: probe_cb.elapp->initial_addr.s_node)) {
388: /* some bozo is probing for address I want... and I
389: * can't tell him to shove off!
390: */
391: untimeout(aarp_sched_probe, 0);
392: probe_cb.no_of_retries = 0;
393: aarp_get_next_node(probe_cb.elapp);
394: no_of_nodes_tried++;
395:
396: if (no_of_nodes_tried == AARP_MAX_NODES_TRIED) {
397: aarp_get_rand_net(probe_cb.elapp);
398: aarp_get_rand_node(probe_cb.elapp);
399: no_of_nodes_tried = 0;
400: no_of_nets_tried++;
401: }
402: if (no_of_nets_tried == AARP_MAX_NETS_TRIED) {
403: /* We have tried enough nodes and nets, give up.
404: */
405: probe_cb.error = EADDRNOTAVAIL;
406: AARPwakeup(&probe_cb);
407: return(0);
408: }
409: if (aarp_send_probe() == -1) {
410: /* expecting aarp_send_probe to fill in
411: * probe_cb.error
412: */
413: AARPwakeup(&probe_cb);
414: return(-1);
415: }
416: } else {
417: /* somebody's probing... none of my business yet, so
418: * just ignore the packet
419: */
420: return (0);
421: }
422: break;
423:
424: case PROBE_DONE :
425: if ((NET_VALUE(pkt->src_at_addr.atalk_net) == elapp->ifThisNode.s_net) &&
426: (pkt->src_at_addr.atalk_node == elapp->ifThisNode.s_node)) {
427: if (aarp_send_resp(elapp, pkt) == -1)
428: return (-1);
429: return (0);
430: }
431: AMT_LOOK(amt_ptr, pkt->src_at_addr, elapp);
432:
433: if (amt_ptr)
434: aarp_delete_amt_info(amt_ptr);
435: break;
436: default :
437: /* probing in a weird state?? */
438: return (-1);
439: }
440: return (0);
441: }
442:
443:
444:
445: /****************************************************************************
446: * aarp_chk_addr()
447: ****************************************************************************/
448: int aarp_chk_addr(ddp_hdrp, elapp)
449: at_ddp_t *ddp_hdrp;
450: at_ifaddr_t *elapp;
451: {
452: if ((ddp_hdrp->dst_node == elapp->ifThisNode.s_node) &&
453: (NET_VALUE(ddp_hdrp->dst_net) == elapp->ifThisNode.s_net)) {
454: return(0); /* exact match in address */
455: }
456:
457: if (AARP_BROADCAST(ddp_hdrp, elapp)) {
458: return(0); /* some kind of broadcast address */
459: }
460: return (AARP_ERR_NOT_OURS); /* not for us */
461: }
462:
463:
464:
465: /****************************************************************************
466: * aarp_send_data()
467: *
468: * remarks :
469: * 1. The message coming in would be of the form {802.3, 802.2, ddp,...}
470: *
471: * 2. The message coming in would be freed here if transmission goes
472: * through okay. If an error is returned by aarp_send_data, the caller
473: * can assume that the message is not freed. The exception to
474: * this scenario is the prepended atalk_addr field. This field
475: * will ALWAYS be removed. If the message is dropped,
476: * it's not an "error".
477: *
478: ****************************************************************************/
479:
480: int aarp_send_data(m, elapp, dest_at_addr, loop)
481: register gbuf_t *m;
482: register at_ifaddr_t *elapp;
483: struct atalk_addr *dest_at_addr;
484: int loop; /* if true, loopback broadcasts */
485: {
486: register aarp_amt_t *amt_ptr;
487: register at_ddp_t *ddp_hdrp;
488: int error;
489: int s;
490:
491: if (gbuf_len(m) <= 0)
492: ddp_hdrp = (at_ddp_t *)gbuf_rptr(gbuf_cont(m));
493: else
494: ddp_hdrp = (at_ddp_t *)gbuf_rptr(m);
495:
496: if ((ddp_hdrp->dst_node == ddp_hdrp->src_node) &&
497: (NET_VALUE(ddp_hdrp->dst_net) == NET_VALUE(ddp_hdrp->src_net))) {
498: /*
499: * we're sending to ourselves
500: * so loop it back upstream
501: */
502: ddp_input(m, elapp);
503: return(0);
504: }
505: ATDISABLE(s, arpinp_lock);
506: AMT_LOOK(amt_ptr, *dest_at_addr, elapp);
507:
508:
509: if (amt_ptr) {
510: if (amt_ptr->m) {
511: /*
512: * there's already a packet awaiting transmission, so
513: * drop this one and let the upper layer retransmit
514: * later.
515: */
516: ATENABLE(s, arpinp_lock);
517: gbuf_freel(m);
518: return (0);
519: }
520: ATENABLE(s, arpinp_lock);
521: return (pat_output(elapp, m,
522: (unsigned char *)&amt_ptr->dest_addr, 0));
523: }
524: /*
525: * either this is a packet to be broadcasted, or the address
526: * resolution needs to be done
527: */
528: if (AARP_BROADCAST(ddp_hdrp, elapp)) {
529: gbuf_t *newm = 0;
530: struct etalk_addr *dest_addr;
531:
532: ATENABLE(s, arpinp_lock);
533: dest_addr = &elapp->cable_multicast_addr;
534: if (loop)
535: newm = (gbuf_t *)gbuf_dupm(m);
536:
537: if ( !(error = pat_output(elapp, m,
538: (unsigned char *)dest_addr, 0))) {
539: /*
540: * The message transmitted successfully;
541: * Also loop a copy back up since this
542: * is a broadcast message.
543: */
544: if (loop) {
545: if (newm == NULL)
546: return (error);
547: ddp_input(newm, elapp);
548: } /* endif loop */
549: } else {
550: if (newm)
551: gbuf_freem(newm);
552: }
553: return (error);
554: }
555: NEW_AMT(amt_ptr, *dest_at_addr,elapp);
556:
557: if (amt_ptr->m) {
558: /*
559: * no non-busy slots available in the cache, so
560: * drop this one and let the upper layer retransmit
561: * later.
562: */
563: ATENABLE(s, arpinp_lock);
564: gbuf_freel(m);
565: return (0);
566: }
567: amt_ptr->dest_at_addr = *dest_at_addr;
568: amt_ptr->dest_at_addr.atalk_unused = 0;
569:
570: amt_ptr->last_time = time.tv_sec;
571: amt_ptr->m = m;
572: amt_ptr->elapp = elapp;
573: amt_ptr->no_of_retries = 0;
574: ATENABLE(s, arpinp_lock);
575:
576: if ((error = aarp_send_req(amt_ptr))) {
577: aarp_delete_amt_info(amt_ptr);
578: return(error);
579: }
580: return(0);
581: }
582:
583:
584:
585: /****************************************************************************
586: * aarp_send_resp()
587: *
588: * remarks :
589: * The pkt being passed here is only to "look at". It should neither
590: * be used for transmission, nor freed. Its contents also must not be
591: * altered.
592: *
593: ****************************************************************************/
594: StaticProc int aarp_send_resp(elapp, pkt)
595: register at_ifaddr_t *elapp;
596: aarp_pkt_t *pkt;
597: {
598: register aarp_pkt_t *new_pkt;
599: register gbuf_t *m;
600:
601: if ((m = gbuf_alloc(AT_WR_OFFSET+sizeof(aarp_pkt_t), PRI_MED)) == NULL) {
602: return (-1);
603: }
604: gbuf_rinc(m,AT_WR_OFFSET);
605: gbuf_wset(m,0);
606:
607: new_pkt = (aarp_pkt_t *)gbuf_rptr(m);
608: aarp_build_pkt(new_pkt, elapp);
609:
610: new_pkt->aarp_cmd = AARP_RESP_CMD;
611: new_pkt->dest_addr = pkt->src_addr;
612:
613: new_pkt->dest_at_addr = pkt->src_at_addr;
614: new_pkt->dest_at_addr.atalk_unused = 0;
615:
616: ATALK_ASSIGN(new_pkt->src_at_addr, elapp->ifThisNode.s_net,
617: elapp->ifThisNode.s_node, 0);
618:
619: gbuf_winc(m,sizeof(aarp_pkt_t));
620: if (FDDI_OR_TOKENRING(elapp->aa_ifp->if_type))
621: ddp_bit_reverse(&new_pkt->dest_addr);
622:
623: if (pat_output(elapp, m, (unsigned char *)&new_pkt->dest_addr,
624: AARP_AT_TYPE))
625: return(-1);
626: return(0);
627: }
628:
629:
630:
631: /****************************************************************************
632: * aarp_send_req()
633: *
634: ****************************************************************************/
635:
636: StaticProc int aarp_send_req (amt_ptr)
637: register aarp_amt_t *amt_ptr;
638: {
639: register aarp_pkt_t *pkt;
640: register gbuf_t *m;
641: int error;
642:
643: if ((m = gbuf_alloc(AT_WR_OFFSET+sizeof(aarp_pkt_t), PRI_MED)) == NULL) {
644: return (ENOBUFS);
645: }
646: gbuf_rinc(m,AT_WR_OFFSET);
647: gbuf_wset(m,0);
648:
649: pkt = (aarp_pkt_t *)gbuf_rptr(m);
650: aarp_build_pkt(pkt, amt_ptr->elapp);
651:
652: pkt->aarp_cmd = AARP_REQ_CMD;
653: pkt->dest_addr = et_zeroaddr;
654: pkt->dest_at_addr = amt_ptr->dest_at_addr;
655: pkt->dest_at_addr.atalk_unused = 0;
656: ATALK_ASSIGN(pkt->src_at_addr, amt_ptr->elapp->ifThisNode.s_net,
657: amt_ptr->elapp->ifThisNode.s_node, 0);
658: gbuf_winc(m,sizeof(aarp_pkt_t));
659:
660: amt_ptr->no_of_retries++;
661: timeout(aarp_sched_req, amt_ptr, AARP_REQ_TIMER_INT);
662: amt_ptr->tmo = 1;
663: error = pat_output(amt_ptr->elapp, m,
664: (unsigned char *)&amt_ptr->elapp->cable_multicast_addr, AARP_AT_TYPE);
665: if (error)
666: {
667: untimeout(aarp_sched_req, amt_ptr);
668: amt_ptr->tmo = 0;
669: return(error);
670: }
671:
672: return(0);
673: }
674:
675:
676:
677: /****************************************************************************
678: * aarp_send_probe()
679: *
680: ****************************************************************************/
681: StaticProc int aarp_send_probe()
682: {
683: register aarp_pkt_t *pkt;
684: register gbuf_t *m;
685:
686: if ((m = gbuf_alloc(AT_WR_OFFSET+sizeof(aarp_pkt_t), PRI_MED)) == NULL) {
687: probe_cb.error = ENOBUFS;
688: return (-1);
689: }
690: gbuf_rinc(m,AT_WR_OFFSET);
691: gbuf_wset(m,0);
692: pkt = (aarp_pkt_t *)gbuf_rptr(m);
693: aarp_build_pkt(pkt, probe_cb.elapp);
694:
695: pkt->aarp_cmd = AARP_PROBE_CMD;
696: pkt->dest_addr = et_zeroaddr;
697:
698: ATALK_ASSIGN(pkt->src_at_addr, probe_cb.elapp->initial_addr.s_net,
699: probe_cb.elapp->initial_addr.s_node, 0);
700:
701: gbuf_winc(m,sizeof(aarp_pkt_t));
702:
703: probe_cb.error = pat_output(probe_cb.elapp, m,
704: (unsigned char *)&probe_cb.elapp->cable_multicast_addr, AARP_AT_TYPE);
705: if (probe_cb.error) {
706: return(-1);
707: }
708:
709: probing = PROBE_TENTATIVE;
710: probe_cb.no_of_retries++;
711: timeout(aarp_sched_probe, 0, AARP_PROBE_TIMER_INT);
712:
713: return(0);
714: }
715:
716:
717:
718: /****************************************************************************
719: * aarp_lru_entry()
720: *
721: ****************************************************************************/
722:
723: StaticProc aarp_amt_t *aarp_lru_entry(at)
724: register aarp_amt_t *at;
725: {
726: register aarp_amt_t *at_ret;
727: register int i;
728:
729: at_ret = at;
730:
731: for (i = 1, at++; i < AMT_BSIZ; i++, at++) {
732: if (at->last_time < at_ret->last_time && (at->m == NULL))
733: at_ret = at;
734: }
735: return(at_ret);
736: }
737:
738:
739:
740: /****************************************************************************
741: * aarp_glean_info()
742: *
743: ****************************************************************************/
744:
745: StaticProc int aarp_glean_info(pkt, elapp)
746: register aarp_pkt_t *pkt;
747: at_ifaddr_t *elapp;
748: {
749: register aarp_amt_t *amt_ptr;
750: int s;
751:
752: ATDISABLE(s, arpinp_lock);
753: AMT_LOOK(amt_ptr, pkt->src_at_addr, elapp);
754:
755: if (amt_ptr == NULL) {
756: /*
757: * amt entry for this address doesn't exist, add it to the cache
758: */
759: NEW_AMT(amt_ptr, pkt->src_at_addr,elapp);
760:
761: if (amt_ptr->m)
762: {
763: ATENABLE(s, arpinp_lock);
764: return(0); /* no non-busy slots available in the cache */
765: }
766: amt_ptr->dest_at_addr = pkt->src_at_addr;
767: amt_ptr->dest_at_addr.atalk_unused = 0;
768:
769: amt_ptr->last_time = (int)random();
770: }
771: /*
772: * update the ethernet address
773: * in either case
774: */
775: amt_ptr->dest_addr = pkt->src_addr;
776: if (FDDI_OR_TOKENRING(elapp->aa_ifp->if_type))
777: ddp_bit_reverse(&amt_ptr->dest_addr);
778: ATENABLE(s, arpinp_lock);
779: return(1);
780: }
781:
782:
783: /****************************************************************************
784: * aarp_delete_amt_info()
785: *
786: ****************************************************************************/
787:
788: StaticProc int aarp_delete_amt_info(amt_ptr)
789: register aarp_amt_t *amt_ptr;
790: {
791: register s;
792: register gbuf_t *m;
793: ATDISABLE(s, arpinp_lock);
794: amt_ptr->last_time = 0;
795: ATALK_ASSIGN(amt_ptr->dest_at_addr, 0, 0, 0);
796: amt_ptr->no_of_retries = 0;
797:
798: if (amt_ptr->m) {
799: m = amt_ptr->m;
800: amt_ptr->m = NULL;
801: ATENABLE(s, arpinp_lock);
802: gbuf_freel(m);
803: }
804: else
805: ATENABLE(s, arpinp_lock);
806: return(0);
807: }
808:
809:
810:
811: /****************************************************************************
812: * aarp_sched_probe()
813: *
814: ****************************************************************************/
815:
816: StaticProc int aarp_sched_probe()
817: {
818: if (probe_cb.no_of_retries != AARP_MAX_PROBE_RETRIES) {
819: if (aarp_send_probe() == -1)
820: AARPwakeup(&probe_cb);
821: } else {
822: probe_cb.error = 0;
823: AARPwakeup(&probe_cb);
824: }
825:
826: return(0);
827: }
828:
829:
830:
831: /****************************************************************************
832: * aarp_build_pkt()
833: *
834: ****************************************************************************/
835:
836: StaticProc void aarp_build_pkt(pkt, elapp)
837: register aarp_pkt_t *pkt;
838: at_ifaddr_t *elapp;
839: {
840: pkt->hardware_type = AARP_ETHER_HW_TYPE;
841: pkt->stack_type = AARP_AT_PROTO;
842: pkt->hw_addr_len = ETHERNET_ADDR_LEN;
843: pkt->stack_addr_len = AARP_AT_ADDR_LEN;
844: bcopy(elapp->xaddr, pkt->src_addr.etalk_addr_octet, sizeof(elapp->xaddr));
845: if (FDDI_OR_TOKENRING(elapp->aa_ifp->if_type))
846: ddp_bit_reverse(pkt->src_addr.etalk_addr_octet);
847: }
848:
849: /****************************************************************************
850: * aarp_sched_req()
851: *
852: ****************************************************************************/
853:
854: StaticProc int aarp_sched_req(amt_ptr)
855: register aarp_amt_t *amt_ptr;
856: {
857: int s;
858:
859: ATDISABLE(s, arpinp_lock);
860: if (amt_ptr->tmo == 0)
861: {
862: ATENABLE(s, arpinp_lock);
863: return(0);
864: }
865: if (amt_ptr->no_of_retries < AARP_MAX_REQ_RETRIES) {
866: ATENABLE(s, arpinp_lock);
867: if (aarp_send_req(amt_ptr) == 0)
868: return(0);
869: ATDISABLE(s, arpinp_lock);
870: }
871: ATENABLE(s, arpinp_lock);
872: aarp_delete_amt_info(amt_ptr);
873: return(0);
874: }
875:
876:
877:
878: /****************************************************************************
879: * aarp_get_rand_node()
880: *
881: ****************************************************************************/
882: StaticProc int aarp_get_rand_node(elapp)
883: at_ifaddr_t *elapp;
884: {
885: register u_char node;
886:
887: /*
888: * generate a starting node number in the range 1 thru 0xfd.
889: * we use this as the starting probe point for a given net
890: * To generate a different node number each time we call
891: * aarp_get_next_node
892: */
893: node = ((u_char)(random() & 0xff)) % 0xfd + 2;
894:
895: elapp->initial_addr.s_node = node;
896: return(0);
897: }
898:
899:
900:
901: StaticProc int aarp_get_next_node(elapp)
902: at_ifaddr_t *elapp;
903: {
904: register u_char node = elapp->initial_addr.s_node;
905:
906: /*
907: * return the next node number in the range 1 thru 0xfd.
908: */
909: node = (node == 0xfd) ? (1) : (node+1);
910:
911: elapp->initial_addr.s_node = node;
912: return(0);
913: }
914:
915:
916:
917:
918:
919: /****************************************************************************
920: * aarp_get_rand_net()
921: *
922: ****************************************************************************/
923: StaticProc int aarp_get_rand_net(elapp)
924: register at_ifaddr_t *elapp;
925: {
926: register at_net_al last_net, new_net;
927:
928: if (elapp->ifThisCableStart) {
929: last_net = elapp->initial_addr.s_net;
930: /*
931: * the range of network numbers valid for this
932: * cable is known. Try to choose a number from
933: * this range only.
934: */
935: new_net= ((at_net_al)random() & 0xffff);
936: /* two-byte random number generated... now fit it in
937: * the prescribed range
938: */
939: new_net = new_net % (unsigned) (elapp->ifThisCableEnd -
940: elapp->ifThisCableStart + 1)
941: + elapp->ifThisCableStart;
942:
943: if (new_net == last_net) {
944: if (new_net == elapp->ifThisCableEnd)
945: new_net = elapp->ifThisCableStart;
946: else
947: new_net++;
948: }
949: elapp->initial_addr.s_net = new_net;
950: } else {
951: /* The range of valid network numbers for this cable
952: * is not known... choose a network number from
953: * startup range.
954: */
955: last_net = (elapp->initial_addr.s_net & 0x00ff);
956: new_net = (at_net_al)random() & 0x00ff;
957:
958: if (new_net == last_net)
959: new_net++;
960: if (new_net == 0xff)
961: new_net = 0;
962: elapp->initial_addr.s_net = (DDP_STARTUP_LOW | new_net);
963: }
964: return(0);
965: }
966:
967:
968: int getAarpTableSize(elapId)
969: int elapId; /* elap_specifics array index (should be
970: * changed when we add a non-ethernet type
971: * of I/F to the mix. Unused for now.
972: */
973: {
974: return(AMTSIZE);
975: }
976:
977: int getPhysAddrSize(elapId)
978: int elapId; /* elap_specifics array index (should be
979: * changed when we add a non-ethernet type
980: * of I/F to the mix. Unused for now.
981: */
982: {
983: return(ETHERNET_ADDR_LEN);
984: }
985:
986: #define ENTRY_SIZE sizeof(struct atalk_addr) + sizeof(struct etalk_addr)
987:
988: snmpAarpEnt_t *getAarp(elapId)
989: int *elapId; /* I/F table to retrieve & table
990: size entries on return */
991:
992: /* gets aarp table for specified interface and builds
993: a table in SNMP expected format. Returns pointer to said
994: table and sets elapId to byte size of used portion of table
995: */
996: {
997: int i, cnt=0;
998: aarp_amt_t *amtp;
999: static snmpAarpEnt_t snmp[AMTSIZE];
1000: snmpAarpEnt_t *snmpp;
1001:
1002:
1003: if (*elapId <0 || *elapId >= IF_TOTAL_MAX)
1004: return NULL;
1005:
1006:
1007: for (i=0, amtp = &(aarp_table[*elapId]->et_aarp_amt[0]), snmpp = snmp;
1008: i < AMTSIZE; i++,amtp++) {
1009:
1010: /* last_time will be 0 if entry was never used */
1011: if (amtp->last_time) {
1012: /* copy just network & mac address.
1013: * For speed, we assume that the atalk_addr
1014: * & etalk_addr positions in the aarp_amt_t struct
1015: * has not changed and copy both at once
1016: */
1017: bcopy(&amtp->dest_at_addr, &snmpp->ap_ddpAddr, ENTRY_SIZE);
1018: snmpp++;
1019: cnt++;
1020:
1021: }
1022: }
1023: *elapId = cnt;
1024: return(snmp);
1025: }
1026: /*#endif *//* COMMENTED_OUT */
1027:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.