tcp_ipv4.c (e21e696edb498c7f7eed42ba3096f6bbe13927b6) tcp_ipv4.c (3ab5aee7fe840b5b1b35a8d1ac11c3de5281e611)
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 * Implementation of the Transmission Control Protocol(TCP).
7 *
8 * IPv4 specific functions

--- 1125 unchanged lines hidden (view full) ---

1134 * so we need to calculate the checksum.
1135 */
1136 genhash = tcp_v4_md5_hash_skb(newhash,
1137 hash_expected,
1138 NULL, NULL, skb);
1139
1140 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1141 if (net_ratelimit()) {
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 * Implementation of the Transmission Control Protocol(TCP).
7 *
8 * IPv4 specific functions

--- 1125 unchanged lines hidden (view full) ---

1134 * so we need to calculate the checksum.
1135 */
1136 genhash = tcp_v4_md5_hash_skb(newhash,
1137 hash_expected,
1138 NULL, NULL, skb);
1139
1140 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1141 if (net_ratelimit()) {
1142 printk(KERN_INFO "MD5 Hash failed for "
1143 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)%s\n",
1144 NIPQUAD(iph->saddr), ntohs(th->source),
1145 NIPQUAD(iph->daddr), ntohs(th->dest),
1142 printk(KERN_INFO "MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1143 &iph->saddr, ntohs(th->source),
1144 &iph->daddr, ntohs(th->dest),
1146 genhash ? " tcp_v4_calc_md5_hash failed" : "");
1147 }
1148 return 1;
1149 }
1150 return 0;
1151}
1152
1153#endif

--- 138 unchanged lines hidden (view full) ---

1292 (!dst || !dst_metric(dst, RTAX_RTT))) {
1293 /* Without syncookies last quarter of
1294 * backlog is filled with destinations,
1295 * proven to be alive.
1296 * It means that we continue to communicate
1297 * to destinations, already remembered
1298 * to the moment of synflood.
1299 */
1145 genhash ? " tcp_v4_calc_md5_hash failed" : "");
1146 }
1147 return 1;
1148 }
1149 return 0;
1150}
1151
1152#endif

--- 138 unchanged lines hidden (view full) ---

1291 (!dst || !dst_metric(dst, RTAX_RTT))) {
1292 /* Without syncookies last quarter of
1293 * backlog is filled with destinations,
1294 * proven to be alive.
1295 * It means that we continue to communicate
1296 * to destinations, already remembered
1297 * to the moment of synflood.
1298 */
1300 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
1301 "request from " NIPQUAD_FMT "/%u\n",
1302 NIPQUAD(saddr),
1303 ntohs(tcp_hdr(skb)->source));
1299 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n",
1300 &saddr, ntohs(tcp_hdr(skb)->source));
1304 goto drop_and_release;
1305 }
1306
1307 isn = tcp_v4_init_sequence(skb);
1308 }
1309 tcp_rsk(req)->snt_isn = isn;
1310
1311 if (__tcp_v4_send_synack(sk, req, dst) || want_cookie)

--- 543 unchanged lines hidden (view full) ---

1855 atomic_dec(&tcp_sockets_allocated);
1856}
1857
1858EXPORT_SYMBOL(tcp_v4_destroy_sock);
1859
1860#ifdef CONFIG_PROC_FS
1861/* Proc filesystem TCP sock list dumping. */
1862
1301 goto drop_and_release;
1302 }
1303
1304 isn = tcp_v4_init_sequence(skb);
1305 }
1306 tcp_rsk(req)->snt_isn = isn;
1307
1308 if (__tcp_v4_send_synack(sk, req, dst) || want_cookie)

--- 543 unchanged lines hidden (view full) ---

