root/netatalk/ddp_input.c

DEFINITIONS

1. atintr
2. ddp_input
3. m_printm
4. bprint

    1 /*      $OpenBSD: ddp_input.c,v 1.4 2006/03/04 22:40:16 brad Exp $      */
    3 /*
    4  * Copyright (c) 1990,1994 Regents of The University of Michigan.
    5  * All Rights Reserved.  See COPYRIGHT.
    6  */
    8 /*
    9  * The following is the contents of the COPYRIGHT file from the
   10  * netatalk-1.4a2 distribution, from which this file is derived.
   11  */
   12 /*
   13  * Copyright (c) 1990,1996 Regents of The University of Michigan.
   14  *
   15  * All Rights Reserved.
   16  *
   17  *    Permission to use, copy, modify, and distribute this software and
   18  *    its documentation for any purpose and without fee is hereby granted,
   19  *    provided that the above copyright notice appears in all copies and
   20  *    that both that copyright notice and this permission notice appear
   21  *    in supporting documentation, and that the name of The University
   22  *    of Michigan not be used in advertising or publicity pertaining to
   23  *    distribution of the software without specific, written prior
   24  *    permission. This software is supplied as is without expressed or
   25  *    implied warranties of any kind.
   26  *
   27  * This product includes software developed by the University of
   28  * California, Berkeley and its contributors.
   29  *
   30  * Solaris code is encumbered by the following:
   31  *
   32  *     Copyright (C) 1996 by Sun Microsystems Computer Co.
   33  *
   34  *     Permission to use, copy, modify, and distribute this software and
   35  *     its documentation for any purpose and without fee is hereby
   36  *     granted, provided that the above copyright notice appear in all
   37  *     copies and that both that copyright notice and this permission
   38  *     notice appear in supporting documentation.  This software is
   39  *     provided "as is" without express or implied warranty.
   40  *
   41  * Research Systems Unix Group
   42  * The University of Michigan
   43  * c/o Wesley Craig
   44  * 535 W. William Street
   45  * Ann Arbor, Michigan
   46  * +1-313-764-2278
   47  * netatalk@umich.edu
   48  */
   49 /*
   50  * None of the Solaris code mentioned is included in OpenBSD.
   51  * This code also relies heavily on previous effort in FreeBSD and NetBSD.
   52  */
   54 #include <sys/param.h>
   55 #include <sys/systm.h>
   56 #include <sys/kernel.h>
   57 #include <sys/malloc.h>
   58 #include <sys/mbuf.h>
   59 #include <sys/protosw.h>
   60 #include <sys/socket.h>
   61 #include <sys/ioctl.h>
   62 #include <sys/errno.h>
   63 #include <sys/syslog.h>
   64 #include <sys/proc.h>
   65 #include <sys/socketvar.h>
   67 #include <net/if.h>
   68 #include <net/route.h>
   70 #include <machine/endian.h>
   72 #include <netatalk/at.h>
   73 #include <netatalk/at_var.h>
   74 #include <netatalk/ddp.h>
   75 #include <netatalk/ddp_var.h>
   76 #include <netatalk/at_extern.h>
   78 void atintr(void);
   79 void ddp_input(struct mbuf *, struct ifnet *,
   80                                 struct elaphdr *, int);
   81 #if 0
   82 static void m_printm(struct mbuf *);
   83 static void bprint( char *, int );
   84 #endif
   86 int             ddp_forward = 1;
   87 int             ddp_firewall = 0;
   88 extern int      ddp_cksum;
   90 /*
   91  * Could probably merge these two code segments a little better...
   92  */
   93 void
