hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added glob handling to qse_fs_cpfile()

Browse Source
This commit is contained in:
hyung-hwan 2016-12-12 16:19:59 +00:00
parent 78600e6edc
commit 7ca53162de
9 changed files with 317 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
qse/cmd/sed/sed.c
View File

@ -855,7 +855,7 @@ static int sed_main (int argc, qse_char_t* argv[])
if (tmpl_tmpfile) if (tmpl_tmpfile)
{ {
qse_fs_delfile (fs, tmpl_tmpfile, 0); qse_fs_rmfile (fs, tmpl_tmpfile, 0);
QSE_MMGR_FREE (qse_sed_getmmgr(sed), tmpl_tmpfile); QSE_MMGR_FREE (qse_sed_getmmgr(sed), tmpl_tmpfile);
} }
print_exec_error (sed); print_exec_error (sed);

76
qse/include/qse/si/fs.h
View File

@ -180,20 +180,24 @@ typedef enum qse_fs_trait_t qse_fs_trait_t;
*/ */
typedef int (*qse_fs_cbs_cp_t) ( typedef int (*qse_fs_cbs_cp_t) (
qse_fs_t* fs, qse_fs_t* fs,
void* ctx const qse_char_t* srcpath,
const qse_char_t* dstpath,
qse_uintmax_t bytes_totoal,
qse_uintmax_t bytes_copied
); );
/** /**
* \return -1 on failure, 0 to skip, 1 to delete * \return -1 on failure, 0 to skip, 1 to delete
*/ */
typedef int (*qse_fs_cbs_del_t) ( typedef int (*qse_fs_cbs_rm_t) (
qse_fs_t* fs, qse_fs_t* fs,
const qse_char_t* path const qse_char_t* path
); );
struct qse_fs_cbs_t struct qse_fs_cbs_t
{ {
qse_fs_cbs_del_t del; qse_fs_cbs_rm_t rm;
qse_fs_cbs_cp_t cp;
}; };
typedef struct qse_fs_cbs_t qse_fs_cbs_t; typedef struct qse_fs_cbs_t qse_fs_cbs_t;
@ -228,51 +232,48 @@ enum qse_fs_cpfile_flag_t
QSE_FS_CPFILE_FORCE = (1 << 2), QSE_FS_CPFILE_FORCE = (1 << 2),
QSE_FS_CPFILE_PRESERVE = (1 << 3), QSE_FS_CPFILE_PRESERVE = (1 << 3),
QSE_FS_CPFILE_REPLACE = (1 << 4), QSE_FS_CPFILE_REPLACE = (1 << 4),
QSE_FS_CPFILE_NOTGTDIR = (1 << 5), /* no target directory */
QSE_FS_CPFILE_SYMLINK = (1 << 15), QSE_FS_CPFILE_SYMLINK = (1 << 15),
QSE_FS_CPFILE_ALL = (QSE_FS_CPFILE_GLOB | QSE_FS_CPFILE_RECURSIVE | QSE_FS_CPFILE_ALL = (QSE_FS_CPFILE_GLOB | QSE_FS_CPFILE_RECURSIVE |
QSE_FS_CPFILE_FORCE | QSE_FS_CPFILE_PRESERVE | QSE_FS_CPFILE_FORCE | QSE_FS_CPFILE_PRESERVE |
QSE_FS_CPFILE_REPLACE | QSE_FS_CPFILE_NOTGTDIR | QSE_FS_CPFILE_REPLACE | QSE_FS_CPFILE_SYMLINK)
QSE_FS_CPFILE_SYMLINK)
}; };
typedef enum qse_fs_cpfile_flag_t qse_fs_cpfile_flag_t; typedef enum qse_fs_cpfile_flag_t qse_fs_cpfile_flag_t;
enum qse_fs_mkdir_flag_t enum qse_fs_mkdir_flag_t
{ {
QSE_FS_MKDIR_PARENT = (1 << 0), QSE_FS_MKDIR_PARENT = (1 << 0),
QSE_FS_MKDIRMBS_PARENT = QSE_FS_MKDIR_PARENT, QSE_FS_MKDIRMBS_PARENT = QSE_FS_MKDIR_PARENT,
QSE_FS_MKDIRWCS_PARENT = QSE_FS_MKDIR_PARENT QSE_FS_MKDIRWCS_PARENT = QSE_FS_MKDIR_PARENT
}; };
typedef enum qse_fs_mkdir_flag_t qse_fs_mkdir_flag_t; typedef enum qse_fs_mkdir_flag_t qse_fs_mkdir_flag_t;
enum qse_fs_delfile_flag_t enum qse_fs_rmfile_flag_t
{ {
QSE_FS_DELFILE_GLOB = (1 << 0), QSE_FS_RMFILE_GLOB = (1 << 0),
QSE_FS_DELFILE_RECURSIVE = (1 << 1), QSE_FS_RMFILE_RECURSIVE = (1 << 1),
QSE_FS_DELFILEMBS_GLOB = QSE_FS_DELFILE_GLOB, QSE_FS_RMFILEMBS_GLOB = QSE_FS_RMFILE_GLOB,
QSE_FS_DELFILEMBS_RECURSIVE = QSE_FS_DELFILE_RECURSIVE, QSE_FS_RMFILEMBS_RECURSIVE = QSE_FS_RMFILE_RECURSIVE,
QSE_FS_DELFILEWCS_GLOB = QSE_FS_DELFILE_GLOB, QSE_FS_RMFILEWCS_GLOB = QSE_FS_RMFILE_GLOB,
QSE_FS_DELFILEWCS_RECURSIVE = QSE_FS_DELFILE_RECURSIVE QSE_FS_RMFILEWCS_RECURSIVE = QSE_FS_RMFILE_RECURSIVE
}; };
typedef enum qse_fs_delfile_flag_t qse_fs_delfile_flag_t; typedef enum qse_fs_rmfile_flag_t qse_fs_rmfile_flag_t;
enum qse_fs_deldir_flag_t enum qse_fs_rmdir_flag_t
{ {
QSE_FS_DELDIR_GLOB = (1 << 0), QSE_FS_RMDIR_GLOB = (1 << 0),
QSE_FS_DELDIR_RECURSIVE = (1 << 1), QSE_FS_RMDIR_RECURSIVE = (1 << 1),
QSE_FS_DELDIRMBS_GLOB = QSE_FS_DELDIR_GLOB, QSE_FS_RMDIRMBS_GLOB = QSE_FS_RMDIR_GLOB,
QSE_FS_DELDIRMBS_RECURSIVE = QSE_FS_DELDIR_RECURSIVE, QSE_FS_RMDIRMBS_RECURSIVE = QSE_FS_RMDIR_RECURSIVE,
QSE_FS_DELDIRWCS_GLOB = QSE_FS_DELDIR_GLOB, QSE_FS_RMDIRWCS_GLOB = QSE_FS_RMDIR_GLOB,
QSE_FS_DELDIRWCS_RECURSIVE = QSE_FS_DELDIR_RECURSIVE QSE_FS_RMDIRWCS_RECURSIVE = QSE_FS_RMDIR_RECURSIVE
}; };
typedef enum qse_fs_deldir_flag_t qse_fs_deldir_flag_t; typedef enum qse_fs_rmdir_flag_t qse_fs_rmdir_flag_t;
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
@ -343,6 +344,10 @@ QSE_EXPORT int qse_fs_pop (
QSE_EXPORT int qse_fs_getattronfd ( QSE_EXPORT int qse_fs_getattronfd (
qse_fs_t* fs, qse_fs_t* fs,
qse_fs_handle_t fd, qse_fs_handle_t fd,
@ -395,9 +400,6 @@ QSE_EXPORT int qse_fs_setattrwcs (
#endif #endif
QSE_EXPORT int qse_fs_move ( QSE_EXPORT int qse_fs_move (
qse_fs_t* fs, qse_fs_t* fs,
const qse_char_t* oldpath, const qse_char_t* oldpath,
@ -405,6 +407,10 @@ QSE_EXPORT int qse_fs_move (
); );
QSE_EXPORT int qse_fs_cpfilembs ( QSE_EXPORT int qse_fs_cpfilembs (
qse_fs_t* fs, qse_fs_t* fs,
const qse_mchar_t* srcpath, const qse_mchar_t* srcpath,
@ -437,25 +443,25 @@ QSE_EXPORT int qse_fs_mkdirwcs (
int flags int flags
); );
QSE_EXPORT int qse_fs_delfilembs ( QSE_EXPORT int qse_fs_rmfilembs (
qse_fs_t* fs, qse_fs_t* fs,
const qse_mchar_t* path, const qse_mchar_t* path,
int flags int flags
); );
QSE_EXPORT int qse_fs_delfilewcs ( QSE_EXPORT int qse_fs_rmfilewcs (
qse_fs_t* fs, qse_fs_t* fs,
const qse_wchar_t* path, const qse_wchar_t* path,
int flags int flags
); );
QSE_EXPORT int qse_fs_deldirmbs ( QSE_EXPORT int qse_fs_rmdirmbs (
qse_fs_t* fs, qse_fs_t* fs,
const qse_mchar_t* path, const qse_mchar_t* path,
int flags int flags
); );
QSE_EXPORT int qse_fs_deldirwcs ( QSE_EXPORT int qse_fs_rmdirwcs (
qse_fs_t* fs, qse_fs_t* fs,
const qse_wchar_t* path, const qse_wchar_t* path,
int flags int flags
@ -463,18 +469,16 @@ QSE_EXPORT int qse_fs_deldirwcs (
#if defined(QSE_CHAR_IS_MCHAR) #if defined(QSE_CHAR_IS_MCHAR)
# define qse_fs_mkdir(fs,path,flags) qse_fs_mkdirmbs(fs,path,flags) # define qse_fs_mkdir(fs,path,flags) qse_fs_mkdirmbs(fs,path,flags)
# define qse_fs_delfile(fs,path,flags) qse_fs_delfilembs(fs,path,flags) # define qse_fs_rmfile(fs,path,flags) qse_fs_rmfilembs(fs,path,flags)
# define qse_fs_deldir(fs,path,flags) qse_fs_deldirmbs(fs,path,flags) # define qse_fs_rmdir(fs,path,flags) qse_fs_rmdirmbs(fs,path,flags)
#else #else
# define qse_fs_mkdir(fs,path,flags) qse_fs_mkdirwcs(fs,path,flags) # define qse_fs_mkdir(fs,path,flags) qse_fs_mkdirwcs(fs,path,flags)
# define qse_fs_delfile(fs,path,flags) qse_fs_delfilewcs(fs,path,flags) # define qse_fs_rmfile(fs,path,flags) qse_fs_rmfilewcs(fs,path,flags)
# define qse_fs_deldir(fs,path,flags) qse_fs_deldirwcs(fs,path,flags) # define qse_fs_rmdir(fs,path,flags) qse_fs_rmdirwcs(fs,path,flags)
#endif #endif
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif

2
qse/lib/http/httpd-proxy.c
View File

@ -1122,7 +1122,7 @@ static int task_init_proxy (qse_httpd_t* httpd, qse_httpd_client_t* client, qse_
/* length must include the parameters also */ /* length must include the parameters also */
proxy->qpath_len_in_reqfwdbuf = QSE_STR_LEN(proxy->reqfwdbuf) - proxy->qpath_pos_in_reqfwdbuf; proxy->qpath_len_in_reqfwdbuf = QSE_STR_LEN(proxy->reqfwdbuf) - proxy->qpath_pos_in_reqfwdbuf;
#if 1 #if 0
{ {
/* EXPERIMENTAL */ /* EXPERIMENTAL */
/* KT FILTERING WORKAROUND POC. KT seems to check the Host: the first packet /* KT FILTERING WORKAROUND POC. KT seems to check the Host: the first packet

513
qse/lib/si/fs-copy.c
View File

@ -46,7 +46,7 @@ struct cpfile_t
typedef struct cpfile_t cpfile_t; typedef struct cpfile_t cpfile_t;
static int merge_dstdir_and_file (qse_fs_t* fs, cpfile_t* cpfile) static int merge_dstdir_and_srcbase (qse_fs_t* fs, cpfile_t* cpfile)
{ {
qse_fs_char_t* fstmp; qse_fs_char_t* fstmp;
@ -65,8 +65,7 @@ static int merge_dstdir_and_file (qse_fs_t* fs, cpfile_t* cpfile)
qse_fs_freefspath (fs, QSE_NULL, cpfile->dst_fspath); qse_fs_freefspath (fs, QSE_NULL, cpfile->dst_fspath);
cpfile->dst_fspath = fstmp; cpfile->dst_fspath = fstmp;
/* TODO: check on the flags to getattrsys()... */ if (qse_fs_getattrsys (fs, cpfile->dst_fspath, &cpfile->dst_attr, QSE_FS_GETATTR_SYMLINK) <= -1)
if (qse_fs_getattrsys (fs, cpfile->dst_fspath, &cpfile->dst_attr, 0) <= -1)
{ {
/* attribute on the new destination is not available */ /* attribute on the new destination is not available */
cpfile->flags &= ~CPFILE_DST_ATTR; cpfile->flags &= ~CPFILE_DST_ATTR;
@ -77,6 +76,7 @@ static int merge_dstdir_and_file (qse_fs_t* fs, cpfile_t* cpfile)
cpfile->flags |= CPFILE_DST_ATTR; cpfile->flags |= CPFILE_DST_ATTR;
} }
cpfile->flags |= CPFILE_DST_FSPATH_MERGED; cpfile->flags |= CPFILE_DST_FSPATH_MERGED;
return 0; return 0;
} }
@ -168,8 +168,12 @@ static int copy_file_in_fs (qse_fs_t* fs, cpfile_t* cpfile)
/* ------------------------------------------------------ */ /* ------------------------------------------------------ */
#else #else
if ((cpfile->flags & QSE_FS_CPFILE_SYMLINK) && cpfile->src_attr.islnk) if ((cpfile->flags & QSE_FS_CPFILE_SYMLINK) && cpfile->src_attr.islnk)
{ {
/* the source file is a symbolic link and the SYMLINK option is on.*/
qse_fs_char_t* tmpbuf; qse_fs_char_t* tmpbuf;
/* TODO: use a static buffer is size is small enough */ /* TODO: use a static buffer is size is small enough */
@ -179,29 +183,67 @@ static int copy_file_in_fs (qse_fs_t* fs, cpfile_t* cpfile)
fs->errnum = QSE_FS_ENOMEM; fs->errnum = QSE_FS_ENOMEM;
return -1; return -1;
} }
QSE_MEMSET (tmpbuf, 0, QSE_SIZEOF(*tmpbuf) * (cpfile->src_attr.size + 1));
if (QSE_READLINK (cpfile->src_fspath, tmpbuf, cpfile->src_attr.size) <= -1 || if (QSE_READLINK (cpfile->src_fspath, tmpbuf, cpfile->src_attr.size) <= -1)
QSE_SYMLINK (tmpbuf, cpfile->dst_fspath) <= -1)
{ {
QSE_MMGR_FREE (fs->mmgr, tmpbuf);
fs->errnum = qse_fs_syserrtoerrnum (fs, errno); fs->errnum = qse_fs_syserrtoerrnum (fs, errno);
QSE_MMGR_FREE (fs->mmgr, tmpbuf);
return -1; return -1;
} }
if (QSE_SYMLINK (tmpbuf, cpfile->dst_fspath) <= -1)
{
if (cpfile->flags & QSE_FS_CPFILE_FORCE)
{
QSE_UNLINK (cpfile->dst_fspath);
if (QSE_SYMLINK (tmpbuf, cpfile->dst_fspath) <= -1)
{
fs->errnum = qse_fs_syserrtoerrnum (fs, errno);
goto oops_1;
}
}
}
if (fs->cbs.cp)
{
qse_char_t* srcpath = QSE_NULL, * dstpath = QSE_NULL;
int x = 1;
srcpath = (qse_char_t*)make_str_with_fspath (fs, cpfile->src_fspath);
dstpath = (qse_char_t*)make_str_with_fspath (fs, cpfile->dst_fspath);
if (srcpath && dstpath)
{
x = fs->cbs.cp (fs, srcpath, dstpath, cpfile->src_attr.size, cpfile->src_attr.size);
}
if (srcpath) free_str_with_fspath (fs, cpfile->src_fspath, srcpath);
if (dstpath) free_str_with_fspath (fs, cpfile->dst_fspath, dstpath);
if (x <= -1) goto oops_1;
}
QSE_MMGR_FREE (fs->mmgr, tmpbuf); QSE_MMGR_FREE (fs->mmgr, tmpbuf);
return 0; return 0;
oops_1:
if (tmpbuf) QSE_MMGR_FREE (fs->mmgr, tmpbuf);
return -1;
} }
else else
{ {
int in = -1, out = -1; int in = -1, out = -1;
qse_ssize_t in_len, out_len; qse_ssize_t in_len, out_len;
qse_uint8_t* bp; qse_uint8_t* bp;
qse_uintmax_t bytes_copied = 0;
qse_char_t* srcpath = QSE_NULL, * dstpath = QSE_NULL;
in = QSE_OPEN (cpfile->src_fspath, O_RDONLY, 0); in = QSE_OPEN (cpfile->src_fspath, O_RDONLY, 0);
if (in <= -1) if (in <= -1)
{ {
fs->errnum = qse_fs_syserrtoerrnum (fs, errno); fs->errnum = qse_fs_syserrtoerrnum (fs, errno);
goto oops; goto oops_2;
} }
out = QSE_OPEN (cpfile->dst_fspath, O_CREAT | O_WRONLY | O_TRUNC, cpfile->src_attr.mode); out = QSE_OPEN (cpfile->dst_fspath, O_CREAT | O_WRONLY | O_TRUNC, cpfile->src_attr.mode);
@ -211,112 +253,73 @@ static int copy_file_in_fs (qse_fs_t* fs, cpfile_t* cpfile)
QSE_UNLINK (cpfile->dst_fspath); QSE_UNLINK (cpfile->dst_fspath);
out = QSE_OPEN (cpfile->dst_fspath, O_CREAT | O_WRONLY | O_TRUNC, cpfile->src_attr.mode); out = QSE_OPEN (cpfile->dst_fspath, O_CREAT | O_WRONLY | O_TRUNC, cpfile->src_attr.mode);
} }
if (out <= -1) if (out <= -1)
{ {
fs->errnum = qse_fs_syserrtoerrnum (fs, errno); fs->errnum = qse_fs_syserrtoerrnum (fs, errno);
goto oops; goto oops_2;
}
if (fs->cbs.cp)
{
srcpath = (qse_char_t*)make_str_with_fspath (fs, cpfile->src_fspath);
dstpath = (qse_char_t*)make_str_with_fspath (fs, cpfile->dst_fspath);
} }
while (1) while (1)
{ {
/* TODO: use vmspliace() and family for faster copying... */
in_len = QSE_READ (in, fs->cpbuf, QSE_SIZEOF(fs->cpbuf)); in_len = QSE_READ (in, fs->cpbuf, QSE_SIZEOF(fs->cpbuf));
if (in_len <= 0) break; if (in_len <= 0)
{
/* TODO: call progress callback */ if (bytes_copied == 0 && srcpath && dstpath)
{
if (fs->cbs.cp (fs, srcpath, dstpath, cpfile->src_attr.size, bytes_copied) <= -1) goto oops_2;
}
break;
}
bp = fs->cpbuf; bp = fs->cpbuf;
while (in_len > 0) while (in_len > 0)
{ {
out_len = QSE_WRITE (out, bp, in_len); out_len = QSE_WRITE (out, bp, in_len);
if (out_len <= -1) goto oops; if (out_len <= -1) goto oops_2;
bp += out_len; bp += out_len;
in_len -= out_len; in_len -= out_len;
bytes_copied += out_len;
}
if (srcpath && dstpath)
{
if (fs->cbs.cp (fs, srcpath, dstpath, cpfile->src_attr.size, bytes_copied) <= -1) goto oops_2;
/* TODO: skip, ignore, etc... */
} }
} }
if (cpfile->flags & QSE_FS_CPFILE_PRESERVE) if (cpfile->flags & QSE_FS_CPFILE_PRESERVE)
{ {
#if defined(HAVE_FUTIMENS) && defined(HAVE_STRUCT_TIMESPEC) if (qse_fs_setattronfd (fs, out, &cpfile->src_attr, QSE_FS_SETATTR_TIME | QSE_FS_SETATTR_OWNER | QSE_FS_SETATTR_MODE) <= -1)
struct timespec ts[2];
#elif defined(HAVE_FUTIMES)
struct timeval tv[2];
#elif defined(HAVE_UTIME)
struct utimbuf ub;
#elif defined(HAVE_UTIMES)
struct timeval tv[2];
#endif
if (QSE_FCHOWN (out, cpfile->src_attr.uid, cpfile->src_attr.gid) <= -1 ||
QSE_FCHMOD (out, cpfile->src_attr.mode) <= -1)
{ {
fs->errnum = qse_fs_syserrtoerrnum (fs, errno); if (fs->errnum == QSE_FS_ENOIMPL)
goto oops;
}
#if defined(HAVE_FUTIMENS) && defined(HAVE_STRUCT_TIMESPEC)
QSE_MEMSET (&ts, 0, QSE_SIZEOF(ts));
ts[0].tv_sec = cpfile->src_attr.atime.sec;
ts[0].tv_nsec = cpfile->src_attr.atime.nsec;
ts[1].tv_sec = cpfile->src_attr.mtime.sec;
ts[1].tv_nsec = cpfile->src_attr.mtime.nsec;
if (QSE_FUTIMENS (out, ts) <= -1)
{ {
fs->errnum = qse_fs_syserrtoerrnum (fs, errno); if (qse_fs_setattrsys (fs, cpfile->dst_fspath, &cpfile->src_attr, QSE_FS_SETATTR_TIME | QSE_FS_SETATTR_OWNER | QSE_FS_SETATTR_MODE) <= -1) goto oops_2;
goto oops;
} }
#elif defined(HAVE_FUTIMES)
QSE_MEMSET (&tv, 0, QSE_SIZEOF(tv));
tv[0].tv_sec = cpfile->src_attr.atime.sec;
tv[0].tv_usec = QSE_NSEC_TO_USEC(cpfile->src_attr.atime.nsec);
tv[1].tv_sec = cpfile->src_attr.mtime.sec;
tv[1].tv_usec = QSE_NSEC_TO_USEC(cpfile->src_attr.mtime.nsec);
if (QSE_FUTIMES (out, tv) <= -1)
{
fs->errnum = qse_fs_syserrtoerrnum (fs, errno);
goto oops;
} }
#elif defined(HAVE_UTIMES)
QSE_MEMSET (&tv, 0, QSE_SIZEOF(tv));
tv[0].tv_sec = cpfile->src_attr.atime.sec;
tv[0].tv_usec = QSE_NSEC_TO_USEC(cpfile->src_attr.atime.nsec);
tv[1].tv_sec = cpfile->src_attr.mtime.sec;
tv[1].tv_usec = QSE_NSEC_TO_USEC(cpfile->src_attr.mtime.nsec);
// work on the file name not on the file descriptor.
if (QSE_UTIMES (cpfile->dst_fspath, tv) <= -1)
{
fs->errnum = qse_fs_syserrtoerrnum (fs, errno);
goto oops;
}
#elif defined(HAVE_UTIME)
QSE_MEMSET (&ub, 0, QSE_SIZEOF(ub));
ub.actime = cpfile->src_attr.atime.sec;
ub.modtime = cpfile->src_attr.mtime.sec;
if (QSE_UTIME (cpfile->dst_fspath, &ub) <= -1)
{
fs->errnum = qse_fs_syserrtoerrnum (fs, errno);
goto oops;
}
#else
# error none of futimens, futimes, utime, utimes exist
#endif
} }
QSE_CLOSE (out); QSE_CLOSE (out);
QSE_CLOSE (in); QSE_CLOSE (in);
if (srcpath) free_str_with_fspath (fs, cpfile->src_fspath, srcpath);
if (dstpath) free_str_with_fspath (fs, cpfile->dst_fspath, dstpath);
return 0; return 0;
oops: oops_2:
if (out >= 0) QSE_CLOSE (out); if (out >= 0) QSE_CLOSE (out);
if (in >= 0) QSE_CLOSE (in); if (in >= 0) QSE_CLOSE (in);
if (srcpath) free_str_with_fspath (fs, cpfile->src_fspath, srcpath);
if (dstpath) free_str_with_fspath (fs, cpfile->dst_fspath, dstpath);
return -1; return -1;
} }
#endif #endif
@ -326,9 +329,9 @@ static int prepare_cpfile (qse_fs_t* fs, cpfile_t* cpfile)
{ {
/* error if the source file can't be stat'ed. /* error if the source file can't be stat'ed.
* ok if the destination file can't be stat'ed */ * ok if the destination file can't be stat'ed */
/* TODO: check on flags to getattrsys() */ /* TODO: check if flags to getattrsys() is correct */
if (qse_fs_getattrsys (fs, cpfile->src_fspath, &cpfile->src_attr, 0) <= -1) return -1; if (qse_fs_getattrsys (fs, cpfile->src_fspath, &cpfile->src_attr, QSE_FS_GETATTR_SYMLINK) <= -1) return -1;
if (qse_fs_getattrsys (fs, cpfile->dst_fspath, &cpfile->dst_attr, 0) >= 0) cpfile->flags |= CPFILE_DST_ATTR; if (qse_fs_getattrsys (fs, cpfile->dst_fspath, &cpfile->dst_attr, QSE_FS_GETATTR_SYMLINK) >= 0) cpfile->flags |= CPFILE_DST_ATTR;
return 0; return 0;
} }
@ -399,7 +402,7 @@ static int copy_file (qse_fs_t* fs, cpfile_t* cpfile)
#else #else
cpfile_t sub_cpfile; cpfile_t sub_cpfile;
#endif #endif
qse_dir_t* dir; qse_dir_t* dir = QSE_NULL;
qse_dir_errnum_t direrr; qse_dir_errnum_t direrr;
qse_dir_ent_t dirent; qse_dir_ent_t dirent;
int x; int x;
@ -408,7 +411,6 @@ start_over:
if (cpfile->src_attr.isdir) if (cpfile->src_attr.isdir)
{ {
/* source is a directory */ /* source is a directory */
copy_dir:
if (cpfile->flags & CPFILE_DST_ATTR) if (cpfile->flags & CPFILE_DST_ATTR)
{ {
if (!cpfile->dst_attr.isdir) if (!cpfile->dst_attr.isdir)
@ -418,23 +420,16 @@ start_over:
goto oops; goto oops;
} }
if (!(cpfile->flags & QSE_FS_CPFILE_NOTGTDIR) && /* the destination is also a directory */
cpfile->dst_attr.isdir) if (cpfile->src_attr.ino == cpfile->dst_attr.ino &&
cpfile->src_attr.dev == cpfile->dst_attr.dev)
{ {
if (cpfile->flags & CPFILE_DST_FSPATH_MERGED) /* cannot copy a directory to itself */
{ fs->errnum = QSE_FS_EINVAL; /* TODO: better error code */
/* merge_dstdir_and_file() has been called already.
* no more getting into a subdirectory */
fs->errnum = QSE_FS_EISDIR;
goto oops; goto oops;
} }
else
{ if (merge_dstdir_and_srcbase (fs, cpfile) <= -1) goto oops;
/* arrange to copy a file into a directory */
if (merge_dstdir_and_file (fs, cpfile) <= -1) return -1;
goto copy_dir;
}
}
/* /*
if (!(cpfile->flags & QSE_FS_CPFILE_REPLACE)) if (!(cpfile->flags & QSE_FS_CPFILE_REPLACE))
@ -466,7 +461,11 @@ start_over:
goto oops; goto oops;
} }
if (qse_fs_sysmkdir (fs, cpfile->dst_fspath) <= -1) goto oops; if (qse_fs_mkdirsys (fs, cpfile->dst_fspath) <= -1)
{
/* it's ok if the destination directory already exists */
if (fs->errnum != QSE_FS_EEXIST) goto oops;
}
while (1) while (1)
{ {
@ -508,17 +507,12 @@ start_over:
if (!sub_cpfile.src_fspath || !sub_cpfile.dst_fspath || prepare_cpfile (fs, &sub_cpfile) <= -1) if (!sub_cpfile.src_fspath || !sub_cpfile.dst_fspath || prepare_cpfile (fs, &sub_cpfile) <= -1)
{ {
clear_cpfile (fs, &sub_cpfile); clear_cpfile (fs, &sub_cpfile);
qse_dir_close (dir); goto oops;
return -1;
} }
x = copy_file (fs, &sub_cpfile); /* TODO: remove recursion */ x = copy_file (fs, &sub_cpfile); /* TODO: remove recursion */
clear_cpfile (fs, &sub_cpfile); clear_cpfile (fs, &sub_cpfile);
if (x <= -1) if (x <= -1) goto oops;
{
qse_dir_close (dir);
return -1;
}
#endif #endif
} }
@ -532,6 +526,8 @@ start_over:
copy_file: copy_file:
if (cpfile->flags & CPFILE_DST_ATTR) if (cpfile->flags & CPFILE_DST_ATTR)
{ {
/* attribute of the destination path is available */
if (cpfile->src_attr.ino == cpfile->dst_attr.ino && if (cpfile->src_attr.ino == cpfile->dst_attr.ino &&
cpfile->src_attr.dev == cpfile->dst_attr.dev) cpfile->src_attr.dev == cpfile->dst_attr.dev)
{ {
@ -540,9 +536,9 @@ start_over:
goto oops; goto oops;
} }
if (!(cpfile->flags & QSE_FS_CPFILE_NOTGTDIR) && if (cpfile->dst_attr.isdir)
cpfile->dst_attr.isdir)
{ {
#if 0
if (cpfile->flags & CPFILE_DST_FSPATH_MERGED) if (cpfile->flags & CPFILE_DST_FSPATH_MERGED)
{ {
/* merge_dstdir_and_file() has been called already. /* merge_dstdir_and_file() has been called already.
@ -552,16 +548,19 @@ start_over:
} }
else else
{ {
#endif
/* arrange to copy a file into a directory */ /* arrange to copy a file into a directory */
if (merge_dstdir_and_file (fs, cpfile) <= -1) return -1; if (merge_dstdir_and_srcbase (fs, cpfile) <= -1) return -1;
goto copy_file; goto copy_file;
#if 0
} }
#endif
} }
if (!(cpfile->flags & QSE_FS_CPFILE_REPLACE)) if (!(cpfile->flags & QSE_FS_CPFILE_REPLACE))
{ {
fs->errnum = QSE_FS_EEXIST; fs->errnum = QSE_FS_EEXIST;
return -1; goto oops;
} }
} }
@ -580,7 +579,6 @@ start_over:
return 0; return 0;
oops: oops:
#if defined(NO_RECURSION) #if defined(NO_RECURSION)
while (fs->cfs) pop_cfs (fs, QSE_NULL, QSE_NULL); while (fs->cfs) pop_cfs (fs, QSE_NULL, QSE_NULL);
@ -589,243 +587,104 @@ oops:
return -1; return -1;
} }
int qse_fs_cpfilembs (qse_fs_t* fs, const qse_mchar_t* srcpath, const qse_mchar_t* dstpath, int flags) /* ========================================================================= */
struct glob_ctx_t
{ {
qse_fs_t* fs;
int flags;
void* dstpath;
int wcs;
};
typedef struct glob_ctx_t glob_ctx_t;
static int copy_file_for_glob (const void* path, void* ctx)
{
glob_ctx_t* gc = (glob_ctx_t*)ctx;
cpfile_t cpfile; cpfile_t cpfile;
int ret; int ret;
QSE_MEMSET (&cpfile, 0, QSE_SIZEOF(cpfile)); QSE_MEMSET (&cpfile, 0, QSE_SIZEOF(cpfile));
cpfile.flags = flags & QSE_FS_CPFILE_ALL; /* keep public flags only */ cpfile.flags = gc->flags & QSE_FS_CPFILE_ALL; /* keep public flags only */
cpfile.src_fspath = (qse_fs_char_t*)qse_fs_dupfspathformbs (fs, srcpath); if (gc->wcs)
cpfile.dst_fspath = (qse_fs_char_t*)qse_fs_dupfspathformbs (fs, dstpath); {
if (!cpfile.src_fspath || !cpfile.dst_fspath || prepare_cpfile (fs, &cpfile) <= -1) goto oops; cpfile.src_fspath = (qse_fs_char_t*)qse_fs_dupfspathforwcs (gc->fs, ((qse_wcstr_t*)path)->ptr);
cpfile.dst_fspath = (qse_fs_char_t*)qse_fs_dupfspathforwcs (gc->fs, gc->dstpath);
}
else
{
cpfile.src_fspath = (qse_fs_char_t*)qse_fs_dupfspathformbs (gc->fs, ((qse_mcstr_t*)path)->ptr);
cpfile.dst_fspath = (qse_fs_char_t*)qse_fs_dupfspathformbs (gc->fs, gc->dstpath);
}
if (!cpfile.src_fspath || !cpfile.dst_fspath || prepare_cpfile (gc->fs, &cpfile) <= -1) goto oops;
ret = copy_file (fs, &cpfile); ret = copy_file (gc->fs, &cpfile);
clear_cpfile (gc->fs, &cpfile);
clear_cpfile (fs, &cpfile);
return ret; return ret;
oops: oops:
clear_cpfile (fs, &cpfile); clear_cpfile (gc->fs, &cpfile);
return -1; return -1;
} }
int qse_fs_cpfilembs (qse_fs_t* fs, const qse_mchar_t* srcpath, const qse_mchar_t* dstpath, int flags)
{
glob_ctx_t ctx;
ctx.fs = fs;
ctx.flags = flags;
ctx.dstpath = (void*)dstpath;
ctx.wcs = 0;
if (flags & QSE_FS_CPFILE_GLOB)
{
if (qse_globmbs (srcpath, copy_file_for_glob, &ctx, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr) <= -1)
{
fs->errnum = QSE_FS_EGLOB;
return -1;
}
return 0;
}
else
{
qse_mcstr_t s;
s.ptr = (qse_mchar_t*)srcpath;
s.len = 0; /* not important */
/* let me use the glob callback function for simplicity */
return copy_file_for_glob (&s, &ctx);
}
}
int qse_fs_cpfilewcs (qse_fs_t* fs, const qse_wchar_t* srcpath, const qse_wchar_t* dstpath, int flags) int qse_fs_cpfilewcs (qse_fs_t* fs, const qse_wchar_t* srcpath, const qse_wchar_t* dstpath, int flags)
{ {
cpfile_t cpfile; glob_ctx_t ctx;
int ret;
QSE_MEMSET (&cpfile, 0, QSE_SIZEOF(cpfile)); ctx.fs = fs;
ctx.flags = flags;
ctx.dstpath = (void*)dstpath;
ctx.wcs = 1;
cpfile.flags = flags & QSE_FS_CPFILE_ALL; /* keep public flags only */ if (flags & QSE_FS_CPFILE_GLOB)
{
cpfile.src_fspath = (qse_fs_char_t*)qse_fs_dupfspathforwcs (fs, srcpath); if (qse_globwcs (srcpath, copy_file_for_glob, &ctx, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr) <= -1)
cpfile.dst_fspath = (qse_fs_char_t*)qse_fs_dupfspathforwcs (fs, dstpath); {
if (!cpfile.src_fspath || !cpfile.dst_fspath || prepare_cpfile (fs, &cpfile) <= -1) goto oops; fs->errnum = QSE_FS_EGLOB;
ret = copy_file (fs, &cpfile);
clear_cpfile (fs, &cpfile);
return ret;
oops:
clear_cpfile (fs, &cpfile);
return -1; return -1;
} }
return 0;
#if 0 }
/* --------------------------------------------------------------------- */ else
/*
* Copyright (c) 1983 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*/
static int copy (const char* from, const char* to)
{ {
int fold, fnew, n, exists; /* let me use the glob callback function for simplicity */
char *last, destname[MAXPATHLEN + 1], buf[MAXBSIZE]; qse_wcstr_t s;
struct stat stfrom, stto; s.ptr = (qse_wchar_t*)srcpath;
s.len = 0; /* not important */
fold = open (from, O_RDONLY); return copy_file_for_glob (&s, &ctx);
if (fold < 0)
{
return -1;
}
if (fstat(fold, &stfrom) < 0)
{
close(fold);
return -1;
}
if (stat(to, &stto) >= 0 && (stto.st_mode&S_IFMT) == S_IFDIR)
{
last = rindex(from, '/');
if (last) last++; else last = from;
if (strlen(to) + strlen(last) >= sizeof(destname) - 1)
{
/* name too long */
close(fold);
return(1);
}
(void) sprintf(destname, "%s/%s", to, last);
to = destname;
}
if (rflag && (stfrom.st_mode&S_IFMT) == S_IFDIR)
{
int fixmode = 0; /* cleanup mode after rcopy */
close(fold);
if (stat(to, &stto) < 0)
{
if (mkdir(to, (stfrom.st_mode & 07777) | 0700) < 0)
{
Perror(to);
return (1);
}
fixmode = 1;
}
else if ((stto.st_mode&S_IFMT) != S_IFDIR)
{
fprintf(stderr, "cp: %s: Not a directory.\n", to);
return (1);
}
else if (pflag)
{
fixmode = 1;
}
n = rcopy(from, to);
if (fixmode) chmod(to, stfrom.st_mode & 07777);
return (n);
}
if ((stfrom.st_mode&S_IFMT) == S_IFDIR)
fprintf(stderr,
"cp: %s: Is a directory (copying as plain file).\n",
from);
exists = stat(to, &stto) == 0;
if (exists)
{
if (stfrom.st_dev == stto.st_dev && stfrom.st_ino == stto.st_ino)
{
fprintf(stderr,
"cp: %s and %s are identical (not copied).\n", from, to);
close(fold);
return (1);
}
if (iflag && isatty(fileno(stdin)))
{
int i, c;
fprintf (stderr, "overwrite %s? ", to);
i = c = getchar();
while (c != '\n' && c != EOF)
c = getchar();
if (i != 'y')
{
close(fold);
return(1);
} }
} }
}
fnew = creat(to, stfrom.st_mode & 07777);
if (fnew < 0)
{
Perror(to);
(void) close(fold);
return(1);
}
if (exists && pflag)
fchmod(fnew, stfrom.st_mode & 07777);
for (;;)
{
/* use vmsplice() to copy??? */
n = read(fold, buf, sizeof buf);
if (n == 0) break;
if (n < 0)
{
Perror(from);
close(fold);
close(fnew);
return (1);
}
if (write(fnew, buf, n) != n)
{
Perror(to);
close(fold);
close(fnew);
return (1);
}
}
close(fold);
close(fnew);
if (pflag) return (setimes(to, &stfrom));
return (0);
}
int rcopy(const char* from, const char* to)
{
DIR *fold = opendir(from);
struct direct *dp;
struct stat statb;
int errs = 0;
char fromname[MAXPATHLEN + 1];
if (fold == 0 || (pflag && fstat(fold->dd_fd, &statb) < 0)) {
Perror(from);
return (1);
}
for (;;)
{
dp = readdir(fold);
if (dp == 0)
{
closedir(fold);
if (pflag) return (setimes(to, &statb) + errs);
return (errs);
}
if (dp->d_ino == 0) continue;
if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) continue;
if (strlen(from)+1+strlen(dp->d_name) >= sizeof fromname - 1)
{
fprintf(stderr, "cp: %s/%s: Name too long.\n", from, dp->d_name);
errs++;
continue;
}
sprintf(fromname, "%s/%s", from, dp->d_name);
errs += copy(fromname, to);
}
}
static int setimes(const char* path, const struct stat* statp)
{
struct timeval tv[2];
tv[0].tv_sec = statp->st_atime;
tv[1].tv_sec = statp->st_mtime;
tv[0].tv_usec = tv[1].tv_usec = 0;
if (utimes(path, tv) < 0)
{
Perror(path);
return (1);
}
return (0);
}
#endif

72
qse/lib/si/fs-delete.c
View File

@ -31,7 +31,7 @@
* qse_dir_xxx() and qse_glob() don't support mbs and wcs separately. * qse_dir_xxx() and qse_glob() don't support mbs and wcs separately.
* while the functions here support them. */ * while the functions here support them. */
int qse_fs_sysrmfile (qse_fs_t* fs, const qse_fs_char_t* fspath) int qse_fs_rmfilesys (qse_fs_t* fs, const qse_fs_char_t* fspath)
{ {
#if defined(_WIN32) #if defined(_WIN32)
@ -74,7 +74,7 @@ int qse_fs_sysrmfile (qse_fs_t* fs, const qse_fs_char_t* fspath)
return 0; return 0;
} }
int qse_fs_sysrmdir (qse_fs_t* fs, const qse_fs_char_t* fspath) int qse_fs_rmdirsys (qse_fs_t* fs, const qse_fs_char_t* fspath)
{ {
#if defined(_WIN32) #if defined(_WIN32)
@ -127,10 +127,10 @@ static int delete_file (qse_fs_t* fs, const qse_char_t* path, int purge)
qse_fs_char_t* fspath; qse_fs_char_t* fspath;
int ret; int ret;
if (fs->cbs.del) if (fs->cbs.rm)
{ {
int x; int x;
x = fs->cbs.del (fs, path); x = fs->cbs.rm (fs, path);
if (x <= -1) return -1; if (x <= -1) return -1;
if (x == 0) return 0; /* skipped */ if (x == 0) return 0; /* skipped */
} }
@ -138,7 +138,7 @@ static int delete_file (qse_fs_t* fs, const qse_char_t* path, int purge)
fspath = qse_fs_makefspath(fs, path); fspath = qse_fs_makefspath(fs, path);
if (!fspath) return -1; if (!fspath) return -1;
ret = qse_fs_sysrmfile (fs, fspath); ret = qse_fs_rmfilesys (fs, fspath);
qse_fs_freefspath (fs, path, fspath); qse_fs_freefspath (fs, path, fspath);
if (ret <= -1 && purge) if (ret <= -1 && purge)
@ -176,7 +176,7 @@ static int delete_directory_nocbs (qse_fs_t* fs, const qse_char_t* path)
fspath = qse_fs_makefspath(fs, path); fspath = qse_fs_makefspath(fs, path);
if (!fspath) return -1; if (!fspath) return -1;
ret = qse_fs_sysrmdir (fs, fspath); ret = qse_fs_rmdirsys (fs, fspath);
qse_fs_freefspath (fs, path, fspath); qse_fs_freefspath (fs, path, fspath);
return ret; return ret;
@ -184,10 +184,10 @@ static int delete_directory_nocbs (qse_fs_t* fs, const qse_char_t* path)
static int delete_directory (qse_fs_t* fs, const qse_char_t* path) static int delete_directory (qse_fs_t* fs, const qse_char_t* path)
{ {
if (fs->cbs.del) if (fs->cbs.rm)
{ {
int x; int x;
x = fs->cbs.del (fs, path); x = fs->cbs.rm (fs, path);
if (x <= -1) return -1; if (x <= -1) return -1;
if (x == 0) return 0; /* skipped */ if (x == 0) return 0; /* skipped */
} }
@ -281,7 +281,7 @@ static int delete_from_fs_with_mbs (qse_fs_t* fs, const qse_mchar_t* path, int d
fspath = qse_fs_makefspathformbs (fs, path); fspath = qse_fs_makefspathformbs (fs, path);
if (!fspath) return -1; if (!fspath) return -1;
if (fs->cbs.del) if (fs->cbs.rm)
{ {
qse_char_t* xpath; qse_char_t* xpath;
int x; int x;
@ -293,7 +293,7 @@ static int delete_from_fs_with_mbs (qse_fs_t* fs, const qse_mchar_t* path, int d
return -1; return -1;
} }
x = fs->cbs.del (fs, xpath); x = fs->cbs.rm (fs, xpath);
free_str_with_mbs (fs, path, xpath); free_str_with_mbs (fs, path, xpath);
@ -301,8 +301,8 @@ static int delete_from_fs_with_mbs (qse_fs_t* fs, const qse_mchar_t* path, int d
if (x == 0) return 0; /* skipped */ if (x == 0) return 0; /* skipped */
} }
ret = dir? qse_fs_sysrmdir (fs, fspath): ret = dir? qse_fs_rmdirsys (fs, fspath):
qse_fs_sysrmfile (fs, fspath); qse_fs_rmfilesys (fs, fspath);
qse_fs_freefspathformbs (fs, path, fspath); qse_fs_freefspathformbs (fs, path, fspath);
@ -314,7 +314,7 @@ static int delete_from_fs_with_wcs (qse_fs_t* fs, const qse_wchar_t* path, int d
qse_fs_char_t* fspath; qse_fs_char_t* fspath;
int ret; int ret;
if (fs->cbs.del) if (fs->cbs.rm)
{ {
qse_char_t* xpath; qse_char_t* xpath;
int x; int x;
@ -326,7 +326,7 @@ static int delete_from_fs_with_wcs (qse_fs_t* fs, const qse_wchar_t* path, int d
return -1; return -1;
} }
x = fs->cbs.del (fs, xpath); x = fs->cbs.rm (fs, xpath);
free_str_with_wcs (fs, path, xpath); free_str_with_wcs (fs, path, xpath);
@ -337,8 +337,8 @@ static int delete_from_fs_with_wcs (qse_fs_t* fs, const qse_wchar_t* path, int d
fspath = qse_fs_makefspathforwcs (fs, path); fspath = qse_fs_makefspathforwcs (fs, path);
if (!fspath) return -1; if (!fspath) return -1;
ret = dir? qse_fs_sysrmdir (fs, fspath): ret = dir? qse_fs_rmdirsys (fs, fspath):
qse_fs_sysrmfile (fs, fspath); qse_fs_rmfilesys (fs, fspath);
qse_fs_freefspathforwcs (fs, path, fspath); qse_fs_freefspathforwcs (fs, path, fspath);
@ -367,11 +367,11 @@ static int purge_path_for_glob (const qse_cstr_t* path, void* ctx)
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
int qse_fs_delfilembs (qse_fs_t* fs, const qse_mchar_t* path, int flags) int qse_fs_rmfilembs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
{ {
int ret; int ret;
if (flags & QSE_FS_DELFILEMBS_GLOB) if (flags & QSE_FS_RMFILEMBS_GLOB)
{ {
qse_char_t* xpath; qse_char_t* xpath;
@ -382,7 +382,7 @@ int qse_fs_delfilembs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
return -1; return -1;
} }
if (flags & QSE_FS_DELFILEMBS_RECURSIVE) if (flags & QSE_FS_RMFILEMBS_RECURSIVE)
{ {
ret = qse_glob (xpath, purge_path_for_glob, fs, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr); ret = qse_glob (xpath, purge_path_for_glob, fs, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr);
} }
@ -399,11 +399,11 @@ int qse_fs_delfilembs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
return -1; return -1;
} }
} }
else if (flags & QSE_FS_DELFILEMBS_RECURSIVE) else if (flags & QSE_FS_RMFILEMBS_RECURSIVE)
{ {
qse_char_t* xpath; qse_char_t* xpath;
/* if RECURSIVE is set, it's not differnt from qse_fs_deldirmbs() */ /* if RECURSIVE is set, it's not differnt from qse_fs_rmdirmbs() */
xpath = (qse_char_t*)make_str_with_mbs (fs, path); xpath = (qse_char_t*)make_str_with_mbs (fs, path);
if (!xpath) if (!xpath)
{ {
@ -423,11 +423,11 @@ int qse_fs_delfilembs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
return ret; return ret;
} }
int qse_fs_delfilewcs (qse_fs_t* fs, const qse_wchar_t* path, int flags) int qse_fs_rmfilewcs (qse_fs_t* fs, const qse_wchar_t* path, int flags)
{ {
int ret; int ret;
if (flags & QSE_FS_DELFILEWCS_GLOB) if (flags & QSE_FS_RMFILEWCS_GLOB)
{ {
qse_char_t* xpath; qse_char_t* xpath;
@ -438,7 +438,7 @@ int qse_fs_delfilewcs (qse_fs_t* fs, const qse_wchar_t* path, int flags)
return -1; return -1;
} }
if (flags & QSE_FS_DELFILEWCS_RECURSIVE) if (flags & QSE_FS_RMFILEWCS_RECURSIVE)
{ {
ret = qse_glob (xpath, purge_path_for_glob, fs, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr); ret = qse_glob (xpath, purge_path_for_glob, fs, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr);
} }
@ -455,11 +455,11 @@ int qse_fs_delfilewcs (qse_fs_t* fs, const qse_wchar_t* path, int flags)
return -1; return -1;
} }
} }
else if (flags & QSE_FS_DELFILEWCS_RECURSIVE) else if (flags & QSE_FS_RMFILEWCS_RECURSIVE)
{ {
qse_char_t* xpath; qse_char_t* xpath;
/* if RECURSIVE is set, it's not differnt from qse_fs_deldirwcs() */ /* if RECURSIVE is set, it's not differnt from qse_fs_rmdirwcs() */
xpath = (qse_char_t*)make_str_with_wcs (fs, path); xpath = (qse_char_t*)make_str_with_wcs (fs, path);
if (!xpath) if (!xpath)
{ {
@ -482,11 +482,11 @@ int qse_fs_delfilewcs (qse_fs_t* fs, const qse_wchar_t* path, int flags)
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
int qse_fs_deldirmbs (qse_fs_t* fs, const qse_mchar_t* path, int flags) int qse_fs_rmdirmbs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
{ {
int ret; int ret;
if (flags & QSE_FS_DELDIRMBS_GLOB) if (flags & QSE_FS_RMDIRMBS_GLOB)
{ {
qse_char_t* xpath; qse_char_t* xpath;
@ -497,7 +497,7 @@ int qse_fs_deldirmbs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
return -1; return -1;
} }
if (flags & QSE_FS_DELDIRMBS_RECURSIVE) if (flags & QSE_FS_RMDIRMBS_RECURSIVE)
{ {
ret = qse_glob (xpath, purge_path_for_glob, fs, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr); ret = qse_glob (xpath, purge_path_for_glob, fs, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr);
} }
@ -510,11 +510,11 @@ int qse_fs_deldirmbs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
if (ret <= -1) fs->errnum = QSE_FS_EGLOB; if (ret <= -1) fs->errnum = QSE_FS_EGLOB;
} }
else if (flags & QSE_FS_DELDIRMBS_RECURSIVE) else if (flags & QSE_FS_RMDIRMBS_RECURSIVE)
{ {
qse_char_t* xpath; qse_char_t* xpath;
/* if RECURSIVE is set, it's not differnt from qse_fs_delfilembs() */ /* if RECURSIVE is set, it's not differnt from qse_fs_rmfilembs() */
xpath = (qse_char_t*)make_str_with_mbs (fs, path); xpath = (qse_char_t*)make_str_with_mbs (fs, path);
if (!xpath) if (!xpath)
{ {
@ -534,11 +534,11 @@ int qse_fs_deldirmbs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
return ret; return ret;
} }
int qse_fs_deldirwcs (qse_fs_t* fs, const qse_wchar_t* path, int flags) int qse_fs_rmdirwcs (qse_fs_t* fs, const qse_wchar_t* path, int flags)
{ {
int ret; int ret;
if (flags & QSE_FS_DELDIRWCS_GLOB) if (flags & QSE_FS_RMDIRWCS_GLOB)
{ {
qse_char_t* xpath; qse_char_t* xpath;
@ -549,7 +549,7 @@ int qse_fs_deldirwcs (qse_fs_t* fs, const qse_wchar_t* path, int flags)
return -1; return -1;
} }
if (flags & QSE_FS_DELDIRWCS_RECURSIVE) if (flags & QSE_FS_RMDIRWCS_RECURSIVE)
{ {
ret = qse_glob (xpath, purge_path_for_glob, fs, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr); ret = qse_glob (xpath, purge_path_for_glob, fs, DEFAULT_GLOB_FLAGS, fs->mmgr, fs->cmgr);
} }
@ -562,11 +562,11 @@ int qse_fs_deldirwcs (qse_fs_t* fs, const qse_wchar_t* path, int flags)
if (ret <= -1) fs->errnum = QSE_FS_EGLOB; if (ret <= -1) fs->errnum = QSE_FS_EGLOB;
} }
else if (flags & QSE_FS_DELDIRWCS_RECURSIVE) else if (flags & QSE_FS_RMDIRWCS_RECURSIVE)
{ {
qse_char_t* xpath; qse_char_t* xpath;
/* if RECURSIVE is set, it's not differnt from qse_fs_delfilewcs() */ /* if RECURSIVE is set, it's not differnt from qse_fs_rmfilewcs() */
xpath = (qse_char_t*)make_str_with_wcs (fs, path); xpath = (qse_char_t*)make_str_with_wcs (fs, path);
if (!xpath) if (!xpath)
{ {

20
qse/lib/si/fs-make.c
View File

@ -26,7 +26,7 @@
#include "fs-prv.h" #include "fs-prv.h"
int qse_fs_sysmkdir (qse_fs_t* fs, const qse_fs_char_t* fspath) int qse_fs_mkdirsys (qse_fs_t* fs, const qse_fs_char_t* fspath)
{ {
#if defined(_WIN32) #if defined(_WIN32)
@ -120,12 +120,8 @@ static int make_directory_chain (qse_fs_t* fs, qse_fs_char_t* fspath)
c = *(p + 1); c = *(p + 1);
*(p + 1) = QSE_FS_T('\0'); *(p + 1) = QSE_FS_T('\0');
#endif #endif
ret = qse_fs_sysmkdir (fs, fspath); ret = qse_fs_mkdirsys (fs, fspath);
if (ret <= -1 && fs->errnum != QSE_FS_EEXIST) if (ret <= -1 && fs->errnum != QSE_FS_EEXIST) goto done; /* abort */
{
return -1;
goto done; /* abort */
}
#if defined(_WIN32) || defined(__DOS__) || defined(__OS2__) #if defined(_WIN32) || defined(__DOS__) || defined(__OS2__)
*p = c; *p = c;
#else #else
@ -134,7 +130,7 @@ static int make_directory_chain (qse_fs_t* fs, qse_fs_char_t* fspath)
} }
} }
if (!IS_FSPATHSEP(*(p - 1))) ret = qse_fs_sysmkdir (fs, fspath); if (!IS_FSPATHSEP(*(p - 1))) ret = qse_fs_mkdirsys (fs, fspath);
done: done:
return ret; return ret;
@ -151,7 +147,7 @@ int qse_fs_mkdirmbs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
return -1; return -1;
} }
if (flags & QSE_FS_MKDIRMBS_PARENT) if (flags & QSE_FS_MKDIR_PARENT)
{ {
/* make_directory_chain changes the input path. /* make_directory_chain changes the input path.
* ensure to create a modifiable string for it. */ * ensure to create a modifiable string for it. */
@ -165,7 +161,7 @@ int qse_fs_mkdirmbs (qse_fs_t* fs, const qse_mchar_t* path, int flags)
fspath = (qse_fs_char_t*)qse_fs_makefspathformbs (fs, path); fspath = (qse_fs_char_t*)qse_fs_makefspathformbs (fs, path);
if (!fspath) return -1; if (!fspath) return -1;
ret = qse_fs_sysmkdir (fs, fspath); ret = qse_fs_mkdirsys (fs, fspath);
} }
qse_fs_freefspathformbs (fs, path, fspath); qse_fs_freefspathformbs (fs, path, fspath);
@ -184,7 +180,7 @@ int qse_fs_mkdirwcs (qse_fs_t* fs, const qse_wchar_t* path, int flags)
return -1; return -1;
} }
if (flags & QSE_FS_MKDIRWCS_PARENT) if (flags & QSE_FS_MKDIR_PARENT)
{ {
/* make_directory_chain changes the input path. /* make_directory_chain changes the input path.
* ensure to create a modifiable string for it. */ * ensure to create a modifiable string for it. */
@ -198,7 +194,7 @@ int qse_fs_mkdirwcs (qse_fs_t* fs, const qse_wchar_t* path, int flags)
fspath = (qse_fs_char_t*)qse_fs_makefspathforwcs (fs, path); fspath = (qse_fs_char_t*)qse_fs_makefspathforwcs (fs, path);
if (!fspath) return -1; if (!fspath) return -1;
ret = qse_fs_sysmkdir (fs, fspath); ret = qse_fs_mkdirsys (fs, fspath);
} }
qse_fs_freefspathforwcs (fs, path, fspath); qse_fs_freefspathforwcs (fs, path, fspath);

20
qse/lib/si/fs-prv.h
View File

@ -66,11 +66,25 @@
# define make_str_with_mbs(fs,mbs) (mbs) # define make_str_with_mbs(fs,mbs) (mbs)
# define free_str_with_wcs(fs,wcs,str) QSE_MMGR_FREE((fs)->mmgr,str) # define free_str_with_wcs(fs,wcs,str) QSE_MMGR_FREE((fs)->mmgr,str)
# define free_str_with_mbs(fs,mbs,str) # define free_str_with_mbs(fs,mbs,str)
# if defined(QSE_FS_CHAR_IS_MCHAR)
# define make_str_with_fspath(fs,fspath) (fspath)
# define free_str_with_fspath(fs,mbs,str)
# else
# define make_str_with_fspath(fs,wcs) qse_wcstombsdupwithcmgr(wcs,QSE_NULL,(fs)->mmgr,(fs)->cmgr)
# define free_str_with_fspath(fs,wcs,str) QSE_MMGR_FREE((fs)->mmgr,str)
# endif
#else #else
# define make_str_with_wcs(fs,wcs) (wcs) # define make_str_with_wcs(fs,wcs) (wcs)
# define make_str_with_mbs(fs,mbs) qse_mbstowcsdupwithcmgr(mbs,QSE_NULL,(fs)->mmgr,(fs)->cmgr) # define make_str_with_mbs(fs,mbs) qse_mbstowcsdupwithcmgr(mbs,QSE_NULL,(fs)->mmgr,(fs)->cmgr)
# define free_str_with_wcs(fs,wcs,str) # define free_str_with_wcs(fs,wcs,str)
# define free_str_with_mbs(fs,mbs,str) QSE_MMGR_FREE((fs)->mmgr,str) # define free_str_with_mbs(fs,mbs,str) QSE_MMGR_FREE((fs)->mmgr,str)
# if defined(QSE_FS_CHAR_IS_MCHAR)
# define make_str_with_fspath(fs,mbs) qse_mbstowcsdupwithcmgr(mbs,QSE_NULL,(fs)->mmgr,(fs)->cmgr)
# define free_str_with_fspath(fs,mbs,str) QSE_MMGR_FREE((fs)->mmgr,str)
# else
# define make_str_with_fspath(fs,fspath) (fspath)
# define free_str_with_fspath(fs,mbs,str)
# endif
#endif #endif
#if defined(QSE_FS_CHAR_IS_MCHAR) #if defined(QSE_FS_CHAR_IS_MCHAR)
@ -163,17 +177,17 @@ int qse_fs_syscpfile (
const qse_fs_char_t* dstpath const qse_fs_char_t* dstpath
); );
int qse_fs_sysmkdir ( int qse_fs_mkdirsys (
qse_fs_t* fs, qse_fs_t* fs,
const qse_fs_char_t* fspath const qse_fs_char_t* fspath
); );
int qse_fs_sysrmfile ( int qse_fs_rmfilesys (
qse_fs_t* fs, qse_fs_t* fs,
const qse_fs_char_t* fspath const qse_fs_char_t* fspath
); );
int qse_fs_sysrmdir ( int qse_fs_rmdirsys (
qse_fs_t* fs, qse_fs_t* fs,
const qse_fs_char_t* fspath const qse_fs_char_t* fspath
); );

12
qse/samples/si/fs02.c
View File

@ -12,7 +12,7 @@
# include <windows.h> # include <windows.h>
#endif #endif
static int fs_del (qse_fs_t* fs, const qse_char_t* path) static int fs_rm (qse_fs_t* fs, const qse_char_t* path)
{ {
qse_printf (QSE_T("Deleting [%s]\n"), path); qse_printf (QSE_T("Deleting [%s]\n"), path);
/*if (qse_strcmp(path, QSE_T("b/c")) == 0) return 0;*/ /*if (qse_strcmp(path, QSE_T("b/c")) == 0) return 0;*/
@ -40,12 +40,12 @@ static int fs_main (int argc, qse_char_t* argv[])
fs = qse_fs_open (QSE_MMGR_GETDFL(), 0); fs = qse_fs_open (QSE_MMGR_GETDFL(), 0);
qse_memset (&cbs, 0, QSE_SIZEOF(cbs)); qse_memset (&cbs, 0, QSE_SIZEOF(cbs));
cbs.del = fs_del; cbs.rm = fs_rm;
qse_fs_setopt (fs, QSE_FS_CBS, &cbs); qse_fs_setopt (fs, QSE_FS_CBS, &cbs);
if (qse_strcmp(argv[1], QSE_T("rmfile")) == 0) if (qse_strcmp(argv[1], QSE_T("rmfile")) == 0)
{ {
if (qse_fs_delfile (fs, argv[2], QSE_FS_DELFILEMBS_GLOB) <= -1) if (qse_fs_rmfile (fs, argv[2], QSE_FS_RMFILEMBS_GLOB) <= -1)
{ {
qse_fprintf (QSE_STDERR, QSE_T("cannot delete files - %d\n"), qse_fs_geterrnum(fs)); qse_fprintf (QSE_STDERR, QSE_T("cannot delete files - %d\n"), qse_fs_geterrnum(fs));
ret = -1; ret = -1;
@ -53,7 +53,7 @@ static int fs_main (int argc, qse_char_t* argv[])
} }
else if (qse_strcmp(argv[1], QSE_T("rmfile-r")) == 0) else if (qse_strcmp(argv[1], QSE_T("rmfile-r")) == 0)
{ {
if (qse_fs_delfile (fs, argv[2], QSE_FS_DELFILE_GLOB | QSE_FS_DELFILE_RECURSIVE) <= -1) if (qse_fs_rmfile (fs, argv[2], QSE_FS_RMFILE_GLOB | QSE_FS_RMFILE_RECURSIVE) <= -1)
{ {
qse_fprintf (QSE_STDERR, QSE_T("cannot delete files - %d\n"), qse_fs_geterrnum(fs)); qse_fprintf (QSE_STDERR, QSE_T("cannot delete files - %d\n"), qse_fs_geterrnum(fs));
ret = -1; ret = -1;
@ -61,7 +61,7 @@ static int fs_main (int argc, qse_char_t* argv[])
} }
else if (qse_strcmp (argv[1], QSE_T("rmdir")) == 0) else if (qse_strcmp (argv[1], QSE_T("rmdir")) == 0)
{ {
if (qse_fs_deldir (fs, argv[2], QSE_FS_DELDIR_GLOB) <= -1) if (qse_fs_rmdir (fs, argv[2], QSE_FS_RMDIR_GLOB) <= -1)
{ {
qse_fprintf (QSE_STDERR, QSE_T("cannot delete directories - %d\n"), qse_fs_geterrnum(fs)); qse_fprintf (QSE_STDERR, QSE_T("cannot delete directories - %d\n"), qse_fs_geterrnum(fs));
ret = -1; ret = -1;
@ -69,7 +69,7 @@ static int fs_main (int argc, qse_char_t* argv[])
} }
else if (qse_strcmp (argv[1], QSE_T("rmdir-r")) == 0) else if (qse_strcmp (argv[1], QSE_T("rmdir-r")) == 0)
{ {
if (qse_fs_deldir (fs, argv[2], QSE_FS_DELDIR_GLOB | QSE_FS_DELDIR_RECURSIVE) <= -1) if (qse_fs_rmdir (fs, argv[2], QSE_FS_RMDIR_GLOB | QSE_FS_RMDIR_RECURSIVE) <= -1)
{ {
qse_fprintf (QSE_STDERR, QSE_T("cannot delete directories - %d\n"), qse_fs_geterrnum(fs)); qse_fprintf (QSE_STDERR, QSE_T("cannot delete directories - %d\n"), qse_fs_geterrnum(fs));
ret = -1; ret = -1;

19
qse/samples/si/fs03.c
View File

@ -22,8 +22,17 @@ static void print_usage (const qse_char_t* argv0)
qse_fprintf (QSE_STDERR, QSE_T(" -p preserve\n")); qse_fprintf (QSE_STDERR, QSE_T(" -p preserve\n"));
qse_fprintf (QSE_STDERR, QSE_T(" -r recursive\n")); qse_fprintf (QSE_STDERR, QSE_T(" -r recursive\n"));
qse_fprintf (QSE_STDERR, QSE_T(" -s symlink\n")); qse_fprintf (QSE_STDERR, QSE_T(" -s symlink\n"));
qse_fprintf (QSE_STDERR, QSE_T(" -g glob\n"));
} }
static int fs_cp (qse_fs_t* fs, const qse_char_t* srcpath, const qse_char_t* dstpath, qse_uintmax_t total, qse_uintmax_t copied)
{
if (total == copied) qse_printf (QSE_T("Copied [%s] to [%s]\n"), srcpath, dstpath);
/*if (qse_strcmp(path, QSE_T("b/c")) == 0) return 0;*/
return 1;
}
static int fs_main (int argc, qse_char_t* argv[]) static int fs_main (int argc, qse_char_t* argv[])
{ {
qse_fs_t* fs; qse_fs_t* fs;
@ -34,7 +43,7 @@ static int fs_main (int argc, qse_char_t* argv[])
static qse_opt_t opt = static qse_opt_t opt =
{ {
QSE_T("foprs"), QSE_T("foprsg"),
QSE_NULL QSE_NULL
}; };
@ -62,6 +71,10 @@ static int fs_main (int argc, qse_char_t* argv[])
cpfile_flags |= QSE_FS_CPFILE_SYMLINK; cpfile_flags |= QSE_FS_CPFILE_SYMLINK;
break; break;
case QSE_T('g'):
cpfile_flags |= QSE_FS_CPFILE_GLOB;
break;
case QSE_T('?'): case QSE_T('?'):
qse_fprintf (QSE_STDERR, QSE_T("illegal option - '%c'\n"), opt.opt); qse_fprintf (QSE_STDERR, QSE_T("illegal option - '%c'\n"), opt.opt);
goto wrong_usage; goto wrong_usage;
@ -79,11 +92,9 @@ static int fs_main (int argc, qse_char_t* argv[])
fs = qse_fs_open (QSE_MMGR_GETDFL(), 0); fs = qse_fs_open (QSE_MMGR_GETDFL(), 0);
/*
qse_memset (&cbs, 0, QSE_SIZEOF(cbs)); qse_memset (&cbs, 0, QSE_SIZEOF(cbs));
cbs.del = fs_del; cbs.cp = fs_cp;
qse_fs_setopt (fs, QSE_FS_CBS, &cbs); qse_fs_setopt (fs, QSE_FS_CBS, &cbs);
*/
if (qse_fs_cpfile (fs, argv[opt.ind], argv[opt.ind + 1], cpfile_flags) <= -1) if (qse_fs_cpfile (fs, argv[opt.ind], argv[opt.ind + 1], cpfile_flags) <= -1)
{ {