net/phonet/socket.c

   1 /*
   2  * File: socket.c
   3  *
   4  * Phonet sockets
   5  *
   6  * Copyright (C) 2008 Nokia Corporation.
   7  *
   8  * Contact: Remi Denis-Courmont <remi.denis-courmont@nokia.com>
   9  * Original author: Sakari Ailus <sakari.ailus@nokia.com>
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * version 2 as published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  23  * 02110-1301 USA
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/net.h>
  28 #include <net/sock.h>
  29 #include <net/tcp_states.h>
  30
  31 #include <linux/phonet.h>
  32 #include <net/phonet/phonet.h>
  33 #include <net/phonet/pn_dev.h>
  34
  35 static int pn_socket_release(struct socket *sock)
  36 {
  37         struct sock *sk = sock->sk;
  38
  39         if (sk) {
  40                 sock->sk = NULL;
  41                 sk->sk_prot->close(sk, 0);
  42         }
  43         return 0;
  44 }
  45
  46 static struct  {
  47         struct hlist_head hlist;
  48         spinlock_t lock;
  49 } pnsocks = {
  50         .hlist = HLIST_HEAD_INIT,
  51         .lock = __SPIN_LOCK_UNLOCKED(pnsocks.lock),
  52 };
  53
  54 /*
  55  * Find address based on socket address, match only certain fields.
  56  * Also grab sock if it was found. Remember to sock_put it later.
  57  */
  58 struct sock *pn_find_sock_by_sa(const struct sockaddr_pn *spn)
  59 {
  60         struct hlist_node *node;
  61         struct sock *sknode;
  62         struct sock *rval = NULL;
  63         u16 obj = pn_sockaddr_get_object(spn);
  64         u8 res = spn->spn_resource;
  65
  66         spin_lock_bh(&pnsocks.lock);
  67
  68         sk_for_each(sknode, node, &pnsocks.hlist) {
  69                 struct pn_sock *pn = pn_sk(sknode);
  70                 BUG_ON(!pn->sobject); /* unbound socket */
  71
  72                 if (pn_port(obj)) {
  73                         /* Look up socket by port */
  74                         if (pn_port(pn->sobject) != pn_port(obj))
  75                                 continue;
  76                 } else {
  77                         /* If port is zero, look up by resource */
  78                         if (pn->resource != res)
  79                                 continue;
  80                 }
  81                 if (pn_addr(pn->sobject)
  82                  && pn_addr(pn->sobject) != pn_addr(obj))
  83                         continue;
  84
  85                 rval = sknode;
  86                 sock_hold(sknode);
  87                 break;
  88         }
  89
  90         spin_unlock_bh(&pnsocks.lock);
  91
  92         return rval;
  93
  94 }
  95
  96 void pn_sock_hash(struct sock *sk)
  97 {
  98         spin_lock_bh(&pnsocks.lock);
  99         sk_add_node(sk, &pnsocks.hlist);
 100         spin_unlock_bh(&pnsocks.lock);
 101 }
 102 EXPORT_SYMBOL(pn_sock_hash);
 103
 104 void pn_sock_unhash(struct sock *sk)
 105 {
 106         spin_lock_bh(&pnsocks.lock);
 107         sk_del_node_init(sk);
 108         spin_unlock_bh(&pnsocks.lock);
 109 }
 110 EXPORT_SYMBOL(pn_sock_unhash);
 111
 112 static int pn_socket_bind(struct socket *sock, struct sockaddr *addr, int len)
 113 {
 114         struct sock *sk = sock->sk;
 115         struct pn_sock *pn = pn_sk(sk);
 116         struct sockaddr_pn *spn = (struct sockaddr_pn *)addr;
 117         int err;
 118         u16 handle;
 119         u8 saddr;
 120
 121         if (sk->sk_prot->bind)
 122                 return sk->sk_prot->bind(sk, addr, len);
 123
 124         if (len < sizeof(struct sockaddr_pn))
 125                 return -EINVAL;
 126         if (spn->spn_family != AF_PHONET)
 127                 return -EAFNOSUPPORT;
 128
 129         handle = pn_sockaddr_get_object((struct sockaddr_pn *)addr);
 130         saddr = pn_addr(handle);
 131         if (saddr && phonet_address_lookup(saddr))
 132                 return -EADDRNOTAVAIL;
 133
 134         lock_sock(sk);
 135         if (sk->sk_state != TCP_CLOSE || pn_port(pn->sobject)) {
 136                 err = -EINVAL; /* attempt to rebind */
 137                 goto out;
 138         }
 139         err = sk->sk_prot->get_port(sk, pn_port(handle));
 140         if (err)
 141                 goto out;
 142
 143         /* get_port() sets the port, bind() sets the address if applicable */
 144         pn->sobject = pn_object(saddr, pn_port(pn->sobject));
 145         pn->resource = spn->spn_resource;
 146
 147         /* Enable RX on the socket */
 148         sk->sk_prot->hash(sk);
 149 out:
 150         release_sock(sk);
 151         return err;
 152 }
 153
 154 static int pn_socket_autobind(struct socket *sock)
 155 {
 156         struct sockaddr_pn sa;
 157         int err;
 158
 159         memset(&sa, 0, sizeof(sa));
 160         sa.spn_family = AF_PHONET;
 161         err = pn_socket_bind(sock, (struct sockaddr *)&sa,
 162                                 sizeof(struct sockaddr_pn));
 163         if (err != -EINVAL)
 164                 return err;
 165         BUG_ON(!pn_port(pn_sk(sock->sk)->sobject));
 166         return 0; /* socket was already bound */
 167 }
 168
 169 static int pn_socket_getname(struct socket *sock, struct sockaddr *addr,
 170                                 int *sockaddr_len, int peer)
 171 {
 172         struct sock *sk = sock->sk;
 173         struct pn_sock *pn = pn_sk(sk);
 174
 175         memset(addr, 0, sizeof(struct sockaddr_pn));
 176         addr->sa_family = AF_PHONET;
 177         if (!peer) /* Race with bind() here is userland's problem. */
 178                 pn_sockaddr_set_object((struct sockaddr_pn *)addr,
 179                                         pn->sobject);
 180
 181         *sockaddr_len = sizeof(struct sockaddr_pn);
 182         return 0;
 183 }
 184
 185 static int pn_socket_ioctl(struct socket *sock, unsigned int cmd,
 186                                 unsigned long arg)
 187 {
 188         struct sock *sk = sock->sk;
 189         struct pn_sock *pn = pn_sk(sk);
 190
 191         if (cmd == SIOCPNGETOBJECT) {
 192                 struct net_device *dev;
 193                 u16 handle;
 194                 u8 saddr;
 195
 196                 if (get_user(handle, (__u16 __user *)arg))
 197                         return -EFAULT;
 198
 199                 lock_sock(sk);
 200                 if (sk->sk_bound_dev_if)
 201                         dev = dev_get_by_index(sock_net(sk),
 202                                                 sk->sk_bound_dev_if);
 203                 else
 204                         dev = phonet_device_get(sock_net(sk));
 205                 if (dev && (dev->flags & IFF_UP))
 206                         saddr = phonet_address_get(dev, pn_addr(handle));
 207                 else
 208                         saddr = PN_NO_ADDR;
 209                 release_sock(sk);
 210
 211                 if (dev)
 212                         dev_put(dev);
 213                 if (saddr == PN_NO_ADDR)
 214                         return -EHOSTUNREACH;
 215
 216                 handle = pn_object(saddr, pn_port(pn->sobject));
 217                 return put_user(handle, (__u16 __user *)arg);
 218         }
 219
 220         return sk->sk_prot->ioctl(sk, cmd, arg);
 221 }
 222
 223 static int pn_socket_sendmsg(struct kiocb *iocb, struct socket *sock,
 224                                 struct msghdr *m, size_t total_len)
 225 {
 226         struct sock *sk = sock->sk;
 227
 228         if (pn_socket_autobind(sock))
 229                 return -EAGAIN;
 230
 231         return sk->sk_prot->sendmsg(iocb, sk, m, total_len);
 232 }
 233
 234 const struct proto_ops phonet_dgram_ops = {
 235         .family         = AF_PHONET,
 236         .owner          = THIS_MODULE,
 237         .release        = pn_socket_release,
 238         .bind           = pn_socket_bind,
 239         .connect        = sock_no_connect,
 240         .socketpair     = sock_no_socketpair,
 241         .accept         = sock_no_accept,
 242         .getname        = pn_socket_getname,
 243         .poll           = datagram_poll,
 244         .ioctl          = pn_socket_ioctl,
 245         .listen         = sock_no_listen,
 246         .shutdown       = sock_no_shutdown,
 247         .setsockopt     = sock_no_setsockopt,
 248         .getsockopt     = sock_no_getsockopt,
 249 #ifdef CONFIG_COMPAT
 250         .compat_setsockopt = sock_no_setsockopt,
 251         .compat_getsockopt = sock_no_getsockopt,
 252 #endif
 253         .sendmsg        = pn_socket_sendmsg,
 254         .recvmsg        = sock_common_recvmsg,
 255         .mmap           = sock_no_mmap,
 256         .sendpage       = sock_no_sendpage,
 257 };
 258
 259 static DEFINE_MUTEX(port_mutex);
 260
 261 /* allocate port for a socket */
 262 int pn_sock_get_port(struct sock *sk, unsigned short sport)
 263 {
 264         static int port_cur;
 265         struct pn_sock *pn = pn_sk(sk);
 266         struct sockaddr_pn try_sa;
 267         struct sock *tmpsk;
 268
 269         memset(&try_sa, 0, sizeof(struct sockaddr_pn));
 270         try_sa.spn_family = AF_PHONET;
 271
 272         mutex_lock(&port_mutex);
 273
 274         if (!sport) {
 275                 /* search free port */
 276                 int port, pmin = 0x40, pmax = 0x7f;
 277
 278                 for (port = pmin; port <= pmax; port++) {
 279                         port_cur++;
 280                         if (port_cur < pmin || port_cur > pmax)
 281                                 port_cur = pmin;
 282
 283                         pn_sockaddr_set_port(&try_sa, port_cur);
 284                         tmpsk = pn_find_sock_by_sa(&try_sa);
 285                         if (tmpsk == NULL) {
 286                                 sport = port_cur;
 287                                 goto found;
 288                         } else
 289                                 sock_put(tmpsk);
 290                 }
 291         } else {
 292                 /* try to find specific port */
 293                 pn_sockaddr_set_port(&try_sa, sport);
 294                 tmpsk = pn_find_sock_by_sa(&try_sa);
 295                 if (tmpsk == NULL)
 296                         /* No sock there! We can use that port... */
 297                         goto found;
 298                 else
 299                         sock_put(tmpsk);
 300         }
 301         mutex_unlock(&port_mutex);
 302
 303         /* the port must be in use already */
 304         return -EADDRINUSE;
 305
 306 found:
 307         mutex_unlock(&port_mutex);
 308         pn->sobject = pn_object(pn_addr(pn->sobject), sport);
 309         return 0;
 310 }
 311 EXPORT_SYMBOL(pn_sock_get_port);