apps/apps.c:1622: error: MEMORY_LEAK
  memory dynamically allocated by call to `TXT_DB_create_index()` at line 1612, column 10 is not reachable after line 1622, column 13.
Showing all 141 steps of the trace


apps/apps.c:1610:1: start of procedure index_index()
1608.   }
1609.   
1610. > int index_index(CA_DB *db)
1611.   {
1612.       if (!TXT_DB_create_index(db->db, DB_serial, NULL,

apps/apps.c:1612:10: 
1610.   int index_index(CA_DB *db)
1611.   {
1612. >     if (!TXT_DB_create_index(db->db, DB_serial, NULL,
1613.                                LHASH_HASH_FN(index_serial),
1614.                                LHASH_COMP_FN(index_serial))) {

crypto/txt_db/txt_db.c:196:1: start of procedure TXT_DB_create_index()
  194.   }
  195.   
  196. > int TXT_DB_create_index(TXT_DB *db, int field, int (*qual) (OPENSSL_STRING *),
  197.                           LHASH_HASH_FN_TYPE hash, LHASH_COMP_FN_TYPE cmp)
  198.   {

crypto/txt_db/txt_db.c:203:9: Taking false branch
  201.       int i, n;
  202.   
  203.       if (field >= db->num_fields) {
                 ^
  204.           db->error = DB_ERROR_INDEX_OUT_OF_RANGE;
  205.           return (0);

crypto/txt_db/txt_db.c:208:9: 
  206.       }
  207.       /* FIXME: we lose type checking at this point */
  208. >     if ((idx = (LHASH_OF(OPENSSL_STRING) *)lh_new(hash, cmp)) == NULL) {
  209.           db->error = DB_ERROR_MALLOC;
  210.           return (0);

crypto/lhash/lhash.c:113:1: start of procedure lh_new()
    111.   static LHASH_NODE **getrn(_LHASH *lh, const void *data, unsigned long *rhash);
    112.   
    113. > _LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c)
    114.   {
    115.       _LHASH *ret;

crypto/lhash/lhash.c:117:9: 
    115.       _LHASH *ret;
    116.   
    117. >     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
    118.           goto err0;
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)

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

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

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
        118.   }
        119.   
        120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
        121.   {
        122.       void *ret = NULL;

crypto/mem.c:122:5: 
        120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
        121.   {
        122. >     void *ret = NULL;
        123.   
        124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
        122.       void *ret = NULL;
        123.   
        124.       if (num <= 0)
                       ^
        125.           return NULL;
        126.   

crypto/mem.c:127:5: 
        125.           return NULL;
        126.   
        127. >     allow_customize = 0;
        128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
        129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
        135.       }
        136.   #else
        137. >     (void)file;
        138.       (void)line;
        139.       ret = malloc(num);

crypto/mem.c:138:5: 
        136.   #else
        137.       (void)file;
        138. >     (void)line;
        139.       ret = malloc(num);
        140.   #endif

crypto/mem.c:139:5: 
        137.       (void)file;
        138.       (void)line;
        139. >     ret = malloc(num);
        140.   #endif
        141.   

crypto/mem.c:154:5: 
        152.   #endif
        153.   
        154. >     return ret;
        155.   }
        156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
        153.   
        154.       return ret;
        155. > }
        156.   
        157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:161:9: Taking true branch
      159.       void *ret = CRYPTO_malloc(num, file, line);
      160.   
      161.       if (ret != NULL)
                     ^
      162.           memset(ret, 0, num);
      163.       return ret;

crypto/mem.c:162:9: 
      160.   
      161.       if (ret != NULL)
      162. >         memset(ret, 0, num);
      163.       return ret;
      164.   }

crypto/mem.c:163:5: 
      161.       if (ret != NULL)
      162.           memset(ret, 0, num);
      163. >     return ret;
      164.   }
      165.   

crypto/mem.c:164:1: return from a call to CRYPTO_zalloc
      162.           memset(ret, 0, num);
      163.       return ret;
      164. > }
      165.   
      166.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/lhash/lhash.c:117:9: Taking false branch
    115.       _LHASH *ret;
    116.   
    117.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
                   ^
    118.           goto err0;
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)

