ssl/record/ssl3_record.c:279: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 2):unsigned64.
Showing all 4 steps of the trace


ssl/record/ssl3_record.c:256:17: <LHS trace>
254.               (RECORD_LAYER_get_packet_length(&s->rlayer)
255.                < SSL3_RT_HEADER_LENGTH)) {
256.               n = ssl3_read_n(s, SSL3_RT_HEADER_LENGTH,
                       ^
257.                   SSL3_BUFFER_get_len(rbuf), 0, num_recs == 0 ? 1 : 0);
258.               if (n <= 0)

ssl/record/ssl3_record.c:256:17: Call
254.               (RECORD_LAYER_get_packet_length(&s->rlayer)
255.                < SSL3_RT_HEADER_LENGTH)) {
256.               n = ssl3_read_n(s, SSL3_RT_HEADER_LENGTH,
                       ^
257.                   SSL3_BUFFER_get_len(rbuf), 0, num_recs == 0 ? 1 : 0);
258.               if (n <= 0)

ssl/record/rec_layer_s3.c:293:1: Parameter `n`
  291.   }
  292.   
  293. > int ssl3_read_n(SSL *s, int n, int max, int extend, int clearold)
  294.   {
  295.       /*

ssl/record/ssl3_record.c:279:21: Binary operation: ([0, +oo] - 2):unsigned64
277.                   rr[num_recs].length = ((p[0] & 0x7f) << 8) | p[1];
278.   
279.                   if (rr[num_recs].length > SSL3_BUFFER_get_len(&rbuf[num_recs])
                           ^
280.                                    - SSL2_RT_HEADER_LENGTH) {
281.                       al = SSL_AD_RECORD_OVERFLOW;

int ssl3_get_record(SSL *s)
{
    int ssl_major, ssl_minor, al;
    int enc_err, n, i, ret = -1;
    SSL3_RECORD *rr;
    SSL3_BUFFER *rbuf;
    SSL_SESSION *sess;
    unsigned char *p;
    unsigned char md[EVP_MAX_MD_SIZE];
    short version;
    unsigned mac_size;
    unsigned empty_record_count = 0, curr_empty = 0;
    unsigned int num_recs = 0;
    unsigned int max_recs;
    unsigned int j;
    rr = RECORD_LAYER_get_rrec(&s->rlayer);
    rbuf = RECORD_LAYER_get_rbuf(&s->rlayer);
    max_recs = s->max_pipelines;
    if (max_recs == 0)
        max_recs = 1;
    sess = s->session;
 again:
    do {
        if ((RECORD_LAYER_get_rstate(&s->rlayer) != SSL_ST_READ_BODY) ||
            (RECORD_LAYER_get_packet_length(&s->rlayer)
             < SSL3_RT_HEADER_LENGTH)) {
            n = ssl3_read_n(s, SSL3_RT_HEADER_LENGTH,
                SSL3_BUFFER_get_len(rbuf), 0, num_recs == 0 ? 1 : 0);
            if (n <= 0)
                return (n);
            RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_BODY);
            p = RECORD_LAYER_get_packet(&s->rlayer);
            if (s->first_packet && s->server && !s->read_hash
                    && !s->enc_read_ctx
                    && (p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO)) {
                rr[num_recs].type = SSL3_RT_HANDSHAKE;
                rr[num_recs].rec_version = SSL2_VERSION;
                rr[num_recs].length = ((p[0] & 0x7f) << 8) | p[1];
                if (rr[num_recs].length > SSL3_BUFFER_get_len(&rbuf[num_recs])
                                 - SSL2_RT_HEADER_LENGTH) {
                    al = SSL_AD_RECORD_OVERFLOW;
                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_PACKET_LENGTH_TOO_LONG);
                    goto f_err;
                }
                if (rr[num_recs].length < MIN_SSL2_RECORD_LEN) {
                    al = SSL_AD_HANDSHAKE_FAILURE;
                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
                    goto f_err;
                }
            } else {
                if (s->msg_callback)
                    s->msg_callback(0, 0, SSL3_RT_HEADER, p, 5, s,
                                    s->msg_callback_arg);
                rr[num_recs].type = *(p++);
                ssl_major = *(p++);
                ssl_minor = *(p++);
                version = (ssl_major << 8) | ssl_minor;
                rr[num_recs].rec_version = version;
                n2s(p, rr[num_recs].length);
                if (!s->first_packet && version != s->version) {
                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);
                    if ((s->version & 0xFF00) == (version & 0xFF00)
                        && !s->enc_write_ctx && !s->write_hash) {
                        if (rr->type == SSL3_RT_ALERT) {
                             goto err;
                        }
                        s->version = (unsigned short)version;
                    }
                    al = SSL_AD_PROTOCOL_VERSION;
                    goto f_err;
                }
                if ((version >> 8) != SSL3_VERSION_MAJOR) {
                    if (s->first_packet) {
                        p = RECORD_LAYER_get_packet(&s->rlayer);
                        if (strncmp((char *)p, "GET ", 4) == 0 ||
                            strncmp((char *)p, "POST ", 5) == 0 ||
                            strncmp((char *)p, "HEAD ", 5) == 0 ||
                            strncmp((char *)p, "PUT ", 4) == 0) {
                            SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_HTTP_REQUEST);
                            goto err;
                        } else if (strncmp((char *)p, "CONNE", 5) == 0) {
                            SSLerr(SSL_F_SSL3_GET_RECORD,
                                   SSL_R_HTTPS_PROXY_REQUEST);
                            goto err;
                        }
                    }
                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);
                    goto err;
                }
                if (rr[num_recs].length >
                        SSL3_BUFFER_get_len(rbuf) - SSL3_RT_HEADER_LENGTH) {
                    al = SSL_AD_RECORD_OVERFLOW;
                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_PACKET_LENGTH_TOO_LONG);
                    goto f_err;
                }
            }
        }
        if (rr[num_recs].rec_version == SSL2_VERSION) {
            i = rr[num_recs].length + SSL2_RT_HEADER_LENGTH
                - SSL3_RT_HEADER_LENGTH;
        } else {
            i = rr[num_recs].length;
        }
        if (i > 0) {
            n = ssl3_read_n(s, i, i, 1, 0);
            if (n <= 0)
                return (n);
        }
        RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_HEADER);
        if(rr[num_recs].rec_version == SSL2_VERSION) {
            rr[num_recs].input =
                &(RECORD_LAYER_get_packet(&s->rlayer)[SSL2_RT_HEADER_LENGTH]);
        } else {
            rr[num_recs].input =
                &(RECORD_LAYER_get_packet(&s->rlayer)[SSL3_RT_HEADER_LENGTH]);
        }
        if (rr[num_recs].length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
            al = SSL_AD_RECORD_OVERFLOW;
            SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
            goto f_err;
        }
        rr[num_recs].data = rr[num_recs].input;
        rr[num_recs].orig_len = rr[num_recs].length;
        num_recs++;
        RECORD_LAYER_reset_packet_length(&s->rlayer);
    } while (num_recs < max_recs && rr->type == SSL3_RT_APPLICATION_DATA
             && SSL_USE_EXPLICIT_IV(s)
             && s->enc_read_ctx != NULL
             && (EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(s->enc_read_ctx))
                & EVP_CIPH_FLAG_PIPELINE)
             && ssl3_record_app_data_waiting(s));
    if (SSL_USE_ETM(s) && s->read_hash) {
        unsigned char *mac;
        mac_size = EVP_MD_CTX_size(s->read_hash);
        OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
        for (j = 0; j < num_recs; j++) {
            if (rr[j].length < mac_size) {
                al = SSL_AD_DECODE_ERROR;
                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
                goto f_err;
            }
            rr[j].length -= mac_size;
            mac = rr[j].data + rr[j].length;
            i = s->method->ssl3_enc->mac(s, &rr[j], md, 0   );
            if (i < 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) {
                al = SSL_AD_BAD_RECORD_MAC;
                SSLerr(SSL_F_SSL3_GET_RECORD,
                       SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
                goto f_err;
            }
        }
    }
    enc_err = s->method->ssl3_enc->enc(s, rr, num_recs, 0);
    if (enc_err == 0) {
        al = SSL_AD_DECRYPTION_FAILED;
        SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
        goto f_err;
    }
#ifdef SSL_DEBUG
    printf("dec %d\n", rr->length);
    {
        unsigned int z;
        for (z = 0; z < rr->length; z++)
            printf("%02X%c", rr->data[z], ((z + 1) % 16) ? ' ' : '\n');
    }
    printf("\n");
#endif
    if ((sess != NULL) &&
        (s->enc_read_ctx != NULL) &&
        (EVP_MD_CTX_md(s->read_hash) != NULL) && !SSL_USE_ETM(s)) {
        unsigned char *mac = NULL;
        unsigned char mac_tmp[EVP_MAX_MD_SIZE];
        mac_size = EVP_MD_CTX_size(s->read_hash);
        OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
        for (j=0; j < num_recs; j++) {
            if (rr[j].orig_len < mac_size ||
                (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
                 rr[j].orig_len < mac_size + 1)) {
                al = SSL_AD_DECODE_ERROR;
                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
                goto f_err;
            }
            if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {
                mac = mac_tmp;
                ssl3_cbc_copy_mac(mac_tmp, &rr[j], mac_size);
                rr[j].length -= mac_size;
            } else {
                rr[j].length -= mac_size;
                mac = &rr[j].data[rr[j].length];
            }
            i = s->method->ssl3_enc->mac(s, &rr[j], md, 0   );
            if (i < 0 || mac == NULL
                || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
                enc_err = -1;
            if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
                enc_err = -1;
        }
    }
    if (enc_err < 0) {
        al = SSL_AD_BAD_RECORD_MAC;
        SSLerr(SSL_F_SSL3_GET_RECORD,
               SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
        goto f_err;
    }
    for (j = 0; j < num_recs; j++) {
        if (s->expand != NULL) {
            if (rr[j].length > SSL3_RT_MAX_COMPRESSED_LENGTH) {
                al = SSL_AD_RECORD_OVERFLOW;
                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_COMPRESSED_LENGTH_TOO_LONG);
                goto f_err;
            }
            if (!ssl3_do_uncompress(s, &rr[j])) {
                al = SSL_AD_DECOMPRESSION_FAILURE;
                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BAD_DECOMPRESSION);
                goto f_err;
            }
        }
        if (rr[j].length > SSL3_RT_MAX_PLAIN_LENGTH) {
            al = SSL_AD_RECORD_OVERFLOW;
            SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);
            goto f_err;
        }
        rr[j].off = 0;
        if (rr[j].length == 0) {
            curr_empty++;
            empty_record_count++;
            if (empty_record_count > MAX_EMPTY_RECORDS) {
                al = SSL_AD_UNEXPECTED_MESSAGE;
                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_RECORD_TOO_SMALL);
                goto f_err;
            }
        }
    }
    if (curr_empty == num_recs) {
        num_recs = 0;
        curr_empty = 0;
        goto again;
    }
    RECORD_LAYER_set_numrpipes(&s->rlayer, num_recs);
    return 1;
 f_err:
    ssl3_send_alert(s, SSL3_AL_FATAL, al);
 err:
    return ret;
}
['int ssl3_get_record(SSL *s)\n{\n    int ssl_major, ssl_minor, al;\n    int enc_err, n, i, ret = -1;\n    SSL3_RECORD *rr;\n    SSL3_BUFFER *rbuf;\n    SSL_SESSION *sess;\n    unsigned char *p;\n    unsigned char md[EVP_MAX_MD_SIZE];\n    short version;\n    unsigned mac_size;\n    unsigned empty_record_count = 0, curr_empty = 0;\n    unsigned int num_recs = 0;\n    unsigned int max_recs;\n    unsigned int j;\n    rr = RECORD_LAYER_get_rrec(&s->rlayer);\n    rbuf = RECORD_LAYER_get_rbuf(&s->rlayer);\n    max_recs = s->max_pipelines;\n    if (max_recs == 0)\n        max_recs = 1;\n    sess = s->session;\n again:\n    do {\n        if ((RECORD_LAYER_get_rstate(&s->rlayer) != SSL_ST_READ_BODY) ||\n            (RECORD_LAYER_get_packet_length(&s->rlayer)\n             < SSL3_RT_HEADER_LENGTH)) {\n            n = ssl3_read_n(s, SSL3_RT_HEADER_LENGTH,\n                SSL3_BUFFER_get_len(rbuf), 0, num_recs == 0 ? 1 : 0);\n            if (n <= 0)\n                return (n);\n            RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_BODY);\n            p = RECORD_LAYER_get_packet(&s->rlayer);\n            if (s->first_packet && s->server && !s->read_hash\n                    && !s->enc_read_ctx\n                    && (p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO)) {\n                rr[num_recs].type = SSL3_RT_HANDSHAKE;\n                rr[num_recs].rec_version = SSL2_VERSION;\n                rr[num_recs].length = ((p[0] & 0x7f) << 8) | p[1];\n                if (rr[num_recs].length > SSL3_BUFFER_get_len(&rbuf[num_recs])\n                                 - SSL2_RT_HEADER_LENGTH) {\n                    al = SSL_AD_RECORD_OVERFLOW;\n                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_PACKET_LENGTH_TOO_LONG);\n                    goto f_err;\n                }\n                if (rr[num_recs].length < MIN_SSL2_RECORD_LEN) {\n                    al = SSL_AD_HANDSHAKE_FAILURE;\n                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);\n                    goto f_err;\n                }\n            } else {\n                if (s->msg_callback)\n                    s->msg_callback(0, 0, SSL3_RT_HEADER, p, 5, s,\n                                    s->msg_callback_arg);\n                rr[num_recs].type = *(p++);\n                ssl_major = *(p++);\n                ssl_minor = *(p++);\n                version = (ssl_major << 8) | ssl_minor;\n                rr[num_recs].rec_version = version;\n                n2s(p, rr[num_recs].length);\n                if (!s->first_packet && version != s->version) {\n                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);\n                    if ((s->version & 0xFF00) == (version & 0xFF00)\n                        && !s->enc_write_ctx && !s->write_hash) {\n                        if (rr->type == SSL3_RT_ALERT) {\n                             goto err;\n                        }\n                        s->version = (unsigned short)version;\n                    }\n                    al = SSL_AD_PROTOCOL_VERSION;\n                    goto f_err;\n                }\n                if ((version >> 8) != SSL3_VERSION_MAJOR) {\n                    if (s->first_packet) {\n                        p = RECORD_LAYER_get_packet(&s->rlayer);\n                        if (strncmp((char *)p, "GET ", 4) == 0 ||\n                            strncmp((char *)p, "POST ", 5) == 0 ||\n                            strncmp((char *)p, "HEAD ", 5) == 0 ||\n                            strncmp((char *)p, "PUT ", 4) == 0) {\n                            SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_HTTP_REQUEST);\n                            goto err;\n                        } else if (strncmp((char *)p, "CONNE", 5) == 0) {\n                            SSLerr(SSL_F_SSL3_GET_RECORD,\n                                   SSL_R_HTTPS_PROXY_REQUEST);\n                            goto err;\n                        }\n                    }\n                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);\n                    goto err;\n                }\n                if (rr[num_recs].length >\n                        SSL3_BUFFER_get_len(rbuf) - SSL3_RT_HEADER_LENGTH) {\n                    al = SSL_AD_RECORD_OVERFLOW;\n                    SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_PACKET_LENGTH_TOO_LONG);\n                    goto f_err;\n                }\n            }\n        }\n        if (rr[num_recs].rec_version == SSL2_VERSION) {\n            i = rr[num_recs].length + SSL2_RT_HEADER_LENGTH\n                - SSL3_RT_HEADER_LENGTH;\n        } else {\n            i = rr[num_recs].length;\n        }\n        if (i > 0) {\n            n = ssl3_read_n(s, i, i, 1, 0);\n            if (n <= 0)\n                return (n);\n        }\n        RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_HEADER);\n        if(rr[num_recs].rec_version == SSL2_VERSION) {\n            rr[num_recs].input =\n                &(RECORD_LAYER_get_packet(&s->rlayer)[SSL2_RT_HEADER_LENGTH]);\n        } else {\n            rr[num_recs].input =\n                &(RECORD_LAYER_get_packet(&s->rlayer)[SSL3_RT_HEADER_LENGTH]);\n        }\n        if (rr[num_recs].length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {\n            al = SSL_AD_RECORD_OVERFLOW;\n            SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);\n            goto f_err;\n        }\n        rr[num_recs].data = rr[num_recs].input;\n        rr[num_recs].orig_len = rr[num_recs].length;\n        num_recs++;\n        RECORD_LAYER_reset_packet_length(&s->rlayer);\n    } while (num_recs < max_recs && rr->type == SSL3_RT_APPLICATION_DATA\n             && SSL_USE_EXPLICIT_IV(s)\n             && s->enc_read_ctx != NULL\n             && (EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(s->enc_read_ctx))\n                & EVP_CIPH_FLAG_PIPELINE)\n             && ssl3_record_app_data_waiting(s));\n    if (SSL_USE_ETM(s) && s->read_hash) {\n        unsigned char *mac;\n        mac_size = EVP_MD_CTX_size(s->read_hash);\n        OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);\n        for (j = 0; j < num_recs; j++) {\n            if (rr[j].length < mac_size) {\n                al = SSL_AD_DECODE_ERROR;\n                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);\n                goto f_err;\n            }\n            rr[j].length -= mac_size;\n            mac = rr[j].data + rr[j].length;\n            i = s->method->ssl3_enc->mac(s, &rr[j], md, 0   );\n            if (i < 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) {\n                al = SSL_AD_BAD_RECORD_MAC;\n                SSLerr(SSL_F_SSL3_GET_RECORD,\n                       SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);\n                goto f_err;\n            }\n        }\n    }\n    enc_err = s->method->ssl3_enc->enc(s, rr, num_recs, 0);\n    if (enc_err == 0) {\n        al = SSL_AD_DECRYPTION_FAILED;\n        SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);\n        goto f_err;\n    }\n#ifdef SSL_DEBUG\n    printf("dec %d\\n", rr->length);\n    {\n        unsigned int z;\n        for (z = 0; z < rr->length; z++)\n            printf("%02X%c", rr->data[z], ((z + 1) % 16) ? \' \' : \'\\n\');\n    }\n    printf("\\n");\n#endif\n    if ((sess != NULL) &&\n        (s->enc_read_ctx != NULL) &&\n        (EVP_MD_CTX_md(s->read_hash) != NULL) && !SSL_USE_ETM(s)) {\n        unsigned char *mac = NULL;\n        unsigned char mac_tmp[EVP_MAX_MD_SIZE];\n        mac_size = EVP_MD_CTX_size(s->read_hash);\n        OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);\n        for (j=0; j < num_recs; j++) {\n            if (rr[j].orig_len < mac_size ||\n                (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&\n                 rr[j].orig_len < mac_size + 1)) {\n                al = SSL_AD_DECODE_ERROR;\n                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);\n                goto f_err;\n            }\n            if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {\n                mac = mac_tmp;\n                ssl3_cbc_copy_mac(mac_tmp, &rr[j], mac_size);\n                rr[j].length -= mac_size;\n            } else {\n                rr[j].length -= mac_size;\n                mac = &rr[j].data[rr[j].length];\n            }\n            i = s->method->ssl3_enc->mac(s, &rr[j], md, 0   );\n            if (i < 0 || mac == NULL\n                || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)\n                enc_err = -1;\n            if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)\n                enc_err = -1;\n        }\n    }\n    if (enc_err < 0) {\n        al = SSL_AD_BAD_RECORD_MAC;\n        SSLerr(SSL_F_SSL3_GET_RECORD,\n               SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);\n        goto f_err;\n    }\n    for (j = 0; j < num_recs; j++) {\n        if (s->expand != NULL) {\n            if (rr[j].length > SSL3_RT_MAX_COMPRESSED_LENGTH) {\n                al = SSL_AD_RECORD_OVERFLOW;\n                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_COMPRESSED_LENGTH_TOO_LONG);\n                goto f_err;\n            }\n            if (!ssl3_do_uncompress(s, &rr[j])) {\n                al = SSL_AD_DECOMPRESSION_FAILURE;\n                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BAD_DECOMPRESSION);\n                goto f_err;\n            }\n        }\n        if (rr[j].length > SSL3_RT_MAX_PLAIN_LENGTH) {\n            al = SSL_AD_RECORD_OVERFLOW;\n            SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);\n            goto f_err;\n        }\n        rr[j].off = 0;\n        if (rr[j].length == 0) {\n            curr_empty++;\n            empty_record_count++;\n            if (empty_record_count > MAX_EMPTY_RECORDS) {\n                al = SSL_AD_UNEXPECTED_MESSAGE;\n                SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_RECORD_TOO_SMALL);\n                goto f_err;\n            }\n        }\n    }\n    if (curr_empty == num_recs) {\n        num_recs = 0;\n        curr_empty = 0;\n        goto again;\n    }\n    RECORD_LAYER_set_numrpipes(&s->rlayer, num_recs);\n    return 1;\n f_err:\n    ssl3_send_alert(s, SSL3_AL_FATAL, al);\n err:\n    return ret;\n}', 'int ssl3_read_n(SSL *s, int n, int max, int extend, int clearold)\n{\n    int i, len, left;\n    size_t align = 0;\n    unsigned char *pkt;\n    SSL3_BUFFER *rb;\n    if (n <= 0)\n        return n;\n    rb = &s->rlayer.rbuf;\n    if (rb->buf == NULL)\n        if (!ssl3_setup_read_buffer(s))\n            return -1;\n    left = rb->left;\n#if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0\n    align = (size_t)rb->buf + SSL3_RT_HEADER_LENGTH;\n    align = (0-align) & (SSL3_ALIGN_PAYLOAD - 1);\n#endif\n    if (!extend) {\n        if (left == 0)\n            rb->offset = align;\n        else if (align != 0 && left >= SSL3_RT_HEADER_LENGTH) {\n            pkt = rb->buf + rb->offset;\n            if (pkt[0] == SSL3_RT_APPLICATION_DATA\n                && (pkt[3] << 8 | pkt[4]) >= 128) {\n                memmove(rb->buf + align, pkt, left);\n                rb->offset = align;\n            }\n        }\n        s->rlayer.packet = rb->buf + rb->offset;\n        s->rlayer.packet_length = 0;\n    }\n    if (SSL_IS_DTLS(s)) {\n        if (left == 0 && extend)\n            return 0;\n        if (left > 0 && n > left)\n            n = left;\n    }\n    if (left >= n) {\n        s->rlayer.packet_length += n;\n        rb->left = left - n;\n        rb->offset += n;\n        return (n);\n    }\n    len = s->rlayer.packet_length;\n    pkt = rb->buf + align;\n    if (s->rlayer.packet != pkt && clearold == 1) {\n        memmove(pkt, s->rlayer.packet, len + left);\n        s->rlayer.packet = pkt;\n        rb->offset = len + align;\n    }\n    if (n > (int)(rb->len - rb->offset)) {\n        SSLerr(SSL_F_SSL3_READ_N, ERR_R_INTERNAL_ERROR);\n        return -1;\n    }\n    if (!s->rlayer.read_ahead && !SSL_IS_DTLS(s))\n        max = n;\n    else {\n        if (max < n)\n            max = n;\n        if (max > (int)(rb->len - rb->offset))\n            max = rb->len - rb->offset;\n    }\n    while (left < n) {\n        clear_sys_error();\n        if (s->rbio != NULL) {\n            s->rwstate = SSL_READING;\n            i = BIO_read(s->rbio, pkt + len + left, max - left);\n        } else {\n            SSLerr(SSL_F_SSL3_READ_N, SSL_R_READ_BIO_NOT_SET);\n            i = -1;\n        }\n        if (i <= 0) {\n            rb->left = left;\n            if (s->mode & SSL_MODE_RELEASE_BUFFERS && !SSL_IS_DTLS(s))\n                if (len + left == 0)\n                    ssl3_release_read_buffer(s);\n            return (i);\n        }\n        left += i;\n        if (SSL_IS_DTLS(s)) {\n            if (n > left)\n                n = left;\n        }\n    }\n    rb->offset += n;\n    rb->left = left - n;\n    s->rlayer.packet_length += n;\n    s->rwstate = SSL_NOTHING;\n    return (n);\n}']