[SCTP] Supported address types should be based on pf_family.

PF_INET sockets are advertising v6 address support.  Make this
choice a pf_family function. 

include/net/sctp/sctp.h

@@ -323,7 +323,8 @@ static inline int sctp_ipv6_addr_type(const struct in6_addr *addr)
 	return ipv6_addr_type((struct in6_addr*) addr);
 }
 
-#define SCTP_SAT_LEN (sizeof(sctp_paramhdr_t) + 2 * sizeof(__u16))
+/* Size of Supported Address Parameter for 'x' address types. */
+#define SCTP_SAT_LEN(x) (sizeof(struct sctp_paramhdr) + (x) * sizeof(__u16))
 
 /* Note: These V6 macros are obsolescent.  */
 /* Use this macro to enclose code fragments which are V6-dependent. */

include/net/sctp/structs.h

@@ -293,6 +293,7 @@ struct sctp_pf {
 			  const union sctp_addr *,
 			  struct sctp_opt *);
 	int  (*bind_verify) (struct sctp_opt *, union sctp_addr *);
+	int  (*supported_addrs)(const struct sctp_opt *, __u16 *);
 	struct sctp_af *af;
 };
 
@@ -397,8 +398,6 @@ typedef struct sctp_signed_cookie {
 	sctp_cookie_t c;
 } sctp_signed_cookie_t;
 
-
-
 /* This is another convenience type to allocate memory for address
  * params for the maximum size and pass such structures around
  * internally.

net/sctp/ipv6.c

@@ -565,6 +565,20 @@ static int sctp_inet6_bind_verify(struct sctp_opt *opt, union sctp_addr *addr)
 	return af->available(addr);
 }
 
+/* Fill in Supported Address Type information for INIT and INIT-ACK
+ * chunks.   Note: In the future, we may want to look at sock options
+ * to determine whether a PF_INET6 socket really wants to have IPV4
+ * addresses.  
+ * Returns number of addresses supported.
+ */
+static int sctp_inet6_supported_addrs(const struct sctp_opt *opt,
+				      __u16 *types) 
+{
+	types[0] = SCTP_PARAM_IPV4_ADDRESS;
+	types[1] = SCTP_PARAM_IPV6_ADDRESS;
+	return 2;
+}
+
 static struct proto_ops inet6_seqpacket_ops = {
 	.family     = PF_INET6,
 	.release    = inet6_release,
@@ -627,6 +641,7 @@ static struct sctp_pf sctp_pf_inet6_specific = {
 	.af_supported  = sctp_inet6_af_supported,
 	.cmp_addr      = sctp_inet6_cmp_addr,
 	.bind_verify   = sctp_inet6_bind_verify,
+	.supported_addrs = sctp_inet6_supported_addrs,
 	.af            = &sctp_ipv6_specific,
 };
 

net/sctp/protocol.c

@@ -631,6 +631,16 @@ static int sctp_inet_bind_verify(struct sctp_opt *opt, union sctp_addr *addr)
 	return sctp_v4_available(addr);
 }
 
+/* Fill in Supported Address Type information for INIT and INIT-ACK
+ * chunks.  Returns number of addresses supported.
+ */
+static int sctp_inet_supported_addrs(const struct sctp_opt *opt, 
+				     __u16 *types)
+{
+	types[0] = SCTP_PARAM_IPV4_ADDRESS;
+	return 1;
+}
+
 /* Wrapper routine that calls the ip transmit routine. */
 static inline int sctp_v4_xmit(struct sk_buff *skb,
 			       struct sctp_transport *transport, int ipfragok)
@@ -653,6 +663,7 @@ static struct sctp_pf sctp_pf_inet = {
 	.af_supported  = sctp_inet_af_supported,
 	.cmp_addr      = sctp_inet_cmp_addr,
 	.bind_verify   = sctp_inet_bind_verify,
+	.supported_addrs = sctp_inet_supported_addrs,
 	.af            = &sctp_ipv4_specific,
 };
 

net/sctp/sm_make_chunk.c

@@ -66,29 +66,6 @@
 #include <net/sctp/sctp.h>
 #include <net/sctp/sm.h>
 
-/* RFC 2960 3.3.2 Initiation (INIT) (1)
- *
- * Note 4: This parameter, when present, specifies all the
- * address types the sending endpoint can support. The absence
- * of this parameter indicates that the sending endpoint can
- * support any address type.
- */
-static const sctp_supported_addrs_param_t sat_param = {
-	{
-		SCTP_PARAM_SUPPORTED_ADDRESS_TYPES,
-		__constant_htons(SCTP_SAT_LEN),
-	}
-};
-
-/* gcc 3.2 doesn't allow initialization of zero-length arrays. So the above
- * structure is split and the address types array is initialized using a
- * fixed length array.
- */
-static const __u16 sat_addr_types[2] = {
-	SCTP_PARAM_IPV4_ADDRESS,
-	SCTP_V6(SCTP_PARAM_IPV6_ADDRESS,)
-};
-
 /* RFC 2960 3.3.2 Initiation (INIT) (1)
  *
  * Note 2: The ECN capable field is reserved for future use of
@@ -174,7 +151,10 @@ sctp_chunk_t *sctp_make_init(const sctp_association_t *asoc,
 	union sctp_params addrs;
 	size_t chunksize;
 	sctp_chunk_t *retval = NULL;
-	int addrs_len = 0;
+	int num_types, addrs_len = 0;
+	struct sctp_opt *sp;
+	sctp_supported_addrs_param_t sat;
+	__u16 types[2];
 
 	/* RFC 2960 3.3.2 Initiation (INIT) (1)
 	 *
@@ -195,7 +175,11 @@ sctp_chunk_t *sctp_make_init(const sctp_association_t *asoc,
 	init.num_inbound_streams   = htons(asoc->c.sinit_max_instreams);
 	init.initial_tsn	   = htonl(asoc->c.initial_tsn);
 
-	chunksize = sizeof(init) + addrs_len + SCTP_SAT_LEN;
+	/* How many address types are needed? */
+	sp = sctp_sk(asoc->base.sk);
+	num_types = sp->pf->supported_addrs(sp, types);
+
+	chunksize = sizeof(init) + addrs_len + SCTP_SAT_LEN(num_types);
 	chunksize += sizeof(ecap_param);
 	chunksize += vparam_len;
 
@@ -220,8 +204,18 @@ sctp_chunk_t *sctp_make_init(const sctp_association_t *asoc,
 	retval->param_hdr.v =
 		sctp_addto_chunk(retval, addrs_len, addrs.v);
 
-	sctp_addto_chunk(retval, sizeof(sctp_paramhdr_t), &sat_param);
-	sctp_addto_chunk(retval, sizeof(sat_addr_types), sat_addr_types);
+	/* RFC 2960 3.3.2 Initiation (INIT) (1)
+	 *
+	 * Note 4: This parameter, when present, specifies all the
+	 * address types the sending endpoint can support. The absence
+	 * of this parameter indicates that the sending endpoint can
+	 * support any address type.
+	 */
+	sat.param_hdr.type = SCTP_PARAM_SUPPORTED_ADDRESS_TYPES;
+	sat.param_hdr.length = htons(SCTP_SAT_LEN(num_types));
+	sctp_addto_chunk(retval, sizeof(sat), &sat);
+	sctp_addto_chunk(retval, num_types * sizeof(__u16), &types);
+
 	sctp_addto_chunk(retval, sizeof(ecap_param), &ecap_param);
 nodata:
 	if (addrs.v)