crypto/lhash/lhash.c:119:9: 
    117.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
    118.           goto err0;
    119. >     if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);

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

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

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
        118.   }
        119.   
        120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
        121.   {
        122.       void *ret = NULL;

crypto/mem.c:122:5: 
        120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
        121.   {
        122. >     void *ret = NULL;
        123.   
        124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
        122.       void *ret = NULL;
        123.   
        124.       if (num <= 0)
                       ^
        125.           return NULL;
        126.   

crypto/mem.c:127:5: 
        125.           return NULL;
        126.   
        127. >     allow_customize = 0;
        128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
        129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
        135.       }
        136.   #else
        137. >     (void)file;
        138.       (void)line;
        139.       ret = malloc(num);

crypto/mem.c:138:5: 
        136.   #else
        137.       (void)file;
        138. >     (void)line;
        139.       ret = malloc(num);
        140.   #endif

crypto/mem.c:139:5: 
        137.       (void)file;
        138.       (void)line;
        139. >     ret = malloc(num);
        140.   #endif
        141.   

crypto/mem.c:154:5: 
        152.   #endif
        153.   
        154. >     return ret;
        155.   }
        156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
        153.   
        154.       return ret;
        155. > }
        156.   
        157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:161:9: Taking true branch
      159.       void *ret = CRYPTO_malloc(num, file, line);
      160.   
      161.       if (ret != NULL)
                     ^
      162.           memset(ret, 0, num);
      163.       return ret;

crypto/mem.c:162:9: 
      160.   
      161.       if (ret != NULL)
      162. >         memset(ret, 0, num);
      163.       return ret;
      164.   }

crypto/mem.c:163:5: 
      161.       if (ret != NULL)
      162.           memset(ret, 0, num);
      163. >     return ret;
      164.   }
      165.   

crypto/mem.c:164:1: return from a call to CRYPTO_zalloc
      162.           memset(ret, 0, num);
      163.       return ret;
      164. > }
      165.   
      166.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/lhash/lhash.c:119:9: Taking false branch
    117.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
    118.           goto err0;
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
                   ^
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);

crypto/lhash/lhash.c:121:19: Condition is false
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
                             ^
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;

crypto/lhash/lhash.c:121:18: 
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
    120.           goto err1;
    121. >     ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;

crypto/lhash/lhash.c:121:5: 
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
    120.           goto err1;
    121. >     ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;

crypto/lhash/lhash.c:122:19: Condition is false
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
                             ^
    123.       ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;

crypto/lhash/lhash.c:122:18: 
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122. >     ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;

crypto/lhash/lhash.c:122:5: 
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122. >     ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;

crypto/lhash/lhash.c:123:5: 
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123. >     ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;
    125.       ret->pmax = MIN_NODES / 2;

crypto/lhash/lhash.c:124:5: 
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;
    124. >     ret->num_alloc_nodes = MIN_NODES;
    125.       ret->pmax = MIN_NODES / 2;
    126.       ret->up_load = UP_LOAD;

crypto/lhash/lhash.c:125:5: 
    123.       ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;
    125. >     ret->pmax = MIN_NODES / 2;
    126.       ret->up_load = UP_LOAD;
    127.       ret->down_load = DOWN_LOAD;

crypto/lhash/lhash.c:126:5: 
    124.       ret->num_alloc_nodes = MIN_NODES;
    125.       ret->pmax = MIN_NODES / 2;
    126. >     ret->up_load = UP_LOAD;
    127.       ret->down_load = DOWN_LOAD;
    128.       return (ret);

crypto/lhash/lhash.c:127:5: 
    125.       ret->pmax = MIN_NODES / 2;
    126.       ret->up_load = UP_LOAD;
    127. >     ret->down_load = DOWN_LOAD;
    128.       return (ret);
    129.   

crypto/lhash/lhash.c:128:5: 
    126.       ret->up_load = UP_LOAD;
    127.       ret->down_load = DOWN_LOAD;
    128. >     return (ret);
    129.   
    130.    err1:

crypto/lhash/lhash.c:134:1: return from a call to lh_new
    132.    err0:
    133.       return (NULL);
    134. > }
    135.   
    136.   void lh_free(_LHASH *lh)

