514 lines
12 KiB
C
514 lines
12 KiB
C
|
||
/*
|
||
* File : rtthread.h
|
||
* This file is part of RT-Thread RTOS
|
||
* COPYRIGHT (C) 2006-2012, RT-Thread Development Team
|
||
*
|
||
* The license and distribution terms for this file may be
|
||
* found in the file LICENSE in this distribution or at
|
||
* http://www.rt-thread.org/license/LICENSE.
|
||
*
|
||
* Change Logs:
|
||
* Date Author Notes
|
||
* 2012-11-27 prife the first version
|
||
*/
|
||
#include <rtthread.h>
|
||
|
||
#include <dfs_fs.h>
|
||
#include <dfs_def.h>
|
||
#include <rtdevice.h>
|
||
//#include "dfs_win32.h"
|
||
|
||
#include <io.h>
|
||
#include <fcntl.h>
|
||
#include <string.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <WinError.h>
|
||
#include <windows.h>
|
||
|
||
/*
|
||
* RT-Thread DFS Interface for win-directory as an disk device
|
||
*/
|
||
#define FILE_PATH_MAX 256 /* the longest file path */
|
||
|
||
#define WIN32_DIRDISK_ROOT "." //"F:\\Project\\svn\\rtt\\trunk\\bsp\\simulator_test"
|
||
|
||
static int win32_result_to_dfs(int res)
|
||
{
|
||
rt_kprintf("win error: %x", res);
|
||
return -1;
|
||
}
|
||
|
||
static int dfs_win32_mount(
|
||
struct dfs_filesystem *fs,
|
||
unsigned long rwflag,
|
||
const void *data)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
static int dfs_win32_unmount(struct dfs_filesystem *fs)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
static int dfs_win32_mkfs(const char *device_name)
|
||
{
|
||
return -DFS_STATUS_ENOSYS;
|
||
}
|
||
|
||
static int dfs_win32_statfs(struct dfs_filesystem *fs,
|
||
struct statfs *buf)
|
||
{
|
||
return -DFS_STATUS_ENOSYS;
|
||
}
|
||
|
||
static char *winpath_dirdup(char *des, const char *src)
|
||
{
|
||
char *path;
|
||
int i = 0;
|
||
|
||
path = rt_malloc(FILE_PATH_MAX);
|
||
if (path == RT_NULL)
|
||
return RT_NULL;
|
||
|
||
strcpy(path, des);
|
||
strcat(path, src);
|
||
|
||
while (1)
|
||
{
|
||
if (path[i] == 0)
|
||
break;
|
||
|
||
if (path[i] == '/')
|
||
path[i] = '\\';
|
||
|
||
i++;
|
||
}
|
||
|
||
return path;
|
||
}
|
||
|
||
static int dfs_win32_open(struct dfs_fd *file)
|
||
{
|
||
int fd;
|
||
int oflag, mode;
|
||
char *file_path;
|
||
int res;
|
||
|
||
oflag = file->flags;
|
||
if (oflag & DFS_O_DIRECTORY) /* operations about dir */
|
||
{
|
||
struct _finddata_t dir;
|
||
int handle;
|
||
int len;
|
||
|
||
file_path = winpath_dirdup(WIN32_DIRDISK_ROOT, file->path);
|
||
|
||
if (oflag & DFS_O_CREAT) /* create a dir*/
|
||
{
|
||
res = CreateDirectory(file_path, NULL);
|
||
if (res == ERROR_ALREADY_EXISTS)
|
||
{
|
||
rt_kprintf("already exists!\n");
|
||
return -DFS_STATUS_EEXIST;
|
||
}
|
||
else if (res == ERROR_PATH_NOT_FOUND)
|
||
{
|
||
rt_kprintf("One or more intermediate directories do not exist!\n");
|
||
return -DFS_STATUS_ENOENT;
|
||
}
|
||
}
|
||
|
||
len = strlen(file_path);
|
||
if (file_path[len - 1] != '\\')
|
||
{
|
||
file_path[len] = '\\';
|
||
file_path[len + 1] = 0;
|
||
}
|
||
|
||
strcat(file_path, "*.*");
|
||
/* _findfirst <20><><EFBFBD>õ<EFBFBD> . */
|
||
if ((handle = _findfirst(file_path, &dir)) == -1)
|
||
{
|
||
rt_free(file_path);
|
||
goto __err;
|
||
}
|
||
|
||
/* save this pointer,will used by dfs_win32_getdents*/
|
||
file->data = handle;
|
||
rt_free(file_path);
|
||
return DFS_STATUS_OK;
|
||
}
|
||
/* regular file operations */
|
||
mode = O_BINARY;
|
||
if (oflag & DFS_O_RDONLY) mode |= O_RDONLY;
|
||
if (oflag & DFS_O_WRONLY) mode |= O_WRONLY;
|
||
if (oflag & DFS_O_RDWR) mode |= O_RDWR;
|
||
/* Opens the file, if it is existing. If not, a new file is created. */
|
||
if (oflag & DFS_O_CREAT) mode |= O_CREAT;
|
||
/* Creates a new file. If the file is existing, it is truncated and overwritten. */
|
||
if (oflag & DFS_O_TRUNC) mode |= O_TRUNC;
|
||
/* Creates a new file. The function fails if the file is already existing. */
|
||
if (oflag & DFS_O_EXCL) mode |= O_EXCL;
|
||
|
||
file_path = winpath_dirdup(WIN32_DIRDISK_ROOT, file->path);
|
||
fd = _open(file_path, mode);
|
||
rt_free(file_path);
|
||
|
||
if (fd < 0)
|
||
goto __err;
|
||
|
||
/* save this pointer, it will be used when calling read()<29><>write(),
|
||
* flush(), seek(), and will be free when calling close()*/
|
||
file->data = (void *)fd;
|
||
file->pos = 0;
|
||
file->size = _lseek(fd, 0, SEEK_END);
|
||
|
||
if (oflag & DFS_O_APPEND)
|
||
{
|
||
file->pos = file->size;
|
||
}
|
||
else
|
||
_lseek(fd, 0, SEEK_SET);
|
||
|
||
return 0;
|
||
|
||
__err:
|
||
return win32_result_to_dfs(GetLastError());
|
||
}
|
||
|
||
static int dfs_win32_close(struct dfs_fd *file)
|
||
{
|
||
int oflag;
|
||
|
||
oflag = file->flags;
|
||
if (oflag & DFS_O_DIRECTORY)
|
||
{
|
||
/* operations about dir */
|
||
if (_findclose(file->data) < 0)
|
||
goto __err;
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* regular file operations */
|
||
if (_close((int)(file->data)) < 0)
|
||
goto __err;
|
||
|
||
return 0;
|
||
|
||
__err:
|
||
return win32_result_to_dfs(GetLastError());
|
||
}
|
||
|
||
static int dfs_win32_ioctl(struct dfs_fd *file, int cmd, void *args)
|
||
{
|
||
return -DFS_STATUS_ENOSYS;
|
||
}
|
||
|
||
static int dfs_win32_read(struct dfs_fd *file, void *buf, rt_size_t len)
|
||
{
|
||
int fd;
|
||
int char_read;
|
||
|
||
fd = (int)(file->data);
|
||
char_read = _read(fd, buf, len);
|
||
if (char_read < 0)
|
||
return win32_result_to_dfs(GetLastError());
|
||
|
||
/* update position */
|
||
file->pos = _lseek(fd, 0, SEEK_CUR);
|
||
return char_read;
|
||
}
|
||
|
||
static int dfs_win32_write(struct dfs_fd *file,
|
||
const void *buf,
|
||
rt_size_t len)
|
||
{
|
||
int fd;
|
||
int char_write;
|
||
|
||
fd = (int)(file->data);
|
||
|
||
char_write = _write(fd, buf, len);
|
||
if (char_write < 0)
|
||
return win32_result_to_dfs(GetLastError());
|
||
|
||
/* update position */
|
||
file->pos = _lseek(fd, 0, SEEK_CUR);
|
||
return char_write;
|
||
}
|
||
|
||
static int dfs_win32_flush(struct dfs_fd *file)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
static int dfs_win32_seek(struct dfs_fd *file,
|
||
rt_off_t offset)
|
||
{
|
||
int result;
|
||
|
||
/* set offset as current offset */
|
||
if (file->type == FT_DIRECTORY)
|
||
{
|
||
return -DFS_STATUS_ENOSYS;
|
||
}
|
||
else if (file->type == FT_REGULAR)
|
||
{
|
||
result = _lseek((int)(file->data), offset, SEEK_SET);
|
||
if (result >= 0)
|
||
return offset;
|
||
}
|
||
|
||
return win32_result_to_dfs(GetLastError());
|
||
}
|
||
|
||
/* return the size of struct dirent*/
|
||
static int dfs_win32_getdents(
|
||
struct dfs_fd *file,
|
||
struct dirent *dirp,
|
||
rt_uint32_t count)
|
||
{
|
||
rt_uint32_t index;
|
||
struct dirent *d;
|
||
struct _finddata_t fileinfo;
|
||
int handle;
|
||
int result;
|
||
|
||
handle = (int)(file->data);
|
||
RT_ASSERT(handle != RT_NULL);
|
||
|
||
/* round count, count is always 1 */
|
||
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
|
||
if (count == 0) return -DFS_STATUS_EINVAL;
|
||
|
||
index = 0;
|
||
/* usually, the while loop should only be looped only once! */
|
||
while (1)
|
||
{
|
||
d = dirp + index;
|
||
if (_findnext(handle, &fileinfo) != 0) //-1 failed
|
||
goto __err;
|
||
|
||
if (fileinfo.attrib & _A_SUBDIR)
|
||
d->d_type = DFS_DT_DIR; /* directory */
|
||
else
|
||
d->d_type = DFS_DT_REG;
|
||
|
||
/* write the rest args of struct dirent* dirp */
|
||
d->d_namlen = strlen(fileinfo.name);
|
||
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
|
||
strcpy(d->d_name, fileinfo.name);
|
||
|
||
index ++;
|
||
if (index * sizeof(struct dirent) >= count)
|
||
break;
|
||
}
|
||
if (index == 0)
|
||
return 0;
|
||
|
||
file->pos += index * sizeof(struct dirent);
|
||
|
||
return index * sizeof(struct dirent);
|
||
|
||
__err:
|
||
if ((result = GetLastError()) == ERROR_NO_MORE_FILES)
|
||
return 0;
|
||
else
|
||
return win32_result_to_dfs(result);
|
||
}
|
||
|
||
static int dfs_win32_unlink(struct dfs_filesystem *fs, const char *path)
|
||
{
|
||
int result;
|
||
char *fp;
|
||
fp = winpath_dirdup(WIN32_DIRDISK_ROOT, path);
|
||
if (fp == RT_NULL)
|
||
{
|
||
rt_kprintf("out of memory.\n");
|
||
return -DFS_STATUS_ENOMEM;
|
||
}
|
||
|
||
result = GetFileAttributes(fp);
|
||
if (result == INVALID_FILE_ATTRIBUTES)
|
||
goto __err;
|
||
|
||
if (result & FILE_ATTRIBUTE_DIRECTORY)//winnt.h
|
||
{
|
||
if (RemoveDirectory(fp) == RT_FALSE)
|
||
goto __err;
|
||
}
|
||
else //(result & FILE_ATTRIBUTE_NORMAL)
|
||
{
|
||
if (_unlink(fp) < 0)
|
||
goto __err;
|
||
}
|
||
|
||
rt_free(fp);
|
||
return 0;
|
||
__err:
|
||
rt_free(fp);
|
||
return win32_result_to_dfs(GetLastError());
|
||
}
|
||
|
||
static int dfs_win32_rename(
|
||
struct dfs_filesystem *fs,
|
||
const char *oldpath,
|
||
const char *newpath)
|
||
{
|
||
int result;
|
||
char *op, *np;
|
||
op = winpath_dirdup(WIN32_DIRDISK_ROOT, oldpath);
|
||
np = winpath_dirdup(WIN32_DIRDISK_ROOT, newpath);
|
||
if (op == RT_NULL || np == RT_NULL)
|
||
{
|
||
rt_kprintf("out of memory.\n");
|
||
return -DFS_STATUS_ENOMEM;
|
||
}
|
||
|
||
/* If the function fails, the return value is zero. */
|
||
result = MoveFile(op, np);
|
||
|
||
rt_free(op);
|
||
rt_free(np);
|
||
|
||
if (result == 0)
|
||
return win32_result_to_dfs(GetLastError());
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int dfs_win32_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
|
||
{
|
||
WIN32_FIND_DATA fileInfo;
|
||
HANDLE hFind;
|
||
char *fp;
|
||
fp = winpath_dirdup(WIN32_DIRDISK_ROOT, path);
|
||
if (fp == RT_NULL)
|
||
{
|
||
rt_kprintf("out of memory.\n");
|
||
return -DFS_STATUS_ENOMEM;
|
||
}
|
||
|
||
hFind = FindFirstFile(fp, &fileInfo);
|
||
rt_free(fp);
|
||
|
||
if (hFind == INVALID_HANDLE_VALUE)
|
||
goto __err;
|
||
|
||
st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH |
|
||
DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH;
|
||
|
||
/* convert file info to dfs stat structure */
|
||
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
||
{
|
||
st->st_mode &= ~DFS_S_IFREG;
|
||
st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH;
|
||
}
|
||
|
||
st->st_dev = 0;
|
||
st->st_size = fileInfo.nFileSizeLow;
|
||
st->st_mtime = 0;
|
||
st->st_blksize = 0;
|
||
|
||
FindClose(hFind);
|
||
|
||
return 0;
|
||
|
||
__err:
|
||
return win32_result_to_dfs(GetLastError());
|
||
}
|
||
|
||
static const struct dfs_filesystem_operation dfs_win32_ops =
|
||
{
|
||
"wdir", /* file system type: dir */
|
||
DFS_FS_FLAG_DEFAULT,
|
||
dfs_win32_mount,
|
||
dfs_win32_unmount,
|
||
dfs_win32_mkfs,
|
||
dfs_win32_statfs,
|
||
|
||
dfs_win32_open,
|
||
dfs_win32_close,
|
||
dfs_win32_ioctl,
|
||
dfs_win32_read,
|
||
dfs_win32_write,
|
||
dfs_win32_flush,
|
||
dfs_win32_seek,
|
||
dfs_win32_getdents,
|
||
dfs_win32_unlink,
|
||
dfs_win32_stat,
|
||
dfs_win32_rename,
|
||
};
|
||
|
||
int dfs_win32_init(void)
|
||
{
|
||
/* register uffs file system */
|
||
dfs_register(&dfs_win32_ops);
|
||
|
||
return 0;
|
||
}
|
||
|
||
static rt_err_t nop_init(rt_device_t dev)
|
||
{
|
||
return RT_EOK;
|
||
}
|
||
|
||
static rt_err_t nop_open(rt_device_t dev, rt_uint16_t oflag)
|
||
{
|
||
return RT_EOK;
|
||
}
|
||
|
||
static rt_err_t nop_close(rt_device_t dev)
|
||
{
|
||
return RT_EOK;
|
||
}
|
||
|
||
static rt_size_t nop_read(rt_device_t dev,
|
||
rt_off_t pos,
|
||
void *buffer,
|
||
rt_size_t size)
|
||
{
|
||
return size;
|
||
}
|
||
|
||
static rt_size_t nop_write(rt_device_t dev,
|
||
rt_off_t pos,
|
||
const void *buffer,
|
||
rt_size_t size)
|
||
{
|
||
return size;
|
||
}
|
||
|
||
static rt_err_t nop_control(rt_device_t dev, rt_uint8_t cmd, void *args)
|
||
{
|
||
return RT_EOK;
|
||
}
|
||
|
||
static struct rt_device win_sharedir_dev;
|
||
rt_err_t rt_win_sharedir_init(const char *name)
|
||
{
|
||
rt_device_t dev;
|
||
|
||
dev = &win_sharedir_dev;
|
||
RT_ASSERT(dev != RT_NULL);
|
||
|
||
/* set device class and generic device interface */
|
||
dev->type = RT_Device_Class_Block;
|
||
dev->init = nop_init;
|
||
dev->open = nop_open;
|
||
dev->read = nop_read;
|
||
dev->write = nop_write;
|
||
dev->close = nop_close;
|
||
dev->control = nop_control;
|
||
|
||
dev->rx_indicate = RT_NULL;
|
||
dev->tx_complete = RT_NULL;
|
||
|
||
/* register to RT-Thread device system */
|
||
return rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
|
||
}
|