1 /* 2 HIDP implementation for Linux Bluetooth stack (BlueZ). 3 Copyright (C) 2003-2004 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/export.h> 24 #include <linux/file.h> 25 26 #include "hidp.h" 27 28 static int hidp_sock_release(struct socket *sock) 29 { 30 struct sock *sk = sock->sk; 31 32 BT_DBG("sock %p sk %p", sock, sk); 33 34 if (!sk) 35 return 0; 36 37 sock_orphan(sk); 38 sock_put(sk); 39 40 return 0; 41 } 42 43 static int hidp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 44 { 45 void __user *argp = (void __user *) arg; 46 struct hidp_connadd_req ca; 47 struct hidp_conndel_req cd; 48 struct hidp_connlist_req cl; 49 struct hidp_conninfo ci; 50 struct socket *csock; 51 struct socket *isock; 52 int err; 53 54 BT_DBG("cmd %x arg %lx", cmd, arg); 55 56 switch (cmd) { 57 case HIDPCONNADD: 58 if (!capable(CAP_NET_ADMIN)) 59 return -EACCES; 60 61 if (copy_from_user(&ca, argp, sizeof(ca))) 62 return -EFAULT; 63 64 csock = sockfd_lookup(ca.ctrl_sock, &err); 65 if (!csock) 66 return err; 67 68 isock = sockfd_lookup(ca.intr_sock, &err); 69 if (!isock) { 70 sockfd_put(csock); 71 return err; 72 } 73 74 if (csock->sk->sk_state != BT_CONNECTED || 75 isock->sk->sk_state != BT_CONNECTED) { 76 sockfd_put(csock); 77 sockfd_put(isock); 78 return -EBADFD; 79 } 80 81 err = hidp_add_connection(&ca, csock, isock); 82 if (!err) { 83 if (copy_to_user(argp, &ca, sizeof(ca))) 84 err = -EFAULT; 85 } else { 86 sockfd_put(csock); 87 sockfd_put(isock); 88 } 89 90 return err; 91 92 case HIDPCONNDEL: 93 if (!capable(CAP_NET_ADMIN)) 94 return -EACCES; 95 96 if (copy_from_user(&cd, argp, sizeof(cd))) 97 return -EFAULT; 98 99 return hidp_del_connection(&cd); 100 101 case HIDPGETCONNLIST: 102 if (copy_from_user(&cl, argp, sizeof(cl))) 103 return -EFAULT; 104 105 if (cl.cnum <= 0) 106 return -EINVAL; 107 108 err = hidp_get_connlist(&cl); 109 if (!err && copy_to_user(argp, &cl, sizeof(cl))) 110 return -EFAULT; 111 112 return err; 113 114 case HIDPGETCONNINFO: 115 if (copy_from_user(&ci, argp, sizeof(ci))) 116 return -EFAULT; 117 118 err = hidp_get_conninfo(&ci); 119 if (!err && copy_to_user(argp, &ci, sizeof(ci))) 120 return -EFAULT; 121 122 return err; 123 } 124 125 return -EINVAL; 126 } 127 128 #ifdef CONFIG_COMPAT 129 struct compat_hidp_connadd_req { 130 int ctrl_sock; /* Connected control socket */ 131 int intr_sock; /* Connected interrupt socket */ 132 __u16 parser; 133 __u16 rd_size; 134 compat_uptr_t rd_data; 135 __u8 country; 136 __u8 subclass; 137 __u16 vendor; 138 __u16 product; 139 __u16 version; 140 __u32 flags; 141 __u32 idle_to; 142 char name[128]; 143 }; 144 145 static int hidp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 146 { 147 if (cmd == HIDPGETCONNLIST) { 148 struct hidp_connlist_req cl; 149 u32 uci; 150 int err; 151 152 if (get_user(cl.cnum, (u32 __user *) arg) || 153 get_user(uci, (u32 __user *) (arg + 4))) 154 return -EFAULT; 155 156 cl.ci = compat_ptr(uci); 157 158 if (cl.cnum <= 0) 159 return -EINVAL; 160 161 err = hidp_get_connlist(&cl); 162 163 if (!err && put_user(cl.cnum, (u32 __user *) arg)) 164 err = -EFAULT; 165 166 return err; 167 } else if (cmd == HIDPCONNADD) { 168 struct compat_hidp_connadd_req ca; 169 struct hidp_connadd_req __user *uca; 170 171 uca = compat_alloc_user_space(sizeof(*uca)); 172 173 if (copy_from_user(&ca, (void __user *) arg, sizeof(ca))) 174 return -EFAULT; 175 176 if (put_user(ca.ctrl_sock, &uca->ctrl_sock) || 177 put_user(ca.intr_sock, &uca->intr_sock) || 178 put_user(ca.parser, &uca->parser) || 179 put_user(ca.rd_size, &uca->rd_size) || 180 put_user(compat_ptr(ca.rd_data), &uca->rd_data) || 181 put_user(ca.country, &uca->country) || 182 put_user(ca.subclass, &uca->subclass) || 183 put_user(ca.vendor, &uca->vendor) || 184 put_user(ca.product, &uca->product) || 185 put_user(ca.version, &uca->version) || 186 put_user(ca.flags, &uca->flags) || 187 put_user(ca.idle_to, &uca->idle_to) || 188 copy_to_user(&uca->name[0], &ca.name[0], 128)) 189 return -EFAULT; 190 191 arg = (unsigned long) uca; 192 193 /* Fall through. We don't actually write back any _changes_ 194 to the structure anyway, so there's no need to copy back 195 into the original compat version */ 196 } 197 198 return hidp_sock_ioctl(sock, cmd, arg); 199 } 200 #endif 201 202 static const struct proto_ops hidp_sock_ops = { 203 .family = PF_BLUETOOTH, 204 .owner = THIS_MODULE, 205 .release = hidp_sock_release, 206 .ioctl = hidp_sock_ioctl, 207 #ifdef CONFIG_COMPAT 208 .compat_ioctl = hidp_sock_compat_ioctl, 209 #endif 210 .bind = sock_no_bind, 211 .getname = sock_no_getname, 212 .sendmsg = sock_no_sendmsg, 213 .recvmsg = sock_no_recvmsg, 214 .poll = sock_no_poll, 215 .listen = sock_no_listen, 216 .shutdown = sock_no_shutdown, 217 .setsockopt = sock_no_setsockopt, 218 .getsockopt = sock_no_getsockopt, 219 .connect = sock_no_connect, 220 .socketpair = sock_no_socketpair, 221 .accept = sock_no_accept, 222 .mmap = sock_no_mmap 223 }; 224 225 static struct proto hidp_proto = { 226 .name = "HIDP", 227 .owner = THIS_MODULE, 228 .obj_size = sizeof(struct bt_sock) 229 }; 230 231 static int hidp_sock_create(struct net *net, struct socket *sock, int protocol, 232 int kern) 233 { 234 struct sock *sk; 235 236 BT_DBG("sock %p", sock); 237 238 if (sock->type != SOCK_RAW) 239 return -ESOCKTNOSUPPORT; 240 241 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hidp_proto); 242 if (!sk) 243 return -ENOMEM; 244 245 sock_init_data(sock, sk); 246 247 sock->ops = &hidp_sock_ops; 248 249 sock->state = SS_UNCONNECTED; 250 251 sock_reset_flag(sk, SOCK_ZAPPED); 252 253 sk->sk_protocol = protocol; 254 sk->sk_state = BT_OPEN; 255 256 return 0; 257 } 258 259 static const struct net_proto_family hidp_sock_family_ops = { 260 .family = PF_BLUETOOTH, 261 .owner = THIS_MODULE, 262 .create = hidp_sock_create 263 }; 264 265 int __init hidp_init_sockets(void) 266 { 267 int err; 268 269 err = proto_register(&hidp_proto, 0); 270 if (err < 0) 271 return err; 272 273 err = bt_sock_register(BTPROTO_HIDP, &hidp_sock_family_ops); 274 if (err < 0) 275 goto error; 276 277 return 0; 278 279 error: 280 BT_ERR("Can't register HIDP socket"); 281 proto_unregister(&hidp_proto); 282 return err; 283 } 284 285 void __exit hidp_cleanup_sockets(void) 286 { 287 if (bt_sock_unregister(BTPROTO_HIDP) < 0) 288 BT_ERR("Can't unregister HIDP socket"); 289 290 proto_unregister(&hidp_proto); 291 } 292