void debugmodel::OnBnClickedButton4()
{
// TODO: 获取状态
char data[] = "1234567";
data[0] = ADDFIRST;
data[2] = ADDEND;
CString tmp;
m_garage_id.GetWindowText(tmp);
if (tmp == "")
return;
data[1] = _wtoi(tmp.GetBuffer(0));
data[3] = GETSTATE;
//m_row.GetWindowText(tmp);
data[4] = 0;// _wtoi(tmp.GetBuffer(0));
//m_col.GetWindowText(tmp);
data[5] = 0;// _wtoi(tmp.GetBuffer(0));
data[6] = (data[1] + data[3] + data[4] + data[5]) % CHECKMOD;
TESTPUTSEND
OnSend(data, 7);
Sleep(100);
memset(recstr, '\0', COMLEN);
OnReceive(recstr, 4);
TESTPUTRECN
//putinfo(recstr);
switch (recstr[1])
{
case STATEFREE:
m_state.SetWindowTextW(_T("空闲"));
break;
case STATESAVE:
m_state.SetWindowTextW(_T("存车"));
break;
case STATEDELETE:
m_state.SetWindowTextW(_T("取车"));
break;
case STATESTOP:
m_state.SetWindowTextW(_T("停止"));
break;
case STATERSET:
m_state.SetWindowTextW(_T("复位"));
break;
case ACCEPTED:
m_state.SetWindowTextW(_T("已接收"));
break;
case BUSY:
m_state.SetWindowTextW(_T("运行中"));
break;
default:
m_state.SetWindowTextW(_T("未知"));
}
}
void CRealControlSocket::OnSocketEvent(wxSocketEvent &event)
{
if (!m_pBackend)
return;
if (event.GetId() != m_pBackend->GetId())
return;
switch (event.GetSocketEvent())
{
case wxSOCKET_CONNECTION:
m_onConnectCalled = true;
OnConnect();
break;
case wxSOCKET_INPUT:
if (!m_onConnectCalled)
{
m_onConnectCalled = true;
OnConnect();
}
OnReceive();
break;
case wxSOCKET_OUTPUT:
OnSend();
break;
case wxSOCKET_LOST:
OnClose();
break;
}
}
void hublistcollector::OnReceive(int error_code)
{
//error checking
if(error_code!=0)
{
p_dlg->StatusUpdate("Error Receiving Data");
}
if(m_receiving_socket_data || m_receiving_some_socket_data)
{
ContinueToReceiveSocketData();
return;
}
ReceiveSomeSocketData(1516);
char buf[1];
memset(buf,0,sizeof(buf));
WSABUF wsabuf;
wsabuf.buf=buf;
wsabuf.len=1;
DWORD num_read=0;
DWORD flags=MSG_PEEK;
int ret=WSARecv(m_hSocket,&wsabuf,1,&num_read,&flags,NULL,NULL);
if(ret!=SOCKET_ERROR)
{
if(num_read!=0)
{
OnReceive(0); // recursive call
}
}
}
int main()
{
{
//The Qt way
QtEmitter e;
QtReceiver r;
QObject::connect(&e,SIGNAL(signal_emit()),&r,SLOT(OnReceive()));
e.DoEmit();
}
{
//The Boost way
//Create the emitter and receiver
Emitter e;
Receiver r;
//The emitter is not yet connected to a receiver/slot
assert(e.m_signal.num_slots() == 0);
//Connect the emitter to a receiver/slot
e.m_signal.connect(
boost::bind(
&Receiver::OnReceive,r //Don't forget to put placeholders here (e.g. _1 ) if the signal have additional arguments
)
);
//The emitter is now connected to a receiver/slot
assert(e.m_signal.num_slots() == 1);
//Make the magic happen: the emitter puts out a signal and -unknown to it- the receiver responds
e.DoEmit();
}
assert(1==2);
}
void Session::handle_receive( const boost::system::error_code& error, size_t bytes_transferred )
{
if( error )
{
if( error == boost::asio::error::eof )
{
std::cout << "클라이언트와 연결이 끊어졌습니다" << std::endl;
}
else
{
std::cout << "error No: " << error.value() << " error Message: " << error.message() << std::endl;
}
_SessionDesc desc;
desc.sessionType = 0;
desc.identifier = 1;
m_pServer->CloseSession( m_nSessionID );
OnDisconnect(m_nSessionID, desc);
}
else
{
_SessionDesc desc;
desc.sessionType = 0;
desc.identifier = 1;
if (false == OnReceive(m_ReceiveBuffer.data(), bytes_transferred, desc))
{
//강제로 끊게 하는 메소드는?
}
PostReceive();
}
}
void NetClientPoll(NetClient *n)
{
if (!n->client || !n->peer)
{
return;
}
// Service the connection
int check;
do
{
ENetEvent event;
check = enet_host_service(n->client, &event, 0);
if (check < 0)
{
printf("Connection error %d\n", check);
return;
}
else if (check > 0)
{
switch (event.type)
{
case ENET_EVENT_TYPE_RECEIVE:
OnReceive(n, event);
break;
default:
printf("Unexpected event type %d\n", event.type);
break;
}
}
} while (check > 0);
}
/**
* Application must call this if a WM_ is coming from network.
*/
HRESULT ACWinSock::MsgProc(WPARAM wp, LPARAM lp)
{
WORD wEvent, wError;
// get data
wError = HIWORD(lp);
wEvent = LOWORD(lp);
// which event
switch (wEvent)
{
// confirmacao depois de uma conexao bem sucedida
case FD_CONNECT: break;
// cliente quer aceitacao
case FD_ACCEPT: { return OnAccept(); } break;
// recebemos algo
case FD_READ: { return OnReceive(wp); } break;
// um cliente ficou offline
case FD_CLOSE: { return OnDisconnect(wp); } break;
// nos mandamos algo?
case FD_WRITE: break;
}
return AC_OK;
};
// NOTE: Since the old WSAAsync functionality has been exchanged in the favor of WSAEvent, I'm not sure if MsgProc will fire correctly
HRESULT ZFXWS::MsgProc( WPARAM wp, LPARAM lp )
{
WORD wEvent, wError;
wError = HIWORD(lp);
wEvent = LOWORD(lp);
//evaluate what event occurred
switch ( wEvent )
{
//new client accepted
case FD_CONNECT:
break;
//new client is knocking
case FD_ACCEPT:
return OnAccept();
break;
//there is data to be received
case FD_READ:
return OnReceive(wp);
break;
//a socket is closing
case FD_CLOSE:
return OnDisconnect(wp);
break;
//after sending data
case FD_WRITE:
break;
}
return ZFX_OK;
}
void CExternalIpCheck::OnConnect(int nErrorCode)
{
if (!m_bActive)
return;
if (nErrorCode)
{
m_bActive = FALSE;
Close();
m_nRetryCount++;
return;
}
CStdStringA address = "GET " + m_pOwner->m_pOptions->GetOption(OPTION_CUSTOMPASVIPSERVER) + " HTTP/1.0\r\nUser-Agent: FileZilla Server\r\n\r\n";
const char *buffer = address;
int len = strlen(buffer);
if (Send(buffer, len) != len)
{
m_bActive = FALSE;
Close();
m_nRetryCount++;
}
OnReceive(0);
}
void CExternalIPResolver::OnSend()
{
while (m_pSendBuffer)
{
unsigned int len = strlen(m_pSendBuffer + m_sendBufferPos);
int error;
int written = m_pSocket->Write(m_pSendBuffer + m_sendBufferPos, len, error);
if (written == -1)
{
if (error != EAGAIN)
Close(false);
return;
}
if (!written)
{
Close(false);
return;
}
if (written == (int)len)
{
delete [] m_pSendBuffer;
m_pSendBuffer = 0;
OnReceive();
}
else
m_sendBufferPos += written;
}
}
Client::Client(QObject *parent) : QObject(parent)
{
socket = new QTcpSocket(this);
connect(this->socket, SIGNAL(readyRead()),this, SLOT(OnReceive()));
m_hostmessref=0;
}
void L2Socket::HandleAccept( tcp::socket& _socket, boost::system::error_code _ec )
{
if (!acceptor->is_open() )
{
LOG( "HandleAccept acceptor !is_open()!!!" );
return ;
}
if( _ec )
{
LOG( "HandleAccept error: "+ _ec.message() );
Disconnect(_socket);
return;
}
LOG( "HandleAccept New Connect ip: "+_socket.remote_endpoint().address().to_string() + " port: " + _socket.remote_endpoint().port());
//tcp::no_delay option(true);
//_socket.set_option(option);
shared_ptr<L2Actor> _act = L2_GET_UNUSED_OBJ(L2Actor);
SERVER->PushActor( _act->OID );
_act->GetAgent()->SetConnect(true);
sockAry.push_back(&_socket);
agentOIDAry.push_back( _act->GetAgent()->OID );
if( bWebSocket )
OnHandshake(_socket,_act->GetAgent()->OID);
else
OnReceive( _socket,_act->GetAgent()->OID );
//THREAD->ThreadSleepFPS();
OnAccept();
}
void L2Socket::HandleReceive( tcp::socket& _socket, size_t _agentOID, shared_ptr<L2Packet> _pack, boost::system::error_code _ec, size_t _bytes_transferred )
{
if( _ec )
{
LOG( "HandleReceive error: "+ _ec.message() );
Disconnect(_socket,_agentOID);
return;
}
_pack->SetSize(_bytes_transferred);
LOG( "HandleReceive success!!! " );
LOG( "HandleReceive size: "+ _pack->GetSize() );
LOG( "HandleReceive data: "+ _pack->ToString() );
if( bWebSocket )
{
if( !ENCODE->DecodeRFC6455(_pack) )
{
Disconnect(_socket,_agentOID);
return;
}
}
//THREAD->ThreadSleepFPS();
PROTCL->Receive(_agentOID, _pack);
OnReceive( _socket,_agentOID );
//_pack->WriteStart();
//_pack->WriteCChar("123456");
//SendTCP(_agentOID, _pack);
}
HRESULT CClientWizard::DirectPlayMessageHandler(PVOID pvUserContext, DWORD dwMessageID, PVOID pMsgBuffer)
{
HRESULT hr = S_OK;
switch(dwMessageID)
{
case DPN_MSGID_ASYNC_OP_COMPLETE:
hr = OnAsyncOpComplete(pMsgBuffer);
break;
case DPN_MSGID_CONNECT_COMPLETE:
hr = OnConnectComplete(pMsgBuffer);
break;
case DPN_MSGID_ENUM_HOSTS_RESPONSE:
hr = OnHostsResponse(pMsgBuffer);
break;
case DPN_MSGID_TERMINATE_SESSION:
// hr = OnTerminateSession(pMsgBuffer);
break;
case DPN_MSGID_RECEIVE:
OnReceive(pMsgBuffer);
break;
default:
break;
}
return hr;
}
void CEC_LogicalDevice::OnReceiveComplete(unsigned char* buffer, int count)
{
ASSERT(count >= 1);
int sourceAddress = (buffer[0] >> 4) & 0x0f;
int targetAddress = buffer[0] & 0x0f;
OnReceive(sourceAddress, targetAddress, buffer + 1, count - 1);
}
void DCDownload::OnReceive(int error_code)
{
if(error_code!=0)
{
return; //return due to error
}
if(m_receiving_socket_data || m_receiving_some_socket_data)
{
ContinueToReceiveSocketData();
return;
}
ReceiveSomeSocketData(1516);
char buf[1];
memset(buf,0,sizeof(buf));
WSABUF wsabuf;
wsabuf.buf=buf;
wsabuf.len=1;
DWORD num_read=0;
DWORD flags=MSG_PEEK;
int ret=WSARecv(m_hSocket,&wsabuf,1,&num_read,&flags,NULL,NULL);
if(ret!=SOCKET_ERROR)
{
if(num_read!=0)
{
OnReceive(0); // recursive call
}
}
//::AfxMessageBox("Received Message");
}
void CEMSocket::DisableDownloadLimit(){
downloadLimitEnable = false;
// CPU load improvement
if(pendingOnReceive == true){
OnReceive(0);
}
}
//--------------------------------
void esp8266::OnUart(uint32_t ui32Ints) {
if (ui32Ints & UART_INT_TX) {
OnTransmit();
}
if (ui32Ints & (UART_INT_RX | UART_INT_RT)) {
OnReceive();
}
}
void CEMSocket::SetDownloadLimit(uint32 limit){
downloadLimit = limit;
downloadLimitEnable = true;
// CPU load improvement
if(limit > 0 && pendingOnReceive == true){
OnReceive(0);
}
}
void CAsyncSocketExLayer::CallEvent(int nEvent, int nErrorCode)
{
if (m_nCriticalError)
return;
m_nCriticalError=nErrorCode;
switch (nEvent)
{
case FD_READ:
case FD_FORCEREAD:
if (GetLayerState()==connected)
{
if (nErrorCode)
SetLayerState(aborted);
OnReceive(nErrorCode);
}
break;
case FD_WRITE:
if (GetLayerState()==connected)
{
if (nErrorCode)
SetLayerState(aborted);
OnSend(nErrorCode);
}
break;
case FD_CONNECT:
if (GetLayerState()==connecting)
{
if (!nErrorCode)
SetLayerState(connected);
else
SetLayerState(aborted);
OnConnect(nErrorCode);
}
break;
case FD_ACCEPT:
if (GetLayerState()==listening)
{
if (!nErrorCode)
SetLayerState(connected);
else
SetLayerState(aborted);
OnAccept(nErrorCode);
}
break;
case FD_CLOSE:
if (GetLayerState()==connected)
{
if (nErrorCode)
SetLayerState(aborted);
else
SetLayerState(closed);
OnClose(nErrorCode);
}
break;
}
}
void CTransferSocket::OnIOThreadEvent(CIOThreadEvent& event)
{
if (!m_bActive || m_transferEndReason != none)
return;
if (m_transferMode == download)
OnReceive();
else if (m_transferMode == upload)
OnSend();
}
void CRS232::ProcessMsgComEvent(DWORD eventid)
{
switch(eventid)
{
case COM_EVT_RECV:
OnReceive();
break;
}
CCom::ProcessMsgComEvent(eventid);
}
static void rtcp_on_receive(RtspdSession_t* session)
{
int type_of_packet= PACKET_UNKNOWN_TYPE;
int total_packet_size = session->request_sz;
unsigned report_sender_ssrc;
char* pbuf_offset;
//RTSPD_TRACE("RTSP interleaved frame");
//RTSPD_TRACE("magic:0x%x",session->request_buf[0]);
//RTSPD_TRACE("channel:0x%x",session->request_buf[1]);
//RTSPD_TRACE("rtcpbodylen:%d bytes",*((unsigned char*)(session->request_buf+3)) | (*((unsigned char*)(session->request_buf+2)) << 8));
pbuf_offset = session->request_buf +4;
//print_rtcp_header(pbuf_offset);
rtcp_t* const preport= (rtcp_t*)pbuf_offset;
switch(preport->common.pt){
case RTCP_SR:
{
RTSPD_TRACE("RTCP receive senderreport!");
break;
}
case RTCP_RR:
{
RTSPD_TRACE("RTCP receive receiverreport!");
report_sender_ssrc = preport->rr.ssrc;
type_of_packet = PACKET_RTCP_REPORT;
break;
}
case RTCP_BYE:
{
RTSPD_TRACE("RTCP receive byereport!");
type_of_packet = PACKET_BYE;
break;
}
}
session->type_of_packet= type_of_packet;
session->last_received_size= total_packet_size;
session->last_received_ssrc= report_sender_ssrc;
OnReceive(session, // p
session, // e
&session->members, // members
&session->pmembers, // pmembers
&session->senders, // senders
&session->avg_rtcp_size, // avg_rtcp_size
&session->prev_report_time, // tp
dTimeNow(), // tc
session->next_report_time);
}
void CEMSocket::SetDownloadLimit(uint32 dwLimit)
{
m_dwDownloadLimit = dwLimit;
m_bEnableDownloadLimit = true;
// CPU load improvement
if (dwLimit > 0 && m_bPendingOnReceive)
{
OnReceive(0);
}
}
void CTransferSocket::OnIOThreadEvent()
{
if (!m_bActive || m_transferEndReason != TransferEndReason::none) {
return;
}
if (m_transferMode == TransferMode::download) {
OnReceive();
}
else if (m_transferMode == TransferMode::upload) {
OnSend();
}
}
void CEMSocket::DisableDownloadLimit(bool bAvoidRead)
{
m_bEnableDownloadLimit = false;
// There're cases when DisableDownloadLimit can be called inside OnReceive()
// as OnReceive() uses static buffer it shouldn't be called recursively
if (bAvoidRead && m_bInPacketReceived)
return;
// CPU load improvement
if (m_bPendingOnReceive)
OnReceive(0);
}
void L2Socket::HandleHandshake( tcp::socket& _socket, size_t _agentOID, shared_ptr<L2Packet> _pack, boost::system::error_code _ec, size_t _bytes_transferred )
{
if( _ec )
{
LOG( "HandleHandshake error: "+ _ec.message() );
Disconnect(_socket,_agentOID);
return;
}
_pack->SetSize(_bytes_transferred);
LOG( "HandleHandshake success!!! " );
LOG( _pack->ToString() );
//THREAD->ThreadSleepFPS();
//OnReceive( _socket,_agentOID );
string handshake(_pack->ToString() );
CChar key1="Sec-WebSocket-Key: ";
size_t s11 = handshake.find( key1 )+strlen(key1);
size_t s12 = handshake.find( "\r",s11 );
string key = handshake.substr(s11,s12-s11);
CChar key2="Sec-WebSocket-Protocol: ";
size_t s21 = handshake.find( key2 )+strlen(key2);
size_t s22 = handshake.find( "\r",s21 );
string protocol = handshake.substr(s21,s22-s21);
//LOG( "test1:"+key );
//LOG( "test2:"+protocol );
//_pack = L2_GET_UNUSED_OBJ(L2Packet);
_pack->WriteStart();
key = ENCODE->EncodeWSGUID(key);
LOG( "Key:"+key );
string s="HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ";
s += key;
s += "\r\nSec-WebSocket-Protocol: ";
s += protocol;
s += "\r\n\r\n";
_pack->WriteString(s.c_str(),s.length());
//LOG( "WSGUID:"+_pack->ToString() );
//LOG( "WSGUID Size:"+_pack->GetSize() );
//SendTCP(_agentOID, _pack);
LOG( "HandleHandshake send: " );
LOG( _pack->ToString() );
async_write( _socket, _pack->GetSendBuffer(), transfer_at_least(1),bind(&L2Socket::HandleSend,this,ref(_socket),_agentOID,_1,_2));
OnReceive( _socket,_agentOID );
}
void CServerWorkFlow::OnMessage(MSG & msg)
{
switch(msg.message)
{
case WM_SEND:
OnSend(msg.wParam, msg.lParam);
break;
case WM_RECEIVE:
OnReceive(msg.wParam, msg.lParam);
break;
default:
break;
}
CThread::OnMessage(msg);
}
VBool VNetworkProcessPacketManager::ReceivePacket(ConnectionPtr conn, VUserPtr user,const HeaderPtr header,const ConstBuffer &buff)
{
VMutableBuffer packet;
const ChatHeader *pHeader = (const ChatHeader *)header;
if( user )
{
if( !user->CanReceivePacket() || user->GetSession().get() != conn )
return false;
}
else if( pHeader->type != vchat::Packet::c2s_db_login )
return false;
packet.first = buff.first;
packet.second = (VChar*)(buff.second);
return OnReceive(conn, (vchat::VChatUserPtr )user, pHeader, packet, VTrue);
}
void CRealControlSocket::OnSocketEvent(CSocketEvent &event)
{
if (!m_pBackend)
return;
switch (event.GetType())
{
case CSocketEvent::hostaddress:
{
const wxString& address = event.GetData();
LogMessage(MessageType::Status, _("Connecting to %s..."), address);
}
break;
case CSocketEvent::connection_next:
if (event.GetError())
LogMessage(MessageType::Status, _("Connection attempt failed with \"%s\", trying next address."), CSocket::GetErrorDescription(event.GetError()));
break;
case CSocketEvent::connection:
if (event.GetError())
{
LogMessage(MessageType::Status, _("Connection attempt failed with \"%s\"."), CSocket::GetErrorDescription(event.GetError()));
OnClose(event.GetError());
}
else
{
if (m_pProxyBackend && !m_pProxyBackend->Detached())
{
m_pProxyBackend->Detach();
m_pBackend = new CSocketBackend(this, m_pSocket);
}
OnConnect();
}
break;
case CSocketEvent::read:
OnReceive();
break;
case CSocketEvent::write:
OnSend();
break;
case CSocketEvent::close:
OnClose(event.GetError());
break;
default:
LogMessage(MessageType::Debug_Warning, _T("Unhandled socket event %d"), event.GetType());
break;
}
}