atintr()
   95 {
   96     struct elaphdr      *elhp, elh;
   97     struct ifnet        *ifp;
   98     struct mbuf         *m;
   99     struct at_ifaddr    *aa;
  100     int                 s;
  102     for (;;) {
s = splnet();
IF_DEQUEUE( &atintrq2, m );
splx( s );
  109         if ( m == 0 ) {                 /* no more queued packets */
  110             break;
  111         }
ifp = m->m_pkthdr.rcvif;
  114         for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
  115             if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 )) {
  116                 break;
  117             }
  118         }
  119         if ( aa == NULL ) {             /* ifp not an appletalk interface */
m_freem( m );
  121             continue;
  122         }
ddp_input( m, ifp, (struct elaphdr *)NULL, 2 );
  125     }
  127     for (;;) {
s = splnet();
IF_DEQUEUE( &atintrq1, m );
splx( s );
  134         if ( m == 0 ) {                 /* no more queued packets */
  135             break;
  136         }
ifp = m->m_pkthdr.rcvif;
  139         for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
  140             if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
  141                 break;
  142             }
  143         }
  144         if ( aa == NULL ) {             /* ifp not an appletalk interface */
m_freem( m );
  146             continue;
  147         }
  149         if ( m->m_len < SZ_ELAPHDR &&
  150                 (( m = m_pullup( m, SZ_ELAPHDR )) == 0 )) {
ddpstat.ddps_tooshort++;
  152             continue;
  153         }
elhp = mtod( m, struct elaphdr *);
m_adj( m, SZ_ELAPHDR );
  158         if ( elhp->el_type == ELAP_DDPEXTEND ) {
ddp_input( m, ifp, (struct elaphdr *)NULL, 1 );
  160         } else {
bcopy((caddr_t)elhp, (caddr_t)&elh, SZ_ELAPHDR );
ddp_input( m, ifp, &elh, 1 );
  163         }
  164     }
  165     return;
  166 }
  168 struct route    forwro;
  170 void
