Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5477f7f3 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'sctp-remove-typedefs-from-structures-part-4' 



Xin Long says:

====================
sctp: remove typedefs from structures part 4

As we know, typedef is suggested not to use in kernel, even checkpatch.pl
also gives warnings about it. Now sctp is using it for many structures.

All this kind of typedef's using should be removed. This patchset is the
part 4 to remove it for another 14 basic structures from linux/sctp.h.
After this patchset, all typedefs are cleaned in linux/sctp.h.

Just as the part 1-3, No any code's logic would be changed in these patches,
only cleaning up.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents ddb08042 bb96dec7

include/linux/sctp.h

+32 −37
Original line number Diff line number Diff line
@@ -416,27 +416,27 @@ struct sctp_abort_chunk { 
/* For the graceful shutdown we must carry the tag (in common header)

 * and the highest consecutive acking value.

 */

typedef struct sctp_shutdownhdr {

struct sctp_shutdownhdr {

	__be32 cum_tsn_ack;

} sctp_shutdownhdr_t;

};



struct sctp_shutdown_chunk_t {

struct sctp_shutdown_chunk {

	struct sctp_chunkhdr chunk_hdr;

	sctp_shutdownhdr_t shutdown_hdr;

	struct sctp_shutdownhdr shutdown_hdr;

};



/* RFC 2960.  Section 3.3.10 Operation Error (ERROR) (9) */



typedef struct sctp_errhdr {

struct sctp_errhdr {

	__be16 cause;

	__be16 length;

	__u8  variable[0];

} sctp_errhdr_t;

};



typedef struct sctp_operr_chunk {

struct sctp_operr_chunk {

	struct sctp_chunkhdr chunk_hdr;

	sctp_errhdr_t err_hdr;

} sctp_operr_chunk_t;

	struct sctp_errhdr err_hdr;

};



/* RFC 2960 3.3.10 - Operation Error

 *
@@ -457,7 +457,7 @@ typedef struct sctp_operr_chunk { 
 *      9              No User Data

 *     10              Cookie Received While Shutting Down

 */

typedef enum {

enum sctp_error {



	SCTP_ERROR_NO_ERROR	   = cpu_to_be16(0x00),

	SCTP_ERROR_INV_STRM	   = cpu_to_be16(0x01),
@@ -512,33 +512,28 @@ typedef enum { 
	 * 0x0105          Unsupported HMAC Identifier

	 */

	 SCTP_ERROR_UNSUP_HMAC	= cpu_to_be16(0x0105)

} sctp_error_t;

};







/* RFC 2960.  Appendix A.  Explicit Congestion Notification.

 *   Explicit Congestion Notification Echo (ECNE) (12)

 */

typedef struct sctp_ecnehdr {

struct sctp_ecnehdr {

	__be32 lowest_tsn;

} sctp_ecnehdr_t;

};



typedef struct sctp_ecne_chunk {

struct sctp_ecne_chunk {

	struct sctp_chunkhdr chunk_hdr;

	sctp_ecnehdr_t ence_hdr;

} sctp_ecne_chunk_t;

	struct sctp_ecnehdr ence_hdr;

};



/* RFC 2960.  Appendix A.  Explicit Congestion Notification.

 *   Congestion Window Reduced (CWR) (13)

 */

typedef struct sctp_cwrhdr {

struct sctp_cwrhdr {

	__be32 lowest_tsn;

} sctp_cwrhdr_t;



typedef struct sctp_cwr_chunk {

	struct sctp_chunkhdr chunk_hdr;

	sctp_cwrhdr_t cwr_hdr;

} sctp_cwr_chunk_t;

};



/* PR-SCTP

 * 3.2 Forward Cumulative TSN Chunk Definition (FORWARD TSN)
@@ -634,20 +629,20 @@ struct sctp_fwdtsn_chunk { 
 *	The ASCONF Parameter Response is used in the ASCONF-ACK to

 *	report status of ASCONF processing.

 */

typedef struct sctp_addip_param {

struct sctp_addip_param {

	struct sctp_paramhdr param_hdr;

	__be32 crr_id;

} sctp_addip_param_t;

};



typedef struct sctp_addiphdr {

struct sctp_addiphdr {

	__be32	serial;

	__u8	params[0];

} sctp_addiphdr_t;

};



typedef struct sctp_addip_chunk {

struct sctp_addip_chunk {

	struct sctp_chunkhdr chunk_hdr;

	sctp_addiphdr_t addip_hdr;

} sctp_addip_chunk_t;

	struct sctp_addiphdr addip_hdr;

};



/* AUTH

 * Section 4.1  Authentication Chunk (AUTH)
@@ -698,16 +693,16 @@ typedef struct sctp_addip_chunk { 
 *   HMAC: n bytes (unsigned integer) This hold the result of the HMAC

 *      calculation.

 */

typedef struct sctp_authhdr {

struct sctp_authhdr {

	__be16 shkey_id;

	__be16 hmac_id;

	__u8   hmac[0];

} sctp_authhdr_t;

};



typedef struct sctp_auth_chunk {

struct sctp_auth_chunk {

	struct sctp_chunkhdr chunk_hdr;

	sctp_authhdr_t auth_hdr;

} sctp_auth_chunk_t;

	struct sctp_authhdr auth_hdr;

};



struct sctp_infox {

	struct sctp_info *sctpinfo;

include/net/sctp/sctp.h

+4 −4
Original line number Diff line number Diff line
@@ -479,13 +479,13 @@ for (pos.v = chunk->member;\ 
_sctp_walk_errors((err), (chunk_hdr), ntohs((chunk_hdr)->length))



#define _sctp_walk_errors(err, chunk_hdr, end)\

for (err = (sctp_errhdr_t *)((void *)chunk_hdr + \

for (err = (struct sctp_errhdr *)((void *)chunk_hdr + \

	    sizeof(struct sctp_chunkhdr));\

     ((void *)err + offsetof(sctp_errhdr_t, length) + sizeof(err->length) <=\

     ((void *)err + offsetof(struct sctp_errhdr, length) + sizeof(err->length) <=\

      (void *)chunk_hdr + end) &&\

     (void *)err <= (void *)chunk_hdr + end - ntohs(err->length) &&\

     ntohs(err->length) >= sizeof(sctp_errhdr_t); \

     err = (sctp_errhdr_t *)((void *)err + SCTP_PAD4(ntohs(err->length))))

     ntohs(err->length) >= sizeof(struct sctp_errhdr); \

     err = (struct sctp_errhdr *)((void *)err + SCTP_PAD4(ntohs(err->length))))



#define sctp_walk_fwdtsn(pos, chunk)\

_sctp_walk_fwdtsn((pos), (chunk), ntohs((chunk)->chunk_hdr->length) - sizeof(struct sctp_fwdtsn_chunk))

net/sctp/chunk.c

+1 −1
Original line number Diff line number Diff line
@@ -201,7 +201,7 @@ struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc, 
		struct sctp_hmac *hmac_desc = sctp_auth_asoc_get_hmac(asoc);



		if (hmac_desc)

			max_data -= SCTP_PAD4(sizeof(sctp_auth_chunk_t) +

			max_data -= SCTP_PAD4(sizeof(struct sctp_auth_chunk) +

					      hmac_desc->hmac_len);

	}

net/sctp/input.c

+1 −1
Original line number Diff line number Diff line
@@ -1111,7 +1111,7 @@ static struct sctp_association *__sctp_rcv_asconf_lookup( 
					__be16 peer_port,

					struct sctp_transport **transportp)

{

	sctp_addip_chunk_t *asconf = (struct sctp_addip_chunk *)ch;

	struct sctp_addip_chunk *asconf = (struct sctp_addip_chunk *)ch;

	struct sctp_af *af;

	union sctp_addr_param *param;

	union sctp_addr paddr;

net/sctp/sm_make_chunk.c

+62 −57
Original line number Diff line number Diff line
@@ -135,14 +135,14 @@ static const struct sctp_paramhdr prsctp_param = { 
void  sctp_init_cause(struct sctp_chunk *chunk, __be16 cause_code,

		      size_t paylen)

{

	sctp_errhdr_t err;

	struct sctp_errhdr err;

	__u16 len;



	/* Cause code constants are now defined in network order.  */

	err.cause = cause_code;

	len = sizeof(sctp_errhdr_t) + paylen;

	len = sizeof(err) + paylen;

	err.length  = htons(len);

	chunk->subh.err_hdr = sctp_addto_chunk(chunk, sizeof(sctp_errhdr_t), &err);

	chunk->subh.err_hdr = sctp_addto_chunk(chunk, sizeof(err), &err);

}



/* A helper to initialize an op error inside a
@@ -153,19 +153,19 @@ void sctp_init_cause(struct sctp_chunk *chunk, __be16 cause_code, 
static int sctp_init_cause_fixed(struct sctp_chunk *chunk, __be16 cause_code,

		      size_t paylen)

{

	sctp_errhdr_t err;

	struct sctp_errhdr err;

	__u16 len;



	/* Cause code constants are now defined in network order.  */

	err.cause = cause_code;

	len = sizeof(sctp_errhdr_t) + paylen;

	len = sizeof(err) + paylen;

	err.length  = htons(len);



	if (skb_tailroom(chunk->skb) < len)

		return -ENOSPC;

	chunk->subh.err_hdr = sctp_addto_chunk_fixed(chunk,

						     sizeof(sctp_errhdr_t),

						     &err);



	chunk->subh.err_hdr = sctp_addto_chunk_fixed(chunk, sizeof(err), &err);



	return 0;

}

/* 3.3.2 Initiation (INIT) (1)
@@ -663,11 +663,11 @@ struct sctp_chunk *sctp_make_cwr(const struct sctp_association *asoc, 
			    const struct sctp_chunk *chunk)

{

	struct sctp_chunk *retval;

	sctp_cwrhdr_t cwr;

	struct sctp_cwrhdr cwr;



	cwr.lowest_tsn = htonl(lowest_tsn);

	retval = sctp_make_control(asoc, SCTP_CID_ECN_CWR, 0,

				   sizeof(sctp_cwrhdr_t), GFP_ATOMIC);

				   sizeof(cwr), GFP_ATOMIC);



	if (!retval)

		goto nodata;
@@ -697,11 +697,11 @@ struct sctp_chunk *sctp_make_ecne(const struct sctp_association *asoc, 
			     const __u32 lowest_tsn)

{

	struct sctp_chunk *retval;

	sctp_ecnehdr_t ecne;

	struct sctp_ecnehdr ecne;



	ecne.lowest_tsn = htonl(lowest_tsn);

	retval = sctp_make_control(asoc, SCTP_CID_ECN_ECNE, 0,

				   sizeof(sctp_ecnehdr_t), GFP_ATOMIC);

				   sizeof(ecne), GFP_ATOMIC);

	if (!retval)

		goto nodata;

	retval->subh.ecne_hdr =
@@ -857,15 +857,15 @@ struct sctp_chunk *sctp_make_sack(const struct sctp_association *asoc) 
struct sctp_chunk *sctp_make_shutdown(const struct sctp_association *asoc,

				      const struct sctp_chunk *chunk)

{

	struct sctp_shutdownhdr shut;

	struct sctp_chunk *retval;

	sctp_shutdownhdr_t shut;

	__u32 ctsn;



	ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);

	shut.cum_tsn_ack = htonl(ctsn);



	retval = sctp_make_control(asoc, SCTP_CID_SHUTDOWN, 0,

				   sizeof(sctp_shutdownhdr_t), GFP_ATOMIC);

				   sizeof(shut), GFP_ATOMIC);

	if (!retval)

		goto nodata;
@@ -979,8 +979,8 @@ struct sctp_chunk *sctp_make_abort_no_data( 
	struct sctp_chunk *retval;

	__be32 payload;



	retval = sctp_make_abort(asoc, chunk, sizeof(sctp_errhdr_t)

				 + sizeof(tsn));

	retval = sctp_make_abort(asoc, chunk,

				 sizeof(struct sctp_errhdr) + sizeof(tsn));



	if (!retval)

		goto no_mem;
@@ -1015,7 +1015,8 @@ struct sctp_chunk *sctp_make_abort_user(const struct sctp_association *asoc, 
	void *payload = NULL;

	int err;



	retval = sctp_make_abort(asoc, NULL, sizeof(sctp_errhdr_t) + paylen);

	retval = sctp_make_abort(asoc, NULL,

				 sizeof(struct sctp_errhdr) + paylen);

	if (!retval)

		goto err_chunk;
@@ -1080,8 +1081,8 @@ struct sctp_chunk *sctp_make_abort_violation( 
	struct sctp_chunk  *retval;

	struct sctp_paramhdr phdr;



	retval = sctp_make_abort(asoc, chunk, sizeof(sctp_errhdr_t) + paylen +

					      sizeof(phdr));

	retval = sctp_make_abort(asoc, chunk, sizeof(struct sctp_errhdr) +

					      paylen + sizeof(phdr));

	if (!retval)

		goto end;
@@ -1104,7 +1105,7 @@ struct sctp_chunk *sctp_make_violation_paramlen( 
{

	struct sctp_chunk *retval;

	static const char error[] = "The following parameter had invalid length:";

	size_t payload_len = sizeof(error) + sizeof(sctp_errhdr_t) +

	size_t payload_len = sizeof(error) + sizeof(struct sctp_errhdr) +

			     sizeof(*param);



	retval = sctp_make_abort(asoc, chunk, payload_len);
@@ -1126,7 +1127,7 @@ struct sctp_chunk *sctp_make_violation_max_retrans( 
{

	struct sctp_chunk *retval;

	static const char error[] = "Association exceeded its max_retans count";

	size_t payload_len = sizeof(error) + sizeof(sctp_errhdr_t);

	size_t payload_len = sizeof(error) + sizeof(struct sctp_errhdr);



	retval = sctp_make_abort(asoc, chunk, payload_len);

	if (!retval)
@@ -1209,7 +1210,8 @@ static struct sctp_chunk *sctp_make_op_error_space( 
	struct sctp_chunk *retval;



	retval = sctp_make_control(asoc, SCTP_CID_ERROR, 0,

				   sizeof(sctp_errhdr_t) + size, GFP_ATOMIC);

				   sizeof(struct sctp_errhdr) + size,

				   GFP_ATOMIC);

	if (!retval)

		goto nodata;
@@ -1280,7 +1282,7 @@ struct sctp_chunk *sctp_make_auth(const struct sctp_association *asoc) 
		return NULL;



	retval = sctp_make_control(asoc, SCTP_CID_AUTH, 0,

			hmac_desc->hmac_len + sizeof(sctp_authhdr_t),

				   hmac_desc->hmac_len + sizeof(auth_hdr),

				   GFP_ATOMIC);

	if (!retval)

		return NULL;
@@ -1288,7 +1290,7 @@ struct sctp_chunk *sctp_make_auth(const struct sctp_association *asoc) 
	auth_hdr.hmac_id = htons(hmac_desc->hmac_id);

	auth_hdr.shkey_id = htons(asoc->active_key_id);



	retval->subh.auth_hdr = sctp_addto_chunk(retval, sizeof(sctp_authhdr_t),

	retval->subh.auth_hdr = sctp_addto_chunk(retval, sizeof(auth_hdr),

						 &auth_hdr);



	hmac = skb_put_zero(retval->skb, hmac_desc->hmac_len);
@@ -2613,7 +2615,7 @@ static int sctp_process_param(struct sctp_association *asoc, 
		if (!net->sctp.addip_enable)

			goto fall_through;



		addr_param = param.v + sizeof(sctp_addip_param_t);

		addr_param = param.v + sizeof(struct sctp_addip_param);



		af = sctp_get_af_specific(param_type2af(addr_param->p.type));

		if (af == NULL)
@@ -2750,7 +2752,7 @@ static struct sctp_chunk *sctp_make_asconf(struct sctp_association *asoc, 
					   union sctp_addr *addr,

					   int vparam_len)

{

	sctp_addiphdr_t asconf;

	struct sctp_addiphdr asconf;

	struct sctp_chunk *retval;

	int length = sizeof(asconf) + vparam_len;

	union sctp_addr_param addrparam;
@@ -2808,7 +2810,7 @@ struct sctp_chunk *sctp_make_asconf_update_ip(struct sctp_association *asoc, 
					      int		      addrcnt,

					      __be16		      flags)

{

	sctp_addip_param_t	param;

	struct sctp_addip_param	param;

	struct sctp_chunk	*retval;

	union sctp_addr_param	addr_param;

	union sctp_addr		*addr;
@@ -2894,7 +2896,7 @@ struct sctp_chunk *sctp_make_asconf_update_ip(struct sctp_association *asoc, 
struct sctp_chunk *sctp_make_asconf_set_prim(struct sctp_association *asoc,

					     union sctp_addr *addr)

{

	sctp_addip_param_t	param;

	struct sctp_addip_param	param;

	struct sctp_chunk 	*retval;

	int 			len = sizeof(param);

	union sctp_addr_param	addrparam;
@@ -2943,7 +2945,7 @@ struct sctp_chunk *sctp_make_asconf_set_prim(struct sctp_association *asoc, 
static struct sctp_chunk *sctp_make_asconf_ack(const struct sctp_association *asoc,

					       __u32 serial, int vparam_len)

{

	sctp_addiphdr_t		asconf;

	struct sctp_addiphdr	asconf;

	struct sctp_chunk	*retval;

	int			length = sizeof(asconf) + vparam_len;
@@ -2963,10 +2965,11 @@ static struct sctp_chunk *sctp_make_asconf_ack(const struct sctp_association *as 


/* Add response parameters to an ASCONF_ACK chunk. */

static void sctp_add_asconf_response(struct sctp_chunk *chunk, __be32 crr_id,

			      __be16 err_code, sctp_addip_param_t *asconf_param)

				     __be16 err_code,

				     struct sctp_addip_param *asconf_param)

{

	sctp_addip_param_t 	ack_param;

	sctp_errhdr_t		err_param;

	struct sctp_addip_param ack_param;

	struct sctp_errhdr	err_param;

	int			asconf_param_len = 0;

	int			err_param_len = 0;

	__be16			response_type;
@@ -3005,14 +3008,14 @@ static void sctp_add_asconf_response(struct sctp_chunk *chunk, __be32 crr_id, 
/* Process a asconf parameter. */

static __be16 sctp_process_asconf_param(struct sctp_association *asoc,

					struct sctp_chunk *asconf,

				       sctp_addip_param_t *asconf_param)

					struct sctp_addip_param *asconf_param)

{

	struct sctp_transport *peer;

	struct sctp_af *af;

	union sctp_addr	addr;

	union sctp_addr_param *addr_param;



	addr_param = (void *)asconf_param + sizeof(sctp_addip_param_t);

	addr_param = (void *)asconf_param + sizeof(*asconf_param);



	if (asconf_param->param_hdr.type != SCTP_PARAM_ADD_IP &&

	    asconf_param->param_hdr.type != SCTP_PARAM_DEL_IP &&
@@ -3137,10 +3140,11 @@ bool sctp_verify_asconf(const struct sctp_association *asoc, 
			struct sctp_chunk *chunk, bool addr_param_needed,

			struct sctp_paramhdr **errp)

{

	sctp_addip_chunk_t *addip = (sctp_addip_chunk_t *) chunk->chunk_hdr;

	struct sctp_addip_chunk *addip;

	union sctp_params param;

	bool addr_param_seen = false;



	addip = (struct sctp_addip_chunk *)chunk->chunk_hdr;

	sctp_walk_params(param, addip, addip_hdr.params) {

		size_t length = ntohs(param.p->length);
@@ -3172,13 +3176,13 @@ bool sctp_verify_asconf(const struct sctp_association *asoc, 
			if (addr_param_needed && !addr_param_seen)

				return false;

			length = ntohs(param.addip->param_hdr.length);

			if (length < sizeof(sctp_addip_param_t) +

			if (length < sizeof(struct sctp_addip_param) +

				     sizeof(**errp))

				return false;

			break;

		case SCTP_PARAM_SUCCESS_REPORT:

		case SCTP_PARAM_ADAPTATION_LAYER_IND:

			if (length != sizeof(sctp_addip_param_t))

			if (length != sizeof(struct sctp_addip_param))

				return false;

			break;

		default:
@@ -3204,10 +3208,10 @@ bool sctp_verify_asconf(const struct sctp_association *asoc, 
struct sctp_chunk *sctp_process_asconf(struct sctp_association *asoc,

				       struct sctp_chunk *asconf)

{

	sctp_addip_chunk_t *addip = (sctp_addip_chunk_t *) asconf->chunk_hdr;

	struct sctp_addip_chunk *addip;

	bool all_param_pass = true;

	union sctp_params param;

	sctp_addiphdr_t		*hdr;

	struct sctp_addiphdr	*hdr;

	union sctp_addr_param	*addr_param;

	struct sctp_chunk	*asconf_ack;

	__be16	err_code;
@@ -3215,13 +3219,14 @@ struct sctp_chunk *sctp_process_asconf(struct sctp_association *asoc, 
	int	chunk_len;

	__u32	serial;



	addip = (struct sctp_addip_chunk *)asconf->chunk_hdr;

	chunk_len = ntohs(asconf->chunk_hdr->length) -

		    sizeof(struct sctp_chunkhdr);

	hdr = (sctp_addiphdr_t *)asconf->skb->data;

	hdr = (struct sctp_addiphdr *)asconf->skb->data;

	serial = ntohl(hdr->serial);



	/* Skip the addiphdr and store a pointer to address parameter.  */

	length = sizeof(sctp_addiphdr_t);

	length = sizeof(*hdr);

	addr_param = (union sctp_addr_param *)(asconf->skb->data + length);

	chunk_len -= length;
@@ -3287,7 +3292,7 @@ struct sctp_chunk *sctp_process_asconf(struct sctp_association *asoc, 


/* Process a asconf parameter that is successfully acked. */

static void sctp_asconf_param_success(struct sctp_association *asoc,

				     sctp_addip_param_t *asconf_param)

				      struct sctp_addip_param *asconf_param)

{

	struct sctp_af *af;

	union sctp_addr	addr;
@@ -3296,7 +3301,7 @@ static void sctp_asconf_param_success(struct sctp_association *asoc, 
	struct sctp_transport *transport;

	struct sctp_sockaddr_entry *saddr;



	addr_param = (void *)asconf_param + sizeof(sctp_addip_param_t);

	addr_param = (void *)asconf_param + sizeof(*asconf_param);



	/* We have checked the packet before, so we do not check again.	*/

	af = sctp_get_af_specific(param_type2af(addr_param->p.type));
@@ -3347,11 +3352,11 @@ static void sctp_asconf_param_success(struct sctp_association *asoc, 
 * specific success indication is present for the parameter.

 */

static __be16 sctp_get_asconf_response(struct sctp_chunk *asconf_ack,

				      sctp_addip_param_t *asconf_param,

				       struct sctp_addip_param *asconf_param,

				       int no_err)

{

	sctp_addip_param_t	*asconf_ack_param;

	sctp_errhdr_t		*err_param;

	struct sctp_addip_param	*asconf_ack_param;

	struct sctp_errhdr	*err_param;

	int			length;

	int			asconf_ack_len;

	__be16			err_code;
@@ -3367,8 +3372,8 @@ static __be16 sctp_get_asconf_response(struct sctp_chunk *asconf_ack, 
	/* Skip the addiphdr from the asconf_ack chunk and store a pointer to

	 * the first asconf_ack parameter.

	 */

	length = sizeof(sctp_addiphdr_t);

	asconf_ack_param = (sctp_addip_param_t *)(asconf_ack->skb->data +

	length = sizeof(struct sctp_addiphdr);

	asconf_ack_param = (struct sctp_addip_param *)(asconf_ack->skb->data +

						       length);

	asconf_ack_len -= length;
@@ -3378,7 +3383,7 @@ static __be16 sctp_get_asconf_response(struct sctp_chunk *asconf_ack, 
			case SCTP_PARAM_SUCCESS_REPORT:

				return SCTP_ERROR_NO_ERROR;

			case SCTP_PARAM_ERR_CAUSE:

				length = sizeof(sctp_addip_param_t);

				length = sizeof(*asconf_ack_param);

				err_param = (void *)asconf_ack_param + length;

				asconf_ack_len -= length;

				if (asconf_ack_len > 0)
@@ -3405,7 +3410,7 @@ int sctp_process_asconf_ack(struct sctp_association *asoc, 
{

	struct sctp_chunk	*asconf = asoc->addip_last_asconf;

	union sctp_addr_param	*addr_param;

	sctp_addip_param_t	*asconf_param;

	struct sctp_addip_param	*asconf_param;

	int	length = 0;

	int	asconf_len = asconf->skb->len;

	int	all_param_pass = 0;
@@ -3416,7 +3421,7 @@ int sctp_process_asconf_ack(struct sctp_association *asoc, 
	/* Skip the chunkhdr and addiphdr from the last asconf sent and store

	 * a pointer to address parameter.

	 */

	length = sizeof(sctp_addip_chunk_t);

	length = sizeof(struct sctp_addip_chunk);

	addr_param = (union sctp_addr_param *)(asconf->skb->data + length);

	asconf_len -= length;
@@ -3432,7 +3437,7 @@ int sctp_process_asconf_ack(struct sctp_association *asoc, 
	 * failures are indicated, then all request(s) are considered

	 * successful.

	 */

	if (asconf_ack->skb->len == sizeof(sctp_addiphdr_t))

	if (asconf_ack->skb->len == sizeof(struct sctp_addiphdr))

		all_param_pass = 1;



	/* Process the TLVs contained in the last sent ASCONF chunk. */