test/danetest.c:141: error: MEMORY_LEAK
  memory dynamically allocated by call to `X509_STORE_CTX_set_ex_data()` at line 127, column 5 is not reachable after line 141, column 5.
Showing all 203 steps of the trace


test/danetest.c:113:1: start of procedure verify_chain()
111.   }
112.   
113. > static int verify_chain(SSL *ssl, STACK_OF(X509) *chain)
114.   {
115.       int ret;

test/danetest.c:117:5: 
115.       int ret;
116.       X509_STORE_CTX *store_ctx;
117. >     SSL_CTX *ssl_ctx = SSL_get_SSL_CTX(ssl);
118.       X509_STORE *store = SSL_CTX_get_cert_store(ssl_ctx);
119.       int store_ctx_idx = SSL_get_ex_data_X509_STORE_CTX_idx();

ssl/ssl_lib.c:3320:1: start of procedure SSL_get_SSL_CTX()
  3318.   }
  3319.   
  3320. > SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
  3321.   {
  3322.       return (ssl->ctx);

ssl/ssl_lib.c:3322:5: 
  3320.   SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
  3321.   {
  3322. >     return (ssl->ctx);
  3323.   }
  3324.   

ssl/ssl_lib.c:3323:1: return from a call to SSL_get_SSL_CTX
  3321.   {
  3322.       return (ssl->ctx);
  3323. > }
  3324.   
  3325.   SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)

test/danetest.c:118:5: 
116.       X509_STORE_CTX *store_ctx;
117.       SSL_CTX *ssl_ctx = SSL_get_SSL_CTX(ssl);
118. >     X509_STORE *store = SSL_CTX_get_cert_store(ssl_ctx);
119.       int store_ctx_idx = SSL_get_ex_data_X509_STORE_CTX_idx();
120.       X509 *cert = sk_X509_value(chain, 0);

ssl/ssl_lib.c:3493:1: start of procedure SSL_CTX_get_cert_store()
  3491.   }
  3492.   
  3493. > X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
  3494.   {
  3495.       return (ctx->cert_store);

ssl/ssl_lib.c:3495:5: 
  3493.   X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
  3494.   {
  3495. >     return (ctx->cert_store);
  3496.   }
  3497.   

ssl/ssl_lib.c:3496:1: return from a call to SSL_CTX_get_cert_store
  3494.   {
  3495.       return (ctx->cert_store);
  3496. > }
  3497.   
  3498.   void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)

test/danetest.c:119:5: Skipping SSL_get_ex_data_X509_STORE_CTX_idx(): empty list of specs
117.       SSL_CTX *ssl_ctx = SSL_get_SSL_CTX(ssl);
118.       X509_STORE *store = SSL_CTX_get_cert_store(ssl_ctx);
119.       int store_ctx_idx = SSL_get_ex_data_X509_STORE_CTX_idx();
           ^
120.       X509 *cert = sk_X509_value(chain, 0);
121.   

test/danetest.c:120:5: 
118.       X509_STORE *store = SSL_CTX_get_cert_store(ssl_ctx);
119.       int store_ctx_idx = SSL_get_ex_data_X509_STORE_CTX_idx();
120. >     X509 *cert = sk_X509_value(chain, 0);
121.   
122.       if ((store_ctx = X509_STORE_CTX_new()) == NULL)

include/openssl/x509.h:169:1: start of procedure sk_X509_value()
  167.   typedef struct x509_cinf_st X509_CINF;
  168.   
  169. > DEFINE_STACK_OF(X509)
  170.   
  171.   /* This is used for a table of trust checking functions */

crypto/stack/stack.c:323:1: start of procedure sk_value()
    321.   }
    322.   
    323. > void *sk_value(const _STACK *st, int i)
    324.   {
    325.       if (!st || (i < 0) || (i >= st->num))

crypto/stack/stack.c:325:10: Taking true branch
    323.   void *sk_value(const _STACK *st, int i)
    324.   {
    325.       if (!st || (i < 0) || (i >= st->num))
                    ^
    326.           return NULL;
    327.       return st->data[i];

crypto/stack/stack.c:326:9: 
    324.   {
    325.       if (!st || (i < 0) || (i >= st->num))
    326. >         return NULL;
    327.       return st->data[i];
    328.   }

crypto/stack/stack.c:328:1: return from a call to sk_value
    326.           return NULL;
    327.       return st->data[i];
    328. > }
    329.   
    330.   void *sk_set(_STACK *st, int i, void *value)

include/openssl/x509.h:169:1: return from a call to sk_X509_value
  167.   typedef struct x509_cinf_st X509_CINF;
  168.   
  169. > DEFINE_STACK_OF(X509)
  170.   
  171.   /* This is used for a table of trust checking functions */

test/danetest.c:122:9: 
120.       X509 *cert = sk_X509_value(chain, 0);
121.   
122. >     if ((store_ctx = X509_STORE_CTX_new()) == NULL)
123.           return -1;
124.   

crypto/x509/x509_vfy.c:2159:1: start of procedure X509_STORE_CTX_new()
  2157.   }
  2158.   
  2159. > X509_STORE_CTX *X509_STORE_CTX_new(void)
  2160.   {
  2161.       X509_STORE_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));

