C++实现ftp客户端

#ifndef CLIENT_H_
#define CLIENT_H_

#include <sys/socket.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <sys/stat.h>
#include <netdb.h>
#include <errno.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <string>
#include <list>

#define INVALID_SOCKET				-1
#define FTP_API						int
#define MAX_PATH					260
#define trace						printf

#define FTP_PARAM_BASE
#define FTP_DEFAULT_PORT			"21"							//FTP默认端口号
#define FTP_DEFAULT_BUFFER			1024*4							//FTP下载缓冲默认大小
#define FTP_DEFAULT_PATH			"/mnt/dvs/"						//FTP默认保存路径

#define FTP_COMMAND_BASE			1000
#define FTP_COMMAND_END				FTP_COMMAND_BASE + 30
#define FTP_COMMAND_USERNAME		FTP_COMMAND_BASE + 1			//用户名
#define FTP_COMMAND_PASSWORD		FTP_COMMAND_BASE + 2			//密码
#define FTP_COMMAND_QUIT			FTP_COMMAND_BASE + 3			//退出
#define FTP_COMMAND_CURRENT_PATH	FTP_COMMAND_BASE + 4			// 获取文件路径
#define FTP_COMMAND_TYPE_MODE		FTP_COMMAND_BASE + 5			// 改变传输模式
#define FTP_COMMAND_PSAV_MODE		FTP_COMMAND_BASE + 6			// 被动端口模式
#define FTP_COMMAND_DIR				FTP_COMMAND_BASE + 7			// 获取文件列表
#define FTP_COMMAND_CHANGE_DIRECTORY FTP_COMMAND_BASE + 8			// 改变路径
#define FTP_COMMAND_DELETE_FILE		FTP_COMMAND_BASE + 9			// 删除文件
#define FTP_COMMAND_DELETE_DIRECTORY FTP_COMMAND_BASE + 10			// 删除目录/文件夹
#define FTP_COMMAND_CREATE_DIRECTORY FTP_COMMAND_BASE + 11			// 创建目录/文件夹
#define FTP_COMMAND_RENAME_BEGIN    FTP_COMMAND_BASE  +12			// 开始重命名
#define FTP_COMMAND_RENAME_END      FTP_COMMAND_BASE + 13			// 重命名结束
#define FTP_COMMAND_FILE_SIZE		FTP_COMMAND_BASE + 14			// 获取文件大小
#define FTP_COMMAND_DOWNLOAD_POS	FTP_COMMAND_BASE + 15			// 下载文件从指定位置开始
#define FTP_COMMAND_DOWNLOAD_FILE	FTP_COMMAND_BASE + 16			// 下载文件
#define FTP_COMMAND_UPLOAD_FILE		FTP_COMMAND_BASE + 17			// 上传文件
#define FTP_COMMAND_APPEND_FILE		FTP_COMMAND_BASE + 18			// 追加上载文件

/*		  登陆步骤
login2Server
|
inputUserName
|
inputPassWord
|
具体操作
|
quit
*/

