ssl/ssl_lib.c:3481: 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:3457:1: Parameter `s->ctx->sessions->num_items`
3455.   }
3456.   
3457. > SSL *SSL_dup(SSL *s)
3458.   {
3459.       STACK_OF(X509_NAME) *sk;

ssl/ssl_lib.c:3473:16: Call
3471.        * Otherwise, copy configuration state, and session if set.
3472.        */
3473.       if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
                       ^
3474.           return NULL;
3475.   

ssl/ssl_lib.c:610:1: Parameter `ctx->sessions->num_items`
  608.   }
  609.   
  610. > SSL *SSL_new(SSL_CTX *ctx)
  611.   {
  612.       SSL *s;

ssl/ssl_lib.c:3481:14: Call
3479.            * session-id, SSL_METHOD, sid_ctx, and 'cert'
3480.            */
3481.           if (!SSL_copy_session_id(ret, s))
                     ^
3482.               goto err;
3483.       } else {

ssl/ssl_lib.c:1482:1: Parameter `t->session_ctx->sessions->num_items`
  1480.    * modify.  We need to be able to read f without being hassled
  1481.    */
  1482. > int SSL_copy_session_id(SSL *t, const SSL *f)
  1483.   {
  1484.       int i;

ssl/ssl_lib.c:1486:10: Call
  1484.       int i;
  1485.       /* Do we need to to SSL locking? */
  1486.       if (!SSL_set_session(t, SSL_get_session(f))) {
                   ^
  1487.           return 0;
  1488.       }

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:1107:1: Parameter `s->session_ctx->sessions->num_items`
      1105.   }
      1106.   
      1107. > int ssl_clear_bad_session(SSL *s)
      1108.   {
      1109.       if ((s->session != NULL) &&

ssl/ssl_sess.c:1112:9: Call
      1110.           !(s->shutdown & SSL_SENT_SHUTDOWN) &&
      1111.           !(SSL_in_init(s) || SSL_in_before(s))) {
      1112.           SSL_CTX_remove_session(s->session_ctx, s->session);
                      ^
      1113.           return 1;
      1114.       } else

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

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

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

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

ssl/ssl_locl.h:697:1: Parameter `lh->num_items`
            695.   } TLSEXT_INDEX;
            696.   
            697. > DEFINE_LHASH_OF(SSL_SESSION);
            698.   /* Needed in ssl_cert.c */
            699.   DEFINE_LHASH_OF(X509_NAME);

ssl/ssl_locl.h:697:1: Call
            695.   } TLSEXT_INDEX;
            696.   
            697. > DEFINE_LHASH_OF(SSL_SESSION);
            698.   /* Needed in ssl_cert.c */
            699.   DEFINE_LHASH_OF(X509_NAME);

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

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

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