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         printk(KERN_ERR "out1");
 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         rc = skb_add_data(rconn->target.out.skb, msg, copy);
 278         BUG_ON(0 > rc);
 279         if (rc != 0)
 280                 return rc;
 281         rconn->target.out.skb_written += copy;
 282
 283         if (send) {
 284                 send_packet(rconn->target.out.skb, rconn->target.out.nb);
 285                 rconn->target.out.skb = 0;
 286                 rconn->target.out.skb_written = 0;
 287         }
 288
 289         return copy;
 290 }
 291
 292 int cor_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 293                 size_t total_len)
 294 {
 295         int copied = 0;
 296
 297         struct conn *rconn = (struct conn *) sock->sk;
 298
 299         int iovidx = 0;
 300         int iovread = 0;
 301
 302         int rc = check_conn_state(rconn);
 303
 304         if (unlikely(rc))
 305                 return -EBADF;
 306
 307         #warning todo nonblocking io
 308         mutex_lock(&(rconn->source.sock.lock));
 309         while (iovidx < msg->msg_iovlen) {
 310                 struct iovec *iov = msg->msg_iov + iovidx;
 311                 __user char *userbuf = iov->iov_base + iovread;
 312                 int len = iov->iov_len - iovread;
 313
 314                 int copy = -ECONNRESET;
 315                 if (rconn->targettype == TARGET_UNCONNECTED) {
 316                         struct data data;
 317
 318                         char buf[1];
 319                         long cpy = copy_from_user(&buf, userbuf, 1);
 320                         if (cpy != 0) {
 321                                 copy = -EFAULT;
 322                                 goto out;
 323                         }
 324
 325                         #warning todo check if receive buffer is empty, otherwise there may be a deadlock
 326
 327                         data.type = TYPE_BUF;
 328                         data.data.buf.buf = buf;
 329                         data.data.buf.len = 1;
 330                         parse(&data, rconn);
 331                         copy = 1 - data.data.buf.len;
 332                 } else if (rconn->targettype == TARGET_SOCK) {
 333                         copy = cor_sendmsg_socket(rconn, userbuf, len,
 334                                         copied == 0);
 335                 } else if (rconn->targettype == TARGET_OUT) {
 336                         copy = cor_sendmsg_out(rconn, userbuf, len,
 337                                         copied == 0);
 338                 } else {
 339                         BUG();
 340                 }
 341
 342 out:
 343
 344                 if (copy < 0) {
 345                         if (copied == 0)
 346                                 copied = copy;
 347                         break;
 348                 }
 349
 350                 copied += copy;
 351                 iovread += copy;
 352
 353                 if (iov->iov_len == iovread) {
 354                         iovidx++;
 355                         iovread = 0;
 356                 }
 357         }
 358         mutex_unlock(&(rconn->source.sock.lock));
 359
 360         return copied;
 361 }
 362
 363 static int cor_readytoread(struct conn *sconn)
 364 {
 365         int rc = 0;
 366         mutex_lock(&(sconn->target.sock.lock));
 367
 368         if (!skb_queue_empty(&(sconn->target.sock.queue)))
 369                 rc = 1;
 370         else if (ringbuffer_maypull(&(sconn->target.sock.rbuf)))
 371                 rc = 1;
 372
 373         mutex_unlock(&(sconn->target.sock.lock));
 374
 375         return rc;
 376 }
 377
 378 static int cor_recvmsg_skb(struct conn *sconn, __user char *msg,
 379                 unsigned int len)
 380 {
 381         int rc;
 382         struct sk_buff *skb = skb_dequeue(&(sconn->target.sock.queue));
 383
 384         BUG_ON(skb == 0);
 385
 386         len = min(len, skb->len);
 387         rc = copy_to_user(msg, skb->data, len);
 388
 389         if (rc == 0)
 390                 cor_pull_skb(skb, len);
 391
 392         if (skb->len != 0)
 393                 skb_queue_head(&(sconn->target.sock.queue), skb);
 394
 395         BUG_ON(0 < rc);
 396
 397         return rc == 0 ? 0 : -EFAULT;
 398 }
 399
 400 int cor_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 401                 size_t total_len, int flags)
 402 {
 403         struct conn *rconn = (struct conn *) sock->sk;
 404         struct conn *sconn = rconn->reversedir;
 405         size_t copied = 0;
 406
 407         int iovidx = 0;
 408         int iovread = 0;
 409
 410         int rc = check_conn_state(rconn);
 411
 412         if (unlikely(rc))
 413                 return -EBADF;
 414
 415         BUG_ON(sconn == 0);
 416
 417         mutex_lock(&(sconn->target.sock.lock));
 418
 419         while (iovidx < msg->msg_iovlen) {
 420                 int rc;
 421
 422                 struct iovec *iov = msg->msg_iov + iovidx;
 423                 __user char *msg = iov->iov_base + iovread;
 424                 unsigned int len = iov->iov_len - iovread;
 425
 426                 if (len == 0) {
 427                         iovidx++;
 428                         iovread = 0;
 429                         continue;
 430                 }
 431
 432                 if (ringbuffer_maypull(&(sconn->target.sock.rbuf)))
 433                         rc = ringbuffer_pull(&(sconn->target.sock.rbuf), msg, len, 1);
 434                 else if (!skb_queue_empty(&(sconn->target.sock.queue)))
 435                         rc = cor_recvmsg_skb(sconn, msg, len);
 436                 else
 437                         rc = 0;
 438
 439                 if (rc < 0 && copied == 0) {
 440                         copied = rc;
 441                         break;
 442                 }
 443
 444                 if (rc > 0) {
 445                         copied += rc;
 446                         iovread += rc;
 447                         continue;
 448                 }
 449
 450                 if (copied > 0)
 451                         break;
 452
 453                 if (flags & MSG_DONTWAIT) {
 454                         copied = -EAGAIN;
 455                         break;
 456                 }
 457
 458                 if (sconn->sourcetype == SOURCE_NONE) {
 459                         copied = -EPIPE;
 460                         break;
 461                 }
 462
 463                 mutex_unlock(&(sconn->target.sock.lock));
 464
 465                 if (wait_event_interruptible(sconn->target.sock.wait,
 466                                 cor_readytoread(sconn)))
 467                         copied = -ERESTARTSYS;
 468                 mutex_lock(&(sconn->target.sock.lock));
 469
 470                 if (copied != 0)
 471                         break;
 472         }
 473
 474         mutex_unlock(&(sconn->target.sock.lock));
 475
 476         if (sconn->sourcetype == SOURCE_SOCK)
 477                 wake_up_interruptible(&(sconn->target.sock.wait));
 478
 479         return copied;
 480 }
 481
 482 const struct proto_ops cor_proto_ops = {
 483                 .family = PF_COR,
 484                 .owner = THIS_MODULE,
 485                 .release = cor_socket_release,
 486                 .bind = cor_socket_bind,
 487                 .connect = cor_socket_connect,
 488                 .accept = cor_socket_accept,
 489                 .listen = cor_socket_listen,
 490                 .shutdown = cor_socket_shutdown,
 491                 .ioctl = cor_ioctl,
 492                 .sendmsg = cor_sendmsg,
 493                 .recvmsg = cor_recvmsg
 494
 495         /*socketpair
 496         getname
 497         poll
 498         compat_ioctl
 499         setsockopt
 500         getsockopt
 501         compat_setsockopt
 502         compat_getsockopt
 503         mmap
 504         sendpage
 505         splice_read*/
 506 };
 507
 508 int cor_createsock(struct net *net, struct socket *sock, int protocol)
 509 {
 510         if (0 != protocol)
 511                 return -EPROTONOSUPPORT;
 512
 513         sock->state = SS_UNCONNECTED;
 514         sock->ops = &cor_proto_ops;
 515
 516         return 0;
 517 }
 518
 519 static struct net_proto_family cor_net_proto_family = {
 520         .family = PF_COR,
 521         .create = cor_createsock,
 522         .owner = THIS_MODULE
 523 };
 524
 525 static int __init cor_sock_init(void)
 526 {
 527         sock_register(&cor_net_proto_family);
 528         return 0;
 529 }
 530
 531 module_init(cor_sock_init);
 532
 533 MODULE_LICENSE("GPL");
 534