1 2/* 3 * DECnet An implementation of the DECnet protocol suite for the LINUX 4 * operating system. DECnet is implemented using the BSD Socket 5 * interface as the means of communication with the user level. 6 * 7 * DECnet Socket Layer Interface 8 * 9 * Authors: Eduardo Marcelo Serrat <emserrat@geocities.com> 10 * Patrick Caulfield <patrick@pandh.demon.co.uk> 11 * 12 * Changes: 13 * Steve Whitehouse: Copied from Eduardo Serrat and Patrick Caulfield's 14 * version of the code. Original copyright preserved 15 * below. 16 * Steve Whitehouse: Some bug fixes, cleaning up some code to make it 17 * compatible with my routing layer. 18 * Steve Whitehouse: Merging changes from Eduardo Serrat and Patrick 19 * Caulfield. 20 * Steve Whitehouse: Further bug fixes, checking module code still works 21 * with new routing layer. 22 * Steve Whitehouse: Additional set/get_sockopt() calls. 23 * Steve Whitehouse: Fixed TIOCINQ ioctl to be same as Eduardo's new 24 * code. 25 * Steve Whitehouse: recvmsg() changed to try and behave in a POSIX like 26 * way. Didn't manage it entirely, but its better. 27 * Steve Whitehouse: ditto for sendmsg(). 28 * Steve Whitehouse: A selection of bug fixes to various things. 29 * Steve Whitehouse: Added TIOCOUTQ ioctl. 30 * Steve Whitehouse: Fixes to username2sockaddr & sockaddr2username. 31 * Steve Whitehouse: Fixes to connect() error returns. 32 * Patrick Caulfield: Fixes to delayed acceptance logic. 33 * David S. Miller: New socket locking 34 * Steve Whitehouse: Socket list hashing/locking 35 * Arnaldo C. Melo: use capable, not suser 36 * Steve Whitehouse: Removed unused code. Fix to use sk->allocation 37 * when required. 38 * Patrick Caulfield: /proc/net/decnet now has object name/number 39 * Steve Whitehouse: Fixed local port allocation, hashed sk list 40 * Matthew Wilcox: Fixes for dn_ioctl() 41 * Steve Whitehouse: New connect/accept logic to allow timeouts and 42 * prepare for sendpage etc. 43 */ 44 45 46/****************************************************************************** 47 (c) 1995-1998 E.M. Serrat emserrat@geocities.com 48 49 This program is free software; you can redistribute it and/or modify 50 it under the terms of the GNU General Public License as published by 51 the Free Software Foundation; either version 2 of the License, or 52 any later version. 53 54 This program is distributed in the hope that it will be useful, 55 but WITHOUT ANY WARRANTY; without even the implied warranty of 56 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 57 GNU General Public License for more details. 58 59HISTORY: 60 61Version Kernel Date Author/Comments 62------- ------ ---- --------------- 63Version 0.0.1 2.0.30 01-dic-97 Eduardo Marcelo Serrat 64 (emserrat@geocities.com) 65 66 First Development of DECnet Socket La- 67 yer for Linux. Only supports outgoing 68 connections. 69 70Version 0.0.2 2.1.105 20-jun-98 Patrick J. Caulfield 71 (patrick@pandh.demon.co.uk) 72 73 Port to new kernel development version. 74 75Version 0.0.3 2.1.106 25-jun-98 Eduardo Marcelo Serrat 76 (emserrat@geocities.com) 77 _ 78 Added support for incoming connections 79 so we can start developing server apps 80 on Linux. 81 - 82 Module Support 83Version 0.0.4 2.1.109 21-jul-98 Eduardo Marcelo Serrat 84 (emserrat@geocities.com) 85 _ 86 Added support for X11R6.4. Now we can 87 use DECnet transport for X on Linux!!! 88 - 89Version 0.0.5 2.1.110 01-aug-98 Eduardo Marcelo Serrat 90 (emserrat@geocities.com) 91 Removed bugs on flow control 92 Removed bugs on incoming accessdata 93 order 94 - 95Version 0.0.6 2.1.110 07-aug-98 Eduardo Marcelo Serrat 96 dn_recvmsg fixes 97 98 Patrick J. Caulfield 99 dn_bind fixes 100*******************************************************************************/ 101 102#include <linux/module.h> 103#include <linux/errno.h> 104#include <linux/types.h> 105#include <linux/slab.h> 106#include <linux/socket.h> 107#include <linux/in.h> 108#include <linux/kernel.h> 109#include <linux/sched.h> 110#include <linux/timer.h> 111#include <linux/string.h> 112#include <linux/sockios.h> 113#include <linux/net.h> 114#include <linux/netdevice.h> 115#include <linux/inet.h> 116#include <linux/route.h> 117#include <linux/netfilter.h> 118#include <linux/seq_file.h> 119#include <net/sock.h> 120#include <net/tcp_states.h> 121#include <net/flow.h> 122#include <asm/ioctls.h> 123#include <linux/capability.h> 124#include <linux/mm.h> 125#include <linux/interrupt.h> 126#include <linux/proc_fs.h> 127#include <linux/stat.h> 128#include <linux/init.h> 129#include <linux/poll.h> 130#include <linux/jiffies.h> 131#include <net/net_namespace.h> 132#include <net/neighbour.h> 133#include <net/dst.h> 134#include <net/fib_rules.h> 135#include <net/dn.h> 136#include <net/dn_nsp.h> 137#include <net/dn_dev.h> 138#include <net/dn_route.h> 139#include <net/dn_fib.h> 140#include <net/dn_neigh.h> 141 142struct dn_sock { 143 struct sock sk; 144 struct dn_scp scp; 145}; 146 147static void dn_keepalive(struct sock *sk); 148 149#define DN_SK_HASH_SHIFT 8 150#define DN_SK_HASH_SIZE (1 << DN_SK_HASH_SHIFT) 151#define DN_SK_HASH_MASK (DN_SK_HASH_SIZE - 1) 152 153 154static const struct proto_ops dn_proto_ops; 155static DEFINE_RWLOCK(dn_hash_lock); 156static struct hlist_head dn_sk_hash[DN_SK_HASH_SIZE]; 157static struct hlist_head dn_wild_sk; 158static atomic_long_t decnet_memory_allocated; 159 160static int __dn_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen, int flags); 161static int __dn_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen, int flags); 162 163static struct hlist_head *dn_find_list(struct sock *sk) 164{ 165 struct dn_scp *scp = DN_SK(sk); 166 167 if (scp->addr.sdn_flags & SDF_WILD) 168 return hlist_empty(&dn_wild_sk) ? &dn_wild_sk : NULL; 169 170 return &dn_sk_hash[le16_to_cpu(scp->addrloc) & DN_SK_HASH_MASK]; 171} 172 173/* 174 * Valid ports are those greater than zero and not already in use. 175 */ 176static int check_port(__le16 port) 177{ 178 struct sock *sk; 179 180 if (port == 0) 181 return -1; 182 183 sk_for_each(sk, &dn_sk_hash[le16_to_cpu(port) & DN_SK_HASH_MASK]) { 184 struct dn_scp *scp = DN_SK(sk); 185 if (scp->addrloc == port) 186 return -1; 187 } 188 return 0; 189} 190 191static unsigned short port_alloc(struct sock *sk) 192{ 193 struct dn_scp *scp = DN_SK(sk); 194static unsigned short port = 0x2000; 195 unsigned short i_port = port; 196 197 while(check_port(cpu_to_le16(++port)) != 0) { 198 if (port == i_port) 199 return 0; 200 } 201 202 scp->addrloc = cpu_to_le16(port); 203 204 return 1; 205} 206 207/* 208 * Since this is only ever called from user 209 * level, we don't need a write_lock() version 210 * of this. 211 */ 212static int dn_hash_sock(struct sock *sk) 213{ 214 struct dn_scp *scp = DN_SK(sk); 215 struct hlist_head *list; 216 int rv = -EUSERS; 217 218 BUG_ON(sk_hashed(sk)); 219 220 write_lock_bh(&dn_hash_lock); 221 222 if (!scp->addrloc && !port_alloc(sk)) 223 goto out; 224 225 rv = -EADDRINUSE; 226 if ((list = dn_find_list(sk)) == NULL) 227 goto out; 228 229 sk_add_node(sk, list); 230 rv = 0; 231out: 232 write_unlock_bh(&dn_hash_lock); 233 return rv; 234} 235 236static void dn_unhash_sock(struct sock *sk) 237{ 238 write_lock(&dn_hash_lock); 239 sk_del_node_init(sk); 240 write_unlock(&dn_hash_lock); 241} 242 243static void dn_unhash_sock_bh(struct sock *sk) 244{ 245 write_lock_bh(&dn_hash_lock); 246 sk_del_node_init(sk); 247 write_unlock_bh(&dn_hash_lock); 248} 249 250static struct hlist_head *listen_hash(struct sockaddr_dn *addr) 251{ 252 int i; 253 unsigned int hash = addr->sdn_objnum; 254 255 if (hash == 0) { 256 hash = addr->sdn_objnamel; 257 for(i = 0; i < le16_to_cpu(addr->sdn_objnamel); i++) { 258 hash ^= addr->sdn_objname[i]; 259 hash ^= (hash << 3); 260 } 261 } 262 263 return &dn_sk_hash[hash & DN_SK_HASH_MASK]; 264} 265 266/* 267 * Called to transform a socket from bound (i.e. with a local address) 268 * into a listening socket (doesn't need a local port number) and rehashes 269 * based upon the object name/number. 270 */ 271static void dn_rehash_sock(struct sock *sk) 272{ 273 struct hlist_head *list; 274 struct dn_scp *scp = DN_SK(sk); 275 276 if (scp->addr.sdn_flags & SDF_WILD) 277 return; 278 279 write_lock_bh(&dn_hash_lock); 280 sk_del_node_init(sk); 281 DN_SK(sk)->addrloc = 0; 282 list = listen_hash(&DN_SK(sk)->addr); 283 sk_add_node(sk, list); 284 write_unlock_bh(&dn_hash_lock); 285} 286 287int dn_sockaddr2username(struct sockaddr_dn *sdn, unsigned char *buf, unsigned char type) 288{ 289 int len = 2; 290 291 *buf++ = type; 292 293 switch (type) { 294 case 0: 295 *buf++ = sdn->sdn_objnum; 296 break; 297 case 1: 298 *buf++ = 0; 299 *buf++ = le16_to_cpu(sdn->sdn_objnamel); 300 memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel)); 301 len = 3 + le16_to_cpu(sdn->sdn_objnamel); 302 break; 303 case 2: 304 memset(buf, 0, 5); 305 buf += 5; 306 *buf++ = le16_to_cpu(sdn->sdn_objnamel); 307 memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel)); 308 len = 7 + le16_to_cpu(sdn->sdn_objnamel); 309 break; 310 } 311 312 return len; 313} 314 315/* 316 * On reception of usernames, we handle types 1 and 0 for destination 317 * addresses only. Types 2 and 4 are used for source addresses, but the 318 * UIC, GIC are ignored and they are both treated the same way. Type 3 319 * is never used as I've no idea what its purpose might be or what its 320 * format is. 321 */ 322int dn_username2sockaddr(unsigned char *data, int len, struct sockaddr_dn *sdn, unsigned char *fmt) 323{ 324 unsigned char type; 325 int size = len; 326 int namel = 12; 327 328 sdn->sdn_objnum = 0; 329 sdn->sdn_objnamel = cpu_to_le16(0); 330 memset(sdn->sdn_objname, 0, DN_MAXOBJL); 331 332 if (len < 2) 333 return -1; 334 335 len -= 2; 336 *fmt = *data++; 337 type = *data++; 338 339 switch (*fmt) { 340 case 0: 341 sdn->sdn_objnum = type; 342 return 2; 343 case 1: 344 namel = 16; 345 break; 346 case 2: 347 len -= 4; 348 data += 4; 349 break; 350 case 4: 351 len -= 8; 352 data += 8; 353 break; 354 default: 355 return -1; 356 } 357 358 len -= 1; 359 360 if (len < 0) 361 return -1; 362 363 sdn->sdn_objnamel = cpu_to_le16(*data++); 364 len -= le16_to_cpu(sdn->sdn_objnamel); 365 366 if ((len < 0) || (le16_to_cpu(sdn->sdn_objnamel) > namel)) 367 return -1; 368 369 memcpy(sdn->sdn_objname, data, le16_to_cpu(sdn->sdn_objnamel)); 370 371 return size - len; 372} 373 374struct sock *dn_sklist_find_listener(struct sockaddr_dn *addr) 375{ 376 struct hlist_head *list = listen_hash(addr); 377 struct sock *sk; 378 379 read_lock(&dn_hash_lock); 380 sk_for_each(sk, list) { 381 struct dn_scp *scp = DN_SK(sk); 382 if (sk->sk_state != TCP_LISTEN) 383 continue; 384 if (scp->addr.sdn_objnum) { 385 if (scp->addr.sdn_objnum != addr->sdn_objnum) 386 continue; 387 } else { 388 if (addr->sdn_objnum) 389 continue; 390 if (scp->addr.sdn_objnamel != addr->sdn_objnamel) 391 continue; 392 if (memcmp(scp->addr.sdn_objname, addr->sdn_objname, le16_to_cpu(addr->sdn_objnamel)) != 0) 393 continue; 394 } 395 sock_hold(sk); 396 read_unlock(&dn_hash_lock); 397 return sk; 398 } 399 400 sk = sk_head(&dn_wild_sk); 401 if (sk) { 402 if (sk->sk_state == TCP_LISTEN) 403 sock_hold(sk); 404 else 405 sk = NULL; 406 } 407 408 read_unlock(&dn_hash_lock); 409 return sk; 410} 411 412struct sock *dn_find_by_skb(struct sk_buff *skb) 413{ 414 struct dn_skb_cb *cb = DN_SKB_CB(skb); 415 struct sock *sk; 416 struct dn_scp *scp; 417 418 read_lock(&dn_hash_lock); 419 sk_for_each(sk, &dn_sk_hash[le16_to_cpu(cb->dst_port) & DN_SK_HASH_MASK]) { 420 scp = DN_SK(sk); 421 if (cb->src != dn_saddr2dn(&scp->peer)) 422 continue; 423 if (cb->dst_port != scp->addrloc) 424 continue; 425 if (scp->addrrem && (cb->src_port != scp->addrrem)) 426 continue; 427 sock_hold(sk); 428 goto found; 429 } 430 sk = NULL; 431found: 432 read_unlock(&dn_hash_lock); 433 return sk; 434} 435 436 437 438static void dn_destruct(struct sock *sk) 439{ 440 struct dn_scp *scp = DN_SK(sk); 441 442 skb_queue_purge(&scp->data_xmit_queue); 443 skb_queue_purge(&scp->other_xmit_queue); 444 skb_queue_purge(&scp->other_receive_queue); 445 446 dst_release(rcu_dereference_check(sk->sk_dst_cache, 1)); 447} 448 449static int dn_memory_pressure; 450 451static void dn_enter_memory_pressure(struct sock *sk) 452{ 453 if (!dn_memory_pressure) { 454 dn_memory_pressure = 1; 455 } 456} 457 458static struct proto dn_proto = { 459 .name = "NSP", 460 .owner = THIS_MODULE, 461 .enter_memory_pressure = dn_enter_memory_pressure, 462 .memory_pressure = &dn_memory_pressure, 463 .memory_allocated = &decnet_memory_allocated, 464 .sysctl_mem = sysctl_decnet_mem, 465 .sysctl_wmem = sysctl_decnet_wmem, 466 .sysctl_rmem = sysctl_decnet_rmem, 467 .max_header = DN_MAX_NSP_DATA_HEADER + 64, 468 .obj_size = sizeof(struct dn_sock), 469}; 470 471static struct sock *dn_alloc_sock(struct net *net, struct socket *sock, gfp_t gfp) 472{ 473 struct dn_scp *scp; 474 struct sock *sk = sk_alloc(net, PF_DECnet, gfp, &dn_proto); 475 476 if (!sk) 477 goto out; 478 479 if (sock) 480 sock->ops = &dn_proto_ops; 481 sock_init_data(sock, sk); 482 483 sk->sk_backlog_rcv = dn_nsp_backlog_rcv; 484 sk->sk_destruct = dn_destruct; 485 sk->sk_no_check_tx = 1; 486 sk->sk_family = PF_DECnet; 487 sk->sk_protocol = 0; 488 sk->sk_allocation = gfp; 489 sk->sk_sndbuf = sysctl_decnet_wmem[1]; 490 sk->sk_rcvbuf = sysctl_decnet_rmem[1]; 491 492 /* Initialization of DECnet Session Control Port */ 493 scp = DN_SK(sk); 494 scp->state = DN_O; /* Open */ 495 scp->numdat = 1; /* Next data seg to tx */ 496 scp->numoth = 1; /* Next oth data to tx */ 497 scp->ackxmt_dat = 0; /* Last data seg ack'ed */ 498 scp->ackxmt_oth = 0; /* Last oth data ack'ed */ 499 scp->ackrcv_dat = 0; /* Highest data ack recv*/ 500 scp->ackrcv_oth = 0; /* Last oth data ack rec*/ 501 scp->flowrem_sw = DN_SEND; 502 scp->flowloc_sw = DN_SEND; 503 scp->flowrem_dat = 0; 504 scp->flowrem_oth = 1; 505 scp->flowloc_dat = 0; 506 scp->flowloc_oth = 1; 507 scp->services_rem = 0; 508 scp->services_loc = 1 | NSP_FC_NONE; 509 scp->info_rem = 0; 510 scp->info_loc = 0x03; /* NSP version 4.1 */ 511 scp->segsize_rem = 230 - DN_MAX_NSP_DATA_HEADER; /* Default: Updated by remote segsize */ 512 scp->nonagle = 0; 513 scp->multi_ireq = 1; 514 scp->accept_mode = ACC_IMMED; 515 scp->addr.sdn_family = AF_DECnet; 516 scp->peer.sdn_family = AF_DECnet; 517 scp->accessdata.acc_accl = 5; 518 memcpy(scp->accessdata.acc_acc, "LINUX", 5); 519 520 scp->max_window = NSP_MAX_WINDOW; 521 scp->snd_window = NSP_MIN_WINDOW; 522 scp->nsp_srtt = NSP_INITIAL_SRTT; 523 scp->nsp_rttvar = NSP_INITIAL_RTTVAR; 524 scp->nsp_rxtshift = 0; 525 526 skb_queue_head_init(&scp->data_xmit_queue); 527 skb_queue_head_init(&scp->other_xmit_queue); 528 skb_queue_head_init(&scp->other_receive_queue); 529 530 scp->persist = 0; 531 scp->persist_fxn = NULL; 532 scp->keepalive = 10 * HZ; 533 scp->keepalive_fxn = dn_keepalive; 534 535 init_timer(&scp->delack_timer); 536 scp->delack_pending = 0; 537 scp->delack_fxn = dn_nsp_delayed_ack; 538 539 dn_start_slow_timer(sk); 540out: 541 return sk; 542} 543 544/* 545 * Keepalive timer. 546 * FIXME: Should respond to SO_KEEPALIVE etc. 547 */ 548static void dn_keepalive(struct sock *sk) 549{ 550 struct dn_scp *scp = DN_SK(sk); 551 552 /* 553 * By checking the other_data transmit queue is empty 554 * we are double checking that we are not sending too 555 * many of these keepalive frames. 556 */ 557 if (skb_queue_empty(&scp->other_xmit_queue)) 558 dn_nsp_send_link(sk, DN_NOCHANGE, 0); 559} 560 561 562/* 563 * Timer for shutdown/destroyed sockets. 564 * When socket is dead & no packets have been sent for a 565 * certain amount of time, they are removed by this 566 * routine. Also takes care of sending out DI & DC 567 * frames at correct times. 568 */ 569int dn_destroy_timer(struct sock *sk) 570{ 571 struct dn_scp *scp = DN_SK(sk); 572 573 scp->persist = dn_nsp_persist(sk); 574 575 switch (scp->state) { 576 case DN_DI: 577 dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC); 578 if (scp->nsp_rxtshift >= decnet_di_count) 579 scp->state = DN_CN; 580 return 0; 581 582 case DN_DR: 583 dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC); 584 if (scp->nsp_rxtshift >= decnet_dr_count) 585 scp->state = DN_DRC; 586 return 0; 587 588 case DN_DN: 589 if (scp->nsp_rxtshift < decnet_dn_count) { 590 /* printk(KERN_DEBUG "dn_destroy_timer: DN\n"); */ 591 dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, 592 GFP_ATOMIC); 593 return 0; 594 } 595 } 596 597 scp->persist = (HZ * decnet_time_wait); 598 599 if (sk->sk_socket) 600 return 0; 601 602 if (time_after_eq(jiffies, scp->stamp + HZ * decnet_time_wait)) { 603 dn_unhash_sock(sk); 604 sock_put(sk); 605 return 1; 606 } 607 608 return 0; 609} 610 611static void dn_destroy_sock(struct sock *sk) 612{ 613 struct dn_scp *scp = DN_SK(sk); 614 615 scp->nsp_rxtshift = 0; /* reset back off */ 616 617 if (sk->sk_socket) { 618 if (sk->sk_socket->state != SS_UNCONNECTED) 619 sk->sk_socket->state = SS_DISCONNECTING; 620 } 621 622 sk->sk_state = TCP_CLOSE; 623 624 switch (scp->state) { 625 case DN_DN: 626 dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, 627 sk->sk_allocation); 628 scp->persist_fxn = dn_destroy_timer; 629 scp->persist = dn_nsp_persist(sk); 630 break; 631 case DN_CR: 632 scp->state = DN_DR; 633 goto disc_reject; 634 case DN_RUN: 635 scp->state = DN_DI; 636 case DN_DI: 637 case DN_DR: 638disc_reject: 639 dn_nsp_send_disc(sk, NSP_DISCINIT, 0, sk->sk_allocation); 640 case DN_NC: 641 case DN_NR: 642 case DN_RJ: 643 case DN_DIC: 644 case DN_CN: 645 case DN_DRC: 646 case DN_CI: 647 case DN_CD: 648 scp->persist_fxn = dn_destroy_timer; 649 scp->persist = dn_nsp_persist(sk); 650 break; 651 default: 652 printk(KERN_DEBUG "DECnet: dn_destroy_sock passed socket in invalid state\n"); 653 case DN_O: 654 dn_stop_slow_timer(sk); 655 656 dn_unhash_sock_bh(sk); 657 sock_put(sk); 658 659 break; 660 } 661} 662 663char *dn_addr2asc(__u16 addr, char *buf) 664{ 665 unsigned short node, area; 666 667 node = addr & 0x03ff; 668 area = addr >> 10; 669 sprintf(buf, "%hd.%hd", area, node); 670 671 return buf; 672} 673 674 675 676static int dn_create(struct net *net, struct socket *sock, int protocol, 677 int kern) 678{ 679 struct sock *sk; 680 681 if (protocol < 0 || protocol > SK_PROTOCOL_MAX) 682 return -EINVAL; 683 684 if (!net_eq(net, &init_net)) 685 return -EAFNOSUPPORT; 686 687 switch (sock->type) { 688 case SOCK_SEQPACKET: 689 if (protocol != DNPROTO_NSP) 690 return -EPROTONOSUPPORT; 691 break; 692 case SOCK_STREAM: 693 break; 694 default: 695 return -ESOCKTNOSUPPORT; 696 } 697 698 699 if ((sk = dn_alloc_sock(net, sock, GFP_KERNEL)) == NULL) 700 return -ENOBUFS; 701 702 sk->sk_protocol = protocol; 703 704 return 0; 705} 706 707 708static int 709dn_release(struct socket *sock) 710{ 711 struct sock *sk = sock->sk; 712 713 if (sk) { 714 sock_orphan(sk); 715 sock_hold(sk); 716 lock_sock(sk); 717 dn_destroy_sock(sk); 718 release_sock(sk); 719 sock_put(sk); 720 } 721 722 return 0; 723} 724 725static int dn_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 726{ 727 struct sock *sk = sock->sk; 728 struct dn_scp *scp = DN_SK(sk); 729 struct sockaddr_dn *saddr = (struct sockaddr_dn *)uaddr; 730 struct net_device *dev, *ldev; 731 int rv; 732 733 if (addr_len != sizeof(struct sockaddr_dn)) 734 return -EINVAL; 735 736 if (saddr->sdn_family != AF_DECnet) 737 return -EINVAL; 738 739 if (le16_to_cpu(saddr->sdn_nodeaddrl) && (le16_to_cpu(saddr->sdn_nodeaddrl) != 2)) 740 return -EINVAL; 741 742 if (le16_to_cpu(saddr->sdn_objnamel) > DN_MAXOBJL) 743 return -EINVAL; 744 745 if (saddr->sdn_flags & ~SDF_WILD) 746 return -EINVAL; 747 748 if (!capable(CAP_NET_BIND_SERVICE) && (saddr->sdn_objnum || 749 (saddr->sdn_flags & SDF_WILD))) 750 return -EACCES; 751 752 if (!(saddr->sdn_flags & SDF_WILD)) { 753 if (le16_to_cpu(saddr->sdn_nodeaddrl)) { 754 rcu_read_lock(); 755 ldev = NULL; 756 for_each_netdev_rcu(&init_net, dev) { 757 if (!dev->dn_ptr) 758 continue; 759 if (dn_dev_islocal(dev, dn_saddr2dn(saddr))) { 760 ldev = dev; 761 break; 762 } 763 } 764 rcu_read_unlock(); 765 if (ldev == NULL) 766 return -EADDRNOTAVAIL; 767 } 768 } 769 770 rv = -EINVAL; 771 lock_sock(sk); 772 if (sock_flag(sk, SOCK_ZAPPED)) { 773 memcpy(&scp->addr, saddr, addr_len); 774 sock_reset_flag(sk, SOCK_ZAPPED); 775 776 rv = dn_hash_sock(sk); 777 if (rv) 778 sock_set_flag(sk, SOCK_ZAPPED); 779 } 780 release_sock(sk); 781 782 return rv; 783} 784 785 786static int dn_auto_bind(struct socket *sock) 787{ 788 struct sock *sk = sock->sk; 789 struct dn_scp *scp = DN_SK(sk); 790 int rv; 791 792 sock_reset_flag(sk, SOCK_ZAPPED); 793 794 scp->addr.sdn_flags = 0; 795 scp->addr.sdn_objnum = 0; 796 797 /* 798 * This stuff is to keep compatibility with Eduardo's 799 * patch. I hope I can dispense with it shortly... 800 */ 801 if ((scp->accessdata.acc_accl != 0) && 802 (scp->accessdata.acc_accl <= 12)) { 803 804 scp->addr.sdn_objnamel = cpu_to_le16(scp->accessdata.acc_accl); 805 memcpy(scp->addr.sdn_objname, scp->accessdata.acc_acc, le16_to_cpu(scp->addr.sdn_objnamel)); 806 807 scp->accessdata.acc_accl = 0; 808 memset(scp->accessdata.acc_acc, 0, 40); 809 } 810 /* End of compatibility stuff */ 811 812 scp->addr.sdn_add.a_len = cpu_to_le16(2); 813 rv = dn_dev_bind_default((__le16 *)scp->addr.sdn_add.a_addr); 814 if (rv == 0) { 815 rv = dn_hash_sock(sk); 816 if (rv) 817 sock_set_flag(sk, SOCK_ZAPPED); 818 } 819 820 return rv; 821} 822 823static int dn_confirm_accept(struct sock *sk, long *timeo, gfp_t allocation) 824{ 825 struct dn_scp *scp = DN_SK(sk); 826 DEFINE_WAIT(wait); 827 int err; 828 829 if (scp->state != DN_CR) 830 return -EINVAL; 831 832 scp->state = DN_CC; 833 scp->segsize_loc = dst_metric_advmss(__sk_dst_get(sk)); 834 dn_send_conn_conf(sk, allocation); 835 836 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 837 for(;;) { 838 release_sock(sk); 839 if (scp->state == DN_CC) 840 *timeo = schedule_timeout(*timeo); 841 lock_sock(sk); 842 err = 0; 843 if (scp->state == DN_RUN) 844 break; 845 err = sock_error(sk); 846 if (err) 847 break; 848 err = sock_intr_errno(*timeo); 849 if (signal_pending(current)) 850 break; 851 err = -EAGAIN; 852 if (!*timeo) 853 break; 854 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 855 } 856 finish_wait(sk_sleep(sk), &wait); 857 if (err == 0) { 858 sk->sk_socket->state = SS_CONNECTED; 859 } else if (scp->state != DN_CC) { 860 sk->sk_socket->state = SS_UNCONNECTED; 861 } 862 return err; 863} 864 865static int dn_wait_run(struct sock *sk, long *timeo) 866{ 867 struct dn_scp *scp = DN_SK(sk); 868 DEFINE_WAIT(wait); 869 int err = 0; 870 871 if (scp->state == DN_RUN) 872 goto out; 873 874 if (!*timeo) 875 return -EALREADY; 876 877 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 878 for(;;) { 879 release_sock(sk); 880 if (scp->state == DN_CI || scp->state == DN_CC) 881 *timeo = schedule_timeout(*timeo); 882 lock_sock(sk); 883 err = 0; 884 if (scp->state == DN_RUN) 885 break; 886 err = sock_error(sk); 887 if (err) 888 break; 889 err = sock_intr_errno(*timeo); 890 if (signal_pending(current)) 891 break; 892 err = -ETIMEDOUT; 893 if (!*timeo) 894 break; 895 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 896 } 897 finish_wait(sk_sleep(sk), &wait); 898out: 899 if (err == 0) { 900 sk->sk_socket->state = SS_CONNECTED; 901 } else if (scp->state != DN_CI && scp->state != DN_CC) { 902 sk->sk_socket->state = SS_UNCONNECTED; 903 } 904 return err; 905} 906 907static int __dn_connect(struct sock *sk, struct sockaddr_dn *addr, int addrlen, long *timeo, int flags) 908{ 909 struct socket *sock = sk->sk_socket; 910 struct dn_scp *scp = DN_SK(sk); 911 int err = -EISCONN; 912 struct flowidn fld; 913 struct dst_entry *dst; 914 915 if (sock->state == SS_CONNECTED) 916 goto out; 917 918 if (sock->state == SS_CONNECTING) { 919 err = 0; 920 if (scp->state == DN_RUN) { 921 sock->state = SS_CONNECTED; 922 goto out; 923 } 924 err = -ECONNREFUSED; 925 if (scp->state != DN_CI && scp->state != DN_CC) { 926 sock->state = SS_UNCONNECTED; 927 goto out; 928 } 929 return dn_wait_run(sk, timeo); 930 } 931 932 err = -EINVAL; 933 if (scp->state != DN_O) 934 goto out; 935 936 if (addr == NULL || addrlen != sizeof(struct sockaddr_dn)) 937 goto out; 938 if (addr->sdn_family != AF_DECnet) 939 goto out; 940 if (addr->sdn_flags & SDF_WILD) 941 goto out; 942 943 if (sock_flag(sk, SOCK_ZAPPED)) { 944 err = dn_auto_bind(sk->sk_socket); 945 if (err) 946 goto out; 947 } 948 949 memcpy(&scp->peer, addr, sizeof(struct sockaddr_dn)); 950 951 err = -EHOSTUNREACH; 952 memset(&fld, 0, sizeof(fld)); 953 fld.flowidn_oif = sk->sk_bound_dev_if; 954 fld.daddr = dn_saddr2dn(&scp->peer); 955 fld.saddr = dn_saddr2dn(&scp->addr); 956 dn_sk_ports_copy(&fld, scp); 957 fld.flowidn_proto = DNPROTO_NSP; 958 if (dn_route_output_sock(&sk->sk_dst_cache, &fld, sk, flags) < 0) 959 goto out; 960 dst = __sk_dst_get(sk); 961 sk->sk_route_caps = dst->dev->features; 962 sock->state = SS_CONNECTING; 963 scp->state = DN_CI; 964 scp->segsize_loc = dst_metric_advmss(dst); 965 966 dn_nsp_send_conninit(sk, NSP_CI); 967 err = -EINPROGRESS; 968 if (*timeo) { 969 err = dn_wait_run(sk, timeo); 970 } 971out: 972 return err; 973} 974 975static int dn_connect(struct socket *sock, struct sockaddr *uaddr, int addrlen, int flags) 976{ 977 struct sockaddr_dn *addr = (struct sockaddr_dn *)uaddr; 978 struct sock *sk = sock->sk; 979 int err; 980 long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK); 981 982 lock_sock(sk); 983 err = __dn_connect(sk, addr, addrlen, &timeo, 0); 984 release_sock(sk); 985 986 return err; 987} 988 989static inline int dn_check_state(struct sock *sk, struct sockaddr_dn *addr, int addrlen, long *timeo, int flags) 990{ 991 struct dn_scp *scp = DN_SK(sk); 992 993 switch (scp->state) { 994 case DN_RUN: 995 return 0; 996 case DN_CR: 997 return dn_confirm_accept(sk, timeo, sk->sk_allocation); 998 case DN_CI: 999 case DN_CC: 1000 return dn_wait_run(sk, timeo); 1001 case DN_O: 1002 return __dn_connect(sk, addr, addrlen, timeo, flags); 1003 } 1004 1005 return -EINVAL; 1006} 1007 1008 1009static void dn_access_copy(struct sk_buff *skb, struct accessdata_dn *acc) 1010{ 1011 unsigned char *ptr = skb->data; 1012 1013 acc->acc_userl = *ptr++; 1014 memcpy(&acc->acc_user, ptr, acc->acc_userl); 1015 ptr += acc->acc_userl; 1016 1017 acc->acc_passl = *ptr++; 1018 memcpy(&acc->acc_pass, ptr, acc->acc_passl); 1019 ptr += acc->acc_passl; 1020 1021 acc->acc_accl = *ptr++; 1022 memcpy(&acc->acc_acc, ptr, acc->acc_accl); 1023 1024 skb_pull(skb, acc->acc_accl + acc->acc_passl + acc->acc_userl + 3); 1025 1026} 1027 1028static void dn_user_copy(struct sk_buff *skb, struct optdata_dn *opt) 1029{ 1030 unsigned char *ptr = skb->data; 1031 u16 len = *ptr++; /* yes, it's 8bit on the wire */ 1032 1033 BUG_ON(len > 16); /* we've checked the contents earlier */ 1034 opt->opt_optl = cpu_to_le16(len); 1035 opt->opt_status = 0; 1036 memcpy(opt->opt_data, ptr, len); 1037 skb_pull(skb, len + 1); 1038} 1039 1040static struct sk_buff *dn_wait_for_connect(struct sock *sk, long *timeo) 1041{ 1042 DEFINE_WAIT(wait); 1043 struct sk_buff *skb = NULL; 1044 int err = 0; 1045 1046 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 1047 for(;;) { 1048 release_sock(sk); 1049 skb = skb_dequeue(&sk->sk_receive_queue); 1050 if (skb == NULL) { 1051 *timeo = schedule_timeout(*timeo); 1052 skb = skb_dequeue(&sk->sk_receive_queue); 1053 } 1054 lock_sock(sk); 1055 if (skb != NULL) 1056 break; 1057 err = -EINVAL; 1058 if (sk->sk_state != TCP_LISTEN) 1059 break; 1060 err = sock_intr_errno(*timeo); 1061 if (signal_pending(current)) 1062 break; 1063 err = -EAGAIN; 1064 if (!*timeo) 1065 break; 1066 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 1067 } 1068 finish_wait(sk_sleep(sk), &wait); 1069 1070 return skb == NULL ? ERR_PTR(err) : skb; 1071} 1072 1073static int dn_accept(struct socket *sock, struct socket *newsock, int flags) 1074{ 1075 struct sock *sk = sock->sk, *newsk; 1076 struct sk_buff *skb = NULL; 1077 struct dn_skb_cb *cb; 1078 unsigned char menuver; 1079 int err = 0; 1080 unsigned char type; 1081 long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 1082 struct dst_entry *dst; 1083 1084 lock_sock(sk); 1085 1086 if (sk->sk_state != TCP_LISTEN || DN_SK(sk)->state != DN_O) { 1087 release_sock(sk); 1088 return -EINVAL; 1089 } 1090 1091 skb = skb_dequeue(&sk->sk_receive_queue); 1092 if (skb == NULL) { 1093 skb = dn_wait_for_connect(sk, &timeo); 1094 if (IS_ERR(skb)) { 1095 release_sock(sk); 1096 return PTR_ERR(skb); 1097 } 1098 } 1099 1100 cb = DN_SKB_CB(skb); 1101 sk->sk_ack_backlog--; 1102 newsk = dn_alloc_sock(sock_net(sk), newsock, sk->sk_allocation); 1103 if (newsk == NULL) { 1104 release_sock(sk); 1105 kfree_skb(skb); 1106 return -ENOBUFS; 1107 } 1108 release_sock(sk); 1109 1110 dst = skb_dst(skb); 1111 sk_dst_set(newsk, dst); 1112 skb_dst_set(skb, NULL); 1113 1114 DN_SK(newsk)->state = DN_CR; 1115 DN_SK(newsk)->addrrem = cb->src_port; 1116 DN_SK(newsk)->services_rem = cb->services; 1117 DN_SK(newsk)->info_rem = cb->info; 1118 DN_SK(newsk)->segsize_rem = cb->segsize; 1119 DN_SK(newsk)->accept_mode = DN_SK(sk)->accept_mode; 1120 1121 if (DN_SK(newsk)->segsize_rem < 230) 1122 DN_SK(newsk)->segsize_rem = 230; 1123 1124 if ((DN_SK(newsk)->services_rem & NSP_FC_MASK) == NSP_FC_NONE) 1125 DN_SK(newsk)->max_window = decnet_no_fc_max_cwnd; 1126 1127 newsk->sk_state = TCP_LISTEN; 1128 memcpy(&(DN_SK(newsk)->addr), &(DN_SK(sk)->addr), sizeof(struct sockaddr_dn)); 1129 1130 /* 1131 * If we are listening on a wild socket, we don't want 1132 * the newly created socket on the wrong hash queue. 1133 */ 1134 DN_SK(newsk)->addr.sdn_flags &= ~SDF_WILD; 1135 1136 skb_pull(skb, dn_username2sockaddr(skb->data, skb->len, &(DN_SK(newsk)->addr), &type)); 1137 skb_pull(skb, dn_username2sockaddr(skb->data, skb->len, &(DN_SK(newsk)->peer), &type)); 1138 *(__le16 *)(DN_SK(newsk)->peer.sdn_add.a_addr) = cb->src; 1139 *(__le16 *)(DN_SK(newsk)->addr.sdn_add.a_addr) = cb->dst; 1140 1141 menuver = *skb->data; 1142 skb_pull(skb, 1); 1143 1144 if (menuver & DN_MENUVER_ACC) 1145 dn_access_copy(skb, &(DN_SK(newsk)->accessdata)); 1146 1147 if (menuver & DN_MENUVER_USR) 1148 dn_user_copy(skb, &(DN_SK(newsk)->conndata_in)); 1149 1150 if (menuver & DN_MENUVER_PRX) 1151 DN_SK(newsk)->peer.sdn_flags |= SDF_PROXY; 1152 1153 if (menuver & DN_MENUVER_UIC) 1154 DN_SK(newsk)->peer.sdn_flags |= SDF_UICPROXY; 1155 1156 kfree_skb(skb); 1157 1158 memcpy(&(DN_SK(newsk)->conndata_out), &(DN_SK(sk)->conndata_out), 1159 sizeof(struct optdata_dn)); 1160 memcpy(&(DN_SK(newsk)->discdata_out), &(DN_SK(sk)->discdata_out), 1161 sizeof(struct optdata_dn)); 1162 1163 lock_sock(newsk); 1164 err = dn_hash_sock(newsk); 1165 if (err == 0) { 1166 sock_reset_flag(newsk, SOCK_ZAPPED); 1167 dn_send_conn_ack(newsk); 1168 1169 /* 1170 * Here we use sk->sk_allocation since although the conn conf is 1171 * for the newsk, the context is the old socket. 1172 */ 1173 if (DN_SK(newsk)->accept_mode == ACC_IMMED) 1174 err = dn_confirm_accept(newsk, &timeo, 1175 sk->sk_allocation); 1176 } 1177 release_sock(newsk); 1178 return err; 1179} 1180 1181 1182static int dn_getname(struct socket *sock, struct sockaddr *uaddr,int *uaddr_len,int peer) 1183{ 1184 struct sockaddr_dn *sa = (struct sockaddr_dn *)uaddr; 1185 struct sock *sk = sock->sk; 1186 struct dn_scp *scp = DN_SK(sk); 1187 1188 *uaddr_len = sizeof(struct sockaddr_dn); 1189 1190 lock_sock(sk); 1191 1192 if (peer) { 1193 if ((sock->state != SS_CONNECTED && 1194 sock->state != SS_CONNECTING) && 1195 scp->accept_mode == ACC_IMMED) { 1196 release_sock(sk); 1197 return -ENOTCONN; 1198 } 1199 1200 memcpy(sa, &scp->peer, sizeof(struct sockaddr_dn)); 1201 } else { 1202 memcpy(sa, &scp->addr, sizeof(struct sockaddr_dn)); 1203 } 1204 1205 release_sock(sk); 1206 1207 return 0; 1208} 1209 1210 1211static unsigned int dn_poll(struct file *file, struct socket *sock, poll_table *wait) 1212{ 1213 struct sock *sk = sock->sk; 1214 struct dn_scp *scp = DN_SK(sk); 1215 int mask = datagram_poll(file, sock, wait); 1216 1217 if (!skb_queue_empty(&scp->other_receive_queue)) 1218 mask |= POLLRDBAND; 1219 1220 return mask; 1221} 1222 1223static int dn_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1224{ 1225 struct sock *sk = sock->sk; 1226 struct dn_scp *scp = DN_SK(sk); 1227 int err = -EOPNOTSUPP; 1228 long amount = 0; 1229 struct sk_buff *skb; 1230 int val; 1231 1232 switch(cmd) 1233 { 1234 case SIOCGIFADDR: 1235 case SIOCSIFADDR: 1236 return dn_dev_ioctl(cmd, (void __user *)arg); 1237 1238 case SIOCATMARK: 1239 lock_sock(sk); 1240 val = !skb_queue_empty(&scp->other_receive_queue); 1241 if (scp->state != DN_RUN) 1242 val = -ENOTCONN; 1243 release_sock(sk); 1244 return val; 1245 1246 case TIOCOUTQ: 1247 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk); 1248 if (amount < 0) 1249 amount = 0; 1250 err = put_user(amount, (int __user *)arg); 1251 break; 1252 1253 case TIOCINQ: 1254 lock_sock(sk); 1255 skb = skb_peek(&scp->other_receive_queue); 1256 if (skb) { 1257 amount = skb->len; 1258 } else { 1259 skb_queue_walk(&sk->sk_receive_queue, skb) 1260 amount += skb->len; 1261 } 1262 release_sock(sk); 1263 err = put_user(amount, (int __user *)arg); 1264 break; 1265 1266 default: 1267 err = -ENOIOCTLCMD; 1268 break; 1269 } 1270 1271 return err; 1272} 1273 1274static int dn_listen(struct socket *sock, int backlog) 1275{ 1276 struct sock *sk = sock->sk; 1277 int err = -EINVAL; 1278 1279 lock_sock(sk); 1280 1281 if (sock_flag(sk, SOCK_ZAPPED)) 1282 goto out; 1283 1284 if ((DN_SK(sk)->state != DN_O) || (sk->sk_state == TCP_LISTEN)) 1285 goto out; 1286 1287 sk->sk_max_ack_backlog = backlog; 1288 sk->sk_ack_backlog = 0; 1289 sk->sk_state = TCP_LISTEN; 1290 err = 0; 1291 dn_rehash_sock(sk); 1292 1293out: 1294 release_sock(sk); 1295 1296 return err; 1297} 1298 1299 1300static int dn_shutdown(struct socket *sock, int how) 1301{ 1302 struct sock *sk = sock->sk; 1303 struct dn_scp *scp = DN_SK(sk); 1304 int err = -ENOTCONN; 1305 1306 lock_sock(sk); 1307 1308 if (sock->state == SS_UNCONNECTED) 1309 goto out; 1310 1311 err = 0; 1312 if (sock->state == SS_DISCONNECTING) 1313 goto out; 1314 1315 err = -EINVAL; 1316 if (scp->state == DN_O) 1317 goto out; 1318 1319 if (how != SHUT_RDWR) 1320 goto out; 1321 1322 sk->sk_shutdown = SHUTDOWN_MASK; 1323 dn_destroy_sock(sk); 1324 err = 0; 1325 1326out: 1327 release_sock(sk); 1328 1329 return err; 1330} 1331 1332static int dn_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen) 1333{ 1334 struct sock *sk = sock->sk; 1335 int err; 1336 1337 lock_sock(sk); 1338 err = __dn_setsockopt(sock, level, optname, optval, optlen, 0); 1339 release_sock(sk); 1340 1341 return err; 1342} 1343 1344static int __dn_setsockopt(struct socket *sock, int level,int optname, char __user *optval, unsigned int optlen, int flags) 1345{ 1346 struct sock *sk = sock->sk; 1347 struct dn_scp *scp = DN_SK(sk); 1348 long timeo; 1349 union { 1350 struct optdata_dn opt; 1351 struct accessdata_dn acc; 1352 int mode; 1353 unsigned long win; 1354 int val; 1355 unsigned char services; 1356 unsigned char info; 1357 } u; 1358 int err; 1359 1360 if (optlen && !optval) 1361 return -EINVAL; 1362 1363 if (optlen > sizeof(u)) 1364 return -EINVAL; 1365 1366 if (copy_from_user(&u, optval, optlen)) 1367 return -EFAULT; 1368 1369 switch (optname) { 1370 case DSO_CONDATA: 1371 if (sock->state == SS_CONNECTED) 1372 return -EISCONN; 1373 if ((scp->state != DN_O) && (scp->state != DN_CR)) 1374 return -EINVAL; 1375 1376 if (optlen != sizeof(struct optdata_dn)) 1377 return -EINVAL; 1378 1379 if (le16_to_cpu(u.opt.opt_optl) > 16) 1380 return -EINVAL; 1381 1382 memcpy(&scp->conndata_out, &u.opt, optlen); 1383 break; 1384 1385 case DSO_DISDATA: 1386 if (sock->state != SS_CONNECTED && 1387 scp->accept_mode == ACC_IMMED) 1388 return -ENOTCONN; 1389 1390 if (optlen != sizeof(struct optdata_dn)) 1391 return -EINVAL; 1392 1393 if (le16_to_cpu(u.opt.opt_optl) > 16) 1394 return -EINVAL; 1395 1396 memcpy(&scp->discdata_out, &u.opt, optlen); 1397 break; 1398 1399 case DSO_CONACCESS: 1400 if (sock->state == SS_CONNECTED) 1401 return -EISCONN; 1402 if (scp->state != DN_O) 1403 return -EINVAL; 1404 1405 if (optlen != sizeof(struct accessdata_dn)) 1406 return -EINVAL; 1407 1408 if ((u.acc.acc_accl > DN_MAXACCL) || 1409 (u.acc.acc_passl > DN_MAXACCL) || 1410 (u.acc.acc_userl > DN_MAXACCL)) 1411 return -EINVAL; 1412 1413 memcpy(&scp->accessdata, &u.acc, optlen); 1414 break; 1415 1416 case DSO_ACCEPTMODE: 1417 if (sock->state == SS_CONNECTED) 1418 return -EISCONN; 1419 if (scp->state != DN_O) 1420 return -EINVAL; 1421 1422 if (optlen != sizeof(int)) 1423 return -EINVAL; 1424 1425 if ((u.mode != ACC_IMMED) && (u.mode != ACC_DEFER)) 1426 return -EINVAL; 1427 1428 scp->accept_mode = (unsigned char)u.mode; 1429 break; 1430 1431 case DSO_CONACCEPT: 1432 if (scp->state != DN_CR) 1433 return -EINVAL; 1434 timeo = sock_rcvtimeo(sk, 0); 1435 err = dn_confirm_accept(sk, &timeo, sk->sk_allocation); 1436 return err; 1437 1438 case DSO_CONREJECT: 1439 if (scp->state != DN_CR) 1440 return -EINVAL; 1441 1442 scp->state = DN_DR; 1443 sk->sk_shutdown = SHUTDOWN_MASK; 1444 dn_nsp_send_disc(sk, 0x38, 0, sk->sk_allocation); 1445 break; 1446 1447 default: 1448#ifdef CONFIG_NETFILTER 1449 return nf_setsockopt(sk, PF_DECnet, optname, optval, optlen); 1450#endif 1451 case DSO_LINKINFO: 1452 case DSO_STREAM: 1453 case DSO_SEQPACKET: 1454 return -ENOPROTOOPT; 1455 1456 case DSO_MAXWINDOW: 1457 if (optlen != sizeof(unsigned long)) 1458 return -EINVAL; 1459 if (u.win > NSP_MAX_WINDOW) 1460 u.win = NSP_MAX_WINDOW; 1461 if (u.win == 0) 1462 return -EINVAL; 1463 scp->max_window = u.win; 1464 if (scp->snd_window > u.win) 1465 scp->snd_window = u.win; 1466 break; 1467 1468 case DSO_NODELAY: 1469 if (optlen != sizeof(int)) 1470 return -EINVAL; 1471 if (scp->nonagle == 2) 1472 return -EINVAL; 1473 scp->nonagle = (u.val == 0) ? 0 : 1; 1474 /* if (scp->nonagle == 1) { Push pending frames } */ 1475 break; 1476 1477 case DSO_CORK: 1478 if (optlen != sizeof(int)) 1479 return -EINVAL; 1480 if (scp->nonagle == 1) 1481 return -EINVAL; 1482 scp->nonagle = (u.val == 0) ? 0 : 2; 1483 /* if (scp->nonagle == 0) { Push pending frames } */ 1484 break; 1485 1486 case DSO_SERVICES: 1487 if (optlen != sizeof(unsigned char)) 1488 return -EINVAL; 1489 if ((u.services & ~NSP_FC_MASK) != 0x01) 1490 return -EINVAL; 1491 if ((u.services & NSP_FC_MASK) == NSP_FC_MASK) 1492 return -EINVAL; 1493 scp->services_loc = u.services; 1494 break; 1495 1496 case DSO_INFO: 1497 if (optlen != sizeof(unsigned char)) 1498 return -EINVAL; 1499 if (u.info & 0xfc) 1500 return -EINVAL; 1501 scp->info_loc = u.info; 1502 break; 1503 } 1504 1505 return 0; 1506} 1507 1508static int dn_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen) 1509{ 1510 struct sock *sk = sock->sk; 1511 int err; 1512 1513 lock_sock(sk); 1514 err = __dn_getsockopt(sock, level, optname, optval, optlen, 0); 1515 release_sock(sk); 1516 1517 return err; 1518} 1519 1520static int __dn_getsockopt(struct socket *sock, int level,int optname, char __user *optval,int __user *optlen, int flags) 1521{ 1522 struct sock *sk = sock->sk; 1523 struct dn_scp *scp = DN_SK(sk); 1524 struct linkinfo_dn link; 1525 unsigned int r_len; 1526 void *r_data = NULL; 1527 unsigned int val; 1528 1529 if(get_user(r_len , optlen)) 1530 return -EFAULT; 1531 1532 switch (optname) { 1533 case DSO_CONDATA: 1534 if (r_len > sizeof(struct optdata_dn)) 1535 r_len = sizeof(struct optdata_dn); 1536 r_data = &scp->conndata_in; 1537 break; 1538 1539 case DSO_DISDATA: 1540 if (r_len > sizeof(struct optdata_dn)) 1541 r_len = sizeof(struct optdata_dn); 1542 r_data = &scp->discdata_in; 1543 break; 1544 1545 case DSO_CONACCESS: 1546 if (r_len > sizeof(struct accessdata_dn)) 1547 r_len = sizeof(struct accessdata_dn); 1548 r_data = &scp->accessdata; 1549 break; 1550 1551 case DSO_ACCEPTMODE: 1552 if (r_len > sizeof(unsigned char)) 1553 r_len = sizeof(unsigned char); 1554 r_data = &scp->accept_mode; 1555 break; 1556 1557 case DSO_LINKINFO: 1558 if (r_len > sizeof(struct linkinfo_dn)) 1559 r_len = sizeof(struct linkinfo_dn); 1560 1561 memset(&link, 0, sizeof(link)); 1562 1563 switch (sock->state) { 1564 case SS_CONNECTING: 1565 link.idn_linkstate = LL_CONNECTING; 1566 break; 1567 case SS_DISCONNECTING: 1568 link.idn_linkstate = LL_DISCONNECTING; 1569 break; 1570 case SS_CONNECTED: 1571 link.idn_linkstate = LL_RUNNING; 1572 break; 1573 default: 1574 link.idn_linkstate = LL_INACTIVE; 1575 } 1576 1577 link.idn_segsize = scp->segsize_rem; 1578 r_data = &link; 1579 break; 1580 1581 default: 1582#ifdef CONFIG_NETFILTER 1583 { 1584 int ret, len; 1585 1586 if (get_user(len, optlen)) 1587 return -EFAULT; 1588 1589 ret = nf_getsockopt(sk, PF_DECnet, optname, optval, &len); 1590 if (ret >= 0) 1591 ret = put_user(len, optlen); 1592 return ret; 1593 } 1594#endif 1595 case DSO_STREAM: 1596 case DSO_SEQPACKET: 1597 case DSO_CONACCEPT: 1598 case DSO_CONREJECT: 1599 return -ENOPROTOOPT; 1600 1601 case DSO_MAXWINDOW: 1602 if (r_len > sizeof(unsigned long)) 1603 r_len = sizeof(unsigned long); 1604 r_data = &scp->max_window; 1605 break; 1606 1607 case DSO_NODELAY: 1608 if (r_len > sizeof(int)) 1609 r_len = sizeof(int); 1610 val = (scp->nonagle == 1); 1611 r_data = &val; 1612 break; 1613 1614 case DSO_CORK: 1615 if (r_len > sizeof(int)) 1616 r_len = sizeof(int); 1617 val = (scp->nonagle == 2); 1618 r_data = &val; 1619 break; 1620 1621 case DSO_SERVICES: 1622 if (r_len > sizeof(unsigned char)) 1623 r_len = sizeof(unsigned char); 1624 r_data = &scp->services_rem; 1625 break; 1626 1627 case DSO_INFO: 1628 if (r_len > sizeof(unsigned char)) 1629 r_len = sizeof(unsigned char); 1630 r_data = &scp->info_rem; 1631 break; 1632 } 1633 1634 if (r_data) { 1635 if (copy_to_user(optval, r_data, r_len)) 1636 return -EFAULT; 1637 if (put_user(r_len, optlen)) 1638 return -EFAULT; 1639 } 1640 1641 return 0; 1642} 1643 1644 1645static int dn_data_ready(struct sock *sk, struct sk_buff_head *q, int flags, int target) 1646{ 1647 struct sk_buff *skb; 1648 int len = 0; 1649 1650 if (flags & MSG_OOB) 1651 return !skb_queue_empty(q) ? 1 : 0; 1652 1653 skb_queue_walk(q, skb) { 1654 struct dn_skb_cb *cb = DN_SKB_CB(skb); 1655 len += skb->len; 1656 1657 if (cb->nsp_flags & 0x40) { 1658 /* SOCK_SEQPACKET reads to EOM */ 1659 if (sk->sk_type == SOCK_SEQPACKET) 1660 return 1; 1661 /* so does SOCK_STREAM unless WAITALL is specified */ 1662 if (!(flags & MSG_WAITALL)) 1663 return 1; 1664 } 1665 1666 /* minimum data length for read exceeded */ 1667 if (len >= target) 1668 return 1; 1669 } 1670 1671 return 0; 1672} 1673 1674 1675static int dn_recvmsg(struct socket *sock, struct msghdr *msg, size_t size, 1676 int flags) 1677{ 1678 struct sock *sk = sock->sk; 1679 struct dn_scp *scp = DN_SK(sk); 1680 struct sk_buff_head *queue = &sk->sk_receive_queue; 1681 size_t target = size > 1 ? 1 : 0; 1682 size_t copied = 0; 1683 int rv = 0; 1684 struct sk_buff *skb, *n; 1685 struct dn_skb_cb *cb = NULL; 1686 unsigned char eor = 0; 1687 long timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 1688 1689 lock_sock(sk); 1690 1691 if (sock_flag(sk, SOCK_ZAPPED)) { 1692 rv = -EADDRNOTAVAIL; 1693 goto out; 1694 } 1695 1696 if (sk->sk_shutdown & RCV_SHUTDOWN) { 1697 rv = 0; 1698 goto out; 1699 } 1700 1701 rv = dn_check_state(sk, NULL, 0, &timeo, flags); 1702 if (rv) 1703 goto out; 1704 1705 if (flags & ~(MSG_CMSG_COMPAT|MSG_PEEK|MSG_OOB|MSG_WAITALL|MSG_DONTWAIT|MSG_NOSIGNAL)) { 1706 rv = -EOPNOTSUPP; 1707 goto out; 1708 } 1709 1710 if (flags & MSG_OOB) 1711 queue = &scp->other_receive_queue; 1712 1713 if (flags & MSG_WAITALL) 1714 target = size; 1715 1716 1717 /* 1718 * See if there is data ready to read, sleep if there isn't 1719 */ 1720 for(;;) { 1721 DEFINE_WAIT(wait); 1722 1723 if (sk->sk_err) 1724 goto out; 1725 1726 if (!skb_queue_empty(&scp->other_receive_queue)) { 1727 if (!(flags & MSG_OOB)) { 1728 msg->msg_flags |= MSG_OOB; 1729 if (!scp->other_report) { 1730 scp->other_report = 1; 1731 goto out; 1732 } 1733 } 1734 } 1735 1736 if (scp->state != DN_RUN) 1737 goto out; 1738 1739 if (signal_pending(current)) { 1740 rv = sock_intr_errno(timeo); 1741 goto out; 1742 } 1743 1744 if (dn_data_ready(sk, queue, flags, target)) 1745 break; 1746 1747 if (flags & MSG_DONTWAIT) { 1748 rv = -EWOULDBLOCK; 1749 goto out; 1750 } 1751 1752 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 1753 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 1754 sk_wait_event(sk, &timeo, dn_data_ready(sk, queue, flags, target)); 1755 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 1756 finish_wait(sk_sleep(sk), &wait); 1757 } 1758 1759 skb_queue_walk_safe(queue, skb, n) { 1760 unsigned int chunk = skb->len; 1761 cb = DN_SKB_CB(skb); 1762 1763 if ((chunk + copied) > size) 1764 chunk = size - copied; 1765 1766 if (memcpy_to_msg(msg, skb->data, chunk)) { 1767 rv = -EFAULT; 1768 break; 1769 } 1770 copied += chunk; 1771 1772 if (!(flags & MSG_PEEK)) 1773 skb_pull(skb, chunk); 1774 1775 eor = cb->nsp_flags & 0x40; 1776 1777 if (skb->len == 0) { 1778 skb_unlink(skb, queue); 1779 kfree_skb(skb); 1780 /* 1781 * N.B. Don't refer to skb or cb after this point 1782 * in loop. 1783 */ 1784 if ((scp->flowloc_sw == DN_DONTSEND) && !dn_congested(sk)) { 1785 scp->flowloc_sw = DN_SEND; 1786 dn_nsp_send_link(sk, DN_SEND, 0); 1787 } 1788 } 1789 1790 if (eor) { 1791 if (sk->sk_type == SOCK_SEQPACKET) 1792 break; 1793 if (!(flags & MSG_WAITALL)) 1794 break; 1795 } 1796 1797 if (flags & MSG_OOB) 1798 break; 1799 1800 if (copied >= target) 1801 break; 1802 } 1803 1804 rv = copied; 1805 1806 1807 if (eor && (sk->sk_type == SOCK_SEQPACKET)) 1808 msg->msg_flags |= MSG_EOR; 1809 1810out: 1811 if (rv == 0) 1812 rv = (flags & MSG_PEEK) ? -sk->sk_err : sock_error(sk); 1813 1814 if ((rv >= 0) && msg->msg_name) { 1815 __sockaddr_check_size(sizeof(struct sockaddr_dn)); 1816 memcpy(msg->msg_name, &scp->peer, sizeof(struct sockaddr_dn)); 1817 msg->msg_namelen = sizeof(struct sockaddr_dn); 1818 } 1819 1820 release_sock(sk); 1821 1822 return rv; 1823} 1824 1825 1826static inline int dn_queue_too_long(struct dn_scp *scp, struct sk_buff_head *queue, int flags) 1827{ 1828 unsigned char fctype = scp->services_rem & NSP_FC_MASK; 1829 if (skb_queue_len(queue) >= scp->snd_window) 1830 return 1; 1831 if (fctype != NSP_FC_NONE) { 1832 if (flags & MSG_OOB) { 1833 if (scp->flowrem_oth == 0) 1834 return 1; 1835 } else { 1836 if (scp->flowrem_dat == 0) 1837 return 1; 1838 } 1839 } 1840 return 0; 1841} 1842 1843/* 1844 * The DECnet spec requires that the "routing layer" accepts packets which 1845 * are at least 230 bytes in size. This excludes any headers which the NSP 1846 * layer might add, so we always assume that we'll be using the maximal 1847 * length header on data packets. The variation in length is due to the 1848 * inclusion (or not) of the two 16 bit acknowledgement fields so it doesn't 1849 * make much practical difference. 1850 */ 1851unsigned int dn_mss_from_pmtu(struct net_device *dev, int mtu) 1852{ 1853 unsigned int mss = 230 - DN_MAX_NSP_DATA_HEADER; 1854 if (dev) { 1855 struct dn_dev *dn_db = rcu_dereference_raw(dev->dn_ptr); 1856 mtu -= LL_RESERVED_SPACE(dev); 1857 if (dn_db->use_long) 1858 mtu -= 21; 1859 else 1860 mtu -= 6; 1861 mtu -= DN_MAX_NSP_DATA_HEADER; 1862 } else { 1863 /* 1864 * 21 = long header, 16 = guess at MAC header length 1865 */ 1866 mtu -= (21 + DN_MAX_NSP_DATA_HEADER + 16); 1867 } 1868 if (mtu > mss) 1869 mss = mtu; 1870 return mss; 1871} 1872 1873static inline unsigned int dn_current_mss(struct sock *sk, int flags) 1874{ 1875 struct dst_entry *dst = __sk_dst_get(sk); 1876 struct dn_scp *scp = DN_SK(sk); 1877 int mss_now = min_t(int, scp->segsize_loc, scp->segsize_rem); 1878 1879 /* Other data messages are limited to 16 bytes per packet */ 1880 if (flags & MSG_OOB) 1881 return 16; 1882 1883 /* This works out the maximum size of segment we can send out */ 1884 if (dst) { 1885 u32 mtu = dst_mtu(dst); 1886 mss_now = min_t(int, dn_mss_from_pmtu(dst->dev, mtu), mss_now); 1887 } 1888 1889 return mss_now; 1890} 1891 1892/* 1893 * N.B. We get the timeout wrong here, but then we always did get it 1894 * wrong before and this is another step along the road to correcting 1895 * it. It ought to get updated each time we pass through the routine, 1896 * but in practise it probably doesn't matter too much for now. 1897 */ 1898static inline struct sk_buff *dn_alloc_send_pskb(struct sock *sk, 1899 unsigned long datalen, int noblock, 1900 int *errcode) 1901{ 1902 struct sk_buff *skb = sock_alloc_send_skb(sk, datalen, 1903 noblock, errcode); 1904 if (skb) { 1905 skb->protocol = htons(ETH_P_DNA_RT); 1906 skb->pkt_type = PACKET_OUTGOING; 1907 } 1908 return skb; 1909} 1910 1911static int dn_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) 1912{ 1913 struct sock *sk = sock->sk; 1914 struct dn_scp *scp = DN_SK(sk); 1915 size_t mss; 1916 struct sk_buff_head *queue = &scp->data_xmit_queue; 1917 int flags = msg->msg_flags; 1918 int err = 0; 1919 size_t sent = 0; 1920 int addr_len = msg->msg_namelen; 1921 DECLARE_SOCKADDR(struct sockaddr_dn *, addr, msg->msg_name); 1922 struct sk_buff *skb = NULL; 1923 struct dn_skb_cb *cb; 1924 size_t len; 1925 unsigned char fctype; 1926 long timeo; 1927 1928 if (flags & ~(MSG_TRYHARD|MSG_OOB|MSG_DONTWAIT|MSG_EOR|MSG_NOSIGNAL|MSG_MORE|MSG_CMSG_COMPAT)) 1929 return -EOPNOTSUPP; 1930 1931 if (addr_len && (addr_len != sizeof(struct sockaddr_dn))) 1932 return -EINVAL; 1933 1934 lock_sock(sk); 1935 timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT); 1936 /* 1937 * The only difference between stream sockets and sequenced packet 1938 * sockets is that the stream sockets always behave as if MSG_EOR 1939 * has been set. 1940 */ 1941 if (sock->type == SOCK_STREAM) { 1942 if (flags & MSG_EOR) { 1943 err = -EINVAL; 1944 goto out; 1945 } 1946 flags |= MSG_EOR; 1947 } 1948 1949 1950 err = dn_check_state(sk, addr, addr_len, &timeo, flags); 1951 if (err) 1952 goto out_err; 1953 1954 if (sk->sk_shutdown & SEND_SHUTDOWN) { 1955 err = -EPIPE; 1956 if (!(flags & MSG_NOSIGNAL)) 1957 send_sig(SIGPIPE, current, 0); 1958 goto out_err; 1959 } 1960 1961 if ((flags & MSG_TRYHARD) && sk->sk_dst_cache) 1962 dst_negative_advice(sk); 1963 1964 mss = scp->segsize_rem; 1965 fctype = scp->services_rem & NSP_FC_MASK; 1966 1967 mss = dn_current_mss(sk, flags); 1968 1969 if (flags & MSG_OOB) { 1970 queue = &scp->other_xmit_queue; 1971 if (size > mss) { 1972 err = -EMSGSIZE; 1973 goto out; 1974 } 1975 } 1976 1977 scp->persist_fxn = dn_nsp_xmit_timeout; 1978 1979 while(sent < size) { 1980 err = sock_error(sk); 1981 if (err) 1982 goto out; 1983 1984 if (signal_pending(current)) { 1985 err = sock_intr_errno(timeo); 1986 goto out; 1987 } 1988 1989 /* 1990 * Calculate size that we wish to send. 1991 */ 1992 len = size - sent; 1993 1994 if (len > mss) 1995 len = mss; 1996 1997 /* 1998 * Wait for queue size to go down below the window 1999 * size. 2000 */ 2001 if (dn_queue_too_long(scp, queue, flags)) { 2002 DEFINE_WAIT(wait); 2003 2004 if (flags & MSG_DONTWAIT) { 2005 err = -EWOULDBLOCK; 2006 goto out; 2007 } 2008 2009 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 2010 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 2011 sk_wait_event(sk, &timeo, 2012 !dn_queue_too_long(scp, queue, flags)); 2013 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 2014 finish_wait(sk_sleep(sk), &wait); 2015 continue; 2016 } 2017 2018 /* 2019 * Get a suitably sized skb. 2020 * 64 is a bit of a hack really, but its larger than any 2021 * link-layer headers and has served us well as a good 2022 * guess as to their real length. 2023 */ 2024 skb = dn_alloc_send_pskb(sk, len + 64 + DN_MAX_NSP_DATA_HEADER, 2025 flags & MSG_DONTWAIT, &err); 2026 2027 if (err) 2028 break; 2029 2030 if (!skb) 2031 continue; 2032 2033 cb = DN_SKB_CB(skb); 2034 2035 skb_reserve(skb, 64 + DN_MAX_NSP_DATA_HEADER); 2036 2037 if (memcpy_from_msg(skb_put(skb, len), msg, len)) { 2038 err = -EFAULT; 2039 goto out; 2040 } 2041 2042 if (flags & MSG_OOB) { 2043 cb->nsp_flags = 0x30; 2044 if (fctype != NSP_FC_NONE) 2045 scp->flowrem_oth--; 2046 } else { 2047 cb->nsp_flags = 0x00; 2048 if (scp->seg_total == 0) 2049 cb->nsp_flags |= 0x20; 2050 2051 scp->seg_total += len; 2052 2053 if (((sent + len) == size) && (flags & MSG_EOR)) { 2054 cb->nsp_flags |= 0x40; 2055 scp->seg_total = 0; 2056 if (fctype == NSP_FC_SCMC) 2057 scp->flowrem_dat--; 2058 } 2059 if (fctype == NSP_FC_SRC) 2060 scp->flowrem_dat--; 2061 } 2062 2063 sent += len; 2064 dn_nsp_queue_xmit(sk, skb, sk->sk_allocation, flags & MSG_OOB); 2065 skb = NULL; 2066 2067 scp->persist = dn_nsp_persist(sk); 2068 2069 } 2070out: 2071 2072 kfree_skb(skb); 2073 2074 release_sock(sk); 2075 2076 return sent ? sent : err; 2077 2078out_err: 2079 err = sk_stream_error(sk, flags, err); 2080 release_sock(sk); 2081 return err; 2082} 2083 2084static int dn_device_event(struct notifier_block *this, unsigned long event, 2085 void *ptr) 2086{ 2087 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 2088 2089 if (!net_eq(dev_net(dev), &init_net)) 2090 return NOTIFY_DONE; 2091 2092 switch (event) { 2093 case NETDEV_UP: 2094 dn_dev_up(dev); 2095 break; 2096 case NETDEV_DOWN: 2097 dn_dev_down(dev); 2098 break; 2099 default: 2100 break; 2101 } 2102 2103 return NOTIFY_DONE; 2104} 2105 2106static struct notifier_block dn_dev_notifier = { 2107 .notifier_call = dn_device_event, 2108}; 2109 2110static struct packet_type dn_dix_packet_type __read_mostly = { 2111 .type = cpu_to_be16(ETH_P_DNA_RT), 2112 .func = dn_route_rcv, 2113}; 2114 2115#ifdef CONFIG_PROC_FS 2116struct dn_iter_state { 2117 int bucket; 2118}; 2119 2120static struct sock *dn_socket_get_first(struct seq_file *seq) 2121{ 2122 struct dn_iter_state *state = seq->private; 2123 struct sock *n = NULL; 2124 2125 for(state->bucket = 0; 2126 state->bucket < DN_SK_HASH_SIZE; 2127 ++state->bucket) { 2128 n = sk_head(&dn_sk_hash[state->bucket]); 2129 if (n) 2130 break; 2131 } 2132 2133 return n; 2134} 2135 2136static struct sock *dn_socket_get_next(struct seq_file *seq, 2137 struct sock *n) 2138{ 2139 struct dn_iter_state *state = seq->private; 2140 2141 n = sk_next(n); 2142try_again: 2143 if (n) 2144 goto out; 2145 if (++state->bucket >= DN_SK_HASH_SIZE) 2146 goto out; 2147 n = sk_head(&dn_sk_hash[state->bucket]); 2148 goto try_again; 2149out: 2150 return n; 2151} 2152 2153static struct sock *socket_get_idx(struct seq_file *seq, loff_t *pos) 2154{ 2155 struct sock *sk = dn_socket_get_first(seq); 2156 2157 if (sk) { 2158 while(*pos && (sk = dn_socket_get_next(seq, sk))) 2159 --*pos; 2160 } 2161 return *pos ? NULL : sk; 2162} 2163 2164static void *dn_socket_get_idx(struct seq_file *seq, loff_t pos) 2165{ 2166 void *rc; 2167 read_lock_bh(&dn_hash_lock); 2168 rc = socket_get_idx(seq, &pos); 2169 if (!rc) { 2170 read_unlock_bh(&dn_hash_lock); 2171 } 2172 return rc; 2173} 2174 2175static void *dn_socket_seq_start(struct seq_file *seq, loff_t *pos) 2176{ 2177 return *pos ? dn_socket_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 2178} 2179 2180static void *dn_socket_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2181{ 2182 void *rc; 2183 2184 if (v == SEQ_START_TOKEN) { 2185 rc = dn_socket_get_idx(seq, 0); 2186 goto out; 2187 } 2188 2189 rc = dn_socket_get_next(seq, v); 2190 if (rc) 2191 goto out; 2192 read_unlock_bh(&dn_hash_lock); 2193out: 2194 ++*pos; 2195 return rc; 2196} 2197 2198static void dn_socket_seq_stop(struct seq_file *seq, void *v) 2199{ 2200 if (v && v != SEQ_START_TOKEN) 2201 read_unlock_bh(&dn_hash_lock); 2202} 2203 2204#define IS_NOT_PRINTABLE(x) ((x) < 32 || (x) > 126) 2205 2206static void dn_printable_object(struct sockaddr_dn *dn, unsigned char *buf) 2207{ 2208 int i; 2209 2210 switch (le16_to_cpu(dn->sdn_objnamel)) { 2211 case 0: 2212 sprintf(buf, "%d", dn->sdn_objnum); 2213 break; 2214 default: 2215 for (i = 0; i < le16_to_cpu(dn->sdn_objnamel); i++) { 2216 buf[i] = dn->sdn_objname[i]; 2217 if (IS_NOT_PRINTABLE(buf[i])) 2218 buf[i] = '.'; 2219 } 2220 buf[i] = 0; 2221 } 2222} 2223 2224static char *dn_state2asc(unsigned char state) 2225{ 2226 switch (state) { 2227 case DN_O: 2228 return "OPEN"; 2229 case DN_CR: 2230 return " CR"; 2231 case DN_DR: 2232 return " DR"; 2233 case DN_DRC: 2234 return " DRC"; 2235 case DN_CC: 2236 return " CC"; 2237 case DN_CI: 2238 return " CI"; 2239 case DN_NR: 2240 return " NR"; 2241 case DN_NC: 2242 return " NC"; 2243 case DN_CD: 2244 return " CD"; 2245 case DN_RJ: 2246 return " RJ"; 2247 case DN_RUN: 2248 return " RUN"; 2249 case DN_DI: 2250 return " DI"; 2251 case DN_DIC: 2252 return " DIC"; 2253 case DN_DN: 2254 return " DN"; 2255 case DN_CL: 2256 return " CL"; 2257 case DN_CN: 2258 return " CN"; 2259 } 2260 2261 return "????"; 2262} 2263 2264static inline void dn_socket_format_entry(struct seq_file *seq, struct sock *sk) 2265{ 2266 struct dn_scp *scp = DN_SK(sk); 2267 char buf1[DN_ASCBUF_LEN]; 2268 char buf2[DN_ASCBUF_LEN]; 2269 char local_object[DN_MAXOBJL+3]; 2270 char remote_object[DN_MAXOBJL+3]; 2271 2272 dn_printable_object(&scp->addr, local_object); 2273 dn_printable_object(&scp->peer, remote_object); 2274 2275 seq_printf(seq, 2276 "%6s/%04X %04d:%04d %04d:%04d %01d %-16s " 2277 "%6s/%04X %04d:%04d %04d:%04d %01d %-16s %4s %s\n", 2278 dn_addr2asc(le16_to_cpu(dn_saddr2dn(&scp->addr)), buf1), 2279 scp->addrloc, 2280 scp->numdat, 2281 scp->numoth, 2282 scp->ackxmt_dat, 2283 scp->ackxmt_oth, 2284 scp->flowloc_sw, 2285 local_object, 2286 dn_addr2asc(le16_to_cpu(dn_saddr2dn(&scp->peer)), buf2), 2287 scp->addrrem, 2288 scp->numdat_rcv, 2289 scp->numoth_rcv, 2290 scp->ackrcv_dat, 2291 scp->ackrcv_oth, 2292 scp->flowrem_sw, 2293 remote_object, 2294 dn_state2asc(scp->state), 2295 ((scp->accept_mode == ACC_IMMED) ? "IMMED" : "DEFER")); 2296} 2297 2298static int dn_socket_seq_show(struct seq_file *seq, void *v) 2299{ 2300 if (v == SEQ_START_TOKEN) { 2301 seq_puts(seq, "Local Remote\n"); 2302 } else { 2303 dn_socket_format_entry(seq, v); 2304 } 2305 return 0; 2306} 2307 2308static const struct seq_operations dn_socket_seq_ops = { 2309 .start = dn_socket_seq_start, 2310 .next = dn_socket_seq_next, 2311 .stop = dn_socket_seq_stop, 2312 .show = dn_socket_seq_show, 2313}; 2314 2315static int dn_socket_seq_open(struct inode *inode, struct file *file) 2316{ 2317 return seq_open_private(file, &dn_socket_seq_ops, 2318 sizeof(struct dn_iter_state)); 2319} 2320 2321static const struct file_operations dn_socket_seq_fops = { 2322 .owner = THIS_MODULE, 2323 .open = dn_socket_seq_open, 2324 .read = seq_read, 2325 .llseek = seq_lseek, 2326 .release = seq_release_private, 2327}; 2328#endif 2329 2330static const struct net_proto_family dn_family_ops = { 2331 .family = AF_DECnet, 2332 .create = dn_create, 2333 .owner = THIS_MODULE, 2334}; 2335 2336static const struct proto_ops dn_proto_ops = { 2337 .family = AF_DECnet, 2338 .owner = THIS_MODULE, 2339 .release = dn_release, 2340 .bind = dn_bind, 2341 .connect = dn_connect, 2342 .socketpair = sock_no_socketpair, 2343 .accept = dn_accept, 2344 .getname = dn_getname, 2345 .poll = dn_poll, 2346 .ioctl = dn_ioctl, 2347 .listen = dn_listen, 2348 .shutdown = dn_shutdown, 2349 .setsockopt = dn_setsockopt, 2350 .getsockopt = dn_getsockopt, 2351 .sendmsg = dn_sendmsg, 2352 .recvmsg = dn_recvmsg, 2353 .mmap = sock_no_mmap, 2354 .sendpage = sock_no_sendpage, 2355}; 2356 2357MODULE_DESCRIPTION("The Linux DECnet Network Protocol"); 2358MODULE_AUTHOR("Linux DECnet Project Team"); 2359MODULE_LICENSE("GPL"); 2360MODULE_ALIAS_NETPROTO(PF_DECnet); 2361 2362static char banner[] __initdata = KERN_INFO "NET4: DECnet for Linux: V.2.5.68s (C) 1995-2003 Linux DECnet Project Team\n"; 2363 2364static int __init decnet_init(void) 2365{ 2366 int rc; 2367 2368 printk(banner); 2369 2370 rc = proto_register(&dn_proto, 1); 2371 if (rc != 0) 2372 goto out; 2373 2374 dn_neigh_init(); 2375 dn_dev_init(); 2376 dn_route_init(); 2377 dn_fib_init(); 2378 2379 sock_register(&dn_family_ops); 2380 dev_add_pack(&dn_dix_packet_type); 2381 register_netdevice_notifier(&dn_dev_notifier); 2382 2383 proc_create("decnet", S_IRUGO, init_net.proc_net, &dn_socket_seq_fops); 2384 dn_register_sysctl(); 2385out: 2386 return rc; 2387 2388} 2389module_init(decnet_init); 2390 2391/* 2392 * Prevent DECnet module unloading until its fixed properly. 2393 * Requires an audit of the code to check for memory leaks and 2394 * initialisation problems etc. 2395 */ 2396#if 0 2397static void __exit decnet_exit(void) 2398{ 2399 sock_unregister(AF_DECnet); 2400 rtnl_unregister_all(PF_DECnet); 2401 dev_remove_pack(&dn_dix_packet_type); 2402 2403 dn_unregister_sysctl(); 2404 2405 unregister_netdevice_notifier(&dn_dev_notifier); 2406 2407 dn_route_cleanup(); 2408 dn_dev_cleanup(); 2409 dn_neigh_cleanup(); 2410 dn_fib_cleanup(); 2411 2412 remove_proc_entry("decnet", init_net.proc_net); 2413 2414 proto_unregister(&dn_proto); 2415 2416 rcu_barrier_bh(); /* Wait for completion of call_rcu_bh()'s */ 2417} 2418module_exit(decnet_exit); 2419#endif 2420