C++ connection_ptr::send方法代码示例

void chat_server_handler::on_message(connection_ptr con, message_ptr msg) {
    if (msg->get_opcode() != websocketpp::frame::opcode::text) {
        return;
    }
    
    std::cout << "message from client " << con << ": " << msg->get_payload() << std::endl;
    
    
    
    // check for special command messages
    if (msg->get_payload() == "/help") {
        // print command list
        con->send(encode_message("server","avaliable commands:<br />&nbsp;&nbsp;&nbsp;&nbsp;/help - show this help<br />&nbsp;&nbsp;&nbsp;&nbsp;/alias foo - set alias to foo",false));
        return;
    }
    
    if (msg->get_payload().substr(0,7) == "/alias ") {
        std::string response;
        std::string alias;
        
        if (msg->get_payload().size() == 7) {
            response = "you must enter an alias.";
            con->send(encode_message("server",response));
            return;
        } else {
            alias = msg->get_payload().substr(7);
        }
        
        response = m_connections[con] + " is now known as "+alias;

        // store alias pre-escaped so we don't have to do this replacing every time this
        // user sends a message
        
        // escape json characters
        boost::algorithm::replace_all(alias,"\\","\\\\");
        boost::algorithm::replace_all(alias,"\"","\\\"");
        
        // escape html characters
        boost::algorithm::replace_all(alias,"&","&amp;");
        boost::algorithm::replace_all(alias,"<","&lt;");
        boost::algorithm::replace_all(alias,">","&gt;");
        
        m_connections[con] = alias;
        
        // set alias
        send_to_all(serialize_state());
        send_to_all(encode_message("server",response));
        return;
    }
    
    // catch other slash commands
    if ((msg->get_payload())[0] == '/') {
        con->send(encode_message("server","unrecognized command"));
        return;
    }
    
    // create json message to send based on msg
    send_to_all(encode_message(m_connections[con],msg->get_payload()));
}

 void send_messages(
     connection_ptr connection
 )
 {
     // Check if sending has been completed....
     if (connection->send())
     {
         error_code ec;
         util::unique_function_nonser<
             void(
                 error_code const&
               , parcelset::locality const&
               , connection_ptr
             )
         > postprocess_handler;
         std::swap(postprocess_handler, connection->postprocess_handler_);
         postprocess_handler(
             ec, connection->destination(), connection);
     }
     else
     {
         std::unique_lock<mutex_type> l(connections_mtx_);
         connections_.push_back(std::move(connection));
     }
 }

 void handle_get_trx_block( const connection_ptr& c, chan_data& cdat, get_trx_block_message msg )
 { try {
     // TODO: throttle attempts to query blocks by a single connection
     uint32_t blk_num = _db->fetch_block_num( msg.block_id );
     trx_block blk    = _db->fetch_trx_block( blk_num );
     c->send( network::message(trx_block_message( blk ), _chan_id ) );
 } FC_RETHROW_EXCEPTIONS( warn, "", ("msg",msg) ) } // provide stack trace for errors

 /* ===================================================== */   
 void handle_get_name_inv( const connection_ptr& con,  chan_data& cdat, const get_name_inv_message& msg )
 {
     name_inv_message reply;
     reply.name_trxs = _trx_broadcast_mgr.get_inventory( cdat.trxs_mgr );
     cdat.trxs_mgr.update_known( reply.name_trxs );
     con->send( network::message(reply,_chan_id) );
 }

 void on_message(connection_ptr con, message_ptr msg) {        
     if (con->get_resource() == "/getcasecount") {
         std::cout << "detected " << msg->get_payload() << " test cases." << std::endl;
         m_case_count = atoi(msg->get_payload().c_str());
     } else {
         con->send(msg->get_payload(),msg->get_opcode());
     }
 }

void chat_server_handler::on_open(connection_ptr con) {
    std::cout << "client " << con << " joined the lobby." << std::endl;
    m_connections.insert(std::pair<connection_ptr,std::string>(con,get_con_id(con)));

    // send user list and signon message to all clients
    send_to_all(serialize_state());
    con->send(encode_message("server","welcome, use the /alias command to set a name, /help for a list of other commands."));
    send_to_all(encode_message("server",m_connections[con]+" has joined the chat."));
}

    void on_open(connection_ptr con) {
        // now it is safe to use the connection
        std::cout << "connection ready" << std::endl;

        received = false;

        std::string SIP_msg="OPTIONS sip:[email protected] SIP/2.0\r\nVia: SIP/2.0/WS df7jal23ls0d.invalid;rport;branch=z9hG4bKhjhs8ass877\r\nMax-Forwards: 70\r\nTo: <sip:[email protected]>\r\nFrom: Alice <sip:[email protected]>;tag=1928301774\r\nCall-ID: a84b4c76e66710\r\nCSeq: 63104 OPTIONS\r\nContact: <sip:[email protected]>\r\nAccept: application/sdp\r\nContent-Length: 0\r\n\r\n";
        con->send(SIP_msg.c_str());
    }

