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


ssl/ssl_lib.c:2264:1: start of procedure SSL_CTX_new()
2262.    */
2263.   
2264. > SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
2265.   {
2266.       SSL_CTX *ret = NULL;

ssl/ssl_lib.c:2266:5: 
2264.   SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
2265.   {
2266. >     SSL_CTX *ret = NULL;
2267.   
2268.       if (meth == NULL) {

ssl/ssl_lib.c:2268:9: Taking false branch
2266.       SSL_CTX *ret = NULL;
2267.   
2268.       if (meth == NULL) {
                ^
2269.           SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_NULL_SSL_METHOD_PASSED);
2270.           return (NULL);

ssl/ssl_lib.c:2273:10: 
2271.       }
2272.   
2273. >     if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
2274.           return NULL;
2275.   

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

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

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

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

ssl/ssl_init.c:323:5: 
  321.           return 0;
  322.   
  323. >     ossl_init_once_run(&ssl_base, ossl_init_ssl_base);
  324.   
  325.       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:325:9: Taking false branch
  323.       ossl_init_once_run(&ssl_base, ossl_init_ssl_base);
  324.   
  325.       if (opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS)
                 ^
  326.           ossl_init_once_run(&ssl_strings, ossl_init_no_load_ssl_strings);
  327.   

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

ssl/ssl_init.c:329:9: 
  327.   
  328.       if (opts & OPENSSL_INIT_LOAD_SSL_STRINGS)
  329. >         ossl_init_once_run(&ssl_strings, ossl_init_load_ssl_strings);
  330.   
  331.       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:331:5: 
  329.           ossl_init_once_run(&ssl_strings, ossl_init_load_ssl_strings);
  330.   
  331. >     return 1;
  332.   }
  333.   

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

ssl/ssl_lib.c:2273:10: Taking false branch
2271.       }
2272.   
2273.       if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
                 ^
2274.           return NULL;
2275.   

ssl/ssl_lib.c:2276:9: 
2274.           return NULL;
2275.   
2276. >     if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
2277.           SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE);
2278.           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:2276:9: Taking false branch
2274.           return NULL;
2275.   
2276.       if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
                ^
2277.           SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE);
2278.           return NULL;

ssl/ssl_lib.c:2281:9: Taking false branch
2279.       }
2280.   
2281.       if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
                ^
2282.           SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
2283.           goto err;

ssl/ssl_lib.c:2285:5: 
2283.           goto err;
2284.       }
2285. >     ret = OPENSSL_zalloc(sizeof(*ret));
2286.       if (ret == NULL)
2287.           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:2286:9: Taking false branch
2284.       }
2285.       ret = OPENSSL_zalloc(sizeof(*ret));
2286.       if (ret == NULL)
                ^
2287.           goto err;
2288.   

ssl/ssl_lib.c:2289:5: 
2287.           goto err;
2288.   
2289. >     ret->method = meth;
2290.       ret->min_proto_version = 0;
2291.       ret->max_proto_version = 0;

ssl/ssl_lib.c:2290:5: 
2288.   
2289.       ret->method = meth;
2290. >     ret->min_proto_version = 0;
2291.       ret->max_proto_version = 0;
2292.       ret->session_cache_mode = SSL_SESS_CACHE_SERVER;

ssl/ssl_lib.c:2291:5: 
2289.       ret->method = meth;
2290.       ret->min_proto_version = 0;
2291. >     ret->max_proto_version = 0;
2292.       ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
2293.       ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;

ssl/ssl_lib.c:2292:5: 
2290.       ret->min_proto_version = 0;
2291.       ret->max_proto_version = 0;
2292. >     ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
2293.       ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
2294.       /* We take the system default. */

ssl/ssl_lib.c:2293:5: 
2291.       ret->max_proto_version = 0;
2292.       ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
2293. >     ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
2294.       /* We take the system default. */
2295.       ret->session_timeout = meth->get_timeout();

ssl/ssl_lib.c:2295:5: Skipping __function_pointer__(): unresolved function pointer
2293.       ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
2294.       /* We take the system default. */
2295.       ret->session_timeout = meth->get_timeout();
            ^
2296.       ret->references = 1;
2297.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;

ssl/ssl_lib.c:2296:5: 
2294.       /* We take the system default. */
2295.       ret->session_timeout = meth->get_timeout();
2296. >     ret->references = 1;
2297.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2298.       ret->verify_mode = SSL_VERIFY_NONE;

