associola.c 38 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369
  1. /* SCTP kernel reference Implementation
  2. * (C) Copyright IBM Corp. 2001, 2004
  3. * Copyright (c) 1999-2000 Cisco, Inc.
  4. * Copyright (c) 1999-2001 Motorola, Inc.
  5. * Copyright (c) 2001 Intel Corp.
  6. * Copyright (c) 2001 La Monte H.P. Yarroll
  7. *
  8. * This file is part of the SCTP kernel reference Implementation
  9. *
  10. * This module provides the abstraction for an SCTP association.
  11. *
  12. * The SCTP reference implementation is free software;
  13. * you can redistribute it and/or modify it under the terms of
  14. * the GNU General Public License as published by
  15. * the Free Software Foundation; either version 2, or (at your option)
  16. * any later version.
  17. *
  18. * The SCTP reference implementation is distributed in the hope that it
  19. * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  20. * ************************
  21. * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  22. * See the GNU General Public License for more details.
  23. *
  24. * You should have received a copy of the GNU General Public License
  25. * along with GNU CC; see the file COPYING. If not, write to
  26. * the Free Software Foundation, 59 Temple Place - Suite 330,
  27. * Boston, MA 02111-1307, USA.
  28. *
  29. * Please send any bug reports or fixes you make to the
  30. * email address(es):
  31. * lksctp developers <lksctp-developers@lists.sourceforge.net>
  32. *
  33. * Or submit a bug report through the following website:
  34. * http://www.sf.net/projects/lksctp
  35. *
  36. * Written or modified by:
  37. * La Monte H.P. Yarroll <piggy@acm.org>
  38. * Karl Knutson <karl@athena.chicago.il.us>
  39. * Jon Grimm <jgrimm@us.ibm.com>
  40. * Xingang Guo <xingang.guo@intel.com>
  41. * Hui Huang <hui.huang@nokia.com>
  42. * Sridhar Samudrala <sri@us.ibm.com>
  43. * Daisy Chang <daisyc@us.ibm.com>
  44. * Ryan Layer <rmlayer@us.ibm.com>
  45. * Kevin Gao <kevin.gao@intel.com>
  46. *
  47. * Any bugs reported given to us we will try to fix... any fixes shared will
  48. * be incorporated into the next SCTP release.
  49. */
  50. #include <linux/types.h>
  51. #include <linux/fcntl.h>
  52. #include <linux/poll.h>
  53. #include <linux/init.h>
  54. #include <linux/slab.h>
  55. #include <linux/in.h>
  56. #include <net/ipv6.h>
  57. #include <net/sctp/sctp.h>
  58. #include <net/sctp/sm.h>
  59. /* Forward declarations for internal functions. */
  60. static void sctp_assoc_bh_rcv(struct work_struct *work);
  61. /* 1st Level Abstractions. */
  62. /* Initialize a new association from provided memory. */
  63. static struct sctp_association *sctp_association_init(struct sctp_association *asoc,
  64. const struct sctp_endpoint *ep,
  65. const struct sock *sk,
  66. sctp_scope_t scope,
  67. gfp_t gfp)
  68. {
  69. struct sctp_sock *sp;
  70. int i;
  71. /* Retrieve the SCTP per socket area. */
  72. sp = sctp_sk((struct sock *)sk);
  73. /* Init all variables to a known value. */
  74. memset(asoc, 0, sizeof(struct sctp_association));
  75. /* Discarding const is appropriate here. */
  76. asoc->ep = (struct sctp_endpoint *)ep;
  77. sctp_endpoint_hold(asoc->ep);
  78. /* Hold the sock. */
  79. asoc->base.sk = (struct sock *)sk;
  80. sock_hold(asoc->base.sk);
  81. /* Initialize the common base substructure. */
  82. asoc->base.type = SCTP_EP_TYPE_ASSOCIATION;
  83. /* Initialize the object handling fields. */
  84. atomic_set(&asoc->base.refcnt, 1);
  85. asoc->base.dead = 0;
  86. asoc->base.malloced = 0;
  87. /* Initialize the bind addr area. */
  88. sctp_bind_addr_init(&asoc->base.bind_addr, ep->base.bind_addr.port);
  89. rwlock_init(&asoc->base.addr_lock);
  90. asoc->state = SCTP_STATE_CLOSED;
  91. /* Set these values from the socket values, a conversion between
  92. * millsecons to seconds/microseconds must also be done.
  93. */
  94. asoc->cookie_life.tv_sec = sp->assocparams.sasoc_cookie_life / 1000;
  95. asoc->cookie_life.tv_usec = (sp->assocparams.sasoc_cookie_life % 1000)
  96. * 1000;
  97. asoc->frag_point = 0;
  98. /* Set the association max_retrans and RTO values from the
  99. * socket values.
  100. */
  101. asoc->max_retrans = sp->assocparams.sasoc_asocmaxrxt;
  102. asoc->rto_initial = msecs_to_jiffies(sp->rtoinfo.srto_initial);
  103. asoc->rto_max = msecs_to_jiffies(sp->rtoinfo.srto_max);
  104. asoc->rto_min = msecs_to_jiffies(sp->rtoinfo.srto_min);
  105. asoc->overall_error_count = 0;
  106. /* Initialize the association's heartbeat interval based on the
  107. * sock configured value.
  108. */
  109. asoc->hbinterval = msecs_to_jiffies(sp->hbinterval);
  110. /* Initialize path max retrans value. */
  111. asoc->pathmaxrxt = sp->pathmaxrxt;
  112. /* Initialize default path MTU. */
  113. asoc->pathmtu = sp->pathmtu;
  114. /* Set association default SACK delay */
  115. asoc->sackdelay = msecs_to_jiffies(sp->sackdelay);
  116. /* Set the association default flags controlling
  117. * Heartbeat, SACK delay, and Path MTU Discovery.
  118. */
  119. asoc->param_flags = sp->param_flags;
  120. /* Initialize the maximum mumber of new data packets that can be sent
  121. * in a burst.
  122. */
  123. asoc->max_burst = sctp_max_burst;
  124. /* initialize association timers */
  125. asoc->timeouts[SCTP_EVENT_TIMEOUT_NONE] = 0;
  126. asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] = asoc->rto_initial;
  127. asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] = asoc->rto_initial;
  128. asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = asoc->rto_initial;
  129. asoc->timeouts[SCTP_EVENT_TIMEOUT_T3_RTX] = 0;
  130. asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = 0;
  131. /* sctpimpguide Section 2.12.2
  132. * If the 'T5-shutdown-guard' timer is used, it SHOULD be set to the
  133. * recommended value of 5 times 'RTO.Max'.
  134. */
  135. asoc->timeouts[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]
  136. = 5 * asoc->rto_max;
  137. asoc->timeouts[SCTP_EVENT_TIMEOUT_HEARTBEAT] = 0;
  138. asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = asoc->sackdelay;
  139. asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] =
  140. sp->autoclose * HZ;
  141. /* Initilizes the timers */
  142. for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {
  143. init_timer(&asoc->timers[i]);
  144. asoc->timers[i].function = sctp_timer_events[i];
  145. asoc->timers[i].data = (unsigned long) asoc;
  146. }
  147. /* Pull default initialization values from the sock options.
  148. * Note: This assumes that the values have already been
  149. * validated in the sock.
  150. */
  151. asoc->c.sinit_max_instreams = sp->initmsg.sinit_max_instreams;
  152. asoc->c.sinit_num_ostreams = sp->initmsg.sinit_num_ostreams;
  153. asoc->max_init_attempts = sp->initmsg.sinit_max_attempts;
  154. asoc->max_init_timeo =
  155. msecs_to_jiffies(sp->initmsg.sinit_max_init_timeo);
  156. /* Allocate storage for the ssnmap after the inbound and outbound
  157. * streams have been negotiated during Init.
  158. */
  159. asoc->ssnmap = NULL;
  160. /* Set the local window size for receive.
  161. * This is also the rcvbuf space per association.
  162. * RFC 6 - A SCTP receiver MUST be able to receive a minimum of
  163. * 1500 bytes in one SCTP packet.
  164. */
  165. if ((sk->sk_rcvbuf/2) < SCTP_DEFAULT_MINWINDOW)
  166. asoc->rwnd = SCTP_DEFAULT_MINWINDOW;
  167. else
  168. asoc->rwnd = sk->sk_rcvbuf/2;
  169. asoc->a_rwnd = asoc->rwnd;
  170. asoc->rwnd_over = 0;
  171. /* Use my own max window until I learn something better. */
  172. asoc->peer.rwnd = SCTP_DEFAULT_MAXWINDOW;
  173. /* Set the sndbuf size for transmit. */
  174. asoc->sndbuf_used = 0;
  175. /* Initialize the receive memory counter */
  176. atomic_set(&asoc->rmem_alloc, 0);
  177. init_waitqueue_head(&asoc->wait);
  178. asoc->c.my_vtag = sctp_generate_tag(ep);
  179. asoc->peer.i.init_tag = 0; /* INIT needs a vtag of 0. */
  180. asoc->c.peer_vtag = 0;
  181. asoc->c.my_ttag = 0;
  182. asoc->c.peer_ttag = 0;
  183. asoc->c.my_port = ep->base.bind_addr.port;
  184. asoc->c.initial_tsn = sctp_generate_tsn(ep);
  185. asoc->next_tsn = asoc->c.initial_tsn;
  186. asoc->ctsn_ack_point = asoc->next_tsn - 1;
  187. asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
  188. asoc->highest_sacked = asoc->ctsn_ack_point;
  189. asoc->last_cwr_tsn = asoc->ctsn_ack_point;
  190. asoc->unack_data = 0;
  191. /* ADDIP Section 4.1 Asconf Chunk Procedures
  192. *
  193. * When an endpoint has an ASCONF signaled change to be sent to the
  194. * remote endpoint it should do the following:
  195. * ...
  196. * A2) a serial number should be assigned to the chunk. The serial
  197. * number SHOULD be a monotonically increasing number. The serial
  198. * numbers SHOULD be initialized at the start of the
  199. * association to the same value as the initial TSN.
  200. */
  201. asoc->addip_serial = asoc->c.initial_tsn;
  202. INIT_LIST_HEAD(&asoc->addip_chunk_list);
  203. /* Make an empty list of remote transport addresses. */
  204. INIT_LIST_HEAD(&asoc->peer.transport_addr_list);
  205. asoc->peer.transport_count = 0;
  206. /* RFC 2960 5.1 Normal Establishment of an Association
  207. *
  208. * After the reception of the first data chunk in an
  209. * association the endpoint must immediately respond with a
  210. * sack to acknowledge the data chunk. Subsequent
  211. * acknowledgements should be done as described in Section
  212. * 6.2.
  213. *
  214. * [We implement this by telling a new association that it
  215. * already received one packet.]
  216. */
  217. asoc->peer.sack_needed = 1;
  218. /* Assume that the peer recongizes ASCONF until reported otherwise
  219. * via an ERROR chunk.
  220. */
  221. asoc->peer.asconf_capable = 1;
  222. /* Create an input queue. */
  223. sctp_inq_init(&asoc->base.inqueue);
  224. sctp_inq_set_th_handler(&asoc->base.inqueue, sctp_assoc_bh_rcv);
  225. /* Create an output queue. */
  226. sctp_outq_init(asoc, &asoc->outqueue);
  227. if (!sctp_ulpq_init(&asoc->ulpq, asoc))
  228. goto fail_init;
  229. /* Set up the tsn tracking. */
  230. sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_SIZE, 0);
  231. asoc->need_ecne = 0;
  232. asoc->assoc_id = 0;
  233. /* Assume that peer would support both address types unless we are
  234. * told otherwise.
  235. */
  236. asoc->peer.ipv4_address = 1;
  237. asoc->peer.ipv6_address = 1;
  238. INIT_LIST_HEAD(&asoc->asocs);
  239. asoc->autoclose = sp->autoclose;
  240. asoc->default_stream = sp->default_stream;
  241. asoc->default_ppid = sp->default_ppid;
  242. asoc->default_flags = sp->default_flags;
  243. asoc->default_context = sp->default_context;
  244. asoc->default_timetolive = sp->default_timetolive;
  245. asoc->default_rcv_context = sp->default_rcv_context;
  246. return asoc;
  247. fail_init:
  248. sctp_endpoint_put(asoc->ep);
  249. sock_put(asoc->base.sk);
  250. return NULL;
  251. }
  252. /* Allocate and initialize a new association */
  253. struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep,
  254. const struct sock *sk,
  255. sctp_scope_t scope,
  256. gfp_t gfp)
  257. {
  258. struct sctp_association *asoc;
  259. asoc = t_new(struct sctp_association, gfp);
  260. if (!asoc)
  261. goto fail;
  262. if (!sctp_association_init(asoc, ep, sk, scope, gfp))
  263. goto fail_init;
  264. asoc->base.malloced = 1;
  265. SCTP_DBG_OBJCNT_INC(assoc);
  266. SCTP_DEBUG_PRINTK("Created asoc %p\n", asoc);
  267. return asoc;
  268. fail_init:
  269. kfree(asoc);
  270. fail:
  271. return NULL;
  272. }
  273. /* Free this association if possible. There may still be users, so
  274. * the actual deallocation may be delayed.
  275. */
  276. void sctp_association_free(struct sctp_association *asoc)
  277. {
  278. struct sock *sk = asoc->base.sk;
  279. struct sctp_transport *transport;
  280. struct list_head *pos, *temp;
  281. int i;
  282. /* Only real associations count against the endpoint, so
  283. * don't bother for if this is a temporary association.
  284. */
  285. if (!asoc->temp) {
  286. list_del(&asoc->asocs);
  287. /* Decrement the backlog value for a TCP-style listening
  288. * socket.
  289. */
  290. if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
  291. sk->sk_ack_backlog--;
  292. }
  293. /* Mark as dead, so other users can know this structure is
  294. * going away.
  295. */
  296. asoc->base.dead = 1;
  297. /* Dispose of any data lying around in the outqueue. */
  298. sctp_outq_free(&asoc->outqueue);
  299. /* Dispose of any pending messages for the upper layer. */
  300. sctp_ulpq_free(&asoc->ulpq);
  301. /* Dispose of any pending chunks on the inqueue. */
  302. sctp_inq_free(&asoc->base.inqueue);
  303. /* Free ssnmap storage. */
  304. sctp_ssnmap_free(asoc->ssnmap);
  305. /* Clean up the bound address list. */
  306. sctp_bind_addr_free(&asoc->base.bind_addr);
  307. /* Do we need to go through all of our timers and
  308. * delete them? To be safe we will try to delete all, but we
  309. * should be able to go through and make a guess based
  310. * on our state.
  311. */
  312. for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {
  313. if (timer_pending(&asoc->timers[i]) &&
  314. del_timer(&asoc->timers[i]))
  315. sctp_association_put(asoc);
  316. }
  317. /* Free peer's cached cookie. */
  318. kfree(asoc->peer.cookie);
  319. /* Release the transport structures. */
  320. list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
  321. transport = list_entry(pos, struct sctp_transport, transports);
  322. list_del(pos);
  323. sctp_transport_free(transport);
  324. }
  325. asoc->peer.transport_count = 0;
  326. /* Free any cached ASCONF_ACK chunk. */
  327. if (asoc->addip_last_asconf_ack)
  328. sctp_chunk_free(asoc->addip_last_asconf_ack);
  329. /* Free any cached ASCONF chunk. */
  330. if (asoc->addip_last_asconf)
  331. sctp_chunk_free(asoc->addip_last_asconf);
  332. sctp_association_put(asoc);
  333. }
  334. /* Cleanup and free up an association. */
  335. static void sctp_association_destroy(struct sctp_association *asoc)
  336. {
  337. SCTP_ASSERT(asoc->base.dead, "Assoc is not dead", return);
  338. sctp_endpoint_put(asoc->ep);
  339. sock_put(asoc->base.sk);
  340. if (asoc->assoc_id != 0) {
  341. spin_lock_bh(&sctp_assocs_id_lock);
  342. idr_remove(&sctp_assocs_id, asoc->assoc_id);
  343. spin_unlock_bh(&sctp_assocs_id_lock);
  344. }
  345. BUG_TRAP(!atomic_read(&asoc->rmem_alloc));
  346. if (asoc->base.malloced) {
  347. kfree(asoc);
  348. SCTP_DBG_OBJCNT_DEC(assoc);
  349. }
  350. }
  351. /* Change the primary destination address for the peer. */
  352. void sctp_assoc_set_primary(struct sctp_association *asoc,
  353. struct sctp_transport *transport)
  354. {
  355. asoc->peer.primary_path = transport;
  356. /* Set a default msg_name for events. */
  357. memcpy(&asoc->peer.primary_addr, &transport->ipaddr,
  358. sizeof(union sctp_addr));
  359. /* If the primary path is changing, assume that the
  360. * user wants to use this new path.
  361. */
  362. if ((transport->state == SCTP_ACTIVE) ||
  363. (transport->state == SCTP_UNKNOWN))
  364. asoc->peer.active_path = transport;
  365. /*
  366. * SFR-CACC algorithm:
  367. * Upon the receipt of a request to change the primary
  368. * destination address, on the data structure for the new
  369. * primary destination, the sender MUST do the following:
  370. *
  371. * 1) If CHANGEOVER_ACTIVE is set, then there was a switch
  372. * to this destination address earlier. The sender MUST set
  373. * CYCLING_CHANGEOVER to indicate that this switch is a
  374. * double switch to the same destination address.
  375. */
  376. if (transport->cacc.changeover_active)
  377. transport->cacc.cycling_changeover = 1;
  378. /* 2) The sender MUST set CHANGEOVER_ACTIVE to indicate that
  379. * a changeover has occurred.
  380. */
  381. transport->cacc.changeover_active = 1;
  382. /* 3) The sender MUST store the next TSN to be sent in
  383. * next_tsn_at_change.
  384. */
  385. transport->cacc.next_tsn_at_change = asoc->next_tsn;
  386. }
  387. /* Remove a transport from an association. */
  388. void sctp_assoc_rm_peer(struct sctp_association *asoc,
  389. struct sctp_transport *peer)
  390. {
  391. struct list_head *pos;
  392. struct sctp_transport *transport;
  393. SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_rm_peer:association %p addr: ",
  394. " port: %d\n",
  395. asoc,
  396. (&peer->ipaddr),
  397. ntohs(peer->ipaddr.v4.sin_port));
  398. /* If we are to remove the current retran_path, update it
  399. * to the next peer before removing this peer from the list.
  400. */
  401. if (asoc->peer.retran_path == peer)
  402. sctp_assoc_update_retran_path(asoc);
  403. /* Remove this peer from the list. */
  404. list_del(&peer->transports);
  405. /* Get the first transport of asoc. */
  406. pos = asoc->peer.transport_addr_list.next;
  407. transport = list_entry(pos, struct sctp_transport, transports);
  408. /* Update any entries that match the peer to be deleted. */
  409. if (asoc->peer.primary_path == peer)
  410. sctp_assoc_set_primary(asoc, transport);
  411. if (asoc->peer.active_path == peer)
  412. asoc->peer.active_path = transport;
  413. if (asoc->peer.last_data_from == peer)
  414. asoc->peer.last_data_from = transport;
  415. /* If we remove the transport an INIT was last sent to, set it to
  416. * NULL. Combined with the update of the retran path above, this
  417. * will cause the next INIT to be sent to the next available
  418. * transport, maintaining the cycle.
  419. */
  420. if (asoc->init_last_sent_to == peer)
  421. asoc->init_last_sent_to = NULL;
  422. asoc->peer.transport_count--;
  423. sctp_transport_free(peer);
  424. }
  425. /* Add a transport address to an association. */
  426. struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc,
  427. const union sctp_addr *addr,
  428. const gfp_t gfp,
  429. const int peer_state)
  430. {
  431. struct sctp_transport *peer;
  432. struct sctp_sock *sp;
  433. unsigned short port;
  434. sp = sctp_sk(asoc->base.sk);
  435. /* AF_INET and AF_INET6 share common port field. */
  436. port = ntohs(addr->v4.sin_port);
  437. SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_add_peer:association %p addr: ",
  438. " port: %d state:%d\n",
  439. asoc,
  440. addr,
  441. port,
  442. peer_state);
  443. /* Set the port if it has not been set yet. */
  444. if (0 == asoc->peer.port)
  445. asoc->peer.port = port;
  446. /* Check to see if this is a duplicate. */
  447. peer = sctp_assoc_lookup_paddr(asoc, addr);
  448. if (peer) {
  449. if (peer->state == SCTP_UNKNOWN) {
  450. if (peer_state == SCTP_ACTIVE)
  451. peer->state = SCTP_ACTIVE;
  452. if (peer_state == SCTP_UNCONFIRMED)
  453. peer->state = SCTP_UNCONFIRMED;
  454. }
  455. return peer;
  456. }
  457. peer = sctp_transport_new(addr, gfp);
  458. if (!peer)
  459. return NULL;
  460. sctp_transport_set_owner(peer, asoc);
  461. /* Initialize the peer's heartbeat interval based on the
  462. * association configured value.
  463. */
  464. peer->hbinterval = asoc->hbinterval;
  465. /* Set the path max_retrans. */
  466. peer->pathmaxrxt = asoc->pathmaxrxt;
  467. /* Initialize the peer's SACK delay timeout based on the
  468. * association configured value.
  469. */
  470. peer->sackdelay = asoc->sackdelay;
  471. /* Enable/disable heartbeat, SACK delay, and path MTU discovery
  472. * based on association setting.
  473. */
  474. peer->param_flags = asoc->param_flags;
  475. /* Initialize the pmtu of the transport. */
  476. if (peer->param_flags & SPP_PMTUD_ENABLE)
  477. sctp_transport_pmtu(peer);
  478. else if (asoc->pathmtu)
  479. peer->pathmtu = asoc->pathmtu;
  480. else
  481. peer->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
  482. /* If this is the first transport addr on this association,
  483. * initialize the association PMTU to the peer's PMTU.
  484. * If not and the current association PMTU is higher than the new
  485. * peer's PMTU, reset the association PMTU to the new peer's PMTU.
  486. */
  487. if (asoc->pathmtu)
  488. asoc->pathmtu = min_t(int, peer->pathmtu, asoc->pathmtu);
  489. else
  490. asoc->pathmtu = peer->pathmtu;
  491. SCTP_DEBUG_PRINTK("sctp_assoc_add_peer:association %p PMTU set to "
  492. "%d\n", asoc, asoc->pathmtu);
  493. asoc->frag_point = sctp_frag_point(sp, asoc->pathmtu);
  494. /* The asoc->peer.port might not be meaningful yet, but
  495. * initialize the packet structure anyway.
  496. */
  497. sctp_packet_init(&peer->packet, peer, asoc->base.bind_addr.port,
  498. asoc->peer.port);
  499. /* 7.2.1 Slow-Start
  500. *
  501. * o The initial cwnd before DATA transmission or after a sufficiently
  502. * long idle period MUST be set to
  503. * min(4*MTU, max(2*MTU, 4380 bytes))
  504. *
  505. * o The initial value of ssthresh MAY be arbitrarily high
  506. * (for example, implementations MAY use the size of the
  507. * receiver advertised window).
  508. */
  509. peer->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380));
  510. /* At this point, we may not have the receiver's advertised window,
  511. * so initialize ssthresh to the default value and it will be set
  512. * later when we process the INIT.
  513. */
  514. peer->ssthresh = SCTP_DEFAULT_MAXWINDOW;
  515. peer->partial_bytes_acked = 0;
  516. peer->flight_size = 0;
  517. /* Set the transport's RTO.initial value */
  518. peer->rto = asoc->rto_initial;
  519. /* Set the peer's active state. */
  520. peer->state = peer_state;
  521. /* Attach the remote transport to our asoc. */
  522. list_add_tail(&peer->transports, &asoc->peer.transport_addr_list);
  523. asoc->peer.transport_count++;
  524. /* If we do not yet have a primary path, set one. */
  525. if (!asoc->peer.primary_path) {
  526. sctp_assoc_set_primary(asoc, peer);
  527. asoc->peer.retran_path = peer;
  528. }
  529. if (asoc->peer.active_path == asoc->peer.retran_path) {
  530. asoc->peer.retran_path = peer;
  531. }
  532. return peer;
  533. }
  534. /* Delete a transport address from an association. */
  535. void sctp_assoc_del_peer(struct sctp_association *asoc,
  536. const union sctp_addr *addr)
  537. {
  538. struct list_head *pos;
  539. struct list_head *temp;
  540. struct sctp_transport *transport;
  541. list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
  542. transport = list_entry(pos, struct sctp_transport, transports);
  543. if (sctp_cmp_addr_exact(addr, &transport->ipaddr)) {
  544. /* Do book keeping for removing the peer and free it. */
  545. sctp_assoc_rm_peer(asoc, transport);
  546. break;
  547. }
  548. }
  549. }
  550. /* Lookup a transport by address. */
  551. struct sctp_transport *sctp_assoc_lookup_paddr(
  552. const struct sctp_association *asoc,
  553. const union sctp_addr *address)
  554. {
  555. struct sctp_transport *t;
  556. struct list_head *pos;
  557. /* Cycle through all transports searching for a peer address. */
  558. list_for_each(pos, &asoc->peer.transport_addr_list) {
  559. t = list_entry(pos, struct sctp_transport, transports);
  560. if (sctp_cmp_addr_exact(address, &t->ipaddr))
  561. return t;
  562. }
  563. return NULL;
  564. }
  565. /* Engage in transport control operations.
  566. * Mark the transport up or down and send a notification to the user.
  567. * Select and update the new active and retran paths.
  568. */
  569. void sctp_assoc_control_transport(struct sctp_association *asoc,
  570. struct sctp_transport *transport,
  571. sctp_transport_cmd_t command,
  572. sctp_sn_error_t error)
  573. {
  574. struct sctp_transport *t = NULL;
  575. struct sctp_transport *first;
  576. struct sctp_transport *second;
  577. struct sctp_ulpevent *event;
  578. struct sockaddr_storage addr;
  579. struct list_head *pos;
  580. int spc_state = 0;
  581. /* Record the transition on the transport. */
  582. switch (command) {
  583. case SCTP_TRANSPORT_UP:
  584. transport->state = SCTP_ACTIVE;
  585. spc_state = SCTP_ADDR_AVAILABLE;
  586. break;
  587. case SCTP_TRANSPORT_DOWN:
  588. transport->state = SCTP_INACTIVE;
  589. spc_state = SCTP_ADDR_UNREACHABLE;
  590. break;
  591. default:
  592. return;
  593. };
  594. /* Generate and send a SCTP_PEER_ADDR_CHANGE notification to the
  595. * user.
  596. */
  597. memset(&addr, 0, sizeof(struct sockaddr_storage));
  598. memcpy(&addr, &transport->ipaddr, transport->af_specific->sockaddr_len);
  599. event = sctp_ulpevent_make_peer_addr_change(asoc, &addr,
  600. 0, spc_state, error, GFP_ATOMIC);
  601. if (event)
  602. sctp_ulpq_tail_event(&asoc->ulpq, event);
  603. /* Select new active and retran paths. */
  604. /* Look for the two most recently used active transports.
  605. *
  606. * This code produces the wrong ordering whenever jiffies
  607. * rolls over, but we still get usable transports, so we don't
  608. * worry about it.
  609. */
  610. first = NULL; second = NULL;
  611. list_for_each(pos, &asoc->peer.transport_addr_list) {
  612. t = list_entry(pos, struct sctp_transport, transports);
  613. if ((t->state == SCTP_INACTIVE) ||
  614. (t->state == SCTP_UNCONFIRMED))
  615. continue;
  616. if (!first || t->last_time_heard > first->last_time_heard) {
  617. second = first;
  618. first = t;
  619. }
  620. if (!second || t->last_time_heard > second->last_time_heard)
  621. second = t;
  622. }
  623. /* RFC 2960 6.4 Multi-Homed SCTP Endpoints
  624. *
  625. * By default, an endpoint should always transmit to the
  626. * primary path, unless the SCTP user explicitly specifies the
  627. * destination transport address (and possibly source
  628. * transport address) to use.
  629. *
  630. * [If the primary is active but not most recent, bump the most
  631. * recently used transport.]
  632. */
  633. if (((asoc->peer.primary_path->state == SCTP_ACTIVE) ||
  634. (asoc->peer.primary_path->state == SCTP_UNKNOWN)) &&
  635. first != asoc->peer.primary_path) {
  636. second = first;
  637. first = asoc->peer.primary_path;
  638. }
  639. /* If we failed to find a usable transport, just camp on the
  640. * primary, even if it is inactive.
  641. */
  642. if (!first) {
  643. first = asoc->peer.primary_path;
  644. second = asoc->peer.primary_path;
  645. }
  646. /* Set the active and retran transports. */
  647. asoc->peer.active_path = first;
  648. asoc->peer.retran_path = second;
  649. }
  650. /* Hold a reference to an association. */
  651. void sctp_association_hold(struct sctp_association *asoc)
  652. {
  653. atomic_inc(&asoc->base.refcnt);
  654. }
  655. /* Release a reference to an association and cleanup
  656. * if there are no more references.
  657. */
  658. void sctp_association_put(struct sctp_association *asoc)
  659. {
  660. if (atomic_dec_and_test(&asoc->base.refcnt))
  661. sctp_association_destroy(asoc);
  662. }
  663. /* Allocate the next TSN, Transmission Sequence Number, for the given
  664. * association.
  665. */
  666. __u32 sctp_association_get_next_tsn(struct sctp_association *asoc)
  667. {
  668. /* From Section 1.6 Serial Number Arithmetic:
  669. * Transmission Sequence Numbers wrap around when they reach
  670. * 2**32 - 1. That is, the next TSN a DATA chunk MUST use
  671. * after transmitting TSN = 2*32 - 1 is TSN = 0.
  672. */
  673. __u32 retval = asoc->next_tsn;
  674. asoc->next_tsn++;
  675. asoc->unack_data++;
  676. return retval;
  677. }
  678. /* Compare two addresses to see if they match. Wildcard addresses
  679. * only match themselves.
  680. */
  681. int sctp_cmp_addr_exact(const union sctp_addr *ss1,
  682. const union sctp_addr *ss2)
  683. {
  684. struct sctp_af *af;
  685. af = sctp_get_af_specific(ss1->sa.sa_family);
  686. if (unlikely(!af))
  687. return 0;
  688. return af->cmp_addr(ss1, ss2);
  689. }
  690. /* Return an ecne chunk to get prepended to a packet.
  691. * Note: We are sly and return a shared, prealloced chunk. FIXME:
  692. * No we don't, but we could/should.
  693. */
  694. struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc)
  695. {
  696. struct sctp_chunk *chunk;
  697. /* Send ECNE if needed.
  698. * Not being able to allocate a chunk here is not deadly.
  699. */
  700. if (asoc->need_ecne)
  701. chunk = sctp_make_ecne(asoc, asoc->last_ecne_tsn);
  702. else
  703. chunk = NULL;
  704. return chunk;
  705. }
  706. /*
  707. * Find which transport this TSN was sent on.
  708. */
  709. struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *asoc,
  710. __u32 tsn)
  711. {
  712. struct sctp_transport *active;
  713. struct sctp_transport *match;
  714. struct list_head *entry, *pos;
  715. struct sctp_transport *transport;
  716. struct sctp_chunk *chunk;
  717. __be32 key = htonl(tsn);
  718. match = NULL;
  719. /*
  720. * FIXME: In general, find a more efficient data structure for
  721. * searching.
  722. */
  723. /*
  724. * The general strategy is to search each transport's transmitted
  725. * list. Return which transport this TSN lives on.
  726. *
  727. * Let's be hopeful and check the active_path first.
  728. * Another optimization would be to know if there is only one
  729. * outbound path and not have to look for the TSN at all.
  730. *
  731. */
  732. active = asoc->peer.active_path;
  733. list_for_each(entry, &active->transmitted) {
  734. chunk = list_entry(entry, struct sctp_chunk, transmitted_list);
  735. if (key == chunk->subh.data_hdr->tsn) {
  736. match = active;
  737. goto out;
  738. }
  739. }
  740. /* If not found, go search all the other transports. */
  741. list_for_each(pos, &asoc->peer.transport_addr_list) {
  742. transport = list_entry(pos, struct sctp_transport, transports);
  743. if (transport == active)
  744. break;
  745. list_for_each(entry, &transport->transmitted) {
  746. chunk = list_entry(entry, struct sctp_chunk,
  747. transmitted_list);
  748. if (key == chunk->subh.data_hdr->tsn) {
  749. match = transport;
  750. goto out;
  751. }
  752. }
  753. }
  754. out:
  755. return match;
  756. }
  757. /* Is this the association we are looking for? */
  758. struct sctp_transport *sctp_assoc_is_match(struct sctp_association *asoc,
  759. const union sctp_addr *laddr,
  760. const union sctp_addr *paddr)
  761. {
  762. struct sctp_transport *transport;
  763. sctp_read_lock(&asoc->base.addr_lock);
  764. if ((htons(asoc->base.bind_addr.port) == laddr->v4.sin_port) &&
  765. (htons(asoc->peer.port) == paddr->v4.sin_port)) {
  766. transport = sctp_assoc_lookup_paddr(asoc, paddr);
  767. if (!transport)
  768. goto out;
  769. if (sctp_bind_addr_match(&asoc->base.bind_addr, laddr,
  770. sctp_sk(asoc->base.sk)))
  771. goto out;
  772. }
  773. transport = NULL;
  774. out:
  775. sctp_read_unlock(&asoc->base.addr_lock);
  776. return transport;
  777. }
  778. /* Do delayed input processing. This is scheduled by sctp_rcv(). */
  779. static void sctp_assoc_bh_rcv(struct work_struct *work)
  780. {
  781. struct sctp_association *asoc =
  782. container_of(work, struct sctp_association,
  783. base.inqueue.immediate);
  784. struct sctp_endpoint *ep;
  785. struct sctp_chunk *chunk;
  786. struct sock *sk;
  787. struct sctp_inq *inqueue;
  788. int state;
  789. sctp_subtype_t subtype;
  790. int error = 0;
  791. /* The association should be held so we should be safe. */
  792. ep = asoc->ep;
  793. sk = asoc->base.sk;
  794. inqueue = &asoc->base.inqueue;
  795. sctp_association_hold(asoc);
  796. while (NULL != (chunk = sctp_inq_pop(inqueue))) {
  797. state = asoc->state;
  798. subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);
  799. /* Remember where the last DATA chunk came from so we
  800. * know where to send the SACK.
  801. */
  802. if (sctp_chunk_is_data(chunk))
  803. asoc->peer.last_data_from = chunk->transport;
  804. else
  805. SCTP_INC_STATS(SCTP_MIB_INCTRLCHUNKS);
  806. if (chunk->transport)
  807. chunk->transport->last_time_heard = jiffies;
  808. /* Run through the state machine. */
  809. error = sctp_do_sm(SCTP_EVENT_T_CHUNK, subtype,
  810. state, ep, asoc, chunk, GFP_ATOMIC);
  811. /* Check to see if the association is freed in response to
  812. * the incoming chunk. If so, get out of the while loop.
  813. */
  814. if (asoc->base.dead)
  815. break;
  816. /* If there is an error on chunk, discard this packet. */
  817. if (error && chunk)
  818. chunk->pdiscard = 1;
  819. }
  820. sctp_association_put(asoc);
  821. }
  822. /* This routine moves an association from its old sk to a new sk. */
  823. void sctp_assoc_migrate(struct sctp_association *assoc, struct sock *newsk)
  824. {
  825. struct sctp_sock *newsp = sctp_sk(newsk);
  826. struct sock *oldsk = assoc->base.sk;
  827. /* Delete the association from the old endpoint's list of
  828. * associations.
  829. */
  830. list_del_init(&assoc->asocs);
  831. /* Decrement the backlog value for a TCP-style socket. */
  832. if (sctp_style(oldsk, TCP))
  833. oldsk->sk_ack_backlog--;
  834. /* Release references to the old endpoint and the sock. */
  835. sctp_endpoint_put(assoc->ep);
  836. sock_put(assoc->base.sk);
  837. /* Get a reference to the new endpoint. */
  838. assoc->ep = newsp->ep;
  839. sctp_endpoint_hold(assoc->ep);
  840. /* Get a reference to the new sock. */
  841. assoc->base.sk = newsk;
  842. sock_hold(assoc->base.sk);
  843. /* Add the association to the new endpoint's list of associations. */
  844. sctp_endpoint_add_asoc(newsp->ep, assoc);
  845. }
  846. /* Update an association (possibly from unexpected COOKIE-ECHO processing). */
  847. void sctp_assoc_update(struct sctp_association *asoc,
  848. struct sctp_association *new)
  849. {
  850. struct sctp_transport *trans;
  851. struct list_head *pos, *temp;
  852. /* Copy in new parameters of peer. */
  853. asoc->c = new->c;
  854. asoc->peer.rwnd = new->peer.rwnd;
  855. asoc->peer.sack_needed = new->peer.sack_needed;
  856. asoc->peer.i = new->peer.i;
  857. sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_SIZE,
  858. asoc->peer.i.initial_tsn);
  859. /* Remove any peer addresses not present in the new association. */
  860. list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
  861. trans = list_entry(pos, struct sctp_transport, transports);
  862. if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr))
  863. sctp_assoc_del_peer(asoc, &trans->ipaddr);
  864. if (asoc->state >= SCTP_STATE_ESTABLISHED)
  865. sctp_transport_reset(trans);
  866. }
  867. /* If the case is A (association restart), use
  868. * initial_tsn as next_tsn. If the case is B, use
  869. * current next_tsn in case data sent to peer
  870. * has been discarded and needs retransmission.
  871. */
  872. if (asoc->state >= SCTP_STATE_ESTABLISHED) {
  873. asoc->next_tsn = new->next_tsn;
  874. asoc->ctsn_ack_point = new->ctsn_ack_point;
  875. asoc->adv_peer_ack_point = new->adv_peer_ack_point;
  876. /* Reinitialize SSN for both local streams
  877. * and peer's streams.
  878. */
  879. sctp_ssnmap_clear(asoc->ssnmap);
  880. /* Flush the ULP reassembly and ordered queue.
  881. * Any data there will now be stale and will
  882. * cause problems.
  883. */
  884. sctp_ulpq_flush(&asoc->ulpq);
  885. /* reset the overall association error count so
  886. * that the restarted association doesn't get torn
  887. * down on the next retransmission timer.
  888. */
  889. asoc->overall_error_count = 0;
  890. } else {
  891. /* Add any peer addresses from the new association. */
  892. list_for_each(pos, &new->peer.transport_addr_list) {
  893. trans = list_entry(pos, struct sctp_transport,
  894. transports);
  895. if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr))
  896. sctp_assoc_add_peer(asoc, &trans->ipaddr,
  897. GFP_ATOMIC, trans->state);
  898. }
  899. asoc->ctsn_ack_point = asoc->next_tsn - 1;
  900. asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
  901. if (!asoc->ssnmap) {
  902. /* Move the ssnmap. */
  903. asoc->ssnmap = new->ssnmap;
  904. new->ssnmap = NULL;
  905. }
  906. }
  907. }
  908. /* Update the retran path for sending a retransmitted packet.
  909. * Round-robin through the active transports, else round-robin
  910. * through the inactive transports as this is the next best thing
  911. * we can try.
  912. */
  913. void sctp_assoc_update_retran_path(struct sctp_association *asoc)
  914. {
  915. struct sctp_transport *t, *next;
  916. struct list_head *head = &asoc->peer.transport_addr_list;
  917. struct list_head *pos;
  918. /* Find the next transport in a round-robin fashion. */
  919. t = asoc->peer.retran_path;
  920. pos = &t->transports;
  921. next = NULL;
  922. while (1) {
  923. /* Skip the head. */
  924. if (pos->next == head)
  925. pos = head->next;
  926. else
  927. pos = pos->next;
  928. t = list_entry(pos, struct sctp_transport, transports);
  929. /* Try to find an active transport. */
  930. if ((t->state == SCTP_ACTIVE) ||
  931. (t->state == SCTP_UNKNOWN)) {
  932. break;
  933. } else {
  934. /* Keep track of the next transport in case
  935. * we don't find any active transport.
  936. */
  937. if (!next)
  938. next = t;
  939. }
  940. /* We have exhausted the list, but didn't find any
  941. * other active transports. If so, use the next
  942. * transport.
  943. */
  944. if (t == asoc->peer.retran_path) {
  945. t = next;
  946. break;
  947. }
  948. }
  949. asoc->peer.retran_path = t;
  950. SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_update_retran_path:association"
  951. " %p addr: ",
  952. " port: %d\n",
  953. asoc,
  954. (&t->ipaddr),
  955. ntohs(t->ipaddr.v4.sin_port));
  956. }
  957. /* Choose the transport for sending a INIT packet. */
  958. struct sctp_transport *sctp_assoc_choose_init_transport(
  959. struct sctp_association *asoc)
  960. {
  961. struct sctp_transport *t;
  962. /* Use the retran path. If the last INIT was sent over the
  963. * retran path, update the retran path and use it.
  964. */
  965. if (!asoc->init_last_sent_to) {
  966. t = asoc->peer.active_path;
  967. } else {
  968. if (asoc->init_last_sent_to == asoc->peer.retran_path)
  969. sctp_assoc_update_retran_path(asoc);
  970. t = asoc->peer.retran_path;
  971. }
  972. SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_update_retran_path:association"
  973. " %p addr: ",
  974. " port: %d\n",
  975. asoc,
  976. (&t->ipaddr),
  977. ntohs(t->ipaddr.v4.sin_port));
  978. return t;
  979. }
  980. /* Choose the transport for sending a SHUTDOWN packet. */
  981. struct sctp_transport *sctp_assoc_choose_shutdown_transport(
  982. struct sctp_association *asoc)
  983. {
  984. /* If this is the first time SHUTDOWN is sent, use the active path,
  985. * else use the retran path. If the last SHUTDOWN was sent over the
  986. * retran path, update the retran path and use it.
  987. */
  988. if (!asoc->shutdown_last_sent_to)
  989. return asoc->peer.active_path;
  990. else {
  991. if (asoc->shutdown_last_sent_to == asoc->peer.retran_path)
  992. sctp_assoc_update_retran_path(asoc);
  993. return asoc->peer.retran_path;
  994. }
  995. }
  996. /* Update the association's pmtu and frag_point by going through all the
  997. * transports. This routine is called when a transport's PMTU has changed.
  998. */
  999. void sctp_assoc_sync_pmtu(struct sctp_association *asoc)
  1000. {
  1001. struct sctp_transport *t;
  1002. struct list_head *pos;
  1003. __u32 pmtu = 0;
  1004. if (!asoc)
  1005. return;
  1006. /* Get the lowest pmtu of all the transports. */
  1007. list_for_each(pos, &asoc->peer.transport_addr_list) {
  1008. t = list_entry(pos, struct sctp_transport, transports);
  1009. if (!pmtu || (t->pathmtu < pmtu))
  1010. pmtu = t->pathmtu;
  1011. }
  1012. if (pmtu) {
  1013. struct sctp_sock *sp = sctp_sk(asoc->base.sk);
  1014. asoc->pathmtu = pmtu;
  1015. asoc->frag_point = sctp_frag_point(sp, pmtu);
  1016. }
  1017. SCTP_DEBUG_PRINTK("%s: asoc:%p, pmtu:%d, frag_point:%d\n",
  1018. __FUNCTION__, asoc, asoc->pathmtu, asoc->frag_point);
  1019. }
  1020. /* Should we send a SACK to update our peer? */
  1021. static inline int sctp_peer_needs_update(struct sctp_association *asoc)
  1022. {
  1023. switch (asoc->state) {
  1024. case SCTP_STATE_ESTABLISHED:
  1025. case SCTP_STATE_SHUTDOWN_PENDING:
  1026. case SCTP_STATE_SHUTDOWN_RECEIVED:
  1027. case SCTP_STATE_SHUTDOWN_SENT:
  1028. if ((asoc->rwnd > asoc->a_rwnd) &&
  1029. ((asoc->rwnd - asoc->a_rwnd) >=
  1030. min_t(__u32, (asoc->base.sk->sk_rcvbuf >> 1), asoc->pathmtu)))
  1031. return 1;
  1032. break;
  1033. default:
  1034. break;
  1035. }
  1036. return 0;
  1037. }
  1038. /* Increase asoc's rwnd by len and send any window update SACK if needed. */
  1039. void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned len)
  1040. {
  1041. struct sctp_chunk *sack;
  1042. struct timer_list *timer;
  1043. if (asoc->rwnd_over) {
  1044. if (asoc->rwnd_over >= len) {
  1045. asoc->rwnd_over -= len;
  1046. } else {
  1047. asoc->rwnd += (len - asoc->rwnd_over);
  1048. asoc->rwnd_over = 0;
  1049. }
  1050. } else {
  1051. asoc->rwnd += len;
  1052. }
  1053. SCTP_DEBUG_PRINTK("%s: asoc %p rwnd increased by %d to (%u, %u) "
  1054. "- %u\n", __FUNCTION__, asoc, len, asoc->rwnd,
  1055. asoc->rwnd_over, asoc->a_rwnd);
  1056. /* Send a window update SACK if the rwnd has increased by at least the
  1057. * minimum of the association's PMTU and half of the receive buffer.
  1058. * The algorithm used is similar to the one described in
  1059. * Section 4.2.3.3 of RFC 1122.
  1060. */
  1061. if (sctp_peer_needs_update(asoc)) {
  1062. asoc->a_rwnd = asoc->rwnd;
  1063. SCTP_DEBUG_PRINTK("%s: Sending window update SACK- asoc: %p "
  1064. "rwnd: %u a_rwnd: %u\n", __FUNCTION__,
  1065. asoc, asoc->rwnd, asoc->a_rwnd);
  1066. sack = sctp_make_sack(asoc);
  1067. if (!sack)
  1068. return;
  1069. asoc->peer.sack_needed = 0;
  1070. sctp_outq_tail(&asoc->outqueue, sack);
  1071. /* Stop the SACK timer. */
  1072. timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
  1073. if (timer_pending(timer) && del_timer(timer))
  1074. sctp_association_put(asoc);
  1075. }
  1076. }
  1077. /* Decrease asoc's rwnd by len. */
  1078. void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned len)
  1079. {
  1080. SCTP_ASSERT(asoc->rwnd, "rwnd zero", return);
  1081. SCTP_ASSERT(!asoc->rwnd_over, "rwnd_over not zero", return);
  1082. if (asoc->rwnd >= len) {
  1083. asoc->rwnd -= len;
  1084. } else {
  1085. asoc->rwnd_over = len - asoc->rwnd;
  1086. asoc->rwnd = 0;
  1087. }
  1088. SCTP_DEBUG_PRINTK("%s: asoc %p rwnd decreased by %d to (%u, %u)\n",
  1089. __FUNCTION__, asoc, len, asoc->rwnd,
  1090. asoc->rwnd_over);
  1091. }
  1092. /* Build the bind address list for the association based on info from the
  1093. * local endpoint and the remote peer.
  1094. */
  1095. int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,
  1096. gfp_t gfp)
  1097. {
  1098. sctp_scope_t scope;
  1099. int flags;
  1100. /* Use scoping rules to determine the subset of addresses from
  1101. * the endpoint.
  1102. */
  1103. scope = sctp_scope(&asoc->peer.active_path->ipaddr);
  1104. flags = (PF_INET6 == asoc->base.sk->sk_family) ? SCTP_ADDR6_ALLOWED : 0;
  1105. if (asoc->peer.ipv4_address)
  1106. flags |= SCTP_ADDR4_PEERSUPP;
  1107. if (asoc->peer.ipv6_address)
  1108. flags |= SCTP_ADDR6_PEERSUPP;
  1109. return sctp_bind_addr_copy(&asoc->base.bind_addr,
  1110. &asoc->ep->base.bind_addr,
  1111. scope, gfp, flags);
  1112. }
  1113. /* Build the association's bind address list from the cookie. */
  1114. int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *asoc,
  1115. struct sctp_cookie *cookie,
  1116. gfp_t gfp)
  1117. {
  1118. int var_size2 = ntohs(cookie->peer_init->chunk_hdr.length);
  1119. int var_size3 = cookie->raw_addr_list_len;
  1120. __u8 *raw = (__u8 *)cookie->peer_init + var_size2;
  1121. return sctp_raw_to_bind_addrs(&asoc->base.bind_addr, raw, var_size3,
  1122. asoc->ep->base.bind_addr.port, gfp);
  1123. }
  1124. /* Lookup laddr in the bind address list of an association. */
  1125. int sctp_assoc_lookup_laddr(struct sctp_association *asoc,
  1126. const union sctp_addr *laddr)
  1127. {
  1128. int found;
  1129. sctp_read_lock(&asoc->base.addr_lock);
  1130. if ((asoc->base.bind_addr.port == ntohs(laddr->v4.sin_port)) &&
  1131. sctp_bind_addr_match(&asoc->base.bind_addr, laddr,
  1132. sctp_sk(asoc->base.sk))) {
  1133. found = 1;
  1134. goto out;
  1135. }
  1136. found = 0;
  1137. out:
  1138. sctp_read_unlock(&asoc->base.addr_lock);
  1139. return found;
  1140. }