Ejemplo n.º 1
0
LONG CALLBACK _mio_wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LONG lParam)
{
    if(msg == WM_TIMER) {
        return 1;
    } else if(msg >= WM_MIO_EVENT) {
        mio_priv_t m = (mio_priv_t)(GetWindowLongPtr(hwnd, GWLP_USERDATA));
        if(msg - WM_MIO_EVENT >= m->count) {
            mio_debug(ZONE, "mio event %d on socket id %d out of socket bounds %d", WSAGETSELECTEVENT(lParam), msg - WM_MIO_EVENT, m->count);
            return 0;
        }
        if(!m->fds[msg - WM_MIO_EVENT].event & WSAGETSELECTEVENT(lParam)) {
            mio_debug(ZONE, "unmatched mio event %d on socket #%d", WSAGETSELECTEVENT(lParam), m->fds[msg - WM_MIO_EVENT].mio_fd.fd);
            return 0;
        }
        m->select_fd = &m->fds[msg - WM_MIO_EVENT];
        m->select_fd->revent = WSAGETSELECTEVENT(lParam);
        mio_debug(ZONE, "get mio event %d on socket #%d", m->select_fd->revent, m->select_fd->mio_fd.fd); \
        return 1;
    } else if(msg == WM_CREATE) {
        SetWindowLongPtr(hwnd, GWLP_USERDATA,
            (LONG_PTR)((LPCREATESTRUCT)lParam)->lpCreateParams);
    } else {
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}
Ejemplo n.º 2
0
void OnWSANetEvent(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
	int rc;
	char szTemp[256];
	szTemp[0]=0;
	SOCKET sock = (SOCKET) wParam;
	if(WSAGETSELECTEVENT(lParam) == FD_READ)
	{
		int acc_sin_len = sizeof(acc_sin);
		getpeername(sock,(LPSOCKADDR) &acc_sin,(int FAR*) &acc_sin_len);
		rc = recv(sock,szTemp,256,0);
		szTemp[rc]=0;
		if(rc)
			SendReply(hWnd,sock,szTemp);
		//closesocket(sock);
	}
	else if(WSAGETSELECTEVENT(lParam)==FD_CLOSE)
	{
		int acc_sin_len = sizeof(acc_sin);
		getpeername(sock,(LPSOCKADDR) &acc_sin,(int FAR*) &acc_sin_len);
		TCHAR wtmp[255];
		wsprintf(wtmp,TEXT("[%lu] Хост %lu завершил соединение"),clock(), acc_sin.sin_addr.s_addr);
		SendMessage(hLst,LB_ADDSTRING,0,(LPARAM)wtmp);
		closesocket(sock);
	}
}
Ejemplo n.º 3
0
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch( msg )
	{
	case UM_SOCKET:	// wParam : socket핸들  lparam :  네트워크 이벤트 
		{
			switch(  WSAGETSELECTEVENT( lParam) ) 
			{
			case FD_ACCEPT: 
				{				
					SOCKADDR_IN ClientAddr;
					int len = sizeof(ClientAddr); 
					SOCKET ClientSocket  = accept(  (SOCKET)wParam   , (SOCKADDR*)&ClientAddr, &len); 
					// ClientSocket + hwnd + send.recv  
					WSAAsyncSelect( ClientSocket, hwnd, UM_CLIENT , FD_WRITE|FD_READ|FD_CLOSE); 	
				} break; 
			}
		}
		return 0; 
	case UM_CLIENT: 
		{
			SOCKET ClientSocket = (SOCKET)wParam;
			char buf[BUF_SIZE] = {0};

			switch( WSAGETSELECTEVENT(lParam)) 
			{
			case FD_READ:
				{
					
					recv( ClientSocket, buf, BUF_SIZE, 0); 
					SetWindowText( hwnd, buf); 

						
				} 
			case FD_WRITE: 
				{
					send( ClientSocket, buf, BUF_SIZE, 0); 
				}
				break;
			case FD_CLOSE:  break;
			}
		}
				
		return 0; 
	case WM_LBUTTONDOWN:
		return 0;
		
	case WM_RBUTTONDOWN:
		return 0;
		
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	}
	return DefWindowProc( hwnd, msg, wParam, lParam);
}
Ejemplo n.º 4
0
int main(int argc, const char* argv[])
{
    HWND hWnd;
    MSG msg;
    const char* host = DEFAULT_HOST;
    const char* port = DEFAULT_PORT;
    if (argc > 2)
    {
        host = argv[1];
        port = argv[2];
    }

    hWnd = IntiInstance((HINSTANCE)GetModuleHandle(NULL));
    CHECK(InitializeServer(hWnd, host, atoi(port)));

    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (msg.message == WM_SOCKET)
        {
            SOCKET fd = msg.wParam;
            int event = WSAGETSELECTEVENT(msg.lParam);
            int error = WSAGETSELECTERROR(msg.lParam);
            HandleNetEvents(hWnd, fd, event, error);
        }
        else
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    CloseServer();
    return 0;
}
Ejemplo n.º 5
0
LRESULT OnSockMsg(WPARAM wParam, LPARAM lParam)
{
	switch (WSAGETSELECTEVENT(lParam))
	{
		case FD_CONNECT:
		{
			InsertLogMsg(_T("로그인 게이트 서버와 접속 되었습니다."));

			break;
		}
		case FD_CLOSE:
		{
			break;
		}
		case FD_READ:
		{
			char	szMsg[4096];

			int nLen = recv((SOCKET)wParam, szMsg, sizeof(szMsg), 0);

			szMsg[nLen] = '\0';

			InsertLogMsg(szMsg);

			break;
		}
	}

	return 0;
}
Ejemplo n.º 6
0
short SockHandler (UINT socket, LPARAM lEvent)
{
    switch (WSAGETSELECTEVENT (lEvent))
    {
    case FD_READ:
        break;
    case FD_WRITE:
        break;
    case FD_OOB:
        break;
    case FD_ACCEPT:
        if (ssd.socket != socket)
            return -1;
        return SockAccept ();
        break;
    case FD_CONNECT:
        break;
    case FD_CLOSE:
        if (ssd.socket != socket)
            return -1;
        return SockClose ();
        break;
    }
    return 0;
}
Ejemplo n.º 7
0
//
// Handles the IDA window messages for the hidden control window.
//
static LRESULT CALLBACK control_window_proc(HWND wnd, UINT msg, 
		WPARAM wp, LPARAM lp)
{
	switch (msg)
	{
		case WM_NETEVENT:
			{
				switch (WSAGETSELECTEVENT(lp))
				{
					case FD_ACCEPT:
						accept_client();
						break;
					case FD_READ:
						process_client((SOCKET)wp);
						break;
					case FD_CLOSE:
						close_client((SOCKET)wp);
						break;
				}
			}
			break;
		default:
			return DefWindowProc(wnd, msg, wp, lp);
	}

	return 0;
}
Ejemplo n.º 8
0
void XProc_DeleteCharacter::OnUserMessage_Socket(  UINT message, WPARAM wparam, LPARAM lparam )
{
	if (WSAGETASYNCERROR(lparam) != 0) 
	{		
		g_NetworkKernel.ProcessNetworkError();
		return;
	}

	switch (WSAGETSELECTEVENT(lparam)) 
	{	
	case FD_READ :
		g_NetworkKernel.ReadSocket();
		break;
	case FD_CLOSE :
		//_XDWINPRINT( "SERVER MESSAGE : Socket close message" );
		g_NetworkKernel.ProcessNetworkError();
		g_NetworkKernel.DisconnectServer();
		g_NetworkKernel.ReleaseNetwork();
		
		((CEmperorOfDragonsApp*)gApp)->m_proc_loginserver.m_PrevProcess_SelectCharacter = TRUE;
		((CEmperorOfDragonsApp*)gApp)->m_ProcessManager.ChangeProcess( 
			&((CEmperorOfDragonsApp*)gApp)->m_proc_loginserver );		
		
		break;
	}
}
Ejemplo n.º 9
0
HRESULT CMBCBaseObj::NetCall_Write(CMBCSocket* pMBCSock, WPARAM wParam, LPARAM lParam )
{
	int nErr =WSAGETSELECTERROR(lParam);
	int nEvent = WSAGETSELECTEVENT(lParam);
	SOCKET socRecv = (SOCKET)wParam;
	//not process
	ASSERT(FALSE);
	return S_OK;
}
Ejemplo n.º 10
0
LRESULT CMainFrame::OnCloseItem(WPARAM wParam,LPARAM lParam)
{
	if(WSAGETSELECTEVENT(lParam) == FD_CLOSE)
	{
		DWORD pClientItem = 
			pClientListView->CloseClient((SOCKET) wParam);
	}
	return TRUE;
}
Ejemplo n.º 11
0
LRESULT CAsynSocket::CSocketWnd::OnWinsocketNotify(WPARAM wParam, LPARAM lParam)
{
	if (wParam == 0 && lParam == 0)
		return 0;

	int nErrorCode = WSAGETSELECTERROR(lParam);
	if(m_bResolved && m_hAsyncGetHostByName == (HANDLE)wParam)	//需要解析主机名
	{
		m_hAsyncGetHostByName	=	NULL;
		m_bResolved				=	FALSE;

		m_pSocket->_OnResolve(nErrorCode);
	}
	else	//已经获取到了主机名,是其他Socket消息
	{
		if((SOCKET)wParam!=m_pSocket->m_hSocket)
			return 0;

		//////////////////////////////////////////////////////////////////
		//lParam = 658833440;	在有proxy的环境容易发生此类消息进行过滤
		//////////////////////////////////////////////////////////////////
		UINT nEvent = WSAGETSELECTEVENT(lParam);
		if(nEvent==FD_CLOSE && nErrorCode==WSAECONNABORTED)
			return 0;

		switch (nEvent)
		{
		case FD_READ:				//读
			{
				DWORD nBytes;
				if (!m_pSocket->IOCtl(FIONREAD, &nBytes))
					nErrorCode = WSAGetLastError();
				if (nBytes != 0 || nErrorCode != 0)
					m_pSocket->_OnReceive(nErrorCode);
			}
			break;
		case FD_WRITE:				//写
			m_pSocket->_OnSend(nErrorCode);
			break;
		case FD_OOB:
			m_pSocket->_OnOOBData(nErrorCode);
			break;
		case FD_ACCEPT:				//接收
			m_pSocket->_OnAccept(nErrorCode);
			break;
		case FD_CONNECT:			//连接
			m_pSocket->_OnConnect(nErrorCode);
			break;
		case FD_CLOSE:				//关闭
			m_pSocket->_OnClose(nErrorCode);
			break;
		default:
			break;
		}
	}
	return 0;
}
Ejemplo n.º 12
0
static LRESULT CALLBACK
rb_process_events(HWND nhwnd, UINT umsg, WPARAM wparam, LPARAM lparam)
{
	rb_fde_t *F;
	PF *hdl;
	void *data;
	switch (umsg)
	{
	case WM_SOCKET:
		{
			F = rb_find_fd(wparam);

			if(F != NULL && IsFDOpen(F))
			{
				switch (WSAGETSELECTEVENT(lparam))
				{
				case FD_ACCEPT:
				case FD_CLOSE:
				case FD_READ:
					{
						if((hdl = F->read_handler) != NULL)
						{
							F->read_handler = NULL;
							data = F->read_data;
							F->read_data = NULL;
							hdl(F, data);
						}
						break;
					}

				case FD_CONNECT:
				case FD_WRITE:
					{
						if((hdl = F->write_handler) != NULL)
						{
							F->write_handler = NULL;
							data = F->write_data;
							F->write_data = NULL;
							hdl(F, data);
						}
					}
				}

			}
			return 0;
		}
	case WM_DESTROY:
		{
			PostQuitMessage(0);
			return 0;
		}

	default:
		return DefWindowProc(nhwnd, umsg, wparam, lparam);
	}
	return 0;
}
Ejemplo n.º 13
0
LONG APIENTRY MyWndProc2(HWND hWnd, UINT message, UINT wParam, LONG lParam)
{
    switch(message) {
	// Sockets Handling
	case WM_USER:
	    DoSocketsCallback(wParam, WSAGETSELECTEVENT(lParam));
	    break;
    }
    return (DefWindowProc(hWnd, message, wParam, lParam));
}
Ejemplo n.º 14
0
void CTCPClientSocketImpl::FireEvent ( bool bIsResolveEvent, uint uiResolveId, LPARAM lType )
{
    // Check this is the correct thingmy #1
    if ( bIsResolveEvent != m_bIsResolvingHost )
        return;

    // Are we resolving host? If so, we got this event from WSAAsyncGetHostByName
    if ( m_bIsResolvingHost )
    {
        // Check this is the correct thingmy #2
        if ( uiResolveId != (uint)m_pAsyncHostResolving )
            return;

        m_bIsResolvingHost = false;

        // Get error code
        unsigned short usError = WSAGETASYNCERROR ( lType );
        // Succeeded? Continue
        if ( !usError )
        {
            ConnectContinue ();
        }
        else
        {
            strcpy ( m_szLastError, "Unable to resolve" );
        }
        return;
    }

    // Check event type
    switch ( WSAGETSELECTEVENT ( lType ) )
    {
        case FD_READ:
            if ( m_pEventRead )
                m_pEventRead ( this, m_pClass );
            break;
        case FD_WRITE:
            if ( m_pEventWrite )
                m_pEventWrite ( this, m_pClass );
            break;
        case FD_CONNECT:    // Client only
            if ( m_pEventConnect )
                m_pEventConnect ( this, m_pClass );
            break;
        case FD_CLOSE:
            if ( m_pEventClose )
                m_pEventClose ( this, m_pClass );
            break;
        /*
        case FD_ACCEPT:     // Server only
            break;
        */
    }
}
Ejemplo n.º 15
0
int handleNetworkDatagramEvents(WPARAM wParam,LPARAM lParam) {
    switch(WSAGETSELECTEVENT(lParam)) {

    case FD_WRITE:
        javanotify_datagram_event(
            JAVACALL_EVENT_DATAGRAM_SENDTO_COMPLETED,
            (javacall_handle)wParam,
            (WSAGETSELECTERROR(lParam) == 0) ? JAVACALL_OK : JAVACALL_FAIL);
#ifdef ENABLE_NETWORK_TRACING
        fprintf(stderr, "[UDP] FD_WRITE)\n");
#endif
        return 0;
    case FD_READ:
#ifdef ENABLE_JSR_120
        if (JAVACALL_OK == try_process_wma_emulator((javacall_handle)wParam)) {
            return 0;
        }
#endif

        javanotify_datagram_event(
            JAVACALL_EVENT_DATAGRAM_RECVFROM_COMPLETED,
            (javacall_handle)wParam,
            (WSAGETSELECTERROR(lParam) == 0) ? JAVACALL_OK : JAVACALL_FAIL);
#ifdef ENABLE_NETWORK_TRACING
        fprintf(stderr, "[UDP] FD_READ)\n");
#endif
        return 0;
    case FD_CLOSE:
#ifdef ENABLE_NETWORK_TRACING
        fprintf(stderr, "[UDP] FD_CLOSE)\n");
#endif
        return 0;
    default:
#ifdef ENABLE_NETWORK_TRACING
        fprintf(stderr, "[UDP] unsolicited event %d)\n",
                WSAGETSELECTEVENT(lParam));
#endif
        break;
    }//end switch
    return 0;
}
Ejemplo n.º 16
0
INT_PTR CALLBACK MainDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uMsg)
	{
	case WSA_READ:
	{
		if (WSAGETSELECTEVENT(lParam) != FD_READ)
		{
			Admin.cSock.CloseSocket();
			break;
		}

		CurrentTime = timeGetTime();

		if (Admin.cSock.Receive() != 1)
			break;

		char temp[256];
		int Error;
		int ErrorCode;

		while (1)
		{
			char *Msg = Admin.cSock.ReadMessage(&Error, &ErrorCode);

			if (Msg == NULL)
				break;

			if (Error == 1 || Error == 2)
			{
				sprintf(temp, "err wsa_read (%d),%d", Error, ErrorCode);
				Log(temp, "-system", 0);

				break;
			}

			ProcessMessage(Msg);
		};
	} break;

	case WM_CLOSE:
		if(MessageBox(hDlg, "Você deseja fechar o aplicativo?", "Close", MB_ICONQUESTION | MB_YESNO) == IDYES)
			DestroyWindow(hDlg);
		return TRUE;

	case WM_DESTROY:
		Admin.cSock.CloseSocket();
		PostQuitMessage(0);
		return TRUE;
	}

	return FALSE;
}
Ejemplo n.º 17
0
LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{	
	case WM_SOCKET:
		{
			// 取得有事件发生的套节字句柄
			SOCKET s = wParam;
			// 查看是否出错
			if(WSAGETSELECTERROR(lParam))
			{
				::closesocket(s);
				return 0;
			}
			// 处理发生的事件
			switch(WSAGETSELECTEVENT(lParam))
			{
			case FD_ACCEPT:		// 监听中的套接字检测到有连接进入
				{
					SOCKET client = ::accept(s, NULL, NULL);
					::WSAAsyncSelect(client, hWnd, WM_SOCKET, FD_READ|FD_WRITE|FD_CLOSE);
				}
				break;
			case FD_WRITE:
				{
				}
				break;
			case FD_READ:
				{
					char szText[1024] = { 0 };
					if(::recv(s, szText, 1024, 0) == -1)
						::closesocket(s);
					else
						printf("接收数据:%s", szText);
				}
				break;
			case FD_CLOSE:
				{ 
					::closesocket(s);
				}
				break;
			}
		}
		return 0;
	case WM_DESTROY:
		::PostQuitMessage(0) ;
		return 0 ;
	}

	// 将我们不处理的消息交给系统做默认处理
	return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
}
Ejemplo n.º 18
0
HRESULT CMBCBaseObj::NetCall_Close(CMBCSocket* pMBCSock, WPARAM wParam, LPARAM lParam )
{
	int nErr =WSAGETSELECTERROR(lParam);
	int nEvent = WSAGETSELECTEVENT(lParam);
	SOCKET socRecv = (SOCKET)wParam;
	if (socRecv ==  *m_pSockBase)
	{
		ChangeSelfState(MBCSTATE_NETERR);
	}
	TRACE("\n Sock Closed");

	return S_OK;
}
Ejemplo n.º 19
0
//
//  함수: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  목적:  주 창의 메시지를 처리합니다.
//
//  WM_COMMAND	- 응용 프로그램 메뉴를 처리합니다.
//  WM_PAINT	- 주 창을 그립니다.
//  WM_DESTROY	- 종료 메시지를 게시하고 반환합니다.
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	PAINTSTRUCT ps;
	HDC hdc;

	switch (message)
	{
	// 프로그램 비활성화 체크
	case WM_ACTIVATEAPP :
		g_bActiveApp = (BOOL)wParam;
		break;
		
	//네트워크 메시지
	case WM_NETWORK :
		if (WSAGETASYNCERROR(lParam))
			MessageBox(g_hWnd, L"WM_NETWORK", NULL, NULL);

		switch (WSAGETSELECTEVENT(lParam))
		{
		case FD_CONNECT :
			break;

		case FD_CLOSE :
			MessageBox(g_hWnd, L"close", NULL, NULL);
			break;

		case FD_READ :
			ReadProc();
			break;

		case FD_WRITE :
			WriteProc();
			break;
		}
		break;

	case WM_PAINT:
		hdc = BeginPaint(hWnd, &ps);
		// TODO: 여기에 그리기 코드를 추가합니다.
		EndPaint(hWnd, &ps);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;

	timeBeginPeriod(1);
}
Ejemplo n.º 20
0
afx_msg LRESULT CServerDlg::OnSock(WPARAM wParam, LPARAM lParam)
{
	if (WSAGETSELECTERROR(lParam))
	{
		return 1;
	}
	switch (WSAGETSELECTEVENT(lParam))
	{
	case FD_ACCEPT:
	{
		sockaddr_in ClientAddr;
		int nSize = sizeof(ClientAddr);

		m_ClientSock = accept(m_ListenSock, (SOCKADDR *)&ClientAddr, &nSize);
		WSAAsyncSelect(m_ClientSock, GetSafeHwnd(), WM_SERVER, FD_READ | FD_CLOSE);
		char *p = inet_ntoa(ClientAddr.sin_addr);
		m_StrMsg.Format("请求IP:%s:%d", p, ntohs(ClientAddr.sin_port));

		char szBuf[MAXBYTE] = { 0 };
		lstrcpy(szBuf, m_StrMsg.GetBuffer());
		send(m_ClientSock, (const char*)&szBuf, sizeof(szBuf), 0);

		break;
	}
	case FD_READ:
	{
		char szBuf[MAXBYTE] = { 0 };
		recv(m_ClientSock, szBuf, MAXBYTE, 0);
		m_StrMsg = "对方发来命令";
		m_StrMsg += szBuf;

		break;
	}
	case FD_CLOSE:
	{
		closesocket(m_ClientSock);
		m_StrMsg = "对方关闭连接";
		break;
	}
	}
	CString temp;
	GetDlgItemText(IDC_EDIT, temp);

	m_StrMsg += "\r\n----------------------\r\n";
	m_StrMsg += temp;

	SetDlgItemText(IDC_EDIT, m_StrMsg);
	m_StrMsg = "";
	return 0;
}
Ejemplo n.º 21
0
BOOL CALLBACK ClientProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
	LPSOCKET_INFO	SocketInfo;
	DWORD			SendBytes;
	LPSTR			psBuff;

	psBuff = (LPSTR)VirtualAlloc((LPVOID)NULL, (DWORD)(255),
					MEM_COMMIT, PAGE_READWRITE);
	
	if (WSAGETSELECTERROR(lParam)) {
		wsprintf(psBuff, (LPCTSTR)"Socket failed with error %d", WSAGetLastError());
		AppendLog(psBuff);
	}
	else {
		switch (WSAGETSELECTEVENT(lParam)) {
			case FD_CONNECT:
				CreateSocketInfo(wParam);
				break;

			case FD_WRITE:
				SocketInfo = GetSocketInfo(wParam);

				if (SocketInfo->DataBuff.len == 0) {
					SocketInfo->DataBuff.buf = SocketInfo->Buffer;
					SocketInfo->DataBuff.len = 0;
				}

				if (WSASend(SocketInfo->Socket, &(SocketInfo->DataBuff), 1, &SendBytes,
					0, NULL, NULL) == SOCKET_ERROR) {
						if (WSAGetLastError() != WSAEWOULDBLOCK) {
							wsprintf(psBuff, (LPCTSTR)"WSASend() failed with error %d", WSAGetLastError());
							AppendLog(psBuff);
							//FreeSocketInfo(wParam);
						}
				}
				else { // Update the byte count
					SocketInfo->BytesSEND += SendBytes;
				}
				break;

			case FD_CLOSE:
				wsprintf(psBuff, (LPCTSTR)"Closing socket %d", wParam);
				AppendLog(psBuff);
				FreeSocketInfo(wParam);
				break;
		}
		return FALSE;
	}

	return FALSE;
}
Ejemplo n.º 22
0
HRESULT CMBCBaseObj::NetCall_Connect(CMBCSocket* pMBCSock, WPARAM wParam, LPARAM lParam )
{
	int nErr =WSAGETSELECTERROR(lParam);
	int nEvent = WSAGETSELECTEVENT(lParam);
	SOCKET socRecv = (SOCKET)wParam;
	//i am client
	ASSERT(socRecv == *pMBCSock);
	if (nErr ==S_OK)
	{	
		//CFWriteLog("==connected, soc = %d, ip =%s", socRecv, Addr2String(pMBCSock->m_addrs.addrRemote).c_str());
		ChangeSelfState(MBCSTATE_OK);
	}
	return S_OK;
}
Ejemplo n.º 23
0
LRESULT CALLBACK SharedSocketDataReceiverWndProc(HWND wnd,UINT message,WPARAM wp,LPARAM lp)
{
	switch (message)
	{
		case WM_SHARED_SOCKET_EVENT:
			{
				switch (WSAGETSELECTEVENT(lp))
				{
					case FD_READ:
						{
							SOCKET data_socket=(SOCKET)wp;
							char type;
							DWORD length;
						
							PBYTE data=RecvTLVData(data_socket,&type,&length);
							if(data)
							{
								gSharedSocketDataReceiver(data_socket,type,length,data);
							}else{
								//msg("Got Error on Socket\n");
							}
						
							//WSAAsyncSelect: READ|CLOSE
							if (WSAAsyncSelect(data_socket ,
								wnd,
								WM_SHARED_SOCKET_EVENT,
								FD_READ|FD_CLOSE
							) == SOCKET_ERROR)
							{
								/*
								print_function("failed to async select client %d, %x data_socket=%d, message_window=%x\n", 
									data_socket,
									WSAGetLastError(),
									data_socket,
									message_window);
								*/
							}							
						}
						break;
					case FD_CLOSE:
						closesocket((SOCKET)wp);
						break;
				}
			}
			break;
		default:
			return DefWindowProc(wnd, message, wp, lp);
	}
	return 0;
}
Ejemplo n.º 24
0
HRESULT CMBCHeartBeatObj::NetCall_Connect(CMBCSocket* pMBCSock, WPARAM wParam, LPARAM lParam )
{
	int nErr =WSAGETSELECTERROR(lParam);
	int nEvent = WSAGETSELECTEVENT(lParam);
	SOCKET socRecv = (SOCKET)wParam;
	//i am client
	ASSERT(socRecv == *pMBCSock);
	if (nErr ==S_OK)
	{	
		m_timerLive.SetTimer(IDTIMER_LIVECHECK, INTERVAL_LIVECHECK, this, (LPARAM)this, WT_EXECUTEDEFAULT, 1000);
		TRACE("\n Sock Connected");

	}
	return CMBCBaseObj::NetCall_Connect(pMBCSock, wParam, lParam);
}
Ejemplo n.º 25
0
LRESULT BTCtcp::ProcessNotifications(HWND hWnd, LPARAM lParam)
{
	int wsaErr = WSAGETSELECTERROR(lParam);
	unsigned int ui=0;
	TCHAR szText[MAX_LOADSTRING];
	switch (WSAGETSELECTEVENT(lParam))
	{
	case FD_ACCEPT:
		break;
	case FD_CONNECT:						// connect() operation terminated
		if (wsaErr == ERROR_SUCCESS) {		// and no error --> we are connected :)
			iBTCSocketStatus = 5;
			iBTCError = ERROR_SUCCESS;
			ui=IDS_SS_CONNECTED;
		}
		else {
			iBTCSocketStatus = 3;			// "connecting..." status did not complete successfully
			iBTCError = wsaErr;				// save error information
			iBTCNodeStatus=0;				// no connection
			ui=IDS_SS_FAILED;
			ShowError(IDS_Err_Socket, iBTCError);
		}
		break;
	case FD_WRITE:
		bWriteReady = true;		// we are notified we can send (again)
		WriteToSocket();		// try to send data if something is waiting in our buffer
		break;
	case FD_READ:
		ReadFromSocket(hWnd);	// data is awaiting
		break;
	case FD_CLOSE:				// connection has been closed
		closesocket(skBTC);		// release the socket
		iBTCSocketStatus=1;
		iBTCNodeStatus=0;
		ui=IDS_SS_NOTHING;
		break;
	}
	if (ui) {	// show something to user
		LoadString(hInst, ui, szText, MAX_LOADSTRING);
		SetWindowText(hStaticSocketStatus, szText);  // update status window related to our TCP connection
		InvalidateRect(hWnd, &rcSocketStatus, true);
		LoadString(hInst, (iBTCSocketStatus>3) ? IDS_DISCONNECT:IDS_CONNECT, szText, MAX_LOADSTRING);
		SetDlgItemText(hWnd, IDC_BTNBTCCONNECT, szText);
		EnableWindow(GetDlgItem(hWnd, IDC_BTNSQLCONNECT), iBTCSocketStatus<2);
	}
	return 0;
}
Ejemplo n.º 26
0
//
/// DoNotification() is the SocketWindow's protected internal notification system.
//
TResult TSocketWindow::DoNotification(TParam1 param1, TParam2 param2)
{
  SOCKET socket = param1;
  int     error   = (int)WSAGETSELECTERROR(param2);

  if (socket != SocketParent->Handle)
    return 0;

  switch (WSAGETSELECTEVENT(param2)) {
    case FD_READ:
      if (WindowNotification && (NotificationSet & NotifyRead)) {
        return WindowNotification->SendMessage(MsgSocketNotification, param1, param2);
      }
      SocketParent->DoReadNotification(socket, error);
      break;
    case FD_WRITE:
      if (WindowNotification && (NotificationSet & NotifyWrite)) {
        return WindowNotification->SendMessage(MsgSocketNotification, param1, param2);
      }
      SocketParent->DoWriteNotification(socket, error);
      break;
    case FD_OOB:
      if (WindowNotification && (NotificationSet & NotifyOOB)) {
        return WindowNotification->SendMessage(MsgSocketNotification, param1, param2);
      }
      SocketParent->DoOOBNotification(socket, error);
      break;
    case FD_ACCEPT:
      if (WindowNotification && (NotificationSet & NotifyAccept)) {
        return WindowNotification->SendMessage(MsgSocketNotification, param1, param2);
      }
      SocketParent->DoAcceptNotification(socket, error);
      break;
    case FD_CONNECT:
      if (WindowNotification && (NotificationSet & NotifyConnect)) {
        return WindowNotification->SendMessage(MsgSocketNotification, param1, param2);
      }
      SocketParent->DoConnectNotification(socket, error);
      break;
    case FD_CLOSE:
      if (WindowNotification && (NotificationSet & NotifyClose)) {
        return WindowNotification->SendMessage(MsgSocketNotification, param1, param2);
      }
      SocketParent->DoCloseNotification(socket, error);
  }
  return 1;
}
Ejemplo n.º 27
0
void PASCAL CAsyncSocket::DoCallBack(WPARAM wParam, LPARAM lParam)
{
	if (wParam == 0 && lParam == 0)
		return;

	// Has the socket be closed?
	CAsyncSocket* pSocket = CAsyncSocket::LookupHandle((SOCKET)wParam, TRUE);

	// If yes ignore message
	if (pSocket != NULL)
		return;

	pSocket = CAsyncSocket::LookupHandle((SOCKET)wParam, FALSE);
	if (pSocket == NULL)
	{
		// Must be in the middle of an Accept call
		pSocket = CAsyncSocket::LookupHandle(INVALID_SOCKET, FALSE);
		ASSERT(pSocket != NULL);
		pSocket->m_hSocket = (SOCKET)wParam;
		CAsyncSocket::DetachHandle(INVALID_SOCKET, FALSE);
		CAsyncSocket::AttachHandle(pSocket->m_hSocket, pSocket, FALSE);
	}

	int nErrorCode = WSAGETSELECTERROR(lParam);
	switch (WSAGETSELECTEVENT(lParam))
	{
	case FD_READ:
		pSocket->OnReceive(nErrorCode);
		break;
	case FD_WRITE:
		pSocket->OnSend(nErrorCode);
		break;
	case FD_OOB:
		pSocket->OnOutOfBandData(nErrorCode);
		break;
	case FD_ACCEPT:
		pSocket->OnAccept(nErrorCode);
		break;
	case FD_CONNECT:
		pSocket->OnConnect(nErrorCode);
		break;
	case FD_CLOSE:
		pSocket->OnClose(nErrorCode);
		break;
	}
}
Ejemplo n.º 28
0
LRESULT Client::HandleEvent(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg) 
	{
	case WM_SOCKET:
		sPlayerMain.OnSocketEvent(wParam, WSAGETSELECTERROR(lParam), WSAGETSELECTEVENT(lParam));
		return 0;
	case WM_CREATE:
		LoadContent();
		return 0;

	case WM_KEYDOWN:
		KeyDown(wParam);
		return 0;

	case WM_PAINT:	
		Draw(hwnd);
		return 0;

	case WM_LBUTTONDBLCLK:
		MouseLDButtonDown(lParam);
		return 0;

	case WM_MBUTTONDOWN:
		MouseMButtonDown(lParam);
		return 0;

	case WM_LBUTTONDOWN:
		MouseLButtonDown(lParam);
		return 0;

	case WM_RBUTTONDOWN:
		MouseRButtonDown(lParam);
		return 0;

	case WM_MOUSEMOVE:
		MouseMove(lParam);
		return 0;

	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	}
	return DefWindowProc(hwnd, msg, wParam, lParam);
}
Ejemplo n.º 29
0
//=============================================================================
int XSocket::iOnSocketEvent(WPARAM wParam, LPARAM lParam)
{
 int WSAEvent;
 PutLogList("iOnSocketEvent");
	if (m_cType != XSOCK_NORMALSOCK) return XSOCKEVENT_SOCKETMISMATCH;
	if (m_cType == NULL) return XSOCKEVENT_NOTINITIALIZED;

	if ((SOCKET)wParam != m_Sock) return XSOCKEVENT_SOCKETMISMATCH;
	WSAEvent = WSAGETSELECTEVENT(lParam);

	switch (WSAEvent) {
	case FD_CONNECT:
		if (WSAGETSELECTERROR(lParam) != 0) {
			if (bConnect(m_pAddr, m_iPortNum, m_uiMsg) == FALSE) return XSOCKEVENT_SOCKETERROR;

			return XSOCKEVENT_RETRYINGCONNECTION;
		}
		else {
			m_bIsAvailable = TRUE;
			return XSOCKEVENT_CONNECTIONESTABLISH;
		}
		break;

	case FD_READ:
		if (WSAGETSELECTERROR(lParam) != 0) {
			m_WSAErr = WSAGETSELECTERROR(lParam);
			return XSOCKEVENT_SOCKETERROR;
		}
		else return _iOnRead();
		break;

	case FD_WRITE:
		return _iSendUnsentData();
		break;

	case FD_CLOSE:
		m_cType = XSOCK_SHUTDOWNEDSOCK;
		return XSOCKEVENT_SOCKETCLOSED;
		break;
	}

	return XSOCKEVENT_UNKNOWN;
}
void CListener::ProcessSocketMsg(WPARAM wParam, LPARAM lParam)
{

	if (WSAGETSELECTERROR(lParam))
	{
		// Display the error and close the socket
		CloseConnection(wParam);
		return;
	}

	switch(WSAGETSELECTEVENT(lParam))
	{
		case FD_ACCEPT:
			{
				SOCKADDR_IN ClientAddr = {0};
				int	iLen = sizeof(ClientAddr);
				accept(wParam, (LPSOCKADDR)&ClientAddr, &iLen);
				break;
			}
		case FD_READ:
			{
				// Receive data from the socket in
				// wParam
				ProcessRead(wParam);
				break;
			}

		case FD_WRITE:
			{
				// The socket in wParam is ready
				// for sending data
				break;
			}

		case FD_CLOSE:
			{
				// The connection is now closed	
				CloseConnection(wParam);
				break;
			}
	}
}