/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      POP3 Test-Program
  File:         main.cpp
  Author:       Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Small test program for POP3 class

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#include "sources/cub_pop.h"

// Header file for console handling
#include <conio.h>

void main ()
{
	CUB_popClient	  popClient;
	CUB_popClientInfo popInfo;

	//////////////////////////////////////////////////////////////////////////////////////////
	// Fill out the popClient structure:
	//
	//		- m_cMailboxName = myname@mydomain.com
	//		- m_cPassword    = mypassword
	//////////////////////////////////////////////////////////////////////////////////////////

	printf ("*** POP3 Test - by United Bytes ***\n\n");

	// Get the mail box name
	printf ("Enter account name: ");
	scanf ("%s", popInfo.m_cMailboxName);

	// Get the password
	printf ("\nEnter account password: ");
	scanf ("%s", popInfo.m_cPassword);

	// Get the mail server address
	printf ("\nEnter POP3 server address: ");
	scanf ("%s", popInfo.m_cPopServer);

	// Get the server port
	printf ("\nEnter server port (default is 110): ");
	scanf ("%ld", &popInfo.m_lServerPort);

	// Connect to a mail server of your provider
	if (!popClient.ConnectToPOP3 (&popInfo)) 
	{
		printf ("ERROR: %s\n", popClient.m_cErrorText);
	}
	else {
		printf ("Connected!\n");

		printf ("You have %ld new messages which have %ld bytes!\n", popClient.GetNumMessages (), popClient.GetSizeOfMessages());

		while (true)
		{
			popClient.MessageManager ();

			if (kbhit ()) 
				break;
		}
	
		popClient.Shutdown ();
	}
} 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_n_client.h
  Author:       Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Client base class for internet applications

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#ifndef __CUB_NETWORK_CLIENT_H__
#define __CUB_NETWORK_CLIENT_H__

#include <stdio.h>

#include "cub_n_socket.h"

// Global network length defines
#define CUB_NETWORK_MAXTEXT				255

// Global network states
#define CUB_NS_NOT_INITIALIZED			0
#define CUB_NS_WINSOCK_INIT				1
#define CUB_NS_SOCKET_CREATED			2
#define CUB_NS_CONNECTED				3

class CUB_Client
{
	public:
							CUB_Client ();
						   ~CUB_Client ();
		bool				Initialize ();
		bool				Shutdown		();
		bool				Connect			();
		bool				CloseConnection ();
		bool				GetLocalIP      (char *cBuffer);
		bool				Setup			(char *cServerIP, int iPort);
		bool				IsConnected		();
		bool				CreateSocket    ();

		char				m_cErrorText [CUB_NETWORK_MAXTEXT];
		CUB_Socket			m_Socket;
		int					m_iInitLevel;

	private:
		char				m_cServerIP [CUB_NETWORK_MAXTEXT];
		int					m_iServerPort;
		int					m_iClientID;
};

#endif 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_pop_baseclass.cpp
  Author:       Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Base class for pop class

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#include "cub_pop_baseclass.h"

CUB_popBaseClass::CUB_popBaseClass ()
{
	BaseShutdown ();
}

CUB_popBaseClass::~CUB_popBaseClass ()
{
	BaseShutdown ();
}

void CUB_popBaseClass::BaseShutdown ()
{
}

bool CUB_popBaseClass::GetError (long lErrorNum, char *cErrorText)
{
	// Check for valid pointer
	if (cErrorText == 0) {
		lErrorNum = -99;
	}
	else {
		// Get the error
		switch (lErrorNum)
		{
			default:
				lErrorNum = -99;
				break;
		}
	}

	if (lErrorNum == -99)
		return false;

	return true;
} 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_pop_baseclass.h
  Author:       Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Header file for pop base class

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#ifndef __CUB_POP_BASECLASS_H__
#define __CUB_POP_BASECLASS_H__

#include "cub_pop_globals.h"

class CUB_popBaseClass
{
	public:
						CUB_popBaseClass ();
					   ~CUB_popBaseClass ();
		bool			GetError		 (long lErrorNum, char *cErrorText);
		void			BaseShutdown     ();

	private:
};

#endif 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_pop.h
  Author:       Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Header file for pop class

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#ifndef __CUB_POP_H__
#define __CUB_POP_H__

// Exclude rarely-used stuff from windows headers
#define WIN32_LEAN_AND_MEAN

// Link with the needed lib files
#pragma comment (lib, "wsock32.lib")

// All header files
#include "cub_pop_globals.h"
#include "cub_pop_client.h"

#include "cub_n_socket.h"
#include "cub_n_client.h"

#endif 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_pop_client.h
  Author:       Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Header file for pop client implementation (RFC 1939) 

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#ifndef __CUB_POP_CLIENT_H__
#define __CUB_POP_CLIENT_H__

#include "cub_n_client.h"
#include "cub_pop_baseclass.h"

struct CUB_popClientInfo 
{
	char m_cMailboxName [CUB_POP_MAX_ARGUMENT];
	char m_cPassword    [CUB_POP_MAX_ARGUMENT];
	char m_cPopServer	[CUB_POP_MAX_ARGUMENT];
	long m_lServerPort;
};

