W5500以太网控制器芯片（五）：实现FTP客户端

最新推荐文章于 2023-12-06 15:21:19 发布
最新推荐文章于 2023-12-06 15:21:19 发布
阅读量2.7k 收藏 22
点赞数 4
分类专栏： W5500 嵌入式 文章标签： c语言 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangfls/article/details/119883211
版权


#W5500以太网控制芯片相关文章链接#

上一篇：

W5500以太网控制器芯片（四）：实现DNS功能

使用w5500通过以太网口可以实现FTP功能。首先要了解FTP的基本命令和通讯方式。
FTP的本质是TCP连接，所以我们要实现一个TCP客户端，然后实现一些指定的FTP命令的发送和解析。

FTP基本命令：

命令描述
ABOR中断数据连接程序
ACCT <account>系统特权帐号
ALLO <bytes>为服务器上的文件存储器分配字节
APPE <filename>添加文件到服务器同名文件
CDUP <dir path>改变服务器上的父目录
CWD <dir path>改变服务器上的工作目录
DELE <filename>删除服务器上的指定文件
HELP <command>返回指定命令信息
LIST <name>如果是文件名列出文件信息，如果是目录则列出文件列表
MODE <mode>传输模式（S=流模式，B=块模式，C=压缩模式）
MKD <directory>在服务器上建立指定目录
NLST <directory>列出指定目录内容
NOOP无动作，除了来自服务器上的承认
PASS <password>系统登录密码
PASV请求服务器等待数据连接
PORT <address>IP 地址和两字节的端口 ID
PWD显示当前工作目录
QUIT从 FTP 服务器上退出登录
REIN重新初始化登录状态连接
REST <offset>由特定偏移量重启文件传递
RETR <filename>从服务器上找回（复制）文件
RMD <directory>在服务器上删除指定目录
RNFR <old path>对旧路径重命名
RNTO <new path>对新路径重命名
SITE <params>由服务器提供的站点特殊参数
SMNT <pathname>挂载指定文件结构
STAT <directory>在当前程序或目录上返回信息
STOR <filename>储存（复制）文件到服务器上
STOU <filename>储存文件到服务器名称上
STRU <type>数据结构（F=文件，R=记录，P=页面）
SYST返回服务器使用的操作系统
TYPE <data type>数据类型（A=ASCII，E=EBCDIC，I=binary）
USER <username>系统登录的用户名

FTP基本响应码：

响应代码解释说明
110新文件指示器上的重启标记
120服务器准备就绪的时间（分钟数）
125打开数据连接，开始传输
150打开连接
200成功
202命令没有执行
211系统状态回复
212目录状态回复
213文件状态回复
214帮助信息回复
215系统类型回复
220服务就绪
221退出网络
225打开数据连接
226结束数据连接
227进入被动模式（IP 地址、ID 端口）
230登录因特网
250文件行为完成
257路径名建立
331要求密码
332要求帐号
350文件行为暂停
421服务关闭
425无法打开数据连接
426结束连接
450文件不可用
451遇到本地错误
452磁盘空间不足
500无效命令
501错误参数
502命令没有执行
503错误指令序列
504无效命令参数
530未登录网络
532存储文件需要帐号
550文件不可用
551不知道的页类型
552超过存储分配
553文件名不允许


通过发送和解析这些命令和响应码，再加上TCP客户端和服务器，就可以分别实现FTP客户端和FTP服务器。

下面来实现一个FTP客户端，下载升级文件:

一般FTP分主动和被动模式，在主动模式下，通常21端口是命令端口，20端口是数据端口。在被动模式下，数据端口不一定。一般客户端可以先通知服务器，请求被动模式命令端口，然后再解析服务器的回复，得到被动端口，然后去连接，接收数据内容。

1、开始先定义一些参数：

//FTP服务socket通道
#define SOCK_FTP_CTRL 6
#define SOCK_FTP_DATA 7

un_l2cval remote_ip;
uint16_t remote_port;
uint16_t local_port;
uint8_t connect_state_control_ftpc = 0;
uint8_t connect_state_data_ftpc = 0;
uint8_t gModeActivePassiveflag = 0;
uint8_t gMenuStart = 0;
uint8_t gDataSockReady = 0;
uint8_t gDataPutGetStart = 0;

//FTP服务器地址
uint8_t FTP_destip[4] = {192, 1, 1, 1};
uint16_t FTP_destport = 0;

//FTP数据传输缓冲区
uint8_t FTP_data_buf[1500] = {0};

struct ftpc ftpc;
struct Command Command;

//以太网获取FTP状态
uint8_t ether_ftp_sta = 0;

//FTP文件大小
u32 ftp_file_size = 0;

//FTP文件句柄
int ftp_fd_w = 0;

void ftp_data_deal(u8 *buf, u16 len);

void ftpc_init(void);

uint8_t ftpc_run(void);

char proc_ftpc(char *buf);

int pportc(char *arg);

头文件定义：

#ifndef __W5500_FTP_H
#define __W5500_FTP_H

#include "bsp_include.h"

#include <stdint.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>
#include <stdarg.h>

#include "w5500_socket.h"


#define LINELEN		128

#define _MAX_SS		1400