ddp_input( m, ifp, elh, phase )
  172     struct mbuf         *m;
  173     struct ifnet        *ifp;
  174     struct elaphdr      *elh;
  175     int                 phase;
  176 {
  177     struct sockaddr_at  from, to;
  178     struct ddpshdr      *dsh, ddps;
  179     struct at_ifaddr    *aa;
  180     struct ddpehdr      *deh, ddpe;
  181     struct ddpcb        *ddp;
  182     int                 dlen, mlen;
u_int16_t           cksum;
bzero( (caddr_t)&from, sizeof( struct sockaddr_at ));
  186     if ( elh ) {
ddpstat.ddps_short++;
  189         if ( m->m_len < sizeof( struct ddpshdr ) &&
  190                 (( m = m_pullup( m, sizeof( struct ddpshdr ))) == 0 )) {
ddpstat.ddps_tooshort++;
  192             return;
  193         }
dsh = mtod( m, struct ddpshdr *);
bcopy( (caddr_t)dsh, (caddr_t)&ddps, sizeof( struct ddpshdr ));
ddps.dsh_bytes = ntohl( ddps.dsh_bytes );
dlen = ddps.dsh_len;
to.sat_addr.s_net = 0;
to.sat_addr.s_node = elh->el_dnode;
to.sat_port = ddps.dsh_dport;
from.sat_addr.s_net = 0;
from.sat_addr.s_node = elh->el_snode;
from.sat_port = ddps.dsh_sport;
  207         for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
  208             if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 ) == 0 &&
  209                     ( AA_SAT( aa )->sat_addr.s_node == to.sat_addr.s_node ||
to.sat_addr.s_node == ATADDR_BCAST )) {
  211                 break;
  212             }
  213         }
  214         if ( aa == NULL ) {
m_freem( m );
  216             return;
  217         }
  218     } else {
ddpstat.ddps_long++;
  221         if ( m->m_len < sizeof( struct ddpehdr ) &&
  222                 (( m = m_pullup( m, sizeof( struct ddpehdr ))) == 0 )) {
ddpstat.ddps_tooshort++;
  224             return;
  225         }
deh = mtod( m, struct ddpehdr *);
bcopy( (caddr_t)deh, (caddr_t)&ddpe, sizeof( struct ddpehdr ));
ddpe.deh_bytes = ntohl( ddpe.deh_bytes );
dlen = ddpe.deh_len;
  232         if (( cksum = ddpe.deh_sum ) == 0 ) {
ddpstat.ddps_nosum++;
  234         }
from.sat_addr.s_net = ddpe.deh_snet;
from.sat_addr.s_node = ddpe.deh_snode;
from.sat_port = ddpe.deh_sport;
to.sat_addr.s_net = ddpe.deh_dnet;
to.sat_addr.s_node = ddpe.deh_dnode;
to.sat_port = ddpe.deh_dport;
  243         if ( to.sat_addr.s_net == 0 ) {
  244             for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
  245                 if ( phase == 1 && ( aa->aa_flags & AFA_PHASE2 )) {
  246                     continue;
  247                 }
  248                 if ( phase == 2 && ( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
  249                     continue;
  250                 }
  251                 if ( aa->aa_ifp == ifp &&
  252                         ( AA_SAT( aa )->sat_addr.s_node == to.sat_addr.s_node ||
to.sat_addr.s_node == ATADDR_BCAST ||
  254                         ( ifp->if_flags & IFF_LOOPBACK ))) {
  255                     break;
  256                 }
  257             }
  258         } else {
  259             for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
  260                 if ( to.sat_addr.s_net == aa->aa_firstnet &&
to.sat_addr.s_node == 0 ) {
  262                     break;
  263                 }
  264                 if (( ntohs( to.sat_addr.s_net ) < ntohs( aa->aa_firstnet ) ||
ntohs( to.sat_addr.s_net ) > ntohs( aa->aa_lastnet )) &&
  266                         ( ntohs( to.sat_addr.s_net ) < 0xff00 ||
ntohs( to.sat_addr.s_net ) > 0xfffe)) {
  268                     continue;
  269                 }
  270                 if ( to.sat_addr.s_node != AA_SAT( aa )->sat_addr.s_node &&
to.sat_addr.s_node != ATADDR_BCAST ) {
  272                     continue;
  273                 }
  274                 break;
  275             }
  276         }
  277     }
  279     /*
  280      * Adjust the length, removing any padding that may have been added
  281      * at a link layer.  We do this before we attempt to forward a packet,
  282      * possibly on a different media.
  283      */
mlen = m->m_pkthdr.len;
  285     if ( mlen < dlen ) {
ddpstat.ddps_toosmall++;
m_freem( m );
  288         return;
  289     }
  290     if ( mlen > dlen ) {
m_adj( m, dlen - mlen );
  292     }
  294     /*
  295      * XXX Should we deliver broadcasts locally, also, or rely on the
  296      * link layer to give us a copy?  For the moment, the latter.
  297      */
  298     if ( aa == NULL || ( to.sat_addr.s_node == ATADDR_BCAST &&
aa->aa_ifp != ifp && ( ifp->if_flags & IFF_LOOPBACK ) == 0 )) {
  300         if ( ddp_forward == 0 ) {
m_freem( m );
  302             return;
  303         }
  304         if ( forwro.ro_rt && ( satosat( &forwro.ro_dst )->sat_addr.s_net !=
to.sat_addr.s_net ||
satosat( &forwro.ro_dst )->sat_addr.s_node !=
to.sat_addr.s_node )) {
RTFREE( forwro.ro_rt );
forwro.ro_rt = (struct rtentry *)0;
  310         }
  311         if ( forwro.ro_rt == (struct rtentry *)0 ||
forwro.ro_rt->rt_ifp == (struct ifnet *)0 ) {
forwro.ro_dst.sa_len = sizeof( struct sockaddr_at );
forwro.ro_dst.sa_family = AF_APPLETALK;
satosat( &forwro.ro_dst )->sat_addr.s_net = to.sat_addr.s_net;
satosat( &forwro.ro_dst )->sat_addr.s_node = to.sat_addr.s_node;
rtalloc( &forwro );
  318         }
  320         if ( to.sat_addr.s_net != satosat( &forwro.ro_dst )->sat_addr.s_net &&
ddpe.deh_hops == DDP_MAXHOPS ) {
m_freem( m );
  323             return;
  324         }
  326         /* XXX FreeBSD doesn't have this */
  327         if ( ddp_firewall &&
  328                 ( forwro.ro_rt == NULL || ( forwro.ro_rt->rt_ifp != ifp &&
forwro.ro_rt->rt_ifp != at_ifaddr->aa_ifp ))) {
m_freem( m );
  331             return;
  332         }
ddpe.deh_hops++;
ddpe.deh_bytes = htonl( ddpe.deh_bytes );
bcopy( (caddr_t)&ddpe, (caddr_t)deh, sizeof( u_int16_t ));
  337         if ( ddp_route( m, &forwro )) {
ddpstat.ddps_cantforward++;
  339         } else {
ddpstat.ddps_forward++;
  341         }
  342         return;
  343     }
