C++实现FTP综合应用详解

#pragma once
 
//服务器侦听控制连接请求的端口
#define CMD_PORT 5858
//客户机侦听数据连接请求的端口
#define DATA_PORT 5850
//命令报文参数缓存的大小
#define CMD_PARAM_SIZE 256
//回复报文消息缓存的大小
#define RSPNS_TEXT_SIZE 256
#define BACKLOG 10
#define DATA_BUFSIZE 4096
 
//命令类型
typedef enum {
    LS, PWD, CD, DOWN, UP, QUIT
} CmdID;
 
//命令报文,从客户端发往服务器
typedef struct _CmdPacket {
    CmdID cmdid;
    char param[CMD_PARAM_SIZE];
} CmdPacket;
 
//回复报文的类型
typedef enum {
    OK, ERR
} RspnsID;
 
//回复报文,从服务器发往客户端
typedef struct _RspnsPacket {
    RspnsID rspnsid;
    char text[RSPNS_TEXT_SIZE];
} RspnsPacket;

#include <WinSock2.h>
#include "sizes.h"
#include <iOStream>
 
#pragma comment(lib, "ws2_32.lib")
 
//创建线程时传递的数据结构,内含控制连接套接字和客户端地址信息:
struct threadData {
    Socket tcps;
    sockaddr_in clientaddr;
};
 
//全局函数声明:
//FTP初始化,创建一个侦听套接字:
int InitFTP(SOCKET *pListenSock);
int InitDataSocket(SOCKET *pDatatcps, SOCKADDR_IN *pClientAddr);
int ProcessCmd(SOCKET tcps, CmdPacket* pCmd, SOCKADDR_IN *pClientAddr);
int SendRspns(SOCKET tcps, RspnsPacket* prspns);
int RecvCmd(SOCKET tcps, char* pCmd);
int SendFileList(SOCKET datatcps);
int SendFileRecord(SOCKET datatcps, WIN32_FIND_DATA* pfd);
int SendFile(SOCKET datatcps, FILE* file);
int RecvFile(SOCKET datatcps, char* filename);
int FileExists(const char *filename);
 
