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