apps/ts.c:976: error: MEMORY_LEAK
  memory dynamically allocated by call to `TS_VERIFY_CTX_new()` at line 933, column 20 is not reachable after line 976, column 9.
Showing all 119 steps of the trace


apps/ts.c:920:1: start of procedure create_verify_ctx()
918.   }
919.   
920. > static TS_VERIFY_CTX *create_verify_ctx(char *data, char *digest,
921.                                           char *queryfile,
922.                                           char *CApath, char *CAfile,

apps/ts.c:926:5: 
924.                                           X509_VERIFY_PARAM *vpm)
925.   {
926. >     TS_VERIFY_CTX *ctx = NULL;
927.       BIO *input = NULL;
928.       TS_REQ *request = NULL;

apps/ts.c:927:5: 
925.   {
926.       TS_VERIFY_CTX *ctx = NULL;
927. >     BIO *input = NULL;
928.       TS_REQ *request = NULL;
929.       int ret = 0;

apps/ts.c:928:5: 
926.       TS_VERIFY_CTX *ctx = NULL;
927.       BIO *input = NULL;
928. >     TS_REQ *request = NULL;
929.       int ret = 0;
930.       int f = 0;

apps/ts.c:929:5: 
927.       BIO *input = NULL;
928.       TS_REQ *request = NULL;
929. >     int ret = 0;
930.       int f = 0;
931.   

apps/ts.c:930:5: 
928.       TS_REQ *request = NULL;
929.       int ret = 0;
930. >     int f = 0;
931.   
932.       if (data != NULL || digest != NULL) {

apps/ts.c:932:9: Taking false branch
930.       int f = 0;
931.   
932.       if (data != NULL || digest != NULL) {
               ^
933.           if ((ctx = TS_VERIFY_CTX_new()) == NULL)
934.               goto err;

apps/ts.c:932:25: Taking true branch
930.       int f = 0;
931.   
932.       if (data != NULL || digest != NULL) {
                               ^
933.           if ((ctx = TS_VERIFY_CTX_new()) == NULL)
934.               goto err;

apps/ts.c:933:13: 
931.   
932.       if (data != NULL || digest != NULL) {
933. >         if ((ctx = TS_VERIFY_CTX_new()) == NULL)
934.               goto err;
935.           f = TS_VFY_VERSION | TS_VFY_SIGNER;

crypto/ts/ts_verify_ctx.c:64:1: start of procedure TS_VERIFY_CTX_new()
  62.   #include "ts_lcl.h"
  63.   
  64. > TS_VERIFY_CTX *TS_VERIFY_CTX_new(void)
  65.   {
  66.       TS_VERIFY_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));

crypto/ts/ts_verify_ctx.c:66:5: 
  64.   TS_VERIFY_CTX *TS_VERIFY_CTX_new(void)
  65.   {
  66. >     TS_VERIFY_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
  67.   
  68.       if (ctx == NULL)

crypto/mem.c:146:1: start of procedure CRYPTO_zalloc()
    144.   }
    145.   
    146. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
    147.   {
    148.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:148:5: 
    146.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
    147.   {
    148. >     void *ret = CRYPTO_malloc(num, file, line);
    149.   
    150.       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 (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)

crypto/mem.c:123:9: Taking false branch
      121.       void *ret = NULL;
      122.   
      123.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                     ^
      124.           return malloc_impl(num, file, line);
      125.   

crypto/mem.c:126:9: Taking false branch
      124.           return malloc_impl(num, file, line);
      125.   
      126.       if (num <= 0)
                     ^
      127.           return NULL;
      128.   

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

crypto/mem.c:139:5: 
      137.       }
      138.   #else
      139. >     osslargused(file); osslargused(line);
      140.       ret = malloc(num);
      141.   #endif

crypto/mem.c:139:24: 
      137.       }
      138.   #else
      139. >     osslargused(file); osslargused(line);
      140.       ret = malloc(num);
      141.   #endif

crypto/mem.c:140:5: 
      138.   #else
      139.       osslargused(file); osslargused(line);
      140. >     ret = malloc(num);
      141.   #endif
      142.   

crypto/mem.c:143:5: 
      141.   #endif
      142.   
      143. >     return ret;
      144.   }
      145.   

crypto/mem.c:144:1: return from a call to CRYPTO_malloc
      142.   
      143.       return ret;
      144. > }
      145.   
      146.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:150:9: Taking true branch
    148.       void *ret = CRYPTO_malloc(num, file, line);
    149.   
    150.       if (ret != NULL)
                   ^
    151.           memset(ret, 0, num);
    152.       return ret;

crypto/mem.c:151:9: 
    149.   
    150.       if (ret != NULL)
    151. >         memset(ret, 0, num);
    152.       return ret;
    153.   }

crypto/mem.c:152:5: 
    150.       if (ret != NULL)
    151.           memset(ret, 0, num);
    152. >     return ret;
    153.   }
    154.   

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

crypto/ts/ts_verify_ctx.c:68:9: Taking false branch
  66.       TS_VERIFY_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
  67.   
  68.       if (ctx == NULL)
                ^
  69.           TSerr(TS_F_TS_VERIFY_CTX_NEW, ERR_R_MALLOC_FAILURE);
  70.       return ctx;

crypto/ts/ts_verify_ctx.c:70:5: 
  68.       if (ctx == NULL)
  69.           TSerr(TS_F_TS_VERIFY_CTX_NEW, ERR_R_MALLOC_FAILURE);
  70. >     return ctx;
  71.   }
  72.   

