From 4aca87515a5083ae0e31ce3177189fd43b6d05ac Mon Sep 17 00:00:00 2001 From: Andreas Baumann Date: Sat, 3 Jan 2015 13:58:15 +0100 Subject: patch to Vanilla Tomato 1.28 --- .../src/linux/linux/scripts/squashfs/mksquashfs.c | 1317 +++++++++++++------- 1 file changed, 853 insertions(+), 464 deletions(-) (limited to 'release/src/linux/linux/scripts/squashfs/mksquashfs.c') diff --git a/release/src/linux/linux/scripts/squashfs/mksquashfs.c b/release/src/linux/linux/scripts/squashfs/mksquashfs.c index fbe25e6d..e773f53c 100644 --- a/release/src/linux/linux/scripts/squashfs/mksquashfs.c +++ b/release/src/linux/linux/scripts/squashfs/mksquashfs.c @@ -1,7 +1,8 @@ /* * Create a squashfs filesystem. This is a highly compressed read only filesystem. * - * Copyright (c) 2002, 2003, 2004 Phillip Lougher + * Copyright (c) 2002, 2003, 2004, 2005, 2006 + * Phillip Lougher * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License @@ -20,7 +21,9 @@ * mksquashfs.c */ +#define FALSE 0 #define TRUE 1 + #include #include #include @@ -33,44 +36,70 @@ #include #include #include -#include #include #include #include #include -#include "mksquashfs.h" +#ifndef linux +#define __BYTE_ORDER BYTE_ORDER +#define __BIG_ENDIAN BIG_ENDIAN +#define __LITTLE_ENDIAN LITTLE_ENDIAN +#else +#include +#endif + #include +#include "mksquashfs.h" +#include "global.h" +#include "sort.h" #ifdef SQUASHFS_TRACE -#define TRACE(s, args...) printf("mksquashfs: "s, ## args) +#define TRACE(s, args...) do { \ + printf("mksquashfs: "s, ## args); \ + } while(0) #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();\ - exit(1); } while(0) -#define BAD_ERROR(s, args...) do {\ +#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(delete && 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 duplicate_checking = 1, noF = 0, no_fragments = 0, always_use_fragments = 0; -int total_compressed = 0, total_uncompressed = 0; + } while(0) +int delete = FALSE; +long long 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; + /* superblock attributes */ -int noI = 0, noD = 0, check_data = 0, block_size = SQUASHFS_FILE_SIZE, block_log; +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; +long long bytes = 0, total_bytes = 0; /* in memory directory table - possibly compressed */ char *directory_table = NULL; @@ -88,22 +117,38 @@ unsigned int inode_bytes = 0, inode_size = 0, total_inode_bytes = 0; char *data_cache = NULL; unsigned int cache_bytes = 0, cache_size = 0, inode_count = 0; -/* in memory directory header */ +/* in memory directory data */ +#define I_COUNT_SIZE 128 +#define DIR_ENTRIES 32 +#define INODE_HASH_SIZE 65536 +#define INODE_HASH_MASK (INODE_HASH_SIZE - 1) +#define INODE_HASH(dev, ino) (ino & INODE_HASH_MASK) + +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; - squashfs_dir_header *entry_count_p; + unsigned char *entry_count_p; + unsigned int i_count; + unsigned int i_size; + struct cached_dir_index *index; + unsigned char *index_count_p; + unsigned int inode_number; }; +struct inode_info *inode_info[INODE_HASH_SIZE]; + +/* hash tables used to do fast duplicate searches in duplicate check */ struct file_info *dupl[65536], *frag_dups[65536]; int dup_files = 0; -int swap, silent = TRUE; -int file_count = 0, sym_count = 0, dev_count = 0, dir_count = 0, fifo_count = 0, sock_count = 0; - /* list of exclude dirs/files */ struct exclude_info { dev_t st_dev; @@ -117,18 +162,22 @@ int excluded(char *filename, struct stat *buf); /* fragment block data structures */ int fragments = 0; -static char *fragment_data; -static int fragment_size = 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; + +/* current inode number for directories and non directories */ +unsigned int dir_inode_no = 1; +unsigned int inode_no = 0; +unsigned int root_inode_number = 0; + /* list of source dirs/files */ int source = 0; char **source_path; @@ -139,13 +188,15 @@ struct old_root_entry_info { char name[SQUASHFS_NAME_LEN + 1]; squashfs_inode inode; int type; + int inode_number; }; +struct old_root_entry_info *old_root_entry; /* in memory file info */ struct file_info { - unsigned int bytes; + long long bytes; unsigned short checksum; - unsigned int start; + long long start; unsigned int *block_list; struct file_info *next; struct fragment *fragment; @@ -158,46 +209,51 @@ 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, + +long long sbytes, stotal_bytes; + +unsigned int sinode_bytes, scache_bytes, sdirectory_bytes, sdirectory_cache_bytes, suid_count, sguid_count, - stotal_bytes, stotal_inode_bytes, stotal_directory_bytes, + stotal_inode_bytes, stotal_directory_bytes, sinode_count, sfile_count, ssym_count, sdev_count, - sdir_count, sdup_files; + sdir_count, sfifo_count, ssock_count, sdup_files; int sfragments; int restore = 0; -/*flag whether destination file is a block device */ +/* 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; -long long global_uid = -1, global_gid = -1; +/* 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; + char *ptr; + long long start; }; -struct old_root_entry_info *old_root_entry; -void add_old_root_entry(char *name, squashfs_inode inode, int type); +void add_old_root_entry(char *name, squashfs_inode inode, int inode_number, 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 **inode_table, int *inode_bytes, - char **data_cache, int *cache_bytes, int *cache_size, char **directory_table, int *directory_bytes, - char **directory_data_cache, int *directory_cache_bytes, int *directory_cache_size, - 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); -squashfs_inode get_sorted_inode(struct stat *buf); +extern long long 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, + long long *uncompressed_file, unsigned int *uncompressed_inode, unsigned int *uncompressed_directory, + unsigned int *inode_dir_inode_number, unsigned int *inode_dir_parent_inode, + void (push_directory_entry)(char *, squashfs_inode, int, 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 +void sort_files_and_write(struct dir_info *dir); +struct file_info *duplicate(char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *file_start, long long bytes, unsigned int **block_list, long long *start, int blocks, struct fragment **fragment, char *frag_data, int frag_bytes); +struct dir_info *dir_scan1(char *, int (_readdir)(char *, char *, struct dir_info *)); #define MKINODE(A) ((squashfs_inode)(((squashfs_inode) inode_bytes << 16) + (((char *)A) - data_cache))) @@ -220,6 +276,8 @@ void restorefs() 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; @@ -239,12 +297,18 @@ void sighandler() } +void sighandler2() +{ + EXIT_MKSQUASHFS(); +} + + 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(!uncompressed && (res = compress2((unsigned char *) d, &c_byte, (unsigned char *) 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) @@ -281,7 +345,7 @@ squashfs_base_inode_header *get_inode(int req_size) SQUASHFS_METADATA_SIZE, SQUASHFS_METADATA_SIZE, noI, 0); TRACE("Inode block @ %x, size %d\n", inode_bytes, c_byte); if(!swap) - memcpy((void *) (inode_table + inode_bytes), (void *) &c_byte, sizeof(unsigned short)); + memcpy(inode_table + inode_bytes, &c_byte, sizeof(unsigned short)); else SQUASHFS_SWAP_SHORTS((&c_byte), (inode_table + inode_bytes), 1); if(check_data) @@ -311,7 +375,7 @@ failed: } -void read_bytes(int fd, unsigned int byte, int bytes, char *buff) +void read_bytes(int fd, long long byte, int bytes, char *buff) { off_t off = byte; @@ -327,13 +391,10 @@ void read_bytes(int fd, unsigned int byte, int bytes, char *buff) } -void write_bytes(int fd, unsigned int byte, int bytes, char *buff) +void write_bytes(int fd, long long 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(); @@ -346,12 +407,12 @@ void write_bytes(int fd, unsigned int byte, int bytes, char *buff) } -unsigned int write_inodes() +long long write_inodes() { unsigned short c_byte; int avail_bytes; char *datap = data_cache; - unsigned int start_bytes = bytes; + long long start_bytes = bytes; while(cache_bytes) { if(inode_size - inode_bytes < ((SQUASHFS_METADATA_SIZE << 1) + 2)) { @@ -364,7 +425,7 @@ unsigned int write_inodes() 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((void *) (inode_table + inode_bytes), (void *) &c_byte, sizeof(unsigned short)); + memcpy(inode_table + inode_bytes, &c_byte, sizeof(unsigned short)); else SQUASHFS_SWAP_SHORTS((&c_byte), (inode_table + inode_bytes), 1); if(check_data) @@ -382,12 +443,12 @@ unsigned int write_inodes() } -unsigned int write_directories() +long long write_directories() { unsigned short c_byte; int avail_bytes; char *directoryp = directory_data_cache; - unsigned int start_bytes = bytes; + long long start_bytes = bytes; while(directory_cache_bytes) { if(directory_size - directory_bytes < ((SQUASHFS_METADATA_SIZE << 1) + 2)) { @@ -401,7 +462,7 @@ unsigned int write_directories() 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((void *) (directory_table + directory_bytes), (void *) &c_byte, sizeof(unsigned short)); + memcpy(directory_table + directory_bytes, &c_byte, sizeof(unsigned short)); else SQUASHFS_SWAP_SHORTS((&c_byte), (directory_table + directory_bytes), 1); if(check_data) @@ -455,81 +516,132 @@ unsigned int get_guid(squashfs_uid uid, squashfs_uid guid) } -squashfs_inode create_inode(char *filename, int type, int byte_size, -squashfs_block start_block, unsigned int offset, unsigned int *block_list, struct fragment *fragment) +int create_inode(squashfs_inode *i_no, struct dir_ent *dir_ent, int type, long long byte_size, long long start_block, unsigned int offset, unsigned int *block_list, struct fragment *fragment, struct directory *dir_in) { - squashfs_inode i_no; - struct stat buf; + struct stat *buf = &dir_ent->inode->buf; squashfs_inode_header inode_header; squashfs_base_inode_header *inode, *base = &inode_header.base; + char *filename = dir_ent->pathname; + int nlink = dir_ent->inode->nlink; + int inode_number = (type == SQUASHFS_LDIR_TYPE || type == SQUASHFS_DIR_TYPE) ? dir_ent->inode->inode_number : dir_ent->inode->inode_number + dir_inode_no; - 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 SQUASHFS_INVALID; - } - - base->mode = SQUASHFS_MODE(buf.st_mode); - base->uid = get_uid((squashfs_uid) global_uid == -1 ? buf.st_uid : global_uid); + 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); + base->guid = get_guid((squashfs_uid) global_uid == -1 ? buf->st_uid : global_uid, (squashfs_uid) global_gid == -1 ? buf->st_gid : global_gid); + base->mtime = buf->st_mtime; + base->inode_number = inode_number; 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; + inodep = (squashfs_reg_inode_header *) inode; reg->file_size = byte_size; reg->start_block = start_block; reg->fragment = fragment->index; reg->offset = fragment->offset; if(!swap) { - memcpy((void *) inodep, (void *) reg, sizeof(*reg)); - memcpy((void *) inodep->block_list, block_list, offset * sizeof(unsigned int)); + 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, + TRACE("File inode, file_size %d, start_block %llx, blocks %d, fragment %d, offset %d, size %d\n", (int) 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_LREG_TYPE) { + int i; + squashfs_lreg_inode_header *reg = &inode_header.lreg, *inodep; + + inode = get_inode(sizeof(*reg) + offset * sizeof(unsigned int)); + inodep = (squashfs_lreg_inode_header *) inode; + reg->nlink = nlink; + 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_LREG_INODE_HEADER(reg, inodep); + SQUASHFS_SWAP_INTS(block_list, inodep->block_list, offset); + } + TRACE("Long file inode, file_size %lld, start_block %llx, blocks %d, fragment %d, offset %d, size %d, nlink %d\n", byte_size, + start_block, offset, fragment->index, fragment->offset, fragment->size, nlink); + 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; + struct cached_dir_index *index = dir_in->index; + unsigned int i_count = dir_in->i_count; + unsigned int i_size = dir_in->i_size; + + 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->nlink = dir_ent->dir->directory_count + 2; + dir->file_size = byte_size; + dir->offset = offset; + dir->start_block = start_block; + dir->i_count = i_count; + dir->parent_inode = dir_ent->our_dir ? dir_ent->our_dir->dir_ent->inode->inode_number : dir_inode_no + inode_no; + + 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 %llx, offset %x, nlink %d\n", (int) byte_size, + start_block, offset, dir_ent->dir->directory_count + 2); + } 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->nlink = dir_ent->dir->directory_count + 2; dir->file_size = byte_size; dir->offset = offset; dir->start_block = start_block; + dir->parent_inode = dir_ent->our_dir ? dir_ent->our_dir->dir_ent->inode->inode_number : dir_inode_no + inode_no; if(!swap) - memcpy((void *) inode, (void *) dir, sizeof(*dir)); + 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); + TRACE("Directory inode, file_size %d, start_block %llx, offset %x, nlink %d\n", (int) byte_size, + start_block, offset, dir_ent->dir->directory_count + 2); } 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)); + dev->nlink = nlink; + dev->rdev = (unsigned short) ((major(buf->st_rdev) << 8) | + (minor(buf->st_rdev) & 0xff)); if(!swap) - memcpy((void *) inode, (void *) dev, sizeof(*dev)); + memcpy(inode, dev, sizeof(*dev)); else SQUASHFS_SWAP_DEV_INODE_HEADER(dev, inode); - TRACE("Device inode, rdev %x\n", dev->rdev); + TRACE("Device inode, rdev %x, nlink %d\n", dev->rdev, nlink); } else if(type == SQUASHFS_SYMLINK_TYPE) { squashfs_symlink_inode_header *symlink = &inode_header.symlink, *inodep; @@ -538,61 +650,65 @@ squashfs_block start_block, unsigned int offset, unsigned int *block_list, struc if((byte = readlink(filename, buff, 65536)) == -1) { perror("Error in reading symbolic link, skipping..."); - return SQUASHFS_INVALID; + return FALSE; } if(byte == 65536) { ERROR("Symlink is greater than 65536 bytes! skipping..."); - return SQUASHFS_INVALID; + return FALSE; } inode = get_inode(sizeof(*symlink) + byte); - inodep = (squashfs_symlink_inode_header *) inode ; + symlink->nlink = nlink; + inodep = (squashfs_symlink_inode_header *) inode; symlink->symlink_size = byte; if(!swap) - memcpy((void *) inode, symlink, sizeof(*symlink)); + 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); + TRACE("Symbolic link inode, symlink_size %d, nlink %d\n", byte, nlink); } else if(type == SQUASHFS_FIFO_TYPE || type == SQUASHFS_SOCKET_TYPE) { squashfs_ipc_inode_header *ipc = &inode_header.ipc; inode = get_inode(sizeof(*ipc)); + ipc->nlink = nlink; if(!swap) - memcpy((void *) inode, (void *) ipc, sizeof(*ipc)); + 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"); + TRACE("ipc inode, type %s, nlink %d\n", type == SQUASHFS_FIFO_TYPE ? "fifo" : "socket", nlink); } else - return SQUASHFS_INVALID; + return FALSE; - i_no = MKINODE(inode); + *i_no = MKINODE(inode); inode_count ++; - TRACE("Created inode 0x%Lx, type %d, uid %d, guid %d\n", i_no, type, base->uid, base->guid); + TRACE("Created inode 0x%llx, type %d, uid %d, guid %d\n", *i_no, type, base->uid, base->guid); - return i_no; + return TRUE; } -void init_dir(struct directory *dir) +void scan2_init_dir(struct directory *dir) { - if((dir->buff = (char *)malloc(SQUASHFS_METADATA_SIZE)) == NULL) { + if((dir->buff = malloc(SQUASHFS_METADATA_SIZE)) == NULL) { BAD_ERROR("Out of memory allocating directory buffer\n"); } dir->size = SQUASHFS_METADATA_SIZE; - dir->p = dir->buff; + dir->p = dir->index_count_p = dir->buff; dir->entry_count = 256; dir->entry_count_p = NULL; + dir->index = NULL; + dir->i_count = dir->i_size = 0; } -void add_dir(squashfs_inode inode, char *name, int type, struct directory *dir) +void add_dir(squashfs_inode inode, unsigned int inode_number, char *name, int type, struct directory *dir) { - char *buff; + unsigned char *buff; squashfs_dir_entry idir, *idirp; unsigned int start_block = inode >> 16; unsigned int offset = inode & 0xffff; @@ -603,33 +719,48 @@ void add_dir(squashfs_inode inode, char *name, int type, struct directory *dir) 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) { + if(dir->p + sizeof(squashfs_dir_entry) + size + sizeof(squashfs_dir_header) >= dir->buff + dir->size) { + if((buff = 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 = (squashfs_dir_header *) (((unsigned char *) dir->entry_count_p) - - dir->buff + buff); + 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) { + 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)) || ((long long) inode_number - dir->inode_number) > 32767 || ((long long) inode_number - dir->inode_number) < - 32768) { 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; + dir_header.inode_number = dir->inode_number; if(!swap) - memcpy((void *) dir->entry_count_p, (void *) &dir_header, sizeof(dir_header)); + memcpy(dir->entry_count_p, &dir_header, sizeof(dir_header)); else - SQUASHFS_SWAP_DIR_HEADER((&dir_header), dir->entry_count_p); + SQUASHFS_SWAP_DIR_HEADER((&dir_header), (squashfs_dir_header *) dir->entry_count_p); + } - dir->entry_count_p = (squashfs_dir_header *) dir->p; + + dir->entry_count_p = dir->p; dir->start_block = start_block; dir->entry_count = 0; + dir->inode_number = inode_number; dir->p += sizeof(squashfs_dir_header); } @@ -637,8 +768,9 @@ void add_dir(squashfs_inode inode, char *name, int type, struct directory *dir) idir.offset = offset; idir.type = type; idir.size = size - 1; + idir.inode_number = ((long long) inode_number - dir->inode_number); if(!swap) - memcpy((void *) idirp, (void *) &idir, sizeof(idir)); + memcpy(idirp, &idir, sizeof(idir)); else SQUASHFS_SWAP_DIR_ENTRY((&idir), idirp); strncpy(idirp->name, name, size); @@ -647,14 +779,48 @@ void add_dir(squashfs_inode inode, char *name, int type, struct directory *dir) } -squashfs_inode write_dir(char *filename, struct directory *dir) +int write_dir(squashfs_inode *inode, struct dir_info *dir_info, struct directory *dir) { - squashfs_inode inode; - unsigned int dir_size; - int data_space; + 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; - while(directory_cache_bytes >= SQUASHFS_METADATA_SIZE) { + 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; + dir_header.inode_number = dir->inode_number; + 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) { @@ -667,7 +833,7 @@ squashfs_inode write_dir(char *filename, struct directory *dir) SQUASHFS_METADATA_SIZE, SQUASHFS_METADATA_SIZE, noI, 0); TRACE("Directory block @ %x, size %d\n", directory_bytes, c_byte); if(!swap) - memcpy((void *) directory_table + directory_bytes, (void *) &c_byte, sizeof(unsigned short)); + memcpy(directory_table + directory_bytes, &c_byte, sizeof(unsigned short)); else SQUASHFS_SWAP_SHORTS((&c_byte), (directory_table + directory_bytes), 1); if(check_data) @@ -678,39 +844,20 @@ squashfs_inode write_dir(char *filename, struct directory *dir) directory_cache_bytes -= SQUASHFS_METADATA_SIZE; } - dir_size = dir->p - dir->buff; - data_space = (directory_cache_size - directory_cache_bytes); - 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((void *) dir->entry_count_p, (void *) &dir_header, sizeof(dir_header)); - else - SQUASHFS_SWAP_DIR_HEADER((&dir_header), dir->entry_count_p); - memcpy(directory_data_cache + directory_cache_bytes, dir->buff, dir_size); + if(dir_info->dir_is_ldir) { + if(create_inode(inode, dir_info->dir_ent, SQUASHFS_LDIR_TYPE, dir_size + 3, directory_block, directory_offset, NULL, NULL, dir) == FALSE) + return FALSE; + } else { + if(create_inode(inode, dir_info->dir_ent, SQUASHFS_DIR_TYPE, dir_size + 3, directory_block, directory_offset, NULL, NULL, NULL) == FALSE) + return FALSE; } - inode = create_inode(filename, SQUASHFS_DIR_TYPE, dir_size, directory_bytes, directory_cache_bytes, NULL, NULL); - - directory_cache_bytes += dir_size; - #ifdef SQUASHFS_TRACE if(!swap) { unsigned char *dirp; int count; - TRACE("Directory contents of inode 0x%Lx\n", inode); + TRACE("Directory contents of inode 0x%llx\n", *inode); dirp = dir->buff; while(dirp < dir->p) { char buffer[SQUASHFS_NAME_LEN + 1]; @@ -735,7 +882,7 @@ squashfs_inode write_dir(char *filename, struct directory *dir) #endif dir_count ++; - return inode; + return TRUE; failed: BAD_ERROR("Out of memory in directory table reallocation!\n"); @@ -744,37 +891,35 @@ failed: char *get_fragment(char *buffer, struct fragment *fragment) { - if(fragment->index == fragments || fragment->index == SQUASHFS_INVALID_BLK) - return fragment_data + fragment->offset; - else { - squashfs_fragment_entry *disk_fragment = &fragment_table[fragment->index]; - int size = SQUASHFS_COMPRESSED_SIZE_BLOCK(disk_fragment->size), res; - long bytes = block_size; - - if(SQUASHFS_COMPRESSED_BLOCK(disk_fragment->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; - } + 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; + unsigned long bytes = block_size; + char cbuffer[block_size]; + + read_bytes(fd, disk_fragment->start_block, size, cbuffer); + + if((res = uncompress((unsigned char *) buffer, &bytes, (const unsigned 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]; + char buffer[block_size << 1]; if(fragment_size == 0) return; @@ -795,7 +940,7 @@ void write_fragment() } -static struct fragment empty_fragment = {SQUASHFS_INVALID_BLK, 0, 0}; +static struct fragment empty_fragment = {SQUASHFS_INVALID_FRAG, 0, 0}; struct fragment *get_and_fill_fragment(char *buff, int size) { struct fragment *ffrg; @@ -819,9 +964,10 @@ struct fragment *get_and_fill_fragment(char *buff, int size) } -unsigned int write_fragment_table() +long long write_fragment_table() { - unsigned int start_bytes, frag_bytes = SQUASHFS_FRAGMENT_BYTES(fragments), + long long start_bytes; + unsigned int 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; @@ -831,9 +977,9 @@ unsigned int write_fragment_table() 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); + TRACE("write_fragment_table: fragment %d, start_block %llx, size %d\n", i, fragment_table[i].start_block, fragment_table[i].size); if(!swap) - memcpy((void *) p, &fragment_table[i], sizeof(squashfs_fragment_entry)); + memcpy(p, &fragment_table[i], sizeof(squashfs_fragment_entry)); else SQUASHFS_SWAP_FRAGMENT_ENTRY(&fragment_table[i], p); } @@ -842,7 +988,7 @@ unsigned int write_fragment_table() 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((void *) cbuffer, (void *) &c_byte, sizeof(unsigned short)); + memcpy(cbuffer, &c_byte, sizeof(unsigned short)); else SQUASHFS_SWAP_SHORTS((&c_byte), cbuffer, 1); if(check_data) @@ -868,16 +1014,16 @@ unsigned int write_fragment_table() } -unsigned char *read_from_buffer(struct duplicate_buffer_handle *handle, unsigned int avail_bytes) +char *read_from_buffer(struct duplicate_buffer_handle *handle, unsigned int avail_bytes) { - unsigned char *v = handle->ptr; + 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) +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; @@ -888,7 +1034,7 @@ unsigned char *read_from_file(struct duplicate_buffer_handle *handle, unsigned i /* * 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 get_checksum(char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *handle, long long l) { unsigned short chksum = 0; unsigned int bytes = 0; @@ -898,7 +1044,7 @@ unsigned short get_checksum(unsigned char *(get_next_file_block)(struct duplicat while(l) { bytes = l > SQUASHFS_FILE_MAX_SIZE ? SQUASHFS_FILE_MAX_SIZE : l; l -= bytes; - b = get_next_file_block(&position, bytes); + b = (unsigned char *) get_next_file_block(&position, bytes); while(bytes--) { chksum = (chksum & 1) ? (chksum >> 1) | 0x8000 : chksum >> 1; chksum += *b++; @@ -909,14 +1055,15 @@ unsigned short get_checksum(unsigned char *(get_next_file_block)(struct duplicat } -static unsigned 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) +int cached_frag = -1; +void add_file(long long start, long long 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; - + unsigned int *block_list = block_listp; + if(!duplicate_checking) return; @@ -926,18 +1073,23 @@ void add_file(int start, int file_bytes, unsigned int *block_listp, int blocks, frg->index = fragment; frg->offset = offset; frg->size = bytes; - if(cached_frag == fragment) + if(fragment == cached_frag || fragment == SQUASHFS_INVALID_FRAG) 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; + else + free(block_list); cached_frag = fragment; } -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) +char cached_fragment[SQUASHFS_FILE_SIZE]; +int cached_frag1 = -1; + +struct file_info *duplicate(char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *file_start, long long bytes, unsigned int **block_list, long long *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 }; @@ -947,10 +1099,11 @@ struct file_info *duplicate(unsigned char *(get_next_file_block)(struct duplicat 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; + char buffer1[SQUASHFS_FILE_MAX_SIZE]; + long long dup_bytes = dupl_ptr->bytes; + long long dup_start = dupl_ptr->start; struct duplicate_buffer_handle position = *file_start; - unsigned char *buffer; + char *buffer; while(dup_bytes) { int avail_bytes = dup_bytes > SQUASHFS_FILE_MAX_SIZE ? SQUASHFS_FILE_MAX_SIZE : dup_bytes; @@ -962,10 +1115,19 @@ struct file_info *duplicate(unsigned char *(get_next_file_block)(struct duplicat dup_start += avail_bytes; } if(dup_bytes == 0) { - char frag_buffer1[block_size]; - char *fragment_buffer1 = get_fragment(frag_buffer1, dupl_ptr->fragment); + char *fragment_buffer1; + + if(dupl_ptr->fragment->index == fragments || dupl_ptr->fragment->index == SQUASHFS_INVALID_FRAG) + 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, + TRACE("Found duplicate file, start 0x%llx, size %lld, 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; @@ -984,11 +1146,8 @@ struct file_info *duplicate(unsigned char *(get_next_file_block)(struct duplicat 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)); + dupl_ptr->block_list = *block_list; + dup_files ++; if(bytes) { dupl_ptr->next = dupl[checksum]; @@ -1003,18 +1162,22 @@ struct file_info *duplicate(unsigned char *(get_next_file_block)(struct duplicat #define MINALLOCBYTES (1024 * 1024) -squashfs_inode write_file(char *filename, long long size, int *duplicate_file) +int write_file(squashfs_inode *inode, struct dir_ent *dir_ent, 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; + int block = 0, i, file, whole_file = 1, status; + unsigned int c_byte, frag_bytes; + long long bbytes, file_bytes = 0, start; + char buff[block_size], *c_buffer = NULL, *filename = dir_ent->pathname; struct fragment *fragment; - struct file_info *dupl_ptr; + struct file_info *dupl_ptr = NULL; struct duplicate_buffer_handle handle; + long long read_size = (size > SQUASHFS_MAX_FILE_SIZE) ? SQUASHFS_MAX_FILE_SIZE : size; + int blocks = (read_size + block_size - 1) >> block_log, allocated_blocks = blocks; + unsigned int *block_list, *block_listp; + + if((block_list = malloc(blocks * sizeof(unsigned int))) == NULL) + BAD_ERROR("Out of memory allocating block_list\n"); + block_listp = block_list; if(!no_fragments && (read_size < block_size || always_use_fragments)) { allocated_blocks = blocks = read_size >> block_log; @@ -1023,20 +1186,19 @@ squashfs_inode write_file(char *filename, long long size, int *duplicate_file) frag_bytes = 0; if(size > read_size) - ERROR("file %s truncated to %Ld bytes\n", filename, SQUASHFS_MAX_FILE_SIZE); + ERROR("file %s truncated to %lld 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 SQUASHFS_INVALID; - } + if((file = open(filename, O_RDONLY)) == -1) + goto read_err; 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); + long long bytes = (((long long) allocated_blocks) + 1) << block_log; + if(bytes != ((size_t) bytes) || (c_buffer = (char *) malloc(bytes)) == NULL) { + TRACE("Out of memory allocating write_file buffer, allocated_blocks %ld, 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)); + if(bytes < MINALLOCBYTES) + BAD_ERROR("Out of memory allocating write_file buffer, could not allocate %ld blocks (%d Kbytes)\n", allocated_blocks, allocated_blocks << (block_log - 10)); allocated_blocks >>= 1; } } while(!c_buffer); @@ -1089,54 +1251,19 @@ squashfs_inode write_file(char *filename, long long size, int *duplicate_file) wr_inode: free(c_buffer); file_count ++; - return create_inode(filename, SQUASHFS_FILE_TYPE, read_size, start, blocks, block_listp, fragment); + if(dir_ent->inode->nlink == 1 && read_size < ((long long) (1<<30) - 1)) + status = create_inode(inode, dir_ent, SQUASHFS_FILE_TYPE, read_size, start, blocks, block_listp, fragment, NULL); + else + status = create_inode(inode, dir_ent, SQUASHFS_LREG_TYPE, read_size, start, blocks, block_listp, fragment, NULL); + if(duplicate_checking == FALSE || *duplicate_file == TRUE) + free(block_list); + return status; read_err: perror("Error in reading file, skipping..."); free(c_buffer); - return SQUASHFS_INVALID; -} - - -struct linuxdir { - DIR *linuxdir; - char pathname[8192]; -}; - - -void *linux_opendir(char *pathname, struct directory *dir) -{ - struct linuxdir *linuxdir; - if((linuxdir = malloc(sizeof(struct linuxdir))) == NULL) - return NULL; - if((linuxdir->linuxdir = opendir(pathname)) == NULL) { - free(linuxdir); - return NULL; - } - strcpy(linuxdir->pathname, pathname); - return (void *) linuxdir; -} - - -int linux_readdir(void *l, char *filename, char *dir_name) -{ - struct dirent *d_name; - struct linuxdir *linuxdir = (struct linuxdir *)l; - - do { - if((d_name = readdir(linuxdir->linuxdir)) == NULL) - return FALSE; - } while(strcmp(d_name->d_name, ".") == 0 || strcmp(d_name->d_name, "..") == 0); - strcat(strcat(strcpy(filename, linuxdir->pathname), "/"), d_name->d_name); - strcpy(dir_name, d_name->d_name); - return TRUE; -} - - -void linux_closedir(void *linuxdir) -{ - closedir(((struct linuxdir *)linuxdir)->linuxdir); - free(linuxdir); + free(block_list); + return FALSE; } @@ -1189,100 +1316,265 @@ char *basename_r() } -char encomp_pathname[8192]; -int encomp_entry = 0; +struct inode_info *lookup_inode(struct stat *buf) +{ + int inode_hash = INODE_HASH(buf->st_dev, buf->st_ino); + struct inode_info *inode = inode_info[inode_hash]; + + while(inode != NULL) { + if(memcmp(buf, &inode->buf, sizeof(struct stat)) == 0) { + inode->nlink ++; + return inode; + } + inode = inode->next; + } + + if((inode = malloc(sizeof(struct inode_info))) == NULL) + BAD_ERROR("Out of memory in inode hash table entry allocation\n"); + + memcpy(&inode->buf, buf, sizeof(struct stat)); + inode->inode = SQUASHFS_INVALID_BLK; + inode->nlink = 1; + if((buf->st_mode & S_IFMT) == S_IFDIR) + inode->inode_number = dir_inode_no ++; + else + inode->inode_number = inode_no ++; + + inode->next = inode_info[inode_hash]; + inode_info[inode_hash] = inode; + + return inode; +} + + +inline void add_dir_entry(char *name, char *pathname, struct dir_info *sub_dir, struct inode_info *inode_info, void *data, struct dir_info *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"); + + if(sub_dir) + sub_dir->dir_ent = dir->list[dir->count]; + dir->list[dir->count]->name = strdup(name); + dir->list[dir->count]->pathname = pathname != NULL ? strdup(pathname) : NULL; + dir->list[dir->count]->inode = inode_info; + dir->list[dir->count]->dir = sub_dir; + dir->list[dir->count]->our_dir = dir; + dir->list[dir->count++]->data = data; + dir->byte_count += strlen(name) + sizeof(squashfs_dir_entry); +} + -void *encomp_opendir(char *pathname, struct directory *dir) +int compare_name(const void *ent1_ptr, const void *ent2_ptr) { - int i; + 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 dir_info *dir) +{ + qsort(dir->list, dir->count, sizeof(struct dir_ent *), compare_name); + + if((dir->count < 257 && dir->byte_count < SQUASHFS_METADATA_SIZE)) + dir->dir_is_ldir = FALSE; +} + + +struct dir_info *scan1_opendir(char *pathname) +{ + DIR *linuxdir; + struct dirent *d_name; + struct dir_info *dir; - for(i = 0; i < old_root_entries; i++) - add_dir(old_root_entry[i].inode, old_root_entry[i].name, old_root_entry[i].type, dir); + if((dir = malloc(sizeof(struct dir_info))) == NULL) + return NULL; + + if(pathname[0] != '\0' && (dir->linuxdir = opendir(pathname)) == NULL) { + free(dir); + return NULL; + } + dir->pathname = strdup(pathname); + dir->count = dir->directory_count = dir->current_count = dir->byte_count = 0; + dir->dir_is_ldir = TRUE; + dir->list = NULL; - return (void *)source_path; + return dir; } -int encomp_readdir(void *l, char *filename, char *dir_name) +int scan1_encomp_readdir(char *pathname, char *dir_name, struct dir_info *dir) { + int i, n, pass; char *basename; - int n, pass = 1; + static int index = 0; + + if(dir->count < old_root_entries) + for(i = 0; i < old_root_entries; i++) { + if(old_root_entry[i].type == SQUASHFS_DIR_TYPE) + dir->directory_count ++; + add_dir_entry(old_root_entry[i].name, "", NULL, NULL, &old_root_entry[i], dir); + } - while(encomp_entry < source) { - if((basename = getbase(source_path[encomp_entry])) == NULL) { - ERROR("Bad source directory %s - skipping ...\n", source_path[encomp_entry]); - encomp_entry++; + while(index < source) { + if((basename = getbase(source_path[index])) == NULL) { + ERROR("Bad source directory %s - skipping ...\n", source_path[index]); + index ++; continue; } - strcpy(filename, source_path[encomp_entry]); strcpy(dir_name, basename); + pass = 1; for(;;) { - for(n = 0; n < old_root_entries && strcmp(old_root_entry[n].name, dir_name) != 0; n++); - if(n == old_root_entries) { - add_old_root_entry(dir_name, 0, 0); - encomp_entry++; - return TRUE; - } + 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); } + strcpy(pathname, source_path[index ++]); + return 1; } - return FALSE; + return 0; +} + + +int scan1_single_readdir(char *pathname, char *dir_name, struct dir_info *dir) +{ + struct dirent *d_name; + int i, pass; + + if(dir->count < old_root_entries) + for(i = 0; i < old_root_entries; i++) { + if(old_root_entry[i].type == SQUASHFS_DIR_TYPE) + dir->directory_count ++; + add_dir_entry(old_root_entry[i].name, "", NULL, NULL, &old_root_entry[i], dir); + } + + if((d_name = readdir(dir->linuxdir)) != NULL) { + 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(pathname, dir->pathname), "/"), d_name->d_name); + return 1; + } + + return 0; } -void encomp_closedir(void *linuxdir) +int scan1_readdir(char *pathname, char *dir_name, struct dir_info *dir) { + struct dirent *d_name; + + if((d_name = readdir(dir->linuxdir)) != NULL) { + strcpy(dir_name, d_name->d_name); + strcat(strcat(strcpy(pathname, dir->pathname), "/"), d_name->d_name); + return 1; + } + + return 0; } -void *single_opendir(char *pathname, struct directory *dir) +struct dir_ent *scan2_readdir(struct directory *dir, struct dir_info *dir_info) { - encomp_opendir(pathname, dir); - return linux_opendir(pathname, dir); + int current_count; + + while((current_count = dir_info->current_count++) < dir_info->count) + if(dir_info->list[current_count]->data) + add_dir(dir_info->list[current_count]->data->inode, dir_info->list[current_count]->data->inode_number, + dir_info->list[current_count]->name, dir_info->list[current_count]->data->type, dir); + else + return dir_info->list[current_count]; + return FALSE; } -int single_readdir(void *l, char *filename, char *dir_name) +void scan1_freedir(struct dir_info *dir) { - int i, pass = 1; - char name[SQUASHFS_NAME_LEN + 1]; + if(dir->pathname[0] != '\0') + closedir(dir->linuxdir); +} - if(linux_readdir(l, filename, dir_name) == FALSE) - return FALSE; - strcpy(name, dir_name); - for(;;) { - for(i = 0; i < old_root_entries && strcmp(old_root_entry[i].name, dir_name) != 0; i++); - if(i == old_root_entries) { - add_old_root_entry(dir_name, 0, 0); - return TRUE; - } - ERROR("Source directory entry %s already used! - trying ", dir_name); - sprintf(dir_name, "%s_%d", name, pass++); - ERROR("%s\n", dir_name); +void scan2_freedir(struct directory *dir) +{ + if(dir->index) + free(dir->index); + free(dir->buff); +} + + +void dir_scan(squashfs_inode *inode, char *pathname, int (_readdir)(char *, char *, struct dir_info *)) +{ + struct dir_info *dir_info = dir_scan1(pathname, _readdir); + struct dir_ent *dir_ent; + struct inode_info *inode_info; + + if(dir_info == NULL) + return; + + if((dir_ent = malloc(sizeof(struct dir_ent))) == NULL) + BAD_ERROR("Out of memory in dir_scan\n"); + + if((inode_info = malloc(sizeof(struct inode_info))) == NULL) + BAD_ERROR("Out of memory in dir_scan\n"); + + dir_ent->name = dir_ent->pathname = strdup(pathname); + dir_ent->dir = dir_info; + dir_ent->inode = inode_info; + dir_ent->our_dir = NULL; + dir_ent->data = NULL; + inode_info->nlink = 1; + inode_info->inode_number = root_inode_number ? root_inode_number : dir_inode_no++; + dir_info->dir_ent = dir_ent; + + if(pathname[0] == '\0') { + /* dummy top level directory, if multiple sources specified on command line */ + inode_info->buf.st_mode = S_IRWXU | S_IRWXG | S_IRWXO; + inode_info->buf.st_uid = getuid(); + inode_info->buf.st_gid = getgid(); + inode_info->buf.st_mtime = time(NULL); + } else if(lstat(pathname, &inode_info->buf) == -1) { + char buffer[8192]; + sprintf(buffer, "Cannot stat dir/file %s, ignoring", pathname); + perror(buffer); + return; } + if(sorted) + sort_files_and_write(dir_info); + dir_scan2(inode, dir_info); } -squashfs_inode dir_scan(char *pathname, void* (_opendir)(char *, struct directory *), int (_readdir)(void *, char *, char *), - void (_closedir)(void *)) +struct dir_info *dir_scan1(char *pathname, int (_readdir)(char *, char *, struct dir_info *)) { - void *linuxdir; + struct dir_info *dir, *sub_dir; struct stat buf; char filename[8192], dir_name[8192]; - int squashfs_type; - squashfs_inode inode = SQUASHFS_INVALID; - struct directory dir; - - init_dir(&dir); - if((linuxdir = _opendir(pathname, &dir)) == NULL) { + + if((dir = scan1_opendir(pathname)) == NULL) { ERROR("Could not open %s, skipping...\n", pathname); goto error; } - - while(_readdir(linuxdir, filename, dir_name) != FALSE) { + + while(_readdir(filename, dir_name, dir) != FALSE) { + + if(strcmp(dir_name, ".") == 0 || strcmp(dir_name, "..") == 0) + continue; if(lstat(filename, &buf) == -1) { char buffer[8192]; @@ -1293,75 +1585,135 @@ squashfs_inode dir_scan(char *pathname, void* (_opendir)(char *, struct director if(excluded(filename, &buf)) continue; - switch(buf.st_mode & S_IFMT) { - case S_IFREG: { - int duplicate_file; + if((buf.st_mode & S_IFMT) == S_IFDIR) { + if((sub_dir = dir_scan1(filename, scan1_readdir)) == NULL) + continue; + dir->directory_count ++; + } else + sub_dir = NULL; - squashfs_type = SQUASHFS_FILE_TYPE; - if(!sorted) { - inode = write_file(filename, buf.st_size, &duplicate_file); - INFO("file %s, uncompressed size %Ld bytes, %s\n", filename, buf.st_size, duplicate_file ? "DUPLICATE" : ""); - } else - inode = get_sorted_inode(&buf); - break; - } - case S_IFDIR: - squashfs_type = SQUASHFS_DIR_TYPE; - inode = dir_scan(filename, linux_opendir, linux_readdir, linux_closedir); - break; + add_dir_entry(dir_name, filename, sub_dir, lookup_inode(&buf), NULL, dir); + } - case S_IFLNK: - squashfs_type = SQUASHFS_SYMLINK_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("symbolic link %s inode 0x%Lx\n", dir_name, inode); - sym_count ++; - break; + scan1_freedir(dir); + sort_directory(dir); - case S_IFCHR: - squashfs_type = SQUASHFS_CHRDEV_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("character device %s inode 0x%Lx\n", dir_name, inode); - dev_count ++; - break; +error: + return dir; +} - case S_IFBLK: - squashfs_type = SQUASHFS_BLKDEV_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("block device %s inode 0x%Lx\n", dir_name, inode); - dev_count ++; - break; - case S_IFIFO: - squashfs_type = SQUASHFS_FIFO_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("fifo %s inode 0x%Lx\n", dir_name, inode); - fifo_count ++; - break; +int dir_scan2(squashfs_inode *inode, struct dir_info *dir_info) +{ + int squashfs_type; + int result = FALSE; + int duplicate_file; + char *pathname = dir_info->pathname; + struct directory dir; + struct dir_ent *dir_ent; + + scan2_init_dir(&dir); + + while((dir_ent = scan2_readdir(&dir, dir_info)) != NULL) { + struct inode_info *inode_info = dir_ent->inode; + struct stat *buf = &inode_info->buf; + char *filename = dir_ent->pathname; + char *dir_name = dir_ent->name; + unsigned int inode_number = ((buf->st_mode & S_IFMT) == S_IFDIR) ? dir_ent->inode->inode_number : dir_ent->inode->inode_number + dir_inode_no; + + if(dir_ent->inode->inode == SQUASHFS_INVALID_BLK) { + switch(buf->st_mode & S_IFMT) { + case S_IFREG: + squashfs_type = SQUASHFS_FILE_TYPE; + result = write_file(inode, dir_ent, buf->st_size, &duplicate_file); + INFO("file %s, uncompressed size %lld bytes %s\n", filename, buf->st_size, duplicate_file ? "DUPLICATE" : ""); + break; - case S_IFSOCK: - squashfs_type = SQUASHFS_SOCKET_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("unix domain socket %s inode 0x%Lx\n", dir_name, inode); - sock_count ++; - break; + case S_IFDIR: + squashfs_type = SQUASHFS_DIR_TYPE; + result = dir_scan2(inode, dir_ent->dir); + break; - default: - ERROR("%s unrecognised file type, mode is %x\n", filename, buf.st_mode); - continue; + case S_IFLNK: + squashfs_type = SQUASHFS_SYMLINK_TYPE; + result = create_inode(inode, dir_ent, squashfs_type, 0, 0, 0, NULL, NULL, NULL); + 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, dir_ent, squashfs_type, 0, 0, 0, NULL, NULL, NULL); + 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, dir_ent, squashfs_type, 0, 0, 0, NULL, NULL, NULL); + 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, dir_ent, squashfs_type, 0, 0, 0, NULL, NULL, NULL); + 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, dir_ent, squashfs_type, 0, 0, 0, NULL, NULL, NULL); + 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) + dir_ent->inode->inode = *inode; + dir_ent->inode->type = squashfs_type; + } else { + *inode = dir_ent->inode->inode; + squashfs_type = dir_ent->inode->type; + switch(squashfs_type) { + case SQUASHFS_FILE_TYPE: + if(!sorted) + INFO("file %s, uncompressed size %lld bytes LINK\n", filename, buf->st_size); + break; + case SQUASHFS_SYMLINK_TYPE: + INFO("symbolic link %s inode 0x%llx LINK\n", dir_name, *inode); + break; + case SQUASHFS_CHRDEV_TYPE: + INFO("character device %s inode 0x%llx LINK\n", dir_name, *inode); + break; + caseSQUASHFS_BLKDEV_TYPE: + INFO("block device %s inode 0x%llx LINK\n", dir_name, *inode); + break; + case SQUASHFS_FIFO_TYPE: + INFO("fifo %s inode 0x%llx LINK\n", dir_name, *inode); + break; + case SQUASHFS_SOCKET_TYPE: + INFO("unix domain socket %s inode 0x%llx LINK\n", dir_name, *inode); + break; } + result = TRUE; + } + - if(inode != SQUASHFS_INVALID) - add_dir(inode, dir_name, squashfs_type, &dir); + if(result) + add_dir(*inode, inode_number, dir_name, squashfs_type, &dir); } - _closedir(linuxdir); - inode = write_dir(pathname, &dir); - INFO("directory %s inode 0x%Lx\n", pathname, inode); + result = write_dir(inode, dir_info, &dir); + INFO("directory %s inode 0x%llx\n", pathname, *inode); -error: - free(dir.buff); + scan2_freedir(&dir); - return inode; + return result; } @@ -1369,7 +1721,7 @@ unsigned int slog(unsigned int block) { int i; - for(i = 9; i <= 16; i++) + for(i = 12; i <= 16; i++) if(block == (1 << i)) return i; return 0; @@ -1425,7 +1777,7 @@ int add_exclude(char *path) } -void add_old_root_entry(char *name, squashfs_inode inode, int type) +void add_old_root_entry(char *name, squashfs_inode inode, int inode_number, 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) @@ -1433,13 +1785,14 @@ void add_old_root_entry(char *name, squashfs_inode inode, int type) strcpy(old_root_entry[old_root_entries].name, name); old_root_entry[old_root_entries].inode = inode; + old_root_entry[old_root_entries].inode_number = inode_number; old_root_entry[old_root_entries++].type = type; } #define VERSION() \ - printf("mksquashfs version 2.0\n");\ - printf("copyright (C) 2004 Phillip Lougher (plougher@users.sourceforge.net)\n\n"); \ + printf("mksquashfs version 3.0 (2006/03/15)\n");\ + printf("copyright (C) 2006 Phillip Lougher \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");\ @@ -1450,11 +1803,12 @@ void add_old_root_entry(char *name, squashfs_inode inode, int type) printf("GNU General Public License for more details.\n"); int main(int argc, char *argv[]) { - struct stat buf; + struct stat buf, source_buf; int i; squashfs_super_block sBlk; char *b, *root_name = NULL; - int be, nopad = FALSE, delete = FALSE, keep_as_directory = FALSE, orig_be; + int be, nopad = FALSE, keep_as_directory = FALSE, orig_be; + squashfs_inode inode; #if __BYTE_ORDER == __BIG_ENDIAN be = TRUE; @@ -1480,7 +1834,7 @@ int main(int argc, char *argv[]) } if((block_log = slog(block_size)) == 0) { - ERROR("%s: -b block size not power of two or not between 512 and 64K\n", argv[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) { @@ -1591,40 +1945,51 @@ int main(int argc, char *argv[]) } else { ERROR("%s: invalid option\n\n", argv[0]); printOptions: - ERROR("SYNTAX:%s source1 source2 ... dest [options] [-e list of exclude dirs/files]\n", argv[0]); + ERROR("SYNTAX:%s source1 source2 ... dest [options] [-e list of exclude\ndirs/files]\n", argv[0]); ERROR("\nOptions are\n"); - ERROR("\t-info\t\t\t\tprint files written to filesystem\n"); - ERROR("\t-sort sort file\t\t\tsort files according to priorities in sort file. One file or dir\n"); - ERROR("\t\t\t\t\twith priority per line. Priority -32768 to 32767, default priority 0\n"); - ERROR("\t-b block size\t\t\tsize of blocks in "); - ERROR("filesystem, default %d\n", SQUASHFS_FILE_SIZE); - ERROR("\t-noappend\t\t\tDo not append to existing filesystem on dest, write a new filesystem\n"); - ERROR("\t\t\t\t\tThis is the default action if dest does not exist, or if no filesystem is on it\n"); - ERROR("\t-keep-as-directory\t\tIf one source directory is specified, create a root directory\n"); - ERROR("\t\t\t\t\tcontaining that directory, rather than the contents of the directory\n"); - ERROR("\t-root-becomes name\t\tWhen appending source files/directories, make the original\n"); - ERROR("\t\t\t\t\troot become a subdirectory in the new root called name, rather\n"); - ERROR("\t\t\t\t\tthan adding the new source items to the original root\n"); - ERROR("\t-noI -noInodeCompression\tdo not compress inode table\n"); - ERROR("\t-noD -noDataCompression\t\tdo not compress data blocks\n"); - ERROR("\t-noF -noFragmentCompression\tdo not compress fragment blocks\n"); - ERROR("\t-no-duplicates\t\t\tdo not perform duplicate checking\n"); - ERROR("\t-no-fragments\t\t\tdo not use fragments\n"); - ERROR("\t-always-use-fragments\t\tuse fragment blocks for files larger than block size\n"); - ERROR("\t-nopad\t\t\t\tdo not pad filesystem to a multiple of 4K\n"); - ERROR("\t-check_data\t\t\tadd checkdata for greater filesystem checks\n"); - ERROR("\t-le\t\t\t\tcreate a little endian filesystem\n"); - ERROR("\t-be\t\t\t\tcreate a big endian filesystem\n"); - ERROR("\t-ef exclude file\t\tfile is a list of exclude dirs/files - one per line\n"); - ERROR("\t-all-root\t\t\toverride file uid/gid and make all file uid/gids owned by root\n"); - ERROR("\t-root-owned\t\t\talternative name for -all-root\n"); - ERROR("\t-force-uid uid\t\t\tset all file uids to uid\n"); - ERROR("\t-force-gid gid\t\t\tset all file gids to gid\n"); - ERROR("\t-version\t\t\tprint version, licence and copyright message\n"); + ERROR("-version\t\tprint version, licence and copyright message\n"); + ERROR("-info\t\t\tprint files written to filesystem\n"); + ERROR("-b \t\tset data block to . Default %d bytes\n", SQUASHFS_FILE_SIZE); + 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 \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 , 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 \tsort files according to priorities in . 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 \tlist of exclude dirs/files. One per line\n"); exit(1); } } + for(i = 0; i < source; i++) + if(stat(source_path[i], &source_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) { @@ -1656,19 +2021,16 @@ printOptions: exit(1); } - if(!delete) { - if(read_super(fd, &sBlk, &orig_be, argv[source + 1]) == 0) { - if(S_ISREG(buf.st_mode)) { /* reopen truncating file */ - close(fd); - if((fd = open(argv[source + 1], O_TRUNC | O_RDWR)) == -1) { - perror("Could not open regular file for writing as destination"); - exit(1); - } - } - delete = TRUE; - } + } + 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(); } + } else { + signal(SIGTERM, sighandler2); + signal(SIGINT, sighandler2); } /* process the exclude files - must be done afer destination file has been possibly created */ @@ -1678,7 +2040,7 @@ printOptions: char filename[16385]; if((fd = fopen(argv[++i], "r")) == NULL) { perror("Could not open exclude file..."); - exit(1); + EXIT_MKSQUASHFS(); } while(fscanf(fd, "%16384[^\n]\n", filename) != EOF) add_exclude(filename); @@ -1691,7 +2053,7 @@ printOptions: if(i != argc) { if(++i == argc) { ERROR("%s: -e missing arguments\n", argv[0]); - exit(1); + EXIT_MKSQUASHFS(); } while(i < argc && add_exclude(argv[i++])); } @@ -1706,14 +2068,17 @@ printOptions: else if(strcmp(argv[i], "-b") == 0 || strcmp(argv[i], "-root-becomes") == 0 || strcmp(argv[i], "-ef") == 0) i++; - if((fragment_data = (char *) malloc(block_size)) == NULL) - BAD_ERROR("Out of memory allocating fragment_data"); - if(delete) { - printf("Creating %s filesystem on %s, block size %d.\n", - be ? "big endian" : "little endian", argv[source + 1], block_size); + printf("Creating %s %d.%d filesystem on %s, block size %d.\n", + be ? "big endian" : "little endian", SQUASHFS_MAJOR, SQUASHFS_MINOR, 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, inode_dir_inode_number, + inode_dir_parent_inode; + unsigned int 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); @@ -1724,47 +2089,48 @@ printOptions: always_use_fragments = SQUASHFS_ALWAYS_FRAGMENTS(sBlk.flags); duplicate_checking = SQUASHFS_DUPLICATES(sBlk.flags); - fragments = SQUASHFS_INVALID_BLK; - if((bytes = read_filesystem(root_name, fd, &sBlk, &inode_table, &inode_bytes, &data_cache, - &cache_bytes, &cache_size, &directory_table, &directory_bytes, - &directory_data_cache, &directory_cache_bytes, &directory_cache_size, - &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) { + 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, &inode_dir_inode_number, + &inode_dir_parent_inode, add_old_root_entry, &fragment_table)) == 0) { ERROR("Failed to read existing filesystem - will not overwrite - ABORTING!\n"); - exit(1); + 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 squashfs filesystem on %s, block size %d\n", be ? "big endian" : - "little endian", argv[source + 1], block_size); - printf("All -be, -le, -b, -noI, noD, noF, -check_data, no-duplicates, no-fragments and always-use-fragments options ignored\n"); + printf("Appending to existing %s %d.%d filesystem on %s, block size %d\n", be ? "big endian" : + "little endian", SQUASHFS_MAJOR, SQUASHFS_MINOR, 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"); - inode_size = inode_bytes; - directory_size = directory_bytes; - + 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; - inode_count = file_count + dir_count + sym_count + dev_count; - sdata_cache = (char *)malloc(scache_bytes = cache_size); - sdirectory_data_cache = (char *)malloc(sdirectory_cache_bytes = directory_cache_size); + 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, sdirectory_cache_bytes); - sinode_bytes = inode_bytes; - sdirectory_bytes = directory_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; + stotal_directory_bytes = total_directory_bytes + compressed_data; sfile_count = file_count; ssym_count = sym_count; sdev_count = dev_count; - sdir_count = dir_count; + sdir_count = dir_count + 1; + sfifo_count = fifo_count; + ssock_count = sock_count; sdup_files = dup_files; restore = TRUE; if(setjmp(env)) @@ -1772,6 +2138,34 @@ printOptions: 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) { + root_inode_number = inode_dir_parent_inode; + dir_inode_no = sBlk.inodes + 2; + 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, inode_dir_inode_number, SQUASHFS_DIR_TYPE); + total_directory_bytes += compressed_data; + dir_count ++; + } else { + root_inode_number = inode_dir_inode_number; + dir_inode_no = sBlk.inodes + 1; + 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 @@ -1782,20 +2176,13 @@ printOptions: block_offset = check_data ? 3 : 2; - if(stat(source_path[0], &buf) == -1) { - perror("Cannot stat source directory"); - EXIT_MKSQUASHFS(); - } - - if(sorted) - sort_files_and_write(source, source_path); - - if(delete && !keep_as_directory && source == 1 && S_ISDIR(buf.st_mode)) - sBlk.root_inode = dir_scan(source_path[0], linux_opendir, linux_readdir, linux_closedir); - else if(!keep_as_directory && source == 1 && S_ISDIR(buf.st_mode)) - sBlk.root_inode = dir_scan(source_path[0], single_opendir, single_readdir, linux_closedir); + if(delete && !keep_as_directory && source == 1 && S_ISDIR(source_buf.st_mode)) + dir_scan(&inode, source_path[0], scan1_readdir); + else if(!keep_as_directory && source == 1 && S_ISDIR(source_buf.st_mode)) + dir_scan(&inode, source_path[0], scan1_single_readdir); else - sBlk.root_inode = dir_scan("", encomp_opendir, encomp_readdir, encomp_closedir); + dir_scan(&inode, "", scan1_encomp_readdir); + sBlk.root_inode = inode; sBlk.inodes = inode_count; sBlk.s_magic = SQUASHFS_MAGIC; sBlk.s_major = SQUASHFS_MAJOR; @@ -1846,6 +2233,8 @@ restore_filesystem: sBlk.bytes_used = bytes; + sBlk.unused = SQUASHFS_INVALID_BLK; + if(!swap) write_bytes(fd, SQUASHFS_START, sizeof(squashfs_super_block), (char *) &sBlk); else { @@ -1856,7 +2245,7 @@ restore_filesystem: } if(!nopad && (i = bytes & (4096 - 1))) { - unsigned char temp[4096] = {0}; + char temp[4096] = {0}; write_bytes(fd, bytes, 4096 - i, temp); } @@ -1865,7 +2254,7 @@ restore_filesystem: 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, noI ? "uncompressed" : "compressed", noD ? + "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", -- cgit v1.2.3-54-g00ecf