ssl/ssl_lib.c:3332: error: INTEGER_OVERFLOW_L2
  ([0, max(0, `s->ctx->sessions->num_items`)] - 1):unsigned64 by call to `SSL_copy_session_id`.
Showing all 19 steps of the trace


ssl/ssl_lib.c:3308:1: Parameter `s->ctx->sessions->num_items`
3306.   }
3307.   
3308. > SSL *SSL_dup(SSL *s)
3309.   {
3310.       STACK_OF(X509_NAME) *sk;

ssl/ssl_lib.c:3324:16: Call
3322.        * Otherwise, copy configuration state, and session if set.
3323.        */
3324.       if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
                       ^
3325.           return (NULL);
3326.   

ssl/ssl_lib.c:521:1: Parameter `ctx->sessions->num_items`
  519.   }
  520.   
  521. > SSL *SSL_new(SSL_CTX *ctx)
  522.   {
  523.       SSL *s;

ssl/ssl_lib.c:3332:14: Call
3330.            * session-id, SSL_METHOD, sid_ctx, and 'cert'
3331.            */
3332.           if (!SSL_copy_session_id(ret, s))
                     ^
3333.               goto err;
3334.       } else {

ssl/ssl_lib.c:1371:1: Parameter `t->session_ctx->sessions->num_items`
  1369.    * modify.  We need to be able to read f without being hassled
  1370.    */
  1371. > int SSL_copy_session_id(SSL *t, const SSL *f)
  1372.   {
  1373.       int i;

ssl/ssl_lib.c:1375:10: Call
  1373.       int i;
  1374.       /* Do we need to to SSL locking? */
  1375.       if (!SSL_set_session(t, SSL_get_session(f))) {
                   ^
  1376.           return 0;
  1377.       }

ssl/ssl_sess.c:812:1: Parameter `s->session_ctx->sessions->num_items`
    810.   }
    811.   
    812. > int SSL_set_session(SSL *s, SSL_SESSION *session)
    813.   {
    814.       ssl_clear_bad_session(s);

ssl/ssl_sess.c:814:5: Call
    812.   int SSL_set_session(SSL *s, SSL_SESSION *session)
    813.   {
    814.       ssl_clear_bad_session(s);
               ^
    815.       if (s->ctx->method != s->method) {
    816.           if (!SSL_set_ssl_method(s, s->ctx->method))

ssl/ssl_sess.c:1049:1: Parameter `s->session_ctx->sessions->num_items`
      1047.   }
      1048.   
      1049. > int ssl_clear_bad_session(SSL *s)
      1050.   {
      1051.       if ((s->session != NULL) &&

ssl/ssl_sess.c:1054:9: Call
      1052.           !(s->shutdown & SSL_SENT_SHUTDOWN) &&
      1053.           !(SSL_in_init(s) || SSL_in_before(s))) {
      1054.           SSL_CTX_remove_session(s->session_ctx, s->session);
                      ^
      1055.           return (1);
      1056.       } else

ssl/ssl_sess.c:725:1: Parameter `ctx->sessions->num_items`
        723.   }
        724.   
        725. > int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
        726.   {
        727.       return remove_session_lock(ctx, c, 1);

ssl/ssl_sess.c:727:12: Call
        725.   int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
        726.   {
        727.       return remove_session_lock(ctx, c, 1);
                          ^
        728.   }
        729.   

ssl/ssl_sess.c:730:1: Parameter `ctx->sessions->num_items`
          728.   }
          729.   
          730. > static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
          731.   {
          732.       SSL_SESSION *r;

ssl/ssl_sess.c:740:17: Call
          738.           if ((r = lh_SSL_SESSION_retrieve(ctx->sessions, c)) == c) {
          739.               ret = 1;
          740.               r = lh_SSL_SESSION_delete(ctx->sessions, c);
                                 ^
          741.               SSL_SESSION_list_remove(ctx, c);
          742.           }

ssl/ssl_locl.h:721:1: Parameter `lh->num_items`
            719.   } TLSEXT_INDEX;
            720.   
            721. > DEFINE_LHASH_OF(SSL_SESSION);
            722.   /* Needed in ssl_cert.c */
            723.   DEFINE_LHASH_OF(X509_NAME);

ssl/ssl_locl.h:721:1: Call
            719.   } TLSEXT_INDEX;
            720.   
            721. > DEFINE_LHASH_OF(SSL_SESSION);
            722.   /* Needed in ssl_cert.c */
            723.   DEFINE_LHASH_OF(X509_NAME);

crypto/lhash/lhash.c:103:1: <LHS trace>
101.   }
102.   
103. > void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data)
104.   {
105.       unsigned long hash;

crypto/lhash/lhash.c:103:1: Parameter `lh->num_items`
              101.   }
              102.   
              103. > void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data)
              104.   {
              105.       unsigned long hash;

crypto/lhash/lhash.c:123:5: Binary operation: ([0, max(0, s->ctx->sessions->num_items)] - 1):unsigned64 by call to `SSL_copy_session_id` 
              121.       }
              122.   
              123.       lh->num_items--;
                         ^
              124.       if ((lh->num_nodes > MIN_NODES) &&
              125.           (lh->down_load >= (lh->num_items * LH_LOAD_MULT / lh->num_nodes)))
