net/cor/sock.c

   1 /*
   2  *      Connection oriented routing
   3  *      Copyright (C) 2007-2008 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         } else {
  56                 BUG();
  57         }
  58
  59         return 0;
  60 }
  61
  62 int cor_socket_bind(struct socket *sock, struct sockaddr *myaddr,
  63                 int sockaddr_len)
  64 {
  65         struct connlistener *listener;
  66         struct cor_sockaddr *addr = (struct cor_sockaddr *) myaddr;
  67
  68         if (sock->sk != 0)
  69                 return -EINVAL;
  70
  71         if (sockaddr_len < sizeof(struct cor_sockaddr))
  72                 return -EINVAL;
  73
  74         if (addr->type != SOCKADDRTYPE_PORT)
  75                 return -EINVAL;
  76
  77         listener = open_port(addr->addr.port);
  78
  79         if (listener == 0)
  80                 return -EADDRINUSE;
  81
  82         sock->sk = (struct sock *) listener;
  83
  84         return 0;
  85 }
  86
  87 int cor_socket_connect(struct socket *sock, struct sockaddr *vaddr,
  88                 int sockaddr_len, int flags)
  89 {
  90         struct conn *conn_rcv;
  91
  92         if (sock->sk != 0)
  93                 return -EISCONN;
  94
  95         conn_rcv = alloc_conn(GFP_KERNEL);
  96
  97         if (0 == conn_rcv)
  98                 return -ENOMEM;
  99
 100         conn_init_sock_source(conn_rcv);
 101         conn_init_sock_target(conn_rcv->reversedir);
 102
 103         sock->sk = (struct sock *) conn_rcv;
 104         sock->state = SS_CONNECTED;
 105
 106         return 0;
 107 }
 108
 109 static int cor_rdytoaccept(struct connlistener *cl)
 110 {
 111         int rc;
 112         mutex_lock(&(cl->lock));
 113         rc = (list_empty(&(cl->conn_queue)) == 0);
 114         mutex_unlock(&(cl->lock));
 115         return rc;
 116 }
 117
 118 const struct proto_ops cor_proto_ops;
 119
 120 int cor_socket_accept(struct socket *sock, struct socket *newsock, int flags)
 121 {
 122         struct connlistener *cl = (struct connlistener *) sock->sk;
 123
 124         int rc = check_connlistener_state(cl);
 125
 126         struct conn *newconn;
 127
 128         if (unlikely(rc))
 129                 return -EINVAL;
 130
 131         mutex_lock(&(cl->lock));
 132
 133         if (unlikely(cl->queue_maxlen <= 0)) {
 134                 mutex_unlock(&(cl->lock));
 135                 return -EINVAL;
 136         }
 137
 138         while (list_empty(&(cl->conn_queue))) {
 139                 mutex_unlock(&(cl->lock));
 140                 if (wait_event_interruptible(cl->wait, cor_rdytoaccept(cl))) {
 141                         return -ERESTARTSYS;
 142                 }
 143                 mutex_lock(&(cl->lock));
 144         }
 145
 146         newconn = container_of(cl->conn_queue.next, struct conn,
 147                         source.sock.cl_list);
 148
 149         BUG_ON(newconn->sourcetype != SOURCE_SOCK);
 150
 151         list_del(cl->conn_queue.next);
 152
 153         cl->queue_len--;
 154
 155         mutex_unlock(&(cl->lock));
 156
 157         newsock->ops = &cor_proto_ops;
 158         newsock->sk = (struct sock *) newconn;
 159         newsock->state = SS_CONNECTED;
 160
 161         return 0;
 162 }
 163
 164 int cor_socket_listen(struct socket *sock, int len)
 165 {
 166         struct connlistener *cl = (struct connlistener *) sock->sk;
 167
 168         int rc = check_connlistener_state(cl);
 169
 170         if (unlikely(rc))
 171                 return -EOPNOTSUPP;
 172
 173         mutex_lock(&(cl->lock));
 174         cl->queue_maxlen = len;
 175         mutex_unlock(&(cl->lock));
 176
 177         return 0;
 178 }
 179
 180 int cor_socket_shutdown(struct socket *sock, int flags)
 181 {
 182         return -ENOTSUPP;
 183 }
 184
 185 int cor_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 186 {
 187         return -ENOIOCTLCMD;
 188 }
 189
 190 static int sendmsg_maypush(struct conn *rconn)
 191 {
 192         int ret;
 193         mutex_lock(&(rconn->rcv_lock));
 194         ret = databuf_maypush(&(rconn->buf)) != 0;
 195         mutex_unlock(&(rconn->rcv_lock));
 196         return ret;
 197 }
 198
 199 int cor_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 200                 size_t total_len)
 201 {
 202         int copied = 0;
 203
 204         struct conn *rconn = (struct conn *) sock->sk;
 205
 206         int rc = check_conn_state(rconn);
 207
 208         int blocking = (msg->msg_flags & MSG_DONTWAIT) == 0;
 209
 210         if (unlikely(rc))
 211                 return -EBADF;
 212
 213 recv:
 214         mutex_lock(&(rconn->rcv_lock));
 215
 216         if (unlikely(rconn->isreset)) {
 217                 copied = -EPIPE;
 218                 goto out;
 219         }
 220
 221         copied = receive_userbuf(rconn, msg);
 222
 223 out:
 224         mutex_unlock(&(rconn->rcv_lock));
 225
 226         if (copied == -EAGAIN && blocking) {
 227                 if (wait_event_interruptible(rconn->source.sock.wait,
 228                                 sendmsg_maypush(rconn) == 0))
 229                         goto recv;
 230                 copied = -ERESTARTSYS;
 231         }
 232
 233         return copied;
 234 }
 235
 236 static int cor_readytoread(struct conn *sconn)
 237 {
 238         int rc = 0;
 239         mutex_lock(&(sconn->rcv_lock));
 240         rc = (sconn->buf.read_remaining != 0);
 241         mutex_unlock(&(sconn->rcv_lock));
 242         return rc;
 243 }
 244
 245 int cor_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 246                 size_t total_len, int flags)
 247 {
 248         struct conn *rconn = (struct conn *) sock->sk;
 249         struct conn *sconn = rconn->reversedir;
 250         size_t copied = 0;
 251
 252         int rc = check_conn_state(rconn);
 253
 254         int blocking = (flags & MSG_DONTWAIT) == 0;
 255
 256         if (unlikely(rc))
 257                 return -EBADF;
 258
 259         BUG_ON(sconn == 0);
 260
 261 recv:
 262         mutex_lock(&(sconn->rcv_lock));
 263
 264         if (unlikely(rconn->isreset)) {
 265                 copied = -EPIPE;
 266                 goto out;
 267         }
 268
 269         copied = databuf_pulluser(sconn, msg);
 270         databuf_ackread(&(sconn->buf));
 271         wake_sender(sconn);
 272
 273 out:
 274         mutex_unlock(&(sconn->rcv_lock));
 275
 276         if (copied == -EAGAIN && blocking) {
 277                 if (wait_event_interruptible(sconn->target.sock.wait,
 278                                 cor_readytoread(sconn)) == 0)
 279                         goto recv;
 280                 copied = -ERESTARTSYS;
 281         }
 282
 283         return copied;
 284 }
 285
 286 const struct proto_ops cor_proto_ops = {
 287                 .family = PF_COR,
 288                 .owner = THIS_MODULE,
 289                 .release = cor_socket_release,
 290                 .bind = cor_socket_bind,
 291                 .connect = cor_socket_connect,
 292                 .accept = cor_socket_accept,
 293                 .listen = cor_socket_listen,
 294                 .shutdown = cor_socket_shutdown,
 295                 .ioctl = cor_ioctl,
 296                 .sendmsg = cor_sendmsg,
 297                 .recvmsg = cor_recvmsg
 298
 299         /*socketpair
 300         getname
 301         poll
 302         compat_ioctl
 303         setsockopt
 304         getsockopt
 305         compat_setsockopt
 306         compat_getsockopt
 307         mmap
 308         sendpage
 309         splice_read*/
 310 };
 311
 312 int cor_createsock(struct net *net, struct socket *sock, int protocol)
 313 {
 314         if (0 != protocol)
 315                 return -EPROTONOSUPPORT;
 316
 317         sock->state = SS_UNCONNECTED;
 318         sock->ops = &cor_proto_ops;
 319
 320         return 0;
 321 }
 322
 323 static struct net_proto_family cor_net_proto_family = {
 324         .family = PF_COR,
 325         .create = cor_createsock,
 326         .owner = THIS_MODULE
 327 };
 328
 329 static int __init cor_sock_init(void)
 330 {
 331         sock_register(&cor_net_proto_family);
 332         return 0;
 333 }
 334
 335 module_init(cor_sock_init);
 336
 337 MODULE_LICENSE("GPL");
 338