T536_DTU/app_public/history_file/history_file.c

/******************************************************************************
版权所有：
文件名称：	history_file.c
文件版本：	01.01
创建作者：
创建日期：	2016-08-09
功能说明：	历史数据文件操作接口实现文件
其它说明：
修改记录：
*/

#include "head.h"
#include "history_file.h"
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/ioctls.h>
#include <linux/syscalls.h>
#include <termios.h>

/******************************************************************************
函数名称：	hf_get_filecnt_from_tmpfile
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 从临时文件中获取文件个数
参数说明：
            tmpfile: 临时文件
            cols:   文件名占用的字节数
返回值：  	成功返回文件个数
            失败返回0

修改记录：
*/
static int hf_get_filecnt_from_tmpfile(char *tmpfile, int cols)
{
    int ret = 0;
    struct stat s;

    // 获取文件属性
    if (sys_newstat(tmpfile, &s))
    {
        rt_printf("%s:sys_newstat(%s) error\n", __func__, tmpfile);
        return 0;
    }

    // 因为每行的字节数字是固定的，所以除以每行的字节数就可得出文件个数
    ret = s.st_size / (cols + 1);

    return ret;
}

/******************************************************************************
函数名称：	hf_get_file_content
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 获取文件内容
参数说明：
            filename:  文件名
            p_file_len:   返回的文件长度
返回值：  	成功返回文件内容
            失败返回NULL

修改记录：
*/
static char *hf_get_file_content(char *filename, int *p_file_len)
{
    char *p = NULL;
    int fd;
    struct stat s;
    int ret;

    // 获取文件属性
    if (sys_newstat(filename, &s))
    {
        rt_printf("%s:sys_newstat(%s) error\n", __func__, filename);
        return NULL;
    }

    *p_file_len = s.st_size;

    p = rt_malloc(s.st_size + 1); // 多一个字节，最后一个字节存放0,便于字符查找方便

    if (!p)
    {
        rt_printf("%s:rt_malloc eror\r\n", __func__);
        return NULL;
    }

    fd = sys_open(filename, O_RDONLY, 0);
    if (fd < 0)
    {
        rt_printf("sys_open(%s) error\r\n", filename);
        rt_free(p);
        return NULL;
    }

    ret = sys_read(fd, p, s.st_size);

    if (ret != s.st_size)
    {
        rt_printf("%s:sys_read error\r\n", __func__);
        rt_free(p);
        sys_close(fd);
        return NULL;
    }

    sys_close(fd);

    p[s.st_size] = 0;
    return p;
}

/******************************************************************************
函数名称：	hf_get_timedfile_content
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 获取录波文件的内容
参数说明：
            tmpfile: 临时文件
            cols:   文件名占用的字节数
返回值：  	成功返回文件个数
            失败返回0

修改记录：
*/
static char *hf_get_timedfile_content(char *dir, int filename, int part, int *p_part_len)
{
#if 1
    char *p = NULL;
    struct dir_file_ext_struct *p_dfs_ext = NULL;
    int i = 0;
    int file_cnt = 0;
    char tmp[128];
    int bfind = 0;

    p_dfs_ext = hf_get_dir_file_ext(dir, &file_cnt, HF_FRZ_101_TMP);

    if (!p_dfs_ext)
    {
        return NULL;
    }

    for (i = 0; i < file_cnt; i++)
    {
        if (filename == (i + HF_FIXPT_FILENAME_N))
        {
            bfind = 1;
            break;
        }
    }

    if (!bfind)
    {
        goto END;
    }

    sprintf(tmp, "%s%s", dir, p_dfs_ext[i].file_name);

    p = hf_get_file_content(tmp, p_part_len);

END:

    rt_free(p_dfs_ext);
    return p;
#else
    char *p = NULL;
    char *p2;
    char *pstr;
    char *cmd_ls[] = {"/app/m", "ls", dir, HF_TIMED_101_TMP, NULL};
    char *envp[] = {NULL};
    char tmp[128];
    char tmp_filename[64];
    char cr_line[] = {'\r', '\n', 0};
    int cnt;
    int fd;
    int i;
    int ret;
    int filelen = 0;
    int addr;

    // 调用shell脚本,生成文件列表
    ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);

    // 文件个数
    cnt = hf_get_filecnt_from_tmpfile(HF_TIMED_101_TMP, HF_FIXPT_FILENAME_LEN);

    fd = sys_open(HF_TIMED_101_TMP, O_RDONLY, 0);

    if (fd < 0)
    {
        return NULL;
    }

    for (i = 0; i < cnt; i++)
    {
        memset(tmp_filename, 0, sizeof(tmp_filename));
        ret = sys_read(fd, tmp_filename, HF_FIXPT_FILENAME_LEN + 1);
        if (ret != HF_FIXPT_FILENAME_LEN + 1)
        {
            sys_close(fd);
        }

        tmp_filename[HF_FIXPT_FILENAME_LEN] = 0;
        addr = simple_strtoul(tmp_filename, NULL, 10);

        if (addr == filename)
        {

            sys_close(fd);
            fd = 0;
            sprintf(tmp, "%s%s", dir, tmp_filename);

            p = hf_get_file_content(tmp, &filelen);

            if (p)
            {
                // 读文件头
                pstr = strstr(p, cr_line);
                if (!pstr)
                {
                    rt_free(p);
                    return NULL;
                }

                pstr += 2;
                pstr = strstr(pstr, cr_line);
                if (!pstr)
                {
                    rt_free(p);
                    return NULL;
                }

                pstr += 2;
                for (i = 0; i < (part - 1); i++)
                {
                    if (pstr >= (p + filelen))
                    {
                        rt_free(p);
                        return NULL;
                    }

                    pstr = strstr(pstr, cr_line);
                    if (!pstr)
                    {
                        rt_free(p);
                        return NULL;
                    }

                    pstr += 2;
                }

                if (*pstr == '\n') // '/A' ?
                {
                    rt_free(p);
                    return NULL;
                }

                p2 = pstr;
                pstr = strstr(pstr, cr_line);
                if (!pstr)
                {
                    rt_free(p);
                    return NULL;
                }

                *p_part_len = (int)(pstr - p2);
                memcpy(p, p2, *p_part_len);
            }
            break;
        }
    }

    if (fd > 0)
    {
        sys_close(fd);
    }
    rt_file_del(HF_TIMED_101_TMP);
    return p;
#endif
}

/******************************************************************************
函数名称：	hf_get_frzfile_content
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 获取录波文件的内容
参数说明：
            tmpfile: 临时文件
            cols:   文件名占用的字节数
返回值：  	成功返回文件个数
            失败返回0

修改记录：
*/
static char *hf_get_frzfile_content(char *dir, int filename, int part, int *p_part_len)
{
    char *p = NULL;
    struct dir_file_ext_struct *p_dfs_ext = NULL;
    int i = 0;
    int file_cnt = 0;
    char tmp[128];
    int bfind = 0;

    p_dfs_ext = hf_get_dir_file_ext(dir, &file_cnt, HF_FRZ_101_TMP);

    if (!p_dfs_ext)
    {
        return NULL;
    }

    for (i = 0; i < file_cnt; i++)
    {
        if (filename == (i + HF_FRZ_FILENAME_N))
        {
            bfind = 1;
            break;
        }
    }

    if (!bfind)
    {
        goto END;
    }

    sprintf(tmp, "%s%s", dir, p_dfs_ext[i].file_name);

    p = hf_get_file_content(tmp, p_part_len);

END:

    rt_free(p_dfs_ext);
    return p;
}

