/*
 * cramfs.c
 *
 * Copyright (C) 1999 Linus Torvalds
 *
 * Copyright (C) 2000-2002 Transmeta Corporation
 *
 * Copyright (C) 2003 Kai-Uwe Bloem,
 * Auerswald GmbH & Co KG, <linux-development@auerswald.de>
 * - adapted from the www.tuxbox.org u-boot tree, added "ls" command
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License (Version 2) as
 * published by the Free Software Foundation.
 *
 * Compressed ROM filesystem for Linux.
 *
 * TODO:
 * add support for resolving symbolic links
 */

/*
 * These are the VFS interfaces to the compressed ROM filesystem.
 * The actual compression is based on zlib, see the other files.
 */

#include <common.h>
#include <malloc.h>
#include <asm/byteorder.h>
#include <linux/stat.h>
#include <jffs2/jffs2.h>
#include <jffs2/load_kernel.h>
#include <cramfs/cramfs_fs.h>

/* These two macros may change in future, to provide better st_ino
   semantics. */
#define CRAMINO(x)      (CRAMFS_GET_OFFSET(x) ? CRAMFS_GET_OFFSET(x)<<2 : 1)
#define OFFSET(x)       ((x)->i_ino)

struct cramfs_super super;

/* CPU address space offset calculation macro, struct part_info offset is
 * device address space offset, so we need to shift it by a device start address. */
#if !defined(CONFIG_SYS_NO_FLASH)
extern flash_info_t flash_info[];
#define PART_OFFSET(x)  ((ulong)x->offset + \
                         flash_info[x->dev->id->num].start[0])
#else
#define PART_OFFSET(x)  ((ulong)x->offset)
#endif

static int cramfs_read_super (struct part_info *info)
{
        unsigned long root_offset;

        /* Read the first block and get the superblock from it */
        memcpy (&super, (void *) PART_OFFSET(info), sizeof (super));

        /* Do sanity checks on the superblock */
        if (super.magic != CRAMFS_32 (CRAMFS_MAGIC)) {
                /* check at 512 byte offset */
                memcpy (&super, (void *) PART_OFFSET(info) + 512, sizeof (super));
                if (super.magic != CRAMFS_32 (CRAMFS_MAGIC)) {
                        printf ("cramfs: wrong magic\n");
                        return -1;
                }
        }

        /* flags is reused several times, so swab it once */
        super.flags = CRAMFS_32 (super.flags);
        super.size = CRAMFS_32 (super.size);

        /* get feature flags first */
        if (super.flags & ~CRAMFS_SUPPORTED_FLAGS) {
                printf ("cramfs: unsupported filesystem features\n");
                return -1;
        }

        /* Check that the root inode is in a sane state */
        if (!S_ISDIR (CRAMFS_16 (super.root.mode))) {
                printf ("cramfs: root is not a directory\n");
                return -1;
        }
        root_offset = CRAMFS_GET_OFFSET (&(super.root)) << 2;
        if (root_offset == 0) {
                printf ("cramfs: empty filesystem");
        } else if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&
                   ((root_offset != sizeof (struct cramfs_super)) &&
                    (root_offset != 512 + sizeof (struct cramfs_super)))) {
                printf ("cramfs: bad root offset %lu\n", root_offset);
                return -1;
        }

        return 0;
}

static unsigned long cramfs_resolve (unsigned long begin, unsigned long offset,
                                     unsigned long size, int raw,
                                     char *filename)
{
        unsigned long inodeoffset = 0, nextoffset;

        while (inodeoffset < size) {
                struct cramfs_inode *inode;
                char *name;
                int namelen;

                inode = (struct cramfs_inode *) (begin + offset +
                                                 inodeoffset);

                /*
                 * Namelengths on disk are shifted by two
                 * and the name padded out to 4-byte boundaries
                 * with zeroes.
                 */
                namelen = CRAMFS_GET_NAMELEN (inode) << 2;
                name = (char *) inode + sizeof (struct cramfs_inode);

                nextoffset =
                        inodeoffset + sizeof (struct cramfs_inode) + namelen;

                for (;;) {
                        if (!namelen)
                                return -1;
                        if (name[namelen - 1])
                                break;
                        namelen--;
                }

                if (!strncmp(filename, name, namelen) &&
                    (namelen == strlen(filename))) {
                        char *p = strtok (NULL, "/");

                        if (raw && (p == NULL || *p == '\0'))
                                return offset + inodeoffset;

                        if (S_ISDIR (CRAMFS_16 (inode->mode))) {
                                return cramfs_resolve (begin,
                                                       CRAMFS_GET_OFFSET
                                                       (inode) << 2,
                                                       CRAMFS_24 (inode->
                                                                  size), raw,
                                                       p);
                        } else if (S_ISREG (CRAMFS_16 (inode->mode))) {
                                return offset + inodeoffset;
                        } else {
                                printf ("%*.*s: unsupported file type (%x)\n",
                                        namelen, namelen, name,
                                        CRAMFS_16 (inode->mode));
                                return 0;
                        }
                }

                inodeoffset = nextoffset;
        }

        printf ("can't find corresponding entry\n");
        return 0;
}

static int cramfs_uncompress (unsigned long begin, unsigned long offset,
                              unsigned long loadoffset)
{
        struct cramfs_inode *inode = (struct cramfs_inode *) (begin + offset);
        unsigned long *block_ptrs = (unsigned long *)
                (begin + (CRAMFS_GET_OFFSET (inode) << 2));
        unsigned long curr_block = (CRAMFS_GET_OFFSET (inode) +
                                    (((CRAMFS_24 (inode->size)) +
                                      4095) >> 12)) << 2;
        int size, total_size = 0;
        int i;

        cramfs_uncompress_init ();

        for (i = 0; i < ((CRAMFS_24 (inode->size) + 4095) >> 12); i++) {
                size = cramfs_uncompress_block ((void *) loadoffset,
                                                (void *) (begin + curr_block),
                                                (CRAMFS_32 (block_ptrs[i]) -
                                                 curr_block));
                if (size < 0)
                        return size;
                loadoffset += size;
                total_size += size;
                curr_block = CRAMFS_32 (block_ptrs[i]);
        }

        cramfs_uncompress_exit ();
        return total_size;
}

