]>
Commit | Line | Data |
---|---|---|
7c657876 ACM |
1 | /* |
2 | * net/dccp/minisocks.c | |
3 | * | |
4 | * An implementation of the DCCP protocol | |
5 | * Arnaldo Carvalho de Melo <acme@conectiva.com.br> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU General Public License | |
9 | * as published by the Free Software Foundation; either version | |
10 | * 2 of the License, or (at your option) any later version. | |
11 | */ | |
12 | ||
7c657876 | 13 | #include <linux/dccp.h> |
5a0e3ad6 | 14 | #include <linux/gfp.h> |
8a73cd09 | 15 | #include <linux/kernel.h> |
7c657876 ACM |
16 | #include <linux/skbuff.h> |
17 | #include <linux/timer.h> | |
18 | ||
19 | #include <net/sock.h> | |
20 | #include <net/xfrm.h> | |
21 | #include <net/inet_timewait_sock.h> | |
22 | ||
ae31c339 | 23 | #include "ackvec.h" |
7c657876 ACM |
24 | #include "ccid.h" |
25 | #include "dccp.h" | |
afe00251 | 26 | #include "feat.h" |
7c657876 | 27 | |
64cf1e5d ACM |
28 | struct inet_timewait_death_row dccp_death_row = { |
29 | .sysctl_max_tw_buckets = NR_FILE * 2, | |
30 | .period = DCCP_TIMEWAIT_LEN / INET_TWDR_TWKILL_SLOTS, | |
4ef8d0ae | 31 | .death_lock = __SPIN_LOCK_UNLOCKED(dccp_death_row.death_lock), |
64cf1e5d ACM |
32 | .hashinfo = &dccp_hashinfo, |
33 | .tw_timer = TIMER_INITIALIZER(inet_twdr_hangman, 0, | |
34 | (unsigned long)&dccp_death_row), | |
35 | .twkill_work = __WORK_INITIALIZER(dccp_death_row.twkill_work, | |
c4028958 | 36 | inet_twdr_twkill_work), |
64cf1e5d ACM |
37 | /* Short-time timewait calendar */ |
38 | ||
39 | .twcal_hand = -1, | |
40 | .twcal_timer = TIMER_INITIALIZER(inet_twdr_twcal_tick, 0, | |
41 | (unsigned long)&dccp_death_row), | |
42 | }; | |
43 | ||
f21e68ca ACM |
44 | EXPORT_SYMBOL_GPL(dccp_death_row); |
45 | ||
7c657876 ACM |
46 | void dccp_time_wait(struct sock *sk, int state, int timeo) |
47 | { | |
64cf1e5d | 48 | struct inet_timewait_sock *tw = NULL; |
7c657876 | 49 | |
64cf1e5d ACM |
50 | if (dccp_death_row.tw_count < dccp_death_row.sysctl_max_tw_buckets) |
51 | tw = inet_twsk_alloc(sk, state); | |
52 | ||
53 | if (tw != NULL) { | |
54 | const struct inet_connection_sock *icsk = inet_csk(sk); | |
55 | const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1); | |
dfd56b8b | 56 | #if IS_ENABLED(CONFIG_IPV6) |
3df80d93 ACM |
57 | if (tw->tw_family == PF_INET6) { |
58 | const struct ipv6_pinfo *np = inet6_sk(sk); | |
64cf1e5d | 59 | |
efe4208f ED |
60 | tw->tw_v6_daddr = sk->sk_v6_daddr; |
61 | tw->tw_v6_rcv_saddr = sk->sk_v6_rcv_saddr; | |
3df80d93 ACM |
62 | tw->tw_ipv6only = np->ipv6only; |
63 | } | |
64 | #endif | |
64cf1e5d ACM |
65 | /* Linkage updates. */ |
66 | __inet_twsk_hashdance(tw, sk, &dccp_hashinfo); | |
67 | ||
68 | /* Get the TIME_WAIT timeout firing. */ | |
69 | if (timeo < rto) | |
70 | timeo = rto; | |
71 | ||
72 | tw->tw_timeout = DCCP_TIMEWAIT_LEN; | |
73 | if (state == DCCP_TIME_WAIT) | |
74 | timeo = DCCP_TIMEWAIT_LEN; | |
75 | ||
76 | inet_twsk_schedule(tw, &dccp_death_row, timeo, | |
77 | DCCP_TIMEWAIT_LEN); | |
78 | inet_twsk_put(tw); | |
79 | } else { | |
80 | /* Sorry, if we're out of memory, just CLOSE this | |
81 | * socket up. We've got bigger problems than | |
82 | * non-graceful socket closings. | |
83 | */ | |
59348b19 | 84 | DCCP_WARN("time wait bucket table overflow\n"); |
64cf1e5d ACM |
85 | } |
86 | ||
87 | dccp_done(sk); | |
7c657876 ACM |
88 | } |
89 | ||
90 | struct sock *dccp_create_openreq_child(struct sock *sk, | |
91 | const struct request_sock *req, | |
92 | const struct sk_buff *skb) | |
93 | { | |
94 | /* | |
95 | * Step 3: Process LISTEN state | |
96 | * | |
d83ca5ac GR |
97 | * (* Generate a new socket and switch to that socket *) |
98 | * Set S := new socket for this port pair | |
7c657876 | 99 | */ |
e56c57d0 | 100 | struct sock *newsk = inet_csk_clone_lock(sk, req, GFP_ATOMIC); |
7c657876 ACM |
101 | |
102 | if (newsk != NULL) { | |
192b27ff | 103 | struct dccp_request_sock *dreq = dccp_rsk(req); |
99c72ce0 | 104 | struct inet_connection_sock *newicsk = inet_csk(newsk); |
7c657876 ACM |
105 | struct dccp_sock *newdp = dccp_sk(newsk); |
106 | ||
b4d4f7c7 GR |
107 | newdp->dccps_role = DCCP_ROLE_SERVER; |
108 | newdp->dccps_hc_rx_ackvec = NULL; | |
109 | newdp->dccps_service_list = NULL; | |
110 | newdp->dccps_service = dreq->dreq_service; | |
111 | newdp->dccps_timestamp_echo = dreq->dreq_timestamp_echo; | |
112 | newdp->dccps_timestamp_time = dreq->dreq_timestamp_time; | |
113 | newicsk->icsk_rto = DCCP_TIMEOUT_INIT; | |
7c657876 | 114 | |
ac75773c | 115 | INIT_LIST_HEAD(&newdp->dccps_featneg); |
7c657876 ACM |
116 | /* |
117 | * Step 3: Process LISTEN state | |
118 | * | |
d83ca5ac GR |
119 | * Choose S.ISS (initial seqno) or set from Init Cookies |
120 | * Initialize S.GAR := S.ISS | |
0b53d460 GR |
121 | * Set S.ISR, S.GSR from packet (or Init Cookies) |
122 | * | |
123 | * Setting AWL/AWH and SWL/SWH happens as part of the feature | |
124 | * activation below, as these windows all depend on the local | |
125 | * and remote Sequence Window feature values (7.5.2). | |
03ace394 | 126 | */ |
f541fb7e SJ |
127 | newdp->dccps_iss = dreq->dreq_iss; |
128 | newdp->dccps_gss = dreq->dreq_gss; | |
0b53d460 | 129 | newdp->dccps_gar = newdp->dccps_iss; |
f541fb7e SJ |
130 | newdp->dccps_isr = dreq->dreq_isr; |
131 | newdp->dccps_gsr = dreq->dreq_gsr; | |
03ace394 | 132 | |
192b27ff | 133 | /* |
0b53d460 | 134 | * Activate features: initialise CCIDs, sequence windows etc. |
192b27ff GR |
135 | */ |
136 | if (dccp_feat_activate_values(newsk, &dreq->dreq_featneg)) { | |
137 | /* It is still raw copy of parent, so invalidate | |
138 | * destructor and make plain sk_free() */ | |
139 | newsk->sk_destruct = NULL; | |
140 | sk_free(newsk); | |
141 | return NULL; | |
142 | } | |
7c657876 ACM |
143 | dccp_init_xmit_timers(newsk); |
144 | ||
145 | DCCP_INC_STATS_BH(DCCP_MIB_PASSIVEOPENS); | |
146 | } | |
147 | return newsk; | |
148 | } | |
149 | ||
f21e68ca ACM |
150 | EXPORT_SYMBOL_GPL(dccp_create_openreq_child); |
151 | ||
8109b02b | 152 | /* |
7c657876 ACM |
153 | * Process an incoming packet for RESPOND sockets represented |
154 | * as an request_sock. | |
155 | */ | |
156 | struct sock *dccp_check_req(struct sock *sk, struct sk_buff *skb, | |
157 | struct request_sock *req, | |
158 | struct request_sock **prev) | |
159 | { | |
160 | struct sock *child = NULL; | |
8109616e | 161 | struct dccp_request_sock *dreq = dccp_rsk(req); |
7c657876 ACM |
162 | |
163 | /* Check for retransmitted REQUEST */ | |
164 | if (dccp_hdr(skb)->dccph_type == DCCP_PKT_REQUEST) { | |
7c657876 | 165 | |
f541fb7e | 166 | if (after48(DCCP_SKB_CB(skb)->dccpd_seq, dreq->dreq_gsr)) { |
7c657876 | 167 | dccp_pr_debug("Retransmitted REQUEST\n"); |
f541fb7e | 168 | dreq->dreq_gsr = DCCP_SKB_CB(skb)->dccpd_seq; |
e11d9d30 GR |
169 | /* |
170 | * Send another RESPONSE packet | |
171 | * To protect against Request floods, increment retrans | |
172 | * counter (backoff, monitored by dccp_response_timer). | |
173 | */ | |
e6c022a4 | 174 | inet_rtx_syn_ack(sk, req); |
7c657876 ACM |
175 | } |
176 | /* Network Duplicate, discard packet */ | |
177 | return NULL; | |
178 | } | |
179 | ||
180 | DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_PACKET_ERROR; | |
181 | ||
182 | if (dccp_hdr(skb)->dccph_type != DCCP_PKT_ACK && | |
183 | dccp_hdr(skb)->dccph_type != DCCP_PKT_DATAACK) | |
184 | goto drop; | |
185 | ||
186 | /* Invalid ACK */ | |
f541fb7e SJ |
187 | if (!between48(DCCP_SKB_CB(skb)->dccpd_ack_seq, |
188 | dreq->dreq_iss, dreq->dreq_gss)) { | |
7690af3f | 189 | dccp_pr_debug("Invalid ACK number: ack_seq=%llu, " |
f541fb7e | 190 | "dreq_iss=%llu, dreq_gss=%llu\n", |
f6ccf554 DM |
191 | (unsigned long long) |
192 | DCCP_SKB_CB(skb)->dccpd_ack_seq, | |
f541fb7e SJ |
193 | (unsigned long long) dreq->dreq_iss, |
194 | (unsigned long long) dreq->dreq_gss); | |
7c657876 ACM |
195 | goto drop; |
196 | } | |
197 | ||
8109616e GR |
198 | if (dccp_parse_options(sk, dreq, skb)) |
199 | goto drop; | |
200 | ||
57cca05a | 201 | child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL); |
7c657876 ACM |
202 | if (child == NULL) |
203 | goto listen_overflow; | |
204 | ||
7c657876 ACM |
205 | inet_csk_reqsk_queue_unlink(sk, req, prev); |
206 | inet_csk_reqsk_queue_removed(sk, req); | |
207 | inet_csk_reqsk_queue_add(sk, req, child); | |
208 | out: | |
209 | return child; | |
210 | listen_overflow: | |
211 | dccp_pr_debug("listen_overflow!\n"); | |
212 | DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY; | |
213 | drop: | |
214 | if (dccp_hdr(skb)->dccph_type != DCCP_PKT_RESET) | |
cfb6eeb4 | 215 | req->rsk_ops->send_reset(sk, skb); |
7c657876 ACM |
216 | |
217 | inet_csk_reqsk_queue_drop(sk, req, prev); | |
218 | goto out; | |
219 | } | |
220 | ||
f21e68ca ACM |
221 | EXPORT_SYMBOL_GPL(dccp_check_req); |
222 | ||
7c657876 ACM |
223 | /* |
224 | * Queue segment on the new socket if the new socket is active, | |
225 | * otherwise we just shortcircuit this and continue with | |
226 | * the new socket. | |
227 | */ | |
228 | int dccp_child_process(struct sock *parent, struct sock *child, | |
229 | struct sk_buff *skb) | |
230 | { | |
231 | int ret = 0; | |
232 | const int state = child->sk_state; | |
233 | ||
234 | if (!sock_owned_by_user(child)) { | |
7690af3f ACM |
235 | ret = dccp_rcv_state_process(child, skb, dccp_hdr(skb), |
236 | skb->len); | |
7c657876 ACM |
237 | |
238 | /* Wakeup parent, send SIGIO */ | |
239 | if (state == DCCP_RESPOND && child->sk_state != state) | |
676d2369 | 240 | parent->sk_data_ready(parent); |
7c657876 ACM |
241 | } else { |
242 | /* Alas, it is possible again, because we do lookup | |
243 | * in main socket hash table and lock on listening | |
244 | * socket does not protect us more. | |
245 | */ | |
a3a858ff | 246 | __sk_add_backlog(child, skb); |
7c657876 ACM |
247 | } |
248 | ||
249 | bh_unlock_sock(child); | |
250 | sock_put(child); | |
251 | return ret; | |
252 | } | |
f21e68ca ACM |
253 | |
254 | EXPORT_SYMBOL_GPL(dccp_child_process); | |
8a73cd09 | 255 | |
6edafaaf GJ |
256 | void dccp_reqsk_send_ack(struct sock *sk, struct sk_buff *skb, |
257 | struct request_sock *rsk) | |
8a73cd09 | 258 | { |
59348b19 | 259 | DCCP_BUG("DCCP-ACK packets are never sent in LISTEN/RESPOND state"); |
8a73cd09 GR |
260 | } |
261 | ||
262 | EXPORT_SYMBOL_GPL(dccp_reqsk_send_ack); | |
cf557926 | 263 | |
ac75773c GR |
264 | int dccp_reqsk_init(struct request_sock *req, |
265 | struct dccp_sock const *dp, struct sk_buff const *skb) | |
cf557926 | 266 | { |
b4d4f7c7 GR |
267 | struct dccp_request_sock *dreq = dccp_rsk(req); |
268 | ||
b44084c2 ED |
269 | inet_rsk(req)->ir_rmt_port = dccp_hdr(skb)->dccph_sport; |
270 | inet_rsk(req)->ir_num = ntohs(dccp_hdr(skb)->dccph_dport); | |
271 | inet_rsk(req)->acked = 0; | |
272 | dreq->dreq_timestamp_echo = 0; | |
ac75773c GR |
273 | |
274 | /* inherit feature negotiation options from listening socket */ | |
275 | return dccp_feat_clone_list(&dp->dccps_featneg, &dreq->dreq_featneg); | |
cf557926 GR |
276 | } |
277 | ||
278 | EXPORT_SYMBOL_GPL(dccp_reqsk_init); |