Commit 9e9858d1 authored by Rich Salz's avatar Rich Salz
Browse files

dead code cleanup: #if 0 in ssl 



I left many "#if 0" lines, usually because I thought we would
probably want to revisit them later, or because they provided
some useful internal documentation tips.

Reviewed-by: default avatarAndy Polyakov <appro@openssl.org>
parent 5b18d302

ssl/bio_ssl.c

+0 −12
Original line number Diff line number Diff line
@@ -150,18 +150,6 @@ static int ssl_read(BIO *b, char *out, int outl) 


    BIO_clear_retry_flags(b);



#if 0

    if (!SSL_is_init_finished(ssl)) {

/*              ret=SSL_do_handshake(ssl); */

        if (ret > 0) {



            outflags = (BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY);

            ret = -1;

            goto end;

        }

    }

#endif

/*      if (ret > 0) */

    ret = SSL_read(ssl, out, outl);



    switch (SSL_get_error(ssl, ret)) {

ssl/d1_both.c

+0 −27
Original line number Diff line number Diff line
@@ -144,14 +144,6 @@ 
                        if (is_complete) for (ii = (((msg_len) - 1) >> 3) - 1; ii >= 0 ; ii--) \

                                if (bitmask[ii] != 0xff) { is_complete = 0; break; } }



#if 0

# define RSMBLY_BITMASK_PRINT(bitmask, msg_len) { \

                        long ii; \

                        printf("bitmask: "); for (ii = 0; ii < (msg_len); ii++) \

                        printf("%d ", (bitmask[ii >> 3] & (1 << (ii & 7))) >> (ii & 7)); \

                        printf("\n"); }

#endif



static unsigned char bitmask_start_values[] =

    { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 };

static unsigned char bitmask_end_values[] =
@@ -1031,20 +1023,6 @@ int dtls1_read_failed(SSL *s, int code) 
        BIO_set_flags(SSL_get_rbio(s), BIO_FLAGS_READ);

        return code;

    }

#if 0                           /* for now, each alert contains only one

                                 * record number */

    item = pqueue_peek(state->rcvd_records);

    if (item) {

        /* send an alert immediately for all the missing records */

    } else

#endif



#if 0                           /* no more alert sending, just retransmit the

                                 * last set of messages */

    if (state->timeout.read_timeouts >= DTLS1_TMO_READ_COUNT)

        ssl3_send_alert(s, SSL3_AL_WARNING,

                        DTLS1_AD_MISSING_HANDSHAKE_MESSAGE);

#endif



    return dtls1_handle_timeout(s);

}
@@ -1144,11 +1122,6 @@ int dtls1_buffer_message(SSL *s, int is_ccs) 
        dtls1_hm_fragment_free(frag);

        return 0;

    }

#if 0

    fprintf(stderr, "buffered messge: \ttype = %xx\n", msg_buf->type);

    fprintf(stderr, "\t\t\t\t\tlen = %d\n", msg_buf->len);

    fprintf(stderr, "\t\t\t\t\tseq_num = %d\n", msg_buf->seq_num);

#endif



    pqueue_insert(s->d1->sent_messages, item);

    return 1;

ssl/d1_clnt.c

+0 −17
Original line number Diff line number Diff line
@@ -714,13 +714,6 @@ int dtls1_connect(SSL *s) 
            /* clean a few things up */

            ssl3_cleanup_key_block(s);



#if 0

            if (s->init_buf != NULL) {

                BUF_MEM_free(s->init_buf);

                s->init_buf = NULL;

            }

