qsslsocket_openssl

Jenkins

qsslsocket_openssl_symbols.cpp

Absolute File Name:

/home/qt/qt5_coco/qt5/qtbase/src/network/ssl/qsslsocket_openssl_symbols.cpp

Line

Source

Count

namespace {

void qsslSocketUnresolvedSymbolWarning(const char *functionName)

{

for (bool qt_category_enabled = lcSsl().isWarningEnabled(); qt_category_enabled; qt_category_enabled = false) QMessageLogger(__FILE__, 119125, __PRETTY_FUNCTION__, lcSsl().categoryName()).warning("QSslSocket: cannot call unresolved function %s", functionName);

}

void qsslSocketCannotResolveSymbolWarning(const char *functionName)

{

for (bool qt_category_enabled = lcSsl().isWarningEnabled(); qt_category_enabled; qt_category_enabled = false) QMessageLogger(__FILE__, 125131, __PRETTY_FUNCTION__, lcSsl().categoryName()).warning("QSslSocket: cannot resolve %s", functionName);

}

typedef long (*_q_PTR_ASN1_INTEGER_get)(ASN1_INTEGER *a); static _q_PTR_ASN1_INTEGER_get _q_ASN1_INTEGER_get = 0; long q_ASN1_INTEGER_get(ASN1_INTEGER *a) { if (__builtin_expect(!!(!_q_ASN1_INTEGER_get), false)) { qsslSocketUnresolvedSymbolWarning("ASN1_INTEGER_get"); return 0; } return _q_ASN1_INTEGER_get(a); }

typedef unsigned char * (*_q_PTR_ASN1_STRING_data)(ASN1_STRING *a); static _q_PTR_ASN1_STRING_data _q_ASN1_STRING_data = 0; unsigned char * q_ASN1_STRING_data(ASN1_STRING *a) { if (__builtin_expect(!!(!_q_ASN1_STRING_data), false)) { qsslSocketUnresolvedSymbolWarning("ASN1_STRING_data"); return 0; } return _q_ASN1_STRING_data(a); }

typedef int (*_q_PTR_ASN1_STRING_length)(ASN1_STRING *a); static _q_PTR_ASN1_STRING_length _q_ASN1_STRING_length = 0; int q_ASN1_STRING_length(ASN1_STRING *a) { if (__builtin_expect(!!(!_q_ASN1_STRING_length), false)) { qsslSocketUnresolvedSymbolWarning("ASN1_STRING_length"); return 0; } return _q_ASN1_STRING_length(a); }

typedef int (*_q_PTR_ASN1_STRING_to_UTF8)(unsigned char **a, ASN1_STRING *b); static _q_PTR_ASN1_STRING_to_UTF8 _q_ASN1_STRING_to_UTF8 = 0; int q_ASN1_STRING_to_UTF8(unsigned char **a, ASN1_STRING *b) { if (__builtin_expect(!!(!_q_ASN1_STRING_to_UTF8), false)) { qsslSocketUnresolvedSymbolWarning("ASN1_STRING_to_UTF8"); return 0; } return _q_ASN1_STRING_to_UTF8(a, b); };

typedef long (*_q_PTR_BIO_ctrl)(BIO *a, int b, long c, void *d); static _q_PTR_BIO_ctrl _q_BIO_ctrl = 0; long q_BIO_ctrl(BIO *a, int b, long c, void *d) { if (__builtin_expect(!!(!_q_BIO_ctrl), false)) { qsslSocketUnresolvedSymbolWarning("BIO_ctrl"); return -1; } return _q_BIO_ctrl(a, b, c, d); }

typedef int (*_q_PTR_BIO_free)(BIO *a); static _q_PTR_BIO_free _q_BIO_free = 0; int q_BIO_free(BIO *a) { if (__builtin_expect(!!(!_q_BIO_free), false)) { qsslSocketUnresolvedSymbolWarning("BIO_free"); return 0; } return _q_BIO_free(a); }

typedef BIO * (*_q_PTR_BIO_new)(BIO_METHOD *a); static _q_PTR_BIO_new _q_BIO_new = 0; BIO * q_BIO_new(BIO_METHOD *a) { if (__builtin_expect(!!(!_q_BIO_new), false)) { qsslSocketUnresolvedSymbolWarning("BIO_new"); return 0; } return _q_BIO_new(a); }

typedef BIO * (*_q_PTR_BIO_new_mem_buf)(void *a, int b); static _q_PTR_BIO_new_mem_buf _q_BIO_new_mem_buf = 0; BIO * q_BIO_new_mem_buf(void *a, int b) { if (__builtin_expect(!!(!_q_BIO_new_mem_buf), false)) { qsslSocketUnresolvedSymbolWarning("BIO_new_mem_buf"); return 0; } return _q_BIO_new_mem_buf(a, b); }

typedef int (*_q_PTR_BIO_read)(BIO *a, void *b, int c); static _q_PTR_BIO_read _q_BIO_read = 0; int q_BIO_read(BIO *a, void *b, int c) { if (__builtin_expect(!!(!_q_BIO_read), false)) { qsslSocketUnresolvedSymbolWarning("BIO_read"); return -1; } return _q_BIO_read(a, b, c); }

typedef BIO_METHOD * (*_q_PTR_BIO_s_mem)(void); static _q_PTR_BIO_s_mem _q_BIO_s_mem = 0; BIO_METHOD * q_BIO_s_mem(void) { if (__builtin_expect(!!(!_q_BIO_s_mem), false)) { qsslSocketUnresolvedSymbolWarning("BIO_s_mem"); return 0; } return _q_BIO_s_mem(); }

typedef int (*_q_PTR_BIO_write)(BIO *a, const void *b, int c); static _q_PTR_BIO_write _q_BIO_write = 0; int q_BIO_write(BIO *a, const void *b, int c) { if (__builtin_expect(!!(!_q_BIO_write), false)) { qsslSocketUnresolvedSymbolWarning("BIO_write"); return -1; } return _q_BIO_write(a, b, c); }

typedef int (*_q_PTR_BN_num_bits)(const BIGNUM *a); static _q_PTR_BN_num_bits _q_BN_num_bits = 0; int q_BN_num_bits(const BIGNUM *a) { if (__builtin_expect(!!(!_q_BN_num_bits), false)) { qsslSocketUnresolvedSymbolWarning("BN_num_bits"); return 0; } return _q_BN_num_bits(a); }

typedef const EC_GROUP* (*_q_PTR_EC_KEY_get0_group)(const EC_KEY* k); static _q_PTR_EC_KEY_get0_group _q_EC_KEY_get0_group = 0; const EC_GROUP* q_EC_KEY_get0_group(const EC_KEY* k) { if (__builtin_expect(!!(!_q_EC_KEY_get0_group), false)) { qsslSocketUnresolvedSymbolWarning("EC_KEY_get0_group"); return 0; } return _q_EC_KEY_get0_group(k); }

typedef int (*_q_PTR_EC_GROUP_get_degree)(const EC_GROUP* g); static _q_PTR_EC_GROUP_get_degree _q_EC_GROUP_get_degree = 0; int q_EC_GROUP_get_degree(const EC_GROUP* g) { if (__builtin_expect(!!(!_q_EC_GROUP_get_degree), false)) { qsslSocketUnresolvedSymbolWarning("EC_GROUP_get_degree"); return 0; } return _q_EC_GROUP_get_degree(g); }

typedef int (*_q_PTR_CRYPTO_num_locks)(); static _q_PTR_CRYPTO_num_locks _q_CRYPTO_num_locks = 0; int q_CRYPTO_num_locks() { if (__builtin_expect(!!(!_q_CRYPTO_num_locks), false)) { qsslSocketUnresolvedSymbolWarning("CRYPTO_num_locks"); return 0; } return _q_CRYPTO_num_locks(); }

typedef void (*_q_PTR_CRYPTO_set_locking_callback)(void (*a)(int, int, const char *, int)); static _q_PTR_CRYPTO_set_locking_callback _q_CRYPTO_set_locking_callback = 0; void q_CRYPTO_set_locking_callback(void (*a)(int, int, const char *, int)) { if (__builtin_expect(!!(!_q_CRYPTO_set_locking_callback), false)) { qsslSocketUnresolvedSymbolWarning("CRYPTO_set_locking_callback"); return; } _q_CRYPTO_set_locking_callback(a); }

typedef void (*_q_PTR_CRYPTO_set_id_callback)(unsigned long (*a)()); static _q_PTR_CRYPTO_set_id_callback _q_CRYPTO_set_id_callback = 0; void q_CRYPTO_set_id_callback(unsigned long (*a)()) { if (__builtin_expect(!!(!_q_CRYPTO_set_id_callback), false)) { qsslSocketUnresolvedSymbolWarning("CRYPTO_set_id_callback"); return; } _q_CRYPTO_set_id_callback(a); }

typedef void (*_q_PTR_CRYPTO_free)(void *a); static _q_PTR_CRYPTO_free _q_CRYPTO_free = 0; void q_CRYPTO_free(void *a) { if (__builtin_expect(!!(!_q_CRYPTO_free), false)) { qsslSocketUnresolvedSymbolWarning("CRYPTO_free"); return; } _q_CRYPTO_free(a); }

typedef DSA * (*_q_PTR_DSA_new)(); static _q_PTR_DSA_new _q_DSA_new = 0; DSA * q_DSA_new() { if (__builtin_expect(!!(!_q_DSA_new), false)) { qsslSocketUnresolvedSymbolWarning("DSA_new"); return 0; } return _q_DSA_new(); }

typedef void (*_q_PTR_DSA_free)(DSA *a); static _q_PTR_DSA_free _q_DSA_free = 0; void q_DSA_free(DSA *a) { if (__builtin_expect(!!(!_q_DSA_free), false)) { qsslSocketUnresolvedSymbolWarning("DSA_free"); return; } _q_DSA_free(a); }

typedef X509 * (*_q_PTR_d2i_X509)(X509 **a, const unsigned char **b, long c); static _q_PTR_d2i_X509 _q_d2i_X509 = 0; X509 * q_d2i_X509(X509 **a, const unsigned char **b, long c) { if (__builtin_expect(!!(!_q_d2i_X509), false)) { qsslSocketUnresolvedSymbolWarning("d2i_X509"); return 0; } return _q_d2i_X509(a, b, c); }

typedef char * (*_q_PTR_ERR_error_string)(unsigned long a, char *b); static _q_PTR_ERR_error_string _q_ERR_error_string = 0; char * q_ERR_error_string(unsigned long a, char *b) { if (__builtin_expect(!!(!_q_ERR_error_string), false)) { qsslSocketUnresolvedSymbolWarning("ERR_error_string"); return 0; } return _q_ERR_error_string(a, b); }

typedef unsigned long (*_q_PTR_ERR_get_error)(); static _q_PTR_ERR_get_error _q_ERR_get_error = 0; unsigned long q_ERR_get_error() { if (__builtin_expect(!!(!_q_ERR_get_error), false)) { qsslSocketUnresolvedSymbolWarning("ERR_get_error"); return 0; } return _q_ERR_get_error(); }

typedef void (*_q_PTR_ERR_free_strings)(void); static _q_PTR_ERR_free_strings _q_ERR_free_strings = 0; void q_ERR_free_strings(void) { if (__builtin_expect(!!(!_q_ERR_free_strings), false)) { qsslSocketUnresolvedSymbolWarning("ERR_free_strings"); return; } _q_ERR_free_strings(); }

typedef void (*_q_PTR_EVP_CIPHER_CTX_cleanup)(EVP_CIPHER_CTX *a); static _q_PTR_EVP_CIPHER_CTX_cleanup _q_EVP_CIPHER_CTX_cleanup = 0; void q_EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *a) { if (__builtin_expect(!!(!_q_EVP_CIPHER_CTX_cleanup), false)) { qsslSocketUnresolvedSymbolWarning("EVP_CIPHER_CTX_cleanup"); return; } _q_EVP_CIPHER_CTX_cleanup(a); }

typedef void (*_q_PTR_EVP_CIPHER_CTX_init)(EVP_CIPHER_CTX *a); static _q_PTR_EVP_CIPHER_CTX_init _q_EVP_CIPHER_CTX_init = 0; void q_EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *a) { if (__builtin_expect(!!(!_q_EVP_CIPHER_CTX_init), false)) { qsslSocketUnresolvedSymbolWarning("EVP_CIPHER_CTX_init"); return; } _q_EVP_CIPHER_CTX_init(a); }

typedef int (*_q_PTR_EVP_CIPHER_CTX_ctrl)(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); static _q_PTR_EVP_CIPHER_CTX_ctrl _q_EVP_CIPHER_CTX_ctrl = 0; int q_EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) { if (__builtin_expect(!!(!_q_EVP_CIPHER_CTX_ctrl), false)) { qsslSocketUnresolvedSymbolWarning("EVP_CIPHER_CTX_ctrl"); return 0; } return _q_EVP_CIPHER_CTX_ctrl(ctx, type, arg, ptr); };

typedef int (*_q_PTR_EVP_CIPHER_CTX_set_key_length)(EVP_CIPHER_CTX *ctx, int keylen); static _q_PTR_EVP_CIPHER_CTX_set_key_length _q_EVP_CIPHER_CTX_set_key_length = 0; int q_EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *ctx, int keylen) { if (__builtin_expect(!!(!_q_EVP_CIPHER_CTX_set_key_length), false)) { qsslSocketUnresolvedSymbolWarning("EVP_CIPHER_CTX_set_key_length"); return 0; } return _q_EVP_CIPHER_CTX_set_key_length(ctx, keylen); }

typedef int (*_q_PTR_EVP_CipherInit)(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, const unsigned char *key, const unsigned char *iv, int enc); static _q_PTR_EVP_CipherInit _q_EVP_CipherInit = 0; int q_EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, const unsigned char *key, const unsigned char *iv, int enc) { if (__builtin_expect(!!(!_q_EVP_CipherInit), false)) { qsslSocketUnresolvedSymbolWarning("EVP_CipherInit"); return 0; } return _q_EVP_CipherInit(ctx, type, key, iv, enc); };

typedef int (*_q_PTR_EVP_CipherUpdate)(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, const unsigned char *in, int inl); static _q_PTR_EVP_CipherUpdate _q_EVP_CipherUpdate = 0; int q_EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, const unsigned char *in, int inl) { if (__builtin_expect(!!(!_q_EVP_CipherUpdate), false)) { qsslSocketUnresolvedSymbolWarning("EVP_CipherUpdate"); return 0; } return _q_EVP_CipherUpdate(ctx, out, outl, in, inl); };

typedef int (*_q_PTR_EVP_CipherFinal)(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); static _q_PTR_EVP_CipherFinal _q_EVP_CipherFinal = 0; int q_EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) { if (__builtin_expect(!!(!_q_EVP_CipherFinal), false)) { qsslSocketUnresolvedSymbolWarning("EVP_CipherFinal"); return 0; } return _q_EVP_CipherFinal(ctx, out, outl); };

typedef const EVP_CIPHER * (*_q_PTR_EVP_des_cbc)(); static _q_PTR_EVP_des_cbc _q_EVP_des_cbc = 0; const EVP_CIPHER * q_EVP_des_cbc() { if (__builtin_expect(!!(!_q_EVP_des_cbc), false)) { qsslSocketUnresolvedSymbolWarning("EVP_des_cbc"); return 0; } return _q_EVP_des_cbc(); }

typedef const EVP_CIPHER * (*_q_PTR_EVP_des_ede3_cbc)(); static _q_PTR_EVP_des_ede3_cbc _q_EVP_des_ede3_cbc = 0; const EVP_CIPHER * q_EVP_des_ede3_cbc() { if (__builtin_expect(!!(!_q_EVP_des_ede3_cbc), false)) { qsslSocketUnresolvedSymbolWarning("EVP_des_ede3_cbc"); return 0; } return _q_EVP_des_ede3_cbc(); }

typedef const EVP_CIPHER * (*_q_PTR_EVP_rc2_cbc)(); static _q_PTR_EVP_rc2_cbc _q_EVP_rc2_cbc = 0; const EVP_CIPHER * q_EVP_rc2_cbc() { if (__builtin_expect(!!(!_q_EVP_rc2_cbc), false)) { qsslSocketUnresolvedSymbolWarning("EVP_rc2_cbc"); return 0; } return _q_EVP_rc2_cbc(); }