class CFTPManager
{
public :

enum type {
binary = 0x31,
ascii,
};

CFTPManager(void);

virtual ~CFTPManager(void);

// ! 登陆服务器
FTP_API login2Server(const std::string &serverIP);

// !输入用户名
FTP_API inputUserName(const std::string &userName);

// !输入密码
FTP_API inputPassWord(const std::string &password);

// !退出FTP
FTP_API quitServer(void);

// !命令： PWD
const std::string PWD();

// !设置传输格式 2进制  还是ascii方式传输
FTP_API setTransferMode(type mode);

// !设置为被动模式
const std::string Pasv();

// ! 命令： DIR
const std::string Dir(const std::string &path);

// !命令 ： CD
FTP_API CD(const std::string &path);

// ！删除文件
FTP_API DeleteFile(const std::string &strRemoteFile);

// ! 删除文件夹/目录
FTP_API DeleteDirectory(const std::string &strRemoteDir);

// ! 创建目录/文件夹
FTP_API CreateDirectory(const std::string &strRemoteDir);

// !重命名
FTP_API Rename(const std::string &strRemoteFile, const std::string &strNewFile);

// !获取文件大小
long getFileLength(const std::string &strRemoteFile);

// !关闭连接
void Close(int sock);

// 下载文件
FTP_API Get(const std::string &strRemoteFile, const std::string &strLocalFile);

// 上载文件  支持断电传送方式
FTP_API Put(const std::string &strRemoteFile, const std::string &strLocalFile);

private:
// !合成发送到服务器的命令
const std::string parseCommand(const unsigned int command, const std::string &strParam);

// ! 建立连接
FTP_API Connect(int socketfd, const std::string &serverIP, unsigned int nPort);

// ! 返回服务器信息
const std::string serverResponse(int sockfd);

// !获取服务器数据
FTP_API getData(int fd, char *strBuf, unsigned long length);

// !发送命令
FTP_API Send(int fd, const std::string &cmd);

// !发送命令
FTP_API Send(int fd, const char *cmd, const size_t len);

// !建立数据连接
FTP_API createDataLink(int data_fd);

// !解析PASV模式返回的字符串获取FTP端口号和FTP服务器IP
FTP_API ParseString(std::list<std::string> strArray, unsigned long & nPort ,std::string & strServerIp);

// 打开本地文件
FILE *createLocalFile(const std::string &strLocalFile);

// 下载文件
FTP_API downLoad(const std::string &strRemoteFile, const std::string &strLocalFile, const int pos = 0, const unsigned int length = 0);

// 解析返回ftp命令的值
FTP_API parseResponse(const std::string &str);

private:
//！控制连接套接字
int		m_cmdSocket;

// !当前用户名
std::string m_strUserName;

// !当前用户密码
std::string m_strPassWord;

// !服务器的IP
std::string m_strServerIP;

// !服务器Port
unsigned int m_nServerPort;

// !服务器回应信息缓存
std::string m_strResponse;

// !保存命令参数
std::string m_commandStr;

// ！当前使用的命令参数
unsigned int m_nCurrentCommand;

// !是否登陆标志。
bool	m_bLogin;
};

#endif

#include "../Source/FTPManager.h"

static int SplitString( std::string strSrc, std::list<std::string> &strArray , std::string strFlag)
{
int pos = 1;

while((pos = (int)strSrc.find_first_of(strFlag.c_str())) > 0)
{
strArray.insert(strArray.end(), strSrc.substr(0 , pos));
strSrc = strSrc.substr(pos + 1, strSrc.length() - pos - 1);
}

strArray.insert(strArray.end(), strSrc.substr(0, strSrc.length()));

return 0;
}

CFTPManager::CFTPManager(void): m_bLogin(false)
{
m_cmdSocket = socket(AF_INET, SOCK_STREAM, 0);

}

CFTPManager::~CFTPManager(void)
{
std::string strCmdLine = parseCommand(FTP_COMMAND_QUIT, "");

Send(m_cmdSocket, strCmdLine.c_str());
close(m_cmdSocket);
m_bLogin = false;
}

FTP_API CFTPManager::login2Server(const std::string &serverIP)
{
std::string strPort;
int pos = serverIP.find_first_of(":");

if (pos > 0)
{
strPort = serverIP.substr(pos + 1, serverIP.length() - pos);
}
else
{
pos = serverIP.length();
strPort = FTP_DEFAULT_PORT;
}

m_strServerIP = serverIP.substr(0, pos);
m_nServerPort = atol(strPort.c_str());

trace("IP: %s port: %d\n", m_strServerIP.c_str(), m_nServerPort);

if (Connect(m_cmdSocket, m_strServerIP, m_nServerPort) < 0)
{

return -1;
}

m_strResponse = serverResponse(m_cmdSocket);
printf("@@@@Response: %s", m_strResponse.c_str());

return	parseResponse(m_strResponse);
}