/* FTP Responses */
#define R_150	150		/* File status ok; opening data conn */
#define R_200	200		/* 'Generic' command ok */
#define R_220	220		/* Service ready for new user. */
#define R_226	226		/* Closing data connection.  File transfer/abort successful */
#define R_227	227		/* Entering passive mode (h1,h2,h3,h4,p1,p2) */
#define R_230	230		/* User logged in, proceed */
#define R_331	331		/* User name okay, need password. */

#define TransferAscii		'A'
#define TransferBinary		'I'

enum ftpc_type {
	ASCII_TYPE,
	IMAGE_TYPE,
};

enum ftpc_datasock_state{
	DATASOCK_IDLE,
	DATASOCK_READY,
	DATASOCK_START
};

enum ftpc_datasock_mode{
	PASSIVE_MODE,
	ACTIVE_MODE
};
enum CommandFirst {
	f_nocmd,
	f_dir,
	f_put,
	f_get,
};
enum CommandSecond {
	s_nocmd,
	s_dir,
	s_put,
	s_get,
};
struct Command {
	enum CommandFirst First;
	enum CommandSecond Second;
};
struct ftpc {
	uint8_t control;			/* Control stream */
	uint8_t data;				/* Data stream */

	enum ftpc_type type;		/* Transfer type */

	enum ftpc_datasock_state dsock_state;
	enum ftpc_datasock_mode dsock_mode;

	char workingdir[LINELEN];
	char filename[LINELEN];
};

typedef union _un_l2cval {
	uint32_t	lVal;
	uint8_t		cVal[4];
}un_l2cval;

void Ethernet_FTP_service_deal(void);

#endif

2、定义一个FTP服务，下载完成后退出

//初始化FTP Client
void ftpc_init(void)
{
    connect_state_control_ftpc = 0;
    connect_state_data_ftpc = 0;
    gModeActivePassiveflag = 0;
    gMenuStart = 0;
    gDataSockReady = 0;
    gDataPutGetStart = 0;

    ftp_file_size = 0;
    ftp_fd_w = 0;

    //创建FTP命令socket
    ftpc.dsock_mode = PASSIVE_MODE;
    local_port = 35000;
    w5500_socket(SOCK_FTP_CTRL, Sn_MR_TCP, FTP_destport, 0x0);
}

//以太网FTP服务处理
void Ethernet_FTP_service_deal(void)
{
    //下载初始化
    if (ether_ftp_sta == 0)
    {
        ether_ftp_sta = 1;
        ftpc_init();
    }

    //下载完成
    if (ether_ftp_sta > 2)
    {
        //关闭socket通道
        w5500_disconnect(SOCK_FTP_DATA);
        w5500_close(SOCK_FTP_DATA);

        w5500_disconnect(SOCK_FTP_CTRL);
        w5500_close(SOCK_FTP_CTRL);

        if (ether_ftp_sta == 3) //下载成功
        {
            ol_print(DEBUG_CHN, 0, "ETH FTP success\n");
            System_Sta.FTP_Sta = FTP_SUCCESS;
        }
        else if (ether_ftp_sta == 0xFF) //下载失败
        {
            ol_print(DEBUG_CHN, 0, "ETH FTP fail\n");
            System_Sta.FTP_Sta = FTP_FAIL;
        }

        ether_ftp_sta = 0;
        return;
    }

    ftpc_run(); //FTP客户端状态机
}

3、实现FTP下载文件的命令发送流程
（1）、连接FTP服务器，提供用户名密码。
（2）、通知FTP服务器被动模式，解析被动模式端口（PASV），打开数据通道
（3）、查询指定的文件在FTP服务器是否存在，获取文件大小(LIST)，数据通道断开
（4）、再次请求数据通道端口（PASV），打开数据通道
（5）、分段读取文件（RETR），读取完成，数据通道断开
（6）、比较读取到的文件和之前查询的长度是否一致

