DialogTemplate::operator DLGTEMPLATE *(void)
{
	DLGTEMPLATE *lpDLGTEMPLATE(0);
	DLGITEMTEMPLATE *lpDLGITEMTEMPLATE;
	String workString;
	BYTE *lpCharByte;
	DWORD sizeData;

	if(!itemCount())return lpDLGTEMPLATE;
	sizeData=sizeof(DLGITEMTEMPLATE)*itemCount()+sizeof(DLGTEMPLATE);
	for(short itemIndex=0;itemIndex<itemCount();itemIndex++)
	{
		sizeData+=mDlgItems[itemIndex].className().length()+1;
		sizeData+=mDlgItems[itemIndex].titleText().length()+1;
		sizeData+=2;
	}
	mItemData.size(sizeData);
	lpDLGTEMPLATE=(DLGTEMPLATE*)((BYTE*)mItemData);
	::memcpy(lpDLGTEMPLATE,&((DLGTEMPLATE&)*this),sizeof(DLGTEMPLATE));
	lpDLGITEMTEMPLATE=(DLGITEMTEMPLATE*)(((BYTE*)lpDLGTEMPLATE)+sizeof(DLGTEMPLATE));
	for(itemIndex=0;itemIndex<itemCount();itemIndex++)
	{
    DialogItemTemplate dlgItem(mDlgItems[itemIndex]);
		workString=mDlgItems[itemIndex].className();
		if(workString.isNull())continue;
		::memcpy(lpDLGITEMTEMPLATE,&dlgItem,sizeof(DLGITEMTEMPLATE));
		lpCharByte=(BYTE*)lpDLGITEMTEMPLATE;
		lpCharByte=lpCharByte+sizeof(DLGITEMTEMPLATE);
		::memcpy(lpCharByte,(LPSTR)workString,workString.length());
		lpCharByte+=workString.length();
		*lpCharByte=0;
		lpCharByte++;
		workString=mDlgItems[itemIndex].titleText();
		if(!workString.isNull())
		{
			::memcpy(lpCharByte,(LPSTR)workString,workString.length());
			lpCharByte+=workString.length();
			*lpCharByte=0;
      lpCharByte++;
		}
		else {*lpCharByte=0;lpCharByte++;}
		*((DWORD*)lpCharByte)=0;
    lpCharByte+=sizeof(DWORD);
    lpDLGITEMTEMPLATE=(DLGITEMTEMPLATE*)lpCharByte;
	}
	return lpDLGTEMPLATE;
}
#if 0
void FTPClient::open(String hostName)
{
  INETSocketAddress internetSocketAddress;
	HostEnt hostEntry;
	ServEnt serverEntry;
	String receiveString;

	InternetAddress inetAddr;
	String stringAddress((String)inetAddr);
	message(String("trying ")+hostName+String("..."));
	if(!mWSASystem.isInitialized()){message("WINSOCK initialization failure.");return;}
	if(!hostEntry.hostByName(hostName)){message(String("no DNS entry for ")+hostName);return;}
	message(String("connect...")+String("'")+hostEntry.hostName()+String("' (")+(String)(hostEntry.addresses())[0]+String(")"));
	internetSocketAddress.internetAddress((hostEntry.addresses())[0]);
	if(!serverEntry.serviceByName("ftp","tcp")){message("cannot determine port number for ftp daemon.");return;}
	if(!mFTPControl.openSocket()){message("unable to create socket.");return;}
	internetSocketAddress.family(PF_INET);
	internetSocketAddress.port(serverEntry.port());
	if(!mFTPControl.connect(internetSocketAddress)){message("unable to connect to ftp daemon");return;}
	if(!mFTPControl.receive(receiveString)){message("error reading data from ftp daemon");return;}
	mFTPControl.getSocketName(internetSocketAddress);
  receiveString.removeTokens("\r\n");
	message(receiveString);
}
#endif



#include <common/windows.hpp>
#include <common/string.hpp>
#include <winsock.h>



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

