コード例 #1
0
ファイル: CRtdsAdapter.cpp プロジェクト: FREEDM-DGI/FREEDM
////////////////////////////////////////////////////////////////////////////////
/// This is the main communication engine.
///
/// @IO
///     At every timestep, a message is sent to the FPGA via TCP socket
///     connection, then a message is retrieved from FPGA via the same
///     connection.  On the FPGA side, it's the reverse order -- receive and
///     then send.  Both DGI and FPGA receive functions will block until a
///     message arrives, creating a synchronous, lock-step communication between
///     DGI and the FPGA. We keep the timestep (a static member of CRtdsAdapter)
///     very small so that how frequently send and receive get executed is
///     dependent on how fast the FPGA runs.
///
/// @Error_Handling
///     Throws std::runtime_error if reading from or writing to socket fails.
///
/// @pre Connection with FPGA is established.
///
/// @post All values in the receive buffer are sent to the FPGA.  All values in
/// the send buffer are updated with data from the FPGA.
///
/// @limitations This function uses synchronous communication.
////////////////////////////////////////////////////////////////////////////////
void CRtdsAdapter::Run(const boost::system::error_code & e)
{
    Logger.Trace << __PRETTY_FUNCTION__ << std::endl;

    if( e )
    {
        if (e == boost::asio::error::operation_aborted)
        {
            return;
        }
        else
        {
            Logger.Fatal << "Run called with error: " << e.message()
                    << std::endl;
            throw boost::system::system_error(e);
        }
    }

    // Always send data to FPGA first
    if( !m_txBuffer.empty() )
    {
        boost::unique_lock<boost::shared_mutex> writeLock(m_txMutex);
        Logger.Debug << "Obtained the txBuffer mutex." << std::endl;

        EndianSwapIfNeeded(m_txBuffer);
        try
        {
            Logger.Debug << "Blocking for a socket write call." << std::endl;
            TimedWrite(m_socket, boost::asio::buffer(m_txBuffer,
                    m_txBuffer.size() * sizeof(SignalValue)),
                    CTimings::Get("DEV_SOCKET_TIMEOUT"));

        }
        catch(boost::system::system_error & e)
        {
            Logger.Fatal << "Send to FPGA failed: " << e.what();
            throw;
        }
        EndianSwapIfNeeded(m_txBuffer);

        Logger.Debug << "Releasing the txBuffer mutex." << std::endl;
    }

    // Receive data from FPGA next
    if( !m_rxBuffer.empty() )
    {
        // must be a unique_lock for endian swaps
        boost::unique_lock<boost::shared_mutex> writeLock(m_rxMutex);
        Logger.Debug << "Obtained the rxBuffer mutex." << std::endl;

        try
        {
            Logger.Debug << "Blocking for a socket read call." << std::endl;
            TimedRead(m_socket, boost::asio::buffer(m_rxBuffer,
                    m_rxBuffer.size() * sizeof(SignalValue)),
                    CTimings::Get("DEV_SOCKET_TIMEOUT"));
        }
        catch (boost::system::system_error & e)
        {
            Logger.Fatal << "Receive from FPGA failed: " << e.what();
            throw;
        }
        EndianSwapIfNeeded(m_rxBuffer);

        if( m_buffer_initialized == false )
        {
            m_buffer_initialized = true;

            for( unsigned int i = 0; i < m_rxBuffer.size(); i++ )
            {
                if( m_rxBuffer[i] == NULL_COMMAND )
                {
                    m_buffer_initialized = false;
                }
            }
            if( m_buffer_initialized )
            {
                Logger.Status << "Clientdata : " <<m_rxBuffer[0]<< std::endl;

                RevealDevices();
            }
        }

        Logger.Debug << "Releasing the rxBuffer mutex." << std::endl;
    }

    // Start the timer; on timeout, this function is called again
    m_runTimer.expires_from_now(
    boost::posix_time::milliseconds(CTimings::Get("DEV_RTDS_DELAY")));
    m_runTimer.async_wait(boost::bind(&CRtdsAdapter::Run, shared_from_this(),
            boost::asio::placeholders::error));
}
コード例 #2
0
ファイル: cserial.cpp プロジェクト: psy0rz/Synapse
//executed from io-service thread
void Cserial::error(int id, const boost::system::error_code& error)
{
	//dummy
	ERROR("serial " << id << " had an error:" << error.message());
}
コード例 #3
0
void ProtocolLogin::onError(const boost::system::error_code& error)
{
    callLuaField("onError", error.message(), true);
    disconnect();
}
コード例 #4
0
ファイル: ClientConnection.cpp プロジェクト: abhay447/malmo
 void ClientConnection::wrote( const boost::system::error_code& error,
                               size_t bytes_transferred )
 {        
     if (error)
         LOGERROR(LT("Failed to write to "), this->socket->remote_endpoint(), LT(" - transferred "), bytes_transferred, LT(" bytes - "), error.message());
     else
     {
         LOGTRACE(LT("Succesfully wrote "), this->outbox.front(), LT(" to "), this->socket->remote_endpoint());
         boost::lock_guard<boost::mutex> scope_guard(this->outbox_mutex);
         this->outbox.pop_front();
     }
     if( !this->outbox.empty() )
         this->write();  
 }
