]> git.saurik.com Git - apple/xnu.git/blob - bsd/netat/ddp_aarp.c
projects / apple / xnu.git / blob
? search:


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