void finger(String userHostName);
void ftp(String userHostName);
void errorMessage(String messageString);

#if 0
int PASCAL WinMain(HINSTANCE /*hInstance*/,HINSTANCE /*hPrevInstance*/,LPSTR /*lpszCmdLine*/,int /*nCmdShow*/)
{
	WSADATA wskData;
	WORD wVersion=MAKEWORD(1,1);

	if(!::WSAStartup(wVersion,&wskData))
	{
		ftp("sean@cnct.com");
	}
	::WSACleanup();
	return FALSE;
}
#endif

void finger(String userHostName)
{
	struct hostent FAR *lpHostEntry;
	struct sockaddr_in anaddr;
	struct servent FAR *lpServent;
	short fingerPort;
	SOCKET clientSocket;
	WORD receiveCount;
  WORD stringLength(4096);
	String receiveString;
	String userName;
  String hostName;

	userName=userHostName.betweenString(0,'@');
  hostName=userHostName.betweenString('@','\0');
  receiveString.reserve(stringLength);
	if((lpHostEntry=::gethostbyname(hostName))==NULL){errorMessage("unknown host");return;}
	::memcpy(&anaddr.sin_addr.s_addr,lpHostEntry->h_addr,lpHostEntry->h_length);
	if((lpServent=::getservbyname("finger","tcp"))==NULL){errorMessage("cannot determine port number for finger daemon.");return;}
	fingerPort=::htons(lpServent->s_port);
	if((clientSocket=::socket(PF_INET,SOCK_STREAM,0))==INVALID_SOCKET){errorMessage("unable to create socket.");return;}
	anaddr.sin_family=PF_INET;
  anaddr.sin_port=::htons(fingerPort);
	if(::connect(clientSocket,(struct sockaddr FAR *)&anaddr,sizeof(anaddr)))
	{errorMessage("unable to connect to finger daemon");::closesocket(clientSocket);return;}
	userName+="\r\n";
	if(::send(clientSocket,userName,userName.length(),0)<userName.length())
	{errorMessage("error sending string to finger daemon");::closesocket(clientSocket);return;}
	if((receiveCount=::recv(clientSocket,receiveString,stringLength,0L))==SOCKET_ERROR)
	{errorMessage("error reading data from finger daemon");::closesocket(clientSocket);return;}
	if(!receiveCount){errorMessage("no data received from finger daemon");::closesocket(clientSocket);return;}
	receiveString+="\n";
  errorMessage(receiveString);
	::closesocket(clientSocket);
  return;
}

