| 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 | */
|
|---|
| 20 | int 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 | */
|
|---|
| 47 | int 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" */
|
|---|
| 81 | int 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" */
|
|---|
| 100 | int 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 | }
|
|---|
