[thirdparty/openssl.git] / crypto / lhash / lhash.c

/*
 * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <openssl/crypto.h>
#include <openssl/lhash.h>
#include "lhash_lcl.h"


#undef MIN_NODES
#define MIN_NODES       16
#define UP_LOAD         (2*LH_LOAD_MULT) /* load times 256 (default 2) */
#define DOWN_LOAD       (LH_LOAD_MULT) /* load times 256 (default 1) */

static int expand(OPENSSL_LHASH *lh);
static void contract(OPENSSL_LHASH *lh);
static OPENSSL_LH_NODE **getrn(OPENSSL_LHASH *lh, const void *data, unsigned long *rhash);

OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c)
{
    OPENSSL_LHASH *ret;

    if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
        return NULL;
    if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
        goto err;
    ret->comp = ((c == NULL) ? (OPENSSL_LH_COMPFUNC)strcmp : c);
    ret->hash = ((h == NULL) ? (OPENSSL_LH_HASHFUNC)OPENSSL_LH_strhash : h);
    ret->num_nodes = MIN_NODES / 2;
    ret->num_alloc_nodes = MIN_NODES;
    ret->pmax = MIN_NODES / 2;
    ret->up_load = UP_LOAD;
    ret->down_load = DOWN_LOAD;
    return ret;

err:
    OPENSSL_free(ret->b);
    OPENSSL_free(ret);
    return NULL;
}

void OPENSSL_LH_free(OPENSSL_LHASH *lh)
{
    unsigned int i;
    OPENSSL_LH_NODE *n, *nn;

    if (lh == NULL)
        return;

    for (i = 0; i < lh->num_nodes; i++) {
        n = lh->b[i];
        while (n != NULL) {
            nn = n->next;
            OPENSSL_free(n);
            n = nn;
        }
    }
    OPENSSL_free(lh->b);
    OPENSSL_free(lh);
}

void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data)
{
    unsigned long hash;
    OPENSSL_LH_NODE *nn, **rn;
    void *ret;

    lh->error = 0;
    if ((lh->up_load <= (lh->num_items * LH_LOAD_MULT / lh->num_nodes)) && !expand(lh))
        return NULL;        /* 'lh->error++' already done in 'expand' */

    rn = getrn(lh, data, &hash);

    if (*rn == NULL) {
        if ((nn = OPENSSL_malloc(sizeof(*nn))) == NULL) {
            lh->error++;
            return NULL;
        }
        nn->data = data;
        nn->next = NULL;
        nn->hash = hash;
        *rn = nn;
        ret = NULL;
        lh->num_insert++;
        lh->num_items++;
    } else {                    /* replace same key */
        ret = (*rn)->data;
        (*rn)->data = data;
        lh->num_replace++;
    }
    return ret;
}

void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data)
{
    unsigned long hash;
    OPENSSL_LH_NODE *nn, **rn;
    void *ret;

    lh->error = 0;
    rn = getrn(lh, data, &hash);

    if (*rn == NULL) {
        lh->num_no_delete++;
        return NULL;
    } else {
        nn = *rn;
        *rn = nn->next;
        ret = nn->data;
        OPENSSL_free(nn);
        lh->num_delete++;
    }

    lh->num_items--;
    if ((lh->num_nodes > MIN_NODES) &&
        (lh->down_load >= (lh->num_items * LH_LOAD_MULT / lh->num_nodes)))
        contract(lh);

    return ret;
}

void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data)
{
    unsigned long hash;
    OPENSSL_LH_NODE **rn;
    void *ret;

    lh->error = 0;
    rn = getrn(lh, data, &hash);

    if (*rn == NULL) {
        lh->num_retrieve_miss++;
        return NULL;
    } else {
        ret = (*rn)->data;
        lh->num_retrieve++;
    }
    return ret;
}

