sys/netbt/rfcomm_socket.c

   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/malloc.h> /* for M_NOWAIT */
  45 #include <sys/mbuf.h>
  46 #include <sys/proc.h>
  47 #include <sys/protosw.h>
  48 #include <sys/socket.h>
  49 #include <sys/socketvar.h>
  50 #include <sys/systm.h>
  51
  52 #include <sys/msgport2.h>
  53
  54 #include <vm/vm_zone.h>
  55
  56 #include <netbt/bluetooth.h>
  57 #include <netbt/hci.h>          /* XXX for EPASSTHROUGH */
  58 #include <netbt/rfcomm.h>
  59
  60 /****************************************************************************
  61  *
  62  *      RFCOMM SOCK_STREAM Sockets - serial line emulation
  63  *
  64  */
  65
  66 static void rfcomm_connecting(void *);
  67 static void rfcomm_connected(void *);
  68 static void rfcomm_disconnected(void *, int);
  69 static void *rfcomm_newconn(void *, struct sockaddr_bt *, struct sockaddr_bt *);
  70 static void rfcomm_complete(void *, int);
  71 static void rfcomm_linkmode(void *, int);
  72 static void rfcomm_input(void *, struct mbuf *);
  73
  74 static const struct btproto rfcomm_proto = {
  75         rfcomm_connecting,
  76         rfcomm_connected,
  77         rfcomm_disconnected,
  78         rfcomm_newconn,
  79         rfcomm_complete,
  80         rfcomm_linkmode,
  81         rfcomm_input,
  82 };
  83
  84 /* sysctl variables */
  85 int rfcomm_sendspace = 4096;
  86 int rfcomm_recvspace = 4096;
  87
  88 /*
  89  * rfcomm_ctloutput(request, socket, level, optname, opt)
  90  *
  91  */
  92 void
  93 rfcomm_ctloutput(netmsg_t msg)
  94 {
  95         struct socket *so = msg->ctloutput.base.nm_so;
  96         struct sockopt *sopt = msg->ctloutput.nm_sopt;
  97         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
  98         struct mbuf *m;
  99         int error = 0;
 100
 101 #ifdef notyet                   /* XXX */
 102         DPRINTFN(2, "%s\n", prcorequests[sopt->sopt_dir]);
 103 #endif
 104
 105         if (pcb == NULL) {
 106                 error = EINVAL;
 107                 goto out;
 108         }
 109
 110         if (sopt->sopt_level != BTPROTO_RFCOMM) {
 111                 error = ENOPROTOOPT;
 112                 goto out;
 113         }
 114
 115         switch(sopt->sopt_dir) {
 116         case PRCO_GETOPT:
 117                 m = m_get(M_WAITOK, MT_DATA);
 118                 crit_enter();
 119                 m->m_len = rfcomm_getopt(pcb, sopt->sopt_name, mtod(m, void *));
 120                 crit_exit();
 121                 if (m->m_len == 0) {
 122                         m_freem(m);
 123                         m = NULL;
 124                         error = ENOPROTOOPT;
 125                 }
 126                 soopt_from_kbuf(sopt, mtod(m, void *), m->m_len);
 127                 break;
 128
 129         case PRCO_SETOPT:
 130                 error = rfcomm_setopt2(pcb, sopt->sopt_name, so, sopt);
 131
 132                 break;
 133
 134         default:
 135                 error = ENOPROTOOPT;
 136                 break;
 137         }
 138 out:
 139         lwkt_replymsg(&msg->ctloutput.base.lmsg, error);
 140 }
 141
 142 /**********************************************************************
 143  *
 144  * RFCOMM callbacks
 145  */
 146
 147 static void
 148 rfcomm_connecting(void *arg)
 149 {
 150         /* struct socket *so = arg; */
 151
 152         KKASSERT(arg != NULL);
 153         DPRINTF("Connecting\n");
 154 }
 155
 156 static void
 157 rfcomm_connected(void *arg)
 158 {
 159         struct socket *so = arg;
 160
 161         KKASSERT(so != NULL);
 162         DPRINTF("Connected\n");
 163         soisconnected(so);
 164 }
 165
 166 static void
 167 rfcomm_disconnected(void *arg, int err)
 168 {
 169         struct socket *so = arg;
 170
 171         KKASSERT(so != NULL);
 172         DPRINTF("Disconnected\n");
 173
 174         so->so_error = err;
 175         soisdisconnected(so);
 176 }
 177
 178 static void *
 179 rfcomm_newconn(void *arg, struct sockaddr_bt *laddr,
 180     struct sockaddr_bt *raddr)
 181 {
 182         struct socket *so = arg;
 183
 184         DPRINTF("New Connection\n");
 185         so = sonewconn(so, 0);
 186         if (so == NULL)
 187                 return NULL;
 188
 189         soisconnecting(so);
 190
 191         return so->so_pcb;
 192 }
 193
 194 /*
 195  * rfcomm_complete(rfcomm_dlc, length)
 196  *
 197  * length bytes are sent and may be removed from socket buffer
 198  */
 199 static void
 200 rfcomm_complete(void *arg, int length)
 201 {
 202         struct socket *so = arg;
 203
 204         sbdrop(&so->so_snd.sb, length);
 205         sowwakeup(so);
 206 }
 207
 208 /*
 209  * rfcomm_linkmode(rfcomm_dlc, new)
 210  *
 211  * link mode change notification.
 212  */
 213 static void
 214 rfcomm_linkmode(void *arg, int new)
 215 {
 216         struct socket *so = arg;
 217         int mode;
 218
 219         DPRINTF("auth %s, encrypt %s, secure %s\n",
 220                 (new & RFCOMM_LM_AUTH ? "on" : "off"),
 221                 (new & RFCOMM_LM_ENCRYPT ? "on" : "off"),
 222                 (new & RFCOMM_LM_SECURE ? "on" : "off"));
 223
 224         (void)rfcomm_getopt(so->so_pcb, SO_RFCOMM_LM, &mode);
 225         if (((mode & RFCOMM_LM_AUTH) && !(new & RFCOMM_LM_AUTH))
 226             || ((mode & RFCOMM_LM_ENCRYPT) && !(new & RFCOMM_LM_ENCRYPT))
 227             || ((mode & RFCOMM_LM_SECURE) && !(new & RFCOMM_LM_SECURE)))
 228                 rfcomm_disconnect(so->so_pcb, 0);
 229 }
 230
 231 /*
 232  * rfcomm_input(rfcomm_dlc, mbuf)
 233  */
 234 static void
 235 rfcomm_input(void *arg, struct mbuf *m)
 236 {
 237         struct socket *so = arg;
 238
 239         KKASSERT(so != NULL);
 240
 241         if (m->m_pkthdr.len > sbspace(&so->so_rcv)) {
 242                 kprintf("%s: %d bytes dropped (socket buffer full)\n",
 243                         __func__, m->m_pkthdr.len);
 244                 m_freem(m);
 245                 return;
 246         }
 247
 248         DPRINTFN(10, "received %d bytes\n", m->m_pkthdr.len);
 249
 250         sbappendstream(&so->so_rcv.sb, m);
 251         sorwakeup(so);
 252 }
 253
 254 /*
 255  * Implementation of usrreqs.
 256  */
 257 static void
 258 rfcomm_sdetach(netmsg_t msg)
 259 {
 260         struct socket *so = msg->detach.base.nm_so;
 261         int error;
 262
 263         error = rfcomm_detach((struct rfcomm_dlc **)&so->so_pcb);
 264         lwkt_replymsg(&msg->detach.base.lmsg, error);
 265 }
 266
 267 /*
 268  * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort()
 269  *       will sofree() it when we return.
 270  */
 271 static void
 272 rfcomm_sabort(netmsg_t msg)
 273 {
 274         struct socket *so = msg->abort.base.nm_so;
 275         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 276
 277         rfcomm_disconnect(pcb, 0);
 278         soisdisconnected(so);
 279         rfcomm_sdetach(msg);
 280         /* msg invalid now */
 281 }
 282
 283 static void
 284 rfcomm_sdisconnect(netmsg_t msg)
 285 {
 286         struct socket *so = msg->abort.base.nm_so;
 287         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 288         int error;
 289
 290         soisdisconnecting(so);
 291         error = rfcomm_disconnect(pcb, so->so_linger);
 292         lwkt_replymsg(&msg->disconnect.base.lmsg, error);
 293 }
 294
 295 static void
 296 rfcomm_scontrol(netmsg_t msg)
 297 {
 298         lwkt_replymsg(&msg->control.base.lmsg, EPASSTHROUGH);
 299 }
 300
 301 static void
 302 rfcomm_sattach(netmsg_t msg)
 303 {
 304         struct socket *so = msg->attach.base.nm_so;
 305         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 306         int error;
 307
 308         if (pcb != NULL) {
 309                 error = EINVAL;
 310                 goto out;
 311         }
 312
 313         /*
 314          * Since we have nothing to add, we attach the DLC
 315          * structure directly to our PCB pointer.
 316          */
 317         error = soreserve(so, rfcomm_sendspace, rfcomm_recvspace, NULL);
 318         if (error)
 319                 goto out;
 320
 321         error = rfcomm_attach((struct rfcomm_dlc **)&so->so_pcb,
 322                               &rfcomm_proto, so);
 323         if (error)
 324                 goto out;
 325
 326         error = rfcomm_rcvd(so->so_pcb, sbspace(&so->so_rcv));
 327         if (error)
 328                 rfcomm_detach((struct rfcomm_dlc **)&so->so_pcb);
 329 out:
 330         lwkt_replymsg(&msg->attach.base.lmsg, error);
 331 }
 332
 333 static void
 334 rfcomm_sbind(netmsg_t msg)
 335 {
 336         struct socket *so = msg->bind.base.nm_so;
 337         struct sockaddr *nam = msg->bind.nm_nam;
 338         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 339         struct sockaddr_bt *sa;
 340         int error;
 341
 342         KKASSERT(nam != NULL);
 343         sa = (struct sockaddr_bt *)nam;
 344
 345         if (sa->bt_len != sizeof(struct sockaddr_bt)) {
 346                 error = EINVAL;
 347         } else if (sa->bt_family != AF_BLUETOOTH) {
 348                 error = EAFNOSUPPORT;
 349         } else {
 350                 error = rfcomm_bind(pcb, sa);
 351         }
 352         lwkt_replymsg(&msg->bind.base.lmsg, error);
 353 }
 354
 355 static void
 356 rfcomm_sconnect(netmsg_t msg)
 357 {
 358         struct socket *so = msg->connect.base.nm_so;
 359         struct sockaddr *nam = msg->connect.nm_nam;
 360         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 361         struct sockaddr_bt *sa;
 362         int error;
 363
 364         KKASSERT(nam != NULL);
 365         sa = (struct sockaddr_bt *)nam;
 366
 367         if (sa->bt_len != sizeof(struct sockaddr_bt)) {
 368                 error = EINVAL;
 369         } else if (sa->bt_family != AF_BLUETOOTH) {
 370                 error = EAFNOSUPPORT;
 371         } else {
 372                 soisconnecting(so);
 373                 error = rfcomm_connect(pcb, sa);
 374         }
 375         lwkt_replymsg(&msg->connect.base.lmsg, error);
 376 }
 377
 378 static void
 379 rfcomm_speeraddr(netmsg_t msg)
 380 {
 381         struct socket *so = msg->peeraddr.base.nm_so;
 382         struct sockaddr **nam = msg->peeraddr.nm_nam;
 383         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 384         struct sockaddr_bt *sa, ssa;
 385         int error;
 386
 387         sa = &ssa;
 388         bzero(sa, sizeof *sa);
 389         sa->bt_len = sizeof(struct sockaddr_bt);
 390         sa->bt_family = AF_BLUETOOTH;
 391         error = rfcomm_peeraddr(pcb, sa);
 392         *nam = dup_sockaddr((struct sockaddr *)sa);
 393
 394         lwkt_replymsg(&msg->peeraddr.base.lmsg, error);
 395 }
 396
 397 static void
 398 rfcomm_ssockaddr(netmsg_t msg)
 399 {
 400         struct socket *so = msg->sockaddr.base.nm_so;
 401         struct sockaddr **nam = msg->sockaddr.nm_nam;
 402         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 403         struct sockaddr_bt *sa, ssa;
 404         int error;
 405
 406         sa = &ssa;
 407         bzero(sa, sizeof *sa);
 408         sa->bt_len = sizeof(struct sockaddr_bt);
 409         sa->bt_family = AF_BLUETOOTH;
 410         error = rfcomm_sockaddr(pcb, sa);
 411         *nam = dup_sockaddr((struct sockaddr *)sa);
 412
 413         lwkt_replymsg(&msg->sockaddr.base.lmsg, error);
 414 }
 415
 416 static void
 417 rfcomm_sshutdown(netmsg_t msg)
 418 {
 419         struct socket *so = msg->shutdown.base.nm_so;
 420
 421         socantsendmore(so);
 422         lwkt_replymsg(&msg->shutdown.base.lmsg, 0);
 423 }
 424
 425 static void
 426 rfcomm_ssend(netmsg_t msg)
 427 {
 428         struct socket *so = msg->send.base.nm_so;
 429         struct mbuf *m = msg->send.nm_m;
 430         struct mbuf *control = msg->send.nm_control;
 431         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 432         struct mbuf *m0;
 433         int error;
 434
 435         KKASSERT(m != NULL);
 436
 437         /* no use for that */
 438         if (control) {
 439                 m_freem(control);
 440                 control = NULL;
 441         }
 442
 443         m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
 444         if (m0) {
 445                 sbappendstream(&so->so_snd.sb, m);
 446                 error = rfcomm_send(pcb, m0);
 447         } else {
 448                 error = ENOMEM;
 449         }
 450         lwkt_replymsg(&msg->send.base.lmsg, error);
 451 }
 452
 453 static void
 454 rfcomm_saccept(netmsg_t msg)
 455 {
 456         struct socket *so = msg->accept.base.nm_so;
 457         struct sockaddr **nam = msg->accept.nm_nam;
 458         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 459         struct sockaddr_bt *sa, ssa;
 460         int error;
 461
 462         sa = &ssa;
 463         bzero(sa, sizeof *sa);
 464         sa->bt_len = sizeof(struct sockaddr_bt);
 465         sa->bt_family = AF_BLUETOOTH;
 466         error = rfcomm_peeraddr(pcb, sa);
 467         *nam = dup_sockaddr((struct sockaddr *)sa);
 468
 469         lwkt_replymsg(&msg->accept.base.lmsg, error);
 470 }
 471
 472 static void
 473 rfcomm_slisten(netmsg_t msg)
 474 {
 475         struct socket *so = msg->listen.base.nm_so;
 476         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *)so->so_pcb;
 477         int error;
 478
 479         error = rfcomm_listen(pcb);
 480         lwkt_replymsg(&msg->listen.base.lmsg, error);
 481 }
 482
 483 static void
 484 rfcomm_srcvd(netmsg_t msg)
 485 {
 486         struct socket *so = msg->rcvd.base.nm_so;
 487         struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
 488         int error;
 489
 490         error = rfcomm_rcvd(pcb, sbspace(&so->so_rcv));
 491         lwkt_replymsg(&msg->rcvd.base.lmsg, error);
 492 }
 493
 494 struct pr_usrreqs rfcomm_usrreqs = {
 495         .pru_abort = rfcomm_sabort,
 496         .pru_accept = rfcomm_saccept,
 497         .pru_attach = rfcomm_sattach,
 498         .pru_bind = rfcomm_sbind,
 499         .pru_connect = rfcomm_sconnect,
 500         .pru_connect2 = pr_generic_notsupp,
 501         .pru_control = rfcomm_scontrol,
 502         .pru_detach = rfcomm_sdetach,
 503         .pru_disconnect = rfcomm_sdisconnect,
 504         .pru_listen = rfcomm_slisten,
 505         .pru_peeraddr = rfcomm_speeraddr,
 506         .pru_rcvd = rfcomm_srcvd,
 507         .pru_rcvoob = pr_generic_notsupp,
 508         .pru_send = rfcomm_ssend,
 509         .pru_sense = pru_sense_null,
 510         .pru_shutdown = rfcomm_sshutdown,
 511         .pru_sockaddr = rfcomm_ssockaddr,
 512         .pru_sosend = sosend,
 513         .pru_soreceive = soreceive
 514 };