/src/openssl33/crypto/stack/stack.c

Source
/*
 * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (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 "internal/cryptlib.h"
#include "internal/numbers.h"
#include "internal/safe_math.h"
#include <openssl/stack.h>
#include <errno.h>
#include <openssl/e_os2.h> /* For ossl_inline */

OSSL_SAFE_MATH_SIGNED(int, int)

/*
 * The initial number of nodes in the array.
 */
static const int min_nodes = 4;
static const int max_nodes = SIZE_MAX / sizeof(void *) < INT_MAX
    ? (int)(SIZE_MAX / sizeof(void *))
    : INT_MAX;

struct stack_st {
    int num;
    const void **data;
    int sorted;
    int num_alloc;
    OPENSSL_sk_compfunc comp;
};

OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk,
    OPENSSL_sk_compfunc c)
{
    OPENSSL_sk_compfunc old = sk->comp;

    if (sk->comp != c)
        sk->sorted = 0;
    sk->comp = c;

    return old;
}

OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *sk)
{
    OPENSSL_STACK *ret;

    if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
        goto err;

    if (sk == NULL) {
        ret->num = 0;
        ret->sorted = 0;
        ret->comp = NULL;
    } else {
        /* direct structure assignment */
        *ret = *sk;
    }

    if (sk == NULL || sk->num == 0) {
        /* postpone |ret->data| allocation */
        ret->data = NULL;
        ret->num_alloc = 0;
        return ret;
    }

    /* duplicate |sk->data| content */
    ret->data = OPENSSL_malloc(sizeof(*ret->data) * sk->num_alloc);
    if (ret->data == NULL)
        goto err;
    memcpy(ret->data, sk->data, sizeof(void *) * sk->num);
    return ret;

err:
    OPENSSL_sk_free(ret);
    return NULL;
}

OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *sk,
    OPENSSL_sk_copyfunc copy_func,
    OPENSSL_sk_freefunc free_func)
{
    OPENSSL_STACK *ret;
    int i;

    if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
        goto err;

    if (sk == NULL) {
        ret->num = 0;
        ret->sorted = 0;
        ret->comp = NULL;
    } else {
        /* direct structure assignment */
        *ret = *sk;
    }

    if (sk == NULL || sk->num == 0) {
        /* postpone |ret| data allocation */
        ret->data = NULL;
        ret->num_alloc = 0;
        return ret;
    }

    ret->num_alloc = sk->num > min_nodes ? sk->num : min_nodes;
    ret->data = OPENSSL_zalloc(sizeof(*ret->data) * ret->num_alloc);
    if (ret->data == NULL)
        goto err;

    for (i = 0; i < ret->num; ++i) {
        if (sk->data[i] == NULL)
            continue;
        if ((ret->data[i] = copy_func(sk->data[i])) == NULL) {
            while (--i >= 0)
                if (ret->data[i] != NULL)
                    free_func((void *)ret->data[i]);
            goto err;
        }
    }
    return ret;

err:
    OPENSSL_sk_free(ret);
    return NULL;
}

OPENSSL_STACK *OPENSSL_sk_new_null(void)
{
    return OPENSSL_sk_new_reserve(NULL, 0);
}

OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc c)
{
    return OPENSSL_sk_new_reserve(c, 0);
}

/*
 * Calculate the array growth based on the target size.
 *
 * The growth factor is a rational number and is defined by a numerator
 * and a denominator.  According to Andrew Koenig in his paper "Why Are
 * Vectors Efficient?" from JOOP 11(5) 1998, this factor should be less
 * than the golden ratio (1.618...).
 *
 * Considering only the Fibonacci ratios less than the golden ratio, the
 * number of steps from the minimum allocation to integer overflow is:
 *      factor  decimal    growths
 *       3/2     1.5          51
 *       8/5     1.6          45
 *      21/13    1.615...     44
 *
 * All larger factors have the same number of growths.
 *
 * 3/2 and 8/5 have nice power of two shifts, so seem like a good choice.
 */
static ossl_inline int compute_growth(int target, int current)
{
    int err = 0;

    while (current < target) {
        if (current >= max_nodes)
            return 0;

        current = safe_muldiv_int(current, 8, 5, &err);
        if (err != 0)
            return 0;
        if (current >= max_nodes)
            current = max_nodes;
    }
    return current;
}

