crypto/err/err.c:368: error: BUFFER_OVERRUN_L3
  Offset: [16, +oo] Size: [1, +oo] by call to `lh_ERR_STATE_insert`.
Showing all 18 steps of the trace


crypto/err/err.c:366:12: Call
364.   
365.       CRYPTO_w_lock(CRYPTO_LOCK_ERR);
366.       hash = int_thread_get(1, 0);
                  ^
367.       if (hash)
368.           p = lh_ERR_STATE_insert(hash, d);

crypto/err/err.c:311:27: Call
  309.           CRYPTO_w_lock(CRYPTO_LOCK_ERR);
  310.       if (!int_thread_hash && create) {
  311.           int_thread_hash = lh_ERR_STATE_new(err_state_hash, err_state_cmp);
                                   ^
  312.       }
  313.       if (int_thread_hash != NULL) {

crypto/err/err_lcl.h:2:1: Call
    1.   
    2. > DEFINE_LHASH_OF(ERR_STATE);

crypto/lhash/lhash.c:124:5: Assignment
      122.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
      123.       ret->num_nodes = MIN_NODES / 2;
      124.       ret->num_alloc_nodes = MIN_NODES;
                 ^
      125.       ret->pmax = MIN_NODES / 2;
      126.       ret->up_load = UP_LOAD;

crypto/err/err.c:368:13: Call
366.       hash = int_thread_get(1, 0);
367.       if (hash)
368.           p = lh_ERR_STATE_insert(hash, d);
                   ^
369.       CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
370.   

crypto/err/err_lcl.h:2:1: Parameter `lh->num_alloc_nodes`
  1.   
  2. > DEFINE_LHASH_OF(ERR_STATE);

crypto/err/err_lcl.h:2:1: Call
  1.   
  2. > DEFINE_LHASH_OF(ERR_STATE);

crypto/lhash/lhash.c:156:1: Parameter `lh->num_alloc_nodes`
    154.   }
    155.   
    156. > void *lh_insert(_LHASH *lh, void *data)
    157.   {
    158.       unsigned long hash;

crypto/lhash/lhash.c:164:9: Call
    162.       lh->error = 0;
    163.       if (lh->up_load <= (lh->num_items * LH_LOAD_MULT / lh->num_nodes))
    164.           expand(lh);
                   ^
    165.   
    166.       rn = getrn(lh, data, &hash);

crypto/lhash/lhash.c:279:1: <Offset trace>
277.   }
278.   
279. > static void expand(_LHASH *lh)
280.   {
281.       LHASH_NODE **n, **n1, **n2, *np;

crypto/lhash/lhash.c:279:1: Parameter `lh->num_alloc_nodes`
      277.   }
      278.   
      279. > static void expand(_LHASH *lh)
      280.   {
      281.       LHASH_NODE **n, **n1, **n2, *np;

crypto/lhash/lhash.c:305:9: Assignment
      303.   
      304.       if ((lh->p) >= lh->pmax) {
      305.           j = (int)lh->num_alloc_nodes * 2;
                     ^
      306.           n = OPENSSL_realloc(lh->b, (int)(sizeof(LHASH_NODE *) * j));
      307.           if (n == NULL) {

crypto/lhash/lhash.c:279:1: <Length trace>
277.   }
278.   
279. > static void expand(_LHASH *lh)
280.   {
281.       LHASH_NODE **n, **n1, **n2, *np;

crypto/lhash/lhash.c:279:1: Parameter `*lh->b`
      277.   }
      278.   
      279. > static void expand(_LHASH *lh)
      280.   {
      281.       LHASH_NODE **n, **n1, **n2, *np;

crypto/lhash/lhash.c:306:13: Call
      304.       if ((lh->p) >= lh->pmax) {
      305.           j = (int)lh->num_alloc_nodes * 2;
      306.           n = OPENSSL_realloc(lh->b, (int)(sizeof(LHASH_NODE *) * j));
                         ^
      307.           if (n == NULL) {
      308.               /* fputs("realloc error in lhash",stderr); */

crypto/mem.c:173:9: Assignment
        171.       if (num == 0) {
        172.           CRYPTO_free(str);
        173.           return NULL;
                       ^
        174.       }
        175.   

crypto/lhash/lhash.c:306:9: Assignment
      304.       if ((lh->p) >= lh->pmax) {
      305.           j = (int)lh->num_alloc_nodes * 2;
      306.           n = OPENSSL_realloc(lh->b, (int)(sizeof(LHASH_NODE *) * j));
                     ^
      307.           if (n == NULL) {
      308.               /* fputs("realloc error in lhash",stderr); */

crypto/lhash/lhash.c:314:13: Array access: Offset: [16, +oo] Size: [1, +oo] by call to `lh_ERR_STATE_insert` 
      312.           }
      313.           for (i = (int)lh->num_alloc_nodes; i < j; i++) /* 26/02/92 eay */
      314.               n[i] = NULL;        /* 02/03/92 eay */
                         ^
      315.           lh->pmax = lh->num_alloc_nodes;
      316.           lh->num_alloc_nodes = j;