class CUB_popClient : public CUB_Client, CUB_popBaseClass
{
	public:
							CUB_popClient ();
						   ~CUB_popClient ();

		bool				ConnectToPOP3		 (CUB_popClientInfo *pClientInfo);
		void				Shutdown			 ();
		long				ReceiveServerMessage (char *cBuffer, long lBufLen);
		bool				SendServerMessage    (char *cBuffer, long lBufLen);
		bool				SendCommand			 (char *cCommand);
		bool				CommandValid		 (char *cCommand);
		bool				MessageManager		 ();
		
		long				GetNumMessages       ();
		long				GetSizeOfMessages    ();

	private:
		long				m_lNumMessages;
		long				m_lSizeOfMessages;

};

#endif 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_pop_client.cpp
  Author:       Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Pop client implementation (RFC 1939) 

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#include "cub_pop_client.h"

CUB_popClient::CUB_popClient ()
{
	Shutdown ();
}

CUB_popClient::~CUB_popClient ()
{
	Shutdown ();
}

void CUB_popClient::Shutdown ()
{
	// Clear variables
	m_lNumMessages    = 0;
	m_lSizeOfMessages = 0;

	// Send quit message
	SendCommand ("QUIT");
}

bool CUB_popClient::ConnectToPOP3 (CUB_popClientInfo *pClientInfo)
{
	int  iError = 0;
	char cBuffer [CUB_POP_MAX_MESSAGE];

	// Check for valid data
	if (!pClientInfo) {
		sprintf (m_cErrorText, "CUB_popClient->ConnectToPOP3: Invalid connection parameters given!");
		iError = 1;
	}
	else {
		// Set up the parameters
		if (!Setup (pClientInfo->m_cPopServer, pClientInfo->m_lServerPort)) {
			iError = 1;
		}
		else {
			// Initialize the client
			if (!Initialize ()) {
				iError = 1;
			}
			else {
				// Connect to the server!
				if (!Connect ()) {
					iError = 1;
				}
			}
		}
	}

	// Still no error occured?
	if (iError == 0)
	{
		////////////////////////////////////////////////////////////////////////////////////////
		// Send login information
		////////////////////////////////////////////////////////////////////////////////////////

		// Eat (=hide) welcome message
		ReceiveServerMessage (cBuffer, CUB_POP_MAX_MESSAGE);

		// Send mailbox name
		sprintf (cBuffer, "USER %s", pClientInfo->m_cMailboxName);
		SendCommand (cBuffer);

		// Await response
		ReceiveServerMessage (cBuffer, CUB_POP_MAX_MESSAGE);
		
		if (!CommandValid (cBuffer)) {
			sprintf (m_cErrorText, "User/Mailbox name not correct!");
			iError = 1;
		}
		else {
			// Send password
			sprintf (cBuffer, "PASS %s", pClientInfo->m_cPassword);
			SendCommand (cBuffer);

			// Await response
			ReceiveServerMessage (cBuffer, CUB_POP_MAX_MESSAGE);

			if (!CommandValid (cBuffer)) {
				sprintf (m_cErrorText, "Password name not correct or logged in too frequently!");
				iError = 1;
			}
			else {
				// Send request for statistics
				SendCommand ("STAT");

				// Read number and size of all messages in mailbox
				ReceiveServerMessage (cBuffer, CUB_POP_MAX_MESSAGE);

				if (!CommandValid (cBuffer)) {
					sprintf (m_cErrorText, "Cannot retrieve number of mails!");
					iError = 1;
				}
				else {
					// Extract the numbers
					sscanf (cBuffer, "+OK %ld %ld", &m_lNumMessages, &m_lSizeOfMessages);
				}
			}
		}
	}

	if (iError != 0)
		return false;

	return true;
}

bool CUB_popClient::CommandValid (char *cCommand)
{
	////////////////////////////////////////////////////////////////////////////////////////
	// Checks for +OK or -ERR at the beginning
	////////////////////////////////////////////////////////////////////////////////////////

	int iError = 0;
	char cBuffer [16];

	if (!cBuffer) {
		sprintf (m_cErrorText, "CUB_popClient->CommandValid: Buffer pointer invalid or too small!");
		iError = 1;
	}
	else {
		// Clear buffer
		memset (cBuffer, 0, sizeof (cBuffer));

		// Get the +OK (maybe)
		memcpy (cBuffer, cCommand, 3);

		if (!strcmp (cBuffer, "+OK"))
			return true;
		else 
			return false;
	}

	if (iError != 0)
		return false;

	return true;
}

