falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6657 Commits
16 Branches
16GB
Tree: 054e75a0a1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '054e75a0a1'
${ noResults }
Carla/source/modules/hylia/link/asio/ssl/impl/context.ipp

1205 lines
32KB
Raw Blame History 

  1. //

  2. // ssl/impl/context.ipp

  3. // ~~~~~~~~~~~~~~~~~~~~

  4. //

  5. // Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com

  6. // Copyright (c) 2005-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)

  7. //

  8. // Distributed under the Boost Software License, Version 1.0. (See accompanying

  9. // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

  10. //

  11. 

  12. #ifndef ASIO_SSL_IMPL_CONTEXT_IPP

  13. #define ASIO_SSL_IMPL_CONTEXT_IPP

  14. 

  15. #if defined(_MSC_VER) && (_MSC_VER >= 1200)

  16. # pragma once

  17. #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

  18. 

  19. #include "asio/detail/config.hpp"

  20. 

  21. #include <cstring>

  22. #include "asio/detail/throw_error.hpp"

  23. #include "asio/error.hpp"

  24. #include "asio/ssl/context.hpp"

  25. #include "asio/ssl/error.hpp"

  26. 

  27. #include "asio/detail/push_options.hpp"

  28. 

  29. namespace asio {

  30. namespace ssl {

  31. 

  32. struct context::bio_cleanup

  33. {

  34.   BIO* p;

  35.   ~bio_cleanup() { if (p) ::BIO_free(p); }

  36. };

  37. 

  38. struct context::x509_cleanup

  39. {

  40.   X509* p;

  41.   ~x509_cleanup() { if (p) ::X509_free(p); }

  42. };

  43. 

  44. struct context::evp_pkey_cleanup

  45. {

  46.   EVP_PKEY* p;

  47.   ~evp_pkey_cleanup() { if (p) ::EVP_PKEY_free(p); }

  48. };

  49. 

  50. struct context::rsa_cleanup

  51. {

  52.   RSA* p;

  53.   ~rsa_cleanup() { if (p) ::RSA_free(p); }

  54. };

  55. 

  56. struct context::dh_cleanup

  57. {

  58.   DH* p;

  59.   ~dh_cleanup() { if (p) ::DH_free(p); }

  60. };

  61. 

  62. context::context(context::method m)

  63.   : handle_(0)

  64. {

  65.   ::ERR_clear_error();

  66. 

  67.   switch (m)

  68.   {

  69.     // SSL v2.

  70. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(OPENSSL_NO_SSL2)

  71.   case context::sslv2:

  72.   case context::sslv2_client:

  73.   case context::sslv2_server:

  74.     asio::detail::throw_error(

  75.         asio::error::invalid_argument, "context");

  76.     break;

  77. #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(OPENSSL_NO_SSL2)

  78.   case context::sslv2:

  79.     handle_ = ::SSL_CTX_new(::SSLv2_method());

  80.     break;

  81.   case context::sslv2_client:

  82.     handle_ = ::SSL_CTX_new(::SSLv2_client_method());

  83.     break;

  84.   case context::sslv2_server:

  85.     handle_ = ::SSL_CTX_new(::SSLv2_server_method());

  86.     break;

  87. #endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(OPENSSL_NO_SSL2)

  88. 

  89.     // SSL v3.

  90. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  91.   case context::sslv3:

  92.     handle_ = ::SSL_CTX_new(::TLS_method());

  93.     if (handle_)

  94.     {

  95.       SSL_CTX_set_min_proto_version(handle_, SSL3_VERSION);

  96.       SSL_CTX_set_max_proto_version(handle_, SSL3_VERSION);

  97.     }

  98.     break;

  99.   case context::sslv3_client:

  100.     handle_ = ::SSL_CTX_new(::TLS_client_method());

  101.     if (handle_)

  102.     {

  103.       SSL_CTX_set_min_proto_version(handle_, SSL3_VERSION);

  104.       SSL_CTX_set_max_proto_version(handle_, SSL3_VERSION);

  105.     }

  106.     break;

  107.   case context::sslv3_server:

  108.     handle_ = ::SSL_CTX_new(::TLS_server_method());

  109.     if (handle_)

  110.     {

  111.       SSL_CTX_set_min_proto_version(handle_, SSL3_VERSION);

  112.       SSL_CTX_set_max_proto_version(handle_, SSL3_VERSION);

  113.     }

  114.     break;

  115. #elif defined(OPENSSL_NO_SSL3)

  116.   case context::sslv3:

  117.   case context::sslv3_client:

  118.   case context::sslv3_server:

  119.     asio::detail::throw_error(

  120.         asio::error::invalid_argument, "context");

  121.     break;

  122. #else // defined(OPENSSL_NO_SSL3)

  123.   case context::sslv3:

  124.     handle_ = ::SSL_CTX_new(::SSLv3_method());

  125.     break;

  126.   case context::sslv3_client:

  127.     handle_ = ::SSL_CTX_new(::SSLv3_client_method());

  128.     break;

  129.   case context::sslv3_server:

  130.     handle_ = ::SSL_CTX_new(::SSLv3_server_method());

  131.     break;

  132. #endif // defined(OPENSSL_NO_SSL3)

  133. 

  134.     // TLS v1.0.

  135. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  136.   case context::tlsv1:

  137.     handle_ = ::SSL_CTX_new(::TLS_method());

  138.     if (handle_)

  139.     {

  140.       SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);

  141.       SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);

  142.     }

  143.     break;

  144.   case context::tlsv1_client:

  145.     handle_ = ::SSL_CTX_new(::TLS_client_method());

  146.     if (handle_)

  147.     {

  148.       SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);

  149.       SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);

  150.     }

  151.     break;

  152.   case context::tlsv1_server:

  153.     handle_ = ::SSL_CTX_new(::TLS_server_method());

  154.     if (handle_)

  155.     {

  156.       SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);

  157.       SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);

  158.     }

  159.     break;

  160. #elif defined(SSL_TXT_TLSV1)

  161.   case context::tlsv1:

  162.     handle_ = ::SSL_CTX_new(::TLSv1_method());

  163.     break;

  164.   case context::tlsv1_client:

  165.     handle_ = ::SSL_CTX_new(::TLSv1_client_method());

  166.     break;

  167.   case context::tlsv1_server:

  168.     handle_ = ::SSL_CTX_new(::TLSv1_server_method());

  169.     break;

  170. #else // defined(SSL_TXT_TLSV1)

  171.   case context::tlsv1:

  172.   case context::tlsv1_client:

  173.   case context::tlsv1_server:

  174.     asio::detail::throw_error(

  175.         asio::error::invalid_argument, "context");

  176.     break;

  177. #endif // defined(SSL_TXT_TLSV1)

  178. 

  179.     // TLS v1.1.

  180. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  181.   case context::tlsv11:

  182.     handle_ = ::SSL_CTX_new(::TLS_method());

  183.     if (handle_)

  184.     {

  185.       SSL_CTX_set_min_proto_version(handle_, TLS1_1_VERSION);

  186.       SSL_CTX_set_max_proto_version(handle_, TLS1_1_VERSION);

  187.     }

  188.     break;

  189.   case context::tlsv11_client:

  190.     handle_ = ::SSL_CTX_new(::TLS_client_method());

  191.     if (handle_)

  192.     {

  193.       SSL_CTX_set_min_proto_version(handle_, TLS1_1_VERSION);

  194.       SSL_CTX_set_max_proto_version(handle_, TLS1_1_VERSION);

  195.     }

  196.     break;

  197.   case context::tlsv11_server:

  198.     handle_ = ::SSL_CTX_new(::TLS_server_method());

  199.     if (handle_)

  200.     {

  201.       SSL_CTX_set_min_proto_version(handle_, TLS1_1_VERSION);

  202.       SSL_CTX_set_max_proto_version(handle_, TLS1_1_VERSION);

  203.     }

  204.     break;

  205. #elif defined(SSL_TXT_TLSV1_1)

  206.   case context::tlsv11:

  207.     handle_ = ::SSL_CTX_new(::TLSv1_1_method());

  208.     break;

  209.   case context::tlsv11_client:

  210.     handle_ = ::SSL_CTX_new(::TLSv1_1_client_method());

  211.     break;

  212.   case context::tlsv11_server:

  213.     handle_ = ::SSL_CTX_new(::TLSv1_1_server_method());

  214.     break;

  215. #else // defined(SSL_TXT_TLSV1_1)

  216.   case context::tlsv11:

  217.   case context::tlsv11_client:

  218.   case context::tlsv11_server:

  219.     asio::detail::throw_error(

  220.         asio::error::invalid_argument, "context");

  221.     break;

  222. #endif // defined(SSL_TXT_TLSV1_1)

  223. 

  224.     // TLS v1.2.

  225. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  226.   case context::tlsv12:

  227.     handle_ = ::SSL_CTX_new(::TLS_method());

  228.     if (handle_)

  229.     {

  230.       SSL_CTX_set_min_proto_version(handle_, TLS1_2_VERSION);

  231.       SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);

  232.     }

  233.     break;

  234.   case context::tlsv12_client:

  235.     handle_ = ::SSL_CTX_new(::TLS_client_method());

  236.     if (handle_)

  237.     {

  238.       SSL_CTX_set_min_proto_version(handle_, TLS1_2_VERSION);

  239.       SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);

  240.     }

  241.     break;

  242.   case context::tlsv12_server:

  243.     handle_ = ::SSL_CTX_new(::TLS_server_method());

  244.     if (handle_)

  245.     {

  246.       SSL_CTX_set_min_proto_version(handle_, TLS1_2_VERSION);

  247.       SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);

  248.     }

  249.     break;

  250. #elif defined(SSL_TXT_TLSV1_2)

  251.   case context::tlsv12:

  252.     handle_ = ::SSL_CTX_new(::TLSv1_2_method());

  253.     break;

  254.   case context::tlsv12_client:

  255.     handle_ = ::SSL_CTX_new(::TLSv1_2_client_method());

  256.     break;

  257.   case context::tlsv12_server:

  258.     handle_ = ::SSL_CTX_new(::TLSv1_2_server_method());

  259.     break;

  260. #else // defined(SSL_TXT_TLSV1_2)

  261.   case context::tlsv12:

  262.   case context::tlsv12_client:

  263.   case context::tlsv12_server:

  264.     asio::detail::throw_error(

  265.         asio::error::invalid_argument, "context");

  266.     break;

  267. #endif // defined(SSL_TXT_TLSV1_2)

  268. 

  269.     // TLS v1.3.

  270. #if (OPENSSL_VERSION_NUMBER >= 0x10101000L) \

  271.     && !defined(LIBRESSL_VERSION_NUMBER)

  272.   case context::tlsv13:

  273.     handle_ = ::SSL_CTX_new(::TLS_method());

  274.     if (handle_)

  275.     {

  276.       SSL_CTX_set_min_proto_version(handle_, TLS1_3_VERSION);

  277.       SSL_CTX_set_max_proto_version(handle_, TLS1_3_VERSION);

  278.     }

  279.     break;

  280.   case context::tlsv13_client:

  281.     handle_ = ::SSL_CTX_new(::TLS_client_method());

  282.     if (handle_)

  283.     {

  284.       SSL_CTX_set_min_proto_version(handle_, TLS1_3_VERSION);

  285.       SSL_CTX_set_max_proto_version(handle_, TLS1_3_VERSION);

  286.     }

  287.     break;

  288.   case context::tlsv13_server:

  289.     handle_ = ::SSL_CTX_new(::TLS_server_method());

  290.     if (handle_)

  291.     {

  292.       SSL_CTX_set_min_proto_version(handle_, TLS1_3_VERSION);

  293.       SSL_CTX_set_max_proto_version(handle_, TLS1_3_VERSION);

  294.     }

  295.     break;

  296. #else // (OPENSSL_VERSION_NUMBER >= 0x10101000L)

  297.       //   && !defined(LIBRESSL_VERSION_NUMBER)

  298.   case context::tlsv13:

  299.   case context::tlsv13_client:

  300.   case context::tlsv13_server:

  301.     asio::detail::throw_error(

  302.         asio::error::invalid_argument, "context");

  303.     break;

  304. #endif // (OPENSSL_VERSION_NUMBER >= 0x10101000L)

  305.        //   && !defined(LIBRESSL_VERSION_NUMBER)

  306. 

  307.     // Any supported SSL/TLS version.

  308.   case context::sslv23:

  309.     handle_ = ::SSL_CTX_new(::SSLv23_method());

  310.     break;

  311.   case context::sslv23_client:

  312.     handle_ = ::SSL_CTX_new(::SSLv23_client_method());

  313.     break;

  314.   case context::sslv23_server:

  315.     handle_ = ::SSL_CTX_new(::SSLv23_server_method());

  316.     break;

  317. 

  318.     // Any supported TLS version.

  319. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  320.   case context::tls:

  321.     handle_ = ::SSL_CTX_new(::TLS_method());

  322.     if (handle_)

  323.       SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);

  324.     break;

  325.   case context::tls_client:

  326.     handle_ = ::SSL_CTX_new(::TLS_client_method());

  327.     if (handle_)

  328.       SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);

  329.     break;

  330.   case context::tls_server:

  331.     handle_ = ::SSL_CTX_new(::TLS_server_method());

  332.     if (handle_)

  333.       SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);

  334.     break;

  335. #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  336.   case context::tls:

  337.     handle_ = ::SSL_CTX_new(::SSLv23_method());

  338.     if (handle_)

  339.       SSL_CTX_set_options(handle_, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);

  340.     break;

  341.   case context::tls_client:

  342.     handle_ = ::SSL_CTX_new(::SSLv23_client_method());

  343.     if (handle_)

  344.       SSL_CTX_set_options(handle_, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);

  345.     break;

  346.   case context::tls_server:

  347.     handle_ = ::SSL_CTX_new(::SSLv23_server_method());

  348.     if (handle_)

  349.       SSL_CTX_set_options(handle_, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);

  350.     break;

  351. #endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  352. 

  353.   default:

  354.     handle_ = ::SSL_CTX_new(0);

  355.     break;

  356.   }

  357. 

  358.   if (handle_ == 0)

  359.   {

  360.     asio::error_code ec(

  361.         static_cast<int>(::ERR_get_error()),

  362.         asio::error::get_ssl_category());

  363.     asio::detail::throw_error(ec, "context");

  364.   }

  365. 

  366.   set_options(no_compression);

  367. }

  368. 

  369. #if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)

  370. context::context(context&& other)

  371. {

  372.   handle_ = other.handle_;

  373.   other.handle_ = 0;

  374. }

  375. 

  376. context& context::operator=(context&& other)

  377. {

  378.   context tmp(ASIO_MOVE_CAST(context)(*this));

  379.   handle_ = other.handle_;

  380.   other.handle_ = 0;

  381.   return *this;

  382. }

  383. #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)

  384. 

  385. context::~context()

  386. {

  387.   if (handle_)

  388.   {

  389. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  390.     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);

  391. #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  392.     void* cb_userdata = handle_->default_passwd_callback_userdata;

  393. #endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  394.     if (cb_userdata)

  395.     {

  396.       detail::password_callback_base* callback =

  397.         static_cast<detail::password_callback_base*>(

  398.             cb_userdata);

  399.       delete callback;

  400. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  401.       ::SSL_CTX_set_default_passwd_cb_userdata(handle_, 0);

  402. #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  403.       handle_->default_passwd_callback_userdata = 0;

  404. #endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  405.     }

  406. 

  407.     if (SSL_CTX_get_app_data(handle_))

  408.     {

  409.       detail::verify_callback_base* callback =

  410.         static_cast<detail::verify_callback_base*>(

  411.             SSL_CTX_get_app_data(handle_));

  412.       delete callback;

  413.       SSL_CTX_set_app_data(handle_, 0);

  414.     }

  415. 

  416.     ::SSL_CTX_free(handle_);

  417.   }

  418. }

  419. 

  420. context::native_handle_type context::native_handle()

  421. {

  422.   return handle_;

  423. }

  424. 

  425. void context::clear_options(context::options o)

  426. {

  427.   asio::error_code ec;

  428.   clear_options(o, ec);

  429.   asio::detail::throw_error(ec, "clear_options");

  430. }

  431. 

  432. ASIO_SYNC_OP_VOID context::clear_options(

  433.     context::options o, asio::error_code& ec)

  434. {

  435. #if (OPENSSL_VERSION_NUMBER >= 0x009080DFL) \

  436.   && (OPENSSL_VERSION_NUMBER != 0x00909000L)

  437. # if !defined(SSL_OP_NO_COMPRESSION)

  438.   if ((o & context::no_compression) != 0)

  439.   {

  440. # if (OPENSSL_VERSION_NUMBER >= 0x00908000L)

  441.     handle_->comp_methods = SSL_COMP_get_compression_methods();

  442. # endif // (OPENSSL_VERSION_NUMBER >= 0x00908000L)

  443.     o ^= context::no_compression;

  444.   }

  445. # endif // !defined(SSL_OP_NO_COMPRESSION)

  446. 

  447.   ::SSL_CTX_clear_options(handle_, o);

  448. 

  449.   ec = asio::error_code();

  450. #else // (OPENSSL_VERSION_NUMBER >= 0x009080DFL)

  451.       //   && (OPENSSL_VERSION_NUMBER != 0x00909000L)

  452.   (void)o;

  453.   ec = asio::error::operation_not_supported;

  454. #endif // (OPENSSL_VERSION_NUMBER >= 0x009080DFL)

  455.        //   && (OPENSSL_VERSION_NUMBER != 0x00909000L)

  456.   ASIO_SYNC_OP_VOID_RETURN(ec);

  457. }

  458. 

  459. void context::set_options(context::options o)

  460. {

  461.   asio::error_code ec;

  462.   set_options(o, ec);

  463.   asio::detail::throw_error(ec, "set_options");

  464. }

  465. 

  466. ASIO_SYNC_OP_VOID context::set_options(

  467.     context::options o, asio::error_code& ec)

  468. {

  469. #if !defined(SSL_OP_NO_COMPRESSION)

  470.   if ((o & context::no_compression) != 0)

  471.   {

  472. #if (OPENSSL_VERSION_NUMBER >= 0x00908000L)

  473.     handle_->comp_methods =

  474.       asio::ssl::detail::openssl_init<>::get_null_compression_methods();

  475. #endif // (OPENSSL_VERSION_NUMBER >= 0x00908000L)

  476.     o ^= context::no_compression;

  477.   }

  478. #endif // !defined(SSL_OP_NO_COMPRESSION)

  479. 

  480.   ::SSL_CTX_set_options(handle_, o);

  481. 

  482.   ec = asio::error_code();

  483.   ASIO_SYNC_OP_VOID_RETURN(ec);

  484. }

  485. 

  486. void context::set_verify_mode(verify_mode v)

  487. {

  488.   asio::error_code ec;

  489.   set_verify_mode(v, ec);

  490.   asio::detail::throw_error(ec, "set_verify_mode");

  491. }

  492. 

  493. ASIO_SYNC_OP_VOID context::set_verify_mode(

  494.     verify_mode v, asio::error_code& ec)

  495. {

  496.   ::SSL_CTX_set_verify(handle_, v, ::SSL_CTX_get_verify_callback(handle_));

  497. 

  498.   ec = asio::error_code();

  499.   ASIO_SYNC_OP_VOID_RETURN(ec);

  500. }

  501. 

  502. void context::set_verify_depth(int depth)

  503. {

  504.   asio::error_code ec;

  505.   set_verify_depth(depth, ec);

  506.   asio::detail::throw_error(ec, "set_verify_depth");

  507. }

  508. 

  509. ASIO_SYNC_OP_VOID context::set_verify_depth(

  510.     int depth, asio::error_code& ec)

  511. {

  512.   ::SSL_CTX_set_verify_depth(handle_, depth);

  513. 

  514.   ec = asio::error_code();

  515.   ASIO_SYNC_OP_VOID_RETURN(ec);

  516. }

  517. 

  518. void context::load_verify_file(const std::string& filename)

  519. {

  520.   asio::error_code ec;

  521.   load_verify_file(filename, ec);

  522.   asio::detail::throw_error(ec, "load_verify_file");

  523. }

  524. 

  525. ASIO_SYNC_OP_VOID context::load_verify_file(

  526.     const std::string& filename, asio::error_code& ec)

  527. {

  528.   ::ERR_clear_error();

  529. 

  530.   if (::SSL_CTX_load_verify_locations(handle_, filename.c_str(), 0) != 1)

  531.   {

  532.     ec = asio::error_code(

  533.         static_cast<int>(::ERR_get_error()),

  534.         asio::error::get_ssl_category());

  535.     ASIO_SYNC_OP_VOID_RETURN(ec);

  536.   }

  537. 

  538.   ec = asio::error_code();

  539.   ASIO_SYNC_OP_VOID_RETURN(ec);

  540. }

  541. 

  542. void context::add_certificate_authority(const const_buffer& ca)

  543. {

  544.   asio::error_code ec;

  545.   add_certificate_authority(ca, ec);

  546.   asio::detail::throw_error(ec, "add_certificate_authority");

  547. }

  548. 

  549. ASIO_SYNC_OP_VOID context::add_certificate_authority(

  550.     const const_buffer& ca, asio::error_code& ec)

  551. {

  552.   ::ERR_clear_error();

  553. 

  554.   bio_cleanup bio = { make_buffer_bio(ca) };

  555.   if (bio.p)

  556.   {

  557.     if (X509_STORE* store = ::SSL_CTX_get_cert_store(handle_))

  558.     {

  559.       for (;;)

  560.       {

  561.         x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };

  562.         if (!cert.p)

  563.           break;

  564. 

  565.         if (::X509_STORE_add_cert(store, cert.p) != 1)

  566.         {

  567.           ec = asio::error_code(

  568.               static_cast<int>(::ERR_get_error()),

  569.               asio::error::get_ssl_category());

  570.           ASIO_SYNC_OP_VOID_RETURN(ec);

  571.         }

  572.       }

  573.     }

  574.   }

  575. 

  576.   ec = asio::error_code();

  577.   ASIO_SYNC_OP_VOID_RETURN(ec);

  578. }

  579. 

  580. void context::set_default_verify_paths()

  581. {

  582.   asio::error_code ec;

  583.   set_default_verify_paths(ec);

  584.   asio::detail::throw_error(ec, "set_default_verify_paths");

  585. }

  586. 

  587. ASIO_SYNC_OP_VOID context::set_default_verify_paths(

  588.     asio::error_code& ec)

  589. {

  590.   ::ERR_clear_error();

  591. 

  592.   if (::SSL_CTX_set_default_verify_paths(handle_) != 1)

  593.   {

  594.     ec = asio::error_code(

  595.         static_cast<int>(::ERR_get_error()),

  596.         asio::error::get_ssl_category());

  597.     ASIO_SYNC_OP_VOID_RETURN(ec);

  598.   }

  599. 

  600.   ec = asio::error_code();

  601.   ASIO_SYNC_OP_VOID_RETURN(ec);

  602. }

  603. 

  604. void context::add_verify_path(const std::string& path)

  605. {

  606.   asio::error_code ec;

  607.   add_verify_path(path, ec);

  608.   asio::detail::throw_error(ec, "add_verify_path");

  609. }

  610. 

  611. ASIO_SYNC_OP_VOID context::add_verify_path(

  612.     const std::string& path, asio::error_code& ec)

  613. {

  614.   ::ERR_clear_error();

  615. 

  616.   if (::SSL_CTX_load_verify_locations(handle_, 0, path.c_str()) != 1)

  617.   {

  618.     ec = asio::error_code(

  619.         static_cast<int>(::ERR_get_error()),

  620.         asio::error::get_ssl_category());

  621.     ASIO_SYNC_OP_VOID_RETURN(ec);

  622.   }

  623. 

  624.   ec = asio::error_code();

  625.   ASIO_SYNC_OP_VOID_RETURN(ec);

  626. }

  627. 

  628. void context::use_certificate(

  629.     const const_buffer& certificate, file_format format)

  630. {

  631.   asio::error_code ec;

  632.   use_certificate(certificate, format, ec);

  633.   asio::detail::throw_error(ec, "use_certificate");

  634. }

  635. 

  636. ASIO_SYNC_OP_VOID context::use_certificate(

  637.     const const_buffer& certificate, file_format format,

  638.     asio::error_code& ec)

  639. {

  640.   ::ERR_clear_error();

  641. 

  642.   if (format == context_base::asn1)

  643.   {

  644.     if (::SSL_CTX_use_certificate_ASN1(handle_,

  645.           static_cast<int>(certificate.size()),

  646.           static_cast<const unsigned char*>(certificate.data())) == 1)

  647.     {

  648.       ec = asio::error_code();

  649.       ASIO_SYNC_OP_VOID_RETURN(ec);

  650.     }

  651.   }

  652.   else if (format == context_base::pem)

  653.   {

  654.     bio_cleanup bio = { make_buffer_bio(certificate) };

  655.     if (bio.p)

  656.     {

  657.       x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };

  658.       if (cert.p)

  659.       {

  660.         if (::SSL_CTX_use_certificate(handle_, cert.p) == 1)

  661.         {

  662.           ec = asio::error_code();

  663.           ASIO_SYNC_OP_VOID_RETURN(ec);

  664.         }

  665.       }

  666.     }

  667.   }

  668.   else

  669.   {

  670.     ec = asio::error::invalid_argument;

  671.     ASIO_SYNC_OP_VOID_RETURN(ec);

  672.   }

  673. 

  674.   ec = asio::error_code(

  675.       static_cast<int>(::ERR_get_error()),

  676.       asio::error::get_ssl_category());

  677.   ASIO_SYNC_OP_VOID_RETURN(ec);

  678. }

  679. 

  680. void context::use_certificate_file(

  681.     const std::string& filename, file_format format)

  682. {

  683.   asio::error_code ec;

  684.   use_certificate_file(filename, format, ec);

  685.   asio::detail::throw_error(ec, "use_certificate_file");

  686. }

  687. 

  688. ASIO_SYNC_OP_VOID context::use_certificate_file(

  689.     const std::string& filename, file_format format,

  690.     asio::error_code& ec)

  691. {

  692.   int file_type;

  693.   switch (format)

  694.   {

  695.   case context_base::asn1:

  696.     file_type = SSL_FILETYPE_ASN1;

  697.     break;

  698.   case context_base::pem:

  699.     file_type = SSL_FILETYPE_PEM;

  700.     break;

  701.   default:

  702.     {

  703.       ec = asio::error::invalid_argument;

  704.       ASIO_SYNC_OP_VOID_RETURN(ec);

  705.     }

  706.   }

  707. 

  708.   ::ERR_clear_error();

  709. 

  710.   if (::SSL_CTX_use_certificate_file(handle_, filename.c_str(), file_type) != 1)

  711.   {

  712.     ec = asio::error_code(

  713.         static_cast<int>(::ERR_get_error()),

  714.         asio::error::get_ssl_category());

  715.     ASIO_SYNC_OP_VOID_RETURN(ec);

  716.   }

  717. 

  718.   ec = asio::error_code();

  719.   ASIO_SYNC_OP_VOID_RETURN(ec);

  720. }

  721. 

  722. void context::use_certificate_chain(const const_buffer& chain)

  723. {

  724.   asio::error_code ec;

  725.   use_certificate_chain(chain, ec);

  726.   asio::detail::throw_error(ec, "use_certificate_chain");

  727. }

  728. 

  729. ASIO_SYNC_OP_VOID context::use_certificate_chain(

  730.     const const_buffer& chain, asio::error_code& ec)

  731. {

  732.   ::ERR_clear_error();

  733. 

  734.   bio_cleanup bio = { make_buffer_bio(chain) };

  735.   if (bio.p)

  736.   {

  737. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  738.     pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);

  739.     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);

  740. #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  741.     pem_password_cb* callback = handle_->default_passwd_callback;

  742.     void* cb_userdata = handle_->default_passwd_callback_userdata;

  743. #endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  744.     x509_cleanup cert = {

  745.       ::PEM_read_bio_X509_AUX(bio.p, 0,

  746.           callback,

  747.           cb_userdata) };

  748.     if (!cert.p)

  749.     {

  750.       ec = asio::error_code(ERR_R_PEM_LIB,

  751.           asio::error::get_ssl_category());

  752.       ASIO_SYNC_OP_VOID_RETURN(ec);

  753.     }

  754. 

  755.     int result = ::SSL_CTX_use_certificate(handle_, cert.p);

  756.     if (result == 0 || ::ERR_peek_error() != 0)

  757.     {

  758.       ec = asio::error_code(

  759.           static_cast<int>(::ERR_get_error()),

  760.           asio::error::get_ssl_category());

  761.       ASIO_SYNC_OP_VOID_RETURN(ec);

  762.     }

  763. 

  764. #if (OPENSSL_VERSION_NUMBER >= 0x10002000L) && !defined(LIBRESSL_VERSION_NUMBER)

  765.     ::SSL_CTX_clear_chain_certs(handle_);

  766. #else

  767.     if (handle_->extra_certs)

  768.     {

  769.       ::sk_X509_pop_free(handle_->extra_certs, X509_free);

  770.       handle_->extra_certs = 0;

  771.     }

  772. #endif // (OPENSSL_VERSION_NUMBER >= 0x10002000L)

  773. 

  774.     while (X509* cacert = ::PEM_read_bio_X509(bio.p, 0,

  775.           callback,

  776.           cb_userdata))

  777.     {

  778.       if (!::SSL_CTX_add_extra_chain_cert(handle_, cacert))

  779.       {

  780.         ec = asio::error_code(

  781.             static_cast<int>(::ERR_get_error()),

  782.             asio::error::get_ssl_category());

  783.         ASIO_SYNC_OP_VOID_RETURN(ec);

  784.       }

  785.     }

  786.   

  787.     result = ::ERR_peek_last_error();

  788.     if ((ERR_GET_LIB(result) == ERR_LIB_PEM)

  789.         && (ERR_GET_REASON(result) == PEM_R_NO_START_LINE))

  790.     {

  791.       ::ERR_clear_error();

  792.       ec = asio::error_code();

  793.       ASIO_SYNC_OP_VOID_RETURN(ec);

  794.     }

  795.   }

  796. 

  797.   ec = asio::error_code(

  798.       static_cast<int>(::ERR_get_error()),

  799.       asio::error::get_ssl_category());

  800.   ASIO_SYNC_OP_VOID_RETURN(ec);

  801. }

  802. 

  803. void context::use_certificate_chain_file(const std::string& filename)

  804. {

  805.   asio::error_code ec;

  806.   use_certificate_chain_file(filename, ec);

  807.   asio::detail::throw_error(ec, "use_certificate_chain_file");

  808. }

  809. 

  810. ASIO_SYNC_OP_VOID context::use_certificate_chain_file(

  811.     const std::string& filename, asio::error_code& ec)

  812. {

  813.   ::ERR_clear_error();

  814. 

  815.   if (::SSL_CTX_use_certificate_chain_file(handle_, filename.c_str()) != 1)

  816.   {

  817.     ec = asio::error_code(

  818.         static_cast<int>(::ERR_get_error()),

  819.         asio::error::get_ssl_category());

  820.     ASIO_SYNC_OP_VOID_RETURN(ec);

  821.   }

  822. 

  823.   ec = asio::error_code();

  824.   ASIO_SYNC_OP_VOID_RETURN(ec);

  825. }

  826. 

  827. void context::use_private_key(

  828.     const const_buffer& private_key, context::file_format format)

  829. {

  830.   asio::error_code ec;

  831.   use_private_key(private_key, format, ec);

  832.   asio::detail::throw_error(ec, "use_private_key");

  833. }

  834. 

  835. ASIO_SYNC_OP_VOID context::use_private_key(

  836.     const const_buffer& private_key, context::file_format format,

  837.     asio::error_code& ec)

  838. {

  839.   ::ERR_clear_error();

  840. 

  841. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  842.     pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);

  843.     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);

  844. #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  845.     pem_password_cb* callback = handle_->default_passwd_callback;

  846.     void* cb_userdata = handle_->default_passwd_callback_userdata;

  847. #endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  848. 

  849.   bio_cleanup bio = { make_buffer_bio(private_key) };

  850.   if (bio.p)

  851.   {

  852.     evp_pkey_cleanup evp_private_key = { 0 };

  853.     switch (format)

  854.     {

  855.     case context_base::asn1:

  856.       evp_private_key.p = ::d2i_PrivateKey_bio(bio.p, 0);

  857.       break;

  858.     case context_base::pem:

  859.       evp_private_key.p = ::PEM_read_bio_PrivateKey(

  860.           bio.p, 0, callback,

  861.           cb_userdata);

  862.       break;

  863.     default:

  864.       {

  865.         ec = asio::error::invalid_argument;

  866.         ASIO_SYNC_OP_VOID_RETURN(ec);

  867.       }

  868.     }

  869. 

  870.     if (evp_private_key.p)

  871.     {

  872.       if (::SSL_CTX_use_PrivateKey(handle_, evp_private_key.p) == 1)

  873.       {

  874.         ec = asio::error_code();

  875.         ASIO_SYNC_OP_VOID_RETURN(ec);

  876.       }

  877.     }

  878.   }

  879. 

  880.   ec = asio::error_code(

  881.       static_cast<int>(::ERR_get_error()),

  882.       asio::error::get_ssl_category());

  883.   ASIO_SYNC_OP_VOID_RETURN(ec);

  884. }

  885. 

  886. void context::use_private_key_file(

  887.     const std::string& filename, context::file_format format)

  888. {

  889.   asio::error_code ec;

  890.   use_private_key_file(filename, format, ec);

  891.   asio::detail::throw_error(ec, "use_private_key_file");

  892. }

  893. 

  894. void context::use_rsa_private_key(

  895.     const const_buffer& private_key, context::file_format format)

  896. {

  897.   asio::error_code ec;

  898.   use_rsa_private_key(private_key, format, ec);

  899.   asio::detail::throw_error(ec, "use_rsa_private_key");

  900. }

  901. 

  902. ASIO_SYNC_OP_VOID context::use_rsa_private_key(

  903.     const const_buffer& private_key, context::file_format format,

  904.     asio::error_code& ec)

  905. {

  906.   ::ERR_clear_error();

  907. 

  908. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  909.     pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);

  910.     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);

  911. #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  912.     pem_password_cb* callback = handle_->default_passwd_callback;

  913.     void* cb_userdata = handle_->default_passwd_callback_userdata;

  914. #endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  915. 

  916.   bio_cleanup bio = { make_buffer_bio(private_key) };

  917.   if (bio.p)

  918.   {

  919.     rsa_cleanup rsa_private_key = { 0 };

  920.     switch (format)

  921.     {

  922.     case context_base::asn1:

  923.       rsa_private_key.p = ::d2i_RSAPrivateKey_bio(bio.p, 0);

  924.       break;

  925.     case context_base::pem:

  926.       rsa_private_key.p = ::PEM_read_bio_RSAPrivateKey(

  927.           bio.p, 0, callback,

  928.           cb_userdata);

  929.       break;

  930.     default:

  931.       {

  932.         ec = asio::error::invalid_argument;

  933.         ASIO_SYNC_OP_VOID_RETURN(ec);

  934.       }

  935.     }

  936. 

  937.     if (rsa_private_key.p)

  938.     {

  939.       if (::SSL_CTX_use_RSAPrivateKey(handle_, rsa_private_key.p) == 1)

  940.       {

  941.         ec = asio::error_code();

  942.         ASIO_SYNC_OP_VOID_RETURN(ec);

  943.       }

  944.     }

  945.   }

  946. 

  947.   ec = asio::error_code(

  948.       static_cast<int>(::ERR_get_error()),

  949.       asio::error::get_ssl_category());

  950.   ASIO_SYNC_OP_VOID_RETURN(ec);

  951. }

  952. 

  953. ASIO_SYNC_OP_VOID context::use_private_key_file(

  954.     const std::string& filename, context::file_format format,

  955.     asio::error_code& ec)

  956. {

  957.   int file_type;

  958.   switch (format)

  959.   {

  960.   case context_base::asn1:

  961.     file_type = SSL_FILETYPE_ASN1;

  962.     break;

  963.   case context_base::pem:

  964.     file_type = SSL_FILETYPE_PEM;

  965.     break;

  966.   default:

  967.     {

  968.       ec = asio::error::invalid_argument;

  969.       ASIO_SYNC_OP_VOID_RETURN(ec);

  970.     }

  971.   }

  972. 

  973.   ::ERR_clear_error();

  974. 

  975.   if (::SSL_CTX_use_PrivateKey_file(handle_, filename.c_str(), file_type) != 1)

  976.   {

  977.     ec = asio::error_code(

  978.         static_cast<int>(::ERR_get_error()),

  979.         asio::error::get_ssl_category());

  980.     ASIO_SYNC_OP_VOID_RETURN(ec);

  981.   }

  982. 

  983.   ec = asio::error_code();

  984.   ASIO_SYNC_OP_VOID_RETURN(ec);

  985. }

  986. 

  987. void context::use_rsa_private_key_file(

  988.     const std::string& filename, context::file_format format)

  989. {

  990.   asio::error_code ec;

  991.   use_rsa_private_key_file(filename, format, ec);

  992.   asio::detail::throw_error(ec, "use_rsa_private_key_file");

  993. }

  994. 

  995. ASIO_SYNC_OP_VOID context::use_rsa_private_key_file(

  996.     const std::string& filename, context::file_format format,

  997.     asio::error_code& ec)

  998. {

  999.   int file_type;

  1000.   switch (format)

  1001.   {

  1002.   case context_base::asn1:

  1003.     file_type = SSL_FILETYPE_ASN1;

  1004.     break;

  1005.   case context_base::pem:

  1006.     file_type = SSL_FILETYPE_PEM;

  1007.     break;

  1008.   default:

  1009.     {

  1010.       ec = asio::error::invalid_argument;

  1011.       ASIO_SYNC_OP_VOID_RETURN(ec);

  1012.     }

  1013.   }

  1014. 

  1015.   ::ERR_clear_error();

  1016. 

  1017.   if (::SSL_CTX_use_RSAPrivateKey_file(

  1018.         handle_, filename.c_str(), file_type) != 1)

  1019.   {

  1020.     ec = asio::error_code(

  1021.         static_cast<int>(::ERR_get_error()),

  1022.         asio::error::get_ssl_category());

  1023.     ASIO_SYNC_OP_VOID_RETURN(ec);

  1024.   }

  1025. 

  1026.   ec = asio::error_code();

  1027.   ASIO_SYNC_OP_VOID_RETURN(ec);

  1028. }

  1029. 

  1030. void context::use_tmp_dh(const const_buffer& dh)

  1031. {

  1032.   asio::error_code ec;

  1033.   use_tmp_dh(dh, ec);

  1034.   asio::detail::throw_error(ec, "use_tmp_dh");

  1035. }

  1036. 

  1037. ASIO_SYNC_OP_VOID context::use_tmp_dh(

  1038.     const const_buffer& dh, asio::error_code& ec)

  1039. {

  1040.   ::ERR_clear_error();

  1041. 

  1042.   bio_cleanup bio = { make_buffer_bio(dh) };

  1043.   if (bio.p)

  1044.   {

  1045.     return do_use_tmp_dh(bio.p, ec);

  1046.   }

  1047. 

  1048.   ec = asio::error_code(

  1049.       static_cast<int>(::ERR_get_error()),

  1050.       asio::error::get_ssl_category());

  1051.   ASIO_SYNC_OP_VOID_RETURN(ec);

  1052. }

  1053. 

  1054. void context::use_tmp_dh_file(const std::string& filename)

  1055. {

  1056.   asio::error_code ec;

  1057.   use_tmp_dh_file(filename, ec);

  1058.   asio::detail::throw_error(ec, "use_tmp_dh_file");

  1059. }

  1060. 

  1061. ASIO_SYNC_OP_VOID context::use_tmp_dh_file(

  1062.     const std::string& filename, asio::error_code& ec)

  1063. {

  1064.   ::ERR_clear_error();

  1065. 

  1066.   bio_cleanup bio = { ::BIO_new_file(filename.c_str(), "r") };

  1067.   if (bio.p)

  1068.   {

  1069.     return do_use_tmp_dh(bio.p, ec);

  1070.   }

  1071. 

  1072.   ec = asio::error_code(

  1073.       static_cast<int>(::ERR_get_error()),

  1074.       asio::error::get_ssl_category());

  1075.   ASIO_SYNC_OP_VOID_RETURN(ec);

  1076. }

  1077. 

  1078. ASIO_SYNC_OP_VOID context::do_use_tmp_dh(

  1079.     BIO* bio, asio::error_code& ec)

  1080. {

  1081.   ::ERR_clear_error();

  1082. 

  1083.   dh_cleanup dh = { ::PEM_read_bio_DHparams(bio, 0, 0, 0) };

  1084.   if (dh.p)

  1085.   {

  1086.     if (::SSL_CTX_set_tmp_dh(handle_, dh.p) == 1)

  1087.     {

  1088.       ec = asio::error_code();

  1089.       ASIO_SYNC_OP_VOID_RETURN(ec);

  1090.     }

  1091.   }

  1092. 

  1093.   ec = asio::error_code(

  1094.       static_cast<int>(::ERR_get_error()),

  1095.       asio::error::get_ssl_category());

  1096.   ASIO_SYNC_OP_VOID_RETURN(ec);

  1097. }

  1098. 

  1099. ASIO_SYNC_OP_VOID context::do_set_verify_callback(

  1100.     detail::verify_callback_base* callback, asio::error_code& ec)

  1101. {

  1102.   if (SSL_CTX_get_app_data(handle_))

  1103.   {

  1104.     delete static_cast<detail::verify_callback_base*>(

  1105.         SSL_CTX_get_app_data(handle_));

  1106.   }

  1107. 

  1108.   SSL_CTX_set_app_data(handle_, callback);

  1109. 

  1110.   ::SSL_CTX_set_verify(handle_,

  1111.       ::SSL_CTX_get_verify_mode(handle_),

  1112.       &context::verify_callback_function);

  1113. 

  1114.   ec = asio::error_code();

  1115.   ASIO_SYNC_OP_VOID_RETURN(ec);

  1116. }

  1117. 

  1118. int context::verify_callback_function(int preverified, X509_STORE_CTX* ctx)

  1119. {

  1120.   if (ctx)

  1121.   {

  1122.     if (SSL* ssl = static_cast<SSL*>(

  1123.           ::X509_STORE_CTX_get_ex_data(

  1124.             ctx, ::SSL_get_ex_data_X509_STORE_CTX_idx())))

  1125.     {

  1126.       if (SSL_CTX* handle = ::SSL_get_SSL_CTX(ssl))

  1127.       {

  1128.         if (SSL_CTX_get_app_data(handle))

  1129.         {

  1130.           detail::verify_callback_base* callback =

  1131.             static_cast<detail::verify_callback_base*>(

  1132.                 SSL_CTX_get_app_data(handle));

  1133. 

  1134.           verify_context verify_ctx(ctx);

  1135.           return callback->call(preverified != 0, verify_ctx) ? 1 : 0;

  1136.         }

  1137.       }

  1138.     }

  1139.   }

  1140. 

  1141.   return 0;

  1142. }

  1143. 

  1144. ASIO_SYNC_OP_VOID context::do_set_password_callback(

  1145.     detail::password_callback_base* callback, asio::error_code& ec)

  1146. {

  1147. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

  1148.   void* old_callback = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);

  1149.   ::SSL_CTX_set_default_passwd_cb_userdata(handle_, callback);

  1150. #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  1151.   void* old_callback = handle_->default_passwd_callback_userdata;

  1152.   handle_->default_passwd_callback_userdata = callback;

  1153. #endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)

  1154. 

  1155.   if (old_callback)

  1156.     delete static_cast<detail::password_callback_base*>(

  1157.         old_callback);

  1158. 

  1159.   SSL_CTX_set_default_passwd_cb(handle_, &context::password_callback_function);

  1160. 

  1161.   ec = asio::error_code();

  1162.   ASIO_SYNC_OP_VOID_RETURN(ec);

  1163. }

  1164. 

  1165. int context::password_callback_function(

  1166.     char* buf, int size, int purpose, void* data)

  1167. {

  1168.   using namespace std; // For strncat and strlen.

  1169. 

  1170.   if (data)

  1171.   {

  1172.     detail::password_callback_base* callback =

  1173.       static_cast<detail::password_callback_base*>(data);

  1174. 

  1175.     std::string passwd = callback->call(static_cast<std::size_t>(size),

  1176.         purpose ? context_base::for_writing : context_base::for_reading);

  1177. 

  1178. #if defined(ASIO_HAS_SECURE_RTL)

  1179.     strcpy_s(buf, size, passwd.c_str());

  1180. #else // defined(ASIO_HAS_SECURE_RTL)

  1181.     *buf = '\0';

  1182.     if (size > 0)

  1183.       strncat(buf, passwd.c_str(), size - 1);

  1184. #endif // defined(ASIO_HAS_SECURE_RTL)

  1185. 

  1186.     return static_cast<int>(strlen(buf));

  1187.   }

  1188. 

  1189.   return 0;

  1190. }

  1191. 

  1192. BIO* context::make_buffer_bio(const const_buffer& b)

  1193. {

  1194.   return ::BIO_new_mem_buf(

  1195.       const_cast<void*>(b.data()),

  1196.       static_cast<int>(b.size()));

  1197. }

  1198. 

  1199. } // namespace ssl

  1200. } // namespace asio

  1201. 

  1202. #include "asio/detail/pop_options.hpp"

  1203. 

  1204. #endif // ASIO_SSL_IMPL_CONTEXT_IPP