crypto/txt_db/txt_db.c:208:9: Taking false branch
  206.       }
  207.       /* FIXME: we lose type checking at this point */
  208.       if ((idx = (LHASH_OF(OPENSSL_STRING) *)lh_new(hash, cmp)) == NULL) {
                 ^
  209.           db->error = DB_ERROR_MALLOC;
  210.           return (0);

crypto/txt_db/txt_db.c:212:5: 
  210.           return (0);
  211.       }
  212. >     n = sk_OPENSSL_PSTRING_num(db->data);
  213.       for (i = 0; i < n; i++) {
  214.           r = sk_OPENSSL_PSTRING_value(db->data, i);

include/openssl/txt_db.h:80:1: start of procedure sk_OPENSSL_PSTRING_num()
    78.   
    79.   typedef OPENSSL_STRING *OPENSSL_PSTRING;
    80. > DEFINE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING)
    81.   
    82.   typedef struct txt_db_st {

crypto/stack/stack.c:317:1: start of procedure sk_num()
      315.   }
      316.   
      317. > int sk_num(const _STACK *st)
      318.   {
      319.       if (st == NULL)

crypto/stack/stack.c:319:9: Taking true branch
      317.   int sk_num(const _STACK *st)
      318.   {
      319.       if (st == NULL)
                     ^
      320.           return -1;
      321.       return st->num;

crypto/stack/stack.c:320:9: 
      318.   {
      319.       if (st == NULL)
      320. >         return -1;
      321.       return st->num;
      322.   }

crypto/stack/stack.c:322:1: return from a call to sk_num
      320.           return -1;
      321.       return st->num;
      322. > }
      323.   
      324.   void *sk_value(const _STACK *st, int i)

include/openssl/txt_db.h:80:1: return from a call to sk_OPENSSL_PSTRING_num
    78.   
    79.   typedef OPENSSL_STRING *OPENSSL_PSTRING;
    80. > DEFINE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING)
    81.   
    82.   typedef struct txt_db_st {

crypto/txt_db/txt_db.c:213:10: 
  211.       }
  212.       n = sk_OPENSSL_PSTRING_num(db->data);
  213. >     for (i = 0; i < n; i++) {
  214.           r = sk_OPENSSL_PSTRING_value(db->data, i);
  215.           if ((qual != NULL) && (qual(r) == 0))

crypto/txt_db/txt_db.c:213:17: Loop condition is false. Leaving loop
  211.       }
  212.       n = sk_OPENSSL_PSTRING_num(db->data);
  213.       for (i = 0; i < n; i++) {
                         ^
  214.           r = sk_OPENSSL_PSTRING_value(db->data, i);
  215.           if ((qual != NULL) && (qual(r) == 0))

crypto/txt_db/txt_db.c:225:5: 
  223.           }
  224.       }
  225. >     lh_OPENSSL_STRING_free(db->index[field]);
  226.       db->index[field] = idx;
  227.       db->qual[field] = qual;

include/openssl/lhash.h:270:1: start of procedure lh_OPENSSL_STRING_free()
    268.     lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg))
    269.   
    270. > DEFINE_LHASH_OF(OPENSSL_STRING);
    271.   DEFINE_LHASH_OF(OPENSSL_CSTRING);
    272.   

include/openssl/lhash.h:270:1: return from a call to lh_OPENSSL_STRING_free
    268.     lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg))
    269.   
    270. > DEFINE_LHASH_OF(OPENSSL_STRING);
    271.   DEFINE_LHASH_OF(OPENSSL_CSTRING);
    272.   

crypto/txt_db/txt_db.c:226:5: 
  224.       }
  225.       lh_OPENSSL_STRING_free(db->index[field]);
  226. >     db->index[field] = idx;
  227.       db->qual[field] = qual;
  228.       return (1);

crypto/txt_db/txt_db.c:227:5: 
  225.       lh_OPENSSL_STRING_free(db->index[field]);
  226.       db->index[field] = idx;
  227. >     db->qual[field] = qual;
  228.       return (1);
  229.   }

crypto/txt_db/txt_db.c:228:5: 
  226.       db->index[field] = idx;
  227.       db->qual[field] = qual;
  228. >     return (1);
  229.   }
  230.   

crypto/txt_db/txt_db.c:229:1: return from a call to TXT_DB_create_index
  227.       db->qual[field] = qual;
  228.       return (1);
  229. > }
  230.   
  231.   long TXT_DB_write(BIO *out, TXT_DB *db)