long CUB_popClient::ReceiveServerMessage (char *cBuffer, long lBufLen)
{
	////////////////////////////////////////////////////////////////////////////////////////
	// Receives a message stream from the POP3 Server
	////////////////////////////////////////////////////////////////////////////////////////

	int		iError   = 0;
	int		iReturn  = 0;
	long	lCounter = 0;
	char	cChar    = 0;

	if ((!cBuffer) || lBufLen < CUB_POP_MAX_MESSAGE) {
		sprintf (m_cErrorText, "CUB_popClient->ReceiveServerMessage: Buffer pointer invalid or too small!");
		iError = 1;
	}
	else {
		memset (cBuffer, 0, lBufLen);

		if (m_iInitLevel < CUB_NS_CONNECTED) {
			sprintf (m_cErrorText, "CUB_popClient->ReceiveServerMessage: Client not connected yet!");
			iError = 1;
		}
	}

	if (iError == 0)
	{
		while (true)
		{
			iReturn = m_Socket.Receive (&cChar, 1);

			if (iReturn <= 0)
				break;

			cBuffer[lCounter] = cChar;

			lCounter ++;

			if (cChar == '\n')
				break;
		}	   
	}

	// Remove the CRLF from the buffer
	cBuffer [lCounter - 1] = '\0';

	if (iError != 0)
		return 0;

	return lCounter;
}

bool CUB_popClient::SendServerMessage (char *cBuffer, long lBufLen)
{
	int		iError    = 0;
	long	lCounter  = 0;
	long	lNumChars = 0;

	if (!cBuffer) {
		sprintf (m_cErrorText, "CUB_popClient->SendServerMessage: Buffer pointer invalid!");
		iError = 1;
	}
	else {
		if (m_iInitLevel < CUB_NS_CONNECTED) {
			sprintf (m_cErrorText, "CUB_popClient->SendServerMessage: Client not connected yet!");
			iError = 1;
		}
	}

	// Set an CRLF at the end of the line
	strcat (cBuffer, "\n");

	// Count the chars in the string
	lNumChars = strlen (cBuffer);

	if (iError == 0)
	{
		while (lCounter < lNumChars)
		{
			lCounter += m_Socket.Send (cBuffer, lNumChars);
		}	   
	}

	if (iError != 0)
		return false;

	return true;	
}

bool CUB_popClient::SendCommand (char *cCommand)
{
	////////////////////////////////////////////////////////////////////////////////////////
	// Send a command to the server
	////////////////////////////////////////////////////////////////////////////////////////

	int	 iError = 0;
	char cBuffer [CUB_POP_MAX_MESSAGE];

	if (!cBuffer) {
		sprintf (m_cErrorText, "CUB_popClient->SendCommand: Buffer pointer invalid!");
		iError = 1;
	}
	else {
		if (m_iInitLevel < CUB_NS_CONNECTED) {
			sprintf (m_cErrorText, "CUB_popClient->SendCommand: Client not connected yet!");
			iError = 1;
		}
	}

	if (iError == 0)
	{
		sprintf (cBuffer, "%s", cCommand);
		return SendServerMessage (cBuffer, CUB_POP_MAX_MESSAGE);
	}

	return false;
}

bool CUB_popClient::MessageManager ()
{
	////////////////////////////////////////////////////////////////////////////////////////
	// Scans all incoming messages
	////////////////////////////////////////////////////////////////////////////////////////

	int  iError = 0;
	char cBuffer [CUB_POP_MAX_MESSAGE];

	if (m_iInitLevel < CUB_NS_CONNECTED) {
		sprintf (m_cErrorText, "CUB_popClient->Refresh: Client not connected yet!");
		iError = 1;
	}
	else {
		// Something found in buffer?
		if (m_Socket.CanReceive ()) 
		{
			// Receive message from server
			if (!ReceiveServerMessage (cBuffer, 512)) {
				iError = 1;
			}
			else {
				if (strcmp (cBuffer, "")) 
					printf ("%s\n", cBuffer);
			}

		}

	}

	return false;
}

long CUB_popClient::GetNumMessages ()
{
	return m_lNumMessages;
}

long CUB_popClient::GetSizeOfMessages ()
{
	return m_lSizeOfMessages;
}

 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_pop_globals.h
  Author:       Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Global defines & definitions for pop class (RFC 1939) 

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#ifndef __CUB_POP_GLOBALS_H__
#define __CUB_POP_GLOBALS_H__

//////////////////////////////////////////////////////////////////////////////////////////
// Header files
//////////////////////////////////////////////////////////////////////////////////////////
#include <stdio.h>

//////////////////////////////////////////////////////////////////////////////////////////
// Length defines
//////////////////////////////////////////////////////////////////////////////////////////

// Global POP max definitions
#define CUB_POP_MAX_MESSAGE				512
#define CUB_POP_MAX_COMMAND				510
#define CUB_POP_MAX_ARGUMENT			40

#endif 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_n_client.cpp
  Author:       Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Client base class for internet applications

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#include "cub_n_client.h"

////////////////////////////////////////////
// States:
//			1:	WinSock init
//			2:  Socket created & binded
//
////////////////////////////////////////////

CUB_Client::CUB_Client ()
{
	// Set init level
	m_iInitLevel = CUB_NS_NOT_INITIALIZED;

	// Clear error text
	memset (m_cErrorText, 0, sizeof(m_cErrorText));
}

CUB_Client::~CUB_Client ()
{
	Shutdown ();
}

bool CUB_Client::Setup (char *cServerIP, int iPort)
{
	if ((iPort == 0) ||
		(!strcmp (cServerIP  , "")))
	{
		sprintf (m_cErrorText, "CUB_Client->Setup: Wrong connect parameters given! Please check them!");
		return false;
	}
	else {
		sprintf (m_cServerIP, "%s", cServerIP);
		m_iServerPort = iPort;
	}

	return true;
}

