~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/dccp/proto.c

Version: ~ [ linux-5.5 ] ~ [ linux-5.4.15 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.98 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.167 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.211 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.211 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  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 
 12 #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>
 23 #include <linux/slab.h>
 24 #include <net/checksum.h>
 25 
 26 #include <net/inet_sock.h>
 27 #include <net/sock.h>
 28 #include <net/xfrm.h>
 29 
 30 #include <asm/ioctls.h>
 31 #include <linux/spinlock.h>
 32 #include <linux/timer.h>
 33 #include <linux/delay.h>
 34 #include <linux/poll.h>
 35 
 36 #include "ccid.h"
 37 #include "dccp.h"
 38 #include "feat.h"
 39 
 40 DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
 41 
 42 EXPORT_SYMBOL_GPL(dccp_statistics);
 43 
 44 struct percpu_counter dccp_orphan_count;
 45 EXPORT_SYMBOL_GPL(dccp_orphan_count);
 46 
 47 struct inet_hashinfo dccp_hashinfo;
 48 EXPORT_SYMBOL_GPL(dccp_hashinfo);
 49 
 50 /* the maximum queue length for tx in packets. 0 is no limit */
 51 int sysctl_dccp_tx_qlen __read_mostly = 5;
 52 
 53 #ifdef CONFIG_IP_DCCP_DEBUG
 54 static 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 
 77 void dccp_set_state(struct sock *sk, const int state)
 78 {
 79         const int oldstate = sk->sk_state;
 80 
 81         dccp_pr_debug("%s(%p)  %s  -->  %s\n", dccp_role(sk), sk,
 82                       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);
 89                 /* Client retransmits all Confirm options until entering OPEN */
 90                 if (oldstate == DCCP_PARTOPEN)
 91                         dccp_feat_list_purge(&dccp_sk(sk)->dccps_featneg);
 92                 break;
 93 
 94         case DCCP_CLOSED:
 95                 if (oldstate == DCCP_OPEN || oldstate == DCCP_ACTIVE_CLOSEREQ ||
 96                     oldstate == DCCP_CLOSING)
 97                         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))
