/src/openssl31/crypto/stack/stack.c

Source (jump to first uncovered line)
/*
 * Copyright 1995-2022 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 <openssl/stack.h>
#include <errno.h>
#include <openssl/e_os2.h>      /* For ossl_inline */

/*
 * 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:
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
    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:
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
    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 fraction 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...).
 *
 * We use 3/2 = 1.5 for simplicity of calculation and overflow checking.
 * Another option 8/5 = 1.6 allows for slightly faster growth, although safe
 * computation is more difficult.
 *
 * The limit to avoid overflow is spot on.  The modulo three correction term
 * ensures that the limit is the largest number than can be expanded by the
 * growth factor without exceeding the hard limit.
 *
 * Do not call it with |current| lower than 2, or it will infinitely loop.
 */
static ossl_inline int compute_growth(int target, int current)
{
    const int limit = (max_nodes / 3) * 2 + (max_nodes % 3 ? 1 : 0);

    while (current < target) {
        /* Check to see if we're at the hard limit */
        if (current >= max_nodes)
            return 0;

        /* Expand the size by a factor of 3/2 if it is within range */
        current = current < limit ? current + current / 2 : 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) {
            ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
            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) {
        ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
        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) {
        ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
        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)
{
    const void *r;
    int i;

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

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

    if (!st->sorted) {
        if (st->num > 1)
            qsort(st->data, st->num, sizeof(void *), st->comp);
        st->sorted = 1; /* empty or single-element stack is considered sorted */
    }
    if (data == NULL)
        return -1;
    if (pnum != 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 != 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 -1;
    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: 2025-06-13 06:58

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 1995-2022 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 <openssl/stack.h>
14		#include <errno.h>
15		#include <openssl/e_os2.h> /* For ossl_inline */
16
17		/*
18		* The initial number of nodes in the array.
19		*/
20		static const int min_nodes = 4;
21		static const int max_nodes = SIZE_MAX / sizeof(void *) < INT_MAX
22		? (int)(SIZE_MAX / sizeof(void *)) : INT_MAX;
23
24		struct stack_st {
25		int num;
26		const void **data;
27		int sorted;
28		int num_alloc;
29		OPENSSL_sk_compfunc comp;
30		};
31
32		OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk,
33		OPENSSL_sk_compfunc c)
34	158k	{
35	158k	OPENSSL_sk_compfunc old = sk->comp;
36
37	158k	if (sk->comp != c)
38	158k	sk->sorted = 0;
39	158k	sk->comp = c;
40
41	158k	return old;
42	158k	}
43
44		OPENSSL_STACK OPENSSL_sk_dup(const OPENSSL_STACK sk)
45	3.43M	{
46	3.43M	OPENSSL_STACK *ret;
47
48	3.43M	if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
49	0	goto err;
50
51	3.43M	if (sk == NULL) {
52	53	ret->num = 0;
53	53	ret->sorted = 0;
54	53	ret->comp = NULL;
55	3.43M	} else {
56		/* direct structure assignment */
57	3.43M	ret = sk;
58	3.43M	}
59
60	3.43M	if (sk == NULL \|\| sk->num == 0) {
61		/* postpone \|ret->data\| allocation */
62	67	ret->data = NULL;
63	67	ret->num_alloc = 0;
64	67	return ret;
65	67	}
66
67		/* duplicate \|sk->data\| content */
68	3.43M	ret->data = OPENSSL_malloc(sizeof(ret->data) sk->num_alloc);
69	3.43M	if (ret->data == NULL)
70	0	goto err;
71	3.43M	memcpy(ret->data, sk->data, sizeof(void ) sk->num);
72	3.43M	return ret;
73
74	0	err:
75	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
76	0	OPENSSL_sk_free(ret);
77	0	return NULL;
78	3.43M	}
79
80		OPENSSL_STACK OPENSSL_sk_deep_copy(const OPENSSL_STACK sk,
81		OPENSSL_sk_copyfunc copy_func,
82		OPENSSL_sk_freefunc free_func)
83	907k	{
84	907k	OPENSSL_STACK *ret;
85	907k	int i;
86
87	907k	if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
88	0	goto err;
89
90	907k	if (sk == NULL) {
91	105	ret->num = 0;
92	105	ret->sorted = 0;
93	105	ret->comp = NULL;
94	907k	} else {
95		/* direct structure assignment */
96	907k	ret = sk;
97	907k	}
98
99	907k	if (sk == NULL \|\| sk->num == 0) {
100		/* postpone \|ret\| data allocation */
101	105	ret->data = NULL;
102	105	ret->num_alloc = 0;
103	105	return ret;
104	105	}
105
106	907k	ret->num_alloc = sk->num > min_nodes ? sk->num : min_nodes;
107	907k	ret->data = OPENSSL_zalloc(sizeof(ret->data) ret->num_alloc);
108	907k	if (ret->data == NULL)
109	0	goto err;
110
111	8.79M	for (i = 0; i < ret->num; ++i) {
112	7.88M	if (sk->data[i] == NULL)
113	0	continue;
114	7.88M	if ((ret->data[i] = copy_func(sk->data[i])) == NULL) {
115	0	while (--i >= 0)
116	0	if (ret->data[i] != NULL)
117	0	free_func((void *)ret->data[i]);
118	0	goto err;
119	0	}
120	7.88M	}
121	907k	return ret;
122
123	0	err:
124	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
125	0	OPENSSL_sk_free(ret);
126	0	return NULL;
127	907k	}
128
129		OPENSSL_STACK *OPENSSL_sk_new_null(void)
130	112M	{
131	112M	return OPENSSL_sk_new_reserve(NULL, 0);
132	112M	}
133
134		OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc c)
135	7.51M	{
136	7.51M	return OPENSSL_sk_new_reserve(c, 0);
137	7.51M	}
138
139		/*
140		* Calculate the array growth based on the target size.
141		*
142		* The growth fraction is a rational number and is defined by a numerator
143		* and a denominator. According to Andrew Koenig in his paper "Why Are
144		* Vectors Efficient?" from JOOP 11(5) 1998, this factor should be less
145		* than the golden ratio (1.618...).
146		*
147		* We use 3/2 = 1.5 for simplicity of calculation and overflow checking.
148		* Another option 8/5 = 1.6 allows for slightly faster growth, although safe
149		* computation is more difficult.
150		*
151		* The limit to avoid overflow is spot on. The modulo three correction term
152		* ensures that the limit is the largest number than can be expanded by the
153		* growth factor without exceeding the hard limit.
154		*
155		* Do not call it with \|current\| lower than 2, or it will infinitely loop.
156		*/
157		static ossl_inline int compute_growth(int target, int current)
158	6.49M	{
159	6.49M	const int limit = (max_nodes / 3) * 2 + (max_nodes % 3 ? 1 : 0);
160
161	12.9M	while (current < target) {
162		/* Check to see if we're at the hard limit */
163	6.49M	if (current >= max_nodes)
164	0	return 0;
165
166		/* Expand the size by a factor of 3/2 if it is within range */
167	6.49M	current = current < limit ? current + current / 2 : max_nodes;
168	6.49M	}
169	6.49M	return current;
170	6.49M	}
171
172		/* internal STACK storage allocation */
173		static int sk_reserve(OPENSSL_STACK *st, int n, int exact)
174	333M	{
175	333M	const void **tmpdata;
176	333M	int num_alloc;
177
178		/* Check to see the reservation isn't exceeding the hard limit */
179	333M	if (n > max_nodes - st->num) {
180	0	ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_RECORDS);
181	0	return 0;
182	0	}
183
184		/* Figure out the new size */
185	333M	num_alloc = st->num + n;
186	333M	if (num_alloc < min_nodes)
187	28.3M	num_alloc = min_nodes;
188
189		/* If \|st->data\| allocation was postponed */
190	333M	if (st->data == NULL) {
191		/*
192		* At this point, \|st->num_alloc\| and \|st->num\| are 0;
193		* so \|num_alloc\| value is \|n\| or \|min_nodes\| if greater than \|n\|.
194		*/
195	18.4M	if ((st->data = OPENSSL_zalloc(sizeof(void ) num_alloc)) == NULL) {
196	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
197	0	return 0;
198	0	}
199	18.4M	st->num_alloc = num_alloc;
200	18.4M	return 1;
201	18.4M	}
202
203	315M	if (!exact) {
204	315M	if (num_alloc <= st->num_alloc)
205	307M	return 1;
206	8.18M	num_alloc = compute_growth(num_alloc, st->num_alloc);
207	8.18M	if (num_alloc == 0) {
208	0	ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_RECORDS);
209	0	return 0;
210	0	}
211	8.18M	} else if (num_alloc == st->num_alloc) {
212	0	return 1;
213	0	}
214
215	8.18M	tmpdata = OPENSSL_realloc((void )st->data, sizeof(void ) * num_alloc);
216	8.18M	if (tmpdata == NULL) {
217	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
218	0	return 0;
219	0	}
220
221	8.18M	st->data = tmpdata;
222	8.18M	st->num_alloc = num_alloc;
223	8.18M	return 1;
224	8.18M	}
225
226		OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n)
227	121M	{
228	121M	OPENSSL_STACK *st = OPENSSL_zalloc(sizeof(OPENSSL_STACK));
229
230	121M	if (st == NULL) {
231	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
232	0	return NULL;
233	0	}
234
235	121M	st->comp = c;
236
237	121M	if (n <= 0)
238	120M	return st;
239
240	1.56M	if (!sk_reserve(st, n, 1)) {
241	0	OPENSSL_sk_free(st);
242	0	return NULL;
243	0	}
244
245	1.56M	return st;
246	1.56M	}
247
248		int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n)
249	0	{
250	0	if (st == NULL) {
251	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
252	0	return 0;
253	0	}
254
255	0	if (n < 0)
256	0	return 1;
257	0	return sk_reserve(st, n, 1);
258	0	}
259
260		int OPENSSL_sk_insert(OPENSSL_STACK st, const void data, int loc)
261	332M	{
262	332M	if (st == NULL) {
263	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
264	0	return 0;
265	0	}
266	332M	if (st->num == max_nodes) {
267	0	ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_RECORDS);
268	0	return 0;
269	0	}
270
271	332M	if (!sk_reserve(st, 1, 0))
272	0	return 0;
273
274	332M	if ((loc >= st->num) \|\| (loc < 0)) {
275	332M	st->data[st->num] = data;
276	332M	} else {
277	3.43k	memmove(&st->data[loc + 1], &st->data[loc],
278	3.43k	sizeof(st->data[0]) * (st->num - loc));
279	3.43k	st->data[loc] = data;
280	3.43k	}
281	332M	st->num++;
282	332M	st->sorted = 0;
283	332M	return st->num;
284	332M	}
285
286		static ossl_inline void internal_delete(OPENSSL_STACK st, int loc)
287	1.34M	{
288	1.34M	const void *ret = st->data[loc];
289
290	1.34M	if (loc != st->num - 1)
291	191k	memmove(&st->data[loc], &st->data[loc + 1],
292	191k	sizeof(st->data[0]) * (st->num - loc - 1));
293	1.34M	st->num--;
294
295	1.34M	return (void *)ret;
296	1.34M	}
297
298		void OPENSSL_sk_delete_ptr(OPENSSL_STACK st, const void *p)
299	162k	{
300	162k	int i;
301
302	162k	if (st == NULL)
303	0	return NULL;
304
305	398k	for (i = 0; i < st->num; i++)
306	398k	if (st->data[i] == p)
307	162k	return internal_delete(st, i);
308	0	return NULL;
309	162k	}
310
311		void OPENSSL_sk_delete(OPENSSL_STACK st, int loc)
312	72.6k	{
313	72.6k	if (st == NULL \|\| loc < 0 \|\| loc >= st->num)
314	0	return NULL;
315
316	72.6k	return internal_delete(st, loc);
317	72.6k	}
318
319		static int internal_find(OPENSSL_STACK st, const void data,
320		int ret_val_options, int *pnum)
321	50.0k	{
322	50.0k	const void *r;
323	50.0k	int i;
324
325	50.0k	if (st == NULL \|\| st->num == 0)
326	19.8k	return -1;
327
328	30.2k	if (st->comp == NULL) {
329	678k	for (i = 0; i < st->num; i++)
330	677k	if (st->data[i] == data) {
331	6.49k	if (pnum != NULL)
332	0	*pnum = 1;
333	6.49k	return i;
334	6.49k	}
335	897	if (pnum != NULL)
336	0	*pnum = 0;
337	897	return -1;
338	7.39k	}
339
340	22.8k	if (!st->sorted) {
341	1.57k	if (st->num > 1)
342	0	qsort(st->data, st->num, sizeof(void *), st->comp);
343	1.57k	st->sorted = 1; /* empty or single-element stack is considered sorted */
344	1.57k	}
345	22.8k	if (data == NULL)
346	0	return -1;
347	22.8k	if (pnum != NULL)
348	4.43k	ret_val_options \|= OSSL_BSEARCH_FIRST_VALUE_ON_MATCH;
349	22.8k	r = ossl_bsearch(&data, st->data, st->num, sizeof(void *), st->comp,
350	22.8k	ret_val_options);
351
352	22.8k	if (pnum != NULL) {
353	4.43k	*pnum = 0;
354	4.43k	if (r != NULL) {
355	3.18k	const void p = (const void )r;
356
357	6.36k	while (p < st->data + st->num) {
358	3.18k	if (st->comp(&data, p) != 0)
359	0	break;
360	3.18k	++*pnum;
361	3.18k	++p;
362	3.18k	}
363	3.18k	}
364	4.43k	}
365
366	22.8k	return r == NULL ? -1 : (int)((const void **)r - st->data);
367	22.8k	}
368
369		int OPENSSL_sk_find(OPENSSL_STACK st, const void data)
370	86.4k	{
371	86.4k	return internal_find(st, data, OSSL_BSEARCH_FIRST_VALUE_ON_MATCH, NULL);
372	86.4k	}
373
374		int OPENSSL_sk_find_ex(OPENSSL_STACK st, const void data)
375	0	{
376	0	return internal_find(st, data, OSSL_BSEARCH_VALUE_ON_NOMATCH, NULL);
377	0	}
378
379		int OPENSSL_sk_find_all(OPENSSL_STACK st, const void data, int *pnum)
380	59.9k	{
381	59.9k	return internal_find(st, data, OSSL_BSEARCH_FIRST_VALUE_ON_MATCH, pnum);
382	59.9k	}
383
384		int OPENSSL_sk_push(OPENSSL_STACK st, const void data)
385	332M	{
386	332M	if (st == NULL)
387	0	return -1;
388	332M	return OPENSSL_sk_insert(st, data, st->num);
389	332M	}
390
391		int OPENSSL_sk_unshift(OPENSSL_STACK st, const void data)
392	0	{
393	0	return OPENSSL_sk_insert(st, data, 0);
394	0	}
395
396		void OPENSSL_sk_shift(OPENSSL_STACK st)
397	0	{
398	0	if (st == NULL \|\| st->num == 0)
399	0	return NULL;
400	0	return internal_delete(st, 0);
401	0	}
402
403		void OPENSSL_sk_pop(OPENSSL_STACK st)
404	1.12M	{
405	1.12M	if (st == NULL \|\| st->num == 0)
406	7.61k	return NULL;
407	1.11M	return internal_delete(st, st->num - 1);
408	1.12M	}
409
410		void OPENSSL_sk_zero(OPENSSL_STACK *st)
411	0	{
412	0	if (st == NULL \|\| st->num == 0)
413	0	return;
414	0	memset(st->data, 0, sizeof(st->data) st->num);
415	0	st->num = 0;
416	0	}
417
418		void OPENSSL_sk_pop_free(OPENSSL_STACK *st, OPENSSL_sk_freefunc func)
419	25.9M	{
420	25.9M	int i;
421
422	25.9M	if (st == NULL)
423	6.84M	return;
424	134M	for (i = 0; i < st->num; i++)
425	115M	if (st->data[i] != NULL)
426	115M	func((char *)st->data[i]);
427	19.1M	OPENSSL_sk_free(st);
428	19.1M	}
429
430		void OPENSSL_sk_free(OPENSSL_STACK *st)
431	158M	{
432	158M	if (st == NULL)
433	32.2M	return;
434	126M	OPENSSL_free(st->data);
435	126M	OPENSSL_free(st);
436	126M	}
437
438		int OPENSSL_sk_num(const OPENSSL_STACK *st)
439	973M	{
440	973M	return st == NULL ? -1 : st->num;
441	973M	}
442
443		void OPENSSL_sk_value(const OPENSSL_STACK st, int i)
444	1.43G	{
445	1.43G	if (st == NULL \|\| i < 0 \|\| i >= st->num)
446	2.20k	return NULL;
447	1.43G	return (void *)st->data[i];
448	1.43G	}
449
450		void OPENSSL_sk_set(OPENSSL_STACK st, int i, const void *data)
451	16.1M	{
452	16.1M	if (st == NULL) {
453	0	ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
454	0	return NULL;
455	0	}
456	16.1M	if (i < 0 \|\| i >= st->num) {
457	0	ERR_raise_data(ERR_LIB_CRYPTO, ERR_R_PASSED_INVALID_ARGUMENT,
458	0	"i=%d", i);
459	0	return NULL;
460	0	}
461	16.1M	st->data[i] = data;
462	16.1M	st->sorted = 0;
463	16.1M	return (void *)st->data[i];
464	16.1M	}
465
466		void OPENSSL_sk_sort(OPENSSL_STACK *st)
467	7.59M	{
468	7.59M	if (st != NULL && !st->sorted && st->comp != NULL) {
469	7.58M	if (st->num > 1)
470	143k	qsort(st->data, st->num, sizeof(void *), st->comp);
471	7.58M	st->sorted = 1; /* empty or single-element stack is considered sorted */
472	7.58M	}
473	7.59M	}
474
475		int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st)
476	44.6k	{
477	44.6k	return st == NULL ? 1 : st->sorted;
478	44.6k	}