input.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577
  1. /*
  2. * net/dccp/input.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/skbuff.h>
  14. #include <net/sock.h>
  15. #include "ackvec.h"
  16. #include "ccid.h"
  17. #include "dccp.h"
  18. static void dccp_fin(struct sock *sk, struct sk_buff *skb)
  19. {
  20. sk->sk_shutdown |= RCV_SHUTDOWN;
  21. sock_set_flag(sk, SOCK_DONE);
  22. __skb_pull(skb, dccp_hdr(skb)->dccph_doff * 4);
  23. __skb_queue_tail(&sk->sk_receive_queue, skb);
  24. skb_set_owner_r(skb, sk);
  25. sk->sk_data_ready(sk, 0);
  26. }
  27. static void dccp_rcv_close(struct sock *sk, struct sk_buff *skb)
  28. {
  29. dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
  30. dccp_fin(sk, skb);
  31. dccp_set_state(sk, DCCP_CLOSED);
  32. sk_wake_async(sk, 1, POLL_HUP);
  33. }
  34. static void dccp_rcv_closereq(struct sock *sk, struct sk_buff *skb)
  35. {
  36. /*
  37. * Step 7: Check for unexpected packet types
  38. * If (S.is_server and P.type == CloseReq)
  39. * Send Sync packet acknowledging P.seqno
  40. * Drop packet and return
  41. */
  42. if (dccp_sk(sk)->dccps_role != DCCP_ROLE_CLIENT) {
  43. dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq, DCCP_PKT_SYNC);
  44. return;
  45. }
  46. if (sk->sk_state != DCCP_CLOSING)
  47. dccp_set_state(sk, DCCP_CLOSING);
  48. dccp_send_close(sk, 0);
  49. }
  50. static void dccp_event_ack_recv(struct sock *sk, struct sk_buff *skb)
  51. {
  52. struct dccp_sock *dp = dccp_sk(sk);
  53. if (dccp_msk(sk)->dccpms_send_ack_vector)
  54. dccp_ackvec_check_rcv_ackno(dp->dccps_hc_rx_ackvec, sk,
  55. DCCP_SKB_CB(skb)->dccpd_ack_seq);
  56. }
  57. static int dccp_check_seqno(struct sock *sk, struct sk_buff *skb)
  58. {
  59. const struct dccp_hdr *dh = dccp_hdr(skb);
  60. struct dccp_sock *dp = dccp_sk(sk);
  61. u64 lswl, lawl;
  62. /*
  63. * Step 5: Prepare sequence numbers for Sync
  64. * If P.type == Sync or P.type == SyncAck,
  65. * If S.AWL <= P.ackno <= S.AWH and P.seqno >= S.SWL,
  66. * / * P is valid, so update sequence number variables
  67. * accordingly. After this update, P will pass the tests
  68. * in Step 6. A SyncAck is generated if necessary in
  69. * Step 15 * /
  70. * Update S.GSR, S.SWL, S.SWH
  71. * Otherwise,
  72. * Drop packet and return
  73. */
  74. if (dh->dccph_type == DCCP_PKT_SYNC ||
  75. dh->dccph_type == DCCP_PKT_SYNCACK) {
  76. if (between48(DCCP_SKB_CB(skb)->dccpd_ack_seq,
  77. dp->dccps_awl, dp->dccps_awh) &&
  78. !before48(DCCP_SKB_CB(skb)->dccpd_seq, dp->dccps_swl))
  79. dccp_update_gsr(sk, DCCP_SKB_CB(skb)->dccpd_seq);
  80. else
  81. return -1;
  82. }
  83. /*
  84. * Step 6: Check sequence numbers
  85. * Let LSWL = S.SWL and LAWL = S.AWL
  86. * If P.type == CloseReq or P.type == Close or P.type == Reset,
  87. * LSWL := S.GSR + 1, LAWL := S.GAR
  88. * If LSWL <= P.seqno <= S.SWH
  89. * and (P.ackno does not exist or LAWL <= P.ackno <= S.AWH),
  90. * Update S.GSR, S.SWL, S.SWH
  91. * If P.type != Sync,
  92. * Update S.GAR
  93. * Otherwise,
  94. * Send Sync packet acknowledging P.seqno
  95. * Drop packet and return
  96. */
  97. lswl = dp->dccps_swl;
  98. lawl = dp->dccps_awl;
  99. if (dh->dccph_type == DCCP_PKT_CLOSEREQ ||
  100. dh->dccph_type == DCCP_PKT_CLOSE ||
  101. dh->dccph_type == DCCP_PKT_RESET) {
  102. lswl = dp->dccps_gsr;
  103. dccp_inc_seqno(&lswl);
  104. lawl = dp->dccps_gar;
  105. }
  106. if (between48(DCCP_SKB_CB(skb)->dccpd_seq, lswl, dp->dccps_swh) &&
  107. (DCCP_SKB_CB(skb)->dccpd_ack_seq == DCCP_PKT_WITHOUT_ACK_SEQ ||
  108. between48(DCCP_SKB_CB(skb)->dccpd_ack_seq,
  109. lawl, dp->dccps_awh))) {
  110. dccp_update_gsr(sk, DCCP_SKB_CB(skb)->dccpd_seq);
  111. if (dh->dccph_type != DCCP_PKT_SYNC &&
  112. (DCCP_SKB_CB(skb)->dccpd_ack_seq !=
  113. DCCP_PKT_WITHOUT_ACK_SEQ))
  114. dp->dccps_gar = DCCP_SKB_CB(skb)->dccpd_ack_seq;
  115. } else {
  116. DCCP_WARN("DCCP: Step 6 failed for %s packet, "
  117. "(LSWL(%llu) <= P.seqno(%llu) <= S.SWH(%llu)) and "
  118. "(P.ackno %s or LAWL(%llu) <= P.ackno(%llu) <= S.AWH(%llu), "
  119. "sending SYNC...\n", dccp_packet_name(dh->dccph_type),
  120. (unsigned long long) lswl,
  121. (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq,
  122. (unsigned long long) dp->dccps_swh,
  123. (DCCP_SKB_CB(skb)->dccpd_ack_seq ==
  124. DCCP_PKT_WITHOUT_ACK_SEQ) ? "doesn't exist" : "exists",
  125. (unsigned long long) lawl,
  126. (unsigned long long) DCCP_SKB_CB(skb)->dccpd_ack_seq,
  127. (unsigned long long) dp->dccps_awh);
  128. dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq, DCCP_PKT_SYNC);
  129. return -1;
  130. }
  131. return 0;
  132. }
  133. static int __dccp_rcv_established(struct sock *sk, struct sk_buff *skb,
  134. const struct dccp_hdr *dh, const unsigned len)
  135. {
  136. struct dccp_sock *dp = dccp_sk(sk);
  137. switch (dccp_hdr(skb)->dccph_type) {
  138. case DCCP_PKT_DATAACK:
  139. case DCCP_PKT_DATA:
  140. /*
  141. * FIXME: check if sk_receive_queue is full, schedule DATA_DROPPED
  142. * option if it is.
  143. */
  144. __skb_pull(skb, dh->dccph_doff * 4);
  145. __skb_queue_tail(&sk->sk_receive_queue, skb);
  146. skb_set_owner_r(skb, sk);
  147. sk->sk_data_ready(sk, 0);
  148. return 0;
  149. case DCCP_PKT_ACK:
  150. goto discard;
  151. case DCCP_PKT_RESET:
  152. /*
  153. * Step 9: Process Reset
  154. * If P.type == Reset,
  155. * Tear down connection
  156. * S.state := TIMEWAIT
  157. * Set TIMEWAIT timer
  158. * Drop packet and return
  159. */
  160. dccp_fin(sk, skb);
  161. dccp_time_wait(sk, DCCP_TIME_WAIT, 0);
  162. return 0;
  163. case DCCP_PKT_CLOSEREQ:
  164. dccp_rcv_closereq(sk, skb);
  165. goto discard;
  166. case DCCP_PKT_CLOSE:
  167. dccp_rcv_close(sk, skb);
  168. return 0;
  169. case DCCP_PKT_REQUEST:
  170. /* Step 7
  171. * or (S.is_server and P.type == Response)
  172. * or (S.is_client and P.type == Request)
  173. * or (S.state >= OPEN and P.type == Request
  174. * and P.seqno >= S.OSR)
  175. * or (S.state >= OPEN and P.type == Response
  176. * and P.seqno >= S.OSR)
  177. * or (S.state == RESPOND and P.type == Data),
  178. * Send Sync packet acknowledging P.seqno
  179. * Drop packet and return
  180. */
  181. if (dp->dccps_role != DCCP_ROLE_LISTEN)
  182. goto send_sync;
  183. goto check_seq;
  184. case DCCP_PKT_RESPONSE:
  185. if (dp->dccps_role != DCCP_ROLE_CLIENT)
  186. goto send_sync;
  187. check_seq:
  188. if (!before48(DCCP_SKB_CB(skb)->dccpd_seq, dp->dccps_osr)) {
  189. send_sync:
  190. dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq,
  191. DCCP_PKT_SYNC);
  192. }
  193. break;
  194. case DCCP_PKT_SYNC:
  195. dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq,
  196. DCCP_PKT_SYNCACK);
  197. /*
  198. * From RFC 4340, sec. 5.7
  199. *
  200. * As with DCCP-Ack packets, DCCP-Sync and DCCP-SyncAck packets
  201. * MAY have non-zero-length application data areas, whose
  202. * contents receivers MUST ignore.
  203. */
  204. goto discard;
  205. }
  206. DCCP_INC_STATS_BH(DCCP_MIB_INERRS);
  207. discard:
  208. __kfree_skb(skb);
  209. return 0;
  210. }
  211. int dccp_rcv_established(struct sock *sk, struct sk_buff *skb,
  212. const struct dccp_hdr *dh, const unsigned len)
  213. {
  214. struct dccp_sock *dp = dccp_sk(sk);
  215. if (dccp_check_seqno(sk, skb))
  216. goto discard;
  217. if (dccp_parse_options(sk, skb))
  218. goto discard;
  219. if (DCCP_SKB_CB(skb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
  220. dccp_event_ack_recv(sk, skb);
  221. if (dccp_msk(sk)->dccpms_send_ack_vector &&
  222. dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
  223. DCCP_SKB_CB(skb)->dccpd_seq,
  224. DCCP_ACKVEC_STATE_RECEIVED))
  225. goto discard;
  226. ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb);
  227. ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb);
  228. return __dccp_rcv_established(sk, skb, dh, len);
  229. discard:
  230. __kfree_skb(skb);
  231. return 0;
  232. }
  233. EXPORT_SYMBOL_GPL(dccp_rcv_established);
  234. static int dccp_rcv_request_sent_state_process(struct sock *sk,
  235. struct sk_buff *skb,
  236. const struct dccp_hdr *dh,
  237. const unsigned len)
  238. {
  239. /*
  240. * Step 4: Prepare sequence numbers in REQUEST
  241. * If S.state == REQUEST,
  242. * If (P.type == Response or P.type == Reset)
  243. * and S.AWL <= P.ackno <= S.AWH,
  244. * / * Set sequence number variables corresponding to the
  245. * other endpoint, so P will pass the tests in Step 6 * /
  246. * Set S.GSR, S.ISR, S.SWL, S.SWH
  247. * / * Response processing continues in Step 10; Reset
  248. * processing continues in Step 9 * /
  249. */
  250. if (dh->dccph_type == DCCP_PKT_RESPONSE) {
  251. const struct inet_connection_sock *icsk = inet_csk(sk);
  252. struct dccp_sock *dp = dccp_sk(sk);
  253. /* Stop the REQUEST timer */
  254. inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
  255. BUG_TRAP(sk->sk_send_head != NULL);
  256. __kfree_skb(sk->sk_send_head);
  257. sk->sk_send_head = NULL;
  258. if (!between48(DCCP_SKB_CB(skb)->dccpd_ack_seq,
  259. dp->dccps_awl, dp->dccps_awh)) {
  260. dccp_pr_debug("invalid ackno: S.AWL=%llu, "
  261. "P.ackno=%llu, S.AWH=%llu \n",
  262. (unsigned long long)dp->dccps_awl,
  263. (unsigned long long)DCCP_SKB_CB(skb)->dccpd_ack_seq,
  264. (unsigned long long)dp->dccps_awh);
  265. goto out_invalid_packet;
  266. }
  267. if (dccp_parse_options(sk, skb))
  268. goto out_invalid_packet;
  269. if (dccp_msk(sk)->dccpms_send_ack_vector &&
  270. dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
  271. DCCP_SKB_CB(skb)->dccpd_seq,
  272. DCCP_ACKVEC_STATE_RECEIVED))
  273. goto out_invalid_packet; /* FIXME: change error code */
  274. dp->dccps_isr = DCCP_SKB_CB(skb)->dccpd_seq;
  275. dccp_update_gsr(sk, dp->dccps_isr);
  276. /*
  277. * SWL and AWL are initially adjusted so that they are not less than
  278. * the initial Sequence Numbers received and sent, respectively:
  279. * SWL := max(GSR + 1 - floor(W/4), ISR),
  280. * AWL := max(GSS - W' + 1, ISS).
  281. * These adjustments MUST be applied only at the beginning of the
  282. * connection.
  283. *
  284. * AWL was adjusted in dccp_v4_connect -acme
  285. */
  286. dccp_set_seqno(&dp->dccps_swl,
  287. max48(dp->dccps_swl, dp->dccps_isr));
  288. dccp_sync_mss(sk, icsk->icsk_pmtu_cookie);
  289. /*
  290. * Step 10: Process REQUEST state (second part)
  291. * If S.state == REQUEST,
  292. * / * If we get here, P is a valid Response from the
  293. * server (see Step 4), and we should move to
  294. * PARTOPEN state. PARTOPEN means send an Ack,
  295. * don't send Data packets, retransmit Acks
  296. * periodically, and always include any Init Cookie
  297. * from the Response * /
  298. * S.state := PARTOPEN
  299. * Set PARTOPEN timer
  300. * Continue with S.state == PARTOPEN
  301. * / * Step 12 will send the Ack completing the
  302. * three-way handshake * /
  303. */
  304. dccp_set_state(sk, DCCP_PARTOPEN);
  305. /* Make sure socket is routed, for correct metrics. */
  306. icsk->icsk_af_ops->rebuild_header(sk);
  307. if (!sock_flag(sk, SOCK_DEAD)) {
  308. sk->sk_state_change(sk);
  309. sk_wake_async(sk, 0, POLL_OUT);
  310. }
  311. if (sk->sk_write_pending || icsk->icsk_ack.pingpong ||
  312. icsk->icsk_accept_queue.rskq_defer_accept) {
  313. /* Save one ACK. Data will be ready after
  314. * several ticks, if write_pending is set.
  315. *
  316. * It may be deleted, but with this feature tcpdumps
  317. * look so _wonderfully_ clever, that I was not able
  318. * to stand against the temptation 8) --ANK
  319. */
  320. /*
  321. * OK, in DCCP we can as well do a similar trick, its
  322. * even in the draft, but there is no need for us to
  323. * schedule an ack here, as dccp_sendmsg does this for
  324. * us, also stated in the draft. -acme
  325. */
  326. __kfree_skb(skb);
  327. return 0;
  328. }
  329. dccp_send_ack(sk);
  330. return -1;
  331. }
  332. out_invalid_packet:
  333. /* dccp_v4_do_rcv will send a reset */
  334. DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_PACKET_ERROR;
  335. return 1;
  336. }
  337. static int dccp_rcv_respond_partopen_state_process(struct sock *sk,
  338. struct sk_buff *skb,
  339. const struct dccp_hdr *dh,
  340. const unsigned len)
  341. {
  342. int queued = 0;
  343. switch (dh->dccph_type) {
  344. case DCCP_PKT_RESET:
  345. inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
  346. break;
  347. case DCCP_PKT_DATA:
  348. if (sk->sk_state == DCCP_RESPOND)
  349. break;
  350. case DCCP_PKT_DATAACK:
  351. case DCCP_PKT_ACK:
  352. /*
  353. * FIXME: we should be reseting the PARTOPEN (DELACK) timer
  354. * here but only if we haven't used the DELACK timer for
  355. * something else, like sending a delayed ack for a TIMESTAMP
  356. * echo, etc, for now were not clearing it, sending an extra
  357. * ACK when there is nothing else to do in DELACK is not a big
  358. * deal after all.
  359. */
  360. /* Stop the PARTOPEN timer */
  361. if (sk->sk_state == DCCP_PARTOPEN)
  362. inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
  363. dccp_sk(sk)->dccps_osr = DCCP_SKB_CB(skb)->dccpd_seq;
  364. dccp_set_state(sk, DCCP_OPEN);
  365. if (dh->dccph_type == DCCP_PKT_DATAACK ||
  366. dh->dccph_type == DCCP_PKT_DATA) {
  367. __dccp_rcv_established(sk, skb, dh, len);
  368. queued = 1; /* packet was queued
  369. (by __dccp_rcv_established) */
  370. }
  371. break;
  372. }
  373. return queued;
  374. }
  375. int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
  376. struct dccp_hdr *dh, unsigned len)
  377. {
  378. struct dccp_sock *dp = dccp_sk(sk);
  379. struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
  380. const int old_state = sk->sk_state;
  381. int queued = 0;
  382. /*
  383. * Step 3: Process LISTEN state
  384. *
  385. * If S.state == LISTEN,
  386. * If P.type == Request or P contains a valid Init Cookie option,
  387. * (* Must scan the packet's options to check for Init
  388. * Cookies. Only Init Cookies are processed here,
  389. * however; other options are processed in Step 8. This
  390. * scan need only be performed if the endpoint uses Init
  391. * Cookies *)
  392. * (* Generate a new socket and switch to that socket *)
  393. * Set S := new socket for this port pair
  394. * S.state = RESPOND
  395. * Choose S.ISS (initial seqno) or set from Init Cookies
  396. * Initialize S.GAR := S.ISS
  397. * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init
  398. * Cookies Continue with S.state == RESPOND
  399. * (* A Response packet will be generated in Step 11 *)
  400. * Otherwise,
  401. * Generate Reset(No Connection) unless P.type == Reset
  402. * Drop packet and return
  403. */
  404. if (sk->sk_state == DCCP_LISTEN) {
  405. if (dh->dccph_type == DCCP_PKT_REQUEST) {
  406. if (inet_csk(sk)->icsk_af_ops->conn_request(sk,
  407. skb) < 0)
  408. return 1;
  409. /* FIXME: do congestion control initialization */
  410. goto discard;
  411. }
  412. if (dh->dccph_type == DCCP_PKT_RESET)
  413. goto discard;
  414. /* Caller (dccp_v4_do_rcv) will send Reset */
  415. dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
  416. return 1;
  417. }
  418. if (sk->sk_state != DCCP_REQUESTING) {
  419. if (dccp_check_seqno(sk, skb))
  420. goto discard;
  421. /*
  422. * Step 8: Process options and mark acknowledgeable
  423. */
  424. if (dccp_parse_options(sk, skb))
  425. goto discard;
  426. if (dcb->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
  427. dccp_event_ack_recv(sk, skb);
  428. if (dccp_msk(sk)->dccpms_send_ack_vector &&
  429. dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
  430. DCCP_SKB_CB(skb)->dccpd_seq,
  431. DCCP_ACKVEC_STATE_RECEIVED))
  432. goto discard;
  433. ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb);
  434. ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb);
  435. }
  436. /*
  437. * Step 9: Process Reset
  438. * If P.type == Reset,
  439. * Tear down connection
  440. * S.state := TIMEWAIT
  441. * Set TIMEWAIT timer
  442. * Drop packet and return
  443. */
  444. if (dh->dccph_type == DCCP_PKT_RESET) {
  445. /*
  446. * Queue the equivalent of TCP fin so that dccp_recvmsg
  447. * exits the loop
  448. */
  449. dccp_fin(sk, skb);
  450. dccp_time_wait(sk, DCCP_TIME_WAIT, 0);
  451. return 0;
  452. /*
  453. * Step 7: Check for unexpected packet types
  454. * If (S.is_server and P.type == CloseReq)
  455. * or (S.is_server and P.type == Response)
  456. * or (S.is_client and P.type == Request)
  457. * or (S.state == RESPOND and P.type == Data),
  458. * Send Sync packet acknowledging P.seqno
  459. * Drop packet and return
  460. */
  461. } else if ((dp->dccps_role != DCCP_ROLE_CLIENT &&
  462. (dh->dccph_type == DCCP_PKT_RESPONSE ||
  463. dh->dccph_type == DCCP_PKT_CLOSEREQ)) ||
  464. (dp->dccps_role == DCCP_ROLE_CLIENT &&
  465. dh->dccph_type == DCCP_PKT_REQUEST) ||
  466. (sk->sk_state == DCCP_RESPOND &&
  467. dh->dccph_type == DCCP_PKT_DATA)) {
  468. dccp_send_sync(sk, dcb->dccpd_seq, DCCP_PKT_SYNC);
  469. goto discard;
  470. } else if (dh->dccph_type == DCCP_PKT_CLOSEREQ) {
  471. dccp_rcv_closereq(sk, skb);
  472. goto discard;
  473. } else if (dh->dccph_type == DCCP_PKT_CLOSE) {
  474. dccp_rcv_close(sk, skb);
  475. return 0;
  476. }
  477. if (unlikely(dh->dccph_type == DCCP_PKT_SYNC)) {
  478. dccp_send_sync(sk, dcb->dccpd_seq, DCCP_PKT_SYNCACK);
  479. goto discard;
  480. }
  481. switch (sk->sk_state) {
  482. case DCCP_CLOSED:
  483. dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
  484. return 1;
  485. case DCCP_REQUESTING:
  486. /* FIXME: do congestion control initialization */
  487. queued = dccp_rcv_request_sent_state_process(sk, skb, dh, len);
  488. if (queued >= 0)
  489. return queued;
  490. __kfree_skb(skb);
  491. return 0;
  492. case DCCP_RESPOND:
  493. case DCCP_PARTOPEN:
  494. queued = dccp_rcv_respond_partopen_state_process(sk, skb,
  495. dh, len);
  496. break;
  497. }
  498. if (dh->dccph_type == DCCP_PKT_ACK ||
  499. dh->dccph_type == DCCP_PKT_DATAACK) {
  500. switch (old_state) {
  501. case DCCP_PARTOPEN:
  502. sk->sk_state_change(sk);
  503. sk_wake_async(sk, 0, POLL_OUT);
  504. break;
  505. }
  506. }
  507. if (!queued) {
  508. discard:
  509. __kfree_skb(skb);
  510. }
  511. return 0;
  512. }
  513. EXPORT_SYMBOL_GPL(dccp_rcv_state_process);