/* internal STACK storage allocation */
static int sk_reserve(OPENSSL_STACK *st, int n, int exact)
{
    const void **tmpdata;
    int num_alloc;

    /* Check to see the reservation isn't exceeding the hard limit */
    if (n > max_nodes - st->num) {
        ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_RECORDS);
        return 0;
    }

    /* Figure out the new size */
    num_alloc = st->num + n;
    if (num_alloc < min_nodes)
        num_alloc = min_nodes;

    /* If |st->data| allocation was postponed */
    if (st->data == NULL) {
        /*
         * At this point, |st->num_alloc| and |st->num| are 0;
         * so |num_alloc| value is |n| or |min_nodes| if greater than |n|.
         */
        if ((st->data = OPENSSL_zalloc(sizeof(void *) * num_alloc)) == NULL)
            return 0;
        st->num_alloc = num_alloc;
        return 1;
    }

    if (!exact) {
        if (num_alloc <= st->num_alloc)
            return 1;
        num_alloc = compute_growth(num_alloc, st->num_alloc);
        if (num_alloc == 0) {
            ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_RECORDS);
            return 0;
        }
    } else if (num_alloc == st->num_alloc) {
        return 1;
    }

    tmpdata = OPENSSL_realloc((void *)st->data, sizeof(void *) * num_alloc);
    if (tmpdata == NULL)
        return 0;

    st->data = tmpdata;
    st->num_alloc = num_alloc;
    return 1;
}

OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n)
{
    OPENSSL_STACK *st = OPENSSL_zalloc(sizeof(OPENSSL_STACK));

    if (st == NULL)
        return NULL;

    st->comp = c;

    if (n <= 0)
        return st;

    if (!sk_reserve(st, n, 1)) {
        OPENSSL_sk_free(st);
        return NULL;
    }

    return st;
}

int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n)
{
    if (st == NULL) {
        ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
        return 0;
    }

    if (n < 0)
        return 1;
    return sk_reserve(st, n, 1);
}

int OPENSSL_sk_insert(OPENSSL_STACK *st, const void *data, int loc)
{
    if (st == NULL) {
        ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
        return 0;
    }
    if (st->num == max_nodes) {
        ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_RECORDS);
        return 0;
    }

    if (!sk_reserve(st, 1, 0))
        return 0;

    if ((loc >= st->num) || (loc < 0)) {
        st->data[st->num] = data;
    } else {
        memmove(&st->data[loc + 1], &st->data[loc],
            sizeof(st->data[0]) * (st->num - loc));
        st->data[loc] = data;
    }
    st->num++;
    st->sorted = 0;
    return st->num;
}

static ossl_inline void *internal_delete(OPENSSL_STACK *st, int loc)
{
    const void *ret = st->data[loc];

    if (loc != st->num - 1)
        memmove(&st->data[loc], &st->data[loc + 1],
            sizeof(st->data[0]) * (st->num - loc - 1));
    st->num--;

    return (void *)ret;
}

void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, const void *p)
{
    int i;

    if (st == NULL)
        return NULL;

    for (i = 0; i < st->num; i++)
        if (st->data[i] == p)
            return internal_delete(st, i);
    return NULL;
}

void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc)
{
    if (st == NULL || loc < 0 || loc >= st->num)
        return NULL;

    return internal_delete(st, loc);
}

static int internal_find(OPENSSL_STACK *st, const void *data,
    int ret_val_options, int *pnum_matched)
{
    const void *r;
    int i, count = 0;
    int *pnum = pnum_matched;

    if (st == NULL || st->num == 0)
        return -1;

    if (pnum == NULL)
        pnum = &count;

    if (st->comp == NULL) {
        for (i = 0; i < st->num; i++)
            if (st->data[i] == data) {
                *pnum = 1;
                return i;
            }
        *pnum = 0;
        return -1;
    }

    if (data == NULL)
        return -1;

    if (!st->sorted) {
        int res = -1;

        for (i = 0; i < st->num; i++)
            if (st->comp(&data, st->data + i) == 0) {
                if (res == -1)
                    res = i;
                ++*pnum;
                /* Check if only one result is wanted and exit if so */
                if (pnum_matched == NULL)
                    return i;
            }
        if (res == -1)
            *pnum = 0;
        return res;
    }

    if (pnum_matched != NULL)
        ret_val_options |= OSSL_BSEARCH_FIRST_VALUE_ON_MATCH;
    r = ossl_bsearch(&data, st->data, st->num, sizeof(void *), st->comp,
        ret_val_options);

    if (pnum_matched != NULL) {
        *pnum = 0;
        if (r != NULL) {
            const void **p = (const void **)r;

            while (p < st->data + st->num) {
                if (st->comp(&data, p) != 0)
                    break;
                ++*pnum;
                ++p;
            }
        }
    }

    return r == NULL ? -1 : (int)((const void **)r - st->data);
}

