1 /* 2 * linux/net/iucv/af_iucv.c 3 * 4 * IUCV protocol stack for Linux on zSeries 5 * 6 * Copyright 2006 IBM Corporation 7 * 8 * Author(s): Jennifer Hunt <jenhunt@us.ibm.com> 9 */ 10 11 #include <linux/module.h> 12 #include <linux/types.h> 13 #include <linux/list.h> 14 #include <linux/errno.h> 15 #include <linux/kernel.h> 16 #include <linux/sched.h> 17 #include <linux/slab.h> 18 #include <linux/skbuff.h> 19 #include <linux/init.h> 20 #include <linux/poll.h> 21 #include <net/sock.h> 22 #include <asm/ebcdic.h> 23 #include <asm/cpcmd.h> 24 #include <linux/kmod.h> 25 26 #include <net/iucv/iucv.h> 27 #include <net/iucv/af_iucv.h> 28 29 #define CONFIG_IUCV_SOCK_DEBUG 1 30 31 #define IPRMDATA 0x80 32 #define VERSION "1.0" 33 34 static char iucv_userid[80]; 35 36 static struct proto_ops iucv_sock_ops; 37 38 static struct proto iucv_proto = { 39 .name = "AF_IUCV", 40 .owner = THIS_MODULE, 41 .obj_size = sizeof(struct iucv_sock), 42 }; 43 44 /* Call Back functions */ 45 static void iucv_callback_rx(struct iucv_path *, struct iucv_message *); 46 static void iucv_callback_txdone(struct iucv_path *, struct iucv_message *); 47 static void iucv_callback_connack(struct iucv_path *, u8 ipuser[16]); 48 static int iucv_callback_connreq(struct iucv_path *, u8 ipvmid[8], u8 ipuser[16]); 49 static void iucv_callback_connrej(struct iucv_path *, u8 ipuser[16]); 50 51 static struct iucv_sock_list iucv_sk_list = { 52 .lock = RW_LOCK_UNLOCKED, 53 .autobind_name = ATOMIC_INIT(0) 54 }; 55 56 static struct iucv_handler af_iucv_handler = { 57 .path_pending = iucv_callback_connreq, 58 .path_complete = iucv_callback_connack, 59 .path_severed = iucv_callback_connrej, 60 .message_pending = iucv_callback_rx, 61 .message_complete = iucv_callback_txdone 62 }; 63 64 static inline void high_nmcpy(unsigned char *dst, char *src) 65 { 66 memcpy(dst, src, 8); 67 } 68 69 static inline void low_nmcpy(unsigned char *dst, char *src) 70 { 71 memcpy(&dst[8], src, 8); 72 } 73 74 /* Timers */ 75 static void iucv_sock_timeout(unsigned long arg) 76 { 77 struct sock *sk = (struct sock *)arg; 78 79 bh_lock_sock(sk); 80 sk->sk_err = ETIMEDOUT; 81 sk->sk_state_change(sk); 82 bh_unlock_sock(sk); 83 84 iucv_sock_kill(sk); 85 sock_put(sk); 86 } 87 88 static void iucv_sock_clear_timer(struct sock *sk) 89 { 90 sk_stop_timer(sk, &sk->sk_timer); 91 } 92 93 static void iucv_sock_init_timer(struct sock *sk) 94 { 95 init_timer(&sk->sk_timer); 96 sk->sk_timer.function = iucv_sock_timeout; 97 sk->sk_timer.data = (unsigned long)sk; 98 } 99 100 static struct sock *__iucv_get_sock_by_name(char *nm) 101 { 102 struct sock *sk; 103 struct hlist_node *node; 104 105 sk_for_each(sk, node, &iucv_sk_list.head) 106 if (!memcmp(&iucv_sk(sk)->src_name, nm, 8)) 107 return sk; 108 109 return NULL; 110 } 111 112 static void iucv_sock_destruct(struct sock *sk) 113 { 114 skb_queue_purge(&sk->sk_receive_queue); 115 skb_queue_purge(&sk->sk_write_queue); 116 } 117 118 /* Cleanup Listen */ 119 static void iucv_sock_cleanup_listen(struct sock *parent) 120 { 121 struct sock *sk; 122 123 /* Close non-accepted connections */ 124 while ((sk = iucv_accept_dequeue(parent, NULL))) { 125 iucv_sock_close(sk); 126 iucv_sock_kill(sk); 127 } 128 129 parent->sk_state = IUCV_CLOSED; 130 sock_set_flag(parent, SOCK_ZAPPED); 131 } 132 133 /* Kill socket */ 134 static void iucv_sock_kill(struct sock *sk) 135 { 136 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket) 137 return; 138 139 iucv_sock_unlink(&iucv_sk_list, sk); 140 sock_set_flag(sk, SOCK_DEAD); 141 sock_put(sk); 142 } 143 144 /* Close an IUCV socket */ 145 static void iucv_sock_close(struct sock *sk) 146 { 147 unsigned char user_data[16]; 148 struct iucv_sock *iucv = iucv_sk(sk); 149 int err; 150 151 iucv_sock_clear_timer(sk); 152 lock_sock(sk); 153 154 switch(sk->sk_state) { 155 case IUCV_LISTEN: 156 iucv_sock_cleanup_listen(sk); 157 break; 158 159 case IUCV_CONNECTED: 160 case IUCV_DISCONN: 161 err = 0; 162 if (iucv->path) { 163 low_nmcpy(user_data, iucv->src_name); 164 high_nmcpy(user_data, iucv->dst_name); 165 ASCEBC(user_data, sizeof(user_data)); 166 err = iucv_path_sever(iucv->path, user_data); 167 iucv_path_free(iucv->path); 168 iucv->path = NULL; 169 } 170 171 sk->sk_state = IUCV_CLOSED; 172 sk->sk_state_change(sk); 173 sk->sk_err = ECONNRESET; 174 sk->sk_state_change(sk); 175 176 skb_queue_purge(&iucv->send_skb_q); 177 178 sock_set_flag(sk, SOCK_ZAPPED); 179 break; 180 181 default: 182 sock_set_flag(sk, SOCK_ZAPPED); 183 break; 184 }; 185 186 release_sock(sk); 187 iucv_sock_kill(sk); 188 } 189 190 static void iucv_sock_init(struct sock *sk, struct sock *parent) 191 { 192 if (parent) 193 sk->sk_type = parent->sk_type; 194 } 195 196 static struct sock *iucv_sock_alloc(struct socket *sock, int proto, gfp_t prio) 197 { 198 struct sock *sk; 199 200 sk = sk_alloc(PF_IUCV, prio, &iucv_proto, 1); 201 if (!sk) 202 return NULL; 203 204 sock_init_data(sock, sk); 205 INIT_LIST_HEAD(&iucv_sk(sk)->accept_q); 206 skb_queue_head_init(&iucv_sk(sk)->send_skb_q); 207 iucv_sk(sk)->send_tag = 0; 208 209 sk->sk_destruct = iucv_sock_destruct; 210 sk->sk_sndtimeo = IUCV_CONN_TIMEOUT; 211 sk->sk_allocation = GFP_DMA; 212 213 sock_reset_flag(sk, SOCK_ZAPPED); 214 215 sk->sk_protocol = proto; 216 sk->sk_state = IUCV_OPEN; 217 218 iucv_sock_init_timer(sk); 219 220 iucv_sock_link(&iucv_sk_list, sk); 221 return sk; 222 } 223 224 /* Create an IUCV socket */ 225 static int iucv_sock_create(struct socket *sock, int protocol) 226 { 227 struct sock *sk; 228 229 if (sock->type != SOCK_STREAM) 230 return -ESOCKTNOSUPPORT; 231 232 sock->state = SS_UNCONNECTED; 233 sock->ops = &iucv_sock_ops; 234 235 sk = iucv_sock_alloc(sock, protocol, GFP_KERNEL); 236 if (!sk) 237 return -ENOMEM; 238 239 iucv_sock_init(sk, NULL); 240 241 return 0; 242 } 243 244 void iucv_sock_link(struct iucv_sock_list *l, struct sock *sk) 245 { 246 write_lock_bh(&l->lock); 247 sk_add_node(sk, &l->head); 248 write_unlock_bh(&l->lock); 249 } 250 251 void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *sk) 252 { 253 write_lock_bh(&l->lock); 254 sk_del_node_init(sk); 255 write_unlock_bh(&l->lock); 256 } 257 258 void iucv_accept_enqueue(struct sock *parent, struct sock *sk) 259 { 260 sock_hold(sk); 261 list_add_tail(&iucv_sk(sk)->accept_q, &iucv_sk(parent)->accept_q); 262 iucv_sk(sk)->parent = parent; 263 parent->sk_ack_backlog++; 264 } 265 266 void iucv_accept_unlink(struct sock *sk) 267 { 268 list_del_init(&iucv_sk(sk)->accept_q); 269 iucv_sk(sk)->parent->sk_ack_backlog--; 270 iucv_sk(sk)->parent = NULL; 271 sock_put(sk); 272 } 273 274 struct sock *iucv_accept_dequeue(struct sock *parent, struct socket *newsock) 275 { 276 struct iucv_sock *isk, *n; 277 struct sock *sk; 278 279 list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q){ 280 sk = (struct sock *) isk; 281 lock_sock(sk); 282 283 if (sk->sk_state == IUCV_CLOSED) { 284 release_sock(sk); 285 iucv_accept_unlink(sk); 286 continue; 287 } 288 289 if (sk->sk_state == IUCV_CONNECTED || 290 sk->sk_state == IUCV_SEVERED || 291 !newsock) { 292 iucv_accept_unlink(sk); 293 if (newsock) 294 sock_graft(sk, newsock); 295 296 if (sk->sk_state == IUCV_SEVERED) 297 sk->sk_state = IUCV_DISCONN; 298 299 release_sock(sk); 300 return sk; 301 } 302 303 release_sock(sk); 304 } 305 return NULL; 306 } 307 308 int iucv_sock_wait_state(struct sock *sk, int state, int state2, 309 unsigned long timeo) 310 { 311 DECLARE_WAITQUEUE(wait, current); 312 int err = 0; 313 314 add_wait_queue(sk->sk_sleep, &wait); 315 while (sk->sk_state != state && sk->sk_state != state2) { 316 set_current_state(TASK_INTERRUPTIBLE); 317 318 if (!timeo) { 319 err = -EAGAIN; 320 break; 321 } 322 323 if (signal_pending(current)) { 324 err = sock_intr_errno(timeo); 325 break; 326 } 327 328 release_sock(sk); 329 timeo = schedule_timeout(timeo); 330 lock_sock(sk); 331 332 err = sock_error(sk); 333 if (err) 334 break; 335 } 336 set_current_state(TASK_RUNNING); 337 remove_wait_queue(sk->sk_sleep, &wait); 338 return err; 339 } 340 341 /* Bind an unbound socket */ 342 static int iucv_sock_bind(struct socket *sock, struct sockaddr *addr, 343 int addr_len) 344 { 345 struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr; 346 struct sock *sk = sock->sk; 347 struct iucv_sock *iucv; 348 int err; 349 350 /* Verify the input sockaddr */ 351 if (!addr || addr->sa_family != AF_IUCV) 352 return -EINVAL; 353 354 lock_sock(sk); 355 if (sk->sk_state != IUCV_OPEN) { 356 err = -EBADFD; 357 goto done; 358 } 359 360 write_lock_bh(&iucv_sk_list.lock); 361 362 iucv = iucv_sk(sk); 363 if (__iucv_get_sock_by_name(sa->siucv_name)) { 364 err = -EADDRINUSE; 365 goto done_unlock; 366 } 367 if (iucv->path) { 368 err = 0; 369 goto done_unlock; 370 } 371 372 /* Bind the socket */ 373 memcpy(iucv->src_name, sa->siucv_name, 8); 374 375 /* Copy the user id */ 376 memcpy(iucv->src_user_id, iucv_userid, 8); 377 sk->sk_state = IUCV_BOUND; 378 err = 0; 379 380 done_unlock: 381 /* Release the socket list lock */ 382 write_unlock_bh(&iucv_sk_list.lock); 383 done: 384 release_sock(sk); 385 return err; 386 } 387 388 /* Automatically bind an unbound socket */ 389 static int iucv_sock_autobind(struct sock *sk) 390 { 391 struct iucv_sock *iucv = iucv_sk(sk); 392 char query_buffer[80]; 393 char name[12]; 394 int err = 0; 395 396 /* Set the userid and name */ 397 cpcmd("QUERY USERID", query_buffer, sizeof(query_buffer), &err); 398 if (unlikely(err)) 399 return -EPROTO; 400 401 memcpy(iucv->src_user_id, query_buffer, 8); 402 403 write_lock_bh(&iucv_sk_list.lock); 404 405 sprintf(name, "%08x", atomic_inc_return(&iucv_sk_list.autobind_name)); 406 while (__iucv_get_sock_by_name(name)) { 407 sprintf(name, "%08x", 408 atomic_inc_return(&iucv_sk_list.autobind_name)); 409 } 410 411 write_unlock_bh(&iucv_sk_list.lock); 412 413 memcpy(&iucv->src_name, name, 8); 414 415 return err; 416 } 417 418 /* Connect an unconnected socket */ 419 static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr, 420 int alen, int flags) 421 { 422 struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr; 423 struct sock *sk = sock->sk; 424 struct iucv_sock *iucv; 425 unsigned char user_data[16]; 426 int err; 427 428 if (addr->sa_family != AF_IUCV || alen < sizeof(struct sockaddr_iucv)) 429 return -EINVAL; 430 431 if (sk->sk_state != IUCV_OPEN && sk->sk_state != IUCV_BOUND) 432 return -EBADFD; 433 434 if (sk->sk_type != SOCK_STREAM) 435 return -EINVAL; 436 437 iucv = iucv_sk(sk); 438 439 if (sk->sk_state == IUCV_OPEN) { 440 err = iucv_sock_autobind(sk); 441 if (unlikely(err)) 442 return err; 443 } 444 445 lock_sock(sk); 446 447 /* Set the destination information */ 448 memcpy(iucv_sk(sk)->dst_user_id, sa->siucv_user_id, 8); 449 memcpy(iucv_sk(sk)->dst_name, sa->siucv_name, 8); 450 451 high_nmcpy(user_data, sa->siucv_name); 452 low_nmcpy(user_data, iucv_sk(sk)->src_name); 453 ASCEBC(user_data, sizeof(user_data)); 454 455 iucv = iucv_sk(sk); 456 /* Create path. */ 457 iucv->path = iucv_path_alloc(IUCV_QUEUELEN_DEFAULT, 458 IPRMDATA, GFP_KERNEL); 459 err = iucv_path_connect(iucv->path, &af_iucv_handler, 460 sa->siucv_user_id, NULL, user_data, sk); 461 if (err) { 462 iucv_path_free(iucv->path); 463 iucv->path = NULL; 464 err = -ECONNREFUSED; 465 goto done; 466 } 467 468 if (sk->sk_state != IUCV_CONNECTED) { 469 err = iucv_sock_wait_state(sk, IUCV_CONNECTED, IUCV_DISCONN, 470 sock_sndtimeo(sk, flags & O_NONBLOCK)); 471 } 472 473 if (sk->sk_state == IUCV_DISCONN) { 474 release_sock(sk); 475 return -ECONNREFUSED; 476 } 477 done: 478 release_sock(sk); 479 return err; 480 } 481 482 /* Move a socket into listening state. */ 483 static int iucv_sock_listen(struct socket *sock, int backlog) 484 { 485 struct sock *sk = sock->sk; 486 int err; 487 488 lock_sock(sk); 489 490 err = -EINVAL; 491 if (sk->sk_state != IUCV_BOUND || sock->type != SOCK_STREAM) 492 goto done; 493 494 sk->sk_max_ack_backlog = backlog; 495 sk->sk_ack_backlog = 0; 496 sk->sk_state = IUCV_LISTEN; 497 err = 0; 498 499 done: 500 release_sock(sk); 501 return err; 502 } 503 504 /* Accept a pending connection */ 505 static int iucv_sock_accept(struct socket *sock, struct socket *newsock, 506 int flags) 507 { 508 DECLARE_WAITQUEUE(wait, current); 509 struct sock *sk = sock->sk, *nsk; 510 long timeo; 511 int err = 0; 512 513 lock_sock(sk); 514 515 if (sk->sk_state != IUCV_LISTEN) { 516 err = -EBADFD; 517 goto done; 518 } 519 520 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 521 522 /* Wait for an incoming connection */ 523 add_wait_queue_exclusive(sk->sk_sleep, &wait); 524 while (!(nsk = iucv_accept_dequeue(sk, newsock))){ 525 set_current_state(TASK_INTERRUPTIBLE); 526 if (!timeo) { 527 err = -EAGAIN; 528 break; 529 } 530 531 release_sock(sk); 532 timeo = schedule_timeout(timeo); 533 lock_sock(sk); 534 535 if (sk->sk_state != IUCV_LISTEN) { 536 err = -EBADFD; 537 break; 538 } 539 540 if (signal_pending(current)) { 541 err = sock_intr_errno(timeo); 542 break; 543 } 544 } 545 546 set_current_state(TASK_RUNNING); 547 remove_wait_queue(sk->sk_sleep, &wait); 548 549 if (err) 550 goto done; 551 552 newsock->state = SS_CONNECTED; 553 554 done: 555 release_sock(sk); 556 return err; 557 } 558 559 static int iucv_sock_getname(struct socket *sock, struct sockaddr *addr, 560 int *len, int peer) 561 { 562 struct sockaddr_iucv *siucv = (struct sockaddr_iucv *) addr; 563 struct sock *sk = sock->sk; 564 565 addr->sa_family = AF_IUCV; 566 *len = sizeof(struct sockaddr_iucv); 567 568 if (peer) { 569 memcpy(siucv->siucv_user_id, iucv_sk(sk)->dst_user_id, 8); 570 memcpy(siucv->siucv_name, &iucv_sk(sk)->dst_name, 8); 571 } else { 572 memcpy(siucv->siucv_user_id, iucv_sk(sk)->src_user_id, 8); 573 memcpy(siucv->siucv_name, iucv_sk(sk)->src_name, 8); 574 } 575 memset(&siucv->siucv_port, 0, sizeof(siucv->siucv_port)); 576 memset(&siucv->siucv_addr, 0, sizeof(siucv->siucv_addr)); 577 memset(siucv->siucv_nodeid, 0, sizeof(siucv->siucv_nodeid)); 578 579 return 0; 580 } 581 582 static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock, 583 struct msghdr *msg, size_t len) 584 { 585 struct sock *sk = sock->sk; 586 struct iucv_sock *iucv = iucv_sk(sk); 587 struct sk_buff *skb; 588 struct iucv_message txmsg; 589 int err; 590 591 err = sock_error(sk); 592 if (err) 593 return err; 594 595 if (msg->msg_flags & MSG_OOB) 596 return -EOPNOTSUPP; 597 598 lock_sock(sk); 599 600 if (sk->sk_shutdown & SEND_SHUTDOWN) { 601 err = -EPIPE; 602 goto out; 603 } 604 605 if (sk->sk_state == IUCV_CONNECTED){ 606 if(!(skb = sock_alloc_send_skb(sk, len, 607 msg->msg_flags & MSG_DONTWAIT, 608 &err))) 609 return err; 610 611 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)){ 612 err = -EFAULT; 613 goto fail; 614 } 615 616 txmsg.class = 0; 617 txmsg.tag = iucv->send_tag++; 618 memcpy(skb->cb, &txmsg.tag, 4); 619 skb_queue_tail(&iucv->send_skb_q, skb); 620 err = iucv_message_send(iucv->path, &txmsg, 0, 0, 621 (void *) skb->data, skb->len); 622 if (err) { 623 if (err == 3) 624 printk(KERN_ERR "AF_IUCV msg limit exceeded\n"); 625 skb_unlink(skb, &iucv->send_skb_q); 626 err = -EPIPE; 627 goto fail; 628 } 629 630 } else { 631 err = -ENOTCONN; 632 goto out; 633 } 634 635 release_sock(sk); 636 return len; 637 638 fail: 639 kfree_skb(skb); 640 out: 641 release_sock(sk); 642 return err; 643 } 644 645 static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock, 646 struct msghdr *msg, size_t len, int flags) 647 { 648 int noblock = flags & MSG_DONTWAIT; 649 struct sock *sk = sock->sk; 650 int target, copied = 0; 651 struct sk_buff *skb; 652 int err = 0; 653 654 if (flags & (MSG_OOB)) 655 return -EOPNOTSUPP; 656 657 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len); 658 659 skb = skb_recv_datagram(sk, flags, noblock, &err); 660 if (!skb) { 661 if (sk->sk_shutdown & RCV_SHUTDOWN) 662 return 0; 663 return err; 664 } 665 666 copied = min_t(unsigned int, skb->len, len); 667 668 if (memcpy_toiovec(msg->msg_iov, skb->data, copied)) { 669 skb_queue_head(&sk->sk_receive_queue, skb); 670 if (copied == 0) 671 return -EFAULT; 672 } 673 674 len -= copied; 675 676 /* Mark read part of skb as used */ 677 if (!(flags & MSG_PEEK)) { 678 skb_pull(skb, copied); 679 680 if (skb->len) { 681 skb_queue_head(&sk->sk_receive_queue, skb); 682 goto done; 683 } 684 685 kfree_skb(skb); 686 } else 687 skb_queue_head(&sk->sk_receive_queue, skb); 688 689 done: 690 return err ? : copied; 691 } 692 693 static inline unsigned int iucv_accept_poll(struct sock *parent) 694 { 695 struct iucv_sock *isk, *n; 696 struct sock *sk; 697 698 list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q){ 699 sk = (struct sock *) isk; 700 701 if (sk->sk_state == IUCV_CONNECTED) 702 return POLLIN | POLLRDNORM; 703 } 704 705 return 0; 706 } 707 708 unsigned int iucv_sock_poll(struct file *file, struct socket *sock, 709 poll_table *wait) 710 { 711 struct sock *sk = sock->sk; 712 unsigned int mask = 0; 713 714 poll_wait(file, sk->sk_sleep, wait); 715 716 if (sk->sk_state == IUCV_LISTEN) 717 return iucv_accept_poll(sk); 718 719 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue)) 720 mask |= POLLERR; 721 722 if (sk->sk_shutdown & RCV_SHUTDOWN) 723 mask |= POLLRDHUP; 724 725 if (sk->sk_shutdown == SHUTDOWN_MASK) 726 mask |= POLLHUP; 727 728 if (!skb_queue_empty(&sk->sk_receive_queue) || 729 (sk->sk_shutdown & RCV_SHUTDOWN)) 730 mask |= POLLIN | POLLRDNORM; 731 732 if (sk->sk_state == IUCV_CLOSED) 733 mask |= POLLHUP; 734 735 if (sock_writeable(sk)) 736 mask |= POLLOUT | POLLWRNORM | POLLWRBAND; 737 else 738 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 739 740 return mask; 741 } 742 743 static int iucv_sock_shutdown(struct socket *sock, int how) 744 { 745 struct sock *sk = sock->sk; 746 struct iucv_sock *iucv = iucv_sk(sk); 747 struct iucv_message txmsg; 748 int err = 0; 749 u8 prmmsg[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}; 750 751 how++; 752 753 if ((how & ~SHUTDOWN_MASK) || !how) 754 return -EINVAL; 755 756 lock_sock(sk); 757 switch(sk->sk_state) { 758 case IUCV_CLOSED: 759 err = -ENOTCONN; 760 goto fail; 761 762 default: 763 sk->sk_shutdown |= how; 764 break; 765 } 766 767 if (how == SEND_SHUTDOWN || how == SHUTDOWN_MASK) { 768 txmsg.class = 0; 769 txmsg.tag = 0; 770 err = iucv_message_send(iucv->path, &txmsg, IUCV_IPRMDATA, 0, 771 (void *) prmmsg, 8); 772 if (err) { 773 switch(err) { 774 case 1: 775 err = -ENOTCONN; 776 break; 777 case 2: 778 err = -ECONNRESET; 779 break; 780 default: 781 err = -ENOTCONN; 782 break; 783 } 784 } 785 } 786 787 if (how == RCV_SHUTDOWN || how == SHUTDOWN_MASK) { 788 err = iucv_path_quiesce(iucv_sk(sk)->path, NULL); 789 if (err) 790 err = -ENOTCONN; 791 792 skb_queue_purge(&sk->sk_receive_queue); 793 } 794 795 /* Wake up anyone sleeping in poll */ 796 sk->sk_state_change(sk); 797 798 fail: 799 release_sock(sk); 800 return err; 801 } 802 803 static int iucv_sock_release(struct socket *sock) 804 { 805 struct sock *sk = sock->sk; 806 int err = 0; 807 808 if (!sk) 809 return 0; 810 811 iucv_sock_close(sk); 812 813 /* Unregister with IUCV base support */ 814 if (iucv_sk(sk)->path) { 815 iucv_path_sever(iucv_sk(sk)->path, NULL); 816 iucv_path_free(iucv_sk(sk)->path); 817 iucv_sk(sk)->path = NULL; 818 } 819 820 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime){ 821 lock_sock(sk); 822 err = iucv_sock_wait_state(sk, IUCV_CLOSED, 0, 823 sk->sk_lingertime); 824 release_sock(sk); 825 } 826 827 sock_orphan(sk); 828 iucv_sock_kill(sk); 829 return err; 830 } 831 832 /* Callback wrappers - called from iucv base support */ 833 static int iucv_callback_connreq(struct iucv_path *path, 834 u8 ipvmid[8], u8 ipuser[16]) 835 { 836 unsigned char user_data[16]; 837 unsigned char nuser_data[16]; 838 unsigned char src_name[8]; 839 struct hlist_node *node; 840 struct sock *sk, *nsk; 841 struct iucv_sock *iucv, *niucv; 842 int err; 843 844 memcpy(src_name, ipuser, 8); 845 EBCASC(src_name, 8); 846 /* Find out if this path belongs to af_iucv. */ 847 read_lock(&iucv_sk_list.lock); 848 iucv = NULL; 849 sk_for_each(sk, node, &iucv_sk_list.head) 850 if (sk->sk_state == IUCV_LISTEN && 851 !memcmp(&iucv_sk(sk)->src_name, src_name, 8)) { 852 /* 853 * Found a listening socket with 854 * src_name == ipuser[0-7]. 855 */ 856 iucv = iucv_sk(sk); 857 break; 858 } 859 read_unlock(&iucv_sk_list.lock); 860 if (!iucv) 861 /* No socket found, not one of our paths. */ 862 return -EINVAL; 863 864 bh_lock_sock(sk); 865 866 /* Check if parent socket is listening */ 867 low_nmcpy(user_data, iucv->src_name); 868 high_nmcpy(user_data, iucv->dst_name); 869 ASCEBC(user_data, sizeof(user_data)); 870 if (sk->sk_state != IUCV_LISTEN) { 871 err = iucv_path_sever(path, user_data); 872 goto fail; 873 } 874 875 /* Check for backlog size */ 876 if (sk_acceptq_is_full(sk)) { 877 err = iucv_path_sever(path, user_data); 878 goto fail; 879 } 880 881 /* Create the new socket */ 882 nsk = iucv_sock_alloc(NULL, SOCK_STREAM, GFP_ATOMIC); 883 if (!nsk){ 884 err = iucv_path_sever(path, user_data); 885 goto fail; 886 } 887 888 niucv = iucv_sk(nsk); 889 iucv_sock_init(nsk, sk); 890 891 /* Set the new iucv_sock */ 892 memcpy(niucv->dst_name, ipuser + 8, 8); 893 EBCASC(niucv->dst_name, 8); 894 memcpy(niucv->dst_user_id, ipvmid, 8); 895 memcpy(niucv->src_name, iucv->src_name, 8); 896 memcpy(niucv->src_user_id, iucv->src_user_id, 8); 897 niucv->path = path; 898 899 /* Call iucv_accept */ 900 high_nmcpy(nuser_data, ipuser + 8); 901 memcpy(nuser_data + 8, niucv->src_name, 8); 902 ASCEBC(nuser_data + 8, 8); 903 904 path->msglim = IUCV_QUEUELEN_DEFAULT; 905 err = iucv_path_accept(path, &af_iucv_handler, nuser_data, nsk); 906 if (err){ 907 err = iucv_path_sever(path, user_data); 908 goto fail; 909 } 910 911 iucv_accept_enqueue(sk, nsk); 912 913 /* Wake up accept */ 914 nsk->sk_state = IUCV_CONNECTED; 915 sk->sk_data_ready(sk, 1); 916 err = 0; 917 fail: 918 bh_unlock_sock(sk); 919 return 0; 920 } 921 922 static void iucv_callback_connack(struct iucv_path *path, u8 ipuser[16]) 923 { 924 struct sock *sk = path->private; 925 926 sk->sk_state = IUCV_CONNECTED; 927 sk->sk_state_change(sk); 928 } 929 930 static void iucv_callback_rx(struct iucv_path *path, struct iucv_message *msg) 931 { 932 struct sock *sk = path->private; 933 struct sk_buff *skb; 934 int rc; 935 936 if (sk->sk_shutdown & RCV_SHUTDOWN) 937 return; 938 939 skb = alloc_skb(msg->length, GFP_ATOMIC | GFP_DMA); 940 if (!skb) { 941 iucv_message_reject(path, msg); 942 return; 943 } 944 945 if (msg->flags & IPRMDATA) { 946 skb->data = NULL; 947 skb->len = 0; 948 } else { 949 rc = iucv_message_receive(path, msg, 0, skb->data, 950 msg->length, NULL); 951 if (rc) { 952 kfree_skb(skb); 953 return; 954 } 955 956 skb->h.raw = skb->data; 957 skb->nh.raw = skb->data; 958 skb->len = msg->length; 959 } 960 961 if (sock_queue_rcv_skb(sk, skb)) 962 kfree_skb(skb); 963 } 964 965 static void iucv_callback_txdone(struct iucv_path *path, 966 struct iucv_message *msg) 967 { 968 struct sock *sk = path->private; 969 struct sk_buff *this; 970 struct sk_buff_head *list = &iucv_sk(sk)->send_skb_q; 971 struct sk_buff *list_skb = list->next; 972 unsigned long flags; 973 974 spin_lock_irqsave(&list->lock, flags); 975 976 do { 977 this = list_skb; 978 list_skb = list_skb->next; 979 } while (memcmp(&msg->tag, this->cb, 4)); 980 981 spin_unlock_irqrestore(&list->lock, flags); 982 983 skb_unlink(this, &iucv_sk(sk)->send_skb_q); 984 kfree_skb(this); 985 } 986 987 static void iucv_callback_connrej(struct iucv_path *path, u8 ipuser[16]) 988 { 989 struct sock *sk = path->private; 990 991 if (!list_empty(&iucv_sk(sk)->accept_q)) 992 sk->sk_state = IUCV_SEVERED; 993 else 994 sk->sk_state = IUCV_DISCONN; 995 996 sk->sk_state_change(sk); 997 } 998 999 static struct proto_ops iucv_sock_ops = { 1000 .family = PF_IUCV, 1001 .owner = THIS_MODULE, 1002 .release = iucv_sock_release, 1003 .bind = iucv_sock_bind, 1004 .connect = iucv_sock_connect, 1005 .listen = iucv_sock_listen, 1006 .accept = iucv_sock_accept, 1007 .getname = iucv_sock_getname, 1008 .sendmsg = iucv_sock_sendmsg, 1009 .recvmsg = iucv_sock_recvmsg, 1010 .poll = iucv_sock_poll, 1011 .ioctl = sock_no_ioctl, 1012 .mmap = sock_no_mmap, 1013 .socketpair = sock_no_socketpair, 1014 .shutdown = iucv_sock_shutdown, 1015 .setsockopt = sock_no_setsockopt, 1016 .getsockopt = sock_no_getsockopt 1017 }; 1018 1019 static struct net_proto_family iucv_sock_family_ops = { 1020 .family = AF_IUCV, 1021 .owner = THIS_MODULE, 1022 .create = iucv_sock_create, 1023 }; 1024 1025 static int afiucv_init(void) 1026 { 1027 int err; 1028 1029 if (!MACHINE_IS_VM) { 1030 printk(KERN_ERR "AF_IUCV connection needs VM as base\n"); 1031 err = -EPROTONOSUPPORT; 1032 goto out; 1033 } 1034 cpcmd("QUERY USERID", iucv_userid, sizeof(iucv_userid), &err); 1035 if (unlikely(err)) { 1036 printk(KERN_ERR "AF_IUCV needs the VM userid\n"); 1037 err = -EPROTONOSUPPORT; 1038 goto out; 1039 } 1040 1041 err = iucv_register(&af_iucv_handler, 0); 1042 if (err) 1043 goto out; 1044 err = proto_register(&iucv_proto, 0); 1045 if (err) 1046 goto out_iucv; 1047 err = sock_register(&iucv_sock_family_ops); 1048 if (err) 1049 goto out_proto; 1050 printk(KERN_INFO "AF_IUCV lowlevel driver initialized\n"); 1051 return 0; 1052 1053 out_proto: 1054 proto_unregister(&iucv_proto); 1055 out_iucv: 1056 iucv_unregister(&af_iucv_handler, 0); 1057 out: 1058 return err; 1059 } 1060 1061 static void __exit afiucv_exit(void) 1062 { 1063 sock_unregister(PF_IUCV); 1064 proto_unregister(&iucv_proto); 1065 iucv_unregister(&af_iucv_handler, 0); 1066 1067 printk(KERN_INFO "AF_IUCV lowlevel driver unloaded\n"); 1068 } 1069 1070 module_init(afiucv_init); 1071 module_exit(afiucv_exit); 1072 1073 MODULE_AUTHOR("Jennifer Hunt <jenhunt@us.ibm.com>"); 1074 MODULE_DESCRIPTION("IUCV Sockets ver " VERSION); 1075 MODULE_VERSION(VERSION); 1076 MODULE_LICENSE("GPL"); 1077 MODULE_ALIAS_NETPROTO(PF_IUCV); 1078