/* * 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 TCP module. * * Version: @(#)tcp.h 1.0.5 05/23/93 * * Authors: Ross Biro, * Fred N. van Kempen, * * 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 _TCP_H #define _TCP_H #include #include /* This is for all connections with a full identity, no wildcards. */ #define TCP_HTABLE_SIZE 256 /* This is for listening sockets, thus all sockets which possess wildcards. */ #define TCP_LHTABLE_SIZE 32 /* Yes, really, this is all you need. */ /* This is for all sockets, to keep track of the local port allocations. */ #define TCP_BHTABLE_SIZE 64 /* tcp_ipv4.c: These need to be shared by v4 and v6 because the lookup * and hashing code needs to work with different AF's yet * the port space is shared. */ extern struct sock *tcp_established_hash[TCP_HTABLE_SIZE]; extern struct sock *tcp_listening_hash[TCP_LHTABLE_SIZE]; extern struct sock *tcp_bound_hash[TCP_BHTABLE_SIZE]; /* These are AF independant. */ static __inline__ int tcp_bhashfn(__u16 lport) { return (lport ^ (lport >> 7)) & (TCP_BHTABLE_SIZE-1); } /* Find the next port that hashes h that is larger than lport. * If you change the hash, change this function to match, or you will * break TCP port selection. This function must also NOT wrap around * when the next number exceeds the largest possible port (2^16-1). */ static __inline__ int tcp_bhashnext(__u16 lport, __u16 h) { __u32 s; /* don't change this to a smaller type! */ s = (lport ^ (h ^ tcp_bhashfn(lport))); if (s > lport) return s; s = lport + TCP_BHTABLE_SIZE; return (s ^ (h ^ tcp_bhashfn(s))); } static __inline__ int tcp_sk_bhashfn(struct sock *sk) { __u16 lport = sk->num; return tcp_bhashfn(lport); } /* These can have wildcards, don't try too hard. * XXX deal with thousands of IP aliases for listening ports later */ static __inline__ int tcp_lhashfn(unsigned short num) { return num & (TCP_LHTABLE_SIZE - 1); } static __inline__ int tcp_sk_listen_hashfn(struct sock *sk) { return tcp_lhashfn(sk->num); } /* This is IPv4 specific. */ static __inline__ int tcp_hashfn(__u32 laddr, __u16 lport, __u32 faddr, __u16 fport) { return ((laddr ^ lport) ^ (faddr ^ fport)) & (TCP_HTABLE_SIZE - 1); } static __inline__ int tcp_sk_hashfn(struct sock *sk) { __u32 laddr = sk->rcv_saddr; __u16 lport = sk->num; __u32 faddr = sk->daddr; __u16 fport = sk->dummy_th.dest; return tcp_hashfn(laddr, lport, faddr, fport); } /* Only those holding the sockhash lock call these two things here. * Note the slightly gross overloading of sk->prev, AF_UNIX is the * only other main benefactor of that member of SK, so who cares. */ static __inline__ void tcp_sk_bindify(struct sock *sk) { int hashent = tcp_sk_bhashfn(sk); struct sock **htable = &tcp_bound_hash[hashent]; if((sk->bind_next = *htable) != NULL) (*htable)->bind_pprev = &sk->bind_next; *htable = sk; sk->bind_pprev = htable; } static __inline__ void tcp_sk_unbindify(struct sock *sk) { if(sk->bind_next) sk->bind_next->bind_pprev = sk->bind_pprev; *(sk->bind_pprev) = sk->bind_next; } /* * 40 is maximal IP options size * 4 is TCP option size (MSS) */ #define MAX_SYN_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + 4 + MAX_HEADER + 15) #define MAX_FIN_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15) #define MAX_ACK_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15) #define MAX_RESET_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15) #define MAX_WINDOW 32767 /* Never offer a window over 32767 without using window scaling (not yet supported). Some poor stacks do signed 16bit maths! */ #define MIN_WINDOW 2048 #define MAX_ACK_BACKLOG 2 #define MAX_DUP_ACKS 3 #define MIN_WRITE_SPACE 2048 #define TCP_WINDOW_DIFF 2048 /* urg_data states */ #define URG_VALID 0x0100 #define URG_NOTYET 0x0200 #define URG_READ 0x0400 #define TCP_RETR1 7 /* * This is how many retries it does before it * tries to figure out if the gateway is * down. */ #define TCP_RETR2 15 /* * This should take at least * 90 minutes to time out. */ #define TCP_TIMEOUT_LEN (15*60*HZ) /* should be about 15 mins */ #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to successfully * close the socket, about 60 seconds */ #define TCP_FIN_TIMEOUT (3*60*HZ) /* BSD style FIN_WAIT2 deadlock breaker */ #define TCP_ACK_TIME (3*HZ) /* time to delay before sending an ACK */ #define TCP_DONE_TIME (5*HZ/2)/* maximum time to wait before actually * destroying a socket */ #define TCP_WRITE_TIME (30*HZ) /* initial time to wait for an ACK, * after last transmit */ #define TCP_TIMEOUT_INIT (3*HZ) /* RFC 1122 initial timeout value */ #define TCP_SYN_RETRIES 5 /* number of times to retry opening a * connection (TCP_RETR2-....) */ #define TCP_PROBEWAIT_LEN (1*HZ)/* time to wait between probes when * I've got something to write and * there is no window */ #define TCP_NO_CHECK 0 /* turn to one if you want the default * to be no checksum */ /* * TCP option */ #define TCPOPT_NOP 1 /* Padding */ #define TCPOPT_EOL 0 /* End of options */ #define TCPOPT_MSS 2 /* Segment size negotiating */ /* * We don't use these yet, but they are for PAWS and big windows */ #define TCPOPT_WINDOW 3 /* Window scaling */ #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ /* * The next routines deal with comparing 32 bit unsigned ints * and worry about wraparound (automatic with unsigned arithmetic). */ extern __inline int before(__u32 seq1, __u32 seq2) { return (__s32)(seq1-seq2) < 0; } extern __inline int after(__u32 seq1, __u32 seq2) { return (__s32)(seq2-seq1) < 0; } /* is s2<=s1<=s3 ? */ extern __inline int between(__u32 seq1, __u32 seq2, __u32 seq3) { return (after(seq1+1, seq2) && before(seq1, seq3+1)); } static __inline__ int min(unsigned int a, unsigned int b) { if (a > b) a = b; return a; } static __inline__ int max(unsigned int a, unsigned int b) { if (a < b) a = b; return a; } extern struct proto tcp_prot; extern struct tcp_mib tcp_statistics; extern unsigned short tcp_good_socknum(void); extern void tcp_err(int type, int code, unsigned char *header, __u32 daddr, __u32, struct inet_protocol *protocol, int len); extern void tcp_shutdown (struct sock *sk, int how); extern int tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, __u32 daddr, unsigned short len, __u32 saddr, int redo, struct inet_protocol *protocol); extern int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg); extern void tcp_v4_unhash(struct sock *sk); extern void tcp_read_wakeup(struct sock *); extern void tcp_write_xmit(struct sock *); extern void tcp_time_wait(struct sock *); extern void tcp_retransmit(struct sock *, int); extern void tcp_do_retransmit(struct sock *, int); extern void tcp_send_check(struct tcphdr *th, unsigned long saddr, unsigned long daddr, int len, struct sk_buff *skb); /* tcp_output.c */ extern void tcp_send_probe0(struct sock *); extern void tcp_send_partial(struct sock *); extern void tcp_write_wakeup(struct sock *); extern void tcp_send_fin(struct sock *sk); extern void tcp_send_synack(struct sock *, struct sock *, struct sk_buff *, int); extern void tcp_send_skb(struct sock *, struct sk_buff *); extern void tcp_send_ack(struct sock *sk); extern void tcp_send_delayed_ack(struct sock *sk, int max_timeout, unsigned long timeout); extern void tcp_send_reset(unsigned long saddr, unsigned long daddr, struct tcphdr *th, struct proto *prot, struct options *opt, struct device *dev, int tos, int ttl); extern void tcp_enqueue_partial(struct sk_buff *, struct sock *); extern struct sk_buff * tcp_dequeue_partial(struct sock *); extern void tcp_shrink_skb(struct sock *,struct sk_buff *,u32); /* CONFIG_IP_TRANSPARENT_PROXY */ extern int tcp_chkaddr(struct sk_buff *); /* tcp_timer.c */ #define tcp_reset_msl_timer(x,y,z) reset_timer(x,y,z) extern void tcp_reset_xmit_timer(struct sock *, int, unsigned long); extern void tcp_delack_timer(unsigned long); extern void tcp_retransmit_timer(unsigned long); static __inline__ int tcp_old_window(struct sock * sk) { return sk->window - (sk->acked_seq - sk->lastwin_seq); } extern int tcp_new_window(struct sock *); /* * Return true if we should raise the window when we * have cleaned up the receive queue. We don't want to * do this normally, only if it makes sense to avoid * zero window probes.. * * We do this only if we can raise the window noticeably. */ static __inline__ int tcp_raise_window(struct sock * sk) { int new = tcp_new_window(sk); return new && (new >= 2*tcp_old_window(sk)); } static __inline__ unsigned short tcp_select_window(struct sock *sk) { int window = tcp_new_window(sk); int oldwin = tcp_old_window(sk); /* Don't allow a shrinking window */ if (window > oldwin) { sk->window = window; sk->lastwin_seq = sk->acked_seq; oldwin = window; } return oldwin; } /* * List all states of a TCP socket that can be viewed as a "connected" * state. This now includes TCP_SYN_RECV, although I am not yet fully * convinced that this is the solution for the 'getpeername(2)' * problem. Thanks to Stephen A. Wood -FvK */ extern __inline const int tcp_connected(const int state) { return(state == TCP_ESTABLISHED || state == TCP_CLOSE_WAIT || state == TCP_FIN_WAIT1 || state == TCP_FIN_WAIT2 || state == TCP_SYN_RECV); } /* * Calculate(/check) TCP checksum */ static __inline__ u16 tcp_check(struct tcphdr *th, int len, unsigned long saddr, unsigned long daddr, unsigned long base) { return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base); } #undef STATE_TRACE #ifdef STATE_TRACE static char *statename[]={ "Unused","Established","Syn Sent","Syn Recv", "Fin Wait 1","Fin Wait 2","Time Wait", "Close", "Close Wait","Last ACK","Listen","Closing" }; #endif static __inline__ void tcp_set_state(struct sock *sk, int state) { int oldstate = sk->state; sk->state = state; #ifdef STATE_TRACE if(sk->debug) printk("TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]); #endif switch (state) { case TCP_ESTABLISHED: if (oldstate != TCP_ESTABLISHED) { tcp_statistics.TcpCurrEstab++; } break; case TCP_CLOSE: /* Preserve the invariant */ tcp_v4_unhash(sk); /* Should be about 2 rtt's */ reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME)); /* fall through */ default: if (oldstate==TCP_ESTABLISHED) tcp_statistics.TcpCurrEstab--; } } #endif /* _TCP_H */