proto.c 30 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * net/dccp/proto.c
  4. *
  5. * An implementation of the DCCP protocol
  6. * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  7. */
  8. #include <linux/dccp.h>
  9. #include <linux/module.h>
  10. #include <linux/types.h>
  11. #include <linux/sched.h>
  12. #include <linux/kernel.h>
  13. #include <linux/skbuff.h>
  14. #include <linux/netdevice.h>
  15. #include <linux/in.h>
  16. #include <linux/if_arp.h>
  17. #include <linux/init.h>
  18. #include <linux/random.h>
  19. #include <linux/slab.h>
  20. #include <net/checksum.h>
  21. #include <net/inet_sock.h>
  22. #include <net/inet_common.h>
  23. #include <net/sock.h>
  24. #include <net/xfrm.h>
  25. #include <asm/ioctls.h>
  26. #include <linux/spinlock.h>
  27. #include <linux/timer.h>
  28. #include <linux/delay.h>
  29. #include <linux/poll.h>
  30. #include "ccid.h"
  31. #include "dccp.h"
  32. #include "feat.h"
  33. #define CREATE_TRACE_POINTS
  34. #include "trace.h"
  35. DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
  36. EXPORT_SYMBOL_GPL(dccp_statistics);
  37. struct percpu_counter dccp_orphan_count;
  38. EXPORT_SYMBOL_GPL(dccp_orphan_count);
  39. struct inet_hashinfo dccp_hashinfo;
  40. EXPORT_SYMBOL_GPL(dccp_hashinfo);
  41. /* the maximum queue length for tx in packets. 0 is no limit */
  42. int sysctl_dccp_tx_qlen __read_mostly = 5;
  43. #ifdef CONFIG_IP_DCCP_DEBUG
  44. static const char *dccp_state_name(const int state)
  45. {
  46. static const char *const dccp_state_names[] = {
  47. [DCCP_OPEN] = "OPEN",
  48. [DCCP_REQUESTING] = "REQUESTING",
  49. [DCCP_PARTOPEN] = "PARTOPEN",
  50. [DCCP_LISTEN] = "LISTEN",
  51. [DCCP_RESPOND] = "RESPOND",
  52. [DCCP_CLOSING] = "CLOSING",
  53. [DCCP_ACTIVE_CLOSEREQ] = "CLOSEREQ",
  54. [DCCP_PASSIVE_CLOSE] = "PASSIVE_CLOSE",
  55. [DCCP_PASSIVE_CLOSEREQ] = "PASSIVE_CLOSEREQ",
  56. [DCCP_TIME_WAIT] = "TIME_WAIT",
  57. [DCCP_CLOSED] = "CLOSED",
  58. };
  59. if (state >= DCCP_MAX_STATES)
  60. return "INVALID STATE!";
  61. else
  62. return dccp_state_names[state];
  63. }
  64. #endif
  65. void dccp_set_state(struct sock *sk, const int state)
  66. {
  67. const int oldstate = sk->sk_state;
  68. dccp_pr_debug("%s(%p) %s --> %s\n", dccp_role(sk), sk,
  69. dccp_state_name(oldstate), dccp_state_name(state));
  70. WARN_ON(state == oldstate);
  71. switch (state) {
  72. case DCCP_OPEN:
  73. if (oldstate != DCCP_OPEN)
  74. DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
  75. /* Client retransmits all Confirm options until entering OPEN */
  76. if (oldstate == DCCP_PARTOPEN)
  77. dccp_feat_list_purge(&dccp_sk(sk)->dccps_featneg);
  78. break;
  79. case DCCP_CLOSED:
  80. if (oldstate == DCCP_OPEN || oldstate == DCCP_ACTIVE_CLOSEREQ ||
  81. oldstate == DCCP_CLOSING)
  82. DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
  83. sk->sk_prot->unhash(sk);
  84. if (inet_csk(sk)->icsk_bind_hash != NULL &&
  85. !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
  86. inet_put_port(sk);
  87. fallthrough;
  88. default:
  89. if (oldstate == DCCP_OPEN)
  90. DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
  91. }
  92. /* Change state AFTER socket is unhashed to avoid closed
  93. * socket sitting in hash tables.
  94. */
  95. inet_sk_set_state(sk, state);
  96. }
  97. EXPORT_SYMBOL_GPL(dccp_set_state);
  98. static void dccp_finish_passive_close(struct sock *sk)
  99. {
  100. switch (sk->sk_state) {
  101. case DCCP_PASSIVE_CLOSE:
  102. /* Node (client or server) has received Close packet. */
  103. dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
  104. dccp_set_state(sk, DCCP_CLOSED);
  105. break;
  106. case DCCP_PASSIVE_CLOSEREQ:
  107. /*
  108. * Client received CloseReq. We set the `active' flag so that
  109. * dccp_send_close() retransmits the Close as per RFC 4340, 8.3.
  110. */
  111. dccp_send_close(sk, 1);
  112. dccp_set_state(sk, DCCP_CLOSING);
  113. }
  114. }
  115. void dccp_done(struct sock *sk)
  116. {
  117. dccp_set_state(sk, DCCP_CLOSED);
  118. dccp_clear_xmit_timers(sk);
  119. sk->sk_shutdown = SHUTDOWN_MASK;
  120. if (!sock_flag(sk, SOCK_DEAD))
  121. sk->sk_state_change(sk);
  122. else
  123. inet_csk_destroy_sock(sk);
  124. }
  125. EXPORT_SYMBOL_GPL(dccp_done);
  126. const char *dccp_packet_name(const int type)
  127. {
  128. static const char *const dccp_packet_names[] = {
  129. [DCCP_PKT_REQUEST] = "REQUEST",
  130. [DCCP_PKT_RESPONSE] = "RESPONSE",
  131. [DCCP_PKT_DATA] = "DATA",
  132. [DCCP_PKT_ACK] = "ACK",
  133. [DCCP_PKT_DATAACK] = "DATAACK",
  134. [DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
  135. [DCCP_PKT_CLOSE] = "CLOSE",
  136. [DCCP_PKT_RESET] = "RESET",
  137. [DCCP_PKT_SYNC] = "SYNC",
  138. [DCCP_PKT_SYNCACK] = "SYNCACK",
  139. };
  140. if (type >= DCCP_NR_PKT_TYPES)
  141. return "INVALID";
  142. else
  143. return dccp_packet_names[type];
  144. }
  145. EXPORT_SYMBOL_GPL(dccp_packet_name);
  146. static void dccp_sk_destruct(struct sock *sk)
  147. {
  148. struct dccp_sock *dp = dccp_sk(sk);
  149. ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
  150. dp->dccps_hc_tx_ccid = NULL;
  151. inet_sock_destruct(sk);
  152. }
  153. int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
  154. {
  155. struct dccp_sock *dp = dccp_sk(sk);
  156. struct inet_connection_sock *icsk = inet_csk(sk);
  157. icsk->icsk_rto = DCCP_TIMEOUT_INIT;
  158. icsk->icsk_syn_retries = sysctl_dccp_request_retries;
  159. sk->sk_state = DCCP_CLOSED;
  160. sk->sk_write_space = dccp_write_space;
  161. sk->sk_destruct = dccp_sk_destruct;
  162. icsk->icsk_sync_mss = dccp_sync_mss;
  163. dp->dccps_mss_cache = 536;
  164. dp->dccps_rate_last = jiffies;
  165. dp->dccps_role = DCCP_ROLE_UNDEFINED;
  166. dp->dccps_service = DCCP_SERVICE_CODE_IS_ABSENT;
  167. dp->dccps_tx_qlen = sysctl_dccp_tx_qlen;
  168. dccp_init_xmit_timers(sk);
  169. INIT_LIST_HEAD(&dp->dccps_featneg);
  170. /* control socket doesn't need feat nego */
  171. if (likely(ctl_sock_initialized))
  172. return dccp_feat_init(sk);
  173. return 0;
  174. }
  175. EXPORT_SYMBOL_GPL(dccp_init_sock);
  176. void dccp_destroy_sock(struct sock *sk)
  177. {
  178. struct dccp_sock *dp = dccp_sk(sk);
  179. __skb_queue_purge(&sk->sk_write_queue);
  180. if (sk->sk_send_head != NULL) {
  181. kfree_skb(sk->sk_send_head);
  182. sk->sk_send_head = NULL;
  183. }
  184. /* Clean up a referenced DCCP bind bucket. */
  185. if (inet_csk(sk)->icsk_bind_hash != NULL)
  186. inet_put_port(sk);
  187. kfree(dp->dccps_service_list);
  188. dp->dccps_service_list = NULL;
  189. if (dp->dccps_hc_rx_ackvec != NULL) {
  190. dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
  191. dp->dccps_hc_rx_ackvec = NULL;
  192. }
  193. ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
  194. dp->dccps_hc_rx_ccid = NULL;
  195. /* clean up feature negotiation state */
  196. dccp_feat_list_purge(&dp->dccps_featneg);
  197. }
  198. EXPORT_SYMBOL_GPL(dccp_destroy_sock);
  199. static inline int dccp_listen_start(struct sock *sk, int backlog)
  200. {
  201. struct dccp_sock *dp = dccp_sk(sk);
  202. dp->dccps_role = DCCP_ROLE_LISTEN;
  203. /* do not start to listen if feature negotiation setup fails */
  204. if (dccp_feat_finalise_settings(dp))
  205. return -EPROTO;
  206. return inet_csk_listen_start(sk, backlog);
  207. }
  208. static inline int dccp_need_reset(int state)
  209. {
  210. return state != DCCP_CLOSED && state != DCCP_LISTEN &&
  211. state != DCCP_REQUESTING;
  212. }
  213. int dccp_disconnect(struct sock *sk, int flags)
  214. {
  215. struct inet_connection_sock *icsk = inet_csk(sk);
  216. struct inet_sock *inet = inet_sk(sk);
  217. struct dccp_sock *dp = dccp_sk(sk);
  218. const int old_state = sk->sk_state;
  219. if (old_state != DCCP_CLOSED)
  220. dccp_set_state(sk, DCCP_CLOSED);
  221. /*
  222. * This corresponds to the ABORT function of RFC793, sec. 3.8
  223. * TCP uses a RST segment, DCCP a Reset packet with Code 2, "Aborted".
  224. */
  225. if (old_state == DCCP_LISTEN) {
  226. inet_csk_listen_stop(sk);
  227. } else if (dccp_need_reset(old_state)) {
  228. dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
  229. sk->sk_err = ECONNRESET;
  230. } else if (old_state == DCCP_REQUESTING)
  231. sk->sk_err = ECONNRESET;
  232. dccp_clear_xmit_timers(sk);
  233. ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
  234. dp->dccps_hc_rx_ccid = NULL;
  235. __skb_queue_purge(&sk->sk_receive_queue);
  236. __skb_queue_purge(&sk->sk_write_queue);
  237. if (sk->sk_send_head != NULL) {
  238. __kfree_skb(sk->sk_send_head);
  239. sk->sk_send_head = NULL;
  240. }
  241. inet->inet_dport = 0;
  242. if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
  243. inet_reset_saddr(sk);
  244. sk->sk_shutdown = 0;
  245. sock_reset_flag(sk, SOCK_DONE);
  246. icsk->icsk_backoff = 0;
  247. inet_csk_delack_init(sk);
  248. __sk_dst_reset(sk);
  249. WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
  250. sk->sk_error_report(sk);
  251. return 0;
  252. }
  253. EXPORT_SYMBOL_GPL(dccp_disconnect);
  254. /*
  255. * Wait for a DCCP event.
  256. *
  257. * Note that we don't need to lock the socket, as the upper poll layers
  258. * take care of normal races (between the test and the event) and we don't
  259. * go look at any of the socket buffers directly.
  260. */
  261. __poll_t dccp_poll(struct file *file, struct socket *sock,
  262. poll_table *wait)
  263. {
  264. __poll_t mask;
  265. struct sock *sk = sock->sk;
  266. sock_poll_wait(file, sock, wait);
  267. if (sk->sk_state == DCCP_LISTEN)
  268. return inet_csk_listen_poll(sk);
  269. /* Socket is not locked. We are protected from async events
  270. by poll logic and correct handling of state changes
  271. made by another threads is impossible in any case.
  272. */
  273. mask = 0;
  274. if (sk->sk_err)
  275. mask = EPOLLERR;
  276. if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
  277. mask |= EPOLLHUP;
  278. if (sk->sk_shutdown & RCV_SHUTDOWN)
  279. mask |= EPOLLIN | EPOLLRDNORM | EPOLLRDHUP;
  280. /* Connected? */
  281. if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
  282. if (atomic_read(&sk->sk_rmem_alloc) > 0)
  283. mask |= EPOLLIN | EPOLLRDNORM;
  284. if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
  285. if (sk_stream_is_writeable(sk)) {
  286. mask |= EPOLLOUT | EPOLLWRNORM;
  287. } else { /* send SIGIO later */
  288. sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
  289. set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
  290. /* Race breaker. If space is freed after
  291. * wspace test but before the flags are set,
  292. * IO signal will be lost.
  293. */
  294. if (sk_stream_is_writeable(sk))
  295. mask |= EPOLLOUT | EPOLLWRNORM;
  296. }
  297. }
  298. }
  299. return mask;
  300. }
  301. EXPORT_SYMBOL_GPL(dccp_poll);
  302. int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
  303. {
  304. int rc = -ENOTCONN;
  305. lock_sock(sk);
  306. if (sk->sk_state == DCCP_LISTEN)
  307. goto out;
  308. switch (cmd) {
  309. case SIOCOUTQ: {
  310. int amount = sk_wmem_alloc_get(sk);
  311. /* Using sk_wmem_alloc here because sk_wmem_queued is not used by DCCP and
  312. * always 0, comparably to UDP.
  313. */
  314. rc = put_user(amount, (int __user *)arg);
  315. }
  316. break;
  317. case SIOCINQ: {
  318. struct sk_buff *skb;
  319. unsigned long amount = 0;
  320. skb = skb_peek(&sk->sk_receive_queue);
  321. if (skb != NULL) {
  322. /*
  323. * We will only return the amount of this packet since
  324. * that is all that will be read.
  325. */
  326. amount = skb->len;
  327. }
  328. rc = put_user(amount, (int __user *)arg);
  329. }
  330. break;
  331. default:
  332. rc = -ENOIOCTLCMD;
  333. break;
  334. }
  335. out:
  336. release_sock(sk);
  337. return rc;
  338. }
  339. EXPORT_SYMBOL_GPL(dccp_ioctl);
  340. static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
  341. sockptr_t optval, unsigned int optlen)
  342. {
  343. struct dccp_sock *dp = dccp_sk(sk);
  344. struct dccp_service_list *sl = NULL;
  345. if (service == DCCP_SERVICE_INVALID_VALUE ||
  346. optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
  347. return -EINVAL;
  348. if (optlen > sizeof(service)) {
  349. sl = kmalloc(optlen, GFP_KERNEL);
  350. if (sl == NULL)
  351. return -ENOMEM;
  352. sl->dccpsl_nr = optlen / sizeof(u32) - 1;
  353. if (copy_from_sockptr_offset(sl->dccpsl_list, optval,
  354. sizeof(service), optlen - sizeof(service)) ||
  355. dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
  356. kfree(sl);
  357. return -EFAULT;
  358. }
  359. }
  360. lock_sock(sk);
  361. dp->dccps_service = service;
  362. kfree(dp->dccps_service_list);
  363. dp->dccps_service_list = sl;
  364. release_sock(sk);
  365. return 0;
  366. }
  367. static int dccp_setsockopt_cscov(struct sock *sk, int cscov, bool rx)
  368. {
  369. u8 *list, len;
  370. int i, rc;
  371. if (cscov < 0 || cscov > 15)
  372. return -EINVAL;
  373. /*
  374. * Populate a list of permissible values, in the range cscov...15. This
  375. * is necessary since feature negotiation of single values only works if
  376. * both sides incidentally choose the same value. Since the list starts
  377. * lowest-value first, negotiation will pick the smallest shared value.
  378. */
  379. if (cscov == 0)
  380. return 0;
  381. len = 16 - cscov;
  382. list = kmalloc(len, GFP_KERNEL);
  383. if (list == NULL)
  384. return -ENOBUFS;
  385. for (i = 0; i < len; i++)
  386. list[i] = cscov++;
  387. rc = dccp_feat_register_sp(sk, DCCPF_MIN_CSUM_COVER, rx, list, len);
  388. if (rc == 0) {
  389. if (rx)
  390. dccp_sk(sk)->dccps_pcrlen = cscov;
  391. else
  392. dccp_sk(sk)->dccps_pcslen = cscov;
  393. }
  394. kfree(list);
  395. return rc;
  396. }
  397. static int dccp_setsockopt_ccid(struct sock *sk, int type,
  398. sockptr_t optval, unsigned int optlen)
  399. {
  400. u8 *val;
  401. int rc = 0;
  402. if (optlen < 1 || optlen > DCCP_FEAT_MAX_SP_VALS)
  403. return -EINVAL;
  404. val = memdup_sockptr(optval, optlen);
  405. if (IS_ERR(val))
  406. return PTR_ERR(val);
  407. lock_sock(sk);
  408. if (type == DCCP_SOCKOPT_TX_CCID || type == DCCP_SOCKOPT_CCID)
  409. rc = dccp_feat_register_sp(sk, DCCPF_CCID, 1, val, optlen);
  410. if (!rc && (type == DCCP_SOCKOPT_RX_CCID || type == DCCP_SOCKOPT_CCID))
  411. rc = dccp_feat_register_sp(sk, DCCPF_CCID, 0, val, optlen);
  412. release_sock(sk);
  413. kfree(val);
  414. return rc;
  415. }
  416. static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
  417. sockptr_t optval, unsigned int optlen)
  418. {
  419. struct dccp_sock *dp = dccp_sk(sk);
  420. int val, err = 0;
  421. switch (optname) {
  422. case DCCP_SOCKOPT_PACKET_SIZE:
  423. DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
  424. return 0;
  425. case DCCP_SOCKOPT_CHANGE_L:
  426. case DCCP_SOCKOPT_CHANGE_R:
  427. DCCP_WARN("sockopt(CHANGE_L/R) is deprecated: fix your app\n");
  428. return 0;
  429. case DCCP_SOCKOPT_CCID:
  430. case DCCP_SOCKOPT_RX_CCID:
  431. case DCCP_SOCKOPT_TX_CCID:
  432. return dccp_setsockopt_ccid(sk, optname, optval, optlen);
  433. }
  434. if (optlen < (int)sizeof(int))
  435. return -EINVAL;
  436. if (copy_from_sockptr(&val, optval, sizeof(int)))
  437. return -EFAULT;
  438. if (optname == DCCP_SOCKOPT_SERVICE)
  439. return dccp_setsockopt_service(sk, val, optval, optlen);
  440. lock_sock(sk);
  441. switch (optname) {
  442. case DCCP_SOCKOPT_SERVER_TIMEWAIT:
  443. if (dp->dccps_role != DCCP_ROLE_SERVER)
  444. err = -EOPNOTSUPP;
  445. else
  446. dp->dccps_server_timewait = (val != 0);
  447. break;
  448. case DCCP_SOCKOPT_SEND_CSCOV:
  449. err = dccp_setsockopt_cscov(sk, val, false);
  450. break;
  451. case DCCP_SOCKOPT_RECV_CSCOV:
  452. err = dccp_setsockopt_cscov(sk, val, true);
  453. break;
  454. case DCCP_SOCKOPT_QPOLICY_ID:
  455. if (sk->sk_state != DCCP_CLOSED)
  456. err = -EISCONN;
  457. else if (val < 0 || val >= DCCPQ_POLICY_MAX)
  458. err = -EINVAL;
  459. else
  460. dp->dccps_qpolicy = val;
  461. break;
  462. case DCCP_SOCKOPT_QPOLICY_TXQLEN:
  463. if (val < 0)
  464. err = -EINVAL;
  465. else
  466. dp->dccps_tx_qlen = val;
  467. break;
  468. default:
  469. err = -ENOPROTOOPT;
  470. break;
  471. }
  472. release_sock(sk);
  473. return err;
  474. }
  475. int dccp_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval,
  476. unsigned int optlen)
  477. {
  478. if (level != SOL_DCCP)
  479. return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
  480. optname, optval,
  481. optlen);
  482. return do_dccp_setsockopt(sk, level, optname, optval, optlen);
  483. }
  484. EXPORT_SYMBOL_GPL(dccp_setsockopt);
  485. static int dccp_getsockopt_service(struct sock *sk, int len,
  486. __be32 __user *optval,
  487. int __user *optlen)
  488. {
  489. const struct dccp_sock *dp = dccp_sk(sk);
  490. const struct dccp_service_list *sl;
  491. int err = -ENOENT, slen = 0, total_len = sizeof(u32);
  492. lock_sock(sk);
  493. if ((sl = dp->dccps_service_list) != NULL) {
  494. slen = sl->dccpsl_nr * sizeof(u32);
  495. total_len += slen;
  496. }
  497. err = -EINVAL;
  498. if (total_len > len)
  499. goto out;
  500. err = 0;
  501. if (put_user(total_len, optlen) ||
  502. put_user(dp->dccps_service, optval) ||
  503. (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
  504. err = -EFAULT;
  505. out:
  506. release_sock(sk);
  507. return err;
  508. }
  509. static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
  510. char __user *optval, int __user *optlen)
  511. {
  512. struct dccp_sock *dp;
  513. int val, len;
  514. if (get_user(len, optlen))
  515. return -EFAULT;
  516. if (len < (int)sizeof(int))
  517. return -EINVAL;
  518. dp = dccp_sk(sk);
  519. switch (optname) {
  520. case DCCP_SOCKOPT_PACKET_SIZE:
  521. DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
  522. return 0;
  523. case DCCP_SOCKOPT_SERVICE:
  524. return dccp_getsockopt_service(sk, len,
  525. (__be32 __user *)optval, optlen);
  526. case DCCP_SOCKOPT_GET_CUR_MPS:
  527. val = dp->dccps_mss_cache;
  528. break;
  529. case DCCP_SOCKOPT_AVAILABLE_CCIDS:
  530. return ccid_getsockopt_builtin_ccids(sk, len, optval, optlen);
  531. case DCCP_SOCKOPT_TX_CCID:
  532. val = ccid_get_current_tx_ccid(dp);
  533. if (val < 0)
  534. return -ENOPROTOOPT;
  535. break;
  536. case DCCP_SOCKOPT_RX_CCID:
  537. val = ccid_get_current_rx_ccid(dp);
  538. if (val < 0)
  539. return -ENOPROTOOPT;
  540. break;
  541. case DCCP_SOCKOPT_SERVER_TIMEWAIT:
  542. val = dp->dccps_server_timewait;
  543. break;
  544. case DCCP_SOCKOPT_SEND_CSCOV:
  545. val = dp->dccps_pcslen;
  546. break;
  547. case DCCP_SOCKOPT_RECV_CSCOV:
  548. val = dp->dccps_pcrlen;
  549. break;
  550. case DCCP_SOCKOPT_QPOLICY_ID:
  551. val = dp->dccps_qpolicy;
  552. break;
  553. case DCCP_SOCKOPT_QPOLICY_TXQLEN:
  554. val = dp->dccps_tx_qlen;
  555. break;
  556. case 128 ... 191:
  557. return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
  558. len, (u32 __user *)optval, optlen);
  559. case 192 ... 255:
  560. return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
  561. len, (u32 __user *)optval, optlen);
  562. default:
  563. return -ENOPROTOOPT;
  564. }
  565. len = sizeof(val);
  566. if (put_user(len, optlen) || copy_to_user(optval, &val, len))
  567. return -EFAULT;
  568. return 0;
  569. }
  570. int dccp_getsockopt(struct sock *sk, int level, int optname,
  571. char __user *optval, int __user *optlen)
  572. {
  573. if (level != SOL_DCCP)
  574. return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
  575. optname, optval,
  576. optlen);
  577. return do_dccp_getsockopt(sk, level, optname, optval, optlen);
  578. }
  579. EXPORT_SYMBOL_GPL(dccp_getsockopt);
  580. static int dccp_msghdr_parse(struct msghdr *msg, struct sk_buff *skb)
  581. {
  582. struct cmsghdr *cmsg;
  583. /*
  584. * Assign an (opaque) qpolicy priority value to skb->priority.
  585. *
  586. * We are overloading this skb field for use with the qpolicy subystem.
  587. * The skb->priority is normally used for the SO_PRIORITY option, which
  588. * is initialised from sk_priority. Since the assignment of sk_priority
  589. * to skb->priority happens later (on layer 3), we overload this field
  590. * for use with queueing priorities as long as the skb is on layer 4.
  591. * The default priority value (if nothing is set) is 0.
  592. */
  593. skb->priority = 0;
  594. for_each_cmsghdr(cmsg, msg) {
  595. if (!CMSG_OK(msg, cmsg))
  596. return -EINVAL;
  597. if (cmsg->cmsg_level != SOL_DCCP)
  598. continue;
  599. if (cmsg->cmsg_type <= DCCP_SCM_QPOLICY_MAX &&
  600. !dccp_qpolicy_param_ok(skb->sk, cmsg->cmsg_type))
  601. return -EINVAL;
  602. switch (cmsg->cmsg_type) {
  603. case DCCP_SCM_PRIORITY:
  604. if (cmsg->cmsg_len != CMSG_LEN(sizeof(__u32)))
  605. return -EINVAL;
  606. skb->priority = *(__u32 *)CMSG_DATA(cmsg);
  607. break;
  608. default:
  609. return -EINVAL;
  610. }
  611. }
  612. return 0;
  613. }
  614. int dccp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
  615. {
  616. const struct dccp_sock *dp = dccp_sk(sk);
  617. const int flags = msg->msg_flags;
  618. const int noblock = flags & MSG_DONTWAIT;
  619. struct sk_buff *skb;
  620. int rc, size;
  621. long timeo;
  622. trace_dccp_probe(sk, len);
  623. if (len > dp->dccps_mss_cache)
  624. return -EMSGSIZE;
  625. lock_sock(sk);
  626. if (dccp_qpolicy_full(sk)) {
  627. rc = -EAGAIN;
  628. goto out_release;
  629. }
  630. timeo = sock_sndtimeo(sk, noblock);
  631. /*
  632. * We have to use sk_stream_wait_connect here to set sk_write_pending,
  633. * so that the trick in dccp_rcv_request_sent_state_process.
  634. */
  635. /* Wait for a connection to finish. */
  636. if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
  637. if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
  638. goto out_release;
  639. size = sk->sk_prot->max_header + len;
  640. release_sock(sk);
  641. skb = sock_alloc_send_skb(sk, size, noblock, &rc);
  642. lock_sock(sk);
  643. if (skb == NULL)
  644. goto out_release;
  645. if (sk->sk_state == DCCP_CLOSED) {
  646. rc = -ENOTCONN;
  647. goto out_discard;
  648. }
  649. skb_reserve(skb, sk->sk_prot->max_header);
  650. rc = memcpy_from_msg(skb_put(skb, len), msg, len);
  651. if (rc != 0)
  652. goto out_discard;
  653. rc = dccp_msghdr_parse(msg, skb);
  654. if (rc != 0)
  655. goto out_discard;
  656. dccp_qpolicy_push(sk, skb);
  657. /*
  658. * The xmit_timer is set if the TX CCID is rate-based and will expire
  659. * when congestion control permits to release further packets into the
  660. * network. Window-based CCIDs do not use this timer.
  661. */
  662. if (!timer_pending(&dp->dccps_xmit_timer))
  663. dccp_write_xmit(sk);
  664. out_release:
  665. release_sock(sk);
  666. return rc ? : len;
  667. out_discard:
  668. kfree_skb(skb);
  669. goto out_release;
  670. }
  671. EXPORT_SYMBOL_GPL(dccp_sendmsg);
  672. int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
  673. int flags, int *addr_len)
  674. {
  675. const struct dccp_hdr *dh;
  676. long timeo;
  677. lock_sock(sk);
  678. if (sk->sk_state == DCCP_LISTEN) {
  679. len = -ENOTCONN;
  680. goto out;
  681. }
  682. timeo = sock_rcvtimeo(sk, nonblock);
  683. do {
  684. struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
  685. if (skb == NULL)
  686. goto verify_sock_status;
  687. dh = dccp_hdr(skb);
  688. switch (dh->dccph_type) {
  689. case DCCP_PKT_DATA:
  690. case DCCP_PKT_DATAACK:
  691. goto found_ok_skb;
  692. case DCCP_PKT_CLOSE:
  693. case DCCP_PKT_CLOSEREQ:
  694. if (!(flags & MSG_PEEK))
  695. dccp_finish_passive_close(sk);
  696. fallthrough;
  697. case DCCP_PKT_RESET:
  698. dccp_pr_debug("found fin (%s) ok!\n",
  699. dccp_packet_name(dh->dccph_type));
  700. len = 0;
  701. goto found_fin_ok;
  702. default:
  703. dccp_pr_debug("packet_type=%s\n",
  704. dccp_packet_name(dh->dccph_type));
  705. sk_eat_skb(sk, skb);
  706. }
  707. verify_sock_status:
  708. if (sock_flag(sk, SOCK_DONE)) {
  709. len = 0;
  710. break;
  711. }
  712. if (sk->sk_err) {
  713. len = sock_error(sk);
  714. break;
  715. }
  716. if (sk->sk_shutdown & RCV_SHUTDOWN) {
  717. len = 0;
  718. break;
  719. }
  720. if (sk->sk_state == DCCP_CLOSED) {
  721. if (!sock_flag(sk, SOCK_DONE)) {
  722. /* This occurs when user tries to read
  723. * from never connected socket.
  724. */
  725. len = -ENOTCONN;
  726. break;
  727. }
  728. len = 0;
  729. break;
  730. }
  731. if (!timeo) {
  732. len = -EAGAIN;
  733. break;
  734. }
  735. if (signal_pending(current)) {
  736. len = sock_intr_errno(timeo);
  737. break;
  738. }
  739. sk_wait_data(sk, &timeo, NULL);
  740. continue;
  741. found_ok_skb:
  742. if (len > skb->len)
  743. len = skb->len;
  744. else if (len < skb->len)
  745. msg->msg_flags |= MSG_TRUNC;
  746. if (skb_copy_datagram_msg(skb, 0, msg, len)) {
  747. /* Exception. Bailout! */
  748. len = -EFAULT;
  749. break;
  750. }
  751. if (flags & MSG_TRUNC)
  752. len = skb->len;
  753. found_fin_ok:
  754. if (!(flags & MSG_PEEK))
  755. sk_eat_skb(sk, skb);
  756. break;
  757. } while (1);
  758. out:
  759. release_sock(sk);
  760. return len;
  761. }
  762. EXPORT_SYMBOL_GPL(dccp_recvmsg);
  763. int inet_dccp_listen(struct socket *sock, int backlog)
  764. {
  765. struct sock *sk = sock->sk;
  766. unsigned char old_state;
  767. int err;
  768. lock_sock(sk);
  769. err = -EINVAL;
  770. if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
  771. goto out;
  772. old_state = sk->sk_state;
  773. if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
  774. goto out;
  775. WRITE_ONCE(sk->sk_max_ack_backlog, backlog);
  776. /* Really, if the socket is already in listen state
  777. * we can only allow the backlog to be adjusted.
  778. */
  779. if (old_state != DCCP_LISTEN) {
  780. /*
  781. * FIXME: here it probably should be sk->sk_prot->listen_start
  782. * see tcp_listen_start
  783. */
  784. err = dccp_listen_start(sk, backlog);
  785. if (err)
  786. goto out;
  787. }
  788. err = 0;
  789. out:
  790. release_sock(sk);
  791. return err;
  792. }
  793. EXPORT_SYMBOL_GPL(inet_dccp_listen);
  794. static void dccp_terminate_connection(struct sock *sk)
  795. {
  796. u8 next_state = DCCP_CLOSED;
  797. switch (sk->sk_state) {
  798. case DCCP_PASSIVE_CLOSE:
  799. case DCCP_PASSIVE_CLOSEREQ:
  800. dccp_finish_passive_close(sk);
  801. break;
  802. case DCCP_PARTOPEN:
  803. dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
  804. inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
  805. fallthrough;
  806. case DCCP_OPEN:
  807. dccp_send_close(sk, 1);
  808. if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
  809. !dccp_sk(sk)->dccps_server_timewait)
  810. next_state = DCCP_ACTIVE_CLOSEREQ;
  811. else
  812. next_state = DCCP_CLOSING;
  813. fallthrough;
  814. default:
  815. dccp_set_state(sk, next_state);
  816. }
  817. }
  818. void dccp_close(struct sock *sk, long timeout)
  819. {
  820. struct dccp_sock *dp = dccp_sk(sk);
  821. struct sk_buff *skb;
  822. u32 data_was_unread = 0;
  823. int state;
  824. lock_sock(sk);
  825. sk->sk_shutdown = SHUTDOWN_MASK;
  826. if (sk->sk_state == DCCP_LISTEN) {
  827. dccp_set_state(sk, DCCP_CLOSED);
  828. /* Special case. */
  829. inet_csk_listen_stop(sk);
  830. goto adjudge_to_death;
  831. }
  832. sk_stop_timer(sk, &dp->dccps_xmit_timer);
  833. /*
  834. * We need to flush the recv. buffs. We do this only on the
  835. * descriptor close, not protocol-sourced closes, because the
  836. *reader process may not have drained the data yet!
  837. */
  838. while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
  839. data_was_unread += skb->len;
  840. __kfree_skb(skb);
  841. }
  842. /* If socket has been already reset kill it. */
  843. if (sk->sk_state == DCCP_CLOSED)
  844. goto adjudge_to_death;
  845. if (data_was_unread) {
  846. /* Unread data was tossed, send an appropriate Reset Code */
  847. DCCP_WARN("ABORT with %u bytes unread\n", data_was_unread);
  848. dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
  849. dccp_set_state(sk, DCCP_CLOSED);
  850. } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
  851. /* Check zero linger _after_ checking for unread data. */
  852. sk->sk_prot->disconnect(sk, 0);
  853. } else if (sk->sk_state != DCCP_CLOSED) {
  854. /*
  855. * Normal connection termination. May need to wait if there are
  856. * still packets in the TX queue that are delayed by the CCID.
  857. */
  858. dccp_flush_write_queue(sk, &timeout);
  859. dccp_terminate_connection(sk);
  860. }
  861. /*
  862. * Flush write queue. This may be necessary in several cases:
  863. * - we have been closed by the peer but still have application data;
  864. * - abortive termination (unread data or zero linger time),
  865. * - normal termination but queue could not be flushed within time limit
  866. */
  867. __skb_queue_purge(&sk->sk_write_queue);
  868. sk_stream_wait_close(sk, timeout);
  869. adjudge_to_death:
  870. state = sk->sk_state;
  871. sock_hold(sk);
  872. sock_orphan(sk);
  873. /*
  874. * It is the last release_sock in its life. It will remove backlog.
  875. */
  876. release_sock(sk);
  877. /*
  878. * Now socket is owned by kernel and we acquire BH lock
  879. * to finish close. No need to check for user refs.
  880. */
  881. local_bh_disable();
  882. bh_lock_sock(sk);
  883. WARN_ON(sock_owned_by_user(sk));
  884. percpu_counter_inc(sk->sk_prot->orphan_count);
  885. /* Have we already been destroyed by a softirq or backlog? */
  886. if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
  887. goto out;
  888. if (sk->sk_state == DCCP_CLOSED)
  889. inet_csk_destroy_sock(sk);
  890. /* Otherwise, socket is reprieved until protocol close. */
  891. out:
  892. bh_unlock_sock(sk);
  893. local_bh_enable();
  894. sock_put(sk);
  895. }
  896. EXPORT_SYMBOL_GPL(dccp_close);
  897. void dccp_shutdown(struct sock *sk, int how)
  898. {
  899. dccp_pr_debug("called shutdown(%x)\n", how);
  900. }
  901. EXPORT_SYMBOL_GPL(dccp_shutdown);
  902. static inline int __init dccp_mib_init(void)
  903. {
  904. dccp_statistics = alloc_percpu(struct dccp_mib);
  905. if (!dccp_statistics)
  906. return -ENOMEM;
  907. return 0;
  908. }
  909. static inline void dccp_mib_exit(void)
  910. {
  911. free_percpu(dccp_statistics);
  912. }
  913. static int thash_entries;
  914. module_param(thash_entries, int, 0444);
  915. MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
  916. #ifdef CONFIG_IP_DCCP_DEBUG
  917. bool dccp_debug;
  918. module_param(dccp_debug, bool, 0644);
  919. MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
  920. EXPORT_SYMBOL_GPL(dccp_debug);
  921. #endif
  922. static int __init dccp_init(void)
  923. {
  924. unsigned long goal;
  925. unsigned long nr_pages = totalram_pages();
  926. int ehash_order, bhash_order, i;
  927. int rc;
  928. BUILD_BUG_ON(sizeof(struct dccp_skb_cb) >
  929. sizeof_field(struct sk_buff, cb));
  930. rc = percpu_counter_init(&dccp_orphan_count, 0, GFP_KERNEL);
  931. if (rc)
  932. goto out_fail;
  933. inet_hashinfo_init(&dccp_hashinfo);
  934. rc = inet_hashinfo2_init_mod(&dccp_hashinfo);
  935. if (rc)
  936. goto out_free_percpu;
  937. rc = -ENOBUFS;
  938. dccp_hashinfo.bind_bucket_cachep =
  939. kmem_cache_create("dccp_bind_bucket",
  940. sizeof(struct inet_bind_bucket), 0,
  941. SLAB_HWCACHE_ALIGN, NULL);
  942. if (!dccp_hashinfo.bind_bucket_cachep)
  943. goto out_free_hashinfo2;
  944. /*
  945. * Size and allocate the main established and bind bucket
  946. * hash tables.
  947. *
  948. * The methodology is similar to that of the buffer cache.
  949. */
  950. if (nr_pages >= (128 * 1024))
  951. goal = nr_pages >> (21 - PAGE_SHIFT);
  952. else
  953. goal = nr_pages >> (23 - PAGE_SHIFT);
  954. if (thash_entries)
  955. goal = (thash_entries *
  956. sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
  957. for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
  958. ;
  959. do {
  960. unsigned long hash_size = (1UL << ehash_order) * PAGE_SIZE /
  961. sizeof(struct inet_ehash_bucket);
  962. while (hash_size & (hash_size - 1))
  963. hash_size--;
  964. dccp_hashinfo.ehash_mask = hash_size - 1;
  965. dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
  966. __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, ehash_order);
  967. } while (!dccp_hashinfo.ehash && --ehash_order > 0);
  968. if (!dccp_hashinfo.ehash) {
  969. DCCP_CRIT("Failed to allocate DCCP established hash table");
  970. goto out_free_bind_bucket_cachep;
  971. }
  972. for (i = 0; i <= dccp_hashinfo.ehash_mask; i++)
  973. INIT_HLIST_NULLS_HEAD(&dccp_hashinfo.ehash[i].chain, i);
  974. if (inet_ehash_locks_alloc(&dccp_hashinfo))
  975. goto out_free_dccp_ehash;
  976. bhash_order = ehash_order;
  977. do {
  978. dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
  979. sizeof(struct inet_bind_hashbucket);
  980. if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
  981. bhash_order > 0)
  982. continue;
  983. dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
  984. __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, bhash_order);
  985. } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
  986. if (!dccp_hashinfo.bhash) {
  987. DCCP_CRIT("Failed to allocate DCCP bind hash table");
  988. goto out_free_dccp_locks;
  989. }
  990. for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
  991. spin_lock_init(&dccp_hashinfo.bhash[i].lock);
  992. INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
  993. }
  994. rc = dccp_mib_init();
  995. if (rc)
  996. goto out_free_dccp_bhash;
  997. rc = dccp_ackvec_init();
  998. if (rc)
  999. goto out_free_dccp_mib;
  1000. rc = dccp_sysctl_init();
  1001. if (rc)
  1002. goto out_ackvec_exit;
  1003. rc = ccid_initialize_builtins();
  1004. if (rc)
  1005. goto out_sysctl_exit;
  1006. dccp_timestamping_init();
  1007. return 0;
  1008. out_sysctl_exit:
  1009. dccp_sysctl_exit();
  1010. out_ackvec_exit:
  1011. dccp_ackvec_exit();
  1012. out_free_dccp_mib:
  1013. dccp_mib_exit();
  1014. out_free_dccp_bhash:
  1015. free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
  1016. out_free_dccp_locks:
  1017. inet_ehash_locks_free(&dccp_hashinfo);
  1018. out_free_dccp_ehash:
  1019. free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
  1020. out_free_bind_bucket_cachep:
  1021. kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
  1022. out_free_hashinfo2:
  1023. inet_hashinfo2_free_mod(&dccp_hashinfo);
  1024. out_free_percpu:
  1025. percpu_counter_destroy(&dccp_orphan_count);
  1026. out_fail:
  1027. dccp_hashinfo.bhash = NULL;
  1028. dccp_hashinfo.ehash = NULL;
  1029. dccp_hashinfo.bind_bucket_cachep = NULL;
  1030. return rc;
  1031. }
  1032. static void __exit dccp_fini(void)
  1033. {
  1034. ccid_cleanup_builtins();
  1035. dccp_mib_exit();
  1036. free_pages((unsigned long)dccp_hashinfo.bhash,
  1037. get_order(dccp_hashinfo.bhash_size *
  1038. sizeof(struct inet_bind_hashbucket)));
  1039. free_pages((unsigned long)dccp_hashinfo.ehash,
  1040. get_order((dccp_hashinfo.ehash_mask + 1) *
  1041. sizeof(struct inet_ehash_bucket)));
  1042. inet_ehash_locks_free(&dccp_hashinfo);
  1043. kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
  1044. dccp_ackvec_exit();
  1045. dccp_sysctl_exit();
  1046. inet_hashinfo2_free_mod(&dccp_hashinfo);
  1047. percpu_counter_destroy(&dccp_orphan_count);
  1048. }
  1049. module_init(dccp_init);
  1050. module_exit(dccp_fini);
  1051. MODULE_LICENSE("GPL");
  1052. MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
  1053. MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");