ssl/ssl_lib.c:2297:5: 
2295.       ret->session_timeout = meth->get_timeout();
2296.       ret->references = 1;
2297. >     ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2298.       ret->verify_mode = SSL_VERIFY_NONE;
2299.       if ((ret->cert = ssl_cert_new()) == NULL)

ssl/ssl_lib.c:2298:5: 
2296.       ret->references = 1;
2297.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2298. >     ret->verify_mode = SSL_VERIFY_NONE;
2299.       if ((ret->cert = ssl_cert_new()) == NULL)
2300.           goto err;

ssl/ssl_lib.c:2299:9: 
2297.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2298.       ret->verify_mode = SSL_VERIFY_NONE;
2299. >     if ((ret->cert = ssl_cert_new()) == NULL)
2300.           goto err;
2301.   

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

ssl/ssl_cert.c:170:5: 
  168.   CERT *ssl_cert_new(void)
  169.   {
  170. >     CERT *ret = OPENSSL_zalloc(sizeof(*ret));
  171.   
  172.       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:172:9: Taking false branch
  170.       CERT *ret = OPENSSL_zalloc(sizeof(*ret));
  171.   
  172.       if (ret == NULL) {
                 ^
  173.           SSLerr(SSL_F_SSL_CERT_NEW, ERR_R_MALLOC_FAILURE);
  174.           return (NULL);

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

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

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

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

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

ssl/ssl_cert.c:182:5: 
  180.       ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;
  181.       ret->sec_ex = NULL;
  182. >     return (ret);
  183.   }
  184.   

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

ssl/ssl_lib.c:2299:9: Taking false branch
2297.       ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2298.       ret->verify_mode = SSL_VERIFY_NONE;
2299.       if ((ret->cert = ssl_cert_new()) == NULL)
                ^
2300.           goto err;
2301.   

ssl/ssl_lib.c:2302:5: 
2300.           goto err;
2301.   
2302. >     ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
2303.       if (ret->sessions == NULL)
2304.           goto err;

ssl/ssl_locl.h:687:1: start of procedure lh_SSL_SESSION_new()
  685.   };
  686.   
  687. > DEFINE_LHASH_OF(SSL_SESSION);
  688.   
  689.   

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:687:1: return from a call to lh_SSL_SESSION_new
  685.   };
  686.   
  687. > DEFINE_LHASH_OF(SSL_SESSION);
  688.   
  689.   

ssl/ssl_lib.c:2303:9: Taking false branch
2301.   
2302.       ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
2303.       if (ret->sessions == NULL)
                ^
2304.           goto err;
2305.       ret->cert_store = X509_STORE_new();

ssl/ssl_lib.c:2305:5: Skipping X509_STORE_new(): empty list of specs
2303.       if (ret->sessions == NULL)
2304.           goto err;
2305.       ret->cert_store = X509_STORE_new();
            ^
2306.       if (ret->cert_store == NULL)
2307.           goto err;

ssl/ssl_lib.c:2306:9: Taking true branch
2304.           goto err;
2305.       ret->cert_store = X509_STORE_new();
2306.       if (ret->cert_store == NULL)
                ^
2307.           goto err;
2308.   

ssl/ssl_lib.c:2383:2: 
2381.   
2382.       return (ret);
2383. >  err:
2384.       SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2385.    err2:

ssl/ssl_lib.c:2384:5: Skipping ERR_put_error(): empty list of specs
2382.       return (ret);
2383.    err:
2384.       SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
            ^
2385.    err2:
2386.       SSL_CTX_free(ret);

ssl/ssl_lib.c:2385:2: 
2383.    err:
2384.       SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2385. >  err2:
2386.       SSL_CTX_free(ret);
2387.       return (NULL);

ssl/ssl_lib.c:2386:5: Skipping SSL_CTX_free(): empty list of specs
2384.       SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2385.    err2:
2386.       SSL_CTX_free(ret);
            ^
2387.       return (NULL);
2388.   }

SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
{
    SSL_CTX *ret = NULL;
    if (meth == NULL) {
        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_NULL_SSL_METHOD_PASSED);
        return (NULL);
    }
    if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
        return NULL;
    if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE);
        return NULL;
    }
    if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
        goto err;
    }
    ret = OPENSSL_zalloc(sizeof(*ret));
    if (ret == NULL)
        goto err;
    ret->method = meth;
    ret->min_proto_version = 0;
    ret->max_proto_version = 0;
    ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
    ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
    ret->session_timeout = meth->get_timeout();
    ret->references = 1;
    ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
    ret->verify_mode = SSL_VERIFY_NONE;
    if ((ret->cert = ssl_cert_new()) == NULL)
        goto err;
    ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
    if (ret->sessions == NULL)
        goto err;
    ret->cert_store = X509_STORE_new();
    if (ret->cert_store == NULL)
        goto err;
    if (!ssl_create_cipher_list(ret->method,
                           &ret->cipher_list, &ret->cipher_list_by_id,
                           SSL_DEFAULT_CIPHER_LIST, ret->cert)
       || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_LIBRARY_HAS_NO_CIPHERS);
        goto err2;
    }
    ret->param = X509_VERIFY_PARAM_new();
    if (ret->param == NULL)
        goto err;
    if ((ret->md5 = EVP_get_digestbyname("ssl3-md5")) == NULL) {
        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
        goto err2;
    }
    if ((ret->sha1 = EVP_get_digestbyname("ssl3-sha1")) == NULL) {
        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
        goto err2;
    }
    if ((ret->client_CA = sk_X509_NAME_new_null()) == NULL)
        goto err;
    CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);
    if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))
        ret->comp_methods = SSL_COMP_get_compression_methods();
    ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
    if ((RAND_bytes(ret->tlsext_tick_key_name, 16) <= 0)
        || (RAND_bytes(ret->tlsext_tick_hmac_key, 16) <= 0)
        || (RAND_bytes(ret->tlsext_tick_aes_key, 16) <= 0))
        ret->options |= SSL_OP_NO_TICKET;
#ifndef OPENSSL_NO_SRP
    if (!SSL_CTX_SRP_CTX_init(ret))
        goto err;
#endif
#ifndef OPENSSL_NO_ENGINE
# ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
#  define eng_strx(x)     #x
#  define eng_str(x)      eng_strx(x)
    {
        ENGINE *eng;
        eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
        if (!eng) {
            ERR_clear_error();
            ENGINE_load_builtin_engines();
            eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
        }
        if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
            ERR_clear_error();
    }