#endif



            /*

             * If we are not 'joining' the last two packets, remove the

             * buffering now
@@ -816,16 +809,6 @@ static int dtls1_get_hello_verify(SSL *s) 
    }



    data = (unsigned char *)s->init_msg;

#if 0

    if (s->method->version != DTLS_ANY_VERSION &&

        ((data[0] != (s->version >> 8)) || (data[1] != (s->version & 0xff))))

    {

        SSLerr(SSL_F_DTLS1_GET_HELLO_VERIFY, SSL_R_WRONG_SSL_VERSION);

        s->version = (s->version & 0xff00) | data[1];

        al = SSL_AD_PROTOCOL_VERSION;

        goto f_err;

    }

#endif

    data += 2;



    cookie_len = *(data++);

ssl/d1_pkt.c

+0 −173
Original line number Diff line number Diff line
@@ -187,11 +187,6 @@ static int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap); 
static void dtls1_record_bitmap_update(SSL *s, DTLS1_BITMAP *bitmap);

static DTLS1_BITMAP *dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr,

                                      unsigned int *is_next_epoch);

#if 0

static int dtls1_record_needs_buffering(SSL *s, SSL3_RECORD *rr,

                                        unsigned short *priority,

                                        unsigned long *offset);

#endif

static int dtls1_buffer_record(SSL *s, record_pqueue *q,

                               unsigned char *priority);

static int dtls1_process_record(SSL *s);
@@ -347,50 +342,6 @@ static int dtls1_process_buffered_records(SSL *s) 
    return (1);

}



#if 0



static int dtls1_get_buffered_record(SSL *s)

{

    pitem *item;

    PQ_64BIT priority =

        (((PQ_64BIT) s->d1->handshake_read_seq) << 32) |

        ((PQ_64BIT) s->d1->r_msg_hdr.frag_off);



    /* if we're not (re)negotiating, nothing buffered */

    if (!SSL_in_init(s))

        return 0;



    item = pqueue_peek(s->d1->rcvd_records);

    if (item && item->priority == priority) {

        /*

         * Check if we've received the record of interest.  It must be a

         * handshake record, since data records as passed up without

         * buffering

         */

        DTLS1_RECORD_DATA *rdata;

        item = pqueue_pop(s->d1->rcvd_records);

        rdata = (DTLS1_RECORD_DATA *)item->data;



        if (s->s3->rbuf.buf != NULL)

            OPENSSL_free(s->s3->rbuf.buf);



        s->packet = rdata->packet;

        s->packet_length = rdata->packet_length;

        memcpy(&(s->s3->rbuf), &(rdata->rbuf), sizeof(SSL3_BUFFER));

        memcpy(&(s->s3->rrec), &(rdata->rrec), sizeof(SSL3_RECORD));



        OPENSSL_free(item->data);

        pitem_free(item);



        /* s->d1->next_expected_seq_num++; */

        return (1);

    }



    return 0;

}



#endif



static int dtls1_process_record(SSL *s)

{

    int i, al;
@@ -1302,15 +1253,7 @@ int dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek) 


        if (((s->state & SSL_ST_MASK) == SSL_ST_OK) &&

            !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) {

#if 0                           /* worked only because C operator preferences

                                 * are not as expected (and because this is

                                 * not really needed for clients except for

                                 * detecting protocol violations): */

            s->state = SSL_ST_BEFORE | (s->server)

                ? SSL_ST_ACCEPT : SSL_ST_CONNECT;

#else

            s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT;

#endif

            s->renegotiate = 1;

            s->new_session = 1;

        }
@@ -1526,41 +1469,6 @@ int do_dtls1_write(SSL *s, int type, const unsigned char *buf, 
            goto err;

    }



    /* DTLS implements explicit IV, so no need for empty fragments */

#if 0

    /*

     * 'create_empty_fragment' is true only when this function calls itself

     */

    if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done

        && SSL_version(s) != DTLS1_VERSION && SSL_version(s) != DTLS1_BAD_VER)

    {

        /*

         * countermeasure against known-IV weakness in CBC ciphersuites (see

         * http://www.openssl.org/~bodo/tls-cbc.txt)

         */



        if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA) {

            /*

             * recursive function call with 'create_empty_fragment' set; this

             * prepares and buffers the data for an empty fragment (these

             * 'prefix_len' bytes are sent out later together with the actual

             * payload)

             */

            prefix_len = s->method->do_ssl_write(s, type, buf, 0, 1);

            if (prefix_len <= 0)

                goto err;



            if (s->s3->wbuf.len <

                (size_t)prefix_len + SSL3_RT_MAX_PACKET_SIZE) {

                /* insufficient space */

                SSLerr(SSL_F_DO_DTLS1_WRITE, ERR_R_INTERNAL_ERROR);

                goto err;

            }

        }



        s->s3->empty_fragment_done = 1;

    }

#endif

    p = wb->buf + prefix_len;



    /* write the header */