コード例 #5
0
 void 
 TCPConnection::ReportDebugMessage(const String &message, const boost::system::error_code &error)
 {
    String formattedMessage;
    formattedMessage.Format(_T("%s Remote IP: %s, Session: %d, Code: %d, Message: %s"), message.c_str(), SafeGetIPAddress().c_str(), GetSessionID(), error.value(), String(error.message()).c_str());
    LOG_DEBUG(formattedMessage);
 }
コード例 #6
0
ファイル: urlpreview.cpp プロジェクト: OSUser/avbot
	// boost::asio::async_read 回调.
	void operator()( const boost::system::error_code &ec, int bytes_transferred )
	{
		bool try_http_redirect = false;
		if( ec && (ec != boost::asio::error::eof ))
		{
			m_sender( boost::str( boost::format("@%s, 获取url有错 %s") % m_speaker % ec.message() ) );
			return;
		}

		m_html_page->append_partial_html(std::string( &(*m_content)[0], bytes_transferred));

		// 解析 <title>
		auto title = (*m_html_page)["title"].to_plain_text();

		if (title.empty() && !ec)
		{
			m_httpstream->async_read_some(boost::asio::buffer(*m_content, 512), *this);
			return;
		}else if (ec ==  boost::asio::error::eof)
		{
			try_http_redirect = true;
			return;
		}

		// 获取charset
		auto charset = (*m_html_page).charset();

		if(!try_http_redirect)
		{
			try
			{
				if( charset != "utf8" && charset != "utf" && charset != "utf-8" )
				{
					title = boost::locale::conv::between( title, "UTF-8", charset );
				}

				boost::trim( title );

				title = html_unescape(title);
				// 将 &bnp 这种反格式化.
				m_sender( boost::str( boost::format("@%s ⇪ 标题: %s ") % m_speaker % title ) );
			}
			catch( const std::runtime_error & )
			{
				m_sender( boost::str( boost::format("@%s ⇪ 解码网页发生错误 ") % m_speaker ) );
			}
		}
		else
		{
			// 解析是不是 html 重定向

			auto dom_page = (*m_html_page)["meta [http-equiv][content][url]"];

			auto cd = dom_page.get_children();

			if (!cd.empty())
			{
				auto url = cd[0]->get_attr("url");

				if (m_redirect < 10  && !url.empty())
				{
					urlpreview(io_service, m_sender, m_speaker, url, m_redirect + 1);
				}else
				{
					m_sender( boost::str( boost::format("@%s ⇪ url 无标题 ") % m_speaker ) );
				}
			}else
			{
				// 还是没有 title ?
				m_sender( boost::str( boost::format("@%s, 获取url有错 %s") % m_speaker % ec.message() ) );
			}
		}
	}
コード例 #7
0
ファイル: visapp.cpp プロジェクト: yaroslav-tarasov/test_osg
 void on_disconnected(boost::system::error_code const& ec, uint32_t sock_id)
 {  
     LogInfo("Client " << sock_id << " disconnected with error: " << ec.message() );
     sockets_.erase(sock_id);
     // peers_.erase(std::find_if(peers_.begin(), peers_.end(), [sock_id](std::pair<id_type, uint32_t> p) { return p.second == sock_id; }));
 }