bool CUB_Client::Initialize ()
{
	WSADATA WSAData;
	int iError = 0;

	if (m_iInitLevel > CUB_NS_NOT_INITIALIZED)
	{
		sprintf (m_cErrorText, "CUB_Client->Initialize: Client already initialized!");
		iError = 1;
	}
	else {
		// Call "WSAStartup", request WSA version 2.2 or 1.1
		iError = WSAStartup(MAKEWORD(2, 2), &WSAData);

		if (iError != 0) {
			sprintf (m_cErrorText, "CUB_Client->Initialize: Could not find a valid WinSock DLL!");
			iError = 1;
		}
		else {
			m_iInitLevel = CUB_NS_WINSOCK_INIT;

			if (!CreateSocket()) {
				iError = 1;
			}
			else {
				sprintf (m_cErrorText, "CUB_Client->Initialize: Success.");
			}
		}
	}

	if (iError == 1) 
		return false;

	return true;	
}

bool CUB_Client::Shutdown ()
{
	int iError = 0;

	if (m_iInitLevel < CUB_NS_WINSOCK_INIT)
	{
		iError = 1;
		sprintf (m_cErrorText, "CUB_Client->Shutdown: Can´t shutdown, cause server is not initialized yet!");
	}
	else {
		switch (m_iInitLevel)
		{
			case CUB_NS_CONNECTED:

			case CUB_NS_SOCKET_CREATED:
				m_Socket.CloseSocket ();

			case CUB_NS_WINSOCK_INIT:
				WSACleanup();
				m_iInitLevel = CUB_NS_NOT_INITIALIZED;
				break;

			default:
				sprintf (m_cErrorText, "CUB_Client->Shutdown: Wrong InitLevel detected!");
				iError = 1;
				break;
		}
	}

	memset (m_cServerIP, 0, sizeof(m_cServerIP));
	m_iServerPort = 0;

	if (iError == 1)
		return false;

	sprintf (m_cErrorText, "CUB_Client->Shutdown: Success.");
	return true;
}

bool CUB_Client::CloseConnection ()
{
	int iError = 0;

	if (m_iInitLevel != CUB_NS_CONNECTED)
	{
		sprintf (m_cErrorText, "CUB_Client->CloseConnection: Not connected yet!");
		iError = 1;
	}
	else {
		

		if (!m_Socket.CloseSocket ()) {
			sprintf (m_cErrorText, "CUB_Client->CloseConnection: Can´t close socket!");
			iError = 1;
		}
		else {
			m_iInitLevel = CUB_NS_SOCKET_CREATED;
		}
	}

	if (iError == 1)
		return false;

	sprintf (m_cErrorText, "CUB_Client->CloseConnection: Success.");
	return true;
}

bool CUB_Client::Connect ()
{
	int iError = 0;

	if (m_iInitLevel != CUB_NS_SOCKET_CREATED)
	{
		sprintf (m_cErrorText, "CUB_Client->Connect: Wrong InitLevel detected!");
		iError = 1;
	}
	else {
		if (!m_Socket.Connect (m_cServerIP, m_iServerPort)) {
			sprintf (m_cErrorText, "CUB_Client->Connect: Connection attempt to address %s, port %d failed!", m_cServerIP, m_iServerPort);
			iError = 1;
		}
		else {
			// Client successfully connected
			m_iInitLevel = CUB_NS_CONNECTED;
		}
	}

	if (iError == 1)
		return false;

	sprintf (m_cErrorText, "CUB_Client->Connect: Success. (Host=%s, Port=%d)", m_cServerIP, m_iServerPort);
	return true;
}

bool CUB_Client::CreateSocket ()
{
	int iError = 0;

	if (m_iInitLevel != CUB_NS_WINSOCK_INIT)
	{
		sprintf (m_cErrorText, "CUB_Client->CreateSocket: Wrong InitLevel detected!");
		iError = 1;
	}
	else {
		// Create the socket
		if (!m_Socket.CreateSocket()) {
			sprintf (m_cErrorText, "CUB_Client->CreateSocket: Cannot create socket! WinSock-Error: %d", GetLastError());
			iError = 1;	
		}
		else {
			// Set socket to non blocking mode
			// m_Socket.SetSocketBlockingMode (false);

			// Set the init level
			m_iInitLevel = CUB_NS_SOCKET_CREATED;
		}
	}

	if (iError == 1)
		return false;

	sprintf (m_cErrorText, "CUB_Client->CreateSocket: Success.");
	return true;
}

bool CUB_Client::GetLocalIP (char *cBuffer)
{
	int iError = 0;

	if (m_iInitLevel < CUB_NS_WINSOCK_INIT)
	{
		sprintf (m_cErrorText, "CUB_Client->GetLocalIP: Wrong InitLevel detected!");
		iError = 1;
	}
	else {
		if (!m_Socket.GetLocalIP (cBuffer)) {
			sprintf (m_cErrorText, "CUB_Client->GetLocalIP: Could not lookup own IP address!");
			iError = 1;	
		}
	}

	if (iError == 1)
		return false;

	sprintf (m_cErrorText, "CUB_Client->GetLocalIP: (%s) Success.", cBuffer);
	return true;
}