/******************************************************************************
函数名称：	hf_get_wavefile_content
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 获取录波文件的内容
参数说明：
            tmpfile: 临时文件
            cols:   文件名占用的字节数
返回值：  	成功返回文件个数
            失败返回0

修改记录：
*/
static char *hf_get_wavefile_content(char *dir, int filename, int part, int *p_part_len)
{

    char *p = NULL;
    char *cmd_ls[] = {"/app/m", "ls", dir, HF_WAVE_TMP, NULL};
    char *envp[] = {NULL};
    char tmp[128];
    char tmp_filename[64];
    int cnt;

    int fd;
    int i;
    int ret;
    int addr;

    // 调用shell脚本,生成文件列表
    ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);

    // 文件个数
    cnt = hf_get_filecnt_from_tmpfile(HF_WAVE_TMP, HF_WAVE_FILE_LENGTH);

    fd = sys_open(HF_WAVE_TMP, O_RDONLY, 0);

    if (fd < 0)
    {
        return NULL;
    }

    for (i = 0; i < cnt; i++)
    {
        memset(tmp_filename, 0, sizeof(tmp_filename));
        ret = sys_read(fd, tmp_filename, HF_WAVE_FILE_LENGTH + 1);
        if (ret != HF_WAVE_FILE_LENGTH + 1)
        {
            sys_close(fd);
        }

        tmp_filename[HF_WAVE_FILE_LENGTH] = 0;
        addr = simple_strtoul(tmp_filename, NULL, 16);

        if (addr == filename)
        {
            // cfg文件
            if ((part == 1) && strstr(tmp_filename, ".cfg"))
            {

                sprintf(tmp, "%s%s", dir, tmp_filename);
                p = hf_get_file_content(tmp, p_part_len);
                break;
            }
            else if ((part == 2) && strstr(tmp_filename, ".dat")) // dat文件
            {
                sprintf(tmp, "%s%s", dir, tmp_filename);
                p = hf_get_file_content(tmp, p_part_len);
                break;
            }
        }
    }

    sys_close(fd);

    rt_file_del(HF_WAVE_TMP);

    return p;
}

/******************************************************************************
函数名称：	hf_get_max_minfile_content
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 获取录波文件的内容
参数说明：
            tmpfile: 临时文件
            cols:   文件名占用的字节数
返回值：  	成功返回文件个数
            失败返回0

修改记录：
*/
static char *hf_get_max_minfile_content(char *dir, int filename, int part, int *p_part_len)
{
#if 1
    char *p = NULL;
    struct dir_file_ext_struct *p_dfs_ext = NULL;
    int i = 0;
    int file_cnt = 0;
    char tmp[128];
    int bfind = 0;

    p_dfs_ext = hf_get_dir_file_ext(dir, &file_cnt, HF_MAX_MIN_101_TMP);

    if (!p_dfs_ext)
    {
        return NULL;
    }

    for (i = 0; i < file_cnt; i++)
    {
        if (filename == (i + HF_EXV_FILENAME_N))
        {
            bfind = 1;
            break;
        }
    }

    if (!bfind)
    {
        goto END;
    }

    sprintf(tmp, "%s%s", dir, p_dfs_ext[i].file_name);

    p = hf_get_file_content(tmp, p_part_len);

END:

    rt_free(p_dfs_ext);
    return p;

#else

    char *p = NULL;
    char *cmd_ls[] = {"/app/m", "ls", dir, HF_MAX_MIN_101_TMP, NULL};
    char *envp[] = {NULL};
    char tmp[128];
    char tmp_filename[64];
    int cnt;

    int fd;
    int i;
    int ret;
    int addr;

    // 调用shell脚本,生成文件列表
    ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);

    // 文件个数
    cnt = hf_get_filecnt_from_tmpfile(HF_MAX_MIN_101_TMP, HF_EXV_FILENAME_LEN);

    fd = sys_open(HF_MAX_MIN_101_TMP, O_RDONLY, 0);

    if (fd < 0)
    {
        return NULL;
    }

    for (i = 0; i < cnt; i++)
    {
        memset(tmp_filename, 0, sizeof(tmp_filename));
        ret = sys_read(fd, tmp_filename, HF_EXV_FILENAME_LEN + 1);
        if (ret != HF_EXV_FILENAME_LEN + 1)
        {
            sys_close(fd);
            return NULL;
        }

        tmp_filename[HF_EXV_FILENAME_LEN] = 0;
        addr = simple_strtoul(tmp_filename, NULL, 10);

        if (addr == filename)
        {

            sprintf(tmp, "%s%s", dir, tmp_filename);
            p = hf_get_file_content(tmp, p_part_len);
            break;
        }
    }

    sys_close(fd);

    rt_file_del(HF_MAX_MIN_101_TMP);

    return p;
#endif
}

/******************************************************************************
函数名称：	hf_str_to_ts
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 字符串时间转struct timespec  结构时间
参数说明：
            p_strtime: 字符串时间(比如20141114_192135_830)
            p_ts:   struct timespec时间

 返回值：  	返回0


修改记录：
*/
int hf_str_to_ts(char *p_strtime, struct timespec *p_ts)
{
    char tmp[8];
    struct rtc_time_t rtc;
    rt_printf("%s\r\n", p_strtime);
    memset(tmp, 0, sizeof(tmp));
    memcpy(tmp, p_strtime, 4);
    rtc.year = simple_strtoul(tmp, NULL, 10) - 2000;

    memset(tmp, 0, sizeof(tmp));
    memcpy(tmp, p_strtime + 4, 2);
    rtc.month = simple_strtoul(tmp, NULL, 10);

    memset(tmp, 0, sizeof(tmp));
    memcpy(tmp, p_strtime + 6, 2);
    rtc.day = simple_strtoul(tmp, NULL, 10);

    memset(tmp, 0, sizeof(tmp));
    memcpy(tmp, p_strtime + 9, 2);
    rtc.hour = simple_strtoul(tmp, NULL, 10);

    memset(tmp, 0, sizeof(tmp));
    memcpy(tmp, p_strtime + 11, 2);
    rtc.min = simple_strtoul(tmp, NULL, 10);

    memset(tmp, 0, sizeof(tmp));
    memcpy(tmp, p_strtime + 13, 2);
    rtc.ms = simple_strtoul(tmp, NULL, 10);
    rtc.ms *= 1000;

    memset(tmp, 0, sizeof(tmp));
    memcpy(tmp, p_strtime + 16, 3);
    rtc.ms += simple_strtoul(tmp, NULL, 10);

    rtc_to_timespec(&rtc, p_ts);

    return 0;
}

/******************************************************************************
函数名称：	hf_gen_dfs_wave
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 生成 dir_file_struct *指针(用于多文件的情况)
参数说明：
            dir: 目录
            file_name:   文件名(字符串)
            file_name_n: 文件名(数字)
            tmpfile: 临时文件 。主要是用于得到目录文件的个数和文件名称
            name_len: 名字长度。比如极值数据，112~141.它的长度就是3。比如定点数据22~51，它的长度就是2

返回值：  	如果获取成功，则得到struct dir_file_struct 的指针。使用完毕应当释放内存。
            如果获取失败，则返回NULL.

修改记录：
*/
static struct dir_file_struct *hf_gen_dfs_wave(char *dir, char *tmpfile, int *p_file_cnt)
{
    struct dir_file_struct *p_dfs = NULL;
    int ret;
    char tmp[128];
    struct stat s;
    int i;
    int len = HF_WAVE_FILE_LENGTH;

    ret = hf_get_filecnt_from_tmpfile(tmpfile, len);

    *p_file_cnt = ret;