//FTP客户端状态机
uint8_t ftpc_run(void)
{
    uint16_t size = 0;
    long ret = 0;
    uint32_t recv_byte;
    uint32_t remain_datasize;
    uint8_t dat[50] = {
        0,
    };

    //FTP命令通道处理
    switch (getSn_SR(SOCK_FTP_CTRL))
    {
    case SOCK_ESTABLISHED:
    {
        //socket连接成功
        if (!connect_state_control_ftpc)
        {
            ol_print(DEBUG_CHN, 0, "%d:FTP Connected\r\n", SOCK_FTP_CTRL);
            strcpy(ftpc.workingdir, "/");
            connect_state_control_ftpc = 1;
        }

        //有命令要执行
        if (gMenuStart)
        {
            ol_print(DEBUG_CHN, 0, "FTP cmd start:%d\r\n", ether_ftp_sta);
            gMenuStart = 0;
            if (ether_ftp_sta == 1) //开始查询文件基本信息
            {
                if (ftpc.dsock_mode == PASSIVE_MODE) //被动模式下载
                {
                    sprintf((char *)dat, "PASV\r\n");
                    w5500_send(SOCK_FTP_CTRL, (uint8_t *)dat, strlen((char *)dat));
                    Command.First = f_dir;
                }
                else
                {
                    wiz_NetInfo gWIZNETINFO;
                    ctlnetwork(CN_GET_NETINFO, (void *)&gWIZNETINFO);
                    sprintf((char *)dat, "PORT %d,%d,%d,%d,%d,%d\r\n", gWIZNETINFO.ip[0], gWIZNETINFO.ip[1], gWIZNETINFO.ip[2], gWIZNETINFO.ip[3], (uint8_t)(local_port >> 8), (uint8_t)(local_port & 0x00ff));
                    w5500_send(SOCK_FTP_CTRL, (uint8_t *)dat, strlen((char *)dat));
                    Command.First = f_dir;
                    gModeActivePassiveflag = 1;
                }
            }
            else if (ether_ftp_sta == 2) //开始下载文件,需要重新分配一次端口
            {
                if (ftpc.dsock_mode == PASSIVE_MODE) //被动模式下载
                {
                    sprintf((char *)dat, "PASV\r\n");
                    w5500_send(SOCK_FTP_CTRL, (uint8_t *)dat, strlen((char *)dat));
                    Command.First = f_get;
                }
                else
                {
                    wiz_NetInfo gWIZNETINFO;
                    ctlnetwork(CN_GET_NETINFO, (void *)&gWIZNETINFO);
                    sprintf((char *)dat, "PORT %d,%d,%d,%d,%d,%d\r\n", gWIZNETINFO.ip[0], gWIZNETINFO.ip[1], gWIZNETINFO.ip[2], gWIZNETINFO.ip[3], (uint8_t)(local_port >> 8), (uint8_t)(local_port & 0x00ff));
                    w5500_send(SOCK_FTP_CTRL, (uint8_t *)dat, strlen((char *)dat));
                    Command.First = f_get;
                    gModeActivePassiveflag = 1;
                }
            }
        }

        //数据通道就绪，可以开始发送FTP命令
        if (gDataSockReady)
        {
            gDataSockReady = 0;
            switch (Command.First)
            {
            case f_dir: //列出要下载的FTP文件信息
                // sprintf(dat, "MLSD\r\n");
                sprintf((char *)dat, "LIST %s\r\n", System_Para.Filename);
                w5500_send(SOCK_FTP_CTRL, (uint8_t *)dat, strlen((char *)dat));
                break;
            case f_get:
                ol_print(DEBUG_CHN, 0, ">get file name?%s\n", System_Para.Filename);
                sprintf((char *)dat, "RETR %s\r\n", System_Para.Filename);
                w5500_send(SOCK_FTP_CTRL, (uint8_t *)dat, strlen((char *)dat));
                break;
            }
        }

        //接收到FTP命令通道数据
        if ((size = getSn_RX_RSR(SOCK_FTP_CTRL)) > 0)
        {
            // Don't need to check SOCKERR_BUSY because it doesn't not occur.
            memset(FTP_data_buf, 0, _MAX_SS);
            if (size > _MAX_SS)
                size = _MAX_SS - 1;

            ret = w5500_recv(SOCK_FTP_CTRL, FTP_data_buf, size);
            FTP_data_buf[ret] = '\0';
            if (ret != size)
            {
                if (ret == SOCK_BUSY)
                    return 0;
                if (ret < 0)
                {
                    ol_print(DEBUG_CHN, 0, "%d:recv() error:%ld\r\n", SOCK_FTP_CTRL, ret);
                    w5500_close(SOCK_FTP_CTRL);
                    //命令通道接收异常，关闭FTP下载
                    ether_ftp_sta = 0xFF;
                    return ret;
                }
            }
            ol_print(DEBUG_CHN, 0, "Rcvd Command: %s\r\n", FTP_data_buf);
            proc_ftpc((char *)FTP_data_buf); //处理命令
        }
        break;
    }
    case SOCK_CLOSE_WAIT: //SOCKET关闭等待
    {
        ol_print(DEBUG_CHN, 0, "%d:CloseWait\r\n", SOCK_FTP_CTRL);
        if ((ret = w5500_disconnect(SOCK_FTP_CTRL)) != SOCK_OK)
            return ret;
        ol_print(DEBUG_CHN, 0, "%d:Closed\r\n", SOCK_FTP_CTRL);
        break;
    }
    case SOCK_CLOSED: //SOCKET关闭状态
    {
        ol_print(DEBUG_CHN, 0, "%d:FTPStart\r\n", SOCK_FTP_CTRL);
        if ((ret = w5500_socket(SOCK_FTP_CTRL, Sn_MR_TCP, FTP_destport, 0x0)) != SOCK_FTP_CTRL)
        {
            ol_print(DEBUG_CHN, 0, "%d:socket() error:%ld\r\n", SOCK_FTP_CTRL, ret);
            w5500_close(SOCK_FTP_CTRL);
            return ret;
        }
        break;
    }
    case SOCK_INIT: //SOCKET初始化状态
    {
        ol_print(DEBUG_CHN, 0, "%d:Opened\r\n", SOCK_FTP_CTRL);
        if ((ret = w5500_connect(SOCK_FTP_CTRL, FTP_destip, FTP_destport)) != SOCK_OK)
        {
            ol_print(DEBUG_CHN, 0, "%d:Connect error\r\n", SOCK_FTP_CTRL);
            return ret;
        }
        connect_state_control_ftpc = 0;
        ol_print(DEBUG_CHN, 0, "%d:Connectting...\r\n", SOCK_FTP_CTRL);
        break;
    }
    }

    //FTP数据通道
    switch (getSn_SR(SOCK_FTP_DATA))
    {
    case SOCK_ESTABLISHED:
    {
        if (!connect_state_data_ftpc)
        {
            ol_print(DEBUG_CHN, 0, "%d:FTP Data socket Connected\r\n", SOCK_FTP_DATA);
            connect_state_data_ftpc = 1;
        }

        //开始接收数据
        if (gDataPutGetStart)
        {
            ol_print(DEBUG_CHN, 0, "%d:rec ftp data:%d\r\n", SOCK_FTP_DATA, Command.Second);

            switch (Command.Second)
            {
            case s_dir: //查询文件信息是小文本，发送完后数据通道会直接断开，此段程序一般无法进入
            {
                while (1)
                {
                    if ((remain_datasize = getSn_RX_RSR(SOCK_FTP_DATA)) > 0)
                    {
                        while (1)
                        {
                            memset(FTP_data_buf, 0, _MAX_SS);
                            if (remain_datasize > _MAX_SS)
                                recv_byte = _MAX_SS;
                            else
                                recv_byte = remain_datasize;
                            ret = w5500_recv(SOCK_FTP_DATA, FTP_data_buf, recv_byte);

                            if (ret > 0)
                            {
                                ftp_data_deal(FTP_data_buf, ret);
                            }
                            else
                            {
                                //传输失败，结束FTP下载
                                ether_ftp_sta = 0xFF;
                                return 0;
                            }

                            remain_datasize -= ret;
                            if (remain_datasize <= 0)
                                break;
                        }
                    }
                    else
                    {
                        if (getSn_SR(SOCK_FTP_DATA) != SOCK_ESTABLISHED)
                            break;
                    }
                }
                gDataPutGetStart = 0;
                Command.Second = s_nocmd;
                break;
            }
            case s_get:
            {
                while (1)
                {
                    if ((remain_datasize = getSn_RX_RSR(SOCK_FTP_DATA)) > 0)
                    {
                        while (1)
                        {
                            memset(FTP_data_buf, 0, _MAX_SS);
                            if (remain_datasize > _MAX_SS)
                                recv_byte = _MAX_SS;
                            else
                                recv_byte = remain_datasize;
                            ret = w5500_recv(SOCK_FTP_DATA, FTP_data_buf, recv_byte);
                            if (ret > 0)
                            {
                                ftp_data_deal(FTP_data_buf, ret);
                            }
                            else
                            {
                                //传输失败，结束FTP下载
                                ether_ftp_sta = 0xFF;
                                return 0;
                            }

                            remain_datasize -= ret;
                            if (remain_datasize <= 0)
                                break;
                        }
                    }
                    else
                    {
                        if (getSn_SR(SOCK_FTP_DATA) != SOCK_ESTABLISHED)
                            break;
                    }
                }
                gDataPutGetStart = 0;
                Command.Second = s_nocmd;
                break;
            }
            }
        }
        break;
    }
    case SOCK_CLOSE_WAIT:
    {
        //对于较小的数据，一次传输后FTP数据通道会直接关闭，所以在SOCK_CLOSE_WAIT状态下也要先接收一次数据
        if (gDataPutGetStart)
        {
            ol_print(DEBUG_CHN, 0, "%d:rec ftp data wait:%d\r\n", SOCK_FTP_DATA, Command.Second);

            switch (Command.Second)
            {
            case s_dir:
            {
                while (1)
                {
                    if ((remain_datasize = getSn_RX_RSR(SOCK_FTP_DATA)) > 0)
                    {
                        while (1)
                        {
                            memset(FTP_data_buf, 0, _MAX_SS);
                            if (remain_datasize > _MAX_SS)
                                recv_byte = _MAX_SS;
                            else
                                recv_byte = remain_datasize;
                            ret = w5500_recv(SOCK_FTP_DATA, FTP_data_buf, recv_byte);
                            if (ret > 0)
                            {
                                ftp_data_deal(FTP_data_buf, ret);
                            }
                            else
                            {
                                //传输失败，结束FTP下载
                                ether_ftp_sta = 0xFF;
                                return 0;
                            }

                            remain_datasize -= ret;
                            if (remain_datasize <= 0)
                                break;
                        }
                    }
                    else
                    {
                        if (getSn_SR(SOCK_FTP_DATA) != SOCK_ESTABLISHED)
                            break;
                    }
                }
                gDataPutGetStart = 0;
                Command.Second = s_nocmd;
                break;
            }
            case s_get:
            {
                while (1)
                {
                    if ((remain_datasize = getSn_RX_RSR(SOCK_FTP_DATA)) > 0)
                    {
                        while (1)
                        {
                            memset(FTP_data_buf, 0, _MAX_SS);
                            if (remain_datasize > _MAX_SS)
                                recv_byte = _MAX_SS;
                            else
                                recv_byte = remain_datasize;
                            ret = w5500_recv(SOCK_FTP_DATA, FTP_data_buf, recv_byte);
                            if (ret > 0)
                            {
                                ftp_data_deal(FTP_data_buf, ret);
                            }
                            else
                            {
                                //传输失败，结束FTP下载
                                ether_ftp_sta = 0xFF;
                                return 0;
                            }

                            remain_datasize -= ret;
                            if (remain_datasize <= 0)
                                break;
                        }
                    }
                    else
                    {
                        if (getSn_SR(SOCK_FTP_DATA) != SOCK_ESTABLISHED)
                            break;
                    }
                }
                gDataPutGetStart = 0;
                Command.Second = s_nocmd;
                break;
            }
            }
        }

        ol_print(DEBUG_CHN, 0, "%d:CloseWait\r\n", SOCK_FTP_DATA);
        if ((ret = w5500_disconnect(SOCK_FTP_DATA)) != SOCK_OK)
        {
            //无法正常关闭数据通道，FTP失败
            ether_ftp_sta = 0xFF;
            return 0;
        }
        else
        {
            //关闭数据通道成功，数据解析完毕，进入FTP下一步
            if (ether_ftp_sta == 1) //文件信息读取结束
            {
                ether_ftp_sta = 2;
                gMenuStart = 1;
            }
            else if (ether_ftp_sta == 2) //文件下载结束，准备升级
            {
                ether_ftp_sta = 3;

                vfs_close(ftp_fd_w);

                //读取文件大小
                ret = vfs_file_size("/fota/ftptext.pack");
                ol_print(DEBUG_CHN, 0, "FTP file size:%d,%d\n", ftp_file_size, ret);

                if (ftp_file_size != System_Para.Filesize)
                {
                    ether_ftp_sta = 0xFF;
                }

                ret = vfs_rename("/fota/ftptext.pack", "/fota/fota.pack");
                if (ret != 0)
                {
                    ether_ftp_sta = 0xFF;
                }
            }
        }
        ol_print(DEBUG_CHN, 0, "%d:Closed\r\n", SOCK_FTP_DATA);
        break;
    }
    case SOCK_CLOSED:
    {
        if (ftpc.dsock_state == DATASOCK_READY)
        {
            if (ftpc.dsock_mode == PASSIVE_MODE)
            {
                ol_print(DEBUG_CHN, 0, "%d:FTPDataStart, port : %d\r\n", SOCK_FTP_DATA, local_port);
                if ((ret = w5500_socket(SOCK_FTP_DATA, Sn_MR_TCP, local_port, 0x0)) != SOCK_FTP_DATA)
                {
                    ol_print(DEBUG_CHN, 0, "%d:socket() error:%ld\r\n", SOCK_FTP_DATA, ret);
                    w5500_close(SOCK_FTP_DATA);
                    return ret;
                }
                local_port++;
                if (local_port > 50000)
                    local_port = 35000;
            }
            else
            {
                ol_print(DEBUG_CHN, 0, "%d:FTPDataStart, port : %d\r\n", SOCK_FTP_DATA, local_port);
                if ((ret = w5500_socket(SOCK_FTP_DATA, Sn_MR_TCP, local_port, 0x0)) != SOCK_FTP_DATA)
                {
                    ol_print(DEBUG_CHN, 0, "%d:socket() error:%ld\r\n", SOCK_FTP_DATA, ret);
                    w5500_close(SOCK_FTP_DATA);
                    return ret;
                }
                local_port++;
                if (local_port > 50000)
                    local_port = 35000;
            }
            ftpc.dsock_state = DATASOCK_START;
        }
        break;
    }
    case SOCK_INIT:
    {
        ol_print(DEBUG_CHN, 0, "%d:Opened\r\n", SOCK_FTP_DATA);
        if (ftpc.dsock_mode == ACTIVE_MODE)
        {
            if ((ret = w5500_listen(SOCK_FTP_DATA)) != SOCK_OK)
            {
                OSI_LOGI(0, "w5500 FTP Listen error %d", SOCK_FTP_DATA);
                return ret;
            }
            gDataSockReady = 1;
            OSI_LOGI(0, "w5500 FTP Listen ok:%d", SOCK_FTP_DATA);
        }
        else
        {
            if ((ret = w5500_connect(SOCK_FTP_DATA, remote_ip.cVal, remote_port)) != SOCK_OK)
            {
                ol_print(DEBUG_CHN, 0, "%d:Connect error\r\n", SOCK_FTP_DATA);
                return ret;
            }
            gDataSockReady = 1; //FTP数据通道开启完成，准备执行命令
        }
        connect_state_data_ftpc = 0;
        break;
    }
    }
    return 0;
}

