#include "config.h"
#include <time.h>
+#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <limits.h> /* for PATH_MAX */
-#ifdef HAVE_ATTR_XATTR_H
+#include <dirent.h> /* for scandir() and alphasort() */
+#if defined HAVE_SYS_XATTR_H
+#include <sys/xattr.h>
+#elif defined HAVE_ATTR_XATTR_H
#include <attr/xattr.h>
#endif
+#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
+#endif
+#ifdef HAVE_SYS_SYSMACROS_H
+#include <sys/sysmacros.h>
+#endif
+
#include <ext2fs/ext2fs.h>
#include <ext2fs/ext2_types.h>
#include <ext2fs/fiemap.h>
#include "create_inode.h"
-#include "nls-enable.h"
-
-#if __STDC_VERSION__ < 199901L
-# if __GNUC__ >= 2
-# define __func__ __FUNCTION__
-# else
-# define __func__ "<unknown>"
-# endif
-#endif
+#include "support/nls-enable.h"
-/* 64KiB is the minimium blksize to best minimize system call overhead. */
+/* 64KiB is the minimum blksize to best minimize system call overhead. */
#define COPY_FILE_BUFLEN 65536
static int ext2_file_type(unsigned int mode)
retval = ext2fs_read_inode(fs, ino, &inode);
if (retval) {
- com_err(__func__, retval, "while reading inode %u", ino);
+ com_err(__func__, retval, _("while reading inode %u"), ino);
return retval;
}
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, parent_ino);
if (retval) {
- com_err(__func__, retval, "while expanding directory");
+ com_err(__func__, retval,
+ _("while expanding directory"));
return retval;
}
retval = ext2fs_link(fs, parent_ino, name, ino,
ext2_file_type(inode.i_mode));
}
if (retval) {
- com_err(__func__, retval, "while linking %s", name);
+ com_err(__func__, retval, _("while linking \"%s\""), name);
return retval;
}
retval = ext2fs_write_inode(fs, ino, &inode);
if (retval)
- com_err(__func__, retval, "while writing inode %u", ino);
+ com_err(__func__, retval, _("while writing inode %u"), ino);
return retval;
}
-/* Fill the uid, gid, mode and time for the inode */
-static void fill_inode(struct ext2_inode *inode, struct stat *st)
-{
- if (st != NULL) {
- inode->i_uid = st->st_uid;
- inode->i_gid = st->st_gid;
- inode->i_mode |= st->st_mode;
- inode->i_atime = st->st_atime;
- inode->i_mtime = st->st_mtime;
- inode->i_ctime = st->st_ctime;
- }
-}
-
/* Set the uid, gid, mode and time for the inode */
-static errcode_t set_inode_extra(ext2_filsys fs, ext2_ino_t cwd,
- ext2_ino_t ino, struct stat *st)
+static errcode_t set_inode_extra(ext2_filsys fs, ext2_ino_t ino,
+ struct stat *st)
{
errcode_t retval;
struct ext2_inode inode;
retval = ext2fs_read_inode(fs, ino, &inode);
if (retval) {
- com_err(__func__, retval, "while reading inode %u", ino);
+ com_err(__func__, retval, _("while reading inode %u"), ino);
return retval;
}
- fill_inode(&inode, st);
+ inode.i_uid = st->st_uid;
+ ext2fs_set_i_uid_high(inode, st->st_uid >> 16);
+ inode.i_gid = st->st_gid;
+ ext2fs_set_i_gid_high(inode, st->st_gid >> 16);
+ inode.i_mode = (LINUX_S_IFMT & inode.i_mode) | (~S_IFMT & st->st_mode);
+ inode.i_atime = st->st_atime;
+ inode.i_mtime = st->st_mtime;
+ inode.i_ctime = st->st_ctime;
retval = ext2fs_write_inode(fs, ino, &inode);
if (retval)
- com_err(__func__, retval, "while writing inode %u", ino);
+ com_err(__func__, retval, _("while writing inode %u"), ino);
return retval;
}
-static errcode_t set_inode_xattr(ext2_filsys fs, ext2_ino_t ino, const char *filename)
-{
#ifdef HAVE_LLISTXATTR
+static errcode_t set_inode_xattr(ext2_filsys fs, ext2_ino_t ino,
+ const char *filename)
+{
errcode_t retval, close_retval;
struct ext2_xattr_handle *handle;
ssize_t size, value_size;
char *list = NULL;
int i;
+ if (no_copy_xattrs)
+ return 0;
+
size = llistxattr(filename, NULL, 0);
if (size == -1) {
- com_err(__func__, errno, "llistxattr failed on %s", filename);
- return errno;
+ retval = errno;
+ com_err(__func__, retval, _("while listing attributes of \"%s\""),
+ filename);
+ return retval;
} else if (size == 0) {
return 0;
}
if (retval) {
if (retval == EXT2_ET_MISSING_EA_FEATURE)
return 0;
- com_err(__func__, retval, "while opening inode %u", ino);
+ com_err(__func__, retval, _("while opening inode %u"), ino);
return retval;
}
retval = ext2fs_get_mem(size, &list);
if (retval) {
- com_err(__func__, retval, "whilst allocating memory");
+ com_err(__func__, retval, _("while allocating memory"));
goto out;
}
size = llistxattr(filename, list, size);
if (size == -1) {
- com_err(__func__, errno, "llistxattr failed on %s", filename);
retval = errno;
+ com_err(__func__, retval, _("while listing attributes of \"%s\""),
+ filename);
goto out;
}
const char *name = &list[i];
char *value;
- value_size = getxattr(filename, name, NULL, 0);
+ value_size = lgetxattr(filename, name, NULL, 0);
if (value_size == -1) {
- com_err(__func__, errno, "getxattr failed on %s",
- filename);
retval = errno;
+ com_err(__func__, retval,
+ _("while reading attribute \"%s\" of \"%s\""),
+ name, filename);
break;
}
retval = ext2fs_get_mem(value_size, &value);
if (retval) {
- com_err(__func__, retval, "whilst allocating memory");
+ com_err(__func__, retval, _("while allocating memory"));
break;
}
- value_size = getxattr(filename, name, value, value_size);
+ value_size = lgetxattr(filename, name, value, value_size);
if (value_size == -1) {
ext2fs_free_mem(&value);
- com_err(__func__, errno, "getxattr failed on %s",
- filename);
retval = errno;
+ com_err(__func__, retval,
+ _("while reading attribute \"%s\" of \"%s\""),
+ name, filename);
break;
}
ext2fs_free_mem(&value);
if (retval) {
com_err(__func__, retval,
- "while writing xattr %u", ino);
+ _("while writing attribute \"%s\" to inode %u"),
+ name, ino);
break;
}
ext2fs_free_mem(&list);
close_retval = ext2fs_xattrs_close(&handle);
if (close_retval) {
- com_err(__func__, retval, "while closing inode %u", ino);
+ com_err(__func__, retval, _("while closing inode %u"), ino);
retval = retval ? retval : close_retval;
}
return retval;
+ return 0;
+}
#else /* HAVE_LLISTXATTR */
+static errcode_t set_inode_xattr(ext2_filsys fs EXT2FS_ATTR((unused)),
+ ext2_ino_t ino EXT2FS_ATTR((unused)),
+ const char *filename EXT2FS_ATTR((unused)))
+{
return 0;
-#endif /* HAVE_LLISTXATTR */
}
+#endif /* HAVE_LLISTXATTR */
+#ifndef _WIN32
/* Make a special files (block and character devices), fifo's, and sockets */
errcode_t do_mknod_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
- struct stat *st)
+ unsigned int st_mode, unsigned int st_rdev)
{
ext2_ino_t ino;
errcode_t retval;
unsigned long devmajor, devminor, mode;
int filetype;
- switch(st->st_mode & S_IFMT) {
+ switch(st_mode & S_IFMT) {
case S_IFCHR:
mode = LINUX_S_IFCHR;
filetype = EXT2_FT_CHRDEV;
mode = LINUX_S_IFIFO;
filetype = EXT2_FT_FIFO;
break;
+#ifndef _WIN32
case S_IFSOCK:
mode = LINUX_S_IFSOCK;
filetype = EXT2_FT_SOCK;
break;
+#endif
default:
return EXT2_ET_INVALID_ARGUMENT;
}
- if (!(fs->flags & EXT2_FLAG_RW)) {
- com_err(__func__, 0, "Filesystem opened read/only");
- return EROFS;
- }
retval = ext2fs_new_inode(fs, cwd, 010755, 0, &ino);
if (retval) {
- com_err(__func__, retval, 0);
+ com_err(__func__, retval, _("while allocating inode \"%s\""),
+ name);
return retval;
}
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, cwd);
if (retval) {
- com_err(__func__, retval, "while expanding directory");
+ com_err(__func__, retval,
+ _("while expanding directory"));
return retval;
}
retval = ext2fs_link(fs, cwd, name, ino, filetype);
}
if (retval) {
- com_err(name, retval, 0);
+ com_err(name, retval, _("while creating inode \"%s\""), name);
return retval;
}
if (ext2fs_test_inode_bitmap2(fs->inode_map, ino))
fs->now ? fs->now : time(0);
if (filetype != S_IFIFO) {
- devmajor = major(st->st_rdev);
- devminor = minor(st->st_rdev);
+ devmajor = major(st_rdev);
+ devminor = minor(st_rdev);
if ((devmajor < 256) && (devminor < 256)) {
inode.i_block[0] = devmajor * 256 + devminor;
retval = ext2fs_write_new_inode(fs, ino, &inode);
if (retval)
- com_err(__func__, retval, "while creating inode %u", ino);
+ com_err(__func__, retval, _("while writing inode %u"), ino);
return retval;
}
+#endif
/* Make a symlink name -> target */
errcode_t do_symlink_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
} else
parent_ino = cwd;
-try_again:
retval = ext2fs_symlink(fs, parent_ino, 0, name, target);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, parent_ino);
if (retval) {
com_err("do_symlink_internal", retval,
- "while expanding directory");
+ _("while expanding directory"));
return retval;
}
- goto try_again;
+ retval = ext2fs_symlink(fs, parent_ino, 0, name, target);
}
if (retval)
- com_err("ext2fs_symlink", retval, 0);
+ com_err("ext2fs_symlink", retval,
+ _("while creating symlink \"%s\""), name);
return retval;
}
/* Make a directory in the fs */
errcode_t do_mkdir_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
- struct stat *st, ext2_ino_t root)
+ ext2_ino_t root)
{
char *cp;
ext2_ino_t parent_ino;
*cp = 0;
retval = ext2fs_namei(fs, root, cwd, name, &parent_ino);
if (retval) {
- com_err(name, retval, 0);
+ com_err(name, retval, _("while looking up \"%s\""),
+ name);
return retval;
}
name = cp+1;
} else
parent_ino = cwd;
-try_again:
retval = ext2fs_mkdir(fs, parent_ino, 0, name);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, parent_ino);
if (retval) {
- com_err(__func__, retval, "while expanding directory");
+ com_err(__func__, retval,
+ _("while expanding directory"));
return retval;
}
- goto try_again;
+ retval = ext2fs_mkdir(fs, parent_ino, 0, name);
}
if (retval)
- com_err("ext2fs_mkdir", retval, 0);
+ com_err("ext2fs_mkdir", retval,
+ _("while creating directory \"%s\""), name);
return retval;
}
#if !defined HAVE_PREAD64 && !defined HAVE_PREAD
-static ssize_t my_pread(int fd, const void *buf, size_t count, off_t offset)
+static ssize_t my_pread(int fd, void *buf, size_t count, off_t offset)
{
if (lseek(fd, offset, SEEK_SET) < 0)
return 0;
}
#endif /* !defined HAVE_PREAD64 && !defined HAVE_PREAD */
-static errcode_t copy_file_range(ext2_filsys fs, int fd, ext2_file_t e2_file,
+static errcode_t copy_file_chunk(ext2_filsys fs, int fd, ext2_file_t e2_file,
off_t start, off_t end, char *buf,
char *zerobuf)
{
ptr += blen;
continue;
}
- err = ext2fs_file_lseek(e2_file, off + bpos,
- EXT2_SEEK_SET, NULL);
+ err = ext2fs_file_llseek(e2_file, off + bpos,
+ EXT2_SEEK_SET, NULL);
if (err)
goto fail;
while (blen > 0) {
return err;
}
+#if defined(SEEK_DATA) && defined(SEEK_HOLE)
static errcode_t try_lseek_copy(ext2_filsys fs, int fd, struct stat *statbuf,
ext2_file_t e2_file, char *buf, char *zerobuf)
{
-#if defined(SEEK_DATA) && defined(SEEK_HOLE)
off_t data = 0, hole;
off_t data_blk, hole_blk;
- errcode_t err;
+ errcode_t err = 0;
/* Try to use SEEK_DATA and SEEK_HOLE */
while (data < statbuf->st_size) {
if (hole < 0)
return EXT2_ET_UNIMPLEMENTED;
- data_blk = data & ~(fs->blocksize - 1);
- hole_blk = (hole + (fs->blocksize - 1)) & ~(fs->blocksize - 1);
- err = copy_file_range(fs, fd, e2_file, data_blk, hole_blk, buf,
+ data_blk = data & ~(off_t)(fs->blocksize - 1);
+ hole_blk = ((hole + (off_t)(fs->blocksize - 1)) &
+ ~(off_t)(fs->blocksize - 1));
+ err = copy_file_chunk(fs, fd, e2_file, data_blk, hole_blk, buf,
zerobuf);
if (err)
return err;
}
return err;
-#else
- return EXT2_ET_UNIMPLEMENTED;
-#endif /* SEEK_DATA and SEEK_HOLE */
}
+#endif /* SEEK_DATA and SEEK_HOLE */
+#if defined(FS_IOC_FIEMAP)
static errcode_t try_fiemap_copy(ext2_filsys fs, int fd, ext2_file_t e2_file,
char *buf, char *zerobuf)
{
-#if defined(FS_IOC_FIEMAP)
#define EXTENT_MAX_COUNT 512
struct fiemap *fiemap_buf;
struct fiemap_extent *ext_buf, *ext;
if (err < 0 && (errno == EOPNOTSUPP || errno == ENOTTY)) {
err = EXT2_ET_UNIMPLEMENTED;
goto out;
- } else if (err < 0 || fiemap_buf->fm_mapped_extents == 0) {
+ } else if (err < 0) {
err = errno;
goto out;
- }
+ } else if (fiemap_buf->fm_mapped_extents == 0)
+ goto out;
for (i = 0, ext = ext_buf; i < fiemap_buf->fm_mapped_extents;
i++, ext++) {
- err = copy_file_range(fs, fd, e2_file, ext->fe_logical,
+ err = copy_file_chunk(fs, fd, e2_file, ext->fe_logical,
ext->fe_logical + ext->fe_length,
buf, zerobuf);
if (err)
out:
ext2fs_free_mem(&fiemap_buf);
return err;
-#else
- return EXT2_ET_UNIMPLEMENTED;
-#endif /* FS_IOC_FIEMAP */
}
+#endif /* FS_IOC_FIEMAP */
static errcode_t copy_file(ext2_filsys fs, int fd, struct stat *statbuf,
ext2_ino_t ino)
if (err)
goto out;
+#if defined(SEEK_DATA) && defined(SEEK_HOLE)
err = try_lseek_copy(fs, fd, statbuf, e2_file, buf, zerobuf);
if (err != EXT2_ET_UNIMPLEMENTED)
goto out;
+#endif
+#if defined(FS_IOC_FIEMAP)
err = try_fiemap_copy(fs, fd, e2_file, buf, zerobuf);
if (err != EXT2_ET_UNIMPLEMENTED)
goto out;
+#endif
- err = copy_file_range(fs, fd, e2_file, 0, statbuf->st_size, buf,
+ err = copy_file_chunk(fs, fd, e2_file, 0, statbuf->st_size, buf,
zerobuf);
out:
ext2fs_free_mem(&zerobuf);
return err;
}
-static int is_hardlink(struct hdlinks_s *hdlinks, dev_t dev, ino_t ino)
+static int is_hardlink(struct hdlinks_s *hdlinks, dev_t dev, ext2_ino_t ino)
{
int i;
fd = ext2fs_open_file(src, O_RDONLY, 0);
if (fd < 0) {
- com_err(src, errno, 0);
- return errno;
+ retval = errno;
+ com_err(__func__, retval, _("while opening \"%s\" to copy"),
+ src);
+ return retval;
}
if (fstat(fd, &statbuf) < 0) {
- com_err(src, errno, 0);
- close(fd);
- return errno;
+ retval = errno;
+ goto out;
}
retval = ext2fs_namei(fs, root, cwd, dest, &newfile);
if (retval == 0) {
- close(fd);
- return EXT2_ET_FILE_EXISTS;
+ retval = EXT2_ET_FILE_EXISTS;
+ goto out;
}
retval = ext2fs_new_inode(fs, cwd, 010755, 0, &newfile);
- if (retval) {
- com_err(__func__, retval, 0);
- close(fd);
- return retval;
- }
+ if (retval)
+ goto out;
#ifdef DEBUGFS
printf("Allocated inode: %u\n", newfile);
#endif
EXT2_FT_REG_FILE);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, cwd);
- if (retval) {
- com_err(__func__, retval, "while expanding directory");
- close(fd);
- return retval;
- }
+ if (retval)
+ goto out;
retval = ext2fs_link(fs, cwd, dest, newfile,
EXT2_FT_REG_FILE);
}
- if (retval) {
- com_err(dest, retval, 0);
- close(fd);
- return errno;
- }
+ if (retval)
+ goto out;
if (ext2fs_test_inode_bitmap2(fs->inode_map, newfile))
com_err(__func__, 0, "Warning: inode already set");
ext2fs_inode_alloc_stats2(fs, newfile, +1, 0);
memset(&inode, 0, sizeof(inode));
- inode.i_mode = (statbuf.st_mode & ~LINUX_S_IFMT) | LINUX_S_IFREG;
+ inode.i_mode = (statbuf.st_mode & ~S_IFMT) | LINUX_S_IFREG;
inode.i_atime = inode.i_ctime = inode.i_mtime =
fs->now ? fs->now : time(0);
inode.i_links_count = 1;
retval = ext2fs_inode_size_set(fs, &inode, statbuf.st_size);
- if (retval) {
- com_err(dest, retval, 0);
- close(fd);
- return retval;
- }
- if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
- EXT4_FEATURE_INCOMPAT_INLINE_DATA)) {
+ if (retval)
+ goto out;
+ if (ext2fs_has_feature_inline_data(fs->super)) {
inode.i_flags |= EXT4_INLINE_DATA_FL;
- } else if (fs->super->s_feature_incompat &
- EXT3_FEATURE_INCOMPAT_EXTENTS) {
+ } else if (ext2fs_has_feature_extents(fs->super)) {
ext2_extent_handle_t handle;
inode.i_flags &= ~EXT4_EXTENTS_FL;
retval = ext2fs_extent_open2(fs, newfile, &inode, &handle);
if (retval)
- return retval;
+ goto out;
ext2fs_extent_free(handle);
}
retval = ext2fs_write_new_inode(fs, newfile, &inode);
- if (retval) {
- com_err(__func__, retval, "while creating inode %u", newfile);
- close(fd);
- return retval;
- }
+ if (retval)
+ goto out;
if (inode.i_flags & EXT4_INLINE_DATA_FL) {
retval = ext2fs_inline_data_init(fs, newfile);
- if (retval) {
- com_err("copy_file", retval, 0);
- close(fd);
- return retval;
- }
+ if (retval)
+ goto out;
}
if (LINUX_S_ISREG(inode.i_mode)) {
retval = copy_file(fs, fd, &statbuf, newfile);
if (retval)
- com_err("copy_file", retval, _("while copying %s"), src);
+ goto out;
}
+out:
close(fd);
-
return retval;
}
-/* Copy files from source_dir to fs */
+struct file_info {
+ char *path;
+ size_t path_len;
+ size_t path_max_len;
+};
+
+static errcode_t path_append(struct file_info *target, const char *file)
+{
+ if (strlen(file) + target->path_len + 1 > target->path_max_len) {
+ void *p;
+ target->path_max_len *= 2;
+ p = realloc(target->path, target->path_max_len);
+ if (p == NULL)
+ return EXT2_ET_NO_MEMORY;
+ target->path = p;
+ }
+ target->path_len += sprintf(target->path + target->path_len, "/%s",
+ file);
+ return 0;
+}
+
+#ifdef _WIN32
+static int scandir(const char *dir_name, struct dirent ***name_list,
+ int (*filter)(const struct dirent*),
+ int (*compar)(const struct dirent**, const struct dirent**)) {
+ DIR *dir;
+ struct dirent *dent;
+ struct dirent **temp_list = NULL;
+ size_t temp_list_size = 0; // unit: num of dirent
+ size_t num_dent = 0;
+
+ dir = opendir(dir_name);
+ if (dir == NULL) {
+ return -1;
+ }
+
+ while ((dent = readdir(dir))) {
+ if (filter != NULL && !(*filter)(dent))
+ continue;
+
+ // re-allocate the list
+ if (num_dent == temp_list_size) {
+ size_t new_list_size = temp_list_size + 32;
+ struct dirent **new_list = (struct dirent**)realloc(
+ temp_list, new_list_size * sizeof(struct dirent*));
+ if (new_list == NULL) {
+ goto out;
+ }
+ temp_list_size = new_list_size;
+ temp_list = new_list;
+ }
+ // add the copy of dirent to the list
+ temp_list[num_dent] = (struct dirent*)malloc((dent->d_reclen + 3) & ~3);
+ memcpy(temp_list[num_dent], dent, dent->d_reclen);
+ num_dent++;
+ }
+
+ if (compar != NULL) {
+ qsort(temp_list, num_dent, sizeof(struct dirent*),
+ (int (*)(const void*, const void*))compar);
+ }
+
+ // release the temp list
+ *name_list = temp_list;
+ temp_list = NULL;
+
+out:
+ if (temp_list != NULL) {
+ while (num_dent > 0) {
+ free(temp_list[--num_dent]);
+ }
+ free(temp_list);
+ num_dent = -1;
+ }
+ closedir(dir);
+ return num_dent;
+}
+
+static int alphasort(const struct dirent **a, const struct dirent **b) {
+ return strcoll((*a)->d_name, (*b)->d_name);
+}
+#endif
+
+/* Copy files from source_dir to fs in alphabetical order */
static errcode_t __populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
const char *source_dir, ext2_ino_t root,
- struct hdlinks_s *hdlinks)
+ struct hdlinks_s *hdlinks,
+ struct file_info *target,
+ struct fs_ops_callbacks *fs_callbacks)
{
const char *name;
- DIR *dh;
- struct dirent *dent;
+ struct dirent **dent;
struct stat st;
- char ln_target[PATH_MAX];
+ char *ln_target = NULL;
unsigned int save_inode;
ext2_ino_t ino;
errcode_t retval = 0;
int read_cnt;
int hdlink;
+ size_t cur_dir_path_len;
+ int i, num_dents;
if (chdir(source_dir) < 0) {
- com_err(__func__, errno,
+ retval = errno;
+ com_err(__func__, retval,
_("while changing working directory to \"%s\""),
source_dir);
- return errno;
+ return retval;
}
- if (!(dh = opendir("."))) {
- com_err(__func__, errno,
- _("while opening directory \"%s\""), source_dir);
- return errno;
+ num_dents = scandir(".", &dent, NULL, alphasort);
+
+ if (num_dents < 0) {
+ retval = errno;
+ com_err(__func__, retval,
+ _("while scanning directory \"%s\""), source_dir);
+ return retval;
}
- while ((dent = readdir(dh))) {
- if ((!strcmp(dent->d_name, ".")) ||
- (!strcmp(dent->d_name, "..")))
+ for (i = 0; i < num_dents; free(dent[i]), i++) {
+ name = dent[i]->d_name;
+ if ((!strcmp(name, ".")) || (!strcmp(name, "..")))
continue;
- if (lstat(dent->d_name, &st)) {
- com_err(__func__, errno, _("while lstat \"%s\""),
- dent->d_name);
+ if (lstat(name, &st)) {
+ retval = errno;
+ com_err(__func__, retval, _("while lstat \"%s\""),
+ name);
goto out;
}
- name = dent->d_name;
/* Check for hardlinks */
save_inode = 0;
save_inode = 1;
}
+ cur_dir_path_len = target->path_len;
+ retval = path_append(target, name);
+ if (retval) {
+ com_err(__func__, retval,
+ "while appending %s", name);
+ goto out;
+ }
+
+ if (fs_callbacks && fs_callbacks->create_new_inode) {
+ retval = fs_callbacks->create_new_inode(fs,
+ target->path, name, parent_ino, root,
+ st.st_mode & S_IFMT);
+ if (retval)
+ goto out;
+ }
+
switch(st.st_mode & S_IFMT) {
case S_IFCHR:
case S_IFBLK:
case S_IFIFO:
+#ifndef _WIN32
case S_IFSOCK:
- retval = do_mknod_internal(fs, parent_ino, name, &st);
+ retval = do_mknod_internal(fs, parent_ino, name,
+ st.st_mode, st.st_rdev);
if (retval) {
com_err(__func__, retval,
_("while creating special file "
}
break;
case S_IFLNK:
+ ln_target = malloc(st.st_size + 1);
+ if (ln_target == NULL) {
+ com_err(__func__, retval,
+ _("malloc failed"));
+ goto out;
+ }
read_cnt = readlink(name, ln_target,
- sizeof(ln_target) - 1);
+ st.st_size + 1);
if (read_cnt == -1) {
- com_err(__func__, errno,
- _("while trying to readlink \"%s\""),
- name);
retval = errno;
+ com_err(__func__, retval,
+ _("while trying to read link \"%s\""),
+ name);
+ free(ln_target);
+ goto out;
+ }
+ if (read_cnt > st.st_size) {
+ com_err(__func__, retval,
+ _("symlink increased in size "
+ "between lstat() and readlink()"));
+ free(ln_target);
goto out;
}
ln_target[read_cnt] = '\0';
retval = do_symlink_internal(fs, parent_ino, name,
ln_target, root);
+ free(ln_target);
if (retval) {
com_err(__func__, retval,
_("while writing symlink\"%s\""),
goto out;
}
break;
+#endif
case S_IFREG:
retval = do_write_internal(fs, parent_ino, name, name,
root);
}
break;
case S_IFDIR:
- retval = do_mkdir_internal(fs, parent_ino, name, &st,
+ /* Don't choke on /lost+found */
+ if (parent_ino == EXT2_ROOT_INO &&
+ strcmp(name, "lost+found") == 0)
+ goto find_lnf;
+ retval = do_mkdir_internal(fs, parent_ino, name,
root);
if (retval) {
com_err(__func__, retval,
_("while making dir \"%s\""), name);
goto out;
}
+find_lnf:
retval = ext2fs_namei(fs, root, parent_ino,
name, &ino);
if (retval) {
goto out;
}
/* Populate the dir recursively*/
- retval = __populate_fs(fs, ino, name, root, hdlinks);
- if (retval) {
- com_err(__func__, retval,
- _("while adding dir \"%s\""), name);
+ retval = __populate_fs(fs, ino, name, root, hdlinks,
+ target, fs_callbacks);
+ if (retval)
goto out;
- }
if (chdir("..")) {
- com_err(__func__, errno, _("during cd .."));
retval = errno;
+ com_err(__func__, retval,
+ _("while changing directory"));
goto out;
}
break;
retval = ext2fs_namei(fs, root, parent_ino, name, &ino);
if (retval) {
- com_err(name, retval, 0);
+ com_err(name, retval, _("while looking up \"%s\""),
+ name);
goto out;
}
- retval = set_inode_extra(fs, parent_ino, ino, &st);
+ retval = set_inode_extra(fs, ino, &st);
if (retval) {
com_err(__func__, retval,
_("while setting inode for \"%s\""), name);
goto out;
}
+ if (fs_callbacks && fs_callbacks->end_create_new_inode) {
+ retval = fs_callbacks->end_create_new_inode(fs,
+ target->path, name, parent_ino, root,
+ st.st_mode & S_IFMT);
+ if (retval)
+ goto out;
+ }
+
/* Save the hardlink ino */
if (save_inode) {
/*
(hdlinks->size + HDLINK_CNT) *
sizeof(struct hdlink_s));
if (p == NULL) {
- com_err(name, errno,
- _("Not enough memory"));
retval = EXT2_ET_NO_MEMORY;
+ com_err(name, retval,
+ _("while saving inode data"));
goto out;
}
hdlinks->hdl = p;
hdlinks->hdl[hdlinks->count].dst_ino = ino;
hdlinks->count++;
}
+ target->path_len = cur_dir_path_len;
+ target->path[target->path_len] = 0;
}
out:
- closedir(dh);
+ for (; i < num_dents; free(dent[i]), i++);
+ free(dent);
return retval;
}
-errcode_t populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
- const char *source_dir, ext2_ino_t root)
+errcode_t populate_fs2(ext2_filsys fs, ext2_ino_t parent_ino,
+ const char *source_dir, ext2_ino_t root,
+ struct fs_ops_callbacks *fs_callbacks)
{
+ struct file_info file_info;
struct hdlinks_s hdlinks;
errcode_t retval;
+ if (!(fs->flags & EXT2_FLAG_RW)) {
+ com_err(__func__, 0, "Filesystem opened readonly");
+ return EROFS;
+ }
+
hdlinks.count = 0;
hdlinks.size = HDLINK_CNT;
hdlinks.hdl = realloc(NULL, hdlinks.size * sizeof(struct hdlink_s));
if (hdlinks.hdl == NULL) {
- com_err(__func__, errno, "Not enough memory");
- return errno;
+ retval = errno;
+ com_err(__func__, retval, _("while allocating memory"));
+ return retval;
}
- retval = __populate_fs(fs, parent_ino, source_dir, root, &hdlinks);
+ file_info.path_len = 0;
+ file_info.path_max_len = 255;
+ file_info.path = calloc(file_info.path_max_len, 1);
+ retval = __populate_fs(fs, parent_ino, source_dir, root, &hdlinks,
+ &file_info, fs_callbacks);
+
+ free(file_info.path);
free(hdlinks.hdl);
return retval;
}
+
+errcode_t populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
+ const char *source_dir, ext2_ino_t root)
+{
+ return populate_fs2(fs, parent_ino, source_dir, root, NULL);
+}