1/* $NetBSD: link_proto.c,v 1.32 2016/11/19 14:44:00 njoly 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.32 2016/11/19 14:44:00 njoly 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
50static int sockaddr_dl_cmp(const struct sockaddr *, const struct sockaddr *);
51static int link_attach(struct socket *, int);
52static void link_detach(struct socket *);
53static int link_accept(struct socket *, struct sockaddr *);
54static int link_bind(struct socket *, struct sockaddr *, struct lwp *);
55static int link_listen(struct socket *, struct lwp *);
56static int link_connect(struct socket *, struct sockaddr *, struct lwp *);
57static int link_connect2(struct socket *, struct socket *);
58static int link_disconnect(struct socket *);
59static int link_shutdown(struct socket *);
60static int link_abort(struct socket *);
61static int link_ioctl(struct socket *, u_long, void *, struct ifnet *);
62static int link_stat(struct socket *, struct stat *);
63static int link_peeraddr(struct socket *, struct sockaddr *);
64static int link_sockaddr(struct socket *, struct sockaddr *);
65static int link_rcvd(struct socket *, int, struct lwp *);
66static int link_recvoob(struct socket *, struct mbuf *, int);
67static int link_send(struct socket *, struct mbuf *, struct sockaddr *,
68 struct mbuf *, struct lwp *);
69static int link_sendoob(struct socket *, struct mbuf *, struct mbuf *);
70static int link_purgeif(struct socket *, struct ifnet *);
71static void link_init(void);
72
73/*
74 * Definitions of protocols supported in the link-layer domain.
75 */
76
77DOMAIN_DEFINE(linkdomain); /* forward define and add to link set */
78
79static const struct pr_usrreqs link_usrreqs = {
80 .pr_attach = link_attach,
81 .pr_detach = link_detach,
82 .pr_accept = link_accept,
83 .pr_bind = link_bind,
84 .pr_listen = link_listen,
85 .pr_connect = link_connect,
86 .pr_connect2 = link_connect2,
87 .pr_disconnect = link_disconnect,
88 .pr_shutdown = link_shutdown,
89 .pr_abort = link_abort,
90 .pr_ioctl = link_ioctl,
91 .pr_stat = link_stat,
92 .pr_peeraddr = link_peeraddr,
93 .pr_sockaddr = link_sockaddr,
94 .pr_rcvd = link_rcvd,
95 .pr_recvoob = link_recvoob,
96 .pr_send = link_send,
97 .pr_sendoob = link_sendoob,
98 .pr_purgeif = link_purgeif,
99};
100
101const struct protosw linksw[] = {
102 { .pr_type = SOCK_DGRAM,
103 .pr_domain = &linkdomain,
104 .pr_protocol = 0, /* XXX */
105 .pr_flags = PR_ATOMIC|PR_ADDR|PR_PURGEIF,
106 .pr_input = NULL,
107 .pr_ctlinput = NULL,
108 .pr_ctloutput = NULL,
109 .pr_usrreqs = &link_usrreqs,
110 .pr_init = link_init,
111 },
112};
113
114struct domain linkdomain = {
115 .dom_family = AF_LINK,
116 .dom_name = "link",
117 .dom_externalize = NULL,
118 .dom_dispose = NULL,
119 .dom_protosw = linksw,
120 .dom_protoswNPROTOSW = &linksw[__arraycount(linksw)],
121 .dom_sockaddr_cmp = sockaddr_dl_cmp
122};
123
124static void
125link_init(void)
126{
127 return;
128}
129
130static int
131link_control(struct socket *so, unsigned long cmd, void *data,
132 struct ifnet *ifp)
133{
134 int error, s;
135 bool isactive, mkactive;
136 struct if_laddrreq *iflr;
137 union {
138 struct sockaddr sa;
139 struct sockaddr_dl sdl;
140 struct sockaddr_storage ss;
141 } u;
142 struct ifaddr *ifa;
143 const struct sockaddr_dl *asdl, *nsdl;
144
145 switch (cmd) {
146 case SIOCALIFADDR:
147 case SIOCDLIFADDR:
148 case SIOCGLIFADDR:
149 iflr = data;
150
151 if (iflr->addr.ss_family != AF_LINK)
152 return EINVAL;
153
154 asdl = satocsdl(sstocsa(&iflr->addr));
155
156 if (asdl->sdl_alen != ifp->if_addrlen)
157 return EINVAL;
158
159 if (sockaddr_dl_init(&u.sdl, sizeof(u.ss), ifp->if_index,
160 ifp->if_type, ifp->if_xname, strlen(ifp->if_xname),
161 CLLADDR(asdl), asdl->sdl_alen) == NULL)
162 return EINVAL;
163
164 if ((iflr->flags & IFLR_PREFIX) == 0)
165 ;
166 else if (iflr->prefixlen != NBBY * ifp->if_addrlen)
167 return EINVAL; /* XXX match with prefix */
168
169 error = 0;
170
171 s = splnet();
172
173 IFADDR_READER_FOREACH(ifa, ifp) {
174 if (sockaddr_cmp(&u.sa, ifa->ifa_addr) == 0)
175 break;
176 }
177
178 switch (cmd) {
179 case SIOCGLIFADDR:
180 if ((iflr->flags & IFLR_PREFIX) == 0) {
181 IFADDR_READER_FOREACH(ifa, ifp) {
182 if (ifa->ifa_addr->sa_family == AF_LINK)
183 break;
184 }
185 }
186 if (ifa == NULL) {
187 error = EADDRNOTAVAIL;
188 break;
189 }
190
191 if (ifa == ifp->if_dl)
192 iflr->flags = IFLR_ACTIVE;
193 else
194 iflr->flags = 0;
195
196 if (ifa == ifp->if_hwdl)
197 iflr->flags |= IFLR_FACTORY;
198
199 sockaddr_copy(sstosa(&iflr->addr), sizeof(iflr->addr),
200 ifa->ifa_addr);
201
202 break;
203 case SIOCDLIFADDR:
204 if (ifa == NULL)
205 error = EADDRNOTAVAIL;
206 else if (ifa == ifp->if_dl || ifa == ifp->if_hwdl)
207 error = EBUSY;
208 else {
209 /* TBD routing socket */
210 rt_newaddrmsg(RTM_DELETE, ifa, 0, NULL);
211 ifa_remove(ifp, ifa);
212 }
213 break;
214 case SIOCALIFADDR:
215 if (ifa != NULL)
216 ;
217 else if ((ifa = if_dl_create(ifp, &nsdl)) == NULL) {
218 error = ENOMEM;
219 break;
220 } else {
221 sockaddr_copy(ifa->ifa_addr,
222 ifa->ifa_addr->sa_len, &u.sa);
223 ifa_insert(ifp, ifa);
224 rt_newaddrmsg(RTM_ADD, ifa, 0, NULL);
225 }
226
227 mkactive = (iflr->flags & IFLR_ACTIVE) != 0;
228 isactive = (ifa == ifp->if_dl);
229
230 if (!isactive && mkactive) {
231 if_activate_sadl(ifp, ifa, nsdl);
232 rt_newaddrmsg(RTM_CHANGE, ifa, 0, NULL);
233 error = ENETRESET;
234 }
235 break;
236 }
237 splx(s);
238 if (error != ENETRESET)
239 return error;
240 else if ((ifp->if_flags & IFF_RUNNING) != 0 &&
241 ifp->if_init != NULL)
242 return (*ifp->if_init)(ifp);
243 else
244 return 0;
245 default:
246 return ENOTTY;
247 }
248}
249
250static int
251link_attach(struct socket *so, int proto)
252{
253 sosetlock(so);
254 KASSERT(solocked(so));
255 return 0;
256}
257
258static void
259link_detach(struct socket *so)
260{
261 KASSERT(solocked(so));
262 sofree(so);
263}
264
265static int
266link_accept(struct socket *so, struct sockaddr *nam)
267{
268 KASSERT(solocked(so));
269
270 return EOPNOTSUPP;
271}
272
273static int
274link_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
275{
276 KASSERT(solocked(so));
277
278 return EOPNOTSUPP;
279}
280
281static int
282link_listen(struct socket *so, struct lwp *l)
283{
284 KASSERT(solocked(so));
285
286 return EOPNOTSUPP;
287}
288
289static int
290link_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
291{
292 KASSERT(solocked(so));
293
294 return EOPNOTSUPP;
295}
296
297static int
298link_connect2(struct socket *so, struct socket *so2)
299{
300 KASSERT(solocked(so));
301
302 return EOPNOTSUPP;
303}
304
305static int
306link_disconnect(struct socket *so)
307{
308 KASSERT(solocked(so));
309
310 return EOPNOTSUPP;
311}
312
313static int
314link_shutdown(struct socket *so)
315{
316 KASSERT(solocked(so));
317
318 return EOPNOTSUPP;
319}
320
321static int
322link_abort(struct socket *so)
323{
324 KASSERT(solocked(so));
325
326 return EOPNOTSUPP;
327}
328
329static int
330link_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp)
331{
332 return link_control(so, cmd, nam, ifp);
333}
334
335static int
336link_stat(struct socket *so, struct stat *ub)
337{
338 KASSERT(solocked(so));
339
340 return 0;
341}
342
343static int
344link_peeraddr(struct socket *so, struct sockaddr *nam)
345{
346 KASSERT(solocked(so));
347
348 return EOPNOTSUPP;
349}
350
351static int
352link_sockaddr(struct socket *so, struct sockaddr *nam)
353{
354 KASSERT(solocked(so));
355
356 return EOPNOTSUPP;
357}
358
359static int
360link_rcvd(struct socket *so, int flags, struct lwp *l)
361{
362 KASSERT(solocked(so));
363
364 return EOPNOTSUPP;
365}
366
367static int
368link_recvoob(struct socket *so, struct mbuf *m, int flags)
369{
370 KASSERT(solocked(so));
371
372 return EOPNOTSUPP;
373}
374
375static int
376link_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
377 struct mbuf *control, struct lwp *l)
378{
379 KASSERT(solocked(so));
380
381 return EOPNOTSUPP;
382}
383
384static int
385link_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
386{
387 KASSERT(solocked(so));
388
389 return EOPNOTSUPP;
390}
391
392static int
393link_purgeif(struct socket *so, struct ifnet *ifp)
394{
395
396 return EOPNOTSUPP;
397}
398
399/* Compare the field at byte offsets [fieldstart, fieldend) in
400 * two memory regions, [l, l + llen) and [r, r + llen).
401 */
402static inline int
403submemcmp(const void *l, const void *r,
404 const uint_fast8_t llen, const uint_fast8_t rlen,
405 const uint_fast8_t fieldstart, const uint_fast8_t fieldend)
406{
407 uint_fast8_t cmpend, minlen;
408 const uint8_t *lb = l, *rb = r;
409 int rc;
410
411 minlen = MIN(llen, rlen);
412
413 /* The field is missing from one region. The shorter region is the
414 * lesser region.
415 */
416 if (fieldstart >= minlen)
417 return llen - rlen;
418
419 /* Two empty, present fields are always equal. */
420 if (fieldstart > fieldend)
421 return 0;
422
423 cmpend = MIN(fieldend, minlen);
424
425 rc = memcmp(&lb[fieldstart], &rb[fieldstart], cmpend - fieldstart);
426
427 if (rc != 0)
428 return rc;
429 /* If one or both fields are truncated, then the shorter is the lesser
430 * field.
431 */
432 if (minlen < fieldend)
433 return llen - rlen;
434 /* Fields are full-length and equal. The fields are equal. */
435 return 0;
436}
437
438uint8_t
439sockaddr_dl_measure(uint8_t namelen, uint8_t addrlen)
440{
441 return offsetof(struct sockaddr_dl, sdl_data[namelen + addrlen]);
442}
443
444struct sockaddr *
445sockaddr_dl_alloc(uint16_t ifindex, uint8_t type,
446 const void *name, uint8_t namelen, const void *addr, uint8_t addrlen,
447 int flags)
448{
449 struct sockaddr *sa;
450 socklen_t len;
451
452 len = sockaddr_dl_measure(namelen, addrlen);
453 sa = sockaddr_alloc(AF_LINK, len, flags);
454
455 if (sa == NULL)
456 return NULL;
457
458 if (sockaddr_dl_init(satosdl(sa), len, ifindex, type, name, namelen,
459 addr, addrlen) == NULL) {
460 sockaddr_free(sa);
461 return NULL;
462 }
463
464 return sa;
465}
466
467struct sockaddr_dl *
468sockaddr_dl_init(struct sockaddr_dl *sdl, socklen_t socklen, uint16_t ifindex,
469 uint8_t type, const void *name, uint8_t namelen, const void *addr,
470 uint8_t addrlen)
471{
472 socklen_t len;
473
474 sdl->sdl_family = AF_LINK;
475 sdl->sdl_slen = 0;
476 len = sockaddr_dl_measure(namelen, addrlen);
477 if (len > socklen) {
478 sdl->sdl_len = socklen;
479#ifdef DIAGNOSTIC
480 printf("%s: too long: %u > %u\n", __func__, (u_int)len,
481 (u_int)socklen);
482#endif
483 return NULL;
484 }
485 sdl->sdl_len = len;
486 sdl->sdl_index = ifindex;
487 sdl->sdl_type = type;
488 memset(&sdl->sdl_data[0], 0, namelen + addrlen);
489 if (name != NULL) {
490 memcpy(&sdl->sdl_data[0], name, namelen);
491 sdl->sdl_nlen = namelen;
492 } else
493 sdl->sdl_nlen = 0;
494 if (addr != NULL) {
495 memcpy(&sdl->sdl_data[sdl->sdl_nlen], addr, addrlen);
496 sdl->sdl_alen = addrlen;
497 } else
498 sdl->sdl_alen = 0;
499 return sdl;
500}
501
502static int
503sockaddr_dl_cmp(const struct sockaddr *sa1, const struct sockaddr *sa2)
504{
505 int rc;
506 const uint_fast8_t indexofs = offsetof(struct sockaddr_dl, sdl_index);
507 const uint_fast8_t nlenofs = offsetof(struct sockaddr_dl, sdl_nlen);
508 uint_fast8_t dataofs = offsetof(struct sockaddr_dl, sdl_data[0]);
509 const struct sockaddr_dl *sdl1, *sdl2;
510
511 sdl1 = satocsdl(sa1);
512 sdl2 = satocsdl(sa2);
513
514 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len,
515 indexofs, nlenofs);
516
517 if (rc != 0)
518 return rc;
519
520 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len,
521 dataofs, dataofs + MIN(sdl1->sdl_nlen, sdl2->sdl_nlen));
522
523 if (rc != 0)
524 return rc;
525
526 if (sdl1->sdl_nlen != sdl2->sdl_nlen)
527 return sdl1->sdl_nlen - sdl2->sdl_nlen;
528
529 dataofs += sdl1->sdl_nlen;
530
531 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len,
532 dataofs, dataofs + MIN(sdl1->sdl_alen, sdl2->sdl_alen));
533
534 if (rc != 0)
535 return rc;
536
537 if (sdl1->sdl_alen != sdl2->sdl_alen)
538 return sdl1->sdl_alen - sdl2->sdl_alen;
539
540 dataofs += sdl1->sdl_alen;
541
542 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len,
543 dataofs, dataofs + MIN(sdl1->sdl_slen, sdl2->sdl_slen));
544
545 if (sdl1->sdl_slen != sdl2->sdl_slen)
546 return sdl1->sdl_slen - sdl2->sdl_slen;
547
548 return sdl1->sdl_len - sdl2->sdl_len;
549}
550
551struct sockaddr_dl *
552sockaddr_dl_setaddr(struct sockaddr_dl *sdl, socklen_t socklen,
553 const void *addr, uint8_t addrlen)
554{
555 socklen_t len;
556
557 len = sockaddr_dl_measure(sdl->sdl_nlen, addrlen);
558 if (len > socklen) {
559#ifdef DIAGNOSTIC
560 printf("%s: too long: %u > %u\n", __func__, (u_int)len,
561 (u_int)socklen);
562#endif
563 return NULL;
564 }
565 memcpy(&sdl->sdl_data[sdl->sdl_nlen], addr, addrlen);
566 sdl->sdl_alen = addrlen;
567 sdl->sdl_len = len;
568 return sdl;
569}
570