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 > 0)
 235                 flush_buf(rconn);
 236
 237         if (copied == -EAGAIN && blocking) {
 238                 if (wait_event_interruptible(rconn->source.sock.wait,
 239                                 sendmsg_maypush(rconn) == 0))
 240                         goto recv;
 241                 copied = -ERESTARTSYS;
 242         }
 243
 244         return copied;
 245 }
 246
 247 static int cor_readytoread(struct conn *sconn)
 248 {
 249         int rc = 0;
 250         mutex_lock(&(sconn->rcv_lock));
 251         rc = (sconn->buf.read_remaining != 0) ||
 252                         unlikely(atomic_read(&(sconn->isreset)) != 0);
 253         mutex_unlock(&(sconn->rcv_lock));
 254         return rc;
 255 }
 256
 257 int cor_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 258                 size_t total_len, int flags)
 259 {
 260         struct conn *rconn = (struct conn *) sock->sk;
 261         struct conn *sconn = rconn->reversedir;
 262         size_t copied = 0;
 263
 264         int rc = check_conn_state(rconn);
 265
 266         int blocking = (flags & MSG_DONTWAIT) == 0;
 267
 268         if (unlikely(rc))
 269                 return -EBADF;
 270
 271         BUG_ON(sconn == 0);
 272
 273 recv:
 274         mutex_lock(&(sconn->rcv_lock));
 275
 276         if (unlikely(atomic_read(&(rconn->isreset)) != 0)) {
 277                 copied = -EPIPE;
 278                 goto out;
 279         }
 280
 281         copied = databuf_pulluser(sconn, msg);
 282         databuf_ackread(sconn);
 283         wake_sender(sconn);
 284
 285 out:
 286         mutex_unlock(&(sconn->rcv_lock));
 287
 288         if (copied == -EAGAIN && blocking) {
 289                 if (wait_event_interruptible(sconn->target.sock.wait,
 290                                 cor_readytoread(sconn)) == 0)
 291                         goto recv;
 292                 copied = -ERESTARTSYS;
 293         }
 294
 295         return copied;
 296 }
 297
 298 const struct proto_ops cor_proto_ops = {
 299                 .family = PF_COR,
 300                 .owner = THIS_MODULE,
 301                 .release = cor_socket_release,
 302                 .bind = cor_socket_bind,
 303                 .connect = cor_socket_connect,
 304                 .accept = cor_socket_accept,
 305                 .listen = cor_socket_listen,
 306                 .shutdown = cor_socket_shutdown,
 307                 .ioctl = cor_ioctl,
 308                 .sendmsg = cor_sendmsg,
 309                 .recvmsg = cor_recvmsg
 310
 311         /*socketpair
 312         getname
 313         poll
 314         compat_ioctl
 315         setsockopt
 316         getsockopt
 317         compat_setsockopt
 318         compat_getsockopt
 319         mmap
 320         sendpage
 321         splice_read*/
 322 };
 323
 324 int cor_createsock(struct net *net, struct socket *sock, int protocol)
 325 {
 326         if (unlikely(protocol != 0))
 327                 return -EPROTONOSUPPORT;
 328
 329         sock->state = SS_UNCONNECTED;
 330         sock->ops = &cor_proto_ops;
 331
 332         return 0;
 333 }
 334
 335 static struct net_proto_family cor_net_proto_family = {
 336         .family = PF_COR,
 337         .create = cor_createsock,
 338         .owner = THIS_MODULE
 339 };
 340
 341 static int __init cor_sock_init(void)
 342 {
 343         sock_register(&cor_net_proto_family);
 344         return 0;
 345 }
 346
 347 module_init(cor_sock_init);
 348
 349 MODULE_LICENSE("GPL");
 350