FTP_API CFTPManager::inputUserName(const std::string &userName)
{
std::string strCommandLine = parseCommand(FTP_COMMAND_USERNAME, userName);

m_strUserName = userName;

if (Send(m_cmdSocket, strCommandLine) < 0)
{
return -1;
}

m_strResponse = serverResponse(m_cmdSocket);
printf("Response: %s\n", m_strResponse.c_str());

return parseResponse(m_strResponse);
}

FTP_API CFTPManager::inputPassWord(const std::string &password)
{
std::string strCmdLine = parseCommand(FTP_COMMAND_PASSWORD, password);

m_strPassWord = password;
if (Send(m_cmdSocket, strCmdLine) < 0)
{
return -1;
}
else
{
m_bLogin = true;

m_strResponse = serverResponse(m_cmdSocket);
printf("Response: %s\n", m_strResponse.c_str());

return parseResponse(m_strResponse);
}
}

FTP_API CFTPManager::quitServer(void)
{
std::string strCmdLine = parseCommand(FTP_COMMAND_QUIT, "");
if (Send(m_cmdSocket, strCmdLine) < 0)
{
return -1;
}
else
{
m_strResponse = serverResponse(m_cmdSocket);
printf("Response: %s\n", m_strResponse.c_str());

return parseResponse(m_strResponse);
}

}

const std::string CFTPManager::PWD()
{
std::string strCmdLine = parseCommand(FTP_COMMAND_CURRENT_PATH, "");

if (Send(m_cmdSocket, strCmdLine.c_str()) < 0)
{
return "";
}
else
{
return serverResponse(m_cmdSocket);
}
}

FTP_API CFTPManager::setTransferMode(type mode)
{
std::string strCmdLine;

switch (mode)
{
case binary:
strCmdLine = parseCommand(FTP_COMMAND_TYPE_MODE, "I");
break;
case ascii:
strCmdLine = parseCommand(FTP_COMMAND_TYPE_MODE, "A");
break;
default:
break;
}

if (Send(m_cmdSocket, strCmdLine.c_str()) < 0)
{
assert(false);
}
else
{
m_strResponse  = serverResponse(m_cmdSocket);
printf("@@@@Response: %s", m_strResponse.c_str());

return parseResponse(m_strResponse);
}
}

const std::string CFTPManager::Pasv()
{
std::string strCmdLine = parseCommand(FTP_COMMAND_PSAV_MODE, "");

if (Send(m_cmdSocket, strCmdLine.c_str()) < 0)
{
return "";
}
else
{
m_strResponse = serverResponse(m_cmdSocket);

return m_strResponse;
}
}

const std::string CFTPManager::Dir(const std::string &path)
{
int dataSocket = socket(AF_INET, SOCK_STREAM, 0);

if (createDataLink(dataSocket) < 0)
{
return "";
}
// 数据连接成功
std::string strCmdLine = parseCommand(FTP_COMMAND_DIR, path);

if (Send(m_cmdSocket, strCmdLine) < 0)
{
trace("@@@@Response: %s\n", serverResponse(m_cmdSocket).c_str());
close(dataSocket);
return "";
}
else
{
trace("@@@@Response: %s\n", serverResponse(m_cmdSocket).c_str());
m_strResponse = serverResponse(dataSocket);

trace("@@@@Response: \n%s\n", m_strResponse.c_str());
close(dataSocket);

return m_strResponse;
}

}

FTP_API CFTPManager::CD(const std::string &path)
{
assert(m_cmdSocket != INVALID_SOCKET);

std::string strCmdLine = parseCommand(FTP_COMMAND_CHANGE_DIRECTORY, path);

if (Send(m_cmdSocket, strCmdLine) < 0)
{
return -1;
}

m_strResponse = serverResponse(m_cmdSocket);

trace("@@@@Response: %s\n", m_strResponse.c_str());
return parseResponse(m_strResponse);
}

