Annotation of sys/netatalk/ddp_usrreq.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ddp_usrreq.c,v 1.8 2007/05/26 12:09:40 claudio 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/errno.h>
! 55: #include <sys/types.h>
! 56: #include <sys/param.h>
! 57: #include <sys/systm.h>
! 58: #include <sys/proc.h>
! 59: #include <sys/user.h>
! 60: #include <sys/mbuf.h>
! 61: #include <sys/ioctl.h>
! 62: #include <sys/socket.h>
! 63: #include <sys/socketvar.h>
! 64: #include <sys/protosw.h>
! 65: #include <net/if.h>
! 66: #include <net/route.h>
! 67:
! 68: #include <machine/endian.h>
! 69:
! 70: #include <netatalk/at.h>
! 71: #include <netatalk/at_var.h>
! 72: #include <netatalk/ddp_var.h>
! 73: #include <netatalk/at_extern.h>
! 74:
! 75: int ddp_usrreq(struct socket *, int, struct mbuf *,
! 76: struct mbuf *, struct mbuf * );
! 77: static void at_sockaddr( struct ddpcb *, struct mbuf * );
! 78: static int at_pcbsetaddr( struct ddpcb *, struct mbuf *,
! 79: struct proc * );
! 80: static int at_pcbconnect( struct ddpcb *, struct mbuf *,
! 81: struct proc *);
! 82: static void at_pcbdisconnect( struct ddpcb * );
! 83: static int at_pcballoc( struct socket * );
! 84: static void at_pcbdetach( struct socket *, struct ddpcb * );
! 85: struct ddpcb *ddp_search( struct sockaddr_at *,
! 86: struct sockaddr_at *, struct at_ifaddr * );
! 87: void ddp_init(void);
! 88:
! 89: struct at_ifaddr *at_ifaddr;
! 90: struct ifqueue atintrq1, atintrq2;
! 91: int atdebug;
! 92:
! 93: struct ddpcb *ddp_ports[ ATPORT_LAST ];
! 94: struct ddpstat ddpstat;
! 95:
! 96: struct ddpcb *ddpcb = NULL;
! 97: u_long ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
! 98: u_long ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at ));
! 99:
! 100: /*ARGSUSED*/
! 101: int
! 102: ddp_usrreq( so, req, m, addr, rights )
! 103: struct socket *so;
! 104: int req;
! 105: struct mbuf *m, *addr, *rights;
! 106: {
! 107: /* XXX Need to pass p into this routine */
! 108: struct proc *p = curproc;
! 109: struct ddpcb *ddp;
! 110: int error = 0;
! 111:
! 112: ddp = sotoddpcb( so );
! 113:
! 114: if ( req == PRU_CONTROL ) {
! 115: return( at_control( (u_long) m, (caddr_t) addr,
! 116: (struct ifnet *) rights, p ));
! 117: }
! 118:
! 119: if ( rights && rights->m_len ) {
! 120: error = EINVAL;
! 121: goto release;
! 122: }
! 123:
! 124: if ( ddp == NULL && req != PRU_ATTACH ) {
! 125: error = EINVAL;
! 126: goto release;
! 127: }
! 128:
! 129: switch ( req ) {
! 130: case PRU_ATTACH :
! 131: if ( ddp != NULL ) {
! 132: error = EINVAL;
! 133: break;
! 134: }
! 135: if (( error = at_pcballoc( so )) != 0 ) {
! 136: break;
! 137: }
! 138: error = soreserve( so, ddp_sendspace, ddp_recvspace );
! 139: break;
! 140:
! 141: case PRU_DETACH :
! 142: at_pcbdetach( so, ddp );
! 143: break;
! 144:
! 145: case PRU_BIND :
! 146: error = at_pcbsetaddr( ddp, addr, p );
! 147: break;
! 148:
! 149: case PRU_SOCKADDR :
! 150: at_sockaddr( ddp, addr );
! 151: break;
! 152:
! 153: case PRU_CONNECT:
! 154: if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
! 155: error = EISCONN;
! 156: break;
! 157: }
! 158:
! 159: error = at_pcbconnect( ddp, addr, p );
! 160: if ( error == 0 )
! 161: soisconnected( so );
! 162: break;
! 163:
! 164: case PRU_DISCONNECT:
! 165: if ( ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE ) {
! 166: error = ENOTCONN;
! 167: break;
! 168: }
! 169: at_pcbdisconnect( ddp );
! 170: soisdisconnected( so );
! 171: break;
! 172:
! 173: case PRU_SHUTDOWN:
! 174: socantsendmore( so );
! 175: break;
! 176:
! 177: case PRU_SEND: {
! 178: int s;
! 179:
! 180: if ( addr ) {
! 181: if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
! 182: error = EISCONN;
! 183: break;
! 184: }
! 185:
! 186: s = splnet();
! 187: error = at_pcbconnect( ddp, addr, p );
! 188: if ( error ) {
! 189: splx( s );
! 190: break;
! 191: }
! 192: } else {
! 193: if ( ddp->ddp_fsat.sat_port == ATADDR_ANYPORT ) {
! 194: error = ENOTCONN;
! 195: break;
! 196: }
! 197: }
! 198:
! 199: error = ddp_output( m, ddp );
! 200: m = NULL;
! 201: if ( addr ) {
! 202: at_pcbdisconnect( ddp );
! 203: splx( s );
! 204: }
! 205: }
! 206: break;
! 207:
! 208: case PRU_ABORT:
! 209: soisdisconnected( so );
! 210: at_pcbdetach( so, ddp );
! 211: break;
! 212:
! 213: case PRU_LISTEN:
! 214: case PRU_CONNECT2:
! 215: case PRU_ACCEPT:
! 216: case PRU_SENDOOB:
! 217: case PRU_FASTTIMO:
! 218: case PRU_SLOWTIMO:
! 219: case PRU_PROTORCV:
! 220: case PRU_PROTOSEND:
! 221: error = EOPNOTSUPP;
! 222: break;
! 223:
! 224: case PRU_RCVD:
! 225: case PRU_RCVOOB:
! 226: /*
! 227: * Don't mfree. Good architecture...
! 228: */
! 229: return( EOPNOTSUPP );
! 230:
! 231: case PRU_SENSE:
! 232: /*
! 233: * 1. Don't return block size.
! 234: * 2. Don't mfree.
! 235: */
! 236: return( 0 );
! 237:
! 238: default:
! 239: error = EOPNOTSUPP;
! 240: }
! 241:
! 242: release:
! 243: if ( m != NULL ) {
! 244: m_freem( m );
! 245: }
! 246: return( error );
! 247: }
! 248:
! 249: static void
! 250: at_sockaddr( ddp, addr )
! 251: struct ddpcb *ddp;
! 252: struct mbuf *addr;
! 253: {
! 254: struct sockaddr_at *sat;
! 255:
! 256: addr->m_len = sizeof( struct sockaddr_at );
! 257: sat = mtod( addr, struct sockaddr_at *);
! 258: *sat = ddp->ddp_lsat;
! 259: }
! 260:
! 261: static int
! 262: at_pcbsetaddr( ddp, addr, p )
! 263: struct ddpcb *ddp;
! 264: struct mbuf *addr;
! 265: struct proc *p;
! 266: {
! 267: struct sockaddr_at lsat, *sat;
! 268: struct at_ifaddr *aa;
! 269: struct ddpcb *ddpp;
! 270:
! 271: if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT ) { /* shouldn't be bound */
! 272: return( EINVAL );
! 273: }
! 274:
! 275: if ( addr != 0 ) { /* validate passed address */
! 276: sat = mtod( addr, struct sockaddr_at *);
! 277: if ( addr->m_len != sizeof( *sat )) {
! 278: return( EINVAL );
! 279: }
! 280: if ( sat->sat_family != AF_APPLETALK ) {
! 281: return( EAFNOSUPPORT );
! 282: }
! 283:
! 284: if ( sat->sat_addr.s_node != ATADDR_ANYNODE ||
! 285: sat->sat_addr.s_net != ATADDR_ANYNET ) {
! 286: for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
! 287: if (( sat->sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) &&
! 288: ( sat->sat_addr.s_node == AA_SAT( aa )->sat_addr.s_node )) {
! 289: break;
! 290: }
! 291: }
! 292: if ( !aa ) {
! 293: return( EADDRNOTAVAIL );
! 294: }
! 295: }
! 296:
! 297: if ( sat->sat_port != ATADDR_ANYPORT ) {
! 298: if ( sat->sat_port < ATPORT_FIRST ||
! 299: sat->sat_port >= ATPORT_LAST ) {
! 300: return( EINVAL );
! 301: }
! 302: if ( sat->sat_port < ATPORT_RESERVED &&
! 303: suser( p, 0 )) {
! 304: return( EACCES );
! 305: }
! 306: }
! 307: } else {
! 308: bzero( (caddr_t)&lsat, sizeof( struct sockaddr_at ));
! 309: lsat.sat_family = AF_APPLETALK;
! 310: sat = &lsat;
! 311: }
! 312:
! 313: if ( sat->sat_addr.s_node == ATADDR_ANYNODE &&
! 314: sat->sat_addr.s_net == ATADDR_ANYNET ) {
! 315: if ( at_ifaddr == NULL ) {
! 316: return( EADDRNOTAVAIL );
! 317: }
! 318: sat->sat_addr = AA_SAT( at_ifaddr )->sat_addr;
! 319: }
! 320: ddp->ddp_lsat = *sat;
! 321:
! 322: /*
! 323: * Choose port.
! 324: */
! 325: if ( sat->sat_port == ATADDR_ANYPORT ) {
! 326: for ( sat->sat_port = ATPORT_RESERVED;
! 327: sat->sat_port < ATPORT_LAST; sat->sat_port++ ) {
! 328: if ( ddp_ports[ sat->sat_port - 1 ] == 0 ) {
! 329: break;
! 330: }
! 331: }
! 332: if ( sat->sat_port == ATPORT_LAST ) {
! 333: return( EADDRNOTAVAIL );
! 334: }
! 335: ddp->ddp_lsat.sat_port = sat->sat_port;
! 336: ddp_ports[ sat->sat_port - 1 ] = ddp;
! 337: } else {
! 338: for ( ddpp = ddp_ports[ sat->sat_port - 1 ]; ddpp;
! 339: ddpp = ddpp->ddp_pnext ) {
! 340: if ( ddpp->ddp_lsat.sat_addr.s_net == sat->sat_addr.s_net &&
! 341: ddpp->ddp_lsat.sat_addr.s_node == sat->sat_addr.s_node ) {
! 342: break;
! 343: }
! 344: }
! 345: if ( ddpp != NULL ) {
! 346: return( EADDRINUSE );
! 347: }
! 348: ddp->ddp_pnext = ddp_ports[ sat->sat_port - 1 ];
! 349: ddp_ports[ sat->sat_port - 1 ] = ddp;
! 350: if ( ddp->ddp_pnext ) {
! 351: ddp->ddp_pnext->ddp_pprev = ddp;
! 352: }
! 353: }
! 354:
! 355: return( 0 );
! 356: }
! 357:
! 358: static int
! 359: at_pcbconnect( ddp, addr, p )
! 360: struct ddpcb *ddp;
! 361: struct mbuf *addr;
! 362: struct proc *p;
! 363: {
! 364: struct sockaddr_at *sat = mtod( addr, struct sockaddr_at *);
! 365: struct route *ro;
! 366: struct at_ifaddr *aa = 0;
! 367: struct ifnet *ifp;
! 368: u_int16_t hintnet = 0, net;
! 369:
! 370: if ( addr->m_len != sizeof( *sat ))
! 371: return( EINVAL );
! 372: if ( sat->sat_family != AF_APPLETALK ) {
! 373: return( EAFNOSUPPORT );
! 374: }
! 375:
! 376: /*
! 377: * Under phase 2, network 0 means "the network". We take "the
! 378: * network" to mean the network the control block is bound to.
! 379: * If the control block is not bound, there is an error.
! 380: */
! 381: if ( sat->sat_addr.s_net == 0 && sat->sat_addr.s_node != ATADDR_ANYNODE ) {
! 382: if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
! 383: return( EADDRNOTAVAIL );
! 384: }
! 385: hintnet = ddp->ddp_lsat.sat_addr.s_net;
! 386: }
! 387:
! 388: ro = &ddp->ddp_route;
! 389: /*
! 390: * If we've got an old route for this pcb, check that it is valid.
! 391: * If we've changed our address, we may have an old "good looking"
! 392: * route here. Attempt to detect it.
! 393: */
! 394: if ( ro->ro_rt ) {
! 395: if ( hintnet ) {
! 396: net = hintnet;
! 397: } else {
! 398: net = sat->sat_addr.s_net;
! 399: }
! 400: aa = 0;
! 401: if ( (ifp = ro->ro_rt->rt_ifp) != NULL ) {
! 402: for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
! 403: if ( aa->aa_ifp == ifp &&
! 404: ntohs( net ) >= ntohs( aa->aa_firstnet ) &&
! 405: ntohs( net ) <= ntohs( aa->aa_lastnet )) {
! 406: break;
! 407: }
! 408: }
! 409: }
! 410: if ( aa == NULL || ( satosat( &ro->ro_dst )->sat_addr.s_net !=
! 411: ( hintnet ? hintnet : sat->sat_addr.s_net ) ||
! 412: satosat( &ro->ro_dst )->sat_addr.s_node !=
! 413: sat->sat_addr.s_node )) {
! 414: RTFREE( ro->ro_rt );
! 415: ro->ro_rt = (struct rtentry *)0;
! 416: }
! 417: }
! 418:
! 419: /*
! 420: * If we've got no route for this interface, try to find one.
! 421: */
! 422: if ( ro->ro_rt == (struct rtentry *)0 ||
! 423: ro->ro_rt->rt_ifp == (struct ifnet *)0 ) {
! 424: ro->ro_dst.sa_len = sizeof( struct sockaddr_at );
! 425: ro->ro_dst.sa_family = AF_APPLETALK;
! 426: if ( hintnet != 0 ) {
! 427: satosat( &ro->ro_dst )->sat_addr.s_net = hintnet;
! 428: } else {
! 429: satosat( &ro->ro_dst )->sat_addr.s_net = sat->sat_addr.s_net;
! 430: }
! 431: satosat( &ro->ro_dst )->sat_addr.s_node = sat->sat_addr.s_node;
! 432: rtalloc( ro );
! 433: }
! 434:
! 435: /*
! 436: * Make sure any route that we have has a valid interface.
! 437: */
! 438: aa = 0;
! 439: if ( ro->ro_rt && ( ifp = ro->ro_rt->rt_ifp )) {
! 440: for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
! 441: if ( aa->aa_ifp == ifp ) {
! 442: break;
! 443: }
! 444: }
! 445: }
! 446: if ( aa == 0 ) {
! 447: return( ENETUNREACH );
! 448: }
! 449:
! 450: ddp->ddp_fsat = *sat;
! 451: if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
! 452: return( at_pcbsetaddr( ddp, (struct mbuf *)0, p ));
! 453: }
! 454: return( 0 );
! 455: }
! 456:
! 457: static void
! 458: at_pcbdisconnect( ddp )
! 459: struct ddpcb *ddp;
! 460: {
! 461: ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
! 462: ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
! 463: ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
! 464: }
! 465:
! 466: static int
! 467: at_pcballoc( so )
! 468: struct socket *so;
! 469: {
! 470: struct ddpcb *ddp;
! 471:
! 472: MALLOC( ddp, struct ddpcb *, sizeof( *ddp ), M_PCB, M_NOWAIT );
! 473: if ( ddp == NULL ) {
! 474: return (ENOBUFS);
! 475: }
! 476: bzero( ddp, sizeof( *ddp ));
! 477:
! 478: ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
! 479:
! 480: ddp->ddp_next = ddpcb;
! 481: ddp->ddp_prev = NULL;
! 482: ddp->ddp_pprev = NULL;
! 483: ddp->ddp_pnext = NULL;
! 484: if ( ddpcb ) {
! 485: ddpcb->ddp_prev = ddp;
! 486: }
! 487: ddpcb = ddp;
! 488:
! 489: ddp->ddp_socket = so;
! 490: so->so_pcb = (caddr_t)ddp;
! 491: return( 0 );
! 492: }
! 493:
! 494: static void
! 495: at_pcbdetach( so, ddp )
! 496: struct socket *so;
! 497: struct ddpcb *ddp;
! 498: {
! 499: soisdisconnected( so );
! 500: so->so_pcb = 0;
! 501: sofree( so );
! 502:
! 503: /* remove ddp from ddp_ports list */
! 504: if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
! 505: ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] != NULL ) {
! 506: if ( ddp->ddp_pprev != NULL ) {
! 507: ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
! 508: } else {
! 509: ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] = ddp->ddp_pnext;
! 510: }
! 511: if ( ddp->ddp_pnext != NULL ) {
! 512: ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
! 513: }
! 514: }
! 515:
! 516: if ( ddp->ddp_route.ro_rt ) {
! 517: rtfree( ddp->ddp_route.ro_rt );
! 518: }
! 519:
! 520: if ( ddp->ddp_prev ) {
! 521: ddp->ddp_prev->ddp_next = ddp->ddp_next;
! 522: } else {
! 523: ddpcb = ddp->ddp_next;
! 524: }
! 525: if ( ddp->ddp_next ) {
! 526: ddp->ddp_next->ddp_prev = ddp->ddp_prev;
! 527: }
! 528:
! 529: FREE( ddp, M_PCB );
! 530: }
! 531:
! 532: /*
! 533: * For the moment, this just find the pcb with the correct local address.
! 534: * In the future, this will actually do some real searching, so we can use
! 535: * the sender's address to do de-multiplexing on a single port to many
! 536: * sockets (pcbs).
! 537: */
! 538: struct ddpcb *
! 539: ddp_search( from, to, aa )
! 540: struct sockaddr_at *from, *to;
! 541: struct at_ifaddr *aa;
! 542: {
! 543: struct ddpcb *ddp;
! 544:
! 545: /*
! 546: * Check for bad ports.
! 547: */
! 548: if ( to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST ) {
! 549: return( NULL );
! 550: }
! 551:
! 552: /*
! 553: * Make sure the local address matches the sent address. What about
! 554: * the interface?
! 555: */
! 556: for ( ddp = ddp_ports[ to->sat_port - 1 ]; ddp; ddp = ddp->ddp_pnext ) {
! 557: /* XXX should we handle 0.YY? */
! 558:
! 559: /* XXXX.YY to socket on destination interface */
! 560: if ( to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
! 561: to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node ) {
! 562: break;
! 563: }
! 564:
! 565: /* 0.255 to socket on receiving interface */
! 566: if ( to->sat_addr.s_node == ATADDR_BCAST && ( to->sat_addr.s_net == 0 ||
! 567: to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net ) &&
! 568: ddp->ddp_lsat.sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) {
! 569: break;
! 570: }
! 571:
! 572: /* XXXX.0 to socket on destination interface */
! 573: if ( to->sat_addr.s_net == aa->aa_firstnet &&
! 574: to->sat_addr.s_node == 0 &&
! 575: ntohs( ddp->ddp_lsat.sat_addr.s_net ) >=
! 576: ntohs( aa->aa_firstnet ) &&
! 577: ntohs( ddp->ddp_lsat.sat_addr.s_net ) <=
! 578: ntohs( aa->aa_lastnet )) {
! 579: break;
! 580: }
! 581: }
! 582: return( ddp );
! 583: }
! 584:
! 585: void
! 586: ddp_init()
! 587: {
! 588: atintrq1.ifq_maxlen = IFQ_MAXLEN;
! 589: atintrq2.ifq_maxlen = IFQ_MAXLEN;
! 590: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ddp_usrreq.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netatalk