Home | History | Annotate | Line # | Download | only in netatalk
ddp_usrreq.c revision 1.29 
      1 /*	$NetBSD: ddp_usrreq.c,v 1.29 2008/01/14 04:12:40 dyoung Exp $	 */
      2 
      3 /*
      4  * Copyright (c) 1990,1991 Regents of The University of Michigan.
      5  * All Rights Reserved.
      6  *
      7  * Permission to use, copy, modify, and distribute this software and
      8  * its documentation for any purpose and without fee is hereby granted,
      9  * provided that the above copyright notice appears in all copies and
     10  * that both that copyright notice and this permission notice appear
     11  * in supporting documentation, and that the name of The University
     12  * of Michigan not be used in advertising or publicity pertaining to
     13  * distribution of the software without specific, written prior
     14  * permission. This software is supplied as is without expressed or
     15  * implied warranties of any kind.
     16  *
     17  * This product includes software developed by the University of
     18  * California, Berkeley and its contributors.
     19  *
     20  *	Research Systems Unix Group
     21  *	The University of Michigan
     22  *	c/o Wesley Craig
     23  *	535 W. William Street
     24  *	Ann Arbor, Michigan
     25  *	+1-313-764-2278
     26  *	netatalk (at) umich.edu
     27  */
     28 
     29 #include <sys/cdefs.h>
     30 __KERNEL_RCSID(0, "$NetBSD: ddp_usrreq.c,v 1.29 2008/01/14 04:12:40 dyoung Exp $");
     31 
     32 #include "opt_mbuftrace.h"
     33 
     34 #include <sys/param.h>
     35 #include <sys/errno.h>
     36 #include <sys/systm.h>
     37 #include <sys/proc.h>
     38 #include <sys/mbuf.h>
     39 #include <sys/ioctl.h>
     40 #include <sys/queue.h>
     41 #include <sys/socket.h>
     42 #include <sys/socketvar.h>
     43 #include <sys/protosw.h>
     44 #include <sys/kauth.h>
     45 #include <net/if.h>
     46 #include <net/route.h>
     47 #include <net/if_ether.h>
     48 #include <netinet/in.h>
     49 
     50 #include <netatalk/at.h>
     51 #include <netatalk/at_var.h>
     52 #include <netatalk/ddp_var.h>
     53 #include <netatalk/aarp.h>
     54 #include <netatalk/at_extern.h>
     55 
     56 static void at_pcbdisconnect __P((struct ddpcb *));
     57 static void at_sockaddr __P((struct ddpcb *, struct mbuf *));
     58 static int at_pcbsetaddr __P((struct ddpcb *, struct mbuf *, struct lwp *));
     59 static int at_pcbconnect __P((struct ddpcb *, struct mbuf *, struct lwp *));
     60 static void at_pcbdetach __P((struct socket *, struct ddpcb *));
     61 static int at_pcballoc __P((struct socket *));
     62 
     63 struct ifqueue atintrq1, atintrq2;
     64 struct ddpcb   *ddp_ports[ATPORT_LAST];
     65 struct ddpcb   *ddpcb = NULL;
     66 struct ddpstat	ddpstat;
     67 struct at_ifaddrhead at_ifaddr;		/* Here as inited in this file */
     68 u_long ddp_sendspace = DDP_MAXSZ;	/* Max ddp size + 1 (ddp_type) */
     69 u_long ddp_recvspace = 25 * (587 + sizeof(struct sockaddr_at));
     70 
     71 #ifdef MBUFTRACE
     72 struct mowner atalk_rx_mowner = MOWNER_INIT("atalk", "rx");
     73 struct mowner atalk_tx_mowner = MOWNER_INIT("atalk", "tx");
     74 #endif
     75 
     76 /* ARGSUSED */
     77 int
     78 ddp_usrreq(so, req, m, addr, rights, l)
     79 	struct socket  *so;
     80 	int             req;
     81 	struct mbuf    *m;
     82 	struct mbuf    *addr;
     83 	struct mbuf    *rights;
     84 	struct lwp *l;
     85 {
     86 	struct ddpcb   *ddp;
     87 	int             error = 0;
     88 
     89 	ddp = sotoddpcb(so);
     90 
     91 	if (req == PRU_CONTROL) {
     92 		return (at_control((long) m, (void *) addr,
     93 		    (struct ifnet *) rights, l));
     94 	}
     95 	if (req == PRU_PURGEIF) {
     96 		at_purgeif((struct ifnet *) rights);
     97 		return (0);
     98 	}
     99 	if (rights && rights->m_len) {
    100 		error = EINVAL;
    101 		goto release;
    102 	}
    103 	if (ddp == NULL && req != PRU_ATTACH) {
    104 		error = EINVAL;
    105 		goto release;
    106 	}
    107 	switch (req) {
    108 	case PRU_ATTACH:
    109 		if (ddp != NULL) {
    110 			error = EINVAL;
    111 			break;
    112 		}
    113 		if ((error = at_pcballoc(so)) != 0) {
    114 			break;
    115 		}
    116 		error = soreserve(so, ddp_sendspace, ddp_recvspace);
    117 		break;
    118 
    119 	case PRU_DETACH:
    120 		at_pcbdetach(so, ddp);
    121 		break;
    122 
    123 	case PRU_BIND:
    124 		error = at_pcbsetaddr(ddp, addr, l);
    125 		break;
    126 
    127 	case PRU_SOCKADDR:
    128 		at_sockaddr(ddp, addr);
    129 		break;
    130 
    131 	case PRU_CONNECT:
    132 		if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT) {
    133 			error = EISCONN;
    134 			break;
    135 		}
    136 		error = at_pcbconnect(ddp, addr, l);
    137 		if (error == 0)
    138 			soisconnected(so);
    139 		break;
    140 
    141 	case PRU_DISCONNECT:
    142 		if (ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE) {
    143 			error = ENOTCONN;
    144 			break;
    145 		}
    146 		at_pcbdisconnect(ddp);
    147 		soisdisconnected(so);
    148 		break;
    149 
    150 	case PRU_SHUTDOWN:
    151 		socantsendmore(so);
    152 		break;
    153 
    154 	case PRU_SEND:{
    155 			int s = 0;
    156 
    157 			if (addr) {
    158 				if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT) {
    159 					error = EISCONN;
    160 					break;
    161 				}
    162 				s = splnet();
    163 				error = at_pcbconnect(ddp, addr, l);
    164 				if (error) {
    165 					splx(s);
    166 					break;
    167 				}
    168 			} else {
    169 				if (ddp->ddp_fsat.sat_port == ATADDR_ANYPORT) {
    170 					error = ENOTCONN;
    171 					break;
    172 				}
    173 			}
    174 
    175 			error = ddp_output(m, ddp);
    176 			m = NULL;
    177 			if (addr) {
    178 				at_pcbdisconnect(ddp);
    179 				splx(s);
    180 			}
    181 		}
    182 		break;
    183 
    184 	case PRU_ABORT:
    185 		soisdisconnected(so);
    186 		at_pcbdetach(so, ddp);
    187 		break;
    188 
    189 	case PRU_LISTEN:
    190 	case PRU_CONNECT2:
    191 	case PRU_ACCEPT:
    192 	case PRU_SENDOOB:
    193 	case PRU_FASTTIMO:
    194 	case PRU_SLOWTIMO:
    195 	case PRU_PROTORCV:
    196 	case PRU_PROTOSEND:
    197 		error = EOPNOTSUPP;
    198 		break;
    199 
    200 	case PRU_RCVD:
    201 	case PRU_RCVOOB:
    202 		/*
    203 		 * Don't mfree. Good architecture...
    204 		 */
    205 		return (EOPNOTSUPP);
    206 
    207 	case PRU_SENSE:
    208 		/*
    209 		 * 1. Don't return block size.
    210 		 * 2. Don't mfree.
    211 		 */
    212 		return (0);
    213 
    214 	default:
    215 		error = EOPNOTSUPP;
    216 	}
    217 
    218 release:
    219 	if (m != NULL) {
    220 		m_freem(m);
    221 	}
    222 	return (error);
    223 }
    224 
    225 static void
    226 at_sockaddr(ddp, addr)
    227 	struct ddpcb   *ddp;
    228 	struct mbuf    *addr;
    229 {
    230 	struct sockaddr_at *sat;
    231 
    232 	addr->m_len = sizeof(struct sockaddr_at);
    233 	sat = mtod(addr, struct sockaddr_at *);
    234 	*sat = ddp->ddp_lsat;
    235 }
    236 
    237 static int
    238 at_pcbsetaddr(ddp, addr, l)
    239 	struct ddpcb   *ddp;
    240 	struct mbuf    *addr;
    241 	struct lwp	*l;
    242 {
    243 	struct sockaddr_at lsat, *sat;
    244 	struct at_ifaddr *aa;
    245 	struct ddpcb   *ddpp;
    246 
    247 	if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT) {	/* shouldn't be bound */
    248 		return (EINVAL);
    249 	}
    250 	if (addr != 0) {	/* validate passed address */
    251 		sat = mtod(addr, struct sockaddr_at *);
    252 		if (addr->m_len != sizeof(*sat))
    253 			return (EINVAL);
    254 
    255 		if (sat->sat_family != AF_APPLETALK)
    256 			return (EAFNOSUPPORT);
    257 
    258 		if (sat->sat_addr.s_node != ATADDR_ANYNODE ||
    259 		    sat->sat_addr.s_net != ATADDR_ANYNET) {
    260 			TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
    261 				if ((sat->sat_addr.s_net ==
    262 				    AA_SAT(aa)->sat_addr.s_net) &&
    263 				    (sat->sat_addr.s_node ==
    264 				    AA_SAT(aa)->sat_addr.s_node))
    265 					break;
    266 			}
    267 			if (!aa)
    268 				return (EADDRNOTAVAIL);
    269 		}
    270 		if (sat->sat_port != ATADDR_ANYPORT) {
    271 			if (sat->sat_port < ATPORT_FIRST ||
    272 			    sat->sat_port >= ATPORT_LAST)
    273 				return (EINVAL);
    274 
    275 			if (sat->sat_port < ATPORT_RESERVED && l &&
    276 			    kauth_authorize_generic(l->l_cred,
    277 			    KAUTH_GENERIC_ISSUSER, NULL))
    278 				return (EACCES);
    279 		}
    280 	} else {
    281 		bzero((void *) & lsat, sizeof(struct sockaddr_at));
    282 		lsat.sat_len = sizeof(struct sockaddr_at);
    283 		lsat.sat_addr.s_node = ATADDR_ANYNODE;
    284 		lsat.sat_addr.s_net = ATADDR_ANYNET;
    285 		lsat.sat_family = AF_APPLETALK;
    286 		sat = &lsat;
    287 	}
    288 
    289 	if (sat->sat_addr.s_node == ATADDR_ANYNODE &&
    290 	    sat->sat_addr.s_net == ATADDR_ANYNET) {
    291 		if (TAILQ_EMPTY(&at_ifaddr))
    292 			return EADDRNOTAVAIL;
    293 		sat->sat_addr = AA_SAT(TAILQ_FIRST(&at_ifaddr))->sat_addr;
    294 	}
    295 	ddp->ddp_lsat = *sat;
    296 
    297 	/*
    298          * Choose port.
    299          */
    300 	if (sat->sat_port == ATADDR_ANYPORT) {
    301 		for (sat->sat_port = ATPORT_RESERVED;
    302 		     sat->sat_port < ATPORT_LAST; sat->sat_port++) {
    303 			if (ddp_ports[sat->sat_port - 1] == 0)
    304 				break;
    305 		}
    306 		if (sat->sat_port == ATPORT_LAST) {
    307 			return (EADDRNOTAVAIL);
    308 		}
    309 		ddp->ddp_lsat.sat_port = sat->sat_port;
    310 		ddp_ports[sat->sat_port - 1] = ddp;
    311 	} else {
    312 		for (ddpp = ddp_ports[sat->sat_port - 1]; ddpp;
    313 		     ddpp = ddpp->ddp_pnext) {
    314 			if (ddpp->ddp_lsat.sat_addr.s_net ==
    315 			    sat->sat_addr.s_net &&
    316 			    ddpp->ddp_lsat.sat_addr.s_node ==
    317 			    sat->sat_addr.s_node)
    318 				break;
    319 		}
    320 		if (ddpp != NULL)
    321 			return (EADDRINUSE);
    322 
    323 		ddp->ddp_pnext = ddp_ports[sat->sat_port - 1];
    324 		ddp_ports[sat->sat_port - 1] = ddp;
    325 		if (ddp->ddp_pnext)
    326 			ddp->ddp_pnext->ddp_pprev = ddp;
    327 	}
    328 
    329 	return 0;
    330 }
    331 
    332 static int
    333 at_pcbconnect(ddp, addr, l)
    334 	struct ddpcb   *ddp;
    335 	struct mbuf    *addr;
    336 	struct lwp     *l;
    337 {
    338 	struct rtentry *rt;
    339 	const struct sockaddr_at *cdst;
    340 	struct sockaddr_at *sat = mtod(addr, struct sockaddr_at *);
    341 	struct route *ro;
    342 	struct at_ifaddr *aa;
    343 	struct ifnet   *ifp;
    344 	u_short         hintnet = 0, net;
    345 
    346 	if (addr->m_len != sizeof(*sat))
    347 		return EINVAL;
    348 	if (sat->sat_family != AF_APPLETALK) {
    349 		return EAFNOSUPPORT;
    350 	}
    351 	/*
    352          * Under phase 2, network 0 means "the network".  We take "the
    353          * network" to mean the network the control block is bound to.
    354          * If the control block is not bound, there is an error.
    355          */
    356 	if (sat->sat_addr.s_net == ATADDR_ANYNET
    357 	    && sat->sat_addr.s_node != ATADDR_ANYNODE) {
    358 		if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT) {
    359 			return EADDRNOTAVAIL;
    360 		}
    361 		hintnet = ddp->ddp_lsat.sat_addr.s_net;
    362 	}
    363 	ro = &ddp->ddp_route;
    364 	/*
    365          * If we've got an old route for this pcb, check that it is valid.
    366          * If we've changed our address, we may have an old "good looking"
    367          * route here.  Attempt to detect it.
    368          */
    369 	if ((rt = rtcache_validate(ro)) != NULL ||
    370 	    (rt = rtcache_update(ro, 1)) != NULL) {
    371 		if (hintnet) {
    372 			net = hintnet;
    373 		} else {
    374 			net = sat->sat_addr.s_net;
    375 		}
    376 		if ((ifp = rt->rt_ifp) != NULL) {
    377 			TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
    378 				if (aa->aa_ifp == ifp &&
    379 				    ntohs(net) >= ntohs(aa->aa_firstnet) &&
    380 				    ntohs(net) <= ntohs(aa->aa_lastnet)) {
    381 					break;
    382 				}
    383 			}
    384 		} else
    385 			aa = NULL;
    386 		cdst = satocsat(rtcache_getdst(ro));
    387 		if (aa == NULL || (cdst->sat_addr.s_net !=
    388 		    (hintnet ? hintnet : sat->sat_addr.s_net) ||
    389 		    cdst->sat_addr.s_node != sat->sat_addr.s_node)) {
    390 			rtcache_free(ro);
    391 			rt = NULL;
    392 		}
    393 	}
    394 	/*
    395          * If we've got no route for this interface, try to find one.
    396          */
    397 	if (rt == NULL) {
    398 		union {
    399 			struct sockaddr		dst;
    400 			struct sockaddr_at	dsta;
    401 		} u;
    402 
    403 		sockaddr_at_init(&u.dsta, &sat->sat_addr, 0);
    404 		if (hintnet)
    405 			u.dsta.sat_addr.s_net = hintnet;
    406 		rtcache_setdst(ro, &u.dst);
    407 
    408 		rt = rtcache_init(ro);
    409 	}
    410 	/*
    411          * Make sure any route that we have has a valid interface.
    412          */
    413 	if (rt != NULL && (ifp = rt->rt_ifp) != NULL) {
    414 		TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
    415 			if (aa->aa_ifp == ifp)
    416 				break;
    417 		}
    418 	} else
    419 		aa = NULL;
    420 	if (aa == NULL)
    421 		return ENETUNREACH;
    422 	ddp->ddp_fsat = *sat;
    423 	if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT)
    424 		return at_pcbsetaddr(ddp, NULL, l);
    425 	return 0;
    426 }
    427 
    428 static void
    429 at_pcbdisconnect(ddp)
    430 	struct ddpcb   *ddp;
    431 {
    432 	ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
    433 	ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
    434 	ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
    435 }
    436 
    437 static int
    438 at_pcballoc(so)
    439 	struct socket  *so;
    440 {
    441 	struct ddpcb   *ddp;
    442 
    443 	MALLOC(ddp, struct ddpcb *, sizeof(*ddp), M_PCB, M_WAITOK|M_ZERO);
    444 	if (!ddp)
    445 		panic("at_pcballoc");
    446 	ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
    447 
    448 	ddp->ddp_next = ddpcb;
    449 	ddp->ddp_prev = NULL;
    450 	ddp->ddp_pprev = NULL;
    451 	ddp->ddp_pnext = NULL;
    452 	if (ddpcb) {
    453 		ddpcb->ddp_prev = ddp;
    454 	}
    455 	ddpcb = ddp;
    456 
    457 	ddp->ddp_socket = so;
    458 	so->so_pcb = (void *) ddp;
    459 #ifdef MBUFTRACE
    460 	so->so_rcv.sb_mowner = &atalk_rx_mowner;
    461 	so->so_snd.sb_mowner = &atalk_tx_mowner;
    462 #endif
    463 	return 0;
    464 }
    465 
    466 static void
    467 at_pcbdetach(so, ddp)
    468 	struct socket  *so;
    469 	struct ddpcb   *ddp;
    470 {
    471 	soisdisconnected(so);
    472 	so->so_pcb = 0;
    473 	sofree(so);
    474 
    475 	/* remove ddp from ddp_ports list */
    476 	if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
    477 	    ddp_ports[ddp->ddp_lsat.sat_port - 1] != NULL) {
    478 		if (ddp->ddp_pprev != NULL) {
    479 			ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
    480 		} else {
    481 			ddp_ports[ddp->ddp_lsat.sat_port - 1] = ddp->ddp_pnext;
    482 		}
    483 		if (ddp->ddp_pnext != NULL) {
    484 			ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
    485 		}
    486 	}
    487 	rtcache_free(&ddp->ddp_route);
    488 	if (ddp->ddp_prev) {
    489 		ddp->ddp_prev->ddp_next = ddp->ddp_next;
    490 	} else {
    491 		ddpcb = ddp->ddp_next;
    492 	}
    493 	if (ddp->ddp_next) {
    494 		ddp->ddp_next->ddp_prev = ddp->ddp_prev;
    495 	}
    496 	free(ddp, M_PCB);
    497 }
    498 
    499 /*
    500  * For the moment, this just find the pcb with the correct local address.
    501  * In the future, this will actually do some real searching, so we can use
    502  * the sender's address to do de-multiplexing on a single port to many
    503  * sockets (pcbs).
    504  */
    505 struct ddpcb   *
    506 ddp_search(
    507     struct sockaddr_at *from,
    508     struct sockaddr_at *to,
    509     struct at_ifaddr *aa)
    510 {
    511 	struct ddpcb   *ddp;
    512 
    513 	/*
    514          * Check for bad ports.
    515          */
    516 	if (to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST)
    517 		return NULL;
    518 
    519 	/*
    520          * Make sure the local address matches the sent address.  What about
    521          * the interface?
    522          */
    523 	for (ddp = ddp_ports[to->sat_port - 1]; ddp; ddp = ddp->ddp_pnext) {
    524 		/* XXX should we handle 0.YY? */
    525 
    526 		/* XXXX.YY to socket on destination interface */
    527 		if (to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
    528 		    to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node) {
    529 			break;
    530 		}
    531 		/* 0.255 to socket on receiving interface */
    532 		if (to->sat_addr.s_node == ATADDR_BCAST &&
    533 		    (to->sat_addr.s_net == 0 ||
    534 		    to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net) &&
    535 		ddp->ddp_lsat.sat_addr.s_net == AA_SAT(aa)->sat_addr.s_net) {
    536 			break;
    537 		}
    538 		/* XXXX.0 to socket on destination interface */
    539 		if (to->sat_addr.s_net == aa->aa_firstnet &&
    540 		    to->sat_addr.s_node == 0 &&
    541 		    ntohs(ddp->ddp_lsat.sat_addr.s_net) >=
    542 		    ntohs(aa->aa_firstnet) &&
    543 		    ntohs(ddp->ddp_lsat.sat_addr.s_net) <=
    544 		    ntohs(aa->aa_lastnet)) {
    545 			break;
    546 		}
    547 	}
    548 	return (ddp);
    549 }
    550 
    551 /*
    552  * Initialize all the ddp & appletalk stuff
    553  */
    554 void
    555 ddp_init()
    556 {
    557 	TAILQ_INIT(&at_ifaddr);
    558 	atintrq1.ifq_maxlen = IFQ_MAXLEN;
    559 	atintrq2.ifq_maxlen = IFQ_MAXLEN;
    560 
    561 	MOWNER_ATTACH(&atalk_tx_mowner);
    562 	MOWNER_ATTACH(&atalk_rx_mowner);
    563 }
    564 
    565 #if 0
    566 static void
    567 ddp_clean()
    568 {
    569 	struct ddpcb   *ddp;
    570 
    571 	for (ddp = ddpcb; ddp; ddp = ddp->ddp_next)
    572 		at_pcbdetach(ddp->ddp_socket, ddp);
    573 }
    574 #endif
    575