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