C++实现ftp客户端

转载

mob604756e7db9c 2019-12-19 20:06:00

文章标签 #define #include 服务器下载文件重命名 文章分类 代码人生

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;

}

————————————————

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Webpack 配置 proxy 代理解决跨域问题

下一篇：angularJS中$http.get( ).success( )报错原因及解决方案

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

C++实现ftp客户端

C++实现ftp客户端

51CTO博客