misc/e2image.c

   1 /*
   2  * e2image.c --- Program which writes an image file backing up
   3  * critical metadata for the filesystem.
   4  *
   5  * Copyright 2000, 2001 by Theodore Ts'o.
   6  *
   7  * %Begin-Header%
   8  * This file may be redistributed under the terms of the GNU Public
   9  * License.
  10  * %End-Header%
  11  */
  12
  13 #define _LARGEFILE_SOURCE
  14 #define _LARGEFILE64_SOURCE
  15
  16 #include <fcntl.h>
  17 #include <grp.h>
  18 #ifdef HAVE_GETOPT_H
  19 #include <getopt.h>
  20 #else
  21 extern char *optarg;
  22 extern int optind;
  23 #endif
  24 #include <pwd.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <time.h>
  29 #include <unistd.h>
  30 #include <fcntl.h>
  31 #include <errno.h>
  32 #include <sys/stat.h>
  33 #include <sys/types.h>
  34
  35 #include "ext2fs/ext2_fs.h"
  36 #include "ext2fs/ext2fs.h"
  37 #include "et/com_err.h"
  38 #include "uuid/uuid.h"
  39 #include "e2p/e2p.h"
  40 #include "ext2fs/e2image.h"
  41
  42 #include "../version.h"
  43 #include "nls-enable.h"
  44
  45 const char * program_name = "e2image";
  46 char * device_name = NULL;
  47
  48 static void usage(void)
  49 {
  50         fprintf(stderr, _("Usage: %s [-rsI] device image_file\n"),
  51                 program_name);
  52         exit (1);
  53 }
  54
  55 static void write_header(int fd, struct ext2_image_hdr *hdr, int blocksize)
  56 {
  57         char *header_buf;
  58         int actual;
  59
  60         header_buf = malloc(blocksize);
  61         if (!header_buf) {
  62                 fputs(_("Couldn't allocate header buffer\n"), stderr);
  63                 exit(1);
  64         }
  65
  66         if (lseek(fd, 0, SEEK_SET) < 0) {
  67                 perror("lseek while writing header");
  68                 exit(1);
  69         }
  70         memset(header_buf, 0, blocksize);
  71
  72         if (hdr)
  73                 memcpy(header_buf, hdr, sizeof(struct ext2_image_hdr));
  74
  75         actual = write(fd, header_buf, blocksize);
  76         if (actual < 0) {
  77                 perror("write header");
  78                 exit(1);
  79         }
  80         if (actual != blocksize) {
  81                 fprintf(stderr, _("short write (only %d bytes) for "
  82                                   "writing image header"), actual);
  83                 exit(1);
  84         }
  85         free(header_buf);
  86 }
  87
  88 static void write_image_file(ext2_filsys fs, int fd)
  89 {
  90         struct ext2_image_hdr   hdr;
  91         struct stat             st;
  92         errcode_t               retval;
  93
  94         write_header(fd, NULL, fs->blocksize);
  95         memset(&hdr, 0, sizeof(struct ext2_image_hdr));
  96
  97         hdr.offset_super = lseek(fd, 0, SEEK_CUR);
  98         retval = ext2fs_image_super_write(fs, fd, 0);
  99         if (retval) {
 100                 com_err(program_name, retval, _("while writing superblock"));
 101                 exit(1);
 102         }
 103
 104         hdr.offset_inode = lseek(fd, 0, SEEK_CUR);
 105         retval = ext2fs_image_inode_write(fs, fd,
 106                                   (fd != 1) ? IMAGER_FLAG_SPARSEWRITE : 0);
 107         if (retval) {
 108                 com_err(program_name, retval, _("while writing inode table"));
 109                 exit(1);
 110         }
 111
 112         hdr.offset_blockmap = lseek(fd, 0, SEEK_CUR);
 113         retval = ext2fs_image_bitmap_write(fs, fd, 0);
 114         if (retval) {
 115                 com_err(program_name, retval, _("while writing block bitmap"));
 116                 exit(1);
 117         }
 118
 119         hdr.offset_inodemap = lseek(fd, 0, SEEK_CUR);
 120         retval = ext2fs_image_bitmap_write(fs, fd, IMAGER_FLAG_INODEMAP);
 121         if (retval) {
 122                 com_err(program_name, retval, _("while writing inode bitmap"));
 123                 exit(1);
 124         }
 125
 126         hdr.magic_number = EXT2_ET_MAGIC_E2IMAGE;
 127         strcpy(hdr.magic_descriptor, "Ext2 Image 1.0");
 128         gethostname(hdr.fs_hostname, sizeof(hdr.fs_hostname));
 129         strncpy(hdr.fs_device_name, device_name, sizeof(hdr.fs_device_name)-1);
 130         hdr.fs_device_name[sizeof(hdr.fs_device_name) - 1] = 0;
 131         hdr.fs_blocksize = fs->blocksize;
 132
 133         if (stat(device_name, &st) == 0)
 134                 hdr.fs_device = st.st_rdev;
 135
 136         if (fstat(fd, &st) == 0) {
 137                 hdr.image_device = st.st_dev;
 138                 hdr.image_inode = st.st_ino;
 139         }
 140         memcpy(hdr.fs_uuid, fs->super->s_uuid, sizeof(hdr.fs_uuid));
 141
 142         hdr.image_time = time(0);
 143         write_header(fd, &hdr, fs->blocksize);
 144 }
 145
 146 /*
 147  * These set of functions are used to write a RAW image file.
 148  */
 149 ext2fs_block_bitmap meta_block_map;
 150 ext2fs_block_bitmap scramble_block_map; /* Directory blocks to be scrambled */
 151
 152 struct process_block_struct {
 153         ext2_ino_t      ino;
 154         int             is_dir;
 155 };
 156
 157 /*
 158  * These subroutines short circuits ext2fs_get_blocks and
 159  * ext2fs_check_directory; we use them since we already have the inode
 160  * structure, so there's no point in letting the ext2fs library read
 161  * the inode again.
 162  */
 163 static ino_t stashed_ino = 0;
 164 static struct ext2_inode *stashed_inode;
 165
 166 static errcode_t meta_get_blocks(ext2_filsys fs EXT2FS_ATTR((unused)),
 167                                  ext2_ino_t ino,
 168                                  blk_t *blocks)
 169 {
 170         int     i;
 171
 172         if ((ino != stashed_ino) || !stashed_inode)
 173                 return EXT2_ET_CALLBACK_NOTHANDLED;
 174
 175         for (i=0; i < EXT2_N_BLOCKS; i++)
 176                 blocks[i] = stashed_inode->i_block[i];
 177         return 0;
 178 }
 179
 180 static errcode_t meta_check_directory(ext2_filsys fs EXT2FS_ATTR((unused)),
 181                                       ext2_ino_t ino)
 182 {
 183         if ((ino != stashed_ino) || !stashed_inode)
 184                 return EXT2_ET_CALLBACK_NOTHANDLED;
 185
 186         if (!LINUX_S_ISDIR(stashed_inode->i_mode))
 187                 return EXT2_ET_NO_DIRECTORY;
 188         return 0;
 189 }
 190
 191 static errcode_t meta_read_inode(ext2_filsys fs EXT2FS_ATTR((unused)),
 192                                  ext2_ino_t ino,
 193                                  struct ext2_inode *inode)
 194 {
 195         if ((ino != stashed_ino) || !stashed_inode)
 196                 return EXT2_ET_CALLBACK_NOTHANDLED;
 197         *inode = *stashed_inode;
 198         return 0;
 199 }
 200
 201 static void use_inode_shortcuts(ext2_filsys fs, int bool)
 202 {
 203         if (bool) {
 204                 fs->get_blocks = meta_get_blocks;
 205                 fs->check_directory = meta_check_directory;
 206                 fs->read_inode = meta_read_inode;
 207                 stashed_ino = 0;
 208         } else {
 209                 fs->get_blocks = 0;
 210                 fs->check_directory = 0;
 211                 fs->read_inode = 0;
 212         }
 213 }
 214
 215 static int process_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)),
 216                              blk_t *block_nr,
 217                              e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
 218                              blk_t ref_block EXT2FS_ATTR((unused)),
 219                              int ref_offset EXT2FS_ATTR((unused)),
 220                              void *priv_data EXT2FS_ATTR((unused)))
 221 {
 222         struct process_block_struct *p;
 223
 224         p = (struct process_block_struct *) priv_data;
 225
 226         ext2fs_mark_block_bitmap(meta_block_map, *block_nr);
 227         if (scramble_block_map && p->is_dir && blockcnt >= 0)
 228                 ext2fs_mark_block_bitmap(scramble_block_map, *block_nr);
 229         return 0;
 230 }
 231
 232 static int process_file_block(ext2_filsys fs EXT2FS_ATTR((unused)),
 233                               blk_t *block_nr,
 234                               e2_blkcnt_t blockcnt,
 235                               blk_t ref_block EXT2FS_ATTR((unused)),
 236                               int ref_offset EXT2FS_ATTR((unused)),
 237                               void *priv_data EXT2FS_ATTR((unused)))
 238 {
 239         if (blockcnt < 0) {
 240                 ext2fs_mark_block_bitmap(meta_block_map, *block_nr);
 241         }
 242         return 0;
 243 }
 244
 245 static void mark_table_blocks(ext2_filsys fs)
 246 {
 247         blk_t   first_block, b;
 248         unsigned int    i,j;
 249
 250         first_block = fs->super->s_first_data_block;
 251         /*
 252          * Mark primary superblock
 253          */
 254         ext2fs_mark_block_bitmap(meta_block_map, first_block);
 255
 256         /*
 257          * Mark the primary superblock descriptors
 258          */
 259         for (j = 0; j < fs->desc_blocks; j++) {
 260                 ext2fs_mark_block_bitmap(meta_block_map,
 261                          ext2fs_descriptor_block_loc(fs, first_block, j));
 262         }
 263
 264         for (i = 0; i < fs->group_desc_count; i++) {
 265                 /*
 266                  * Mark the blocks used for the inode table
 267                  */
 268                 if (fs->group_desc[i].bg_inode_table) {
 269                         for (j = 0, b = fs->group_desc[i].bg_inode_table;
 270                              j < (unsigned) fs->inode_blocks_per_group;
 271                              j++, b++)
 272                                 ext2fs_mark_block_bitmap(meta_block_map, b);
 273                 }
 274
 275                 /*
 276                  * Mark block used for the block bitmap
 277                  */
 278                 if (fs->group_desc[i].bg_block_bitmap) {
 279                         ext2fs_mark_block_bitmap(meta_block_map,
 280                                      fs->group_desc[i].bg_block_bitmap);
 281                 }
 282
 283                 /*
 284                  * Mark block used for the inode bitmap
 285                  */
 286                 if (fs->group_desc[i].bg_inode_bitmap) {
 287                         ext2fs_mark_block_bitmap(meta_block_map,
 288                                  fs->group_desc[i].bg_inode_bitmap);
 289                 }
 290         }
 291 }
 292
 293 /*
 294  * This function returns 1 if the specified block is all zeros
 295  */
 296 static int check_zero_block(char *buf, int blocksize)
 297 {
 298         char    *cp = buf;
 299         int     left = blocksize;
 300
 301         while (left > 0) {
 302                 if (*cp++)
 303                         return 0;
 304                 left--;
 305         }
 306         return 1;
 307 }
 308
 309 static void write_block(int fd, char *buf, int sparse_offset,
 310                         int blocksize, blk_t block)
 311 {
 312         int             count;
 313         errcode_t       err;
 314
 315         if (sparse_offset) {
 316 #ifdef HAVE_LSEEK64
 317                 if (lseek64(fd, sparse_offset, SEEK_CUR) < 0)
 318                         perror("lseek");
 319 #else
 320                 if (lseek(fd, sparse_offset, SEEK_CUR) < 0)
 321                         perror("lseek");
 322 #endif
 323         }
 324         if (blocksize) {
 325                 count = write(fd, buf, blocksize);
 326                 if (count != blocksize) {
 327                         if (count == -1)
 328                                 err = errno;
 329                         else
 330                                 err = 0;
 331                         com_err(program_name, err, "error writing block %u",
 332                                 block);
 333                         exit(1);
 334                 }
 335         }
 336 }
 337
 338 int name_id[256];
 339
 340 static void scramble_dir_block(ext2_filsys fs, blk_t blk, char *buf)
 341 {
 342         char *p, *end, *cp;
 343         struct ext2_dir_entry_2 *dirent;
 344         int rec_len, id, len;
 345
 346         end = buf + fs->blocksize;
 347         for (p = buf; p < end-8; p += rec_len) {
 348                 dirent = (struct ext2_dir_entry_2 *) p;
 349                 rec_len = dirent->rec_len;
 350 #ifdef EXT2FS_ENABLE_SWAPFS
 351                 if (fs->flags & EXT2_FLAG_SWAP_BYTES)
 352                         rec_len = ext2fs_swab16(rec_len);
 353 #endif
 354 #if 0
 355                 printf("rec_len = %d, name_len = %d\n", rec_len, dirent->name_len);
 356 #endif
 357                 if (rec_len < 8 || (rec_len % 4) ||
 358                     (p+rec_len > end)) {
 359                         printf("Corrupt directory block %lu: "
 360                                "bad rec_len (%d)\n", (unsigned long) blk,
 361                                rec_len);
 362                         rec_len = end - p;
 363 #ifdef EXT2FS_ENABLE_SWAPFS
 364                         if (fs->flags & EXT2_FLAG_SWAP_BYTES)
 365                                 dirent->rec_len = ext2fs_swab16(rec_len);
 366 #endif
 367                         continue;
 368                 }
 369                 if (dirent->name_len + 8 > rec_len) {
 370                         printf("Corrupt directory block %lu: "
 371                                "bad name_len (%d)\n", (unsigned long) blk,
 372                                dirent->name_len);
 373                         dirent->name_len = rec_len - 8;
 374                         continue;
 375                 }
 376                 cp = p+8;
 377                 len = rec_len - dirent->name_len - 8;
 378                 if (len > 0)
 379                         memset(cp+dirent->name_len, 0, len);
 380                 if (dirent->name_len==1 && cp[0] == '.')
 381                         continue;
 382                 if (dirent->name_len==2 && cp[0] == '.' && cp[1] == '.')
 383                         continue;
 384
 385                 memset(cp, 'A', dirent->name_len);
 386                 len = dirent->name_len;
 387                 id = name_id[len]++;
 388                 while ((len > 0) && (id > 0)) {
 389                         *cp += id % 26;
 390                         id = id / 26;
 391                         cp++;
 392                         len--;
 393                 }
 394         }
 395 }
 396
 397 static void output_meta_data_blocks(ext2_filsys fs, int fd)
 398 {
 399         errcode_t       retval;
 400         blk_t           blk;
 401         char            *buf, *zero_buf;
 402         int             sparse = 0;
 403
 404         buf = malloc(fs->blocksize);
 405         if (!buf) {
 406                 com_err(program_name, ENOMEM, "while allocating buffer");
 407                 exit(1);
 408         }
 409         zero_buf = malloc(fs->blocksize);
 410         if (!zero_buf) {
 411                 com_err(program_name, ENOMEM, "while allocating buffer");
 412                 exit(1);
 413         }
 414         memset(zero_buf, 0, fs->blocksize);
 415         for (blk = 0; blk < fs->super->s_blocks_count; blk++) {
 416                 if ((blk >= fs->super->s_first_data_block) &&
 417                     ext2fs_test_block_bitmap(meta_block_map, blk)) {
 418                         retval = io_channel_read_blk(fs->io, blk, 1, buf);
 419                         if (retval) {
 420                                 com_err(program_name, retval,
 421                                         "error reading block %u", blk);
 422                         }
 423                         if (scramble_block_map &&
 424                             ext2fs_test_block_bitmap(scramble_block_map, blk))
 425                                 scramble_dir_block(fs, blk, buf);
 426                         if ((fd != 1) && check_zero_block(buf, fs->blocksize))
 427                                 goto sparse_write;
 428                         write_block(fd, buf, sparse, fs->blocksize, blk);
 429                         sparse = 0;
 430                 } else {
 431                 sparse_write:
 432                         if (fd == 1) {
 433                                 write_block(fd, zero_buf, 0,
 434                                             fs->blocksize, blk);
 435                                 continue;
 436                         }
 437                         sparse += fs->blocksize;
 438                         if (sparse >= 1024*1024) {
 439                                 write_block(fd, 0, sparse, 0, 0);
 440                                 sparse = 0;
 441                         }
 442                 }
 443         }
 444         if (sparse)
 445                 write_block(fd, zero_buf, sparse-1, 1, -1);
 446         free(zero_buf);
 447         free(buf);
 448 }
 449
 450 static void write_raw_image_file(ext2_filsys fs, int fd, int scramble_flag)
 451 {
 452         struct process_block_struct     pb;
 453         struct ext2_inode               inode;
 454         ext2_inode_scan                 scan;
 455         ext2_ino_t                      ino;
 456         errcode_t                       retval;
 457         char *                          block_buf;
 458
 459         retval = ext2fs_allocate_block_bitmap(fs, "in-use block map",
 460                                               &meta_block_map);
 461         if (retval) {
 462                 com_err(program_name, retval, "while allocating block bitmap");
 463                 exit(1);
 464         }
 465
 466         if (scramble_flag) {
 467                 retval = ext2fs_allocate_block_bitmap(fs, "scramble block map",
 468                                                       &scramble_block_map);
 469                 if (retval) {
 470                         com_err(program_name, retval,
 471                                 "while allocating scramble block bitmap");
 472                         exit(1);
 473                 }
 474         }
 475
 476         mark_table_blocks(fs);
 477
 478         retval = ext2fs_open_inode_scan(fs, 0, &scan);
 479         if (retval) {
 480                 com_err(program_name, retval, _("while opening inode scan"));
 481                 exit(1);
 482         }
 483
 484         block_buf = malloc(fs->blocksize * 3);
 485         if (!block_buf) {
 486                 com_err(program_name, 0, "Can't allocate block buffer");
 487                 exit(1);
 488         }
 489
 490         use_inode_shortcuts(fs, 1);
 491         stashed_inode = &inode;
 492         while (1) {
 493                 retval = ext2fs_get_next_inode(scan, &ino, &inode);
 494                 if (retval == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE)
 495                         continue;
 496                 if (retval) {
 497                         com_err(program_name, retval,
 498                                 _("while getting next inode"));
 499                         exit(1);
 500                 }
 501                 if (ino == 0)
 502                         break;
 503                 if (!inode.i_links_count)
 504                         continue;
 505                 if (inode.i_file_acl) {
 506                         ext2fs_mark_block_bitmap(meta_block_map,
 507                                                  inode.i_file_acl);
 508                 }
 509                 if (!ext2fs_inode_has_valid_blocks(&inode))
 510                         continue;
 511
 512                 stashed_ino = ino;
 513                 pb.ino = ino;
 514                 pb.is_dir = LINUX_S_ISDIR(inode.i_mode);
 515                 if (LINUX_S_ISDIR(inode.i_mode) ||
 516                     (LINUX_S_ISLNK(inode.i_mode) &&
 517                      ext2fs_inode_has_valid_blocks(&inode)) ||
 518                     ino == fs->super->s_journal_inum) {
 519                         retval = ext2fs_block_iterate2(fs, ino, 0,
 520                                        block_buf, process_dir_block, &pb);
 521                         if (retval) {
 522                                 com_err(program_name, retval,
 523                                         "while iterating over inode %u",
 524                                         ino);
 525                                 exit(1);
 526                         }
 527                 } else {
 528                         if (inode.i_block[EXT2_IND_BLOCK] ||
 529                             inode.i_block[EXT2_DIND_BLOCK] ||
 530                             inode.i_block[EXT2_TIND_BLOCK]) {
 531                                 retval = ext2fs_block_iterate2(fs,
 532                                        ino, 0, block_buf,
 533                                        process_file_block, &pb);
 534                                 if (retval) {
 535                                         com_err(program_name, retval,
 536                                         "while iterating over inode %u", ino);
 537                                         exit(1);
 538                                 }
 539                         }
 540                 }
 541         }
 542         use_inode_shortcuts(fs, 0);
 543         output_meta_data_blocks(fs, fd);
 544         free(block_buf);
 545 }
 546
 547 static void install_image(char *device, char *image_fn, int raw_flag)
 548 {
 549         errcode_t retval;
 550         ext2_filsys fs;
 551         int open_flag = EXT2_FLAG_IMAGE_FILE;
 552         int fd = 0;
 553         io_manager      io_ptr;
 554         io_channel      io, image_io;
 555
 556         if (raw_flag) {
 557                 com_err(program_name, 0, "Raw images cannot be installed");
 558                 exit(1);
 559         }
 560
 561 #ifdef CONFIG_TESTIO_DEBUG
 562         io_ptr = test_io_manager;
 563         test_io_backing_manager = unix_io_manager;
 564 #else
 565         io_ptr = unix_io_manager;
 566 #endif
 567
 568         retval = ext2fs_open (image_fn, open_flag, 0, 0,
 569                               io_ptr, &fs);
 570         if (retval) {
 571                 com_err (program_name, retval, _("while trying to open %s"),
 572                          image_fn);
 573                 exit(1);
 574         }
 575
 576         retval = ext2fs_read_bitmaps (fs);
 577         if (retval) {
 578                 com_err(program_name, retval, "error reading bitmaps");
 579                 exit(1);
 580         }
 581
 582 #ifdef HAVE_OPEN64
 583         fd = open64(image_fn, O_RDONLY);
 584 #else
 585         fd = open(image_fn, O_RDONLY);
 586 #endif
 587         if (fd < 0) {
 588                 perror(image_fn);
 589                 exit(1);
 590         }
 591
 592         retval = io_ptr->open(device, IO_FLAG_RW, &io);
 593         if (retval) {
 594                 com_err(device, 0, "while opening device file");
 595                 exit(1);
 596         }
 597
 598         image_io = fs->io;
 599
 600         ext2fs_rewrite_to_io(fs, io);
 601
 602         if (lseek(fd, fs->image_header->offset_inode, SEEK_SET) < 0) {
 603                 perror("lseek");
 604                 exit(1);
 605         }
 606
 607         retval = ext2fs_image_inode_read(fs, fd, 0);
 608         if (retval) {
 609                 com_err(image_fn, 0, "while restoring the image table");
 610                 exit(1);
 611         }
 612
 613         ext2fs_close (fs);
 614         exit (0);
 615 }
 616
 617 int main (int argc, char ** argv)
 618 {
 619         int c;
 620         errcode_t retval;
 621         ext2_filsys fs;
 622         char *image_fn;
 623         int open_flag = 0;
 624         int raw_flag = 0;
 625         int install_flag = 0;
 626         int scramble_flag = 0;
 627         int fd = 0;
 628
 629 #ifdef ENABLE_NLS
 630         setlocale(LC_MESSAGES, "");
 631         setlocale(LC_CTYPE, "");
 632         bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
 633         textdomain(NLS_CAT_NAME);
 634 #endif
 635         fprintf (stderr, "e2image %s (%s)\n", E2FSPROGS_VERSION,
 636                  E2FSPROGS_DATE);
 637         if (argc && *argv)
 638                 program_name = *argv;
 639         add_error_table(&et_ext2_error_table);
 640         while ((c = getopt (argc, argv, "rsI")) != EOF)
 641                 switch (c) {
 642                 case 'r':
 643                         raw_flag++;
 644                         break;
 645                 case 's':
 646                         scramble_flag++;
 647                         break;
 648                 case 'I':
 649                         install_flag++;
 650                         break;
 651                 default:
 652                         usage();
 653                 }
 654         if (optind != argc - 2 )
 655                 usage();
 656         device_name = argv[optind];
 657         image_fn = argv[optind+1];
 658
 659         if (install_flag) {
 660                 install_image(device_name, image_fn, raw_flag);
 661                 exit (0);
 662         }
 663
 664         retval = ext2fs_open (device_name, open_flag, 0, 0,
 665                               unix_io_manager, &fs);
 666         if (retval) {
 667                 com_err (program_name, retval, _("while trying to open %s"),
 668                          device_name);
 669                 fputs(_("Couldn't find valid filesystem superblock.\n"), stdout);
 670                 exit(1);
 671         }
 672
 673         if (strcmp(image_fn, "-") == 0)
 674                 fd = 1;
 675         else {
 676 #ifdef HAVE_OPEN64
 677                 fd = open64(image_fn, O_CREAT|O_TRUNC|O_WRONLY, 0600);
 678 #else
 679                 fd = open(image_fn, O_CREAT|O_TRUNC|O_WRONLY, 0600);
 680 #endif
 681                 if (fd < 0) {
 682                         com_err(program_name, errno,
 683                                 _("while trying to open %s"), argv[optind+1]);
 684                         exit(1);
 685                 }
 686         }
 687
 688         if (raw_flag)
 689                 write_raw_image_file(fs, fd, scramble_flag);
 690         else
 691                 write_image_file(fs, fd);
 692
 693         ext2fs_close (fs);
 694         remove_error_table(&et_ext2_error_table);
 695         exit (0);
 696 }