base.inqueue.immediate);
        struct sctp_endpoint *ep;
        struct sctp_chunk *chunk;
-       struct sock *sk;
        struct sctp_inq *inqueue;
        int state;
        sctp_subtype_t subtype;
 
        /* The association should be held so we should be safe. */
        ep = asoc->ep;
-       sk = asoc->base.sk;
 
        inqueue = &asoc->base.inqueue;
        sctp_association_hold(asoc);
 
        union sctp_addr addr;
        union sctp_addr *paddr = &addr;
        struct sctphdr *sh = sctp_hdr(skb);
-       sctp_chunkhdr_t *ch;
        union sctp_params params;
        sctp_init_chunk_t *init;
        struct sctp_transport *transport;
        struct sctp_af *af;
 
-       ch = (sctp_chunkhdr_t *) skb->data;
-
        /*
         * This code will NOT touch anything inside the chunk--it is
         * strictly READ-ONLY.
 
        struct sctp_transport *transport = pkt->transport;
        sctp_xmit_t status;
        struct sctp_chunk *chunk, *chunk1;
-       struct sctp_association *asoc;
        int fast_rtx;
        int error = 0;
        int timer = 0;
        int done = 0;
 
-       asoc = q->asoc;
        lqueue = &q->retransmit;
        fast_rtx = q->fast_rtx;
 
 
                                    struct sctp_fwdtsn_skip *skiplist)
 {
        struct sctp_chunk *retval = NULL;
-       struct sctp_fwdtsn_chunk *ftsn_chunk;
        struct sctp_fwdtsn_hdr ftsn_hdr;
        struct sctp_fwdtsn_skip skip;
        size_t hint;
        if (!retval)
                return NULL;
 
-       ftsn_chunk = (struct sctp_fwdtsn_chunk *)retval->subh.fwdtsn_hdr;
-
        ftsn_hdr.new_cum_tsn = htonl(new_cum_tsn);
        retval->subh.fwdtsn_hdr =
                sctp_addto_chunk(retval, sizeof(ftsn_hdr), &ftsn_hdr);
 
                                             unsigned int optlen)
 {
        struct sctp_sock        *sp;
-       struct sctp_endpoint    *ep;
        struct sctp_association *asoc = NULL;
        struct sctp_setpeerprim prim;
        struct sctp_chunk       *chunk;
        int                     err;
 
        sp = sctp_sk(sk);
-       ep = sp->ep;
 
        if (!sctp_addip_enable)
                return -EPERM;
 
                        gfp_t gfp)
 {
        struct sk_buff_head temp;
-       sctp_data_chunk_t *hdr;
        struct sctp_ulpevent *event;
 
-       hdr = (sctp_data_chunk_t *) chunk->chunk_hdr;
-
        /* Create an event from the incoming chunk. */
        event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp);
        if (!event)
        struct sk_buff *pos, *tmp;
        struct sctp_ulpevent *cevent;
        struct sctp_stream *in;
-       __u16 sid, csid;
-       __u16 ssn, cssn;
+       __u16 sid, csid, cssn;
 
        sid = event->stream;
-       ssn = event->ssn;
        in  = &ulpq->asoc->ssnmap->in;
 
        event_list = (struct sk_buff_head *) sctp_event2skb(event)->prev;