csock.cpp

早期的WINDOWS编程,适合刚接触WINDOWS编程的初学者

{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::gethostname\n");
#endif
		int ihostname = ::gethostname(name,namelen);
		m_iLastError = ::GetLastError();
		if (ihostname == SOCKET_ERROR){
			WS_TRACE0("gethostname error:");
			PrintError(m_iLastError);
		}
		return ihostname;
}

//Debug version of getprotobyname
//See CSock.h for an MFC definition using CString instead of LPCSTR
PPROTOENT CWinSock::getprotobyname(LPCSTR name)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::getprotobyname\n");
#endif
		PPROTOENT pprotoent = ::getprotobyname(name);
		m_iLastError = ::GetLastError();
		if (pprotoent == NULL){
			WS_TRACE0("getprotobyname error:");
			PrintError(m_iLastError);
		}
		return pprotoent;
}

//Debug version of getprotobynumber
PPROTOENT CWinSock::getprotobynumber(int number)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::getprotobynumber\n");
#endif
		PPROTOENT pprotoent = ::getprotobynumber(number);
		m_iLastError = ::GetLastError();
		if (pprotoent == NULL){
			WS_TRACE0("getprotobynumber error:");
			PrintError(m_iLastError);
		}
		return pprotoent;
}

//Debug version of getservbyname
//See CSock.h for an MFC definition using CString instead of LPCSTR
PSERVENT CWinSock::getservbyname(LPCSTR name, LPCSTR proto)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::getservbyname\n");
#endif
		PSERVENT pservent = ::getservbyname(name,proto);
		m_iLastError = ::GetLastError();
		if (pservent == NULL){
			WS_TRACE0("getservbyname error:");
			PrintError(m_iLastError);
		}
		return pservent;
}

//Debug version of getservbyport
//See CSock.h for an MFC definition using CString instead of LPCSTR
PSERVENT CWinSock::getservbyport(int port, LPCSTR proto)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::getservbyport\n");
#endif
		PSERVENT pservent = ::getservbyport(port,proto);
		m_iLastError = ::GetLastError();
		if (pservent == NULL){
			WS_TRACE0("getservbyport error:");
			PrintError(m_iLastError);
		}
		return pservent;
}

//Debug version of WSAAsyncGetHostByAddr
HANDLE CWinSock::WSAAsyncGetHostByAddr(HWND hWnd,
   								unsigned int wMsg, 
                                LPCSTR addr,
                                int len,
                                int type,
                                LPTSTR buf,
                                int buflen)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAAsyncGetHostByAddr\n");
#endif
		if (hWnd != NULL){
			if (!IsWindow(hWnd))
				WS_TRACE0("CWinSock::WSAAsyncGetHostByAddr was passed an invalid window handle\n");
		}

		HANDLE hRet = ::WSAAsyncGetHostByAddr(hWnd, wMsg, addr, len, type, buf, buflen);
		m_iLastError = ::GetLastError();
		if (hRet == 0){
			WS_TRACE0("WSAAsyncGetHostByAddr error:");
			PrintError(m_iLastError);
		}
		return hRet;
}

//Debug version of WSAAsyncGetHostByName
HANDLE CWinSock::WSAAsyncGetHostByName(HWND hWnd,
   								unsigned int wMsg,
                                LPCSTR name,
                                LPTSTR buf,
                                int buflen)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAAsyncGetHostByName\n");
#endif
		if (hWnd != NULL){
			if (!IsWindow(hWnd))
				WS_TRACE0("CWinSock::WSAAsyncGetHostByName was passed an invalid window handle\n");
		}

		HANDLE hRet = ::WSAAsyncGetHostByName(hWnd, wMsg, name, buf, buflen);
		m_iLastError = ::GetLastError();
		if (hRet == 0){
			WS_TRACE0("WSAAsyncGetHostByName error:");
			PrintError(m_iLastError);
		}
		return hRet;
}

//Debug version of WSAAsyncGetProtoByName
HANDLE CWinSock::WSAAsyncGetProtoByName(HWND hWnd, 
   								 unsigned int wMsg,
                                 LPCSTR name,
                                 LPTSTR buf,
                                 int buflen)