//线程函数,参数包括相应控制连接的套接字:
DWord WINapi ThreadFunc(LPVOID lpParam) {
    SOCKET tcps;
    sockaddr_in clientaddr;
    tcps = ((struct threadData *)lpParam)->tcps;
    clientaddr = ((struct threadData *)lpParam)->clientaddr;
    printf("socket的编号是：%u.\n", tcps);
 
    //发送回复报文给客户端,内含命令使用说明:
    printf("Serve client %s:%d\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
    RspnsPacket rspns = { OK,
            "欢迎进入FTP综合应用系统!\n"
            "你可以使用的命令:\n"
            "ls\t<展示当前目录下的文件(夹)，无需参数>\n"
            "pwd\t<展示当前目录的绝对路径，无需参数>\n"
            "cd\t<切换到指定目录，参数为路径>\n"
            "down\t<下载文件，参数为文件名>\n"
            "up\t<上传文件，参数为文件名>\n"
            "quit\t<退出系统，无需参数>\n"
    };
    SendRspns(tcps, &rspns);
 
    //循环获取客户端命令报文并进行处理
    for (;;) {
        CmdPacket cmd;
        if (!RecvCmd(tcps, (char *)&cmd))
            break;
        if (!ProcessCmd(tcps, &cmd, &clientaddr))
            break;
    }
 
    //线程结束前关闭控制连接套接字:
    closesocket(tcps);
    delete lpParam;
    return 0;
}
 
int main(int arGC, char* argv[]) {
    SOCKET tcps_listen;  //FTP服务器控制连接侦听套接字
    struct threadData *pThInfo;
 
    if (!InitFTP(&tcps_listen))  //FTP初始化
        return 0;
    printf("FTP服务器开始监听，端口号为：%d。。。。。。\n", CMD_PORT);
 
    //循环接受客户端连接请求,并生成线程去处理:
    for (;;) {
        pThInfo = NULL;
        pThInfo = new threadData;
        if (pThInfo == NULL) {
            printf("为新线程申请空间失败。\n");
            continue;
        }
 
        int len = sizeof(struct threadData);
        //等待接受客户端控制连接请求
        pThInfo->tcps = accept(tcps_listen, (SOCKADDR*)&pThInfo->clientaddr, &len);
 
        //创建一个线程来处理相应客户端的请求:
        DWORD dwThreadId, dwThrdParam = 1;
        HANDLE hThread;
 
        hThread = CreateThread(
            NULL,               //无需安全性的继承
            0,                    //默认线程栈大小
            ThreadFunc,            //线程入口函数
            pThInfo,            //线程入口函数的参数
            0,                    //立即启动线程
            &dwThreadId);        //返回线程的id值
 
        //检查返回值是否创建线程成功
        if (hThread == NULL) {
            printf("创建线程失败。\n");
            closesocket(pThInfo->tcps);
            delete pThInfo;
        }
    }
 
    return 0;
 
}
 
//FTP初始化,创建一个侦听套接字:
 
int InitFTP(SOCKET *pListenSock) {
    //按照此步骤创建新的服务器端套接字，嗯，没错，前三个都是这个步骤
    //startup->socket->bind->listen
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;
    SOCKET tcps_listen;
 
    wVersionRequested = MAKEWORD(2, 2);
    err = WSAStartup(wVersionRequested, &wsaData);
    if (err != 0) {
        printf("Winsock初始化时发生错误!\n");
        return 0;
    }
    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
        WSACleanup();
        printf("无效Winsock版本!\n");
        return 0;
    }
 
    tcps_listen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (tcps_listen == INVALID_SOCKET) {
        WSACleanup();
        printf("创建Socket失败!\n");
        return 0;
    }
 
    SOCKADDR_IN tcpaddr;
    tcpaddr.sin_family = AF_INET;
    tcpaddr.sin_port = htons(CMD_PORT);
    tcpaddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    err = bind(tcps_listen, (SOCKADDR*)&tcpaddr, sizeof(tcpaddr));
    if (err != 0) {
        err = WSAGetLastError();
        WSACleanup();
        printf("Scoket绑定时发生错误!\n");
        return 0;
    }
    err = listen(tcps_listen, 3);
    if (err != 0) {
        WSACleanup();
        printf("Scoket监听时发生错误!\n");
        return 0;
    }
 
    *pListenSock = tcps_listen;
    return 1;
}
 
 
//建立数据连接
//pDatatcps:用于存储数据连接套接字
//pClientAddr:指向客户端的控制连接套接字地址,需要使用其中的IP地址
//返回值:0表示失败,1正常
int InitDataSocket(SOCKET *pDatatcps, SOCKADDR_IN *pClientAddr) {
    SOCKET datatcps;
 
    //创建socket
    datatcps = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (datatcps == INVALID_SOCKET) {
        printf("Creating data socket failed!\n");
        return 0;
    }
 
    SOCKADDR_IN tcpaddr;
    memcpy(&tcpaddr, pClientAddr, sizeof(SOCKADDR_IN));
    tcpaddr.sin_port = htons(DATA_PORT);    //如若有什么意外只需要在头文件修改端口值
 
    //请求连接客户端
    if (connect(datatcps, (SOCKADDR*)&tcpaddr, sizeof(tcpaddr)) == SOCKET_ERROR) {
        printf("Connecting to client failed!\n");
        closesocket(datatcps);
        return 0;
    }
 
    *pDatatcps = datatcps;
    return 1;
}
 
//处理命令报文
//tcps:控制连接套接字
//pcmd:指向待处理的命令报文
//pClientAddr:指向客户端控制连接套接字地址
//返回值:0表示有错或者需要结束连接,1正常
 
