//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/***************************************************************************
** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S **
***************************************************************************
* *
* Project Name : Command & Conquer *
* *
* File Name : TCPIP.CPP *
* *
* Programmer : Steve Tall *
* *
* Start Date : March 11th, 1996 *
* *
* Last Update : March 20th, 1996 [ST] *
* *
*-------------------------------------------------------------------------*
* Overview: *
* *
* Member functions of the TcpipManagerClass which provides the Winsock *
* interface for C&C *
* *
* *
*-------------------------------------------------------------------------*
* Functions: *
* *
* TMC::TcpipManagerClass -- constructor for the TcpipManagerClass *
* TMC::~TcpipManagerClass -- destructor for the TcpipManagerClass *
* TMC::Close -- restores any currently in use Winsock resources *
* TMC::Init -- Initialised Winsock for use. *
* TMC::Start_Server -- Initialise connection and start listening. *
* TMC::Read -- read any pending input from the stream socket *
* TMC::Write -- Send data via the Winsock streaming socket *
* TMC::Add_Client -- A client has requested to connect. *
* TMC::Message_Handler -- Message handler for Winsock. *
* TMC::Set_Host_Address -- Set the address of the host *
* TMC::Start_Client -- Start trying to connect to a game host *
* TMC::Close_Socket -- Close an opened Winsock socket. *
* TMC::Copy_To_In_Buffer -- copy data from our winsock buffer *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
#include "tcpip.h"
#ifdef FORCE_WINSOCK
/*
** Nasty globals
*/
bool Server; //Is this player acting as client or server
TcpipManagerClass Winsock; //The object for interfacing with Winsock
/***********************************************************************************************
* TMC::TcpipManagerClass -- constructor for the TcpipManagerClass *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 2:51PM ST : Created *
*=============================================================================================*/
TcpipManagerClass::TcpipManagerClass(void)
{
WinsockInitialised = FALSE;
Connected = FALSE;
UseUDP = TRUE;
SocketReceiveBuffer = 4096;
SocketSendBuffer = 4096;
}
/***********************************************************************************************
* TMC::~TcpipManagerClass -- destructor for the TcpipManagerClass *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 2:52PM ST : Created *
*=============================================================================================*/
TcpipManagerClass::~TcpipManagerClass(void)
{
Close();
}
/***********************************************************************************************
* TMC::Close -- restores any currently in use Winsock resources *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 2:52PM ST : Created *
*=============================================================================================*/
void TcpipManagerClass::Close(void)
{
/*
** If we never initialised the class in the first place then just return
*/
if (!WinsockInitialised) return;
/*
** Cancel any outstaning asyncronous events
*/
if (Async){
WSACancelAsyncRequest(Async);
}
/*
** Close any open sockets
*/
if (ConnectSocket != INVALID_SOCKET){
Close_Socket(ConnectSocket);
ConnectSocket = INVALID_SOCKET;
}
if (ListenSocket != INVALID_SOCKET){
Close_Socket(ListenSocket);
ListenSocket = INVALID_SOCKET;
}
if (UDPSocket != INVALID_SOCKET){
Close_Socket(ListenSocket);
UDPSocket = INVALID_SOCKET;
}
/*
** Call the Winsock cleanup function to say we are finished using Winsock
*/
WSACleanup();
WinsockInitialised = FALSE;
Connected = FALSE;
}
/***********************************************************************************************
* TMC::Init -- Initialised Winsock for use. *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: TRUE if Winsock is available and was initialised *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 2:54PM ST : Created *
*=============================================================================================*/
BOOL TcpipManagerClass::Init(void)
{
short version;
int rc;
/*
** Just return true if we are already set up
*/
if (WinsockInitialised) return (TRUE);
/*
** Initialise sockets to null
*/
ListenSocket = INVALID_SOCKET;
ConnectSocket =INVALID_SOCKET;
UDPSocket = INVALID_SOCKET;
/*
** Start WinSock, and fill in our WinSockData
*/
version = (WINSOCK_MINOR_VER << 8) | WINSOCK_MAJOR_VER;
rc = WSAStartup(version, &WinsockInfo);
if (rc != 0) {
return (FALSE);
}
/*
** Check the Winsock version number
*/
if ((WinsockInfo.wVersion & 0x00ff) != (version & 0x00ff) ||
(WinsockInfo.wVersion >> 8) != (version >> 8)) {
return (FALSE);
}
/*
** Everything is OK so return success
*/
WinsockInitialised = TRUE;
return (TRUE);
}
/***********************************************************************************************
* TMC::Start_Server -- initialise out connection as the server. Start listening for clients. *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 2:56PM ST : Created *
*=============================================================================================*/
void TcpipManagerClass::Start_Server(void)
{
int i;
//struct sockaddr_in addr;
Start_Client();
/*
** Set up the incoming and outgoing data buffers head and tail pointers
*/
//InBufferHead = 0;
//InBufferTail = 0;
//OutBufferHead= 0;
//OutBufferTail= 0;
TXBufferHead = 0;
TXBufferTail = 0;
RXBufferHead = 0;
RXBufferTail = 0;
for (i=0 ; i<WS_NUM_TX_BUFFERS ; i++){
TransmitBuffers[i].InUse = false;
}
for (i=0 ; i<WS_NUM_RX_BUFFERS ; i++){
ReceiveBuffers[i].InUse = false;
}
/*
** Flag that we are the server side not the client
*/
IsServer = TRUE;
UseUDP = TRUE;
#if (0)
/*
** Create our socket and bind it to our port number
*/
ListenSocket = socket(AF_INET, SOCK_STREAM, 0);
if (ListenSocket == INVALID_SOCKET) {
ConnectStatus = NOT_CONNECTING;
return ;
}
addr.sin_family = AF_INET;
addr.sin_port = htons(PORTNUM);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(ListenSocket, (LPSOCKADDR)&addr, sizeof(addr)) ==
SOCKET_ERROR) {
Close_Socket(ListenSocket);
ConnectStatus = NOT_CONNECTING;
return;
}
/*
** Start listening for connections on this socket
*/
if (listen(ListenSocket, 1) == SOCKET_ERROR) {
Close_Socket(ListenSocket);
ConnectStatus = NOT_CONNECTING;
return;
}
/*
** Select the asynchronous events we want to process
*/
if (WSAAsyncSelect (ListenSocket, MainWindow, WM_ACCEPT, FD_ACCEPT) == SOCKET_ERROR) {
Close_Socket(ListenSocket);
ConnectStatus = NOT_CONNECTING;
return;
}
#endif
ConnectStatus = CONNECTING;
}
/***********************************************************************************************
* TMC::Read -- read any pending input from the stream socket *
* *
* *
* *
* INPUT: ptr to buffer to receive input *
* length of buffer *
* *
* OUTPUT: number of bytes transfered to buffer *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 2:58PM ST : Created *
*=============================================================================================*/
int TcpipManagerClass::Read(void *buffer, int buffer_len)
{
int bytes_copied = 0;
char *dest_buf = (char*) buffer;
/*
** Make sure the message loop gets called because all the Winsock notifications
** are done via messages.
*/
Keyboard::Check();
/*
** Copy any outstanding incoming data to the buffer provided
*/
if (ReceiveBuffers[RXBufferTail].InUse){
memcpy (buffer, ReceiveBuffers[RXBufferTail].Buffer,
MIN(ReceiveBuffers[RXBufferTail].DataLength, buffer_len));
ReceiveBuffers[RXBufferTail].InUse = false;
bytes_copied = MIN(ReceiveBuffers[RXBufferTail++].DataLength, buffer_len);
RXBufferTail &= WS_NUM_RX_BUFFERS-1;
}
return (bytes_copied);
}
/***********************************************************************************************
* TMC::Write -- Send data via the Winsock UDP socket *
* *
* *
* *
* INPUT: ptr to buffer containing data to send *
* length of data to send *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 3:00PM ST : Created *
*=============================================================================================*/
void TcpipManagerClass::Write(void *buffer, int buffer_len)
{
char *source_buf = (char*) buffer;
/*
** Copy the data to one of the classes internal buffers
*/
if (!TransmitBuffers[TXBufferHead].InUse){
memcpy (TransmitBuffers[TXBufferHead].Buffer,
buffer,
MIN (buffer_len, WS_INTERNET_BUFFER_LEN));
TransmitBuffers[TXBufferHead].InUse = true;
TransmitBuffers[TXBufferHead++].DataLength = MIN(buffer_len, WS_INTERNET_BUFFER_LEN);
TXBufferHead &= WS_NUM_TX_BUFFERS-1;
}
/*
** Send a message to ourselves to start off the event
*/
if (UseUDP){
SendMessage(MainWindow, WM_UDPASYNCEVENT, 0, (LONG)FD_WRITE);
}else{
SendMessage(MainWindow, WM_ASYNCEVENT, 0, (LONG)FD_WRITE);
}
Keyboard::Check();
}
/***********************************************************************************************
* TMC::Add_Client -- a client has requested to connect. Make the connection *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: TRUE if client was successfully connected *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 3:02PM ST : Created *
*=============================================================================================*/
BOOL TcpipManagerClass::Add_Client(void)
{
struct sockaddr_in addr;
int addrsize;
bool delay = TRUE;
/*
** Accept the connection. If there is an error then dont do anything else
*/
addrsize = sizeof(addr);
ConnectSocket = accept (ListenSocket, (LPSOCKADDR)&addr, &addrsize);
if (ConnectSocket == INVALID_SOCKET) {
//Show_Error("accept", WSAGetLastError());
return(FALSE);
}
/*
** Set options for this socket
*/
setsockopt (ConnectSocket, IPPROTO_TCP, TCP_NODELAY, (char*)&delay, 4);
setsockopt (ConnectSocket, SOL_SOCKET, SO_RCVBUF, (char*)&SocketReceiveBuffer, 4);
setsockopt (ConnectSocket, SOL_SOCKET, SO_SNDBUF, (char*)&SocketSendBuffer, 4);
/*
** Save the clients address
*/
memcpy(&ClientIPAddress, &addr.sin_addr.s_addr,4);
memcpy(&UDPIPAddress, &addr.sin_addr.s_addr,4);
/*
** Initiate an asynchronous host lookup by address. Our window will receive notification
** when this is complete or when it times out.
*/
Async = WSAAsyncGetHostByAddr (MainWindow, WM_HOSTBYADDRESS,
(char const *)&addr.sin_addr, 4, PF_INET, &HostBuff[0],
MAXGETHOSTSTRUCT);
/*
** Enable asynchronous events on this socket
*/
if (WSAAsyncSelect (ConnectSocket, MainWindow, WM_ASYNCEVENT,
FD_READ | FD_WRITE | FD_CLOSE) == SOCKET_ERROR){
WSACancelAsyncRequest(Async);
Close_Socket (ConnectSocket);
return(FALSE);
}
/*
** Create our UDP socket
*/
UDPSocket = socket(AF_INET, SOCK_DGRAM, 0);
if (UDPSocket == INVALID_SOCKET) {
return (FALSE);
}
/*
** Bind our UDP socket to our UDP port number
*/
addr.sin_family = AF_INET;
addr.sin_port = htons(PlanetWestwoodPortNumber);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(UDPSocket, (LPSOCKADDR)&addr, sizeof(addr)) ==
SOCKET_ERROR) {
Close_Socket(UDPSocket);
ConnectStatus = NOT_CONNECTING;
return(FALSE);
}
/*
** Set options for the UDP socket
*/
setsockopt (UDPSocket, SOL_SOCKET, SO_RCVBUF, (char*)&SocketReceiveBuffer, 4);
setsockopt (UDPSocket, SOL_SOCKET, SO_SNDBUF, (char*)&SocketSendBuffer, 4);
/*
** Enable asynchronous events on this socket
*/
if (WSAAsyncSelect (UDPSocket, MainWindow, WM_UDPASYNCEVENT,
FD_READ | FD_WRITE) == SOCKET_ERROR){
WSACancelAsyncRequest(Async);
Close_Socket (UDPSocket);
Close_Socket (ConnectSocket);
return(FALSE);
}
return (TRUE);
}
/***********************************************************************************************
* TMC::Message_Handler -- Message handler function for Winsock related messages *
* *
* *
* *
* INPUT: Windows message handler stuff *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 3:05PM ST : Created *
*=============================================================================================*/
void TcpipManagerClass::Message_Handler(HWND, UINT message, UINT , LONG lParam)
{
struct hostent *hentry;
struct sockaddr_in addr;
int event;
int rc;
int addr_len;
switch (message){
/*
** Handle the GetHostByAddress result
*/
case WM_HOSTBYADDRESS:
if (IsServer){
/*
** We are the server
*/
ConnectStatus = CONNECTING;
if (WSAGETASYNCERROR(lParam)==0) {
hentry = (struct hostent *)&HostBuff[0];
strcpy (&ClientName[0], hentry->h_name);
}
Async = 0;
return;
}else{
/*
** We are the client
*/
ConnectStatus = CONTACTING_SERVER;
if (WSAGETASYNCERROR(lParam)==0) {
hentry = (struct hostent *)&HostBuff[0];
strcpy (Server.Name, hentry->h_name);
}
else {
Server.Name[0] = 0;
}
Async = 0;
return;
}
/*
** Retrieve host by name: Start connecting now that we have the
** address.
*/
case WM_HOSTBYNAME:
if (WSAGETASYNCERROR(lParam)==0) {
hentry = (struct hostent *)&HostBuff[0];
memcpy (&(Server.Addr.s_addr), hentry->h_addr, 4);
memcpy(&UDPIPAddress, hentry->h_addr, 4);
strcpy (Server.DotAddr, inet_ntoa(Server.Addr));
ConnectStatus = CONNECTED_OK;
Connected = TRUE;
}
else {
Server.Name[0] = 0;
strcpy (Server.DotAddr, "????");
ConnectStatus = SERVER_ADDRESS_LOOKUP_FAILED;
}
Async = 0;
return;
/*
** Connection is ready - accept the client
*/
case WM_ACCEPT:
rc = WSAGETSELECTERROR(lParam);
if (rc != 0) {
ConnectStatus = UNABLE_TO_ACCEPT_CLIENT;
return;
}
if (Add_Client()) {
ConnectStatus = CONNECTED_OK;
Connected = TRUE;
}
else {
ConnectStatus = UNABLE_TO_ACCEPT_CLIENT;
}
return;
/*
** Handle UDP packet events
*/
case WM_UDPASYNCEVENT:
event = WSAGETSELECTEVENT(lParam);
switch (event) {
case FD_READ:
rc = WSAGETSELECTERROR(lParam);
if (rc != 0) {
Clear_Socket_Error(UDPSocket);
return;
}
addr_len = sizeof(addr);
rc = recvfrom(UDPSocket, ReceiveBuffer, WS_RECEIVE_BUFFER_LEN, 0,
(LPSOCKADDR)&addr, &addr_len);
if (rc == SOCKET_ERROR) {
Clear_Socket_Error(UDPSocket);
return;
}
memcpy(&UDPIPAddress, &addr.sin_addr.s_addr, 4);
Copy_To_In_Buffer(rc);
return;
case FD_WRITE:
if (UseUDP){
rc = WSAGETSELECTERROR(lParam);
if (rc != 0) {
Clear_Socket_Error(UDPSocket);
return;
}
addr.sin_family = AF_INET;
addr.sin_port = htons(PlanetWestwoodPortNumber);
memcpy (&addr.sin_addr.s_addr, &UDPIPAddress, 4);
/*
** Send as many bytes as there are in the buffer; if there's
** an error, just bail out. If we get a WOULDBLOCK error,
** WinSock will send us another message when the socket is
** available for another write.
*/
while (TransmitBuffers[TXBufferTail].InUse){
rc = sendto(UDPSocket,
TransmitBuffers[TXBufferTail].Buffer,
TransmitBuffers[TXBufferTail].DataLength,
0,
(LPSOCKADDR)&addr,
sizeof (addr));
if (rc == SOCKET_ERROR){
if (WSAGetLastError() != WSAEWOULDBLOCK) {
Clear_Socket_Error(UDPSocket);
}
break;
}
TransmitBuffers[TXBufferTail++].InUse = false;
TXBufferTail &= WS_NUM_TX_BUFFERS-1;
}
return;
}
}
/*
** Handle the asynchronous event callbacks
*/
case WM_ASYNCEVENT:
event = WSAGETSELECTEVENT(lParam);
switch (event) {
/*
** FD_CLOSE: the client has gone away. Remove the client from our system.
*/
case FD_CLOSE:
rc = WSAGETSELECTERROR(lParam);
if (rc != 0 && rc != WSAECONNRESET) {
ConnectStatus = CONNECTION_LOST;
return;
}
if (Async != 0) {
WSACancelAsyncRequest(Async);
}
WSAAsyncSelect (ConnectSocket, MainWindow, WM_ASYNCEVENT, 0);
Close_Socket (ConnectSocket);
ConnectSocket = INVALID_SOCKET;
//Connected = FALSE;
ConnectStatus = CONNECTION_LOST;
break;
#if (0)
/*
** FD_READ: Data is available on our socket. This message is sent every time
** data becomes available so we only have to do one read
*/
case FD_READ:
if (!UseUDP){
rc = WSAGETSELECTERROR(lParam);
if (rc != 0) {
return;
}
rc = recv(ConnectSocket, ReceiveBuffer, WS_RECEIVE_BUFFER_LEN, 0);
if (rc == SOCKET_ERROR) {
Clear_Socket_Error(ConnectSocket);
return;
}
Copy_To_In_Buffer(rc);
return;
}
/*
** FD_WRITE: The socket is available for writing. We may actually have sent this
** message from elewhere in the class.
*/
case FD_WRITE:
rc = WSAGETSELECTERROR(lParam);
if (rc != 0) {
return;
}
/*
** Send as many bytes as there are in the buffer; if there's
** an error, just bail out. If we get a WOULDBLOCK error,
** WinSock will send us another message when the socket is
** available for another write.
*/
while (OutBufferHead > OutBufferTail){
rc = send(ConnectSocket, OutBuffer + OutBufferTail,
OutBufferHead - OutBufferTail, 0);
if (rc == SOCKET_ERROR){
if (WSAGetLastError() != WSAEWOULDBLOCK) {
Clear_Socket_Error(ConnectSocket);
}
break;
}
OutBufferTail+=rc;
}
if (OutBufferHead == OutBufferTail){
OutBufferHead = OutBufferTail = 0;
}
return;
#endif //(0)
/*
** FD_CONNECT: A connection was made, or an error occurred.
*/
case FD_CONNECT:
rc = WSAGETSELECTERROR(lParam);
if (rc != 0) {
ConnectStatus = UNABLE_TO_CONNECT;
return;
}
ConnectStatus = CONNECTED_OK;
Connected = TRUE;
return;
}
}
}
/***********************************************************************************************
* TMC::Copy_To_In_Buffer -- copy data from our winsock buffer to our internal buffer *
* *
* *
* *
* INPUT: bytes to copy *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 3:17PM ST : Created *
*=============================================================================================*/
void TcpipManagerClass::Copy_To_In_Buffer(int bytes)
{
if (!ReceiveBuffers[RXBufferHead].InUse){
memcpy (ReceiveBuffers[RXBufferHead].Buffer, ReceiveBuffer, MIN(bytes, WS_INTERNET_BUFFER_LEN));
ReceiveBuffers[RXBufferHead].InUse = true;
ReceiveBuffers[RXBufferHead++].DataLength = MIN(bytes, WS_INTERNET_BUFFER_LEN);
RXBufferHead &= WS_NUM_RX_BUFFERS-1;
}
}
/***********************************************************************************************
* TMC::Set_Host_Address -- Set the address of the host game we want to connect to *
* *
* *
* *
* INPUT: ptr to address string *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 3:19PM ST : Created *
*=============================================================================================*/
void TcpipManagerClass::Set_Host_Address(char *address)
{
strcpy(HostAddress, address);
}
/***********************************************************************************************
* TMC::Start_Client -- Start trying to connect to a game host *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 3:19PM ST : Created *
*=============================================================================================*/
void TcpipManagerClass::Start_Client(void)
{
struct sockaddr_in addr;
bool delay = true;
int i;
addr.sin_family = AF_INET;
addr.sin_port = 0;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
/*
** Set up the incoming and outgoing data buffers head and tail pointers
*/
// InBufferHead = 0;
// InBufferTail = 0;
// OutBufferHead= 0;
// OutBufferTail= 0;
TXBufferHead = 0;
TXBufferTail = 0;
RXBufferHead = 0;
RXBufferTail = 0;
for (i=0 ; i<WS_NUM_TX_BUFFERS ; i++){
TransmitBuffers[i].InUse = false;
}
for (i=0 ; i<WS_NUM_RX_BUFFERS ; i++){
ReceiveBuffers[i].InUse = false;
}
Connected = FALSE;
/*
** Flag that we are the client side not the server
*/
IsServer = FALSE;
UseUDP = TRUE;
/*
** Create our UDP socket
*/
UDPSocket = socket(AF_INET, SOCK_DGRAM, 0);
if (UDPSocket == INVALID_SOCKET) {
Close_Socket(ConnectSocket);
ConnectStatus = NOT_CONNECTING;
return;
}
/*
** Bind our UDP socket to our UDP port number
*/
addr.sin_family = AF_INET;
addr.sin_port = htons(PlanetWestwoodPortNumber);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(UDPSocket, (LPSOCKADDR)&addr, sizeof(addr)) ==
SOCKET_ERROR) {
Close_Socket(UDPSocket);
Close_Socket(ConnectSocket);
ConnectStatus = NOT_CONNECTING;
return;
}
/*
** Set options for the UDP socket
*/
setsockopt (UDPSocket, SOL_SOCKET, SO_RCVBUF, (char*)&SocketReceiveBuffer, 4);
setsockopt (UDPSocket, SOL_SOCKET, SO_SNDBUF, (char*)&SocketSendBuffer, 4);
/*
** Enable asynchronous events on the UDP socket
*/
if (WSAAsyncSelect (UDPSocket, MainWindow, WM_UDPASYNCEVENT,
FD_READ | FD_WRITE) == SOCKET_ERROR){
WSACancelAsyncRequest(Async);
Close_Socket (UDPSocket);
Close_Socket (ConnectSocket);
ConnectStatus = NOT_CONNECTING;
return;
}
/*
** If the name is not a dot-decimal ip address then do a nameserver lookup
*/
Server.Addr.s_addr = inet_addr(PlanetWestwoodIPAddress);
memcpy(&UDPIPAddress, &Server.Addr.s_addr, 4);
if (Server.Addr.s_addr == INADDR_NONE){
strcpy (Server.Name, PlanetWestwoodIPAddress);
Async = WSAAsyncGetHostByName(MainWindow, WM_HOSTBYNAME,
Server.Name, HostBuff, MAXGETHOSTSTRUCT);
ConnectStatus = RESOLVING_HOST_ADDRESS;
}else{
ConnectStatus = CONNECTED_OK;
Connected = TRUE;
}
}
/***********************************************************************************************
* TMC::Close_Socket -- Close an opened Winsock socket. *
* *
* *
* *
* INPUT: Socket to close *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/20/96 3:24PM ST : Created *
*=============================================================================================*/
void TcpipManagerClass::Close_Socket(SOCKET s)
{
LINGER ling;
ling.l_onoff = 0; // linger off
ling.l_linger = 0; // timeout in seconds (ie close now)
setsockopt(s, SOL_SOCKET, SO_LINGER, (LPSTR)&ling, sizeof(ling));
closesocket (s);
}
void TcpipManagerClass::Set_Protocol_UDP(BOOL state)
{
UseUDP = state;
}
void TcpipManagerClass::Clear_Socket_Error(SOCKET socket)
{
unsigned long error_code;
int length = 4;
getsockopt (socket, SOL_SOCKET, SO_ERROR, (char*)&error_code, &length);
error_code = 0;
setsockopt (socket, SOL_SOCKET, SO_ERROR, (char*)&error_code, length);
}
#endif //FORCE_WINSOCK