    if (ret > 0)
    {
        int fd;
        char tmp2[128];
        int cnt;

        p_dfs = rt_malloc(ret * sizeof(struct dir_file_struct));
        if (!p_dfs)
        {
            return NULL;
        }

        memset(tmp, 0, sizeof(tmp));
        fd = sys_open(tmpfile, O_RDONLY, 0);
        if (fd < 0)
        {
            rt_printf("sys_open(%s) error\r\n", tmpfile);
            rt_free(p_dfs);
            return NULL;
        }

        cnt = ret;
        for (i = 0; i < cnt; i++)
        {
            ret = sys_read(fd, tmp, len + 1); // 包括换行符
            if (ret != (len + 1))
            {
                rt_printf("sys_read error\r\n");
                rt_free(p_dfs);
                sys_close(fd);
            }
            tmp[28] = 0;
            p_dfs[i].file_name = simple_strtoul(tmp, NULL, 16);
            sprintf(tmp2, "%s%s", dir, tmp);
            if (sys_newstat(tmp2, &s))
            {
                rt_printf("%s:sys_newstat(%s) error\n", __func__, tmp2);
                rt_free(p_dfs);
                sys_close(fd);
            }
            p_dfs[i].file_size = s.st_size;
            p_dfs[i].file_time.tv_nsec = 0;
            hf_str_to_ts(tmp + 5, &p_dfs[i].file_time);
        }

        sys_close(fd);
    }

    return p_dfs;
}

/******************************************************************************
函数名称：	hf_gen_dfs_ext
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 生成 dir_file_struct *指针(用于多文件的情况)
参数说明：
            dir: 目录
            file_name:   文件名(字符串)
            file_name_n: 文件名(数字)
            tmpfile: 临时文件 。主要是用于得到目录文件的个数和文件名称
            name_len: 名字长度。比如极值数据，112~141.它的长度就是3。比如定点数据22~51，它的长度就是2

返回值：  	如果获取成功，则得到struct dir_file_struct 的指针。使用完毕应当释放内存。
            如果获取失败，则返回NULL.

修改记录：
*/
#if 1
static struct dir_file_struct *hf_gen_dfs_ext(char *dir, int *p_file_cnt, char *tmpfile, int filename_base, int filename_max)
{
    struct dir_file_struct *p_dfs = NULL;
    struct dir_file_ext_struct *p_dfs_ext = NULL;
    int i = 0;

    p_dfs_ext = hf_get_dir_file_ext(dir, p_file_cnt, tmpfile);

    if (!p_dfs_ext)
    {
        return NULL;
    }

    p_dfs = rt_malloc((*p_file_cnt) * sizeof(struct dir_file_struct));

    if (!p_dfs)
    {
        rt_free(p_dfs_ext);
        return NULL;
    }

    for (i = 0; i < *p_file_cnt; i++)
    {
        if (((filename_base + i) >= filename_base) && ((filename_base + i) <= filename_max))
        {
            p_dfs[i].file_name = filename_base + i;
            p_dfs[i].file_size = p_dfs_ext[i].file_size;
            p_dfs[i].file_time = p_dfs_ext[i].file_time;
            strcpy(p_dfs[i].name, p_dfs_ext[i].file_name);
        }
    }

    rt_free(p_dfs_ext);

    return p_dfs;
}
#else
static struct dir_file_struct *hf_gen_dfs_ext(char *dir, char *file_name, int file_name_n, char *tmpfile, int name_len, int *p_file_cnt)
{
    struct dir_file_struct *p_dfs = NULL;
    int ret;
    char tmp[128];
    int len = strlen(file_name);
    struct stat s;
    int i;

    file_name_n = file_name_n;

    ret = hf_get_filecnt_from_tmpfile(tmpfile, len);

    *p_file_cnt = ret;

    if (ret > 0)
    {
        int fd;
        char tmp2[128];
        int cnt;

        p_dfs = rt_malloc(ret * sizeof(struct dir_file_struct));
        if (!p_dfs)
        {
            return NULL;
        }

        memset(tmp, 0, sizeof(tmp));
        fd = sys_open(tmpfile, O_RDONLY, 0);
        if (fd < 0)
        {
            rt_printf("sys_open(%s) error\r\n", tmpfile);
            rt_free(p_dfs);
            return NULL;
        }

        cnt = ret;
        for (i = 0; i < cnt; i++)
        {
            ret = sys_read(fd, tmp, len + name_len + 1); // 包括换行符
            if (ret != (len + name_len + 1))
            {
                rt_printf("sys_read error\r\n");
                rt_free(p_dfs);
                sys_close(fd);
            }
            tmp[len + name_len] = 0;
            p_dfs[i].file_name = simple_strtoul(tmp, NULL, 10);
            sprintf(tmp2, "%s%s", dir, tmp);
            if (sys_newstat(tmp2, &s))
            {
                rt_printf("%s:sys_newstat(%s) error\n", __func__, tmp2);
                rt_free(p_dfs);
                sys_close(fd);
            }
            p_dfs[i].file_size = s.st_size;
            p_dfs[i].file_time.tv_nsec = 0;
            p_dfs[i].file_time.tv_sec = s.st_ctime + 8 * 60 * 60;
        }

        sys_close(fd);
    }

    return p_dfs;
}
#endif
/******************************************************************************
函数名称：	hf_gen_dfs
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	 生成 dir_file_struct *指针
参数说明：
            dir: 目录
            file_name:   文件名(字符串)
            file_name_n: 文件名(数字)
返回值：  	如果获取成功，则得到struct dir_file_struct 的指针。使用完毕应当释放内存。
            如果获取失败，则返回NULL.

修改记录：
*/
static struct dir_file_struct *hf_gen_dfs(char *dir, char *file_name, int file_name_n)
{
    struct dir_file_struct *p_dfs = NULL;
    struct stat s;
    char tmp[128];

#if 0
	if(file_cnt==1)
	{
#endif
    sprintf(tmp, "%s%s", dir, file_name);
    // 获取文件属性
    if (sys_newstat(tmp, &s))
    {
        rt_printf("%s:sys_newstat(%s) error\n", __func__, tmp);
        return NULL;
    }

    p_dfs = rt_malloc(sizeof(struct dir_file_struct));
    if (!p_dfs)
    {
        return NULL;
    }

    p_dfs->file_name = file_name_n;
    p_dfs->file_size = s.st_size;
    p_dfs->file_time.tv_nsec = 0;
    p_dfs->file_time.tv_sec = s.st_ctime + 8 * 60 * 60;
    strcpy(p_dfs->name, file_name);

#if 0
	}
	else
	{

		p_dfs=rt_malloc(sizeof(struct dir_file_struct)*file_cnt);	
		if(!p_dfs)
		{
			return NULL;
		}
		
		for(i=0;i<file_cnt;i++)
		{
			sprintf(tmp, "%s%03d%s", dir,  file_cnt, file_name);	
			//获取文件属性
			if(sys_newstat(tmp,&s))
			{
				rt_printf("%s:sys_newstat(%s) error\n",__func__, tmp);
				return NULL;
			}			

			p_dfs[i].file_name = file_name_n+i;
			p_dfs[i].file_size=s.st_size;
			p_dfs[i].file_time.tv_nsec=0;
			p_dfs[i].file_time.tv_sec=s.st_ctime+8*60*60;

		}
	}
#endif
    return p_dfs;
}
/******************************************************************************
函数名称：	hf_get_file_len
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	获取文件长度
参数说明：
                filename:文件名

返回值：  	返回文件长度.

修改记录：
*/
static int hf_get_file_len(char *filename)
{
    struct stat s;

    // 获取文件属性
    if (sys_newstat(filename, &s))
    {
        rt_printf("%s:sys_newstat(%s) error\n", __func__, filename);
        return 0;
    }

    return (int)s.st_size;
}
/******************************************************************************
函数名称：	hf_get_dir_file
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	获取目录文件.
参数说明：
            dir: 目录
            p_file_cnt:  返回的文件个数
返回值：  	如果获取成功，则得到*p_file_cnt 个struct dir_file_struct 的指针。使用完毕应当释放内存。
            如果获取失败，则返回NULL.

修改记录：
*/
struct dir_file_struct *hf_get_dir_file(char *dir, int *p_file_cnt)
{
    int ret;
    int len;
    char *cmd_ls[] = {"/app/m", "ls", dir, NULL, NULL};
    char *envp[] = {NULL};
    struct dir_file_struct *p_dfs = NULL;

