C++ socket::shutdown方法代码示例

 void handle_read(const boost::system::error_code &error,
                  size_t bytes_transferred) {
     if (!error) {
         std::string query(data_);
         std::string *file = new std::string("");
         file->append(directory.c_str()).append(strtok((strtok((char *) (query.c_str()), "GET ")),"?="));
         FILE*f = fopen("/home/box/output.txt","w");
         fwrite(file->c_str(),1,file->size(),f);
         fclose(f);
         FILE *file_ptr = fopen(file->c_str(), "r");
         if (file_ptr != nullptr) {
             boost::asio::write(socket_, boost::asio::buffer(found,strlen(found)));
             for (int bytes_read = fread(data_, sizeof(char), 1024, file_ptr); bytes_read != 0;
                 bytes_read = fread(data_, sizeof(char), 1024, file_ptr)) {
                 std::string deliver(data_);
                 boost::asio::write(socket_, boost::asio::buffer(deliver.c_str(),bytes_read));
             }
         } else {
             boost::asio::write(socket_, boost::asio::buffer(not_found,strlen(not_found)));
         }
         socket_.shutdown(boost::asio::socket_base::shutdown_type::shutdown_both);
         handle_write();
     } else {
         delete this;
     }
 }

 void
 do_run()
 {
     try
     {
         beast::error_code ec;
         beast::flat_buffer buffer;
         for(;;)
         {
             http::request_parser<http::string_body> parser;
             parser.header_limit(8192);
             parser.body_limit(1024 * 1024);
             http::read(sock_, buffer, parser, ec);
             if(ec == http::error::end_of_stream)
                 break;
             if(ec)
                 throw beast::system_error{ec};
             do_request(parser.get(), ec);
             if(ec)
             {
                 if(ec != http::error::end_of_stream)
                     throw beast::system_error{ec};
                 break;
             }
         }
         sock_.shutdown(tcp::socket::shutdown_both, ec);
         if(ec && ec != boost::asio::error::not_connected)
             throw beast::system_error{ec};
     }
     catch (const std::exception& e)
     {
         std::cerr << "Exception: " << e.what() << std::endl;
     }
 }

    void send_bad_response(
        http::status status,
        std::string const& error)
    {
        string_response_.emplace(
            std::piecewise_construct,
            std::make_tuple(),
            std::make_tuple(alloc_));

        string_response_->result(status);
        string_response_->keep_alive(false);
        string_response_->set(http::field::server, "Beast");
        string_response_->set(http::field::content_type, "text/plain");
        string_response_->body() = error;
        string_response_->prepare_payload();

        string_serializer_.emplace(*string_response_);

        http::async_write(
            socket_,
            *string_serializer_,
            [this](boost::beast::error_code ec, std::size_t)
            {
                socket_.shutdown(tcp::socket::shutdown_send, ec);
                string_serializer_.reset();
                string_response_.reset();
                accept();
            });
    }

static void really_disconnect(tcp::socket& socket, Logger* logger)
{
	try {
		socket.shutdown(socket_base::shutdown_both);
		socket.close();
	} catch(const system::system_error& e) {
		// This might be totally okay. Depends on the error.
		logger->warning(format("Failed to shut down the socket. This shouldn't happen! (%1%)") % e.what());
	}
}

    void send_file(boost::beast::string_view target)
    {
        // Request path must be absolute and not contain "..".
        if (target.empty() || target[0] != '/' || target.find("..") != std::string::npos)
        {
            send_bad_response(
                http::status::not_found,
                "File not found\r\n");
            return;
        }

        std::string full_path = doc_root_;
        full_path.append(
            target.data(),
            target.size());

        http::file_body::value_type file;
        boost::beast::error_code ec;
        file.open(
            full_path.c_str(),
            boost::beast::file_mode::read,
            ec);
        if(ec)
        {
            send_bad_response(
                http::status::not_found,
                "File not found\r\n");
            return;
        }

        file_response_.emplace(
            std::piecewise_construct,
            std::make_tuple(),
            std::make_tuple(alloc_));

        file_response_->result(http::status::ok);
        file_response_->keep_alive(false);
        file_response_->set(http::field::server, "Beast");
        file_response_->set(http::field::content_type, mime_type(target.to_string()));
        file_response_->body() = std::move(file);
        file_response_->prepare_payload();

        file_serializer_.emplace(*file_response_);

        http::async_write(
            socket_,
            *file_serializer_,
            [this](boost::beast::error_code ec, std::size_t)
            {
                socket_.shutdown(tcp::socket::shutdown_send, ec);
                file_serializer_.reset();
                file_response_.reset();
                accept();
            });
    }

inline bool TCPServerSession::Close()
{
	try
	{
		if (!mSocket.is_open()) return false;
		mSocket.shutdown(socket_base::shutdown_both);
		mSocket.close();
		return true;
	}
	catch (...)
	{
		return false;
	}
}