FTP_API CFTPManager::DeleteFile(const std::string &strRemoteFile)
{
assert(m_cmdSocket != INVALID_SOCKET);

std::string strCmdLine = parseCommand(FTP_COMMAND_DELETE_FILE, strRemoteFile);

if (Send(m_cmdSocket, strCmdLine) < 0)
{
return -1;
}

m_strResponse = serverResponse(m_cmdSocket);
printf("@@@@Response: %s\n", m_strResponse.c_str());
return parseResponse(m_strResponse);
}

FTP_API CFTPManager::DeleteDirectory(const std::string &strRemoteDir)
{
assert(m_cmdSocket != INVALID_SOCKET);

std::string strCmdLine = parseCommand(FTP_COMMAND_DELETE_DIRECTORY, strRemoteDir);

if (Send(m_cmdSocket, strCmdLine) < 0)
{
return -1;
}

m_strResponse = serverResponse(m_cmdSocket);

trace("@@@@Response: %s\n", m_strResponse.c_str());
return parseResponse(m_strResponse);
}

FTP_API CFTPManager::CreateDirectory(const std::string &strRemoteDir)
{
assert(m_cmdSocket != INVALID_SOCKET);

std::string strCmdLine = parseCommand(FTP_COMMAND_CREATE_DIRECTORY, strRemoteDir);

if (Send(m_cmdSocket, strCmdLine) < 0)
{
return -1;
}

m_strResponse = serverResponse(m_cmdSocket);

trace("@@@@Response: %s\n", m_strResponse.c_str());
return parseResponse(m_strResponse);
}

FTP_API CFTPManager::Rename(const std::string &strRemoteFile, const std::string &strNewFile)
{
assert(m_cmdSocket != INVALID_SOCKET);

std::string strCmdLine = parseCommand(FTP_COMMAND_RENAME_BEGIN, strRemoteFile);
Send(m_cmdSocket, strCmdLine);
trace("@@@@Response: %s\n", serverResponse(m_cmdSocket).c_str());

Send(m_cmdSocket, parseCommand(FTP_COMMAND_RENAME_END, strNewFile));

m_strResponse = serverResponse(m_cmdSocket);
trace("@@@@Response: %s\n", m_strResponse.c_str());
return parseResponse(m_strResponse);
}

long CFTPManager::getFileLength(const std::string &strRemoteFile)
{
assert(m_cmdSocket != INVALID_SOCKET);

std::string strCmdLine = parseCommand(FTP_COMMAND_FILE_SIZE, strRemoteFile);

if (Send(m_cmdSocket, strCmdLine) < 0)
{
return -1;
}

m_strResponse = serverResponse(m_cmdSocket);

trace("@@@@Response: %s\n", m_strResponse.c_str());

std::string strData = m_strResponse.substr(0, 3);
unsigned long val = atol(strData.c_str());

if (val == 213)
{
strData = m_strResponse.substr(4);
trace("strData: %s\n", strData.c_str());
val = atol(strData.c_str());

return val;
}

return -1;
}

void CFTPManager::Close(int sock)
{
shutdown(sock, SHUT_RDWR);
close(sock);
sock = INVALID_SOCKET;
}

FTP_API CFTPManager::Get(const std::string &strRemoteFile, const std::string &strLocalFile)
{
return downLoad(strRemoteFile, strLocalFile);
}

