Do not close RRQ socket until the last ACK is received.

git-svn-id: http://svn.klever.net/kin/pumpkin/trunk@152 fe716a7a-6dde-0310-88d9-d003556173a8

3 files changed, 107 insertions, 204 deletions

diff --git a/PumpKINDlg.cpp b/PumpKINDlg.cpp
index 070f3e8..2a01918 100644
--- a/PumpKINDlg.cpp
+++ b/PumpKINDlg.cpp
@@ -326,902 +326,906 @@ void CPumpKINDlg::OnPaint()
 

 		// Center icon in client rectangle

 		int cxIcon = GetSystemMetrics(SM_CXICON);

 		int cyIcon = GetSystemMetrics(SM_CYICON);

 		CRect rect;

 		GetClientRect(&rect);

 		int x = (rect.Width() - cxIcon + 1) / 2;

 		int y = (rect.Height() - cyIcon + 1) / 2;

 

 		// Draw the icon

 		dc.DrawIcon(x, y, m_hIcon);

 	}

 	else

 	{

 	CPaintDC pDC(this);

 	CDC bmpDC;

 		bmpDC.CreateCompatibleDC(&pDC);

 		bmpDC.SelectObject(&m_bmpBack);

 	CRect rc;

 		GetClientRect(&rc);

 		for(int x=-m_bitmapBack.bmWidth*2/4;x<rc.Width();x+=m_bitmapBack.bmWidth)

 			for(int y=-m_bitmapBack.bmHeight*2/4;y<rc.Height();y+=m_bitmapBack.bmHeight)

 				pDC.BitBlt(x,y,m_bitmapBack.bmWidth,m_bitmapBack.bmHeight,&bmpDC,0,0,SRCCOPY);

 		bmpDC.DeleteDC();

 		CDialog::OnPaint();

 	}

 }

 

 // The system calls this to obtain the cursor to display while the user drags

 //  the minimized window.

 HCURSOR CPumpKINDlg::OnQueryDragIcon()

 {

 	return (HCURSOR) m_hIcon;

 }

 

 int CPumpKINDlg::OnCreate(LPCREATESTRUCT lpCreateStruct) 

 {

 	if (CDialog::OnCreate(lpCreateStruct) == -1)

 		return -1;

 

 	if(!m_Listener.SetListen(m_bListen)) {

 		m_bListen=FALSE;

 		TRACE0("Failed to create socket\n");

 		AfxMessageBox(IDS_BOX_CANTBIND,MB_OK|MB_ICONEXCLAMATION);

 	}

 

 	if(!m_Trayer->Create(NULL,"PumpKIN TrayIcon",WS_CHILD,CRect(0,0,0,0),this,0)){

 		TRACE0("Failed to create trayer\n");

 		return -1;

 	}

 

 NOTIFYICONDATA nid;

 	memset(&nid,0,sizeof(nid));

 	nid.cbSize=sizeof(nid);

 	nid.hWnd=m_Trayer->m_hWnd;

 	nid.uID=IDC_TRAYICON;

 	nid.uFlags=NIF_MESSAGE|NIF_ICON|NIF_TIP;

 	nid.uCallbackMessage=WM_TRAYICON;

 	nid.hIcon=AfxGetApp()->LoadIcon(IDR_MAINFRAME);

 	// *** Load from resource

 	strcpy(nid.szTip,"PumpKIN");

 	VERIFY(Shell_NotifyIcon(NIM_ADD,&nid));

 

 	return 0;

 }

 

 void CListenSocket::OnReceive(int nErrorCode)

 {

 	ASSERT(m_Daddy);

 	if(nErrorCode){

 		m_Daddy->LogLine(IDS_LOG_LISTENRECEIVEERROR);

 		return;

 	}

 DWORD fionread = 0;

 	VERIFY(IOCtl(FIONREAD,&fionread));	// *** Do some checking on the value acquired

 tftp *tftpRQ = tftp::Allocate(fionread);

 	ASSERT(tftpRQ);

 SOCKADDR_IN sin;

 	if(!tftpRQ->Receive(this,fionread,&sin)){

 		m_Daddy->LogLine(IDS_LOG_LISTENACCEPTERROR);

 		delete tftpRQ;

 		return;

 	}

 #ifndef	NDEBUG

 CString tmp;

 	tmp.Format("%u - %s - %u\n",tftpRQ->Opcode(),inet_ntoa(sin.sin_addr),sin.sin_port);

 	TRACE0(tmp);

 #endif

 POSITION p = m_Daddy->m_Xfers.GetStartPosition();

 	while(p){

 	SOCKET key;

 	CXferSocket *sock;

 		m_Daddy->m_Xfers.GetNextAssoc(p,key,sock);

 		ASSERT(sock);

 		if(sock->m_Peer.sin_addr.s_addr==sin.sin_addr.s_addr && sock->m_Peer.sin_port==sin.sin_port){

 			TRACE0("Ignoring request which we are already processing\n");

 			delete tftpRQ;

 			return;

 		}

 	}

 	switch(tftpRQ->Opcode()){

 	case tftp::opRRQ:

 		// Read Request

 		{

 		CString tmp;

 			tmp.Format(IDS_LOG_RRQSERVE,tftpRQ->rqFileName(),tftpRQ->rqType(),inet_ntoa(sin.sin_addr));

 			m_Daddy->LogLine(tmp);

 		CRRQSocket *s = new CRRQSocket(m_Daddy,tftpRQ->rqFileName(),tftpRQ->rqType(),&sin);

 			ASSERT(s);

 			tftpRQ->GetOptions(&s->m_Options);

 			if(!s->Create())

 				s->Destroy(FALSE);

 		}

 		break;

 	case tftp::opWRQ:

 		// Write Request

 		{

 		CString tmp;

 			tmp.Format(IDS_LOG_WRQSERVE,tftpRQ->rqFileName(),tftpRQ->rqType(),inet_ntoa(sin.sin_addr));

 			m_Daddy->LogLine(tmp);

 		CWRQSocket *s = new CWRQSocket(m_Daddy,tftpRQ->rqFileName(),tftpRQ->rqType(),&sin);

 			ASSERT(s);

 			tftpRQ->GetOptions(&s->m_Options);

 			if(!s->Create(NULL,NULL))

 				s->Destroy(FALSE);

 		}

 		break;

 	default:

 		m_Daddy->LogLine(IDS_LOG_LISTENOPCODE);

 		delete tftpRQ;

 		return;

 	}

 	delete tftpRQ;

 }

 

 BOOL tftp::Receive(CAsyncSocket* socket,UINT maxLength,SOCKADDR_IN *sin)

 {

 	ASSERT(socket);

 int saddrLen = sizeof(SOCKADDR_IN);

 	length = sin ? 

 			socket->ReceiveFrom(udpBase(),maxLength,(SOCKADDR*)sin,&saddrLen)

 		:

 			socket->Receive(udpBase(),maxLength)

 	;

 	if(!length)

 		return FALSE;

 	if(length==(tftpLength)SOCKET_ERROR)

 		return FALSE;

 	return TRUE;

 }

 

 UINT tftp::Opcode()

 {

 	return REVERSEBYTES(opcode);

 }

 

 CString tftp::rqFileName()

 {

 	ASSERT(length);

 	ASSERT(Opcode()==opRRQ || Opcode()==opWRQ);

 CString rv;

 	if(memchr(&data.m_RQ.data,0,length-sizeof(opcode)))

 		rv = (LPCTSTR)data.m_RQ.data;

 	return rv;

 }

 

 CString tftp::rqType()

 {

 	ASSERT(length);

 	ASSERT(Opcode()==opRRQ || Opcode()==opWRQ);

 CString rv;

 char *tmp = (char*)memchr(&data.m_RQ.data,0,length-sizeof(opcode));

 	if(tmp++)

 		rv = (LPCTSTR)tmp;

 	return rv;

 }

 

 UINT tftp::GetOptions(tftp::tftpOptions* ops)

 {

 	ASSERT(length);

 	ASSERT(Opcode()==opRRQ || Opcode()==opWRQ || Opcode()==opOACK);

 	ASSERT(ops);

 tftpOptions& o = *ops;

 LPSTR base = (LPSTR)&data.m_RQ.data;

 UINT basePtr = 0;

 	if(Opcode()==opRRQ || Opcode()==opWRQ){

 		base = (LPSTR)memchr(&data.m_RQ.data,0,length-sizeof(opcode));

 		if(!base)

 			return 0;

 		base++;

 		basePtr = (base-(LPSTR)&data.m_RQ.data);

 		base = (LPSTR)memchr(base,0,length-basePtr);

 		if(!base)

 			return 0;

 		base++;

 		basePtr = (base-(LPSTR)&data.m_RQ.data);

 	}

 	ops->RemoveAll();

 UINT rv = 0;

 	while(basePtr<(length-sizeof(opcode))){

 	CString onam = (LPSTR)&data.m_RQ.data[basePtr];

 		basePtr+=onam.GetLength()+1;

 	CString oval = (LPSTR)&data.m_RQ.data[basePtr];

 		basePtr+=oval.GetLength()+1;

 		onam.MakeLower();

 		o[onam]=oval;

 		rv++;

 	}

 	return rv;

 }

 

 tftp::tftp()

 {

 	length=0;

 }

 

 

 void CXferSocket::OnSend(int nErrorCode)

 {

 	if(nErrorCode){

 		ASSERT(m_Daddy);

 		m_Daddy->LogLine(IDS_LOG_XFERSEND);

 		return;

 	}

 	if(!m_Queue.IsEmpty()){

 	tftp *p = m_Queue.GetHead();

 		ASSERT(p);

 		m_Queue.RemoveHead();

 		if(!p->Send(this,&m_Peer)){

 			ASSERT(m_Daddy);

 			m_Daddy->LogLine(IDS_LOG_XFERUDPSEND);

 		}

 		delete p;

 	}

 	DoSelect();

 	if(m_Queue.IsEmpty()){

 		switch(state){

 		case stateDeny:

 			Destroy(FALSE);

 			break;

 		case stateFinish:

 			Destroy(TRUE);

 			break;

 		}

 	}

 }

 

 BOOL tftp::Send(CAsyncSocket *socket,SOCKADDR_IN* saddr)

 {

 	ASSERT(socket);

 int rv = socket->SendTo(udpBase(),length,(SOCKADDR*)saddr,sizeof(SOCKADDR_IN));

 	if(rv!=length)

 		return FALSE;

 	return TRUE;

 }

 

-void CXferSocket::DoSelect()