コード例 #8
0
ファイル: SapConnection.cpp プロジェクト: victorzjl/BPE
void CSapConnection::HandleRead(const boost::system::error_code& err,std::size_t dwTransferred)
{
    SS_XLOG(XLOG_DEBUG,"CSapConnection::%s,id[%d],bytes_transferred[%d]\n",__FUNCTION__,m_nId,dwTransferred);
    if(!err)
    {
        gettimeofday_a(&m_AlivePoint,NULL);
        buffer_.inc_loc(dwTransferred);
        while(buffer_.top()>=m_pHeader+sizeof(SSapMsgHeader))
        {
            SSapMsgHeader *ptrHeader=(SSapMsgHeader *)m_pHeader;
            unsigned int packetlen=ntohl(ptrHeader->dwPacketLen);
            if(packetlen<=MAX_SAP_PAKET_LEN&&packetlen>0&&(ptrHeader->byIdentifer==SAP_PACKET_REQUEST||ptrHeader->byIdentifer==SAP_PACKET_RESPONSE))
            {
                if(buffer_.top()>=m_pHeader+packetlen)
                {
                    ReadPacketCompleted(m_pHeader,packetlen);
                    m_pHeader+=packetlen;
                }
                else
                {
                    break;
                }
            }
            else
            {
                SS_XLOG(XLOG_WARNING,"CSapConnection::%s,id[%d],packetlen[%d],identifier[%d], will close this socket\n",__FUNCTION__,m_nId,packetlen,ptrHeader->byIdentifer);
              	StopConnection();
                return;
            }
        }
        if(m_pHeader!=buffer_.base())
        {
            memmove(buffer_.base(),m_pHeader,buffer_.top()-m_pHeader);
            buffer_.reset_loc(buffer_.top()-m_pHeader);
            m_pHeader=buffer_.base();
        }
        else if(buffer_.capacity()==0)
        {
	    	m_pHeader=buffer_.base();
	    	SSapMsgHeader *ptrHeader=(SSapMsgHeader *)m_pHeader;
            unsigned int packetlen=ntohl(ptrHeader->dwPacketLen);
            buffer_.add_capacity(SAP_ALIGN(packetlen));
            m_pHeader=buffer_.base();
        }
        m_socket.async_read_some(boost::asio::buffer(buffer_.top(),buffer_.capacity()),
           MakeSapAllocHandler(m_allocReader,boost::bind(&CSapConnection::HandleRead, shared_from_this(),
                boost::asio::placeholders::error,boost::asio::placeholders::bytes_transferred)));
    }
    else
    {
        SS_SLOG(XLOG_WARNING,"CSapConnection::"<<__FUNCTION__<<",id["<<m_nId<<"],error:" <<err.message()<<"\n");
        StopConnection();
    }
}
コード例 #9
0
ファイル: SapConnection.cpp プロジェクト: victorzjl/BPE
void CSapConnection::HandleWrite(const boost::system::error_code& err)
{
    SS_XLOG(XLOG_DEBUG,"CSapConnection::%s,id[%d]\n",__FUNCTION__,m_nId);
    SSapMsgHeader *pHeader=NULL;
    unsigned int dwServiceId=0;
    unsigned int dwMsgId=0;
    if(err)
    {
        SS_SLOG(XLOG_WARNING,"CSapConnection::"<<__FUNCTION__<<",id["<<m_nId<<"],error:" <<err.message()<<"\n");
        while(!m_queue.empty())
        {
            SSapMsgHeader *pHeader=(SSapMsgHeader *)(m_queue.front().pBuffer);
            unsigned int dwServiceId=ntohl(pHeader->dwServiceId);
            unsigned int dwMsgId=ntohl(pHeader->dwMsgId);
            if(!(dwServiceId==0&&dwMsgId==0))
            {
                if(pHeader->byIdentifer==SAP_PACKET_REQUEST && m_pSession!=NULL)
                {
                    SSapMsgHeader stSendFailResponse;
                    stSendFailResponse.byIdentifer=SAP_PACKET_RESPONSE;
                    stSendFailResponse.byHeadLen=sizeof(SSapMsgHeader);
                    stSendFailResponse.dwPacketLen=htonl(sizeof(SSapMsgHeader));
                    stSendFailResponse.byVersion=0x1;
                    stSendFailResponse.dwCode=htonl(ERROR_SOS_SEND_FAIL);
            
                    stSendFailResponse.dwServiceId=pHeader->dwServiceId;
                    stSendFailResponse.dwMsgId=pHeader->dwMsgId;
                    stSendFailResponse.dwSequence=pHeader->dwSequence;
                    m_pSession->OnReceiveSosAvenueResponse(m_nId,&stSendFailResponse,sizeof(stSendFailResponse),m_strRemoteIp,m_dwRemotePort);
                }
                free((void *)(m_queue.front().pBuffer));
            }
            m_queue.pop_front();
			m_nQueueLen--;
        }
        HandleStop();
        return;
    }
    
    pHeader=(SSapMsgHeader *)(m_queue.front().pBuffer);
    dwServiceId=ntohl(pHeader->dwServiceId);
    dwMsgId=ntohl(pHeader->dwMsgId);
    if(!(dwServiceId==0&&dwMsgId==0))
    {
        free((void *)(m_queue.front().pBuffer));
    }
    
    m_queue.pop_front();
	m_nQueueLen--;
    if (!m_queue.empty())
    {
        boost::asio::async_write(m_socket,
              boost::asio::buffer(m_queue.front().pBuffer,m_queue.front().nLen),
              MakeSapAllocHandler(m_allocWrite,boost::bind(&CSapConnection::HandleWrite, shared_from_this(),
                boost::asio::placeholders::error)));
    }
}
コード例 #10
0
ファイル: ssl_connection.cpp プロジェクト: jkells/nscp
		void ssl_connection::handle_handshake(const boost::system::error_code& error) {
			if (!error)
				connection::start();
			else {
				handler_->log_error(__FILE__, __LINE__, _T("Failed to establish secure connection: ") + to_wstring(error.message()));
				//ConnectionManager_.stop(shared_from_this());
			}
		}
