include/linux/net.h /* * INET An implementation of the TCP/IP protocol suite for the LINUX * operating system. INET is implemented using the BSD Socket * interface as the means of communication with the user level. * * Definitions for the AF_INET socket handler. * * Version: @(#)sock.h 1.0.4 05/13/93 * * Authors: Ross Biro, <[e-mail]> * Fred N. van Kempen, <[e-mail]> * Corey Minyard <wf-rch![e-mail]> * Florian La Roche <[e-mail]> * * Fixes: * Alan Cox : Volatiles in skbuff pointers. See * skbuff comments. May be overdone, * better to prove they can be removed * than the reverse. * Alan Cox : Added a zapped field for tcp to note * a socket is reset and must stay shut up * Alan Cox : New fields for options * Pauline Middelink : identd support * Alan Cox : Eliminate low level recv/recvfrom * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */ #ifndef _SOCK_H #define _SOCK_H #include <linux/timer.h> #include <linux/ip.h> /* struct options */ #include <linux/in.h> /* struct sockaddr_in */ #include <linux/tcp.h> /* struct tcphdr */ #include <linux/config.h> #include <linux/netdevice.h> #include <linux/skbuff.h> /* struct sk_buff */ #include <net/protocol.h> /* struct inet_protocol */ #ifdef CONFIG_AX25 #include <net/ax25.h> #ifdef CONFIG_NETROM #include <net/netrom.h> #endif #endif #if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE) #include <net/ipx.h> #endif #if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE) #include <linux/atalk.h> #endif #include <linux/igmp.h> #include <asm/atomic.h> /* Think big (also on some systems a byte is faster) */ #define SOCK_ARRAY_SIZE 256 /* * The AF_UNIX specific socket options */ struct unix_opt { int family; char * name; int locks; struct inode * inode; struct semaphore readsem; struct sock * other; int marksweep; #define MARKED 1 int inflight; }; /* * IP packet socket options */ struct inet_packet_opt { struct notifier_block notifier; /* Used when bound */ struct device *bound_dev; unsigned long dev_stamp; struct packet_type *prot_hook; char device_name[15]; }; /* * Once the IPX ncpd patches are in these are going into protinfo */ #if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE) struct ipx_opt { ipx_address dest_addr; ipx_interface *intrfc; unsigned short port; #ifdef CONFIG_IPX_INTERN unsigned char node[IPX_NODE_LEN]; #endif unsigned short type; /* * To handle asynchronous messages from the NetWare server, we have to * know the connection this socket belongs to. */ struct ncp_server *ncp_server; }; #endif #ifdef CONFIG_NUTCP struct tcp_opt { /* * RFC793 variables by their proper names. This means you can * read the code and the spec side by side (and laugh ...) * See RFC793 and RFC1122. The RFC writes these in capitals. */ __u32 rcv_nxt; /* What we want to receive next */ __u32 rcv_up; /* The urgent point (may not be valid) */ __u32 rcv_wnd; /* Current receiver window */ __u32 snd_nxt; /* Next sequence we send */ __u32 snd_una; /* First byte we want an ack for */ __u32 snd_up; /* Outgoing urgent pointer */ __u32 snd_wl1; /* Sequence for window update */ __u32 snd_wl2; /* Ack sequence for update */ /* * Slow start and congestion control (see also Nagle, and Karn & Partridge) */ __u32 snd_cwnd; /* Sending congestion window */ __u32 snd_ssthresh; /* Slow start size threshold */ /* * Timers used by the TCP protocol layer */ struct timer_list delack_timer; /* Ack delay */ struct timer_list idle_timer; /* Idle watch */ struct timer_list completion_timer; /* Up/Down timer */ struct timer_list probe_timer; /* Probes */ struct timer_list retransmit_timer; /* Resend (no ack) */ }; #endif /* * This structure really needs to be cleaned up. * Most of it is for TCP, and not used by any of * the other protocols. */ struct sock { struct options *opt; atomic_t wmem_alloc; atomic_t rmem_alloc; unsigned long allocation; /* Allocation mode */ __u32 write_seq; __u32 sent_seq; __u32 acked_seq; __u32 copied_seq; __u32 rcv_ack_seq; unsigned short rcv_ack_cnt; /* count of same ack */ __u32 window_seq; __u32 fin_seq; __u32 urg_seq; __u32 urg_data; int users; /* user count */ /* * Not all are volatile, but some are, so we * might as well say they all are. */ volatile char dead, urginline, intr, blog, done, reuse, keepopen, linger, delay_acks, destroy, ack_timed, no_check, zapped, /* In ax25 & ipx means not linked */ broadcast, nonagle, bsdism; unsigned long lingertime; int proc; struct sock *next; struct sock *prev; /* Doubly linked chain.. */ struct sock *pair; struct sk_buff * volatile send_head; struct sk_buff * volatile send_next; struct sk_buff * volatile send_tail; struct sk_buff_head back_log; struct sk_buff *partial; struct timer_list partial_timer; long retransmits; struct sk_buff_head write_queue, receive_queue; struct proto *prot; struct wait_queue **sleep; __u32 daddr; __u32 saddr; /* Sending source */ __u32 rcv_saddr; /* Bound address */ unsigned short max_unacked; unsigned short window; __u32 lastwin_seq; /* sequence number when we last updated the window we offer */ __u32 high_seq; /* sequence number when we did current fast retransmit */ volatile unsigned long ato; /* ack timeout */ volatile unsigned long lrcvtime; /* jiffies at last data rcv */ volatile unsigned long idletime; /* jiffies at last rcv */ unsigned short bytes_rcv; /* * mss is min(mtu, max_window) */ unsigned short mtu; /* mss negotiated in the syn's */ volatile unsigned short mss; /* current eff. mss - can change */ volatile unsigned short user_mss; /* mss requested by user in ioctl */ volatile unsigned short max_window; unsigned long window_clamp; unsigned int ssthresh; unsigned short num; volatile unsigned short cong_window; volatile unsigned short cong_count; volatile unsigned short packets_out; volatile unsigned short shutdown; volatile unsigned long rtt; volatile unsigned long mdev; volatile unsigned long rto; /* * currently backoff isn't used, but I'm maintaining it in case * we want to go back to a backoff formula that needs it */ volatile unsigned short backoff; int err, err_soft; /* Soft holds errors that don't cause failure but are the cause of a persistent failure not just 'timed out' */ unsigned char protocol; volatile unsigned char state; unsigned char ack_backlog; unsigned char max_ack_backlog; unsigned char priority; unsigned char debug; unsigned short rcvbuf; unsigned short sndbuf; unsigned short type; unsigned char localroute; /* Route locally only */ #ifdef CONFIG_AX25 ax25_cb *ax25; #ifdef CONFIG_NETROM nr_cb *nr; #endif #endif /* * This is where all the private (optional) areas that don't * overlap will eventually live. */ union { struct unix_opt af_unix; #if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE) struct atalk_sock af_at; #endif #if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE) struct ipx_opt af_ipx; #endif #ifdef CONFIG_INET struct inet_packet_opt af_packet; #ifdef CONFIG_NUTCP struct tcp_opt af_tcp; #endif #endif } protinfo; /* * IP 'private area' or will be eventually */ int ip_ttl; /* TTL setting */ int ip_tos; /* TOS */ struct tcphdr dummy_th; struct timer_list keepalive_timer; /* TCP keepalive hack */ struct timer_list retransmit_timer; /* TCP retransmit timer */ struct timer_list delack_timer; /* TCP delayed ack timer */ int ip_xmit_timeout; /* Why the timeout is running */ struct rtable *ip_route_cache; /* Cached output route */ unsigned char ip_hdrincl; /* Include headers ? */ #ifdef CONFIG_IP_MULTICAST int ip_mc_ttl; /* Multicasting TTL */ int ip_mc_loop; /* Loopback */ char ip_mc_name[MAX_ADDR_LEN];/* Multicast device name */ struct ip_mc_socklist *ip_mc_list; /* Group array */ #endif /* * This part is used for the timeout functions (timer.c). */ int timeout; /* What are we waiting for? */ struct timer_list timer; /* This is the TIME_WAIT/receive timer * when we are doing IP */ struct timeval stamp; /* * Identd */ struct socket *socket; /* * Callbacks */ void (*state_change)(struct sock *sk); void (*data_ready)(struct sock *sk,int bytes); void (*write_space)(struct sock *sk); void (*error_report)(struct sock *sk); }; /* * IP protocol blocks we attach to sockets. */ struct proto { void (*close)(struct sock *sk, unsigned long timeout); int (*build_header)(struct sk_buff *skb, __u32 saddr, __u32 daddr, struct device **dev, int type, struct options *opt, int len, int tos, int ttl, struct rtable ** rp); int (*connect)(struct sock *sk, struct sockaddr_in *usin, int addr_len); struct sock * (*accept) (struct sock *sk, int flags); void (*queue_xmit)(struct sock *sk, struct device *dev, struct sk_buff *skb, int free); void (*retransmit)(struct sock *sk, int all); void (*write_wakeup)(struct sock *sk); void (*read_wakeup)(struct sock *sk); int (*rcv)(struct sk_buff *buff, struct device *dev, struct options *opt, __u32 daddr, unsigned short len, __u32 saddr, int redo, struct inet_protocol *protocol); int (*select)(struct sock *sk, int which, select_table *wait); int (*ioctl)(struct sock *sk, int cmd, unsigned long arg); int (*init)(struct sock *sk); void (*shutdown)(struct sock *sk, int how); int (*setsockopt)(struct sock *sk, int level, int optname, char *optval, int optlen); int (*getsockopt)(struct sock *sk, int level, int optname, char *optval, int *option); int (*sendmsg)(struct sock *sk, struct msghdr *msg, int len, int noblock, int flags); int (*recvmsg)(struct sock *sk, struct msghdr *msg, int len, int noblock, int flags, int *addr_len); int (*bind)(struct sock *sk, struct sockaddr *uaddr, int addr_len); unsigned short max_header; unsigned long retransmits; char name[32]; int inuse, highestinuse; struct sock * sock_array[SOCK_ARRAY_SIZE]; }; #define TIME_WRITE 1 #define TIME_CLOSE 2 #define TIME_KEEPOPEN 3 #define TIME_DESTROY 4 #define TIME_DONE 5 /* Used to absorb those last few packets */ #define TIME_PROBE0 6 /* * About 10 seconds */ #define SOCK_DESTROY_TIME (10*HZ) /* * Sockets 0-1023 can't be bound to unless you are superuser */ #define PROT_SOCK 1024 #define SHUTDOWN_MASK 3 #define RCV_SHUTDOWN 1 #define SEND_SHUTDOWN 2 /* * Used by processes to "lock" a socket state, so that * interrupts and bottom half handlers won't change it * from under us. It essentially blocks any incoming * packets, so that we won't get any new data or any * packets that change the state of the socket. * * Note the 'barrier()' calls: gcc may not move a lock * "downwards" or a unlock "upwards" when optimizing. */ extern void __release_sock(struct sock *sk); static inline void lock_sock(struct sock *sk) { #if 0 /* debugging code: the test isn't even 100% correct, but it can catch bugs */ /* Note that a double lock is ok in theory - it's just _usually_ a bug */ if (sk->users) { __label__ here; printk("double lock on socket at %p\n", &&here); here: } #endif sk->users++; barrier(); } static inline void release_sock(struct sock *sk) { barrier(); #if 0 /* debugging code: remove me when ok */ if (sk->users == 0) { __label__ here; sk->users = 1; printk("trying to unlock unlocked socket at %p\n", &&here); here: } #endif if ((sk->users = sk->users-1) == 0) __release_sock(sk); } extern struct sock * sk_alloc(int priority); extern void sk_free(struct sock *sk); extern void destroy_sock(struct sock *sk); extern unsigned short get_new_socknum(struct proto *, unsigned short); extern void put_sock(unsigned short, struct sock *); extern struct sock *get_sock(struct proto *, unsigned short, unsigned long, unsigned short, unsigned long, unsigned long, unsigned short); extern struct sock *get_sock_mcast(struct sock *, unsigned short, unsigned long, unsigned short, unsigned long); extern struct sock *get_sock_raw(struct sock *, unsigned short, unsigned long, unsigned long); extern struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority); extern struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority); extern void sock_wfree(struct sock *sk, struct sk_buff *skb); extern void sock_rfree(struct sock *sk, struct sk_buff *skb); extern unsigned long sock_rspace(struct sock *sk); extern unsigned long sock_wspace(struct sock *sk); extern int sock_setsockopt(struct sock *sk, int level, int op, char *optval, int optlen); extern int sock_getsockopt(struct sock *sk, int level, int op, char *optval, int *optlen); extern struct sk_buff *sock_alloc_send_skb(struct sock *skb, unsigned long size, unsigned long fallback, int noblock, int *errcode); /* * Queue a received datagram if it will fit. Stream and sequenced * protocols can't normally use this as they need to fit buffers in * and play with them. * * Inlined as it's very short and called for pretty much every * packet ever received. */ extern __inline__ int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) { if (sk->rmem_alloc + skb->truesize >= sk->rcvbuf) return -ENOMEM; atomic_add(skb->truesize, &sk->rmem_alloc); skb->sk=sk; skb_queue_tail(&sk->receive_queue,skb); if (!sk->dead) sk->data_ready(sk,skb->len); return 0; } extern __inline__ int __sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) { if (sk->rmem_alloc + skb->truesize >= sk->rcvbuf) return -ENOMEM; atomic_add(skb->truesize, &sk->rmem_alloc); skb->sk=sk; __skb_queue_tail(&sk->receive_queue,skb); if (!sk->dead) sk->data_ready(sk,skb->len); return 0; } /* * Recover an error report and clear atomically */ extern __inline__ int sock_error(struct sock *sk) { int err=xchg(&sk->err,0); return -err; } /* * Declarations from timer.c */ extern struct sock *timer_base; extern void delete_timer (struct sock *); extern void reset_timer (struct sock *, int, unsigned long); extern void net_timer (unsigned long); /* * Enable debug/info messages */ #define NETDEBUG(x) do { } while (0) #endif /* _SOCK_H */