net/cor/sock.c

   1 /*
   2  *      Connection oriented routing
   3  *      Copyright (C) 2007-2010 Michael Blizek
   4  *
   5  *      This program is free software; you can redistribute it and/or
   6  *      modify it under the terms of the GNU General Public License
   7  *      as published by the Free Software Foundation; either version 2
   8  *      of the License, or (at your option) any later version.
   9  *
  10  *      This program is distributed in the hope that it will be useful,
  11  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *      GNU General Public License for more details.
  14  *
  15  *      You should have received a copy of the GNU General Public License
  16  *      along with this program; if not, write to the Free Software
  17  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  *      02110-1301, USA.
  19  */
  20
  21 #include <net/sock.h>
  22 #include <linux/net.h>
  23 #include <asm/uaccess.h>
  24
  25 #include "cor.h"
  26
  27 static int check_connlistener_state(struct connlistener *cl)
  28 {
  29         if (likely(cl != 0 && cl->sockstate == SOCKSTATE_LISTENER))
  30                 return 0;
  31
  32         return 1;
  33 }
  34
  35 static int check_conn_state(struct conn *conn)
  36 {
  37         if (likely(conn != 0 && conn->sockstate == SOCKSTATE_CONN))
  38                 return 0;
  39
  40         return 1;
  41 }
  42
  43 int cor_socket_release(struct socket *sock)
  44 {
  45         struct connlistener *cl = (struct connlistener *) sock->sk;
  46         struct conn *rconn = (struct conn *) sock->sk;
  47
  48         if (sock->sk == 0)
  49                 return 0;
  50
  51         if (cl->sockstate == SOCKSTATE_LISTENER) {
  52                 close_port(cl);
  53         } else if (rconn->sockstate == SOCKSTATE_CONN) {
  54                 reset_conn(rconn);
  55                 kref_put(&(rconn->ref), free_conn);
  56         } else {
  57                 BUG();
  58         }
  59
  60         return 0;
  61 }
  62
  63 int cor_socket_bind(struct socket *sock, struct sockaddr *myaddr,
  64                 int sockaddr_len)
  65 {
  66         struct connlistener *listener;
  67         struct cor_sockaddr *addr = (struct cor_sockaddr *) myaddr;
  68
  69         if (unlikely(sock->sk != 0))
  70                 return -EINVAL;
  71
  72         if (sockaddr_len < sizeof(struct cor_sockaddr))
  73                 return -EINVAL;
  74
  75         if (addr->type != SOCKADDRTYPE_PORT)
  76                 return -EINVAL;
  77
  78         listener = open_port(addr->addr.port);
  79
  80         if (listener == 0)
  81                 return -EADDRINUSE;
  82
  83         sock->sk = (struct sock *) listener;
  84
  85         return 0;
  86 }
  87
  88 int cor_socket_connect(struct socket *sock, struct sockaddr *vaddr,
  89                 int sockaddr_len, int flags)
  90 {
  91         struct conn *rconn;
  92
  93         if (unlikely(sock->sk != 0))
  94                 return -EISCONN;
  95
  96         rconn = alloc_conn(GFP_KERNEL);
  97
  98         kref_get(&(rconn->ref));
  99
 100         if (unlikely(rconn == 0))
 101                 return -ENOMEM;
 102
 103         mutex_lock(&(rconn->rcv_lock));
 104         mutex_lock(&(rconn->reversedir->rcv_lock));
 105         conn_init_sock_source(rconn);
 106         conn_init_sock_target(rconn->reversedir);
 107         mutex_unlock(&(rconn->reversedir->rcv_lock));
 108         mutex_unlock(&(rconn->rcv_lock));
 109
 110         sock->sk = (struct sock *) rconn;
 111         sock->state = SS_CONNECTED;
 112
 113         return 0;
 114 }
 115
 116 static int cor_rdytoaccept(struct connlistener *cl)
 117 {
 118         int rc;
 119         mutex_lock(&(cl->lock));
 120         rc = (list_empty(&(cl->conn_queue)) == 0);
 121         mutex_unlock(&(cl->lock));
 122         return rc;
 123 }
 124
 125 const struct proto_ops cor_proto_ops;
 126
 127 int cor_socket_accept(struct socket *sock, struct socket *newsock, int flags)
 128 {
 129         struct connlistener *cl = (struct connlistener *) sock->sk;
 130
 131         int rc = check_connlistener_state(cl);
 132
 133         struct conn *newconn;
 134
 135         if (unlikely(rc))
 136                 return -EINVAL;
 137
 138         mutex_lock(&(cl->lock));
 139
 140         if (unlikely(cl->queue_maxlen <= 0)) {
 141                 mutex_unlock(&(cl->lock));
 142                 return -EINVAL;
 143         }
 144
 145         while (list_empty(&(cl->conn_queue))) {
 146                 mutex_unlock(&(cl->lock));
 147                 if (wait_event_interruptible(cl->wait, cor_rdytoaccept(cl))) {
 148                         return -ERESTARTSYS;
 149                 }
 150                 mutex_lock(&(cl->lock));
 151         }
 152
 153         newconn = container_of(cl->conn_queue.next, struct conn,
 154                         source.sock.cl_list);
 155
 156         BUG_ON(newconn->sourcetype != SOURCE_SOCK);
 157
 158         list_del(cl->conn_queue.next);
 159
 160         cl->queue_len--;
 161
 162         mutex_unlock(&(cl->lock));
 163
 164         newsock->ops = &cor_proto_ops;
 165         newsock->sk = (struct sock *) newconn;
 166         newsock->state = SS_CONNECTED;
 167
 168         return 0;
 169 }
 170
 171 int cor_socket_listen(struct socket *sock, int len)
 172 {
 173         struct connlistener *cl = (struct connlistener *) sock->sk;
 174
 175         int rc = check_connlistener_state(cl);
 176
 177         if (unlikely(rc))
 178                 return -EOPNOTSUPP;
 179
 180         mutex_lock(&(cl->lock));
 181         cl->queue_maxlen = len;
 182         mutex_unlock(&(cl->lock));
 183
 184         return 0;
 185 }
 186
 187 int cor_socket_shutdown(struct socket *sock, int flags)
 188 {
 189         return -ENOTSUPP;
 190 }
 191
 192 int cor_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 193 {
 194         return -ENOIOCTLCMD;
 195 }
 196
 197 static int sendmsg_maypush(struct conn *rconn)
 198 {
 199         int ret;
 200         mutex_lock(&(rconn->rcv_lock));
 201         ret = (databuf_maypush(&(rconn->buf)) != 0) ||
 202                         unlikely(atomic_read(&(rconn->isreset)) != 0);
 203         mutex_unlock(&(rconn->rcv_lock));
 204         return ret;
 205 }
 206
 207 int cor_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 208                 size_t total_len)
 209 {
 210         int copied = 0;
 211
 212         struct conn *rconn = (struct conn *) sock->sk;
 213
 214         int rc = check_conn_state(rconn);
 215
 216         int blocking = (msg->msg_flags & MSG_DONTWAIT) == 0;
 217
 218         if (unlikely(rc))
 219                 return -EBADF;
 220
 221 recv:
 222         mutex_lock(&(rconn->rcv_lock));
 223
 224         if (unlikely(atomic_read(&(rconn->isreset)) != 0)) {
 225                 copied = -EPIPE;
 226                 goto out;
 227         }
 228
 229         copied = receive_userbuf(rconn, msg);
 230
 231 out:
 232         mutex_unlock(&(rconn->rcv_lock));
 233
 234         if (copied == -EAGAIN && blocking) {
 235                 if (wait_event_interruptible(rconn->source.sock.wait,
 236                                 sendmsg_maypush(rconn) == 0))
 237                         goto recv;
 238                 copied = -ERESTARTSYS;
 239         }
 240
 241         return copied;
 242 }
 243
 244 static int cor_readytoread(struct conn *sconn)
 245 {
 246         int rc = 0;
 247         mutex_lock(&(sconn->rcv_lock));
 248         rc = (sconn->buf.read_remaining != 0) ||
 249                         unlikely(atomic_read(&(sconn->isreset)) != 0);
 250         mutex_unlock(&(sconn->rcv_lock));
 251         return rc;
 252 }
 253
 254 int cor_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 255                 size_t total_len, int flags)
 256 {
 257         struct conn *rconn = (struct conn *) sock->sk;
 258         struct conn *sconn = rconn->reversedir;
 259         size_t copied = 0;
 260
 261         int rc = check_conn_state(rconn);
 262
 263         int blocking = (flags & MSG_DONTWAIT) == 0;
 264
 265         if (unlikely(rc))
 266                 return -EBADF;
 267
 268         BUG_ON(sconn == 0);
 269
 270 recv:
 271         mutex_lock(&(sconn->rcv_lock));
 272
 273         if (unlikely(atomic_read(&(rconn->isreset)) != 0)) {
 274                 copied = -EPIPE;
 275                 goto out;
 276         }
 277
 278         copied = databuf_pulluser(sconn, msg);
 279         databuf_ackread(sconn);
 280         wake_sender(sconn);
 281
 282 out:
 283         mutex_unlock(&(sconn->rcv_lock));
 284
 285         if (copied == -EAGAIN && blocking) {
 286                 if (wait_event_interruptible(sconn->target.sock.wait,
 287                                 cor_readytoread(sconn)) == 0)
 288                         goto recv;
 289                 copied = -ERESTARTSYS;
 290         }
 291
 292         return copied;
 293 }
 294
 295 const struct proto_ops cor_proto_ops = {
 296                 .family = PF_COR,
 297                 .owner = THIS_MODULE,
 298                 .release = cor_socket_release,
 299                 .bind = cor_socket_bind,
 300                 .connect = cor_socket_connect,
 301                 .accept = cor_socket_accept,
 302                 .listen = cor_socket_listen,
 303                 .shutdown = cor_socket_shutdown,
 304                 .ioctl = cor_ioctl,
 305                 .sendmsg = cor_sendmsg,
 306                 .recvmsg = cor_recvmsg
 307
 308         /*socketpair
 309         getname
 310         poll
 311         compat_ioctl
 312         setsockopt
 313         getsockopt
 314         compat_setsockopt
 315         compat_getsockopt
 316         mmap
 317         sendpage
 318         splice_read*/
 319 };
 320
 321 int cor_createsock(struct net *net, struct socket *sock, int protocol)
 322 {
 323         if (unlikely(protocol != 0))
 324                 return -EPROTONOSUPPORT;
 325
 326         sock->state = SS_UNCONNECTED;
 327         sock->ops = &cor_proto_ops;
 328
 329         return 0;
 330 }
 331
 332 static struct net_proto_family cor_net_proto_family = {
 333         .family = PF_COR,
 334         .create = cor_createsock,
 335         .owner = THIS_MODULE
 336 };
 337
 338 static int __init cor_sock_init(void)
 339 {
 340         sock_register(&cor_net_proto_family);
 341         return 0;
 342 }
 343
 344 module_init(cor_sock_init);
 345
 346 MODULE_LICENSE("GPL");
 347