static void doall_util_fn(OPENSSL_LHASH *lh, int use_arg,
                          OPENSSL_LH_DOALL_FUNC func,
                          OPENSSL_LH_DOALL_FUNCARG func_arg, void *arg)
{
    int i;
    OPENSSL_LH_NODE *a, *n;

    if (lh == NULL)
        return;

    /*
     * reverse the order so we search from 'top to bottom' We were having
     * memory leaks otherwise
     */
    for (i = lh->num_nodes - 1; i >= 0; i--) {
        a = lh->b[i];
        while (a != NULL) {
            n = a->next;
            if (use_arg)
                func_arg(a->data, arg);
            else
                func(a->data);
            a = n;
        }
    }
}

void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func)
{
    doall_util_fn(lh, 0, func, (OPENSSL_LH_DOALL_FUNCARG)0, NULL);
}

void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNCARG func, void *arg)
{
    doall_util_fn(lh, 1, (OPENSSL_LH_DOALL_FUNC)0, func, arg);
}

static int expand(OPENSSL_LHASH *lh)
{
    OPENSSL_LH_NODE **n, **n1, **n2, *np;
    unsigned int p, i, j;
    unsigned long hash, nni;

    lh->num_nodes++;
    lh->num_expands++;
    p = (int)lh->p++;
    n1 = &(lh->b[p]);
    n2 = &(lh->b[p + (int)lh->pmax]);
    *n2 = NULL;
    nni = lh->num_alloc_nodes;

    for (np = *n1; np != NULL;) {
        hash = np->hash;
        if ((hash % nni) != p) { /* move it */
            *n1 = (*n1)->next;
            np->next = *n2;
            *n2 = np;
        } else
            n1 = &((*n1)->next);
        np = *n1;
    }

    if ((lh->p) >= lh->pmax) {
        j = (int)lh->num_alloc_nodes * 2;
        n = OPENSSL_realloc(lh->b, (int)(sizeof(OPENSSL_LH_NODE *) * j));
        if (n == NULL) {
            lh->error++;
            lh->num_nodes--;
            lh->p = 0;
            return 0;
        }
        for (i = (int)lh->num_alloc_nodes; i < j; i++) /* 26/02/92 eay */
            n[i] = NULL;        /* 02/03/92 eay */
        lh->pmax = lh->num_alloc_nodes;
        lh->num_alloc_nodes = j;
        lh->num_expand_reallocs++;
        lh->p = 0;
        lh->b = n;
    }
    return 1;
}

static void contract(OPENSSL_LHASH *lh)
{
    OPENSSL_LH_NODE **n, *n1, *np;

    np = lh->b[lh->p + lh->pmax - 1];
    lh->b[lh->p + lh->pmax - 1] = NULL; /* 24/07-92 - eay - weird but :-( */
    if (lh->p == 0) {
        n = OPENSSL_realloc(lh->b,
                            (unsigned int)(sizeof(OPENSSL_LH_NODE *) * lh->pmax));
        if (n == NULL) {
            /* fputs("realloc error in lhash",stderr); */
            lh->error++;
            return;
        }
        lh->num_contract_reallocs++;
        lh->num_alloc_nodes /= 2;
        lh->pmax /= 2;
        lh->p = lh->pmax - 1;
        lh->b = n;
    } else
        lh->p--;

    lh->num_nodes--;
    lh->num_contracts++;

    n1 = lh->b[(int)lh->p];
    if (n1 == NULL)
        lh->b[(int)lh->p] = np;
    else {
        while (n1->next != NULL)
            n1 = n1->next;
        n1->next = np;
    }
}

static OPENSSL_LH_NODE **getrn(OPENSSL_LHASH *lh,
                               const void *data, unsigned long *rhash)
{
    OPENSSL_LH_NODE **ret, *n1;
    unsigned long hash, nn;
    OPENSSL_LH_COMPFUNC cf;

    hash = (*(lh->hash)) (data);
    lh->num_hash_calls++;
    *rhash = hash;

    nn = hash % lh->pmax;
    if (nn < lh->p)
        nn = hash % lh->num_alloc_nodes;

    cf = lh->comp;
    ret = &(lh->b[(int)nn]);
    for (n1 = *ret; n1 != NULL; n1 = n1->next) {
        lh->num_hash_comps++;
        if (n1->hash != hash) {
            ret = &(n1->next);
            continue;
        }
        lh->num_comp_calls++;
        if (cf(n1->data, data) == 0)
            break;
        ret = &(n1->next);
    }
    return ret;
}

