712 lines
15 KiB
C++
712 lines
15 KiB
C++
/*++
|
|
|
|
Copyright (c) 1995-1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
icsocket.hxx
|
|
|
|
Abstract:
|
|
|
|
Contains types, manifests, prototypes for Internet Socket Class (ICSocket)
|
|
functions and methods (in common\icsocket.cxx)
|
|
|
|
Author:
|
|
|
|
Richard L Firth (rfirth) 24-May-1995
|
|
|
|
Revision History:
|
|
|
|
24-May-1995 rfirth
|
|
Created
|
|
|
|
20-March-1996 arthurbi
|
|
Created the CSOCKET class.
|
|
|
|
08-Apr-1997 rfirth
|
|
Changed to ICSocket class (Internet CSocket to avoid issues with MFC).
|
|
Base socket implementation. Secure sockets is a derived class in
|
|
ssocket.hxx/.cxx
|
|
|
|
--*/
|
|
|
|
//
|
|
// manifests
|
|
//
|
|
|
|
#define HOST_INADDR_ANY 0x00000000
|
|
#define HOST_INADDR_NONE 0xffffffff
|
|
#define HOST_INADDR_LOOPBACK 0x0100007f
|
|
|
|
//
|
|
// common flags for ConnectSocket(), SocketSend(), SocketReceive(),
|
|
// SocketDataAvailable()
|
|
//
|
|
|
|
#define SF_ENCRYPT 0x00000001 // encrypt data (send)
|
|
#define SF_DECRYPT 0x00000002 // decrypt data (receive)
|
|
#define SF_EXPAND 0x00000004 // input buffer can be expanded to fit (receive)
|
|
#define SF_COMPRESS 0x00000008 // input buffer can be compressed to fit (receive)
|
|
#define SF_RECEIVE_ALL 0x00000010 // loop until buffer full/all data received (receive)
|
|
#define SF_INDICATE 0x00000020 // provide status callbacks
|
|
#define SF_NON_BLOCKING 0x00000040 // socket is non-blocking
|
|
#define SF_WAIT 0x00000080 // wait for data if non-blocking
|
|
#define SF_IGNORE_CONNRESET 0x00000100 // SPX_SUPPORT
|
|
#define SF_SENDING_DATA 0x00000200 // data is being sent through the socket, errors may now apply.
|
|
#define SF_SCH_REDO 0x00000400 // schannel is redone.
|
|
#define SF_CONNECTIONLESS 0x00000800 // send/receive datagrams
|
|
#define SF_EXPEDITED 0x00001000 // function expected to complete quickly (test with select())
|
|
#define SF_AUTHORIZED 0x00002000 // set if we added an authorization header
|
|
#define SF_RANDOM 0x00004000 // set if we connect to address list entry chosen at random
|
|
#define SF_FORCE 0x00008000 // set if the name must be resolved (ResolveHost)
|
|
#define SF_SECURE 0x00010000 // set if this is a secure (SSL/PCT) socket object
|
|
#define SF_NO_WAIT 0x00020000 // set if one-shot operation required (Receive)
|
|
#define SF_KEEP_ALIVE 0x00040000 // set if connection is keep-alive
|
|
#define SF_PIPELINED 0x00080000 // set if connection is pipelined (HTTP 1.1)
|
|
#define SF_PERUSER 0x00100000 // set if authorization header is added so response marked per-user in shared cache
|
|
#define SF_AUTHENTICATED 0x00200000 // set if authentication was successful on this socket.
|
|
#define SF_TUNNEL 0x00400000 // set if this connection is a nested CONNECT directly to a proxy
|
|
|
|
//
|
|
// types
|
|
//
|
|
|
|
//
|
|
// SOCKET_BUFFER_ID - which socket buffer we are dealing with
|
|
//
|
|
|
|
typedef enum {
|
|
ReceiveBuffer = SO_RCVBUF,
|
|
SendBuffer = SO_SNDBUF
|
|
} SOCKET_BUFFER_ID;
|
|
|
|
//
|
|
// timeout types for SetSocketTimeout
|
|
//
|
|
|
|
#define SEND_TIMEOUT 1
|
|
#define RECEIVE_TIMEOUT 0
|
|
|
|
//
|
|
// macros
|
|
//
|
|
|
|
#define IS_VALID_NON_LOOPBACK_IP_ADDRESS(address) \
|
|
(((address) != HOST_INADDR_ANY) \
|
|
&& ((address) != HOST_INADDR_NONE) \
|
|
&& ((address) != HOST_INADDR_LOOPBACK))
|
|
|
|
//
|
|
// prototypes
|
|
//
|
|
|
|
LPSTR
|
|
MapNetAddressToName(
|
|
IN LPSTR lpszAddress,
|
|
OUT LPSTR * lplpszMappedName
|
|
);
|
|
|
|
//DWORD
|
|
//GetServiceAddress(
|
|
// IN LPSTR HostName,
|
|
// IN DWORD Port,
|
|
// OUT LPADDRESS_INFO_LIST AddressList
|
|
// );
|
|
//
|
|
//BOOL
|
|
//IsNetAddress(
|
|
// IN LPSTR lpszAddress
|
|
// );
|
|
//
|
|
//#if INET_DEBUG
|
|
//
|
|
//DEBUG_FUNCTION
|
|
//VOID
|
|
//InitializeAddressList(
|
|
// IN LPADDRESS_INFO_LIST AddressList
|
|
// );
|
|
//
|
|
//DEBUG_FUNCTION
|
|
//VOID
|
|
//FreeAddressList(
|
|
// IN LPADDRESS_INFO_LIST AddressList
|
|
// );
|
|
//
|
|
//DEBUG_FUNCTION
|
|
//BOOL
|
|
//IsAddressListEmpty(
|
|
// IN LPADDRESS_INFO_LIST AddressList
|
|
// );
|
|
//
|
|
//#else
|
|
//
|
|
//#define InitializeAddressList(AddressList) \
|
|
// (AddressList)->AddressCount = 0; \
|
|
// (AddressList)->Addresses = NULL
|
|
//
|
|
//#define FreeAddressList(AddressList) \
|
|
// if ((AddressList)->AddressCount != 0) { \
|
|
// (AddressList)->Addresses = (LPCSADDR_INFO)FREE_MEMORY((HLOCAL)((AddressList)->Addresses)); \
|
|
// (AddressList)->AddressCount = 0; \
|
|
// }
|
|
//
|
|
//#define IsAddressListEmpty(AddressList) \
|
|
// (((AddressList)->AddressCount == 0) ? TRUE : FALSE)
|
|
//
|
|
//#endif // INET_DEBUG
|
|
//
|
|
//DWORD
|
|
//DestinationAddressFromAddressList(
|
|
// IN LPADDRESS_INFO_LIST lpAddressList,
|
|
// IN DWORD dwIndex,
|
|
// OUT LPBYTE lpbDestinationAddress,
|
|
// IN OUT LPDWORD lpdwDestinationAddressLength
|
|
// );
|
|
//
|
|
//DWORD
|
|
//InterfaceAddressFromSocket(
|
|
// IN SOCKET Socket,
|
|
// OUT LPBYTE lpbInterfaceAddress,
|
|
// IN OUT LPDWORD lpdwInterfaceAddressLength
|
|
// );
|
|
|
|
//
|
|
// classes
|
|
//
|
|
|
|
//
|
|
// forward references
|
|
//
|
|
|
|
class CFsm_SocketConnect;
|
|
class CFsm_SocketSend;
|
|
class CFsm_SocketReceive;
|
|
class CServerInfo;
|
|
|
|
//
|
|
// ICSocket - abstracts a TCP/IP connection
|
|
//
|
|
|
|
class ICSocket {
|
|
|
|
protected:
|
|
|
|
LIST_ENTRY m_List; // keep-alive list
|
|
DWORD m_dwTimeout; // keep-alive expiry
|
|
BOOL m_fTimeoutWraps;
|
|
LONG m_ReferenceCount;
|
|
SOCKET m_Socket;
|
|
DWORD m_dwFlags;
|
|
INTERNET_PORT m_Port; // needed for keep-alive
|
|
INTERNET_PORT m_SourcePort;
|
|
BOOL m_bAborted;
|
|
DWORD m_SocksAddress;
|
|
INTERNET_PORT m_SocksPort;
|
|
//HINTERNET m_hRequest;
|
|
BOOL m_fExemptConnLImit;
|
|
|
|
#if INET_DEBUG
|
|
|
|
#define ICSOCKET_SIGNATURE 0x6b636f53 // "Sock"
|
|
|
|
DWORD m_Signature;
|
|
|
|
#define SIGN_ICSOCKET() \
|
|
m_Signature = ICSOCKET_SIGNATURE
|
|
|
|
#define CHECK_ICSOCKET() \
|
|
INET_ASSERT((m_Signature == ICSOCKET_SIGNATURE) || (m_Signature == SECURE_SOCKET_SIGNATURE))
|
|
|
|
#else
|
|
|
|
#define SIGN_ICSOCKET() \
|
|
/* NOTHING */
|
|
|
|
#define CHECK_ICSOCKET() \
|
|
/* NOTHING */
|
|
|
|
#endif
|
|
|
|
public:
|
|
|
|
ICSocket();
|
|
|
|
virtual ~ICSocket();
|
|
|
|
void ExemptConnLimit(void) {
|
|
m_fExemptConnLImit = TRUE;
|
|
}
|
|
|
|
BOOL ConnLimitExempted(void) const {
|
|
return m_fExemptConnLImit;
|
|
}
|
|
|
|
void ResetExemptFlag(void) {
|
|
m_fExemptConnLImit = FALSE;
|
|
}
|
|
VOID
|
|
Destroy(
|
|
VOID
|
|
);
|
|
|
|
PLIST_ENTRY List(VOID) {
|
|
return &m_List;
|
|
}
|
|
|
|
PLIST_ENTRY Next(VOID) {
|
|
return m_List.Flink;
|
|
}
|
|
|
|
BOOL IsOnList(VOID) {
|
|
return ((m_List.Flink == NULL) && (m_List.Blink == NULL)) ? FALSE : TRUE;
|
|
}
|
|
|
|
VOID
|
|
Reference(
|
|
VOID
|
|
);
|
|
|
|
BOOL
|
|
Dereference(
|
|
VOID
|
|
);
|
|
|
|
LONG ReferenceCount(VOID) const {
|
|
return m_ReferenceCount;
|
|
}
|
|
|
|
BOOL IsValid(VOID) {
|
|
return (m_Socket != INVALID_SOCKET) ? TRUE : FALSE;
|
|
}
|
|
|
|
BOOL IsInvalid(VOID) {
|
|
return !IsValid();
|
|
}
|
|
|
|
BOOL IsOpen(VOID) {
|
|
return IsValid();
|
|
}
|
|
|
|
BOOL IsClosed(VOID) {
|
|
return !IsOpen();
|
|
}
|
|
|
|
SOCKET GetSocket(VOID) const {
|
|
return m_Socket;
|
|
}
|
|
|
|
VOID SetSocket(SOCKET Socket) {
|
|
m_Socket = Socket;
|
|
}
|
|
|
|
BOOL IsNonBlocking(VOID) {
|
|
return (m_dwFlags & SF_NON_BLOCKING) ? TRUE : FALSE;
|
|
}
|
|
|
|
BOOL IsSecure(VOID) const {
|
|
return (m_dwFlags & SF_SECURE) ? TRUE : FALSE;
|
|
}
|
|
|
|
VOID SetEncryption(VOID) {
|
|
m_dwFlags |= SF_ENCRYPT | SF_DECRYPT;
|
|
}
|
|
|
|
VOID ResetEncryption(VOID) {
|
|
m_dwFlags &= ~(SF_ENCRYPT | SF_DECRYPT);
|
|
}
|
|
|
|
DWORD GetFlags(VOID) const {
|
|
return m_dwFlags;
|
|
}
|
|
|
|
VOID SetAuthorized(VOID) {
|
|
m_dwFlags |= SF_AUTHORIZED;
|
|
}
|
|
|
|
BOOL IsAuthorized(VOID) {
|
|
return (m_dwFlags & SF_AUTHORIZED) ? TRUE : FALSE;
|
|
}
|
|
|
|
VOID SetAuthenticated(VOID) {
|
|
m_dwFlags |= SF_AUTHENTICATED;
|
|
}
|
|
|
|
BOOL IsAuthenticated(VOID) {
|
|
return (m_dwFlags & SF_AUTHENTICATED) ? TRUE : FALSE;
|
|
}
|
|
|
|
VOID SetPerUser (VOID) {
|
|
m_dwFlags |= SF_PERUSER;
|
|
}
|
|
|
|
BOOL IsPerUser(VOID) {
|
|
return (m_dwFlags & SF_PERUSER) ? TRUE : FALSE;
|
|
}
|
|
|
|
VOID SetKeepAlive(VOID) {
|
|
m_dwFlags |= SF_KEEP_ALIVE;
|
|
}
|
|
|
|
VOID ResetKeepAlive(VOID) {
|
|
m_dwFlags &= ~SF_KEEP_ALIVE;
|
|
}
|
|
|
|
BOOL IsKeepAlive(VOID) {
|
|
return (m_dwFlags & SF_KEEP_ALIVE) ? TRUE : FALSE;
|
|
}
|
|
|
|
VOID SetPipelined(VOID) {
|
|
m_dwFlags |= SF_PIPELINED;
|
|
}
|
|
|
|
VOID ResetPipelined(VOID) {
|
|
m_dwFlags &= ~SF_PIPELINED;
|
|
}
|
|
|
|
BOOL IsPipelined(VOID) {
|
|
return (m_dwFlags & SF_PIPELINED) ? TRUE : FALSE;
|
|
}
|
|
|
|
BOOL Match(DWORD dwFlags) {
|
|
return ((m_dwFlags & dwFlags) == dwFlags) ? TRUE : FALSE;
|
|
}
|
|
|
|
virtual BOOL MatchTunnelSemantics(DWORD dwFlags, LPSTR pszHostName = NULL) {
|
|
return ((m_dwFlags & SF_TUNNEL) == (dwFlags & SF_TUNNEL)) ? TRUE : FALSE;
|
|
}
|
|
|
|
VOID SetPort(INTERNET_PORT Port) {
|
|
m_Port = Port;
|
|
}
|
|
|
|
INTERNET_PORT GetPort(VOID) const {
|
|
return m_Port;
|
|
}
|
|
|
|
VOID SetSourcePort(VOID);
|
|
|
|
VOID SetSourcePort(INTERNET_PORT Port) {
|
|
m_SourcePort = Port;
|
|
}
|
|
|
|
INTERNET_PORT GetSourcePort(VOID) const {
|
|
return m_SourcePort;
|
|
}
|
|
|
|
VOID SetAborted(VOID) {
|
|
m_bAborted = TRUE;
|
|
}
|
|
|
|
BOOL IsAborted(VOID) const {
|
|
return m_bAborted;
|
|
}
|
|
|
|
DWORD
|
|
GetServiceAddress(
|
|
IN LPSTR HostName,
|
|
IN DWORD Port
|
|
);
|
|
|
|
virtual
|
|
DWORD
|
|
Connect(
|
|
IN LONG Timeout,
|
|
IN INT Retries,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
DWORD
|
|
SocketConnect(
|
|
IN LONG Timeout,
|
|
IN INT Retries,
|
|
IN DWORD dwFlags,
|
|
IN CServerInfo *pServerInfo
|
|
);
|
|
|
|
DWORD
|
|
Connect_Start(
|
|
IN CFsm_SocketConnect * Fsm
|
|
);
|
|
|
|
DWORD
|
|
Connect_Continue(
|
|
IN CFsm_SocketConnect * Fsm
|
|
);
|
|
|
|
DWORD
|
|
Connect_Error(
|
|
IN CFsm_SocketConnect * Fsm
|
|
);
|
|
|
|
DWORD
|
|
Connect_Finish(
|
|
IN CFsm_SocketConnect * Fsm
|
|
);
|
|
|
|
int
|
|
SocksConnect(
|
|
IN LPSOCKADDR_IN pSockaddr,
|
|
IN INT nLen
|
|
);
|
|
|
|
virtual
|
|
DWORD
|
|
Disconnect(
|
|
IN DWORD dwFlags = 0
|
|
);
|
|
|
|
DWORD
|
|
Close(
|
|
VOID
|
|
);
|
|
|
|
DWORD
|
|
Abort(
|
|
VOID
|
|
);
|
|
|
|
DWORD
|
|
Shutdown(
|
|
IN DWORD dwControl
|
|
);
|
|
|
|
BOOL
|
|
IsReset(
|
|
VOID
|
|
);
|
|
|
|
virtual
|
|
DWORD
|
|
Send(
|
|
IN LPVOID lpBuffer,
|
|
IN DWORD dwBufferLength,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
DWORD
|
|
Send_Start(
|
|
IN CFsm_SocketSend * Fsm
|
|
);
|
|
|
|
virtual
|
|
DWORD
|
|
Receive(
|
|
IN OUT LPVOID* lplpBuffer,
|
|
IN OUT LPDWORD lpdwBufferLength,
|
|
IN OUT LPDWORD lpdwBufferRemaining,
|
|
IN OUT LPDWORD lpdwBytesReceived,
|
|
IN DWORD dwExtraSpace,
|
|
IN DWORD dwFlags,
|
|
OUT LPBOOL lpbEof
|
|
);
|
|
|
|
DWORD
|
|
Receive_Start(
|
|
IN CFsm_SocketReceive * Fsm
|
|
);
|
|
|
|
DWORD
|
|
Receive_Continue(
|
|
IN CFsm_SocketReceive * Fsm
|
|
);
|
|
|
|
DWORD
|
|
Receive_Finish(
|
|
IN CFsm_SocketReceive * Fsm
|
|
);
|
|
|
|
DWORD
|
|
SetTimeout(
|
|
IN DWORD Type,
|
|
IN int Timeout
|
|
);
|
|
|
|
DWORD
|
|
SetLinger(
|
|
IN BOOL Linger,
|
|
IN int Timeout
|
|
);
|
|
|
|
DWORD
|
|
SetNonBlockingMode(
|
|
IN BOOL bNonBlocking
|
|
);
|
|
|
|
DWORD
|
|
GetBufferLength(
|
|
IN SOCKET_BUFFER_ID SocketBufferId
|
|
);
|
|
|
|
DWORD
|
|
GetBufferLength(
|
|
IN SOCKET_BUFFER_ID SocketBufferId,
|
|
OUT LPDWORD lpdwBufferLength
|
|
);
|
|
|
|
DWORD
|
|
SetBufferLength(
|
|
IN SOCKET_BUFFER_ID SocketBufferId,
|
|
IN DWORD dwBufferLength
|
|
);
|
|
|
|
DWORD
|
|
SetSendCoalescing(
|
|
IN BOOL bOnOff
|
|
);
|
|
|
|
// This code needs to handle system time roll over.
|
|
// SetExpireTime is passed the duration, and we calculate the ultimate time
|
|
// However, this may result in a rollover -- e.g. if the current time is
|
|
// 0xffffff00, the ultimate time could be 0x000000fd
|
|
|
|
// HasExpired is passed the current tick count, however, and in the past
|
|
// would return TRUE immediately.
|
|
// Thus we set a flag is we need to wait for system time rollover to happen,
|
|
|
|
VOID
|
|
SetExpiryTime(
|
|
IN DWORD dwTimeout = GlobalKeepAliveSocketTimeout
|
|
) {
|
|
DWORD dw = GetTickCountWrap();
|
|
m_dwTimeout = dw + dwTimeout;
|
|
m_fTimeoutWraps = (m_dwTimeout < dw);
|
|
}
|
|
|
|
DWORD GetExpiryTime(VOID) const {
|
|
return m_dwTimeout;
|
|
}
|
|
|
|
BOOL HasExpired(
|
|
IN DWORD dwTime = GetTickCountWrap()
|
|
) {
|
|
if (m_fTimeoutWraps)
|
|
{
|
|
m_fTimeoutWraps = ((LONG)dwTime < 0);
|
|
}
|
|
return ((m_dwTimeout == 0) || m_fTimeoutWraps)
|
|
? FALSE
|
|
: (dwTime > m_dwTimeout);
|
|
}
|
|
|
|
DWORD
|
|
DataAvailable(
|
|
OUT LPDWORD lpdwDataAvailable
|
|
);
|
|
|
|
DWORD
|
|
DataAvailable2(
|
|
OUT LPVOID lpBuffer,
|
|
IN DWORD dwBufferLength,
|
|
OUT LPDWORD lpdwBytesAvailable
|
|
);
|
|
|
|
DWORD
|
|
WaitForReceive(
|
|
IN DWORD Timeout
|
|
);
|
|
|
|
DWORD
|
|
AllocateQueryBuffer(
|
|
OUT LPVOID * lplpBuffer,
|
|
OUT LPDWORD lpdwBufferLength
|
|
);
|
|
|
|
VOID
|
|
FreeQueryBuffer(
|
|
IN LPVOID lpBuffer
|
|
);
|
|
|
|
DWORD
|
|
EnableSocks(
|
|
IN LPSTR lpSocksHost,
|
|
IN INTERNET_PORT ipSocksPort
|
|
);
|
|
|
|
BOOL IsSocks(VOID) {
|
|
return m_SocksAddress != 0;
|
|
}
|
|
|
|
DWORD
|
|
CreateSocket(
|
|
IN DWORD dwFlags,
|
|
IN int nFamily,
|
|
IN int nType,
|
|
IN int nProtocol
|
|
);
|
|
|
|
DWORD
|
|
GetSockName(
|
|
IN PSOCKADDR psaSockName,
|
|
IN int SockNameSize
|
|
);
|
|
|
|
DWORD
|
|
GetPeerName(
|
|
IN PSOCKADDR psaSockName,
|
|
IN int SockNameSize
|
|
);
|
|
|
|
DWORD
|
|
Listen(
|
|
VOID
|
|
);
|
|
|
|
DWORD
|
|
DirectConnect(
|
|
IN PSOCKADDR psaRemoteSock
|
|
);
|
|
|
|
DWORD
|
|
SelectAccept(
|
|
IN ICSocket & acceptSocket,
|
|
IN DWORD dwTimeout
|
|
);
|
|
|
|
DWORD
|
|
GetBytesAvailable(
|
|
OUT LPDWORD lpdwBytesAvailable
|
|
);
|
|
|
|
//VOID
|
|
//SetServiceAddress(
|
|
// IN LPADDRESS_INFO_LIST AddressList
|
|
// )
|
|
//{
|
|
// m_fOwnAddressList = FALSE;
|
|
// m_AddressList.Addresses = AddressList->Addresses;
|
|
// m_AddressList.AddressCount = AddressList->AddressCount;
|
|
//}
|
|
|
|
//DWORD
|
|
//GetServiceAddress(
|
|
// IN LPSTR HostName OPTIONAL,
|
|
// IN LPSTR ServiceName OPTIONAL,
|
|
// IN LPGUID ServiceGuid OPTIONAL,
|
|
// IN DWORD NameSpace,
|
|
// IN DWORD Port,
|
|
// IN DWORD ProtocolCharacteristics
|
|
// )
|
|
//{
|
|
// return ::GetServiceAddress(
|
|
// HostName,
|
|
// ServiceName,
|
|
// ServiceGuid,
|
|
// NameSpace,
|
|
// Port,
|
|
// ProtocolCharacteristics,
|
|
// &m_AddressList
|
|
// );
|
|
//}
|
|
|
|
|
|
//
|
|
// friend functions
|
|
//
|
|
|
|
friend
|
|
ICSocket *
|
|
ContainingICSocket(
|
|
LPVOID lpAddress
|
|
);
|
|
};
|