bool CUB_Client::IsConnected ()
{
	if (m_iInitLevel >= CUB_NS_CONNECTED)
		return true;

	return false;
}

 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_n_socket.h
  Author:       Tim C. Schroeder, modified by Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Simple socket class

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#ifndef __CUB_NETWORK_SOCKET_H__
#define __CUB_NETWORK_SOCKET_H__

#include <winsock.h>

class CUB_Socket  
{
	public:
						CUB_Socket();
						CUB_Socket(SOCKET iSocket);
		virtual		   ~CUB_Socket();

		bool			Bind		 (unsigned int iPort, bool bListen);
		int				Select		 (bool bRead, bool bWrite, int iTimeOut);
		bool			Connect		 (char szIPAddress[], unsigned int iPort);
		void			GetLastError (char szErrDescription[]);
		bool			GetRemoteIP  (char szIPAddress[]);
		bool		    GetLocalIP   (char szIPAddress[]);
		int				Send		 (char *cBuffer, long lBufLen);
		int				Receive		 (char *cBuffer, long lBufLen);
		bool			ResolveHost  (char *cIP, char *cResponseBuffer);
		bool			CanAccept	 ();
		bool			CanReceive   ();
		CUB_Socket	   *Accept		 (struct sockaddr *addr,  int *addrlen);
		bool			CloseSocket  ();
		bool			Peek         ();
		bool			ClearSocketBuffer ();
		bool			Wait         (long lNetworkEvents, DWORD dwTimeOut);
		void			ResolveHost  (char szHost[]);
		bool			SetSocketBlockingMode (bool bBlocking);
		
		SOCKET			m_sock;
		struct			sockaddr_in m_sa;
		bool			CreateSocket();

		bool			Init();
		static int		m_iInstCout;	 // Use this to prevent multiple initialisations of the WSA
};

#endif 

/******************************************************************
  (C) Copyright 2001 by UNITED BYTES
   
  web:  http://www.unitedbytes.de
        http://www.unitedbytes.org
		http://www.unitedbytes.net
  mail: info@unitedbytes.de

  This program 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 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, 
  Boston, MA  02111-1307, USA.

  *****************************************************************

  Program:      ubNetwork
  File:         sources/cub_n_socket.cpp
  Author:       Tim C. Schroeder, modified by Andreas Loeffler
  Date:         Mon, 10.04.2001
  Version:      1.0
  Description:  Simple socket class

  -----------------------------------------------------------------

  Changes:		-
  Date:			-
  Description:	-

  *****************************************************************/

#include "cub_n_socket.h"

// Static member variables
int CUB_Socket::m_iInstCout = 0;

//////////////////////////////////////////////////////////////////////
// Construcktion / destruction
//////////////////////////////////////////////////////////////////////

CUB_Socket::CUB_Socket()
{
	Init();
}

CUB_Socket::CUB_Socket(SOCKET iSocket)
{
	Init();
	m_sock = iSocket;
}

bool CUB_Socket::Init()
{
	//////////////////////////////////////////////////////////////////////
	// Init member variables
	//////////////////////////////////////////////////////////////////////

	m_sock = 0;

	m_iInstCout++;

	if (m_iInstCout == 1)
	{
	}

	return true;
}

CUB_Socket::~CUB_Socket()
{
	m_iInstCout--;

	// Close the socket (if opened)
	CloseSocket();
}

bool CUB_Socket::CreateSocket()
{
	//////////////////////////////////////////////////////////////////////
	// Create the socket
	//////////////////////////////////////////////////////////////////////

	if (!m_sock)
	{
		m_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
		if (m_sock == SOCKET_ERROR)
			return false;
		return true;
	}

	return false;
}

bool CUB_Socket::CloseSocket()
{
	//////////////////////////////////////////////////////////////////////
	// Close the socket
	//////////////////////////////////////////////////////////////////////
	
	if (m_sock)
	{
		closesocket(m_sock);
		m_sock = 0;
		return true;
	}
	
	return true;
}

bool CUB_Socket::Connect(char szIPAddress[], unsigned int iPort)
{
	char cBuffer [1024];

	//////////////////////////////////////////////////////////////////////
	// Connect to the given host
	//////////////////////////////////////////////////////////////////////

	// Don't connect if no IP is present
	if (szIPAddress[0] == '\0')
		return false;

	if (iPort <= 0)
		return false;
		
	//////////////////////////////////////////////////////////////////////
	// Open the connection on the socket
	//////////////////////////////////////////////////////////////////////

	// Get the IP
	ResolveHost (szIPAddress, cBuffer);

	m_sa.sin_family           = AF_INET;
	m_sa.sin_port             = htons(iPort);
	m_sa.sin_addr.S_un.S_addr = inet_addr(cBuffer);

	// Call "connect" with passed IP address and the passed port
	if (connect(m_sock, (SOCKADDR *) &m_sa, sizeof (m_sa)) == SOCKET_ERROR)
		return false;

	return true;
}

