root/netbt/sco_socket.c

DEFINITIONS

1. sco_usrreq
2. sco_ctloutput
3. sco_connecting
4. sco_connected
5. sco_disconnected
6. sco_newconn
7. sco_complete
8. sco_linkmode
9. sco_input

    1 /*      $OpenBSD: sco_socket.c,v 1.1 2007/06/01 02:46:12 uwe Exp $      */
    2 /*      $NetBSD: sco_socket.c,v 1.9 2007/04/21 06:15:23 plunky Exp $    */
    4 /*-
    5  * Copyright (c) 2006 Itronix Inc.
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. The name of Itronix Inc. may not be used to endorse
   17  *    or promote products derived from this software without specific
   18  *    prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
   24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   27  * ON ANY THEORY OF LIABILITY, WHETHER IN
   28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   30  * POSSIBILITY OF SUCH DAMAGE.
   31  */
   33 #include <sys/cdefs.h>
   35 /* load symbolic names */
   36 #ifdef BLUETOOTH_DEBUG
   37 #define PRUREQUESTS
   38 #define PRCOREQUESTS
   39 #endif
   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>
   51 #include <netbt/bluetooth.h>
   52 #include <netbt/hci.h>
   53 #include <netbt/sco.h>
   55 /*******************************************************************************
   56  *
   57  * SCO SOCK_SEQPACKET sockets - low latency audio data
   58  */
   60 static void sco_connecting(void *);
   61 static void sco_connected(void *);
   62 static void sco_disconnected(void *, int);
   63 static void *sco_newconn(void *, struct sockaddr_bt *, struct sockaddr_bt *);
   64 static void sco_complete(void *, int);
   65 static void sco_linkmode(void *, int);
   66 static void sco_input(void *, struct mbuf *);
   68 static const struct btproto sco_proto = {
sco_connecting,
sco_connected,
sco_disconnected,
sco_newconn,
sco_complete,
sco_linkmode,
sco_input,
   76 };
   78 int sco_sendspace = 4096;
   79 int sco_recvspace = 4096;
   81 /*
   82  * User Request.
   83  * up is socket
   84  * m is either
   85  *      optional mbuf chain containing message
   86  *      ioctl command (PRU_CONTROL)
   87  * nam is either
   88  *      optional mbuf chain containing an address
   89  *      ioctl data (PRU_CONTROL)
   90  *      optionally, protocol number (PRU_ATTACH)
   91  * ctl is optional mbuf chain containing socket options
   92  * l is pointer to process requesting action (if any)
   93  *
   94  * we are responsible for disposing of m and ctl if
   95  * they are mbuf chains
   96  */
   97 int
sco_usrreq(struct socket *up, int req, struct mbuf *m,
   99     struct mbuf *nam, struct mbuf *ctl)
  100 {
  101         struct sco_pcb *pcb = (struct sco_pcb *)up->so_pcb;
  102         struct sockaddr_bt *sa;
  103         struct mbuf *m0;
  104         int err = 0;
  106 #ifdef notyet                   /* XXX */
DPRINTFN(2, "%s\n", prurequests[req]);
  108 #endif
  110         switch(req) {
  111         case PRU_CONTROL:
  112                 return EOPNOTSUPP;
  114 #ifdef notyet                   /* XXX */
  115         case PRU_PURGEIF:
  116                 return EOPNOTSUPP;
  117 #endif
  119         case PRU_ATTACH:
  120                 if (pcb)
  121                         return EINVAL;
err = soreserve(up, sco_sendspace, sco_recvspace);
  124                 if (err)
  125                         return err;
  127                 return sco_attach((struct sco_pcb **)&up->so_pcb,
  128                                         &sco_proto, up);
  129         }
  131         /* anything after here *requires* a pcb */
  132         if (pcb == NULL) {
err = EINVAL;
  134                 goto release;
  135         }
  137         switch(req) {
  138         case PRU_DISCONNECT:
soisdisconnecting(up);
  140                 return sco_disconnect(pcb, up->so_linger);
  142         case PRU_ABORT:
sco_disconnect(pcb, 0);
soisdisconnected(up);
  145                 /* fall through to */
  146         case PRU_DETACH:
  147                 return sco_detach((struct sco_pcb **)&up->so_pcb);
  149         case PRU_BIND:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
  153                 if (sa->bt_len != sizeof(struct sockaddr_bt))
  154                         return EINVAL;
  156                 if (sa->bt_family != AF_BLUETOOTH)
  157                         return EAFNOSUPPORT;
  159                 return sco_bind(pcb, sa);
  161         case PRU_CONNECT:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
  165                 if (sa->bt_len != sizeof(struct sockaddr_bt))
  166                         return EINVAL;
  168                 if (sa->bt_family != AF_BLUETOOTH)
  169                         return EAFNOSUPPORT;
soisconnecting(up);
  172                 return sco_connect(pcb, sa);
  174         case PRU_PEERADDR:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
  178                 return sco_peeraddr(pcb, sa);
  180         case PRU_SOCKADDR:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
  184                 return sco_sockaddr(pcb, sa);
  186         case PRU_SHUTDOWN:
socantsendmore(up);
  188                 break;
  190         case PRU_SEND:
KASSERT(m != NULL);
  192                 if (m->m_pkthdr.len == 0)
  193                         break;
  195                 if (m->m_pkthdr.len > pcb->sp_mtu) {
err = EMSGSIZE;
  197                         break;
  198                 }
m0 = m_copym(m, 0, M_COPYALL, M_DONTWAIT);
  201                 if (m0 == NULL) {
err = ENOMEM;
  203                         break;
  204                 }
  206                 if (ctl) /* no use for that */
m_freem(ctl);
sbappendrecord(&up->so_snd, m);
  210                 return sco_send(pcb, m0);
  212         case PRU_SENSE:
  213                 return 0;               /* (no sense - Doh!) */
  215         case PRU_RCVD:
  216         case PRU_RCVOOB:
  217                 return EOPNOTSUPP;      /* (no release) */
  219         case PRU_LISTEN:
  220                 return sco_listen(pcb);
  222         case PRU_ACCEPT:
KASSERT(nam != NULL);
sa = mtod(nam, struct sockaddr_bt *);
nam->m_len = sizeof(struct sockaddr_bt);
  226                 return sco_peeraddr(pcb, sa);
  228         case PRU_CONNECT2:
  229         case PRU_SENDOOB:
  230         case PRU_FASTTIMO:
  231         case PRU_SLOWTIMO:
  232         case PRU_PROTORCV:
  233         case PRU_PROTOSEND:
err = EOPNOTSUPP;
  235                 break;
  237         default:
UNKNOWN(req);
err = EOPNOTSUPP;
  240                 break;
  241         }
release:
  244         if (m) m_freem(m);
  245         if (ctl) m_freem(ctl);
  246         return err;
  247 }
  249 /*
  250  * get/set socket options
  251  */
  252 int
