view_old.cpp

简单的ftp客户端下载程序

		m_sktListen = INVALID_SOCKET;
	}	
	if( m_sktData != INVALID_SOCKET )
	{
		closesocket(m_sktData);
		m_sktData = INVALID_SOCKET;
	}
	//CString sOut.Format( "\r\nMiniFTP Status>Connection closed by client\r\n\r\n");
	Log("\r\nMiniFTP Status>Connection closed by client\r\n\r\n");
}

/////////////////////////////////////////////////////////////////////////////
void CMiniFTPView::OnClearview() 
{
	// clear the user input edit box
	GetEditCtrl().SetWindowText("");
}

/////////////////////////////////////////////////////////////////////////////
void CMiniFTPView::OnUpdateCloseconn(CCmdUI* pCmdUI) 
{
	if( m_sktControl != INVALID_SOCKET )
	{
		pCmdUI->Enable(1 ); 
	}
	else
	{
		pCmdUI->Enable(0);
	}
}

////////////////////////////////////////////////////////////////////////////
void CMiniFTPView::OnUpdateConnect(CCmdUI* pCmdUI) 
{
	if( m_sktControl == INVALID_SOCKET )
	{
		pCmdUI->Enable(1 ); 
	}
	else
	{
		pCmdUI->Enable(0);
	}
}

