test/exdatatest.c:206: error: MEMORY_LEAK
  memory dynamically allocated by call to `CRYPTO_strdup()` at line 195, column 9 is not reachable after line 206, column 10.
Showing all 47 steps of the trace


test/exdatatest.c:186:1: start of procedure test_exdata()
184.   }
185.   
186. > static int test_exdata(void)
187.   {
188.       MYOBJ *t1, *t2, *t3;

test/exdatatest.c:193:5: 
191.       char *p;
192.   
193. >     gbl_result = 1;
194.   
195.       p = OPENSSL_strdup("hello world");

test/exdatatest.c:195:5: 
193.       gbl_result = 1;
194.   
195. >     p = OPENSSL_strdup("hello world");
196.       saved_argl = 21;
197.       saved_argp = OPENSSL_malloc(1);

crypto/o_str.c:28:1: start of procedure CRYPTO_strdup()
  26.   }
  27.   
  28. > char *CRYPTO_strdup(const char *str, const char* file, int line)
  29.   {
  30.       char *ret;

crypto/o_str.c:33:9: Taking false branch
  31.       size_t size;
  32.   
  33.       if (str == NULL)
                ^
  34.           return NULL;
  35.       size = strlen(str) + 1;

crypto/o_str.c:35:5: 
  33.       if (str == NULL)
  34.           return NULL;
  35. >     size = strlen(str) + 1;
  36.       ret = CRYPTO_malloc(size, file, line);
  37.       if (ret != NULL)

crypto/o_str.c:36:5: 
  34.           return NULL;
  35.       size = strlen(str) + 1;
  36. >     ret = CRYPTO_malloc(size, file, line);
  37.       if (ret != NULL)
  38.           memcpy(ret, str, size);

crypto/mem.c:158:1: start of procedure CRYPTO_malloc()
    156.   #endif
    157.   
    158. > void *CRYPTO_malloc(size_t num, const char *file, int line)
    159.   {
    160.       void *ret = NULL;

crypto/mem.c:160:5: 
    158.   void *CRYPTO_malloc(size_t num, const char *file, int line)
    159.   {
    160. >     void *ret = NULL;
    161.   
    162.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)

crypto/mem.c:162:9: Taking false branch
    160.       void *ret = NULL;
    161.   
    162.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                   ^
    163.           return malloc_impl(num, file, line);
    164.   

crypto/mem.c:165:9: Taking false branch
    163.           return malloc_impl(num, file, line);
    164.   
    165.       if (num == 0)
                   ^
    166.           return NULL;
    167.   

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

crypto/mem.c:179:5: 
    177.       }
    178.   #else
    179. >     osslargused(file); osslargused(line);
    180.       ret = malloc(num);
    181.   #endif

crypto/mem.c:179:24: 
    177.       }
    178.   #else
    179. >     osslargused(file); osslargused(line);
    180.       ret = malloc(num);
    181.   #endif

crypto/mem.c:180:5: 
    178.   #else
    179.       osslargused(file); osslargused(line);
    180. >     ret = malloc(num);
    181.   #endif
    182.   

crypto/mem.c:183:5: 
    181.   #endif
    182.   
    183. >     return ret;
    184.   }
    185.   

crypto/mem.c:184:1: return from a call to CRYPTO_malloc
    182.   
    183.       return ret;
    184. > }
    185.   
    186.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/o_str.c:37:9: Taking true branch
  35.       size = strlen(str) + 1;
  36.       ret = CRYPTO_malloc(size, file, line);
  37.       if (ret != NULL)
                ^
  38.           memcpy(ret, str, size);
  39.       return ret;

crypto/o_str.c:38:9: 
  36.       ret = CRYPTO_malloc(size, file, line);
  37.       if (ret != NULL)
  38. >         memcpy(ret, str, size);
  39.       return ret;
  40.   }

crypto/o_str.c:39:5: 
  37.       if (ret != NULL)
  38.           memcpy(ret, str, size);
  39. >     return ret;
  40.   }
  41.   

crypto/o_str.c:40:1: return from a call to CRYPTO_strdup
  38.           memcpy(ret, str, size);
  39.       return ret;
  40. > }
  41.   
  42.   char *CRYPTO_strndup(const char *str, size_t s, const char* file, int line)

test/exdatatest.c:196:5: 
194.   
195.       p = OPENSSL_strdup("hello world");
196. >     saved_argl = 21;
197.       saved_argp = OPENSSL_malloc(1);
198.       saved_idx = CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_APP,

test/exdatatest.c:197:5: 
195.       p = OPENSSL_strdup("hello world");
196.       saved_argl = 21;
197. >     saved_argp = OPENSSL_malloc(1);
198.       saved_idx = CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_APP,
199.                                           saved_argl, saved_argp,

crypto/mem.c:158:1: start of procedure CRYPTO_malloc()
  156.   #endif
  157.   
  158. > void *CRYPTO_malloc(size_t num, const char *file, int line)
  159.   {
  160.       void *ret = NULL;

crypto/mem.c:160:5: 
  158.   void *CRYPTO_malloc(size_t num, const char *file, int line)
  159.   {
  160. >     void *ret = NULL;
  161.   
  162.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)

crypto/mem.c:162:9: Taking false branch
  160.       void *ret = NULL;
  161.   
  162.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                 ^
  163.           return malloc_impl(num, file, line);
  164.   

crypto/mem.c:165:9: Taking false branch
  163.           return malloc_impl(num, file, line);
  164.   
  165.       if (num == 0)
                 ^
  166.           return NULL;
  167.   

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

crypto/mem.c:179:5: 
  177.       }
  178.   #else
  179. >     osslargused(file); osslargused(line);
  180.       ret = malloc(num);
  181.   #endif