FTP_API CFTPManager::Put(const std::string &strRemoteFile, const std::string &strLocalFile)
{
std::string strCmdLine;
const unsigned long dataLen = FTP_DEFAULT_BUFFER;
char strBuf[dataLen] = {0};
unsigned long nSize = getFileLength(strRemoteFile);
unsigned long nLen = 0;
// 	struct stat sBuf;
//
// 	assert(stat(strLocalFile.c_str(), &sBuf) == 0);
// 	trace("size: %d\n", sBuf.st_size);

FILE *pFile = fopen(strLocalFile.c_str(), "rb");  // 以只读方式打开  且文件必须存在
assert(pFile != NULL);

int data_fd = socket(AF_INET, SOCK_STREAM, 0);
assert(data_fd != -1);

if (createDataLink(data_fd) < 0)
{
return -1;
}

if (nSize == -1)
{
strCmdLine = parseCommand(FTP_COMMAND_UPLOAD_FILE, strRemoteFile);
}
else
{
strCmdLine = parseCommand(FTP_COMMAND_APPEND_FILE, strRemoteFile);
}

if (Send(m_cmdSocket, strCmdLine) < 0)
{
Close(data_fd);
return -1;
}

trace("@@@@Response: %s\n", serverResponse(m_cmdSocket).c_str());

fseek(pFile, nSize, SEEK_SET);
while (!feof(pFile))
{
nLen = fread(strBuf, 1, dataLen, pFile);
if (nLen < 0)
{
break;
}

if (Send(data_fd, strBuf) < 0)
{
Close(data_fd);
return -1;
}
}

trace("@@@@Response: %s\n", serverResponse(data_fd).c_str());

Close(data_fd);
trace("@@@@Response: %s\n", serverResponse(m_cmdSocket).c_str());
fclose(pFile);

return 0;
}

const std::string CFTPManager::parseCommand(const unsigned int command, const std::string &strParam)
{
if (command < FTP_COMMAND_BASE || command > FTP_COMMAND_END)
{
return "";
}

std::string strCommandLine;

m_nCurrentCommand = command;
m_commandStr.clear();

switch (command)
{
case FTP_COMMAND_USERNAME:
strCommandLine = "USER ";
break;
case FTP_COMMAND_PASSWORD:
strCommandLine = "PASS ";
break;
case FTP_COMMAND_QUIT:
strCommandLine = "QUIT ";
break;
case FTP_COMMAND_CURRENT_PATH:
strCommandLine = "PWD ";
break;
case FTP_COMMAND_TYPE_MODE:
strCommandLine = "TYPE ";
break;
case FTP_COMMAND_PSAV_MODE:
strCommandLine = "PASV ";
break;
case FTP_COMMAND_DIR:
strCommandLine = "LIST ";
break;
case FTP_COMMAND_CHANGE_DIRECTORY:
strCommandLine = "CWD ";
break;
case FTP_COMMAND_DELETE_FILE:
strCommandLine = "DELE ";
break;
case FTP_COMMAND_DELETE_DIRECTORY:
strCommandLine = "RMD ";
break;
case FTP_COMMAND_CREATE_DIRECTORY:
strCommandLine = "MKD ";
break;
case FTP_COMMAND_RENAME_BEGIN:
strCommandLine = "RNFR ";
break;
case FTP_COMMAND_RENAME_END:
strCommandLine = "RNTO ";
break;
case FTP_COMMAND_FILE_SIZE:
strCommandLine = "SIZE ";
break;
case FTP_COMMAND_DOWNLOAD_FILE:
strCommandLine = "RETR ";
break;
case FTP_COMMAND_DOWNLOAD_POS:
strCommandLine = "REST ";
break;
case FTP_COMMAND_UPLOAD_FILE:
strCommandLine = "STOR ";
break;
case FTP_COMMAND_APPEND_FILE:
strCommandLine = "APPE ";
break;
default :
break;
}

strCommandLine += strParam;
strCommandLine += "\r\n";

m_commandStr = strCommandLine;
trace("parseCommand: %s\n", m_commandStr.c_str());

return m_commandStr;
}