1852 atomic_dec(&tcp_sockets_allocated);
1853}
1854
1855EXPORT_SYMBOL(tcp_v4_destroy_sock);
1856
1857#ifdef CONFIG_PROC_FS
1858/* Proc filesystem TCP sock list dumping. */
1859
1863static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1860static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
1864{
1861{
1865 return hlist_empty(head) ? NULL :
1862 return hlist_nulls_empty(head) ? NULL :
1866 list_entry(head->first, struct inet_timewait_sock, tw_node);
1867}
1868
1869static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1870{
1863 list_entry(head->first, struct inet_timewait_sock, tw_node);
1864}
1865
1866static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1867{
1871 return tw->tw_node.next ?
1872 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1868 return !is_a_nulls(tw->tw_node.next) ?
1869 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1873}
1874
1875static void *listening_get_next(struct seq_file *seq, void *cur)
1876{
1877 struct inet_connection_sock *icsk;
1878 struct hlist_node *node;
1879 struct sock *sk = cur;
1870}
1871
1872static void *listening_get_next(struct seq_file *seq, void *cur)
1873{
1874 struct inet_connection_sock *icsk;
1875 struct hlist_node *node;
1876 struct sock *sk = cur;
1880 struct tcp_iter_state* st = seq->private;
1877 struct tcp_iter_state *st = seq->private;
1881 struct net *net = seq_file_net(seq);
1882
1883 if (!sk) {
1884 st->bucket = 0;
1885 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1886 goto get_sk;
1887 }
1888

--- 63 unchanged lines hidden (view full) ---

1952 rc = listening_get_next(seq, rc);
1953 --*pos;
1954 }
1955 return rc;
1956}
1957
1958static inline int empty_bucket(struct tcp_iter_state *st)
1959{
1878 struct net *net = seq_file_net(seq);
1879
1880 if (!sk) {
1881 st->bucket = 0;
1882 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1883 goto get_sk;
1884 }
1885

--- 63 unchanged lines hidden (view full) ---

1949 rc = listening_get_next(seq, rc);
1950 --*pos;
1951 }
1952 return rc;
1953}
1954
1955static inline int empty_bucket(struct tcp_iter_state *st)
1956{
1960 return hlist_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
1961 hlist_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
1957 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
1958 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
1962}
1963
1964static void *established_get_first(struct seq_file *seq)
1965{
1959}
1960
1961static void *established_get_first(struct seq_file *seq)
1962{
1966 struct tcp_iter_state* st = seq->private;
1963 struct tcp_iter_state *st = seq->private;
1967 struct net *net = seq_file_net(seq);
1968 void *rc = NULL;
1969
1970 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
1971 struct sock *sk;
1964 struct net *net = seq_file_net(seq);
1965 void *rc = NULL;
1966
1967 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
1968 struct sock *sk;
1972 struct hlist_node *node;
1969 struct hlist_nulls_node *node;
1973 struct inet_timewait_sock *tw;
1974 rwlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
1975
1976 /* Lockless fast path for the common case of empty buckets */
1977 if (empty_bucket(st))
1978 continue;
1979
1980 read_lock_bh(lock);
1970 struct inet_timewait_sock *tw;
1971 rwlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
1972
1973 /* Lockless fast path for the common case of empty buckets */
1974 if (empty_bucket(st))
1975 continue;
1976
1977 read_lock_bh(lock);
1981 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
1978 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
1982 if (sk->sk_family != st->family ||
1983 !net_eq(sock_net(sk), net)) {
1984 continue;
1985 }
1986 rc = sk;
1987 goto out;
1988 }
1989 st->state = TCP_SEQ_STATE_TIME_WAIT;

--- 12 unchanged lines hidden (view full) ---

2002out:
2003 return rc;
2004}
2005
2006static void *established_get_next(struct seq_file *seq, void *cur)
2007{
2008 struct sock *sk = cur;
2009 struct inet_timewait_sock *tw;
1979 if (sk->sk_family != st->family ||
1980 !net_eq(sock_net(sk), net)) {
1981 continue;
1982 }
1983 rc = sk;
1984 goto out;
1985 }
1986 st->state = TCP_SEQ_STATE_TIME_WAIT;

--- 12 unchanged lines hidden (view full) ---