    len = strlen(dir);

    // SOE文件(101)
    if (strncmp(dir, HF_SOE_101_DIR, len) == 0)
    {
        *p_file_cnt = 1;
        p_dfs = hf_gen_dfs(HF_SOE_101_DIR, HF_SOE_FILENAME, HF_SOE_FILENAME_N);
    }
    else if (strncmp(dir, HF_CO_101_DIR, len) == 0) // yk文件(101)
    {
        *p_file_cnt = 1;
        p_dfs = hf_gen_dfs(HF_CO_101_DIR, HF_YK_FILENAME, HF_YK_FILENAME_N);
    }
#ifdef HISTORY_EVENT_EXT
    else if (strncmp(dir, HF_SOECOS_101_DIR, len) == 0) // yk文件(101)
    {
        *p_file_cnt = 1;
        p_dfs = hf_gen_dfs(HF_SOECOS_101_DIR, HF_SOECOS_FILENAME, HF_SOECOS_FILENAME_N);
    }
#endif
    else if (strncmp(dir, HF_FIXPT_101_DIR, len) == 0) // 定点文件(101)
    {
        cmd_ls[3] = HF_TIMED_101_TMP;
        // 调用shell脚本,生成文件列表
        ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);
        p_dfs = hf_gen_dfs_ext(HF_FIXPT_101_DIR, p_file_cnt, HF_TIMED_101_TMP, HF_FIXPT_FILENAME_N, HF_FIXPT_FILENAME_N_MAX);
        rt_file_del(HF_TIMED_101_TMP);
    }
    else if (strncmp(dir, HF_EXV_101_DIR, len) == 0) // 极值文件(101)
    {
        cmd_ls[3] = HF_MAX_MIN_101_TMP;
        // 调用shell脚本,生成文件列表
        ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);
        p_dfs = hf_gen_dfs_ext(HF_EXV_101_DIR, p_file_cnt, HF_MAX_MIN_101_TMP, HF_EXV_FILENAME_N, HF_EXV_FILENAME_N_MAX);
        rt_file_del(HF_MAX_MIN_101_TMP);
    }

    else if (strncmp(dir, HF_FRZ_101_DIR, len) == 0) // 定点文件(101)
    {
        cmd_ls[3] = HF_FRZ_101_TMP;
        // 调用shell脚本,生成文件列表
        ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);
        p_dfs = hf_gen_dfs_ext(HF_FRZ_101_DIR, p_file_cnt, HF_FRZ_101_TMP, HF_FRZ_FILENAME_N, HF_FRZ_FILENAME_N_MAX);
        rt_file_del(HF_FRZ_101_TMP);
    }
    else if (strncmp(dir, HF_FLOWREV_101_DIR, len) == 0)
    {
        *p_file_cnt = 1;
        p_dfs = hf_gen_dfs(HF_FLOWREV_101_DIR, HF_FLOWREV_FILENAME, HF_FLOWREV_FILENAME_N);
    }
    else if (strncmp(dir, HF_LOG_101_DIR, len) == 0)
    {
        *p_file_cnt = 1;
        p_dfs = hf_gen_dfs(HF_LOG_101_DIR, HF_LOG_FILENAME, HF_LOG_FILENAME_N);
    }
    else if (strncmp(dir, HF_WAVE_DIR, len) == 0) // 录波文件
    {
        cmd_ls[3] = HF_WAVE_TMP;
        // 调用shell脚本,生成文件列表
        ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);
        p_dfs = hf_gen_dfs_wave(HF_WAVE_DIR, HF_WAVE_TMP, p_file_cnt);
        rt_file_del(HF_WAVE_TMP);
    }
    return p_dfs;
}

/******************************************************************************
函数名称：	hf_get_max_minfile_len
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	获取极值文件大小
参数说明：
            dir: 目录
            file_name: 文件名
返回值：  	返回文件长度

修改记录：
*/
int hf_get_max_minfile_len(char *dir, int file_name)
{
#if 1
    int len = 0;
    struct dir_file_ext_struct *p_dfs_ext = NULL;
    int i = 0;
    int file_cnt = 0;
    char tmp[128];
    int bfind = 0;

    p_dfs_ext = hf_get_dir_file_ext(dir, &file_cnt, HF_MAX_MIN_101_TMP);

    if (!p_dfs_ext)
    {
        return 0;
    }

    for (i = 0; i < file_cnt; i++)
    {
        if (file_name == (i + HF_EXV_FILENAME_N))
        {
            bfind = 1;
            break;
        }
    }

    if (!bfind)
    {
        goto END;
    }

    sprintf(tmp, "%s%s", dir, p_dfs_ext[i].file_name);

    len = hf_get_file_len(tmp);

END:

    rt_free(p_dfs_ext);
    return len;
#else
    char *cmd_ls[] = {"/app/m", "ls", dir, HF_MAX_MIN_101_TMP, NULL};
    char *envp[] = {NULL};
    char tmp[128];
    char tmp_filename[64];
    int cnt;
    int fd;
    int i;
    int ret;
    int addr;
    int len = 0;

    // 调用shell脚本,生成文件列表
    ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);

    // 文件个数
    cnt = hf_get_filecnt_from_tmpfile(HF_MAX_MIN_101_TMP, HF_EXV_FILENAME_LEN);

    fd = sys_open(HF_MAX_MIN_101_TMP, O_RDONLY, 0);

    if (fd < 0)
    {
        return 0;
    }

    for (i = 0; i < cnt; i++)
    {
        memset(tmp_filename, 0, sizeof(tmp_filename));
        ret = sys_read(fd, tmp_filename, HF_EXV_FILENAME_LEN + 1);
        if (ret != HF_EXV_FILENAME_LEN + 1)
        {
            sys_close(fd);
            return 0;
        }

        tmp_filename[HF_EXV_FILENAME_LEN] = 0;
        addr = simple_strtoul(tmp_filename, NULL, 10);

        if (addr == file_name)
        {

            sprintf(tmp, "%s%s", dir, tmp_filename);
            len = hf_get_file_len(tmp);
            break;
        }
    }

    sys_close(fd);

    rt_file_del(HF_MAX_MIN_101_TMP);

    return len;

#endif
}

/******************************************************************************
函数名称：	hf_get_wavefile_len
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	获取录波文件大小
参数说明：
            dir: 目录
            file_name: 文件名
返回值：  	返回文件长度

修改记录：
*/
int hf_get_wavefile_len(char *dir, int file_name)
{
    char *cmd_ls[] = {"/app/m", "ls", dir, HF_WAVE_TMP, NULL};
    char *envp[] = {NULL};
    char tmp[128];
    char tmp_filename[64];
    int cnt;
    int fd;
    int i;
    int ret;
    int addr;
    int len = 0;
    int cfg_dat = 0;

    // 调用shell脚本,生成文件列表
    ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);

    // 文件个数
    cnt = hf_get_filecnt_from_tmpfile(HF_WAVE_TMP, HF_WAVE_FILE_LENGTH);

    fd = sys_open(HF_WAVE_TMP, O_RDONLY, 0);

    if (fd < 0)
    {
        return 0;
    }

    for (i = 0; i < cnt; i++)
    {
        memset(tmp_filename, 0, sizeof(tmp_filename));
        ret = sys_read(fd, tmp_filename, HF_WAVE_FILE_LENGTH + 1);
        if (ret != HF_WAVE_FILE_LENGTH + 1)
        {
            sys_close(fd);
            return 0;
        }

        tmp_filename[HF_WAVE_FILE_LENGTH] = 0;
        addr = simple_strtoul(tmp_filename, NULL, 16);
        if (addr == file_name)
        {

            cfg_dat++;
            sprintf(tmp, "%s%s", dir, tmp_filename);

            len += hf_get_file_len(tmp);
            if (cfg_dat == 2)
                break;
        }
    }

    sys_close(fd);

    rt_file_del(HF_WAVE_TMP);

    return len;
}