解析FTP相应码：

//FTP服务器回复的协议解析
char proc_ftpc(char *buf)
{
    uint16_t Responses;
    uint8_t dat[30] = {
        0,
    };

    Responses = (buf[0] - '0') * 100 + (buf[1] - '0') * 10 + (buf[2] - '0');

    switch (Responses)
    {
    case R_220: /* Service ready for new user. */
        ol_print(DEBUG_CHN, 0, "USER %s\n", System_Para.User);
        sprintf((char *)dat, "USER %s\r\n", System_Para.User);
        ol_print(DEBUG_CHN, 0, "\r\n");
        w5500_send(SOCK_FTP_CTRL, (uint8_t *)dat, strlen((char *)dat));
        break;
    case R_331: /* User name okay, need password. */
        ol_print(DEBUG_CHN, 0, "PASS %s\n", System_Para.Pass);
        sprintf((char *)dat, "PASS %s\r\n", System_Para.Pass);
        w5500_send(SOCK_FTP_CTRL, (uint8_t *)dat, strlen((char *)dat));
        break;
    case R_230: //登录成功，通知FTP服务器使用ASCII通讯
        ol_print(DEBUG_CHN, 0, "\r\nlogged in, proceed\r\n");
        sprintf((char *)dat, "TYPE %c\r\n", TransferAscii);
        ftpc.type = ASCII_TYPE;
        w5500_send(SOCK_FTP_CTRL, (uint8_t *)dat, strlen((char *)dat));
        break;
    case R_200: //设置ASCII模式完成，服务器回复成功
    {
        if ((ftpc.dsock_mode == ACTIVE_MODE) && gModeActivePassiveflag)
        {
            ftpc.dsock_state = DATASOCK_READY;
            gModeActivePassiveflag = 0;
        }
        else
        {
            gMenuStart = 1;
        }
        break;
    }
    case R_150: //命令发送成功，开始传输数据
    {
        switch (Command.First)
        {
        case f_dir:
            Command.First = f_nocmd;
            Command.Second = s_dir;
            gDataPutGetStart = 1;
            break;
        case f_get:
            Command.First = f_nocmd;
            Command.Second = s_get;
            gDataPutGetStart = 1;
            break;
        }
        break;
    }
    case R_226: //数据通道结束连接
        gMenuStart = 1;
        break;
    case R_227: //被动模式设置成功，服务器返回被动模式数据端口
    {
        if (pportc(buf) == -1)
        {
            ol_print(DEBUG_CHN, 0, "Bad port syntax\r\n");

            //转换被动模式失败，结束FTP
            ether_ftp_sta = 0xFF;
        }
        else
        {
            ol_print(DEBUG_CHN, 0, "Go Open Data Sock...\r\n ");
            ftpc.dsock_mode = PASSIVE_MODE;
            ftpc.dsock_state = DATASOCK_READY; //开启FTP数据通道
        }
        break;
    }
    default:
        OSI_LOGI(0, "w5500 FTP Default Status:%d", (uint16_t)Responses);
        gDataSockReady = 1;
        break;
    }
    return 1;
}