1999out:
2000 return rc;
2001}
2002
2003static void *established_get_next(struct seq_file *seq, void *cur)
2004{
2005 struct sock *sk = cur;
2006 struct inet_timewait_sock *tw;
2010 struct hlist_node *node;
2011 struct tcp_iter_state* st = seq->private;
2007 struct hlist_nulls_node *node;
2008 struct tcp_iter_state *st = seq->private;
2012 struct net *net = seq_file_net(seq);
2013
2014 ++st->num;
2015
2016 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2017 tw = cur;
2018 tw = tw_next(tw);
2019get_tw:

--- 10 unchanged lines hidden (view full) ---

2030 /* Look for next non empty bucket */
2031 while (++st->bucket < tcp_hashinfo.ehash_size &&
2032 empty_bucket(st))
2033 ;
2034 if (st->bucket >= tcp_hashinfo.ehash_size)
2035 return NULL;
2036
2037 read_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2009 struct net *net = seq_file_net(seq);
2010
2011 ++st->num;
2012
2013 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2014 tw = cur;
2015 tw = tw_next(tw);
2016get_tw:

--- 10 unchanged lines hidden (view full) ---

2027 /* Look for next non empty bucket */
2028 while (++st->bucket < tcp_hashinfo.ehash_size &&
2029 empty_bucket(st))
2030 ;
2031 if (st->bucket >= tcp_hashinfo.ehash_size)
2032 return NULL;
2033
2034 read_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2038 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
2035 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
2039 } else
2036 } else
2040 sk = sk_next(sk);
2037 sk = sk_nulls_next(sk);
2041
2038
2042 sk_for_each_from(sk, node) {
2039 sk_nulls_for_each_from(sk, node) {
2043 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
2044 goto found;
2045 }
2046
2047 st->state = TCP_SEQ_STATE_TIME_WAIT;
2048 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
2049 goto get_tw;
2050found:

--- 11 unchanged lines hidden (view full) ---

2062 --pos;
2063 }
2064 return rc;
2065}
2066
2067static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2068{
2069 void *rc;
2040 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
2041 goto found;
2042 }
2043
2044 st->state = TCP_SEQ_STATE_TIME_WAIT;
2045 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
2046 goto get_tw;
2047found:

--- 11 unchanged lines hidden (view full) ---

