ipv4.c 28 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * net/dccp/ipv4.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/icmp.h>
  10. #include <linux/slab.h>
  11. #include <linux/module.h>
  12. #include <linux/skbuff.h>
  13. #include <linux/random.h>
  14. #include <net/icmp.h>
  15. #include <net/inet_common.h>
  16. #include <net/inet_hashtables.h>
  17. #include <net/inet_sock.h>
  18. #include <net/protocol.h>
  19. #include <net/sock.h>
  20. #include <net/timewait_sock.h>
  21. #include <net/tcp_states.h>
  22. #include <net/xfrm.h>
  23. #include <net/secure_seq.h>
  24. #include "ackvec.h"
  25. #include "ccid.h"
  26. #include "dccp.h"
  27. #include "feat.h"
  28. /*
  29. * The per-net dccp.v4_ctl_sk socket is used for responding to
  30. * the Out-of-the-blue (OOTB) packets. A control sock will be created
  31. * for this socket at the initialization time.
  32. */
  33. int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
  34. {
  35. const struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
  36. struct inet_sock *inet = inet_sk(sk);
  37. struct dccp_sock *dp = dccp_sk(sk);
  38. __be16 orig_sport, orig_dport;
  39. __be32 daddr, nexthop;
  40. struct flowi4 *fl4;
  41. struct rtable *rt;
  42. int err;
  43. struct ip_options_rcu *inet_opt;
  44. dp->dccps_role = DCCP_ROLE_CLIENT;
  45. if (addr_len < sizeof(struct sockaddr_in))
  46. return -EINVAL;
  47. if (usin->sin_family != AF_INET)
  48. return -EAFNOSUPPORT;
  49. nexthop = daddr = usin->sin_addr.s_addr;
  50. inet_opt = rcu_dereference_protected(inet->inet_opt,
  51. lockdep_sock_is_held(sk));
  52. if (inet_opt != NULL && inet_opt->opt.srr) {
  53. if (daddr == 0)
  54. return -EINVAL;
  55. nexthop = inet_opt->opt.faddr;
  56. }
  57. orig_sport = inet->inet_sport;
  58. orig_dport = usin->sin_port;
  59. fl4 = &inet->cork.fl.u.ip4;
  60. rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
  61. RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
  62. IPPROTO_DCCP,
  63. orig_sport, orig_dport, sk);
  64. if (IS_ERR(rt))
  65. return PTR_ERR(rt);
  66. if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
  67. ip_rt_put(rt);
  68. return -ENETUNREACH;
  69. }
  70. if (inet_opt == NULL || !inet_opt->opt.srr)
  71. daddr = fl4->daddr;
  72. if (inet->inet_saddr == 0)
  73. inet->inet_saddr = fl4->saddr;
  74. sk_rcv_saddr_set(sk, inet->inet_saddr);
  75. inet->inet_dport = usin->sin_port;
  76. sk_daddr_set(sk, daddr);
  77. inet_csk(sk)->icsk_ext_hdr_len = 0;
  78. if (inet_opt)
  79. inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
  80. /*
  81. * Socket identity is still unknown (sport may be zero).
  82. * However we set state to DCCP_REQUESTING and not releasing socket
  83. * lock select source port, enter ourselves into the hash tables and
  84. * complete initialization after this.
  85. */
  86. dccp_set_state(sk, DCCP_REQUESTING);
  87. err = inet_hash_connect(&dccp_death_row, sk);
  88. if (err != 0)
  89. goto failure;
  90. rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
  91. inet->inet_sport, inet->inet_dport, sk);
  92. if (IS_ERR(rt)) {
  93. err = PTR_ERR(rt);
  94. rt = NULL;
  95. goto failure;
  96. }
  97. /* OK, now commit destination to socket. */
  98. sk_setup_caps(sk, &rt->dst);
  99. dp->dccps_iss = secure_dccp_sequence_number(inet->inet_saddr,
  100. inet->inet_daddr,
  101. inet->inet_sport,
  102. inet->inet_dport);
  103. inet->inet_id = prandom_u32();
  104. err = dccp_connect(sk);
  105. rt = NULL;
  106. if (err != 0)
  107. goto failure;
  108. out:
  109. return err;
  110. failure:
  111. /*
  112. * This unhashes the socket and releases the local port, if necessary.
  113. */
  114. dccp_set_state(sk, DCCP_CLOSED);
  115. ip_rt_put(rt);
  116. sk->sk_route_caps = 0;
  117. inet->inet_dport = 0;
  118. goto out;
  119. }
  120. EXPORT_SYMBOL_GPL(dccp_v4_connect);
  121. /*
  122. * This routine does path mtu discovery as defined in RFC1191.
  123. */
  124. static inline void dccp_do_pmtu_discovery(struct sock *sk,
  125. const struct iphdr *iph,
  126. u32 mtu)
  127. {
  128. struct dst_entry *dst;
  129. const struct inet_sock *inet = inet_sk(sk);
  130. const struct dccp_sock *dp = dccp_sk(sk);
  131. /* We are not interested in DCCP_LISTEN and request_socks (RESPONSEs
  132. * send out by Linux are always < 576bytes so they should go through
  133. * unfragmented).
  134. */
  135. if (sk->sk_state == DCCP_LISTEN)
  136. return;
  137. dst = inet_csk_update_pmtu(sk, mtu);
  138. if (!dst)
  139. return;
  140. /* Something is about to be wrong... Remember soft error
  141. * for the case, if this connection will not able to recover.
  142. */
  143. if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
  144. sk->sk_err_soft = EMSGSIZE;
  145. mtu = dst_mtu(dst);
  146. if (inet->pmtudisc != IP_PMTUDISC_DONT &&
  147. ip_sk_accept_pmtu(sk) &&
  148. inet_csk(sk)->icsk_pmtu_cookie > mtu) {
  149. dccp_sync_mss(sk, mtu);
  150. /*
  151. * From RFC 4340, sec. 14.1:
  152. *
  153. * DCCP-Sync packets are the best choice for upward
  154. * probing, since DCCP-Sync probes do not risk application
  155. * data loss.
  156. */
  157. dccp_send_sync(sk, dp->dccps_gsr, DCCP_PKT_SYNC);
  158. } /* else let the usual retransmit timer handle it */
  159. }
  160. static void dccp_do_redirect(struct sk_buff *skb, struct sock *sk)
  161. {
  162. struct dst_entry *dst = __sk_dst_check(sk, 0);
  163. if (dst)
  164. dst->ops->redirect(dst, sk, skb);
  165. }
  166. void dccp_req_err(struct sock *sk, u64 seq)
  167. {
  168. struct request_sock *req = inet_reqsk(sk);
  169. struct net *net = sock_net(sk);
  170. /*
  171. * ICMPs are not backlogged, hence we cannot get an established
  172. * socket here.
  173. */
  174. if (!between48(seq, dccp_rsk(req)->dreq_iss, dccp_rsk(req)->dreq_gss)) {
  175. __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
  176. } else {
  177. /*
  178. * Still in RESPOND, just remove it silently.
  179. * There is no good way to pass the error to the newly
  180. * created socket, and POSIX does not want network
  181. * errors returned from accept().
  182. */
  183. inet_csk_reqsk_queue_drop(req->rsk_listener, req);
  184. }
  185. reqsk_put(req);
  186. }
  187. EXPORT_SYMBOL(dccp_req_err);
  188. /*
  189. * This routine is called by the ICMP module when it gets some sort of error
  190. * condition. If err < 0 then the socket should be closed and the error
  191. * returned to the user. If err > 0 it's just the icmp type << 8 | icmp code.
  192. * After adjustment header points to the first 8 bytes of the tcp header. We
  193. * need to find the appropriate port.
  194. *
  195. * The locking strategy used here is very "optimistic". When someone else
  196. * accesses the socket the ICMP is just dropped and for some paths there is no
  197. * check at all. A more general error queue to queue errors for later handling
  198. * is probably better.
  199. */
  200. static int dccp_v4_err(struct sk_buff *skb, u32 info)
  201. {
  202. const struct iphdr *iph = (struct iphdr *)skb->data;
  203. const u8 offset = iph->ihl << 2;
  204. const struct dccp_hdr *dh;
  205. struct dccp_sock *dp;
  206. struct inet_sock *inet;
  207. const int type = icmp_hdr(skb)->type;
  208. const int code = icmp_hdr(skb)->code;
  209. struct sock *sk;
  210. __u64 seq;
  211. int err;
  212. struct net *net = dev_net(skb->dev);
  213. /* Only need dccph_dport & dccph_sport which are the first
  214. * 4 bytes in dccp header.
  215. * Our caller (icmp_socket_deliver()) already pulled 8 bytes for us.
  216. */
  217. BUILD_BUG_ON(offsetofend(struct dccp_hdr, dccph_sport) > 8);
  218. BUILD_BUG_ON(offsetofend(struct dccp_hdr, dccph_dport) > 8);
  219. dh = (struct dccp_hdr *)(skb->data + offset);
  220. sk = __inet_lookup_established(net, &dccp_hashinfo,
  221. iph->daddr, dh->dccph_dport,
  222. iph->saddr, ntohs(dh->dccph_sport),
  223. inet_iif(skb), 0);
  224. if (!sk) {
  225. __ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
  226. return -ENOENT;
  227. }
  228. if (sk->sk_state == DCCP_TIME_WAIT) {
  229. inet_twsk_put(inet_twsk(sk));
  230. return 0;
  231. }
  232. seq = dccp_hdr_seq(dh);
  233. if (sk->sk_state == DCCP_NEW_SYN_RECV) {
  234. dccp_req_err(sk, seq);
  235. return 0;
  236. }
  237. bh_lock_sock(sk);
  238. /* If too many ICMPs get dropped on busy
  239. * servers this needs to be solved differently.
  240. */
  241. if (sock_owned_by_user(sk))
  242. __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS);
  243. if (sk->sk_state == DCCP_CLOSED)
  244. goto out;
  245. dp = dccp_sk(sk);
  246. if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_LISTEN) &&
  247. !between48(seq, dp->dccps_awl, dp->dccps_awh)) {
  248. __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
  249. goto out;
  250. }
  251. switch (type) {
  252. case ICMP_REDIRECT:
  253. if (!sock_owned_by_user(sk))
  254. dccp_do_redirect(skb, sk);
  255. goto out;
  256. case ICMP_SOURCE_QUENCH:
  257. /* Just silently ignore these. */
  258. goto out;
  259. case ICMP_PARAMETERPROB:
  260. err = EPROTO;
  261. break;
  262. case ICMP_DEST_UNREACH:
  263. if (code > NR_ICMP_UNREACH)
  264. goto out;
  265. if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
  266. if (!sock_owned_by_user(sk))
  267. dccp_do_pmtu_discovery(sk, iph, info);
  268. goto out;
  269. }
  270. err = icmp_err_convert[code].errno;
  271. break;
  272. case ICMP_TIME_EXCEEDED:
  273. err = EHOSTUNREACH;
  274. break;
  275. default:
  276. goto out;
  277. }
  278. switch (sk->sk_state) {
  279. case DCCP_REQUESTING:
  280. case DCCP_RESPOND:
  281. if (!sock_owned_by_user(sk)) {
  282. __DCCP_INC_STATS(DCCP_MIB_ATTEMPTFAILS);
  283. sk->sk_err = err;
  284. sk->sk_error_report(sk);
  285. dccp_done(sk);
  286. } else
  287. sk->sk_err_soft = err;
  288. goto out;
  289. }
  290. /* If we've already connected we will keep trying
  291. * until we time out, or the user gives up.
  292. *
  293. * rfc1122 4.2.3.9 allows to consider as hard errors
  294. * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
  295. * but it is obsoleted by pmtu discovery).
  296. *
  297. * Note, that in modern internet, where routing is unreliable
  298. * and in each dark corner broken firewalls sit, sending random
  299. * errors ordered by their masters even this two messages finally lose
  300. * their original sense (even Linux sends invalid PORT_UNREACHs)
  301. *
  302. * Now we are in compliance with RFCs.
  303. * --ANK (980905)
  304. */
  305. inet = inet_sk(sk);
  306. if (!sock_owned_by_user(sk) && inet->recverr) {
  307. sk->sk_err = err;
  308. sk->sk_error_report(sk);
  309. } else /* Only an error on timeout */
  310. sk->sk_err_soft = err;
  311. out:
  312. bh_unlock_sock(sk);
  313. sock_put(sk);
  314. return 0;
  315. }
  316. static inline __sum16 dccp_v4_csum_finish(struct sk_buff *skb,
  317. __be32 src, __be32 dst)
  318. {
  319. return csum_tcpudp_magic(src, dst, skb->len, IPPROTO_DCCP, skb->csum);
  320. }
  321. void dccp_v4_send_check(struct sock *sk, struct sk_buff *skb)
  322. {
  323. const struct inet_sock *inet = inet_sk(sk);
  324. struct dccp_hdr *dh = dccp_hdr(skb);
  325. dccp_csum_outgoing(skb);
  326. dh->dccph_checksum = dccp_v4_csum_finish(skb,
  327. inet->inet_saddr,
  328. inet->inet_daddr);
  329. }
  330. EXPORT_SYMBOL_GPL(dccp_v4_send_check);
  331. static inline u64 dccp_v4_init_sequence(const struct sk_buff *skb)
  332. {
  333. return secure_dccp_sequence_number(ip_hdr(skb)->daddr,
  334. ip_hdr(skb)->saddr,
  335. dccp_hdr(skb)->dccph_dport,
  336. dccp_hdr(skb)->dccph_sport);
  337. }
  338. /*
  339. * The three way handshake has completed - we got a valid ACK or DATAACK -
  340. * now create the new socket.
  341. *
  342. * This is the equivalent of TCP's tcp_v4_syn_recv_sock
  343. */
  344. struct sock *dccp_v4_request_recv_sock(const struct sock *sk,
  345. struct sk_buff *skb,
  346. struct request_sock *req,
  347. struct dst_entry *dst,
  348. struct request_sock *req_unhash,
  349. bool *own_req)
  350. {
  351. struct inet_request_sock *ireq;
  352. struct inet_sock *newinet;
  353. struct sock *newsk;
  354. if (sk_acceptq_is_full(sk))
  355. goto exit_overflow;
  356. newsk = dccp_create_openreq_child(sk, req, skb);
  357. if (newsk == NULL)
  358. goto exit_nonewsk;
  359. newinet = inet_sk(newsk);
  360. ireq = inet_rsk(req);
  361. sk_daddr_set(newsk, ireq->ir_rmt_addr);
  362. sk_rcv_saddr_set(newsk, ireq->ir_loc_addr);
  363. newinet->inet_saddr = ireq->ir_loc_addr;
  364. RCU_INIT_POINTER(newinet->inet_opt, rcu_dereference(ireq->ireq_opt));
  365. newinet->mc_index = inet_iif(skb);
  366. newinet->mc_ttl = ip_hdr(skb)->ttl;
  367. newinet->inet_id = prandom_u32();
  368. if (dst == NULL && (dst = inet_csk_route_child_sock(sk, newsk, req)) == NULL)
  369. goto put_and_exit;
  370. sk_setup_caps(newsk, dst);
  371. dccp_sync_mss(newsk, dst_mtu(dst));
  372. if (__inet_inherit_port(sk, newsk) < 0)
  373. goto put_and_exit;
  374. *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash), NULL);
  375. if (*own_req)
  376. ireq->ireq_opt = NULL;
  377. else
  378. newinet->inet_opt = NULL;
  379. return newsk;
  380. exit_overflow:
  381. __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
  382. exit_nonewsk:
  383. dst_release(dst);
  384. exit:
  385. __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENDROPS);
  386. return NULL;
  387. put_and_exit:
  388. newinet->inet_opt = NULL;
  389. inet_csk_prepare_forced_close(newsk);
  390. dccp_done(newsk);
  391. goto exit;
  392. }
  393. EXPORT_SYMBOL_GPL(dccp_v4_request_recv_sock);
  394. static struct dst_entry* dccp_v4_route_skb(struct net *net, struct sock *sk,
  395. struct sk_buff *skb)
  396. {
  397. struct rtable *rt;
  398. const struct iphdr *iph = ip_hdr(skb);
  399. struct flowi4 fl4 = {
  400. .flowi4_oif = inet_iif(skb),
  401. .daddr = iph->saddr,
  402. .saddr = iph->daddr,
  403. .flowi4_tos = RT_CONN_FLAGS(sk),
  404. .flowi4_proto = sk->sk_protocol,
  405. .fl4_sport = dccp_hdr(skb)->dccph_dport,
  406. .fl4_dport = dccp_hdr(skb)->dccph_sport,
  407. };
  408. security_skb_classify_flow(skb, flowi4_to_flowi(&fl4));
  409. rt = ip_route_output_flow(net, &fl4, sk);
  410. if (IS_ERR(rt)) {
  411. IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
  412. return NULL;
  413. }
  414. return &rt->dst;
  415. }
  416. static int dccp_v4_send_response(const struct sock *sk, struct request_sock *req)
  417. {
  418. int err = -1;
  419. struct sk_buff *skb;
  420. struct dst_entry *dst;
  421. struct flowi4 fl4;
  422. dst = inet_csk_route_req(sk, &fl4, req);
  423. if (dst == NULL)
  424. goto out;
  425. skb = dccp_make_response(sk, dst, req);
  426. if (skb != NULL) {
  427. const struct inet_request_sock *ireq = inet_rsk(req);
  428. struct dccp_hdr *dh = dccp_hdr(skb);
  429. dh->dccph_checksum = dccp_v4_csum_finish(skb, ireq->ir_loc_addr,
  430. ireq->ir_rmt_addr);
  431. rcu_read_lock();
  432. err = ip_build_and_send_pkt(skb, sk, ireq->ir_loc_addr,
  433. ireq->ir_rmt_addr,
  434. rcu_dereference(ireq->ireq_opt),
  435. inet_sk(sk)->tos);
  436. rcu_read_unlock();
  437. err = net_xmit_eval(err);
  438. }
  439. out:
  440. dst_release(dst);
  441. return err;
  442. }
  443. static void dccp_v4_ctl_send_reset(const struct sock *sk, struct sk_buff *rxskb)
  444. {
  445. int err;
  446. const struct iphdr *rxiph;
  447. struct sk_buff *skb;
  448. struct dst_entry *dst;
  449. struct net *net = dev_net(skb_dst(rxskb)->dev);
  450. struct sock *ctl_sk = net->dccp.v4_ctl_sk;
  451. /* Never send a reset in response to a reset. */
  452. if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
  453. return;
  454. if (skb_rtable(rxskb)->rt_type != RTN_LOCAL)
  455. return;
  456. dst = dccp_v4_route_skb(net, ctl_sk, rxskb);
  457. if (dst == NULL)
  458. return;
  459. skb = dccp_ctl_make_reset(ctl_sk, rxskb);
  460. if (skb == NULL)
  461. goto out;
  462. rxiph = ip_hdr(rxskb);
  463. dccp_hdr(skb)->dccph_checksum = dccp_v4_csum_finish(skb, rxiph->saddr,
  464. rxiph->daddr);
  465. skb_dst_set(skb, dst_clone(dst));
  466. local_bh_disable();
  467. bh_lock_sock(ctl_sk);
  468. err = ip_build_and_send_pkt(skb, ctl_sk,
  469. rxiph->daddr, rxiph->saddr, NULL,
  470. inet_sk(ctl_sk)->tos);
  471. bh_unlock_sock(ctl_sk);
  472. if (net_xmit_eval(err) == 0) {
  473. __DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
  474. __DCCP_INC_STATS(DCCP_MIB_OUTRSTS);
  475. }
  476. local_bh_enable();
  477. out:
  478. dst_release(dst);
  479. }
  480. static void dccp_v4_reqsk_destructor(struct request_sock *req)
  481. {
  482. dccp_feat_list_purge(&dccp_rsk(req)->dreq_featneg);
  483. kfree(rcu_dereference_protected(inet_rsk(req)->ireq_opt, 1));
  484. }
  485. void dccp_syn_ack_timeout(const struct request_sock *req)
  486. {
  487. }
  488. EXPORT_SYMBOL(dccp_syn_ack_timeout);
  489. static struct request_sock_ops dccp_request_sock_ops __read_mostly = {
  490. .family = PF_INET,
  491. .obj_size = sizeof(struct dccp_request_sock),
  492. .rtx_syn_ack = dccp_v4_send_response,
  493. .send_ack = dccp_reqsk_send_ack,
  494. .destructor = dccp_v4_reqsk_destructor,
  495. .send_reset = dccp_v4_ctl_send_reset,
  496. .syn_ack_timeout = dccp_syn_ack_timeout,
  497. };
  498. int dccp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
  499. {
  500. struct inet_request_sock *ireq;
  501. struct request_sock *req;
  502. struct dccp_request_sock *dreq;
  503. const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
  504. struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
  505. /* Never answer to DCCP_PKT_REQUESTs send to broadcast or multicast */
  506. if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
  507. return 0; /* discard, don't send a reset here */
  508. if (dccp_bad_service_code(sk, service)) {
  509. dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
  510. goto drop;
  511. }
  512. /*
  513. * TW buckets are converted to open requests without
  514. * limitations, they conserve resources and peer is
  515. * evidently real one.
  516. */
  517. dcb->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY;
  518. if (inet_csk_reqsk_queue_is_full(sk))
  519. goto drop;
  520. if (sk_acceptq_is_full(sk))
  521. goto drop;
  522. req = inet_reqsk_alloc(&dccp_request_sock_ops, sk, true);
  523. if (req == NULL)
  524. goto drop;
  525. if (dccp_reqsk_init(req, dccp_sk(sk), skb))
  526. goto drop_and_free;
  527. dreq = dccp_rsk(req);
  528. if (dccp_parse_options(sk, dreq, skb))
  529. goto drop_and_free;
  530. if (security_inet_conn_request(sk, skb, req))
  531. goto drop_and_free;
  532. ireq = inet_rsk(req);
  533. sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr);
  534. sk_daddr_set(req_to_sk(req), ip_hdr(skb)->saddr);
  535. ireq->ir_mark = inet_request_mark(sk, skb);
  536. ireq->ireq_family = AF_INET;
  537. ireq->ir_iif = sk->sk_bound_dev_if;
  538. /*
  539. * Step 3: Process LISTEN state
  540. *
  541. * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
  542. *
  543. * Setting S.SWL/S.SWH to is deferred to dccp_create_openreq_child().
  544. */
  545. dreq->dreq_isr = dcb->dccpd_seq;
  546. dreq->dreq_gsr = dreq->dreq_isr;
  547. dreq->dreq_iss = dccp_v4_init_sequence(skb);
  548. dreq->dreq_gss = dreq->dreq_iss;
  549. dreq->dreq_service = service;
  550. if (dccp_v4_send_response(sk, req))
  551. goto drop_and_free;
  552. inet_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT);
  553. reqsk_put(req);
  554. return 0;
  555. drop_and_free:
  556. reqsk_free(req);
  557. drop:
  558. __DCCP_INC_STATS(DCCP_MIB_ATTEMPTFAILS);
  559. return -1;
  560. }
  561. EXPORT_SYMBOL_GPL(dccp_v4_conn_request);
  562. int dccp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
  563. {
  564. struct dccp_hdr *dh = dccp_hdr(skb);
  565. if (sk->sk_state == DCCP_OPEN) { /* Fast path */
  566. if (dccp_rcv_established(sk, skb, dh, skb->len))
  567. goto reset;
  568. return 0;
  569. }
  570. /*
  571. * Step 3: Process LISTEN state
  572. * If P.type == Request or P contains a valid Init Cookie option,
  573. * (* Must scan the packet's options to check for Init
  574. * Cookies. Only Init Cookies are processed here,
  575. * however; other options are processed in Step 8. This
  576. * scan need only be performed if the endpoint uses Init
  577. * Cookies *)
  578. * (* Generate a new socket and switch to that socket *)
  579. * Set S := new socket for this port pair
  580. * S.state = RESPOND
  581. * Choose S.ISS (initial seqno) or set from Init Cookies
  582. * Initialize S.GAR := S.ISS
  583. * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookies
  584. * Continue with S.state == RESPOND
  585. * (* A Response packet will be generated in Step 11 *)
  586. * Otherwise,
  587. * Generate Reset(No Connection) unless P.type == Reset
  588. * Drop packet and return
  589. *
  590. * NOTE: the check for the packet types is done in
  591. * dccp_rcv_state_process
  592. */
  593. if (dccp_rcv_state_process(sk, skb, dh, skb->len))
  594. goto reset;
  595. return 0;
  596. reset:
  597. dccp_v4_ctl_send_reset(sk, skb);
  598. kfree_skb(skb);
  599. return 0;
  600. }
  601. EXPORT_SYMBOL_GPL(dccp_v4_do_rcv);
  602. /**
  603. * dccp_invalid_packet - check for malformed packets
  604. * @skb: Packet to validate
  605. *
  606. * Implements RFC 4340, 8.5: Step 1: Check header basics
  607. * Packets that fail these checks are ignored and do not receive Resets.
  608. */
  609. int dccp_invalid_packet(struct sk_buff *skb)
  610. {
  611. const struct dccp_hdr *dh;
  612. unsigned int cscov;
  613. u8 dccph_doff;
  614. if (skb->pkt_type != PACKET_HOST)
  615. return 1;
  616. /* If the packet is shorter than 12 bytes, drop packet and return */
  617. if (!pskb_may_pull(skb, sizeof(struct dccp_hdr))) {
  618. DCCP_WARN("pskb_may_pull failed\n");
  619. return 1;
  620. }
  621. dh = dccp_hdr(skb);
  622. /* If P.type is not understood, drop packet and return */
  623. if (dh->dccph_type >= DCCP_PKT_INVALID) {
  624. DCCP_WARN("invalid packet type\n");
  625. return 1;
  626. }
  627. /*
  628. * If P.Data Offset is too small for packet type, drop packet and return
  629. */
  630. dccph_doff = dh->dccph_doff;
  631. if (dccph_doff < dccp_hdr_len(skb) / sizeof(u32)) {
  632. DCCP_WARN("P.Data Offset(%u) too small\n", dccph_doff);
  633. return 1;
  634. }
  635. /*
  636. * If P.Data Offset is too large for packet, drop packet and return
  637. */
  638. if (!pskb_may_pull(skb, dccph_doff * sizeof(u32))) {
  639. DCCP_WARN("P.Data Offset(%u) too large\n", dccph_doff);
  640. return 1;
  641. }
  642. dh = dccp_hdr(skb);
  643. /*
  644. * If P.type is not Data, Ack, or DataAck and P.X == 0 (the packet
  645. * has short sequence numbers), drop packet and return
  646. */
  647. if ((dh->dccph_type < DCCP_PKT_DATA ||
  648. dh->dccph_type > DCCP_PKT_DATAACK) && dh->dccph_x == 0) {
  649. DCCP_WARN("P.type (%s) not Data || [Data]Ack, while P.X == 0\n",
  650. dccp_packet_name(dh->dccph_type));
  651. return 1;
  652. }
  653. /*
  654. * If P.CsCov is too large for the packet size, drop packet and return.
  655. * This must come _before_ checksumming (not as RFC 4340 suggests).
  656. */
  657. cscov = dccp_csum_coverage(skb);
  658. if (cscov > skb->len) {
  659. DCCP_WARN("P.CsCov %u exceeds packet length %d\n",
  660. dh->dccph_cscov, skb->len);
  661. return 1;
  662. }
  663. /* If header checksum is incorrect, drop packet and return.
  664. * (This step is completed in the AF-dependent functions.) */
  665. skb->csum = skb_checksum(skb, 0, cscov, 0);
  666. return 0;
  667. }
  668. EXPORT_SYMBOL_GPL(dccp_invalid_packet);
  669. /* this is called when real data arrives */
  670. static int dccp_v4_rcv(struct sk_buff *skb)
  671. {
  672. const struct dccp_hdr *dh;
  673. const struct iphdr *iph;
  674. bool refcounted;
  675. struct sock *sk;
  676. int min_cov;
  677. /* Step 1: Check header basics */
  678. if (dccp_invalid_packet(skb))
  679. goto discard_it;
  680. iph = ip_hdr(skb);
  681. /* Step 1: If header checksum is incorrect, drop packet and return */
  682. if (dccp_v4_csum_finish(skb, iph->saddr, iph->daddr)) {
  683. DCCP_WARN("dropped packet with invalid checksum\n");
  684. goto discard_it;
  685. }
  686. dh = dccp_hdr(skb);
  687. DCCP_SKB_CB(skb)->dccpd_seq = dccp_hdr_seq(dh);
  688. DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type;
  689. dccp_pr_debug("%8.8s src=%pI4@%-5d dst=%pI4@%-5d seq=%llu",
  690. dccp_packet_name(dh->dccph_type),
  691. &iph->saddr, ntohs(dh->dccph_sport),
  692. &iph->daddr, ntohs(dh->dccph_dport),
  693. (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq);
  694. if (dccp_packet_without_ack(skb)) {
  695. DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ;
  696. dccp_pr_debug_cat("\n");
  697. } else {
  698. DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb);
  699. dccp_pr_debug_cat(", ack=%llu\n", (unsigned long long)
  700. DCCP_SKB_CB(skb)->dccpd_ack_seq);
  701. }
  702. lookup:
  703. sk = __inet_lookup_skb(&dccp_hashinfo, skb, __dccp_hdr_len(dh),
  704. dh->dccph_sport, dh->dccph_dport, 0, &refcounted);
  705. if (!sk) {
  706. dccp_pr_debug("failed to look up flow ID in table and "
  707. "get corresponding socket\n");
  708. goto no_dccp_socket;
  709. }
  710. /*
  711. * Step 2:
  712. * ... or S.state == TIMEWAIT,
  713. * Generate Reset(No Connection) unless P.type == Reset
  714. * Drop packet and return
  715. */
  716. if (sk->sk_state == DCCP_TIME_WAIT) {
  717. dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: do_time_wait\n");
  718. inet_twsk_put(inet_twsk(sk));
  719. goto no_dccp_socket;
  720. }
  721. if (sk->sk_state == DCCP_NEW_SYN_RECV) {
  722. struct request_sock *req = inet_reqsk(sk);
  723. struct sock *nsk;
  724. sk = req->rsk_listener;
  725. if (unlikely(sk->sk_state != DCCP_LISTEN)) {
  726. inet_csk_reqsk_queue_drop_and_put(sk, req);
  727. goto lookup;
  728. }
  729. sock_hold(sk);
  730. refcounted = true;
  731. nsk = dccp_check_req(sk, skb, req);
  732. if (!nsk) {
  733. reqsk_put(req);
  734. goto discard_and_relse;
  735. }
  736. if (nsk == sk) {
  737. reqsk_put(req);
  738. } else if (dccp_child_process(sk, nsk, skb)) {
  739. dccp_v4_ctl_send_reset(sk, skb);
  740. goto discard_and_relse;
  741. } else {
  742. sock_put(sk);
  743. return 0;
  744. }
  745. }
  746. /*
  747. * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage
  748. * o if MinCsCov = 0, only packets with CsCov = 0 are accepted
  749. * o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov
  750. */
  751. min_cov = dccp_sk(sk)->dccps_pcrlen;
  752. if (dh->dccph_cscov && (min_cov == 0 || dh->dccph_cscov < min_cov)) {
  753. dccp_pr_debug("Packet CsCov %d does not satisfy MinCsCov %d\n",
  754. dh->dccph_cscov, min_cov);
  755. /* FIXME: "Such packets SHOULD be reported using Data Dropped
  756. * options (Section 11.7) with Drop Code 0, Protocol
  757. * Constraints." */
  758. goto discard_and_relse;
  759. }
  760. if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
  761. goto discard_and_relse;
  762. nf_reset_ct(skb);
  763. return __sk_receive_skb(sk, skb, 1, dh->dccph_doff * 4, refcounted);
  764. no_dccp_socket:
  765. if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
  766. goto discard_it;
  767. /*
  768. * Step 2:
  769. * If no socket ...
  770. * Generate Reset(No Connection) unless P.type == Reset
  771. * Drop packet and return
  772. */
  773. if (dh->dccph_type != DCCP_PKT_RESET) {
  774. DCCP_SKB_CB(skb)->dccpd_reset_code =
  775. DCCP_RESET_CODE_NO_CONNECTION;
  776. dccp_v4_ctl_send_reset(sk, skb);
  777. }
  778. discard_it:
  779. kfree_skb(skb);
  780. return 0;
  781. discard_and_relse:
  782. if (refcounted)
  783. sock_put(sk);
  784. goto discard_it;
  785. }
  786. static const struct inet_connection_sock_af_ops dccp_ipv4_af_ops = {
  787. .queue_xmit = ip_queue_xmit,
  788. .send_check = dccp_v4_send_check,
  789. .rebuild_header = inet_sk_rebuild_header,
  790. .conn_request = dccp_v4_conn_request,
  791. .syn_recv_sock = dccp_v4_request_recv_sock,
  792. .net_header_len = sizeof(struct iphdr),
  793. .setsockopt = ip_setsockopt,
  794. .getsockopt = ip_getsockopt,
  795. .addr2sockaddr = inet_csk_addr2sockaddr,
  796. .sockaddr_len = sizeof(struct sockaddr_in),
  797. };
  798. static int dccp_v4_init_sock(struct sock *sk)
  799. {
  800. static __u8 dccp_v4_ctl_sock_initialized;
  801. int err = dccp_init_sock(sk, dccp_v4_ctl_sock_initialized);
  802. if (err == 0) {
  803. if (unlikely(!dccp_v4_ctl_sock_initialized))
  804. dccp_v4_ctl_sock_initialized = 1;
  805. inet_csk(sk)->icsk_af_ops = &dccp_ipv4_af_ops;
  806. }
  807. return err;
  808. }
  809. static struct timewait_sock_ops dccp_timewait_sock_ops = {
  810. .twsk_obj_size = sizeof(struct inet_timewait_sock),
  811. };
  812. static struct proto dccp_v4_prot = {
  813. .name = "DCCP",
  814. .owner = THIS_MODULE,
  815. .close = dccp_close,
  816. .connect = dccp_v4_connect,
  817. .disconnect = dccp_disconnect,
  818. .ioctl = dccp_ioctl,
  819. .init = dccp_v4_init_sock,
  820. .setsockopt = dccp_setsockopt,
  821. .getsockopt = dccp_getsockopt,
  822. .sendmsg = dccp_sendmsg,
  823. .recvmsg = dccp_recvmsg,
  824. .backlog_rcv = dccp_v4_do_rcv,
  825. .hash = inet_hash,
  826. .unhash = inet_unhash,
  827. .accept = inet_csk_accept,
  828. .get_port = inet_csk_get_port,
  829. .shutdown = dccp_shutdown,
  830. .destroy = dccp_destroy_sock,
  831. .orphan_count = &dccp_orphan_count,
  832. .max_header = MAX_DCCP_HEADER,
  833. .obj_size = sizeof(struct dccp_sock),
  834. .slab_flags = SLAB_TYPESAFE_BY_RCU,
  835. .rsk_prot = &dccp_request_sock_ops,
  836. .twsk_prot = &dccp_timewait_sock_ops,
  837. .h.hashinfo = &dccp_hashinfo,
  838. };
  839. static const struct net_protocol dccp_v4_protocol = {
  840. .handler = dccp_v4_rcv,
  841. .err_handler = dccp_v4_err,
  842. .no_policy = 1,
  843. .netns_ok = 1,
  844. .icmp_strict_tag_validation = 1,
  845. };
  846. static const struct proto_ops inet_dccp_ops = {
  847. .family = PF_INET,
  848. .owner = THIS_MODULE,
  849. .release = inet_release,
  850. .bind = inet_bind,
  851. .connect = inet_stream_connect,
  852. .socketpair = sock_no_socketpair,
  853. .accept = inet_accept,
  854. .getname = inet_getname,
  855. /* FIXME: work on tcp_poll to rename it to inet_csk_poll */
  856. .poll = dccp_poll,
  857. .ioctl = inet_ioctl,
  858. .gettstamp = sock_gettstamp,
  859. /* FIXME: work on inet_listen to rename it to sock_common_listen */
  860. .listen = inet_dccp_listen,
  861. .shutdown = inet_shutdown,
  862. .setsockopt = sock_common_setsockopt,
  863. .getsockopt = sock_common_getsockopt,
  864. .sendmsg = inet_sendmsg,
  865. .recvmsg = sock_common_recvmsg,
  866. .mmap = sock_no_mmap,
  867. .sendpage = sock_no_sendpage,
  868. };
  869. static struct inet_protosw dccp_v4_protosw = {
  870. .type = SOCK_DCCP,
  871. .protocol = IPPROTO_DCCP,
  872. .prot = &dccp_v4_prot,
  873. .ops = &inet_dccp_ops,
  874. .flags = INET_PROTOSW_ICSK,
  875. };
  876. static int __net_init dccp_v4_init_net(struct net *net)
  877. {
  878. if (dccp_hashinfo.bhash == NULL)
  879. return -ESOCKTNOSUPPORT;
  880. return inet_ctl_sock_create(&net->dccp.v4_ctl_sk, PF_INET,
  881. SOCK_DCCP, IPPROTO_DCCP, net);
  882. }
  883. static void __net_exit dccp_v4_exit_net(struct net *net)
  884. {
  885. inet_ctl_sock_destroy(net->dccp.v4_ctl_sk);
  886. }
  887. static void __net_exit dccp_v4_exit_batch(struct list_head *net_exit_list)
  888. {
  889. inet_twsk_purge(&dccp_hashinfo, AF_INET);
  890. }
  891. static struct pernet_operations dccp_v4_ops = {
  892. .init = dccp_v4_init_net,
  893. .exit = dccp_v4_exit_net,
  894. .exit_batch = dccp_v4_exit_batch,
  895. };
  896. static int __init dccp_v4_init(void)
  897. {
  898. int err = proto_register(&dccp_v4_prot, 1);
  899. if (err)
  900. goto out;
  901. inet_register_protosw(&dccp_v4_protosw);
  902. err = register_pernet_subsys(&dccp_v4_ops);
  903. if (err)
  904. goto out_destroy_ctl_sock;
  905. err = inet_add_protocol(&dccp_v4_protocol, IPPROTO_DCCP);
  906. if (err)
  907. goto out_proto_unregister;
  908. out:
  909. return err;
  910. out_proto_unregister:
  911. unregister_pernet_subsys(&dccp_v4_ops);
  912. out_destroy_ctl_sock:
  913. inet_unregister_protosw(&dccp_v4_protosw);
  914. proto_unregister(&dccp_v4_prot);
  915. goto out;
  916. }
  917. static void __exit dccp_v4_exit(void)
  918. {
  919. inet_del_protocol(&dccp_v4_protocol, IPPROTO_DCCP);
  920. unregister_pernet_subsys(&dccp_v4_ops);
  921. inet_unregister_protosw(&dccp_v4_protosw);
  922. proto_unregister(&dccp_v4_prot);
  923. }
  924. module_init(dccp_v4_init);
  925. module_exit(dccp_v4_exit);
  926. /*
  927. * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33)
  928. * values directly, Also cover the case where the protocol is not specified,
  929. * i.e. net-pf-PF_INET-proto-0-type-SOCK_DCCP
  930. */
  931. MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET, 33, 6);
  932. MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET, 0, 6);
  933. MODULE_LICENSE("GPL");
  934. MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
  935. MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");