root/netbt/l2cap_socket.c

DEFINITIONS

1. l2cap_usrreq
2. l2cap_ctloutput
3. l2cap_connecting
4. l2cap_connected
5. l2cap_disconnected
6. l2cap_newconn
7. l2cap_complete
8. l2cap_linkmode
9. l2cap_input

    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 $  */
    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  */
   34 #include <sys/cdefs.h>
   36 /* load symbolic names */
   37 #ifdef BLUETOOTH_DEBUG
   38 #define PRUREQUESTS
   39 #define PRCOREQUESTS
   40 #endif
   42 #include <sys/param.h>
   43 #include <sys/domain.h>
   44 #include <sys/kernel.h>
   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>
   52 #include <netbt/bluetooth.h>
   53 #include <netbt/hci.h>          /* XXX for EPASSTHROUGH */
   54 #include <netbt/l2cap.h>
   56 /*
   57  * L2CAP Sockets
   58  *
   59  *      SOCK_SEQPACKET - normal L2CAP connection
   60  *
   61  *      SOCK_DGRAM - connectionless L2CAP - XXX not yet
   62  */
   64 static void l2cap_connecting(void *);
   65 static void l2cap_connected(void *);
   66 static void l2cap_disconnected(void *, int);
   67 static void *l2cap_newconn(void *, struct sockaddr_bt *, struct sockaddr_bt *);
   68 static void l2cap_complete(void *, int);
   69 static void l2cap_linkmode(void *, int);
   70 static void l2cap_input(void *, struct mbuf *);
   72 static const struct btproto l2cap_proto = {
l2cap_connecting,
l2cap_connected,
l2cap_disconnected,
l2cap_newconn,
l2cap_complete,
l2cap_linkmode,
l2cap_input,
   80 };
   82 /* sysctl variables */
   83 int l2cap_sendspace = 4096;
   84 int l2cap_recvspace = 4096;
   86 /*
   87  * User Request.
   88  * up is socket
   89  * m is either
   90  *      optional mbuf chain containing message
   91  *      ioctl command (PRU_CONTROL)
   92  * nam is either
   93  *      optional mbuf chain containing an address
   94  *      ioctl data (PRU_CONTROL)
   95  *      optionally protocol number (PRU_ATTACH)
   96  *      message flags (PRU_RCVD)
   97  * ctl is either
   98  *      optional mbuf chain containing socket options
   99  *      optional interface pointer (PRU_CONTROL, PRU_PURGEIF)
  100  * l is pointer to process requesting action (if any)
  101  *
  102  * we are responsible for disposing of m and ctl if
  103  * they are mbuf chains
  104  */
  105 int
l2cap_usrreq(struct socket *up, int req, struct mbuf *m,
  107     struct mbuf *nam, struct mbuf *ctl)
  108 {
  109         struct l2cap_channel *pcb = up->so_pcb;
  110         struct sockaddr_bt *sa;
  111         struct mbuf *m0;
  112         int err = 0;
  114 #ifdef notyet                   /* XXX */
DPRINTFN(2, "%s\n", prurequests[req]);
  116 #endif
  118         switch (req) {
  119         case PRU_CONTROL:
  120                 return EPASSTHROUGH;
  122 #ifdef notyet                   /* XXX */
  123         case PRU_PURGEIF:
  124                 return EOPNOTSUPP;
  125 #endif
  127         case PRU_ATTACH:
  128                 if (pcb != NULL)
  129                         return EINVAL;
  131                 /*
  132                  * For L2CAP socket PCB we just use an l2cap_channel structure
  133                  * since we have nothing to add..
  134                  */
err = soreserve(up, l2cap_sendspace, l2cap_recvspace);
  136                 if (err)
  137                         return err;
  139                 return l2cap_attach((struct l2cap_channel **)&up->so_pcb,
  140                                         &l2cap_proto, up);
  141         }
  143         if (pcb == NULL) {
err = EINVAL;
  145                 goto release;
  146         }
  148         switch(req) {
  149         case PRU_DISCONNECT:
soisdisconnecting(up);
  151                 return l2cap_disconnect(pcb, up->so_linger);
  153         case PRU_ABORT:
l2cap_disconnect(pcb, 0);
soisdisconnected(up);
  156                 /* fall through to */
  157         case PRU_DETACH:
  158                 return l2cap_detach((struct l2cap_channel **)&up->so_pcb);
  160         case PRU_BIND:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
  164                 if (sa->bt_len != sizeof(struct sockaddr_bt))
  165                         return EINVAL;
  167                 if (sa->bt_family != AF_BLUETOOTH)
  168                         return EAFNOSUPPORT;
  170                 return l2cap_bind(pcb, sa);
  172         case PRU_CONNECT:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
  176                 if (sa->bt_len != sizeof(struct sockaddr_bt))
  177                         return EINVAL;
  179                 if (sa->bt_family != AF_BLUETOOTH)
  180                         return EAFNOSUPPORT;
soisconnecting(up);
  183                 return l2cap_connect(pcb, sa);
  185         case PRU_PEERADDR:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
  189                 return l2cap_peeraddr(pcb, sa);
  191         case PRU_SOCKADDR:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
  195                 return l2cap_sockaddr(pcb, sa);
  197         case PRU_SHUTDOWN:
socantsendmore(up);
  199                 break;
  201         case PRU_SEND:
KASSERT(m != NULL);
  203                 if (m->m_pkthdr.len == 0)
  204                         break;
  206                 if (m->m_pkthdr.len > pcb->lc_omtu) {
err = EMSGSIZE;
  208                         break;
  209                 }
m0 = m_copym(m, 0, M_COPYALL, M_DONTWAIT);
  212                 if (m0 == NULL) {
err = ENOMEM;
  214                         break;
  215                 }
  217                 if (ctl)        /* no use for that */
m_freem(ctl);
sbappendrecord(&up->so_snd, m);
  221                 return l2cap_send(pcb, m0);
  223         case PRU_SENSE:
  224                 return 0;               /* (no release) */
  226         case PRU_RCVD:
  227         case PRU_RCVOOB:
  228                 return EOPNOTSUPP;      /* (no release) */
  230         case PRU_LISTEN:
  231                 return l2cap_listen(pcb);
  233         case PRU_ACCEPT:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
  237                 return l2cap_peeraddr(pcb, sa);
  239         case PRU_CONNECT2:
  240         case PRU_SENDOOB:
  241         case PRU_FASTTIMO:
  242         case PRU_SLOWTIMO:
  243         case PRU_PROTORCV:
  244         case PRU_PROTOSEND:
err = EOPNOTSUPP;
  246                 break;
  248         default:
UNKNOWN(req);
err = EOPNOTSUPP;
  251                 break;
  252         }
release:
  255         if (m) m_freem(m);
  256         if (ctl) m_freem(ctl);
  257         return err;
  258 }
  260 /*
  261  * l2cap_ctloutput(request, socket, level, optname, opt)
  262  *
  263  *      Apply configuration commands to channel. This corresponds to
  264  *      "Reconfigure Channel Request" in the L2CAP specification.
  265  */
  266 int