计算被动模式端口：

//计算被动模式连接端口
int pportc(char *arg)
{
    int i;
    char *tok = 0;
    strtok(arg, "(");
    for (i = 0; i < 4; i++)
    {
        if (i == 0)
            tok = strtok(NULL, ",\r\n");
        else
            tok = strtok(NULL, ",");
        remote_ip.cVal[i] = (uint8_t)atoi(tok);
        if (!tok)
        {
            ol_print(DEBUG_CHN, 0, "bad pport : %s\r\n", arg);
            return -1;
        }
    }
    remote_port = 0;
    for (i = 0; i < 2; i++)
    {
        tok = strtok(NULL, ",\r\n");
        remote_port <<= 8;
        remote_port += atoi(tok);
        if (!tok)
        {
            ol_print(DEBUG_CHN, 0, "bad pport : %s\r\n", arg);
            return -1;
        }
    }
    ol_print(DEBUG_CHN, 0, "ip : %d.%d.%d.%d, port : %d\r\n", remote_ip.cVal[0], remote_ip.cVal[1], remote_ip.cVal[2], remote_ip.cVal[3], remote_port);
    return 0;
}

5、处理FTP接收数据
仅供参考，文件参数信息解析的是filezilla服务器的默认信息。文件原始数据的接收也要根据w5500设备所在的文件存储类型（文件系统或者是无系统的FLASH）自行处理。

