1 /* $OpenBSD: l2cap_socket.c,v 1.1 2007/06/01 02:46:11 uwe Exp $ */ 2 /* $NetBSD: l2cap_socket.c,v 1.7 2007/04/21 06:15:23 plunky Exp $ */ 3 4 /*- 5 * Copyright (c) 2005 Iain Hibbert. 6 * Copyright (c) 2006 Itronix Inc. 7 * All rights reserved. 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 /* load symbolic names */ 35 #ifdef BLUETOOTH_DEBUG 36 #define PRUREQUESTS 37 #define PRCOREQUESTS 38 #endif 39 40 #include <sys/param.h> 41 #include <sys/domain.h> 42 #include <sys/kernel.h> 43 #include <sys/mbuf.h> 44 #include <sys/proc.h> 45 #include <sys/protosw.h> 46 #include <sys/socket.h> 47 #include <sys/socketvar.h> 48 #include <sys/systm.h> 49 50 #include <sys/msgport2.h> 51 52 #include <vm/vm_zone.h> 53 54 #include <netbt/bluetooth.h> 55 #include <netbt/hci.h> /* XXX for EPASSTHROUGH */ 56 #include <netbt/l2cap.h> 57 58 /* 59 * L2CAP Sockets 60 * 61 * SOCK_SEQPACKET - normal L2CAP connection 62 * 63 * SOCK_DGRAM - connectionless L2CAP - XXX not yet 64 */ 65 66 static void l2cap_connecting(void *); 67 static void l2cap_connected(void *); 68 static void l2cap_disconnected(void *, int); 69 static void *l2cap_newconn(void *, struct sockaddr_bt *, struct sockaddr_bt *); 70 static void l2cap_complete(void *, int); 71 static void l2cap_linkmode(void *, int); 72 static void l2cap_input(void *, struct mbuf *); 73 74 static const struct btproto l2cap_proto = { 75 l2cap_connecting, 76 l2cap_connected, 77 l2cap_disconnected, 78 l2cap_newconn, 79 l2cap_complete, 80 l2cap_linkmode, 81 l2cap_input, 82 }; 83 84 /* sysctl variables */ 85 int l2cap_sendspace = 4096; 86 int l2cap_recvspace = 4096; 87 88 /* 89 * l2cap_ctloutput(request, socket, level, optname, opt) 90 * 91 * Apply configuration commands to channel. This corresponds to 92 * "Reconfigure Channel Request" in the L2CAP specification. 93 */ 94 void 95 l2cap_ctloutput(netmsg_t msg) 96 { 97 struct socket *so = msg->ctloutput.base.nm_so; 98 struct sockopt *sopt = msg->ctloutput.nm_sopt; 99 struct l2cap_channel *pcb = (struct l2cap_channel *) so->so_pcb; 100 struct mbuf *m; 101 int error = 0; 102 103 #ifdef notyet /* XXX */ 104 DPRINTFN(2, "%s\n", prcorequests[req]); 105 #endif 106 107 if (pcb == NULL) { 108 error = EINVAL; 109 goto out; 110 } 111 112 if (sopt->sopt_level != BTPROTO_L2CAP) { 113 error = ENOPROTOOPT; 114 goto out; 115 } 116 117 switch(sopt->sopt_dir) { 118 case PRCO_GETOPT: 119 m = m_get(M_NOWAIT, MT_DATA); 120 if (m == NULL) { 121 error = ENOMEM; 122 break; 123 } 124 m->m_len = l2cap_getopt(pcb, sopt->sopt_name, mtod(m, void *)); 125 if (m->m_len == 0) { 126 m_freem(m); 127 m = NULL; 128 error = ENOPROTOOPT; 129 } 130 soopt_from_kbuf(sopt, mtod(m, void *), m->m_len); 131 break; 132 133 case PRCO_SETOPT: 134 error = l2cap_setopt2(pcb, sopt->sopt_name, so, sopt); 135 break; 136 137 default: 138 error = ENOPROTOOPT; 139 break; 140 } 141 out: 142 lwkt_replymsg(&msg->ctloutput.base.lmsg, error); 143 } 144 145 /********************************************************************** 146 * 147 * L2CAP Protocol socket callbacks 148 * 149 */ 150 151 static void 152 l2cap_connecting(void *arg) 153 { 154 struct socket *so = arg; 155 156 DPRINTF("Connecting\n"); 157 soisconnecting(so); 158 } 159 160 static void 161 l2cap_connected(void *arg) 162 { 163 struct socket *so = arg; 164 165 DPRINTF("Connected\n"); 166 soisconnected(so); 167 } 168 169 static void 170 l2cap_disconnected(void *arg, int err) 171 { 172 struct socket *so = arg; 173 174 DPRINTF("Disconnected (%d)\n", err); 175 176 so->so_error = err; 177 soisdisconnected(so); 178 } 179 180 static void * 181 l2cap_newconn(void *arg, struct sockaddr_bt *laddr, 182 struct sockaddr_bt *raddr) 183 { 184 struct socket *so = arg; 185 186 DPRINTF("New Connection\n"); 187 so = sonewconn(so, 0); 188 if (so == NULL) 189 return NULL; 190 191 soisconnecting(so); 192 193 return so->so_pcb; 194 } 195 196 static void 197 l2cap_complete(void *arg, int count) 198 { 199 struct socket *so = arg; 200 201 while (count-- > 0) 202 sbdroprecord(&so->so_snd.sb); 203 204 sowwakeup(so); 205 } 206 207 static void 208 l2cap_linkmode(void *arg, int new) 209 { 210 struct socket *so = arg; 211 int mode; 212 213 DPRINTF("auth %s, encrypt %s, secure %s\n", 214 (new & L2CAP_LM_AUTH ? "on" : "off"), 215 (new & L2CAP_LM_ENCRYPT ? "on" : "off"), 216 (new & L2CAP_LM_SECURE ? "on" : "off")); 217 218 (void)l2cap_getopt(so->so_pcb, SO_L2CAP_LM, &mode); 219 if (((mode & L2CAP_LM_AUTH) && !(new & L2CAP_LM_AUTH)) 220 || ((mode & L2CAP_LM_ENCRYPT) && !(new & L2CAP_LM_ENCRYPT)) 221 || ((mode & L2CAP_LM_SECURE) && !(new & L2CAP_LM_SECURE))) 222 l2cap_disconnect(so->so_pcb, 0); 223 } 224 225 static void 226 l2cap_input(void *arg, struct mbuf *m) 227 { 228 struct socket *so = arg; 229 230 if (m->m_pkthdr.len > sbspace(&so->so_rcv)) { 231 kprintf("%s: packet (%d bytes) dropped (socket buffer full)\n", 232 __func__, m->m_pkthdr.len); 233 m_freem(m); 234 return; 235 } 236 237 DPRINTFN(10, "received %d bytes\n", m->m_pkthdr.len); 238 239 sbappendrecord(&so->so_rcv.sb, m); 240 sorwakeup(so); 241 } 242 243 244 /* 245 * Implementation of usrreqs. 246 */ 247 static void 248 l2cap_sdetach(netmsg_t msg) 249 { 250 struct socket *so = msg->detach.base.nm_so; 251 int error; 252 253 error = l2cap_detach((struct l2cap_channel **)&so->so_pcb); 254 lwkt_replymsg(&msg->detach.base.lmsg, error); 255 } 256 257 /* 258 * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort() 259 * will sofree() it when we return. 260 */ 261 static void 262 l2cap_sabort(netmsg_t msg) 263 { 264 struct socket *so = msg->abort.base.nm_so; 265 struct l2cap_channel *pcb = so->so_pcb; 266 267 l2cap_disconnect(pcb, 0); 268 soisdisconnected(so); 269 270 l2cap_sdetach(msg); 271 /* msg invalid now */ 272 } 273 274 static void 275 l2cap_sdisconnect(netmsg_t msg) 276 { 277 struct socket *so = msg->disconnect.base.nm_so; 278 struct l2cap_channel *pcb = so->so_pcb; 279 int error; 280 281 soisdisconnecting(so); 282 283 error = l2cap_disconnect(pcb, so->so_linger); 284 lwkt_replymsg(&msg->disconnect.base.lmsg, error); 285 } 286 287 static void 288 l2cap_scontrol(netmsg_t msg) 289 { 290 lwkt_replymsg(&msg->control.base.lmsg, EPASSTHROUGH); 291 } 292 293 static void 294 l2cap_sattach(netmsg_t msg) 295 { 296 struct socket *so = msg->attach.base.nm_so; 297 struct l2cap_channel *pcb = so->so_pcb; 298 int error; 299 300 if (pcb != NULL) { 301 error = EINVAL; 302 goto out; 303 } 304 305 /* 306 * For L2CAP socket PCB we just use an l2cap_channel structure 307 * since we have nothing to add.. 308 */ 309 error = soreserve(so, l2cap_sendspace, l2cap_recvspace, NULL); 310 if (error == 0) { 311 error = l2cap_attach((struct l2cap_channel **)&so->so_pcb, 312 &l2cap_proto, so); 313 } 314 out: 315 lwkt_replymsg(&msg->attach.base.lmsg, error); 316 } 317 318 static void 319 l2cap_sbind (netmsg_t msg) 320 { 321 struct socket *so = msg->bind.base.nm_so; 322 struct sockaddr *nam = msg->bind.nm_nam; 323 struct l2cap_channel *pcb = so->so_pcb; 324 struct sockaddr_bt *sa; 325 int error; 326 327 KKASSERT(nam != NULL); 328 sa = (struct sockaddr_bt *)nam; 329 330 if (sa->bt_len != sizeof(struct sockaddr_bt)) { 331 error = EINVAL; 332 } else if (sa->bt_family != AF_BLUETOOTH) { 333 error = EAFNOSUPPORT; 334 } else { 335 error = l2cap_bind(pcb, sa); 336 } 337 lwkt_replymsg(&msg->bind.base.lmsg, error); 338 } 339 340 static void 341 l2cap_sconnect(netmsg_t msg) 342 { 343 struct socket *so = msg->connect.base.nm_so; 344 struct sockaddr *nam = msg->connect.nm_nam; 345 struct l2cap_channel *pcb = so->so_pcb; 346 struct sockaddr_bt *sa; 347 int error; 348 349 KKASSERT(nam != NULL); 350 sa = (struct sockaddr_bt *)nam; 351 352 if (sa->bt_len != sizeof(struct sockaddr_bt)) { 353 error = EINVAL; 354 } else if (sa->bt_family != AF_BLUETOOTH) { 355 error = EAFNOSUPPORT; 356 } else { 357 soisconnecting(so); 358 error = l2cap_connect(pcb, sa); 359 } 360 lwkt_replymsg(&msg->connect.base.lmsg, error); 361 } 362 363 static void 364 l2cap_speeraddr(netmsg_t msg) 365 { 366 struct socket *so = msg->peeraddr.base.nm_so; 367 struct sockaddr **nam = msg->peeraddr.nm_nam; 368 struct l2cap_channel *pcb = so->so_pcb; 369 struct sockaddr_bt *sa, ssa; 370 int error; 371 372 sa = &ssa; 373 bzero(sa, sizeof *sa); 374 sa->bt_len = sizeof(struct sockaddr_bt); 375 sa->bt_family = AF_BLUETOOTH; 376 error = l2cap_peeraddr(pcb, sa); 377 *nam = dup_sockaddr((struct sockaddr *)sa); 378 379 lwkt_replymsg(&msg->peeraddr.base.lmsg, error); 380 } 381 382 static void 383 l2cap_ssockaddr(netmsg_t msg) 384 { 385 struct socket *so = msg->sockaddr.base.nm_so; 386 struct sockaddr **nam = msg->sockaddr.nm_nam; 387 struct l2cap_channel *pcb = so->so_pcb; 388 struct sockaddr_bt *sa, ssa; 389 int error; 390 391 sa = &ssa; 392 bzero(sa, sizeof *sa); 393 sa->bt_len = sizeof(struct sockaddr_bt); 394 sa->bt_family = AF_BLUETOOTH; 395 error = l2cap_sockaddr(pcb, sa); 396 *nam = dup_sockaddr((struct sockaddr *)sa); 397 398 lwkt_replymsg(&msg->sockaddr.base.lmsg, error); 399 } 400 401 static void 402 l2cap_sshutdown(netmsg_t msg) 403 { 404 struct socket *so = msg->shutdown.base.nm_so; 405 406 socantsendmore(so); 407 408 lwkt_replymsg(&msg->shutdown.base.lmsg, 0); 409 } 410 411 static void 412 l2cap_ssend(netmsg_t msg) 413 { 414 struct socket *so = msg->send.base.nm_so; 415 struct mbuf *m = msg->send.nm_m; 416 struct mbuf *control = msg->send.nm_control; 417 struct l2cap_channel *pcb = so->so_pcb; 418 struct mbuf *m0; 419 int error; 420 421 KKASSERT(m != NULL); 422 if (m->m_pkthdr.len == 0) { 423 error = 0; 424 goto out; 425 } 426 427 if (m->m_pkthdr.len > pcb->lc_omtu) { 428 error = EMSGSIZE; 429 goto out; 430 } 431 432 m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT); 433 if (m0 == NULL) { 434 error = ENOMEM; 435 goto out; 436 } 437 438 m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT); 439 if (m0 == NULL) { 440 error = ENOMEM; 441 goto out; 442 } 443 444 /* no use for that */ 445 if (control) { 446 m_freem(control); 447 control = NULL; 448 } 449 sbappendrecord(&so->so_snd.sb, m); 450 error = l2cap_send(pcb, m0); 451 m = NULL; 452 out: 453 if (m) 454 m_freem(m); 455 if (control) 456 m_freem(control); 457 458 lwkt_replymsg(&msg->send.base.lmsg, error); 459 } 460 461 static void 462 l2cap_saccept(netmsg_t msg) 463 { 464 struct socket *so = msg->accept.base.nm_so; 465 struct sockaddr **nam = msg->accept.nm_nam; 466 struct l2cap_channel *pcb = so->so_pcb; 467 struct sockaddr_bt sa; 468 int error; 469 470 KKASSERT(nam != NULL); 471 472 bzero(&sa, sizeof (sa) ); 473 sa.bt_len = sizeof(struct sockaddr_bt); 474 sa.bt_family = AF_BLUETOOTH; 475 476 error = l2cap_peeraddr(pcb, &sa); 477 *nam = dup_sockaddr((struct sockaddr *)&sa); 478 479 lwkt_replymsg(&msg->accept.base.lmsg, error); 480 } 481 482 static void 483 l2cap_slisten(netmsg_t msg) 484 { 485 struct socket *so = msg->listen.base.nm_so; 486 struct l2cap_channel *pcb = so->so_pcb; 487 int error; 488 489 error = l2cap_listen(pcb); 490 lwkt_replymsg(&msg->accept.base.lmsg, error); 491 } 492 493 494 struct pr_usrreqs l2cap_usrreqs = { 495 .pru_abort = l2cap_sabort, 496 .pru_accept = l2cap_saccept, 497 .pru_attach = l2cap_sattach, 498 .pru_bind = l2cap_sbind, 499 .pru_connect = l2cap_sconnect, 500 .pru_connect2 = pr_generic_notsupp, 501 .pru_control = l2cap_scontrol, 502 .pru_detach = l2cap_sdetach, 503 .pru_disconnect = l2cap_sdisconnect, 504 .pru_listen = l2cap_slisten, 505 .pru_peeraddr = l2cap_speeraddr, 506 .pru_rcvd = pr_generic_notsupp, 507 .pru_rcvoob = pr_generic_notsupp, 508 .pru_send = l2cap_ssend, 509 .pru_sense = pru_sense_null, 510 .pru_shutdown = l2cap_sshutdown, 511 .pru_sockaddr = l2cap_ssockaddr, 512 .pru_sosend = sosend, 513 .pru_soreceive = soreceive 514 }; 515