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