bool CUB_Socket::ResolveHost (char *cIP, char *cResponseBuffer)
{
	int		iError = 0;
	struct	in_addr  sInAddr;
	struct  hostent *spHe = gethostbyname (cIP);

	// No IP returned ?
	if (!spHe)
	{
		if (cResponseBuffer != NULL) {
			strcpy(cResponseBuffer, "CUB_Server->ResolveHost: Host is unknown!");
			iError = 1;
		}
	}
	else {
		// Extract the IP and replace the host name with it
		memcpy (&sInAddr, spHe->h_addr_list[0], sizeof(struct in_addr));

		if (cResponseBuffer != NULL)
			strcpy (cResponseBuffer, inet_ntoa(sInAddr));
	}

	if (iError == 1)
		return false;

	return true;
}

bool CUB_Socket::Bind (unsigned int iPort, bool bListen)
{
	//////////////////////////////////////////////////////////////////////
	// Bind the socket to the given port
	//////////////////////////////////////////////////////////////////////

	// Disconnect and close if a connection / socket is alive
	if (m_sock != 0)
		CloseSocket();
	
	// Create a new socket
	if (!CreateSocket())
		return false;

	m_sa.sin_addr.s_addr = htonl(INADDR_ANY);
	m_sa.sin_family = AF_INET;
	m_sa.sin_port = htons(iPort);

	// Bind 
	if (bind(m_sock, (struct sockaddr *) &m_sa, sizeof(m_sa)) == SOCKET_ERROR)
		return false;

	if (bListen) 
	{
		// Set backlog
		if (listen(m_sock, 5) != 0)
			return false;
	}

	return true;
}

bool CUB_Socket::CanAccept()
{
	//////////////////////////////////////////////////////////////////////
	// Returns true if there is at least one incomming connection request
	//////////////////////////////////////////////////////////////////////

	struct timeval sTimeVal;
	fd_set		   sFd;
	int			   iRv;
	
	FD_ZERO (&sFd);
	FD_SET  (m_sock, &sFd);
	
	sTimeVal.tv_sec = 0;
	sTimeVal.tv_usec = 1;
	
	iRv = select (1, &sFd, NULL, NULL, &sTimeVal);
	
	return iRv ? true : false;
}

CUB_Socket *CUB_Socket::Accept(sockaddr *addr, int *addrlen)
{
	//////////////////////////////////////////////////////////////////////
	// Accepts incoming connections on the socket and returns the socket
	//////////////////////////////////////////////////////////////////////

	SOCKET ClientSocket;
	CUB_Socket *pSocket = 0;

	if (!m_sock)
		return 0;

	// Accept connection
	ClientSocket = accept(m_sock, addr, addrlen);

	// Connection established ?
	if (ClientSocket == INVALID_SOCKET)
		return 0;
	
	// Create new socket class to connect to the client
	pSocket = new CUB_Socket(ClientSocket);

	return pSocket;
}

bool CUB_Socket::ClearSocketBuffer ()
{
	//////////////////////////////////////////////////////////////////////
	// Clears the complete socket buffer
	//////////////////////////////////////////////////////////////////////

	int  iReturn;
	char cBuffer[255];

	if (!m_sock)
		return false;

	// If data old data in socket, clear it!
	while (Peek()) {
		iReturn = recv(m_sock, cBuffer, sizeof(cBuffer), 0);
	
		if (iReturn == 0 || iReturn == SOCKET_ERROR)
			break;
	}

	return true;
}

int CUB_Socket::Receive (char *cBuffer, long lBufLen)
{
	//////////////////////////////////////////////////////////////////////
	// Receive data from a connected socket
	//////////////////////////////////////////////////////////////////////

	int  iReturn;
		
	if (!m_sock)
		return false;

	if (!cBuffer)
		return false;

	// Clear the buffer
	memset (cBuffer, 0, sizeof(lBufLen));

	// Receive the data
	iReturn = recv(m_sock, cBuffer, lBufLen, 0);

	return iReturn;
}

bool CUB_Socket::Peek()
{
	//////////////////////////////////////////////////////////////////////
	// Return true if data is available on the connected socket
	//////////////////////////////////////////////////////////////////////

	int iReturn;
	char szBuffer[1];
		
	if (!m_sock)
		return 0;

	SetSocketBlockingMode (false);

	// Receive the data
	iReturn = recv(m_sock, szBuffer, sizeof(szBuffer), MSG_PEEK);

	SetSocketBlockingMode (true);

	// Error ?
	if (iReturn == 0 || iReturn == SOCKET_ERROR)
		return false;

	return true;
}

bool CUB_Socket::Wait(long lNetworkEvents, DWORD dwTimeOut)
{
/*	//////////////////////////////////////////////////////////////////////
	// Wait for one of of the lNetworkEvents to become signaled
	//////////////////////////////////////////////////////////////////////
	
	WSAEVENT hEvent;
	DWORD dwReturn;

	if (!m_sock)
		return false;
	
	// Create the event object
	hEvent = WSACreateEvent();

	// Let hEvent be triggered by lNetworkEvents
	if (WSAEventSelect(m_sock, hEvent, lNetworkEvents) == SOCKET_ERROR)
		return false;

	// Wait for the event(s)
	dwReturn = WSAWaitForMultipleEvents(1, &hEvent, FALSE, dwTimeOut, FALSE);

	// Close the event
	WSACloseEvent(hEvent);

	// Evaluate the return value
	if (dwReturn == WSA_WAIT_TIMEOUT ||
		dwReturn == WSA_WAIT_FAILED)
	{
		// Wait has failed
		return false;
	}*/

	// Event triggered
	return true;
}