void ftp(String userHostName)
{
	struct hostent FAR *lpHostEntry;
	struct sockaddr_in anaddr;
	struct servent FAR *lpServent;
	short ftpPort;
	SOCKET clientSocket;
	WORD receiveCount;
  WORD stringLength(4096);
	String receiveString;
	String userName;
  String hostName;

	userName=userHostName.betweenString(0,'@');
  hostName=userHostName.betweenString('@','\0');
  receiveString.reserve(stringLength);
	if((lpHostEntry=::gethostbyname(hostName))==NULL){errorMessage("unknown host");return;}
	::memcpy(&anaddr.sin_addr.s_addr,lpHostEntry->h_addr,lpHostEntry->h_length);
	if((lpServent=::getservbyname("ftp","tcp"))==NULL){errorMessage("cannot determine port number for ftp daemon.");return;}
	ftpPort=::htons(lpServent->s_port);
	if((clientSocket=::socket(PF_INET,SOCK_STREAM,0))==INVALID_SOCKET){errorMessage("unable to create socket.");return;}
	anaddr.sin_family=PF_INET;
  anaddr.sin_port=::htons(ftpPort);
	if(::connect(clientSocket,(struct sockaddr FAR *)&anaddr,sizeof(anaddr)))
	{errorMessage("unable to connect to ftp daemon");::closesocket(clientSocket);return;}
	if((receiveCount=::recv(clientSocket,receiveString,stringLength,0L))==SOCKET_ERROR)
	{errorMessage("error reading data from ftp daemon");::closesocket(clientSocket);return;}
	if(!receiveCount){errorMessage("no data received from ftp daemon");::closesocket(clientSocket);return;}
	errorMessage(receiveString);
	String ftpString("USER sean@cnct.com");
  ftpString+="\r\n";
	if(::send(clientSocket,ftpString,ftpString.length(),0)<ftpString.length())
	{errorMessage("error sending string to ftp daemon");::closesocket(clientSocket);return;}
	if((receiveCount=::recv(clientSocket,receiveString,stringLength,0L))==SOCKET_ERROR)
	{errorMessage("error reading data from ftp daemon");::closesocket(clientSocket);return;}
	if(!receiveCount){errorMessage("no data received from ftp daemon");::closesocket(clientSocket);return;}
	receiveString+="\n";
	errorMessage(receiveString);
	String nameString("PASS cygnus-x1");
	nameString+="\r\n";
	if(::send(clientSocket,nameString,nameString.length(),0)<nameString.length())
	{errorMessage("error sending string to ftp daemon");::closesocket(clientSocket);return;}
	if((receiveCount=::recv(clientSocket,receiveString,stringLength,0L))==SOCKET_ERROR)
	{errorMessage("error reading data from ftp daemon");::closesocket(clientSocket);return;}
	if(!receiveCount){errorMessage("no data received from ftp daemon");::closesocket(clientSocket);return;}
	receiveString+="\n";
  errorMessage(receiveString);
	::closesocket(clientSocket);
  return;
}

void errorMessage(String messageString)
{
  ::MessageBox(::GetFocus(),(LPSTR)messageString,(LPSTR)"MESSAGE",MB_APPLMODAL);
}

#if 0
	sizeData=sizeof(DLGITEMTEMPLATE)*itemCount()+sizeof(DLGTEMPLATE);
	sizeData+=className().length()+1;
	sizeData+=titleText().length()+1;
	sizeData+=16;
	for(short itemIndex=0;itemIndex<itemCount();itemIndex++)
	{
		sizeData+=mDlgItems[itemIndex].className().length()+1;
		sizeData+=mDlgItems[itemIndex].titleText().length()+1;
		sizeData+=16;
	}
#endif

BYTE *DialogTemplate::copyString(BYTE *lpCharByte,const String &someString)const
{
	if(!someString.isNull())
	{
		WideString wideString(someString);
		::memcpy(lpCharByte,(PureWORD*)wideString,wideString.size()*sizeof(WORD));
		lpCharByte+=wideString.size()*sizeof(WORD);
	}
	*((WORD*)lpCharByte)=0x0000;
	lpCharByte+=sizeof(WORD);
	return lpCharByte;
}

	DialogTemplate dlgTemplate;
	DialogItemTemplate userEdit;
	DialogItemTemplate passEdit;
	DialogItemTemplate userStatic;
	DialogItemTemplate passStatic;


  dlgTemplate.titleText("Login to host...");
	dlgTemplate.posRect(Rect(8,19,197,76));
	dlgTemplate.pointSize(8);
  dlgTemplate.typeFace("Helv");
	dlgTemplate.style(DS_MODALFRAME|WS_TABSTOP|WS_VISIBLE|WS_CAPTION|WS_SYSMENU|DS_3DLOOK|DS_SETFONT|WS_POPUP);

	userEdit.className("EDIT");
  userEdit.titleText("");
	userEdit.style(WS_BORDER|WS_TABSTOP|WS_VISIBLE|WS_CHILD);
	userEdit.posRect(Rect(56,19,98,12));
	userEdit.itemID(101);

	passEdit.className("EDIT");
	passEdit.style(WS_BORDER|WS_TABSTOP|ES_PASSWORD|WS_CHILD|WS_VISIBLE);
	passEdit.posRect(Rect(56,35,98,12));
	passEdit.itemID(103);

	userStatic.className("STATIC");
	userStatic.titleText("User Name :");
	userStatic.style(WS_CHILD|WS_VISIBLE);
	userStatic.posRect(Rect(2,20,39,8));
	userStatic.itemID(-1);

	passStatic.className("STATIC");
	passStatic.titleText("Password :");
	passStatic.style(WS_CHILD|WS_VISIBLE);
	passStatic.posRect(Rect(2,36,39,8));
	passStatic.itemID(-1);

	dlgTemplate+=userEdit;
	dlgTemplate+=passEdit;
	dlgTemplate+=userStatic;
	dlgTemplate+=passStatic;

	DynamicDialog dynamicDialog;

	dynamicDialog.createDialog(dlgTemplate);

  	if(!mFTPControl.isConnected())return FALSE;
	if(!putControlData(mFTPCommands[Passive]))return FALSE;
  receiveStrings();
	if(pathName.isNull())
	{
		if(!putControlData(mFTPCommands[List]))return FALSE;
    receiveStrings();
	}
	else
	{
		if(!putControlData(mFTPCommands[List]+String(" ")+pathName))return FALSE;
    receiveStrings();
	}
  return TRUE;

