?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fetch.9: Minor fixes.
[dragonfly.git] / sys / netproto / atm / uni / uniarp.c
blob1ebe9b6db4e9848653c032d19bf9c8e83145bb0c
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/uni/uniarp.c,v 1.8 2000/01/15 20:46:07 mks Exp $
27 * @(#) $DragonFly: src/sys/netproto/atm/uni/uniarp.c,v 1.8 2006/01/14 13:36:39 swildner Exp $
28 */
29
30 /*
31 * ATM Forum UNI Support
32 * ---------------------
33 *
34 * UNI ATMARP support (RFC1577)
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 "unisig_var.h"
43 #include "uniip_var.h"
44
45 /*
46 * Global variables
47 */
48 struct uniarp *uniarp_arptab[UNIARP_HASHSIZ] = {NULL};
49 struct uniarp *uniarp_nomaptab = NULL;
50 struct uniarp *uniarp_pvctab = NULL;
51 struct atm_time uniarp_timer = {0, 0}; /* Aging timer */
52 struct uniarp_stat uniarp_stat = {0};
53 int uniarp_print = 0;
54
55 Atm_endpoint uniarp_endpt = {
56 NULL,
57 ENDPT_ATMARP,
58 uniarp_ioctl,
59 uniarp_getname,
60 uniarp_connected,
61 uniarp_cleared,
62 NULL,
63 NULL,
64 NULL,
65 NULL,
66 uniarp_cpcs_data,
67 NULL,
68 NULL,
69 NULL,
70 NULL
71 };
72
73 struct sp_info uniarp_pool = {
74 "uni arp pool", /* si_name */
75 sizeof(struct uniarp), /* si_blksiz */
76 10, /* si_blkcnt */
77 200 /* si_maxallow */
78 };
79
80
81 /*
82 * Local variables
83 */
84 static void uniarp_server_mode (struct uniip *);
85 static void uniarp_client_mode (struct uniip *, Atm_addr *);
86
87
88 /*
89 * Process module loading notification
90 *
91 * Called whenever the uni module is initializing.
92 *
93 * Arguments:
94 * none
95 *
96 * Returns:
97 * 0 initialization successful
98 * errno initialization failed - reason indicated
99 *
100 */
101 int
102 uniarp_start(void)
103 {
104 int err;
105
106 /*
107 * Register our endpoint
108 */
109 err = atm_endpoint_register(&uniarp_endpt);
110
111 return (err);
112 }
113
114
115 /*
116 * Process module unloading notification
117 *
118 * Called whenever the uni module is about to be unloaded. All signalling
119 * instances will have been previously detached. All uniarp resources
120 * must be freed now.
121 *
122 * Arguments:
123 * none
124 *
125 * Returns:
126 * none
127 *
128 */
129 void
130 uniarp_stop(void)
131 {
132 int i;
133
134 /*
135 * Make sure the arp table is empty
136 */
137 for (i = 0; i < UNIARP_HASHSIZ; i++) {
138 if (uniarp_arptab[i] != NULL)
139 panic("uniarp_stop: arp table not empty");
140 }
141
142 /*
143 * Cancel timers
144 */
145 atm_untimeout(&uniarp_timer);
146
147 /*
148 * De-register ourselves
149 */
150 atm_endpoint_deregister(&uniarp_endpt);
151
152 /*
153 * Free our storage pools
154 */
155 atm_release_pool(&uniarp_pool);
156 }
157
158
159 /*
160 * Process IP Network Interface Activation
161 *
162 * Called whenever an IP network interface becomes active.
163 *
164 * Called at splnet.
165 *
166 * Arguments:
167 * uip pointer to UNI IP interface
168 *
169 * Returns:
170 * none
171 *
172 */
173 void
174 uniarp_ipact(struct uniip *uip)
175 {
176 struct unisig *usp;
177
178 ATM_DEBUG1("uniarp_ipact: uip=%p\n", uip);
179
180 /*
181 * Set initial state
182 */
183 uip->uip_arpstate = UIAS_NOTCONF;
184 uip->uip_arpsvratm.address_format = T_ATM_ABSENT;
185 uip->uip_arpsvratm.address_length = 0;
186 uip->uip_arpsvrsub.address_format = T_ATM_ABSENT;
187 uip->uip_arpsvrsub.address_length = 0;
188
189 usp = (struct unisig *)uip->uip_ipnif->inf_nif->nif_pif->pif_siginst;
190 if (usp->us_addr.address_format != T_ATM_ABSENT)
191 uip->uip_flags |= UIF_IFADDR;
192
193 /*
194 * Make sure aging timer is running
195 */
196 if ((uniarp_timer.ti_flag & TIF_QUEUED) == 0)
197 atm_timeout(&uniarp_timer, UNIARP_AGING, uniarp_aging);
198
199 return;
200 }
201
202
203 /*
204 * Process IP Network Interface Deactivation
205 *
206 * Called whenever an IP network interface becomes inactive. All VCCs
207 * for this interface should already have been closed.
208 *
209 * Called at splnet.
210 *
211 * Arguments:
212 * uip pointer to UNI IP interface
213 *
214 * Returns:
215 * none
216 *
217 */
218 void
219 uniarp_ipdact(struct uniip *uip)
220 {
221 struct uniarp *uap, *unext;
222 int i;
223
224 ATM_DEBUG1("uniarp_ipdact: uip=%p\n", uip);
225
226 /*
227 * Delete all interface entries
228 */
229 for (i = 0; i < UNIARP_HASHSIZ; i++) {
230 for (uap = uniarp_arptab[i]; uap; uap = unext) {
231 unext = uap->ua_next;
232
233 if (uap->ua_intf != uip)
234 continue;
235
236 /*
237 * All VCCs should (better) be gone by now
238 */
239 if (uap->ua_ivp)
240 panic("uniarp_ipdact: entry not empty");
241
242 /*
243 * Clean up any loose ends
244 */
245 UNIARP_CANCEL(uap);
246
247 /*
248 * Delete entry from arp table and free entry
249 */
250 UNIARP_DELETE(uap);
251 atm_free((caddr_t)uap);
252 }
253 }
254
255 /*
256 * Clean up 'nomap' table
257 */
258 for (uap = uniarp_nomaptab; uap; uap = unext) {
259 unext = uap->ua_next;
260
261 if (uap->ua_intf != uip)
262 continue;
263
264 /*
265 * All VCCs should (better) be gone by now
266 */
267 if (uap->ua_ivp)
268 panic("uniarp_ipdact: entry not empty");
269
270 /*
271 * Clean up any loose ends
272 */
273 UNIARP_CANCEL(uap);
274
275 /*
276 * Delete entry from 'no map' table and free entry
277 */
278 UNLINK(uap, struct uniarp, uniarp_nomaptab, ua_next);
279 atm_free((caddr_t)uap);
280 }
281
282 /*
283 * Also clean up pvc table
284 */
285 for (uap = uniarp_pvctab; uap; uap = unext) {
286 unext = uap->ua_next;
287
288 if (uap->ua_intf != uip)
289 continue;
290
291 /*
292 * All PVCs should (better) be gone by now
293 */
294 panic("uniarp_ipdact: pvc table not empty");
295 }
296
297 /*
298 * Cancel arp interface timer
299 */
300 UNIIP_ARP_CANCEL(uip);
301
302 /*
303 * Stop aging timer if this is the last active interface
304 */
305 if (uniip_head == uip && uip->uip_next == NULL)
306 atm_untimeout(&uniarp_timer);
307 }
308
309
310 /*
311 * Process Interface ATM Address Change
312 *
313 * This function is called whenever the ATM address for a physical
314 * interface is set/changed.
315 *
316 * Called at splnet.
317 *
318 * Arguments:
319 * sip pointer to interface's UNI signalling instance
320 *
321 * Returns:
322 * none
323 *
324 */
325 void
326 uniarp_ifaddr(struct siginst *sip)
327 {
328 struct atm_nif *nip;
329 struct uniip *uip;
330
331 ATM_DEBUG1("uniarp_ifaddr: sip=%p\n", sip);
332
333 /*
334 * We've got to handle this for every network interface
335 */
336 for (nip = sip->si_pif->pif_nif; nip; nip = nip->nif_pnext) {
337
338 /*
339 * Find our control blocks
340 */
341 for (uip = uniip_head; uip; uip = uip->uip_next) {
342 if (uip->uip_ipnif->inf_nif == nip)
343 break;
344 }
345 if (uip == NULL)
346 continue;
347
348 /*
349 * We don't support changing prefix (yet)
350 */
351 if (uip->uip_flags & UIF_IFADDR) {
352 log(LOG_ERR, "uniarp_ifaddr: change not supported\n");
353 continue;
354 }
355
356 /*
357 * Note that address has been set and figure out what
358 * to do next
359 */
360 uip->uip_flags |= UIF_IFADDR;
361
362 if (uip->uip_arpstate == UIAS_CLIENT_PADDR) {
363 /*
364 * This is what we're waiting for
365 */
366 uniarp_client_mode(uip, NULL);
367 } else if (uip->uip_arpstate == UIAS_SERVER_ACTIVE) {
368 /*
369 * Set new local arpserver atm address
370 */
371 ATM_ADDR_SEL_COPY(&sip->si_addr, nip->nif_sel,
372 &uip->uip_arpsvratm);
373 }
374 }
375
376 return;
377 }
378
379
380 /*
381 * Set ATMARP Server Mode
382 *
383 * This function is called to configure the local node to become the
384 * ATMARP server for the specified LIS.
385 *
386 * Called at splnet.
387 *
388 * Arguments:
389 * uip pointer to UNI IP interface
390 *
391 * Returns:
392 * none
393 *
394 */
395 static void
396 uniarp_server_mode(struct uniip *uip)
397 {
398 struct ip_nif *inp;
399 struct atm_nif *nip;
400 struct siginst *sgp;
401 struct ipvcc *ivp, *inext;
402 struct uniarp *uap, *unext;
403 int i;
404
405 ATM_DEBUG1("uniarp_server_mode: uip=%p\n", uip);
406
407 /*
408 * Handle client/server mode changes first
409 */
410 switch (uip->uip_arpstate) {
411
412 case UIAS_NOTCONF:
413 case UIAS_SERVER_ACTIVE:
414 case UIAS_CLIENT_PADDR:
415 /*
416 * Nothing to undo
417 */
418 break;
419
420 case UIAS_CLIENT_POPEN:
421 /*
422 * We're becoming the server, so kill the pending connection
423 */
424 UNIIP_ARP_CANCEL(uip);
425 if ((ivp = uip->uip_arpsvrvcc) != NULL) {
426 ivp->iv_flags &= ~IVF_NOIDLE;
427 uip->uip_arpsvrvcc = NULL;
428 (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_FAILED);
429 }
430 break;
431
432 case UIAS_CLIENT_REGISTER:
433 case UIAS_CLIENT_ACTIVE:
434 /*
435 * We're becoming the server, but leave existing VCC as a
436 * "normal" IP VCC
437 */
438 UNIIP_ARP_CANCEL(uip);
439 ivp = uip->uip_arpsvrvcc;
440 ivp->iv_flags &= ~IVF_NOIDLE;
441 uip->uip_arpsvrvcc = NULL;
442 break;
443 }
444
445 /*
446 * Revalidate status for all arp entries on this interface
447 */
448 for (i = 0; i < UNIARP_HASHSIZ; i++) {
449 for (uap = uniarp_arptab[i]; uap; uap = unext) {
450 unext = uap->ua_next;
451
452 if (uap->ua_intf != uip)
453 continue;
454
455 if (uap->ua_origin >= UAO_PERM)
456 continue;
457
458 if (uap->ua_origin >= UAO_SCSP) {
459 if (uniarp_validate_ip(uip, &uap->ua_dstip,
460 uap->ua_origin) == 0)
461 continue;
462 }
463
464 if (uap->ua_ivp == NULL) {
465 UNIARP_CANCEL(uap);
466 UNIARP_DELETE(uap);
467 atm_free((caddr_t)uap);
468 continue;
469 }
470
471 if (uap->ua_flags & UAF_VALID) {
472 uap->ua_flags |= UAF_LOCKED;
473 for (ivp = uap->ua_ivp; ivp; ivp = inext) {
474 inext = ivp->iv_arpnext;
475 (*ivp->iv_ipnif->inf_arpnotify)
476 (ivp, MAP_INVALID);
477 }
478 uap->ua_flags &= ~(UAF_LOCKED | UAF_VALID);
479 }
480 uap->ua_aging = 1;
481 uap->ua_origin = 0;
482 }
483 }
484
485 /*
486 * OK, now let's make ourselves the server
487 */
488 inp = uip->uip_ipnif;
489 nip = inp->inf_nif;
490 sgp = nip->nif_pif->pif_siginst;
491 ATM_ADDR_SEL_COPY(&sgp->si_addr, nip->nif_sel, &uip->uip_arpsvratm);
492 uip->uip_arpsvrip = IA_SIN(inp->inf_addr)->sin_addr;
493 uip->uip_arpstate = UIAS_SERVER_ACTIVE;
494 return;
495 }
496
497
498 /*
499 * Set ATMARP Client Mode
500 *
501 * This function is called to configure the local node to be an ATMARP
502 * client on the specified LIS using the specified ATMARP server.
503 *
504 * Called at splnet.
505 *
506 * Arguments:
507 * uip pointer to UNI IP interface
508 * aap pointer to the ATMARP server's ATM address
509 *
510 * Returns:
511 * none
512 *
513 */
514 static void
515 uniarp_client_mode(struct uniip *uip, Atm_addr *aap)
516 {
517 struct ip_nif *inp = uip->uip_ipnif;
518 struct uniarp *uap, *unext;
519 struct ipvcc *ivp, *inext;
520 int i;
521
522 ATM_DEBUG2("uniarp_client_mode: uip=%p, atm=(%s,-)\n",
523 uip, aap ? unisig_addr_print(aap): "-");
524
525 /*
526 * Handle client/server mode changes first
527 */
528 switch (uip->uip_arpstate) {
529
530 case UIAS_NOTCONF:
531 case UIAS_CLIENT_PADDR:
532 /*
533 * Nothing to undo
534 */
535 break;
536
537 case UIAS_CLIENT_POPEN:
538 /*
539 * If this is this a timeout retry, just go do it
540 */
541 if (aap == NULL)
542 break;
543
544 /*
545 * If this isn't really a different arpserver, we're done
546 */
547 if (ATM_ADDR_EQUAL(aap, &uip->uip_arpsvratm))
548 return;
549
550 /*
551 * We're changing servers, so kill the pending connection
552 */
553 UNIIP_ARP_CANCEL(uip);
554 if ((ivp = uip->uip_arpsvrvcc) != NULL) {
555 ivp->iv_flags &= ~IVF_NOIDLE;
556 uip->uip_arpsvrvcc = NULL;
557 (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_FAILED);
558 }
559 break;
560
561 case UIAS_CLIENT_REGISTER:
562 case UIAS_CLIENT_ACTIVE:
563 /*
564 * If this isn't really a different arpserver, we're done
565 */
566 if (ATM_ADDR_EQUAL(aap, &uip->uip_arpsvratm))
567 return;
568
569 /*
570 * We're changing servers, but leave existing VCC as a
571 * "normal" IP VCC
572 */
573 UNIIP_ARP_CANCEL(uip);
574 ivp = uip->uip_arpsvrvcc;
575 ivp->iv_flags &= ~IVF_NOIDLE;
576 uip->uip_arpsvrvcc = NULL;
577 break;
578
579 case UIAS_SERVER_ACTIVE:
580 /*
581 * We're changing from server mode, so...
582 *
583 * Reset valid/authoritative status for all arp entries
584 * on this interface
585 */
586 for (i = 0; i < UNIARP_HASHSIZ; i++) {
587 for (uap = uniarp_arptab[i]; uap; uap = unext) {
588 unext = uap->ua_next;
589
590 if (uap->ua_intf != uip)
591 continue;
592
593 if (uap->ua_origin >= UAO_PERM)
594 continue;
595
596 if (uap->ua_ivp == NULL) {
597 UNIARP_CANCEL(uap);
598 UNIARP_DELETE(uap);
599 atm_free((caddr_t)uap);
600 continue;
601 }
602
603 if (uap->ua_flags & UAF_VALID) {
604 uap->ua_flags |= UAF_LOCKED;
605 for (ivp = uap->ua_ivp; ivp;
606 ivp = inext) {
607 inext = ivp->iv_arpnext;
608 (*ivp->iv_ipnif->inf_arpnotify)
609 (ivp, MAP_INVALID);
610 }
611 uap->ua_flags &=
612 ~(UAF_LOCKED | UAF_VALID);
613 }
614 uap->ua_aging = 1;
615 uap->ua_origin = 0;
616 }
617 }
618 uip->uip_arpsvratm.address_format = T_ATM_ABSENT;
619 uip->uip_arpsvratm.address_length = 0;
620 uip->uip_arpsvrsub.address_format = T_ATM_ABSENT;
621 uip->uip_arpsvrsub.address_length = 0;
622 uip->uip_arpsvrip.s_addr = 0;
623 break;
624 }
625
626 /*
627 * Save the arp server address, if supplied now
628 */
629 if (aap)
630 ATM_ADDR_COPY(aap, &uip->uip_arpsvratm);
631
632 /*
633 * If the interface's ATM address isn't set yet, then we
634 * can't do much until it is
635 */
636 if ((uip->uip_flags & UIF_IFADDR) == 0) {
637 uip->uip_arpstate = UIAS_CLIENT_PADDR;
638 return;
639 }
640
641 /*
642 * Just to keep things simple, if we already have (or are trying to
643 * setup) any SVCs to our new server, kill the connections so we can
644 * open a "fresh" SVC for the arpserver connection.
645 */
646 for (i = 0; i < UNIARP_HASHSIZ; i++) {
647 for (uap = uniarp_arptab[i]; uap; uap = unext) {
648 unext = uap->ua_next;
649
650 if (ATM_ADDR_EQUAL(&uip->uip_arpsvratm,
651 &uap->ua_dstatm) &&
652 ATM_ADDR_EQUAL(&uip->uip_arpsvrsub,
653 &uap->ua_dstatmsub)) {
654 uap->ua_flags &= ~UAF_VALID;
655 for (ivp = uap->ua_ivp; ivp; ivp = inext) {
656 inext = ivp->iv_arpnext;
657 (*inp->inf_arpnotify)(ivp, MAP_FAILED);
658 }
659 }
660 }
661 }
662 for (uap = uniarp_nomaptab; uap; uap = unext) {
663 unext = uap->ua_next;
664
665 if (ATM_ADDR_EQUAL(&uip->uip_arpsvratm, &uap->ua_dstatm) &&
666 ATM_ADDR_EQUAL(&uip->uip_arpsvrsub, &uap->ua_dstatmsub)) {
667 uap->ua_flags &= ~UAF_VALID;
668 for (ivp = uap->ua_ivp; ivp; ivp = inext) {
669 inext = ivp->iv_arpnext;
670 (*inp->inf_arpnotify)(ivp, MAP_FAILED);
671 }
672 }
673 }
674
675 /*
676 * Now, get an arp entry for the server connection
677 */
678 uip->uip_arpstate = UIAS_CLIENT_POPEN;
679 uap = (struct uniarp *)atm_allocate(&uniarp_pool);
680 if (uap == NULL) {
681 UNIIP_ARP_TIMER(uip, 1 * ATM_HZ);
682 return;
683 }
684
685 /*
686 * Next, initiate an SVC to the server
687 */
688 if ((*inp->inf_createsvc)(&inp->inf_nif->nif_if, AF_ATM,
689 (caddr_t)&uip->uip_arpsvratm, &ivp)) {
690 atm_free((caddr_t)uap);
691 UNIIP_ARP_TIMER(uip, 1 * ATM_HZ);
692 return;
693 }
694
695 /*
696 * Finally, get everything set up and wait for the SVC
697 * connection to complete
698 */
699 uip->uip_arpsvrvcc = ivp;
700 ivp->iv_flags |= IVF_NOIDLE;
701
702 ATM_ADDR_COPY(&uip->uip_arpsvratm, &uap->ua_dstatm);
703 ATM_ADDR_COPY(&uip->uip_arpsvrsub, &uap->ua_dstatmsub);
704 uap->ua_intf = uip;
705
706 LINK2TAIL(ivp, struct ipvcc, uap->ua_ivp, iv_arpnext);
707 ivp->iv_arpent = (struct arpmap *)uap;
708
709 LINK2TAIL(uap, struct uniarp, uniarp_nomaptab, ua_next);
710
711 return;
712 }
713
714
715 /*
716 * Process a UNI ARP interface timeout
717 *
718 * Called when a previously scheduled uniip arp interface timer expires.
719 * Processing will be based on the current uniip arp state.
720 *
721 * Called at splnet.
722 *
723 * Arguments:
724 * tip pointer to uniip arp timer control block
725 *
726 * Returns:
727 * none
728 *
729 */
730 void
731 uniarp_iftimeout(struct atm_time *tip)
732 {
733 struct ip_nif *inp;
734 struct uniip *uip;
735
736
737 /*
738 * Back-off to uniip control block
739 */
740 uip = (struct uniip *)
741 ((caddr_t)tip - (int)(&((struct uniip *)0)->uip_arptime));
742
743 ATM_DEBUG2("uniarp_iftimeout: uip=%p, state=%d\n", uip,
744 uip->uip_arpstate);
745
746 /*
747 * Process timeout based on protocol state
748 */
749 switch (uip->uip_arpstate) {
750
751 case UIAS_CLIENT_POPEN:
752 /*
753 * Retry opening arp server connection
754 */
755 uniarp_client_mode(uip, NULL);
756 break;
757
758 case UIAS_CLIENT_REGISTER:
759 /*
760 * Resend registration request
761 */
762 inp = uip->uip_ipnif;
763 uniarp_arp_req(uip, &(IA_SIN(inp->inf_addr)->sin_addr));
764
765 /*
766 * Restart timer
767 */
768 UNIIP_ARP_TIMER(uip, 2 * ATM_HZ);
769
770 break;
771
772 case UIAS_CLIENT_ACTIVE:
773 /*
774 * Refresh our registration
775 */
776 inp = uip->uip_ipnif;
777 uniarp_arp_req(uip, &(IA_SIN(inp->inf_addr)->sin_addr));
778
779 /*
780 * Restart timer
781 */
782 UNIIP_ARP_TIMER(uip, UNIARP_REGIS_RETRY);
783
784 break;
785
786 default:
787 log(LOG_ERR, "uniarp_iftimeout: invalid state %d\n",
788 uip->uip_arpstate);
789 }
790 }
791
792
793 /*
794 * UNI ARP IOCTL support
795 *
796 * Function will be called at splnet.
797 *
798 * Arguments:
799 * code PF_ATM sub-operation code
800 * data pointer to code specific parameter data area
801 * arg1 pointer to code specific argument
802 *
803 * Returns:
804 * 0 request procesed
805 * errno error processing request - reason indicated
806 *
807 */
808 int
809 uniarp_ioctl(int code, caddr_t data, caddr_t arg1)
810 {
811 struct atmaddreq *aap;
812 struct atmdelreq *adp;
813 struct atmsetreq *asp;
814 struct atminfreq *aip;
815 struct air_arp_rsp aar;
816 struct air_asrv_rsp asr;
817 struct atm_pif *pip;
818 struct atm_nif *nip;
819 struct ipvcc *ivp, *inext;
820 struct uniip *uip;
821 struct uniarp *uap;
822 struct unisig *usp;
823 struct in_addr ip;
824 Atm_addr atmsub;
825 u_long dst;
826 int err = 0, i, buf_len;
827 caddr_t buf_addr;
828
829 switch (code) {
830
831 case AIOCS_ADD_ARP:
832 /*
833 * Add a permanent ARP mapping
834 */
835 aap = (struct atmaddreq *)data;
836 uip = (struct uniip *)arg1;
837 if (aap->aar_arp_addr.address_format != T_ATM_ENDSYS_ADDR) {
838 err = EINVAL;
839 break;
840 }
841 atmsub.address_format = T_ATM_ABSENT;
842 atmsub.address_length = 0;
843 ip = SATOSIN(&aap->aar_arp_dst)->sin_addr;
844
845 /*
846 * Validate IP address
847 */
848 if (uniarp_validate_ip(uip, &ip, aap->aar_arp_origin) != 0) {
849 err = EADDRNOTAVAIL;
850 break;
851 }
852
853 /*
854 * Add an entry to the cache
855 */
856 err = uniarp_cache_svc(uip, &ip, &aap->aar_arp_addr,
857 &atmsub, aap->aar_arp_origin);
858 break;
859
860 case AIOCS_DEL_ARP:
861 /*
862 * Delete an ARP mapping
863 */
864 adp = (struct atmdelreq *)data;
865 uip = (struct uniip *)arg1;
866 ip = SATOSIN(&adp->adr_arp_dst)->sin_addr;
867
868 /*
869 * Now find the entry to be deleted
870 */
871 UNIARP_LOOKUP(ip.s_addr, uap);
872 if (uap == NULL) {
873 err = ENOENT;
874 break;
875 }
876
877 /*
878 * Notify all VCCs using this entry that they must finish
879 * up now.
880 */
881 uap->ua_flags |= UAF_LOCKED;
882 for (ivp = uap->ua_ivp; ivp; ivp = inext) {
883 inext = ivp->iv_arpnext;
884 (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_FAILED);
885 }
886
887 /*
888 * Now free up the entry
889 */
890 UNIARP_CANCEL(uap);
891 UNIARP_DELETE(uap);
892 atm_free((caddr_t)uap);
893 break;
894
895 case AIOCS_SET_ASV:
896 /*
897 * Set interface ARP server address
898 */
899 asp = (struct atmsetreq *)data;
900 for (uip = uniip_head; uip; uip = uip->uip_next) {
901 if (uip->uip_ipnif->inf_nif == (struct atm_nif *)arg1)
902 break;
903 }
904 if (uip == NULL) {
905 err = ENOPROTOOPT;
906 break;
907 }
908
909 /*
910 * Check for our own address
911 */
912 usp = (struct unisig *)
913 uip->uip_ipnif->inf_nif->nif_pif->pif_siginst;
914 if (ATM_ADDR_EQUAL(&asp->asr_arp_addr, &usp->us_addr)) {
915 asp->asr_arp_addr.address_format = T_ATM_ABSENT;
916 }
917
918 /*
919 * If we're going into server mode, make sure we can get
920 * the memory for the prefix list before continuing
921 */
922 if (asp->asr_arp_addr.address_format == T_ATM_ABSENT) {
923 i = asp->asr_arp_plen / sizeof(struct uniarp_prf);
924 if (i <= 0) {
925 err = EINVAL;
926 break;
927 }
928 buf_len = i * sizeof(struct uniarp_prf);
929 buf_addr = KM_ALLOC(buf_len, M_DEVBUF,
930 M_INTWAIT | M_NULLOK);
931 if (buf_addr == NULL) {
932 err = ENOMEM;
933 break;
934 }
935 err = copyin(asp->asr_arp_pbuf, buf_addr, buf_len);
936 if (err) {
937 KM_FREE(buf_addr, buf_len, M_DEVBUF);
938 break;
939 }
940 } else {
941 /* Silence the compiler */
942 i = 0;
943 buf_addr = NULL;
944 }
945
946 /*
947 * Free any existing prefix address list
948 */
949 if (uip->uip_prefix != NULL) {
950 KM_FREE(uip->uip_prefix,
951 uip->uip_nprefix * sizeof(struct uniarp_prf),
952 M_DEVBUF);
953 uip->uip_prefix = NULL;
954 uip->uip_nprefix = 0;
955 }
956
957 if (asp->asr_arp_addr.address_format == T_ATM_ABSENT) {
958 /*
959 * Set ATMARP server mode
960 */
961 uip->uip_prefix = (struct uniarp_prf *)buf_addr;
962 uip->uip_nprefix = i;
963 uniarp_server_mode(uip);
964 } else
965 /*
966 * Set ATMARP client mode
967 */
968 uniarp_client_mode(uip, &asp->asr_arp_addr);
969 break;
970
971 case AIOCS_INF_ARP:
972 /*
973 * Get ARP table information
974 */
975 aip = (struct atminfreq *)data;
976
977 if (aip->air_arp_addr.sa_family != AF_INET)
978 break;
979 dst = SATOSIN(&aip->air_arp_addr)->sin_addr.s_addr;
980
981 buf_addr = aip->air_buf_addr;
982 buf_len = aip->air_buf_len;
983
984 pip = ((struct siginst *)arg1)->si_pif;
985
986 /*
987 * Run through entire arp table
988 */
989 for (i = 0; i < UNIARP_HASHSIZ; i++) {
990 for (uap = uniarp_arptab[i]; uap; uap = uap->ua_next) {
991 /*
992 * We only want valid entries learned
993 * from the supplied interface.
994 */
995 nip = uap->ua_intf->uip_ipnif->inf_nif;
996 if (nip->nif_pif != pip)
997 continue;
998 if ((dst != INADDR_ANY) &&
999 (dst != uap->ua_dstip.s_addr))
1000 continue;
1001
1002 /*
1003 * Make sure there's room in the user's buffer
1004 */
1005 if (buf_len < sizeof(aar)) {
1006 err = ENOSPC;
1007 break;
1008 }
1009
1010 /*
1011 * Fill in info to be returned
1012 */
1013 SATOSIN(&aar.aap_arp_addr)->sin_family =
1014 AF_INET;
1015 SATOSIN(&aar.aap_arp_addr)->sin_addr.s_addr =
1016 uap->ua_dstip.s_addr;
1017 strlcpy(aar.aap_intf,
1018 nip->nif_if.if_xname,
1019 sizeof(aar.aap_intf));
1020 aar.aap_flags = uap->ua_flags;
1021 aar.aap_origin = uap->ua_origin;
1022 if (uap->ua_flags & UAF_VALID)
1023 aar.aap_age = uap->ua_aging +
1024 uap->ua_retry * UNIARP_RETRY_AGE;
1025 else
1026 aar.aap_age = 0;
1027 ATM_ADDR_COPY(&uap->ua_dstatm, &aar.aap_addr);
1028 ATM_ADDR_COPY(&uap->ua_dstatmsub,
1029 &aar.aap_subaddr);
1030
1031 /*
1032 * Copy the response into the user's buffer
1033 */
1034 if ((err = copyout((caddr_t)&aar, buf_addr,
1035 sizeof(aar))) != 0)
1036 break;
1037 buf_addr += sizeof(aar);
1038 buf_len -= sizeof(aar);
1039 }
1040 if (err)
1041 break;
1042 }
1043
1044 /*
1045 * Now go through the 'nomap' table
1046 */
1047 if (err || (dst != INADDR_ANY))
1048 goto updbuf;
1049 for (uap = uniarp_nomaptab; uap; uap = uap->ua_next) {
1050 /*
1051 * We only want valid entries learned
1052 * from the supplied interface.
1053 */
1054 nip = uap->ua_intf->uip_ipnif->inf_nif;
1055 if (nip->nif_pif != pip)
1056 continue;
1057
1058 /*
1059 * Make sure there's room in the user's buffer
1060 */
1061 if (buf_len < sizeof(aar)) {
1062 err = ENOSPC;
1063 break;
1064 }
1065
1066 /*
1067 * Fill in info to be returned
1068 */
1069 SATOSIN(&aar.aap_arp_addr)->sin_family = AF_INET;
1070 SATOSIN(&aar.aap_arp_addr)->sin_addr.s_addr = 0;
1071 strlcpy(aar.aap_intf,
1072 nip->nif_if.if_xname,
1073 sizeof(aar.aap_intf));
1074 aar.aap_flags = 0;
1075 aar.aap_origin = uap->ua_origin;
1076 aar.aap_age = 0;
1077 ATM_ADDR_COPY(&uap->ua_dstatm, &aar.aap_addr);
1078 ATM_ADDR_COPY(&uap->ua_dstatmsub,
1079 &aar.aap_subaddr);
1080
1081 /*
1082 * Copy the response into the user's buffer
1083 */
1084 if ((err = copyout((caddr_t)&aar, buf_addr,
1085 sizeof(aar))) != 0)
1086 break;
1087 buf_addr += sizeof(aar);
1088 buf_len -= sizeof(aar);
1089 }
1090
1091 updbuf:
1092 /*
1093 * Update the buffer pointer and length
1094 */
1095 aip->air_buf_addr = buf_addr;
1096 aip->air_buf_len = buf_len;
1097
1098 /*
1099 * If the user wants the refresh status reset and no
1100 * errors have been encountered, then do the reset
1101 */
1102 if ((err == 0) && (aip->air_arp_flags & ARP_RESET_REF)) {
1103 for (i = 0; i < UNIARP_HASHSIZ; i++) {
1104 for (uap = uniarp_arptab[i]; uap;
1105 uap = uap->ua_next) {
1106 /*
1107 * We only want valid entries learned
1108 * from the supplied interface.
1109 */
1110 nip = uap->ua_intf->uip_ipnif->inf_nif;
1111 if (nip->nif_pif != pip)
1112 continue;
1113 if ((dst != INADDR_ANY) &&
1114 (dst != uap->ua_dstip.s_addr))
1115 continue;
1116
1117 /*
1118 * Reset refresh flag
1119 */
1120 uap->ua_flags &= ~UAF_REFRESH;
1121 }
1122 }
1123 }
1124 break;
1125
1126 case AIOCS_INF_ASV:
1127 /*
1128 * Get ARP server information
1129 */
1130 aip = (struct atminfreq *)data;
1131 nip = (struct atm_nif *)arg1;
1132
1133 buf_addr = aip->air_buf_addr;
1134 buf_len = aip->air_buf_len;
1135
1136 for (uip = uniip_head; uip; uip = uip->uip_next) {
1137
1138 if (uip->uip_ipnif->inf_nif != nip)
1139 continue;
1140
1141 /*
1142 * Make sure there's room in the user's buffer
1143 */
1144 if (buf_len < sizeof(asr)) {
1145 err = ENOSPC;
1146 break;
1147 }
1148
1149 /*
1150 * Fill in info to be returned
1151 */
1152 strlcpy(asr.asp_intf,
1153 nip->nif_if.if_xname,
1154 sizeof(asr.asp_intf));
1155 asr.asp_state = uip->uip_arpstate;
1156 if (uip->uip_arpstate == UIAS_SERVER_ACTIVE) {
1157 asr.asp_addr.address_format = T_ATM_ABSENT;
1158 asr.asp_addr.address_length = 0;
1159 } else {
1160 ATM_ADDR_COPY(&uip->uip_arpsvratm,
1161 &asr.asp_addr);
1162 }
1163 asr.asp_subaddr.address_format = T_ATM_ABSENT;
1164 asr.asp_subaddr.address_length = 0;
1165 asr.asp_nprefix = uip->uip_nprefix;
1166
1167 /*
1168 * Copy the response into the user's buffer
1169 */
1170 if ((err = copyout((caddr_t)&asr, buf_addr, sizeof(asr))) != 0)
1171 break;
1172 buf_addr += sizeof(asr);
1173 buf_len -= sizeof(asr);
1174
1175 /*
1176 * Copy the prefix list into the user's buffer
1177 */
1178 if (uip->uip_nprefix) {
1179 i = uip->uip_nprefix
1180 * sizeof(struct uniarp_prf);
1181 if (buf_len < i) {
1182 err = ENOSPC;
1183 break;
1184 }
1185 if ((err = copyout(uip->uip_prefix, buf_addr, i)) != 0)
1186 break;
1187 buf_addr += i;
1188 buf_len -= i;
1189 }
1190 }
1191
1192 /*
1193 * Update the buffer pointer and length
1194 */
1195 aip->air_buf_addr = buf_addr;
1196 aip->air_buf_len = buf_len;
1197 break;
1198
1199 default:
1200 err = EOPNOTSUPP;
1201 }
1202
1203 return (err);
1204 }
1205
1206
1207 /*
1208 * Get Connection's Application/Owner Name
1209 *
1210 * Arguments:
1211 * tok uniarp connection token (pointer to ipvcc)
1212 *
1213 * Returns:
1214 * addr pointer to string containing our name
1215 *
1216 */
1217 caddr_t
1218 uniarp_getname(void *tok)
1219 {
1220 return ("ATMARP");
1221 }
1222
DragonFly BSD