mbtk/mbtk_lib/src/mbtk_fs.c

/*************************************************************
Description:
    MBTK fs c file.
Author:
    LiuBin
Date:
    2020/4/30 13:51:42
*************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <dirent.h>
#include <linux/msg.h>
#include <sys/statfs.h>
#include <sys/vfs.h>
#include <sys/param.h>
#include <sys/mount.h>
#include <math.h>
#include <errno.h>
#include <linux/magic.h>
#include <time.h>
#include <sys/time.h>
#include <signal.h>
#include <pthread.h>
#include <cutils/properties.h>
#include "mbtk_type.h"
#include "mbtk_fs.h"

/*************************************************************
    Constants and Macros
*************************************************************/


/*************************************************************
    Variables:local
*************************************************************/
int DEF_DIR_S = 0;

int msgid;

/*************************************************************
    Variables:public
*************************************************************/
//mbtk_fs
struct my_msg   //消息队列结构体
{
    long int my_msg_type;
    char *ptr;
}mbtk_at_fs_msg;

typedef struct
{
    char in_dir_file[MBTK_FS_MAX + 1];
    char out_dir_file[MBTK_FS_MAX + 1];
} mbtk_fs_file_dir_info_s;
mbtk_fs_file_dir_info_s mbtk_at_fs_par_at={0};

/*************************************************************
    Local Function Declaration
*************************************************************/
int mbtk_at_fs_msgid(int *at_msgid);
void mbtk_at_fs_printf(void *data);
static bool fs_is_space_char(char ch);
static bool fs_str_empty(char *str);
static int read_file_len(char *file);
static char *GET_PWD();
static int pwd_def_dir(char* path_dir);
static int path_pass();
static int creat_filesystem_def_dir();
void fs_ls_at_cb_func(void *file_list_cb);
void fs_ls_at_cb_func_num(void *file_list_cb);
void mbtk_at_fs_data_cb(void *data, int data_len);


/*************************************************************
    Local Function Definitions
*************************************************************/

/*
//收
void mbtk_at_fs_printf()
{
	int msgid;
	mbtk_at_msg.my_msg_type=3;
	msgid=msgget(12,0666|IPC_CREAT);
    MBTK_FUNC(mbtk_at_msgid)(&msgid);
    //char read_buf[MAXMSG];
	while(1)
	{
	    msgrcv(msgid,&mbtk_at_msg,4,mbtk_at_msg.my_msg_type,0);
       	if(strncmp(mbtk_at_msg.ptr,"end",3)==0)
		    break;
        ATRESP(IND_REQ_HANDLE , ATCI_RESULT_CODE_NULL, 0, mbtk_at_msg.ptr);
        free(mbtk_at_msg.ptr);
        mbtk_at_msg.ptr=NULL;
	}
	msgctl(msgid,IPC_RMID,0);
}
*/
//发

int mbtk_at_fs_msgid(int *at_msgid)
{
    msgid = *at_msgid;
    return 0;
}

void mbtk_at_fs_printf(void *data)
{
    char *ptr = malloc(strlen(data)+1);
    memset(ptr,0,strlen(data)+1);
    memcpy(ptr, data, strlen(data)+1);
    mbtk_at_fs_msg.ptr = ptr;
    mbtk_at_fs_msg.my_msg_type=4;
    msgsnd(msgid,&mbtk_at_fs_msg,sizeof(&mbtk_at_fs_msg),0);   //发送数据到缓冲区
}


static bool fs_is_space_char(char ch)
{
    if(ch == ' ' || ch == '\r' || ch == '\t' || ch == '\n')
        return TRUE;

    return FALSE;
}

static bool fs_str_empty(char *str)
{
    if(str == NULL || strlen(str) == 0)
        return TRUE;

    return FALSE;
}

static int read_file_len(char* file)
{
    int size;
    FILE* fp;

    fp=fopen(file,"r");
    if(NULL==fp)
    {
        fclose(fp);
    }
    else
    {
        fseek(fp,0,SEEK_END); //将文件读写指针移动到文件尾
        size=ftell(fp); //ftell函数获取从文件尾移动到文件开头的偏移量
        fseek(fp,0,SEEK_SET);//恢复指针位置
        fclose(fp);
    }
    return size;
}


//Gets the current working directory
static char *GET_PWD()
{
    char dir_buff[1024] = {0};
    char *dir = NULL;

    dir = getcwd(dir_buff,sizeof(dir_buff));

    if (dir == NULL)
    {
        LOGE(" Not current working directory errno = [%d]\n",errno);
    }
    //LOGE("getcwd dir=[%s]\n",dir);

    return dir;
}

//Default directory determinations
static int pwd_def_dir(char* path_dir)
{
    int ret = 0;
    
    if (strncmp(path_dir,DFF_DIR_NVM,3) == 0 || strncmp(path_dir,DFF_DIR_BIN,3) == 0 || strncmp(path_dir,DFF_DIR_DEV,3) == 0 || \
        strncmp(path_dir,DFF_DIR_ETC,3) == 0 || strncmp(path_dir,DFF_DIR_LIB,3) == 0 || strncmp(path_dir,DFF_DIR_LOG,3) == 0 || \
        strncmp(path_dir,DFF_DIR_MNT,3) == 0 || strncmp(path_dir,DFF_DIR_OVERLAY,3) == 0 || strncmp(path_dir,DFF_DIR_PROC,3) == 0 || \
        strncmp(path_dir,DFF_DIR_ROM,3) == 0 || strncmp(path_dir,DFF_DIR_ROOT,3) == 0 || strncmp(path_dir,DFF_DIR_SBIN,3) == 0 || \
        strncmp(path_dir,DFF_DIR_SYS,3) == 0 || strncmp(path_dir,DFF_DIR_TMP,3) == 0 || strncmp(path_dir,DFF_DIR_USR,3) == 0 || \
        strncmp(path_dir,DFF_DIR_VAR,3) == 0 || strncmp(path_dir,DFF_DIR_WWW,3) == 0 )
        {
            ret = -1;
            LOGE("Enter the default directory \n");
        }

    return ret;
}

