disk-utils/fsck.cramfs.c

   1 /*
   2  * cramfsck - check a cramfs file system
   3  *
   4  * Copyright (C) 2000-2002 Transmeta Corporation
   5  *               2005 Adrian Bunk
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * 1999/12/03: Linus Torvalds (cramfs tester and unarchive program)
  22  * 2000/06/03: Daniel Quinlan (CRC and length checking program)
  23  * 2000/06/04: Daniel Quinlan (merged programs, added options, support
  24  *                            for special files, preserve permissions and
  25  *                            ownership, cramfs superblock v2, bogus mode
  26  *                            test, pathname length test, etc.)
  27  * 2000/06/06: Daniel Quinlan (support for holes, pretty-printing,
  28  *                            symlink size test)
  29  * 2000/07/11: Daniel Quinlan (file length tests, start at offset 0 or 512,
  30  *                            fsck-compatible exit codes)
  31  * 2000/07/15: Daniel Quinlan (initial support for block devices)
  32  * 2002/01/10: Daniel Quinlan (additional checks, test more return codes,
  33  *                            use read if mmap fails, standardize messages)
  34  */
  35
  36 #include <stdio.h>
  37 #include <stdarg.h>
  38 #include <stdint.h>
  39 #include <unistd.h>
  40 #include <dirent.h>
  41 #include <stdlib.h>
  42 #include <errno.h>
  43 #include <string.h>
  44 #include <getopt.h>
  45 #include <utime.h>
  46 #include <fcntl.h>
  47
  48 /* We don't use our include/crc32.h, but crc32 from zlib!
  49  *
  50  * The zlib implemenation performs pre/post-conditioning. The util-linux
  51  * imlemenation requires post-conditioning (xor) in the applications.
  52  */
  53 #include <zlib.h>
  54
  55 #include <sys/types.h>
  56 #include <sys/stat.h>
  57 #include <sys/mman.h>
  58
  59 #include "c.h"
  60 #include "cramfs.h"
  61 #include "nls.h"
  62 #include "blkdev.h"
  63 #include "exitcodes.h"
  64 #include "strutils.h"
  65 #include "closestream.h"
  66
  67 #define XALLOC_EXIT_CODE FSCK_EX_ERROR
  68 #include "xalloc.h"
  69
  70 static int fd;                  /* ROM image file descriptor */
  71 static char *filename;          /* ROM image filename */
  72 struct cramfs_super super;      /* just find the cramfs superblock once */
  73 static int cramfs_is_big_endian = 0;    /* source is big endian */
  74 static int opt_verbose = 0;     /* 1 = verbose (-v), 2+ = very verbose (-vv) */
  75 static int opt_extract = 0;     /* extract cramfs (-x) */
  76 char *extract_dir = "";         /* optional extraction directory (-x) */
  77
  78 #define PAD_SIZE 512
  79
  80 static uid_t euid;              /* effective UID */
  81
  82 /* (cramfs_super + start) <= start_dir < end_dir <= start_data <= end_data */
  83 static unsigned long start_dir = ~0UL;  /* start of first non-root inode */
  84 static unsigned long end_dir = 0;       /* end of the directory structure */
  85 static unsigned long start_data = ~0UL; /* start of the data (256 MB = max) */
  86 static unsigned long end_data = 0;      /* end of the data */
  87
  88
  89 /* Guarantee access to at least 8kB at a time */
  90 #define ROMBUFFER_BITS  13
  91 #define ROMBUFFERSIZE   (1 << ROMBUFFER_BITS)
  92 #define ROMBUFFERMASK   (ROMBUFFERSIZE - 1)
  93 static char read_buffer[ROMBUFFERSIZE * 2];
  94 static unsigned long read_buffer_block = ~0UL;
  95
  96 static z_stream stream;
  97
  98 /* Prototypes */
  99 static void expand_fs(char *, struct cramfs_inode *);
 100
 101 static char *outbuffer;
 102
 103 static size_t blksize = 0;
 104
 105
 106 /* Input status of 0 to print help and exit without an error. */
 107 static void __attribute__((__noreturn__)) usage(int status)
 108 {
 109         FILE *out = status ? stderr : stdout;
 110
 111         fputs(USAGE_HEADER, out);
 112         fprintf(out,
 113                 _(" %s [options] <file>\n"), program_invocation_short_name);
 114
 115         fputs(USAGE_SEPARATOR, out);
 116         fputs(_("Check and repair a compressed ROM filesystem.\n"), out);
 117
 118         fputs(USAGE_OPTIONS, out);
 119         fputs(_(" -a                       for compatibility only, ignored\n"), out);
 120         fputs(_(" -v, --verbose            be more verbose\n"), out);
 121         fputs(_(" -y                       for compatibility only, ignored\n"), out);
 122         fputs(_(" -b, --blocksize <size>   use this blocksize, defaults to page size\n"), out);
 123         fputs(_("     --extract[=<dir>]    test uncompression, optionally extract into <dir>\n"), out);
 124         fputs(USAGE_SEPARATOR, out);
 125         fputs(USAGE_HELP, out);
 126         fputs(USAGE_VERSION, out);
 127         fputs(USAGE_SEPARATOR, out);
 128
 129         exit(status);
 130 }
 131
 132 static int get_superblock_endianness(uint32_t magic)
 133 {
 134         if (magic == CRAMFS_MAGIC) {
 135                 cramfs_is_big_endian = HOST_IS_BIG_ENDIAN;
 136                 return 0;
 137         } else if (magic ==
 138                    u32_toggle_endianness(!HOST_IS_BIG_ENDIAN, CRAMFS_MAGIC)) {
 139                 cramfs_is_big_endian = !HOST_IS_BIG_ENDIAN;
 140                 return 0;
 141         } else
 142                 return -1;
 143 }
 144
 145 static void test_super(int *start, size_t * length)
 146 {
 147         struct stat st;
 148
 149         /* find the physical size of the file or block device */
 150         if (stat(filename, &st) < 0)
 151                 err(FSCK_EX_ERROR, _("stat of %s failed"), filename);
 152
 153         fd = open(filename, O_RDONLY);
 154         if (fd < 0)
 155                 err(FSCK_EX_ERROR, _("cannot open %s"), filename);
 156
 157         if (S_ISBLK(st.st_mode)) {
 158                 unsigned long long bytes;
 159                 if (blkdev_get_size(fd, &bytes))
 160                         err(FSCK_EX_ERROR,
 161                             _("ioctl failed: unable to determine device size: %s"),
 162                             filename);
 163                 *length = bytes;
 164         } else if (S_ISREG(st.st_mode))
 165                 *length = st.st_size;
 166         else
 167                 errx(FSCK_EX_ERROR, _("not a block device or file: %s"), filename);
 168
 169         if (*length < sizeof(struct cramfs_super))
 170                 errx(FSCK_EX_UNCORRECTED, _("file length too short"));
 171
 172         /* find superblock */
 173         if (read(fd, &super, sizeof(super)) != sizeof(super))
 174                 err(FSCK_EX_ERROR, _("cannot read %s"), filename);
 175         if (get_superblock_endianness(super.magic) != -1)
 176                 *start = 0;
 177         else if (*length >= (PAD_SIZE + sizeof(super))) {
 178                 if (lseek(fd, PAD_SIZE, SEEK_SET) == (off_t) -1)
 179                         err(FSCK_EX_ERROR, _("seek on %s failed"), filename);
 180                 if (read(fd, &super, sizeof(super)) != sizeof(super))
 181                         err(FSCK_EX_ERROR, _("cannot read %s"), filename);
 182                 if (get_superblock_endianness(super.magic) != -1)
 183                         *start = PAD_SIZE;
 184                 else
 185                         errx(FSCK_EX_UNCORRECTED, _("superblock magic not found"));
 186         } else
 187                 errx(FSCK_EX_UNCORRECTED, _("superblock magic not found"));
 188
 189         if (opt_verbose)
 190                 printf(_("cramfs endianness is %s\n"),
 191                        cramfs_is_big_endian ? _("big") : _("little"));
 192
 193         super_toggle_endianness(cramfs_is_big_endian, &super);
 194         if (super.flags & ~CRAMFS_SUPPORTED_FLAGS)
 195                 errx(FSCK_EX_ERROR, _("unsupported filesystem features"));
 196
 197         /* What are valid superblock sizes? */
 198         if (super.size < sizeof(struct cramfs_super))
 199                 errx(FSCK_EX_UNCORRECTED, _("superblock size (%d) too small"),
 200                      super.size);
 201
 202         if (super.flags & CRAMFS_FLAG_FSID_VERSION_2) {
 203                 if (super.fsid.files == 0)
 204                         errx(FSCK_EX_UNCORRECTED, _("zero file count"));
 205                 if (*length < super.size)
 206                         errx(FSCK_EX_UNCORRECTED, _("file length too short"));
 207                 else if (*length > super.size)
 208                         warnx(_("file extends past end of filesystem"));
 209         } else
 210                 warnx(_("old cramfs format"));
 211 }
 212
 213 static void test_crc(int start)
 214 {
 215         void *buf;
 216         uint32_t crc;
 217
 218         if (!(super.flags & CRAMFS_FLAG_FSID_VERSION_2)) {
 219                 warnx(_("unable to test CRC: old cramfs format"));
 220                 return;
 221         }
 222
 223         crc = crc32(0L, Z_NULL, 0);
 224
 225         buf =
 226             mmap(NULL, super.size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
 227         if (buf == MAP_FAILED) {
 228                 buf =
 229                     mmap(NULL, super.size, PROT_READ | PROT_WRITE,
 230                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 231                 if (buf != MAP_FAILED) {
 232                         if (lseek(fd, 0, SEEK_SET) == (off_t) -1)
 233                                 err(FSCK_EX_ERROR, _("seek on %s failed"), filename);
 234                         if (read(fd, buf, super.size) != (ssize_t) super.size)
 235                                 err(FSCK_EX_ERROR, _("cannot read %s"), filename);
 236                 }
 237         }
 238         if (buf != MAP_FAILED) {
 239                 ((struct cramfs_super *)((unsigned char *) buf + start))->fsid.crc =
 240                     crc32(0L, Z_NULL, 0);
 241                 crc = crc32(crc, (unsigned char *) buf + start, super.size - start);
 242                 munmap(buf, super.size);
 243         } else {
 244                 int retval;
 245                 size_t length = 0;
 246
 247                 buf = xmalloc(4096);
 248                 if (lseek(fd, start, SEEK_SET) == (off_t) -1)
 249                         err(FSCK_EX_ERROR, _("seek on %s failed"), filename);
 250                 for (;;) {
 251                         retval = read(fd, buf, 4096);
 252                         if (retval < 0)
 253                                 err(FSCK_EX_ERROR, _("cannot read %s"), filename);
 254                         else if (retval == 0)
 255                                 break;
 256                         if (length == 0)
 257                                 ((struct cramfs_super *)buf)->fsid.crc =
 258                                     crc32(0L, Z_NULL, 0);
 259                         length += retval;
 260                         if (length > (super.size - start)) {
 261                                 crc = crc32(crc, buf,
 262                                           retval - (length -
 263                                                     (super.size - start)));
 264                                 break;
 265                         }
 266                         crc = crc32(crc, buf, retval);
 267                 }
 268                 free(buf);
 269         }
 270
 271         if (crc != super.fsid.crc)
 272                 errx(FSCK_EX_UNCORRECTED, _("crc error"));
 273 }
 274
 275 static void print_node(char type, struct cramfs_inode *i, char *name)
 276 {
 277         char info[10];
 278
 279         if (S_ISCHR(i->mode) || (S_ISBLK(i->mode)))
 280                 /* major/minor numbers can be as high as 2^12 or 4096 */
 281                 snprintf(info, 10, "%4d,%4d", major(i->size), minor(i->size));
 282         else
 283                 /* size be as high as 2^24 or 16777216 */
 284                 snprintf(info, 10, "%9d", i->size);
 285
 286         printf("%c %04o %s %5d:%-3d %s\n",
 287                type, i->mode & ~S_IFMT, info, i->uid, i->gid,
 288                !*name && type == 'd' ? "/" : name);
 289 }
 290
 291 /*
 292  * Create a fake "blocked" access
 293  */
 294 static void *romfs_read(unsigned long offset)
 295 {
 296         unsigned int block = offset >> ROMBUFFER_BITS;
 297         if (block != read_buffer_block) {
 298                 ssize_t x;
 299
 300                 read_buffer_block = block;
 301                 if (lseek(fd, block << ROMBUFFER_BITS, SEEK_SET) == (off_t) -1)
 302                         warn(_("seek failed"));
 303
 304                 x = read(fd, read_buffer, ROMBUFFERSIZE * 2);
 305                 if (x < 0)
 306                         warn(_("read romfs failed"));
 307         }
 308         return read_buffer + (offset & ROMBUFFERMASK);
 309 }
 310
 311 static struct cramfs_inode *cramfs_iget(struct cramfs_inode *i)
 312 {
 313         struct cramfs_inode *inode = xmalloc(sizeof(struct cramfs_inode));
 314
 315         inode_to_host(cramfs_is_big_endian, i, inode);
 316         return inode;
 317 }
 318
 319 static struct cramfs_inode *iget(unsigned int ino)
 320 {
 321         return cramfs_iget(romfs_read(ino));
 322 }
 323
 324 static void iput(struct cramfs_inode *inode)
 325 {
 326         free(inode);
 327 }
 328
 329 /*
 330  * Return the offset of the root directory
 331  */
 332 static struct cramfs_inode *read_super(void)
 333 {
 334         struct cramfs_inode *root = cramfs_iget(&super.root);
 335         unsigned long offset = root->offset << 2;
 336
 337         if (!S_ISDIR(root->mode))
 338                 errx(FSCK_EX_UNCORRECTED, _("root inode is not directory"));
 339         if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&
 340             ((offset != sizeof(struct cramfs_super)) &&
 341              (offset != PAD_SIZE + sizeof(struct cramfs_super)))) {
 342                 errx(FSCK_EX_UNCORRECTED, _("bad root offset (%lu)"), offset);
 343         }
 344         return root;
 345 }
 346
 347 static int uncompress_block(void *src, size_t len)
 348 {
 349         int err;
 350
 351         stream.next_in = src;
 352         stream.avail_in = len;
 353
 354         stream.next_out = (unsigned char *)outbuffer;
 355         stream.avail_out = blksize * 2;
 356
 357         inflateReset(&stream);
 358
 359         if (len > blksize * 2)
 360                 errx(FSCK_EX_UNCORRECTED, _("data block too large"));
 361
 362         err = inflate(&stream, Z_FINISH);
 363         if (err != Z_STREAM_END)
 364                 errx(FSCK_EX_UNCORRECTED, _("decompression error: %s"),
 365                      zError(err));
 366         return stream.total_out;
 367 }
 368
 369 #if !HAVE_LCHOWN
 370 #define lchown chown
 371 #endif
 372
 373 static void do_uncompress(char *path, int outfd, unsigned long offset,
 374                           unsigned long size)
 375 {
 376         unsigned long curr = offset + 4 * ((size + blksize - 1) / blksize);
 377
 378         do {
 379                 unsigned long out = blksize;
 380                 unsigned long next = u32_toggle_endianness(cramfs_is_big_endian,
 381                                                            *(uint32_t *)
 382                                                            romfs_read(offset));
 383
 384                 if (next > end_data)
 385                         end_data = next;
 386
 387                 offset += 4;
 388                 if (curr == next) {
 389                         if (opt_verbose > 1)
 390                                 printf(_("  hole at %lu (%zu)\n"), curr,
 391                                        blksize);
 392                         if (size < blksize)
 393                                 out = size;
 394                         memset(outbuffer, 0x00, out);
 395                 } else {
 396                         if (opt_verbose > 1)
 397                                 printf(_("  uncompressing block at %lu to %lu (%lu)\n"),
 398                                        curr, next, next - curr);
 399                         out = uncompress_block(romfs_read(curr), next - curr);
 400                 }
 401                 if (size >= blksize) {
 402                         if (out != blksize)
 403                                 errx(FSCK_EX_UNCORRECTED,
 404                                      _("non-block (%ld) bytes"), out);
 405                 } else {
 406                         if (out != size)
 407                                 errx(FSCK_EX_UNCORRECTED,
 408                                      _("non-size (%ld vs %ld) bytes"), out,
 409                                      size);
 410                 }
 411                 size -= out;
 412                 if (*extract_dir != '\0' && write(outfd, outbuffer, out) < 0)
 413                         err(FSCK_EX_ERROR, _("write failed: %s"), path);
 414                 curr = next;
 415         } while (size);
 416 }
 417
 418 static void change_file_status(char *path, struct cramfs_inode *i)
 419 {
 420         struct utimbuf epoch = { 0, 0 };
 421
 422         if (euid == 0) {
 423                 if (lchown(path, i->uid, i->gid) < 0)
 424                         err(FSCK_EX_ERROR, _("lchown failed: %s"), path);
 425                 if (S_ISLNK(i->mode))
 426                         return;
 427                 if (((S_ISUID | S_ISGID) & i->mode) && chmod(path, i->mode) < 0)
 428                         err(FSCK_EX_ERROR, _("chown failed: %s"), path);
 429         }
 430         if (S_ISLNK(i->mode))
 431                 return;
 432         if (utime(path, &epoch) < 0)
 433                 err(FSCK_EX_ERROR, _("utime failed: %s"), path);
 434 }
 435
 436 static void do_directory(char *path, struct cramfs_inode *i)
 437 {
 438         int pathlen = strlen(path);
 439         int count = i->size;
 440         unsigned long offset = i->offset << 2;
 441         char *newpath = xmalloc(pathlen + 256);
 442
 443         if (offset == 0 && count != 0)
 444                 errx(FSCK_EX_UNCORRECTED,
 445                      _("directory inode has zero offset and non-zero size: %s"),
 446                      path);
 447
 448         if (offset != 0 && offset < start_dir)
 449                 start_dir = offset;
 450
 451         /* TODO: Do we need to check end_dir for empty case? */
 452         memcpy(newpath, path, pathlen);
 453         newpath[pathlen] = '/';
 454         pathlen++;
 455         if (opt_verbose)
 456                 print_node('d', i, path);
 457
 458         if (*extract_dir != '\0') {
 459                 if (mkdir(path, i->mode) < 0)
 460                         err(FSCK_EX_ERROR, _("mkdir failed: %s"), path);
 461                 change_file_status(path, i);
 462         }
 463         while (count > 0) {
 464                 struct cramfs_inode *child = iget(offset);
 465                 int size;
 466                 int newlen = child->namelen << 2;
 467
 468                 size = sizeof(struct cramfs_inode) + newlen;
 469                 count -= size;
 470
 471                 offset += sizeof(struct cramfs_inode);
 472
 473                 memcpy(newpath + pathlen, romfs_read(offset), newlen);
 474                 newpath[pathlen + newlen] = 0;
 475                 if (newlen == 0)
 476                         errx(FSCK_EX_UNCORRECTED, _("filename length is zero"));
 477                 if ((pathlen + newlen) - strlen(newpath) > 3)
 478                         errx(FSCK_EX_UNCORRECTED, _("bad filename length"));
 479                 expand_fs(newpath, child);
 480
 481                 offset += newlen;
 482
 483                 if (offset <= start_dir)
 484                         errx(FSCK_EX_UNCORRECTED, _("bad inode offset"));
 485                 if (offset > end_dir)
 486                         end_dir = offset;
 487                 iput(child);    /* free(child) */
 488         }
 489         free(newpath);
 490 }
 491
 492 static void do_file(char *path, struct cramfs_inode *i)
 493 {
 494         unsigned long offset = i->offset << 2;
 495         int outfd = 0;
 496
 497         if (offset == 0 && i->size != 0)
 498                 errx(FSCK_EX_UNCORRECTED,
 499                      _("file inode has zero offset and non-zero size"));
 500         if (i->size == 0 && offset != 0)
 501                 errx(FSCK_EX_UNCORRECTED,
 502                      _("file inode has zero size and non-zero offset"));
 503         if (offset != 0 && offset < start_data)
 504                 start_data = offset;
 505         if (opt_verbose)
 506                 print_node('f', i, path);
 507         if (*extract_dir != '\0') {
 508                 outfd = open(path, O_WRONLY | O_CREAT | O_TRUNC, i->mode);
 509                 if (outfd < 0)
 510                         err(FSCK_EX_ERROR, _("cannot open %s"), path);
 511         }
 512         if (i->size)
 513                 do_uncompress(path, outfd, offset, i->size);
 514         if ( *extract_dir != '\0') {
 515                 if (close_fd(outfd) != 0)
 516                         err(FSCK_EX_ERROR, _("write failed: %s"), path);
 517                 change_file_status(path, i);
 518         }
 519 }
 520
 521 static void do_symlink(char *path, struct cramfs_inode *i)
 522 {
 523         unsigned long offset = i->offset << 2;
 524         unsigned long curr = offset + 4;
 525         unsigned long next =
 526             u32_toggle_endianness(cramfs_is_big_endian,
 527                                   *(uint32_t *) romfs_read(offset));
 528         unsigned long size;
 529
 530         if (offset == 0)
 531                 errx(FSCK_EX_UNCORRECTED, _("symbolic link has zero offset"));
 532         if (i->size == 0)
 533                 errx(FSCK_EX_UNCORRECTED, _("symbolic link has zero size"));
 534
 535         if (offset < start_data)
 536                 start_data = offset;
 537         if (next > end_data)
 538                 end_data = next;
 539
 540         size = uncompress_block(romfs_read(curr), next - curr);
 541         if (size != i->size)
 542                 errx(FSCK_EX_UNCORRECTED, _("size error in symlink: %s"), path);
 543         outbuffer[size] = 0;
 544         if (opt_verbose) {
 545                 char *str;
 546
 547                 xasprintf(&str, "%s -> %s", path, outbuffer);
 548                 print_node('l', i, str);
 549                 if (opt_verbose > 1)
 550                         printf(_("  uncompressing block at %lu to %lu (%lu)\n"),
 551                                curr, next, next - curr);
 552                 free(str);
 553         }
 554         if (*extract_dir != '\0') {
 555                 if (symlink(outbuffer, path) < 0)
 556                         err(FSCK_EX_ERROR, _("symlink failed: %s"), path);
 557                 change_file_status(path, i);
 558         }
 559 }
 560
 561 static void do_special_inode(char *path, struct cramfs_inode *i)
 562 {
 563         dev_t devtype = 0;
 564         char type;
 565
 566         if (i->offset)
 567                 /* no need to shift offset */
 568                 errx(FSCK_EX_UNCORRECTED,
 569                      _("special file has non-zero offset: %s"), path);
 570
 571         if (S_ISCHR(i->mode)) {
 572                 devtype = i->size;
 573                 type = 'c';
 574         } else if (S_ISBLK(i->mode)) {
 575                 devtype = i->size;
 576                 type = 'b';
 577         } else if (S_ISFIFO(i->mode)) {
 578                 if (i->size != 0)
 579                         errx(FSCK_EX_UNCORRECTED, _("fifo has non-zero size: %s"),
 580                              path);
 581                 type = 'p';
 582         } else if (S_ISSOCK(i->mode)) {
 583                 if (i->size != 0)
 584                         errx(FSCK_EX_UNCORRECTED,
 585                              _("socket has non-zero size: %s"), path);
 586                 type = 's';
 587         } else {
 588                 errx(FSCK_EX_UNCORRECTED, _("bogus mode: %s (%o)"), path, i->mode);
 589                 return;         /* not reached */
 590         }
 591
 592         if (opt_verbose)
 593                 print_node(type, i, path);
 594
 595         if (*extract_dir != '\0') {
 596                 if (mknod(path, i->mode, devtype) < 0)
 597                         err(FSCK_EX_ERROR, _("mknod failed: %s"), path);
 598                 change_file_status(path, i);
 599         }
 600 }
 601
 602 static void expand_fs(char *path, struct cramfs_inode *inode)
 603 {
 604         if (S_ISDIR(inode->mode))
 605                 do_directory(path, inode);
 606         else if (S_ISREG(inode->mode))
 607                 do_file(path, inode);
 608         else if (S_ISLNK(inode->mode))
 609                 do_symlink(path, inode);
 610         else
 611                 do_special_inode(path, inode);
 612 }
 613
 614 static void test_fs(int start)
 615 {
 616         struct cramfs_inode *root;
 617
 618         root = read_super();
 619         umask(0);
 620         euid = geteuid();
 621         stream.next_in = NULL;
 622         stream.avail_in = 0;
 623         inflateInit(&stream);
 624         expand_fs(extract_dir, root);
 625         inflateEnd(&stream);
 626         if (start_data != ~0UL) {
 627                 if (start_data < (sizeof(struct cramfs_super) + start))
 628                         errx(FSCK_EX_UNCORRECTED,
 629                              _("directory data start (%lu) < sizeof(struct cramfs_super) + start (%zu)"),
 630                              start_data, sizeof(struct cramfs_super) + start);
 631                 if (end_dir != start_data)
 632                         errx(FSCK_EX_UNCORRECTED,
 633                              _("directory data end (%lu) != file data start (%lu)"),
 634                              end_dir, start_data);
 635         }
 636         if (super.flags & CRAMFS_FLAG_FSID_VERSION_2 && end_data > super.size)
 637                 errx(FSCK_EX_UNCORRECTED, _("invalid file data offset"));
 638
 639         iput(root);             /* free(root) */
 640 }
 641
 642 int main(int argc, char **argv)
 643 {
 644         int c;                  /* for getopt */
 645         int start = 0;
 646         size_t length = 0;
 647
 648         static const struct option longopts[] = {
 649                 {"verbose", no_argument, 0, 'v'},
 650                 {"version", no_argument, 0, 'V'},
 651                 {"help", no_argument, 0, 'h'},
 652                 {"blocksize", required_argument, 0, 'b'},
 653                 {"extract", optional_argument, 0, 'x'},
 654                 {NULL, no_argument, 0, '0'},
 655         };
 656
 657         setlocale(LC_MESSAGES, "");
 658         setlocale(LC_CTYPE, "");
 659         bindtextdomain(PACKAGE, LOCALEDIR);
 660         textdomain(PACKAGE);
 661         atexit(close_stdout);
 662
 663         /* command line options */
 664         while ((c = getopt_long(argc, argv, "ayvVhb:", longopts, NULL)) != EOF)
 665                 switch (c) {
 666                 case 'a':               /* ignore */
 667                 case 'y':
 668                         break;
 669                 case 'h':
 670                         usage(FSCK_EX_OK);
 671                         break;
 672                 case 'V':
 673                         printf(UTIL_LINUX_VERSION);
 674                         return EXIT_SUCCESS;
 675                 case 'x':
 676                         opt_extract = 1;
 677                         if(optarg)
 678                                 extract_dir = optarg;
 679                         break;
 680                 case 'v':
 681                         opt_verbose++;
 682                         break;
 683                 case 'b':
 684                         blksize = strtou32_or_err(optarg, _("invalid blocksize argument"));
 685                         break;
 686                 default:
 687                         errtryhelp(FSCK_EX_USAGE);
 688                 }
 689
 690         if ((argc - optind) != 1)
 691                 usage(FSCK_EX_USAGE);
 692         filename = argv[optind];
 693
 694         test_super(&start, &length);
 695         test_crc(start);
 696
 697         if(opt_extract) {
 698                 if (blksize == 0)
 699                         blksize = getpagesize();
 700                 outbuffer = xmalloc(blksize * 2);
 701                 test_fs(start);
 702         }
 703
 704         if (opt_verbose)
 705                 printf(_("%s: OK\n"), filename);
 706
 707         exit(FSCK_EX_OK);
 708 }