apps/apps.c:1612:10: Taking false branch
1610.   int index_index(CA_DB *db)
1611.   {
1612.       if (!TXT_DB_create_index(db->db, DB_serial, NULL,
                 ^
1613.                                LHASH_HASH_FN(index_serial),
1614.                                LHASH_COMP_FN(index_serial))) {

apps/apps.c:1621:9: Taking true branch
1619.       }
1620.   
1621.       if (db->attributes.unique_subject
                ^
1622.           && !TXT_DB_create_index(db->db, DB_name, index_name_qual,
1623.                                   LHASH_HASH_FN(index_name),

apps/apps.c:1622:13: 
1620.   
1621.       if (db->attributes.unique_subject
1622. >         && !TXT_DB_create_index(db->db, DB_name, index_name_qual,
1623.                                   LHASH_HASH_FN(index_name),
1624.                                   LHASH_COMP_FN(index_name))) {

crypto/txt_db/txt_db.c:196:1: start of procedure TXT_DB_create_index()
  194.   }
  195.   
  196. > int TXT_DB_create_index(TXT_DB *db, int field, int (*qual) (OPENSSL_STRING *),
  197.                           LHASH_HASH_FN_TYPE hash, LHASH_COMP_FN_TYPE cmp)
  198.   {

crypto/txt_db/txt_db.c:203:9: Taking false branch
  201.       int i, n;
  202.   
  203.       if (field >= db->num_fields) {
                 ^
  204.           db->error = DB_ERROR_INDEX_OUT_OF_RANGE;
  205.           return (0);

crypto/txt_db/txt_db.c:208:9: 
  206.       }
  207.       /* FIXME: we lose type checking at this point */
  208. >     if ((idx = (LHASH_OF(OPENSSL_STRING) *)lh_new(hash, cmp)) == NULL) {
  209.           db->error = DB_ERROR_MALLOC;
  210.           return (0);

crypto/lhash/lhash.c:113:1: start of procedure lh_new()
    111.   static LHASH_NODE **getrn(_LHASH *lh, const void *data, unsigned long *rhash);
    112.   
    113. > _LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c)
    114.   {
    115.       _LHASH *ret;

crypto/lhash/lhash.c:117:9: 
    115.       _LHASH *ret;
    116.   
    117. >     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
    118.           goto err0;
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)

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

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

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
        118.   }
        119.   
        120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
        121.   {
        122.       void *ret = NULL;

crypto/mem.c:122:5: 
        120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
        121.   {
        122. >     void *ret = NULL;
        123.   
        124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
        122.       void *ret = NULL;
        123.   
        124.       if (num <= 0)
                       ^
        125.           return NULL;
        126.   

crypto/mem.c:127:5: 
        125.           return NULL;
        126.   
        127. >     allow_customize = 0;
        128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
        129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
        135.       }
        136.   #else
        137. >     (void)file;
        138.       (void)line;
        139.       ret = malloc(num);

crypto/mem.c:138:5: 
        136.   #else
        137.       (void)file;
        138. >     (void)line;
        139.       ret = malloc(num);
        140.   #endif

crypto/mem.c:139:5: 
        137.       (void)file;
        138.       (void)line;
        139. >     ret = malloc(num);
        140.   #endif
        141.   

crypto/mem.c:154:5: 
        152.   #endif
        153.   
        154. >     return ret;
        155.   }
        156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
        153.   
        154.       return ret;
        155. > }
        156.   
        157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:161:9: Taking true branch
      159.       void *ret = CRYPTO_malloc(num, file, line);
      160.   
      161.       if (ret != NULL)
                     ^
      162.           memset(ret, 0, num);
      163.       return ret;

crypto/mem.c:162:9: 
      160.   
      161.       if (ret != NULL)
      162. >         memset(ret, 0, num);
      163.       return ret;
      164.   }

crypto/mem.c:163:5: 
      161.       if (ret != NULL)
      162.           memset(ret, 0, num);
      163. >     return ret;
      164.   }
      165.   

crypto/mem.c:164:1: return from a call to CRYPTO_zalloc
      162.           memset(ret, 0, num);
      163.       return ret;
      164. > }
      165.   
      166.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/lhash/lhash.c:117:9: Taking false branch
    115.       _LHASH *ret;
    116.   
    117.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
                   ^
    118.           goto err0;
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)