+void CXferSocket::DoSelect(BOOL do_select)

 {

 	if(m_Peer.sin_addr.s_addr!=INADDR_NONE)

-		AsyncSelect(FD_CLOSE|FD_READ|(m_Queue.IsEmpty()?0:FD_WRITE));

+		AsyncSelect(FD_CLOSE|FD_READ|((m_Queue.IsEmpty()&&!do_select)?0:FD_WRITE));

 }

 

 void CXferSocket::OnReceive(int nErrorCode)

 {

 	if(nErrorCode){

 		ASSERT(m_Daddy);

 		m_Daddy->LogLine(IDS_LOG_XFERRECEIVE);

 		return;

 	}

 	ASSERT(m_Daddy);

 DWORD fionread = 0;

 	VERIFY(IOCtl(FIONREAD,&fionread));

 tftp *p = tftp::Allocate(fionread);

 	ASSERT(p);

 SOCKADDR_IN sin;

 	if(!p->Receive(this,fionread,&sin)){

 		m_Daddy->LogLine(IDS_LOG_XFERUDPRECEIVE);

 		delete p;

 	}else

 		if(m_Peer.sin_addr.s_addr==INADDR_NONE){

 			m_Peer.sin_addr=sin.sin_addr;

 			m_Peer.sin_port=sin.sin_port;

 	}

 BOOL alive = TRUE;

 	if(state==stateInit){

 		state=stateXfer;

 		m_Peer.sin_port=sin.sin_port;

 		UpdateList();

 	}

 	if(sin.sin_addr.s_addr!=m_Peer.sin_addr.s_addr || sin.sin_port!=m_Peer.sin_port){

 		m_Daddy->LogLine(IDS_LOG_XFERSOURCETID);

 		// *** Bounce it!

 	}else{

 		alive = OnTFTP(p);

 	}

 	delete p;

 	if(alive){

 		DoSelect();

 		ResetTimeout();

 	}

 }

 

 void CXferSocket::SetPeer(SOCKADDR_IN *sin)

 {

 	ASSERT(sin);

 	memmove(&m_Peer,sin,sizeof(m_Peer));

 }

 

 void CXferSocket::UpdateList()

 {

 	ASSERT(m_Daddy);

 LV_FINDINFO lvf;

 	memset(&lvf,0,sizeof(lvf));

 	lvf.flags=LVFI_PARAM;

 	lvf.lParam=(LPARAM)this;

 int i = m_Daddy->m_List.FindItem(&lvf);

 	if(i<0){

 		ASSERT(IsKindOf(RUNTIME_CLASS(CRRQSocket)) || IsKindOf(RUNTIME_CLASS(CWRQSocket)));

 		i=m_Daddy->m_List.InsertItem(0,m_FileName,IsKindOf(RUNTIME_CLASS(CRRQSocket))?m_Daddy->m_iRRQ:m_Daddy->m_iWRQ);

 		ASSERT(!(i<0));

 		m_Daddy->m_List.SetItemData(i,(DWORD)this);

 	}

 	m_Daddy->m_List.SetItemText(i,CPumpKINDlg::subitemFile,m_FileName);

 	m_Daddy->m_List.SetItemText(i,CPumpKINDlg::subitemType,m_Type);

 	m_Daddy->m_List.SetItemText(i,CPumpKINDlg::subitemPeer,inet_ntoa(m_Peer.sin_addr));

 CString tmp;

 	tmp.Format(IDS_FMT_BYTES,GetACK());

 	m_Daddy->m_List.SetItemText(i,CPumpKINDlg::subitemBytes,tmp);

 	if(m_xferSize>=0){

 		tmp.Format(IDS_FMT_BYTES,m_xferSize);

 		m_Daddy->m_List.SetItemText(i,CPumpKINDlg::subitemTSize,tmp);

 	}

 }

 

 CXferSocket::CXferSocket()

 	: m_wndResolver(NULL), m_Retry(NULL), m_bRetry(FALSE),

 	m_blkSize(512), m_timeOut(30), m_xferSize(-1),

 	m__blkSize(512), m__timeOut(30)

 {

 	m_Daddy=NULL;

 	m_Peer.sin_addr.s_addr=INADDR_NONE;

 	m_Peer.sin_family=AF_INET;

 	state=stateNone;

 }

 

 ULONG CXferSocket::GetACK()

 {

 	return 0;

 }

 

 CXferSocket::CXferSocket(CPumpKINDlg *daddy,LPCTSTR fileName,LPCTSTR type,SOCKADDR_IN* sin)

 	: m_wndResolver(NULL), m_Retry(NULL), m_bRetry(FALSE),

 	m_blkSize(512), m_timeOut(30), m_xferSize(-1),

 	m__blkSize(512), m__timeOut(30)

 {

 	m_Peer.sin_family=AF_INET;

 	state=stateNone;

 	ASSERT(daddy);

 	m_Daddy=daddy;

 	m_timeOut=m__timeOut=m_Daddy->m_TFTPTimeOut.GetTotalSeconds();

 	if(sin){

 		m_Peer.sin_addr.s_addr=sin->sin_addr.s_addr;

 		m_Peer.sin_port=sin->sin_port;

 	}else

 		m_Peer.sin_addr.s_addr=INADDR_NONE;

 	m_FileName=fileName;

 	m_Type=type;

 }

 

 BOOL CRRQSocket::Create(LPCTSTR localFile,LPCTSTR hostName)

 {

 	if(!CAsyncSocket::Create(0,SOCK_DGRAM))

 		return FALSE;

 	ASSERT(m_Daddy);

 	ASSERT(m_Peer.sin_addr.s_addr!=INADDR_NONE || hostName);

 	m_Daddy->m_Xfers[m_hSocket]=this;

 CString lFile = localFile?localFile:m_FileName;

 	TurnSlashes(lFile,TRUE);

 	UpdateList();

 	if(!localFile){	// Check only for incoming requests

 		if(CheckBadRelativeness(m_FileName)){

 			Deny(tftp::errAccessViolation,IDS_TFTP_ERROR_ACCESS);

 			return TRUE;

 		}

 		int atar=m_Daddy->m_aclRules.FindTarget(acl_rule::opRRQ,m_Peer.sin_addr.s_addr);

 		if(atar<0)

 			atar = m_Daddy->m_RRQMode;

 		switch(atar){

 		case CPumpKINDlg::rrqGiveAll:

 			break;

 		case CPumpKINDlg::rrqAlwaysConfirm:

 			if(ConfirmRequest())

 				break;

 		default:

 			TRACE1("Unexpected access target: %d\n",atar);

 		case CPumpKINDlg::rrqDenyAll:

 			Deny(tftp::errAccessViolation,IDS_TFTP_ERROR_ACCESS);

 			return TRUE;

 		}

 	}

 CString fn = localFile?ApplyRootGently(lFile):ApplyRoot(lFile);

 CFileException e;

 	if(!m_File.Open(fn,CFile::modeRead|CFile::shareDenyWrite,&e)){

 		if(localFile){

 		CString tmp;

 			tmp.Format(IDS_LOG_FAILEDLOCALFILE,fn);

 			m_Daddy->LogLine(tmp);

 			return FALSE;

 		}

 		Deny(&e);

 		return TRUE;

 	}

 	m_xferSize=m_File.GetLength();	// *** HANDLE EXCEPTION

 	if(hostName){

 		m_HostName=hostName;

 	

 	CString tmp;

 		tmp.Format(IDS_LOG_SENDING,m_FileName,m_HostName);

 		m_Daddy->LogLine(tmp);

 

 		CString inAddr = hostName;

 	int at = inAddr.Find('@');

 		if(at>=0)

 			inAddr=inAddr.Mid(at+1);

 		if((m_Peer.sin_addr.s_addr=inet_addr((LPCTSTR)inAddr))==INADDR_NONE){

 			ASSERT(!m_wndResolver);

 			m_wndResolver = new CResolver(this);

 			ASSERT(m_wndResolver);

 			return m_wndResolver->Resolve();

 		}

 		else

 			OnHostKnown();

 	}else{

 	tftp::tftpOptions o;

 	CString v;

 		if(m_Options.Lookup(tftpoBSize,v)){

 			m__blkSize=atoi(v);

 			if(m__blkSize){

 				m_blkSize=m__blkSize;

 				v.Format("%u",m_blkSize);

 				o[tftpoBSize]=v;

 			}

 		}

 		if(m_Options.Lookup(tftpoTSize,v)){

 			v.Format("%lu",m_xferSize);

 			o[tftpoTSize]=v;

 		}

 		if(m_Options.Lookup(tftpoTOut,v)){

 			m__timeOut=atoi(v);

 			if(m__timeOut){

 				m_timeOut=m__timeOut;

 				v.Format("%u",m_timeOut);

 				o[tftpoTOut]=v;

 			}

 		}

 		state = stateXfer;

 		m_ACK=0;

 		if(o.GetCount()){

 		tftp *p = tftp::Allocate(tftp::tftpOACK::tftpSize(&o));

 			ASSERT(p);

 			p->SetOpcode(tftp::opOACK);

 			p->data.m_OACK.Set(&o);

 			PostTFTP(p,TRUE);

 		}else

 			DoXfer();

 	}

 	return TRUE;

 }

 

 CRRQSocket::CRRQSocket(CPumpKINDlg *daddy,LPCTSTR fileName,LPCTSTR type,SOCKADDR_IN *sin)

 	: CXferSocket(daddy,fileName,type,sin)

 {

 	m_ACK=0;

 	m_LastSlack=0;

 }

 

 UINT tftp::tftpERROR::tftpSize(LPCTSTR msg)

 {

 	return tftpHdrSize-tftpSlackSize+sizeof(tftp::tftpERROR::tftpErrorCode)+strlen(msg)+1;

 }

 

 tftp* tftp::Allocate(UINT tftpSize)

 {

 	ASSERT(tftpSize);

 tftp* rv = (tftp*) new BYTE[tftpSlackSize+tftpSize];

 	ASSERT(rv);

 	rv->length=tftpSize;

 	return rv;

 }

 

 void tftp::errSet(UINT code,LPCTSTR msg)

 {

 	ASSERT(this);

 	ASSERT(length>=data.m_ERROR.tftpSize(msg));

 	strcpy((char*)data.m_ERROR.data,msg);

 	data.m_ERROR.SetCode(code);

 }

 

 void CXferSocket::PostTFTP(tftp* p,BOOL retryable)

 {

 	ASSERT(p);

 	m_Queue.AddTail(p);

 	DoSelect();

 	if(!m_bRetry){

 		if(retryable)

 			SetTry(p);

 		else

 			SetTry();

 	}

 	ResetTimeout();

 }

 

 void CXferSocket::Deny(UINT errCode,UINT errID)

 {

 	PostError(errCode,errID);

 	state=stateDeny;

 }

 

 void CRRQSocket::DoXfer()

 {

 tftp *p = tftp::Allocate(tftp::tftpDATA::tftpSize(m_blkSize));

 	ASSERT(p);

 	p->SetOpcode(tftp::opDATA);

 	TRY{

 		m_File.Seek(m_ACK*m_blkSize,CFile::begin);

 	int bytes = m_File.Read(p->data.m_DATA.data,m_blkSize);

 		p->data.m_DATA.SetBlock(m_ACK+1);

 		p->length=p->length-m_blkSize+bytes;

 		m_LastSlack = m_blkSize-bytes;

 		PostTFTP(p);

 		if(bytes<m_blkSize){

-			state=stateFinish;

-			ASSERT(m_Daddy);

-		CString tmp;

-			tmp.Format(IDS_LOG_XFERRRQFINISHED,(LPCTSTR)m_FileName);

-			m_Daddy->LogLine(tmp);

+			state=stateClosing; m_ACKtoClose = m_ACK+1;

 		}

 	}CATCH(CFileException,e){

 		Deny(e);

 	}END_CATCH

 }

 

 UINT tftp::tftpDATA::tftpSize(UINT blkSize)

 {

 	return tftpHdrSize-tftpSlackSize+sizeof(tftp::tftpDATA)

 		-sizeof(BYTE)+blkSize;

 }

 

 void CXferSocket::Deny(CFileException* e)

 {

 	PostError(e);

 	state=stateDeny;

 }

 

 void CXferSocket::PostError(UINT errCode,UINT errID)

 {

 CString msg;

 	msg.LoadString(errID);

 	ASSERT(m_Daddy);

 /*	// ***

 CString tmp;

 	tmp.Format(IDS_LOG_SENTTFTPERROR,errCode,(LPCTSTR)msg);

 	m_Daddy->LogLine(tmp);

  */

 tftp* err = tftp::Allocate(tftp::tftpERROR::tftpSize(msg));

 err->SetOpcode(tftp::opERROR);

 	err->errSet(errCode,msg);

 	PostTFTP(err);

 }

 

 void CXferSocket::PostError(CFileException* e)

 {

 UINT eCode;

 UINT eMsgID;

 	switch(e->m_cause){

 	case CFileException::fileNotFound:

 		eCode=tftp::errNotFound;

 		eMsgID=IDS_TFTP_ERROR_NOTFOUND;

 		break;

 	case CFileException::accessDenied:

 		eCode=tftp::errAccessViolation;

 		eMsgID=IDS_TFTP_ERROR_ACCESS;

 		break;

 	case CFileException::directoryFull:

 		eCode=tftp::errDiskFull;

 		eMsgID=IDS_TFTP_ERROR_DIRFULL;

 		break;

 	case CFileException::sharingViolation:

 		eCode=tftp::errAccessViolation;

 		eMsgID=IDS_TFTP_ERROR_SHARING;

 		break;

 	case CFileException::diskFull:

 		eCode=tftp::errDiskFull;

 		eMsgID=IDS_TFTP_ERROR_DISKFULL;

 		break;

 	default:

 		eCode=tftp::errUndefined;

 		eMsgID=IDS_TFTP_ERROR_UNDEFINED;

 		break;

 	}

 	PostError(eCode,eMsgID);

 }

 

 ULONG CRRQSocket::GetACK(void)

 {

 	return (m_ACK*m_blkSize)-m_LastSlack;

 }

 

 BOOL CRRQSocket::OnTFTP(tftp* p)

 {

 BOOL rv = TRUE;

 	switch(p->Opcode()){

 	case tftp::opOACK:

-		m_ACK=0;

-		ASSERT(state!=stateFinish);

-	{

-	tftp::tftpOptions o;

-		if(p->GetOptions(&o)){

-		CString v;

-			if(o.Lookup(tftpoBSize,v)){

-				m_blkSize=atoi(v);

-				if(!m_blkSize){	// *** More sanity checks

-					Deny(tftp::errOption,IDS_TFTP_ERROR_BSIZE);

-					rv = TRUE;

-					break;

+		{

+			m_ACK=0;

+			ASSERT(state!=stateFinish);

+		tftp::tftpOptions o;

+			if(p->GetOptions(&o)){

+			CString v;

+				if(o.Lookup(tftpoBSize,v)){

+					m_blkSize=atoi(v);

+					if(!m_blkSize){	// *** More sanity checks

+						Deny(tftp::errOption,IDS_TFTP_ERROR_BSIZE);

+						rv = TRUE;

+						break;

+					}

 				}

-			}

-			if(o.Lookup(tftpoTOut,v)){

-				m_timeOut=atoi(v);

-				if(!m_timeOut){	// *** More sanity checks

-					Deny(tftp::errOption,IDS_TFTP_ERROR_TOUT);

-					rv = TRUE;

-					break;

+				if(o.Lookup(tftpoTOut,v)){

+					m_timeOut=atoi(v);

+					if(!m_timeOut){	// *** More sanity checks

+						Deny(tftp::errOption,IDS_TFTP_ERROR_TOUT);

+						rv = TRUE;

+						break;

+					}

+				}

+				if(o.Lookup(tftpoXResume,v)){

+					m_ACK=atoi(v);

 				}

 			}

-			if(o.Lookup(tftpoXResume,v)){

-				m_ACK=atoi(v);

-			}

+			UpdateList();

+			DoXfer();

 		}

-		UpdateList();

-		DoXfer();

-	}

 		break;

 	case tftp::opACK:

 		m_ACK=p->data.m_ACK.Block();

-		if(state!=stateFinish){

+		if(state==stateClosing && m_ACK==m_ACKtoClose) {

+			state = stateFinish;

+			ASSERT(m_Daddy);

+		CString tmp;

+			tmp.Format(IDS_LOG_XFERRRQFINISHED,(LPCTSTR)m_FileName);

+			m_Daddy->LogLine(tmp);

+			rv = FALSE;

+			DoSelect(TRUE);

+		}else if(state!=stateFinish){

 			UpdateList();

 			DoXfer();

 		}

 		break;

 	case tftp::opERROR:

 		{

 			ASSERT(m_Daddy);

 		CString tmp;

 			tmp.Format(IDS_LOG_GOTTFTPERROR,p->data.m_ERROR.Code(),(LPCTSTR)p->errMessage());

 			m_Daddy->LogLine(tmp);

 		}

 		Destroy(FALSE);

 		rv = FALSE;

 		break;

 	default:

 		{

 			ASSERT(m_Daddy);

 			CString tmp;

 			tmp.Format(IDS_LOG_XFEROPCODE,p->Opcode());

 			m_Daddy->LogLine(tmp);

 			// *** Self destruct maybe??

 		}

 		break;

 	}

 	return rv;

 }

 

 BOOL CWRQSocket::OnTFTP(tftp* p)

 {

 	switch(p->Opcode()){

 	case tftp::opOACK:

 		ASSERT(state!=stateFinish);

 	{

 		if(m_bResume)

 			m_ACK=m_File.GetLength()/m_blkSize;

 		else

 			m_ACK=0;

 	tftp::tftpOptions o;

 		if(p->GetOptions(&o)){

 		CString v;

 			if(o.Lookup(tftpoBSize,v)){

 				m_blkSize=atoi(v);

 				if(!m_blkSize){	// *** More sanity checks

 					Deny(tftp::errOption,IDS_TFTP_ERROR_BSIZE);

 					return TRUE;

 				}

 			}

 			if(o.Lookup(tftpoTOut,v)){

 				m_timeOut=atoi(v);

 				if(!m_timeOut){	// *** More sanity checks

 					Deny(tftp::errOption,IDS_TFTP_ERROR_TOUT);

 					return TRUE;

 				}

 			}

 			if(o.Lookup(tftpoTSize,v)){

 				m_xferSize=atoi(v);

 			}

 		}

 		UpdateList();

 		DoXfer();

 	}

 		break;

 	case tftp::opDATA:

 		{

 		UINT	block = p->data.m_DATA.Block();

 			TRY{

 				m_File.Seek((block-1)*m_blkSize,CFile::begin);

 			int bytes = p->length-sizeof(p->data.m_DATA.block)-(tftpHdrSize-tftpSlackSize);

 				if(bytes){

 					m_File.Write(p->data.m_DATA.data,bytes);

 					// *** Move to the other place where we can do it not that often

 					m_File.SetLength(m_File.GetPosition());

 				}

 				if(bytes<m_blkSize){

 					state=stateFinish;

 					ASSERT(m_Daddy);

 				CString tmp;

 					tmp.Format(IDS_LOG_XFERWRQFINISHED,(LPCTSTR)m_FileName);

 					m_Daddy->LogLine(tmp);

 				}

 				m_ACK=block;

 				m_LastSlack=m_blkSize-bytes;

 				UpdateList();

 				DoXfer();

 			}CATCH(CFileException,e){

 				Deny(e);

 			}END_CATCH

 		}

 		break;

 	case tftp::opERROR:

 		{

 			ASSERT(m_Daddy);

 		CString tmp;

 			tmp.Format(IDS_LOG_GOTTFTPERROR,p->data.m_ERROR.Code(),(LPCTSTR)p->errMessage());

 			m_Daddy->LogLine(tmp);

 		}

 		Destroy(FALSE);

 		return FALSE;

 	default:

 		{

 			ASSERT(m_Daddy);

 			CString tmp;

 			tmp.Format(IDS_LOG_XFEROPCODE,p->Opcode());

 			m_Daddy->LogLine(tmp);

 			// *** Self destruct maybe??

 		}

 		break;

 	}

 	return TRUE;

 }

 

 void tftp::SetOpcode(WORD op)

 {

 	opcode = REVERSEBYTES(op);

 }

 void tftp::tftpDATA::SetBlock(WORD b)

 {

 	block=REVERSEBYTES(b);

 }

 WORD tftp::tftpDATA::Block()

 {

 	return REVERSEBYTES(block);

 }

 WORD tftp::tftpACK::Block()

 {

 	return REVERSEBYTES(block);

 }

 void tftp::tftpACK::SetBlock(WORD b)

 {

 	block = REVERSEBYTES(b);

 }

 WORD tftp::tftpERROR::Code()

 {

 	return REVERSEBYTES(code);

 }

 void tftp::tftpERROR::SetCode(WORD c)

 {

 	code = REVERSEBYTES(c);

 }

 

 

 CString tftp::errMessage()

 {

 CString rv;

 	if(memchr(data.m_ERROR.data,0,length-(tftpHdrSize-tftpSlackSize)-sizeof(data.m_ERROR.code)))

 		rv = (LPCTSTR)data.m_ERROR.data;

 	return rv;

 }

 

 void CXferSocket::Destroy(BOOL success)

 {

 	if(m_wndResolver){

 		delete m_wndResolver;

 		m_wndResolver=NULL;

 	}

 	SetTry();

 	m_Daddy->m_bnw.StartSound(

 		success

 			? m_Daddy->m_bnwSuccess

 			: m_Daddy->m_bnwAbort

 	);

 	if(m_File.m_hFile!=CFile::hFileNull){

 		TRY{

 			m_File.Close();

 		}CATCH(CFileException,e){

 			TRACE0("Error closing file\n");

 		}END_CATCH

 	}

 	ASSERT(m_Daddy);

 	m_Daddy->KillTimer(m_hSocket);

 	m_Daddy->m_Xfers.RemoveKey(m_hSocket);

 LV_FINDINFO lvf;

 	memset(&lvf,0,sizeof(lvf));

 	lvf.flags=LVFI_PARAM;

 	lvf.lParam=(LPARAM)this;

 int i = m_Daddy->m_List.FindItem(&lvf);

 	if(i>=0)

 		m_Daddy->m_List.DeleteItem(i);

 	delete this;

 }

 

 void CPumpKINDlg::LogLineToScreen(LPCTSTR str)

 {

 	ASSERT(m_LogLength);

 	while(m_Log.GetCount()>m_LogLength && m_Log.GetCount()!=LB_ERR){

 	CTime *t = (CTime*)m_Log.GetItemData(0);

 		if(((DWORD)t)!=LB_ERR){

 			ASSERT(t);

 			m_LogTimes.RemoveKey(t);

 			delete t;

 		}

 		m_Log.DeleteString(0);

 	}

 int i = m_Log.AddString(str);

 	ASSERT(i!=LB_ERR);

 CTime *t = new CTime(CTime::GetCurrentTime());

 	m_Log.SetItemData(i,(DWORD)(m_LogTimes[t]=t));

 	m_Log.SetCurSel(i);

 }

 

 void CPumpKINDlg::LogLine(UINT msgID)

 {

 CString tmp;

 	tmp.Format(msgID);

 	LogLine(tmp);

 }

 

 void CXferSocket::TurnSlashes(CString& fn,BOOL bBack)

 {

 int	s = fn.Find(bBack?'/':'\\');

 	while(s>=0){

 		fn.SetAt(s,bBack?'\\':'/');

 		s = fn.Find(bBack?'/':'\\');

 	}

 }

 

 CString CXferSocket::ApplyRoot(LPCTSTR fileName)

 {

 	ASSERT(m_Daddy);

 CString fn  = fileName;

 CString rv = m_Daddy->m_TFTPRoot;

 	if(rv.IsEmpty())

 		rv = ".";

 	if(rv[rv.GetLength()-1]!='\\')

 		rv+="\\";

 	while((!fn.IsEmpty()) && fn[0]=='\\')

 		fn=fn.Mid(1);

 	rv+=fn;

 	return rv;

 }

 

 void CPumpKINDlg::OnOptions() 

 {

 CPropertySheet cps(IDS_TITLE_OPTIONS,this);

 CPropsServer server;

 CPropsNetwork network;

 CPropsSounds sounds;

 CPropsACL acl;

 

 	server.m_RRQMode=m_RRQMode;

 	server.m_TFTPRoot=m_TFTPRoot;

 	server.m_TFTPSubdirs=m_bTFTPSubdirs;

 	server.m_WRQMode=m_WRQMode;

 	server.m_PromptTimeOut=m_PromptTimeOut;

 	server.m_LogFile=m_LogFile;

 

 	network.m_ListenPort=m_ListenPort;

 	network.m_SpeakPort=m_SpeakPort;

 	network.m_TimeOut=m_TFTPTimeOut.GetTotalSeconds();

 	network.m_BlockSize=m_BlockSize;

 

 	sounds.m_Request = m_bnwRequest;

 	sounds.m_Success = m_bnwSuccess;

 	sounds.m_Abort = m_bnwAbort;

 

 	acl.m_rulist = m_aclRules;

diff --git a/PumpKINDlg.h b/PumpKINDlg.h
index c5469f1..23c2657 100644
--- a/PumpKINDlg.h
+++ b/PumpKINDlg.h
@@ -59,442 +59,443 @@ public:
 		BYTE data[1];

 	public:

 	WORD Block();

 	void SetBlock(WORD b);

 	static UINT tftpSize(UINT blkSize=512);

 	};

 	struct tftpACK {

 		WORD block;

 	public:

 	static UINT tftpSize();

 	void SetBlock(WORD b);

 	WORD Block();

 	};

 	struct	tftpERROR {

 		typedef WORD tftpErrorCode;

 		tftpErrorCode code;

 		BYTE data[1];

 	public:

 	void SetCode(WORD c);

 	WORD Code();

 		static UINT tftpSize(LPCTSTR msg);

 	};

 	struct tftpOACK {

 		BYTE data[1];

 	public:

 	void Set(tftpOptions* ops);

 		static UINT tftpSize(tftpOptions* ops);

 	};

 	union	tftpPacket {

 		tftpUNKNOWN m_UNKNOWN;

 		tftpRQ m_RQ;

 		tftpRRQ m_RRQ;

 		tftpWRQ m_WRQ;

 		tftpDATA m_DATA;

 		tftpACK m_ACK;

 		tftpERROR m_ERROR;

 		tftpOACK m_OACK;

 	}	data;

 

 	void	*udpBase(void)	{ return &opcode; }

 public:

 	static tftp* Copy(tftp *src);

 	CString errMessage();

 	void SetOpcode(WORD op);

 	void errSet(UINT code,LPCTSTR msg);

 	static tftp* Allocate(UINT tftpSize=0);

 	BOOL Send(CAsyncSocket *socket,SOCKADDR_IN* saddr);

 	CString rqType();

 	CString rqFileName();

 	UINT GetOptions(tftpOptions* ops);

 	tftp();

 	UINT Opcode();

 	BOOL Receive(CAsyncSocket* socket,UINT maxLength,SOCKADDR_IN *sin=NULL);

 };

 #define	tftpHdrSize	(sizeof(tftp)-sizeof(tftp::tftpPacket))

 #define	tftpSlackSize sizeof(tftp::tftpLength)

 

 struct acl_rule {

  enum {

 	 opRRQ=tftp::opRRQ, opWRQ=tftp::opWRQ

  };

  int op;

  DWORD addr, mask;

  enum {

 	rrqGrant=0, rrqPrompt, rrqDeny,

 	rrqRules,

 	rrqNone=-1

  };

  enum {

 	 wrqGrant=0, wrqPromptIfExists, wrqPrompt, wrqDeny,

 	 wrqRules,

 	 wrqNone=-1

  };

  int target;

 

  acl_rule()

 	 : op(-1), addr(0), mask(0), target(-1) { }

  acl_rule(int o,DWORD a,DWORD m,int t)

 	 : op(o), addr(a), mask(m), target(t) { }

  acl_rule(const acl_rule& s)

 	 : op(s.op), addr(s.addr), mask(s.mask), target(s.target) { }

 

  BOOL IsValid() {

 	 if(op==opRRQ) {

 		 if(target<rrqNone || target>=rrqRules)

 			 return FALSE;

 	 }else if(op==opWRQ) {

 		 if(target<wrqNone || target>=wrqRules)

 			 return FALSE;

 	 }else

 		 return FALSE;

 	 return TRUE;

  }

 

  BOOL IsMatch(int o,DWORD a) {

 	 if(o!=op) return FALSE;

 	 if( (a&mask) != (addr&mask)) return FALSE;

 	 return TRUE;

  }

 

  CString str_addr() {

 	 return inet_ntoa(*(struct in_addr*)&addr);

  }

  CString str_mask() {

 	 return inet_ntoa(*(struct in_addr*)&mask);

  }

  CString str_target() {

 	 if(op==opRRQ) {

 		 switch(target) {

 		 case rrqNone: return "fallback";

 		 case rrqGrant: return "grant";

 		 case rrqPrompt: return "prompt";

 		 case rrqDeny: return "deny";

 		 default: return "?";

 		 }

 	 }else if(op==opWRQ) {

 		 switch(target) {

 		 case wrqNone: return "fallback";

 		 case wrqGrant: return "grant";

 		 case wrqPromptIfExists: return "prompt if exists";

 		 case wrqPrompt: return "prompt";

 		 case wrqDeny: return "deny";

 		 default: return "?";

 		 }

 	 }else

 		 return "?";

  }

 

  void SaveProfile(CWinApp* app,int i) {

 	 CString n; n.Format("%d",i);

 	 app->WriteProfileInt("ACL","op_"+n,op);

 	 app->WriteProfileString("ACL","addr_"+n,str_addr());

 	 app->WriteProfileString("ACL","mask_"+n,str_mask());

 	 app->WriteProfileInt("ACL","target_"+n,target);

  }

 

  void LoadProfile(CWinApp* app,int i) {

 	 CString n; n.Format("%d",i);

 	 op=app->GetProfileInt("ACL","op_"+n,-1);

 	 addr=inet_addr(app->GetProfileString("ACL","addr_"+n));

 	 mask=inet_addr(app->GetProfileString("ACL","mask_"+n));

 	 target=app->GetProfileInt("ACL","target_"+n,-1);

  }

 

 };

 

 class acl_rules_t : public CArray<acl_rule,acl_rule&> {

 public:

 

 	acl_rules_t& operator=(const acl_rules_t& s) {

 		// Copy(s); XXX: unsuprisingly, there's a bug in MFC Copy, *pDst++=*pSrc (no ++ for Src)

 		RemoveAll();

 		int ns = s.GetSize();

 		SetSize(ns);

 		for(int i=0;i<ns;++i)

 			m_pData[i]=s.m_pData[i];

 		return *this;

 	}

 

 	int AppendRule(acl_rule& r) {

 		return Add(r);

 	}

 

 	void DeleteRule(int r) {

 		RemoveAt(r);

 	}

 

 	int FindRule(int op,DWORD ip) {

 		for(int i=0;i<GetSize();++i)

 			if(m_pData[i].IsMatch(op,ip))

 				return i;

 		return -1;

 	}

 

 	int FindTarget(int op,DWORD ip) {

 		int r=FindRule(op,ip);

 		if(r<0) return -1;

 		return m_pData[r].target;

 	}

 

 	void SaveProfile(CWinApp* app) {

 		int s=GetSize();

 		for(int i=0;i<s;++i)

 			m_pData[i].SaveProfile(app,i);

 		app->WriteProfileInt("ACL","rules",s);

 	}

 	void LoadProfile(CWinApp* app) {

 		RemoveAll();

 		int s=app->GetProfileInt("ACL","rules",0);

 		for(int i=0;i<s;++i) {

 			acl_rule r;

 			r.LoadProfile(app,i);

 			if(r.IsValid())

 				Add(r);

 		}

 	}

 };

 

 class CPumpKINDlg;

 class CListenSocket : public CAsyncSocket	{

 public:

 	CPumpKINDlg* m_Daddy;

 	BOOL m_bListen;

 

 	CListenSocket()

 		: m_bListen(FALSE), m_Daddy(0) { }

 

 	BOOL SetListen(BOOL b);

 	virtual void OnReceive(int nErrorCode);

 };

 

 typedef	CList<tftp*,tftp*>	CTFTPList;

 class CResolver;

 class CXferSocket : public CAsyncSocket	{

 public:

 	UINT m__timeOut;

 	UINT m__blkSize;

 	tftp::tftpOptions m_Options;

 	LONG m_xferSize;

 	UINT m_timeOut;

 	UINT m_blkSize;

 	BOOL m_bRetry;

 	void SetTry(tftp *p=NULL);

 	tftp* m_Retry;

 	void OnRetry();

 	BOOL CheckBadRelativeness(LPCTSTR file);

 	CString ApplyRootGently(LPCTSTR fn);

 	CString m_HostName;

 	virtual void OnResolved();

 	virtual void OnFailedToResolve();

 	CResolver *m_wndResolver;

 	BYTE m_ResolveBuff[MAXGETHOSTSTRUCT];

 	virtual void Abort();

 	void ResetTimeout();

 	enum	{

 		stateNone, stateDeny, stateInit, stateOACK, stateXfer, stateFinish, stateClosing

 	};

 	int state;

 	void Deny(UINT errCode,UINT errID);

 	void Deny(CFileException* e);

 	CString ApplyRoot(LPCTSTR fileName);

 	void TurnSlashes(CString& fn,BOOL bBack=TRUE);

 	virtual void Destroy(BOOL success=TRUE);

 	void PostError(CFileException* e);

 	void PostError(UINT errCode,UINT errID);

 	void PostTFTP(tftp* p,BOOL retryable=FALSE);

 	CXferSocket(CPumpKINDlg *daddy,LPCTSTR fileName,LPCTSTR type,SOCKADDR_IN* sin);

 	CFile m_File;

 	virtual ULONG GetACK();

 	CString m_Type;

 	CString m_FileName;

 	CXferSocket();

 	void UpdateList();

 	void SetPeer(SOCKADDR_IN *sin);

 	virtual BOOL OnTFTP(tftp* p) = 0;

 	virtual void OnReceive(int nErrorCode);

-	void DoSelect();

+	void DoSelect(BOOL do_select=FALSE);

 	SOCKADDR_IN m_Peer;

 	virtual void OnSend(int nErrorCode);

 	CPumpKINDlg* m_Daddy;

 	CTFTPList m_Queue;

 

 	DECLARE_DYNAMIC(CXferSocket)

 };

 class CWRQSocket : public CXferSocket {

 public:

 	BOOL m_bResume;

 	void OnHostKnown();

 	virtual void OnResolved();

 	UINT m_LastSlack;

 	ULONG GetACK();

 	void DoXfer();

 	UINT m_ACK;

 	BOOL SaveAs(CString& fn);

 	BOOL RenameFile(CString& fn);

 	BOOL m_Rename;

 	BOOL ConfirmRequest();

 	BOOL Create(LPCTSTR localFile=NULL,LPCTSTR hostName=NULL);

 	CWRQSocket(CPumpKINDlg* daddy,LPCTSTR fileName,LPCTSTR type,SOCKADDR_IN *sin);

 	BOOL OnTFTP(tftp* p);

 

 	DECLARE_DYNAMIC(CWRQSocket)

 };

 class CRRQSocket : public CXferSocket {

 public:

+	UINT m_ACKtoClose;

 	void OnHostKnown();

 	virtual void OnResolved();

 	BOOL ConfirmRequest();

 	WORD m_LastSlack;

 	UINT m_ACK;

 	BOOL OnTFTP(tftp* p);

 	ULONG GetACK(void);

 	void DoXfer();

 	CRRQSocket(CPumpKINDlg *daddy,LPCTSTR fileName,LPCTSTR type,SOCKADDR_IN *sin);

 	BOOL Create(LPCTSTR localFile=NULL,LPCTSTR hostName=NULL);

 

 	DECLARE_DYNAMIC(CRRQSocket)

 };

 

 typedef	CMap<SOCKET,SOCKET,CXferSocket*,CXferSocket*>	CTIDMap;

 typedef CMap<CTime*,CTime*,CTime*,CTime*> CTimeMap;

 

 /////////////////////////////////////////////////////////////////////////////

 // CPumpKINDlg dialog

 

 class CTrayer;

 class CRetrier;

 class CPumpKINDlg : public CDialog

 {

 // Construction

 public:

 	void AdjustButton(CWnd& w,CRect& wrc);

 	void RecalcLayout(int,int);

 	CSize m_MinSize;

 	UINT m_bottomGapLog;

 	UINT m_bottomGapListen;

 	UINT m_rightGapList;

 	UINT m_rightGapButtons;

 	CString m_lastlogerr;

 	void LogLine(LPCTSTR str);

 	CString m_LogFile;

 	BOOL m_bListen;

 	acl_rules_t m_aclRules;

 	CString m_bnwRequest;

 	CString m_bnwSuccess;

 	CString m_bnwAbort;

 	CBellsNWhistles m_bnw;

 	CTrayer *m_Trayer;

 	CTimeSpan m_RetryTimeOut;

 	virtual ~CPumpKINDlg();

 	CRetrier* m_Retrier;

 	virtual BOOL PreTranslateMessage(MSG* pMsg);

 	BOOL m_bShown;

 	BOOL m_bExiting;

 	void SaveSettings();

 	void LoadSettings();

 	void SetupButtons();

 	BITMAP m_bitmapBack;

 	CBitmap m_bmpBack;

 	UINT m_PromptTimeOut;

 	UINT m_SpeakPort;

 	void LogLine(UINT msgID);

 	CTimeMap m_LogTimes;

 	void LogLineToFile(LPCTSTR str);

 	void LogLineToScreen(LPCTSTR str);

 	int m_LogLength;

 	enum	{

 		subitemFile=0, subitemType, subitemPeer, subitemBytes, subitemTSize

 	};

 	int m_iWRQ;

 	int m_iRRQ;

 	CImageList m_Images;

 	CTIDMap m_Xfers;

 	CTimeSpan m_TFTPTimeOut;

 	enum	{

 		rrqGiveAll=acl_rule::rrqGrant,

 		rrqAlwaysConfirm=acl_rule::rrqPrompt,

 		rrqDenyAll=acl_rule::rrqDeny,

 		rrqFallback=acl_rule::rrqNone,

 		rrqGrant=rrqGiveAll, rrqDeny=rrqDenyAll, rrqPrompt=rrqAlwaysConfirm

 	};

 	enum	{

 		wrqTakeAll=acl_rule::wrqGrant,

 		wrqConfirmIfExists=acl_rule::wrqPromptIfExists,

 		wrqAlwaysConfirm=acl_rule::wrqPrompt,

 		wrqDenyAll=acl_rule::wrqDeny,

 		wrqFallback=acl_rule::wrqNone,

 		wrqGrant=wrqTakeAll,wrqDeny=wrqDenyAll, wrqPrompt=wrqAlwaysConfirm

 	};

 	UINT m_RRQMode;

 	UINT m_WRQMode;

 	BOOL m_bTFTPSubdirs;

 	CString m_TFTPRoot;

 	UINT m_ListenPort;

 	UINT m_BlockSize;

 	CListenSocket m_Listener;

 	CPumpKINDlg(CWnd* pParent = NULL);	// standard constructor

 

 // Dialog Data

 	//{{AFX_DATA(CPumpKINDlg)

 	enum { IDD = IDD_PUMPKIN_DIALOG };

 	CButton	m_HelpCtl;

 	CButton	m_PutCtl;

 	CButton	m_GetCtl;

 	CButton	m_ExitCtl;

 	CButton	m_ListenCtl;

 	CButton	m_AbortCtl;

 	CButton	m_OptionsCtl;

 	CListBox	m_Log;

 	CListCtrl	m_List;

 	//}}AFX_DATA

 

 	// ClassWizard generated virtual function overrides

 	//{{AFX_VIRTUAL(CPumpKINDlg)

 	protected:

 	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support

 	//}}AFX_VIRTUAL

 

 // Implementation

 protected:

 	CToolTipCtrl m_tooltip;

 	HICON m_hIcon;

 

 	// Generated message map functions

 	//{{AFX_MSG(CPumpKINDlg)

 	virtual BOOL OnInitDialog();

 	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);

 	afx_msg void OnDestroy();

 	afx_msg void OnPaint();

 	afx_msg HCURSOR OnQueryDragIcon();

 	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);

 	afx_msg void OnOptions();

 	afx_msg void OnTimer(UINT nIDEvent);

 	afx_msg void OnExit();

 	afx_msg void OnPut();

 	afx_msg void OnGet();

 	afx_msg void OnDeleteallitemsConnections(NMHDR* pNMHDR, LRESULT* pResult);

 	afx_msg void OnDeleteitemConnections(NMHDR* pNMHDR, LRESULT* pResult);

 	afx_msg void OnInsertitemConnections(NMHDR* pNMHDR, LRESULT* pResult);

 	afx_msg void OnItemchangedConnections(NMHDR* pNMHDR, LRESULT* pResult);

 	afx_msg void OnAbort();

 	afx_msg void OnClose();

 	afx_msg void OnTrayShowpumpkinwindow();

 	afx_msg void OnTrayListen();

 	afx_msg void OnTrayExit();

 	afx_msg void OnTrayAboutpumpkin();

 	afx_msg void OnTrayFetchfile();

 	afx_msg void OnTrayHelp();

 	afx_msg void OnTrayOptions();

 	afx_msg void OnTraySendfile();

 	afx_msg void OnWindowPosChanging(WINDOWPOS FAR* lpwndpos);

 	afx_msg void OnSelchangeLog();

 	afx_msg void OnTrayOpenfilesfolder();

 	afx_msg void OnDropFiles(HDROP hDropInfo);

 	virtual void OnCancel();

 	afx_msg void OnHelp();

 	afx_msg void OnListening();

 	afx_msg void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);

 	afx_msg void OnSize(UINT nType, int cx, int cy);

 	//}}AFX_MSG

 	DECLARE_MESSAGE_MAP()

 };

diff --git a/pumpkin.mak b/pumpkin.mak
index a22a6fa..bf9e895 100644
--- a/pumpkin.mak
+++ b/pumpkin.mak
@@ -433,1253 +433,1151 @@ CLEAN :
 CPP_PROJ=/nologo /MLd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS"\

  /D "_MBCS" /Fp"$(INTDIR)/Install.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 

 CPP_OBJS=.\Install\Debug/

 CPP_SBRS=.\.

 # ADD BASE MTL /nologo /D "_DEBUG" /win32

 # ADD MTL /nologo /D "_DEBUG" /win32

 MTL_PROJ=/nologo /D "_DEBUG" /win32 

 # ADD BASE RSC /l 0x409 /d "_DEBUG" /d "_AFXDLL"

 # ADD RSC /l 0x409 /d "_DEBUG"

 RSC_PROJ=/l 0x409 /fo"$(INTDIR)/Install.res" /d "_DEBUG" 

 BSC32=bscmake.exe

 # ADD BASE BSC32 /nologo

 # ADD BSC32 /nologo

 BSC32_FLAGS=/nologo /o"$(OUTDIR)/Install.bsc" 

 BSC32_SBRS= \

 	

 LINK32=link.exe

 # ADD BASE LINK32 /nologo /subsystem:windows /debug /machine:I386

 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib version.lib /nologo /subsystem:windows /debug /machine:I386

 LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\

  advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\

  odbccp32.lib version.lib /nologo /subsystem:windows /incremental:yes\

  /pdb:"$(OUTDIR)/Install.pdb" /debug /machine:I386 /out:"$(OUTDIR)/Install.exe" 

 LINK32_OBJS= \

 	"$(INTDIR)\install.obj" \

 	"$(INTDIR)\Install.res"

 

 "$(OUTDIR)\Install.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)

     $(LINK32) @<<

   $(LINK32_FLAGS) $(LINK32_OBJS)

 <<

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Pure"

 

 # PROP BASE Use_MFC 2

 # PROP BASE Use_Debug_Libraries 0

 # PROP BASE Output_Dir "Install\Pure"

 # PROP BASE Intermediate_Dir "Install\Pure"

 # PROP BASE Target_Dir "Install"

 # PROP Use_MFC 0

 # PROP Use_Debug_Libraries 0

 # PROP Output_Dir "Install\Pure"

 # PROP Intermediate_Dir "Install\Pure"

 # PROP Target_Dir "Install"

 OUTDIR=.\Install\Pure

 INTDIR=.\Install\Pure

 

 ALL : "$(OUTDIR)\Install.exe" "$(OUTDIR)\Install.bsc"

 

 CLEAN : 

 	-@erase "$(INTDIR)\install.obj"

 	-@erase "$(INTDIR)\Install.res"

 	-@erase "$(INTDIR)\install.sbr"

 	-@erase "$(OUTDIR)\Install.bsc"

 	-@erase "$(OUTDIR)\Install.exe"

 

 "$(OUTDIR)" :

     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"

 

 # ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /YX /c

 # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /FR /YX /c

 CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D\

  "_MBCS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/Install.pch" /YX /Fo"$(INTDIR)/" /c 

 CPP_OBJS=.\Install\Pure/

 CPP_SBRS=.\Install\Pure/

 # ADD BASE MTL /nologo /D "NDEBUG" /win32

 # ADD MTL /nologo /D "NDEBUG" /win32

 MTL_PROJ=/nologo /D "NDEBUG" /win32 

 # ADD BASE RSC /l 0x409 /d "NDEBUG" /d "_AFXDLL"

 # ADD RSC /l 0x409 /d "NDEBUG"

 RSC_PROJ=/l 0x409 /fo"$(INTDIR)/Install.res" /d "NDEBUG" 

 BSC32=bscmake.exe

 # ADD BASE BSC32 /nologo

 # ADD BSC32 /nologo

 BSC32_FLAGS=/nologo /o"$(OUTDIR)/Install.bsc" 

 BSC32_SBRS= \

 	"$(INTDIR)\install.sbr"

 

 "$(OUTDIR)\Install.bsc" : "$(OUTDIR)" $(BSC32_SBRS)

     $(BSC32) @<<

   $(BSC32_FLAGS) $(BSC32_SBRS)

 <<

 

 LINK32=link.exe

 # ADD BASE LINK32 /nologo /subsystem:windows /machine:I386

 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib version.lib /nologo /subsystem:windows /machine:I386

 LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\

  advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\

  odbccp32.lib version.lib /nologo /subsystem:windows /incremental:no\

  /pdb:"$(OUTDIR)/Install.pdb" /machine:I386 /out:"$(OUTDIR)/Install.exe" 

 LINK32_OBJS= \

 	"$(INTDIR)\install.obj" \

 	"$(INTDIR)\Install.res"

 

 "$(OUTDIR)\Install.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)

     $(LINK32) @<<

   $(LINK32_FLAGS) $(LINK32_OBJS)

 <<

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Static"

 

 # PROP BASE Use_MFC 2

 # PROP BASE Use_Debug_Libraries 0

 # PROP BASE Output_Dir "Install\Static"

 # PROP BASE Intermediate_Dir "Install\Static"

 # PROP BASE Target_Dir "Install"

 # PROP Use_MFC 0

 # PROP Use_Debug_Libraries 0

 # PROP Output_Dir "Install\Static"

 # PROP Intermediate_Dir "Install\Static"

 # PROP Target_Dir "Install"

 OUTDIR=.\Install\Static

 INTDIR=.\Install\Static

 

 ALL : "$(OUTDIR)\Install.exe"

 

 CLEAN : 

 	-@erase "$(INTDIR)\install.obj"

 	-@erase "$(INTDIR)\Install.res"

 	-@erase "$(OUTDIR)\Install.exe"

 

 "$(OUTDIR)" :

     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"

 

 # ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /YX /c

 # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "STATI_K" /YX /c

 CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D\

  "_MBCS" /D "STATI_K" /Fp"$(INTDIR)/Install.pch" /YX /Fo"$(INTDIR)/" /c 

 CPP_OBJS=.\Install\Static/

 CPP_SBRS=.\.

 # ADD BASE MTL /nologo /D "NDEBUG" /win32

 # ADD MTL /nologo /D "NDEBUG" /win32

 MTL_PROJ=/nologo /D "NDEBUG" /win32 

 # ADD BASE RSC /l 0x409 /d "NDEBUG" /d "_AFXDLL"

 # ADD RSC /l 0x409 /d "NDEBUG" /d "STATI_K"

 RSC_PROJ=/l 0x409 /fo"$(INTDIR)/Install.res" /d "NDEBUG" /d "STATI_K" 

 BSC32=bscmake.exe

 # ADD BASE BSC32 /nologo

 # ADD BSC32 /nologo

 BSC32_FLAGS=/nologo /o"$(OUTDIR)/Install.bsc" 

 BSC32_SBRS= \

 	

 LINK32=link.exe

 # ADD BASE LINK32 /nologo /subsystem:windows /machine:I386

 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib version.lib /nologo /subsystem:windows /machine:I386

 LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\

  advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\

  odbccp32.lib version.lib /nologo /subsystem:windows /incremental:no\

  /pdb:"$(OUTDIR)/Install.pdb" /machine:I386 /out:"$(OUTDIR)/Install.exe" 

 LINK32_OBJS= \

 	"$(INTDIR)\install.obj" \

 	"$(INTDIR)\Install.res"

 

 "$(OUTDIR)\Install.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)

     $(LINK32) @<<

   $(LINK32_FLAGS) $(LINK32_OBJS)

 <<

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Canned"

 

 # PROP BASE Use_MFC 2

 # PROP BASE Use_Debug_Libraries 0

 # PROP BASE Output_Dir "Install\Canned"

 # PROP BASE Intermediate_Dir "Install\Canned"

 # PROP BASE Target_Dir "Install"

 # PROP Use_MFC 0

 # PROP Use_Debug_Libraries 0

 # PROP Output_Dir "Install\Canned"

 # PROP Intermediate_Dir "Install\Canned"

 # PROP Target_Dir "Install"

 OUTDIR=.\Install\Canned

 INTDIR=.\Install\Canned

 

 ALL : "$(OUTDIR)\Install.exe"

 

 CLEAN : 

 	-@erase "$(INTDIR)\install.obj"

 	-@erase "$(INTDIR)\Install.res"

 	-@erase "$(OUTDIR)\Install.exe"

 

 "$(OUTDIR)" :

     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"

 

 # ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /YX /c

 # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "K_ANNED" /YX /c

 CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D\

  "_MBCS" /D "K_ANNED" /Fp"$(INTDIR)/Install.pch" /YX /Fo"$(INTDIR)/" /c 

 CPP_OBJS=.\Install\Canned/

 CPP_SBRS=.\.

 # ADD BASE MTL /nologo /D "NDEBUG" /win32

 # ADD MTL /nologo /D "NDEBUG" /win32

 MTL_PROJ=/nologo /D "NDEBUG" /win32 

 # ADD BASE RSC /l 0x409 /d "NDEBUG" /d "_AFXDLL"

 # ADD RSC /l 0x409 /d "NDEBUG" /d "K_ANNED"

 RSC_PROJ=/l 0x409 /fo"$(INTDIR)/Install.res" /d "NDEBUG" /d "K_ANNED" 

 BSC32=bscmake.exe

 # ADD BASE BSC32 /nologo

 # ADD BSC32 /nologo

 BSC32_FLAGS=/nologo /o"$(OUTDIR)/Install.bsc" 

 BSC32_SBRS= \

 	

 LINK32=link.exe

 # ADD BASE LINK32 /nologo /subsystem:windows /machine:I386

 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib version.lib /nologo /subsystem:windows /machine:I386

 LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\

  advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\

  odbccp32.lib version.lib /nologo /subsystem:windows /incremental:no\

  /pdb:"$(OUTDIR)/Install.pdb" /machine:I386 /out:"$(OUTDIR)/Install.exe" 

 LINK32_OBJS= \

 	"$(INTDIR)\install.obj" \

 	"$(INTDIR)\Install.res"

 

 "$(OUTDIR)\Install.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)

     $(LINK32) @<<

   $(LINK32_FLAGS) $(LINK32_OBJS)

 <<

 

 !ENDIF 

 

 .c{$(CPP_OBJS)}.obj:

    $(CPP) $(CPP_PROJ) $<  

 

 .cpp{$(CPP_OBJS)}.obj:

    $(CPP) $(CPP_PROJ) $<  

 

 .cxx{$(CPP_OBJS)}.obj:

    $(CPP) $(CPP_PROJ) $<  

 

 .c{$(CPP_SBRS)}.sbr:

    $(CPP) $(CPP_PROJ) $<  

 

 .cpp{$(CPP_SBRS)}.sbr:

    $(CPP) $(CPP_PROJ) $<  

 

 .cxx{$(CPP_SBRS)}.sbr:

    $(CPP) $(CPP_PROJ) $<  

 

 ################################################################################

 # Begin Target

 

 # Name "PumpKIN - Win32 Release"

 # Name "PumpKIN - Win32 Debug"

 # Name "PumpKIN - Win32 Static"

 

 !IF  "$(CFG)" == "PumpKIN - Win32 Release"

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

 !ENDIF 

 

 ################################################################################

 # Begin Source File

 

 SOURCE=.\PumpKIN.cpp

-

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

 DEP_CPP_PUMPK=\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

+

 "$(INTDIR)\PumpKIN.obj" : $(SOURCE) $(DEP_CPP_PUMPK) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

-DEP_CPP_PUMPK=\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\PumpKIN.obj" : $(SOURCE) $(DEP_CPP_PUMPK) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\PumpKIN.sbr" : $(SOURCE) $(DEP_CPP_PUMPK) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

-DEP_CPP_PUMPK=\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\PumpKIN.obj" : $(SOURCE) $(DEP_CPP_PUMPK) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\PumpKINDlg.cpp

+

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

 DEP_CPP_PUMPKI=\

 	".\ACLTargetCombo.h"\

 	".\ConfirmRRQDlg.h"\

 	".\ConfirmWRQDlg.h"\

 	".\PropsACL.h"\

 	".\PropsNetwork.h"\

 	".\PropsServer.h"\

 	".\PropsSounds.h"\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\RequestDlg.h"\

 	".\Resolver.h"\

 	".\Retrier.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	".\Trayer.h"\

 	

 

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

-

 "$(INTDIR)\PumpKINDlg.obj" : $(SOURCE) $(DEP_CPP_PUMPKI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

+DEP_CPP_PUMPKI=\

+	".\ACLTargetCombo.h"\

+	".\ConfirmRRQDlg.h"\

+	".\ConfirmWRQDlg.h"\

+	".\PropsACL.h"\

+	".\PropsNetwork.h"\

+	".\PropsServer.h"\

+	".\PropsSounds.h"\

+	".\pumpkin.h"\

+	".\PumpKINDlg.h"\

+	".\RequestDlg.h"\

+	".\Resolver.h"\

+	".\Retrier.h"\

+	".\shared-code\kHelpers.h"\

+	".\stdafx.h"\

+	".\Trayer.h"\

+	

+NODEP_CPP_PUMPKI=\

+	".\DoSelect"\

+	

 

 "$(INTDIR)\PumpKINDlg.obj" : $(SOURCE) $(DEP_CPP_PUMPKI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\PumpKINDlg.sbr" : $(SOURCE) $(DEP_CPP_PUMPKI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

+DEP_CPP_PUMPKI=\

+	".\ACLTargetCombo.h"\

+	".\ConfirmRRQDlg.h"\

+	".\ConfirmWRQDlg.h"\

+	".\PropsACL.h"\

+	".\PropsNetwork.h"\

+	".\PropsServer.h"\

+	".\PropsSounds.h"\

+	".\pumpkin.h"\

+	".\PumpKINDlg.h"\

+	".\RequestDlg.h"\

+	".\Resolver.h"\

+	".\Retrier.h"\

+	".\shared-code\BellsNWhistles.h"\

+	".\shared-code\kHelpers.h"\

+	".\stdafx.h"\

+	".\Trayer.h"\

+	

 

 "$(INTDIR)\PumpKINDlg.obj" : $(SOURCE) $(DEP_CPP_PUMPKI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\StdAfx.cpp

 DEP_CPP_STDAF=\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

 !IF  "$(CFG)" == "PumpKIN - Win32 Release"

 

 # ADD CPP /Yc"stdafx.h"

 

 BuildCmds= \

 	$(CPP) /nologo /Zp1 /MD /W3 /GX /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D\

  "_AFXDLL" /D "_MBCS" /Fp"$(INTDIR)/pumpkin.pch" /Yc"stdafx.h" /Fo"$(INTDIR)/"\

  /c $(SOURCE) \

 	

 

 "$(INTDIR)\StdAfx.obj" : $(SOURCE) $(DEP_CPP_STDAF) "$(INTDIR)"

    $(BuildCmds)

 

 "$(INTDIR)\pumpkin.pch" : $(SOURCE) $(DEP_CPP_STDAF) "$(INTDIR)"

    $(BuildCmds)

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

 # ADD CPP /Yc"stdafx.h"

 

 BuildCmds= \

 	$(CPP) /nologo /Zp1 /MDd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D\

  "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/pumpkin.pch"\

  /Yc"stdafx.h" /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c $(SOURCE) \

 	

 

 "$(INTDIR)\StdAfx.obj" : $(SOURCE) $(DEP_CPP_STDAF) "$(INTDIR)"

    $(BuildCmds)

 

 "$(INTDIR)\StdAfx.sbr" : $(SOURCE) $(DEP_CPP_STDAF) "$(INTDIR)"

    $(BuildCmds)

 

 "$(INTDIR)\pumpkin.pch" : $(SOURCE) $(DEP_CPP_STDAF) "$(INTDIR)"

    $(BuildCmds)

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

 # ADD BASE CPP /Yc"stdafx.h"

 # ADD CPP /Yc"stdafx.h"

 

 BuildCmds= \

 	$(CPP) /nologo /Zp1 /MT /W3 /GX /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D\

  "_MBCS" /Fp"$(INTDIR)/pumpkin.pch" /Yc"stdafx.h" /Fo"$(INTDIR)/" /c $(SOURCE) \

 	

 

 "$(INTDIR)\StdAfx.obj" : $(SOURCE) $(DEP_CPP_STDAF) "$(INTDIR)"

    $(BuildCmds)

 

 "$(INTDIR)\pumpkin.pch" : $(SOURCE) $(DEP_CPP_STDAF) "$(INTDIR)"

    $(BuildCmds)

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\pumpkin.rc

 DEP_RSC_PUMPKIN=\

 	".\res\down.ico"\

 	".\res\failed.wav"\

 	".\res\finished.wav"\

 	".\res\PumpKIN.ico"\

 	".\res\pumpkin.rc2"\

 	".\res\remove.ico"\

 	".\res\ring.wav"\

 	".\res\rrq.ico"\

 	".\res\up.ico"\

 	".\res\wrq.ico"\

 	".\shared-data\browse-icon.ico"\

 	".\shared-data\klever-background.bmp"\

 	".\shared-data\play-icon.ico"\

 	

 

 !IF  "$(CFG)" == "PumpKIN - Win32 Release"

 

 

 "$(INTDIR)\pumpkin.res" : $(SOURCE) $(DEP_RSC_PUMPKIN) "$(INTDIR)"

    $(RSC) $(RSC_PROJ) $(SOURCE)

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

 

 "$(INTDIR)\pumpkin.res" : $(SOURCE) $(DEP_RSC_PUMPKIN) "$(INTDIR)"

    $(RSC) $(RSC_PROJ) $(SOURCE)

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

 

 "$(INTDIR)\pumpkin.res" : $(SOURCE) $(DEP_RSC_PUMPKIN) "$(INTDIR)"

    $(RSC) $(RSC_PROJ) $(SOURCE)

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\help\pumpkin.hpj

 

 !IF  "$(CFG)" == "PumpKIN - Win32 Release"

 

 # Begin Custom Build - Making help files...

 OutDir=.\Release

 ProjDir=.

 TargetName=pumpkin

 InputPath=.\help\pumpkin.hpj

 

 BuildCmds= \

 	"$(ProjDir)\makehelp.bat" \

 	compress $(OutDir)\$(TargetName).hlp $(OutDir)\$(TargetName).hl_ \

 	compress $(OutDir)\$(TargetName).cnt $(OutDir)\$(TargetName).cn_ \

 	

 

 "$(OutDir)\$(TargetName).hlp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 

 "$(OutDir)\$(TargetName).cnt" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 

 "$(OutDir)\$(TargetName).hl_" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 

 "$(OutDir)\$(TargetName).cn_" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 # End Custom Build

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

 # Begin Custom Build - Making help files...

 OutDir=.\Debug

 ProjDir=.

 TargetName=pumpkin

 InputPath=.\help\pumpkin.hpj

 

 BuildCmds= \

 	"$(ProjDir)\makehelp.bat" \

 	compress $(OutDir)\$(TargetName).hlp $(OutDir)\$(TargetName).hl_ \

 	compress $(OutDir)\$(TargetName).cnt $(OutDir)\$(TargetName).cn_ \

 	

 

 "$(OutDir)\$(TargetName).hlp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 

 "$(OutDir)\$(TargetName).cnt" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 

 "$(OutDir)\$(TargetName).hl_" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 

 "$(OutDir)\$(TargetName).cn_" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 # End Custom Build

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

 # Begin Custom Build - Making help files...

 OutDir=.\Releast

 ProjDir=.

 TargetName=pumpkin

 InputPath=.\help\pumpkin.hpj

 

 BuildCmds= \

 	"$(ProjDir)\makehelp.bat" \

 	compress $(OutDir)\$(TargetName).hlp $(OutDir)\$(TargetName).hl_ \

 	compress $(OutDir)\$(TargetName).cnt $(OutDir)\$(TargetName).cn_ \

 	

 

 "$(OutDir)\$(TargetName).hlp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 

 "$(OutDir)\$(TargetName).cnt" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 

 "$(OutDir)\$(TargetName).hl_" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 

 "$(OutDir)\$(TargetName).cn_" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

 # End Custom Build

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\PropsServer.cpp

-

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

 DEP_CPP_PROPS=\

 	".\PropsServer.h"\

 	".\pumpkin.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

+

 "$(INTDIR)\PropsServer.obj" : $(SOURCE) $(DEP_CPP_PROPS) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

-DEP_CPP_PROPS=\

-	".\PropsServer.h"\

-	".\pumpkin.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\PropsServer.obj" : $(SOURCE) $(DEP_CPP_PROPS) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\PropsServer.sbr" : $(SOURCE) $(DEP_CPP_PROPS) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

-DEP_CPP_PROPS=\

-	".\PropsServer.h"\

-	".\pumpkin.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\PropsServer.obj" : $(SOURCE) $(DEP_CPP_PROPS) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\PropsNetwork.cpp

 DEP_CPP_PROPSN=\

 	".\PropsNetwork.h"\

 	".\pumpkin.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

 !IF  "$(CFG)" == "PumpKIN - Win32 Release"

 

 

 "$(INTDIR)\PropsNetwork.obj" : $(SOURCE) $(DEP_CPP_PROPSN) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

 

 "$(INTDIR)\PropsNetwork.obj" : $(SOURCE) $(DEP_CPP_PROPSN) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\PropsNetwork.sbr" : $(SOURCE) $(DEP_CPP_PROPSN) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

 

 "$(INTDIR)\PropsNetwork.obj" : $(SOURCE) $(DEP_CPP_PROPSN) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\ConfirmRRQDlg.cpp

-

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

 DEP_CPP_CONFI=\

 	".\ConfirmRRQDlg.h"\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

+

 "$(INTDIR)\ConfirmRRQDlg.obj" : $(SOURCE) $(DEP_CPP_CONFI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

-DEP_CPP_CONFI=\

-	".\ConfirmRRQDlg.h"\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\ConfirmRRQDlg.obj" : $(SOURCE) $(DEP_CPP_CONFI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\ConfirmRRQDlg.sbr" : $(SOURCE) $(DEP_CPP_CONFI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

-DEP_CPP_CONFI=\

-	".\ConfirmRRQDlg.h"\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\ConfirmRRQDlg.obj" : $(SOURCE) $(DEP_CPP_CONFI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\ConfirmWRQDlg.cpp

-

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

 DEP_CPP_CONFIR=\

 	".\ConfirmWRQDlg.h"\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

+

 "$(INTDIR)\ConfirmWRQDlg.obj" : $(SOURCE) $(DEP_CPP_CONFIR) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

-DEP_CPP_CONFIR=\

-	".\ConfirmWRQDlg.h"\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\ConfirmWRQDlg.obj" : $(SOURCE) $(DEP_CPP_CONFIR) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\ConfirmWRQDlg.sbr" : $(SOURCE) $(DEP_CPP_CONFIR) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

-DEP_CPP_CONFIR=\

-	".\ConfirmWRQDlg.h"\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\ConfirmWRQDlg.obj" : $(SOURCE) $(DEP_CPP_CONFIR) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\RequestDlg.cpp

 DEP_CPP_REQUE=\

 	".\pumpkin.h"\

 	".\RequestDlg.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

 !IF  "$(CFG)" == "PumpKIN - Win32 Release"

 

 

 "$(INTDIR)\RequestDlg.obj" : $(SOURCE) $(DEP_CPP_REQUE) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

 

 "$(INTDIR)\RequestDlg.obj" : $(SOURCE) $(DEP_CPP_REQUE) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\RequestDlg.sbr" : $(SOURCE) $(DEP_CPP_REQUE) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

 

 "$(INTDIR)\RequestDlg.obj" : $(SOURCE) $(DEP_CPP_REQUE) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\Resolver.cpp

-

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

 DEP_CPP_RESOL=\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\Resolver.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

+

 "$(INTDIR)\Resolver.obj" : $(SOURCE) $(DEP_CPP_RESOL) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

-DEP_CPP_RESOL=\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\Resolver.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\Resolver.obj" : $(SOURCE) $(DEP_CPP_RESOL) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\Resolver.sbr" : $(SOURCE) $(DEP_CPP_RESOL) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

-DEP_CPP_RESOL=\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\Resolver.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\Resolver.obj" : $(SOURCE) $(DEP_CPP_RESOL) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\Retrier.cpp

-

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

 DEP_CPP_RETRI=\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\Retrier.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

+

 "$(INTDIR)\Retrier.obj" : $(SOURCE) $(DEP_CPP_RETRI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

-DEP_CPP_RETRI=\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\Retrier.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\Retrier.obj" : $(SOURCE) $(DEP_CPP_RETRI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\Retrier.sbr" : $(SOURCE) $(DEP_CPP_RETRI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

-DEP_CPP_RETRI=\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\Retrier.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\Retrier.obj" : $(SOURCE) $(DEP_CPP_RETRI) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\Trayer.cpp

-

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

 DEP_CPP_TRAYE=\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	".\Trayer.h"\

 	

 

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

+

 "$(INTDIR)\Trayer.obj" : $(SOURCE) $(DEP_CPP_TRAYE) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

-DEP_CPP_TRAYE=\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	".\Trayer.h"\

-	

 

 "$(INTDIR)\Trayer.obj" : $(SOURCE) $(DEP_CPP_TRAYE) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\Trayer.sbr" : $(SOURCE) $(DEP_CPP_TRAYE) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

-DEP_CPP_TRAYE=\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	".\Trayer.h"\

-	

 

 "$(INTDIR)\Trayer.obj" : $(SOURCE) $(DEP_CPP_TRAYE) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\help\pumpkin.cnt

 

 !IF  "$(CFG)" == "PumpKIN - Win32 Release"

 

 # PROP Exclude_From_Build 1

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

 # PROP Exclude_From_Build 1

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

 # PROP Exclude_From_Build 1

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\PropsSounds.cpp

-

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

 DEP_CPP_PROPSS=\

 	".\PropsSounds.h"\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

+

 "$(INTDIR)\PropsSounds.obj" : $(SOURCE) $(DEP_CPP_PROPSS) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

-DEP_CPP_PROPSS=\

-	".\PropsSounds.h"\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\PropsSounds.obj" : $(SOURCE) $(DEP_CPP_PROPSS) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\PropsSounds.sbr" : $(SOURCE) $(DEP_CPP_PROPSS) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

-DEP_CPP_PROPSS=\

-	".\PropsSounds.h"\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\PropsSounds.obj" : $(SOURCE) $(DEP_CPP_PROPSS) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\PropsACL.cpp

 DEP_CPP_PROPSA=\

 	".\ACLTargetCombo.h"\

 	".\PropsACL.h"\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

 !IF  "$(CFG)" == "PumpKIN - Win32 Release"

 

 

 "$(INTDIR)\PropsACL.obj" : $(SOURCE) $(DEP_CPP_PROPSA) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

 

 "$(INTDIR)\PropsACL.obj" : $(SOURCE) $(DEP_CPP_PROPSA) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\PropsACL.sbr" : $(SOURCE) $(DEP_CPP_PROPSA) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

 

 "$(INTDIR)\PropsACL.obj" : $(SOURCE) $(DEP_CPP_PROPSA) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\ACLTargetCombo.cpp

-

-!IF  "$(CFG)" == "PumpKIN - Win32 Release"

-

 DEP_CPP_ACLTA=\

 	".\ACLTargetCombo.h"\

 	".\pumpkin.h"\

 	".\PumpKINDlg.h"\

 	".\shared-code\BellsNWhistles.h"\

 	".\shared-code\kHelpers.h"\

 	".\stdafx.h"\

 	

 

+!IF  "$(CFG)" == "PumpKIN - Win32 Release"

+

+

 "$(INTDIR)\ACLTargetCombo.obj" : $(SOURCE) $(DEP_CPP_ACLTA) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Debug"

 

-DEP_CPP_ACLTA=\

-	".\ACLTargetCombo.h"\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\ACLTargetCombo.obj" : $(SOURCE) $(DEP_CPP_ACLTA) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 "$(INTDIR)\ACLTargetCombo.sbr" : $(SOURCE) $(DEP_CPP_ACLTA) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ELSEIF  "$(CFG)" == "PumpKIN - Win32 Static"

 

-DEP_CPP_ACLTA=\

-	".\ACLTargetCombo.h"\

-	".\pumpkin.h"\

-	".\PumpKINDlg.h"\

-	".\shared-code\BellsNWhistles.h"\

-	".\shared-code\kHelpers.h"\

-	".\stdafx.h"\

-	

 

 "$(INTDIR)\ACLTargetCombo.obj" : $(SOURCE) $(DEP_CPP_ACLTA) "$(INTDIR)"\

  "$(INTDIR)\pumpkin.pch"

 

 

 !ENDIF 

 

 # End Source File

 # End Target

 ################################################################################

 # Begin Target

 

 # Name "Install - Win32 Debug"

 # Name "Install - Win32 Pure"

 # Name "Install - Win32 Static"

 # Name "Install - Win32 Canned"

 

 !IF  "$(CFG)" == "Install - Win32 Debug"

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Pure"

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Static"

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Canned"

 

 !ENDIF 

 

 ################################################################################

 # Begin Source File

 

 SOURCE=.\Install\Install.rc

 DEP_RSC_INSTA=\

 	".\Install\Custom.rch"\

 	".\shared-data\install-icon.ico"\

 	

 

 !IF  "$(CFG)" == "Install - Win32 Debug"

 

 

 "$(INTDIR)\Install.res" : $(SOURCE) $(DEP_RSC_INSTA) "$(INTDIR)"

    $(RSC) /l 0x409 /fo"$(INTDIR)/Install.res" /i "Install" /d "_DEBUG"\

  $(SOURCE)

 

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Pure"

 

 

 "$(INTDIR)\Install.res" : $(SOURCE) $(DEP_RSC_INSTA) "$(INTDIR)"

    $(RSC) /l 0x409 /fo"$(INTDIR)/Install.res" /i "Install" /d "NDEBUG"\

  $(SOURCE)

 

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Static"

 

 

 "$(INTDIR)\Install.res" : $(SOURCE) $(DEP_RSC_INSTA) "$(INTDIR)"

    $(RSC) /l 0x409 /fo"$(INTDIR)/Install.res" /i "Install" /d "NDEBUG" /d\

  "STATI_K" $(SOURCE)

 

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Canned"

 

 

 "$(INTDIR)\Install.res" : $(SOURCE) $(DEP_RSC_INSTA) "$(INTDIR)"

    $(RSC) /l 0x409 /fo"$(INTDIR)/Install.res" /i "Install" /d "NDEBUG" /d\

  "K_ANNED" $(SOURCE)

 

 

 !ENDIF 

 

 # End Source File

 ################################################################################

 # Begin Source File

 

 SOURCE=.\Install\install.cpp

 DEP_CPP_INSTAL=\

 	".\shared-code\install.h"\

 	

 

 !IF  "$(CFG)" == "Install - Win32 Debug"

 

 

 "$(INTDIR)\install.obj" : $(SOURCE) $(DEP_CPP_INSTAL) "$(INTDIR)"

    $(CPP) $(CPP_PROJ) $(SOURCE)

 

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Pure"

 

 

 BuildCmds= \

 	$(CPP) $(CPP_PROJ) $(SOURCE) \

 	

 

 "$(INTDIR)\install.obj" : $(SOURCE) $(DEP_CPP_INSTAL) "$(INTDIR)"

    $(BuildCmds)

 

 "$(INTDIR)\install.sbr" : $(SOURCE) $(DEP_CPP_INSTAL) "$(INTDIR)"

    $(BuildCmds)

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Static"

 

 

 "$(INTDIR)\install.obj" : $(SOURCE) $(DEP_CPP_INSTAL) "$(INTDIR)"

    $(CPP) $(CPP_PROJ) $(SOURCE)

 

 

 !ELSEIF  "$(CFG)" == "Install - Win32 Canned"

 

 

 "$(INTDIR)\install.obj" : $(SOURCE) $(DEP_CPP_INSTAL) "$(INTDIR)"

    $(CPP) $(CPP_PROJ) $(SOURCE)

 

 

 !ENDIF 

 

 # End Source File

 # End Target

 # End Project

 ################################################################################

 ################################################################################

 # Section PumpKIN : {4FD78B34-1FD7-11D0-A9FB-444553540000}

 # 	2:11:CPumpKINDlg:1

 # 	2:11:CRequestDlg:1

 # End Section

 ################################################################################