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