int CUB_Socket::Send (char *cBuffer, long lBufLen)
{
	//////////////////////////////////////////////////////////////////////
	// Send data over a connected socket
	//////////////////////////////////////////////////////////////////////

	int iReturn = 0;
		
	if (!m_sock)
		return 0;

	// Send the data
	iReturn = send (m_sock, cBuffer, lBufLen, 0);

	// Error ?
	if (iReturn == SOCKET_ERROR)
		return false;

	return iReturn;
}

bool CUB_Socket::GetLocalIP(char szIPAddress[])
{
	//////////////////////////////////////////////////////////////////////
	// Return the IP adress of the last local interface. This is most
	// likely the PPP adapter (if connected)
	//////////////////////////////////////////////////////////////////////

	char ac[80];
	struct in_addr addr;
	unsigned int i;

	// Get the local host name
	if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR) 
		return false;
    
	struct hostent *phe = gethostbyname(ac);
	
	// Test up to 64 addresses
	for (i=0; i<64; i++) 
	{
		// Last IP found ?
		if (phe->h_addr_list[i+1] == 0)
		{
			// Return
			memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr));
			strcpy(szIPAddress, inet_ntoa(addr));
			break;
		}
    }
    
	return true;
}

bool CUB_Socket::GetRemoteIP(char szIPAddress[])
{
	//////////////////////////////////////////////////////////////////////
	// Return the IP adress of the peer
	//////////////////////////////////////////////////////////////////////

	struct sockaddr_in name;
	int iLen;

	if (!m_sock)
		return false;

	// Size of the sockaddr_in structure 
	iLen = sizeof(sockaddr_in);

	// Retrieve the peer name
	if (getpeername(m_sock, (sockaddr *) &name, &iLen) == SOCKET_ERROR)
		return false;
	
	// Copy the string into the passed buffer
	strcpy(szIPAddress, inet_ntoa(name.sin_addr));
	    
	return true;
}

void CUB_Socket::ResolveHost(char szHost[])
{
	//////////////////////////////////////////////////////////////////////
	// Resolve the passed host to an IP address
	//////////////////////////////////////////////////////////////////////

	struct in_addr addr;
	struct hostent *phe = gethostbyname(szHost);

	// No IP returned ?
	if (!phe)
	{
		strcpy(szHost, "<Unknown>");
		return;
	}

	// Extract the IP and replace the host name with it
	memcpy(&addr, phe->h_addr_list[0], sizeof(struct in_addr));
	strcpy(szHost, inet_ntoa(addr));
}

int CUB_Socket::Select(bool bRead, bool bWrite, int iTimeOut)
{
	//////////////////////////////////////////////////////////////////////
	// Determine the status of the connected socket
	//////////////////////////////////////////////////////////////////////

	fd_set ReadSocket;
	fd_set WriteSocket;
	timeval TimeOut;
	int iReturn;

	// Set timeout
	TimeOut.tv_sec = iTimeOut;			// Old: / 1000;
	TimeOut.tv_usec = 0;

	// Fill socket sets
	ReadSocket.fd_array[0] = m_sock;
	ReadSocket.fd_count = 1;
	WriteSocket.fd_array[0] = m_sock;
	WriteSocket.fd_count = 1;

	// Make the requested select call
	iReturn = select(0, bRead ? &ReadSocket : 0, bWrite ? &WriteSocket : 0,
		0, &TimeOut);

	if (iReturn == SOCKET_ERROR)
		return 0;

	return iReturn;
}

bool CUB_Socket::CanReceive ()
{
	//////////////////////////////////////////////////////////////////////
	// Determine the status of the connected socket
	//////////////////////////////////////////////////////////////////////

	fd_set  lReceiveSocket;
	timeval TimeOut;

	lReceiveSocket.fd_count    = 1;
	lReceiveSocket.fd_array[0] = m_sock;
		
	TimeOut.tv_sec = 0;
	TimeOut.tv_usec = 0;

	// Determine status of the socket
	if (select (0, &lReceiveSocket, NULL, NULL, &TimeOut) == 1)
		return true;
	else
		return false;
}

bool CUB_Socket::SetSocketBlockingMode (bool bBlocking)
{
	//////////////////////////////////////////////////////////////////////
	// Turns the blocking mode on/off
	//////////////////////////////////////////////////////////////////////

	unsigned long lMode = 0;

	if (bBlocking)
		lMode = 0;
	else
		lMode = 1;

    if (ioctlsocket (m_sock, FIONBIO, &lMode) == SOCKET_ERROR)
        return false;
	
	return true;
}  