/////////////////////////////////////////////////////////////////////////////
/*LONG CMiniFTPView::OnWinsockEvent (WPARAM wParam, LPARAM lParam)
{
	ASSERT( m_pWinsockControl != NULL);

	char szBuffer[NUM1024+2], *str;
	CString sOut;
	SOCKET sTemp;
	int nLen;
	BOOL bCancel = FALSE;
	int nRet;

	switch ( WSAGETSELECTEVENT(lParam) ) 	  // which message arrived?
	{
		case FD_CLOSE:
			sOut.Format( "\r\nMiniFTP Status>Connection closed by client (socket %d)\r\n\r\n", wParam);
			Log(sOut);
			// kill the winsock object
			if( m_pWinsockControl != NULL &&
				m_pWinsockControl->GetSocket() == wParam )
			{
				// its a window so destroy it first
				m_pWinsockControl->DestroyWindow();
				delete m_pWinsockControl;
				m_pWinsockControl = NULL;
			}
			else if( m_pWinsockData != NULL &&
						m_pWinsockData->GetSocket() == wParam )
			{
				// its a window so destroy it first
				m_pWinsockData->DestroyWindow();
				delete m_pWinsockData;
				m_pWinsockData = NULL;
				// if I am closing the Data socket, do the listner now, too
				 if( m_pWinsockListen != NULL  )
				{
					// its a window so destroy it first
					m_pWinsockListen->DestroyWindow();
					delete m_pWinsockListen;
					m_pWinsockListen = NULL;
				 }
			}
			else if( m_pWinsockListen != NULL &&
						m_pWinsockListen->GetSocket() == wParam )
			{
				// its a window so destroy it first
				m_pWinsockListen->DestroyWindow();
				delete m_pWinsockListen;
				m_pWinsockListen = NULL;
			}
			break;

		case FD_READ:

			if( m_bWaitingForTimeout )
			{
				KillTimer(ID_MYTIMEOUT);
				m_bWaitingForTimeout = FALSE;
			}

			memset(szBuffer,0,NUM1024+2);
			// this memset trick avoids having strtok insert a wild \0 somewhere bad
			//		it is guaranteed to find a \n (the delimiter in this case) before
			//		running off into other memory
			memset(szBuffer+NUM1024, '\n', 1); 

			// process the control socket
			if( m_pWinsockControl->GetSocket() == wParam )
			{
				m_pWinsockControl->Recv(szBuffer,NUM1024,0);
				// make a copy for the state machine
				strcpy( m_szReplyBuffer, szBuffer);
				// set flag
				m_bReplyReceived = TRUE;
				// send to screen
				DisplaySktRead( szBuffer );
				// is it a 5xx reply?
				if( *m_szReplyBuffer == '5' )
				{
					MakeSafeState();
				}
			}

			// process the listen socket
			if( m_pWinsockListen != NULL &&
					m_pWinsockListen->GetSocket() == wParam )
			{
				m_pWinsockListen->Recv(szBuffer,NUM1024,0);
				DisplaySktRead( szBuffer );
			}

			// process the data socket
			if( m_bSavingFile && m_pWinsockData != NULL &&
					m_pWinsockData->GetSocket() == wParam )
			{
				// deal with the data socket for saving to disk
				ASSERT( m_pSaveFilePointer==NULL );
				m_pSaveFilePointer = fopen( (const char *)m_sExportFileName, "r" );
				if( m_pSaveFilePointer )
				{
					fclose( m_pSaveFilePointer );
					sOut.Format( "File %s\nalready exists.\n\nOverwrite?", m_sExportFileName);
					if( AfxMessageBox( sOut, MB_YESNO ) != IDYES )
					{
						bCancel = TRUE;
					}
				}
				if( bCancel )
				{
					BeginWaitCursor(); // show hourglass 
					// just burn it off
					do
					{
						nRet = m_pWinsockData->Recv(szBuffer,NUM1024,0);
					} while( nRet != SOCKET_ERROR ); 
					m_bFileHasBeenSaved = TRUE; // kinda misnomer - more like "operation complete"
					m_pSaveFilePointer = NULL;
					EndWaitCursor(); // kill hourglass 
				}
				else if( !bCancel && !m_nRadioASCII )
				{
					// a binary store to disk
					BeginWaitCursor(); // show hourglass 
					m_pSaveFilePointer = fopen( (const char *)m_sExportFileName, "wb" );
					ASSERT( m_pSaveFilePointer );
					do
					{
						nRet = m_pWinsockData->Recv(szBuffer,NUM1024,0);
						if( nRet != SOCKET_ERROR && nRet > 0 )
						{
							fwrite( (char *)szBuffer, sizeof( char ), nRet, m_pSaveFilePointer );
						}
					} while( nRet != SOCKET_ERROR && nRet > 0 ); 
					fclose(m_pSaveFilePointer);
					m_bFileHasBeenSaved = TRUE;
					m_pSaveFilePointer = NULL;
					EndWaitCursor(); // kill hourglass 
				}
				else if( !bCancel && m_nRadioASCII )
				{
					// an ASCII store to disk
					BeginWaitCursor(); // show hourglass 
					m_pSaveFilePointer = fopen( (const char *)m_sExportFileName, "w" );
					ASSERT( m_pSaveFilePointer );
					do
					{
						memset(szBuffer,0,NUM1024+2);
						// this memset trick avoids having strtok insert a wild \0 somewhere bad
						//		it is guaranteed to find a \n (the delimiter in this case) before
						//		running off into other memory
						memset(szBuffer+NUM1024, '\n', 1); 

						nRet = m_pWinsockData->Recv(szBuffer,NUM1024,0);
						if( nRet != SOCKET_ERROR && nRet > 0 )
						{
							str=strtok(szBuffer,"\n");
							while( str && *str)
							{
								char temp[NUM1024+1];
								strcpy( temp, str);
								nLen = strlen(str);
								if( nLen > 0 )
								{
									if( *( str + nLen - 1 ) == 0x0d) // remove the 0x0d aka \r
									{
										*( str + nLen - 1 ) = 0;
										fprintf( m_pSaveFilePointer, "%s\n", str );
									}
									else
									{
										fprintf( m_pSaveFilePointer, "%s", str );
									}
								}

				
								str=strtok((char *)NULL,"\n");
							}
						}
					} while( nRet != SOCKET_ERROR && nRet > 0 ); 
					fclose(m_pSaveFilePointer);
					m_pSaveFilePointer = NULL;
					m_bFileHasBeenSaved = TRUE;
					EndWaitCursor(); // kill hourglass 
				} // end of else if on !bCancel && m_nRadioASCII 
			} // end of if on data socket if saving file

			// just a plain data socket (no file saving)  - get the data to the screen
			if( (!m_bSavingFile) && (m_pWinsockData != NULL) &&
				(m_pWinsockData->GetSocket() == wParam) )  //just send to the log window
			{
				m_pWinsockData->Recv(szBuffer,NUM1024,0);
				DisplaySktRead(szBuffer);
			}

			// all dones saving?
			if( m_bSavingFile && m_bFileHasBeenSaved )
			{
				m_bSavingFile = FALSE;
				m_bFileHasBeenSaved = FALSE;
			}
			break;  

		case FD_OOB:
			AfxMessageBox("OOB");
			break;  

		case FD_ACCEPT:
			ASSERT(m_pWinsockListen != NULL);
			sTemp = m_pWinsockListen->Accept(NULL,NULL);
			//sTemp = m_pWinsockListen->GetWSocket();
			ASSERT(sTemp != INVALID_SOCKET);
			m_pWinsockData->SetSocket(sTemp);
			m_pWinsockData->SetSockOpt(SOL_SOCKET,SO_LINGER,0,0);	
			m_pWinsockData->SetSockOpt(SOL_SOCKET,SO_REUSEADDR,0,0);
			m_pWinsockData->SetSockOpt(SOL_SOCKET,SO_KEEPALIVE,0,0);
			m_pWinsockData->SetSockOpt(SOL_SOCKET,SO_OOBINLINE,0,0);
			//m_pWinsockListen->CloseSocket();
			// its a window so destroy it first
			//m_pWinsockListen->DestroyWindow();
			//delete m_pWinsockListen;
			//m_pWinsockListen = NULL; 

			sOut.Format("\r\nMiniFTP Status>Data Connection made OK (socket %d)\r\n\r\n", sTemp);
			Log(sOut);
			break;

		case FD_WRITE:
			memset(szBuffer,0,NUM1024+2);
			m_pWinsockControl->Recv(szBuffer,NUM1024,0);
			str=strtok(szBuffer,"\n");
			while( str && *str)
			{
			   Log((const char *)str);
			   Log("\r\n");
			   str=strtok((char *)NULL,"\n");
			}
			break;

		default:
			AfxMessageBox("Default");
			break;
	} // end of switch
	return 0L;
} */