int ProcessCmd(SOCKET tcps, CmdPacket* pCmd, SOCKADDR_IN *pClientAddr) {
    SOCKET datatcps;   //数据连接套接字
    RspnsPacket rspns;  //回复报文
    FILE* file;
 
    //根据命令类型分派执行:
    switch (pCmd->cmdid) {
    case LS://展示当前目录下的文件列表
        //首先建立数据连接:
        if (!InitDataSocket(&datatcps, pClientAddr))
            return 0;
        //发送文件列表信息:
        if (!SendFileList(datatcps))
            return 0;
        break;
    case PWD://展示当前目录的绝对路径
        rspns.rspnsid = OK;
        //获取当前目录,并放至回复报文中
        if (!GetCurrentDirectory(RSPNS_TEXT_SIZE, rspns.text))
            strcpy(rspns.text, "Can't get current dir!\n");
        if (!SendRspns(tcps, &rspns))
            return 0;
        break;
    case CD://设置当前目录,使用win32 API 接口函数
        if (SetCurrentDirectory(pCmd->param)) {
            rspns.rspnsid = OK;
            if (!GetCurrentDirectory(RSPNS_TEXT_SIZE, rspns.text))
                strcpy(rspns.text, "切换当前目录成功！但是不能获取到当前的文件列表！\n");
        }
        else {
            strcpy(rspns.text, "不能更换到所选目录！\n");
        }
        if (!SendRspns(tcps, &rspns))   //发送回复报文
            return 0;
        break;
    case DOWN://处理下载文件请求:
        file = fopen(pCmd->param, "rb");   //打开要下载的文件
        if (file) {
            rspns.rspnsid = OK;
            sprintf(rspns.text, "下载文件%s\n", pCmd->param);
            if (!SendRspns(tcps, &rspns)) {
                fclose(file);
                return 0;
            }
            else {
                //创建额外的数据连接来传送数据:
                if (!InitDataSocket(&datatcps, pClientAddr)) {
                    fclose(file);
                    return 0;
                }
                if (!SendFile(datatcps, file))
                    return 0;
                fclose(file);
            }
        }
        else  //打开文件失败
        {
            rspns.rspnsid = ERR;
            strcpy(rspns.text, "不能打开文件！\n");
            if (!SendRspns(tcps, &rspns))
                return 0;
        }
        break;
    case UP://处理上传文件请求
        //首先发送回复报文
        char filename[64];
        strcpy(filename, pCmd->param);
        //首先看一下服务器上是否已经有这个文件里，如果有就告诉客户端不用传输了
        if (FileExists(filename)) {
            rspns.rspnsid = ERR;
            sprintf(rspns.text, "服务器已经存在名字为%s的文件！\n", filename);
            if (!SendRspns(tcps, &rspns))
                return 0;
        }
        else {
            rspns.rspnsid = OK;
            if (!SendRspns(tcps, &rspns))
                return 0;
            //另建立一个数据连接来接受数据:
            if (!InitDataSocket(&datatcps, pClientAddr))
                return 0;
            if (!RecvFile(datatcps, filename))
                return 0;
        }
        break;
    case QUIT:
        printf("客户端断开连接。\n");
        rspns.rspnsid = OK;
        strcpy(rspns.text, "常来啊！\n");
        SendRspns(tcps, &rspns);
        return 0;
 
 
    }
 
    return 1;
 
}
 
//发送回复报文
int SendRspns(SOCKET tcps, RspnsPacket* prspns) {
    if (send(tcps, (char *)prspns, sizeof(RspnsPacket), 0) == SOCKET_ERROR) {
        printf("与客户端失去连接。\n");
        return 0;
    }
    return 1;
}
 
