Boost :: Asio,SSL连接问题

Question

我试着解决我的问题几天了,只是不能支持它.我尝试与Boost :: Asio库和OpenSSL进行SSL连接.有一个示例代码,如何执行此操作:http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/example/cpp03/ssl/client.cpp

它构建并运行良好甚至验证似乎都有效,但是当我发送一个简单的请求时,很长一段时间都没有发生任何事情,然后我收到错误消息:"读取失败:短读".我想,我只是把请求线本身做错了,但我无法弄清楚它是如何做的.我尝试了以下几行:

GET / HTTP/1.1<CR><LF>Host: www.google.de<CR><LF>Connection: close<CR><LF><CR><LF>

GET / HTTP/1.1\r\nHost: www.google.de\r\nConnection: close\r\n\r\n

我无法发布图片,因为这是我的第一个帖子,但你可以在这里找到cmd-Window:

提前致谢!

更新:我得到了它的工作!:D非常感谢sehe,我只需要更改代码中的第77行:

size_t request_length = strlen(request_);

至:

 size_t request_length = strlen(raw);

现在它工作得很好,为你的帮助thx :)

我仍然不明白,为什么boost示例代码不能按我的意图工作..

Answer 1

哈！

我又抽出时间又看了一遍。我这里的代码（http://coliru.stacked-crooked.com/a/2042c3d24a16c6ac）已经几乎是正确的。除了一个非常简单的错误：

size_t request_length = strlen(request_);

看起来无害，不是吗？除了...request_此时尚未初始化。它需要是（在上下文中）：

  static char const raw[] = "GET / HTTP/1.1\r\nHost: www.google.de\r\nConnection: close\r\n\r\n";

  static_assert(sizeof(raw)<=sizeof(request_), "too large");

  size_t request_length = strlen(raw);
  std::copy(raw, raw+request_length, request_);

当然，这个问题在您链接到的官方Boost示例中不存在（因为它直接读取到请求缓冲区std::cin.getline）。然而，像我一样，你可能也犯过同样的初学者错误。

希望这可以帮助。

附件是一个完整的工作演示，您甚至可以切换到使用 HTTPS 或不使用预处理器指令：

#define SEHE_USE_SSL

另请注意，我使用

ctx.set_default_verify_paths();

因此您可以使用在您的计算机上注册的默认根权限证书（如果您的 openssl 安装有它）。

完整代码

#define SEHE_USE_SSL
#define BOOST_ASIO_ENABLE_HANDLER_TRACKING

#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>

class client
{
public:
  client(boost::asio::io_service& io_service,
      boost::asio::ssl::context& context,
      boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
    : socket_(io_service
#ifdef SEHE_USE_SSL
            , context)
  {
    socket_.set_verify_mode(boost::asio::ssl::verify_peer);
    socket_.set_verify_callback(
        boost::bind(&client::verify_certificate, this, _1, _2));
#else
            )
  {
      (void) context;
#endif

    boost::asio::async_connect(socket_.lowest_layer(), endpoint_iterator,
        boost::bind(&client::handle_connect, this,
          boost::asio::placeholders::error));
  }

  bool verify_certificate(bool preverified,
      boost::asio::ssl::verify_context& ctx)
  {
      // The verify callback can be used to check whether the certificate that is
      // being presented is valid for the peer. For example, RFC 2818 describes
      // the steps involved in doing this for HTTPS. Consult the OpenSSL
      // documentation for more details. Note that the callback is called once
      // for each certificate in the certificate chain, starting from the root
      // certificate authority.

      // In this example we will simply print the certificate's subject name.
      char subject_name[256];
      X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
      X509_NAME_oneline(X509_get_subject_name(cert), subject_name, 256);
      std::cout << "Verifying " << subject_name << "\n";

      return true || preverified;
  }

  void handle_connect(const boost::system::error_code& error)
  {
#ifdef SEHE_USE_SSL
      if (!error)
      {
          socket_.async_handshake(boost::asio::ssl::stream_base::client,
                  boost::bind(&client::handle_handshake, this,
                      boost::asio::placeholders::error));
      }
      else
      {
          std::cout << "Connect failed: " << error.message() << "\n";
      }
#else
      handle_handshake(error);
#endif
  }

  void handle_handshake(const boost::system::error_code& error)
  {
      if (!error)
      {
          std::cout << "Enter message: ";
          static char const raw[] = "GET / HTTP/1.1\r\nHost: www.google.de\r\nConnection: close\r\n\r\n";

          static_assert(sizeof(raw)<=sizeof(request_), "too large");

          size_t request_length = strlen(raw);
          std::copy(raw, raw+request_length, request_);

          {
              // used this for debugging:
              std::ostream hexos(std::cout.rdbuf());
              for(auto it = raw; it != raw+request_length; ++it)
                  hexos << std::hex << std::setw(2) << std::setfill('0') << std::showbase << ((short unsigned) *it) << " ";
              std::cout << "\n";
          }

          boost::asio::async_write(socket_,
                  boost::asio::buffer(request_, request_length),
                  boost::bind(&client::handle_write, this,
                      boost::asio::placeholders::error,
                      boost::asio::placeholders::bytes_transferred));
      }
      else
      {
          std::cout << "Handshake failed: " << error.message() << "\n";
      }
  }

  void handle_write(const boost::system::error_code& error,
      size_t /*bytes_transferred*/)
  {
      if (!error)
      {
          std::cout << "starting read loop\n";
          boost::asio::async_read_until(socket_,
                  //boost::asio::buffer(reply_, sizeof(reply_)),
                  reply_, '\n',
                  boost::bind(&client::handle_read, this,
                      boost::asio::placeholders::error,
                      boost::asio::placeholders::bytes_transferred));
      }
      else
      {
          std::cout << "Write failed: " << error.message() << "\n";
      }
  }

  void handle_read(const boost::system::error_code& error, size_t /*bytes_transferred*/)
  {
      if (!error)
      {
          std::cout << "Reply: " << &reply_ << "\n";
      }
      else
      {
          std::cout << "Read failed: " << error.message() << "\n";
      }
  }

private:
#ifdef SEHE_USE_SSL
  boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket_;
#else
  boost::asio::ip::tcp::socket socket_;
#endif
  char request_[1024];
  //char reply_  [1024];
  boost::asio::streambuf reply_;
};

int main(int argc, char* argv[])
{
    try
    {
        if (argc != 3)
        {
            std::cerr << "Usage: client <host> <port>\n";
            return 1;
        }

        boost::asio::io_service io_service;

        boost::asio::ip::tcp::resolver resolver(io_service);
        boost::asio::ip::tcp::resolver::query query(argv[1], argv[2]);
        boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);

        boost::asio::ssl::context ctx(boost::asio::ssl::context::sslv23);
        ctx.set_default_verify_paths();

        client c(io_service, ctx, iterator);

        io_service.run();
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}