sco_ctloutput(int req, struct socket *so, int level,
  254                 int optname, struct mbuf **opt)
  255 {
  256         struct sco_pcb *pcb = (struct sco_pcb *)so->so_pcb;
  257         struct mbuf *m;
  258         int err = 0;
  260 #ifdef notyet                   /* XXX */
DPRINTFN(2, "req %s\n", prcorequests[req]);
  262 #endif
  264         if (pcb == NULL)
  265                 return EINVAL;
  267         if (level != BTPROTO_SCO)
  268                 return ENOPROTOOPT;
  270         switch(req) {
  271         case PRCO_GETOPT:
m = m_get(M_WAIT, MT_SOOPTS);
m->m_len = sco_getopt(pcb, optname, mtod(m, uint8_t *));
  274                 if (m->m_len == 0) {
m_freem(m);
m = NULL;
err = ENOPROTOOPT;
  278                 }
  279                 *opt = m;
  280                 break;
  282         case PRCO_SETOPT:
m = *opt;
KASSERT(m != NULL);
err = sco_setopt(pcb, optname, mtod(m, uint8_t *));
m_freem(m);
  287                 break;
  289         default:
err = ENOPROTOOPT;
  291                 break;
  292         }
  294         return err;
  295 }
  297 /*****************************************************************************
  298  *
  299  *      SCO Protocol socket callbacks
  300  *
  301  */
  302 static void
sco_connecting(void *arg)
  304 {
  305         struct socket *so = arg;
DPRINTF("Connecting\n");
soisconnecting(so);
  309 }
  311 static void
sco_connected(void *arg)
  313 {
  314         struct socket *so = arg;
DPRINTF("Connected\n");
soisconnected(so);
  318 }
  320 static void
sco_disconnected(void *arg, int err)
  322 {
  323         struct socket *so = arg;
DPRINTF("Disconnected (%d)\n", err);
so->so_error = err;
soisdisconnected(so);
  329 }
  331 static void *
sco_newconn(void *arg, struct sockaddr_bt *laddr,
  333     struct sockaddr_bt *raddr)
  334 {
  335         struct socket *so = arg;
DPRINTF("New Connection\n");
so = sonewconn(so, 0);
  339         if (so == NULL)
  340                 return NULL;
soisconnecting(so);
  343         return so->so_pcb;
  344 }
  346 static void
sco_complete(void *arg, int num)
  348 {
  349         struct socket *so = arg;
  351         while (num-- > 0)
sbdroprecord(&so->so_snd);
sowwakeup(so);
  355 }
  357 static void
sco_linkmode(void *arg, int mode)
  359 {
  360 }
  362 static void
sco_input(void *arg, struct mbuf *m)
  364 {
  365         struct socket *so = arg;
  367         /*
  368          * since this data is time sensitive, if the buffer
  369          * is full we just dump data until the latest one
  370          * will fit.
  371          */
  373         while (m->m_pkthdr.len > sbspace(&so->so_rcv))
sbdroprecord(&so->so_rcv);
DPRINTFN(10, "received %d bytes\n", m->m_pkthdr.len);
sbappendrecord(&so->so_rcv, m);
sorwakeup(so);
  380 }