////////////////////////////////////////////////////////////////////////////
// the major sequencer for client/server stuff
/*void CMiniFTPView::StateMachine(void) 
{
	CString sOut;

	switch ( m_nState ) 	  // which state are we in now ?
	{
		case 0:
			// do we need to logon?
			if( !m_bInTransit && m_bStartLogon)
			{
				m_bStartCommand = FALSE;
				m_bReplyReceived = FALSE;
				m_bStartLogon = FALSE;
				m_bCommandToSend = FALSE;

				// send	name
				sOut = "USER ";
				sOut += m_sName;
				m_pWinsockControl->Send((const char *)sOut, sOut.GetLength(), 0);
				Log(sOut);
				sOut = "\r\n";
				m_pWinsockControl->Send((const char *)sOut, sOut.GetLength(), 0);
				Log(sOut);
				m_bInTransit = TRUE;
			}
			else
			{
				// all done with logon?
				if( m_bInTransit && m_bReplyReceived )
				{
					m_nState = 1;
					m_bInTransit = FALSE;
					m_bReplyReceived = FALSE;
				}
			}
			break;

		case 1:
			// do we need to send password?
			if( !m_bInTransit )
			{
				// send	password
				sOut = "PASS ";
				sOut += m_sPassword;
				m_pWinsockControl->Send((const char *)sOut, sOut.GetLength(), 0);
				sOut = "PASS xxx";
				Log(sOut);
				sOut = "\r\n";
				m_pWinsockControl->Send((const char *)sOut, sOut.GetLength(), 0);
				Log(sOut);	 
				m_bInTransit = TRUE;
			}
			else
			{
				// all done with password?
				if( m_bInTransit && m_bReplyReceived )
				{
					m_nState = 2;
					m_bInTransit = FALSE;
					m_bReplyReceived = FALSE;
				}
			}
			break;

		case 2:
			// do we need to send the PORT coammand and get a listening socket?
			if( !m_bInTransit)
			{ 
				m_bSavingFile = FALSE; // if it ever was true, is isnt now!
				m_bInTransit = TRUE;
				SOCKET sTemp;
				ASSERT( m_pWinsockListen != NULL);

				sTemp = m_pWinsockListen->ConnectToListen( "0", "0");
				m_pWinsockListen->AsyncSelect(FD_WRITE|FD_READ|FD_CLOSE|FD_OOB|FD_ACCEPT);

   				CString sOut;
				sOut.Format("\r\nMiniFTP Status>Listen Connection made OK (socket %d)\r\n\r\n", 
								m_pWinsockListen->GetSocket() );
				Log(sOut);

				m_pWinsockListen->Listen(3);

				// inform remote end about our port that we created.
				// get the port name that we got for later transmission in PORT cmd
				struct sockaddr_in saCtrlAddr;
				int iLength=sizeof(saCtrlAddr);
				getsockname(m_pWinsockListen->GetSocket(),(struct sockaddr *)&saCtrlAddr,&iLength);

				struct sockaddr_in saTmpAddr;
				iLength = sizeof (saTmpAddr);
				if (getsockname(m_pWinsockControl->GetSocket(),(LPSOCKADDR)&saTmpAddr, &iLength)
								==SOCKET_ERROR)
				{
					AfxMessageBox("getsockname problem");
				}

				char *a,*p;
				a = (char *)&saTmpAddr.sin_addr;
				p = (char *)&saCtrlAddr.sin_port;
				#define  UC(b)  (((int)b)&0xff)
				CString sPort= "PORT ";
				sPort.Format( "PORT %d,%d,%d,%d,%d,%d",
						UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
						UC(p[0]), UC(p[1]) );
					
				m_pWinsockControl->Send((const char *)sPort, sPort.GetLength(), 0);
				Log(sPort);
				sPort = "\r\n";
				m_pWinsockControl->Send((const char *)sPort, sPort.GetLength(), 0);
				Log(sPort);	

				//m_pWinsockListen->Accept(NULL,NULL);

				m_nState = 3;
				m_bInTransit= FALSE;
				m_bReplyReceived = FALSE;
			}
			break;

		case 3:
			// Do I have a command to send?
			if( !m_bInTransit && m_bCommandToSend )
			{
				ASSERT( !m_bWaitingForTimeout );
				SetTimer(ID_MYTIMEOUT, 10000, NULL);
				m_bWaitingForTimeout = TRUE;
				ASSERT( strlen( m_szCommandToServer ) > 0 );
				sOut = m_szCommandToServer;
				sOut = sOut.Left(4);
				sOut.MakeUpper();
				if( sOut == "RETR" )
				{
					m_bSavingFile = TRUE;
					m_bFileHasBeenSaved = FALSE;
				}
				m_bInTransit = TRUE;
				m_pWinsockControl->Send(m_szCommandToServer, 
													strlen(m_szCommandToServer), 0);
				sOut = m_szCommandToServer;
				Log(sOut);
				m_bCommandToSend = FALSE;
			}
			else if(  m_bInTransit && !m_bCommandToSend )
			{
				// all done sending the command?
				m_bInTransit = FALSE;
				//KillTimer(ID_MYTIMER);
			}
			break;

		case 4:
			break;
		default:
			break;
	}
}*/