//typedef struct _CSADDR_INFO {
//
//		SOCKET_ADDRESS	    LocalAddr ;
//		SOCKET_ADDRESS    	RemoteAddr ;
//		INT	    iSocketType ;
//		INT	    iProtocol ;
//} CSADDR_INFO ;

WORD FTPClient::port(String portDesignator)
{
	if(!mFTPControl.isConnected())return FALSE;
	if(!putControlData(mFTPCommands[DataPort]+String(" ")+portDesignator))return FALSE;
  return TRUE;
}

WORD FTPClient::getControlData(void)
{
	WORD isInMultiLine(FALSE);
  WORD processing(TRUE);
	String replyCode;
	String stringData;

  mResponseStrings.remove();
	while(processing)
	{
		if(!mFTPControl.receive(mResponseStrings)||!mResponseStrings.size())return FALSE;
		for(short itemIndex=0;itemIndex<mResponseStrings.size();itemIndex++)
		{
			stringData=mResponseStrings[itemIndex];
			message(stringData);
			if(!isInMultiLine&&'-'==stringData[3])
			{
				isInMultiLine=TRUE;
        processing=TRUE;
				replyCode=stringData.betweenString(0,'-');
			}
			else if(isInMultiLine&&replyCode==stringData.betweenString(0,' '))
			{
				processing=FALSE;
        isInMultiLine=FALSE;
			}
			else if(!isInMultiLine)processing=FALSE;
		}
	}
	return TRUE;
}

WORD Socket::receive(String &receiveString)const
{
	short receiveCount;
  BYTE rcvChar;

	if(!isConnected())return FALSE;
//	if(!hasData())return FALSE;
	receiveString.reserve(MaxLength);
	while(TRUE)
	{
//		if(!hasData(FALSE))break;
    while(!hasData(FALSE));
		if((receiveCount=::recv(mSocket,&rcvChar,1,0L))==SOCKET_ERROR||!receiveCount)return FALSE;
		if(rcvChar==0x0D)continue;
    else if(rcvChar==0x0A)break;
    receiveString+=rcvChar;
	}
  return receiveString.length();
}

void FTPData::create(void)
{
	ServEnt serviceEntry;

	destroy();
	if(!mWSASystem.isInitialized())return;
	if(!serviceEntry.serviceByName("ftp-data","tcp"))return;
	if(!mFTPDataSocket.openSocket())return;
	family(AF_INET);
	port(htons(serviceEntry.port()));
	if(!mFTPDataSocket.bind((INETSocketAddress&)*this))return;
	if(!mFTPDataSocket.listen())return;
}

WORD ServEnt::isWINNT(void)const
{
	OSVERSIONINFO osVersionInfo;
	::GetVersionEx(&osVersionInfo);
  return osVersionInfo.dwPlatformId==VER_PLATFORM_WIN32_NT;
}