crypto/lhash/lhash.c:119:9: 
    117.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
    118.           goto err0;
    119. >     if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);

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

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

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
        118.   }
        119.   
        120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
        121.   {
        122.       void *ret = NULL;

crypto/mem.c:122:5: 
        120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
        121.   {
        122. >     void *ret = NULL;
        123.   
        124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
        122.       void *ret = NULL;
        123.   
        124.       if (num <= 0)
                       ^
        125.           return NULL;
        126.   

crypto/mem.c:127:5: 
        125.           return NULL;
        126.   
        127. >     allow_customize = 0;
        128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
        129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
        135.       }
        136.   #else
        137. >     (void)file;
        138.       (void)line;
        139.       ret = malloc(num);

crypto/mem.c:138:5: 
        136.   #else
        137.       (void)file;
        138. >     (void)line;
        139.       ret = malloc(num);
        140.   #endif

crypto/mem.c:139:5: 
        137.       (void)file;
        138.       (void)line;
        139. >     ret = malloc(num);
        140.   #endif
        141.   

crypto/mem.c:154:5: 
        152.   #endif
        153.   
        154. >     return ret;
        155.   }
        156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
        153.   
        154.       return ret;
        155. > }
        156.   
        157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:161:9: Taking true branch
      159.       void *ret = CRYPTO_malloc(num, file, line);
      160.   
      161.       if (ret != NULL)
                     ^
      162.           memset(ret, 0, num);
      163.       return ret;

crypto/mem.c:162:9: 
      160.   
      161.       if (ret != NULL)
      162. >         memset(ret, 0, num);
      163.       return ret;
      164.   }

crypto/mem.c:163:5: 
      161.       if (ret != NULL)
      162.           memset(ret, 0, num);
      163. >     return ret;
      164.   }
      165.   

crypto/mem.c:164:1: return from a call to CRYPTO_zalloc
      162.           memset(ret, 0, num);
      163.       return ret;
      164. > }
      165.   
      166.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/lhash/lhash.c:119:9: Taking false branch
    117.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
    118.           goto err0;
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
                   ^
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);

crypto/lhash/lhash.c:121:19: Condition is false
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
                             ^
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;

crypto/lhash/lhash.c:121:18: 
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
    120.           goto err1;
    121. >     ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;

crypto/lhash/lhash.c:121:5: 
    119.       if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
    120.           goto err1;
    121. >     ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;

crypto/lhash/lhash.c:122:19: Condition is false
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
                             ^
    123.       ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;

crypto/lhash/lhash.c:122:18: 
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122. >     ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;

crypto/lhash/lhash.c:122:5: 
    120.           goto err1;
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122. >     ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;

crypto/lhash/lhash.c:123:5: 
    121.       ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123. >     ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;
    125.       ret->pmax = MIN_NODES / 2;

crypto/lhash/lhash.c:124:5: 
    122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
    123.       ret->num_nodes = MIN_NODES / 2;
    124. >     ret->num_alloc_nodes = MIN_NODES;
    125.       ret->pmax = MIN_NODES / 2;
    126.       ret->up_load = UP_LOAD;

crypto/lhash/lhash.c:125:5: 
    123.       ret->num_nodes = MIN_NODES / 2;
    124.       ret->num_alloc_nodes = MIN_NODES;
    125. >     ret->pmax = MIN_NODES / 2;
    126.       ret->up_load = UP_LOAD;
    127.       ret->down_load = DOWN_LOAD;

crypto/lhash/lhash.c:126:5: 
    124.       ret->num_alloc_nodes = MIN_NODES;
    125.       ret->pmax = MIN_NODES / 2;
    126. >     ret->up_load = UP_LOAD;
    127.       ret->down_load = DOWN_LOAD;
    128.       return (ret);

crypto/lhash/lhash.c:127:5: 
    125.       ret->pmax = MIN_NODES / 2;
    126.       ret->up_load = UP_LOAD;
    127. >     ret->down_load = DOWN_LOAD;
    128.       return (ret);
    129.   

crypto/lhash/lhash.c:128:5: 
    126.       ret->up_load = UP_LOAD;
    127.       ret->down_load = DOWN_LOAD;
    128. >     return (ret);
    129.   
    130.    err1:

crypto/lhash/lhash.c:134:1: return from a call to lh_new
    132.    err0:
    133.       return (NULL);
    134. > }
    135.   
    136.   void lh_free(_LHASH *lh)

