rfcomm_socket.c revision 1.33.2.1
1 /* $NetBSD: rfcomm_socket.c,v 1.33.2.1 2019/01/29 07:57:00 msaitoh 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.33.2.1 2019/01/29 07:57:00 msaitoh 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 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 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 128 rfcomm_accept(struct socket *so, struct mbuf *nam) 129 { 130 struct rfcomm_dlc *pcb = so->so_pcb; 131 struct sockaddr_bt *sa; 132 133 KASSERT(solocked(so)); 134 KASSERT(nam != NULL); 135 136 if (pcb == NULL) 137 return EINVAL; 138 139 sa = mtod(nam, struct sockaddr_bt *); 140 nam->m_len = sizeof(struct sockaddr_bt); 141 return rfcomm_peeraddr_pcb(pcb, sa); 142 } 143 144 static int 145 rfcomm_bind(struct socket *so, struct mbuf *nam, struct lwp *l) 146 { 147 struct rfcomm_dlc *pcb = so->so_pcb; 148 struct sockaddr_bt *sa; 149 150 KASSERT(solocked(so)); 151 KASSERT(nam != NULL); 152 153 if (pcb == NULL) 154 return EINVAL; 155 156 sa = mtod(nam, struct sockaddr_bt *); 157 if (sa->bt_len != sizeof(struct sockaddr_bt)) 158 return EINVAL; 159 160 if (sa->bt_family != AF_BLUETOOTH) 161 return EAFNOSUPPORT; 162 163 return rfcomm_bind_pcb(pcb, sa); 164 } 165 166 static int 167 rfcomm_listen(struct socket *so, struct lwp *l) 168 { 169 struct rfcomm_dlc *pcb = so->so_pcb; 170 171 KASSERT(solocked(so)); 172 173 if (pcb == NULL) 174 return EINVAL; 175 176 return rfcomm_listen_pcb(pcb); 177 } 178 179 static int 180 rfcomm_connect(struct socket *so, struct mbuf *nam, struct lwp *l) 181 { 182 struct rfcomm_dlc *pcb = so->so_pcb; 183 struct sockaddr_bt *sa; 184 185 KASSERT(solocked(so)); 186 KASSERT(nam != NULL); 187 188 if (pcb == NULL) 189 return EINVAL; 190 191 sa = mtod(nam, struct sockaddr_bt *); 192 if (sa->bt_len != sizeof(struct sockaddr_bt)) 193 return EINVAL; 194 195 if (sa->bt_family != AF_BLUETOOTH) 196 return EAFNOSUPPORT; 197 198 soisconnecting(so); 199 return rfcomm_connect_pcb(pcb, sa); 200 } 201 202 static int 203 rfcomm_connect2(struct socket *so, struct socket *so2) 204 { 205 struct rfcomm_dlc *pcb = so->so_pcb; 206 207 KASSERT(solocked(so)); 208 209 if (pcb == NULL) 210 return EINVAL; 211 212 return EOPNOTSUPP; 213 } 214 215 static int 216 rfcomm_disconnect(struct socket *so) 217 { 218 struct rfcomm_dlc *pcb = so->so_pcb; 219 220 KASSERT(solocked(so)); 221 222 if (pcb == NULL) 223 return EINVAL; 224 225 soisdisconnecting(so); 226 return rfcomm_disconnect_pcb(pcb, so->so_linger); 227 } 228 229 static int 230 rfcomm_shutdown(struct socket *so) 231 { 232 KASSERT(solocked(so)); 233 234 socantsendmore(so); 235 return 0; 236 } 237 238 static int 239 rfcomm_abort(struct socket *so) 240 { 241 struct rfcomm_dlc *pcb = so->so_pcb; 242 243 KASSERT(solocked(so)); 244 245 if (pcb == NULL) 246 return EINVAL; 247 248 rfcomm_disconnect_pcb(pcb, 0); 249 soisdisconnected(so); 250 rfcomm_detach(so); 251 return 0; 252 } 253 254 static int 255 rfcomm_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp) 256 { 257 return EPASSTHROUGH; 258 } 259 260 static int 261 rfcomm_stat(struct socket *so, struct stat *ub) 262 { 263 KASSERT(solocked(so)); 264 265 return 0; 266 } 267 268 static int 269 rfcomm_peeraddr(struct socket *so, struct mbuf *nam) 270 { 271 struct rfcomm_dlc *pcb = so->so_pcb; 272 struct sockaddr_bt *sa; 273 274 KASSERT(solocked(so)); 275 KASSERT(pcb != NULL); 276 KASSERT(nam != NULL); 277 278 sa = mtod(nam, struct sockaddr_bt *); 279 nam->m_len = sizeof(struct sockaddr_bt); 280 return rfcomm_peeraddr_pcb(pcb, sa); 281 } 282 283 static int 284 rfcomm_sockaddr(struct socket *so, struct mbuf *nam) 285 { 286 struct rfcomm_dlc *pcb = so->so_pcb; 287 struct sockaddr_bt *sa; 288 289 KASSERT(solocked(so)); 290 KASSERT(pcb != NULL); 291 KASSERT(nam != NULL); 292 293 sa = mtod(nam, struct sockaddr_bt *); 294 nam->m_len = sizeof(struct sockaddr_bt); 295 return rfcomm_sockaddr_pcb(pcb, sa); 296 } 297 298 static int 299 rfcomm_rcvd(struct socket *so, int flags, struct lwp *l) 300 { 301 struct rfcomm_dlc *pcb = so->so_pcb; 302 303 KASSERT(solocked(so)); 304 305 if (pcb == NULL) 306 return EINVAL; 307 308 return rfcomm_rcvd_pcb(pcb, sbspace(&so->so_rcv)); 309 } 310 311 static int 312 rfcomm_recvoob(struct socket *so, struct mbuf *m, int flags) 313 { 314 KASSERT(solocked(so)); 315 316 return EOPNOTSUPP; 317 } 318 319 static int 320 rfcomm_send(struct socket *so, struct mbuf *m, struct mbuf *nam, 321 struct mbuf *control, struct lwp *l) 322 { 323 struct rfcomm_dlc *pcb = so->so_pcb; 324 int err = 0; 325 struct mbuf *m0; 326 327 KASSERT(solocked(so)); 328 KASSERT(m != NULL); 329 330 if (control) /* no use for that */ 331 m_freem(control); 332 333 if (pcb == NULL) { 334 err = EINVAL; 335 goto release; 336 } 337 338 m0 = m_copypacket(m, M_DONTWAIT); 339 if (m0 == NULL) { 340 err = ENOMEM; 341 goto release; 342 } 343 344 sbappendstream(&so->so_snd, m); 345 return rfcomm_send_pcb(pcb, m0); 346 347 release: 348 m_freem(m); 349 return err; 350 } 351 352 static int 353 rfcomm_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control) 354 { 355 KASSERT(solocked(so)); 356 357 m_freem(m); 358 m_freem(control); 359 360 return EOPNOTSUPP; 361 } 362 363 static int 364 rfcomm_purgeif(struct socket *so, struct ifnet *ifp) 365 { 366 367 return EOPNOTSUPP; 368 } 369 370 /* 371 * User Request. 372 * up is socket 373 * m is optional mbuf chain containing message 374 * ctl is either 375 * optional mbuf chain containing socket options 376 * l is pointer to process requesting action (if any) 377 * 378 * we are responsible for disposing of m and ctl if 379 * they are mbuf chains 380 */ 381 static int 382 rfcomm_usrreq(struct socket *up, int req, struct mbuf *m, 383 struct mbuf *nam, struct mbuf *ctl, struct lwp *l) 384 { 385 struct rfcomm_dlc *pcb = up->so_pcb; 386 int err = 0; 387 388 DPRINTFN(2, "%s\n", prurequests[req]); 389 KASSERT(req != PRU_ATTACH); 390 KASSERT(req != PRU_DETACH); 391 KASSERT(req != PRU_ACCEPT); 392 KASSERT(req != PRU_BIND); 393 KASSERT(req != PRU_LISTEN); 394 KASSERT(req != PRU_CONNECT); 395 KASSERT(req != PRU_CONNECT2); 396 KASSERT(req != PRU_DISCONNECT); 397 KASSERT(req != PRU_SHUTDOWN); 398 KASSERT(req != PRU_ABORT); 399 KASSERT(req != PRU_CONTROL); 400 KASSERT(req != PRU_SENSE); 401 KASSERT(req != PRU_PEERADDR); 402 KASSERT(req != PRU_SOCKADDR); 403 KASSERT(req != PRU_RCVD); 404 KASSERT(req != PRU_RCVOOB); 405 KASSERT(req != PRU_SEND); 406 KASSERT(req != PRU_SENDOOB); 407 KASSERT(req != PRU_PURGEIF); 408 409 if (pcb == NULL) { 410 err = EINVAL; 411 goto release; 412 } 413 414 switch(req) { 415 case PRU_FASTTIMO: 416 case PRU_SLOWTIMO: 417 case PRU_PROTORCV: 418 case PRU_PROTOSEND: 419 err = EOPNOTSUPP; 420 break; 421 422 default: 423 UNKNOWN(req); 424 err = EOPNOTSUPP; 425 break; 426 } 427 428 release: 429 if (m) m_freem(m); 430 if (ctl) m_freem(ctl); 431 return err; 432 } 433 434 /* 435 * rfcomm_ctloutput(req, socket, sockopt) 436 * 437 */ 438 int 439 rfcomm_ctloutput(int req, struct socket *so, struct sockopt *sopt) 440 { 441 struct rfcomm_dlc *pcb = so->so_pcb; 442 int err = 0; 443 444 DPRINTFN(2, "%s\n", prcorequests[req]); 445 446 if (pcb == NULL) 447 return EINVAL; 448 449 if (sopt->sopt_level != BTPROTO_RFCOMM) 450 return ENOPROTOOPT; 451 452 switch(req) { 453 case PRCO_GETOPT: 454 err = rfcomm_getopt(pcb, sopt); 455 break; 456 457 case PRCO_SETOPT: 458 err = rfcomm_setopt(pcb, sopt); 459 break; 460 461 default: 462 err = ENOPROTOOPT; 463 break; 464 } 465 466 return err; 467 } 468 469 /********************************************************************** 470 * 471 * RFCOMM callbacks 472 */ 473 474 static void 475 rfcomm_connecting(void *arg) 476 { 477 /* struct socket *so = arg; */ 478 479 KASSERT(arg != NULL); 480 DPRINTF("Connecting\n"); 481 } 482 483 static void 484 rfcomm_connected(void *arg) 485 { 486 struct socket *so = arg; 487 488 KASSERT(so != NULL); 489 DPRINTF("Connected\n"); 490 soisconnected(so); 491 } 492 493 static void 494 rfcomm_disconnected(void *arg, int err) 495 { 496 struct socket *so = arg; 497 498 KASSERT(so != NULL); 499 DPRINTF("Disconnected\n"); 500 501 so->so_error = err; 502 soisdisconnected(so); 503 } 504 505 static void * 506 rfcomm_newconn(void *arg, struct sockaddr_bt *laddr, 507 struct sockaddr_bt *raddr) 508 { 509 struct socket *so = arg; 510 511 DPRINTF("New Connection\n"); 512 so = sonewconn(so, false); 513 if (so == NULL) 514 return NULL; 515 516 soisconnecting(so); 517 518 return so->so_pcb; 519 } 520 521 /* 522 * rfcomm_complete(rfcomm_dlc, length) 523 * 524 * length bytes are sent and may be removed from socket buffer 525 */ 526 static void 527 rfcomm_complete(void *arg, int length) 528 { 529 struct socket *so = arg; 530 531 sbdrop(&so->so_snd, length); 532 sowwakeup(so); 533 } 534 535 /* 536 * rfcomm_linkmode(rfcomm_dlc, new) 537 * 538 * link mode change notification. 539 */ 540 static void 541 rfcomm_linkmode(void *arg, int new) 542 { 543 struct socket *so = arg; 544 struct sockopt sopt; 545 int mode; 546 547 DPRINTF("auth %s, encrypt %s, secure %s\n", 548 (new & RFCOMM_LM_AUTH ? "on" : "off"), 549 (new & RFCOMM_LM_ENCRYPT ? "on" : "off"), 550 (new & RFCOMM_LM_SECURE ? "on" : "off")); 551 552 sockopt_init(&sopt, BTPROTO_RFCOMM, SO_RFCOMM_LM, 0); 553 (void)rfcomm_getopt(so->so_pcb, &sopt); 554 (void)sockopt_getint(&sopt, &mode); 555 sockopt_destroy(&sopt); 556 557 if (((mode & RFCOMM_LM_AUTH) && !(new & RFCOMM_LM_AUTH)) 558 || ((mode & RFCOMM_LM_ENCRYPT) && !(new & RFCOMM_LM_ENCRYPT)) 559 || ((mode & RFCOMM_LM_SECURE) && !(new & RFCOMM_LM_SECURE))) 560 rfcomm_disconnect_pcb(so->so_pcb, 0); 561 } 562 563 /* 564 * rfcomm_input(rfcomm_dlc, mbuf) 565 */ 566 static void 567 rfcomm_input(void *arg, struct mbuf *m) 568 { 569 struct socket *so = arg; 570 571 KASSERT(so != NULL); 572 573 if (m->m_pkthdr.len > sbspace(&so->so_rcv)) { 574 printf("%s: %d bytes dropped (socket buffer full)\n", 575 __func__, m->m_pkthdr.len); 576 m_freem(m); 577 return; 578 } 579 580 DPRINTFN(10, "received %d bytes\n", m->m_pkthdr.len); 581 582 sbappendstream(&so->so_rcv, m); 583 sorwakeup(so); 584 } 585 586 PR_WRAP_USRREQS(rfcomm) 587 588 #define rfcomm_attach rfcomm_attach_wrapper 589 #define rfcomm_detach rfcomm_detach_wrapper 590 #define rfcomm_accept rfcomm_accept_wrapper 591 #define rfcomm_bind rfcomm_bind_wrapper 592 #define rfcomm_listen rfcomm_listen_wrapper 593 #define rfcomm_connect rfcomm_connect_wrapper 594 #define rfcomm_connect2 rfcomm_connect2_wrapper 595 #define rfcomm_disconnect rfcomm_disconnect_wrapper 596 #define rfcomm_shutdown rfcomm_shutdown_wrapper 597 #define rfcomm_abort rfcomm_abort_wrapper 598 #define rfcomm_ioctl rfcomm_ioctl_wrapper 599 #define rfcomm_stat rfcomm_stat_wrapper 600 #define rfcomm_peeraddr rfcomm_peeraddr_wrapper 601 #define rfcomm_sockaddr rfcomm_sockaddr_wrapper 602 #define rfcomm_rcvd rfcomm_rcvd_wrapper 603 #define rfcomm_recvoob rfcomm_recvoob_wrapper 604 #define rfcomm_send rfcomm_send_wrapper 605 #define rfcomm_sendoob rfcomm_sendoob_wrapper 606 #define rfcomm_purgeif rfcomm_purgeif_wrapper 607 #define rfcomm_usrreq rfcomm_usrreq_wrapper 608 609 const struct pr_usrreqs rfcomm_usrreqs = { 610 .pr_attach = rfcomm_attach, 611 .pr_detach = rfcomm_detach, 612 .pr_accept = rfcomm_accept, 613 .pr_bind = rfcomm_bind, 614 .pr_listen = rfcomm_listen, 615 .pr_connect = rfcomm_connect, 616 .pr_connect2 = rfcomm_connect2, 617 .pr_disconnect = rfcomm_disconnect, 618 .pr_shutdown = rfcomm_shutdown, 619 .pr_abort = rfcomm_abort, 620 .pr_ioctl = rfcomm_ioctl, 621 .pr_stat = rfcomm_stat, 622 .pr_peeraddr = rfcomm_peeraddr, 623 .pr_sockaddr = rfcomm_sockaddr, 624 .pr_rcvd = rfcomm_rcvd, 625 .pr_recvoob = rfcomm_recvoob, 626 .pr_send = rfcomm_send, 627 .pr_sendoob = rfcomm_sendoob, 628 .pr_purgeif = rfcomm_purgeif, 629 .pr_generic = rfcomm_usrreq, 630 }; 631
Indexes created Thu Oct 02 14:10:14 GMT 2025