//接收命令报文
//tcps:控制连接套接字
//pCmd:用于存储返回的命令报文
//返回值:0表示有错或者连接已经断开,1表示正常
int RecvCmd(SOCKET tcps, char* pCmd) {                    //used to receive command from client
    int nRet;
    int left = sizeof(CmdPacket);
 
    //从控制连接中读取数据,大小为 sizeof(CmdPacket):
    while (left) {
        nRet = recv(tcps, pCmd, left, 0);
        if (nRet == SOCKET_ERROR) {
            printf("从客户端接受命令时发生未知错误！\n");
            return 0;
        }
        if (!nRet) {
            printf("客户端关闭了连接！\n");
            return 0;
        }
 
        left -= nRet;
        pCmd += nRet;
    }
    return 1;   //成功获取命令报文
}
 
 
//发送一项文件信息:
int SendFileRecord(SOCKET datatcps, WIN32_FIND_DATA* pfd) {                    //used to send response to client
    char filerecord[MAX_PATH + 32];
    FILETIME ft;
    FileTimeToLocalFileTime(&pfd->ftLastWriteTime, &ft);
    SYSTEMTIME lastwtime;
    FileTimeToSystemTime(&ft, &lastwtime);
    char* dir = (char*)(pfd->dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY ? "<DIR>" : "");
    sprintf(filerecord, "%04d-%02d-%02d%02d:%02d   %5s   %10d   %-20s\n",
        lastwtime.wYear,
        lastwtime.wMonth,
        lastwtime.wDay,
        lastwtime.wHour,
        lastwtime.wMinute,
        dir,
        pfd->nFileSizeLow,
        pfd->cFileName);
    if (send(datatcps, filerecord, strlen(filerecord), 0) == SOCKET_ERROR) {
        printf("发送文件列表时发生未知错误！\n");
        return 0;
 
    }
    return 1;
}
 
 
//发送文件列表信息
//datatcps:数据连接套接字
//返回值:0表示出错,1表示正常
int SendFileList(SOCKET datatcps) {
    HANDLE hff;
    WIN32_FIND_DATA fd;
 
    //搜索文件
    hff = FindFirstFile("*", &fd);
    if (hff == INVALID_HANDLE_VALUE)  //发生错误
    {
        const char* errstr = "不能列出文件！\n";
        printf("文件列表输出失败！\n");
        if (send(datatcps, errstr, strlen(errstr), 0) == SOCKET_ERROR) {
            printf("发送给文件列表时发生未知错误！\n");
        }
        closesocket(datatcps);            return 0;
    }
 
    BOOL fMoreFiles = TRUE;
    while (fMoreFiles) {
        //发送此项文件信息:
        if (!SendFileRecord(datatcps, &fd)) {
            closesocket(datatcps);
            return 0;
        }
        //搜索下一个文件
        fMoreFiles = FindNextFile(hff, &fd);
    }
    closesocket(datatcps);
    return 1;
}
 
//通过数据连接发送文件
int SendFile(SOCKET datatcps, FILE* file) {
    char buf[1024];
    printf("发送文件数据中。。。。。。");
    for (;;) {                //从文件中循环读取数据并发送客户端
        int r = fread(buf, 1, 1024, file);
        if (send(datatcps, buf, r, 0) == SOCKET_ERROR) {
            printf("与客户端失去连接！\n");
            closesocket(datatcps);
            return 0;
        }
        if (r < 1024)   //文件传输结束
        {
            break;
        }
    }
    closesocket(datatcps);
    printf("完成传输!\n");
    return 1;
}
 
//接收文件
//datatcps:数据连接套接字,通过它来接收数据
//filename:用于存放数据的文件名
int RecvFile(SOCKET datatcps, char* filename) {
    char buf[1024];
    FILE* file = fopen(filename, "wb");
    if (!file) {
        printf("写入文件时发生未知错误！\n");
        fclose(file);
        closesocket(datatcps);
        return 0;
    }
    printf("接受文件数据中。。。。。。");
    while (1) {
        int r = recv(datatcps, buf, 1024, 0);
        if (r == SOCKET_ERROR) {
            printf("从客户端接受文件时发生未知错误！\n");
            fclose(file);
            closesocket(datatcps);
            return 0;
        }
        if (!r) {
            break;
        }
        fwrite(buf, 1, r, file);
    }
    fclose(file);
    closesocket(datatcps);
    printf("完成传输!\n");
    return 1;
}
 
