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