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