//检测文件是否存在:
int FileExists(const char *filename)
{
    WIN32_FIND_DATA fd;
    if (FindFirstFile(filename, &fd) == INVALID_HANDLE_VALUE)
        return 0;
    return 1;
}

#pragma once
 
//服务器侦听控制连接请求的端口
#define CMD_PORT 5858
//客户机侦听数据连接请求的端口
#define DATA_PORT 5850
//命令报文参数缓存的大小
#define CMD_PARAM_SIZE 256
//回复报文消息缓存的大小
#define RSPNS_TEXT_SIZE 256
#define BACKLOG 10
#define DATA_BUFSIZE 4096
 
//命令类型
typedef enum {
    LS, PWD, CD, DOWN, UP, QUIT
} CmdID;
 
//命令报文,从客户端发往服务器
typedef struct _CmdPacket {
    CmdID cmdid;
    char param[CMD_PARAM_SIZE];
} CmdPacket;
 
//回复报文的类型
typedef enum {
    OK, ERR
} RspnsID;
 
//回复报文,从服务器发往客户端
typedef struct _RspnsPacket {
    RspnsID rspnsid;
    char text[RSPNS_TEXT_SIZE];
} RspnsPacket;

#include <WinSock2.h>
#include <windows.h>
#include "sizes.h"
#include <tchar.h>
#include <iostream>
 
#pragma comment(lib, "ws2_32.lib")
 
//读取回复报文
void do_read_rspns(SOCKET fd, RspnsPacket *ptr)
{
    int count = 0;
    int size = sizeof(RspnsPacket);
    while (count < size)
    {
        int nRead = recv(fd, (char *)ptr + count, size - count, 0);
        if (nRead <= 0)
        {
            printf("读取服务器的回复失败！\n");
            closesocket(fd);
            exit(1);
        }
        count += nRead;
    }
}
 
//发送命令报文
void do_write_cmd(SOCKET fd, CmdPacket *ptr)
{
    int size = sizeof(CmdPacket);
    int flag = send(fd, (char *)ptr, size, 0);
    if (flag == SOCKET_ERROR)
    {
        printf("给服务器发送命令失败！\n");
        closesocket(fd);
        WSACleanup();
        exit(1);
    }
}
 
//创建数据连接套接字并进入侦听状态
SOCKET create_data_socket()
{
    SOCKET sockfd;
    struct sockaddr_in my_addr;
    //创建用于数据连接的套接字
    if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
    {
        printf("创建用于数据连接的套接字失败！\n");
        WSACleanup();
        exit(1);
    }
    my_addr.sin_family = AF_INET;
    my_addr.sin_port = htons(DATA_PORT);
    my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    memset(&(my_addr.sin_zero), 0, sizeof(my_addr.sin_zero));
 
    //绑定
    if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == SOCKET_ERROR)
    {
        int err = WSAGetLastError();
        printf("绑定地址失败，错误代码：%d\n", err);
        closesocket(sockfd);
        WSACleanup();
        exit(1);
    }
 
    //侦听数据连接请求
    if (listen(sockfd, 1) == SOCKET_ERROR)
    {
        printf("监听数据连接失败！\n");
        closesocket(sockfd);
        WSACleanup();
        exit(1);
    }
    return sockfd;
}
 
