apps/s_client.c:1420: error: INTEGER_OVERFLOW_L1
  (0 - 1):unsigned64 by call to `SSL_new`.
Showing all 24 steps of the trace


apps/s_client.c:1412:3: Call
1410.   		SSL_CTX_set_srp_cb_arg(ctx,&srp_arg);
1411.   		SSL_CTX_set_srp_client_pwd_callback(ctx, ssl_give_srp_client_pwd_cb);
1412.   		SSL_CTX_set_srp_strength(ctx, srp_arg.strength);
          ^
1413.   		if (c_msg || c_debug || srp_arg.amp == 0)
1414.   			SSL_CTX_set_srp_verify_param_callback(ctx, ssl_srp_verify_param_cb);

ssl/tls_srp.c:507:9: Call
  505.   int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength)
  506.   	{
  507.   	return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength,
                 ^
  508.   			     NULL);
  509.   	}

ssl/s3_lib.c:4087:12: Call
    4085.   			return 0;
    4086.   			}
    4087.   		if ((new=DHparams_dup(dh)) == NULL)
                       ^
    4088.   			{
    4089.   			SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_DH_LIB);

crypto/dh/dh_ameth.c:523:8: Call
      521.   	{
      522.   	DH *ret;
      523.   	ret = DH_new();
                    ^
      524.   	if (!ret)
      525.   		return NULL;

crypto/dh/dh_lib.c:104:9: Call
        102.   DH *DH_new(void)
        103.   	{
        104.   	return DH_new_method(NULL);
                       ^
        105.   	}
        106.   

crypto/dh/dh_lib.c:131:17: Call
          129.   		}
          130.   	else
          131.   		ret->engine = ENGINE_get_default_DH();
                                 ^
          132.   	if(ret->engine)
          133.   		{

crypto/engine/tb_dh.c:104:9: Call
            102.   ENGINE *ENGINE_get_default_DH(void)
            103.   	{
            104.   	return engine_table_select(&dh_table, dummy_nid);
                           ^
            105.   	}
            106.   

crypto/engine/eng_table.c:261:6: Call
              259.   	/* Check again inside the lock otherwise we could race against cleanup
              260.   	 * operations. But don't worry about a fprintf(stderr). */
              261.   	if(!int_table_check(table, 0)) goto end;
                          ^
              262.   	tmplate.nid = nid;
              263.   	fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);

crypto/engine/eng_table.c:122:11: Call
                120.   	if(*t) return 1;
                121.   	if(!create) return 0;
                122.   	if((lh = lh_ENGINE_PILE_new()) == NULL)
                                 ^
                123.   		return 0;
                124.   	*t = (ENGINE_TABLE *)lh;

crypto/lhash/lhash.c:133:2: Assignment
                  131.   	ret->up_load=UP_LOAD;
                  132.   	ret->down_load=DOWN_LOAD;
                  133.   	ret->num_items=0;
                          ^
                  134.   
                  135.   	ret->num_expands=0;

apps/s_client.c:1420:6: Call
1418.   #endif
1419.   
1420.   	con=SSL_new(ctx);
             ^
1421.   	if (sess_in)
1422.   		{

ssl/ssl_lib.c:275:1: Parameter `ctx->sessions->num_items`
  273.   	}
  274.   
  275. > SSL *SSL_new(SSL_CTX *ctx)
  276.   	{
  277.   	SSL *s;

ssl/ssl_lib.c:408:2: Call
  406.   	s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
  407.   
  408.   	SSL_clear(s);
          ^
  409.   
  410.   	CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);

ssl/ssl_lib.c:185:1: Parameter `s->ctx->sessions->num_items`
    183.   	};
    184.   
    185. > int SSL_clear(SSL *s)
    186.   	{
    187.   

ssl/ssl_lib.c:194:6: Call
    192.   		}
    193.   
    194.   	if (ssl_clear_bad_session(s))
                ^
    195.   		{
    196.   		SSL_SESSION_free(s->session);

ssl/ssl_sess.c:991:1: Parameter `s->ctx->sessions->num_items`
      989.   	}
      990.   
      991. > int ssl_clear_bad_session(SSL *s)
      992.   	{
      993.   	if (	(s->session != NULL) &&

ssl/ssl_sess.c:997:3: Call
      995.   		!(SSL_in_init(s) || SSL_in_before(s)))
      996.   		{
      997.   		SSL_CTX_remove_session(s->ctx,s->session);
                ^
      998.   		return(1);
      999.   		}

ssl/ssl_sess.c:682:1: Parameter `ctx->sessions->num_items`
        680.   	}
        681.   
        682. > int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
        683.   {
        684.   	return remove_session_lock(ctx, c, 1);

ssl/ssl_sess.c:684:9: Call
        682.   int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
        683.   {
        684.   	return remove_session_lock(ctx, c, 1);
                       ^
        685.   }
        686.   

ssl/ssl_sess.c:687:1: Parameter `ctx->sessions->num_items`
          685.   }
          686.   
          687. > static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
          688.   	{
          689.   	SSL_SESSION *r;

ssl/ssl_sess.c:698:6: Call
          696.   			{
          697.   			ret=1;
          698.   			r=lh_SSL_SESSION_delete(ctx->sessions,c);
                      ^
          699.   			SSL_SESSION_list_remove(ctx,c);
          700.   			}

crypto/lhash/lhash.c:217:1: <LHS trace>
215.   	}
216.   
217. > void *lh_delete(_LHASH *lh, const void *data)
218.   	{
219.   	unsigned long hash;

crypto/lhash/lhash.c:217:1: Parameter `lh->num_items`
            215.   	}
            216.   
            217. > void *lh_delete(_LHASH *lh, const void *data)
            218.   	{
            219.   	unsigned long hash;

crypto/lhash/lhash.c:240:2: Binary operation: (0 - 1):unsigned64 by call to `SSL_new` 
            238.   		}
            239.   
            240.   	lh->num_items--;
                    ^
            241.   	if ((lh->num_nodes > MIN_NODES) &&
            242.   		(lh->down_load >= (lh->num_items*LH_LOAD_MULT/lh->num_nodes)))
