reactos/dll/win32/schannel/schannel_gnutls.c

   1 /*
   2  * GnuTLS-based implementation of the schannel (SSL/TLS) provider.
   3  *
   4  * Copyright 2005 Juan Lang
   5  * Copyright 2008 Henri Verbeet
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "precomp.h"
  23
  24 #include <wine/config.h>
  25 #include <wine/port.h>
  26 #include <wine/library.h>
  27 #include <strsafe.h>
  28
  29 #ifdef SONAME_LIBGNUTLS
  30 #include <gnutls/gnutls.h>
  31 #include <gnutls/crypto.h>
  32 #endif
  33
  34 #define __wine_dbch_secur32 __wine_dbch_schannel
  35
  36 #if defined(SONAME_LIBGNUTLS) && !defined(HAVE_SECURITY_SECURITY_H)
  37
  38 static void *libgnutls_handle;
  39
  40 #ifdef _MSC_VER
  41 #include "msvc_typeof_hack.h"
  42 #endif
  43
  44 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
  45 MAKE_FUNCPTR(gnutls_alert_get);
  46 MAKE_FUNCPTR(gnutls_alert_get_name);
  47 MAKE_FUNCPTR(gnutls_certificate_allocate_credentials);
  48 MAKE_FUNCPTR(gnutls_certificate_free_credentials);
  49 MAKE_FUNCPTR(gnutls_certificate_get_peers);
  50 MAKE_FUNCPTR(gnutls_cipher_get);
  51 MAKE_FUNCPTR(gnutls_cipher_get_key_size);
  52 MAKE_FUNCPTR(gnutls_credentials_set);
  53 MAKE_FUNCPTR(gnutls_deinit);
  54 MAKE_FUNCPTR(gnutls_global_deinit);
  55 MAKE_FUNCPTR(gnutls_global_init);
  56 MAKE_FUNCPTR(gnutls_global_set_log_function);
  57 MAKE_FUNCPTR(gnutls_global_set_log_level);
  58 MAKE_FUNCPTR(gnutls_handshake);
  59 MAKE_FUNCPTR(gnutls_init);
  60 MAKE_FUNCPTR(gnutls_kx_get);
  61 MAKE_FUNCPTR(gnutls_mac_get);
  62 MAKE_FUNCPTR(gnutls_mac_get_key_size);
  63 MAKE_FUNCPTR(gnutls_perror);
  64 MAKE_FUNCPTR(gnutls_protocol_get_version);
  65 MAKE_FUNCPTR(gnutls_priority_set_direct);
  66 MAKE_FUNCPTR(gnutls_record_get_max_size);
  67 MAKE_FUNCPTR(gnutls_record_recv);
  68 MAKE_FUNCPTR(gnutls_record_send);
  69 MAKE_FUNCPTR(gnutls_server_name_set);
  70 MAKE_FUNCPTR(gnutls_transport_get_ptr);
  71 MAKE_FUNCPTR(gnutls_transport_set_errno);
  72 MAKE_FUNCPTR(gnutls_transport_set_ptr);
  73 MAKE_FUNCPTR(gnutls_transport_set_pull_function);
  74 MAKE_FUNCPTR(gnutls_transport_set_push_function);
  75 #undef MAKE_FUNCPTR
  76
  77
  78
  79 static ssize_t schan_pull_adapter(gnutls_transport_ptr_t transport,
  80                                       void *buff, size_t buff_len)
  81 {
  82     struct schan_transport *t = (struct schan_transport*)transport;
  83     gnutls_session_t s = (gnutls_session_t)schan_session_for_transport(t);
  84
  85     int ret = schan_pull(transport, buff, &buff_len);
  86     if (ret)
  87     {
  88         pgnutls_transport_set_errno(s, ret);
  89         return -1;
  90     }
  91
  92     return buff_len;
  93 }
  94
  95 static ssize_t schan_push_adapter(gnutls_transport_ptr_t transport,
  96                                       const void *buff, size_t buff_len)
  97 {
  98     struct schan_transport *t = (struct schan_transport*)transport;
  99     gnutls_session_t s = (gnutls_session_t)schan_session_for_transport(t);
 100
 101     int ret = schan_push(transport, buff, &buff_len);
 102     if (ret)
 103     {
 104         pgnutls_transport_set_errno(s, ret);
 105         return -1;
 106     }
 107
 108     return buff_len;
 109 }
 110
 111 static const struct {
 112     DWORD enable_flag;
 113     const char *gnutls_flag;
 114 } protocol_priority_flags[] = {
 115     {SP_PROT_TLS1_2_CLIENT, "VERS-TLS1.2"},
 116     {SP_PROT_TLS1_1_CLIENT, "VERS-TLS1.1"},
 117     {SP_PROT_TLS1_0_CLIENT, "VERS-TLS1.0"},
 118     {SP_PROT_SSL3_CLIENT,   "VERS-SSL3.0"}
 119     /* {SP_PROT_SSL2_CLIENT} is not supported by GnuTLS */
 120 };
 121
 122 DWORD schan_imp_enabled_protocols(void)
 123 {
 124     /* NOTE: No support for SSL 2.0 */
 125     return SP_PROT_SSL3_CLIENT | SP_PROT_TLS1_0_CLIENT | SP_PROT_TLS1_1_CLIENT | SP_PROT_TLS1_2_CLIENT;
 126 }
 127
 128 BOOL schan_imp_create_session(schan_imp_session *session, schan_credentials *cred)
 129 {
 130     gnutls_session_t *s = (gnutls_session_t*)session;
 131     char priority[64] = "NORMAL", *p;
 132     unsigned i;
 133
 134     int err = pgnutls_init(s, cred->credential_use == SECPKG_CRED_INBOUND ? GNUTLS_SERVER : GNUTLS_CLIENT);
 135     if (err != GNUTLS_E_SUCCESS)
 136     {
 137         pgnutls_perror(err);
 138         return FALSE;
 139     }
 140
 141     p = priority + strlen(priority);
 142     for(i=0; i < sizeof(protocol_priority_flags)/sizeof(*protocol_priority_flags); i++) {
 143         *p++ = ':';
 144         *p++ = (cred->enabled_protocols & protocol_priority_flags[i].enable_flag) ? '+' : '-';
 145         strcpy(p, protocol_priority_flags[i].gnutls_flag);
 146         p += strlen(p);
 147     }
 148
 149     TRACE("Using %s priority\n", debugstr_a(priority));
 150     err = pgnutls_priority_set_direct(*s, priority, NULL);
 151     if (err != GNUTLS_E_SUCCESS)
 152     {
 153         pgnutls_perror(err);
 154         pgnutls_deinit(*s);
 155         return FALSE;
 156     }
 157
 158     err = pgnutls_credentials_set(*s, GNUTLS_CRD_CERTIFICATE,
 159                                   (gnutls_certificate_credentials_t)cred->credentials);
 160     if (err != GNUTLS_E_SUCCESS)
 161     {
 162         pgnutls_perror(err);
 163         pgnutls_deinit(*s);
 164         return FALSE;
 165     }
 166
 167     pgnutls_transport_set_pull_function(*s, schan_pull_adapter);
 168     pgnutls_transport_set_push_function(*s, schan_push_adapter);
 169
 170     return TRUE;
 171 }
 172
 173 void schan_imp_dispose_session(schan_imp_session session)
 174 {
 175     gnutls_session_t s = (gnutls_session_t)session;
 176     pgnutls_deinit(s);
 177 }
 178
 179 void schan_imp_set_session_transport(schan_imp_session session,
 180                                      struct schan_transport *t)
 181 {
 182     gnutls_session_t s = (gnutls_session_t)session;
 183     pgnutls_transport_set_ptr(s, (gnutls_transport_ptr_t)t);
 184 }
 185
 186 void schan_imp_set_session_target(schan_imp_session session, const char *target)
 187 {
 188     gnutls_session_t s = (gnutls_session_t)session;
 189
 190     pgnutls_server_name_set( s, GNUTLS_NAME_DNS, target, strlen(target) );
 191 }
 192
 193 SECURITY_STATUS schan_imp_handshake(schan_imp_session session)
 194 {
 195     gnutls_session_t s = (gnutls_session_t)session;
 196     int err;
 197
 198     while(1) {
 199         err = pgnutls_handshake(s);
 200         switch(err) {
 201         case GNUTLS_E_SUCCESS:
 202             TRACE("Handshake completed\n");
 203             return SEC_E_OK;
 204
 205         case GNUTLS_E_AGAIN:
 206             TRACE("Continue...\n");
 207             return SEC_I_CONTINUE_NEEDED;
 208
 209         case GNUTLS_E_WARNING_ALERT_RECEIVED:
 210         {
 211             gnutls_alert_description_t alert = pgnutls_alert_get(s);
 212
 213             WARN("WARNING ALERT: %d %s\n", alert, pgnutls_alert_get_name(alert));
 214
 215             switch(alert) {
 216             case GNUTLS_A_UNRECOGNIZED_NAME:
 217                 TRACE("Ignoring\n");
 218                 continue;
 219             default:
 220                 return SEC_E_INTERNAL_ERROR;
 221             }
 222         }
 223
 224         case GNUTLS_E_FATAL_ALERT_RECEIVED:
 225         {
 226             gnutls_alert_description_t alert = pgnutls_alert_get(s);
 227             WARN("FATAL ALERT: %d %s\n", alert, pgnutls_alert_get_name(alert));
 228             return SEC_E_INTERNAL_ERROR;
 229         }
 230
 231         default:
 232             pgnutls_perror(err);
 233             return SEC_E_INTERNAL_ERROR;
 234         }
 235     }
 236
 237     /* Never reached */
 238     return SEC_E_OK;
 239 }
 240
 241 static unsigned int schannel_get_cipher_block_size(gnutls_cipher_algorithm_t cipher)
 242 {
 243     const struct
 244     {
 245         gnutls_cipher_algorithm_t cipher;
 246         unsigned int block_size;
 247     }
 248     algorithms[] =
 249     {
 250         {GNUTLS_CIPHER_3DES_CBC, 8},
 251         {GNUTLS_CIPHER_AES_128_CBC, 16},
 252         {GNUTLS_CIPHER_AES_256_CBC, 16},
 253         {GNUTLS_CIPHER_ARCFOUR_128, 1},
 254         {GNUTLS_CIPHER_ARCFOUR_40, 1},
 255         {GNUTLS_CIPHER_DES_CBC, 8},
 256         {GNUTLS_CIPHER_NULL, 1},
 257         {GNUTLS_CIPHER_RC2_40_CBC, 8},
 258     };
 259     unsigned int i;
 260
 261     for (i = 0; i < sizeof(algorithms) / sizeof(*algorithms); ++i)
 262     {
 263         if (algorithms[i].cipher == cipher)
 264             return algorithms[i].block_size;
 265     }
 266
 267     FIXME("Unknown cipher %#x, returning 1\n", cipher);
 268
 269     return 1;
 270 }
 271
 272 static DWORD schannel_get_protocol(gnutls_protocol_t proto)
 273 {
 274     /* FIXME: currently schannel only implements client connections, but
 275      * there's no reason it couldn't be used for servers as well.  The
 276      * context doesn't tell us which it is, so assume client for now.
 277      */
 278     switch (proto)
 279     {
 280     case GNUTLS_SSL3: return SP_PROT_SSL3_CLIENT;
 281     case GNUTLS_TLS1_0: return SP_PROT_TLS1_0_CLIENT;
 282     case GNUTLS_TLS1_1: return SP_PROT_TLS1_1_CLIENT;
 283     case GNUTLS_TLS1_2: return SP_PROT_TLS1_2_CLIENT;
 284     default:
 285         FIXME("unknown protocol %d\n", proto);
 286         return 0;
 287     }
 288 }
 289
 290 static ALG_ID schannel_get_cipher_algid(gnutls_cipher_algorithm_t cipher)
 291 {
 292     switch (cipher)
 293     {
 294     case GNUTLS_CIPHER_UNKNOWN:
 295     case GNUTLS_CIPHER_NULL: return 0;
 296     case GNUTLS_CIPHER_ARCFOUR_40:
 297     case GNUTLS_CIPHER_ARCFOUR_128: return CALG_RC4;
 298     case GNUTLS_CIPHER_DES_CBC:
 299     case GNUTLS_CIPHER_3DES_CBC: return CALG_DES;
 300     case GNUTLS_CIPHER_AES_128_CBC:
 301     case GNUTLS_CIPHER_AES_256_CBC: return CALG_AES;
 302     case GNUTLS_CIPHER_RC2_40_CBC: return CALG_RC2;
 303     default:
 304         FIXME("unknown algorithm %d\n", cipher);
 305         return 0;
 306     }
 307 }
 308
 309 static ALG_ID schannel_get_mac_algid(gnutls_mac_algorithm_t mac)
 310 {
 311     switch (mac)
 312     {
 313     case GNUTLS_MAC_UNKNOWN:
 314     case GNUTLS_MAC_NULL: return 0;
 315     case GNUTLS_MAC_MD5: return CALG_MD5;
 316     case GNUTLS_MAC_SHA1:
 317     case GNUTLS_MAC_SHA256:
 318     case GNUTLS_MAC_SHA384:
 319     case GNUTLS_MAC_SHA512: return CALG_SHA;
 320     default:
 321         FIXME("unknown algorithm %d\n", mac);
 322         return 0;
 323     }
 324 }
 325
 326 static ALG_ID schannel_get_kx_algid(gnutls_kx_algorithm_t kx)
 327 {
 328     switch (kx)
 329     {
 330         case GNUTLS_KX_RSA: return CALG_RSA_KEYX;
 331         case GNUTLS_KX_DHE_DSS:
 332         case GNUTLS_KX_DHE_RSA: return CALG_DH_EPHEM;
 333     default:
 334         FIXME("unknown algorithm %d\n", kx);
 335         return 0;
 336     }
 337 }
 338
 339 unsigned int schan_imp_get_session_cipher_block_size(schan_imp_session session)
 340 {
 341     gnutls_session_t s = (gnutls_session_t)session;
 342     gnutls_cipher_algorithm_t cipher = pgnutls_cipher_get(s);
 343     return schannel_get_cipher_block_size(cipher);
 344 }
 345
 346 unsigned int schan_imp_get_max_message_size(schan_imp_session session)
 347 {
 348     return pgnutls_record_get_max_size((gnutls_session_t)session);
 349 }
 350
 351 SECURITY_STATUS schan_imp_get_connection_info(schan_imp_session session,
 352                                               SecPkgContext_ConnectionInfo *info)
 353 {
 354     gnutls_session_t s = (gnutls_session_t)session;
 355     gnutls_protocol_t proto = pgnutls_protocol_get_version(s);
 356     gnutls_cipher_algorithm_t alg = pgnutls_cipher_get(s);
 357     gnutls_mac_algorithm_t mac = pgnutls_mac_get(s);
 358     gnutls_kx_algorithm_t kx = pgnutls_kx_get(s);
 359
 360     info->dwProtocol = schannel_get_protocol(proto);
 361     info->aiCipher = schannel_get_cipher_algid(alg);
 362     info->dwCipherStrength = pgnutls_cipher_get_key_size(alg) * 8;
 363     info->aiHash = schannel_get_mac_algid(mac);
 364     info->dwHashStrength = pgnutls_mac_get_key_size(mac) * 8;
 365     info->aiExch = schannel_get_kx_algid(kx);
 366     /* FIXME: info->dwExchStrength? */
 367     info->dwExchStrength = 0;
 368     return SEC_E_OK;
 369 }
 370
 371 SECURITY_STATUS schan_imp_get_session_peer_certificate(schan_imp_session session, HCERTSTORE store,
 372                                                        PCCERT_CONTEXT *ret)
 373 {
 374     gnutls_session_t s = (gnutls_session_t)session;
 375     PCCERT_CONTEXT cert = NULL;
 376     const gnutls_datum_t *datum;
 377     unsigned list_size, i;
 378     BOOL res;
 379
 380     datum = pgnutls_certificate_get_peers(s, &list_size);
 381     if(!datum)
 382         return SEC_E_INTERNAL_ERROR;
 383
 384     for(i = 0; i < list_size; i++) {
 385         res = CertAddEncodedCertificateToStore(store, X509_ASN_ENCODING, datum[i].data, datum[i].size,
 386                 CERT_STORE_ADD_REPLACE_EXISTING, i ? NULL : &cert);
 387         if(!res) {
 388             if(i)
 389                 CertFreeCertificateContext(cert);
 390             return GetLastError();
 391         }
 392     }
 393
 394     *ret = cert;
 395     return SEC_E_OK;
 396 }
 397
 398 SECURITY_STATUS schan_imp_send(schan_imp_session session, const void *buffer,
 399                                SIZE_T *length)
 400 {
 401     gnutls_session_t s = (gnutls_session_t)session;
 402     ssize_t ret;
 403
 404 again:
 405     ret = pgnutls_record_send(s, buffer, *length);
 406
 407     if (ret >= 0)
 408         *length = ret;
 409     else if (ret == GNUTLS_E_AGAIN)
 410     {
 411         struct schan_transport *t = (struct schan_transport *)pgnutls_transport_get_ptr(s);
 412         SIZE_T count = 0;
 413
 414         if (schan_get_buffer(t, &t->out, &count))
 415             goto again;
 416
 417         return SEC_I_CONTINUE_NEEDED;
 418     }
 419     else
 420     {
 421         pgnutls_perror(ret);
 422         return SEC_E_INTERNAL_ERROR;
 423     }
 424
 425     return SEC_E_OK;
 426 }
 427
 428 SECURITY_STATUS schan_imp_recv(schan_imp_session session, void *buffer,
 429                                SIZE_T *length)
 430 {
 431     gnutls_session_t s = (gnutls_session_t)session;
 432     ssize_t ret;
 433
 434 again:
 435     ret = pgnutls_record_recv(s, buffer, *length);
 436
 437     if (ret >= 0)
 438         *length = ret;
 439     else if (ret == GNUTLS_E_AGAIN)
 440     {
 441         struct schan_transport *t = (struct schan_transport *)pgnutls_transport_get_ptr(s);
 442         SIZE_T count = 0;
 443
 444         if (schan_get_buffer(t, &t->in, &count))
 445             goto again;
 446
 447         return SEC_I_CONTINUE_NEEDED;
 448     }
 449     else
 450     {
 451         pgnutls_perror(ret);
 452         return SEC_E_INTERNAL_ERROR;
 453     }
 454
 455     return SEC_E_OK;
 456 }
 457
 458 BOOL schan_imp_allocate_certificate_credentials(schan_credentials *c)
 459 {
 460     int ret = pgnutls_certificate_allocate_credentials((gnutls_certificate_credentials_t*)&c->credentials);
 461     if (ret != GNUTLS_E_SUCCESS)
 462         pgnutls_perror(ret);
 463     return (ret == GNUTLS_E_SUCCESS);
 464 }
 465
 466 void schan_imp_free_certificate_credentials(schan_credentials *c)
 467 {
 468     pgnutls_certificate_free_credentials(c->credentials);
 469 }
 470
 471 static void schan_gnutls_log(int level, const char *msg)
 472 {
 473     TRACE("<%d> %s", level, msg);
 474 }
 475
 476 BOOL schan_imp_init(void)
 477 {
 478     int ret;
 479
 480 #ifndef __REACTOS__
 481     libgnutls_handle = wine_dlopen(SONAME_LIBGNUTLS, RTLD_NOW, NULL, 0);
 482     if (!libgnutls_handle)
 483     {
 484         WARN("Failed to load libgnutls.\n");
 485         return FALSE;
 486     }
 487
 488 #define LOAD_FUNCPTR(f) \
 489     if (!(p##f = wine_dlsym(libgnutls_handle, #f, NULL, 0))) \
 490     { \
 491         ERR("Failed to load %s\n", #f); \
 492         goto fail; \
 493     }
 494 #else
 495 /*
 496     static const WCHAR RosSchannelKey[] = L"Software\\ReactOS\\Schannel";
 497     static const WCHAR PathValue[] = L"GnuTLSPath";
 498     WCHAR Path[MAX_PATH];
 499     DWORD PathSize = sizeof(Path), ValueType;
 500     HKEY Key;
 501     DWORD Error;
 502
 503     Error = RegOpenKeyW(HKEY_LOCAL_MACHINE, RosSchannelKey, &Key);
 504     if(Error != ERROR_SUCCESS)
 505         return FALSE;
 506
 507     Error = RegQueryValueExW(Key, PathValue, NULL, &ValueType, (LPBYTE)Path, &PathSize);
 508     RegCloseKey(Key);
 509     if ((Error != ERROR_SUCCESS) || (ValueType != REG_SZ))
 510         return FALSE;
 511     wcscat(Path, L"\\");
 512     wcscat(Path, SONAME_LIBGNUTLS);
 513 */
 514         WCHAR Path[MAX_PATH];
 515         DWORD PathSize = sizeof(Path);
 516         PathSize = GetSystemDirectoryW(Path, PathSize);
 517         if(!PathSize)
 518                 return FALSE;
 519     wcscat(Path, L"\\");
 520     wcscat(Path, SONAME_LIBGNUTLS);
 521
 522     libgnutls_handle = LoadLibraryExW(Path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
 523     if (!libgnutls_handle)
 524     {
 525         ERR("Could not load %S.\n", Path);
 526         return FALSE;
 527     }
 528
 529 #define LOAD_FUNCPTR(f) \
 530     if (!(p##f = (void*)GetProcAddress(libgnutls_handle, #f))) \
 531     { \
 532         ERR("Failed to load %s\n", #f); \
 533         goto fail; \
 534     }
 535 #endif // __REACTOS__
 536
 537     LOAD_FUNCPTR(gnutls_alert_get)
 538     LOAD_FUNCPTR(gnutls_alert_get_name)
 539     LOAD_FUNCPTR(gnutls_certificate_allocate_credentials)
 540     LOAD_FUNCPTR(gnutls_certificate_free_credentials)
 541     LOAD_FUNCPTR(gnutls_certificate_get_peers)
 542     LOAD_FUNCPTR(gnutls_cipher_get)
 543     LOAD_FUNCPTR(gnutls_cipher_get_key_size)
 544     LOAD_FUNCPTR(gnutls_credentials_set)
 545     LOAD_FUNCPTR(gnutls_deinit)
 546     LOAD_FUNCPTR(gnutls_global_deinit)
 547     LOAD_FUNCPTR(gnutls_global_init)
 548     LOAD_FUNCPTR(gnutls_global_set_log_function)
 549     LOAD_FUNCPTR(gnutls_global_set_log_level)
 550     LOAD_FUNCPTR(gnutls_handshake)
 551     LOAD_FUNCPTR(gnutls_init)
 552     LOAD_FUNCPTR(gnutls_kx_get)
 553     LOAD_FUNCPTR(gnutls_mac_get)
 554     LOAD_FUNCPTR(gnutls_mac_get_key_size)
 555     LOAD_FUNCPTR(gnutls_perror)
 556     LOAD_FUNCPTR(gnutls_protocol_get_version)
 557     LOAD_FUNCPTR(gnutls_priority_set_direct)
 558     LOAD_FUNCPTR(gnutls_record_get_max_size);
 559     LOAD_FUNCPTR(gnutls_record_recv);
 560     LOAD_FUNCPTR(gnutls_record_send);
 561     LOAD_FUNCPTR(gnutls_server_name_set)
 562     LOAD_FUNCPTR(gnutls_transport_get_ptr)
 563     LOAD_FUNCPTR(gnutls_transport_set_errno)
 564     LOAD_FUNCPTR(gnutls_transport_set_ptr)
 565     LOAD_FUNCPTR(gnutls_transport_set_pull_function)
 566     LOAD_FUNCPTR(gnutls_transport_set_push_function)
 567 #undef LOAD_FUNCPTR
 568
 569     ret = pgnutls_global_init();
 570     if (ret != GNUTLS_E_SUCCESS)
 571     {
 572         pgnutls_perror(ret);
 573         goto fail;
 574     }
 575
 576     if (TRACE_ON(secur32))
 577     {
 578         pgnutls_global_set_log_level(4);
 579         pgnutls_global_set_log_function(schan_gnutls_log);
 580     }
 581
 582     return TRUE;
 583
 584 fail:
 585 #ifndef __REACTOS__
 586     wine_dlclose(libgnutls_handle, NULL, 0);
 587 #else
 588     FreeLibrary(libgnutls_handle);
 589 #endif
 590     libgnutls_handle = NULL;
 591     return FALSE;
 592 }
 593
 594 void schan_imp_deinit(void)
 595 {
 596     pgnutls_global_deinit();
 597 #ifndef __REACTOS__
 598     wine_dlclose(libgnutls_handle, NULL, 0);
 599 #else
 600     FreeLibrary(libgnutls_handle);
 601 #endif
 602     libgnutls_handle = NULL;
 603 }
 604
 605 #endif /* SONAME_LIBGNUTLS && !HAVE_SECURITY_SECURITY_H */