/*
 * The following hash seems to work very well on normal text strings no
 * collisions on /usr/dict/words and it distributes on %2^n quite well, not
 * as good as MD5, but still good.
 */
unsigned long OPENSSL_LH_strhash(const char *c)
{
    unsigned long ret = 0;
    long n;
    unsigned long v;
    int r;

    if ((c == NULL) || (*c == '\0'))
        return ret;

    n = 0x100;
    while (*c) {
        v = n | (*c);
        n += 0x100;
        r = (int)((v >> 2) ^ v) & 0x0f;
        ret = (ret << r) | (ret >> (32 - r));
        ret &= 0xFFFFFFFFL;
        ret ^= v * v;
        c++;
    }
    return (ret >> 16) ^ ret;
}

unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh)
{
    return lh ? lh->num_items : 0;
}

unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh)
{
    return lh->down_load;
}

void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load)
{
    lh->down_load = down_load;
}

int OPENSSL_LH_error(OPENSSL_LHASH *lh)
{
    return lh->error;
}
Commit	Line	Data
b1322259	1	/*
2e8b5d75	2	* Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
d02b48c6	3	*
b1322259 RS	4	* Licensed under the OpenSSL license (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
d02b48c6 RE	8	*/
d02b48c6 RE	9
d02b48c6 RE	10	#include <stdio.h>
	11	#include <string.h>
	12	#include <stdlib.h>
ec577822 BM	13	#include <openssl/crypto.h>
ec577822 BM	14	#include <openssl/lhash.h>
739a1eb1 RS	15	#include "lhash_lcl.h"
739a1eb1 RS	16
d02b48c6	17
0f113f3e MC	18	#undef MIN_NODES
	19	#define MIN_NODES 16
	20	#define UP_LOAD (2LH_LOAD_MULT) / load times 256 (default 2) */
	21	#define DOWN_LOAD (LH_LOAD_MULT) /* load times 256 (default 1) */
d02b48c6	22
0a1d3a81	23	static int expand(OPENSSL_LHASH *lh);
739a1eb1 RS	24	static void contract(OPENSSL_LHASH *lh);
739a1eb1 RS	25	static OPENSSL_LH_NODE *getrn(OPENSSL_LHASH lh, const void data, unsigned long rhash);
d02b48c6	26
739a1eb1	27	OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c)
0f113f3e	28	{
739a1eb1	29	OPENSSL_LHASH *ret;
0f113f3e	30
64b25758	31	if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
be606c01	32	return NULL;
64b25758	33	if ((ret->b = OPENSSL_zalloc(sizeof(ret->b) MIN_NODES)) == NULL)
be606c01	34	goto err;
739a1eb1 RS	35	ret->comp = ((c == NULL) ? (OPENSSL_LH_COMPFUNC)strcmp : c);
739a1eb1 RS	36	ret->hash = ((h == NULL) ? (OPENSSL_LH_HASHFUNC)OPENSSL_LH_strhash : h);
0f113f3e MC	37	ret->num_nodes = MIN_NODES / 2;
0f113f3e MC	38	ret->num_alloc_nodes = MIN_NODES;
0f113f3e MC	39	ret->pmax = MIN_NODES / 2;
	40	ret->up_load = UP_LOAD;
	41	ret->down_load = DOWN_LOAD;
2e8b5d75	42	return ret;
64b25758	43
be606c01 RS	44	err:
be606c01 RS	45	OPENSSL_free(ret->b);
0f113f3e	46	OPENSSL_free(ret);
be606c01	47	return NULL;
0f113f3e	48	}
d02b48c6	49
739a1eb1	50	void OPENSSL_LH_free(OPENSSL_LHASH *lh)
0f113f3e MC	51	{
0f113f3e MC	52	unsigned int i;
739a1eb1	53	OPENSSL_LH_NODE n, nn;
0f113f3e MC	54
	55	if (lh == NULL)
	56	return;
	57
	58	for (i = 0; i < lh->num_nodes; i++) {
	59	n = lh->b[i];
	60	while (n != NULL) {
	61	nn = n->next;
	62	OPENSSL_free(n);
	63	n = nn;
	64	}
	65	}
	66	OPENSSL_free(lh->b);
	67	OPENSSL_free(lh);
	68	}