l2cap_ctloutput(int req, struct socket *so, int level,
  268                 int optname, struct mbuf **opt)
  269 {
  270         struct l2cap_channel *pcb = so->so_pcb;
  271         struct mbuf *m;
  272         int err = 0;
  274 #ifdef notyet                   /* XXX */
DPRINTFN(2, "%s\n", prcorequests[req]);
  276 #endif
  278         if (pcb == NULL)
  279                 return EINVAL;
  281         if (level != BTPROTO_L2CAP)
  282                 return ENOPROTOOPT;
  284         switch(req) {
  285         case PRCO_GETOPT:
m = m_get(M_WAIT, MT_SOOPTS);
m->m_len = l2cap_getopt(pcb, optname, mtod(m, void *));
  288                 if (m->m_len == 0) {
m_freem(m);
m = NULL;
err = ENOPROTOOPT;
  292                 }
  293                 *opt = m;
  294                 break;
  296         case PRCO_SETOPT:
m = *opt;
KASSERT(m != NULL);
err = l2cap_setopt(pcb, optname, mtod(m, void *));
m_freem(m);
  301                 break;
  303         default:
err = ENOPROTOOPT;
  305                 break;
  306         }
  308         return err;
  309 }
  311 /**********************************************************************
  312  *
  313  *      L2CAP Protocol socket callbacks
  314  *
  315  */
  317 static void
l2cap_connecting(void *arg)
  319 {
  320         struct socket *so = arg;
DPRINTF("Connecting\n");
soisconnecting(so);
  324 }
  326 static void
l2cap_connected(void *arg)
  328 {
  329         struct socket *so = arg;
DPRINTF("Connected\n");
soisconnected(so);
  333 }
  335 static void
l2cap_disconnected(void *arg, int err)
  337 {
  338         struct socket *so = arg;
DPRINTF("Disconnected (%d)\n", err);
so->so_error = err;
soisdisconnected(so);
  344 }
  346 static void *
l2cap_newconn(void *arg, struct sockaddr_bt *laddr,
  348     struct sockaddr_bt *raddr)
  349 {
  350         struct socket *so = arg;
DPRINTF("New Connection\n");
so = sonewconn(so, 0);
  354         if (so == NULL)
  355                 return NULL;
soisconnecting(so);
  359         return so->so_pcb;
  360 }
  362 static void
l2cap_complete(void *arg, int count)
  364 {
  365         struct socket *so = arg;
  367         while (count-- > 0)
sbdroprecord(&so->so_snd);
sowwakeup(so);
  371 }
  373 static void
l2cap_linkmode(void *arg, int new)
  375 {
  376         struct socket *so = arg;
  377         int mode;
DPRINTF("auth %s, encrypt %s, secure %s\n",
  380                 (new & L2CAP_LM_AUTH ? "on" : "off"),
  381                 (new & L2CAP_LM_ENCRYPT ? "on" : "off"),
  382                 (new & L2CAP_LM_SECURE ? "on" : "off"));
  384         (void)l2cap_getopt(so->so_pcb, SO_L2CAP_LM, &mode);
  385         if (((mode & L2CAP_LM_AUTH) && !(new & L2CAP_LM_AUTH))
  386             || ((mode & L2CAP_LM_ENCRYPT) && !(new & L2CAP_LM_ENCRYPT))
  387             || ((mode & L2CAP_LM_SECURE) && !(new & L2CAP_LM_SECURE)))
l2cap_disconnect(so->so_pcb, 0);
  389 }
  391 static void
l2cap_input(void *arg, struct mbuf *m)
  393 {
  394         struct socket *so = arg;
  396         if (m->m_pkthdr.len > sbspace(&so->so_rcv)) {
printf("%s: packet (%d bytes) dropped (socket buffer full)\n",
__func__, m->m_pkthdr.len);
m_freem(m);
  400                 return;
  401         }
DPRINTFN(10, "received %d bytes\n", m->m_pkthdr.len);
sbappendrecord(&so->so_rcv, m);
sorwakeup(so);
  407 }