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