blob: eb892b4f48144966e47f386108942f51b8b85e50 [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{
706 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msg);
707
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
720 for (; cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg)) {
721
722 if (!CMSG_OK(msg, cmsg))
723 return -EINVAL;
724
725 if (cmsg->cmsg_level != SOL_DCCP)
726 continue;
727
Tomasz Grobelny04910262010-12-04 13:39:13 +0100728 if (cmsg->cmsg_type <= DCCP_SCM_QPOLICY_MAX &&
729 !dccp_qpolicy_param_ok(skb->sk, cmsg->cmsg_type))
730 return -EINVAL;
731
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100732 switch (cmsg->cmsg_type) {
733 case DCCP_SCM_PRIORITY:
734 if (cmsg->cmsg_len != CMSG_LEN(sizeof(__u32)))
735 return -EINVAL;
736 skb->priority = *(__u32 *)CMSG_DATA(cmsg);
737 break;
738 default:
739 return -EINVAL;
740 }
741 }
742 return 0;
743}
744
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700745int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
746 size_t len)
747{
748 const struct dccp_sock *dp = dccp_sk(sk);
749 const int flags = msg->msg_flags;
750 const int noblock = flags & MSG_DONTWAIT;
751 struct sk_buff *skb;
752 int rc, size;
753 long timeo;
754
755 if (len > dp->dccps_mss_cache)
756 return -EMSGSIZE;
757
758 lock_sock(sk);
Ian McDonaldb1308dc2006-11-20 18:30:17 -0200759
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100760 if (dccp_qpolicy_full(sk)) {
Ian McDonaldb1308dc2006-11-20 18:30:17 -0200761 rc = -EAGAIN;
762 goto out_release;
763 }
764
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700765 timeo = sock_sndtimeo(sk, noblock);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700766
767 /*
768 * We have to use sk_stream_wait_connect here to set sk_write_pending,
769 * so that the trick in dccp_rcv_request_sent_state_process.
770 */
771 /* Wait for a connection to finish. */
Gerrit Renkercecd8d02007-09-26 19:36:08 -0300772 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700773 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700774 goto out_release;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700775
776 size = sk->sk_prot->max_header + len;
777 release_sock(sk);
778 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
779 lock_sock(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700780 if (skb == NULL)
781 goto out_release;
782
783 skb_reserve(skb, sk->sk_prot->max_header);
784 rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700785 if (rc != 0)
786 goto out_discard;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700787
Tomasz Grobelny871a2c12010-12-04 13:38:01 +0100788 rc = dccp_msghdr_parse(msg, skb);
789 if (rc != 0)
790 goto out_discard;
791
792 dccp_qpolicy_push(sk, skb);
Gerrit Renkerb1fcf552010-10-27 19:16:27 +0000793 /*
794 * The xmit_timer is set if the TX CCID is rate-based and will expire
795 * when congestion control permits to release further packets into the
796 * network. Window-based CCIDs do not use this timer.
797 */
798 if (!timer_pending(&dp->dccps_xmit_timer))
799 dccp_write_xmit(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700800out_release:
801 release_sock(sk);
802 return rc ? : len;
Arnaldo Carvalho de Melo27258ee2005-08-09 20:30:56 -0700803out_discard:
804 kfree_skb(skb);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700805 goto out_release;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700806}
807
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800808EXPORT_SYMBOL_GPL(dccp_sendmsg);
809
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700810int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
811 size_t len, int nonblock, int flags, int *addr_len)
812{
813 const struct dccp_hdr *dh;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700814 long timeo;
815
816 lock_sock(sk);
817
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300818 if (sk->sk_state == DCCP_LISTEN) {
819 len = -ENOTCONN;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700820 goto out;
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300821 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700822
823 timeo = sock_rcvtimeo(sk, nonblock);
824
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700825 do {
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300826 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700827
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300828 if (skb == NULL)
829 goto verify_sock_status;
830
831 dh = dccp_hdr(skb);
832
Gerrit Renker0c869622007-11-28 11:59:48 -0200833 switch (dh->dccph_type) {
834 case DCCP_PKT_DATA:
835 case DCCP_PKT_DATAACK:
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300836 goto found_ok_skb;
837
Gerrit Renker0c869622007-11-28 11:59:48 -0200838 case DCCP_PKT_CLOSE:
839 case DCCP_PKT_CLOSEREQ:
840 if (!(flags & MSG_PEEK))
841 dccp_finish_passive_close(sk);
842 /* fall through */
843 case DCCP_PKT_RESET:
844 dccp_pr_debug("found fin (%s) ok!\n",
845 dccp_packet_name(dh->dccph_type));
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300846 len = 0;
847 goto found_fin_ok;
Gerrit Renker0c869622007-11-28 11:59:48 -0200848 default:
849 dccp_pr_debug("packet_type=%s\n",
850 dccp_packet_name(dh->dccph_type));
Eric Dumazetdc6b9b72012-05-16 22:48:15 +0000851 sk_eat_skb(sk, skb, false);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700852 }
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300853verify_sock_status:
854 if (sock_flag(sk, SOCK_DONE)) {
855 len = 0;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700856 break;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700857 }
858
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300859 if (sk->sk_err) {
860 len = sock_error(sk);
861 break;
862 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700863
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300864 if (sk->sk_shutdown & RCV_SHUTDOWN) {
865 len = 0;
866 break;
867 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700868
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300869 if (sk->sk_state == DCCP_CLOSED) {
870 if (!sock_flag(sk, SOCK_DONE)) {
871 /* This occurs when user tries to read
872 * from never connected socket.
873 */
874 len = -ENOTCONN;
875 break;
876 }
877 len = 0;
878 break;
879 }
880
881 if (!timeo) {
882 len = -EAGAIN;
883 break;
884 }
885
886 if (signal_pending(current)) {
887 len = sock_intr_errno(timeo);
888 break;
889 }
890
891 sk_wait_data(sk, &timeo);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700892 continue;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700893 found_ok_skb:
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300894 if (len > skb->len)
895 len = skb->len;
896 else if (len < skb->len)
897 msg->msg_flags |= MSG_TRUNC;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700898
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300899 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
900 /* Exception. Bailout! */
901 len = -EFAULT;
902 break;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700903 }
Gerrit Renker55d95592010-02-10 20:26:18 +0000904 if (flags & MSG_TRUNC)
905 len = skb->len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700906 found_fin_ok:
907 if (!(flags & MSG_PEEK))
Eric Dumazetdc6b9b72012-05-16 22:48:15 +0000908 sk_eat_skb(sk, skb, false);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700909 break;
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300910 } while (1);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700911out:
912 release_sock(sk);
Arnaldo Carvalho de Melo531669a2005-08-13 20:35:17 -0300913 return len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700914}
915
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800916EXPORT_SYMBOL_GPL(dccp_recvmsg);
917
918int inet_dccp_listen(struct socket *sock, int backlog)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700919{
920 struct sock *sk = sock->sk;
921 unsigned char old_state;
922 int err;
923
924 lock_sock(sk);
925
926 err = -EINVAL;
927 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
928 goto out;
929
930 old_state = sk->sk_state;
931 if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
932 goto out;
933
934 /* Really, if the socket is already in listen state
935 * we can only allow the backlog to be adjusted.
936 */
937 if (old_state != DCCP_LISTEN) {
938 /*
939 * FIXME: here it probably should be sk->sk_prot->listen_start
940 * see tcp_listen_start
941 */
Eric Dumazet72a3eff2006-11-16 02:30:37 -0800942 err = dccp_listen_start(sk, backlog);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700943 if (err)
944 goto out;
945 }
946 sk->sk_max_ack_backlog = backlog;
947 err = 0;
948
949out:
950 release_sock(sk);
951 return err;
952}
953
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -0800954EXPORT_SYMBOL_GPL(inet_dccp_listen);
955
Gerrit Renker0c869622007-11-28 11:59:48 -0200956static void dccp_terminate_connection(struct sock *sk)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700957{
Gerrit Renker0c869622007-11-28 11:59:48 -0200958 u8 next_state = DCCP_CLOSED;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700959
Gerrit Renker0c869622007-11-28 11:59:48 -0200960 switch (sk->sk_state) {
961 case DCCP_PASSIVE_CLOSE:
962 case DCCP_PASSIVE_CLOSEREQ:
963 dccp_finish_passive_close(sk);
964 break;
965 case DCCP_PARTOPEN:
966 dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
967 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
968 /* fall through */
969 case DCCP_OPEN:
970 dccp_send_close(sk, 1);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700971
Gerrit Renkerb8599d22007-12-13 12:25:01 -0200972 if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
973 !dccp_sk(sk)->dccps_server_timewait)
Gerrit Renker0c869622007-11-28 11:59:48 -0200974 next_state = DCCP_ACTIVE_CLOSEREQ;
975 else
976 next_state = DCCP_CLOSING;
977 /* fall through */
978 default:
979 dccp_set_state(sk, next_state);
980 }
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700981}
982
983void dccp_close(struct sock *sk, long timeout)
984{
Ian McDonald97e58482006-08-26 19:16:45 -0700985 struct dccp_sock *dp = dccp_sk(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700986 struct sk_buff *skb;
Gerrit Renkerd83bd952007-12-16 16:06:03 -0800987 u32 data_was_unread = 0;
Herbert Xu134af342006-05-05 17:09:13 -0700988 int state;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -0700989
990 lock_sock(sk);
991
992 sk->sk_shutdown = SHUTDOWN_MASK;
993
994 if (sk->sk_state == DCCP_LISTEN) {
995 dccp_set_state(sk, DCCP_CLOSED);
996
997 /* Special case. */
998 inet_csk_listen_stop(sk);
999
1000 goto adjudge_to_death;
1001 }
1002
Ian McDonald97e58482006-08-26 19:16:45 -07001003 sk_stop_timer(sk, &dp->dccps_xmit_timer);
1004
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001005 /*
1006 * We need to flush the recv. buffs. We do this only on the
1007 * descriptor close, not protocol-sourced closes, because the
1008 *reader process may not have drained the data yet!
1009 */
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001010 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
Gerrit Renkerd83bd952007-12-16 16:06:03 -08001011 data_was_unread += skb->len;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001012 __kfree_skb(skb);
1013 }
1014
Gerrit Renkerd83bd952007-12-16 16:06:03 -08001015 if (data_was_unread) {
1016 /* Unread data was tossed, send an appropriate Reset Code */
Gerrit Renker2f34b322010-10-11 20:44:42 +02001017 DCCP_WARN("ABORT with %u bytes unread\n", data_was_unread);
Gerrit Renkerd83bd952007-12-16 16:06:03 -08001018 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
1019 dccp_set_state(sk, DCCP_CLOSED);
1020 } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001021 /* Check zero linger _after_ checking for unread data. */
1022 sk->sk_prot->disconnect(sk, 0);
Gerrit Renker0c869622007-11-28 11:59:48 -02001023 } else if (sk->sk_state != DCCP_CLOSED) {
Gerrit Renkerb1fcf552010-10-27 19:16:27 +00001024 /*
1025 * Normal connection termination. May need to wait if there are
1026 * still packets in the TX queue that are delayed by the CCID.
1027 */
1028 dccp_flush_write_queue(sk, &timeout);
Gerrit Renker0c869622007-11-28 11:59:48 -02001029 dccp_terminate_connection(sk);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001030 }
1031
Gerrit Renkerb1fcf552010-10-27 19:16:27 +00001032 /*
1033 * Flush write queue. This may be necessary in several cases:
1034 * - we have been closed by the peer but still have application data;
1035 * - abortive termination (unread data or zero linger time),
1036 * - normal termination but queue could not be flushed within time limit
1037 */
1038 __skb_queue_purge(&sk->sk_write_queue);
1039
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001040 sk_stream_wait_close(sk, timeout);
1041
1042adjudge_to_death:
Herbert Xu134af342006-05-05 17:09:13 -07001043 state = sk->sk_state;
1044 sock_hold(sk);
1045 sock_orphan(sk);
Herbert Xu134af342006-05-05 17:09:13 -07001046
Arnaldo Carvalho de Melo7ad07e72005-08-23 21:50:06 -07001047 /*
1048 * It is the last release_sock in its life. It will remove backlog.
1049 */
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001050 release_sock(sk);
1051 /*
1052 * Now socket is owned by kernel and we acquire BH lock
1053 * to finish close. No need to check for user refs.
1054 */
1055 local_bh_disable();
1056 bh_lock_sock(sk);
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001057 WARN_ON(sock_owned_by_user(sk));
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001058
Herbert Xueb4dea52008-12-29 23:04:08 -08001059 percpu_counter_inc(sk->sk_prot->orphan_count);
1060
Herbert Xu134af342006-05-05 17:09:13 -07001061 /* Have we already been destroyed by a softirq or backlog? */
1062 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
1063 goto out;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001064
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001065 if (sk->sk_state == DCCP_CLOSED)
1066 inet_csk_destroy_sock(sk);
1067
1068 /* Otherwise, socket is reprieved until protocol close. */
1069
Herbert Xu134af342006-05-05 17:09:13 -07001070out:
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001071 bh_unlock_sock(sk);
1072 local_bh_enable();
1073 sock_put(sk);
1074}
1075
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -08001076EXPORT_SYMBOL_GPL(dccp_close);
1077
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001078void dccp_shutdown(struct sock *sk, int how)
1079{
Gerrit Renker8e8c71f2007-11-21 09:56:48 -02001080 dccp_pr_debug("called shutdown(%x)\n", how);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001081}
1082
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -08001083EXPORT_SYMBOL_GPL(dccp_shutdown);
1084
YOSHIFUJI Hideaki24e8b7e2008-04-10 03:48:43 -07001085static inline int dccp_mib_init(void)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001086{
Tejun Heo7d720c32010-02-16 15:20:26 +00001087 return snmp_mib_init((void __percpu **)dccp_statistics,
Eric Dumazet1823e4c82010-06-22 20:58:41 +00001088 sizeof(struct dccp_mib),
1089 __alignof__(struct dccp_mib));
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001090}
1091
YOSHIFUJI Hideaki24e8b7e2008-04-10 03:48:43 -07001092static inline void dccp_mib_exit(void)
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001093{
Tejun Heo7d720c32010-02-16 15:20:26 +00001094 snmp_mib_free((void __percpu **)dccp_statistics);
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001095}
1096
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001097static int thash_entries;
1098module_param(thash_entries, int, 0444);
1099MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
1100
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -03001101#ifdef CONFIG_IP_DCCP_DEBUG
Rusty Russelleb939922011-12-19 14:08:01 +00001102bool dccp_debug;
Gerrit Renker43264992008-08-23 13:28:27 +02001103module_param(dccp_debug, bool, 0644);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001104MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
Arnaldo Carvalho de Melof21e68c2005-12-13 23:24:16 -08001105
1106EXPORT_SYMBOL_GPL(dccp_debug);
Arnaldo Carvalho de Meloa1d3a352005-08-13 22:42:25 -03001107#endif
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001108
1109static int __init dccp_init(void)
1110{
1111 unsigned long goal;
1112 int ehash_order, bhash_order, i;
Eric Dumazetdd24c002008-11-25 21:17:14 -08001113 int rc;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001114
Patrick McHardy028b0272008-04-12 18:35:41 -07001115 BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
1116 FIELD_SIZEOF(struct sk_buff, cb));
Eric Dumazetdd24c002008-11-25 21:17:14 -08001117 rc = percpu_counter_init(&dccp_orphan_count, 0);
1118 if (rc)
Gerrit Renkerd14a0eb2010-03-14 20:13:19 +00001119 goto out_fail;
Eric Dumazetdd24c002008-11-25 21:17:14 -08001120 rc = -ENOBUFS;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001121 inet_hashinfo_init(&dccp_hashinfo);
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001122 dccp_hashinfo.bind_bucket_cachep =
1123 kmem_cache_create("dccp_bind_bucket",
1124 sizeof(struct inet_bind_bucket), 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09001125 SLAB_HWCACHE_ALIGN, NULL);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001126 if (!dccp_hashinfo.bind_bucket_cachep)
Eric Dumazetdd24c002008-11-25 21:17:14 -08001127 goto out_free_percpu;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001128
1129 /*
1130 * Size and allocate the main established and bind bucket
1131 * hash tables.
1132 *
1133 * The methodology is similar to that of the buffer cache.
1134 */
Jan Beulich44813742009-09-21 17:03:05 -07001135 if (totalram_pages >= (128 * 1024))
1136 goal = totalram_pages >> (21 - PAGE_SHIFT);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001137 else
Jan Beulich44813742009-09-21 17:03:05 -07001138 goal = totalram_pages >> (23 - PAGE_SHIFT);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001139
1140 if (thash_entries)
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001141 goal = (thash_entries *
1142 sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001143 for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1144 ;
1145 do {
Eric Dumazetf373b532009-10-09 00:16:19 +00001146 unsigned long hash_size = (1UL << ehash_order) * PAGE_SIZE /
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001147 sizeof(struct inet_ehash_bucket);
Eric Dumazetf373b532009-10-09 00:16:19 +00001148
1149 while (hash_size & (hash_size - 1))
1150 hash_size--;
1151 dccp_hashinfo.ehash_mask = hash_size - 1;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001152 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
Mel Gorman1c29b3f2009-07-29 15:04:10 -07001153 __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, ehash_order);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001154 } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1155
1156 if (!dccp_hashinfo.ehash) {
Gerrit Renker59348b12006-11-20 18:39:23 -02001157 DCCP_CRIT("Failed to allocate DCCP established hash table");
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001158 goto out_free_bind_bucket_cachep;
1159 }
1160
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001161 for (i = 0; i <= dccp_hashinfo.ehash_mask; i++)
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001162 INIT_HLIST_NULLS_HEAD(&dccp_hashinfo.ehash[i].chain, i);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001163
Eric Dumazet230140c2007-11-07 02:40:20 -08001164 if (inet_ehash_locks_alloc(&dccp_hashinfo))
1165 goto out_free_dccp_ehash;
1166
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001167 bhash_order = ehash_order;
1168
1169 do {
1170 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1171 sizeof(struct inet_bind_hashbucket);
Arnaldo Carvalho de Melo7690af32005-08-13 20:34:54 -03001172 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1173 bhash_order > 0)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001174 continue;
1175 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
Mel Gorman1c29b3f2009-07-29 15:04:10 -07001176 __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, bhash_order);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001177 } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1178
1179 if (!dccp_hashinfo.bhash) {
Gerrit Renker59348b12006-11-20 18:39:23 -02001180 DCCP_CRIT("Failed to allocate DCCP bind hash table");
Eric Dumazet230140c2007-11-07 02:40:20 -08001181 goto out_free_dccp_locks;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001182 }
1183
1184 for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1185 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1186 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1187 }
1188
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001189 rc = dccp_mib_init();
Arnaldo Carvalho de Melofa23e2e2006-03-20 17:16:01 -08001190 if (rc)
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001191 goto out_free_dccp_bhash;
1192
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001193 rc = dccp_ackvec_init();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001194 if (rc)
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001195 goto out_free_dccp_mib;
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001196
Arnaldo Carvalho de Meloe55d9122006-03-20 19:25:02 -08001197 rc = dccp_sysctl_init();
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001198 if (rc)
1199 goto out_ackvec_exit;
Gerrit Renker4c70f382007-09-25 22:40:13 -07001200
Gerrit Renkerddebc972009-01-04 21:42:53 -08001201 rc = ccid_initialize_builtins();
1202 if (rc)
1203 goto out_sysctl_exit;
1204
Gerrit Renker4c70f382007-09-25 22:40:13 -07001205 dccp_timestamping_init();
Gerrit Renkerd14a0eb2010-03-14 20:13:19 +00001206
1207 return 0;
1208
Gerrit Renkerddebc972009-01-04 21:42:53 -08001209out_sysctl_exit:
1210 dccp_sysctl_exit();
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001211out_ackvec_exit:
1212 dccp_ackvec_exit();
Arnaldo Carvalho de Melob61fafc2006-03-20 21:25:11 -08001213out_free_dccp_mib:
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001214 dccp_mib_exit();
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001215out_free_dccp_bhash:
1216 free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
Eric Dumazet230140c2007-11-07 02:40:20 -08001217out_free_dccp_locks:
1218 inet_ehash_locks_free(&dccp_hashinfo);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001219out_free_dccp_ehash:
1220 free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001221out_free_bind_bucket_cachep:
1222 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
Eric Dumazetdd24c002008-11-25 21:17:14 -08001223out_free_percpu:
1224 percpu_counter_destroy(&dccp_orphan_count);
Gerrit Renkerd14a0eb2010-03-14 20:13:19 +00001225out_fail:
1226 dccp_hashinfo.bhash = NULL;
1227 dccp_hashinfo.ehash = NULL;
1228 dccp_hashinfo.bind_bucket_cachep = NULL;
1229 return rc;
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001230}
1231
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001232static void __exit dccp_fini(void)
1233{
Gerrit Renkerddebc972009-01-04 21:42:53 -08001234 ccid_cleanup_builtins();
Arnaldo Carvalho de Melo46f09ff2006-03-20 21:24:42 -08001235 dccp_mib_exit();
Arnaldo Carvalho de Melo725ba8e2005-08-13 20:35:39 -03001236 free_pages((unsigned long)dccp_hashinfo.bhash,
1237 get_order(dccp_hashinfo.bhash_size *
1238 sizeof(struct inet_bind_hashbucket)));
1239 free_pages((unsigned long)dccp_hashinfo.ehash,
Eric Dumazetf373b532009-10-09 00:16:19 +00001240 get_order((dccp_hashinfo.ehash_mask + 1) *
Arnaldo Carvalho de Melo725ba8e2005-08-13 20:35:39 -03001241 sizeof(struct inet_ehash_bucket)));
Eric Dumazet230140c2007-11-07 02:40:20 -08001242 inet_ehash_locks_free(&dccp_hashinfo);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001243 kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
Arnaldo Carvalho de Melo9b07ef52006-03-20 17:16:17 -08001244 dccp_ackvec_exit();
Arnaldo Carvalho de Meloe55d9122006-03-20 19:25:02 -08001245 dccp_sysctl_exit();
Wei Yongjun476181c2009-08-04 21:44:39 +00001246 percpu_counter_destroy(&dccp_orphan_count);
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001247}
1248
1249module_init(dccp_init);
1250module_exit(dccp_fini);
1251
Arnaldo Carvalho de Melo7c657872005-08-09 20:14:34 -07001252MODULE_LICENSE("GPL");
1253MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1254MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");