Provided by: linux-doc-2.6.15_2.6.15-23.39_all bug

NAME

       struct sock - network layer representation of sockets

SYNOPSIS

       struct sock {
         struct sock_common __sk_common;
       #define sk_family        __sk_common.skc_family
       #define sk_state         __sk_common.skc_state
       #define sk_reuse         __sk_common.skc_reuse
       #define sk_bound_dev_if       __sk_common.skc_bound_dev_if
       #define sk_node               __sk_common.skc_node
       #define sk_bind_node          __sk_common.skc_bind_node
       #define sk_refcnt        __sk_common.skc_refcnt
       #define sk_hash               __sk_common.skc_hash
       #define sk_prot               __sk_common.skc_prot
         unsigned char sk_shutdown:2;
         unsigned char sk_no_check:2;
         unsigned char sk_userlocks:4;
         unsigned char sk_protocol;
         unsigned short sk_type;
         int sk_rcvbuf;
         socket_lock_t sk_lock;
         wait_queue_head_t * sk_sleep;
         struct dst_entry * sk_dst_cache;
         struct xfrm_policy * sk_policy[2];
         rwlock_t sk_dst_lock;
         atomic_t sk_rmem_alloc;
         atomic_t sk_wmem_alloc;
         atomic_t sk_omem_alloc;
         struct sk_buff_head sk_receive_queue;
         struct sk_buff_head sk_write_queue;
         int sk_wmem_queued;
         int sk_forward_alloc;
         gfp_t sk_allocation;
         int sk_sndbuf;
         int sk_route_caps;
         unsigned long sk_flags;
         unsigned long sk_lingertime;
         struct sk_backlog;
         struct sk_buff_head sk_error_queue;
         struct proto * sk_prot_creator;
         rwlock_t sk_callback_lock;
         int sk_err;
         int sk_err_soft;
         unsigned short sk_ack_backlog;
         unsigned short sk_max_ack_backlog;
         __u32 sk_priority;
         struct ucred sk_peercred;
         int sk_rcvlowat;
         long sk_rcvtimeo;
         long sk_sndtimeo;
         struct sk_filter * sk_filter;
         void * sk_protinfo;
         struct timer_list sk_timer;
         struct timeval sk_stamp;
         struct socket * sk_socket;
         void * sk_user_data;
         struct page * sk_sndmsg_page;
         struct sk_buff * sk_send_head;
         __u32 sk_sndmsg_off;
         int sk_write_pending;
         void * sk_security;
         void (* sk_state_change) (struct sock *sk);
         void (* sk_data_ready) (struct sock *sk, int bytes);
         void (* sk_write_space) (struct sock *sk);
         void (* sk_error_report) (struct sock *sk);
         int (* sk_backlog_rcv) (struct sock *sk,struct sk_buff *skb);
         void (* sk_destruct) (struct sock *sk);
       };

MEMBERS

       __sk_common
              shared layout with inet_timewait_sock

       sk_shutdown
              mask of SEND_SHUTDOWN and/or RCV_SHUTDOWN

       sk_no_check
               SO_NO_CHECK setting, wether or not checkup packets

       sk_userlocks
               SO_SNDBUF and SO_RCVBUF settings

       sk_protocol
              which protocol this socket belongs in this network family

       sk_type
              socket type (SOCK_STREAM, etc)

       sk_rcvbuf
              size of receive buffer in bytes

       sk_lock
              synchronizer

       sk_sleep
              sock wait queue

       sk_dst_cache
              destination cache

       sk_policy[2]
              flow policy

       sk_dst_lock
              destination cache lock

       sk_rmem_alloc
              receive queue bytes committed

       sk_wmem_alloc
              transmit queue bytes committed

       sk_omem_alloc
               ‘‘o’’ is ‘‘option’’ or ‘‘other’’

       sk_receive_queue
              incoming packets

       sk_write_queue
              Packet sending queue

       sk_wmem_queued
              persistent queue size

       sk_forward_alloc
              space allocated forward

       sk_allocation
              allocation mode

       sk_sndbuf
              size of send buffer in bytes

       sk_route_caps
              route capabilities (e.g. NETIF_F_TSO)

       sk_flags
               SO_LINGER  (l_onoff),  SO_BROADCAST, SO_KEEPALIVE, SO_OOBINLINE
              settings

       sk_lingertime
               SO_LINGER l_linger setting

       sk_backlog
              always used with the per-socket spinlock held

       sk_error_queue
              rarely used

       sk_prot_creator
              sk_prot  of  original   sock   creator   (see   ipv6_setsockopt,
              IPV6_ADDRFORM for instance)

       sk_callback_lock
              used with the callbacks in the end of this struct

       sk_err last error

       sk_err_soft
              errors  that  don’t  cause  failure  but  are  the  cause  of  a
              persistent failure not just ’timed out’

       sk_ack_backlog
              current listen backlog

       sk_max_ack_backlog
              listen backlog set in listen

       sk_priority
               SO_PRIORITY setting

       sk_peercred
               SO_PEERCRED setting

       sk_rcvlowat
               SO_RCVLOWAT setting

       sk_rcvtimeo
               SO_RCVTIMEO setting

       sk_sndtimeo
               SO_SNDTIMEO setting

       sk_filter
              socket filtering instructions

       sk_protinfo
              private area, net family specific, when not using slab

       sk_timer
              sock cleanup timer

       sk_stamp
              time stamp of last packet received

       sk_socket
              Identd and reporting IO signals

       sk_user_data
              RPC layer private data

       sk_sndmsg_page
              cached page for sendmsg

       sk_send_head
              front of stuff to transmit

       sk_sndmsg_off
              cached offset for sendmsg

       sk_write_pending
              a write to stream socket waits to start

       sk_security
              used by security modules

       sk_state_change
              callback to indicate change in the state of the sock

       sk_data_ready
              callback to indicate there is data to be processed

       sk_write_space
              callback to indicate there is bf sending space available

       sk_error_report
              callback to indicate errors (e.g. MSG_ERRQUEUE)

       sk_backlog_rcv
              callback to process the backlog

       sk_destruct
              called at sock freeing time, i.e. when all refcnt == 0