net/bluetooth/hci_conn.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
   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 <linux/uaccess.h>
  43 #include <asm/unaligned.h>
  44
  45 #include <net/bluetooth/bluetooth.h>
  46 #include <net/bluetooth/hci_core.h>
  47
  48 void hci_acl_connect(struct hci_conn *conn)
  49 {
  50         struct hci_dev *hdev = conn->hdev;
  51         struct inquiry_entry *ie;
  52         struct hci_cp_create_conn cp;
  53
  54         BT_DBG("%p", conn);
  55
  56         conn->state = BT_CONNECT;
  57         conn->out = 1;
  58
  59         conn->link_mode = HCI_LM_MASTER;
  60
  61         conn->attempt++;
  62
  63         conn->link_policy = hdev->link_policy;
  64
  65         memset(&cp, 0, sizeof(cp));
  66         bacpy(&cp.bdaddr, &conn->dst);
  67         cp.pscan_rep_mode = 0x02;
  68
  69         ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
  70         if (ie) {
  71                 if (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 |
  75                                                         cpu_to_le16(0x8000);
  76                 }
  77
  78                 memcpy(conn->dev_class, ie->data.dev_class, 3);
  79                 conn->ssp_mode = ie->data.ssp_mode;
  80         }
  81
  82         cp.pkt_type = cpu_to_le16(conn->pkt_type);
  83         if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
  84                 cp.role_switch = 0x01;
  85         else
  86                 cp.role_switch = 0x00;
  87
  88         hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
  89 }
  90
  91 static void hci_acl_connect_cancel(struct hci_conn *conn)
  92 {
  93         struct hci_cp_create_conn_cancel cp;
  94
  95         BT_DBG("%p", conn);
  96
  97         if (conn->hdev->hci_ver < 2)
  98                 return;
  99
 100         bacpy(&cp.bdaddr, &conn->dst);
 101         hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
 102 }
 103
 104 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
 105 {
 106         struct hci_cp_disconnect cp;
 107
 108         BT_DBG("%p", conn);
 109
 110         conn->state = BT_DISCONN;
 111
 112         cp.handle = cpu_to_le16(conn->handle);
 113         cp.reason = reason;
 114         hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
 115 }
 116
 117 void hci_add_sco(struct hci_conn *conn, __u16 handle)
 118 {
 119         struct hci_dev *hdev = conn->hdev;
 120         struct hci_cp_add_sco cp;
 121
 122         BT_DBG("%p", conn);
 123
 124         conn->state = BT_CONNECT;
 125         conn->out = 1;
 126
 127         conn->attempt++;
 128
 129         cp.handle   = cpu_to_le16(handle);
 130         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 131
 132         hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
 133 }
 134
 135 void hci_setup_sync(struct hci_conn *conn, __u16 handle)
 136 {
 137         struct hci_dev *hdev = conn->hdev;
 138         struct hci_cp_setup_sync_conn cp;
 139
 140         BT_DBG("%p", conn);
 141
 142         conn->state = BT_CONNECT;
 143         conn->out = 1;
 144
 145         conn->attempt++;
 146
 147         cp.handle   = cpu_to_le16(handle);
 148         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 149
 150         cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 151         cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 152         cp.max_latency    = cpu_to_le16(0xffff);
 153         cp.voice_setting  = cpu_to_le16(hdev->voice_setting);
 154         cp.retrans_effort = 0xff;
 155
 156         hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
 157 }
 158
 159 /* Device _must_ be locked */
 160 void hci_sco_setup(struct hci_conn *conn, __u8 status)
 161 {
 162         struct hci_conn *sco = conn->link;
 163
 164         BT_DBG("%p", conn);
 165
 166         if (!sco)
 167                 return;
 168
 169         if (!status) {
 170                 if (lmp_esco_capable(conn->hdev))
 171                         hci_setup_sync(sco, conn->handle);
 172                 else
 173                         hci_add_sco(sco, conn->handle);
 174         } else {
 175                 hci_proto_connect_cfm(sco, status);
 176                 hci_conn_del(sco);
 177         }
 178 }
 179
 180 static void hci_conn_timeout(unsigned long arg)
 181 {
 182         struct hci_conn *conn = (void *) arg;
 183         struct hci_dev *hdev = conn->hdev;
 184         __u8 reason;
 185
 186         BT_DBG("conn %p state %d", conn, conn->state);
 187
 188         if (atomic_read(&conn->refcnt))
 189                 return;
 190
 191         hci_dev_lock(hdev);
 192
 193         switch (conn->state) {
 194         case BT_CONNECT:
 195         case BT_CONNECT2:
 196                 if (conn->type == ACL_LINK && conn->out)
 197                         hci_acl_connect_cancel(conn);
 198                 break;
 199         case BT_CONFIG:
 200         case BT_CONNECTED:
 201                 reason = hci_proto_disconn_ind(conn);
 202                 hci_acl_disconn(conn, reason);
 203                 break;
 204         default:
 205                 conn->state = BT_CLOSED;
 206                 break;
 207         }
 208
 209         hci_dev_unlock(hdev);
 210 }
 211
 212 static void hci_conn_idle(unsigned long arg)
 213 {
 214         struct hci_conn *conn = (void *) arg;
 215
 216         BT_DBG("conn %p mode %d", conn, conn->mode);
 217
 218         hci_conn_enter_sniff_mode(conn);
 219 }
 220
 221 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
 222 {
 223         struct hci_conn *conn;
 224
 225         BT_DBG("%s dst %s", hdev->name, batostr(dst));
 226
 227         conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
 228         if (!conn)
 229                 return NULL;
 230
 231         bacpy(&conn->dst, dst);
 232         conn->hdev  = hdev;
 233         conn->type  = type;
 234         conn->mode  = HCI_CM_ACTIVE;
 235         conn->state = BT_OPEN;
 236         conn->auth_type = HCI_AT_GENERAL_BONDING;
 237         conn->io_capability = hdev->io_capability;
 238
 239         conn->power_save = 1;
 240         conn->disc_timeout = HCI_DISCONN_TIMEOUT;
 241
 242         switch (type) {
 243         case ACL_LINK:
 244                 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
 245                 break;
 246         case SCO_LINK:
 247                 if (lmp_esco_capable(hdev))
 248                         conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
 249                                         (hdev->esco_type & EDR_ESCO_MASK);
 250                 else
 251                         conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
 252                 break;
 253         case ESCO_LINK:
 254                 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
 255                 break;
 256         }
 257
 258         skb_queue_head_init(&conn->data_q);
 259
 260         setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
 261         setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
 262
 263         atomic_set(&conn->refcnt, 0);
 264
 265         hci_dev_hold(hdev);
 266
 267         tasklet_disable(&hdev->tx_task);
 268
 269         hci_conn_hash_add(hdev, conn);
 270         if (hdev->notify)
 271                 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
 272
 273         atomic_set(&conn->devref, 0);
 274
 275         hci_conn_init_sysfs(conn);
 276
 277         tasklet_enable(&hdev->tx_task);
 278
 279         return conn;
 280 }
 281
 282 int hci_conn_del(struct hci_conn *conn)
 283 {
 284         struct hci_dev *hdev = conn->hdev;
 285
 286         BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
 287
 288         del_timer(&conn->idle_timer);
 289
 290         del_timer(&conn->disc_timer);
 291
 292         if (conn->type == ACL_LINK) {
 293                 struct hci_conn *sco = conn->link;
 294                 if (sco)
 295                         sco->link = NULL;
 296
 297                 /* Unacked frames */
 298                 hdev->acl_cnt += conn->sent;
 299         } else {
 300                 struct hci_conn *acl = conn->link;
 301                 if (acl) {
 302                         acl->link = NULL;
 303                         hci_conn_put(acl);
 304                 }
 305         }
 306
 307         tasklet_disable(&hdev->tx_task);
 308
 309         hci_conn_hash_del(hdev, conn);
 310         if (hdev->notify)
 311                 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
 312
 313         tasklet_enable(&hdev->tx_task);
 314
 315         skb_queue_purge(&conn->data_q);
 316
 317         hci_conn_put_device(conn);
 318
 319         hci_dev_put(hdev);
 320
 321         return 0;
 322 }
 323
 324 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
 325 {
 326         int use_src = bacmp(src, BDADDR_ANY);
 327         struct hci_dev *hdev = NULL;
 328         struct list_head *p;
 329
 330         BT_DBG("%s -> %s", batostr(src), batostr(dst));
 331
 332         read_lock_bh(&hci_dev_list_lock);
 333
 334         list_for_each(p, &hci_dev_list) {
 335                 struct hci_dev *d = list_entry(p, struct hci_dev, list);
 336
 337                 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
 338                         continue;
 339
 340                 /* Simple routing:
 341                  *   No source address - find interface with bdaddr != dst
 342                  *   Source address    - find interface with bdaddr == src
 343                  */
 344
 345                 if (use_src) {
 346                         if (!bacmp(&d->bdaddr, src)) {
 347                                 hdev = d; break;
 348                         }
 349                 } else {
 350                         if (bacmp(&d->bdaddr, dst)) {
 351                                 hdev = d; break;
 352                         }
 353                 }
 354         }
 355
 356         if (hdev)
 357                 hdev = hci_dev_hold(hdev);
 358
 359         read_unlock_bh(&hci_dev_list_lock);
 360         return hdev;
 361 }
 362 EXPORT_SYMBOL(hci_get_route);
 363
 364 /* Create SCO or ACL connection.
 365  * Device _must_ be locked */
 366 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst, __u8 sec_level, __u8 auth_type)
 367 {
 368         struct hci_conn *acl;
 369         struct hci_conn *sco;
 370
 371         BT_DBG("%s dst %s", hdev->name, batostr(dst));
 372
 373         acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
 374         if (!acl) {
 375                 acl = hci_conn_add(hdev, ACL_LINK, dst);
 376                 if (!acl)
 377                         return NULL;
 378         }
 379
 380         hci_conn_hold(acl);
 381
 382         if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
 383                 acl->sec_level = BT_SECURITY_LOW;
 384                 acl->pending_sec_level = sec_level;
 385                 acl->auth_type = auth_type;
 386                 hci_acl_connect(acl);
 387         }
 388
 389         if (type == ACL_LINK)
 390                 return acl;
 391
 392         sco = hci_conn_hash_lookup_ba(hdev, type, dst);
 393         if (!sco) {
 394                 sco = hci_conn_add(hdev, type, dst);
 395                 if (!sco) {
 396                         hci_conn_put(acl);
 397                         return NULL;
 398                 }
 399         }
 400
 401         acl->link = sco;
 402         sco->link = acl;
 403
 404         hci_conn_hold(sco);
 405
 406         if (acl->state == BT_CONNECTED &&
 407                         (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
 408                 acl->power_save = 1;
 409                 hci_conn_enter_active_mode(acl);
 410
 411                 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->pend)) {
 412                         /* defer SCO setup until mode change completed */
 413                         set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->pend);
 414                         return sco;
 415                 }
 416
 417                 hci_sco_setup(acl, 0x00);
 418         }
 419
 420         return sco;
 421 }
 422 EXPORT_SYMBOL(hci_connect);
 423
 424 /* Check link security requirement */
 425 int hci_conn_check_link_mode(struct hci_conn *conn)
 426 {
 427         BT_DBG("conn %p", conn);
 428
 429         if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0 &&
 430                                         !(conn->link_mode & HCI_LM_ENCRYPT))
 431                 return 0;
 432
 433         return 1;
 434 }
 435 EXPORT_SYMBOL(hci_conn_check_link_mode);
 436
 437 /* Authenticate remote device */
 438 static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
 439 {
 440         BT_DBG("conn %p", conn);
 441
 442         if (conn->pending_sec_level > sec_level)
 443                 sec_level = conn->pending_sec_level;
 444
 445         if (sec_level > conn->sec_level)
 446                 conn->pending_sec_level = sec_level;
 447         else if (conn->link_mode & HCI_LM_AUTH)
 448                 return 1;
 449
 450         /* Make sure we preserve an existing MITM requirement*/
 451         auth_type |= (conn->auth_type & 0x01);
 452
 453         conn->auth_type = auth_type;
 454
 455         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
 456                 struct hci_cp_auth_requested cp;
 457                 cp.handle = cpu_to_le16(conn->handle);
 458                 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
 459                                                         sizeof(cp), &cp);
 460         }
 461
 462         return 0;
 463 }
 464
 465 /* Enable security */
 466 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
 467 {
 468         BT_DBG("conn %p", conn);
 469
 470         if (sec_level == BT_SECURITY_SDP)
 471                 return 1;
 472
 473         if (sec_level == BT_SECURITY_LOW &&
 474                                 (!conn->ssp_mode || !conn->hdev->ssp_mode))
 475                 return 1;
 476
 477         if (conn->link_mode & HCI_LM_ENCRYPT)
 478                 return hci_conn_auth(conn, sec_level, auth_type);
 479
 480         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
 481                 return 0;
 482
 483         if (hci_conn_auth(conn, sec_level, auth_type)) {
 484                 struct hci_cp_set_conn_encrypt cp;
 485                 cp.handle  = cpu_to_le16(conn->handle);
 486                 cp.encrypt = 1;
 487                 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT,
 488                                                         sizeof(cp), &cp);
 489         }
 490
 491         return 0;
 492 }
 493 EXPORT_SYMBOL(hci_conn_security);
 494
 495 /* Change link key */
 496 int hci_conn_change_link_key(struct hci_conn *conn)
 497 {
 498         BT_DBG("conn %p", conn);
 499
 500         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
 501                 struct hci_cp_change_conn_link_key cp;
 502                 cp.handle = cpu_to_le16(conn->handle);
 503                 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
 504                                                         sizeof(cp), &cp);
 505         }
 506
 507         return 0;
 508 }
 509 EXPORT_SYMBOL(hci_conn_change_link_key);
 510
 511 /* Switch role */
 512 int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
 513 {
 514         BT_DBG("conn %p", conn);
 515
 516         if (!role && conn->link_mode & HCI_LM_MASTER)
 517                 return 1;
 518
 519         if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
 520                 struct hci_cp_switch_role cp;
 521                 bacpy(&cp.bdaddr, &conn->dst);
 522                 cp.role = role;
 523                 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
 524         }
 525
 526         return 0;
 527 }
 528 EXPORT_SYMBOL(hci_conn_switch_role);
 529
 530 /* Enter active mode */
 531 void hci_conn_enter_active_mode(struct hci_conn *conn)
 532 {
 533         struct hci_dev *hdev = conn->hdev;
 534
 535         BT_DBG("conn %p mode %d", conn, conn->mode);
 536
 537         if (test_bit(HCI_RAW, &hdev->flags))
 538                 return;
 539
 540         if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
 541                 goto timer;
 542
 543         if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
 544                 struct hci_cp_exit_sniff_mode cp;
 545                 cp.handle = cpu_to_le16(conn->handle);
 546                 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
 547         }
 548
 549 timer:
 550         if (hdev->idle_timeout > 0)
 551                 mod_timer(&conn->idle_timer,
 552                         jiffies + msecs_to_jiffies(hdev->idle_timeout));
 553 }
 554
 555 /* Enter sniff mode */
 556 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
 557 {
 558         struct hci_dev *hdev = conn->hdev;
 559
 560         BT_DBG("conn %p mode %d", conn, conn->mode);
 561
 562         if (test_bit(HCI_RAW, &hdev->flags))
 563                 return;
 564
 565         if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
 566                 return;
 567
 568         if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
 569                 return;
 570
 571         if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
 572                 struct hci_cp_sniff_subrate cp;
 573                 cp.handle             = cpu_to_le16(conn->handle);
 574                 cp.max_latency        = cpu_to_le16(0);
 575                 cp.min_remote_timeout = cpu_to_le16(0);
 576                 cp.min_local_timeout  = cpu_to_le16(0);
 577                 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
 578         }
 579
 580         if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
 581                 struct hci_cp_sniff_mode cp;
 582                 cp.handle       = cpu_to_le16(conn->handle);
 583                 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
 584                 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
 585                 cp.attempt      = cpu_to_le16(4);
 586                 cp.timeout      = cpu_to_le16(1);
 587                 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
 588         }
 589 }
 590
 591 /* Drop all connection on the device */
 592 void hci_conn_hash_flush(struct hci_dev *hdev)
 593 {
 594         struct hci_conn_hash *h = &hdev->conn_hash;
 595         struct list_head *p;
 596
 597         BT_DBG("hdev %s", hdev->name);
 598
 599         p = h->list.next;
 600         while (p != &h->list) {
 601                 struct hci_conn *c;
 602
 603                 c = list_entry(p, struct hci_conn, list);
 604                 p = p->next;
 605
 606                 c->state = BT_CLOSED;
 607
 608                 hci_proto_disconn_cfm(c, 0x16);
 609                 hci_conn_del(c);
 610         }
 611 }
 612
 613 /* Check pending connect attempts */
 614 void hci_conn_check_pending(struct hci_dev *hdev)
 615 {
 616         struct hci_conn *conn;
 617
 618         BT_DBG("hdev %s", hdev->name);
 619
 620         hci_dev_lock(hdev);
 621
 622         conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
 623         if (conn)
 624                 hci_acl_connect(conn);
 625
 626         hci_dev_unlock(hdev);
 627 }
 628
 629 void hci_conn_hold_device(struct hci_conn *conn)
 630 {
 631         atomic_inc(&conn->devref);
 632 }
 633 EXPORT_SYMBOL(hci_conn_hold_device);
 634
 635 void hci_conn_put_device(struct hci_conn *conn)
 636 {
 637         if (atomic_dec_and_test(&conn->devref))
 638                 hci_conn_del_sysfs(conn);
 639 }
 640 EXPORT_SYMBOL(hci_conn_put_device);
 641
 642 int hci_get_conn_list(void __user *arg)
 643 {
 644         struct hci_conn_list_req req, *cl;
 645         struct hci_conn_info *ci;
 646         struct hci_dev *hdev;
 647         struct list_head *p;
 648         int n = 0, size, err;
 649
 650         if (copy_from_user(&req, arg, sizeof(req)))
 651                 return -EFAULT;
 652
 653         if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
 654                 return -EINVAL;
 655
 656         size = sizeof(req) + req.conn_num * sizeof(*ci);
 657
 658         cl = kmalloc(size, GFP_KERNEL);
 659         if (!cl)
 660                 return -ENOMEM;
 661
 662         hdev = hci_dev_get(req.dev_id);
 663         if (!hdev) {
 664                 kfree(cl);
 665                 return -ENODEV;
 666         }
 667
 668         ci = cl->conn_info;
 669
 670         hci_dev_lock_bh(hdev);
 671         list_for_each(p, &hdev->conn_hash.list) {
 672                 register struct hci_conn *c;
 673                 c = list_entry(p, struct hci_conn, list);
 674
 675                 bacpy(&(ci + n)->bdaddr, &c->dst);
 676                 (ci + n)->handle = c->handle;
 677                 (ci + n)->type  = c->type;
 678                 (ci + n)->out   = c->out;
 679                 (ci + n)->state = c->state;
 680                 (ci + n)->link_mode = c->link_mode;
 681                 if (++n >= req.conn_num)
 682                         break;
 683         }
 684         hci_dev_unlock_bh(hdev);
 685
 686         cl->dev_id = hdev->id;
 687         cl->conn_num = n;
 688         size = sizeof(req) + n * sizeof(*ci);
 689
 690         hci_dev_put(hdev);
 691
 692         err = copy_to_user(arg, cl, size);
 693         kfree(cl);
 694
 695         return err ? -EFAULT : 0;
 696 }
 697
 698 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
 699 {
 700         struct hci_conn_info_req req;
 701         struct hci_conn_info ci;
 702         struct hci_conn *conn;
 703         char __user *ptr = arg + sizeof(req);
 704
 705         if (copy_from_user(&req, arg, sizeof(req)))
 706                 return -EFAULT;
 707
 708         hci_dev_lock_bh(hdev);
 709         conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
 710         if (conn) {
 711                 bacpy(&ci.bdaddr, &conn->dst);
 712                 ci.handle = conn->handle;
 713                 ci.type  = conn->type;
 714                 ci.out   = conn->out;
 715                 ci.state = conn->state;
 716                 ci.link_mode = conn->link_mode;
 717         }
 718         hci_dev_unlock_bh(hdev);
 719
 720         if (!conn)
 721                 return -ENOENT;
 722
 723         return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
 724 }
 725
 726 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
 727 {
 728         struct hci_auth_info_req req;
 729         struct hci_conn *conn;
 730
 731         if (copy_from_user(&req, arg, sizeof(req)))
 732                 return -EFAULT;
 733
 734         hci_dev_lock_bh(hdev);
 735         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
 736         if (conn)
 737                 req.type = conn->auth_type;
 738         hci_dev_unlock_bh(hdev);
 739
 740         if (!conn)
 741                 return -ENOENT;
 742
 743         return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
 744 }