1 /* SCTP kernel 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
9 * This file is part of the SCTP kernel implementation
11 * This abstraction represents an SCTP endpoint.
13 * The SCTP implementation is free software;
14 * you can redistribute it and/or modify it under the terms of
15 * the GNU General Public License as published by
16 * the Free Software Foundation; either version 2, or (at your option)
19 * The SCTP implementation is distributed in the hope that it
20 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
21 * ************************
22 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
23 * See the GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with GNU CC; see the file COPYING. If not, see
27 * <http://www.gnu.org/licenses/>.
29 * Please send any bug reports or fixes you make to the
31 * lksctp developers <linux-sctp@vger.kernel.org>
33 * Written or modified by:
34 * La Monte H.P. Yarroll <piggy@acm.org>
35 * Karl Knutson <karl@athena.chicago.il.us>
36 * Jon Grimm <jgrimm@austin.ibm.com>
37 * Daisy Chang <daisyc@us.ibm.com>
38 * Dajiang Zhang <dajiang.zhang@nokia.com>
41 #include <linux/types.h>
42 #include <linux/slab.h>
44 #include <linux/random.h> /* get_random_bytes() */
45 #include <linux/crypto.h>
48 #include <net/sctp/sctp.h>
49 #include <net/sctp/sm.h>
51 /* Forward declarations for internal helpers. */
52 static void sctp_endpoint_bh_rcv(struct work_struct
*work
);
55 * Initialize the base fields of the endpoint structure.
57 static struct sctp_endpoint
*sctp_endpoint_init(struct sctp_endpoint
*ep
,
61 struct net
*net
= sock_net(sk
);
62 struct sctp_hmac_algo_param
*auth_hmacs
= NULL
;
63 struct sctp_chunks_param
*auth_chunks
= NULL
;
64 struct sctp_shared_key
*null_key
;
67 ep
->digest
= kzalloc(SCTP_SIGNATURE_SIZE
, gfp
);
71 if (net
->sctp
.auth_enable
) {
72 /* Allocate space for HMACS and CHUNKS authentication
73 * variables. There are arrays that we encode directly
74 * into parameters to make the rest of the operations easier.
76 auth_hmacs
= kzalloc(sizeof(sctp_hmac_algo_param_t
) +
77 sizeof(__u16
) * SCTP_AUTH_NUM_HMACS
, gfp
);
81 auth_chunks
= kzalloc(sizeof(sctp_chunks_param_t
) +
82 SCTP_NUM_CHUNK_TYPES
, gfp
);
86 /* Initialize the HMACS parameter.
87 * SCTP-AUTH: Section 3.3
88 * Every endpoint supporting SCTP chunk authentication MUST
89 * support the HMAC based on the SHA-1 algorithm.
91 auth_hmacs
->param_hdr
.type
= SCTP_PARAM_HMAC_ALGO
;
92 auth_hmacs
->param_hdr
.length
=
93 htons(sizeof(sctp_paramhdr_t
) + 2);
94 auth_hmacs
->hmac_ids
[0] = htons(SCTP_AUTH_HMAC_ID_SHA1
);
96 /* Initialize the CHUNKS parameter */
97 auth_chunks
->param_hdr
.type
= SCTP_PARAM_CHUNKS
;
98 auth_chunks
->param_hdr
.length
= htons(sizeof(sctp_paramhdr_t
));
100 /* If the Add-IP functionality is enabled, we must
101 * authenticate, ASCONF and ASCONF-ACK chunks
103 if (net
->sctp
.addip_enable
) {
104 auth_chunks
->chunks
[0] = SCTP_CID_ASCONF
;
105 auth_chunks
->chunks
[1] = SCTP_CID_ASCONF_ACK
;
106 auth_chunks
->param_hdr
.length
=
107 htons(sizeof(sctp_paramhdr_t
) + 2);
111 /* Initialize the base structure. */
112 /* What type of endpoint are we? */
113 ep
->base
.type
= SCTP_EP_TYPE_SOCKET
;
115 /* Initialize the basic object fields. */
116 atomic_set(&ep
->base
.refcnt
, 1);
117 ep
->base
.dead
= false;
119 /* Create an input queue. */
120 sctp_inq_init(&ep
->base
.inqueue
);
122 /* Set its top-half handler */
123 sctp_inq_set_th_handler(&ep
->base
.inqueue
, sctp_endpoint_bh_rcv
);
125 /* Initialize the bind addr area */
126 sctp_bind_addr_init(&ep
->base
.bind_addr
, 0);
128 /* Remember who we are attached to. */
130 sock_hold(ep
->base
.sk
);
132 /* Create the lists of associations. */
133 INIT_LIST_HEAD(&ep
->asocs
);
135 /* Use SCTP specific send buffer space queues. */
136 ep
->sndbuf_policy
= net
->sctp
.sndbuf_policy
;
138 sk
->sk_data_ready
= sctp_data_ready
;
139 sk
->sk_write_space
= sctp_write_space
;
140 sock_set_flag(sk
, SOCK_USE_WRITE_QUEUE
);
142 /* Get the receive buffer policy for this endpoint */
143 ep
->rcvbuf_policy
= net
->sctp
.rcvbuf_policy
;
145 /* Initialize the secret key used with cookie. */
146 get_random_bytes(ep
->secret_key
, sizeof(ep
->secret_key
));
148 /* SCTP-AUTH extensions*/
149 INIT_LIST_HEAD(&ep
->endpoint_shared_keys
);
150 null_key
= sctp_auth_shkey_create(0, gfp
);
154 list_add(&null_key
->key_list
, &ep
->endpoint_shared_keys
);
156 /* Allocate and initialize transorms arrays for supported HMACs. */
157 err
= sctp_auth_init_hmacs(ep
, gfp
);
161 /* Add the null key to the endpoint shared keys list and
162 * set the hmcas and chunks pointers.
164 ep
->auth_hmacs_list
= auth_hmacs
;
165 ep
->auth_chunk_list
= auth_chunks
;
170 sctp_auth_destroy_keys(&ep
->endpoint_shared_keys
);
172 /* Free all allocations */
180 /* Create a sctp_endpoint with all that boring stuff initialized.
181 * Returns NULL if there isn't enough memory.
183 struct sctp_endpoint
*sctp_endpoint_new(struct sock
*sk
, gfp_t gfp
)
185 struct sctp_endpoint
*ep
;
187 /* Build a local endpoint. */
188 ep
= kzalloc(sizeof(*ep
), gfp
);
192 if (!sctp_endpoint_init(ep
, sk
, gfp
))
195 SCTP_DBG_OBJCNT_INC(ep
);
204 /* Add an association to an endpoint. */
205 void sctp_endpoint_add_asoc(struct sctp_endpoint
*ep
,
206 struct sctp_association
*asoc
)
208 struct sock
*sk
= ep
->base
.sk
;
210 /* If this is a temporary association, don't bother
211 * since we'll be removing it shortly and don't
212 * want anyone to find it anyway.
217 /* Now just add it to our list of asocs */
218 list_add_tail(&asoc
->asocs
, &ep
->asocs
);
220 /* Increment the backlog value for a TCP-style listening socket. */
221 if (sctp_style(sk
, TCP
) && sctp_sstate(sk
, LISTENING
))
222 sk
->sk_ack_backlog
++;
225 /* Free the endpoint structure. Delay cleanup until
226 * all users have released their reference count on this structure.
228 void sctp_endpoint_free(struct sctp_endpoint
*ep
)
230 ep
->base
.dead
= true;
232 ep
->base
.sk
->sk_state
= SCTP_SS_CLOSED
;
234 /* Unlink this endpoint, so we can't find it again! */
235 sctp_unhash_endpoint(ep
);
237 sctp_endpoint_put(ep
);
240 /* Final destructor for endpoint. */
241 static void sctp_endpoint_destroy(struct sctp_endpoint
*ep
)
245 if (unlikely(!ep
->base
.dead
)) {
246 WARN(1, "Attempt to destroy undead endpoint %p!\n", ep
);
250 /* Free the digest buffer */
253 /* SCTP-AUTH: Free up AUTH releated data such as shared keys
254 * chunks and hmacs arrays that were allocated
256 sctp_auth_destroy_keys(&ep
->endpoint_shared_keys
);
257 kfree(ep
->auth_hmacs_list
);
258 kfree(ep
->auth_chunk_list
);
260 /* AUTH - Free any allocated HMAC transform containers */
261 sctp_auth_destroy_hmacs(ep
->auth_hmacs
);
264 sctp_inq_free(&ep
->base
.inqueue
);
265 sctp_bind_addr_free(&ep
->base
.bind_addr
);
267 memset(ep
->secret_key
, 0, sizeof(ep
->secret_key
));
269 /* Give up our hold on the sock. */
272 /* Remove and free the port */
273 if (sctp_sk(sk
)->bind_hash
)
280 SCTP_DBG_OBJCNT_DEC(ep
);
283 /* Hold a reference to an endpoint. */
284 void sctp_endpoint_hold(struct sctp_endpoint
*ep
)
286 atomic_inc(&ep
->base
.refcnt
);
289 /* Release a reference to an endpoint and clean up if there are
290 * no more references.
292 void sctp_endpoint_put(struct sctp_endpoint
*ep
)
294 if (atomic_dec_and_test(&ep
->base
.refcnt
))
295 sctp_endpoint_destroy(ep
);
298 /* Is this the endpoint we are looking for? */
299 struct sctp_endpoint
*sctp_endpoint_is_match(struct sctp_endpoint
*ep
,
301 const union sctp_addr
*laddr
)
303 struct sctp_endpoint
*retval
= NULL
;
305 if ((htons(ep
->base
.bind_addr
.port
) == laddr
->v4
.sin_port
) &&
306 net_eq(sock_net(ep
->base
.sk
), net
)) {
307 if (sctp_bind_addr_match(&ep
->base
.bind_addr
, laddr
,
308 sctp_sk(ep
->base
.sk
)))
315 /* Find the association that goes with this chunk.
316 * We do a linear search of the associations for this endpoint.
317 * We return the matching transport address too.
319 static struct sctp_association
*__sctp_endpoint_lookup_assoc(
320 const struct sctp_endpoint
*ep
,
321 const union sctp_addr
*paddr
,
322 struct sctp_transport
**transport
)
324 struct sctp_association
*asoc
= NULL
;
325 struct sctp_association
*tmp
;
326 struct sctp_transport
*t
= NULL
;
327 struct sctp_hashbucket
*head
;
328 struct sctp_ep_common
*epb
;
334 /* If the local port is not set, there can't be any associations
337 if (!ep
->base
.bind_addr
.port
)
340 rport
= ntohs(paddr
->v4
.sin_port
);
342 hash
= sctp_assoc_hashfn(sock_net(ep
->base
.sk
), ep
->base
.bind_addr
.port
,
344 head
= &sctp_assoc_hashtable
[hash
];
345 read_lock(&head
->lock
);
346 sctp_for_each_hentry(epb
, &head
->chain
) {
347 tmp
= sctp_assoc(epb
);
348 if (tmp
->ep
!= ep
|| rport
!= tmp
->peer
.port
)
351 t
= sctp_assoc_lookup_paddr(tmp
, paddr
);
358 read_unlock(&head
->lock
);
363 /* Lookup association on an endpoint based on a peer address. BH-safe. */
364 struct sctp_association
*sctp_endpoint_lookup_assoc(
365 const struct sctp_endpoint
*ep
,
366 const union sctp_addr
*paddr
,
367 struct sctp_transport
**transport
)
369 struct sctp_association
*asoc
;
372 asoc
= __sctp_endpoint_lookup_assoc(ep
, paddr
, transport
);
378 /* Look for any peeled off association from the endpoint that matches the
379 * given peer address.
381 int sctp_endpoint_is_peeled_off(struct sctp_endpoint
*ep
,
382 const union sctp_addr
*paddr
)
384 struct sctp_sockaddr_entry
*addr
;
385 struct sctp_bind_addr
*bp
;
386 struct net
*net
= sock_net(ep
->base
.sk
);
388 bp
= &ep
->base
.bind_addr
;
389 /* This function is called with the socket lock held,
390 * so the address_list can not change.
392 list_for_each_entry(addr
, &bp
->address_list
, list
) {
393 if (sctp_has_association(net
, &addr
->a
, paddr
))
400 /* Do delayed input processing. This is scheduled by sctp_rcv().
401 * This may be called on BH or task time.
403 static void sctp_endpoint_bh_rcv(struct work_struct
*work
)
405 struct sctp_endpoint
*ep
=
406 container_of(work
, struct sctp_endpoint
,
407 base
.inqueue
.immediate
);
408 struct sctp_association
*asoc
;
411 struct sctp_transport
*transport
;
412 struct sctp_chunk
*chunk
;
413 struct sctp_inq
*inqueue
;
414 sctp_subtype_t subtype
;
417 int first_time
= 1; /* is this the first time through the loop */
423 inqueue
= &ep
->base
.inqueue
;
427 while (NULL
!= (chunk
= sctp_inq_pop(inqueue
))) {
428 subtype
= SCTP_ST_CHUNK(chunk
->chunk_hdr
->type
);
430 /* If the first chunk in the packet is AUTH, do special
431 * processing specified in Section 6.3 of SCTP-AUTH spec
433 if (first_time
&& (subtype
.chunk
== SCTP_CID_AUTH
)) {
434 struct sctp_chunkhdr
*next_hdr
;
436 next_hdr
= sctp_inq_peek(inqueue
);
440 /* If the next chunk is COOKIE-ECHO, skip the AUTH
441 * chunk while saving a pointer to it so we can do
442 * Authentication later (during cookie-echo
445 if (next_hdr
->type
== SCTP_CID_COOKIE_ECHO
) {
446 chunk
->auth_chunk
= skb_clone(chunk
->skb
,
453 /* We might have grown an association since last we
454 * looked, so try again.
456 * This happens when we've just processed our
459 if (NULL
== chunk
->asoc
) {
460 asoc
= sctp_endpoint_lookup_assoc(ep
,
464 chunk
->transport
= transport
;
467 state
= asoc
? asoc
->state
: SCTP_STATE_CLOSED
;
468 if (sctp_auth_recv_cid(subtype
.chunk
, asoc
) && !chunk
->auth
)
471 /* Remember where the last DATA chunk came from so we
472 * know where to send the SACK.
474 if (asoc
&& sctp_chunk_is_data(chunk
))
475 asoc
->peer
.last_data_from
= chunk
->transport
;
477 SCTP_INC_STATS(sock_net(ep
->base
.sk
), SCTP_MIB_INCTRLCHUNKS
);
479 asoc
->stats
.ictrlchunks
++;
482 if (chunk
->transport
)
483 chunk
->transport
->last_time_heard
= jiffies
;
485 error
= sctp_do_sm(net
, SCTP_EVENT_T_CHUNK
, subtype
, state
,
486 ep
, asoc
, chunk
, GFP_ATOMIC
);
491 /* Check to see if the endpoint is freed in response to
492 * the incoming chunk. If so, get out of the while loop.
494 if (!sctp_sk(sk
)->ep
)
This page took 0.040874 seconds and 5 git commands to generate.