d02b48c6	69
739a1eb1	70	void OPENSSL_LH_insert(OPENSSL_LHASH lh, void *data)
0f113f3e MC	71	{
0f113f3e MC	72	unsigned long hash;
739a1eb1	73	OPENSSL_LH_NODE nn, *rn;
0f113f3e	74	void *ret;
152d2646	75
0f113f3e	76	lh->error = 0;
152d2646	77	if ((lh->up_load <= (lh->num_items * LH_LOAD_MULT / lh->num_nodes)) && !expand(lh))
	78	return NULL; /* 'lh->error++' already done in 'expand' */
	79
0f113f3e MC	80	rn = getrn(lh, data, &hash);
	81
	82	if (*rn == NULL) {
b4faea50	83	if ((nn = OPENSSL_malloc(sizeof(*nn))) == NULL) {
0f113f3e	84	lh->error++;
2e8b5d75	85	return NULL;
0f113f3e MC	86	}
	87	nn->data = data;
	88	nn->next = NULL;
0f113f3e	89	nn->hash = hash;
0f113f3e MC	90	*rn = nn;
	91	ret = NULL;
	92	lh->num_insert++;
	93	lh->num_items++;
	94	} else { /* replace same key */
0f113f3e MC	95	ret = (*rn)->data;
	96	(*rn)->data = data;
	97	lh->num_replace++;
	98	}
2e8b5d75	99	return ret;
0f113f3e	100	}
d02b48c6	101
739a1eb1	102	void OPENSSL_LH_delete(OPENSSL_LHASH lh, const void *data)
0f113f3e MC	103	{
0f113f3e MC	104	unsigned long hash;
739a1eb1	105	OPENSSL_LH_NODE nn, *rn;
0f113f3e MC	106	void *ret;
	107
	108	lh->error = 0;
	109	rn = getrn(lh, data, &hash);
	110
	111	if (*rn == NULL) {
	112	lh->num_no_delete++;
2e8b5d75	113	return NULL;
0f113f3e MC	114	} else {
	115	nn = *rn;
	116	*rn = nn->next;
	117	ret = nn->data;
	118	OPENSSL_free(nn);
	119	lh->num_delete++;
	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)))
	125	contract(lh);
	126
2e8b5d75	127	return ret;
0f113f3e	128	}
d02b48c6	129
739a1eb1	130	void OPENSSL_LH_retrieve(OPENSSL_LHASH lh, const void *data)
0f113f3e MC	131	{
0f113f3e MC	132	unsigned long hash;
739a1eb1	133	OPENSSL_LH_NODE **rn;
0f113f3e MC	134	void *ret;
	135
	136	lh->error = 0;
	137	rn = getrn(lh, data, &hash);
	138
	139	if (*rn == NULL) {
2e8b5d75	140	lh->num_retrieve_miss++;
be606c01	141	return NULL;
0f113f3e MC	142	} else {
0f113f3e MC	143	ret = (*rn)->data;
2e8b5d75	144	lh->num_retrieve++;
0f113f3e	145	}
be606c01	146	return ret;
0f113f3e	147	}
d02b48c6	148
739a1eb1 RS	149	static void doall_util_fn(OPENSSL_LHASH *lh, int use_arg,
	150	OPENSSL_LH_DOALL_FUNC func,
	151	OPENSSL_LH_DOALL_FUNCARG func_arg, void *arg)
