8d9d169e7e5ebaa509d5ab6fefdc58a0bc9a1754
[dragonfly.git] / sys / netbt / l2cap_upper.c
1 /* $DragonFly: src/sys/netbt/l2cap_upper.c,v 1.3 2008/06/20 20:52:29 aggelos Exp $ */
2 /* $OpenBSD: l2cap_upper.c,v 1.2 2007/10/01 16:39:30 krw Exp $ */
3 /* $NetBSD: l2cap_upper.c,v 1.8 2007/04/29 20:23:36 msaitoh Exp $ */
4
5 /*-
6  * Copyright (c) 2005 Iain Hibbert.
7  * Copyright (c) 2006 Itronix Inc.
8  * All rights reserved.
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 #include <sys/cdefs.h>
36
37 #include <sys/param.h>
38 #include <sys/kernel.h>
39 #include <sys/mbuf.h>
40 #include <sys/proc.h>
41 #include <sys/queue.h>
42 #include <sys/socket.h>
43 #include <sys/socketvar.h>
44 #include <sys/systm.h>
45 #include <sys/endian.h>
46
47 #include <netbt/bluetooth.h>
48 #include <netbt/hci.h>
49 #include <netbt/l2cap.h>
50
51 /*******************************************************************************
52  *
53  *      L2CAP Channel - Upper Protocol API
54  */
55
56 /*
57  * l2cap_attach(handle, btproto, upper)
58  *
59  *      attach new l2cap_channel to handle, populate
60  *      with reasonable defaults
61  */
62 int
63 l2cap_attach(struct l2cap_channel **handle,
64                 const struct btproto *proto, void *upper)
65 {
66         struct l2cap_channel *chan;
67
68         KKASSERT(handle != NULL);
69         KKASSERT(proto != NULL);
70         KKASSERT(upper != NULL);
71
72         chan = kmalloc(sizeof(*chan), M_BLUETOOTH, M_NOWAIT | M_ZERO);
73         if (chan == NULL)
74                 return ENOMEM;
75
76         chan->lc_proto = proto;
77         chan->lc_upper = upper;
78
79         chan->lc_state = L2CAP_CLOSED;
80
81         chan->lc_lcid = L2CAP_NULL_CID;
82         chan->lc_rcid = L2CAP_NULL_CID;
83
84         chan->lc_laddr.bt_len = sizeof(struct sockaddr_bt);
85         chan->lc_laddr.bt_family = AF_BLUETOOTH;
86         chan->lc_laddr.bt_psm = L2CAP_PSM_ANY;
87
88         chan->lc_raddr.bt_len = sizeof(struct sockaddr_bt);
89         chan->lc_raddr.bt_family = AF_BLUETOOTH;
90         chan->lc_raddr.bt_psm = L2CAP_PSM_ANY;
91
92         chan->lc_imtu = L2CAP_MTU_DEFAULT;
93         chan->lc_omtu = L2CAP_MTU_DEFAULT;
94         chan->lc_flush = L2CAP_FLUSH_TIMO_DEFAULT;
95
96         memcpy(&chan->lc_iqos, &l2cap_default_qos, sizeof(l2cap_qos_t));
97         memcpy(&chan->lc_oqos, &l2cap_default_qos, sizeof(l2cap_qos_t));
98
99         *handle = chan;
100         return 0;
101 }
102
103 /*
104  * l2cap_bind(l2cap_channel, sockaddr)
105  *
106  *      set local address of channel
107  */
108 int
109 l2cap_bind(struct l2cap_channel *chan, struct sockaddr_bt *addr)
110 {
111
112         memcpy(&chan->lc_laddr, addr, sizeof(struct sockaddr_bt));
113         return 0;
114 }
115
116 /*
117  * l2cap_sockaddr(l2cap_channel, sockaddr)
118  *
119  *      get local address of channel
120  */
121 int
122 l2cap_sockaddr(struct l2cap_channel *chan, struct sockaddr_bt *addr)
123 {
124         memcpy(addr, &chan->lc_laddr, sizeof(struct sockaddr_bt));
125         return 0;
126 }
127
128 /*
129  * l2cap_connect(l2cap_channel, sockaddr)
130  *
131  *      Initiate a connection to destination. This corresponds to
132  *      "Open Channel Request" in the L2CAP specification and will
133  *      result in one of the following:
134  *
135  *              proto->connected(upper)
136  *              proto->disconnected(upper, error)
137  *
138  *      and, optionally
139  *              proto->connecting(upper)
140  */
141 int
142 l2cap_connect(struct l2cap_channel *chan, struct sockaddr_bt *dest)
143 {
144         struct hci_unit *unit;
145         int err;
146
147         memcpy(&chan->lc_raddr, dest, sizeof(struct sockaddr_bt));
148
149         if (L2CAP_PSM_INVALID(chan->lc_raddr.bt_psm))
150                 return EINVAL;
151
152         if (bdaddr_any(&chan->lc_raddr.bt_bdaddr))
153                 return EDESTADDRREQ;
154
155         /* set local address if it needs setting */
156         if (bdaddr_any(&chan->lc_laddr.bt_bdaddr)) {
157                 err = hci_route_lookup(&chan->lc_laddr.bt_bdaddr,
158                                         &chan->lc_raddr.bt_bdaddr);
159                 if (err)
160                         return err;
161         }
162
163         unit = hci_unit_lookup(&chan->lc_laddr.bt_bdaddr);
164         if (unit == NULL)
165                 return EHOSTUNREACH;
166
167         /* attach to active list */
168         err = l2cap_cid_alloc(chan);
169         if (err)
170                 return err;
171
172         /* open link to remote device */
173         chan->lc_link = hci_acl_open(unit, &chan->lc_raddr.bt_bdaddr);
174         if (chan->lc_link == NULL)
175                 return EHOSTUNREACH;
176
177         /* set the link mode */
178         err = l2cap_setmode(chan);
179         if (err == EINPROGRESS) {
180                 chan->lc_state = L2CAP_WAIT_SEND_CONNECT_REQ;
181                 (*chan->lc_proto->connecting)(chan->lc_upper);
182                 return 0;
183         }
184         if (err)
185                 goto fail;
186
187         /*
188          * We can queue a connect request now even though the link may
189          * not yet be open; Our mode setting is assured, and the queue
190          * will be started automatically at the right time.
191          */
192         chan->lc_state = L2CAP_WAIT_RECV_CONNECT_RSP;
193         err = l2cap_send_connect_req(chan);
194         if (err)
195                 goto fail;
196
197         return 0;
198
199 fail:
200         chan->lc_state = L2CAP_CLOSED;
201         hci_acl_close(chan->lc_link, err);
202         chan->lc_link = NULL;
203         return err;
204 }
205
206 /*
207  * l2cap_peeraddr(l2cap_channel, sockaddr)
208  *
209  *      get remote address of channel
210  */
211 int
212 l2cap_peeraddr(struct l2cap_channel *chan, struct sockaddr_bt *addr)
213 {
214         memcpy(addr, &chan->lc_raddr, sizeof(struct sockaddr_bt));
215         return 0;
216 }
217
218 /*
219  * l2cap_disconnect(l2cap_channel, linger)
220  *
221  *      Initiate L2CAP disconnection. This corresponds to
222  *      "Close Channel Request" in the L2CAP specification
223  *      and will result in a call to
224  *
225  *              proto->disconnected(upper, error)
226  *
227  *      when the disconnection is complete. If linger is set,
228  *      the call will not be made until data has flushed from
229  *      the queue.
230  */
231 int
232 l2cap_disconnect(struct l2cap_channel *chan, int linger)
233 {
234         int err = 0;
235
236         if (chan->lc_state == L2CAP_CLOSED
237             || chan->lc_state == L2CAP_WAIT_DISCONNECT)
238                 return EINVAL;
239
240         chan->lc_flags |= L2CAP_SHUTDOWN;
241
242         /*
243          * no need to do anything unless the queue is empty or
244          * we are not lingering..
245          */
246         if ((IF_QEMPTY(&chan->lc_txq) && chan->lc_pending == 0)
247             || linger == 0) {
248                 chan->lc_state = L2CAP_WAIT_DISCONNECT;
249                 err = l2cap_send_disconnect_req(chan);
250                 if (err)
251                         l2cap_close(chan, err);
252         }
253         return err;
254 }
255
256 /*
257  * l2cap_detach(handle)
258  *
259  *      Detach l2cap channel from handle & close it down
260  */
261 int
262 l2cap_detach(struct l2cap_channel **handle)
263 {
264         struct l2cap_channel *chan;
265
266         chan = *handle;
267         *handle = NULL;
268
269         if (chan->lc_state != L2CAP_CLOSED)
270                 l2cap_close(chan, 0);
271
272         if (chan->lc_lcid != L2CAP_NULL_CID) {
273                 LIST_REMOVE(chan, lc_ncid);
274                 chan->lc_lcid = L2CAP_NULL_CID;
275         }
276
277         IF_DRAIN(&chan->lc_txq);
278
279         /*
280          * Could implement some kind of delayed expunge to make sure that the
281          * CID is really dead before it becomes available for reuse?
282          */
283
284         kfree(chan, M_BLUETOOTH);
285         return 0;
286 }
287
288 /*
289  * l2cap_listen(l2cap_channel)
290  *
291  *      Use this channel as a listening post (until detached). This will
292  *      result in calls to:
293  *
294  *              proto->newconn(upper, laddr, raddr)
295  *
296  *      for incoming connections matching the psm and local address of the
297  *      channel (NULL psm/address are permitted and match any protocol/device).
298  *
299  *      The upper layer should create and return a new channel.
300  *
301  *      You cannot use this channel for anything else subsequent to this call
302  */
303 int
304 l2cap_listen(struct l2cap_channel *chan)
305 {
306         struct l2cap_channel *used, *prev = NULL;
307
308         if (chan->lc_lcid != L2CAP_NULL_CID)
309                 return EINVAL;
310
311         if (chan->lc_laddr.bt_psm != L2CAP_PSM_ANY
312             && L2CAP_PSM_INVALID(chan->lc_laddr.bt_psm))
313                 return EADDRNOTAVAIL;
314
315         /*
316          * This CID is irrelevant, as the channel is not stored on the active
317          * list and the socket code does not allow operations on listening
318          * sockets, but we set it so the detach code knows to LIST_REMOVE the
319          * channel.
320          */
321         chan->lc_lcid = L2CAP_SIGNAL_CID;
322
323         /*
324          * The list of listening channels is stored in an order such that new
325          * listeners dont usurp current listeners, but that specific listening
326          * takes precedence over promiscuous, and the connect request code can
327          * easily use the first matching entry.
328          */
329         LIST_FOREACH(used, &l2cap_listen_list, lc_ncid) {
330                 if (used->lc_laddr.bt_psm < chan->lc_laddr.bt_psm)
331                         break;
332
333                 if (used->lc_laddr.bt_psm == chan->lc_laddr.bt_psm
334                         && bdaddr_any(&used->lc_laddr.bt_bdaddr)
335                         && !bdaddr_any(&chan->lc_laddr.bt_bdaddr))
336                         break;
337
338                 prev = used;
339         }
340
341         if (prev == NULL)
342                 LIST_INSERT_HEAD(&l2cap_listen_list, chan, lc_ncid);
343         else
344                 LIST_INSERT_AFTER(prev, chan, lc_ncid);
345
346         return 0;
347 }
348
349 /*
350  * l2cap_send(l2cap_channel, mbuf)
351  *
352  *      Output SDU on channel described by channel. This corresponds
353  *      to "Send Data Request" in the L2CAP specification. The upper
354  *      layer will be notified when SDU's have completed sending by a
355  *      call to:
356  *
357  *              proto->complete(upper, n)
358  *
359  *      (currently n == 1)
360  *
361  *      Note: I'm not sure how this will work out, but I think that
362  *      if outgoing Retransmission Mode or Flow Control Mode is
363  *      negotiated then this call will not be made until the SDU has
364  *      been acknowleged by the peer L2CAP entity. For 'Best Effort'
365  *      it will be made when the packet has cleared the controller
366  *      buffers.
367  *
368  *      We only support Basic mode so far, so encapsulate with a
369  *      B-Frame header and start sending if we are not already
370  */
371 int
372 l2cap_send(struct l2cap_channel *chan, struct mbuf *m)
373 {
374         l2cap_hdr_t *hdr;
375         int plen;
376
377         if (chan->lc_state == L2CAP_CLOSED) {
378                 m_freem(m);
379                 return ENOTCONN;
380         }
381
382         plen = m->m_pkthdr.len;
383
384         DPRINTFN(5, "send %d bytes on CID #%d (pending = %d)\n",
385                 plen, chan->lc_lcid, chan->lc_pending);
386
387         /* Encapsulate with B-Frame */
388         M_PREPEND(m, sizeof(l2cap_hdr_t), MB_DONTWAIT);
389         if (m == NULL)
390                 return ENOMEM;
391
392         hdr = mtod(m, l2cap_hdr_t *);
393         hdr->length = htole16(plen);
394         hdr->dcid = htole16(chan->lc_rcid);
395
396         /* Queue it on our list */
397         IF_ENQUEUE(&chan->lc_txq, m);
398
399         /* If we are not sending, then start doing so */
400         if (chan->lc_pending == 0)
401                 return l2cap_start(chan);
402
403         return 0;
404 }
405
406 /*
407  * l2cap_setopt(l2cap_channel, opt, addr)
408  *
409  *      Apply configuration options to channel. This corresponds to
410  *      "Configure Channel Request" in the L2CAP specification.
411  *
412  *      for SO_L2CAP_LM, the settings will take effect when the
413  *      channel is established. If the channel is already open,
414  *      a call to
415  *              proto->linkmode(upper, new)
416  *
417  *      will be made when the change is complete.
418  */
419 int
420 l2cap_setopt(struct l2cap_channel *chan, int opt, void *addr)
421 {
422         int mode, err = 0;
423         uint16_t mtu;
424
425         switch (opt) {
426         case SO_L2CAP_IMTU:     /* set Incoming MTU */
427                 mtu = *(uint16_t *)addr;
428                 if (mtu < L2CAP_MTU_MINIMUM)
429                         err = EINVAL;
430                 else if (chan->lc_state == L2CAP_CLOSED)
431                         chan->lc_imtu = mtu;
432                 else
433                         err = EBUSY;
434
435                 break;
436
437         case SO_L2CAP_LM:       /* set link mode */
438                 mode = *(int *)addr;
439                 mode &= (L2CAP_LM_SECURE | L2CAP_LM_ENCRYPT | L2CAP_LM_AUTH);
440
441                 if (mode & L2CAP_LM_SECURE)
442                         mode |= L2CAP_LM_ENCRYPT;
443
444                 if (mode & L2CAP_LM_ENCRYPT)
445                         mode |= L2CAP_LM_AUTH;
446
447                 chan->lc_mode = mode;
448
449                 if (chan->lc_state == L2CAP_OPEN)
450                         err = l2cap_setmode(chan);
451
452                 break;
453
454         case SO_L2CAP_OQOS:     /* set Outgoing QoS flow spec */
455         case SO_L2CAP_FLUSH:    /* set Outgoing Flush Timeout */
456         default:
457                 err = ENOPROTOOPT;
458                 break;
459         }
460
461         return err;
462 }
463
464
465 /*
466  * Used in l2cap_socket for set options, coming from socket.
467  */
468 int
469 l2cap_setopt2(struct l2cap_channel *chan, int opt, struct socket *so,
470     struct sockopt *sopt)
471 {
472         int mode, err = 0;
473         uint16_t mtu;
474
475         switch (opt) {
476         case SO_L2CAP_IMTU:     /* set Incoming MTU */
477                 err = soopt_to_kbuf(sopt, &mtu, sizeof(uint16_t),
478                     sizeof(uint16_t)); 
479                 if (err)
480                         break;
481
482                 if (mtu < L2CAP_MTU_MINIMUM)
483                         err = EINVAL;
484                 else if (chan->lc_state == L2CAP_CLOSED)
485                         chan->lc_imtu = mtu;
486                 else
487                         err = EBUSY;
488
489                 break;
490
491         case SO_L2CAP_LM:       /* set link mode */
492                 err = soopt_to_kbuf(sopt, &mode, sizeof(int), sizeof(int)); 
493                 if (err)
494                         break;
495
496                 mode &= (L2CAP_LM_SECURE | L2CAP_LM_ENCRYPT | L2CAP_LM_AUTH);
497
498                 if (mode & L2CAP_LM_SECURE)
499                         mode |= L2CAP_LM_ENCRYPT;
500                 if (mode & L2CAP_LM_ENCRYPT)
501                         mode |= L2CAP_LM_AUTH;
502                 chan->lc_mode = mode;
503
504                 if (chan->lc_state == L2CAP_OPEN)
505                         err = l2cap_setmode(chan);
506
507                 break;
508
509         case SO_L2CAP_OQOS:     /* set Outgoing QoS flow spec */
510         case SO_L2CAP_FLUSH:    /* set Outgoing Flush Timeout */
511         default:
512                 err = ENOPROTOOPT;
513                 break;
514         }
515         return err;
516 }
517
518 /*
519  * l2cap_getopt(l2cap_channel, opt, addr)
520  *
521  *      Return configuration parameters.
522  */
523 int
524 l2cap_getopt(struct l2cap_channel *chan, int opt, void *addr)
525 {
526
527         switch (opt) {
528         case SO_L2CAP_IMTU:     /* get Incoming MTU */
529                 *(uint16_t *)addr = chan->lc_imtu;
530                 return sizeof(uint16_t);
531
532         case SO_L2CAP_OMTU:     /* get Outgoing MTU */
533                 *(uint16_t *)addr = chan->lc_omtu;
534                 return sizeof(uint16_t);
535
536         case SO_L2CAP_IQOS:     /* get Incoming QoS flow spec */
537                 memcpy(addr, &chan->lc_iqos, sizeof(l2cap_qos_t));
538                 return sizeof(l2cap_qos_t);
539
540         case SO_L2CAP_OQOS:     /* get Outgoing QoS flow spec */
541                 memcpy(addr, &chan->lc_oqos, sizeof(l2cap_qos_t));
542                 return sizeof(l2cap_qos_t);
543
544         case SO_L2CAP_FLUSH:    /* get Flush Timeout */
545                 *(uint16_t *)addr = chan->lc_flush;
546                 return sizeof(uint16_t);
547
548         case SO_L2CAP_LM:       /* get link mode */
549                 *(int *)addr = chan->lc_mode;
550                 return sizeof(int);
551
552         default:
553                 break;
554         }
555
556         return 0;
557 }