unix平台下ftp客户端c++实现实例

最新推荐文章于 2024-05-12 18:46:21 发布
最新推荐文章于 2024-05-12 18:46:21 发布
阅读量657 收藏 1
点赞数
分类专栏： ftp客户端实现

此实例为unix平台下运行要想在window下运行，只需稍微改动几处即可。

1，文件描述符改为SOCKET

2，去除connect函数中的ictl（）函数

3，默认路径修改

4，对于多个文件或者多个文件夹，可以先压缩，然后传送。此实现可根据put()函数改写一下；

PutCompressPackage(const std::string &strRemoteFile, const std::string &strLocalFile)
{
 std::string strCmdLine;
 const unsigned long dataLen = FTP_DEFAULT_BUFFER;
 char strBuf[dataLen] = {0};
 unsigned long nLen = 0;
 FILE *pFile = fopen(strLocalFile.c_str(), "rb");  // 以只读方式打开  且文件必须存在
 assert(pFile != NULL);

fseek(pFile, 0, SEEK_END);  //先指向文件末尾

unsigned long nSize = ftell(pFile); //计算文件长度

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

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


 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, 0, SEEK_SET); //指向文件开始，后边用于读取。
 while (!feof(pFile))
 {
  nLen = fread(strBuf, 1, dataLen, pFile);
  if (nLen < 0)
  {
   break;
  }

  if (Send(data_fd, strBuf,nLen) < 0)    //不同于put函数，使用的是send函数的重载，必须带上长度！
  {
   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;
}

 

其余的地方根据自己的情况自行修改下就可以直接在window下运行了。

#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;
}

 

