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 cor_readytowriterbuf(struct conn *rconn)
 191 {
 192         int rc = 0;
 193         mutex_lock(&(rconn->target.sock.lock));
 194         rc = ringbuffer_maypush(&(rconn->target.sock.rbuf));
 195         mutex_unlock(&(rconn->target.sock.lock));
 196         return rc;
 197 }
 198
 199 static int cor_sendmsg_socket(struct conn *rconn, __user char *msg, int len,
 200                 int blocking)
 201 {
 202         int ret;
 203
 204         do {
 205                 BUG_ON(rconn->targettype != TARGET_SOCK);
 206
 207                 mutex_lock(&(rconn->target.sock.lock));
 208                 ret = ringbuffer_put(&(rconn->target.sock.rbuf), msg, len, 1);
 209                 mutex_unlock(&(rconn->target.sock.lock));
 210
 211                 if (ret < 0)
 212                         return ret;
 213
 214                 if (ret == 0 && !blocking) {
 215                         ret = -EAGAIN;
 216                 } else if (ret == 0 && blocking) {
 217                         if (wait_event_interruptible(rconn->source.sock.wait,
 218                                         cor_readytowriterbuf(rconn)))
 219                                 ret = -ERESTARTSYS;
 220                 } else {
 221                         wake_up_interruptible(&(rconn->target.sock.wait));
 222                 }
 223         } while (blocking && ret <= 0);
 224
 225         return ret;
 226 }
 227
 228 void cor_flush_sockbuf(struct conn *rconn)
 229 {
 230         char *buf;
 231         __u32 len;
 232
 233         if (rconn->target.out.skb_written == 0)
 234                 return;
 235
 236         if (atomic_read(&(rconn->target.out.inflight_packets)) != 0)
 237                 return;
 238
 239         len = rconn->target.out.skb_written;
 240         buf = kmalloc(len, GFP_KERNEL);
 241
 242         memcpy(buf, rconn->target.out.skb->tail - len, len);
 243
 244         rconn->target.out.seqno -= rconn->target.out.skb_mss;
 245         kfree_skb(rconn->target.out.skb);
 246         rconn->target.out.skb = 0;
 247         rconn->target.out.skb_written = 0;
 248
 249         send_conn_flushdata(rconn, buf, len);
 250 }
 251
 252 static int cor_sendmsg_out(struct conn *rconn, __user char *msg, int len, int blocking)
 253 {
 254         int send = 1;
 255         int targetmss = mss(rconn->target.out.nb);
 256         int copy;
 257         int rc;
 258
 259         BUG_ON(rconn->targettype != TARGET_OUT);
 260
 261         if (rconn->target.out.skb == 0) {
 262                 struct sk_buff *skb = create_packet_conn(rconn, targetmss,
 263                                 GFP_KERNEL);
 264                 if (skb == 0)
 265                         return -ENOMEM;
 266                 rconn->target.out.skb = skb;
 267                 rconn->target.out.skb_written = 0;
 268                 rconn->target.out.skb_mss = targetmss;
 269         }
 270
 271         copy = skb_tailroom(rconn->target.out.skb);
 272         if (len < copy) {
 273                 copy = len;
 274                 send = 0;
 275         }
 276
 277
 278         rc = skb_add_data(rconn->target.out.skb, msg, copy);
 279
 280         BUG_ON(0 > rc);
 281
 282         if (rc != 0)
 283                 return rc;
 284
 285         rconn->target.out.skb_written += copy;
 286
 287         if (send) {
 288                 send_packet(rconn->target.out.skb, rconn->target.out.nb);
 289                 rconn->target.out.skb = 0;
 290                 rconn->target.out.skb_written = 0;
 291         }
 292
 293         return copy;
 294 }
 295
 296 int cor_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 297                 size_t total_len)
 298 {
 299         int copied = 0;
 300
 301         struct conn *rconn = (struct conn *) sock->sk;
 302
 303         int iovidx = 0;
 304         int iovread = 0;
 305
 306         int rc = check_conn_state(rconn);
 307
 308         if (unlikely(rc))
 309                 return -EBADF;
 310
 311         #warning todo nonblocking io
 312         mutex_lock(&(rconn->source.sock.lock));
 313
 314         while (iovidx < msg->msg_iovlen) {
 315                 struct iovec *iov = msg->msg_iov + iovidx;
 316                 __user char *userbuf = iov->iov_base + iovread;
 317                 int len = iov->iov_len - iovread;
 318
 319                 int copy = -ECONNRESET;
 320                 if (rconn->targettype == TARGET_UNCONNECTED) {
 321                         struct data data;
 322
 323                         char buf[1];
 324                         long cpy = copy_from_user(&buf, userbuf, 1);
 325                         if (cpy != 0) {
 326                                 copy = -EFAULT;
 327                                 goto out;
 328                         }
 329
 330                         #warning todo check if receive buffer is empty, otherwise there may be a deadlock
 331
 332                         data.type = TYPE_BUF;
 333                         data.data.buf.buf = buf;
 334                         data.data.buf.len = 1;
 335                         parse(&data, rconn);
 336                         copy = 1 - data.data.buf.len;
 337                 } else if (rconn->targettype == TARGET_SOCK) {
 338                         copy = cor_sendmsg_socket(rconn, userbuf, len,
 339                                         copied == 0);
 340                 } else if (rconn->targettype == TARGET_OUT) {
 341                         copy = cor_sendmsg_out(rconn, userbuf, len,
 342                                         copied == 0);
 343                 } else {
 344                         BUG();
 345                 }
 346
 347 out:
 348
 349                 if (copy < 0) {
 350                         if (copied == 0)
 351                                 copied = copy;
 352                         break;
 353                 }
 354
 355                 copied += copy;
 356                 iovread += copy;
 357
 358                 if (iov->iov_len == iovread) {
 359                         iovidx++;
 360                         iovread = 0;
 361                 }
 362         }
 363
 364         mutex_unlock(&(rconn->source.sock.lock));
 365
 366         return copied;
 367 }
 368
 369 static int cor_readytoread(struct conn *sconn)
 370 {
 371         int rc = 0;
 372         mutex_lock(&(sconn->target.sock.lock));
 373
 374         if (sconn->target.sock.queue.next != 0)
 375                 rc = 1;
 376         else if (ringbuffer_maypull(&(sconn->target.sock.rbuf)))
 377                 rc = 1;
 378
 379         mutex_unlock(&(sconn->target.sock.lock));
 380
 381         return rc;
 382 }
 383
 384 static int cor_recvmsg_skb(struct conn *sconn, __user char *msg,
 385                 unsigned int len)
 386 {
 387         int rc;
 388         struct sk_buff *skb = skb_dequeue(&(sconn->target.sock.queue));
 389
 390         BUG_ON(skb == 0);
 391
 392         len = min(len, skb->len);
 393         rc = copy_to_user(msg, skb->data, len);
 394
 395         if (rc == 0)
 396                 cor_pull_skb(skb, len);
 397
 398         if (skb->len != 0)
 399                 skb_queue_head(&(sconn->target.sock.queue), skb);
 400
 401         BUG_ON(0 < rc);
 402
 403         return rc == 0 ? 0 : -EFAULT;
 404 }
 405
 406 int cor_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 407                 size_t total_len, int flags)
 408 {
 409         struct conn *rconn = (struct conn *) sock->sk;
 410         struct conn *sconn = rconn->reversedir;
 411         size_t copied = 0;
 412
 413         int iovidx = 0;
 414         int iovread = 0;
 415
 416         int rc = check_conn_state(rconn);
 417
 418         if (unlikely(rc))
 419                 return -EBADF;
 420
 421         BUG_ON(sconn == 0);
 422
 423         mutex_lock(&(sconn->target.sock.lock));
 424
 425         while (iovidx < msg->msg_iovlen) {
 426                 int rc;
 427
 428                 struct iovec *iov = msg->msg_iov + iovidx;
 429                 __user char *msg = iov->iov_base + iovread;
 430                 unsigned int len = iov->iov_len - iovread;
 431
 432                 if (len == 0) {
 433                         iovidx++;
 434                         iovread = 0;
 435                         continue;
 436                 }
 437
 438                 if (ringbuffer_maypull(&(sconn->target.sock.rbuf)))
 439                         rc = ringbuffer_pull(&(sconn->target.sock.rbuf), msg, len, 1);
 440                 else if (sconn->target.sock.queue.next != 0)
 441                         rc = cor_recvmsg_skb(sconn, msg, len);
 442                 else
 443                         rc = 0;
 444
 445                 if (rc < 0 && copied == 0) {
 446                         copied = rc;
 447                         break;
 448                 }
 449
 450                 if (rc > 0) {
 451                         copied += rc;
 452                         continue;
 453                 }
 454
 455                 if (0 > copied)
 456                         break;
 457
 458                 if (flags & MSG_DONTWAIT) {
 459                         copied = -EAGAIN;
 460                         break;
 461                 }
 462
 463                 mutex_unlock(&(sconn->target.sock.lock));
 464                 if (wait_event_interruptible(sconn->target.sock.wait,
 465                                 cor_readytoread(sconn)))
 466                         copied = -ERESTARTSYS;
 467                 mutex_lock(&(sconn->target.sock.lock));
 468
 469                 if (copied != 0)
 470                         break;
 471         }
 472
 473         mutex_unlock(&(sconn->target.sock.lock));
 474
 475         if (sconn->sourcetype == SOURCE_SOCK)
 476                 wake_up_interruptible(&(sconn->target.sock.wait));
 477
 478         return copied;
 479 }
 480
 481 const struct proto_ops cor_proto_ops = {
 482                 .family = PF_COR,
 483                 .owner = THIS_MODULE,
 484                 .release = cor_socket_release,
 485                 .bind = cor_socket_bind,
 486                 .connect = cor_socket_connect,
 487                 .accept = cor_socket_accept,
 488                 .listen = cor_socket_listen,
 489                 .shutdown = cor_socket_shutdown,
 490                 .ioctl = cor_ioctl,
 491                 .sendmsg = cor_sendmsg,
 492                 .recvmsg = cor_recvmsg
 493
 494         /*socketpair
 495         getname
 496         poll
 497         compat_ioctl
 498         setsockopt
 499         getsockopt
 500         compat_setsockopt
 501         compat_getsockopt
 502         mmap
 503         sendpage
 504         splice_read*/
 505 };
 506
 507 int cor_createsock(struct net *net, struct socket *sock, int protocol)
 508 {
 509         if (0 != protocol)
 510                 return -EPROTONOSUPPORT;
 511
 512         sock->state = SS_UNCONNECTED;
 513         sock->ops = &cor_proto_ops;
 514
 515         return 0;
 516 }
 517
 518 static struct net_proto_family cor_net_proto_family = {
 519         .family = PF_COR,
 520         .create = cor_createsock,
 521         .owner = THIS_MODULE
 522 };
 523
 524 static int __init cor_sock_init(void)
 525 {
 526         sock_register(&cor_net_proto_family);
 527         return 0;
 528 }
 529
 530 module_init(cor_sock_init);
 531
 532 MODULE_LICENSE("GPL");
 533