Annotation of sys/netatalk/ddp_input.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ddp_input.c,v 1.4 2006/03/04 22:40:16 brad Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 1990,1994 Regents of The University of Michigan.
! 5: * All Rights Reserved. See COPYRIGHT.
! 6: */
! 7:
! 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: */
! 53:
! 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>
! 66:
! 67: #include <net/if.h>
! 68: #include <net/route.h>
! 69:
! 70: #include <machine/endian.h>
! 71:
! 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>
! 77:
! 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
! 85:
! 86: int ddp_forward = 1;
! 87: int ddp_firewall = 0;
! 88: extern int ddp_cksum;
! 89:
! 90: /*
! 91: * Could probably merge these two code segments a little better...
! 92: */
! 93: void
! 94: atintr()
! 95: {
! 96: struct elaphdr *elhp, elh;
! 97: struct ifnet *ifp;
! 98: struct mbuf *m;
! 99: struct at_ifaddr *aa;
! 100: int s;
! 101:
! 102: for (;;) {
! 103: s = splnet();
! 104:
! 105: IF_DEQUEUE( &atintrq2, m );
! 106:
! 107: splx( s );
! 108:
! 109: if ( m == 0 ) { /* no more queued packets */
! 110: break;
! 111: }
! 112:
! 113: 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 */
! 120: m_freem( m );
! 121: continue;
! 122: }
! 123:
! 124: ddp_input( m, ifp, (struct elaphdr *)NULL, 2 );
! 125: }
! 126:
! 127: for (;;) {
! 128: s = splnet();
! 129:
! 130: IF_DEQUEUE( &atintrq1, m );
! 131:
! 132: splx( s );
! 133:
! 134: if ( m == 0 ) { /* no more queued packets */
! 135: break;
! 136: }
! 137:
! 138: 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 */
! 145: m_freem( m );
! 146: continue;
! 147: }
! 148:
! 149: if ( m->m_len < SZ_ELAPHDR &&
! 150: (( m = m_pullup( m, SZ_ELAPHDR )) == 0 )) {
! 151: ddpstat.ddps_tooshort++;
! 152: continue;
! 153: }
! 154:
! 155: elhp = mtod( m, struct elaphdr *);
! 156: m_adj( m, SZ_ELAPHDR );
! 157:
! 158: if ( elhp->el_type == ELAP_DDPEXTEND ) {
! 159: ddp_input( m, ifp, (struct elaphdr *)NULL, 1 );
! 160: } else {
! 161: bcopy((caddr_t)elhp, (caddr_t)&elh, SZ_ELAPHDR );
! 162: ddp_input( m, ifp, &elh, 1 );
! 163: }
! 164: }
! 165: return;
! 166: }
! 167:
! 168: struct route forwro;
! 169:
! 170: void
! 171: 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;
! 183: u_int16_t cksum;
! 184:
! 185: bzero( (caddr_t)&from, sizeof( struct sockaddr_at ));
! 186: if ( elh ) {
! 187: ddpstat.ddps_short++;
! 188:
! 189: if ( m->m_len < sizeof( struct ddpshdr ) &&
! 190: (( m = m_pullup( m, sizeof( struct ddpshdr ))) == 0 )) {
! 191: ddpstat.ddps_tooshort++;
! 192: return;
! 193: }
! 194:
! 195: dsh = mtod( m, struct ddpshdr *);
! 196: bcopy( (caddr_t)dsh, (caddr_t)&ddps, sizeof( struct ddpshdr ));
! 197: ddps.dsh_bytes = ntohl( ddps.dsh_bytes );
! 198: dlen = ddps.dsh_len;
! 199:
! 200: to.sat_addr.s_net = 0;
! 201: to.sat_addr.s_node = elh->el_dnode;
! 202: to.sat_port = ddps.dsh_dport;
! 203: from.sat_addr.s_net = 0;
! 204: from.sat_addr.s_node = elh->el_snode;
! 205: from.sat_port = ddps.dsh_sport;
! 206:
! 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 ||
! 210: to.sat_addr.s_node == ATADDR_BCAST )) {
! 211: break;
! 212: }
! 213: }
! 214: if ( aa == NULL ) {
! 215: m_freem( m );
! 216: return;
! 217: }
! 218: } else {
! 219: ddpstat.ddps_long++;
! 220:
! 221: if ( m->m_len < sizeof( struct ddpehdr ) &&
! 222: (( m = m_pullup( m, sizeof( struct ddpehdr ))) == 0 )) {
! 223: ddpstat.ddps_tooshort++;
! 224: return;
! 225: }
! 226:
! 227: deh = mtod( m, struct ddpehdr *);
! 228: bcopy( (caddr_t)deh, (caddr_t)&ddpe, sizeof( struct ddpehdr ));
! 229: ddpe.deh_bytes = ntohl( ddpe.deh_bytes );
! 230: dlen = ddpe.deh_len;
! 231:
! 232: if (( cksum = ddpe.deh_sum ) == 0 ) {
! 233: ddpstat.ddps_nosum++;
! 234: }
! 235:
! 236: from.sat_addr.s_net = ddpe.deh_snet;
! 237: from.sat_addr.s_node = ddpe.deh_snode;
! 238: from.sat_port = ddpe.deh_sport;
! 239: to.sat_addr.s_net = ddpe.deh_dnet;
! 240: to.sat_addr.s_node = ddpe.deh_dnode;
! 241: to.sat_port = ddpe.deh_dport;
! 242:
! 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 ||
! 253: 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 &&
! 261: to.sat_addr.s_node == 0 ) {
! 262: break;
! 263: }
! 264: if (( ntohs( to.sat_addr.s_net ) < ntohs( aa->aa_firstnet ) ||
! 265: ntohs( to.sat_addr.s_net ) > ntohs( aa->aa_lastnet )) &&
! 266: ( ntohs( to.sat_addr.s_net ) < 0xff00 ||
! 267: ntohs( to.sat_addr.s_net ) > 0xfffe)) {
! 268: continue;
! 269: }
! 270: if ( to.sat_addr.s_node != AA_SAT( aa )->sat_addr.s_node &&
! 271: to.sat_addr.s_node != ATADDR_BCAST ) {
! 272: continue;
! 273: }
! 274: break;
! 275: }
! 276: }
! 277: }
! 278:
! 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: */
! 284: mlen = m->m_pkthdr.len;
! 285: if ( mlen < dlen ) {
! 286: ddpstat.ddps_toosmall++;
! 287: m_freem( m );
! 288: return;
! 289: }
! 290: if ( mlen > dlen ) {
! 291: m_adj( m, dlen - mlen );
! 292: }
! 293:
! 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 &&
! 299: aa->aa_ifp != ifp && ( ifp->if_flags & IFF_LOOPBACK ) == 0 )) {
! 300: if ( ddp_forward == 0 ) {
! 301: m_freem( m );
! 302: return;
! 303: }
! 304: if ( forwro.ro_rt && ( satosat( &forwro.ro_dst )->sat_addr.s_net !=
! 305: to.sat_addr.s_net ||
! 306: satosat( &forwro.ro_dst )->sat_addr.s_node !=
! 307: to.sat_addr.s_node )) {
! 308: RTFREE( forwro.ro_rt );
! 309: forwro.ro_rt = (struct rtentry *)0;
! 310: }
! 311: if ( forwro.ro_rt == (struct rtentry *)0 ||
! 312: forwro.ro_rt->rt_ifp == (struct ifnet *)0 ) {
! 313: forwro.ro_dst.sa_len = sizeof( struct sockaddr_at );
! 314: forwro.ro_dst.sa_family = AF_APPLETALK;
! 315: satosat( &forwro.ro_dst )->sat_addr.s_net = to.sat_addr.s_net;
! 316: satosat( &forwro.ro_dst )->sat_addr.s_node = to.sat_addr.s_node;
! 317: rtalloc( &forwro );
! 318: }
! 319:
! 320: if ( to.sat_addr.s_net != satosat( &forwro.ro_dst )->sat_addr.s_net &&
! 321: ddpe.deh_hops == DDP_MAXHOPS ) {
! 322: m_freem( m );
! 323: return;
! 324: }
! 325:
! 326: /* XXX FreeBSD doesn't have this */
! 327: if ( ddp_firewall &&
! 328: ( forwro.ro_rt == NULL || ( forwro.ro_rt->rt_ifp != ifp &&
! 329: forwro.ro_rt->rt_ifp != at_ifaddr->aa_ifp ))) {
! 330: m_freem( m );
! 331: return;
! 332: }
! 333:
! 334: ddpe.deh_hops++;
! 335: ddpe.deh_bytes = htonl( ddpe.deh_bytes );
! 336: bcopy( (caddr_t)&ddpe, (caddr_t)deh, sizeof( u_int16_t ));
! 337: if ( ddp_route( m, &forwro )) {
! 338: ddpstat.ddps_cantforward++;
! 339: } else {
! 340: ddpstat.ddps_forward++;
! 341: }
! 342: return;
! 343: }
! 344:
! 345: from.sat_len = sizeof( struct sockaddr_at );
! 346: from.sat_family = AF_APPLETALK;
! 347:
! 348: if ( elh ) {
! 349: 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 ))) {
! 359: ddpstat.ddps_badsum++;
! 360: m_freem( m );
! 361: return;
! 362: }
! 363: m_adj( m, sizeof( struct ddpehdr ));
! 364: }
! 365:
! 366: if (( ddp = ddp_search( &from, &to, aa )) == NULL ) {
! 367: m_freem( m );
! 368: return;
! 369: }
! 370:
! 371: if ( sbappendaddr( &ddp->ddp_socket->so_rcv, (struct sockaddr *)&from,
! 372: m, (struct mbuf *)0 ) == 0 ) {
! 373: ddpstat.ddps_nosockspace++;
! 374: m_freem( m );
! 375: return;
! 376: }
! 377: sorwakeup( ddp->ddp_socket );
! 378: }
! 379:
! 380: #if 0
! 381: static void
! 382: m_printm( m )
! 383: struct mbuf *m;
! 384: {
! 385: for (; m; m = m->m_next ) {
! 386: bprint( mtod( m, char * ), m->m_len );
! 387: }
! 388: }
! 389:
! 390: #define BPXLEN 48
! 391: #define BPALEN 16
! 392: char hexdig[] = "0123456789ABCDEF";
! 393:
! 394: static void
! 395: bprint( data, len )
! 396: char *data;
! 397: int len;
! 398: {
! 399: char xout[ BPXLEN ], aout[ BPALEN ];
! 400: int i = 0;
! 401:
! 402: bzero( xout, BPXLEN );
! 403: bzero( aout, BPALEN );
! 404:
! 405: for ( ;; ) {
! 406: if ( len < 1 ) {
! 407: if ( i != 0 ) {
! 408: printf( "%s\t%s\n", xout, aout );
! 409: }
! 410: printf( "%s\n", "(end)" );
! 411: break;
! 412: }
! 413:
! 414: xout[ (i*3) ] = hexdig[ ( *data & 0xf0 ) >> 4 ];
! 415: xout[ (i*3) + 1 ] = hexdig[ *data & 0x0f ];
! 416:
! 417: if ( (u_char)*data < 0x7f && (u_char)*data > 0x20 ) {
! 418: aout[ i ] = *data;
! 419: } else {
! 420: aout[ i ] = '.';
! 421: }
! 422:
! 423: xout[ (i*3) + 2 ] = ' ';
! 424:
! 425: i++;
! 426: len--;
! 427: data++;
! 428:
! 429: if ( i > BPALEN - 2 ) {
! 430: printf( "%s\t%s\n", xout, aout );
! 431: bzero( xout, BPXLEN );
! 432: bzero( aout, BPALEN );
! 433: i = 0;
! 434: continue;
! 435: }
! 436: }
! 437: }
! 438: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ddp_input.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netatalk