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> |
8a73cd09 | 14 | #include <linux/kernel.h> |
7c657876 ACM |
15 | #include <linux/skbuff.h> |
16 | #include <linux/timer.h> | |
17 | ||
18 | #include <net/sock.h> | |
19 | #include <net/xfrm.h> | |
20 | #include <net/inet_timewait_sock.h> | |
21 | ||
ae31c339 | 22 | #include "ackvec.h" |
7c657876 ACM |
23 | #include "ccid.h" |
24 | #include "dccp.h" | |
afe00251 | 25 | #include "feat.h" |
7c657876 | 26 | |
64cf1e5d ACM |
27 | struct inet_timewait_death_row dccp_death_row = { |
28 | .sysctl_max_tw_buckets = NR_FILE * 2, | |
29 | .period = DCCP_TIMEWAIT_LEN / INET_TWDR_TWKILL_SLOTS, | |
4ef8d0ae | 30 | .death_lock = __SPIN_LOCK_UNLOCKED(dccp_death_row.death_lock), |
64cf1e5d ACM |
31 | .hashinfo = &dccp_hashinfo, |
32 | .tw_timer = TIMER_INITIALIZER(inet_twdr_hangman, 0, | |
33 | (unsigned long)&dccp_death_row), | |
34 | .twkill_work = __WORK_INITIALIZER(dccp_death_row.twkill_work, | |
c4028958 | 35 | inet_twdr_twkill_work), |
64cf1e5d ACM |
36 | /* Short-time timewait calendar */ |
37 | ||
38 | .twcal_hand = -1, | |
39 | .twcal_timer = TIMER_INITIALIZER(inet_twdr_twcal_tick, 0, | |
40 | (unsigned long)&dccp_death_row), | |
41 | }; | |
42 | ||
f21e68ca ACM |
43 | EXPORT_SYMBOL_GPL(dccp_death_row); |
44 | ||
451bc047 GR |
45 | void dccp_minisock_init(struct dccp_minisock *dmsk) |
46 | { | |
47 | dmsk->dccpms_sequence_window = sysctl_dccp_feat_sequence_window; | |
48 | dmsk->dccpms_rx_ccid = sysctl_dccp_feat_rx_ccid; | |
49 | dmsk->dccpms_tx_ccid = sysctl_dccp_feat_tx_ccid; | |
50 | dmsk->dccpms_ack_ratio = sysctl_dccp_feat_ack_ratio; | |
51 | dmsk->dccpms_send_ack_vector = sysctl_dccp_feat_send_ack_vector; | |
52 | dmsk->dccpms_send_ndp_count = sysctl_dccp_feat_send_ndp_count; | |
53 | } | |
54 | ||
7c657876 ACM |
55 | void dccp_time_wait(struct sock *sk, int state, int timeo) |
56 | { | |
64cf1e5d | 57 | struct inet_timewait_sock *tw = NULL; |
7c657876 | 58 | |
64cf1e5d ACM |
59 | if (dccp_death_row.tw_count < dccp_death_row.sysctl_max_tw_buckets) |
60 | tw = inet_twsk_alloc(sk, state); | |
61 | ||
62 | if (tw != NULL) { | |
63 | const struct inet_connection_sock *icsk = inet_csk(sk); | |
64 | const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1); | |
3df80d93 ACM |
65 | #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) |
66 | if (tw->tw_family == PF_INET6) { | |
67 | const struct ipv6_pinfo *np = inet6_sk(sk); | |
68 | struct inet6_timewait_sock *tw6; | |
64cf1e5d | 69 | |
3df80d93 ACM |
70 | tw->tw_ipv6_offset = inet6_tw_offset(sk->sk_prot); |
71 | tw6 = inet6_twsk((struct sock *)tw); | |
72 | ipv6_addr_copy(&tw6->tw_v6_daddr, &np->daddr); | |
73 | ipv6_addr_copy(&tw6->tw_v6_rcv_saddr, &np->rcv_saddr); | |
74 | tw->tw_ipv6only = np->ipv6only; | |
75 | } | |
76 | #endif | |
64cf1e5d ACM |
77 | /* Linkage updates. */ |
78 | __inet_twsk_hashdance(tw, sk, &dccp_hashinfo); | |
79 | ||
80 | /* Get the TIME_WAIT timeout firing. */ | |
81 | if (timeo < rto) | |
82 | timeo = rto; | |
83 | ||
84 | tw->tw_timeout = DCCP_TIMEWAIT_LEN; | |
85 | if (state == DCCP_TIME_WAIT) | |
86 | timeo = DCCP_TIMEWAIT_LEN; | |
87 | ||
88 | inet_twsk_schedule(tw, &dccp_death_row, timeo, | |
89 | DCCP_TIMEWAIT_LEN); | |
90 | inet_twsk_put(tw); | |
91 | } else { | |
92 | /* Sorry, if we're out of memory, just CLOSE this | |
93 | * socket up. We've got bigger problems than | |
94 | * non-graceful socket closings. | |
95 | */ | |
59348b19 | 96 | DCCP_WARN("time wait bucket table overflow\n"); |
64cf1e5d ACM |
97 | } |
98 | ||
99 | dccp_done(sk); | |
7c657876 ACM |
100 | } |
101 | ||
102 | struct sock *dccp_create_openreq_child(struct sock *sk, | |
103 | const struct request_sock *req, | |
104 | const struct sk_buff *skb) | |
105 | { | |
106 | /* | |
107 | * Step 3: Process LISTEN state | |
108 | * | |
d83ca5ac GR |
109 | * (* Generate a new socket and switch to that socket *) |
110 | * Set S := new socket for this port pair | |
7c657876 ACM |
111 | */ |
112 | struct sock *newsk = inet_csk_clone(sk, req, GFP_ATOMIC); | |
113 | ||
114 | if (newsk != NULL) { | |
115 | const struct dccp_request_sock *dreq = dccp_rsk(req); | |
99c72ce0 | 116 | struct inet_connection_sock *newicsk = inet_csk(newsk); |
7c657876 | 117 | struct dccp_sock *newdp = dccp_sk(newsk); |
a4bf3902 | 118 | struct dccp_minisock *newdmsk = dccp_msk(newsk); |
7c657876 | 119 | |
b4d4f7c7 GR |
120 | newdp->dccps_role = DCCP_ROLE_SERVER; |
121 | newdp->dccps_hc_rx_ackvec = NULL; | |
122 | newdp->dccps_service_list = NULL; | |
123 | newdp->dccps_service = dreq->dreq_service; | |
124 | newdp->dccps_timestamp_echo = dreq->dreq_timestamp_echo; | |
125 | newdp->dccps_timestamp_time = dreq->dreq_timestamp_time; | |
126 | newicsk->icsk_rto = DCCP_TIMEOUT_INIT; | |
7c657876 | 127 | |
afe00251 AB |
128 | if (dccp_feat_clone(sk, newsk)) |
129 | goto out_free; | |
130 | ||
a4bf3902 | 131 | if (newdmsk->dccpms_send_ack_vector) { |
ae31c339 | 132 | newdp->dccps_hc_rx_ackvec = |
7400d781 | 133 | dccp_ackvec_alloc(GFP_ATOMIC); |
ae31c339 | 134 | if (unlikely(newdp->dccps_hc_rx_ackvec == NULL)) |
7c657876 ACM |
135 | goto out_free; |
136 | } | |
137 | ||
91f0ebf7 | 138 | newdp->dccps_hc_rx_ccid = |
a4bf3902 | 139 | ccid_hc_rx_new(newdmsk->dccpms_rx_ccid, |
91f0ebf7 ACM |
140 | newsk, GFP_ATOMIC); |
141 | newdp->dccps_hc_tx_ccid = | |
a4bf3902 | 142 | ccid_hc_tx_new(newdmsk->dccpms_tx_ccid, |
91f0ebf7 ACM |
143 | newsk, GFP_ATOMIC); |
144 | if (unlikely(newdp->dccps_hc_rx_ccid == NULL || | |
145 | newdp->dccps_hc_tx_ccid == NULL)) { | |
ae31c339 | 146 | dccp_ackvec_free(newdp->dccps_hc_rx_ackvec); |
91f0ebf7 ACM |
147 | ccid_hc_rx_delete(newdp->dccps_hc_rx_ccid, newsk); |
148 | ccid_hc_tx_delete(newdp->dccps_hc_tx_ccid, newsk); | |
7c657876 ACM |
149 | out_free: |
150 | /* It is still raw copy of parent, so invalidate | |
151 | * destructor and make plain sk_free() */ | |
152 | newsk->sk_destruct = NULL; | |
153 | sk_free(newsk); | |
154 | return NULL; | |
155 | } | |
156 | ||
7c657876 ACM |
157 | /* |
158 | * Step 3: Process LISTEN state | |
159 | * | |
d83ca5ac GR |
160 | * Choose S.ISS (initial seqno) or set from Init Cookies |
161 | * Initialize S.GAR := S.ISS | |
162 | * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookies | |
7c657876 ACM |
163 | */ |
164 | ||
165 | /* See dccp_v4_conn_request */ | |
a4bf3902 | 166 | newdmsk->dccpms_sequence_window = req->rcv_wnd; |
7c657876 | 167 | |
be4c798a | 168 | newdp->dccps_gar = newdp->dccps_iss = dreq->dreq_iss; |
7c657876 ACM |
169 | dccp_update_gss(newsk, dreq->dreq_iss); |
170 | ||
be4c798a GR |
171 | newdp->dccps_isr = dreq->dreq_isr; |
172 | dccp_update_gsr(newsk, dreq->dreq_isr); | |
173 | ||
03ace394 ACM |
174 | /* |
175 | * SWL and AWL are initially adjusted so that they are not less than | |
176 | * the initial Sequence Numbers received and sent, respectively: | |
177 | * SWL := max(GSR + 1 - floor(W/4), ISR), | |
178 | * AWL := max(GSS - W' + 1, ISS). | |
179 | * These adjustments MUST be applied only at the beginning of the | |
180 | * connection. | |
181 | */ | |
182 | dccp_set_seqno(&newdp->dccps_swl, | |
183 | max48(newdp->dccps_swl, newdp->dccps_isr)); | |
184 | dccp_set_seqno(&newdp->dccps_awl, | |
185 | max48(newdp->dccps_awl, newdp->dccps_iss)); | |
186 | ||
7c657876 ACM |
187 | dccp_init_xmit_timers(newsk); |
188 | ||
189 | DCCP_INC_STATS_BH(DCCP_MIB_PASSIVEOPENS); | |
190 | } | |
191 | return newsk; | |
192 | } | |
193 | ||
f21e68ca ACM |
194 | EXPORT_SYMBOL_GPL(dccp_create_openreq_child); |
195 | ||
8109b02b | 196 | /* |
7c657876 ACM |
197 | * Process an incoming packet for RESPOND sockets represented |
198 | * as an request_sock. | |
199 | */ | |
200 | struct sock *dccp_check_req(struct sock *sk, struct sk_buff *skb, | |
201 | struct request_sock *req, | |
202 | struct request_sock **prev) | |
203 | { | |
204 | struct sock *child = NULL; | |
8109616e | 205 | struct dccp_request_sock *dreq = dccp_rsk(req); |
7c657876 ACM |
206 | |
207 | /* Check for retransmitted REQUEST */ | |
208 | if (dccp_hdr(skb)->dccph_type == DCCP_PKT_REQUEST) { | |
7c657876 | 209 | |
e11d9d30 | 210 | if (after48(DCCP_SKB_CB(skb)->dccpd_seq, dreq->dreq_isr)) { |
7c657876 | 211 | dccp_pr_debug("Retransmitted REQUEST\n"); |
e11d9d30 GR |
212 | dreq->dreq_isr = DCCP_SKB_CB(skb)->dccpd_seq; |
213 | /* | |
214 | * Send another RESPONSE packet | |
215 | * To protect against Request floods, increment retrans | |
216 | * counter (backoff, monitored by dccp_response_timer). | |
217 | */ | |
218 | req->retrans++; | |
fd80eb94 | 219 | req->rsk_ops->rtx_syn_ack(sk, req); |
7c657876 ACM |
220 | } |
221 | /* Network Duplicate, discard packet */ | |
222 | return NULL; | |
223 | } | |
224 | ||
225 | DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_PACKET_ERROR; | |
226 | ||
227 | if (dccp_hdr(skb)->dccph_type != DCCP_PKT_ACK && | |
228 | dccp_hdr(skb)->dccph_type != DCCP_PKT_DATAACK) | |
229 | goto drop; | |
230 | ||
231 | /* Invalid ACK */ | |
8109616e | 232 | if (DCCP_SKB_CB(skb)->dccpd_ack_seq != dreq->dreq_iss) { |
7690af3f ACM |
233 | dccp_pr_debug("Invalid ACK number: ack_seq=%llu, " |
234 | "dreq_iss=%llu\n", | |
f6ccf554 DM |
235 | (unsigned long long) |
236 | DCCP_SKB_CB(skb)->dccpd_ack_seq, | |
8109616e | 237 | (unsigned long long) dreq->dreq_iss); |
7c657876 ACM |
238 | goto drop; |
239 | } | |
240 | ||
8109616e GR |
241 | if (dccp_parse_options(sk, dreq, skb)) |
242 | goto drop; | |
243 | ||
57cca05a | 244 | child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL); |
7c657876 ACM |
245 | if (child == NULL) |
246 | goto listen_overflow; | |
247 | ||
7c657876 ACM |
248 | inet_csk_reqsk_queue_unlink(sk, req, prev); |
249 | inet_csk_reqsk_queue_removed(sk, req); | |
250 | inet_csk_reqsk_queue_add(sk, req, child); | |
251 | out: | |
252 | return child; | |
253 | listen_overflow: | |
254 | dccp_pr_debug("listen_overflow!\n"); | |
255 | DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY; | |
256 | drop: | |
257 | if (dccp_hdr(skb)->dccph_type != DCCP_PKT_RESET) | |
cfb6eeb4 | 258 | req->rsk_ops->send_reset(sk, skb); |
7c657876 ACM |
259 | |
260 | inet_csk_reqsk_queue_drop(sk, req, prev); | |
261 | goto out; | |
262 | } | |
263 | ||
f21e68ca ACM |
264 | EXPORT_SYMBOL_GPL(dccp_check_req); |
265 | ||
7c657876 ACM |
266 | /* |
267 | * Queue segment on the new socket if the new socket is active, | |
268 | * otherwise we just shortcircuit this and continue with | |
269 | * the new socket. | |
270 | */ | |
271 | int dccp_child_process(struct sock *parent, struct sock *child, | |
272 | struct sk_buff *skb) | |
273 | { | |
274 | int ret = 0; | |
275 | const int state = child->sk_state; | |
276 | ||
277 | if (!sock_owned_by_user(child)) { | |
7690af3f ACM |
278 | ret = dccp_rcv_state_process(child, skb, dccp_hdr(skb), |
279 | skb->len); | |
7c657876 ACM |
280 | |
281 | /* Wakeup parent, send SIGIO */ | |
282 | if (state == DCCP_RESPOND && child->sk_state != state) | |
283 | parent->sk_data_ready(parent, 0); | |
284 | } else { | |
285 | /* Alas, it is possible again, because we do lookup | |
286 | * in main socket hash table and lock on listening | |
287 | * socket does not protect us more. | |
288 | */ | |
289 | sk_add_backlog(child, skb); | |
290 | } | |
291 | ||
292 | bh_unlock_sock(child); | |
293 | sock_put(child); | |
294 | return ret; | |
295 | } | |
f21e68ca ACM |
296 | |
297 | EXPORT_SYMBOL_GPL(dccp_child_process); | |
8a73cd09 | 298 | |
6edafaaf GJ |
299 | void dccp_reqsk_send_ack(struct sock *sk, struct sk_buff *skb, |
300 | struct request_sock *rsk) | |
8a73cd09 | 301 | { |
59348b19 | 302 | DCCP_BUG("DCCP-ACK packets are never sent in LISTEN/RESPOND state"); |
8a73cd09 GR |
303 | } |
304 | ||
305 | EXPORT_SYMBOL_GPL(dccp_reqsk_send_ack); | |
cf557926 GR |
306 | |
307 | void dccp_reqsk_init(struct request_sock *req, struct sk_buff *skb) | |
308 | { | |
b4d4f7c7 GR |
309 | struct dccp_request_sock *dreq = dccp_rsk(req); |
310 | ||
311 | inet_rsk(req)->rmt_port = dccp_hdr(skb)->dccph_sport; | |
944f7502 | 312 | inet_rsk(req)->loc_port = dccp_hdr(skb)->dccph_dport; |
b4d4f7c7 GR |
313 | inet_rsk(req)->acked = 0; |
314 | req->rcv_wnd = sysctl_dccp_feat_sequence_window; | |
315 | dreq->dreq_timestamp_echo = 0; | |
cf557926 GR |
316 | } |
317 | ||
318 | EXPORT_SYMBOL_GPL(dccp_reqsk_init); |