Loading...
1/*
2 RFCOMM implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
4 Copyright (C) 2002 Marcel Holtmann <marcel@holtmann.org>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License version 2 as
8 published by the Free Software Foundation;
9
10 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
11 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
13 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
14 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
15 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18
19 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
21 SOFTWARE IS DISCLAIMED.
22*/
23
24/*
25 * Bluetooth RFCOMM core.
26 */
27
28#include <linux/module.h>
29#include <linux/debugfs.h>
30#include <linux/kthread.h>
31#include <asm/unaligned.h>
32
33#include <net/bluetooth/bluetooth.h>
34#include <net/bluetooth/hci_core.h>
35#include <net/bluetooth/l2cap.h>
36#include <net/bluetooth/rfcomm.h>
37
38#include <trace/events/sock.h>
39
40#define VERSION "1.11"
41
42static bool disable_cfc;
43static bool l2cap_ertm;
44static int channel_mtu = -1;
45
46static struct task_struct *rfcomm_thread;
47
48static DEFINE_MUTEX(rfcomm_mutex);
49#define rfcomm_lock() mutex_lock(&rfcomm_mutex)
50#define rfcomm_unlock() mutex_unlock(&rfcomm_mutex)
51
52
53static LIST_HEAD(session_list);
54
55static int rfcomm_send_frame(struct rfcomm_session *s, u8 *data, int len);
56static int rfcomm_send_sabm(struct rfcomm_session *s, u8 dlci);
57static int rfcomm_send_disc(struct rfcomm_session *s, u8 dlci);
58static int rfcomm_queue_disc(struct rfcomm_dlc *d);
59static int rfcomm_send_nsc(struct rfcomm_session *s, int cr, u8 type);
60static int rfcomm_send_pn(struct rfcomm_session *s, int cr, struct rfcomm_dlc *d);
61static int rfcomm_send_msc(struct rfcomm_session *s, int cr, u8 dlci, u8 v24_sig);
62static int rfcomm_send_test(struct rfcomm_session *s, int cr, u8 *pattern, int len);
63static int rfcomm_send_credits(struct rfcomm_session *s, u8 addr, u8 credits);
64static void rfcomm_make_uih(struct sk_buff *skb, u8 addr);
65
66static void rfcomm_process_connect(struct rfcomm_session *s);
67
68static struct rfcomm_session *rfcomm_session_create(bdaddr_t *src,
69 bdaddr_t *dst,
70 u8 sec_level,
71 int *err);
72static struct rfcomm_session *rfcomm_session_get(bdaddr_t *src, bdaddr_t *dst);
73static struct rfcomm_session *rfcomm_session_del(struct rfcomm_session *s);
74
75/* ---- RFCOMM frame parsing macros ---- */
76#define __get_dlci(b) ((b & 0xfc) >> 2)
77#define __get_type(b) ((b & 0xef))
78
79#define __test_ea(b) ((b & 0x01))
80#define __test_cr(b) (!!(b & 0x02))
81#define __test_pf(b) (!!(b & 0x10))
82
83#define __session_dir(s) ((s)->initiator ? 0x00 : 0x01)
84
85#define __addr(cr, dlci) (((dlci & 0x3f) << 2) | (cr << 1) | 0x01)
86#define __ctrl(type, pf) (((type & 0xef) | (pf << 4)))
87#define __dlci(dir, chn) (((chn & 0x1f) << 1) | dir)
88#define __srv_channel(dlci) (dlci >> 1)
89
90#define __len8(len) (((len) << 1) | 1)
91#define __len16(len) ((len) << 1)
92
93/* MCC macros */
94#define __mcc_type(cr, type) (((type << 2) | (cr << 1) | 0x01))
95#define __get_mcc_type(b) ((b & 0xfc) >> 2)
96#define __get_mcc_len(b) ((b & 0xfe) >> 1)
97
98/* RPN macros */
99#define __rpn_line_settings(data, stop, parity) ((data & 0x3) | ((stop & 0x1) << 2) | ((parity & 0x7) << 3))
100#define __get_rpn_data_bits(line) ((line) & 0x3)
101#define __get_rpn_stop_bits(line) (((line) >> 2) & 0x1)
102#define __get_rpn_parity(line) (((line) >> 3) & 0x7)
103
104static DECLARE_WAIT_QUEUE_HEAD(rfcomm_wq);
105
106static void rfcomm_schedule(void)
107{
108 wake_up_all(&rfcomm_wq);
109}
110
111/* ---- RFCOMM FCS computation ---- */
112
113/* reversed, 8-bit, poly=0x07 */
114static unsigned char rfcomm_crc_table[256] = {
115 0x00, 0x91, 0xe3, 0x72, 0x07, 0x96, 0xe4, 0x75,
116 0x0e, 0x9f, 0xed, 0x7c, 0x09, 0x98, 0xea, 0x7b,
117 0x1c, 0x8d, 0xff, 0x6e, 0x1b, 0x8a, 0xf8, 0x69,
118 0x12, 0x83, 0xf1, 0x60, 0x15, 0x84, 0xf6, 0x67,
119
120 0x38, 0xa9, 0xdb, 0x4a, 0x3f, 0xae, 0xdc, 0x4d,
121 0x36, 0xa7, 0xd5, 0x44, 0x31, 0xa0, 0xd2, 0x43,
122 0x24, 0xb5, 0xc7, 0x56, 0x23, 0xb2, 0xc0, 0x51,
123 0x2a, 0xbb, 0xc9, 0x58, 0x2d, 0xbc, 0xce, 0x5f,
124
125 0x70, 0xe1, 0x93, 0x02, 0x77, 0xe6, 0x94, 0x05,
126 0x7e, 0xef, 0x9d, 0x0c, 0x79, 0xe8, 0x9a, 0x0b,
127 0x6c, 0xfd, 0x8f, 0x1e, 0x6b, 0xfa, 0x88, 0x19,
128 0x62, 0xf3, 0x81, 0x10, 0x65, 0xf4, 0x86, 0x17,
129
130 0x48, 0xd9, 0xab, 0x3a, 0x4f, 0xde, 0xac, 0x3d,
131 0x46, 0xd7, 0xa5, 0x34, 0x41, 0xd0, 0xa2, 0x33,
132 0x54, 0xc5, 0xb7, 0x26, 0x53, 0xc2, 0xb0, 0x21,
133 0x5a, 0xcb, 0xb9, 0x28, 0x5d, 0xcc, 0xbe, 0x2f,
134
135 0xe0, 0x71, 0x03, 0x92, 0xe7, 0x76, 0x04, 0x95,
136 0xee, 0x7f, 0x0d, 0x9c, 0xe9, 0x78, 0x0a, 0x9b,
137 0xfc, 0x6d, 0x1f, 0x8e, 0xfb, 0x6a, 0x18, 0x89,
138 0xf2, 0x63, 0x11, 0x80, 0xf5, 0x64, 0x16, 0x87,
139
140 0xd8, 0x49, 0x3b, 0xaa, 0xdf, 0x4e, 0x3c, 0xad,
141 0xd6, 0x47, 0x35, 0xa4, 0xd1, 0x40, 0x32, 0xa3,
142 0xc4, 0x55, 0x27, 0xb6, 0xc3, 0x52, 0x20, 0xb1,
143 0xca, 0x5b, 0x29, 0xb8, 0xcd, 0x5c, 0x2e, 0xbf,
144
145 0x90, 0x01, 0x73, 0xe2, 0x97, 0x06, 0x74, 0xe5,
146 0x9e, 0x0f, 0x7d, 0xec, 0x99, 0x08, 0x7a, 0xeb,
147 0x8c, 0x1d, 0x6f, 0xfe, 0x8b, 0x1a, 0x68, 0xf9,
148 0x82, 0x13, 0x61, 0xf0, 0x85, 0x14, 0x66, 0xf7,
149
150 0xa8, 0x39, 0x4b, 0xda, 0xaf, 0x3e, 0x4c, 0xdd,
151 0xa6, 0x37, 0x45, 0xd4, 0xa1, 0x30, 0x42, 0xd3,
152 0xb4, 0x25, 0x57, 0xc6, 0xb3, 0x22, 0x50, 0xc1,
153 0xba, 0x2b, 0x59, 0xc8, 0xbd, 0x2c, 0x5e, 0xcf
154};
155
156/* CRC on 2 bytes */
157#define __crc(data) (rfcomm_crc_table[rfcomm_crc_table[0xff ^ data[0]] ^ data[1]])
158
159/* FCS on 2 bytes */
160static inline u8 __fcs(u8 *data)
161{
162 return 0xff - __crc(data);
163}
164
165/* FCS on 3 bytes */
166static inline u8 __fcs2(u8 *data)
167{
168 return 0xff - rfcomm_crc_table[__crc(data) ^ data[2]];
169}
170
171/* Check FCS */
172static inline int __check_fcs(u8 *data, int type, u8 fcs)
173{
174 u8 f = __crc(data);
175
176 if (type != RFCOMM_UIH)
177 f = rfcomm_crc_table[f ^ data[2]];
178
179 return rfcomm_crc_table[f ^ fcs] != 0xcf;
180}
181
182/* ---- L2CAP callbacks ---- */
183static void rfcomm_l2state_change(struct sock *sk)
184{
185 BT_DBG("%p state %d", sk, sk->sk_state);
186 rfcomm_schedule();
187}
188
189static void rfcomm_l2data_ready(struct sock *sk)
190{
191 trace_sk_data_ready(sk);
192
193 BT_DBG("%p", sk);
194 rfcomm_schedule();
195}
196
197static int rfcomm_l2sock_create(struct socket **sock)
198{
199 int err;
200
201 BT_DBG("");
202
203 err = sock_create_kern(&init_net, PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP, sock);
204 if (!err) {
205 struct sock *sk = (*sock)->sk;
206 sk->sk_data_ready = rfcomm_l2data_ready;
207 sk->sk_state_change = rfcomm_l2state_change;
208 }
209 return err;
210}
211
212static int rfcomm_check_security(struct rfcomm_dlc *d)
213{
214 struct sock *sk = d->session->sock->sk;
215 struct l2cap_conn *conn = l2cap_pi(sk)->chan->conn;
216
217 __u8 auth_type;
218
219 switch (d->sec_level) {
220 case BT_SECURITY_HIGH:
221 case BT_SECURITY_FIPS:
222 auth_type = HCI_AT_GENERAL_BONDING_MITM;
223 break;
224 case BT_SECURITY_MEDIUM:
225 auth_type = HCI_AT_GENERAL_BONDING;
226 break;
227 default:
228 auth_type = HCI_AT_NO_BONDING;
229 break;
230 }
231
232 return hci_conn_security(conn->hcon, d->sec_level, auth_type,
233 d->out);
234}
235
236static void rfcomm_session_timeout(struct timer_list *t)
237{
238 struct rfcomm_session *s = from_timer(s, t, timer);
239
240 BT_DBG("session %p state %ld", s, s->state);
241
242 set_bit(RFCOMM_TIMED_OUT, &s->flags);
243 rfcomm_schedule();
244}
245
246static void rfcomm_session_set_timer(struct rfcomm_session *s, long timeout)
247{
248 BT_DBG("session %p state %ld timeout %ld", s, s->state, timeout);
249
250 mod_timer(&s->timer, jiffies + timeout);
251}
252
253static void rfcomm_session_clear_timer(struct rfcomm_session *s)
254{
255 BT_DBG("session %p state %ld", s, s->state);
256
257 del_timer_sync(&s->timer);
258}
259
260/* ---- RFCOMM DLCs ---- */
261static void rfcomm_dlc_timeout(struct timer_list *t)
262{
263 struct rfcomm_dlc *d = from_timer(d, t, timer);
264
265 BT_DBG("dlc %p state %ld", d, d->state);
266
267 set_bit(RFCOMM_TIMED_OUT, &d->flags);
268 rfcomm_dlc_put(d);
269 rfcomm_schedule();
270}
271
272static void rfcomm_dlc_set_timer(struct rfcomm_dlc *d, long timeout)
273{
274 BT_DBG("dlc %p state %ld timeout %ld", d, d->state, timeout);
275
276 if (!mod_timer(&d->timer, jiffies + timeout))
277 rfcomm_dlc_hold(d);
278}
279
280static void rfcomm_dlc_clear_timer(struct rfcomm_dlc *d)
281{
282 BT_DBG("dlc %p state %ld", d, d->state);
283
284 if (del_timer(&d->timer))
285 rfcomm_dlc_put(d);
286}
287
288static void rfcomm_dlc_clear_state(struct rfcomm_dlc *d)
289{
290 BT_DBG("%p", d);
291
292 d->state = BT_OPEN;
293 d->flags = 0;
294 d->mscex = 0;
295 d->sec_level = BT_SECURITY_LOW;
296 d->mtu = RFCOMM_DEFAULT_MTU;
297 d->v24_sig = RFCOMM_V24_RTC | RFCOMM_V24_RTR | RFCOMM_V24_DV;
298
299 d->cfc = RFCOMM_CFC_DISABLED;
300 d->rx_credits = RFCOMM_DEFAULT_CREDITS;
301}
302
303struct rfcomm_dlc *rfcomm_dlc_alloc(gfp_t prio)
304{
305 struct rfcomm_dlc *d = kzalloc(sizeof(*d), prio);
306
307 if (!d)
308 return NULL;
309
310 timer_setup(&d->timer, rfcomm_dlc_timeout, 0);
311
312 skb_queue_head_init(&d->tx_queue);
313 mutex_init(&d->lock);
314 refcount_set(&d->refcnt, 1);
315
316 rfcomm_dlc_clear_state(d);
317
318 BT_DBG("%p", d);
319
320 return d;
321}
322
323void rfcomm_dlc_free(struct rfcomm_dlc *d)
324{
325 BT_DBG("%p", d);
326
327 skb_queue_purge(&d->tx_queue);
328 kfree(d);
329}
330
331static void rfcomm_dlc_link(struct rfcomm_session *s, struct rfcomm_dlc *d)
332{
333 BT_DBG("dlc %p session %p", d, s);
334
335 rfcomm_session_clear_timer(s);
336 rfcomm_dlc_hold(d);
337 list_add(&d->list, &s->dlcs);
338 d->session = s;
339}
340
341static void rfcomm_dlc_unlink(struct rfcomm_dlc *d)
342{
343 struct rfcomm_session *s = d->session;
344
345 BT_DBG("dlc %p refcnt %d session %p", d, refcount_read(&d->refcnt), s);
346
347 list_del(&d->list);
348 d->session = NULL;
349 rfcomm_dlc_put(d);
350
351 if (list_empty(&s->dlcs))
352 rfcomm_session_set_timer(s, RFCOMM_IDLE_TIMEOUT);
353}
354
355static struct rfcomm_dlc *rfcomm_dlc_get(struct rfcomm_session *s, u8 dlci)
356{
357 struct rfcomm_dlc *d;
358
359 list_for_each_entry(d, &s->dlcs, list)
360 if (d->dlci == dlci)
361 return d;
362
363 return NULL;
364}
365
366static int rfcomm_check_channel(u8 channel)
367{
368 return channel < 1 || channel > 30;
369}
370
371static int __rfcomm_dlc_open(struct rfcomm_dlc *d, bdaddr_t *src, bdaddr_t *dst, u8 channel)
372{
373 struct rfcomm_session *s;
374 int err = 0;
375 u8 dlci;
376
377 BT_DBG("dlc %p state %ld %pMR -> %pMR channel %d",
378 d, d->state, src, dst, channel);
379
380 if (rfcomm_check_channel(channel))
381 return -EINVAL;
382
383 if (d->state != BT_OPEN && d->state != BT_CLOSED)
384 return 0;
385
386 s = rfcomm_session_get(src, dst);
387 if (!s) {
388 s = rfcomm_session_create(src, dst, d->sec_level, &err);
389 if (!s)
390 return err;
391 }
392
393 dlci = __dlci(__session_dir(s), channel);
394
395 /* Check if DLCI already exists */
396 if (rfcomm_dlc_get(s, dlci))
397 return -EBUSY;
398
399 rfcomm_dlc_clear_state(d);
400
401 d->dlci = dlci;
402 d->addr = __addr(s->initiator, dlci);
403 d->priority = 7;
404
405 d->state = BT_CONFIG;
406 rfcomm_dlc_link(s, d);
407
408 d->out = 1;
409
410 d->mtu = s->mtu;
411 d->cfc = (s->cfc == RFCOMM_CFC_UNKNOWN) ? 0 : s->cfc;
412
413 if (s->state == BT_CONNECTED) {
414 if (rfcomm_check_security(d))
415 rfcomm_send_pn(s, 1, d);
416 else
417 set_bit(RFCOMM_AUTH_PENDING, &d->flags);
418 }
419
420 rfcomm_dlc_set_timer(d, RFCOMM_CONN_TIMEOUT);
421
422 return 0;
423}
424
425int rfcomm_dlc_open(struct rfcomm_dlc *d, bdaddr_t *src, bdaddr_t *dst, u8 channel)
426{
427 int r;
428
429 rfcomm_lock();
430
431 r = __rfcomm_dlc_open(d, src, dst, channel);
432
433 rfcomm_unlock();
434 return r;
435}
436
437static void __rfcomm_dlc_disconn(struct rfcomm_dlc *d)
438{
439 struct rfcomm_session *s = d->session;
440
441 d->state = BT_DISCONN;
442 if (skb_queue_empty(&d->tx_queue)) {
443 rfcomm_send_disc(s, d->dlci);
444 rfcomm_dlc_set_timer(d, RFCOMM_DISC_TIMEOUT);
445 } else {
446 rfcomm_queue_disc(d);
447 rfcomm_dlc_set_timer(d, RFCOMM_DISC_TIMEOUT * 2);
448 }
449}
450
451static int __rfcomm_dlc_close(struct rfcomm_dlc *d, int err)
452{
453 struct rfcomm_session *s = d->session;
454 if (!s)
455 return 0;
456
457 BT_DBG("dlc %p state %ld dlci %d err %d session %p",
458 d, d->state, d->dlci, err, s);
459
460 switch (d->state) {
461 case BT_CONNECT:
462 case BT_CONFIG:
463 case BT_OPEN:
464 case BT_CONNECT2:
465 if (test_and_clear_bit(RFCOMM_DEFER_SETUP, &d->flags)) {
466 set_bit(RFCOMM_AUTH_REJECT, &d->flags);
467 rfcomm_schedule();
468 return 0;
469 }
470 }
471
472 switch (d->state) {
473 case BT_CONNECT:
474 case BT_CONNECTED:
475 __rfcomm_dlc_disconn(d);
476 break;
477
478 case BT_CONFIG:
479 if (s->state != BT_BOUND) {
480 __rfcomm_dlc_disconn(d);
481 break;
482 }
483 /* if closing a dlc in a session that hasn't been started,
484 * just close and unlink the dlc
485 */
486 fallthrough;
487
488 default:
489 rfcomm_dlc_clear_timer(d);
490
491 rfcomm_dlc_lock(d);
492 d->state = BT_CLOSED;
493 d->state_change(d, err);
494 rfcomm_dlc_unlock(d);
495
496 skb_queue_purge(&d->tx_queue);
497 rfcomm_dlc_unlink(d);
498 }
499
500 return 0;
501}
502
503int rfcomm_dlc_close(struct rfcomm_dlc *d, int err)
504{
505 int r = 0;
506 struct rfcomm_dlc *d_list;
507 struct rfcomm_session *s, *s_list;
508
509 BT_DBG("dlc %p state %ld dlci %d err %d", d, d->state, d->dlci, err);
510
511 rfcomm_lock();
512
513 s = d->session;
514 if (!s)
515 goto no_session;
516
517 /* after waiting on the mutex check the session still exists
518 * then check the dlc still exists
519 */
520 list_for_each_entry(s_list, &session_list, list) {
521 if (s_list == s) {
522 list_for_each_entry(d_list, &s->dlcs, list) {
523 if (d_list == d) {
524 r = __rfcomm_dlc_close(d, err);
525 break;
526 }
527 }
528 break;
529 }
530 }
531
532no_session:
533 rfcomm_unlock();
534 return r;
535}
536
537struct rfcomm_dlc *rfcomm_dlc_exists(bdaddr_t *src, bdaddr_t *dst, u8 channel)
538{
539 struct rfcomm_session *s;
540 struct rfcomm_dlc *dlc = NULL;
541 u8 dlci;
542
543 if (rfcomm_check_channel(channel))
544 return ERR_PTR(-EINVAL);
545
546 rfcomm_lock();
547 s = rfcomm_session_get(src, dst);
548 if (s) {
549 dlci = __dlci(__session_dir(s), channel);
550 dlc = rfcomm_dlc_get(s, dlci);
551 }
552 rfcomm_unlock();
553 return dlc;
554}
555
556static int rfcomm_dlc_send_frag(struct rfcomm_dlc *d, struct sk_buff *frag)
557{
558 int len = frag->len;
559
560 BT_DBG("dlc %p mtu %d len %d", d, d->mtu, len);
561
562 if (len > d->mtu)
563 return -EINVAL;
564
565 rfcomm_make_uih(frag, d->addr);
566 __skb_queue_tail(&d->tx_queue, frag);
567
568 return len;
569}
570
571int rfcomm_dlc_send(struct rfcomm_dlc *d, struct sk_buff *skb)
572{
573 unsigned long flags;
574 struct sk_buff *frag, *next;
575 int len;
576
577 if (d->state != BT_CONNECTED)
578 return -ENOTCONN;
579
580 frag = skb_shinfo(skb)->frag_list;
581 skb_shinfo(skb)->frag_list = NULL;
582
583 /* Queue all fragments atomically. */
584 spin_lock_irqsave(&d->tx_queue.lock, flags);
585
586 len = rfcomm_dlc_send_frag(d, skb);
587 if (len < 0 || !frag)
588 goto unlock;
589
590 for (; frag; frag = next) {
591 int ret;
592
593 next = frag->next;
594
595 ret = rfcomm_dlc_send_frag(d, frag);
596 if (ret < 0) {
597 dev_kfree_skb_irq(frag);
598 goto unlock;
599 }
600
601 len += ret;
602 }
603
604unlock:
605 spin_unlock_irqrestore(&d->tx_queue.lock, flags);
606
607 if (len > 0 && !test_bit(RFCOMM_TX_THROTTLED, &d->flags))
608 rfcomm_schedule();
609 return len;
610}
611
612void rfcomm_dlc_send_noerror(struct rfcomm_dlc *d, struct sk_buff *skb)
613{
614 int len = skb->len;
615
616 BT_DBG("dlc %p mtu %d len %d", d, d->mtu, len);
617
618 rfcomm_make_uih(skb, d->addr);
619 skb_queue_tail(&d->tx_queue, skb);
620
621 if (d->state == BT_CONNECTED &&
622 !test_bit(RFCOMM_TX_THROTTLED, &d->flags))
623 rfcomm_schedule();
624}
625
626void __rfcomm_dlc_throttle(struct rfcomm_dlc *d)
627{
628 BT_DBG("dlc %p state %ld", d, d->state);
629
630 if (!d->cfc) {
631 d->v24_sig |= RFCOMM_V24_FC;
632 set_bit(RFCOMM_MSC_PENDING, &d->flags);
633 }
634 rfcomm_schedule();
635}
636
637void __rfcomm_dlc_unthrottle(struct rfcomm_dlc *d)
638{
639 BT_DBG("dlc %p state %ld", d, d->state);
640
641 if (!d->cfc) {
642 d->v24_sig &= ~RFCOMM_V24_FC;
643 set_bit(RFCOMM_MSC_PENDING, &d->flags);
644 }
645 rfcomm_schedule();
646}
647
648/*
649 Set/get modem status functions use _local_ status i.e. what we report
650 to the other side.
651 Remote status is provided by dlc->modem_status() callback.
652 */
653int rfcomm_dlc_set_modem_status(struct rfcomm_dlc *d, u8 v24_sig)
654{
655 BT_DBG("dlc %p state %ld v24_sig 0x%x",
656 d, d->state, v24_sig);
657
658 if (test_bit(RFCOMM_RX_THROTTLED, &d->flags))
659 v24_sig |= RFCOMM_V24_FC;
660 else
661 v24_sig &= ~RFCOMM_V24_FC;
662
663 d->v24_sig = v24_sig;
664
665 if (!test_and_set_bit(RFCOMM_MSC_PENDING, &d->flags))
666 rfcomm_schedule();
667
668 return 0;
669}
670
671int rfcomm_dlc_get_modem_status(struct rfcomm_dlc *d, u8 *v24_sig)
672{
673 BT_DBG("dlc %p state %ld v24_sig 0x%x",
674 d, d->state, d->v24_sig);
675
676 *v24_sig = d->v24_sig;
677 return 0;
678}
679
680/* ---- RFCOMM sessions ---- */
681static struct rfcomm_session *rfcomm_session_add(struct socket *sock, int state)
682{
683 struct rfcomm_session *s = kzalloc(sizeof(*s), GFP_KERNEL);
684
685 if (!s)
686 return NULL;
687
688 BT_DBG("session %p sock %p", s, sock);
689
690 timer_setup(&s->timer, rfcomm_session_timeout, 0);
691
692 INIT_LIST_HEAD(&s->dlcs);
693 s->state = state;
694 s->sock = sock;
695
696 s->mtu = RFCOMM_DEFAULT_MTU;
697 s->cfc = disable_cfc ? RFCOMM_CFC_DISABLED : RFCOMM_CFC_UNKNOWN;
698
699 /* Do not increment module usage count for listening sessions.
700 * Otherwise we won't be able to unload the module. */
701 if (state != BT_LISTEN)
702 if (!try_module_get(THIS_MODULE)) {
703 kfree(s);
704 return NULL;
705 }
706
707 list_add(&s->list, &session_list);
708
709 return s;
710}
711
712static struct rfcomm_session *rfcomm_session_del(struct rfcomm_session *s)
713{
714 int state = s->state;
715
716 BT_DBG("session %p state %ld", s, s->state);
717
718 list_del(&s->list);
719
720 rfcomm_session_clear_timer(s);
721 sock_release(s->sock);
722 kfree(s);
723
724 if (state != BT_LISTEN)
725 module_put(THIS_MODULE);
726
727 return NULL;
728}
729
730static struct rfcomm_session *rfcomm_session_get(bdaddr_t *src, bdaddr_t *dst)
731{
732 struct rfcomm_session *s, *n;
733 struct l2cap_chan *chan;
734 list_for_each_entry_safe(s, n, &session_list, list) {
735 chan = l2cap_pi(s->sock->sk)->chan;
736
737 if ((!bacmp(src, BDADDR_ANY) || !bacmp(&chan->src, src)) &&
738 !bacmp(&chan->dst, dst))
739 return s;
740 }
741 return NULL;
742}
743
744static struct rfcomm_session *rfcomm_session_close(struct rfcomm_session *s,
745 int err)
746{
747 struct rfcomm_dlc *d, *n;
748
749 s->state = BT_CLOSED;
750
751 BT_DBG("session %p state %ld err %d", s, s->state, err);
752
753 /* Close all dlcs */
754 list_for_each_entry_safe(d, n, &s->dlcs, list) {
755 d->state = BT_CLOSED;
756 __rfcomm_dlc_close(d, err);
757 }
758
759 rfcomm_session_clear_timer(s);
760 return rfcomm_session_del(s);
761}
762
763static struct rfcomm_session *rfcomm_session_create(bdaddr_t *src,
764 bdaddr_t *dst,
765 u8 sec_level,
766 int *err)
767{
768 struct rfcomm_session *s = NULL;
769 struct sockaddr_l2 addr;
770 struct socket *sock;
771 struct sock *sk;
772
773 BT_DBG("%pMR -> %pMR", src, dst);
774
775 *err = rfcomm_l2sock_create(&sock);
776 if (*err < 0)
777 return NULL;
778
779 bacpy(&addr.l2_bdaddr, src);
780 addr.l2_family = AF_BLUETOOTH;
781 addr.l2_psm = 0;
782 addr.l2_cid = 0;
783 addr.l2_bdaddr_type = BDADDR_BREDR;
784 *err = kernel_bind(sock, (struct sockaddr *) &addr, sizeof(addr));
785 if (*err < 0)
786 goto failed;
787
788 /* Set L2CAP options */
789 sk = sock->sk;
790 lock_sock(sk);
791 /* Set MTU to 0 so L2CAP can auto select the MTU */
792 l2cap_pi(sk)->chan->imtu = 0;
793 l2cap_pi(sk)->chan->sec_level = sec_level;
794 if (l2cap_ertm)
795 l2cap_pi(sk)->chan->mode = L2CAP_MODE_ERTM;
796 release_sock(sk);
797
798 s = rfcomm_session_add(sock, BT_BOUND);
799 if (!s) {
800 *err = -ENOMEM;
801 goto failed;
802 }
803
804 s->initiator = 1;
805
806 bacpy(&addr.l2_bdaddr, dst);
807 addr.l2_family = AF_BLUETOOTH;
808 addr.l2_psm = cpu_to_le16(L2CAP_PSM_RFCOMM);
809 addr.l2_cid = 0;
810 addr.l2_bdaddr_type = BDADDR_BREDR;
811 *err = kernel_connect(sock, (struct sockaddr *) &addr, sizeof(addr), O_NONBLOCK);
812 if (*err == 0 || *err == -EINPROGRESS)
813 return s;
814
815 return rfcomm_session_del(s);
816
817failed:
818 sock_release(sock);
819 return NULL;
820}
821
822void rfcomm_session_getaddr(struct rfcomm_session *s, bdaddr_t *src, bdaddr_t *dst)
823{
824 struct l2cap_chan *chan = l2cap_pi(s->sock->sk)->chan;
825 if (src)
826 bacpy(src, &chan->src);
827 if (dst)
828 bacpy(dst, &chan->dst);
829}
830
831/* ---- RFCOMM frame sending ---- */
832static int rfcomm_send_frame(struct rfcomm_session *s, u8 *data, int len)
833{
834 struct kvec iv = { data, len };
835 struct msghdr msg;
836
837 BT_DBG("session %p len %d", s, len);
838
839 memset(&msg, 0, sizeof(msg));
840
841 return kernel_sendmsg(s->sock, &msg, &iv, 1, len);
842}
843
844static int rfcomm_send_cmd(struct rfcomm_session *s, struct rfcomm_cmd *cmd)
845{
846 BT_DBG("%p cmd %u", s, cmd->ctrl);
847
848 return rfcomm_send_frame(s, (void *) cmd, sizeof(*cmd));
849}
850
851static int rfcomm_send_sabm(struct rfcomm_session *s, u8 dlci)
852{
853 struct rfcomm_cmd cmd;
854
855 BT_DBG("%p dlci %d", s, dlci);
856
857 cmd.addr = __addr(s->initiator, dlci);
858 cmd.ctrl = __ctrl(RFCOMM_SABM, 1);
859 cmd.len = __len8(0);
860 cmd.fcs = __fcs2((u8 *) &cmd);
861
862 return rfcomm_send_cmd(s, &cmd);
863}
864
865static int rfcomm_send_ua(struct rfcomm_session *s, u8 dlci)
866{
867 struct rfcomm_cmd cmd;
868
869 BT_DBG("%p dlci %d", s, dlci);
870
871 cmd.addr = __addr(!s->initiator, dlci);
872 cmd.ctrl = __ctrl(RFCOMM_UA, 1);
873 cmd.len = __len8(0);
874 cmd.fcs = __fcs2((u8 *) &cmd);
875
876 return rfcomm_send_cmd(s, &cmd);
877}
878
879static int rfcomm_send_disc(struct rfcomm_session *s, u8 dlci)
880{
881 struct rfcomm_cmd cmd;
882
883 BT_DBG("%p dlci %d", s, dlci);
884
885 cmd.addr = __addr(s->initiator, dlci);
886 cmd.ctrl = __ctrl(RFCOMM_DISC, 1);
887 cmd.len = __len8(0);
888 cmd.fcs = __fcs2((u8 *) &cmd);
889
890 return rfcomm_send_cmd(s, &cmd);
891}
892
893static int rfcomm_queue_disc(struct rfcomm_dlc *d)
894{
895 struct rfcomm_cmd *cmd;
896 struct sk_buff *skb;
897
898 BT_DBG("dlc %p dlci %d", d, d->dlci);
899
900 skb = alloc_skb(sizeof(*cmd), GFP_KERNEL);
901 if (!skb)
902 return -ENOMEM;
903
904 cmd = __skb_put(skb, sizeof(*cmd));
905 cmd->addr = d->addr;
906 cmd->ctrl = __ctrl(RFCOMM_DISC, 1);
907 cmd->len = __len8(0);
908 cmd->fcs = __fcs2((u8 *) cmd);
909
910 skb_queue_tail(&d->tx_queue, skb);
911 rfcomm_schedule();
912 return 0;
913}
914
915static int rfcomm_send_dm(struct rfcomm_session *s, u8 dlci)
916{
917 struct rfcomm_cmd cmd;
918
919 BT_DBG("%p dlci %d", s, dlci);
920
921 cmd.addr = __addr(!s->initiator, dlci);
922 cmd.ctrl = __ctrl(RFCOMM_DM, 1);
923 cmd.len = __len8(0);
924 cmd.fcs = __fcs2((u8 *) &cmd);
925
926 return rfcomm_send_cmd(s, &cmd);
927}
928
929static int rfcomm_send_nsc(struct rfcomm_session *s, int cr, u8 type)
930{
931 struct rfcomm_hdr *hdr;
932 struct rfcomm_mcc *mcc;
933 u8 buf[16], *ptr = buf;
934
935 BT_DBG("%p cr %d type %d", s, cr, type);
936
937 hdr = (void *) ptr; ptr += sizeof(*hdr);
938 hdr->addr = __addr(s->initiator, 0);
939 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
940 hdr->len = __len8(sizeof(*mcc) + 1);
941
942 mcc = (void *) ptr; ptr += sizeof(*mcc);
943 mcc->type = __mcc_type(0, RFCOMM_NSC);
944 mcc->len = __len8(1);
945
946 /* Type that we didn't like */
947 *ptr = __mcc_type(cr, type); ptr++;
948
949 *ptr = __fcs(buf); ptr++;
950
951 return rfcomm_send_frame(s, buf, ptr - buf);
952}
953
954static int rfcomm_send_pn(struct rfcomm_session *s, int cr, struct rfcomm_dlc *d)
955{
956 struct rfcomm_hdr *hdr;
957 struct rfcomm_mcc *mcc;
958 struct rfcomm_pn *pn;
959 u8 buf[16], *ptr = buf;
960
961 BT_DBG("%p cr %d dlci %d mtu %d", s, cr, d->dlci, d->mtu);
962
963 hdr = (void *) ptr; ptr += sizeof(*hdr);
964 hdr->addr = __addr(s->initiator, 0);
965 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
966 hdr->len = __len8(sizeof(*mcc) + sizeof(*pn));
967
968 mcc = (void *) ptr; ptr += sizeof(*mcc);
969 mcc->type = __mcc_type(cr, RFCOMM_PN);
970 mcc->len = __len8(sizeof(*pn));
971
972 pn = (void *) ptr; ptr += sizeof(*pn);
973 pn->dlci = d->dlci;
974 pn->priority = d->priority;
975 pn->ack_timer = 0;
976 pn->max_retrans = 0;
977
978 if (s->cfc) {
979 pn->flow_ctrl = cr ? 0xf0 : 0xe0;
980 pn->credits = RFCOMM_DEFAULT_CREDITS;
981 } else {
982 pn->flow_ctrl = 0;
983 pn->credits = 0;
984 }
985
986 if (cr && channel_mtu >= 0)
987 pn->mtu = cpu_to_le16(channel_mtu);
988 else
989 pn->mtu = cpu_to_le16(d->mtu);
990
991 *ptr = __fcs(buf); ptr++;
992
993 return rfcomm_send_frame(s, buf, ptr - buf);
994}
995
996int rfcomm_send_rpn(struct rfcomm_session *s, int cr, u8 dlci,
997 u8 bit_rate, u8 data_bits, u8 stop_bits,
998 u8 parity, u8 flow_ctrl_settings,
999 u8 xon_char, u8 xoff_char, u16 param_mask)
1000{
1001 struct rfcomm_hdr *hdr;
1002 struct rfcomm_mcc *mcc;
1003 struct rfcomm_rpn *rpn;
1004 u8 buf[16], *ptr = buf;
1005
1006 BT_DBG("%p cr %d dlci %d bit_r 0x%x data_b 0x%x stop_b 0x%x parity 0x%x"
1007 " flwc_s 0x%x xon_c 0x%x xoff_c 0x%x p_mask 0x%x",
1008 s, cr, dlci, bit_rate, data_bits, stop_bits, parity,
1009 flow_ctrl_settings, xon_char, xoff_char, param_mask);
1010
1011 hdr = (void *) ptr; ptr += sizeof(*hdr);
1012 hdr->addr = __addr(s->initiator, 0);
1013 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1014 hdr->len = __len8(sizeof(*mcc) + sizeof(*rpn));
1015
1016 mcc = (void *) ptr; ptr += sizeof(*mcc);
1017 mcc->type = __mcc_type(cr, RFCOMM_RPN);
1018 mcc->len = __len8(sizeof(*rpn));
1019
1020 rpn = (void *) ptr; ptr += sizeof(*rpn);
1021 rpn->dlci = __addr(1, dlci);
1022 rpn->bit_rate = bit_rate;
1023 rpn->line_settings = __rpn_line_settings(data_bits, stop_bits, parity);
1024 rpn->flow_ctrl = flow_ctrl_settings;
1025 rpn->xon_char = xon_char;
1026 rpn->xoff_char = xoff_char;
1027 rpn->param_mask = cpu_to_le16(param_mask);
1028
1029 *ptr = __fcs(buf); ptr++;
1030
1031 return rfcomm_send_frame(s, buf, ptr - buf);
1032}
1033
1034static int rfcomm_send_rls(struct rfcomm_session *s, int cr, u8 dlci, u8 status)
1035{
1036 struct rfcomm_hdr *hdr;
1037 struct rfcomm_mcc *mcc;
1038 struct rfcomm_rls *rls;
1039 u8 buf[16], *ptr = buf;
1040
1041 BT_DBG("%p cr %d status 0x%x", s, cr, status);
1042
1043 hdr = (void *) ptr; ptr += sizeof(*hdr);
1044 hdr->addr = __addr(s->initiator, 0);
1045 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1046 hdr->len = __len8(sizeof(*mcc) + sizeof(*rls));
1047
1048 mcc = (void *) ptr; ptr += sizeof(*mcc);
1049 mcc->type = __mcc_type(cr, RFCOMM_RLS);
1050 mcc->len = __len8(sizeof(*rls));
1051
1052 rls = (void *) ptr; ptr += sizeof(*rls);
1053 rls->dlci = __addr(1, dlci);
1054 rls->status = status;
1055
1056 *ptr = __fcs(buf); ptr++;
1057
1058 return rfcomm_send_frame(s, buf, ptr - buf);
1059}
1060
1061static int rfcomm_send_msc(struct rfcomm_session *s, int cr, u8 dlci, u8 v24_sig)
1062{
1063 struct rfcomm_hdr *hdr;
1064 struct rfcomm_mcc *mcc;
1065 struct rfcomm_msc *msc;
1066 u8 buf[16], *ptr = buf;
1067
1068 BT_DBG("%p cr %d v24 0x%x", s, cr, v24_sig);
1069
1070 hdr = (void *) ptr; ptr += sizeof(*hdr);
1071 hdr->addr = __addr(s->initiator, 0);
1072 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1073 hdr->len = __len8(sizeof(*mcc) + sizeof(*msc));
1074
1075 mcc = (void *) ptr; ptr += sizeof(*mcc);
1076 mcc->type = __mcc_type(cr, RFCOMM_MSC);
1077 mcc->len = __len8(sizeof(*msc));
1078
1079 msc = (void *) ptr; ptr += sizeof(*msc);
1080 msc->dlci = __addr(1, dlci);
1081 msc->v24_sig = v24_sig | 0x01;
1082
1083 *ptr = __fcs(buf); ptr++;
1084
1085 return rfcomm_send_frame(s, buf, ptr - buf);
1086}
1087
1088static int rfcomm_send_fcoff(struct rfcomm_session *s, int cr)
1089{
1090 struct rfcomm_hdr *hdr;
1091 struct rfcomm_mcc *mcc;
1092 u8 buf[16], *ptr = buf;
1093
1094 BT_DBG("%p cr %d", s, cr);
1095
1096 hdr = (void *) ptr; ptr += sizeof(*hdr);
1097 hdr->addr = __addr(s->initiator, 0);
1098 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1099 hdr->len = __len8(sizeof(*mcc));
1100
1101 mcc = (void *) ptr; ptr += sizeof(*mcc);
1102 mcc->type = __mcc_type(cr, RFCOMM_FCOFF);
1103 mcc->len = __len8(0);
1104
1105 *ptr = __fcs(buf); ptr++;
1106
1107 return rfcomm_send_frame(s, buf, ptr - buf);
1108}
1109
1110static int rfcomm_send_fcon(struct rfcomm_session *s, int cr)
1111{
1112 struct rfcomm_hdr *hdr;
1113 struct rfcomm_mcc *mcc;
1114 u8 buf[16], *ptr = buf;
1115
1116 BT_DBG("%p cr %d", s, cr);
1117
1118 hdr = (void *) ptr; ptr += sizeof(*hdr);
1119 hdr->addr = __addr(s->initiator, 0);
1120 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1121 hdr->len = __len8(sizeof(*mcc));
1122
1123 mcc = (void *) ptr; ptr += sizeof(*mcc);
1124 mcc->type = __mcc_type(cr, RFCOMM_FCON);
1125 mcc->len = __len8(0);
1126
1127 *ptr = __fcs(buf); ptr++;
1128
1129 return rfcomm_send_frame(s, buf, ptr - buf);
1130}
1131
1132static int rfcomm_send_test(struct rfcomm_session *s, int cr, u8 *pattern, int len)
1133{
1134 struct socket *sock = s->sock;
1135 struct kvec iv[3];
1136 struct msghdr msg;
1137 unsigned char hdr[5], crc[1];
1138
1139 if (len > 125)
1140 return -EINVAL;
1141
1142 BT_DBG("%p cr %d", s, cr);
1143
1144 hdr[0] = __addr(s->initiator, 0);
1145 hdr[1] = __ctrl(RFCOMM_UIH, 0);
1146 hdr[2] = 0x01 | ((len + 2) << 1);
1147 hdr[3] = 0x01 | ((cr & 0x01) << 1) | (RFCOMM_TEST << 2);
1148 hdr[4] = 0x01 | (len << 1);
1149
1150 crc[0] = __fcs(hdr);
1151
1152 iv[0].iov_base = hdr;
1153 iv[0].iov_len = 5;
1154 iv[1].iov_base = pattern;
1155 iv[1].iov_len = len;
1156 iv[2].iov_base = crc;
1157 iv[2].iov_len = 1;
1158
1159 memset(&msg, 0, sizeof(msg));
1160
1161 return kernel_sendmsg(sock, &msg, iv, 3, 6 + len);
1162}
1163
1164static int rfcomm_send_credits(struct rfcomm_session *s, u8 addr, u8 credits)
1165{
1166 struct rfcomm_hdr *hdr;
1167 u8 buf[16], *ptr = buf;
1168
1169 BT_DBG("%p addr %d credits %d", s, addr, credits);
1170
1171 hdr = (void *) ptr; ptr += sizeof(*hdr);
1172 hdr->addr = addr;
1173 hdr->ctrl = __ctrl(RFCOMM_UIH, 1);
1174 hdr->len = __len8(0);
1175
1176 *ptr = credits; ptr++;
1177
1178 *ptr = __fcs(buf); ptr++;
1179
1180 return rfcomm_send_frame(s, buf, ptr - buf);
1181}
1182
1183static void rfcomm_make_uih(struct sk_buff *skb, u8 addr)
1184{
1185 struct rfcomm_hdr *hdr;
1186 int len = skb->len;
1187 u8 *crc;
1188
1189 if (len > 127) {
1190 hdr = skb_push(skb, 4);
1191 put_unaligned(cpu_to_le16(__len16(len)), (__le16 *) &hdr->len);
1192 } else {
1193 hdr = skb_push(skb, 3);
1194 hdr->len = __len8(len);
1195 }
1196 hdr->addr = addr;
1197 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1198
1199 crc = skb_put(skb, 1);
1200 *crc = __fcs((void *) hdr);
1201}
1202
1203/* ---- RFCOMM frame reception ---- */
1204static struct rfcomm_session *rfcomm_recv_ua(struct rfcomm_session *s, u8 dlci)
1205{
1206 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1207
1208 if (dlci) {
1209 /* Data channel */
1210 struct rfcomm_dlc *d = rfcomm_dlc_get(s, dlci);
1211 if (!d) {
1212 rfcomm_send_dm(s, dlci);
1213 return s;
1214 }
1215
1216 switch (d->state) {
1217 case BT_CONNECT:
1218 rfcomm_dlc_clear_timer(d);
1219
1220 rfcomm_dlc_lock(d);
1221 d->state = BT_CONNECTED;
1222 d->state_change(d, 0);
1223 rfcomm_dlc_unlock(d);
1224
1225 rfcomm_send_msc(s, 1, dlci, d->v24_sig);
1226 break;
1227
1228 case BT_DISCONN:
1229 d->state = BT_CLOSED;
1230 __rfcomm_dlc_close(d, 0);
1231
1232 if (list_empty(&s->dlcs)) {
1233 s->state = BT_DISCONN;
1234 rfcomm_send_disc(s, 0);
1235 rfcomm_session_clear_timer(s);
1236 }
1237
1238 break;
1239 }
1240 } else {
1241 /* Control channel */
1242 switch (s->state) {
1243 case BT_CONNECT:
1244 s->state = BT_CONNECTED;
1245 rfcomm_process_connect(s);
1246 break;
1247
1248 case BT_DISCONN:
1249 s = rfcomm_session_close(s, ECONNRESET);
1250 break;
1251 }
1252 }
1253 return s;
1254}
1255
1256static struct rfcomm_session *rfcomm_recv_dm(struct rfcomm_session *s, u8 dlci)
1257{
1258 int err = 0;
1259
1260 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1261
1262 if (dlci) {
1263 /* Data DLC */
1264 struct rfcomm_dlc *d = rfcomm_dlc_get(s, dlci);
1265 if (d) {
1266 if (d->state == BT_CONNECT || d->state == BT_CONFIG)
1267 err = ECONNREFUSED;
1268 else
1269 err = ECONNRESET;
1270
1271 d->state = BT_CLOSED;
1272 __rfcomm_dlc_close(d, err);
1273 }
1274 } else {
1275 if (s->state == BT_CONNECT)
1276 err = ECONNREFUSED;
1277 else
1278 err = ECONNRESET;
1279
1280 s = rfcomm_session_close(s, err);
1281 }
1282 return s;
1283}
1284
1285static struct rfcomm_session *rfcomm_recv_disc(struct rfcomm_session *s,
1286 u8 dlci)
1287{
1288 int err = 0;
1289
1290 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1291
1292 if (dlci) {
1293 struct rfcomm_dlc *d = rfcomm_dlc_get(s, dlci);
1294 if (d) {
1295 rfcomm_send_ua(s, dlci);
1296
1297 if (d->state == BT_CONNECT || d->state == BT_CONFIG)
1298 err = ECONNREFUSED;
1299 else
1300 err = ECONNRESET;
1301
1302 d->state = BT_CLOSED;
1303 __rfcomm_dlc_close(d, err);
1304 } else
1305 rfcomm_send_dm(s, dlci);
1306
1307 } else {
1308 rfcomm_send_ua(s, 0);
1309
1310 if (s->state == BT_CONNECT)
1311 err = ECONNREFUSED;
1312 else
1313 err = ECONNRESET;
1314
1315 s = rfcomm_session_close(s, err);
1316 }
1317 return s;
1318}
1319
1320void rfcomm_dlc_accept(struct rfcomm_dlc *d)
1321{
1322 struct sock *sk = d->session->sock->sk;
1323 struct l2cap_conn *conn = l2cap_pi(sk)->chan->conn;
1324
1325 BT_DBG("dlc %p", d);
1326
1327 rfcomm_send_ua(d->session, d->dlci);
1328
1329 rfcomm_dlc_clear_timer(d);
1330
1331 rfcomm_dlc_lock(d);
1332 d->state = BT_CONNECTED;
1333 d->state_change(d, 0);
1334 rfcomm_dlc_unlock(d);
1335
1336 if (d->role_switch)
1337 hci_conn_switch_role(conn->hcon, 0x00);
1338
1339 rfcomm_send_msc(d->session, 1, d->dlci, d->v24_sig);
1340}
1341
1342static void rfcomm_check_accept(struct rfcomm_dlc *d)
1343{
1344 if (rfcomm_check_security(d)) {
1345 if (d->defer_setup) {
1346 set_bit(RFCOMM_DEFER_SETUP, &d->flags);
1347 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
1348
1349 rfcomm_dlc_lock(d);
1350 d->state = BT_CONNECT2;
1351 d->state_change(d, 0);
1352 rfcomm_dlc_unlock(d);
1353 } else
1354 rfcomm_dlc_accept(d);
1355 } else {
1356 set_bit(RFCOMM_AUTH_PENDING, &d->flags);
1357 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
1358 }
1359}
1360
1361static int rfcomm_recv_sabm(struct rfcomm_session *s, u8 dlci)
1362{
1363 struct rfcomm_dlc *d;
1364 u8 channel;
1365
1366 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1367
1368 if (!dlci) {
1369 rfcomm_send_ua(s, 0);
1370
1371 if (s->state == BT_OPEN) {
1372 s->state = BT_CONNECTED;
1373 rfcomm_process_connect(s);
1374 }
1375 return 0;
1376 }
1377
1378 /* Check if DLC exists */
1379 d = rfcomm_dlc_get(s, dlci);
1380 if (d) {
1381 if (d->state == BT_OPEN) {
1382 /* DLC was previously opened by PN request */
1383 rfcomm_check_accept(d);
1384 }
1385 return 0;
1386 }
1387
1388 /* Notify socket layer about incoming connection */
1389 channel = __srv_channel(dlci);
1390 if (rfcomm_connect_ind(s, channel, &d)) {
1391 d->dlci = dlci;
1392 d->addr = __addr(s->initiator, dlci);
1393 rfcomm_dlc_link(s, d);
1394
1395 rfcomm_check_accept(d);
1396 } else {
1397 rfcomm_send_dm(s, dlci);
1398 }
1399
1400 return 0;
1401}
1402
1403static int rfcomm_apply_pn(struct rfcomm_dlc *d, int cr, struct rfcomm_pn *pn)
1404{
1405 struct rfcomm_session *s = d->session;
1406
1407 BT_DBG("dlc %p state %ld dlci %d mtu %d fc 0x%x credits %d",
1408 d, d->state, d->dlci, pn->mtu, pn->flow_ctrl, pn->credits);
1409
1410 if ((pn->flow_ctrl == 0xf0 && s->cfc != RFCOMM_CFC_DISABLED) ||
1411 pn->flow_ctrl == 0xe0) {
1412 d->cfc = RFCOMM_CFC_ENABLED;
1413 d->tx_credits = pn->credits;
1414 } else {
1415 d->cfc = RFCOMM_CFC_DISABLED;
1416 set_bit(RFCOMM_TX_THROTTLED, &d->flags);
1417 }
1418
1419 if (s->cfc == RFCOMM_CFC_UNKNOWN)
1420 s->cfc = d->cfc;
1421
1422 d->priority = pn->priority;
1423
1424 d->mtu = __le16_to_cpu(pn->mtu);
1425
1426 if (cr && d->mtu > s->mtu)
1427 d->mtu = s->mtu;
1428
1429 return 0;
1430}
1431
1432static int rfcomm_recv_pn(struct rfcomm_session *s, int cr, struct sk_buff *skb)
1433{
1434 struct rfcomm_pn *pn = (void *) skb->data;
1435 struct rfcomm_dlc *d;
1436 u8 dlci = pn->dlci;
1437
1438 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1439
1440 if (!dlci)
1441 return 0;
1442
1443 d = rfcomm_dlc_get(s, dlci);
1444 if (d) {
1445 if (cr) {
1446 /* PN request */
1447 rfcomm_apply_pn(d, cr, pn);
1448 rfcomm_send_pn(s, 0, d);
1449 } else {
1450 /* PN response */
1451 switch (d->state) {
1452 case BT_CONFIG:
1453 rfcomm_apply_pn(d, cr, pn);
1454
1455 d->state = BT_CONNECT;
1456 rfcomm_send_sabm(s, d->dlci);
1457 break;
1458 }
1459 }
1460 } else {
1461 u8 channel = __srv_channel(dlci);
1462
1463 if (!cr)
1464 return 0;
1465
1466 /* PN request for non existing DLC.
1467 * Assume incoming connection. */
1468 if (rfcomm_connect_ind(s, channel, &d)) {
1469 d->dlci = dlci;
1470 d->addr = __addr(s->initiator, dlci);
1471 rfcomm_dlc_link(s, d);
1472
1473 rfcomm_apply_pn(d, cr, pn);
1474
1475 d->state = BT_OPEN;
1476 rfcomm_send_pn(s, 0, d);
1477 } else {
1478 rfcomm_send_dm(s, dlci);
1479 }
1480 }
1481 return 0;
1482}
1483
1484static int rfcomm_recv_rpn(struct rfcomm_session *s, int cr, int len, struct sk_buff *skb)
1485{
1486 struct rfcomm_rpn *rpn = (void *) skb->data;
1487 u8 dlci = __get_dlci(rpn->dlci);
1488
1489 u8 bit_rate = 0;
1490 u8 data_bits = 0;
1491 u8 stop_bits = 0;
1492 u8 parity = 0;
1493 u8 flow_ctrl = 0;
1494 u8 xon_char = 0;
1495 u8 xoff_char = 0;
1496 u16 rpn_mask = RFCOMM_RPN_PM_ALL;
1497
1498 BT_DBG("dlci %d cr %d len 0x%x bitr 0x%x line 0x%x flow 0x%x xonc 0x%x xoffc 0x%x pm 0x%x",
1499 dlci, cr, len, rpn->bit_rate, rpn->line_settings, rpn->flow_ctrl,
1500 rpn->xon_char, rpn->xoff_char, rpn->param_mask);
1501
1502 if (!cr)
1503 return 0;
1504
1505 if (len == 1) {
1506 /* This is a request, return default (according to ETSI TS 07.10) settings */
1507 bit_rate = RFCOMM_RPN_BR_9600;
1508 data_bits = RFCOMM_RPN_DATA_8;
1509 stop_bits = RFCOMM_RPN_STOP_1;
1510 parity = RFCOMM_RPN_PARITY_NONE;
1511 flow_ctrl = RFCOMM_RPN_FLOW_NONE;
1512 xon_char = RFCOMM_RPN_XON_CHAR;
1513 xoff_char = RFCOMM_RPN_XOFF_CHAR;
1514 goto rpn_out;
1515 }
1516
1517 /* Check for sane values, ignore/accept bit_rate, 8 bits, 1 stop bit,
1518 * no parity, no flow control lines, normal XON/XOFF chars */
1519
1520 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_BITRATE)) {
1521 bit_rate = rpn->bit_rate;
1522 if (bit_rate > RFCOMM_RPN_BR_230400) {
1523 BT_DBG("RPN bit rate mismatch 0x%x", bit_rate);
1524 bit_rate = RFCOMM_RPN_BR_9600;
1525 rpn_mask ^= RFCOMM_RPN_PM_BITRATE;
1526 }
1527 }
1528
1529 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_DATA)) {
1530 data_bits = __get_rpn_data_bits(rpn->line_settings);
1531 if (data_bits != RFCOMM_RPN_DATA_8) {
1532 BT_DBG("RPN data bits mismatch 0x%x", data_bits);
1533 data_bits = RFCOMM_RPN_DATA_8;
1534 rpn_mask ^= RFCOMM_RPN_PM_DATA;
1535 }
1536 }
1537
1538 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_STOP)) {
1539 stop_bits = __get_rpn_stop_bits(rpn->line_settings);
1540 if (stop_bits != RFCOMM_RPN_STOP_1) {
1541 BT_DBG("RPN stop bits mismatch 0x%x", stop_bits);
1542 stop_bits = RFCOMM_RPN_STOP_1;
1543 rpn_mask ^= RFCOMM_RPN_PM_STOP;
1544 }
1545 }
1546
1547 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_PARITY)) {
1548 parity = __get_rpn_parity(rpn->line_settings);
1549 if (parity != RFCOMM_RPN_PARITY_NONE) {
1550 BT_DBG("RPN parity mismatch 0x%x", parity);
1551 parity = RFCOMM_RPN_PARITY_NONE;
1552 rpn_mask ^= RFCOMM_RPN_PM_PARITY;
1553 }
1554 }
1555
1556 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_FLOW)) {
1557 flow_ctrl = rpn->flow_ctrl;
1558 if (flow_ctrl != RFCOMM_RPN_FLOW_NONE) {
1559 BT_DBG("RPN flow ctrl mismatch 0x%x", flow_ctrl);
1560 flow_ctrl = RFCOMM_RPN_FLOW_NONE;
1561 rpn_mask ^= RFCOMM_RPN_PM_FLOW;
1562 }
1563 }
1564
1565 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_XON)) {
1566 xon_char = rpn->xon_char;
1567 if (xon_char != RFCOMM_RPN_XON_CHAR) {
1568 BT_DBG("RPN XON char mismatch 0x%x", xon_char);
1569 xon_char = RFCOMM_RPN_XON_CHAR;
1570 rpn_mask ^= RFCOMM_RPN_PM_XON;
1571 }
1572 }
1573
1574 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_XOFF)) {
1575 xoff_char = rpn->xoff_char;
1576 if (xoff_char != RFCOMM_RPN_XOFF_CHAR) {
1577 BT_DBG("RPN XOFF char mismatch 0x%x", xoff_char);
1578 xoff_char = RFCOMM_RPN_XOFF_CHAR;
1579 rpn_mask ^= RFCOMM_RPN_PM_XOFF;
1580 }
1581 }
1582
1583rpn_out:
1584 rfcomm_send_rpn(s, 0, dlci, bit_rate, data_bits, stop_bits,
1585 parity, flow_ctrl, xon_char, xoff_char, rpn_mask);
1586
1587 return 0;
1588}
1589
1590static int rfcomm_recv_rls(struct rfcomm_session *s, int cr, struct sk_buff *skb)
1591{
1592 struct rfcomm_rls *rls = (void *) skb->data;
1593 u8 dlci = __get_dlci(rls->dlci);
1594
1595 BT_DBG("dlci %d cr %d status 0x%x", dlci, cr, rls->status);
1596
1597 if (!cr)
1598 return 0;
1599
1600 /* We should probably do something with this information here. But
1601 * for now it's sufficient just to reply -- Bluetooth 1.1 says it's
1602 * mandatory to recognise and respond to RLS */
1603
1604 rfcomm_send_rls(s, 0, dlci, rls->status);
1605
1606 return 0;
1607}
1608
1609static int rfcomm_recv_msc(struct rfcomm_session *s, int cr, struct sk_buff *skb)
1610{
1611 struct rfcomm_msc *msc = (void *) skb->data;
1612 struct rfcomm_dlc *d;
1613 u8 dlci = __get_dlci(msc->dlci);
1614
1615 BT_DBG("dlci %d cr %d v24 0x%x", dlci, cr, msc->v24_sig);
1616
1617 d = rfcomm_dlc_get(s, dlci);
1618 if (!d)
1619 return 0;
1620
1621 if (cr) {
1622 if (msc->v24_sig & RFCOMM_V24_FC && !d->cfc)
1623 set_bit(RFCOMM_TX_THROTTLED, &d->flags);
1624 else
1625 clear_bit(RFCOMM_TX_THROTTLED, &d->flags);
1626
1627 rfcomm_dlc_lock(d);
1628
1629 d->remote_v24_sig = msc->v24_sig;
1630
1631 if (d->modem_status)
1632 d->modem_status(d, msc->v24_sig);
1633
1634 rfcomm_dlc_unlock(d);
1635
1636 rfcomm_send_msc(s, 0, dlci, msc->v24_sig);
1637
1638 d->mscex |= RFCOMM_MSCEX_RX;
1639 } else
1640 d->mscex |= RFCOMM_MSCEX_TX;
1641
1642 return 0;
1643}
1644
1645static int rfcomm_recv_mcc(struct rfcomm_session *s, struct sk_buff *skb)
1646{
1647 struct rfcomm_mcc *mcc = (void *) skb->data;
1648 u8 type, cr, len;
1649
1650 cr = __test_cr(mcc->type);
1651 type = __get_mcc_type(mcc->type);
1652 len = __get_mcc_len(mcc->len);
1653
1654 BT_DBG("%p type 0x%x cr %d", s, type, cr);
1655
1656 skb_pull(skb, 2);
1657
1658 switch (type) {
1659 case RFCOMM_PN:
1660 rfcomm_recv_pn(s, cr, skb);
1661 break;
1662
1663 case RFCOMM_RPN:
1664 rfcomm_recv_rpn(s, cr, len, skb);
1665 break;
1666
1667 case RFCOMM_RLS:
1668 rfcomm_recv_rls(s, cr, skb);
1669 break;
1670
1671 case RFCOMM_MSC:
1672 rfcomm_recv_msc(s, cr, skb);
1673 break;
1674
1675 case RFCOMM_FCOFF:
1676 if (cr) {
1677 set_bit(RFCOMM_TX_THROTTLED, &s->flags);
1678 rfcomm_send_fcoff(s, 0);
1679 }
1680 break;
1681
1682 case RFCOMM_FCON:
1683 if (cr) {
1684 clear_bit(RFCOMM_TX_THROTTLED, &s->flags);
1685 rfcomm_send_fcon(s, 0);
1686 }
1687 break;
1688
1689 case RFCOMM_TEST:
1690 if (cr)
1691 rfcomm_send_test(s, 0, skb->data, skb->len);
1692 break;
1693
1694 case RFCOMM_NSC:
1695 break;
1696
1697 default:
1698 BT_ERR("Unknown control type 0x%02x", type);
1699 rfcomm_send_nsc(s, cr, type);
1700 break;
1701 }
1702 return 0;
1703}
1704
1705static int rfcomm_recv_data(struct rfcomm_session *s, u8 dlci, int pf, struct sk_buff *skb)
1706{
1707 struct rfcomm_dlc *d;
1708
1709 BT_DBG("session %p state %ld dlci %d pf %d", s, s->state, dlci, pf);
1710
1711 d = rfcomm_dlc_get(s, dlci);
1712 if (!d) {
1713 rfcomm_send_dm(s, dlci);
1714 goto drop;
1715 }
1716
1717 if (pf && d->cfc) {
1718 u8 credits = *(u8 *) skb->data; skb_pull(skb, 1);
1719
1720 d->tx_credits += credits;
1721 if (d->tx_credits)
1722 clear_bit(RFCOMM_TX_THROTTLED, &d->flags);
1723 }
1724
1725 if (skb->len && d->state == BT_CONNECTED) {
1726 rfcomm_dlc_lock(d);
1727 d->rx_credits--;
1728 d->data_ready(d, skb);
1729 rfcomm_dlc_unlock(d);
1730 return 0;
1731 }
1732
1733drop:
1734 kfree_skb(skb);
1735 return 0;
1736}
1737
1738static struct rfcomm_session *rfcomm_recv_frame(struct rfcomm_session *s,
1739 struct sk_buff *skb)
1740{
1741 struct rfcomm_hdr *hdr = (void *) skb->data;
1742 u8 type, dlci, fcs;
1743
1744 if (!s) {
1745 /* no session, so free socket data */
1746 kfree_skb(skb);
1747 return s;
1748 }
1749
1750 dlci = __get_dlci(hdr->addr);
1751 type = __get_type(hdr->ctrl);
1752
1753 /* Trim FCS */
1754 skb->len--; skb->tail--;
1755 fcs = *(u8 *)skb_tail_pointer(skb);
1756
1757 if (__check_fcs(skb->data, type, fcs)) {
1758 BT_ERR("bad checksum in packet");
1759 kfree_skb(skb);
1760 return s;
1761 }
1762
1763 if (__test_ea(hdr->len))
1764 skb_pull(skb, 3);
1765 else
1766 skb_pull(skb, 4);
1767
1768 switch (type) {
1769 case RFCOMM_SABM:
1770 if (__test_pf(hdr->ctrl))
1771 rfcomm_recv_sabm(s, dlci);
1772 break;
1773
1774 case RFCOMM_DISC:
1775 if (__test_pf(hdr->ctrl))
1776 s = rfcomm_recv_disc(s, dlci);
1777 break;
1778
1779 case RFCOMM_UA:
1780 if (__test_pf(hdr->ctrl))
1781 s = rfcomm_recv_ua(s, dlci);
1782 break;
1783
1784 case RFCOMM_DM:
1785 s = rfcomm_recv_dm(s, dlci);
1786 break;
1787
1788 case RFCOMM_UIH:
1789 if (dlci) {
1790 rfcomm_recv_data(s, dlci, __test_pf(hdr->ctrl), skb);
1791 return s;
1792 }
1793 rfcomm_recv_mcc(s, skb);
1794 break;
1795
1796 default:
1797 BT_ERR("Unknown packet type 0x%02x", type);
1798 break;
1799 }
1800 kfree_skb(skb);
1801 return s;
1802}
1803
1804/* ---- Connection and data processing ---- */
1805
1806static void rfcomm_process_connect(struct rfcomm_session *s)
1807{
1808 struct rfcomm_dlc *d, *n;
1809
1810 BT_DBG("session %p state %ld", s, s->state);
1811
1812 list_for_each_entry_safe(d, n, &s->dlcs, list) {
1813 if (d->state == BT_CONFIG) {
1814 d->mtu = s->mtu;
1815 if (rfcomm_check_security(d)) {
1816 rfcomm_send_pn(s, 1, d);
1817 } else {
1818 set_bit(RFCOMM_AUTH_PENDING, &d->flags);
1819 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
1820 }
1821 }
1822 }
1823}
1824
1825/* Send data queued for the DLC.
1826 * Return number of frames left in the queue.
1827 */
1828static int rfcomm_process_tx(struct rfcomm_dlc *d)
1829{
1830 struct sk_buff *skb;
1831 int err;
1832
1833 BT_DBG("dlc %p state %ld cfc %d rx_credits %d tx_credits %d",
1834 d, d->state, d->cfc, d->rx_credits, d->tx_credits);
1835
1836 /* Send pending MSC */
1837 if (test_and_clear_bit(RFCOMM_MSC_PENDING, &d->flags))
1838 rfcomm_send_msc(d->session, 1, d->dlci, d->v24_sig);
1839
1840 if (d->cfc) {
1841 /* CFC enabled.
1842 * Give them some credits */
1843 if (!test_bit(RFCOMM_RX_THROTTLED, &d->flags) &&
1844 d->rx_credits <= (d->cfc >> 2)) {
1845 rfcomm_send_credits(d->session, d->addr, d->cfc - d->rx_credits);
1846 d->rx_credits = d->cfc;
1847 }
1848 } else {
1849 /* CFC disabled.
1850 * Give ourselves some credits */
1851 d->tx_credits = 5;
1852 }
1853
1854 if (test_bit(RFCOMM_TX_THROTTLED, &d->flags))
1855 return skb_queue_len(&d->tx_queue);
1856
1857 while (d->tx_credits && (skb = skb_dequeue(&d->tx_queue))) {
1858 err = rfcomm_send_frame(d->session, skb->data, skb->len);
1859 if (err < 0) {
1860 skb_queue_head(&d->tx_queue, skb);
1861 break;
1862 }
1863 kfree_skb(skb);
1864 d->tx_credits--;
1865 }
1866
1867 if (d->cfc && !d->tx_credits) {
1868 /* We're out of TX credits.
1869 * Set TX_THROTTLED flag to avoid unnesary wakeups by dlc_send. */
1870 set_bit(RFCOMM_TX_THROTTLED, &d->flags);
1871 }
1872
1873 return skb_queue_len(&d->tx_queue);
1874}
1875
1876static void rfcomm_process_dlcs(struct rfcomm_session *s)
1877{
1878 struct rfcomm_dlc *d, *n;
1879
1880 BT_DBG("session %p state %ld", s, s->state);
1881
1882 list_for_each_entry_safe(d, n, &s->dlcs, list) {
1883 if (test_bit(RFCOMM_TIMED_OUT, &d->flags)) {
1884 __rfcomm_dlc_close(d, ETIMEDOUT);
1885 continue;
1886 }
1887
1888 if (test_bit(RFCOMM_ENC_DROP, &d->flags)) {
1889 __rfcomm_dlc_close(d, ECONNREFUSED);
1890 continue;
1891 }
1892
1893 if (test_and_clear_bit(RFCOMM_AUTH_ACCEPT, &d->flags)) {
1894 rfcomm_dlc_clear_timer(d);
1895 if (d->out) {
1896 rfcomm_send_pn(s, 1, d);
1897 rfcomm_dlc_set_timer(d, RFCOMM_CONN_TIMEOUT);
1898 } else {
1899 if (d->defer_setup) {
1900 set_bit(RFCOMM_DEFER_SETUP, &d->flags);
1901 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
1902
1903 rfcomm_dlc_lock(d);
1904 d->state = BT_CONNECT2;
1905 d->state_change(d, 0);
1906 rfcomm_dlc_unlock(d);
1907 } else
1908 rfcomm_dlc_accept(d);
1909 }
1910 continue;
1911 } else if (test_and_clear_bit(RFCOMM_AUTH_REJECT, &d->flags)) {
1912 rfcomm_dlc_clear_timer(d);
1913 if (!d->out)
1914 rfcomm_send_dm(s, d->dlci);
1915 else
1916 d->state = BT_CLOSED;
1917 __rfcomm_dlc_close(d, ECONNREFUSED);
1918 continue;
1919 }
1920
1921 if (test_bit(RFCOMM_SEC_PENDING, &d->flags))
1922 continue;
1923
1924 if (test_bit(RFCOMM_TX_THROTTLED, &s->flags))
1925 continue;
1926
1927 if ((d->state == BT_CONNECTED || d->state == BT_DISCONN) &&
1928 d->mscex == RFCOMM_MSCEX_OK)
1929 rfcomm_process_tx(d);
1930 }
1931}
1932
1933static struct rfcomm_session *rfcomm_process_rx(struct rfcomm_session *s)
1934{
1935 struct socket *sock = s->sock;
1936 struct sock *sk = sock->sk;
1937 struct sk_buff *skb;
1938
1939 BT_DBG("session %p state %ld qlen %d", s, s->state, skb_queue_len(&sk->sk_receive_queue));
1940
1941 /* Get data directly from socket receive queue without copying it. */
1942 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
1943 skb_orphan(skb);
1944 if (!skb_linearize(skb) && sk->sk_state != BT_CLOSED) {
1945 s = rfcomm_recv_frame(s, skb);
1946 if (!s)
1947 break;
1948 } else {
1949 kfree_skb(skb);
1950 }
1951 }
1952
1953 if (s && (sk->sk_state == BT_CLOSED))
1954 s = rfcomm_session_close(s, sk->sk_err);
1955
1956 return s;
1957}
1958
1959static void rfcomm_accept_connection(struct rfcomm_session *s)
1960{
1961 struct socket *sock = s->sock, *nsock;
1962 int err;
1963
1964 /* Fast check for a new connection.
1965 * Avoids unnesesary socket allocations. */
1966 if (list_empty(&bt_sk(sock->sk)->accept_q))
1967 return;
1968
1969 BT_DBG("session %p", s);
1970
1971 err = kernel_accept(sock, &nsock, O_NONBLOCK);
1972 if (err < 0)
1973 return;
1974
1975 /* Set our callbacks */
1976 nsock->sk->sk_data_ready = rfcomm_l2data_ready;
1977 nsock->sk->sk_state_change = rfcomm_l2state_change;
1978
1979 s = rfcomm_session_add(nsock, BT_OPEN);
1980 if (s) {
1981 /* We should adjust MTU on incoming sessions.
1982 * L2CAP MTU minus UIH header and FCS. */
1983 s->mtu = min(l2cap_pi(nsock->sk)->chan->omtu,
1984 l2cap_pi(nsock->sk)->chan->imtu) - 5;
1985
1986 rfcomm_schedule();
1987 } else
1988 sock_release(nsock);
1989}
1990
1991static struct rfcomm_session *rfcomm_check_connection(struct rfcomm_session *s)
1992{
1993 struct sock *sk = s->sock->sk;
1994
1995 BT_DBG("%p state %ld", s, s->state);
1996
1997 switch (sk->sk_state) {
1998 case BT_CONNECTED:
1999 s->state = BT_CONNECT;
2000
2001 /* We can adjust MTU on outgoing sessions.
2002 * L2CAP MTU minus UIH header and FCS. */
2003 s->mtu = min(l2cap_pi(sk)->chan->omtu, l2cap_pi(sk)->chan->imtu) - 5;
2004
2005 rfcomm_send_sabm(s, 0);
2006 break;
2007
2008 case BT_CLOSED:
2009 s = rfcomm_session_close(s, sk->sk_err);
2010 break;
2011 }
2012 return s;
2013}
2014
2015static void rfcomm_process_sessions(void)
2016{
2017 struct rfcomm_session *s, *n;
2018
2019 rfcomm_lock();
2020
2021 list_for_each_entry_safe(s, n, &session_list, list) {
2022 if (test_and_clear_bit(RFCOMM_TIMED_OUT, &s->flags)) {
2023 s->state = BT_DISCONN;
2024 rfcomm_send_disc(s, 0);
2025 continue;
2026 }
2027
2028 switch (s->state) {
2029 case BT_LISTEN:
2030 rfcomm_accept_connection(s);
2031 continue;
2032
2033 case BT_BOUND:
2034 s = rfcomm_check_connection(s);
2035 break;
2036
2037 default:
2038 s = rfcomm_process_rx(s);
2039 break;
2040 }
2041
2042 if (s)
2043 rfcomm_process_dlcs(s);
2044 }
2045
2046 rfcomm_unlock();
2047}
2048
2049static int rfcomm_add_listener(bdaddr_t *ba)
2050{
2051 struct sockaddr_l2 addr;
2052 struct socket *sock;
2053 struct sock *sk;
2054 struct rfcomm_session *s;
2055 int err = 0;
2056
2057 /* Create socket */
2058 err = rfcomm_l2sock_create(&sock);
2059 if (err < 0) {
2060 BT_ERR("Create socket failed %d", err);
2061 return err;
2062 }
2063
2064 /* Bind socket */
2065 bacpy(&addr.l2_bdaddr, ba);
2066 addr.l2_family = AF_BLUETOOTH;
2067 addr.l2_psm = cpu_to_le16(L2CAP_PSM_RFCOMM);
2068 addr.l2_cid = 0;
2069 addr.l2_bdaddr_type = BDADDR_BREDR;
2070 err = kernel_bind(sock, (struct sockaddr *) &addr, sizeof(addr));
2071 if (err < 0) {
2072 BT_ERR("Bind failed %d", err);
2073 goto failed;
2074 }
2075
2076 /* Set L2CAP options */
2077 sk = sock->sk;
2078 lock_sock(sk);
2079 /* Set MTU to 0 so L2CAP can auto select the MTU */
2080 l2cap_pi(sk)->chan->imtu = 0;
2081 release_sock(sk);
2082
2083 /* Start listening on the socket */
2084 err = kernel_listen(sock, 10);
2085 if (err) {
2086 BT_ERR("Listen failed %d", err);
2087 goto failed;
2088 }
2089
2090 /* Add listening session */
2091 s = rfcomm_session_add(sock, BT_LISTEN);
2092 if (!s) {
2093 err = -ENOMEM;
2094 goto failed;
2095 }
2096
2097 return 0;
2098failed:
2099 sock_release(sock);
2100 return err;
2101}
2102
2103static void rfcomm_kill_listener(void)
2104{
2105 struct rfcomm_session *s, *n;
2106
2107 BT_DBG("");
2108
2109 list_for_each_entry_safe(s, n, &session_list, list)
2110 rfcomm_session_del(s);
2111}
2112
2113static int rfcomm_run(void *unused)
2114{
2115 DEFINE_WAIT_FUNC(wait, woken_wake_function);
2116 BT_DBG("");
2117
2118 set_user_nice(current, -10);
2119
2120 rfcomm_add_listener(BDADDR_ANY);
2121
2122 add_wait_queue(&rfcomm_wq, &wait);
2123 while (!kthread_should_stop()) {
2124
2125 /* Process stuff */
2126 rfcomm_process_sessions();
2127
2128 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
2129 }
2130 remove_wait_queue(&rfcomm_wq, &wait);
2131
2132 rfcomm_kill_listener();
2133
2134 return 0;
2135}
2136
2137static void rfcomm_security_cfm(struct hci_conn *conn, u8 status, u8 encrypt)
2138{
2139 struct rfcomm_session *s;
2140 struct rfcomm_dlc *d, *n;
2141
2142 BT_DBG("conn %p status 0x%02x encrypt 0x%02x", conn, status, encrypt);
2143
2144 s = rfcomm_session_get(&conn->hdev->bdaddr, &conn->dst);
2145 if (!s)
2146 return;
2147
2148 list_for_each_entry_safe(d, n, &s->dlcs, list) {
2149 if (test_and_clear_bit(RFCOMM_SEC_PENDING, &d->flags)) {
2150 rfcomm_dlc_clear_timer(d);
2151 if (status || encrypt == 0x00) {
2152 set_bit(RFCOMM_ENC_DROP, &d->flags);
2153 continue;
2154 }
2155 }
2156
2157 if (d->state == BT_CONNECTED && !status && encrypt == 0x00) {
2158 if (d->sec_level == BT_SECURITY_MEDIUM) {
2159 set_bit(RFCOMM_SEC_PENDING, &d->flags);
2160 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
2161 continue;
2162 } else if (d->sec_level == BT_SECURITY_HIGH ||
2163 d->sec_level == BT_SECURITY_FIPS) {
2164 set_bit(RFCOMM_ENC_DROP, &d->flags);
2165 continue;
2166 }
2167 }
2168
2169 if (!test_and_clear_bit(RFCOMM_AUTH_PENDING, &d->flags))
2170 continue;
2171
2172 if (!status && hci_conn_check_secure(conn, d->sec_level))
2173 set_bit(RFCOMM_AUTH_ACCEPT, &d->flags);
2174 else
2175 set_bit(RFCOMM_AUTH_REJECT, &d->flags);
2176 }
2177
2178 rfcomm_schedule();
2179}
2180
2181static struct hci_cb rfcomm_cb = {
2182 .name = "RFCOMM",
2183 .security_cfm = rfcomm_security_cfm
2184};
2185
2186static int rfcomm_dlc_debugfs_show(struct seq_file *f, void *x)
2187{
2188 struct rfcomm_session *s;
2189
2190 rfcomm_lock();
2191
2192 list_for_each_entry(s, &session_list, list) {
2193 struct l2cap_chan *chan = l2cap_pi(s->sock->sk)->chan;
2194 struct rfcomm_dlc *d;
2195 list_for_each_entry(d, &s->dlcs, list) {
2196 seq_printf(f, "%pMR %pMR %ld %d %d %d %d\n",
2197 &chan->src, &chan->dst,
2198 d->state, d->dlci, d->mtu,
2199 d->rx_credits, d->tx_credits);
2200 }
2201 }
2202
2203 rfcomm_unlock();
2204
2205 return 0;
2206}
2207
2208DEFINE_SHOW_ATTRIBUTE(rfcomm_dlc_debugfs);
2209
2210static struct dentry *rfcomm_dlc_debugfs;
2211
2212/* ---- Initialization ---- */
2213static int __init rfcomm_init(void)
2214{
2215 int err;
2216
2217 hci_register_cb(&rfcomm_cb);
2218
2219 rfcomm_thread = kthread_run(rfcomm_run, NULL, "krfcommd");
2220 if (IS_ERR(rfcomm_thread)) {
2221 err = PTR_ERR(rfcomm_thread);
2222 goto unregister;
2223 }
2224
2225 err = rfcomm_init_ttys();
2226 if (err < 0)
2227 goto stop;
2228
2229 err = rfcomm_init_sockets();
2230 if (err < 0)
2231 goto cleanup;
2232
2233 BT_INFO("RFCOMM ver %s", VERSION);
2234
2235 if (IS_ERR_OR_NULL(bt_debugfs))
2236 return 0;
2237
2238 rfcomm_dlc_debugfs = debugfs_create_file("rfcomm_dlc", 0444,
2239 bt_debugfs, NULL,
2240 &rfcomm_dlc_debugfs_fops);
2241
2242 return 0;
2243
2244cleanup:
2245 rfcomm_cleanup_ttys();
2246
2247stop:
2248 kthread_stop(rfcomm_thread);
2249
2250unregister:
2251 hci_unregister_cb(&rfcomm_cb);
2252
2253 return err;
2254}
2255
2256static void __exit rfcomm_exit(void)
2257{
2258 debugfs_remove(rfcomm_dlc_debugfs);
2259
2260 hci_unregister_cb(&rfcomm_cb);
2261
2262 kthread_stop(rfcomm_thread);
2263
2264 rfcomm_cleanup_ttys();
2265
2266 rfcomm_cleanup_sockets();
2267}
2268
2269module_init(rfcomm_init);
2270module_exit(rfcomm_exit);
2271
2272module_param(disable_cfc, bool, 0644);
2273MODULE_PARM_DESC(disable_cfc, "Disable credit based flow control");
2274
2275module_param(channel_mtu, int, 0644);
2276MODULE_PARM_DESC(channel_mtu, "Default MTU for the RFCOMM channel");
2277
2278module_param(l2cap_ertm, bool, 0644);
2279MODULE_PARM_DESC(l2cap_ertm, "Use L2CAP ERTM mode for connection");
2280
2281MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
2282MODULE_DESCRIPTION("Bluetooth RFCOMM ver " VERSION);
2283MODULE_VERSION(VERSION);
2284MODULE_LICENSE("GPL");
2285MODULE_ALIAS("bt-proto-3");
1/*
2 RFCOMM implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
4 Copyright (C) 2002 Marcel Holtmann <marcel@holtmann.org>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License version 2 as
8 published by the Free Software Foundation;
9
10 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
11 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
13 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
14 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
15 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18
19 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
21 SOFTWARE IS DISCLAIMED.
22*/
23
24/*
25 * Bluetooth RFCOMM core.
26 */
27
28#include <linux/module.h>
29#include <linux/debugfs.h>
30#include <linux/kthread.h>
31#include <asm/unaligned.h>
32
33#include <net/bluetooth/bluetooth.h>
34#include <net/bluetooth/hci_core.h>
35#include <net/bluetooth/l2cap.h>
36#include <net/bluetooth/rfcomm.h>
37
38#define VERSION "1.11"
39
40static bool disable_cfc;
41static bool l2cap_ertm;
42static int channel_mtu = -1;
43
44static struct task_struct *rfcomm_thread;
45
46static DEFINE_MUTEX(rfcomm_mutex);
47#define rfcomm_lock() mutex_lock(&rfcomm_mutex)
48#define rfcomm_unlock() mutex_unlock(&rfcomm_mutex)
49
50
51static LIST_HEAD(session_list);
52
53static int rfcomm_send_frame(struct rfcomm_session *s, u8 *data, int len);
54static int rfcomm_send_sabm(struct rfcomm_session *s, u8 dlci);
55static int rfcomm_send_disc(struct rfcomm_session *s, u8 dlci);
56static int rfcomm_queue_disc(struct rfcomm_dlc *d);
57static int rfcomm_send_nsc(struct rfcomm_session *s, int cr, u8 type);
58static int rfcomm_send_pn(struct rfcomm_session *s, int cr, struct rfcomm_dlc *d);
59static int rfcomm_send_msc(struct rfcomm_session *s, int cr, u8 dlci, u8 v24_sig);
60static int rfcomm_send_test(struct rfcomm_session *s, int cr, u8 *pattern, int len);
61static int rfcomm_send_credits(struct rfcomm_session *s, u8 addr, u8 credits);
62static void rfcomm_make_uih(struct sk_buff *skb, u8 addr);
63
64static void rfcomm_process_connect(struct rfcomm_session *s);
65
66static struct rfcomm_session *rfcomm_session_create(bdaddr_t *src,
67 bdaddr_t *dst,
68 u8 sec_level,
69 int *err);
70static struct rfcomm_session *rfcomm_session_get(bdaddr_t *src, bdaddr_t *dst);
71static struct rfcomm_session *rfcomm_session_del(struct rfcomm_session *s);
72
73/* ---- RFCOMM frame parsing macros ---- */
74#define __get_dlci(b) ((b & 0xfc) >> 2)
75#define __get_type(b) ((b & 0xef))
76
77#define __test_ea(b) ((b & 0x01))
78#define __test_cr(b) (!!(b & 0x02))
79#define __test_pf(b) (!!(b & 0x10))
80
81#define __session_dir(s) ((s)->initiator ? 0x00 : 0x01)
82
83#define __addr(cr, dlci) (((dlci & 0x3f) << 2) | (cr << 1) | 0x01)
84#define __ctrl(type, pf) (((type & 0xef) | (pf << 4)))
85#define __dlci(dir, chn) (((chn & 0x1f) << 1) | dir)
86#define __srv_channel(dlci) (dlci >> 1)
87
88#define __len8(len) (((len) << 1) | 1)
89#define __len16(len) ((len) << 1)
90
91/* MCC macros */
92#define __mcc_type(cr, type) (((type << 2) | (cr << 1) | 0x01))
93#define __get_mcc_type(b) ((b & 0xfc) >> 2)
94#define __get_mcc_len(b) ((b & 0xfe) >> 1)
95
96/* RPN macros */
97#define __rpn_line_settings(data, stop, parity) ((data & 0x3) | ((stop & 0x1) << 2) | ((parity & 0x7) << 3))
98#define __get_rpn_data_bits(line) ((line) & 0x3)
99#define __get_rpn_stop_bits(line) (((line) >> 2) & 0x1)
100#define __get_rpn_parity(line) (((line) >> 3) & 0x7)
101
102static DECLARE_WAIT_QUEUE_HEAD(rfcomm_wq);
103
104static void rfcomm_schedule(void)
105{
106 wake_up_all(&rfcomm_wq);
107}
108
109/* ---- RFCOMM FCS computation ---- */
110
111/* reversed, 8-bit, poly=0x07 */
112static unsigned char rfcomm_crc_table[256] = {
113 0x00, 0x91, 0xe3, 0x72, 0x07, 0x96, 0xe4, 0x75,
114 0x0e, 0x9f, 0xed, 0x7c, 0x09, 0x98, 0xea, 0x7b,
115 0x1c, 0x8d, 0xff, 0x6e, 0x1b, 0x8a, 0xf8, 0x69,
116 0x12, 0x83, 0xf1, 0x60, 0x15, 0x84, 0xf6, 0x67,
117
118 0x38, 0xa9, 0xdb, 0x4a, 0x3f, 0xae, 0xdc, 0x4d,
119 0x36, 0xa7, 0xd5, 0x44, 0x31, 0xa0, 0xd2, 0x43,
120 0x24, 0xb5, 0xc7, 0x56, 0x23, 0xb2, 0xc0, 0x51,
121 0x2a, 0xbb, 0xc9, 0x58, 0x2d, 0xbc, 0xce, 0x5f,
122
123 0x70, 0xe1, 0x93, 0x02, 0x77, 0xe6, 0x94, 0x05,
124 0x7e, 0xef, 0x9d, 0x0c, 0x79, 0xe8, 0x9a, 0x0b,
125 0x6c, 0xfd, 0x8f, 0x1e, 0x6b, 0xfa, 0x88, 0x19,
126 0x62, 0xf3, 0x81, 0x10, 0x65, 0xf4, 0x86, 0x17,
127
128 0x48, 0xd9, 0xab, 0x3a, 0x4f, 0xde, 0xac, 0x3d,
129 0x46, 0xd7, 0xa5, 0x34, 0x41, 0xd0, 0xa2, 0x33,
130 0x54, 0xc5, 0xb7, 0x26, 0x53, 0xc2, 0xb0, 0x21,
131 0x5a, 0xcb, 0xb9, 0x28, 0x5d, 0xcc, 0xbe, 0x2f,
132
133 0xe0, 0x71, 0x03, 0x92, 0xe7, 0x76, 0x04, 0x95,
134 0xee, 0x7f, 0x0d, 0x9c, 0xe9, 0x78, 0x0a, 0x9b,
135 0xfc, 0x6d, 0x1f, 0x8e, 0xfb, 0x6a, 0x18, 0x89,
136 0xf2, 0x63, 0x11, 0x80, 0xf5, 0x64, 0x16, 0x87,
137
138 0xd8, 0x49, 0x3b, 0xaa, 0xdf, 0x4e, 0x3c, 0xad,
139 0xd6, 0x47, 0x35, 0xa4, 0xd1, 0x40, 0x32, 0xa3,
140 0xc4, 0x55, 0x27, 0xb6, 0xc3, 0x52, 0x20, 0xb1,
141 0xca, 0x5b, 0x29, 0xb8, 0xcd, 0x5c, 0x2e, 0xbf,
142
143 0x90, 0x01, 0x73, 0xe2, 0x97, 0x06, 0x74, 0xe5,
144 0x9e, 0x0f, 0x7d, 0xec, 0x99, 0x08, 0x7a, 0xeb,
145 0x8c, 0x1d, 0x6f, 0xfe, 0x8b, 0x1a, 0x68, 0xf9,
146 0x82, 0x13, 0x61, 0xf0, 0x85, 0x14, 0x66, 0xf7,
147
148 0xa8, 0x39, 0x4b, 0xda, 0xaf, 0x3e, 0x4c, 0xdd,
149 0xa6, 0x37, 0x45, 0xd4, 0xa1, 0x30, 0x42, 0xd3,
150 0xb4, 0x25, 0x57, 0xc6, 0xb3, 0x22, 0x50, 0xc1,
151 0xba, 0x2b, 0x59, 0xc8, 0xbd, 0x2c, 0x5e, 0xcf
152};
153
154/* CRC on 2 bytes */
155#define __crc(data) (rfcomm_crc_table[rfcomm_crc_table[0xff ^ data[0]] ^ data[1]])
156
157/* FCS on 2 bytes */
158static inline u8 __fcs(u8 *data)
159{
160 return 0xff - __crc(data);
161}
162
163/* FCS on 3 bytes */
164static inline u8 __fcs2(u8 *data)
165{
166 return 0xff - rfcomm_crc_table[__crc(data) ^ data[2]];
167}
168
169/* Check FCS */
170static inline int __check_fcs(u8 *data, int type, u8 fcs)
171{
172 u8 f = __crc(data);
173
174 if (type != RFCOMM_UIH)
175 f = rfcomm_crc_table[f ^ data[2]];
176
177 return rfcomm_crc_table[f ^ fcs] != 0xcf;
178}
179
180/* ---- L2CAP callbacks ---- */
181static void rfcomm_l2state_change(struct sock *sk)
182{
183 BT_DBG("%p state %d", sk, sk->sk_state);
184 rfcomm_schedule();
185}
186
187static void rfcomm_l2data_ready(struct sock *sk)
188{
189 BT_DBG("%p", sk);
190 rfcomm_schedule();
191}
192
193static int rfcomm_l2sock_create(struct socket **sock)
194{
195 int err;
196
197 BT_DBG("");
198
199 err = sock_create_kern(&init_net, PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP, sock);
200 if (!err) {
201 struct sock *sk = (*sock)->sk;
202 sk->sk_data_ready = rfcomm_l2data_ready;
203 sk->sk_state_change = rfcomm_l2state_change;
204 }
205 return err;
206}
207
208static int rfcomm_check_security(struct rfcomm_dlc *d)
209{
210 struct sock *sk = d->session->sock->sk;
211 struct l2cap_conn *conn = l2cap_pi(sk)->chan->conn;
212
213 __u8 auth_type;
214
215 switch (d->sec_level) {
216 case BT_SECURITY_HIGH:
217 case BT_SECURITY_FIPS:
218 auth_type = HCI_AT_GENERAL_BONDING_MITM;
219 break;
220 case BT_SECURITY_MEDIUM:
221 auth_type = HCI_AT_GENERAL_BONDING;
222 break;
223 default:
224 auth_type = HCI_AT_NO_BONDING;
225 break;
226 }
227
228 return hci_conn_security(conn->hcon, d->sec_level, auth_type,
229 d->out);
230}
231
232static void rfcomm_session_timeout(struct timer_list *t)
233{
234 struct rfcomm_session *s = from_timer(s, t, timer);
235
236 BT_DBG("session %p state %ld", s, s->state);
237
238 set_bit(RFCOMM_TIMED_OUT, &s->flags);
239 rfcomm_schedule();
240}
241
242static void rfcomm_session_set_timer(struct rfcomm_session *s, long timeout)
243{
244 BT_DBG("session %p state %ld timeout %ld", s, s->state, timeout);
245
246 mod_timer(&s->timer, jiffies + timeout);
247}
248
249static void rfcomm_session_clear_timer(struct rfcomm_session *s)
250{
251 BT_DBG("session %p state %ld", s, s->state);
252
253 del_timer_sync(&s->timer);
254}
255
256/* ---- RFCOMM DLCs ---- */
257static void rfcomm_dlc_timeout(struct timer_list *t)
258{
259 struct rfcomm_dlc *d = from_timer(d, t, timer);
260
261 BT_DBG("dlc %p state %ld", d, d->state);
262
263 set_bit(RFCOMM_TIMED_OUT, &d->flags);
264 rfcomm_dlc_put(d);
265 rfcomm_schedule();
266}
267
268static void rfcomm_dlc_set_timer(struct rfcomm_dlc *d, long timeout)
269{
270 BT_DBG("dlc %p state %ld timeout %ld", d, d->state, timeout);
271
272 if (!mod_timer(&d->timer, jiffies + timeout))
273 rfcomm_dlc_hold(d);
274}
275
276static void rfcomm_dlc_clear_timer(struct rfcomm_dlc *d)
277{
278 BT_DBG("dlc %p state %ld", d, d->state);
279
280 if (del_timer(&d->timer))
281 rfcomm_dlc_put(d);
282}
283
284static void rfcomm_dlc_clear_state(struct rfcomm_dlc *d)
285{
286 BT_DBG("%p", d);
287
288 d->state = BT_OPEN;
289 d->flags = 0;
290 d->mscex = 0;
291 d->sec_level = BT_SECURITY_LOW;
292 d->mtu = RFCOMM_DEFAULT_MTU;
293 d->v24_sig = RFCOMM_V24_RTC | RFCOMM_V24_RTR | RFCOMM_V24_DV;
294
295 d->cfc = RFCOMM_CFC_DISABLED;
296 d->rx_credits = RFCOMM_DEFAULT_CREDITS;
297}
298
299struct rfcomm_dlc *rfcomm_dlc_alloc(gfp_t prio)
300{
301 struct rfcomm_dlc *d = kzalloc(sizeof(*d), prio);
302
303 if (!d)
304 return NULL;
305
306 timer_setup(&d->timer, rfcomm_dlc_timeout, 0);
307
308 skb_queue_head_init(&d->tx_queue);
309 mutex_init(&d->lock);
310 refcount_set(&d->refcnt, 1);
311
312 rfcomm_dlc_clear_state(d);
313
314 BT_DBG("%p", d);
315
316 return d;
317}
318
319void rfcomm_dlc_free(struct rfcomm_dlc *d)
320{
321 BT_DBG("%p", d);
322
323 skb_queue_purge(&d->tx_queue);
324 kfree(d);
325}
326
327static void rfcomm_dlc_link(struct rfcomm_session *s, struct rfcomm_dlc *d)
328{
329 BT_DBG("dlc %p session %p", d, s);
330
331 rfcomm_session_clear_timer(s);
332 rfcomm_dlc_hold(d);
333 list_add(&d->list, &s->dlcs);
334 d->session = s;
335}
336
337static void rfcomm_dlc_unlink(struct rfcomm_dlc *d)
338{
339 struct rfcomm_session *s = d->session;
340
341 BT_DBG("dlc %p refcnt %d session %p", d, refcount_read(&d->refcnt), s);
342
343 list_del(&d->list);
344 d->session = NULL;
345 rfcomm_dlc_put(d);
346
347 if (list_empty(&s->dlcs))
348 rfcomm_session_set_timer(s, RFCOMM_IDLE_TIMEOUT);
349}
350
351static struct rfcomm_dlc *rfcomm_dlc_get(struct rfcomm_session *s, u8 dlci)
352{
353 struct rfcomm_dlc *d;
354
355 list_for_each_entry(d, &s->dlcs, list)
356 if (d->dlci == dlci)
357 return d;
358
359 return NULL;
360}
361
362static int rfcomm_check_channel(u8 channel)
363{
364 return channel < 1 || channel > 30;
365}
366
367static int __rfcomm_dlc_open(struct rfcomm_dlc *d, bdaddr_t *src, bdaddr_t *dst, u8 channel)
368{
369 struct rfcomm_session *s;
370 int err = 0;
371 u8 dlci;
372
373 BT_DBG("dlc %p state %ld %pMR -> %pMR channel %d",
374 d, d->state, src, dst, channel);
375
376 if (rfcomm_check_channel(channel))
377 return -EINVAL;
378
379 if (d->state != BT_OPEN && d->state != BT_CLOSED)
380 return 0;
381
382 s = rfcomm_session_get(src, dst);
383 if (!s) {
384 s = rfcomm_session_create(src, dst, d->sec_level, &err);
385 if (!s)
386 return err;
387 }
388
389 dlci = __dlci(__session_dir(s), channel);
390
391 /* Check if DLCI already exists */
392 if (rfcomm_dlc_get(s, dlci))
393 return -EBUSY;
394
395 rfcomm_dlc_clear_state(d);
396
397 d->dlci = dlci;
398 d->addr = __addr(s->initiator, dlci);
399 d->priority = 7;
400
401 d->state = BT_CONFIG;
402 rfcomm_dlc_link(s, d);
403
404 d->out = 1;
405
406 d->mtu = s->mtu;
407 d->cfc = (s->cfc == RFCOMM_CFC_UNKNOWN) ? 0 : s->cfc;
408
409 if (s->state == BT_CONNECTED) {
410 if (rfcomm_check_security(d))
411 rfcomm_send_pn(s, 1, d);
412 else
413 set_bit(RFCOMM_AUTH_PENDING, &d->flags);
414 }
415
416 rfcomm_dlc_set_timer(d, RFCOMM_CONN_TIMEOUT);
417
418 return 0;
419}
420
421int rfcomm_dlc_open(struct rfcomm_dlc *d, bdaddr_t *src, bdaddr_t *dst, u8 channel)
422{
423 int r;
424
425 rfcomm_lock();
426
427 r = __rfcomm_dlc_open(d, src, dst, channel);
428
429 rfcomm_unlock();
430 return r;
431}
432
433static void __rfcomm_dlc_disconn(struct rfcomm_dlc *d)
434{
435 struct rfcomm_session *s = d->session;
436
437 d->state = BT_DISCONN;
438 if (skb_queue_empty(&d->tx_queue)) {
439 rfcomm_send_disc(s, d->dlci);
440 rfcomm_dlc_set_timer(d, RFCOMM_DISC_TIMEOUT);
441 } else {
442 rfcomm_queue_disc(d);
443 rfcomm_dlc_set_timer(d, RFCOMM_DISC_TIMEOUT * 2);
444 }
445}
446
447static int __rfcomm_dlc_close(struct rfcomm_dlc *d, int err)
448{
449 struct rfcomm_session *s = d->session;
450 if (!s)
451 return 0;
452
453 BT_DBG("dlc %p state %ld dlci %d err %d session %p",
454 d, d->state, d->dlci, err, s);
455
456 switch (d->state) {
457 case BT_CONNECT:
458 case BT_CONFIG:
459 case BT_OPEN:
460 case BT_CONNECT2:
461 if (test_and_clear_bit(RFCOMM_DEFER_SETUP, &d->flags)) {
462 set_bit(RFCOMM_AUTH_REJECT, &d->flags);
463 rfcomm_schedule();
464 return 0;
465 }
466 }
467
468 switch (d->state) {
469 case BT_CONNECT:
470 case BT_CONNECTED:
471 __rfcomm_dlc_disconn(d);
472 break;
473
474 case BT_CONFIG:
475 if (s->state != BT_BOUND) {
476 __rfcomm_dlc_disconn(d);
477 break;
478 }
479 /* if closing a dlc in a session that hasn't been started,
480 * just close and unlink the dlc
481 */
482 fallthrough;
483
484 default:
485 rfcomm_dlc_clear_timer(d);
486
487 rfcomm_dlc_lock(d);
488 d->state = BT_CLOSED;
489 d->state_change(d, err);
490 rfcomm_dlc_unlock(d);
491
492 skb_queue_purge(&d->tx_queue);
493 rfcomm_dlc_unlink(d);
494 }
495
496 return 0;
497}
498
499int rfcomm_dlc_close(struct rfcomm_dlc *d, int err)
500{
501 int r = 0;
502 struct rfcomm_dlc *d_list;
503 struct rfcomm_session *s, *s_list;
504
505 BT_DBG("dlc %p state %ld dlci %d err %d", d, d->state, d->dlci, err);
506
507 rfcomm_lock();
508
509 s = d->session;
510 if (!s)
511 goto no_session;
512
513 /* after waiting on the mutex check the session still exists
514 * then check the dlc still exists
515 */
516 list_for_each_entry(s_list, &session_list, list) {
517 if (s_list == s) {
518 list_for_each_entry(d_list, &s->dlcs, list) {
519 if (d_list == d) {
520 r = __rfcomm_dlc_close(d, err);
521 break;
522 }
523 }
524 break;
525 }
526 }
527
528no_session:
529 rfcomm_unlock();
530 return r;
531}
532
533struct rfcomm_dlc *rfcomm_dlc_exists(bdaddr_t *src, bdaddr_t *dst, u8 channel)
534{
535 struct rfcomm_session *s;
536 struct rfcomm_dlc *dlc = NULL;
537 u8 dlci;
538
539 if (rfcomm_check_channel(channel))
540 return ERR_PTR(-EINVAL);
541
542 rfcomm_lock();
543 s = rfcomm_session_get(src, dst);
544 if (s) {
545 dlci = __dlci(__session_dir(s), channel);
546 dlc = rfcomm_dlc_get(s, dlci);
547 }
548 rfcomm_unlock();
549 return dlc;
550}
551
552static int rfcomm_dlc_send_frag(struct rfcomm_dlc *d, struct sk_buff *frag)
553{
554 int len = frag->len;
555
556 BT_DBG("dlc %p mtu %d len %d", d, d->mtu, len);
557
558 if (len > d->mtu)
559 return -EINVAL;
560
561 rfcomm_make_uih(frag, d->addr);
562 __skb_queue_tail(&d->tx_queue, frag);
563
564 return len;
565}
566
567int rfcomm_dlc_send(struct rfcomm_dlc *d, struct sk_buff *skb)
568{
569 unsigned long flags;
570 struct sk_buff *frag, *next;
571 int len;
572
573 if (d->state != BT_CONNECTED)
574 return -ENOTCONN;
575
576 frag = skb_shinfo(skb)->frag_list;
577 skb_shinfo(skb)->frag_list = NULL;
578
579 /* Queue all fragments atomically. */
580 spin_lock_irqsave(&d->tx_queue.lock, flags);
581
582 len = rfcomm_dlc_send_frag(d, skb);
583 if (len < 0 || !frag)
584 goto unlock;
585
586 for (; frag; frag = next) {
587 int ret;
588
589 next = frag->next;
590
591 ret = rfcomm_dlc_send_frag(d, frag);
592 if (ret < 0) {
593 dev_kfree_skb_irq(frag);
594 goto unlock;
595 }
596
597 len += ret;
598 }
599
600unlock:
601 spin_unlock_irqrestore(&d->tx_queue.lock, flags);
602
603 if (len > 0 && !test_bit(RFCOMM_TX_THROTTLED, &d->flags))
604 rfcomm_schedule();
605 return len;
606}
607
608void rfcomm_dlc_send_noerror(struct rfcomm_dlc *d, struct sk_buff *skb)
609{
610 int len = skb->len;
611
612 BT_DBG("dlc %p mtu %d len %d", d, d->mtu, len);
613
614 rfcomm_make_uih(skb, d->addr);
615 skb_queue_tail(&d->tx_queue, skb);
616
617 if (d->state == BT_CONNECTED &&
618 !test_bit(RFCOMM_TX_THROTTLED, &d->flags))
619 rfcomm_schedule();
620}
621
622void __rfcomm_dlc_throttle(struct rfcomm_dlc *d)
623{
624 BT_DBG("dlc %p state %ld", d, d->state);
625
626 if (!d->cfc) {
627 d->v24_sig |= RFCOMM_V24_FC;
628 set_bit(RFCOMM_MSC_PENDING, &d->flags);
629 }
630 rfcomm_schedule();
631}
632
633void __rfcomm_dlc_unthrottle(struct rfcomm_dlc *d)
634{
635 BT_DBG("dlc %p state %ld", d, d->state);
636
637 if (!d->cfc) {
638 d->v24_sig &= ~RFCOMM_V24_FC;
639 set_bit(RFCOMM_MSC_PENDING, &d->flags);
640 }
641 rfcomm_schedule();
642}
643
644/*
645 Set/get modem status functions use _local_ status i.e. what we report
646 to the other side.
647 Remote status is provided by dlc->modem_status() callback.
648 */
649int rfcomm_dlc_set_modem_status(struct rfcomm_dlc *d, u8 v24_sig)
650{
651 BT_DBG("dlc %p state %ld v24_sig 0x%x",
652 d, d->state, v24_sig);
653
654 if (test_bit(RFCOMM_RX_THROTTLED, &d->flags))
655 v24_sig |= RFCOMM_V24_FC;
656 else
657 v24_sig &= ~RFCOMM_V24_FC;
658
659 d->v24_sig = v24_sig;
660
661 if (!test_and_set_bit(RFCOMM_MSC_PENDING, &d->flags))
662 rfcomm_schedule();
663
664 return 0;
665}
666
667int rfcomm_dlc_get_modem_status(struct rfcomm_dlc *d, u8 *v24_sig)
668{
669 BT_DBG("dlc %p state %ld v24_sig 0x%x",
670 d, d->state, d->v24_sig);
671
672 *v24_sig = d->v24_sig;
673 return 0;
674}
675
676/* ---- RFCOMM sessions ---- */
677static struct rfcomm_session *rfcomm_session_add(struct socket *sock, int state)
678{
679 struct rfcomm_session *s = kzalloc(sizeof(*s), GFP_KERNEL);
680
681 if (!s)
682 return NULL;
683
684 BT_DBG("session %p sock %p", s, sock);
685
686 timer_setup(&s->timer, rfcomm_session_timeout, 0);
687
688 INIT_LIST_HEAD(&s->dlcs);
689 s->state = state;
690 s->sock = sock;
691
692 s->mtu = RFCOMM_DEFAULT_MTU;
693 s->cfc = disable_cfc ? RFCOMM_CFC_DISABLED : RFCOMM_CFC_UNKNOWN;
694
695 /* Do not increment module usage count for listening sessions.
696 * Otherwise we won't be able to unload the module. */
697 if (state != BT_LISTEN)
698 if (!try_module_get(THIS_MODULE)) {
699 kfree(s);
700 return NULL;
701 }
702
703 list_add(&s->list, &session_list);
704
705 return s;
706}
707
708static struct rfcomm_session *rfcomm_session_del(struct rfcomm_session *s)
709{
710 int state = s->state;
711
712 BT_DBG("session %p state %ld", s, s->state);
713
714 list_del(&s->list);
715
716 rfcomm_session_clear_timer(s);
717 sock_release(s->sock);
718 kfree(s);
719
720 if (state != BT_LISTEN)
721 module_put(THIS_MODULE);
722
723 return NULL;
724}
725
726static struct rfcomm_session *rfcomm_session_get(bdaddr_t *src, bdaddr_t *dst)
727{
728 struct rfcomm_session *s, *n;
729 struct l2cap_chan *chan;
730 list_for_each_entry_safe(s, n, &session_list, list) {
731 chan = l2cap_pi(s->sock->sk)->chan;
732
733 if ((!bacmp(src, BDADDR_ANY) || !bacmp(&chan->src, src)) &&
734 !bacmp(&chan->dst, dst))
735 return s;
736 }
737 return NULL;
738}
739
740static struct rfcomm_session *rfcomm_session_close(struct rfcomm_session *s,
741 int err)
742{
743 struct rfcomm_dlc *d, *n;
744
745 s->state = BT_CLOSED;
746
747 BT_DBG("session %p state %ld err %d", s, s->state, err);
748
749 /* Close all dlcs */
750 list_for_each_entry_safe(d, n, &s->dlcs, list) {
751 d->state = BT_CLOSED;
752 __rfcomm_dlc_close(d, err);
753 }
754
755 rfcomm_session_clear_timer(s);
756 return rfcomm_session_del(s);
757}
758
759static struct rfcomm_session *rfcomm_session_create(bdaddr_t *src,
760 bdaddr_t *dst,
761 u8 sec_level,
762 int *err)
763{
764 struct rfcomm_session *s = NULL;
765 struct sockaddr_l2 addr;
766 struct socket *sock;
767 struct sock *sk;
768
769 BT_DBG("%pMR -> %pMR", src, dst);
770
771 *err = rfcomm_l2sock_create(&sock);
772 if (*err < 0)
773 return NULL;
774
775 bacpy(&addr.l2_bdaddr, src);
776 addr.l2_family = AF_BLUETOOTH;
777 addr.l2_psm = 0;
778 addr.l2_cid = 0;
779 addr.l2_bdaddr_type = BDADDR_BREDR;
780 *err = kernel_bind(sock, (struct sockaddr *) &addr, sizeof(addr));
781 if (*err < 0)
782 goto failed;
783
784 /* Set L2CAP options */
785 sk = sock->sk;
786 lock_sock(sk);
787 /* Set MTU to 0 so L2CAP can auto select the MTU */
788 l2cap_pi(sk)->chan->imtu = 0;
789 l2cap_pi(sk)->chan->sec_level = sec_level;
790 if (l2cap_ertm)
791 l2cap_pi(sk)->chan->mode = L2CAP_MODE_ERTM;
792 release_sock(sk);
793
794 s = rfcomm_session_add(sock, BT_BOUND);
795 if (!s) {
796 *err = -ENOMEM;
797 goto failed;
798 }
799
800 s->initiator = 1;
801
802 bacpy(&addr.l2_bdaddr, dst);
803 addr.l2_family = AF_BLUETOOTH;
804 addr.l2_psm = cpu_to_le16(L2CAP_PSM_RFCOMM);
805 addr.l2_cid = 0;
806 addr.l2_bdaddr_type = BDADDR_BREDR;
807 *err = kernel_connect(sock, (struct sockaddr *) &addr, sizeof(addr), O_NONBLOCK);
808 if (*err == 0 || *err == -EINPROGRESS)
809 return s;
810
811 return rfcomm_session_del(s);
812
813failed:
814 sock_release(sock);
815 return NULL;
816}
817
818void rfcomm_session_getaddr(struct rfcomm_session *s, bdaddr_t *src, bdaddr_t *dst)
819{
820 struct l2cap_chan *chan = l2cap_pi(s->sock->sk)->chan;
821 if (src)
822 bacpy(src, &chan->src);
823 if (dst)
824 bacpy(dst, &chan->dst);
825}
826
827/* ---- RFCOMM frame sending ---- */
828static int rfcomm_send_frame(struct rfcomm_session *s, u8 *data, int len)
829{
830 struct kvec iv = { data, len };
831 struct msghdr msg;
832
833 BT_DBG("session %p len %d", s, len);
834
835 memset(&msg, 0, sizeof(msg));
836
837 return kernel_sendmsg(s->sock, &msg, &iv, 1, len);
838}
839
840static int rfcomm_send_cmd(struct rfcomm_session *s, struct rfcomm_cmd *cmd)
841{
842 BT_DBG("%p cmd %u", s, cmd->ctrl);
843
844 return rfcomm_send_frame(s, (void *) cmd, sizeof(*cmd));
845}
846
847static int rfcomm_send_sabm(struct rfcomm_session *s, u8 dlci)
848{
849 struct rfcomm_cmd cmd;
850
851 BT_DBG("%p dlci %d", s, dlci);
852
853 cmd.addr = __addr(s->initiator, dlci);
854 cmd.ctrl = __ctrl(RFCOMM_SABM, 1);
855 cmd.len = __len8(0);
856 cmd.fcs = __fcs2((u8 *) &cmd);
857
858 return rfcomm_send_cmd(s, &cmd);
859}
860
861static int rfcomm_send_ua(struct rfcomm_session *s, u8 dlci)
862{
863 struct rfcomm_cmd cmd;
864
865 BT_DBG("%p dlci %d", s, dlci);
866
867 cmd.addr = __addr(!s->initiator, dlci);
868 cmd.ctrl = __ctrl(RFCOMM_UA, 1);
869 cmd.len = __len8(0);
870 cmd.fcs = __fcs2((u8 *) &cmd);
871
872 return rfcomm_send_cmd(s, &cmd);
873}
874
875static int rfcomm_send_disc(struct rfcomm_session *s, u8 dlci)
876{
877 struct rfcomm_cmd cmd;
878
879 BT_DBG("%p dlci %d", s, dlci);
880
881 cmd.addr = __addr(s->initiator, dlci);
882 cmd.ctrl = __ctrl(RFCOMM_DISC, 1);
883 cmd.len = __len8(0);
884 cmd.fcs = __fcs2((u8 *) &cmd);
885
886 return rfcomm_send_cmd(s, &cmd);
887}
888
889static int rfcomm_queue_disc(struct rfcomm_dlc *d)
890{
891 struct rfcomm_cmd *cmd;
892 struct sk_buff *skb;
893
894 BT_DBG("dlc %p dlci %d", d, d->dlci);
895
896 skb = alloc_skb(sizeof(*cmd), GFP_KERNEL);
897 if (!skb)
898 return -ENOMEM;
899
900 cmd = __skb_put(skb, sizeof(*cmd));
901 cmd->addr = d->addr;
902 cmd->ctrl = __ctrl(RFCOMM_DISC, 1);
903 cmd->len = __len8(0);
904 cmd->fcs = __fcs2((u8 *) cmd);
905
906 skb_queue_tail(&d->tx_queue, skb);
907 rfcomm_schedule();
908 return 0;
909}
910
911static int rfcomm_send_dm(struct rfcomm_session *s, u8 dlci)
912{
913 struct rfcomm_cmd cmd;
914
915 BT_DBG("%p dlci %d", s, dlci);
916
917 cmd.addr = __addr(!s->initiator, dlci);
918 cmd.ctrl = __ctrl(RFCOMM_DM, 1);
919 cmd.len = __len8(0);
920 cmd.fcs = __fcs2((u8 *) &cmd);
921
922 return rfcomm_send_cmd(s, &cmd);
923}
924
925static int rfcomm_send_nsc(struct rfcomm_session *s, int cr, u8 type)
926{
927 struct rfcomm_hdr *hdr;
928 struct rfcomm_mcc *mcc;
929 u8 buf[16], *ptr = buf;
930
931 BT_DBG("%p cr %d type %d", s, cr, type);
932
933 hdr = (void *) ptr; ptr += sizeof(*hdr);
934 hdr->addr = __addr(s->initiator, 0);
935 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
936 hdr->len = __len8(sizeof(*mcc) + 1);
937
938 mcc = (void *) ptr; ptr += sizeof(*mcc);
939 mcc->type = __mcc_type(0, RFCOMM_NSC);
940 mcc->len = __len8(1);
941
942 /* Type that we didn't like */
943 *ptr = __mcc_type(cr, type); ptr++;
944
945 *ptr = __fcs(buf); ptr++;
946
947 return rfcomm_send_frame(s, buf, ptr - buf);
948}
949
950static int rfcomm_send_pn(struct rfcomm_session *s, int cr, struct rfcomm_dlc *d)
951{
952 struct rfcomm_hdr *hdr;
953 struct rfcomm_mcc *mcc;
954 struct rfcomm_pn *pn;
955 u8 buf[16], *ptr = buf;
956
957 BT_DBG("%p cr %d dlci %d mtu %d", s, cr, d->dlci, d->mtu);
958
959 hdr = (void *) ptr; ptr += sizeof(*hdr);
960 hdr->addr = __addr(s->initiator, 0);
961 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
962 hdr->len = __len8(sizeof(*mcc) + sizeof(*pn));
963
964 mcc = (void *) ptr; ptr += sizeof(*mcc);
965 mcc->type = __mcc_type(cr, RFCOMM_PN);
966 mcc->len = __len8(sizeof(*pn));
967
968 pn = (void *) ptr; ptr += sizeof(*pn);
969 pn->dlci = d->dlci;
970 pn->priority = d->priority;
971 pn->ack_timer = 0;
972 pn->max_retrans = 0;
973
974 if (s->cfc) {
975 pn->flow_ctrl = cr ? 0xf0 : 0xe0;
976 pn->credits = RFCOMM_DEFAULT_CREDITS;
977 } else {
978 pn->flow_ctrl = 0;
979 pn->credits = 0;
980 }
981
982 if (cr && channel_mtu >= 0)
983 pn->mtu = cpu_to_le16(channel_mtu);
984 else
985 pn->mtu = cpu_to_le16(d->mtu);
986
987 *ptr = __fcs(buf); ptr++;
988
989 return rfcomm_send_frame(s, buf, ptr - buf);
990}
991
992int rfcomm_send_rpn(struct rfcomm_session *s, int cr, u8 dlci,
993 u8 bit_rate, u8 data_bits, u8 stop_bits,
994 u8 parity, u8 flow_ctrl_settings,
995 u8 xon_char, u8 xoff_char, u16 param_mask)
996{
997 struct rfcomm_hdr *hdr;
998 struct rfcomm_mcc *mcc;
999 struct rfcomm_rpn *rpn;
1000 u8 buf[16], *ptr = buf;
1001
1002 BT_DBG("%p cr %d dlci %d bit_r 0x%x data_b 0x%x stop_b 0x%x parity 0x%x"
1003 " flwc_s 0x%x xon_c 0x%x xoff_c 0x%x p_mask 0x%x",
1004 s, cr, dlci, bit_rate, data_bits, stop_bits, parity,
1005 flow_ctrl_settings, xon_char, xoff_char, param_mask);
1006
1007 hdr = (void *) ptr; ptr += sizeof(*hdr);
1008 hdr->addr = __addr(s->initiator, 0);
1009 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1010 hdr->len = __len8(sizeof(*mcc) + sizeof(*rpn));
1011
1012 mcc = (void *) ptr; ptr += sizeof(*mcc);
1013 mcc->type = __mcc_type(cr, RFCOMM_RPN);
1014 mcc->len = __len8(sizeof(*rpn));
1015
1016 rpn = (void *) ptr; ptr += sizeof(*rpn);
1017 rpn->dlci = __addr(1, dlci);
1018 rpn->bit_rate = bit_rate;
1019 rpn->line_settings = __rpn_line_settings(data_bits, stop_bits, parity);
1020 rpn->flow_ctrl = flow_ctrl_settings;
1021 rpn->xon_char = xon_char;
1022 rpn->xoff_char = xoff_char;
1023 rpn->param_mask = cpu_to_le16(param_mask);
1024
1025 *ptr = __fcs(buf); ptr++;
1026
1027 return rfcomm_send_frame(s, buf, ptr - buf);
1028}
1029
1030static int rfcomm_send_rls(struct rfcomm_session *s, int cr, u8 dlci, u8 status)
1031{
1032 struct rfcomm_hdr *hdr;
1033 struct rfcomm_mcc *mcc;
1034 struct rfcomm_rls *rls;
1035 u8 buf[16], *ptr = buf;
1036
1037 BT_DBG("%p cr %d status 0x%x", s, cr, status);
1038
1039 hdr = (void *) ptr; ptr += sizeof(*hdr);
1040 hdr->addr = __addr(s->initiator, 0);
1041 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1042 hdr->len = __len8(sizeof(*mcc) + sizeof(*rls));
1043
1044 mcc = (void *) ptr; ptr += sizeof(*mcc);
1045 mcc->type = __mcc_type(cr, RFCOMM_RLS);
1046 mcc->len = __len8(sizeof(*rls));
1047
1048 rls = (void *) ptr; ptr += sizeof(*rls);
1049 rls->dlci = __addr(1, dlci);
1050 rls->status = status;
1051
1052 *ptr = __fcs(buf); ptr++;
1053
1054 return rfcomm_send_frame(s, buf, ptr - buf);
1055}
1056
1057static int rfcomm_send_msc(struct rfcomm_session *s, int cr, u8 dlci, u8 v24_sig)
1058{
1059 struct rfcomm_hdr *hdr;
1060 struct rfcomm_mcc *mcc;
1061 struct rfcomm_msc *msc;
1062 u8 buf[16], *ptr = buf;
1063
1064 BT_DBG("%p cr %d v24 0x%x", s, cr, v24_sig);
1065
1066 hdr = (void *) ptr; ptr += sizeof(*hdr);
1067 hdr->addr = __addr(s->initiator, 0);
1068 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1069 hdr->len = __len8(sizeof(*mcc) + sizeof(*msc));
1070
1071 mcc = (void *) ptr; ptr += sizeof(*mcc);
1072 mcc->type = __mcc_type(cr, RFCOMM_MSC);
1073 mcc->len = __len8(sizeof(*msc));
1074
1075 msc = (void *) ptr; ptr += sizeof(*msc);
1076 msc->dlci = __addr(1, dlci);
1077 msc->v24_sig = v24_sig | 0x01;
1078
1079 *ptr = __fcs(buf); ptr++;
1080
1081 return rfcomm_send_frame(s, buf, ptr - buf);
1082}
1083
1084static int rfcomm_send_fcoff(struct rfcomm_session *s, int cr)
1085{
1086 struct rfcomm_hdr *hdr;
1087 struct rfcomm_mcc *mcc;
1088 u8 buf[16], *ptr = buf;
1089
1090 BT_DBG("%p cr %d", s, cr);
1091
1092 hdr = (void *) ptr; ptr += sizeof(*hdr);
1093 hdr->addr = __addr(s->initiator, 0);
1094 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1095 hdr->len = __len8(sizeof(*mcc));
1096
1097 mcc = (void *) ptr; ptr += sizeof(*mcc);
1098 mcc->type = __mcc_type(cr, RFCOMM_FCOFF);
1099 mcc->len = __len8(0);
1100
1101 *ptr = __fcs(buf); ptr++;
1102
1103 return rfcomm_send_frame(s, buf, ptr - buf);
1104}
1105
1106static int rfcomm_send_fcon(struct rfcomm_session *s, int cr)
1107{
1108 struct rfcomm_hdr *hdr;
1109 struct rfcomm_mcc *mcc;
1110 u8 buf[16], *ptr = buf;
1111
1112 BT_DBG("%p cr %d", s, cr);
1113
1114 hdr = (void *) ptr; ptr += sizeof(*hdr);
1115 hdr->addr = __addr(s->initiator, 0);
1116 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1117 hdr->len = __len8(sizeof(*mcc));
1118
1119 mcc = (void *) ptr; ptr += sizeof(*mcc);
1120 mcc->type = __mcc_type(cr, RFCOMM_FCON);
1121 mcc->len = __len8(0);
1122
1123 *ptr = __fcs(buf); ptr++;
1124
1125 return rfcomm_send_frame(s, buf, ptr - buf);
1126}
1127
1128static int rfcomm_send_test(struct rfcomm_session *s, int cr, u8 *pattern, int len)
1129{
1130 struct socket *sock = s->sock;
1131 struct kvec iv[3];
1132 struct msghdr msg;
1133 unsigned char hdr[5], crc[1];
1134
1135 if (len > 125)
1136 return -EINVAL;
1137
1138 BT_DBG("%p cr %d", s, cr);
1139
1140 hdr[0] = __addr(s->initiator, 0);
1141 hdr[1] = __ctrl(RFCOMM_UIH, 0);
1142 hdr[2] = 0x01 | ((len + 2) << 1);
1143 hdr[3] = 0x01 | ((cr & 0x01) << 1) | (RFCOMM_TEST << 2);
1144 hdr[4] = 0x01 | (len << 1);
1145
1146 crc[0] = __fcs(hdr);
1147
1148 iv[0].iov_base = hdr;
1149 iv[0].iov_len = 5;
1150 iv[1].iov_base = pattern;
1151 iv[1].iov_len = len;
1152 iv[2].iov_base = crc;
1153 iv[2].iov_len = 1;
1154
1155 memset(&msg, 0, sizeof(msg));
1156
1157 return kernel_sendmsg(sock, &msg, iv, 3, 6 + len);
1158}
1159
1160static int rfcomm_send_credits(struct rfcomm_session *s, u8 addr, u8 credits)
1161{
1162 struct rfcomm_hdr *hdr;
1163 u8 buf[16], *ptr = buf;
1164
1165 BT_DBG("%p addr %d credits %d", s, addr, credits);
1166
1167 hdr = (void *) ptr; ptr += sizeof(*hdr);
1168 hdr->addr = addr;
1169 hdr->ctrl = __ctrl(RFCOMM_UIH, 1);
1170 hdr->len = __len8(0);
1171
1172 *ptr = credits; ptr++;
1173
1174 *ptr = __fcs(buf); ptr++;
1175
1176 return rfcomm_send_frame(s, buf, ptr - buf);
1177}
1178
1179static void rfcomm_make_uih(struct sk_buff *skb, u8 addr)
1180{
1181 struct rfcomm_hdr *hdr;
1182 int len = skb->len;
1183 u8 *crc;
1184
1185 if (len > 127) {
1186 hdr = skb_push(skb, 4);
1187 put_unaligned(cpu_to_le16(__len16(len)), (__le16 *) &hdr->len);
1188 } else {
1189 hdr = skb_push(skb, 3);
1190 hdr->len = __len8(len);
1191 }
1192 hdr->addr = addr;
1193 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1194
1195 crc = skb_put(skb, 1);
1196 *crc = __fcs((void *) hdr);
1197}
1198
1199/* ---- RFCOMM frame reception ---- */
1200static struct rfcomm_session *rfcomm_recv_ua(struct rfcomm_session *s, u8 dlci)
1201{
1202 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1203
1204 if (dlci) {
1205 /* Data channel */
1206 struct rfcomm_dlc *d = rfcomm_dlc_get(s, dlci);
1207 if (!d) {
1208 rfcomm_send_dm(s, dlci);
1209 return s;
1210 }
1211
1212 switch (d->state) {
1213 case BT_CONNECT:
1214 rfcomm_dlc_clear_timer(d);
1215
1216 rfcomm_dlc_lock(d);
1217 d->state = BT_CONNECTED;
1218 d->state_change(d, 0);
1219 rfcomm_dlc_unlock(d);
1220
1221 rfcomm_send_msc(s, 1, dlci, d->v24_sig);
1222 break;
1223
1224 case BT_DISCONN:
1225 d->state = BT_CLOSED;
1226 __rfcomm_dlc_close(d, 0);
1227
1228 if (list_empty(&s->dlcs)) {
1229 s->state = BT_DISCONN;
1230 rfcomm_send_disc(s, 0);
1231 rfcomm_session_clear_timer(s);
1232 }
1233
1234 break;
1235 }
1236 } else {
1237 /* Control channel */
1238 switch (s->state) {
1239 case BT_CONNECT:
1240 s->state = BT_CONNECTED;
1241 rfcomm_process_connect(s);
1242 break;
1243
1244 case BT_DISCONN:
1245 s = rfcomm_session_close(s, ECONNRESET);
1246 break;
1247 }
1248 }
1249 return s;
1250}
1251
1252static struct rfcomm_session *rfcomm_recv_dm(struct rfcomm_session *s, u8 dlci)
1253{
1254 int err = 0;
1255
1256 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1257
1258 if (dlci) {
1259 /* Data DLC */
1260 struct rfcomm_dlc *d = rfcomm_dlc_get(s, dlci);
1261 if (d) {
1262 if (d->state == BT_CONNECT || d->state == BT_CONFIG)
1263 err = ECONNREFUSED;
1264 else
1265 err = ECONNRESET;
1266
1267 d->state = BT_CLOSED;
1268 __rfcomm_dlc_close(d, err);
1269 }
1270 } else {
1271 if (s->state == BT_CONNECT)
1272 err = ECONNREFUSED;
1273 else
1274 err = ECONNRESET;
1275
1276 s = rfcomm_session_close(s, err);
1277 }
1278 return s;
1279}
1280
1281static struct rfcomm_session *rfcomm_recv_disc(struct rfcomm_session *s,
1282 u8 dlci)
1283{
1284 int err = 0;
1285
1286 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1287
1288 if (dlci) {
1289 struct rfcomm_dlc *d = rfcomm_dlc_get(s, dlci);
1290 if (d) {
1291 rfcomm_send_ua(s, dlci);
1292
1293 if (d->state == BT_CONNECT || d->state == BT_CONFIG)
1294 err = ECONNREFUSED;
1295 else
1296 err = ECONNRESET;
1297
1298 d->state = BT_CLOSED;
1299 __rfcomm_dlc_close(d, err);
1300 } else
1301 rfcomm_send_dm(s, dlci);
1302
1303 } else {
1304 rfcomm_send_ua(s, 0);
1305
1306 if (s->state == BT_CONNECT)
1307 err = ECONNREFUSED;
1308 else
1309 err = ECONNRESET;
1310
1311 s = rfcomm_session_close(s, err);
1312 }
1313 return s;
1314}
1315
1316void rfcomm_dlc_accept(struct rfcomm_dlc *d)
1317{
1318 struct sock *sk = d->session->sock->sk;
1319 struct l2cap_conn *conn = l2cap_pi(sk)->chan->conn;
1320
1321 BT_DBG("dlc %p", d);
1322
1323 rfcomm_send_ua(d->session, d->dlci);
1324
1325 rfcomm_dlc_clear_timer(d);
1326
1327 rfcomm_dlc_lock(d);
1328 d->state = BT_CONNECTED;
1329 d->state_change(d, 0);
1330 rfcomm_dlc_unlock(d);
1331
1332 if (d->role_switch)
1333 hci_conn_switch_role(conn->hcon, 0x00);
1334
1335 rfcomm_send_msc(d->session, 1, d->dlci, d->v24_sig);
1336}
1337
1338static void rfcomm_check_accept(struct rfcomm_dlc *d)
1339{
1340 if (rfcomm_check_security(d)) {
1341 if (d->defer_setup) {
1342 set_bit(RFCOMM_DEFER_SETUP, &d->flags);
1343 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
1344
1345 rfcomm_dlc_lock(d);
1346 d->state = BT_CONNECT2;
1347 d->state_change(d, 0);
1348 rfcomm_dlc_unlock(d);
1349 } else
1350 rfcomm_dlc_accept(d);
1351 } else {
1352 set_bit(RFCOMM_AUTH_PENDING, &d->flags);
1353 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
1354 }
1355}
1356
1357static int rfcomm_recv_sabm(struct rfcomm_session *s, u8 dlci)
1358{
1359 struct rfcomm_dlc *d;
1360 u8 channel;
1361
1362 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1363
1364 if (!dlci) {
1365 rfcomm_send_ua(s, 0);
1366
1367 if (s->state == BT_OPEN) {
1368 s->state = BT_CONNECTED;
1369 rfcomm_process_connect(s);
1370 }
1371 return 0;
1372 }
1373
1374 /* Check if DLC exists */
1375 d = rfcomm_dlc_get(s, dlci);
1376 if (d) {
1377 if (d->state == BT_OPEN) {
1378 /* DLC was previously opened by PN request */
1379 rfcomm_check_accept(d);
1380 }
1381 return 0;
1382 }
1383
1384 /* Notify socket layer about incoming connection */
1385 channel = __srv_channel(dlci);
1386 if (rfcomm_connect_ind(s, channel, &d)) {
1387 d->dlci = dlci;
1388 d->addr = __addr(s->initiator, dlci);
1389 rfcomm_dlc_link(s, d);
1390
1391 rfcomm_check_accept(d);
1392 } else {
1393 rfcomm_send_dm(s, dlci);
1394 }
1395
1396 return 0;
1397}
1398
1399static int rfcomm_apply_pn(struct rfcomm_dlc *d, int cr, struct rfcomm_pn *pn)
1400{
1401 struct rfcomm_session *s = d->session;
1402
1403 BT_DBG("dlc %p state %ld dlci %d mtu %d fc 0x%x credits %d",
1404 d, d->state, d->dlci, pn->mtu, pn->flow_ctrl, pn->credits);
1405
1406 if ((pn->flow_ctrl == 0xf0 && s->cfc != RFCOMM_CFC_DISABLED) ||
1407 pn->flow_ctrl == 0xe0) {
1408 d->cfc = RFCOMM_CFC_ENABLED;
1409 d->tx_credits = pn->credits;
1410 } else {
1411 d->cfc = RFCOMM_CFC_DISABLED;
1412 set_bit(RFCOMM_TX_THROTTLED, &d->flags);
1413 }
1414
1415 if (s->cfc == RFCOMM_CFC_UNKNOWN)
1416 s->cfc = d->cfc;
1417
1418 d->priority = pn->priority;
1419
1420 d->mtu = __le16_to_cpu(pn->mtu);
1421
1422 if (cr && d->mtu > s->mtu)
1423 d->mtu = s->mtu;
1424
1425 return 0;
1426}
1427
1428static int rfcomm_recv_pn(struct rfcomm_session *s, int cr, struct sk_buff *skb)
1429{
1430 struct rfcomm_pn *pn = (void *) skb->data;
1431 struct rfcomm_dlc *d;
1432 u8 dlci = pn->dlci;
1433
1434 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1435
1436 if (!dlci)
1437 return 0;
1438
1439 d = rfcomm_dlc_get(s, dlci);
1440 if (d) {
1441 if (cr) {
1442 /* PN request */
1443 rfcomm_apply_pn(d, cr, pn);
1444 rfcomm_send_pn(s, 0, d);
1445 } else {
1446 /* PN response */
1447 switch (d->state) {
1448 case BT_CONFIG:
1449 rfcomm_apply_pn(d, cr, pn);
1450
1451 d->state = BT_CONNECT;
1452 rfcomm_send_sabm(s, d->dlci);
1453 break;
1454 }
1455 }
1456 } else {
1457 u8 channel = __srv_channel(dlci);
1458
1459 if (!cr)
1460 return 0;
1461
1462 /* PN request for non existing DLC.
1463 * Assume incoming connection. */
1464 if (rfcomm_connect_ind(s, channel, &d)) {
1465 d->dlci = dlci;
1466 d->addr = __addr(s->initiator, dlci);
1467 rfcomm_dlc_link(s, d);
1468
1469 rfcomm_apply_pn(d, cr, pn);
1470
1471 d->state = BT_OPEN;
1472 rfcomm_send_pn(s, 0, d);
1473 } else {
1474 rfcomm_send_dm(s, dlci);
1475 }
1476 }
1477 return 0;
1478}
1479
1480static int rfcomm_recv_rpn(struct rfcomm_session *s, int cr, int len, struct sk_buff *skb)
1481{
1482 struct rfcomm_rpn *rpn = (void *) skb->data;
1483 u8 dlci = __get_dlci(rpn->dlci);
1484
1485 u8 bit_rate = 0;
1486 u8 data_bits = 0;
1487 u8 stop_bits = 0;
1488 u8 parity = 0;
1489 u8 flow_ctrl = 0;
1490 u8 xon_char = 0;
1491 u8 xoff_char = 0;
1492 u16 rpn_mask = RFCOMM_RPN_PM_ALL;
1493
1494 BT_DBG("dlci %d cr %d len 0x%x bitr 0x%x line 0x%x flow 0x%x xonc 0x%x xoffc 0x%x pm 0x%x",
1495 dlci, cr, len, rpn->bit_rate, rpn->line_settings, rpn->flow_ctrl,
1496 rpn->xon_char, rpn->xoff_char, rpn->param_mask);
1497
1498 if (!cr)
1499 return 0;
1500
1501 if (len == 1) {
1502 /* This is a request, return default (according to ETSI TS 07.10) settings */
1503 bit_rate = RFCOMM_RPN_BR_9600;
1504 data_bits = RFCOMM_RPN_DATA_8;
1505 stop_bits = RFCOMM_RPN_STOP_1;
1506 parity = RFCOMM_RPN_PARITY_NONE;
1507 flow_ctrl = RFCOMM_RPN_FLOW_NONE;
1508 xon_char = RFCOMM_RPN_XON_CHAR;
1509 xoff_char = RFCOMM_RPN_XOFF_CHAR;
1510 goto rpn_out;
1511 }
1512
1513 /* Check for sane values, ignore/accept bit_rate, 8 bits, 1 stop bit,
1514 * no parity, no flow control lines, normal XON/XOFF chars */
1515
1516 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_BITRATE)) {
1517 bit_rate = rpn->bit_rate;
1518 if (bit_rate > RFCOMM_RPN_BR_230400) {
1519 BT_DBG("RPN bit rate mismatch 0x%x", bit_rate);
1520 bit_rate = RFCOMM_RPN_BR_9600;
1521 rpn_mask ^= RFCOMM_RPN_PM_BITRATE;
1522 }
1523 }
1524
1525 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_DATA)) {
1526 data_bits = __get_rpn_data_bits(rpn->line_settings);
1527 if (data_bits != RFCOMM_RPN_DATA_8) {
1528 BT_DBG("RPN data bits mismatch 0x%x", data_bits);
1529 data_bits = RFCOMM_RPN_DATA_8;
1530 rpn_mask ^= RFCOMM_RPN_PM_DATA;
1531 }
1532 }
1533
1534 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_STOP)) {
1535 stop_bits = __get_rpn_stop_bits(rpn->line_settings);
1536 if (stop_bits != RFCOMM_RPN_STOP_1) {
1537 BT_DBG("RPN stop bits mismatch 0x%x", stop_bits);
1538 stop_bits = RFCOMM_RPN_STOP_1;
1539 rpn_mask ^= RFCOMM_RPN_PM_STOP;
1540 }
1541 }
1542
1543 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_PARITY)) {
1544 parity = __get_rpn_parity(rpn->line_settings);
1545 if (parity != RFCOMM_RPN_PARITY_NONE) {
1546 BT_DBG("RPN parity mismatch 0x%x", parity);
1547 parity = RFCOMM_RPN_PARITY_NONE;
1548 rpn_mask ^= RFCOMM_RPN_PM_PARITY;
1549 }
1550 }
1551
1552 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_FLOW)) {
1553 flow_ctrl = rpn->flow_ctrl;
1554 if (flow_ctrl != RFCOMM_RPN_FLOW_NONE) {
1555 BT_DBG("RPN flow ctrl mismatch 0x%x", flow_ctrl);
1556 flow_ctrl = RFCOMM_RPN_FLOW_NONE;
1557 rpn_mask ^= RFCOMM_RPN_PM_FLOW;
1558 }
1559 }
1560
1561 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_XON)) {
1562 xon_char = rpn->xon_char;
1563 if (xon_char != RFCOMM_RPN_XON_CHAR) {
1564 BT_DBG("RPN XON char mismatch 0x%x", xon_char);
1565 xon_char = RFCOMM_RPN_XON_CHAR;
1566 rpn_mask ^= RFCOMM_RPN_PM_XON;
1567 }
1568 }
1569
1570 if (rpn->param_mask & cpu_to_le16(RFCOMM_RPN_PM_XOFF)) {
1571 xoff_char = rpn->xoff_char;
1572 if (xoff_char != RFCOMM_RPN_XOFF_CHAR) {
1573 BT_DBG("RPN XOFF char mismatch 0x%x", xoff_char);
1574 xoff_char = RFCOMM_RPN_XOFF_CHAR;
1575 rpn_mask ^= RFCOMM_RPN_PM_XOFF;
1576 }
1577 }
1578
1579rpn_out:
1580 rfcomm_send_rpn(s, 0, dlci, bit_rate, data_bits, stop_bits,
1581 parity, flow_ctrl, xon_char, xoff_char, rpn_mask);
1582
1583 return 0;
1584}
1585
1586static int rfcomm_recv_rls(struct rfcomm_session *s, int cr, struct sk_buff *skb)
1587{
1588 struct rfcomm_rls *rls = (void *) skb->data;
1589 u8 dlci = __get_dlci(rls->dlci);
1590
1591 BT_DBG("dlci %d cr %d status 0x%x", dlci, cr, rls->status);
1592
1593 if (!cr)
1594 return 0;
1595
1596 /* We should probably do something with this information here. But
1597 * for now it's sufficient just to reply -- Bluetooth 1.1 says it's
1598 * mandatory to recognise and respond to RLS */
1599
1600 rfcomm_send_rls(s, 0, dlci, rls->status);
1601
1602 return 0;
1603}
1604
1605static int rfcomm_recv_msc(struct rfcomm_session *s, int cr, struct sk_buff *skb)
1606{
1607 struct rfcomm_msc *msc = (void *) skb->data;
1608 struct rfcomm_dlc *d;
1609 u8 dlci = __get_dlci(msc->dlci);
1610
1611 BT_DBG("dlci %d cr %d v24 0x%x", dlci, cr, msc->v24_sig);
1612
1613 d = rfcomm_dlc_get(s, dlci);
1614 if (!d)
1615 return 0;
1616
1617 if (cr) {
1618 if (msc->v24_sig & RFCOMM_V24_FC && !d->cfc)
1619 set_bit(RFCOMM_TX_THROTTLED, &d->flags);
1620 else
1621 clear_bit(RFCOMM_TX_THROTTLED, &d->flags);
1622
1623 rfcomm_dlc_lock(d);
1624
1625 d->remote_v24_sig = msc->v24_sig;
1626
1627 if (d->modem_status)
1628 d->modem_status(d, msc->v24_sig);
1629
1630 rfcomm_dlc_unlock(d);
1631
1632 rfcomm_send_msc(s, 0, dlci, msc->v24_sig);
1633
1634 d->mscex |= RFCOMM_MSCEX_RX;
1635 } else
1636 d->mscex |= RFCOMM_MSCEX_TX;
1637
1638 return 0;
1639}
1640
1641static int rfcomm_recv_mcc(struct rfcomm_session *s, struct sk_buff *skb)
1642{
1643 struct rfcomm_mcc *mcc = (void *) skb->data;
1644 u8 type, cr, len;
1645
1646 cr = __test_cr(mcc->type);
1647 type = __get_mcc_type(mcc->type);
1648 len = __get_mcc_len(mcc->len);
1649
1650 BT_DBG("%p type 0x%x cr %d", s, type, cr);
1651
1652 skb_pull(skb, 2);
1653
1654 switch (type) {
1655 case RFCOMM_PN:
1656 rfcomm_recv_pn(s, cr, skb);
1657 break;
1658
1659 case RFCOMM_RPN:
1660 rfcomm_recv_rpn(s, cr, len, skb);
1661 break;
1662
1663 case RFCOMM_RLS:
1664 rfcomm_recv_rls(s, cr, skb);
1665 break;
1666
1667 case RFCOMM_MSC:
1668 rfcomm_recv_msc(s, cr, skb);
1669 break;
1670
1671 case RFCOMM_FCOFF:
1672 if (cr) {
1673 set_bit(RFCOMM_TX_THROTTLED, &s->flags);
1674 rfcomm_send_fcoff(s, 0);
1675 }
1676 break;
1677
1678 case RFCOMM_FCON:
1679 if (cr) {
1680 clear_bit(RFCOMM_TX_THROTTLED, &s->flags);
1681 rfcomm_send_fcon(s, 0);
1682 }
1683 break;
1684
1685 case RFCOMM_TEST:
1686 if (cr)
1687 rfcomm_send_test(s, 0, skb->data, skb->len);
1688 break;
1689
1690 case RFCOMM_NSC:
1691 break;
1692
1693 default:
1694 BT_ERR("Unknown control type 0x%02x", type);
1695 rfcomm_send_nsc(s, cr, type);
1696 break;
1697 }
1698 return 0;
1699}
1700
1701static int rfcomm_recv_data(struct rfcomm_session *s, u8 dlci, int pf, struct sk_buff *skb)
1702{
1703 struct rfcomm_dlc *d;
1704
1705 BT_DBG("session %p state %ld dlci %d pf %d", s, s->state, dlci, pf);
1706
1707 d = rfcomm_dlc_get(s, dlci);
1708 if (!d) {
1709 rfcomm_send_dm(s, dlci);
1710 goto drop;
1711 }
1712
1713 if (pf && d->cfc) {
1714 u8 credits = *(u8 *) skb->data; skb_pull(skb, 1);
1715
1716 d->tx_credits += credits;
1717 if (d->tx_credits)
1718 clear_bit(RFCOMM_TX_THROTTLED, &d->flags);
1719 }
1720
1721 if (skb->len && d->state == BT_CONNECTED) {
1722 rfcomm_dlc_lock(d);
1723 d->rx_credits--;
1724 d->data_ready(d, skb);
1725 rfcomm_dlc_unlock(d);
1726 return 0;
1727 }
1728
1729drop:
1730 kfree_skb(skb);
1731 return 0;
1732}
1733
1734static struct rfcomm_session *rfcomm_recv_frame(struct rfcomm_session *s,
1735 struct sk_buff *skb)
1736{
1737 struct rfcomm_hdr *hdr = (void *) skb->data;
1738 u8 type, dlci, fcs;
1739
1740 if (!s) {
1741 /* no session, so free socket data */
1742 kfree_skb(skb);
1743 return s;
1744 }
1745
1746 dlci = __get_dlci(hdr->addr);
1747 type = __get_type(hdr->ctrl);
1748
1749 /* Trim FCS */
1750 skb->len--; skb->tail--;
1751 fcs = *(u8 *)skb_tail_pointer(skb);
1752
1753 if (__check_fcs(skb->data, type, fcs)) {
1754 BT_ERR("bad checksum in packet");
1755 kfree_skb(skb);
1756 return s;
1757 }
1758
1759 if (__test_ea(hdr->len))
1760 skb_pull(skb, 3);
1761 else
1762 skb_pull(skb, 4);
1763
1764 switch (type) {
1765 case RFCOMM_SABM:
1766 if (__test_pf(hdr->ctrl))
1767 rfcomm_recv_sabm(s, dlci);
1768 break;
1769
1770 case RFCOMM_DISC:
1771 if (__test_pf(hdr->ctrl))
1772 s = rfcomm_recv_disc(s, dlci);
1773 break;
1774
1775 case RFCOMM_UA:
1776 if (__test_pf(hdr->ctrl))
1777 s = rfcomm_recv_ua(s, dlci);
1778 break;
1779
1780 case RFCOMM_DM:
1781 s = rfcomm_recv_dm(s, dlci);
1782 break;
1783
1784 case RFCOMM_UIH:
1785 if (dlci) {
1786 rfcomm_recv_data(s, dlci, __test_pf(hdr->ctrl), skb);
1787 return s;
1788 }
1789 rfcomm_recv_mcc(s, skb);
1790 break;
1791
1792 default:
1793 BT_ERR("Unknown packet type 0x%02x", type);
1794 break;
1795 }
1796 kfree_skb(skb);
1797 return s;
1798}
1799
1800/* ---- Connection and data processing ---- */
1801
1802static void rfcomm_process_connect(struct rfcomm_session *s)
1803{
1804 struct rfcomm_dlc *d, *n;
1805
1806 BT_DBG("session %p state %ld", s, s->state);
1807
1808 list_for_each_entry_safe(d, n, &s->dlcs, list) {
1809 if (d->state == BT_CONFIG) {
1810 d->mtu = s->mtu;
1811 if (rfcomm_check_security(d)) {
1812 rfcomm_send_pn(s, 1, d);
1813 } else {
1814 set_bit(RFCOMM_AUTH_PENDING, &d->flags);
1815 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
1816 }
1817 }
1818 }
1819}
1820
1821/* Send data queued for the DLC.
1822 * Return number of frames left in the queue.
1823 */
1824static int rfcomm_process_tx(struct rfcomm_dlc *d)
1825{
1826 struct sk_buff *skb;
1827 int err;
1828
1829 BT_DBG("dlc %p state %ld cfc %d rx_credits %d tx_credits %d",
1830 d, d->state, d->cfc, d->rx_credits, d->tx_credits);
1831
1832 /* Send pending MSC */
1833 if (test_and_clear_bit(RFCOMM_MSC_PENDING, &d->flags))
1834 rfcomm_send_msc(d->session, 1, d->dlci, d->v24_sig);
1835
1836 if (d->cfc) {
1837 /* CFC enabled.
1838 * Give them some credits */
1839 if (!test_bit(RFCOMM_RX_THROTTLED, &d->flags) &&
1840 d->rx_credits <= (d->cfc >> 2)) {
1841 rfcomm_send_credits(d->session, d->addr, d->cfc - d->rx_credits);
1842 d->rx_credits = d->cfc;
1843 }
1844 } else {
1845 /* CFC disabled.
1846 * Give ourselves some credits */
1847 d->tx_credits = 5;
1848 }
1849
1850 if (test_bit(RFCOMM_TX_THROTTLED, &d->flags))
1851 return skb_queue_len(&d->tx_queue);
1852
1853 while (d->tx_credits && (skb = skb_dequeue(&d->tx_queue))) {
1854 err = rfcomm_send_frame(d->session, skb->data, skb->len);
1855 if (err < 0) {
1856 skb_queue_head(&d->tx_queue, skb);
1857 break;
1858 }
1859 kfree_skb(skb);
1860 d->tx_credits--;
1861 }
1862
1863 if (d->cfc && !d->tx_credits) {
1864 /* We're out of TX credits.
1865 * Set TX_THROTTLED flag to avoid unnesary wakeups by dlc_send. */
1866 set_bit(RFCOMM_TX_THROTTLED, &d->flags);
1867 }
1868
1869 return skb_queue_len(&d->tx_queue);
1870}
1871
1872static void rfcomm_process_dlcs(struct rfcomm_session *s)
1873{
1874 struct rfcomm_dlc *d, *n;
1875
1876 BT_DBG("session %p state %ld", s, s->state);
1877
1878 list_for_each_entry_safe(d, n, &s->dlcs, list) {
1879 if (test_bit(RFCOMM_TIMED_OUT, &d->flags)) {
1880 __rfcomm_dlc_close(d, ETIMEDOUT);
1881 continue;
1882 }
1883
1884 if (test_bit(RFCOMM_ENC_DROP, &d->flags)) {
1885 __rfcomm_dlc_close(d, ECONNREFUSED);
1886 continue;
1887 }
1888
1889 if (test_and_clear_bit(RFCOMM_AUTH_ACCEPT, &d->flags)) {
1890 rfcomm_dlc_clear_timer(d);
1891 if (d->out) {
1892 rfcomm_send_pn(s, 1, d);
1893 rfcomm_dlc_set_timer(d, RFCOMM_CONN_TIMEOUT);
1894 } else {
1895 if (d->defer_setup) {
1896 set_bit(RFCOMM_DEFER_SETUP, &d->flags);
1897 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
1898
1899 rfcomm_dlc_lock(d);
1900 d->state = BT_CONNECT2;
1901 d->state_change(d, 0);
1902 rfcomm_dlc_unlock(d);
1903 } else
1904 rfcomm_dlc_accept(d);
1905 }
1906 continue;
1907 } else if (test_and_clear_bit(RFCOMM_AUTH_REJECT, &d->flags)) {
1908 rfcomm_dlc_clear_timer(d);
1909 if (!d->out)
1910 rfcomm_send_dm(s, d->dlci);
1911 else
1912 d->state = BT_CLOSED;
1913 __rfcomm_dlc_close(d, ECONNREFUSED);
1914 continue;
1915 }
1916
1917 if (test_bit(RFCOMM_SEC_PENDING, &d->flags))
1918 continue;
1919
1920 if (test_bit(RFCOMM_TX_THROTTLED, &s->flags))
1921 continue;
1922
1923 if ((d->state == BT_CONNECTED || d->state == BT_DISCONN) &&
1924 d->mscex == RFCOMM_MSCEX_OK)
1925 rfcomm_process_tx(d);
1926 }
1927}
1928
1929static struct rfcomm_session *rfcomm_process_rx(struct rfcomm_session *s)
1930{
1931 struct socket *sock = s->sock;
1932 struct sock *sk = sock->sk;
1933 struct sk_buff *skb;
1934
1935 BT_DBG("session %p state %ld qlen %d", s, s->state, skb_queue_len(&sk->sk_receive_queue));
1936
1937 /* Get data directly from socket receive queue without copying it. */
1938 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
1939 skb_orphan(skb);
1940 if (!skb_linearize(skb)) {
1941 s = rfcomm_recv_frame(s, skb);
1942 if (!s)
1943 break;
1944 } else {
1945 kfree_skb(skb);
1946 }
1947 }
1948
1949 if (s && (sk->sk_state == BT_CLOSED))
1950 s = rfcomm_session_close(s, sk->sk_err);
1951
1952 return s;
1953}
1954
1955static void rfcomm_accept_connection(struct rfcomm_session *s)
1956{
1957 struct socket *sock = s->sock, *nsock;
1958 int err;
1959
1960 /* Fast check for a new connection.
1961 * Avoids unnesesary socket allocations. */
1962 if (list_empty(&bt_sk(sock->sk)->accept_q))
1963 return;
1964
1965 BT_DBG("session %p", s);
1966
1967 err = kernel_accept(sock, &nsock, O_NONBLOCK);
1968 if (err < 0)
1969 return;
1970
1971 /* Set our callbacks */
1972 nsock->sk->sk_data_ready = rfcomm_l2data_ready;
1973 nsock->sk->sk_state_change = rfcomm_l2state_change;
1974
1975 s = rfcomm_session_add(nsock, BT_OPEN);
1976 if (s) {
1977 /* We should adjust MTU on incoming sessions.
1978 * L2CAP MTU minus UIH header and FCS. */
1979 s->mtu = min(l2cap_pi(nsock->sk)->chan->omtu,
1980 l2cap_pi(nsock->sk)->chan->imtu) - 5;
1981
1982 rfcomm_schedule();
1983 } else
1984 sock_release(nsock);
1985}
1986
1987static struct rfcomm_session *rfcomm_check_connection(struct rfcomm_session *s)
1988{
1989 struct sock *sk = s->sock->sk;
1990
1991 BT_DBG("%p state %ld", s, s->state);
1992
1993 switch (sk->sk_state) {
1994 case BT_CONNECTED:
1995 s->state = BT_CONNECT;
1996
1997 /* We can adjust MTU on outgoing sessions.
1998 * L2CAP MTU minus UIH header and FCS. */
1999 s->mtu = min(l2cap_pi(sk)->chan->omtu, l2cap_pi(sk)->chan->imtu) - 5;
2000
2001 rfcomm_send_sabm(s, 0);
2002 break;
2003
2004 case BT_CLOSED:
2005 s = rfcomm_session_close(s, sk->sk_err);
2006 break;
2007 }
2008 return s;
2009}
2010
2011static void rfcomm_process_sessions(void)
2012{
2013 struct rfcomm_session *s, *n;
2014
2015 rfcomm_lock();
2016
2017 list_for_each_entry_safe(s, n, &session_list, list) {
2018 if (test_and_clear_bit(RFCOMM_TIMED_OUT, &s->flags)) {
2019 s->state = BT_DISCONN;
2020 rfcomm_send_disc(s, 0);
2021 continue;
2022 }
2023
2024 switch (s->state) {
2025 case BT_LISTEN:
2026 rfcomm_accept_connection(s);
2027 continue;
2028
2029 case BT_BOUND:
2030 s = rfcomm_check_connection(s);
2031 break;
2032
2033 default:
2034 s = rfcomm_process_rx(s);
2035 break;
2036 }
2037
2038 if (s)
2039 rfcomm_process_dlcs(s);
2040 }
2041
2042 rfcomm_unlock();
2043}
2044
2045static int rfcomm_add_listener(bdaddr_t *ba)
2046{
2047 struct sockaddr_l2 addr;
2048 struct socket *sock;
2049 struct sock *sk;
2050 struct rfcomm_session *s;
2051 int err = 0;
2052
2053 /* Create socket */
2054 err = rfcomm_l2sock_create(&sock);
2055 if (err < 0) {
2056 BT_ERR("Create socket failed %d", err);
2057 return err;
2058 }
2059
2060 /* Bind socket */
2061 bacpy(&addr.l2_bdaddr, ba);
2062 addr.l2_family = AF_BLUETOOTH;
2063 addr.l2_psm = cpu_to_le16(L2CAP_PSM_RFCOMM);
2064 addr.l2_cid = 0;
2065 addr.l2_bdaddr_type = BDADDR_BREDR;
2066 err = kernel_bind(sock, (struct sockaddr *) &addr, sizeof(addr));
2067 if (err < 0) {
2068 BT_ERR("Bind failed %d", err);
2069 goto failed;
2070 }
2071
2072 /* Set L2CAP options */
2073 sk = sock->sk;
2074 lock_sock(sk);
2075 /* Set MTU to 0 so L2CAP can auto select the MTU */
2076 l2cap_pi(sk)->chan->imtu = 0;
2077 release_sock(sk);
2078
2079 /* Start listening on the socket */
2080 err = kernel_listen(sock, 10);
2081 if (err) {
2082 BT_ERR("Listen failed %d", err);
2083 goto failed;
2084 }
2085
2086 /* Add listening session */
2087 s = rfcomm_session_add(sock, BT_LISTEN);
2088 if (!s) {
2089 err = -ENOMEM;
2090 goto failed;
2091 }
2092
2093 return 0;
2094failed:
2095 sock_release(sock);
2096 return err;
2097}
2098
2099static void rfcomm_kill_listener(void)
2100{
2101 struct rfcomm_session *s, *n;
2102
2103 BT_DBG("");
2104
2105 list_for_each_entry_safe(s, n, &session_list, list)
2106 rfcomm_session_del(s);
2107}
2108
2109static int rfcomm_run(void *unused)
2110{
2111 DEFINE_WAIT_FUNC(wait, woken_wake_function);
2112 BT_DBG("");
2113
2114 set_user_nice(current, -10);
2115
2116 rfcomm_add_listener(BDADDR_ANY);
2117
2118 add_wait_queue(&rfcomm_wq, &wait);
2119 while (!kthread_should_stop()) {
2120
2121 /* Process stuff */
2122 rfcomm_process_sessions();
2123
2124 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
2125 }
2126 remove_wait_queue(&rfcomm_wq, &wait);
2127
2128 rfcomm_kill_listener();
2129
2130 return 0;
2131}
2132
2133static void rfcomm_security_cfm(struct hci_conn *conn, u8 status, u8 encrypt)
2134{
2135 struct rfcomm_session *s;
2136 struct rfcomm_dlc *d, *n;
2137
2138 BT_DBG("conn %p status 0x%02x encrypt 0x%02x", conn, status, encrypt);
2139
2140 s = rfcomm_session_get(&conn->hdev->bdaddr, &conn->dst);
2141 if (!s)
2142 return;
2143
2144 list_for_each_entry_safe(d, n, &s->dlcs, list) {
2145 if (test_and_clear_bit(RFCOMM_SEC_PENDING, &d->flags)) {
2146 rfcomm_dlc_clear_timer(d);
2147 if (status || encrypt == 0x00) {
2148 set_bit(RFCOMM_ENC_DROP, &d->flags);
2149 continue;
2150 }
2151 }
2152
2153 if (d->state == BT_CONNECTED && !status && encrypt == 0x00) {
2154 if (d->sec_level == BT_SECURITY_MEDIUM) {
2155 set_bit(RFCOMM_SEC_PENDING, &d->flags);
2156 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
2157 continue;
2158 } else if (d->sec_level == BT_SECURITY_HIGH ||
2159 d->sec_level == BT_SECURITY_FIPS) {
2160 set_bit(RFCOMM_ENC_DROP, &d->flags);
2161 continue;
2162 }
2163 }
2164
2165 if (!test_and_clear_bit(RFCOMM_AUTH_PENDING, &d->flags))
2166 continue;
2167
2168 if (!status && hci_conn_check_secure(conn, d->sec_level))
2169 set_bit(RFCOMM_AUTH_ACCEPT, &d->flags);
2170 else
2171 set_bit(RFCOMM_AUTH_REJECT, &d->flags);
2172 }
2173
2174 rfcomm_schedule();
2175}
2176
2177static struct hci_cb rfcomm_cb = {
2178 .name = "RFCOMM",
2179 .security_cfm = rfcomm_security_cfm
2180};
2181
2182static int rfcomm_dlc_debugfs_show(struct seq_file *f, void *x)
2183{
2184 struct rfcomm_session *s;
2185
2186 rfcomm_lock();
2187
2188 list_for_each_entry(s, &session_list, list) {
2189 struct l2cap_chan *chan = l2cap_pi(s->sock->sk)->chan;
2190 struct rfcomm_dlc *d;
2191 list_for_each_entry(d, &s->dlcs, list) {
2192 seq_printf(f, "%pMR %pMR %ld %d %d %d %d\n",
2193 &chan->src, &chan->dst,
2194 d->state, d->dlci, d->mtu,
2195 d->rx_credits, d->tx_credits);
2196 }
2197 }
2198
2199 rfcomm_unlock();
2200
2201 return 0;
2202}
2203
2204DEFINE_SHOW_ATTRIBUTE(rfcomm_dlc_debugfs);
2205
2206static struct dentry *rfcomm_dlc_debugfs;
2207
2208/* ---- Initialization ---- */
2209static int __init rfcomm_init(void)
2210{
2211 int err;
2212
2213 hci_register_cb(&rfcomm_cb);
2214
2215 rfcomm_thread = kthread_run(rfcomm_run, NULL, "krfcommd");
2216 if (IS_ERR(rfcomm_thread)) {
2217 err = PTR_ERR(rfcomm_thread);
2218 goto unregister;
2219 }
2220
2221 err = rfcomm_init_ttys();
2222 if (err < 0)
2223 goto stop;
2224
2225 err = rfcomm_init_sockets();
2226 if (err < 0)
2227 goto cleanup;
2228
2229 BT_INFO("RFCOMM ver %s", VERSION);
2230
2231 if (IS_ERR_OR_NULL(bt_debugfs))
2232 return 0;
2233
2234 rfcomm_dlc_debugfs = debugfs_create_file("rfcomm_dlc", 0444,
2235 bt_debugfs, NULL,
2236 &rfcomm_dlc_debugfs_fops);
2237
2238 return 0;
2239
2240cleanup:
2241 rfcomm_cleanup_ttys();
2242
2243stop:
2244 kthread_stop(rfcomm_thread);
2245
2246unregister:
2247 hci_unregister_cb(&rfcomm_cb);
2248
2249 return err;
2250}
2251
2252static void __exit rfcomm_exit(void)
2253{
2254 debugfs_remove(rfcomm_dlc_debugfs);
2255
2256 hci_unregister_cb(&rfcomm_cb);
2257
2258 kthread_stop(rfcomm_thread);
2259
2260 rfcomm_cleanup_ttys();
2261
2262 rfcomm_cleanup_sockets();
2263}
2264
2265module_init(rfcomm_init);
2266module_exit(rfcomm_exit);
2267
2268module_param(disable_cfc, bool, 0644);
2269MODULE_PARM_DESC(disable_cfc, "Disable credit based flow control");
2270
2271module_param(channel_mtu, int, 0644);
2272MODULE_PARM_DESC(channel_mtu, "Default MTU for the RFCOMM channel");
2273
2274module_param(l2cap_ertm, bool, 0644);
2275MODULE_PARM_DESC(l2cap_ertm, "Use L2CAP ERTM mode for connection");
2276
2277MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
2278MODULE_DESCRIPTION("Bluetooth RFCOMM ver " VERSION);
2279MODULE_VERSION(VERSION);
2280MODULE_LICENSE("GPL");
2281MODULE_ALIAS("bt-proto-3");