?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fetch.9: Minor fixes.
[dragonfly.git] / sys / netproto / atm / spans / spans_arp.c
blob0f41d3eebbd9e893f0660bf64d3e9789b2c469b4
1 /*
2 *
3 * ===================================
4 * HARP | Host ATM Research Platform
5 * ===================================
6 *
7 *
8 * This Host ATM Research Platform ("HARP") file (the "Software") is
9 * made available by Network Computing Services, Inc. ("NetworkCS")
10 * "AS IS". NetworkCS does not provide maintenance, improvements or
11 * support of any kind.
12 *
13 * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14 * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15 * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16 * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17 * In no event shall NetworkCS be responsible for any damages, including
18 * but not limited to consequential damages, arising from or relating to
19 * any use of the Software or related support.
20 *
21 * Copyright 1994-1998 Network Computing Services, Inc.
22 *
23 * Copies of this Software may be made, however, the above copyright
24 * notice must be reproduced on all copies.
25 *
26 * @(#) $FreeBSD: src/sys/netatm/spans/spans_arp.c,v 1.7 2000/01/15 20:34:55 mks Exp $
27 * @(#) $DragonFly: src/sys/netproto/atm/spans/spans_arp.c,v 1.9 2006/01/14 13:36:39 swildner Exp $
28 */
29
30 /*
31 * SPANS Signalling Manager
32 * ---------------------------
33 *
34 * SPANS CLS - ARP support
35 *
36 */
37
38 #include <netproto/atm/kern_include.h>
39
40 #include <netproto/atm/ipatm/ipatm_var.h>
41 #include <netproto/atm/ipatm/ipatm_serv.h>
42 #include "spans_xdr.h"
43 #include "spans_var.h"
44 #include "spans_cls.h"
45
46 /*
47 * Global variables
48 */
49 struct spansarp *spansarp_arptab[SPANSARP_HASHSIZ] = {NULL};
50
51
52 /*
53 * Local functions
54 */
55 static int spansarp_request (struct spansarp *);
56 static void spansarp_aging (struct atm_time *);
57 static void spansarp_retry (struct atm_time *);
58
59 /*
60 * Local variables
61 */
62 static struct atm_time spansarp_timer = {0, 0}; /* Aging timer */
63 static struct atm_time spansarp_rtimer = {0, 0}; /* Retry timer */
64
65 static struct spansarp *spansarp_retry_head = NULL; /* Retry chain */
66
67 static struct sp_info spansarp_pool = {
68 "spans arp pool", /* si_name */
69 sizeof(struct spansarp), /* si_blksiz */
70 10, /* si_blkcnt */
71 100 /* si_maxallow */
72 };
73
74
75 /*
76 * Process a new outgoing SVC requiring SPANS ARP support
77 *
78 * This function is called by an endpoint wishing to resolve a destination
79 * IP address to an ATM address in order to open an SVC to that destination.
80 * If a valid mapping is already in our cache, then we just tell the caller
81 * about it and that's that. Otherwise, we have to allocate a new arp entry
82 * and issue a query for the mapping.
83 *
84 * Arguments:
85 * ivp pointer to SVC's IPVCC control block
86 * dst pointer to destination IP address
87 *
88 * Returns:
89 * MAP_VALID - Got the answer, returned via iv_arpent field.
90 * MAP_PROCEEDING - OK so far, querying for peer's mapping
91 * MAP_FAILED - error, unable to allocate resources
92 *
93 */
94 int
95 spansarp_svcout(struct ipvcc *ivp, struct in_addr *dst)
96 {
97 struct spanscls *clp;
98 struct spansarp *sap;
99
100 ivp->iv_arpent = NULL;
101
102 /*
103 * Lookup destination address
104 */
105 crit_enter();
106 SPANSARP_LOOKUP(dst->s_addr, sap);
107
108 if (sap) {
109 /*
110 * Link this vcc to entry queue
111 */
112 LINK2TAIL(ivp, struct ipvcc, sap->sa_ivp, iv_arpnext);
113
114 /*
115 * If entry is valid, we're done
116 */
117 if (sap->sa_flags & SAF_VALID) {
118 ivp->iv_arpent = (struct arpmap *)sap;
119 crit_exit();
120 return (MAP_VALID);
121 }
122
123 /*
124 * We're already looking for this address
125 */
126 crit_exit();
127 return (MAP_PROCEEDING);
128 }
129
130 /*
131 * Need a new arp entry - first, find the cls instance
132 * corresponding to the requestor's IP interface.
133 */
134 for (clp = spanscls_head; clp; clp = clp->cls_next) {
135 if (clp->cls_ipnif == ivp->iv_ipnif)
136 break;
137 }
138 if (clp == NULL) {
139 crit_exit();
140 return (MAP_FAILED);
141 }
142
143 /*
144 * Now get the new arp entry
145 */
146 sap = (struct spansarp *)atm_allocate(&spansarp_pool);
147 if (sap == NULL) {
148 crit_exit();
149 return (MAP_FAILED);
150 }
151
152 /*
153 * Get entry set up
154 */
155 sap->sa_dstip.s_addr = dst->s_addr;
156 sap->sa_dstatm.address_format = T_ATM_ABSENT;
157 sap->sa_dstatm.address_length = 0;
158 sap->sa_dstatmsub.address_format = T_ATM_ABSENT;
159 sap->sa_dstatmsub.address_length = 0;
160 sap->sa_cls = clp;
161 sap->sa_origin = SAO_LOOKUP;
162
163 /*
164 * Link ipvcc to arp entry for later notification
165 */
166 LINK2TAIL(ivp, struct ipvcc, sap->sa_ivp, iv_arpnext);
167
168 /*
169 * Add arp entry to table
170 */
171 SPANSARP_ADD(sap);
172
173 /*
174 * Add arp entry to retry list and start retry timer if needed
175 */
176 LINK2TAIL(sap, struct spansarp, spansarp_retry_head, sa_rnext);
177 if ((spansarp_rtimer.ti_flag & TIF_QUEUED) == 0)
178 atm_timeout(&spansarp_rtimer, SPANSARP_RETRY, spansarp_retry);
179
180 /*
181 * Issue arp request for this address
182 */
183 spansarp_request(sap);
184
185 crit_exit();
186 return (MAP_PROCEEDING);
187 }
188
189
190 /*
191 * Process a new incoming SVC requiring SPANS ARP support
192 *
193 * This function is called by an endpoint wishing to resolve a destination
194 * ATM address to its IP address for an incoming call in order to allow a
195 * bi-directional flow of IP packets on the SVC.
196 *
197 * SPANS ARP does not provide reverse mapping facilities and only supports
198 * uni-directional SVCs. Thus, we lie a little to IP and always return a
199 * MAP_PROCEEDING indication, but we will never later notify IP of a
200 * MAP_VALID condition.
201 *
202 * Arguments:
203 * ivp pointer to SVC's IPVCC control block
204 * dst pointer to destination ATM address
205 * dstsub pointer to destination ATM subaddress
206 *
207 * Returns:
208 * MAP_VALID - Got the answer, returned via iv_arpent field.
209 * MAP_PROCEEDING - OK so far, querying for peer's mapping
210 * MAP_FAILED - error, unable to allocate resources
211 *
212 */
213 int
214 spansarp_svcin(struct ipvcc *ivp, Atm_addr *dst, Atm_addr *dstsub)
215 {
216 /*
217 * Clear ARP entry field
218 */
219 ivp->iv_arpent = NULL;
220
221 return (MAP_PROCEEDING);
222 }
223
224
225 /*
226 * SPANS ARP SVC activation notification
227 *
228 * This function is called when a previously opened SVC has successfully
229 * been connected.
230 *
231 * Arguments:
232 * ivp pointer to SVC's IPVCC control block
233 *
234 * Returns:
235 * 0 activation processing successful
236 * errno activation failed - reason indicated
237 *
238 */
239 int
240 spansarp_svcactive(struct ipvcc *ivp)
241 {
242 struct spansarp *sap;
243
244 crit_enter();
245 /*
246 * Find an entry for the destination address
247 */
248 SPANSARP_LOOKUP(ivp->iv_dst.s_addr, sap);
249 if (sap) {
250 /*
251 * IP is finished with entry, so remove IP VCC from chain
252 */
253 UNLINK(ivp, struct ipvcc, sap->sa_ivp, iv_arpnext);
254 ivp->iv_arpent = NULL;
255
256 /*
257 * This seems like a reasonable reason to refresh the entry
258 */
259 sap->sa_reftime = 0;
260 }
261 crit_exit();
262 return (0);
263 }
264
265
266 /*
267 * SPANS ARP supported VCC is closing
268 *
269 * This function is called just prior to a user closing a VCC which
270 * supports SPANS ARP. We'll sever our links to the VCC and then
271 * figure out how much more cleanup we need to do for now.
272 *
273 * Arguments:
274 * ivp pointer to VCC's IPVCC control block
275 *
276 * Returns:
277 * none
278 *
279 */
280 void
281 spansarp_vcclose(struct ipvcc *ivp)
282 {
283 struct spansarp *sap;
284
285 crit_enter();
286 /*
287 * Get spansarp entry
288 */
289 SPANSARP_LOOKUP(ivp->iv_dst.s_addr, sap);
290 if (sap == NULL) {
291 crit_exit();
292 return;
293 }
294
295 /*
296 * Remove IP VCC from chain
297 */
298 UNLINK(ivp, struct ipvcc, sap->sa_ivp, iv_arpnext);
299 ivp->iv_arpent = NULL;
300
301 /*
302 * If entry is currently valid or in use, not much else for us to do
303 */
304 if ((sap->sa_flags & (SAF_VALID | SAF_LOCKED)) ||
305 (sap->sa_origin >= SAO_PERM)) {
306 crit_exit();
307 return;
308 }
309
310 /*
311 * If there are still other VCCs waiting, exit
312 */
313 if (sap->sa_ivp) {
314 crit_exit();
315 return;
316 }
317
318 /*
319 * Noone else waiting, so remove entry from the retry chain
320 */
321 UNLINK(sap, struct spansarp, spansarp_retry_head, sa_rnext);
322
323 /*
324 * Free entry
325 */
326 SPANSARP_DELETE(sap);
327 atm_free((caddr_t)sap);
328 crit_exit();
329 }
330
331
332 /*
333 * Process module unloading notification
334 *
335 * Called whenever the spans module is about to be unloaded. All signalling
336 * instances will have been previously detached. All spansarp resources
337 * must be freed now.
338 *
339 * Arguments:
340 * none
341 *
342 * Returns:
343 * none
344 *
345 */
346 void
347 spansarp_stop(void)
348 {
349 int i;
350
351 /*
352 * Make sure the arp table is empty
353 */
354 for (i = 0; i < SPANSARP_HASHSIZ; i++) {
355 if (spansarp_arptab[i] != NULL)
356 panic("spansarp_stop: arp table not empty");
357 }
358
359 /*
360 * Cancel timers
361 */
362 atm_untimeout(&spansarp_timer);
363 atm_untimeout(&spansarp_rtimer);
364
365 /*
366 * Free our storage pools
367 */
368 atm_release_pool(&spansarp_pool);
369 }
370
371
372 /*
373 * Process IP Network Interface Activation
374 *
375 * Called whenever an IP network interface becomes active.
376 *
377 * Called from a critical section.
378 *
379 * Arguments:
380 * clp pointer to CLS interface
381 *
382 * Returns:
383 * none
384 *
385 */
386 void
387 spansarp_ipact(struct spanscls *clp)
388 {
389 /*
390 * Make sure aging timer is running
391 */
392 if ((spansarp_timer.ti_flag & TIF_QUEUED) == 0)
393 atm_timeout(&spansarp_timer, SPANSARP_AGING, spansarp_aging);
394 }
395
396
397 /*
398 * Process IP Network Interface Deactivation
399 *
400 * Called whenever an IP network interface becomes inactive.
401 *
402 * Called from a critical section.
403 *
404 * Arguments:
405 * clp pointer to CLS interface
406 *
407 * Returns:
408 * none
409 *
410 */
411 void
412 spansarp_ipdact(struct spanscls *clp)
413 {
414 struct spanscls *clp2;
415 struct spansarp *sap, *snext;
416 int i;
417
418 /*
419 * Delete all interface entries
420 */
421 for (i = 0; i < SPANSARP_HASHSIZ; i++) {
422 for (sap = spansarp_arptab[i]; sap; sap = snext) {
423 snext = sap->sa_next;
424
425 /*
426 * Clean up entries for this interface
427 */
428 if (sap->sa_cls != clp)
429 continue;
430
431 /*
432 * All VCCs better be gone by now
433 */
434 if (sap->sa_ivp)
435 panic("spansarp_ipdact: entry not empty");
436
437 /*
438 * Remove entry from the retry chain
439 */
440 UNLINK(sap, struct spansarp,
441 spansarp_retry_head, sa_rnext);
442
443 /*
444 * Delete entry from arp table
445 */
446 SPANSARP_DELETE(sap);
447 atm_free((caddr_t)sap);
448 }
449 }
450
451 /*
452 * Stop aging timer if this is the last active interface
453 */
454 for (clp2 = spanscls_head; clp2; clp2 = clp2->cls_next) {
455 if ((clp != clp2) && (clp2->cls_ipnif))
456 break;
457 }
458 if (clp2 == NULL)
459 atm_untimeout(&spansarp_timer);
460 }
461
462
463 /*
464 * Issue a SPANS ARP request packet
465 *
466 * Arguments:
467 * sap pointer to arp table entry
468 *
469 * Returns:
470 * 0 packet was successfully sent
471 * else unable to send packet
472 *
473 */
474 static int
475 spansarp_request(struct spansarp *sap)
476 {
477 struct spanscls *clp;
478 struct spans *spp;
479 struct spanscls_hdr *chp;
480 struct spansarp_hdr *ahp;
481 KBuffer *m;
482 struct ip_nif *inp;
483 int err;
484
485 clp = sap->sa_cls;
486 spp = clp->cls_spans;
487 inp = clp->cls_ipnif;
488
489 /*
490 * Make sure CLS VCC is open and that we know our addresses
491 */
492 if (clp->cls_state != CLS_OPEN)
493 return (1);
494 if (spp->sp_addr.address_format != T_ATM_SPANS_ADDR)
495 return (1);
496 if (inp == NULL)
497 return (1);
498
499 /*
500 * Get a buffer for pdu
501 */
502 KB_ALLOCPKT(m, ARP_PACKET_LEN, KB_F_NOWAIT, KB_T_DATA);
503 if (m == NULL)
504 return (1);
505
506 /*
507 * Place pdu at end of buffer
508 */
509 KB_PLENSET(m, ARP_PACKET_LEN);
510 KB_TAILALIGN(m, ARP_PACKET_LEN);
511 KB_DATASTART(m, chp, struct spanscls_hdr *);
512 ahp = (struct spansarp_hdr *)(chp + 1);
513
514 /*
515 * Build headers
516 */
517 spans_addr_copy(&spans_bcastaddr, &chp->ch_dst);
518 spans_addr_copy(spp->sp_addr.address, &chp->ch_src);
519 *(u_int *)&chp->ch_proto = *(u_int *)&spanscls_hdr.ch_proto;
520 *(u_int *)&chp->ch_dsap = *(u_int *)&spanscls_hdr.ch_dsap;
521 *(u_short *)&chp->ch_oui[1] = *(u_short *)&spanscls_hdr.ch_oui[1];
522 chp->ch_pid = htons(ETHERTYPE_ARP);
523
524
525 /*
526 * Build ARP packet
527 */
528 ahp->ah_hrd = htons(ARP_SPANS);
529 ahp->ah_pro = htons(ETHERTYPE_IP);
530 ahp->ah_hln = sizeof(spans_addr);
531 ahp->ah_pln = sizeof(struct in_addr);
532 ahp->ah_op = htons(ARP_REQUEST);
533 spans_addr_copy(spp->sp_addr.address, &ahp->ah_sha);
534 KM_COPY(&(IA_SIN(inp->inf_addr)->sin_addr), ahp->ah_spa,
535 sizeof(struct in_addr));
536 KM_COPY(&sap->sa_dstip, ahp->ah_tpa, sizeof(struct in_addr));
537
538 /*
539 * Now, send the pdu via the CLS service
540 */
541 err = atm_cm_cpcs_data(clp->cls_conn, m);
542 if (err) {
543 KB_FREEALL(m);
544 return (1);
545 }
546
547 return (0);
548 }
549
550
551 /*
552 * Process a SPANS ARP input packet
553 *
554 * Arguments:
555 * clp pointer to interface CLS control block
556 * m pointer to input packet buffer chain
557 *
558 * Returns:
559 * none
560 *
561 */
562 void
563 spansarp_input(struct spanscls *clp, KBuffer *m)
564 {
565 struct spans *spp = clp->cls_spans;
566 struct spanscls_hdr *chp;
567 struct spansarp_hdr *ahp;
568 struct spansarp *sap;
569 struct ip_nif *inp = clp->cls_ipnif;
570 struct in_addr in_me, in_src, in_targ;
571 int err;
572
573 /*
574 * Make sure IP interface has been activated
575 */
576 if (inp == NULL)
577 goto free;
578
579 /*
580 * Get the packet together
581 */
582 if (KB_LEN(m) < ARP_PACKET_LEN) {
583 KB_PULLUP(m, ARP_PACKET_LEN, m);
584 if (m == 0)
585 return;
586 }
587 KB_DATASTART(m, chp, struct spanscls_hdr *);
588 ahp = (struct spansarp_hdr *)(chp + 1);
589
590 KM_COPY(ahp->ah_spa, &in_src, sizeof(struct in_addr));
591 KM_COPY(ahp->ah_tpa, &in_targ, sizeof(struct in_addr));
592 KM_COPY(&(IA_SIN(inp->inf_addr)->sin_addr), &in_me,
593 sizeof(struct in_addr));
594
595 /*
596 * Initial packet verification
597 */
598 if ((ahp->ah_hrd != htons(ARP_SPANS)) ||
599 (ahp->ah_pro != htons(ETHERTYPE_IP)))
600 goto free;
601
602 /*
603 * Validate source addresses
604 * can't be from hardware broadcast
605 * can't be from me
606 */
607 if (!spans_addr_cmp(&ahp->ah_sha, &spans_bcastaddr))
608 goto free;
609 if (!spans_addr_cmp(&ahp->ah_sha, spp->sp_addr.address))
610 goto free;
611 if (in_src.s_addr == in_me.s_addr) {
612 log(LOG_ERR,
613 "duplicate IP address sent from spans address %s\n",
614 spans_addr_print(&ahp->ah_sha));
615 in_targ = in_me;
616 goto chkop;
617 }
618
619 /*
620 * If source IP address is from unspecified or broadcast addresses,
621 * don't bother updating arp table, but answer possible requests
622 */
623 if (in_broadcast(in_src, &inp->inf_nif->nif_if))
624 goto chkop;
625
626 /*
627 * Update arp table with source address info
628 */
629 crit_enter();
630 SPANSARP_LOOKUP(in_src.s_addr, sap);
631 if (sap) {
632 /*
633 * Found an entry for the source, but don't
634 * update permanent entries
635 */
636 if (sap->sa_origin != SAO_PERM) {
637
638 /*
639 * Update the entry
640 */
641 sap->sa_dstatm.address_format = T_ATM_SPANS_ADDR;
642 sap->sa_dstatm.address_length = sizeof(spans_addr);
643 spans_addr_copy(&ahp->ah_sha, sap->sa_dstatm.address);
644 sap->sa_cls = clp;
645 sap->sa_reftime = 0;
646 if ((sap->sa_flags & SAF_VALID) == 0) {
647 /*
648 * Newly valid entry, notify waiting users
649 */
650 struct ipvcc *ivp, *inext;
651
652 sap->sa_flags |= SAF_VALID;
653 for (ivp = sap->sa_ivp; ivp; ivp = inext) {
654 inext = ivp->iv_arpnext;
655
656 ivp->iv_arpent = (struct arpmap *)sap;
657 (*inp->inf_arpnotify)(ivp, MAP_VALID);
658 }
659
660 /*
661 * Remove ourselves from the retry chain
662 */
663 UNLINK(sap, struct spansarp,
664 spansarp_retry_head, sa_rnext);
665 }
666 }
667
668 } else if (in_targ.s_addr == in_me.s_addr) {
669 /*
670 * Source unknown and we're the target - add new entry
671 */
672 sap = (struct spansarp *)atm_allocate(&spansarp_pool);
673 if (sap) {
674 sap->sa_dstip.s_addr = in_src.s_addr;
675 sap->sa_dstatm.address_format = T_ATM_SPANS_ADDR;
676 sap->sa_dstatm.address_length = sizeof(spans_addr);
677 spans_addr_copy(&ahp->ah_sha, sap->sa_dstatm.address);
678 sap->sa_dstatmsub.address_format = T_ATM_ABSENT;
679 sap->sa_dstatmsub.address_length = 0;
680 sap->sa_cls = clp;
681 sap->sa_flags = SAF_VALID;
682 sap->sa_origin = SAO_LOOKUP;
683 SPANSARP_ADD(sap);
684 }
685 }
686 crit_exit();
687
688 chkop:
689 /*
690 * If this is a request for our address, send a reply
691 */
692 if (ntohs(ahp->ah_op) != ARP_REQUEST)
693 goto free;
694 if (in_targ.s_addr != in_me.s_addr)
695 goto free;
696
697 spans_addr_copy(&chp->ch_src, &chp->ch_dst);
698 spans_addr_copy(spp->sp_addr.address, &chp->ch_src);
699 ahp->ah_op = htons(ARP_REPLY);
700 spans_addr_copy(&ahp->ah_sha, &ahp->ah_tha);
701 spans_addr_copy(spp->sp_addr.address, &ahp->ah_sha);
702 KM_COPY(ahp->ah_spa, ahp->ah_tpa, sizeof(struct in_addr));
703 KM_COPY(&in_me, ahp->ah_spa, sizeof(struct in_addr));
704
705 err = atm_cm_cpcs_data(clp->cls_conn, m);
706 if (err)
707 goto free;
708 return;
709
710 free:
711 KB_FREEALL(m);
712 }
713
714
715 /*
716 * Process a SPANS ARP aging timer tick
717 *
718 * This function is called every SPANSARP_AGING seconds, in order to age
719 * all the arp table entries.
720 *
721 * Called from a critical section.
722 *
723 * Arguments:
724 * tip pointer to spansarp aging timer control block
725 *
726 * Returns:
727 * none
728 *
729 */
730 static void
731 spansarp_aging(struct atm_time *tip)
732 {
733 struct spansarp *sap, *snext;
734 struct ipvcc *ivp, *inext;
735 int i;
736
737
738 /*
739 * Schedule next timeout
740 */
741 atm_timeout(&spansarp_timer, SPANSARP_AGING, spansarp_aging);
742
743 /*
744 * Run through arp table bumping each entry's aging timer.
745 */
746 for (i = 0; i < SPANSARP_HASHSIZ; i++) {
747 for (sap = spansarp_arptab[i]; sap; sap = snext) {
748 snext = sap->sa_next;
749
750 /*
751 * Permanent (manually installed) entries aren't aged
752 */
753 if (sap->sa_origin == SAO_PERM)
754 continue;
755
756 /*
757 * See if entry is valid and over-aged
758 */
759 if ((sap->sa_flags & SAF_VALID) == 0)
760 continue;
761 if (++sap->sa_reftime < SPANSARP_MAXAGE)
762 continue;
763
764 /*
765 * Entry is now invalid, tell IP/ATM about it
766 */
767 sap->sa_flags |= SAF_LOCKED;
768 for (ivp = sap->sa_ivp; ivp; ivp = inext) {
769 inext = ivp->iv_arpnext;
770 (*ivp->iv_ipnif->inf_arpnotify)
771 (ivp, MAP_INVALID);
772 }
773 sap->sa_flags &= ~(SAF_LOCKED | SAF_VALID);
774
775 if (sap->sa_ivp != NULL) {
776 /*
777 * Somebody still cares, so add the arp
778 * entry to the retry list.
779 */
780 LINK2TAIL(sap, struct spansarp,
781 spansarp_retry_head, sa_rnext);
782 if ((spansarp_rtimer.ti_flag & TIF_QUEUED) == 0)
783 atm_timeout(&spansarp_rtimer,
784 SPANSARP_RETRY, spansarp_retry);
785
786 /*
787 * Issue arp request for this address
788 */
789 spansarp_request(sap);
790
791 } else {
792 /*
793 * Delete unused entry
794 */
795 SPANSARP_DELETE(sap);
796 atm_free((caddr_t)sap);
797 }
798 }
799 }
800 }
801
802
803 /*
804 * Process a SPANS ARP retry timer tick
805 *
806 * This function is called every SPANSARP_RETRY seconds, in order to retry
807 * awaiting arp resolution requests. We will retry requests indefinitely,
808 * assuming that IP will set a timeout to close the VCC(s) requesting the
809 * failing address resolution.
810 *
811 * Called from a critical section.
812 *
813 * Arguments:
814 * tip pointer to spansarp retry timer control block
815 *
816 * Returns:
817 * none
818 *
819 */
820 static void
821 spansarp_retry(struct atm_time *tip)
822 {
823 struct spansarp *sap;
824
825
826 /*
827 * See if there's work to do
828 */
829 if (spansarp_retry_head == NULL) {
830 return;
831 }
832
833 /*
834 * Schedule next timeout
835 */
836 atm_timeout(&spansarp_rtimer, SPANSARP_RETRY, spansarp_retry);
837
838 /*
839 * Run through retry chain, (re)issuing arp requests.
840 */
841 for (sap = spansarp_retry_head; sap; sap = sap->sa_next) {
842
843 /*
844 * Send another arp request
845 */
846 spansarp_request(sap);
847 }
848 }
849
850
851 /*
852 * SPANS ARP IOCTL support
853 *
854 * Function will be called from a critical section.
855 *
856 * Arguments:
857 * code PF_ATM sub-operation code
858 * data pointer to code specific parameter data area
859 * arg1 pointer to code specific argument
860 *
861 * Returns:
862 * 0 request procesed
863 * errno error processing request - reason indicated
864 *
865 */
866 int
867 spansarp_ioctl(int code, caddr_t data, caddr_t arg1)
868 {
869 struct atmaddreq *aap;
870 struct atmdelreq *adp;
871 struct atminfreq *aip;
872 struct spans *spp;
873 struct spanscls *clp;
874 struct spansarp *sap;
875 struct air_arp_rsp aar;
876 struct ip_nif *inp;
877 struct ipvcc *ivp, *inext;
878 struct in_addr ip;
879 u_long dst;
880 int err = 0, i, buf_len;
881 caddr_t buf_addr;
882
883
884 switch (code) {
885
886 case AIOCS_ADD_ARP:
887 /*
888 * Add a permanent ARP mapping
889 */
890 aap = (struct atmaddreq *)data;
891 clp = (struct spanscls *)arg1;
892 inp = clp->cls_ipnif;
893 if ((aap->aar_arp_addr.address_format != T_ATM_SPANS_ADDR) ||
894 (aap->aar_arp_origin != ARP_ORIG_PERM)) {
895 err = EINVAL;
896 break;
897 }
898 ip = SATOSIN(&aap->aar_arp_dst)->sin_addr;
899
900 /*
901 * See if we already have an entry for this IP address
902 */
903 SPANSARP_LOOKUP(ip.s_addr, sap);
904 if (sap == NULL) {
905 /*
906 * No, get a new arp entry
907 */
908 sap = (struct spansarp *)atm_allocate(&spansarp_pool);
909 if (sap == NULL) {
910 err = ENOMEM;
911 break;
912 }
913
914 /*
915 * Get entry set up
916 */
917 sap->sa_dstip = ip;
918 ATM_ADDR_COPY(&aap->aar_arp_addr, &sap->sa_dstatm);
919 sap->sa_dstatmsub.address_format = T_ATM_ABSENT;
920 sap->sa_dstatmsub.address_length = 0;
921 sap->sa_cls = clp;
922 sap->sa_flags |= SAF_VALID;
923 sap->sa_origin = SAO_PERM;
924
925 /*
926 * Add entry to table
927 */
928 SPANSARP_ADD(sap);
929 break;
930
931 }
932
933 /*
934 * See if we're attempting to change the ATM address for
935 * this cached entry
936 */
937 if ((sap->sa_dstatm.address_format != T_ATM_ABSENT) &&
938 (!ATM_ADDR_EQUAL(&aap->aar_arp_addr, &sap->sa_dstatm) ||
939 (clp != sap->sa_cls))) {
940
941 /*
942 * Yes, notify IP/ATM that a mapping change has
943 * occurred. IP/ATM will close any VCC's which
944 * aren't waiting for this map.
945 */
946 sap->sa_flags |= SAF_LOCKED;
947 for (ivp = sap->sa_ivp; ivp; ivp = inext) {
948 inext = ivp->iv_arpnext;
949 (*inp->inf_arpnotify)(ivp, MAP_CHANGED);
950 }
951 sap->sa_flags &= ~SAF_LOCKED;
952 }
953
954 /*
955 * Update the cached entry with the new data
956 */
957 ATM_ADDR_COPY(&aap->aar_arp_addr, &sap->sa_dstatm);
958 sap->sa_cls = clp;
959
960 /*
961 * If this entry isn't valid, notify anyone who might
962 * be interested
963 */
964 if ((sap->sa_flags & SAF_VALID) == 0) {
965
966 sap->sa_flags |= SAF_LOCKED;
967 for (ivp = sap->sa_ivp; ivp; ivp = inext) {
968 inext = ivp->iv_arpnext;
969 (*inp->inf_arpnotify)(ivp, MAP_VALID);
970 }
971 sap->sa_flags &= ~SAF_LOCKED;
972 }
973
974 /*
975 * Remove this entry from the retry chain
976 */
977 UNLINK(sap, struct spansarp, spansarp_retry_head, sa_rnext);
978
979 /*
980 * Mark the entry as permanent
981 */
982 sap->sa_flags |= SAF_VALID;
983 sap->sa_origin = SAO_PERM;
984 break;
985
986 case AIOCS_DEL_ARP:
987 /*
988 * Delete an ARP mapping
989 */
990 adp = (struct atmdelreq *)data;
991 clp = (struct spanscls *)arg1;
992 ip = SATOSIN(&adp->adr_arp_dst)->sin_addr;
993
994 /*
995 * Now find the entry to be deleted
996 */
997 SPANSARP_LOOKUP(ip.s_addr, sap);
998 if (sap == NULL) {
999 err = ENOENT;
1000 break;
1001 }
1002
1003 /*
1004 * Notify all VCCs using this entry that they must finish
1005 * up now.
1006 */
1007 sap->sa_flags |= SAF_LOCKED;
1008 for (ivp = sap->sa_ivp; ivp; ivp = inext) {
1009 inext = ivp->iv_arpnext;
1010 (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_FAILED);
1011 }
1012
1013 /*
1014 * Now free up the entry
1015 */
1016 UNLINK(sap, struct spansarp, spansarp_retry_head, sa_rnext);
1017 SPANSARP_DELETE(sap);
1018 atm_free((caddr_t)sap);
1019 break;
1020
1021 case AIOCS_INF_ARP:
1022 /*
1023 * Get ARP table information
1024 */
1025 aip = (struct atminfreq *)data;
1026 spp = (struct spans *)arg1;
1027
1028 if (aip->air_arp_addr.sa_family != AF_INET)
1029 break;
1030 dst = SATOSIN(&aip->air_arp_addr)->sin_addr.s_addr;
1031
1032 buf_addr = aip->air_buf_addr;
1033 buf_len = aip->air_buf_len;
1034
1035 if ((clp = spp->sp_cls) == NULL)
1036 break;
1037
1038 /*
1039 * Run through entire arp table
1040 */
1041 for (i = 0; i < SPANSARP_HASHSIZ; i++) {
1042 for (sap = spansarp_arptab[i]; sap;
1043 sap = sap->sa_next) {
1044 /*
1045 * We only want entries learned
1046 * from the supplied interface.
1047 */
1048 if (sap->sa_cls != clp)
1049 continue;
1050 if ((dst != INADDR_ANY) &&
1051 (dst != sap->sa_dstip.s_addr))
1052 continue;
1053
1054 /*
1055 * Make sure there's room in the user's buffer
1056 */
1057 if (buf_len < sizeof(aar)) {
1058 err = ENOSPC;
1059 break;
1060 }
1061
1062 /*
1063 * Fill in info to be returned
1064 */
1065 SATOSIN(&aar.aap_arp_addr)->sin_family =
1066 AF_INET;
1067 SATOSIN(&aar.aap_arp_addr)->sin_addr.s_addr =
1068 sap->sa_dstip.s_addr;
1069 strlcpy(aar.aap_intf,
1070 clp->cls_ipnif->inf_nif->nif_if.if_xname,
1071 sizeof(aar.aap_intf));
1072 aar.aap_flags = sap->sa_flags;
1073 aar.aap_origin = sap->sa_origin;
1074 if (sap->sa_flags & SAF_VALID)
1075 aar.aap_age = SPANSARP_MAXAGE -
1076 sap->sa_reftime;
1077 else
1078 aar.aap_age = 0;
1079 ATM_ADDR_COPY(&sap->sa_dstatm, &aar.aap_addr);
1080 ATM_ADDR_COPY(&sap->sa_dstatmsub,
1081 &aar.aap_subaddr);
1082
1083 /*
1084 * Copy the response into the user's buffer
1085 */
1086 if ((err = copyout((caddr_t)&aar, buf_addr,
1087 sizeof(aar))) != 0)
1088 break;
1089 buf_addr += sizeof(aar);
1090 buf_len -= sizeof(aar);
1091 }
1092 if (err)
1093 break;
1094 }
1095
1096 /*
1097 * Update the buffer pointer and length
1098 */
1099 aip->air_buf_addr = buf_addr;
1100 aip->air_buf_len = buf_len;
1101 break;
1102
1103 case AIOCS_INF_ASV:
1104 /*
1105 * Get ARP server information
1106 */
1107 /* SPANS doesn't have an ARP server */
1108 break;
1109
1110 default:
1111 err = EOPNOTSUPP;
1112 }
1113
1114 return (err);
1115 }
1116
DragonFly BSD