1 /* $OpenBSD: src/sys/netbt/rfcomm_socket.c,v 1.2 2008/02/24 21:34:48 uwe Exp $ */ 2 /* $NetBSD: rfcomm_socket.c,v 1.8 2007/10/15 18:04:34 plunky Exp $ */ 3 4 /*- 5 * Copyright (c) 2006 Itronix Inc. 6 * All rights reserved. 7 * 8 * Written by Iain Hibbert for Itronix Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. The name of Itronix Inc. may not be used to endorse 19 * or promote products derived from this software without specific 20 * prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY 26 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 27 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 29 * ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 /* load symbolic names */ 36 #ifdef BLUETOOTH_DEBUG 37 #define PRUREQUESTS 38 #define PRCOREQUESTS 39 #endif 40 41 #include <sys/param.h> 42 #include <sys/domain.h> 43 #include <sys/kernel.h> 44 #include <sys/mbuf.h> 45 #include <sys/proc.h> 46 #include <sys/protosw.h> 47 #include <sys/socket.h> 48 #include <sys/socketvar.h> 49 #include <sys/systm.h> 50 51 #include <sys/msgport2.h> 52 53 #include <vm/vm_zone.h> 54 55 #include <netbt/bluetooth.h> 56 #include <netbt/hci.h> /* XXX for EPASSTHROUGH */ 57 #include <netbt/rfcomm.h> 58 59 /**************************************************************************** 60 * 61 * RFCOMM SOCK_STREAM Sockets - serial line emulation 62 * 63 */ 64 65 static void rfcomm_connecting(void *); 66 static void rfcomm_connected(void *); 67 static void rfcomm_disconnected(void *, int); 68 static void *rfcomm_newconn(void *, struct sockaddr_bt *, struct sockaddr_bt *); 69 static void rfcomm_complete(void *, int); 70 static void rfcomm_linkmode(void *, int); 71 static void rfcomm_input(void *, struct mbuf *); 72 73 static const struct btproto rfcomm_proto = { 74 rfcomm_connecting, 75 rfcomm_connected, 76 rfcomm_disconnected, 77 rfcomm_newconn, 78 rfcomm_complete, 79 rfcomm_linkmode, 80 rfcomm_input, 81 }; 82 83 /* sysctl variables */ 84 int rfcomm_sendspace = 4096; 85 int rfcomm_recvspace = 4096; 86 87 /* 88 * rfcomm_ctloutput(request, socket, level, optname, opt) 89 * 90 */ 91 void 92 rfcomm_ctloutput(netmsg_t msg) 93 { 94 struct socket *so = msg->ctloutput.base.nm_so; 95 struct sockopt *sopt = msg->ctloutput.nm_sopt; 96 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 97 struct mbuf *m; 98 int error = 0; 99 100 #ifdef notyet /* XXX */ 101 DPRINTFN(2, "%s\n", prcorequests[sopt->sopt_dir]); 102 #endif 103 104 if (pcb == NULL) { 105 error = EINVAL; 106 goto out; 107 } 108 109 if (sopt->sopt_level != BTPROTO_RFCOMM) { 110 error = ENOPROTOOPT; 111 goto out; 112 } 113 114 switch(sopt->sopt_dir) { 115 case PRCO_GETOPT: 116 m = m_get(M_WAITOK, MT_DATA); 117 crit_enter(); 118 m->m_len = rfcomm_getopt(pcb, sopt->sopt_name, mtod(m, void *)); 119 crit_exit(); 120 if (m->m_len == 0) { 121 m_freem(m); 122 m = NULL; 123 error = ENOPROTOOPT; 124 } 125 soopt_from_kbuf(sopt, mtod(m, void *), m->m_len); 126 break; 127 128 case PRCO_SETOPT: 129 error = rfcomm_setopt2(pcb, sopt->sopt_name, so, sopt); 130 131 break; 132 133 default: 134 error = ENOPROTOOPT; 135 break; 136 } 137 out: 138 lwkt_replymsg(&msg->ctloutput.base.lmsg, error); 139 } 140 141 /********************************************************************** 142 * 143 * RFCOMM callbacks 144 */ 145 146 static void 147 rfcomm_connecting(void *arg) 148 { 149 /* struct socket *so = arg; */ 150 151 KKASSERT(arg != NULL); 152 DPRINTF("Connecting\n"); 153 } 154 155 static void 156 rfcomm_connected(void *arg) 157 { 158 struct socket *so = arg; 159 160 KKASSERT(so != NULL); 161 DPRINTF("Connected\n"); 162 soisconnected(so); 163 } 164 165 static void 166 rfcomm_disconnected(void *arg, int err) 167 { 168 struct socket *so = arg; 169 170 KKASSERT(so != NULL); 171 DPRINTF("Disconnected\n"); 172 173 so->so_error = err; 174 soisdisconnected(so); 175 } 176 177 static void * 178 rfcomm_newconn(void *arg, struct sockaddr_bt *laddr, 179 struct sockaddr_bt *raddr) 180 { 181 struct socket *so = arg; 182 183 DPRINTF("New Connection\n"); 184 so = sonewconn(so, 0); 185 if (so == NULL) 186 return NULL; 187 188 soisconnecting(so); 189 190 return so->so_pcb; 191 } 192 193 /* 194 * rfcomm_complete(rfcomm_dlc, length) 195 * 196 * length bytes are sent and may be removed from socket buffer 197 */ 198 static void 199 rfcomm_complete(void *arg, int length) 200 { 201 struct socket *so = arg; 202 203 sbdrop(&so->so_snd.sb, length); 204 sowwakeup(so); 205 } 206 207 /* 208 * rfcomm_linkmode(rfcomm_dlc, new) 209 * 210 * link mode change notification. 211 */ 212 static void 213 rfcomm_linkmode(void *arg, int new) 214 { 215 struct socket *so = arg; 216 int mode; 217 218 DPRINTF("auth %s, encrypt %s, secure %s\n", 219 (new & RFCOMM_LM_AUTH ? "on" : "off"), 220 (new & RFCOMM_LM_ENCRYPT ? "on" : "off"), 221 (new & RFCOMM_LM_SECURE ? "on" : "off")); 222 223 (void)rfcomm_getopt(so->so_pcb, SO_RFCOMM_LM, &mode); 224 if (((mode & RFCOMM_LM_AUTH) && !(new & RFCOMM_LM_AUTH)) 225 || ((mode & RFCOMM_LM_ENCRYPT) && !(new & RFCOMM_LM_ENCRYPT)) 226 || ((mode & RFCOMM_LM_SECURE) && !(new & RFCOMM_LM_SECURE))) 227 rfcomm_disconnect(so->so_pcb, 0); 228 } 229 230 /* 231 * rfcomm_input(rfcomm_dlc, mbuf) 232 */ 233 static void 234 rfcomm_input(void *arg, struct mbuf *m) 235 { 236 struct socket *so = arg; 237 238 KKASSERT(so != NULL); 239 240 if (m->m_pkthdr.len > sbspace(&so->so_rcv)) { 241 kprintf("%s: %d bytes dropped (socket buffer full)\n", 242 __func__, m->m_pkthdr.len); 243 m_freem(m); 244 return; 245 } 246 247 DPRINTFN(10, "received %d bytes\n", m->m_pkthdr.len); 248 249 sbappendstream(&so->so_rcv.sb, m); 250 sorwakeup(so); 251 } 252 253 /* 254 * Implementation of usrreqs. 255 */ 256 static void 257 rfcomm_sdetach(netmsg_t msg) 258 { 259 struct socket *so = msg->detach.base.nm_so; 260 int error; 261 262 error = rfcomm_detach((struct rfcomm_dlc **)&so->so_pcb); 263 lwkt_replymsg(&msg->detach.base.lmsg, error); 264 } 265 266 /* 267 * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort() 268 * will sofree() it when we return. 269 */ 270 static void 271 rfcomm_sabort(netmsg_t msg) 272 { 273 struct socket *so = msg->abort.base.nm_so; 274 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 275 276 rfcomm_disconnect(pcb, 0); 277 soisdisconnected(so); 278 rfcomm_sdetach(msg); 279 /* msg invalid now */ 280 } 281 282 static void 283 rfcomm_sdisconnect(netmsg_t msg) 284 { 285 struct socket *so = msg->abort.base.nm_so; 286 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 287 int error; 288 289 soisdisconnecting(so); 290 error = rfcomm_disconnect(pcb, so->so_linger); 291 lwkt_replymsg(&msg->disconnect.base.lmsg, error); 292 } 293 294 static void 295 rfcomm_scontrol(netmsg_t msg) 296 { 297 lwkt_replymsg(&msg->control.base.lmsg, EPASSTHROUGH); 298 } 299 300 static void 301 rfcomm_sattach(netmsg_t msg) 302 { 303 struct socket *so = msg->attach.base.nm_so; 304 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 305 int error; 306 307 if (pcb != NULL) { 308 error = EINVAL; 309 goto out; 310 } 311 312 /* 313 * Since we have nothing to add, we attach the DLC 314 * structure directly to our PCB pointer. 315 */ 316 error = soreserve(so, rfcomm_sendspace, rfcomm_recvspace, NULL); 317 if (error) 318 goto out; 319 320 error = rfcomm_attach((struct rfcomm_dlc **)&so->so_pcb, 321 &rfcomm_proto, so); 322 if (error) 323 goto out; 324 325 error = rfcomm_rcvd(so->so_pcb, sbspace(&so->so_rcv)); 326 if (error) 327 rfcomm_detach((struct rfcomm_dlc **)&so->so_pcb); 328 out: 329 lwkt_replymsg(&msg->attach.base.lmsg, error); 330 } 331 332 static void 333 rfcomm_sbind(netmsg_t msg) 334 { 335 struct socket *so = msg->bind.base.nm_so; 336 struct sockaddr *nam = msg->bind.nm_nam; 337 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 338 struct sockaddr_bt *sa; 339 int error; 340 341 KKASSERT(nam != NULL); 342 sa = (struct sockaddr_bt *)nam; 343 344 if (sa->bt_len != sizeof(struct sockaddr_bt)) { 345 error = EINVAL; 346 } else if (sa->bt_family != AF_BLUETOOTH) { 347 error = EAFNOSUPPORT; 348 } else { 349 error = rfcomm_bind(pcb, sa); 350 } 351 lwkt_replymsg(&msg->bind.base.lmsg, error); 352 } 353 354 static void 355 rfcomm_sconnect(netmsg_t msg) 356 { 357 struct socket *so = msg->connect.base.nm_so; 358 struct sockaddr *nam = msg->connect.nm_nam; 359 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 360 struct sockaddr_bt *sa; 361 int error; 362 363 KKASSERT(nam != NULL); 364 sa = (struct sockaddr_bt *)nam; 365 366 if (sa->bt_len != sizeof(struct sockaddr_bt)) { 367 error = EINVAL; 368 } else if (sa->bt_family != AF_BLUETOOTH) { 369 error = EAFNOSUPPORT; 370 } else { 371 soisconnecting(so); 372 error = rfcomm_connect(pcb, sa); 373 } 374 lwkt_replymsg(&msg->connect.base.lmsg, error); 375 } 376 377 static void 378 rfcomm_speeraddr(netmsg_t msg) 379 { 380 struct socket *so = msg->peeraddr.base.nm_so; 381 struct sockaddr **nam = msg->peeraddr.nm_nam; 382 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 383 struct sockaddr_bt *sa, ssa; 384 int error; 385 386 sa = &ssa; 387 bzero(sa, sizeof *sa); 388 sa->bt_len = sizeof(struct sockaddr_bt); 389 sa->bt_family = AF_BLUETOOTH; 390 error = rfcomm_peeraddr(pcb, sa); 391 *nam = dup_sockaddr((struct sockaddr *)sa); 392 393 lwkt_replymsg(&msg->peeraddr.base.lmsg, error); 394 } 395 396 static void 397 rfcomm_ssockaddr(netmsg_t msg) 398 { 399 struct socket *so = msg->sockaddr.base.nm_so; 400 struct sockaddr **nam = msg->sockaddr.nm_nam; 401 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 402 struct sockaddr_bt *sa, ssa; 403 int error; 404 405 sa = &ssa; 406 bzero(sa, sizeof *sa); 407 sa->bt_len = sizeof(struct sockaddr_bt); 408 sa->bt_family = AF_BLUETOOTH; 409 error = rfcomm_sockaddr(pcb, sa); 410 *nam = dup_sockaddr((struct sockaddr *)sa); 411 412 lwkt_replymsg(&msg->sockaddr.base.lmsg, error); 413 } 414 415 static void 416 rfcomm_sshutdown(netmsg_t msg) 417 { 418 struct socket *so = msg->shutdown.base.nm_so; 419 420 socantsendmore(so); 421 lwkt_replymsg(&msg->shutdown.base.lmsg, 0); 422 } 423 424 static void 425 rfcomm_ssend(netmsg_t msg) 426 { 427 struct socket *so = msg->send.base.nm_so; 428 struct mbuf *m = msg->send.nm_m; 429 struct mbuf *control = msg->send.nm_control; 430 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 431 struct mbuf *m0; 432 int error; 433 434 KKASSERT(m != NULL); 435 436 /* no use for that */ 437 if (control) { 438 m_freem(control); 439 control = NULL; 440 } 441 442 m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT); 443 if (m0) { 444 sbappendstream(&so->so_snd.sb, m); 445 error = rfcomm_send(pcb, m0); 446 } else { 447 error = ENOMEM; 448 } 449 lwkt_replymsg(&msg->send.base.lmsg, error); 450 } 451 452 static void 453 rfcomm_saccept(netmsg_t msg) 454 { 455 struct socket *so = msg->accept.base.nm_so; 456 struct sockaddr **nam = msg->accept.nm_nam; 457 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 458 struct sockaddr_bt *sa, ssa; 459 int error; 460 461 sa = &ssa; 462 bzero(sa, sizeof *sa); 463 sa->bt_len = sizeof(struct sockaddr_bt); 464 sa->bt_family = AF_BLUETOOTH; 465 error = rfcomm_peeraddr(pcb, sa); 466 *nam = dup_sockaddr((struct sockaddr *)sa); 467 468 lwkt_replymsg(&msg->accept.base.lmsg, error); 469 } 470 471 static void 472 rfcomm_slisten(netmsg_t msg) 473 { 474 struct socket *so = msg->listen.base.nm_so; 475 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *)so->so_pcb; 476 int error; 477 478 error = rfcomm_listen(pcb); 479 lwkt_replymsg(&msg->listen.base.lmsg, error); 480 } 481 482 static void 483 rfcomm_srcvd(netmsg_t msg) 484 { 485 struct socket *so = msg->rcvd.base.nm_so; 486 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb; 487 int error; 488 489 error = rfcomm_rcvd(pcb, sbspace(&so->so_rcv)); 490 lwkt_replymsg(&msg->rcvd.base.lmsg, error); 491 } 492 493 struct pr_usrreqs rfcomm_usrreqs = { 494 .pru_abort = rfcomm_sabort, 495 .pru_accept = rfcomm_saccept, 496 .pru_attach = rfcomm_sattach, 497 .pru_bind = rfcomm_sbind, 498 .pru_connect = rfcomm_sconnect, 499 .pru_connect2 = pr_generic_notsupp, 500 .pru_control = rfcomm_scontrol, 501 .pru_detach = rfcomm_sdetach, 502 .pru_disconnect = rfcomm_sdisconnect, 503 .pru_listen = rfcomm_slisten, 504 .pru_peeraddr = rfcomm_speeraddr, 505 .pru_rcvd = rfcomm_srcvd, 506 .pru_rcvoob = pr_generic_notsupp, 507 .pru_send = rfcomm_ssend, 508 .pru_sense = pru_sense_null, 509 .pru_shutdown = rfcomm_sshutdown, 510 .pru_sockaddr = rfcomm_ssockaddr, 511 .pru_sosend = sosend, 512 .pru_soreceive = soreceive 513 }; 514