sys/netproto/atalk/ddp_usrreq.c

   1 /*
   2  * Copyright (c) 1990,1994 Regents of The University of Michigan.
   3  * All Rights Reserved.  See COPYRIGHT.
   4  *
   5  * $DragonFly: src/sys/netproto/atalk/ddp_usrreq.c,v 1.8 2004/06/06 19:16:12 dillon Exp $
   6  */
   7
   8 #include <sys/param.h>
   9 #include <sys/systm.h>
  10 #include <sys/proc.h>
  11 #include <sys/malloc.h>
  12 #include <sys/mbuf.h>
  13 #include <sys/socket.h>
  14 #include <sys/socketvar.h>
  15 #include <sys/protosw.h>
  16 #include <net/if.h>
  17 #include <net/netisr.h>
  18 #include <net/route.h>
  19
  20 #include "at.h"
  21 #include "at_var.h"
  22 #include "ddp_var.h"
  23 #include "at_extern.h"
  24
  25 static void at_pcbdisconnect( struct ddpcb *ddp );
  26 static void at_sockaddr(struct ddpcb *ddp, struct sockaddr **addr);
  27 static int at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr,
  28                           struct thread *td);
  29 static int at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr,
  30                          struct thread *td);
  31 static void at_pcbdetach(struct socket *so, struct ddpcb *ddp);
  32 static int at_pcballoc(struct socket *so);
  33
  34 struct ddpcb    *ddp_ports[ ATPORT_LAST ];
  35 struct ddpcb    *ddpcb = NULL;
  36 static u_long   ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
  37 static u_long   ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at ));
  38
  39 static int
  40 ddp_attach(struct socket *so, int proto, struct pru_attach_info *ai)
  41 {
  42         struct ddpcb    *ddp;
  43         int             error = 0;
  44         int             s;
  45
  46
  47         ddp = sotoddpcb( so );
  48         if ( ddp != NULL ) {
  49             return( EINVAL);
  50         }
  51
  52         s = splnet();
  53         error = at_pcballoc( so );
  54         splx(s);
  55         if (error) {
  56             return (error);
  57         }
  58         return (soreserve( so, ddp_sendspace, ddp_recvspace, ai->sb_rlimit ));
  59 }
  60
  61 static int
  62 ddp_detach(struct socket *so)
  63 {
  64         struct ddpcb    *ddp;
  65         int             s;
  66
  67         ddp = sotoddpcb( so );
  68         if ( ddp == NULL ) {
  69             return( EINVAL);
  70         }
  71         s = splnet();
  72         at_pcbdetach( so, ddp );
  73         splx(s);
  74         return(0);
  75 }
  76
  77 static int
  78 ddp_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
  79 {
  80         struct ddpcb    *ddp;
  81         int             error = 0;
  82         int             s;
  83
  84         ddp = sotoddpcb( so );
  85         if ( ddp == NULL ) {
  86             return( EINVAL);
  87         }
  88         s = splnet();
  89         error = at_pcbsetaddr(ddp, nam, td);
  90         splx(s);
  91         return (error);
  92 }
  93
  94 static int
  95 ddp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
  96 {
  97         struct ddpcb    *ddp;
  98         int             error = 0;
  99         int             s;
 100
 101         ddp = sotoddpcb( so );
 102         if ( ddp == NULL ) {
 103             return( EINVAL);
 104         }
 105
 106         if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
 107             return(EISCONN);
 108         }
 109
 110         s = splnet();
 111         error = at_pcbconnect( ddp, nam, td );
 112         splx(s);
 113         if ( error == 0 )
 114             soisconnected( so );
 115         return(error);
 116 }
 117
 118 static int
 119 ddp_disconnect(struct socket *so)
 120 {
 121
 122         struct ddpcb    *ddp;
 123         int             s;
 124
 125         ddp = sotoddpcb( so );
 126         if ( ddp == NULL ) {
 127             return( EINVAL);
 128         }
 129         if ( ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE ) {
 130             return(ENOTCONN);
 131         }
 132
 133         s = splnet();
 134         at_pcbdisconnect( ddp );
 135         ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
 136         splx(s);
 137         soisdisconnected( so );
 138         return(0);
 139 }
 140
 141 static int
 142 ddp_shutdown(struct socket *so)
 143 {
 144         struct ddpcb    *ddp;
 145
 146         ddp = sotoddpcb( so );
 147         if ( ddp == NULL ) {
 148                 return( EINVAL);
 149         }
 150         socantsendmore( so );
 151         return(0);
 152 }
 153
 154 static int
 155 ddp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
 156             struct mbuf *control, struct thread *td)
 157 {
 158         struct ddpcb    *ddp;
 159         int             error = 0;
 160         int             s;
 161
 162         ddp = sotoddpcb( so );
 163         if ( ddp == NULL ) {
 164                 return(EINVAL);
 165         }
 166
 167         if ( control && control->m_len ) {
 168                 return(EINVAL);
 169         }
 170
 171         if ( addr ) {
 172                 if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
 173                         return(EISCONN);
 174                 }
 175
 176                 s = splnet();
 177                 error = at_pcbconnect(ddp, addr, td);
 178                 splx( s );
 179                 if ( error ) {
 180                         return(error);
 181                 }
 182         } else {
 183                 if ( ddp->ddp_fsat.sat_port == ATADDR_ANYPORT ) {
 184                         return(ENOTCONN);
 185                 }
 186         }
 187
 188         s = splnet();
 189         error = ddp_output( m, so );
 190         if ( addr ) {
 191             at_pcbdisconnect( ddp );
 192         }
 193         splx(s);
 194         return(error);
 195 }
 196
 197 static int
 198 ddp_abort(struct socket *so)
 199 {
 200         struct ddpcb    *ddp;
 201         int             s;
 202
 203         ddp = sotoddpcb( so );
 204         if ( ddp == NULL ) {
 205                 return(EINVAL);
 206         }
 207         soisdisconnected( so );
 208         s = splnet();
 209         at_pcbdetach( so, ddp );
 210         splx(s);
 211         return(0);
 212 }
 213
 214
 215 static void
 216 at_sockaddr(struct ddpcb *ddp, struct sockaddr **addr)
 217 {
 218     *addr = dup_sockaddr((struct sockaddr *)&ddp->ddp_lsat);
 219 }
 220
 221 static int
 222 at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
 223 {
 224     struct sockaddr_at  lsat, *sat;
 225     struct at_ifaddr    *aa;
 226     struct ddpcb        *ddpp;
 227
 228     if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT ) { /* shouldn't be bound */
 229         return( EINVAL );
 230     }
 231
 232     if (addr != 0) {                    /* validate passed address */
 233         sat = (struct sockaddr_at *)addr;
 234         if (sat->sat_family != AF_APPLETALK) {
 235             return(EAFNOSUPPORT);
 236         }
 237
 238         if ( sat->sat_addr.s_node != ATADDR_ANYNODE ||
 239                 sat->sat_addr.s_net != ATADDR_ANYNET ) {
 240             for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 241                 if (( sat->sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) &&
 242                  ( sat->sat_addr.s_node == AA_SAT( aa )->sat_addr.s_node )) {
 243                     break;
 244                 }
 245             }
 246             if ( !aa ) {
 247                 return( EADDRNOTAVAIL );
 248             }
 249         }
 250
 251         if ( sat->sat_port != ATADDR_ANYPORT ) {
 252             if ( sat->sat_port < ATPORT_FIRST ||
 253                     sat->sat_port >= ATPORT_LAST ) {
 254                 return( EINVAL );
 255             }
 256             if ( sat->sat_port < ATPORT_RESERVED &&
 257                  suser(td) ) {
 258                 return( EACCES );
 259             }
 260         }
 261     } else {
 262         bzero( (caddr_t)&lsat, sizeof( struct sockaddr_at ));
 263         lsat.sat_len = sizeof(struct sockaddr_at);
 264         lsat.sat_addr.s_node = ATADDR_ANYNODE;
 265         lsat.sat_addr.s_net = ATADDR_ANYNET;
 266         lsat.sat_family = AF_APPLETALK;
 267         sat = &lsat;
 268     }
 269
 270     if ( sat->sat_addr.s_node == ATADDR_ANYNODE &&
 271             sat->sat_addr.s_net == ATADDR_ANYNET ) {
 272         if ( at_ifaddr == NULL ) {
 273             return( EADDRNOTAVAIL );
 274         }
 275         sat->sat_addr = AA_SAT( at_ifaddr )->sat_addr;
 276     }
 277     ddp->ddp_lsat = *sat;
 278
 279     /*
 280      * Choose port.
 281      */
 282     if ( sat->sat_port == ATADDR_ANYPORT ) {
 283         for ( sat->sat_port = ATPORT_RESERVED;
 284                 sat->sat_port < ATPORT_LAST; sat->sat_port++ ) {
 285             if ( ddp_ports[ sat->sat_port - 1 ] == 0 ) {
 286                 break;
 287             }
 288         }
 289         if ( sat->sat_port == ATPORT_LAST ) {
 290             return( EADDRNOTAVAIL );
 291         }
 292         ddp->ddp_lsat.sat_port = sat->sat_port;
 293         ddp_ports[ sat->sat_port - 1 ] = ddp;
 294     } else {
 295         for ( ddpp = ddp_ports[ sat->sat_port - 1 ]; ddpp;
 296                 ddpp = ddpp->ddp_pnext ) {
 297             if ( ddpp->ddp_lsat.sat_addr.s_net == sat->sat_addr.s_net &&
 298                     ddpp->ddp_lsat.sat_addr.s_node == sat->sat_addr.s_node ) {
 299                 break;
 300             }
 301         }
 302         if ( ddpp != NULL ) {
 303             return( EADDRINUSE );
 304         }
 305         ddp->ddp_pnext = ddp_ports[ sat->sat_port - 1 ];
 306         ddp_ports[ sat->sat_port - 1 ] = ddp;
 307         if ( ddp->ddp_pnext ) {
 308             ddp->ddp_pnext->ddp_pprev = ddp;
 309         }
 310     }
 311
 312     return( 0 );
 313 }
 314
 315 static int
 316 at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
 317 {
 318     struct sockaddr_at  *sat = (struct sockaddr_at *)addr;
 319     struct route        *ro;
 320     struct at_ifaddr    *aa = 0;
 321     struct ifnet        *ifp;
 322     u_short             hintnet = 0, net;
 323
 324     if (sat->sat_family != AF_APPLETALK) {
 325         return(EAFNOSUPPORT);
 326     }
 327
 328     /*
 329      * Under phase 2, network 0 means "the network".  We take "the
 330      * network" to mean the network the control block is bound to.
 331      * If the control block is not bound, there is an error.
 332      */
 333     if ( sat->sat_addr.s_net == ATADDR_ANYNET
 334                 && sat->sat_addr.s_node != ATADDR_ANYNODE ) {
 335         if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
 336             return( EADDRNOTAVAIL );
 337         }
 338         hintnet = ddp->ddp_lsat.sat_addr.s_net;
 339     }
 340
 341     ro = &ddp->ddp_route;
 342     /*
 343      * If we've got an old route for this pcb, check that it is valid.
 344      * If we've changed our address, we may have an old "good looking"
 345      * route here.  Attempt to detect it.
 346      */
 347     if ( ro->ro_rt ) {
 348         if ( hintnet ) {
 349             net = hintnet;
 350         } else {
 351             net = sat->sat_addr.s_net;
 352         }
 353         aa = 0;
 354         if ((ifp = ro->ro_rt->rt_ifp) != NULL) {
 355             for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 356                 if ( aa->aa_ifp == ifp &&
 357                         ntohs( net ) >= ntohs( aa->aa_firstnet ) &&
 358                         ntohs( net ) <= ntohs( aa->aa_lastnet )) {
 359                     break;
 360                 }
 361             }
 362         }
 363         if ( aa == NULL || ( satosat( &ro->ro_dst )->sat_addr.s_net !=
 364                 ( hintnet ? hintnet : sat->sat_addr.s_net ) ||
 365                 satosat( &ro->ro_dst )->sat_addr.s_node !=
 366                 sat->sat_addr.s_node )) {
 367             RTFREE( ro->ro_rt );
 368             ro->ro_rt = (struct rtentry *)0;
 369         }
 370     }
 371
 372     /*
 373      * If we've got no route for this interface, try to find one.
 374      */
 375     if ( ro->ro_rt == (struct rtentry *)0 ||
 376          ro->ro_rt->rt_ifp == (struct ifnet *)0 ) {
 377         ro->ro_dst.sa_len = sizeof( struct sockaddr_at );
 378         ro->ro_dst.sa_family = AF_APPLETALK;
 379         if ( hintnet ) {
 380             satosat( &ro->ro_dst )->sat_addr.s_net = hintnet;
 381         } else {
 382             satosat( &ro->ro_dst )->sat_addr.s_net = sat->sat_addr.s_net;
 383         }
 384         satosat( &ro->ro_dst )->sat_addr.s_node = sat->sat_addr.s_node;
 385         rtalloc( ro );
 386     }
 387
 388     /*
 389      * Make sure any route that we have has a valid interface.
 390      */
 391     aa = 0;
 392     if ( ro->ro_rt && ( ifp = ro->ro_rt->rt_ifp )) {
 393         for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 394             if ( aa->aa_ifp == ifp ) {
 395                 break;
 396             }
 397         }
 398     }
 399     if ( aa == 0 ) {
 400         return( ENETUNREACH );
 401     }
 402
 403     ddp->ddp_fsat = *sat;
 404     if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
 405         return(at_pcbsetaddr(ddp, (struct sockaddr *)0, td));
 406     }
 407     return( 0 );
 408 }
 409
 410 static void
 411 at_pcbdisconnect( struct ddpcb  *ddp )
 412 {
 413     ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
 414     ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
 415     ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
 416 }
 417
 418 static int
 419 at_pcballoc( struct socket *so )
 420 {
 421         struct ddpcb    *ddp;
 422
 423         MALLOC(ddp, struct ddpcb *, sizeof *ddp, M_PCB, M_WAITOK);
 424         bzero(ddp, sizeof *ddp);
 425         ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
 426
 427         ddp->ddp_next = ddpcb;
 428         ddp->ddp_prev = NULL;
 429         ddp->ddp_pprev = NULL;
 430         ddp->ddp_pnext = NULL;
 431         if (ddpcb) {
 432                 ddpcb->ddp_prev = ddp;
 433         }
 434         ddpcb = ddp;
 435
 436         ddp->ddp_socket = so;
 437         so->so_pcb = (caddr_t)ddp;
 438         return(0);
 439 }
 440
 441 static void
 442 at_pcbdetach( struct socket *so, struct ddpcb *ddp)
 443 {
 444     soisdisconnected( so );
 445     so->so_pcb = 0;
 446     sofree( so );
 447
 448     /* remove ddp from ddp_ports list */
 449     if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
 450             ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] != NULL ) {
 451         if ( ddp->ddp_pprev != NULL ) {
 452             ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
 453         } else {
 454             ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] = ddp->ddp_pnext;
 455         }
 456         if ( ddp->ddp_pnext != NULL ) {
 457             ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
 458         }
 459     }
 460
 461     if ( ddp->ddp_route.ro_rt ) {
 462         rtfree( ddp->ddp_route.ro_rt );
 463     }
 464
 465     if ( ddp->ddp_prev ) {
 466         ddp->ddp_prev->ddp_next = ddp->ddp_next;
 467     } else {
 468         ddpcb = ddp->ddp_next;
 469     }
 470     if ( ddp->ddp_next ) {
 471         ddp->ddp_next->ddp_prev = ddp->ddp_prev;
 472     }
 473     FREE(ddp, M_PCB);
 474 }
 475
 476 /*
 477  * For the moment, this just find the pcb with the correct local address.
 478  * In the future, this will actually do some real searching, so we can use
 479  * the sender's address to do de-multiplexing on a single port to many
 480  * sockets (pcbs).
 481  */
 482 struct ddpcb *
 483 ddp_search( struct sockaddr_at *from, struct sockaddr_at *to,
 484                         struct at_ifaddr *aa)
 485 {
 486     struct ddpcb        *ddp;
 487
 488     /*
 489      * Check for bad ports.
 490      */
 491     if ( to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST ) {
 492         return( NULL );
 493     }
 494
 495     /*
 496      * Make sure the local address matches the sent address.  What about
 497      * the interface?
 498      */
 499     for ( ddp = ddp_ports[ to->sat_port - 1 ]; ddp; ddp = ddp->ddp_pnext ) {
 500         /* XXX should we handle 0.YY? */
 501
 502         /* XXXX.YY to socket on destination interface */
 503         if ( to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
 504                 to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node ) {
 505             break;
 506         }
 507
 508         /* 0.255 to socket on receiving interface */
 509         if ( to->sat_addr.s_node == ATADDR_BCAST && ( to->sat_addr.s_net == 0 ||
 510                 to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net ) &&
 511                 ddp->ddp_lsat.sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) {
 512             break;
 513         }
 514
 515         /* XXXX.0 to socket on destination interface */
 516         if ( to->sat_addr.s_net == aa->aa_firstnet &&
 517                 to->sat_addr.s_node == 0 &&
 518                 ntohs( ddp->ddp_lsat.sat_addr.s_net ) >=
 519                 ntohs( aa->aa_firstnet ) &&
 520                 ntohs( ddp->ddp_lsat.sat_addr.s_net ) <=
 521                 ntohs( aa->aa_lastnet )) {
 522             break;
 523         }
 524     }
 525     return( ddp );
 526 }
 527 static int
 528 at_setpeeraddr(struct socket *so, struct sockaddr **nam)
 529 {
 530         return(EOPNOTSUPP);
 531 }
 532
 533 static int
 534 at_setsockaddr(struct socket *so, struct sockaddr **nam)
 535 {
 536         struct ddpcb    *ddp;
 537
 538         ddp = sotoddpcb( so );
 539         if ( ddp == NULL ) {
 540             return( EINVAL);
 541         }
 542         at_sockaddr( ddp, nam );
 543         return(0);
 544 }
 545
 546
 547 void
 548 ddp_init(void )
 549 {
 550         netisr_register(NETISR_ATALK1, cpu0_portfn, at1intr);
 551         netisr_register(NETISR_ATALK2, cpu0_portfn, at2intr);
 552         netisr_register(NETISR_AARP, cpu0_portfn, aarpintr);
 553 }
 554
 555 #if 0
 556 static void
 557 ddp_clean(void )
 558 {
 559     struct ddpcb        *ddp;
 560
 561     for ( ddp = ddpcb; ddp; ddp = ddp->ddp_next ) {
 562         at_pcbdetach( ddp->ddp_socket, ddp );
 563     }
 564 }
 565 #endif
 566
 567 struct pr_usrreqs ddp_usrreqs = {
 568         ddp_abort,
 569         pru_accept_notsupp,
 570         ddp_attach,
 571         ddp_bind,
 572         ddp_connect,
 573         pru_connect2_notsupp,
 574         at_control,
 575         ddp_detach,
 576         ddp_disconnect,
 577         pru_listen_notsupp,
 578         at_setpeeraddr,
 579         pru_rcvd_notsupp,
 580         pru_rcvoob_notsupp,
 581         ddp_send,
 582         pru_sense_null,
 583         ddp_shutdown,
 584         at_setsockaddr,
 585         sosend,
 586         soreceive,
 587         sopoll
 588 };