FTP_API CFTPManager::Connect(int socketfd, const std::string &serverIP, unsigned int nPort)
{
if (socketfd == INVALID_SOCKET)
{
return -1;
}

unsigned int argp = 1;
int error = -1;
int len = sizeof(int);
struct sockaddr_in  addr;
bool ret = false;
timeval stime;
fd_set  set;

ioctl(socketfd, FIONBIO, &argp);  //设置为非阻塞模式

memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_port	= htons(nPort);
addr.sin_addr.s_addr = inet_addr(serverIP.c_str());
bzero(&(addr.sin_zero), 8);

trace("Address: %s %d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

if (connect(socketfd, (struct sockaddr*)&addr, sizeof(struct sockaddr)) == -1)   //若直接返回 则说明正在进行TCP三次握手
{
stime.tv_sec = 20;  //设置为1秒超时
stime.tv_usec = 0;
FD_ZERO(&set);
FD_SET(socketfd, &set);

if (select(socketfd + 1, NULL, &set, NULL, &stime) > 0)   ///在这边等待 阻塞 返回可以读的描述符 或者超时返回0  或者出错返回-1
{
getsockopt(socketfd, SOL_SOCKET, SO_ERROR, &error, (socklen_t*)&len);
if (error == 0)
{
ret = true;
}
else
{
ret = false;
}
}
}
else
{	trace("Connect Immediately!!!\n");
ret = true;
}

argp = 0;
ioctl(socketfd, FIONBIO, &argp);

if (!ret)
{
close(socketfd);
fprintf(stderr, "cannot connect server!!\n");
return -1;
}

//fprintf(stdout, "Connect!!!\n");

return 0;
}

const std::string CFTPManager::serverResponse(int sockfd)
{
if (sockfd == INVALID_SOCKET)
{
return "";
}

int nRet = -1;
char buf[MAX_PATH] = {0};

m_strResponse.clear();

while ((nRet = getData(sockfd, buf, MAX_PATH)) > 0)
{
buf[MAX_PATH - 1] = '\0';
m_strResponse += buf;
}

return m_strResponse;
}

FTP_API CFTPManager::getData(int fd, char *strBuf, unsigned long length)
{
assert(strBuf != NULL);

if (fd == INVALID_SOCKET)
{
return -1;
}

memset(strBuf, 0, length);
timeval stime;
int nLen;

stime.tv_sec = 1;
stime.tv_usec = 0;

fd_set	readfd;
FD_ZERO( &readfd );
FD_SET(fd, &readfd );

if (select(fd + 1, &readfd, 0, 0, &stime) > 0)
{
if ((nLen = recv(fd, strBuf, length, 0)) > 0)
{
return nLen;
}
else
{
return -2;
}
}
return 0;
}

FTP_API CFTPManager::Send(int fd, const std::string &cmd)
{
if (fd == INVALID_SOCKET)
{
return -1;
}

return Send(fd, cmd.c_str(), cmd.length());
}

FTP_API CFTPManager::Send(int fd, const char *cmd, const size_t len)
{
if((FTP_COMMAND_USERNAME != m_nCurrentCommand)
&&(FTP_COMMAND_PASSWORD != m_nCurrentCommand)
&&(!m_bLogin))
{
return -1;
}

timeval timeout;
timeout.tv_sec  = 1;
timeout.tv_usec = 0;

fd_set  writefd;
FD_ZERO(&writefd);
FD_SET(fd, &writefd);

if(select(fd + 1, 0, &writefd , 0 , &timeout) > 0)
{
size_t nlen  = len;
int nSendLen = 0;
while (nlen >0)
{
nSendLen = send(fd, cmd , (int)nlen , 0);

if(nSendLen == -1)
return -2;

nlen = nlen - nSendLen;
cmd +=  nSendLen;
}
return 0;
}
return -1;
}

FTP_API CFTPManager::createDataLink(int data_fd)
{
assert(data_fd != INVALID_SOCKET);

std::string strData;
unsigned long nPort = 0 ;
std::string strServerIp ;
std::list<std::string> strArray ;

std::string parseStr = Pasv();

if (parseStr.size() <= 0)
{
return -1;
}

//trace("parseInfo: %s\n", parseStr.c_str());

size_t nBegin = parseStr.find_first_of("(");
size_t nEnd	  = parseStr.find_first_of(")");
strData		  = parseStr.substr(nBegin + 1, nEnd - nBegin - 1);

//trace("ParseAfter: %s\n", strData.c_str());
if( SplitString( strData , strArray , "," ) <0)
return -1;

if( ParseString( strArray , nPort , strServerIp) < 0)
return -1;

//trace("nPort: %ld IP: %s\n", nPort, strServerIp.c_str());

if (Connect(data_fd, strServerIp, nPort) < 0)
{
return -1;
}

return 0;

}

FTP_API CFTPManager::ParseString(std::list<std::string> strArray, unsigned long & nPort ,std::string & strServerIp)
{
if (strArray.size() < 6 )
return -1 ;

std::list<std::string>::iterator citor;
citor = strArray.begin();
strServerIp = *citor;
strServerIp += ".";
citor ++;
strServerIp += *citor;
strServerIp += ".";
citor ++ ;
strServerIp += *citor;
strServerIp += ".";
citor ++ ;
strServerIp += *citor;
citor = strArray.end();
citor--;
nPort = atol( (*citor).c_str());
citor--;
nPort += atol( (*(citor)).c_str()) * 256 ;
return 0 ;
}

FILE *CFTPManager::createLocalFile(const std::string &strLocalFile)
{
return fopen(strLocalFile.c_str(), "w+b");
}

FTP_API CFTPManager::downLoad(const std::string &strRemoteFile, const std::string &strLocalFile, const int pos, const unsigned int length)
{
assert(length >= 0);

FILE *file = NULL;
unsigned long nDataLen = FTP_DEFAULT_BUFFER;
char strPos[MAX_PATH]  = {0};
int data_fd = socket(AF_INET, SOCK_STREAM, 0);

assert(data_fd != -1);

if ((length != 0) && (length < nDataLen))
{
nDataLen = length;
}
char *dataBuf = new char[nDataLen];
assert(dataBuf != NULL);

sprintf(strPos, "%d", pos);

if (createDataLink(data_fd) < 0)
{
trace("@@@@ Create Data Link error!!!\n");
return -1;
}

std::string strCmdLine = parseCommand(FTP_COMMAND_DOWNLOAD_POS, strPos);
if (Send(m_cmdSocket, strCmdLine) < 0)
{
return -1;
}
trace("@@@@Response: %s\n", serverResponse(m_cmdSocket).c_str());

strCmdLine = parseCommand(FTP_COMMAND_DOWNLOAD_FILE, strRemoteFile);

if (Send(m_cmdSocket, strCmdLine) < 0)
{
return -1;
}
trace("@@@@Response: %s\n", serverResponse(m_cmdSocket).c_str());

file = createLocalFile(std::string(FTP_DEFAULT_PATH + strLocalFile));
assert(file != NULL);

int len = 0;
int nReceiveLen = 0;
while ((len = getData(data_fd, dataBuf, nDataLen)) > 0)
{
nReceiveLen += len;

int num = fwrite(dataBuf, 1, len, file);
memset(dataBuf, 0, sizeof(dataBuf));

//trace("%s", dataBuf);
trace("Num:%d\n", num);
if (nReceiveLen == length && length != 0)
break;

if ((nReceiveLen + nDataLen) > length  && length != 0)
{
delete []dataBuf;
nDataLen = length - nReceiveLen;
dataBuf = new char[nDataLen];
}
}

Close(data_fd);
fclose(file);
delete []dataBuf;

return 0;
}

FTP_API CFTPManager::parseResponse(const std::string &str)
{
assert(!str.empty());

std::string strData = str.substr(0, 3);
unsigned int val = atoi(strData.c_str());

return val;
}