//
static int path_pass()
{
    int at_fs_ret = 0;
    char *fs_pwd_path = NULL;
    char tmp_path[FS_NAME_LEN] = {0};

    fs_pwd_path = GET_PWD();//获取当前路径

    strcpy(tmp_path, fs_pwd_path);

    if ((at_fs_ret = pwd_def_dir(tmp_path)) == -1)
        return at_fs_ret;

    if (strncmp(tmp_path, PART_FS, 3) != 0)
    {
        if (strcmp(tmp_path, ROOT_PATH) == 0)//首次进入,所以不用指定前一个字符匹配，全部匹配
        {
            at_fs_ret = chdir(PART_FS);//首次进入切换路径
            LOGE(">dir == [%s]\n", getcwd(NULL,NULL));
            if(-1 == at_fs_ret)
            {
                LOGE("chdir path error:[%d]\n", errno);
                return at_fs_ret;
            }
        }
        else
        {
            at_fs_ret = -1;
            LOGE("Not specified dir %s\n", tmp_path);
            return at_fs_ret;
        }
    }

    return at_fs_ret;

}


//创建文件系统的默认操作路径
static int creat_filesystem_def_dir()
{
    int ret = 0;

    if (DEF_DIR_S == 0)//以全局变量判断是否创建了默认路径
    {
        if (access(PART_FS, F_OK) == 0)
        {
            DEF_DIR_S = 1;
        }
        else
        {
            ret = mkdir(PART_FS, 0766);//创建路径
            if(-1 == ret)
            {
                LOGE("mkdir path error:[%d]\n", errno);
                return ret;
            }
            ret = chdir(PART_FS);//切换路径
            LOGE(">dir == [%s]\n", getcwd(NULL,NULL));
            if(-1 == ret)
            {
                LOGE("chdir path error:[%d]\n", errno);
                return ret;
            }
            DEF_DIR_S = 1;
        }
    }
    else if (DEF_DIR_S == 1)
    {
        ;//不进行处理
    }
    else
    {
        LOGE("mkdir path  DEF_DIR_S error:[%d]\n", errno);
    }

    return ret;
}

//拼接传入的路径到默认操作路径
static int path_redirection(char *in_path, char *out_path)
{
    int ret = 0, len = 0;
    char *tmp_dir = NULL;
    char def_fs[FS_NAME_LEN] = {0};

    len = strlen(in_path);
    if ( len + 5 >= 127 )
    {
        LOGE("in_path len more than error:[%d]\n", errno);
        ret = -1;
        return ret;
    }

    strcpy(def_fs, PART_FS);

    tmp_dir = strncat(def_fs, in_path, sizeof(def_fs)-1);//先拼接再判断

    if (strncmp(PART_FS_, tmp_dir, 4) == 0)
    {
        memcpy(out_path, tmp_dir, MBTK_FS_MAX);
    }
    else
    {
        ret = -1;
        return ret;
    }

    memset(def_fs, 0x00, sizeof(def_fs));

    return ret;
}

void fs_ls_at_cb_func(void *file_list_cb)
{
    char resp_buf[1024 + 1] = {0};
    printf("+MFSLS::\r\n%s\n", ((mbtk_fs_dir_file_info_s *)file_list_cb)->name);
    sprintf(resp_buf, "%s\n",((mbtk_fs_dir_file_info_s *)file_list_cb)->name);
    mbtk_at_fs_printf(resp_buf);
    //ret = ATRESP(30163, 0, 0, resp_buf);
}

void fs_ls_at_cb_func_num(void *file_list_cb)
{
    //不进行处理，只走流程
}

void mbtk_at_fs_data_cb(void *data, int data_len)
{
    char resp_buf[1024];
    printf("\n=====data_cb data[%s]=====\n=====data_cb data_len[%d]=====\n",data, data_len);

    memset(resp_buf,0,1024);
    mbtk_at_fs_printf(resp_buf);

    if(data_len > 512)
    {
        memset(resp_buf,0,1024);
        memcpy(resp_buf,data,512);
        mbtk_at_fs_printf(resp_buf);
        memset(resp_buf,0,1024);
        sprintf(resp_buf, "DATA: <%d>", 512);
        mbtk_at_fs_printf(resp_buf);

        memset(resp_buf,0,1024);
        sprintf(resp_buf, "+MFSREAD:");
        mbtk_at_fs_printf(resp_buf);
        memset(resp_buf,0,1024);
        memcpy(resp_buf,data+512,data_len-512);
        mbtk_at_fs_printf(resp_buf);
        memset(resp_buf,0,1024);
        sprintf(resp_buf, "DATA: <%d>", data_len-512);
        mbtk_at_fs_printf(resp_buf);
    }
    else
    {
        memset(resp_buf,0,1024);
        memcpy(resp_buf,data,data_len);
        mbtk_at_fs_printf(resp_buf);
        
        memset(resp_buf,0,1024);
        sprintf(resp_buf, "<%d>", data_len);
        mbtk_at_fs_printf(resp_buf);
    }

}


