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