{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAAsyncGetProtoByName\n");
#endif
		if (hWnd != NULL){
			if (!IsWindow(hWnd))
				WS_TRACE0("CWinSock::WSAAsyncGetProtoByName was passed an invalid window handle\n");
		}

		HANDLE hRet = ::WSAAsyncGetProtoByName(hWnd, wMsg, name, buf, buflen);
		m_iLastError = ::GetLastError();
		if (hRet == 0){
			WS_TRACE0("WSAAsyncGetProtoByName error:");
			PrintError(m_iLastError);
		}
		return hRet;
}

//Debug version of WSAAsyncGetProtoByNumber
HANDLE CWinSock::WSAAsyncGetProtoByNumber( HWND hWnd,
   									unsigned int wMsg,
									int number,
									LPTSTR buf,
									int buflen)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAAsyncGetProtoByNumber\n");
#endif
		if (hWnd != NULL){
			if (!IsWindow(hWnd))
				WS_TRACE0("CWinSock::WSAAsyncGetProtoByNumber was passed an invalid window handle\n");
		}

		HANDLE hRet = ::WSAAsyncGetProtoByNumber(hWnd, wMsg, number, buf, buflen);
		m_iLastError = ::GetLastError();
		if (hRet == 0){
			WS_TRACE0("WSAAsyncGetProtoByNumber error:");
			PrintError(m_iLastError);
		}
		return hRet;
}

//Debug version of WSAAsyncGetServByName
HANDLE CWinSock::WSAAsyncGetServByName(HWND hWnd, 
   								unsigned int wMsg,
                                LPCSTR name,
                                LPCSTR proto,
                                LPTSTR buf,
                                int buflen)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAAsyncGetServByName\n");
#endif
		if (hWnd != NULL){
			if (!IsWindow(hWnd))
				WS_TRACE0("CWinSock::WSAAsyncGetServByName was passed an invalid window handle\n");
		}

		HANDLE hRet = ::WSAAsyncGetServByName(hWnd, wMsg, name, proto, buf, buflen);
		m_iLastError = ::GetLastError();
		if (hRet == 0){
			WS_TRACE0("WSAAsyncGetServByName error:");
			PrintError(m_iLastError);
		}
		return hRet;
}

//Debug version of WSAAsyncGetServByPort
HANDLE CWinSock::WSAAsyncGetServByPort(HWND hWnd,
   								unsigned int wMsg,
                                int port,
                                LPCSTR proto,
                                LPTSTR buf,
                                int buflen)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAAsyncGetServByPort\n");
#endif
		if (hWnd != NULL){
			if (!IsWindow(hWnd))
				WS_TRACE0("CWinSock::WSAAsyncGetServByPort was passed an invalid window handle\n");
		}

		HANDLE hRet = ::WSAAsyncGetServByPort(hWnd, wMsg, port, proto, buf, buflen);
		m_iLastError = ::GetLastError();
		if (hRet == 0){
			WS_TRACE0("WSAAsyncGetServByPort error:");
			PrintError(m_iLastError);
		}
		return hRet;
}

//Debug version of WSAAsyncSelect
int CWinSock::WSAAsyncSelect(SOCKET s, HWND hWnd, unsigned int wMsg, long lEvent)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAAsyncSelect\n");
#endif
		if (hWnd != NULL){
			if (!IsWindow(hWnd))
				WS_TRACE0("CWinSock::WSAAsyncSelect was passed an invalid window handle\n");
		}

		int iRet = ::WSAAsyncSelect(s, hWnd, wMsg, lEvent);
		m_iLastError = ::GetLastError();
		if (iRet == SOCKET_ERROR){
			WS_TRACE0("WSAAsyncSelect error:");
			PrintError(m_iLastError);
		}
		return iRet;
}

//Debug version of WSACancelAsyncRequest
int CWinSock::WSACancelAsyncRequest(HANDLE hAsyncTaskHandle)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSACancelAsyncRequest\n");
#endif

		int iRet = ::WSACancelAsyncRequest(hAsyncTaskHandle);
		m_iLastError = ::GetLastError();
		if (iRet == SOCKET_ERROR){
			WS_TRACE0("WSACancelAsyncRequest error:");
			PrintError(m_iLastError);
		}
		return iRet;
}

