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/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/sched.h> 30 #include <linux/slab.h> 31 #include <linux/poll.h> 32 #include <linux/fcntl.h> 33 #include <linux/skbuff.h> 34 #include <linux/socket.h> 35 #include <linux/ioctl.h> 36 #include <linux/file.h> 37 #include <linux/init.h> 38 #include <net/sock.h> 39 40 #include "hidp.h" 41 42 #ifndef CONFIG_BT_HIDP_DEBUG 43 #undef BT_DBG 44 #define BT_DBG(D...) 45 #endif 46 47 static int hidp_sock_release(struct socket *sock) 48 { 49 struct sock *sk = sock->sk; 50 51 BT_DBG("sock %p sk %p", sock, sk); 52 53 if (!sk) 54 return 0; 55 56 sock_orphan(sk); 57 sock_put(sk); 58 59 return 0; 60 } 61 62 static int hidp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 63 { 64 void __user *argp = (void __user *) arg; 65 struct hidp_connadd_req ca; 66 struct hidp_conndel_req cd; 67 struct hidp_connlist_req cl; 68 struct hidp_conninfo ci; 69 struct socket *csock; 70 struct socket *isock; 71 int err; 72 73 BT_DBG("cmd %x arg %lx", cmd, arg); 74 75 switch (cmd) { 76 case HIDPCONNADD: 77 if (!capable(CAP_NET_ADMIN)) 78 return -EACCES; 79 80 if (copy_from_user(&ca, argp, sizeof(ca))) 81 return -EFAULT; 82 83 csock = sockfd_lookup(ca.ctrl_sock, &err); 84 if (!csock) 85 return err; 86 87 isock = sockfd_lookup(ca.intr_sock, &err); 88 if (!isock) { 89 fput(csock->file); 90 return err; 91 } 92 93 if (csock->sk->sk_state != BT_CONNECTED || isock->sk->sk_state != BT_CONNECTED) { 94 fput(csock->file); 95 fput(isock->file); 96 return -EBADFD; 97 } 98 99 err = hidp_add_connection(&ca, csock, isock); 100 if (!err) { 101 if (copy_to_user(argp, &ca, sizeof(ca))) 102 err = -EFAULT; 103 } else { 104 fput(csock->file); 105 fput(isock->file); 106 } 107 108 return err; 109 110 case HIDPCONNDEL: 111 if (!capable(CAP_NET_ADMIN)) 112 return -EACCES; 113 114 if (copy_from_user(&cd, argp, sizeof(cd))) 115 return -EFAULT; 116 117 return hidp_del_connection(&cd); 118 119 case HIDPGETCONNLIST: 120 if (copy_from_user(&cl, argp, sizeof(cl))) 121 return -EFAULT; 122 123 if (cl.cnum <= 0) 124 return -EINVAL; 125 126 err = hidp_get_connlist(&cl); 127 if (!err && copy_to_user(argp, &cl, sizeof(cl))) 128 return -EFAULT; 129 130 return err; 131 132 case HIDPGETCONNINFO: 133 if (copy_from_user(&ci, argp, sizeof(ci))) 134 return -EFAULT; 135 136 err = hidp_get_conninfo(&ci); 137 if (!err && copy_to_user(argp, &ci, sizeof(ci))) 138 return -EFAULT; 139 140 return err; 141 } 142 143 return -EINVAL; 144 } 145 146 static const struct proto_ops hidp_sock_ops = { 147 .family = PF_BLUETOOTH, 148 .owner = THIS_MODULE, 149 .release = hidp_sock_release, 150 .ioctl = hidp_sock_ioctl, 151 .bind = sock_no_bind, 152 .getname = sock_no_getname, 153 .sendmsg = sock_no_sendmsg, 154 .recvmsg = sock_no_recvmsg, 155 .poll = sock_no_poll, 156 .listen = sock_no_listen, 157 .shutdown = sock_no_shutdown, 158 .setsockopt = sock_no_setsockopt, 159 .getsockopt = sock_no_getsockopt, 160 .connect = sock_no_connect, 161 .socketpair = sock_no_socketpair, 162 .accept = sock_no_accept, 163 .mmap = sock_no_mmap 164 }; 165 166 static struct proto hidp_proto = { 167 .name = "HIDP", 168 .owner = THIS_MODULE, 169 .obj_size = sizeof(struct bt_sock) 170 }; 171 172 static int hidp_sock_create(struct socket *sock, int protocol) 173 { 174 struct sock *sk; 175 176 BT_DBG("sock %p", sock); 177 178 if (sock->type != SOCK_RAW) 179 return -ESOCKTNOSUPPORT; 180 181 sk = sk_alloc(PF_BLUETOOTH, GFP_KERNEL, &hidp_proto, 1); 182 if (!sk) 183 return -ENOMEM; 184 185 sock_init_data(sock, sk); 186 187 sock->ops = &hidp_sock_ops; 188 189 sock->state = SS_UNCONNECTED; 190 191 sock_reset_flag(sk, SOCK_ZAPPED); 192 193 sk->sk_protocol = protocol; 194 sk->sk_state = BT_OPEN; 195 196 return 0; 197 } 198 199 static struct net_proto_family hidp_sock_family_ops = { 200 .family = PF_BLUETOOTH, 201 .owner = THIS_MODULE, 202 .create = hidp_sock_create 203 }; 204 205 int __init hidp_init_sockets(void) 206 { 207 int err; 208 209 err = proto_register(&hidp_proto, 0); 210 if (err < 0) 211 return err; 212 213 err = bt_sock_register(BTPROTO_HIDP, &hidp_sock_family_ops); 214 if (err < 0) 215 goto error; 216 217 return 0; 218 219 error: 220 BT_ERR("Can't register HIDP socket"); 221 proto_unregister(&hidp_proto); 222 return err; 223 } 224 225 void __exit hidp_cleanup_sockets(void) 226 { 227 if (bt_sock_unregister(BTPROTO_HIDP) < 0) 228 BT_ERR("Can't unregister HIDP socket"); 229 230 proto_unregister(&hidp_proto); 231 } 232