endpointola.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382
  1. /* SCTP kernel reference Implementation
  2. * Copyright (c) 1999-2000 Cisco, Inc.
  3. * Copyright (c) 1999-2001 Motorola, Inc.
  4. * Copyright (c) 2001-2002 International Business Machines, Corp.
  5. * Copyright (c) 2001 Intel Corp.
  6. * Copyright (c) 2001 Nokia, Inc.
  7. * Copyright (c) 2001 La Monte H.P. Yarroll
  8. *
  9. * This file is part of the SCTP kernel reference Implementation
  10. *
  11. * This abstraction represents an SCTP endpoint.
  12. *
  13. * This file is part of the implementation of the add-IP extension,
  14. * based on <draft-ietf-tsvwg-addip-sctp-02.txt> June 29, 2001,
  15. * for the SCTP kernel reference Implementation.
  16. *
  17. * The SCTP reference implementation is free software;
  18. * you can redistribute it and/or modify it under the terms of
  19. * the GNU General Public License as published by
  20. * the Free Software Foundation; either version 2, or (at your option)
  21. * any later version.
  22. *
  23. * The SCTP reference implementation is distributed in the hope that it
  24. * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  25. * ************************
  26. * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  27. * See the GNU General Public License for more details.
  28. *
  29. * You should have received a copy of the GNU General Public License
  30. * along with GNU CC; see the file COPYING. If not, write to
  31. * the Free Software Foundation, 59 Temple Place - Suite 330,
  32. * Boston, MA 02111-1307, USA.
  33. *
  34. * Please send any bug reports or fixes you make to the
  35. * email address(es):
  36. * lksctp developers <lksctp-developers@lists.sourceforge.net>
  37. *
  38. * Or submit a bug report through the following website:
  39. * http://www.sf.net/projects/lksctp
  40. *
  41. * Written or modified by:
  42. * La Monte H.P. Yarroll <piggy@acm.org>
  43. * Karl Knutson <karl@athena.chicago.il.us>
  44. * Jon Grimm <jgrimm@austin.ibm.com>
  45. * Daisy Chang <daisyc@us.ibm.com>
  46. * Dajiang Zhang <dajiang.zhang@nokia.com>
  47. *
  48. * Any bugs reported given to us we will try to fix... any fixes shared will
  49. * be incorporated into the next SCTP release.
  50. */
  51. #include <linux/types.h>
  52. #include <linux/slab.h>
  53. #include <linux/in.h>
  54. #include <linux/random.h> /* get_random_bytes() */
  55. #include <linux/crypto.h>
  56. #include <net/sock.h>
  57. #include <net/ipv6.h>
  58. #include <net/sctp/sctp.h>
  59. #include <net/sctp/sm.h>
  60. /* Forward declarations for internal helpers. */
  61. static void sctp_endpoint_bh_rcv(struct work_struct *work);
  62. /*
  63. * Initialize the base fields of the endpoint structure.
  64. */
  65. static struct sctp_endpoint *sctp_endpoint_init(struct sctp_endpoint *ep,
  66. struct sock *sk,
  67. gfp_t gfp)
  68. {
  69. memset(ep, 0, sizeof(struct sctp_endpoint));
  70. ep->digest = kzalloc(SCTP_SIGNATURE_SIZE, gfp);
  71. if (!ep->digest)
  72. return NULL;
  73. /* Initialize the base structure. */
  74. /* What type of endpoint are we? */
  75. ep->base.type = SCTP_EP_TYPE_SOCKET;
  76. /* Initialize the basic object fields. */
  77. atomic_set(&ep->base.refcnt, 1);
  78. ep->base.dead = 0;
  79. ep->base.malloced = 1;
  80. /* Create an input queue. */
  81. sctp_inq_init(&ep->base.inqueue);
  82. /* Set its top-half handler */
  83. sctp_inq_set_th_handler(&ep->base.inqueue, sctp_endpoint_bh_rcv);
  84. /* Initialize the bind addr area */
  85. sctp_bind_addr_init(&ep->base.bind_addr, 0);
  86. rwlock_init(&ep->base.addr_lock);
  87. /* Remember who we are attached to. */
  88. ep->base.sk = sk;
  89. sock_hold(ep->base.sk);
  90. /* Create the lists of associations. */
  91. INIT_LIST_HEAD(&ep->asocs);
  92. /* Use SCTP specific send buffer space queues. */
  93. ep->sndbuf_policy = sctp_sndbuf_policy;
  94. sk->sk_write_space = sctp_write_space;
  95. sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
  96. /* Get the receive buffer policy for this endpoint */
  97. ep->rcvbuf_policy = sctp_rcvbuf_policy;
  98. /* Initialize the secret key used with cookie. */
  99. get_random_bytes(&ep->secret_key[0], SCTP_SECRET_SIZE);
  100. ep->last_key = ep->current_key = 0;
  101. ep->key_changed_at = jiffies;
  102. return ep;
  103. }
  104. /* Create a sctp_endpoint with all that boring stuff initialized.
  105. * Returns NULL if there isn't enough memory.
  106. */
  107. struct sctp_endpoint *sctp_endpoint_new(struct sock *sk, gfp_t gfp)
  108. {
  109. struct sctp_endpoint *ep;
  110. /* Build a local endpoint. */
  111. ep = t_new(struct sctp_endpoint, gfp);
  112. if (!ep)
  113. goto fail;
  114. if (!sctp_endpoint_init(ep, sk, gfp))
  115. goto fail_init;
  116. ep->base.malloced = 1;
  117. SCTP_DBG_OBJCNT_INC(ep);
  118. return ep;
  119. fail_init:
  120. kfree(ep);
  121. fail:
  122. return NULL;
  123. }
  124. /* Add an association to an endpoint. */
  125. void sctp_endpoint_add_asoc(struct sctp_endpoint *ep,
  126. struct sctp_association *asoc)
  127. {
  128. struct sock *sk = ep->base.sk;
  129. /* If this is a temporary association, don't bother
  130. * since we'll be removing it shortly and don't
  131. * want anyone to find it anyway.
  132. */
  133. if (asoc->temp)
  134. return;
  135. /* Now just add it to our list of asocs */
  136. list_add_tail(&asoc->asocs, &ep->asocs);
  137. /* Increment the backlog value for a TCP-style listening socket. */
  138. if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
  139. sk->sk_ack_backlog++;
  140. }
  141. /* Free the endpoint structure. Delay cleanup until
  142. * all users have released their reference count on this structure.
  143. */
  144. void sctp_endpoint_free(struct sctp_endpoint *ep)
  145. {
  146. ep->base.dead = 1;
  147. ep->base.sk->sk_state = SCTP_SS_CLOSED;
  148. /* Unlink this endpoint, so we can't find it again! */
  149. sctp_unhash_endpoint(ep);
  150. sctp_endpoint_put(ep);
  151. }
  152. /* Final destructor for endpoint. */
  153. static void sctp_endpoint_destroy(struct sctp_endpoint *ep)
  154. {
  155. SCTP_ASSERT(ep->base.dead, "Endpoint is not dead", return);
  156. /* Free up the HMAC transform. */
  157. crypto_free_hash(sctp_sk(ep->base.sk)->hmac);
  158. /* Free the digest buffer */
  159. kfree(ep->digest);
  160. /* Cleanup. */
  161. sctp_inq_free(&ep->base.inqueue);
  162. sctp_bind_addr_free(&ep->base.bind_addr);
  163. /* Remove and free the port */
  164. if (sctp_sk(ep->base.sk)->bind_hash)
  165. sctp_put_port(ep->base.sk);
  166. /* Give up our hold on the sock. */
  167. if (ep->base.sk)
  168. sock_put(ep->base.sk);
  169. /* Finally, free up our memory. */
  170. if (ep->base.malloced) {
  171. kfree(ep);
  172. SCTP_DBG_OBJCNT_DEC(ep);
  173. }
  174. }
  175. /* Hold a reference to an endpoint. */
  176. void sctp_endpoint_hold(struct sctp_endpoint *ep)
  177. {
  178. atomic_inc(&ep->base.refcnt);
  179. }
  180. /* Release a reference to an endpoint and clean up if there are
  181. * no more references.
  182. */
  183. void sctp_endpoint_put(struct sctp_endpoint *ep)
  184. {
  185. if (atomic_dec_and_test(&ep->base.refcnt))
  186. sctp_endpoint_destroy(ep);
  187. }
  188. /* Is this the endpoint we are looking for? */
  189. struct sctp_endpoint *sctp_endpoint_is_match(struct sctp_endpoint *ep,
  190. const union sctp_addr *laddr)
  191. {
  192. struct sctp_endpoint *retval;
  193. sctp_read_lock(&ep->base.addr_lock);
  194. if (htons(ep->base.bind_addr.port) == laddr->v4.sin_port) {
  195. if (sctp_bind_addr_match(&ep->base.bind_addr, laddr,
  196. sctp_sk(ep->base.sk))) {
  197. retval = ep;
  198. goto out;
  199. }
  200. }
  201. retval = NULL;
  202. out:
  203. sctp_read_unlock(&ep->base.addr_lock);
  204. return retval;
  205. }
  206. /* Find the association that goes with this chunk.
  207. * We do a linear search of the associations for this endpoint.
  208. * We return the matching transport address too.
  209. */
  210. static struct sctp_association *__sctp_endpoint_lookup_assoc(
  211. const struct sctp_endpoint *ep,
  212. const union sctp_addr *paddr,
  213. struct sctp_transport **transport)
  214. {
  215. int rport;
  216. struct sctp_association *asoc;
  217. struct list_head *pos;
  218. rport = ntohs(paddr->v4.sin_port);
  219. list_for_each(pos, &ep->asocs) {
  220. asoc = list_entry(pos, struct sctp_association, asocs);
  221. if (rport == asoc->peer.port) {
  222. sctp_read_lock(&asoc->base.addr_lock);
  223. *transport = sctp_assoc_lookup_paddr(asoc, paddr);
  224. sctp_read_unlock(&asoc->base.addr_lock);
  225. if (*transport)
  226. return asoc;
  227. }
  228. }
  229. *transport = NULL;
  230. return NULL;
  231. }
  232. /* Lookup association on an endpoint based on a peer address. BH-safe. */
  233. struct sctp_association *sctp_endpoint_lookup_assoc(
  234. const struct sctp_endpoint *ep,
  235. const union sctp_addr *paddr,
  236. struct sctp_transport **transport)
  237. {
  238. struct sctp_association *asoc;
  239. sctp_local_bh_disable();
  240. asoc = __sctp_endpoint_lookup_assoc(ep, paddr, transport);
  241. sctp_local_bh_enable();
  242. return asoc;
  243. }
  244. /* Look for any peeled off association from the endpoint that matches the
  245. * given peer address.
  246. */
  247. int sctp_endpoint_is_peeled_off(struct sctp_endpoint *ep,
  248. const union sctp_addr *paddr)
  249. {
  250. struct list_head *pos;
  251. struct sctp_sockaddr_entry *addr;
  252. struct sctp_bind_addr *bp;
  253. sctp_read_lock(&ep->base.addr_lock);
  254. bp = &ep->base.bind_addr;
  255. list_for_each(pos, &bp->address_list) {
  256. addr = list_entry(pos, struct sctp_sockaddr_entry, list);
  257. if (sctp_has_association(&addr->a, paddr)) {
  258. sctp_read_unlock(&ep->base.addr_lock);
  259. return 1;
  260. }
  261. }
  262. sctp_read_unlock(&ep->base.addr_lock);
  263. return 0;
  264. }
  265. /* Do delayed input processing. This is scheduled by sctp_rcv().
  266. * This may be called on BH or task time.
  267. */
  268. static void sctp_endpoint_bh_rcv(struct work_struct *work)
  269. {
  270. struct sctp_endpoint *ep =
  271. container_of(work, struct sctp_endpoint,
  272. base.inqueue.immediate);
  273. struct sctp_association *asoc;
  274. struct sock *sk;
  275. struct sctp_transport *transport;
  276. struct sctp_chunk *chunk;
  277. struct sctp_inq *inqueue;
  278. sctp_subtype_t subtype;
  279. sctp_state_t state;
  280. int error = 0;
  281. if (ep->base.dead)
  282. return;
  283. asoc = NULL;
  284. inqueue = &ep->base.inqueue;
  285. sk = ep->base.sk;
  286. while (NULL != (chunk = sctp_inq_pop(inqueue))) {
  287. subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);
  288. /* We might have grown an association since last we
  289. * looked, so try again.
  290. *
  291. * This happens when we've just processed our
  292. * COOKIE-ECHO chunk.
  293. */
  294. if (NULL == chunk->asoc) {
  295. asoc = sctp_endpoint_lookup_assoc(ep,
  296. sctp_source(chunk),
  297. &transport);
  298. chunk->asoc = asoc;
  299. chunk->transport = transport;
  300. }
  301. state = asoc ? asoc->state : SCTP_STATE_CLOSED;
  302. /* Remember where the last DATA chunk came from so we
  303. * know where to send the SACK.
  304. */
  305. if (asoc && sctp_chunk_is_data(chunk))
  306. asoc->peer.last_data_from = chunk->transport;
  307. else
  308. SCTP_INC_STATS(SCTP_MIB_INCTRLCHUNKS);
  309. if (chunk->transport)
  310. chunk->transport->last_time_heard = jiffies;
  311. error = sctp_do_sm(SCTP_EVENT_T_CHUNK, subtype, state,
  312. ep, asoc, chunk, GFP_ATOMIC);
  313. if (error && chunk)
  314. chunk->pdiscard = 1;
  315. /* Check to see if the endpoint is freed in response to
  316. * the incoming chunk. If so, get out of the while loop.
  317. */
  318. if (!sctp_sk(sk)->ep)
  319. break;
  320. }
  321. }