Openwrt-EcoNet/TP-Link_Archer-XR500v
Archived
1
0
Fork 0
Code
This repository has been archived on 2024-07-22. You can view files and clone it, but cannot push or open issues or pull requests.
main
TP-Link_Archer-XR500v/EN7526G_3.18Kernel_SDK/tools/squashfs-tools/mksquashfs.c
Matheus Sampaio Queiroga aaca98136a
Add gpl
2024-07-22 01:58:46 -03:00

2299 lines
73 KiB
C
Executable File
Raw Permalink Blame History

/*
* Create a squashfs filesystem. This is a highly compressed read only filesystem.
*
* Copyright (c) 2002, 2003, 2004, 2005, 2006
* Phillip Lougher <phillip@lougher.org.uk>
*
* 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 FALSE 0
#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>
#include <stdlib.h>
#include <signal.h>
#include <setjmp.h>
#include <sys/mman.h>
#ifndef linux
#define __BYTE_ORDER BYTE_ORDER
#define __BIG_ENDIAN BIG_ENDIAN
#define __LITTLE_ENDIAN LITTLE_ENDIAN
#else
#include <endian.h>
#endif
#include <squashfs_fs.h>
#include "mksquashfs.h"
#include "global.h"
#include "sort.h"
#ifdef SQUASHFS_TRACE
#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();\
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 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 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 */
long long 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
#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;
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;
/* 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;
/* 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;
/* 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;
int inode_number;
};
struct old_root_entry_info *old_root_entry;
/* in memory file info */
struct file_info {
long long bytes;
unsigned short checksum;
long long 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;
long long sbytes, stotal_bytes;
unsigned int sinode_bytes, scache_bytes, sdirectory_bytes,
sdirectory_cache_bytes, suid_count, sguid_count,
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 {
char *ptr;
long long start;
};
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 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(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)))
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 ++;
}
}
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((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)
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, long long 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, long long byte, int bytes, char *buff)
{
off_t off = byte;
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();
}
}
long long write_inodes()
{
unsigned short c_byte;
int avail_bytes;
char *datap = data_cache;
long long 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;
}
long long write_directories()
{
unsigned short c_byte;
int avail_bytes;
char *directoryp = directory_data_cache;
long long 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, 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)
{
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;
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->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->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 %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->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(inode, dir, sizeof(*dir));
else
SQUASHFS_SWAP_DIR_INODE_HEADER(dir, inode);
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->nlink = nlink;
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, nlink %d\n", dev->rdev, nlink);
}
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);
symlink->nlink = nlink;
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, 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(inode, ipc, sizeof(*ipc));
else
SQUASHFS_SWAP_IPC_INODE_HEADER(ipc, inode);
TRACE("ipc inode, type %s, nlink %d\n", type == SQUASHFS_FIFO_TYPE ? "fifo" : "socket", nlink);
} 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 scan2_init_dir(struct directory *dir)
{
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->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, unsigned int inode_number, char *name, int type, struct directory *dir)
{
unsigned 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 + 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 = (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)) || ((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(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->inode_number = inode_number;
dir->p += sizeof(squashfs_dir_header);
}
idirp = (squashfs_dir_entry *) dir->p;
idir.offset = offset;
idir.type = type;
idir.size = size - 1;
idir.inode_number = ((long long) inode_number - dir->inode_number);
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, struct dir_info *dir_info, 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;
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) {
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_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;
}
#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;
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;
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_FRAG, 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;
}
long long write_fragment_table()
{
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;
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 %llx, 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;
}
char *read_from_buffer(struct duplicate_buffer_handle *handle, unsigned int avail_bytes)
{
char *v = handle->ptr;
handle->ptr += avail_bytes;
return v;
}
char read_from_file_buffer[SQUASHFS_FILE_MAX_SIZE];
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(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;
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 = (unsigned char *) 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(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;
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_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;
}
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 };
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) {
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;
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_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%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;
*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;
dupl_ptr->block_list = *block_list;
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, struct dir_ent *dir_ent, long long size, int *duplicate_file)
{
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 = 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;
frag_bytes = read_size % block_size;
} else
frag_bytes = 0;
if(size > read_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)
goto read_err;
do {
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(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);
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 ++;
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);
free(block_list);
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;
}
}
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);
}
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 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;
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 dir;
}
int scan1_encomp_readdir(char *pathname, char *dir_name, struct dir_info *dir)
{
int i, n, pass;
char *basename;
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(index < source) {
if((basename = getbase(source_path[index])) == NULL) {
ERROR("Bad source directory %s - skipping ...\n", source_path[index]);
index ++;
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);
}
strcpy(pathname, source_path[index ++]);
return 1;
}
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;
}
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;
}
struct dir_ent *scan2_readdir(struct directory *dir, struct dir_info *dir_info)
{
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;
}
void scan1_freedir(struct dir_info *dir)
{
if(dir->pathname[0] != '\0')
closedir(dir->linuxdir);
}
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);
}
struct dir_info *dir_scan1(char *pathname, int (_readdir)(char *, char *, struct dir_info *))
{
struct dir_info *dir, *sub_dir;
struct stat buf;
char filename[8192], dir_name[8192];
if((dir = scan1_opendir(pathname)) == NULL) {
ERROR("Could not open %s, skipping...\n", pathname);
goto error;
}
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];
sprintf(buffer, "Cannot stat dir/file %s, ignoring", filename);
perror(buffer);
continue;
}
if(excluded(filename, &buf))
continue;
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;
add_dir_entry(dir_name, filename, sub_dir, lookup_inode(&buf), NULL, dir);
}
scan1_freedir(dir);
sort_directory(dir);
error:
return dir;
}
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_IFDIR:
squashfs_type = SQUASHFS_DIR_TYPE;
result = dir_scan2(inode, dir_ent->dir);
break;
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(result)
add_dir(*inode, inode_number, dir_name, squashfs_type, &dir);
}
result = write_dir(inode, dir_info, &dir);
INFO("directory %s inode 0x%llx\n", pathname, *inode);
scan2_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 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)
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].inode_number = inode_number;
old_root_entry[old_root_entries++].type = type;
}
#define VERSION() \
printf("mksquashfs version 3.0 (2006/03/15)\n");\
printf("copyright (C) 2006 Phillip Lougher <phillip@lougher.org.uk>\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, source_buf;
int i;
squashfs_super_block sBlk;
char *b, *root_name = NULL;
int be, nopad = 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], "-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("-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(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) {
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();
}
} else {
signal(SIGTERM, sighandler2);
signal(SIGINT, sighandler2);
}
/* 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_MKSQUASHFS();
}
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, 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);
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);
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_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, 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");
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) {
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
swap = !be;
#else
swap = be;
#endif
block_offset = check_data ? 3 : 2;
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
dir_scan(&inode, "", scan1_encomp_readdir);
sBlk.root_inode = inode;
sBlk.inodes = inode_count;
sBlk.s_magic = SQUASHFS_MAGIC;
sBlk.s_major = SQUASHFS_MAJOR;
sBlk.s_minor = SQUASHFS_MINOR;
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;
sBlk.unused = SQUASHFS_INVALID_BLK;
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))) {
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;
}
View Git Blame Copy Permalink