crypto/cms/cms_smime.c:117: error: MEMORY_LEAK
  memory dynamically allocated by call to `cms_get_text_bio()` at line 82, column 14 is not reachable after line 117, column 9.
Showing all 76 steps of the trace


crypto/cms/cms_smime.c:76:1: start of procedure cms_copy_content()
74.   }
75.   
76. > static int cms_copy_content(BIO *out, BIO *in, unsigned int flags)
77.   {
78.       unsigned char buf[4096];

crypto/cms/cms_smime.c:79:5: 
77.   {
78.       unsigned char buf[4096];
79. >     int r = 0, i;
80.       BIO *tmpout;
81.   

crypto/cms/cms_smime.c:82:5: 
80.       BIO *tmpout;
81.   
82. >     tmpout = cms_get_text_bio(out, flags);
83.   
84.       if (tmpout == NULL) {

crypto/cms/cms_smime.c:63:1: start of procedure cms_get_text_bio()
  61.   #include "internal/asn1_int.h"
  62.   
  63. > static BIO *cms_get_text_bio(BIO *out, unsigned int flags)
  64.   {
  65.       BIO *rbio;

crypto/cms/cms_smime.c:66:9: Taking true branch
  64.   {
  65.       BIO *rbio;
  66.       if (out == NULL)
                ^
  67.           rbio = BIO_new(BIO_s_null());
  68.       else if (flags & CMS_TEXT) {

crypto/cms/cms_smime.c:67:9: 
  65.       BIO *rbio;
  66.       if (out == NULL)
  67. >         rbio = BIO_new(BIO_s_null());
  68.       else if (flags & CMS_TEXT) {
  69.           rbio = BIO_new(BIO_s_mem());

crypto/bio/bss_null.c:83:1: start of procedure BIO_s_null()
    81.   };
    82.   
    83. > BIO_METHOD *BIO_s_null(void)
    84.   {
    85.       return (&null_method);

crypto/bio/bss_null.c:85:5: 
    83.   BIO_METHOD *BIO_s_null(void)
    84.   {
    85. >     return (&null_method);
    86.   }
    87.   

crypto/bio/bss_null.c:86:1: return from a call to BIO_s_null
    84.   {
    85.       return (&null_method);
    86. > }
    87.   
    88.   static int null_new(BIO *bi)

crypto/bio/bio_lib.c:65:1: start of procedure BIO_new()
    63.   #include <openssl/stack.h>
    64.   
    65. > BIO *BIO_new(BIO_METHOD *method)
    66.   {
    67.       BIO *ret = OPENSSL_malloc(sizeof(*ret));

crypto/bio/bio_lib.c:67:5: 
    65.   BIO *BIO_new(BIO_METHOD *method)
    66.   {
    67. >     BIO *ret = OPENSSL_malloc(sizeof(*ret));
    68.   
    69.       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/bio/bio_lib.c:69:9: Taking false branch
    67.       BIO *ret = OPENSSL_malloc(sizeof(*ret));
    68.   
    69.       if (ret == NULL) {
                  ^
    70.           BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE);
    71.           return (NULL);

crypto/bio/bio_lib.c:73:10: Taking false branch
    71.           return (NULL);
    72.       }
    73.       if (!BIO_set(ret, method)) {
                   ^
    74.           OPENSSL_free(ret);
    75.           ret = NULL;

crypto/bio/bio_lib.c:77:5: 
    75.           ret = NULL;
    76.       }
    77. >     return (ret);
    78.   }
    79.   

crypto/bio/bio_lib.c:78:1: return from a call to BIO_new
    76.       }
    77.       return (ret);
    78. > }
    79.   
    80.   int BIO_set(BIO *bio, BIO_METHOD *method)

crypto/cms/cms_smime.c:73:5: 
  71.       } else
  72.           rbio = out;
  73. >     return rbio;
  74.   }
  75.   

crypto/cms/cms_smime.c:74:1: return from a call to cms_get_text_bio
  72.           rbio = out;
  73.       return rbio;
  74. > }
  75.   
  76.   static int cms_copy_content(BIO *out, BIO *in, unsigned int flags)

crypto/cms/cms_smime.c:84:9: Taking false branch
82.       tmpout = cms_get_text_bio(out, flags);
83.   
84.       if (tmpout == NULL) {
              ^
85.           CMSerr(CMS_F_CMS_COPY_CONTENT, ERR_R_MALLOC_FAILURE);
86.           goto err;

crypto/cms/cms_smime.c:104:5: Loop condition is true. Entering loop body
102.           if (tmpout && (BIO_write(tmpout, buf, i) != i))
103.               goto err;
104.       }
           ^
105.   
106.       if (flags & CMS_TEXT) {

crypto/cms/cms_smime.c:91:9: 
89.       /* Read all content through chain to process digest, decrypt etc */
90.       for (;;) {
91. >         i = BIO_read(in, buf, sizeof(buf));
92.           if (i <= 0) {
93.               if (BIO_method_type(in) == BIO_TYPE_CIPHER) {

crypto/bio/bio_lib.c:181:1: start of procedure BIO_read()
  179.   }
  180.   
  181. > int BIO_read(BIO *b, void *out, int outl)
  182.   {
  183.       int i;

crypto/bio/bio_lib.c:186:10: Taking false branch
  184.       long (*cb) (BIO *, int, const char *, int, long, long);
  185.   
  186.       if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) {
                  ^
  187.           BIOerr(BIO_F_BIO_READ, BIO_R_UNSUPPORTED_METHOD);
  188.           return (-2);

crypto/bio/bio_lib.c:186:25: Taking false branch
  184.       long (*cb) (BIO *, int, const char *, int, long, long);
  185.   
  186.       if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) {
                                 ^
  187.           BIOerr(BIO_F_BIO_READ, BIO_R_UNSUPPORTED_METHOD);
  188.           return (-2);

crypto/bio/bio_lib.c:186:48: Taking false branch
  184.       long (*cb) (BIO *, int, const char *, int, long, long);
  185.   
  186.       if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) {
                                                        ^
  187.           BIOerr(BIO_F_BIO_READ, BIO_R_UNSUPPORTED_METHOD);
  188.           return (-2);

crypto/bio/bio_lib.c:191:5: 
  189.       }
  190.   
  191. >     cb = b->callback;
  192.       if ((cb != NULL) &&
  193.           ((i = (int)cb(b, BIO_CB_READ, out, outl, 0L, 1L)) <= 0))

crypto/bio/bio_lib.c:192:10: Taking false branch
  190.   
  191.       cb = b->callback;
  192.       if ((cb != NULL) &&
                  ^
  193.           ((i = (int)cb(b, BIO_CB_READ, out, outl, 0L, 1L)) <= 0))
  194.           return (i);

crypto/bio/bio_lib.c:196:10: Taking true branch
  194.           return (i);
  195.   
  196.       if (!b->init) {
                  ^
  197.           BIOerr(BIO_F_BIO_READ, BIO_R_UNINITIALIZED);
  198.           return (-2);

crypto/bio/bio_lib.c:197:9: Skipping ERR_put_error(): empty list of specs
  195.   
  196.       if (!b->init) {
  197.           BIOerr(BIO_F_BIO_READ, BIO_R_UNINITIALIZED);
                 ^
  198.           return (-2);
  199.       }

crypto/bio/bio_lib.c:198:9: 
  196.       if (!b->init) {
  197.           BIOerr(BIO_F_BIO_READ, BIO_R_UNINITIALIZED);
  198. >         return (-2);
  199.       }
  200.   

crypto/bio/bio_lib.c:209:1: return from a call to BIO_read
  207.           i = (int)cb(b, BIO_CB_READ | BIO_CB_RETURN, out, outl, 0L, (long)i);
  208.       return (i);
  209. > }
  210.   
  211.   int BIO_write(BIO *b, const void *in, int inl)

crypto/cms/cms_smime.c:92:13: Taking true branch
90.       for (;;) {
91.           i = BIO_read(in, buf, sizeof(buf));
92.           if (i <= 0) {
                  ^
93.               if (BIO_method_type(in) == BIO_TYPE_CIPHER) {
94.                   if (!BIO_get_cipher_status(in))

crypto/cms/cms_smime.c:93:17: 
91.           i = BIO_read(in, buf, sizeof(buf));
92.           if (i <= 0) {
93. >             if (BIO_method_type(in) == BIO_TYPE_CIPHER) {
94.                   if (!BIO_get_cipher_status(in))
95.                       goto err;

crypto/bio/bio_lib.c:176:1: start of procedure BIO_method_type()
  174.   }
  175.   
  176. > int BIO_method_type(const BIO *b)
  177.   {
  178.       return b->method->type;

crypto/bio/bio_lib.c:178:5: 
  176.   int BIO_method_type(const BIO *b)
  177.   {
  178. >     return b->method->type;
  179.   }
  180.   

crypto/bio/bio_lib.c:179:1: return from a call to BIO_method_type
  177.   {
  178.       return b->method->type;
  179. > }
  180.   
  181.   int BIO_read(BIO *b, void *out, int outl)

crypto/cms/cms_smime.c:93:17: Taking false branch
91.           i = BIO_read(in, buf, sizeof(buf));
92.           if (i <= 0) {
93.               if (BIO_method_type(in) == BIO_TYPE_CIPHER) {
                      ^
94.                   if (!BIO_get_cipher_status(in))
95.                       goto err;

crypto/cms/cms_smime.c:97:17: Taking true branch
95.                       goto err;
96.               }
97.               if (i < 0)
                       ^
98.                   goto err;
99.               break;

crypto/cms/cms_smime.c:115:2: 
113.       r = 1;
114.   
115. >  err:
116.       if (tmpout != out)
117.           BIO_free(tmpout);

crypto/cms/cms_smime.c:116:9: Taking true branch
114.   
115.    err:
116.       if (tmpout != out)
               ^
117.           BIO_free(tmpout);
118.       return r;

crypto/cms/cms_smime.c:117:9: 
115.    err:
116.       if (tmpout != out)
117. >         BIO_free(tmpout);
118.       return r;
119.   

crypto/bio/bio_lib.c:105:1: start of procedure BIO_free()
  103.   }
  104.   
  105. > int BIO_free(BIO *a)
  106.   {
  107.       int i;

crypto/bio/bio_lib.c:109:9: Taking false branch
  107.       int i;
  108.   
  109.       if (a == NULL)
                 ^
  110.           return (0);
  111.   

crypto/bio/bio_lib.c:112:5: 
  110.           return (0);
  111.   
  112. >     i = CRYPTO_add(&a->references, -1, CRYPTO_LOCK_BIO);
  113.       REF_PRINT_COUNT("BIO", a);
  114.       if (i > 0)

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/bio/bio_lib.c:114:9: Taking false branch
  112.       i = CRYPTO_add(&a->references, -1, CRYPTO_LOCK_BIO);
  113.       REF_PRINT_COUNT("BIO", a);
  114.       if (i > 0)
                 ^
  115.           return (1);
  116.       REF_ASSERT_ISNT(i < 0);

crypto/bio/bio_lib.c:117:10: Taking true branch
  115.           return (1);
  116.       REF_ASSERT_ISNT(i < 0);
  117.       if ((a->callback != NULL) &&
                  ^
  118.           ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
  119.           return (i);

crypto/bio/bio_lib.c:118:10: Taking true branch
  116.       REF_ASSERT_ISNT(i < 0);
  117.       if ((a->callback != NULL) &&
  118.           ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
                  ^
  119.           return (i);
  120.   

crypto/bio/bio_lib.c:119:9: 
  117.       if ((a->callback != NULL) &&
  118.           ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
  119. >         return (i);
  120.   
  121.       CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);

crypto/bio/bio_lib.c:127:1: return from a call to BIO_free
  125.       OPENSSL_free(a);
  126.       return (1);
  127. > }
  128.   
  129.   void BIO_vfree(BIO *a)
