1 /* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * PF_INET protocol family socket handler. 7 * 8 * Version: $Id: af_inet.c,v 1.137 2002/02/01 22:01:03 davem Exp $ 9 * 10 * Authors: Ross Biro 11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 12 * Florian La Roche, <flla@stud.uni-sb.de> 13 * Alan Cox, <A.Cox@swansea.ac.uk> 14 * 15 * Changes (see also sock.c) 16 * 17 * piggy, 18 * Karl Knutson : Socket protocol table 19 * A.N.Kuznetsov : Socket death error in accept(). 20 * John Richardson : Fix non blocking error in connect() 21 * so sockets that fail to connect 22 * don't return -EINPROGRESS. 23 * Alan Cox : Asynchronous I/O support 24 * Alan Cox : Keep correct socket pointer on sock 25 * structures 26 * when accept() ed 27 * Alan Cox : Semantics of SO_LINGER aren't state 28 * moved to close when you look carefully. 29 * With this fixed and the accept bug fixed 30 * some RPC stuff seems happier. 31 * Niibe Yutaka : 4.4BSD style write async I/O 32 * Alan Cox, 33 * Tony Gale : Fixed reuse semantics. 34 * Alan Cox : bind() shouldn't abort existing but dead 35 * sockets. Stops FTP netin:.. I hope. 36 * Alan Cox : bind() works correctly for RAW sockets. 37 * Note that FreeBSD at least was broken 38 * in this respect so be careful with 39 * compatibility tests... 40 * Alan Cox : routing cache support 41 * Alan Cox : memzero the socket structure for 42 * compactness. 43 * Matt Day : nonblock connect error handler 44 * Alan Cox : Allow large numbers of pending sockets 45 * (eg for big web sites), but only if 46 * specifically application requested. 47 * Alan Cox : New buffering throughout IP. Used 48 * dumbly. 49 * Alan Cox : New buffering now used smartly. 50 * Alan Cox : BSD rather than common sense 51 * interpretation of listen. 52 * Germano Caronni : Assorted small races. 53 * Alan Cox : sendmsg/recvmsg basic support. 54 * Alan Cox : Only sendmsg/recvmsg now supported. 55 * Alan Cox : Locked down bind (see security list). 56 * Alan Cox : Loosened bind a little. 57 * Mike McLagan : ADD/DEL DLCI Ioctls 58 * Willy Konynenberg : Transparent proxying support. 59 * David S. Miller : New socket lookup architecture. 60 * Some other random speedups. 61 * Cyrus Durgin : Cleaned up file for kmod hacks. 62 * Andi Kleen : Fix inet_stream_connect TCP race. 63 * 64 * This program is free software; you can redistribute it and/or 65 * modify it under the terms of the GNU General Public License 66 * as published by the Free Software Foundation; either version 67 * 2 of the License, or (at your option) any later version. 68 */ 69 70 #include <linux/config.h> 71 #include <linux/errno.h> 72 #include <linux/types.h> 73 #include <linux/socket.h> 74 #include <linux/in.h> 75 #include <linux/kernel.h> 76 #include <linux/module.h> 77 #include <linux/sched.h> 78 #include <linux/timer.h> 79 #include <linux/string.h> 80 #include <linux/sockios.h> 81 #include <linux/net.h> 82 #include <linux/fcntl.h> 83 #include <linux/mm.h> 84 #include <linux/interrupt.h> 85 #include <linux/stat.h> 86 #include <linux/init.h> 87 #include <linux/poll.h> 88 #include <linux/netfilter_ipv4.h> 89 90 #include <asm/uaccess.h> 91 #include <asm/system.h> 92 93 #include <linux/smp_lock.h> 94 #include <linux/inet.h> 95 #include <linux/igmp.h> 96 #include <linux/netdevice.h> 97 #include <net/ip.h> 98 #include <net/protocol.h> 99 #include <net/arp.h> 100 #include <net/route.h> 101 #include <net/ip_fib.h> 102 #include <net/tcp.h> 103 #include <net/udp.h> 104 #include <linux/skbuff.h> 105 #include <net/sock.h> 106 #include <net/raw.h> 107 #include <net/icmp.h> 108 #include <net/ipip.h> 109 #include <net/inet_common.h> 110 #include <net/xfrm.h> 111 #ifdef CONFIG_IP_MROUTE 112 #include <linux/mroute.h> 113 #endif 114 115 DEFINE_SNMP_STAT(struct linux_mib, net_statistics); 116 117 #ifdef INET_REFCNT_DEBUG 118 atomic_t inet_sock_nr; 119 #endif 120 121 extern void ip_mc_drop_socket(struct sock *sk); 122 123 /* The inetsw table contains everything that inet_create needs to 124 * build a new socket. 125 */ 126 static struct list_head inetsw[SOCK_MAX]; 127 static DEFINE_SPINLOCK(inetsw_lock); 128 129 /* New destruction routine */ 130 131 void inet_sock_destruct(struct sock *sk) 132 { 133 struct inet_sock *inet = inet_sk(sk); 134 135 __skb_queue_purge(&sk->sk_receive_queue); 136 __skb_queue_purge(&sk->sk_error_queue); 137 138 if (sk->sk_type == SOCK_STREAM && sk->sk_state != TCP_CLOSE) { 139 printk("Attempt to release TCP socket in state %d %p\n", 140 sk->sk_state, sk); 141 return; 142 } 143 if (!sock_flag(sk, SOCK_DEAD)) { 144 printk("Attempt to release alive inet socket %p\n", sk); 145 return; 146 } 147 148 BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc)); 149 BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc)); 150 BUG_TRAP(!sk->sk_wmem_queued); 151 BUG_TRAP(!sk->sk_forward_alloc); 152 153 if (inet->opt) 154 kfree(inet->opt); 155 dst_release(sk->sk_dst_cache); 156 #ifdef INET_REFCNT_DEBUG 157 atomic_dec(&inet_sock_nr); 158 printk(KERN_DEBUG "INET socket %p released, %d are still alive\n", 159 sk, atomic_read(&inet_sock_nr)); 160 #endif 161 } 162 163 /* 164 * The routines beyond this point handle the behaviour of an AF_INET 165 * socket object. Mostly it punts to the subprotocols of IP to do 166 * the work. 167 */ 168 169 /* 170 * Automatically bind an unbound socket. 171 */ 172 173 static int inet_autobind(struct sock *sk) 174 { 175 struct inet_sock *inet; 176 /* We may need to bind the socket. */ 177 lock_sock(sk); 178 inet = inet_sk(sk); 179 if (!inet->num) { 180 if (sk->sk_prot->get_port(sk, 0)) { 181 release_sock(sk); 182 return -EAGAIN; 183 } 184 inet->sport = htons(inet->num); 185 } 186 release_sock(sk); 187 return 0; 188 } 189 190 /* 191 * Move a socket into listening state. 192 */ 193 int inet_listen(struct socket *sock, int backlog) 194 { 195 struct sock *sk = sock->sk; 196 unsigned char old_state; 197 int err; 198 199 lock_sock(sk); 200 201 err = -EINVAL; 202 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM) 203 goto out; 204 205 old_state = sk->sk_state; 206 if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN))) 207 goto out; 208 209 /* Really, if the socket is already in listen state 210 * we can only allow the backlog to be adjusted. 211 */ 212 if (old_state != TCP_LISTEN) { 213 err = tcp_listen_start(sk); 214 if (err) 215 goto out; 216 } 217 sk->sk_max_ack_backlog = backlog; 218 err = 0; 219 220 out: 221 release_sock(sk); 222 return err; 223 } 224 225 /* 226 * Create an inet socket. 227 */ 228 229 static int inet_create(struct socket *sock, int protocol) 230 { 231 struct sock *sk; 232 struct list_head *p; 233 struct inet_protosw *answer; 234 struct inet_sock *inet; 235 struct proto *answer_prot; 236 unsigned char answer_flags; 237 char answer_no_check; 238 int err; 239 240 sock->state = SS_UNCONNECTED; 241 242 /* Look for the requested type/protocol pair. */ 243 answer = NULL; 244 rcu_read_lock(); 245 list_for_each_rcu(p, &inetsw[sock->type]) { 246 answer = list_entry(p, struct inet_protosw, list); 247 248 /* Check the non-wild match. */ 249 if (protocol == answer->protocol) { 250 if (protocol != IPPROTO_IP) 251 break; 252 } else { 253 /* Check for the two wild cases. */ 254 if (IPPROTO_IP == protocol) { 255 protocol = answer->protocol; 256 break; 257 } 258 if (IPPROTO_IP == answer->protocol) 259 break; 260 } 261 answer = NULL; 262 } 263 264 err = -ESOCKTNOSUPPORT; 265 if (!answer) 266 goto out_rcu_unlock; 267 err = -EPERM; 268 if (answer->capability > 0 && !capable(answer->capability)) 269 goto out_rcu_unlock; 270 err = -EPROTONOSUPPORT; 271 if (!protocol) 272 goto out_rcu_unlock; 273 274 sock->ops = answer->ops; 275 answer_prot = answer->prot; 276 answer_no_check = answer->no_check; 277 answer_flags = answer->flags; 278 rcu_read_unlock(); 279 280 BUG_TRAP(answer_prot->slab != NULL); 281 282 err = -ENOBUFS; 283 sk = sk_alloc(PF_INET, GFP_KERNEL, answer_prot, 1); 284 if (sk == NULL) 285 goto out; 286 287 err = 0; 288 sk->sk_no_check = answer_no_check; 289 if (INET_PROTOSW_REUSE & answer_flags) 290 sk->sk_reuse = 1; 291 292 inet = inet_sk(sk); 293 294 if (SOCK_RAW == sock->type) { 295 inet->num = protocol; 296 if (IPPROTO_RAW == protocol) 297 inet->hdrincl = 1; 298 } 299 300 if (ipv4_config.no_pmtu_disc) 301 inet->pmtudisc = IP_PMTUDISC_DONT; 302 else 303 inet->pmtudisc = IP_PMTUDISC_WANT; 304 305 inet->id = 0; 306 307 sock_init_data(sock, sk); 308 309 sk->sk_destruct = inet_sock_destruct; 310 sk->sk_family = PF_INET; 311 sk->sk_protocol = protocol; 312 sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv; 313 314 inet->uc_ttl = -1; 315 inet->mc_loop = 1; 316 inet->mc_ttl = 1; 317 inet->mc_index = 0; 318 inet->mc_list = NULL; 319 320 #ifdef INET_REFCNT_DEBUG 321 atomic_inc(&inet_sock_nr); 322 #endif 323 324 if (inet->num) { 325 /* It assumes that any protocol which allows 326 * the user to assign a number at socket 327 * creation time automatically 328 * shares. 329 */ 330 inet->sport = htons(inet->num); 331 /* Add to protocol hash chains. */ 332 sk->sk_prot->hash(sk); 333 } 334 335 if (sk->sk_prot->init) { 336 err = sk->sk_prot->init(sk); 337 if (err) 338 sk_common_release(sk); 339 } 340 out: 341 return err; 342 out_rcu_unlock: 343 rcu_read_unlock(); 344 goto out; 345 } 346 347 348 /* 349 * The peer socket should always be NULL (or else). When we call this 350 * function we are destroying the object and from then on nobody 351 * should refer to it. 352 */ 353 int inet_release(struct socket *sock) 354 { 355 struct sock *sk = sock->sk; 356 357 if (sk) { 358 long timeout; 359 360 /* Applications forget to leave groups before exiting */ 361 ip_mc_drop_socket(sk); 362 363 /* If linger is set, we don't return until the close 364 * is complete. Otherwise we return immediately. The 365 * actually closing is done the same either way. 366 * 367 * If the close is due to the process exiting, we never 368 * linger.. 369 */ 370 timeout = 0; 371 if (sock_flag(sk, SOCK_LINGER) && 372 !(current->flags & PF_EXITING)) 373 timeout = sk->sk_lingertime; 374 sock->sk = NULL; 375 sk->sk_prot->close(sk, timeout); 376 } 377 return 0; 378 } 379 380 /* It is off by default, see below. */ 381 int sysctl_ip_nonlocal_bind; 382 383 int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 384 { 385 struct sockaddr_in *addr = (struct sockaddr_in *)uaddr; 386 struct sock *sk = sock->sk; 387 struct inet_sock *inet = inet_sk(sk); 388 unsigned short snum; 389 int chk_addr_ret; 390 int err; 391 392 /* If the socket has its own bind function then use it. (RAW) */ 393 if (sk->sk_prot->bind) { 394 err = sk->sk_prot->bind(sk, uaddr, addr_len); 395 goto out; 396 } 397 err = -EINVAL; 398 if (addr_len < sizeof(struct sockaddr_in)) 399 goto out; 400 401 chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr); 402 403 /* Not specified by any standard per-se, however it breaks too 404 * many applications when removed. It is unfortunate since 405 * allowing applications to make a non-local bind solves 406 * several problems with systems using dynamic addressing. 407 * (ie. your servers still start up even if your ISDN link 408 * is temporarily down) 409 */ 410 err = -EADDRNOTAVAIL; 411 if (!sysctl_ip_nonlocal_bind && 412 !inet->freebind && 413 addr->sin_addr.s_addr != INADDR_ANY && 414 chk_addr_ret != RTN_LOCAL && 415 chk_addr_ret != RTN_MULTICAST && 416 chk_addr_ret != RTN_BROADCAST) 417 goto out; 418 419 snum = ntohs(addr->sin_port); 420 err = -EACCES; 421 if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE)) 422 goto out; 423 424 /* We keep a pair of addresses. rcv_saddr is the one 425 * used by hash lookups, and saddr is used for transmit. 426 * 427 * In the BSD API these are the same except where it 428 * would be illegal to use them (multicast/broadcast) in 429 * which case the sending device address is used. 430 */ 431 lock_sock(sk); 432 433 /* Check these errors (active socket, double bind). */ 434 err = -EINVAL; 435 if (sk->sk_state != TCP_CLOSE || inet->num) 436 goto out_release_sock; 437 438 inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr; 439 if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST) 440 inet->saddr = 0; /* Use device */ 441 442 /* Make sure we are allowed to bind here. */ 443 if (sk->sk_prot->get_port(sk, snum)) { 444 inet->saddr = inet->rcv_saddr = 0; 445 err = -EADDRINUSE; 446 goto out_release_sock; 447 } 448 449 if (inet->rcv_saddr) 450 sk->sk_userlocks |= SOCK_BINDADDR_LOCK; 451 if (snum) 452 sk->sk_userlocks |= SOCK_BINDPORT_LOCK; 453 inet->sport = htons(inet->num); 454 inet->daddr = 0; 455 inet->dport = 0; 456 sk_dst_reset(sk); 457 err = 0; 458 out_release_sock: 459 release_sock(sk); 460 out: 461 return err; 462 } 463 464 int inet_dgram_connect(struct socket *sock, struct sockaddr * uaddr, 465 int addr_len, int flags) 466 { 467 struct sock *sk = sock->sk; 468 469 if (uaddr->sa_family == AF_UNSPEC) 470 return sk->sk_prot->disconnect(sk, flags); 471 472 if (!inet_sk(sk)->num && inet_autobind(sk)) 473 return -EAGAIN; 474 return sk->sk_prot->connect(sk, (struct sockaddr *)uaddr, addr_len); 475 } 476 477 static long inet_wait_for_connect(struct sock *sk, long timeo) 478 { 479 DEFINE_WAIT(wait); 480 481 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 482 483 /* Basic assumption: if someone sets sk->sk_err, he _must_ 484 * change state of the socket from TCP_SYN_*. 485 * Connect() does not allow to get error notifications 486 * without closing the socket. 487 */ 488 while ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) { 489 release_sock(sk); 490 timeo = schedule_timeout(timeo); 491 lock_sock(sk); 492 if (signal_pending(current) || !timeo) 493 break; 494 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 495 } 496 finish_wait(sk->sk_sleep, &wait); 497 return timeo; 498 } 499 500 /* 501 * Connect to a remote host. There is regrettably still a little 502 * TCP 'magic' in here. 503 */ 504 int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr, 505 int addr_len, int flags) 506 { 507 struct sock *sk = sock->sk; 508 int err; 509 long timeo; 510 511 lock_sock(sk); 512 513 if (uaddr->sa_family == AF_UNSPEC) { 514 err = sk->sk_prot->disconnect(sk, flags); 515 sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED; 516 goto out; 517 } 518 519 switch (sock->state) { 520 default: 521 err = -EINVAL; 522 goto out; 523 case SS_CONNECTED: 524 err = -EISCONN; 525 goto out; 526 case SS_CONNECTING: 527 err = -EALREADY; 528 /* Fall out of switch with err, set for this state */ 529 break; 530 case SS_UNCONNECTED: 531 err = -EISCONN; 532 if (sk->sk_state != TCP_CLOSE) 533 goto out; 534 535 err = sk->sk_prot->connect(sk, uaddr, addr_len); 536 if (err < 0) 537 goto out; 538 539 sock->state = SS_CONNECTING; 540 541 /* Just entered SS_CONNECTING state; the only 542 * difference is that return value in non-blocking 543 * case is EINPROGRESS, rather than EALREADY. 544 */ 545 err = -EINPROGRESS; 546 break; 547 } 548 549 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK); 550 551 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) { 552 /* Error code is set above */ 553 if (!timeo || !inet_wait_for_connect(sk, timeo)) 554 goto out; 555 556 err = sock_intr_errno(timeo); 557 if (signal_pending(current)) 558 goto out; 559 } 560 561 /* Connection was closed by RST, timeout, ICMP error 562 * or another process disconnected us. 563 */ 564 if (sk->sk_state == TCP_CLOSE) 565 goto sock_error; 566 567 /* sk->sk_err may be not zero now, if RECVERR was ordered by user 568 * and error was received after socket entered established state. 569 * Hence, it is handled normally after connect() return successfully. 570 */ 571 572 sock->state = SS_CONNECTED; 573 err = 0; 574 out: 575 release_sock(sk); 576 return err; 577 578 sock_error: 579 err = sock_error(sk) ? : -ECONNABORTED; 580 sock->state = SS_UNCONNECTED; 581 if (sk->sk_prot->disconnect(sk, flags)) 582 sock->state = SS_DISCONNECTING; 583 goto out; 584 } 585 586 /* 587 * Accept a pending connection. The TCP layer now gives BSD semantics. 588 */ 589 590 int inet_accept(struct socket *sock, struct socket *newsock, int flags) 591 { 592 struct sock *sk1 = sock->sk; 593 int err = -EINVAL; 594 struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err); 595 596 if (!sk2) 597 goto do_err; 598 599 lock_sock(sk2); 600 601 BUG_TRAP((1 << sk2->sk_state) & 602 (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE)); 603 604 sock_graft(sk2, newsock); 605 606 newsock->state = SS_CONNECTED; 607 err = 0; 608 release_sock(sk2); 609 do_err: 610 return err; 611 } 612 613 614 /* 615 * This does both peername and sockname. 616 */ 617 int inet_getname(struct socket *sock, struct sockaddr *uaddr, 618 int *uaddr_len, int peer) 619 { 620 struct sock *sk = sock->sk; 621 struct inet_sock *inet = inet_sk(sk); 622 struct sockaddr_in *sin = (struct sockaddr_in *)uaddr; 623 624 sin->sin_family = AF_INET; 625 if (peer) { 626 if (!inet->dport || 627 (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) && 628 peer == 1)) 629 return -ENOTCONN; 630 sin->sin_port = inet->dport; 631 sin->sin_addr.s_addr = inet->daddr; 632 } else { 633 __u32 addr = inet->rcv_saddr; 634 if (!addr) 635 addr = inet->saddr; 636 sin->sin_port = inet->sport; 637 sin->sin_addr.s_addr = addr; 638 } 639 memset(sin->sin_zero, 0, sizeof(sin->sin_zero)); 640 *uaddr_len = sizeof(*sin); 641 return 0; 642 } 643 644 int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, 645 size_t size) 646 { 647 struct sock *sk = sock->sk; 648 649 /* We may need to bind the socket. */ 650 if (!inet_sk(sk)->num && inet_autobind(sk)) 651 return -EAGAIN; 652 653 return sk->sk_prot->sendmsg(iocb, sk, msg, size); 654 } 655 656 657 static ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags) 658 { 659 struct sock *sk = sock->sk; 660 661 /* We may need to bind the socket. */ 662 if (!inet_sk(sk)->num && inet_autobind(sk)) 663 return -EAGAIN; 664 665 if (sk->sk_prot->sendpage) 666 return sk->sk_prot->sendpage(sk, page, offset, size, flags); 667 return sock_no_sendpage(sock, page, offset, size, flags); 668 } 669 670 671 int inet_shutdown(struct socket *sock, int how) 672 { 673 struct sock *sk = sock->sk; 674 int err = 0; 675 676 /* This should really check to make sure 677 * the socket is a TCP socket. (WHY AC...) 678 */ 679 how++; /* maps 0->1 has the advantage of making bit 1 rcvs and 680 1->2 bit 2 snds. 681 2->3 */ 682 if ((how & ~SHUTDOWN_MASK) || !how) /* MAXINT->0 */ 683 return -EINVAL; 684 685 lock_sock(sk); 686 if (sock->state == SS_CONNECTING) { 687 if ((1 << sk->sk_state) & 688 (TCPF_SYN_SENT | TCPF_SYN_RECV | TCPF_CLOSE)) 689 sock->state = SS_DISCONNECTING; 690 else 691 sock->state = SS_CONNECTED; 692 } 693 694 switch (sk->sk_state) { 695 case TCP_CLOSE: 696 err = -ENOTCONN; 697 /* Hack to wake up other listeners, who can poll for 698 POLLHUP, even on eg. unconnected UDP sockets -- RR */ 699 default: 700 sk->sk_shutdown |= how; 701 if (sk->sk_prot->shutdown) 702 sk->sk_prot->shutdown(sk, how); 703 break; 704 705 /* Remaining two branches are temporary solution for missing 706 * close() in multithreaded environment. It is _not_ a good idea, 707 * but we have no choice until close() is repaired at VFS level. 708 */ 709 case TCP_LISTEN: 710 if (!(how & RCV_SHUTDOWN)) 711 break; 712 /* Fall through */ 713 case TCP_SYN_SENT: 714 err = sk->sk_prot->disconnect(sk, O_NONBLOCK); 715 sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED; 716 break; 717 } 718 719 /* Wake up anyone sleeping in poll. */ 720 sk->sk_state_change(sk); 721 release_sock(sk); 722 return err; 723 } 724 725 /* 726 * ioctl() calls you can issue on an INET socket. Most of these are 727 * device configuration and stuff and very rarely used. Some ioctls 728 * pass on to the socket itself. 729 * 730 * NOTE: I like the idea of a module for the config stuff. ie ifconfig 731 * loads the devconfigure module does its configuring and unloads it. 732 * There's a good 20K of config code hanging around the kernel. 733 */ 734 735 int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 736 { 737 struct sock *sk = sock->sk; 738 int err = 0; 739 740 switch (cmd) { 741 case SIOCGSTAMP: 742 err = sock_get_timestamp(sk, (struct timeval __user *)arg); 743 break; 744 case SIOCADDRT: 745 case SIOCDELRT: 746 case SIOCRTMSG: 747 err = ip_rt_ioctl(cmd, (void __user *)arg); 748 break; 749 case SIOCDARP: 750 case SIOCGARP: 751 case SIOCSARP: 752 err = arp_ioctl(cmd, (void __user *)arg); 753 break; 754 case SIOCGIFADDR: 755 case SIOCSIFADDR: 756 case SIOCGIFBRDADDR: 757 case SIOCSIFBRDADDR: 758 case SIOCGIFNETMASK: 759 case SIOCSIFNETMASK: 760 case SIOCGIFDSTADDR: 761 case SIOCSIFDSTADDR: 762 case SIOCSIFPFLAGS: 763 case SIOCGIFPFLAGS: 764 case SIOCSIFFLAGS: 765 err = devinet_ioctl(cmd, (void __user *)arg); 766 break; 767 default: 768 if (!sk->sk_prot->ioctl || 769 (err = sk->sk_prot->ioctl(sk, cmd, arg)) == 770 -ENOIOCTLCMD) 771 err = dev_ioctl(cmd, (void __user *)arg); 772 break; 773 } 774 return err; 775 } 776 777 struct proto_ops inet_stream_ops = { 778 .family = PF_INET, 779 .owner = THIS_MODULE, 780 .release = inet_release, 781 .bind = inet_bind, 782 .connect = inet_stream_connect, 783 .socketpair = sock_no_socketpair, 784 .accept = inet_accept, 785 .getname = inet_getname, 786 .poll = tcp_poll, 787 .ioctl = inet_ioctl, 788 .listen = inet_listen, 789 .shutdown = inet_shutdown, 790 .setsockopt = sock_common_setsockopt, 791 .getsockopt = sock_common_getsockopt, 792 .sendmsg = inet_sendmsg, 793 .recvmsg = sock_common_recvmsg, 794 .mmap = sock_no_mmap, 795 .sendpage = tcp_sendpage 796 }; 797 798 struct proto_ops inet_dgram_ops = { 799 .family = PF_INET, 800 .owner = THIS_MODULE, 801 .release = inet_release, 802 .bind = inet_bind, 803 .connect = inet_dgram_connect, 804 .socketpair = sock_no_socketpair, 805 .accept = sock_no_accept, 806 .getname = inet_getname, 807 .poll = udp_poll, 808 .ioctl = inet_ioctl, 809 .listen = sock_no_listen, 810 .shutdown = inet_shutdown, 811 .setsockopt = sock_common_setsockopt, 812 .getsockopt = sock_common_getsockopt, 813 .sendmsg = inet_sendmsg, 814 .recvmsg = sock_common_recvmsg, 815 .mmap = sock_no_mmap, 816 .sendpage = inet_sendpage, 817 }; 818 819 /* 820 * For SOCK_RAW sockets; should be the same as inet_dgram_ops but without 821 * udp_poll 822 */ 823 static struct proto_ops inet_sockraw_ops = { 824 .family = PF_INET, 825 .owner = THIS_MODULE, 826 .release = inet_release, 827 .bind = inet_bind, 828 .connect = inet_dgram_connect, 829 .socketpair = sock_no_socketpair, 830 .accept = sock_no_accept, 831 .getname = inet_getname, 832 .poll = datagram_poll, 833 .ioctl = inet_ioctl, 834 .listen = sock_no_listen, 835 .shutdown = inet_shutdown, 836 .setsockopt = sock_common_setsockopt, 837 .getsockopt = sock_common_getsockopt, 838 .sendmsg = inet_sendmsg, 839 .recvmsg = sock_common_recvmsg, 840 .mmap = sock_no_mmap, 841 .sendpage = inet_sendpage, 842 }; 843 844 static struct net_proto_family inet_family_ops = { 845 .family = PF_INET, 846 .create = inet_create, 847 .owner = THIS_MODULE, 848 }; 849 850 851 extern void tcp_init(void); 852 extern void tcp_v4_init(struct net_proto_family *); 853 854 /* Upon startup we insert all the elements in inetsw_array[] into 855 * the linked list inetsw. 856 */ 857 static struct inet_protosw inetsw_array[] = 858 { 859 { 860 .type = SOCK_STREAM, 861 .protocol = IPPROTO_TCP, 862 .prot = &tcp_prot, 863 .ops = &inet_stream_ops, 864 .capability = -1, 865 .no_check = 0, 866 .flags = INET_PROTOSW_PERMANENT, 867 }, 868 869 { 870 .type = SOCK_DGRAM, 871 .protocol = IPPROTO_UDP, 872 .prot = &udp_prot, 873 .ops = &inet_dgram_ops, 874 .capability = -1, 875 .no_check = UDP_CSUM_DEFAULT, 876 .flags = INET_PROTOSW_PERMANENT, 877 }, 878 879 880 { 881 .type = SOCK_RAW, 882 .protocol = IPPROTO_IP, /* wild card */ 883 .prot = &raw_prot, 884 .ops = &inet_sockraw_ops, 885 .capability = CAP_NET_RAW, 886 .no_check = UDP_CSUM_DEFAULT, 887 .flags = INET_PROTOSW_REUSE, 888 } 889 }; 890 891 #define INETSW_ARRAY_LEN (sizeof(inetsw_array) / sizeof(struct inet_protosw)) 892 893 void inet_register_protosw(struct inet_protosw *p) 894 { 895 struct list_head *lh; 896 struct inet_protosw *answer; 897 int protocol = p->protocol; 898 struct list_head *last_perm; 899 900 spin_lock_bh(&inetsw_lock); 901 902 if (p->type >= SOCK_MAX) 903 goto out_illegal; 904 905 /* If we are trying to override a permanent protocol, bail. */ 906 answer = NULL; 907 last_perm = &inetsw[p->type]; 908 list_for_each(lh, &inetsw[p->type]) { 909 answer = list_entry(lh, struct inet_protosw, list); 910 911 /* Check only the non-wild match. */ 912 if (INET_PROTOSW_PERMANENT & answer->flags) { 913 if (protocol == answer->protocol) 914 break; 915 last_perm = lh; 916 } 917 918 answer = NULL; 919 } 920 if (answer) 921 goto out_permanent; 922 923 /* Add the new entry after the last permanent entry if any, so that 924 * the new entry does not override a permanent entry when matched with 925 * a wild-card protocol. But it is allowed to override any existing 926 * non-permanent entry. This means that when we remove this entry, the 927 * system automatically returns to the old behavior. 928 */ 929 list_add_rcu(&p->list, last_perm); 930 out: 931 spin_unlock_bh(&inetsw_lock); 932 933 synchronize_net(); 934 935 return; 936 937 out_permanent: 938 printk(KERN_ERR "Attempt to override permanent protocol %d.\n", 939 protocol); 940 goto out; 941 942 out_illegal: 943 printk(KERN_ERR 944 "Ignoring attempt to register invalid socket type %d.\n", 945 p->type); 946 goto out; 947 } 948 949 void inet_unregister_protosw(struct inet_protosw *p) 950 { 951 if (INET_PROTOSW_PERMANENT & p->flags) { 952 printk(KERN_ERR 953 "Attempt to unregister permanent protocol %d.\n", 954 p->protocol); 955 } else { 956 spin_lock_bh(&inetsw_lock); 957 list_del_rcu(&p->list); 958 spin_unlock_bh(&inetsw_lock); 959 960 synchronize_net(); 961 } 962 } 963 964 #ifdef CONFIG_IP_MULTICAST 965 static struct net_protocol igmp_protocol = { 966 .handler = igmp_rcv, 967 }; 968 #endif 969 970 static struct net_protocol tcp_protocol = { 971 .handler = tcp_v4_rcv, 972 .err_handler = tcp_v4_err, 973 .no_policy = 1, 974 }; 975 976 static struct net_protocol udp_protocol = { 977 .handler = udp_rcv, 978 .err_handler = udp_err, 979 .no_policy = 1, 980 }; 981 982 static struct net_protocol icmp_protocol = { 983 .handler = icmp_rcv, 984 }; 985 986 static int __init init_ipv4_mibs(void) 987 { 988 net_statistics[0] = alloc_percpu(struct linux_mib); 989 net_statistics[1] = alloc_percpu(struct linux_mib); 990 ip_statistics[0] = alloc_percpu(struct ipstats_mib); 991 ip_statistics[1] = alloc_percpu(struct ipstats_mib); 992 icmp_statistics[0] = alloc_percpu(struct icmp_mib); 993 icmp_statistics[1] = alloc_percpu(struct icmp_mib); 994 tcp_statistics[0] = alloc_percpu(struct tcp_mib); 995 tcp_statistics[1] = alloc_percpu(struct tcp_mib); 996 udp_statistics[0] = alloc_percpu(struct udp_mib); 997 udp_statistics[1] = alloc_percpu(struct udp_mib); 998 if (! 999 (net_statistics[0] && net_statistics[1] && ip_statistics[0] 1000 && ip_statistics[1] && tcp_statistics[0] && tcp_statistics[1] 1001 && udp_statistics[0] && udp_statistics[1])) 1002 return -ENOMEM; 1003 1004 (void) tcp_mib_init(); 1005 1006 return 0; 1007 } 1008 1009 static int ipv4_proc_init(void); 1010 extern void ipfrag_init(void); 1011 1012 static int __init inet_init(void) 1013 { 1014 struct sk_buff *dummy_skb; 1015 struct inet_protosw *q; 1016 struct list_head *r; 1017 int rc = -EINVAL; 1018 1019 if (sizeof(struct inet_skb_parm) > sizeof(dummy_skb->cb)) { 1020 printk(KERN_CRIT "%s: panic\n", __FUNCTION__); 1021 goto out; 1022 } 1023 1024 rc = proto_register(&tcp_prot, 1); 1025 if (rc) 1026 goto out; 1027 1028 rc = proto_register(&udp_prot, 1); 1029 if (rc) 1030 goto out_unregister_tcp_proto; 1031 1032 rc = proto_register(&raw_prot, 1); 1033 if (rc) 1034 goto out_unregister_udp_proto; 1035 1036 /* 1037 * Tell SOCKET that we are alive... 1038 */ 1039 1040 (void)sock_register(&inet_family_ops); 1041 1042 /* 1043 * Add all the base protocols. 1044 */ 1045 1046 if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0) 1047 printk(KERN_CRIT "inet_init: Cannot add ICMP protocol\n"); 1048 if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0) 1049 printk(KERN_CRIT "inet_init: Cannot add UDP protocol\n"); 1050 if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0) 1051 printk(KERN_CRIT "inet_init: Cannot add TCP protocol\n"); 1052 #ifdef CONFIG_IP_MULTICAST 1053 if (inet_add_protocol(&igmp_protocol, IPPROTO_IGMP) < 0) 1054 printk(KERN_CRIT "inet_init: Cannot add IGMP protocol\n"); 1055 #endif 1056 1057 /* Register the socket-side information for inet_create. */ 1058 for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r) 1059 INIT_LIST_HEAD(r); 1060 1061 for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q) 1062 inet_register_protosw(q); 1063 1064 /* 1065 * Set the ARP module up 1066 */ 1067 1068 arp_init(); 1069 1070 /* 1071 * Set the IP module up 1072 */ 1073 1074 ip_init(); 1075 1076 tcp_v4_init(&inet_family_ops); 1077 1078 /* Setup TCP slab cache for open requests. */ 1079 tcp_init(); 1080 1081 1082 /* 1083 * Set the ICMP layer up 1084 */ 1085 1086 icmp_init(&inet_family_ops); 1087 1088 /* 1089 * Initialise the multicast router 1090 */ 1091 #if defined(CONFIG_IP_MROUTE) 1092 ip_mr_init(); 1093 #endif 1094 /* 1095 * Initialise per-cpu ipv4 mibs 1096 */ 1097 1098 if(init_ipv4_mibs()) 1099 printk(KERN_CRIT "inet_init: Cannot init ipv4 mibs\n"); ; 1100 1101 ipv4_proc_init(); 1102 1103 ipfrag_init(); 1104 1105 rc = 0; 1106 out: 1107 return rc; 1108 out_unregister_tcp_proto: 1109 proto_unregister(&tcp_prot); 1110 out_unregister_udp_proto: 1111 proto_unregister(&udp_prot); 1112 goto out; 1113 } 1114 1115 module_init(inet_init); 1116 1117 /* ------------------------------------------------------------------------ */ 1118 1119 #ifdef CONFIG_PROC_FS 1120 extern int fib_proc_init(void); 1121 extern void fib_proc_exit(void); 1122 extern int ip_misc_proc_init(void); 1123 extern int raw_proc_init(void); 1124 extern void raw_proc_exit(void); 1125 extern int tcp4_proc_init(void); 1126 extern void tcp4_proc_exit(void); 1127 extern int udp4_proc_init(void); 1128 extern void udp4_proc_exit(void); 1129 1130 static int __init ipv4_proc_init(void) 1131 { 1132 int rc = 0; 1133 1134 if (raw_proc_init()) 1135 goto out_raw; 1136 if (tcp4_proc_init()) 1137 goto out_tcp; 1138 if (udp4_proc_init()) 1139 goto out_udp; 1140 if (fib_proc_init()) 1141 goto out_fib; 1142 if (ip_misc_proc_init()) 1143 goto out_misc; 1144 out: 1145 return rc; 1146 out_misc: 1147 fib_proc_exit(); 1148 out_fib: 1149 udp4_proc_exit(); 1150 out_udp: 1151 tcp4_proc_exit(); 1152 out_tcp: 1153 raw_proc_exit(); 1154 out_raw: 1155 rc = -ENOMEM; 1156 goto out; 1157 } 1158 1159 #else /* CONFIG_PROC_FS */ 1160 static int __init ipv4_proc_init(void) 1161 { 1162 return 0; 1163 } 1164 #endif /* CONFIG_PROC_FS */ 1165 1166 MODULE_ALIAS_NETPROTO(PF_INET); 1167 1168 EXPORT_SYMBOL(inet_accept); 1169 EXPORT_SYMBOL(inet_bind); 1170 EXPORT_SYMBOL(inet_dgram_connect); 1171 EXPORT_SYMBOL(inet_dgram_ops); 1172 EXPORT_SYMBOL(inet_getname); 1173 EXPORT_SYMBOL(inet_ioctl); 1174 EXPORT_SYMBOL(inet_listen); 1175 EXPORT_SYMBOL(inet_register_protosw); 1176 EXPORT_SYMBOL(inet_release); 1177 EXPORT_SYMBOL(inet_sendmsg); 1178 EXPORT_SYMBOL(inet_shutdown); 1179 EXPORT_SYMBOL(inet_sock_destruct); 1180 EXPORT_SYMBOL(inet_stream_connect); 1181 EXPORT_SYMBOL(inet_stream_ops); 1182 EXPORT_SYMBOL(inet_unregister_protosw); 1183 EXPORT_SYMBOL(net_statistics); 1184 EXPORT_SYMBOL(sysctl_ip_nonlocal_bind); 1185 1186 #ifdef INET_REFCNT_DEBUG 1187 EXPORT_SYMBOL(inet_sock_nr); 1188 #endif 1189