void CUB_Socket::GetLastError(char *szErrDescription)
{
	//////////////////////////////////////////////////////////////////////
	// Return a string for the last error
	//////////////////////////////////////////////////////////////////////

	// Retrieve the last error
	int iError = WSAGetLastError();

	switch (iError)
	{
		case 0:                  
			strcpy(szErrDescription, "No error");
			break;
		case WSAEINTR:           
			strcpy(szErrDescription, "Interrupted system call");
			break;
		case WSAEBADF:           
			strcpy(szErrDescription, "Bad file number");
			break;
		case WSAEACCES:          
			strcpy(szErrDescription, "Permission denied");
			break;
		case WSAEFAULT:          
			strcpy(szErrDescription, "Bad address");
			break;
		case WSAEINVAL:          
			strcpy(szErrDescription, "Invalid argument");
			break;
		case WSAEMFILE:          
			strcpy(szErrDescription, "Too many open sockets");
			break;
		case WSAEWOULDBLOCK:     
			strcpy(szErrDescription, "Operation would block");
			break;
		case WSAEINPROGRESS:     
			strcpy(szErrDescription, "Operation now in progress");
			break;
		case WSAEALREADY:        
			strcpy(szErrDescription, "Operation already in progress");
			break;
		case WSAENOTSOCK:        
			strcpy(szErrDescription, "Socket operation on non-socket");
			break;
		case WSAEDESTADDRREQ:    
			strcpy(szErrDescription, "Destination address required");
			break;
		case WSAEMSGSIZE:        
			strcpy(szErrDescription, "Message too long");
			break;
		case WSAEPROTOTYPE:      
			strcpy(szErrDescription, "Protocol wrong type for socket");
			break;
		case WSAENOPROTOOPT:     
			strcpy(szErrDescription, "Bad protocol option");
			break;
		case WSAEPROTONOSUPPORT: 
			strcpy(szErrDescription, "Protocol not supported");
			break;
		case WSAESOCKTNOSUPPORT: 
			strcpy(szErrDescription, "Socket type not supported");
			break;
		case WSAEOPNOTSUPP:      
			strcpy(szErrDescription, "Operation not supported on socket");
			break;
		case WSAEPFNOSUPPORT:    
			strcpy(szErrDescription, "Protocol family not supported");
			break;
		case WSAEAFNOSUPPORT:    
			strcpy(szErrDescription, "Address family not supported");
			break;
		case WSAEADDRINUSE:      
			strcpy(szErrDescription, "Address already in use");
			break;
		case WSAEADDRNOTAVAIL:   
			strcpy(szErrDescription, "Can't assign requested address");
			break;
		case WSAENETDOWN:        
			strcpy(szErrDescription, "Network is down");
			break;
		case WSAENETUNREACH:     
			strcpy(szErrDescription, "Network is unreachable");
			break;
		case WSAENETRESET:       
			strcpy(szErrDescription, "Net connection reset");
			break;
		case WSAECONNABORTED:    
			strcpy(szErrDescription, "Software caused connection abort");
			break;
		case WSAECONNRESET:      
			strcpy(szErrDescription, "Connection reset by peer");
			break;
		case WSAENOBUFS:         
			strcpy(szErrDescription, "No buffer space available");
			break;
		case WSAEISCONN:         
			strcpy(szErrDescription, "Socket is already connected");
			break;
		case WSAENOTCONN:        
			strcpy(szErrDescription, "Socket is not connected");
			break;
		case WSAESHUTDOWN:       
			strcpy(szErrDescription, "Can't send after socket shutdown");
			break;
		case WSAETOOMANYREFS:    
			strcpy(szErrDescription, "Too many references, can't splice");
			break;
		case WSAETIMEDOUT:       
			strcpy(szErrDescription, "Connection timed out");
			break;
		case WSAECONNREFUSED:    
			strcpy(szErrDescription, "Connection refused");
			break;
		case WSAELOOP:           
			strcpy(szErrDescription, "Too many levels of symbolic links");
			break;
		case WSAENAMETOOLONG:    
			strcpy(szErrDescription, "File name too long");
			break;
		case WSAEHOSTDOWN:       
			strcpy(szErrDescription, "Host is down");
			break;
		case WSAEHOSTUNREACH:   
			strcpy(szErrDescription, "No route to host");
			break;
		case WSAENOTEMPTY:       
			strcpy(szErrDescription, "Directory not empty");
			break;
		case WSAEPROCLIM:        
			strcpy(szErrDescription, "Too many processes");
			break;
		case WSAEUSERS:          
			strcpy(szErrDescription, "Too many users");
			break;
		case WSAEDQUOT:          
			strcpy(szErrDescription, "Disc quota exceeded");
			break;
		case WSAESTALE:          
			strcpy(szErrDescription, "Stale NFS file handle");
			break;
		case WSAEREMOTE:         
			strcpy(szErrDescription, "Too many levels of remote in path");
			break;
		case WSASYSNOTREADY:     
			strcpy(szErrDescription, "Network system is unavailable");
			break;
		case WSAVERNOTSUPPORTED: 
			strcpy(szErrDescription, "Winsock version out of range");
			break;
		case WSANOTINITIALISED:  
			strcpy(szErrDescription, "WSAStartup not yet called");
			break;
		case WSAEDISCON:         
			strcpy(szErrDescription, "Graceful shutdown in progress");
			break;
		default:
			strcpy(szErrDescription, "Unknown error");
			break;
	}
}