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