ftp_wzm.cpp

带DirectFB界面的FTP客户端

#include "wzm.h"

char fileinfo[MAXNUM];

static void AlrmHandler(int signum)
{
	ofstream ofs;
	signal( SIGALRM, AlrmHandler );
	ofs.open( DEBUGFILE, ios::out|ios::app );
	if( ofs )
	{
		ofs<<" Time Out!"<<endl;
		ofs.flush();
		ofs.close();
	}
	else
		ERR(" Time Out!");
}

wsocket::wsocket()
{		
	socket_id = socket( PF_INET,SOCK_STREAM,0 );	
	if( socket_id < 0 )
		perror( "wsocket::wsocket()" );
}

wsocket::~wsocket()
{
	if( socket_id > 0 )
		close( socket_id );	
}

int wsocket::sockConnect()
{	
	int err = 0;
	
	if( socket_id > 0 )
	{
		err = connect( socket_id, &sa.sa, sizeof(sa.sa) );
		if( err < 0 )
			perror( "wsocket::sockConnect()" );
	}
	else
	{
		ERR( "wsocket::sockConnect socket init fail! " );
		return socket_id;
	}
	
	return err;
}

int wsocket::setAddr( const string &ip, const int port )
{
	memset( &sa, 0, sizeof(sa) );
	sa.sin.sin_family = AF_INET;
	sa.sin.sin_port = htons( port );
	sa.sin.sin_addr.s_addr = inet_addr( ip.c_str() );
	
	return 0;	
}

int wsocket::setAddr( const unsigned int *v )
{
	memset( &sa, 0, sizeof(sa) );
	sa.sa.sa_family = AF_INET;
	sa.sa.sa_data[2] = v[2];
	sa.sa.sa_data[3] = v[3];
	sa.sa.sa_data[4] = v[4];
	sa.sa.sa_data[5] = v[5];
	sa.sa.sa_data[0] = v[0];
	sa.sa.sa_data[1] = v[1];	
	
	return 0;
}

int wsocket::sockServer( unsigned int *v )
{
	int err = 0;
		
	sa.sin.sin_port = 0;
	
	if( socket_id > 0 )
	{
		err = bind( socket_id, &sa.sa, sizeof(sa.sa) );
		if( err < 0 )
			perror( "wsocket::sockServer bind()" );
		else
		{
			err = listen( socket_id, 1 );
			if( err < 0 )
				perror( "wsocket::sockServer listen()" );
			else
			{
				if( sockName( v ) )	
					ERR("wsocket::sockServer sockName fail!");
			}
		}
	}
	else
	{
		ERR( "wsocket::sockServer socket init fail! " );
		return socket_id;
	}
	
	return err;		
}

int wsocket::sockAccept( )
{
	int id = -1;
	
	if( socket_id > 0 )
	{
		socklen_t l= sizeof(sa.sa);
		
		alarm(TIMEOUT);
		id = accept( socket_id, &sa.sa, &l );
		alarm(0);
		if( id < 0 )
			perror( "wsocket::sockAccept()" );
			
		if( sockClose() < 0 )
		{
			ERR( "wsocket::sockAccept() close socket fail!" );
			return -1;
		}
		
		if( id < 0 )
			return id;
			
		socket_id = id;		
	}
	else
	{
		ERR( "wsocket::sockConnect socket init fail! " );
		return socket_id;
	}
	
	return 0;		
}

int wsocket::sockName( unsigned int *v ) 
{
	socklen_t l = sizeof(sa.sa);
	
	if ( getsockname( socket_id , &sa.sa, &l ) < 0 )
	{
		perror("wsocket::sockName()");
	    return 1;	
	}
	
	v[2] = (unsigned int) sa.sa.sa_data[2];
	v[3] = (unsigned int) sa.sa.sa_data[3];
	v[4] = (unsigned int) sa.sa.sa_data[4];
	v[5] = (unsigned int) sa.sa.sa_data[5];
	v[0] = (unsigned int) sa.sa.sa_data[0];
	v[1] = (unsigned int) sa.sa.sa_data[1];
	
	return 0;
}