/******************************************************************************
函数名称：	hf_get_timedfile_len
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	获取定点文件大小
参数说明：
            dir: 目录
            file_name: 文件名
返回值：  	返回文件长度

修改记录：
*/
int hf_get_timedfile_len(char *dir, int file_name, int *partnum)
{
#if 1
    char *p = NULL;
    int len = 0;
    struct dir_file_ext_struct *p_dfs_ext = NULL;
    int i = 0;
    int file_cnt = 0;
    char tmp[128];
    int bfind = 0;
    int filelen = 0;

    p_dfs_ext = hf_get_dir_file_ext(dir, &file_cnt, HF_TIMED_101_TMP);

    if (!p_dfs_ext)
    {
        return 0;
    }

    for (i = 0; i < file_cnt; i++)
    {
        if (file_name == (i + HF_FIXPT_FILENAME_N))
        {
            bfind = 1;
            break;
        }
    }

    if (!bfind)
    {
        goto END;
    }

    sprintf(tmp, "%s%s", dir, p_dfs_ext[i].file_name);

    len = hf_get_file_len(tmp);
    p = hf_get_file_content(tmp, &filelen);

    if (p)
    {
        int linecnt = 0;
        char *pp = p;
        char cr_line[] = {'\r', '\n', 0};
        while (pp)
        {
            pp = strstr(pp, cr_line);
            if (!pp)
            {
                break;
            }
            linecnt++;
            pp += 2;
        }

        linecnt -= 2;
        if (linecnt < 0)
        {
            linecnt = 0;
        }

        *partnum = linecnt;

        rt_free(p);
    }
END:

    rt_free(p_dfs_ext);
    return len;

#else
    char *p = NULL;
    char *cmd_ls[] = {"/app/m", "ls", dir, HF_TIMED_101_TMP, NULL};
    char *envp[] = {NULL};
    char tmp[128];
    char tmp_filename[64];
    int cnt;
    int fd;
    int i;
    int ret;
    int addr;
    int len = 0;
    int filelen;

    // 调用shell脚本,生成文件列表
    ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);

    // 文件个数
    cnt = hf_get_filecnt_from_tmpfile(HF_TIMED_101_TMP, HF_FIXPT_FILENAME_LEN);

    fd = sys_open(HF_TIMED_101_TMP, O_RDONLY, 0);

    if (fd < 0)
    {
        return 0;
    }

    for (i = 0; i < cnt; i++)
    {
        memset(tmp_filename, 0, sizeof(tmp_filename));
        ret = sys_read(fd, tmp_filename, HF_FIXPT_FILENAME_LEN + 1);
        if (ret != HF_FIXPT_FILENAME_LEN + 1)
        {
            sys_close(fd);
            return 0;
        }

        tmp_filename[HF_FIXPT_FILENAME_LEN] = 0;
        addr = simple_strtoul(tmp_filename, NULL, 10);

        if (addr == file_name)
        {

            sprintf(tmp, "%s%s", dir, tmp_filename);
            len = hf_get_file_len(tmp);

            p = hf_get_file_content(tmp, &filelen);

            if (p)
            {
                int linecnt = 0;
                char *pp = p;
                char cr_line[] = {'\r', '\n', 0};
                while (pp)
                {
                    pp = strstr(pp, cr_line);
                    if (!pp)
                    {
                        break;
                    }
                    linecnt++;
                    pp += 2;
                }

                linecnt -= 2;
                if (linecnt < 0)
                {
                    linecnt = 0;
                }

                *partnum = linecnt;

                rt_free(p);
            }

            break;
        }
    }

    sys_close(fd);

    rt_file_del(HF_TIMED_101_TMP);

    return len;
#endif
}

int hf_get_frzfile_len(char *dir, int file_name, int *partnum)
{

    char *p = NULL;
    int len = 0;
    struct dir_file_ext_struct *p_dfs_ext = NULL;
    int i = 0;
    int file_cnt = 0;
    char tmp[128];
    int bfind = 0;
    int filelen = 0;

    p_dfs_ext = hf_get_dir_file_ext(dir, &file_cnt, HF_FRZ_101_TMP);

    if (!p_dfs_ext)
    {
        return 0;
    }

    for (i = 0; i < file_cnt; i++)
    {
        if (file_name == (i + HF_FRZ_FILENAME_N))
        {
            bfind = 1;
            break;
        }
    }

    if (!bfind)
    {
        goto END;
    }

    sprintf(tmp, "%s%s", dir, p_dfs_ext[i].file_name);

    len = hf_get_file_len(tmp);
    p = hf_get_file_content(tmp, &filelen);

    if (p)
    {
        int linecnt = 0;
        char *pp = p;
        char cr_line[] = {'\r', '\n', 0};
        while (pp)
        {
            pp = strstr(pp, cr_line);
            if (!pp)
            {
                break;
            }
            linecnt++;
            pp += 2;
        }

        linecnt -= 2;
        if (linecnt < 0)
        {
            linecnt = 0;
        }

        *partnum = linecnt;

        rt_free(p);
    }
END:

    rt_free(p_dfs_ext);
    return len;
}

/******************************************************************************
函数名称：	hf_get_file_part
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	获取特定目录下某个文件节的信息
参数说明：
            dir: 目录
            file_name: 文件名
            part: 节名
            part_len: 节长度
返回值：  	如果获取成功，则得到节内容和节长度
            如果获取失败，则返回NULL.

修改记录：
*/
char *hf_get_file_part(char *dir, int file_name, int part, int *part_len)
{
    char *p = NULL;
    char tmp[128];
    int len = strlen(dir);

    if (strncmp(dir, HF_SOE_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_SOE_FILENAME);
        p = hf_get_file_content(tmp, part_len);
    }
    else if (strncmp(dir, HF_CO_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_YK_FILENAME);
        p = hf_get_file_content(tmp, part_len);
    }
#ifdef HISTORY_EVENT_EXT
    else if (strncmp(dir, HF_SOECOS_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_SOECOS_FILENAME);
        p = hf_get_file_content(tmp, part_len);
    }
#endif
    else if (strncmp(dir, HF_EXV_101_DIR, len) == 0)
    {
        // sprintf(tmp, "%s%03d%s", dir, file_name, HF_EXV_FILENAME);
        // p=hf_get_file_content(tmp, part_len);
        p = hf_get_max_minfile_content(dir, file_name, part, part_len);
    }
    else if (strncmp(dir, HF_FIXPT_101_DIR, len) == 0)
    {
        p = hf_get_timedfile_content(dir, file_name, part, part_len);
    }
    else if (strncmp(dir, HF_FRZ_101_DIR, len) == 0)
    {
        p = hf_get_frzfile_content(dir, file_name, part, part_len);
    }
    else if (strncmp(dir, HF_FLOWREV_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_FLOWREV_FILENAME);
        p = hf_get_file_content(tmp, part_len);
    }
    else if (strncmp(dir, HF_LOG_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_LOG_FILENAME);
        p = hf_get_file_content(tmp, part_len);
    }
    else if (strncmp(dir, HF_WAVE_DIR, len) == 0)
    {
        p = hf_get_wavefile_content(dir, file_name, part, part_len);
    }

    return p;
}

