Exemple #1
0
void CEMSocket::InitProxySupport()
{
//	Destroy all proxy layers (done inside Close())
	Close();

//	Proxy initialization
	const ProxySettings	&settings = g_App.m_pPrefs->GetProxySettings();

	m_bProxyConnectFailed = false;
	if (settings.m_bUseProxy && settings.m_nType != PROXYTYPE_NOPROXY)
	{
		m_pProxyLayer = new CAsyncProxySocketLayer;
		switch (settings.m_nType)
		{
			case PROXYTYPE_SOCKS4:
			case PROXYTYPE_SOCKS4A:
				m_pProxyLayer->SetProxy(settings.m_nType, settings.m_strName, settings.m_uPort);
				break;
			case PROXYTYPE_SOCKS5:
			case PROXYTYPE_HTTP11:
				if (settings.m_bEnablePassword)
					m_pProxyLayer->SetProxy(settings.m_nType, settings.m_strName, settings.m_uPort, settings.m_strUser, settings.m_strPassword);
				else
					m_pProxyLayer->SetProxy(settings.m_nType, settings.m_strName, settings.m_uPort);
				break;
			default:
				ASSERT(0);
		}
		AddLayer(m_pProxyLayer);
	}

//	Connection Initialization
	Create(0, SOCK_STREAM, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE, g_App.m_pPrefs->GetBindAddrA());
	AsyncSelect(FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
}
Exemple #2
0
void CEMSocket::InitProxySupport()
{
    m_bProxyConnectFailed = false;

    // ProxyInitialisation
    const ProxySettings& settings = thePrefs.GetProxySettings();
    if (settings.UseProxy && settings.type != PROXYTYPE_NOPROXY)
    {
        Close();

        m_pProxyLayer = new CAsyncProxySocketLayer;
        switch (settings.type)
        {
        case PROXYTYPE_SOCKS4:
        case PROXYTYPE_SOCKS4A:
            m_pProxyLayer->SetProxy(settings.type, settings.name, settings.port);
            break;
        case PROXYTYPE_SOCKS5:
        case PROXYTYPE_HTTP10:
        case PROXYTYPE_HTTP11:
            if (settings.EnablePassword)
                m_pProxyLayer->SetProxy(settings.type, settings.name, settings.port, settings.user, settings.password);
            else
                m_pProxyLayer->SetProxy(settings.type, settings.name, settings.port);
            break;
        default:
            ASSERT(0);
        }
        AddLayer(m_pProxyLayer);

        // Connection Initialisation
        Create(0, SOCK_STREAM, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE, thePrefs.GetBindAddrA());
        AsyncSelect(FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
    }
}
Exemple #3
0
CEMSocket::~CEMSocket()
{
	EMTrace("CEMSocket::~CEMSocket() on %d",(SOCKET)this);
	ClearQueues();
	RemoveAllLayers();
	AsyncSelect(0);
}
Exemple #4
0
CChatControl::~CChatControl()
{	
	// Save chat prefs
	m_pPrefs->SaveServers(m_pDoc->m_RunPath  + "Data\\ChatServers.ini");
	m_pPrefs->SaveChatAliases(m_pDoc->m_RunPath + "Data\\ChatAliases.ini");
	m_pPrefs->SaveChatScripts(m_pDoc->m_RunPath + "Data\\ChatScripts.ini");
	m_pPrefs->SaveChatHotlist(m_pDoc->m_RunPath + "Data\\ChatHotlist.ini");

	delete m_pPrefs;
	m_pPrefs = NULL;


	if(m_hSocket != INVALID_SOCKET)
		AsyncSelect(0);

	TRACE0("*** CChatControl Deconstructing\n");

	for(int i = 0; i < m_ServerList.size(); i++)
	{
		delete m_ServerList[i];
		m_ServerList[i] = NULL;
	}

	while(m_IdentdList.size())
	{
		delete m_IdentdList.back();
		m_IdentdList.pop_back();
	}

	m_ServerList.clear();
}
int WAsyncSocket::Close()
{
	AsyncSelect(0);	// turn off all async notifications
	
	m_wnd.DestroyWindow();
	
	return WSocket::Close();
}
Exemple #6
0
BOOL CAsyncSocket::Attach(SOCKET hSocket, long lEvent)
{
	ASSERT(hSocket != INVALID_SOCKET);

	m_hSocket = hSocket;
	CAsyncSocket::AttachHandle(hSocket, this);
		
	return AsyncSelect(lEvent);
}
Exemple #7
0
BOOL CAsynSocket::Socket(int nSocketType, long lEvent,	int nProtocolType, int nAddressFormat)
{
	ASSERT(m_hSocket == INVALID_SOCKET);

	m_hSocket = socket(nAddressFormat,nSocketType,nProtocolType);
	if (m_hSocket != INVALID_SOCKET)
		return AsyncSelect(lEvent);

	return FALSE;
}
Exemple #8
0
SOCKET CAsyncSocket::Detach()
{
	SOCKET hSocket = m_hSocket;
	if (AsyncSelect(0))
	{
		CAsyncSocket::KillSocket(hSocket, this);
		m_hSocket = INVALID_SOCKET;
		return hSocket;
	}
	return INVALID_SOCKET;
}
Exemple #9
0
void CSocket::Close()
{
	if (m_hSocket != INVALID_SOCKET)
	{
		CancelBlockingCall();

		VERIFY(AsyncSelect(0));
		CAsyncSocket::Close();
		m_hSocket = INVALID_SOCKET;
	}
}
Exemple #10
0
void WAsyncSocket::Attach(SOCKET hSocket)
{
	WSocket::Attach(hSocket);

	// Create message window so that it will accept messages posted to it
	m_wnd.CreateEx(0,AfxRegisterWndClass(0),NULL,0,0,0,0,0,0,NULL,NULL);
	m_wnd.InitSocket(this);
	m_hwnd=m_wnd.GetSafeHwnd();
		
	// Do the asyncselect crap
	AsyncSelect(FD_CONNECT|FD_READ|FD_WRITE|FD_CLOSE);	// was FD_ALL_EVENTS
}
int WAsyncSocket2::Create(unsigned int port)
{
	int ret=WSocket2::Create(port);

	if((ret!=INVALID_SOCKET)&&(ret!=SOCKET_ERROR))
	{
		// Do the asyncselect crap
		ret=AsyncSelect(FD_ALL_EVENTS);
	}

	return ret;
}
Exemple #12
0
// Called when data is received.
void CNDKClientSocket::OnReceive(int nErrorCode) 
{
	CString str;
	UINT ui;

	//remove read notifications
	VERIFY(AsyncSelect(/*FD_READ | */FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE));

	CSocket::OnReceive(nErrorCode);

	ASSERT(m_pClient != NULL);

	if (m_pClient != NULL)
		m_pClient->ProcessPendingRead(nErrorCode);

	//reset notifications to default
	if(0 != GetSockName(str, ui))
	{
		VERIFY(AsyncSelect());
	}
}
void ClientSocket::OnReceive(int nErrorCode)
{
	// TODO:  在此添加专用代码和/或调用基类
	char *pData = NULL;
	
	//pData = new char[10240];
	//memset(pData, 0, sizeof(char)*10240);
	External_Mag_Head msgHead;
	int msgLen = sizeof(External_Mag_Head);
	UINT leng = 0;
	CString strDoc;
	pData = new char[msgLen];
	memset(pData, 0, sizeof(char)*msgLen);
	SetTimeOut(3000);
	leng = Receive(pData, msgLen, 0);
	KillTimeOut();
	AsyncSelect(FD_READ);
	memcpy(&msgHead, pData, msgLen);
	free(pData);
	pData = new char[msgHead.load_len + 1];
	
	memset(pData, 0, sizeof(char)*msgHead.load_len + 1);
	SetTimeOut(3000);
	leng = Receive(pData, msgHead.load_len, 0);
	KillTimeOut();
	AsyncSelect(FD_READ);
	//char *p_msgBody = (char*)malloc(sizeof(char)*msgHead.load_len);
	//memset(p_msgBody, 0, sizeof(char)*msgHead.load_len);
	//memcpy(p_msgBody, pData + msgLen, sizeof(char)*msgHead.load_len);
	strDoc = StringConvertor::Utf8ToWide(pData);
	m_xml.SetDoc(strDoc);
	ParseXml(m_xml);
	/*DWORD *pParams = new DWORD[2];
	pParams[0] = (DWORD)this;
	pParams[1] = (DWORD)pData;
	m_hThread = ::CreateThread(NULL, NULL, ParseXml, (LPVOID*)(pParams), NULL, NULL);*/
	
	delete pData;
	CSocket::OnReceive(nErrorCode);
}
Exemple #14
0
void CAsynSocket::_OnClose(int nErrorCode)
{
	AsyncSelect(0);

	if(m_pSocketWnd)
	{
		m_pSocketWnd->DestroyWindow();
		delete m_pSocketWnd;
		m_pSocketWnd = NULL;
	}	

	OnClose(nErrorCode);
}
void CClientSocket::OnSend(int nErrorCode)
{
	// TODO:  在此添加专用代码和/或调用基类
	my_nLength = WideCharToMultiByte(CP_ACP, 0, my_SendData, my_SendData.GetLength(), NULL, 0, NULL, NULL);
	WideCharToMultiByte(CP_ACP, 0, my_SendData, my_SendData.GetLength() + 1, my_szBuffer, my_nLength + 1, NULL, NULL);	//转换为字节为单位
	my_szBuffer[my_nLength + 1] = '/0';
	Send(my_szBuffer, sizeof(my_szBuffer), 0);
	my_nLength = 0;
	memset(my_szBuffer, 0, sizeof(my_szBuffer));
	AsyncSelect(FD_READ);

	CAsyncSocket::OnSend(nErrorCode);
}
int MightyTCPAsyncSelectClient::afreshConnect()
{
	if (m_ClientSock==INVALID_SOCKET)
	{
		m_ClientSock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
		m_lEvent=FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE;
		AsyncSelect(m_lEvent);
		Connect(m_strAddress.c_str(),m_ConnectPort);
		return 0;
	}
	else
	{
		return 1;
	}
}
Exemple #17
0
int WAsyncSocket::Create(unsigned short int port,unsigned int ip)
{
	// Create message window so that it will accept messages posted to it
	m_wnd.CreateEx(0,AfxRegisterWndClass(0),NULL,0,0,0,0,0,0,NULL,NULL);
	m_wnd.InitSocket(this);
	m_hwnd=m_wnd.GetSafeHwnd();
	
	int ret=WSocket::Create(port,ip);

	if((ret!=INVALID_SOCKET)&&(ret!=SOCKET_ERROR))
	{
		// Do the asyncselect crap
		ret=AsyncSelect(FD_ALL_EVENTS);
	}

	return ret;
}
Exemple #18
0
BOOL CAsynSocket::Attach(SOCKET hSocket, long lEvent)
{
	ASSERT(hSocket != INVALID_SOCKET);

	m_hSocket = hSocket;

	m_pSocketWnd = new CSocketWnd(this);
	m_pSocketWnd->m_hWnd = NULL;
	if (!m_pSocketWnd->CreateEx(0, AfxRegisterWndClass(0), 
		_T(""), WS_OVERLAPPED, 0, 0, 0, 0, NULL, NULL))
	{
		TRACE0("Warning: unable to create socket notify window!\n");
		return FALSE;
	}

	return AsyncSelect(lEvent);
}
void CClientSocket::OnConnect(int nErrorCode)
{
	// TODO:  在此添加专用代码和/或调用基类
	if (nErrorCode == 0)
	{
		my_bConnected = TRUE;
		C客户端App *pApp = (C客户端App*)AfxGetApp();
		C客户端Dlg *pDlg = (C客户端Dlg*)pApp->m_pMainWnd;
		CString temp = L"连接到:";
		temp += pDlg->my_ServerAddr;
		pDlg->m_MsgR.InsertString(0, temp);
		pDlg->GetDlgItem(IDC_SEND)->EnableWindow(true);
		AsyncSelect(FD_READ);
	}

	CAsyncSocket::OnConnect(nErrorCode);
}
Exemple #20
0
CEMSocket::~CEMSocket(){
	EMTrace("CEMSocket::~CEMSocket() on %d",(SOCKET)this);

    // need to be locked here to know that the other methods
    // won't be in the middle of things
    sendLocker.Lock();
	byConnected = ES_DISCONNECTED;
    sendLocker.Unlock();

    // now that we know no other method will keep adding to the queue
    // we can remove ourself from the queue
    theApp.uploadBandwidthThrottler->RemoveFromAllQueues(this);

    ClearQueues();
	RemoveAllLayers(); // deadlake PROXYSUPPORT
	AsyncSelect(0);
}
Exemple #21
0
void CGnuUpdateSock::Close()
{
	if(m_SocketData.hSocket != INVALID_SOCKET)
	{
		AsyncSelect(0);
		ShutDown(2);

		CAsyncSocketEx::Close();
	}

	m_Status = TRANSFER_CLOSED;
	
	if(m_BytesCompleted)
		if(m_BytesCompleted == m_FileSize)
			m_Status = TRANSFER_COMPLETED;

	m_File.Abort();

	
}
Exemple #22
0
WAsyncSocket::~WAsyncSocket()
{
	AsyncSelect(0);	// turn off all async notifications
	m_wnd.DestroyWindow();
}
Exemple #23
0
// pach2:
// written this overriden Receive to handle transparently FIN notifications coming from calls to recv()
// This was maybe(??) the cause of a lot of socket error, notably after a brutal close from peer
// also added trace so that we can debug after the fact ...
int CEMSocket::Receive(void* lpBuf, int nBufLen, int nFlags)
{
//	EMTrace("CEMSocket::Receive on %d, maxSize=%d",(SOCKET)this,nBufLen);
    int recvRetCode = CEncryptedStreamSocket::Receive(lpBuf,nBufLen,nFlags); // deadlake PROXYSUPPORT - changed to AsyncSocketEx
    switch (recvRetCode)
    {
    case 0:
        if (GetRealReceivedBytes() > 0) // we received data but it was for the underlying encryption layer - all fine
            return 0;
        //EMTrace("CEMSocket::##Received FIN on %d, maxSize=%d",(SOCKET)this,nBufLen);
        // FIN received on socket // Connection is being closed by peer
        //ASSERT (false);
        if ( 0 == AsyncSelect(FD_CLOSE|FD_WRITE) )
        { // no more READ notifications ...
            //int waserr = GetLastError(); // oups, AsyncSelect failed !!!
            ASSERT(false);
        }
        return 0;
    case SOCKET_ERROR:
        switch (GetLastError())
        {
        case WSANOTINITIALISED:
            ASSERT(false);
            EMTrace("CEMSocket::OnReceive:A successful AfxSocketInit must occur before using this API.");
            break;
        case WSAENETDOWN:
            ASSERT(true);
            EMTrace("CEMSocket::OnReceive:The socket %d received a net down error",(SOCKET)this);
            break;
        case WSAENOTCONN: // The socket is not connected.
            EMTrace("CEMSocket::OnReceive:The socket %d is not connected",(SOCKET)this);
            break;
        case WSAEINPROGRESS:   // A blocking Windows Sockets operation is in progress.
            EMTrace("CEMSocket::OnReceive:The socket %d is blocked",(SOCKET)this);
            break;
        case WSAEWOULDBLOCK:   // The socket is marked as nonblocking and the Receive operation would block.
            EMTrace("CEMSocket::OnReceive:The socket %d would block",(SOCKET)this);
            break;
        case WSAENOTSOCK:   // The descriptor is not a socket.
            EMTrace("CEMSocket::OnReceive:The descriptor %d is not a socket (may have been closed or never created)",(SOCKET)this);
            break;
        case WSAEOPNOTSUPP:  // MSG_OOB was specified, but the socket is not of type SOCK_STREAM.
            break;
        case WSAESHUTDOWN:   // The socket has been shut down; it is not possible to call Receive on a socket after ShutDown has been invoked with nHow set to 0 or 2.
            EMTrace("CEMSocket::OnReceive:The socket %d has been shut down",(SOCKET)this);
            break;
        case WSAEMSGSIZE:   // The datagram was too large to fit into the specified buffer and was truncated.
            EMTrace("CEMSocket::OnReceive:The datagram was too large to fit and was truncated (socket %d)",(SOCKET)this);
            break;
        case WSAEINVAL:   // The socket has not been bound with Bind.
            EMTrace("CEMSocket::OnReceive:The socket %d has not been bound",(SOCKET)this);
            break;
        case WSAECONNABORTED:   // The virtual circuit was aborted due to timeout or other failure.
            EMTrace("CEMSocket::OnReceive:The socket %d has not been bound",(SOCKET)this);
            break;
        case WSAECONNRESET:   // The virtual circuit was reset by the remote side.
            EMTrace("CEMSocket::OnReceive:The socket %d has not been bound",(SOCKET)this);
            break;
        default:
            EMTrace("CEMSocket::OnReceive:Unexpected socket error %x on socket %d",GetLastError(),(SOCKET)this);
            break;
        }
        break;
    default:
//		EMTrace("CEMSocket::OnReceive on %d, receivedSize=%d",(SOCKET)this,recvRetCode);
        return recvRetCode;
    }
    return SOCKET_ERROR;
}
Exemple #24
0
CGnuLocal::~CGnuLocal()
{
	if(m_hSocket != INVALID_SOCKET)
		AsyncSelect(0);
}
int WAsyncSocket2::Close()
{
	AsyncSelect(0);	// turn off all async notifications
	return WSocket2::Close();
}
Exemple #26
0
SOCKET WAsyncSocket::Detach()
{
	AsyncSelect(0);	// turn off all async notifications
	m_wnd.DestroyWindow();
	return WSocket::Detach();
}