int OPENSSL_sk_find(OPENSSL_STACK *st, const void *data)
{
    return internal_find(st, data, OSSL_BSEARCH_FIRST_VALUE_ON_MATCH, NULL);
}

int OPENSSL_sk_find_ex(OPENSSL_STACK *st, const void *data)
{
    return internal_find(st, data, OSSL_BSEARCH_VALUE_ON_NOMATCH, NULL);
}

int OPENSSL_sk_find_all(OPENSSL_STACK *st, const void *data, int *pnum)
{
    return internal_find(st, data, OSSL_BSEARCH_FIRST_VALUE_ON_MATCH, pnum);
}

int OPENSSL_sk_push(OPENSSL_STACK *st, const void *data)
{
    if (st == NULL)
        return 0;
    return OPENSSL_sk_insert(st, data, st->num);
}

int OPENSSL_sk_unshift(OPENSSL_STACK *st, const void *data)
{
    return OPENSSL_sk_insert(st, data, 0);
}

void *OPENSSL_sk_shift(OPENSSL_STACK *st)
{
    if (st == NULL || st->num == 0)
        return NULL;
    return internal_delete(st, 0);
}

void *OPENSSL_sk_pop(OPENSSL_STACK *st)
{
    if (st == NULL || st->num == 0)
        return NULL;
    return internal_delete(st, st->num - 1);
}

void OPENSSL_sk_zero(OPENSSL_STACK *st)
{
    if (st == NULL || st->num == 0)
        return;
    memset(st->data, 0, sizeof(*st->data) * st->num);
    st->num = 0;
}

void OPENSSL_sk_pop_free(OPENSSL_STACK *st, OPENSSL_sk_freefunc func)
{
    int i;

    if (st == NULL)
        return;
    for (i = 0; i < st->num; i++)
        if (st->data[i] != NULL)
            func((char *)st->data[i]);
    OPENSSL_sk_free(st);
}

void OPENSSL_sk_free(OPENSSL_STACK *st)
{
    if (st == NULL)
        return;
    OPENSSL_free(st->data);
    OPENSSL_free(st);
}

int OPENSSL_sk_num(const OPENSSL_STACK *st)
{
    return st == NULL ? -1 : st->num;
}

void *OPENSSL_sk_value(const OPENSSL_STACK *st, int i)
{
    if (st == NULL || i < 0 || i >= st->num)
        return NULL;
    return (void *)st->data[i];
}

void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, const void *data)
{
    if (st == NULL) {
        ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
        return NULL;
    }
    if (i < 0 || i >= st->num) {
        ERR_raise_data(ERR_LIB_CRYPTO, ERR_R_PASSED_INVALID_ARGUMENT,
            "i=%d", i);
        return NULL;
    }
    st->data[i] = data;
    st->sorted = 0;
    return (void *)st->data[i];
}

void OPENSSL_sk_sort(OPENSSL_STACK *st)
{
    if (st != NULL && !st->sorted && st->comp != NULL) {
        if (st->num > 1)
            qsort(st->data, st->num, sizeof(void *), st->comp);
        st->sorted = 1; /* empty or single-element stack is considered sorted */
    }
}

int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st)
{
    return st == NULL ? 1 : st->sorted;
}

Coverage Report

Created: 2026-07-23 06:28