from.sat_len = sizeof( struct sockaddr_at );
from.sat_family = AF_APPLETALK;
  348     if ( elh ) {
m_adj( m, sizeof( struct ddpshdr ));
  350     } else {
  351         /*
  352          * XXX I've always hated this about the TCP checksum, and here it
  353          * is again. ddp_cksum determines whether we compute checksums on
  354          * outgoing packets. Why is it used to disable checkumming on
  355          * incoming packets as well? If the remote node went to the
  356          * trouble of computing the checksum, shouldn't we check it?
  357          */
  358         if ( ddp_cksum && cksum && cksum != at_cksum( m, sizeof( int ))) {
ddpstat.ddps_badsum++;
m_freem( m );
  361             return;
  362         }
m_adj( m, sizeof( struct ddpehdr ));
  364     }
  366     if (( ddp = ddp_search( &from, &to, aa )) == NULL ) {
m_freem( m );
  368         return;
  369     }
  371     if ( sbappendaddr( &ddp->ddp_socket->so_rcv, (struct sockaddr *)&from,
m, (struct mbuf *)0 ) == 0 ) {
ddpstat.ddps_nosockspace++;
m_freem( m );
  375         return;
  376     }
sorwakeup( ddp->ddp_socket );
  378 }
  380 #if 0
  381 static void
m_printm( m )
  383     struct mbuf *m;
  384 {
  385     for (; m; m = m->m_next ) {
bprint( mtod( m, char * ), m->m_len );
  387     }
  388 }
  390 #define BPXLEN  48
  391 #define BPALEN  16
  392 char    hexdig[] = "0123456789ABCDEF";
  394 static void
bprint( data, len )
  396     char        *data;
  397     int         len;
  398 {
  399     char        xout[ BPXLEN ], aout[ BPALEN ];
  400     int         i = 0;
bzero( xout, BPXLEN );
bzero( aout, BPALEN );
  405     for ( ;; ) {
  406         if ( len < 1 ) {
  407             if ( i != 0 ) {
printf( "%s\t%s\n", xout, aout );
  409             }
printf( "%s\n", "(end)" );
  411             break;
  412         }
xout[ (i*3) ] = hexdig[ ( *data & 0xf0 ) >> 4 ];
xout[ (i*3) + 1 ] = hexdig[ *data & 0x0f ];
  417         if ( (u_char)*data < 0x7f && (u_char)*data > 0x20 ) {
aout[ i ] = *data;
  419         } else {
aout[ i ] = '.';
  421         }
xout[ (i*3) + 2 ] = ' ';
i++;
len--;
data++;
  429         if ( i > BPALEN - 2 ) {
printf( "%s\t%s\n", xout, aout );
bzero( xout, BPXLEN );
bzero( aout, BPALEN );
i = 0;
  434             continue;
  435         }
  436     }
  437 }
  438 #endif