blob: 52a94016526d3c595a71f4affac1a24251f964d7 [file] [log] [blame]
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001/*
2 * net/dccp/proto.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 modify it
8 * under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070012#include <linux/dccp.h>
13#include <linux/module.h>
14#include <linux/types.h>
15#include <linux/sched.h>
16#include <linux/kernel.h>
17#include <linux/skbuff.h>
18#include <linux/netdevice.h>
19#include <linux/in.h>
20#include <linux/if_arp.h>
21#include <linux/init.h>
22#include <linux/random.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/slab.h>
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070024#include <net/checksum.h>
25
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020026#include <net/inet_sock.h>
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070027#include <net/sock.h>
28#include <net/xfrm.h>
29
Arnaldo Carvalho de Melo62731722007-10-23 20:23:30 -070030#include <asm/ioctls.h>
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070031#include <linux/spinlock.h>
32#include <linux/timer.h>
33#include <linux/delay.h>
34#include <linux/poll.h>
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070035
36#include "ccid.h"
37#include "dccp.h"
Andrea Bittauafe00252006-03-20 17:43:56 -080038#include "feat.h"
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070039
Eric Dumazetba899662005-08-26 12:05:31 -070040DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -070041
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -080042EXPORT_SYMBOL_GPL(dccp_statistics);
43
Eric Dumazetdd24c002008-11-25 21:17:14 -080044struct percpu_counter dccp_orphan_count;
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -080045EXPORT_SYMBOL_GPL(dccp_orphan_count);
46
Eric Dumazet5caea4e2008-11-20 00:40:07 -080047struct inet_hashinfo dccp_hashinfo;
Arnaldo Carvalho de Melo075ae862006-03-20 21:24:19 -080048EXPORT_SYMBOL_GPL(dccp_hashinfo);
49
Ian McDonaldb1308dc2006-11-20 18:30:17 -020050/* the maximum queue length for tx in packets. 0 is no limit */
51int sysctl_dccp_tx_qlen __read_mostly = 5;
52
stephen hemminger1f4f0f62010-10-05 04:24:09 +000053#ifdef CONFIG_IP_DCCP_DEBUG
54static const char *dccp_state_name(const int state)
55{
56 static const char *const dccp_state_names[] = {
57 [DCCP_OPEN] = "OPEN",
58 [DCCP_REQUESTING] = "REQUESTING",
59 [DCCP_PARTOPEN] = "PARTOPEN",
60 [DCCP_LISTEN] = "LISTEN",
61 [DCCP_RESPOND] = "RESPOND",
62 [DCCP_CLOSING] = "CLOSING",
63 [DCCP_ACTIVE_CLOSEREQ] = "CLOSEREQ",
64 [DCCP_PASSIVE_CLOSE] = "PASSIVE_CLOSE",
65 [DCCP_PASSIVE_CLOSEREQ] = "PASSIVE_CLOSEREQ",
66 [DCCP_TIME_WAIT] = "TIME_WAIT",
67 [DCCP_CLOSED] = "CLOSED",
68 };
69
70 if (state >= DCCP_MAX_STATES)
71 return "INVALID STATE!";
72 else
73 return dccp_state_names[state];
74}
75#endif
76
Arnaldo Carvalho de Meloc25a18b2006-03-20 21:58:56 -080077void dccp_set_state(struct sock *sk, const int state)
78{
79 const int oldstate = sk->sk_state;
80
Gerrit Renkerf11135a2007-11-28 11:34:53 -020081 dccp_pr_debug("%s(%p) %s --> %s\n", dccp_role(sk), sk,
Arnaldo Carvalho de Meloc25a18b2006-03-20 21:58:56 -080082 dccp_state_name(oldstate), dccp_state_name(state));
83 WARN_ON(state == oldstate);
84
85 switch (state) {
86 case DCCP_OPEN:
87 if (oldstate != DCCP_OPEN)
88 DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
Gerrit Renker6eb55d12008-12-08 01:15:26 -080089 /* Client retransmits all Confirm options until entering OPEN */
90 if (oldstate == DCCP_PARTOPEN)
91 dccp_feat_list_purge(&dccp_sk(sk)->dccps_featneg);
Arnaldo Carvalho de Meloc25a18b2006-03-20 21:58:56 -080092 break;
93
94 case DCCP_CLOSED:
Gerrit Renker0c869622007-11-28 11:59:48 -020095 if (oldstate == DCCP_OPEN || oldstate == DCCP_ACTIVE_CLOSEREQ ||
96 oldstate == DCCP_CLOSING)
Arnaldo Carvalho de Meloc25a18b2006-03-20 21:58:56 -080097 DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
98
99 sk->sk_prot->unhash(sk);
100 if (inet_csk(sk)->icsk_bind_hash != NULL &&
101 !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -0800102 inet_put_port(sk);
Arnaldo Carvalho de Meloc25a18b2006-03-20 21:58:56 -0800103 /* fall through */
104 default:
105 if (oldstate == DCCP_OPEN)
106 DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
107 }
108
109 /* Change state AFTER socket is unhashed to avoid closed
110 * socket sitting in hash tables.
111 */
112 sk->sk_state = state;
113}
114
115EXPORT_SYMBOL_GPL(dccp_set_state);
116
Gerrit Renker0c869622007-11-28 11:59:48 -0200117static void dccp_finish_passive_close(struct sock *sk)
118{
119 switch (sk->sk_state) {
120 case DCCP_PASSIVE_CLOSE:
121 /* Node (client or server) has received Close packet. */
122 dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
123 dccp_set_state(sk, DCCP_CLOSED);
124 break;
125 case DCCP_PASSIVE_CLOSEREQ:
126 /*
127 * Client received CloseReq. We set the `active' flag so that
128 * dccp_send_close() retransmits the Close as per RFC 4340, 8.3.
129 */
130 dccp_send_close(sk, 1);
131 dccp_set_state(sk, DCCP_CLOSING);
132 }
133}
134
Arnaldo Carvalho de Meloc25a18b2006-03-20 21:58:56 -0800135void dccp_done(struct sock *sk)
136{
137 dccp_set_state(sk, DCCP_CLOSED);
138 dccp_clear_xmit_timers(sk);
139
140 sk->sk_shutdown = SHUTDOWN_MASK;
141
142 if (!sock_flag(sk, SOCK_DEAD))
143 sk->sk_state_change(sk);
144 else
145 inet_csk_destroy_sock(sk);
146}
147
148EXPORT_SYMBOL_GPL(dccp_done);
149
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700150const char *dccp_packet_name(const int type)
151{
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -0700152 static const char *const dccp_packet_names[] = {
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700153 [DCCP_PKT_REQUEST] = "REQUEST",
154 [DCCP_PKT_RESPONSE] = "RESPONSE",
155 [DCCP_PKT_DATA] = "DATA",
156 [DCCP_PKT_ACK] = "ACK",
157 [DCCP_PKT_DATAACK] = "DATAACK",
158 [DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
159 [DCCP_PKT_CLOSE] = "CLOSE",
160 [DCCP_PKT_RESET] = "RESET",
161 [DCCP_PKT_SYNC] = "SYNC",
162 [DCCP_PKT_SYNCACK] = "SYNCACK",
163 };
164
165 if (type >= DCCP_NR_PKT_TYPES)
166 return "INVALID";
167 else
168 return dccp_packet_names[type];
169}
170
171EXPORT_SYMBOL_GPL(dccp_packet_name);
172
Arnaldo Carvalho de Melo72478872006-03-20 22:00:37 -0800173int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800174{
175 struct dccp_sock *dp = dccp_sk(sk);
176 struct inet_connection_sock *icsk = inet_csk(sk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800177
Arnaldo Carvalho de Meloe18d7a92007-11-24 21:42:53 -0200178 icsk->icsk_rto = DCCP_TIMEOUT_INIT;
179 icsk->icsk_syn_retries = sysctl_dccp_request_retries;
180 sk->sk_state = DCCP_CLOSED;
181 sk->sk_write_space = dccp_write_space;
182 icsk->icsk_sync_mss = dccp_sync_mss;
Gerrit Renker410e27a2008-09-09 13:27:22 +0200183 dp->dccps_mss_cache = 536;
Arnaldo Carvalho de Meloe18d7a92007-11-24 21:42:53 -0200184 dp->dccps_rate_last = jiffies;
185 dp->dccps_role = DCCP_ROLE_UNDEFINED;
186 dp->dccps_service = DCCP_SERVICE_CODE_IS_ABSENT;
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100187 dp->dccps_tx_qlen = sysctl_dccp_tx_qlen;
Arnaldo Carvalho de Meloe18d7a92007-11-24 21:42:53 -0200188
189 dccp_init_xmit_timers(sk);
190
Gerrit Renkerac757732008-11-04 23:55:49 -0800191 INIT_LIST_HEAD(&dp->dccps_featneg);
Gerrit Renker6eb55d12008-12-08 01:15:26 -0800192 /* control socket doesn't need feat nego */
193 if (likely(ctl_sock_initialized))
194 return dccp_feat_init(sk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800195 return 0;
196}
197
198EXPORT_SYMBOL_GPL(dccp_init_sock);
199
Brian Haley7d06b2e2008-06-14 17:04:49 -0700200void dccp_destroy_sock(struct sock *sk)
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800201{
202 struct dccp_sock *dp = dccp_sk(sk);
203
204 /*
205 * DCCP doesn't use sk_write_queue, just sk_send_head
206 * for retransmissions
207 */
208 if (sk->sk_send_head != NULL) {
209 kfree_skb(sk->sk_send_head);
210 sk->sk_send_head = NULL;
211 }
212
213 /* Clean up a referenced DCCP bind bucket. */
214 if (inet_csk(sk)->icsk_bind_hash != NULL)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -0800215 inet_put_port(sk);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800216
217 kfree(dp->dccps_service_list);
218 dp->dccps_service_list = NULL;
219
Gerrit Renker6fdd34d2008-12-08 01:19:06 -0800220 if (dp->dccps_hc_rx_ackvec != NULL) {
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800221 dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
222 dp->dccps_hc_rx_ackvec = NULL;
223 }
224 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
225 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
226 dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
227
228 /* clean up feature negotiation state */
Gerrit Renkerd99a7bd2008-11-04 23:56:30 -0800229 dccp_feat_list_purge(&dp->dccps_featneg);
Arnaldo Carvalho de Melo3e0fadc2006-03-20 21:23:15 -0800230}
231
232EXPORT_SYMBOL_GPL(dccp_destroy_sock);
233
Eric Dumazet72a3eff2006-11-16 02:30:37 -0800234static inline int dccp_listen_start(struct sock *sk, int backlog)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700235{
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700236 struct dccp_sock *dp = dccp_sk(sk);
237
238 dp->dccps_role = DCCP_ROLE_LISTEN;
Gerrit Renker9eca0a42008-11-12 00:48:44 -0800239 /* do not start to listen if feature negotiation setup fails */
240 if (dccp_feat_finalise_settings(dp))
241 return -EPROTO;
Eric Dumazet72a3eff2006-11-16 02:30:37 -0800242 return inet_csk_listen_start(sk, backlog);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700243}
244
Gerrit Renkerce865a62007-11-24 22:14:15 -0200245static inline int dccp_need_reset(int state)
246{
247 return state != DCCP_CLOSED && state != DCCP_LISTEN &&
248 state != DCCP_REQUESTING;
249}
250
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700251int dccp_disconnect(struct sock *sk, int flags)
252{
253 struct inet_connection_sock *icsk = inet_csk(sk);
254 struct inet_sock *inet = inet_sk(sk);
255 int err = 0;
256 const int old_state = sk->sk_state;
257
258 if (old_state != DCCP_CLOSED)
259 dccp_set_state(sk, DCCP_CLOSED);
260
Gerrit Renkerce865a62007-11-24 22:14:15 -0200261 /*
262 * This corresponds to the ABORT function of RFC793, sec. 3.8
263 * TCP uses a RST segment, DCCP a Reset packet with Code 2, "Aborted".
264 */
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700265 if (old_state == DCCP_LISTEN) {
266 inet_csk_listen_stop(sk);
Gerrit Renkerce865a62007-11-24 22:14:15 -0200267 } else if (dccp_need_reset(old_state)) {
268 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
269 sk->sk_err = ECONNRESET;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700270 } else if (old_state == DCCP_REQUESTING)
271 sk->sk_err = ECONNRESET;
272
273 dccp_clear_xmit_timers(sk);
Gerrit Renker48816322008-08-23 13:28:27 +0200274
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700275 __skb_queue_purge(&sk->sk_receive_queue);
Gerrit Renker48816322008-08-23 13:28:27 +0200276 __skb_queue_purge(&sk->sk_write_queue);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700277 if (sk->sk_send_head != NULL) {
278 __kfree_skb(sk->sk_send_head);
279 sk->sk_send_head = NULL;
280 }
281
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000282 inet->inet_dport = 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700283
284 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
285 inet_reset_saddr(sk);
286
287 sk->sk_shutdown = 0;
288 sock_reset_flag(sk, SOCK_DONE);
289
290 icsk->icsk_backoff = 0;
291 inet_csk_delack_init(sk);
292 __sk_dst_reset(sk);
293
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000294 WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700295
296 sk->sk_error_report(sk);
297 return err;
298}
299
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800300EXPORT_SYMBOL_GPL(dccp_disconnect);
301
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700302/*
303 * Wait for a DCCP event.
304 *
305 * Note that we don't need to lock the socket, as the upper poll layers
306 * take care of normal races (between the test and the event) and we don't
307 * go look at any of the socket buffers directly.
308 */
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800309unsigned int dccp_poll(struct file *file, struct socket *sock,
310 poll_table *wait)
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700311{
312 unsigned int mask;
313 struct sock *sk = sock->sk;
314
Eric Dumazetaa395142010-04-20 13:03:51 +0000315 sock_poll_wait(file, sk_sleep(sk), wait);
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700316 if (sk->sk_state == DCCP_LISTEN)
317 return inet_csk_listen_poll(sk);
318
319 /* Socket is not locked. We are protected from async events
320 by poll logic and correct handling of state changes
321 made by another threads is impossible in any case.
322 */
323
324 mask = 0;
325 if (sk->sk_err)
326 mask = POLLERR;
327
328 if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
329 mask |= POLLHUP;
330 if (sk->sk_shutdown & RCV_SHUTDOWN)
Davide Libenzif348d702006-03-25 03:07:39 -0800331 mask |= POLLIN | POLLRDNORM | POLLRDHUP;
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700332
333 /* Connected? */
334 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
335 if (atomic_read(&sk->sk_rmem_alloc) > 0)
336 mask |= POLLIN | POLLRDNORM;
337
338 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
Eric Dumazet64dc6132013-07-22 20:26:31 -0700339 if (sk_stream_is_writeable(sk)) {
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700340 mask |= POLLOUT | POLLWRNORM;
341 } else { /* send SIGIO later */
342 set_bit(SOCK_ASYNC_NOSPACE,
343 &sk->sk_socket->flags);
344 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
345
346 /* Race breaker. If space is freed after
347 * wspace test but before the flags are set,
348 * IO signal will be lost.
349 */
Eric Dumazet64dc6132013-07-22 20:26:31 -0700350 if (sk_stream_is_writeable(sk))
Arnaldo Carvalho de Melo331968b2005-08-23 21:54:23 -0700351 mask |= POLLOUT | POLLWRNORM;
352 }
353 }
354 }
355 return mask;
356}
357
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800358EXPORT_SYMBOL_GPL(dccp_poll);
359
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700360int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
361{
Arnaldo Carvalho de Melo62731722007-10-23 20:23:30 -0700362 int rc = -ENOTCONN;
363
364 lock_sock(sk);
365
366 if (sk->sk_state == DCCP_LISTEN)
367 goto out;
368
369 switch (cmd) {
370 case SIOCINQ: {
371 struct sk_buff *skb;
372 unsigned long amount = 0;
373
374 skb = skb_peek(&sk->sk_receive_queue);
375 if (skb != NULL) {
376 /*
377 * We will only return the amount of this packet since
378 * that is all that will be read.
379 */
380 amount = skb->len;
381 }
382 rc = put_user(amount, (int __user *)arg);
383 }
384 break;
385 default:
386 rc = -ENOIOCTLCMD;
387 break;
388 }
389out:
390 release_sock(sk);
391 return rc;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700392}
393
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800394EXPORT_SYMBOL_GPL(dccp_ioctl);
395
Andrea Bittau60fe62e2006-03-20 19:23:32 -0800396static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
David S. Millerb7058842009-09-30 16:12:20 -0700397 char __user *optval, unsigned int optlen)
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700398{
399 struct dccp_sock *dp = dccp_sk(sk);
400 struct dccp_service_list *sl = NULL;
401
Arnaldo Carvalho de Melo8109b022006-12-10 16:01:18 -0200402 if (service == DCCP_SERVICE_INVALID_VALUE ||
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700403 optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
404 return -EINVAL;
405
406 if (optlen > sizeof(service)) {
407 sl = kmalloc(optlen, GFP_KERNEL);
408 if (sl == NULL)
409 return -ENOMEM;
410
411 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
412 if (copy_from_user(sl->dccpsl_list,
413 optval + sizeof(service),
414 optlen - sizeof(service)) ||
415 dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
416 kfree(sl);
417 return -EFAULT;
418 }
419 }
420
421 lock_sock(sk);
422 dp->dccps_service = service;
423
Jesper Juhla51482b2005-11-08 09:41:34 -0800424 kfree(dp->dccps_service_list);
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700425
426 dp->dccps_service_list = sl;
427 release_sock(sk);
428 return 0;
429}
430
Gerrit Renker29450552008-11-16 22:53:48 -0800431static int dccp_setsockopt_cscov(struct sock *sk, int cscov, bool rx)
432{
433 u8 *list, len;
434 int i, rc;
435
436 if (cscov < 0 || cscov > 15)
437 return -EINVAL;
438 /*
439 * Populate a list of permissible values, in the range cscov...15. This
440 * is necessary since feature negotiation of single values only works if
441 * both sides incidentally choose the same value. Since the list starts
442 * lowest-value first, negotiation will pick the smallest shared value.
443 */
444 if (cscov == 0)
445 return 0;
446 len = 16 - cscov;
447
448 list = kmalloc(len, GFP_KERNEL);
449 if (list == NULL)
450 return -ENOBUFS;
451
452 for (i = 0; i < len; i++)
453 list[i] = cscov++;
454
455 rc = dccp_feat_register_sp(sk, DCCPF_MIN_CSUM_COVER, rx, list, len);
456
457 if (rc == 0) {
458 if (rx)
459 dccp_sk(sk)->dccps_pcrlen = cscov;
460 else
461 dccp_sk(sk)->dccps_pcslen = cscov;
462 }
463 kfree(list);
464 return rc;
465}
466
Gerrit Renkerb20a9c22008-11-23 16:02:31 -0800467static int dccp_setsockopt_ccid(struct sock *sk, int type,
David S. Millerb7058842009-09-30 16:12:20 -0700468 char __user *optval, unsigned int optlen)
Gerrit Renkerb20a9c22008-11-23 16:02:31 -0800469{
470 u8 *val;
471 int rc = 0;
472
473 if (optlen < 1 || optlen > DCCP_FEAT_MAX_SP_VALS)
474 return -EINVAL;
475
Julia Lawall042604d2010-05-21 22:25:19 +0000476 val = memdup_user(optval, optlen);
477 if (IS_ERR(val))
478 return PTR_ERR(val);
Gerrit Renkerb20a9c22008-11-23 16:02:31 -0800479
480 lock_sock(sk);
481 if (type == DCCP_SOCKOPT_TX_CCID || type == DCCP_SOCKOPT_CCID)
482 rc = dccp_feat_register_sp(sk, DCCPF_CCID, 1, val, optlen);
483
484 if (!rc && (type == DCCP_SOCKOPT_RX_CCID || type == DCCP_SOCKOPT_CCID))
485 rc = dccp_feat_register_sp(sk, DCCPF_CCID, 0, val, optlen);
486 release_sock(sk);
487
488 kfree(val);
489 return rc;
490}
491
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800492static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
David S. Millerb7058842009-09-30 16:12:20 -0700493 char __user *optval, unsigned int optlen)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700494{
Gerrit Renker09dbc382006-11-14 12:57:34 -0200495 struct dccp_sock *dp = dccp_sk(sk);
496 int val, err = 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700497
Gerrit Renker19102992008-11-16 22:56:55 -0800498 switch (optname) {
499 case DCCP_SOCKOPT_PACKET_SIZE:
500 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
501 return 0;
502 case DCCP_SOCKOPT_CHANGE_L:
503 case DCCP_SOCKOPT_CHANGE_R:
504 DCCP_WARN("sockopt(CHANGE_L/R) is deprecated: fix your app\n");
505 return 0;
Gerrit Renkerb20a9c22008-11-23 16:02:31 -0800506 case DCCP_SOCKOPT_CCID:
507 case DCCP_SOCKOPT_RX_CCID:
508 case DCCP_SOCKOPT_TX_CCID:
509 return dccp_setsockopt_ccid(sk, optname, optval, optlen);
Gerrit Renker19102992008-11-16 22:56:55 -0800510 }
511
512 if (optlen < (int)sizeof(int))
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300513 return -EINVAL;
514
515 if (get_user(val, (int __user *)optval))
516 return -EFAULT;
517
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700518 if (optname == DCCP_SOCKOPT_SERVICE)
519 return dccp_setsockopt_service(sk, val, optval, optlen);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300520
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700521 lock_sock(sk);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300522 switch (optname) {
Gerrit Renkerb8599d22007-12-13 12:25:01 -0200523 case DCCP_SOCKOPT_SERVER_TIMEWAIT:
524 if (dp->dccps_role != DCCP_ROLE_SERVER)
525 err = -EOPNOTSUPP;
526 else
527 dp->dccps_server_timewait = (val != 0);
528 break;
Gerrit Renker29450552008-11-16 22:53:48 -0800529 case DCCP_SOCKOPT_SEND_CSCOV:
530 err = dccp_setsockopt_cscov(sk, val, false);
Tomasz Grobelnyd6da3512008-09-04 07:30:19 +0200531 break;
Gerrit Renker29450552008-11-16 22:53:48 -0800532 case DCCP_SOCKOPT_RECV_CSCOV:
533 err = dccp_setsockopt_cscov(sk, val, true);
Tomasz Grobelnyd6da3512008-09-04 07:30:19 +0200534 break;
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100535 case DCCP_SOCKOPT_QPOLICY_ID:
536 if (sk->sk_state != DCCP_CLOSED)
537 err = -EISCONN;
538 else if (val < 0 || val >= DCCPQ_POLICY_MAX)
539 err = -EINVAL;
540 else
541 dp->dccps_qpolicy = val;
542 break;
543 case DCCP_SOCKOPT_QPOLICY_TXQLEN:
544 if (val < 0)
545 err = -EINVAL;
546 else
547 dp->dccps_tx_qlen = val;
548 break;
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300549 default:
550 err = -ENOPROTOOPT;
551 break;
552 }
Gerrit Renker410e27a2008-09-09 13:27:22 +0200553 release_sock(sk);
Gerrit Renker19102992008-11-16 22:56:55 -0800554
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300555 return err;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700556}
557
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800558int dccp_setsockopt(struct sock *sk, int level, int optname,
David S. Millerb7058842009-09-30 16:12:20 -0700559 char __user *optval, unsigned int optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800560{
561 if (level != SOL_DCCP)
562 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
563 optname, optval,
564 optlen);
565 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
566}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800567
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800568EXPORT_SYMBOL_GPL(dccp_setsockopt);
569
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800570#ifdef CONFIG_COMPAT
571int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
David S. Millerb7058842009-09-30 16:12:20 -0700572 char __user *optval, unsigned int optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800573{
Arnaldo Carvalho de Melodec73ff2006-03-20 22:46:16 -0800574 if (level != SOL_DCCP)
575 return inet_csk_compat_setsockopt(sk, level, optname,
576 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800577 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
578}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800579
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800580EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
581#endif
582
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700583static int dccp_getsockopt_service(struct sock *sk, int len,
Andrea Bittau60fe62e2006-03-20 19:23:32 -0800584 __be32 __user *optval,
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700585 int __user *optlen)
586{
587 const struct dccp_sock *dp = dccp_sk(sk);
588 const struct dccp_service_list *sl;
589 int err = -ENOENT, slen = 0, total_len = sizeof(u32);
590
591 lock_sock(sk);
Arnaldo Carvalho de Melo67e6b622005-09-16 16:58:40 -0700592 if ((sl = dp->dccps_service_list) != NULL) {
593 slen = sl->dccpsl_nr * sizeof(u32);
594 total_len += slen;
595 }
596
597 err = -EINVAL;
598 if (total_len > len)
599 goto out;
600
601 err = 0;
602 if (put_user(total_len, optlen) ||
603 put_user(dp->dccps_service, optval) ||
604 (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
605 err = -EFAULT;
606out:
607 release_sock(sk);
608 return err;
609}
610
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800611static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -0300612 char __user *optval, int __user *optlen)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700613{
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300614 struct dccp_sock *dp;
615 int val, len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700616
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300617 if (get_user(len, optlen))
618 return -EFAULT;
619
Arnaldo Carvalho de Melo39ebc022007-03-28 11:54:32 -0700620 if (len < (int)sizeof(int))
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300621 return -EINVAL;
622
623 dp = dccp_sk(sk);
624
625 switch (optname) {
626 case DCCP_SOCKOPT_PACKET_SIZE:
Gerrit Renker5aed3242006-11-28 19:33:36 -0200627 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
Arnaldo Carvalho de Melo841bac12006-11-28 19:42:03 -0200628 return 0;
Arnaldo Carvalho de Melo88f964d2005-09-18 00:19:32 -0700629 case DCCP_SOCKOPT_SERVICE:
630 return dccp_getsockopt_service(sk, len,
Andrea Bittau60fe62e2006-03-20 19:23:32 -0800631 (__be32 __user *)optval, optlen);
Gerrit Renker7c559a92007-10-04 14:39:22 -0700632 case DCCP_SOCKOPT_GET_CUR_MPS:
633 val = dp->dccps_mss_cache;
Gerrit Renker7c559a92007-10-04 14:39:22 -0700634 break;
Gerrit Renkerd90ebcb2008-11-12 00:47:26 -0800635 case DCCP_SOCKOPT_AVAILABLE_CCIDS:
636 return ccid_getsockopt_builtin_ccids(sk, len, optval, optlen);
Gerrit Renker71c262a2008-11-23 16:04:59 -0800637 case DCCP_SOCKOPT_TX_CCID:
638 val = ccid_get_current_tx_ccid(dp);
639 if (val < 0)
640 return -ENOPROTOOPT;
641 break;
642 case DCCP_SOCKOPT_RX_CCID:
643 val = ccid_get_current_rx_ccid(dp);
644 if (val < 0)
645 return -ENOPROTOOPT;
646 break;
Gerrit Renkerb8599d22007-12-13 12:25:01 -0200647 case DCCP_SOCKOPT_SERVER_TIMEWAIT:
648 val = dp->dccps_server_timewait;
Gerrit Renkerb8599d22007-12-13 12:25:01 -0200649 break;
Gerrit Renker6f4e5ff2006-11-10 17:43:06 -0200650 case DCCP_SOCKOPT_SEND_CSCOV:
651 val = dp->dccps_pcslen;
652 break;
653 case DCCP_SOCKOPT_RECV_CSCOV:
654 val = dp->dccps_pcrlen;
655 break;
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100656 case DCCP_SOCKOPT_QPOLICY_ID:
657 val = dp->dccps_qpolicy;
658 break;
659 case DCCP_SOCKOPT_QPOLICY_TXQLEN:
660 val = dp->dccps_tx_qlen;
661 break;
Arnaldo Carvalho de Melo88f964d2005-09-18 00:19:32 -0700662 case 128 ... 191:
663 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
664 len, (u32 __user *)optval, optlen);
665 case 192 ... 255:
666 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
667 len, (u32 __user *)optval, optlen);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300668 default:
669 return -ENOPROTOOPT;
670 }
671
Gerrit Renker79133502007-12-13 12:27:14 -0200672 len = sizeof(val);
Arnaldo Carvalho de Meloa84ffe42005-08-28 04:51:32 -0300673 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
674 return -EFAULT;
675
676 return 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700677}
678
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800679int dccp_getsockopt(struct sock *sk, int level, int optname,
680 char __user *optval, int __user *optlen)
681{
682 if (level != SOL_DCCP)
683 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
684 optname, optval,
685 optlen);
686 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
687}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800688
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800689EXPORT_SYMBOL_GPL(dccp_getsockopt);
690
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800691#ifdef CONFIG_COMPAT
692int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800693 char __user *optval, int __user *optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800694{
Arnaldo Carvalho de Melodec73ff2006-03-20 22:46:16 -0800695 if (level != SOL_DCCP)
696 return inet_csk_compat_getsockopt(sk, level, optname,
697 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800698 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
699}
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -0800700
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800701EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
702#endif
703
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100704static int dccp_msghdr_parse(struct msghdr *msg, struct sk_buff *skb)
705{
Gu Zhengf95b4142014-12-11 11:22:04 +0800706 struct cmsghdr *cmsg;
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100707
708 /*
709 * Assign an (opaque) qpolicy priority value to skb->priority.
710 *
711 * We are overloading this skb field for use with the qpolicy subystem.
712 * The skb->priority is normally used for the SO_PRIORITY option, which
713 * is initialised from sk_priority. Since the assignment of sk_priority
714 * to skb->priority happens later (on layer 3), we overload this field
715 * for use with queueing priorities as long as the skb is on layer 4.
716 * The default priority value (if nothing is set) is 0.
717 */
718 skb->priority = 0;
719
Gu Zhengf95b4142014-12-11 11:22:04 +0800720 for_each_cmsghdr(cmsg, msg) {
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100721 if (!CMSG_OK(msg, cmsg))
722 return -EINVAL;
723
724 if (cmsg->cmsg_level != SOL_DCCP)
725 continue;
726
Tomasz Grobelny04910262010-12-04 13:39:13 +0100727 if (cmsg->cmsg_type <= DCCP_SCM_QPOLICY_MAX &&
728 !dccp_qpolicy_param_ok(skb->sk, cmsg->cmsg_type))
729 return -EINVAL;
730
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100731 switch (cmsg->cmsg_type) {
732 case DCCP_SCM_PRIORITY:
733 if (cmsg->cmsg_len != CMSG_LEN(sizeof(__u32)))
734 return -EINVAL;
735 skb->priority = *(__u32 *)CMSG_DATA(cmsg);
736 break;
737 default:
738 return -EINVAL;
739 }
740 }
741 return 0;
742}
743
Ying Xue1b784142015-03-02 15:37:48 +0800744int dccp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700745{
746 const struct dccp_sock *dp = dccp_sk(sk);
747 const int flags = msg->msg_flags;
748 const int noblock = flags & MSG_DONTWAIT;
749 struct sk_buff *skb;
750 int rc, size;
751 long timeo;
752
753 if (len > dp->dccps_mss_cache)
754 return -EMSGSIZE;
755
756 lock_sock(sk);
Ian McDonaldb1308dc2006-11-20 18:30:17 -0200757
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100758 if (dccp_qpolicy_full(sk)) {
Ian McDonaldb1308dc2006-11-20 18:30:17 -0200759 rc = -EAGAIN;
760 goto out_release;
761 }
762
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700763 timeo = sock_sndtimeo(sk, noblock);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700764
765 /*
766 * We have to use sk_stream_wait_connect here to set sk_write_pending,
767 * so that the trick in dccp_rcv_request_sent_state_process.
768 */
769 /* Wait for a connection to finish. */
Gerrit Renkercecd8d02007-09-26 19:36:08 -0300770 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700771 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700772 goto out_release;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700773
774 size = sk->sk_prot->max_header + len;
775 release_sock(sk);
776 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
777 lock_sock(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700778 if (skb == NULL)
779 goto out_release;
780
781 skb_reserve(skb, sk->sk_prot->max_header);
Al Viro6ce8e9c2014-04-06 21:25:44 -0400782 rc = memcpy_from_msg(skb_put(skb, len), msg, len);
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700783 if (rc != 0)
784 goto out_discard;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700785
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100786 rc = dccp_msghdr_parse(msg, skb);
787 if (rc != 0)
788 goto out_discard;
789
790 dccp_qpolicy_push(sk, skb);
Gerrit Renkerb1fcf552010-10-27 19:16:27 +0000791 /*
792 * The xmit_timer is set if the TX CCID is rate-based and will expire
793 * when congestion control permits to release further packets into the
794 * network. Window-based CCIDs do not use this timer.
795 */
796 if (!timer_pending(&dp->dccps_xmit_timer))
797 dccp_write_xmit(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700798out_release:
799 release_sock(sk);
800 return rc ? : len;
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700801out_discard:
802 kfree_skb(skb);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700803 goto out_release;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700804}
805
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800806EXPORT_SYMBOL_GPL(dccp_sendmsg);
807
Ying Xue1b784142015-03-02 15:37:48 +0800808int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
809 int flags, int *addr_len)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700810{
811 const struct dccp_hdr *dh;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700812 long timeo;
813
814 lock_sock(sk);
815
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300816 if (sk->sk_state == DCCP_LISTEN) {
817 len = -ENOTCONN;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700818 goto out;
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300819 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700820
821 timeo = sock_rcvtimeo(sk, nonblock);
822
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700823 do {
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300824 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700825
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300826 if (skb == NULL)
827 goto verify_sock_status;
828
829 dh = dccp_hdr(skb);
830
Gerrit Renker0c869622007-11-28 11:59:48 -0200831 switch (dh->dccph_type) {
832 case DCCP_PKT_DATA:
833 case DCCP_PKT_DATAACK:
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300834 goto found_ok_skb;
835
Gerrit Renker0c869622007-11-28 11:59:48 -0200836 case DCCP_PKT_CLOSE:
837 case DCCP_PKT_CLOSEREQ:
838 if (!(flags & MSG_PEEK))
839 dccp_finish_passive_close(sk);
840 /* fall through */
841 case DCCP_PKT_RESET:
842 dccp_pr_debug("found fin (%s) ok!\n",
843 dccp_packet_name(dh->dccph_type));
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300844 len = 0;
845 goto found_fin_ok;
Gerrit Renker0c869622007-11-28 11:59:48 -0200846 default:
847 dccp_pr_debug("packet_type=%s\n",
848 dccp_packet_name(dh->dccph_type));
Dan Williams7bced392013-12-30 12:37:29 -0800849 sk_eat_skb(sk, skb);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700850 }
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300851verify_sock_status:
852 if (sock_flag(sk, SOCK_DONE)) {
853 len = 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700854 break;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700855 }
856
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300857 if (sk->sk_err) {
858 len = sock_error(sk);
859 break;
860 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700861
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300862 if (sk->sk_shutdown & RCV_SHUTDOWN) {
863 len = 0;
864 break;
865 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700866
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300867 if (sk->sk_state == DCCP_CLOSED) {
868 if (!sock_flag(sk, SOCK_DONE)) {
869 /* This occurs when user tries to read
870 * from never connected socket.
871 */
872 len = -ENOTCONN;
873 break;
874 }
875 len = 0;
876 break;
877 }
878
879 if (!timeo) {
880 len = -EAGAIN;
881 break;
882 }
883
884 if (signal_pending(current)) {
885 len = sock_intr_errno(timeo);
886 break;
887 }
888
889 sk_wait_data(sk, &timeo);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700890 continue;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700891 found_ok_skb:
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300892 if (len > skb->len)
893 len = skb->len;
894 else if (len < skb->len)
895 msg->msg_flags |= MSG_TRUNC;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700896
David S. Miller51f3d022014-11-05 16:46:40 -0500897 if (skb_copy_datagram_msg(skb, 0, msg, len)) {
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300898 /* Exception. Bailout! */
899 len = -EFAULT;
900 break;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700901 }
Gerrit Renker55d95592010-02-10 20:26:18 +0000902 if (flags & MSG_TRUNC)
903 len = skb->len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700904 found_fin_ok:
905 if (!(flags & MSG_PEEK))
Dan Williams7bced392013-12-30 12:37:29 -0800906 sk_eat_skb(sk, skb);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700907 break;
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300908 } while (1);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700909out:
910 release_sock(sk);
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300911 return len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700912}
913
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800914EXPORT_SYMBOL_GPL(dccp_recvmsg);
915
916int inet_dccp_listen(struct socket *sock, int backlog)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700917{
918 struct sock *sk = sock->sk;
919 unsigned char old_state;
920 int err;
921
922 lock_sock(sk);
923
924 err = -EINVAL;
925 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
926 goto out;
927
928 old_state = sk->sk_state;
929 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
930 goto out;
931
932 /* Really, if the socket is already in listen state
933 * we can only allow the backlog to be adjusted.
934 */
935 if (old_state != DCCP_LISTEN) {
936 /*
937 * FIXME: here it probably should be sk->sk_prot->listen_start
938 * see tcp_listen_start
939 */
Eric Dumazet72a3eff2006-11-16 02:30:37 -0800940 err = dccp_listen_start(sk, backlog);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700941 if (err)
942 goto out;
943 }
944 sk->sk_max_ack_backlog = backlog;
945 err = 0;
946
947out:
948 release_sock(sk);
949 return err;
950}
951
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800952EXPORT_SYMBOL_GPL(inet_dccp_listen);
953
Gerrit Renker0c869622007-11-28 11:59:48 -0200954static void dccp_terminate_connection(struct sock *sk)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700955{
Gerrit Renker0c869622007-11-28 11:59:48 -0200956 u8 next_state = DCCP_CLOSED;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700957
Gerrit Renker0c869622007-11-28 11:59:48 -0200958 switch (sk->sk_state) {
959 case DCCP_PASSIVE_CLOSE:
960 case DCCP_PASSIVE_CLOSEREQ:
961 dccp_finish_passive_close(sk);
962 break;
963 case DCCP_PARTOPEN:
964 dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
965 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
966 /* fall through */
967 case DCCP_OPEN:
968 dccp_send_close(sk, 1);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700969
Gerrit Renkerb8599d22007-12-13 12:25:01 -0200970 if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
971 !dccp_sk(sk)->dccps_server_timewait)
Gerrit Renker0c869622007-11-28 11:59:48 -0200972 next_state = DCCP_ACTIVE_CLOSEREQ;
973 else
974 next_state = DCCP_CLOSING;
975 /* fall through */
976 default:
977 dccp_set_state(sk, next_state);
978 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700979}
980
981void dccp_close(struct sock *sk, long timeout)
982{
Ian McDonald97e58482006-08-26 19:16:45 -0700983 struct dccp_sock *dp = dccp_sk(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700984 struct sk_buff *skb;
Gerrit Renkerd83bd952007-12-16 16:06:03 -0800985 u32 data_was_unread = 0;
Herbert Xu134af342006-05-05 17:09:13 -0700986 int state;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700987
988 lock_sock(sk);
989
990 sk->sk_shutdown = SHUTDOWN_MASK;
991
992 if (sk->sk_state == DCCP_LISTEN) {
993 dccp_set_state(sk, DCCP_CLOSED);
994
995 /* Special case. */
996 inet_csk_listen_stop(sk);
997
998 goto adjudge_to_death;
999 }
1000
Ian McDonald97e58482006-08-26 19:16:45 -07001001 sk_stop_timer(sk, &dp->dccps_xmit_timer);
1002
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001003 /*
1004 * We need to flush the recv. buffs. We do this only on the
1005 * descriptor close, not protocol-sourced closes, because the
1006 *reader process may not have drained the data yet!
1007 */
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001008 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
Gerrit Renkerd83bd952007-12-16 16:06:03 -08001009 data_was_unread += skb->len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001010 __kfree_skb(skb);
1011 }
1012
Gerrit Renkerd83bd952007-12-16 16:06:03 -08001013 if (data_was_unread) {
1014 /* Unread data was tossed, send an appropriate Reset Code */
Gerrit Renker2f34b322010-10-11 20:44:42 +02001015 DCCP_WARN("ABORT with %u bytes unread\n", data_was_unread);
Gerrit Renkerd83bd952007-12-16 16:06:03 -08001016 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
1017 dccp_set_state(sk, DCCP_CLOSED);
1018 } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001019 /* Check zero linger _after_ checking for unread data. */
1020 sk->sk_prot->disconnect(sk, 0);
Gerrit Renker0c869622007-11-28 11:59:48 -02001021 } else if (sk->sk_state != DCCP_CLOSED) {
Gerrit Renkerb1fcf552010-10-27 19:16:27 +00001022 /*
1023 * Normal connection termination. May need to wait if there are
1024 * still packets in the TX queue that are delayed by the CCID.
1025 */
1026 dccp_flush_write_queue(sk, &timeout);
Gerrit Renker0c869622007-11-28 11:59:48 -02001027 dccp_terminate_connection(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001028 }
1029
Gerrit Renkerb1fcf552010-10-27 19:16:27 +00001030 /*
1031 * Flush write queue. This may be necessary in several cases:
1032 * - we have been closed by the peer but still have application data;
1033 * - abortive termination (unread data or zero linger time),
1034 * - normal termination but queue could not be flushed within time limit
1035 */
1036 __skb_queue_purge(&sk->sk_write_queue);
1037
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001038 sk_stream_wait_close(sk, timeout);
1039
1040adjudge_to_death:
Herbert Xu134af342006-05-05 17:09:13 -07001041 state = sk->sk_state;
1042 sock_hold(sk);
1043 sock_orphan(sk);
Herbert Xu134af342006-05-05 17:09:13 -07001044
Arnaldo Carvalho de Melo7ad07e72005-08-23 21:50:06 -07001045 /*
1046 * It is the last release_sock in its life. It will remove backlog.
1047 */
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001048 release_sock(sk);
1049 /*
1050 * Now socket is owned by kernel and we acquire BH lock
1051 * to finish close. No need to check for user refs.
1052 */
1053 local_bh_disable();
1054 bh_lock_sock(sk);
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001055 WARN_ON(sock_owned_by_user(sk));
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001056
Herbert Xueb4dea52008-12-29 23:04:08 -08001057 percpu_counter_inc(sk->sk_prot->orphan_count);
1058
Herbert Xu134af342006-05-05 17:09:13 -07001059 /* Have we already been destroyed by a softirq or backlog? */
1060 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
1061 goto out;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001062
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001063 if (sk->sk_state == DCCP_CLOSED)
1064 inet_csk_destroy_sock(sk);
1065
1066 /* Otherwise, socket is reprieved until protocol close. */
1067
Herbert Xu134af342006-05-05 17:09:13 -07001068out:
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001069 bh_unlock_sock(sk);
1070 local_bh_enable();
1071 sock_put(sk);
1072}
1073
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -08001074EXPORT_SYMBOL_GPL(dccp_close);
1075
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001076void dccp_shutdown(struct sock *sk, int how)
1077{
Gerrit Renker8e8c71f2007-11-21 09:56:48 -02001078 dccp_pr_debug("called shutdown(%x)\n", how);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001079}
1080
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -08001081EXPORT_SYMBOL_GPL(dccp_shutdown);
1082
Fabian Frederick0c5b8a42014-10-01 06:48:03 +02001083static inline int __init dccp_mib_init(void)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001084{
WANG Cong698365f2014-05-05 15:55:55 -07001085 dccp_statistics = alloc_percpu(struct dccp_mib);
1086 if (!dccp_statistics)
1087 return -ENOMEM;
1088 return 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001089}
1090
YOSHIFUJI Hideaki24e8b7e2008-04-10 03:48:43 -07001091static inline void dccp_mib_exit(void)
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001092{
WANG Cong698365f2014-05-05 15:55:55 -07001093 free_percpu(dccp_statistics);
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001094}
1095
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001096static int thash_entries;
1097module_param(thash_entries, int, 0444);
1098MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
1099
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -03001100#ifdef CONFIG_IP_DCCP_DEBUG
Rusty Russelleb939922011-12-19 14:08:01 +00001101bool dccp_debug;
Gerrit Renker43264992008-08-23 13:28:27 +02001102module_param(dccp_debug, bool, 0644);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001103MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -08001104
1105EXPORT_SYMBOL_GPL(dccp_debug);
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -03001106#endif
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001107
1108static int __init dccp_init(void)
1109{
1110 unsigned long goal;
1111 int ehash_order, bhash_order, i;
Eric Dumazetdd24c002008-11-25 21:17:14 -08001112 int rc;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001113
Patrick McHardy028b0272008-04-12 18:35:41 -07001114 BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
1115 FIELD_SIZEOF(struct sk_buff, cb));
Tejun Heo908c7f12014-09-08 09:51:29 +09001116 rc = percpu_counter_init(&dccp_orphan_count, 0, GFP_KERNEL);
Eric Dumazetdd24c002008-11-25 21:17:14 -08001117 if (rc)
Gerrit Renkerd14a0eb2010-03-14 20:13:19 +00001118 goto out_fail;
Eric Dumazetdd24c002008-11-25 21:17:14 -08001119 rc = -ENOBUFS;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001120 inet_hashinfo_init(&dccp_hashinfo);
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001121 dccp_hashinfo.bind_bucket_cachep =
1122 kmem_cache_create("dccp_bind_bucket",
1123 sizeof(struct inet_bind_bucket), 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09001124 SLAB_HWCACHE_ALIGN, NULL);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001125 if (!dccp_hashinfo.bind_bucket_cachep)
Eric Dumazetdd24c002008-11-25 21:17:14 -08001126 goto out_free_percpu;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001127
1128 /*
1129 * Size and allocate the main established and bind bucket
1130 * hash tables.
1131 *
1132 * The methodology is similar to that of the buffer cache.
1133 */
Jan Beulich44813742009-09-21 17:03:05 -07001134 if (totalram_pages >= (128 * 1024))
1135 goal = totalram_pages >> (21 - PAGE_SHIFT);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001136 else
Jan Beulich44813742009-09-21 17:03:05 -07001137 goal = totalram_pages >> (23 - PAGE_SHIFT);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001138
1139 if (thash_entries)
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001140 goal = (thash_entries *
1141 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001142 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1143 ;
1144 do {
Eric Dumazetf373b532009-10-09 00:16:19 +00001145 unsigned long hash_size = (1UL << ehash_order) * PAGE_SIZE /
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001146 sizeof(struct inet_ehash_bucket);
Eric Dumazetf373b532009-10-09 00:16:19 +00001147
1148 while (hash_size & (hash_size - 1))
1149 hash_size--;
1150 dccp_hashinfo.ehash_mask = hash_size - 1;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001151 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
Mel Gorman1c29b3f2009-07-29 15:04:10 -07001152 __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, ehash_order);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001153 } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1154
1155 if (!dccp_hashinfo.ehash) {
Gerrit Renker59348b12006-11-20 18:39:23 -02001156 DCCP_CRIT("Failed to allocate DCCP established hash table");
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001157 goto out_free_bind_bucket_cachep;
1158 }
1159
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001160 for (i = 0; i <= dccp_hashinfo.ehash_mask; i++)
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001161 INIT_HLIST_NULLS_HEAD(&dccp_hashinfo.ehash[i].chain, i);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001162
Eric Dumazet230140c2007-11-07 02:40:20 -08001163 if (inet_ehash_locks_alloc(&dccp_hashinfo))
1164 goto out_free_dccp_ehash;
1165
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001166 bhash_order = ehash_order;
1167
1168 do {
1169 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1170 sizeof(struct inet_bind_hashbucket);
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001171 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1172 bhash_order > 0)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001173 continue;
1174 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
Mel Gorman1c29b3f2009-07-29 15:04:10 -07001175 __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, bhash_order);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001176 } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1177
1178 if (!dccp_hashinfo.bhash) {
Gerrit Renker59348b12006-11-20 18:39:23 -02001179 DCCP_CRIT("Failed to allocate DCCP bind hash table");
Eric Dumazet230140c2007-11-07 02:40:20 -08001180 goto out_free_dccp_locks;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001181 }
1182
1183 for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1184 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1185 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1186 }
1187
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001188 rc = dccp_mib_init();
Arnaldo Carvalho de Melofa23e2e2006-03-20 17:16:01 -08001189 if (rc)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001190 goto out_free_dccp_bhash;
1191
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001192 rc = dccp_ackvec_init();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001193 if (rc)
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001194 goto out_free_dccp_mib;
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001195
Arnaldo Carvalho de Meloe55d9122006-03-20 19:25:02 -08001196 rc = dccp_sysctl_init();
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001197 if (rc)
1198 goto out_ackvec_exit;
Gerrit Renker4c70f382007-09-25 22:40:13 -07001199
Gerrit Renkerddebc972009-01-04 21:42:53 -08001200 rc = ccid_initialize_builtins();
1201 if (rc)
1202 goto out_sysctl_exit;
1203
Gerrit Renker4c70f382007-09-25 22:40:13 -07001204 dccp_timestamping_init();
Gerrit Renkerd14a0eb2010-03-14 20:13:19 +00001205
1206 return 0;
1207
Gerrit Renkerddebc972009-01-04 21:42:53 -08001208out_sysctl_exit:
1209 dccp_sysctl_exit();
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001210out_ackvec_exit:
1211 dccp_ackvec_exit();
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001212out_free_dccp_mib:
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001213 dccp_mib_exit();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001214out_free_dccp_bhash:
1215 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
Eric Dumazet230140c2007-11-07 02:40:20 -08001216out_free_dccp_locks:
1217 inet_ehash_locks_free(&dccp_hashinfo);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001218out_free_dccp_ehash:
1219 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001220out_free_bind_bucket_cachep:
1221 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
Eric Dumazetdd24c002008-11-25 21:17:14 -08001222out_free_percpu:
1223 percpu_counter_destroy(&dccp_orphan_count);
Gerrit Renkerd14a0eb2010-03-14 20:13:19 +00001224out_fail:
1225 dccp_hashinfo.bhash = NULL;
1226 dccp_hashinfo.ehash = NULL;
1227 dccp_hashinfo.bind_bucket_cachep = NULL;
1228 return rc;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001229}
1230
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001231static void __exit dccp_fini(void)
1232{
Gerrit Renkerddebc972009-01-04 21:42:53 -08001233 ccid_cleanup_builtins();
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001234 dccp_mib_exit();
Arnaldo Carvalho de Melo725ba8e2005-08-13 20:35:39 -03001235 free_pages((unsigned long)dccp_hashinfo.bhash,
1236 get_order(dccp_hashinfo.bhash_size *
1237 sizeof(struct inet_bind_hashbucket)));
1238 free_pages((unsigned long)dccp_hashinfo.ehash,
Eric Dumazetf373b532009-10-09 00:16:19 +00001239 get_order((dccp_hashinfo.ehash_mask + 1) *
Arnaldo Carvalho de Melo725ba8e2005-08-13 20:35:39 -03001240 sizeof(struct inet_ehash_bucket)));
Eric Dumazet230140c2007-11-07 02:40:20 -08001241 inet_ehash_locks_free(&dccp_hashinfo);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001242 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001243 dccp_ackvec_exit();
Arnaldo Carvalho de Meloe55d9122006-03-20 19:25:02 -08001244 dccp_sysctl_exit();
Wei Yongjun476181c2009-08-04 21:44:39 +00001245 percpu_counter_destroy(&dccp_orphan_count);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001246}
1247
1248module_init(dccp_init);
1249module_exit(dccp_fini);
1250
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001251MODULE_LICENSE("GPL");
1252MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1253MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");