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