@@ -1672,13 +1580,6 @@ int do_dtls1_write(SSL *s, int type, const unsigned char *buf, 
    wr->type = type;            /* not needed but helps for debugging */

    wr->length += DTLS1_RT_HEADER_LENGTH;



#if 0                           /* this is now done at the message layer */

    /* buffer the record, making it easy to handle retransmits */

    if (type == SSL3_RT_HANDSHAKE || type == SSL3_RT_CHANGE_CIPHER_SPEC)

        dtls1_buffer_record(s, wr->data, wr->length,

                            *((PQ_64BIT *) & (s->s3->write_sequence[0])));

#endif



    ssl3_record_sequence_update(&(s->s3->write_sequence[0]));



    if (create_empty_fragment) {
@@ -1766,20 +1667,6 @@ int dtls1_dispatch_alert(SSL *s) 
#ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE

    if (s->s3->send_alert[1] == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE) {

        s2n(s->d1->handshake_read_seq, ptr);

# if 0

        if (s->d1->r_msg_hdr.frag_off == 0)

            /*

             * waiting for a new msg

             */

            else

            s2n(s->d1->r_msg_hdr.seq, ptr); /* partial msg read */

# endif



# if 0

        fprintf(stderr,

                "s->d1->handshake_read_seq = %d, s->d1->r_msg_hdr.seq = %d\n",

                s->d1->handshake_read_seq, s->d1->r_msg_hdr.seq);

# endif

        l2n3(s->d1->r_msg_hdr.frag_off, ptr);

    }

#endif
@@ -1833,66 +1720,6 @@ static DTLS1_BITMAP *dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr, 
    return NULL;

}



#if 0

static int

dtls1_record_needs_buffering(SSL *s, SSL3_RECORD *rr,

                             unsigned short *priority, unsigned long *offset)

{



    /* alerts are passed up immediately */

    if (rr->type == SSL3_RT_APPLICATION_DATA || rr->type == SSL3_RT_ALERT)

        return 0;



    /*

     * Only need to buffer if a handshake is underway. (this implies that

     * Hello Request and Client Hello are passed up immediately)

     */

    if (SSL_in_init(s)) {

        unsigned char *data = rr->data;

        /* need to extract the HM/CCS sequence number here */

        if (rr->type == SSL3_RT_HANDSHAKE ||

            rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) {

            unsigned short seq_num;

            struct hm_header_st msg_hdr;

            struct ccs_header_st ccs_hdr;



            if (rr->type == SSL3_RT_HANDSHAKE) {

                dtls1_get_message_header(data, &msg_hdr);

                seq_num = msg_hdr.seq;

                *offset = msg_hdr.frag_off;

            } else {

                dtls1_get_ccs_header(data, &ccs_hdr);

                seq_num = ccs_hdr.seq;

                *offset = 0;

            }



            /*

             * this is either a record we're waiting for, or a retransmit of

             * something we happened to previously receive (higher layers

             * will drop the repeat silently

             */

            if (seq_num < s->d1->handshake_read_seq)

                return 0;

            if (rr->type == SSL3_RT_HANDSHAKE &&

                seq_num == s->d1->handshake_read_seq &&

                msg_hdr.frag_off < s->d1->r_msg_hdr.frag_off)

                return 0;

            else if (seq_num == s->d1->handshake_read_seq &&

                     (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC ||

                      msg_hdr.frag_off == s->d1->r_msg_hdr.frag_off))

                return 0;

            else {

                *priority = seq_num;

                return 1;

            }

        } else                  /* unknown record type */

            return 0;

    }



    return 0;

}

#endif



void dtls1_reset_seq_numbers(SSL *s, int rw)

{

    unsigned char *seq;

ssl/d1_srtp.c

+0 −10
Original line number Diff line number Diff line
@@ -129,16 +129,6 @@ static SRTP_PROTECTION_PROFILE srtp_known_profiles[] = { 
     "SRTP_AES128_CM_SHA1_32",

     SRTP_AES128_CM_SHA1_32,

     },

# if 0

    {

     "SRTP_NULL_SHA1_80",

     SRTP_NULL_SHA1_80,

     },

    {

     "SRTP_NULL_SHA1_32",

     SRTP_NULL_SHA1_32,

     },

# endif

    {0}

};