crypto/mem.c:179:24: 
  177.       }
  178.   #else
  179. >     osslargused(file); osslargused(line);
  180.       ret = malloc(num);
  181.   #endif

crypto/mem.c:180:5: 
  178.   #else
  179.       osslargused(file); osslargused(line);
  180. >     ret = malloc(num);
  181.   #endif
  182.   

crypto/mem.c:183:5: 
  181.   #endif
  182.   
  183. >     return ret;
  184.   }
  185.   

crypto/mem.c:184:1: return from a call to CRYPTO_malloc
  182.   
  183.       return ret;
  184. > }
  185.   
  186.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

test/exdatatest.c:198:5: Skipping CRYPTO_get_ex_new_index(): empty list of specs
196.       saved_argl = 21;
197.       saved_argp = OPENSSL_malloc(1);
198.       saved_idx = CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_APP,
           ^
199.                                           saved_argl, saved_argp,
200.                                           exnew, exdup, exfree);

test/exdatatest.c:201:5: Skipping CRYPTO_get_ex_new_index(): empty list of specs
199.                                           saved_argl, saved_argp,
200.                                           exnew, exdup, exfree);
201.       saved_idx2 = CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_APP,
           ^
202.                                            saved_argl, saved_argp,
203.                                            exnew2, exdup2, exfree2);

test/exdatatest.c:204:5: Skipping MYOBJ_new(): empty list of specs
202.                                            saved_argl, saved_argp,
203.                                            exnew2, exdup2, exfree2);
204.       t1 = MYOBJ_new();
           ^
205.       t2 = MYOBJ_new();
206.       if (!TEST_int_eq(t1->st, 1) || !TEST_int_eq(t2->st, 1))

test/exdatatest.c:205:5: Skipping MYOBJ_new(): empty list of specs
203.                                            exnew2, exdup2, exfree2);
204.       t1 = MYOBJ_new();
205.       t2 = MYOBJ_new();
           ^
206.       if (!TEST_int_eq(t1->st, 1) || !TEST_int_eq(t2->st, 1))
207.           return 0;

test/exdatatest.c:206:10: 
204.       t1 = MYOBJ_new();
205.       t2 = MYOBJ_new();
206. >     if (!TEST_int_eq(t1->st, 1) || !TEST_int_eq(t2->st, 1))
207.           return 0;
208.       if (!TEST_ptr(CRYPTO_get_ex_data(&t1->ex_data, saved_idx2)))

test/testutil/tests.c:588:1: start of procedure test_int_eq()
  586.       DEFINE_COMPARISON(type, name, ge, >=, fmt)
  587.   
  588. > DEFINE_COMPARISONS(int, int, "%d")
  589.   DEFINE_COMPARISONS(unsigned int, uint, "%u")
  590.   DEFINE_COMPARISONS(char, char, "%c")

test/testutil/tests.c:588:1: Taking false branch
  586.       DEFINE_COMPARISON(type, name, ge, >=, fmt)
  587.   
  588. > DEFINE_COMPARISONS(int, int, "%d")
  589.   DEFINE_COMPARISONS(unsigned int, uint, "%u")
  590.   DEFINE_COMPARISONS(char, char, "%c")

test/testutil/tests.c:492:1: start of procedure test_fail_message()
    490.   }
    491.   
    492. > static void test_fail_message(const char *prefix, const char *file,
    493.                                 int line, const char *type,
    494.                                 const char *left, const char *right,

test/testutil/tests.c:499:5: 
    497.       va_list ap;
    498.   
    499. >     va_start(ap, fmt);
    500.       test_fail_message_va(prefix, file, line, type, left, right, op, fmt, ap);
    501.       va_end(ap);

test/testutil/tests.c:500:5: Skipping test_fail_message_va(): empty list of specs
    498.   
    499.       va_start(ap, fmt);
    500.       test_fail_message_va(prefix, file, line, type, left, right, op, fmt, ap);
               ^
    501.       va_end(ap);
    502.   }

test/testutil/tests.c:501:5: 
    499.       va_start(ap, fmt);
    500.       test_fail_message_va(prefix, file, line, type, left, right, op, fmt, ap);
    501. >     va_end(ap);
    502.   }
    503.   

test/testutil/tests.c:502:1: return from a call to test_fail_message
    500.       test_fail_message_va(prefix, file, line, type, left, right, op, fmt, ap);
    501.       va_end(ap);
    502. > }
    503.   
    504.   void test_info_c90(const char *desc, ...)

test/testutil/tests.c:588:1: return from a call to test_int_eq
  586.       DEFINE_COMPARISON(type, name, ge, >=, fmt)
  587.   
  588. > DEFINE_COMPARISONS(int, int, "%d")
  589.   DEFINE_COMPARISONS(unsigned int, uint, "%u")
  590.   DEFINE_COMPARISONS(char, char, "%c")

test/exdatatest.c:206:10: Taking true branch
204.       t1 = MYOBJ_new();
205.       t2 = MYOBJ_new();
206.       if (!TEST_int_eq(t1->st, 1) || !TEST_int_eq(t2->st, 1))
                ^
207.           return 0;
208.       if (!TEST_ptr(CRYPTO_get_ex_data(&t1->ex_data, saved_idx2)))
