projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: set skbuffer priority based on L2CAP socket priority
[GitHub/mt8127/android_kernel_alcatel_ttab.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 43#include <net/sock.h>
285b4e90 44#include <linux/uaccess.h>
1da177e4
LT		 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
285b4e90
AE		 54static int disable_cfc;
55static int l2cap_ertm;
98bcd08b 56static int channel_mtu = -1;
56f3a40a
MH		 57static unsigned int l2cap_mtu = RFCOMM_MAX_L2CAP_MTU;
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 64
1da177e4
LT		 65
66static LIST_HEAD(session_list);
1da177e4
LT		 67
68static int rfcomm_send_frame(struct rfcomm_session *s, u8 *data, int len);
69static int rfcomm_send_sabm(struct rfcomm_session *s, u8 dlci);
70static int rfcomm_send_disc(struct rfcomm_session *s, u8 dlci);
71static int rfcomm_queue_disc(struct rfcomm_dlc *d);
72static int rfcomm_send_nsc(struct rfcomm_session *s, int cr, u8 type);
73static int rfcomm_send_pn(struct rfcomm_session *s, int cr, struct rfcomm_dlc *d);
74static int rfcomm_send_msc(struct rfcomm_session *s, int cr, u8 dlci, u8 v24_sig);
75static int rfcomm_send_test(struct rfcomm_session *s, int cr, u8 *pattern, int len);
76static int rfcomm_send_credits(struct rfcomm_session *s, u8 addr, u8 credits);
77static void rfcomm_make_uih(struct sk_buff *skb, u8 addr);
78
79static void rfcomm_process_connect(struct rfcomm_session *s);
80
63ce0900
LAD		 81static struct rfcomm_session *rfcomm_session_create(bdaddr_t *src,
82 bdaddr_t *dst,
83 u8 sec_level,
84 int *err);
1da177e4
LT		 85static struct rfcomm_session *rfcomm_session_get(bdaddr_t *src, bdaddr_t *dst);
86static void rfcomm_session_del(struct rfcomm_session *s);
87
88/* ---- RFCOMM frame parsing macros ---- */
89#define __get_dlci(b) ((b & 0xfc) >> 2)
90#define __get_channel(b) ((b & 0xf8) >> 3)
91#define __get_dir(b) ((b & 0x04) >> 2)
92#define __get_type(b) ((b & 0xef))
93
94#define __test_ea(b) ((b & 0x01))
95#define __test_cr(b) ((b & 0x02))
96#define __test_pf(b) ((b & 0x10))
97
98#define __addr(cr, dlci) (((dlci & 0x3f) << 2) | (cr << 1) | 0x01)
99#define __ctrl(type, pf) (((type & 0xef) | (pf << 4)))
100#define __dlci(dir, chn) (((chn & 0x1f) << 1) | dir)
101#define __srv_channel(dlci) (dlci >> 1)
102#define __dir(dlci) (dlci & 0x01)
103
104#define __len8(len) (((len) << 1) | 1)
105#define __len16(len) ((len) << 1)
106
107/* MCC macros */
108#define __mcc_type(cr, type) (((type << 2) | (cr << 1) | 0x01))
109#define __get_mcc_type(b) ((b & 0xfc) >> 2)
110#define __get_mcc_len(b) ((b & 0xfe) >> 1)
111
112/* RPN macros */
3a5e903c 113#define __rpn_line_settings(data, stop, parity) ((data & 0x3) | ((stop & 0x1) << 2) | ((parity & 0x7) << 3))
1da177e4
LT		 114#define __get_rpn_data_bits(line) ((line) & 0x3)
115#define __get_rpn_stop_bits(line) (((line) >> 2) & 0x1)
3a5e903c 116#define __get_rpn_parity(line) (((line) >> 3) & 0x7)
1da177e4 117
534c92fd 118static inline void rfcomm_schedule(void)
1da177e4
LT		 119{
120 if (!rfcomm_thread)
121 return;
1da177e4
LT		 122 wake_up_process(rfcomm_thread);
123}
124
125static inline void rfcomm_session_put(struct rfcomm_session *s)
126{
127 if (atomic_dec_and_test(&s->refcnt))
128 rfcomm_session_del(s);
129}
130
131/* ---- RFCOMM FCS computation ---- */
132
408c1ce2 133/* reversed, 8-bit, poly=0x07 */
8e87d142 134static unsigned char rfcomm_crc_table[256] = {
408c1ce2
MH		 135 0x00, 0x91, 0xe3, 0x72, 0x07, 0x96, 0xe4, 0x75,
136 0x0e, 0x9f, 0xed, 0x7c, 0x09, 0x98, 0xea, 0x7b,
137 0x1c, 0x8d, 0xff, 0x6e, 0x1b, 0x8a, 0xf8, 0x69,
138 0x12, 0x83, 0xf1, 0x60, 0x15, 0x84, 0xf6, 0x67,
139
140 0x38, 0xa9, 0xdb, 0x4a, 0x3f, 0xae, 0xdc, 0x4d,
141 0x36, 0xa7, 0xd5, 0x44, 0x31, 0xa0, 0xd2, 0x43,
142 0x24, 0xb5, 0xc7, 0x56, 0x23, 0xb2, 0xc0, 0x51,
143 0x2a, 0xbb, 0xc9, 0x58, 0x2d, 0xbc, 0xce, 0x5f,
144
145 0x70, 0xe1, 0x93, 0x02, 0x77, 0xe6, 0x94, 0x05,
146 0x7e, 0xef, 0x9d, 0x0c, 0x79, 0xe8, 0x9a, 0x0b,
147 0x6c, 0xfd, 0x8f, 0x1e, 0x6b, 0xfa, 0x88, 0x19,
148 0x62, 0xf3, 0x81, 0x10, 0x65, 0xf4, 0x86, 0x17,
149
150 0x48, 0xd9, 0xab, 0x3a, 0x4f, 0xde, 0xac, 0x3d,
151 0x46, 0xd7, 0xa5, 0x34, 0x41, 0xd0, 0xa2, 0x33,
152 0x54, 0xc5, 0xb7, 0x26, 0x53, 0xc2, 0xb0, 0x21,
153 0x5a, 0xcb, 0xb9, 0x28, 0x5d, 0xcc, 0xbe, 0x2f,
154
155 0xe0, 0x71, 0x03, 0x92, 0xe7, 0x76, 0x04, 0x95,
156 0xee, 0x7f, 0x0d, 0x9c, 0xe9, 0x78, 0x0a, 0x9b,
157 0xfc, 0x6d, 0x1f, 0x8e, 0xfb, 0x6a, 0x18, 0x89,
158 0xf2, 0x63, 0x11, 0x80, 0xf5, 0x64, 0x16, 0x87,
159
160 0xd8, 0x49, 0x3b, 0xaa, 0xdf, 0x4e, 0x3c, 0xad,
161 0xd6, 0x47, 0x35, 0xa4, 0xd1, 0x40, 0x32, 0xa3,
162 0xc4, 0x55, 0x27, 0xb6, 0xc3, 0x52, 0x20, 0xb1,
163 0xca, 0x5b, 0x29, 0xb8, 0xcd, 0x5c, 0x2e, 0xbf,
164
165 0x90, 0x01, 0x73, 0xe2, 0x97, 0x06, 0x74, 0xe5,
166 0x9e, 0x0f, 0x7d, 0xec, 0x99, 0x08, 0x7a, 0xeb,
167 0x8c, 0x1d, 0x6f, 0xfe, 0x8b, 0x1a, 0x68, 0xf9,
168 0x82, 0x13, 0x61, 0xf0, 0x85, 0x14, 0x66, 0xf7,
169
170 0xa8, 0x39, 0x4b, 0xda, 0xaf, 0x3e, 0x4c, 0xdd,
171 0xa6, 0x37, 0x45, 0xd4, 0xa1, 0x30, 0x42, 0xd3,
172 0xb4, 0x25, 0x57, 0xc6, 0xb3, 0x22, 0x50, 0xc1,
173 0xba, 0x2b, 0x59, 0xc8, 0xbd, 0x2c, 0x5e, 0xcf
174};
175
1da177e4
LT		 176/* CRC on 2 bytes */
177#define __crc(data) (rfcomm_crc_table[rfcomm_crc_table[0xff ^ data[0]] ^ data[1]])
178
8e87d142 179/* FCS on 2 bytes */
1da177e4
LT		 180static inline u8 __fcs(u8 *data)
181{
a02cec21 182 return 0xff - __crc(data);
1da177e4
LT		 183}
184
8e87d142 185/* FCS on 3 bytes */
1da177e4
LT		 186static inline u8 __fcs2(u8 *data)
187{
a02cec21 188 return 0xff - rfcomm_crc_table[__crc(data) ^ data[2]];
1da177e4
LT		 189}
190
191/* Check FCS */
192static inline int __check_fcs(u8 *data, int type, u8 fcs)
193{
194 u8 f = __crc(data);
195
196 if (type != RFCOMM_UIH)
197 f = rfcomm_crc_table[f ^ data[2]];
198
199 return rfcomm_crc_table[f ^ fcs] != 0xcf;
200}
201
202/* ---- L2CAP callbacks ---- */
203static void rfcomm_l2state_change(struct sock *sk)
204{
205 BT_DBG("%p state %d", sk, sk->sk_state);
534c92fd 206 rfcomm_schedule();
1da177e4
LT		 207}
208
209static void rfcomm_l2data_ready(struct sock *sk, int bytes)
210{
211 BT_DBG("%p bytes %d", sk, bytes);
534c92fd 212 rfcomm_schedule();
1da177e4
LT		 213}
214
215static int rfcomm_l2sock_create(struct socket **sock)
216{
217 int err;
218
219 BT_DBG("");
220
221 err = sock_create_kern(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP, sock);
222 if (!err) {
223 struct sock *sk = (*sock)->sk;
224 sk->sk_data_ready = rfcomm_l2data_ready;
225 sk->sk_state_change = rfcomm_l2state_change;
226 }
227 return err;
228}
229
9f2c8a03 230static inline int rfcomm_check_security(struct rfcomm_dlc *d)
77db1980
MH		 231{
232 struct sock *sk = d->session->sock->sk;
8c1d787b
GP		 233 struct l2cap_conn *conn = l2cap_pi(sk)->chan->conn;
234
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
8c1d787b 249 return hci_conn_security(conn->hcon, d->sec_level, auth_type);
77db1980
MH		 250}
251
9e726b17
LAD		 252static void rfcomm_session_timeout(unsigned long arg)
253{
254 struct rfcomm_session *s = (void *) arg;
255
256 BT_DBG("session %p state %ld", s, s->state);
257
258 set_bit(RFCOMM_TIMED_OUT, &s->flags);
534c92fd 259 rfcomm_schedule();
9e726b17
LAD		 260}
261
262static void rfcomm_session_set_timer(struct rfcomm_session *s, long timeout)
263{
264 BT_DBG("session %p state %ld timeout %ld", s, s->state, timeout);
265
266 if (!mod_timer(&s->timer, jiffies + timeout))
267 rfcomm_session_hold(s);
268}
269
270static void rfcomm_session_clear_timer(struct rfcomm_session *s)
271{
272 BT_DBG("session %p state %ld", s, s->state);
273
274 if (timer_pending(&s->timer) && del_timer(&s->timer))
275 rfcomm_session_put(s);
276}
277
1da177e4
LT		 278/* ---- RFCOMM DLCs ---- */
279static void rfcomm_dlc_timeout(unsigned long arg)
280{
281 struct rfcomm_dlc *d = (void *) arg;
282
283 BT_DBG("dlc %p state %ld", d, d->state);
284
285 set_bit(RFCOMM_TIMED_OUT, &d->flags);
286 rfcomm_dlc_put(d);
534c92fd 287 rfcomm_schedule();
1da177e4
LT		 288}
289
290static void rfcomm_dlc_set_timer(struct rfcomm_dlc *d, long timeout)
291{
292 BT_DBG("dlc %p state %ld timeout %ld", d, d->state, timeout);
293
294 if (!mod_timer(&d->timer, jiffies + timeout))
295 rfcomm_dlc_hold(d);
296}
297
298static void rfcomm_dlc_clear_timer(struct rfcomm_dlc *d)
299{
300 BT_DBG("dlc %p state %ld", d, d->state);
301
302 if (timer_pending(&d->timer) && del_timer(&d->timer))
303 rfcomm_dlc_put(d);
304}
305
306static void rfcomm_dlc_clear_state(struct rfcomm_dlc *d)
307{
308 BT_DBG("%p", d);
309
310 d->state = BT_OPEN;
311 d->flags = 0;
312 d->mscex = 0;
183f732c 313 d->sec_level = BT_SECURITY_LOW;
1da177e4
LT		 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;
1da177e4 380
8035ded4 381 list_for_each_entry(d, &s->dlcs, list)
1da177e4
LT		 382 if (d->dlci == dlci)
383 return d;
8035ded4 384
1da177e4
LT		 385 return NULL;
386}
387
388static int __rfcomm_dlc_open(struct rfcomm_dlc *d, bdaddr_t *src, bdaddr_t *dst, u8 channel)
389{
390 struct rfcomm_session *s;
391 int err = 0;
392 u8 dlci;
393
8e87d142 394 BT_DBG("dlc %p state %ld %s %s channel %d",
1da177e4
LT		 395 d, d->state, batostr(src), batostr(dst), channel);
396
397 if (channel < 1 || channel > 30)
398 return -EINVAL;
399
400 if (d->state != BT_OPEN && d->state != BT_CLOSED)
401 return 0;
402
403 s = rfcomm_session_get(src, dst);
404 if (!s) {
63ce0900 405 s = rfcomm_session_create(src, dst, d->sec_level, &err);
1da177e4
LT		 406 if (!s)
407 return err;
408 }
409
410 dlci = __dlci(!s->initiator, channel);
411
412 /* Check if DLCI already exists */
413 if (rfcomm_dlc_get(s, dlci))
414 return -EBUSY;
415
416 rfcomm_dlc_clear_state(d);
417
418 d->dlci = dlci;
419 d->addr = __addr(s->initiator, dlci);
420 d->priority = 7;
421
77db1980 422 d->state = BT_CONFIG;
1da177e4
LT		 423 rfcomm_dlc_link(s, d);
424
77db1980
MH		 425 d->out = 1;
426
1da177e4
LT		 427 d->mtu = s->mtu;
428 d->cfc = (s->cfc == RFCOMM_CFC_UNKNOWN) ? 0 : s->cfc;
429
77db1980 430 if (s->state == BT_CONNECTED) {
9f2c8a03 431 if (rfcomm_check_security(d))
77db1980 432 rfcomm_send_pn(s, 1, d);
8c1b2355
MH		 433 else
434 set_bit(RFCOMM_AUTH_PENDING, &d->flags);
77db1980
MH		 435 }
436
1da177e4 437 rfcomm_dlc_set_timer(d, RFCOMM_CONN_TIMEOUT);
77db1980 438
1da177e4
LT		 439 return 0;
440}
441
442int rfcomm_dlc_open(struct rfcomm_dlc *d, bdaddr_t *src, bdaddr_t *dst, u8 channel)
443{
444 int r;
445
446 rfcomm_lock();
447
448 r = __rfcomm_dlc_open(d, src, dst, channel);
449
450 rfcomm_unlock();
451 return r;
452}
453
454static int __rfcomm_dlc_close(struct rfcomm_dlc *d, int err)
455{
456 struct rfcomm_session *s = d->session;
457 if (!s)
458 return 0;
459
460 BT_DBG("dlc %p state %ld dlci %d err %d session %p",
461 d, d->state, d->dlci, err, s);
462
463 switch (d->state) {
1da177e4 464 case BT_CONNECT:
bb23c0ab
MH		 465 case BT_CONFIG:
466 if (test_and_clear_bit(RFCOMM_DEFER_SETUP, &d->flags)) {
467 set_bit(RFCOMM_AUTH_REJECT, &d->flags);
534c92fd 468 rfcomm_schedule();
bb23c0ab
MH		 469 break;
470 }
471 /* Fall through */
472
473 case BT_CONNECTED:
1da177e4
LT		 474 d->state = BT_DISCONN;
475 if (skb_queue_empty(&d->tx_queue)) {
476 rfcomm_send_disc(s, d->dlci);
477 rfcomm_dlc_set_timer(d, RFCOMM_DISC_TIMEOUT);
478 } else {
479 rfcomm_queue_disc(d);
480 rfcomm_dlc_set_timer(d, RFCOMM_DISC_TIMEOUT * 2);
481 }
482 break;
483
bb23c0ab 484 case BT_OPEN:
8bf47941 485 case BT_CONNECT2:
bb23c0ab
MH		 486 if (test_and_clear_bit(RFCOMM_DEFER_SETUP, &d->flags)) {
487 set_bit(RFCOMM_AUTH_REJECT, &d->flags);
534c92fd 488 rfcomm_schedule();
bb23c0ab
MH		 489 break;
490 }
491 /* Fall through */
492
1da177e4
LT		 493 default:
494 rfcomm_dlc_clear_timer(d);
495
496 rfcomm_dlc_lock(d);
497 d->state = BT_CLOSED;
1905f6c7 498 d->state_change(d, err);
4c8411f8 499 rfcomm_dlc_unlock(d);
1da177e4
LT		 500
501 skb_queue_purge(&d->tx_queue);
1da177e4
LT		 502 rfcomm_dlc_unlink(d);
503 }
504
505 return 0;
506}
507
508int rfcomm_dlc_close(struct rfcomm_dlc *d, int err)
509{
510 int r;
511
512 rfcomm_lock();
513
514 r = __rfcomm_dlc_close(d, err);
515
516 rfcomm_unlock();
517 return r;
518}
519
520int rfcomm_dlc_send(struct rfcomm_dlc *d, struct sk_buff *skb)
521{
522 int len = skb->len;
523
524 if (d->state != BT_CONNECTED)
525 return -ENOTCONN;
526
527 BT_DBG("dlc %p mtu %d len %d", d, d->mtu, len);
528
529 if (len > d->mtu)
530 return -EINVAL;
531
532 rfcomm_make_uih(skb, d->addr);
533 skb_queue_tail(&d->tx_queue, skb);
534
535 if (!test_bit(RFCOMM_TX_THROTTLED, &d->flags))
534c92fd 536 rfcomm_schedule();
1da177e4
LT		 537 return len;
538}
539
b5606c2d 540void __rfcomm_dlc_throttle(struct rfcomm_dlc *d)
1da177e4
LT		 541{
542 BT_DBG("dlc %p state %ld", d, d->state);
543
544 if (!d->cfc) {
545 d->v24_sig |= RFCOMM_V24_FC;
546 set_bit(RFCOMM_MSC_PENDING, &d->flags);
547 }
534c92fd 548 rfcomm_schedule();
1da177e4
LT		 549}
550
b5606c2d 551void __rfcomm_dlc_unthrottle(struct rfcomm_dlc *d)
1da177e4
LT		 552{
553 BT_DBG("dlc %p state %ld", d, d->state);
554
555 if (!d->cfc) {
556 d->v24_sig &= ~RFCOMM_V24_FC;
557 set_bit(RFCOMM_MSC_PENDING, &d->flags);
558 }
534c92fd 559 rfcomm_schedule();
1da177e4
LT		 560}
561
8e87d142 562/*
1da177e4
LT		 563 Set/get modem status functions use _local_ status i.e. what we report
564 to the other side.
565 Remote status is provided by dlc->modem_status() callback.
566 */
567int rfcomm_dlc_set_modem_status(struct rfcomm_dlc *d, u8 v24_sig)
568{
8e87d142 569 BT_DBG("dlc %p state %ld v24_sig 0x%x",
1da177e4
LT		 570 d, d->state, v24_sig);
571
572 if (test_bit(RFCOMM_RX_THROTTLED, &d->flags))
573 v24_sig |= RFCOMM_V24_FC;
574 else
575 v24_sig &= ~RFCOMM_V24_FC;
8e87d142 576
1da177e4
LT		 577 d->v24_sig = v24_sig;
578
579 if (!test_and_set_bit(RFCOMM_MSC_PENDING, &d->flags))
534c92fd 580 rfcomm_schedule();
1da177e4
LT		 581
582 return 0;
583}
584
585int rfcomm_dlc_get_modem_status(struct rfcomm_dlc *d, u8 *v24_sig)
586{
8e87d142 587 BT_DBG("dlc %p state %ld v24_sig 0x%x",
1da177e4
LT		 588 d, d->state, d->v24_sig);
589
590 *v24_sig = d->v24_sig;
591 return 0;
592}
593
594/* ---- RFCOMM sessions ---- */
595static struct rfcomm_session *rfcomm_session_add(struct socket *sock, int state)
596{
25ea6db0
MH		 597 struct rfcomm_session *s = kzalloc(sizeof(*s), GFP_KERNEL);
598
1da177e4
LT		 599 if (!s)
600 return NULL;
1da177e4
LT		 601
602 BT_DBG("session %p sock %p", s, sock);
603
9e726b17
LAD		 604 setup_timer(&s->timer, rfcomm_session_timeout, (unsigned long) s);
605
1da177e4
LT		 606 INIT_LIST_HEAD(&s->dlcs);
607 s->state = state;
608 s->sock = sock;
609
610 s->mtu = RFCOMM_DEFAULT_MTU;
7c2660b0 611 s->cfc = disable_cfc ? RFCOMM_CFC_DISABLED : RFCOMM_CFC_UNKNOWN;
1da177e4
LT		 612
613 /* Do not increment module usage count for listening sessions.
614 * Otherwise we won't be able to unload the module. */
615 if (state != BT_LISTEN)
616 if (!try_module_get(THIS_MODULE)) {
617 kfree(s);
618 return NULL;
619 }
620
621 list_add(&s->list, &session_list);
622
623 return s;
624}
625
626static void rfcomm_session_del(struct rfcomm_session *s)
627{
628 int state = s->state;
629
630 BT_DBG("session %p state %ld", s, s->state);
631
632 list_del(&s->list);
633
634 if (state == BT_CONNECTED)
635 rfcomm_send_disc(s, 0);
636
9e726b17 637 rfcomm_session_clear_timer(s);
1da177e4
LT		 638 sock_release(s->sock);
639 kfree(s);
640
641 if (state != BT_LISTEN)
642 module_put(THIS_MODULE);
643}
644
645static struct rfcomm_session *rfcomm_session_get(bdaddr_t *src, bdaddr_t *dst)
646{
647 struct rfcomm_session *s;
648 struct list_head *p, *n;
649 struct bt_sock *sk;
650 list_for_each_safe(p, n, &session_list) {
651 s = list_entry(p, struct rfcomm_session, list);
8e87d142 652 sk = bt_sk(s->sock->sk);
1da177e4
LT		 653
654 if ((!bacmp(src, BDADDR_ANY) || !bacmp(&sk->src, src)) &&
655 !bacmp(&sk->dst, dst))
656 return s;
657 }
658 return NULL;
659}
660
661static void rfcomm_session_close(struct rfcomm_session *s, int err)
662{
663 struct rfcomm_dlc *d;
664 struct list_head *p, *n;
665
666 BT_DBG("session %p state %ld err %d", s, s->state, err);
667
668 rfcomm_session_hold(s);
669
670 s->state = BT_CLOSED;
671
672 /* Close all dlcs */
673 list_for_each_safe(p, n, &s->dlcs) {
674 d = list_entry(p, struct rfcomm_dlc, list);
675 d->state = BT_CLOSED;
676 __rfcomm_dlc_close(d, err);
677 }
678
9e726b17 679 rfcomm_session_clear_timer(s);
1da177e4
LT		 680 rfcomm_session_put(s);
681}
682
63ce0900
LAD		 683static struct rfcomm_session *rfcomm_session_create(bdaddr_t *src,
684 bdaddr_t *dst,
685 u8 sec_level,
686 int *err)
1da177e4
LT		 687{
688 struct rfcomm_session *s = NULL;
689 struct sockaddr_l2 addr;
690 struct socket *sock;
691 struct sock *sk;
692
693 BT_DBG("%s %s", batostr(src), batostr(dst));
694
695 *err = rfcomm_l2sock_create(&sock);
696 if (*err < 0)
697 return NULL;
698
699 bacpy(&addr.l2_bdaddr, src);
700 addr.l2_family = AF_BLUETOOTH;
701 addr.l2_psm = 0;
37e62f55 702 addr.l2_cid = 0;
48db9ca4 703 *err = kernel_bind(sock, (struct sockaddr *) &addr, sizeof(addr));
1da177e4
LT		 704 if (*err < 0)
705 goto failed;
706
707 /* Set L2CAP options */
708 sk = sock->sk;
709 lock_sock(sk);
0c1bc5c6 710 l2cap_pi(sk)->chan->imtu = l2cap_mtu;
47d1ec61 711 l2cap_pi(sk)->chan->sec_level = sec_level;
eae38eed 712 if (l2cap_ertm)
0c1bc5c6 713 l2cap_pi(sk)->chan->mode = L2CAP_MODE_ERTM;
1da177e4
LT		 714 release_sock(sk);
715
716 s = rfcomm_session_add(sock, BT_BOUND);
717 if (!s) {
718 *err = -ENOMEM;
719 goto failed;
720 }
721
1da177e4
LT		 722 s->initiator = 1;
723
724 bacpy(&addr.l2_bdaddr, dst);
725 addr.l2_family = AF_BLUETOOTH;
b4324b5d 726 addr.l2_psm = cpu_to_le16(RFCOMM_PSM);
37e62f55 727 addr.l2_cid = 0;
48db9ca4 728 *err = kernel_connect(sock, (struct sockaddr *) &addr, sizeof(addr), O_NONBLOCK);
b4c612a4 729 if (*err == 0 || *err == -EINPROGRESS)
1da177e4
LT		 730 return s;
731
732 rfcomm_session_del(s);
733 return NULL;
734
735failed:
736 sock_release(sock);
737 return NULL;
738}
739
740void rfcomm_session_getaddr(struct rfcomm_session *s, bdaddr_t *src, bdaddr_t *dst)
741{
742 struct sock *sk = s->sock->sk;
743 if (src)
744 bacpy(src, &bt_sk(sk)->src);
745 if (dst)
746 bacpy(dst, &bt_sk(sk)->dst);
747}
748
749/* ---- RFCOMM frame sending ---- */
750static int rfcomm_send_frame(struct rfcomm_session *s, u8 *data, int len)
751{
752 struct socket *sock = s->sock;
753 struct kvec iv = { data, len };
754 struct msghdr msg;
755
756 BT_DBG("session %p len %d", s, len);
757
758 memset(&msg, 0, sizeof(msg));
759
760 return kernel_sendmsg(sock, &msg, &iv, 1, len);
761}
762
763static int rfcomm_send_sabm(struct rfcomm_session *s, u8 dlci)
764{
765 struct rfcomm_cmd cmd;
766
767 BT_DBG("%p dlci %d", s, dlci);
768
769 cmd.addr = __addr(s->initiator, dlci);
770 cmd.ctrl = __ctrl(RFCOMM_SABM, 1);
771 cmd.len = __len8(0);
772 cmd.fcs = __fcs2((u8 *) &cmd);
773
774 return rfcomm_send_frame(s, (void *) &cmd, sizeof(cmd));
775}
776
777static int rfcomm_send_ua(struct rfcomm_session *s, u8 dlci)
778{
779 struct rfcomm_cmd cmd;
780
781 BT_DBG("%p dlci %d", s, dlci);
782
783 cmd.addr = __addr(!s->initiator, dlci);
784 cmd.ctrl = __ctrl(RFCOMM_UA, 1);
785 cmd.len = __len8(0);
786 cmd.fcs = __fcs2((u8 *) &cmd);
787
788 return rfcomm_send_frame(s, (void *) &cmd, sizeof(cmd));
789}
790
791static int rfcomm_send_disc(struct rfcomm_session *s, u8 dlci)
792{
793 struct rfcomm_cmd cmd;
794
795 BT_DBG("%p dlci %d", s, dlci);
796
797 cmd.addr = __addr(s->initiator, dlci);
798 cmd.ctrl = __ctrl(RFCOMM_DISC, 1);
799 cmd.len = __len8(0);
800 cmd.fcs = __fcs2((u8 *) &cmd);
801
802 return rfcomm_send_frame(s, (void *) &cmd, sizeof(cmd));
803}
804
805static int rfcomm_queue_disc(struct rfcomm_dlc *d)
806{
807 struct rfcomm_cmd *cmd;
808 struct sk_buff *skb;
809
810 BT_DBG("dlc %p dlci %d", d, d->dlci);
811
812 skb = alloc_skb(sizeof(*cmd), GFP_KERNEL);
813 if (!skb)
814 return -ENOMEM;
815
816 cmd = (void *) __skb_put(skb, sizeof(*cmd));
817 cmd->addr = d->addr;
818 cmd->ctrl = __ctrl(RFCOMM_DISC, 1);
819 cmd->len = __len8(0);
820 cmd->fcs = __fcs2((u8 *) cmd);
821
822 skb_queue_tail(&d->tx_queue, skb);
534c92fd 823 rfcomm_schedule();
1da177e4
LT		 824 return 0;
825}
826
827static int rfcomm_send_dm(struct rfcomm_session *s, u8 dlci)
828{
829 struct rfcomm_cmd cmd;
830
831 BT_DBG("%p dlci %d", s, dlci);
832
833 cmd.addr = __addr(!s->initiator, dlci);
834 cmd.ctrl = __ctrl(RFCOMM_DM, 1);
835 cmd.len = __len8(0);
836 cmd.fcs = __fcs2((u8 *) &cmd);
837
838 return rfcomm_send_frame(s, (void *) &cmd, sizeof(cmd));
839}
840
841static int rfcomm_send_nsc(struct rfcomm_session *s, int cr, u8 type)
842{
843 struct rfcomm_hdr *hdr;
844 struct rfcomm_mcc *mcc;
845 u8 buf[16], *ptr = buf;
846
847 BT_DBG("%p cr %d type %d", s, cr, type);
848
849 hdr = (void *) ptr; ptr += sizeof(*hdr);
850 hdr->addr = __addr(s->initiator, 0);
851 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
852 hdr->len = __len8(sizeof(*mcc) + 1);
853
854 mcc = (void *) ptr; ptr += sizeof(*mcc);
855 mcc->type = __mcc_type(cr, RFCOMM_NSC);
856 mcc->len = __len8(1);
857
858 /* Type that we didn't like */
859 *ptr = __mcc_type(cr, type); ptr++;
860
861 *ptr = __fcs(buf); ptr++;
862
863 return rfcomm_send_frame(s, buf, ptr - buf);
864}
865
866static int rfcomm_send_pn(struct rfcomm_session *s, int cr, struct rfcomm_dlc *d)
867{
868 struct rfcomm_hdr *hdr;
869 struct rfcomm_mcc *mcc;
870 struct rfcomm_pn *pn;
871 u8 buf[16], *ptr = buf;
872
873 BT_DBG("%p cr %d dlci %d mtu %d", s, cr, d->dlci, d->mtu);
874
875 hdr = (void *) ptr; ptr += sizeof(*hdr);
876 hdr->addr = __addr(s->initiator, 0);
877 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
878 hdr->len = __len8(sizeof(*mcc) + sizeof(*pn));
879
880 mcc = (void *) ptr; ptr += sizeof(*mcc);
881 mcc->type = __mcc_type(cr, RFCOMM_PN);
882 mcc->len = __len8(sizeof(*pn));
883
884 pn = (void *) ptr; ptr += sizeof(*pn);
885 pn->dlci = d->dlci;
886 pn->priority = d->priority;
887 pn->ack_timer = 0;
888 pn->max_retrans = 0;
889
890 if (s->cfc) {
891 pn->flow_ctrl = cr ? 0xf0 : 0xe0;
892 pn->credits = RFCOMM_DEFAULT_CREDITS;
893 } else {
894 pn->flow_ctrl = 0;
895 pn->credits = 0;
896 }
897
98bcd08b 898 if (cr && channel_mtu >= 0)
b4324b5d 899 pn->mtu = cpu_to_le16(channel_mtu);
98bcd08b 900 else
b4324b5d 901 pn->mtu = cpu_to_le16(d->mtu);
1da177e4
LT		 902
903 *ptr = __fcs(buf); ptr++;
904
905 return rfcomm_send_frame(s, buf, ptr - buf);
906}
907
3a5e903c
S		 908int rfcomm_send_rpn(struct rfcomm_session *s, int cr, u8 dlci,
909 u8 bit_rate, u8 data_bits, u8 stop_bits,
8e87d142 910 u8 parity, u8 flow_ctrl_settings,
3a5e903c 911 u8 xon_char, u8 xoff_char, u16 param_mask)
1da177e4
LT		 912{
913 struct rfcomm_hdr *hdr;
914 struct rfcomm_mcc *mcc;
915 struct rfcomm_rpn *rpn;
916 u8 buf[16], *ptr = buf;
917
918 BT_DBG("%p cr %d dlci %d bit_r 0x%x data_b 0x%x stop_b 0x%x parity 0x%x"
8e87d142
YH		 919 " flwc_s 0x%x xon_c 0x%x xoff_c 0x%x p_mask 0x%x",
920 s, cr, dlci, bit_rate, data_bits, stop_bits, parity,
3a5e903c 921 flow_ctrl_settings, xon_char, xoff_char, param_mask);
1da177e4
LT		 922
923 hdr = (void *) ptr; ptr += sizeof(*hdr);
924 hdr->addr = __addr(s->initiator, 0);
925 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
926 hdr->len = __len8(sizeof(*mcc) + sizeof(*rpn));
927
928 mcc = (void *) ptr; ptr += sizeof(*mcc);
929 mcc->type = __mcc_type(cr, RFCOMM_RPN);
930 mcc->len = __len8(sizeof(*rpn));
931
932 rpn = (void *) ptr; ptr += sizeof(*rpn);
933 rpn->dlci = __addr(1, dlci);
934 rpn->bit_rate = bit_rate;
935 rpn->line_settings = __rpn_line_settings(data_bits, stop_bits, parity);
936 rpn->flow_ctrl = flow_ctrl_settings;
937 rpn->xon_char = xon_char;
938 rpn->xoff_char = xoff_char;
e8db8c99 939 rpn->param_mask = cpu_to_le16(param_mask);
1da177e4
LT		 940
941 *ptr = __fcs(buf); ptr++;
942
943 return rfcomm_send_frame(s, buf, ptr - buf);
944}
945
946static int rfcomm_send_rls(struct rfcomm_session *s, int cr, u8 dlci, u8 status)
947{
948 struct rfcomm_hdr *hdr;
949 struct rfcomm_mcc *mcc;
950 struct rfcomm_rls *rls;
951 u8 buf[16], *ptr = buf;
952
953 BT_DBG("%p cr %d status 0x%x", s, cr, status);
954
955 hdr = (void *) ptr; ptr += sizeof(*hdr);
956 hdr->addr = __addr(s->initiator, 0);
957 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
958 hdr->len = __len8(sizeof(*mcc) + sizeof(*rls));
959
960 mcc = (void *) ptr; ptr += sizeof(*mcc);
961 mcc->type = __mcc_type(cr, RFCOMM_RLS);
962 mcc->len = __len8(sizeof(*rls));
963
964 rls = (void *) ptr; ptr += sizeof(*rls);
965 rls->dlci = __addr(1, dlci);
966 rls->status = status;
967
968 *ptr = __fcs(buf); ptr++;
969
970 return rfcomm_send_frame(s, buf, ptr - buf);
971}
972
973static int rfcomm_send_msc(struct rfcomm_session *s, int cr, u8 dlci, u8 v24_sig)
974{
975 struct rfcomm_hdr *hdr;
976 struct rfcomm_mcc *mcc;
977 struct rfcomm_msc *msc;
978 u8 buf[16], *ptr = buf;
979
980 BT_DBG("%p cr %d v24 0x%x", s, cr, v24_sig);
981
982 hdr = (void *) ptr; ptr += sizeof(*hdr);
983 hdr->addr = __addr(s->initiator, 0);
984 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
985 hdr->len = __len8(sizeof(*mcc) + sizeof(*msc));
986
987 mcc = (void *) ptr; ptr += sizeof(*mcc);
988 mcc->type = __mcc_type(cr, RFCOMM_MSC);
989 mcc->len = __len8(sizeof(*msc));
990
991 msc = (void *) ptr; ptr += sizeof(*msc);
992 msc->dlci = __addr(1, dlci);
993 msc->v24_sig = v24_sig | 0x01;
994
995 *ptr = __fcs(buf); ptr++;
996
997 return rfcomm_send_frame(s, buf, ptr - buf);
998}
999
1000static int rfcomm_send_fcoff(struct rfcomm_session *s, int cr)
1001{
1002 struct rfcomm_hdr *hdr;
1003 struct rfcomm_mcc *mcc;
1004 u8 buf[16], *ptr = buf;
1005
1006 BT_DBG("%p cr %d", s, cr);
1007
1008 hdr = (void *) ptr; ptr += sizeof(*hdr);
1009 hdr->addr = __addr(s->initiator, 0);
1010 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1011 hdr->len = __len8(sizeof(*mcc));
1012
1013 mcc = (void *) ptr; ptr += sizeof(*mcc);
1014 mcc->type = __mcc_type(cr, RFCOMM_FCOFF);
1015 mcc->len = __len8(0);
1016
1017 *ptr = __fcs(buf); ptr++;
1018
1019 return rfcomm_send_frame(s, buf, ptr - buf);
1020}
1021
1022static int rfcomm_send_fcon(struct rfcomm_session *s, int cr)
1023{
1024 struct rfcomm_hdr *hdr;
1025 struct rfcomm_mcc *mcc;
1026 u8 buf[16], *ptr = buf;
1027
1028 BT_DBG("%p cr %d", s, cr);
1029
1030 hdr = (void *) ptr; ptr += sizeof(*hdr);
1031 hdr->addr = __addr(s->initiator, 0);
1032 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1033 hdr->len = __len8(sizeof(*mcc));
1034
1035 mcc = (void *) ptr; ptr += sizeof(*mcc);
1036 mcc->type = __mcc_type(cr, RFCOMM_FCON);
1037 mcc->len = __len8(0);
1038
1039 *ptr = __fcs(buf); ptr++;
1040
1041 return rfcomm_send_frame(s, buf, ptr - buf);
1042}
1043
1044static int rfcomm_send_test(struct rfcomm_session *s, int cr, u8 *pattern, int len)
1045{
1046 struct socket *sock = s->sock;
1047 struct kvec iv[3];
1048 struct msghdr msg;
1049 unsigned char hdr[5], crc[1];
1050
1051 if (len > 125)
1052 return -EINVAL;
1053
1054 BT_DBG("%p cr %d", s, cr);
1055
1056 hdr[0] = __addr(s->initiator, 0);
1057 hdr[1] = __ctrl(RFCOMM_UIH, 0);
1058 hdr[2] = 0x01 | ((len + 2) << 1);
1059 hdr[3] = 0x01 | ((cr & 0x01) << 1) | (RFCOMM_TEST << 2);
1060 hdr[4] = 0x01 | (len << 1);
1061
1062 crc[0] = __fcs(hdr);
1063
1064 iv[0].iov_base = hdr;
1065 iv[0].iov_len = 5;
1066 iv[1].iov_base = pattern;
1067 iv[1].iov_len = len;
1068 iv[2].iov_base = crc;
1069 iv[2].iov_len = 1;
1070
1071 memset(&msg, 0, sizeof(msg));
1072
1073 return kernel_sendmsg(sock, &msg, iv, 3, 6 + len);
1074}
1075
1076static int rfcomm_send_credits(struct rfcomm_session *s, u8 addr, u8 credits)
1077{
1078 struct rfcomm_hdr *hdr;
1079 u8 buf[16], *ptr = buf;
1080
1081 BT_DBG("%p addr %d credits %d", s, addr, credits);
1082
1083 hdr = (void *) ptr; ptr += sizeof(*hdr);
1084 hdr->addr = addr;
1085 hdr->ctrl = __ctrl(RFCOMM_UIH, 1);
1086 hdr->len = __len8(0);
1087
1088 *ptr = credits; ptr++;
1089
1090 *ptr = __fcs(buf); ptr++;
1091
1092 return rfcomm_send_frame(s, buf, ptr - buf);
1093}
1094
1095static void rfcomm_make_uih(struct sk_buff *skb, u8 addr)
1096{
1097 struct rfcomm_hdr *hdr;
1098 int len = skb->len;
1099 u8 *crc;
1100
1101 if (len > 127) {
1102 hdr = (void *) skb_push(skb, 4);
b4324b5d 1103 put_unaligned(cpu_to_le16(__len16(len)), (__le16 *) &hdr->len);
1da177e4
LT		 1104 } else {
1105 hdr = (void *) skb_push(skb, 3);
1106 hdr->len = __len8(len);
1107 }
1108 hdr->addr = addr;
1109 hdr->ctrl = __ctrl(RFCOMM_UIH, 0);
1110
1111 crc = skb_put(skb, 1);
1112 *crc = __fcs((void *) hdr);
1113}
1114
1115/* ---- RFCOMM frame reception ---- */
1116static int rfcomm_recv_ua(struct rfcomm_session *s, u8 dlci)
1117{
1118 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1119
1120 if (dlci) {
1121 /* Data channel */
1122 struct rfcomm_dlc *d = rfcomm_dlc_get(s, dlci);
1123 if (!d) {
1124 rfcomm_send_dm(s, dlci);
1125 return 0;
1126 }
1127
1128 switch (d->state) {
1129 case BT_CONNECT:
1130 rfcomm_dlc_clear_timer(d);
1131
1132 rfcomm_dlc_lock(d);
1133 d->state = BT_CONNECTED;
1134 d->state_change(d, 0);
1135 rfcomm_dlc_unlock(d);
1136
1137 rfcomm_send_msc(s, 1, dlci, d->v24_sig);
1138 break;
1139
1140 case BT_DISCONN:
1141 d->state = BT_CLOSED;
1142 __rfcomm_dlc_close(d, 0);
9cf5b0ea
MH		 1143
1144 if (list_empty(&s->dlcs)) {
1145 s->state = BT_DISCONN;
1146 rfcomm_send_disc(s, 0);
1147 }
1148
1da177e4
LT		 1149 break;
1150 }
1151 } else {
1152 /* Control channel */
1153 switch (s->state) {
1154 case BT_CONNECT:
1155 s->state = BT_CONNECTED;
1156 rfcomm_process_connect(s);
1157 break;
9cf5b0ea
MH		 1158
1159 case BT_DISCONN:
6c2718da
NP		 1160 /* When socket is closed and we are not RFCOMM
1161 * initiator rfcomm_process_rx already calls
1162 * rfcomm_session_put() */
1163 if (s->sock->sk->sk_state != BT_CLOSED)
683d949a
LT		 1164 if (list_empty(&s->dlcs))
1165 rfcomm_session_put(s);
9cf5b0ea 1166 break;
1da177e4
LT		 1167 }
1168 }
1169 return 0;
1170}
1171
1172static int rfcomm_recv_dm(struct rfcomm_session *s, u8 dlci)
1173{
1174 int err = 0;
1175
1176 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1177
1178 if (dlci) {
1179 /* Data DLC */
1180 struct rfcomm_dlc *d = rfcomm_dlc_get(s, dlci);
1181 if (d) {
1182 if (d->state == BT_CONNECT || d->state == BT_CONFIG)
1183 err = ECONNREFUSED;
1184 else
1185 err = ECONNRESET;
1186
1187 d->state = BT_CLOSED;
1188 __rfcomm_dlc_close(d, err);
1189 }
1190 } else {
1191 if (s->state == BT_CONNECT)
1192 err = ECONNREFUSED;
1193 else
1194 err = ECONNRESET;
1195
1196 s->state = BT_CLOSED;
1197 rfcomm_session_close(s, err);
1198 }
1199 return 0;
1200}
1201
1202static int rfcomm_recv_disc(struct rfcomm_session *s, u8 dlci)
1203{
1204 int err = 0;
1205
1206 BT_DBG("session %p state %ld dlci %d", s, s->state, dlci);
1207
1208 if (dlci) {
1209 struct rfcomm_dlc *d = rfcomm_dlc_get(s, dlci);
1210 if (d) {
1211 rfcomm_send_ua(s, dlci);
1212
1213 if (d->state == BT_CONNECT || d->state == BT_CONFIG)
1214 err = ECONNREFUSED;
1215 else
1216 err = ECONNRESET;
1217
1218 d->state = BT_CLOSED;
1219 __rfcomm_dlc_close(d, err);
8e87d142 1220 } else
1da177e4 1221 rfcomm_send_dm(s, dlci);
8e87d142 1222
1da177e4
LT		 1223 } else {
1224 rfcomm_send_ua(s, 0);
1225
1226 if (s->state == BT_CONNECT)
1227 err = ECONNREFUSED;
1228 else
1229 err = ECONNRESET;
1230
1231 s->state = BT_CLOSED;
1232 rfcomm_session_close(s, err);
1233 }
1234
1235 return 0;
1236}
1237
bb23c0ab 1238void rfcomm_dlc_accept(struct rfcomm_dlc *d)
1da177e4 1239{
300b9397 1240 struct sock *sk = d->session->sock->sk;
8c1d787b 1241 struct l2cap_conn *conn = l2cap_pi(sk)->chan->conn;
300b9397 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)
8c1d787b 1255 hci_conn_switch_role(conn->hcon, 0x00);
300b9397 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);
44935720
MM		 1854 if (!skb_linearize(skb))
1855 rfcomm_recv_frame(s, skb);
1856 else
1857 kfree_skb(skb);
1da177e4
LT		 1858 }
1859
1860 if (sk->sk_state == BT_CLOSED) {
1861 if (!s->initiator)
1862 rfcomm_session_put(s);
1863
1864 rfcomm_session_close(s, sk->sk_err);
1865 }
1866}
1867
1868static inline void rfcomm_accept_connection(struct rfcomm_session *s)
1869{
1870 struct socket *sock = s->sock, *nsock;
1871 int err;
1872
1873 /* Fast check for a new connection.
1874 * Avoids unnesesary socket allocations. */
1875 if (list_empty(&bt_sk(sock->sk)->accept_q))
1876 return;
1877
1878 BT_DBG("session %p", s);
1879
48db9ca4
MH		 1880 err = kernel_accept(sock, &nsock, O_NONBLOCK);
1881 if (err < 0)
1da177e4
LT		 1882 return;
1883
1da177e4
LT		 1884 /* Set our callbacks */
1885 nsock->sk->sk_data_ready = rfcomm_l2data_ready;
1886 nsock->sk->sk_state_change = rfcomm_l2state_change;
1887
1888 s = rfcomm_session_add(nsock, BT_OPEN);
1889 if (s) {
1890 rfcomm_session_hold(s);
98bcd08b
MH		 1891
1892 /* We should adjust MTU on incoming sessions.
1893 * L2CAP MTU minus UIH header and FCS. */
0c1bc5c6
GP		 1894 s->mtu = min(l2cap_pi(nsock->sk)->chan->omtu,
1895 l2cap_pi(nsock->sk)->chan->imtu) - 5;
98bcd08b 1896
534c92fd 1897 rfcomm_schedule();
1da177e4
LT		 1898 } else
1899 sock_release(nsock);
1900}
1901
1902static inline void rfcomm_check_connection(struct rfcomm_session *s)
1903{
1904 struct sock *sk = s->sock->sk;
1905
1906 BT_DBG("%p state %ld", s, s->state);
1907
285b4e90 1908 switch (sk->sk_state) {
1da177e4
LT		 1909 case BT_CONNECTED:
1910 s->state = BT_CONNECT;
1911
1912 /* We can adjust MTU on outgoing sessions.
1913 * L2CAP MTU minus UIH header and FCS. */
0c1bc5c6 1914 s->mtu = min(l2cap_pi(sk)->chan->omtu, l2cap_pi(sk)->chan->imtu) - 5;
1da177e4
LT		 1915
1916 rfcomm_send_sabm(s, 0);
1917 break;
1918
1919 case BT_CLOSED:
1920 s->state = BT_CLOSED;
1921 rfcomm_session_close(s, sk->sk_err);
1922 break;
1923 }
1924}
1925
1926static inline void rfcomm_process_sessions(void)
1927{
1928 struct list_head *p, *n;
1929
1930 rfcomm_lock();
1931
1932 list_for_each_safe(p, n, &session_list) {
1933 struct rfcomm_session *s;
1934 s = list_entry(p, struct rfcomm_session, list);
1935
9e726b17
LAD		 1936 if (test_and_clear_bit(RFCOMM_TIMED_OUT, &s->flags)) {
1937 s->state = BT_DISCONN;
1938 rfcomm_send_disc(s, 0);
485f1eff 1939 rfcomm_session_put(s);
9e726b17
LAD		 1940 continue;
1941 }
1942
1da177e4
LT		 1943 if (s->state == BT_LISTEN) {
1944 rfcomm_accept_connection(s);
1945 continue;
1946 }
1947
1948 rfcomm_session_hold(s);
1949
1950 switch (s->state) {
1951 case BT_BOUND:
1952 rfcomm_check_connection(s);
1953 break;
1954
1955 default:
1956 rfcomm_process_rx(s);
1957 break;
1958 }
1959
1960 rfcomm_process_dlcs(s);
1961
1962 rfcomm_session_put(s);
1963 }
1964
1965 rfcomm_unlock();
1966}
1967
1da177e4
LT		 1968static int rfcomm_add_listener(bdaddr_t *ba)
1969{
1970 struct sockaddr_l2 addr;
1971 struct socket *sock;
1972 struct sock *sk;
1973 struct rfcomm_session *s;
1974 int err = 0;
1975
1976 /* Create socket */
1977 err = rfcomm_l2sock_create(&sock);
8e87d142 1978 if (err < 0) {
1da177e4
LT		 1979 BT_ERR("Create socket failed %d", err);
1980 return err;
1981 }
1982
1983 /* Bind socket */
1984 bacpy(&addr.l2_bdaddr, ba);
1985 addr.l2_family = AF_BLUETOOTH;
b4324b5d 1986 addr.l2_psm = cpu_to_le16(RFCOMM_PSM);
37e62f55 1987 addr.l2_cid = 0;
48db9ca4 1988 err = kernel_bind(sock, (struct sockaddr *) &addr, sizeof(addr));
1da177e4
LT		 1989 if (err < 0) {
1990 BT_ERR("Bind failed %d", err);
1991 goto failed;
1992 }
1993
1994 /* Set L2CAP options */
1995 sk = sock->sk;
1996 lock_sock(sk);
0c1bc5c6 1997 l2cap_pi(sk)->chan->imtu = l2cap_mtu;
1da177e4
LT		 1998 release_sock(sk);
1999
2000 /* Start listening on the socket */
48db9ca4 2001 err = kernel_listen(sock, 10);
1da177e4
LT		 2002 if (err) {
2003 BT_ERR("Listen failed %d", err);
2004 goto failed;
2005 }
2006
2007 /* Add listening session */
2008 s = rfcomm_session_add(sock, BT_LISTEN);
2009 if (!s)
2010 goto failed;
2011
2012 rfcomm_session_hold(s);
2013 return 0;
2014failed:
2015 sock_release(sock);
2016 return err;
2017}
2018
2019static void rfcomm_kill_listener(void)
2020{
2021 struct rfcomm_session *s;
2022 struct list_head *p, *n;
2023
2024 BT_DBG("");
2025
2026 list_for_each_safe(p, n, &session_list) {
2027 s = list_entry(p, struct rfcomm_session, list);
2028 rfcomm_session_del(s);
2029 }
2030}
2031
2032static int rfcomm_run(void *unused)
2033{
a524eccc 2034 BT_DBG("");
1da177e4 2035
1da177e4 2036 set_user_nice(current, -10);
1da177e4 2037
1da177e4
LT		 2038 rfcomm_add_listener(BDADDR_ANY);
2039
e5842cdb 2040 while (1) {
a524eccc 2041 set_current_state(TASK_INTERRUPTIBLE);
e5842cdb
PH		 2042
2043 if (kthread_should_stop())
2044 break;
a524eccc
MH		 2045
2046 /* Process stuff */
a524eccc 2047 rfcomm_process_sessions();
e5842cdb
PH		 2048
2049 schedule();
a524eccc 2050 }
e5842cdb 2051 __set_current_state(TASK_RUNNING);
1da177e4
LT		 2052
2053 rfcomm_kill_listener();
2054
1da177e4
LT		 2055 return 0;
2056}
2057
8c1b2355 2058static void rfcomm_security_cfm(struct hci_conn *conn, u8 status, u8 encrypt)
1da177e4
LT		 2059{
2060 struct rfcomm_session *s;
2061 struct rfcomm_dlc *d;
2062 struct list_head *p, *n;
2063
2064 BT_DBG("conn %p status 0x%02x encrypt 0x%02x", conn, status, encrypt);
2065
2066 s = rfcomm_session_get(&conn->hdev->bdaddr, &conn->dst);
2067 if (!s)
2068 return;
2069
2070 rfcomm_session_hold(s);
2071
2072 list_for_each_safe(p, n, &s->dlcs) {
2073 d = list_entry(p, struct rfcomm_dlc, list);
2074
8c84b830
MH		 2075 if (test_and_clear_bit(RFCOMM_SEC_PENDING, &d->flags)) {
2076 rfcomm_dlc_clear_timer(d);
2077 if (status || encrypt == 0x00) {
2078 __rfcomm_dlc_close(d, ECONNREFUSED);
2079 continue;
2080 }
2081 }
2082
2083 if (d->state == BT_CONNECTED && !status && encrypt == 0x00) {
2084 if (d->sec_level == BT_SECURITY_MEDIUM) {
2085 set_bit(RFCOMM_SEC_PENDING, &d->flags);
2086 rfcomm_dlc_set_timer(d, RFCOMM_AUTH_TIMEOUT);
2087 continue;
2088 } else if (d->sec_level == BT_SECURITY_HIGH) {
2089 __rfcomm_dlc_close(d, ECONNREFUSED);
2090 continue;
2091 }
9719f8af
MH		 2092 }
2093
1da177e4
LT		 2094 if (!test_and_clear_bit(RFCOMM_AUTH_PENDING, &d->flags))
2095 continue;
2096
b3b1b061 2097 if (!status && hci_conn_check_secure(conn, d->sec_level))
1da177e4
LT		 2098 set_bit(RFCOMM_AUTH_ACCEPT, &d->flags);
2099 else
2100 set_bit(RFCOMM_AUTH_REJECT, &d->flags);
2101 }
2102
2103 rfcomm_session_put(s);
2104
534c92fd 2105 rfcomm_schedule();
1da177e4
LT		 2106}
2107
2108static struct hci_cb rfcomm_cb = {
2109 .name = "RFCOMM",
8c1b2355 2110 .security_cfm = rfcomm_security_cfm
1da177e4
LT		 2111};
2112
aef7d97c 2113static int rfcomm_dlc_debugfs_show(struct seq_file *f, void *x)
1da177e4
LT		 2114{
2115 struct rfcomm_session *s;
1da177e4
LT		 2116
2117 rfcomm_lock();
2118
8035ded4
LAD		 2119 list_for_each_entry(s, &session_list, list) {
2120 struct rfcomm_dlc *d;
2121 list_for_each_entry(d, &s->dlcs, list) {
be9d1227 2122 struct sock *sk = s->sock->sk;
1da177e4 2123
aef7d97c
MH		 2124 seq_printf(f, "%s %s %ld %d %d %d %d\n",
2125 batostr(&bt_sk(sk)->src),
2126 batostr(&bt_sk(sk)->dst),
2127 d->state, d->dlci, d->mtu,
2128 d->rx_credits, d->tx_credits);
1da177e4
LT		 2129 }
2130 }
1da177e4 2131
1da177e4 2132 rfcomm_unlock();
1da177e4 2133
aef7d97c
MH		 2134 return 0;
2135}
2136
2137static int rfcomm_dlc_debugfs_open(struct inode *inode, struct file *file)
2138{
2139 return single_open(file, rfcomm_dlc_debugfs_show, inode->i_private);
1da177e4
LT		 2140}
2141
aef7d97c
MH		 2142static const struct file_operations rfcomm_dlc_debugfs_fops = {
2143 .open = rfcomm_dlc_debugfs_open,
2144 .read = seq_read,
2145 .llseek = seq_lseek,
2146 .release = single_release,
2147};
2148
2149static struct dentry *rfcomm_dlc_debugfs;
1da177e4
LT		 2150
2151/* ---- Initialization ---- */
2152static int __init rfcomm_init(void)
2153{
52d18347 2154 int err;
af0d3b10 2155
1da177e4
LT		 2156 hci_register_cb(&rfcomm_cb);
2157
a524eccc
MH		 2158 rfcomm_thread = kthread_run(rfcomm_run, NULL, "krfcommd");
2159 if (IS_ERR(rfcomm_thread)) {
52d18347
MH		 2160 err = PTR_ERR(rfcomm_thread);
2161 goto unregister;
a524eccc 2162 }
1da177e4 2163
aef7d97c
MH		 2164 if (bt_debugfs) {
2165 rfcomm_dlc_debugfs = debugfs_create_file("rfcomm_dlc", 0444,
2166 bt_debugfs, NULL, &rfcomm_dlc_debugfs_fops);
2167 if (!rfcomm_dlc_debugfs)
2168 BT_ERR("Failed to create RFCOMM debug file");
2169 }
1da177e4 2170
52d18347
MH		 2171 err = rfcomm_init_ttys();
2172 if (err < 0)
2173 goto stop;
1da177e4 2174
52d18347
MH		 2175 err = rfcomm_init_sockets();
2176 if (err < 0)
2177 goto cleanup;
1da177e4 2178
be9d1227
MH		 2179 BT_INFO("RFCOMM ver %s", VERSION);
2180
1da177e4 2181 return 0;
af0d3b10 2182
52d18347 2183cleanup:
af0d3b10 2184 rfcomm_cleanup_ttys();
52d18347
MH		 2185
2186stop:
af0d3b10 2187 kthread_stop(rfcomm_thread);
52d18347
MH		 2188
2189unregister:
af0d3b10
DY		 2190 hci_unregister_cb(&rfcomm_cb);
2191
52d18347 2192 return err;
1da177e4
LT		 2193}
2194
2195static void __exit rfcomm_exit(void)
2196{
aef7d97c 2197 debugfs_remove(rfcomm_dlc_debugfs);
be9d1227 2198
1da177e4
LT		 2199 hci_unregister_cb(&rfcomm_cb);
2200
a524eccc 2201 kthread_stop(rfcomm_thread);
1da177e4 2202
1da177e4 2203 rfcomm_cleanup_ttys();
1da177e4
LT		 2204
2205 rfcomm_cleanup_sockets();
1da177e4
LT		 2206}
2207
2208module_init(rfcomm_init);
2209module_exit(rfcomm_exit);
2210
7c2660b0
MH		 2211module_param(disable_cfc, bool, 0644);
2212MODULE_PARM_DESC(disable_cfc, "Disable credit based flow control");
2213
98bcd08b
MH		 2214module_param(channel_mtu, int, 0644);
2215MODULE_PARM_DESC(channel_mtu, "Default MTU for the RFCOMM channel");
2216
56f3a40a
MH		 2217module_param(l2cap_mtu, uint, 0644);
2218MODULE_PARM_DESC(l2cap_mtu, "Default MTU for the L2CAP connection");
2219
eae38eed
MH		 2220module_param(l2cap_ertm, bool, 0644);
2221MODULE_PARM_DESC(l2cap_ertm, "Use L2CAP ERTM mode for connection");
2222
63fbd24e 2223MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4
LT		 2224MODULE_DESCRIPTION("Bluetooth RFCOMM ver " VERSION);
2225MODULE_VERSION(VERSION);
2226MODULE_LICENSE("GPL");
2227MODULE_ALIAS("bt-proto-3");
kernel source for telekom puls (alcatel/mediatek)