Line	Count	Source
1		/*
2		* Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (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
8		*/
9
10		#include <stdio.h>
11		#include "internal/cryptlib.h"
12		#include "internal/numbers.h"
13		#include "internal/safe_math.h"
14		#include <openssl/stack.h>
15		#include <errno.h>
16		#include <openssl/e_os2.h> /* For ossl_inline */
17
18		OSSL_SAFE_MATH_SIGNED(int, int)
19
20		/*
21		* The initial number of nodes in the array.
22		*/
23		static const int min_nodes = 4;
24		static const int max_nodes = SIZE_MAX / sizeof(void *) < INT_MAX
25		? (int)(SIZE_MAX / sizeof(void *))
26		: INT_MAX;
27
28		struct stack_st {
29		int num;
30		const void **data;
31		int sorted;
32		int num_alloc;
33		OPENSSL_sk_compfunc comp;
34		};
35
36		OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk,
37		OPENSSL_sk_compfunc c)
38	266k	{
39	266k	OPENSSL_sk_compfunc old = sk->comp;
40
41	266k	if (sk->comp != c)
42	266k	sk->sorted = 0;
43	266k	sk->comp = c;
44
45	266k	return old;
46	266k	}
47
48		OPENSSL_STACK OPENSSL_sk_dup(const OPENSSL_STACK sk)
49	39.1M	{
50	39.1M	OPENSSL_STACK *ret;
51
52	39.1M	if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
53	0	goto err;
54
55	39.1M	if (sk == NULL) {
56	196	ret->num = 0;
57	196	ret->sorted = 0;
58	196	ret->comp = NULL;
59	39.1M	} else {
60		/* direct structure assignment */
61	39.1M	ret = sk;
62	39.1M	}
63
64	39.1M	if (sk == NULL \|\| sk->num == 0) {
65		/* postpone \|ret->data\| allocation */
66	241	ret->data = NULL;
67	241	ret->num_alloc = 0;
68	241	return ret;
69	241	}
70
71		/* duplicate \|sk->data\| content */
72	39.1M	ret->data = OPENSSL_malloc(sizeof(ret->data) sk->num_alloc);
73	39.1M	if (ret->data == NULL)
74	0	goto err;
75	39.1M	memcpy(ret->data, sk->data, sizeof(void ) sk->num);
76	39.1M	return ret;
77
78	0	err:
79	0	OPENSSL_sk_free(ret);
80	0	return NULL;
81	39.1M	}
82
83		OPENSSL_STACK OPENSSL_sk_deep_copy(const OPENSSL_STACK sk,
84		OPENSSL_sk_copyfunc copy_func,
85		OPENSSL_sk_freefunc free_func)
86	1.79M	{
87	1.79M	OPENSSL_STACK *ret;
88	1.79M	int i;
89
90	1.79M	if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
91	0	goto err;
92
93	1.79M	if (sk == NULL) {
94	188	ret->num = 0;
95	188	ret->sorted = 0;
96	188	ret->comp = NULL;
97	1.79M	} else {
98		/* direct structure assignment */
99	1.79M	ret = sk;
100	1.79M	}
101
102	1.79M	if (sk == NULL \|\| sk->num == 0) {
103		/* postpone \|ret\| data allocation */
104	188	ret->data = NULL;
105	188	ret->num_alloc = 0;
106	188	return ret;
107	188	}
108
109	1.79M	ret->num_alloc = sk->num > min_nodes ? sk->num : min_nodes;
110	1.79M	ret->data = OPENSSL_zalloc(sizeof(ret->data) ret->num_alloc);
111	1.79M	if (ret->data == NULL)
112	0	goto err;
113
114	17.6M	for (i = 0; i < ret->num; ++i) {
115	15.8M	if (sk->data[i] == NULL)
116	0	continue;
117	15.8M	if ((ret->data[i] = copy_func(sk->data[i])) == NULL) {
118	0	while (--i >= 0)
119	0	if (ret->data[i] != NULL)
120	0	free_func((void *)ret->data[i]);
121	0	goto err;
122	0	}
123	15.8M	}
124	1.79M	return ret;
125
126	0	err:
127	0	OPENSSL_sk_free(ret);
128	0	return NULL;
129	1.79M	}
130
131		OPENSSL_STACK *OPENSSL_sk_new_null(void)
132	194M	{
133	194M	return OPENSSL_sk_new_reserve(NULL, 0);
134	194M	}
135
136		OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc c)
137	25.5M	{
138	25.5M	return OPENSSL_sk_new_reserve(c, 0);
139	25.5M	}
140
141		/*
142		* Calculate the array growth based on the target size.
143		*
144		* The growth factor is a rational number and is defined by a numerator
145		* and a denominator. According to Andrew Koenig in his paper "Why Are
146		* Vectors Efficient?" from JOOP 11(5) 1998, this factor should be less
147		* than the golden ratio (1.618...).
148		*
149		* Considering only the Fibonacci ratios less than the golden ratio, the
150		* number of steps from the minimum allocation to integer overflow is:
151		* factor decimal growths
152		* 3/2 1.5 51
153		* 8/5 1.6 45
154		* 21/13 1.615... 44
155		*
156		* All larger factors have the same number of growths.
157		*
158		* 3/2 and 8/5 have nice power of two shifts, so seem like a good choice.
159		*/
160		static ossl_inline int compute_growth(int target, int current)
161	5.34M	{
162	5.34M	int err = 0;
163
164	10.6M	while (current < target) {
165	5.34M	if (current >= max_nodes)
166	0	return 0;
167
168	5.34M	current = safe_muldiv_int(current, 8, 5, &err);
169	5.34M	if (err != 0)
170	0	return 0;
171	5.34M	if (current >= max_nodes)
172	0	current = max_nodes;
173	5.34M	}
174	5.34M	return current;
175	5.34M	}
176
177		/* internal STACK storage allocation */
178		static int sk_reserve(OPENSSL_STACK *st, int n, int exact)
179	446M	{
180	446M	const void **tmpdata;
181	446M	int num_alloc;
182
183		/* Check to see the reservation isn't exceeding the hard limit */
184	446M	if (n > max_nodes - st->num) {
185	0	ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_RECORDS);
186	0	return 0;
187	0	}
188
189		/* Figure out the new size */
190	446M	num_alloc = st->num + n;
191	446M	if (num_alloc < min_nodes)
192	40.1M	num_alloc = min_nodes;
193
194		/* If \|st->data\| allocation was postponed */
195	446M	if (st->data == NULL) {
196		/*
197		* At this point, \|st->num_alloc\| and \|st->num\| are 0;
198		* so \|num_alloc\| value is \|n\| or \|min_nodes\| if greater than \|n\|.
199		*/
200	29.0M	if ((st->data = OPENSSL_zalloc(sizeof(void ) num_alloc)) == NULL)
201	0	return 0;
202	29.0M	st->num_alloc = num_alloc;
203	29.0M	return 1;
204	29.0M	}
205
206	417M	if (!exact) {
207	417M	if (num_alloc <= st->num_alloc)
208	407M	return 1;
209	9.15M	num_alloc = compute_growth(num_alloc, st->num_alloc);
210	9.15M	if (num_alloc == 0) {
211	0	ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_RECORDS);
212	0	return 0;
213	0	}
214	9.15M	} else if (num_alloc == st->num_alloc) {
215	0	return 1;
216	0	}
217
218	9.15M	tmpdata = OPENSSL_realloc((void )st->data, sizeof(void ) * num_alloc);
219	9.15M	if (tmpdata == NULL)
220	0	return 0;
221
222	9.15M	st->data = tmpdata;
223	9.15M	st->num_alloc = num_alloc;
224	9.15M	return 1;
225	9.15M	}
226
227		OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n)
228	221M	{
229	221M	OPENSSL_STACK *st = OPENSSL_zalloc(sizeof(OPENSSL_STACK));
230
231	221M	if (st == NULL)
232	0	return NULL;
233
234	221M	st->comp = c;
235
236	221M	if (n <= 0)
237	220M	return st;
238
239	1.02M	if (!sk_reserve(st, n, 1)) {
240	0	OPENSSL_sk_free(st);
241	0	return NULL;
242	0	}
243
244	1.02M	return st;
245	1.02M	}
246
247		int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n)
248	0	{
249	0	if (st == NULL) {
250	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
251	0	return 0;
252	0	}
253
254	0	if (n < 0)
255	0	return 1;
256	0	return sk_reserve(st, n, 1);
257	0	}
258
259		int OPENSSL_sk_insert(OPENSSL_STACK st, const void data, int loc)
260	373M	{
261	373M	if (st == NULL) {
262	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
263	0	return 0;
264	0	}
265	373M	if (st->num == max_nodes) {
266	0	ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_RECORDS);
267	0	return 0;
268	0	}
269
270	373M	if (!sk_reserve(st, 1, 0))
271	0	return 0;
272
273	373M	if ((loc >= st->num) \|\| (loc < 0)) {
274	373M	st->data[st->num] = data;
275	373M	} else {
276	5.19k	memmove(&st->data[loc + 1], &st->data[loc],
277	5.19k	sizeof(st->data[0]) * (st->num - loc));
278	5.19k	st->data[loc] = data;
279	5.19k	}
280	373M	st->num++;
281	373M	st->sorted = 0;
282	373M	return st->num;
283	373M	}
284
285		static ossl_inline void internal_delete(OPENSSL_STACK st, int loc)
286	2.30M	{
287	2.30M	const void *ret = st->data[loc];
288
289	2.30M	if (loc != st->num - 1)
290	260k	memmove(&st->data[loc], &st->data[loc + 1],
291	260k	sizeof(st->data[0]) * (st->num - loc - 1));
292	2.30M	st->num--;
293
294	2.30M	return (void *)ret;
295	2.30M	}
296
297		void OPENSSL_sk_delete_ptr(OPENSSL_STACK st, const void *p)
298	174k	{
299	174k	int i;
300
301	174k	if (st == NULL)
302	0	return NULL;
303
304	710k	for (i = 0; i < st->num; i++)
305	710k	if (st->data[i] == p)
306	174k	return internal_delete(st, i);
307	0	return NULL;
308	174k	}
309
310		void OPENSSL_sk_delete(OPENSSL_STACK st, int loc)
311	269k	{
312	269k	if (st == NULL \|\| loc < 0 \|\| loc >= st->num)
313	0	return NULL;
314
315	269k	return internal_delete(st, loc);
316	269k	}
317
318		static int internal_find(OPENSSL_STACK st, const void data,
319		int ret_val_options, int *pnum_matched)
320	291k	{
321	291k	const void *r;
322	291k	int i, count = 0;
323	291k	int *pnum = pnum_matched;
324
325	291k	if (st == NULL \|\| st->num == 0)
326	109k	return -1;
327
328	182k	if (pnum == NULL)
329	176k	pnum = &count;
330
331	182k	if (st->comp == NULL) {
332	3.07M	for (i = 0; i < st->num; i++)
333	3.07M	if (st->data[i] == data) {
334	28.8k	*pnum = 1;
335	28.8k	return i;
336	28.8k	}
337	2.52k	*pnum = 0;
338	2.52k	return -1;
339	31.4k	}
340
341	150k	if (data == NULL)
342	0	return -1;
343
344	150k	if (!st->sorted) {
345	0	int res = -1;
346
347	0	for (i = 0; i < st->num; i++)
348	0	if (st->comp(&data, st->data + i) == 0) {
349	0	if (res == -1)
350	0	res = i;
351	0	++*pnum;
352		/* Check if only one result is wanted and exit if so */
353	0	if (pnum_matched == NULL)
354	0	return i;
355	0	}
356	0	if (res == -1)
357	0	*pnum = 0;
358	0	return res;
359	0	}
360
361	150k	if (pnum_matched != NULL)
362	5.95k	ret_val_options \|= OSSL_BSEARCH_FIRST_VALUE_ON_MATCH;
363	150k	r = ossl_bsearch(&data, st->data, st->num, sizeof(void *), st->comp,
364	150k	ret_val_options);
365
366	150k	if (pnum_matched != NULL) {
367	5.95k	*pnum = 0;
368	5.95k	if (r != NULL) {
369	4.02k	const void p = (const void )r;
370
371	8.05k	while (p < st->data + st->num) {
372	4.02k	if (st->comp(&data, p) != 0)
373	0	break;
374	4.02k	++*pnum;
375	4.02k	++p;
376	4.02k	}
377	4.02k	}
378	5.95k	}
379
380	150k	return r == NULL ? -1 : (int)((const void **)r - st->data);
381	150k	}
382
383		int OPENSSL_sk_find(OPENSSL_STACK st, const void data)
384	209k	{
385	209k	return internal_find(st, data, OSSL_BSEARCH_FIRST_VALUE_ON_MATCH, NULL);
386	209k	}
387
388		int OPENSSL_sk_find_ex(OPENSSL_STACK st, const void data)
389	0	{
390	0	return internal_find(st, data, OSSL_BSEARCH_VALUE_ON_NOMATCH, NULL);
391	0	}
392
393		int OPENSSL_sk_find_all(OPENSSL_STACK st, const void data, int *pnum)
394	102k	{
395	102k	return internal_find(st, data, OSSL_BSEARCH_FIRST_VALUE_ON_MATCH, pnum);
396	102k	}
397
398		int OPENSSL_sk_push(OPENSSL_STACK st, const void data)
399	444M	{
400	444M	if (st == NULL)
401	0	return 0;
402	444M	return OPENSSL_sk_insert(st, data, st->num);
403	444M	}
404
405		int OPENSSL_sk_unshift(OPENSSL_STACK st, const void data)
406	0	{
407	0	return OPENSSL_sk_insert(st, data, 0);
408	0	}
409
410		void OPENSSL_sk_shift(OPENSSL_STACK st)
411	60	{
412	60	if (st == NULL \|\| st->num == 0)
413	60	return NULL;
414	0	return internal_delete(st, 0);
415	60	}
416
417		void OPENSSL_sk_pop(OPENSSL_STACK st)
418	1.92M	{
419	1.92M	if (st == NULL \|\| st->num == 0)
420	10.0k	return NULL;
421	1.91M	return internal_delete(st, st->num - 1);
422	1.92M	}
423
424		void OPENSSL_sk_zero(OPENSSL_STACK *st)
425	0	{
426	0	if (st == NULL \|\| st->num == 0)
427	0	return;
428	0	memset(st->data, 0, sizeof(st->data) st->num);
429	0	st->num = 0;
430	0	}
431
432		void OPENSSL_sk_pop_free(OPENSSL_STACK *st, OPENSSL_sk_freefunc func)
433	52.7M	{
434	52.7M	int i;
435
436	52.7M	if (st == NULL)
437	11.3M	return;
438	239M	for (i = 0; i < st->num; i++)
439	197M	if (st->data[i] != NULL)
440	197M	func((char *)st->data[i]);
441	41.3M	OPENSSL_sk_free(st);
442	41.3M	}
443
444		void OPENSSL_sk_free(OPENSSL_STACK *st)
445	315M	{
446	315M	if (st == NULL)
447	53.2M	return;
448	261M	OPENSSL_free(st->data);
449	261M	OPENSSL_free(st);
450	261M	}
451
452		int OPENSSL_sk_num(const OPENSSL_STACK *st)
453	1.31G	{
454	1.31G	return st == NULL ? -1 : st->num;
455	1.31G	}
456
457		void OPENSSL_sk_value(const OPENSSL_STACK st, int i)
458	1.39G	{
459	1.39G	if (st == NULL \|\| i < 0 \|\| i >= st->num)
460	5.11k	return NULL;
461	1.39G	return (void *)st->data[i];
462	1.39G	}
463
464		void OPENSSL_sk_set(OPENSSL_STACK st, int i, const void *data)
465	14.3M	{
466	14.3M	if (st == NULL) {
467	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
468	0	return NULL;
469	0	}
470	14.3M	if (i < 0 \|\| i >= st->num) {
471	0	ERR_raise_data(ERR_LIB_CRYPTO, ERR_R_PASSED_INVALID_ARGUMENT,
472	0	"i=%d", i);
473	0	return NULL;
474	0	}
475	14.3M	st->data[i] = data;
476	14.3M	st->sorted = 0;
477	14.3M	return (void *)st->data[i];
478	14.3M	}
479
480		void OPENSSL_sk_sort(OPENSSL_STACK *st)
481	25.6M	{
482	25.6M	if (st != NULL && !st->sorted && st->comp != NULL) {
483	21.5M	if (st->num > 1)
484	301k	qsort(st->data, st->num, sizeof(void *), st->comp);
485	21.5M	st->sorted = 1; /* empty or single-element stack is considered sorted */
486	21.5M	}
487	25.6M	}
488
489		int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st)
490	86.5k	{
491	86.5k	return st == NULL ? 1 : st->sorted;
492	86.5k	}