Check when M_PREPEND returns an empty mbuf.
[dragonfly.git] / sys / netproto / atalk / aarp.c
1 /*
2  * Copyright (c) 1990,1991 Regents of The University of Michigan.
3  * All Rights Reserved.
4  *
5  * $FreeBSD: src/sys/netatalk/aarp.c,v 1.12.2.2 2001/06/23 20:43:09 iedowse Exp $
6  * $DragonFly: src/sys/netproto/atalk/aarp.c,v 1.4 2003/09/03 14:30:57 hmp Exp $
7  */
8
9 #include "opt_atalk.h"
10
11 #include <sys/param.h>
12 #include <sys/systm.h>
13 #include <sys/mbuf.h>
14 #include <sys/kernel.h>
15 #include <sys/socket.h>
16 #include <sys/syslog.h>
17
18 #include <net/if.h>
19
20 #include <netinet/in.h>
21 #undef s_net
22 #include <netinet/if_ether.h>
23
24 #include "at.h"
25 #include "at_var.h"
26 #include "aarp.h"
27 #include "phase2.h"
28 #include "at_extern.h"
29
30 static void aarptfree( struct aarptab *aat);
31 static void at_aarpinput( struct arpcom *ac, struct mbuf *m);
32
33 #define AARPTAB_BSIZ    9
34 #define AARPTAB_NB      19
35 #define AARPTAB_SIZE    (AARPTAB_BSIZ * AARPTAB_NB)
36 static struct aarptab   aarptab[AARPTAB_SIZE];
37
38 #define AARPTAB_HASH(a) \
39     ((((a).s_net << 8 ) + (a).s_node ) % AARPTAB_NB )
40
41 #define AARPTAB_LOOK(aat,addr) { \
42     int         n; \
43     aat = &aarptab[ AARPTAB_HASH(addr) * AARPTAB_BSIZ ]; \
44     for ( n = 0; n < AARPTAB_BSIZ; n++, aat++ ) \
45         if ( aat->aat_ataddr.s_net == (addr).s_net && \
46              aat->aat_ataddr.s_node == (addr).s_node ) \
47             break; \
48         if ( n >= AARPTAB_BSIZ ) \
49             aat = 0; \
50 }
51
52 #define AARPT_AGE       (60 * 1)
53 #define AARPT_KILLC     20
54 #define AARPT_KILLI     3
55
56 # if !defined( __FreeBSD__ )
57 extern u_char                   etherbroadcastaddr[6];
58 # endif __FreeBSD__
59
60 static u_char atmulticastaddr[ 6 ] = {
61     0x09, 0x00, 0x07, 0xff, 0xff, 0xff,
62 };
63
64 u_char  at_org_code[ 3 ] = {
65     0x08, 0x00, 0x07,
66 };
67 u_char  aarp_org_code[ 3 ] = {
68     0x00, 0x00, 0x00,
69 };
70
71 static struct callout_handle aarptimer_ch =
72     CALLOUT_HANDLE_INITIALIZER(&aarptimer_ch);
73
74 static void
75 aarptimer(void *ignored)
76 {
77     struct aarptab      *aat;
78     int                 i, s;
79
80     aarptimer_ch = timeout( aarptimer, (caddr_t)0, AARPT_AGE * hz );
81     aat = aarptab;
82     for ( i = 0; i < AARPTAB_SIZE; i++, aat++ ) {
83         if ( aat->aat_flags == 0 || ( aat->aat_flags & ATF_PERM ))
84             continue;
85         if ( ++aat->aat_timer < (( aat->aat_flags & ATF_COM ) ?
86                 AARPT_KILLC : AARPT_KILLI ))
87             continue;
88         s = splimp();
89         aarptfree( aat );
90         splx( s );
91     }
92 }
93
94 /* 
95  * search through the network addresses to find one that includes
96  * the given network.. remember to take netranges into
97  * consideration.
98  */
99 struct at_ifaddr *
100 at_ifawithnet(struct sockaddr_at  *sat )
101 {
102     struct at_ifaddr    *aa;
103     struct sockaddr_at  *sat2;
104
105         for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
106                 sat2 = &(aa->aa_addr);
107                 if ( sat2->sat_addr.s_net == sat->sat_addr.s_net ) {
108                         break;
109                 }
110                 if( (aa->aa_flags & AFA_PHASE2 )
111                 && (ntohs(aa->aa_firstnet) <= ntohs(sat->sat_addr.s_net))
112                 && (ntohs(aa->aa_lastnet) >= ntohs(sat->sat_addr.s_net))) {
113                         break;
114                 }
115         }
116         return( aa );
117 }
118
119 static void
120 aarpwhohas( struct arpcom *ac, struct sockaddr_at *sat )
121 {
122     struct mbuf         *m;
123     struct ether_header *eh;
124     struct ether_aarp   *ea;
125     struct at_ifaddr    *aa;
126     struct llc          *llc;
127     struct sockaddr     sa;
128
129     if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
130         return;
131     }
132     m->m_len = sizeof( *ea );
133     m->m_pkthdr.len = sizeof( *ea );
134     MH_ALIGN( m, sizeof( *ea ));
135
136     ea = mtod( m, struct ether_aarp *);
137     bzero((caddr_t)ea, sizeof( *ea ));
138
139     ea->aarp_hrd = htons( AARPHRD_ETHER );
140     ea->aarp_pro = htons( ETHERTYPE_AT );
141     ea->aarp_hln = sizeof( ea->aarp_sha );
142     ea->aarp_pln = sizeof( ea->aarp_spu );
143     ea->aarp_op = htons( AARPOP_REQUEST );
144     bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
145             sizeof( ea->aarp_sha ));
146
147     /*
148      * We need to check whether the output ethernet type should
149      * be phase 1 or 2. We have the interface that we'll be sending
150      * the aarp out. We need to find an AppleTalk network on that
151      * interface with the same address as we're looking for. If the
152      * net is phase 2, generate an 802.2 and SNAP header.
153      */
154     if ((aa = at_ifawithnet( sat )) == NULL) {
155         m_freem( m );
156         return;
157     }
158
159     eh = (struct ether_header *)sa.sa_data;
160
161     if ( aa->aa_flags & AFA_PHASE2 ) {
162         bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
163                 sizeof( eh->ether_dhost ));
164         eh->ether_type = htons(sizeof(struct llc) + sizeof(struct ether_aarp));
165         M_PREPEND( m, sizeof( struct llc ), M_WAIT );
166         llc = mtod( m, struct llc *);
167         llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
168         llc->llc_control = LLC_UI;
169         bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
170         llc->llc_ether_type = htons( ETHERTYPE_AARP );
171
172         bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
173                sizeof( ea->aarp_spnet ));
174         bcopy( &sat->sat_addr.s_net, ea->aarp_tpnet,
175                sizeof( ea->aarp_tpnet ));
176         ea->aarp_spnode = AA_SAT( aa )->sat_addr.s_node;
177         ea->aarp_tpnode = sat->sat_addr.s_node;
178     } else {
179         bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
180                 sizeof( eh->ether_dhost ));
181         eh->ether_type = htons( ETHERTYPE_AARP );
182
183         ea->aarp_spa = AA_SAT( aa )->sat_addr.s_node;
184         ea->aarp_tpa = sat->sat_addr.s_node;
185     }
186
187 #ifdef NETATALKDEBUG
188     printf("aarp: sending request for %u.%u\n",
189            ntohs(AA_SAT( aa )->sat_addr.s_net),
190            AA_SAT( aa )->sat_addr.s_node);
191 #endif /* NETATALKDEBUG */
192
193     sa.sa_len = sizeof( struct sockaddr );
194     sa.sa_family = AF_UNSPEC;
195     (*ac->ac_if.if_output)(&ac->ac_if,
196         m, &sa, NULL);  /* XXX NULL should be routing information */
197 }
198
199 int
200 aarpresolve( ac, m, destsat, desten )
201     struct arpcom       *ac;
202     struct mbuf         *m;
203     struct sockaddr_at  *destsat;
204     u_char              *desten;
205 {
206     struct at_ifaddr    *aa;
207     struct aarptab      *aat;
208     int                 s;
209
210     if ( at_broadcast( destsat )) {
211         m->m_flags |= M_BCAST;
212         if ((aa = at_ifawithnet( destsat )) == NULL)  {
213             m_freem( m );
214             return( 0 );
215         }
216         if ( aa->aa_flags & AFA_PHASE2 ) {
217             bcopy( (caddr_t)atmulticastaddr, (caddr_t)desten,
218                     sizeof( atmulticastaddr ));
219         } else {
220             bcopy( (caddr_t)etherbroadcastaddr, (caddr_t)desten,
221                     sizeof( etherbroadcastaddr ));
222         }
223         return( 1 );
224     }
225
226     s = splimp();
227     AARPTAB_LOOK( aat, destsat->sat_addr );
228     if ( aat == 0 ) {                   /* No entry */
229         aat = aarptnew( &destsat->sat_addr );
230         if ( aat == 0 ) {
231             panic( "aarpresolve: no free entry" );
232         }
233         aat->aat_hold = m;
234         aarpwhohas( ac, destsat );
235         splx( s );
236         return( 0 );
237     }
238     /* found an entry */
239     aat->aat_timer = 0;
240     if ( aat->aat_flags & ATF_COM ) {   /* entry is COMplete */
241         bcopy( (caddr_t)aat->aat_enaddr, (caddr_t)desten,
242                 sizeof( aat->aat_enaddr ));
243         splx( s );
244         return( 1 );
245     }
246     /* entry has not completed */
247     if ( aat->aat_hold ) {
248         m_freem( aat->aat_hold );
249     }
250     aat->aat_hold = m;
251     aarpwhohas( ac, destsat );
252     splx( s );
253     return( 0 );
254 }
255
256 void
257 aarpinput( ac, m )
258     struct arpcom       *ac;
259     struct mbuf         *m;
260 {
261     struct arphdr       *ar;
262
263     if ( ac->ac_if.if_flags & IFF_NOARP )
264         goto out;
265
266     if ( m->m_len < sizeof( struct arphdr )) {
267         goto out;
268     }
269
270     ar = mtod( m, struct arphdr *);
271     if ( ntohs( ar->ar_hrd ) != AARPHRD_ETHER ) {
272         goto out;
273     }
274     
275     if ( m->m_len < sizeof( struct arphdr ) + 2 * ar->ar_hln +
276             2 * ar->ar_pln ) {
277         goto out;
278     }
279     
280     switch( ntohs( ar->ar_pro )) {
281     case ETHERTYPE_AT :
282         at_aarpinput( ac, m );
283         return;
284
285     default:
286         break;
287     }
288
289 out:
290     m_freem( m );
291 }
292
293 static void
294 at_aarpinput( struct arpcom *ac, struct mbuf *m)
295 {
296     struct ether_aarp   *ea;
297     struct at_ifaddr    *aa;
298     struct aarptab      *aat;
299     struct ether_header *eh;
300     struct llc          *llc;
301     struct sockaddr_at  sat;
302     struct sockaddr     sa;
303     struct at_addr      spa, tpa, ma;
304     int                 op;
305     u_short             net;
306
307     ea = mtod( m, struct ether_aarp *);
308
309     /* Check to see if from my hardware address */
310     if ( !bcmp(( caddr_t )ea->aarp_sha, ( caddr_t )ac->ac_enaddr,
311             sizeof( ac->ac_enaddr ))) {
312         m_freem( m );
313         return;
314     }
315
316     op = ntohs( ea->aarp_op );
317     bcopy( ea->aarp_tpnet, &net, sizeof( net ));
318
319     if ( net != 0 ) { /* should be ATADDR_ANYNET? */
320         sat.sat_len = sizeof(struct sockaddr_at);
321         sat.sat_family = AF_APPLETALK;
322         sat.sat_addr.s_net = net;
323         if ((aa = at_ifawithnet( &sat )) == NULL) {
324             m_freem( m );
325             return;
326         }
327         bcopy( ea->aarp_spnet, &spa.s_net, sizeof( spa.s_net ));
328         bcopy( ea->aarp_tpnet, &tpa.s_net, sizeof( tpa.s_net ));
329     } else {
330         /*
331          * Since we don't know the net, we just look for the first
332          * phase 1 address on the interface.
333          */
334         for (aa = (struct at_ifaddr *)ac->ac_if.if_addrhead.tqh_first; aa;
335                 aa = (struct at_ifaddr *)aa->aa_ifa.ifa_link.tqe_next) {
336             if ( AA_SAT( aa )->sat_family == AF_APPLETALK &&
337                     ( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
338                 break;
339             }
340         }
341         if ( aa == NULL ) {
342             m_freem( m );
343             return;
344         }
345         tpa.s_net = spa.s_net = AA_SAT( aa )->sat_addr.s_net;
346     }
347
348     spa.s_node = ea->aarp_spnode;
349     tpa.s_node = ea->aarp_tpnode;
350     ma.s_net = AA_SAT( aa )->sat_addr.s_net;
351     ma.s_node = AA_SAT( aa )->sat_addr.s_node;
352
353     /*
354      * This looks like it's from us.
355      */
356     if ( spa.s_net == ma.s_net && spa.s_node == ma.s_node ) {
357         if ( aa->aa_flags & AFA_PROBING ) {
358             /*
359              * We're probing, someone either responded to our probe, or
360              * probed for the same address we'd like to use. Change the
361              * address we're probing for.
362              */
363             untimeout( aarpprobe, ac, aa->aa_ch );
364             wakeup( aa );
365             m_freem( m );
366             return;
367         } else if ( op != AARPOP_PROBE ) {
368             /*
369              * This is not a probe, and we're not probing. This means
370              * that someone's saying they have the same source address
371              * as the one we're using. Get upset...
372              */
373             log( LOG_ERR,
374                     "aarp: duplicate AT address!! %x:%x:%x:%x:%x:%x\n",
375                     ea->aarp_sha[ 0 ], ea->aarp_sha[ 1 ], ea->aarp_sha[ 2 ],
376                     ea->aarp_sha[ 3 ], ea->aarp_sha[ 4 ], ea->aarp_sha[ 5 ]);
377             m_freem( m );
378             return;
379         }
380     }
381
382     AARPTAB_LOOK( aat, spa );
383     if ( aat ) {
384         if ( op == AARPOP_PROBE ) {
385             /*
386              * Someone's probing for spa, dealocate the one we've got,
387              * so that if the prober keeps the address, we'll be able
388              * to arp for him.
389              */
390             aarptfree( aat );
391             m_freem( m );
392             return;
393         }
394
395         bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
396                 sizeof( ea->aarp_sha ));
397         aat->aat_flags |= ATF_COM;
398         if ( aat->aat_hold ) {
399             struct mbuf *mhold = aat->aat_hold;
400             aat->aat_hold = NULL;
401             sat.sat_len = sizeof(struct sockaddr_at);
402             sat.sat_family = AF_APPLETALK;
403             sat.sat_addr = spa;
404             (*ac->ac_if.if_output)( &ac->ac_if, mhold,
405                     (struct sockaddr *)&sat, NULL); /* XXX */
406         }
407     } else if ((tpa.s_net == ma.s_net)
408            && (tpa.s_node == ma.s_node)
409            && (op != AARPOP_PROBE)
410            && ((aat = aarptnew( &spa )) != NULL)) {
411                 bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
412                     sizeof( ea->aarp_sha ));
413                 aat->aat_flags |= ATF_COM;
414     }
415
416     /*
417      * Don't respond to responses, and never respond if we're
418      * still probing.
419      */
420     if ( tpa.s_net != ma.s_net || tpa.s_node != ma.s_node ||
421             op == AARPOP_RESPONSE || ( aa->aa_flags & AFA_PROBING )) {
422         m_freem( m );
423         return;
424     }
425
426     bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )ea->aarp_tha,
427             sizeof( ea->aarp_sha ));
428     bcopy(( caddr_t )ac->ac_enaddr, ( caddr_t )ea->aarp_sha,
429             sizeof( ea->aarp_sha ));
430
431     /* XXX */
432     eh = (struct ether_header *)sa.sa_data;
433     bcopy(( caddr_t )ea->aarp_tha, ( caddr_t )eh->ether_dhost,
434             sizeof( eh->ether_dhost ));
435
436     if ( aa->aa_flags & AFA_PHASE2 ) {
437         eh->ether_type = htons( sizeof( struct llc ) +
438                 sizeof( struct ether_aarp ));
439         M_PREPEND( m, sizeof( struct llc ), M_DONTWAIT );
440         if ( m == NULL ) {
441             return;
442         }
443         llc = mtod( m, struct llc *);
444         llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
445         llc->llc_control = LLC_UI;
446         bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
447         llc->llc_ether_type = htons( ETHERTYPE_AARP );
448
449         bcopy( ea->aarp_spnet, ea->aarp_tpnet, sizeof( ea->aarp_tpnet ));
450         bcopy( &ma.s_net, ea->aarp_spnet, sizeof( ea->aarp_spnet ));
451     } else {
452         eh->ether_type = htons( ETHERTYPE_AARP );
453     }
454
455     ea->aarp_tpnode = ea->aarp_spnode;
456     ea->aarp_spnode = ma.s_node;
457     ea->aarp_op = htons( AARPOP_RESPONSE );
458
459     sa.sa_len = sizeof( struct sockaddr );
460     sa.sa_family = AF_UNSPEC;
461     (*ac->ac_if.if_output)( &ac->ac_if, m, &sa, NULL); /* XXX */
462     return;
463 }
464
465 static void
466 aarptfree( struct aarptab *aat)
467 {
468
469     if ( aat->aat_hold )
470         m_freem( aat->aat_hold );
471     aat->aat_hold = NULL;
472     aat->aat_timer = aat->aat_flags = 0;
473     aat->aat_ataddr.s_net = 0;
474     aat->aat_ataddr.s_node = 0;
475 }
476
477     struct aarptab *
478 aarptnew( addr )
479     struct at_addr      *addr;
480 {
481     int                 n;
482     int                 oldest = -1;
483     struct aarptab      *aat, *aato = NULL;
484     static int          first = 1;
485
486     if ( first ) {
487         first = 0;
488         aarptimer_ch = timeout( aarptimer, (caddr_t)0, hz );
489     }
490     aat = &aarptab[ AARPTAB_HASH( *addr ) * AARPTAB_BSIZ ];
491     for ( n = 0; n < AARPTAB_BSIZ; n++, aat++ ) {
492         if ( aat->aat_flags == 0 )
493             goto out;
494         if ( aat->aat_flags & ATF_PERM )
495             continue;
496         if ((int) aat->aat_timer > oldest ) {
497             oldest = aat->aat_timer;
498             aato = aat;
499         }
500     }
501     if ( aato == NULL )
502         return( NULL );
503     aat = aato;
504     aarptfree( aat );
505 out:
506     aat->aat_ataddr = *addr;
507     aat->aat_flags = ATF_INUSE;
508     return( aat );
509 }
510
511
512 void
513 aarpprobe( void *arg )
514 {
515     struct arpcom       *ac = arg;
516     struct mbuf         *m;
517     struct ether_header *eh;
518     struct ether_aarp   *ea;
519     struct at_ifaddr    *aa;
520     struct llc          *llc;
521     struct sockaddr     sa;
522
523     /*
524      * We need to check whether the output ethernet type should
525      * be phase 1 or 2. We have the interface that we'll be sending
526      * the aarp out. We need to find an AppleTalk network on that
527      * interface with the same address as we're looking for. If the
528      * net is phase 2, generate an 802.2 and SNAP header.
529      */
530     for (aa = (struct at_ifaddr *)ac->ac_if.if_addrhead.tqh_first; aa;
531             aa = (struct at_ifaddr *)aa->aa_ifa.ifa_link.tqe_next) {
532         if ( AA_SAT( aa )->sat_family == AF_APPLETALK &&
533                 ( aa->aa_flags & AFA_PROBING )) {
534             break;
535         }
536     }
537     if ( aa == NULL ) {         /* serious error XXX */
538         printf( "aarpprobe why did this happen?!\n" );
539         return;
540     }
541
542     if ( aa->aa_probcnt <= 0 ) {
543         aa->aa_flags &= ~AFA_PROBING;
544         wakeup( aa );
545         return;
546     } else {
547         aa->aa_ch = timeout( aarpprobe, (caddr_t)ac, hz / 5 );
548     }
549
550     if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
551         return;
552     }
553     m->m_len = sizeof( *ea );
554     m->m_pkthdr.len = sizeof( *ea );
555     MH_ALIGN( m, sizeof( *ea ));
556
557     ea = mtod( m, struct ether_aarp *);
558     bzero((caddr_t)ea, sizeof( *ea ));
559
560     ea->aarp_hrd = htons( AARPHRD_ETHER );
561     ea->aarp_pro = htons( ETHERTYPE_AT );
562     ea->aarp_hln = sizeof( ea->aarp_sha );
563     ea->aarp_pln = sizeof( ea->aarp_spu );
564     ea->aarp_op = htons( AARPOP_PROBE );
565     bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
566             sizeof( ea->aarp_sha ));
567
568     eh = (struct ether_header *)sa.sa_data;
569
570     if ( aa->aa_flags & AFA_PHASE2 ) {
571         bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
572                 sizeof( eh->ether_dhost ));
573         eh->ether_type = htons( sizeof( struct llc ) +
574                 sizeof( struct ether_aarp ));
575         M_PREPEND( m, sizeof( struct llc ), M_WAIT );
576         /* XXX-MBUF */
577         llc = mtod( m, struct llc *);
578         llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
579         llc->llc_control = LLC_UI;
580         bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
581         llc->llc_ether_type = htons( ETHERTYPE_AARP );
582
583         bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
584                 sizeof( ea->aarp_spnet ));
585         bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_tpnet,
586                 sizeof( ea->aarp_tpnet ));
587         ea->aarp_spnode = ea->aarp_tpnode = AA_SAT( aa )->sat_addr.s_node;
588     } else {
589         bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
590                 sizeof( eh->ether_dhost ));
591         eh->ether_type = htons( ETHERTYPE_AARP );
592         ea->aarp_spa = ea->aarp_tpa = AA_SAT( aa )->sat_addr.s_node;
593     }
594
595 #ifdef NETATALKDEBUG
596     printf("aarp: sending probe for %u.%u\n",
597            ntohs(AA_SAT( aa )->sat_addr.s_net),
598            AA_SAT( aa )->sat_addr.s_node);
599 #endif /* NETATALKDEBUG */
600
601     sa.sa_len = sizeof( struct sockaddr );
602     sa.sa_family = AF_UNSPEC;
603     (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, NULL); /* XXX */
604     aa->aa_probcnt--;
605 }
606
607 void
608 aarp_clean(void)
609 {
610     struct aarptab      *aat;
611     int                 i;
612
613     untimeout( aarptimer, 0, aarptimer_ch );
614     for ( i = 0, aat = aarptab; i < AARPTAB_SIZE; i++, aat++ ) {
615         if ( aat->aat_hold ) {
616             m_freem( aat->aat_hold );
617             aat->aat_hold = NULL;
618         }
619     }
620 }