int cramfs_load (char *loadoffset, struct part_info *info, char *filename)
{
        unsigned long offset;

        if (cramfs_read_super (info))
                return -1;

        offset = cramfs_resolve (PART_OFFSET(info),
                                 CRAMFS_GET_OFFSET (&(super.root)) << 2,
                                 CRAMFS_24 (super.root.size), 0,
                                 strtok (filename, "/"));

        if (offset <= 0)
                return offset;

        return cramfs_uncompress (PART_OFFSET(info), offset,
                                  (unsigned long) loadoffset);
}

static int cramfs_list_inode (struct part_info *info, unsigned long offset)
{
        struct cramfs_inode *inode = (struct cramfs_inode *)
                (PART_OFFSET(info) + offset);
        char *name, str[20];
        int namelen, nextoff;

        /*
         * Namelengths on disk are shifted by two
         * and the name padded out to 4-byte boundaries
         * with zeroes.
         */
        namelen = CRAMFS_GET_NAMELEN (inode) << 2;
        name = (char *) inode + sizeof (struct cramfs_inode);
        nextoff = namelen;

        for (;;) {
                if (!namelen)
                        return namelen;
                if (name[namelen - 1])
                        break;
                namelen--;
        }

        printf (" %s %8d %*.*s", mkmodestr (CRAMFS_16 (inode->mode), str),
                CRAMFS_24 (inode->size), namelen, namelen, name);

        if ((CRAMFS_16 (inode->mode) & S_IFMT) == S_IFLNK) {
                /* symbolic link.
                 * Unpack the link target, trusting in the inode's size field.
                 */
                unsigned long size = CRAMFS_24 (inode->size);
                char *link = malloc (size);

                if (link != NULL && cramfs_uncompress (PART_OFFSET(info), offset,
                                                       (unsigned long) link)
                    == size)
                        printf (" -> %*.*s\n", (int) size, (int) size, link);
                else
                        printf (" [Error reading link]\n");
                if (link)
                        free (link);
        } else
                printf ("\n");

        return nextoff;
}

int cramfs_ls (struct part_info *info, char *filename)
{
        struct cramfs_inode *inode;
        unsigned long inodeoffset = 0, nextoffset;
        unsigned long offset, size;

        if (cramfs_read_super (info))
                return -1;

        if (strlen (filename) == 0 || !strcmp (filename, "/")) {
                /* Root directory. Use root inode in super block */
                offset = CRAMFS_GET_OFFSET (&(super.root)) << 2;
                size = CRAMFS_24 (super.root.size);
        } else {
                /* Resolve the path */
                offset = cramfs_resolve (PART_OFFSET(info),
                                         CRAMFS_GET_OFFSET (&(super.root)) <<
                                         2, CRAMFS_24 (super.root.size), 1,
                                         strtok (filename, "/"));

                if (offset <= 0)
                        return offset;

                /* Resolving was successful. Examine the inode */
                inode = (struct cramfs_inode *) (PART_OFFSET(info) + offset);
                if (!S_ISDIR (CRAMFS_16 (inode->mode))) {
                        /* It's not a directory - list it, and that's that */
                        return (cramfs_list_inode (info, offset) > 0);
                }

                /* It's a directory. List files within */
                offset = CRAMFS_GET_OFFSET (inode) << 2;
                size = CRAMFS_24 (inode->size);
        }

        /* List the given directory */
        while (inodeoffset < size) {
                inode = (struct cramfs_inode *) (PART_OFFSET(info) + offset +
                                                 inodeoffset);

                nextoffset = cramfs_list_inode (info, offset + inodeoffset);
                if (nextoffset == 0)
                        break;
                inodeoffset += sizeof (struct cramfs_inode) + nextoffset;
        }

        return 1;
}

int cramfs_info (struct part_info *info)
{
        if (cramfs_read_super (info))
                return 0;

        printf ("size: 0x%x (%u)\n", super.size, super.size);

        if (super.flags != 0) {
                printf ("flags:\n");
                if (super.flags & CRAMFS_FLAG_FSID_VERSION_2)
                        printf ("\tFSID version 2\n");
                if (super.flags & CRAMFS_FLAG_SORTED_DIRS)
                        printf ("\tsorted dirs\n");
                if (super.flags & CRAMFS_FLAG_HOLES)
                        printf ("\tholes\n");
                if (super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET)
                        printf ("\tshifted root offset\n");
        }

        printf ("fsid:\n\tcrc: 0x%x\n\tedition: 0x%x\n",
                super.fsid.crc, super.fsid.edition);
        printf ("name: %16s\n", super.name);

        return 1;
}

int cramfs_check (struct part_info *info)
{
        struct cramfs_super *sb;

        if (info->dev->id->type != MTD_DEV_TYPE_NOR)
                return 0;

        sb = (struct cramfs_super *) PART_OFFSET(info);
        if (sb->magic != CRAMFS_32 (CRAMFS_MAGIC)) {
                /* check at 512 byte offset */
                sb = (struct cramfs_super *) (PART_OFFSET(info) + 512);
                if (sb->magic != CRAMFS_32 (CRAMFS_MAGIC))
                        return 0;
        }
        return 1;
}