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