1 /* $NetBSD: l2cap_socket.c,v 1.37 2024/07/05 04:31:53 rin Exp $ */
2
3 /*-
4 * Copyright (c) 2005 Iain Hibbert.
5 * Copyright (c) 2006 Itronix Inc.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. The name of Itronix Inc. may not be used to endorse
17 * or promote products derived from this software without specific
18 * prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
24 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27 * ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: l2cap_socket.c,v 1.37 2024/07/05 04:31:53 rin Exp $");
35
36 /* load symbolic names */
37 #ifdef BLUETOOTH_DEBUG
38 #define PRUREQUESTS
39 #define PRCOREQUESTS
40 #endif
41
42 #include <sys/param.h>
43 #include <sys/domain.h>
44 #include <sys/kernel.h>
45 #include <sys/mbuf.h>
46 #include <sys/proc.h>
47 #include <sys/protosw.h>
48 #include <sys/socket.h>
49 #include <sys/socketvar.h>
50 #include <sys/systm.h>
51
52 #include <netbt/bluetooth.h>
53 #include <netbt/l2cap.h>
54
55 /*
56 * L2CAP Sockets
57 *
58 * SOCK_SEQPACKET - normal L2CAP connection
59 *
60 * SOCK_DGRAM - connectionless L2CAP - XXX not yet
61 */
62
63 static void l2cap_connecting(void *);
64 static void l2cap_connected(void *);
65 static void l2cap_disconnected(void *, int);
66 static void *l2cap_newconn(void *, struct sockaddr_bt *, struct sockaddr_bt *);
67 static void l2cap_complete(void *, int);
68 static void l2cap_linkmode(void *, int);
69 static void l2cap_input(void *, struct mbuf *);
70
71 static const struct btproto l2cap_proto = {
72 l2cap_connecting,
73 l2cap_connected,
74 l2cap_disconnected,
75 l2cap_newconn,
76 l2cap_complete,
77 l2cap_linkmode,
78 l2cap_input,
79 };
80
81 /* sysctl variables */
82 int l2cap_sendspace = 4096;
83 int l2cap_recvspace = 4096;
84
85 static int
l2cap_attach(struct socket * so,int proto)86 l2cap_attach(struct socket *so, int proto)
87 {
88 int error;
89
90 KASSERT(so->so_pcb == NULL);
91
92 if (so->so_lock == NULL) {
93 mutex_obj_hold(bt_lock);
94 so->so_lock = bt_lock;
95 solock(so);
96 }
97 KASSERT(solocked(so));
98
99 /*
100 * For L2CAP socket PCB we just use an l2cap_channel structure
101 * since we have nothing to add..
102 */
103 error = soreserve(so, l2cap_sendspace, l2cap_recvspace);
104 if (error)
105 return error;
106
107 return l2cap_attach_pcb((struct l2cap_channel **)&so->so_pcb,
108 &l2cap_proto, so);
109 }
110
111 static void
l2cap_detach(struct socket * so)112 l2cap_detach(struct socket *so)
113 {
114 KASSERT(so->so_pcb != NULL);
115 l2cap_detach_pcb((struct l2cap_channel **)&so->so_pcb);
116 KASSERT(so->so_pcb == NULL);
117 }
118
119 static int
l2cap_accept(struct socket * so,struct sockaddr * nam)120 l2cap_accept(struct socket *so, struct sockaddr *nam)
121 {
122 struct l2cap_channel *pcb = so->so_pcb;
123
124 KASSERT(solocked(so));
125 KASSERT(nam != NULL);
126
127 if (pcb == NULL)
128 return EINVAL;
129
130 return l2cap_peeraddr_pcb(pcb, (struct sockaddr_bt *)nam);
131 }
132
133 static int
l2cap_bind(struct socket * so,struct sockaddr * nam,struct lwp * l)134 l2cap_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
135 {
136 struct l2cap_channel *pcb = so->so_pcb;
137 struct sockaddr_bt *sa = (struct sockaddr_bt *)nam;
138
139 KASSERT(solocked(so));
140 KASSERT(nam != NULL);
141
142 if (pcb == NULL)
143 return EINVAL;
144
145 if (sa->bt_len != sizeof(struct sockaddr_bt))
146 return EINVAL;
147
148 if (sa->bt_family != AF_BLUETOOTH)
149 return EAFNOSUPPORT;
150
151 return l2cap_bind_pcb(pcb, sa);
152 }
153
154 static int
l2cap_listen(struct socket * so,struct lwp * l)155 l2cap_listen(struct socket *so, struct lwp *l)
156 {
157 struct l2cap_channel *pcb = so->so_pcb;
158
159 KASSERT(solocked(so));
160
161 if (pcb == NULL)
162 return EINVAL;
163
164 return l2cap_listen_pcb(pcb);
165 }
166
167 static int
l2cap_connect(struct socket * so,struct sockaddr * nam,struct lwp * l)168 l2cap_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
169 {
170 struct l2cap_channel *pcb = so->so_pcb;
171 struct sockaddr_bt *sa = (struct sockaddr_bt *)nam;
172
173 KASSERT(solocked(so));
174 KASSERT(nam != NULL);
175
176 if (pcb == NULL)
177 return EINVAL;
178
179 if (sa->bt_len != sizeof(struct sockaddr_bt))
180 return EINVAL;
181
182 if (sa->bt_family != AF_BLUETOOTH)
183 return EAFNOSUPPORT;
184
185 soisconnecting(so);
186 return l2cap_connect_pcb(pcb, sa);
187 }
188
189 static int
l2cap_connect2(struct socket * so,struct socket * so2)190 l2cap_connect2(struct socket *so, struct socket *so2)
191 {
192 KASSERT(solocked(so));
193
194 if (so->so_pcb == NULL)
195 return EINVAL;
196
197 return EOPNOTSUPP;
198 }
199
200 static int
l2cap_disconnect(struct socket * so)201 l2cap_disconnect(struct socket *so)
202 {
203 struct l2cap_channel *pcb = so->so_pcb;
204
205 KASSERT(solocked(so));
206
207 if (pcb == NULL)
208 return EINVAL;
209
210 soisdisconnecting(so);
211 return l2cap_disconnect_pcb(pcb, so->so_linger);
212 }
213
214 static int
l2cap_shutdown(struct socket * so)215 l2cap_shutdown(struct socket *so)
216 {
217 KASSERT(solocked(so));
218
219 socantsendmore(so);
220 return 0;
221 }
222
223 static int
l2cap_abort(struct socket * so)224 l2cap_abort(struct socket *so)
225 {
226 struct l2cap_channel *pcb = so->so_pcb;
227
228 KASSERT(solocked(so));
229
230 if (pcb == NULL)
231 return EINVAL;
232
233 l2cap_disconnect_pcb(pcb, 0);
234 soisdisconnected(so);
235 l2cap_detach(so);
236 return 0;
237 }
238
239 static int
l2cap_ioctl(struct socket * so,u_long cmd,void * nam,struct ifnet * ifp)240 l2cap_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp)
241 {
242 return EPASSTHROUGH;
243 }
244
245 static int
l2cap_stat(struct socket * so,struct stat * ub)246 l2cap_stat(struct socket *so, struct stat *ub)
247 {
248 KASSERT(solocked(so));
249
250 return 0;
251 }
252
253 static int
l2cap_peeraddr(struct socket * so,struct sockaddr * nam)254 l2cap_peeraddr(struct socket *so, struct sockaddr *nam)
255 {
256 struct l2cap_channel *pcb = so->so_pcb;
257
258 KASSERT(solocked(so));
259 KASSERT(pcb != NULL);
260 KASSERT(nam != NULL);
261
262 return l2cap_peeraddr_pcb(pcb, (struct sockaddr_bt *)nam);
263 }
264
265 static int
l2cap_sockaddr(struct socket * so,struct sockaddr * nam)266 l2cap_sockaddr(struct socket *so, struct sockaddr *nam)
267 {
268 struct l2cap_channel *pcb = so->so_pcb;
269
270 KASSERT(solocked(so));
271 KASSERT(pcb != NULL);
272 KASSERT(nam != NULL);
273
274 return l2cap_sockaddr_pcb(pcb, (struct sockaddr_bt *)nam);
275 }
276
277 static int
l2cap_rcvd(struct socket * so,int flags,struct lwp * l)278 l2cap_rcvd(struct socket *so, int flags, struct lwp *l)
279 {
280 KASSERT(solocked(so));
281
282 return EOPNOTSUPP;
283 }
284
285 static int
l2cap_recvoob(struct socket * so,struct mbuf * m,int flags)286 l2cap_recvoob(struct socket *so, struct mbuf *m, int flags)
287 {
288 KASSERT(solocked(so));
289
290 return EOPNOTSUPP;
291 }
292
293 static int
l2cap_send(struct socket * so,struct mbuf * m,struct sockaddr * nam,struct mbuf * control,struct lwp * l)294 l2cap_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
295 struct mbuf *control, struct lwp *l)
296 {
297 struct l2cap_channel *pcb = so->so_pcb;
298 struct mbuf *m0;
299 int error = 0;
300
301 KASSERT(solocked(so));
302 KASSERT(m != NULL);
303
304 m_freem(control);
305
306 if (pcb == NULL) {
307 error = EINVAL;
308 goto release;
309 }
310
311 if (m->m_pkthdr.len == 0)
312 goto release;
313
314 if (m->m_pkthdr.len > pcb->lc_omtu) {
315 error = EMSGSIZE;
316 goto release;
317 }
318
319 m0 = m_copypacket(m, M_DONTWAIT);
320 if (m0 == NULL) {
321 error = ENOMEM;
322 goto release;
323 }
324
325 sbappendrecord(&so->so_snd, m);
326 return l2cap_send_pcb(pcb, m0);
327
328 release:
329 m_freem(m);
330
331 return error;
332 }
333
334 static int
l2cap_sendoob(struct socket * so,struct mbuf * m,struct mbuf * control)335 l2cap_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
336 {
337 KASSERT(solocked(so));
338
339 m_freem(m);
340 m_freem(control);
341
342 return EOPNOTSUPP;
343 }
344
345 static int
l2cap_purgeif(struct socket * so,struct ifnet * ifp)346 l2cap_purgeif(struct socket *so, struct ifnet *ifp)
347 {
348
349 return EOPNOTSUPP;
350 }
351
352 /*
353 * l2cap_ctloutput(req, socket, sockopt)
354 *
355 * Apply configuration commands to channel. This corresponds to
356 * "Reconfigure Channel Request" in the L2CAP specification.
357 */
358 int
l2cap_ctloutput(int req,struct socket * so,struct sockopt * sopt)359 l2cap_ctloutput(int req, struct socket *so, struct sockopt *sopt)
360 {
361 struct l2cap_channel *pcb = so->so_pcb;
362 int err = 0;
363
364 DPRINTFN(2, "%s\n", prcorequests[req]);
365
366 if (pcb == NULL)
367 return EINVAL;
368
369 if (sopt->sopt_level != BTPROTO_L2CAP)
370 return ENOPROTOOPT;
371
372 switch(req) {
373 case PRCO_GETOPT:
374 err = l2cap_getopt(pcb, sopt);
375 break;
376
377 case PRCO_SETOPT:
378 err = l2cap_setopt(pcb, sopt);
379 break;
380
381 default:
382 err = ENOPROTOOPT;
383 break;
384 }
385
386 return err;
387 }
388
389 /**********************************************************************
390 *
391 * L2CAP Protocol socket callbacks
392 *
393 */
394
395 static void
l2cap_connecting(void * arg)396 l2cap_connecting(void *arg)
397 {
398 struct socket *so = arg;
399
400 DPRINTF("Connecting\n");
401 soisconnecting(so);
402 }
403
404 static void
l2cap_connected(void * arg)405 l2cap_connected(void *arg)
406 {
407 struct socket *so = arg;
408
409 DPRINTF("Connected\n");
410 soisconnected(so);
411 }
412
413 static void
l2cap_disconnected(void * arg,int err)414 l2cap_disconnected(void *arg, int err)
415 {
416 struct socket *so = arg;
417
418 DPRINTF("Disconnected (%d)\n", err);
419
420 so->so_error = err;
421 soisdisconnected(so);
422 }
423
424 static void *
l2cap_newconn(void * arg,struct sockaddr_bt * laddr,struct sockaddr_bt * raddr)425 l2cap_newconn(void *arg, struct sockaddr_bt *laddr,
426 struct sockaddr_bt *raddr)
427 {
428 struct socket *so = arg;
429
430 DPRINTF("New Connection\n");
431 so = sonewconn(so, false);
432 if (so == NULL)
433 return NULL;
434
435 soisconnecting(so);
436
437 return so->so_pcb;
438 }
439
440 static void
l2cap_complete(void * arg,int count)441 l2cap_complete(void *arg, int count)
442 {
443 struct socket *so = arg;
444
445 while (count-- > 0)
446 sbdroprecord(&so->so_snd);
447
448 sowwakeup(so);
449 }
450
451 static void
l2cap_linkmode(void * arg,int new)452 l2cap_linkmode(void *arg, int new)
453 {
454 struct socket *so = arg;
455 struct sockopt sopt;
456 int mode;
457
458 DPRINTF("auth %s, encrypt %s, secure %s\n",
459 (new & L2CAP_LM_AUTH ? "on" : "off"),
460 (new & L2CAP_LM_ENCRYPT ? "on" : "off"),
461 (new & L2CAP_LM_SECURE ? "on" : "off"));
462
463 sockopt_init(&sopt, BTPROTO_L2CAP, SO_L2CAP_LM, 0);
464 (void)l2cap_getopt(so->so_pcb, &sopt);
465 (void)sockopt_getint(&sopt, &mode);
466 sockopt_destroy(&sopt);
467
468 if (((mode & L2CAP_LM_AUTH) && !(new & L2CAP_LM_AUTH))
469 || ((mode & L2CAP_LM_ENCRYPT) && !(new & L2CAP_LM_ENCRYPT))
470 || ((mode & L2CAP_LM_SECURE) && !(new & L2CAP_LM_SECURE)))
471 l2cap_disconnect_pcb(so->so_pcb, 0);
472 }
473
474 static void
l2cap_input(void * arg,struct mbuf * m)475 l2cap_input(void *arg, struct mbuf *m)
476 {
477 struct socket *so = arg;
478
479 if (m->m_pkthdr.len > sbspace(&so->so_rcv)) {
480 printf("%s: packet (%d bytes) dropped (socket buffer full)\n",
481 __func__, m->m_pkthdr.len);
482 m_freem(m);
483 return;
484 }
485
486 DPRINTFN(10, "received %d bytes\n", m->m_pkthdr.len);
487
488 sbappendrecord(&so->so_rcv, m);
489 sorwakeup(so);
490 }
491
492 PR_WRAP_USRREQS(l2cap)
493
494 #define l2cap_attach l2cap_attach_wrapper
495 #define l2cap_detach l2cap_detach_wrapper
496 #define l2cap_accept l2cap_accept_wrapper
497 #define l2cap_bind l2cap_bind_wrapper
498 #define l2cap_listen l2cap_listen_wrapper
499 #define l2cap_connect l2cap_connect_wrapper
500 #define l2cap_connect2 l2cap_connect2_wrapper
501 #define l2cap_disconnect l2cap_disconnect_wrapper
502 #define l2cap_shutdown l2cap_shutdown_wrapper
503 #define l2cap_abort l2cap_abort_wrapper
504 #define l2cap_ioctl l2cap_ioctl_wrapper
505 #define l2cap_stat l2cap_stat_wrapper
506 #define l2cap_peeraddr l2cap_peeraddr_wrapper
507 #define l2cap_sockaddr l2cap_sockaddr_wrapper
508 #define l2cap_rcvd l2cap_rcvd_wrapper
509 #define l2cap_recvoob l2cap_recvoob_wrapper
510 #define l2cap_send l2cap_send_wrapper
511 #define l2cap_sendoob l2cap_sendoob_wrapper
512 #define l2cap_purgeif l2cap_purgeif_wrapper
513
514 const struct pr_usrreqs l2cap_usrreqs = {
515 .pr_attach = l2cap_attach,
516 .pr_detach = l2cap_detach,
517 .pr_accept = l2cap_accept,
518 .pr_bind = l2cap_bind,
519 .pr_listen = l2cap_listen,
520 .pr_connect = l2cap_connect,
521 .pr_connect2 = l2cap_connect2,
522 .pr_disconnect = l2cap_disconnect,
523 .pr_shutdown = l2cap_shutdown,
524 .pr_abort = l2cap_abort,
525 .pr_ioctl = l2cap_ioctl,
526 .pr_stat = l2cap_stat,
527 .pr_peeraddr = l2cap_peeraddr,
528 .pr_sockaddr = l2cap_sockaddr,
529 .pr_rcvd = l2cap_rcvd,
530 .pr_recvoob = l2cap_recvoob,
531 .pr_send = l2cap_send,
532 .pr_sendoob = l2cap_sendoob,
533 .pr_purgeif = l2cap_purgeif,
534 };
535