xref: /openbmc/linux/net/dccp/minisocks.c (revision 9ac8d3fb)
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 
13 #include <linux/dccp.h>
14 #include <linux/kernel.h>
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 
22 #include "ackvec.h"
23 #include "ccid.h"
24 #include "dccp.h"
25 #include "feat.h"
26 
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,
30 	.death_lock	= __SPIN_LOCK_UNLOCKED(dccp_death_row.death_lock),
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,
35 					     inet_twdr_twkill_work),
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 
43 EXPORT_SYMBOL_GPL(dccp_death_row);
44 
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 
55 void dccp_time_wait(struct sock *sk, int state, int timeo)
56 {
57 	struct inet_timewait_sock *tw = NULL;
58 
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);
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;
69 
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
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 		 */
96 		DCCP_WARN("time wait bucket table overflow\n");
97 	}
98 
99 	dccp_done(sk);
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 	 *
109 	 *   (* Generate a new socket and switch to that socket *)
110 	 *   Set S := new socket for this port pair
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);
116 		struct inet_connection_sock *newicsk = inet_csk(newsk);
117 		struct dccp_sock *newdp = dccp_sk(newsk);
118 		struct dccp_minisock *newdmsk = dccp_msk(newsk);
119 
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;
127 
128 		if (dccp_feat_clone(sk, newsk))
129 			goto out_free;
130 
131 		if (newdmsk->dccpms_send_ack_vector) {
132 			newdp->dccps_hc_rx_ackvec =
133 						dccp_ackvec_alloc(GFP_ATOMIC);
134 			if (unlikely(newdp->dccps_hc_rx_ackvec == NULL))
135 				goto out_free;
136 		}
137 
138 		newdp->dccps_hc_rx_ccid =
139 			    ccid_hc_rx_new(newdmsk->dccpms_rx_ccid,
140 					   newsk, GFP_ATOMIC);
141 		newdp->dccps_hc_tx_ccid =
142 			    ccid_hc_tx_new(newdmsk->dccpms_tx_ccid,
143 					   newsk, GFP_ATOMIC);
144 		if (unlikely(newdp->dccps_hc_rx_ccid == NULL ||
145 			     newdp->dccps_hc_tx_ccid == NULL)) {
146 			dccp_ackvec_free(newdp->dccps_hc_rx_ackvec);
147 			ccid_hc_rx_delete(newdp->dccps_hc_rx_ccid, newsk);
148 			ccid_hc_tx_delete(newdp->dccps_hc_tx_ccid, newsk);
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 
157 		/*
158 		 * Step 3: Process LISTEN state
159 		 *
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
163 		 */
164 
165 		/* See dccp_v4_conn_request */
166 		newdmsk->dccpms_sequence_window = req->rcv_wnd;
167 
168 		newdp->dccps_gar = newdp->dccps_iss = dreq->dreq_iss;
169 		dccp_update_gss(newsk, dreq->dreq_iss);
170 
171 		newdp->dccps_isr = dreq->dreq_isr;
172 		dccp_update_gsr(newsk, dreq->dreq_isr);
173 
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 
187 		dccp_init_xmit_timers(newsk);
188 
189 		DCCP_INC_STATS_BH(DCCP_MIB_PASSIVEOPENS);
190 	}
191 	return newsk;
192 }
193 
194 EXPORT_SYMBOL_GPL(dccp_create_openreq_child);
195 
196 /*
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;
205 	struct dccp_request_sock *dreq = dccp_rsk(req);
206 
207 	/* Check for retransmitted REQUEST */
208 	if (dccp_hdr(skb)->dccph_type == DCCP_PKT_REQUEST) {
209 
210 		if (after48(DCCP_SKB_CB(skb)->dccpd_seq, dreq->dreq_isr)) {
211 			dccp_pr_debug("Retransmitted REQUEST\n");
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++;
219 			req->rsk_ops->rtx_syn_ack(sk, req);
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 */
232 	if (DCCP_SKB_CB(skb)->dccpd_ack_seq != dreq->dreq_iss) {
233 		dccp_pr_debug("Invalid ACK number: ack_seq=%llu, "
234 			      "dreq_iss=%llu\n",
235 			      (unsigned long long)
236 			      DCCP_SKB_CB(skb)->dccpd_ack_seq,
237 			      (unsigned long long) dreq->dreq_iss);
238 		goto drop;
239 	}
240 
241 	if (dccp_parse_options(sk, dreq, skb))
242 		 goto drop;
243 
244 	child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
245 	if (child == NULL)
246 		goto listen_overflow;
247 
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)
258 		req->rsk_ops->send_reset(sk, skb);
259 
260 	inet_csk_reqsk_queue_drop(sk, req, prev);
261 	goto out;
262 }
263 
264 EXPORT_SYMBOL_GPL(dccp_check_req);
265 
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)) {
278 		ret = dccp_rcv_state_process(child, skb, dccp_hdr(skb),
279 					     skb->len);
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 }
296 
297 EXPORT_SYMBOL_GPL(dccp_child_process);
298 
299 void dccp_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
300 			 struct request_sock *rsk)
301 {
302 	DCCP_BUG("DCCP-ACK packets are never sent in LISTEN/RESPOND state");
303 }
304 
305 EXPORT_SYMBOL_GPL(dccp_reqsk_send_ack);
306 
307 void dccp_reqsk_init(struct request_sock *req, struct sk_buff *skb)
308 {
309 	struct dccp_request_sock *dreq = dccp_rsk(req);
310 
311 	inet_rsk(req)->rmt_port	  = dccp_hdr(skb)->dccph_sport;
312 	inet_rsk(req)->loc_port	  = dccp_hdr(skb)->dccph_dport;
313 	inet_rsk(req)->acked	  = 0;
314 	req->rcv_wnd		  = sysctl_dccp_feat_sequence_window;
315 	dreq->dreq_timestamp_echo = 0;
316 }
317 
318 EXPORT_SYMBOL_GPL(dccp_reqsk_init);
319