apps/ts.c:947: error: NULL_DEREFERENCE
  pointer `ctx->store` last assigned on line 935 could be null and is dereferenced by call to `TS_VERIFY_CTX_free()` at line 947, column 9.
Showing all 129 steps of the trace


apps/ts.c:892:1: start of procedure create_verify_ctx()
890.   }
891.   
892. > static TS_VERIFY_CTX *create_verify_ctx(char *data, char *digest,
893.                                           char *queryfile,
894.                                           char *CApath, char *CAfile,

apps/ts.c:897:5: 
895.                                           char *untrusted)
896.   {
897. >     TS_VERIFY_CTX *ctx = NULL;
898.       BIO *input = NULL;
899.       TS_REQ *request = NULL;

apps/ts.c:898:5: 
896.   {
897.       TS_VERIFY_CTX *ctx = NULL;
898. >     BIO *input = NULL;
899.       TS_REQ *request = NULL;
900.       int ret = 0;

apps/ts.c:899:5: 
897.       TS_VERIFY_CTX *ctx = NULL;
898.       BIO *input = NULL;
899. >     TS_REQ *request = NULL;
900.       int ret = 0;
901.       int f = 0;

apps/ts.c:900:5: 
898.       BIO *input = NULL;
899.       TS_REQ *request = NULL;
900. >     int ret = 0;
901.       int f = 0;
902.   

apps/ts.c:901:5: 
899.       TS_REQ *request = NULL;
900.       int ret = 0;
901. >     int f = 0;
902.   
903.       if (data != NULL || digest != NULL) {

apps/ts.c:903:9: Taking true branch
901.       int f = 0;
902.   
903.       if (data != NULL || digest != NULL) {
               ^
904.           if ((ctx = TS_VERIFY_CTX_new()) == NULL)
905.               goto err;

apps/ts.c:904:13: 
902.   
903.       if (data != NULL || digest != NULL) {
904. >         if ((ctx = TS_VERIFY_CTX_new()) == NULL)
905.               goto err;
906.           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: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/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:904:13: Taking false branch
902.   
903.       if (data != NULL || digest != NULL) {
904.           if ((ctx = TS_VERIFY_CTX_new()) == NULL)
                   ^
905.               goto err;
906.           f = TS_VFY_VERSION | TS_VFY_SIGNER;

apps/ts.c:906:9: 
904.           if ((ctx = TS_VERIFY_CTX_new()) == NULL)
905.               goto err;
906. >         f = TS_VFY_VERSION | TS_VFY_SIGNER;
907.           if (data != NULL) {
908.               f |= TS_VFY_DATA;

apps/ts.c:907:13: Taking true branch
905.               goto err;
906.           f = TS_VFY_VERSION | TS_VFY_SIGNER;
907.           if (data != NULL) {
                   ^
908.               f |= TS_VFY_DATA;
909.               if (TS_VERIFY_CTX_set_data(ctx, BIO_new_file(data, "rb")) == NULL)

apps/ts.c:908:13: 
906.           f = TS_VFY_VERSION | TS_VFY_SIGNER;
907.           if (data != NULL) {
908. >             f |= TS_VFY_DATA;
909.               if (TS_VERIFY_CTX_set_data(ctx, BIO_new_file(data, "rb")) == NULL)
910.                   goto err;

apps/ts.c:909:17: Skipping BIO_new_file(): empty list of specs
907.           if (data != NULL) {
908.               f |= TS_VFY_DATA;
909.               if (TS_VERIFY_CTX_set_data(ctx, BIO_new_file(data, "rb")) == NULL)
                       ^
910.                   goto err;
911.           } else if (digest != NULL) {

crypto/ts/ts_verify_ctx.c:100:1: start of procedure TS_VERIFY_CTX_set_data()
  98.   }
  99.   
  100. > BIO *TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *b)
  101.   {
  102.       ctx->data = b;

crypto/ts/ts_verify_ctx.c:102:5: 
  100.   BIO *TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *b)
  101.   {
  102. >     ctx->data = b;
  103.       return ctx->data;
  104.   }

crypto/ts/ts_verify_ctx.c:103:5: 
  101.   {
  102.       ctx->data = b;
  103. >     return ctx->data;
  104.   }
  105.   

crypto/ts/ts_verify_ctx.c:104:1: return from a call to TS_VERIFY_CTX_set_data
  102.       ctx->data = b;
  103.       return ctx->data;
  104. > }
  105.   
  106.   X509_STORE *TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *s)

apps/ts.c:909:17: Taking false branch
907.           if (data != NULL) {
908.               f |= TS_VFY_DATA;
909.               if (TS_VERIFY_CTX_set_data(ctx, BIO_new_file(data, "rb")) == NULL)
                       ^
910.                   goto err;
911.           } else if (digest != NULL) {

apps/ts.c:932:5: 
930.   
931.       /* Add the signature verification flag and arguments. */
932. >     TS_VERIFY_CTX_add_flags(ctx, f | TS_VFY_SIGNATURE);
933.   
934.       /* 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:935:9: 
933.   
934.       /* Initialising the X509_STORE object. */
935. >     if (TS_VERIFY_CTX_set_store(ctx, create_cert_store(CApath, CAfile))
936.               == NULL)
937.           goto err;

apps/ts.c:955:1: start of procedure create_cert_store()
  953.   }
  954.   
  955. > static X509_STORE *create_cert_store(char *CApath, char *CAfile)
  956.   {
  957.       X509_STORE *cert_ctx = NULL;

apps/ts.c:957:5: 
  955.   static X509_STORE *create_cert_store(char *CApath, char *CAfile)
  956.   {
  957. >     X509_STORE *cert_ctx = NULL;
  958.       X509_LOOKUP *lookup = NULL;
  959.       int i;

apps/ts.c:958:5: 
  956.   {
  957.       X509_STORE *cert_ctx = NULL;
  958. >     X509_LOOKUP *lookup = NULL;
  959.       int i;
  960.   

apps/ts.c:961:5: Skipping X509_STORE_new(): empty list of specs
  959.       int i;
  960.   
  961.       cert_ctx = X509_STORE_new();
             ^
  962.       X509_STORE_set_verify_cb(cert_ctx, verify_cb);
  963.       if (CApath != NULL) {

apps/ts.c:962:5: 
  960.   
  961.       cert_ctx = X509_STORE_new();
  962. >     X509_STORE_set_verify_cb(cert_ctx, verify_cb);
  963.       if (CApath != NULL) {
  964.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());

crypto/x509/x509_lu.c:690:1: start of procedure X509_STORE_set_verify_cb()
    688.   }
    689.   
    690. > void X509_STORE_set_verify_cb(X509_STORE *ctx,
    691.                                 int (*verify_cb) (int, X509_STORE_CTX *))
    692.   {

crypto/x509/x509_lu.c:693:5: 
    691.                                 int (*verify_cb) (int, X509_STORE_CTX *))
    692.   {
    693. >     ctx->verify_cb = verify_cb;
    694.   }
    695.   

crypto/x509/x509_lu.c:694:1: return from a call to X509_STORE_set_verify_cb
    692.   {
    693.       ctx->verify_cb = verify_cb;
    694. > }
    695.   
    696.   void X509_STORE_set_lookup_crls_cb(X509_STORE *ctx,

apps/ts.c:963:9: Taking true branch
  961.       cert_ctx = X509_STORE_new();
  962.       X509_STORE_set_verify_cb(cert_ctx, verify_cb);
  963.       if (CApath != NULL) {
                 ^
  964.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
  965.           if (lookup == NULL) {

apps/ts.c:964:9: 
  962.       X509_STORE_set_verify_cb(cert_ctx, verify_cb);
  963.       if (CApath != NULL) {
  964. >         lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
  965.           if (lookup == NULL) {
  966.               BIO_printf(bio_err, "memory allocation failure\n");

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

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

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

apps/ts.c:964:9: Skipping X509_STORE_add_lookup(): empty list of specs
  962.       X509_STORE_set_verify_cb(cert_ctx, verify_cb);
  963.       if (CApath != NULL) {
  964.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
                 ^
  965.           if (lookup == NULL) {
  966.               BIO_printf(bio_err, "memory allocation failure\n");

apps/ts.c:965:13: Taking false branch
  963.       if (CApath != NULL) {
  964.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
  965.           if (lookup == NULL) {
                     ^
  966.               BIO_printf(bio_err, "memory allocation failure\n");
  967.               goto err;

apps/ts.c:969:9: 
  967.               goto err;
  968.           }
  969. >         i = X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM);
  970.           if (!i) {
  971.               BIO_printf(bio_err, "Error loading directory %s\n", CApath);

crypto/x509/x509_lu.c:111:1: start of procedure X509_LOOKUP_ctrl()
    109.   }
    110.   
    111. > int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
    112.                        char **ret)
    113.   {

crypto/x509/x509_lu.c:114:9: Taking true branch
    112.                        char **ret)
    113.   {
    114.       if (ctx->method == NULL)
                   ^
    115.           return -1;
    116.       if (ctx->method->ctrl != NULL)

crypto/x509/x509_lu.c:115:9: 
    113.   {
    114.       if (ctx->method == NULL)
    115. >         return -1;
    116.       if (ctx->method->ctrl != NULL)
    117.           return ctx->method->ctrl(ctx, cmd, argc, argl, ret);

crypto/x509/x509_lu.c:120:1: return from a call to X509_LOOKUP_ctrl
    118.       else
    119.           return 1;
    120. > }
    121.   
    122.   int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, int type, X509_NAME *name,

apps/ts.c:970:14: Taking false branch
  968.           }
  969.           i = X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM);
  970.           if (!i) {
                      ^
  971.               BIO_printf(bio_err, "Error loading directory %s\n", CApath);
  972.               goto err;

apps/ts.c:976:9: Taking true branch
  974.       }
  975.   
  976.       if (CAfile != NULL) {
                 ^
  977.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
  978.           if (lookup == NULL) {

apps/ts.c:977:9: 
  975.   
  976.       if (CAfile != NULL) {
  977. >         lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
  978.           if (lookup == NULL) {
  979.               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,

apps/ts.c:977:9: Skipping X509_STORE_add_lookup(): empty list of specs
  975.   
  976.       if (CAfile != NULL) {
  977.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
                 ^
  978.           if (lookup == NULL) {
  979.               BIO_printf(bio_err, "memory allocation failure\n");

apps/ts.c:978:13: Taking true branch
  976.       if (CAfile != NULL) {
  977.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
  978.           if (lookup == NULL) {
                     ^
  979.               BIO_printf(bio_err, "memory allocation failure\n");
  980.               goto err;

apps/ts.c:979:13: Skipping BIO_printf(): empty list of specs
  977.           lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file());
  978.           if (lookup == NULL) {
  979.               BIO_printf(bio_err, "memory allocation failure\n");
                     ^
  980.               goto err;
  981.           }

apps/ts.c:990:2: 
  988.       return cert_ctx;
  989.   
  990. >  err:
  991.       X509_STORE_free(cert_ctx);
  992.       return NULL;

apps/ts.c:991:5: 
  989.   
  990.    err:
  991. >     X509_STORE_free(cert_ctx);
  992.       return NULL;
  993.   }

crypto/x509/x509_lu.c:222:1: start of procedure X509_STORE_free()
    220.   }
    221.   
    222. > void X509_STORE_free(X509_STORE *vfy)
    223.   {
    224.       int i;

crypto/x509/x509_lu.c:228:9: Taking false branch
    226.       X509_LOOKUP *lu;
    227.   
    228.       if (vfy == NULL)
                   ^
    229.           return;
    230.   

crypto/x509/x509_lu.c:231:5: 
    229.           return;
    230.   
    231. >     i = CRYPTO_add(&vfy->references, -1, CRYPTO_LOCK_X509_STORE);
    232.   #ifdef REF_PRINT
    233.       REF_PRINT("X509_STORE", vfy);

crypto/lock.c:456:1: start of procedure CRYPTO_add_lock()
      454.   }
      455.   
      456. > int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
      457.                       int line)
      458.   {

crypto/lock.c:459:5: 
      457.                       int line)
      458.   {
      459. >     int ret = 0;
      460.   
      461.       if (add_lock_callback != NULL) {

crypto/lock.c:461:9: Taking false branch
      459.       int ret = 0;
      460.   
      461.       if (add_lock_callback != NULL) {
                     ^
      462.   #ifdef LOCK_DEBUG
      463.           int before = *pointer;

crypto/lock.c:477:9: 
      475.   #endif
      476.       } else {
      477. >         CRYPTO_lock(CRYPTO_LOCK | CRYPTO_WRITE, type, file, line);
      478.   
      479.           ret = *pointer + amount;

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
        412.   }
        413.   
        414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
        415.   {
        416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
        439.       }
        440.   #endif
        441.       if (type < 0) {
                       ^
        442.           if (dynlock_lock_callback != NULL) {
        443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking false branch
        450.               CRYPTO_destroy_dynlockid(type);
        451.           }
        452.       } else if (locking_callback != NULL)
                              ^
        453.           locking_callback(mode, type, file, line);
        454.   }

crypto/lock.c:441:5: 
        439.       }
        440.   #endif
        441. >     if (type < 0) {
        442.           if (dynlock_lock_callback != NULL) {
        443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
        452.       } else if (locking_callback != NULL)
        453.           locking_callback(mode, type, file, line);
        454. > }
        455.   
        456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/lock.c:479:9: 
      477.           CRYPTO_lock(CRYPTO_LOCK | CRYPTO_WRITE, type, file, line);
      478.   
      479. >         ret = *pointer + amount;
      480.   #ifdef LOCK_DEBUG
      481.           {

crypto/lock.c:490:9: 
      488.           }
      489.   #endif
      490. >         *pointer = ret;
      491.           CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, type, file, line);
      492.       }

crypto/lock.c:491:9: 
      489.   #endif
      490.           *pointer = ret;
      491. >         CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, type, file, line);
      492.       }
      493.       return (ret);

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
        412.   }
        413.   
        414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
        415.   {
        416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
        439.       }
        440.   #endif
        441.       if (type < 0) {
                       ^
        442.           if (dynlock_lock_callback != NULL) {
        443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking false branch
        450.               CRYPTO_destroy_dynlockid(type);
        451.           }
        452.       } else if (locking_callback != NULL)
                              ^
        453.           locking_callback(mode, type, file, line);
        454.   }

crypto/lock.c:441:5: 
        439.       }
        440.   #endif
        441. >     if (type < 0) {
        442.           if (dynlock_lock_callback != NULL) {
        443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
        452.       } else if (locking_callback != NULL)
        453.           locking_callback(mode, type, file, line);
        454. > }
        455.   
        456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/lock.c:493:5: 
      491.           CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, type, file, line);
      492.       }
      493. >     return (ret);
      494.   }
      495.   

crypto/lock.c:494:1: return from a call to CRYPTO_add_lock
      492.       }
      493.       return (ret);
      494. > }
      495.   
      496.   const char *CRYPTO_get_lock_name(int type)

crypto/x509/x509_lu.c:235:9: Taking true branch
    233.       REF_PRINT("X509_STORE", vfy);
    234.   #endif
    235.       if (i > 0)
                   ^
    236.           return;
    237.   #ifdef REF_CHECK

crypto/x509/x509_lu.c:236:9: 
    234.   #endif
    235.       if (i > 0)
    236. >         return;
    237.   #ifdef REF_CHECK
    238.       if (i < 0) {

crypto/x509/x509_lu.c:256:1: return from a call to X509_STORE_free
    254.       X509_VERIFY_PARAM_free(vfy->param);
    255.       OPENSSL_free(vfy);
    256. > }
    257.   
    258.   X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m)

apps/ts.c:992:5: 
  990.    err:
  991.       X509_STORE_free(cert_ctx);
  992. >     return NULL;
  993.   }
  994.   

apps/ts.c:993:1: return from a call to create_cert_store
  991.       X509_STORE_free(cert_ctx);
  992.       return NULL;
  993. > }
  994.   
  995.   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:935:9: Taking true branch
933.   
934.       /* Initialising the X509_STORE object. */
935.       if (TS_VERIFY_CTX_set_store(ctx, create_cert_store(CApath, CAfile))
               ^
936.               == NULL)
937.           goto err;

apps/ts.c:945:2: 
943.       ret = 1;
944.   
945. >  err:
946.       if (!ret) {
947.           TS_VERIFY_CTX_free(ctx);

apps/ts.c:946:10: Taking true branch
944.   
945.    err:
946.       if (!ret) {
                ^
947.           TS_VERIFY_CTX_free(ctx);
948.           ctx = NULL;

apps/ts.c:947:9: 
945.    err:
946.       if (!ret) {
947. >         TS_VERIFY_CTX_free(ctx);
948.           ctx = NULL;
949.       }

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: 
  82.           return;
  83.   
  84. >     TS_VERIFY_CTX_cleanup(ctx);
  85.       OPENSSL_free(ctx);
  86.   }

crypto/ts/ts_verify_ctx.c:127:1: start of procedure TS_VERIFY_CTX_cleanup()
    125.   }
    126.   
    127. > void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx)
    128.   {
    129.       if (!ctx)

crypto/ts/ts_verify_ctx.c:129:10: Taking false branch
    127.   void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx)
    128.   {
    129.       if (!ctx)
                    ^
    130.           return;
    131.   

crypto/ts/ts_verify_ctx.c:132:5: 
    130.           return;
    131.   
    132. >     X509_STORE_free(ctx->store);
    133.       sk_X509_pop_free(ctx->certs, X509_free);
    134.   

crypto/x509/x509_lu.c:222:1: start of procedure X509_STORE_free()
      220.   }
      221.   
      222. > void X509_STORE_free(X509_STORE *vfy)
      223.   {
      224.       int i;

crypto/x509/x509_lu.c:228:9: Taking false branch
      226.       X509_LOOKUP *lu;
      227.   
      228.       if (vfy == NULL)
                     ^
      229.           return;
      230.   

crypto/x509/x509_lu.c:231:5: 
      229.           return;
      230.   
      231. >     i = CRYPTO_add(&vfy->references, -1, CRYPTO_LOCK_X509_STORE);
      232.   #ifdef REF_PRINT
      233.       REF_PRINT("X509_STORE", vfy);

crypto/lock.c:456:1: start of procedure CRYPTO_add_lock()
        454.   }
        455.   
        456. > int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
        457.                       int line)
        458.   {

crypto/lock.c:459:5: 
        457.                       int line)
        458.   {
        459. >     int ret = 0;
        460.   
        461.       if (add_lock_callback != NULL) {

crypto/lock.c:461:9: Taking false branch
        459.       int ret = 0;
        460.   
        461.       if (add_lock_callback != NULL) {
                       ^
        462.   #ifdef LOCK_DEBUG
        463.           int before = *pointer;

crypto/lock.c:477:9: 
        475.   #endif
        476.       } else {
        477. >         CRYPTO_lock(CRYPTO_LOCK | CRYPTO_WRITE, type, file, line);
        478.   
        479.           ret = *pointer + amount;

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
          412.   }
          413.   
          414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
          415.   {
          416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
          439.       }
          440.   #endif
          441.       if (type < 0) {
                         ^
          442.           if (dynlock_lock_callback != NULL) {
          443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking false branch
          450.               CRYPTO_destroy_dynlockid(type);
          451.           }
          452.       } else if (locking_callback != NULL)
                                ^
          453.           locking_callback(mode, type, file, line);
          454.   }

crypto/lock.c:441:5: 
          439.       }
          440.   #endif
          441. >     if (type < 0) {
          442.           if (dynlock_lock_callback != NULL) {
          443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
          452.       } else if (locking_callback != NULL)
          453.           locking_callback(mode, type, file, line);
          454. > }
          455.   
          456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/lock.c:479:9: 
        477.           CRYPTO_lock(CRYPTO_LOCK | CRYPTO_WRITE, type, file, line);
        478.   
        479. >         ret = *pointer + amount;
        480.   #ifdef LOCK_DEBUG
        481.           {