我亦歌狂
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
非常好用的c++ ftp库源码（vs2013工程）
01-10
非常好用的c++ ftp库源码（vs2013工程）
C++的简单FTP客户端实现（一）FTP基础知识
余金兑人的技术角落
02-01 1万+
FTP（File Transfer Protocol，文件传输协议） 是 TCP/IP 协议组中的协议之一。FTP协议包括两个组成部分，其一为FTP服务器，其二为FTP客户端。其中FTP服务器用来存储文件，用户可以使用FTP客户端通过FTP协议访问位于FTP服务器上的资源。在开发网站的时候，通常利用FTP协议把网页或程序传到Web服务器上。此外，由于FTP传输效率非常高，在网络上传输大的文件时，一般也采用该协议。 相比其他协议，如 HTTP 协议，FTP 协议要复杂一些。与一般的 C/S 应用不同点在于一
在Linux下，用C语言实现TCP文件传输以及下载
最新发布
qq_52308536的博客
05-12 446
本文使用TCP进行文件传输，支持不同的主机进行传输文件
C++实现ftp客户端
热门推荐
The_King_Cloud的专栏
10-19 3万+
#ifndef CLIENT_H_ #define CLIENT_H_ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define INV
c++对ftp/sftp文件及文件夹上传下载操作工程源代码
whish1994的博客
05-02 1万+
1.完整的项目结构，文档，测试用例2.经过单元测试，集成测试3.sftp使用sshlib2技术源代码工程下载地址：https://download.csdn.net/download/whish1994/10386884GitHub社区clone地址：https://github.com/hiWSH/ftp_sftp调用实例：SFTP操作const char csOpen[] = "{\"ip\"...
Qt：FTP 与 QFtp 实现文件传输（C++: ftplib）
belien
03-04 6100
ftp 定义与介绍、简单阐述，Qt 实现 FTP 传输的三种模式，Qftp 操作与实现
FileZilla FTP Client.zip_Linux/Unix编程_C/C++_
08-10
FileZilla 是一款流行的开源FTP客户端，适用于多种操作系统，包括Windows、Linux和Unix。它提供了直观的用户界面，使得文件传输过程简单易行，无论是对于新手还是经验丰富的开发者都是一个高效的选择。在Linux和Unix...
vs2017 c++ ftp
03-13
1. **套接字编程**：C++中的套接字编程是通过标准库中的`<sys/socket.h>`（Unix-like系统）或Windows Socket API（Winsock）来实现的。套接字是网络通信的基础，它允许程序发送和接收数据。 2. **FTP命令**：FTP...
UNIXUsHb_Unix_Linux_linux_UNIX_
10-03
10. **编程环境**：C、C++、Perl、Python等语言在Unix下的开发环境搭建，Makefile的编写。 11. **版本控制系统**：Git的使用，版本管理的基本概念和实践。 12. **安全与权限**：用户与组管理，访问控制列表（ACL）...
WinCE.rar_Windows_CE_Windows_Unix_
08-11
这需要熟悉FTP/SFTP服务器的配置，以及在Windows CE环境下实现这些协议的客户端代码。 此外，对于跨平台兼容性，开发者需要了解不同的文件系统格式，如FAT32（Windows CE常用）和ext系列（Unix常用），以及如何在...
wangluoxieyi.rar_网络编程_Visual_C++_
08-12
在本文中，我们将深入探讨如何利用Microsoft的Visual C++ 6.0开发环境，结合Windows Socket API（通常称为Winsock）来实现一个网络协议查看器。这个工具可以帮助我们监测和分析网络流量，了解网络通信的底层细节。 ...
C/C++ 实现FTP文件上传下载
CSDN
11-30 5677
FTP（文件传输协议）是一种用于在网络上传输文件的标准协议。它属于因特网标准化的协议族之一，为文件的上传、下载和文件管理提供了一种标准化的方法，在Windows系统中操作FTP上传下载可以使用WinINet库，WinINet（Windows Internet）库是 Windows 操作系统中的一个网络 API 库，用于访问 Internet 上的资源。它提供了一组函数，使开发人员能够创建网络应用程序，例如通过 HTTP 协议下载文件，发送 HTTP 请求，处理 cookie 等，本章将通过使用WinInet
简单的C++ 实现ftp服务器
DongGu‘s Programming
11-24 2254
Linux 服务端， Windows 客户端客户端负责输入要下载的文件名字， 服务器负责传送，但这个代码非常简单，后期可以加好多功能，比如。
计网课设 C++实现 FTP客户端 和 服务器端
Authur_gyc
06-25 1万+
文章目录一、FTP课本知识1.1 概述1.2 基本工作原理二、课设要求三、课设完成流程四、一些知识点五、代码六、参考知识 一、FTP课本知识 计算机网络第七版 谢希仁编著 1.1 概述 FTP提供交互式访问，允许客户指明文件的类型和格式，允许文件具有存取权限。FTP屏蔽了各计算机系统的细节，因此适合于异构网络中任意计算机之间传送文件。RFC959很早就成为了互联网的正式标准。 1.2 基本工作原理 FTP采用客户服务器模式，即Client-Server(C/S)结构。 一个FTP服务器进程可以同时为多个客户
c++ ftp客户端开源库ftplibpp在win10 64环境使用
hx0318的博客
06-06 1650
ir = ftp->Put("F:/ColorTestServer_SchemeDesign/资源/ftplibpp-master.zip", "/a/b/c/ftplibpp-master.zip", ftp->image);需要注意，Connect函数参数需要ip:port的方式，匿名用户的话用户名用anonymous，密码为空。
C++的简单FTP客户端实现（二）编程
余金兑人的技术角落
02-01 6982
基于QT，实现的不是一个功能全的FTP客户端，而是程序中有从FTP服务器下载文件的需求，主要实现了下载的功能，包括断点续传，没有实现多线程下载。
GitHub上有哪些C++写的FTP库
m0_61629312的博客
09-12 833
2023年9月12日，周二下午今天了解到了FTP，想迫不及待地想使用FTP来尝试一些有趣的事情于是去Github找了一些相关的库来玩玩。
C++使用libcurl实现ftp客户端（上传、下载、文件列表、进度、断点续传）
踏莎行的博客
11-08 2万+
在此之前需要先搭建ftp服务器（windows自带，linux可以用vsftpd）以linux环境为例，用cmake编译出libcurl.so动态库（静态库也行）用libcurl C++库写了个ftp上传限制的简单示例，带进度和断点续传功能。
C语言实现FTP客户端与服务器端详解
在实现FTP服务器的过程中，你需要理解如何使用这些函数来建立和维护客户端与服务器之间的连接，以及如何解析和响应FTP命令。同时，服务器端还需要处理多线程或多进程，以便同时处理多个客户端的连接请求。这通常涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值