Annotation of /trunk/qt4/patches/qt-4.8.7-openssl-1.1-2.patch
Parent Directory | Revision Log
Revision 3148 -
(hide annotations)
(download)
Mon Jul 2 08:12:28 2018 UTC (6 years, 2 months ago) by niro
File size: 28628 byte(s)
Mon Jul 2 08:12:28 2018 UTC (6 years, 2 months ago) by niro
File size: 28628 byte(s)
-fedora patch
1 | niro | 3148 | diff -ur qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslcertificate.cpp qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslcertificate.cpp |
2 | --- qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslcertificate.cpp 2015-05-07 16:14:44.000000000 +0200 | ||
3 | +++ qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslcertificate.cpp 2018-01-05 17:44:16.997588265 +0100 | ||
4 | @@ -259,10 +259,10 @@ | ||
5 | QByteArray QSslCertificate::version() const | ||
6 | { | ||
7 | QMutexLocker lock(QMutexPool::globalInstanceGet(d.data())); | ||
8 | - if (d->versionString.isEmpty() && d->x509) | ||
9 | + if (d->versionString.isEmpty() && d->x509) { | ||
10 | d->versionString = | ||
11 | - QByteArray::number(qlonglong(q_ASN1_INTEGER_get(d->x509->cert_info->version)) + 1); | ||
12 | - | ||
13 | + QByteArray::number(qlonglong(q_X509_get_version(d->x509)) + 1); | ||
14 | + } | ||
15 | return d->versionString; | ||
16 | } | ||
17 | |||
18 | @@ -276,7 +276,7 @@ | ||
19 | { | ||
20 | QMutexLocker lock(QMutexPool::globalInstanceGet(d.data())); | ||
21 | if (d->serialNumberString.isEmpty() && d->x509) { | ||
22 | - ASN1_INTEGER *serialNumber = d->x509->cert_info->serialNumber; | ||
23 | + ASN1_INTEGER *serialNumber = q_X509_get_serialNumber(d->x509); | ||
24 | // if we cannot convert to a long, just output the hexadecimal number | ||
25 | if (serialNumber->length > 4) { | ||
26 | QByteArray hexString; | ||
27 | @@ -489,24 +489,33 @@ | ||
28 | QSslKey key; | ||
29 | |||
30 | key.d->type = QSsl::PublicKey; | ||
31 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
32 | X509_PUBKEY *xkey = d->x509->cert_info->key; | ||
33 | +#else | ||
34 | + X509_PUBKEY *xkey = q_X509_get_X509_PUBKEY(d->x509); | ||
35 | +#endif | ||
36 | EVP_PKEY *pkey = q_X509_PUBKEY_get(xkey); | ||
37 | Q_ASSERT(pkey); | ||
38 | |||
39 | - if (q_EVP_PKEY_type(pkey->type) == EVP_PKEY_RSA) { | ||
40 | + int key_id; | ||
41 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
42 | + key_id = q_EVP_PKEY_type(pkey->type); | ||
43 | +#else | ||
44 | + key_id = q_EVP_PKEY_base_id(pkey); | ||
45 | +#endif | ||
46 | + if (key_id == EVP_PKEY_RSA) { | ||
47 | key.d->rsa = q_EVP_PKEY_get1_RSA(pkey); | ||
48 | key.d->algorithm = QSsl::Rsa; | ||
49 | key.d->isNull = false; | ||
50 | - } else if (q_EVP_PKEY_type(pkey->type) == EVP_PKEY_DSA) { | ||
51 | + } else if (key_id == EVP_PKEY_DSA) { | ||
52 | key.d->dsa = q_EVP_PKEY_get1_DSA(pkey); | ||
53 | key.d->algorithm = QSsl::Dsa; | ||
54 | key.d->isNull = false; | ||
55 | - } else if (q_EVP_PKEY_type(pkey->type) == EVP_PKEY_DH) { | ||
56 | + } else if (key_id == EVP_PKEY_DH) { | ||
57 | // DH unsupported | ||
58 | } else { | ||
59 | // error? | ||
60 | } | ||
61 | - | ||
62 | q_EVP_PKEY_free(pkey); | ||
63 | return key; | ||
64 | } | ||
65 | @@ -687,7 +696,11 @@ | ||
66 | unsigned char *data = 0; | ||
67 | int size = q_ASN1_STRING_to_UTF8(&data, q_X509_NAME_ENTRY_get_data(e)); | ||
68 | info[QString::fromUtf8(obj)] = QString::fromUtf8((char*)data, size); | ||
69 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
70 | q_CRYPTO_free(data); | ||
71 | +#else | ||
72 | + q_CRYPTO_free(data, __FILE__, __LINE__); | ||
73 | +#endif | ||
74 | } | ||
75 | return info; | ||
76 | } | ||
77 | diff -ur qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslkey.cpp qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslkey.cpp | ||
78 | --- qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslkey.cpp 2015-05-07 16:14:44.000000000 +0200 | ||
79 | +++ qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslkey.cpp 2018-01-05 18:00:27.453937599 +0100 | ||
80 | @@ -321,8 +321,19 @@ | ||
81 | { | ||
82 | if (d->isNull) | ||
83 | return -1; | ||
84 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
85 | return (d->algorithm == QSsl::Rsa) | ||
86 | ? q_BN_num_bits(d->rsa->n) : q_BN_num_bits(d->dsa->p); | ||
87 | +#else | ||
88 | + if (d->algorithm == QSsl::Rsa) { | ||
89 | + return q_RSA_bits(d->rsa); | ||
90 | + } else { | ||
91 | + const BIGNUM *p = (const BIGNUM *) NULL; | ||
92 | + q_DSA_get0_pqg(d->dsa, &p, (const BIGNUM **) NULL, (const BIGNUM **) NULL); | ||
93 | + return q_BN_num_bits(p); | ||
94 | + } | ||
95 | +#endif | ||
96 | + | ||
97 | } | ||
98 | |||
99 | /*! | ||
100 | diff -ur qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslsocket_openssl.cpp qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslsocket_openssl.cpp | ||
101 | --- qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslsocket_openssl.cpp 2015-05-07 16:14:44.000000000 +0200 | ||
102 | +++ qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslsocket_openssl.cpp 2018-01-05 12:06:06.336990956 +0100 | ||
103 | @@ -93,6 +93,7 @@ | ||
104 | bool QSslSocketPrivate::s_loadedCiphersAndCerts = false; | ||
105 | bool QSslSocketPrivate::s_loadRootCertsOnDemand = false; | ||
106 | |||
107 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
108 | /* \internal | ||
109 | |||
110 | From OpenSSL's thread(3) manual page: | ||
111 | @@ -174,6 +175,8 @@ | ||
112 | } | ||
113 | } // extern "C" | ||
114 | |||
115 | +#endif //OPENSSL_VERSION_NUMBER >= 0x10100000L | ||
116 | + | ||
117 | QSslSocketBackendPrivate::QSslSocketBackendPrivate() | ||
118 | : ssl(0), | ||
119 | ctx(0), | ||
120 | @@ -222,9 +225,12 @@ | ||
121 | ciph.d->encryptionMethod = descriptionList.at(4).mid(4); | ||
122 | ciph.d->exportable = (descriptionList.size() > 6 && descriptionList.at(6) == QLatin1String("export")); | ||
123 | |||
124 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
125 | ciph.d->bits = cipher->strength_bits; | ||
126 | ciph.d->supportedBits = cipher->alg_bits; | ||
127 | - | ||
128 | +#else | ||
129 | + ciph.d->bits = q_SSL_CIPHER_get_bits(cipher, &ciph.d->supportedBits); | ||
130 | +#endif | ||
131 | } | ||
132 | return ciph; | ||
133 | } | ||
134 | @@ -363,7 +369,7 @@ | ||
135 | // | ||
136 | // See also: QSslContext::fromConfiguration() | ||
137 | if (caCertificate.expiryDate() >= QDateTime::currentDateTime()) { | ||
138 | - q_X509_STORE_add_cert(ctx->cert_store, (X509 *)caCertificate.handle()); | ||
139 | + q_X509_STORE_add_cert(q_SSL_CTX_get_cert_store(ctx), (X509 *)caCertificate.handle()); | ||
140 | } | ||
141 | } | ||
142 | |||
143 | @@ -500,8 +506,10 @@ | ||
144 | */ | ||
145 | void QSslSocketPrivate::deinitialize() | ||
146 | { | ||
147 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
148 | q_CRYPTO_set_id_callback(0); | ||
149 | q_CRYPTO_set_locking_callback(0); | ||
150 | +#endif | ||
151 | } | ||
152 | |||
153 | /*! | ||
154 | @@ -522,13 +530,17 @@ | ||
155 | return false; | ||
156 | |||
157 | // Check if the library itself needs to be initialized. | ||
158 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
159 | QMutexLocker locker(openssl_locks()->initLock()); | ||
160 | +#endif | ||
161 | if (!s_libraryLoaded) { | ||
162 | s_libraryLoaded = true; | ||
163 | |||
164 | // Initialize OpenSSL. | ||
165 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
166 | q_CRYPTO_set_id_callback(id_function); | ||
167 | q_CRYPTO_set_locking_callback(locking_function); | ||
168 | +#endif | ||
169 | if (q_SSL_library_init() != 1) | ||
170 | return false; | ||
171 | q_SSL_load_error_strings(); | ||
172 | @@ -567,7 +579,9 @@ | ||
173 | |||
174 | void QSslSocketPrivate::ensureCiphersAndCertsLoaded() | ||
175 | { | ||
176 | - QMutexLocker locker(openssl_locks()->initLock()); | ||
177 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
178 | + QMutexLocker locker(openssl_locks()->initLock()); | ||
179 | +#endif | ||
180 | if (s_loadedCiphersAndCerts) | ||
181 | return; | ||
182 | s_loadedCiphersAndCerts = true; | ||
183 | @@ -659,13 +673,18 @@ | ||
184 | STACK_OF(SSL_CIPHER) *supportedCiphers = q_SSL_get_ciphers(mySsl); | ||
185 | for (int i = 0; i < q_sk_SSL_CIPHER_num(supportedCiphers); ++i) { | ||
186 | if (SSL_CIPHER *cipher = q_sk_SSL_CIPHER_value(supportedCiphers, i)) { | ||
187 | - if (cipher->valid) { | ||
188 | + | ||
189 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
190 | + if (cipher->valid) { | ||
191 | +#endif | ||
192 | QSslCipher ciph = QSslSocketBackendPrivate::QSslCipher_from_SSL_CIPHER(cipher); | ||
193 | if (!ciph.isNull()) { | ||
194 | if (!ciph.name().toLower().startsWith(QLatin1String("adh"))) | ||
195 | ciphers << ciph; | ||
196 | } | ||
197 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
198 | } | ||
199 | +#endif | ||
200 | } | ||
201 | } | ||
202 | |||
203 | diff -ur qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslsocket_openssl_p.h qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslsocket_openssl_p.h | ||
204 | --- qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslsocket_openssl_p.h 2015-05-07 16:14:44.000000000 +0200 | ||
205 | +++ qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslsocket_openssl_p.h 2018-01-05 12:06:06.337990940 +0100 | ||
206 | @@ -84,6 +84,10 @@ | ||
207 | #include <openssl/tls1.h> | ||
208 | #endif | ||
209 | |||
210 | +#if OPENSSL_VERSION_NUMBER >= 0x10100000L | ||
211 | +#define OPENSSL_NO_SSL2 | ||
212 | +#endif | ||
213 | + | ||
214 | #if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
215 | typedef _STACK STACK; | ||
216 | #endif | ||
217 | diff -ur qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslsocket_openssl_symbols.cpp qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslsocket_openssl_symbols.cpp | ||
218 | --- qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslsocket_openssl_symbols.cpp 2015-05-07 16:14:44.000000000 +0200 | ||
219 | +++ qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslsocket_openssl_symbols.cpp 2018-01-05 17:59:10.636973932 +0100 | ||
220 | @@ -111,16 +111,30 @@ | ||
221 | DEFINEFUNC2(int, ASN1_STRING_to_UTF8, unsigned char **a, a, ASN1_STRING *b, b, return 0, return); | ||
222 | DEFINEFUNC4(long, BIO_ctrl, BIO *a, a, int b, b, long c, c, void *d, d, return -1, return) | ||
223 | DEFINEFUNC(int, BIO_free, BIO *a, a, return 0, return) | ||
224 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
225 | DEFINEFUNC(BIO *, BIO_new, BIO_METHOD *a, a, return 0, return) | ||
226 | +#else | ||
227 | +DEFINEFUNC(BIO *, BIO_new, const BIO_METHOD *a, a, return 0, return) | ||
228 | +#endif | ||
229 | DEFINEFUNC2(BIO *, BIO_new_mem_buf, void *a, a, int b, b, return 0, return) | ||
230 | DEFINEFUNC3(int, BIO_read, BIO *a, a, void *b, b, int c, c, return -1, return) | ||
231 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
232 | DEFINEFUNC(BIO_METHOD *, BIO_s_mem, void, DUMMYARG, return 0, return) | ||
233 | +#else | ||
234 | +DEFINEFUNC(const BIO_METHOD *, BIO_s_mem, void, DUMMYARG, return 0, return) | ||
235 | +#endif | ||
236 | DEFINEFUNC3(int, BIO_write, BIO *a, a, const void *b, b, int c, c, return -1, return) | ||
237 | DEFINEFUNC(int, BN_num_bits, const BIGNUM *a, a, return 0, return) | ||
238 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
239 | DEFINEFUNC(int, CRYPTO_num_locks, DUMMYARG, DUMMYARG, return 0, return) | ||
240 | DEFINEFUNC(void, CRYPTO_set_locking_callback, void (*a)(int, int, const char *, int), a, return, DUMMYARG) | ||
241 | DEFINEFUNC(void, CRYPTO_set_id_callback, unsigned long (*a)(), a, return, DUMMYARG) | ||
242 | +#endif | ||
243 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
244 | DEFINEFUNC(void, CRYPTO_free, void *a, a, return, DUMMYARG) | ||
245 | +#else | ||
246 | +DEFINEFUNC3(void, CRYPTO_free, void *a, a, const char *b, b, int c, c, return, DUMMYARG) | ||
247 | +#endif | ||
248 | DEFINEFUNC(void, DSA_free, DSA *a, a, return, DUMMYARG) | ||
249 | #if OPENSSL_VERSION_NUMBER < 0x00908000L | ||
250 | DEFINEFUNC3(X509 *, d2i_X509, X509 **a, a, unsigned char **b, b, long c, c, return 0, return) | ||
251 | @@ -157,6 +171,7 @@ | ||
252 | DEFINEFUNC2(void, RAND_seed, const void *a, a, int b, b, return, DUMMYARG) | ||
253 | DEFINEFUNC(int, RAND_status, void, DUMMYARG, return -1, return) | ||
254 | DEFINEFUNC(void, RSA_free, RSA *a, a, return, DUMMYARG) | ||
255 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
256 | DEFINEFUNC(int, sk_num, STACK *a, a, return -1, return) | ||
257 | DEFINEFUNC2(void, sk_pop_free, STACK *a, a, void (*b)(void*), b, return, DUMMYARG) | ||
258 | #if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
259 | @@ -166,6 +181,12 @@ | ||
260 | DEFINEFUNC(void, sk_free, STACK *a, a, return, DUMMYARG) | ||
261 | DEFINEFUNC2(char *, sk_value, STACK *a, a, int b, b, return 0, return) | ||
262 | #endif | ||
263 | +#else | ||
264 | +DEFINEFUNC(int, OPENSSL_sk_num, STACK *a, a, return -1, return) | ||
265 | +DEFINEFUNC2(void, OPENSSL_sk_pop_free, STACK *a, a, void (*b)(void*), b, return, DUMMYARG) | ||
266 | +DEFINEFUNC(void, OPENSSL_sk_free, _STACK *a, a, return, DUMMYARG) | ||
267 | +DEFINEFUNC2(void *, OPENSSL_sk_value, STACK *a, a, int b, b, return 0, return) | ||
268 | +#endif | ||
269 | DEFINEFUNC(int, SSL_accept, SSL *a, a, return -1, return) | ||
270 | DEFINEFUNC(int, SSL_clear, SSL *a, a, return -1, return) | ||
271 | DEFINEFUNC3(char *, SSL_CIPHER_description, SSL_CIPHER *a, a, char *b, b, int c, c, return 0, return) | ||
272 | @@ -213,8 +234,12 @@ | ||
273 | #else | ||
274 | DEFINEFUNC(long, SSL_get_verify_result, SSL *a, a, return -1, return) | ||
275 | #endif | ||
276 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
277 | DEFINEFUNC(int, SSL_library_init, void, DUMMYARG, return -1, return) | ||
278 | DEFINEFUNC(void, SSL_load_error_strings, void, DUMMYARG, return, DUMMYARG) | ||
279 | +#else | ||
280 | +DEFINEFUNC2(int, OPENSSL_init_ssl, uint64_t opts, opts, const OPENSSL_INIT_SETTINGS *settings, settings, return -1, return) | ||
281 | +#endif | ||
282 | DEFINEFUNC(SSL *, SSL_new, SSL_CTX *a, a, return 0, return) | ||
283 | #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT) | ||
284 | DEFINEFUNC4(long, SSL_ctrl, SSL *a, a, int cmd, cmd, long larg, larg, void *parg, parg, return -1, return) | ||
285 | @@ -229,13 +254,21 @@ | ||
286 | DEFINEFUNC(const SSL_METHOD *, SSLv2_client_method, DUMMYARG, DUMMYARG, return 0, return) | ||
287 | #endif | ||
288 | DEFINEFUNC(const SSL_METHOD *, SSLv3_client_method, DUMMYARG, DUMMYARG, return 0, return) | ||
289 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
290 | DEFINEFUNC(const SSL_METHOD *, SSLv23_client_method, DUMMYARG, DUMMYARG, return 0, return) | ||
291 | +#else | ||
292 | +DEFINEFUNC(const SSL_METHOD *, TLS_client_method, DUMMYARG, DUMMYARG, return 0, return) | ||
293 | +#endif | ||
294 | DEFINEFUNC(const SSL_METHOD *, TLSv1_client_method, DUMMYARG, DUMMYARG, return 0, return) | ||
295 | #ifndef OPENSSL_NO_SSL2 | ||
296 | DEFINEFUNC(const SSL_METHOD *, SSLv2_server_method, DUMMYARG, DUMMYARG, return 0, return) | ||
297 | #endif | ||
298 | DEFINEFUNC(const SSL_METHOD *, SSLv3_server_method, DUMMYARG, DUMMYARG, return 0, return) | ||
299 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
300 | DEFINEFUNC(const SSL_METHOD *, SSLv23_server_method, DUMMYARG, DUMMYARG, return 0, return) | ||
301 | +#else | ||
302 | +DEFINEFUNC(const SSL_METHOD *, TLS_server_method, DUMMYARG, DUMMYARG, return 0, return) | ||
303 | +#endif | ||
304 | DEFINEFUNC(const SSL_METHOD *, TLSv1_server_method, DUMMYARG, DUMMYARG, return 0, return) | ||
305 | #else | ||
306 | DEFINEFUNC(SSL_METHOD *, SSLv2_client_method, DUMMYARG, DUMMYARG, return 0, return) | ||
307 | @@ -274,7 +307,11 @@ | ||
308 | DEFINEFUNC(int, X509_STORE_CTX_get_error, X509_STORE_CTX *a, a, return -1, return) | ||
309 | DEFINEFUNC(int, X509_STORE_CTX_get_error_depth, X509_STORE_CTX *a, a, return -1, return) | ||
310 | DEFINEFUNC(X509 *, X509_STORE_CTX_get_current_cert, X509_STORE_CTX *a, a, return 0, return) | ||
311 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
312 | DEFINEFUNC(STACK_OF(X509) *, X509_STORE_CTX_get_chain, X509_STORE_CTX *a, a, return 0, return) | ||
313 | +#else | ||
314 | +DEFINEFUNC(STACK_OF(X509) *, X509_STORE_CTX_get0_chain, X509_STORE_CTX *a, a, return 0, return) | ||
315 | +#endif | ||
316 | DEFINEFUNC(X509_STORE_CTX *, X509_STORE_CTX_new, DUMMYARG, DUMMYARG, return 0, return) | ||
317 | #ifdef SSLEAY_MACROS | ||
318 | DEFINEFUNC2(int, i2d_DSAPrivateKey, const DSA *a, a, unsigned char **b, b, return -1, return) | ||
319 | @@ -282,10 +319,34 @@ | ||
320 | DEFINEFUNC3(RSA *, d2i_RSAPrivateKey, RSA **a, a, unsigned char **b, b, long c, c, return 0, return) | ||
321 | DEFINEFUNC3(DSA *, d2i_DSAPrivateKey, DSA **a, a, unsigned char **b, b, long c, c, return 0, return) | ||
322 | #endif | ||
323 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
324 | DEFINEFUNC(void, OPENSSL_add_all_algorithms_noconf, void, DUMMYARG, return, DUMMYARG) | ||
325 | DEFINEFUNC(void, OPENSSL_add_all_algorithms_conf, void, DUMMYARG, return, DUMMYARG) | ||
326 | +#else | ||
327 | +DEFINEFUNC2(int, OPENSSL_init_crypto, uint64_t opts, opts, const OPENSSL_INIT_SETTINGS *settings, settings, return -1, return) | ||
328 | +#endif | ||
329 | DEFINEFUNC3(int, SSL_CTX_load_verify_locations, SSL_CTX *ctx, ctx, const char *CAfile, CAfile, const char *CApath, CApath, return 0, return) | ||
330 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
331 | DEFINEFUNC(long, SSLeay, void, DUMMYARG, return 0, return) | ||
332 | +#else | ||
333 | +DEFINEFUNC(unsigned long, OpenSSL_version_num, void, DUMMYARG, return 0, return) | ||
334 | +#endif | ||
335 | +DEFINEFUNC(X509_STORE *, SSL_CTX_get_cert_store, const SSL_CTX *ctx, ctx, return 0, return) | ||
336 | + | ||
337 | +DEFINEFUNC(ASN1_INTEGER *, X509_get_serialNumber, X509 *x, x, return 0, return) | ||
338 | +#if OPENSSL_VERSION_NUMBER >= 0x10100000L | ||
339 | +DEFINEFUNC(int, EVP_PKEY_id, const EVP_PKEY *pkey, pkey, return 0, return) | ||
340 | +DEFINEFUNC(int, EVP_PKEY_base_id, const EVP_PKEY *pkey, pkey, return 0, return) | ||
341 | +DEFINEFUNC2(int, SSL_CIPHER_get_bits, const SSL_CIPHER *cipher, cipher, int *alg_bits, alg_bits, return 0, return) | ||
342 | +DEFINEFUNC2(long, SSL_CTX_set_options, SSL_CTX *ctx, ctx, long options, options, return 0, return) | ||
343 | +DEFINEFUNC(long, X509_get_version, X509 *x, x, return 0, return) | ||
344 | +DEFINEFUNC(X509_PUBKEY *, X509_get_X509_PUBKEY, X509 *x, x, return 0, return) | ||
345 | +DEFINEFUNC(int, RSA_bits, const RSA *rsa, rsa, return 0, return) | ||
346 | +DEFINEFUNC(int, DSA_security_bits, const DSA *dsa, dsa, return 0, return) | ||
347 | +DEFINEFUNC(ASN1_TIME *, X509_getm_notAfter, X509 *x, x, return 0, return) | ||
348 | +DEFINEFUNC(ASN1_TIME *, X509_getm_notBefore, X509 *x, x, return 0, return) | ||
349 | +DEFINEFUNC4(void, DSA_get0_pqg, const DSA *d, d, const BIGNUM **p, p, const BIGNUM **q, q, const BIGNUM **g, g, return, return) | ||
350 | +#endif | ||
351 | |||
352 | #ifdef Q_OS_SYMBIAN | ||
353 | #define RESOLVEFUNC(func, ordinal, lib) \ | ||
354 | @@ -580,7 +641,11 @@ | ||
355 | static volatile bool symbolsResolved = false; | ||
356 | static volatile bool triedToResolveSymbols = false; | ||
357 | #ifndef QT_NO_THREAD | ||
358 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
359 | QMutexLocker locker(QMutexPool::globalInstanceGet((void *)&q_SSL_library_init)); | ||
360 | +#else | ||
361 | + QMutexLocker locker(QMutexPool::globalInstanceGet((void *)&q_OPENSSL_init_ssl)); | ||
362 | +#endif | ||
363 | #endif | ||
364 | if (symbolsResolved) | ||
365 | return true; | ||
366 | @@ -614,9 +679,11 @@ | ||
367 | RESOLVEFUNC(BIO_write, 269, libs.second ) | ||
368 | RESOLVEFUNC(BN_num_bits, 387, libs.second ) | ||
369 | RESOLVEFUNC(CRYPTO_free, 469, libs.second ) | ||
370 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
371 | RESOLVEFUNC(CRYPTO_num_locks, 500, libs.second ) | ||
372 | RESOLVEFUNC(CRYPTO_set_id_callback, 513, libs.second ) | ||
373 | RESOLVEFUNC(CRYPTO_set_locking_callback, 516, libs.second ) | ||
374 | +#endif | ||
375 | RESOLVEFUNC(DSA_free, 594, libs.second ) | ||
376 | RESOLVEFUNC(ERR_error_string, 744, libs.second ) | ||
377 | RESOLVEFUNC(ERR_get_error, 749, libs.second ) | ||
378 | @@ -674,8 +741,10 @@ | ||
379 | RESOLVEFUNC(SSL_get_peer_cert_chain, 117, libs.first ) | ||
380 | RESOLVEFUNC(SSL_get_peer_certificate, 118, libs.first ) | ||
381 | RESOLVEFUNC(SSL_get_verify_result, 132, libs.first ) | ||
382 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
383 | RESOLVEFUNC(SSL_library_init, 137, libs.first ) | ||
384 | RESOLVEFUNC(SSL_load_error_strings, 139, libs.first ) | ||
385 | +#endif | ||
386 | RESOLVEFUNC(SSL_new, 140, libs.first ) | ||
387 | #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT) | ||
388 | RESOLVEFUNC(SSL_ctrl, 95, libs.first ) | ||
389 | @@ -747,9 +816,11 @@ | ||
390 | RESOLVEFUNC(BIO_write) | ||
391 | RESOLVEFUNC(BN_num_bits) | ||
392 | RESOLVEFUNC(CRYPTO_free) | ||
393 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
394 | RESOLVEFUNC(CRYPTO_num_locks) | ||
395 | RESOLVEFUNC(CRYPTO_set_id_callback) | ||
396 | RESOLVEFUNC(CRYPTO_set_locking_callback) | ||
397 | +#endif | ||
398 | RESOLVEFUNC(DSA_free) | ||
399 | RESOLVEFUNC(ERR_error_string) | ||
400 | RESOLVEFUNC(ERR_get_error) | ||
401 | @@ -779,10 +850,17 @@ | ||
402 | RESOLVEFUNC(RAND_seed) | ||
403 | RESOLVEFUNC(RAND_status) | ||
404 | RESOLVEFUNC(RSA_free) | ||
405 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
406 | RESOLVEFUNC(sk_free) | ||
407 | RESOLVEFUNC(sk_num) | ||
408 | RESOLVEFUNC(sk_pop_free) | ||
409 | RESOLVEFUNC(sk_value) | ||
410 | +#else | ||
411 | + RESOLVEFUNC(OPENSSL_sk_free) | ||
412 | + RESOLVEFUNC(OPENSSL_sk_num) | ||
413 | + RESOLVEFUNC(OPENSSL_sk_pop_free) | ||
414 | + RESOLVEFUNC(OPENSSL_sk_value) | ||
415 | +#endif | ||
416 | RESOLVEFUNC(SSL_CIPHER_description) | ||
417 | RESOLVEFUNC(SSL_CTX_check_private_key) | ||
418 | RESOLVEFUNC(SSL_CTX_ctrl) | ||
419 | @@ -797,6 +875,7 @@ | ||
420 | RESOLVEFUNC(SSL_CTX_use_PrivateKey) | ||
421 | RESOLVEFUNC(SSL_CTX_use_RSAPrivateKey) | ||
422 | RESOLVEFUNC(SSL_CTX_use_PrivateKey_file) | ||
423 | + RESOLVEFUNC(SSL_CTX_get_cert_store) | ||
424 | RESOLVEFUNC(SSL_accept) | ||
425 | RESOLVEFUNC(SSL_clear) | ||
426 | RESOLVEFUNC(SSL_connect) | ||
427 | @@ -807,8 +886,12 @@ | ||
428 | RESOLVEFUNC(SSL_get_peer_cert_chain) | ||
429 | RESOLVEFUNC(SSL_get_peer_certificate) | ||
430 | RESOLVEFUNC(SSL_get_verify_result) | ||
431 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
432 | RESOLVEFUNC(SSL_library_init) | ||
433 | RESOLVEFUNC(SSL_load_error_strings) | ||
434 | +#else | ||
435 | + RESOLVEFUNC(OPENSSL_init_ssl) | ||
436 | +#endif | ||
437 | RESOLVEFUNC(SSL_new) | ||
438 | #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT) | ||
439 | RESOLVEFUNC(SSL_ctrl) | ||
440 | @@ -819,17 +902,47 @@ | ||
441 | RESOLVEFUNC(SSL_set_connect_state) | ||
442 | RESOLVEFUNC(SSL_shutdown) | ||
443 | RESOLVEFUNC(SSL_write) | ||
444 | + | ||
445 | + RESOLVEFUNC(X509_get_serialNumber) | ||
446 | +#if OPENSSL_VERSION_NUMBER >= 0x10100000L | ||
447 | + RESOLVEFUNC(SSL_CTX_ctrl) | ||
448 | + RESOLVEFUNC(EVP_PKEY_id) | ||
449 | + RESOLVEFUNC(EVP_PKEY_base_id) | ||
450 | + RESOLVEFUNC(SSL_CIPHER_get_bits) | ||
451 | + RESOLVEFUNC(SSL_CTX_set_options) | ||
452 | + RESOLVEFUNC(X509_get_version) | ||
453 | + RESOLVEFUNC(X509_get_X509_PUBKEY) | ||
454 | + RESOLVEFUNC(RSA_bits) | ||
455 | + RESOLVEFUNC(DSA_security_bits) | ||
456 | + RESOLVEFUNC(DSA_get0_pqg) | ||
457 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
458 | + RESOLVEFUNC(X509_get_notAfter) | ||
459 | + RESOLVEFUNC(X509_get_notBefore) | ||
460 | +#else | ||
461 | + RESOLVEFUNC(X509_getm_notAfter) | ||
462 | + RESOLVEFUNC(X509_getm_notBefore) | ||
463 | +#endif | ||
464 | +#endif | ||
465 | + | ||
466 | #ifndef OPENSSL_NO_SSL2 | ||
467 | RESOLVEFUNC(SSLv2_client_method) | ||
468 | #endif | ||
469 | RESOLVEFUNC(SSLv3_client_method) | ||
470 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
471 | RESOLVEFUNC(SSLv23_client_method) | ||
472 | +#else | ||
473 | + RESOLVEFUNC(TLS_client_method) | ||
474 | +#endif | ||
475 | RESOLVEFUNC(TLSv1_client_method) | ||
476 | #ifndef OPENSSL_NO_SSL2 | ||
477 | RESOLVEFUNC(SSLv2_server_method) | ||
478 | #endif | ||
479 | RESOLVEFUNC(SSLv3_server_method) | ||
480 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
481 | RESOLVEFUNC(SSLv23_server_method) | ||
482 | +#else | ||
483 | + RESOLVEFUNC(TLS_server_method) | ||
484 | +#endif | ||
485 | RESOLVEFUNC(TLSv1_server_method) | ||
486 | RESOLVEFUNC(X509_NAME_entry_count) | ||
487 | RESOLVEFUNC(X509_NAME_get_entry) | ||
488 | @@ -846,7 +959,11 @@ | ||
489 | RESOLVEFUNC(X509_STORE_CTX_get_error) | ||
490 | RESOLVEFUNC(X509_STORE_CTX_get_error_depth) | ||
491 | RESOLVEFUNC(X509_STORE_CTX_get_current_cert) | ||
492 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
493 | RESOLVEFUNC(X509_STORE_CTX_get_chain) | ||
494 | +#else | ||
495 | + RESOLVEFUNC(X509_STORE_CTX_get0_chain) | ||
496 | +#endif | ||
497 | RESOLVEFUNC(X509_cmp) | ||
498 | #ifndef SSLEAY_MACROS | ||
499 | RESOLVEFUNC(X509_dup) | ||
500 | @@ -867,10 +984,18 @@ | ||
501 | RESOLVEFUNC(d2i_DSAPrivateKey) | ||
502 | RESOLVEFUNC(d2i_RSAPrivateKey) | ||
503 | #endif | ||
504 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
505 | RESOLVEFUNC(OPENSSL_add_all_algorithms_noconf) | ||
506 | RESOLVEFUNC(OPENSSL_add_all_algorithms_conf) | ||
507 | +#else | ||
508 | + RESOLVEFUNC(OPENSSL_init_crypto) | ||
509 | +#endif | ||
510 | RESOLVEFUNC(SSL_CTX_load_verify_locations) | ||
511 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
512 | RESOLVEFUNC(SSLeay) | ||
513 | +#else | ||
514 | + RESOLVEFUNC(OpenSSL_version_num) | ||
515 | +#endif | ||
516 | #endif // Q_OS_SYMBIAN | ||
517 | symbolsResolved = true; | ||
518 | delete libs.first; | ||
519 | diff -ur qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslsocket_openssl_symbols_p.h qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslsocket_openssl_symbols_p.h | ||
520 | --- qt-everywhere-opensource-src-4.8.7/src/network/ssl/qsslsocket_openssl_symbols_p.h 2015-05-07 16:14:44.000000000 +0200 | ||
521 | +++ qt-everywhere-opensource-src-4.8.7-openssl-1.1/src/network/ssl/qsslsocket_openssl_symbols_p.h 2018-01-05 17:59:42.041550255 +0100 | ||
522 | @@ -207,16 +207,31 @@ | ||
523 | int q_ASN1_STRING_to_UTF8(unsigned char **a, ASN1_STRING *b); | ||
524 | long q_BIO_ctrl(BIO *a, int b, long c, void *d); | ||
525 | int q_BIO_free(BIO *a); | ||
526 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
527 | BIO *q_BIO_new(BIO_METHOD *a); | ||
528 | +#else | ||
529 | +BIO *q_BIO_new(const BIO_METHOD *a); | ||
530 | +#endif | ||
531 | BIO *q_BIO_new_mem_buf(void *a, int b); | ||
532 | int q_BIO_read(BIO *a, void *b, int c); | ||
533 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
534 | BIO_METHOD *q_BIO_s_mem(); | ||
535 | +#else | ||
536 | +const BIO_METHOD *q_BIO_s_mem(); | ||
537 | +#endif | ||
538 | int q_BIO_write(BIO *a, const void *b, int c); | ||
539 | int q_BN_num_bits(const BIGNUM *a); | ||
540 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
541 | int q_CRYPTO_num_locks(); | ||
542 | void q_CRYPTO_set_locking_callback(void (*a)(int, int, const char *, int)); | ||
543 | void q_CRYPTO_set_id_callback(unsigned long (*a)()); | ||
544 | void q_CRYPTO_free(void *a); | ||
545 | +#else | ||
546 | +#define q_CRYPTO_num_locks() 1 | ||
547 | +#define q_CRYPTO_set_locking_callback(a) | ||
548 | +#define q_CRYPTO_set_id_callback(a) | ||
549 | +void q_CRYPTO_free(void *a, const char *b, int c); | ||
550 | +#endif | ||
551 | void q_DSA_free(DSA *a); | ||
552 | #if OPENSSL_VERSION_NUMBER >= 0x00908000L | ||
553 | // 0.9.8 broke SC and BC by changing this function's signature. | ||
554 | @@ -258,6 +273,7 @@ | ||
555 | void q_RAND_seed(const void *a, int b); | ||
556 | int q_RAND_status(); | ||
557 | void q_RSA_free(RSA *a); | ||
558 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
559 | int q_sk_num(STACK *a); | ||
560 | void q_sk_pop_free(STACK *a, void (*b)(void *)); | ||
561 | #if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
562 | @@ -267,6 +283,16 @@ | ||
563 | void q_sk_free(STACK *a); | ||
564 | char * q_sk_value(STACK *a, int b); | ||
565 | #endif | ||
566 | +#else | ||
567 | +int q_OPENSSL_sk_num(STACK *a); | ||
568 | +void q_OPENSSL_sk_pop_free(STACK *a, void (*b)(void *)); | ||
569 | +void q_OPENSSL_sk_free(_STACK *a); | ||
570 | +void * q_OPENSSL_sk_value(STACK *a, int b); | ||
571 | +#define q_sk_num q_OPENSSL_sk_num | ||
572 | +#define q_sk_pop_free q_OPENSSL_sk_pop_free | ||
573 | +#define q_sk_free q_OPENSSL_sk_free | ||
574 | +#define q_sk_value q_OPENSSL_sk_value | ||
575 | +#endif | ||
576 | int q_SSL_accept(SSL *a); | ||
577 | int q_SSL_clear(SSL *a); | ||
578 | char *q_SSL_CIPHER_description(SSL_CIPHER *a, char *b, int c); | ||
579 | @@ -314,8 +340,14 @@ | ||
580 | #else | ||
581 | long q_SSL_get_verify_result(SSL *a); | ||
582 | #endif | ||
583 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
584 | int q_SSL_library_init(); | ||
585 | void q_SSL_load_error_strings(); | ||
586 | +#else | ||
587 | +int q_OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings); | ||
588 | +#define q_SSL_library_init() q_OPENSSL_init_ssl(0, (const OPENSSL_INIT_SETTINGS *) NULL) | ||
589 | +#define q_SSL_load_error_strings() q_OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, (const OPENSSL_INIT_SETTINGS *) NULL) | ||
590 | +#endif | ||
591 | SSL *q_SSL_new(SSL_CTX *a); | ||
592 | #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT) | ||
593 | long q_SSL_ctrl(SSL *ssl,int cmd, long larg, void *parg); | ||
594 | @@ -328,11 +360,21 @@ | ||
595 | #if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
596 | const SSL_METHOD *q_SSLv2_client_method(); | ||
597 | const SSL_METHOD *q_SSLv3_client_method(); | ||
598 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
599 | const SSL_METHOD *q_SSLv23_client_method(); | ||
600 | +#else | ||
601 | +const SSL_METHOD *q_TLS_client_method(); | ||
602 | +#define q_SSLv23_client_method q_TLS_client_method | ||
603 | +#endif | ||
604 | const SSL_METHOD *q_TLSv1_client_method(); | ||
605 | const SSL_METHOD *q_SSLv2_server_method(); | ||
606 | const SSL_METHOD *q_SSLv3_server_method(); | ||
607 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
608 | const SSL_METHOD *q_SSLv23_server_method(); | ||
609 | +#else | ||
610 | +const SSL_METHOD *q_TLS_server_method(); | ||
611 | +#define q_SSLv23_server_method q_TLS_server_method | ||
612 | +#endif | ||
613 | const SSL_METHOD *q_TLSv1_server_method(); | ||
614 | #else | ||
615 | SSL_METHOD *q_SSLv2_client_method(); | ||
616 | @@ -377,7 +419,12 @@ | ||
617 | int q_X509_STORE_CTX_get_error(X509_STORE_CTX *ctx); | ||
618 | int q_X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx); | ||
619 | X509 *q_X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx); | ||
620 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
621 | STACK_OF(X509) *q_X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx); | ||
622 | +#else | ||
623 | +STACK_OF(X509) *q_X509_STORE_CTX_get0_chain(X509_STORE_CTX *ctx); | ||
624 | +#define q_X509_STORE_CTX_get_chain q_X509_STORE_CTX_get0_chain | ||
625 | +#endif | ||
626 | |||
627 | #define q_BIO_get_mem_data(b, pp) (int)q_BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)pp) | ||
628 | #define q_BIO_pending(b) (int)q_BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL) | ||
629 | @@ -399,7 +446,25 @@ | ||
630 | PEM_ASN1_write_bio((int (*)(void*, unsigned char**))q_i2d_DSAPrivateKey,PEM_STRING_DSA,\ | ||
631 | bp,(char *)x,enc,kstr,klen,cb,u) | ||
632 | #endif | ||
633 | + | ||
634 | +X509_STORE * q_SSL_CTX_get_cert_store(const SSL_CTX *ctx); | ||
635 | +ASN1_INTEGER * q_X509_get_serialNumber(X509 *x); | ||
636 | + | ||
637 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
638 | #define q_SSL_CTX_set_options(ctx,op) q_SSL_CTX_ctrl((ctx),SSL_CTRL_OPTIONS,(op),NULL) | ||
639 | +#define q_X509_get_version(x) X509_get_version(x) | ||
640 | +#else | ||
641 | +int q_EVP_PKEY_id(const EVP_PKEY *pkey); | ||
642 | +int q_EVP_PKEY_base_id(const EVP_PKEY *pkey); | ||
643 | +int q_SSL_CIPHER_get_bits(const SSL_CIPHER *cipher, int *alg_bits); | ||
644 | +long q_SSL_CTX_set_options(SSL_CTX *ctx, long options); | ||
645 | +long q_X509_get_version(X509 *x); | ||
646 | +X509_PUBKEY * q_X509_get_X509_PUBKEY(X509 *x); | ||
647 | +int q_RSA_bits(const RSA *rsa); | ||
648 | +int q_DSA_security_bits(const DSA *dsa); | ||
649 | +void q_DSA_get0_pqg(const DSA *d, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g); | ||
650 | +#endif | ||
651 | + | ||
652 | #define q_SKM_sk_num(type, st) ((int (*)(const STACK_OF(type) *))q_sk_num)(st) | ||
653 | #define q_SKM_sk_value(type, st,i) ((type * (*)(const STACK_OF(type) *, int))q_sk_value)(st, i) | ||
654 | #define q_sk_GENERAL_NAME_num(st) q_SKM_sk_num(GENERAL_NAME, (st)) | ||
655 | @@ -410,8 +475,17 @@ | ||
656 | #define q_sk_SSL_CIPHER_value(st, i) q_SKM_sk_value(SSL_CIPHER, (st), (i)) | ||
657 | #define q_SSL_CTX_add_extra_chain_cert(ctx,x509) \ | ||
658 | q_SSL_CTX_ctrl(ctx,SSL_CTRL_EXTRA_CHAIN_CERT,0,(char *)x509) | ||
659 | + | ||
660 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
661 | #define q_X509_get_notAfter(x) X509_get_notAfter(x) | ||
662 | #define q_X509_get_notBefore(x) X509_get_notBefore(x) | ||
663 | +#else | ||
664 | +ASN1_TIME *q_X509_getm_notAfter(X509 *x); | ||
665 | +ASN1_TIME *q_X509_getm_notBefore(X509 *x); | ||
666 | +#define q_X509_get_notAfter(x) q_X509_getm_notAfter(x) | ||
667 | +#define q_X509_get_notBefore(x) q_X509_getm_notBefore(x) | ||
668 | +#endif | ||
669 | + | ||
670 | #define q_EVP_PKEY_assign_RSA(pkey,rsa) q_EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\ | ||
671 | (char *)(rsa)) | ||
672 | #define q_EVP_PKEY_assign_DSA(pkey,dsa) q_EVP_PKEY_assign((pkey),EVP_PKEY_DSA,\ | ||
673 | @@ -421,10 +495,21 @@ | ||
674 | #else | ||
675 | #define q_OpenSSL_add_all_algorithms() q_OPENSSL_add_all_algorithms_noconf() | ||
676 | #endif | ||
677 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
678 | void q_OPENSSL_add_all_algorithms_noconf(); | ||
679 | void q_OPENSSL_add_all_algorithms_conf(); | ||
680 | +#else | ||
681 | +int q_OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings); | ||
682 | +#define q_OPENSSL_add_all_algorithms_conf() q_OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS | OPENSSL_INIT_LOAD_CONFIG, (const OPENSSL_INIT_SETTINGS *) NULL) | ||
683 | +# define q_OPENSSL_add_all_algorithms_noconf() q_OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS, (const OPENSSL_INIT_SETTINGS *) NULL) | ||
684 | +#endif | ||
685 | int q_SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, const char *CApath); | ||
686 | +#if OPENSSL_VERSION_NUMBER < 0x10100000L | ||
687 | long q_SSLeay(); | ||
688 | +#else | ||
689 | +unsigned long q_OpenSSL_version_num(); | ||
690 | +#define q_SSLeay q_OpenSSL_version_num | ||
691 | +#endif | ||
692 | |||
693 | // Helper function | ||
694 | class QDateTime; |