diff options
author | Thomas Bushnell <thomas@gnu.org> | 1999-04-26 05:58:44 +0000 |
---|---|---|
committer | Thomas Bushnell <thomas@gnu.org> | 1999-04-26 05:58:44 +0000 |
commit | 86297c41a26f18d924e64fc93321c59cbc4c48dd (patch) | |
tree | 376954c6b95b735d361875319a1a2a9db6a27527 /linux/src/include/net/tcp.h | |
parent | 851137902d3e7ad87af177487df3eea53e940a1c (diff) |
1998-11-30 OKUJI Yoshinori <okuji@kuicr.kyoto-u.ac.jp>
Clean up linux emulation code to make it architecture-independent
as much as possible.
* linux: Renamed from linuxdev.
* Makefile.in (objfiles): Add linux.o instead of linuxdev.o.
(MAKE): New variable. Used for the linux.o target.
* configure.in: Add AC_CHECK_TOOL(MAKE, make).
* i386/i386/spl.h: Include <i386/ipl.h>, for compatibility with
OSF Mach 3.0. Suggested by Elgin Lee <ehl@funghi.com>.
* linux/src: Renamed from linux/linux.
* linux/dev: Renamed from linux/mach.
* linux/Drivers.in (AC_INIT): Use dev/include/linux/autoconf.h,
instead of mach/include/linux/autoconf.h.
* Makefile.in (all): Target ../linux.o instead of ../linuxdev.o.
* linux/dev/drivers/block/genhd.c: Include <machine/spl.h> instead
of <i386/ipl.h>.
* linux/dev/drivers/net/auto_irq.c: Remove unneeded header files,
<i386/ipl.h> and <i386/pic.h>.
* linux/dev/init/main.c: Many i386-dependent codes moved to ...
* linux/dev/arch/i386/irq.c: ... here.
* linux/dev/arch/i386/setup.c: New file.
* linux/dev/arch/i386/linux_emul.h: Likewise.
* linux/dev/arch/i386/glue/timer.c: Merged into sched.c.
* linux/dev/arch/i386/glue/sched.c: Include <machine/spl.h> instead
of <i386/ipl.h>, and moved to ...
* linux/dev/kernel/sched.c: ... here.
* linux/dev/arch/i386/glue/block.c: Include <machine/spl.h> and
<linux_emul.h>, instead of i386-dependent header files, and
moved to ...
* linux/dev/glue/blocl.c: ... here.
* linux/dev/arch/i386/glue/net.c: Include <machine/spl.h> and
<linux_emul.h>, instead of i386-dependent header files, and
moved to ...
* linux/dev/glue/net.c: ... here.
* linux/dev/arch/i386/glue/misc.c: Remove `x86' and moved to ...
* linux/dev/glue/misc.c: ... here.
* linux/dev/arch/i386/glue/kmem.c: Moved to ...
* linux/dev/glue/kmem.c: ... here.
Diffstat (limited to 'linux/src/include/net/tcp.h')
-rw-r--r-- | linux/src/include/net/tcp.h | 374 |
1 files changed, 374 insertions, 0 deletions
diff --git a/linux/src/include/net/tcp.h b/linux/src/include/net/tcp.h new file mode 100644 index 0000000..b2534ba --- /dev/null +++ b/linux/src/include/net/tcp.h @@ -0,0 +1,374 @@ +/* + * 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, <bir7@leland.Stanford.Edu> + * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> + * + * 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 <linux/tcp.h> +#include <net/checksum.h> + +/* 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 <saw@cebaf.gov> -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 */ |