2059 --pos;
2060 }
2061 return rc;
2062}
2063
2064static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2065{
2066 void *rc;
2070 struct tcp_iter_state* st = seq->private;
2067 struct tcp_iter_state *st = seq->private;
2071
2072 inet_listen_lock(&tcp_hashinfo);
2073 st->state = TCP_SEQ_STATE_LISTENING;
2074 rc = listening_get_idx(seq, &pos);
2075
2076 if (!rc) {
2077 inet_listen_unlock(&tcp_hashinfo);
2078 st->state = TCP_SEQ_STATE_ESTABLISHED;
2079 rc = established_get_idx(seq, pos);
2080 }
2081
2082 return rc;
2083}
2084
2085static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2086{
2068
2069 inet_listen_lock(&tcp_hashinfo);
2070 st->state = TCP_SEQ_STATE_LISTENING;
2071 rc = listening_get_idx(seq, &pos);
2072
2073 if (!rc) {
2074 inet_listen_unlock(&tcp_hashinfo);
2075 st->state = TCP_SEQ_STATE_ESTABLISHED;
2076 rc = established_get_idx(seq, pos);
2077 }
2078
2079 return rc;
2080}
2081
2082static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2083{
2087 struct tcp_iter_state* st = seq->private;
2084 struct tcp_iter_state *st = seq->private;
2088 st->state = TCP_SEQ_STATE_LISTENING;
2089 st->num = 0;
2090 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2091}
2092
2093static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2094{
2095 void *rc = NULL;
2085 st->state = TCP_SEQ_STATE_LISTENING;
2086 st->num = 0;
2087 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2088}
2089
2090static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2091{
2092 void *rc = NULL;
2096 struct tcp_iter_state* st;
2093 struct tcp_iter_state *st;
2097
2098 if (v == SEQ_START_TOKEN) {
2099 rc = tcp_get_idx(seq, 0);
2100 goto out;
2101 }
2102 st = seq->private;
2103
2104 switch (st->state) {

--- 13 unchanged lines hidden (view full) ---

2118 }
2119out:
2120 ++*pos;
2121 return rc;
2122}
2123
2124static void tcp_seq_stop(struct seq_file *seq, void *v)
2125{
2094
2095 if (v == SEQ_START_TOKEN) {
2096 rc = tcp_get_idx(seq, 0);
2097 goto out;
2098 }
2099 st = seq->private;
2100
2101 switch (st->state) {

--- 13 unchanged lines hidden (view full) ---

2115 }
2116out:
2117 ++*pos;
2118 return rc;
2119}
2120
2121static void tcp_seq_stop(struct seq_file *seq, void *v)
2122{
2126 struct tcp_iter_state* st = seq->private;
2123 struct tcp_iter_state *st = seq->private;
2127
2128 switch (st->state) {
2129 case TCP_SEQ_STATE_OPENREQ:
2130 if (v) {
2131 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2132 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2133 }
2134 case TCP_SEQ_STATE_LISTENING:

--- 144 unchanged lines hidden (view full) ---

2279 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2280 atomic_read(&tw->tw_refcnt), tw, len);
2281}
2282
2283#define TMPSZ 150
2284
2285static int tcp4_seq_show(struct seq_file *seq, void *v)
2286{
2124
2125 switch (st->state) {
2126 case TCP_SEQ_STATE_OPENREQ:
2127 if (v) {
2128 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2129 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2130 }
2131 case TCP_SEQ_STATE_LISTENING:

--- 144 unchanged lines hidden (view full) ---

2276 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2277 atomic_read(&tw->tw_refcnt), tw, len);
2278}
2279
2280#define TMPSZ 150
2281
2282static int tcp4_seq_show(struct seq_file *seq, void *v)
2283{
2287 struct tcp_iter_state* st;
2284 struct tcp_iter_state *st;
2288 int len;
2289
2290 if (v == SEQ_START_TOKEN) {
2291 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2292 " sl local_address rem_address st tx_queue "
2293 "rx_queue tr tm->when retrnsmt uid timeout "
2294 "inode");
2295 goto out;

--- 77 unchanged lines hidden (view full) ---

2373 .orphan_count = &tcp_orphan_count,
2374 .memory_allocated = &tcp_memory_allocated,
2375 .memory_pressure = &tcp_memory_pressure,
2376 .sysctl_mem = sysctl_tcp_mem,
2377 .sysctl_wmem = sysctl_tcp_wmem,
2378 .sysctl_rmem = sysctl_tcp_rmem,
2379 .max_header = MAX_TCP_HEADER,
2380 .obj_size = sizeof(struct tcp_sock),
2285 int len;
2286
2287 if (v == SEQ_START_TOKEN) {
2288 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2289 " sl local_address rem_address st tx_queue "
2290 "rx_queue tr tm->when retrnsmt uid timeout "
2291 "inode");
2292 goto out;

--- 77 unchanged lines hidden (view full) ---

2370 .orphan_count = &tcp_orphan_count,
2371 .memory_allocated = &tcp_memory_allocated,
2372 .memory_pressure = &tcp_memory_pressure,
2373 .sysctl_mem = sysctl_tcp_mem,
2374 .sysctl_wmem = sysctl_tcp_wmem,
2375 .sysctl_rmem = sysctl_tcp_rmem,
2376 .max_header = MAX_TCP_HEADER,
2377 .obj_size = sizeof(struct tcp_sock),
2378 .slab_flags = SLAB_DESTROY_BY_RCU,
2381 .twsk_prot = &tcp_timewait_sock_ops,
2382 .rsk_prot = &tcp_request_sock_ops,
2383 .h.hashinfo = &tcp_hashinfo,
2384#ifdef CONFIG_COMPAT
2385 .compat_setsockopt = compat_tcp_setsockopt,
2386 .compat_getsockopt = compat_tcp_getsockopt,
2387#endif
2388};

--- 41 unchanged lines hidden --- 		2379 .twsk_prot = &tcp_timewait_sock_ops,
2380 .rsk_prot = &tcp_request_sock_ops,
2381 .h.hashinfo = &tcp_hashinfo,
2382#ifdef CONFIG_COMPAT
2383 .compat_setsockopt = compat_tcp_setsockopt,
2384 .compat_getsockopt = compat_tcp_getsockopt,
2385#endif
2386};

--- 41 unchanged lines hidden ---