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