/******************************************************************************
函数名称：	hf_get_file_inf
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	获取目录文件.
参数说明：
            dir: 目录
            file_name:  文件名
            partnum: 节个数
返回值：  	如果获取成功，则返回 文件长度、节个数

            如果获取失败，则返回NULL.

修改记录：
*/
int hf_get_file_inf(char *dir, int file_name, int *partnum)
{
    char tmp[128];
    int len = strlen(dir);
    int ret = 0;

    if (strncmp(dir, HF_SOE_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_SOE_FILENAME);
        ret = hf_get_file_len(tmp);
        *partnum = 1;
    }
    else if (strncmp(dir, HF_CO_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_YK_FILENAME);
        ret = hf_get_file_len(tmp);
        *partnum = 1;
    }
#ifdef HISTORY_EVENT_EXT
    else if (strncmp(dir, HF_SOECOS_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_SOECOS_FILENAME);
        ret = hf_get_file_len(tmp);
        *partnum = 1;
    }
#endif
    else if (strncmp(dir, HF_EXV_101_DIR, len) == 0)
    {
        ret = hf_get_max_minfile_len(dir, file_name);
        *partnum = 1;
    }
    else if (strncmp(dir, HF_FIXPT_101_DIR, len) == 0)
    {
        ret = hf_get_timedfile_len(dir, file_name, partnum);
    }
    else if (strncmp(dir, HF_FRZ_101_DIR, len) == 0)
    {
        ret = hf_get_frzfile_len(dir, file_name, partnum);
    }
    else if (strncmp(dir, HF_FLOWREV_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_FLOWREV_FILENAME);
        ret = hf_get_file_len(tmp);
        *partnum = 1;
    }
    else if (strncmp(dir, HF_LOG_101_DIR, len) == 0)
    {
        sprintf(tmp, "%s%s", dir, HF_LOG_FILENAME);
        ret = hf_get_file_len(tmp);
        *partnum = 1;
    }
    else if (strncmp(dir, HF_WAVE_DIR, len) == 0)
    {

        ret = hf_get_wavefile_len(dir, file_name);
        *partnum = 2;
    }

    return ret;
}

/******************************************************************************
函数名称：	hf_get_dir_file_ext
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	获取目录文件.
参数说明：
            dir: 目录
            p_file_cnt:  返回的文件个数
             tmpfile: 指定一个临时文件
返回值：  	如果获取成功，则得到*p_file_cnt 个struct dir_file_ext_struct 的指针。使用完毕应当释放内存。
            如果获取失败，则返回NULL.

修改记录：
*/
struct dir_file_ext_struct *hf_get_dir_file_ext(char *dir, int *p_file_cnt, char *tmpfile)
{
    char *cmd_ls[] = {"/app/m", "ls", dir, tmpfile, NULL};
    char *envp[] = {NULL};
    struct dir_file_ext_struct *p_dfs = NULL;
    int fd;
    struct stat s;
    char *p = NULL;
    char *pp;
    char *pp2;
    char end_A[] = {0x0A, 0};
    int ret;
    int file_cnt = 0;
    int i = 0;
    char tmp[128];

    // 调用shell脚本,生成文件列表
    ret = call_usermodehelper("/app/m", cmd_ls, envp, UMH_WAIT_PROC);

    // 获取文件属性
    if (sys_newstat(tmpfile, &s))
    {
        rt_printf("%s:sys_newstat(%s) error\n", __func__, tmpfile);
        rt_file_del(tmpfile);
        return NULL;
    }

    if (s.st_size == 0)
    {
        rt_file_del(tmpfile);
        return NULL;
    }

    p = rt_malloc(s.st_size + 1);
    if (!p)
    {
        rt_file_del(tmpfile);
        return NULL;
    }

    fd = sys_open(tmpfile, O_RDONLY, 0);
    if (fd < 0)
    {
        rt_free(p);
        rt_file_del(tmpfile);
        return NULL;
    }

    memset(p, 0, s.st_size + 1);
    ret = sys_read(fd, p, s.st_size);
    sys_close(fd);
    rt_file_del(tmpfile);
    if (ret != s.st_size)
    {
        rt_printf("%s:sys_read error\n", __func__);
        rt_free(p);
        return NULL;
    }

    pp = p;
    // 求目录下的文件个数
    while (pp)
    {
        pp = strstr(pp, end_A);

        if (!pp)
        {
            break;
        }

        pp++;

        file_cnt++;
    }

    *p_file_cnt = file_cnt;
    if (file_cnt <= 0)
    {
        rt_free(p);
        return NULL;
    }

    p_dfs = rt_malloc(file_cnt * sizeof(struct dir_file_ext_struct));
    if (!p_dfs)
    {
        rt_free(p);
        return NULL;
    }

    pp = p;
    memset(p_dfs, 0, file_cnt * sizeof(struct dir_file_ext_struct));
    for (i = 0; i < file_cnt; i++)
    {
        pp2 = strstr(pp, end_A);

        if (!pp2)
        {
            break;
        }

        memcpy(p_dfs[i].file_name, pp, pp2 - pp);
        sprintf(tmp, "%s%s", dir, p_dfs[i].file_name);
        // 获取文件属性
        if (sys_newstat(tmp, &s))
        {
            rt_printf("%s:sys_newstat(%s) error\n", __func__, tmp);
            rt_free(p);
            rt_free(p_dfs);
            return NULL;
        }

        p_dfs[i].file_size = s.st_size;
        p_dfs[i].file_time.tv_nsec = 0;
        p_dfs[i].file_time.tv_sec = s.st_ctime + 8 * 60 * 60;

        pp2++;
        pp = pp2;
    }

    rt_free(p);

    return p_dfs;
}

/******************************下面是国网最新标准文件传输的内容*********************************/

/* *********************************************************************
获取目录信息
 id :目录ID 暂时不知怎么用
 dir :目录名称，若为空，则为默认目录
 cf: =0 全部目录 ==1 满足搜索条件的信息
 ts te  搜索开始及结束时间

*/

struct dir_file_struct *hf_get_dir_file_n(uint32_t id, char *dir, char cf, struct rtc_time_t *ts, struct rtc_time_t *te, int *p_file_cnt)
{
    struct dir_file_ext_struct *p_dfes;
    struct dir_file_struct *p_dfs;
    struct timespec ts1, ts2;
    int cnt;
    int i, j;

    id = id;

    if (!dir)
    {
        p_dfes = hf_get_dir_file_ext(HF_DEFAULT_PATH, p_file_cnt, "/tmp/gdfn.tmp");
    }
    else
    {
        p_dfes = hf_get_dir_file_ext(dir, p_file_cnt, "/tmp/gdfn.tmp");
    }

    if (!p_dfes)
    {
        return NULL;
    }

    if (cf == 0)
    {

        p_dfs = rt_malloc((*p_file_cnt) * sizeof(struct dir_file_struct));
        if (!p_dfs)
        {
            rt_printf("%s: rt_malloc error \n", __func__);
            rt_free(p_dfes);
            return NULL;
        }

        for (i = 0; i < *p_file_cnt; i++)
        {
            memcpy(p_dfs[i].name, p_dfes[i].file_name, 64);
            p_dfs[i].file_size = p_dfes[i].file_size;
            p_dfs[i].file_time = p_dfes[i].file_time;
        }
    }
    else
    {
        int c1, c2;
        rtc_to_timespec(ts, &ts1);
        rtc_to_timespec(te, &ts2);
        cnt = 0;
        // 查找符合条件的文件
        for (i = 0; i < *p_file_cnt; i++)
        {
            c1 = (p_dfes[i].file_time.tv_sec > ts1.tv_sec) || ((p_dfes[i].file_time.tv_sec == ts1.tv_sec) && (p_dfes[i].file_time.tv_nsec >= ts1.tv_nsec));
            c2 = (p_dfes[i].file_time.tv_sec < ts2.tv_sec) || ((p_dfes[i].file_time.tv_sec == ts2.tv_sec) && (p_dfes[i].file_time.tv_nsec <= ts2.tv_nsec));
            if (c1 && c2)
            {
                cnt++;
            }
        }

        p_dfs = rt_malloc(cnt * sizeof(struct dir_file_struct));
        if (!p_dfs)
        {
            rt_printf("%s: rt_malloc error \n", __func__);
            rt_free(p_dfes);
            return NULL;
        }

        j = 0;
        // 查找符合条件的文件
        for (i = 0; i < *p_file_cnt; i++)
        {
            c1 = (p_dfes[i].file_time.tv_sec > ts1.tv_sec) || ((p_dfes[i].file_time.tv_sec == ts1.tv_sec) && (p_dfes[i].file_time.tv_nsec >= ts1.tv_nsec));
            c2 = (p_dfes[i].file_time.tv_sec < ts2.tv_sec) || ((p_dfes[i].file_time.tv_sec == ts2.tv_sec) && (p_dfes[i].file_time.tv_nsec <= ts2.tv_nsec));
            if (c1 && c2)
            {

                memcpy(p_dfs[j].name, p_dfes[i].file_name, 64);
                p_dfs[j].file_size = p_dfes[i].file_size;
                p_dfs[j].file_time = p_dfes[i].file_time;
                j++;
            }
        }

        *p_file_cnt = cnt;
    }

