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