WORD Socket::receive(String &receiveString)const
{
	short receiveCount;
	char rcvChar;
	
	if(!isConnected())return FALSE;
	receiveString.reserve(MaxLength);
	while(TRUE)
	{
	  if(!isConnected())break;
		while(!hasData(FALSE));
		if((receiveCount=::recv(mSocket,&rcvChar,1,0L))==SOCKET_ERROR||!receiveCount)return FALSE;
		if(rcvChar==0x0D)continue;
    else if(rcvChar==0x0A)break;
    receiveString+=rcvChar;
	}
  return receiveString.length();
}

#if 0
WORD Socket::receive(String &receiveString)
{
	short receiveCount;
	char rcvChar;
	
	receiveString.reserve(MaxLength);
	while(TRUE)
	{
	  if(!isConnected())return FALSE;
		while(!hasData(FALSE));
		if((receiveCount=::recv(mSocket,&rcvChar,1,0L))==SOCKET_ERROR||!receiveCount)return FALSE;
		if(rcvChar==0x0D)continue;
    else if(rcvChar==0x0A)break;
		else receiveString+=rcvChar;
	}
	return TRUE;
}
#endif



WORD Socket::hasData(WORD useWait)const
{
	fd_set setDescriptor;
	timeval waitTime;

	setDescriptor.fd_count=1;
	setDescriptor.fd_array[0]=mSocket;
	if(useWait){waitTime.tv_sec=2;waitTime.tv_usec=0;}
	else {waitTime.tv_sec=1;waitTime.tv_usec=500;}
	return ::select(0,&setDescriptor,0,0,&waitTime);
}



inline
WORD ReceiveCache::hasData(BOOL acquireData)
{
  int receiveCount;

  if(itemsInCache()>0)return TRUE;
	if(!acquireData)return FALSE;
	return cacheData();
}


  if(!(itemsInCache()>0))
	{
	  if(!waitForData&&!isReady(TRUE))return FALSE;
		if(!cacheData())return FALSE;
	}



//WORD Socket::hasData(WORD useWait)const
//{
//	fd_set setDescriptor;
//	timeval waitTime;
//
//	setDescriptor.fd_count=1;
//	setDescriptor.fd_array[0]=mSocket;
//	if(useWait){waitTime.tv_sec=WaitTime;waitTime.tv_usec=0;}
//	else {waitTime.tv_sec=0;waitTime.tv_usec=500;}
//	return ::select(0,&setDescriptor,0,0,&waitTime);
//}




class EchoServer : public GenericServer
{
public:
  EchoServer(void);
	virtual ~EchoServer();
protected:
  WORD charHandler(const char &charData);
	void acceptHandler(void);
	void message(const String &message);
private:
  Console mWinConsole;
};

EchoServer::EchoServer(void)
{
}

EchoServer::~EchoServer()
{
  mWinConsole.writeLine("ECHO server is destructing...");
	mWinConsole.read();
}

void EchoServer::acceptHandler(void)
{
  char charData;

  send(TelnetPacket::InterpretAsCommand);
  send(TelnetPacket::Do);
  send(TelnetPacket::TermType);

	send(TelnetPacket::InterpretAsCommand);
	send(TelnetPacket::Do);
	send(TelnetPacket::Authentication);

	receive(charData);
	receive(charData);
	receive(charData);

	receive(charData);
	receive(charData);
	receive(charData);

	send("welcome to generic server, please login:");
}

WORD EchoServer::charHandler(const char &charData)
{
  String strVal;
	char rcvChar;

	::sprintf(strVal,"received : (%lx)(%c)",(int)charData,charData);
	message(strVal);
	return TRUE;
}

void EchoServer::message(const String &message)
{
  mWinConsole.writeLine(message);
}




