/* 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)
{
char *cp;
ext2_ino_t parent_ino;
errcode_t retval;
cp = strrchr(name, '/');
if (cp) {
*cp = 0;
retval = ext2fs_namei(fs, root, cwd, name, &parent_ino);
if (retval) {
com_err(name, retval, 0);
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");
return retval;
}
goto try_again;
}
if (retval)
com_err("ext2fs_mkdir", retval, 0);
return retval;
}
static errcode_t get_file(ext2_filsys fs, const char * filename,
struct mem_file *ret_file)
{
errcode_t retval;
char *buf;
ext2_file_t e2_file = NULL;
unsigned int got;
struct ext2_inode inode;
ext2_ino_t ino;
ret_file->buf = 0;
ret_file->size = 0;
ret_file->ptr = 0;
retval = ext2fs_namei(fs, EXT2_ROOT_INO, EXT2_ROOT_INO,
filename, &ino);
if (retval)
return retval;
retval = ext2fs_read_inode(fs, ino, &inode);
if (retval)
return retval;
if (inode.i_size_high || (inode.i_size > 65536))
return EFBIG;
buf = malloc(inode.i_size + 1);
if (!buf)
return ENOMEM;
memset(buf, 0, inode.i_size+1);
retval = ext2fs_file_open(fs, ino, 0, &e2_file);
if (retval)
goto errout;
retval = ext2fs_file_read(e2_file, buf, inode.i_size, &got);
if (retval)
goto errout;
retval = ext2fs_file_close(e2_file);
if (retval)
goto errout;
ret_file->buf = buf;
ret_file->size = (int) got;
return 0;
errout:
free(buf);
if (e2_file)
ext2fs_file_close(e2_file);
return retval;
}
int do_readinode (ext2_filsys e2fs, const char *path, ext2_ino_t *ino, struct ext2_inode *inode)
{
errcode_t rc;
rc = ext2fs_namei(e2fs, EXT2_ROOT_INO, EXT2_ROOT_INO, path, ino);
if (rc) {
debugf("ext2fs_namei(e2fs, EXT2_ROOT_INO, EXT2_ROOT_INO, %s, ino); failed", path);
return -ENOENT;
}
rc = ext2fs_read_inode(e2fs, *ino, inode);
if (rc) {
debugf("ext2fs_read_inode(e2fs, *ino, inode); failed");
return -EIO;
}
return 0;
}
/*
* This routine is used whenever a command needs to turn a string into
* an inode.
*/
ext2_ino_t string_to_inode(char *str)
{
ext2_ino_t ino;
int len = strlen(str);
char *end;
int retval;
/*
* If the string is of the form <ino>, then treat it as an
* inode number.
*/
if ((len > 2) && (str[0] == '<') && (str[len-1] == '>')) {
ino = strtoul(str+1, &end, 0);
if (*end=='>')
return ino;
}
retval = ext2fs_namei(current_fs, root, cwd, str, &ino);
if (retval) {
com_err(str, retval, 0);
return 0;
}
return ino;
}
/* Make a symlink name -> target */
errcode_t do_symlink_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
char *target, ext2_ino_t root)
{
char *cp;
ext2_ino_t parent_ino;
errcode_t retval;
struct ext2_inode inode;
struct stat st;
cp = strrchr(name, '/');
if (cp) {
*cp = 0;
retval = ext2fs_namei(fs, root, cwd, name, &parent_ino);
if (retval) {
com_err(name, retval, 0);
return retval;
}
name = cp+1;
} 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");
return retval;
}
goto try_again;
}
if (retval)
com_err("ext2fs_symlink", retval, 0);
return retval;
}
/* Name: tail()
*
* Description:
*
* This function displays the last lines at the end of a file in an ext2
* file system.
*
* Algorithm:
*
* Get the directory and basename of the file
* Determine the inode number for the file
* Open the file for reading
* Skip to the last block in the file
* While we have not found the last num_lines of newline characters
* Skip backwards in the file one block and read it
* Display the contents of the block from that point on.
* Display the rest of the file if not contained in the block
* Save the current location of the file.
* If we are following the file as it grows
* While forever
* Sleep
* Re-read the inode for the file
* If the size has changed
* Display the file from the saved point on
* Save the current location of the file.
*
*
* Global Variables:
*
* None
*
* Arguments:
*
* ext2_filsys *fs; Our filesystem
* ext2_ino_t root; The root directory inode number
* char *input; The name of the input file to tail
* int num_lines; The number of lines to display
* int follow; Flag indicating if the we should follow any
* new contents to the file.
* int sleep_int; The number of seconds to sleep between checking
* for new lines
* char *cur_filesys
*
* Return Values:
*
* 0 - the last number of lines was displayed correctly.
* an error occurred.
*
* Author: Keith W. Sheffield
* Date: 08/07/2002
*
* Modification History:
*
* MM/DD/YY Name Description
*/
static long
tail(ext2_filsys *fs_ptr, ext2_ino_t root, char *input, int num_lines,
int follow, int sleep_int, char *cur_filesys)
{
ext2_filsys fs = *fs_ptr;
ext2_ino_t cwd;
ext2_ino_t tail_ino;
ext2_ino_t t_tail_ino;
char *tail_dir;
char *tail_name;
long retval;
char buf[BLK_SIZE];
unsigned int bytes_to_read;
unsigned int bytes_read;
char *ptr;
struct ext2_inode inode;
ext2_file_t tail_fd;
ext2_off_t offset;
ext2_off_t cur_pos;
if (get_file_parts(fs, root, input, &cwd, &tail_dir, &tail_name))
{
ext2fs_close(fs);
return(-1);
}
/* get the inode number for the source file */
if ((retval = ext2fs_namei(fs, cwd, cwd, tail_name, &tail_ino)))
{
fprintf(stderr, "%s: file %s\n",error_message(retval),
tail_name);
return(retval);
}
/* open the file */
if ((retval = ext2fs_file_open(fs, tail_ino, 0, &tail_fd)))
{
fputs(error_message(retval), stderr);
return retval;
}
/* get the length of the file and determine where to start reading */
inode.i_size = offset = ext2fs_file_get_size(tail_fd);
bytes_to_read = offset % BLK_SIZE;
if (bytes_to_read == 0)
bytes_to_read = BLK_SIZE;
offset -= bytes_to_read;
if (((int32_t)offset) < 0)
offset = 0;
do
{
/* seek to the start of the last block in the file */
if ((retval = ext2fs_file_lseek(tail_fd, offset, EXT2_SEEK_SET, NULL)))
{
fputs(error_message(retval), stderr);
return retval;
}
/* read the last block in the file */
if ((retval = ext2fs_file_read(tail_fd, buf, bytes_to_read,
&bytes_read)))
{
fputs(error_message(retval), stderr);
return retval;
}
if (bytes_to_read != bytes_read)
{
fputs("error reading file\n", stderr);
return(-1);
}
ptr = buf + bytes_read - 1;
while (bytes_to_read--)
{
if (*ptr == '\n' && num_lines-- == 0)
{
/* if the newline wasn't the last character in the buffer, then
* print what's remaining.
*/
if (bytes_to_read != bytes_read - 1)
{
ptr++;
if (0 > write(1, ptr, bytes_read - bytes_to_read - 1))
{
perror("writing bytes to stdout");
return -1;
}
}
offset = 0; /* make sure we break out of the main loop */
break;
}
ptr--;
}
offset -= (offset < BLK_SIZE) ? offset : BLK_SIZE;
bytes_to_read = BLK_SIZE;
}
while (offset > 0);
/* if we are here and have any lines left, we hit the beginning, so
* dump the rest of what's in memory out.
*/
if (num_lines > 0)
{
if (0 > write(1, buf, bytes_read)) {
perror("writing bytes to stdout");
return -1;
}
}
/* retreive the current position in the file */
if ((retval = ext2fs_file_lseek(tail_fd, 0, EXT2_SEEK_CUR, &cur_pos)))
{
fputs(error_message(retval), stderr);
return retval;
}
/* ok, if we are before the end of the file, then dump the rest of it */
if (cur_pos < inode.i_size)
{
if ((retval = read_to_eof(tail_fd, 1, cur_pos, &cur_pos)))
{
return retval;
}
}
if ((retval = ext2fs_file_close(tail_fd)))
{
fputs(error_message(retval), stderr);
return retval;
}
if (follow)
{
while(1)
{
sleep(sleep_int);
/* I don't know how to force a re-read of the file system info yet,
* so, just close the file system and reopen it.
*/
ext2fs_close(fs);
if ((retval = open_filesystem(cur_filesys, &fs, &root, 0)))
{
*fs_ptr = NULL;
fprintf(stderr, "%s: %s\n", error_message(retval), cur_filesys);
return retval;
}
*fs_ptr = fs;
/* if we are following the name, find the directory and file name
* again.
*/
if (follow == FOLLOW_NAME)
{
cwd = root;
if (tail_dir != NULL && *tail_dir != '\0' &&
strcmp(tail_dir, ",") != 0 &&
(retval = change_cwd(fs, root, &cwd, tail_dir)))
{
fprintf(stderr, "Error changing to directory %s\n",
tail_dir);
return(retval);
}
/* get the inode number for the source file */
if ((retval = ext2fs_namei(fs, cwd, cwd, tail_name,
&t_tail_ino)))
{
fprintf(stderr, "%s: file %s\n",error_message(retval),
tail_name);
return(retval);
}
/* if we are dealing with a new file, then start from the
* beginning.
*/
if (t_tail_ino != tail_ino)
{
tail_ino = t_tail_ino;
cur_pos = 0;
}
}
if ((retval = ext2fs_read_inode(fs, tail_ino, &inode)))
{
fputs(error_message(retval), stderr);
return retval;
}
if (inode.i_size > cur_pos)
{
if ((retval = retrieve_data(fs, tail_ino, 1, NULL, 0, cur_pos,
&cur_pos)))
{
fputs(error_message(retval), stderr);
return retval;
}
}
else if (inode.i_size < cur_pos)
{
/* the file was truncated, so bail */
return(0);
}
}
}
return(0);
}
/* Name: do_ln()
*
* Description:
*
* This function reads the command line arguments and creates a link
* in an ext2fs file system
*
* Algorithm:
*
* Read any command line switches
* Get the source file specification
* Open the file system
* Get the directory and basename of the source file
* Determine the inode number for the source file
* If the destination file is not given or if it's a .
* use the current directory and the basename of the source file
* Otherwise
* Get the directory and basename of the destination file
* Create the link
*
* Global Variables:
*
* None
*
* Arguments:
*
* int argc; The number of arguments
* char *argv[]; The command line arguments
*
* Return Values:
*
* 0 - the link was created successfully
* an error occurred.
*
* Author: Keith W. Sheffield
* Date: 03/05/2002
*
* Modification History:
*
* MM/DD/YY Name Description
* 03/06/02 K. Sheffield Modified to perform file moves
* 03/20/02 K. Sheffield Moved the mv operation to a separate file
*/
long
do_ln(int argc, char *argv[])
{
int verbose=0;
int force=0;
int symlink=0;
int errcnt=0;
char *cur_filesys = NULL;
ext2_filsys fs = NULL;
ext2_ino_t root;
ext2_ino_t srcd;
ext2_ino_t destd;
ext2_ino_t source_file;
char *src_dir;
char *dest_dir;
char *src_name;
char *dest_name;
long retval;
int c;
#ifdef HAVE_OPTRESET
optreset = 1; /* Makes BSD getopt happy */
#endif
while ((c = getopt(argc, argv, "vfs")) != EOF)
{
switch (c)
{
case 'v':
verbose = 1;
break;
case 'f':
force = E2T_FORCE;
break;
case 's':
symlink = 1;
break;
default:
errcnt++;
break;
}
}
if (errcnt || argc == optind)
{
fputs(USAGE, stderr);
return(1);
}
if (symlink)
{
fputs("Not implemented yet\n", stderr);
return(1);
}
cur_filesys = argv[optind++];
if (NULL == (src_dir = strchr(cur_filesys, ':')))
{
fprintf(stderr, "Invalid file specification: %s\n", cur_filesys);
return(1);
}
*src_dir++ = '\0';
if (*src_dir == '\0')
{
fputs(USAGE, stderr);
return(1);
}
if ((retval = open_filesystem(cur_filesys, &fs, &root, 1)))
{
fprintf(stderr, "%s: %s\n", error_message(retval), cur_filesys);
return retval;
}
/* move to the source directory */
if (get_file_parts(fs, root, src_dir, &srcd, &src_dir, &src_name))
{
ext2fs_close(fs);
return(-1);
}
/* get the inode number for the source file */
if ((retval = ext2fs_namei(fs, srcd, srcd, src_name, &source_file)))
{
fprintf(stderr, "%s: source file %s\n",error_message(retval), src_name);
ext2fs_close(fs);
return(retval);
}
/* get the destination directory */
destd = root;
if (argc == optind || strcmp(dest_dir = argv[optind], ".") == 0)
dest_name = src_name;
else
{
if (get_file_parts(fs, root, dest_dir, &destd, &dest_dir,
&dest_name))
{
ext2fs_close(fs);
return(-1);
}
}
/* now create the link */
if ((retval = create_hard_link(fs, destd, source_file, dest_name, force)))
{
fprintf(stderr, "Error linking %s/%s as %s/%s\n",
((src_dir == NULL) ? "." : src_dir), src_name,
((dest_dir == NULL) ? "." : dest_dir), dest_name);
ext2fs_close(fs);
return(1);
}
if (verbose)
fprintf(stderr, "linked %s/%s as %s/%s\n",
((src_dir == NULL) ? "." : src_dir), src_name,
((dest_dir == NULL) ? "." : dest_dir), dest_name);
ext2fs_close(fs);
return(0);
} /* end of do_ln */
/* Name: create_hard_link()
*
* Description:
*
* This function creates a hard link to an existing file
*
* Algorithm:
*
* Check input parameters
* Check to see if the new file name already exists
* Make sure the new file is not an existing directory
* If the file exists, remove it if the del_current flag is set
* Add the new file name and it's inode to the current directory.
* Get the inode structure for the current inode number
* update the number of links
* Write the inode structure back out to the file system.
*
* Global Variables:
*
* None.
*
* Arguments:
*
* ext2_filsys fs; The current file system
* ext2_ino_t cwd; The current working directory
* ext2_ino_t new_file_ino; The inode number of the new file
* char *newfile; The name of the new file
* int ln_flags; Flags affecting hard_link action
*
* Return Values:
*
* 0 - the new file link was created successfully
* any other value indicates an error
*
* Author: Keith W. Sheffield
* Date: 03/05/2002
*
* Modification History:
*
* MM/DD/YY Name Description
* 06/30/02 K.Sheffield Directory link flag is now based on the
* type of file being linked. This was
* causing problems if a directory was
* renamed.
*/
long
create_hard_link(ext2_filsys fs, ext2_ino_t cwd, ext2_ino_t new_file_ino,
char *newfile, int ln_flags)
{
ext2_ino_t curr_ino;
struct ext2_inode inode;
long retval;
int dir_flag;
if (fs == NULL || newfile == NULL)
{
fputs("Invalid input parameter. Exiting create_hard_link() with -1\n",
stderr);
return (-1);
}
/* check to see if the file name already exists in the current directory */
if ((retval = ext2fs_namei(fs, cwd, cwd, newfile, &curr_ino)))
{
if (retval != EXT2_ET_FILE_NOT_FOUND)
{
fprintf(stderr, "%s\n",error_message(retval));
return(retval);
}
}
/* file name exists, let's see if is a directory */
else if ((retval = ext2fs_check_directory(fs, curr_ino)))
{
if (retval != EXT2_ET_NO_DIRECTORY)
{
fprintf(stderr, "%s\n",error_message(retval));
return(retval);
}
/* delete the existing file if needed */
if ((ln_flags & E2T_FORCE) &&
(curr_ino != new_file_ino))
{
if ((retval = rm_file(fs, cwd, newfile, curr_ino)))
{
fprintf(stderr, "%s\n",error_message(retval));
return(retval);
}
}
else
{
fprintf(stderr, "ln: %s: File exists\n", newfile);
return(1);
}
}
else
{
/* if we get here, then it's an existing directory */
fprintf(stderr, "%s is a directory!\n", newfile);
return(1);
}
/* read the inode associated with the file */
if ((retval = read_inode(fs, new_file_ino, &inode)))
{
fprintf(stderr, "%s\n", error_message(retval));
return (retval);
}
/* determine how to link into the directory based on the type of file */
switch(inode.i_mode & LINUX_S_IFMT)
{
case LINUX_S_IFREG:
dir_flag = EXT2_FT_REG_FILE;
break;
case LINUX_S_IFLNK:
dir_flag = EXT2_FT_SYMLINK;
break;
case LINUX_S_IFDIR:
dir_flag = EXT2_FT_DIR;
break;
case LINUX_S_IFSOCK:
dir_flag = EXT2_FT_SOCK;
break;
case LINUX_S_IFBLK:
dir_flag = EXT2_FT_BLKDEV;
break;
case LINUX_S_IFCHR:
dir_flag = EXT2_FT_CHRDEV;
break;
case LINUX_S_IFIFO:
dir_flag = EXT2_FT_FIFO;
break;
default:
dir_flag = EXT2_FT_UNKNOWN;
break;
}
if ((retval = ext2fs_link(fs, cwd, newfile, new_file_ino, dir_flag)))
{
/* check to see if we ran out of space in the directory */
if (retval == EXT2_ET_DIR_NO_SPACE)
{
/* try resizing the directory and try again */
if (0 == (retval = ext2fs_expand_dir(fs, cwd)))
retval = ext2fs_link(fs, cwd, newfile, new_file_ino, dir_flag);
}
if (retval)
{
fprintf(stderr, "%s\n", error_message(retval));
return retval;
}
}
/* update the inode stat information */
if ((ln_flags & E2T_DO_MV) == 0)
{
inode.i_links_count++;
if ((retval = write_inode(fs, new_file_ino, &inode)))
{
fprintf(stderr, "%s\n", error_message(retval));
return (retval);
}
}
return(0);
} /* end of create_hard_link */
/* Name: do_mv()
*
* Description:
*
* This function reads the command line arguments and moves or renames files
* in an ext2fs file system
*
* Algorithm:
*
* Read any command line switches
* Get the first source file specification
* If we are performing a file swap, call do_swap()
* Open the file system
* Get the destination and determine if it is a directory
* If not, then get the destination's directory and basename
* Also check that the number of source files are no more than one
* For each source file
* Get the directory and basename of the source file
* Determine the inode number for the source file
* Create the link
* Unlink the original source file.
*
* Global Variables:
*
* None
*
* Arguments:
*
* int argc; The number of arguments
* char *argv[]; The command line arguments
*
* Return Values:
*
* 0 - the file was move successfully
* an error occurred.
*
* Author: Keith W. Sheffield
* Date: 03/20/2002
*
* Modification History:
*
* MM/DD/YY Name Description
*/
long
do_mv(int argc, char *argv[])
{
int verbose=0;
int force=0;
int swap_files=0;
int errcnt=0;
char *cur_filesys = NULL;
ext2_filsys fs = NULL;
ext2_ino_t root;
ext2_ino_t srcd;
ext2_ino_t destd;
ext2_ino_t source_file;
char *src_dir;
char *dest_dir;
char *src_name;
char *dest_name;
char *result_name;
long retval;
int c;
int curidx;
#ifdef HAVE_OPTRESET
optreset = 1; /* Makes BSD getopt happy */
#endif
while ((c = getopt(argc, argv, "vfs")) != EOF)
{
switch (c)
{
case 'v':
verbose = 1;
break;
case 'f':
force = E2T_FORCE;
break;
case 's':
swap_files = 1;
break;
default:
errcnt++;
break;
}
}
curidx = optind;
force |= E2T_DO_MV;
if (errcnt || argc < curidx+2)
{
fputs(USAGE, stderr);
return(1);
}
if (swap_files)
return(do_swap(force, verbose, curidx, argc, argv));
cur_filesys = argv[curidx++];
if (NULL == (src_dir = strchr(cur_filesys, ':')))
{
fprintf(stderr, "Invalid file specification: %s\n", cur_filesys);
return(1);
}
*src_dir++ = '\0';
if ((retval = open_filesystem(cur_filesys, &fs, &root, 1)))
{
return retval;
}
/* get the destination directory */
dest_name = NULL;
if (strcmp(dest_dir = argv[argc-1], ".") != 0)
{
/* check to see if the file name already exists in the current
* directory and also see if it is a directory.
*/
if ((retval = ext2fs_namei(fs, root, root, dest_dir, &destd)) ||
(retval = ext2fs_check_directory(fs, destd)))
{
if (retval != EXT2_ET_FILE_NOT_FOUND &&
retval != EXT2_ET_NO_DIRECTORY)
{
fprintf(stderr, "%s\n",error_message(retval));
ext2fs_close(fs);
return(retval);
}
/* ok, so it's either not there or it's not a directory, so
* get the real destination directory and file name.
*/
if (curidx+1 < argc)
{
fprintf(stderr, "%s must be a directory!\n", dest_dir);
ext2fs_close(fs);
return(1);
}
if (get_file_parts(fs, root, dest_dir, &destd, &dest_dir,
&dest_name))
{
ext2fs_close(fs);
return(-1);
}
}
else /* we have a directory!!! */
dest_name = NULL;
}
else
{
destd = root;
dest_name = NULL;
}
do
{
/* move to the source directory */
if (get_file_parts(fs, root, src_dir, &srcd, &src_dir, &src_name))
{
ext2fs_close(fs);
return(-1);
}
/* get the inode number for the source file */
if ((retval = ext2fs_namei(fs, srcd, srcd, src_name, &source_file)))
{
fprintf(stderr, "%s: source file %s\n",error_message(retval),
src_name);
ext2fs_close(fs);
return(retval);
}
result_name = (dest_name) ? dest_name : src_name;
/* now create the link */
if ((retval = create_hard_link(fs, destd, source_file, result_name,
force)))
{
fprintf(stderr, "Error renaming %s/%s as %s/%s\n",
((src_dir == NULL) ? "." : src_dir), src_name,
((dest_dir == NULL) ? "." : dest_dir), result_name);
ext2fs_close(fs);
return(1);
}
if ((retval = ext2fs_unlink(fs, srcd, src_name, 0, 0)))
{
fprintf(stderr, "%s - %s\n", src_name, error_message(retval));
ext2fs_close(fs);
return(retval);
}
if (verbose)
fprintf(stderr, "moved %s/%s as %s/%s\n",
((src_dir == NULL) ? "." : src_dir), src_name,
((dest_dir == NULL) ? "." : dest_dir), result_name);
src_dir = argv[curidx++];
}
while (curidx < argc);
ext2fs_close(fs);
return(0);
} /* end of do_mv */
static long
do_swap(int force, int verbose, int curidx, int argc, char **argv)
{
char *cur_filesys = NULL;
ext2_filsys fs = NULL;
ext2_ino_t root;
ext2_ino_t file1_dirno;
ext2_ino_t file2_dirno;
ext2_ino_t file3_dirno;
ext2_ino_t file1_no;
ext2_ino_t file2_no;
char *file1_dir;
char *file2_dir;
char *file3_dir;
char *file1_name;
char *file2_name;
char *file3_name;
long retval;
if (curidx + 2 > argc)
{
fputs(USAGE, stderr);
return(1);
}
cur_filesys = argv[curidx++];
if (NULL == (file1_dir = strchr(cur_filesys, ':')))
{
fprintf(stderr, "Invalid file specification: %s\n", cur_filesys);
return(1);
}
*file1_dir++ = '\0';
if ((retval = open_filesystem(cur_filesys, &fs, &root, 1)))
{
return retval;
}
/* move to the file 1 directory */
if (get_file_parts(fs, root, file1_dir, &file1_dirno, &file1_dir,
&file1_name))
{
ext2fs_close(fs);
return(-1);
}
/* get the inode number for the file 1 file */
if ((retval = ext2fs_namei(fs, file1_dirno, file1_dirno, file1_name,
&file1_no)))
{
fprintf(stderr, "%s: file 1 file %s\n",error_message(retval),
file1_name);
ext2fs_close(fs);
return(retval);
}
/* move to the file 2 directory */
if (get_file_parts(fs, root, argv[curidx++], &file2_dirno, &file2_dir,
&file2_name))
{
ext2fs_close(fs);
return(-1);
}
/* get the inode number for the file 2 file */
if ((retval = ext2fs_namei(fs, file2_dirno, file2_dirno, file2_name,
&file2_no)))
{
fprintf(stderr, "%s: file 2 file %s\n",error_message(retval),
file2_name);
ext2fs_close(fs);
return(retval);
}
if (curidx < argc)
{
/* move to the file 3 directory */
if (get_file_parts(fs, root, argv[curidx++], &file3_dirno, &file3_dir,
&file3_name))
{
ext2fs_close(fs);
return(-1);
}
/* now move the first file to the 3rd */
if ((retval = create_hard_link(fs, file3_dirno, file1_no, file3_name,
force)))
{
fprintf(stderr, "Error renaming %s/%s as %s/%s\n",
((file1_dir == NULL) ? "." : file1_dir), file1_name,
((file3_dir == NULL) ? "." : file3_dir), file3_name);
ext2fs_close(fs);
return(1);
}
if ((retval = ext2fs_unlink(fs, file1_dirno, file1_name, 0, 0)))
{
fprintf(stderr, "%s - %s\n", file1_name, error_message(retval));
ext2fs_close(fs);
return(retval);
}
/* now move the 2nd file to the 1st */
if ((retval = create_hard_link(fs, file1_dirno, file2_no, file1_name,
force)))
{
fprintf(stderr, "Error renaming %s/%s as %s/%s\n",
((file2_dir == NULL) ? "." : file2_dir), file2_name,
((file1_dir == NULL) ? "." : file1_dir), file1_name);
ext2fs_close(fs);
return(1);
}
if ((retval = ext2fs_unlink(fs, file2_dirno, file2_name, 0, 0)))
{
fprintf(stderr, "%s - %s\n", file2_name, error_message(retval));
ext2fs_close(fs);
return(retval);
}
if (verbose)
fprintf(stderr, "renamed file %s/%s as %s/%s\n"
"renamed file %s/%s as %s/%s\n",
((file1_dir == NULL) ? "." : file1_dir), file1_name,
((file3_dir == NULL) ? "." : file3_dir), file3_name,
((file2_dir == NULL) ? "." : file2_dir), file2_name,
((file1_dir == NULL) ? "." : file1_dir), file1_name);
}
else
{
/* now remove the first file */
if ((retval = ext2fs_unlink(fs, file1_dirno, file1_name, 0, 0)))
{
fprintf(stderr, "%s - %s\n", file1_name, error_message(retval));
ext2fs_close(fs);
return(retval);
}
/* now move the 2nd file to the 1st */
if ((retval = create_hard_link(fs, file1_dirno, file2_no, file1_name,
force)))
{
fprintf(stderr, "Error renaming %s/%s as %s/%s\n",
((file2_dir == NULL) ? "." : file2_dir), file2_name,
((file1_dir == NULL) ? "." : file1_dir), file1_name);
ext2fs_close(fs);
return(1);
}
if ((retval = ext2fs_unlink(fs, file2_dirno, file2_name, 0, 0)))
{
fprintf(stderr, "%s - %s\n", file2_name, error_message(retval));
ext2fs_close(fs);
return(retval);
}
if ((retval = create_hard_link(fs, file2_dirno, file1_no, file2_name,
force)))
{
fprintf(stderr, "Error renaming %s/%s as %s/%s\n",
((file1_dir == NULL) ? "." : file1_dir), file1_name,
((file2_dir == NULL) ? "." : file2_dir), file2_name);
ext2fs_close(fs);
return(1);
}
if (verbose)
fprintf(stderr, "swapped files %s/%s <-> %s/%s\n",
((file1_dir == NULL) ? "." : file1_dir), file1_name,
((file2_dir == NULL) ? "." : file2_dir), file2_name);
}
ext2fs_close(fs);
return(0);
} /* end of do_swap */
/* Copy files from source_dir to fs */
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)
{
const char *name;
DIR *dh;
struct dirent *dent;
struct stat st;
char ln_target[PATH_MAX];
unsigned int save_inode;
ext2_ino_t ino;
errcode_t retval = 0;
int read_cnt;
int hdlink;
if (chdir(source_dir) < 0) {
com_err(__func__, errno,
_("while changing working directory to \"%s\""),
source_dir);
return errno;
}
if (!(dh = opendir("."))) {
com_err(__func__, errno,
_("while opening directory \"%s\""), source_dir);
return errno;
}
while ((dent = readdir(dh))) {
if ((!strcmp(dent->d_name, ".")) ||
(!strcmp(dent->d_name, "..")))
continue;
if (lstat(dent->d_name, &st)) {
com_err(__func__, errno, _("while lstat \"%s\""),
dent->d_name);
goto out;
}
name = dent->d_name;
/* Check for hardlinks */
save_inode = 0;
if (!S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode) &&
st.st_nlink > 1) {
hdlink = is_hardlink(hdlinks, st.st_dev, st.st_ino);
if (hdlink >= 0) {
retval = add_link(fs, parent_ino,
hdlinks->hdl[hdlink].dst_ino,
name);
if (retval) {
com_err(__func__, retval,
"while linking %s", name);
goto out;
}
continue;
} else
save_inode = 1;
}
switch(st.st_mode & S_IFMT) {
case S_IFCHR:
case S_IFBLK:
case S_IFIFO:
case S_IFSOCK:
retval = do_mknod_internal(fs, parent_ino, name, &st);
if (retval) {
com_err(__func__, retval,
_("while creating special file "
"\"%s\""), name);
goto out;
}
break;
case S_IFLNK:
read_cnt = readlink(name, ln_target,
sizeof(ln_target) - 1);
if (read_cnt == -1) {
com_err(__func__, errno,
_("while trying to readlink \"%s\""),
name);
retval = errno;
goto out;
}
ln_target[read_cnt] = '\0';
retval = do_symlink_internal(fs, parent_ino, name,
ln_target, root);
if (retval) {
com_err(__func__, retval,
_("while writing symlink\"%s\""),
name);
goto out;
}
break;
case S_IFREG:
retval = do_write_internal(fs, parent_ino, name, name,
root);
if (retval) {
com_err(__func__, retval,
_("while writing file \"%s\""), name);
goto out;
}
break;
case S_IFDIR:
retval = do_mkdir_internal(fs, parent_ino, name, &st,
root);
if (retval) {
com_err(__func__, retval,
_("while making dir \"%s\""), name);
goto out;
}
retval = ext2fs_namei(fs, root, parent_ino,
name, &ino);
if (retval) {
com_err(name, retval, 0);
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);
goto out;
}
if (chdir("..")) {
com_err(__func__, errno, _("during cd .."));
retval = errno;
goto out;
}
break;
default:
com_err(__func__, 0,
_("ignoring entry \"%s\""), name);
}
retval = ext2fs_namei(fs, root, parent_ino, name, &ino);
if (retval) {
com_err(name, retval, 0);
goto out;
}
retval = set_inode_extra(fs, parent_ino, ino, &st);
if (retval) {
com_err(__func__, retval,
_("while setting inode for \"%s\""), name);
goto out;
}
retval = set_inode_xattr(fs, ino, name);
if (retval) {
com_err(__func__, retval,
_("while setting xattrs for \"%s\""), name);
goto out;
}
/* Save the hardlink ino */
if (save_inode) {
/*
* Check whether need more memory, and we don't need
* free() since the lifespan will be over after the fs
* populated.
*/
if (hdlinks->count == hdlinks->size) {
void *p = realloc(hdlinks->hdl,
(hdlinks->size + HDLINK_CNT) *
sizeof(struct hdlink_s));
if (p == NULL) {
com_err(name, errno,
_("Not enough memory"));
retval = EXT2_ET_NO_MEMORY;
goto out;
}
hdlinks->hdl = p;
hdlinks->size += HDLINK_CNT;
}
hdlinks->hdl[hdlinks->count].src_dev = st.st_dev;
hdlinks->hdl[hdlinks->count].src_ino = st.st_ino;
hdlinks->hdl[hdlinks->count].dst_ino = ino;
hdlinks->count++;
}
}
out:
closedir(dh);
return retval;
}
/* Copy the native file to the fs */
errcode_t do_write_internal(ext2_filsys fs, ext2_ino_t cwd, const char *src,
const char *dest, ext2_ino_t root)
{
int fd;
struct stat statbuf;
ext2_ino_t newfile;
errcode_t retval;
struct ext2_inode inode;
int bufsize = IO_BUFSIZE;
int make_holes = 0;
fd = ext2fs_open_file(src, O_RDONLY, 0);
if (fd < 0) {
com_err(src, errno, 0);
return errno;
}
if (fstat(fd, &statbuf) < 0) {
com_err(src, errno, 0);
close(fd);
return errno;
}
retval = ext2fs_namei(fs, root, cwd, dest, &newfile);
if (retval == 0) {
close(fd);
return EXT2_ET_FILE_EXISTS;
}
retval = ext2fs_new_inode(fs, cwd, 010755, 0, &newfile);
if (retval) {
com_err(__func__, retval, 0);
close(fd);
return retval;
}
#ifdef DEBUGFS
printf("Allocated inode: %u\n", newfile);
#endif
retval = ext2fs_link(fs, cwd, dest, newfile,
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;
}
retval = ext2fs_link(fs, cwd, dest, newfile,
EXT2_FT_REG_FILE);
}
if (retval) {
com_err(dest, retval, 0);
close(fd);
return errno;
}
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_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)) {
inode.i_flags |= EXT4_INLINE_DATA_FL;
} else if (fs->super->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_EXTENTS) {
int i;
struct ext3_extent_header *eh;
eh = (struct ext3_extent_header *) &inode.i_block[0];
eh->eh_depth = 0;
eh->eh_entries = 0;
eh->eh_magic = ext2fs_cpu_to_le16(EXT3_EXT_MAGIC);
i = (sizeof(inode.i_block) - sizeof(*eh)) /
sizeof(struct ext3_extent);
eh->eh_max = ext2fs_cpu_to_le16(i);
inode.i_flags |= EXT4_EXTENTS_FL;
}
retval = ext2fs_write_new_inode(fs, newfile, &inode);
if (retval) {
com_err(__func__, retval, "while creating inode %u", newfile);
close(fd);
return retval;
}
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 (LINUX_S_ISREG(inode.i_mode)) {
if (statbuf.st_blocks < statbuf.st_size / S_BLKSIZE) {
make_holes = 1;
/*
* Use I/O blocksize as buffer size when
* copying sparse files.
*/
bufsize = statbuf.st_blksize;
}
retval = copy_file(fs, fd, newfile, bufsize, make_holes);
if (retval)
com_err("copy_file", retval, 0);
}
close(fd);
return retval;
}