    rt_free(p_dfes);

    return p_dfs;
}

/******************************************************************************
函数名称：	hf_get_file_inf_n
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	根据文件名称，获取文件内容,将 文件ID及文件长度赋值 ，返回文件内容指针
参数说明：

            filename : 文件名称
            id           :文件ID ，如何定义，暂时没有规定，可自主定义,保证文件ID的唯一即可，
            filelenth : 文件长度
 返回值:文件内容的指针索引


修改记录：
*/
char *hf_get_file_inf_n(char *file_name, uint32_t *id, int *filelenth)
{
    int fd;
    struct stat s;
    char *p;

    // 获取文件属性
    if (sys_newstat(file_name, &s))
    {
        rt_printf("%s: sys_newstat(%s)error \n", __func__, file_name);
        return NULL;
    }
#ifdef HISFILE_ID
    *id = (uint32_t)s.st_ino;
#else
    *id = 0; // 将文件ID默认为 0
#endif

    *filelenth = (int)s.st_size;

    fd = sys_open(file_name, O_RDONLY, 0);
    if (fd < 0)
    {
        rt_printf("%s:sys_open(%s)error \n", __func__, file_name);
        return NULL;
    }

    p = rt_malloc(s.st_size);
    if (!p)
    {
        sys_close(fd);
        return NULL;
    }

    if (sys_read(fd, p, s.st_size) != s.st_size)
    {
        rt_printf("%s:sys_read error \n", __func__);
        rt_free(p);
        sys_close(fd);
        return NULL;
    }

    sys_close(fd);

    return p;
}

/******************************************************************************
函数名称：	hf_init
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	初始化历史文件
参数说明：

 返回值:成功返回0,失败返回-1；


修改记录：
*/
int hf_init(void)
{

    rt_file_mkdir(HF_HISTORY_DIR);
    rt_file_mkdir(HF_SOE_101_DIR);
    rt_file_mkdir(HF_CO_101_DIR);
    rt_file_mkdir(HF_EXV_101_DIR);
    rt_file_mkdir(HF_FIXPT_101_DIR);
    rt_file_mkdir(HF_FRZ_101_DIR);
    rt_file_mkdir(HF_FLOWREV_101_DIR);
    rt_file_mkdir(HF_LOG_101_DIR);
#ifdef HISTORY_EVENT_EXT
    rt_file_mkdir(HF_SOECOS_101_DIR);
#endif
    // 录波文件目录HF_WAVE_DIR在录波文件实现文件Record.c中创建

    rt_file_mkdir(HF_HISTORY_DB_INFO);

    return 0;
}

/******************************************************************************
函数名称：	hf_init
函数版本：	01.01
创建作者：
创建日期：	2016-08-09
函数说明：	初始化历史文件
参数说明：

 返回值:成功返回0,失败返回-1；


修改记录：
*/
int hf_exit(void)
{
    return 0;
}

