output.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801
  1. /* SCTP kernel implementation
  2. * (C) Copyright IBM Corp. 2001, 2004
  3. * Copyright (c) 1999-2000 Cisco, Inc.
  4. * Copyright (c) 1999-2001 Motorola, Inc.
  5. *
  6. * This file is part of the SCTP kernel implementation
  7. *
  8. * These functions handle output processing.
  9. *
  10. * This SCTP implementation is free software;
  11. * you can redistribute it and/or modify it under the terms of
  12. * the GNU General Public License as published by
  13. * the Free Software Foundation; either version 2, or (at your option)
  14. * any later version.
  15. *
  16. * This SCTP implementation is distributed in the hope that it
  17. * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  18. * ************************
  19. * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  20. * See the GNU General Public License for more details.
  21. *
  22. * You should have received a copy of the GNU General Public License
  23. * along with GNU CC; see the file COPYING. If not, write to
  24. * the Free Software Foundation, 59 Temple Place - Suite 330,
  25. * Boston, MA 02111-1307, USA.
  26. *
  27. * Please send any bug reports or fixes you make to the
  28. * email address(es):
  29. * lksctp developers <lksctp-developers@lists.sourceforge.net>
  30. *
  31. * Or submit a bug report through the following website:
  32. * http://www.sf.net/projects/lksctp
  33. *
  34. * Written or modified by:
  35. * La Monte H.P. Yarroll <piggy@acm.org>
  36. * Karl Knutson <karl@athena.chicago.il.us>
  37. * Jon Grimm <jgrimm@austin.ibm.com>
  38. * Sridhar Samudrala <sri@us.ibm.com>
  39. *
  40. * Any bugs reported given to us we will try to fix... any fixes shared will
  41. * be incorporated into the next SCTP release.
  42. */
  43. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  44. #include <linux/types.h>
  45. #include <linux/kernel.h>
  46. #include <linux/wait.h>
  47. #include <linux/time.h>
  48. #include <linux/ip.h>
  49. #include <linux/ipv6.h>
  50. #include <linux/init.h>
  51. #include <linux/slab.h>
  52. #include <net/inet_ecn.h>
  53. #include <net/ip.h>
  54. #include <net/icmp.h>
  55. #include <net/net_namespace.h>
  56. #include <linux/socket.h> /* for sa_family_t */
  57. #include <net/sock.h>
  58. #include <net/sctp/sctp.h>
  59. #include <net/sctp/sm.h>
  60. #include <net/sctp/checksum.h>
  61. /* Forward declarations for private helpers. */
  62. static sctp_xmit_t __sctp_packet_append_chunk(struct sctp_packet *packet,
  63. struct sctp_chunk *chunk);
  64. static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet,
  65. struct sctp_chunk *chunk);
  66. static void sctp_packet_append_data(struct sctp_packet *packet,
  67. struct sctp_chunk *chunk);
  68. static sctp_xmit_t sctp_packet_will_fit(struct sctp_packet *packet,
  69. struct sctp_chunk *chunk,
  70. u16 chunk_len);
  71. static void sctp_packet_reset(struct sctp_packet *packet)
  72. {
  73. packet->size = packet->overhead;
  74. packet->has_cookie_echo = 0;
  75. packet->has_sack = 0;
  76. packet->has_data = 0;
  77. packet->has_auth = 0;
  78. packet->ipfragok = 0;
  79. packet->auth = NULL;
  80. }
  81. /* Config a packet.
  82. * This appears to be a followup set of initializations.
  83. */
  84. struct sctp_packet *sctp_packet_config(struct sctp_packet *packet,
  85. __u32 vtag, int ecn_capable)
  86. {
  87. struct sctp_chunk *chunk = NULL;
  88. SCTP_DEBUG_PRINTK("%s: packet:%p vtag:0x%x\n", __func__,
  89. packet, vtag);
  90. packet->vtag = vtag;
  91. if (ecn_capable && sctp_packet_empty(packet)) {
  92. chunk = sctp_get_ecne_prepend(packet->transport->asoc);
  93. /* If there a is a prepend chunk stick it on the list before
  94. * any other chunks get appended.
  95. */
  96. if (chunk)
  97. sctp_packet_append_chunk(packet, chunk);
  98. }
  99. return packet;
  100. }
  101. /* Initialize the packet structure. */
  102. struct sctp_packet *sctp_packet_init(struct sctp_packet *packet,
  103. struct sctp_transport *transport,
  104. __u16 sport, __u16 dport)
  105. {
  106. struct sctp_association *asoc = transport->asoc;
  107. size_t overhead;
  108. SCTP_DEBUG_PRINTK("%s: packet:%p transport:%p\n", __func__,
  109. packet, transport);
  110. packet->transport = transport;
  111. packet->source_port = sport;
  112. packet->destination_port = dport;
  113. INIT_LIST_HEAD(&packet->chunk_list);
  114. if (asoc) {
  115. struct sctp_sock *sp = sctp_sk(asoc->base.sk);
  116. overhead = sp->pf->af->net_header_len;
  117. } else {
  118. overhead = sizeof(struct ipv6hdr);
  119. }
  120. overhead += sizeof(struct sctphdr);
  121. packet->overhead = overhead;
  122. sctp_packet_reset(packet);
  123. packet->vtag = 0;
  124. return packet;
  125. }
  126. /* Free a packet. */
  127. void sctp_packet_free(struct sctp_packet *packet)
  128. {
  129. struct sctp_chunk *chunk, *tmp;
  130. SCTP_DEBUG_PRINTK("%s: packet:%p\n", __func__, packet);
  131. list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
  132. list_del_init(&chunk->list);
  133. sctp_chunk_free(chunk);
  134. }
  135. }
  136. /* This routine tries to append the chunk to the offered packet. If adding
  137. * the chunk causes the packet to exceed the path MTU and COOKIE_ECHO chunk
  138. * is not present in the packet, it transmits the input packet.
  139. * Data can be bundled with a packet containing a COOKIE_ECHO chunk as long
  140. * as it can fit in the packet, but any more data that does not fit in this
  141. * packet can be sent only after receiving the COOKIE_ACK.
  142. */
  143. sctp_xmit_t sctp_packet_transmit_chunk(struct sctp_packet *packet,
  144. struct sctp_chunk *chunk,
  145. int one_packet)
  146. {
  147. sctp_xmit_t retval;
  148. int error = 0;
  149. SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __func__,
  150. packet, chunk);
  151. switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) {
  152. case SCTP_XMIT_PMTU_FULL:
  153. if (!packet->has_cookie_echo) {
  154. error = sctp_packet_transmit(packet);
  155. if (error < 0)
  156. chunk->skb->sk->sk_err = -error;
  157. /* If we have an empty packet, then we can NOT ever
  158. * return PMTU_FULL.
  159. */
  160. if (!one_packet)
  161. retval = sctp_packet_append_chunk(packet,
  162. chunk);
  163. }
  164. break;
  165. case SCTP_XMIT_RWND_FULL:
  166. case SCTP_XMIT_OK:
  167. case SCTP_XMIT_NAGLE_DELAY:
  168. break;
  169. }
  170. return retval;
  171. }
  172. /* Try to bundle an auth chunk into the packet. */
  173. static sctp_xmit_t sctp_packet_bundle_auth(struct sctp_packet *pkt,
  174. struct sctp_chunk *chunk)
  175. {
  176. struct sctp_association *asoc = pkt->transport->asoc;
  177. struct sctp_chunk *auth;
  178. sctp_xmit_t retval = SCTP_XMIT_OK;
  179. /* if we don't have an association, we can't do authentication */
  180. if (!asoc)
  181. return retval;
  182. /* See if this is an auth chunk we are bundling or if
  183. * auth is already bundled.
  184. */
  185. if (chunk->chunk_hdr->type == SCTP_CID_AUTH || pkt->has_auth)
  186. return retval;
  187. /* if the peer did not request this chunk to be authenticated,
  188. * don't do it
  189. */
  190. if (!chunk->auth)
  191. return retval;
  192. auth = sctp_make_auth(asoc);
  193. if (!auth)
  194. return retval;
  195. retval = __sctp_packet_append_chunk(pkt, auth);
  196. if (retval != SCTP_XMIT_OK)
  197. sctp_chunk_free(auth);
  198. return retval;
  199. }
  200. /* Try to bundle a SACK with the packet. */
  201. static sctp_xmit_t sctp_packet_bundle_sack(struct sctp_packet *pkt,
  202. struct sctp_chunk *chunk)
  203. {
  204. sctp_xmit_t retval = SCTP_XMIT_OK;
  205. /* If sending DATA and haven't aleady bundled a SACK, try to
  206. * bundle one in to the packet.
  207. */
  208. if (sctp_chunk_is_data(chunk) && !pkt->has_sack &&
  209. !pkt->has_cookie_echo) {
  210. struct sctp_association *asoc;
  211. struct timer_list *timer;
  212. asoc = pkt->transport->asoc;
  213. timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
  214. /* If the SACK timer is running, we have a pending SACK */
  215. if (timer_pending(timer)) {
  216. struct sctp_chunk *sack;
  217. if (pkt->transport->sack_generation !=
  218. pkt->transport->asoc->peer.sack_generation)
  219. return retval;
  220. asoc->a_rwnd = asoc->rwnd;
  221. sack = sctp_make_sack(asoc);
  222. if (sack) {
  223. retval = __sctp_packet_append_chunk(pkt, sack);
  224. if (retval != SCTP_XMIT_OK) {
  225. sctp_chunk_free(sack);
  226. goto out;
  227. }
  228. asoc->peer.sack_needed = 0;
  229. if (del_timer(timer))
  230. sctp_association_put(asoc);
  231. }
  232. }
  233. }
  234. out:
  235. return retval;
  236. }
  237. /* Append a chunk to the offered packet reporting back any inability to do
  238. * so.
  239. */
  240. static sctp_xmit_t __sctp_packet_append_chunk(struct sctp_packet *packet,
  241. struct sctp_chunk *chunk)
  242. {
  243. sctp_xmit_t retval = SCTP_XMIT_OK;
  244. __u16 chunk_len = WORD_ROUND(ntohs(chunk->chunk_hdr->length));
  245. /* Check to see if this chunk will fit into the packet */
  246. retval = sctp_packet_will_fit(packet, chunk, chunk_len);
  247. if (retval != SCTP_XMIT_OK)
  248. goto finish;
  249. /* We believe that this chunk is OK to add to the packet */
  250. switch (chunk->chunk_hdr->type) {
  251. case SCTP_CID_DATA:
  252. /* Account for the data being in the packet */
  253. sctp_packet_append_data(packet, chunk);
  254. /* Disallow SACK bundling after DATA. */
  255. packet->has_sack = 1;
  256. /* Disallow AUTH bundling after DATA */
  257. packet->has_auth = 1;
  258. /* Let it be knows that packet has DATA in it */
  259. packet->has_data = 1;
  260. /* timestamp the chunk for rtx purposes */
  261. chunk->sent_at = jiffies;
  262. break;
  263. case SCTP_CID_COOKIE_ECHO:
  264. packet->has_cookie_echo = 1;
  265. break;
  266. case SCTP_CID_SACK:
  267. packet->has_sack = 1;
  268. if (chunk->asoc)
  269. chunk->asoc->stats.osacks++;
  270. break;
  271. case SCTP_CID_AUTH:
  272. packet->has_auth = 1;
  273. packet->auth = chunk;
  274. break;
  275. }
  276. /* It is OK to send this chunk. */
  277. list_add_tail(&chunk->list, &packet->chunk_list);
  278. packet->size += chunk_len;
  279. chunk->transport = packet->transport;
  280. finish:
  281. return retval;
  282. }
  283. /* Append a chunk to the offered packet reporting back any inability to do
  284. * so.
  285. */
  286. sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *packet,
  287. struct sctp_chunk *chunk)
  288. {
  289. sctp_xmit_t retval = SCTP_XMIT_OK;
  290. SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __func__, packet,
  291. chunk);
  292. /* Data chunks are special. Before seeing what else we can
  293. * bundle into this packet, check to see if we are allowed to
  294. * send this DATA.
  295. */
  296. if (sctp_chunk_is_data(chunk)) {
  297. retval = sctp_packet_can_append_data(packet, chunk);
  298. if (retval != SCTP_XMIT_OK)
  299. goto finish;
  300. }
  301. /* Try to bundle AUTH chunk */
  302. retval = sctp_packet_bundle_auth(packet, chunk);
  303. if (retval != SCTP_XMIT_OK)
  304. goto finish;
  305. /* Try to bundle SACK chunk */
  306. retval = sctp_packet_bundle_sack(packet, chunk);
  307. if (retval != SCTP_XMIT_OK)
  308. goto finish;
  309. retval = __sctp_packet_append_chunk(packet, chunk);
  310. finish:
  311. return retval;
  312. }
  313. static void sctp_packet_release_owner(struct sk_buff *skb)
  314. {
  315. sk_free(skb->sk);
  316. }
  317. static void sctp_packet_set_owner_w(struct sk_buff *skb, struct sock *sk)
  318. {
  319. skb_orphan(skb);
  320. skb->sk = sk;
  321. skb->destructor = sctp_packet_release_owner;
  322. /*
  323. * The data chunks have already been accounted for in sctp_sendmsg(),
  324. * therefore only reserve a single byte to keep socket around until
  325. * the packet has been transmitted.
  326. */
  327. atomic_inc(&sk->sk_wmem_alloc);
  328. }
  329. /* All packets are sent to the network through this function from
  330. * sctp_outq_tail().
  331. *
  332. * The return value is a normal kernel error return value.
  333. */
  334. int sctp_packet_transmit(struct sctp_packet *packet)
  335. {
  336. struct sctp_transport *tp = packet->transport;
  337. struct sctp_association *asoc = tp->asoc;
  338. struct sctphdr *sh;
  339. struct sk_buff *nskb;
  340. struct sctp_chunk *chunk, *tmp;
  341. struct sock *sk;
  342. int err = 0;
  343. int padding; /* How much padding do we need? */
  344. __u8 has_data = 0;
  345. struct dst_entry *dst = tp->dst;
  346. unsigned char *auth = NULL; /* pointer to auth in skb data */
  347. __u32 cksum_buf_len = sizeof(struct sctphdr);
  348. SCTP_DEBUG_PRINTK("%s: packet:%p\n", __func__, packet);
  349. /* Do NOT generate a chunkless packet. */
  350. if (list_empty(&packet->chunk_list))
  351. return err;
  352. /* Set up convenience variables... */
  353. chunk = list_entry(packet->chunk_list.next, struct sctp_chunk, list);
  354. sk = chunk->skb->sk;
  355. /* Allocate the new skb. */
  356. nskb = alloc_skb(packet->size + LL_MAX_HEADER, GFP_ATOMIC);
  357. if (!nskb)
  358. goto nomem;
  359. /* Make sure the outbound skb has enough header room reserved. */
  360. skb_reserve(nskb, packet->overhead + LL_MAX_HEADER);
  361. /* Set the owning socket so that we know where to get the
  362. * destination IP address.
  363. */
  364. sctp_packet_set_owner_w(nskb, sk);
  365. if (!sctp_transport_dst_check(tp)) {
  366. sctp_transport_route(tp, NULL, sctp_sk(sk));
  367. if (asoc && (asoc->param_flags & SPP_PMTUD_ENABLE)) {
  368. sctp_assoc_sync_pmtu(sk, asoc);
  369. }
  370. }
  371. dst = dst_clone(tp->dst);
  372. skb_dst_set(nskb, dst);
  373. if (!dst)
  374. goto no_route;
  375. /* Build the SCTP header. */
  376. sh = (struct sctphdr *)skb_push(nskb, sizeof(struct sctphdr));
  377. skb_reset_transport_header(nskb);
  378. sh->source = htons(packet->source_port);
  379. sh->dest = htons(packet->destination_port);
  380. /* From 6.8 Adler-32 Checksum Calculation:
  381. * After the packet is constructed (containing the SCTP common
  382. * header and one or more control or DATA chunks), the
  383. * transmitter shall:
  384. *
  385. * 1) Fill in the proper Verification Tag in the SCTP common
  386. * header and initialize the checksum field to 0's.
  387. */
  388. sh->vtag = htonl(packet->vtag);
  389. sh->checksum = 0;
  390. /**
  391. * 6.10 Bundling
  392. *
  393. * An endpoint bundles chunks by simply including multiple
  394. * chunks in one outbound SCTP packet. ...
  395. */
  396. /**
  397. * 3.2 Chunk Field Descriptions
  398. *
  399. * The total length of a chunk (including Type, Length and
  400. * Value fields) MUST be a multiple of 4 bytes. If the length
  401. * of the chunk is not a multiple of 4 bytes, the sender MUST
  402. * pad the chunk with all zero bytes and this padding is not
  403. * included in the chunk length field. The sender should
  404. * never pad with more than 3 bytes.
  405. *
  406. * [This whole comment explains WORD_ROUND() below.]
  407. */
  408. SCTP_DEBUG_PRINTK("***sctp_transmit_packet***\n");
  409. list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
  410. list_del_init(&chunk->list);
  411. if (sctp_chunk_is_data(chunk)) {
  412. /* 6.3.1 C4) When data is in flight and when allowed
  413. * by rule C5, a new RTT measurement MUST be made each
  414. * round trip. Furthermore, new RTT measurements
  415. * SHOULD be made no more than once per round-trip
  416. * for a given destination transport address.
  417. */
  418. if (!tp->rto_pending) {
  419. chunk->rtt_in_progress = 1;
  420. tp->rto_pending = 1;
  421. }
  422. has_data = 1;
  423. }
  424. padding = WORD_ROUND(chunk->skb->len) - chunk->skb->len;
  425. if (padding)
  426. memset(skb_put(chunk->skb, padding), 0, padding);
  427. /* if this is the auth chunk that we are adding,
  428. * store pointer where it will be added and put
  429. * the auth into the packet.
  430. */
  431. if (chunk == packet->auth)
  432. auth = skb_tail_pointer(nskb);
  433. cksum_buf_len += chunk->skb->len;
  434. memcpy(skb_put(nskb, chunk->skb->len),
  435. chunk->skb->data, chunk->skb->len);
  436. SCTP_DEBUG_PRINTK("%s %p[%s] %s 0x%x, %s %d, %s %d, %s %d\n",
  437. "*** Chunk", chunk,
  438. sctp_cname(SCTP_ST_CHUNK(
  439. chunk->chunk_hdr->type)),
  440. chunk->has_tsn ? "TSN" : "No TSN",
  441. chunk->has_tsn ?
  442. ntohl(chunk->subh.data_hdr->tsn) : 0,
  443. "length", ntohs(chunk->chunk_hdr->length),
  444. "chunk->skb->len", chunk->skb->len,
  445. "rtt_in_progress", chunk->rtt_in_progress);
  446. /*
  447. * If this is a control chunk, this is our last
  448. * reference. Free data chunks after they've been
  449. * acknowledged or have failed.
  450. */
  451. if (!sctp_chunk_is_data(chunk))
  452. sctp_chunk_free(chunk);
  453. }
  454. /* SCTP-AUTH, Section 6.2
  455. * The sender MUST calculate the MAC as described in RFC2104 [2]
  456. * using the hash function H as described by the MAC Identifier and
  457. * the shared association key K based on the endpoint pair shared key
  458. * described by the shared key identifier. The 'data' used for the
  459. * computation of the AUTH-chunk is given by the AUTH chunk with its
  460. * HMAC field set to zero (as shown in Figure 6) followed by all
  461. * chunks that are placed after the AUTH chunk in the SCTP packet.
  462. */
  463. if (auth)
  464. sctp_auth_calculate_hmac(asoc, nskb,
  465. (struct sctp_auth_chunk *)auth,
  466. GFP_ATOMIC);
  467. /* 2) Calculate the Adler-32 checksum of the whole packet,
  468. * including the SCTP common header and all the
  469. * chunks.
  470. *
  471. * Note: Adler-32 is no longer applicable, as has been replaced
  472. * by CRC32-C as described in <draft-ietf-tsvwg-sctpcsum-02.txt>.
  473. */
  474. if (!sctp_checksum_disable) {
  475. if (!(dst->dev->features & NETIF_F_SCTP_CSUM)) {
  476. __u32 crc32 = sctp_start_cksum((__u8 *)sh, cksum_buf_len);
  477. /* 3) Put the resultant value into the checksum field in the
  478. * common header, and leave the rest of the bits unchanged.
  479. */
  480. sh->checksum = sctp_end_cksum(crc32);
  481. } else {
  482. /* no need to seed pseudo checksum for SCTP */
  483. nskb->ip_summed = CHECKSUM_PARTIAL;
  484. nskb->csum_start = (skb_transport_header(nskb) -
  485. nskb->head);
  486. nskb->csum_offset = offsetof(struct sctphdr, checksum);
  487. }
  488. }
  489. /* IP layer ECN support
  490. * From RFC 2481
  491. * "The ECN-Capable Transport (ECT) bit would be set by the
  492. * data sender to indicate that the end-points of the
  493. * transport protocol are ECN-capable."
  494. *
  495. * Now setting the ECT bit all the time, as it should not cause
  496. * any problems protocol-wise even if our peer ignores it.
  497. *
  498. * Note: The works for IPv6 layer checks this bit too later
  499. * in transmission. See IP6_ECN_flow_xmit().
  500. */
  501. (*tp->af_specific->ecn_capable)(nskb->sk);
  502. /* Set up the IP options. */
  503. /* BUG: not implemented
  504. * For v4 this all lives somewhere in sk->sk_opt...
  505. */
  506. /* Dump that on IP! */
  507. if (asoc) {
  508. asoc->stats.opackets++;
  509. if (asoc->peer.last_sent_to != tp)
  510. /* Considering the multiple CPU scenario, this is a
  511. * "correcter" place for last_sent_to. --xguo
  512. */
  513. asoc->peer.last_sent_to = tp;
  514. }
  515. if (has_data) {
  516. struct timer_list *timer;
  517. unsigned long timeout;
  518. /* Restart the AUTOCLOSE timer when sending data. */
  519. if (sctp_state(asoc, ESTABLISHED) && asoc->autoclose) {
  520. timer = &asoc->timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE];
  521. timeout = asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE];
  522. if (!mod_timer(timer, jiffies + timeout))
  523. sctp_association_hold(asoc);
  524. }
  525. }
  526. SCTP_DEBUG_PRINTK("***sctp_transmit_packet*** skb len %d\n",
  527. nskb->len);
  528. nskb->local_df = packet->ipfragok;
  529. (*tp->af_specific->sctp_xmit)(nskb, tp);
  530. out:
  531. sctp_packet_reset(packet);
  532. return err;
  533. no_route:
  534. kfree_skb(nskb);
  535. IP_INC_STATS_BH(sock_net(asoc->base.sk), IPSTATS_MIB_OUTNOROUTES);
  536. /* FIXME: Returning the 'err' will effect all the associations
  537. * associated with a socket, although only one of the paths of the
  538. * association is unreachable.
  539. * The real failure of a transport or association can be passed on
  540. * to the user via notifications. So setting this error may not be
  541. * required.
  542. */
  543. /* err = -EHOSTUNREACH; */
  544. err:
  545. /* Control chunks are unreliable so just drop them. DATA chunks
  546. * will get resent or dropped later.
  547. */
  548. list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
  549. list_del_init(&chunk->list);
  550. if (!sctp_chunk_is_data(chunk))
  551. sctp_chunk_free(chunk);
  552. }
  553. goto out;
  554. nomem:
  555. err = -ENOMEM;
  556. goto err;
  557. }
  558. /********************************************************************
  559. * 2nd Level Abstractions
  560. ********************************************************************/
  561. /* This private function check to see if a chunk can be added */
  562. static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet,
  563. struct sctp_chunk *chunk)
  564. {
  565. sctp_xmit_t retval = SCTP_XMIT_OK;
  566. size_t datasize, rwnd, inflight, flight_size;
  567. struct sctp_transport *transport = packet->transport;
  568. struct sctp_association *asoc = transport->asoc;
  569. struct sctp_outq *q = &asoc->outqueue;
  570. /* RFC 2960 6.1 Transmission of DATA Chunks
  571. *
  572. * A) At any given time, the data sender MUST NOT transmit new data to
  573. * any destination transport address if its peer's rwnd indicates
  574. * that the peer has no buffer space (i.e. rwnd is 0, see Section
  575. * 6.2.1). However, regardless of the value of rwnd (including if it
  576. * is 0), the data sender can always have one DATA chunk in flight to
  577. * the receiver if allowed by cwnd (see rule B below). This rule
  578. * allows the sender to probe for a change in rwnd that the sender
  579. * missed due to the SACK having been lost in transit from the data
  580. * receiver to the data sender.
  581. */
  582. rwnd = asoc->peer.rwnd;
  583. inflight = q->outstanding_bytes;
  584. flight_size = transport->flight_size;
  585. datasize = sctp_data_size(chunk);
  586. if (datasize > rwnd) {
  587. if (inflight > 0) {
  588. /* We have (at least) one data chunk in flight,
  589. * so we can't fall back to rule 6.1 B).
  590. */
  591. retval = SCTP_XMIT_RWND_FULL;
  592. goto finish;
  593. }
  594. }
  595. /* RFC 2960 6.1 Transmission of DATA Chunks
  596. *
  597. * B) At any given time, the sender MUST NOT transmit new data
  598. * to a given transport address if it has cwnd or more bytes
  599. * of data outstanding to that transport address.
  600. */
  601. /* RFC 7.2.4 & the Implementers Guide 2.8.
  602. *
  603. * 3) ...
  604. * When a Fast Retransmit is being performed the sender SHOULD
  605. * ignore the value of cwnd and SHOULD NOT delay retransmission.
  606. */
  607. if (chunk->fast_retransmit != SCTP_NEED_FRTX)
  608. if (flight_size >= transport->cwnd) {
  609. retval = SCTP_XMIT_RWND_FULL;
  610. goto finish;
  611. }
  612. /* Nagle's algorithm to solve small-packet problem:
  613. * Inhibit the sending of new chunks when new outgoing data arrives
  614. * if any previously transmitted data on the connection remains
  615. * unacknowledged.
  616. */
  617. if (!sctp_sk(asoc->base.sk)->nodelay && sctp_packet_empty(packet) &&
  618. inflight && sctp_state(asoc, ESTABLISHED)) {
  619. unsigned int max = transport->pathmtu - packet->overhead;
  620. unsigned int len = chunk->skb->len + q->out_qlen;
  621. /* Check whether this chunk and all the rest of pending
  622. * data will fit or delay in hopes of bundling a full
  623. * sized packet.
  624. * Don't delay large message writes that may have been
  625. * fragmeneted into small peices.
  626. */
  627. if ((len < max) && chunk->msg->can_delay) {
  628. retval = SCTP_XMIT_NAGLE_DELAY;
  629. goto finish;
  630. }
  631. }
  632. finish:
  633. return retval;
  634. }
  635. /* This private function does management things when adding DATA chunk */
  636. static void sctp_packet_append_data(struct sctp_packet *packet,
  637. struct sctp_chunk *chunk)
  638. {
  639. struct sctp_transport *transport = packet->transport;
  640. size_t datasize = sctp_data_size(chunk);
  641. struct sctp_association *asoc = transport->asoc;
  642. u32 rwnd = asoc->peer.rwnd;
  643. /* Keep track of how many bytes are in flight over this transport. */
  644. transport->flight_size += datasize;
  645. /* Keep track of how many bytes are in flight to the receiver. */
  646. asoc->outqueue.outstanding_bytes += datasize;
  647. /* Update our view of the receiver's rwnd. */
  648. if (datasize < rwnd)
  649. rwnd -= datasize;
  650. else
  651. rwnd = 0;
  652. asoc->peer.rwnd = rwnd;
  653. /* Has been accepted for transmission. */
  654. if (!asoc->peer.prsctp_capable)
  655. chunk->msg->can_abandon = 0;
  656. sctp_chunk_assign_tsn(chunk);
  657. sctp_chunk_assign_ssn(chunk);
  658. }
  659. static sctp_xmit_t sctp_packet_will_fit(struct sctp_packet *packet,
  660. struct sctp_chunk *chunk,
  661. u16 chunk_len)
  662. {
  663. size_t psize;
  664. size_t pmtu;
  665. int too_big;
  666. sctp_xmit_t retval = SCTP_XMIT_OK;
  667. psize = packet->size;
  668. pmtu = ((packet->transport->asoc) ?
  669. (packet->transport->asoc->pathmtu) :
  670. (packet->transport->pathmtu));
  671. too_big = (psize + chunk_len > pmtu);
  672. /* Decide if we need to fragment or resubmit later. */
  673. if (too_big) {
  674. /* It's OK to fragmet at IP level if any one of the following
  675. * is true:
  676. * 1. The packet is empty (meaning this chunk is greater
  677. * the MTU)
  678. * 2. The chunk we are adding is a control chunk
  679. * 3. The packet doesn't have any data in it yet and data
  680. * requires authentication.
  681. */
  682. if (sctp_packet_empty(packet) || !sctp_chunk_is_data(chunk) ||
  683. (!packet->has_data && chunk->auth)) {
  684. /* We no longer do re-fragmentation.
  685. * Just fragment at the IP layer, if we
  686. * actually hit this condition
  687. */
  688. packet->ipfragok = 1;
  689. } else {
  690. retval = SCTP_XMIT_PMTU_FULL;
  691. }
  692. }
  693. return retval;
  694. }