crypto/ts/ts_verify_ctx.c:71:1: return from a call to TS_VERIFY_CTX_new
  69.           TSerr(TS_F_TS_VERIFY_CTX_NEW, ERR_R_MALLOC_FAILURE);
  70.       return ctx;
  71. > }
  72.   
  73.   void TS_VERIFY_CTX_init(TS_VERIFY_CTX *ctx)

apps/ts.c:933:13: Taking false branch
931.   
932.       if (data != NULL || digest != NULL) {
933.           if ((ctx = TS_VERIFY_CTX_new()) == NULL)
                   ^
934.               goto err;
935.           f = TS_VFY_VERSION | TS_VFY_SIGNER;

apps/ts.c:935:9: 
933.           if ((ctx = TS_VERIFY_CTX_new()) == NULL)
934.               goto err;
935. >         f = TS_VFY_VERSION | TS_VFY_SIGNER;
936.           if (data != NULL) {
937.               f |= TS_VFY_DATA;

apps/ts.c:936:13: Taking false branch
934.               goto err;
935.           f = TS_VFY_VERSION | TS_VFY_SIGNER;
936.           if (data != NULL) {
                   ^
937.               f |= TS_VFY_DATA;
938.               if (TS_VERIFY_CTX_set_data(ctx, BIO_new_file(data, "rb")) == NULL)

apps/ts.c:940:20: Taking true branch
938.               if (TS_VERIFY_CTX_set_data(ctx, BIO_new_file(data, "rb")) == NULL)
939.                   goto err;
940.           } else if (digest != NULL) {
                          ^
941.               long imprint_len;
942.               unsigned char *hexstr = string_to_hex(digest, &imprint_len);

apps/ts.c:942:13: Skipping string_to_hex(): empty list of specs
940.           } else if (digest != NULL) {
941.               long imprint_len;
942.               unsigned char *hexstr = string_to_hex(digest, &imprint_len);
                   ^
943.               f |= TS_VFY_IMPRINT;
944.               if (TS_VERIFY_CTX_set_imprint(ctx, hexstr, imprint_len) == NULL) {

apps/ts.c:943:13: 
941.               long imprint_len;
942.               unsigned char *hexstr = string_to_hex(digest, &imprint_len);
943. >             f |= TS_VFY_IMPRINT;
944.               if (TS_VERIFY_CTX_set_imprint(ctx, hexstr, imprint_len) == NULL) {
945.                   BIO_printf(bio_err, "invalid digest string\n");

apps/ts.c:944:17: 
942.               unsigned char *hexstr = string_to_hex(digest, &imprint_len);
943.               f |= TS_VFY_IMPRINT;
944. >             if (TS_VERIFY_CTX_set_imprint(ctx, hexstr, imprint_len) == NULL) {
945.                   BIO_printf(bio_err, "invalid digest string\n");
946.                   goto err;

crypto/ts/ts_verify_ctx.c:119:1: start of procedure TS_VERIFY_CTX_set_imprint()
  117.   }
  118.   
  119. > unsigned char *TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx,
  120.                                            unsigned char *hexstr, long len)
  121.   {

crypto/ts/ts_verify_ctx.c:122:5: 
  120.                                            unsigned char *hexstr, long len)
  121.   {
  122. >     ctx->imprint = hexstr;
  123.       ctx->imprint_len = len;
  124.       return ctx->imprint;

crypto/ts/ts_verify_ctx.c:123:5: 
  121.   {
  122.       ctx->imprint = hexstr;
  123. >     ctx->imprint_len = len;
  124.       return ctx->imprint;
  125.   }

crypto/ts/ts_verify_ctx.c:124:5: 
  122.       ctx->imprint = hexstr;
  123.       ctx->imprint_len = len;
  124. >     return ctx->imprint;
  125.   }
  126.   

crypto/ts/ts_verify_ctx.c:125:1: return from a call to TS_VERIFY_CTX_set_imprint
  123.       ctx->imprint_len = len;
  124.       return ctx->imprint;
  125. > }
  126.   
  127.   void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx)

apps/ts.c:944:17: Taking false branch
942.               unsigned char *hexstr = string_to_hex(digest, &imprint_len);
943.               f |= TS_VFY_IMPRINT;
944.               if (TS_VERIFY_CTX_set_imprint(ctx, hexstr, imprint_len) == NULL) {
                       ^
945.                   BIO_printf(bio_err, "invalid digest string\n");
946.                   goto err;

apps/ts.c:961:5: 
959.   
960.       /* Add the signature verification flag and arguments. */
961. >     TS_VERIFY_CTX_add_flags(ctx, f | TS_VFY_SIGNATURE);
962.   
963.       /* Initialising the X509_STORE object. */

crypto/ts/ts_verify_ctx.c:88:1: start of procedure TS_VERIFY_CTX_add_flags()
  86.   }
  87.   
  88. > int TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX *ctx, int f)
  89.   {
  90.       ctx->flags |= f;

crypto/ts/ts_verify_ctx.c:90:5: 
  88.   int TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX *ctx, int f)
  89.   {
  90. >     ctx->flags |= f;
  91.       return ctx->flags;
  92.   }

crypto/ts/ts_verify_ctx.c:91:5: 
  89.   {
  90.       ctx->flags |= f;
  91. >     return ctx->flags;
  92.   }
  93.   

crypto/ts/ts_verify_ctx.c:92:1: return from a call to TS_VERIFY_CTX_add_flags
  90.       ctx->flags |= f;
  91.       return ctx->flags;
  92. > }
  93.   
  94.   int TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX *ctx, int f)

