proto.c 26 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117
  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. #include <linux/dccp.h>
  12. #include <linux/module.h>
  13. #include <linux/types.h>
  14. #include <linux/sched.h>
  15. #include <linux/kernel.h>
  16. #include <linux/skbuff.h>
  17. #include <linux/netdevice.h>
  18. #include <linux/in.h>
  19. #include <linux/if_arp.h>
  20. #include <linux/init.h>
  21. #include <linux/random.h>
  22. #include <net/checksum.h>
  23. #include <net/inet_sock.h>
  24. #include <net/sock.h>
  25. #include <net/xfrm.h>
  26. #include <asm/semaphore.h>
  27. #include <linux/spinlock.h>
  28. #include <linux/timer.h>
  29. #include <linux/delay.h>
  30. #include <linux/poll.h>
  31. #include "ccid.h"
  32. #include "dccp.h"
  33. #include "feat.h"
  34. DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;
  35. EXPORT_SYMBOL_GPL(dccp_statistics);
  36. atomic_t dccp_orphan_count = ATOMIC_INIT(0);
  37. EXPORT_SYMBOL_GPL(dccp_orphan_count);
  38. struct inet_hashinfo __cacheline_aligned dccp_hashinfo = {
  39. .lhash_lock = RW_LOCK_UNLOCKED,
  40. .lhash_users = ATOMIC_INIT(0),
  41. .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(dccp_hashinfo.lhash_wait),
  42. };
  43. EXPORT_SYMBOL_GPL(dccp_hashinfo);
  44. /* the maximum queue length for tx in packets. 0 is no limit */
  45. int sysctl_dccp_tx_qlen __read_mostly = 5;
  46. void dccp_set_state(struct sock *sk, const int state)
  47. {
  48. const int oldstate = sk->sk_state;
  49. dccp_pr_debug("%s(%p) %-10.10s -> %s\n",
  50. dccp_role(sk), sk,
  51. dccp_state_name(oldstate), dccp_state_name(state));
  52. WARN_ON(state == oldstate);
  53. switch (state) {
  54. case DCCP_OPEN:
  55. if (oldstate != DCCP_OPEN)
  56. DCCP_INC_STATS(DCCP_MIB_CURRESTAB);
  57. break;
  58. case DCCP_CLOSED:
  59. if (oldstate == DCCP_CLOSING || oldstate == DCCP_OPEN)
  60. DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
  61. sk->sk_prot->unhash(sk);
  62. if (inet_csk(sk)->icsk_bind_hash != NULL &&
  63. !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
  64. inet_put_port(&dccp_hashinfo, sk);
  65. /* fall through */
  66. default:
  67. if (oldstate == DCCP_OPEN)
  68. DCCP_DEC_STATS(DCCP_MIB_CURRESTAB);
  69. }
  70. /* Change state AFTER socket is unhashed to avoid closed
  71. * socket sitting in hash tables.
  72. */
  73. sk->sk_state = state;
  74. }
  75. EXPORT_SYMBOL_GPL(dccp_set_state);
  76. void dccp_done(struct sock *sk)
  77. {
  78. dccp_set_state(sk, DCCP_CLOSED);
  79. dccp_clear_xmit_timers(sk);
  80. sk->sk_shutdown = SHUTDOWN_MASK;
  81. if (!sock_flag(sk, SOCK_DEAD))
  82. sk->sk_state_change(sk);
  83. else
  84. inet_csk_destroy_sock(sk);
  85. }
  86. EXPORT_SYMBOL_GPL(dccp_done);
  87. const char *dccp_packet_name(const int type)
  88. {
  89. static const char *dccp_packet_names[] = {
  90. [DCCP_PKT_REQUEST] = "REQUEST",
  91. [DCCP_PKT_RESPONSE] = "RESPONSE",
  92. [DCCP_PKT_DATA] = "DATA",
  93. [DCCP_PKT_ACK] = "ACK",
  94. [DCCP_PKT_DATAACK] = "DATAACK",
  95. [DCCP_PKT_CLOSEREQ] = "CLOSEREQ",
  96. [DCCP_PKT_CLOSE] = "CLOSE",
  97. [DCCP_PKT_RESET] = "RESET",
  98. [DCCP_PKT_SYNC] = "SYNC",
  99. [DCCP_PKT_SYNCACK] = "SYNCACK",
  100. };
  101. if (type >= DCCP_NR_PKT_TYPES)
  102. return "INVALID";
  103. else
  104. return dccp_packet_names[type];
  105. }
  106. EXPORT_SYMBOL_GPL(dccp_packet_name);
  107. const char *dccp_state_name(const int state)
  108. {
  109. static char *dccp_state_names[] = {
  110. [DCCP_OPEN] = "OPEN",
  111. [DCCP_REQUESTING] = "REQUESTING",
  112. [DCCP_PARTOPEN] = "PARTOPEN",
  113. [DCCP_LISTEN] = "LISTEN",
  114. [DCCP_RESPOND] = "RESPOND",
  115. [DCCP_CLOSING] = "CLOSING",
  116. [DCCP_TIME_WAIT] = "TIME_WAIT",
  117. [DCCP_CLOSED] = "CLOSED",
  118. };
  119. if (state >= DCCP_MAX_STATES)
  120. return "INVALID STATE!";
  121. else
  122. return dccp_state_names[state];
  123. }
  124. EXPORT_SYMBOL_GPL(dccp_state_name);
  125. void dccp_hash(struct sock *sk)
  126. {
  127. inet_hash(&dccp_hashinfo, sk);
  128. }
  129. EXPORT_SYMBOL_GPL(dccp_hash);
  130. void dccp_unhash(struct sock *sk)
  131. {
  132. inet_unhash(&dccp_hashinfo, sk);
  133. }
  134. EXPORT_SYMBOL_GPL(dccp_unhash);
  135. int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
  136. {
  137. struct dccp_sock *dp = dccp_sk(sk);
  138. struct dccp_minisock *dmsk = dccp_msk(sk);
  139. struct inet_connection_sock *icsk = inet_csk(sk);
  140. dccp_minisock_init(&dp->dccps_minisock);
  141. do_gettimeofday(&dp->dccps_epoch);
  142. /*
  143. * FIXME: We're hardcoding the CCID, and doing this at this point makes
  144. * the listening (master) sock get CCID control blocks, which is not
  145. * necessary, but for now, to not mess with the test userspace apps,
  146. * lets leave it here, later the real solution is to do this in a
  147. * setsockopt(CCIDs-I-want/accept). -acme
  148. */
  149. if (likely(ctl_sock_initialized)) {
  150. int rc = dccp_feat_init(dmsk);
  151. if (rc)
  152. return rc;
  153. if (dmsk->dccpms_send_ack_vector) {
  154. dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(GFP_KERNEL);
  155. if (dp->dccps_hc_rx_ackvec == NULL)
  156. return -ENOMEM;
  157. }
  158. dp->dccps_hc_rx_ccid = ccid_hc_rx_new(dmsk->dccpms_rx_ccid,
  159. sk, GFP_KERNEL);
  160. dp->dccps_hc_tx_ccid = ccid_hc_tx_new(dmsk->dccpms_tx_ccid,
  161. sk, GFP_KERNEL);
  162. if (unlikely(dp->dccps_hc_rx_ccid == NULL ||
  163. dp->dccps_hc_tx_ccid == NULL)) {
  164. ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
  165. ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
  166. if (dmsk->dccpms_send_ack_vector) {
  167. dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
  168. dp->dccps_hc_rx_ackvec = NULL;
  169. }
  170. dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
  171. return -ENOMEM;
  172. }
  173. } else {
  174. /* control socket doesn't need feat nego */
  175. INIT_LIST_HEAD(&dmsk->dccpms_pending);
  176. INIT_LIST_HEAD(&dmsk->dccpms_conf);
  177. }
  178. dccp_init_xmit_timers(sk);
  179. icsk->icsk_rto = DCCP_TIMEOUT_INIT;
  180. icsk->icsk_syn_retries = sysctl_dccp_request_retries;
  181. sk->sk_state = DCCP_CLOSED;
  182. sk->sk_write_space = dccp_write_space;
  183. icsk->icsk_sync_mss = dccp_sync_mss;
  184. dp->dccps_mss_cache = 536;
  185. dp->dccps_role = DCCP_ROLE_UNDEFINED;
  186. dp->dccps_service = DCCP_SERVICE_CODE_IS_ABSENT;
  187. dp->dccps_l_ack_ratio = dp->dccps_r_ack_ratio = 1;
  188. return 0;
  189. }
  190. EXPORT_SYMBOL_GPL(dccp_init_sock);
  191. int dccp_destroy_sock(struct sock *sk)
  192. {
  193. struct dccp_sock *dp = dccp_sk(sk);
  194. struct dccp_minisock *dmsk = dccp_msk(sk);
  195. /*
  196. * DCCP doesn't use sk_write_queue, just sk_send_head
  197. * for retransmissions
  198. */
  199. if (sk->sk_send_head != NULL) {
  200. kfree_skb(sk->sk_send_head);
  201. sk->sk_send_head = NULL;
  202. }
  203. /* Clean up a referenced DCCP bind bucket. */
  204. if (inet_csk(sk)->icsk_bind_hash != NULL)
  205. inet_put_port(&dccp_hashinfo, sk);
  206. kfree(dp->dccps_service_list);
  207. dp->dccps_service_list = NULL;
  208. if (dmsk->dccpms_send_ack_vector) {
  209. dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
  210. dp->dccps_hc_rx_ackvec = NULL;
  211. }
  212. ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
  213. ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
  214. dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
  215. /* clean up feature negotiation state */
  216. dccp_feat_clean(dmsk);
  217. return 0;
  218. }
  219. EXPORT_SYMBOL_GPL(dccp_destroy_sock);
  220. static inline int dccp_listen_start(struct sock *sk, int backlog)
  221. {
  222. struct dccp_sock *dp = dccp_sk(sk);
  223. dp->dccps_role = DCCP_ROLE_LISTEN;
  224. return inet_csk_listen_start(sk, backlog);
  225. }
  226. int dccp_disconnect(struct sock *sk, int flags)
  227. {
  228. struct inet_connection_sock *icsk = inet_csk(sk);
  229. struct inet_sock *inet = inet_sk(sk);
  230. int err = 0;
  231. const int old_state = sk->sk_state;
  232. if (old_state != DCCP_CLOSED)
  233. dccp_set_state(sk, DCCP_CLOSED);
  234. /* ABORT function of RFC793 */
  235. if (old_state == DCCP_LISTEN) {
  236. inet_csk_listen_stop(sk);
  237. /* FIXME: do the active reset thing */
  238. } else if (old_state == DCCP_REQUESTING)
  239. sk->sk_err = ECONNRESET;
  240. dccp_clear_xmit_timers(sk);
  241. __skb_queue_purge(&sk->sk_receive_queue);
  242. if (sk->sk_send_head != NULL) {
  243. __kfree_skb(sk->sk_send_head);
  244. sk->sk_send_head = NULL;
  245. }
  246. inet->dport = 0;
  247. if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
  248. inet_reset_saddr(sk);
  249. sk->sk_shutdown = 0;
  250. sock_reset_flag(sk, SOCK_DONE);
  251. icsk->icsk_backoff = 0;
  252. inet_csk_delack_init(sk);
  253. __sk_dst_reset(sk);
  254. BUG_TRAP(!inet->num || icsk->icsk_bind_hash);
  255. sk->sk_error_report(sk);
  256. return err;
  257. }
  258. EXPORT_SYMBOL_GPL(dccp_disconnect);
  259. /*
  260. * Wait for a DCCP event.
  261. *
  262. * Note that we don't need to lock the socket, as the upper poll layers
  263. * take care of normal races (between the test and the event) and we don't
  264. * go look at any of the socket buffers directly.
  265. */
  266. unsigned int dccp_poll(struct file *file, struct socket *sock,
  267. poll_table *wait)
  268. {
  269. unsigned int mask;
  270. struct sock *sk = sock->sk;
  271. poll_wait(file, sk->sk_sleep, wait);
  272. if (sk->sk_state == DCCP_LISTEN)
  273. return inet_csk_listen_poll(sk);
  274. /* Socket is not locked. We are protected from async events
  275. by poll logic and correct handling of state changes
  276. made by another threads is impossible in any case.
  277. */
  278. mask = 0;
  279. if (sk->sk_err)
  280. mask = POLLERR;
  281. if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
  282. mask |= POLLHUP;
  283. if (sk->sk_shutdown & RCV_SHUTDOWN)
  284. mask |= POLLIN | POLLRDNORM | POLLRDHUP;
  285. /* Connected? */
  286. if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
  287. if (atomic_read(&sk->sk_rmem_alloc) > 0)
  288. mask |= POLLIN | POLLRDNORM;
  289. if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
  290. if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
  291. mask |= POLLOUT | POLLWRNORM;
  292. } else { /* send SIGIO later */
  293. set_bit(SOCK_ASYNC_NOSPACE,
  294. &sk->sk_socket->flags);
  295. set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
  296. /* Race breaker. If space is freed after
  297. * wspace test but before the flags are set,
  298. * IO signal will be lost.
  299. */
  300. if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
  301. mask |= POLLOUT | POLLWRNORM;
  302. }
  303. }
  304. }
  305. return mask;
  306. }
  307. EXPORT_SYMBOL_GPL(dccp_poll);
  308. int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
  309. {
  310. dccp_pr_debug("entry\n");
  311. return -ENOIOCTLCMD;
  312. }
  313. EXPORT_SYMBOL_GPL(dccp_ioctl);
  314. static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
  315. char __user *optval, int optlen)
  316. {
  317. struct dccp_sock *dp = dccp_sk(sk);
  318. struct dccp_service_list *sl = NULL;
  319. if (service == DCCP_SERVICE_INVALID_VALUE ||
  320. optlen > DCCP_SERVICE_LIST_MAX_LEN * sizeof(u32))
  321. return -EINVAL;
  322. if (optlen > sizeof(service)) {
  323. sl = kmalloc(optlen, GFP_KERNEL);
  324. if (sl == NULL)
  325. return -ENOMEM;
  326. sl->dccpsl_nr = optlen / sizeof(u32) - 1;
  327. if (copy_from_user(sl->dccpsl_list,
  328. optval + sizeof(service),
  329. optlen - sizeof(service)) ||
  330. dccp_list_has_service(sl, DCCP_SERVICE_INVALID_VALUE)) {
  331. kfree(sl);
  332. return -EFAULT;
  333. }
  334. }
  335. lock_sock(sk);
  336. dp->dccps_service = service;
  337. kfree(dp->dccps_service_list);
  338. dp->dccps_service_list = sl;
  339. release_sock(sk);
  340. return 0;
  341. }
  342. /* byte 1 is feature. the rest is the preference list */
  343. static int dccp_setsockopt_change(struct sock *sk, int type,
  344. struct dccp_so_feat __user *optval)
  345. {
  346. struct dccp_so_feat opt;
  347. u8 *val;
  348. int rc;
  349. if (copy_from_user(&opt, optval, sizeof(opt)))
  350. return -EFAULT;
  351. val = kmalloc(opt.dccpsf_len, GFP_KERNEL);
  352. if (!val)
  353. return -ENOMEM;
  354. if (copy_from_user(val, opt.dccpsf_val, opt.dccpsf_len)) {
  355. rc = -EFAULT;
  356. goto out_free_val;
  357. }
  358. rc = dccp_feat_change(dccp_msk(sk), type, opt.dccpsf_feat,
  359. val, opt.dccpsf_len, GFP_KERNEL);
  360. if (rc)
  361. goto out_free_val;
  362. out:
  363. return rc;
  364. out_free_val:
  365. kfree(val);
  366. goto out;
  367. }
  368. static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
  369. char __user *optval, int optlen)
  370. {
  371. struct dccp_sock *dp = dccp_sk(sk);
  372. int val, err = 0;
  373. if (optlen < sizeof(int))
  374. return -EINVAL;
  375. if (get_user(val, (int __user *)optval))
  376. return -EFAULT;
  377. if (optname == DCCP_SOCKOPT_SERVICE)
  378. return dccp_setsockopt_service(sk, val, optval, optlen);
  379. lock_sock(sk);
  380. switch (optname) {
  381. case DCCP_SOCKOPT_PACKET_SIZE:
  382. DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
  383. err = 0;
  384. break;
  385. case DCCP_SOCKOPT_CHANGE_L:
  386. if (optlen != sizeof(struct dccp_so_feat))
  387. err = -EINVAL;
  388. else
  389. err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,
  390. (struct dccp_so_feat __user *)
  391. optval);
  392. break;
  393. case DCCP_SOCKOPT_CHANGE_R:
  394. if (optlen != sizeof(struct dccp_so_feat))
  395. err = -EINVAL;
  396. else
  397. err = dccp_setsockopt_change(sk, DCCPO_CHANGE_R,
  398. (struct dccp_so_feat __user *)
  399. optval);
  400. break;
  401. case DCCP_SOCKOPT_SEND_CSCOV: /* sender side, RFC 4340, sec. 9.2 */
  402. if (val < 0 || val > 15)
  403. err = -EINVAL;
  404. else
  405. dp->dccps_pcslen = val;
  406. break;
  407. case DCCP_SOCKOPT_RECV_CSCOV: /* receiver side, RFC 4340 sec. 9.2.1 */
  408. if (val < 0 || val > 15)
  409. err = -EINVAL;
  410. else {
  411. dp->dccps_pcrlen = val;
  412. /* FIXME: add feature negotiation,
  413. * ChangeL(MinimumChecksumCoverage, val) */
  414. }
  415. break;
  416. default:
  417. err = -ENOPROTOOPT;
  418. break;
  419. }
  420. release_sock(sk);
  421. return err;
  422. }
  423. int dccp_setsockopt(struct sock *sk, int level, int optname,
  424. char __user *optval, int optlen)
  425. {
  426. if (level != SOL_DCCP)
  427. return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
  428. optname, optval,
  429. optlen);
  430. return do_dccp_setsockopt(sk, level, optname, optval, optlen);
  431. }
  432. EXPORT_SYMBOL_GPL(dccp_setsockopt);
  433. #ifdef CONFIG_COMPAT
  434. int compat_dccp_setsockopt(struct sock *sk, int level, int optname,
  435. char __user *optval, int optlen)
  436. {
  437. if (level != SOL_DCCP)
  438. return inet_csk_compat_setsockopt(sk, level, optname,
  439. optval, optlen);
  440. return do_dccp_setsockopt(sk, level, optname, optval, optlen);
  441. }
  442. EXPORT_SYMBOL_GPL(compat_dccp_setsockopt);
  443. #endif
  444. static int dccp_getsockopt_service(struct sock *sk, int len,
  445. __be32 __user *optval,
  446. int __user *optlen)
  447. {
  448. const struct dccp_sock *dp = dccp_sk(sk);
  449. const struct dccp_service_list *sl;
  450. int err = -ENOENT, slen = 0, total_len = sizeof(u32);
  451. lock_sock(sk);
  452. if ((sl = dp->dccps_service_list) != NULL) {
  453. slen = sl->dccpsl_nr * sizeof(u32);
  454. total_len += slen;
  455. }
  456. err = -EINVAL;
  457. if (total_len > len)
  458. goto out;
  459. err = 0;
  460. if (put_user(total_len, optlen) ||
  461. put_user(dp->dccps_service, optval) ||
  462. (sl != NULL && copy_to_user(optval + 1, sl->dccpsl_list, slen)))
  463. err = -EFAULT;
  464. out:
  465. release_sock(sk);
  466. return err;
  467. }
  468. static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
  469. char __user *optval, int __user *optlen)
  470. {
  471. struct dccp_sock *dp;
  472. int val, len;
  473. if (get_user(len, optlen))
  474. return -EFAULT;
  475. if (len < (int)sizeof(int))
  476. return -EINVAL;
  477. dp = dccp_sk(sk);
  478. switch (optname) {
  479. case DCCP_SOCKOPT_PACKET_SIZE:
  480. DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app\n");
  481. return 0;
  482. case DCCP_SOCKOPT_SERVICE:
  483. return dccp_getsockopt_service(sk, len,
  484. (__be32 __user *)optval, optlen);
  485. case DCCP_SOCKOPT_SEND_CSCOV:
  486. val = dp->dccps_pcslen;
  487. len = sizeof(val);
  488. break;
  489. case DCCP_SOCKOPT_RECV_CSCOV:
  490. val = dp->dccps_pcrlen;
  491. len = sizeof(val);
  492. break;
  493. case 128 ... 191:
  494. return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
  495. len, (u32 __user *)optval, optlen);
  496. case 192 ... 255:
  497. return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
  498. len, (u32 __user *)optval, optlen);
  499. default:
  500. return -ENOPROTOOPT;
  501. }
  502. if (put_user(len, optlen) || copy_to_user(optval, &val, len))
  503. return -EFAULT;
  504. return 0;
  505. }
  506. int dccp_getsockopt(struct sock *sk, int level, int optname,
  507. char __user *optval, int __user *optlen)
  508. {
  509. if (level != SOL_DCCP)
  510. return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
  511. optname, optval,
  512. optlen);
  513. return do_dccp_getsockopt(sk, level, optname, optval, optlen);
  514. }
  515. EXPORT_SYMBOL_GPL(dccp_getsockopt);
  516. #ifdef CONFIG_COMPAT
  517. int compat_dccp_getsockopt(struct sock *sk, int level, int optname,
  518. char __user *optval, int __user *optlen)
  519. {
  520. if (level != SOL_DCCP)
  521. return inet_csk_compat_getsockopt(sk, level, optname,
  522. optval, optlen);
  523. return do_dccp_getsockopt(sk, level, optname, optval, optlen);
  524. }
  525. EXPORT_SYMBOL_GPL(compat_dccp_getsockopt);
  526. #endif
  527. int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
  528. size_t len)
  529. {
  530. const struct dccp_sock *dp = dccp_sk(sk);
  531. const int flags = msg->msg_flags;
  532. const int noblock = flags & MSG_DONTWAIT;
  533. struct sk_buff *skb;
  534. int rc, size;
  535. long timeo;
  536. if (len > dp->dccps_mss_cache)
  537. return -EMSGSIZE;
  538. lock_sock(sk);
  539. if (sysctl_dccp_tx_qlen &&
  540. (sk->sk_write_queue.qlen >= sysctl_dccp_tx_qlen)) {
  541. rc = -EAGAIN;
  542. goto out_release;
  543. }
  544. timeo = sock_sndtimeo(sk, noblock);
  545. /*
  546. * We have to use sk_stream_wait_connect here to set sk_write_pending,
  547. * so that the trick in dccp_rcv_request_sent_state_process.
  548. */
  549. /* Wait for a connection to finish. */
  550. if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN | DCCPF_CLOSING))
  551. if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
  552. goto out_release;
  553. size = sk->sk_prot->max_header + len;
  554. release_sock(sk);
  555. skb = sock_alloc_send_skb(sk, size, noblock, &rc);
  556. lock_sock(sk);
  557. if (skb == NULL)
  558. goto out_release;
  559. skb_reserve(skb, sk->sk_prot->max_header);
  560. rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
  561. if (rc != 0)
  562. goto out_discard;
  563. skb_queue_tail(&sk->sk_write_queue, skb);
  564. dccp_write_xmit(sk,0);
  565. out_release:
  566. release_sock(sk);
  567. return rc ? : len;
  568. out_discard:
  569. kfree_skb(skb);
  570. goto out_release;
  571. }
  572. EXPORT_SYMBOL_GPL(dccp_sendmsg);
  573. int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
  574. size_t len, int nonblock, int flags, int *addr_len)
  575. {
  576. const struct dccp_hdr *dh;
  577. long timeo;
  578. lock_sock(sk);
  579. if (sk->sk_state == DCCP_LISTEN) {
  580. len = -ENOTCONN;
  581. goto out;
  582. }
  583. timeo = sock_rcvtimeo(sk, nonblock);
  584. do {
  585. struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
  586. if (skb == NULL)
  587. goto verify_sock_status;
  588. dh = dccp_hdr(skb);
  589. if (dh->dccph_type == DCCP_PKT_DATA ||
  590. dh->dccph_type == DCCP_PKT_DATAACK)
  591. goto found_ok_skb;
  592. if (dh->dccph_type == DCCP_PKT_RESET ||
  593. dh->dccph_type == DCCP_PKT_CLOSE) {
  594. dccp_pr_debug("found fin ok!\n");
  595. len = 0;
  596. goto found_fin_ok;
  597. }
  598. dccp_pr_debug("packet_type=%s\n",
  599. dccp_packet_name(dh->dccph_type));
  600. sk_eat_skb(sk, skb, 0);
  601. verify_sock_status:
  602. if (sock_flag(sk, SOCK_DONE)) {
  603. len = 0;
  604. break;
  605. }
  606. if (sk->sk_err) {
  607. len = sock_error(sk);
  608. break;
  609. }
  610. if (sk->sk_shutdown & RCV_SHUTDOWN) {
  611. len = 0;
  612. break;
  613. }
  614. if (sk->sk_state == DCCP_CLOSED) {
  615. if (!sock_flag(sk, SOCK_DONE)) {
  616. /* This occurs when user tries to read
  617. * from never connected socket.
  618. */
  619. len = -ENOTCONN;
  620. break;
  621. }
  622. len = 0;
  623. break;
  624. }
  625. if (!timeo) {
  626. len = -EAGAIN;
  627. break;
  628. }
  629. if (signal_pending(current)) {
  630. len = sock_intr_errno(timeo);
  631. break;
  632. }
  633. sk_wait_data(sk, &timeo);
  634. continue;
  635. found_ok_skb:
  636. if (len > skb->len)
  637. len = skb->len;
  638. else if (len < skb->len)
  639. msg->msg_flags |= MSG_TRUNC;
  640. if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len)) {
  641. /* Exception. Bailout! */
  642. len = -EFAULT;
  643. break;
  644. }
  645. found_fin_ok:
  646. if (!(flags & MSG_PEEK))
  647. sk_eat_skb(sk, skb, 0);
  648. break;
  649. } while (1);
  650. out:
  651. release_sock(sk);
  652. return len;
  653. }
  654. EXPORT_SYMBOL_GPL(dccp_recvmsg);
  655. int inet_dccp_listen(struct socket *sock, int backlog)
  656. {
  657. struct sock *sk = sock->sk;
  658. unsigned char old_state;
  659. int err;
  660. lock_sock(sk);
  661. err = -EINVAL;
  662. if (sock->state != SS_UNCONNECTED || sock->type != SOCK_DCCP)
  663. goto out;
  664. old_state = sk->sk_state;
  665. if (!((1 << old_state) & (DCCPF_CLOSED | DCCPF_LISTEN)))
  666. goto out;
  667. /* Really, if the socket is already in listen state
  668. * we can only allow the backlog to be adjusted.
  669. */
  670. if (old_state != DCCP_LISTEN) {
  671. /*
  672. * FIXME: here it probably should be sk->sk_prot->listen_start
  673. * see tcp_listen_start
  674. */
  675. err = dccp_listen_start(sk, backlog);
  676. if (err)
  677. goto out;
  678. }
  679. sk->sk_max_ack_backlog = backlog;
  680. err = 0;
  681. out:
  682. release_sock(sk);
  683. return err;
  684. }
  685. EXPORT_SYMBOL_GPL(inet_dccp_listen);
  686. static const unsigned char dccp_new_state[] = {
  687. /* current state: new state: action: */
  688. [0] = DCCP_CLOSED,
  689. [DCCP_OPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
  690. [DCCP_REQUESTING] = DCCP_CLOSED,
  691. [DCCP_PARTOPEN] = DCCP_CLOSING | DCCP_ACTION_FIN,
  692. [DCCP_LISTEN] = DCCP_CLOSED,
  693. [DCCP_RESPOND] = DCCP_CLOSED,
  694. [DCCP_CLOSING] = DCCP_CLOSED,
  695. [DCCP_TIME_WAIT] = DCCP_CLOSED,
  696. [DCCP_CLOSED] = DCCP_CLOSED,
  697. };
  698. static int dccp_close_state(struct sock *sk)
  699. {
  700. const int next = dccp_new_state[sk->sk_state];
  701. const int ns = next & DCCP_STATE_MASK;
  702. if (ns != sk->sk_state)
  703. dccp_set_state(sk, ns);
  704. return next & DCCP_ACTION_FIN;
  705. }
  706. void dccp_close(struct sock *sk, long timeout)
  707. {
  708. struct dccp_sock *dp = dccp_sk(sk);
  709. struct sk_buff *skb;
  710. int state;
  711. lock_sock(sk);
  712. sk->sk_shutdown = SHUTDOWN_MASK;
  713. if (sk->sk_state == DCCP_LISTEN) {
  714. dccp_set_state(sk, DCCP_CLOSED);
  715. /* Special case. */
  716. inet_csk_listen_stop(sk);
  717. goto adjudge_to_death;
  718. }
  719. sk_stop_timer(sk, &dp->dccps_xmit_timer);
  720. /*
  721. * We need to flush the recv. buffs. We do this only on the
  722. * descriptor close, not protocol-sourced closes, because the
  723. *reader process may not have drained the data yet!
  724. */
  725. /* FIXME: check for unread data */
  726. while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
  727. __kfree_skb(skb);
  728. }
  729. if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
  730. /* Check zero linger _after_ checking for unread data. */
  731. sk->sk_prot->disconnect(sk, 0);
  732. } else if (dccp_close_state(sk)) {
  733. dccp_send_close(sk, 1);
  734. }
  735. sk_stream_wait_close(sk, timeout);
  736. adjudge_to_death:
  737. state = sk->sk_state;
  738. sock_hold(sk);
  739. sock_orphan(sk);
  740. atomic_inc(sk->sk_prot->orphan_count);
  741. /*
  742. * It is the last release_sock in its life. It will remove backlog.
  743. */
  744. release_sock(sk);
  745. /*
  746. * Now socket is owned by kernel and we acquire BH lock
  747. * to finish close. No need to check for user refs.
  748. */
  749. local_bh_disable();
  750. bh_lock_sock(sk);
  751. BUG_TRAP(!sock_owned_by_user(sk));
  752. /* Have we already been destroyed by a softirq or backlog? */
  753. if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
  754. goto out;
  755. /*
  756. * The last release_sock may have processed the CLOSE or RESET
  757. * packet moving sock to CLOSED state, if not we have to fire
  758. * the CLOSE/CLOSEREQ retransmission timer, see "8.3. Termination"
  759. * in draft-ietf-dccp-spec-11. -acme
  760. */
  761. if (sk->sk_state == DCCP_CLOSING) {
  762. /* FIXME: should start at 2 * RTT */
  763. /* Timer for repeating the CLOSE/CLOSEREQ until an answer. */
  764. inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
  765. inet_csk(sk)->icsk_rto,
  766. DCCP_RTO_MAX);
  767. #if 0
  768. /* Yeah, we should use sk->sk_prot->orphan_count, etc */
  769. dccp_set_state(sk, DCCP_CLOSED);
  770. #endif
  771. }
  772. if (sk->sk_state == DCCP_CLOSED)
  773. inet_csk_destroy_sock(sk);
  774. /* Otherwise, socket is reprieved until protocol close. */
  775. out:
  776. bh_unlock_sock(sk);
  777. local_bh_enable();
  778. sock_put(sk);
  779. }
  780. EXPORT_SYMBOL_GPL(dccp_close);
  781. void dccp_shutdown(struct sock *sk, int how)
  782. {
  783. dccp_pr_debug("entry\n");
  784. }
  785. EXPORT_SYMBOL_GPL(dccp_shutdown);
  786. static int __init dccp_mib_init(void)
  787. {
  788. int rc = -ENOMEM;
  789. dccp_statistics[0] = alloc_percpu(struct dccp_mib);
  790. if (dccp_statistics[0] == NULL)
  791. goto out;
  792. dccp_statistics[1] = alloc_percpu(struct dccp_mib);
  793. if (dccp_statistics[1] == NULL)
  794. goto out_free_one;
  795. rc = 0;
  796. out:
  797. return rc;
  798. out_free_one:
  799. free_percpu(dccp_statistics[0]);
  800. dccp_statistics[0] = NULL;
  801. goto out;
  802. }
  803. static void dccp_mib_exit(void)
  804. {
  805. free_percpu(dccp_statistics[0]);
  806. free_percpu(dccp_statistics[1]);
  807. dccp_statistics[0] = dccp_statistics[1] = NULL;
  808. }
  809. static int thash_entries;
  810. module_param(thash_entries, int, 0444);
  811. MODULE_PARM_DESC(thash_entries, "Number of ehash buckets");
  812. #ifdef CONFIG_IP_DCCP_DEBUG
  813. int dccp_debug;
  814. module_param(dccp_debug, int, 0444);
  815. MODULE_PARM_DESC(dccp_debug, "Enable debug messages");
  816. EXPORT_SYMBOL_GPL(dccp_debug);
  817. #endif
  818. static int __init dccp_init(void)
  819. {
  820. unsigned long goal;
  821. int ehash_order, bhash_order, i;
  822. int rc = -ENOBUFS;
  823. dccp_hashinfo.bind_bucket_cachep =
  824. kmem_cache_create("dccp_bind_bucket",
  825. sizeof(struct inet_bind_bucket), 0,
  826. SLAB_HWCACHE_ALIGN, NULL, NULL);
  827. if (!dccp_hashinfo.bind_bucket_cachep)
  828. goto out;
  829. /*
  830. * Size and allocate the main established and bind bucket
  831. * hash tables.
  832. *
  833. * The methodology is similar to that of the buffer cache.
  834. */
  835. if (num_physpages >= (128 * 1024))
  836. goal = num_physpages >> (21 - PAGE_SHIFT);
  837. else
  838. goal = num_physpages >> (23 - PAGE_SHIFT);
  839. if (thash_entries)
  840. goal = (thash_entries *
  841. sizeof(struct inet_ehash_bucket)) >> PAGE_SHIFT;
  842. for (ehash_order = 0; (1UL << ehash_order) < goal; ehash_order++)
  843. ;
  844. do {
  845. dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
  846. sizeof(struct inet_ehash_bucket);
  847. while (dccp_hashinfo.ehash_size &
  848. (dccp_hashinfo.ehash_size - 1))
  849. dccp_hashinfo.ehash_size--;
  850. dccp_hashinfo.ehash = (struct inet_ehash_bucket *)
  851. __get_free_pages(GFP_ATOMIC, ehash_order);
  852. } while (!dccp_hashinfo.ehash && --ehash_order > 0);
  853. if (!dccp_hashinfo.ehash) {
  854. DCCP_CRIT("Failed to allocate DCCP established hash table");
  855. goto out_free_bind_bucket_cachep;
  856. }
  857. for (i = 0; i < dccp_hashinfo.ehash_size; i++) {
  858. rwlock_init(&dccp_hashinfo.ehash[i].lock);
  859. INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].chain);
  860. INIT_HLIST_HEAD(&dccp_hashinfo.ehash[i].twchain);
  861. }
  862. bhash_order = ehash_order;
  863. do {
  864. dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
  865. sizeof(struct inet_bind_hashbucket);
  866. if ((dccp_hashinfo.bhash_size > (64 * 1024)) &&
  867. bhash_order > 0)
  868. continue;
  869. dccp_hashinfo.bhash = (struct inet_bind_hashbucket *)
  870. __get_free_pages(GFP_ATOMIC, bhash_order);
  871. } while (!dccp_hashinfo.bhash && --bhash_order >= 0);
  872. if (!dccp_hashinfo.bhash) {
  873. DCCP_CRIT("Failed to allocate DCCP bind hash table");
  874. goto out_free_dccp_ehash;
  875. }
  876. for (i = 0; i < dccp_hashinfo.bhash_size; i++) {
  877. spin_lock_init(&dccp_hashinfo.bhash[i].lock);
  878. INIT_HLIST_HEAD(&dccp_hashinfo.bhash[i].chain);
  879. }
  880. rc = dccp_mib_init();
  881. if (rc)
  882. goto out_free_dccp_bhash;
  883. rc = dccp_ackvec_init();
  884. if (rc)
  885. goto out_free_dccp_mib;
  886. rc = dccp_sysctl_init();
  887. if (rc)
  888. goto out_ackvec_exit;
  889. out:
  890. return rc;
  891. out_ackvec_exit:
  892. dccp_ackvec_exit();
  893. out_free_dccp_mib:
  894. dccp_mib_exit();
  895. out_free_dccp_bhash:
  896. free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
  897. dccp_hashinfo.bhash = NULL;
  898. out_free_dccp_ehash:
  899. free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
  900. dccp_hashinfo.ehash = NULL;
  901. out_free_bind_bucket_cachep:
  902. kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
  903. dccp_hashinfo.bind_bucket_cachep = NULL;
  904. goto out;
  905. }
  906. static void __exit dccp_fini(void)
  907. {
  908. dccp_mib_exit();
  909. free_pages((unsigned long)dccp_hashinfo.bhash,
  910. get_order(dccp_hashinfo.bhash_size *
  911. sizeof(struct inet_bind_hashbucket)));
  912. free_pages((unsigned long)dccp_hashinfo.ehash,
  913. get_order(dccp_hashinfo.ehash_size *
  914. sizeof(struct inet_ehash_bucket)));
  915. kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
  916. dccp_ackvec_exit();
  917. dccp_sysctl_exit();
  918. }
  919. module_init(dccp_init);
  920. module_exit(dccp_fini);
  921. MODULE_LICENSE("GPL");
  922. MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@conectiva.com.br>");
  923. MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");