コード例 #11
0
ファイル: connection.cpp プロジェクト: Ziemin/sp2p
void Connection::handle_read(const boost::system::error_code& e,
                             std::size_t bytes_transferred)
{
    if (!e)
    {
#ifdef DEBUG_LOGGING
        BOOST_LOG_TRIVIAL(debug) << "in handle read with no error";
#endif

        boost::tribool result;
        result = requestParser->parse(request_.get(), buffer_.data(), bytes_transferred);

        if (result)
        {
#ifdef DEBUG_LOGGING
            BOOST_LOG_TRIVIAL(debug) << "in result";
#endif
            reply_ = Response_ptr(factory->produceResponse());
            requestHandler->handleRequest(request_.get(), reply_.get());
            std::ostream ostream(&outBuff);
            reply_->parseIntoOstream(&ostream);
#ifdef DEBUG_LOGGING
            BOOST_LOG_TRIVIAL(debug) << "Sending reply to: " << socket().remote_endpoint().address().to_string()
                                     << " size: " << reply_->getSize() << " status: " << reply_->status();
#endif
            boost::asio::async_write(socket_, outBuff,
                                     strand_.wrap(
                                         boost::bind(&Connection::handle_write, shared_from_this(),
                                                     boost::asio::placeholders::error)));
        }
        else if (!result)
        {
#ifdef DEBUG_LOGGING
            BOOST_LOG_TRIVIAL(debug) << "in not result";
#endif
#ifdef DEBUG_LOGGING
            BOOST_LOG_TRIVIAL(debug) << "Result not parsed";
#endif
            reply_ = Response_ptr(factory->produceResponse());
            requestHandler->badRequestResponse(reply_.get());
            std::ostream ostream(&outBuff);
            reply_->parseIntoOstream(&ostream);
            boost::asio::async_write(socket_, outBuff,
                                     strand_.wrap(
                                         boost::bind(&Connection::handle_write, shared_from_this(),
                                                     boost::asio::placeholders::error)));
        }
        else
        {
#ifdef DEBUG_LOGGING
            BOOST_LOG_TRIVIAL(debug) << "in else";
#endif

            socket_.async_read_some(boost::asio::buffer(buffer_), strand_.wrap(
                                        boost::bind(&Connection::handle_read, shared_from_this(),
                                                    boost::asio::placeholders::error,
                                                    boost::asio::placeholders::bytes_transferred)));
        }
    }
    else {
#ifdef DEBUG_LOGGING
            BOOST_LOG_TRIVIAL(debug) << "Error in handle_read: " << e.message();
#endif
    }
}
コード例 #12
0
//----------------------------------------------------------------------------------
void TNetControlTCP::SendEvent(const boost::system::error_code& error,size_t bytes_transferred)
{
  if(error)
    GetLogger(STR_NAME_NET_TRANSPORT)->
      WriteF_time("SendEvent TCP error=%s.\n",error.message().data());
}
コード例 #13
0
void Acceptor::HandleAccept(int reference, boost::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::system::error_code& error) {
	LogDebug("Acceptor::HandleAccept (%p) (id:%u) (new socket %p)", this, m_acceptorId, socket.get());
	lua_State* L = LuaNode::GetLuaVM();
	lua_rawgeti(L, LUA_REGISTRYINDEX, reference);
	luaL_unref(L, LUA_REGISTRYINDEX, reference);

	lua_getfield(L, 1, "callback");
	assert(lua_type(L, -1) == LUA_TFUNCTION); //An acceptor must have a callback"

	if(!error) {
		// Get the remote endpoint, dealing with the case the connection is already closed when we get here.
		boost::system::error_code ec;
		const boost::asio::ip::tcp::endpoint& endpoint = socket->remote_endpoint(ec);
		if(ec) {
			if(ec == boost::asio::error::not_connected) {
				LogWarning("Acceptor::HandleAccept (%p) (id:%u) (new socket %p) - Socket was already closed when accepted. %s", 
					this, m_acceptorId, socket.get(), ec.message().c_str());
			}
			else {
				LogWarning("Acceptor::HandleAccept (%p) (id:%u) (new socket %p) - Error retrieving remote endpoint. %s", 
					this, m_acceptorId, socket.get(), ec.message().c_str());
			}
			LogInfo("Acceptor::HandleAccept - Retrying accept operation");
			lua_settop(L, 1);	// leave only 'self' on the stack
			Accept(L);
			return;
		}

		boost::asio::ip::address address = endpoint.address();
		
		lua_pushnil(L);
		lua_newtable(L);
		int peer = lua_gettop(L);

		lua_pushstring(L, "socket");
		Socket* luasocket = new Socket(L, socket);
		Socket::push(L, luasocket, true);	// now Socket is the owner
		lua_rawset(L, peer);

		const std::string& sAddress = address.to_string();
		lua_pushstring(L, "address");
		lua_pushlstring(L, sAddress.c_str(), sAddress.length());
		lua_rawset(L, peer);

		lua_pushstring(L, "port");
		lua_pushnumber(L, endpoint.port());
		lua_rawset(L, peer);

		LuaNode::GetLuaVM().call(2, LUA_MULTRET);
	}
	else {
		if(error != boost::asio::error::operation_aborted) {
			LogError("Acceptor::HandleAccept (%p) (id:%u) (new socket %p) - %s", this, m_acceptorId, socket.get(), error.message().c_str());
		}

		int ret = BoostErrorToCallback(L, error);
		LuaNode::GetLuaVM().call(ret, LUA_MULTRET);
	}
	lua_settop(L, 0);
}
コード例 #14
0
void SIPWebSocketConnection::handleRead(const boost::system::error_code& e, std::size_t bytes_transferred, OSS_HANDLE userData)
    /// Handle completion of a read operation.
{
	if (e || bytes_transferred <=0)
	{
		OSS_LOG_DEBUG("SIPWebSocketConnection::handleRead Exception " << e.message());

		if (++_readExceptionCount >= 5)
		{
			OSS_LOG_ERROR("SIPWebSocketConnection::handleRead has reached maximum exception count.  Bailing out.");
			boost::system::error_code ignored_ec;

			_connectionManager.stop(shared_from_this());
		}
	}

	OSS_LOG_DEBUG("SIPWebSocketConnection::handleRead STARTING new connection");
	std::string* buffer = reinterpret_cast<std::string*>(userData);

	//
	// set the last read address
	//
	if (!_lastReadAddress.isValid())
	{
		boost::system::error_code ec;

		EndPoint ep = _pServerConnection->get_raw_socket().remote_endpoint(ec);
		if (!ec)
		{
			boost::asio::ip::address ip = ep.address();
			_lastReadAddress = OSS::Net::IPAddress(ip.to_string(), ep.port());
		}
		else
		{
			OSS_LOG_WARNING("SIPWebSocketConnection::handleRead() Exception " << ec.message());
		}
	}

	//
	// Reset the read exception count
	//
	_readExceptionCount = 0;

	_bytesRead =  bytes_transferred;
	if (!_pRequest)
	{
		_pRequest = SIPMessage::Ptr(new SIPMessage());
	}

	boost::tribool result;
	const char* begin = buffer->data();
	const char* end = buffer->data() + bytes_transferred;

	boost::tuple<boost::tribool, const char*> ret =  _pRequest->consume(begin, end);
	result = ret.get<0>();
	const char* tail = ret.get<1>();

	if (result)
	{
		//
		// Message has been read in full
		//
		dispatchMessage(_pRequest->shared_from_this(), shared_from_this());
		if (tail >= end)
		{
			//
			// The end of the SIPMessage is reached so we can simply reset the
			// request buffer and start the read operation all over again
			//
			_pRequest.reset();

			//
			// We are done
			//
			return;
		}
		else
		{
			//
			// This should not happen as there is one full message per read.
			// The tail is within the range of the end of the read buffer.
			//
			OSS_ASSERT(false);
		}
	}
	else if (!result)
	{
		_pRequest.reset();
	}
	else
	{
		//
		// This should not happen as there is one full message per read.
		// Partial message?
		//
		OSS_ASSERT(false);
	}
}
コード例 #15
0
// Report a failure
void
fail(boost::system::error_code ec, char const* what)
{
    std::cerr << what << ": " << ec.message() << "\n";
}
コード例 #16
0
ファイル: SapConnection.cpp プロジェクト: victorzjl/BPE
void CSapConnection::HandleResolve(const boost::system::error_code& err,tcp::resolver::iterator endpoint_iterator,unsigned int dwLocalPort)
{
    if (!err)
    {
        if(dwLocalPort!=0)
        {
            boost::system::error_code ec;
            m_socket.open(tcp::v4(),ec);
            if(ec)
            {
                SS_SLOG(XLOG_WARNING,"CSapConnection::"<<__FUNCTION__<<",id["<<m_nId<<"],open socket error:" <<ec.message()<<"\n");
                ConnectFinish(-1);
                return;
            }
			m_socket.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true),ec);
			m_socket.set_option(boost::asio::ip::tcp::no_delay(true),ec);
            m_socket.bind(tcp::endpoint(tcp::v4(),dwLocalPort),ec);
            if(ec)
            {
                SS_SLOG(XLOG_WARNING,"CSapConnection::"<<__FUNCTION__<<",id["<<m_nId<<"],bind port error:" <<ec.message()<<"\n");
                ConnectFinish(-1);
                return;
            }
        }
        tcp::endpoint endpoint = *endpoint_iterator;
        SS_XLOG(XLOG_DEBUG,"CSapConnection::%s,id[%d],addr[%s:%d]\n",__FUNCTION__,m_nId,endpoint.address().to_string() .c_str() ,endpoint.port());
        m_socket.async_connect(endpoint,
            MakeSapAllocHandler(m_allocReader, boost::bind(&CSapConnection::HandleConnected, shared_from_this(),
            	boost::asio::placeholders::error, ++endpoint_iterator)));
    }
    else
    {
      SS_SLOG(XLOG_WARNING,"CSapConnection::"<<__FUNCTION__<<",id["<<m_nId<<"],error:" <<err.message()<<"\n");
      ConnectFinish(-2);
    }
}
コード例 #17
0
ファイル: client.cpp プロジェクト: BillTheBest/freelan-all
static void on_hello_response(const std::string& name, fscp::server& server, const fscp::server::ep_type& sender, const boost::system::error_code& ec, const boost::posix_time::time_duration& duration)
{
	mutex::scoped_lock lock(output_mutex);

	if (ec)
	{
		std::cout << "[" << name << "] Received no HELLO response from " << sender << " after " << duration << ": " << ec.message() << std::endl;
	}
	else
	{
		std::cout << "[" << name << "] Received HELLO response from " << sender << " after " << duration << ": " << ec.message() << std::endl;

		server.async_introduce_to(sender, boost::bind(&simple_handler, name, "async_introduce_to()", _1));

		std::cout << "[" << name << "] Sending a presentation message to " << sender << std::endl;
	}
}
コード例 #18
0
ファイル: SapConnection.cpp プロジェクト: victorzjl/BPE
void CSapConnection::HandleConnected(const boost::system::error_code& err,tcp::resolver::iterator endpoint_iterator)
{
    SS_XLOG(XLOG_DEBUG,"CSapConnection::%s,id[%d]\n",__FUNCTION__,m_nId);
    if (!err)
    {
        gettimeofday_a(&m_HeartBeatPoint,NULL);
        gettimeofday_a(&m_AlivePoint,NULL);
        ConnectFinish(0);
        m_isConnected=true;
        SetRemoteAddr();
		
        AsyncRead();
    }
    else if (endpoint_iterator != tcp::resolver::iterator())
    {
      boost::system::error_code ignore_ec;
      m_socket.close(ignore_ec);
      tcp::endpoint endpoint = *endpoint_iterator;
      m_socket.async_connect(endpoint,
          MakeSapAllocHandler(m_allocReader,boost::bind(&CSapConnection::HandleConnected, shared_from_this(),
            boost::asio::placeholders::error, ++endpoint_iterator)));
    }
    else
    {
        //SS_SLOG(XLOG_WARNING,"CSapConnection::"<<__FUNCTION__<<",id["<<m_nId<<"],addr[], error:" <<err.message()<<"\n");
		SS_XLOG(XLOG_WARNING,"CSapConnection::%s, id[%d],  error:%s\n",	__FUNCTION__,m_nId,(err.message()).c_str());
        ConnectFinish(-3);
    }
}
コード例 #19
0
ファイル: local_fwd.cpp プロジェクト: condy0919/ACProxy
void LocalForwarder::getHeadersHandle(const boost::system::error_code& e) {
    if (e) {
        LOG_ACPROXY_ERROR("get http request header error ", e.message());
        //conn_->close();
        return;
    }

    LOG_ACPROXY_INFO("start reading http request headers...");

    char buf[1024];  // XXX

    auto fd = socket_->native_handle();
    ssize_t sz = ::recv(fd, buf, sizeof(buf), MSG_PEEK);
    LOG_ACPROXY_DEBUG("sz of read http request header = ", sz);
    if (sz < 0) {
        const int err = errno;
        if (err == EAGAIN || err == EWOULDBLOCK) {
            LOG_ACPROXY_INFO("read http request header again...");
            getHeaders();
            return;
        }
        LOG_ACPROXY_INFO("read http request header error");
        //conn_->close();
        return;
    } else if (sz == 0) {
        LOG_ACPROXY_INFO("client close socket");
        //conn_->close();
        return;
    }
    const char* pos = (const char*)::memmem(buf, sz, "\r\n\r\n", 4);

    bool found = pos;
    ssize_t diff = (found ? pos - buf + 4 : sz);
    if (!found) {
        // \r | \n\r\n
        if (headers.size() >= 1 && headers.back() == '\r' && sz >= 3 &&
            buf[0] == '\n' && buf[1] == '\r' && buf[2] == '\n') {
            found = true;
            diff = 3;
        }

        // \r\n | \r\n
        if (headers.size() >= 2 && headers[headers.size() - 2] == '\r' &&
            headers[headers.size() - 1] == '\n' && sz >= 2 && buf[0] == '\r' &&
            buf[1] == '\n') {
            found = true;
            diff = 2;
        }

        // \r\n\r | \n
        if (headers.size() >= 3 && headers[headers.size() - 3] == '\r' &&
            headers[headers.size() - 2] == '\n' &&
            headers[headers.size() - 1] == '\r' && sz >= 1 && buf[0] == '\n') {
            found = true;
            diff = 1;
        }
    }

    // consume
    ::recv(fd, buf, diff, 0);
    headers.insert(headers.end(), buf, buf + diff);
    if (found) {
        Http::RequestHeaderGrammar<decltype(headers)::iterator> grammar;
        bool res = phrase_parse(headers.begin(), headers.end(), grammar,
                                boost::spirit::qi::ascii::blank, request_);
        if (!res) {
            LOG_ACPROXY_ERROR("parse http request header error");
            //conn_->close();
            return;
        }

        request_.rewrite();
        request_.setKeepAlive(false);

        // cache layer
        if (request_.method == "GET" || request_.method == "HEAD") {
            std::string key = keygen(request_.getHost(), request_.getPort(),
                                     request_.uri, request_.method);
            auto& cache = getGlobalCache();
            if (boost::optional<std::string> resp = cache.get(key)) {
                LOG_ACPROXY_INFO("hit, found in cache!");
                finish(resp.value());
                return;
            }
            if (auto c = conn_.lock()) {
                c->getRemoteForwarder()->setCacheKey(key);
            } else {
                LOG_ACPROXY_WARNING("connection object is freed");
                return;
            }
        }

        // LOG_ACPROXY_DEBUG("request = \n", request_.toBuffer());

        if (!request_.hasResponseBody()) {
            if (auto c = conn_.lock()) {
                c->getRemoteForwarder()->setResponseBody(false);
            } else {
                LOG_ACPROXY_WARNING("connection object is freed");
                return;
            }
        }

        std::string host = request_.getHost();
        int port = request_.getPort();
        if (auto c = conn_.lock()) {
            res = c->getRemoteForwarder()->connect(host, port);
        } else {
            LOG_ACPROXY_WARNING("connection object is freed");
            return;
        }
        if (!res) {
            if (auto c = conn_.lock()) {
                c->report("failure", {{"host", boost::asio::ip::host_name()}},
                          std::time(0));
            }
            // XXX Maybe shutdowning socket is better
            LOG_ACPROXY_INFO("connection timeout, close it");
            //send("HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n");
            //conn_->close();
            return;
        }
        LOG_ACPROXY_DEBUG("connection complete");

        if (!request_.isConnectMethod()) {
            // forward header to server
            if (auto c = conn_.lock()) {
                c->getRemoteForwarder()->send(request_.toBuffer());
            } else {
                LOG_ACPROXY_WARNING("connection object is freed");
                return;
            }
        } else {
            // no parse response header, get rawdata and forward instead
            if (auto c = conn_.lock()) {
                c->getRemoteForwarder()->setParseResponseHeader(false);
            } else {
                LOG_ACPROXY_WARNING("connection object is freed");
                return;
            }
            // send a fake 200 response in tunnel mode
            send("HTTP/1.1 200 Connection Established\r\n\r\n");
        }

        if (request_.hasContentBody()) {
            getBody();
        }
    } else {
        // request header is incomplete, read again
        LOG_ACPROXY_INFO("http request header incomplete, read again");
        getHeaders();
    }
    if (auto c = conn_.lock()) {
        c->update();
    } else {
        LOG_ACPROXY_WARNING("connection object is freed");
        return;
    }
}
コード例 #20
0
ファイル: async_http.cpp プロジェクト: xyliuke/plan9
    static void event_callback(void* data, std::shared_ptr<socket_info> tcp_socket, curl_socket_t curl_socket, CURL* curl, int action, const boost::system::error_code &err) {
        asyn_http_object* aho = (asyn_http_object*)data;

        if (err) {
            log_wrap::net().e("function : ", __FUNCTION__, ", socket : ", curl_socket, ", action : ", action, " error : ", err.message());
            CURLMcode code = curl_multi_socket_action(aho->curlm, tcp_socket->socket.native_handle(), CURL_CSELECT_ERR, &aho->still_running);
        } else {
            CURLMcode code = curl_multi_socket_action(aho->curlm, tcp_socket->socket.native_handle(), action, &aho->still_running);
        }

        check_multi_curl(data);

        if (aho->still_running <= 0) {
            timer.cancel();
        } else {
            int action_continue = (tcp_socket->mask) & action;
            if (action_continue) {
                set_socket(tcp_socket, curl_socket, curl, action_continue, data);
            }
        }
    }