void testhf(void)
{

    struct dir_file_struct *p_dfs;
    int file_cnt;
    struct rtc_time_t tm;
    int i;

    p_dfs = hf_get_dir_file(HF_FIXPT_101_DIR, &file_cnt);

    if (p_dfs)
    {
        rt_printf("目录%s\r\n", HF_FIXPT_101_DIR);
        rt_printf("文件个数:%d  p=%p\r\n", file_cnt, p_dfs);
        for (i = 0; i < file_cnt; i++)
        {
            rt_printf("文件名称:%d\r\n", p_dfs[i].file_name);
            rt_printf("名称:%s\r\n", p_dfs[i].name);

            rt_printf("文件大小:%d\r\n", p_dfs[i].file_size);
            timespec_to_rtc(p_dfs[i].file_time, &tm, 0);
            rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n", tm.year, tm.month, tm.day, tm.hour, tm.min, tm.ms / 1000);
        }
        rt_printf("\r\n\r\n");
        rt_free(p_dfs);
    }
#if 0
	

	struct dir_file_ext_struct *p_dfs;
	int file_cnt;
	struct rtc_time_t tm;	
	int i;
	p_dfs=hf_get_dir_file_ext("/app/data/rec_wave/", &file_cnt, "/tmp/123");

	if(p_dfs)
	{
		
		rt_printf("目录%s\r\n", "/app/data/rec_wave/");
		rt_printf("文件个数:%d\r\n", file_cnt);
		for(i=0;i<file_cnt;i++)
		{
			
			rt_printf("文件名称:%s\r\n", p_dfs[i].file_name);
			rt_printf("文件大小:%d\r\n", p_dfs[i].file_size);
			timespec_to_rtc(p_dfs[i].file_time, &tm, 0);
			rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
			rt_printf("\r\n\r\n");
		}
		rt_free(p_dfs);
	}
#endif
#if 0
	struct dir_file_struct *p_dfs;
	int file_cnt;
	char tmp[128];

	struct timespec ts;
	struct rtc_time_t tm;	
	char *p;
	
	
	int  part_len=0;
	int len = 0;


	len=hf_get_file_inf(HF_SOE_101_DIR, 20, &part_len);
	rt_printf("%s  len=%d, part_len=%d\r\n", HF_SOE_101_DIR, len, part_len);

	len=hf_get_file_inf(HF_CO_101_DIR, 21, &part_len);
	rt_printf("%s  len=%d, part_len=%d\r\n", HF_CO_101_DIR, len, part_len);

	len=hf_get_file_inf(HF_EXV_101_DIR, 112, &part_len);
	rt_printf("%s  len=%d, part_len=%d\r\n", HF_EXV_101_DIR, len, part_len);

	len=hf_get_file_inf(HF_FIXPT_101_DIR, 23, &part_len);
	rt_printf("%s  len=%d, part_len=%d\r\n", HF_FIXPT_101_DIR, len, part_len);	
		
	len=hf_get_file_inf(HF_WAVE_DIR, 0x010A , &part_len);
	rt_printf("%s  len=%d, part_len=%d\r\n", HF_WAVE_DIR, len, part_len);
#endif
#if 0
	p_dfs=hf_get_dir_file(HF_SOE_101_DIR, &file_cnt);

	if(p_dfs)
	{
		rt_printf("目录%s\r\n", HF_SOE_101_DIR);
		rt_printf("文件个数:%d\r\n", file_cnt);
		rt_printf("文件名称:%d\r\n", p_dfs->file_name);
		rt_printf("文件大小:%d\r\n", p_dfs->file_size);
		timespec_to_rtc(p_dfs->file_time, &tm, 0);
		rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		rt_printf("\r\n\r\n");
		rt_free(p_dfs);
	}
	
	p_dfs=hf_get_dir_file(HF_SOE_104_DIR, &file_cnt);

	if(p_dfs)
	{
		rt_printf("目录%s\r\n", HF_SOE_104_DIR);
		rt_printf("文件个数:%d\r\n", file_cnt);
		rt_printf("文件名称:%d\r\n", p_dfs->file_name);
		rt_printf("文件大小:%d\r\n", p_dfs->file_size);
		timespec_to_rtc(p_dfs->file_time, &tm, 0);
		rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		rt_printf("\r\n\r\n");
		rt_free(p_dfs);
	}	
	
	p_dfs=hf_get_dir_file(HF_CO_101_DIR, &file_cnt);

	if(p_dfs)
	{
		rt_printf("目录%s\r\n", HF_CO_101_DIR);
		rt_printf("文件个数:%d\r\n", file_cnt);
		rt_printf("文件名称:%d\r\n", p_dfs->file_name);
		rt_printf("文件大小:%d\r\n", p_dfs->file_size);
		timespec_to_rtc(p_dfs->file_time, &tm, 0);
		rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		rt_printf("\r\n\r\n");
		rt_free(p_dfs);
	}	

	p_dfs=hf_get_dir_file(HF_CO_104_DIR, &file_cnt);

	if(p_dfs)
	{
		rt_printf("目录%s\r\n", HF_CO_104_DIR);
		rt_printf("文件个数:%d\r\n", file_cnt);
		rt_printf("文件名称:%d\r\n", p_dfs->file_name);
		rt_printf("文件大小:%d\r\n", p_dfs->file_size);
		timespec_to_rtc(p_dfs->file_time, &tm, 0);
		rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		rt_printf("\r\n\r\n");
		rt_free(p_dfs);
	}	

	p_dfs=hf_get_dir_file(HF_EXV_101_DIR, &file_cnt);

	if(p_dfs)
	{
		rt_printf("目录%s\r\n", HF_EXV_101_DIR);
		rt_printf("文件个数:%d\r\n", file_cnt);
		for(i=0;i<file_cnt;i++)
		{
			rt_printf("文件名称:%d\r\n", p_dfs[i].file_name);
			rt_printf("文件大小:%d\r\n", p_dfs[i].file_size);
			timespec_to_rtc(p_dfs[i].file_time, &tm, 0);
			rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		}
		rt_printf("\r\n\r\n");
		rt_free(p_dfs);
	}	

	p_dfs=hf_get_dir_file(HF_EXV_104_DIR, &file_cnt);

	if(p_dfs)
	{
		rt_printf("目录%s\r\n", HF_EXV_104_DIR);
		rt_printf("文件个数:%d\r\n", file_cnt);
		for(i=0;i<file_cnt;i++)
		{
			rt_printf("文件名称:%d\r\n", p_dfs[i].file_name);
			rt_printf("文件大小:%d\r\n", p_dfs[i].file_size);
			timespec_to_rtc(p_dfs[i].file_time, &tm, 0);
			rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		}
		rt_printf("\r\n\r\n");
		rt_free(p_dfs);
	}	


	p_dfs=hf_get_dir_file(HF_FIXPT_101_DIR, &file_cnt);

	if(p_dfs)
	{
		rt_printf("目录%s\r\n", HF_FIXPT_101_DIR);
		rt_printf("文件个数:%d\r\n", file_cnt);
		for(i=0;i<file_cnt;i++)
		{
			rt_printf("文件名称:%d\r\n", p_dfs[i].file_name);
			rt_printf("文件大小:%d\r\n", p_dfs[i].file_size);
			timespec_to_rtc(p_dfs[i].file_time, &tm, 0);
			rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		}
		rt_printf("\r\n\r\n");
		rt_free(p_dfs);
	}	


	p_dfs=hf_get_dir_file(HF_FIXPT_104_DIR, &file_cnt);

	if(p_dfs)
	{
		rt_printf("目录%s\r\n", HF_FIXPT_104_DIR);
		rt_printf("文件个数:%d\r\n", file_cnt);
		for(i=0;i<file_cnt;i++)
		{
			rt_printf("文件名称:%d\r\n", p_dfs[i].file_name);
			rt_printf("文件大小:%d\r\n", p_dfs[i].file_size);
			timespec_to_rtc(p_dfs[i].file_time, &tm, 0);
			rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu \r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000);
		}
		rt_printf("\r\n\r\n");
		rt_free(p_dfs);
	}	

	p_dfs=hf_get_dir_file(HF_WAVE_DIR, &file_cnt);

	if(p_dfs)
	{
		rt_printf("目录%s\r\n", HF_WAVE_DIR);
		rt_printf("文件个数:%d\r\n", file_cnt);
		for(i=0;i<file_cnt;i++)
		{
			rt_printf("文件名称:%d\r\n", p_dfs[i].file_name);
			rt_printf("文件大小:%d\r\n", p_dfs[i].file_size);
			timespec_to_rtc(p_dfs[i].file_time, &tm, 0);
			rt_printf("创建时间:20%02hu-%02hu-%02hu %02hu:%02hu:%02hu  %02hu\r\n",tm.year,tm.month,tm.day,tm.hour,tm.min,tm.ms/1000, tm.ms%1000);
		}
		rt_printf("\r\n\r\n");
		rt_free(p_dfs);
	}


	int part_len=0;
	int i=0;
	char *p;
	p=hf_get_file_part(HF_SOE_101_DIR, HF_SOE_FILENAME_N, 1, &part_len);
	if(p)
	{
		rt_printf("%s\r\n", HF_SOE_101_DIR);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}
	
	p=hf_get_file_part(HF_SOE_104_DIR, HF_SOE_FILENAME_N, 1, &part_len);
	if(p)
	{
		rt_printf("%s\r\n", HF_SOE_104_DIR);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}


	p=hf_get_file_part(HF_CO_101_DIR, HF_YK_FILENAME_N, 1, &part_len);
	if(p)
	{
		rt_printf("%s\r\n", HF_CO_101_DIR);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}
	
	p=hf_get_file_part(HF_CO_104_DIR, HF_YK_FILENAME_N, 1, &part_len);
	if(p)
	{
		rt_printf("%s\r\n", HF_CO_104_DIR);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}	


	p=hf_get_file_part(HF_EXV_101_DIR, HF_EXV_FILENAME_N, 1, &part_len);
	if(p)
	{
		rt_printf("%s%d%s\r\n", HF_EXV_101_DIR, HF_EXV_FILENAME_N,HF_EXV_FILENAME);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}	

	p=hf_get_file_part(HF_EXV_104_DIR, 112, 1, &part_len);
	if(p)
	{
		rt_printf("%s%d%s\r\n", HF_EXV_104_DIR, HF_EXV_FILENAME_N+4,HF_EXV_FILENAME);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}	

	p=hf_get_file_part(HF_FIXPT_101_DIR, HF_FIXPT_FILENAME_N, 2, &part_len);
	if(p)
	{
		rt_printf("%s%d%s\r\n", HF_FIXPT_101_DIR, HF_FIXPT_FILENAME_N,HF_FIXPT_FILENAME);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}	


	p=hf_get_file_part(HF_FIXPT_104_DIR, 26, 3, &part_len);
	if(p)
	{
		rt_printf("%s%d%s\r\n", HF_FIXPT_104_DIR, HF_FIXPT_FILENAME_N,HF_FIXPT_FILENAME);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}	

	p=hf_get_file_part(HF_WAVE_DIR, 267, 1, &part_len);
	if(p)
	{
		rt_printf("%s%04x \r\n", HF_WAVE_DIR, 267);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}	

	p=hf_get_file_part(HF_WAVE_DIR, 267, 2, &part_len);
	if(p)
	{
		rt_printf("%s%04x \r\n", HF_WAVE_DIR, 267);
		for(i=0;i<part_len;i++)
		{
			rt_printf("%02x ", p[i]);
		}
		rt_printf("\r\n\r\n");
		rt_free(p);
	}

#endif
}