//Creating a directory
static int fs_cmd_process_mkd(char *path)
{
    int ret = 0;
    char Filepath[MBTK_FS_MAX + 1];
    char Pathtmp[MBTK_FS_MAX + 1];
    char *pDir = NULL;
    struct stat FileStat_t;

    memset(Filepath, 0x00, sizeof(Filepath));
    memset(Pathtmp, 0x00, sizeof(Pathtmp));
    memset(&FileStat_t, 0x00, sizeof(FileStat_t));

    memcpy(Filepath, path, sizeof(Filepath));

    if ((ret = path_redirection(Filepath, Pathtmp)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        return ret;
    }

//后期再看那个合适
#if 0
    pDir = strtok(Filepath, "/");
    strcat(Pathtmp, "/");
    strcat(Pathtmp, pDir);
    strcat(Pathtmp, "/");

    memset(&FileStat_t, 0x00, sizeof(FileStat_t));
    stat(Pathtmp, &FileStat_t);

    if(!S_ISDIR(FileStat_t.st_mode))
    {
        ret = mkdir(Pathtmp, 0766);//创建路径
        if(-1 == ret)
        {
            LOGE("mkdir path [%s] error:[%d]\n", __FUNCTION__, errno);
            return ret;
        }
    }

    while(NULL != ( pDir=strtok(NULL, "/") ))
    {
        strcat(Pathtmp, pDir);
        strcat(Pathtmp, "/");

        memset(&FileStat_t, 0x00, sizeof(FileStat_t));
        stat(Pathtmp, &FileStat_t);

        if(!S_ISDIR(FileStat_t.st_mode))
        {
            ret = mkdir(Pathtmp, 0766);//创建文件
            if(-1 == ret)
            {
                LOGE("mkdir path [%s] error:[%d]\n", __FUNCTION__, errno);
                return ret;
            }
        }
    }
#else
    stat(Pathtmp, &FileStat_t);

    if(!S_ISDIR(FileStat_t.st_mode))
    {
        ret = mkdir(Pathtmp, 0766);//创建路径
        if(-1 == ret)
        {
            LOGE("mkdir path error:[%d]\n", errno);
            return ret;
        }
    }
    else
    {
        ret = -1;
        LOGE("not a directory error:[%d]\n", errno);
        return ret;
    }

#endif

    return ret;
}

static int fs_cmd_process_rmkd(char *path)
{
    int ret = 0;
    char Filepath[MBTK_FS_MAX + 1]={0};
    char Pathtmp[MBTK_FS_MAX + 1]={0};

    memcpy(Filepath, path, sizeof(Filepath));

    if ((ret = path_redirection(Filepath, Pathtmp)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        return ret;
    }

     if (access(Pathtmp, F_OK) != 0)
     {
        ret = -1;
        LOGE("File does not exist error:[%d]\n", errno);
        return ret;
     }

    //ret = rmdir(Filepath);
    ret = rmdir(Pathtmp);
    if (ret == -1)
    {
        LOGE("rmkdir path error:[%d]\n", errno);
    }

    return ret;
}

static int fs_cmd_process_list_dir(char *path,mbtk_fs_dir_file_info_s *fs_dir_list)
{
    int ret = 0, count = 0, dir_count = 0, file_count = 0, len_name;
    const char *temp_fs_path = NULL; 
    struct dirent *files;
    struct stat FileStat_t;
    DIR *dir;
    mbtk_fs_dir_file_info_s fs_dir_file_t, fs_dir_t, fs_file_t;
    char Filepath[MBTK_FS_MAX + 1];

    memset(fs_dir_list, 0x0, sizeof(mbtk_fs_dir_file_info_s)-sizeof(void *));

    temp_fs_path = path;

    chdir(temp_fs_path);

    dir = opendir(temp_fs_path);

    if (dir == NULL)
    {
        ret = -1;
        LOGE("Directory cannot be opened!\n");
        return ret;
    }
    while ((files = readdir(dir)) != NULL)
    {
        if(strcmp(files->d_name, ".") == 0 || strcmp(files->d_name, "..") == 0)
        {
            continue;
        }//跳过隐藏文件

        memset(&FileStat_t, 0x00, sizeof(FileStat_t));
        memset(&fs_dir_file_t, 0x0, sizeof(mbtk_fs_dir_file_info_s));
        memset(&fs_file_t, 0x0, sizeof(mbtk_fs_dir_file_info_s));
        memset(&fs_dir_t, 0x0, sizeof(mbtk_fs_dir_file_info_s));

        len_name = strlen(files->d_name);
        //目录或者文件夹名字长度不能超过256，可以的话这里也可以做出错处理;
        stat(files->d_name,&FileStat_t);

        if(S_ISDIR(FileStat_t.st_mode)) //递归调用解析其子目录下的文件夹
        {
            memcpy(fs_dir_t.name, files->d_name, sizeof(len_name));
            dir_count++;
        }
        else
        {
            memcpy(fs_file_t.name, files->d_name, sizeof(len_name));
            file_count++;
        }

        memcpy(fs_dir_file_t.name, files->d_name, sizeof(len_name));
        count++;

        //每次对一个文件或者目录处理，就加入里面
        (fs_dir_list->fs_ls_cb_typedef)(&fs_dir_t);
    }
    closedir(dir);

    //每次显示完成后，把读取的数量传给全局变量方便读取
    //mbtk_at_fs_par.all_dir_file = count;
    mbtk_at_fs_par.dir_num = dir_count;
    //mbtk_at_fs_par.file_num = file_count;

    return ret;
}

static int fs_cmd_process_list_file(char *path,mbtk_fs_dir_file_info_s *fs_file_list)
{
    int ret = 0, count = 0, dir_count = 0, file_count = 0, len_name;
    const char *temp_fs_path = NULL; 
    struct dirent *files;
    struct stat FileStat_t;
    DIR *dir;
    mbtk_fs_dir_file_info_s fs_dir_file_t, fs_dir_t, fs_file_t;
    char Filepath[MBTK_FS_MAX + 1];

    memset(fs_file_list, 0x0, sizeof(mbtk_fs_dir_file_info_s)-sizeof(void *));

    temp_fs_path = path;

    chdir(temp_fs_path);

    dir = opendir(temp_fs_path);

    if (dir == NULL)
    {
        ret = -1;
        LOGE("Directory cannot be opened!\n");
        return ret;
    }
    while ((files = readdir(dir)) != NULL)
    {
        if(strcmp(files->d_name, ".") == 0 || strcmp(files->d_name, "..") == 0)
        {
            continue;
        }//跳过隐藏文件

        memset(&FileStat_t, 0x00, sizeof(FileStat_t));
        memset(&fs_dir_file_t, 0x0, sizeof(mbtk_fs_dir_file_info_s));
        memset(&fs_file_t, 0x0, sizeof(mbtk_fs_dir_file_info_s));
        memset(&fs_dir_t, 0x0, sizeof(mbtk_fs_dir_file_info_s));

        len_name = strlen(files->d_name);
        //目录或者文件夹名字长度不能超过256，可以的话这里也可以做出错处理;
        stat(files->d_name,&FileStat_t);

        if(S_ISDIR(FileStat_t.st_mode)) //递归调用解析其子目录下的文件夹
        {
            memcpy(fs_dir_t.name, files->d_name, (len_name)+1);
            dir_count++;
        }
        else
        {
            memcpy(fs_file_t.name, files->d_name, (len_name)+1);
            file_count++;
        }

        memcpy(fs_dir_file_t.name, files->d_name, (len_name)+1);
        count++;

        //每次对一个文件或者目录处理，就加入里面
        (fs_file_list->fs_ls_cb_typedef)(&fs_file_t);
    }

    //每次显示完成后，把读取的数量传给全局变量方便读取
    //mbtk_at_fs_par.all_dir_file = count;
    //mbtk_at_fs_par.dir_num = dir_count;
    mbtk_at_fs_par.file_num = file_count;

    closedir(dir);

    return ret;
}

static int fs_cmd_process_list_all(char *path,mbtk_fs_dir_file_info_s *fs_dir_and_file_list)
{
    int ret = 0, count = 0, dir_count = 0, file_count = 0, len_name;
    const char *temp_fs_path = NULL; 
    struct dirent *files;
    struct stat FileStat_t;
    DIR *dir;
    mbtk_fs_dir_file_info_s fs_dir_file_t, fs_dir_t, fs_file_t;
    char Filepath[MBTK_FS_MAX + 1];

    memset(fs_dir_and_file_list, 0x0, sizeof(mbtk_fs_dir_file_info_s)-sizeof(void *));

    temp_fs_path = path;

    chdir(temp_fs_path);

    dir = opendir(temp_fs_path);

    if (dir == NULL)
    {
        ret = -1;
        LOGE("Directory cannot be opened!\n");
        return ret;
    }
    while ((files = readdir(dir)) != NULL)
    {
        if(strcmp(files->d_name, ".") == 0 || strcmp(files->d_name, "..") == 0)
        {
            continue;
        }//跳过隐藏文件

        memset(&FileStat_t, 0x00, sizeof(FileStat_t));
        memset(&fs_dir_file_t, 0x0, sizeof(mbtk_fs_dir_file_info_s));
        memset(&fs_file_t, 0x0, sizeof(mbtk_fs_dir_file_info_s));
        memset(&fs_dir_t, 0x0, sizeof(mbtk_fs_dir_file_info_s));

        len_name = strlen(files->d_name);
        //目录或者文件夹名字长度不能超过256，可以的话这里也可以做出错处理;
        stat(files->d_name,&FileStat_t);

        if(S_ISDIR(FileStat_t.st_mode)) //递归调用解析其子目录下的文件夹
        {
            memcpy(fs_dir_t.name, files->d_name, (len_name)+1);
            //LOGE("DIR>>>>>>>>>>>>>> [%s]\n", fs_dir_t.name);
            dir_count++;
        }
        else
        {
            memcpy(fs_file_t.name, files->d_name, (len_name)+1);
            //LOGE("FILE>>>>>>>>>>>>>> [%s]\n", fs_file_t.name);
            file_count++;
        }

        memcpy(fs_dir_file_t.name, files->d_name, (len_name)+1);
        //LOGE("ALL>>>>>>>>>>>>>> [%s]\n", fs_dir_file_t.name);
        count++;

        //每次对一个文件或者目录处理，就加入里面
        (fs_dir_and_file_list->fs_ls_cb_typedef)(&fs_dir_file_t);
    }

    //每次显示完成后，把读取的数量传给全局变量方便读取
    mbtk_at_fs_par.all_dir_file = count;
    mbtk_at_fs_par.dir_num = dir_count;
    mbtk_at_fs_par.file_num = file_count;

    closedir(dir);

    return ret;
}

static int fs_cmd_process_cd(char *path)
{
    int ret = 0;
    char buf[1024];
    char Filepath[MBTK_FS_MAX + 1];
    char Pathtmp[MBTK_FS_MAX + 1];

    memset(buf, 0x00, sizeof(buf));
    memset(Filepath , 0x00, sizeof(Filepath));
    memset(Pathtmp , 0x00, sizeof(Pathtmp));

    memcpy(Filepath, path, sizeof(Filepath));

    if ((ret = path_redirection(Filepath, Pathtmp)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        return ret;
    }

    ret = chdir(Pathtmp);

//    ret = chdir(path);

    if (ret == -1)
    {
        LOGE("cd path error:[%d]\n", errno);
    }

    char *ptr = getcwd(buf, sizeof(buf));
    if (ptr == NULL)
        LOGE("cd path error:[%d]\n", errno);

    return ret;
}

static int fs_cmd_process_rename(char *old_path, char *new_path)
{
    int ret = 0;
    char tmp_old[MBTK_FS_MAX + 1];
    char tmp_new[MBTK_FS_MAX + 1];

    memset(tmp_old , 0x00, sizeof(tmp_old));
    memset(tmp_new , 0x00, sizeof(tmp_new));

    if ((ret = path_redirection(old_path, tmp_old)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        return ret;
    }

    if ((ret = path_redirection(new_path, tmp_new)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        return ret;
    }

    ret = rename(tmp_old, tmp_new);
//    ret = rename(old_path, new_path);

    if (ret == -1)
    {
        LOGE("rename error:[%d]\n", errno);
    }

    return ret;
}

static int fs_cmd_process_copy(char *old_path, char *new_path, int mode)
{
    int ret = 0, num = 0;
    int old_fd,new_fd;
    char *tbuf = NULL;
    int tmode = mode;//没有做处理，默认以同步方式
    char tmp_old[MBTK_FS_MAX + 1];
    char tmp_new[MBTK_FS_MAX + 1];

    memset(tmp_old , 0x00, sizeof(tmp_old));
    memset(tmp_new , 0x00, sizeof(tmp_new));

    if ((ret = path_redirection(old_path, tmp_old)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        return ret;
    }

    if ((ret = path_redirection(new_path, tmp_new)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        return ret;
    }

    if (access(tmp_old, F_OK) != 0) //旧文件必须存在
    {
        ret = -1;
        LOGE("old_file  access  errn = [%d]\n",errno);
        goto exit;
    }

    if (access(tmp_new, F_OK) == 0) //新文件存在，则错误
    {
        ret = -1;
        LOGE("new_file  access  errn = [%d]\n",errno);
        goto exit;
    }

    if ( (old_fd=file_open(tmp_old, O_RDWR)) == -1 )
    {
        LOGE("open old_path error:[%d]\n", errno);
        ret = -1;
        goto exit;
    }

    if ( (new_fd=file_open(tmp_new, O_RDWR | O_CREAT)) == -1 )
    {
        LOGE("open new_path error:[%d]\n", errno);
        ret = -1;
        goto exit;
    }

    int len = lseek(old_fd,0,SEEK_END);//获取长度

    if (len == -1)//获取文件大小时出错
    {
        LOGE("lseek error:[%d]\n", errno);
        ret = -1;
        goto exit;
    }

    lseek(old_fd,0,SEEK_SET);//还原指针指到开头处

    tbuf = malloc(len + 1);

    if (len+1 > BUFFERSIZE)
        LOGE("Out of length\n");

    num = file_read(old_fd, tbuf, len);

    if (file_write(new_fd, tbuf, len) !=  num)
    {
        LOGE("The write does not match the read out\n");
        ret = -1;
        goto exit;
    }

    fsync(old_fd);
    fsync(new_fd);

exit:
    file_close(old_fd);
    file_close(new_fd);
    free(tbuf);
    return ret;
}

static int fs_cmd_process_memory(uint64 *total, uint64 *available)
{
    int ret = 0;
    struct statfs buf;
    uint64 blocksize, totalsize, availablesize, freesize;

    ret = statfs(PART_FS_OERLAY, &buf);
    if (ret == -1)
    {
        LOGE("statfs error:[%d]\n", errno);
    }
    else
    {
        blocksize = buf.f_bsize;                   // 每个block里包含的字节数
        totalsize = blocksize * buf.f_blocks;      // 总的字节数，f_blocks为block的数目
        //freesize = buf.f_bfree * blocksize;      // 剩余空间的大小
        availablesize = buf.f_bavail * blocksize;  // 可用空间大小

        *total = totalsize;
        *available = availablesize;
    }

    return ret;
}

static int fs_cmd_process_delfile(char *path)
{
    int ret = 0;
    char tmp[MBTK_FS_MAX + 1];

    memset(tmp , 0x00, sizeof(tmp));

    if ((ret = path_redirection(path, tmp)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        return ret;
    }

    ret = remove(tmp);
//    ret = remove(path);

    if (ret == -1)
    {
        LOGE("rm file error:[%d]\n", errno);
    }

    return ret;
}

static int fs_cmd_process_creatfile(char *path)
{
    int ret = 0 ,fd;
    char tmp[MBTK_FS_MAX + 1];

    memset(tmp , 0x00, sizeof(tmp));

    if ((ret = path_redirection(path, tmp)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        return ret;
    }

    fd = file_open(tmp, O_RDWR | O_CREAT | O_TRUNC);
    if (fd == -1)
    {
        ret = -1;
        LOGE("creat file error:[%d]\n", errno);
    }

    file_close(fd);

    return ret;
}

int mbtk_at_fs_dir(int cmd, char *fs_path)
{
    int at_fs_ret = 0;
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    switch (cmd)
    {
        case 0:
        {
            at_fs_ret = fs_cmd_process_mkd(fs_path);
            break;
        }
        case 1:
        {
            at_fs_ret = fs_cmd_process_rmkd(fs_path);
            break;
        }
        default:
        {
            LOGE("ERROR cmd \n");
            at_fs_ret = -1;
            break;
        }
    }

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_list_num_get(int32* dir_num, int32* file_num)
{
    int at_fs_ret = 0;
    mbtk_fs_dir_file_info_s fs_dir_file;
    char tmp_path[FS_NAME_LEN] = {0};
    char *fs_pwd_path = NULL;
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    fs_pwd_path = GET_PWD();//获取当前路径

    strcpy(tmp_path, fs_pwd_path);

    if (at_fs_ret == 0)
    {
        fs_dir_file.fs_ls_cb_typedef = fs_ls_at_cb_func_num;
        at_fs_ret = fs_cmd_process_list_all(tmp_path, &fs_dir_file);

        *file_num =  mbtk_at_fs_par.file_num;
        *dir_num =  mbtk_at_fs_par.dir_num;
    }
    else
    {
        at_fs_ret = -1;
        LOGE("OPEN this dir errno [%s]\n", tmp_path);
        goto exit;
    }

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_list_dir_file_get()
{
    int at_fs_ret = 0;
    char send_buf[SENDBUFF] = {0};
    char *fs_pwd_path = NULL;
    mbtk_fs_dir_file_info_s  fs_dir, fs_file;
    char tmp_path[FS_NAME_LEN] = {0};

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    fs_pwd_path = GET_PWD();//获取当前路径

    strcpy(tmp_path, fs_pwd_path);

    if ((at_fs_ret = pwd_def_dir(tmp_path)) == -1)
        goto exit;

    memset(send_buf, 0x00, sizeof(send_buf));

    mbtk_at_fs_printf("+MFSLS: SUBDIRECTORIES:");
    fs_dir.fs_ls_cb_typedef = fs_ls_at_cb_func;
    at_fs_ret = fs_cmd_process_list_dir(tmp_path,&fs_dir);

    mbtk_at_fs_printf("+MFSLS: FILES:");
    fs_file.fs_ls_cb_typedef = fs_ls_at_cb_func;
    at_fs_ret = fs_cmd_process_list_file(tmp_path,&fs_file);

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    memset(send_buf, 0x00, sizeof(send_buf));
    return at_fs_ret;
}

int mbtk_at_fs_list_set(int type)
{
    int at_fs_ret = 0;
    char send_buf[SENDBUFF] = {0};
    char *fs_pwd_path = NULL;
    mbtk_fs_dir_file_info_s fs_dir_file, fs_dir, fs_file;
    char tmp_path[FS_NAME_LEN] = {0};

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    fs_pwd_path = GET_PWD();//获取当前路径

    strcpy(tmp_path, fs_pwd_path);

    if ((at_fs_ret = pwd_def_dir(tmp_path)) == -1)
        goto exit;

    if (tmp_path != NULL)
    {
        LOGE("OPEN this dir [%s]\n", tmp_path);
    }
    else
    {
        at_fs_ret = -1;
        LOGE("OPEN this dir errno [%s]\n", tmp_path);
        goto exit;
    }
    memset(send_buf, 0x00, sizeof(send_buf));
    mbtk_at_fs_par.at_fs_type = type;

    switch (mbtk_at_fs_par.at_fs_type)
    {
        case 0://显示目录和文件名称
        {
            mbtk_at_fs_printf("+MFSLS:\n");
            fs_dir_file.fs_ls_cb_typedef = fs_ls_at_cb_func;
            at_fs_ret = fs_cmd_process_list_all(tmp_path, &fs_dir_file);

            if(at_fs_ret != 0)
            {
                printf("+MFSLS: FAIL,<%d>\n",at_fs_ret);
                sprintf(send_buf,"+MFSLS: FAIL,<%d>\n",at_fs_ret);
            }
            else
            {
                printf("+MFSLS:SUBDIRECTORIES: %d FILES: %d \r\n", mbtk_at_fs_par.dir_num, mbtk_at_fs_par.file_num);
                sprintf(send_buf,"+MFSLS: SUBDIRECTORIES: %d FILES: %d \n", mbtk_at_fs_par.dir_num, mbtk_at_fs_par.file_num);
            }
            break;
        }
        case 1://显示目录名称
        {
            mbtk_at_fs_printf("+MFSLS:");
            fs_dir.fs_ls_cb_typedef = fs_ls_at_cb_func;
            at_fs_ret = fs_cmd_process_list_dir(tmp_path,&fs_dir);

            if(at_fs_ret != 0)
            {
                printf("+MFSLS: FAIL,<%d>\n",at_fs_ret);
                sprintf(send_buf,"+MFSRMDIR: FAIL,<%d>\n",at_fs_ret);
            }
            else
            {
                printf("+MFSLS:SUBDIRECTORIES: %d \r\n", mbtk_at_fs_par.dir_num);
                sprintf(send_buf,"+MFSLS: SUBDIRECTORIES: %d \n", mbtk_at_fs_par.dir_num);
            }
            break;
        }
        case 2://显示文件名称
        {
            mbtk_at_fs_printf("+MFSLS:");
            fs_file.fs_ls_cb_typedef = fs_ls_at_cb_func;
            at_fs_ret = fs_cmd_process_list_file(tmp_path,&fs_file);

            if(at_fs_ret != 0)
            {
                printf("+MFSLS: FAIL,<%d>\n",at_fs_ret);
                sprintf(send_buf,"+MFSRMDIR: FAIL,<%d>\n",at_fs_ret);
            }
            else
            {
                printf("+MFSLS:FILES: %d \r\n",mbtk_at_fs_par.file_num);
                sprintf(send_buf,"+MFSLS: FILES: %d \n",mbtk_at_fs_par.file_num);
            }
            break;
        }
        default:
        {
            LOGE("ERROR mbtk_at_fs_par.at_fs_type \n");
            at_fs_ret = -1;
            break;
        }
    }

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    memset(send_buf, 0x00, sizeof(send_buf));
    return at_fs_ret;
}

int mbtk_at_fs_cd(char *fs_dir)
{
    int at_fs_ret = 0;
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    at_fs_ret = fs_cmd_process_cd(fs_dir);

    if(at_fs_ret == 0)
    {
        sprintf(send_buf,"+MFSCD: %s\r\n",fs_dir);
    }

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_delfile(char *fs_dir_file)
{
    int at_fs_ret = 0;
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    at_fs_ret = fs_cmd_process_delfile(fs_dir_file);

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_attri(char *fs_file)
{
    int at_fs_ret = 0, len_size;
    char Filepath[MBTK_FS_MAX + 1]={0};
    char Pathtmp[MBTK_FS_MAX + 1]={0};
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    memcpy(Filepath, fs_file, sizeof(Filepath));

    if ((at_fs_ret = path_redirection(Filepath, Pathtmp)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        goto exit;
    }

    if (0 != (access(Pathtmp, F_OK)))
    {
        LOGE("access file is null\n");
        at_fs_ret = -1;
        goto exit;
    }

    len_size = read_file_len(Pathtmp);

    if(at_fs_ret != 0)
    {
        printf("+MFSATTRI : FAIL,<%d>\n",at_fs_ret);
        sprintf(send_buf,"+MFSATTRI : FAIL,<%d>\n",at_fs_ret);
        goto exit;
    }
    else
    {
        printf("+MFSATTRI: <%d>\n",len_size);
        sprintf(send_buf,"+MFSATTRI: %d\n",len_size);
        goto exit;
    }

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_writefile(mbtk_fs_data_info_t *fs_w_data)
{
    int at_fs_ret = 0, len_size, fd, write_mode, write_size;
    char get_buf[FS_DATA_LEN];
    char Filepath[MBTK_FS_MAX + 1]={0};
    char Pathtmp[MBTK_FS_MAX + 1]={0};
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    memset(get_buf, 0x00, sizeof(get_buf));

    write_size = fs_w_data->fs_data_size;
    memcpy(get_buf, fs_w_data->fs_data, write_size);
    memcpy(Filepath, fs_w_data->fs_data_name, strlen(fs_w_data->fs_data_name));
    write_mode = fs_w_data->fs_data_mode;

    if ((at_fs_ret = path_redirection(Filepath, Pathtmp)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        goto exit;
    }

    if (0 != (access(Pathtmp, F_OK)))
    {
        LOGE("access file is null\n");
        at_fs_ret = -1;
        goto exit;
    }

    fd=file_open(Pathtmp,O_WRONLY);
    if(-1 == fd)
    {
        LOGE("Write file error\n");
        at_fs_ret = -1;
        file_close(fd);
        goto exit;
    }
    else
    {
        LOGE("Open file SUCCESS\r\n");

        if (write_mode == 0)
        { //将文件读写指针移动到文件头
            lseek(fd,0,SEEK_SET);
        }
        else if (write_mode == 1)
        { //将文件读写指针移动到文件尾
            lseek(fd,0,SEEK_END);
        }
        else
        {
            LOGE("write_mode error\n");
            at_fs_ret = -1;
            file_close(fd);
            goto exit;
        }
        //这两步可以加出错处理
        file_write(fd, get_buf, write_size);
        fsync(fd);
        file_close(fd);
    }

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

//int mbtk_at_fs_readfile(void *dir_file, int read_offset, int read_size, char* read_buff)
int mbtk_at_fs_readfile(void *dir_file, int read_offset, int read_size)
{
    int at_fs_ret = 0, fd, count = 0,file_size, len_count = 0, len = 0;
    char read_buf[1024];
    char Filepath[MBTK_FS_MAX + 1]={0};
    char Pathtmp[MBTK_FS_MAX + 1]={0};
    char send_buf[1024] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    memset(read_buf, 0x00, sizeof(read_buf));

    memcpy(Filepath, dir_file, sizeof(Filepath));

    if ((at_fs_ret = path_redirection(Filepath, Pathtmp)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        goto exit;
    }

    if (0 != (access(Pathtmp, F_OK)))
    {
        LOGE("access file is null\n");
        at_fs_ret = -1;
        goto exit;
    }

    file_size = read_file_len(Pathtmp);


    fd = file_open(Pathtmp, O_RDONLY);
    if (fd == -1)
    {
        LOGE("Read file error\n");
        at_fs_ret = -1;
        goto exit;
    }
    else
    {
        LOGE("Open file SUCCESS\r\n");
        if (read_offset >= file_size)
        {
            LOGE("read_offset > file_size \n");
            at_fs_ret = -1;
            goto exit;
        }

        lseek(fd,read_offset,SEEK_SET);

        //由于at客户端缓存才1k,切片512字节大小传输
        if (read_size > 0)
        {
           if (0 < read_size  &&  read_size <= 512) //单次发生：文件大小-偏移量 < 发送大小
           {
                len = read(fd, read_buf, read_size); //返回实际读取的大小
                LOGE("len = [%d]\n",len);
                if (len > 0)
                {
                    //LOGE("read_buff = [%s]\n",read_buf);
                    sprintf(send_buf,"+MFSREAD: DATA: %d, %s\n",len, read_buf);
                }
           }
           else if(read_size <= 1024 && read_size > 512) //多次发送：
           {
                len = read(fd, read_buf, read_size);
                count++;
                LOGE("count = [%d]\n",count);
                mbtk_at_fs_data_cb(read_buf, len);
                sprintf(send_buf, "+MFSREAD: DATA: [%d] count: [%d]\r\n",len,count);
                mbtk_at_fs_printf(send_buf);
                memset(send_buf, 0x00, sizeof(send_buf));
           }
           else
           {
                LOGE("read_size errno\n");
           }
        }
        else if (read_size == 0)//全部读取完成
        {
            if ((file_size-read_offset) < 512)
            {
                len = read(fd, read_buf, 1024); //返回实际读取的大小
                LOGE("len = [%d]\n",len);
                if (len > 0)
                {
                     //LOGE("read_buff = [%s]\n",read_buf);
                     sprintf(send_buf,"+MFSREAD: DATA: %d, %s\n",len, read_buf);
                }
            }
            else
            {
                while((file_size-read_offset) > len_count)
                {
                    len = read(fd, read_buf, 1024);
                    count++;
                    LOGE("count = [%d]\n",count);
                    mbtk_at_fs_data_cb(read_buf, len);
                    len_count += len;
                    sprintf(send_buf, "+MFSREAD: DATA: [%d] count: [%d]\r\n",len_count, count);
                    mbtk_at_fs_printf(send_buf);
                    memset(send_buf, 0x00, sizeof(send_buf));
                }
            }
        }
        else
        {
            LOGE("read_size errno =[%d]\n",errno);
        }

        file_close(fd);
    }

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_rename(char *old_file, char *new_file)
{
    int at_fs_ret = 0;
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    if (old_file == NULL || new_file == NULL)
    {
        at_fs_ret = -1;
        LOGE("old_file or new_file is null\n");
        goto exit;
    }

    at_fs_ret = fs_cmd_process_rename(old_file, new_file);

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_creatfile(char *fs_file)
{
    int at_fs_ret = 0;
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    at_fs_ret = fs_cmd_process_creatfile(fs_file);

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_memory(uint64 *total_len,uint64 *available_len)
{
    int at_fs_ret = 0;
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    at_fs_ret = fs_cmd_process_memory(total_len, available_len);

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_copy(char *old_file, char *new_file, int mode)
{
    int at_fs_ret = 0;
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    if (old_file == NULL || new_file == NULL)
    {
        at_fs_ret = -1;
        LOGE("old_file or new_file is null\n");
        goto exit;
    }

    at_fs_ret = fs_cmd_process_copy(old_file, new_file, mode);

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_certload(mbtk_fs_data_certmode_t *certmode)
{
    int at_fs_ret = 0, fd, cert_mode, write_size;
    char tmp_buf[FS_NAME_LEN];
    char get_buf[FS_DATA_LEN];
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    memset(get_buf, 0x00, sizeof(get_buf));
    memset(tmp_buf, 0x00, sizeof(tmp_buf));

    write_size = certmode->fs_data_size;
    memcpy(get_buf, certmode->fs_data, write_size);
    cert_mode = certmode->fs_data_certmode;

    switch(cert_mode)
    {
        case 0:
        {
            memcpy(tmp_buf, FS_CERT_0, sizeof(tmp_buf));
            break;
        }
        case 1:
        {
            memcpy(tmp_buf, FS_CERT_1, sizeof(tmp_buf));
            break;
        }
        case 2:
        {
            memcpy(tmp_buf, FS_CERT_2, sizeof(tmp_buf));
            break;
        }
        case 3:
        {
            memcpy(tmp_buf, FS_CERT_3, sizeof(tmp_buf));
            break;
        }
        case 4:
        {
            memcpy(tmp_buf, FS_CERT_4, sizeof(tmp_buf));
            break;
        }
        default:
        {
            LOGE("ERROR cert_mode \n");
            at_fs_ret = -1;
            break;
        }
    }

    if (at_fs_ret == -1)
        goto exit;

    if (fd = file_open(tmp_buf,  O_RDWR | O_CREAT | O_TRUNC) == -1)
    {
        LOGE("Open file is err  [%d]\n",errno);
        at_fs_ret = -1;
        goto exit;
    }
    else
    {
        //通过at客户端往里面写数据
        LOGE("Open file SUCCESS\r\n");
        if (lseek(fd,0,SEEK_SET) == -1 )
        {
            LOGE("lseek error = [%d]\n",errno);
            at_fs_ret = -1;
            file_close(fd);
            goto exit;
        }
        //这两步可以加出错处理
        file_write(fd, get_buf, write_size);
        fsync(fd);
        file_close(fd);
    }

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}

int mbtk_at_fs_fileload(mbtk_fs_data_file_t *file)
{
    int at_fs_ret = 0, fd, write_size;
    char get_buf[FS_DATA_LEN];
    char Filepath[MBTK_FS_MAX + 1]={0};
    char Pathtmp[MBTK_FS_MAX + 1]={0};
    char send_buf[SENDBUFF] = {0};
    memset(send_buf, 0x00, sizeof(send_buf));

    if ((at_fs_ret = creat_filesystem_def_dir()) == -1)
    {
        LOGE("creat_filesystem_def_dir error:[%d]\n", errno);
        return at_fs_ret;
    }

    if ((at_fs_ret = path_pass()) == -1)
        goto exit;

    memset(get_buf, 0x00, sizeof(get_buf));

    if (file == NULL)
    {
        at_fs_ret = -1;
        LOGE("file is null\n");
        goto exit;
    }

    write_size = file->fs_data_size;
    memcpy(get_buf, file->fs_data, write_size);
    memcpy(Filepath, file->fs_data_name, strlen(file->fs_data_name));

    if ((at_fs_ret = path_redirection(Filepath, Pathtmp)) == -1)
    {
        LOGE("input path_redirection error:[%d]\n", errno);
        goto exit;
    }

    if (fd = file_open(Pathtmp, O_RDWR | O_CREAT | O_TRUNC) == -1)
    {
        LOGE("open file is err  [%d]\n",errno);
    }
    else
    {
        //通过at客户端往里面写数据
        LOGE("Open file SUCCESS\r\n");
        if (lseek(fd,0,SEEK_SET) == -1 )
        {
            LOGE("lseek error = [%d]\n",errno);
            at_fs_ret = -1;
            file_close(fd);
            goto exit;
        }
        //这两步可以加出错处理
        file_write(fd, get_buf, write_size);
        fsync(fd);
        file_close(fd);
    }

exit:
    mbtk_at_fs_printf(send_buf);
    mbtk_at_fs_printf("end");
    return at_fs_ret;
}