//Debug version of WSACleanup
int CWinSock::WSACleanup(void)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSACleanup\n");
#endif

		int iRet = ::WSACleanup();
		m_iLastError = ::GetLastError();
		if (iRet == SOCKET_ERROR){
			WS_TRACE0("WSACleanup error:");
			PrintError(m_iLastError);
		}
		return iRet;
}

//Debug version of WSAGetLastError
//NOTICE: The debug version of this API DOES NOT CALL WSAGetLastError
//Instead it uses an internal variable which contains the last error
//If you absolutely want to call WSAGetLastError in the debug version
//call ::WSAGetLastError instead
//You must call ::WSAGetLastError if you called a Winsock API directly instead
//of the Winsock API from this class
int CWinSock::WSAGetLastError(void)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAGetLastError\n");
#endif
	return m_iLastError;
}

//Debug version of WSAIsBlocking
BOOL CWinSock::WSAIsBlocking(void)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAIsBlocking\n");
#endif
	return ::WSAIsBlocking();
}

//Debug version of WSASetBlockingHook
//This API is not needed (although it can be used) in Windows NT or Windows 95
FARPROC CWinSock::WSASetBlockingHook(FARPROC lpBlockFunc)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSASetBlockingHook\n");
#endif

		FARPROC fpHook = ::WSASetBlockingHook(lpBlockFunc);
		m_iLastError = ::GetLastError();
		if (fpHook == NULL){
			WS_TRACE0("WSASetBlockingHook error:");
			PrintError(m_iLastError);
		}
		return fpHook;
}

//Debug version of WSASetLastError
//Note: m_iLastError is also set by this call so that WSAGetLastError will return
//the error code which you set
void CWinSock::WSASetLastError(int iError)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSASetLastError\n");
#endif

		m_iLastError = iError;
		::WSASetLastError(iError);
}

//Debug version of WSAStartup
//Although included, you should not call this API directly, it is already called
//in the constructor.
int CWinSock::WSAStartup(WORD wVersionRequired, LPWSADATA lpWSAData)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAStartup\n");
#endif

		m_iLastError = ::WSAStartup(wVersionRequired, lpWSAData);
		if (m_iLastError != 0){
			WS_TRACE0("WSAStartup error:");
			PrintError(m_iLastError);
		}
		return m_iLastError;
}

//Debug version of WSAUnhookBlockingHook
int CWinSock::WSAUnhookBlockingHook(void)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSAUnhookBlockingHook\n");
#endif

		int iRet = ::WSAUnhookBlockingHook();
		m_iLastError = ::GetLastError();
		if (iRet == SOCKET_ERROR){
			WS_TRACE0("WSAUnhookBlockingHook error:");
			PrintError(m_iLastError);
		}
		return iRet;
}

//The following API is only available in WIN32
//You must also define WSARECVEX to use this API as the beta version
//of Windows95 did not seem to have the correct definition of this API
#ifdef WIN32

#ifdef WSARECVEX
int CWinSock::WSARecvEx(SOCKET s, LPTSTR buf, int len, int *flags)
{
#ifdef _WS_VERBOSE_API
		WS_TRACE0("CWinSock::WSARecvEx\n");
#endif
		int irecv = ::WSARecvEx(s,buf,len,flags);
		m_iLastError = ::GetLastError();
		if (irecv == SOCKET_ERROR){
			WS_TRACE0("WSARecvEx error:");
			PrintError(m_iLastError);
		}
		return irecv;
}
#endif
#endif //Win32
#endif

//Debug version of StringError
//You must define _CaseLoadErrorString for your compiler
//Currently only MFC is supported

