[Problem] freetz "make" bricht unter Archlinux mit Fehlern ab

andiling · 25 Jun 2015

Also ich kann den Fehler mit Deiner .config reproduzieren, ein zweites make direkt danach läuft aber dann durch. Komisch, scheint als ob der Prozess auf einem Kern noch nicht fertig ist und das Skript weitermacht.

Honigmelone · 17 Jan 2016

Bei mir trat mit gcc (Ubuntu 5.2.1-22ubuntu2) 5.2.1 20151010 auch der Fehler auf

Code:

 mksquashfs-lzma undefined reference to `add_dir_entry'

Mit dem minimal veränderten source file aus

Code:

freetz-stable-2.0/source/host-tools/squashfs2.2-r2/squashfs-tools/mksquashfs-lzma.c

konnte ich jedoch nach 2 Versuchen compilieren.

Code:

/*
 * Create a squashfs filesystem.  This is a highly compressed read only filesystem.
 *
 * Copyright (c) 2002, 2003, 2004, 2005
 * Phillip Lougher <[email protected]>
 *
 * 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 the Free Software Foundation; either version 2,
 * or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * mksquashfs.c
 */

#define TRUE 1
#include <pwd.h>
#include <grp.h>
#include <time.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <dirent.h>
#include <string.h>
#include <zlib.h>
#ifdef __APPLE__
    #include <machine/endian.h>
    #define __BYTE_ORDER BYTE_ORDER
    #define __BIG_ENDIAN BIG_ENDIAN
#else
    #include <endian.h>
#endif
#include <stdlib.h>
#include <signal.h>
#include <setjmp.h>
#include <sys/mman.h>

#include <squashfs_fs-lzma.h>
#include "mksquashfs.h"
#include "global.h"

#ifdef SQUASHFS_TRACE
#define TRACE(s, args...)        printf("mksquashfs: "s, ## args)
#else
#define TRACE(s, args...)
#endif

#define INFO(s, args...)        do { if(!silent) printf("mksquashfs: "s, ## args); } while(0)
#define ERROR(s, args...)        do { fprintf(stderr, s, ## args); } while(0)
#define EXIT_MKSQUASHFS()        do { if(restore)\
                    restorefs();\
                    if(destination_file && !block_device)\
                    unlink(destination_file);\
                    exit(1); } while(0)
#define BAD_ERROR(s, args...)        do {\
                    fprintf(stderr, "FATAL ERROR:" s, ##args);\
                    EXIT_MKSQUASHFS();\
                    } while(0)

int total_compressed = 0, total_uncompressed = 0;
int fd;

/* filesystem flags for building */
int duplicate_checking = 1, noF = 0, no_fragments = 0, always_use_fragments = 0;
int noI = 0, noD = 0, check_data = 0;
int swap, silent = TRUE;
long long global_uid = -1, global_gid = -1;
int filesystem_minor_version = SQUASHFS_MINOR;

/* superblock attributes */
int block_size = SQUASHFS_FILE_SIZE, block_log;
unsigned short uid_count = 0, guid_count = 0;
squashfs_uid uids[SQUASHFS_UIDS], guids[SQUASHFS_GUIDS];
int block_offset;
int file_count = 0, sym_count = 0, dev_count = 0, dir_count = 0, fifo_count = 0, sock_count = 0;

/* write position within data section */
unsigned int bytes = 0, total_bytes = 0;

/* in memory directory table - possibly compressed */
char *directory_table = NULL;
unsigned int directory_bytes = 0, directory_size = 0, total_directory_bytes = 0;

/* cached directory table */
char *directory_data_cache = NULL;
unsigned int directory_cache_bytes = 0, directory_cache_size = 0;

/* in memory inode table - possibly compressed */
char *inode_table = NULL;
unsigned int inode_bytes = 0, inode_size = 0, total_inode_bytes = 0;

/* cached inode table */
char *data_cache = NULL;
unsigned int cache_bytes = 0, cache_size = 0, inode_count = 0;

/* in memory directory data */
#define I_COUNT_SIZE        128

struct cached_dir_index {
    squashfs_dir_index    index;
    char            *name;
};

struct directory {
    unsigned int        start_block;
    unsigned int        size;
    unsigned char        *buff;
    unsigned char        *p;
    unsigned int        entry_count;
    unsigned char        *entry_count_p;
    unsigned int        i_count;
    unsigned int        i_size;
    struct cached_dir_index    *index;
    struct dir_ent        **list;
    char            *pathname;
    unsigned int        count;
    unsigned int        current_count;
    unsigned int        byte_count;
    char            dir_is_ldir;
    unsigned char        *index_count_p;
};

/* hash tables used to do fast duplicate searches in duplicate check */
struct file_info *dupl[65536], *frag_dups[65536];
int dup_files = 0;

/* list of exclude dirs/files */
struct exclude_info {
    dev_t            st_dev;
    ino_t            st_ino;
};

#define EXCLUDE_SIZE 8192
int exclude = 0;
struct exclude_info *exclude_paths = NULL;
int excluded(char *filename, struct stat *buf);

/* fragment block data structures */
int fragments = 0;
char fragment_data[SQUASHFS_FILE_SIZE];
int fragment_size = 0;
struct fragment {
    unsigned int        index;
    int            offset;
    int            size;
};
#define FRAG_SIZE 32768
squashfs_fragment_entry *fragment_table = NULL;


/* list of source dirs/files */
int source = 0;
char **source_path;

/* list of root directory entries read from original filesystem */
int old_root_entries = 0;
struct old_root_entry_info {
    char            name[SQUASHFS_NAME_LEN + 1];
    squashfs_inode        inode;
    int            type;
};
struct old_root_entry_info *old_root_entry;

/* in memory file info */
struct file_info {
    unsigned int        bytes;
    unsigned short        checksum;
    unsigned int        start;
    unsigned int        *block_list;
    struct file_info    *next;
    struct fragment        *fragment;
    unsigned short        fragment_checksum;
};

/* count of how many times SIGINT or SIGQUIT has been sent */
int interrupted = 0;

/* restore orignal filesystem state if appending to existing filesystem is cancelled */
jmp_buf env;
char *sdata_cache, *sdirectory_data_cache;
unsigned int sbytes, sinode_bytes, scache_bytes, sdirectory_bytes,
    sdirectory_cache_bytes, suid_count, sguid_count,
    stotal_bytes, stotal_inode_bytes, stotal_directory_bytes,
    sinode_count, sfile_count, ssym_count, sdev_count,
    sdir_count, sfifo_count, ssock_count, sdup_files;
int sfragments;
int restore = 0;

/* flag whether destination file is a block device */
int block_device = 0;

/* flag indicating whether files are sorted using sort list(s) */
int sorted = 0;

/* save destination file name for deleting on error */
char *destination_file = NULL;

/* structure to used to pass in a pointer or an integer
 * to duplicate buffer read helper functions.
 */
struct duplicate_buffer_handle {
    unsigned char    *ptr;
    unsigned int    start;
};

void add_old_root_entry(char *name, squashfs_inode inode, int type);
extern int read_super(int fd, squashfs_super_block *sBlk, int *be, char *source);
extern int read_filesystem(char *root_name, int fd, squashfs_super_block *sBlk, char **cinode_table,
        char **data_cache, char **cdirectory_table, char **directory_data_cache, unsigned int *last_directory_block,
        unsigned int *inode_dir_offset, unsigned int *inode_dir_file_size, unsigned int *root_inode_size,
        unsigned int *inode_dir_start_block, int *file_count, int *sym_count, int *dev_count, int *dir_count,
        int *fifo_count, int *sock_count, squashfs_uid *uids, unsigned short *uid_count, squashfs_uid *guids,
        unsigned short *guid_count, unsigned int *uncompressed_file, unsigned int *uncompressed_inode,
        unsigned int *uncompressed_directory, void (push_directory_entry)(char *, squashfs_inode, int),
        squashfs_fragment_entry **fragment_table);
int get_sorted_inode(squashfs_inode *inode, struct stat *buf);
int read_sort_file(char *filename, int source, char *source_path[]);
void sort_files_and_write(int source, char *source_path[]);
struct file_info *duplicate(unsigned char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *file_start, int bytes, unsigned int **block_list, int *start, int blocks, struct fragment **fragment, char *frag_data, int frag_bytes);

#define FALSE 0

#define MKINODE(A)    ((squashfs_inode)(((squashfs_inode) inode_bytes << 16) + (((char *)A) - data_cache)))


void restorefs()
{
    ERROR("Exiting - restoring original filesystem!\n\n");
    bytes = sbytes;
    memcpy(data_cache, sdata_cache, cache_bytes = scache_bytes);
    memcpy(directory_data_cache, sdirectory_data_cache, directory_cache_bytes = sdirectory_cache_bytes);
    inode_bytes = sinode_bytes;
    directory_bytes = sdirectory_bytes;
    uid_count = suid_count;
    guid_count = sguid_count;
    total_bytes = stotal_bytes;
    total_inode_bytes = stotal_inode_bytes;
    total_directory_bytes = stotal_directory_bytes;
    inode_count = sinode_count;
    file_count = sfile_count;
    sym_count = ssym_count;
    dev_count = sdev_count;
    dir_count = sdir_count;
    fifo_count = sfifo_count;
    sock_count = ssock_count;
    dup_files = sdup_files;
    fragments = sfragments;
    fragment_size = 0;
    longjmp(env, 1);
}


void sighandler()
{
    if(interrupted == 1)
        restorefs();
    else {
        ERROR("Interrupting will restore original filesystem!\n");
        ERROR("Interrupt again to quit\n");
        interrupted ++;
    }
}


unsigned int mangle(char *d, char *s, int size, int block_size, int uncompressed, int data_block)
{
    unsigned long c_byte = block_size << 1;
    unsigned int res;

    if(!uncompressed && (res = compress2(d, &c_byte, s, size, 9)) != Z_OK) {
        if(res == Z_MEM_ERROR)
            BAD_ERROR("zlib::compress failed, not enough memory\n");
        else if(res == Z_BUF_ERROR)
            BAD_ERROR("zlib::compress failed, not enough room in output buffer\n");
        else
            BAD_ERROR("zlib::compress failed, unknown error %d\n", res);
        return 0;
    }

    if(uncompressed || c_byte >= size) {
        memcpy(d, s, size);
        return size | (data_block ? SQUASHFS_COMPRESSED_BIT_BLOCK : SQUASHFS_COMPRESSED_BIT);
    }

    return (unsigned int) c_byte;
}


squashfs_base_inode_header *get_inode(int req_size)
{
    int data_space;
    unsigned short c_byte;

    while(cache_bytes >= SQUASHFS_METADATA_SIZE) {
        if((inode_size - inode_bytes) < ((SQUASHFS_METADATA_SIZE << 1)) + 2) {
            if((inode_table = (char *) realloc(inode_table, inode_size + (SQUASHFS_METADATA_SIZE << 1) + 2))
                    == NULL) {
                goto failed;
            }
            inode_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
        }

        c_byte = mangle(inode_table + inode_bytes + block_offset, data_cache,
                                SQUASHFS_METADATA_SIZE, SQUASHFS_METADATA_SIZE, noI, 0);
        TRACE("Inode block @ %x, size %d\n", inode_bytes, c_byte);
        if(!swap)
            memcpy(inode_table + inode_bytes, &c_byte, sizeof(unsigned short));
        else
            SQUASHFS_SWAP_SHORTS((&c_byte), (inode_table + inode_bytes), 1);
        if(check_data)
            *((unsigned char *)(inode_table + inode_bytes + block_offset - 1)) = SQUASHFS_MARKER_BYTE;
        inode_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset;
        total_inode_bytes += SQUASHFS_METADATA_SIZE + block_offset;
        memcpy(data_cache, data_cache + SQUASHFS_METADATA_SIZE, cache_bytes - SQUASHFS_METADATA_SIZE);
        cache_bytes -= SQUASHFS_METADATA_SIZE;
    }

    data_space = (cache_size - cache_bytes);
    if(data_space < req_size) {
            int realloc_size = cache_size == 0 ? ((req_size + SQUASHFS_METADATA_SIZE) & ~(SQUASHFS_METADATA_SIZE - 1)) : req_size - data_space;

            if((data_cache = (char *) realloc(data_cache, cache_size + realloc_size)) == NULL) {
                goto failed;
            }
            cache_size += realloc_size;
    }

    cache_bytes += req_size;

    return (squashfs_base_inode_header *)(data_cache + (cache_bytes - req_size));

failed:
    BAD_ERROR("Out of memory in inode table reallocation!\n");
}


void read_bytes(int fd, unsigned int byte, int bytes, char *buff)
{
    off_t off = byte;

    if(lseek(fd, off, SEEK_SET) == -1) {
        perror("Lseek on destination failed");
        EXIT_MKSQUASHFS();
    }

    if(read(fd, buff, bytes) == -1) {
        perror("Read on destination failed");
        EXIT_MKSQUASHFS();
    }
}


void write_bytes(int fd, unsigned int byte, int bytes, char *buff)
{
    off_t off = byte;

    if(off + bytes > ((long long)1<<32) - 1 )
        BAD_ERROR("Filesystem greater than maximum size 2^32 - 1\n");

    if(lseek(fd, off, SEEK_SET) == -1) {
        perror("Lseek on destination failed");
        EXIT_MKSQUASHFS();
    }

    if(write(fd, buff, bytes) == -1) {
        perror("Write on destination failed");
        EXIT_MKSQUASHFS();
    }
}


unsigned int write_inodes()
{
    unsigned short c_byte;
    int avail_bytes;
    char *datap = data_cache;
    unsigned int start_bytes = bytes;

    while(cache_bytes) {
        if(inode_size - inode_bytes < ((SQUASHFS_METADATA_SIZE << 1) + 2)) {
            if((inode_table = (char *) realloc(inode_table, inode_size + ((SQUASHFS_METADATA_SIZE << 1) + 2))) == NULL) {
                BAD_ERROR("Out of memory in inode table reallocation!\n");
            }
            inode_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
        }
        avail_bytes = cache_bytes > SQUASHFS_METADATA_SIZE ? SQUASHFS_METADATA_SIZE : cache_bytes;
        c_byte = mangle(inode_table + inode_bytes + block_offset, datap, avail_bytes, SQUASHFS_METADATA_SIZE, noI, 0);
        TRACE("Inode block @ %x, size %d\n", inode_bytes, c_byte);
        if(!swap)
            memcpy(inode_table + inode_bytes, &c_byte, sizeof(unsigned short));
        else
            SQUASHFS_SWAP_SHORTS((&c_byte), (inode_table + inode_bytes), 1); 
        if(check_data)
            *((unsigned char *)(inode_table + inode_bytes + block_offset - 1)) = SQUASHFS_MARKER_BYTE;
        inode_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset;
        total_inode_bytes += avail_bytes + block_offset;
        datap += avail_bytes;
        cache_bytes -= avail_bytes;
    }

    write_bytes(fd, bytes, inode_bytes, (char *) inode_table);
    bytes += inode_bytes;

    return start_bytes;
}


unsigned int write_directories()
{
    unsigned short c_byte;
    int avail_bytes;
    char *directoryp = directory_data_cache;
    unsigned int start_bytes = bytes;

    while(directory_cache_bytes) {
        if(directory_size - directory_bytes < ((SQUASHFS_METADATA_SIZE << 1) + 2)) {
            if((directory_table = (char *) realloc(directory_table, directory_size +
                    ((SQUASHFS_METADATA_SIZE << 1) + 2))) == NULL) {
                BAD_ERROR("Out of memory in directory table reallocation!\n");
            }
            directory_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
        }
        avail_bytes = directory_cache_bytes > SQUASHFS_METADATA_SIZE ? SQUASHFS_METADATA_SIZE : directory_cache_bytes;
        c_byte = mangle(directory_table + directory_bytes + block_offset, directoryp, avail_bytes, SQUASHFS_METADATA_SIZE, noI, 0);
        TRACE("Directory block @ %x, size %d\n", directory_bytes, c_byte);
        if(!swap)
            memcpy(directory_table + directory_bytes, &c_byte, sizeof(unsigned short));
        else
            SQUASHFS_SWAP_SHORTS((&c_byte), (directory_table + directory_bytes), 1);
        if(check_data)
            *((unsigned char *)(directory_table + directory_bytes + block_offset - 1)) = SQUASHFS_MARKER_BYTE;
        directory_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset;
        total_directory_bytes += avail_bytes + block_offset;
        directoryp += avail_bytes;
        directory_cache_bytes -= avail_bytes;
    }
    write_bytes(fd, bytes, directory_bytes, (char *) directory_table);
    bytes += directory_bytes;

    return start_bytes;
}


unsigned int get_uid(squashfs_uid uid)
{
    int i;

    for(i = 0; (i < uid_count) && uids[i] != uid; i++);
    if(i == uid_count) {
        if(uid_count == SQUASHFS_UIDS) {
            ERROR("Out of uids! - using uid 0 - probably not what's wanted!\n");
            i = 0;
        } else
            uids[uid_count++] = uid;
    }

    return i;
}


unsigned int get_guid(squashfs_uid uid, squashfs_uid guid)
{
    int i;

    if(uid == guid)
        return SQUASHFS_GUIDS;

    for(i = 0; (i < guid_count) && guids[i] != guid; i++);
    if(i == guid_count) {
        if(guid_count == SQUASHFS_GUIDS) {
            ERROR("Out of gids! - using gid 0 - probably not what's wanted!\n");
            return SQUASHFS_GUIDS;
        } else
            guids[guid_count++] = guid;
    }

    return i;
}


int create_inode(squashfs_inode *i_no, char *filename, int type, int byte_size, squashfs_block start_block, unsigned int offset, unsigned int *block_list, struct fragment *fragment, struct cached_dir_index *index, unsigned int i_count, unsigned int i_size)
{
    struct stat buf;
    squashfs_inode_header inode_header;
    squashfs_base_inode_header *inode, *base = &inode_header.base;

    if(filename[0] == '\0') {
        /* dummy top level directory, if multiple sources specified on command line */
        buf.st_mode = S_IRWXU | S_IRWXG | S_IRWXO;
        buf.st_uid = getuid();
        buf.st_gid = getgid();
        buf.st_mtime = time(NULL);
    } else if(lstat(filename, &buf) == -1) {
        char buffer[8192];
        sprintf(buffer, "Cannot stat dir/file %s, ignoring", filename);
        perror(buffer);
        return FALSE;
    }

    base->mode = SQUASHFS_MODE(buf.st_mode);
    base->uid = get_uid((squashfs_uid) global_uid == -1 ? buf.st_uid : global_uid);
    base->inode_type = type;
    base->guid = get_guid((squashfs_uid) global_uid == -1 ? buf.st_uid : global_uid, (squashfs_uid) global_gid == -1 ? buf.st_gid : global_gid);

    if(type == SQUASHFS_FILE_TYPE) {
        int i;
        squashfs_reg_inode_header *reg = &inode_header.reg, *inodep;

        inode = get_inode(sizeof(*reg) + offset * sizeof(unsigned int));
        inodep = (squashfs_reg_inode_header *) inode;
        reg->mtime = buf.st_mtime;
        reg->file_size = byte_size;
        reg->start_block = start_block;
        reg->fragment = fragment->index;
        reg->offset = fragment->offset;
        if(!swap) {
            memcpy(inodep, reg, sizeof(*reg));
            memcpy(inodep->block_list, block_list, offset * sizeof(unsigned int));
        } else {
            SQUASHFS_SWAP_REG_INODE_HEADER(reg, inodep);
            SQUASHFS_SWAP_INTS(block_list, inodep->block_list, offset);
        }
        TRACE("File inode, file_size %d, start_block %x, blocks %d, fragment %d, offset %d, size %d\n", byte_size,
            start_block, offset, fragment->index, fragment->offset, fragment->size);
        for(i = 0; i < offset; i++)
            TRACE("Block %d, size %d\n", i, block_list[i]);
    }
    else if(type == SQUASHFS_LDIR_TYPE) {
        int i;
        unsigned char *p;
        squashfs_ldir_inode_header *dir = &inode_header.ldir, *inodep;

        if(byte_size >= 1 << 27)
            BAD_ERROR("directory greater than 2^27-1 bytes!\n");

        inode = get_inode(sizeof(*dir) + i_size);
        inodep = (squashfs_ldir_inode_header *) inode;
        dir->inode_type = SQUASHFS_LDIR_TYPE;
        dir->mtime = buf.st_mtime;
        dir->file_size = byte_size;
        dir->offset = offset;
        dir->start_block = start_block;
        dir->i_count = i_count;
        if(!swap)
            memcpy(inode, dir, sizeof(*dir));
        else
            SQUASHFS_SWAP_LDIR_INODE_HEADER(dir, inode);
        p = (unsigned char *) inodep->index;
        for(i = 0; i < i_count; i++) {
            if(!swap)
                memcpy(p, &index[i].index, sizeof(squashfs_dir_index));
            else
                SQUASHFS_SWAP_DIR_INDEX(&index[i].index, p);
            memcpy(((squashfs_dir_index *)p)->name, index[i].name, index[i].index.size + 1);
            p += sizeof(squashfs_dir_index) + index[i].index.size + 1;
        }
        TRACE("Long directory inode, file_size %d, start_block %x, offset %x\n", byte_size,
            start_block, offset);
    }
    else if(type == SQUASHFS_DIR_TYPE) {
        squashfs_dir_inode_header *dir = &inode_header.dir;

        inode = get_inode(sizeof(*dir));
        dir->mtime = buf.st_mtime;
        dir->file_size = byte_size;
        dir->offset = offset;
        dir->start_block = start_block;
        if(!swap)
            memcpy(inode, dir, sizeof(*dir));
        else
            SQUASHFS_SWAP_DIR_INODE_HEADER(dir, inode);
        TRACE("Directory inode, file_size %d, start_block %x, offset %x\n", byte_size,
            start_block, offset);
    }
    else if(type == SQUASHFS_CHRDEV_TYPE || type == SQUASHFS_BLKDEV_TYPE) {
        squashfs_dev_inode_header *dev = &inode_header.dev;

        inode = get_inode(sizeof(*dev));
        dev->rdev = (unsigned short) ((major(buf.st_rdev) << 8) |
            (minor(buf.st_rdev) & 0xff));
        if(!swap)
            memcpy(inode, dev, sizeof(*dev));
        else
            SQUASHFS_SWAP_DEV_INODE_HEADER(dev, inode);
        TRACE("Device inode, rdev %x\n", dev->rdev);
    }
    else if(type == SQUASHFS_SYMLINK_TYPE) {
        squashfs_symlink_inode_header *symlink = &inode_header.symlink, *inodep;
        int byte;
        char buff[65536];

        if((byte = readlink(filename, buff, 65536)) == -1) {
            perror("Error in reading symbolic link, skipping...");
            return FALSE;
        }

        if(byte == 65536) {
            ERROR("Symlink is greater than 65536 bytes! skipping...");
            return FALSE;
        }

        inode = get_inode(sizeof(*symlink) + byte);
        inodep = (squashfs_symlink_inode_header *) inode;
        symlink->symlink_size = byte;
        if(!swap)
            memcpy(inode, symlink, sizeof(*symlink));
        else
            SQUASHFS_SWAP_SYMLINK_INODE_HEADER(symlink, inode);
        strncpy(inodep->symlink, buff, byte);
        TRACE("Symbolic link inode, symlink_size %d\n",     byte);
    }
    else if(type == SQUASHFS_FIFO_TYPE || type == SQUASHFS_SOCKET_TYPE) {
        squashfs_ipc_inode_header *ipc = &inode_header.ipc;

        inode = get_inode(sizeof(*ipc));
        if(!swap)
            memcpy(inode, ipc, sizeof(*ipc));
        else
            SQUASHFS_SWAP_IPC_INODE_HEADER(ipc, inode);
        TRACE("ipc inode, type %s %d\n", type == SQUASHFS_FIFO_TYPE ? "fifo" : "socket");
    } else
        return FALSE;

    *i_no = MKINODE(inode);
    inode_count ++;

    TRACE("Created inode 0x%llx, type %d, uid %d, guid %d\n", *i_no, type, base->uid, base->guid);

    return TRUE;
}


void init_dir(struct directory *dir)
{
    if((dir->buff = (char *)malloc(SQUASHFS_METADATA_SIZE)) == NULL) {
        BAD_ERROR("Out of memory allocating directory buffer\n");
    }

    dir->size = SQUASHFS_METADATA_SIZE;
    dir->p = dir->index_count_p = dir->buff;
    dir->entry_count = 256;
    dir->entry_count_p = NULL;
    dir->index = NULL;
    dir->list = NULL;
    dir->pathname = NULL;
    dir->count = dir->current_count = dir->i_count = dir->byte_count = dir->i_size = 0;
    dir->dir_is_ldir = TRUE;
}


void add_dir(squashfs_inode inode, char *name, int type, struct directory *dir)
{
    char *buff;
    squashfs_dir_entry idir, *idirp;
    unsigned int start_block = inode >> 16;
    unsigned int offset = inode & 0xffff;
    unsigned int size;

    if((size = strlen(name)) > SQUASHFS_NAME_LEN) {
        size = SQUASHFS_NAME_LEN;
        ERROR("Filename is greater than %d characters, truncating! ...\n", SQUASHFS_NAME_LEN);
    }

    if(dir->p + sizeof(squashfs_dir_entry) + size + 6 >= dir->buff + dir->size) {
        if((buff = (char *) realloc(dir->buff, dir->size += SQUASHFS_METADATA_SIZE)) == NULL)  {
            BAD_ERROR("Out of memory reallocating directory buffer\n");
        }

        dir->p = (dir->p - dir->buff) + buff;
        if(dir->entry_count_p) 
            dir->entry_count_p = (dir->entry_count_p - dir->buff + buff);
        dir->index_count_p = dir->index_count_p - dir->buff + buff;
        dir->buff = buff;
    }

    if(dir->entry_count == 256 || start_block != dir->start_block || ((dir->entry_count_p != NULL) && ((dir->p + sizeof(squashfs_dir_entry) + size - dir->index_count_p) > SQUASHFS_METADATA_SIZE))) {
        if(dir->entry_count_p) {
            squashfs_dir_header dir_header;

            if((dir->p + sizeof(squashfs_dir_entry) + size - dir->index_count_p) > SQUASHFS_METADATA_SIZE) {
                if(dir->i_count % I_COUNT_SIZE == 0)
                    if((dir->index = realloc(dir->index, (dir->i_count + I_COUNT_SIZE) * sizeof(struct cached_dir_index))) == NULL)
                        BAD_ERROR("Out of memory in directory index table reallocation!\n");
                dir->index[dir->i_count].index.index = dir->p - dir->buff;
                dir->index[dir->i_count].index.size = size - 1;
                dir->index[dir->i_count++].name = name;
                dir->i_size += sizeof(squashfs_dir_index) + size;
                dir->index_count_p = dir->p;
            }

            dir_header.count = dir->entry_count - 1;
            dir_header.start_block = dir->start_block;
            if(!swap)
                memcpy(dir->entry_count_p, &dir_header, sizeof(dir_header));
            else
                SQUASHFS_SWAP_DIR_HEADER((&dir_header), (squashfs_dir_header *) dir->entry_count_p);

        }


        dir->entry_count_p = dir->p;
        dir->start_block = start_block;
        dir->entry_count = 0;
        dir->p += sizeof(squashfs_dir_header);
    }

    idirp = (squashfs_dir_entry *) dir->p;
    idir.offset = offset;
    idir.type = type;
    idir.size = size - 1;
    if(!swap)
        memcpy(idirp, &idir, sizeof(idir));
    else
        SQUASHFS_SWAP_DIR_ENTRY((&idir), idirp);
    strncpy(idirp->name, name, size);
    dir->p += sizeof(squashfs_dir_entry) + size;
    dir->entry_count ++;
}


int write_dir(squashfs_inode *inode, char *filename, struct directory *dir)
{
    unsigned int dir_size = dir->p - dir->buff;
    int data_space = (directory_cache_size - directory_cache_bytes);
    unsigned int directory_block, directory_offset, i_count, index;
    unsigned short c_byte;

    if(data_space < dir_size) {
        int realloc_size = directory_cache_size == 0 ? ((dir_size + SQUASHFS_METADATA_SIZE) & ~(SQUASHFS_METADATA_SIZE - 1)) : dir_size - data_space;

        if((directory_data_cache = (char *) realloc(directory_data_cache, directory_cache_size + realloc_size)) == NULL) {
            goto failed;
        }
        directory_cache_size += realloc_size;
    }

    if(dir_size) {
        squashfs_dir_header dir_header;

        dir_header.count = dir->entry_count - 1;
        dir_header.start_block = dir->start_block;
        if(!swap)
            memcpy(dir->entry_count_p, &dir_header, sizeof(dir_header));
        else
            SQUASHFS_SWAP_DIR_HEADER((&dir_header), (squashfs_dir_header *) dir->entry_count_p);
        memcpy(directory_data_cache + directory_cache_bytes, dir->buff, dir_size);
    }
    directory_offset = directory_cache_bytes;
    directory_block = directory_bytes;
    directory_cache_bytes += dir_size;
    i_count = 0;
    index = SQUASHFS_METADATA_SIZE - directory_offset;

    while(1) {
        while(i_count < dir->i_count && dir->index[i_count].index.index < index)
            dir->index[i_count++].index.start_block = directory_bytes;
        index += SQUASHFS_METADATA_SIZE;

        if(directory_cache_bytes < SQUASHFS_METADATA_SIZE)
            break;

        if((directory_size - directory_bytes) < ((SQUASHFS_METADATA_SIZE << 1) + 2)) {
            if((directory_table = (char *) realloc(directory_table,
                            directory_size + (SQUASHFS_METADATA_SIZE << 1) + 2)) == NULL) {
                goto failed;
            }
            directory_size += SQUASHFS_METADATA_SIZE << 1;
        }

        c_byte = mangle(directory_table + directory_bytes + block_offset, directory_data_cache,
                SQUASHFS_METADATA_SIZE, SQUASHFS_METADATA_SIZE, noI, 0);
        TRACE("Directory block @ %x, size %d\n", directory_bytes, c_byte);
        if(!swap)
            memcpy(directory_table + directory_bytes, &c_byte, sizeof(unsigned short));
        else
            SQUASHFS_SWAP_SHORTS((&c_byte), (directory_table + directory_bytes), 1);
        if(check_data)
            *((unsigned char *)(directory_table + directory_bytes + block_offset - 1)) = SQUASHFS_MARKER_BYTE;
        directory_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset;
        total_directory_bytes += SQUASHFS_METADATA_SIZE + block_offset;
        memcpy(directory_data_cache, directory_data_cache + SQUASHFS_METADATA_SIZE, directory_cache_bytes - SQUASHFS_METADATA_SIZE);
        directory_cache_bytes -= SQUASHFS_METADATA_SIZE;
    }

    if(dir->dir_is_ldir) {
        if(create_inode(inode, filename, SQUASHFS_LDIR_TYPE, dir_size, directory_block, directory_offset, NULL, NULL, dir->index, dir->i_count, dir->i_size) == FALSE)
            return FALSE;
    } else {
        if(create_inode(inode, filename, SQUASHFS_DIR_TYPE, dir_size, directory_block, directory_offset, NULL, NULL, NULL, 0, 0) == FALSE)
            return FALSE;
    }

#ifdef SQUASHFS_TRACE
    if(!swap) {
        unsigned char *dirp;
        int count;

        TRACE("Directory contents of inode 0x%llx\n", *inode);
        dirp = dir->buff;
        while(dirp < dir->p) {
            char buffer[SQUASHFS_NAME_LEN + 1];
            squashfs_dir_entry idir, *idirp;
            squashfs_dir_header *dirh = (squashfs_dir_header *) dirp;
            count = dirh->count + 1;
            dirp += sizeof(squashfs_dir_header);

            TRACE("\tStart block 0x%x, count %d\n", dirh->start_block, count);

            while(count--) {
                idirp = (squashfs_dir_entry *) dirp;
                memcpy((char *) &idir, (char *) idirp, sizeof(idir));
                strncpy(buffer, idirp->name, idir.size + 1);
                buffer[idir.size + 1] = '\0';
                TRACE("\t\tname %s, inode offset 0x%x, type %d\n", buffer,
                          idir.offset, idir.type);
                dirp += sizeof(squashfs_dir_entry) + idir.size + 1;
            }
        }
    }
#endif
    dir_count ++;

    return TRUE;

failed:
    BAD_ERROR("Out of memory in directory table reallocation!\n");
}


char *get_fragment(char *buffer, struct fragment *fragment)
{
    squashfs_fragment_entry *disk_fragment = &fragment_table[fragment->index];
    int size = SQUASHFS_COMPRESSED_SIZE_BLOCK(disk_fragment->size);

    if(SQUASHFS_COMPRESSED_BLOCK(disk_fragment->size)) {
        int res;
        long bytes = block_size;
        char cbuffer[block_size];

        read_bytes(fd, disk_fragment->start_block, size, cbuffer);

        if((res = uncompress(buffer, &bytes, (const char *) cbuffer, size)) != Z_OK) {
            if(res == Z_MEM_ERROR)
                BAD_ERROR("zlib::uncompress failed, not enough memory\n");
            else if(res == Z_BUF_ERROR)
                BAD_ERROR("zlib::uncompress failed, not enough room in output buffer\n");
            else
                BAD_ERROR("zlib::uncompress failed, unknown error %d\n", res);
        }
    } else
        read_bytes(fd, disk_fragment->start_block, size, buffer);

    return buffer + fragment->offset;
}

    
void write_fragment()
{
    int compressed_size;
    unsigned char buffer[block_size << 1];

    if(fragment_size == 0)
        return;

    if(fragments % FRAG_SIZE == 0)
        if((fragment_table = (squashfs_fragment_entry *) realloc(fragment_table, (fragments + FRAG_SIZE) * sizeof(squashfs_fragment_entry))) == NULL)
            BAD_ERROR("Out of memory in fragment table\n");
    fragment_table[fragments].size = mangle(buffer, fragment_data, fragment_size, block_size, noF, 1);
    fragment_table[fragments].start_block = bytes;
    compressed_size = SQUASHFS_COMPRESSED_SIZE_BLOCK(fragment_table[fragments].size);
    write_bytes(fd, bytes, compressed_size, buffer);
    bytes += compressed_size;
    total_uncompressed += fragment_size;
    total_compressed += compressed_size;
    TRACE("Writing fragment %d, uncompressed size %d, compressed size %d\n",fragments, fragment_size, compressed_size);
    fragments ++;
    fragment_size = 0;
}


static struct fragment empty_fragment = {SQUASHFS_INVALID_BLK, 0, 0};
struct fragment *get_and_fill_fragment(char *buff, int size)
{
    struct fragment *ffrg;

    if(size == 0)
        return &empty_fragment;

    if(fragment_size + size > block_size)
        write_fragment();

    if((ffrg = (struct fragment *) malloc(sizeof(struct fragment))) == NULL)
        BAD_ERROR("Out of memory in fragment block allocation!\n");

    ffrg->index = fragments;
    ffrg->offset = fragment_size;
    ffrg->size = size;
    memcpy(fragment_data + fragment_size, buff, size);
    fragment_size += size;

    return ffrg;
}


unsigned int write_fragment_table()
{
    unsigned int start_bytes, frag_bytes = SQUASHFS_FRAGMENT_BYTES(fragments),
        meta_blocks = SQUASHFS_FRAGMENT_INDEXES(fragments);
    char cbuffer[(SQUASHFS_METADATA_SIZE << 2) + 2], buffer[frag_bytes];
    squashfs_fragment_entry *p = (squashfs_fragment_entry *) buffer;
    unsigned short c_byte;
    int i, compressed_size;
    squashfs_fragment_index list[meta_blocks];

    TRACE("write_fragment_table: fragments %d, frag_bytes %d, meta_blocks %d\n", fragments, frag_bytes, meta_blocks);
    for(i = 0; i < fragments; i++, p++) {
        TRACE("write_fragment_table: fragment %d, start_block %x, size %d\n", i, fragment_table[i].start_block, fragment_table[i].size);
        if(!swap)
            memcpy(p, &fragment_table[i], sizeof(squashfs_fragment_entry));
        else
            SQUASHFS_SWAP_FRAGMENT_ENTRY(&fragment_table[i], p);
    }

    for(i = 0; i < meta_blocks; i++) {
        int avail_bytes = i == meta_blocks - 1 ? frag_bytes % SQUASHFS_METADATA_SIZE : SQUASHFS_METADATA_SIZE;
        c_byte = mangle(cbuffer + block_offset, buffer + i * SQUASHFS_METADATA_SIZE , avail_bytes, SQUASHFS_METADATA_SIZE, noF, 0);
        if(!swap)
            memcpy(cbuffer, &c_byte, sizeof(unsigned short));
        else
            SQUASHFS_SWAP_SHORTS((&c_byte), cbuffer, 1);
        if(check_data)
            *((unsigned char *)(cbuffer + block_offset - 1)) = SQUASHFS_MARKER_BYTE;
        list[i] = bytes;
        compressed_size = SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset;
        write_bytes(fd, bytes, compressed_size, cbuffer);
        bytes += compressed_size;
    }

    if(!swap)
        write_bytes(fd, bytes, sizeof(list), (char *) list);
    else {
        squashfs_fragment_index slist[meta_blocks];
        SQUASHFS_SWAP_FRAGMENT_INDEXES(list, slist, meta_blocks);
        write_bytes(fd, bytes, sizeof(list), (char *) slist);
    }

    start_bytes = bytes;
    bytes += sizeof(list);

    return start_bytes;
}


unsigned char *read_from_buffer(struct duplicate_buffer_handle *handle, unsigned int avail_bytes)
{
    unsigned char *v = handle->ptr;
    handle->ptr += avail_bytes;    
    return v;
}


char read_from_file_buffer[SQUASHFS_FILE_MAX_SIZE];
unsigned char *read_from_file(struct duplicate_buffer_handle *handle, unsigned int avail_bytes)
{
    read_bytes(fd, handle->start, avail_bytes, read_from_file_buffer);
    handle->start += avail_bytes;
    return read_from_file_buffer;
}


/*
 * Compute 16 bit BSD checksum over the data
 */
unsigned short get_checksum(unsigned char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *handle, int l)
{
    unsigned short chksum = 0;
    unsigned int bytes = 0;
    unsigned char *b;
    struct duplicate_buffer_handle position = *handle;

    while(l) {
        bytes = l > SQUASHFS_FILE_MAX_SIZE ? SQUASHFS_FILE_MAX_SIZE : l;
        l -= bytes;
        b = get_next_file_block(&position, bytes);
        while(bytes--) {
            chksum = (chksum & 1) ? (chksum >> 1) | 0x8000 : chksum >> 1;
            chksum += *b++;
        }
    }

    return chksum;
}


int cached_frag = -1;
void add_file(int start, int file_bytes, unsigned int *block_listp, int blocks, unsigned int fragment, int offset, int bytes)
{
    struct fragment *frg;
    struct file_info *dupl_ptr;
    char *datap;
    struct duplicate_buffer_handle handle;
    
    if(!duplicate_checking)
        return;

    if((frg = (struct fragment *) malloc(sizeof(struct fragment))) == NULL)
        BAD_ERROR("Out of memory in fragment block allocation!\n");

    frg->index = fragment;
    frg->offset = offset;
    frg->size = bytes;
    if(fragment == cached_frag || fragment == SQUASHFS_INVALID_BLK)
        datap = fragment_data + offset;
    else
        datap = get_fragment(fragment_data, frg);
    handle.start = start;
    if((dupl_ptr = duplicate(read_from_file, &handle, file_bytes, &block_listp, &start, blocks, &frg, datap, bytes)) != NULL)
        dupl_ptr->fragment = frg;
    cached_frag = fragment;
}


char cached_fragment[SQUASHFS_FILE_SIZE];
int cached_frag1 = -1;

struct file_info *duplicate(unsigned char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *file_start, int bytes, unsigned int **block_list, int *start, int blocks, struct fragment **fragment, char *frag_data, int frag_bytes)
{
    unsigned short checksum = get_checksum(get_next_file_block, file_start, bytes);
    struct duplicate_buffer_handle handle = { frag_data, 0 };
    unsigned short fragment_checksum = get_checksum(read_from_buffer, &handle, frag_bytes);
    struct file_info *dupl_ptr = bytes ? dupl[checksum] : frag_dups[fragment_checksum];


    for(; dupl_ptr; dupl_ptr = dupl_ptr->next)
        if(bytes == dupl_ptr->bytes && frag_bytes == dupl_ptr->fragment->size && fragment_checksum == dupl_ptr->fragment_checksum) {
            unsigned char buffer1[SQUASHFS_FILE_MAX_SIZE];
            unsigned int dup_bytes = dupl_ptr->bytes, dup_start = dupl_ptr->start;
            struct duplicate_buffer_handle position = *file_start;
            unsigned char *buffer;
            while(dup_bytes) {
                int avail_bytes = dup_bytes > SQUASHFS_FILE_MAX_SIZE ? SQUASHFS_FILE_MAX_SIZE : dup_bytes;

                buffer = get_next_file_block(&position, avail_bytes);
                read_bytes(fd, dup_start, avail_bytes, buffer1);
                if(memcmp(buffer, buffer1, avail_bytes) != 0)
                    break;
                dup_bytes -= avail_bytes;
                dup_start += avail_bytes;
            }
            if(dup_bytes == 0) {
                char *fragment_buffer1;
                
                if(dupl_ptr->fragment->index == fragments || dupl_ptr->fragment->index == SQUASHFS_INVALID_BLK)
                    fragment_buffer1 = fragment_data + dupl_ptr->fragment->offset;
                else if(dupl_ptr->fragment->index == cached_frag1)
                    fragment_buffer1 = cached_fragment + dupl_ptr->fragment->offset;
                else {
                    fragment_buffer1 = get_fragment(cached_fragment, dupl_ptr->fragment);
                    cached_frag1 = dupl_ptr->fragment->index;
                }

                if(frag_bytes == 0 || memcmp(frag_data, fragment_buffer1, frag_bytes) == 0) {
                    TRACE("Found duplicate file, start 0x%x, size %d, checksum 0x%x, fragment %d, size %d, offset %d, checksum 0x%x\n", dupl_ptr->start,
                        dupl_ptr->bytes, dupl_ptr->checksum, dupl_ptr->fragment->index, frag_bytes, dupl_ptr->fragment->offset, fragment_checksum);
                    *block_list = dupl_ptr->block_list;
                    *start = dupl_ptr->start;
                    *fragment = dupl_ptr->fragment;
                    return 0;
                }
            }
        }


    if((dupl_ptr = (struct file_info *) malloc(sizeof(struct file_info))) == NULL) {
        BAD_ERROR("Out of memory in dup_files allocation!\n");
    }

    dupl_ptr->bytes = bytes;
    dupl_ptr->checksum = checksum;
    dupl_ptr->start = *start;
    dupl_ptr->fragment_checksum = fragment_checksum;
    if((dupl_ptr->block_list = (unsigned int *) malloc(blocks * sizeof(unsigned int))) == NULL) {
        BAD_ERROR("Out of memory allocating block_list\n");
    }
    
    memcpy(dupl_ptr->block_list, *block_list, blocks * sizeof(unsigned int));
    dup_files ++;
    if(bytes) {
        dupl_ptr->next = dupl[checksum];
        dupl[checksum] = dupl_ptr;
    } else {
        dupl_ptr->next = frag_dups[fragment_checksum];
        frag_dups[fragment_checksum] = dupl_ptr;
    }

    return dupl_ptr;
}


#define MINALLOCBYTES (1024 * 1024)
int write_file(squashfs_inode *inode, char *filename, long long size, int *duplicate_file)
{
    unsigned int frag_bytes, file, start, file_bytes = 0, block = 0;
    unsigned int c_byte;
    long long read_size = (size > SQUASHFS_MAX_FILE_SIZE) ? SQUASHFS_MAX_FILE_SIZE : size;
    unsigned int blocks = (read_size + block_size - 1) >> block_log;
    unsigned int block_list[blocks], *block_listp = block_list;
    char buff[block_size], *c_buffer;
    int allocated_blocks = blocks, i, bbytes, whole_file = 1;
    struct fragment *fragment;
    struct file_info *dupl_ptr = NULL;
    struct duplicate_buffer_handle handle;

    if(!no_fragments && (read_size < block_size || always_use_fragments)) {
        allocated_blocks = blocks = read_size >> block_log;
        frag_bytes = read_size % block_size;
    } else
        frag_bytes = 0;

    if(size > read_size)
        ERROR("file %s truncated to %zu bytes\n", filename, SQUASHFS_MAX_FILE_SIZE);

    total_bytes += read_size;
    if((file = open(filename, O_RDONLY)) == -1) {
        perror("Error in opening file, skipping...");
        return FALSE;
    }

    do {
        if((c_buffer = (char *) malloc((allocated_blocks + 1) << block_log)) == NULL) {
            TRACE("Out of memory allocating write_file buffer, allocated_blocks %d, blocks %d\n", allocated_blocks, blocks);
            whole_file = 0;
            if((allocated_blocks << (block_log - 1)) < MINALLOCBYTES)
                BAD_ERROR("Out of memory allocating write_file buffer, could not allocate %d blocks (%d Kbytes)\n", allocated_blocks, allocated_blocks << (block_log - 10));
            allocated_blocks >>= 1;
        }
    } while(!c_buffer);

    for(start = bytes; block < blocks; file_bytes += bbytes) {
        for(i = 0, bbytes = 0; (i < allocated_blocks) && (block < blocks); i++) {
            int available_bytes = read_size - (block * block_size) > block_size ? block_size : read_size - (block * block_size);
            if(read(file, buff, available_bytes) == -1)
                goto read_err;
            c_byte = mangle(c_buffer + bbytes, buff, available_bytes, block_size, noD, 1);
            block_list[block ++] = c_byte;
            bbytes += SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte);
        }
        if(!whole_file) {
            write_bytes(fd, bytes, bbytes, c_buffer);
            bytes += bbytes;
        }
    }

    if(frag_bytes != 0)
        if(read(file, buff, frag_bytes) == -1)
            goto read_err;

    close(file);
    if(whole_file) {
        handle.ptr = c_buffer;
        if(duplicate_checking && (dupl_ptr = duplicate(read_from_buffer, &handle, file_bytes, &block_listp, &start, blocks, &fragment, buff, frag_bytes)) == NULL) {
            *duplicate_file = TRUE;
            goto wr_inode;
        }
        write_bytes(fd, bytes, file_bytes, c_buffer);
        bytes += file_bytes;
    } else {
        handle.start = start;
        if(duplicate_checking && (dupl_ptr = duplicate(read_from_file, &handle, file_bytes, &block_listp, &start, blocks, &fragment, buff, frag_bytes)) == NULL) {
            bytes = start;
            if(!block_device)
                ftruncate(fd, bytes);
            *duplicate_file = TRUE;
            goto wr_inode;
        }
    }

    fragment = get_and_fill_fragment(buff, frag_bytes);
    if(duplicate_checking)
        dupl_ptr->fragment = fragment;

    *duplicate_file = FALSE;

wr_inode:
    free(c_buffer);
    file_count ++;
    return create_inode(inode, filename, SQUASHFS_FILE_TYPE, read_size, start, blocks, block_listp, fragment, NULL, 0, 0);

read_err:
    perror("Error in reading file, skipping...");
    free(c_buffer);
    return FALSE;
}


char b_buffer[8192];
char *name;
char *basename_r();

char *getbase(char *pathname)
{
    char *result;

    if(*pathname != '/') {
        result = getenv("PWD");
        strcat(strcat(strcpy(b_buffer, result), "/"), pathname);
    } else
        strcpy(b_buffer, pathname);
    name = b_buffer;
    if(((result = basename_r()) == NULL) || (strcmp(result, "..") == 0))
        return NULL;
    else
        return result;
}


char *basename_r()
{
    char *s;
    char *p;
    int n = 1;

    for(;;) {
        s = name;
        if(*name == '\0')
            return NULL;
        if(*name != '/') {
            while(*name != '\0' && *name != '/') name++;
            n = name - s;
        }
        while(*name == '/') name++;
        if(strncmp(s, ".", n) == 0)
            continue;
        if((*name == '\0') || (strncmp(s, "..", n) == 0) || ((p = basename_r()) == NULL)) {
            s[n] = '\0';
            return s;
        }
        if(strcmp(p, "..") == 0)
            continue;
        return p;
    }
}


#define DIR_ENTRIES 256

struct dir_ent {
    char *name;
    char *pathname;
    struct old_root_entry_info *data;
};


void static inline add_dir_entry(char *name, char *pathname, void *data, struct directory *dir)
{
        if((dir->count % DIR_ENTRIES) == 0)
            if((dir->list = realloc(dir->list, (dir->count + DIR_ENTRIES) * sizeof(struct dir_ent *))) == NULL)
                BAD_ERROR("Out of memory in add_dir_entry\n");

        if((dir->list[dir->count] = malloc(sizeof(struct dir_ent))) == NULL)
            BAD_ERROR("Out of memory in linux_opendir\n");

        dir->list[dir->count]->name = strdup(name);
        dir->list[dir->count]->pathname = pathname != NULL ? strdup(pathname) : NULL;
        dir->list[dir->count ++]->data = data;
        dir->byte_count += strlen(name) + sizeof(squashfs_dir_entry);
}



int compare_name(const void *ent1_ptr, const void *ent2_ptr)
{
    struct dir_ent *ent1 = *((struct dir_ent **) ent1_ptr);
    struct dir_ent *ent2 = *((struct dir_ent **) ent2_ptr);

    return strcmp(ent1->name, ent2->name);
}


void sort_directory(struct directory *dir)
{
    qsort(dir->list, dir->count, sizeof(struct dir_ent *), compare_name);

    if(filesystem_minor_version == 0 || (dir->count < 257 && dir->byte_count < SQUASHFS_METADATA_SIZE))
        dir->dir_is_ldir = FALSE;
}


int linux_opendir(char *pathname, struct directory *dir)
{
    DIR    *linuxdir;
    struct dirent *d_name;

    dir->pathname = strdup(pathname);
    if((linuxdir = opendir(pathname)) == NULL)
        return 0;

    while((d_name = readdir(linuxdir)) != NULL) {
        if(strcmp(d_name->d_name, ".") != 0 && strcmp(d_name->d_name, "..") != 0)
            add_dir_entry(d_name->d_name, NULL, NULL, dir);
    }

    closedir(linuxdir);
    sort_directory(dir);
    return 1;
}


int encomp_opendir(char *pathname, struct directory *dir)
{
    int i, n, pass;
    char *basename, dir_name[8192];

    for(i = 0; i < old_root_entries; i++)
        add_dir_entry(old_root_entry[i].name, "", &old_root_entry[i], dir);

    for(i = 0; i < source; i++) {
        if((basename = getbase(source_path[i])) == NULL) {
            ERROR("Bad source directory %s - skipping ...\n", source_path[i]);
            continue;
        }
        strcpy(dir_name, basename);
        pass = 1;
        for(;;) {
            for(n = 0; n < dir->count && strcmp(dir->list[n]->name, dir_name) != 0; n++);
            if(n == dir->count)
                break;
            ERROR("Source directory entry %s already used! - trying ", dir_name);
            sprintf(dir_name, "%s_%d", basename, pass++);
            ERROR("%s\n", dir_name);
        }
        add_dir_entry(dir_name, source_path[i], NULL, dir);
    }
    sort_directory(dir);
    return 1;
}


int single_opendir(char *pathname, struct directory *dir)
{
    DIR    *linuxdir;
    struct dirent *d_name;
    int i, pass;
    char dir_name[1024], filename[8192];

    for(i = 0; i < old_root_entries; i++)
        add_dir_entry(old_root_entry[i].name, "", &old_root_entry[i], dir);

    if((linuxdir = opendir(pathname)) == NULL)
        return 0;

    while((d_name = readdir(linuxdir)) != NULL) {
        if(strcmp(d_name->d_name, ".") == 0 || strcmp(d_name->d_name, "..") == 0)
            continue;

        strcpy(dir_name, d_name->d_name);
        pass = 1;
        for(;;) {
            for(i = 0; i < dir->count && strcmp(dir->list[i]->name, dir_name) != 0; i++);
            if(i == dir->count)
                break;
            ERROR("Source directory entry %s already used! - trying ", dir_name);
            sprintf(dir_name, "%s_%d", d_name->d_name, pass++);
            ERROR("%s\n", dir_name);
        }
        strcat(strcat(strcpy(filename, pathname), "/"), d_name->d_name);
        add_dir_entry(dir_name, filename, NULL, dir);
    }

    closedir(linuxdir);
    sort_directory(dir);
    return 1;
}


int linux_readdir(struct directory *dir, char **filename, char **dir_name)
{
    int current_count;

    while((current_count = dir->current_count++) < dir->count)
        if(dir->list[current_count]->data)
            add_dir(dir->list[current_count]->data->inode, dir->list[current_count]->name,
                dir->list[current_count]->data->type, dir);
        else {
            if(dir->list[current_count]->pathname)
                *filename = dir->list[current_count]->pathname;
            else
                strcat(strcat(strcpy(*filename, dir->pathname), "/"), dir->list[current_count]->name);
            *dir_name = dir->list[current_count]->name;
            return 1;
        }
    return FALSE;    
}


void linux_freedir(struct directory *dir)
{
    int i;

    for(i = 0; i < dir->count; i++) {
        if(dir->list[i]->pathname)
            free(dir->list[i]->pathname);
        free(dir->list[i]->name);
        free(dir->list[i]);
    }
    if(dir->index)
        free(dir->index);
    if(dir->list)
        free(dir->list);
    free(dir->buff);
}


int dir_scan(squashfs_inode *inode, char *pathname, int (_opendir)(char *, struct directory *))
{
    struct stat buf;
    char filename2[8192], *filename = filename2, *dir_name;
    int squashfs_type;
    struct directory dir;
    int result = FALSE;
    int duplicate_file;
    
    init_dir(&dir);
    if(_opendir(pathname, &dir) == 0) {
        ERROR("Could not open %s, skipping...\n", pathname);
        goto error;
    }
    
    while(linux_readdir(&dir, &filename, &dir_name) != FALSE) {

        if(lstat(filename, &buf) == -1) {
            char buffer[8192];
            sprintf(buffer, "Cannot stat dir/file %s, ignoring", filename);
            perror(buffer);
            continue;
        }
        if(excluded(filename, &buf))
            continue;

        switch(buf.st_mode & S_IFMT) {
            case S_IFREG:
                squashfs_type = SQUASHFS_FILE_TYPE;
                if(!sorted) {
                    result = write_file(inode, filename, buf.st_size, &duplicate_file);
                    INFO("file %s, uncompressed size %zu bytes, %s\n", filename, buf.st_size, duplicate_file ? "DUPLICATE" : "");
                } else
                    result = get_sorted_inode(inode, &buf);
                break;

            case S_IFDIR:
                squashfs_type = SQUASHFS_DIR_TYPE;
                result = dir_scan(inode, filename, linux_opendir);
                break;

            case S_IFLNK:
                squashfs_type = SQUASHFS_SYMLINK_TYPE;
                result = create_inode(inode, filename, squashfs_type, 0, 0, 0, NULL, NULL, NULL, 0, 0);
                INFO("symbolic link %s inode 0x%llx\n", dir_name, *inode);
                sym_count ++;
                break;

            case S_IFCHR:
                squashfs_type = SQUASHFS_CHRDEV_TYPE;
                result = create_inode(inode, filename, squashfs_type, 0, 0, 0, NULL, NULL, NULL, 0, 0);
                INFO("character device %s inode 0x%llx\n", dir_name, *inode);
                dev_count ++;
                break;

            case S_IFBLK:
                squashfs_type = SQUASHFS_BLKDEV_TYPE;
                result = create_inode(inode, filename, squashfs_type, 0, 0, 0, NULL, NULL, NULL, 0, 0);
                INFO("block device %s inode 0x%llx\n", dir_name, *inode);
                dev_count ++;
                break;

            case S_IFIFO:
                squashfs_type = SQUASHFS_FIFO_TYPE;
                result = create_inode(inode, filename, squashfs_type, 0, 0, 0, NULL, NULL, NULL, 0, 0);
                INFO("fifo %s inode 0x%llx\n", dir_name, *inode);
                fifo_count ++;
                break;

            case S_IFSOCK:
                squashfs_type = SQUASHFS_SOCKET_TYPE;
                result = create_inode(inode, filename, squashfs_type, 0, 0, 0, NULL, NULL, NULL, 0, 0);
                INFO("unix domain socket %s inode 0x%llx\n", dir_name, *inode);
                sock_count ++;
                break;

             default:
                ERROR("%s unrecognised file type, mode is %x\n", filename, buf.st_mode);
                result = FALSE;
            }

        if(result)
            add_dir(*inode, dir_name, squashfs_type, &dir);
    }

    result = write_dir(inode, pathname, &dir);
    INFO("directory %s inode 0x%llx\n", pathname, *inode);

error:
    linux_freedir(&dir);

    return result;
}


unsigned int slog(unsigned int block)
{
    int i;

    for(i = 12; i <= 16; i++)
        if(block == (1 << i))
            return i;
    return 0;
}


int excluded(char *filename, struct stat *buf)
{
    int i;

    for(i = 0; i < exclude; i++)
        if((exclude_paths[i].st_dev == buf->st_dev) && (exclude_paths[i].st_ino == buf->st_ino))
            return TRUE;
    return FALSE;
}


#define ADD_ENTRY(buf) \
    if(exclude % EXCLUDE_SIZE == 0) {\
        if((exclude_paths = (struct exclude_info *) realloc(exclude_paths, (exclude + EXCLUDE_SIZE) * sizeof(struct exclude_info))) == NULL)\
            BAD_ERROR("Out of memory in exclude dir/file table\n");\
    }\
    exclude_paths[exclude].st_dev = buf.st_dev;\
    exclude_paths[exclude++].st_ino = buf.st_ino;
int add_exclude(char *path)
{
    int i;
    char buffer[4096], filename[4096];
    struct stat buf;

    if(path[0] == '/' || strncmp(path, "./", 2) == 0 || strncmp(path, "../", 3) == 0) {
        if(lstat(path, &buf) == -1) {
            sprintf(buffer, "Cannot stat exclude dir/file %s, ignoring", path);
            perror(buffer);
            return TRUE;
        }
        ADD_ENTRY(buf);
        return TRUE;
    }

    for(i = 0; i < source; i++) {
        strcat(strcat(strcpy(filename, source_path[i]), "/"), path);
        if(lstat(filename, &buf) == -1) {
            if(!(errno == ENOENT || errno == ENOTDIR)) {
                sprintf(buffer, "Cannot stat exclude dir/file %s, ignoring", filename);
                perror(buffer);
            }
            continue;
        }
        ADD_ENTRY(buf);
    }
    return TRUE;
}


void add_old_root_entry(char *name, squashfs_inode inode, int type)
{
    if((old_root_entry = (struct old_root_entry_info *) realloc(old_root_entry, sizeof(struct old_root_entry_info)
                * (old_root_entries + 1))) == NULL)
        BAD_ERROR("Out of memory in old root directory entries reallocation\n");

    strcpy(old_root_entry[old_root_entries].name, name);
    old_root_entry[old_root_entries].inode = inode;
    old_root_entry[old_root_entries++].type = type;
}


#define VERSION() \
    printf("mksquashfs version 2.2-r2\n");\
    printf("copyright (C) 2005 Phillip Lougher ([email protected])\n\n"); \
        printf("This program is free software; you can redistribute it and/or\n");\
    printf("modify it under the terms of the GNU General Public License\n");\
    printf("as published by the Free Software Foundation; either version 2,\n");\
    printf("or (at your option) any later version.\n\n");\
    printf("This program is distributed in the hope that it will be useful,\n");\
    printf("but WITHOUT ANY WARRANTY; without even the implied warranty of\n");\
    printf("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");\
    printf("GNU General Public License for more details.\n");
int main(int argc, char *argv[])
{
    struct stat buf;
    int i;
    squashfs_super_block sBlk;
    char *b, *root_name = NULL;
    int be, nopad = FALSE, delete = FALSE, keep_as_directory = FALSE, orig_be;
    squashfs_inode inode;

#if __BYTE_ORDER == __BIG_ENDIAN
    be = TRUE;
#else
    be = FALSE;
#endif

    block_log = slog(block_size);
    if(argc > 1 && strcmp(argv[1], "-version") == 0) {
        VERSION();
        exit(0);
    }
        for(i = 1; i < argc && argv[i][0] != '-'; i++);
    if(i < 3)
        goto printOptions;
    source_path = argv + 1;
    source = i - 2;
    for(; i < argc; i++) {
        if(strcmp(argv[i], "-b") == 0) {
            if((++i == argc) || (block_size = strtol(argv[i], &b, 10), *b !='\0')) {
                ERROR("%s: -b missing or invalid block size\n", argv[0]);
                exit(1);
            }

            if((block_log = slog(block_size)) == 0) {
                ERROR("%s: -b block size not power of two or not between 4096 and 64K\n", argv[0]);
                exit(1);
            }
        } else if(strcmp(argv[i], "-ef") == 0) {
            if(++i == argc) {
                ERROR("%s: -ef missing filename\n", argv[0]);
                exit(1);
            }
        } else if(strcmp(argv[i], "-2.0") == 0)
            filesystem_minor_version = 0;

        else if(strcmp(argv[i], "-no-duplicates") == 0)
            duplicate_checking = FALSE;

        else if(strcmp(argv[i], "-no-fragments") == 0)
            no_fragments = TRUE;

         else if(strcmp(argv[i], "-always-use-fragments") == 0)
            always_use_fragments = TRUE;

         else if(strcmp(argv[i], "-sort") == 0) {
            if(++i == argc) {
                ERROR("%s: -sort missing filename\n", argv[0]);
                exit(1);
            }
        } else if(strcmp(argv[i], "-all-root") == 0 ||
                strcmp(argv[i], "-root-owned") == 0)
            global_uid = global_gid = 0;

        else if(strcmp(argv[i], "-force-uid") == 0) {
            if(++i == argc) {
                ERROR("%s: -force-uid missing uid or user\n", argv[0]);
                exit(1);
            }
            if((global_uid = strtoll(argv[i], &b, 10)), *b =='\0') {
                if(global_uid < 0 || global_uid > (((long long) 1 << 32) - 1)) {
                    ERROR("%s: -force-uid uid out of range\n", argv[0]);
                    exit(1);
                }
            } else {
                struct passwd *uid = getpwnam(argv[i]);
                if(uid)
                    global_uid = uid->pw_uid;
                else {
                    ERROR("%s: -force-uid invalid uid or unknown user\n", argv[0]);
                    exit(1);
                }
            }
        } else if(strcmp(argv[i], "-force-gid") == 0) {
            if(++i == argc) {
                ERROR("%s: -force-gid missing gid or group\n", argv[0]);
                exit(1);
            }
            if((global_gid = strtoll(argv[i], &b, 10)), *b =='\0') {
                if(global_gid < 0 || global_gid > (((long long) 1 << 32) - 1)) {
                    ERROR("%s: -force-gid gid out of range\n", argv[0]);
                    exit(1);
                }
            } else {
                struct group *gid = getgrnam(argv[i]);
                if(gid)
                    global_gid = gid->gr_gid;
                else {
                    ERROR("%s: -force-gid invalid gid or unknown group\n", argv[0]);
                    exit(1);
                }
            }
        } else if(strcmp(argv[i], "-noI") == 0 ||
                strcmp(argv[i], "-noInodeCompression") == 0)
            noI = TRUE;

        else if(strcmp(argv[i], "-noD") == 0 ||
                strcmp(argv[i], "-noDataCompression") == 0)
            noD = TRUE;

        else if(strcmp(argv[i], "-noF") == 0 ||
                strcmp(argv[i], "-noFragmentCompression") == 0)
            noF = TRUE;

        else if(strcmp(argv[i], "-nopad") == 0)
            nopad = TRUE;

        else if(strcmp(argv[i], "-check_data") == 0)
            check_data = TRUE;

        else if(strcmp(argv[i], "-info") == 0)
            silent = 0;

        else if(strcmp(argv[i], "-be") == 0)
            be = TRUE;

        else if(strcmp(argv[i], "-le") == 0)
            be = FALSE;

        else if(strcmp(argv[i], "-e") == 0)
            break;

        else if(strcmp(argv[i], "-noappend") == 0)
            delete = TRUE;

        else if(strcmp(argv[i], "-keep-as-directory") == 0)
            keep_as_directory = TRUE;

        else if(strcmp(argv[i], "-root-becomes") == 0) {
            if(++i == argc) {
                ERROR("%s: -root-becomes: missing name\n", argv[0]);
                exit(1);
            }    
            root_name = argv[i];
        } else if(strcmp(argv[i], "-version") == 0) {
            VERSION();
        } else {
            ERROR("%s: invalid option\n\n", argv[0]);
printOptions:
            ERROR("SYNTAX:%s source1 source2 ...  dest [options] [-e list of exclude\ndirs/files]\n", argv[0]);
            ERROR("\nOptions are\n");
            ERROR("-version\t\tprint version, licence and copyright message\n");
            ERROR("-info\t\t\tprint files written to filesystem\n");
            ERROR("-b <block_size>\t\tset data block to <block_size>.  Default %d bytes\n", SQUASHFS_FILE_SIZE);
            ERROR("-2.0\t\t\tcreate a 2.0 filesystem\n");
            ERROR("-noI\t\t\tdo not compress inode table\n");
            ERROR("-noD\t\t\tdo not compress data blocks\n");
            ERROR("-noF\t\t\tdo not compress fragment blocks\n");
            ERROR("-no-fragments\t\tdo not use fragments\n");
            ERROR("-always-use-fragments\tuse fragment blocks for files larger than block size\n");
            ERROR("-no-duplicates\t\tdo not perform duplicate checking\n");
            ERROR("-noappend\t\tdo not append to existing filesystem\n");
            ERROR("-keep-as-directory\tif one source directory is specified, create a root\n");
            ERROR("\t\t\tdirectory containing that directory, rather than the\n");
            ERROR("\t\t\tcontents of the directory\n");
            ERROR("-root-becomes <name>\twhen appending source files/directories, make the\n");
            ERROR("\t\t\toriginal root become a subdirectory in the new root\n");
            ERROR("\t\t\tcalled <name>, rather than adding the new source items\n");
            ERROR("\t\t\tto the original root\n");
            ERROR("-all-root\t\tmake all files owned by root\n");
            ERROR("-force-uid uid\t\tset all file uids to uid\n");
            ERROR("-force-gid gid\t\tset all file gids to gid\n");
            ERROR("-le\t\t\tcreate a little endian filesystem\n");
            ERROR("-be\t\t\tcreate a big endian filesystem\n");
            ERROR("-nopad\t\t\tdo not pad filesystem to a multiple of 4K\n");
            ERROR("-check_data\t\tadd checkdata for greater filesystem checks\n");
            ERROR("-root-owned\t\talternative name for -all-root\n");
            ERROR("-noInodeCompression\talternative name for -noI\n");
            ERROR("-noDataCompression\talternative name for -noD\n");
            ERROR("-noFragmentCompression\talternative name for -noF\n");
            ERROR("-sort <sort_file>\tsort files according to priorities in <sort_file>.  One\n");
            ERROR("\t\t\tfile or dir with priority per line.  Priority -32768 to\n");
            ERROR("\t\t\t32767, default priority 0\n");
            ERROR("-ef <exclude_file>\tlist of exclude dirs/files.  One per line\n");
            exit(1);
        }
    }


    for(i = 0; i < source; i++)
        if(lstat(source_path[i], &buf) == -1) {
            fprintf(stderr, "Cannot stat source directory \"%s\" because %s\n", source_path[i], strerror(errno));
            EXIT_MKSQUASHFS();
        }


    destination_file = argv[source + 1];
    if(stat(argv[source + 1], &buf) == -1) {
        if(errno == ENOENT) { /* Does not exist */
            if((fd = open(argv[source + 1], O_CREAT | O_TRUNC | O_RDWR, S_IRWXU)) == -1) {
                perror("Could not create destination file");
                exit(1);
            }
            delete = TRUE;
        } else {
            perror("Could not stat destination file");
            exit(1);
        }

    } else {
        if(S_ISBLK(buf.st_mode)) {
            if((fd = open(argv[source + 1], O_RDWR)) == -1) {
                perror("Could not open block device as destination");
                exit(1);
            }
            block_device = 1;

        } else if(S_ISREG(buf.st_mode))     {
            if((fd = open(argv[source + 1], (delete ? O_TRUNC : 0) | O_RDWR)) == -1) {
                perror("Could not open regular file for writing as destination");
                exit(1);
            }
        }
        else {
            ERROR("Destination not block device or regular file\n");
            exit(1);
        }

        if(!delete) {
                if(read_super(fd, &sBlk, &orig_be, argv[source + 1]) == 0) {
                ERROR("Failed to read existing filesystem - will not overwrite - ABORTING!\n");
                EXIT_MKSQUASHFS();
            }
        }
    }

    /* process the exclude files - must be done afer destination file has been possibly created */
    for(i = source + 2; i < argc; i++)
        if(strcmp(argv[i], "-ef") == 0) {
            FILE *fd;
            char filename[16385];
            if((fd = fopen(argv[++i], "r")) == NULL) {
                perror("Could not open exclude file...");
                exit(1);
            }
            while(fscanf(fd, "%16384[^\n]\n", filename) != EOF)
                add_exclude(filename);
            fclose(fd);
        } else if(strcmp(argv[i], "-e") == 0)
            break;
        else if(strcmp(argv[i], "-b") == 0 || strcmp(argv[i], "-root-becomes") == 0 || strcmp(argv[i], "-sort") == 0)
            i++;

    if(i != argc) {
        if(++i == argc) {
            ERROR("%s: -e missing arguments\n", argv[0]);
            EXIT_MKSQUASHFS();
        }
        while(i < argc && add_exclude(argv[i++]));
    }

    /* process the sort files - must be done afer the exclude files  */
    for(i = source + 2; i < argc; i++)
        if(strcmp(argv[i], "-sort") == 0) {
            read_sort_file(argv[++i], source, source_path);
            sorted ++;
        } else if(strcmp(argv[i], "-e") == 0)
            break;
        else if(strcmp(argv[i], "-b") == 0 || strcmp(argv[i], "-root-becomes") == 0 || strcmp(argv[i], "-ef") == 0)
            i++;

    if(delete) {
        printf("Creating %s %d.%d filesystem on %s, block size %d.\n",
                be ? "big endian" : "little endian", SQUASHFS_MAJOR, filesystem_minor_version, argv[source + 1], block_size);
        bytes = sizeof(squashfs_super_block);
    } else {
        unsigned int last_directory_block, inode_dir_offset, inode_dir_file_size, root_inode_size,
        inode_dir_start_block, uncompressed_data, compressed_data;
        unsigned root_inode_start = SQUASHFS_INODE_BLK(sBlk.root_inode), root_inode_offset =
        SQUASHFS_INODE_OFFSET(sBlk.root_inode);

        be = orig_be;
        block_log = slog(block_size = sBlk.block_size);
        noI = SQUASHFS_UNCOMPRESSED_INODES(sBlk.flags);
        noD = SQUASHFS_UNCOMPRESSED_DATA(sBlk.flags);
        noF = SQUASHFS_UNCOMPRESSED_FRAGMENTS(sBlk.flags);
        check_data = SQUASHFS_CHECK_DATA(sBlk.flags);
        no_fragments = SQUASHFS_NO_FRAGMENTS(sBlk.flags);
        always_use_fragments = SQUASHFS_ALWAYS_FRAGMENTS(sBlk.flags);
        duplicate_checking = SQUASHFS_DUPLICATES(sBlk.flags);
        filesystem_minor_version = sBlk.s_minor;
        
        if((bytes = read_filesystem(root_name, fd, &sBlk, &inode_table, &data_cache,
                &directory_table, &directory_data_cache, &last_directory_block, &inode_dir_offset,
                &inode_dir_file_size, &root_inode_size, &inode_dir_start_block,
                &file_count, &sym_count, &dev_count, &dir_count, &fifo_count, &sock_count,
                (squashfs_uid *) uids, &uid_count, (squashfs_uid *) guids, &guid_count,
                &total_bytes, &total_inode_bytes, &total_directory_bytes, add_old_root_entry, &fragment_table)) == 0) {
            ERROR("Failed to read existing filesystem - will not overwrite - ABORTING!\n");
            EXIT_MKSQUASHFS();
        }
        if((fragments = sBlk.fragments))
            fragment_table = (squashfs_fragment_entry *) realloc((char *) fragment_table, ((fragments + FRAG_SIZE - 1) & ~(FRAG_SIZE - 1)) * sizeof(squashfs_fragment_entry)); 

        printf("Appending to existing %s %d.%d filesystem on %s, block size %d\n", be ? "big endian" :
            "little endian", SQUASHFS_MAJOR, filesystem_minor_version, argv[source + 1], block_size);
        printf("All -be, -le, -b, -noI, -noD, -noF, -check_data, no-duplicates, no-fragments, -always-use-fragments and -2.0 options ignored\n");
        printf("\nIf appending is not wanted, please re-run with -noappend specified!\n\n");

        compressed_data = inode_dir_offset + inode_dir_file_size & ~(SQUASHFS_METADATA_SIZE - 1);
        uncompressed_data = inode_dir_offset + inode_dir_file_size & (SQUASHFS_METADATA_SIZE - 1);
        
        /* save original filesystem state for restoring ... */
        sfragments = fragments;
        sbytes = bytes;
        sinode_count = sBlk.inodes;
        sdata_cache = (char *)malloc(scache_bytes = root_inode_offset + root_inode_size);
        sdirectory_data_cache = (char *)malloc(sdirectory_cache_bytes = uncompressed_data);
        memcpy(sdata_cache, data_cache, scache_bytes);
        memcpy(sdirectory_data_cache, directory_data_cache + compressed_data, sdirectory_cache_bytes);
        sinode_bytes = root_inode_start;
        sdirectory_bytes = last_directory_block;
        suid_count = uid_count;
        sguid_count = guid_count;
        stotal_bytes = total_bytes;
        stotal_inode_bytes = total_inode_bytes;
        stotal_directory_bytes = total_directory_bytes + compressed_data;
        sfile_count = file_count;
        ssym_count = sym_count;
        sdev_count = dev_count;
        sdir_count = dir_count + 1;
        sfifo_count = fifo_count;
        ssock_count = sock_count;
        sdup_files = dup_files;
        restore = TRUE;
        if(setjmp(env))
            goto restore_filesystem;
        signal(SIGTERM, sighandler);
        signal(SIGINT, sighandler);
        write_bytes(fd, SQUASHFS_START, 4, "\0\0\0\0");

        /* set the filesystem state up to be able to append to the original filesystem.  The filesystem state
         * differs depending on whether we're appending to the original root directory, or if the original
         * root directory becomes a sub-directory (root-becomes specified on command line, here root_name != NULL)
         */
        inode_bytes = inode_size = root_inode_start;
        directory_size = last_directory_block;
        cache_size = root_inode_offset + root_inode_size;
        directory_cache_size = inode_dir_offset + inode_dir_file_size;
        if(root_name) {
            directory_bytes = last_directory_block;
            directory_cache_bytes = uncompressed_data;
            memmove(directory_data_cache, directory_data_cache + compressed_data, uncompressed_data);
            cache_bytes = root_inode_offset + root_inode_size;
            add_old_root_entry(root_name, sBlk.root_inode, SQUASHFS_DIR_TYPE);
            total_directory_bytes += compressed_data;
            dir_count ++;
        } else {
            directory_bytes = inode_dir_start_block;
            directory_cache_bytes = inode_dir_offset;
            cache_bytes = root_inode_offset;
        }

        inode_count = file_count + dir_count + sym_count + dev_count + fifo_count + sock_count;
    }

#if __BYTE_ORDER == __BIG_ENDIAN
    swap = !be;
#else
    swap = be;
#endif

    block_offset = check_data ? 3 : 2;

    if(sorted)
        sort_files_and_write(source, source_path);

    if(delete && !keep_as_directory && source == 1 && S_ISDIR(buf.st_mode))
        dir_scan(&inode, source_path[0], linux_opendir);
    else if(!keep_as_directory && source == 1 && S_ISDIR(buf.st_mode))
        dir_scan(&inode, source_path[0], single_opendir);
    else
        dir_scan(&inode, "", encomp_opendir);
    sBlk.root_inode = inode;
    sBlk.inodes = inode_count;
    sBlk.s_magic = SQUASHFS_MAGIC;
    sBlk.s_major = SQUASHFS_MAJOR;
    sBlk.s_minor = filesystem_minor_version;
    sBlk.block_size = block_size;
    sBlk.block_log = block_log;
    sBlk.flags = SQUASHFS_MKFLAGS(noI, noD, check_data, noF, no_fragments, always_use_fragments, duplicate_checking);
    sBlk.mkfs_time = time(NULL);

restore_filesystem:
    write_fragment();
    sBlk.fragments = fragments;
    sBlk.inode_table_start = write_inodes();
    sBlk.directory_table_start = write_directories();
    sBlk.fragment_table_start = write_fragment_table();

    TRACE("sBlk->inode_table_start 0x%x\n", sBlk.inode_table_start);
    TRACE("sBlk->directory_table_start 0x%x\n", sBlk.directory_table_start);
    TRACE("sBlk->fragment_table_start 0x%x\n", sBlk.fragment_table_start);

    if(sBlk.no_uids = uid_count) {
        if(!swap)
            write_bytes(fd, bytes, uid_count * sizeof(squashfs_uid), (char *) uids);
        else {
            squashfs_uid uids_copy[uid_count];

            SQUASHFS_SWAP_DATA(uids, uids_copy, uid_count, sizeof(squashfs_uid) * 8);
            write_bytes(fd, bytes, uid_count * sizeof(squashfs_uid), (char *) uids_copy);
        }
        sBlk.uid_start = bytes;
        bytes += uid_count * sizeof(squashfs_uid);
    } else
        sBlk.uid_start = 0;

    if(sBlk.no_guids = guid_count) {
        if(!swap)
            write_bytes(fd, bytes, guid_count * sizeof(squashfs_uid), (char *) guids);
        else {
            squashfs_uid guids_copy[guid_count];

            SQUASHFS_SWAP_DATA(guids, guids_copy, guid_count, sizeof(squashfs_uid) * 8);
            write_bytes(fd, bytes, guid_count * sizeof(squashfs_uid), (char *) guids_copy);
        }
        sBlk.guid_start = bytes;
        bytes += guid_count * sizeof(squashfs_uid);
    } else
        sBlk.guid_start = 0;

    sBlk.bytes_used = bytes;

    if(!swap)
        write_bytes(fd, SQUASHFS_START, sizeof(squashfs_super_block), (char *) &sBlk);
    else {
        squashfs_super_block sBlk_copy;

        SQUASHFS_SWAP_SUPER_BLOCK((&sBlk), &sBlk_copy); 
        write_bytes(fd, SQUASHFS_START, sizeof(squashfs_super_block), (char *) &sBlk_copy);
    }

    if(!nopad && (i = bytes & (4096 - 1))) {
        unsigned char temp[4096] = {0};
        write_bytes(fd, bytes, 4096 - i, temp);
    }

    total_bytes += total_inode_bytes + total_directory_bytes + uid_count
        * sizeof(unsigned short) + guid_count * sizeof(unsigned short) +
        sizeof(squashfs_super_block);

    printf("\n%s filesystem, data block size %d, %s data, %s metadata, %s fragments\n", be ?
        "Big endian" : "Little endian", block_size, noD ? "uncompressed" : "compressed", noI ?
    "uncompressed" : "compressed", no_fragments ? "no" : noF ? "uncompressed" : "compressed");
    printf("Filesystem size %.2f Kbytes (%.2f Mbytes)\n", bytes / 1024.0, bytes / (1024.0 * 1024.0));
    printf("\t%.2f%% of uncompressed filesystem size (%.2f Kbytes)\n",
        ((float) bytes / total_bytes) * 100.0, total_bytes / 1024.0);
    printf("Inode table size %d bytes (%.2f Kbytes)\n",
        inode_bytes, inode_bytes / 1024.0);
    printf("\t%.2f%% of uncompressed inode table size (%d bytes)\n",
        ((float) inode_bytes / total_inode_bytes) * 100.0, total_inode_bytes);
    printf("Directory table size %d bytes (%.2f Kbytes)\n",
        directory_bytes, directory_bytes / 1024.0);
    printf("\t%.2f%% of uncompressed directory table size (%d bytes)\n",
        ((float) directory_bytes / total_directory_bytes) * 100.0, total_directory_bytes);
    if(duplicate_checking)
        printf("Number of duplicate files found %d\n", file_count - dup_files);
    else
        printf("No duplicate files removed\n");
    printf("Number of inodes %d\n", inode_count);
    printf("Number of files %d\n", file_count);
    if(!no_fragments)
        printf("Number of fragments %d\n", fragments);
    printf("Number of symbolic links  %d\n", sym_count);
    printf("Number of device nodes %d\n", dev_count);
    printf("Number of fifo nodes %d\n", fifo_count);
    printf("Number of socket nodes %d\n", sock_count);
    printf("Number of directories %d\n", dir_count);
    printf("Number of uids %d\n", uid_count);

    for(i = 0; i < uid_count; i++) {
        struct passwd *user = getpwuid(uids[i]);
        printf("\t%s (%d)\n", user == NULL ? "unknown" : user->pw_name, uids[i]);
    }

    printf("Number of gids %d\n", guid_count);

    for(i = 0; i < guid_count; i++) {
        struct group *group = getgrgid(guids[i]);
        printf("\t%s (%d)\n", group == NULL ? "unknown" : group->gr_name, guids[i]);
    }
    close(fd);
    return 0;
}

er13 · 18 Jan 2016

Wozu? Wer braucht stable-2.0? Bitte trunk nutzen, es ist für die älteren Firmware-Versionen nicht weniger stabil als jede Stable-Version davor.

Honigmelone · 18 Jan 2016

Danke für den Hinweis. Bin ein Freetz Neuling und hatte das Wiki falsch verstanden.

andiling · 18 Jan 2016

So falsch hast Du es gar nicht verstanden... (leider ist das Wiki readonly)

Languages

Suche

Languages

Suche

[Problem] freetz "make" bricht unter Archlinux mit Fehlern ab

andiling

IPPF-Promi

Honigmelone

Neuer User

er13

Aktives Mitglied

Honigmelone

Neuer User

andiling

IPPF-Promi

Zurzeit aktive Besucher

Neueste Beiträge

Statistik des Forums