bool ConnectService::process(message_ptr const & message, connection_ptr const & connection)
{
	static Engine& engine = Engine::get_instance();
	if (message->type != MessageType::PING) return false;

	uint32_t id;
	_dec_declare2_(req, message->get_content_data(), message->get_content_size());
	_dec_get_var32_(req, id);
	if (!_dec_valid_(req))
	{
		DLOG(ERROR) << "Bad Ping format";
		return true;
	}

	NodeConf* config = (NodeConf*) engine.get_component(COMP_SERVERCONF).get();
	servernode_map::iterator it = config->nodes.find(id);
	if (it != config->nodes.end())
	{
		servernode_ptr node = it->second;
		connection->asyn = true;
		connection->authenticated = true;
		connection->data = node.get();
		connection->type = CT_S2S;
		node->connection = connection;
		node->state = READY;

		_enc_declare_(rep, 64);
		_enc_put_msg_header_(rep, MessageType::REPLY, message->id, 0);
		_enc_put_var32_(rep, ErrorCode::OK);
		_enc_update_msg_size_(rep);
		connection->send(_enc_data_(rep), _enc_size_(rep));
	}
	else
	{
		_enc_declare_(rep, 64);
		_enc_put_msg_header_(rep, MessageType::REPLY, message->id, 0);
		_enc_put_var32_(rep, ErrorCode::IS_NOT_FOUND);
		_enc_update_msg_size_(rep);
		connection->send(_enc_data_(rep), _enc_size_(rep));
	}
	return true;
}

 /* ===================================================== */   
 void handle_get_block_index( const connection_ptr& con,  chan_data& cdat, const get_block_index_message& msg )
 { try {
    ilog( "${msg}", ("msg",msg) );
    const fc::optional<name_block_index>& trx = _block_index_broadcast_mgr.get_value( msg.block_id );
    if( !trx ) // must be a db
    {
      auto debug_str = _block_index_broadcast_mgr.debug();
      FC_ASSERT( !"Name block index not in broadcast cache", "${str}", ("str",debug_str) );
    }
    con->send( network::message( block_index_message( *trx ), _chan_id ) );
 } FC_RETHROW_EXCEPTIONS( warn, "", ("msg",msg) ) }

          void handle_get_full_block( const connection_ptr& c, chan_data& cdat, get_full_block_message msg )
          { try {
              // TODO: throttle attempts to query blocks by a single connection
              // this request must hit the DB... cost in proof of work is proportional to age to prevent
              // cache thrashing attacks and allowing us to keep newer blocks in the cache 
              // penalize connections that request too many full blocks...
              uint32_t blk_num = _db->fetch_block_num( msg.block_id );
              full_block blk   = _db->fetch_full_block( blk_num );
              c->send( network::message(full_block_message( blk ), _chan_id ) );

          } FC_RETHROW_EXCEPTIONS( warn, "", ("msg",msg) ) } // provide stack trace for errors

 void on_message(connection_ptr con,message_ptr msg) {
     int value = atoi(msg->get_payload().c_str());
     
     if (value == 0) {
         con->send("Invalid sleep value.");
     } else {
         request r;
         r.con = con;
         r.value = value;
         r.process();
     }
 }

 void on_message(connection_ptr con,message_ptr msg) {
     int value = atoi(msg->get_payload().c_str());
     
     if (value == 0) {
         con->send("invalid sleep value.");
     } else {
         request r;
         r.con = con;
         r.value = value;
         m_coordinator.add_request(r);
     }
 }

 void on_open(connection_ptr con) {
     std::stringstream o;
     
     o << "{"
       << "\"type\":\"test_welcome\","
       << "\"version\":\"" << m_ua << "\","
       << "\"ident\":\"" << m_ident << "\","
       << "\"num_workers\":" << m_num_workers 
       << "}";
     
     con->send(o.str());
 }

 void handle_get_trx_inv( const connection_ptr& c, chan_data& cdat, get_trx_inv_message msg )
 { try {
    // TODO: only allow this request once every couple of minutes to prevent flood attacks
    
    // TODO: make sure these inventory items are sorted by fees
    trx_inv_message reply;
    reply.items.reserve( TRX_INV_QUERY_LIMIT ); 
    for( auto itr = _pending_trx.begin(); reply.items.size() < TRX_INV_QUERY_LIMIT && itr != _pending_trx.end(); ++itr )
    {
       reply.items.push_back( itr->first );
    }
    c->send( network::message( reply, _chan_id ) );
 } FC_RETHROW_EXCEPTIONS( warn, "", ("msg",msg) ) } // provide stack trace for errors

 void handle_get_priv( const connection_ptr& c, bitchat_chan_data& cd, const get_priv_message& msg )
 {
    // TODO: throttle the rate at which get_priv may be called for a given connection
    for( auto itr = msg.items.begin(); itr != msg.items.end(); ++itr )
    {
       auto m = priv_msgs.find( *itr );
       if( m != priv_msgs.end() )
       {
          c->send( network::message( m->second, chan_id ) );
          cd.known_inv.insert( *itr ); 
       }
    }
 }