crypto/x509/x509_vfy.c:2161:5: 
  2159.   X509_STORE_CTX *X509_STORE_CTX_new(void)
  2160.   {
  2161. >     X509_STORE_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
  2162.   
  2163.       if (ctx == NULL) {

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
    154.   }
    155.   
    156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
    157.   {
    158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
    156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
    157.   {
    158. >     void *ret = CRYPTO_malloc(num, file, line);
    159.   
    160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
      117.   }
      118.   
      119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
      120.   {
      121.       void *ret = NULL;

crypto/mem.c:121:5: 
      119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
      120.   {
      121. >     void *ret = NULL;
      122.   
      123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
      121.       void *ret = NULL;
      122.   
      123.       if (num <= 0)
                     ^
      124.           return NULL;
      125.   

crypto/mem.c:126:5: 
      124.           return NULL;
      125.   
      126. >     allow_customize = 0;
      127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
      128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
      134.       }
      135.   #else
      136. >     (void)file;
      137.       (void)line;
      138.       ret = malloc(num);

crypto/mem.c:137:5: 
      135.   #else
      136.       (void)file;
      137. >     (void)line;
      138.       ret = malloc(num);
      139.   #endif

crypto/mem.c:138:5: 
      136.       (void)file;
      137.       (void)line;
      138. >     ret = malloc(num);
      139.   #endif
      140.   

crypto/mem.c:153:5: 
      151.   #endif
      152.   
      153. >     return ret;
      154.   }
      155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
      152.   
      153.       return ret;
      154. > }
      155.   
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
    158.       void *ret = CRYPTO_malloc(num, file, line);
    159.   
    160.       if (ret != NULL)
                   ^
    161.           memset(ret, 0, num);
    162.       return ret;

crypto/mem.c:161:9: 
    159.   
    160.       if (ret != NULL)
    161. >         memset(ret, 0, num);
    162.       return ret;
    163.   }

crypto/mem.c:162:5: 
    160.       if (ret != NULL)
    161.           memset(ret, 0, num);
    162. >     return ret;
    163.   }
    164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
    161.           memset(ret, 0, num);
    162.       return ret;
    163. > }
    164.   
    165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/x509/x509_vfy.c:2163:9: Taking false branch
  2161.       X509_STORE_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
  2162.   
  2163.       if (ctx == NULL) {
                  ^
  2164.           X509err(X509_F_X509_STORE_CTX_NEW, ERR_R_MALLOC_FAILURE);
  2165.           return NULL;

crypto/x509/x509_vfy.c:2167:5: 
  2165.           return NULL;
  2166.       }
  2167. >     return ctx;
  2168.   }
  2169.   

crypto/x509/x509_vfy.c:2168:1: return from a call to X509_STORE_CTX_new
  2166.       }
  2167.       return ctx;
  2168. > }
  2169.   
  2170.   void X509_STORE_CTX_free(X509_STORE_CTX *ctx)

test/danetest.c:122:9: Taking false branch
120.       X509 *cert = sk_X509_value(chain, 0);
121.   
122.       if ((store_ctx = X509_STORE_CTX_new()) == NULL)
               ^
123.           return -1;
124.   

test/danetest.c:125:10: Taking false branch
123.           return -1;
124.   
125.       if (!X509_STORE_CTX_init(store_ctx, store, cert, chain))
                ^
126.   	return 0;
127.       X509_STORE_CTX_set_ex_data(store_ctx, store_ctx_idx, ssl);

