/*
* cramfsck - check a cramfs file system
*
- * Copyright (C) 2000-2001 Transmeta Corporation
+ * Copyright (C) 2000-2002 Transmeta Corporation
+ * 2005 Adrian Bunk
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* 2000/07/11: Daniel Quinlan (file length tests, start at offset 0 or 512,
* fsck-compatible exit codes)
* 2000/07/15: Daniel Quinlan (initial support for block devices)
+ * 2002/01/10: Daniel Quinlan (additional checks, test more return codes,
+ * use read if mmap fails, standardize messages)
*/
/* compile-time options */
-#define INCLUDE_FS_TESTS /* include cramfs checking and extraction */
+//#define INCLUDE_FS_TESTS /* include cramfs checking and extraction */
+#define _GNU_SOURCE
#include <stdio.h>
+#include <stdarg.h>
#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
static int fd; /* ROM image file descriptor */
static char *filename; /* ROM image filename */
-struct cramfs_super *super; /* just find the cramfs superblock once */
+struct cramfs_super super; /* just find the cramfs superblock once */
static int opt_verbose = 0; /* 1 = verbose (-v), 2+ = very verbose (-vv) */
-#ifdef INCLUDE_FS_TESTS
-static int opt_extract = 0; /* extract cramfs (-x) */
char *extract_dir = NULL; /* extraction directory (-x) */
-unsigned long start_inode = 1 << 28; /* start of first non-root inode */
-unsigned long end_inode = 0; /* end of the directory structure */
-unsigned long start_data = 1 << 28; /* start of the data (256 MB = max) */
-unsigned long end_data = 0; /* end of the data */
-/* true? cramfs_super < start_inode < end_inode <= start_data <= end_data */
-static uid_t euid; /* effective UID */
+/* Exit codes used by fsck-type programs */
+#define FSCK_OK 0 /* No errors */
+#define FSCK_NONDESTRUCT 1 /* File system errors corrected */
+#define FSCK_REBOOT 2 /* System should be rebooted */
+#define FSCK_UNCORRECTED 4 /* File system errors left uncorrected */
+#define FSCK_ERROR 8 /* Operational error */
+#define FSCK_USAGE 16 /* Usage or syntax error */
+#define FSCK_LIBRARY 128 /* Shared library error */
#define PAD_SIZE 512
-#include <asm/page.h>
-#ifdef PAGE_SIZE
-#define PAGE_CACHE_SIZE ((int) PAGE_SIZE)
-#elif defined __ia64__
-#define PAGE_CACHE_SIZE (16384)
-#elif defined __alpha__
-#define PAGE_CACHE_SIZE (8192)
-#else
-#define PAGE_CACHE_SIZE (4096)
-#endif
+#ifdef INCLUDE_FS_TESTS
+
+static int opt_extract = 0; /* extract cramfs (-x) */
+
+static uid_t euid; /* effective UID */
+
+/* (cramfs_super + start) <= start_dir < end_dir <= start_data <= end_data */
+static unsigned long start_dir = ~0UL; /* start of first non-root inode */
+static unsigned long end_dir = 0; /* end of the directory structure */
+static unsigned long start_data = ~0UL; /* start of the data (256 MB = max) */
+static unsigned long end_data = 0; /* end of the data */
+
/* Guarantee access to at least 8kB at a time */
#define ROMBUFFER_BITS 13
static char read_buffer[ROMBUFFERSIZE * 2];
static unsigned long read_buffer_block = ~0UL;
-/* Uncompressing data structures... */
-static char outbuffer[PAGE_CACHE_SIZE*2];
-z_stream stream;
+static z_stream stream;
+/* Prototypes */
+static void expand_fs(char *, struct cramfs_inode *);
#endif /* INCLUDE_FS_TESTS */
+static char *outbuffer;
+
+static size_t page_size;
+
/* Input status of 0 to print help and exit without an error. */
static void usage(int status)
{
exit(status);
}
+static void die(int status, int syserr, const char *fmt, ...)
+{
+ va_list arg_ptr;
+ int save = errno;
+
+ fflush(0);
+ va_start(arg_ptr, fmt);
+ fprintf(stderr, "%s: ", progname);
+ vfprintf(stderr, fmt, arg_ptr);
+ if (syserr) {
+ fprintf(stderr, ": %s", strerror(save));
+ }
+ fprintf(stderr, "\n");
+ va_end(arg_ptr);
+ exit(status);
+}
+
+static void test_super(int *start, size_t *length) {
+ struct stat st;
+
+ /* find the physical size of the file or block device */
+ if (stat(filename, &st) < 0) {
+ die(FSCK_ERROR, 1, "stat failed: %s", filename);
+ }
+ fd = open(filename, O_RDONLY);
+ if (fd < 0) {
+ die(FSCK_ERROR, 1, "open failed: %s", filename);
+ }
+ if (S_ISBLK(st.st_mode)) {
+ if (ioctl(fd, BLKGETSIZE, length) < 0) {
+ die(FSCK_ERROR, 1, "ioctl failed: unable to determine device size: %s", filename);
+ }
+ *length = *length * 512;
+ }
+ else if (S_ISREG(st.st_mode)) {
+ *length = st.st_size;
+ }
+ else {
+ die(FSCK_ERROR, 0, "not a block device or file: %s", filename);
+ }
+
+ if (*length < sizeof(struct cramfs_super)) {
+ die(FSCK_UNCORRECTED, 0, "file length too short");
+ }
+
+ /* find superblock */
+ if (read(fd, &super, sizeof(super)) != sizeof(super)) {
+ die(FSCK_ERROR, 1, "read failed: %s", filename);
+ }
+ if (super.magic == CRAMFS_MAGIC) {
+ *start = 0;
+ }
+ else if (*length >= (PAD_SIZE + sizeof(super))) {
+ lseek(fd, PAD_SIZE, SEEK_SET);
+ if (read(fd, &super, sizeof(super)) != sizeof(super)) {
+ die(FSCK_ERROR, 1, "read failed: %s", filename);
+ }
+ if (super.magic == CRAMFS_MAGIC) {
+ *start = PAD_SIZE;
+ }
+ }
+
+ /* superblock tests */
+ if (super.magic != CRAMFS_MAGIC) {
+ die(FSCK_UNCORRECTED, 0, "superblock magic not found");
+ }
+ if (super.flags & ~CRAMFS_SUPPORTED_FLAGS) {
+ die(FSCK_ERROR, 0, "unsupported filesystem features");
+ }
+ if (super.size < page_size) {
+ die(FSCK_UNCORRECTED, 0, "superblock size (%d) too small", super.size);
+ }
+ if (super.flags & CRAMFS_FLAG_FSID_VERSION_2) {
+ if (super.fsid.files == 0) {
+ die(FSCK_UNCORRECTED, 0, "zero file count");
+ }
+ if (*length < super.size) {
+ die(FSCK_UNCORRECTED, 0, "file length too short");
+ }
+ else if (*length > super.size) {
+ fprintf(stderr, "warning: file extends past end of filesystem\n");
+ }
+ }
+ else {
+ fprintf(stderr, "warning: old cramfs format\n");
+ }
+}
+
+static void test_crc(int start)
+{
+ void *buf;
+ u32 crc;
+
+ if (!(super.flags & CRAMFS_FLAG_FSID_VERSION_2)) {
+#ifdef INCLUDE_FS_TESTS
+ return;
+#else /* not INCLUDE_FS_TESTS */
+ die(FSCK_USAGE, 0, "unable to test CRC: old cramfs format");
+#endif /* not INCLUDE_FS_TESTS */
+ }
+
+ crc = crc32(0L, Z_NULL, 0);
+
+ buf = mmap(NULL, super.size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+ if (buf == MAP_FAILED) {
+ buf = mmap(NULL, super.size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ if (buf != MAP_FAILED) {
+ lseek(fd, 0, SEEK_SET);
+ read(fd, buf, super.size);
+ }
+ }
+ if (buf != MAP_FAILED) {
+ ((struct cramfs_super *) (buf+start))->fsid.crc = crc32(0L, Z_NULL, 0);
+ crc = crc32(crc, buf+start, super.size-start);
+ munmap(buf, super.size);
+ }
+ else {
+ int retval;
+ size_t length = 0;
+
+ buf = malloc(4096);
+ if (!buf) {
+ die(FSCK_ERROR, 1, "malloc failed");
+ }
+ lseek(fd, start, SEEK_SET);
+ for (;;) {
+ retval = read(fd, buf, 4096);
+ if (retval < 0) {
+ die(FSCK_ERROR, 1, "read failed: %s", filename);
+ }
+ else if (retval == 0) {
+ break;
+ }
+ if (length == 0) {
+ ((struct cramfs_super *) buf)->fsid.crc = crc32(0L, Z_NULL, 0);
+ }
+ length += retval;
+ if (length > (super.size-start)) {
+ crc = crc32(crc, buf, retval - (length - (super.size-start)));
+ break;
+ }
+ crc = crc32(crc, buf, retval);
+ }
+ free(buf);
+ }
+
+ if (crc != super.fsid.crc) {
+ die(FSCK_UNCORRECTED, 0, "crc error");
+ }
+}
+
#ifdef INCLUDE_FS_TESTS
static void print_node(char type, struct cramfs_inode *i, char *name)
{
static struct cramfs_inode *cramfs_iget(struct cramfs_inode * i)
{
struct cramfs_inode *inode = malloc(sizeof(struct cramfs_inode));
+
+ if (!inode) {
+ die(FSCK_ERROR, 1, "malloc failed");
+ }
*inode = *i;
return inode;
}
return cramfs_iget(romfs_read(ino));
}
-#if 0
static void iput(struct cramfs_inode *inode)
{
free(inode);
}
-#endif
/*
- * Return the offset of the root directory,
- * or 0 if none.
+ * Return the offset of the root directory
*/
static struct cramfs_inode *read_super(void)
{
- unsigned long offset;
-
- offset = super->root.offset << 2;
- if (super->magic != CRAMFS_MAGIC)
- return NULL;
- if (memcmp(super->signature, CRAMFS_SIGNATURE, sizeof(super->signature)) != 0)
- return NULL;
- if (offset < sizeof(super))
- return NULL;
- return cramfs_iget(&super->root);
+ unsigned long offset = super.root.offset << 2;
+
+ if (!S_ISDIR(super.root.mode))
+ die(FSCK_UNCORRECTED, 0, "root inode is not directory");
+ if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&
+ ((offset != sizeof(struct cramfs_super)) &&
+ (offset != PAD_SIZE + sizeof(struct cramfs_super))))
+ {
+ die(FSCK_UNCORRECTED, 0, "bad root offset (%lu)", offset);
+ }
+ return cramfs_iget(&super.root);
}
static int uncompress_block(void *src, int len)
stream.avail_in = len;
stream.next_out = (unsigned char *) outbuffer;
- stream.avail_out = PAGE_CACHE_SIZE*2;
+ stream.avail_out = page_size*2;
inflateReset(&stream);
+ if (len > page_size*2) {
+ die(FSCK_UNCORRECTED, 0, "data block too large");
+ }
err = inflate(&stream, Z_FINISH);
if (err != Z_STREAM_END) {
- fprintf(stderr,
- _("%s: error %d while decompressing! %p(%d)\n"),
- filename, err, src, len);
- exit(4);
+ die(FSCK_UNCORRECTED, 0, "decompression error %p(%d): %s",
+ zError(err), src, len);
}
return stream.total_out;
}
#if !HAVE_LCHOWN
#define lchown chown
#endif
+static void do_uncompress(char *path, int fd, unsigned long offset, unsigned long size)
+{
+ unsigned long curr = offset + 4 * ((size + page_size - 1) / page_size);
+
+ do {
+ unsigned long out = page_size;
+ unsigned long next = *(u32 *) romfs_read(offset);
+
+ if (next > end_data) {
+ end_data = next;
+ }
+
+ offset += 4;
+ if (curr == next) {
+ if (opt_verbose > 1) {
+ printf(" hole at %ld (%d)\n", curr, page_size);
+ }
+ if (size < page_size)
+ out = size;
+ memset(outbuffer, 0x00, out);
+ }
+ else {
+ if (opt_verbose > 1) {
+ printf(" uncompressing block at %ld to %ld (%ld)\n", curr, next, next - curr);
+ }
+ out = uncompress_block(romfs_read(curr), next - curr);
+ }
+ if (size >= page_size) {
+ if (out != page_size) {
+ die(FSCK_UNCORRECTED, 0, "non-block (%ld) bytes", out);
+ }
+ } else {
+ if (out != size) {
+ die(FSCK_UNCORRECTED, 0, "non-size (%ld vs %ld) bytes", out, size);
+ }
+ }
+ size -= out;
+ if (opt_extract) {
+ if (write(fd, outbuffer, out) < 0) {
+ die(FSCK_ERROR, 1, "write failed: %s", path);
+ }
+ }
+ curr = next;
+ } while (size);
+}
static void change_file_status(char *path, struct cramfs_inode *i)
{
if (euid == 0) {
if (lchown(path, i->uid, i->gid) < 0) {
- perror(path);
- exit(8);
+ die(FSCK_ERROR, 1, "lchown failed: %s", path);
}
if (S_ISLNK(i->mode))
return;
if ((S_ISUID | S_ISGID) & i->mode) {
if (chmod(path, i->mode) < 0) {
- perror(path);
- exit(8);
+ die(FSCK_ERROR, 1, "chown failed: %s", path);
}
}
}
if (S_ISLNK(i->mode))
return;
if (utime(path, &epoch) < 0) {
- perror(path);
- exit(8);
+ die(FSCK_ERROR, 1, "utime failed: %s", path);
+ }
+}
+
+static void do_directory(char *path, struct cramfs_inode *i)
+{
+ int pathlen = strlen(path);
+ int count = i->size;
+ unsigned long offset = i->offset << 2;
+ char *newpath = malloc(pathlen + 256);
+
+ if (!newpath) {
+ die(FSCK_ERROR, 1, "malloc failed");
+ }
+ if (offset == 0 && count != 0) {
+ die(FSCK_UNCORRECTED, 0, "directory inode has zero offset and non-zero size: %s", path);
+ }
+ if (offset != 0 && offset < start_dir) {
+ start_dir = offset;
+ }
+ /* TODO: Do we need to check end_dir for empty case? */
+ memcpy(newpath, path, pathlen);
+ newpath[pathlen] = '/';
+ pathlen++;
+ if (opt_verbose) {
+ print_node('d', i, path);
+ }
+ if (opt_extract) {
+ if (mkdir(path, i->mode) < 0) {
+ die(FSCK_ERROR, 1, "mkdir failed: %s", path);
+ }
+ change_file_status(path, i);
+ }
+ while (count > 0) {
+ struct cramfs_inode *child = iget(offset);
+ int size;
+ int newlen = child->namelen << 2;
+
+ size = sizeof(struct cramfs_inode) + newlen;
+ count -= size;
+
+ offset += sizeof(struct cramfs_inode);
+
+ memcpy(newpath + pathlen, romfs_read(offset), newlen);
+ newpath[pathlen + newlen] = 0;
+ if (newlen == 0) {
+ die(FSCK_UNCORRECTED, 0, "filename length is zero");
+ }
+ if ((pathlen + newlen) - strlen(newpath) > 3) {
+ die(FSCK_UNCORRECTED, 0, "bad filename length");
+ }
+ expand_fs(newpath, child);
+
+ offset += newlen;
+
+ if (offset <= start_dir) {
+ die(FSCK_UNCORRECTED, 0, "bad inode offset");
+ }
+ if (offset > end_dir) {
+ end_dir = offset;
+ }
+ iput(child); /* free(child) */
+ }
+ free(newpath);
+}
+
+static void do_file(char *path, struct cramfs_inode *i)
+{
+ unsigned long offset = i->offset << 2;
+ int fd = 0;
+
+ if (offset == 0 && i->size != 0) {
+ die(FSCK_UNCORRECTED, 0, "file inode has zero offset and non-zero size");
+ }
+ if (i->size == 0 && offset != 0) {
+ die(FSCK_UNCORRECTED, 0, "file inode has zero size and non-zero offset");
+ }
+ if (offset != 0 && offset < start_data) {
+ start_data = offset;
+ }
+ if (opt_verbose) {
+ print_node('f', i, path);
+ }
+ if (opt_extract) {
+ fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, i->mode);
+ if (fd < 0) {
+ die(FSCK_ERROR, 1, "open failed: %s", path);
+ }
+ }
+ if (i->size) {
+ do_uncompress(path, fd, offset, i->size);
+ }
+ if (opt_extract) {
+ close(fd);
+ change_file_status(path, i);
}
}
unsigned long next = *(u32 *) romfs_read(offset);
unsigned long size;
+ if (offset == 0) {
+ die(FSCK_UNCORRECTED, 0, "symbolic link has zero offset");
+ }
+ if (i->size == 0) {
+ die(FSCK_UNCORRECTED, 0, "symbolic link has zero size");
+ }
+
+ if (offset < start_data) {
+ start_data = offset;
+ }
if (next > end_data) {
end_data = next;
}
size = uncompress_block(romfs_read(curr), next - curr);
if (size != i->size) {
- fprintf(stderr, _("%s: size error in symlink `%s'\n"),
- filename, path);
- exit(4);
+ die(FSCK_UNCORRECTED, 0, "size error in symlink: %s", path);
}
outbuffer[size] = 0;
if (opt_verbose) {
char *str;
- str = malloc(strlen(outbuffer) + strlen(path) + 5);
- strcpy(str, path);
- strncat(str, " -> ", 4);
- strncat(str, outbuffer, size);
-
+ asprintf(&str, "%s -> %s", path, outbuffer);
print_node('l', i, str);
if (opt_verbose > 1) {
- printf(_(" uncompressing block at %ld "
- "to %ld (%ld)\n"),
- curr, next, next - curr);
+ printf(" uncompressing block at %ld to %ld (%ld)\n", curr, next, next - curr);
}
+ free(str);
}
if (opt_extract) {
- symlink(outbuffer, path);
+ if (symlink(outbuffer, path) < 0) {
+ die(FSCK_ERROR, 1, "symlink failed: %s", path);
+ }
change_file_status(path, i);
}
}
dev_t devtype = 0;
char type;
+ if (i->offset) { /* no need to shift offset */
+ die(FSCK_UNCORRECTED, 0, "special file has non-zero offset: %s", path);
+ }
if (S_ISCHR(i->mode)) {
devtype = i->size;
type = 'c';
devtype = i->size;
type = 'b';
}
- else if (S_ISFIFO(i->mode))
+ else if (S_ISFIFO(i->mode)) {
+ if (i->size != 0) {
+ die(FSCK_UNCORRECTED, 0, "fifo has non-zero size: %s", path);
+ }
type = 'p';
- else if (S_ISSOCK(i->mode))
+ }
+ else if (S_ISSOCK(i->mode)) {
+ if (i->size != 0) {
+ die(FSCK_UNCORRECTED, 0, "socket has non-zero size: %s", path);
+ }
type = 's';
+ }
else {
- fprintf(stderr, _("%s: bogus mode on `%s' (%o)\n"),
- filename, path, i->mode);
- exit(4);
+ die(FSCK_UNCORRECTED, 0, "bogus mode: %s (%o)", path, i->mode);
+ return; /* not reached */
}
if (opt_verbose) {
if (opt_extract) {
if (mknod(path, i->mode, devtype) < 0) {
- perror(path);
- exit(8);
+ die(FSCK_ERROR, 1, "mknod failed: %s", path);
}
change_file_status(path, i);
}
}
-static void do_uncompress(int fd, unsigned long offset, unsigned long size)
+static void expand_fs(char *path, struct cramfs_inode *inode)
{
- unsigned long curr = offset + 4 * ((size + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE);
-
- do {
- unsigned long out = PAGE_CACHE_SIZE;
- unsigned long next = *(u32 *) romfs_read(offset);
-
- if (next > end_data)
- end_data = next;
-
- offset += 4;
- if (curr == next) {
- if (opt_verbose > 1) {
- printf(_(" hole at %ld (%d)\n"),
- curr, PAGE_CACHE_SIZE);
- }
- if (size < PAGE_CACHE_SIZE)
- out = size;
- memset(outbuffer, 0x00, out);
- }
- else {
- if (opt_verbose > 1) {
- printf(_(" uncompressing block at %ld "
- "to %ld (%ld)\n"),
- curr, next, next - curr);
- }
- out = uncompress_block(romfs_read(curr), next - curr);
- }
- if (size >= PAGE_CACHE_SIZE) {
- if (out != PAGE_CACHE_SIZE) {
- fprintf(stderr,
- _("%s: Non-block (%ld) bytes\n"),
- filename, out);
- exit(4);
- }
- } else {
- if (out != size) {
- fprintf(stderr, _("%s: Non-size (%ld vs %ld) "
- "bytes\n"),
- filename, out, size);
- exit(4);
- }
- }
- size -= out;
- if (opt_extract) {
- write(fd, outbuffer, out);
- }
- curr = next;
- } while (size);
+ if (S_ISDIR(inode->mode)) {
+ do_directory(path, inode);
+ }
+ else if (S_ISREG(inode->mode)) {
+ do_file(path, inode);
+ }
+ else if (S_ISLNK(inode->mode)) {
+ do_symlink(path, inode);
+ }
+ else {
+ do_special_inode(path, inode);
+ }
}
-static void expand_fs(int pathlen, char *path, struct cramfs_inode *inode)
+static void test_fs(int start)
{
- if (S_ISDIR(inode->mode)) {
- int count = inode->size;
- unsigned long offset = inode->offset << 2;
- char *newpath = malloc(pathlen + 256);
-
- if (count > 0 && offset < start_inode) {
- start_inode = offset;
- }
- /* XXX - need to check end_inode for empty case? */
- memcpy(newpath, path, pathlen);
- newpath[pathlen] = '/';
- pathlen++;
- if (opt_verbose) {
- print_node('d', inode, path);
- }
- if (opt_extract) {
- mkdir(path, inode->mode);
- change_file_status(path, inode);
- }
- while (count > 0) {
- struct cramfs_inode *child = iget(offset);
- int size;
- int newlen = child->namelen << 2;
-
- size = sizeof(struct cramfs_inode) + newlen;
- count -= size;
-
- offset += sizeof(struct cramfs_inode);
-
- memcpy(newpath + pathlen, romfs_read(offset), newlen);
- newpath[pathlen + newlen] = 0;
- if ((pathlen + newlen) - strlen(newpath) > 3) {
- fprintf(stderr,
- _("%s: invalid cramfs--bad "
- "path length\n"),
- filename);
- exit(4);
- }
- expand_fs(strlen(newpath), newpath, child);
-
- offset += newlen;
-
- if (offset > end_inode) {
- end_inode = offset;
- }
- }
- return;
- }
- if (S_ISREG(inode->mode)) {
- int fd = 0;
- unsigned long offset = inode->offset << 2;
+ struct cramfs_inode *root;
- if (offset > 0 && offset < start_data) {
- start_data = offset;
- }
- if (opt_verbose) {
- print_node('f', inode, path);
- }
- if (opt_extract) {
- fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, inode->mode);
- }
- if (inode->size) {
- do_uncompress(fd, offset, inode->size);
+ root = read_super();
+ umask(0);
+ euid = geteuid();
+ stream.next_in = NULL;
+ stream.avail_in = 0;
+ inflateInit(&stream);
+ expand_fs(extract_dir, root);
+ inflateEnd(&stream);
+ if (start_data != ~0UL) {
+ if (start_data < (sizeof(struct cramfs_super) + start)) {
+ die(FSCK_UNCORRECTED, 0, "directory data start (%ld) < sizeof(struct cramfs_super) + start (%ld)", start_data, sizeof(struct cramfs_super) + start);
}
- if (opt_extract) {
- close(fd);
- change_file_status(path, inode);
+ if (end_dir != start_data) {
+ die(FSCK_UNCORRECTED, 0, "directory data end (%ld) != file data start (%ld)", end_dir, start_data);
}
- return;
}
- if (S_ISLNK(inode->mode)) {
- unsigned long offset = inode->offset << 2;
-
- if (offset < start_data) {
- start_data = offset;
+ if (super.flags & CRAMFS_FLAG_FSID_VERSION_2) {
+ if (end_data > super.size) {
+ die(FSCK_UNCORRECTED, 0, "invalid file data offset");
}
- do_symlink(path, inode);
- return;
- }
- else {
- do_special_inode(path, inode);
- return;
}
+ iput(root); /* free(root) */
}
#endif /* INCLUDE_FS_TESTS */
int main(int argc, char **argv)
{
- void *buf;
- size_t length;
- struct stat st;
- u32 crc_old, crc_new;
-#ifdef INCLUDE_FS_TESTS
- struct cramfs_inode *root;
-#endif /* INCLUDE_FS_TESTS */
int c; /* for getopt */
int start = 0;
+ size_t length;
+
+ page_size = sysconf(_SC_PAGESIZE);
if (argc)
progname = argv[0];
+ outbuffer = malloc(page_size * 2);
+ if (!outbuffer)
+ die(FSCK_ERROR, 1, "failed to allocate outbuffer");
+
/* command line options */
while ((c = getopt(argc, argv, "hx:v")) != EOF) {
switch (c) {
case 'h':
- usage(0);
+ usage(FSCK_OK);
case 'x':
#ifdef INCLUDE_FS_TESTS
opt_extract = 1;
- extract_dir = malloc(strlen(optarg) + 1);
- strcpy(extract_dir, optarg);
+ extract_dir = optarg;
break;
-#else /* not INCLUDE_FS_TESTS */
- fprintf(stderr, _("%s: compiled without -x support\n"),
- progname);
- exit(16);
+#else /* not INCLUDE_FS_TESTS */
+ die(FSCK_USAGE, 0, "compiled without -x support");
#endif /* not INCLUDE_FS_TESTS */
case 'v':
opt_verbose++;
}
if ((argc - optind) != 1)
- usage(16);
+ usage(FSCK_USAGE);
filename = argv[optind];
- /* find the physical size of the file or block device */
- if (lstat(filename, &st) < 0) {
- perror(filename);
- exit(8);
- }
- fd = open(filename, O_RDONLY);
- if (fd < 0) {
- perror(filename);
- exit(8);
- }
- if (S_ISBLK(st.st_mode)) {
- if (ioctl(fd, BLKGETSIZE, &length) < 0) {
- fprintf(stderr, _("%s: warning--unable to determine "
- "filesystem size \n"), filename);
- exit(4);
- }
- length = length * 512;
- }
- else if (S_ISREG(st.st_mode)) {
- length = st.st_size;
- }
- else {
- fprintf(stderr, _("%s is not a block device or file\n"),
- filename);
- exit(8);
- }
-
- if (length < sizeof(struct cramfs_super)) {
- fprintf(stderr, _("%s: invalid cramfs--file length "
- "too short\n"), filename);
- exit(4);
- }
-
- if (S_ISBLK(st.st_mode)) {
- /* nasty because mmap of block devices fails */
- buf = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
- read(fd, buf, length);
- }
- else {
- /* nice and easy */
- buf = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
- }
-
- /* XXX - this could be cleaner... */
- if (((struct cramfs_super *) buf)->magic == CRAMFS_MAGIC) {
- start = 0;
- super = (struct cramfs_super *) buf;
- }
- else if (length >= (PAD_SIZE + sizeof(struct cramfs_super)) &&
- ((((struct cramfs_super *) (buf + PAD_SIZE))->magic == CRAMFS_MAGIC)))
- {
- start = PAD_SIZE;
- super = (struct cramfs_super *) (buf + PAD_SIZE);
- }
- else {
- fprintf(stderr, _("%s: invalid cramfs--wrong magic\n"),
- filename);
- exit(4);
- }
-
- if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) {
- /* length test */
- if (length < super->size) {
- fprintf(stderr, _("%s: invalid cramfs--file length "
- "too short\n"), filename);
- exit(4);
- }
- else if (length > super->size) {
- fprintf(stderr, _("%s: warning--file length too long, "
- "padded image?\n"), filename);
- }
-
- /* CRC test */
- crc_old = super->fsid.crc;
- super->fsid.crc = crc32(0L, Z_NULL, 0);
- crc_new = crc32(0L, Z_NULL, 0);
- crc_new = crc32(crc_new, (unsigned char *) buf+start, super->size - start);
- if (crc_new != crc_old) {
- fprintf(stderr, _("%s: invalid cramfs--crc error\n"),
- filename);
- exit(4);
- }
- }
- else {
- fprintf(stderr, _("%s: warning--old cramfs image, no CRC\n"),
- filename);
- }
-
+ test_super(&start, &length);
+ test_crc(start);
#ifdef INCLUDE_FS_TESTS
- super = (struct cramfs_super *) malloc(sizeof(struct cramfs_super));
- if (((struct cramfs_super *) buf)->magic == CRAMFS_MAGIC) {
- memcpy(super, buf, sizeof(struct cramfs_super));
- }
- else if (length >= (PAD_SIZE + sizeof(struct cramfs_super)) &&
- ((((struct cramfs_super *) (buf + PAD_SIZE))->magic == CRAMFS_MAGIC)))
- {
- memcpy(super, (buf + PAD_SIZE), sizeof(struct cramfs_super));
- }
-
- munmap(buf, length);
-
- /* file format test, uses fake "blocked" accesses */
- root = read_super();
- umask(0);
- euid = geteuid();
- if (!root) {
- fprintf(stderr, _("%s: invalid cramfs--bad superblock\n"),
- filename);
- exit(4);
- }
- stream.next_in = NULL;
- stream.avail_in = 0;
- inflateInit(&stream);
-
- if (!extract_dir)
- extract_dir = "root";
-
- expand_fs(strlen(extract_dir), extract_dir, root);
- inflateEnd(&stream);
+ test_fs(start);
+#endif /* INCLUDE_FS_TESTS */
- if (start_data != 1 << 28 && end_inode != start_data) {
- fprintf(stderr,
- _("%s: invalid cramfs--directory data end "
- "(%ld) != file data start (%ld)\n"),
- filename, end_inode, start_data);
- exit(4);
- }
- if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) {
- if (end_data > super->size) {
- fprintf(stderr,
- _("%s: invalid cramfs--invalid file "
- "data offset\n"),
- filename);
- exit(4);
- }
+ if (opt_verbose) {
+ printf("%s: OK\n", filename);
}
-#endif /* INCLUDE_FS_TESTS */
- exit(0);
+ exit(FSCK_OK);
}
projects / thirdparty / util-linux.git / commitdiff
