C++实现ftp客户端

zoukankan html css js c++ java

C++实现ftp客户端

C++实现ftp客户端
原创The_King_Cloud 发布于2012-10-19 17:09:42 阅读数 26454 收藏
展开

#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 ", 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 ", 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 ", 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 ", 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 ", serverResponse(m_cmdSocket).c_str());
       close(dataSocket);
       return "";
   }
   else
   {
       trace("@@@@Response: %s ", serverResponse(m_cmdSocket).c_str());
       m_strResponse = serverResponse(dataSocket);

       trace("@@@@Response: %s ", 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 ", 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 ", 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 ", 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 ", 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 ", serverResponse(m_cmdSocket).c_str());

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

   m_strResponse = serverResponse(m_cmdSocket);
   trace("@@@@Response: %s ", 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 ", 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 ", 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 ", 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 ", 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 ", serverResponse(data_fd).c_str());

   Close(data_fd);
   trace("@@@@Response: %s ", 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 += " ";

   m_commandStr = strCommandLine;
   trace("parseCommand: %s ", 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 ", 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!!! ");
       ret = true;
   }

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

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

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

   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] = '';
       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 ", 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 ", strData.c_str());
   if( SplitString( strData , strArray , "," ) <0)
       return -1;

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

   //trace("nPort: %ld IP: %s ", 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!!! ");
       return -1;
   }

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

   strCmdLine = parseCommand(FTP_COMMAND_DOWNLOAD_FILE, strRemoteFile);

   if (Send(m_cmdSocket, strCmdLine) < 0)
   {
       return -1;
   }
   trace("@@@@Response: %s ", 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 ", 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;
}

————————————————
版权声明：本文为CSDN博主「The_King_Cloud」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/The_King_Cloud/article/details/8090699

查看全文

相关阅读:
CRC在线计算器
 freemodbus-v1.5.0 源码分析
 图及其实现
 最短路径
 交换排序-------快速排序
 FreeRTOS--删除任务
 Install OE and BitBake
高端编程之DOM
timeout使用实例
 使用JS提交表单

原文地址：https://www.cnblogs.com/grj001/p/12223103.html

最新文章
Python之几种常用模块
 Python之递归函数
 Python之re模块
 题型分析
 Python之内置函数
 Python之迭代器和生成器
 Python之匿名函数
 Java
cmd
Tomcat