test/danetest.c:127:5: 
125.       if (!X509_STORE_CTX_init(store_ctx, store, cert, chain))
126.   	return 0;
127. >     X509_STORE_CTX_set_ex_data(store_ctx, store_ctx_idx, ssl);
128.   
129.       X509_STORE_CTX_set_default(store_ctx,

crypto/x509/x509_vfy.c:2006:1: start of procedure X509_STORE_CTX_set_ex_data()
  2004.   }
  2005.   
  2006. > int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
  2007.   {
  2008.       return CRYPTO_set_ex_data(&ctx->ex_data, idx, data);

crypto/x509/x509_vfy.c:2008:5: 
  2006.   int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
  2007.   {
  2008. >     return CRYPTO_set_ex_data(&ctx->ex_data, idx, data);
  2009.   }
  2010.   

crypto/ex_data.c:418:1: start of procedure CRYPTO_set_ex_data()
    416.    * particular index in the class used by this variable
    417.    */
    418. > int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val)
    419.   {
    420.       int i;

crypto/ex_data.c:422:9: Taking true branch
    420.       int i;
    421.   
    422.       if (ad->sk == NULL) {
                   ^
    423.           if ((ad->sk = sk_void_new_null()) == NULL) {
    424.               CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);

crypto/ex_data.c:423:13: 
    421.   
    422.       if (ad->sk == NULL) {
    423. >         if ((ad->sk = sk_void_new_null()) == NULL) {
    424.               CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);
    425.               return 0;

include/openssl/crypto.h:263:1: start of procedure sk_void_new_null()
      261.       STACK_OF(void) *sk;
      262.   };
      263. > DEFINE_STACK_OF(void)
      264.   
      265.   /*

crypto/stack/stack.c:144:1: start of procedure sk_new_null()
        142.   }
        143.   
        144. > _STACK *sk_new_null(void)
        145.   {
        146.       return sk_new((int (*)(const void *, const void *))0);

crypto/stack/stack.c:146:5: 
        144.   _STACK *sk_new_null(void)
        145.   {
        146. >     return sk_new((int (*)(const void *, const void *))0);
        147.   }
        148.   

crypto/stack/stack.c:149:1: start of procedure sk_new()
          147.   }
          148.   
          149. > _STACK *sk_new(int (*c) (const void *, const void *))
          150.   {
          151.       _STACK *ret;

crypto/stack/stack.c:153:9: 
          151.       _STACK *ret;
          152.   
          153. >     if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
          154.           goto err;
          155.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
            154.   }
            155.   
            156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
            157.   {
            158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
            156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
            157.   {
            158. >     void *ret = CRYPTO_malloc(num, file, line);
            159.   
            160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
              117.   }
              118.   
              119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
              120.   {
              121.       void *ret = NULL;

crypto/mem.c:121:5: 
              119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
              120.   {
              121. >     void *ret = NULL;
              122.   
              123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
              121.       void *ret = NULL;
              122.   
              123.       if (num <= 0)
                             ^
              124.           return NULL;
              125.   

crypto/mem.c:126:5: 
              124.           return NULL;
              125.   
              126. >     allow_customize = 0;
              127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
              128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
              134.       }
              135.   #else
              136. >     (void)file;
              137.       (void)line;
              138.       ret = malloc(num);

crypto/mem.c:137:5: 
              135.   #else
              136.       (void)file;
              137. >     (void)line;
              138.       ret = malloc(num);
              139.   #endif

crypto/mem.c:138:5: 
              136.       (void)file;
              137.       (void)line;
              138. >     ret = malloc(num);
              139.   #endif
              140.   

crypto/mem.c:153:5: 
              151.   #endif
              152.   
              153. >     return ret;
              154.   }
              155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
              152.   
              153.       return ret;
              154. > }
              155.   
              156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
            158.       void *ret = CRYPTO_malloc(num, file, line);
            159.   
            160.       if (ret != NULL)
                           ^
            161.           memset(ret, 0, num);
            162.       return ret;

crypto/mem.c:161:9: 
            159.   
            160.       if (ret != NULL)
            161. >         memset(ret, 0, num);
            162.       return ret;
            163.   }

crypto/mem.c:162:5: 
            160.       if (ret != NULL)
            161.           memset(ret, 0, num);
            162. >     return ret;
            163.   }
            164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
            161.           memset(ret, 0, num);
            162.       return ret;
            163. > }
            164.   
            165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/stack/stack.c:153:9: Taking false branch
          151.       _STACK *ret;
          152.   
          153.       if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
                         ^
          154.           goto err;
          155.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)

crypto/stack/stack.c:155:9: 
          153.       if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
          154.           goto err;
          155. >     if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
          156.           goto err;
          157.       ret->comp = c;

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
            154.   }
            155.   
            156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
            157.   {
            158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
            156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
            157.   {
            158. >     void *ret = CRYPTO_malloc(num, file, line);
            159.   
            160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
              117.   }
              118.   
              119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
              120.   {
              121.       void *ret = NULL;

crypto/mem.c:121:5: 
              119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
              120.   {
              121. >     void *ret = NULL;
              122.   
              123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
              121.       void *ret = NULL;
              122.   
              123.       if (num <= 0)
                             ^
              124.           return NULL;
              125.   

crypto/mem.c:126:5: 
              124.           return NULL;
              125.   
              126. >     allow_customize = 0;
              127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
              128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
              134.       }
              135.   #else
              136. >     (void)file;
              137.       (void)line;
              138.       ret = malloc(num);

crypto/mem.c:137:5: 
              135.   #else
              136.       (void)file;
              137. >     (void)line;
              138.       ret = malloc(num);
              139.   #endif

crypto/mem.c:138:5: 
              136.       (void)file;
              137.       (void)line;
              138. >     ret = malloc(num);
              139.   #endif
              140.   

crypto/mem.c:153:5: 
              151.   #endif
              152.   
              153. >     return ret;
              154.   }
              155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
              152.   
              153.       return ret;
              154. > }
              155.   
              156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
            158.       void *ret = CRYPTO_malloc(num, file, line);
            159.   
            160.       if (ret != NULL)
                           ^
            161.           memset(ret, 0, num);
            162.       return ret;

crypto/mem.c:161:9: 
            159.   
            160.       if (ret != NULL)
            161. >         memset(ret, 0, num);
            162.       return ret;
            163.   }

crypto/mem.c:162:5: 
            160.       if (ret != NULL)
            161.           memset(ret, 0, num);
            162. >     return ret;
            163.   }
            164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
            161.           memset(ret, 0, num);
            162.       return ret;
            163. > }
            164.   
            165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/stack/stack.c:155:9: Taking false branch
          153.       if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
          154.           goto err;
          155.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
                         ^
          156.           goto err;
          157.       ret->comp = c;

crypto/stack/stack.c:157:5: 
          155.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
          156.           goto err;
          157. >     ret->comp = c;
          158.       ret->num_alloc = MIN_NODES;
          159.       return (ret);

crypto/stack/stack.c:158:5: 
          156.           goto err;
          157.       ret->comp = c;
          158. >     ret->num_alloc = MIN_NODES;
          159.       return (ret);
          160.   

crypto/stack/stack.c:159:5: 
          157.       ret->comp = c;
          158.       ret->num_alloc = MIN_NODES;
          159. >     return (ret);
          160.   
          161.    err:

crypto/stack/stack.c:164:1: return from a call to sk_new
          162.       OPENSSL_free(ret);
          163.       return (NULL);
          164. > }
          165.   
          166.   int sk_insert(_STACK *st, void *data, int loc)

crypto/stack/stack.c:147:1: return from a call to sk_new_null
        145.   {
        146.       return sk_new((int (*)(const void *, const void *))0);
        147. > }
        148.   
        149.   _STACK *sk_new(int (*c) (const void *, const void *))

include/openssl/crypto.h:263:1: return from a call to sk_void_new_null
      261.       STACK_OF(void) *sk;
      262.   };
      263. > DEFINE_STACK_OF(void)
      264.   
      265.   /*

crypto/ex_data.c:423:13: Taking false branch
    421.   
    422.       if (ad->sk == NULL) {
    423.           if ((ad->sk = sk_void_new_null()) == NULL) {
                       ^
    424.               CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);
    425.               return 0;

crypto/ex_data.c:429:10: 
    427.       }
    428.   
    429. >     for (i = sk_void_num(ad->sk); i <= idx; ++i) {
    430.           if (!sk_void_push(ad->sk, NULL)) {
    431.               CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);

include/openssl/crypto.h:263:1: start of procedure sk_void_num()
      261.       STACK_OF(void) *sk;
      262.   };
      263. > DEFINE_STACK_OF(void)
      264.   
      265.   /*

crypto/stack/stack.c:316:1: start of procedure sk_num()
        314.   }
        315.   
        316. > int sk_num(const _STACK *st)
        317.   {
        318.       if (st == NULL)

crypto/stack/stack.c:318:9: Taking false branch
        316.   int sk_num(const _STACK *st)
        317.   {
        318.       if (st == NULL)
                       ^
        319.           return -1;
        320.       return st->num;

crypto/stack/stack.c:320:5: 
        318.       if (st == NULL)
        319.           return -1;
        320. >     return st->num;
        321.   }
        322.   

crypto/stack/stack.c:321:1: return from a call to sk_num
        319.           return -1;
        320.       return st->num;
        321. > }
        322.   
        323.   void *sk_value(const _STACK *st, int i)

include/openssl/crypto.h:263:1: return from a call to sk_void_num
      261.       STACK_OF(void) *sk;
      262.   };
      263. > DEFINE_STACK_OF(void)
      264.   
      265.   /*

crypto/ex_data.c:429:35: Loop condition is false. Leaving loop
    427.       }
    428.   
    429.       for (i = sk_void_num(ad->sk); i <= idx; ++i) {
                                             ^
    430.           if (!sk_void_push(ad->sk, NULL)) {
    431.               CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);

crypto/ex_data.c:435:5: 
    433.           }
    434.       }
    435. >     sk_void_set(ad->sk, idx, val);
    436.       return 1;
    437.   }

include/openssl/crypto.h:263:1: start of procedure sk_void_set()
      261.       STACK_OF(void) *sk;
      262.   };
      263. > DEFINE_STACK_OF(void)
      264.   
      265.   /*

crypto/stack/stack.c:330:1: start of procedure sk_set()
        328.   }
        329.   
        330. > void *sk_set(_STACK *st, int i, void *value)
        331.   {
        332.       if (!st || (i < 0) || (i >= st->num))

crypto/stack/stack.c:332:10: Taking false branch
        330.   void *sk_set(_STACK *st, int i, void *value)
        331.   {
        332.       if (!st || (i < 0) || (i >= st->num))
                        ^
        333.           return NULL;
        334.       return (st->data[i] = value);

crypto/stack/stack.c:332:17: Taking true branch
        330.   void *sk_set(_STACK *st, int i, void *value)
        331.   {
        332.       if (!st || (i < 0) || (i >= st->num))
                               ^
        333.           return NULL;
        334.       return (st->data[i] = value);

crypto/stack/stack.c:333:9: 
        331.   {
        332.       if (!st || (i < 0) || (i >= st->num))
        333. >         return NULL;
        334.       return (st->data[i] = value);
        335.   }

crypto/stack/stack.c:335:1: return from a call to sk_set
        333.           return NULL;
        334.       return (st->data[i] = value);
        335. > }
        336.   
        337.   void sk_sort(_STACK *st)

include/openssl/crypto.h:263:1: return from a call to sk_void_set
      261.       STACK_OF(void) *sk;
      262.   };
      263. > DEFINE_STACK_OF(void)
      264.   
      265.   /*

crypto/ex_data.c:436:5: 
    434.       }
    435.       sk_void_set(ad->sk, idx, val);
    436. >     return 1;
    437.   }
    438.   

crypto/ex_data.c:437:1: return from a call to CRYPTO_set_ex_data
    435.       sk_void_set(ad->sk, idx, val);
    436.       return 1;
    437. > }
    438.   
    439.   /*

crypto/x509/x509_vfy.c:2009:1: return from a call to X509_STORE_CTX_set_ex_data
  2007.   {
  2008.       return CRYPTO_set_ex_data(&ctx->ex_data, idx, data);
  2009. > }
  2010.   
  2011.   void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx)

test/danetest.c:130:13: 
128.   
129.       X509_STORE_CTX_set_default(store_ctx,
130. >             SSL_is_server(ssl) ? "ssl_client" : "ssl_server");
131.       X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(store_ctx),
132.               SSL_get0_param(ssl));

ssl/ssl_lib.c:3716:1: start of procedure SSL_is_server()
  3714.   }
  3715.   
  3716. > int SSL_is_server(SSL *s)
  3717.   {
  3718.       return s->server;

ssl/ssl_lib.c:3718:5: 
  3716.   int SSL_is_server(SSL *s)
  3717.   {
  3718. >     return s->server;
  3719.   }
  3720.   

ssl/ssl_lib.c:3719:1: return from a call to SSL_is_server
  3717.   {
  3718.       return s->server;
  3719. > }
  3720.   
  3721.   #if OPENSSL_API_COMPAT < 0x10100000L

test/danetest.c:130:13: Condition is true
128.   
129.       X509_STORE_CTX_set_default(store_ctx,
130.               SSL_is_server(ssl) ? "ssl_client" : "ssl_server");
                   ^
131.       X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(store_ctx),
132.               SSL_get0_param(ssl));

test/danetest.c:129:5: 
127.       X509_STORE_CTX_set_ex_data(store_ctx, store_ctx_idx, ssl);
128.   
129. >     X509_STORE_CTX_set_default(store_ctx,
130.               SSL_is_server(ssl) ? "ssl_client" : "ssl_server");
131.       X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(store_ctx),

crypto/x509/x509_vfy.c:2390:1: start of procedure X509_STORE_CTX_set_default()
  2388.   }
  2389.   
  2390. > int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
  2391.   {
  2392.       const X509_VERIFY_PARAM *param;

crypto/x509/x509_vfy.c:2393:5: 
  2391.   {
  2392.       const X509_VERIFY_PARAM *param;
  2393. >     param = X509_VERIFY_PARAM_lookup(name);
  2394.       if (!param)
  2395.           return 0;

crypto/x509/x509_vpm.c:615:1: start of procedure X509_VERIFY_PARAM_lookup()
    613.   }
    614.   
    615. > const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name)
    616.   {
    617.       int idx;

crypto/x509/x509_vpm.c:620:5: 
    618.       X509_VERIFY_PARAM pm;
    619.   
    620. >     pm.name = (char *)name;
    621.       if (param_table) {
    622.           idx = sk_X509_VERIFY_PARAM_find(param_table, &pm);

crypto/x509/x509_vpm.c:621:9: Taking true branch
    619.   
    620.       pm.name = (char *)name;
    621.       if (param_table) {
                   ^
    622.           idx = sk_X509_VERIFY_PARAM_find(param_table, &pm);
    623.           if (idx != -1)

crypto/x509/x509_vpm.c:622:9: 
    620.       pm.name = (char *)name;
    621.       if (param_table) {
    622. >         idx = sk_X509_VERIFY_PARAM_find(param_table, &pm);
    623.           if (idx != -1)
    624.               return sk_X509_VERIFY_PARAM_value(param_table, idx);

include/openssl/x509_vfy.h:146:1: start of procedure sk_X509_VERIFY_PARAM_find()
      144.   typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;
      145.   
      146. > DEFINE_STACK_OF(X509_VERIFY_PARAM)
      147.   
      148.   /*

crypto/stack/stack.c:248:1: start of procedure sk_find()
        246.   }
        247.   
        248. > int sk_find(_STACK *st, void *data)
        249.   {
        250.       return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH);

crypto/stack/stack.c:250:5: 
        248.   int sk_find(_STACK *st, void *data)
        249.   {
        250. >     return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH);
        251.   }
        252.   

crypto/stack/stack.c:224:1: start of procedure internal_find()
          222.   }
          223.   
          224. > static int internal_find(_STACK *st, void *data, int ret_val_options)
          225.   {
          226.       const void *const *r;

crypto/stack/stack.c:229:9: Taking false branch
          227.       int i;
          228.   
          229.       if (st == NULL)
                         ^
          230.           return -1;
          231.   

crypto/stack/stack.c:232:9: Taking true branch
          230.           return -1;
          231.   
          232.       if (st->comp == NULL) {
                         ^
          233.           for (i = 0; i < st->num; i++)
          234.               if (st->data[i] == data)

crypto/stack/stack.c:233:14: 
          231.   
          232.       if (st->comp == NULL) {
          233. >         for (i = 0; i < st->num; i++)
          234.               if (st->data[i] == data)
          235.                   return (i);

crypto/stack/stack.c:233:21: Loop condition is true. Entering loop body
          231.   
          232.       if (st->comp == NULL) {
          233.           for (i = 0; i < st->num; i++)
                                     ^
          234.               if (st->data[i] == data)
          235.                   return (i);

crypto/stack/stack.c:234:17: Taking false branch
          232.       if (st->comp == NULL) {
          233.           for (i = 0; i < st->num; i++)
          234.               if (st->data[i] == data)
                                 ^
          235.                   return (i);
          236.           return (-1);

crypto/stack/stack.c:233:34: 
          231.   
          232.       if (st->comp == NULL) {
          233. >         for (i = 0; i < st->num; i++)
          234.               if (st->data[i] == data)
          235.                   return (i);

crypto/stack/stack.c:233:21: Loop condition is true. Entering loop body
          231.   
          232.       if (st->comp == NULL) {
          233.           for (i = 0; i < st->num; i++)
                                     ^
          234.               if (st->data[i] == data)
          235.                   return (i);

crypto/stack/stack.c:234:17: Taking true branch
          232.       if (st->comp == NULL) {
          233.           for (i = 0; i < st->num; i++)
          234.               if (st->data[i] == data)
                                 ^
          235.                   return (i);
          236.           return (-1);

crypto/stack/stack.c:235:17: 
          233.           for (i = 0; i < st->num; i++)
          234.               if (st->data[i] == data)
          235. >                 return (i);
          236.           return (-1);
          237.       }

crypto/stack/stack.c:246:1: return from a call to internal_find
          244.           return (-1);
          245.       return (int)((char **)r - st->data);
          246. > }
          247.   
          248.   int sk_find(_STACK *st, void *data)

crypto/stack/stack.c:251:1: return from a call to sk_find
        249.   {
        250.       return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH);
        251. > }
        252.   
        253.   int sk_find_ex(_STACK *st, void *data)

include/openssl/x509_vfy.h:146:1: return from a call to sk_X509_VERIFY_PARAM_find
      144.   typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;
      145.   
      146. > DEFINE_STACK_OF(X509_VERIFY_PARAM)
      147.   
      148.   /*

crypto/x509/x509_vpm.c:623:13: Taking true branch
    621.       if (param_table) {
    622.           idx = sk_X509_VERIFY_PARAM_find(param_table, &pm);
    623.           if (idx != -1)
                       ^
    624.               return sk_X509_VERIFY_PARAM_value(param_table, idx);
    625.       }

crypto/x509/x509_vpm.c:624:13: 
    622.           idx = sk_X509_VERIFY_PARAM_find(param_table, &pm);
    623.           if (idx != -1)
    624. >             return sk_X509_VERIFY_PARAM_value(param_table, idx);
    625.       }
    626.       return OBJ_bsearch_table(&pm, default_table, OSSL_NELEM(default_table));

include/openssl/x509_vfy.h:146:1: start of procedure sk_X509_VERIFY_PARAM_value()
      144.   typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;
      145.   
      146. > DEFINE_STACK_OF(X509_VERIFY_PARAM)
      147.   
      148.   /*

crypto/stack/stack.c:323:1: start of procedure sk_value()
        321.   }
        322.   
        323. > void *sk_value(const _STACK *st, int i)
        324.   {
        325.       if (!st || (i < 0) || (i >= st->num))

crypto/stack/stack.c:325:10: Taking false branch
        323.   void *sk_value(const _STACK *st, int i)
        324.   {
        325.       if (!st || (i < 0) || (i >= st->num))
                        ^
        326.           return NULL;
        327.       return st->data[i];

crypto/stack/stack.c:325:17: Taking true branch
        323.   void *sk_value(const _STACK *st, int i)
        324.   {
        325.       if (!st || (i < 0) || (i >= st->num))
                               ^
        326.           return NULL;
        327.       return st->data[i];

crypto/stack/stack.c:326:9: 
        324.   {
        325.       if (!st || (i < 0) || (i >= st->num))
        326. >         return NULL;
        327.       return st->data[i];
        328.   }

crypto/stack/stack.c:328:1: return from a call to sk_value
        326.           return NULL;
        327.       return st->data[i];
        328. > }
        329.   
        330.   void *sk_set(_STACK *st, int i, void *value)

include/openssl/x509_vfy.h:146:1: return from a call to sk_X509_VERIFY_PARAM_value
      144.   typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;
      145.   
      146. > DEFINE_STACK_OF(X509_VERIFY_PARAM)
      147.   
      148.   /*

crypto/x509/x509_vpm.c:627:1: return from a call to X509_VERIFY_PARAM_lookup
    625.       }
    626.       return OBJ_bsearch_table(&pm, default_table, OSSL_NELEM(default_table));
    627. > }
    628.   
    629.   void X509_VERIFY_PARAM_table_cleanup(void)

crypto/x509/x509_vfy.c:2394:10: Taking true branch
  2392.       const X509_VERIFY_PARAM *param;
  2393.       param = X509_VERIFY_PARAM_lookup(name);
  2394.       if (!param)
                   ^
  2395.           return 0;
  2396.       return X509_VERIFY_PARAM_inherit(ctx->param, param);

crypto/x509/x509_vfy.c:2395:9: 
  2393.       param = X509_VERIFY_PARAM_lookup(name);
  2394.       if (!param)
  2395. >         return 0;
  2396.       return X509_VERIFY_PARAM_inherit(ctx->param, param);
  2397.   }

crypto/x509/x509_vfy.c:2397:1: return from a call to X509_STORE_CTX_set_default
  2395.           return 0;
  2396.       return X509_VERIFY_PARAM_inherit(ctx->param, param);
  2397. > }
  2398.   
  2399.   X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx)

test/danetest.c:131:5: 
129.       X509_STORE_CTX_set_default(store_ctx,
130.               SSL_is_server(ssl) ? "ssl_client" : "ssl_server");
131. >     X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(store_ctx),
132.               SSL_get0_param(ssl));
133.       store_ctx_dane_init(store_ctx, ssl);

crypto/x509/x509_vfy.c:2399:1: start of procedure X509_STORE_CTX_get0_param()
  2397.   }
  2398.   
  2399. > X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx)
  2400.   {
  2401.       return ctx->param;

crypto/x509/x509_vfy.c:2401:5: 
  2399.   X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx)
  2400.   {
  2401. >     return ctx->param;
  2402.   }
  2403.   

crypto/x509/x509_vfy.c:2402:1: return from a call to X509_STORE_CTX_get0_param
  2400.   {
  2401.       return ctx->param;
  2402. > }
  2403.   
  2404.   void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)

ssl/ssl_lib.c:980:1: start of procedure SSL_get0_param()
  978.   }
  979.   
  980. > X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
  981.   {
  982.       return ssl->param;

ssl/ssl_lib.c:982:5: 
  980.   X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
  981.   {
  982. >     return ssl->param;
  983.   }
  984.   

ssl/ssl_lib.c:983:1: return from a call to SSL_get0_param
  981.   {
  982.       return ssl->param;
  983. > }
  984.   
  985.   void SSL_certs_clear(SSL *s)

crypto/x509/x509_vpm.c:293:1: start of procedure X509_VERIFY_PARAM_set1()
  291.   }
  292.   
  293. > int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to,
  294.                              const X509_VERIFY_PARAM *from)
  295.   {

crypto/x509/x509_vpm.c:296:5: 
  294.                              const X509_VERIFY_PARAM *from)
  295.   {
  296. >     unsigned long save_flags = to->inh_flags;
  297.       int ret;
  298.       to->inh_flags |= X509_VP_FLAG_DEFAULT;

crypto/x509/x509_vpm.c:298:5: 
  296.       unsigned long save_flags = to->inh_flags;
  297.       int ret;
  298. >     to->inh_flags |= X509_VP_FLAG_DEFAULT;
  299.       ret = X509_VERIFY_PARAM_inherit(to, from);
  300.       to->inh_flags = save_flags;

crypto/x509/x509_vpm.c:299:5: Skipping X509_VERIFY_PARAM_inherit(): empty list of specs
  297.       int ret;
  298.       to->inh_flags |= X509_VP_FLAG_DEFAULT;
  299.       ret = X509_VERIFY_PARAM_inherit(to, from);
             ^
  300.       to->inh_flags = save_flags;
  301.       return ret;

crypto/x509/x509_vpm.c:300:5: 
  298.       to->inh_flags |= X509_VP_FLAG_DEFAULT;
  299.       ret = X509_VERIFY_PARAM_inherit(to, from);
  300. >     to->inh_flags = save_flags;
  301.       return ret;
  302.   }

crypto/x509/x509_vpm.c:301:5: 
  299.       ret = X509_VERIFY_PARAM_inherit(to, from);
  300.       to->inh_flags = save_flags;
  301. >     return ret;
  302.   }
  303.   

crypto/x509/x509_vpm.c:302:1: return from a call to X509_VERIFY_PARAM_set1
  300.       to->inh_flags = save_flags;
  301.       return ret;
  302. > }
  303.   
  304.   static int int_x509_param_set1(char **pdest, size_t *pdestlen,

test/danetest.c:133:5: 
131.       X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(store_ctx),
132.               SSL_get0_param(ssl));
133. >     store_ctx_dane_init(store_ctx, ssl);
134.   
135.       if (SSL_get_verify_callback(ssl))

test/danetest.c:537:1: start of procedure store_ctx_dane_init()
  535.   #include <internal/dane.h>
  536.   
  537. > static void store_ctx_dane_init(X509_STORE_CTX *store_ctx, SSL *ssl)
  538.   {
  539.       X509_STORE_CTX_set0_dane(store_ctx, SSL_get0_dane(ssl));

test/danetest.c:539:5: 
  537.   static void store_ctx_dane_init(X509_STORE_CTX *store_ctx, SSL *ssl)
  538.   {
  539. >     X509_STORE_CTX_set0_dane(store_ctx, SSL_get0_dane(ssl));
  540.   }

ssl/ssl_lib.c:949:1: start of procedure SSL_get0_dane()
    947.   }
    948.   
    949. > struct dane_st *SSL_get0_dane(SSL *s)
    950.   {
    951.       return &s->dane;

ssl/ssl_lib.c:951:5: 
    949.   struct dane_st *SSL_get0_dane(SSL *s)
    950.   {
    951. >     return &s->dane;
    952.   }
    953.   

ssl/ssl_lib.c:952:1: return from a call to SSL_get0_dane
    950.   {
    951.       return &s->dane;
    952. > }
    953.   
    954.   int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,

crypto/x509/x509_vfy.c:2410:1: start of procedure X509_STORE_CTX_set0_dane()
    2408.   }
    2409.   
    2410. > void X509_STORE_CTX_set0_dane(X509_STORE_CTX *ctx, struct dane_st *dane)
    2411.   {
    2412.       ctx->dane = dane;

crypto/x509/x509_vfy.c:2412:5: 
    2410.   void X509_STORE_CTX_set0_dane(X509_STORE_CTX *ctx, struct dane_st *dane)
    2411.   {
    2412. >     ctx->dane = dane;
    2413.   }
    2414.   

crypto/x509/x509_vfy.c:2413:1: return from a call to X509_STORE_CTX_set0_dane
    2411.   {
    2412.       ctx->dane = dane;
    2413. > }
    2414.   
    2415.   static unsigned char *dane_i2d(

test/danetest.c:540:1: return from a call to store_ctx_dane_init
  538.   {
  539.       X509_STORE_CTX_set0_dane(store_ctx, SSL_get0_dane(ssl));
  540. > }

test/danetest.c:135:9: 
133.       store_ctx_dane_init(store_ctx, ssl);
134.   
135. >     if (SSL_get_verify_callback(ssl))
136.   	X509_STORE_CTX_set_verify_cb(store_ctx, SSL_get_verify_callback(ssl));
137.   

ssl/ssl_lib.c:1246:1: start of procedure SSL_get_verify_callback()
  1244.   }
  1245.   
  1246. > int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
  1247.       return (s->verify_callback);
  1248.   }

ssl/ssl_lib.c:1247:5: 
  1245.   
  1246.   int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
  1247. >     return (s->verify_callback);
  1248.   }
  1249.   

ssl/ssl_lib.c:1248:1: return from a call to SSL_get_verify_callback
  1246.   int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
  1247.       return (s->verify_callback);
  1248. > }
  1249.   
  1250.   int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)

test/danetest.c:135:9: Taking true branch
133.       store_ctx_dane_init(store_ctx, ssl);
134.   
135.       if (SSL_get_verify_callback(ssl))
               ^
136.   	X509_STORE_CTX_set_verify_cb(store_ctx, SSL_get_verify_callback(ssl));
137.   

test/danetest.c:136:2: 
134.   
135.       if (SSL_get_verify_callback(ssl))
136. > 	X509_STORE_CTX_set_verify_cb(store_ctx, SSL_get_verify_callback(ssl));
137.   
138.       ret = X509_verify_cert(store_ctx);

ssl/ssl_lib.c:1246:1: start of procedure SSL_get_verify_callback()
  1244.   }
  1245.   
  1246. > int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
  1247.       return (s->verify_callback);
  1248.   }

ssl/ssl_lib.c:1247:5: 
  1245.   
  1246.   int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
  1247. >     return (s->verify_callback);
  1248.   }
  1249.   

ssl/ssl_lib.c:1248:1: return from a call to SSL_get_verify_callback
  1246.   int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
  1247.       return (s->verify_callback);
  1248. > }
  1249.   
  1250.   int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)

crypto/x509/x509_vfy.c:2369:1: start of procedure X509_STORE_CTX_set_verify_cb()
  2367.   }
  2368.   
  2369. > void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
  2370.                                     int (*verify_cb) (int, X509_STORE_CTX *))
  2371.   {

crypto/x509/x509_vfy.c:2372:5: 
  2370.                                     int (*verify_cb) (int, X509_STORE_CTX *))
  2371.   {
  2372. >     ctx->verify_cb = verify_cb;
  2373.   }
  2374.   

crypto/x509/x509_vfy.c:2373:1: return from a call to X509_STORE_CTX_set_verify_cb
  2371.   {
  2372.       ctx->verify_cb = verify_cb;
  2373. > }
  2374.   
  2375.   X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx)

test/danetest.c:138:5: 
136.   	X509_STORE_CTX_set_verify_cb(store_ctx, SSL_get_verify_callback(ssl));
137.   
138. >     ret = X509_verify_cert(store_ctx);
139.   
140.       SSL_set_verify_result(ssl, X509_STORE_CTX_get_error(store_ctx));

crypto/x509/x509_vfy.c:238:1: start of procedure X509_verify_cert()
  236.   }
  237.   
  238. > int X509_verify_cert(X509_STORE_CTX *ctx)
  239.   {
  240.       struct dane_st *dane = (struct dane_st *)ctx->dane;

crypto/x509/x509_vfy.c:240:5: 
  238.   int X509_verify_cert(X509_STORE_CTX *ctx)
  239.   {
  240. >     struct dane_st *dane = (struct dane_st *)ctx->dane;
  241.   
  242.       if (ctx->cert == NULL) {

crypto/x509/x509_vfy.c:242:9: Taking false branch
  240.       struct dane_st *dane = (struct dane_st *)ctx->dane;
  241.   
  242.       if (ctx->cert == NULL) {
                 ^
  243.           X509err(X509_F_X509_VERIFY_CERT, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY);
  244.           return -1;

crypto/x509/x509_vfy.c:247:9: Taking true branch
  245.       }
  246.   
  247.       if (ctx->chain != NULL) {
                 ^
  248.           /*
  249.            * This X509_STORE_CTX has already been used to verify a cert. We

crypto/x509/x509_vfy.c:252:9: Skipping ERR_put_error(): empty list of specs
  250.            * cannot do another one.
  251.            */
  252.           X509err(X509_F_X509_VERIFY_CERT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
                 ^
  253.           return -1;
  254.       }

crypto/x509/x509_vfy.c:253:9: 
  251.            */
  252.           X509err(X509_F_X509_VERIFY_CERT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  253. >         return -1;
  254.       }
  255.   

crypto/x509/x509_vfy.c:277:1: return from a call to X509_verify_cert
  275.           return dane_verify(ctx);
  276.       return verify_chain(ctx);
  277. > }
  278.   
  279.   /*

test/danetest.c:140:5: 
138.       ret = X509_verify_cert(store_ctx);
139.   
140. >     SSL_set_verify_result(ssl, X509_STORE_CTX_get_error(store_ctx));
141.       X509_STORE_CTX_cleanup(store_ctx);
142.       X509_STORE_CTX_free(store_ctx);

crypto/x509/x509_vfy.c:2016:1: start of procedure X509_STORE_CTX_get_error()
  2014.   }
  2015.   
  2016. > int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
  2017.   {
  2018.       return ctx->error;

crypto/x509/x509_vfy.c:2018:5: 
  2016.   int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
  2017.   {
  2018. >     return ctx->error;
  2019.   }
  2020.   

crypto/x509/x509_vfy.c:2019:1: return from a call to X509_STORE_CTX_get_error
  2017.   {
  2018.       return ctx->error;
  2019. > }
  2020.   
  2021.   void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err)

ssl/ssl_lib.c:3423:1: start of procedure SSL_set_verify_result()
  3421.   }
  3422.   
  3423. > void SSL_set_verify_result(SSL *ssl, long arg)
  3424.   {
  3425.       ssl->verify_result = arg;

ssl/ssl_lib.c:3425:5: 
  3423.   void SSL_set_verify_result(SSL *ssl, long arg)
  3424.   {
  3425. >     ssl->verify_result = arg;
  3426.   }
  3427.   

ssl/ssl_lib.c:3426:1: return from a call to SSL_set_verify_result
  3424.   {
  3425.       ssl->verify_result = arg;
  3426. > }
  3427.   
  3428.   long SSL_get_verify_result(const SSL *ssl)

test/danetest.c:141:5: Skipping X509_STORE_CTX_cleanup(): empty list of specs
139.   
140.       SSL_set_verify_result(ssl, X509_STORE_CTX_get_error(store_ctx));
141.       X509_STORE_CTX_cleanup(store_ctx);
           ^
142.       X509_STORE_CTX_free(store_ctx);
143.   