//处理list命令
void list(SOCKET sockfd)
{
    int sin_size;
    int nRead;
    CmdPacket cmd_packet;
    SOCKET newsockfd, data_sockfd;
    struct sockaddr_in their_add;
    char data_buf[DATA_BUFSIZE];
 
    //创建数据连接
    newsockfd = create_data_socket();
    //构建命令报文并发送至服务器
    cmd_packet.cmdid = LS;//没有参数
    do_write_cmd(sockfd, &cmd_packet);
    sin_size = sizeof(struct sockaddr_in);
    //接受服务器的数据连接请求
    if ((data_sockfd = accept(newsockfd, (struct sockaddr*)&their_add, &sin_size)) == INVALID_SOCKET)
    {
        printf("获取文件列表失败！\n");
        closesocket(newsockfd);
        closesocket(sockfd);
        WSACleanup();
        exit(1);
    }
 
    //每次读到多少数据就显示多少，直到数据连接断开
    while (true)
    {
        nRead = recv(data_sockfd, data_buf, DATA_BUFSIZE - 1, 0);
        if (nRead == SOCKET_ERROR)
        {
            printf("读取服务器回复失败！\n");
            closesocket(data_sockfd);
            closesocket(newsockfd);
            closesocket(sockfd);
            WSACleanup();
            exit(1);
        }
 
        if (nRead == 0)//数据读取结束
            break;
 
        //显示数据
        data_buf[nRead] = '\0';
        printf("%s", data_buf);
 
    }
    closesocket(data_sockfd);
    closesocket(newsockfd);
}
//处理pwd命令：
void pwd(int sockfd)
{
    CmdPacket cmd_packet;
    RspnsPacket rspns_packet;
 
    cmd_packet.cmdid = PWD;
    //发送命令报文并读取回复：
    do_write_cmd(sockfd, &cmd_packet);
    do_read_rspns(sockfd, &rspns_packet);
    printf("%s\n", rspns_packet.text);
}
 
//处理cd命令:
void cd(int sockfd)
{
    CmdPacket cmd_packet;
    RspnsPacket rspns_packet;
 
 
    cmd_packet.cmdid = CD;
    scanf("%s", cmd_packet.param);
 
    //发送命令报文并读取回复：
    do_write_cmd(sockfd, &cmd_packet);
    do_read_rspns(sockfd, &rspns_packet);
    if (rspns_packet.rspnsid == ERR)
        printf("%s", rspns_packet.text);
}
 
 
//处理down命令，即下载文件：
void get_file(SOCKET sockfd)
{
    FILE *fd;
    char data_buf[DATA_BUFSIZE];
 
    CmdPacket cmd_packet;
    RspnsPacket rspns_packet;
 
    SOCKET newsockfd, data_sockfd;
    struct sockaddr_in their_addr;
    int sin_size;
    int count;
 
    //设置命令报文：
    cmd_packet.cmdid = DOWN;
    scanf("%s", cmd_packet.param);
 
    //打开或者创建本地文件以供写数据：
    fd = fopen(cmd_packet.param, "wb");//使用二进制方程
    if (fd == NULL)
    {
        printf("打开文件%s来写入失败！\n", cmd_packet.param);
        return;
    }
 
    //创建数据连接并侦听服务器的连接请求：
    newsockfd = create_data_socket();
 
    //发送报文请求：
    do_write_cmd(sockfd, &cmd_packet);
 
    //读取回复报文：
    do_read_rspns(sockfd, &rspns_packet);
    if (rspns_packet.rspnsid == ERR)
    {
        printf("%s", rspns_packet.text);
        closesocket(newsockfd);
 
        fclose(fd);
        //删除文件:
        DeleteFile(cmd_packet.param);
        return;
    }
 
    sin_size = sizeof(struct sockaddr_in);
    //等待接受服务器的连接请求
    if ((data_sockfd = accept(newsockfd, (struct sockaddr *)&their_addr, &sin_size)) == INVALID_SOCKET)
    {
        printf("获取文件失败！\n");
        closesocket(newsockfd);
 
        fclose(fd);
        //删除文件：
        DeleteFile(cmd_packet.param);
        return;
    }
 
    //循环读取网络数据并写入文件：
    while ((count = recv(data_sockfd, data_buf, DATA_BUFSIZE, 0)) > 0)
        fwrite(data_buf, sizeof(char), count, fd);
 
    closesocket(data_sockfd);
    closesocket(newsockfd);
    fclose(fd);
}
 
