* %End-Header%
*/
+#ifndef _LARGEFILE_SOURCE
#define _LARGEFILE_SOURCE
+#endif
+#ifndef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE
+#endif
#include "config.h"
#include <fcntl.h>
#include "ext2fs/ext2_fs.h"
#include "ext2fs/ext2fs.h"
+#include "ext2fs/ext2fsP.h"
#include "et/com_err.h"
#include "uuid/uuid.h"
#include "e2p/e2p.h"
#include "ext2fs/e2image.h"
#include "ext2fs/qcow2.h"
+#include "support/nls-enable.h"
+#include "support/plausible.h"
#include "../version.h"
-#include "nls-enable.h"
-#define QCOW_OFLAG_COPIED (1LL << 63)
+#define QCOW_OFLAG_COPIED (1ULL << 63)
#define NO_BLK ((blk64_t) -1)
/* Image types */
static void usage(void)
{
- fprintf(stderr, _("Usage: %s [-acfnprsIQ] [-o src_offset] "
- "[-O dest_offset] \\\n\tdevice image_file\n"),
+ fprintf(stderr, _("Usage: %s [ -r|-Q ] [ -f ] [ -b superblock ] [ -B blocksize ] "
+ "device image-file\n"),
+ program_name);
+ fprintf(stderr, _(" %s -I device image-file\n"), program_name);
+ fprintf(stderr, _(" %s -ra [ -cfnp ] [ -o src_offset ] "
+ "[ -O dest_offset ] src_fs [ dest_fs ]\n"),
program_name);
exit (1);
}
free_buf = 1;
err = ext2fs_get_arrayzero(1, blocksize, &buf);
if (err) {
- com_err(program_name, err, "while allocating buffer");
+ com_err(program_name, err, "%s",
+ _("while allocating buffer"));
exit(1);
}
}
if (nop_flag) {
- printf("Writing block %llu\n", (unsigned long long) block);
- seek_relative(fd, blocksize);
- return;
+ printf(_("Writing block %llu\n"), (unsigned long long) block);
+ if (fd != 1)
+ seek_relative(fd, blocksize);
+ goto free_and_return;
}
count = write(fd, buf, blocksize);
if (count != blocksize) {
err = 0;
if (block)
- com_err(program_name, err, "error writing block %llu",
- block);
+ com_err(program_name, err,
+ _("error writing block %llu"), block);
else
- com_err(program_name, err, "error in write()");
+ com_err(program_name, err, "%s",
+ _("error in generic_write()"));
exit(1);
}
+free_and_return:
if (free_buf)
ext2fs_free_mem(&buf);
}
write_header(fd, NULL, sizeof(struct ext2_image_hdr), fs->blocksize);
memset(&hdr, 0, sizeof(struct ext2_image_hdr));
- hdr.offset_super = seek_relative(fd, 0);
+ hdr.offset_super = ext2fs_cpu_to_le32(seek_relative(fd, 0));
retval = ext2fs_image_super_write(fs, fd, 0);
if (retval) {
com_err(program_name, retval, "%s",
exit(1);
}
- hdr.offset_inode = seek_relative(fd, 0);
+ hdr.offset_inode = ext2fs_cpu_to_le32(seek_relative(fd, 0));
retval = ext2fs_image_inode_write(fs, fd,
(fd != 1) ? IMAGER_FLAG_SPARSEWRITE : 0);
if (retval) {
exit(1);
}
- hdr.offset_blockmap = seek_relative(fd, 0);
+ hdr.offset_blockmap = ext2fs_cpu_to_le32(seek_relative(fd, 0));
retval = ext2fs_image_bitmap_write(fs, fd, 0);
if (retval) {
com_err(program_name, retval, "%s",
exit(1);
}
- hdr.offset_inodemap = seek_relative(fd, 0);
+ hdr.offset_inodemap = ext2fs_cpu_to_le32(seek_relative(fd, 0));
retval = ext2fs_image_bitmap_write(fs, fd, IMAGER_FLAG_INODEMAP);
if (retval) {
com_err(program_name, retval, "%s",
exit(1);
}
- hdr.magic_number = EXT2_ET_MAGIC_E2IMAGE;
+ hdr.magic_number = ext2fs_cpu_to_le32(EXT2_ET_MAGIC_E2IMAGE);
strcpy(hdr.magic_descriptor, "Ext2 Image 1.0");
gethostname(hdr.fs_hostname, sizeof(hdr.fs_hostname));
strncpy(hdr.fs_device_name, device_name, sizeof(hdr.fs_device_name)-1);
hdr.fs_device_name[sizeof(hdr.fs_device_name) - 1] = 0;
- hdr.fs_blocksize = fs->blocksize;
+ hdr.fs_blocksize = ext2fs_cpu_to_le32(fs->blocksize);
if (stat(device_name, &st) == 0)
- hdr.fs_device = st.st_rdev;
+ hdr.fs_device = ext2fs_cpu_to_le32(st.st_rdev);
if (fstat(fd, &st) == 0) {
- hdr.image_device = st.st_dev;
- hdr.image_inode = st.st_ino;
+ hdr.image_device = ext2fs_cpu_to_le32(st.st_dev);
+ hdr.image_inode = ext2fs_cpu_to_le32(st.st_ino);
}
memcpy(hdr.fs_uuid, fs->super->s_uuid, sizeof(hdr.fs_uuid));
- hdr.image_time = time(0);
+ hdr.image_time = ext2fs_cpu_to_le32(time(0));
write_header(fd, &hdr, sizeof(struct ext2_image_hdr), fs->blocksize);
}
}
meta_blocks_count += fs->desc_blocks;
+ /*
+ * Mark MMP block
+ */
+ if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_MMP) {
+ ext2fs_mark_block_bitmap2(meta_block_map, fs->super->s_mmp_block);
+ meta_blocks_count++;
+ }
+
for (i = 0; i < fs->group_desc_count; i++) {
/*
* Mark the blocks used for the inode table
ext2fs_inode_table_loc(fs, i)) {
unsigned int end = (unsigned) fs->inode_blocks_per_group;
/* skip unused blocks */
- if (!output_is_blk &&
- EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
- EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
+ if (!output_is_blk && ext2fs_has_group_desc_csum(fs))
end -= (ext2fs_bg_itable_unused(fs, i) /
EXT2_INODES_PER_BLOCK(fs->super));
for (j = 0, b = ext2fs_inode_table_loc(fs, i);
#endif
if (rec_len < 8 || (rec_len % 4) ||
(p+rec_len > end)) {
- printf("Corrupt directory block %llu: "
- "bad rec_len (%d)\n", (unsigned long long) blk,
- rec_len);
+ printf(_("Corrupt directory block %llu: "
+ "bad rec_len (%d)\n"),
+ (unsigned long long) blk, rec_len);
rec_len = end - p;
(void) ext2fs_set_rec_len(fs, rec_len,
(struct ext2_dir_entry *) dirent);
continue;
}
if (dirent->name_len + 8U > rec_len) {
- printf("Corrupt directory block %llu: "
- "bad name_len (%d)\n", (unsigned long long) blk,
- dirent->name_len);
+ printf(_("Corrupt directory block %llu: "
+ "bad name_len (%d)\n"),
+ (unsigned long long) blk, dirent->name_len);
dirent->name_len = rec_len - 8;
continue;
}
signal (SIGINT, SIG_DFL);
}
+#define calc_percent(a, b) ((int) ((100.0 * (((float) (a)) / \
+ ((float) (b)))) + 0.5))
+#define calc_rate(t, b, d) (((float)(t) / ((float)(1024 * 1024) / (b))) / (d))
+
+static int print_progress(blk64_t num, blk64_t total)
+{
+ return fprintf(stderr, _("%llu / %llu blocks (%d%%)"), num, total,
+ calc_percent(num, total));
+}
+
static void output_meta_data_blocks(ext2_filsys fs, int fd, int flags)
{
errcode_t retval;
retval = ext2fs_get_mem(fs->blocksize, &buf);
if (retval) {
- com_err(program_name, retval, "while allocating buffer");
+ com_err(program_name, retval, "%s",
+ _("while allocating buffer"));
exit(1);
}
retval = ext2fs_get_memzero(fs->blocksize, &zero_buf);
if (retval) {
- com_err(program_name, retval, "while allocating buffer");
+ com_err(program_name, retval, "%s",
+ _("while allocating buffer"));
exit(1);
}
if (show_progress) {
- printf("Copying ");
- bscount = printf("%llu / %llu blocks (%llu%%)",
- total_written,
- meta_blocks_count,
- (total_written + 50) / ((meta_blocks_count + 50) / 100));
- fflush(stdout);
+ fprintf(stderr, "%s", _("Copying "));
+ bscount = print_progress(total_written, meta_blocks_count);
+ fflush(stderr);
last_update = time(NULL);
start_time = time(NULL);
}
if (got_sigint) {
if (distance) {
/* moving to the right */
- if (distance >= ext2fs_blocks_count(fs->super) ||
- start == ext2fs_blocks_count(fs->super) - distance)
- kill (getpid(), SIGINT);
+ if (distance >= ext2fs_blocks_count(fs->super)||
+ start == ext2fs_blocks_count(fs->super) -
+ distance)
+ kill(getpid(), SIGINT);
} else {
/* moving to the left */
- if (blk < (source_offset - dest_offset) / fs->blocksize)
- kill (getpid(), SIGINT);
+ if (blk < (source_offset - dest_offset) /
+ fs->blocksize)
+ kill(getpid(), SIGINT);
}
if (show_progress)
- printf ("\r");
- printf ("Stopping now will destroy the filesystem, "
- "interrupt again if you are sure\n");
+ fputc('\r', stderr);
+ fprintf(stderr, "%s",
+ _("Stopping now will destroy the filesystem, "
+ "interrupt again if you are sure\n"));
if (show_progress) {
- printf("Copying ");
- bscount = printf("%llu / %llu blocks (%llu%%)",
- total_written,
- meta_blocks_count,
- (total_written + 50) / ((meta_blocks_count + 50)
- / 100));
- fflush(stdout);
+ fprintf(stderr, "%s", _("Copying "));
+ bscount = print_progress(total_written,
+ meta_blocks_count);
+ fflush(stderr);
}
got_sigint = 0;
time_t duration;
last_update = time(NULL);
while (bscount--)
- printf("\b");
- bscount = printf("%llu / %llu blocks (%llu%%)",
- total_written,
- meta_blocks_count,
- (total_written + 50) /
- ((meta_blocks_count + 50) / 100));
+ fputc('\b', stderr);
+ bscount = print_progress(total_written,
+ meta_blocks_count);
duration = time(NULL) - start_time;
- if (duration > 5) {
- time_t est = (duration *
- meta_blocks_count / total_written) -
- (duration);
+ if (duration > 5 && total_written) {
+ time_t est = (duration * meta_blocks_count /
+ total_written) - duration;
char buff[30];
strftime(buff, 30, "%T", gmtime(&est));
- bscount += printf(" %s remaining at %.2f MB/s",
- buff,
- ((float)total_written /
- ((1024 * 1024) / fs->blocksize)) /
- duration);
+ bscount +=
+ fprintf(stderr,
+ _(" %s remaining at %.2f MB/s"),
+ buff, calc_rate(total_written,
+ fs->blocksize,
+ duration));
}
- fflush (stdout);
+ fflush (stderr);
}
if ((blk >= fs->super->s_first_data_block) &&
ext2fs_test_block_bitmap2(meta_block_map, blk)) {
retval = io_channel_read_blk64(fs->io, blk, 1, buf);
if (retval) {
com_err(program_name, retval,
- "error reading block %llu", blk);
+ _("error reading block %llu"), blk);
}
total_written++;
if (scramble_block_map &&
} else {
sparse_write:
if (fd == 1) {
- generic_write(fd, zero_buf, fs->blocksize, blk);
+ if (!nop_flag)
+ generic_write(fd, zero_buf,
+ fs->blocksize, blk);
continue;
}
sparse += fs->blocksize;
if (show_progress) {
time_t duration = time(NULL) - start_time;
char buff[30];
- while (bscount--)
- printf("\b");
+ fputc('\r', stderr);
strftime(buff, 30, "%T", gmtime(&duration));
- printf("\b\b\b\b\b\b\b\bCopied %llu / %llu blocks (%llu%%) in "
- "%s at %.2f MB/s \n",
- total_written,
- meta_blocks_count,
- (total_written + 50) / ((meta_blocks_count + 50) / 100),
- buff,
- ((float)total_written /
- ((1024 * 1024) / fs->blocksize)) /
- duration);
-
+ fprintf(stderr, _("Copied %llu / %llu blocks (%d%%) in %s "),
+ total_written, meta_blocks_count,
+ calc_percent(total_written, meta_blocks_count), buff);
+ if (duration)
+ fprintf(stderr, _("at %.2f MB/s"),
+ calc_rate(total_written, fs->blocksize, duration));
+ fputs(" \n", stderr);
}
#ifdef HAVE_FTRUNCATE64
if (sparse) {
ret = ext2fs_get_arrayzero(image->l1_size, sizeof(__u64), &l1_table);
if (ret) {
- com_err(program_name, ret, "while allocating l1 table");
+ com_err(program_name, ret, "%s",
+ _("while allocating l1 table"));
exit(1);
}
return;
alloc_err:
- com_err(program_name, ret, "while allocating l2 cache");
+ com_err(program_name, ret, "%s", _("while allocating l2 cache"));
exit(1);
}
}
if (cache->free != cache->count) {
- fprintf(stderr, "Warning: There are still tables in the "
- "cache while putting the cache, data will "
- "be lost so the image may not be valid.\n");
+ fprintf(stderr, "%s", _("Warning: There are still tables in "
+ "the cache while putting the cache, "
+ "data will be lost so the image may "
+ "not be valid.\n"));
table = cache->used_head;
cache->used_head = NULL;
goto again;
return ret;
}
-static int initialize_qcow2_image(int fd, ext2_filsys fs,
- struct ext2_qcow2_image *image)
+static errcode_t initialize_qcow2_image(int fd, ext2_filsys fs,
+ struct ext2_qcow2_image *image)
{
struct ext2_qcow2_hdr *header;
blk64_t total_size, offset;
int cluster_bits = get_bits_from_size(fs->blocksize);
struct ext2_super_block *sb = fs->super;
+ if (fs->blocksize < 1024)
+ return EINVAL; /* Can never happen, but just in case... */
+
/* Allocate header */
ret = ext2fs_get_memzero(sizeof(struct ext2_qcow2_hdr), &header);
if (ret)
/*
* We are relying on the fact that we are creating the qcow2
* image sequentially, hence we will always allocate refcount
- * block items sequentialy.
+ * block items sequentially.
*/
ref->refcount_block[ref->refcount_block_index] = ext2fs_cpu_to_be16(1);
ref->refcount_block_index++;
/* allocate struct ext2_qcow2_image */
retval = ext2fs_get_mem(sizeof(struct ext2_qcow2_image), &img);
if (retval) {
- com_err(program_name, retval,
- "while allocating ext2_qcow2_image");
+ com_err(program_name, retval, "%s",
+ _("while allocating ext2_qcow2_image"));
exit(1);
}
retval = initialize_qcow2_image(fd, fs, img);
if (retval) {
- com_err(program_name, retval,
- "while initializing ext2_qcow2_image");
+ com_err(program_name, retval, "%s",
+ _("while initializing ext2_qcow2_image"));
exit(1);
}
header_size = align_offset(sizeof(struct ext2_qcow2_hdr),
retval = ext2fs_get_mem(fs->blocksize, &buf);
if (retval) {
- com_err(program_name, retval, "while allocating buffer");
+ com_err(program_name, retval, "%s",
+ _("while allocating buffer"));
exit(1);
}
/* Write qcow2 data blocks */
retval = io_channel_read_blk64(fs->io, blk, 1, buf);
if (retval) {
com_err(program_name, retval,
- "error reading block %llu", blk);
+ _("error reading block %llu"), blk);
continue;
}
if (scramble_block_map &&
* block should not be created!
*/
if (update_refcount(fd, img, offset, offset)) {
- fprintf(stderr, "Programming error: "
- "multiple sequential refcount "
- "blocks created!\n");
+ fprintf(stderr, "%s",
+ _("Programming error: multiple "
+ "sequential refcount blocks "
+ "created!\n"));
exit(1);
}
}
offset += img->cluster_size;
if (update_refcount(fd, img, offset,
offset)) {
- fprintf(stderr,
- "Programming error: multiple sequential refcount "
- "blocks created!\n");
+ fprintf(stderr, "%s",
+ _("Programming error: multiple sequential refcount "
+ "blocks created!\n"));
exit(1);
}
}
free_qcow2_image(img);
}
-static void write_raw_image_file(ext2_filsys fs, int fd, int type, int flags)
+static void write_raw_image_file(ext2_filsys fs, int fd, int type, int flags,
+ blk64_t superblock)
{
struct process_block_struct pb;
struct ext2_inode inode;
char * block_buf;
meta_blocks_count = 0;
- retval = ext2fs_allocate_block_bitmap(fs, "in-use block map",
+ retval = ext2fs_allocate_block_bitmap(fs, _("in-use block map"),
&meta_block_map);
if (retval) {
- com_err(program_name, retval, "while allocating block bitmap");
+ com_err(program_name, retval, "%s",
+ _("while allocating block bitmap"));
exit(1);
}
retval = ext2fs_allocate_block_bitmap(fs, "scramble block map",
&scramble_block_map);
if (retval) {
- com_err(program_name, retval,
- "while allocating scramble block bitmap");
+ com_err(program_name, retval, "%s",
+ _("while allocating scramble block bitmap"));
exit(1);
}
}
+ if (superblock) {
+ int j;
+
+ ext2fs_mark_block_bitmap2(meta_block_map, superblock);
+ meta_blocks_count++;
+
+ /*
+ * Mark the backup superblock descriptors
+ */
+ for (j = 0; j < fs->desc_blocks; j++) {
+ ext2fs_mark_block_bitmap2(meta_block_map,
+ ext2fs_descriptor_block_loc2(fs, superblock, j));
+ }
+ meta_blocks_count += fs->desc_blocks;
+ }
+
mark_table_blocks(fs);
if (show_progress)
- printf("Scanning inodes...\n");
+ fprintf(stderr, "%s", _("Scanning inodes...\n"));
retval = ext2fs_open_inode_scan(fs, 0, &scan);
if (retval) {
- com_err(program_name, retval,"%s",
+ com_err(program_name, retval, "%s",
_("while opening inode scan"));
exit(1);
}
process_dir_block, &pb);
if (retval) {
com_err(program_name, retval,
- "while iterating over inode %u",
+ _("while iterating over inode %u"),
ino);
exit(1);
}
process_file_block, &pb);
if (retval) {
com_err(program_name, retval,
- "while iterating over inode %u", ino);
+ _("while iterating over inode %u"), ino);
exit(1);
}
}
{
errcode_t retval;
ext2_filsys fs;
- int open_flag = EXT2_FLAG_IMAGE_FILE | EXT2_FLAG_64BITS;
+ int open_flag = EXT2_FLAG_IMAGE_FILE | EXT2_FLAG_64BITS |
+ EXT2_FLAG_IGNORE_CSUM_ERRORS;
int fd = 0;
io_manager io_ptr;
io_channel io;
if (type) {
- com_err(program_name, 0, "Raw and qcow2 images cannot"
- "be installed");
+ com_err(program_name, 0, "%s",
+ _("Raw and qcow2 images cannot be installed"));
exit(1);
}
retval = ext2fs_open (image_fn, open_flag, 0, 0,
io_ptr, &fs);
if (retval) {
- com_err (program_name, retval, _("while trying to open %s"),
- image_fn);
+ com_err(program_name, retval, _("while trying to open %s"),
+ image_fn);
exit(1);
}
retval = ext2fs_read_bitmaps (fs);
if (retval) {
- com_err(program_name, retval, "error reading bitmaps");
+ com_err(program_name, retval, "%s", _("error reading bitmaps"));
exit(1);
}
retval = io_ptr->open(device, IO_FLAG_RW, &io);
if (retval) {
- com_err(device, 0, "while opening device file");
+ com_err(device, 0, "%s", _("while opening device file"));
exit(1);
}
ext2fs_rewrite_to_io(fs, io);
- seek_set(fd, fs->image_header->offset_inode);
+ seek_set(fd, ext2fs_le32_to_cpu(fs->image_header->offset_inode));
retval = ext2fs_image_inode_read(fs, fd, 0);
if (retval) {
- com_err(image_fn, 0, "while restoring the image table");
+ com_err(image_fn, 0, "%s",
+ _("while restoring the image table"));
exit(1);
}
close(fd);
- ext2fs_close (fs);
+ ext2fs_close_free(&fs);
}
static struct ext2_qcow2_hdr *check_qcow2_image(int *fd, char *name)
ext2_filsys fs;
char *image_fn, offset_opt[64];
struct ext2_qcow2_hdr *header = NULL;
- int open_flag = EXT2_FLAG_64BITS;
+ int open_flag = EXT2_FLAG_64BITS | EXT2_FLAG_IGNORE_CSUM_ERRORS;
int img_type = 0;
int flags = 0;
int mount_flags = 0;
int ignore_rw_mount = 0;
int check = 0;
struct stat st;
+ blk64_t superblock = 0;
+ int blocksize = 0;
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
if (argc && *argv)
program_name = *argv;
add_error_table(&et_ext2_error_table);
- while ((c = getopt(argc, argv, "nrsIQafo:O:pc")) != EOF)
+ while ((c = getopt(argc, argv, "b:B:nrsIQafo:O:pc")) != EOF)
switch (c) {
+ case 'b':
+ superblock = strtoull(optarg, NULL, 0);
+ break;
+ case 'B':
+ blocksize = strtoul(optarg, NULL, 0);
+ break;
case 'I':
flags |= E2IMAGE_INSTALL_FLAG;
break;
usage();
if (all_data && !img_type) {
- com_err(program_name, 0, "-a option can only be used "
- "with raw or QCOW2 images.");
+ com_err(program_name, 0, "%s", _("-a option can only be used "
+ "with raw or QCOW2 images."));
+ exit(1);
+ }
+ if (superblock && !img_type) {
+ com_err(program_name, 0, "%s", _("-b option can only be used "
+ "with raw or QCOW2 images."));
exit(1);
}
if ((source_offset || dest_offset) && img_type != E2IMAGE_RAW) {
- com_err(program_name, 0,
- "Offsets are only allowed with raw images.");
+ com_err(program_name, 0, "%s",
+ _("Offsets are only allowed with raw images."));
exit(1);
}
if (move_mode && img_type != E2IMAGE_RAW) {
- com_err(program_name, 0,
- "Move mode is only allowed with raw images.");
+ com_err(program_name, 0, "%s",
+ _("Move mode is only allowed with raw images."));
exit(1);
}
if (move_mode && !all_data) {
- com_err(program_name, 0,
- "Move mode requires all data mode.");
+ com_err(program_name, 0, "%s",
+ _("Move mode requires all data mode."));
exit(1);
}
device_name = argv[optind];
retval = ext2fs_check_if_mounted(device_name, &mount_flags);
if (retval) {
- com_err(program_name, retval, "checking if mounted");
+ com_err(program_name, retval, "%s", _("checking if mounted"));
exit(1);
}
if (img_type && !ignore_rw_mount &&
(mount_flags & EXT2_MF_MOUNTED) &&
!(mount_flags & EXT2_MF_READONLY)) {
- fprintf(stderr, "\nRunning e2image on a R/W mounted "
+ fprintf(stderr, "%s", _("\nRunning e2image on a R/W mounted "
"filesystem can result in an\n"
"inconsistent image which will not be useful "
"for debugging purposes.\n"
- "Use -f option if you really want to do that.\n");
+ "Use -f option if you really want to do that.\n"));
exit(1);
}
}
}
sprintf(offset_opt, "offset=%llu", source_offset);
- retval = ext2fs_open2(device_name, offset_opt, open_flag, 0, 0,
- unix_io_manager, &fs);
+ retval = ext2fs_open2(device_name, offset_opt, open_flag,
+ superblock, blocksize, unix_io_manager, &fs);
if (retval) {
com_err (program_name, retval, _("while trying to open %s"),
device_name);
fputs(_("Couldn't find valid filesystem superblock.\n"), stdout);
+ if (retval == EXT2_ET_BAD_MAGIC)
+ check_plausibility(device_name, CHECK_FS_EXIST, NULL);
exit(1);
}
seek_set(fd, dest_offset);
if ((img_type & E2IMAGE_QCOW2) && (fd == 1)) {
- com_err(program_name, 0, "QCOW2 image can not be written to "
- "the stdout!\n");
+ com_err(program_name, 0, "%s",
+ _("QCOW2 image can not be written to the stdout!\n"));
exit(1);
}
if (fd != 1) {
if (fstat(fd, &st)) {
- com_err(program_name, 0, "Can not stat output\n");
+ com_err(program_name, 0, "%s",
+ _("Can not stat output\n"));
exit(1);
}
- if (S_ISBLK(st.st_mode))
+ if (ext2fsP_is_disk_device(st.st_mode))
output_is_blk = 1;
}
if (flags & E2IMAGE_IS_QCOW2_FLAG) {
ret = qcow2_write_raw_image(qcow2_fd, fd, header);
if (ret) {
if (ret == -QCOW_COMPRESSED)
- fprintf(stderr, "Image (%s) is compressed\n",
+ fprintf(stderr, _("Image (%s) is compressed\n"),
image_fn);
- if (ret == -QCOW_ENCRYPTED)
- fprintf(stderr, "Image (%s) is encrypted\n",
+ else if (ret == -QCOW_ENCRYPTED)
+ fprintf(stderr, _("Image (%s) is encrypted\n"),
image_fn);
- com_err(program_name, ret,
- _("while trying to convert qcow2 image"
- " (%s) into raw image (%s)"),
- device_name, image_fn);
+ else if (ret == -QCOW_CORRUPTED)
+ fprintf(stderr, _("Image (%s) is corrupted\n"),
+ image_fn);
+ else
+ com_err(program_name, ret,
+ _("while trying to convert qcow2 image"
+ " (%s) into raw image (%s)"),
+ image_fn, device_name);
+ ret = 1;
}
goto out;
}
if (check) {
if (img_type != E2IMAGE_RAW) {
- fprintf(stderr, _("The -c option only supported "
- "in raw mode\n"));
+ fprintf(stderr, "%s", _("The -c option only supported "
+ "in raw mode\n"));
exit(1);
}
if (fd == 1) {
- fprintf(stderr, _("The -c option is not supported "
- "when writing to stdout\n"));
+ fprintf(stderr, "%s", _("The -c option not supported "
+ "when writing to stdout\n"));
exit(1);
}
retval = ext2fs_get_mem(fs->blocksize, &check_buf);
if (retval) {
- com_err(program_name, retval,
- "while allocating check_buf");
+ com_err(program_name, retval, "%s",
+ _("while allocating check_buf"));
exit(1);
}
}
-
+ if (show_progress && (img_type != E2IMAGE_RAW)) {
+ fprintf(stderr, "%s",
+ _("The -p option only supported in raw mode\n"));
+ exit(1);
+ }
if (img_type)
- write_raw_image_file(fs, fd, img_type, flags);
+ write_raw_image_file(fs, fd, img_type, flags, superblock);
else
write_image_file(fs, fd);
- ext2fs_close (fs);
+ ext2fs_close_free(&fs);
if (check)
- printf("%d blocks already contained the data to be copied.\n",
+ printf(_("%d blocks already contained the data to be copied\n"),
skipped_blocks);
out: