net/core/sock.c

   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  *              Generic socket support routines. Memory allocators, socket lock/release
   7  *              handler for protocols to use and generic option handler.
   8  *
   9  *
  10  * Version:     $Id: sock.c,v 1.117 2002/02/01 22:01:03 davem Exp $
  11  *
  12  * Authors:     Ross Biro
  13  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  14  *              Florian La Roche, <flla@stud.uni-sb.de>
  15  *              Alan Cox, <A.Cox@swansea.ac.uk>
  16  *
  17  * Fixes:
  18  *              Alan Cox        :       Numerous verify_area() problems
  19  *              Alan Cox        :       Connecting on a connecting socket
  20  *                                      now returns an error for tcp.
  21  *              Alan Cox        :       sock->protocol is set correctly.
  22  *                                      and is not sometimes left as 0.
  23  *              Alan Cox        :       connect handles icmp errors on a
  24  *                                      connect properly. Unfortunately there
  25  *                                      is a restart syscall nasty there. I
  26  *                                      can't match BSD without hacking the C
  27  *                                      library. Ideas urgently sought!
  28  *              Alan Cox        :       Disallow bind() to addresses that are
  29  *                                      not ours - especially broadcast ones!!
  30  *              Alan Cox        :       Socket 1024 _IS_ ok for users. (fencepost)
  31  *              Alan Cox        :       sock_wfree/sock_rfree don't destroy sockets,
  32  *                                      instead they leave that for the DESTROY timer.
  33  *              Alan Cox        :       Clean up error flag in accept
  34  *              Alan Cox        :       TCP ack handling is buggy, the DESTROY timer
  35  *                                      was buggy. Put a remove_sock() in the handler
  36  *                                      for memory when we hit 0. Also altered the timer
  37  *                                      code. The ACK stuff can wait and needs major
  38  *                                      TCP layer surgery.
  39  *              Alan Cox        :       Fixed TCP ack bug, removed remove sock
  40  *                                      and fixed timer/inet_bh race.
  41  *              Alan Cox        :       Added zapped flag for TCP
  42  *              Alan Cox        :       Move kfree_skb into skbuff.c and tidied up surplus code
  43  *              Alan Cox        :       for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
  44  *              Alan Cox        :       kfree_s calls now are kfree_skbmem so we can track skb resources
  45  *              Alan Cox        :       Supports socket option broadcast now as does udp. Packet and raw need fixing.
  46  *              Alan Cox        :       Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
  47  *              Rick Sladkey    :       Relaxed UDP rules for matching packets.
  48  *              C.E.Hawkins     :       IFF_PROMISC/SIOCGHWADDR support
  49  *      Pauline Middelink       :       identd support
  50  *              Alan Cox        :       Fixed connect() taking signals I think.
  51  *              Alan Cox        :       SO_LINGER supported
  52  *              Alan Cox        :       Error reporting fixes
  53  *              Anonymous       :       inet_create tidied up (sk->reuse setting)
  54  *              Alan Cox        :       inet sockets don't set sk->type!
  55  *              Alan Cox        :       Split socket option code
  56  *              Alan Cox        :       Callbacks
  57  *              Alan Cox        :       Nagle flag for Charles & Johannes stuff
  58  *              Alex            :       Removed restriction on inet fioctl
  59  *              Alan Cox        :       Splitting INET from NET core
  60  *              Alan Cox        :       Fixed bogus SO_TYPE handling in getsockopt()
  61  *              Adam Caldwell   :       Missing return in SO_DONTROUTE/SO_DEBUG code
  62  *              Alan Cox        :       Split IP from generic code
  63  *              Alan Cox        :       New kfree_skbmem()
  64  *              Alan Cox        :       Make SO_DEBUG superuser only.
  65  *              Alan Cox        :       Allow anyone to clear SO_DEBUG
  66  *                                      (compatibility fix)
  67  *              Alan Cox        :       Added optimistic memory grabbing for AF_UNIX throughput.
  68  *              Alan Cox        :       Allocator for a socket is settable.
  69  *              Alan Cox        :       SO_ERROR includes soft errors.
  70  *              Alan Cox        :       Allow NULL arguments on some SO_ opts
  71  *              Alan Cox        :       Generic socket allocation to make hooks
  72  *                                      easier (suggested by Craig Metz).
  73  *              Michael Pall    :       SO_ERROR returns positive errno again
  74  *              Steve Whitehouse:       Added default destructor to free
  75  *                                      protocol private data.
  76  *              Steve Whitehouse:       Added various other default routines
  77  *                                      common to several socket families.
  78  *              Chris Evans     :       Call suser() check last on F_SETOWN
  79  *              Jay Schulist    :       Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
  80  *              Andi Kleen      :       Add sock_kmalloc()/sock_kfree_s()
  81  *              Andi Kleen      :       Fix write_space callback
  82  *              Chris Evans     :       Security fixes - signedness again
  83  *              Arnaldo C. Melo :       cleanups, use skb_queue_purge
  84  *
  85  * To Fix:
  86  *
  87  *
  88  *              This program is free software; you can redistribute it and/or
  89  *              modify it under the terms of the GNU General Public License
  90  *              as published by the Free Software Foundation; either version
  91  *              2 of the License, or (at your option) any later version.
  92  */
  93
  94 #include <linux/capability.h>
  95 #include <linux/config.h>
  96 #include <linux/errno.h>
  97 #include <linux/types.h>
  98 #include <linux/socket.h>
  99 #include <linux/in.h>
 100 #include <linux/kernel.h>
 101 #include <linux/module.h>
 102 #include <linux/proc_fs.h>
 103 #include <linux/seq_file.h>
 104 #include <linux/sched.h>
 105 #include <linux/timer.h>
 106 #include <linux/string.h>
 107 #include <linux/sockios.h>
 108 #include <linux/net.h>
 109 #include <linux/mm.h>
 110 #include <linux/slab.h>
 111 #include <linux/interrupt.h>
 112 #include <linux/poll.h>
 113 #include <linux/tcp.h>
 114 #include <linux/init.h>
 115
 116 #include <asm/uaccess.h>
 117 #include <asm/system.h>
 118
 119 #include <linux/netdevice.h>
 120 #include <net/protocol.h>
 121 #include <linux/skbuff.h>
 122 #include <net/request_sock.h>
 123 #include <net/sock.h>
 124 #include <net/xfrm.h>
 125 #include <linux/ipsec.h>
 126
 127 #include <linux/filter.h>
 128
 129 #ifdef CONFIG_INET
 130 #include <net/tcp.h>
 131 #endif
 132
 133 /* Take into consideration the size of the struct sk_buff overhead in the
 134  * determination of these values, since that is non-constant across
 135  * platforms.  This makes socket queueing behavior and performance
 136  * not depend upon such differences.
 137  */
 138 #define _SK_MEM_PACKETS         256
 139 #define _SK_MEM_OVERHEAD        (sizeof(struct sk_buff) + 256)
 140 #define SK_WMEM_MAX             (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
 141 #define SK_RMEM_MAX             (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
 142
 143 /* Run time adjustable parameters. */
 144 __u32 sysctl_wmem_max = SK_WMEM_MAX;
 145 __u32 sysctl_rmem_max = SK_RMEM_MAX;
 146 __u32 sysctl_wmem_default = SK_WMEM_MAX;
 147 __u32 sysctl_rmem_default = SK_RMEM_MAX;
 148
 149 /* Maximal space eaten by iovec or ancilliary data plus some space */
 150 int sysctl_optmem_max = sizeof(unsigned long)*(2*UIO_MAXIOV + 512);
 151
 152 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
 153 {
 154         struct timeval tv;
 155
 156         if (optlen < sizeof(tv))
 157                 return -EINVAL;
 158         if (copy_from_user(&tv, optval, sizeof(tv)))
 159                 return -EFAULT;
 160
 161         *timeo_p = MAX_SCHEDULE_TIMEOUT;
 162         if (tv.tv_sec == 0 && tv.tv_usec == 0)
 163                 return 0;
 164         if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
 165                 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
 166         return 0;
 167 }
 168
 169 static void sock_warn_obsolete_bsdism(const char *name)
 170 {
 171         static int warned;
 172         static char warncomm[TASK_COMM_LEN];
 173         if (strcmp(warncomm, current->comm) && warned < 5) {
 174                 strcpy(warncomm,  current->comm);
 175                 printk(KERN_WARNING "process `%s' is using obsolete "
 176                        "%s SO_BSDCOMPAT\n", warncomm, name);
 177                 warned++;
 178         }
 179 }
 180
 181 static void sock_disable_timestamp(struct sock *sk)
 182 {
 183         if (sock_flag(sk, SOCK_TIMESTAMP)) {
 184                 sock_reset_flag(sk, SOCK_TIMESTAMP);
 185                 net_disable_timestamp();
 186         }
 187 }
 188
 189
 190 int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
 191 {
 192         int err = 0;
 193         int skb_len;
 194
 195         /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
 196            number of warnings when compiling with -W --ANK
 197          */
 198         if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
 199             (unsigned)sk->sk_rcvbuf) {
 200                 err = -ENOMEM;
 201                 goto out;
 202         }
 203
 204         /* It would be deadlock, if sock_queue_rcv_skb is used
 205            with socket lock! We assume that users of this
 206            function are lock free.
 207         */
 208         err = sk_filter(sk, skb, 1);
 209         if (err)
 210                 goto out;
 211
 212         skb->dev = NULL;
 213         skb_set_owner_r(skb, sk);
 214
 215         /* Cache the SKB length before we tack it onto the receive
 216          * queue.  Once it is added it no longer belongs to us and
 217          * may be freed by other threads of control pulling packets
 218          * from the queue.
 219          */
 220         skb_len = skb->len;
 221
 222         skb_queue_tail(&sk->sk_receive_queue, skb);
 223
 224         if (!sock_flag(sk, SOCK_DEAD))
 225                 sk->sk_data_ready(sk, skb_len);
 226 out:
 227         return err;
 228 }
 229 EXPORT_SYMBOL(sock_queue_rcv_skb);
 230
 231 int sk_receive_skb(struct sock *sk, struct sk_buff *skb)
 232 {
 233         int rc = NET_RX_SUCCESS;
 234
 235         if (sk_filter(sk, skb, 0))
 236                 goto discard_and_relse;
 237
 238         skb->dev = NULL;
 239
 240         bh_lock_sock(sk);
 241         if (!sock_owned_by_user(sk))
 242                 rc = sk->sk_backlog_rcv(sk, skb);
 243         else
 244                 sk_add_backlog(sk, skb);
 245         bh_unlock_sock(sk);
 246 out:
 247         sock_put(sk);
 248         return rc;
 249 discard_and_relse:
 250         kfree_skb(skb);
 251         goto out;
 252 }
 253 EXPORT_SYMBOL(sk_receive_skb);
 254
 255 struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
 256 {
 257         struct dst_entry *dst = sk->sk_dst_cache;
 258
 259         if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
 260                 sk->sk_dst_cache = NULL;
 261                 dst_release(dst);
 262                 return NULL;
 263         }
 264
 265         return dst;
 266 }
 267 EXPORT_SYMBOL(__sk_dst_check);
 268
 269 struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
 270 {
 271         struct dst_entry *dst = sk_dst_get(sk);
 272
 273         if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
 274                 sk_dst_reset(sk);
 275                 dst_release(dst);
 276                 return NULL;
 277         }
 278
 279         return dst;
 280 }
 281 EXPORT_SYMBOL(sk_dst_check);
 282
 283 /*
 284  *      This is meant for all protocols to use and covers goings on
 285  *      at the socket level. Everything here is generic.
 286  */
 287
 288 int sock_setsockopt(struct socket *sock, int level, int optname,
 289                     char __user *optval, int optlen)
 290 {
 291         struct sock *sk=sock->sk;
 292         struct sk_filter *filter;
 293         int val;
 294         int valbool;
 295         struct linger ling;
 296         int ret = 0;
 297
 298         /*
 299          *      Options without arguments
 300          */
 301
 302 #ifdef SO_DONTLINGER            /* Compatibility item... */
 303         if (optname == SO_DONTLINGER) {
 304                 lock_sock(sk);
 305                 sock_reset_flag(sk, SOCK_LINGER);
 306                 release_sock(sk);
 307                 return 0;
 308         }
 309 #endif
 310
 311         if(optlen<sizeof(int))
 312                 return(-EINVAL);
 313
 314         if (get_user(val, (int __user *)optval))
 315                 return -EFAULT;
 316
 317         valbool = val?1:0;
 318
 319         lock_sock(sk);
 320
 321         switch(optname)
 322         {
 323                 case SO_DEBUG:
 324                         if(val && !capable(CAP_NET_ADMIN))
 325                         {
 326                                 ret = -EACCES;
 327                         }
 328                         else if (valbool)
 329                                 sock_set_flag(sk, SOCK_DBG);
 330                         else
 331                                 sock_reset_flag(sk, SOCK_DBG);
 332                         break;
 333                 case SO_REUSEADDR:
 334                         sk->sk_reuse = valbool;
 335                         break;
 336                 case SO_TYPE:
 337                 case SO_ERROR:
 338                         ret = -ENOPROTOOPT;
 339                         break;
 340                 case SO_DONTROUTE:
 341                         if (valbool)
 342                                 sock_set_flag(sk, SOCK_LOCALROUTE);
 343                         else
 344                                 sock_reset_flag(sk, SOCK_LOCALROUTE);
 345                         break;
 346                 case SO_BROADCAST:
 347                         sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
 348                         break;
 349                 case SO_SNDBUF:
 350                         /* Don't error on this BSD doesn't and if you think
 351                            about it this is right. Otherwise apps have to
 352                            play 'guess the biggest size' games. RCVBUF/SNDBUF
 353                            are treated in BSD as hints */
 354
 355                         if (val > sysctl_wmem_max)
 356                                 val = sysctl_wmem_max;
 357 set_sndbuf:
 358                         sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
 359                         if ((val * 2) < SOCK_MIN_SNDBUF)
 360                                 sk->sk_sndbuf = SOCK_MIN_SNDBUF;
 361                         else
 362                                 sk->sk_sndbuf = val * 2;
 363
 364                         /*
 365                          *      Wake up sending tasks if we
 366                          *      upped the value.
 367                          */
 368                         sk->sk_write_space(sk);
 369                         break;
 370
 371                 case SO_SNDBUFFORCE:
 372                         if (!capable(CAP_NET_ADMIN)) {
 373                                 ret = -EPERM;
 374                                 break;
 375                         }
 376                         goto set_sndbuf;
 377
 378                 case SO_RCVBUF:
 379                         /* Don't error on this BSD doesn't and if you think
 380                            about it this is right. Otherwise apps have to
 381                            play 'guess the biggest size' games. RCVBUF/SNDBUF
 382                            are treated in BSD as hints */
 383
 384                         if (val > sysctl_rmem_max)
 385                                 val = sysctl_rmem_max;
 386 set_rcvbuf:
 387                         sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
 388                         /*
 389                          * We double it on the way in to account for
 390                          * "struct sk_buff" etc. overhead.   Applications
 391                          * assume that the SO_RCVBUF setting they make will
 392                          * allow that much actual data to be received on that
 393                          * socket.
 394                          *
 395                          * Applications are unaware that "struct sk_buff" and
 396                          * other overheads allocate from the receive buffer
 397                          * during socket buffer allocation.
 398                          *
 399                          * And after considering the possible alternatives,
 400                          * returning the value we actually used in getsockopt
 401                          * is the most desirable behavior.
 402                          */
 403                         if ((val * 2) < SOCK_MIN_RCVBUF)
 404                                 sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
 405                         else
 406                                 sk->sk_rcvbuf = val * 2;
 407                         break;
 408
 409                 case SO_RCVBUFFORCE:
 410                         if (!capable(CAP_NET_ADMIN)) {
 411                                 ret = -EPERM;
 412                                 break;
 413                         }
 414                         goto set_rcvbuf;
 415
 416                 case SO_KEEPALIVE:
 417 #ifdef CONFIG_INET
 418                         if (sk->sk_protocol == IPPROTO_TCP)
 419                                 tcp_set_keepalive(sk, valbool);
 420 #endif
 421                         sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
 422                         break;
 423
 424                 case SO_OOBINLINE:
 425                         sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
 426                         break;
 427
 428                 case SO_NO_CHECK:
 429                         sk->sk_no_check = valbool;
 430                         break;
 431
 432                 case SO_PRIORITY:
 433                         if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
 434                                 sk->sk_priority = val;
 435                         else
 436                                 ret = -EPERM;
 437                         break;
 438
 439                 case SO_LINGER:
 440                         if(optlen<sizeof(ling)) {
 441                                 ret = -EINVAL;  /* 1003.1g */
 442                                 break;
 443                         }
 444                         if (copy_from_user(&ling,optval,sizeof(ling))) {
 445                                 ret = -EFAULT;
 446                                 break;
 447                         }
 448                         if (!ling.l_onoff)
 449                                 sock_reset_flag(sk, SOCK_LINGER);
 450                         else {
 451 #if (BITS_PER_LONG == 32)
 452                                 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
 453                                         sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
 454                                 else
 455 #endif
 456                                         sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
 457                                 sock_set_flag(sk, SOCK_LINGER);
 458                         }
 459                         break;
 460
 461                 case SO_BSDCOMPAT:
 462                         sock_warn_obsolete_bsdism("setsockopt");
 463                         break;
 464
 465                 case SO_PASSCRED:
 466                         if (valbool)
 467                                 set_bit(SOCK_PASSCRED, &sock->flags);
 468                         else
 469                                 clear_bit(SOCK_PASSCRED, &sock->flags);
 470                         break;
 471
 472                 case SO_TIMESTAMP:
 473                         if (valbool)  {
 474                                 sock_set_flag(sk, SOCK_RCVTSTAMP);
 475                                 sock_enable_timestamp(sk);
 476                         } else
 477                                 sock_reset_flag(sk, SOCK_RCVTSTAMP);
 478                         break;
 479
 480                 case SO_RCVLOWAT:
 481                         if (val < 0)
 482                                 val = INT_MAX;
 483                         sk->sk_rcvlowat = val ? : 1;
 484                         break;
 485
 486                 case SO_RCVTIMEO:
 487                         ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
 488                         break;
 489
 490                 case SO_SNDTIMEO:
 491                         ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
 492                         break;
 493
 494 #ifdef CONFIG_NETDEVICES
 495                 case SO_BINDTODEVICE:
 496                 {
 497                         char devname[IFNAMSIZ];
 498
 499                         /* Sorry... */
 500                         if (!capable(CAP_NET_RAW)) {
 501                                 ret = -EPERM;
 502                                 break;
 503                         }
 504
 505                         /* Bind this socket to a particular device like "eth0",
 506                          * as specified in the passed interface name. If the
 507                          * name is "" or the option length is zero the socket
 508                          * is not bound.
 509                          */
 510
 511                         if (!valbool) {
 512                                 sk->sk_bound_dev_if = 0;
 513                         } else {
 514                                 if (optlen > IFNAMSIZ - 1)
 515                                         optlen = IFNAMSIZ - 1;
 516                                 memset(devname, 0, sizeof(devname));
 517                                 if (copy_from_user(devname, optval, optlen)) {
 518                                         ret = -EFAULT;
 519                                         break;
 520                                 }
 521
 522                                 /* Remove any cached route for this socket. */
 523                                 sk_dst_reset(sk);
 524
 525                                 if (devname[0] == '\0') {
 526                                         sk->sk_bound_dev_if = 0;
 527                                 } else {
 528                                         struct net_device *dev = dev_get_by_name(devname);
 529                                         if (!dev) {
 530                                                 ret = -ENODEV;
 531                                                 break;
 532                                         }
 533                                         sk->sk_bound_dev_if = dev->ifindex;
 534                                         dev_put(dev);
 535                                 }
 536                         }
 537                         break;
 538                 }
 539 #endif
 540
 541
 542                 case SO_ATTACH_FILTER:
 543                         ret = -EINVAL;
 544                         if (optlen == sizeof(struct sock_fprog)) {
 545                                 struct sock_fprog fprog;
 546
 547                                 ret = -EFAULT;
 548                                 if (copy_from_user(&fprog, optval, sizeof(fprog)))
 549                                         break;
 550
 551                                 ret = sk_attach_filter(&fprog, sk);
 552                         }
 553                         break;
 554
 555                 case SO_DETACH_FILTER:
 556                         spin_lock_bh(&sk->sk_lock.slock);
 557                         filter = sk->sk_filter;
 558                         if (filter) {
 559                                 sk->sk_filter = NULL;
 560                                 spin_unlock_bh(&sk->sk_lock.slock);
 561                                 sk_filter_release(sk, filter);
 562                                 break;
 563                         }
 564                         spin_unlock_bh(&sk->sk_lock.slock);
 565                         ret = -ENONET;
 566                         break;
 567
 568                 /* We implement the SO_SNDLOWAT etc to
 569                    not be settable (1003.1g 5.3) */
 570                 default:
 571                         ret = -ENOPROTOOPT;
 572                         break;
 573         }
 574         release_sock(sk);
 575         return ret;
 576 }
 577
 578
 579 int sock_getsockopt(struct socket *sock, int level, int optname,
 580                     char __user *optval, int __user *optlen)
 581 {
 582         struct sock *sk = sock->sk;
 583
 584         union
 585         {
 586                 int val;
 587                 struct linger ling;
 588                 struct timeval tm;
 589         } v;
 590
 591         unsigned int lv = sizeof(int);
 592         int len;
 593
 594         if(get_user(len,optlen))
 595                 return -EFAULT;
 596         if(len < 0)
 597                 return -EINVAL;
 598
 599         switch(optname)
 600         {
 601                 case SO_DEBUG:
 602                         v.val = sock_flag(sk, SOCK_DBG);
 603                         break;
 604
 605                 case SO_DONTROUTE:
 606                         v.val = sock_flag(sk, SOCK_LOCALROUTE);
 607                         break;
 608
 609                 case SO_BROADCAST:
 610                         v.val = !!sock_flag(sk, SOCK_BROADCAST);
 611                         break;
 612
 613                 case SO_SNDBUF:
 614                         v.val = sk->sk_sndbuf;
 615                         break;
 616
 617                 case SO_RCVBUF:
 618                         v.val = sk->sk_rcvbuf;
 619                         break;
 620
 621                 case SO_REUSEADDR:
 622                         v.val = sk->sk_reuse;
 623                         break;
 624
 625                 case SO_KEEPALIVE:
 626                         v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
 627                         break;
 628
 629                 case SO_TYPE:
 630                         v.val = sk->sk_type;
 631                         break;
 632
 633                 case SO_ERROR:
 634                         v.val = -sock_error(sk);
 635                         if(v.val==0)
 636                                 v.val = xchg(&sk->sk_err_soft, 0);
 637                         break;
 638
 639                 case SO_OOBINLINE:
 640                         v.val = !!sock_flag(sk, SOCK_URGINLINE);
 641                         break;
 642
 643                 case SO_NO_CHECK:
 644                         v.val = sk->sk_no_check;
 645                         break;
 646
 647                 case SO_PRIORITY:
 648                         v.val = sk->sk_priority;
 649                         break;
 650
 651                 case SO_LINGER:
 652                         lv              = sizeof(v.ling);
 653                         v.ling.l_onoff  = !!sock_flag(sk, SOCK_LINGER);
 654                         v.ling.l_linger = sk->sk_lingertime / HZ;
 655                         break;
 656
 657                 case SO_BSDCOMPAT:
 658                         sock_warn_obsolete_bsdism("getsockopt");
 659                         break;
 660
 661                 case SO_TIMESTAMP:
 662                         v.val = sock_flag(sk, SOCK_RCVTSTAMP);
 663                         break;
 664
 665                 case SO_RCVTIMEO:
 666                         lv=sizeof(struct timeval);
 667                         if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
 668                                 v.tm.tv_sec = 0;
 669                                 v.tm.tv_usec = 0;
 670                         } else {
 671                                 v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
 672                                 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
 673                         }
 674                         break;
 675
 676                 case SO_SNDTIMEO:
 677                         lv=sizeof(struct timeval);
 678                         if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
 679                                 v.tm.tv_sec = 0;
 680                                 v.tm.tv_usec = 0;
 681                         } else {
 682                                 v.tm.tv_sec = sk->sk_sndtimeo / HZ;
 683                                 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
 684                         }
 685                         break;
 686
 687                 case SO_RCVLOWAT:
 688                         v.val = sk->sk_rcvlowat;
 689                         break;
 690
 691                 case SO_SNDLOWAT:
 692                         v.val=1;
 693                         break;
 694
 695                 case SO_PASSCRED:
 696                         v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
 697                         break;
 698
 699                 case SO_PEERCRED:
 700                         if (len > sizeof(sk->sk_peercred))
 701                                 len = sizeof(sk->sk_peercred);
 702                         if (copy_to_user(optval, &sk->sk_peercred, len))
 703                                 return -EFAULT;
 704                         goto lenout;
 705
 706                 case SO_PEERNAME:
 707                 {
 708                         char address[128];
 709
 710                         if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
 711                                 return -ENOTCONN;
 712                         if (lv < len)
 713                                 return -EINVAL;
 714                         if (copy_to_user(optval, address, len))
 715                                 return -EFAULT;
 716                         goto lenout;
 717                 }
 718
 719                 /* Dubious BSD thing... Probably nobody even uses it, but
 720                  * the UNIX standard wants it for whatever reason... -DaveM
 721                  */
 722                 case SO_ACCEPTCONN:
 723                         v.val = sk->sk_state == TCP_LISTEN;
 724                         break;
 725
 726                 case SO_PEERSEC:
 727                         return security_socket_getpeersec_stream(sock, optval, optlen, len);
 728
 729                 default:
 730                         return(-ENOPROTOOPT);
 731         }
 732         if (len > lv)
 733                 len = lv;
 734         if (copy_to_user(optval, &v, len))
 735                 return -EFAULT;
 736 lenout:
 737         if (put_user(len, optlen))
 738                 return -EFAULT;
 739         return 0;
 740 }
 741
 742 /**
 743  *      sk_alloc - All socket objects are allocated here
 744  *      @family: protocol family
 745  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
 746  *      @prot: struct proto associated with this new sock instance
 747  *      @zero_it: if we should zero the newly allocated sock
 748  */
 749 struct sock *sk_alloc(int family, gfp_t priority,
 750                       struct proto *prot, int zero_it)
 751 {
 752         struct sock *sk = NULL;
 753         kmem_cache_t *slab = prot->slab;
 754
 755         if (slab != NULL)
 756                 sk = kmem_cache_alloc(slab, priority);
 757         else
 758                 sk = kmalloc(prot->obj_size, priority);
 759
 760         if (sk) {
 761                 if (zero_it) {
 762                         memset(sk, 0, prot->obj_size);
 763                         sk->sk_family = family;
 764                         /*
 765                          * See comment in struct sock definition to understand
 766                          * why we need sk_prot_creator -acme
 767                          */
 768                         sk->sk_prot = sk->sk_prot_creator = prot;
 769                         sock_lock_init(sk);
 770                 }
 771
 772                 if (security_sk_alloc(sk, family, priority))
 773                         goto out_free;
 774
 775                 if (!try_module_get(prot->owner))
 776                         goto out_free;
 777         }
 778         return sk;
 779
 780 out_free:
 781         if (slab != NULL)
 782                 kmem_cache_free(slab, sk);
 783         else
 784                 kfree(sk);
 785         return NULL;
 786 }
 787
 788 void sk_free(struct sock *sk)
 789 {
 790         struct sk_filter *filter;
 791         struct module *owner = sk->sk_prot_creator->owner;
 792
 793         if (sk->sk_destruct)
 794                 sk->sk_destruct(sk);
 795
 796         filter = sk->sk_filter;
 797         if (filter) {
 798                 sk_filter_release(sk, filter);
 799                 sk->sk_filter = NULL;
 800         }
 801
 802         sock_disable_timestamp(sk);
 803
 804         if (atomic_read(&sk->sk_omem_alloc))
 805                 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
 806                        __FUNCTION__, atomic_read(&sk->sk_omem_alloc));
 807
 808         security_sk_free(sk);
 809         if (sk->sk_prot_creator->slab != NULL)
 810                 kmem_cache_free(sk->sk_prot_creator->slab, sk);
 811         else
 812                 kfree(sk);
 813         module_put(owner);
 814 }
 815
 816 struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
 817 {
 818         struct sock *newsk = sk_alloc(sk->sk_family, priority, sk->sk_prot, 0);
 819
 820         if (newsk != NULL) {
 821                 struct sk_filter *filter;
 822
 823                 memcpy(newsk, sk, sk->sk_prot->obj_size);
 824
 825                 /* SANITY */
 826                 sk_node_init(&newsk->sk_node);
 827                 sock_lock_init(newsk);
 828                 bh_lock_sock(newsk);
 829
 830                 atomic_set(&newsk->sk_rmem_alloc, 0);
 831                 atomic_set(&newsk->sk_wmem_alloc, 0);
 832                 atomic_set(&newsk->sk_omem_alloc, 0);
 833                 skb_queue_head_init(&newsk->sk_receive_queue);
 834                 skb_queue_head_init(&newsk->sk_write_queue);
 835
 836                 rwlock_init(&newsk->sk_dst_lock);
 837                 rwlock_init(&newsk->sk_callback_lock);
 838
 839                 newsk->sk_dst_cache     = NULL;
 840                 newsk->sk_wmem_queued   = 0;
 841                 newsk->sk_forward_alloc = 0;
 842                 newsk->sk_send_head     = NULL;
 843                 newsk->sk_backlog.head  = newsk->sk_backlog.tail = NULL;
 844                 newsk->sk_userlocks     = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
 845
 846                 sock_reset_flag(newsk, SOCK_DONE);
 847                 skb_queue_head_init(&newsk->sk_error_queue);
 848
 849                 filter = newsk->sk_filter;
 850                 if (filter != NULL)
 851                         sk_filter_charge(newsk, filter);
 852
 853                 if (unlikely(xfrm_sk_clone_policy(newsk))) {
 854                         /* It is still raw copy of parent, so invalidate
 855                          * destructor and make plain sk_free() */
 856                         newsk->sk_destruct = NULL;
 857                         sk_free(newsk);
 858                         newsk = NULL;
 859                         goto out;
 860                 }
 861
 862                 newsk->sk_err      = 0;
 863                 newsk->sk_priority = 0;
 864                 atomic_set(&newsk->sk_refcnt, 2);
 865
 866                 /*
 867                  * Increment the counter in the same struct proto as the master
 868                  * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
 869                  * is the same as sk->sk_prot->socks, as this field was copied
 870                  * with memcpy).
 871                  *
 872                  * This _changes_ the previous behaviour, where
 873                  * tcp_create_openreq_child always was incrementing the
 874                  * equivalent to tcp_prot->socks (inet_sock_nr), so this have
 875                  * to be taken into account in all callers. -acme
 876                  */
 877                 sk_refcnt_debug_inc(newsk);
 878                 newsk->sk_socket = NULL;
 879                 newsk->sk_sleep  = NULL;
 880
 881                 if (newsk->sk_prot->sockets_allocated)
 882                         atomic_inc(newsk->sk_prot->sockets_allocated);
 883         }
 884 out:
 885         return newsk;
 886 }
 887
 888 EXPORT_SYMBOL_GPL(sk_clone);
 889
 890 void __init sk_init(void)
 891 {
 892         if (num_physpages <= 4096) {
 893                 sysctl_wmem_max = 32767;
 894                 sysctl_rmem_max = 32767;
 895                 sysctl_wmem_default = 32767;
 896                 sysctl_rmem_default = 32767;
 897         } else if (num_physpages >= 131072) {
 898                 sysctl_wmem_max = 131071;
 899                 sysctl_rmem_max = 131071;
 900         }
 901 }
 902
 903 /*
 904  *      Simple resource managers for sockets.
 905  */
 906
 907
 908 /*
 909  * Write buffer destructor automatically called from kfree_skb.
 910  */
 911 void sock_wfree(struct sk_buff *skb)
 912 {
 913         struct sock *sk = skb->sk;
 914
 915         /* In case it might be waiting for more memory. */
 916         atomic_sub(skb->truesize, &sk->sk_wmem_alloc);
 917         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
 918                 sk->sk_write_space(sk);
 919         sock_put(sk);
 920 }
 921
 922 /*
 923  * Read buffer destructor automatically called from kfree_skb.
 924  */
 925 void sock_rfree(struct sk_buff *skb)
 926 {
 927         struct sock *sk = skb->sk;
 928
 929         atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
 930 }
 931
 932
 933 int sock_i_uid(struct sock *sk)
 934 {
 935         int uid;
 936
 937         read_lock(&sk->sk_callback_lock);
 938         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
 939         read_unlock(&sk->sk_callback_lock);
 940         return uid;
 941 }
 942
 943 unsigned long sock_i_ino(struct sock *sk)
 944 {
 945         unsigned long ino;
 946
 947         read_lock(&sk->sk_callback_lock);
 948         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
 949         read_unlock(&sk->sk_callback_lock);
 950         return ino;
 951 }
 952
 953 /*
 954  * Allocate a skb from the socket's send buffer.
 955  */
 956 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
 957                              gfp_t priority)
 958 {
 959         if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
 960                 struct sk_buff * skb = alloc_skb(size, priority);
 961                 if (skb) {
 962                         skb_set_owner_w(skb, sk);
 963                         return skb;
 964                 }
 965         }
 966         return NULL;
 967 }
 968
 969 /*
 970  * Allocate a skb from the socket's receive buffer.
 971  */
 972 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
 973                              gfp_t priority)
 974 {
 975         if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
 976                 struct sk_buff *skb = alloc_skb(size, priority);
 977                 if (skb) {
 978                         skb_set_owner_r(skb, sk);
 979                         return skb;
 980                 }
 981         }
 982         return NULL;
 983 }
 984
 985 /*
 986  * Allocate a memory block from the socket's option memory buffer.
 987  */
 988 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
 989 {
 990         if ((unsigned)size <= sysctl_optmem_max &&
 991             atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
 992                 void *mem;
 993                 /* First do the add, to avoid the race if kmalloc
 994                  * might sleep.
 995                  */
 996                 atomic_add(size, &sk->sk_omem_alloc);
 997                 mem = kmalloc(size, priority);
 998                 if (mem)
 999                         return mem;
1000                 atomic_sub(size, &sk->sk_omem_alloc);
1001         }
1002         return NULL;
1003 }
1004
1005 /*
1006  * Free an option memory block.
1007  */
1008 void sock_kfree_s(struct sock *sk, void *mem, int size)
1009 {
1010         kfree(mem);
1011         atomic_sub(size, &sk->sk_omem_alloc);
1012 }
1013
1014 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1015    I think, these locks should be removed for datagram sockets.
1016  */
1017 static long sock_wait_for_wmem(struct sock * sk, long timeo)
1018 {
1019         DEFINE_WAIT(wait);
1020
1021         clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1022         for (;;) {
1023                 if (!timeo)
1024                         break;
1025                 if (signal_pending(current))
1026                         break;
1027                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1028                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1029                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1030                         break;
1031                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1032                         break;
1033                 if (sk->sk_err)
1034                         break;
1035                 timeo = schedule_timeout(timeo);
1036         }
1037         finish_wait(sk->sk_sleep, &wait);
1038         return timeo;
1039 }
1040
1041
1042 /*
1043  *      Generic send/receive buffer handlers
1044  */
1045
1046 static struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
1047                                             unsigned long header_len,
1048                                             unsigned long data_len,
1049                                             int noblock, int *errcode)
1050 {
1051         struct sk_buff *skb;
1052         gfp_t gfp_mask;
1053         long timeo;
1054         int err;
1055
1056         gfp_mask = sk->sk_allocation;
1057         if (gfp_mask & __GFP_WAIT)
1058                 gfp_mask |= __GFP_REPEAT;
1059
1060         timeo = sock_sndtimeo(sk, noblock);
1061         while (1) {
1062                 err = sock_error(sk);
1063                 if (err != 0)
1064                         goto failure;
1065
1066                 err = -EPIPE;
1067                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1068                         goto failure;
1069
1070                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1071                         skb = alloc_skb(header_len, sk->sk_allocation);
1072                         if (skb) {
1073                                 int npages;
1074                                 int i;
1075
1076                                 /* No pages, we're done... */
1077                                 if (!data_len)
1078                                         break;
1079
1080                                 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1081                                 skb->truesize += data_len;
1082                                 skb_shinfo(skb)->nr_frags = npages;
1083                                 for (i = 0; i < npages; i++) {
1084                                         struct page *page;
1085                                         skb_frag_t *frag;
1086
1087                                         page = alloc_pages(sk->sk_allocation, 0);
1088                                         if (!page) {
1089                                                 err = -ENOBUFS;
1090                                                 skb_shinfo(skb)->nr_frags = i;
1091                                                 kfree_skb(skb);
1092                                                 goto failure;
1093                                         }
1094
1095                                         frag = &skb_shinfo(skb)->frags[i];
1096                                         frag->page = page;
1097                                         frag->page_offset = 0;
1098                                         frag->size = (data_len >= PAGE_SIZE ?
1099                                                       PAGE_SIZE :
1100                                                       data_len);
1101                                         data_len -= PAGE_SIZE;
1102                                 }
1103
1104                                 /* Full success... */
1105                                 break;
1106                         }
1107                         err = -ENOBUFS;
1108                         goto failure;
1109                 }
1110                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1111                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1112                 err = -EAGAIN;
1113                 if (!timeo)
1114                         goto failure;
1115                 if (signal_pending(current))
1116                         goto interrupted;
1117                 timeo = sock_wait_for_wmem(sk, timeo);
1118         }
1119
1120         skb_set_owner_w(skb, sk);
1121         return skb;
1122
1123 interrupted:
1124         err = sock_intr_errno(timeo);
1125 failure:
1126         *errcode = err;
1127         return NULL;
1128 }
1129
1130 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1131                                     int noblock, int *errcode)
1132 {
1133         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1134 }
1135
1136 static void __lock_sock(struct sock *sk)
1137 {
1138         DEFINE_WAIT(wait);
1139
1140         for(;;) {
1141                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1142                                         TASK_UNINTERRUPTIBLE);
1143                 spin_unlock_bh(&sk->sk_lock.slock);
1144                 schedule();
1145                 spin_lock_bh(&sk->sk_lock.slock);
1146                 if(!sock_owned_by_user(sk))
1147                         break;
1148         }
1149         finish_wait(&sk->sk_lock.wq, &wait);
1150 }
1151
1152 static void __release_sock(struct sock *sk)
1153 {
1154         struct sk_buff *skb = sk->sk_backlog.head;
1155
1156         do {
1157                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1158                 bh_unlock_sock(sk);
1159
1160                 do {
1161                         struct sk_buff *next = skb->next;
1162
1163                         skb->next = NULL;
1164                         sk->sk_backlog_rcv(sk, skb);
1165
1166                         /*
1167                          * We are in process context here with softirqs
1168                          * disabled, use cond_resched_softirq() to preempt.
1169                          * This is safe to do because we've taken the backlog
1170                          * queue private:
1171                          */
1172                         cond_resched_softirq();
1173
1174                         skb = next;
1175                 } while (skb != NULL);
1176
1177                 bh_lock_sock(sk);
1178         } while((skb = sk->sk_backlog.head) != NULL);
1179 }
1180
1181 /**
1182  * sk_wait_data - wait for data to arrive at sk_receive_queue
1183  * @sk:    sock to wait on
1184  * @timeo: for how long
1185  *
1186  * Now socket state including sk->sk_err is changed only under lock,
1187  * hence we may omit checks after joining wait queue.
1188  * We check receive queue before schedule() only as optimization;
1189  * it is very likely that release_sock() added new data.
1190  */
1191 int sk_wait_data(struct sock *sk, long *timeo)
1192 {
1193         int rc;
1194         DEFINE_WAIT(wait);
1195
1196         prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1197         set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1198         rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1199         clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1200         finish_wait(sk->sk_sleep, &wait);
1201         return rc;
1202 }
1203
1204 EXPORT_SYMBOL(sk_wait_data);
1205
1206 /*
1207  * Set of default routines for initialising struct proto_ops when
1208  * the protocol does not support a particular function. In certain
1209  * cases where it makes no sense for a protocol to have a "do nothing"
1210  * function, some default processing is provided.
1211  */
1212
1213 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1214 {
1215         return -EOPNOTSUPP;
1216 }
1217
1218 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1219                     int len, int flags)
1220 {
1221         return -EOPNOTSUPP;
1222 }
1223
1224 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1225 {
1226         return -EOPNOTSUPP;
1227 }
1228
1229 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1230 {
1231         return -EOPNOTSUPP;
1232 }
1233
1234 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1235                     int *len, int peer)
1236 {
1237         return -EOPNOTSUPP;
1238 }
1239
1240 unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt)
1241 {
1242         return 0;
1243 }
1244
1245 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1246 {
1247         return -EOPNOTSUPP;
1248 }
1249
1250 int sock_no_listen(struct socket *sock, int backlog)
1251 {
1252         return -EOPNOTSUPP;
1253 }
1254
1255 int sock_no_shutdown(struct socket *sock, int how)
1256 {
1257         return -EOPNOTSUPP;
1258 }
1259
1260 int sock_no_setsockopt(struct socket *sock, int level, int optname,
1261                     char __user *optval, int optlen)
1262 {
1263         return -EOPNOTSUPP;
1264 }
1265
1266 int sock_no_getsockopt(struct socket *sock, int level, int optname,
1267                     char __user *optval, int __user *optlen)
1268 {
1269         return -EOPNOTSUPP;
1270 }
1271
1272 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1273                     size_t len)
1274 {
1275         return -EOPNOTSUPP;
1276 }
1277
1278 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1279                     size_t len, int flags)
1280 {
1281         return -EOPNOTSUPP;
1282 }
1283
1284 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1285 {
1286         /* Mirror missing mmap method error code */
1287         return -ENODEV;
1288 }
1289
1290 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1291 {
1292         ssize_t res;
1293         struct msghdr msg = {.msg_flags = flags};
1294         struct kvec iov;
1295         char *kaddr = kmap(page);
1296         iov.iov_base = kaddr + offset;
1297         iov.iov_len = size;
1298         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1299         kunmap(page);
1300         return res;
1301 }
1302
1303 /*
1304  *      Default Socket Callbacks
1305  */
1306
1307 static void sock_def_wakeup(struct sock *sk)
1308 {
1309         read_lock(&sk->sk_callback_lock);
1310         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1311                 wake_up_interruptible_all(sk->sk_sleep);
1312         read_unlock(&sk->sk_callback_lock);
1313 }
1314
1315 static void sock_def_error_report(struct sock *sk)
1316 {
1317         read_lock(&sk->sk_callback_lock);
1318         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1319                 wake_up_interruptible(sk->sk_sleep);
1320         sk_wake_async(sk,0,POLL_ERR);
1321         read_unlock(&sk->sk_callback_lock);
1322 }
1323
1324 static void sock_def_readable(struct sock *sk, int len)
1325 {
1326         read_lock(&sk->sk_callback_lock);
1327         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1328                 wake_up_interruptible(sk->sk_sleep);
1329         sk_wake_async(sk,1,POLL_IN);
1330         read_unlock(&sk->sk_callback_lock);
1331 }
1332
1333 static void sock_def_write_space(struct sock *sk)
1334 {
1335         read_lock(&sk->sk_callback_lock);
1336
1337         /* Do not wake up a writer until he can make "significant"
1338          * progress.  --DaveM
1339          */
1340         if((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
1341                 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1342                         wake_up_interruptible(sk->sk_sleep);
1343
1344                 /* Should agree with poll, otherwise some programs break */
1345                 if (sock_writeable(sk))
1346                         sk_wake_async(sk, 2, POLL_OUT);
1347         }
1348
1349         read_unlock(&sk->sk_callback_lock);
1350 }
1351
1352 static void sock_def_destruct(struct sock *sk)
1353 {
1354         kfree(sk->sk_protinfo);
1355 }
1356
1357 void sk_send_sigurg(struct sock *sk)
1358 {
1359         if (sk->sk_socket && sk->sk_socket->file)
1360                 if (send_sigurg(&sk->sk_socket->file->f_owner))
1361                         sk_wake_async(sk, 3, POLL_PRI);
1362 }
1363
1364 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1365                     unsigned long expires)
1366 {
1367         if (!mod_timer(timer, expires))
1368                 sock_hold(sk);
1369 }
1370
1371 EXPORT_SYMBOL(sk_reset_timer);
1372
1373 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1374 {
1375         if (timer_pending(timer) && del_timer(timer))
1376                 __sock_put(sk);
1377 }
1378
1379 EXPORT_SYMBOL(sk_stop_timer);
1380
1381 void sock_init_data(struct socket *sock, struct sock *sk)
1382 {
1383         skb_queue_head_init(&sk->sk_receive_queue);
1384         skb_queue_head_init(&sk->sk_write_queue);
1385         skb_queue_head_init(&sk->sk_error_queue);
1386
1387         sk->sk_send_head        =       NULL;
1388
1389         init_timer(&sk->sk_timer);
1390
1391         sk->sk_allocation       =       GFP_KERNEL;
1392         sk->sk_rcvbuf           =       sysctl_rmem_default;
1393         sk->sk_sndbuf           =       sysctl_wmem_default;
1394         sk->sk_state            =       TCP_CLOSE;
1395         sk->sk_socket           =       sock;
1396
1397         sock_set_flag(sk, SOCK_ZAPPED);
1398
1399         if(sock)
1400         {
1401                 sk->sk_type     =       sock->type;
1402                 sk->sk_sleep    =       &sock->wait;
1403                 sock->sk        =       sk;
1404         } else
1405                 sk->sk_sleep    =       NULL;
1406
1407         rwlock_init(&sk->sk_dst_lock);
1408         rwlock_init(&sk->sk_callback_lock);
1409
1410         sk->sk_state_change     =       sock_def_wakeup;
1411         sk->sk_data_ready       =       sock_def_readable;
1412         sk->sk_write_space      =       sock_def_write_space;
1413         sk->sk_error_report     =       sock_def_error_report;
1414         sk->sk_destruct         =       sock_def_destruct;
1415
1416         sk->sk_sndmsg_page      =       NULL;
1417         sk->sk_sndmsg_off       =       0;
1418
1419         sk->sk_peercred.pid     =       0;
1420         sk->sk_peercred.uid     =       -1;
1421         sk->sk_peercred.gid     =       -1;
1422         sk->sk_write_pending    =       0;
1423         sk->sk_rcvlowat         =       1;
1424         sk->sk_rcvtimeo         =       MAX_SCHEDULE_TIMEOUT;
1425         sk->sk_sndtimeo         =       MAX_SCHEDULE_TIMEOUT;
1426
1427         sk->sk_stamp.tv_sec     = -1L;
1428         sk->sk_stamp.tv_usec    = -1L;
1429
1430         atomic_set(&sk->sk_refcnt, 1);
1431 }
1432
1433 void fastcall lock_sock(struct sock *sk)
1434 {
1435         might_sleep();
1436         spin_lock_bh(&(sk->sk_lock.slock));
1437         if (sk->sk_lock.owner)
1438                 __lock_sock(sk);
1439         sk->sk_lock.owner = (void *)1;
1440         spin_unlock_bh(&(sk->sk_lock.slock));
1441 }
1442
1443 EXPORT_SYMBOL(lock_sock);
1444
1445 void fastcall release_sock(struct sock *sk)
1446 {
1447         spin_lock_bh(&(sk->sk_lock.slock));
1448         if (sk->sk_backlog.tail)
1449                 __release_sock(sk);
1450         sk->sk_lock.owner = NULL;
1451         if (waitqueue_active(&(sk->sk_lock.wq)))
1452                 wake_up(&(sk->sk_lock.wq));
1453         spin_unlock_bh(&(sk->sk_lock.slock));
1454 }
1455 EXPORT_SYMBOL(release_sock);
1456
1457 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
1458 {
1459         if (!sock_flag(sk, SOCK_TIMESTAMP))
1460                 sock_enable_timestamp(sk);
1461         if (sk->sk_stamp.tv_sec == -1)
1462                 return -ENOENT;
1463         if (sk->sk_stamp.tv_sec == 0)
1464                 do_gettimeofday(&sk->sk_stamp);
1465         return copy_to_user(userstamp, &sk->sk_stamp, sizeof(struct timeval)) ?
1466                 -EFAULT : 0;
1467 }
1468 EXPORT_SYMBOL(sock_get_timestamp);
1469
1470 void sock_enable_timestamp(struct sock *sk)
1471 {
1472         if (!sock_flag(sk, SOCK_TIMESTAMP)) {
1473                 sock_set_flag(sk, SOCK_TIMESTAMP);
1474                 net_enable_timestamp();
1475         }
1476 }
1477 EXPORT_SYMBOL(sock_enable_timestamp);
1478
1479 /*
1480  *      Get a socket option on an socket.
1481  *
1482  *      FIX: POSIX 1003.1g is very ambiguous here. It states that
1483  *      asynchronous errors should be reported by getsockopt. We assume
1484  *      this means if you specify SO_ERROR (otherwise whats the point of it).
1485  */
1486 int sock_common_getsockopt(struct socket *sock, int level, int optname,
1487                            char __user *optval, int __user *optlen)
1488 {
1489         struct sock *sk = sock->sk;
1490
1491         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1492 }
1493
1494 EXPORT_SYMBOL(sock_common_getsockopt);
1495
1496 #ifdef CONFIG_COMPAT
1497 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
1498                                   char __user *optval, int __user *optlen)
1499 {
1500         struct sock *sk = sock->sk;
1501
1502         if (sk->sk_prot->compat_setsockopt != NULL)
1503                 return sk->sk_prot->compat_getsockopt(sk, level, optname,
1504                                                       optval, optlen);
1505         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1506 }
1507 EXPORT_SYMBOL(compat_sock_common_getsockopt);
1508 #endif
1509
1510 int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1511                         struct msghdr *msg, size_t size, int flags)
1512 {
1513         struct sock *sk = sock->sk;
1514         int addr_len = 0;
1515         int err;
1516
1517         err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
1518                                    flags & ~MSG_DONTWAIT, &addr_len);
1519         if (err >= 0)
1520                 msg->msg_namelen = addr_len;
1521         return err;
1522 }
1523
1524 EXPORT_SYMBOL(sock_common_recvmsg);
1525
1526 /*
1527  *      Set socket options on an inet socket.
1528  */
1529 int sock_common_setsockopt(struct socket *sock, int level, int optname,
1530                            char __user *optval, int optlen)
1531 {
1532         struct sock *sk = sock->sk;
1533
1534         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1535 }
1536
1537 EXPORT_SYMBOL(sock_common_setsockopt);
1538
1539 #ifdef CONFIG_COMPAT
1540 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
1541                                   char __user *optval, int optlen)
1542 {
1543         struct sock *sk = sock->sk;
1544
1545         if (sk->sk_prot->compat_setsockopt != NULL)
1546                 return sk->sk_prot->compat_setsockopt(sk, level, optname,
1547                                                       optval, optlen);
1548         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1549 }
1550 EXPORT_SYMBOL(compat_sock_common_setsockopt);
1551 #endif
1552
1553 void sk_common_release(struct sock *sk)
1554 {
1555         if (sk->sk_prot->destroy)
1556                 sk->sk_prot->destroy(sk);
1557
1558         /*
1559          * Observation: when sock_common_release is called, processes have
1560          * no access to socket. But net still has.
1561          * Step one, detach it from networking:
1562          *
1563          * A. Remove from hash tables.
1564          */
1565
1566         sk->sk_prot->unhash(sk);
1567
1568         /*
1569          * In this point socket cannot receive new packets, but it is possible
1570          * that some packets are in flight because some CPU runs receiver and
1571          * did hash table lookup before we unhashed socket. They will achieve
1572          * receive queue and will be purged by socket destructor.
1573          *
1574          * Also we still have packets pending on receive queue and probably,
1575          * our own packets waiting in device queues. sock_destroy will drain
1576          * receive queue, but transmitted packets will delay socket destruction
1577          * until the last reference will be released.
1578          */
1579
1580         sock_orphan(sk);
1581
1582         xfrm_sk_free_policy(sk);
1583
1584         sk_refcnt_debug_release(sk);
1585         sock_put(sk);
1586 }
1587
1588 EXPORT_SYMBOL(sk_common_release);
1589
1590 static DEFINE_RWLOCK(proto_list_lock);
1591 static LIST_HEAD(proto_list);
1592
1593 int proto_register(struct proto *prot, int alloc_slab)
1594 {
1595         char *request_sock_slab_name = NULL;
1596         char *timewait_sock_slab_name;
1597         int rc = -ENOBUFS;
1598
1599         if (alloc_slab) {
1600                 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
1601                                                SLAB_HWCACHE_ALIGN, NULL, NULL);
1602
1603                 if (prot->slab == NULL) {
1604                         printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
1605                                prot->name);
1606                         goto out;
1607                 }
1608
1609                 if (prot->rsk_prot != NULL) {
1610                         static const char mask[] = "request_sock_%s";
1611
1612                         request_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
1613                         if (request_sock_slab_name == NULL)
1614                                 goto out_free_sock_slab;
1615
1616                         sprintf(request_sock_slab_name, mask, prot->name);
1617                         prot->rsk_prot->slab = kmem_cache_create(request_sock_slab_name,
1618                                                                  prot->rsk_prot->obj_size, 0,
1619                                                                  SLAB_HWCACHE_ALIGN, NULL, NULL);
1620
1621                         if (prot->rsk_prot->slab == NULL) {
1622                                 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
1623                                        prot->name);
1624                                 goto out_free_request_sock_slab_name;
1625                         }
1626                 }
1627
1628                 if (prot->twsk_prot != NULL) {
1629                         static const char mask[] = "tw_sock_%s";
1630
1631                         timewait_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
1632
1633                         if (timewait_sock_slab_name == NULL)
1634                                 goto out_free_request_sock_slab;
1635
1636                         sprintf(timewait_sock_slab_name, mask, prot->name);
1637                         prot->twsk_prot->twsk_slab =
1638                                 kmem_cache_create(timewait_sock_slab_name,
1639                                                   prot->twsk_prot->twsk_obj_size,
1640                                                   0, SLAB_HWCACHE_ALIGN,
1641                                                   NULL, NULL);
1642                         if (prot->twsk_prot->twsk_slab == NULL)
1643                                 goto out_free_timewait_sock_slab_name;
1644                 }
1645         }
1646
1647         write_lock(&proto_list_lock);
1648         list_add(&prot->node, &proto_list);
1649         write_unlock(&proto_list_lock);
1650         rc = 0;
1651 out:
1652         return rc;
1653 out_free_timewait_sock_slab_name:
1654         kfree(timewait_sock_slab_name);
1655 out_free_request_sock_slab:
1656         if (prot->rsk_prot && prot->rsk_prot->slab) {
1657                 kmem_cache_destroy(prot->rsk_prot->slab);
1658                 prot->rsk_prot->slab = NULL;
1659         }
1660 out_free_request_sock_slab_name:
1661         kfree(request_sock_slab_name);
1662 out_free_sock_slab:
1663         kmem_cache_destroy(prot->slab);
1664         prot->slab = NULL;
1665         goto out;
1666 }
1667
1668 EXPORT_SYMBOL(proto_register);
1669
1670 void proto_unregister(struct proto *prot)
1671 {
1672         write_lock(&proto_list_lock);
1673         list_del(&prot->node);
1674         write_unlock(&proto_list_lock);
1675
1676         if (prot->slab != NULL) {
1677                 kmem_cache_destroy(prot->slab);
1678                 prot->slab = NULL;
1679         }
1680
1681         if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
1682                 const char *name = kmem_cache_name(prot->rsk_prot->slab);
1683
1684                 kmem_cache_destroy(prot->rsk_prot->slab);
1685                 kfree(name);
1686                 prot->rsk_prot->slab = NULL;
1687         }
1688
1689         if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
1690                 const char *name = kmem_cache_name(prot->twsk_prot->twsk_slab);
1691
1692                 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
1693                 kfree(name);
1694                 prot->twsk_prot->twsk_slab = NULL;
1695         }
1696 }
1697
1698 EXPORT_SYMBOL(proto_unregister);
1699
1700 #ifdef CONFIG_PROC_FS
1701 static inline struct proto *__proto_head(void)
1702 {
1703         return list_entry(proto_list.next, struct proto, node);
1704 }
1705
1706 static inline struct proto *proto_head(void)
1707 {
1708         return list_empty(&proto_list) ? NULL : __proto_head();
1709 }
1710
1711 static inline struct proto *proto_next(struct proto *proto)
1712 {
1713         return proto->node.next == &proto_list ? NULL :
1714                 list_entry(proto->node.next, struct proto, node);
1715 }
1716
1717 static inline struct proto *proto_get_idx(loff_t pos)
1718 {
1719         struct proto *proto;
1720         loff_t i = 0;
1721
1722         list_for_each_entry(proto, &proto_list, node)
1723                 if (i++ == pos)
1724                         goto out;
1725
1726         proto = NULL;
1727 out:
1728         return proto;
1729 }
1730
1731 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
1732 {
1733         read_lock(&proto_list_lock);
1734         return *pos ? proto_get_idx(*pos - 1) : SEQ_START_TOKEN;
1735 }
1736
1737 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1738 {
1739         ++*pos;
1740         return v == SEQ_START_TOKEN ? proto_head() : proto_next(v);
1741 }
1742
1743 static void proto_seq_stop(struct seq_file *seq, void *v)
1744 {
1745         read_unlock(&proto_list_lock);
1746 }
1747
1748 static char proto_method_implemented(const void *method)
1749 {
1750         return method == NULL ? 'n' : 'y';
1751 }
1752
1753 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
1754 {
1755         seq_printf(seq, "%-9s %4u %6d  %6d   %-3s %6u   %-3s  %-10s "
1756                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
1757                    proto->name,
1758                    proto->obj_size,
1759                    proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1,
1760                    proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
1761                    proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
1762                    proto->max_header,
1763                    proto->slab == NULL ? "no" : "yes",
1764                    module_name(proto->owner),
1765                    proto_method_implemented(proto->close),
1766                    proto_method_implemented(proto->connect),
1767                    proto_method_implemented(proto->disconnect),
1768                    proto_method_implemented(proto->accept),
1769                    proto_method_implemented(proto->ioctl),
1770                    proto_method_implemented(proto->init),
1771                    proto_method_implemented(proto->destroy),
1772                    proto_method_implemented(proto->shutdown),
1773                    proto_method_implemented(proto->setsockopt),
1774                    proto_method_implemented(proto->getsockopt),
1775                    proto_method_implemented(proto->sendmsg),
1776                    proto_method_implemented(proto->recvmsg),
1777                    proto_method_implemented(proto->sendpage),
1778                    proto_method_implemented(proto->bind),
1779                    proto_method_implemented(proto->backlog_rcv),
1780                    proto_method_implemented(proto->hash),
1781                    proto_method_implemented(proto->unhash),
1782                    proto_method_implemented(proto->get_port),
1783                    proto_method_implemented(proto->enter_memory_pressure));
1784 }
1785
1786 static int proto_seq_show(struct seq_file *seq, void *v)
1787 {
1788         if (v == SEQ_START_TOKEN)
1789                 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
1790                            "protocol",
1791                            "size",
1792                            "sockets",
1793                            "memory",
1794                            "press",
1795                            "maxhdr",
1796                            "slab",
1797                            "module",
1798                            "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
1799         else
1800                 proto_seq_printf(seq, v);
1801         return 0;
1802 }
1803
1804 static struct seq_operations proto_seq_ops = {
1805         .start  = proto_seq_start,
1806         .next   = proto_seq_next,
1807         .stop   = proto_seq_stop,
1808         .show   = proto_seq_show,
1809 };
1810
1811 static int proto_seq_open(struct inode *inode, struct file *file)
1812 {
1813         return seq_open(file, &proto_seq_ops);
1814 }
1815
1816 static struct file_operations proto_seq_fops = {
1817         .owner          = THIS_MODULE,
1818         .open           = proto_seq_open,
1819         .read           = seq_read,
1820         .llseek         = seq_lseek,
1821         .release        = seq_release,
1822 };
1823
1824 static int __init proto_init(void)
1825 {
1826         /* register /proc/net/protocols */
1827         return proc_net_fops_create("protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0;
1828 }
1829
1830 subsys_initcall(proto_init);
1831
1832 #endif /* PROC_FS */
1833
1834 EXPORT_SYMBOL(sk_alloc);
1835 EXPORT_SYMBOL(sk_free);
1836 EXPORT_SYMBOL(sk_send_sigurg);
1837 EXPORT_SYMBOL(sock_alloc_send_skb);
1838 EXPORT_SYMBOL(sock_init_data);
1839 EXPORT_SYMBOL(sock_kfree_s);
1840 EXPORT_SYMBOL(sock_kmalloc);
1841 EXPORT_SYMBOL(sock_no_accept);
1842 EXPORT_SYMBOL(sock_no_bind);
1843 EXPORT_SYMBOL(sock_no_connect);
1844 EXPORT_SYMBOL(sock_no_getname);
1845 EXPORT_SYMBOL(sock_no_getsockopt);
1846 EXPORT_SYMBOL(sock_no_ioctl);
1847 EXPORT_SYMBOL(sock_no_listen);
1848 EXPORT_SYMBOL(sock_no_mmap);
1849 EXPORT_SYMBOL(sock_no_poll);
1850 EXPORT_SYMBOL(sock_no_recvmsg);
1851 EXPORT_SYMBOL(sock_no_sendmsg);
1852 EXPORT_SYMBOL(sock_no_sendpage);
1853 EXPORT_SYMBOL(sock_no_setsockopt);
1854 EXPORT_SYMBOL(sock_no_shutdown);
1855 EXPORT_SYMBOL(sock_no_socketpair);
1856 EXPORT_SYMBOL(sock_rfree);
1857 EXPORT_SYMBOL(sock_setsockopt);
1858 EXPORT_SYMBOL(sock_wfree);
1859 EXPORT_SYMBOL(sock_wmalloc);
1860 EXPORT_SYMBOL(sock_i_uid);
1861 EXPORT_SYMBOL(sock_i_ino);
1862 EXPORT_SYMBOL(sysctl_optmem_max);
1863 #ifdef CONFIG_SYSCTL
1864 EXPORT_SYMBOL(sysctl_rmem_max);
1865 EXPORT_SYMBOL(sysctl_wmem_max);
1866 #endif