//查找下一空格后的第一个字符
s32 search_space(char *buf, u16 max_len)
{
    char *p = buf;
    u8 falg = 0, res = 0;

    while (falg < 2)
    {
        if (*p == 0x20)
        {
            falg = 1;
        }
        else
        {
            if (falg == 1)
            {
                falg = 2;
                break;
            }
        }
        res++;
        if (res > max_len)
        {
            return 0xff;
        }
        p++;
    }
    return res;
}

//接收处理FTP文件、命令协议
void ftp_data_deal(u8 *buf, u16 len)
{
    u8 pos = 0;
    u32 file_size = 0;
    s32 ret;

    //-r--r--r-- 1 ftp ftp          89344 May 20  2021 FTP.bin
    //查询文件信息解析文件大小
    if (Command.Second == s_dir)
    {
        ol_print(DEBUG_CHN, 0, "FTP file info,%d:%s", len, buf);

        //解析过第一个空格 文件权限
        pos = search_space((char *)buf, len);
        if (pos == 0xFF)
            return;
        buf += pos;

        //解析第二个空格    文件硬连接数
        len = len - pos;
        pos = search_space((char *)buf, len);
        if (pos == 0xFF)
            return;
        buf += pos;

        //解析第三个空格    文件所有人
        len = len - pos;
        pos = search_space((char *)buf, len);
        if (pos == 0xFF)
            return;
        buf += pos;

        //解析第四个空格    文件所有组
        len = len - pos;
        pos = search_space((char *)buf, len);
        if (pos == 0xFF)
            return;
        buf += pos;

        //解析文件大小
        file_size = Str2Num((char *)buf, &pos);

        ol_print(DEBUG_CHN, 0, "FTP file size:%d\r\n", file_size);

        System_Para.Filesize = file_size;
    }
    else if (Command.Second == s_get) //下载文件
    {
        OSI_LOGI(0, "w5500 FTP page size:%d", len);

        //创建文件
        if (ftp_file_size == 0)
        {
            //打开文件
            vfs_mkdir("/fota", 0);
            ftp_fd_w = vfs_open("/fota/ftptext.pack", O_CREAT | O_RDWR | O_TRUNC);
            if (ftp_fd_w < 0)
            {
                ol_print(DEBUG_CHN, 0, "FTP file open fail\r\n");
                vfs_close(ftp_fd_w);
                ether_ftp_sta = 0xFF;
                return;
            }
        }

        //传输文件
        ret = vfs_write(ftp_fd_w, buf, len);
        if (ret <= 0)
        {
            ol_print(DEBUG_CHN, 0, "FTP file write fail,%d\r\n", ftp_file_size);
            vfs_close(ftp_fd_w);
            ether_ftp_sta = 0xFF;
            return;
        }
        else if (ret < len) //一次未传输完成
        {
            pos = len - ret;
            ret = vfs_write(ftp_fd_w, buf, pos);
            if (ret != pos)
            {
                ol_print(DEBUG_CHN, 0, "FTP file write fail,%d\r\n", ftp_file_size);
                vfs_close(ftp_fd_w);
                ether_ftp_sta = 0xFF;
                return;
            }
        }
        else
        {
            ftp_file_size += len;
        }
        OSI_LOGI(0, "w5500 FTP total size:%d", ftp_file_size);
    }
}