int wsocket::sockRecv( char *buf )
{
	fd_set rfds;
	struct timeval tv;
	int ret = 0;
	
	FD_ZERO( &rfds );
	FD_SET( socket_id, &rfds );
	
	tv.tv_sec = TIMEOUT;
    tv.tv_usec = 0;
	select( socket_id+1, &rfds, NULL, NULL, &tv );

	if( FD_ISSET( socket_id, &rfds ) )
		ret = read( socket_id, buf, MAXNUM );	
	
	if( ret < 0 )
		perror( "wsocket::sockRecv()" );
		
	return ret;
}

int wsocket::sockSend( const char *buf, const int &len )
{
	fd_set wfds;
	struct timeval tv;
	int ret = -1;
	
	FD_ZERO( &wfds );
	FD_SET( socket_id, &wfds );
	
	tv.tv_sec = TIMEOUT;
    tv.tv_usec = 0;
	select( socket_id+1, NULL, &wfds, NULL, &tv );

	if( FD_ISSET( socket_id, &wfds ) )
			ret = write( socket_id, buf, len );	
	
	if( ret < 0 )
		perror( "wsocket::sockSend()" );
			
	return ret;
}

int wsocket::sockClose()
{
	int err = 0;
	
	if( socket_id > 0 )
	{
		err = close( socket_id );	
		if( err < 0 )
			perror( "wsocket::sockClose()" );
	}
	
	return err;
}

FtpPI::FtpPI()
{
	int i = 0;
	
	do
	{
		ofs.open( DEBUGFILE, ios::out|ios::app );
	}while( !ofs && ++i < 10 );
	
	if( i>= 10 )
		ERR("open file [%s] fail!", DEBUGFILE );	
	
}

FtpPI::~FtpPI()
{
	if( ofs )
		ofs.close();
}

void FtpPI::putstring( const char *buf )
{
	if( ofs )
	{
		ofs << buf;	
		ofs.flush();
	}
	else
		ERR( "%s", buf );
}

int  FtpPI::GetAddr( unsigned int *v )
{
	if( sockName( v ) )	
		putstring("FtpPI::GetAddr get addr fail!\n");
		
	return 0;
}

int FtpPI::ConServ( const string &ip )
{
	int err = 1;
	
	if( !setAddr( ip, 21 ) )
	{
		err = sockConnect();
		if( err < 0 )
			putstring("FtpPI::ConServ connect fail!\n");
	}
	else
	{
		putstring("FtpPI::ConServ set addr fail!\n");
		return err;
	}
	
	return err;
}

int FtpPI::SendCmd( const string &cmd, const string &result )
{
	string buffer;
	
	buffer = cmd + "\r\n";
	putstring( buffer.c_str() );
	
	if( sockSend( buffer.c_str(), buffer.length() ) <= 0 )
	{
		putstring(" FtpPI::SendCmd send fail!\n");
		return 1;
	}
	
	return RecvCmd( result );	
}

int FtpPI::RecvCmd( const string &result )
{
	char *buf;
	int strlong = 0;
	bool match = false;
	string tmp;
	
	if( NULL == (buf = (char *)calloc( MAXNUM,1 )))
	{
		putstring( "FtpPI::RecvCmd calloc fail!" );
		return 1;
	}
	
	try
	{
		if( result.empty() )
			return 2;
		while( strlong <= (MAXNUM) )
		{
			int ret=0;
			
			ret = sockRecv( buf+strlong );
			if( ret <= 0 )
				break;
			laststring = buf + strlong;
			putstring( laststring.c_str() );
			if( *(buf+strlong+3) != '-' )
			{					
				if( match == false )	
					break;
				else
				{
					if( laststring.find( tmp,0 ) != string::npos )		
						break;	
				}
			}
			else
			{
				match = true;
				tmp = laststring.substr( 0, 3 );
			}
			strlong += ret;			
		}
		if( laststring.find( result.substr( 0, 3 ),0 ) == string::npos ) 
		{
			putstring("FtpPI::RecvCmd recv and result differ!\n");
			free( buf );
			return 2;
		}
		
	}
	catch( ... )
	{
		putstring("FtpPI::RecvCmd catch except!\n");	
		free( buf );
		return 3;
	}
	
	free( buf );
	return 0;
}