コード例 #21
0
ファイル: visapp.cpp プロジェクト: yaroslav-tarasov/test_osg
 void on_error(boost::system::error_code const& ec, uint32_t sock_id)
 {
     LogError("TCP error: " << ec.message());
     sockets_.erase(sock_id);
     // peers_.erase(std::find_if(peers_.begin(), peers_.end(), [sock_id](std::pair<id_type, uint32_t> p) { return p.second == sock_id; }));
 }
コード例 #22
0
 void MergeDispatcher::handle_buffer(
     boost::system::error_code const & ec)
 {
     LOG_DEBUG("[handle_buffer] ec:"<<ec.message());
     response(ec);
 }
コード例 #23
0
   void
   TCPConnection::HandshakeFailed_(const boost::system::error_code& error)
   {
      // The SSL handshake failed. This may happen for example if the user who has connected
      // to the TCP/IP port disconnects immediately without sending any data.
      String sMessage;
      sMessage.Format(_T("TCPConnection - TLS/SSL handshake failed. Session Id: %d, Remote IP: %s, Error code: %d, Message: %s"), session_id_, SafeGetIPAddress().c_str(), error.value(), String(error.message()).c_str());
      LOG_TCPIP(sMessage);

      OnHandshakeFailed();
   }
コード例 #24
0
ファイル: logic_server.cpp プロジェクト: hcqmaker/simple_game
	void onErrorServerHandle(IServer *server, const boost::system::error_code& error)
	{
		long serverId = server->getId();
		NetLib::instance().destroyServer(serverId);
		sLog.outError("server error serverId:%ld error:%s \n", serverId, error.message().c_str());
	}