//处理put命令，即上传文件
void put_file(SOCKET sockfd)
{
    FILE *fd;
    CmdPacket cmd_packet;
    RspnsPacket rspns_packet;
    char data_buf[DATA_BUFSIZE];
 
    SOCKET newsockfd, data_sockfd;
    struct sockaddr_in their_addr;
    int sin_size;
    int count;
    cmd_packet.cmdid = UP;
    scanf("%s", cmd_packet.param);
 
    //打开本地文件用于读取数据
    fd = fopen(cmd_packet.param, "rb");
    if (fd == NULL)
    {
        printf("打开文件%s来读取数据失败！\n", cmd_packet.param);
        return;
    }
 
    //创建数据连接套接字并进入侦听状态；
    newsockfd = create_data_socket();
 
    //发送命令报文
    do_write_cmd(sockfd, &cmd_packet);
 
    //读取回复报文
    do_read_rspns(sockfd, &rspns_packet);
    if (rspns_packet.rspnsid == ERR)
    {
        printf("%s", rspns_packet.text);
        closesocket(newsockfd);
        fclose(fd);
        return;
    }
 
    sin_size = sizeof(struct sockaddr_in);
    //准备接受数据连接
    if ((data_sockfd = accept(newsockfd, (struct sockaddr *)&their_addr, &sin_size)) == INVALID_SOCKET)
    {
        printf("上传文件传输错误！\n");
        closesocket(newsockfd);
        fclose(fd);
        return;
    }
    //循环从文件中读取数据并发给服务器
    while (true)
    {
        count = fread(data_buf, sizeof(char), DATA_BUFSIZE, fd);
        send(data_sockfd, data_buf, count, 0);
        if (count < DATA_BUFSIZE)//数据已经读完或者发生cuowu
            break;
    }
 
    closesocket(data_sockfd);
    closesocket(newsockfd);
    fclose(fd);
}
 
//处理退出命令
void quit(int sockfd)
{
    CmdPacket cmd_packet;
    RspnsPacket rspns_packet;
 
    cmd_packet.cmdid = QUIT;
    do_write_cmd(sockfd, &cmd_packet);
    do_read_rspns(sockfd, &rspns_packet);
    printf("%s", rspns_packet.text);
    getchar();
}
 
void main()
{
    SOCKET sockfd;
    struct sockaddr_in their_addr;
    char cmd[10];
    RspnsPacket rspns_packet;
 
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;
    wVersionRequested = MAKEWORD(2, 2);
    //Winsock初始化
    err = WSAStartup(wVersionRequested, &wsaData);
    if (err != 0)
    {
        printf("WinSock初始化失败！\n");
        return;
    }
 
    //确认WindSock DLL的版本是2.2
    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
    {
        printf("WindSock版本不是2.2！\n");
        WSACleanup();
        return;
    }
 
    //创建用于控制谅解的socket
    sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockfd == INVALID_SOCKET)
    {
        printf("创建套接字失败！\n");
        WSACleanup();
        exit(1);
    }
    their_addr.sin_family = AF_INET;
    their_addr.sin_port = htons(CMD_PORT);
    their_addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    memset(&(their_addr.sin_zero), 0, sizeof(their_addr.sin_zero));
 
    //连接服务器
    if (connect(sockfd, (struct sockaddr*)&their_addr, sizeof(struct sockaddr)) == SOCKET_ERROR)
    {
        printf("连接服务器失败！\n");
        closesocket(sockfd);
        WSACleanup();
        exit(1);
    }
 
    //连接成功后，首先接受服务器发回的消息
    do_read_rspns(sockfd, &rspns_packet);
    printf("%s", rspns_packet.text);
 
    //主循环：读取用户输入并分配执行
    while (true)
    {
        scanf("%s", cmd);
        switch (cmd[0])
        {
        case 'l'://处理List命令
            list(sockfd);
            break;
        case 'p'://处理pwd命令
            pwd(sockfd);
            break;
        case 'c'://处理cd命令
            cd(sockfd);
            break;
        case 'd'://处理down命令
            get_file(sockfd);
            break;
        case 'u'://处理up命令
            put_file(sockfd);
            break;
        case 'q'://处理quit命令
            quit(sockfd);
            break;
        default:
            printf("不存在的命令！\n");
            break;
        }
        if (cmd[0] == 'q')
            break;
    }
    WSACleanup();
}