Beispiel #1
0
        std::shared_ptr<const Msg>
        unmarshall(const_buffer<char> inb)
        {
            std::map<int, std::shared_ptr<BaseMarshall> >::iterator it;
            int type=ntohl(*reinterpret_cast<const int*> (inb.addr()));
            unsigned int len=ntohl(*reinterpret_cast<const unsigned int*> (inb.addr()+sizeof(int)));

            it=m_map.find(type);
            if(it==m_map.end())
                throw std::runtime_error("marshalling:: message type not supported");
            return it->second->unmarshall(const_buffer<char>(inb.addr()+HEAD_SIZE,len));
        }
Beispiel #2
0
    void UHPacket::parse_uh(const const_buffer<uint8_t> & uh_buf)
    {

        const uint8_t  * buf = uh_buf.addr();

        m_key.proto = *(buf + 0x0A);
        m_key.src_port = ntohs(*((uint16_t*)(buf + 0x1C)));
        m_key.dst_port = ntohs(*((uint16_t*)(buf + 0x1E)));
        m_key.src_ip4  = ntohl(*((uint32_t*)(buf + 0x2C)));
        m_key.dst_ip4  = ntohl(*((uint32_t*)(buf + 0x3C)));

        //m_tstamp = ntohl(*((uint32_t*)(buf + 0x10)));    // FIXME: retype
        m_length = ntohs(*((uint16_t*)(buf + 0x0B)));
        m_caplen = 0;

        switch(*(buf + 0x08))
        {
        case 0x40:
            m_pkttype = Packet::kPktTypeIP4;
            break;
        case 0x60:
            m_pkttype = Packet::kPktTypeIP6;
            break;
        default:
            m_pkttype = 0;
            break;
        }
        m_iptos = *(buf + 0x1A);
        m_ipttl = *(buf + 0x1B);

        m_machdr_parsed = true;
        m_iphdr_parsed = true;
        m_ports_parsed = true;
        m_l4hdr_parsed = true;
    }
Beispiel #3
0
int stream_socket::writev(const_buffer const &b)
{
	static const unsigned max_vec_size = 16;
	const_buffer::buffer_data_type data = b.get();
	unsigned size=0;
#ifndef BOOSTER_WIN32
	struct iovec vec[max_vec_size];
	for(;size < max_vec_size && size < data.second;size++) {
		vec[size].iov_base = const_cast<char *>(data.first[size].ptr);
		vec[size].iov_len = data.first[size].size;
	}
	for(;;) {
		int ret = ::writev(native(),vec,size);
		if(ret >= 0)
			return ret;
		if(ret < 0 && errno==EINTR)
			continue;
		return ret;
	}
#else // Win32
	WSABUF vec[max_vec_size];
	for(;size < max_vec_size && size < data.second;size++) {
		vec[size].buf = const_cast<char *>(data.first[size].ptr);
		vec[size].len = data.first[size].size;
	}
	DWORD send=0;
	int res = ::WSASend(native(),vec,size,&send,0,0,0);
	if(res == 0)
		return send;
	return -1;
#endif
}
Beispiel #4
0
void proxy::do_send(const std::string& command, const_buffer buffer,
    result_handler handler)
{
    if (stopped())
    {
        handler(error::channel_stopped);
        return;
    }

    LOG_DEBUG(LOG_NETWORK)
        << "Sending " << command << " to [" << authority() << "] ("
        << buffer.size() << " bytes)";

    // Critical Section (protect socket)
    ///////////////////////////////////////////////////////////////////////////
    // The socket is locked until async_write returns.
    const auto socket = socket_->get_socket();

    // The shared buffer is kept in scope until the handler is invoked.
    using namespace boost::asio;
    async_write(socket->get(), buffer,
        std::bind(&proxy::handle_send,
            shared_from_this(), _1, buffer, handler));
    ///////////////////////////////////////////////////////////////////////////
}
Beispiel #5
0
void proxy::handle_send(const boost_code& ec, const_buffer buffer,
    result_handler handler)
{
    const auto error = code(error::boost_to_error_code(ec));

    if (error)
        LOG_DEBUG(LOG_NETWORK)
            << "Failure sending " << buffer.size() << " byte message to ["
            << authority() << "] " << error.message();

    handler(error);
}
void proxy::handle_send(const boost_code& ec, const_buffer buffer,
    /*scope_lock::ptr lock,*/ result_handler handler)
{
    ////lock = nullptr;
    //////\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

    const auto error = code(error::boost_to_error_code(ec));

    if (error)
        log::debug(LOG_NETWORK)
            << "Failure sending " << buffer.size() << " byte message to ["
            << authority() << "] " << error.message();

    handler(error);
}
////// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
////// THIS REQUIRES AT LEAST TWO NETWORK THREADS TO PREVENT THREAD STARVATION.
////// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
////// The send subscriber pushes queued writes to the writer instead of having
////// writer pull them from a passive queue. This is less thread-efficient but it
////// allows us to reuse the subscriber and facilitates bypass of subscriber
////// queuing for large message types such as blocks, as we do with reads.
bool proxy::do_send(const code&, const std::string& command,
    const_buffer buffer, result_handler handler)
{
    if (stopped())
    {
        handler(error::channel_stopped);
        return false;
    }

    ////if (ec)
    ////{
    ////    log::debug(LOG_NETWORK)
    ////        << "Send dequeue failure [" << authority() << "] " << ec.message();
    ////    handler(ec);
    ////    stop(ec);
    ////    return false;
    ////}

    log::debug(LOG_NETWORK)
        << "Sending " << command << " to [" << authority() << "] ("
        << buffer.size() << " bytes)";

    ////// Critical Section (protect writer)
    //////\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
    ////// The lock must be held until the handler is invoked.
    ////const auto lock = std::make_shared<scope_lock>(mutex_);

    // Critical Section (protect socket)
    ///////////////////////////////////////////////////////////////////////////
    // The socket is locked until async_write returns.
    const auto socket = socket_->get_socket();

    // The shared buffer must be kept in scope until the handler is invoked.
    using namespace boost::asio;
    async_write(socket->get(), buffer,
        std::bind(&proxy::handle_send,
            shared_from_this(), _1, buffer, /*lock,*/ handler));

    return true;
    ///////////////////////////////////////////////////////////////////////////
}