ipv4.c 27 KB

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