コード例 #25
0
	void WebSocket::_async_read( usr_ptr u, char* request, const boost::system::error_code& error, size_t bytes_transferred )
	{
		if( !error )
		{
			if( u->handshaken )
			{ // bitch has handshaken. Lets process him :)
				size_t start = 0;
				size_t offset = 0;
				
				while( offset < bytes_transferred )
				offset += u->ftype->unpackFrame( (unsigned char*)(request + offset), bytes_transferred - offset );
				if( u->ftype->disconnect( ) )
				{
					log( "Request from client " + itoa( u->uid ) + " to disconnect" );
					
					_disconnect( u );
					delete[ ] request;
					
					return;
				}
				else
				{
					std::string response;
					std::string req = u->ftype->data( );
					
					size_t b;
					switch( _processable->process( req, response ) )
					{
					case RESPOND:
						unsigned char* frame;
						b = u->ftype->packFrame( response, frame, false );
						_async_send( u, std::string( (char*)frame, b ) );
						delete[ ] frame;
					
						break;
					case BROADCAST:
						_async_broadcast( response );
						break;
					default:
						break;
					}
				}
				
				// std::cout << "Frames in request: " << framecount << std::endl;
			}
			else
			{// lets shake hands, mr client
				log( "Handshaking with client " + itoa( u->uid ) );
				_handshake( u, std::string( request, bytes_transferred ) );
			}
		
			// request = new char[ _maxBytes ];
			u->sock->async_receive( boost::asio::buffer( request, _maxBytes ), boost::bind( &WebSocket::_async_read, this, u, request, _1, _2 ) );
		}
		else if( error == boost::asio::error::eof )
		{
			delete[ ] request;
			
			log( "Client " + itoa( u->uid ) + " closed the connection (eof)." );
			// u->sock->close( );
			_disconnect( u );
		}
		else
		{
			delete[ ] request;
			log( "Error: " + error.message( ) );
		}
	}
