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


apps/s_client.c:1384:9: Call
1382.           SSL_CTX_set_srp_cb_arg(ctx, &srp_arg);
1383.           SSL_CTX_set_srp_client_pwd_callback(ctx, ssl_give_srp_client_pwd_cb);
1384.           SSL_CTX_set_srp_strength(ctx, srp_arg.strength);
                ^
1385.           if (c_msg || c_debug || srp_arg.amp == 0)
1386.               SSL_CTX_set_srp_verify_param_callback(ctx,

ssl/tls_srp.c:514:12: Call
  512.   int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength)
  513.   {
  514.       return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength,
                    ^
  515.                            NULL);
  516.   }

ssl/s3_lib.c:3746:24: Call
    3744.                   return 0;
    3745.               }
    3746.               if ((new = DHparams_dup(dh)) == NULL) {
                                   ^
    3747.                   SSLerr(SSL_F_SSL3_CTX_CTRL, ERR_R_DH_LIB);
    3748.                   return 0;

crypto/dh/dh_ameth.c:506:11: Call
      504.   {
      505.       DH *ret;
      506.       ret = DH_new();
                       ^
      507.       if (!ret)
      508.           return NULL;

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

crypto/dh/dh_lib.c:130:23: Call
          128.           ret->engine = engine;
          129.       } else
          130.           ret->engine = ENGINE_get_default_DH();
                                       ^
          131.       if (ret->engine) {
          132.           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:264:10: Call
              262.        * operations. But don't worry about a fprintf(stderr).
              263.        */
              264.       if (!int_table_check(table, 0))
                              ^
              265.           goto end;
              266.       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:134:5: Assignment
                  132.       ret->up_load = UP_LOAD;
                  133.       ret->down_load = DOWN_LOAD;
                  134.       ret->num_items = 0;
                             ^
                  135.   
                  136.       ret->num_expands = 0;

apps/s_client.c:1392:11: Call
1390.   #endif
1391.   
1392.       con = SSL_new(ctx);
                  ^
1393.       if (sess_in) {
1394.           SSL_SESSION *sess;

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

ssl/ssl_lib.c:384:9: Call
  382.       s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
  383.   
  384.       if(!SSL_clear(s))
                 ^
  385.           goto err;
  386.   

ssl/ssl_lib.c:190:1: Parameter `s->ctx->sessions->num_items`
    188.   };
    189.   
    190. > int SSL_clear(SSL *s)
    191.   {
    192.       if (s->method == NULL) {

ssl/ssl_lib.c:197:9: Call
    195.       }
    196.   
    197.       if (ssl_clear_bad_session(s)) {
                   ^
    198.           SSL_SESSION_free(s->session);
    199.           s->session = NULL;

ssl/ssl_sess.c:1010:1: Parameter `s->ctx->sessions->num_items`
      1008.   }
      1009.   
      1010. > int ssl_clear_bad_session(SSL *s)
      1011.   {
      1012.       if ((s->session != NULL) &&

ssl/ssl_sess.c:1015:9: Call
      1013.           !(s->shutdown & SSL_SENT_SHUTDOWN) &&
      1014.           !(SSL_in_init(s) || SSL_in_before(s))) {
      1015.           SSL_CTX_remove_session(s->ctx, s->session);
                      ^
      1016.           return (1);
      1017.       } else

ssl/ssl_sess.c:675:1: Parameter `ctx->sessions->num_items`
        673.   }
        674.   
        675. > int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
        676.   {
        677.       return remove_session_lock(ctx, c, 1);

ssl/ssl_sess.c:677:12: Call
        675.   int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
        676.   {
        677.       return remove_session_lock(ctx, c, 1);
                          ^
        678.   }
        679.   

ssl/ssl_sess.c:680:1: Parameter `ctx->sessions->num_items`
          678.   }
          679.   
          680. > static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
          681.   {
          682.       SSL_SESSION *r;

ssl/ssl_sess.c:690:17: Call
          688.           if ((r = lh_SSL_SESSION_retrieve(ctx->sessions, c)) == c) {
          689.               ret = 1;
          690.               r = lh_SSL_SESSION_delete(ctx->sessions, c);
                                 ^
          691.               SSL_SESSION_list_remove(ctx, c);
          692.           }

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

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

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