net/bluetooth/hci_conn.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4
   5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License version 2 as
   9    published by the Free Software Foundation;
  10
  11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19
  20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  22    SOFTWARE IS DISCLAIMED.
  23 */
  24
  25 /* Bluetooth HCI connection handling. */
  26
  27 #include <linux/module.h>
  28
  29 #include <linux/types.h>
  30 #include <linux/errno.h>
  31 #include <linux/kernel.h>
  32 #include <linux/slab.h>
  33 #include <linux/poll.h>
  34 #include <linux/fcntl.h>
  35 #include <linux/init.h>
  36 #include <linux/skbuff.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/notifier.h>
  39 #include <net/sock.h>
  40
  41 #include <asm/system.h>
  42 #include <asm/uaccess.h>
  43 #include <asm/unaligned.h>
  44
  45 #include <net/bluetooth/bluetooth.h>
  46 #include <net/bluetooth/hci_core.h>
  47
  48 #ifndef CONFIG_BT_HCI_CORE_DEBUG
  49 #undef  BT_DBG
  50 #define BT_DBG(D...)
  51 #endif
  52
  53 void hci_acl_connect(struct hci_conn *conn)
  54 {
  55         struct hci_dev *hdev = conn->hdev;
  56         struct inquiry_entry *ie;
  57         struct hci_cp_create_conn cp;
  58
  59         BT_DBG("%p", conn);
  60
  61         conn->state = BT_CONNECT;
  62         conn->out   = 1;
  63         conn->link_mode = HCI_LM_MASTER;
  64
  65         conn->attempt++;
  66
  67         memset(&cp, 0, sizeof(cp));
  68         bacpy(&cp.bdaddr, &conn->dst);
  69         cp.pscan_rep_mode = 0x02;
  70
  71         if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)) &&
  72                         inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
  73                 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
  74                 cp.pscan_mode     = ie->data.pscan_mode;
  75                 cp.clock_offset   = ie->data.clock_offset | cpu_to_le16(0x8000);
  76                 memcpy(conn->dev_class, ie->data.dev_class, 3);
  77         }
  78
  79         cp.pkt_type = cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK);
  80         if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
  81                 cp.role_switch = 0x01;
  82         else
  83                 cp.role_switch = 0x00;
  84
  85         hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
  86 }
  87
  88 static void hci_acl_connect_cancel(struct hci_conn *conn)
  89 {
  90         struct hci_cp_create_conn_cancel cp;
  91
  92         BT_DBG("%p", conn);
  93
  94         if (conn->hdev->hci_ver < 2)
  95                 return;
  96
  97         bacpy(&cp.bdaddr, &conn->dst);
  98         hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
  99 }
 100
 101 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
 102 {
 103         struct hci_cp_disconnect cp;
 104
 105         BT_DBG("%p", conn);
 106
 107         conn->state = BT_DISCONN;
 108
 109         cp.handle = cpu_to_le16(conn->handle);
 110         cp.reason = reason;
 111         hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
 112 }
 113
 114 void hci_add_sco(struct hci_conn *conn, __u16 handle)
 115 {
 116         struct hci_dev *hdev = conn->hdev;
 117         struct hci_cp_add_sco cp;
 118
 119         BT_DBG("%p", conn);
 120
 121         conn->state = BT_CONNECT;
 122         conn->out = 1;
 123
 124         cp.handle   = cpu_to_le16(handle);
 125         cp.pkt_type = cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
 126
 127         hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
 128 }
 129
 130 void hci_setup_sync(struct hci_conn *conn, __u16 handle)
 131 {
 132         struct hci_dev *hdev = conn->hdev;
 133         struct hci_cp_setup_sync_conn cp;
 134
 135         BT_DBG("%p", conn);
 136
 137         conn->state = BT_CONNECT;
 138         conn->out = 1;
 139
 140         cp.handle   = cpu_to_le16(handle);
 141         cp.pkt_type = cpu_to_le16(hdev->esco_type);
 142
 143         cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 144         cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 145         cp.max_latency    = cpu_to_le16(0xffff);
 146         cp.voice_setting  = cpu_to_le16(hdev->voice_setting);
 147         cp.retrans_effort = 0xff;
 148
 149         hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
 150 }
 151
 152 static void hci_conn_timeout(unsigned long arg)
 153 {
 154         struct hci_conn *conn = (void *) arg;
 155         struct hci_dev *hdev = conn->hdev;
 156
 157         BT_DBG("conn %p state %d", conn, conn->state);
 158
 159         if (atomic_read(&conn->refcnt))
 160                 return;
 161
 162         hci_dev_lock(hdev);
 163
 164         switch (conn->state) {
 165         case BT_CONNECT:
 166                 if (conn->type == ACL_LINK)
 167                         hci_acl_connect_cancel(conn);
 168                 else
 169                         hci_acl_disconn(conn, 0x13);
 170                 break;
 171         case BT_CONNECTED:
 172                 hci_acl_disconn(conn, 0x13);
 173                 break;
 174         default:
 175                 conn->state = BT_CLOSED;
 176                 break;
 177         }
 178
 179         hci_dev_unlock(hdev);
 180 }
 181
 182 static void hci_conn_idle(unsigned long arg)
 183 {
 184         struct hci_conn *conn = (void *) arg;
 185
 186         BT_DBG("conn %p mode %d", conn, conn->mode);
 187
 188         hci_conn_enter_sniff_mode(conn);
 189 }
 190
 191 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
 192 {
 193         struct hci_conn *conn;
 194
 195         BT_DBG("%s dst %s", hdev->name, batostr(dst));
 196
 197         conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
 198         if (!conn)
 199                 return NULL;
 200
 201         bacpy(&conn->dst, dst);
 202         conn->hdev   = hdev;
 203         conn->type   = type;
 204         conn->mode   = HCI_CM_ACTIVE;
 205         conn->state  = BT_OPEN;
 206
 207         conn->power_save = 1;
 208
 209         skb_queue_head_init(&conn->data_q);
 210
 211         setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
 212         setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
 213
 214         atomic_set(&conn->refcnt, 0);
 215
 216         hci_dev_hold(hdev);
 217
 218         tasklet_disable(&hdev->tx_task);
 219
 220         hci_conn_hash_add(hdev, conn);
 221         if (hdev->notify)
 222                 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
 223
 224         hci_conn_add_sysfs(conn);
 225
 226         tasklet_enable(&hdev->tx_task);
 227
 228         return conn;
 229 }
 230
 231 int hci_conn_del(struct hci_conn *conn)
 232 {
 233         struct hci_dev *hdev = conn->hdev;
 234
 235         BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
 236
 237         del_timer(&conn->idle_timer);
 238
 239         del_timer(&conn->disc_timer);
 240
 241         if (conn->type == ACL_LINK) {
 242                 struct hci_conn *sco = conn->link;
 243                 if (sco)
 244                         sco->link = NULL;
 245
 246                 /* Unacked frames */
 247                 hdev->acl_cnt += conn->sent;
 248         } else {
 249                 struct hci_conn *acl = conn->link;
 250                 if (acl) {
 251                         acl->link = NULL;
 252                         hci_conn_put(acl);
 253                 }
 254         }
 255
 256         tasklet_disable(&hdev->tx_task);
 257         hci_conn_hash_del(hdev, conn);
 258         if (hdev->notify)
 259                 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
 260         tasklet_enable(&hdev->tx_task);
 261         skb_queue_purge(&conn->data_q);
 262         hci_conn_del_sysfs(conn);
 263         hci_dev_put(hdev);
 264
 265         return 0;
 266 }
 267
 268 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
 269 {
 270         int use_src = bacmp(src, BDADDR_ANY);
 271         struct hci_dev *hdev = NULL;
 272         struct list_head *p;
 273
 274         BT_DBG("%s -> %s", batostr(src), batostr(dst));
 275
 276         read_lock_bh(&hci_dev_list_lock);
 277
 278         list_for_each(p, &hci_dev_list) {
 279                 struct hci_dev *d = list_entry(p, struct hci_dev, list);
 280
 281                 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
 282                         continue;
 283
 284                 /* Simple routing:
 285                  *   No source address - find interface with bdaddr != dst
 286                  *   Source address    - find interface with bdaddr == src
 287                  */
 288
 289                 if (use_src) {
 290                         if (!bacmp(&d->bdaddr, src)) {
 291                                 hdev = d; break;
 292                         }
 293                 } else {
 294                         if (bacmp(&d->bdaddr, dst)) {
 295                                 hdev = d; break;
 296                         }
 297                 }
 298         }
 299
 300         if (hdev)
 301                 hdev = hci_dev_hold(hdev);
 302
 303         read_unlock_bh(&hci_dev_list_lock);
 304         return hdev;
 305 }
 306 EXPORT_SYMBOL(hci_get_route);
 307
 308 /* Create SCO or ACL connection.
 309  * Device _must_ be locked */
 310 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
 311 {
 312         struct hci_conn *acl;
 313         struct hci_conn *sco;
 314
 315         BT_DBG("%s dst %s", hdev->name, batostr(dst));
 316
 317         if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
 318                 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
 319                         return NULL;
 320         }
 321
 322         hci_conn_hold(acl);
 323
 324         if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
 325                 hci_acl_connect(acl);
 326
 327         if (type == ACL_LINK)
 328                 return acl;
 329
 330         if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
 331                 if (!(sco = hci_conn_add(hdev, type, dst))) {
 332                         hci_conn_put(acl);
 333                         return NULL;
 334                 }
 335         }
 336
 337         acl->link = sco;
 338         sco->link = acl;
 339
 340         hci_conn_hold(sco);
 341
 342         if (acl->state == BT_CONNECTED &&
 343                         (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
 344                 if (lmp_esco_capable(hdev))
 345                         hci_setup_sync(sco, acl->handle);
 346                 else
 347                         hci_add_sco(sco, acl->handle);
 348         }
 349
 350         return sco;
 351 }
 352 EXPORT_SYMBOL(hci_connect);
 353
 354 /* Authenticate remote device */
 355 int hci_conn_auth(struct hci_conn *conn)
 356 {
 357         BT_DBG("conn %p", conn);
 358
 359         if (conn->link_mode & HCI_LM_AUTH)
 360                 return 1;
 361
 362         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
 363                 struct hci_cp_auth_requested cp;
 364                 cp.handle = cpu_to_le16(conn->handle);
 365                 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
 366         }
 367         return 0;
 368 }
 369 EXPORT_SYMBOL(hci_conn_auth);
 370
 371 /* Enable encryption */
 372 int hci_conn_encrypt(struct hci_conn *conn)
 373 {
 374         BT_DBG("conn %p", conn);
 375
 376         if (conn->link_mode & HCI_LM_ENCRYPT)
 377                 return 1;
 378
 379         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
 380                 return 0;
 381
 382         if (hci_conn_auth(conn)) {
 383                 struct hci_cp_set_conn_encrypt cp;
 384                 cp.handle  = cpu_to_le16(conn->handle);
 385                 cp.encrypt = 1;
 386                 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
 387         }
 388         return 0;
 389 }
 390 EXPORT_SYMBOL(hci_conn_encrypt);
 391
 392 /* Change link key */
 393 int hci_conn_change_link_key(struct hci_conn *conn)
 394 {
 395         BT_DBG("conn %p", conn);
 396
 397         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
 398                 struct hci_cp_change_conn_link_key cp;
 399                 cp.handle = cpu_to_le16(conn->handle);
 400                 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
 401         }
 402         return 0;
 403 }
 404 EXPORT_SYMBOL(hci_conn_change_link_key);
 405
 406 /* Switch role */
 407 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
 408 {
 409         BT_DBG("conn %p", conn);
 410
 411         if (!role && conn->link_mode & HCI_LM_MASTER)
 412                 return 1;
 413
 414         if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
 415                 struct hci_cp_switch_role cp;
 416                 bacpy(&cp.bdaddr, &conn->dst);
 417                 cp.role = role;
 418                 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
 419         }
 420         return 0;
 421 }
 422 EXPORT_SYMBOL(hci_conn_switch_role);
 423
 424 /* Enter active mode */
 425 void hci_conn_enter_active_mode(struct hci_conn *conn)
 426 {
 427         struct hci_dev *hdev = conn->hdev;
 428
 429         BT_DBG("conn %p mode %d", conn, conn->mode);
 430
 431         if (test_bit(HCI_RAW, &hdev->flags))
 432                 return;
 433
 434         if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
 435                 goto timer;
 436
 437         if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
 438                 struct hci_cp_exit_sniff_mode cp;
 439                 cp.handle = cpu_to_le16(conn->handle);
 440                 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
 441         }
 442
 443 timer:
 444         if (hdev->idle_timeout > 0)
 445                 mod_timer(&conn->idle_timer,
 446                         jiffies + msecs_to_jiffies(hdev->idle_timeout));
 447 }
 448
 449 /* Enter sniff mode */
 450 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
 451 {
 452         struct hci_dev *hdev = conn->hdev;
 453
 454         BT_DBG("conn %p mode %d", conn, conn->mode);
 455
 456         if (test_bit(HCI_RAW, &hdev->flags))
 457                 return;
 458
 459         if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
 460                 return;
 461
 462         if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
 463                 return;
 464
 465         if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
 466                 struct hci_cp_sniff_subrate cp;
 467                 cp.handle             = cpu_to_le16(conn->handle);
 468                 cp.max_latency        = cpu_to_le16(0);
 469                 cp.min_remote_timeout = cpu_to_le16(0);
 470                 cp.min_local_timeout  = cpu_to_le16(0);
 471                 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
 472         }
 473
 474         if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
 475                 struct hci_cp_sniff_mode cp;
 476                 cp.handle       = cpu_to_le16(conn->handle);
 477                 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
 478                 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
 479                 cp.attempt      = cpu_to_le16(4);
 480                 cp.timeout      = cpu_to_le16(1);
 481                 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
 482         }
 483 }
 484
 485 /* Drop all connection on the device */
 486 void hci_conn_hash_flush(struct hci_dev *hdev)
 487 {
 488         struct hci_conn_hash *h = &hdev->conn_hash;
 489         struct list_head *p;
 490
 491         BT_DBG("hdev %s", hdev->name);
 492
 493         p = h->list.next;
 494         while (p != &h->list) {
 495                 struct hci_conn *c;
 496
 497                 c = list_entry(p, struct hci_conn, list);
 498                 p = p->next;
 499
 500                 c->state = BT_CLOSED;
 501
 502                 hci_proto_disconn_ind(c, 0x16);
 503                 hci_conn_del(c);
 504         }
 505 }
 506
 507 /* Check pending connect attempts */
 508 void hci_conn_check_pending(struct hci_dev *hdev)
 509 {
 510         struct hci_conn *conn;
 511
 512         BT_DBG("hdev %s", hdev->name);
 513
 514         hci_dev_lock(hdev);
 515
 516         conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
 517         if (conn)
 518                 hci_acl_connect(conn);
 519
 520         hci_dev_unlock(hdev);
 521 }
 522
 523 int hci_get_conn_list(void __user *arg)
 524 {
 525         struct hci_conn_list_req req, *cl;
 526         struct hci_conn_info *ci;
 527         struct hci_dev *hdev;
 528         struct list_head *p;
 529         int n = 0, size, err;
 530
 531         if (copy_from_user(&req, arg, sizeof(req)))
 532                 return -EFAULT;
 533
 534         if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
 535                 return -EINVAL;
 536
 537         size = sizeof(req) + req.conn_num * sizeof(*ci);
 538
 539         if (!(cl = kmalloc(size, GFP_KERNEL)))
 540                 return -ENOMEM;
 541
 542         if (!(hdev = hci_dev_get(req.dev_id))) {
 543                 kfree(cl);
 544                 return -ENODEV;
 545         }
 546
 547         ci = cl->conn_info;
 548
 549         hci_dev_lock_bh(hdev);
 550         list_for_each(p, &hdev->conn_hash.list) {
 551                 register struct hci_conn *c;
 552                 c = list_entry(p, struct hci_conn, list);
 553
 554                 bacpy(&(ci + n)->bdaddr, &c->dst);
 555                 (ci + n)->handle = c->handle;
 556                 (ci + n)->type  = c->type;
 557                 (ci + n)->out   = c->out;
 558                 (ci + n)->state = c->state;
 559                 (ci + n)->link_mode = c->link_mode;
 560                 if (++n >= req.conn_num)
 561                         break;
 562         }
 563         hci_dev_unlock_bh(hdev);
 564
 565         cl->dev_id = hdev->id;
 566         cl->conn_num = n;
 567         size = sizeof(req) + n * sizeof(*ci);
 568
 569         hci_dev_put(hdev);
 570
 571         err = copy_to_user(arg, cl, size);
 572         kfree(cl);
 573
 574         return err ? -EFAULT : 0;
 575 }
 576
 577 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
 578 {
 579         struct hci_conn_info_req req;
 580         struct hci_conn_info ci;
 581         struct hci_conn *conn;
 582         char __user *ptr = arg + sizeof(req);
 583
 584         if (copy_from_user(&req, arg, sizeof(req)))
 585                 return -EFAULT;
 586
 587         hci_dev_lock_bh(hdev);
 588         conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
 589         if (conn) {
 590                 bacpy(&ci.bdaddr, &conn->dst);
 591                 ci.handle = conn->handle;
 592                 ci.type  = conn->type;
 593                 ci.out   = conn->out;
 594                 ci.state = conn->state;
 595                 ci.link_mode = conn->link_mode;
 596         }
 597         hci_dev_unlock_bh(hdev);
 598
 599         if (!conn)
 600                 return -ENOENT;
 601
 602         return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
 603 }