zhangfls
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
stm32_IAP远程升级程序_STM32+W5500+IAP
12-25
stm32_IAP远程升级程序_STM32+W5500+IAP，现在项目正在使用，基于http的get和post两种模式。
STM32使用W5500的FTP客户端功能
Running_A的博客
12-26 1953
W5500 FTP客户端测试记录
十二、W5100S/W5500+RP2040树莓派Pico＜FTP Client＞
WIZnet2012专栏
11-08 218
一般来说，使用互联网的首要目的就是实现信息共享，文件传输是信息共享非常重要的内容。我们知道互联网是一个非常复杂的计算机环境，而各种设备和操作系统之间的文件交流问题，需要建立一个统一的文件传输协议，这就是FTP协议。W5100S/W5500是一款集成全硬件 TCP/IP 协议栈的嵌入式以太网控制器，同时也是一颗工业级以太网控制芯片。本教程将介绍W5100S/W5500以太网FTP应用的基本原理、使用步骤、应用实例以及注意事项，帮助读者更好地掌握这一技术。FTP是一种用于在互联网上控制文件双向传输的协议。
32单片机+W5500实现FTP传输多个COMTRADE文件的详细设计。
最新发布
Adentlyloves的博客
12-06 498
GD32+W5500实现FTP传输多个COMTRADE文件详细设计
基于W5500的嵌入式TFTP服务器实现
WIZnet2012专栏
09-01 7146
之前一段时间专门研究了固件升级的方法，主要是通过网页或者上位机软件实现远程固件升级。最近正好在研究TFTP简单文件传输协议，于是我就尝试给设备添加联网功能，通过TFTP实现网络更新固件，而后发现这种升级方式所占设备内存小，可以穿越多数防火墙，并且不需要去设备现场，在办公室通过网络就能将成千上万用户或设备的固件升级，简单高效。
【STM32+W5500】 21，移植说明，以太网关键函数,若要连接外部广域网，必须使用DHCP连路由器(不是PC)..
CSAPP
12-18 3766
0.移植说明，w5500移植文件 Ethernet和Internet里面包含的文件就是以太网五层模型中的应用层 应用层协议：HTTP,FTP,SMTP,TFTP,Telent, MQTT    支撑协议：DNS，SNMP HTTP使用TCP而不是UDP. MQTT（Message Queuing Telemetry Transport，消息队列遥测传输）是IBM开发的一个即时通讯协议，...
STM32+w5500+FTP client例子
12-19
STM32+w5500+FTP client例子是嵌入式开发中的一个典型应用场景，它结合了STM32微控制器、W5500以太网接口芯片以及FTP客户端功能，实现了从远程FTP服务器下载文件的功能。这个例程主要用于帮助开发者理解和实践如何在...
基于W5500芯片物联网TCPIP技术祥解.rar
01-11
W5500是一款专为嵌入式系统设计的以太网控制器，它集成了硬件TCP/IP协议栈，使得在物联网设备中实现网络通信变得更加便捷。本文将深入探讨W5500芯片在物联网中的应用以及其TCP/IP技术的详细解析。 首先，W5500芯片...
ftp ota.zip
07-18
在本文中，我们将深入探讨如何使用C语言通过W5500以太网控制器实现FTP（File Transfer Protocol）在线更新（Over-The-Air，简称OTA）功能。标题“ftp ota.zip”暗示了这是一个关于利用FTP协议进行设备固件升级的项目...
基于W5500和EC20的FTP升级源码
06-08
基于STM32F207作为客户端通过W5500和EC20芯片访问FTP服务器进行IAP升级，W5500使用SPI接口操作，EC20通过串口发送AT指令
W5500参考例程,w5500数据手册,C,C++
09-10
W5500教程代码
W5100 W5200 W5500平台使用DHCP功能 51STM32等平台
11-25
对于大家 在W5100 W5500 W5200 网络部分的实现DHCP部分 本代码简单移植 稳定性很好，在“蓝云智能家居”网关得到大面积的验证 可移植大多数C语言平台 AVR 51 STM32 STM8等 平台
stm32+w5500
05-12
STM32是一款基于ARM Cortex-M内核的微控制器系列，由意法半导体（STMicroelectronics）生产。这个系列因其高性能、低功耗和广泛的外设支持而被广泛应用在嵌入式系统设计中。W5500是一款由WIZnet公司生产的以太网接口...
一文掌握w5500以太网芯片
热门推荐
Shijia Yin
11-07 2万+
文章目录序言W5500芯片简介库文件组成介绍ioLibrary Driver库文件移植过程准备接口函数接口绑定官方库源码分析wizchip_conf.c 和wizchip_conf.hw5500.c和w5500.hsocket.c和socket.h总结 序言 最近开始了W5500的编程之旅，我从商家给的例程开始学习，但是渐渐地发现，这些例程有一些缺点（功能不够完善，可移植性差，代码编写不规范，接...
STM32基于TFTP固件升级经验分享
DaveDing888的博客
01-27 2621
开发背景 最近开发的一款产品上位机与下位机之间使用LAN通讯（下位机MCU通过SPI控制网络模块W5500联网）因此固件升级也考虑通过LAN通讯的方式传输文件。 一、文件传输方案选择 1、HTTP协议 1、上位机作为客户端使用浏览器，下位机作为服务器。采用这种方式，在下位机httpserver功能完善的情况下在浏览器上可以查看配置信息，如版本号，网络参数。但是下位机httpserver开发复杂，暂用较大FLAH存储空间。 2、上位机充当服务器，下位机作为客户端模拟浏览器。采用这种方式，下位机只能请求
STM32 以太网W5500
木牛的博客
04-20 5258
W5500 是一款全硬件 TCP/IP嵌入式以太网控制器，为嵌入式系统提供了更加简易的互联网连接方案。支持硬件 TCP/IP 协议： TCP, UDP, ICMP, IPv4, ARP, IGMP, PPPoE支持8个独立端口（Socket）同时通讯支持高速串行外设接口SPI（ 80MHz 速率）内部32K字节收发缓存LED状态显示支持掉电模式、网络唤醒。
STM32+W5500实现以太网通信
铁路十六宿舍的博客
04-12 1万+
本篇文章介绍了在STM32平台利用W5500芯片实现以太网通信的原理以及嵌入式代码详解，同时对官方的例程进行了解读，帮助嵌入式工程师熟悉物联网TCP/IP技术。
基于STM32F103，利用W5500芯片实现TCP客户端连接TCP服务器的实践
qq_38334677的博客
06-28 2191
STM32F103是ST公司基于ARM Cortex-M3内核的32位闪存微控制器，具有高性能、低成本、易于使用的特点。其主要特性包括72 MHz频率，64或128 K字节的Flash，20 K字节的SRAM，以及广泛的外设接口等。
W5500实现FTP客户端
07-28
W5500是一款嵌入式以太网控制器芯片，可以用于实现FTP客户端功能。根据引用\[1\]中的描述，虽然本文主要讨论了TFTP协议的设计方案，但是类似的分析方法也可以用于实现稍微复杂一点的FTP协议。FTP协议是一种用于文件传输的协议，可以通过W5500芯片实现FTP客户端功能。 根据引用\[2\]中的描述，TFTP基于UDP协议实现，而W5500芯片支持UDP协议。因此，可以使用W5500芯片的UDP功能来实现FTP客户端的数据传输。 具体实现FTP客户端功能的步骤如下： 1. 初始化W5500芯片，包括配置网络参数和初始化UDP功能。 2. 建立与FTP服务器的连接，可以使用W5500芯片的TCP功能来建立连接。 3. 发送FTP命令，例如登录、切换目录、下载文件等。可以使用W5500芯片的UDP功能发送FTP命令。 4. 接收FTP服务器的响应，可以使用W5500芯片的UDP功能接收FTP服务器的响应。 5. 根据FTP服务器的响应进行相应的处理，例如解析文件列表、下载文件等。 6. 断开与FTP服务器的连接，释放资源。 需要注意的是，FTP协议相对复杂，实现FTP客户端功能可能需要更多的代码和处理逻辑。具体的实现细节可以参考相关的FTP协议规范和W5500芯片的开发文档。 总之，通过使用W5500芯片的UDP功能，可以实现FTP客户端功能。具体的实现步骤和细节可以根据FTP协议规范和W5500芯片的开发文档进行参考和实现。 #### 引用[.reference_title] - *1* *2* *3* [基于W5500的嵌入式TFTP服务器实现](https://blog.csdn.net/WIZnet2012/article/details/48157319)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值