#ifdef _AFX
CString CWinSock::StringError(int ErrorCode)
{
	CString	strMessage;
#define _CaseLoadErrorString(x)			case x: strMessage.LoadString(IDS_##x);
#else
TCHAR   strMessage[256];
TCHAR   *CWinSock::StringError(int ErrorCode)
{
#define _CaseLoadErrorString(x)         case x: LoadString(hInstApp,IDS_##x,strMessage,256);
#endif
	switch (ErrorCode){
#ifdef _AFX
	case 0: strMessage = "No Error";
#else
    case 0: lstrcpy(strMessage,"No Error");
#endif
			break;
	_CaseLoadErrorString(WSAEINTR);
			break;
	_CaseLoadErrorString(WSAEBADF);
			break;
	_CaseLoadErrorString(WSAEACCES);
			break;
	_CaseLoadErrorString(WSAEFAULT);
			break;
	_CaseLoadErrorString(WSAEINVAL);
			break;
	_CaseLoadErrorString(WSAEMFILE);
			break;
	_CaseLoadErrorString(WSAEWOULDBLOCK);
			break;
	_CaseLoadErrorString(WSAEINPROGRESS);
			break;
	_CaseLoadErrorString(WSAEALREADY);
			break;
	_CaseLoadErrorString(WSAENOTSOCK);
			break;
	_CaseLoadErrorString(WSAEDESTADDRREQ);
			break;
	_CaseLoadErrorString(WSAEMSGSIZE);
			break;
	_CaseLoadErrorString(WSAEPROTOTYPE);
			break;
	_CaseLoadErrorString(WSAENOPROTOOPT);
			break;
	_CaseLoadErrorString(WSAEPROTONOSUPPORT);
			break;
	_CaseLoadErrorString(WSAESOCKTNOSUPPORT);
			break;
	_CaseLoadErrorString(WSAEOPNOTSUPP);
			break;
	_CaseLoadErrorString(WSAEPFNOSUPPORT);
			break;
	_CaseLoadErrorString(WSAEAFNOSUPPORT);
			break;
	_CaseLoadErrorString(WSAEADDRINUSE);
			break;
	_CaseLoadErrorString(WSAEADDRNOTAVAIL);
			break;
	_CaseLoadErrorString(WSAENETDOWN);
			break;
	_CaseLoadErrorString(WSAENETUNREACH);
			break;
	_CaseLoadErrorString(WSAENETRESET);
			break;
	_CaseLoadErrorString(WSAECONNABORTED);
			break;
	_CaseLoadErrorString(WSAECONNRESET);
			break;
	_CaseLoadErrorString(WSAENOBUFS);
			break;
	_CaseLoadErrorString(WSAEISCONN);
			break;
	_CaseLoadErrorString(WSAENOTCONN);
			break;
	_CaseLoadErrorString(WSAESHUTDOWN);
			break;
	_CaseLoadErrorString(WSAETOOMANYREFS);
			break;
	_CaseLoadErrorString(WSAETIMEDOUT);
			break;
	_CaseLoadErrorString(WSAECONNREFUSED);
			break;
	_CaseLoadErrorString(WSAELOOP);
			break;
	_CaseLoadErrorString(WSAENAMETOOLONG);
			break;
	_CaseLoadErrorString(WSAEHOSTDOWN);
			break;
	_CaseLoadErrorString(WSAEHOSTUNREACH);
			break;
	_CaseLoadErrorString(WSAENOTEMPTY);
			break;
	_CaseLoadErrorString(WSAEPROCLIM);
			break;
	_CaseLoadErrorString(WSAEUSERS);
			break;
	_CaseLoadErrorString(WSAEDQUOT);
			break;
	_CaseLoadErrorString(WSAESTALE);
			break;
	_CaseLoadErrorString(WSAEREMOTE);
			break;
	_CaseLoadErrorString(WSANOTINITIALISED);
			break;
	default:
	#ifdef _AFX
		strMessage.Format("Unknown error %u",ErrorCode);
	#endif
			break;
	}

	return strMessage;
#ifdef _CaseLoadErrorString
#undef _CaseLoadErrorString
#endif
}

//Debug version of PrintError
//Sends the string to the debug window
#ifdef _DEBUG
void CWinSock::PrintError(int ErrorCode)
{
#ifdef _AFX
	CString	strRet = StringError(ErrorCode);
	WS_TRACE1("%s\n",strRet);
#else
    WS_TRACE1(TEXT("%s\n"),(const TCHAR *)StringError(ErrorCode));
#endif
}
#endif	//ifdef _DEBUG