#if 0
WORD FTPClient::open(String hostName)
{
	HostEnt hostEntry;
	ServEnt serverEntry;

	message(String("trying ")+hostName+String("..."));
	if(!mWSASystem.isInitialized()){message("WINSOCK initialization failure.");return FALSE;}
	InternetAddress internetAddress(hostName);
	if(!internetAddress.isZero()){if(!hostEntry.hostByAddress(internetAddress)){message(String("no DNS entry for ")+hostName);return FALSE;}}
	else if(!hostEntry.hostByName(hostName)){message(String("no DNS entry for ")+hostName);return FALSE;}
	message(String("connect...")+String("'")+hostEntry.hostName()+String("' (")+(String)(hostEntry.addresses())[0]+String(")"));
	INETSocketAddress::internetAddress((hostEntry.addresses())[0]);
	if(!serverEntry.serviceByName("ftp","tcp")){message("cannot determine port number for ftp daemon.");return FALSE;}
	if(!mFTPControl.openSocket()){message("unable to create socket.");return FALSE;}
	INETSocketAddress::family(PF_INET);
	INETSocketAddress::port(serverEntry.port());
	if(!mFTPControl.connect((INETSocketAddress&)*this)){message("unable to connect to ftp daemon");return FALSE;}
	if(!receive(mAckConnectionResponseStrings))return FALSE;
	mFTPControl.getSocketName((INETSocketAddress&)*this);
	return mFTPControl.isConnected();
}
#endif



WORD Socket::receiveBinary(String pathFileName,TimeInfo &someTimeInfo)
{
	Profile iniProfile;
	char rcvChar[BlockLength];
	DWORD bufferLength(sizeof(rcvChar));
	DWORD receiveCount(0);

	if(!isConnected())return FALSE;
//	mReceiveCache.reset();
	iniProfile.makeFileName(pathFileName);
	if(pathFileName.isNull())return FALSE;
	FileHandle writeFile(pathFileName,FileHandle::Write,FileHandle::ShareNone,FileHandle::Create);
	someTimeInfo.startTime();
	while(TRUE)
	{
    while(!mReceiveCache.isReady(FALSE));
//		if((bufferLength=::recv(mSocket,rcvChar,bufferLength,0L))==SOCKET_ERROR||!bufferLength)break;
    if(!mReceiveCache.receive(rcvChar,sizeof(rcvChar),bufferLength))break;
		writeFile.write((unsigned char*)rcvChar,bufferLength);
		receiveCount+=bufferLength;
		if(!isConnected())break;
	}
	someTimeInfo.endTime(receiveCount);
	return TRUE;
}


WORD Socket::receiveBinary(String pathFileName,DWORD sizeData,TimeInfo &someTimeInfo)
{
  String strDirectory(pathFileName);
	DiskInfo diskInfo;
	Profile iniProfile;
	char rcvChar[BlockLength];
	DWORD bufferLength;
	DWORD receiveCount(0);

	if(!isConnected())return FALSE;
//	mReceiveCache.reset();
	if(diskInfo.getDiskFreeSpace()<sizeData)return FALSE;
	if(pathFileName.isNull())return FALSE;
	if(iniProfile.makeDirectoryName(strDirectory))diskInfo.createDirectory(strDirectory);
	FileHandle writeFile(pathFileName,FileHandle::Write,FileHandle::ShareNone,FileHandle::Create);
	if(!writeFile.isOkay())return FALSE;
	someTimeInfo.startTime();
	while(receiveCount<sizeData)
	{
		if(receiveCount+sizeof(rcvChar)>sizeData)bufferLength=sizeData-receiveCount;
		else bufferLength=sizeof(rcvChar);
    while(!mReceiveCache.isReady(FALSE)); 
//		if((bufferLength=::recv(mSocket,rcvChar,bufferLength,0L))==SOCKET_ERROR||!bufferLength)return FALSE;
    if(!mReceiveCache.receive(rcvChar,sizeof(rcvChar),bufferLength))break;
		writeFile.write((unsigned char*)rcvChar,bufferLength);
		receiveCount+=bufferLength;
		if(!isConnected())break;
	}
	someTimeInfo.endTime(sizeData);
	return TRUE;
}