0f113f3e MC	152	{
0f113f3e MC	153	int i;
739a1eb1	154	OPENSSL_LH_NODE a, n;
0f113f3e MC	155
	156	if (lh == NULL)
	157	return;
	158
	159	/*
	160	* reverse the order so we search from 'top to bottom' We were having
	161	* memory leaks otherwise
	162	*/
	163	for (i = lh->num_nodes - 1; i >= 0; i--) {
	164	a = lh->b[i];
	165	while (a != NULL) {
0f113f3e MC	166	n = a->next;
	167	if (use_arg)
	168	func_arg(a->data, arg);
	169	else
	170	func(a->data);
	171	a = n;
	172	}
	173	}
	174	}
d02b48c6	175
739a1eb1	176	void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func)
0f113f3e	177	{
739a1eb1	178	doall_util_fn(lh, 0, func, (OPENSSL_LH_DOALL_FUNCARG)0, NULL);
0f113f3e	179	}
18602745	180
739a1eb1	181	void OPENSSL_LH_doall_arg(OPENSSL_LHASH lh, OPENSSL_LH_DOALL_FUNCARG func, void arg)
0f113f3e	182	{
739a1eb1	183	doall_util_fn(lh, 1, (OPENSSL_LH_DOALL_FUNC)0, func, arg);
0f113f3e	184	}
18602745	185
0a1d3a81	186	static int expand(OPENSSL_LHASH *lh)
0f113f3e	187	{
739a1eb1	188	OPENSSL_LH_NODE n, n1, *n2, np;
0f113f3e MC	189	unsigned int p, i, j;
	190	unsigned long hash, nni;
	191
	192	lh->num_nodes++;
	193	lh->num_expands++;
	194	p = (int)lh->p++;
	195	n1 = &(lh->b[p]);
	196	n2 = &(lh->b[p + (int)lh->pmax]);
739a1eb1	197	*n2 = NULL;
0f113f3e MC	198	nni = lh->num_alloc_nodes;
	199
	200	for (np = *n1; np != NULL;) {
0f113f3e	201	hash = np->hash;
0f113f3e MC	202	if ((hash % nni) != p) { /* move it */
	203	n1 = (n1)->next;
	204	np->next = *n2;
	205	*n2 = np;
	206	} else
	207	n1 = &((*n1)->next);
	208	np = *n1;
	209	}
	210
	211	if ((lh->p) >= lh->pmax) {
	212	j = (int)lh->num_alloc_nodes * 2;
739a1eb1	213	n = OPENSSL_realloc(lh->b, (int)(sizeof(OPENSSL_LH_NODE ) j));
0f113f3e	214	if (n == NULL) {
0f113f3e	215	lh->error++;
6fcace45	216	lh->num_nodes--;
0f113f3e	217	lh->p = 0;
152d2646	218	return 0;
0f113f3e	219	}
0f113f3e MC	220	for (i = (int)lh->num_alloc_nodes; i < j; i++) /* 26/02/92 eay */
	221	n[i] = NULL; /* 02/03/92 eay */
	222	lh->pmax = lh->num_alloc_nodes;
	223	lh->num_alloc_nodes = j;
	224	lh->num_expand_reallocs++;
	225	lh->p = 0;
	226	lh->b = n;
	227	}
152d2646	228	return 1;
0f113f3e	229	}
d02b48c6	230
739a1eb1	231	static void contract(OPENSSL_LHASH *lh)
0f113f3e	232	{
739a1eb1	233	OPENSSL_LH_NODE *n, n1, *np;
0f113f3e MC	234
	235	np = lh->b[lh->p + lh->pmax - 1];
	236	lh->b[lh->p + lh->pmax - 1] = NULL; /* 24/07-92 - eay - weird but :-( */
	237	if (lh->p == 0) {
b196e7d9	238	n = OPENSSL_realloc(lh->b,
739a1eb1	239	(unsigned int)(sizeof(OPENSSL_LH_NODE ) lh->pmax));
0f113f3e	240	if (n == NULL) {
b196e7d9	241	/* fputs("realloc error in lhash",stderr); */
0f113f3e MC	242	lh->error++;
	243	return;
	244	}
	245	lh->num_contract_reallocs++;
	246	lh->num_alloc_nodes /= 2;
	247	lh->pmax /= 2;
	248	lh->p = lh->pmax - 1;
	249	lh->b = n;
	250	} else
	251	lh->p--;
	252
	253	lh->num_nodes--;
	254	lh->num_contracts++;
	255
	256	n1 = lh->b[(int)lh->p];
	257	if (n1 == NULL)
	258	lh->b[(int)lh->p] = np;
	259	else {
	260	while (n1->next != NULL)
	261	n1 = n1->next;
	262	n1->next = np;
	263	}
	264	}
