1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtNetwork module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include "qsslsocket_openssl_symbols_p.h"

    44 

    45 #include <QtCore/qlibrary.h>

    46 #include <QtCore/qmutex.h>

    47 #include <private/qmutexpool_p.h>

    48 #include <QtCore/qdatetime.h>

    49 #if defined(Q_OS_UNIX)

    50 #include <QtCore/qdir.h>

    51 #endif

    52 

    53 QT_BEGIN_NAMESPACE

    54 

    55 /*

    56     Note to maintainer:

    57     -------------------

    58 

    59     We load OpenSSL symbols dynamically. Because symbols are known to

    60     disappear, and signatures sometimes change, between releases, we need to

    61     be careful about how this is done. To ensure we don't end up dereferencing

    62     null function pointers, and continue running even if certain functions are

    63     missing, we define helper functions for each of the symbols we load from

    64     OpenSSL, all prefixed with "q_" (declared in

    65     qsslsocket_openssl_symbols_p.h). So instead of calling SSL_connect

    66     directly, we call q_SSL_connect, which is a function that checks if the

    67     actual SSL_connect fptr is null, and returns a failure if it is, or calls

    68     SSL_connect if it isn't.

    69 

    70     This requires a somewhat tedious process of declaring each function we

    71     want to call in OpenSSL thrice: once with the q_, in _p.h, once using the

    72     DEFINEFUNC macros below, and once in the function that actually resolves

    73     the symbols, below the DEFINEFUNC declarations below.

    74 

    75     There's one DEFINEFUNC macro declared for every number of arguments

    76     exposed by OpenSSL (feel free to extend when needed). The easiest thing to

    77     do is to find an existing entry that matches the arg count of the function

    78     you want to import, and do the same.

    79 

    80     The first macro arg is the function return type. The second is the

    81     verbatim name of the function/symbol. Then follows a list of N pairs of

    82     argument types with a variable name, and just the variable name (char *a,

    83     a, char *b, b, etc). Finally there's two arguments - a suitable return

    84     statement for the error case (for an int function, return 0 or return -1

    85     is usually right). Then either just "return" or DUMMYARG, the latter being

    86     for void functions.

    87 

    88     Note: Take into account that these macros and declarations are processed

    89     at compile-time, and the result depends on the OpenSSL headers the

    90     compiling host has installed, but the symbols are resolved at run-time,

    91     possibly with a different version of OpenSSL.

    92 */

    93 

    94 #ifdef SSLEAY_MACROS

    95 DEFINEFUNC3(void *, ASN1_dup, i2d_of_void *a, a, d2i_of_void *b, b, char *c, c, return 0, return)

    96 #endif

    97 DEFINEFUNC(long, ASN1_INTEGER_get, ASN1_INTEGER *a, a, return 0, return)

    98 DEFINEFUNC(unsigned char *, ASN1_STRING_data, ASN1_STRING *a, a, return 0, return)

    99 DEFINEFUNC(int, ASN1_STRING_length, ASN1_STRING *a, a, return 0, return)

   100 DEFINEFUNC4(long, BIO_ctrl, BIO *a, a, int b, b, long c, c, void *d, d, return -1, return)

   101 DEFINEFUNC(int, BIO_free, BIO *a, a, return 0, return)

   102 DEFINEFUNC(BIO *, BIO_new, BIO_METHOD *a, a, return 0, return)

   103 DEFINEFUNC2(BIO *, BIO_new_mem_buf, void *a, a, int b, b, return 0, return)

   104 DEFINEFUNC3(int, BIO_read, BIO *a, a, void *b, b, int c, c, return -1, return)

   105 DEFINEFUNC(BIO_METHOD *, BIO_s_mem, void, DUMMYARG, return 0, return)

   106 DEFINEFUNC3(int, BIO_write, BIO *a, a, const void *b, b, int c, c, return -1, return)

   107 DEFINEFUNC(int, BN_num_bits, const BIGNUM *a, a, return 0, return)

   108 DEFINEFUNC(int, CRYPTO_num_locks, DUMMYARG, DUMMYARG, return 0, return)

   109 DEFINEFUNC(void, CRYPTO_set_locking_callback, void (*a)(int, int, const char *, int), a, return, DUMMYARG)

   110 DEFINEFUNC(void, CRYPTO_set_id_callback, unsigned long (*a)(), a, return, DUMMYARG)

   111 DEFINEFUNC(void, CRYPTO_free, void *a, a, return, DUMMYARG)

   112 DEFINEFUNC(void, DSA_free, DSA *a, a, return, DUMMYARG)

   113 #if  OPENSSL_VERSION_NUMBER < 0x00908000L

   114 DEFINEFUNC3(X509 *, d2i_X509, X509 **a, a, unsigned char **b, b, long c, c, return 0, return)

   115 #else // 0.9.8 broke SC and BC by changing this signature.

   116 DEFINEFUNC3(X509 *, d2i_X509, X509 **a, a, const unsigned char **b, b, long c, c, return 0, return)

   117 #endif

   118 DEFINEFUNC2(char *, ERR_error_string, unsigned long a, a, char *b, b, return 0, return)

   119 DEFINEFUNC(unsigned long, ERR_get_error, DUMMYARG, DUMMYARG, return 0, return)

   120 DEFINEFUNC(const EVP_CIPHER *, EVP_des_ede3_cbc, DUMMYARG, DUMMYARG, return 0, return)

   121 DEFINEFUNC3(int, EVP_PKEY_assign, EVP_PKEY *a, a, int b, b, char *c, c, return -1, return)

   122 DEFINEFUNC(void, EVP_PKEY_free, EVP_PKEY *a, a, return, DUMMYARG)

   123 DEFINEFUNC(DSA *, EVP_PKEY_get1_DSA, EVP_PKEY *a, a, return 0, return)

   124 DEFINEFUNC(RSA *, EVP_PKEY_get1_RSA, EVP_PKEY *a, a, return 0, return)

   125 DEFINEFUNC(EVP_PKEY *, EVP_PKEY_new, DUMMYARG, DUMMYARG, return 0, return)

   126 DEFINEFUNC(int, EVP_PKEY_type, int a, a, return NID_undef, return)

   127 DEFINEFUNC2(int, i2d_X509, X509 *a, a, unsigned char **b, b, return -1, return)

   128 DEFINEFUNC(const char *, OBJ_nid2sn, int a, a, return 0, return)

   129 DEFINEFUNC(int, OBJ_obj2nid, const ASN1_OBJECT *a, a, return NID_undef, return)

   130 #ifdef SSLEAY_MACROS

   131 DEFINEFUNC6(void *, PEM_ASN1_read_bio, d2i_of_void *a, a, const char *b, b, BIO *c, c, void **d, d, pem_password_cb *e, e, void *f, f, return 0, return)

   132 DEFINEFUNC6(void *, PEM_ASN1_write_bio, d2i_of_void *a, a, const char *b, b, BIO *c, c, void **d, d, pem_password_cb *e, e, void *f, f, return 0, return)

   133 #else

   134 DEFINEFUNC4(DSA *, PEM_read_bio_DSAPrivateKey, BIO *a, a, DSA **b, b, pem_password_cb *c, c, void *d, d, return 0, return)

   135 DEFINEFUNC4(RSA *, PEM_read_bio_RSAPrivateKey, BIO *a, a, RSA **b, b, pem_password_cb *c, c, void *d, d, return 0, return)

   136 DEFINEFUNC7(int, PEM_write_bio_DSAPrivateKey, BIO *a, a, DSA *b, b, const EVP_CIPHER *c, c, unsigned char *d, d, int e, e, pem_password_cb *f, f, void *g, g, return 0, return)

   137 DEFINEFUNC7(int, PEM_write_bio_RSAPrivateKey, BIO *a, a, RSA *b, b, const EVP_CIPHER *c, c, unsigned char *d, d, int e, e, pem_password_cb *f, f, void *g, g, return 0, return)

   138 #endif

   139 DEFINEFUNC4(DSA *, PEM_read_bio_DSA_PUBKEY, BIO *a, a, DSA **b, b, pem_password_cb *c, c, void *d, d, return 0, return)

   140 DEFINEFUNC4(RSA *, PEM_read_bio_RSA_PUBKEY, BIO *a, a, RSA **b, b, pem_password_cb *c, c, void *d, d, return 0, return)

   141 DEFINEFUNC2(int, PEM_write_bio_DSA_PUBKEY, BIO *a, a, DSA *b, b, return 0, return)

   142 DEFINEFUNC2(int, PEM_write_bio_RSA_PUBKEY, BIO *a, a, RSA *b, b, return 0, return)

   143 DEFINEFUNC2(void, RAND_seed, const void *a, a, int b, b, return, DUMMYARG)

   144 DEFINEFUNC(int, RAND_status, void, DUMMYARG, return -1, return)

   145 DEFINEFUNC(void, RSA_free, RSA *a, a, return, DUMMYARG)

   146 DEFINEFUNC(int, sk_num, STACK *a, a, return -1, return)

   147 DEFINEFUNC2(void, sk_pop_free, STACK *a, a, void (*b)(void*), b, return, DUMMYARG)

   148 #if OPENSSL_VERSION_NUMBER >= 0x10000000L

   149 DEFINEFUNC(void, sk_free, _STACK *a, a, return, DUMMYARG)

   150 DEFINEFUNC2(void *, sk_value, STACK *a, a, int b, b, return 0, return)

   151 #else

   152 DEFINEFUNC(void, sk_free, STACK *a, a, return, DUMMYARG)

   153 DEFINEFUNC2(char *, sk_value, STACK *a, a, int b, b, return 0, return)

   154 #endif

   155 DEFINEFUNC(int, SSL_accept, SSL *a, a, return -1, return)

   156 DEFINEFUNC(int, SSL_clear, SSL *a, a, return -1, return)

   157 DEFINEFUNC3(char *, SSL_CIPHER_description, SSL_CIPHER *a, a, char *b, b, int c, c, return 0, return)

   158 DEFINEFUNC(int, SSL_connect, SSL *a, a, return -1, return)

   159 #if OPENSSL_VERSION_NUMBER >= 0x00908000L

   160 // 0.9.8 broke SC and BC by changing this function's signature.

   161 DEFINEFUNC(int, SSL_CTX_check_private_key, const SSL_CTX *a, a, return -1, return)

   162 #else

   163 DEFINEFUNC(int, SSL_CTX_check_private_key, SSL_CTX *a, a, return -1, return)

   164 #endif

   165 DEFINEFUNC4(long, SSL_CTX_ctrl, SSL_CTX *a, a, int b, b, long c, c, void *d, d, return -1, return)

   166 DEFINEFUNC(void, SSL_CTX_free, SSL_CTX *a, a, return, DUMMYARG)

   167 #if OPENSSL_VERSION_NUMBER >= 0x10000000L

   168 DEFINEFUNC(SSL_CTX *, SSL_CTX_new, const SSL_METHOD *a, a, return 0, return)

   169 #else

   170 DEFINEFUNC(SSL_CTX *, SSL_CTX_new, SSL_METHOD *a, a, return 0, return)

   171 #endif

   172 DEFINEFUNC2(int, SSL_CTX_set_cipher_list, SSL_CTX *a, a, const char *b, b, return -1, return)

   173 DEFINEFUNC(int, SSL_CTX_set_default_verify_paths, SSL_CTX *a, a, return -1, return)

   174 DEFINEFUNC3(void, SSL_CTX_set_verify, SSL_CTX *a, a, int b, b, int (*c)(int, X509_STORE_CTX *), c, return, DUMMYARG)

   175 DEFINEFUNC2(void, SSL_CTX_set_verify_depth, SSL_CTX *a, a, int b, b, return, DUMMYARG)

   176 DEFINEFUNC2(int, SSL_CTX_use_certificate, SSL_CTX *a, a, X509 *b, b, return -1, return)

   177 DEFINEFUNC3(int, SSL_CTX_use_certificate_file, SSL_CTX *a, a, const char *b, b, int c, c, return -1, return)

   178 DEFINEFUNC2(int, SSL_CTX_use_PrivateKey, SSL_CTX *a, a, EVP_PKEY *b, b, return -1, return)

   179 DEFINEFUNC2(int, SSL_CTX_use_RSAPrivateKey, SSL_CTX *a, a, RSA *b, b, return -1, return)

   180 DEFINEFUNC3(int, SSL_CTX_use_PrivateKey_file, SSL_CTX *a, a, const char *b, b, int c, c, return -1, return)

   181 DEFINEFUNC(void, SSL_free, SSL *a, a, return, DUMMYARG)

   182 #if OPENSSL_VERSION_NUMBER >= 0x00908000L

   183 // 0.9.8 broke SC and BC by changing this function's signature.

   184 DEFINEFUNC(STACK_OF(SSL_CIPHER) *, SSL_get_ciphers, const SSL *a, a, return 0, return)

   185 #else

   186 DEFINEFUNC(STACK_OF(SSL_CIPHER) *, SSL_get_ciphers, SSL *a, a, return 0, return)

   187 #endif

   188 #if OPENSSL_VERSION_NUMBER >= 0x10000000L

   189 DEFINEFUNC(const SSL_CIPHER *, SSL_get_current_cipher, SSL *a, a, return 0, return)

   190 #else

   191 DEFINEFUNC(SSL_CIPHER *, SSL_get_current_cipher, SSL *a, a, return 0, return)

   192 #endif

   193 DEFINEFUNC2(int, SSL_get_error, SSL *a, a, int b, b, return -1, return)

   194 DEFINEFUNC(STACK_OF(X509) *, SSL_get_peer_cert_chain, SSL *a, a, return 0, return)

   195 DEFINEFUNC(X509 *, SSL_get_peer_certificate, SSL *a, a, return 0, return)

   196 #if OPENSSL_VERSION_NUMBER >= 0x00908000L

   197 // 0.9.8 broke SC and BC by changing this function's signature.

   198 DEFINEFUNC(long, SSL_get_verify_result, const SSL *a, a, return -1, return)

   199 #else

   200 DEFINEFUNC(long, SSL_get_verify_result, SSL *a, a, return -1, return)

   201 #endif

   202 DEFINEFUNC(int, SSL_library_init, void, DUMMYARG, return -1, return)

   203 DEFINEFUNC(void, SSL_load_error_strings, void, DUMMYARG, return, DUMMYARG)

   204 DEFINEFUNC(SSL *, SSL_new, SSL_CTX *a, a, return 0, return)

   205 DEFINEFUNC3(int, SSL_read, SSL *a, a, void *b, b, int c, c, return -1, return)

   206 DEFINEFUNC3(void, SSL_set_bio, SSL *a, a, BIO *b, b, BIO *c, c, return, DUMMYARG)

   207 DEFINEFUNC(void, SSL_set_accept_state, SSL *a, a, return, DUMMYARG)

   208 DEFINEFUNC(void, SSL_set_connect_state, SSL *a, a, return, DUMMYARG)

   209 DEFINEFUNC(int, SSL_shutdown, SSL *a, a, return -1, return)

   210 #if OPENSSL_VERSION_NUMBER >= 0x10000000L

   211 DEFINEFUNC(const SSL_METHOD *, SSLv2_client_method, DUMMYARG, DUMMYARG, return 0, return)

   212 DEFINEFUNC(const SSL_METHOD *, SSLv3_client_method, DUMMYARG, DUMMYARG, return 0, return)

   213 DEFINEFUNC(const SSL_METHOD *, SSLv23_client_method, DUMMYARG, DUMMYARG, return 0, return)

   214 DEFINEFUNC(const SSL_METHOD *, TLSv1_client_method, DUMMYARG, DUMMYARG, return 0, return)

   215 DEFINEFUNC(const SSL_METHOD *, SSLv2_server_method, DUMMYARG, DUMMYARG, return 0, return)

   216 DEFINEFUNC(const SSL_METHOD *, SSLv3_server_method, DUMMYARG, DUMMYARG, return 0, return)

   217 DEFINEFUNC(const SSL_METHOD *, SSLv23_server_method, DUMMYARG, DUMMYARG, return 0, return)

   218 DEFINEFUNC(const SSL_METHOD *, TLSv1_server_method, DUMMYARG, DUMMYARG, return 0, return)

   219 #else

   220 DEFINEFUNC(SSL_METHOD *, SSLv2_client_method, DUMMYARG, DUMMYARG, return 0, return)

   221 DEFINEFUNC(SSL_METHOD *, SSLv3_client_method, DUMMYARG, DUMMYARG, return 0, return)

   222 DEFINEFUNC(SSL_METHOD *, SSLv23_client_method, DUMMYARG, DUMMYARG, return 0, return)

   223 DEFINEFUNC(SSL_METHOD *, TLSv1_client_method, DUMMYARG, DUMMYARG, return 0, return)

   224 DEFINEFUNC(SSL_METHOD *, SSLv2_server_method, DUMMYARG, DUMMYARG, return 0, return)

   225 DEFINEFUNC(SSL_METHOD *, SSLv3_server_method, DUMMYARG, DUMMYARG, return 0, return)

   226 DEFINEFUNC(SSL_METHOD *, SSLv23_server_method, DUMMYARG, DUMMYARG, return 0, return)

   227 DEFINEFUNC(SSL_METHOD *, TLSv1_server_method, DUMMYARG, DUMMYARG, return 0, return)

   228 #endif

   229 DEFINEFUNC3(int, SSL_write, SSL *a, a, const void *b, b, int c, c, return -1, return)

   230 DEFINEFUNC2(int, X509_cmp, X509 *a, a, X509 *b, b, return -1, return)

   231 #ifndef SSLEAY_MACROS

   232 DEFINEFUNC(X509 *, X509_dup, X509 *a, a, return 0, return)

   233 #endif

   234 DEFINEFUNC(ASN1_OBJECT *, X509_EXTENSION_get_object, X509_EXTENSION *a, a, return 0, return)

   235 DEFINEFUNC(void, X509_free, X509 *a, a, return, DUMMYARG)

   236 DEFINEFUNC2(X509_EXTENSION *, X509_get_ext, X509 *a, a, int b, b, return 0, return)

   237 DEFINEFUNC(int, X509_get_ext_count, X509 *a, a, return 0, return)

   238 DEFINEFUNC4(void *, X509_get_ext_d2i, X509 *a, a, int b, b, int *c, c, int *d, d, return 0, return)

   239 DEFINEFUNC(X509_NAME *, X509_get_issuer_name, X509 *a, a, return 0, return)

   240 DEFINEFUNC(X509_NAME *, X509_get_subject_name, X509 *a, a, return 0, return)

   241 DEFINEFUNC(int, X509_verify_cert, X509_STORE_CTX *a, a, return -1, return)

   242 DEFINEFUNC3(char *, X509_NAME_oneline, X509_NAME *a, a, char *b, b, int c, c, return 0, return)

   243 DEFINEFUNC(EVP_PKEY *, X509_PUBKEY_get, X509_PUBKEY *a, a, return 0, return)

   244 DEFINEFUNC(void, X509_STORE_free, X509_STORE *a, a, return, DUMMYARG)

   245 DEFINEFUNC(X509_STORE *, X509_STORE_new, DUMMYARG, DUMMYARG, return 0, return)

   246 DEFINEFUNC2(int, X509_STORE_add_cert, X509_STORE *a, a, X509 *b, b, return 0, return)

   247 DEFINEFUNC(void, X509_STORE_CTX_free, X509_STORE_CTX *a, a, return, DUMMYARG)

   248 DEFINEFUNC4(int, X509_STORE_CTX_init, X509_STORE_CTX *a, a, X509_STORE *b, b, X509 *c, c, STACK_OF(X509) *d, d, return -1, return)

   249 DEFINEFUNC2(int, X509_STORE_CTX_set_purpose, X509_STORE_CTX *a, a, int b, b, return -1, return)

   250 DEFINEFUNC(X509_STORE_CTX *, X509_STORE_CTX_new, DUMMYARG, DUMMYARG, return 0, return)

   251 #ifdef SSLEAY_MACROS

   252 DEFINEFUNC2(int, i2d_DSAPrivateKey, const DSA *a, a, unsigned char **b, b, return -1, return)

   253 DEFINEFUNC2(int, i2d_RSAPrivateKey, const RSA *a, a, unsigned char **b, b, return -1, return)

   254 DEFINEFUNC3(RSA *, d2i_RSAPrivateKey, RSA **a, a, unsigned char **b, b, long c, c, return 0, return)

   255 DEFINEFUNC3(DSA *, d2i_DSAPrivateKey, DSA **a, a, unsigned char **b, b, long c, c, return 0, return)

   256 #endif

   257 DEFINEFUNC(void, OPENSSL_add_all_algorithms_noconf, void, DUMMYARG, return, DUMMYARG)

   258 DEFINEFUNC(void, OPENSSL_add_all_algorithms_conf, void, DUMMYARG, return, DUMMYARG)

   259 

   260 #ifdef Q_OS_SYMBIAN

   261 #define RESOLVEFUNC(func, ordinal, lib) \

   262     if (!(_q_##func = _q_PTR_##func(lib->resolve(#ordinal)))) \

   263         qWarning("QSslSocket: cannot resolve "#func);

   264 #else

   265 #define RESOLVEFUNC(func) \

   266     if (!(_q_##func = _q_PTR_##func(libs.first->resolve(#func)))     \

   267         && !(_q_##func = _q_PTR_##func(libs.second->resolve(#func)))) \

   268         qWarning("QSslSocket: cannot resolve "#func);

   269 #endif

   270 

   271 #if !defined QT_LINKED_OPENSSL

   272 

   273 #ifdef QT_NO_LIBRARY

   274 bool q_resolveOpenSslSymbols()

   275 {

   276     qWarning("QSslSocket: unable to resolve symbols. "

   277              "QT_NO_LIBRARY is defined which means runtime resolving of "

   278              "libraries won't work.");

   279     qWarning("Either compile Qt statically or with support for runtime resolving "

   280              "of libraries.");

   281     return false;

   282 }

   283 #else

   284 

   285 # ifdef Q_OS_UNIX

   286 static bool libGreaterThan(const QString &lhs, const QString &rhs)

   287 {

   288     QStringList lhsparts = lhs.split(QLatin1Char('.'));

   289     QStringList rhsparts = rhs.split(QLatin1Char('.'));

   290     Q_ASSERT(lhsparts.count() > 1 && rhsparts.count() > 1);

   291 

   292     for (int i = 1; i < rhsparts.count(); ++i) {

   293         if (lhsparts.count() <= i)

   294             // left hand side is shorter, so it's less than rhs

   295             return false;

   296 

   297         bool ok = false;

   298         int b = 0;

   299         int a = lhsparts.at(i).toInt(&ok);

   300         if (ok)

   301             b = rhsparts.at(i).toInt(&ok);

   302         if (ok) {

   303             // both toInt succeeded

   304             if (a == b)

   305                 continue;

   306             return a > b;

   307         } else {

   308             // compare as strings;

   309             if (lhsparts.at(i) == rhsparts.at(i))

   310                 continue;

   311             return lhsparts.at(i) > rhsparts.at(i);

   312         }

   313     }

   314 

   315     // they compared strictly equally so far

   316     // lhs cannot be less than rhs

   317     return true;

   318 }

   319 

   320 static QStringList findAllLibSsl()

   321 {

   322     QStringList paths;

   323 #  ifdef Q_OS_DARWIN

   324     paths = QString::fromLatin1(qgetenv("DYLD_LIBRARY_PATH"))

   325             .split(QLatin1Char(':'), QString::SkipEmptyParts);

   326 #  else

   327     paths = QString::fromLatin1(qgetenv("LD_LIBRARY_PATH"))

   328             .split(QLatin1Char(':'), QString::SkipEmptyParts);

   329 #  endif

   330     paths << QLatin1String("/usr/lib") << QLatin1String("/usr/local/lib");

   331 

   332     QStringList foundSsls;

   333     foreach (const QString &path, paths) {

   334         QDir dir = QDir(path);

   335         QStringList entryList = dir.entryList(QStringList() << QLatin1String("libssl.*"), QDir::Files);

   336 

   337         qSort(entryList.begin(), entryList.end(), libGreaterThan);

   338         foreach (const QString &entry, entryList)

   339             foundSsls << path + QLatin1Char('/') + entry;

   340     }

   341 

   342     return foundSsls;

   343 }

   344 # endif

   345 

   346 static QPair<QLibrary*, QLibrary*> loadOpenSsl()

   347 {

   348     QPair<QLibrary*,QLibrary*> pair;

   349     pair.first = 0;

   350     pair.second = 0;

   351 

   352 # ifdef Q_OS_WIN

   353     QLibrary *ssleay32 = new QLibrary(QLatin1String("ssleay32"));

   354     if (!ssleay32->load()) {

   355         // Cannot find ssleay32.dll

   356         delete ssleay32;

   357         return pair;

   358     }

   359 

   360     QLibrary *libeay32 = new QLibrary(QLatin1String("libeay32"));

   361     if (!libeay32->load()) {

   362         delete ssleay32;

   363         delete libeay32;

   364         return pair;

   365     }

   366 

   367     pair.first = ssleay32;

   368     pair.second = libeay32;

   369     return pair;

   370 # elif defined(Q_OS_SYMBIAN)

   371      QLibrary *libssl = new QLibrary(QLatin1String("libssl"));

   372     if (!libssl->load()) {

   373         // Cannot find ssleay32.dll

   374         delete libssl;

   375         return pair;

   376     }

   377 

   378     QLibrary *libcrypto = new QLibrary(QLatin1String("libcrypto"));

   379     if (!libcrypto->load()) {

   380         delete libcrypto;

   381         delete libssl;

   382         return pair;

   383     }

   384 

   385     pair.first = libssl;

   386     pair.second = libcrypto;

   387     return pair;

   388 # elif defined(Q_OS_UNIX)

   389     QLibrary *&libssl = pair.first;

   390     QLibrary *&libcrypto = pair.second;

   391     libssl = new QLibrary;

   392     libcrypto = new QLibrary;

   393 

   394     // Try to find the libssl library on the system.

   395     //

   396     // Up until Qt 4.3, this only searched for the "ssl" library at version -1, that

   397     // is, libssl.so on most Unix systems.  However, the .so file isn't present in

   398     // user installations because it's considered a development file.

   399     //

   400     // The right thing to do is to load the library at the major version we know how

   401     // to work with: the SHLIB_VERSION_NUMBER version (macro defined in opensslv.h)

   402     //

   403     // However, OpenSSL is a well-known case of binary-compatibility breakage. To

   404     // avoid such problems, many system integrators and Linux distributions change

   405     // the soname of the binary, letting the full version number be the soname. So

   406     // we'll find libssl.so.0.9.7, libssl.so.0.9.8, etc. in the system. For that

   407     // reason, we will search a few common paths (see findAllLibSsl() above) in hopes

   408     // we find one that works.

   409     //

   410     // It is important, however, to try the canonical name and the unversioned name

   411     // without going through the loop. By not specifying a path, we let the system

   412     // dlopen(3) function determine it for us. This will include any DT_RUNPATH or

   413     // DT_RPATH tags on our library header as well as other system-specific search

   414     // paths. See the man page for dlopen(3) on your system for more information.

   415 

   416 #ifdef Q_OS_OPENBSD

   417     libcrypto->setLoadHints(QLibrary::ExportExternalSymbolsHint);

   418 #endif

   419 #ifdef SHLIB_VERSION_NUMBER

   420     // first attempt: the canonical name is libssl.so.<SHLIB_VERSION_NUMBER>

   421     libssl->setFileNameAndVersion(QLatin1String("ssl"), QLatin1String(SHLIB_VERSION_NUMBER));

   422     libcrypto->setFileNameAndVersion(QLatin1String("crypto"), QLatin1String(SHLIB_VERSION_NUMBER));

   423     if (libcrypto->load() && libssl->load()) {

   424         // libssl.so.<SHLIB_VERSION_NUMBER> and libcrypto.so.<SHLIB_VERSION_NUMBER> found

   425         return pair;

   426     } else {

   427         libssl->unload();

   428         libcrypto->unload();

   429     }

   430 #endif

   431 

   432     // second attempt: find the development files libssl.so and libcrypto.so

   433     libssl->setFileNameAndVersion(QLatin1String("ssl"), -1);

   434     libcrypto->setFileNameAndVersion(QLatin1String("crypto"), -1);

   435     if (libcrypto->load() && libssl->load()) {

   436         // libssl.so.0 and libcrypto.so.0 found

   437         return pair;

   438     } else {

   439         libssl->unload();

   440         libcrypto->unload();

   441     }

   442 

   443     // third attempt: loop on the most common library paths and find libssl

   444     QStringList sslList = findAllLibSsl();

   445     foreach (const QString &ssl, sslList) {

   446         QString crypto = ssl;

   447         crypto.replace(QLatin1String("ssl"), QLatin1String("crypto"));

   448         libssl->setFileNameAndVersion(ssl, -1);

   449         libcrypto->setFileNameAndVersion(crypto, -1);

   450         if (libcrypto->load() && libssl->load()) {

   451             // libssl.so.0 and libcrypto.so.0 found

   452             return pair;

   453         } else {

   454             libssl->unload();

   455             libcrypto->unload();

   456         }

   457     }

   458 

   459     // failed to load anything

   460     delete libssl;

   461     delete libcrypto;

   462     libssl = libcrypto = 0;

   463     return pair;

   464 

   465 # else

   466     // not implemented for this platform yet

   467     return pair;

   468 # endif

   469 }

   470 

   471 bool q_resolveOpenSslSymbols()

   472 {

   473     static volatile bool symbolsResolved = false;

   474     static volatile bool triedToResolveSymbols = false;

   475 #ifndef QT_NO_THREAD

   476     QMutexLocker locker(QMutexPool::globalInstanceGet((void *)&q_SSL_library_init));

   477 #endif

   478     if (symbolsResolved)

   479         return true;

   480     if (triedToResolveSymbols)

   481         return false;

   482     triedToResolveSymbols = true;

   483 

   484     QPair<QLibrary *, QLibrary *> libs = loadOpenSsl();

   485     if (!libs.first || !libs.second)

   486         // failed to load them

   487         return false;

   488 

   489 #ifdef Q_OS_SYMBIAN

   490 #ifdef SSLEAY_MACROS

   491     RESOLVEFUNC(ASN1_dup, 125, libs.second )

   492 #endif

   493     RESOLVEFUNC(ASN1_INTEGER_get, 48, libs.second )

   494     RESOLVEFUNC(ASN1_STRING_data, 71, libs.second )

   495     RESOLVEFUNC(ASN1_STRING_length, 76, libs.second )

   496     RESOLVEFUNC(BIO_ctrl, 184, libs.second )

   497     RESOLVEFUNC(BIO_free, 209, libs.second )

   498     RESOLVEFUNC(BIO_new, 222, libs.second )

   499     RESOLVEFUNC(BIO_new_mem_buf, 230, libs.second )

   500     RESOLVEFUNC(BIO_read, 244, libs.second )

   501     RESOLVEFUNC(BIO_s_mem, 251, libs.second )

   502     RESOLVEFUNC(BIO_write, 269, libs.second )

   503     RESOLVEFUNC(BN_num_bits, 387, libs.second )

   504     RESOLVEFUNC(CRYPTO_free, 469, libs.second )

   505     RESOLVEFUNC(CRYPTO_num_locks, 500, libs.second )

   506     RESOLVEFUNC(CRYPTO_set_id_callback, 513, libs.second )

   507     RESOLVEFUNC(CRYPTO_set_locking_callback, 516, libs.second )

   508     RESOLVEFUNC(DSA_free, 594, libs.second )

   509     RESOLVEFUNC(ERR_error_string, 744, libs.second )

   510     RESOLVEFUNC(ERR_get_error, 749, libs.second )

   511     RESOLVEFUNC(EVP_des_ede3_cbc, 919, libs.second )

   512     RESOLVEFUNC(EVP_PKEY_assign, 859, libs.second )

   513     RESOLVEFUNC(EVP_PKEY_free, 867, libs.second )

   514     RESOLVEFUNC(EVP_PKEY_get1_DSA, 869, libs.second )

   515     RESOLVEFUNC(EVP_PKEY_get1_RSA, 870, libs.second )

   516     RESOLVEFUNC(EVP_PKEY_new, 876, libs.second )

   517     RESOLVEFUNC(EVP_PKEY_type, 882, libs.second )

   518     RESOLVEFUNC(OBJ_nid2sn, 1036, libs.second )

   519     RESOLVEFUNC(OBJ_obj2nid, 1037, libs.second )

   520 #ifdef SSLEAY_MACROS // ### verify

   521     RESOLVEFUNC(PEM_ASN1_read_bio, 1180, libs.second )

   522 #else

   523     RESOLVEFUNC(PEM_read_bio_DSAPrivateKey, 1219, libs.second )

   524     RESOLVEFUNC(PEM_read_bio_RSAPrivateKey, 1228, libs.second )

   525     RESOLVEFUNC(PEM_write_bio_DSAPrivateKey, 1260, libs.second )

   526     RESOLVEFUNC(PEM_write_bio_RSAPrivateKey, 1271, libs.second )

   527 #endif

   528     RESOLVEFUNC(PEM_read_bio_DSA_PUBKEY, 1220, libs.second )

   529     RESOLVEFUNC(PEM_read_bio_RSA_PUBKEY, 1230, libs.second )

   530     RESOLVEFUNC(PEM_write_bio_DSA_PUBKEY, 1261, libs.second )

   531     RESOLVEFUNC(PEM_write_bio_RSA_PUBKEY, 1273, libs.second )

   532     RESOLVEFUNC(RAND_seed, 1426, libs.second )

   533     RESOLVEFUNC(RAND_status, 1429, libs.second )

   534     RESOLVEFUNC(RSA_free, 1450, libs.second )

   535     RESOLVEFUNC(sk_free, 2571, libs.second )

   536     RESOLVEFUNC(sk_num, 2576, libs.second )

   537     RESOLVEFUNC(sk_pop_free, 2578, libs.second )    

   538     RESOLVEFUNC(sk_value, 2585, libs.second )

   539     RESOLVEFUNC(SSL_CIPHER_description, 11, libs.first )

   540     RESOLVEFUNC(SSL_CTX_check_private_key, 21, libs.first )

   541     RESOLVEFUNC(SSL_CTX_ctrl, 22, libs.first )

   542     RESOLVEFUNC(SSL_CTX_free, 24, libs.first )

   543     RESOLVEFUNC(SSL_CTX_new, 35, libs.first )

   544     RESOLVEFUNC(SSL_CTX_set_cipher_list, 40, libs.first )

   545     RESOLVEFUNC(SSL_CTX_set_default_verify_paths, 44, libs.first )

   546     RESOLVEFUNC(SSL_CTX_set_verify, 56, libs.first )

   547     RESOLVEFUNC(SSL_CTX_set_verify_depth, 57, libs.first )

   548     RESOLVEFUNC(SSL_CTX_use_certificate, 64, libs.first )

   549     RESOLVEFUNC(SSL_CTX_use_certificate_file, 67, libs.first )

   550     RESOLVEFUNC(SSL_CTX_use_PrivateKey, 58, libs.first )

   551     RESOLVEFUNC(SSL_CTX_use_RSAPrivateKey, 61, libs.first )

   552     RESOLVEFUNC(SSL_CTX_use_PrivateKey_file, 60, libs.first )

   553     RESOLVEFUNC(SSL_accept, 82, libs.first )

   554     RESOLVEFUNC(SSL_clear, 92, libs.first )

   555     RESOLVEFUNC(SSL_connect, 93, libs.first )

   556     RESOLVEFUNC(SSL_free, 99, libs.first )

   557     RESOLVEFUNC(SSL_get_ciphers, 104, libs.first )

   558     RESOLVEFUNC(SSL_get_current_cipher, 106, libs.first )

   559     RESOLVEFUNC(SSL_get_error, 110, libs.first )

   560     RESOLVEFUNC(SSL_get_peer_cert_chain, 117, libs.first )

   561     RESOLVEFUNC(SSL_get_peer_certificate, 118, libs.first )

   562     RESOLVEFUNC(SSL_get_verify_result, 132, libs.first )

   563     RESOLVEFUNC(SSL_library_init, 137, libs.first )

   564     RESOLVEFUNC(SSL_load_error_strings, 139, libs.first )

   565     RESOLVEFUNC(SSL_new, 140, libs.first )

   566     RESOLVEFUNC(SSL_read, 143, libs.first )

   567     RESOLVEFUNC(SSL_set_accept_state, 148, libs.first )

   568     RESOLVEFUNC(SSL_set_bio, 149, libs.first )

   569     RESOLVEFUNC(SSL_set_connect_state, 152, libs.first )

   570     RESOLVEFUNC(SSL_shutdown, 173, libs.first )

   571     RESOLVEFUNC(SSL_write, 188, libs.first )

   572     RESOLVEFUNC(SSLv2_client_method, 192, libs.first )

   573     RESOLVEFUNC(SSLv3_client_method, 195, libs.first )

   574     RESOLVEFUNC(SSLv23_client_method, 189, libs.first )

   575     RESOLVEFUNC(TLSv1_client_method, 198, libs.first )

   576     RESOLVEFUNC(SSLv2_server_method, 194, libs.first )

   577     RESOLVEFUNC(SSLv3_server_method, 197, libs.first )

   578     RESOLVEFUNC(SSLv23_server_method, 191, libs.first )

   579     RESOLVEFUNC(TLSv1_server_method, 200, libs.first )

   580     RESOLVEFUNC(X509_NAME_oneline, 1830, libs.second )

   581     RESOLVEFUNC(X509_PUBKEY_get, 1844, libs.second )

   582     RESOLVEFUNC(X509_STORE_free, 1939, libs.second )

   583     RESOLVEFUNC(X509_STORE_new, 1942, libs.second )

   584     RESOLVEFUNC(X509_STORE_add_cert, 1936, libs.second )

   585     RESOLVEFUNC(X509_STORE_CTX_free, 1907, libs.second )

   586     RESOLVEFUNC(X509_STORE_CTX_init, 1919, libs.second )

   587     RESOLVEFUNC(X509_STORE_CTX_new, 1920, libs.second )

   588     RESOLVEFUNC(X509_STORE_CTX_set_purpose, 1931, libs.second )

   589     RESOLVEFUNC(X509_cmp, 1992, libs.second )

   590 #ifndef SSLEAY_MACROS

   591     RESOLVEFUNC(X509_dup, 1997, libs.second )

   592 #endif

   593     RESOLVEFUNC(X509_EXTENSION_get_object, 1785, libs.second )

   594     RESOLVEFUNC(X509_free, 2001, libs.second )

   595     RESOLVEFUNC(X509_get_ext, 2012, libs.second )

   596     RESOLVEFUNC(X509_get_ext_count, 2016, libs.second )

   597     RESOLVEFUNC(X509_get_ext_d2i, 2017, libs.second )

   598     RESOLVEFUNC(X509_get_issuer_name, 2018, libs.second )

   599     RESOLVEFUNC(X509_get_subject_name, 2022, libs.second )

   600     RESOLVEFUNC(X509_verify_cert, 2069, libs.second )

   601     RESOLVEFUNC(d2i_X509, 2309, libs.second )

   602     RESOLVEFUNC(i2d_X509, 2489, libs.second )

   603 #ifdef SSLEAY_MACROS

   604     RESOLVEFUNC(i2d_DSAPrivateKey, 2395, libs.second )

   605     RESOLVEFUNC(i2d_RSAPrivateKey, 2476, libs.second )

   606     RESOLVEFUNC(d2i_DSAPrivateKey, 2220, libs.second )

   607     RESOLVEFUNC(d2i_RSAPrivateKey, 2296, libs.second )

   608 #endif

   609     RESOLVEFUNC(OPENSSL_add_all_algorithms_noconf, 1153, libs.second )

   610     RESOLVEFUNC(OPENSSL_add_all_algorithms_conf, 1152, libs.second )

   611 #else // Q_OS_SYMBIAN

   612 #ifdef SSLEAY_MACROS

   613     RESOLVEFUNC(ASN1_dup)

   614 #endif

   615     RESOLVEFUNC(ASN1_INTEGER_get)

   616     RESOLVEFUNC(ASN1_STRING_data)

   617     RESOLVEFUNC(ASN1_STRING_length)

   618     RESOLVEFUNC(BIO_ctrl)

   619     RESOLVEFUNC(BIO_free)

   620     RESOLVEFUNC(BIO_new)

   621     RESOLVEFUNC(BIO_new_mem_buf)

   622     RESOLVEFUNC(BIO_read)

   623     RESOLVEFUNC(BIO_s_mem)

   624     RESOLVEFUNC(BIO_write)

   625     RESOLVEFUNC(BN_num_bits)

   626     RESOLVEFUNC(CRYPTO_free)

   627     RESOLVEFUNC(CRYPTO_num_locks)

   628     RESOLVEFUNC(CRYPTO_set_id_callback)

   629     RESOLVEFUNC(CRYPTO_set_locking_callback)

   630     RESOLVEFUNC(DSA_free)

   631     RESOLVEFUNC(ERR_error_string)

   632     RESOLVEFUNC(ERR_get_error)

   633     RESOLVEFUNC(EVP_des_ede3_cbc)

   634     RESOLVEFUNC(EVP_PKEY_assign)

   635     RESOLVEFUNC(EVP_PKEY_free)

   636     RESOLVEFUNC(EVP_PKEY_get1_DSA)

   637     RESOLVEFUNC(EVP_PKEY_get1_RSA)

   638     RESOLVEFUNC(EVP_PKEY_new)

   639     RESOLVEFUNC(EVP_PKEY_type)

   640     RESOLVEFUNC(OBJ_nid2sn)

   641     RESOLVEFUNC(OBJ_obj2nid)

   642 #ifdef SSLEAY_MACROS // ### verify

   643     RESOLVEFUNC(PEM_ASN1_read_bio)

   644 #else

   645     RESOLVEFUNC(PEM_read_bio_DSAPrivateKey)

   646     RESOLVEFUNC(PEM_read_bio_RSAPrivateKey)

   647     RESOLVEFUNC(PEM_write_bio_DSAPrivateKey)

   648     RESOLVEFUNC(PEM_write_bio_RSAPrivateKey)

   649 #endif

   650     RESOLVEFUNC(PEM_read_bio_DSA_PUBKEY)

   651     RESOLVEFUNC(PEM_read_bio_RSA_PUBKEY)

   652     RESOLVEFUNC(PEM_write_bio_DSA_PUBKEY)

   653     RESOLVEFUNC(PEM_write_bio_RSA_PUBKEY)

   654     RESOLVEFUNC(RAND_seed)

   655     RESOLVEFUNC(RAND_status)

   656     RESOLVEFUNC(RSA_free)

   657     RESOLVEFUNC(sk_free)

   658     RESOLVEFUNC(sk_num)

   659     RESOLVEFUNC(sk_pop_free)

   660     RESOLVEFUNC(sk_value)

   661     RESOLVEFUNC(SSL_CIPHER_description)

   662     RESOLVEFUNC(SSL_CTX_check_private_key)

   663     RESOLVEFUNC(SSL_CTX_ctrl)

   664     RESOLVEFUNC(SSL_CTX_free)

   665     RESOLVEFUNC(SSL_CTX_new)

   666     RESOLVEFUNC(SSL_CTX_set_cipher_list)

   667     RESOLVEFUNC(SSL_CTX_set_default_verify_paths)

   668     RESOLVEFUNC(SSL_CTX_set_verify)

   669     RESOLVEFUNC(SSL_CTX_set_verify_depth)

   670     RESOLVEFUNC(SSL_CTX_use_certificate)

   671     RESOLVEFUNC(SSL_CTX_use_certificate_file)

   672     RESOLVEFUNC(SSL_CTX_use_PrivateKey)

   673     RESOLVEFUNC(SSL_CTX_use_RSAPrivateKey)

   674     RESOLVEFUNC(SSL_CTX_use_PrivateKey_file)

   675     RESOLVEFUNC(SSL_accept)

   676     RESOLVEFUNC(SSL_clear)

   677     RESOLVEFUNC(SSL_connect)

   678     RESOLVEFUNC(SSL_free)

   679     RESOLVEFUNC(SSL_get_ciphers)

   680     RESOLVEFUNC(SSL_get_current_cipher)

   681     RESOLVEFUNC(SSL_get_error)

   682     RESOLVEFUNC(SSL_get_peer_cert_chain)

   683     RESOLVEFUNC(SSL_get_peer_certificate)

   684     RESOLVEFUNC(SSL_get_verify_result)

   685     RESOLVEFUNC(SSL_library_init)

   686     RESOLVEFUNC(SSL_load_error_strings)

   687     RESOLVEFUNC(SSL_new)

   688     RESOLVEFUNC(SSL_read)

   689     RESOLVEFUNC(SSL_set_accept_state)

   690     RESOLVEFUNC(SSL_set_bio)

   691     RESOLVEFUNC(SSL_set_connect_state)

   692     RESOLVEFUNC(SSL_shutdown)

   693     RESOLVEFUNC(SSL_write)

   694     RESOLVEFUNC(SSLv2_client_method)

   695     RESOLVEFUNC(SSLv3_client_method)

   696     RESOLVEFUNC(SSLv23_client_method)

   697     RESOLVEFUNC(TLSv1_client_method)

   698     RESOLVEFUNC(SSLv2_server_method)

   699     RESOLVEFUNC(SSLv3_server_method)

   700     RESOLVEFUNC(SSLv23_server_method)

   701     RESOLVEFUNC(TLSv1_server_method)

   702     RESOLVEFUNC(X509_NAME_oneline)

   703     RESOLVEFUNC(X509_PUBKEY_get)

   704     RESOLVEFUNC(X509_STORE_free)

   705     RESOLVEFUNC(X509_STORE_new)

   706     RESOLVEFUNC(X509_STORE_add_cert)

   707     RESOLVEFUNC(X509_STORE_CTX_free)

   708     RESOLVEFUNC(X509_STORE_CTX_init)

   709     RESOLVEFUNC(X509_STORE_CTX_new)

   710     RESOLVEFUNC(X509_STORE_CTX_set_purpose)

   711     RESOLVEFUNC(X509_cmp)

   712 #ifndef SSLEAY_MACROS

   713     RESOLVEFUNC(X509_dup)

   714 #endif

   715     RESOLVEFUNC(X509_EXTENSION_get_object)

   716     RESOLVEFUNC(X509_free)

   717     RESOLVEFUNC(X509_get_ext)

   718     RESOLVEFUNC(X509_get_ext_count)

   719     RESOLVEFUNC(X509_get_ext_d2i)

   720     RESOLVEFUNC(X509_get_issuer_name)

   721     RESOLVEFUNC(X509_get_subject_name)

   722     RESOLVEFUNC(X509_verify_cert)

   723     RESOLVEFUNC(d2i_X509)

   724     RESOLVEFUNC(i2d_X509)

   725 #ifdef SSLEAY_MACROS

   726     RESOLVEFUNC(i2d_DSAPrivateKey)

   727     RESOLVEFUNC(i2d_RSAPrivateKey)

   728     RESOLVEFUNC(d2i_DSAPrivateKey)

   729     RESOLVEFUNC(d2i_RSAPrivateKey)

   730 #endif

   731     RESOLVEFUNC(OPENSSL_add_all_algorithms_noconf)

   732     RESOLVEFUNC(OPENSSL_add_all_algorithms_conf)

   733 #endif // Q_OS_SYMBIAN

   734     symbolsResolved = true;

   735     delete libs.first;

   736     delete libs.second;

   737     return true;

   738 }

   739 #endif // QT_NO_LIBRARY

   740 

   741 #else // !defined QT_LINKED_OPENSSL

   742 

   743 bool q_resolveOpenSslSymbols()

   744 {

   745 #ifdef QT_NO_SSL

   746     return false;

   747 #endif

   748     return true;

   749 }

   750 #endif // !defined QT_LINKED_OPENSSL

   751 

   752 //==============================================================================

   753 // contributed by Jay Case of Sarvega, Inc.; http://sarvega.com/

   754 // Based on X509_cmp_time() for intitial buffer hacking.

   755 //==============================================================================

   756 QDateTime q_getTimeFromASN1(const ASN1_TIME *aTime)

   757 {

   758     char lBuffer[24];

   759     char *pBuffer = lBuffer;

   760 

   761     size_t lTimeLength = aTime->length;

   762     char *pString = (char *) aTime->data;

   763 

   764     if (aTime->type == V_ASN1_UTCTIME) {

   765         if ((lTimeLength < 11) || (lTimeLength > 17))

   766             return QDateTime();

   767 

   768         memcpy(pBuffer, pString, 10);

   769         pBuffer += 10;

   770         pString += 10;

   771     } else {

   772         if (lTimeLength < 13)

   773             return QDateTime();

   774 

   775         memcpy(pBuffer, pString, 12);

   776         pBuffer += 12;

   777         pString += 12;

   778     }

   779 

   780     if ((*pString == 'Z') || (*pString == '-') || (*pString == '+')) {

   781         *pBuffer++ = '0';

   782         *pBuffer++ = '0';

   783     } else {

   784         *pBuffer++ = *pString++;

   785         *pBuffer++ = *pString++;

   786         // Skip any fractional seconds...

   787         if (*pString == '.') {

   788             pString++;

   789             while ((*pString >= '0') && (*pString <= '9'))

   790                 pString++;

   791         }

   792     }

   793 

   794     *pBuffer++ = 'Z';

   795     *pBuffer++ = '\0';

   796 

   797     time_t lSecondsFromUCT;

   798     if (*pString == 'Z') {

   799         lSecondsFromUCT = 0;

   800     } else {

   801         if ((*pString != '+') && (*pString != '-'))

   802             return QDateTime();

   803 

   804         lSecondsFromUCT = ((pString[1] - '0') * 10 + (pString[2] - '0')) * 60;

   805         lSecondsFromUCT += (pString[3] - '0') * 10 + (pString[4] - '0');

   806         lSecondsFromUCT *= 60;

   807         if (*pString == '-')

   808             lSecondsFromUCT = -lSecondsFromUCT;

   809     }

   810 

   811     tm lTime;

   812     lTime.tm_sec = ((lBuffer[10] - '0') * 10) + (lBuffer[11] - '0');

   813     lTime.tm_min = ((lBuffer[8] - '0') * 10) + (lBuffer[9] - '0');

   814     lTime.tm_hour = ((lBuffer[6] - '0') * 10) + (lBuffer[7] - '0');

   815     lTime.tm_mday = ((lBuffer[4] - '0') * 10) + (lBuffer[5] - '0');

   816     lTime.tm_mon = (((lBuffer[2] - '0') * 10) + (lBuffer[3] - '0')) - 1;

   817     lTime.tm_year = ((lBuffer[0] - '0') * 10) + (lBuffer[1] - '0');

   818     if (lTime.tm_year < 50)

   819         lTime.tm_year += 100; // RFC 2459

   820 

   821     QDate resDate(lTime.tm_year + 1900, lTime.tm_mon + 1, lTime.tm_mday);

   822     QTime resTime(lTime.tm_hour, lTime.tm_min, lTime.tm_sec);

   823     QDateTime result(resDate, resTime, Qt::UTC);

   824     result = result.addSecs(lSecondsFromUCT);

   825     return result;

   826 }

   827 

   828 QT_END_NAMESPACE