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


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

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

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

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

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

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

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

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

apps/ts.c:932:13: 
930.   
931.       if (data != NULL || digest != NULL) {
932. >         if ((ctx = TS_VERIFY_CTX_new()) == NULL)
933.               goto err;
934.           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:932:13: Taking false branch
930.   
931.       if (data != NULL || digest != NULL) {
932.           if ((ctx = TS_VERIFY_CTX_new()) == NULL)
                   ^
933.               goto err;
934.           f = TS_VFY_VERSION | TS_VFY_SIGNER;

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

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

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

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

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

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

apps/ts.c:960:5: 
958.   
959.       /* Add the signature verification flag and arguments. */
960. >     TS_VERIFY_CTX_add_flags(ctx, f | TS_VFY_SIGNATURE);
961.   
962.       /* 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:963:9: 
961.   
962.       /* Initialising the X509_STORE object. */
963. >     if (TS_VERIFY_CTX_set_store(ctx, create_cert_store(CApath, CAfile, vpm))
964.               == NULL)
965.           goto err;

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

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

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

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

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

crypto/x509/x509_lu.c:732:1: start of procedure X509_STORE_set_verify_cb()
    730.   }
    731.   
    732. > void X509_STORE_set_verify_cb(X509_STORE *ctx,
    733.                                 int (*verify_cb) (int, X509_STORE_CTX *))
    734.   {

crypto/x509/x509_lu.c:735:5: 
    733.                                 int (*verify_cb) (int, X509_STORE_CTX *))
    734.   {
    735. >     ctx->verify_cb = verify_cb;
    736.   }
    737.   

crypto/x509/x509_lu.c:736:1: return from a call to X509_STORE_set_verify_cb
    734.   {
    735.       ctx->verify_cb = verify_cb;
    736. > }
    737.   
    738.   void X509_STORE_set_lookup_crls_cb(X509_STORE *ctx,

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

apps/ts.c:992:9: 
  990.       X509_STORE_set_verify_cb(cert_ctx, verify_cb);
  991.       if (CApath != NULL) {
  992. >         lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
  993.           if (lookup == NULL) {
  994.               BIO_printf(bio_err, "memory allocation failure\n");

crypto/x509/by_dir.c:115:1: start of procedure X509_LOOKUP_hash_dir()
    113.   };
    114.   
    115. > X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void)
    116.   {
    117.       return (&x509_dir_lookup);

crypto/x509/by_dir.c:117:5: 
    115.   X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void)
    116.   {
    117. >     return (&x509_dir_lookup);
    118.   }
    119.   

crypto/x509/by_dir.c:118:1: return from a call to X509_LOOKUP_hash_dir
    116.   {
    117.       return (&x509_dir_lookup);
    118. > }
    119.   
    120.   static int dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,

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:101:1: start of procedure sk_X509_LOOKUP_num()
      99.   
      100.   
      101. > DEFINE_STACK_OF(X509_LOOKUP)
      102.   DEFINE_STACK_OF(X509_OBJECT)
      103.   DEFINE_STACK_OF(X509_VERIFY_PARAM)

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:101:1: return from a call to sk_X509_LOOKUP_num
      99.   
      100.   
      101. > DEFINE_STACK_OF(X509_LOOKUP)
      102.   DEFINE_STACK_OF(X509_OBJECT)
      103.   DEFINE_STACK_OF(X509_VERIFY_PARAM)

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.   X509_OBJECT *X509_STORE_get_X509_by_subject(X509_STORE_CTX *vs, int type,

apps/ts.c:993:13: Taking true branch
  991.       if (CApath != NULL) {
  992.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
  993.           if (lookup == NULL) {
                     ^
  994.               BIO_printf(bio_err, "memory allocation failure\n");
  995.               goto err;

apps/ts.c:994:13: 
  992.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
  993.           if (lookup == NULL) {
  994. >             BIO_printf(bio_err, "memory allocation failure\n");
  995.               goto err;
  996.           }

crypto/bio/b_print.c:776:1: start of procedure BIO_printf()
    774.   /***************************************************************************/
    775.   
    776. > int BIO_printf(BIO *bio, const char *format, ...)
    777.   {
    778.       va_list args;

crypto/bio/b_print.c:781:5: 
    779.       int ret;
    780.   
    781. >     va_start(args, format);
    782.   
    783.       ret = BIO_vprintf(bio, format, args);

crypto/bio/b_print.c:783:5: Skipping BIO_vprintf(): empty list of specs
    781.       va_start(args, format);
    782.   
    783.       ret = BIO_vprintf(bio, format, args);
               ^
    784.   
    785.       va_end(args);

crypto/bio/b_print.c:785:5: 
    783.       ret = BIO_vprintf(bio, format, args);
    784.   
    785. >     va_end(args);
    786.       return (ret);
    787.   }

crypto/bio/b_print.c:786:5: 
    784.   
    785.       va_end(args);
    786. >     return (ret);
    787.   }
    788.   

crypto/bio/b_print.c:787:1: return from a call to BIO_printf
    785.       va_end(args);
    786.       return (ret);
    787. > }
    788.   
    789.   int BIO_vprintf(BIO *bio, const char *format, va_list args)

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

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

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:1024:5: 
  1022.    err:
  1023.       X509_STORE_free(cert_ctx);
  1024. >     return NULL;
  1025.   }
  1026.   

apps/ts.c:1025:1: return from a call to create_cert_store
  1023.       X509_STORE_free(cert_ctx);
  1024.       return NULL;
  1025. > }
  1026.   
  1027.   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:963:9: Taking true branch
961.   
962.       /* Initialising the X509_STORE object. */
963.       if (TS_VERIFY_CTX_set_store(ctx, create_cert_store(CApath, CAfile, vpm))
               ^
964.               == NULL)
965.           goto err;

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

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

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

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)
