crypto/x509/by_dir.c:193: error: MEMORY_LEAK
  memory dynamically allocated by call to `CRYPTO_strndup()` at line 191, column 24 is not reachable after line 193, column 17.
Showing all 96 steps of the trace


crypto/x509/by_dir.c:151:1: start of procedure add_cert_dir()
149.   }
150.   
151. > static int add_cert_dir(BY_DIR *ctx, const char *dir, int type)
152.   {
153.       int j;

crypto/x509/by_dir.c:157:9: Taking false branch
155.       const char *s, *ss, *p;
156.   
157.       if (dir == NULL || !*dir) {
               ^
158.           X509err(X509_F_ADD_CERT_DIR, X509_R_INVALID_DIRECTORY);
159.           return 0;

crypto/x509/by_dir.c:157:25: Taking false branch
155.       const char *s, *ss, *p;
156.   
157.       if (dir == NULL || !*dir) {
                               ^
158.           X509err(X509_F_ADD_CERT_DIR, X509_R_INVALID_DIRECTORY);
159.           return 0;

crypto/x509/by_dir.c:162:5: 
160.       }
161.   
162. >     s = dir;
163.       p = s;
164.       do {

crypto/x509/by_dir.c:163:5: 
161.   
162.       s = dir;
163. >     p = s;
164.       do {
165.           if ((*p == LIST_SEPARATOR_CHAR) || (*p == '\0')) {

crypto/x509/by_dir.c:165:14: Taking true branch
163.       p = s;
164.       do {
165.           if ((*p == LIST_SEPARATOR_CHAR) || (*p == '\0')) {
                    ^
166.               BY_DIR_ENTRY *ent;
167.               ss = s;

crypto/x509/by_dir.c:167:13: 
165.           if ((*p == LIST_SEPARATOR_CHAR) || (*p == '\0')) {
166.               BY_DIR_ENTRY *ent;
167. >             ss = s;
168.               s = p + 1;
169.               len = p - ss;

crypto/x509/by_dir.c:168:13: 
166.               BY_DIR_ENTRY *ent;
167.               ss = s;
168. >             s = p + 1;
169.               len = p - ss;
170.               if (len == 0)

crypto/x509/by_dir.c:169:13: 
167.               ss = s;
168.               s = p + 1;
169. >             len = p - ss;
170.               if (len == 0)
171.                   continue;

crypto/x509/by_dir.c:170:17: Taking false branch
168.               s = p + 1;
169.               len = p - ss;
170.               if (len == 0)
                       ^
171.                   continue;
172.               for (j = 0; j < sk_BY_DIR_ENTRY_num(ctx->dirs); j++) {

crypto/x509/by_dir.c:172:18: 
170.               if (len == 0)
171.                   continue;
172. >             for (j = 0; j < sk_BY_DIR_ENTRY_num(ctx->dirs); j++) {
173.                   ent = sk_BY_DIR_ENTRY_value(ctx->dirs, j);
174.                   if (strlen(ent->dir) == len && strncmp(ent->dir, ss, len) == 0)

crypto/x509/by_dir.c:172:25: 
170.               if (len == 0)
171.                   continue;
172. >             for (j = 0; j < sk_BY_DIR_ENTRY_num(ctx->dirs); j++) {
173.                   ent = sk_BY_DIR_ENTRY_value(ctx->dirs, j);
174.                   if (strlen(ent->dir) == len && strncmp(ent->dir, ss, len) == 0)

crypto/x509/x509_lcl.h:142:1: start of procedure sk_BY_DIR_ENTRY_num()
  140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
  141.   DEFINE_STACK_OF(BY_DIR_HASH)
  142. > DEFINE_STACK_OF(BY_DIR_ENTRY)
  143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;
  144.   DEFINE_STACK_OF(STACK_OF_X509_NAME_ENTRY)

crypto/stack/stack.c:277:1: start of procedure OPENSSL_sk_num()
    275.   }
    276.   
    277. > int OPENSSL_sk_num(const OPENSSL_STACK *st)
    278.   {
    279.       if (st == NULL)

crypto/stack/stack.c:279:9: Taking true branch
    277.   int OPENSSL_sk_num(const OPENSSL_STACK *st)
    278.   {
    279.       if (st == NULL)
                   ^
    280.           return -1;
    281.       return st->num;

crypto/stack/stack.c:280:9: 
    278.   {
    279.       if (st == NULL)
    280. >         return -1;
    281.       return st->num;
    282.   }

crypto/stack/stack.c:282:1: return from a call to OPENSSL_sk_num
    280.           return -1;
    281.       return st->num;
    282. > }
    283.   
    284.   void *OPENSSL_sk_value(const OPENSSL_STACK *st, int i)

crypto/x509/x509_lcl.h:142:1: return from a call to sk_BY_DIR_ENTRY_num
  140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
  141.   DEFINE_STACK_OF(BY_DIR_HASH)
  142. > DEFINE_STACK_OF(BY_DIR_ENTRY)
  143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;
  144.   DEFINE_STACK_OF(STACK_OF_X509_NAME_ENTRY)

crypto/x509/by_dir.c:172:25: Loop condition is false. Leaving loop
170.               if (len == 0)
171.                   continue;
172.               for (j = 0; j < sk_BY_DIR_ENTRY_num(ctx->dirs); j++) {
                               ^
173.                   ent = sk_BY_DIR_ENTRY_value(ctx->dirs, j);
174.                   if (strlen(ent->dir) == len && strncmp(ent->dir, ss, len) == 0)

crypto/x509/by_dir.c:177:17: 
175.                       break;
176.               }
177. >             if (j < sk_BY_DIR_ENTRY_num(ctx->dirs))
178.                   continue;
179.               if (ctx->dirs == NULL) {

crypto/x509/x509_lcl.h:142:1: start of procedure sk_BY_DIR_ENTRY_num()
  140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
  141.   DEFINE_STACK_OF(BY_DIR_HASH)
  142. > DEFINE_STACK_OF(BY_DIR_ENTRY)
  143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;
  144.   DEFINE_STACK_OF(STACK_OF_X509_NAME_ENTRY)

crypto/stack/stack.c:277:1: start of procedure OPENSSL_sk_num()
    275.   }
    276.   
    277. > int OPENSSL_sk_num(const OPENSSL_STACK *st)
    278.   {
    279.       if (st == NULL)

crypto/stack/stack.c:279:9: Taking true branch
    277.   int OPENSSL_sk_num(const OPENSSL_STACK *st)
    278.   {
    279.       if (st == NULL)
                   ^
    280.           return -1;
    281.       return st->num;

crypto/stack/stack.c:280:9: 
    278.   {
    279.       if (st == NULL)
    280. >         return -1;
    281.       return st->num;
    282.   }

crypto/stack/stack.c:282:1: return from a call to OPENSSL_sk_num
    280.           return -1;
    281.       return st->num;
    282. > }
    283.   
    284.   void *OPENSSL_sk_value(const OPENSSL_STACK *st, int i)

crypto/x509/x509_lcl.h:142:1: return from a call to sk_BY_DIR_ENTRY_num
  140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
  141.   DEFINE_STACK_OF(BY_DIR_HASH)
  142. > DEFINE_STACK_OF(BY_DIR_ENTRY)
  143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;
  144.   DEFINE_STACK_OF(STACK_OF_X509_NAME_ENTRY)

crypto/x509/by_dir.c:177:17: Taking false branch
175.                       break;
176.               }
177.               if (j < sk_BY_DIR_ENTRY_num(ctx->dirs))
                       ^
178.                   continue;
179.               if (ctx->dirs == NULL) {

crypto/x509/by_dir.c:179:17: Taking true branch
177.               if (j < sk_BY_DIR_ENTRY_num(ctx->dirs))
178.                   continue;
179.               if (ctx->dirs == NULL) {
                       ^
180.                   ctx->dirs = sk_BY_DIR_ENTRY_new_null();
181.                   if (!ctx->dirs) {

crypto/x509/by_dir.c:180:17: 
178.                   continue;
179.               if (ctx->dirs == NULL) {
180. >                 ctx->dirs = sk_BY_DIR_ENTRY_new_null();
181.                   if (!ctx->dirs) {
182.                       X509err(X509_F_ADD_CERT_DIR, ERR_R_MALLOC_FAILURE);

crypto/x509/x509_lcl.h:142:1: start of procedure sk_BY_DIR_ENTRY_new_null()
  140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
  141.   DEFINE_STACK_OF(BY_DIR_HASH)
  142. > DEFINE_STACK_OF(BY_DIR_ENTRY)
  143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;
  144.   DEFINE_STACK_OF(STACK_OF_X509_NAME_ENTRY)

crypto/stack/stack.c:99:1: start of procedure OPENSSL_sk_new_null()
    97.   }
    98.   
    99. > OPENSSL_STACK *OPENSSL_sk_new_null(void)
    100.   {
    101.       return OPENSSL_sk_new((OPENSSL_sk_compfunc)NULL);

crypto/stack/stack.c:101:5: Skipping OPENSSL_sk_new(): empty list of specs
    99.   OPENSSL_STACK *OPENSSL_sk_new_null(void)
    100.   {
    101.       return OPENSSL_sk_new((OPENSSL_sk_compfunc)NULL);
               ^
    102.   }
    103.   

crypto/stack/stack.c:102:1: return from a call to OPENSSL_sk_new_null
    100.   {
    101.       return OPENSSL_sk_new((OPENSSL_sk_compfunc)NULL);
    102. > }
    103.   
    104.   OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc c)

crypto/x509/x509_lcl.h:142:1: return from a call to sk_BY_DIR_ENTRY_new_null
  140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
  141.   DEFINE_STACK_OF(BY_DIR_HASH)
  142. > DEFINE_STACK_OF(BY_DIR_ENTRY)
  143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;
  144.   DEFINE_STACK_OF(STACK_OF_X509_NAME_ENTRY)

crypto/x509/by_dir.c:181:22: Taking false branch
179.               if (ctx->dirs == NULL) {
180.                   ctx->dirs = sk_BY_DIR_ENTRY_new_null();
181.                   if (!ctx->dirs) {
                            ^
182.                       X509err(X509_F_ADD_CERT_DIR, ERR_R_MALLOC_FAILURE);
183.                       return 0;

crypto/x509/by_dir.c:186:13: 
184.                   }
185.               }
186. >             ent = OPENSSL_malloc(sizeof(*ent));
187.               if (ent == NULL)
188.                   return 0;

crypto/mem.c:170:1: start of procedure CRYPTO_malloc()
  168.   #endif
  169.   
  170. > void *CRYPTO_malloc(size_t num, const char *file, int line)
  171.   {
  172.       void *ret = NULL;

crypto/mem.c:172:5: 
  170.   void *CRYPTO_malloc(size_t num, const char *file, int line)
  171.   {
  172. >     void *ret = NULL;
  173.   
  174.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)

crypto/mem.c:174:9: Taking true branch
  172.       void *ret = NULL;
  173.   
  174.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                 ^
  175.           return malloc_impl(num, file, line);
  176.   

crypto/mem.c:174:32: Taking true branch
  172.       void *ret = NULL;
  173.   
  174.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                                        ^
  175.           return malloc_impl(num, file, line);
  176.   

crypto/mem.c:175:9: Skipping __function_pointer__(): unresolved function pointer
  173.   
  174.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
  175.           return malloc_impl(num, file, line);
                 ^
  176.   
  177.       if (num == 0)

crypto/mem.c:196:1: return from a call to CRYPTO_malloc
  194.   
  195.       return ret;
  196. > }
  197.   
  198.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/x509/by_dir.c:187:17: Taking false branch
185.               }
186.               ent = OPENSSL_malloc(sizeof(*ent));
187.               if (ent == NULL)
                       ^
188.                   return 0;
189.               ent->dir_type = type;

crypto/x509/by_dir.c:189:13: 
187.               if (ent == NULL)
188.                   return 0;
189. >             ent->dir_type = type;
190.               ent->hashes = sk_BY_DIR_HASH_new(by_dir_hash_cmp);
191.               ent->dir = OPENSSL_strndup(ss, len);

crypto/x509/by_dir.c:190:13: 
188.                   return 0;
189.               ent->dir_type = type;
190. >             ent->hashes = sk_BY_DIR_HASH_new(by_dir_hash_cmp);
191.               ent->dir = OPENSSL_strndup(ss, len);
192.               if (ent->dir == NULL || ent->hashes == NULL) {

crypto/x509/x509_lcl.h:141:1: start of procedure sk_BY_DIR_HASH_new()
  139.   typedef struct lookup_dir_hashes_st BY_DIR_HASH;
  140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
  141. > DEFINE_STACK_OF(BY_DIR_HASH)
  142.   DEFINE_STACK_OF(BY_DIR_ENTRY)
  143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;

crypto/x509/x509_lcl.h:141:1: return from a call to sk_BY_DIR_HASH_new
  139.   typedef struct lookup_dir_hashes_st BY_DIR_HASH;
  140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
  141. > DEFINE_STACK_OF(BY_DIR_HASH)
  142.   DEFINE_STACK_OF(BY_DIR_ENTRY)
  143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;

crypto/x509/by_dir.c:191:13: 
189.               ent->dir_type = type;
190.               ent->hashes = sk_BY_DIR_HASH_new(by_dir_hash_cmp);
191. >             ent->dir = OPENSSL_strndup(ss, len);
192.               if (ent->dir == NULL || ent->hashes == NULL) {
193.                   by_dir_entry_free(ent);

crypto/o_str.c:39:1: start of procedure CRYPTO_strndup()
  37.   }
  38.   
  39. > char *CRYPTO_strndup(const char *str, size_t s, const char* file, int line)
  40.   {
  41.       size_t maxlen;

crypto/o_str.c:44:9: Taking false branch
  42.       char *ret;
  43.   
  44.       if (str == NULL)
                ^
  45.           return NULL;
  46.   

crypto/o_str.c:47:5: 
  45.           return NULL;
  46.   
  47. >     maxlen = OPENSSL_strnlen(str, s);
  48.   
  49.       ret = CRYPTO_malloc(maxlen + 1, file, line);

crypto/o_str.c:72:1: start of procedure OPENSSL_strnlen()
    70.   }
    71.   
    72. > size_t OPENSSL_strnlen(const char *str, size_t maxlen)
    73.   {
    74.       const char *p;

crypto/o_str.c:76:10: 
    74.       const char *p;
    75.   
    76. >     for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ;
    77.   
    78.       return p - str;

crypto/o_str.c:76:19: Loop condition is true. Entering loop body
    74.       const char *p;
    75.   
    76.       for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ;
                            ^
    77.   
    78.       return p - str;

crypto/o_str.c:76:36: Loop condition is true. Entering loop body
    74.       const char *p;
    75.   
    76.       for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ;
                                             ^
    77.   
    78.       return p - str;

crypto/o_str.c:76:48: 
    74.       const char *p;
    75.   
    76. >     for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ;
    77.   
    78.       return p - str;

crypto/o_str.c:76:19: Loop condition is true. Entering loop body
    74.       const char *p;
    75.   
    76.       for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ;
                            ^
    77.   
    78.       return p - str;

crypto/o_str.c:76:36: Loop condition is false. Leaving loop
    74.       const char *p;
    75.   
    76.       for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ;
                                             ^
    77.   
    78.       return p - str;

crypto/o_str.c:78:5: 
    76.       for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ;
    77.   
    78. >     return p - str;
    79.   }
    80.   

crypto/o_str.c:79:1: return from a call to OPENSSL_strnlen
    77.   
    78.       return p - str;
    79. > }
    80.   
    81.   size_t OPENSSL_strlcpy(char *dst, const char *src, size_t size)

crypto/o_str.c:49:5: 
  47.       maxlen = OPENSSL_strnlen(str, s);
  48.   
  49. >     ret = CRYPTO_malloc(maxlen + 1, file, line);
  50.       if (ret) {
  51.           memcpy(ret, str, maxlen);

crypto/mem.c:170:1: start of procedure CRYPTO_malloc()
    168.   #endif
    169.   
    170. > void *CRYPTO_malloc(size_t num, const char *file, int line)
    171.   {
    172.       void *ret = NULL;

crypto/mem.c:172:5: 
    170.   void *CRYPTO_malloc(size_t num, const char *file, int line)
    171.   {
    172. >     void *ret = NULL;
    173.   
    174.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)

crypto/mem.c:174:9: Taking false branch
    172.       void *ret = NULL;
    173.   
    174.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                   ^
    175.           return malloc_impl(num, file, line);
    176.   

crypto/mem.c:177:9: Taking false branch
    175.           return malloc_impl(num, file, line);
    176.   
    177.       if (num == 0)
                   ^
    178.           return NULL;
    179.   

crypto/mem.c:181:5: 
    179.   
    180.       FAILTEST();
    181. >     allow_customize = 0;
    182.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
    183.       if (call_malloc_debug) {

crypto/mem.c:191:5: 
    189.       }
    190.   #else
    191. >     (void)(file); (void)(line);
    192.       ret = malloc(num);
    193.   #endif

crypto/mem.c:191:19: 
    189.       }
    190.   #else
    191. >     (void)(file); (void)(line);
    192.       ret = malloc(num);
    193.   #endif

crypto/mem.c:192:5: 
    190.   #else
    191.       (void)(file); (void)(line);
    192. >     ret = malloc(num);
    193.   #endif
    194.   

crypto/mem.c:195:5: 
    193.   #endif
    194.   
    195. >     return ret;
    196.   }
    197.   

crypto/mem.c:196:1: return from a call to CRYPTO_malloc
    194.   
    195.       return ret;
    196. > }
    197.   
    198.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/o_str.c:50:9: Taking true branch
  48.   
  49.       ret = CRYPTO_malloc(maxlen + 1, file, line);
  50.       if (ret) {
                ^
  51.           memcpy(ret, str, maxlen);
  52.           ret[maxlen] = '\0';

crypto/o_str.c:51:9: 
  49.       ret = CRYPTO_malloc(maxlen + 1, file, line);
  50.       if (ret) {
  51. >         memcpy(ret, str, maxlen);
  52.           ret[maxlen] = '\0';
  53.       }

crypto/o_str.c:52:9: 
  50.       if (ret) {
  51.           memcpy(ret, str, maxlen);
  52. >         ret[maxlen] = '\0';
  53.       }
  54.       return ret;

crypto/o_str.c:54:5: 
  52.           ret[maxlen] = '\0';
  53.       }
  54. >     return ret;
  55.   }
  56.   

crypto/o_str.c:55:1: return from a call to CRYPTO_strndup
  53.       }
  54.       return ret;
  55. > }
  56.   
  57.   void *CRYPTO_memdup(const void *data, size_t siz, const char* file, int line)

crypto/x509/by_dir.c:192:17: Taking false branch
190.               ent->hashes = sk_BY_DIR_HASH_new(by_dir_hash_cmp);
191.               ent->dir = OPENSSL_strndup(ss, len);
192.               if (ent->dir == NULL || ent->hashes == NULL) {
                       ^
193.                   by_dir_entry_free(ent);
194.                   return 0;

crypto/x509/by_dir.c:192:37: Taking true branch
190.               ent->hashes = sk_BY_DIR_HASH_new(by_dir_hash_cmp);
191.               ent->dir = OPENSSL_strndup(ss, len);
192.               if (ent->dir == NULL || ent->hashes == NULL) {
                                           ^
193.                   by_dir_entry_free(ent);
194.                   return 0;

crypto/x509/by_dir.c:193:17: 
191.               ent->dir = OPENSSL_strndup(ss, len);
192.               if (ent->dir == NULL || ent->hashes == NULL) {
193. >                 by_dir_entry_free(ent);
194.                   return 0;
195.               }

crypto/x509/by_dir.c:133:1: start of procedure by_dir_entry_free()
  131.   }
  132.   
  133. > static void by_dir_entry_free(BY_DIR_ENTRY *ent)
  134.   {
  135.       OPENSSL_free(ent->dir);

crypto/x509/by_dir.c:135:5: 
  133.   static void by_dir_entry_free(BY_DIR_ENTRY *ent)
  134.   {
  135. >     OPENSSL_free(ent->dir);
  136.       sk_BY_DIR_HASH_pop_free(ent->hashes, by_dir_hash_free);
  137.       OPENSSL_free(ent);

crypto/mem.c:265:1: start of procedure CRYPTO_free()
    263.   }
    264.   
    265. > void CRYPTO_free(void *str, const char *file, int line)
    266.   {
    267.       if (free_impl != NULL && free_impl != &CRYPTO_free) {

crypto/mem.c:267:9: Taking true branch
    265.   void CRYPTO_free(void *str, const char *file, int line)
    266.   {
    267.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
                   ^
    268.           free_impl(str, file, line);
    269.           return;

crypto/mem.c:267:30: Taking true branch
    265.   void CRYPTO_free(void *str, const char *file, int line)
    266.   {
    267.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
                                        ^
    268.           free_impl(str, file, line);
    269.           return;

crypto/mem.c:268:9: Skipping __function_pointer__(): unresolved function pointer
    266.   {
    267.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
    268.           free_impl(str, file, line);
                   ^
    269.           return;
    270.       }

crypto/mem.c:269:9: 
    267.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
    268.           free_impl(str, file, line);
    269. >         return;
    270.       }
    271.   

crypto/mem.c:283:1: return from a call to CRYPTO_free
    281.       free(str);
    282.   #endif
    283. > }
    284.   
    285.   void CRYPTO_clear_free(void *str, size_t num, const char *file, int line)

crypto/x509/by_dir.c:136:5: 
  134.   {
  135.       OPENSSL_free(ent->dir);
  136. >     sk_BY_DIR_HASH_pop_free(ent->hashes, by_dir_hash_free);
  137.       OPENSSL_free(ent);
  138.   }

crypto/x509/x509_lcl.h:141:1: start of procedure sk_BY_DIR_HASH_pop_free()
    139.   typedef struct lookup_dir_hashes_st BY_DIR_HASH;
    140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
    141. > DEFINE_STACK_OF(BY_DIR_HASH)
    142.   DEFINE_STACK_OF(BY_DIR_ENTRY)
    143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;

crypto/x509/x509_lcl.h:141:1: return from a call to sk_BY_DIR_HASH_pop_free
    139.   typedef struct lookup_dir_hashes_st BY_DIR_HASH;
    140.   typedef struct lookup_dir_entry_st BY_DIR_ENTRY;
    141. > DEFINE_STACK_OF(BY_DIR_HASH)
    142.   DEFINE_STACK_OF(BY_DIR_ENTRY)
    143.   typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY;

crypto/x509/by_dir.c:137:5: 
  135.       OPENSSL_free(ent->dir);
  136.       sk_BY_DIR_HASH_pop_free(ent->hashes, by_dir_hash_free);
  137. >     OPENSSL_free(ent);
  138.   }
  139.   

crypto/mem.c:265:1: start of procedure CRYPTO_free()
    263.   }
    264.   
    265. > void CRYPTO_free(void *str, const char *file, int line)
    266.   {
    267.       if (free_impl != NULL && free_impl != &CRYPTO_free) {

crypto/mem.c:267:9: Taking false branch
    265.   void CRYPTO_free(void *str, const char *file, int line)
    266.   {
    267.       if (free_impl != NULL && free_impl != &CRYPTO_free) {
                   ^
    268.           free_impl(str, file, line);
    269.           return;

crypto/mem.c:281:5: 
    279.       }
    280.   #else
    281. >     free(str);
    282.   #endif
    283.   }

crypto/mem.c:283:1: return from a call to CRYPTO_free
    281.       free(str);
    282.   #endif
    283. > }
    284.   
    285.   void CRYPTO_clear_free(void *str, size_t num, const char *file, int line)

crypto/x509/by_dir.c:138:1: return from a call to by_dir_entry_free
  136.       sk_BY_DIR_HASH_pop_free(ent->hashes, by_dir_hash_free);
  137.       OPENSSL_free(ent);
  138. > }
  139.   
  140.   static void free_dir(X509_LOOKUP *lu)
