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/sched.h>
  33 #include <linux/slab.h>
  34 #include <linux/poll.h>
  35 #include <linux/fcntl.h>
  36 #include <linux/init.h>
  37 #include <linux/skbuff.h>
  38 #include <linux/interrupt.h>
  39 #include <linux/notifier.h>
  40 #include <net/sock.h>
  41
  42 #include <asm/system.h>
  43 #include <asm/uaccess.h>
  44 #include <asm/unaligned.h>
  45
  46 #include <net/bluetooth/bluetooth.h>
  47 #include <net/bluetooth/hci_core.h>
  48
  49 #ifndef CONFIG_BT_HCI_CORE_DEBUG
  50 #undef  BT_DBG
  51 #define BT_DBG(D...)
  52 #endif
  53
  54 static void hci_acl_connect(struct hci_conn *conn)
  55 {
  56         struct hci_dev *hdev = conn->hdev;
  57         struct inquiry_entry *ie;
  58         struct hci_cp_create_conn cp;
  59
  60         BT_DBG("%p", conn);
  61
  62         conn->state = BT_CONNECT;
  63         conn->out   = 1;
  64         conn->link_mode = HCI_LM_MASTER;
  65
  66         memset(&cp, 0, sizeof(cp));
  67         bacpy(&cp.bdaddr, &conn->dst);
  68         cp.pscan_rep_mode = 0x02;
  69
  70         if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)) &&
  71                         inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
  72                 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
  73                 cp.pscan_mode     = ie->data.pscan_mode;
  74                 cp.clock_offset   = ie->data.clock_offset | __cpu_to_le16(0x8000);
  75                 memcpy(conn->dev_class, ie->data.dev_class, 3);
  76         }
  77
  78         cp.pkt_type = __cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK);
  79         if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
  80                 cp.role_switch  = 0x01;
  81         else
  82                 cp.role_switch  = 0x00;
  83
  84         hci_send_cmd(hdev, OGF_LINK_CTL, OCF_CREATE_CONN, sizeof(cp), &cp);
  85 }
  86
  87 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
  88 {
  89         struct hci_cp_disconnect cp;
  90
  91         BT_DBG("%p", conn);
  92
  93         conn->state = BT_DISCONN;
  94
  95         cp.handle = __cpu_to_le16(conn->handle);
  96         cp.reason = reason;
  97         hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_DISCONNECT, sizeof(cp), &cp);
  98 }
  99
 100 void hci_add_sco(struct hci_conn *conn, __u16 handle)
 101 {
 102         struct hci_dev *hdev = conn->hdev;
 103         struct hci_cp_add_sco cp;
 104
 105         BT_DBG("%p", conn);
 106
 107         conn->state = BT_CONNECT;
 108         conn->out = 1;
 109
 110         cp.pkt_type = __cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
 111         cp.handle   = __cpu_to_le16(handle);
 112
 113         hci_send_cmd(hdev, OGF_LINK_CTL, OCF_ADD_SCO, sizeof(cp), &cp);
 114 }
 115
 116 static void hci_conn_timeout(unsigned long arg)
 117 {
 118         struct hci_conn *conn = (void *)arg;
 119         struct hci_dev  *hdev = conn->hdev;
 120
 121         BT_DBG("conn %p state %d", conn, conn->state);
 122
 123         if (atomic_read(&conn->refcnt))
 124                 return;
 125
 126         hci_dev_lock(hdev);
 127         if (conn->state == BT_CONNECTED)
 128                 hci_acl_disconn(conn, 0x13);
 129         else
 130                 conn->state = BT_CLOSED;
 131         hci_dev_unlock(hdev);
 132         return;
 133 }
 134
 135 static void hci_conn_init_timer(struct hci_conn *conn)
 136 {
 137         init_timer(&conn->timer);
 138         conn->timer.function = hci_conn_timeout;
 139         conn->timer.data = (unsigned long)conn;
 140 }
 141
 142 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
 143 {
 144         struct hci_conn *conn;
 145
 146         BT_DBG("%s dst %s", hdev->name, batostr(dst));
 147
 148         if (!(conn = kmalloc(sizeof(struct hci_conn), GFP_ATOMIC)))
 149                 return NULL;
 150         memset(conn, 0, sizeof(struct hci_conn));
 151
 152         bacpy(&conn->dst, dst);
 153         conn->type   = type;
 154         conn->hdev   = hdev;
 155         conn->state  = BT_OPEN;
 156
 157         skb_queue_head_init(&conn->data_q);
 158         hci_conn_init_timer(conn);
 159
 160         atomic_set(&conn->refcnt, 0);
 161
 162         hci_dev_hold(hdev);
 163
 164         tasklet_disable(&hdev->tx_task);
 165
 166         hci_conn_hash_add(hdev, conn);
 167         if (hdev->notify)
 168                 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
 169
 170         tasklet_enable(&hdev->tx_task);
 171
 172         return conn;
 173 }
 174
 175 int hci_conn_del(struct hci_conn *conn)
 176 {
 177         struct hci_dev *hdev = conn->hdev;
 178
 179         BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
 180
 181         hci_conn_del_timer(conn);
 182
 183         if (conn->type == SCO_LINK) {
 184                 struct hci_conn *acl = conn->link;
 185                 if (acl) {
 186                         acl->link = NULL;
 187                         hci_conn_put(acl);
 188                 }
 189         } else {
 190                 struct hci_conn *sco = conn->link;
 191                 if (sco)
 192                         sco->link = NULL;
 193
 194                 /* Unacked frames */
 195                 hdev->acl_cnt += conn->sent;
 196         }
 197
 198         tasklet_disable(&hdev->tx_task);
 199
 200         hci_conn_hash_del(hdev, conn);
 201         if (hdev->notify)
 202                 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
 203
 204         tasklet_enable(&hdev->tx_task);
 205
 206         skb_queue_purge(&conn->data_q);
 207
 208         hci_dev_put(hdev);
 209
 210         kfree(conn);
 211         return 0;
 212 }
 213
 214 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
 215 {
 216         int use_src = bacmp(src, BDADDR_ANY);
 217         struct hci_dev *hdev = NULL;
 218         struct list_head *p;
 219
 220         BT_DBG("%s -> %s", batostr(src), batostr(dst));
 221
 222         read_lock_bh(&hci_dev_list_lock);
 223
 224         list_for_each(p, &hci_dev_list) {
 225                 struct hci_dev *d = list_entry(p, struct hci_dev, list);
 226
 227                 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
 228                         continue;
 229
 230                 /* Simple routing:
 231                  *   No source address - find interface with bdaddr != dst
 232                  *   Source address    - find interface with bdaddr == src
 233                  */
 234
 235                 if (use_src) {
 236                         if (!bacmp(&d->bdaddr, src)) {
 237                                 hdev = d; break;
 238                         }
 239                 } else {
 240                         if (bacmp(&d->bdaddr, dst)) {
 241                                 hdev = d; break;
 242                         }
 243                 }
 244         }
 245
 246         if (hdev)
 247                 hdev = hci_dev_hold(hdev);
 248
 249         read_unlock_bh(&hci_dev_list_lock);
 250         return hdev;
 251 }
 252 EXPORT_SYMBOL(hci_get_route);
 253
 254 /* Create SCO or ACL connection.
 255  * Device _must_ be locked */
 256 struct hci_conn * hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
 257 {
 258         struct hci_conn *acl;
 259
 260         BT_DBG("%s dst %s", hdev->name, batostr(dst));
 261
 262         if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
 263                 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
 264                         return NULL;
 265         }
 266
 267         hci_conn_hold(acl);
 268
 269         if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
 270                 hci_acl_connect(acl);
 271
 272         if (type == SCO_LINK) {
 273                 struct hci_conn *sco;
 274
 275                 if (!(sco = hci_conn_hash_lookup_ba(hdev, SCO_LINK, dst))) {
 276                         if (!(sco = hci_conn_add(hdev, SCO_LINK, dst))) {
 277                                 hci_conn_put(acl);
 278                                 return NULL;
 279                         }
 280                 }
 281                 acl->link = sco;
 282                 sco->link = acl;
 283
 284                 hci_conn_hold(sco);
 285
 286                 if (acl->state == BT_CONNECTED &&
 287                                 (sco->state == BT_OPEN || sco->state == BT_CLOSED))
 288                         hci_add_sco(sco, acl->handle);
 289
 290                 return sco;
 291         } else {
 292                 return acl;
 293         }
 294 }
 295 EXPORT_SYMBOL(hci_connect);
 296
 297 /* Authenticate remote device */
 298 int hci_conn_auth(struct hci_conn *conn)
 299 {
 300         BT_DBG("conn %p", conn);
 301
 302         if (conn->link_mode & HCI_LM_AUTH)
 303                 return 1;
 304
 305         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
 306                 struct hci_cp_auth_requested cp;
 307                 cp.handle = __cpu_to_le16(conn->handle);
 308                 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_AUTH_REQUESTED, sizeof(cp), &cp);
 309         }
 310         return 0;
 311 }
 312 EXPORT_SYMBOL(hci_conn_auth);
 313
 314 /* Enable encryption */
 315 int hci_conn_encrypt(struct hci_conn *conn)
 316 {
 317         BT_DBG("conn %p", conn);
 318
 319         if (conn->link_mode & HCI_LM_ENCRYPT)
 320                 return 1;
 321
 322         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
 323                 return 0;
 324
 325         if (hci_conn_auth(conn)) {
 326                 struct hci_cp_set_conn_encrypt cp;
 327                 cp.handle  = __cpu_to_le16(conn->handle);
 328                 cp.encrypt = 1;
 329                 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT, sizeof(cp), &cp);
 330         }
 331         return 0;
 332 }
 333 EXPORT_SYMBOL(hci_conn_encrypt);
 334
 335 /* Change link key */
 336 int hci_conn_change_link_key(struct hci_conn *conn)
 337 {
 338         BT_DBG("conn %p", conn);
 339
 340         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
 341                 struct hci_cp_change_conn_link_key cp;
 342                 cp.handle = __cpu_to_le16(conn->handle);
 343                 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
 344         }
 345         return 0;
 346 }
 347 EXPORT_SYMBOL(hci_conn_change_link_key);
 348
 349 /* Switch role */
 350 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
 351 {
 352         BT_DBG("conn %p", conn);
 353
 354         if (!role && conn->link_mode & HCI_LM_MASTER)
 355                 return 1;
 356
 357         if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
 358                 struct hci_cp_switch_role cp;
 359                 bacpy(&cp.bdaddr, &conn->dst);
 360                 cp.role = role;
 361                 hci_send_cmd(conn->hdev, OGF_LINK_POLICY, OCF_SWITCH_ROLE, sizeof(cp), &cp);
 362         }
 363         return 0;
 364 }
 365 EXPORT_SYMBOL(hci_conn_switch_role);
 366
 367 /* Drop all connection on the device */
 368 void hci_conn_hash_flush(struct hci_dev *hdev)
 369 {
 370         struct hci_conn_hash *h = &hdev->conn_hash;
 371         struct list_head *p;
 372
 373         BT_DBG("hdev %s", hdev->name);
 374
 375         p = h->list.next;
 376         while (p != &h->list) {
 377                 struct hci_conn *c;
 378
 379                 c = list_entry(p, struct hci_conn, list);
 380                 p = p->next;
 381
 382                 c->state = BT_CLOSED;
 383
 384                 hci_proto_disconn_ind(c, 0x16);
 385                 hci_conn_del(c);
 386         }
 387 }
 388
 389 int hci_get_conn_list(void __user *arg)
 390 {
 391         struct hci_conn_list_req req, *cl;
 392         struct hci_conn_info *ci;
 393         struct hci_dev *hdev;
 394         struct list_head *p;
 395         int n = 0, size, err;
 396
 397         if (copy_from_user(&req, arg, sizeof(req)))
 398                 return -EFAULT;
 399
 400         if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
 401                 return -EINVAL;
 402
 403         size = sizeof(req) + req.conn_num * sizeof(*ci);
 404
 405         if (!(cl = kmalloc(size, GFP_KERNEL)))
 406                 return -ENOMEM;
 407
 408         if (!(hdev = hci_dev_get(req.dev_id))) {
 409                 kfree(cl);
 410                 return -ENODEV;
 411         }
 412
 413         ci = cl->conn_info;
 414
 415         hci_dev_lock_bh(hdev);
 416         list_for_each(p, &hdev->conn_hash.list) {
 417                 register struct hci_conn *c;
 418                 c = list_entry(p, struct hci_conn, list);
 419
 420                 bacpy(&(ci + n)->bdaddr, &c->dst);
 421                 (ci + n)->handle = c->handle;
 422                 (ci + n)->type  = c->type;
 423                 (ci + n)->out   = c->out;
 424                 (ci + n)->state = c->state;
 425                 (ci + n)->link_mode = c->link_mode;
 426                 if (++n >= req.conn_num)
 427                         break;
 428         }
 429         hci_dev_unlock_bh(hdev);
 430
 431         cl->dev_id = hdev->id;
 432         cl->conn_num = n;
 433         size = sizeof(req) + n * sizeof(*ci);
 434
 435         hci_dev_put(hdev);
 436
 437         err = copy_to_user(arg, cl, size);
 438         kfree(cl);
 439
 440         return err ? -EFAULT : 0;
 441 }
 442
 443 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
 444 {
 445         struct hci_conn_info_req req;
 446         struct hci_conn_info ci;
 447         struct hci_conn *conn;
 448         char __user *ptr = arg + sizeof(req);
 449
 450         if (copy_from_user(&req, arg, sizeof(req)))
 451                 return -EFAULT;
 452
 453         hci_dev_lock_bh(hdev);
 454         conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
 455         if (conn) {
 456                 bacpy(&ci.bdaddr, &conn->dst);
 457                 ci.handle = conn->handle;
 458                 ci.type  = conn->type;
 459                 ci.out   = conn->out;
 460                 ci.state = conn->state;
 461                 ci.link_mode = conn->link_mode;
 462         }
 463         hci_dev_unlock_bh(hdev);
 464
 465         if (!conn)
 466                 return -ENOENT;
 467
 468         return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
 469 }