net/bluetooth/cmtp/sock.c

   1 /*
   2    CMTP implementation for Linux Bluetooth stack (BlueZ).
   3    Copyright (C) 2002-2003 Marcel Holtmann <marcel@holtmann.org>
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License version 2 as
   7    published by the Free Software Foundation;
   8
   9    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  10    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  11    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  12    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  13    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  14    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17
  18    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  19    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  20    SOFTWARE IS DISCLAIMED.
  21 */
  22
  23 #include <linux/module.h>
  24
  25 #include <linux/types.h>
  26 #include <linux/capability.h>
  27 #include <linux/errno.h>
  28 #include <linux/kernel.h>
  29 #include <linux/poll.h>
  30 #include <linux/fcntl.h>
  31 #include <linux/skbuff.h>
  32 #include <linux/socket.h>
  33 #include <linux/ioctl.h>
  34 #include <linux/file.h>
  35 #include <linux/compat.h>
  36 #include <linux/gfp.h>
  37 #include <linux/uaccess.h>
  38 #include <net/sock.h>
  39
  40 #include <linux/isdn/capilli.h>
  41
  42
  43 #include "cmtp.h"
  44
  45 static int cmtp_sock_release(struct socket *sock)
  46 {
  47         struct sock *sk = sock->sk;
  48
  49         BT_DBG("sock %p sk %p", sock, sk);
  50
  51         if (!sk)
  52                 return 0;
  53
  54         sock_orphan(sk);
  55         sock_put(sk);
  56
  57         return 0;
  58 }
  59
  60 static int cmtp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  61 {
  62         struct cmtp_connadd_req ca;
  63         struct cmtp_conndel_req cd;
  64         struct cmtp_connlist_req cl;
  65         struct cmtp_conninfo ci;
  66         struct socket *nsock;
  67         void __user *argp = (void __user *)arg;
  68         int err;
  69
  70         BT_DBG("cmd %x arg %lx", cmd, arg);
  71
  72         switch (cmd) {
  73         case CMTPCONNADD:
  74                 if (!capable(CAP_NET_ADMIN))
  75                         return -EPERM;
  76
  77                 if (copy_from_user(&ca, argp, sizeof(ca)))
  78                         return -EFAULT;
  79
  80                 nsock = sockfd_lookup(ca.sock, &err);
  81                 if (!nsock)
  82                         return err;
  83
  84                 if (nsock->sk->sk_state != BT_CONNECTED) {
  85                         sockfd_put(nsock);
  86                         return -EBADFD;
  87                 }
  88
  89                 err = cmtp_add_connection(&ca, nsock);
  90                 if (!err) {
  91                         if (copy_to_user(argp, &ca, sizeof(ca)))
  92                                 err = -EFAULT;
  93                 } else
  94                         sockfd_put(nsock);
  95
  96                 return err;
  97
  98         case CMTPCONNDEL:
  99                 if (!capable(CAP_NET_ADMIN))
 100                         return -EPERM;
 101
 102                 if (copy_from_user(&cd, argp, sizeof(cd)))
 103                         return -EFAULT;
 104
 105                 return cmtp_del_connection(&cd);
 106
 107         case CMTPGETCONNLIST:
 108                 if (copy_from_user(&cl, argp, sizeof(cl)))
 109                         return -EFAULT;
 110
 111                 if (cl.cnum <= 0)
 112                         return -EINVAL;
 113
 114                 err = cmtp_get_connlist(&cl);
 115                 if (!err && copy_to_user(argp, &cl, sizeof(cl)))
 116                         return -EFAULT;
 117
 118                 return err;
 119
 120         case CMTPGETCONNINFO:
 121                 if (copy_from_user(&ci, argp, sizeof(ci)))
 122                         return -EFAULT;
 123
 124                 err = cmtp_get_conninfo(&ci);
 125                 if (!err && copy_to_user(argp, &ci, sizeof(ci)))
 126                         return -EFAULT;
 127
 128                 return err;
 129         }
 130
 131         return -EINVAL;
 132 }
 133
 134 #ifdef CONFIG_COMPAT
 135 static int cmtp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 136 {
 137         if (cmd == CMTPGETCONNLIST) {
 138                 struct cmtp_connlist_req cl;
 139                 u32 uci;
 140                 int err;
 141
 142                 if (get_user(cl.cnum, (u32 __user *) arg) ||
 143                                 get_user(uci, (u32 __user *) (arg + 4)))
 144                         return -EFAULT;
 145
 146                 cl.ci = compat_ptr(uci);
 147
 148                 if (cl.cnum <= 0)
 149                         return -EINVAL;
 150
 151                 err = cmtp_get_connlist(&cl);
 152
 153                 if (!err && put_user(cl.cnum, (u32 __user *) arg))
 154                         err = -EFAULT;
 155
 156                 return err;
 157         }
 158
 159         return cmtp_sock_ioctl(sock, cmd, arg);
 160 }
 161 #endif
 162
 163 static const struct proto_ops cmtp_sock_ops = {
 164         .family         = PF_BLUETOOTH,
 165         .owner          = THIS_MODULE,
 166         .release        = cmtp_sock_release,
 167         .ioctl          = cmtp_sock_ioctl,
 168 #ifdef CONFIG_COMPAT
 169         .compat_ioctl   = cmtp_sock_compat_ioctl,
 170 #endif
 171         .bind           = sock_no_bind,
 172         .getname        = sock_no_getname,
 173         .sendmsg        = sock_no_sendmsg,
 174         .recvmsg        = sock_no_recvmsg,
 175         .poll           = sock_no_poll,
 176         .listen         = sock_no_listen,
 177         .shutdown       = sock_no_shutdown,
 178         .setsockopt     = sock_no_setsockopt,
 179         .getsockopt     = sock_no_getsockopt,
 180         .connect        = sock_no_connect,
 181         .socketpair     = sock_no_socketpair,
 182         .accept         = sock_no_accept,
 183         .mmap           = sock_no_mmap
 184 };
 185
 186 static struct proto cmtp_proto = {
 187         .name           = "CMTP",
 188         .owner          = THIS_MODULE,
 189         .obj_size       = sizeof(struct bt_sock)
 190 };
 191
 192 static int cmtp_sock_create(struct net *net, struct socket *sock, int protocol,
 193                             int kern)
 194 {
 195         struct sock *sk;
 196
 197         BT_DBG("sock %p", sock);
 198
 199         if (sock->type != SOCK_RAW)
 200                 return -ESOCKTNOSUPPORT;
 201
 202         sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &cmtp_proto);
 203         if (!sk)
 204                 return -ENOMEM;
 205
 206         sock_init_data(sock, sk);
 207
 208         sock->ops = &cmtp_sock_ops;
 209
 210         sock->state = SS_UNCONNECTED;
 211
 212         sock_reset_flag(sk, SOCK_ZAPPED);
 213
 214         sk->sk_protocol = protocol;
 215         sk->sk_state    = BT_OPEN;
 216
 217         return 0;
 218 }
 219
 220 static const struct net_proto_family cmtp_sock_family_ops = {
 221         .family = PF_BLUETOOTH,
 222         .owner  = THIS_MODULE,
 223         .create = cmtp_sock_create
 224 };
 225
 226 int cmtp_init_sockets(void)
 227 {
 228         int err;
 229
 230         err = proto_register(&cmtp_proto, 0);
 231         if (err < 0)
 232                 return err;
 233
 234         err = bt_sock_register(BTPROTO_CMTP, &cmtp_sock_family_ops);
 235         if (err < 0)
 236                 goto error;
 237
 238         return 0;
 239
 240 error:
 241         BT_ERR("Can't register CMTP socket");
 242         proto_unregister(&cmtp_proto);
 243         return err;
 244 }
 245
 246 void cmtp_cleanup_sockets(void)
 247 {
 248         if (bt_sock_unregister(BTPROTO_CMTP) < 0)
 249                 BT_ERR("Can't unregister CMTP socket");
 250
 251         proto_unregister(&cmtp_proto);
 252 }