d02b48c6	265
739a1eb1 RS	266	static OPENSSL_LH_NODE *getrn(OPENSSL_LHASH lh,
739a1eb1 RS	267	const void data, unsigned long rhash)
0f113f3e	268	{
739a1eb1	269	OPENSSL_LH_NODE *ret, n1;
0f113f3e	270	unsigned long hash, nn;
739a1eb1	271	OPENSSL_LH_COMPFUNC cf;
0f113f3e MC	272
0f113f3e MC	273	hash = (*(lh->hash)) (data);
2e8b5d75	274	lh->num_hash_calls++;
0f113f3e MC	275	*rhash = hash;
	276
	277	nn = hash % lh->pmax;
	278	if (nn < lh->p)
	279	nn = hash % lh->num_alloc_nodes;
	280
	281	cf = lh->comp;
	282	ret = &(lh->b[(int)nn]);
	283	for (n1 = *ret; n1 != NULL; n1 = n1->next) {
2e8b5d75	284	lh->num_hash_comps++;
0f113f3e MC	285	if (n1->hash != hash) {
	286	ret = &(n1->next);
	287	continue;
	288	}
2e8b5d75	289	lh->num_comp_calls++;
0f113f3e MC	290	if (cf(n1->data, data) == 0)
	291	break;
	292	ret = &(n1->next);
	293	}
2e8b5d75	294	return ret;
0f113f3e MC	295	}
	296
	297	/*
	298	* The following hash seems to work very well on normal text strings no
	299	* collisions on /usr/dict/words and it distributes on %2^n quite well, not
	300	* as good as MD5, but still good.
d02b48c6	301	*/
739a1eb1	302	unsigned long OPENSSL_LH_strhash(const char *c)
0f113f3e MC	303	{
	304	unsigned long ret = 0;
	305	long n;
	306	unsigned long v;
	307	int r;
	308
	309	if ((c == NULL) \|\| (*c == '\0'))
2e8b5d75	310	return ret;
d02b48c6	311
0f113f3e MC	312	n = 0x100;
	313	while (*c) {
	314	v = n \| (*c);
	315	n += 0x100;
	316	r = (int)((v >> 2) ^ v) & 0x0f;
	317	ret = (ret << r) \| (ret >> (32 - r));
	318	ret &= 0xFFFFFFFFL;
	319	ret ^= v * v;
	320	c++;
	321	}
2e8b5d75	322	return (ret >> 16) ^ ret;
0f113f3e	323	}
d02b48c6	324
739a1eb1	325	unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh)
0f113f3e MC	326	{
	327	return lh ? lh->num_items : 0;
	328	}
e6b5c341	329
739a1eb1	330	unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh)
e6b5c341 DSH	331	{
	332	return lh->down_load;
	333	}
	334
739a1eb1	335	void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load)
e6b5c341 DSH	336	{
	337	lh->down_load = down_load;
	338	}
	339
739a1eb1	340	int OPENSSL_LH_error(OPENSSL_LHASH *lh)
e6b5c341 DSH	341	{
	342	return lh->error;
	343	}