102                         inet_put_port(sk);
103                 /* 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 
115 EXPORT_SYMBOL_GPL(dccp_set_state);
116 
117 static 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 
135 void 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 
148 EXPORT_SYMBOL_GPL(dccp_done);
149 
150 const char *dccp_packet_name(const int type)
151 {
152         static const char *const dccp_packet_names[] = {
153                 [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 
171 EXPORT_SYMBOL_GPL(dccp_packet_name);
172 
173 int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
174 {
175         struct dccp_sock *dp = dccp_sk(sk);
176         struct inet_connection_sock *icsk = inet_csk(sk);
177 
178         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;
183         dp->dccps_mss_cache     = 536;
184         dp->dccps_rate_last     = jiffies;
185         dp->dccps_role          = DCCP_ROLE_UNDEFINED;
186         dp->dccps_service       = DCCP_SERVICE_CODE_IS_ABSENT;
187         dp->dccps_tx_qlen       = sysctl_dccp_tx_qlen;
188 
189         dccp_init_xmit_timers(sk);
190 
191         INIT_LIST_HEAD(&dp->dccps_featneg);
192         /* control socket doesn't need feat nego */
193         if (likely(ctl_sock_initialized))
194                 return dccp_feat_init(sk);
195         return 0;
196 }
197 
198 EXPORT_SYMBOL_GPL(dccp_init_sock);
199 
200 void dccp_destroy_sock(struct sock *sk)
201 {
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)
215                 inet_put_port(sk);
216 
217         kfree(dp->dccps_service_list);
218         dp->dccps_service_list = NULL;
219 
220         if (dp->dccps_hc_rx_ackvec != NULL) {
221                 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 */
229         dccp_feat_list_purge(&dp->dccps_featneg);
230 }
231 
232 EXPORT_SYMBOL_GPL(dccp_destroy_sock);
233 
234 static inline int dccp_listen_start(struct sock *sk, int backlog)
235 {
236         struct dccp_sock *dp = dccp_sk(sk);
237 
238         dp->dccps_role = DCCP_ROLE_LISTEN;
239         /* do not start to listen if feature negotiation setup fails */
240         if (dccp_feat_finalise_settings(dp))
241                 return -EPROTO;
242         return inet_csk_listen_start(sk, backlog);
243 }
244 
245 static inline int dccp_need_reset(int state)
246 {
247         return state != DCCP_CLOSED && state != DCCP_LISTEN &&
248                state != DCCP_REQUESTING;
249 }
250 
251 int 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 
261         /*
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          */
265         if (old_state == DCCP_LISTEN) {
266                 inet_csk_listen_stop(sk);
267         } else if (dccp_need_reset(old_state)) {
268                 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
269                 sk->sk_err = ECONNRESET;
270         } else if (old_state == DCCP_REQUESTING)
271                 sk->sk_err = ECONNRESET;
272 
273         dccp_clear_xmit_timers(sk);
274 
275         __skb_queue_purge(&sk->sk_receive_queue);
276         __skb_queue_purge(&sk->sk_write_queue);
277         if (sk->sk_send_head != NULL) {
278                 __kfree_skb(sk->sk_send_head);
279                 sk->sk_send_head = NULL;
280         }
281 
282         inet->inet_dport = 0;
283 
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 
294         WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
295 
296         sk->sk_error_report(sk);
297         return err;
298 }
299 
300 EXPORT_SYMBOL_GPL(dccp_disconnect);
301 
302 /*
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  */
309 unsigned int dccp_poll(struct file *file, struct socket *sock,
310                        poll_table *wait)
311 {
312         unsigned int mask;
313         struct sock *sk = sock->sk;
314 
315         sock_poll_wait(file, sk_sleep(sk), wait);
316         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)
331                 mask |= POLLIN | POLLRDNORM | POLLRDHUP;
332 
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)) {
339                         if (sk_stream_is_writeable(sk)) {
340                                 mask |= POLLOUT | POLLWRNORM;
341                         } else {  /* send SIGIO later */
342                                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
343                                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
344 
345                                 /* Race breaker. If space is freed after
346                                  * wspace test but before the flags are set,
347                                  * IO signal will be lost.
348                                  */
349                                 if (sk_stream_is_writeable(sk))
350                                         mask |= POLLOUT | POLLWRNORM;
351                         }
352                 }
353         }
354         return mask;
355 }
356 
357 EXPORT_SYMBOL_GPL(dccp_poll);
358 
359 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
360 {
361         int rc = -ENOTCONN;
362 
363         lock_sock(sk);
364 
365         if (sk->sk_state == DCCP_LISTEN)
366                 goto out;
367 
368         switch (cmd) {
369         case SIOCINQ: {
370                 struct sk_buff *skb;
371                 unsigned long amount = 0;
372 
373                 skb = skb_peek(&sk->sk_receive_queue);
374                 if (skb != NULL) {
375                         /*
376                          * We will only return the amount of this packet since
377                          * that is all that will be read.
378                          */
379                         amount = skb->len;
380                 }
381                 rc = put_user(amount, (int __user *)arg);
382         }
383                 break;
384         default:
385                 rc = -ENOIOCTLCMD;
386                 break;
387         }
388 out:
389         release_sock(sk);
390         return rc;
391 }
392 
393 EXPORT_SYMBOL_GPL(dccp_ioctl);
394 
395 static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
396                                    char __user *optval, unsigned int optlen)
397 {
398         struct dccp_sock *dp = dccp_sk(sk);
399         struct dccp_service_list *sl = NULL;
400 
401         if (service == DCCP_SERVICE_INVALID_VALUE ||
402             optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
403                 return -EINVAL;
404 
405         if (optlen > sizeof(service)) {
406                 sl = kmalloc(optlen, GFP_KERNEL);
407                 if (sl == NULL)
408                         return -ENOMEM;
409 
410                 sl->dccpsl_nr = optlen / sizeof(u32) - 1;
411                 if (copy_from_user(sl->dccpsl_list,
412                                    optval + sizeof(service),
413                                    optlen - sizeof(service)) ||
414                     dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
415                         kfree(sl);
416                         return -EFAULT;
417                 }
418         }
419 
420         lock_sock(sk);
421         dp->dccps_service = service;
422 
423         kfree(dp->dccps_service_list);
424 
425         dp->dccps_service_list = sl;
426         release_sock(sk);
427         return 0;
428 }
429 
430 static int dccp_setsockopt_cscov(struct sock *sk, int cscov, bool rx)
431 {
432         u8 *list, len;
433         int i, rc;
434 
435         if (cscov < 0 || cscov > 15)
436                 return -EINVAL;
437         /*
438          * Populate a list of permissible values, in the range cscov...15. This
439          * is necessary since feature negotiation of single values only works if
440          * both sides incidentally choose the same value. Since the list starts
441          * lowest-value first, negotiation will pick the smallest shared value.
442          */
443         if (cscov == 0)
444                 return 0;
445         len = 16 - cscov;
446 
447         list = kmalloc(len, GFP_KERNEL);
448         if (list == NULL)
449                 return -ENOBUFS;
450 
451         for (i = 0; i < len; i++)
452                 list[i] = cscov++;
453 
454         rc = dccp_feat_register_sp(sk, DCCPF_MIN_CSUM_COVER, rx, list, len);
455 
456         if (rc == 0) {
457                 if (rx)
458                         dccp_sk(sk)->dccps_pcrlen = cscov;
459                 else
460                         dccp_sk(sk)->dccps_pcslen = cscov;
461         }
462         kfree(list);
463         return rc;
464 }
465 
466 static int dccp_setsockopt_ccid(struct sock *sk, int type,
467                                 char __user *optval, unsigned int optlen)
468 {
469         u8 *val;
470         int rc = 0;
471 
472         if (optlen < 1 || optlen > DCCP_FEAT_MAX_SP_VALS)
473                 return -EINVAL;
474 
475         val = memdup_user(optval, optlen);
476         if (IS_ERR(val))
477                 return PTR_ERR(val);
478 
479         lock_sock(sk);
480         if (type == DCCP_SOCKOPT_TX_CCID || type == DCCP_SOCKOPT_CCID)
481                 rc = dccp_feat_register_sp(sk, DCCPF_CCID, 1, val, optlen);
482 
483         if (!rc && (type == DCCP_SOCKOPT_RX_CCID || type == DCCP_SOCKOPT_CCID))
484                 rc = dccp_feat_register_sp(sk, DCCPF_CCID, 0, val, optlen);
485         release_sock(sk);
486 
487         kfree(val);
488         return rc;
489 }
490 
491 static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
492                 char __user *optval, unsigned int optlen)
493 {
494         struct dccp_sock *dp = dccp_sk(sk);
495         int val, err = 0;
496 
497         switch (optname) {
498         case DCCP_SOCKOPT_PACKET_SIZE:
499                 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
500                 return 0;
501         case DCCP_SOCKOPT_CHANGE_L:
502         case DCCP_SOCKOPT_CHANGE_R:
503                 DCCP_WARN("sockopt(CHANGE_L/R) is deprecated: fix your app\n");
504                 return 0;
505         case DCCP_SOCKOPT_CCID:
506         case DCCP_SOCKOPT_RX_CCID:
507         case DCCP_SOCKOPT_TX_CCID:
508                 return dccp_setsockopt_ccid(sk, optname, optval, optlen);
509         }
510 
511         if (optlen < (int)sizeof(int))
512                 return -EINVAL;
513 
514         if (get_user(val, (int __user *)optval))
515                 return -EFAULT;
516 
517         if (optname == DCCP_SOCKOPT_SERVICE)
518                 return dccp_setsockopt_service(sk, val, optval, optlen);
519 
520         lock_sock(sk);
521         switch (optname) {
522         case DCCP_SOCKOPT_SERVER_TIMEWAIT:
523                 if (dp->dccps_role != DCCP_ROLE_SERVER)
524                         err = -EOPNOTSUPP;
525                 else
526                         dp->dccps_server_timewait = (val != 0);
527                 break;
528         case DCCP_SOCKOPT_SEND_CSCOV:
529                 err = dccp_setsockopt_cscov(sk, val, false);
530                 break;
531         case DCCP_SOCKOPT_RECV_CSCOV:
532                 err = dccp_setsockopt_cscov(sk, val, true);
533                 break;
534         case DCCP_SOCKOPT_QPOLICY_ID:
535                 if (sk->sk_state != DCCP_CLOSED)
536                         err = -EISCONN;
537                 else if (val < 0 || val >= DCCPQ_POLICY_MAX)
538                         err = -EINVAL;
539                 else
540                         dp->dccps_qpolicy = val;
541                 break;
542         case DCCP_SOCKOPT_QPOLICY_TXQLEN:
543                 if (val < 0)
544                         err = -EINVAL;
545                 else
546                         dp->dccps_tx_qlen = val;
547                 break;
548         default:
549                 err = -ENOPROTOOPT;
550                 break;
551         }
552         release_sock(sk);
553 
554         return err;
555 }
556 
557 int dccp_setsockopt(struct sock *sk, int level, int optname,
558                     char __user *optval, unsigned int optlen)
559 {
560         if (level != SOL_DCCP)
561                 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
562                                                              optname, optval,
563                                                              optlen);
564         return do_dccp_setsockopt(sk, level, optname, optval, optlen);
565 }
566 
567 EXPORT_SYMBOL_GPL(dccp_setsockopt);
568 
569 #ifdef CONFIG_COMPAT
570 int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
571                            char __user *optval, unsigned int optlen)
572 {
573         if (level != SOL_DCCP)
574                 return inet_csk_compat_setsockopt(sk, level, optname,
575                                                   optval, optlen);
576         return do_dccp_setsockopt(sk, level, optname, optval, optlen);
577 }
578 
579 EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
580 #endif
581 
582 static int dccp_getsockopt_service(struct sock *sk, int len,
583                                    __be32 __user *optval,
584                                    int __user *optlen)
585 {
586         const struct dccp_sock *dp = dccp_sk(sk);
587         const struct dccp_service_list *sl;
588         int err = -ENOENT, slen = 0, total_len = sizeof(u32);
589 
590         lock_sock(sk);
591         if ((sl = dp->dccps_service_list) != NULL) {
592                 slen = sl->dccpsl_nr * sizeof(u32);
593                 total_len += slen;
594         }
595 
596         err = -EINVAL;
597         if (total_len > len)
598                 goto out;
599 
600         err = 0;
601         if (put_user(total_len, optlen) ||
602             put_user(dp->dccps_service, optval) ||
603             (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
604                 err = -EFAULT;
605 out:
606         release_sock(sk);
607         return err;
608 }
609 
610 static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
611                     char __user *optval, int __user *optlen)
612 {
613         struct dccp_sock *dp;
614         int val, len;
615 
616         if (get_user(len, optlen))
617                 return -EFAULT;
618 
619         if (len < (int)sizeof(int))
620                 return -EINVAL;
621 
622         dp = dccp_sk(sk);
623 
624         switch (optname) {
625         case DCCP_SOCKOPT_PACKET_SIZE:
626                 DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
627                 return 0;
628         case DCCP_SOCKOPT_SERVICE:
629                 return dccp_getsockopt_service(sk, len,
630                                                (__be32 __user *)optval, optlen);
631         case DCCP_SOCKOPT_GET_CUR_MPS:
632                 val = dp->dccps_mss_cache;
633                 break;
634         case DCCP_SOCKOPT_AVAILABLE_CCIDS:
635                 return ccid_getsockopt_builtin_ccids(sk, len, optval, optlen);
636         case DCCP_SOCKOPT_TX_CCID:
637                 val = ccid_get_current_tx_ccid(dp);
638                 if (val < 0)
639                         return -ENOPROTOOPT;
640                 break;
641         case DCCP_SOCKOPT_RX_CCID:
642                 val = ccid_get_current_rx_ccid(dp);
643                 if (val < 0)
644                         return -ENOPROTOOPT;
645                 break;
646         case DCCP_SOCKOPT_SERVER_TIMEWAIT:
647                 val = dp->dccps_server_timewait;
648                 break;
649         case DCCP_SOCKOPT_SEND_CSCOV:
650                 val = dp->dccps_pcslen;
651                 break;
652         case DCCP_SOCKOPT_RECV_CSCOV:
653                 val = dp->dccps_pcrlen;
654                 break;
655         case DCCP_SOCKOPT_QPOLICY_ID:
656                 val = dp->dccps_qpolicy;
657                 break;
658         case DCCP_SOCKOPT_QPOLICY_TXQLEN:
659                 val = dp->dccps_tx_qlen;
660                 break;
661         case 128 ... 191:
662                 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
663                                              len, (u32 __user *)optval, optlen);
664         case 192 ... 255:
665                 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
666                                              len, (u32 __user *)optval, optlen);
667         default:
668                 return -ENOPROTOOPT;
669         }
670 
671         len = sizeof(val);
672         if (put_user(len, optlen) || copy_to_user(optval, &val, len))
673                 return -EFAULT;
674 
675         return 0;
676 }
677 
678 int dccp_getsockopt(struct sock *sk, int level, int optname,
679                     char __user *optval, int __user *optlen)
680 {
681         if (level != SOL_DCCP)
682                 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
683                                                              optname, optval,
684                                                              optlen);
685         return do_dccp_getsockopt(sk, level, optname, optval, optlen);
686 }
687 
688 EXPORT_SYMBOL_GPL(dccp_getsockopt);
689 
690 #ifdef CONFIG_COMPAT
691 int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
692                            char __user *optval, int __user *optlen)
693 {
694         if (level != SOL_DCCP)
695                 return inet_csk_compat_getsockopt(sk, level, optname,
696                                                   optval, optlen);
697         return do_dccp_getsockopt(sk, level, optname, optval, optlen);
698 }
699 
700 EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
701 #endif
702 
703 static int dccp_msghdr_parse(struct msghdr *msg, struct sk_buff *skb)
704 {
705         struct cmsghdr *cmsg;
706 
707         /*
708          * Assign an (opaque) qpolicy priority value to skb->priority.
709          *
710          * We are overloading this skb field for use with the qpolicy subystem.
711          * The skb->priority is normally used for the SO_PRIORITY option, which
712          * is initialised from sk_priority. Since the assignment of sk_priority
713          * to skb->priority happens later (on layer 3), we overload this field
714          * for use with queueing priorities as long as the skb is on layer 4.
715          * The default priority value (if nothing is set) is 0.
716          */
717         skb->priority = 0;
718 
719         for_each_cmsghdr(cmsg, msg) {
720                 if (!CMSG_OK(msg, cmsg))
721                         return -EINVAL;
722 
723                 if (cmsg->cmsg_level != SOL_DCCP)
724                         continue;
725 
726                 if (cmsg->cmsg_type <= DCCP_SCM_QPOLICY_MAX &&
727                     !dccp_qpolicy_param_ok(skb->sk, cmsg->cmsg_type))
728                         return -EINVAL;
729 
730                 switch (cmsg->cmsg_type) {
731                 case DCCP_SCM_PRIORITY:
732                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(__u32)))
733                                 return -EINVAL;
734                         skb->priority = *(__u32 *)CMSG_DATA(cmsg);
735                         break;
736                 default:
737                         return -EINVAL;
738                 }
739         }
740         return 0;
741 }
742 
743 int dccp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
744 {
745         const struct dccp_sock *dp = dccp_sk(sk);
746         const int flags = msg->msg_flags;
747         const int noblock = flags & MSG_DONTWAIT;
748         struct sk_buff *skb;
749         int rc, size;
750         long timeo;
751 
752         if (len > dp->dccps_mss_cache)
753                 return -EMSGSIZE;
754 
755         lock_sock(sk);
756 
757         if (dccp_qpolicy_full(sk)) {
758                 rc = -EAGAIN;
759                 goto out_release;
760         }
761 
762         timeo = sock_sndtimeo(sk, noblock);
763 
764         /*
765          * We have to use sk_stream_wait_connect here to set sk_write_pending,
766          * so that the trick in dccp_rcv_request_sent_state_process.
767          */
768         /* Wait for a connection to finish. */
769         if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
770                 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
771                         goto out_release;
772 
773         size = sk->sk_prot->max_header + len;
774         release_sock(sk);
775         skb = sock_alloc_send_skb(sk, size, noblock, &rc);
776         lock_sock(sk);
777         if (skb == NULL)
778                 goto out_release;
779 
780         skb_reserve(skb, sk->sk_prot->max_header);
781         rc = memcpy_from_msg(skb_put(skb, len), msg, len);
782         if (rc != 0)
783                 goto out_discard;
784 
785         rc = dccp_msghdr_parse(msg, skb);
786         if (rc != 0)
787                 goto out_discard;
788 
789         dccp_qpolicy_push(sk, skb);
790         /*
791          * The xmit_timer is set if the TX CCID is rate-based and will expire
792          * when congestion control permits to release further packets into the
793          * network. Window-based CCIDs do not use this timer.
794          */
795         if (!timer_pending(&dp->dccps_xmit_timer))
796                 dccp_write_xmit(sk);
797 out_release:
798         release_sock(sk);
799         return rc ? : len;
800 out_discard:
801         kfree_skb(skb);
802         goto out_release;
803 }
804 
805 EXPORT_SYMBOL_GPL(dccp_sendmsg);
806 
807 int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
808                  int flags, int *addr_len)
809 {
810         const struct dccp_hdr *dh;
811         long timeo;
812 
813         lock_sock(sk);
814 
815         if (sk->sk_state == DCCP_LISTEN) {
816                 len = -ENOTCONN;
817                 goto out;
818         }
819 
820         timeo = sock_rcvtimeo(sk, nonblock);
821 
822         do {
823                 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
824 
825                 if (skb == NULL)
826                         goto verify_sock_status;
827 
828                 dh = dccp_hdr(skb);
829 
830                 switch (dh->dccph_type) {
831                 case DCCP_PKT_DATA:
832                 case DCCP_PKT_DATAACK:
833                         goto found_ok_skb;
834 
835                 case DCCP_PKT_CLOSE:
836                 case DCCP_PKT_CLOSEREQ:
837                         if (!(flags & MSG_PEEK))
838                                 dccp_finish_passive_close(sk);
839                         /* fall through */
840                 case DCCP_PKT_RESET:
841                         dccp_pr_debug("found fin (%s) ok!\n",
842                                       dccp_packet_name(dh->dccph_type));
843                         len = 0;
844                         goto found_fin_ok;
845                 default:
846                         dccp_pr_debug("packet_type=%s\n",
847                                       dccp_packet_name(dh->dccph_type));
848                         sk_eat_skb(sk, skb);
849                 }
850 verify_sock_status:
851                 if (sock_flag(sk, SOCK_DONE)) {
852                         len = 0;
853                         break;
854                 }
855 
856                 if (sk->sk_err) {
857                         len = sock_error(sk);
858                         break;
859                 }
860 
861                 if (sk->sk_shutdown & RCV_SHUTDOWN) {
862                         len = 0;
863                         break;
864                 }
865 
866                 if (sk->sk_state == DCCP_CLOSED) {
867                         if (!sock_flag(sk, SOCK_DONE)) {
868                                 /* This occurs when user tries to read
869                                  * from never connected socket.
870                                  */
871                                 len = -ENOTCONN;
872                                 break;
873                         }
874                         len = 0;
875                         break;
876                 }
877 
878                 if (!timeo) {
879                         len = -EAGAIN;
880                         break;
881                 }
882 
883                 if (signal_pending(current)) {
884                         len = sock_intr_errno(timeo);
885                         break;
886                 }
887 
888                 sk_wait_data(sk, &timeo, NULL);
889                 continue;
890         found_ok_skb:
891                 if (len > skb->len)
892                         len = skb->len;
893                 else if (len < skb->len)
894                         msg->msg_flags |= MSG_TRUNC;
895 
896                 if (skb_copy_datagram_msg(skb, 0, msg, len)) {
897                         /* Exception. Bailout! */
898                         len = -EFAULT;
899                         break;
900                 }
901                 if (flags & MSG_TRUNC)
902                         len = skb->len;
903         found_fin_ok:
904                 if (!(flags & MSG_PEEK))
905                         sk_eat_skb(sk, skb);
906                 break;
907         } while (1);
908 out:
909         release_sock(sk);
910         return len;
911 }
912 
913 EXPORT_SYMBOL_GPL(dccp_recvmsg);
914 
915 int inet_dccp_listen(struct socket *sock, int backlog)
916 {
917         struct sock *sk = sock->sk;
918         unsigned char old_state;
919         int err;
920 
921         lock_sock(sk);
922 
923         err = -EINVAL;
924         if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
925                 goto out;
926 
927         old_state = sk->sk_state;
928         if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
929                 goto out;
930 
931         /* Really, if the socket is already in listen state
932          * we can only allow the backlog to be adjusted.
933          */
934         if (old_state != DCCP_LISTEN) {
935                 /*
936                  * FIXME: here it probably should be sk->sk_prot->listen_start
937                  * see tcp_listen_start
938                  */
939                 err = dccp_listen_start(sk, backlog);
940                 if (err)
941                         goto out;
942         }
943         sk->sk_max_ack_backlog = backlog;
944         err = 0;
945 
946 out:
947         release_sock(sk);
948         return err;
949 }
950 
951 EXPORT_SYMBOL_GPL(inet_dccp_listen);
952 
953 static void dccp_terminate_connection(struct sock *sk)
954 {
955         u8 next_state = DCCP_CLOSED;
956 
957         switch (sk->sk_state) {
958         case DCCP_PASSIVE_CLOSE:
959         case DCCP_PASSIVE_CLOSEREQ:
960                 dccp_finish_passive_close(sk);
961                 break;
962         case DCCP_PARTOPEN:
963                 dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
964                 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
965                 /* fall through */
966         case DCCP_OPEN:
967                 dccp_send_close(sk, 1);
968 
969                 if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
970                     !dccp_sk(sk)->dccps_server_timewait)
971                         next_state = DCCP_ACTIVE_CLOSEREQ;
972                 else
973                         next_state = DCCP_CLOSING;
974                 /* fall through */
975         default:
976                 dccp_set_state(sk, next_state);
977         }
978 }
979 
980 void dccp_close(struct sock *sk, long timeout)
981 {
982         struct dccp_sock *dp = dccp_sk(sk);
983         struct sk_buff *skb;
984         u32 data_was_unread = 0;
985         int state;
986 
987         lock_sock(sk);
988 
989         sk->sk_shutdown = SHUTDOWN_MASK;
990 
991         if (sk->sk_state == DCCP_LISTEN) {
992                 dccp_set_state(sk, DCCP_CLOSED);
993 
994                 /* Special case. */
995                 inet_csk_listen_stop(sk);
996 
997                 goto adjudge_to_death;
998         }
999 
1000         sk_stop_timer(sk, &dp->dccps_xmit_timer);
1001 
1002         /*
1003          * We need to flush the recv. buffs.  We do this only on the
1004          * descriptor close, not protocol-sourced closes, because the
1005           *reader process may not have drained the data yet!
1006          */
1007         while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
1008                 data_was_unread += skb->len;
1009                 __kfree_skb(skb);
1010         }
1011 
1012         /* If socket has been already reset kill it. */
1013         if (sk->sk_state == DCCP_CLOSED)
1014                 goto adjudge_to_death;
1015 
1016         if (data_was_unread) {
1017                 /* Unread data was tossed, send an appropriate Reset Code */
1018                 DCCP_WARN("ABORT with %u bytes unread\n", data_was_unread);
1019                 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
1020                 dccp_set_state(sk, DCCP_CLOSED);
1021         } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
1022                 /* Check zero linger _after_ checking for unread data. */
1023                 sk->sk_prot->disconnect(sk, 0);
1024         } else if (sk->sk_state != DCCP_CLOSED) {
1025                 /*
1026                  * Normal connection termination. May need to wait if there are
1027                  * still packets in the TX queue that are delayed by the CCID.
1028                  */
1029                 dccp_flush_write_queue(sk, &timeout);
1030                 dccp_terminate_connection(sk);
1031         }
1032 
1033         /*
1034          * Flush write queue. This may be necessary in several cases:
1035          * - we have been closed by the peer but still have application data;
1036          * - abortive termination (unread data or zero linger time),
1037          * - normal termination but queue could not be flushed within time limit
1038          */
1039         __skb_queue_purge(&sk->sk_write_queue);
1040 
1041         sk_stream_wait_close(sk, timeout);
1042 
1043 adjudge_to_death:
1044         state = sk->sk_state;
1045         sock_hold(sk);
1046         sock_orphan(sk);
1047 
1048         /*
1049          * It is the last release_sock in its life. It will remove backlog.
1050          */
1051         release_sock(sk);
1052         /*
1053          * Now socket is owned by kernel and we acquire BH lock
1054          * to finish close. No need to check for user refs.
1055          */
1056         local_bh_disable();
1057         bh_lock_sock(sk);
1058         WARN_ON(sock_owned_by_user(sk));
1059 
1060         percpu_counter_inc(sk->sk_prot->orphan_count);
1061 
1062         /* Have we already been destroyed by a softirq or backlog? */
1063         if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
1064                 goto out;
1065 
1066         if (sk->sk_state == DCCP_CLOSED)
1067                 inet_csk_destroy_sock(sk);
1068 
1069         /* Otherwise, socket is reprieved until protocol close. */
1070 
1071 out:
1072         bh_unlock_sock(sk);
1073         local_bh_enable();
1074         sock_put(sk);
1075 }
1076 
1077 EXPORT_SYMBOL_GPL(dccp_close);
1078 
1079 void dccp_shutdown(struct sock *sk, int how)
1080 {
1081         dccp_pr_debug("called shutdown(%x)\n", how);
1082 }
1083 
1084 EXPORT_SYMBOL_GPL(dccp_shutdown);
1085 
1086 static inline int __init dccp_mib_init(void)
1087 {
1088         dccp_statistics = alloc_percpu(struct dccp_mib);
1089         if (!dccp_statistics)
1090                 return -ENOMEM;
1091         return 0;
1092 }
1093 
1094 static inline void dccp_mib_exit(void)
1095 {
1096         free_percpu(dccp_statistics);
1097 }
1098 
1099 static int thash_entries;
1100 module_param(thash_entries, int, 0444);
1101 MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
1102 
1103 #ifdef CONFIG_IP_DCCP_DEBUG
1104 bool dccp_debug;
1105 module_param(dccp_debug, bool, 0644);
1106 MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
1107 
1108 EXPORT_SYMBOL_GPL(dccp_debug);
1109 #endif
1110 
1111 static int __init dccp_init(void)
1112 {
1113         unsigned long goal;
1114         int ehash_order, bhash_order, i;
1115         int rc;
1116 
1117         BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
1118                      FIELD_SIZEOF(struct sk_buff, cb));
1119         rc = percpu_counter_init(&dccp_orphan_count, 0, GFP_KERNEL);
1120         if (rc)
1121                 goto out_fail;
1122         rc = -ENOBUFS;
1123         inet_hashinfo_init(&dccp_hashinfo);
1124         dccp_hashinfo.bind_bucket_cachep =
1125                 kmem_cache_create("dccp_bind_bucket",
1126                                   sizeof(struct inet_bind_bucket), 0,
1127                                   SLAB_HWCACHE_ALIGN, NULL);
1128         if (!dccp_hashinfo.bind_bucket_cachep)
1129                 goto out_free_percpu;
1130 
1131         /*
1132          * Size and allocate the main established and bind bucket
1133          * hash tables.
1134          *
1135          * The methodology is similar to that of the buffer cache.
1136          */
1137         if (totalram_pages >= (128 * 1024))
1138                 goal = totalram_pages >> (21 - PAGE_SHIFT);
1139         else
1140                 goal = totalram_pages >> (23 - PAGE_SHIFT);
1141 
1142         if (thash_entries)
1143                 goal = (thash_entries *
1144                         sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
1145         for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
1146                 ;
1147         do {
1148                 unsigned long hash_size = (1UL << ehash_order) * PAGE_SIZE /
1149                                         sizeof(struct inet_ehash_bucket);
1150 
1151                 while (hash_size & (hash_size - 1))
1152                         hash_size--;
1153                 dccp_hashinfo.ehash_mask = hash_size - 1;
1154                 dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
1155                         __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, ehash_order);
1156         } while (!dccp_hashinfo.ehash && --ehash_order > 0);
1157 
1158         if (!dccp_hashinfo.ehash) {
1159                 DCCP_CRIT("Failed to allocate DCCP established hash table");
1160                 goto out_free_bind_bucket_cachep;
1161         }
1162 
1163         for (i = 0; i <= dccp_hashinfo.ehash_mask; i++)
1164                 INIT_HLIST_NULLS_HEAD(&dccp_hashinfo.ehash[i].chain, i);
1165 
1166         if (inet_ehash_locks_alloc(&dccp_hashinfo))
1167                         goto out_free_dccp_ehash;
1168 
1169         bhash_order = ehash_order;
1170 
1171         do {
1172                 dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
1173                                         sizeof(struct inet_bind_hashbucket);
1174                 if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
1175                     bhash_order > 0)
1176                         continue;
1177                 dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
1178                         __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, bhash_order);
1179         } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
1180 
1181         if (!dccp_hashinfo.bhash) {
1182                 DCCP_CRIT("Failed to allocate DCCP bind hash table");
1183                 goto out_free_dccp_locks;
1184         }
1185 
1186         for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
1187                 spin_lock_init(&dccp_hashinfo.bhash[i].lock);
1188                 INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
1189         }
1190 
1191         rc = dccp_mib_init();
1192         if (rc)
1193                 goto out_free_dccp_bhash;
1194 
1195         rc = dccp_ackvec_init();
1196         if (rc)
1197                 goto out_free_dccp_mib;
1198 
1199         rc = dccp_sysctl_init();
1200         if (rc)
1201                 goto out_ackvec_exit;
1202 
1203         rc = ccid_initialize_builtins();
1204         if (rc)
1205                 goto out_sysctl_exit;
1206 
1207         dccp_timestamping_init();
1208 
1209         return 0;
1210 
1211 out_sysctl_exit:
1212         dccp_sysctl_exit();
1213 out_ackvec_exit:
1214         dccp_ackvec_exit();
1215 out_free_dccp_mib:
1216         dccp_mib_exit();
1217 out_free_dccp_bhash:
1218         free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
1219 out_free_dccp_locks:
1220         inet_ehash_locks_free(&dccp_hashinfo);
1221 out_free_dccp_ehash:
1222         free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
1223 out_free_bind_bucket_cachep:
1224         kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1225 out_free_percpu:
1226         percpu_counter_destroy(&dccp_orphan_count);
1227 out_fail:
1228         dccp_hashinfo.bhash = NULL;
1229         dccp_hashinfo.ehash = NULL;
1230         dccp_hashinfo.bind_bucket_cachep = NULL;
1231         return rc;
1232 }
1233 
1234 static void __exit dccp_fini(void)
1235 {
1236         ccid_cleanup_builtins();
1237         dccp_mib_exit();
1238         free_pages((unsigned long)dccp_hashinfo.bhash,
1239                    get_order(dccp_hashinfo.bhash_size *
1240                              sizeof(struct inet_bind_hashbucket)));
1241         free_pages((unsigned long)dccp_hashinfo.ehash,
1242                    get_order((dccp_hashinfo.ehash_mask + 1) *
1243                              sizeof(struct inet_ehash_bucket)));
1244         inet_ehash_locks_free(&dccp_hashinfo);
1245         kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
1246         dccp_ackvec_exit();
1247         dccp_sysctl_exit();
1248         percpu_counter_destroy(&dccp_orphan_count);
1249 }
1250 
1251 module_init(dccp_init);
1252 module_exit(dccp_fini);
1253 
1254 MODULE_LICENSE("GPL");
1255 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
1256 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");
1257 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp