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


apps/s_client.c:1295:9: Call
1293.           SSL_CTX_set_srp_cb_arg(ctx, &srp_arg);
1294.           SSL_CTX_set_srp_client_pwd_callback(ctx, ssl_give_srp_client_pwd_cb);
1295.           SSL_CTX_set_srp_strength(ctx, srp_arg.strength);
                ^
1296.           if (c_msg || c_debug || srp_arg.amp == 0)
1297.               SSL_CTX_set_srp_verify_param_callback(ctx,

ssl/tls_srp.c:491:12: Call
  489.   int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength)
  490.   {
  491.       return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength,
                    ^
  492.                            NULL);
  493.   }

ssl/s3_lib.c:4242:24: Call
    4240.                   return 0;
    4241.               }
    4242.               if ((new = DHparams_dup(dh)) == NULL) {
                                   ^
    4243.                   SSLerr(SSL_F_SSL3_CTX_CTRL, ERR_R_DH_LIB);
    4244.                   return 0;

crypto/dh/dh_ameth.c:500:11: Call
      498.   {
      499.       DH *ret;
      500.       ret = DH_new();
                       ^
      501.       if (!ret)
      502.           return NULL;

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

crypto/dh/dh_lib.c:127:23: Call
          125.           ret->engine = engine;
          126.       } else
          127.           ret->engine = ENGINE_get_default_DH();
                                       ^
          128.       if (ret->engine) {
          129.           ret->meth = ENGINE_get_DH(ret->engine);

crypto/engine/tb_dh.c:110:12: Call
            108.   ENGINE *ENGINE_get_default_DH(void)
            109.   {
            110.       return engine_table_select(&dh_table, dummy_nid);
                              ^
            111.   }
            112.   

crypto/engine/eng_table.c:266:10: Call
              264.        * operations. But don't worry about a fprintf(stderr).
              265.        */
              266.       if (!int_table_check(table, 0))
                              ^
              267.           goto end;
              268.       tmplate.nid = nid;

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

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

apps/s_client.c:1302:11: Call
1300.   # endif
1301.   
1302.       con = SSL_new(ctx);
                  ^
1303.       if (sess_in) {
1304.           SSL_SESSION *sess;

ssl/ssl_lib.c:267:1: Parameter `ctx->sessions->num_items`
  265.   }
  266.   
  267. > SSL *SSL_new(SSL_CTX *ctx)
  268.   {
  269.       SSL *s;

ssl/ssl_lib.c:379:10: Call
  377.       s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
  378.   
  379.       if (!SSL_clear(s))
                  ^
  380.           goto err;
  381.   

ssl/ssl_lib.c:197:1: Parameter `s->ctx->sessions->num_items`
    195.   }
    196.   
    197. > int SSL_clear(SSL *s)
    198.   {
    199.       if (s->method == NULL) {

ssl/ssl_lib.c:204:9: Call
    202.       }
    203.   
    204.       if (ssl_clear_bad_session(s)) {
                   ^
    205.           SSL_SESSION_free(s->session);
    206.           s->session = NULL;

ssl/ssl_sess.c:1086:1: Parameter `s->ctx->sessions->num_items`
      1084.   }
      1085.   
      1086. > int ssl_clear_bad_session(SSL *s)
      1087.   {
      1088.       if ((s->session != NULL) &&

ssl/ssl_sess.c:1091:9: Call
      1089.           !(s->shutdown & SSL_SENT_SHUTDOWN) &&
      1090.           !(SSL_in_init(s) || SSL_in_before(s))) {
      1091.           SSL_CTX_remove_session(s->ctx, s->session);
                      ^
      1092.           return (1);
      1093.       } else

ssl/ssl_sess.c:787:1: Parameter `ctx->sessions->num_items`
        785.   }
        786.   
        787. > int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
        788.   {
        789.       return remove_session_lock(ctx, c, 1);

ssl/ssl_sess.c:789:12: Call
        787.   int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
        788.   {
        789.       return remove_session_lock(ctx, c, 1);
                          ^
        790.   }
        791.   

ssl/ssl_sess.c:792:1: Parameter `ctx->sessions->num_items`
          790.   }
          791.   
          792. > static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
          793.   {
          794.       SSL_SESSION *r;

ssl/ssl_sess.c:802:17: Call
          800.           if ((r = lh_SSL_SESSION_retrieve(ctx->sessions, c)) == c) {
          801.               ret = 1;
          802.               r = lh_SSL_SESSION_delete(ctx->sessions, c);
                                 ^
          803.               SSL_SESSION_list_remove(ctx, c);
          804.           }

crypto/lhash/lhash.c:209:1: <LHS trace>
207.   }
208.   
209. > void *lh_delete(_LHASH *lh, const void *data)
210.   {
211.       unsigned long hash;

crypto/lhash/lhash.c:209:1: Parameter `lh->num_items`
            207.   }
            208.   
            209. > void *lh_delete(_LHASH *lh, const void *data)
            210.   {
            211.       unsigned long hash;

crypto/lhash/lhash.c:229:5: Binary operation: (0 - 1):unsigned64 by call to `SSL_new` 
            227.       }
            228.   
            229.       lh->num_items--;
                       ^
            230.       if ((lh->num_nodes > MIN_NODES) &&
            231.           (lh->down_load >= (lh->num_items * LH_LOAD_MULT / lh->num_nodes)))
