static void copydir(const char * src, const char * dst)
{
struct dirent dirent;
struct stat stat;
int length;
if (dfs_file_open(&fd, src, DFS_O_DIRECTORY) < 0)
{
rt_kprintf("open %s failed\n", src);
return ;
}
do
{
rt_memset(&dirent, 0, sizeof(struct dirent));
length = dfs_file_getdents(&fd, &dirent, sizeof(struct dirent));
if (length > 0)
{
char * src_entry_full = RT_NULL;
char * dst_entry_full = RT_NULL;
if (strcmp(dirent.d_name, "..") == 0 || strcmp(dirent.d_name, ".") == 0)
continue;
/* build full path for each file */
if ((src_entry_full = dfs_normalize_path(src, dirent.d_name)) == RT_NULL)
{
rt_kprintf("out of memory!\n");
break;
}
if ((dst_entry_full = dfs_normalize_path(dst, dirent.d_name)) == RT_NULL)
{
rt_kprintf("out of memory!\n");
rt_free(src_entry_full);
break;
}
rt_memset(&stat, 0, sizeof(struct stat));
if (dfs_file_stat(src_entry_full, &stat) != 0)
{
rt_kprintf("open file: %s failed\n", dirent.d_name);
continue;
}
if (DFS_S_ISDIR(stat.st_mode))
{
mkdir(dst_entry_full, 0);
copydir(src_entry_full, dst_entry_full);
}
else
{
copyfile(src_entry_full, dst_entry_full);
}
rt_free(src_entry_full);
rt_free(dst_entry_full);
}
}while(length > 0);
dfs_file_close(&fd);
}
/**
* this function will rename an old path name to a new path name.
*
* @param oldpath the old path name.
* @param newpath the new path name.
*
* @return 0 on successful, -1 on failed.
*/
int dfs_file_rename(const char *oldpath, const char *newpath)
{
int result;
struct dfs_filesystem *oldfs, *newfs;
char *oldfullpath, *newfullpath;
result = DFS_STATUS_OK;
newfullpath = RT_NULL;
oldfullpath = RT_NULL;
oldfullpath = dfs_normalize_path(RT_NULL, oldpath);
if (oldfullpath == RT_NULL)
{
result = -DFS_STATUS_ENOENT;
goto __exit;
}
newfullpath = dfs_normalize_path(RT_NULL, newpath);
if (newfullpath == RT_NULL)
{
result = -DFS_STATUS_ENOENT;
goto __exit;
}
oldfs = dfs_filesystem_lookup(oldfullpath);
newfs = dfs_filesystem_lookup(newfullpath);
if (oldfs == newfs)
{
if (oldfs->ops->rename == RT_NULL)
{
result = -DFS_STATUS_ENOSYS;
}
else
{
if (oldfs->ops->flags & DFS_FS_FLAG_FULLPATH)
result = oldfs->ops->rename(oldfs, oldfullpath, newfullpath);
else
/* use sub directory to rename in file system */
result = oldfs->ops->rename(oldfs,
dfs_subdir(oldfs->path, oldfullpath),
dfs_subdir(newfs->path, newfullpath));
}
}
else
{
result = -DFS_STATUS_EXDEV;
}
__exit:
rt_free(oldfullpath);
rt_free(newfullpath);
/* not at same file system, return EXDEV */
return result;
}
/**
* this funciton will rename an old path name to a new path name.
*
* @param oldpath the old path name.
* @param newpath the new path name.
*
* @return 0 on successful, -1 on failed.
*/
int dfs_file_rename(const char* oldpath, const char* newpath)
{
int result;
struct dfs_filesystem *oldfs, *newfs;
char *oldfullpath, *newfullpath;
result = DFS_STATUS_OK;
oldfullpath = dfs_normalize_path(RT_NULL, oldpath);
if ( oldfullpath == RT_NULL )
{
result = -DFS_STATUS_ENOENT;
goto __exit;
}
newfullpath = dfs_normalize_path(RT_NULL, newpath);
if ( newfullpath == RT_NULL )
{
result = -DFS_STATUS_ENOENT;
goto __exit;
}
if ( (oldfs = dfs_filesystem_lookup(oldfullpath)) == RT_NULL )
{
result = -DFS_STATUS_ENOENT;
goto __exit;
}
if ( (newfs = dfs_filesystem_lookup(newfullpath)) == RT_NULL )
{
result = -DFS_STATUS_ENOENT;
goto __exit;
}
if ( oldfs == newfs )
{
if ( oldfs->ops->rename == RT_NULL )
{
result = -DFS_STATUS_ENOSYS;
goto __exit;
}
result = oldfs->ops->rename(oldfs, oldfullpath, newfullpath);
goto __exit;
}
result = -DFS_STATUS_EXDEV;
__exit:
rt_free(oldfullpath);
rt_free(newfullpath);
/* not at same file system, return EXDEV */
return result;
}
/**
* this function will get file information.
*
* @param path the file path.
* @param buf the data buffer to save stat description.
*
* @return 0 on successful, -1 on failed.
*/
int dfs_file_stat(const char *path, struct stat *buf)
{
int result;
char* fullpath;
struct dfs_filesystem* fs;
fullpath = dfs_normalize_path(RT_NULL, path);
if ( fullpath == RT_NULL )
{
return -1;
}
if ((fs = dfs_filesystem_lookup(fullpath)) == RT_NULL)
{
dfs_log(DFS_DEBUG_ERROR, ("can't find mounted filesystem on this path:%s", fullpath));
rt_free(fullpath);
return -DFS_STATUS_ENOENT;
}
if (fullpath[0] == '/' && fullpath[1] == '\0')
{
/* it's the root directory */
buf->st_dev = 0;
buf->st_mode = DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH |
DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH;
buf->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH;
buf->st_size = 0;
buf->st_mtime = 0;
buf->st_blksize = 512;
/* release full path */
rt_free(fullpath);
return DFS_STATUS_OK;
}
/* get the real file path */
if (fs->ops->stat == RT_NULL)
{
rt_free(fullpath);
dfs_log(DFS_DEBUG_ERROR, ("the filesystem didn't implement this function"));
return -DFS_STATUS_ENOSYS;
}
if (dfs_subdir(fs->path, fullpath) == RT_NULL)
result = fs->ops->stat(fs, "/", buf);
else
result = fs->ops->stat(fs, dfs_subdir(fs->path, fullpath), buf);
rt_free(fullpath);
return result;
}
/**
* @ingroup Fd
*
* This function will return whether this file has been opend.
*
* @param pathname the file path name.
*
* @return 0 on file has been open successfully, -1 on open failed.
*/
int fd_is_open(const char *pathname)
{
char *fullpath;
unsigned int index;
struct dfs_filesystem *fs;
struct dfs_fd *fd;
fullpath = dfs_normalize_path(RT_NULL, pathname);
if (fullpath != RT_NULL)
{
char *mountpath;
fs = dfs_filesystem_lookup(fullpath);
if (fs == RT_NULL)
{
/* can't find mounted file system */
rt_free(fullpath);
return -1;
}
/* get file path name under mounted file system */
if (fs->path[0] == '/' && fs->path[1] == '\0')
mountpath = fullpath;
else
mountpath = fullpath + strlen(fs->path);
dfs_lock();
for (index = 0; index < DFS_FD_MAX; index++)
{
fd = &(fd_table[index]);
if (fd->fs == RT_NULL)
continue;
if (fd->fs == fs && strcmp(fd->path, mountpath) == 0)
{
/* found file in file descriptor table */
rt_free(fullpath);
dfs_unlock();
return 0;
}
}
dfs_unlock();
rt_free(fullpath);
}
return -1;
}
int ui_calibration(int argc, char** argv)
{
gui_msg_t msg;
char *fullpath;
if(argc != 2)
{
return -1;
}
fullpath = dfs_normalize_path(NULL, argv[1]);
msg.cmd = 2;
msg.exec = GUI_AppAutoCalibration;
msg.parameter = (void *)fullpath;
rt_mq_send(guimq, &msg, sizeof(msg));
return 0;
}
/**
* this function will unlink (remove) a specified path file from file system.
*
* @param path the specified path file to be unlinked.
*
* @return 0 on successful, -1 on failed.
*/
int dfs_file_unlink(const char *path)
{
int result;
char *fullpath;
struct dfs_filesystem *fs;
/* Make sure we have an absolute path */
fullpath = dfs_normalize_path(RT_NULL, path);
if (fullpath == RT_NULL)
{
return -DFS_STATUS_EINVAL;
}
/* get filesystem */
if ((fs = dfs_filesystem_lookup(fullpath)) == RT_NULL)
{
result = -DFS_STATUS_ENOENT;
goto __exit;
}
/* Check whether file is already open */
if (fd_is_open(fullpath) == 0)
{
result = -DFS_STATUS_EBUSY;
goto __exit;
}
if (fs->ops->unlink != RT_NULL)
{
if (!(fs->ops->flags & DFS_FS_FLAG_FULLPATH))
{
if (dfs_subdir(fs->path, fullpath) == RT_NULL)
result = fs->ops->unlink(fs, "/");
else
result = fs->ops->unlink(fs, dfs_subdir(fs->path, fullpath));
}
else
result = fs->ops->unlink(fs, fullpath);
}
else result = -DFS_STATUS_ENOSYS;
__exit:
rt_free(fullpath);
return result;
}
/**
* This function will do a executable program with main function and parameters.
*
* @param path the full path of application module
* @param cmd_line the command line of program
* @param size the size of command line of program
*
* @return the module object
*/
rt_module_t rt_module_exec_cmd(const char *path, const char* cmd_line, int line_size)
{
struct dfs_filesystem *fs;
appentry_t fptr;
HINSTANCE hinstlib;
rt_module_t module;
char * winpath = RT_NULL;
char * name = RT_NULL;
char *full_path = RT_NULL;
RT_DEBUG_NOT_IN_INTERRUPT;
/* check parameters */
RT_ASSERT(path != RT_NULL);
if (*path != '/')
{
full_path = dfs_normalize_path(RT_NULL, path);
}
else
{
full_path = (const char*)path;
}
/* app module should only in DFS_WIN32 */
fs = dfs_filesystem_lookup(full_path);
if ((fs == RT_NULL) || (strcmp(fs->ops->name,"wdir") != 0))
{
rt_kprintf("invalid path: %s\n", path);
goto __exit;
}
/* change path */
// len = strlen(full_path + 1);
if ((winpath = dfs_win32_dirdup((char *)full_path)) == RT_NULL)
{
rt_kprintf("out of memory, exit", path);
goto __exit;
}
hinstlib = LoadLibrary(winpath);
if (hinstlib == NULL)
{
rt_kprintf("error: unable to open %s\n", winpath);
goto __exit;
}
fptr = (appentry_t)GetProcAddress(hinstlib, "main");
if (fptr == NULL)
{
rt_kprintf("error: unable to find function in %s\n", winpath);
FreeLibrary(hinstlib);
goto __exit;
}
/* release winpath */
rt_free(winpath);
/* get the name of the module */
name = _module_name(path);
/* allocate module */
module = (struct rt_module *)rt_object_allocate(RT_Object_Class_Module, name);
if (!module)
{
goto __exit;
}
module->nref = 0;
module->module_entry = fptr;
/* init module object container */
rt_module_init_object_container(module);
/* increase module reference count */
module->nref ++;
if (module->module_entry != 0)
{
/* set module argument */
module->module_cmd_line = (rt_uint8_t*)rt_malloc(line_size + 1);
rt_memcpy(module->module_cmd_line, cmd_line, line_size);
module->module_cmd_line[line_size] = '\0';
module->module_cmd_size = line_size;
#ifdef RT_USING_SLAB
/* init module memory allocator */
module->mem_list = RT_NULL;
/* create page array */
module->page_array =
(void *)rt_malloc(PAGE_COUNT_MAX * sizeof(struct rt_page_info));
module->page_cnt = 0;
#endif
/* create module thread */
module->module_thread = rt_thread_create(name,
module_main_entry, module,
2048, RT_THREAD_PRIORITY_MAX - 2, 10);
/* set module id */
module->module_thread->module_id = (void *)module;
module->parent.flag = RT_MODULE_FLAG_WITHENTRY;
/* startup module thread */
rt_thread_startup(module->module_thread);
}
else
{
/* without entry point */
module->parent.flag |= RT_MODULE_FLAG_WITHOUTENTRY;
}
#ifdef RT_USING_HOOK
if (rt_module_load_hook != RT_NULL)
{
rt_module_load_hook(module);
}
#endif
rt_free(name);
return module;
__exit:
if (full_path != path) rt_free(full_path);
if (name != RT_NULL) rt_free(full_path);
if (winpath != RT_NULL)rt_free(winpath);
return RT_NULL;
/* FreeLibrary(hinstlib); */
}
void ls(const char* pathname)
{
struct stat stat;
int length;
char *fullpath, *path;
fullpath = RT_NULL;
if (pathname == RT_NULL)
{
#ifdef DFS_USING_WORKDIR
/* open current working directory */
path = rt_strdup(working_directory);
#else
path = rt_strdup("/");
#endif
if (path == RT_NULL) return ; /* out of memory */
}
else
{
path = (char*)pathname;
}
/* list directory */
if ( dfs_file_open(&fd, path, DFS_O_DIRECTORY) == 0 )
{
rt_kprintf("Directory %s:\n", path);
do
{
rt_memset(&dirent, 0, sizeof(struct dirent));
length = dfs_file_getdents(&fd, &dirent, sizeof(struct dirent));
if ( length > 0 )
{
rt_memset(&stat, 0, sizeof(struct stat));
/* build full path for each file */
fullpath = dfs_normalize_path(path, dirent.d_name);
if (fullpath == RT_NULL) break;
if (dfs_file_stat(fullpath, &stat) == 0)
{
rt_kprintf("%-20s", dirent.d_name);
if ( DFS_S_ISDIR(stat.st_mode))
{
rt_kprintf("%-25s\n", "<DIR>");
}
else
{
rt_kprintf("%-25lu\n", stat.st_size);
}
}
else
rt_kprintf("BAD file: %s\n", dirent.d_name);
rt_free(fullpath);
}
}while(length > 0);
dfs_file_close(&fd);
}
else
{
rt_kprintf("No such directory\n");
}
if (pathname == RT_NULL) rt_free(path);
}
/**
* this function will open a file which specified by path with specified flags.
*
* @param fd the file descriptor pointer to return the corresponding result.
* @param path the spaciefied file path.
* @param flags the flags for open operator.
*
* @return 0 on successful, -1 on failed.
*/
int dfs_file_open(struct dfs_fd* fd, const char *path, int flags)
{
struct dfs_filesystem* fs;
char *fullpath;
int result;
/* parameter check */
if ( fd == RT_NULL ) return -DFS_STATUS_EINVAL;
/* make sure we have an absolute path */
fullpath = dfs_normalize_path(RT_NULL, path);
if (fullpath == RT_NULL)
{
return -1;
}
dfs_log(DFS_DEBUG_INFO, ("open file:%s", fullpath));
/* find filesystem */
fs = dfs_filesystem_lookup(fullpath);
if ( fs == RT_NULL )
{
rt_free(fullpath); /* release path */
return -DFS_STATUS_ENOENT;
}
dfs_log(DFS_DEBUG_INFO, ("open in filesystem:%s", fs->ops->name));
fd->fs = fs;
/* initilize the fd item */
fd->type = FT_REGULAR;
fd->flags = flags;
fd->size = 0;
fd->pos = 0;
if (dfs_subdir(fs->path, fullpath) == RT_NULL)
fd->path = rt_strdup("/");
else
fd->path = rt_strdup(dfs_subdir(fs->path, fullpath));
rt_free(fullpath);
dfs_log(DFS_DEBUG_INFO, ("actul file path: %s\n", fd->path));
/* specific file system open routine */
if (fs->ops->open == RT_NULL)
{
/* clear fd */
rt_free(fd->path);
rt_memset(fd, 0, sizeof(*fd));
return -DFS_STATUS_ENOSYS;
}
if ((result = fs->ops->open(fd)) < 0)
{
/* clear fd */
rt_free(fd->path);
rt_memset(fd, 0, sizeof(*fd));
dfs_log(DFS_DEBUG_INFO, ("open failed"));
return result;
}
fd->flags |= DFS_F_OPEN;
if ( flags & DFS_O_DIRECTORY )
{
fd->type = FT_DIRECTORY;
fd->flags |= DFS_F_DIRECTORY;
}
dfs_log(DFS_DEBUG_INFO, ("open successful"));
return 0;
}
void copy(const char *src, const char *dst)
{
#define FLAG_SRC_TYPE 0x03
#define FLAG_SRC_IS_DIR 0x01
#define FLAG_SRC_IS_FILE 0x02
#define FLAG_SRC_NON_EXSIT 0x00
#define FLAG_DST_TYPE 0x0C
#define FLAG_DST_IS_DIR 0x04
#define FLAG_DST_IS_FILE 0x08
#define FLAG_DST_NON_EXSIT 0x00
struct stat stat;
rt_uint32_t flag = 0;
/* check the staus of src and dst */
if (dfs_file_stat(src, &stat) < 0)
{
rt_kprintf("copy failed, bad %s\n", src);
return;
}
if (DFS_S_ISDIR(stat.st_mode))
flag |= FLAG_SRC_IS_DIR;
else
flag |= FLAG_SRC_IS_FILE;
if (dfs_file_stat(dst, &stat) < 0)
{
flag |= FLAG_DST_NON_EXSIT;
}
else
{
if (DFS_S_ISDIR(stat.st_mode))
flag |= FLAG_DST_IS_DIR;
else
flag |= FLAG_DST_IS_FILE;
}
//2. check status
if ((flag & FLAG_SRC_IS_DIR) && (flag & FLAG_DST_IS_FILE))
{
rt_kprintf("cp faild, cp dir to file is not permitted!\n");
return ;
}
//3. do copy
if (flag & FLAG_SRC_IS_FILE)
{
if (flag & FLAG_DST_IS_DIR)
{
char * fdst;
fdst = dfs_normalize_path(dst, _get_path_lastname(src));
if (fdst == NULL)
{
rt_kprintf("out of memory\n");
return;
}
copyfile(src, fdst);
rt_free(fdst);
}
else
{
copyfile(src, dst);
}
}
else //flag & FLAG_SRC_IS_DIR
{
if (flag & FLAG_DST_IS_DIR)
{
char * fdst;
fdst = dfs_normalize_path(dst, _get_path_lastname(src));
if (fdst == NULL)
{
rt_kprintf("out of memory\n");
return;
}
mkdir(fdst, 0);
copydir(src, fdst);
rt_free(fdst);
}
else if ((flag & FLAG_DST_TYPE) == FLAG_DST_NON_EXSIT)
{
mkdir(dst, 0);
copydir(src, dst);
}
else
{
copydir(src, dst);
}
}
}