int FtpPI::ClsServ()
{
	int err = 0;
	
	err = sockClose();	
	if( err < 0 )
		putstring("FtpPI::ClsServ fail!\n");
		
	return err;
}

int FtpDTP::ConnData( const string &iport, const char *filename )
{
	unsigned int v[6];
	int err = 0;
	
	if( filename == NULL || strlen(filename) <= 0 )
		file = TEMPFILE;
	else
		file = filename;
	
	try
	{
		sscanf(iport.c_str(),"(%u,%u,%u,%u,%u,%u)",&v[2],&v[3],&v[4],&v[5],&v[0],&v[1]);
	}
	catch( ... )
	{
		ERR( "FtpDTP::ConnData string [%s] fail!", iport.c_str());	
		return 1;
	}
	
	if( !setAddr( v ) )
		err = sockConnect();	
	
	if( err < 0 )
		ERR( "FtpDTP::ConnData conncet [%s] fail!", iport.c_str() );
	
	return err;
}

int FtpDTP::DataServer( unsigned int *v, const char *filename )
{
	if( filename == NULL || strlen(filename) <= 0 )
		file = TEMPFILE;
	else
		file = filename;
	
	if( setAddr( v ) )	
	{
		ERR("FtpDTP::DataServer set addr fail!");
		return 1;
	}
	
	if( sockServer( v ) )
	{
		ERR("FtpDTP::DataServer server fail!");
		return 2;	
	}
	
	return 0;
}

int FtpDTP::DataAccept(  )
{
	if( sockAccept() < 0 )
		return 1;
	return 0;	
}

int FtpDTP::SendData(  const char &type )
{
	char buf[MAXNUM];
	ifstream fs;
	
	if( type == 'a' )
		fs.open( file.c_str() );
	else
		fs.open( file.c_str(), ios::binary );
	
	if( fs )
	{
		while( fs.good() )
		{
			if( type == 'a' )
			{
				fs.getline( buf, sizeof(buf) );		
				sprintf( buf, "%s%s", buf, "\r\n" );		
				if( sockSend( buf, strlen(buf) ) < 0 )
				{
					ERR( "FtpDTP::SendData send data [%s] fail!", buf );
					return 1;
				}	
			}
			else
			{
				fs.read( buf, MAXNUM );				
				if( sockSend( buf, MAXNUM ) < 0 )
				{
					ERR( "FtpDTP::SendData send data [%s] fail!", buf );
					return 1;
				}
			}
		}
		fs.close();
	}
	else
	{
		ERR( "FtpDTP::SendData open file [%s] fail!", file.c_str() );	
		return 2;
	}	
	
	return 0;
}

int FtpDTP::RecvData( const char &type )
{
	char *buf;
	int ret;
	ofstream fs;
	
	if( type == 'a' )
		fs.open( file.c_str() );
	else
		fs.open( file.c_str(), ios::binary );
	
	if( fs )
	{
		if( !(buf = (char *)malloc( MAXNUM+1 )))
		{
			ERR("FtpDTP::RecvData malloc fail!");
			return 1;
		}
		memset( buf, 0, MAXNUM+1 );
		while( (ret = sockRecv( buf )) > 0 )
		{
			if( type == 'a' )
				fs << buf;
			else
				fs.write( buf, ret );
			memset( buf, 0, MAXNUM+1 );
		}	
		
		free( buf );
		fs.flush();
		fs.close();
		if( ret < 0 )
		{
			ERR("FtpDTP::RecvData recv data fail!");
			return 2;
		}
	}
	else