ssl/bio_ssl.c:505: error: MEMORY_LEAK
  memory dynamically allocated by call to `BIO_new()` at line 497, column 16 is not reachable after line 505, column 5.
Showing all 52 steps of the trace


ssl/bio_ssl.c:492:1: start of procedure BIO_new_buffer_ssl_connect()
490.   }
491.   
492. > BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx)
493.   {
494.   #ifndef OPENSSL_NO_SOCK

ssl/bio_ssl.c:495:5: 
493.   {
494.   #ifndef OPENSSL_NO_SOCK
495. >     BIO *ret = NULL, *buf = NULL, *ssl = NULL;
496.   
497.       if ((buf = BIO_new(BIO_f_buffer())) == NULL)

ssl/bio_ssl.c:497:9: 
495.       BIO *ret = NULL, *buf = NULL, *ssl = NULL;
496.   
497. >     if ((buf = BIO_new(BIO_f_buffer())) == NULL)
498.           return (NULL);
499.       if ((ssl = BIO_new_ssl_connect(ctx)) == NULL)

crypto/bio/bf_buff.c:86:1: start of procedure BIO_f_buffer()
  84.   };
  85.   
  86. > BIO_METHOD *BIO_f_buffer(void)
  87.   {
  88.       return (&methods_buffer);

crypto/bio/bf_buff.c:88:5: 
  86.   BIO_METHOD *BIO_f_buffer(void)
  87.   {
  88. >     return (&methods_buffer);
  89.   }
  90.   

crypto/bio/bf_buff.c:89:1: return from a call to BIO_f_buffer
  87.   {
  88.       return (&methods_buffer);
  89. > }
  90.   
  91.   static int buffer_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)

ssl/bio_ssl.c:497:9: Taking false branch
495.       BIO *ret = NULL, *buf = NULL, *ssl = NULL;
496.   
497.       if ((buf = BIO_new(BIO_f_buffer())) == NULL)
               ^
498.           return (NULL);
499.       if ((ssl = BIO_new_ssl_connect(ctx)) == NULL)

ssl/bio_ssl.c:499:9: Taking true branch
497.       if ((buf = BIO_new(BIO_f_buffer())) == NULL)
498.           return (NULL);
499.       if ((ssl = BIO_new_ssl_connect(ctx)) == NULL)
               ^
500.           goto err;
501.       if ((ret = BIO_push(buf, ssl)) == NULL)

ssl/bio_ssl.c:504:2: 
502.           goto err;
503.       return (ret);
504. >  err:
505.       BIO_free(buf);
506.       BIO_free(ssl);

ssl/bio_ssl.c:505:5: 
503.       return (ret);
504.    err:
505. >     BIO_free(buf);
506.       BIO_free(ssl);
507.   #endif

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.   #ifdef REF_PRINT
  114.       REF_PRINT("BIO", a);

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:116:9: Taking false branch
  114.       REF_PRINT("BIO", a);
  115.   #endif
  116.       if (i > 0)
                 ^
  117.           return (1);
  118.   #ifdef REF_CHECK

crypto/bio/bio_lib.c:124:10: Taking true branch
  122.       }
  123.   #endif
  124.       if ((a->callback != NULL) &&
                  ^
  125.           ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
  126.           return (i);

crypto/bio/bio_lib.c:125:10: Taking true branch
  123.   #endif
  124.       if ((a->callback != NULL) &&
  125.           ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
                  ^
  126.           return (i);
  127.   

crypto/bio/bio_lib.c:126:9: 
  124.       if ((a->callback != NULL) &&
  125.           ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0))
  126. >         return (i);
  127.   
  128.       CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);

crypto/bio/bio_lib.c:134:1: return from a call to BIO_free
  132.       OPENSSL_free(a);
  133.       return (1);
  134. > }
  135.   
  136.   void BIO_vfree(BIO *a)