crypto/txt_db/txt_db.c:208:9: Taking false branch
  206.       }
  207.       /* FIXME: we lose type checking at this point */
  208.       if ((idx = (LHASH_OF(OPENSSL_STRING) *)lh_new(hash, cmp)) == NULL) {
                 ^
  209.           db->error = DB_ERROR_MALLOC;
  210.           return (0);

crypto/txt_db/txt_db.c:212:5: 
  210.           return (0);
  211.       }
  212. >     n = sk_OPENSSL_PSTRING_num(db->data);
  213.       for (i = 0; i < n; i++) {
  214.           r = sk_OPENSSL_PSTRING_value(db->data, i);

include/openssl/txt_db.h:80:1: start of procedure sk_OPENSSL_PSTRING_num()
    78.   
    79.   typedef OPENSSL_STRING *OPENSSL_PSTRING;
    80. > DEFINE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING)
    81.   
    82.   typedef struct txt_db_st {

crypto/stack/stack.c:317:1: start of procedure sk_num()
      315.   }
      316.   
      317. > int sk_num(const _STACK *st)
      318.   {
      319.       if (st == NULL)

crypto/stack/stack.c:319:9: Taking true branch
      317.   int sk_num(const _STACK *st)
      318.   {
      319.       if (st == NULL)
                     ^
      320.           return -1;
      321.       return st->num;

crypto/stack/stack.c:320:9: 
      318.   {
      319.       if (st == NULL)
      320. >         return -1;
      321.       return st->num;
      322.   }

crypto/stack/stack.c:322:1: return from a call to sk_num
      320.           return -1;
      321.       return st->num;
      322. > }
      323.   
      324.   void *sk_value(const _STACK *st, int i)

include/openssl/txt_db.h:80:1: return from a call to sk_OPENSSL_PSTRING_num
    78.   
    79.   typedef OPENSSL_STRING *OPENSSL_PSTRING;
    80. > DEFINE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING)
    81.   
    82.   typedef struct txt_db_st {

crypto/txt_db/txt_db.c:213:10: 
  211.       }
  212.       n = sk_OPENSSL_PSTRING_num(db->data);
  213. >     for (i = 0; i < n; i++) {
  214.           r = sk_OPENSSL_PSTRING_value(db->data, i);
  215.           if ((qual != NULL) && (qual(r) == 0))

crypto/txt_db/txt_db.c:213:17: Loop condition is false. Leaving loop
  211.       }
  212.       n = sk_OPENSSL_PSTRING_num(db->data);
  213.       for (i = 0; i < n; i++) {
                         ^
  214.           r = sk_OPENSSL_PSTRING_value(db->data, i);
  215.           if ((qual != NULL) && (qual(r) == 0))

crypto/txt_db/txt_db.c:225:5: 
  223.           }
  224.       }
  225. >     lh_OPENSSL_STRING_free(db->index[field]);
  226.       db->index[field] = idx;
  227.       db->qual[field] = qual;

include/openssl/lhash.h:270:1: start of procedure lh_OPENSSL_STRING_free()
    268.     lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg))
    269.   
    270. > DEFINE_LHASH_OF(OPENSSL_STRING);
    271.   DEFINE_LHASH_OF(OPENSSL_CSTRING);
    272.   

include/openssl/lhash.h:270:1: return from a call to lh_OPENSSL_STRING_free
    268.     lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg))
    269.   
    270. > DEFINE_LHASH_OF(OPENSSL_STRING);
    271.   DEFINE_LHASH_OF(OPENSSL_CSTRING);
    272.   

crypto/txt_db/txt_db.c:226:5: 
  224.       }
  225.       lh_OPENSSL_STRING_free(db->index[field]);
  226. >     db->index[field] = idx;
  227.       db->qual[field] = qual;
  228.       return (1);

crypto/txt_db/txt_db.c:227:5: 
  225.       lh_OPENSSL_STRING_free(db->index[field]);
  226.       db->index[field] = idx;
  227. >     db->qual[field] = qual;
  228.       return (1);
  229.   }

crypto/txt_db/txt_db.c:228:5: 
  226.       db->index[field] = idx;
  227.       db->qual[field] = qual;
  228. >     return (1);
  229.   }
  230.   

crypto/txt_db/txt_db.c:229:1: return from a call to TXT_DB_create_index
  227.       db->qual[field] = qual;
  228.       return (1);
  229. > }
  230.   
  231.   long TXT_DB_write(BIO *out, TXT_DB *db)