コード例 #26
0
ファイル: logic_server.cpp プロジェクト: hcqmaker/simple_game
	void onErrorClientHandle(IClient *client, const boost::system::error_code& error)
	{
		long clientId = client->getId();
		NetLib::instance().destroyClient(clientId);
		sLog.outError("client error clientId:%ld error:%s \n", clientId, error.message().c_str());
	}
コード例 #27
0
ファイル: c_tun_device.cpp プロジェクト: tigusoft/galaxy42
void c_tun_device_apple::handle_read(const boost::system::error_code &error, size_t length) {
    if (error || (length < 1))
        throw std::runtime_error("TUN read error, length = " + std::to_string(length) + " error message: " + error.message());
    m_readed_bytes = length;
    // continue reading
    m_stream_handle_ptr->async_read_some(boost::asio::buffer(m_buffer),
                                         [this](const boost::system::error_code &error, size_t length) {
        handle_read(error, length);
    }); // lambda
}
コード例 #28
0
void ServerNetworkComm::callback_read( TCPConnection::Ptr conn,
                                       const boost::system::error_code & error )
{
  if( !error )
  {
    std::string error_msg;
    ClientInfo& info = m_clients[conn];
    SignalFrame & buffer = info.buffer;

    std::string target = buffer.node.attribute_value( "target" );
    std::string receiver = buffer.node.attribute_value( "receiver" );
    std::string clientid = buffer.node.attribute_value( "clientid" );
    std::string frameid = buffer.node.attribute_value( "frameid" );

    // check if the client is attempting to register
    if( target == "client_registration" )
    {
      if( !info.uuid.empty() )
        error_msg = "This client has already been registered.";
      else
      {
        info.uuid = clientid;

        // Build and send the reply
        SignalFrame reply = buffer.create_reply();
        SignalOptions & roptions = reply.options();

        roptions.add("accepted", true);
        roptions.flush();

        this->init_send(conn, buffer );

        // tell listeners a new client has arrived
        SignalFrame frame("new_client_connected", "cpath:/", "cpath:/");
        frame.options().add( "clientid", clientid );
        call_signal( "new_client_connected", frame );
      }
    }
    else
    {
      if( info.uuid.empty() )
        error_msg = "The signal came from an unregistered client.";
      else if( info.uuid != clientid )
        error_msg = "The client id '" + info.uuid + "' (used for registration) "
            + "and '" + clientid + "' (used for identification) do not match.";
      else
        ServerRoot::instance().process_signal(target, receiver, clientid, frameid, buffer);
    }

    if( !error_msg.empty() )
      this->send_frame_rejected( conn, frameid, SERVER_CORE_PATH, error_msg );

    init_read( info );
  }
  else if( error != boost::asio::error::eof )
    CFerror << "Could not read from [" << conn->socket().remote_endpoint()
            << "]: " << error.message() << CFendl;

  if( error )
  {
    std::string uuid = m_clients[conn].uuid;
    conn->disconnect();
    m_clients.erase( conn );

    if( error == boost::asio::error::eof )
      CFinfo << "Cliemt [" << uuid << "] has disconnected. ("
             << m_clients.size() << " left)." << CFendl;
  }

}
コード例 #29
0
ファイル: NetServer.cpp プロジェクト: hcqmaker/simple_game
	//-------------------------------------------------------------
	//
	void NetServer::onErrorHandle(ISessionPtr session, const boost::system::error_code& error)
	{
		uint64 sessionId = session->getId();
		this->closeSession(sessionId);
		sLog.outError("session error session:%lld server:%lld error:%s \n", sessionId, this->m_nId, error.message().c_str());
	}
コード例 #30
0
ファイル: smtptest.cpp プロジェクト: HackLinux/avbot
static void sended( const boost::system::error_code & ec )
{
	std::cout <<  ec.message() <<  std::endl;
}