test/handshake_helper.c:404: error: UNINITIALIZED_VALUE
  The value read from server_ex_data.session_ticket_do_not_call was never initialized.
Showing all 1 steps of the trace


test/handshake_helper.c:404:5: 
402.       else
403.           ret.session_ticket = SSL_TEST_SESSION_TICKET_YES;
404. >     ret.session_ticket_do_not_call = server_ex_data.session_ticket_do_not_call;
405.   
406.       SSL_free(server);

HANDSHAKE_RESULT do_handshake(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,
                              SSL_CTX *client_ctx, const SSL_TEST_CTX *test_ctx)
{
    SSL *server, *client;
    BIO *client_to_server, *server_to_client;
    HANDSHAKE_EX_DATA server_ex_data, client_ex_data;
    HANDSHAKE_RESULT ret;
    int client_turn = 1;
    peer_status_t client_status = PEER_RETRY, server_status = PEER_RETRY;
    handshake_status_t status = HANDSHAKE_RETRY;
    unsigned char* tick = NULL;
    size_t len = 0;
    SSL_SESSION* sess = NULL;
    configure_handshake_ctx(server_ctx, server2_ctx, client_ctx, test_ctx);
    server = SSL_new(server_ctx);
    client = SSL_new(client_ctx);
    OPENSSL_assert(server != NULL && client != NULL);
    configure_handshake_ssl(server, client, test_ctx);
    memset(&server_ex_data, 0, sizeof(server_ex_data));
    memset(&client_ex_data, 0, sizeof(client_ex_data));
    memset(&ret, 0, sizeof(ret));
    ret.result = SSL_TEST_INTERNAL_ERROR;
    client_to_server = BIO_new(BIO_s_mem());
    server_to_client = BIO_new(BIO_s_mem());
    OPENSSL_assert(client_to_server != NULL && server_to_client != NULL);
    BIO_set_nbio(client_to_server, 1);
    BIO_set_nbio(server_to_client, 1);
    SSL_set_connect_state(client);
    SSL_set_accept_state(server);
    SSL_set_bio(client, server_to_client, client_to_server);
    OPENSSL_assert(BIO_up_ref(server_to_client) > 0);
    OPENSSL_assert(BIO_up_ref(client_to_server) > 0);
    SSL_set_bio(server, client_to_server, server_to_client);
    ex_data_idx = SSL_get_ex_new_index(0, "ex data", NULL, NULL, NULL);
    OPENSSL_assert(ex_data_idx >= 0);
    OPENSSL_assert(SSL_set_ex_data(server, ex_data_idx,
                                   &server_ex_data) == 1);
    OPENSSL_assert(SSL_set_ex_data(client, ex_data_idx,
                                   &client_ex_data) == 1);
    SSL_set_info_callback(server, &info_cb);
    SSL_set_info_callback(client, &info_cb);
    for(;;) {
        if (client_turn) {
            client_status = do_handshake_step(client);
            status = handshake_status(client_status, server_status,
                                      1  );
        } else {
            server_status = do_handshake_step(server);
            status = handshake_status(server_status, client_status,
                                      0  );
        }
        switch (status) {
        case HANDSHAKE_SUCCESS:
            ret.result = SSL_TEST_SUCCESS;
            goto err;
        case CLIENT_ERROR:
            ret.result = SSL_TEST_CLIENT_FAIL;
            goto err;
        case SERVER_ERROR:
            ret.result = SSL_TEST_SERVER_FAIL;
            goto err;
        case INTERNAL_ERROR:
            ret.result = SSL_TEST_INTERNAL_ERROR;
            goto err;
        case HANDSHAKE_RETRY:
            client_turn ^= 1;
            break;
        }
    }
 err:
    ret.server_alert_sent = server_ex_data.alert_sent;
    ret.server_alert_received = client_ex_data.alert_received;
    ret.client_alert_sent = client_ex_data.alert_sent;
    ret.client_alert_received = server_ex_data.alert_received;
    ret.server_protocol = SSL_version(server);
    ret.client_protocol = SSL_version(client);
    ret.servername = server_ex_data.servername;
    if ((sess = SSL_get0_session(client)) != NULL)
        SSL_SESSION_get0_ticket(sess, &tick, &len);
    if (tick == NULL || len == 0)
        ret.session_ticket = SSL_TEST_SESSION_TICKET_NO;
    else
        ret.session_ticket = SSL_TEST_SESSION_TICKET_YES;
    ret.session_ticket_do_not_call = server_ex_data.session_ticket_do_not_call;
    SSL_free(server);
    SSL_free(client);
    return ret;
}
['HANDSHAKE_RESULT do_handshake(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,\n                              SSL_CTX *client_ctx, const SSL_TEST_CTX *test_ctx)\n{\n    SSL *server, *client;\n    BIO *client_to_server, *server_to_client;\n    HANDSHAKE_EX_DATA server_ex_data, client_ex_data;\n    HANDSHAKE_RESULT ret;\n    int client_turn = 1;\n    peer_status_t client_status = PEER_RETRY, server_status = PEER_RETRY;\n    handshake_status_t status = HANDSHAKE_RETRY;\n    unsigned char* tick = NULL;\n    size_t len = 0;\n    SSL_SESSION* sess = NULL;\n    configure_handshake_ctx(server_ctx, server2_ctx, client_ctx, test_ctx);\n    server = SSL_new(server_ctx);\n    client = SSL_new(client_ctx);\n    OPENSSL_assert(server != NULL && client != NULL);\n    configure_handshake_ssl(server, client, test_ctx);\n    memset(&server_ex_data, 0, sizeof(server_ex_data));\n    memset(&client_ex_data, 0, sizeof(client_ex_data));\n    memset(&ret, 0, sizeof(ret));\n    ret.result = SSL_TEST_INTERNAL_ERROR;\n    client_to_server = BIO_new(BIO_s_mem());\n    server_to_client = BIO_new(BIO_s_mem());\n    OPENSSL_assert(client_to_server != NULL && server_to_client != NULL);\n    BIO_set_nbio(client_to_server, 1);\n    BIO_set_nbio(server_to_client, 1);\n    SSL_set_connect_state(client);\n    SSL_set_accept_state(server);\n    SSL_set_bio(client, server_to_client, client_to_server);\n    OPENSSL_assert(BIO_up_ref(server_to_client) > 0);\n    OPENSSL_assert(BIO_up_ref(client_to_server) > 0);\n    SSL_set_bio(server, client_to_server, server_to_client);\n    ex_data_idx = SSL_get_ex_new_index(0, "ex data", NULL, NULL, NULL);\n    OPENSSL_assert(ex_data_idx >= 0);\n    OPENSSL_assert(SSL_set_ex_data(server, ex_data_idx,\n                                   &server_ex_data) == 1);\n    OPENSSL_assert(SSL_set_ex_data(client, ex_data_idx,\n                                   &client_ex_data) == 1);\n    SSL_set_info_callback(server, &info_cb);\n    SSL_set_info_callback(client, &info_cb);\n    for(;;) {\n        if (client_turn) {\n            client_status = do_handshake_step(client);\n            status = handshake_status(client_status, server_status,\n                                      1  );\n        } else {\n            server_status = do_handshake_step(server);\n            status = handshake_status(server_status, client_status,\n                                      0  );\n        }\n        switch (status) {\n        case HANDSHAKE_SUCCESS:\n            ret.result = SSL_TEST_SUCCESS;\n            goto err;\n        case CLIENT_ERROR:\n            ret.result = SSL_TEST_CLIENT_FAIL;\n            goto err;\n        case SERVER_ERROR:\n            ret.result = SSL_TEST_SERVER_FAIL;\n            goto err;\n        case INTERNAL_ERROR:\n            ret.result = SSL_TEST_INTERNAL_ERROR;\n            goto err;\n        case HANDSHAKE_RETRY:\n            client_turn ^= 1;\n            break;\n        }\n    }\n err:\n    ret.server_alert_sent = server_ex_data.alert_sent;\n    ret.server_alert_received = client_ex_data.alert_received;\n    ret.client_alert_sent = client_ex_data.alert_sent;\n    ret.client_alert_received = server_ex_data.alert_received;\n    ret.server_protocol = SSL_version(server);\n    ret.client_protocol = SSL_version(client);\n    ret.servername = server_ex_data.servername;\n    if ((sess = SSL_get0_session(client)) != NULL)\n        SSL_SESSION_get0_ticket(sess, &tick, &len);\n    if (tick == NULL || len == 0)\n        ret.session_ticket = SSL_TEST_SESSION_TICKET_NO;\n    else\n        ret.session_ticket = SSL_TEST_SESSION_TICKET_YES;\n    ret.session_ticket_do_not_call = server_ex_data.session_ticket_do_not_call;\n    SSL_free(server);\n    SSL_free(client);\n    return ret;\n}']