net/bluetooth/bnep/core.c

   1 /*
   2    BNEP implementation for Linux Bluetooth stack (BlueZ).
   3    Copyright (C) 2001-2002 Inventel Systemes
   4    Written 2001-2002 by
   5         Clément Moreau <clement.moreau@inventel.fr>
   6         David Libault  <david.libault@inventel.fr>
   7
   8    Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License version 2 as
  12    published by the Free Software Foundation;
  13
  14    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  17    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  18    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  19    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  21    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  24    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  25    SOFTWARE IS DISCLAIMED.
  26 */
  27
  28 #include <linux/module.h>
  29
  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>
  35 #include <linux/freezer.h>
  36 #include <linux/errno.h>
  37 #include <linux/net.h>
  38 #include <linux/slab.h>
  39 #include <linux/kthread.h>
  40 #include <net/sock.h>
  41
  42 #include <linux/socket.h>
  43 #include <linux/file.h>
  44
  45 #include <linux/netdevice.h>
  46 #include <linux/etherdevice.h>
  47 #include <linux/skbuff.h>
  48
  49 #include <asm/unaligned.h>
  50
  51 #include <net/bluetooth/bluetooth.h>
  52 #include <net/bluetooth/hci_core.h>
  53 #include <net/bluetooth/l2cap.h>
  54
  55 #include "bnep.h"
  56
  57 #define VERSION "1.3"
  58
  59 static int compress_src = 1;
  60 static int compress_dst = 1;
  61
  62 static LIST_HEAD(bnep_session_list);
  63 static DECLARE_RWSEM(bnep_session_sem);
  64
  65 static struct bnep_session *__bnep_get_session(u8 *dst)
  66 {
  67         struct bnep_session *s;
  68         struct list_head *p;
  69
  70         BT_DBG("");
  71
  72         list_for_each(p, &bnep_session_list) {
  73                 s = list_entry(p, struct bnep_session, list);
  74                 if (!compare_ether_addr(dst, s->eh.h_source))
  75                         return s;
  76         }
  77         return NULL;
  78 }
  79
  80 static void __bnep_link_session(struct bnep_session *s)
  81 {
  82         /* It's safe to call __module_get() here because sessions are added
  83            by the socket layer which has to hold the reference to this module.
  84          */
  85         __module_get(THIS_MODULE);
  86         list_add(&s->list, &bnep_session_list);
  87 }
  88
  89 static void __bnep_unlink_session(struct bnep_session *s)
  90 {
  91         list_del(&s->list);
  92         module_put(THIS_MODULE);
  93 }
  94
  95 static int bnep_send(struct bnep_session *s, void *data, size_t len)
  96 {
  97         struct socket *sock = s->sock;
  98         struct kvec iv = { data, len };
  99
 100         return kernel_sendmsg(sock, &s->msg, &iv, 1, len);
 101 }
 102
 103 static int bnep_send_rsp(struct bnep_session *s, u8 ctrl, u16 resp)
 104 {
 105         struct bnep_control_rsp rsp;
 106         rsp.type = BNEP_CONTROL;
 107         rsp.ctrl = ctrl;
 108         rsp.resp = htons(resp);
 109         return bnep_send(s, &rsp, sizeof(rsp));
 110 }
 111
 112 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
 113 static inline void bnep_set_default_proto_filter(struct bnep_session *s)
 114 {
 115         /* (IPv4, ARP)  */
 116         s->proto_filter[0].start = ETH_P_IP;
 117         s->proto_filter[0].end   = ETH_P_ARP;
 118         /* (RARP, AppleTalk) */
 119         s->proto_filter[1].start = ETH_P_RARP;
 120         s->proto_filter[1].end   = ETH_P_AARP;
 121         /* (IPX, IPv6) */
 122         s->proto_filter[2].start = ETH_P_IPX;
 123         s->proto_filter[2].end   = ETH_P_IPV6;
 124 }
 125 #endif
 126
 127 static int bnep_ctrl_set_netfilter(struct bnep_session *s, __be16 *data, int len)
 128 {
 129         int n;
 130
 131         if (len < 2)
 132                 return -EILSEQ;
 133
 134         n = get_unaligned_be16(data);
 135         data++;
 136         len -= 2;
 137
 138         if (len < n)
 139                 return -EILSEQ;
 140
 141         BT_DBG("filter len %d", n);
 142
 143 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
 144         n /= 4;
 145         if (n <= BNEP_MAX_PROTO_FILTERS) {
 146                 struct bnep_proto_filter *f = s->proto_filter;
 147                 int i;
 148
 149                 for (i = 0; i < n; i++) {
 150                         f[i].start = get_unaligned_be16(data++);
 151                         f[i].end   = get_unaligned_be16(data++);
 152
 153                         BT_DBG("proto filter start %d end %d",
 154                                 f[i].start, f[i].end);
 155                 }
 156
 157                 if (i < BNEP_MAX_PROTO_FILTERS)
 158                         memset(f + i, 0, sizeof(*f));
 159
 160                 if (n == 0)
 161                         bnep_set_default_proto_filter(s);
 162
 163                 bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_SUCCESS);
 164         } else {
 165                 bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_LIMIT_REACHED);
 166         }
 167 #else
 168         bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
 169 #endif
 170         return 0;
 171 }
 172
 173 static int bnep_ctrl_set_mcfilter(struct bnep_session *s, u8 *data, int len)
 174 {
 175         int n;
 176
 177         if (len < 2)
 178                 return -EILSEQ;
 179
 180         n = get_unaligned_be16(data);
 181         data += 2;
 182         len -= 2;
 183
 184         if (len < n)
 185                 return -EILSEQ;
 186
 187         BT_DBG("filter len %d", n);
 188
 189 #ifdef CONFIG_BT_BNEP_MC_FILTER
 190         n /= (ETH_ALEN * 2);
 191
 192         if (n > 0) {
 193                 int i;
 194
 195                 s->mc_filter = 0;
 196
 197                 /* Always send broadcast */
 198                 set_bit(bnep_mc_hash(s->dev->broadcast), (ulong *) &s->mc_filter);
 199
 200                 /* Add address ranges to the multicast hash */
 201                 for (; n > 0; n--) {
 202                         u8 a1[6], *a2;
 203
 204                         memcpy(a1, data, ETH_ALEN);
 205                         data += ETH_ALEN;
 206                         a2 = data;
 207                         data += ETH_ALEN;
 208
 209                         BT_DBG("mc filter %s -> %s",
 210                                 batostr((void *) a1), batostr((void *) a2));
 211
 212                         /* Iterate from a1 to a2 */
 213                         set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
 214                         while (memcmp(a1, a2, 6) < 0 && s->mc_filter != ~0LL) {
 215                                 /* Increment a1 */
 216                                 i = 5;
 217                                 while (i >= 0 && ++a1[i--] == 0)
 218                                         ;
 219
 220                                 set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
 221                         }
 222                 }
 223         }
 224
 225         BT_DBG("mc filter hash 0x%llx", s->mc_filter);
 226
 227         bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_SUCCESS);
 228 #else
 229         bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
 230 #endif
 231         return 0;
 232 }
 233
 234 static int bnep_rx_control(struct bnep_session *s, void *data, int len)
 235 {
 236         u8  cmd = *(u8 *)data;
 237         int err = 0;
 238
 239         data++;
 240         len--;
 241
 242         switch (cmd) {
 243         case BNEP_CMD_NOT_UNDERSTOOD:
 244         case BNEP_SETUP_CONN_RSP:
 245         case BNEP_FILTER_NET_TYPE_RSP:
 246         case BNEP_FILTER_MULTI_ADDR_RSP:
 247                 /* Ignore these for now */
 248                 break;
 249
 250         case BNEP_FILTER_NET_TYPE_SET:
 251                 err = bnep_ctrl_set_netfilter(s, data, len);
 252                 break;
 253
 254         case BNEP_FILTER_MULTI_ADDR_SET:
 255                 err = bnep_ctrl_set_mcfilter(s, data, len);
 256                 break;
 257
 258         case BNEP_SETUP_CONN_REQ:
 259                 err = bnep_send_rsp(s, BNEP_SETUP_CONN_RSP, BNEP_CONN_NOT_ALLOWED);
 260                 break;
 261
 262         default: {
 263                         u8 pkt[3];
 264                         pkt[0] = BNEP_CONTROL;
 265                         pkt[1] = BNEP_CMD_NOT_UNDERSTOOD;
 266                         pkt[2] = cmd;
 267                         bnep_send(s, pkt, sizeof(pkt));
 268                 }
 269                 break;
 270         }
 271
 272         return err;
 273 }
 274
 275 static int bnep_rx_extension(struct bnep_session *s, struct sk_buff *skb)
 276 {
 277         struct bnep_ext_hdr *h;
 278         int err = 0;
 279
 280         do {
 281                 h = (void *) skb->data;
 282                 if (!skb_pull(skb, sizeof(*h))) {
 283                         err = -EILSEQ;
 284                         break;
 285                 }
 286
 287                 BT_DBG("type 0x%x len %d", h->type, h->len);
 288
 289                 switch (h->type & BNEP_TYPE_MASK) {
 290                 case BNEP_EXT_CONTROL:
 291                         bnep_rx_control(s, skb->data, skb->len);
 292                         break;
 293
 294                 default:
 295                         /* Unknown extension, skip it. */
 296                         break;
 297                 }
 298
 299                 if (!skb_pull(skb, h->len)) {
 300                         err = -EILSEQ;
 301                         break;
 302                 }
 303         } while (!err && (h->type & BNEP_EXT_HEADER));
 304
 305         return err;
 306 }
 307
 308 static u8 __bnep_rx_hlen[] = {
 309         ETH_HLEN,     /* BNEP_GENERAL */
 310         0,            /* BNEP_CONTROL */
 311         2,            /* BNEP_COMPRESSED */
 312         ETH_ALEN + 2, /* BNEP_COMPRESSED_SRC_ONLY */
 313         ETH_ALEN + 2  /* BNEP_COMPRESSED_DST_ONLY */
 314 };
 315
 316 static inline int bnep_rx_frame(struct bnep_session *s, struct sk_buff *skb)
 317 {
 318         struct net_device *dev = s->dev;
 319         struct sk_buff *nskb;
 320         u8 type;
 321
 322         dev->stats.rx_bytes += skb->len;
 323
 324         type = *(u8 *) skb->data;
 325         skb_pull(skb, 1);
 326
 327         if ((type & BNEP_TYPE_MASK) >= sizeof(__bnep_rx_hlen))
 328                 goto badframe;
 329
 330         if ((type & BNEP_TYPE_MASK) == BNEP_CONTROL) {
 331                 bnep_rx_control(s, skb->data, skb->len);
 332                 kfree_skb(skb);
 333                 return 0;
 334         }
 335
 336         skb_reset_mac_header(skb);
 337
 338         /* Verify and pull out header */
 339         if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK]))
 340                 goto badframe;
 341
 342         s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
 343
 344         if (type & BNEP_EXT_HEADER) {
 345                 if (bnep_rx_extension(s, skb) < 0)
 346                         goto badframe;
 347         }
 348
 349         /* Strip 802.1p header */
 350         if (ntohs(s->eh.h_proto) == 0x8100) {
 351                 if (!skb_pull(skb, 4))
 352                         goto badframe;
 353                 s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
 354         }
 355
 356         /* We have to alloc new skb and copy data here :(. Because original skb
 357          * may not be modified and because of the alignment requirements. */
 358         nskb = alloc_skb(2 + ETH_HLEN + skb->len, GFP_KERNEL);
 359         if (!nskb) {
 360                 dev->stats.rx_dropped++;
 361                 kfree_skb(skb);
 362                 return -ENOMEM;
 363         }
 364         skb_reserve(nskb, 2);
 365
 366         /* Decompress header and construct ether frame */
 367         switch (type & BNEP_TYPE_MASK) {
 368         case BNEP_COMPRESSED:
 369                 memcpy(__skb_put(nskb, ETH_HLEN), &s->eh, ETH_HLEN);
 370                 break;
 371
 372         case BNEP_COMPRESSED_SRC_ONLY:
 373                 memcpy(__skb_put(nskb, ETH_ALEN), s->eh.h_dest, ETH_ALEN);
 374                 memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb), ETH_ALEN);
 375                 put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
 376                 break;
 377
 378         case BNEP_COMPRESSED_DST_ONLY:
 379                 memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb),
 380                                                                 ETH_ALEN);
 381                 memcpy(__skb_put(nskb, ETH_ALEN + 2), s->eh.h_source,
 382                                                                 ETH_ALEN + 2);
 383                 break;
 384
 385         case BNEP_GENERAL:
 386                 memcpy(__skb_put(nskb, ETH_ALEN * 2), skb_mac_header(skb),
 387                                                                 ETH_ALEN * 2);
 388                 put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
 389                 break;
 390         }
 391
 392         skb_copy_from_linear_data(skb, __skb_put(nskb, skb->len), skb->len);
 393         kfree_skb(skb);
 394
 395         dev->stats.rx_packets++;
 396         nskb->ip_summed = CHECKSUM_NONE;
 397         nskb->protocol  = eth_type_trans(nskb, dev);
 398         netif_rx_ni(nskb);
 399         return 0;
 400
 401 badframe:
 402         dev->stats.rx_errors++;
 403         kfree_skb(skb);
 404         return 0;
 405 }
 406
 407 static u8 __bnep_tx_types[] = {
 408         BNEP_GENERAL,
 409         BNEP_COMPRESSED_SRC_ONLY,
 410         BNEP_COMPRESSED_DST_ONLY,
 411         BNEP_COMPRESSED
 412 };
 413
 414 static inline int bnep_tx_frame(struct bnep_session *s, struct sk_buff *skb)
 415 {
 416         struct ethhdr *eh = (void *) skb->data;
 417         struct socket *sock = s->sock;
 418         struct kvec iv[3];
 419         int len = 0, il = 0;
 420         u8 type = 0;
 421
 422         BT_DBG("skb %p dev %p type %d", skb, skb->dev, skb->pkt_type);
 423
 424         if (!skb->dev) {
 425                 /* Control frame sent by us */
 426                 goto send;
 427         }
 428
 429         iv[il++] = (struct kvec) { &type, 1 };
 430         len++;
 431
 432         if (compress_src && !compare_ether_addr(eh->h_dest, s->eh.h_source))
 433                 type |= 0x01;
 434
 435         if (compress_dst && !compare_ether_addr(eh->h_source, s->eh.h_dest))
 436                 type |= 0x02;
 437
 438         if (type)
 439                 skb_pull(skb, ETH_ALEN * 2);
 440
 441         type = __bnep_tx_types[type];
 442         switch (type) {
 443         case BNEP_COMPRESSED_SRC_ONLY:
 444                 iv[il++] = (struct kvec) { eh->h_source, ETH_ALEN };
 445                 len += ETH_ALEN;
 446                 break;
 447
 448         case BNEP_COMPRESSED_DST_ONLY:
 449                 iv[il++] = (struct kvec) { eh->h_dest, ETH_ALEN };
 450                 len += ETH_ALEN;
 451                 break;
 452         }
 453
 454 send:
 455         iv[il++] = (struct kvec) { skb->data, skb->len };
 456         len += skb->len;
 457
 458         /* FIXME: linearize skb */
 459         {
 460                 len = kernel_sendmsg(sock, &s->msg, iv, il, len);
 461         }
 462         kfree_skb(skb);
 463
 464         if (len > 0) {
 465                 s->dev->stats.tx_bytes += len;
 466                 s->dev->stats.tx_packets++;
 467                 return 0;
 468         }
 469
 470         return len;
 471 }
 472
 473 static int bnep_session(void *arg)
 474 {
 475         struct bnep_session *s = arg;
 476         struct net_device *dev = s->dev;
 477         struct sock *sk = s->sock->sk;
 478         struct sk_buff *skb;
 479         wait_queue_t wait;
 480
 481         BT_DBG("");
 482
 483         set_user_nice(current, -15);
 484
 485         init_waitqueue_entry(&wait, current);
 486         add_wait_queue(sk_sleep(sk), &wait);
 487         while (1) {
 488                 set_current_state(TASK_INTERRUPTIBLE);
 489
 490                 if (atomic_read(&s->terminate))
 491                         break;
 492                 /* RX */
 493                 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
 494                         skb_orphan(skb);
 495                         if (!skb_linearize(skb))
 496                                 bnep_rx_frame(s, skb);
 497                         else
 498                                 kfree_skb(skb);
 499                 }
 500
 501                 if (sk->sk_state != BT_CONNECTED)
 502                         break;
 503
 504                 /* TX */
 505                 while ((skb = skb_dequeue(&sk->sk_write_queue)))
 506                         if (bnep_tx_frame(s, skb))
 507                                 break;
 508                 netif_wake_queue(dev);
 509
 510                 schedule();
 511         }
 512         __set_current_state(TASK_RUNNING);
 513         remove_wait_queue(sk_sleep(sk), &wait);
 514
 515         /* Cleanup session */
 516         down_write(&bnep_session_sem);
 517
 518         /* Delete network device */
 519         unregister_netdev(dev);
 520
 521         /* Wakeup user-space polling for socket errors */
 522         s->sock->sk->sk_err = EUNATCH;
 523
 524         wake_up_interruptible(sk_sleep(s->sock->sk));
 525
 526         /* Release the socket */
 527         fput(s->sock->file);
 528
 529         __bnep_unlink_session(s);
 530
 531         up_write(&bnep_session_sem);
 532         free_netdev(dev);
 533         return 0;
 534 }
 535
 536 static struct device *bnep_get_device(struct bnep_session *session)
 537 {
 538         bdaddr_t *src = &bt_sk(session->sock->sk)->src;
 539         bdaddr_t *dst = &bt_sk(session->sock->sk)->dst;
 540         struct hci_dev *hdev;
 541         struct hci_conn *conn;
 542
 543         hdev = hci_get_route(dst, src);
 544         if (!hdev)
 545                 return NULL;
 546
 547         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
 548
 549         hci_dev_put(hdev);
 550
 551         return conn ? &conn->dev : NULL;
 552 }
 553
 554 static struct device_type bnep_type = {
 555         .name   = "bluetooth",
 556 };
 557
 558 int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
 559 {
 560         struct net_device *dev;
 561         struct bnep_session *s, *ss;
 562         u8 dst[ETH_ALEN], src[ETH_ALEN];
 563         int err;
 564
 565         BT_DBG("");
 566
 567         baswap((void *) dst, &bt_sk(sock->sk)->dst);
 568         baswap((void *) src, &bt_sk(sock->sk)->src);
 569
 570         /* session struct allocated as private part of net_device */
 571         dev = alloc_netdev(sizeof(struct bnep_session),
 572                                 (*req->device) ? req->device : "bnep%d",
 573                                 bnep_net_setup);
 574         if (!dev)
 575                 return -ENOMEM;
 576
 577         down_write(&bnep_session_sem);
 578
 579         ss = __bnep_get_session(dst);
 580         if (ss && ss->state == BT_CONNECTED) {
 581                 err = -EEXIST;
 582                 goto failed;
 583         }
 584
 585         s = netdev_priv(dev);
 586
 587         /* This is rx header therefore addresses are swapped.
 588          * ie. eh.h_dest is our local address. */
 589         memcpy(s->eh.h_dest,   &src, ETH_ALEN);
 590         memcpy(s->eh.h_source, &dst, ETH_ALEN);
 591         memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);
 592
 593         s->dev   = dev;
 594         s->sock  = sock;
 595         s->role  = req->role;
 596         s->state = BT_CONNECTED;
 597
 598         s->msg.msg_flags = MSG_NOSIGNAL;
 599
 600 #ifdef CONFIG_BT_BNEP_MC_FILTER
 601         /* Set default mc filter */
 602         set_bit(bnep_mc_hash(dev->broadcast), (ulong *) &s->mc_filter);
 603 #endif
 604
 605 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
 606         /* Set default protocol filter */
 607         bnep_set_default_proto_filter(s);
 608 #endif
 609
 610         SET_NETDEV_DEV(dev, bnep_get_device(s));
 611         SET_NETDEV_DEVTYPE(dev, &bnep_type);
 612
 613         err = register_netdev(dev);
 614         if (err)
 615                 goto failed;
 616
 617         __bnep_link_session(s);
 618
 619         s->task = kthread_run(bnep_session, s, "kbnepd %s", dev->name);
 620         if (IS_ERR(s->task)) {
 621                 /* Session thread start failed, gotta cleanup. */
 622                 unregister_netdev(dev);
 623                 __bnep_unlink_session(s);
 624                 err = PTR_ERR(s->task);
 625                 goto failed;
 626         }
 627
 628         up_write(&bnep_session_sem);
 629         strcpy(req->device, dev->name);
 630         return 0;
 631
 632 failed:
 633         up_write(&bnep_session_sem);
 634         free_netdev(dev);
 635         return err;
 636 }
 637
 638 int bnep_del_connection(struct bnep_conndel_req *req)
 639 {
 640         struct bnep_session *s;
 641         int  err = 0;
 642
 643         BT_DBG("");
 644
 645         down_read(&bnep_session_sem);
 646
 647         s = __bnep_get_session(req->dst);
 648         if (s) {
 649                 atomic_inc(&s->terminate);
 650                 wake_up_process(s->task);
 651         } else
 652                 err = -ENOENT;
 653
 654         up_read(&bnep_session_sem);
 655         return err;
 656 }
 657
 658 static void __bnep_copy_ci(struct bnep_conninfo *ci, struct bnep_session *s)
 659 {
 660         memset(ci, 0, sizeof(*ci));
 661         memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
 662         strcpy(ci->device, s->dev->name);
 663         ci->flags = s->flags;
 664         ci->state = s->state;
 665         ci->role  = s->role;
 666 }
 667
 668 int bnep_get_connlist(struct bnep_connlist_req *req)
 669 {
 670         struct list_head *p;
 671         int err = 0, n = 0;
 672
 673         down_read(&bnep_session_sem);
 674
 675         list_for_each(p, &bnep_session_list) {
 676                 struct bnep_session *s;
 677                 struct bnep_conninfo ci;
 678
 679                 s = list_entry(p, struct bnep_session, list);
 680
 681                 __bnep_copy_ci(&ci, s);
 682
 683                 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
 684                         err = -EFAULT;
 685                         break;
 686                 }
 687
 688                 if (++n >= req->cnum)
 689                         break;
 690
 691                 req->ci++;
 692         }
 693         req->cnum = n;
 694
 695         up_read(&bnep_session_sem);
 696         return err;
 697 }
 698
 699 int bnep_get_conninfo(struct bnep_conninfo *ci)
 700 {
 701         struct bnep_session *s;
 702         int err = 0;
 703
 704         down_read(&bnep_session_sem);
 705
 706         s = __bnep_get_session(ci->dst);
 707         if (s)
 708                 __bnep_copy_ci(ci, s);
 709         else
 710                 err = -ENOENT;
 711
 712         up_read(&bnep_session_sem);
 713         return err;
 714 }
 715
 716 static int __init bnep_init(void)
 717 {
 718         char flt[50] = "";
 719
 720 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
 721         strcat(flt, "protocol ");
 722 #endif
 723
 724 #ifdef CONFIG_BT_BNEP_MC_FILTER
 725         strcat(flt, "multicast");
 726 #endif
 727
 728         BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION);
 729         if (flt[0])
 730                 BT_INFO("BNEP filters: %s", flt);
 731
 732         bnep_sock_init();
 733         return 0;
 734 }
 735
 736 static void __exit bnep_exit(void)
 737 {
 738         bnep_sock_cleanup();
 739 }
 740
 741 module_init(bnep_init);
 742 module_exit(bnep_exit);
 743
 744 module_param(compress_src, bool, 0644);
 745 MODULE_PARM_DESC(compress_src, "Compress sources headers");
 746
 747 module_param(compress_dst, bool, 0644);
 748 MODULE_PARM_DESC(compress_dst, "Compress destination headers");
 749
 750 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 751 MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION);
 752 MODULE_VERSION(VERSION);
 753 MODULE_LICENSE("GPL");
 754 MODULE_ALIAS("bt-proto-4");