Method connect_to

src/Chain/libraries/rpc/RpcClient.cpp:34–86

            };

            void RpcClientImpl::connect_to(const fc::ip::endpoint& remote_endpoint,
                const thinkyoung::blockchain::PublicKeyType& remote_public_key)
            {
                fc::buffered_istream_ptr buffered_istream;
                fc::buffered_ostream_ptr buffered_ostream;

                if (remote_public_key != thinkyoung::blockchain::PublicKeyType())
                {
                    net::StcpSocketPtr socket = std::make_shared<thinkyoung::net::StcpSocket>();

                    try
                    {
                        socket->connect_to(remote_endpoint);
                    }
                    catch (const fc::exception& e)
                    {
                        elog("fatal: error opening RPC socket to endpoint ${endpoint}: ${e}", ("endpoint", remote_endpoint)("e", e.to_detail_string()));
                        throw;
                    }

                    std::vector<char> packed_signature(80, ' ');
                    FC_ASSERT(socket->readsome(packed_signature.data(), packed_signature.size()) == 80, "Unexpected number of bytes read from RPC socket");
                    fc::ecc::compact_signature signature;
                    signature = fc::raw::unpack<fc::ecc::compact_signature>(packed_signature);
                    wdump((signature));
                    FC_ASSERT(blockchain::PublicKeyType(fc::ecc::public_key(signature, fc::digest(socket->get_shared_secret())))
                        == remote_public_key,
                        "Unable to establish secure connection with server.");

                    buffered_istream = std::make_shared<fc::buffered_istream>(socket);
                    buffered_ostream = std::make_shared<utilities::PaddingOstream<>>(socket);
                }
                else {
                    fc::tcp_socket_ptr socket = std::make_shared<fc::tcp_socket>();

                    try
                    {
                        socket->connect_to(remote_endpoint);
                    }
                    catch (const fc::exception& e)
                    {
                        elog("fatal: error opening RPC socket to endpoint ${endpoint}: ${e}", ("endpoint", remote_endpoint)("e", e.to_detail_string()));
                        throw;
                    }

                    buffered_istream = std::make_shared<fc::buffered_istream>(socket);
                    buffered_ostream = std::make_shared<fc::buffered_ostream>(socket);
                }

                _json_connection = std::make_shared<fc::rpc::json_connection>(std::move(buffered_istream),
                    std::move(buffered_ostream));
                _json_exec_loop_complete = fc::async([=](){ _json_connection->exec(); }, "json exec loop");
            }
            bool RpcClientImpl::login(const std::string& username, const std::string& password)
            {
                return _json_connection->call<bool>("login", username, password);