apps/engine.c:111: error: MEMORY_LEAK
  memory dynamically allocated by call to `app_malloc()` at line 105, column 16 is not reachable after line 111, column 9.
Showing all 32 steps of the trace


apps/engine.c:101:1: start of procedure append_buf()
99.   }
100.   
101. > static int append_buf(char **buf, int *size, const char *s)
102.   {
103.       if (*buf == NULL) {

apps/engine.c:103:9: Taking true branch
101.   static int append_buf(char **buf, int *size, const char *s)
102.   {
103.       if (*buf == NULL) {
               ^
104.           *size = 256;
105.           *buf = app_malloc(*size, "engine buffer");

apps/engine.c:104:9: 
102.   {
103.       if (*buf == NULL) {
104. >         *size = 256;
105.           *buf = app_malloc(*size, "engine buffer");
106.           **buf = '\0';

apps/engine.c:105:9: 
103.       if (*buf == NULL) {
104.           *size = 256;
105. >         *buf = app_malloc(*size, "engine buffer");
106.           **buf = '\0';
107.       }

apps/apps.c:993:1: start of procedure app_malloc()
  991.   }
  992.   
  993. > void* app_malloc(int sz, const char *what)
  994.   {
  995.       void *vp = OPENSSL_malloc(sz);

apps/apps.c:995:5: 
  993.   void* app_malloc(int sz, const char *what)
  994.   {
  995. >     void *vp = OPENSSL_malloc(sz);
  996.   
  997.       if (vp == 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)

apps/apps.c:997:9: Taking false branch
  995.       void *vp = OPENSSL_malloc(sz);
  996.   
  997.       if (vp == NULL) {
                  ^
  998.           BIO_printf(bio_err, "%s: Could not allocate %d bytes for %s\n",
  999.                   opt_getprog(), sz, what);

apps/apps.c:1003:5: 
  1001.           exit(1);
  1002.       }
  1003. >     return vp;
  1004.   }
  1005.   

apps/apps.c:1004:1: return from a call to app_malloc
  1002.       }
  1003.       return vp;
  1004. > }
  1005.   
  1006.   /*

apps/engine.c:106:9: 
104.           *size = 256;
105.           *buf = app_malloc(*size, "engine buffer");
106. >         **buf = '\0';
107.       }
108.   

apps/engine.c:109:9: Taking true branch
107.       }
108.   
109.       if (strlen(*buf) + strlen(s) >= (unsigned int)*size) {
               ^
110.           *size += 256;
111.           *buf = OPENSSL_realloc(*buf, *size);

apps/engine.c:110:9: 
108.   
109.       if (strlen(*buf) + strlen(s) >= (unsigned int)*size) {
110. >         *size += 256;
111.           *buf = OPENSSL_realloc(*buf, *size);
112.       }

apps/engine.c:111:9: 
109.       if (strlen(*buf) + strlen(s) >= (unsigned int)*size) {
110.           *size += 256;
111. >         *buf = OPENSSL_realloc(*buf, *size);
112.       }
113.   

crypto/mem.c:155:1: start of procedure CRYPTO_realloc()
  153.   }
  154.   
  155. > void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)
  156.   {
  157.       if (realloc_impl != NULL && realloc_impl != &CRYPTO_realloc)

crypto/mem.c:157:9: Taking false branch
  155.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)
  156.   {
  157.       if (realloc_impl != NULL && realloc_impl != &CRYPTO_realloc)
                 ^
  158.           return realloc_impl(str, num, file, line);
  159.   

crypto/mem.c:160:9: Taking false branch
  158.           return realloc_impl(str, num, file, line);
  159.   
  160.       if (str == NULL)
                 ^
  161.           return CRYPTO_malloc(num, file, line);
  162.   

crypto/mem.c:163:9: Taking false branch
  161.           return CRYPTO_malloc(num, file, line);
  162.   
  163.       if (num == 0) {
                 ^
  164.           CRYPTO_free(str, file, line);
  165.           return NULL;

crypto/mem.c:168:5: 
  166.       }
  167.   
  168. >     allow_customize = 0;
  169.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
  170.       if (call_malloc_debug) {

crypto/mem.c:178:5: 
  176.       }
  177.   #else
  178. >     osslargused(file); osslargused(line);
  179.   #endif
  180.       return realloc(str, num);

crypto/mem.c:178:24: 
  176.       }
  177.   #else
  178. >     osslargused(file); osslargused(line);
  179.   #endif
  180.       return realloc(str, num);

crypto/mem.c:180:5: 
  178.       osslargused(file); osslargused(line);
  179.   #endif
  180. >     return realloc(str, num);
  181.   
  182.   }

crypto/mem.c:182:1: return from a call to CRYPTO_realloc
  180.       return realloc(str, num);
  181.   
  182. > }
  183.   
  184.   void *CRYPTO_clear_realloc(void *str, size_t old_len, size_t num,