/////////////////////////////////////////////////////////////////////////////
/*void CMiniFTPView::KillSockObj(void)
{
	ASSERT(m_pWinsockControl != NULL );
	// its a window so destroy it first
	m_pWinsockControl->DestroyWindow();
	delete m_pWinsockControl;
	m_pWinsockControl = NULL;

	if(m_pWinsockListen != NULL )
	{
		// its a window so destroy it first
		m_pWinsockListen->DestroyWindow();
		delete m_pWinsockListen;
		m_pWinsockListen = NULL;
	}

	if(m_pWinsockData != NULL )
	{
		// its a window so destroy it first
		m_pWinsockData->DestroyWindow();
		delete m_pWinsockData;
		m_pWinsockData = NULL;
	}

	m_nState = 0;
	MakeSafeState();
}*/

/////////////////////////////////////////////////////////////////////////////
/*void CMiniFTPView::MakeSockObj(void)
{
	// make the winsock object
	if(m_pWinsockControl == NULL )
	{
		m_pWinsockControl = new CWinsock(this);
		ASSERT( m_pWinsockControl != NULL);
	}

	// make the winsock object
	if(m_pWinsockListen == NULL )
	{
		m_pWinsockListen = new CWinsock(this);
		ASSERT( m_pWinsockListen != NULL);
	}

	// make the winsock object
	if(m_pWinsockData == NULL )
	{
		m_pWinsockData = new CWinsock(this);
		ASSERT( m_pWinsockData != NULL);
	}
}*/