typedef int (*_q_PTR_EVP_PKEY_assign)(EVP_PKEY *a, int b, char *c); static _q_PTR_EVP_PKEY_assign _q_EVP_PKEY_assign = 0; int q_EVP_PKEY_assign(EVP_PKEY *a, int b, char *c) { if (__builtin_expect(!!(!_q_EVP_PKEY_assign), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_assign"); return -1; } return _q_EVP_PKEY_assign(a, b, c); }

typedef int (*_q_PTR_EVP_PKEY_set1_RSA)(EVP_PKEY *a, RSA *b); static _q_PTR_EVP_PKEY_set1_RSA _q_EVP_PKEY_set1_RSA = 0; int q_EVP_PKEY_set1_RSA(EVP_PKEY *a, RSA *b) { if (__builtin_expect(!!(!_q_EVP_PKEY_set1_RSA), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_set1_RSA"); return -1; } return _q_EVP_PKEY_set1_RSA(a, b); }

typedef int (*_q_PTR_EVP_PKEY_set1_DSA)(EVP_PKEY *a, DSA *b); static _q_PTR_EVP_PKEY_set1_DSA _q_EVP_PKEY_set1_DSA = 0; int q_EVP_PKEY_set1_DSA(EVP_PKEY *a, DSA *b) { if (__builtin_expect(!!(!_q_EVP_PKEY_set1_DSA), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_set1_DSA"); return -1; } return _q_EVP_PKEY_set1_DSA(a, b); }

typedef int (*_q_PTR_EVP_PKEY_set1_EC_KEY)(EVP_PKEY *a, EC_KEY *b); static _q_PTR_EVP_PKEY_set1_EC_KEY _q_EVP_PKEY_set1_EC_KEY = 0; int q_EVP_PKEY_set1_EC_KEY(EVP_PKEY *a, EC_KEY *b) { if (__builtin_expect(!!(!_q_EVP_PKEY_set1_EC_KEY), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_set1_EC_KEY"); return -1; } return _q_EVP_PKEY_set1_EC_KEY(a, b); }

typedef void (*_q_PTR_EVP_PKEY_free)(EVP_PKEY *a); static _q_PTR_EVP_PKEY_free _q_EVP_PKEY_free = 0; void q_EVP_PKEY_free(EVP_PKEY *a) { if (__builtin_expect(!!(!_q_EVP_PKEY_free), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_free"); return; } _q_EVP_PKEY_free(a); }

typedef DSA * (*_q_PTR_EVP_PKEY_get1_DSA)(EVP_PKEY *a); static _q_PTR_EVP_PKEY_get1_DSA _q_EVP_PKEY_get1_DSA = 0; DSA * q_EVP_PKEY_get1_DSA(EVP_PKEY *a) { if (__builtin_expect(!!(!_q_EVP_PKEY_get1_DSA), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_get1_DSA"); return 0; } return _q_EVP_PKEY_get1_DSA(a); }

typedef RSA * (*_q_PTR_EVP_PKEY_get1_RSA)(EVP_PKEY *a); static _q_PTR_EVP_PKEY_get1_RSA _q_EVP_PKEY_get1_RSA = 0; RSA * q_EVP_PKEY_get1_RSA(EVP_PKEY *a) { if (__builtin_expect(!!(!_q_EVP_PKEY_get1_RSA), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_get1_RSA"); return 0; } return _q_EVP_PKEY_get1_RSA(a); }

typedef EC_KEY * (*_q_PTR_EVP_PKEY_get1_EC_KEY)(EVP_PKEY *a); static _q_PTR_EVP_PKEY_get1_EC_KEY _q_EVP_PKEY_get1_EC_KEY = 0; EC_KEY * q_EVP_PKEY_get1_EC_KEY(EVP_PKEY *a) { if (__builtin_expect(!!(!_q_EVP_PKEY_get1_EC_KEY), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_get1_EC_KEY"); return 0; } return _q_EVP_PKEY_get1_EC_KEY(a); }

typedef EVP_PKEY * (*_q_PTR_EVP_PKEY_new)(); static _q_PTR_EVP_PKEY_new _q_EVP_PKEY_new = 0; EVP_PKEY * q_EVP_PKEY_new() { if (__builtin_expect(!!(!_q_EVP_PKEY_new), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_new"); return 0; } return _q_EVP_PKEY_new(); }

typedef int (*_q_PTR_EVP_PKEY_type)(int a); static _q_PTR_EVP_PKEY_type _q_EVP_PKEY_type = 0; int q_EVP_PKEY_type(int a) { if (__builtin_expect(!!(!_q_EVP_PKEY_type), false)) { qsslSocketUnresolvedSymbolWarning("EVP_PKEY_type"); return 0; } return _q_EVP_PKEY_type(a); }

typedef int (*_q_PTR_i2d_X509)(X509 *a, unsigned char **b); static _q_PTR_i2d_X509 _q_i2d_X509 = 0; int q_i2d_X509(X509 *a, unsigned char **b) { if (__builtin_expect(!!(!_q_i2d_X509), false)) { qsslSocketUnresolvedSymbolWarning("i2d_X509"); return -1; } return _q_i2d_X509(a, b); }

typedef const char * (*_q_PTR_OBJ_nid2sn)(int a); static _q_PTR_OBJ_nid2sn _q_OBJ_nid2sn = 0; const char * q_OBJ_nid2sn(int a) { if (__builtin_expect(!!(!_q_OBJ_nid2sn), false)) { qsslSocketUnresolvedSymbolWarning("OBJ_nid2sn"); return 0; } return _q_OBJ_nid2sn(a); }

typedef const char * (*_q_PTR_OBJ_nid2ln)(int a); static _q_PTR_OBJ_nid2ln _q_OBJ_nid2ln = 0; const char * q_OBJ_nid2ln(int a) { if (__builtin_expect(!!(!_q_OBJ_nid2ln), false)) { qsslSocketUnresolvedSymbolWarning("OBJ_nid2ln"); return 0; } return _q_OBJ_nid2ln(a); }

typedef int (*_q_PTR_OBJ_sn2nid)(const char *s); static _q_PTR_OBJ_sn2nid _q_OBJ_sn2nid = 0; int q_OBJ_sn2nid(const char *s) { if (__builtin_expect(!!(!_q_OBJ_sn2nid), false)) { qsslSocketUnresolvedSymbolWarning("OBJ_sn2nid"); return 0; } return _q_OBJ_sn2nid(s); }

typedef int (*_q_PTR_OBJ_ln2nid)(const char *s); static _q_PTR_OBJ_ln2nid _q_OBJ_ln2nid = 0; int q_OBJ_ln2nid(const char *s) { if (__builtin_expect(!!(!_q_OBJ_ln2nid), false)) { qsslSocketUnresolvedSymbolWarning("OBJ_ln2nid"); return 0; } return _q_OBJ_ln2nid(s); }

typedef int (*_q_PTR_i2t_ASN1_OBJECT)(char *a, int b, ASN1_OBJECT *c); static _q_PTR_i2t_ASN1_OBJECT _q_i2t_ASN1_OBJECT = 0; int q_i2t_ASN1_OBJECT(char *a, int b, ASN1_OBJECT *c) { if (__builtin_expect(!!(!_q_i2t_ASN1_OBJECT), false)) { qsslSocketUnresolvedSymbolWarning("i2t_ASN1_OBJECT"); return -1; } return _q_i2t_ASN1_OBJECT(a, b, c); }

typedef int (*_q_PTR_OBJ_obj2txt)(char *a, int b, ASN1_OBJECT *c, int d); static _q_PTR_OBJ_obj2txt _q_OBJ_obj2txt = 0; int q_OBJ_obj2txt(char *a, int b, ASN1_OBJECT *c, int d) { if (__builtin_expect(!!(!_q_OBJ_obj2txt), false)) { qsslSocketUnresolvedSymbolWarning("OBJ_obj2txt"); return -1; } return _q_OBJ_obj2txt(a, b, c, d); }

typedef int (*_q_PTR_OBJ_obj2nid)(const ASN1_OBJECT *a); static _q_PTR_OBJ_obj2nid _q_OBJ_obj2nid = 0; int q_OBJ_obj2nid(const ASN1_OBJECT *a) { if (__builtin_expect(!!(!_q_OBJ_obj2nid), false)) { qsslSocketUnresolvedSymbolWarning("OBJ_obj2nid"); return 0; } return _q_OBJ_obj2nid(a); }

100

typedef DSA * (*_q_PTR_PEM_read_bio_DSAPrivateKey)(BIO *a, DSA **b, pem_password_cb *c, void *d); static _q_PTR_PEM_read_bio_DSAPrivateKey _q_PEM_read_bio_DSAPrivateKey = 0; DSA * q_PEM_read_bio_DSAPrivateKey(BIO *a, DSA **b, pem_password_cb *c, void *d) { if (__builtin_expect(!!(!_q_PEM_read_bio_DSAPrivateKey), false)) { qsslSocketUnresolvedSymbolWarning("PEM_read_bio_DSAPrivateKey"); return 0; } return _q_PEM_read_bio_DSAPrivateKey(a, b, c, d); }

101

typedef RSA * (*_q_PTR_PEM_read_bio_RSAPrivateKey)(BIO *a, RSA **b, pem_password_cb *c, void *d); static _q_PTR_PEM_read_bio_RSAPrivateKey _q_PEM_read_bio_RSAPrivateKey = 0; RSA * q_PEM_read_bio_RSAPrivateKey(BIO *a, RSA **b, pem_password_cb *c, void *d) { if (__builtin_expect(!!(!_q_PEM_read_bio_RSAPrivateKey), false)) { qsslSocketUnresolvedSymbolWarning("PEM_read_bio_RSAPrivateKey"); return 0; } return _q_PEM_read_bio_RSAPrivateKey(a, b, c, d); }

102

103

typedef EC_KEY * (*_q_PTR_PEM_read_bio_ECPrivateKey)(BIO *a, EC_KEY **b, pem_password_cb *c, void *d); static _q_PTR_PEM_read_bio_ECPrivateKey _q_PEM_read_bio_ECPrivateKey = 0; EC_KEY * q_PEM_read_bio_ECPrivateKey(BIO *a, EC_KEY **b, pem_password_cb *c, void *d) { if (__builtin_expect(!!(!_q_PEM_read_bio_ECPrivateKey), false)) { qsslSocketUnresolvedSymbolWarning("PEM_read_bio_ECPrivateKey"); return 0; } return _q_PEM_read_bio_ECPrivateKey(a, b, c, d); }

104

105

typedef int (*_q_PTR_PEM_write_bio_DSAPrivateKey)(BIO *a, DSA *b, const EVP_CIPHER *c, unsigned char *d, int e, pem_password_cb *f, void *g); static _q_PTR_PEM_write_bio_DSAPrivateKey _q_PEM_write_bio_DSAPrivateKey = 0; int q_PEM_write_bio_DSAPrivateKey(BIO *a, DSA *b, const EVP_CIPHER *c, unsigned char *d, int e, pem_password_cb *f, void *g) { if (__builtin_expect(!!(!_q_PEM_write_bio_DSAPrivateKey), false)) { qsslSocketUnresolvedSymbolWarning("PEM_write_bio_DSAPrivateKey"); return 0; } return _q_PEM_write_bio_DSAPrivateKey(a, b, c, d, e, f, g); }

106

typedef int (*_q_PTR_PEM_write_bio_RSAPrivateKey)(BIO *a, RSA *b, const EVP_CIPHER *c, unsigned char *d, int e, pem_password_cb *f, void *g); static _q_PTR_PEM_write_bio_RSAPrivateKey _q_PEM_write_bio_RSAPrivateKey = 0; int q_PEM_write_bio_RSAPrivateKey(BIO *a, RSA *b, const EVP_CIPHER *c, unsigned char *d, int e, pem_password_cb *f, void *g) { if (__builtin_expect(!!(!_q_PEM_write_bio_RSAPrivateKey), false)) { qsslSocketUnresolvedSymbolWarning("PEM_write_bio_RSAPrivateKey"); return 0; } return _q_PEM_write_bio_RSAPrivateKey(a, b, c, d, e, f, g); }

107

108

typedef int (*_q_PTR_PEM_write_bio_ECPrivateKey)(BIO *a, EC_KEY *b, const EVP_CIPHER *c, unsigned char *d, int e, pem_password_cb *f, void *g); static _q_PTR_PEM_write_bio_ECPrivateKey _q_PEM_write_bio_ECPrivateKey = 0; int q_PEM_write_bio_ECPrivateKey(BIO *a, EC_KEY *b, const EVP_CIPHER *c, unsigned char *d, int e, pem_password_cb *f, void *g) { if (__builtin_expect(!!(!_q_PEM_write_bio_ECPrivateKey), false)) { qsslSocketUnresolvedSymbolWarning("PEM_write_bio_ECPrivateKey"); return 0; } return _q_PEM_write_bio_ECPrivateKey(a, b, c, d, e, f, g); }

109

110

111

typedef DSA * (*_q_PTR_PEM_read_bio_DSA_PUBKEY)(BIO *a, DSA **b, pem_password_cb *c, void *d); static _q_PTR_PEM_read_bio_DSA_PUBKEY _q_PEM_read_bio_DSA_PUBKEY = 0; DSA * q_PEM_read_bio_DSA_PUBKEY(BIO *a, DSA **b, pem_password_cb *c, void *d) { if (__builtin_expect(!!(!_q_PEM_read_bio_DSA_PUBKEY), false)) { qsslSocketUnresolvedSymbolWarning("PEM_read_bio_DSA_PUBKEY"); return 0; } return _q_PEM_read_bio_DSA_PUBKEY(a, b, c, d); }

112

typedef RSA * (*_q_PTR_PEM_read_bio_RSA_PUBKEY)(BIO *a, RSA **b, pem_password_cb *c, void *d); static _q_PTR_PEM_read_bio_RSA_PUBKEY _q_PEM_read_bio_RSA_PUBKEY = 0; RSA * q_PEM_read_bio_RSA_PUBKEY(BIO *a, RSA **b, pem_password_cb *c, void *d) { if (__builtin_expect(!!(!_q_PEM_read_bio_RSA_PUBKEY), false)) { qsslSocketUnresolvedSymbolWarning("PEM_read_bio_RSA_PUBKEY"); return 0; } return _q_PEM_read_bio_RSA_PUBKEY(a, b, c, d); }

113

114

typedef EC_KEY * (*_q_PTR_PEM_read_bio_EC_PUBKEY)(BIO *a, EC_KEY **b, pem_password_cb *c, void *d); static _q_PTR_PEM_read_bio_EC_PUBKEY _q_PEM_read_bio_EC_PUBKEY = 0; EC_KEY * q_PEM_read_bio_EC_PUBKEY(BIO *a, EC_KEY **b, pem_password_cb *c, void *d) { if (__builtin_expect(!!(!_q_PEM_read_bio_EC_PUBKEY), false)) { qsslSocketUnresolvedSymbolWarning("PEM_read_bio_EC_PUBKEY"); return 0; } return _q_PEM_read_bio_EC_PUBKEY(a, b, c, d); }

115

116

typedef int (*_q_PTR_PEM_write_bio_DSA_PUBKEY)(BIO *a, DSA *b); static _q_PTR_PEM_write_bio_DSA_PUBKEY _q_PEM_write_bio_DSA_PUBKEY = 0; int q_PEM_write_bio_DSA_PUBKEY(BIO *a, DSA *b) { if (__builtin_expect(!!(!_q_PEM_write_bio_DSA_PUBKEY), false)) { qsslSocketUnresolvedSymbolWarning("PEM_write_bio_DSA_PUBKEY"); return 0; } return _q_PEM_write_bio_DSA_PUBKEY(a, b); }

117

typedef int (*_q_PTR_PEM_write_bio_RSA_PUBKEY)(BIO *a, RSA *b); static _q_PTR_PEM_write_bio_RSA_PUBKEY _q_PEM_write_bio_RSA_PUBKEY = 0; int q_PEM_write_bio_RSA_PUBKEY(BIO *a, RSA *b) { if (__builtin_expect(!!(!_q_PEM_write_bio_RSA_PUBKEY), false)) { qsslSocketUnresolvedSymbolWarning("PEM_write_bio_RSA_PUBKEY"); return 0; } return _q_PEM_write_bio_RSA_PUBKEY(a, b); }

118

119

typedef int (*_q_PTR_PEM_write_bio_EC_PUBKEY)(BIO *a, EC_KEY *b); static _q_PTR_PEM_write_bio_EC_PUBKEY _q_PEM_write_bio_EC_PUBKEY = 0; int q_PEM_write_bio_EC_PUBKEY(BIO *a, EC_KEY *b) { if (__builtin_expect(!!(!_q_PEM_write_bio_EC_PUBKEY), false)) { qsslSocketUnresolvedSymbolWarning("PEM_write_bio_EC_PUBKEY"); return 0; } return _q_PEM_write_bio_EC_PUBKEY(a, b); }

120

121

typedef void (*_q_PTR_RAND_seed)(const void *a, int b); static _q_PTR_RAND_seed _q_RAND_seed = 0; void q_RAND_seed(const void *a, int b) { if (__builtin_expect(!!(!_q_RAND_seed), false)) { qsslSocketUnresolvedSymbolWarning("RAND_seed"); return; } _q_RAND_seed(a, b); }

122

typedef int (*_q_PTR_RAND_status)(void); static _q_PTR_RAND_status _q_RAND_status = 0; int q_RAND_status(void) { if (__builtin_expect(!!(!_q_RAND_status), false)) { qsslSocketUnresolvedSymbolWarning("RAND_status"); return -1; } return _q_RAND_status(); }

123

typedef RSA * (*_q_PTR_RSA_new)(); static _q_PTR_RSA_new _q_RSA_new = 0; RSA * q_RSA_new() { if (__builtin_expect(!!(!_q_RSA_new), false)) { qsslSocketUnresolvedSymbolWarning("RSA_new"); return 0; } return _q_RSA_new(); }

124

typedef void (*_q_PTR_RSA_free)(RSA *a); static _q_PTR_RSA_free _q_RSA_free = 0; void q_RSA_free(RSA *a) { if (__builtin_expect(!!(!_q_RSA_free), false)) { qsslSocketUnresolvedSymbolWarning("RSA_free"); return; } _q_RSA_free(a); }

125

typedef int (*_q_PTR_sk_num)(STACK *a); static _q_PTR_sk_num _q_sk_num = 0; int q_sk_num(STACK *a) { if (__builtin_expect(!!(!_q_sk_num), false)) { qsslSocketUnresolvedSymbolWarning("sk_num"); return -1; } return _q_sk_num(a); }

126

typedef void (*_q_PTR_sk_pop_free)(STACK *a, void (*b)(void*)); static _q_PTR_sk_pop_free _q_sk_pop_free = 0; void q_sk_pop_free(STACK *a, void (*b)(void*)) { if (__builtin_expect(!!(!_q_sk_pop_free), false)) { qsslSocketUnresolvedSymbolWarning("sk_pop_free"); return; } _q_sk_pop_free(a, b); }

127

128

typedef _STACK * (*_q_PTR_sk_new_null)(); static _q_PTR_sk_new_null _q_sk_new_null = 0; _STACK * q_sk_new_null() { if (__builtin_expect(!!(!_q_sk_new_null), false)) { qsslSocketUnresolvedSymbolWarning("sk_new_null"); return 0; } return _q_sk_new_null(); }

129

typedef void (*_q_PTR_sk_push)(_STACK *a, void *b); static _q_PTR_sk_push _q_sk_push = 0; void q_sk_push(_STACK *a, void *b) { if (__builtin_expect(!!(!_q_sk_push), false)) { qsslSocketUnresolvedSymbolWarning("sk_push"); return; } _q_sk_push(a, b); }

130

typedef void (*_q_PTR_sk_free)(_STACK *a); static _q_PTR_sk_free _q_sk_free = 0; void q_sk_free(_STACK *a) { if (__builtin_expect(!!(!_q_sk_free), false)) { qsslSocketUnresolvedSymbolWarning("sk_free"); return; } _q_sk_free(a); }

131

typedef void * (*_q_PTR_sk_value)(STACK *a, int b); static _q_PTR_sk_value _q_sk_value = 0; void * q_sk_value(STACK *a, int b) { if (__builtin_expect(!!(!_q_sk_value), false)) { qsslSocketUnresolvedSymbolWarning("sk_value"); return 0; } return _q_sk_value(a, b); }

typedef int (*_q_PTR_SSL_accept)(SSL *a); static _q_PTR_SSL_accept _q_SSL_accept = 0; int q_SSL_accept(SSL *a) { if (__builtin_expect(!!(!_q_SSL_accept), false)) { qsslSocketUnresolvedSymbolWarning("SSL_accept"); return -1; } return _q_SSL_accept(a); }

139

typedef int (*_q_PTR_SSL_clear)(SSL *a); static _q_PTR_SSL_clear _q_SSL_clear = 0; int q_SSL_clear(SSL *a) { if (__builtin_expect(!!(!_q_SSL_clear), false)) { qsslSocketUnresolvedSymbolWarning("SSL_clear"); return -1; } return _q_SSL_clear(a); }

140

typedef char * (*_q_PTR_SSL_CIPHER_description)(SSL_CIPHER *a, char *b, int c); static _q_PTR_SSL_CIPHER_description _q_SSL_CIPHER_description = 0; char * q_SSL_CIPHER_description(SSL_CIPHER *a, char *b, int c) { if (__builtin_expect(!!(!_q_SSL_CIPHER_description), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CIPHER_description"); return 0; } return _q_SSL_CIPHER_description(a, b, c); }

141

typedef int (*_q_PTR_SSL_CIPHER_get_bits)(SSL_CIPHER *a, int *b); static _q_PTR_SSL_CIPHER_get_bits _q_SSL_CIPHER_get_bits = 0; int q_SSL_CIPHER_get_bits(SSL_CIPHER *a, int *b) { if (__builtin_expect(!!(!_q_SSL_CIPHER_get_bits), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CIPHER_get_bits"); return 0; } return _q_SSL_CIPHER_get_bits(a, b); }

142

typedef int (*_q_PTR_SSL_connect)(SSL *a); static _q_PTR_SSL_connect _q_SSL_connect = 0; int q_SSL_connect(SSL *a) { if (__builtin_expect(!!(!_q_SSL_connect), false)) { qsslSocketUnresolvedSymbolWarning("SSL_connect"); return -1; } return _q_SSL_connect(a); }

143

typedef int (*_q_PTR_SSL_CTX_check_private_key)(const SSL_CTX *a); static _q_PTR_SSL_CTX_check_private_key _q_SSL_CTX_check_private_key = 0; int q_SSL_CTX_check_private_key(const SSL_CTX *a) { if (__builtin_expect(!!(!_q_SSL_CTX_check_private_key), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_check_private_key"); return -1; } return _q_SSL_CTX_check_private_key(a); }

144

typedef long (*_q_PTR_SSL_CTX_ctrl)(SSL_CTX *a, int b, long c, void *d); static _q_PTR_SSL_CTX_ctrl _q_SSL_CTX_ctrl = 0; long q_SSL_CTX_ctrl(SSL_CTX *a, int b, long c, void *d) { if (__builtin_expect(!!(!_q_SSL_CTX_ctrl), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_ctrl"); return -1; } return _q_SSL_CTX_ctrl(a, b, c, d); }

145

typedef void (*_q_PTR_SSL_CTX_free)(SSL_CTX *a); static _q_PTR_SSL_CTX_free _q_SSL_CTX_free = 0; void q_SSL_CTX_free(SSL_CTX *a) { if (__builtin_expect(!!(!_q_SSL_CTX_free), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_free"); return; } _q_SSL_CTX_free(a); }

146

147

typedef SSL_CTX * (*_q_PTR_SSL_CTX_new)(const SSL_METHOD *a); static _q_PTR_SSL_CTX_new _q_SSL_CTX_new = 0; SSL_CTX * q_SSL_CTX_new(const SSL_METHOD *a) { if (__builtin_expect(!!(!_q_SSL_CTX_new), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_new"); return 0; } return _q_SSL_CTX_new(a); }

typedef int (*_q_PTR_SSL_CTX_set_cipher_list)(SSL_CTX *a, const char *b); static _q_PTR_SSL_CTX_set_cipher_list _q_SSL_CTX_set_cipher_list = 0; int q_SSL_CTX_set_cipher_list(SSL_CTX *a, const char *b) { if (__builtin_expect(!!(!_q_SSL_CTX_set_cipher_list), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_set_cipher_list"); return -1; } return _q_SSL_CTX_set_cipher_list(a, b); }

152

typedef int (*_q_PTR_SSL_CTX_set_default_verify_paths)(SSL_CTX *a); static _q_PTR_SSL_CTX_set_default_verify_paths _q_SSL_CTX_set_default_verify_paths = 0; int q_SSL_CTX_set_default_verify_paths(SSL_CTX *a) { if (__builtin_expect(!!(!_q_SSL_CTX_set_default_verify_paths), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_set_default_verify_paths"); return -1; } return _q_SSL_CTX_set_default_verify_paths(a); }

153

typedef void (*_q_PTR_SSL_CTX_set_verify)(SSL_CTX *a, int b, int (*c)(int, X509_STORE_CTX *)); static _q_PTR_SSL_CTX_set_verify _q_SSL_CTX_set_verify = 0; void q_SSL_CTX_set_verify(SSL_CTX *a, int b, int (*c)(int, X509_STORE_CTX *)) { if (__builtin_expect(!!(!_q_SSL_CTX_set_verify), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_set_verify"); return; } _q_SSL_CTX_set_verify(a, b, c); }

154

typedef void (*_q_PTR_SSL_CTX_set_verify_depth)(SSL_CTX *a, int b); static _q_PTR_SSL_CTX_set_verify_depth _q_SSL_CTX_set_verify_depth = 0; void q_SSL_CTX_set_verify_depth(SSL_CTX *a, int b) { if (__builtin_expect(!!(!_q_SSL_CTX_set_verify_depth), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_set_verify_depth"); return; } _q_SSL_CTX_set_verify_depth(a, b); }

155

typedef int (*_q_PTR_SSL_CTX_use_certificate)(SSL_CTX *a, X509 *b); static _q_PTR_SSL_CTX_use_certificate _q_SSL_CTX_use_certificate = 0; int q_SSL_CTX_use_certificate(SSL_CTX *a, X509 *b) { if (__builtin_expect(!!(!_q_SSL_CTX_use_certificate), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_use_certificate"); return -1; } return _q_SSL_CTX_use_certificate(a, b); }

156

typedef int (*_q_PTR_SSL_CTX_use_certificate_file)(SSL_CTX *a, const char *b, int c); static _q_PTR_SSL_CTX_use_certificate_file _q_SSL_CTX_use_certificate_file = 0; int q_SSL_CTX_use_certificate_file(SSL_CTX *a, const char *b, int c) { if (__builtin_expect(!!(!_q_SSL_CTX_use_certificate_file), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_use_certificate_file"); return -1; } return _q_SSL_CTX_use_certificate_file(a, b, c); }

157

typedef int (*_q_PTR_SSL_CTX_use_PrivateKey)(SSL_CTX *a, EVP_PKEY *b); static _q_PTR_SSL_CTX_use_PrivateKey _q_SSL_CTX_use_PrivateKey = 0; int q_SSL_CTX_use_PrivateKey(SSL_CTX *a, EVP_PKEY *b) { if (__builtin_expect(!!(!_q_SSL_CTX_use_PrivateKey), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_use_PrivateKey"); return -1; } return _q_SSL_CTX_use_PrivateKey(a, b); }

158

typedef int (*_q_PTR_SSL_CTX_use_RSAPrivateKey)(SSL_CTX *a, RSA *b); static _q_PTR_SSL_CTX_use_RSAPrivateKey _q_SSL_CTX_use_RSAPrivateKey = 0; int q_SSL_CTX_use_RSAPrivateKey(SSL_CTX *a, RSA *b) { if (__builtin_expect(!!(!_q_SSL_CTX_use_RSAPrivateKey), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_use_RSAPrivateKey"); return -1; } return _q_SSL_CTX_use_RSAPrivateKey(a, b); }

159

typedef int (*_q_PTR_SSL_CTX_use_PrivateKey_file)(SSL_CTX *a, const char *b, int c); static _q_PTR_SSL_CTX_use_PrivateKey_file _q_SSL_CTX_use_PrivateKey_file = 0; int q_SSL_CTX_use_PrivateKey_file(SSL_CTX *a, const char *b, int c) { if (__builtin_expect(!!(!_q_SSL_CTX_use_PrivateKey_file), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_use_PrivateKey_file"); return -1; } return _q_SSL_CTX_use_PrivateKey_file(a, b, c); }

160

typedef X509_STORE * (*_q_PTR_SSL_CTX_get_cert_store)(const SSL_CTX *a); static _q_PTR_SSL_CTX_get_cert_store _q_SSL_CTX_get_cert_store = 0; X509_STORE * q_SSL_CTX_get_cert_store(const SSL_CTX *a) { if (__builtin_expect(!!(!_q_SSL_CTX_get_cert_store), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_get_cert_store"); return 0; } return _q_SSL_CTX_get_cert_store(a); }

161

typedef void (*_q_PTR_SSL_free)(SSL *a); static _q_PTR_SSL_free _q_SSL_free = 0; void q_SSL_free(SSL *a) { if (__builtin_expect(!!(!_q_SSL_free), false)) { qsslSocketUnresolvedSymbolWarning("SSL_free"); return; } _q_SSL_free(a); }

162

typedef struct stack_st_SSL_CIPHER * (*_q_PTR_SSL_get_ciphers)(const SSL *a); static _q_PTR_SSL_get_ciphers _q_SSL_get_ciphers = 0; struct stack_st_SSL_CIPHER * q_SSL_get_ciphers(const SSL *a) { if (__builtin_expect(!!(!_q_SSL_get_ciphers), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get_ciphers"); return 0; } return _q_SSL_get_ciphers(a); }

163

164

typedef const SSL_CIPHER * (*_q_PTR_SSL_get_current_cipher)(SSL *a); static _q_PTR_SSL_get_current_cipher _q_SSL_get_current_cipher = 0; const SSL_CIPHER * q_SSL_get_current_cipher(SSL *a) { if (__builtin_expect(!!(!_q_SSL_get_current_cipher), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get_current_cipher"); return 0; } return _q_SSL_get_current_cipher(a); }

typedef int (*_q_PTR_SSL_version)(const SSL *a); static _q_PTR_SSL_version _q_SSL_version = 0; int q_SSL_version(const SSL *a) { if (__builtin_expect(!!(!_q_SSL_version), false)) { qsslSocketUnresolvedSymbolWarning("SSL_version"); return 0; } return _q_SSL_version(a); }

169

typedef int (*_q_PTR_SSL_get_error)(SSL *a, int b); static _q_PTR_SSL_get_error _q_SSL_get_error = 0; int q_SSL_get_error(SSL *a, int b) { if (__builtin_expect(!!(!_q_SSL_get_error), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get_error"); return -1; } return _q_SSL_get_error(a, b); }

170

typedef struct stack_st_X509 * (*_q_PTR_SSL_get_peer_cert_chain)(SSL *a); static _q_PTR_SSL_get_peer_cert_chain _q_SSL_get_peer_cert_chain = 0; struct stack_st_X509 * q_SSL_get_peer_cert_chain(SSL *a) { if (__builtin_expect(!!(!_q_SSL_get_peer_cert_chain), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get_peer_cert_chain"); return 0; } return _q_SSL_get_peer_cert_chain(a); }

171

typedef X509 * (*_q_PTR_SSL_get_peer_certificate)(SSL *a); static _q_PTR_SSL_get_peer_certificate _q_SSL_get_peer_certificate = 0; X509 * q_SSL_get_peer_certificate(SSL *a) { if (__builtin_expect(!!(!_q_SSL_get_peer_certificate), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get_peer_certificate"); return 0; } return _q_SSL_get_peer_certificate(a); }

172

173

174

typedef long (*_q_PTR_SSL_get_verify_result)(const SSL *a); static _q_PTR_SSL_get_verify_result _q_SSL_get_verify_result = 0; long q_SSL_get_verify_result(const SSL *a) { if (__builtin_expect(!!(!_q_SSL_get_verify_result), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get_verify_result"); return -1; } return _q_SSL_get_verify_result(a); }

typedef int (*_q_PTR_SSL_library_init)(void); static _q_PTR_SSL_library_init _q_SSL_library_init = 0; int q_SSL_library_init(void) { if (__builtin_expect(!!(!_q_SSL_library_init), false)) { qsslSocketUnresolvedSymbolWarning("SSL_library_init"); return -1; } return _q_SSL_library_init(); }

179

typedef void (*_q_PTR_SSL_load_error_strings)(void); static _q_PTR_SSL_load_error_strings _q_SSL_load_error_strings = 0; void q_SSL_load_error_strings(void) { if (__builtin_expect(!!(!_q_SSL_load_error_strings), false)) { qsslSocketUnresolvedSymbolWarning("SSL_load_error_strings"); return; } _q_SSL_load_error_strings(); }

180

typedef SSL * (*_q_PTR_SSL_new)(SSL_CTX *a); static _q_PTR_SSL_new _q_SSL_new = 0; SSL * q_SSL_new(SSL_CTX *a) { if (__builtin_expect(!!(!_q_SSL_new), false)) { qsslSocketUnresolvedSymbolWarning("SSL_new"); return 0; } return _q_SSL_new(a); }

181

typedef long (*_q_PTR_SSL_ctrl)(SSL *a, int cmd, long larg, void *parg); static _q_PTR_SSL_ctrl _q_SSL_ctrl = 0; long q_SSL_ctrl(SSL *a, int cmd, long larg, void *parg) { if (__builtin_expect(!!(!_q_SSL_ctrl), false)) { qsslSocketUnresolvedSymbolWarning("SSL_ctrl"); return -1; } return _q_SSL_ctrl(a, cmd, larg, parg); }

182

typedef int (*_q_PTR_SSL_read)(SSL *a, void *b, int c); static _q_PTR_SSL_read _q_SSL_read = 0; int q_SSL_read(SSL *a, void *b, int c) { if (__builtin_expect(!!(!_q_SSL_read), false)) { qsslSocketUnresolvedSymbolWarning("SSL_read"); return -1; } return _q_SSL_read(a, b, c); }

183

typedef void (*_q_PTR_SSL_set_bio)(SSL *a, BIO *b, BIO *c); static _q_PTR_SSL_set_bio _q_SSL_set_bio = 0; void q_SSL_set_bio(SSL *a, BIO *b, BIO *c) { if (__builtin_expect(!!(!_q_SSL_set_bio), false)) { qsslSocketUnresolvedSymbolWarning("SSL_set_bio"); return; } _q_SSL_set_bio(a, b, c); }

184

typedef void (*_q_PTR_SSL_set_accept_state)(SSL *a); static _q_PTR_SSL_set_accept_state _q_SSL_set_accept_state = 0; void q_SSL_set_accept_state(SSL *a) { if (__builtin_expect(!!(!_q_SSL_set_accept_state), false)) { qsslSocketUnresolvedSymbolWarning("SSL_set_accept_state"); return; } _q_SSL_set_accept_state(a); }

185

typedef void (*_q_PTR_SSL_set_connect_state)(SSL *a); static _q_PTR_SSL_set_connect_state _q_SSL_set_connect_state = 0; void q_SSL_set_connect_state(SSL *a) { if (__builtin_expect(!!(!_q_SSL_set_connect_state), false)) { qsslSocketUnresolvedSymbolWarning("SSL_set_connect_state"); return; } _q_SSL_set_connect_state(a); }

186

typedef int (*_q_PTR_SSL_shutdown)(SSL *a); static _q_PTR_SSL_shutdown _q_SSL_shutdown = 0; int q_SSL_shutdown(SSL *a) { if (__builtin_expect(!!(!_q_SSL_shutdown), false)) { qsslSocketUnresolvedSymbolWarning("SSL_shutdown"); return -1; } return _q_SSL_shutdown(a); }

187

typedef int (*_q_PTR_SSL_set_session)(SSL* to, SSL_SESSION *session); static _q_PTR_SSL_set_session _q_SSL_set_session = 0; int q_SSL_set_session(SSL* to, SSL_SESSION *session) { if (__builtin_expect(!!(!_q_SSL_set_session), false)) { qsslSocketUnresolvedSymbolWarning("SSL_set_session"); return -1; } return _q_SSL_set_session(to, session); }

188

typedef void (*_q_PTR_SSL_SESSION_free)(SSL_SESSION *ses); static _q_PTR_SSL_SESSION_free _q_SSL_SESSION_free = 0; void q_SSL_SESSION_free(SSL_SESSION *ses) { if (__builtin_expect(!!(!_q_SSL_SESSION_free), false)) { qsslSocketUnresolvedSymbolWarning("SSL_SESSION_free"); return; } _q_SSL_SESSION_free(ses); }

189

typedef SSL_SESSION* (*_q_PTR_SSL_get1_session)(SSL *ssl); static _q_PTR_SSL_get1_session _q_SSL_get1_session = 0; SSL_SESSION* q_SSL_get1_session(SSL *ssl) { if (__builtin_expect(!!(!_q_SSL_get1_session), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get1_session"); return 0; } return _q_SSL_get1_session(ssl); }

190

typedef SSL_SESSION* (*_q_PTR_SSL_get_session)(const SSL *ssl); static _q_PTR_SSL_get_session _q_SSL_get_session = 0; SSL_SESSION* q_SSL_get_session(const SSL *ssl) { if (__builtin_expect(!!(!_q_SSL_get_session), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get_session"); return 0; } return _q_SSL_get_session(ssl); }

191

192

typedef int (*_q_PTR_SSL_get_ex_new_index)(long argl, void *argp, CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); static _q_PTR_SSL_get_ex_new_index _q_SSL_get_ex_new_index = 0; int q_SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func) { if (__builtin_expect(!!(!_q_SSL_get_ex_new_index), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get_ex_new_index"); return -1; } return _q_SSL_get_ex_new_index(argl, argp, new_func, dup_func, free_func); }

193

typedef int (*_q_PTR_SSL_set_ex_data)(SSL *ssl, int idx, void *arg); static _q_PTR_SSL_set_ex_data _q_SSL_set_ex_data = 0; int q_SSL_set_ex_data(SSL *ssl, int idx, void *arg) { if (__builtin_expect(!!(!_q_SSL_set_ex_data), false)) { qsslSocketUnresolvedSymbolWarning("SSL_set_ex_data"); return 0; } return _q_SSL_set_ex_data(ssl, idx, arg); }

194

typedef void * (*_q_PTR_SSL_get_ex_data)(const SSL *ssl, int idx); static _q_PTR_SSL_get_ex_data _q_SSL_get_ex_data = 0; void * q_SSL_get_ex_data(const SSL *ssl, int idx) { if (__builtin_expect(!!(!_q_SSL_get_ex_data), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get_ex_data"); return __null; } return _q_SSL_get_ex_data(ssl, idx); }

195

196

197

typedef void (*_q_PTR_SSL_set_psk_client_callback)(SSL* ssl, q_psk_client_callback_t callback); static _q_PTR_SSL_set_psk_client_callback _q_SSL_set_psk_client_callback = 0; void q_SSL_set_psk_client_callback(SSL* ssl, q_psk_client_callback_t callback) { if (__builtin_expect(!!(!_q_SSL_set_psk_client_callback), false)) { qsslSocketUnresolvedSymbolWarning("SSL_set_psk_client_callback"); return; } _q_SSL_set_psk_client_callback(ssl, callback); }

typedef const SSL_METHOD * (*_q_PTR_SSLv3_client_method)(); static _q_PTR_SSLv3_client_method _q_SSLv3_client_method = 0; const SSL_METHOD * q_SSLv3_client_method() { if (__builtin_expect(!!(!_q_SSLv3_client_method), false)) { qsslSocketUnresolvedSymbolWarning("SSLv3_client_method"); return 0; } return _q_SSLv3_client_method(); }

205

206

typedef const SSL_METHOD * (*_q_PTR_SSLv23_client_method)(); static _q_PTR_SSLv23_client_method _q_SSLv23_client_method = 0; const SSL_METHOD * q_SSLv23_client_method() { if (__builtin_expect(!!(!_q_SSLv23_client_method), false)) { qsslSocketUnresolvedSymbolWarning("SSLv23_client_method"); return 0; } return _q_SSLv23_client_method(); }

207

typedef const SSL_METHOD * (*_q_PTR_TLSv1_client_method)(); static _q_PTR_TLSv1_client_method _q_TLSv1_client_method = 0; const SSL_METHOD * q_TLSv1_client_method() { if (__builtin_expect(!!(!_q_TLSv1_client_method), false)) { qsslSocketUnresolvedSymbolWarning("TLSv1_client_method"); return 0; } return _q_TLSv1_client_method(); }

208

209

typedef const SSL_METHOD * (*_q_PTR_TLSv1_1_client_method)(); static _q_PTR_TLSv1_1_client_method _q_TLSv1_1_client_method = 0; const SSL_METHOD * q_TLSv1_1_client_method() { if (__builtin_expect(!!(!_q_TLSv1_1_client_method), false)) { qsslSocketUnresolvedSymbolWarning("TLSv1_1_client_method"); return 0; } return _q_TLSv1_1_client_method(); }

210

typedef const SSL_METHOD * (*_q_PTR_TLSv1_2_client_method)(); static _q_PTR_TLSv1_2_client_method _q_TLSv1_2_client_method = 0; const SSL_METHOD * q_TLSv1_2_client_method() { if (__builtin_expect(!!(!_q_TLSv1_2_client_method), false)) { qsslSocketUnresolvedSymbolWarning("TLSv1_2_client_method"); return 0; } return _q_TLSv1_2_client_method(); }

typedef const SSL_METHOD * (*_q_PTR_SSLv3_server_method)(); static _q_PTR_SSLv3_server_method _q_SSLv3_server_method = 0; const SSL_METHOD * q_SSLv3_server_method() { if (__builtin_expect(!!(!_q_SSLv3_server_method), false)) { qsslSocketUnresolvedSymbolWarning("SSLv3_server_method"); return 0; } return _q_SSLv3_server_method(); }

217

218

typedef const SSL_METHOD * (*_q_PTR_SSLv23_server_method)(); static _q_PTR_SSLv23_server_method _q_SSLv23_server_method = 0; const SSL_METHOD * q_SSLv23_server_method() { if (__builtin_expect(!!(!_q_SSLv23_server_method), false)) { qsslSocketUnresolvedSymbolWarning("SSLv23_server_method"); return 0; } return _q_SSLv23_server_method(); }

219

typedef const SSL_METHOD * (*_q_PTR_TLSv1_server_method)(); static _q_PTR_TLSv1_server_method _q_TLSv1_server_method = 0; const SSL_METHOD * q_TLSv1_server_method() { if (__builtin_expect(!!(!_q_TLSv1_server_method), false)) { qsslSocketUnresolvedSymbolWarning("TLSv1_server_method"); return 0; } return _q_TLSv1_server_method(); }

220

221

typedef const SSL_METHOD * (*_q_PTR_TLSv1_1_server_method)(); static _q_PTR_TLSv1_1_server_method _q_TLSv1_1_server_method = 0; const SSL_METHOD * q_TLSv1_1_server_method() { if (__builtin_expect(!!(!_q_TLSv1_1_server_method), false)) { qsslSocketUnresolvedSymbolWarning("TLSv1_1_server_method"); return 0; } return _q_TLSv1_1_server_method(); }

222

typedef const SSL_METHOD * (*_q_PTR_TLSv1_2_server_method)(); static _q_PTR_TLSv1_2_server_method _q_TLSv1_2_server_method = 0; const SSL_METHOD * q_TLSv1_2_server_method() { if (__builtin_expect(!!(!_q_TLSv1_2_server_method), false)) { qsslSocketUnresolvedSymbolWarning("TLSv1_2_server_method"); return 0; } return _q_TLSv1_2_server_method(); }

223

typedef int (*_q_PTR_SSL_write)(SSL *a, const void *b, int c); static _q_PTR_SSL_write _q_SSL_write = 0; int q_SSL_write(SSL *a, const void *b, int c) { if (__builtin_expect(!!(!_q_SSL_write), false)) { qsslSocketUnresolvedSymbolWarning("SSL_write"); return -1; } return _q_SSL_write(a, b, c); }

224

typedef int (*_q_PTR_X509_cmp)(X509 *a, X509 *b); static _q_PTR_X509_cmp _q_X509_cmp = 0; int q_X509_cmp(X509 *a, X509 *b) { if (__builtin_expect(!!(!_q_X509_cmp), false)) { qsslSocketUnresolvedSymbolWarning("X509_cmp"); return -1; } return _q_X509_cmp(a, b); }

225

226

typedef X509 * (*_q_PTR_X509_dup)(X509 *a); static _q_PTR_X509_dup _q_X509_dup = 0; X509 * q_X509_dup(X509 *a) { if (__builtin_expect(!!(!_q_X509_dup), false)) { qsslSocketUnresolvedSymbolWarning("X509_dup"); return 0; } return _q_X509_dup(a); }

227

228

typedef void (*_q_PTR_X509_print)(BIO *a, X509 *b); static _q_PTR_X509_print _q_X509_print = 0; void q_X509_print(BIO *a, X509 *b) { if (__builtin_expect(!!(!_q_X509_print), false)) { qsslSocketUnresolvedSymbolWarning("X509_print"); return; } _q_X509_print(a, b); };

229

typedef ASN1_OBJECT * (*_q_PTR_X509_EXTENSION_get_object)(X509_EXTENSION *a); static _q_PTR_X509_EXTENSION_get_object _q_X509_EXTENSION_get_object = 0; ASN1_OBJECT * q_X509_EXTENSION_get_object(X509_EXTENSION *a) { if (__builtin_expect(!!(!_q_X509_EXTENSION_get_object), false)) { qsslSocketUnresolvedSymbolWarning("X509_EXTENSION_get_object"); return 0; } return _q_X509_EXTENSION_get_object(a); }

230

typedef void (*_q_PTR_X509_free)(X509 *a); static _q_PTR_X509_free _q_X509_free = 0; void q_X509_free(X509 *a) { if (__builtin_expect(!!(!_q_X509_free), false)) { qsslSocketUnresolvedSymbolWarning("X509_free"); return; } _q_X509_free(a); }

231

typedef X509_EXTENSION * (*_q_PTR_X509_get_ext)(X509 *a, int b); static _q_PTR_X509_get_ext _q_X509_get_ext = 0; X509_EXTENSION * q_X509_get_ext(X509 *a, int b) { if (__builtin_expect(!!(!_q_X509_get_ext), false)) { qsslSocketUnresolvedSymbolWarning("X509_get_ext"); return 0; } return _q_X509_get_ext(a, b); }

232

typedef int (*_q_PTR_X509_get_ext_count)(X509 *a); static _q_PTR_X509_get_ext_count _q_X509_get_ext_count = 0; int q_X509_get_ext_count(X509 *a) { if (__builtin_expect(!!(!_q_X509_get_ext_count), false)) { qsslSocketUnresolvedSymbolWarning("X509_get_ext_count"); return 0; } return _q_X509_get_ext_count(a); }

233

typedef void * (*_q_PTR_X509_get_ext_d2i)(X509 *a, int b, int *c, int *d); static _q_PTR_X509_get_ext_d2i _q_X509_get_ext_d2i = 0; void * q_X509_get_ext_d2i(X509 *a, int b, int *c, int *d) { if (__builtin_expect(!!(!_q_X509_get_ext_d2i), false)) { qsslSocketUnresolvedSymbolWarning("X509_get_ext_d2i"); return 0; } return _q_X509_get_ext_d2i(a, b, c, d); }

234

typedef const X509V3_EXT_METHOD * (*_q_PTR_X509V3_EXT_get)(X509_EXTENSION *a); static _q_PTR_X509V3_EXT_get _q_X509V3_EXT_get = 0; const X509V3_EXT_METHOD * q_X509V3_EXT_get(X509_EXTENSION *a) { if (__builtin_expect(!!(!_q_X509V3_EXT_get), false)) { qsslSocketUnresolvedSymbolWarning("X509V3_EXT_get"); return 0; } return _q_X509V3_EXT_get(a); }

235

typedef void * (*_q_PTR_X509V3_EXT_d2i)(X509_EXTENSION *a); static _q_PTR_X509V3_EXT_d2i _q_X509V3_EXT_d2i = 0; void * q_X509V3_EXT_d2i(X509_EXTENSION *a) { if (__builtin_expect(!!(!_q_X509V3_EXT_d2i), false)) { qsslSocketUnresolvedSymbolWarning("X509V3_EXT_d2i"); return 0; } return _q_X509V3_EXT_d2i(a); }

236

typedef int (*_q_PTR_X509_EXTENSION_get_critical)(X509_EXTENSION *a); static _q_PTR_X509_EXTENSION_get_critical _q_X509_EXTENSION_get_critical = 0; int q_X509_EXTENSION_get_critical(X509_EXTENSION *a) { if (__builtin_expect(!!(!_q_X509_EXTENSION_get_critical), false)) { qsslSocketUnresolvedSymbolWarning("X509_EXTENSION_get_critical"); return 0; } return _q_X509_EXTENSION_get_critical(a); }

237

typedef ASN1_OCTET_STRING * (*_q_PTR_X509_EXTENSION_get_data)(X509_EXTENSION *a); static _q_PTR_X509_EXTENSION_get_data _q_X509_EXTENSION_get_data = 0; ASN1_OCTET_STRING * q_X509_EXTENSION_get_data(X509_EXTENSION *a) { if (__builtin_expect(!!(!_q_X509_EXTENSION_get_data), false)) { qsslSocketUnresolvedSymbolWarning("X509_EXTENSION_get_data"); return 0; } return _q_X509_EXTENSION_get_data(a); }

238

typedef void (*_q_PTR_BASIC_CONSTRAINTS_free)(BASIC_CONSTRAINTS *a); static _q_PTR_BASIC_CONSTRAINTS_free _q_BASIC_CONSTRAINTS_free = 0; void q_BASIC_CONSTRAINTS_free(BASIC_CONSTRAINTS *a) { if (__builtin_expect(!!(!_q_BASIC_CONSTRAINTS_free), false)) { qsslSocketUnresolvedSymbolWarning("BASIC_CONSTRAINTS_free"); return; } _q_BASIC_CONSTRAINTS_free(a); }

239

typedef void (*_q_PTR_AUTHORITY_KEYID_free)(AUTHORITY_KEYID *a); static _q_PTR_AUTHORITY_KEYID_free _q_AUTHORITY_KEYID_free = 0; void q_AUTHORITY_KEYID_free(AUTHORITY_KEYID *a) { if (__builtin_expect(!!(!_q_AUTHORITY_KEYID_free), false)) { qsslSocketUnresolvedSymbolWarning("AUTHORITY_KEYID_free"); return; } _q_AUTHORITY_KEYID_free(a); }

240

241

typedef int (*_q_PTR_ASN1_STRING_print)(BIO *a, const ASN1_STRING *b); static _q_PTR_ASN1_STRING_print _q_ASN1_STRING_print = 0; int q_ASN1_STRING_print(BIO *a, const ASN1_STRING *b) { if (__builtin_expect(!!(!_q_ASN1_STRING_print), false)) { qsslSocketUnresolvedSymbolWarning("ASN1_STRING_print"); return 0; } return _q_ASN1_STRING_print(a, b); }

typedef int (*_q_PTR_X509_check_issued)(X509 *a, X509 *b); static _q_PTR_X509_check_issued _q_X509_check_issued = 0; int q_X509_check_issued(X509 *a, X509 *b) { if (__builtin_expect(!!(!_q_X509_check_issued), false)) { qsslSocketUnresolvedSymbolWarning("X509_check_issued"); return -1; } return _q_X509_check_issued(a, b); }

246

typedef X509_NAME * (*_q_PTR_X509_get_issuer_name)(X509 *a); static _q_PTR_X509_get_issuer_name _q_X509_get_issuer_name = 0; X509_NAME * q_X509_get_issuer_name(X509 *a) { if (__builtin_expect(!!(!_q_X509_get_issuer_name), false)) { qsslSocketUnresolvedSymbolWarning("X509_get_issuer_name"); return 0; } return _q_X509_get_issuer_name(a); }

247

typedef X509_NAME * (*_q_PTR_X509_get_subject_name)(X509 *a); static _q_PTR_X509_get_subject_name _q_X509_get_subject_name = 0; X509_NAME * q_X509_get_subject_name(X509 *a) { if (__builtin_expect(!!(!_q_X509_get_subject_name), false)) { qsslSocketUnresolvedSymbolWarning("X509_get_subject_name"); return 0; } return _q_X509_get_subject_name(a); }

248

typedef int (*_q_PTR_X509_verify_cert)(X509_STORE_CTX *a); static _q_PTR_X509_verify_cert _q_X509_verify_cert = 0; int q_X509_verify_cert(X509_STORE_CTX *a) { if (__builtin_expect(!!(!_q_X509_verify_cert), false)) { qsslSocketUnresolvedSymbolWarning("X509_verify_cert"); return -1; } return _q_X509_verify_cert(a); }

249

typedef int (*_q_PTR_X509_NAME_entry_count)(X509_NAME *a); static _q_PTR_X509_NAME_entry_count _q_X509_NAME_entry_count = 0; int q_X509_NAME_entry_count(X509_NAME *a) { if (__builtin_expect(!!(!_q_X509_NAME_entry_count), false)) { qsslSocketUnresolvedSymbolWarning("X509_NAME_entry_count"); return 0; } return _q_X509_NAME_entry_count(a); }

250

typedef X509_NAME_ENTRY * (*_q_PTR_X509_NAME_get_entry)(X509_NAME *a, int b); static _q_PTR_X509_NAME_get_entry _q_X509_NAME_get_entry = 0; X509_NAME_ENTRY * q_X509_NAME_get_entry(X509_NAME *a, int b) { if (__builtin_expect(!!(!_q_X509_NAME_get_entry), false)) { qsslSocketUnresolvedSymbolWarning("X509_NAME_get_entry"); return 0; } return _q_X509_NAME_get_entry(a, b); }

251

typedef ASN1_STRING * (*_q_PTR_X509_NAME_ENTRY_get_data)(X509_NAME_ENTRY *a); static _q_PTR_X509_NAME_ENTRY_get_data _q_X509_NAME_ENTRY_get_data = 0; ASN1_STRING * q_X509_NAME_ENTRY_get_data(X509_NAME_ENTRY *a) { if (__builtin_expect(!!(!_q_X509_NAME_ENTRY_get_data), false)) { qsslSocketUnresolvedSymbolWarning("X509_NAME_ENTRY_get_data"); return 0; } return _q_X509_NAME_ENTRY_get_data(a); }

252

typedef ASN1_OBJECT * (*_q_PTR_X509_NAME_ENTRY_get_object)(X509_NAME_ENTRY *a); static _q_PTR_X509_NAME_ENTRY_get_object _q_X509_NAME_ENTRY_get_object = 0; ASN1_OBJECT * q_X509_NAME_ENTRY_get_object(X509_NAME_ENTRY *a) { if (__builtin_expect(!!(!_q_X509_NAME_ENTRY_get_object), false)) { qsslSocketUnresolvedSymbolWarning("X509_NAME_ENTRY_get_object"); return 0; } return _q_X509_NAME_ENTRY_get_object(a); }

253

typedef EVP_PKEY * (*_q_PTR_X509_PUBKEY_get)(X509_PUBKEY *a); static _q_PTR_X509_PUBKEY_get _q_X509_PUBKEY_get = 0; EVP_PKEY * q_X509_PUBKEY_get(X509_PUBKEY *a) { if (__builtin_expect(!!(!_q_X509_PUBKEY_get), false)) { qsslSocketUnresolvedSymbolWarning("X509_PUBKEY_get"); return 0; } return _q_X509_PUBKEY_get(a); }

254

typedef void (*_q_PTR_X509_STORE_free)(X509_STORE *a); static _q_PTR_X509_STORE_free _q_X509_STORE_free = 0; void q_X509_STORE_free(X509_STORE *a) { if (__builtin_expect(!!(!_q_X509_STORE_free), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_free"); return; } _q_X509_STORE_free(a); }

255

typedef X509_STORE * (*_q_PTR_X509_STORE_new)(); static _q_PTR_X509_STORE_new _q_X509_STORE_new = 0; X509_STORE * q_X509_STORE_new() { if (__builtin_expect(!!(!_q_X509_STORE_new), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_new"); return 0; } return _q_X509_STORE_new(); }

256

typedef int (*_q_PTR_X509_STORE_add_cert)(X509_STORE *a, X509 *b); static _q_PTR_X509_STORE_add_cert _q_X509_STORE_add_cert = 0; int q_X509_STORE_add_cert(X509_STORE *a, X509 *b) { if (__builtin_expect(!!(!_q_X509_STORE_add_cert), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_add_cert"); return 0; } return _q_X509_STORE_add_cert(a, b); }

257

typedef void (*_q_PTR_X509_STORE_CTX_free)(X509_STORE_CTX *a); static _q_PTR_X509_STORE_CTX_free _q_X509_STORE_CTX_free = 0; void q_X509_STORE_CTX_free(X509_STORE_CTX *a) { if (__builtin_expect(!!(!_q_X509_STORE_CTX_free), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_CTX_free"); return; } _q_X509_STORE_CTX_free(a); }

258

typedef int (*_q_PTR_X509_STORE_CTX_init)(X509_STORE_CTX *a, X509_STORE *b, X509 *c, struct stack_st_X509 *d); static _q_PTR_X509_STORE_CTX_init _q_X509_STORE_CTX_init = 0; int q_X509_STORE_CTX_init(X509_STORE_CTX *a, X509_STORE *b, X509 *c, struct stack_st_X509 *d) { if (__builtin_expect(!!(!_q_X509_STORE_CTX_init), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_CTX_init"); return -1; } return _q_X509_STORE_CTX_init(a, b, c, d); }

259

typedef int (*_q_PTR_X509_STORE_CTX_set_purpose)(X509_STORE_CTX *a, int b); static _q_PTR_X509_STORE_CTX_set_purpose _q_X509_STORE_CTX_set_purpose = 0; int q_X509_STORE_CTX_set_purpose(X509_STORE_CTX *a, int b) { if (__builtin_expect(!!(!_q_X509_STORE_CTX_set_purpose), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_CTX_set_purpose"); return -1; } return _q_X509_STORE_CTX_set_purpose(a, b); }

260

typedef int (*_q_PTR_X509_STORE_CTX_get_error)(X509_STORE_CTX *a); static _q_PTR_X509_STORE_CTX_get_error _q_X509_STORE_CTX_get_error = 0; int q_X509_STORE_CTX_get_error(X509_STORE_CTX *a) { if (__builtin_expect(!!(!_q_X509_STORE_CTX_get_error), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_CTX_get_error"); return -1; } return _q_X509_STORE_CTX_get_error(a); }

261

typedef int (*_q_PTR_X509_STORE_CTX_get_error_depth)(X509_STORE_CTX *a); static _q_PTR_X509_STORE_CTX_get_error_depth _q_X509_STORE_CTX_get_error_depth = 0; int q_X509_STORE_CTX_get_error_depth(X509_STORE_CTX *a) { if (__builtin_expect(!!(!_q_X509_STORE_CTX_get_error_depth), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_CTX_get_error_depth"); return -1; } return _q_X509_STORE_CTX_get_error_depth(a); }

262

typedef X509 * (*_q_PTR_X509_STORE_CTX_get_current_cert)(X509_STORE_CTX *a); static _q_PTR_X509_STORE_CTX_get_current_cert _q_X509_STORE_CTX_get_current_cert = 0; X509 * q_X509_STORE_CTX_get_current_cert(X509_STORE_CTX *a) { if (__builtin_expect(!!(!_q_X509_STORE_CTX_get_current_cert), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_CTX_get_current_cert"); return 0; } return _q_X509_STORE_CTX_get_current_cert(a); }

263

typedef struct stack_st_X509 * (*_q_PTR_X509_STORE_CTX_get_chain)(X509_STORE_CTX *a); static _q_PTR_X509_STORE_CTX_get_chain _q_X509_STORE_CTX_get_chain = 0; struct stack_st_X509 * q_X509_STORE_CTX_get_chain(X509_STORE_CTX *a) { if (__builtin_expect(!!(!_q_X509_STORE_CTX_get_chain), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_CTX_get_chain"); return 0; } return _q_X509_STORE_CTX_get_chain(a); }

264

typedef X509_STORE_CTX * (*_q_PTR_X509_STORE_CTX_new)(); static _q_PTR_X509_STORE_CTX_new _q_X509_STORE_CTX_new = 0; X509_STORE_CTX * q_X509_STORE_CTX_new() { if (__builtin_expect(!!(!_q_X509_STORE_CTX_new), false)) { qsslSocketUnresolvedSymbolWarning("X509_STORE_CTX_new"); return 0; } return _q_X509_STORE_CTX_new(); }

265

typedef void (*_q_PTR_OPENSSL_add_all_algorithms_noconf)(void); static _q_PTR_OPENSSL_add_all_algorithms_noconf _q_OPENSSL_add_all_algorithms_noconf = 0; void q_OPENSSL_add_all_algorithms_noconf(void) { if (__builtin_expect(!!(!_q_OPENSSL_add_all_algorithms_noconf), false)) { qsslSocketUnresolvedSymbolWarning("OPENSSL_add_all_algorithms_noconf"); return; } _q_OPENSSL_add_all_algorithms_noconf(); }

266

typedef void (*_q_PTR_OPENSSL_add_all_algorithms_conf)(void); static _q_PTR_OPENSSL_add_all_algorithms_conf _q_OPENSSL_add_all_algorithms_conf = 0; void q_OPENSSL_add_all_algorithms_conf(void) { if (__builtin_expect(!!(!_q_OPENSSL_add_all_algorithms_conf), false)) { qsslSocketUnresolvedSymbolWarning("OPENSSL_add_all_algorithms_conf"); return; } _q_OPENSSL_add_all_algorithms_conf(); }

267

typedef int (*_q_PTR_SSL_CTX_load_verify_locations)(SSL_CTX *ctx, const char *CAfile, const char *CApath); static _q_PTR_SSL_CTX_load_verify_locations _q_SSL_CTX_load_verify_locations = 0; int q_SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, const char *CApath) { if (__builtin_expect(!!(!_q_SSL_CTX_load_verify_locations), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_load_verify_locations"); return 0; } return _q_SSL_CTX_load_verify_locations(ctx, CAfile, CApath); }

268

typedef long (*_q_PTR_SSLeay)(void); static _q_PTR_SSLeay _q_SSLeay = 0; long q_SSLeay(void) { if (__builtin_expect(!!(!_q_SSLeay), false)) { qsslSocketUnresolvedSymbolWarning("SSLeay"); return 0; } return _q_SSLeay(); }

269

typedef const char * (*_q_PTR_SSLeay_version)(int a); static _q_PTR_SSLeay_version _q_SSLeay_version = 0; const char * q_SSLeay_version(int a) { if (__builtin_expect(!!(!_q_SSLeay_version), false)) { qsslSocketUnresolvedSymbolWarning("SSLeay_version"); return 0; } return _q_SSLeay_version(a); }

270

typedef int (*_q_PTR_i2d_SSL_SESSION)(SSL_SESSION *in, unsigned char **pp); static _q_PTR_i2d_SSL_SESSION _q_i2d_SSL_SESSION = 0; int q_i2d_SSL_SESSION(SSL_SESSION *in, unsigned char **pp) { if (__builtin_expect(!!(!_q_i2d_SSL_SESSION), false)) { qsslSocketUnresolvedSymbolWarning("i2d_SSL_SESSION"); return 0; } return _q_i2d_SSL_SESSION(in, pp); }

271

typedef SSL_SESSION * (*_q_PTR_d2i_SSL_SESSION)(SSL_SESSION **a, const unsigned char **pp, long length); static _q_PTR_d2i_SSL_SESSION _q_d2i_SSL_SESSION = 0; SSL_SESSION * q_d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp, long length) { if (__builtin_expect(!!(!_q_d2i_SSL_SESSION), false)) { qsslSocketUnresolvedSymbolWarning("d2i_SSL_SESSION"); return 0; } return _q_d2i_SSL_SESSION(a, pp, length); }

272

273

typedef int (*_q_PTR_SSL_select_next_proto)(unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, const unsigned char *client, unsigned int client_len); static _q_PTR_SSL_select_next_proto _q_SSL_select_next_proto = 0; int q_SSL_select_next_proto(unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, const unsigned char *client, unsigned int client_len) { if (__builtin_expect(!!(!_q_SSL_select_next_proto), false)) { qsslSocketUnresolvedSymbolWarning("SSL_select_next_proto"); return -1; } return _q_SSL_select_next_proto(out, outlen, in, inlen, client, client_len); }

typedef void (*_q_PTR_SSL_CTX_set_next_proto_select_cb)(SSL_CTX *s, int (*cb) (SSL *ssl, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg), void *arg); static _q_PTR_SSL_CTX_set_next_proto_select_cb _q_SSL_CTX_set_next_proto_select_cb = 0; void q_SSL_CTX_set_next_proto_select_cb(SSL_CTX *s, int (*cb) (SSL *ssl, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg), void *arg) { if (__builtin_expect(!!(!_q_SSL_CTX_set_next_proto_select_cb), false)) { qsslSocketUnresolvedSymbolWarning("SSL_CTX_set_next_proto_select_cb"); return; } _q_SSL_CTX_set_next_proto_select_cb(s, cb, arg); }

typedef void (*_q_PTR_SSL_get0_next_proto_negotiated)(const SSL *s, const unsigned char **data, unsigned *len); static _q_PTR_SSL_get0_next_proto_negotiated _q_SSL_get0_next_proto_negotiated = 0; void q_SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data, unsigned *len) { if (__builtin_expect(!!(!_q_SSL_get0_next_proto_negotiated), false)) { qsslSocketUnresolvedSymbolWarning("SSL_get0_next_proto_negotiated"); return; } _q_SSL_get0_next_proto_negotiated(s, data, len); }

284

285

286

typedef DH * (*_q_PTR_DH_new)(); static _q_PTR_DH_new _q_DH_new = 0; DH * q_DH_new() { if (__builtin_expect(!!(!_q_DH_new), false)) { qsslSocketUnresolvedSymbolWarning("DH_new"); return 0; } return _q_DH_new(); }

287

typedef void (*_q_PTR_DH_free)(DH *dh); static _q_PTR_DH_free _q_DH_free = 0; void q_DH_free(DH *dh) { if (__builtin_expect(!!(!_q_DH_free), false)) { qsslSocketUnresolvedSymbolWarning("DH_free"); return; } _q_DH_free(dh); }

288

typedef DH * (*_q_PTR_d2i_DHparams)(DH**a, const unsigned char **pp, long length); static _q_PTR_d2i_DHparams _q_d2i_DHparams = 0; DH * q_d2i_DHparams(DH**a, const unsigned char **pp, long length) { if (__builtin_expect(!!(!_q_d2i_DHparams), false)) { qsslSocketUnresolvedSymbolWarning("d2i_DHparams"); return 0; } return _q_d2i_DHparams(a, pp, length); }

289

typedef BIGNUM * (*_q_PTR_BN_bin2bn)(const unsigned char *s, int len, BIGNUM *ret); static _q_PTR_BN_bin2bn _q_BN_bin2bn = 0; BIGNUM * q_BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret) { if (__builtin_expect(!!(!_q_BN_bin2bn), false)) { qsslSocketUnresolvedSymbolWarning("BN_bin2bn"); return 0; } return _q_BN_bin2bn(s, len, ret); }

290

291

typedef EC_KEY * (*_q_PTR_EC_KEY_dup)(const EC_KEY *ec); static _q_PTR_EC_KEY_dup _q_EC_KEY_dup = 0; EC_KEY * q_EC_KEY_dup(const EC_KEY *ec) { if (__builtin_expect(!!(!_q_EC_KEY_dup), false)) { qsslSocketUnresolvedSymbolWarning("EC_KEY_dup"); return 0; } return _q_EC_KEY_dup(ec); }

292

typedef EC_KEY * (*_q_PTR_EC_KEY_new_by_curve_name)(int nid); static _q_PTR_EC_KEY_new_by_curve_name _q_EC_KEY_new_by_curve_name = 0; EC_KEY * q_EC_KEY_new_by_curve_name(int nid) { if (__builtin_expect(!!(!_q_EC_KEY_new_by_curve_name), false)) { qsslSocketUnresolvedSymbolWarning("EC_KEY_new_by_curve_name"); return 0; } return _q_EC_KEY_new_by_curve_name(nid); }

293

typedef void (*_q_PTR_EC_KEY_free)(EC_KEY *ecdh); static _q_PTR_EC_KEY_free _q_EC_KEY_free = 0; void q_EC_KEY_free(EC_KEY *ecdh) { if (__builtin_expect(!!(!_q_EC_KEY_free), false)) { qsslSocketUnresolvedSymbolWarning("EC_KEY_free"); return; } _q_EC_KEY_free(ecdh); }

294

typedef size_t (*_q_PTR_EC_get_builtin_curves)(EC_builtin_curve * r, size_t nitems); static _q_PTR_EC_get_builtin_curves _q_EC_get_builtin_curves = 0; size_t q_EC_get_builtin_curves(EC_builtin_curve * r, size_t nitems) { if (__builtin_expect(!!(!_q_EC_get_builtin_curves), false)) { qsslSocketUnresolvedSymbolWarning("EC_get_builtin_curves"); return 0; } return _q_EC_get_builtin_curves(r, nitems); }

typedef int (*_q_PTR_PKCS12_parse)(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, X509 **cert, struct stack_st_X509 **ca); static _q_PTR_PKCS12_parse _q_PKCS12_parse = 0; int q_PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, X509 **cert, struct stack_st_X509 **ca) { if (__builtin_expect(!!(!_q_PKCS12_parse), false)) { qsslSocketUnresolvedSymbolWarning("PKCS12_parse"); return 1; } return _q_PKCS12_parse(p12, pass, pkey, cert, ca); }

301

;

302

typedef PKCS12 * (*_q_PTR_d2i_PKCS12_bio)(BIO *bio, PKCS12 **pkcs12); static _q_PTR_d2i_PKCS12_bio _q_d2i_PKCS12_bio = 0; PKCS12 * q_d2i_PKCS12_bio(BIO *bio, PKCS12 **pkcs12) { if (__builtin_expect(!!(!_q_d2i_PKCS12_bio), false)) { qsslSocketUnresolvedSymbolWarning("d2i_PKCS12_bio"); return 0; } return _q_d2i_PKCS12_bio(bio, pkcs12); };

303

typedef void (*_q_PTR_PKCS12_free)(PKCS12 *pkcs12); static _q_PTR_PKCS12_free _q_PKCS12_free = 0; void q_PKCS12_free(PKCS12 *pkcs12) { if (__builtin_expect(!!(!_q_PKCS12_free), false)) { qsslSocketUnresolvedSymbolWarning("PKCS12_free"); return; } _q_PKCS12_free(pkcs12); }

304

struct NumericallyLess

305

{

306

typedef bool result_type;

307

result_type operator()(const QStringRef &lhs, const QStringRef &rhs) const

{

bool ok = false;

int b = 0;

int a = lhs.toInt(&ok);

if (ok)

b = rhs.toInt(&ok);

if (ok) {

return a < b;

} else {

return lhs < rhs;

}

}

};

struct LibGreaterThan

325

{

326

typedef bool result_type;

327

result_type operator()(const QString &lhs, const QString &rhs) const

328

{

329

const QVector<QStringRef> lhsparts = lhs.splitRef(QLatin1Char('.'));

330

const QVector<QStringRef> rhsparts = rhs.splitRef(QLatin1Char('.'));

331

((!(lhsparts.count() > 1 && rhsparts.count() > 1)) ? qt_assert("lhsparts.count() > 1 && rhsparts.count() > 1",__FILE__,482488) : qt_noop());

332

333

334

return std::lexicographical_compare(rhsparts.begin() + 1, rhsparts.end(),

335

lhsparts.begin() + 1, lhsparts.end(),

NumericallyLess());

}

};

static int dlIterateCallback(struct dl_phdr_info *info, size_t size, void *data)

342

{

343

if (size < sizeof (info->dlpi_addr) + sizeof (info->dlpi_name))

344

return 1;

345

QSet<QString> *paths = (QSet<QString> *)data;

346

QString path = QString::fromLocal8Bit(info->dlpi_name);

347

if (!path.isEmpty()) {

348

QFileInfo fi(path);

349

path = fi.absolutePath();

if (!path.isEmpty())

paths->insert(path);

}

return 0;

}

static QStringList libraryPathList()

358

{

359

QStringList paths;

360

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

361

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

362

363

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

364

paths << QLatin1String("/lib64") << QLatin1String("/usr/lib64") << QLatin1String("/usr/local/lib64");

365

paths << QLatin1String("/lib32") << QLatin1String("/usr/lib32") << QLatin1String("/usr/local/lib32");

QSet<QString> loadedPaths;

372

dl_iterate_phdr(dlIterateCallback, &loadedPaths);

373

paths.append(loadedPaths.toList());

return paths;

}

__attribute__((noinline))

380

static QStringList findAllLibs(QLatin1String filter)

381

{

382

const QStringList paths = libraryPathList();

383

QStringList found;

384

const QStringList filters((QString(filter)));

385

386

for (QForeachContainer<typename QtPrivate::remove_reference<decltype(paths)>::type> _container_((paths)); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1)for (const QString &path = *_container_.i; _container_.control; _container_.control = 0: paths) {

387

QDir dir(path);

388

QStringList entryList = dir.entryList(filters, QDir::Files);

389

390

std::sort(entryList.begin(), entryList.end(), LibGreaterThan());

391

for (QForeachContainer<typename QtPrivate::remove_reference<decltype(entryList)>::type> _container_((entryList)); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1)for (const QString &entry = *_container_.i; _container_.control; _container_.control = 0): qAsConst(entryList))

392

found << path + QLatin1Char('/') + entry;

never executed: found << path + QLatin1Char('/') + entry;

393

}

never executed: end of block

394

395

return

never executed: return found;

found;

never executed: return found;

396

}

397

398

static QStringList findAllLibSsl()

399

{

400

return findAllLibs(QLatin1String("libssl.*"));

401

}

402

403

static QStringList findAllLibCrypto()

404

{

405

return findAllLibs(QLatin1String("libcrypto.*"));

406

}

407

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

408

{

409

QPair<QLibrary*,QLibrary*> pair;

410

411

412

QLibrary *&libssl = pair.first;

413

QLibrary *&libcrypto = pair.second;

414

libssl = new QLibrary;

415

libcrypto = new QLibrary;

416

libssl->setFileNameAndVersion(QLatin1String("ssl"), QLatin1String("1.0.0"));

417

libcrypto->setFileNameAndVersion(QLatin1String("crypto"), QLatin1String("1.0.0"));

418

if (libcrypto->load()

libcrypto->load()

Description

TRUE

evaluated 16 times by 16 tests

Evaluated by:

tst_NetworkSelfTest
tst_QAbstractNetworkCache
tst_QHttpNetworkConnection
tst_QNetworkAccessManager_And_QProgressDialog
tst_QNetworkDiskCache
tst_QNetworkProxyFactory
tst_QXmlInputSource
tst_Spdy
tst_qsslcertificate - unknown status
tst_qsslellipticcurve - unknown status
tst_qsslerror - unknown status
tst_qsslkey - unknown status
tst_qsslsocket - unknown status
tst_qsslsocket_onDemandCertificates_member - unknown status
tst_qsslsocket_onDemandCertificates_static - unknown status
tst_qtcpsocket - unknown status

FALSE

never evaluated

&& libssl->load()

libssl->load()

Description

TRUE

evaluated 16 times by 16 tests

Evaluated by:

tst_NetworkSelfTest
tst_QAbstractNetworkCache
tst_QHttpNetworkConnection
tst_QNetworkAccessManager_And_QProgressDialog
tst_QNetworkDiskCache
tst_QNetworkProxyFactory
tst_QXmlInputSource
tst_Spdy
tst_qsslcertificate - unknown status
tst_qsslellipticcurve - unknown status
tst_qsslerror - unknown status
tst_qsslkey - unknown status
tst_qsslsocket - unknown status
tst_qsslsocket_onDemandCertificates_member - unknown status
tst_qsslsocket_onDemandCertificates_static - unknown status
tst_qtcpsocket - unknown status

FALSE

never evaluated

) {

0-16

419

420

return

executed 16 times by 16 tests: return pair;

Executed by:

tst_NetworkSelfTest
tst_QAbstractNetworkCache
tst_QHttpNetworkConnection
tst_QNetworkAccessManager_And_QProgressDialog
tst_QNetworkDiskCache
tst_QNetworkProxyFactory
tst_QXmlInputSource
tst_Spdy
tst_qsslcertificate - unknown status
tst_qsslellipticcurve - unknown status
tst_qsslerror - unknown status
tst_qsslkey - unknown status
tst_qsslsocket - unknown status
tst_qsslsocket_onDemandCertificates_member - unknown status
tst_qsslsocket_onDemandCertificates_static - unknown status
tst_qtcpsocket - unknown status

pair;

executed 16 times by 16 tests: return pair;

Executed by:

tst_NetworkSelfTest
tst_QAbstractNetworkCache
tst_QHttpNetworkConnection
tst_QNetworkAccessManager_And_QProgressDialog
tst_QNetworkDiskCache
tst_QNetworkProxyFactory
tst_QXmlInputSource
tst_Spdy
tst_qsslcertificate - unknown status
tst_qsslellipticcurve - unknown status
tst_qsslerror - unknown status
tst_qsslkey - unknown status
tst_qsslsocket - unknown status
tst_qsslsocket_onDemandCertificates_member - unknown status
tst_qsslsocket_onDemandCertificates_static - unknown status
tst_qtcpsocket - unknown status

} else {

libssl->unload();

libcrypto->unload();

}

never executed: end of block

425

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

426

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

427

if (libcrypto->load()

libcrypto->load()	Description
TRUE	never evaluated
FALSE	never evaluated

&& libssl->load()

libssl->load()	Description
TRUE	never evaluated
FALSE	never evaluated

) {

428

429

return

never executed: return pair;

pair;

never executed: return pair;

} else {

libssl->unload();

libcrypto->unload();

}

never executed: end of block

const QStringList sslList = findAllLibSsl();

438

const QStringList cryptoList = findAllLibCrypto();

439

440

for (QForeachContainer<typename QtPrivate::remove_reference<decltype(cryptoList)>::type> _container_((cryptoList)); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1)for (const QString &crypto = *_container_.i; _container_.control; _container_.control = 0: cryptoList) {

441

libcrypto->setFileNameAndVersion(crypto, -1);

442

if (libcrypto->load()

libcrypto->load()	Description
TRUE	never evaluated
FALSE	never evaluated

) {

443

QFileInfo fi(crypto);

444

QString version = fi.completeSuffix();

445

446

for (QForeachContainer<typename QtPrivate::remove_reference<decltype(sslList)>::type> _container_((sslList)); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1)for (const QString &ssl = *_container_.i; _container_.control; _container_.control = 0: sslList) {

447

if (!ssl.endsWith(version)

!ssl.endsWith(version)	Description
TRUE	never evaluated
FALSE	never evaluated

)

448

continue;

never executed: continue;

449

450

libssl->setFileNameAndVersion(ssl, -1);

451

452

if (libssl->load()

libssl->load()	Description
TRUE	never evaluated
FALSE	never evaluated

) {

453

454

return

never executed: return pair;

pair;

never executed: return pair;

455

} else {

456

libssl->unload();

457

}

never executed: end of block

458

}

459

}

never executed: end of block

460

libcrypto->unload();

461

}

never executed: end of block

delete libssl;

delete libcrypto;

libssl = libcrypto = 0;

467

return

never executed: return pair;

pair;

never executed: return pair;

}

bool q_resolveOpenSslSymbols()

477

{

478

static bool symbolsResolved = false;

479

static bool triedToResolveSymbols = false;

480

481

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

if (symbolsResolved)

return true;

if (triedToResolveSymbols)

486

return false;

487

triedToResolveSymbols = true;

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

493

494

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

return false;

if (!(_q_ASN1_INTEGER_get = _q_PTR_ASN1_INTEGER_get(libs.first->resolve("ASN1_INTEGER_get"))) && !(_q_ASN1_INTEGER_get = _q_PTR_ASN1_INTEGER_get(libs.second->resolve("ASN1_INTEGER_get")))) qsslSocketCannotResolveSymbolWarning("ASN1_INTEGER_get");

502

if (!(_q_ASN1_STRING_data = _q_PTR_ASN1_STRING_data(libs.first->resolve("ASN1_STRING_data"))) && !(_q_ASN1_STRING_data = _q_PTR_ASN1_STRING_data(libs.second->resolve("ASN1_STRING_data")))) qsslSocketCannotResolveSymbolWarning("ASN1_STRING_data");

503

if (!(_q_ASN1_STRING_length = _q_PTR_ASN1_STRING_length(libs.first->resolve("ASN1_STRING_length"))) && !(_q_ASN1_STRING_length = _q_PTR_ASN1_STRING_length(libs.second->resolve("ASN1_STRING_length")))) qsslSocketCannotResolveSymbolWarning("ASN1_STRING_length");

504

if (!(_q_ASN1_STRING_to_UTF8 = _q_PTR_ASN1_STRING_to_UTF8(libs.first->resolve("ASN1_STRING_to_UTF8"))) && !(_q_ASN1_STRING_to_UTF8 = _q_PTR_ASN1_STRING_to_UTF8(libs.second->resolve("ASN1_STRING_to_UTF8")))) qsslSocketCannotResolveSymbolWarning("ASN1_STRING_to_UTF8");

505

if (!(_q_BIO_ctrl = _q_PTR_BIO_ctrl(libs.first->resolve("BIO_ctrl"))) && !(_q_BIO_ctrl = _q_PTR_BIO_ctrl(libs.second->resolve("BIO_ctrl")))) qsslSocketCannotResolveSymbolWarning("BIO_ctrl");

506

if (!(_q_BIO_free = _q_PTR_BIO_free(libs.first->resolve("BIO_free"))) && !(_q_BIO_free = _q_PTR_BIO_free(libs.second->resolve("BIO_free")))) qsslSocketCannotResolveSymbolWarning("BIO_free");

507

if (!(_q_BIO_new = _q_PTR_BIO_new(libs.first->resolve("BIO_new"))) && !(_q_BIO_new = _q_PTR_BIO_new(libs.second->resolve("BIO_new")))) qsslSocketCannotResolveSymbolWarning("BIO_new");

508

if (!(_q_BIO_new_mem_buf = _q_PTR_BIO_new_mem_buf(libs.first->resolve("BIO_new_mem_buf"))) && !(_q_BIO_new_mem_buf = _q_PTR_BIO_new_mem_buf(libs.second->resolve("BIO_new_mem_buf")))) qsslSocketCannotResolveSymbolWarning("BIO_new_mem_buf");

509

if (!(_q_BIO_read = _q_PTR_BIO_read(libs.first->resolve("BIO_read"))) && !(_q_BIO_read = _q_PTR_BIO_read(libs.second->resolve("BIO_read")))) qsslSocketCannotResolveSymbolWarning("BIO_read");

510

if (!(_q_BIO_s_mem = _q_PTR_BIO_s_mem(libs.first->resolve("BIO_s_mem"))) && !(_q_BIO_s_mem = _q_PTR_BIO_s_mem(libs.second->resolve("BIO_s_mem")))) qsslSocketCannotResolveSymbolWarning("BIO_s_mem");

511

if (!(_q_BIO_write = _q_PTR_BIO_write(libs.first->resolve("BIO_write"))) && !(_q_BIO_write = _q_PTR_BIO_write(libs.second->resolve("BIO_write")))) qsslSocketCannotResolveSymbolWarning("BIO_write");

512

513

if (!(_q_EC_KEY_get0_group = _q_PTR_EC_KEY_get0_group(libs.first->resolve("EC_KEY_get0_group"))) && !(_q_EC_KEY_get0_group = _q_PTR_EC_KEY_get0_group(libs.second->resolve("EC_KEY_get0_group")))) qsslSocketCannotResolveSymbolWarning("EC_KEY_get0_group");

514

if (!(_q_EC_GROUP_get_degree = _q_PTR_EC_GROUP_get_degree(libs.first->resolve("EC_GROUP_get_degree"))) && !(_q_EC_GROUP_get_degree = _q_PTR_EC_GROUP_get_degree(libs.second->resolve("EC_GROUP_get_degree")))) qsslSocketCannotResolveSymbolWarning("EC_GROUP_get_degree");

515

516

if (!(_q_BN_num_bits = _q_PTR_BN_num_bits(libs.first->resolve("BN_num_bits"))) && !(_q_BN_num_bits = _q_PTR_BN_num_bits(libs.second->resolve("BN_num_bits")))) qsslSocketCannotResolveSymbolWarning("BN_num_bits");

517

if (!(_q_CRYPTO_free = _q_PTR_CRYPTO_free(libs.first->resolve("CRYPTO_free"))) && !(_q_CRYPTO_free = _q_PTR_CRYPTO_free(libs.second->resolve("CRYPTO_free")))) qsslSocketCannotResolveSymbolWarning("CRYPTO_free");

518

if (!(_q_CRYPTO_num_locks = _q_PTR_CRYPTO_num_locks(libs.first->resolve("CRYPTO_num_locks"))) && !(_q_CRYPTO_num_locks = _q_PTR_CRYPTO_num_locks(libs.second->resolve("CRYPTO_num_locks")))) qsslSocketCannotResolveSymbolWarning("CRYPTO_num_locks");

519

if (!(_q_CRYPTO_set_id_callback = _q_PTR_CRYPTO_set_id_callback(libs.first->resolve("CRYPTO_set_id_callback"))) && !(_q_CRYPTO_set_id_callback = _q_PTR_CRYPTO_set_id_callback(libs.second->resolve("CRYPTO_set_id_callback")))) qsslSocketCannotResolveSymbolWarning("CRYPTO_set_id_callback");

520

if (!(_q_CRYPTO_set_locking_callback = _q_PTR_CRYPTO_set_locking_callback(libs.first->resolve("CRYPTO_set_locking_callback"))) && !(_q_CRYPTO_set_locking_callback = _q_PTR_CRYPTO_set_locking_callback(libs.second->resolve("CRYPTO_set_locking_callback")))) qsslSocketCannotResolveSymbolWarning("CRYPTO_set_locking_callback");

521

if (!(_q_DSA_new = _q_PTR_DSA_new(libs.first->resolve("DSA_new"))) && !(_q_DSA_new = _q_PTR_DSA_new(libs.second->resolve("DSA_new")))) qsslSocketCannotResolveSymbolWarning("DSA_new");

522

if (!(_q_DSA_free = _q_PTR_DSA_free(libs.first->resolve("DSA_free"))) && !(_q_DSA_free = _q_PTR_DSA_free(libs.second->resolve("DSA_free")))) qsslSocketCannotResolveSymbolWarning("DSA_free");

523

if (!(_q_ERR_error_string = _q_PTR_ERR_error_string(libs.first->resolve("ERR_error_string"))) && !(_q_ERR_error_string = _q_PTR_ERR_error_string(libs.second->resolve("ERR_error_string")))) qsslSocketCannotResolveSymbolWarning("ERR_error_string");

524

if (!(_q_ERR_get_error = _q_PTR_ERR_get_error(libs.first->resolve("ERR_get_error"))) && !(_q_ERR_get_error = _q_PTR_ERR_get_error(libs.second->resolve("ERR_get_error")))) qsslSocketCannotResolveSymbolWarning("ERR_get_error");

525

if (!(_q_ERR_free_strings = _q_PTR_ERR_free_strings(libs.first->resolve("ERR_free_strings"))) && !(_q_ERR_free_strings = _q_PTR_ERR_free_strings(libs.second->resolve("ERR_free_strings")))) qsslSocketCannotResolveSymbolWarning("ERR_free_strings");

526

if (!(_q_EVP_CIPHER_CTX_cleanup = _q_PTR_EVP_CIPHER_CTX_cleanup(libs.first->resolve("EVP_CIPHER_CTX_cleanup"))) && !(_q_EVP_CIPHER_CTX_cleanup = _q_PTR_EVP_CIPHER_CTX_cleanup(libs.second->resolve("EVP_CIPHER_CTX_cleanup")))) qsslSocketCannotResolveSymbolWarning("EVP_CIPHER_CTX_cleanup");

527

if (!(_q_EVP_CIPHER_CTX_init = _q_PTR_EVP_CIPHER_CTX_init(libs.first->resolve("EVP_CIPHER_CTX_init"))) && !(_q_EVP_CIPHER_CTX_init = _q_PTR_EVP_CIPHER_CTX_init(libs.second->resolve("EVP_CIPHER_CTX_init")))) qsslSocketCannotResolveSymbolWarning("EVP_CIPHER_CTX_init");

528

if (!(_q_EVP_CIPHER_CTX_ctrl = _q_PTR_EVP_CIPHER_CTX_ctrl(libs.first->resolve("EVP_CIPHER_CTX_ctrl"))) && !(_q_EVP_CIPHER_CTX_ctrl = _q_PTR_EVP_CIPHER_CTX_ctrl(libs.second->resolve("EVP_CIPHER_CTX_ctrl")))) qsslSocketCannotResolveSymbolWarning("EVP_CIPHER_CTX_ctrl");

529

if (!(_q_EVP_CIPHER_CTX_set_key_length = _q_PTR_EVP_CIPHER_CTX_set_key_length(libs.first->resolve("EVP_CIPHER_CTX_set_key_length"))) && !(_q_EVP_CIPHER_CTX_set_key_length = _q_PTR_EVP_CIPHER_CTX_set_key_length(libs.second->resolve("EVP_CIPHER_CTX_set_key_length")))) qsslSocketCannotResolveSymbolWarning("EVP_CIPHER_CTX_set_key_length");

530

if (!(_q_EVP_CipherInit = _q_PTR_EVP_CipherInit(libs.first->resolve("EVP_CipherInit"))) && !(_q_EVP_CipherInit = _q_PTR_EVP_CipherInit(libs.second->resolve("EVP_CipherInit")))) qsslSocketCannotResolveSymbolWarning("EVP_CipherInit");

531

if (!(_q_EVP_CipherUpdate = _q_PTR_EVP_CipherUpdate(libs.first->resolve("EVP_CipherUpdate"))) && !(_q_EVP_CipherUpdate = _q_PTR_EVP_CipherUpdate(libs.second->resolve("EVP_CipherUpdate")))) qsslSocketCannotResolveSymbolWarning("EVP_CipherUpdate");

532

if (!(_q_EVP_CipherFinal = _q_PTR_EVP_CipherFinal(libs.first->resolve("EVP_CipherFinal"))) && !(_q_EVP_CipherFinal = _q_PTR_EVP_CipherFinal(libs.second->resolve("EVP_CipherFinal")))) qsslSocketCannotResolveSymbolWarning("EVP_CipherFinal");

533

if (!(_q_EVP_des_cbc = _q_PTR_EVP_des_cbc(libs.first->resolve("EVP_des_cbc"))) && !(_q_EVP_des_cbc = _q_PTR_EVP_des_cbc(libs.second->resolve("EVP_des_cbc")))) qsslSocketCannotResolveSymbolWarning("EVP_des_cbc");

534

if (!(_q_EVP_des_ede3_cbc = _q_PTR_EVP_des_ede3_cbc(libs.first->resolve("EVP_des_ede3_cbc"))) && !(_q_EVP_des_ede3_cbc = _q_PTR_EVP_des_ede3_cbc(libs.second->resolve("EVP_des_ede3_cbc")))) qsslSocketCannotResolveSymbolWarning("EVP_des_ede3_cbc");

535

if (!(_q_EVP_rc2_cbc = _q_PTR_EVP_rc2_cbc(libs.first->resolve("EVP_rc2_cbc"))) && !(_q_EVP_rc2_cbc = _q_PTR_EVP_rc2_cbc(libs.second->resolve("EVP_rc2_cbc")))) qsslSocketCannotResolveSymbolWarning("EVP_rc2_cbc");

536

if (!(_q_EVP_PKEY_assign = _q_PTR_EVP_PKEY_assign(libs.first->resolve("EVP_PKEY_assign"))) && !(_q_EVP_PKEY_assign = _q_PTR_EVP_PKEY_assign(libs.second->resolve("EVP_PKEY_assign")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_assign");

537

if (!(_q_EVP_PKEY_set1_RSA = _q_PTR_EVP_PKEY_set1_RSA(libs.first->resolve("EVP_PKEY_set1_RSA"))) && !(_q_EVP_PKEY_set1_RSA = _q_PTR_EVP_PKEY_set1_RSA(libs.second->resolve("EVP_PKEY_set1_RSA")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_set1_RSA");

538

if (!(_q_EVP_PKEY_set1_DSA = _q_PTR_EVP_PKEY_set1_DSA(libs.first->resolve("EVP_PKEY_set1_DSA"))) && !(_q_EVP_PKEY_set1_DSA = _q_PTR_EVP_PKEY_set1_DSA(libs.second->resolve("EVP_PKEY_set1_DSA")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_set1_DSA");

539

540

if (!(_q_EVP_PKEY_set1_EC_KEY = _q_PTR_EVP_PKEY_set1_EC_KEY(libs.first->resolve("EVP_PKEY_set1_EC_KEY"))) && !(_q_EVP_PKEY_set1_EC_KEY = _q_PTR_EVP_PKEY_set1_EC_KEY(libs.second->resolve("EVP_PKEY_set1_EC_KEY")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_set1_EC_KEY");

541

542

if (!(_q_EVP_PKEY_free = _q_PTR_EVP_PKEY_free(libs.first->resolve("EVP_PKEY_free"))) && !(_q_EVP_PKEY_free = _q_PTR_EVP_PKEY_free(libs.second->resolve("EVP_PKEY_free")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_free");

543

if (!(_q_EVP_PKEY_get1_DSA = _q_PTR_EVP_PKEY_get1_DSA(libs.first->resolve("EVP_PKEY_get1_DSA"))) && !(_q_EVP_PKEY_get1_DSA = _q_PTR_EVP_PKEY_get1_DSA(libs.second->resolve("EVP_PKEY_get1_DSA")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_get1_DSA");

544

if (!(_q_EVP_PKEY_get1_RSA = _q_PTR_EVP_PKEY_get1_RSA(libs.first->resolve("EVP_PKEY_get1_RSA"))) && !(_q_EVP_PKEY_get1_RSA = _q_PTR_EVP_PKEY_get1_RSA(libs.second->resolve("EVP_PKEY_get1_RSA")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_get1_RSA");

545

546

if (!(_q_EVP_PKEY_get1_EC_KEY = _q_PTR_EVP_PKEY_get1_EC_KEY(libs.first->resolve("EVP_PKEY_get1_EC_KEY"))) && !(_q_EVP_PKEY_get1_EC_KEY = _q_PTR_EVP_PKEY_get1_EC_KEY(libs.second->resolve("EVP_PKEY_get1_EC_KEY")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_get1_EC_KEY");

547

548

if (!(_q_EVP_PKEY_new = _q_PTR_EVP_PKEY_new(libs.first->resolve("EVP_PKEY_new"))) && !(_q_EVP_PKEY_new = _q_PTR_EVP_PKEY_new(libs.second->resolve("EVP_PKEY_new")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_new");

549

if (!(_q_EVP_PKEY_type = _q_PTR_EVP_PKEY_type(libs.first->resolve("EVP_PKEY_type"))) && !(_q_EVP_PKEY_type = _q_PTR_EVP_PKEY_type(libs.second->resolve("EVP_PKEY_type")))) qsslSocketCannotResolveSymbolWarning("EVP_PKEY_type");

550

if (!(_q_OBJ_nid2sn = _q_PTR_OBJ_nid2sn(libs.first->resolve("OBJ_nid2sn"))) && !(_q_OBJ_nid2sn = _q_PTR_OBJ_nid2sn(libs.second->resolve("OBJ_nid2sn")))) qsslSocketCannotResolveSymbolWarning("OBJ_nid2sn");

551

if (!(_q_OBJ_nid2ln = _q_PTR_OBJ_nid2ln(libs.first->resolve("OBJ_nid2ln"))) && !(_q_OBJ_nid2ln = _q_PTR_OBJ_nid2ln(libs.second->resolve("OBJ_nid2ln")))) qsslSocketCannotResolveSymbolWarning("OBJ_nid2ln");

552

if (!(_q_OBJ_sn2nid = _q_PTR_OBJ_sn2nid(libs.first->resolve("OBJ_sn2nid"))) && !(_q_OBJ_sn2nid = _q_PTR_OBJ_sn2nid(libs.second->resolve("OBJ_sn2nid")))) qsslSocketCannotResolveSymbolWarning("OBJ_sn2nid");

553

if (!(_q_OBJ_ln2nid = _q_PTR_OBJ_ln2nid(libs.first->resolve("OBJ_ln2nid"))) && !(_q_OBJ_ln2nid = _q_PTR_OBJ_ln2nid(libs.second->resolve("OBJ_ln2nid")))) qsslSocketCannotResolveSymbolWarning("OBJ_ln2nid");

554

if (!(_q_i2t_ASN1_OBJECT = _q_PTR_i2t_ASN1_OBJECT(libs.first->resolve("i2t_ASN1_OBJECT"))) && !(_q_i2t_ASN1_OBJECT = _q_PTR_i2t_ASN1_OBJECT(libs.second->resolve("i2t_ASN1_OBJECT")))) qsslSocketCannotResolveSymbolWarning("i2t_ASN1_OBJECT");

555

if (!(_q_OBJ_obj2txt = _q_PTR_OBJ_obj2txt(libs.first->resolve("OBJ_obj2txt"))) && !(_q_OBJ_obj2txt = _q_PTR_OBJ_obj2txt(libs.second->resolve("OBJ_obj2txt")))) qsslSocketCannotResolveSymbolWarning("OBJ_obj2txt");

556

if (!(_q_OBJ_obj2nid = _q_PTR_OBJ_obj2nid(libs.first->resolve("OBJ_obj2nid"))) && !(_q_OBJ_obj2nid = _q_PTR_OBJ_obj2nid(libs.second->resolve("OBJ_obj2nid")))) qsslSocketCannotResolveSymbolWarning("OBJ_obj2nid");

if (!(_q_PEM_read_bio_DSAPrivateKey = _q_PTR_PEM_read_bio_DSAPrivateKey(libs.first->resolve("PEM_read_bio_DSAPrivateKey"))) && !(_q_PEM_read_bio_DSAPrivateKey = _q_PTR_PEM_read_bio_DSAPrivateKey(libs.second->resolve("PEM_read_bio_DSAPrivateKey")))) qsslSocketCannotResolveSymbolWarning("PEM_read_bio_DSAPrivateKey");

561

if (!(_q_PEM_read_bio_RSAPrivateKey = _q_PTR_PEM_read_bio_RSAPrivateKey(libs.first->resolve("PEM_read_bio_RSAPrivateKey"))) && !(_q_PEM_read_bio_RSAPrivateKey = _q_PTR_PEM_read_bio_RSAPrivateKey(libs.second->resolve("PEM_read_bio_RSAPrivateKey")))) qsslSocketCannotResolveSymbolWarning("PEM_read_bio_RSAPrivateKey");

562

563

if (!(_q_PEM_read_bio_ECPrivateKey = _q_PTR_PEM_read_bio_ECPrivateKey(libs.first->resolve("PEM_read_bio_ECPrivateKey"))) && !(_q_PEM_read_bio_ECPrivateKey = _q_PTR_PEM_read_bio_ECPrivateKey(libs.second->resolve("PEM_read_bio_ECPrivateKey")))) qsslSocketCannotResolveSymbolWarning("PEM_read_bio_ECPrivateKey");

564

565

if (!(_q_PEM_write_bio_DSAPrivateKey = _q_PTR_PEM_write_bio_DSAPrivateKey(libs.first->resolve("PEM_write_bio_DSAPrivateKey"))) && !(_q_PEM_write_bio_DSAPrivateKey = _q_PTR_PEM_write_bio_DSAPrivateKey(libs.second->resolve("PEM_write_bio_DSAPrivateKey")))) qsslSocketCannotResolveSymbolWarning("PEM_write_bio_DSAPrivateKey");

566

if (!(_q_PEM_write_bio_RSAPrivateKey = _q_PTR_PEM_write_bio_RSAPrivateKey(libs.first->resolve("PEM_write_bio_RSAPrivateKey"))) && !(_q_PEM_write_bio_RSAPrivateKey = _q_PTR_PEM_write_bio_RSAPrivateKey(libs.second->resolve("PEM_write_bio_RSAPrivateKey")))) qsslSocketCannotResolveSymbolWarning("PEM_write_bio_RSAPrivateKey");

567

568

if (!(_q_PEM_write_bio_ECPrivateKey = _q_PTR_PEM_write_bio_ECPrivateKey(libs.first->resolve("PEM_write_bio_ECPrivateKey"))) && !(_q_PEM_write_bio_ECPrivateKey = _q_PTR_PEM_write_bio_ECPrivateKey(libs.second->resolve("PEM_write_bio_ECPrivateKey")))) qsslSocketCannotResolveSymbolWarning("PEM_write_bio_ECPrivateKey");

569

570

571

if (!(_q_PEM_read_bio_DSA_PUBKEY = _q_PTR_PEM_read_bio_DSA_PUBKEY(libs.first->resolve("PEM_read_bio_DSA_PUBKEY"))) && !(_q_PEM_read_bio_DSA_PUBKEY = _q_PTR_PEM_read_bio_DSA_PUBKEY(libs.second->resolve("PEM_read_bio_DSA_PUBKEY")))) qsslSocketCannotResolveSymbolWarning("PEM_read_bio_DSA_PUBKEY");

572

if (!(_q_PEM_read_bio_RSA_PUBKEY = _q_PTR_PEM_read_bio_RSA_PUBKEY(libs.first->resolve("PEM_read_bio_RSA_PUBKEY"))) && !(_q_PEM_read_bio_RSA_PUBKEY = _q_PTR_PEM_read_bio_RSA_PUBKEY(libs.second->resolve("PEM_read_bio_RSA_PUBKEY")))) qsslSocketCannotResolveSymbolWarning("PEM_read_bio_RSA_PUBKEY");

573

574

if (!(_q_PEM_read_bio_EC_PUBKEY = _q_PTR_PEM_read_bio_EC_PUBKEY(libs.first->resolve("PEM_read_bio_EC_PUBKEY"))) && !(_q_PEM_read_bio_EC_PUBKEY = _q_PTR_PEM_read_bio_EC_PUBKEY(libs.second->resolve("PEM_read_bio_EC_PUBKEY")))) qsslSocketCannotResolveSymbolWarning("PEM_read_bio_EC_PUBKEY");

575

576

if (!(_q_PEM_write_bio_DSA_PUBKEY = _q_PTR_PEM_write_bio_DSA_PUBKEY(libs.first->resolve("PEM_write_bio_DSA_PUBKEY"))) && !(_q_PEM_write_bio_DSA_PUBKEY = _q_PTR_PEM_write_bio_DSA_PUBKEY(libs.second->resolve("PEM_write_bio_DSA_PUBKEY")))) qsslSocketCannotResolveSymbolWarning("PEM_write_bio_DSA_PUBKEY");

577

if (!(_q_PEM_write_bio_RSA_PUBKEY = _q_PTR_PEM_write_bio_RSA_PUBKEY(libs.first->resolve("PEM_write_bio_RSA_PUBKEY"))) && !(_q_PEM_write_bio_RSA_PUBKEY = _q_PTR_PEM_write_bio_RSA_PUBKEY(libs.second->resolve("PEM_write_bio_RSA_PUBKEY")))) qsslSocketCannotResolveSymbolWarning("PEM_write_bio_RSA_PUBKEY");

578

579

if (!(_q_PEM_write_bio_EC_PUBKEY = _q_PTR_PEM_write_bio_EC_PUBKEY(libs.first->resolve("PEM_write_bio_EC_PUBKEY"))) && !(_q_PEM_write_bio_EC_PUBKEY = _q_PTR_PEM_write_bio_EC_PUBKEY(libs.second->resolve("PEM_write_bio_EC_PUBKEY")))) qsslSocketCannotResolveSymbolWarning("PEM_write_bio_EC_PUBKEY");

580

581

if (!(_q_RAND_seed = _q_PTR_RAND_seed(libs.first->resolve("RAND_seed"))) && !(_q_RAND_seed = _q_PTR_RAND_seed(libs.second->resolve("RAND_seed")))) qsslSocketCannotResolveSymbolWarning("RAND_seed");

582

if (!(_q_RAND_status = _q_PTR_RAND_status(libs.first->resolve("RAND_status"))) && !(_q_RAND_status = _q_PTR_RAND_status(libs.second->resolve("RAND_status")))) qsslSocketCannotResolveSymbolWarning("RAND_status");

583

if (!(_q_RSA_new = _q_PTR_RSA_new(libs.first->resolve("RSA_new"))) && !(_q_RSA_new = _q_PTR_RSA_new(libs.second->resolve("RSA_new")))) qsslSocketCannotResolveSymbolWarning("RSA_new");

584

if (!(_q_RSA_free = _q_PTR_RSA_free(libs.first->resolve("RSA_free"))) && !(_q_RSA_free = _q_PTR_RSA_free(libs.second->resolve("RSA_free")))) qsslSocketCannotResolveSymbolWarning("RSA_free");

585

if (!(_q_sk_new_null = _q_PTR_sk_new_null(libs.first->resolve("sk_new_null"))) && !(_q_sk_new_null = _q_PTR_sk_new_null(libs.second->resolve("sk_new_null")))) qsslSocketCannotResolveSymbolWarning("sk_new_null");

586

if (!(_q_sk_push = _q_PTR_sk_push(libs.first->resolve("sk_push"))) && !(_q_sk_push = _q_PTR_sk_push(libs.second->resolve("sk_push")))) qsslSocketCannotResolveSymbolWarning("sk_push");

587

if (!(_q_sk_free = _q_PTR_sk_free(libs.first->resolve("sk_free"))) && !(_q_sk_free = _q_PTR_sk_free(libs.second->resolve("sk_free")))) qsslSocketCannotResolveSymbolWarning("sk_free");

588

if (!(_q_sk_num = _q_PTR_sk_num(libs.first->resolve("sk_num"))) && !(_q_sk_num = _q_PTR_sk_num(libs.second->resolve("sk_num")))) qsslSocketCannotResolveSymbolWarning("sk_num");

589

if (!(_q_sk_pop_free = _q_PTR_sk_pop_free(libs.first->resolve("sk_pop_free"))) && !(_q_sk_pop_free = _q_PTR_sk_pop_free(libs.second->resolve("sk_pop_free")))) qsslSocketCannotResolveSymbolWarning("sk_pop_free");

590

if (!(_q_sk_value = _q_PTR_sk_value(libs.first->resolve("sk_value"))) && !(_q_sk_value = _q_PTR_sk_value(libs.second->resolve("sk_value")))) qsslSocketCannotResolveSymbolWarning("sk_value");

591

if (!(_q_SSL_CIPHER_description = _q_PTR_SSL_CIPHER_description(libs.first->resolve("SSL_CIPHER_description"))) && !(_q_SSL_CIPHER_description = _q_PTR_SSL_CIPHER_description(libs.second->resolve("SSL_CIPHER_description")))) qsslSocketCannotResolveSymbolWarning("SSL_CIPHER_description");

592

if (!(_q_SSL_CIPHER_get_bits = _q_PTR_SSL_CIPHER_get_bits(libs.first->resolve("SSL_CIPHER_get_bits"))) && !(_q_SSL_CIPHER_get_bits = _q_PTR_SSL_CIPHER_get_bits(libs.second->resolve("SSL_CIPHER_get_bits")))) qsslSocketCannotResolveSymbolWarning("SSL_CIPHER_get_bits");

593

if (!(_q_SSL_CTX_check_private_key = _q_PTR_SSL_CTX_check_private_key(libs.first->resolve("SSL_CTX_check_private_key"))) && !(_q_SSL_CTX_check_private_key = _q_PTR_SSL_CTX_check_private_key(libs.second->resolve("SSL_CTX_check_private_key")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_check_private_key");

594

if (!(_q_SSL_CTX_ctrl = _q_PTR_SSL_CTX_ctrl(libs.first->resolve("SSL_CTX_ctrl"))) && !(_q_SSL_CTX_ctrl = _q_PTR_SSL_CTX_ctrl(libs.second->resolve("SSL_CTX_ctrl")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_ctrl");

595

if (!(_q_SSL_CTX_free = _q_PTR_SSL_CTX_free(libs.first->resolve("SSL_CTX_free"))) && !(_q_SSL_CTX_free = _q_PTR_SSL_CTX_free(libs.second->resolve("SSL_CTX_free")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_free");

596

if (!(_q_SSL_CTX_new = _q_PTR_SSL_CTX_new(libs.first->resolve("SSL_CTX_new"))) && !(_q_SSL_CTX_new = _q_PTR_SSL_CTX_new(libs.second->resolve("SSL_CTX_new")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_new");

597

if (!(_q_SSL_CTX_set_cipher_list = _q_PTR_SSL_CTX_set_cipher_list(libs.first->resolve("SSL_CTX_set_cipher_list"))) && !(_q_SSL_CTX_set_cipher_list = _q_PTR_SSL_CTX_set_cipher_list(libs.second->resolve("SSL_CTX_set_cipher_list")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_set_cipher_list");

598

if (!(_q_SSL_CTX_set_default_verify_paths = _q_PTR_SSL_CTX_set_default_verify_paths(libs.first->resolve("SSL_CTX_set_default_verify_paths"))) && !(_q_SSL_CTX_set_default_verify_paths = _q_PTR_SSL_CTX_set_default_verify_paths(libs.second->resolve("SSL_CTX_set_default_verify_paths")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_set_default_verify_paths");

599

if (!(_q_SSL_CTX_set_verify = _q_PTR_SSL_CTX_set_verify(libs.first->resolve("SSL_CTX_set_verify"))) && !(_q_SSL_CTX_set_verify = _q_PTR_SSL_CTX_set_verify(libs.second->resolve("SSL_CTX_set_verify")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_set_verify");

600

if (!(_q_SSL_CTX_set_verify_depth = _q_PTR_SSL_CTX_set_verify_depth(libs.first->resolve("SSL_CTX_set_verify_depth"))) && !(_q_SSL_CTX_set_verify_depth = _q_PTR_SSL_CTX_set_verify_depth(libs.second->resolve("SSL_CTX_set_verify_depth")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_set_verify_depth");

601

if (!(_q_SSL_CTX_use_certificate = _q_PTR_SSL_CTX_use_certificate(libs.first->resolve("SSL_CTX_use_certificate"))) && !(_q_SSL_CTX_use_certificate = _q_PTR_SSL_CTX_use_certificate(libs.second->resolve("SSL_CTX_use_certificate")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_use_certificate");

602

if (!(_q_SSL_CTX_use_certificate_file = _q_PTR_SSL_CTX_use_certificate_file(libs.first->resolve("SSL_CTX_use_certificate_file"))) && !(_q_SSL_CTX_use_certificate_file = _q_PTR_SSL_CTX_use_certificate_file(libs.second->resolve("SSL_CTX_use_certificate_file")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_use_certificate_file");

603

if (!(_q_SSL_CTX_use_PrivateKey = _q_PTR_SSL_CTX_use_PrivateKey(libs.first->resolve("SSL_CTX_use_PrivateKey"))) && !(_q_SSL_CTX_use_PrivateKey = _q_PTR_SSL_CTX_use_PrivateKey(libs.second->resolve("SSL_CTX_use_PrivateKey")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_use_PrivateKey");

604

if (!(_q_SSL_CTX_use_RSAPrivateKey = _q_PTR_SSL_CTX_use_RSAPrivateKey(libs.first->resolve("SSL_CTX_use_RSAPrivateKey"))) && !(_q_SSL_CTX_use_RSAPrivateKey = _q_PTR_SSL_CTX_use_RSAPrivateKey(libs.second->resolve("SSL_CTX_use_RSAPrivateKey")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_use_RSAPrivateKey");

605

if (!(_q_SSL_CTX_use_PrivateKey_file = _q_PTR_SSL_CTX_use_PrivateKey_file(libs.first->resolve("SSL_CTX_use_PrivateKey_file"))) && !(_q_SSL_CTX_use_PrivateKey_file = _q_PTR_SSL_CTX_use_PrivateKey_file(libs.second->resolve("SSL_CTX_use_PrivateKey_file")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_use_PrivateKey_file");

606

if (!(_q_SSL_CTX_get_cert_store = _q_PTR_SSL_CTX_get_cert_store(libs.first->resolve("SSL_CTX_get_cert_store"))) && !(_q_SSL_CTX_get_cert_store = _q_PTR_SSL_CTX_get_cert_store(libs.second->resolve("SSL_CTX_get_cert_store")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_get_cert_store");;

607

if (!(_q_SSL_accept = _q_PTR_SSL_accept(libs.first->resolve("SSL_accept"))) && !(_q_SSL_accept = _q_PTR_SSL_accept(libs.second->resolve("SSL_accept")))) qsslSocketCannotResolveSymbolWarning("SSL_accept");

608

if (!(_q_SSL_clear = _q_PTR_SSL_clear(libs.first->resolve("SSL_clear"))) && !(_q_SSL_clear = _q_PTR_SSL_clear(libs.second->resolve("SSL_clear")))) qsslSocketCannotResolveSymbolWarning("SSL_clear");

609

if (!(_q_SSL_connect = _q_PTR_SSL_connect(libs.first->resolve("SSL_connect"))) && !(_q_SSL_connect = _q_PTR_SSL_connect(libs.second->resolve("SSL_connect")))) qsslSocketCannotResolveSymbolWarning("SSL_connect");

610

if (!(_q_SSL_free = _q_PTR_SSL_free(libs.first->resolve("SSL_free"))) && !(_q_SSL_free = _q_PTR_SSL_free(libs.second->resolve("SSL_free")))) qsslSocketCannotResolveSymbolWarning("SSL_free");

611

if (!(_q_SSL_get_ciphers = _q_PTR_SSL_get_ciphers(libs.first->resolve("SSL_get_ciphers"))) && !(_q_SSL_get_ciphers = _q_PTR_SSL_get_ciphers(libs.second->resolve("SSL_get_ciphers")))) qsslSocketCannotResolveSymbolWarning("SSL_get_ciphers");

612

if (!(_q_SSL_get_current_cipher = _q_PTR_SSL_get_current_cipher(libs.first->resolve("SSL_get_current_cipher"))) && !(_q_SSL_get_current_cipher = _q_PTR_SSL_get_current_cipher(libs.second->resolve("SSL_get_current_cipher")))) qsslSocketCannotResolveSymbolWarning("SSL_get_current_cipher");

613

if (!(_q_SSL_version = _q_PTR_SSL_version(libs.first->resolve("SSL_version"))) && !(_q_SSL_version = _q_PTR_SSL_version(libs.second->resolve("SSL_version")))) qsslSocketCannotResolveSymbolWarning("SSL_version");

614

if (!(_q_SSL_get_error = _q_PTR_SSL_get_error(libs.first->resolve("SSL_get_error"))) && !(_q_SSL_get_error = _q_PTR_SSL_get_error(libs.second->resolve("SSL_get_error")))) qsslSocketCannotResolveSymbolWarning("SSL_get_error");

615

if (!(_q_SSL_get_peer_cert_chain = _q_PTR_SSL_get_peer_cert_chain(libs.first->resolve("SSL_get_peer_cert_chain"))) && !(_q_SSL_get_peer_cert_chain = _q_PTR_SSL_get_peer_cert_chain(libs.second->resolve("SSL_get_peer_cert_chain")))) qsslSocketCannotResolveSymbolWarning("SSL_get_peer_cert_chain");

616

if (!(_q_SSL_get_peer_certificate = _q_PTR_SSL_get_peer_certificate(libs.first->resolve("SSL_get_peer_certificate"))) && !(_q_SSL_get_peer_certificate = _q_PTR_SSL_get_peer_certificate(libs.second->resolve("SSL_get_peer_certificate")))) qsslSocketCannotResolveSymbolWarning("SSL_get_peer_certificate");

617

if (!(_q_SSL_get_verify_result = _q_PTR_SSL_get_verify_result(libs.first->resolve("SSL_get_verify_result"))) && !(_q_SSL_get_verify_result = _q_PTR_SSL_get_verify_result(libs.second->resolve("SSL_get_verify_result")))) qsslSocketCannotResolveSymbolWarning("SSL_get_verify_result");

618

if (!(_q_SSL_library_init = _q_PTR_SSL_library_init(libs.first->resolve("SSL_library_init"))) && !(_q_SSL_library_init = _q_PTR_SSL_library_init(libs.second->resolve("SSL_library_init")))) qsslSocketCannotResolveSymbolWarning("SSL_library_init");

619

if (!(_q_SSL_load_error_strings = _q_PTR_SSL_load_error_strings(libs.first->resolve("SSL_load_error_strings"))) && !(_q_SSL_load_error_strings = _q_PTR_SSL_load_error_strings(libs.second->resolve("SSL_load_error_strings")))) qsslSocketCannotResolveSymbolWarning("SSL_load_error_strings");

620

if (!(_q_SSL_new = _q_PTR_SSL_new(libs.first->resolve("SSL_new"))) && !(_q_SSL_new = _q_PTR_SSL_new(libs.second->resolve("SSL_new")))) qsslSocketCannotResolveSymbolWarning("SSL_new");

621

if (!(_q_SSL_ctrl = _q_PTR_SSL_ctrl(libs.first->resolve("SSL_ctrl"))) && !(_q_SSL_ctrl = _q_PTR_SSL_ctrl(libs.second->resolve("SSL_ctrl")))) qsslSocketCannotResolveSymbolWarning("SSL_ctrl");

622

if (!(_q_SSL_read = _q_PTR_SSL_read(libs.first->resolve("SSL_read"))) && !(_q_SSL_read = _q_PTR_SSL_read(libs.second->resolve("SSL_read")))) qsslSocketCannotResolveSymbolWarning("SSL_read");

623

if (!(_q_SSL_set_accept_state = _q_PTR_SSL_set_accept_state(libs.first->resolve("SSL_set_accept_state"))) && !(_q_SSL_set_accept_state = _q_PTR_SSL_set_accept_state(libs.second->resolve("SSL_set_accept_state")))) qsslSocketCannotResolveSymbolWarning("SSL_set_accept_state");

624

if (!(_q_SSL_set_bio = _q_PTR_SSL_set_bio(libs.first->resolve("SSL_set_bio"))) && !(_q_SSL_set_bio = _q_PTR_SSL_set_bio(libs.second->resolve("SSL_set_bio")))) qsslSocketCannotResolveSymbolWarning("SSL_set_bio");

625

if (!(_q_SSL_set_connect_state = _q_PTR_SSL_set_connect_state(libs.first->resolve("SSL_set_connect_state"))) && !(_q_SSL_set_connect_state = _q_PTR_SSL_set_connect_state(libs.second->resolve("SSL_set_connect_state")))) qsslSocketCannotResolveSymbolWarning("SSL_set_connect_state");

626

if (!(_q_SSL_shutdown = _q_PTR_SSL_shutdown(libs.first->resolve("SSL_shutdown"))) && !(_q_SSL_shutdown = _q_PTR_SSL_shutdown(libs.second->resolve("SSL_shutdown")))) qsslSocketCannotResolveSymbolWarning("SSL_shutdown");

627

if (!(_q_SSL_set_session = _q_PTR_SSL_set_session(libs.first->resolve("SSL_set_session"))) && !(_q_SSL_set_session = _q_PTR_SSL_set_session(libs.second->resolve("SSL_set_session")))) qsslSocketCannotResolveSymbolWarning("SSL_set_session");

628

if (!(_q_SSL_SESSION_free = _q_PTR_SSL_SESSION_free(libs.first->resolve("SSL_SESSION_free"))) && !(_q_SSL_SESSION_free = _q_PTR_SSL_SESSION_free(libs.second->resolve("SSL_SESSION_free")))) qsslSocketCannotResolveSymbolWarning("SSL_SESSION_free");

629

if (!(_q_SSL_get1_session = _q_PTR_SSL_get1_session(libs.first->resolve("SSL_get1_session"))) && !(_q_SSL_get1_session = _q_PTR_SSL_get1_session(libs.second->resolve("SSL_get1_session")))) qsslSocketCannotResolveSymbolWarning("SSL_get1_session");

630

if (!(_q_SSL_get_session = _q_PTR_SSL_get_session(libs.first->resolve("SSL_get_session"))) && !(_q_SSL_get_session = _q_PTR_SSL_get_session(libs.second->resolve("SSL_get_session")))) qsslSocketCannotResolveSymbolWarning("SSL_get_session");

631

632

if (!(_q_SSL_get_ex_new_index = _q_PTR_SSL_get_ex_new_index(libs.first->resolve("SSL_get_ex_new_index"))) && !(_q_SSL_get_ex_new_index = _q_PTR_SSL_get_ex_new_index(libs.second->resolve("SSL_get_ex_new_index")))) qsslSocketCannotResolveSymbolWarning("SSL_get_ex_new_index");

633

if (!(_q_SSL_set_ex_data = _q_PTR_SSL_set_ex_data(libs.first->resolve("SSL_set_ex_data"))) && !(_q_SSL_set_ex_data = _q_PTR_SSL_set_ex_data(libs.second->resolve("SSL_set_ex_data")))) qsslSocketCannotResolveSymbolWarning("SSL_set_ex_data");

634

if (!(_q_SSL_get_ex_data = _q_PTR_SSL_get_ex_data(libs.first->resolve("SSL_get_ex_data"))) && !(_q_SSL_get_ex_data = _q_PTR_SSL_get_ex_data(libs.second->resolve("SSL_get_ex_data")))) qsslSocketCannotResolveSymbolWarning("SSL_get_ex_data");

635

636

637

if (!(_q_SSL_set_psk_client_callback = _q_PTR_SSL_set_psk_client_callback(libs.first->resolve("SSL_set_psk_client_callback"))) && !(_q_SSL_set_psk_client_callback = _q_PTR_SSL_set_psk_client_callback(libs.second->resolve("SSL_set_psk_client_callback")))) qsslSocketCannotResolveSymbolWarning("SSL_set_psk_client_callback");

638

639

if (!(_q_SSL_write = _q_PTR_SSL_write(libs.first->resolve("SSL_write"))) && !(_q_SSL_write = _q_PTR_SSL_write(libs.second->resolve("SSL_write")))) qsslSocketCannotResolveSymbolWarning("SSL_write");

if (!(_q_SSLv3_client_method = _q_PTR_SSLv3_client_method(libs.first->resolve("SSLv3_client_method"))) && !(_q_SSLv3_client_method = _q_PTR_SSLv3_client_method(libs.second->resolve("SSLv3_client_method")))) qsslSocketCannotResolveSymbolWarning("SSLv3_client_method");

645

646

if (!(_q_SSLv23_client_method = _q_PTR_SSLv23_client_method(libs.first->resolve("SSLv23_client_method"))) && !(_q_SSLv23_client_method = _q_PTR_SSLv23_client_method(libs.second->resolve("SSLv23_client_method")))) qsslSocketCannotResolveSymbolWarning("SSLv23_client_method");

647

if (!(_q_TLSv1_client_method = _q_PTR_TLSv1_client_method(libs.first->resolve("TLSv1_client_method"))) && !(_q_TLSv1_client_method = _q_PTR_TLSv1_client_method(libs.second->resolve("TLSv1_client_method")))) qsslSocketCannotResolveSymbolWarning("TLSv1_client_method");

648

649

if (!(_q_TLSv1_1_client_method = _q_PTR_TLSv1_1_client_method(libs.first->resolve("TLSv1_1_client_method"))) && !(_q_TLSv1_1_client_method = _q_PTR_TLSv1_1_client_method(libs.second->resolve("TLSv1_1_client_method")))) qsslSocketCannotResolveSymbolWarning("TLSv1_1_client_method");

650

if (!(_q_TLSv1_2_client_method = _q_PTR_TLSv1_2_client_method(libs.first->resolve("TLSv1_2_client_method"))) && !(_q_TLSv1_2_client_method = _q_PTR_TLSv1_2_client_method(libs.second->resolve("TLSv1_2_client_method")))) qsslSocketCannotResolveSymbolWarning("TLSv1_2_client_method");

if (!(_q_SSLv3_server_method = _q_PTR_SSLv3_server_method(libs.first->resolve("SSLv3_server_method"))) && !(_q_SSLv3_server_method = _q_PTR_SSLv3_server_method(libs.second->resolve("SSLv3_server_method")))) qsslSocketCannotResolveSymbolWarning("SSLv3_server_method");

657

658

if (!(_q_SSLv23_server_method = _q_PTR_SSLv23_server_method(libs.first->resolve("SSLv23_server_method"))) && !(_q_SSLv23_server_method = _q_PTR_SSLv23_server_method(libs.second->resolve("SSLv23_server_method")))) qsslSocketCannotResolveSymbolWarning("SSLv23_server_method");

659

if (!(_q_TLSv1_server_method = _q_PTR_TLSv1_server_method(libs.first->resolve("TLSv1_server_method"))) && !(_q_TLSv1_server_method = _q_PTR_TLSv1_server_method(libs.second->resolve("TLSv1_server_method")))) qsslSocketCannotResolveSymbolWarning("TLSv1_server_method");

660

661

if (!(_q_TLSv1_1_server_method = _q_PTR_TLSv1_1_server_method(libs.first->resolve("TLSv1_1_server_method"))) && !(_q_TLSv1_1_server_method = _q_PTR_TLSv1_1_server_method(libs.second->resolve("TLSv1_1_server_method")))) qsslSocketCannotResolveSymbolWarning("TLSv1_1_server_method");

662

if (!(_q_TLSv1_2_server_method = _q_PTR_TLSv1_2_server_method(libs.first->resolve("TLSv1_2_server_method"))) && !(_q_TLSv1_2_server_method = _q_PTR_TLSv1_2_server_method(libs.second->resolve("TLSv1_2_server_method")))) qsslSocketCannotResolveSymbolWarning("TLSv1_2_server_method");

663

664

if (!(_q_X509_NAME_entry_count = _q_PTR_X509_NAME_entry_count(libs.first->resolve("X509_NAME_entry_count"))) && !(_q_X509_NAME_entry_count = _q_PTR_X509_NAME_entry_count(libs.second->resolve("X509_NAME_entry_count")))) qsslSocketCannotResolveSymbolWarning("X509_NAME_entry_count");

665

if (!(_q_X509_NAME_get_entry = _q_PTR_X509_NAME_get_entry(libs.first->resolve("X509_NAME_get_entry"))) && !(_q_X509_NAME_get_entry = _q_PTR_X509_NAME_get_entry(libs.second->resolve("X509_NAME_get_entry")))) qsslSocketCannotResolveSymbolWarning("X509_NAME_get_entry");

666

if (!(_q_X509_NAME_ENTRY_get_data = _q_PTR_X509_NAME_ENTRY_get_data(libs.first->resolve("X509_NAME_ENTRY_get_data"))) && !(_q_X509_NAME_ENTRY_get_data = _q_PTR_X509_NAME_ENTRY_get_data(libs.second->resolve("X509_NAME_ENTRY_get_data")))) qsslSocketCannotResolveSymbolWarning("X509_NAME_ENTRY_get_data");

667

if (!(_q_X509_NAME_ENTRY_get_object = _q_PTR_X509_NAME_ENTRY_get_object(libs.first->resolve("X509_NAME_ENTRY_get_object"))) && !(_q_X509_NAME_ENTRY_get_object = _q_PTR_X509_NAME_ENTRY_get_object(libs.second->resolve("X509_NAME_ENTRY_get_object")))) qsslSocketCannotResolveSymbolWarning("X509_NAME_ENTRY_get_object");

668

if (!(_q_X509_PUBKEY_get = _q_PTR_X509_PUBKEY_get(libs.first->resolve("X509_PUBKEY_get"))) && !(_q_X509_PUBKEY_get = _q_PTR_X509_PUBKEY_get(libs.second->resolve("X509_PUBKEY_get")))) qsslSocketCannotResolveSymbolWarning("X509_PUBKEY_get");

669

if (!(_q_X509_STORE_free = _q_PTR_X509_STORE_free(libs.first->resolve("X509_STORE_free"))) && !(_q_X509_STORE_free = _q_PTR_X509_STORE_free(libs.second->resolve("X509_STORE_free")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_free");

670

if (!(_q_X509_STORE_new = _q_PTR_X509_STORE_new(libs.first->resolve("X509_STORE_new"))) && !(_q_X509_STORE_new = _q_PTR_X509_STORE_new(libs.second->resolve("X509_STORE_new")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_new");

671

if (!(_q_X509_STORE_add_cert = _q_PTR_X509_STORE_add_cert(libs.first->resolve("X509_STORE_add_cert"))) && !(_q_X509_STORE_add_cert = _q_PTR_X509_STORE_add_cert(libs.second->resolve("X509_STORE_add_cert")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_add_cert");

672

if (!(_q_X509_STORE_CTX_free = _q_PTR_X509_STORE_CTX_free(libs.first->resolve("X509_STORE_CTX_free"))) && !(_q_X509_STORE_CTX_free = _q_PTR_X509_STORE_CTX_free(libs.second->resolve("X509_STORE_CTX_free")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_CTX_free");

673

if (!(_q_X509_STORE_CTX_init = _q_PTR_X509_STORE_CTX_init(libs.first->resolve("X509_STORE_CTX_init"))) && !(_q_X509_STORE_CTX_init = _q_PTR_X509_STORE_CTX_init(libs.second->resolve("X509_STORE_CTX_init")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_CTX_init");

674

if (!(_q_X509_STORE_CTX_new = _q_PTR_X509_STORE_CTX_new(libs.first->resolve("X509_STORE_CTX_new"))) && !(_q_X509_STORE_CTX_new = _q_PTR_X509_STORE_CTX_new(libs.second->resolve("X509_STORE_CTX_new")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_CTX_new");

675

if (!(_q_X509_STORE_CTX_set_purpose = _q_PTR_X509_STORE_CTX_set_purpose(libs.first->resolve("X509_STORE_CTX_set_purpose"))) && !(_q_X509_STORE_CTX_set_purpose = _q_PTR_X509_STORE_CTX_set_purpose(libs.second->resolve("X509_STORE_CTX_set_purpose")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_CTX_set_purpose");

676

if (!(_q_X509_STORE_CTX_get_error = _q_PTR_X509_STORE_CTX_get_error(libs.first->resolve("X509_STORE_CTX_get_error"))) && !(_q_X509_STORE_CTX_get_error = _q_PTR_X509_STORE_CTX_get_error(libs.second->resolve("X509_STORE_CTX_get_error")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_CTX_get_error");

677

if (!(_q_X509_STORE_CTX_get_error_depth = _q_PTR_X509_STORE_CTX_get_error_depth(libs.first->resolve("X509_STORE_CTX_get_error_depth"))) && !(_q_X509_STORE_CTX_get_error_depth = _q_PTR_X509_STORE_CTX_get_error_depth(libs.second->resolve("X509_STORE_CTX_get_error_depth")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_CTX_get_error_depth");

678

if (!(_q_X509_STORE_CTX_get_current_cert = _q_PTR_X509_STORE_CTX_get_current_cert(libs.first->resolve("X509_STORE_CTX_get_current_cert"))) && !(_q_X509_STORE_CTX_get_current_cert = _q_PTR_X509_STORE_CTX_get_current_cert(libs.second->resolve("X509_STORE_CTX_get_current_cert")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_CTX_get_current_cert");

679

if (!(_q_X509_STORE_CTX_get_chain = _q_PTR_X509_STORE_CTX_get_chain(libs.first->resolve("X509_STORE_CTX_get_chain"))) && !(_q_X509_STORE_CTX_get_chain = _q_PTR_X509_STORE_CTX_get_chain(libs.second->resolve("X509_STORE_CTX_get_chain")))) qsslSocketCannotResolveSymbolWarning("X509_STORE_CTX_get_chain");

680

if (!(_q_X509_cmp = _q_PTR_X509_cmp(libs.first->resolve("X509_cmp"))) && !(_q_X509_cmp = _q_PTR_X509_cmp(libs.second->resolve("X509_cmp")))) qsslSocketCannotResolveSymbolWarning("X509_cmp");

681

682

if (!(_q_X509_dup = _q_PTR_X509_dup(libs.first->resolve("X509_dup"))) && !(_q_X509_dup = _q_PTR_X509_dup(libs.second->resolve("X509_dup")))) qsslSocketCannotResolveSymbolWarning("X509_dup");

683

684

if (!(_q_X509_print = _q_PTR_X509_print(libs.first->resolve("X509_print"))) && !(_q_X509_print = _q_PTR_X509_print(libs.second->resolve("X509_print")))) qsslSocketCannotResolveSymbolWarning("X509_print");

685

if (!(_q_X509_EXTENSION_get_object = _q_PTR_X509_EXTENSION_get_object(libs.first->resolve("X509_EXTENSION_get_object"))) && !(_q_X509_EXTENSION_get_object = _q_PTR_X509_EXTENSION_get_object(libs.second->resolve("X509_EXTENSION_get_object")))) qsslSocketCannotResolveSymbolWarning("X509_EXTENSION_get_object");

686

if (!(_q_X509_free = _q_PTR_X509_free(libs.first->resolve("X509_free"))) && !(_q_X509_free = _q_PTR_X509_free(libs.second->resolve("X509_free")))) qsslSocketCannotResolveSymbolWarning("X509_free");

687

if (!(_q_X509_get_ext = _q_PTR_X509_get_ext(libs.first->resolve("X509_get_ext"))) && !(_q_X509_get_ext = _q_PTR_X509_get_ext(libs.second->resolve("X509_get_ext")))) qsslSocketCannotResolveSymbolWarning("X509_get_ext");

688

if (!(_q_X509_get_ext_count = _q_PTR_X509_get_ext_count(libs.first->resolve("X509_get_ext_count"))) && !(_q_X509_get_ext_count = _q_PTR_X509_get_ext_count(libs.second->resolve("X509_get_ext_count")))) qsslSocketCannotResolveSymbolWarning("X509_get_ext_count");

689

if (!(_q_X509_get_ext_d2i = _q_PTR_X509_get_ext_d2i(libs.first->resolve("X509_get_ext_d2i"))) && !(_q_X509_get_ext_d2i = _q_PTR_X509_get_ext_d2i(libs.second->resolve("X509_get_ext_d2i")))) qsslSocketCannotResolveSymbolWarning("X509_get_ext_d2i");

690

if (!(_q_X509V3_EXT_get = _q_PTR_X509V3_EXT_get(libs.first->resolve("X509V3_EXT_get"))) && !(_q_X509V3_EXT_get = _q_PTR_X509V3_EXT_get(libs.second->resolve("X509V3_EXT_get")))) qsslSocketCannotResolveSymbolWarning("X509V3_EXT_get");

691

if (!(_q_X509V3_EXT_d2i = _q_PTR_X509V3_EXT_d2i(libs.first->resolve("X509V3_EXT_d2i"))) && !(_q_X509V3_EXT_d2i = _q_PTR_X509V3_EXT_d2i(libs.second->resolve("X509V3_EXT_d2i")))) qsslSocketCannotResolveSymbolWarning("X509V3_EXT_d2i");

692

if (!(_q_X509_EXTENSION_get_critical = _q_PTR_X509_EXTENSION_get_critical(libs.first->resolve("X509_EXTENSION_get_critical"))) && !(_q_X509_EXTENSION_get_critical = _q_PTR_X509_EXTENSION_get_critical(libs.second->resolve("X509_EXTENSION_get_critical")))) qsslSocketCannotResolveSymbolWarning("X509_EXTENSION_get_critical");

693

if (!(_q_X509_EXTENSION_get_data = _q_PTR_X509_EXTENSION_get_data(libs.first->resolve("X509_EXTENSION_get_data"))) && !(_q_X509_EXTENSION_get_data = _q_PTR_X509_EXTENSION_get_data(libs.second->resolve("X509_EXTENSION_get_data")))) qsslSocketCannotResolveSymbolWarning("X509_EXTENSION_get_data");

694

if (!(_q_BASIC_CONSTRAINTS_free = _q_PTR_BASIC_CONSTRAINTS_free(libs.first->resolve("BASIC_CONSTRAINTS_free"))) && !(_q_BASIC_CONSTRAINTS_free = _q_PTR_BASIC_CONSTRAINTS_free(libs.second->resolve("BASIC_CONSTRAINTS_free")))) qsslSocketCannotResolveSymbolWarning("BASIC_CONSTRAINTS_free");

695

if (!(_q_AUTHORITY_KEYID_free = _q_PTR_AUTHORITY_KEYID_free(libs.first->resolve("AUTHORITY_KEYID_free"))) && !(_q_AUTHORITY_KEYID_free = _q_PTR_AUTHORITY_KEYID_free(libs.second->resolve("AUTHORITY_KEYID_free")))) qsslSocketCannotResolveSymbolWarning("AUTHORITY_KEYID_free");

696

if (!(_q_ASN1_STRING_print = _q_PTR_ASN1_STRING_print(libs.first->resolve("ASN1_STRING_print"))) && !(_q_ASN1_STRING_print = _q_PTR_ASN1_STRING_print(libs.second->resolve("ASN1_STRING_print")))) qsslSocketCannotResolveSymbolWarning("ASN1_STRING_print");

697

if (!(_q_X509_check_issued = _q_PTR_X509_check_issued(libs.first->resolve("X509_check_issued"))) && !(_q_X509_check_issued = _q_PTR_X509_check_issued(libs.second->resolve("X509_check_issued")))) qsslSocketCannotResolveSymbolWarning("X509_check_issued");

698

if (!(_q_X509_get_issuer_name = _q_PTR_X509_get_issuer_name(libs.first->resolve("X509_get_issuer_name"))) && !(_q_X509_get_issuer_name = _q_PTR_X509_get_issuer_name(libs.second->resolve("X509_get_issuer_name")))) qsslSocketCannotResolveSymbolWarning("X509_get_issuer_name");

699

if (!(_q_X509_get_subject_name = _q_PTR_X509_get_subject_name(libs.first->resolve("X509_get_subject_name"))) && !(_q_X509_get_subject_name = _q_PTR_X509_get_subject_name(libs.second->resolve("X509_get_subject_name")))) qsslSocketCannotResolveSymbolWarning("X509_get_subject_name");

700

if (!(_q_X509_verify_cert = _q_PTR_X509_verify_cert(libs.first->resolve("X509_verify_cert"))) && !(_q_X509_verify_cert = _q_PTR_X509_verify_cert(libs.second->resolve("X509_verify_cert")))) qsslSocketCannotResolveSymbolWarning("X509_verify_cert");

701

if (!(_q_d2i_X509 = _q_PTR_d2i_X509(libs.first->resolve("d2i_X509"))) && !(_q_d2i_X509 = _q_PTR_d2i_X509(libs.second->resolve("d2i_X509")))) qsslSocketCannotResolveSymbolWarning("d2i_X509");

702

if (!(_q_i2d_X509 = _q_PTR_i2d_X509(libs.first->resolve("i2d_X509"))) && !(_q_i2d_X509 = _q_PTR_i2d_X509(libs.second->resolve("i2d_X509")))) qsslSocketCannotResolveSymbolWarning("i2d_X509");

if (!(_q_OPENSSL_add_all_algorithms_noconf = _q_PTR_OPENSSL_add_all_algorithms_noconf(libs.first->resolve("OPENSSL_add_all_algorithms_noconf"))) && !(_q_OPENSSL_add_all_algorithms_noconf = _q_PTR_OPENSSL_add_all_algorithms_noconf(libs.second->resolve("OPENSSL_add_all_algorithms_noconf")))) qsslSocketCannotResolveSymbolWarning("OPENSSL_add_all_algorithms_noconf");

710

if (!(_q_OPENSSL_add_all_algorithms_conf = _q_PTR_OPENSSL_add_all_algorithms_conf(libs.first->resolve("OPENSSL_add_all_algorithms_conf"))) && !(_q_OPENSSL_add_all_algorithms_conf = _q_PTR_OPENSSL_add_all_algorithms_conf(libs.second->resolve("OPENSSL_add_all_algorithms_conf")))) qsslSocketCannotResolveSymbolWarning("OPENSSL_add_all_algorithms_conf");

711

if (!(_q_SSL_CTX_load_verify_locations = _q_PTR_SSL_CTX_load_verify_locations(libs.first->resolve("SSL_CTX_load_verify_locations"))) && !(_q_SSL_CTX_load_verify_locations = _q_PTR_SSL_CTX_load_verify_locations(libs.second->resolve("SSL_CTX_load_verify_locations")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_load_verify_locations");

712

if (!(_q_SSLeay = _q_PTR_SSLeay(libs.first->resolve("SSLeay"))) && !(_q_SSLeay = _q_PTR_SSLeay(libs.second->resolve("SSLeay")))) qsslSocketCannotResolveSymbolWarning("SSLeay");

713

if (!(_q_SSLeay_version = _q_PTR_SSLeay_version(libs.first->resolve("SSLeay_version"))) && !(_q_SSLeay_version = _q_PTR_SSLeay_version(libs.second->resolve("SSLeay_version")))) qsslSocketCannotResolveSymbolWarning("SSLeay_version");

714

if (!(_q_i2d_SSL_SESSION = _q_PTR_i2d_SSL_SESSION(libs.first->resolve("i2d_SSL_SESSION"))) && !(_q_i2d_SSL_SESSION = _q_PTR_i2d_SSL_SESSION(libs.second->resolve("i2d_SSL_SESSION")))) qsslSocketCannotResolveSymbolWarning("i2d_SSL_SESSION");

715

if (!(_q_d2i_SSL_SESSION = _q_PTR_d2i_SSL_SESSION(libs.first->resolve("d2i_SSL_SESSION"))) && !(_q_d2i_SSL_SESSION = _q_PTR_d2i_SSL_SESSION(libs.second->resolve("d2i_SSL_SESSION")))) qsslSocketCannotResolveSymbolWarning("d2i_SSL_SESSION");

716

717

if (!(_q_SSL_select_next_proto = _q_PTR_SSL_select_next_proto(libs.first->resolve("SSL_select_next_proto"))) && !(_q_SSL_select_next_proto = _q_PTR_SSL_select_next_proto(libs.second->resolve("SSL_select_next_proto")))) qsslSocketCannotResolveSymbolWarning("SSL_select_next_proto");

718

if (!(_q_SSL_CTX_set_next_proto_select_cb = _q_PTR_SSL_CTX_set_next_proto_select_cb(libs.first->resolve("SSL_CTX_set_next_proto_select_cb"))) && !(_q_SSL_CTX_set_next_proto_select_cb = _q_PTR_SSL_CTX_set_next_proto_select_cb(libs.second->resolve("SSL_CTX_set_next_proto_select_cb")))) qsslSocketCannotResolveSymbolWarning("SSL_CTX_set_next_proto_select_cb");

719

if (!(_q_SSL_get0_next_proto_negotiated = _q_PTR_SSL_get0_next_proto_negotiated(libs.first->resolve("SSL_get0_next_proto_negotiated"))) && !(_q_SSL_get0_next_proto_negotiated = _q_PTR_SSL_get0_next_proto_negotiated(libs.second->resolve("SSL_get0_next_proto_negotiated")))) qsslSocketCannotResolveSymbolWarning("SSL_get0_next_proto_negotiated");

720

721

if (!(_q_DH_new = _q_PTR_DH_new(libs.first->resolve("DH_new"))) && !(_q_DH_new = _q_PTR_DH_new(libs.second->resolve("DH_new")))) qsslSocketCannotResolveSymbolWarning("DH_new");

722

if (!(_q_DH_free = _q_PTR_DH_free(libs.first->resolve("DH_free"))) && !(_q_DH_free = _q_PTR_DH_free(libs.second->resolve("DH_free")))) qsslSocketCannotResolveSymbolWarning("DH_free");

723

if (!(_q_d2i_DHparams = _q_PTR_d2i_DHparams(libs.first->resolve("d2i_DHparams"))) && !(_q_d2i_DHparams = _q_PTR_d2i_DHparams(libs.second->resolve("d2i_DHparams")))) qsslSocketCannotResolveSymbolWarning("d2i_DHparams");

724

if (!(_q_BN_bin2bn = _q_PTR_BN_bin2bn(libs.first->resolve("BN_bin2bn"))) && !(_q_BN_bin2bn = _q_PTR_BN_bin2bn(libs.second->resolve("BN_bin2bn")))) qsslSocketCannotResolveSymbolWarning("BN_bin2bn");

725

726

if (!(_q_EC_KEY_dup = _q_PTR_EC_KEY_dup(libs.first->resolve("EC_KEY_dup"))) && !(_q_EC_KEY_dup = _q_PTR_EC_KEY_dup(libs.second->resolve("EC_KEY_dup")))) qsslSocketCannotResolveSymbolWarning("EC_KEY_dup");

727

if (!(_q_EC_KEY_new_by_curve_name = _q_PTR_EC_KEY_new_by_curve_name(libs.first->resolve("EC_KEY_new_by_curve_name"))) && !(_q_EC_KEY_new_by_curve_name = _q_PTR_EC_KEY_new_by_curve_name(libs.second->resolve("EC_KEY_new_by_curve_name")))) qsslSocketCannotResolveSymbolWarning("EC_KEY_new_by_curve_name");

728

if (!(_q_EC_KEY_free = _q_PTR_EC_KEY_free(libs.first->resolve("EC_KEY_free"))) && !(_q_EC_KEY_free = _q_PTR_EC_KEY_free(libs.second->resolve("EC_KEY_free")))) qsslSocketCannotResolveSymbolWarning("EC_KEY_free");

729

if (!(_q_EC_get_builtin_curves = _q_PTR_EC_get_builtin_curves(libs.first->resolve("EC_get_builtin_curves"))) && !(_q_EC_get_builtin_curves = _q_PTR_EC_get_builtin_curves(libs.second->resolve("EC_get_builtin_curves")))) qsslSocketCannotResolveSymbolWarning("EC_get_builtin_curves");

if (!(_q_PKCS12_parse = _q_PTR_PKCS12_parse(libs.first->resolve("PKCS12_parse"))) && !(_q_PKCS12_parse = _q_PTR_PKCS12_parse(libs.second->resolve("PKCS12_parse")))) qsslSocketCannotResolveSymbolWarning("PKCS12_parse");

736

if (!(_q_d2i_PKCS12_bio = _q_PTR_d2i_PKCS12_bio(libs.first->resolve("d2i_PKCS12_bio"))) && !(_q_d2i_PKCS12_bio = _q_PTR_d2i_PKCS12_bio(libs.second->resolve("d2i_PKCS12_bio")))) qsslSocketCannotResolveSymbolWarning("d2i_PKCS12_bio");

737

if (!(_q_PKCS12_free = _q_PTR_PKCS12_free(libs.first->resolve("PKCS12_free"))) && !(_q_PKCS12_free = _q_PTR_PKCS12_free(libs.second->resolve("PKCS12_free")))) qsslSocketCannotResolveSymbolWarning("PKCS12_free");

738

739

symbolsResolved = true;

delete libs.first;

delete libs.second;

return true;

}

QDateTime q_getTimeFromASN1(const ASN1_TIME *aTime)

745

{

746

size_t lTimeLength = aTime->length;

747

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

748

749

if (aTime->type == 23) {

750

751

char lBuffer[24];

752

char *pBuffer = lBuffer;

753

754

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

755

return QDateTime();

756

757

memcpy(pBuffer, pString, 10);

pBuffer += 10;

pString += 10;

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

*pBuffer++ = '0';

*pBuffer++ = '0';

} else {

*pBuffer++ = *pString++;

766

*pBuffer++ = *pString++;

767

768

if (*pString == '.') {

769

pString++;

770

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

pString++;

}

}

*pBuffer++ = 'Z';

*pBuffer++ = '\0';

time_t lSecondsFromUCT;

779

if (*pString == 'Z') {

780

lSecondsFromUCT = 0;

781

} else {

782

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

783

return QDateTime();

784

785

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

786

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

787

lSecondsFromUCT *= 60;

788

if (*pString == '-')

789

lSecondsFromUCT = -lSecondsFromUCT;

}

tm lTime;

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

794

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

795

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

796

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

797

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

798

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

799

if (lTime.tm_year < 50)

800

lTime.tm_year += 100;

801

802

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

803

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

804

805

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

806

result = result.addSecs(lSecondsFromUCT);

807

return result;

808

809

} else if (aTime->type == 24) {

810

811

if (lTimeLength < 15)

return QDateTime();

tm lTime;

lTime.tm_sec = ((pString[12] - '0') * 10) + (pString[13] - '0');

817

lTime.tm_min = ((pString[10] - '0') * 10) + (pString[11] - '0');

818

lTime.tm_hour = ((pString[8] - '0') * 10) + (pString[9] - '0');

819

lTime.tm_mday = ((pString[6] - '0') * 10) + (pString[7] - '0');

820

lTime.tm_mon = (((pString[4] - '0') * 10) + (pString[5] - '0'));

821

lTime.tm_year = ((pString[0] - '0') * 1000) + ((pString[1] - '0') * 100) +

822

((pString[2] - '0') * 10) + (pString[3] - '0');

823

824

QDate resDate(lTime.tm_year, lTime.tm_mon, lTime.tm_mday);

825

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

826

827

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

return result;

} else {

for (bool qt_category_enabled = lcSsl().isWarningEnabled(); qt_category_enabled; qt_category_enabled = false) QMessageLogger(__FILE__, 10961102, __PRETTY_FUNCTION__, lcSsl().categoryName()).warning("unsupported date format detected");

return QDateTime();

}

}

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9