# endif
#endif
    ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
    ret->options |= SSL_OP_NO_COMPRESSION;
    return (ret);
 err:
    SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
 err2:
    SSL_CTX_free(ret);
    return (NULL);
}
['SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)\n{\n    SSL_CTX *ret = NULL;\n    if (meth == NULL) {\n        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_NULL_SSL_METHOD_PASSED);\n        return (NULL);\n    }\n    if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))\n        return NULL;\n    if (FIPS_mode() && (meth->version < TLS1_VERSION)) {\n        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE);\n        return NULL;\n    }\n    if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {\n        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);\n        goto err;\n    }\n    ret = OPENSSL_zalloc(sizeof(*ret));\n    if (ret == NULL)\n        goto err;\n    ret->method = meth;\n    ret->min_proto_version = 0;\n    ret->max_proto_version = 0;\n    ret->session_cache_mode = SSL_SESS_CACHE_SERVER;\n    ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;\n    ret->session_timeout = meth->get_timeout();\n    ret->references = 1;\n    ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;\n    ret->verify_mode = SSL_VERIFY_NONE;\n    if ((ret->cert = ssl_cert_new()) == NULL)\n        goto err;\n    ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);\n    if (ret->sessions == NULL)\n        goto err;\n    ret->cert_store = X509_STORE_new();\n    if (ret->cert_store == NULL)\n        goto err;\n    if (!ssl_create_cipher_list(ret->method,\n                           &ret->cipher_list, &ret->cipher_list_by_id,\n                           SSL_DEFAULT_CIPHER_LIST, ret->cert)\n       || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {\n        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_LIBRARY_HAS_NO_CIPHERS);\n        goto err2;\n    }\n    ret->param = X509_VERIFY_PARAM_new();\n    if (ret->param == NULL)\n        goto err;\n    if ((ret->md5 = EVP_get_digestbyname("ssl3-md5")) == NULL) {\n        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);\n        goto err2;\n    }\n    if ((ret->sha1 = EVP_get_digestbyname("ssl3-sha1")) == NULL) {\n        SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);\n        goto err2;\n    }\n    if ((ret->client_CA = sk_X509_NAME_new_null()) == NULL)\n        goto err;\n    CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);\n    if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))\n        ret->comp_methods = SSL_COMP_get_compression_methods();\n    ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;\n    if ((RAND_bytes(ret->tlsext_tick_key_name, 16) <= 0)\n        || (RAND_bytes(ret->tlsext_tick_hmac_key, 16) <= 0)\n        || (RAND_bytes(ret->tlsext_tick_aes_key, 16) <= 0))\n        ret->options |= SSL_OP_NO_TICKET;\n#ifndef OPENSSL_NO_SRP\n    if (!SSL_CTX_SRP_CTX_init(ret))\n        goto err;\n#endif\n#ifndef OPENSSL_NO_ENGINE\n# ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO\n#  define eng_strx(x)     #x\n#  define eng_str(x)      eng_strx(x)\n    {\n        ENGINE *eng;\n        eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));\n        if (!eng) {\n            ERR_clear_error();\n            ENGINE_load_builtin_engines();\n            eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));\n        }\n        if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))\n            ERR_clear_error();\n    }\n# endif\n#endif\n    ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;\n    ret->options |= SSL_OP_NO_COMPRESSION;\n    return (ret);\n err:\n    SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);\n err2:\n    SSL_CTX_free(ret);\n    return (NULL);\n}', 'int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)\n{\n    static int stoperrset = 0;\n    if (stopped) {\n        if (!stoperrset) {\n            stoperrset = 1;\n            SSLerr(SSL_F_OPENSSL_INIT_SSL, ERR_R_INIT_FAIL);\n        }\n        return 0;\n    }\n    if (!OPENSSL_init_crypto(opts | OPENSSL_INIT_ADD_ALL_CIPHERS\n                             | OPENSSL_INIT_ADD_ALL_DIGESTS, settings))\n        return 0;\n    ossl_init_once_run(&ssl_base, ossl_init_ssl_base);\n    if (opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS)\n        ossl_init_once_run(&ssl_strings, ossl_init_no_load_ssl_strings);\n    if (opts & OPENSSL_INIT_LOAD_SSL_STRINGS)\n        ossl_init_once_run(&ssl_strings, ossl_init_load_ssl_strings);\n    return 1;\n}', 'static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))\n{\n    pthread_once(once, init);\n}', 'int FIPS_mode(void)\n{\n#ifdef OPENSSL_FIPS\n    return FIPS_module_mode();\n#else\n    return 0;\n#endif\n}', 'void *CRYPTO_zalloc(size_t num, const char *file, int line)\n{\n    void *ret = CRYPTO_malloc(num, file, line);\n    if (ret != NULL)\n        memset(ret, 0, num);\n    return ret;\n}', 'void *CRYPTO_malloc(size_t num, const char *file, int line)\n{\n    void *ret = NULL;\n    if (num <= 0)\n        return NULL;\n    allow_customize = 0;\n#ifndef OPENSSL_NO_CRYPTO_MDEBUG\n    if (call_malloc_debug) {\n        CRYPTO_mem_debug_malloc(NULL, num, 0, file, line);\n        ret = malloc(num);\n        CRYPTO_mem_debug_malloc(ret, num, 1, file, line);\n    } else {\n        ret = malloc(num);\n    }\n#else\n    (void)file;\n    (void)line;\n    ret = malloc(num);\n#endif\n#ifndef OPENSSL_CPUID_OBJ\n    if (ret && (num > 2048)) {\n        extern unsigned char cleanse_ctr;\n        ((unsigned char *)ret)[0] = cleanse_ctr;\n    }\n#endif\n    return ret;\n}', 'CERT *ssl_cert_new(void)\n{\n    CERT *ret = OPENSSL_zalloc(sizeof(*ret));\n    if (ret == NULL) {\n        SSLerr(SSL_F_SSL_CERT_NEW, ERR_R_MALLOC_FAILURE);\n        return (NULL);\n    }\n    ret->key = &(ret->pkeys[SSL_PKEY_RSA_ENC]);\n    ret->references = 1;\n    ret->sec_cb = ssl_security_default_callback;\n    ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;\n    ret->sec_ex = NULL;\n    return (ret);\n}', 'DEFINE_LHASH_OF(SSL_SESSION)', '_LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c)\n{\n    _LHASH *ret;\n    if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)\n        goto err0;\n    if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)\n        goto err1;\n    ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);\n    ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);\n    ret->num_nodes = MIN_NODES / 2;\n    ret->num_alloc_nodes = MIN_NODES;\n    ret->pmax = MIN_NODES / 2;\n    ret->up_load = UP_LOAD;\n    ret->down_load = DOWN_LOAD;\n    return (ret);\n err1:\n    OPENSSL_free(ret);\n err0:\n    return (NULL);\n}']