ssl/ssl_lib.c:2379: error: MEMORY_LEAK
  memory dynamically allocated by call to `CRYPTO_zalloc()` at line 2278, column 11 is not reachable after line 2379, column 5.
Showing all 138 steps of the trace


ssl/ssl_lib.c:2257:1: start of procedure SSL_CTX_new()
2255.    */
2256.   
2257. > SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
2258.   {
2259.       SSL_CTX *ret = NULL;

ssl/ssl_lib.c:2259:5: 
2257.   SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
2258.   {
2259. >     SSL_CTX *ret = NULL;
2260.   
2261.       if (meth == NULL) {

ssl/ssl_lib.c:2261:9: Taking false branch
2259.       SSL_CTX *ret = NULL;
2260.   
2261.       if (meth == NULL) {
                ^
2262.           SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_NULL_SSL_METHOD_PASSED);
2263.           return (NULL);

ssl/ssl_lib.c:2266:10: 
2264.       }
2265.   
2266. >     if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
2267.           return NULL;
2268.   

ssl/ssl_init.c:303:1: start of procedure OPENSSL_init_ssl()
  301.    * i.e. passing a non-null settings value is assumed to be single-threaded.
  302.    */
  303. > int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
  304.   {
  305.       static int stoperrset = 0;

ssl/ssl_init.c:305:5: 
  303.   int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
  304.   {
  305. >     static int stoperrset = 0;
  306.   
  307.       if (stopped) {

ssl/ssl_init.c:307:9: Taking false branch
  305.       static int stoperrset = 0;
  306.   
  307.       if (stopped) {
                 ^
  308.           if (!stoperrset) {
  309.               /*

ssl/ssl_init.c:320:10: Taking false branch
  318.       }
  319.   
  320.       if (!OPENSSL_init_crypto(opts | OPENSSL_INIT_ADD_ALL_CIPHERS
                  ^
  321.                                | OPENSSL_INIT_ADD_ALL_DIGESTS, settings))
  322.           return 0;

ssl/ssl_init.c:324:5: 
  322.           return 0;
  323.   
  324. >     ossl_init_once_run(&ssl_base, ossl_init_ssl_base);
  325.   
  326.       if (opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS)

ssl/ssl_init.c:138:1: start of procedure ossl_init_once_run()
    136.   # define OPENSSL_INIT_ONCE_STATIC_INIT          PTHREAD_ONCE_INIT
    137.   
    138. > static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
    139.   {
    140.       pthread_once(once, init);

ssl/ssl_init.c:140:5: Skipping pthread_once(): method has no implementation
    138.   static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
    139.   {
    140.       pthread_once(once, init);
               ^
    141.   }
    142.   #endif

ssl/ssl_init.c:141:1: return from a call to ossl_init_once_run
    139.   {
    140.       pthread_once(once, init);
    141. > }
    142.   #endif
    143.   

ssl/ssl_init.c:326:9: Taking false branch
  324.       ossl_init_once_run(&ssl_base, ossl_init_ssl_base);
  325.   
  326.       if (opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS)
                 ^
  327.           ossl_init_once_run(&ssl_strings, ossl_init_no_load_ssl_strings);
  328.   

ssl/ssl_init.c:329:9: Taking true branch
  327.           ossl_init_once_run(&ssl_strings, ossl_init_no_load_ssl_strings);
  328.   
  329.       if (opts & OPENSSL_INIT_LOAD_SSL_STRINGS)
                 ^
  330.           ossl_init_once_run(&ssl_strings, ossl_init_load_ssl_strings);
  331.   

ssl/ssl_init.c:330:9: 
  328.   
  329.       if (opts & OPENSSL_INIT_LOAD_SSL_STRINGS)
  330. >         ossl_init_once_run(&ssl_strings, ossl_init_load_ssl_strings);
  331.   
  332.       return 1;

ssl/ssl_init.c:138:1: start of procedure ossl_init_once_run()
    136.   # define OPENSSL_INIT_ONCE_STATIC_INIT          PTHREAD_ONCE_INIT
    137.   
    138. > static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
    139.   {
    140.       pthread_once(once, init);

ssl/ssl_init.c:140:5: Skipping pthread_once(): method has no implementation
    138.   static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
    139.   {
    140.       pthread_once(once, init);
               ^
    141.   }
    142.   #endif

ssl/ssl_init.c:141:1: return from a call to ossl_init_once_run
    139.   {
    140.       pthread_once(once, init);
    141. > }
    142.   #endif
    143.   

ssl/ssl_init.c:332:5: 
  330.           ossl_init_once_run(&ssl_strings, ossl_init_load_ssl_strings);
  331.   
  332. >     return 1;
  333.   }
  334.   

ssl/ssl_init.c:333:1: return from a call to OPENSSL_init_ssl
  331.   
  332.       return 1;
  333. > }
  334.   

ssl/ssl_lib.c:2266:10: Taking false branch
2264.       }
2265.   
2266.       if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
                 ^
2267.           return NULL;
2268.   

ssl/ssl_lib.c:2269:9: 
2267.           return NULL;
2268.   
2269. >     if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
2270.           SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE);
2271.           return NULL;

crypto/o_fips.c:64:1: start of procedure FIPS_mode()
  62.   #endif
  63.   
  64. > int FIPS_mode(void)
  65.   {
  66.   #ifdef OPENSSL_FIPS

crypto/o_fips.c:69:5: 
  67.       return FIPS_module_mode();
  68.   #else
  69. >     return 0;
  70.   #endif
  71.   }

crypto/o_fips.c:71:1: return from a call to FIPS_mode
  69.       return 0;
  70.   #endif
  71. > }
  72.   
  73.   int FIPS_mode_set(int r)

ssl/ssl_lib.c:2269:9: Taking false branch
2267.           return NULL;
2268.   
2269.       if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
                ^
2270.           SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE);
2271.           return NULL;

ssl/ssl_lib.c:2274:9: Taking false branch
2272.       }
2273.   
2274.       if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
                ^
2275.           SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
2276.           goto err;

ssl/ssl_lib.c:2278:5: 
2276.           goto err;
2277.       }
2278. >     ret = OPENSSL_zalloc(sizeof(*ret));
2279.       if (ret == NULL)
2280.           goto err;

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

crypto/mem.c:158:5: 
  156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
  157.   {
  158. >     void *ret = CRYPTO_malloc(num, file, line);
  159.   
  160.       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/mem.c:160:9: Taking true branch
  158.       void *ret = CRYPTO_malloc(num, file, line);
  159.   
  160.       if (ret != NULL)
                 ^
  161.           memset(ret, 0, num);
  162.       return ret;

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

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

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

ssl/ssl_lib.c:2279:9: Taking false branch
2277.       }
2278.       ret = OPENSSL_zalloc(sizeof(*ret));
2279.       if (ret == NULL)
                ^
2280.           goto err;
2281.   

ssl/ssl_lib.c:2282:5: 
2280.           goto err;
2281.   
2282. >     ret->method = meth;
2283.       ret->min_proto_version = 0;
2284.       ret->max_proto_version = 0;

ssl/ssl_lib.c:2283:5: 
2281.   
2282.       ret->method = meth;
2283. >     ret->min_proto_version = 0;
2284.       ret->max_proto_version = 0;
2285.       ret->session_cache_mode = SSL_SESS_CACHE_SERVER;

ssl/ssl_lib.c:2284:5: 
2282.       ret->method = meth;
2283.       ret->min_proto_version = 0;
2284. >     ret->max_proto_version = 0;
2285.       ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
2286.       ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;

ssl/ssl_lib.c:2285:5: 
2283.       ret->min_proto_version = 0;
2284.       ret->max_proto_version = 0;
2285. >     ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
2286.       ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
2287.       /* We take the system default. */

ssl/ssl_lib.c:2286:5: 
2284.       ret->max_proto_version = 0;
2285.       ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
2286. >     ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
2287.       /* We take the system default. */
2288.       ret->session_timeout = meth->get_timeout();

ssl/ssl_lib.c:2288:5: Skipping __function_pointer__(): unresolved function pointer
2286.       ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
2287.       /* We take the system default. */
2288.       ret->session_timeout = meth->get_timeout();
            ^
2289.       ret->references = 1;
2290.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;

ssl/ssl_lib.c:2289:5: 
2287.       /* We take the system default. */
2288.       ret->session_timeout = meth->get_timeout();
2289. >     ret->references = 1;
2290.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2291.       ret->verify_mode = SSL_VERIFY_NONE;

ssl/ssl_lib.c:2290:5: 
2288.       ret->session_timeout = meth->get_timeout();
2289.       ret->references = 1;
2290. >     ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2291.       ret->verify_mode = SSL_VERIFY_NONE;
2292.       if ((ret->cert = ssl_cert_new()) == NULL)

ssl/ssl_lib.c:2291:5: 
2289.       ret->references = 1;
2290.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2291. >     ret->verify_mode = SSL_VERIFY_NONE;
2292.       if ((ret->cert = ssl_cert_new()) == NULL)
2293.           goto err;

ssl/ssl_lib.c:2292:9: 
2290.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2291.       ret->verify_mode = SSL_VERIFY_NONE;
2292. >     if ((ret->cert = ssl_cert_new()) == NULL)
2293.           goto err;
2294.   

ssl/ssl_cert.c:165:1: start of procedure ssl_cert_new()
  163.   }
  164.   
  165. > CERT *ssl_cert_new(void)
  166.   {
  167.       CERT *ret = OPENSSL_zalloc(sizeof(*ret));

ssl/ssl_cert.c:167:5: 
  165.   CERT *ssl_cert_new(void)
  166.   {
  167. >     CERT *ret = OPENSSL_zalloc(sizeof(*ret));
  168.   
  169.       if (ret == NULL) {

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

crypto/mem.c:158:5: 
    156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
    157.   {
    158. >     void *ret = CRYPTO_malloc(num, file, line);
    159.   
    160.       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/mem.c:160:9: Taking true branch
    158.       void *ret = CRYPTO_malloc(num, file, line);
    159.   
    160.       if (ret != NULL)
                   ^
    161.           memset(ret, 0, num);
    162.       return ret;

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

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

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

ssl/ssl_cert.c:169:9: Taking false branch
  167.       CERT *ret = OPENSSL_zalloc(sizeof(*ret));
  168.   
  169.       if (ret == NULL) {
                 ^
  170.           SSLerr(SSL_F_SSL_CERT_NEW, ERR_R_MALLOC_FAILURE);
  171.           return (NULL);

ssl/ssl_cert.c:174:5: 
  172.       }
  173.   
  174. >     ret->key = &(ret->pkeys[SSL_PKEY_RSA_ENC]);
  175.       ret->references = 1;
  176.       ret->sec_cb = ssl_security_default_callback;

ssl/ssl_cert.c:175:5: 
  173.   
  174.       ret->key = &(ret->pkeys[SSL_PKEY_RSA_ENC]);
  175. >     ret->references = 1;
  176.       ret->sec_cb = ssl_security_default_callback;
  177.       ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;

ssl/ssl_cert.c:176:5: 
  174.       ret->key = &(ret->pkeys[SSL_PKEY_RSA_ENC]);
  175.       ret->references = 1;
  176. >     ret->sec_cb = ssl_security_default_callback;
  177.       ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;
  178.       ret->sec_ex = NULL;

ssl/ssl_cert.c:177:5: 
  175.       ret->references = 1;
  176.       ret->sec_cb = ssl_security_default_callback;
  177. >     ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;
  178.       ret->sec_ex = NULL;
  179.       return (ret);

ssl/ssl_cert.c:178:5: 
  176.       ret->sec_cb = ssl_security_default_callback;
  177.       ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;
  178. >     ret->sec_ex = NULL;
  179.       return (ret);
  180.   }

ssl/ssl_cert.c:179:5: 
  177.       ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;
  178.       ret->sec_ex = NULL;
  179. >     return (ret);
  180.   }
  181.   

ssl/ssl_cert.c:180:1: return from a call to ssl_cert_new
  178.       ret->sec_ex = NULL;
  179.       return (ret);
  180. > }
  181.   
  182.   CERT *ssl_cert_dup(CERT *cert)

ssl/ssl_lib.c:2292:9: Taking false branch
2290.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2291.       ret->verify_mode = SSL_VERIFY_NONE;
2292.       if ((ret->cert = ssl_cert_new()) == NULL)
                ^
2293.           goto err;
2294.   

ssl/ssl_lib.c:2295:5: 
2293.           goto err;
2294.   
2295. >     ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
2296.       if (ret->sessions == NULL)
2297.           goto err;

ssl/ssl_locl.h:681:1: start of procedure lh_SSL_SESSION_new()
  679.   };
  680.   
  681. > DEFINE_LHASH_OF(SSL_SESSION);
  682.   /* Needed in ssl_cert.c */
  683.   DEFINE_LHASH_OF(X509_NAME);

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

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

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

crypto/mem.c:158:5: 
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158. >     void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       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/mem.c:160:9: Taking true branch
      158.       void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)
                     ^
      161.           memset(ret, 0, num);
      162.       return ret;

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

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

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

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

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

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

crypto/mem.c:158:5: 
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158. >     void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       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/mem.c:160:9: Taking true branch
      158.       void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)
                     ^
      161.           memset(ret, 0, num);
      162.       return ret;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ssl/ssl_locl.h:681:1: return from a call to lh_SSL_SESSION_new
  679.   };
  680.   
  681. > DEFINE_LHASH_OF(SSL_SESSION);
  682.   /* Needed in ssl_cert.c */
  683.   DEFINE_LHASH_OF(X509_NAME);

ssl/ssl_lib.c:2296:9: Taking false branch
2294.   
2295.       ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
2296.       if (ret->sessions == NULL)
                ^
2297.           goto err;
2298.       ret->cert_store = X509_STORE_new();

ssl/ssl_lib.c:2298:5: Skipping X509_STORE_new(): empty list of specs
2296.       if (ret->sessions == NULL)
2297.           goto err;
2298.       ret->cert_store = X509_STORE_new();
            ^
2299.       if (ret->cert_store == NULL)
2300.           goto err;

ssl/ssl_lib.c:2299:9: Taking true branch
2297.           goto err;
2298.       ret->cert_store = X509_STORE_new();
2299.       if (ret->cert_store == NULL)
                ^
2300.           goto err;
2301.   

ssl/ssl_lib.c:2376:2: 
2374.   
2375.       return (ret);
2376. >  err:
2377.       SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2378.    err2:

ssl/ssl_lib.c:2377:5: Skipping ERR_put_error(): empty list of specs
2375.       return (ret);
2376.    err:
2377.       SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
            ^
2378.    err2:
2379.       SSL_CTX_free(ret);

ssl/ssl_lib.c:2378:2: 
2376.    err:
2377.       SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2378. >  err2:
2379.       SSL_CTX_free(ret);
2380.       return (NULL);

ssl/ssl_lib.c:2379:5: Skipping SSL_CTX_free(): empty list of specs
2377.       SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2378.    err2:
2379.       SSL_CTX_free(ret);
            ^
2380.       return (NULL);
2381.   }