apps/ts.c:964:9: 
962.   
963.       /* Initialising the X509_STORE object. */
964. >     if (TS_VERIFY_CTX_set_store(ctx, create_cert_store(CApath, CAfile, vpm))
965.               == NULL)
966.           goto err;

apps/ts.c:984:1: start of procedure create_cert_store()
  982.   }
  983.   
  984. > static X509_STORE *create_cert_store(char *CApath, char *CAfile, X509_VERIFY_PARAM *vpm)
  985.   {
  986.       X509_STORE *cert_ctx = NULL;

apps/ts.c:986:5: 
  984.   static X509_STORE *create_cert_store(char *CApath, char *CAfile, X509_VERIFY_PARAM *vpm)
  985.   {
  986. >     X509_STORE *cert_ctx = NULL;
  987.       X509_LOOKUP *lookup = NULL;
  988.       int i;

apps/ts.c:987:5: 
  985.   {
  986.       X509_STORE *cert_ctx = NULL;
  987. >     X509_LOOKUP *lookup = NULL;
  988.       int i;
  989.   

apps/ts.c:990:5: Skipping X509_STORE_new(): empty list of specs
  988.       int i;
  989.   
  990.       cert_ctx = X509_STORE_new();
             ^
  991.       X509_STORE_set_verify_cb(cert_ctx, verify_cb);
  992.       if (CApath != NULL) {

apps/ts.c:991:5: 
  989.   
  990.       cert_ctx = X509_STORE_new();
  991. >     X509_STORE_set_verify_cb(cert_ctx, verify_cb);
  992.       if (CApath != NULL) {
  993.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());

crypto/x509/x509_lu.c:701:1: start of procedure X509_STORE_set_verify_cb()
    699.   }
    700.   
    701. > void X509_STORE_set_verify_cb(X509_STORE *ctx,
    702.                                 int (*verify_cb) (int, X509_STORE_CTX *))
    703.   {

crypto/x509/x509_lu.c:704:5: 
    702.                                 int (*verify_cb) (int, X509_STORE_CTX *))
    703.   {
    704. >     ctx->verify_cb = verify_cb;
    705.   }
    706.   

crypto/x509/x509_lu.c:705:1: return from a call to X509_STORE_set_verify_cb
    703.   {
    704.       ctx->verify_cb = verify_cb;
    705. > }
    706.   
    707.   void X509_STORE_set_lookup_crls_cb(X509_STORE *ctx,

apps/ts.c:992:9: Taking false branch
  990.       cert_ctx = X509_STORE_new();
  991.       X509_STORE_set_verify_cb(cert_ctx, verify_cb);
  992.       if (CApath != NULL) {
                 ^
  993.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
  994.           if (lookup == NULL) {

apps/ts.c:1005:9: Taking true branch
  1003.       }
  1004.   
  1005.       if (CAfile != NULL) {
                  ^
  1006.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
  1007.           if (lookup == NULL) {

apps/ts.c:1006:9: 
  1004.   
  1005.       if (CAfile != NULL) {
  1006. >         lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
  1007.           if (lookup == NULL) {
  1008.               BIO_printf(bio_err, "memory allocation failure\n");

crypto/x509/by_file.c:83:1: start of procedure X509_LOOKUP_file()
    81.   };
    82.   
    83. > X509_LOOKUP_METHOD *X509_LOOKUP_file(void)
    84.   {
    85.       return (&x509_file_lookup);

crypto/x509/by_file.c:85:5: 
    83.   X509_LOOKUP_METHOD *X509_LOOKUP_file(void)
    84.   {
    85. >     return (&x509_file_lookup);
    86.   }
    87.   

crypto/x509/by_file.c:86:1: return from a call to X509_LOOKUP_file
    84.   {
    85.       return (&x509_file_lookup);
    86. > }
    87.   
    88.   static int by_file_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp,

crypto/x509/x509_lu.c:269:1: start of procedure X509_STORE_add_lookup()
    267.   }
    268.   
    269. > X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m)
    270.   {
    271.       int i;

crypto/x509/x509_lu.c:275:5: 
    273.       X509_LOOKUP *lu;
    274.   
    275. >     sk = v->get_cert_methods;
    276.       for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) {
    277.           lu = sk_X509_LOOKUP_value(sk, i);

crypto/x509/x509_lu.c:276:10: 
    274.   
    275.       sk = v->get_cert_methods;
    276. >     for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) {
    277.           lu = sk_X509_LOOKUP_value(sk, i);
    278.           if (m == lu->method) {

crypto/x509/x509_lu.c:276:17: 
    274.   
    275.       sk = v->get_cert_methods;
    276. >     for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) {
    277.           lu = sk_X509_LOOKUP_value(sk, i);
    278.           if (m == lu->method) {

include/openssl/x509_vfy.h:121:1: start of procedure sk_X509_LOOKUP_num()
      119.   typedef struct x509_lookup_st X509_LOOKUP;
      120.   
      121. > DEFINE_STACK_OF(X509_LOOKUP)
      122.   DEFINE_STACK_OF(X509_OBJECT)
      123.   

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 true branch
        316.   int sk_num(const _STACK *st)
        317.   {
        318.       if (st == NULL)
                       ^
        319.           return -1;
        320.       return st->num;

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

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/x509_vfy.h:121:1: return from a call to sk_X509_LOOKUP_num
      119.   typedef struct x509_lookup_st X509_LOOKUP;
      120.   
      121. > DEFINE_STACK_OF(X509_LOOKUP)
      122.   DEFINE_STACK_OF(X509_OBJECT)
      123.   

crypto/x509/x509_lu.c:276:17: Loop condition is false. Leaving loop
    274.   
    275.       sk = v->get_cert_methods;
    276.       for (i = 0; i < sk_X509_LOOKUP_num(sk); i++) {
                           ^
    277.           lu = sk_X509_LOOKUP_value(sk, i);
    278.           if (m == lu->method) {

crypto/x509/x509_lu.c:283:5: Skipping X509_LOOKUP_new(): empty list of specs
    281.       }
    282.       /* a new one */
    283.       lu = X509_LOOKUP_new(m);
               ^
    284.       if (lu == NULL)
    285.           return NULL;

crypto/x509/x509_lu.c:284:9: Taking true branch
    282.       /* a new one */
    283.       lu = X509_LOOKUP_new(m);
    284.       if (lu == NULL)
                   ^
    285.           return NULL;
    286.       else {

crypto/x509/x509_lu.c:285:9: 
    283.       lu = X509_LOOKUP_new(m);
    284.       if (lu == NULL)
    285. >         return NULL;
    286.       else {
    287.           lu->store_ctx = v;

crypto/x509/x509_lu.c:295:1: return from a call to X509_STORE_add_lookup
    293.           }
    294.       }
    295. > }
    296.   
    297.   int X509_STORE_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,

apps/ts.c:1007:13: Taking true branch
  1005.       if (CAfile != NULL) {
  1006.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
  1007.           if (lookup == NULL) {
                      ^
  1008.               BIO_printf(bio_err, "memory allocation failure\n");
  1009.               goto err;

apps/ts.c:1008:13: 
  1006.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
  1007.           if (lookup == NULL) {
  1008. >             BIO_printf(bio_err, "memory allocation failure\n");
  1009.               goto err;
  1010.           }

crypto/bio/b_print.c:783:1: start of procedure BIO_printf()
    781.   /***************************************************************************/
    782.   
    783. > int BIO_printf(BIO *bio, const char *format, ...)
    784.   {
    785.       va_list args;

crypto/bio/b_print.c:788:5: 
    786.       int ret;
    787.   
    788. >     va_start(args, format);
    789.   
    790.       ret = BIO_vprintf(bio, format, args);

crypto/bio/b_print.c:790:5: Skipping BIO_vprintf(): empty list of specs
    788.       va_start(args, format);
    789.   
    790.       ret = BIO_vprintf(bio, format, args);
               ^
    791.   
    792.       va_end(args);

crypto/bio/b_print.c:792:5: 
    790.       ret = BIO_vprintf(bio, format, args);
    791.   
    792. >     va_end(args);
    793.       return (ret);
    794.   }

crypto/bio/b_print.c:793:5: 
    791.   
    792.       va_end(args);
    793. >     return (ret);
    794.   }
    795.   

crypto/bio/b_print.c:794:1: return from a call to BIO_printf
    792.       va_end(args);
    793.       return (ret);
    794. > }
    795.   
    796.   int BIO_vprintf(BIO *bio, const char *format, va_list args)

apps/ts.c:1023:2: 
  1021.       return cert_ctx;
  1022.   
  1023. >  err:
  1024.       X509_STORE_free(cert_ctx);
  1025.       return NULL;

apps/ts.c:1024:5: 
  1022.   
  1023.    err:
  1024. >     X509_STORE_free(cert_ctx);
  1025.       return NULL;
  1026.   }

crypto/x509/x509_lu.c:227:1: start of procedure X509_STORE_free()
    225.   }
    226.   
    227. > void X509_STORE_free(X509_STORE *vfy)
    228.   {
    229.       int i;

crypto/x509/x509_lu.c:233:9: Taking false branch
    231.       X509_LOOKUP *lu;
    232.   
    233.       if (vfy == NULL)
                   ^
    234.           return;
    235.   

crypto/x509/x509_lu.c:236:5: 
    234.           return;
    235.   
    236. >     CRYPTO_atomic_add(&vfy->references, -1, &i, vfy->lock);
    237.       REF_PRINT_COUNT("X509_STORE", vfy);
    238.       if (i > 0)

crypto/threads_pthread.c:151:1: start of procedure CRYPTO_atomic_add()
      149.   }
      150.   
      151. > int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock)
      152.   {
      153.   #ifdef __ATOMIC_RELAXED

crypto/threads_pthread.c:154:5: 
      152.   {
      153.   #ifdef __ATOMIC_RELAXED
      154. >     *ret = __atomic_add_fetch(val, amount, __ATOMIC_RELAXED);
      155.   #else
      156.       if (!CRYPTO_THREAD_write_lock(lock))

crypto/threads_pthread.c:166:5: 
      164.   #endif
      165.   
      166. >     return 1;
      167.   }
      168.   

crypto/threads_pthread.c:167:1: return from a call to CRYPTO_atomic_add
      165.   
      166.       return 1;
      167. > }
      168.   
      169.   #endif

crypto/x509/x509_lu.c:238:9: Taking true branch
    236.       CRYPTO_atomic_add(&vfy->references, -1, &i, vfy->lock);
    237.       REF_PRINT_COUNT("X509_STORE", vfy);
    238.       if (i > 0)
                   ^
    239.           return;
    240.       REF_ASSERT_ISNT(i < 0);

crypto/x509/x509_lu.c:239:9: 
    237.       REF_PRINT_COUNT("X509_STORE", vfy);
    238.       if (i > 0)
    239. >         return;
    240.       REF_ASSERT_ISNT(i < 0);
    241.   

crypto/x509/x509_lu.c:255:1: return from a call to X509_STORE_free
    253.       CRYPTO_THREAD_lock_free(vfy->lock);
    254.       OPENSSL_free(vfy);
    255. > }
    256.   
    257.   int X509_STORE_up_ref(X509_STORE *vfy)

apps/ts.c:1025:5: 
  1023.    err:
  1024.       X509_STORE_free(cert_ctx);
  1025. >     return NULL;
  1026.   }
  1027.   

apps/ts.c:1026:1: return from a call to create_cert_store
  1024.       X509_STORE_free(cert_ctx);
  1025.       return NULL;
  1026. > }
  1027.   
  1028.   static int verify_cb(int ok, X509_STORE_CTX *ctx)

crypto/ts/ts_verify_ctx.c:106:1: start of procedure TS_VERIFY_CTX_set_store()
  104.   }
  105.   
  106. > X509_STORE *TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *s)
  107.   {
  108.       ctx->store = s;

crypto/ts/ts_verify_ctx.c:108:5: 
  106.   X509_STORE *TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *s)
  107.   {
  108. >     ctx->store = s;
  109.       return ctx->store;
  110.   }

crypto/ts/ts_verify_ctx.c:109:5: 
  107.   {
  108.       ctx->store = s;
  109. >     return ctx->store;
  110.   }
  111.   

crypto/ts/ts_verify_ctx.c:110:1: return from a call to TS_VERIFY_CTX_set_store
  108.       ctx->store = s;
  109.       return ctx->store;
  110. > }
  111.   
  112.   STACK_OF(X509) *TS_VERIFY_CTS_set_certs(TS_VERIFY_CTX *ctx,

apps/ts.c:964:9: Taking true branch
962.   
963.       /* Initialising the X509_STORE object. */
964.       if (TS_VERIFY_CTX_set_store(ctx, create_cert_store(CApath, CAfile, vpm))
               ^
965.               == NULL)
966.           goto err;

apps/ts.c:974:2: 
972.       ret = 1;
973.   
974. >  err:
975.       if (!ret) {
976.           TS_VERIFY_CTX_free(ctx);

apps/ts.c:975:10: Taking true branch
973.   
974.    err:
975.       if (!ret) {
                ^
976.           TS_VERIFY_CTX_free(ctx);
977.           ctx = NULL;

apps/ts.c:976:9: 
974.    err:
975.       if (!ret) {
976. >         TS_VERIFY_CTX_free(ctx);
977.           ctx = NULL;
978.       }

crypto/ts/ts_verify_ctx.c:79:1: start of procedure TS_VERIFY_CTX_free()
  77.   }
  78.   
  79. > void TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx)
  80.   {
  81.       if (!ctx)

crypto/ts/ts_verify_ctx.c:81:10: Taking false branch
  79.   void TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx)
  80.   {
  81.       if (!ctx)
                 ^
  82.           return;
  83.   

crypto/ts/ts_verify_ctx.c:84:5: Skipping TS_VERIFY_CTX_cleanup(): empty list of specs
  82.           return;
  83.   
  84.       TS_VERIFY_CTX_cleanup(ctx);
            ^
  85.       OPENSSL_free(ctx);
  86.   }

crypto/ts/ts_verify_ctx.c:85:5: 
  83.   
  84.       TS_VERIFY_CTX_cleanup(ctx);
  85. >     OPENSSL_free(ctx);
  86.   }
  87.   

crypto/mem.c:210:1: start of procedure CRYPTO_free()
    208.   }
    209.   
    210. > void CRYPTO_free(void *str, const char *file, int line)
    211.   {
    212.       if (free_impl != NULL && free_impl != &CRYPTO_free) {

crypto/mem.c:212:9: Taking true branch
    210.   void CRYPTO_free(void *str, const char *file, int line)
    211.   {
    212.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
                   ^
    213.           free_impl(str, file, line);
    214.           return;

crypto/mem.c:212:30: Taking true branch
    210.   void CRYPTO_free(void *str, const char *file, int line)
    211.   {
    212.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
                                        ^
    213.           free_impl(str, file, line);
    214.           return;

crypto/mem.c:213:9: Skipping __function_pointer__(): unresolved function pointer
    211.   {
    212.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
    213.           free_impl(str, file, line);
                   ^
    214.           return;
    215.       }

crypto/mem.c:214:9: 
    212.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
    213.           free_impl(str, file, line);
    214. >         return;
    215.       }
    216.   

crypto/mem.c:228:1: return from a call to CRYPTO_free
    226.       free(str);
    227.   #endif
    228. > }
    229.   
    230.   void CRYPTO_clear_free(void *str, size_t num, const char *file, int line)

crypto/ts/ts_verify_ctx.c:86:1: return from a call to TS_VERIFY_CTX_free
  84.       TS_VERIFY_CTX_cleanup(ctx);
  85.       OPENSSL_free(ctx);
  86. > }
  87.   
  88.   int TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX *ctx, int f)
