Home | History | Annotate | Line # | Download | only in net
link_proto.c revision 1.18 
      1 /*	$NetBSD: link_proto.c,v 1.18 2014/07/24 15:12:03 rtr Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1982, 1986, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  *
     31  *	@(#)uipc_proto.c	8.2 (Berkeley) 2/14/95
     32  */
     33 
     34 #include <sys/cdefs.h>
     35 __KERNEL_RCSID(0, "$NetBSD: link_proto.c,v 1.18 2014/07/24 15:12:03 rtr Exp $");
     36 
     37 #include <sys/param.h>
     38 #include <sys/socket.h>
     39 #include <sys/protosw.h>
     40 #include <sys/domain.h>
     41 #include <sys/mbuf.h>
     42 #include <sys/un.h>
     43 #include <sys/socketvar.h>
     44 
     45 #include <net/if.h>
     46 #include <net/if_dl.h>
     47 #include <net/raw_cb.h>
     48 #include <net/route.h>
     49 
     50 static int sockaddr_dl_cmp(const struct sockaddr *, const struct sockaddr *);
     51 static int link_attach(struct socket *, int);
     52 static void link_detach(struct socket *);
     53 static int link_accept(struct socket *, struct mbuf *);
     54 static int link_bind(struct socket *, struct mbuf *);
     55 static int link_listen(struct socket *);
     56 static int link_ioctl(struct socket *, u_long, void *, struct ifnet *);
     57 static int link_stat(struct socket *, struct stat *);
     58 static int link_peeraddr(struct socket *, struct mbuf *);
     59 static int link_sockaddr(struct socket *, struct mbuf *);
     60 static int link_usrreq(struct socket *, int, struct mbuf *, struct mbuf *,
     61     struct mbuf *, struct lwp *);
     62 static void link_init(void);
     63 
     64 /*
     65  * Definitions of protocols supported in the link-layer domain.
     66  */
     67 
     68 DOMAIN_DEFINE(linkdomain);	/* forward define and add to link set */
     69 
     70 static const struct pr_usrreqs link_usrreqs = {
     71 	.pr_attach	= link_attach,
     72 	.pr_detach	= link_detach,
     73 	.pr_accept	= link_accept,
     74 	.pr_bind	= link_bind,
     75 	.pr_listen	= link_listen,
     76 	.pr_ioctl	= link_ioctl,
     77 	.pr_stat	= link_stat,
     78 	.pr_peeraddr	= link_peeraddr,
     79 	.pr_sockaddr	= link_sockaddr,
     80 	.pr_generic	= link_usrreq,
     81 };
     82 
     83 const struct protosw linksw[] = {
     84 	{	.pr_type = SOCK_DGRAM,
     85 		.pr_domain = &linkdomain,
     86 		.pr_protocol = 0,	/* XXX */
     87 		.pr_flags = PR_ATOMIC|PR_ADDR|PR_PURGEIF,
     88 		.pr_input = NULL,
     89 		.pr_ctlinput = NULL,
     90 		.pr_ctloutput = NULL,
     91 		.pr_usrreqs = &link_usrreqs,
     92 		.pr_init = link_init,
     93 	},
     94 };
     95 
     96 struct domain linkdomain = {
     97 	.dom_family = AF_LINK,
     98 	.dom_name = "link",
     99 	.dom_externalize = NULL,
    100 	.dom_dispose = NULL,
    101 	.dom_protosw = linksw,
    102 	.dom_protoswNPROTOSW = &linksw[__arraycount(linksw)],
    103 	.dom_sockaddr_cmp = sockaddr_dl_cmp
    104 };
    105 
    106 static void
    107 link_init(void)
    108 {
    109 	return;
    110 }
    111 
    112 static int
    113 link_control(struct socket *so, unsigned long cmd, void *data,
    114     struct ifnet *ifp)
    115 {
    116 	int error, s;
    117 	bool isactive, mkactive;
    118 	struct if_laddrreq *iflr;
    119 	union {
    120 		struct sockaddr sa;
    121 		struct sockaddr_dl sdl;
    122 		struct sockaddr_storage ss;
    123 	} u;
    124 	struct ifaddr *ifa;
    125 	const struct sockaddr_dl *asdl, *nsdl;
    126 
    127 	switch (cmd) {
    128 	case SIOCALIFADDR:
    129 	case SIOCDLIFADDR:
    130 	case SIOCGLIFADDR:
    131 		iflr = data;
    132 
    133 		if (iflr->addr.ss_family != AF_LINK)
    134 			return EINVAL;
    135 
    136 		asdl = satocsdl(sstocsa(&iflr->addr));
    137 
    138 		if (asdl->sdl_alen != ifp->if_addrlen)
    139 			return EINVAL;
    140 
    141 		if (sockaddr_dl_init(&u.sdl, sizeof(u.ss), ifp->if_index,
    142 		    ifp->if_type, ifp->if_xname, strlen(ifp->if_xname),
    143 		    CLLADDR(asdl), asdl->sdl_alen) == NULL)
    144 			return EINVAL;
    145 
    146 		if ((iflr->flags & IFLR_PREFIX) == 0)
    147 			;
    148 		else if (iflr->prefixlen != NBBY * ifp->if_addrlen)
    149 			return EINVAL;	/* XXX match with prefix */
    150 
    151 		error = 0;
    152 
    153 		s = splnet();
    154 
    155 		IFADDR_FOREACH(ifa, ifp) {
    156 			if (sockaddr_cmp(&u.sa, ifa->ifa_addr) == 0)
    157 				break;
    158 		}
    159 
    160 		switch (cmd) {
    161 		case SIOCGLIFADDR:
    162 			if ((iflr->flags & IFLR_PREFIX) == 0) {
    163 				IFADDR_FOREACH(ifa, ifp) {
    164 					if (ifa->ifa_addr->sa_family == AF_LINK)
    165 						break;
    166 				}
    167 			}
    168 			if (ifa == NULL) {
    169 				error = EADDRNOTAVAIL;
    170 				break;
    171 			}
    172 
    173 			if (ifa == ifp->if_dl)
    174 				iflr->flags = IFLR_ACTIVE;
    175 			else
    176 				iflr->flags = 0;
    177 
    178 			if (ifa == ifp->if_hwdl)
    179 				iflr->flags |= IFLR_FACTORY;
    180 
    181 			sockaddr_copy(sstosa(&iflr->addr), sizeof(iflr->addr),
    182 			    ifa->ifa_addr);
    183 
    184 			break;
    185 		case SIOCDLIFADDR:
    186 			if (ifa == NULL)
    187 				error = EADDRNOTAVAIL;
    188 			else if (ifa == ifp->if_dl || ifa == ifp->if_hwdl)
    189 				error = EBUSY;
    190 			else {
    191 				/* TBD routing socket */
    192 				rt_newaddrmsg(RTM_DELETE, ifa, 0, NULL);
    193 				ifa_remove(ifp, ifa);
    194 			}
    195 			break;
    196 		case SIOCALIFADDR:
    197 			if (ifa != NULL)
    198 				;
    199 			else if ((ifa = if_dl_create(ifp, &nsdl)) == NULL) {
    200 				error = ENOMEM;
    201 				break;
    202 			} else {
    203 				sockaddr_copy(ifa->ifa_addr,
    204 				    ifa->ifa_addr->sa_len, &u.sa);
    205 				ifa_insert(ifp, ifa);
    206 				rt_newaddrmsg(RTM_ADD, ifa, 0, NULL);
    207 			}
    208 
    209 			mkactive = (iflr->flags & IFLR_ACTIVE) != 0;
    210 			isactive = (ifa == ifp->if_dl);
    211 
    212 			if (!isactive && mkactive) {
    213 				if_activate_sadl(ifp, ifa, nsdl);
    214 				rt_newaddrmsg(RTM_CHANGE, ifa, 0, NULL);
    215 				error = ENETRESET;
    216 			}
    217 			break;
    218 		}
    219 		splx(s);
    220 		if (error != ENETRESET)
    221 			return error;
    222 		else if ((ifp->if_flags & IFF_RUNNING) != 0 &&
    223 		         ifp->if_init != NULL)
    224 			return (*ifp->if_init)(ifp);
    225 		else
    226 			return 0;
    227 	default:
    228 		return ENOTTY;
    229 	}
    230 }
    231 
    232 static int
    233 link_attach(struct socket *so, int proto)
    234 {
    235 	sosetlock(so);
    236 	KASSERT(solocked(so));
    237 	return 0;
    238 }
    239 
    240 static void
    241 link_detach(struct socket *so)
    242 {
    243 	KASSERT(solocked(so));
    244 	sofree(so);
    245 }
    246 
    247 static int
    248 link_accept(struct socket *so, struct mbuf *nam)
    249 {
    250 	KASSERT(solocked(so));
    251 
    252 	return EOPNOTSUPP;
    253 }
    254 
    255 static int
    256 link_bind(struct socket *so, struct mbuf *nam)
    257 {
    258 	KASSERT(solocked(so));
    259 
    260 	return EOPNOTSUPP;
    261 }
    262 
    263 static int
    264 link_listen(struct socket *so)
    265 {
    266 	KASSERT(solocked(so));
    267 
    268 	return EOPNOTSUPP;
    269 }
    270 
    271 static int
    272 link_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp)
    273 {
    274 	return link_control(so, cmd, nam, ifp);
    275 }
    276 
    277 static int
    278 link_stat(struct socket *so, struct stat *ub)
    279 {
    280 	KASSERT(solocked(so));
    281 
    282 	return EOPNOTSUPP;
    283 }
    284 
    285 static int
    286 link_peeraddr(struct socket *so, struct mbuf *nam)
    287 {
    288 	KASSERT(solocked(so));
    289 
    290 	return EOPNOTSUPP;
    291 }
    292 
    293 static int
    294 link_sockaddr(struct socket *so, struct mbuf *nam)
    295 {
    296  	KASSERT(solocked(so));
    297 
    298 	return EOPNOTSUPP;
    299 }
    300 
    301 static int
    302 link_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
    303 	struct mbuf *control, struct lwp *l)
    304 {
    305 	KASSERT(req != PRU_ATTACH);
    306 	KASSERT(req != PRU_DETACH);
    307 	KASSERT(req != PRU_ACCEPT);
    308 	KASSERT(req != PRU_BIND);
    309 	KASSERT(req != PRU_LISTEN);
    310 	KASSERT(req != PRU_CONTROL);
    311 	KASSERT(req != PRU_SENSE);
    312 	KASSERT(req != PRU_PEERADDR);
    313 	KASSERT(req != PRU_SOCKADDR);
    314 
    315 	return EOPNOTSUPP;
    316 }
    317 
    318 /* Compare the field at byte offsets [fieldstart, fieldend) in
    319  * two memory regions, [l, l + llen) and [r, r + llen).
    320  */
    321 static inline int
    322 submemcmp(const void *l, const void *r,
    323     const uint_fast8_t llen, const uint_fast8_t rlen,
    324     const uint_fast8_t fieldstart, const uint_fast8_t fieldend)
    325 {
    326 	uint_fast8_t cmpend, minlen;
    327 	const uint8_t *lb = l, *rb = r;
    328 	int rc;
    329 
    330 	minlen = MIN(llen, rlen);
    331 
    332 	/* The field is missing from one region.  The shorter region is the
    333 	 * lesser region.
    334 	 */
    335 	if (fieldstart >= minlen)
    336 		return llen - rlen;
    337 
    338 	/* Two empty, present fields are always equal. */
    339 	if (fieldstart > fieldend)
    340 		return 0;
    341 
    342 	cmpend = MIN(fieldend, minlen);
    343 
    344 	rc = memcmp(&lb[fieldstart], &rb[fieldstart], cmpend - fieldstart);
    345 
    346 	if (rc != 0)
    347 		return rc;
    348 	/* If one or both fields are truncated, then the shorter is the lesser
    349 	 * field.
    350 	 */
    351 	if (minlen < fieldend)
    352 		return llen - rlen;
    353 	/* Fields are full-length and equal.  The fields are equal. */
    354 	return 0;
    355 }
    356 
    357 uint8_t
    358 sockaddr_dl_measure(uint8_t namelen, uint8_t addrlen)
    359 {
    360 	return offsetof(struct sockaddr_dl, sdl_data[namelen + addrlen]);
    361 }
    362 
    363 struct sockaddr *
    364 sockaddr_dl_alloc(uint16_t ifindex, uint8_t type,
    365     const void *name, uint8_t namelen, const void *addr, uint8_t addrlen,
    366     int flags)
    367 {
    368 	struct sockaddr *sa;
    369 	socklen_t len;
    370 
    371 	len = sockaddr_dl_measure(namelen, addrlen);
    372 	sa = sockaddr_alloc(AF_LINK, len, flags);
    373 
    374 	if (sa == NULL)
    375 		return NULL;
    376 
    377 	if (sockaddr_dl_init(satosdl(sa), len, ifindex, type, name, namelen,
    378 	    addr, addrlen) == NULL) {
    379 		sockaddr_free(sa);
    380 		return NULL;
    381 	}
    382 
    383 	return sa;
    384 }
    385 
    386 struct sockaddr_dl *
    387 sockaddr_dl_init(struct sockaddr_dl *sdl, socklen_t socklen, uint16_t ifindex,
    388     uint8_t type, const void *name, uint8_t namelen, const void *addr,
    389     uint8_t addrlen)
    390 {
    391 	socklen_t len;
    392 
    393 	sdl->sdl_family = AF_LINK;
    394 	sdl->sdl_slen = 0;
    395 	len = sockaddr_dl_measure(namelen, addrlen);
    396 	if (len > socklen) {
    397 		sdl->sdl_len = socklen;
    398 #ifdef DIAGNOSTIC
    399 		printf("%s: too long: %u > %u\n", __func__, (u_int)len,
    400 		    (u_int)socklen);
    401 #endif
    402 		return NULL;
    403 	}
    404 	sdl->sdl_len = len;
    405 	sdl->sdl_index = ifindex;
    406 	sdl->sdl_type = type;
    407 	memset(&sdl->sdl_data[0], 0, namelen + addrlen);
    408 	if (name != NULL) {
    409 		memcpy(&sdl->sdl_data[0], name, namelen);
    410 		sdl->sdl_nlen = namelen;
    411 	} else
    412 		sdl->sdl_nlen = 0;
    413 	if (addr != NULL) {
    414 		memcpy(&sdl->sdl_data[sdl->sdl_nlen], addr, addrlen);
    415 		sdl->sdl_alen = addrlen;
    416 	} else
    417 		sdl->sdl_alen = 0;
    418 	return sdl;
    419 }
    420 
    421 static int
    422 sockaddr_dl_cmp(const struct sockaddr *sa1, const struct sockaddr *sa2)
    423 {
    424 	int rc;
    425 	const uint_fast8_t indexofs = offsetof(struct sockaddr_dl, sdl_index);
    426 	const uint_fast8_t nlenofs = offsetof(struct sockaddr_dl, sdl_nlen);
    427 	uint_fast8_t dataofs = offsetof(struct sockaddr_dl, sdl_data[0]);
    428 	const struct sockaddr_dl *sdl1, *sdl2;
    429 
    430 	sdl1 = satocsdl(sa1);
    431 	sdl2 = satocsdl(sa2);
    432 
    433 	rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len,
    434 	    indexofs, nlenofs);
    435 
    436 	if (rc != 0)
    437 		return rc;
    438 
    439 	rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len,
    440 	    dataofs, dataofs + MIN(sdl1->sdl_nlen, sdl2->sdl_nlen));
    441 
    442 	if (rc != 0)
    443 		return rc;
    444 
    445 	if (sdl1->sdl_nlen != sdl2->sdl_nlen)
    446 		return sdl1->sdl_nlen - sdl2->sdl_nlen;
    447 
    448 	dataofs += sdl1->sdl_nlen;
    449 
    450 	rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len,
    451 	    dataofs, dataofs + MIN(sdl1->sdl_alen, sdl2->sdl_alen));
    452 
    453 	if (rc != 0)
    454 		return rc;
    455 
    456 	if (sdl1->sdl_alen != sdl2->sdl_alen)
    457 		return sdl1->sdl_alen - sdl2->sdl_alen;
    458 
    459 	dataofs += sdl1->sdl_alen;
    460 
    461 	rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len,
    462 	    dataofs, dataofs + MIN(sdl1->sdl_slen, sdl2->sdl_slen));
    463 
    464 	if (sdl1->sdl_slen != sdl2->sdl_slen)
    465 		return sdl1->sdl_slen - sdl2->sdl_slen;
    466 
    467 	return sdl1->sdl_len - sdl2->sdl_len;
    468 }
    469 
    470 struct sockaddr_dl *
    471 sockaddr_dl_setaddr(struct sockaddr_dl *sdl, socklen_t socklen,
    472     const void *addr, uint8_t addrlen)
    473 {
    474 	socklen_t len;
    475 
    476 	len = sockaddr_dl_measure(sdl->sdl_nlen, addrlen);
    477 	if (len > socklen) {
    478 #ifdef DIAGNOSTIC
    479 		printf("%s: too long: %u > %u\n", __func__, (u_int)len,
    480 		    (u_int)socklen);
    481 #endif
    482 		return NULL;
    483 	}
    484 	memcpy(&sdl->sdl_data[sdl->sdl_nlen], addr, addrlen);
    485 	sdl->sdl_alen = addrlen;
    486 	sdl->sdl_len = len;
    487 	return sdl;
    488 }
    489