Merge http://linux-lksctp.bkbits.net/lksctp-2.5

into nuts.ninka.net:/home/davem/src/BK/sctp-2.5

include/linux/sctp.h

@@ -155,7 +155,7 @@ typedef struct sctp_paramhdr {
 typedef enum {
 
 	/* RFC 2960 Section 3.3.5 */
-	SCTP_PARAM_HEATBEAT_INFO		= __constant_htons(1),  
+	SCTP_PARAM_HEARTBEAT_INFO		= __constant_htons(1),
 	/* RFC 2960 Section 3.3.2.1 */
 	SCTP_PARAM_IPV4_ADDRESS			= __constant_htons(5),
 	SCTP_PARAM_IPV6_ADDRESS			= __constant_htons(6),
@@ -190,6 +190,7 @@ typedef enum {
 	SCTP_PARAM_ACTION_SKIP_ERR    = __constant_htons(0xc000),
 } sctp_param_action_t; 
 
+enum { SCTP_PARAM_ACTION_MASK = __constant_htons(0xc000), };
 
 /* RFC 2960 Section 3.3.1 Payload Data (DATA) (0) */
 

include/net/sctp/sctp.h

@@ -103,6 +103,14 @@
 #define SCTP_PROTOSW_FLAG INET_PROTOSW_PERMANENT
 #endif
 
+
+/* Certain internal static functions need to be exported when 
+ * compiled into the test frame.
+ */
+#ifndef SCTP_STATIC
+#define SCTP_STATIC static
+#endif
+
 /* 
  * Function declarations. 
  */

include/net/sctp/sm.h

@@ -215,7 +215,8 @@ sctp_chunk_t *sctp_make_init(const sctp_association_t *,
 			     int priority);
 sctp_chunk_t *sctp_make_init_ack(const sctp_association_t *,
 				 const sctp_chunk_t *,
-				 const int priority);
+				 const int priority,
+				 const int unkparam_len);
 sctp_chunk_t *sctp_make_cookie_echo(const sctp_association_t *,
 				    const sctp_chunk_t *);
 sctp_chunk_t *sctp_make_cookie_ack(const sctp_association_t *,
@@ -304,6 +305,14 @@ void sctp_generate_t3_rtx_event(unsigned long peer);
 void sctp_generate_heartbeat_event(unsigned long peer);
 
 sctp_sackhdr_t *sctp_sm_pull_sack(sctp_chunk_t *);
+sctp_packet_t *sctp_abort_pkt_new(const sctp_endpoint_t *ep,
+				  const sctp_association_t *asoc,
+				  sctp_chunk_t *chunk,
+				  const void *payload,
+				  size_t paylen);
+sctp_packet_t *sctp_ootb_pkt_new(const sctp_association_t *asoc,
+				 const sctp_chunk_t *chunk);
+void sctp_ootb_pkt_free(sctp_packet_t *packet);
 
 sctp_cookie_param_t *
 sctp_pack_cookie(const sctp_endpoint_t *, const sctp_association_t *,

include/net/sctp/structs.h

@@ -1044,6 +1044,20 @@ sctp_association_t *sctp_endpoint_lookup_assoc(const sctp_endpoint_t *ep,
 sctp_endpoint_t *sctp_endpoint_is_match(sctp_endpoint_t *,
 					const sockaddr_storage_t *);
 
+int sctp_verify_init(const sctp_association_t *asoc,
+		     sctp_cid_t cid,
+		     sctp_init_chunk_t *peer_init,
+		     sctp_chunk_t *chunk,
+		     sctp_chunk_t **err_chunk);
+int sctp_verify_param(const sctp_association_t *asoc,
+		      sctpParam_t param,
+		      sctp_cid_t cid,
+		      sctp_chunk_t *chunk,
+		      sctp_chunk_t **err_chunk);
+int sctp_process_unk_param(const sctp_association_t *asoc,
+			   sctpParam_t param,
+			   sctp_chunk_t *chunk,
+			   sctp_chunk_t **err_chunk);
 void sctp_process_init(sctp_association_t *asoc, sctp_cid_t cid,
 		       const sockaddr_storage_t *peer_addr,
 		       sctp_init_chunk_t  *peer_init, int priority);

net/sctp/debug.c

@@ -97,7 +97,7 @@ const char *sctp_cname(const sctp_subtype_t cid)
 /* These are printable form of variable-length parameters. */
 const char *sctp_param_tbl[SCTP_PARAM_ECN_CAPABLE + 1] = {
 	"",
-	"PARAM_HEATBEAT_INFO",
+	"PARAM_HEARTBEAT_INFO",
 	"",
 	"",
 	"",

net/sctp/outqueue.c

@@ -104,7 +104,7 @@ void sctp_outqueue_init(sctp_association_t *asoc, sctp_outqueue_t *q)
 void sctp_outqueue_teardown(sctp_outqueue_t *q)
 {
 	sctp_transport_t *transport;
-	struct list_head *lchunk, *pos;
+	struct list_head *lchunk, *pos, *temp;
 	sctp_chunk_t *chunk;
 
 	/* Throw away unacknowledged chunks. */
@@ -117,6 +117,13 @@ void sctp_outqueue_teardown(sctp_outqueue_t *q)
 		}
 	}
 
+	/* Throw away chunks that have been gap ACKed.  */
+	list_for_each_safe(lchunk, temp, &q->sacked) {
+		list_del(lchunk);
+		chunk = list_entry(lchunk, sctp_chunk_t, transmitted_list);
+		sctp_free_chunk(chunk);
+	}
+
 	/* Throw away any leftover chunks. */
 	while ((chunk = (sctp_chunk_t *) skb_dequeue(&q->out)))
 		sctp_free_chunk(chunk);

net/sctp/sm_make_chunk.c

@@ -223,7 +223,7 @@ sctp_chunk_t *sctp_make_init(const sctp_association_t *asoc,
 
 sctp_chunk_t *sctp_make_init_ack(const sctp_association_t *asoc,
 				 const sctp_chunk_t *chunk,
-				 int priority)
+				 int priority, int unkparam_len)
 {
 	sctp_inithdr_t initack;
 	sctp_chunk_t *retval;
@@ -278,7 +278,10 @@ sctp_chunk_t *sctp_make_init_ack(const sctp_association_t *asoc,
 	if (!cookie)
 		goto nomem_cookie;
 
-	chunksize = sizeof(initack) + addrs_len + cookie_len;
+	/* Calculate the total size of allocation, include the reserved
+	 * space for reporting unknown parameters if it is specified.
+	 */
+	chunksize = sizeof(initack) + addrs_len + cookie_len + unkparam_len;
 
         /* Tell peer that we'll do ECN only if peer advertised such cap.  */
 	if (asoc->peer.ecn_capable)
@@ -883,25 +886,27 @@ sctp_chunk_t *sctp_make_heartbeat_ack(const sctp_association_t *asoc,
 	return retval;
 }
 
-/* Create an Operation Error chunk.  */
-sctp_chunk_t *sctp_make_op_error(const sctp_association_t *asoc,
+/* Create an Operation Error chunk with the specified space reserved.
+ * This routine can be used for containing multiple causes in the chunk.
+ */
+sctp_chunk_t *sctp_make_op_error_space(const sctp_association_t *asoc,
 				       const sctp_chunk_t *chunk,
-				 __u16 cause_code, const void *payload,
-				 size_t paylen)
+				       size_t size)
 {
-	sctp_chunk_t *retval = sctp_make_chunk(asoc, SCTP_CID_ERROR, 0,
-					       sizeof(sctp_errhdr_t) + paylen);
+	sctp_chunk_t *retval;
 
+	retval = sctp_make_chunk(asoc, SCTP_CID_ERROR, 0,
+				 sizeof(sctp_errhdr_t) + size);
 	if (!retval)
 		goto nodata;
-	sctp_init_cause(retval, cause_code, payload, paylen);
 
 	/* RFC 2960 6.4 Multi-homed SCTP Endpoints
 	 *
 	 * An endpoint SHOULD transmit reply chunks (e.g., SACK,
-	 * HEARTBEAT ACK, * etc.) to the same destination transport
-	 * address from which it * received the DATA or control chunk
+	 * HEARTBEAT ACK, etc.) to the same destination transport
+	 * address from which it received the DATA or control chunk
 	 * to which it is replying.
+	 *
 	 */
 	if (chunk)
 		retval->transport = chunk->transport;
@@ -910,6 +915,23 @@ sctp_chunk_t *sctp_make_op_error(const sctp_association_t *asoc,
 	return retval;
 }
 
+/* Create an Operation Error chunk.  */
+sctp_chunk_t *sctp_make_op_error(const sctp_association_t *asoc,
+				 const sctp_chunk_t *chunk,
+				 __u16 cause_code, const void *payload,
+				 size_t paylen)
+{
+	sctp_chunk_t *retval = sctp_make_op_error_space(asoc, chunk, paylen);
+
+	if (!retval)
+		goto nodata;
+
+	sctp_init_cause(retval, cause_code, payload, paylen);
+
+nodata:
+	return retval;
+}
+
 /********************************************************************
  * 2nd Level Abstractions
  ********************************************************************/
@@ -1405,6 +1427,162 @@ sctp_association_t *sctp_unpack_cookie(const sctp_endpoint_t *ep,
  * 3rd Level Abstractions
  ********************************************************************/
 
+/* Verify the INIT packet before we process it.  */
+int sctp_verify_init(const sctp_association_t *asoc,
+		     sctp_cid_t cid,
+		     sctp_init_chunk_t *peer_init,
+		     sctp_chunk_t *chunk,
+		     sctp_chunk_t **err_chk_p)
+{
+	sctpParam_t param;
+	uint8_t *end;
+
+	/* FIXME - Verify the fixed fields of the INIT chunk. Also, verify
+	 * the mandatory parameters somewhere here and generate either the
+	 * "Missing mandatory parameter" error or the "Invalid mandatory
+	 * parameter" error. */
+
+	/* Find unrecognized parameters. */
+
+	end = ((uint8_t *)peer_init + ntohs(peer_init->chunk_hdr.length));
+
+	for (param.v = peer_init->init_hdr.params;
+	     param.v < end;
+	     param.v += WORD_ROUND(ntohs(param.p->length))) {
+
+		if (!sctp_verify_param(asoc, param, cid, chunk, err_chk_p))
+			return 0;
+
+	} /* for (loop through all parameters) */
+	 
+	return 1;
+}
+
+
+/* Find unrecognized parameters in the chunk.
+ * Return values:
+ * 	0 - discard the chunk
+ * 	1 - continue with the chunk
+ */
+int sctp_verify_param(const sctp_association_t *asoc,
+		      sctpParam_t param,
+		      sctp_cid_t cid,
+		      sctp_chunk_t *chunk,
+		      sctp_chunk_t **err_chk_p)
+{
+	int retval = 1;
+
+	/* FIXME - This routine is not looking at each parameter per the
+	 * chunk type, i.e., unrecognized parameters should be further
+	 * identified based on the chunk id.
+	 */
+
+	switch (param.p->type) {
+	case SCTP_PARAM_IPV4_ADDRESS:
+	case SCTP_PARAM_IPV6_ADDRESS:
+	case SCTP_PARAM_COOKIE_PRESERVATIVE:
+	/* FIXME - If we don't support the host name parameter, we should
+	 * generate an error for this - Unresolvable address.
+	 */
+	case SCTP_PARAM_HOST_NAME_ADDRESS:
+	case SCTP_PARAM_SUPPORTED_ADDRESS_TYPES:
+	case SCTP_PARAM_STATE_COOKIE:
+	case SCTP_PARAM_HEARTBEAT_INFO:
+	case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
+	case SCTP_PARAM_ECN_CAPABLE:
+		break;
+	default:
+		SCTP_DEBUG_PRINTK("Unrecognized param: %d for chunk %d.\n",
+				ntohs(param.p->type), cid);
+		return sctp_process_unk_param(asoc, param, chunk, err_chk_p);
+
+		break;
+	}
+	return retval;
+}
+
+/* RFC 3.2.1 & the Implementers Guide 2.2.
+ *
+ * The Parameter Types are encoded such that the
+ * highest-order two bits specify the action that must be
+ * taken if the processing endpoint does not recognize the
+ * Parameter Type.
+ *
+ * 00 - Stop processing this SCTP chunk and discard it,
+ *	do not process any further chunks within it.
+ *
+ * 01 - Stop processing this SCTP chunk and discard it,
+ *	do not process any further chunks within it, and report
+ *	the unrecognized parameter in an 'Unrecognized
+ *	Parameter Type' (in either an ERROR or in the INIT ACK).
+ *
+ * 10 - Skip this parameter and continue processing.
+ *
+ * 11 - Skip this parameter and continue processing but
+ *	report the unrecognized parameter in an
+ *	'Unrecognized Parameter Type' (in either an ERROR or in
+ *	the INIT ACK).
+ *
+ * Return value:
+ * 	0 - discard the chunk
+ * 	1 - continue with the chunk
+ */
+int sctp_process_unk_param(const sctp_association_t *asoc,
+			   sctpParam_t param,
+			   sctp_chunk_t *chunk,
+			   sctp_chunk_t **err_chk_p)
+{
+	int retval = 1;
+
+	switch (param.p->type & SCTP_PARAM_ACTION_MASK) {
+	case SCTP_PARAM_ACTION_DISCARD:
+		retval =  0;
+		break;
+	case SCTP_PARAM_ACTION_DISCARD_ERR:
+		retval =  0;
+		/* Make an ERROR chunk, preparing enough room for
+		 * returning multiple unknown parameters.
+		 */
+		if (NULL == *err_chk_p)
+			*err_chk_p = sctp_make_op_error_space(asoc, chunk,
+					ntohs(chunk->chunk_hdr->length));
+
+		if (*err_chk_p)
+			sctp_init_cause(*err_chk_p, SCTP_ERROR_UNKNOWN_PARAM,
+					(const void *)param.p,
+					WORD_ROUND(ntohs(param.p->length)));
+
+		break;
+	case SCTP_PARAM_ACTION_SKIP:
+		break;
+	case SCTP_PARAM_ACTION_SKIP_ERR:
+		/* Make an ERROR chunk, preparing enough room for
+		 * returning multiple unknown parameters.
+		 */
+		if (NULL == *err_chk_p)
+			*err_chk_p = sctp_make_op_error_space(asoc, chunk,
+					ntohs(chunk->chunk_hdr->length));
+
+		if (*err_chk_p) {
+			sctp_init_cause(*err_chk_p, SCTP_ERROR_UNKNOWN_PARAM,
+					(const void *)param.p,
+					WORD_ROUND(ntohs(param.p->length)));
+		} else {
+			/* If there is no memory for generating the ERROR
+			 * report as specified, an ABORT will be triggered
+			 * to the peer and the association won't be established.
+			 */
+			retval = 0;
+		}
+
+		break;
+	default:
+		break;
+	}
+
+	return retval;
+}
+
 /* Unpack the parameters in an INIT packet.
  * FIXME:  There is no return status to allow callers to do
  * error handling.
@@ -1609,9 +1787,9 @@ int sctp_process_param(sctp_association_t *asoc, sctpParam_t param,
 		asoc->peer.cookie = param.cookie->body;
 		break;
 
-	case SCTP_PARAM_HEATBEAT_INFO:
+	case SCTP_PARAM_HEARTBEAT_INFO:
 		SCTP_DEBUG_PRINTK("unimplemented "
-				  "SCTP_PARAM_HEATBEAT_INFO\n");
+				  "SCTP_PARAM_HEARTBEAT_INFO\n");
 		break;
 
 	case SCTP_PARAM_UNRECOGNIZED_PARAMETERS:
@@ -1624,14 +1802,13 @@ int sctp_process_param(sctp_association_t *asoc, sctpParam_t param,
 		break;
 
 	default:
+		/* Any unrecognized parameters should have been caught
+		 * and handled by sctp_verify_param() which should be
+		 * called prior to this routine.  Simply log the error
+		 * here.
+		 */
 		SCTP_DEBUG_PRINTK("Ignoring param: %d for association %p.\n",
 				  ntohs(param.p->type), asoc);
-		/* FIXME:  The entire parameter processing really needs
-		 * redesigned.  For now, always return success as doing
-		 * otherwise craters the system.
-		 */
-		retval = 1;
-
 		break;
 	};
 

net/sctp/sm_sideeffect.c

@@ -327,7 +327,8 @@ int sctp_cmd_interpreter(sctp_event_t event_type, sctp_subtype_t subtype,
 
 		case SCTP_CMD_GEN_INIT_ACK:
 			/* Generate an INIT ACK chunk.  */
-			new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC);
+			new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,
+						     0);
 			if (!new_obj)
 				goto nomem;
 
@@ -344,10 +345,20 @@ int sctp_cmd_interpreter(sctp_event_t event_type, sctp_subtype_t subtype,
 		case SCTP_CMD_GEN_COOKIE_ECHO:
 			/* Generate a COOKIE ECHO chunk.  */
 			new_obj = sctp_make_cookie_echo(asoc, chunk);
-			if (!new_obj)
+			if (!new_obj) {
+				if (command->obj.ptr)
+					sctp_free_chunk(command->obj.ptr);
 				goto nomem;
+			}
 			sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
 					SCTP_CHUNK(new_obj));
+
+			/* If there is an ERROR chunk to be sent along with
+			 * the COOKIE_ECHO, send it, too.
+			 */
+			if (command->obj.ptr)
+				sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
+						SCTP_CHUNK(command->obj.ptr));
 			break;
 
 		case SCTP_CMD_GEN_SHUTDOWN:
@@ -397,8 +408,7 @@ int sctp_cmd_interpreter(sctp_event_t event_type, sctp_subtype_t subtype,
 			/* Send a full packet to our peer.  */
 			packet = command->obj.ptr;
 			sctp_packet_transmit(packet);
-			sctp_transport_free(packet->transport);
-			sctp_packet_free(packet);
+			sctp_ootb_pkt_free(packet);
 			break;
 
 		case SCTP_CMD_RETRAN:

net/sctp/socket.c

@@ -73,8 +73,12 @@
 #include <net/sock.h>
 #include <net/sctp/sctp.h>
 
+/* WARNING:  Please do not remove the SCTP_STATIC attribute to
+ * any of the functions below as they are used to export functions
+ * used by a project regression testsuite.
+ */
+
 /* Forward declarations for internal helper functions. */
-static void __sctp_write_space(sctp_association_t *asoc);
 static int sctp_writeable(struct sock *sk);
 static inline int sctp_wspace(sctp_association_t *asoc);
 static inline void sctp_set_owner_w(sctp_chunk_t *chunk);
@@ -92,8 +96,7 @@ static int sctp_bindx_add(struct sock *, struct sockaddr_storage *, int);
 static int sctp_bindx_rem(struct sock *, struct sockaddr_storage *, int);
 static int sctp_do_bind(struct sock *, sockaddr_storage_t *, int);
 static int sctp_autobind(struct sock *sk);
-static sctp_bind_bucket_t *sctp_bucket_create(sctp_bind_hashbucket_t *head,
-					      unsigned short snum);
+
 
 /* API 3.1.2 bind() - UDP Style Syntax
  * The syntax of bind() is,
@@ -132,7 +135,8 @@ int sctp_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
 static long sctp_get_port_local(struct sock *, unsigned short);
 
 /* Bind a local address either to an endpoint or to an association.  */
-static int sctp_do_bind(struct sock *sk, sockaddr_storage_t *newaddr, int addr_len)
+SCTP_STATIC int sctp_do_bind(struct sock *sk, sockaddr_storage_t *newaddr,
+			     int addr_len)
 {
 	sctp_opt_t *sp = sctp_sk(sk);
 	sctp_endpoint_t *ep = sp->ep;
@@ -603,7 +607,7 @@ int sctp_bindx_rem(struct sock *sk, struct sockaddr_storage *addrs, int addrcnt)
  *
  * Returns 0 if ok, <0 errno code on error.
  */
-static int sctp_setsockopt_bindx(struct sock* sk,
+SCTP_STATIC int sctp_setsockopt_bindx(struct sock* sk,
 				      struct sockaddr_storage *addrs,
 				      int addrssize, int op)
 {
@@ -659,7 +663,7 @@ static int sctp_setsockopt_bindx(struct sock* sk,
  * If sd in the close() call is a branched-off socket representing only
  * one association, the shutdown is performed on that association only.
  */
-static void sctp_close(struct sock *sk, long timeout)
+SCTP_STATIC void sctp_close(struct sock *sk, long timeout)
 {
 	sctp_endpoint_t *ep;
 	sctp_association_t *asoc;
@@ -727,9 +731,9 @@ static void sctp_close(struct sock *sk, long timeout)
 /* BUG:  We do not implement timeouts.  */
 /* BUG:  We do not implement the equivalent of wait_for_tcp_memory(). */
 
-static int sctp_msghdr_parse(const struct msghdr *, sctp_cmsgs_t *);
+SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *, sctp_cmsgs_t *);
 
-static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, int size)
+SCTP_STATIC int sctp_sendmsg(struct sock *sk, struct msghdr *msg, int size)
 {
 	sctp_opt_t *sp;
 	sctp_endpoint_t *ep;
@@ -1094,7 +1098,7 @@ static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, int size)
  */
 static struct sk_buff *sctp_skb_recv_datagram(struct sock *, int, int, int *);
 
-static int sctp_recvmsg(struct sock *sk, struct msghdr *msg, int len,
+SCTP_STATIC int sctp_recvmsg(struct sock *sk, struct msghdr *msg, int len,
 			     int noblock, int flags, int *addr_len)
 {
 	sctp_ulpevent_t *event = NULL;
@@ -1229,7 +1233,7 @@ static inline int sctp_setsockopt_autoclose(struct sock *sk, char *optval,
  *   optval  - the buffer to store the value of the option.
  *   optlen  - the size of the buffer.
  */
-static int sctp_setsockopt(struct sock *sk, int level, int optname,
+SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname,
 			   char *optval, int optlen)
 {
 	int retval = 0;
@@ -1313,19 +1317,20 @@ static int sctp_setsockopt(struct sock *sk, int level, int optname,
 }
 
 /* FIXME: Write comments. */
-static int sctp_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
+SCTP_STATIC int sctp_connect(struct sock *sk, struct sockaddr *uaddr,
+			     int addr_len)
 {
 	return -EOPNOTSUPP; /* STUB */
 }
 
 /* FIXME: Write comments. */
-static int sctp_disconnect(struct sock *sk, int flags)
+SCTP_STATIC int sctp_disconnect(struct sock *sk, int flags)
 {
 	return -EOPNOTSUPP; /* STUB */
 }
 
 /* FIXME: Write comments. */
-static struct sock *sctp_accept(struct sock *sk, int flags, int *err)
+SCTP_STATIC struct sock *sctp_accept(struct sock *sk, int flags, int *err)
 {
 	int error = -EOPNOTSUPP;
 
@@ -1334,7 +1339,7 @@ static struct sock *sctp_accept(struct sock *sk, int flags, int *err)
 }
 
 /* FIXME: Write Comments. */
-static int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)
+SCTP_STATIC int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)
 {
 	return -EOPNOTSUPP; /* STUB */
 }
@@ -1343,7 +1348,7 @@ static int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)
  * initialized the SCTP-specific portion of the sock.
  * The sock structure should already be zero-filled memory.
  */
-static int sctp_init_sock(struct sock *sk)
+SCTP_STATIC int sctp_init_sock(struct sock *sk)
 {
 	sctp_endpoint_t *ep;
 	sctp_protocol_t *proto;
@@ -1428,7 +1433,7 @@ static int sctp_init_sock(struct sock *sk)
 }
 
 /* Cleanup any SCTP per socket resources.  */
-static int sctp_destroy_sock(struct sock *sk)
+SCTP_STATIC int sctp_destroy_sock(struct sock *sk)
 {
 	sctp_endpoint_t *ep;
 
@@ -1442,7 +1447,7 @@ static int sctp_destroy_sock(struct sock *sk)
 }
 
 /* FIXME: Comments needed.  */
-static void sctp_shutdown(struct sock *sk, int how)
+SCTP_STATIC void sctp_shutdown(struct sock *sk, int how)
 {
 	/* UDP-style sockets do not support shutdown. */
 	/* STUB */
@@ -1563,7 +1568,7 @@ static inline int sctp_getsockopt_autoclose(struct sock *sk, int len, char *optv
 }
 
 /* Helper routine to branch off an association to a new socket.  */
-static int sctp_do_peeloff(sctp_association_t *assoc, struct socket **newsock)
+SCTP_STATIC int sctp_do_peeloff(sctp_association_t *assoc, struct socket **newsock)
 {
 	struct sock *oldsk = assoc->base.sk;
 	struct sock *newsk;
@@ -1652,7 +1657,7 @@ static inline int sctp_getsockopt_peeloff(struct sock *sk, int len, char *optval
 	return 0;
 }
 
-static int sctp_getsockopt(struct sock *sk, int level, int optname,
+SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
 				char *optval, int *optlen)
 {
 	int retval = 0;
@@ -1734,6 +1739,8 @@ static void sctp_unhash(struct sock *sk)
  * link to the socket (struct sock) that uses it, the port number and
  * a fastreuse flag (FIXME: NPI ipg).
  */
+static sctp_bind_bucket_t *sctp_bucket_create(sctp_bind_hashbucket_t *head,
+					      unsigned short snum);
 static long sctp_get_port_local(struct sock *sk, unsigned short snum)
 {
 	sctp_bind_hashbucket_t *head; /* hash list */
@@ -1927,7 +1934,7 @@ static int sctp_get_port(struct sock *sk, unsigned short snum)
  *   An application uses listen() to mark a socket as being able to
  *   accept new associations.
  */
-static int sctp_seqpacket_listen(struct sock *sk, int backlog)
+SCTP_STATIC int sctp_seqpacket_listen(struct sock *sk, int backlog)
 {
 	sctp_opt_t *sp = sctp_sk(sk);
 	sctp_endpoint_t *ep = sp->ep;
@@ -2184,7 +2191,8 @@ static int sctp_autobind(struct sock *sk)
  * msg_control
  * points here
  */
-static int sctp_msghdr_parse(const struct msghdr *msg, sctp_cmsgs_t *cmsgs)
+SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *msg,
+				  sctp_cmsgs_t *cmsgs)
 {
 	struct cmsghdr *cmsg;
 
@@ -2500,6 +2508,31 @@ static inline void sctp_set_owner_w(sctp_chunk_t *chunk)
 	sk->wmem_queued += SCTP_DATA_SNDSIZE(chunk);
 }
 
+/* If sndbuf has changed, wake up per association sndbuf waiters.  */
+static void __sctp_write_space(sctp_association_t *asoc)
+{
+	struct sock *sk = asoc->base.sk;
+	struct socket *sock = sk->socket;
+
+	if ((sctp_wspace(asoc) > 0) && sock) {
+		if (waitqueue_active(&asoc->wait))
+			wake_up_interruptible(&asoc->wait);
+
+		if (sctp_writeable(sk)) {
+			if (sk->sleep && waitqueue_active(sk->sleep))
+				wake_up_interruptible(sk->sleep);
+
+			/* Note that we try to include the Async I/O support
+			 * here by modeling from the current TCP/UDP code.
+			 * We have not tested with it yet.
+			 */
+			if (sock->fasync_list &&
+			    !(sk->shutdown & SEND_SHUTDOWN))
+				sock_wake_async(sock, 2, POLL_OUT);
+		}
+	}
+}
+
 /* Do accounting for the sndbuf space.
  * Decrement the used sndbuf space of the corresponding association by the
  * data size which was just transmitted(freed).
@@ -2522,7 +2555,8 @@ static void sctp_wfree(struct sk_buff *skb)
 }
 
 /* Helper function to wait for space in the sndbuf.  */
-static int sctp_wait_for_sndbuf(sctp_association_t *asoc, long *timeo_p, int msg_len)
+static int sctp_wait_for_sndbuf(sctp_association_t *asoc, long *timeo_p,
+				int msg_len)
 {
 	struct sock *sk = asoc->base.sk;
 	int err = 0;
@@ -2581,31 +2615,6 @@ static int sctp_wait_for_sndbuf(sctp_association_t *asoc, long *timeo_p, int msg
 	goto out;
 }
 
-/* If sndbuf has changed, wake up per association sndbuf waiters.  */
-static void __sctp_write_space(sctp_association_t *asoc)
-{
-	struct sock *sk = asoc->base.sk;
-	struct socket *sock = sk->socket;
-
-	if ((sctp_wspace(asoc) > 0) && sock) {
-		if (waitqueue_active(&asoc->wait))
-			wake_up_interruptible(&asoc->wait);
-
-		if (sctp_writeable(sk)) {
-			if (sk->sleep && waitqueue_active(sk->sleep))
-				wake_up_interruptible(sk->sleep);
-
-			/* Note that we try to include the Async I/O support
-			 * here by modeling from the current TCP/UDP code.
-			 * We have not tested with it yet.
-			 */
-			if (sock->fasync_list &&
-			    !(sk->shutdown & SEND_SHUTDOWN))
-				sock_wake_async(sock, 2, POLL_OUT);
-		}
-	}
-}
-
 /* If socket sndbuf has changed, wake up all per association waiters.  */
 void sctp_write_space(struct sock *sk)
 {