1/*
2 * Copyright 2001-2021 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/* We need to use some engine deprecated APIs */
11#define OPENSSL_SUPPRESS_DEPRECATED
12
13#include "e_os.h"
14#include "eng_local.h"
15
16/*
17 * Initialise a engine type for use (or up its functional reference count if
18 * it's already in use). This version is only used internally.
19 */
20int engine_unlocked_init(ENGINE *e)
21{
22    int to_return = 1;
23
24    if ((e->funct_ref == 0) && e->init)
25        /*
26         * This is the first functional reference and the engine requires
27         * initialisation so we do it now.
28         */
29        to_return = e->init(e);
30    if (to_return) {
31        /*
32         * OK, we return a functional reference which is also a structural
33         * reference.
34         */
35        e->struct_ref++;
36        e->funct_ref++;
37        ENGINE_REF_PRINT(e, 0, 1);
38        ENGINE_REF_PRINT(e, 1, 1);
39    }
40    return to_return;
41}
42
43/*
44 * Free a functional reference to a engine type. This version is only used
45 * internally.
46 */
47int engine_unlocked_finish(ENGINE *e, int unlock_for_handlers)
48{
49    int to_return = 1;
50
51    /*
52     * Reduce the functional reference count here so if it's the terminating
53     * case, we can release the lock safely and call the finish() handler
54     * without risk of a race. We get a race if we leave the count until
55     * after and something else is calling "finish" at the same time -
56     * there's a chance that both threads will together take the count from 2
57     * to 0 without either calling finish().
58     */
59    e->funct_ref--;
60    ENGINE_REF_PRINT(e, 1, -1);
61    if ((e->funct_ref == 0) && e->finish) {
62        if (unlock_for_handlers)
63            CRYPTO_THREAD_unlock(global_engine_lock);
64        to_return = e->finish(e);
65        if (unlock_for_handlers)
66            if (!CRYPTO_THREAD_write_lock(global_engine_lock))
67                return 0;
68        if (!to_return)
69            return 0;
70    }
71    REF_ASSERT_ISNT(e->funct_ref < 0);
72    /* Release the structural reference too */
73    if (!engine_free_util(e, 0)) {
74        ERR_raise(ERR_LIB_ENGINE, ENGINE_R_FINISH_FAILED);
75        return 0;
76    }
77    return to_return;
78}
79
80/* The API (locked) version of "init" */
81int ENGINE_init(ENGINE *e)
82{
83    int ret;
84    if (e == NULL) {
85        ERR_raise(ERR_LIB_ENGINE, ERR_R_PASSED_NULL_PARAMETER);
86        return 0;
87    }
88    if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) {
89        ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
90        return 0;
91    }
92    if (!CRYPTO_THREAD_write_lock(global_engine_lock))
93        return 0;
94    ret = engine_unlocked_init(e);
95    CRYPTO_THREAD_unlock(global_engine_lock);
96    return ret;
97}
98
99/* The API (locked) version of "finish" */
100int ENGINE_finish(ENGINE *e)
101{
102    int to_return = 1;
103
104    if (e == NULL)
105        return 1;
106    if (!CRYPTO_THREAD_write_lock(global_engine_lock))
107        return 0;
108    to_return = engine_unlocked_finish(e, 1);
109    CRYPTO_THREAD_unlock(global_engine_lock);
110    if (!to_return) {
111        ERR_raise(ERR_LIB_ENGINE, ENGINE_R_FINISH_FAILED);
112        return 0;
113    }
114    return to_return;
115}
116