mirror of
https://github.com/ventoy/Ventoy.git
synced 2024-12-29 08:33:24 -05:00
3160 lines
78 KiB
C
3160 lines
78 KiB
C
/*
|
|
* Unsquash a squashfs filesystem. This is a highly compressed read only
|
|
* filesystem.
|
|
*
|
|
* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
|
|
* 2012, 2013, 2014, 2017, 2019
|
|
* Phillip Lougher <phillip@squashfs.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.
|
|
*
|
|
* unsquashfs.c
|
|
*/
|
|
|
|
#include "unsquashfs.h"
|
|
#include "squashfs_swap.h"
|
|
#include "squashfs_compat.h"
|
|
#include "compressor.h"
|
|
#include "xattr.h"
|
|
#include "unsquashfs_info.h"
|
|
#include "stdarg.h"
|
|
#include "fnmatch_compat.h"
|
|
|
|
#include <sys/sysinfo.h>
|
|
#include <sys/sysmacros.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/resource.h>
|
|
#include <limits.h>
|
|
#include <ctype.h>
|
|
|
|
|
|
typedef unsigned long long uint64_t;
|
|
typedef unsigned int uint32_t;
|
|
|
|
static int verbose = 0;
|
|
#define debug(fmt, ...) if(verbose) printf(fmt, ##__VA_ARGS__)
|
|
|
|
#pragma pack(1)
|
|
|
|
typedef struct fs_disk_region
|
|
{
|
|
uint32_t sector;
|
|
uint32_t count;
|
|
}fs_disk_region;
|
|
|
|
typedef struct fs_disk_map
|
|
{
|
|
char diskname[32];
|
|
uint64_t filesize;
|
|
|
|
//fs_disk_region[N];
|
|
}fs_disk_map;
|
|
#pragma pack()
|
|
|
|
int g_fs_region_num = 0;
|
|
fs_disk_region *g_fs_region_list = NULL;
|
|
fs_disk_map g_fs_disk_map;
|
|
|
|
struct cache *fragment_cache, *data_cache;
|
|
struct queue *to_reader, *to_inflate, *to_writer, *from_writer;
|
|
pthread_t *thread, *inflator_thread;
|
|
pthread_mutex_t fragment_mutex;
|
|
static long long start_offset = 0;
|
|
|
|
/* user options that control parallelisation */
|
|
int processors = -1;
|
|
|
|
struct super_block sBlk;
|
|
squashfs_operations *s_ops;
|
|
squashfs_operations *(*read_filesystem_tables)();
|
|
struct compressor *comp;
|
|
|
|
int bytes = 0, swap, file_count = 0, dir_count = 0, sym_count = 0,
|
|
dev_count = 0, fifo_count = 0;
|
|
struct hash_table_entry *inode_table_hash[65536], *directory_table_hash[65536];
|
|
int fd;
|
|
unsigned int cached_frag = SQUASHFS_INVALID_FRAG;
|
|
unsigned int block_size;
|
|
unsigned int block_log;
|
|
int lsonly = FALSE, info = FALSE, force = FALSE, short_ls = TRUE;
|
|
int concise = FALSE, quiet = FALSE, numeric = FALSE;
|
|
int use_regex = FALSE;
|
|
char **created_inode;
|
|
int root_process;
|
|
int columns;
|
|
int rotate = 0;
|
|
pthread_mutex_t screen_mutex;
|
|
int progress = TRUE, progress_enabled = FALSE;
|
|
unsigned int total_blocks = 0, total_files = 0, total_inodes = 0;
|
|
unsigned int cur_blocks = 0;
|
|
int inode_number = 1;
|
|
int no_xattrs = XATTR_DEF;
|
|
int user_xattrs = FALSE;
|
|
int ignore_errors = FALSE;
|
|
int strict_errors = FALSE;
|
|
int use_localtime = TRUE;
|
|
|
|
int lookup_type[] = {
|
|
0,
|
|
S_IFDIR,
|
|
S_IFREG,
|
|
S_IFLNK,
|
|
S_IFBLK,
|
|
S_IFCHR,
|
|
S_IFIFO,
|
|
S_IFSOCK,
|
|
S_IFDIR,
|
|
S_IFREG,
|
|
S_IFLNK,
|
|
S_IFBLK,
|
|
S_IFCHR,
|
|
S_IFIFO,
|
|
S_IFSOCK
|
|
};
|
|
|
|
struct test table[] = {
|
|
{ S_IFMT, S_IFSOCK, 0, 's' },
|
|
{ S_IFMT, S_IFLNK, 0, 'l' },
|
|
{ S_IFMT, S_IFBLK, 0, 'b' },
|
|
{ S_IFMT, S_IFDIR, 0, 'd' },
|
|
{ S_IFMT, S_IFCHR, 0, 'c' },
|
|
{ S_IFMT, S_IFIFO, 0, 'p' },
|
|
{ S_IRUSR, S_IRUSR, 1, 'r' },
|
|
{ S_IWUSR, S_IWUSR, 2, 'w' },
|
|
{ S_IRGRP, S_IRGRP, 4, 'r' },
|
|
{ S_IWGRP, S_IWGRP, 5, 'w' },
|
|
{ S_IROTH, S_IROTH, 7, 'r' },
|
|
{ S_IWOTH, S_IWOTH, 8, 'w' },
|
|
{ S_IXUSR | S_ISUID, S_IXUSR | S_ISUID, 3, 's' },
|
|
{ S_IXUSR | S_ISUID, S_ISUID, 3, 'S' },
|
|
{ S_IXUSR | S_ISUID, S_IXUSR, 3, 'x' },
|
|
{ S_IXGRP | S_ISGID, S_IXGRP | S_ISGID, 6, 's' },
|
|
{ S_IXGRP | S_ISGID, S_ISGID, 6, 'S' },
|
|
{ S_IXGRP | S_ISGID, S_IXGRP, 6, 'x' },
|
|
{ S_IXOTH | S_ISVTX, S_IXOTH | S_ISVTX, 9, 't' },
|
|
{ S_IXOTH | S_ISVTX, S_ISVTX, 9, 'T' },
|
|
{ S_IXOTH | S_ISVTX, S_IXOTH, 9, 'x' },
|
|
{ 0, 0, 0, 0}
|
|
};
|
|
|
|
void progress_bar(long long current, long long max, int columns);
|
|
|
|
#define MAX_LINE 16384
|
|
|
|
void prep_exit()
|
|
{
|
|
}
|
|
|
|
|
|
void sigwinch_handler()
|
|
{
|
|
struct winsize winsize;
|
|
|
|
if(ioctl(1, TIOCGWINSZ, &winsize) == -1) {
|
|
if(isatty(STDOUT_FILENO))
|
|
ERROR("TIOCGWINSZ ioctl failed, defaulting to 80 "
|
|
"columns\n");
|
|
columns = 80;
|
|
} else
|
|
columns = winsize.ws_col;
|
|
}
|
|
|
|
|
|
void sigalrm_handler()
|
|
{
|
|
rotate = (rotate + 1) % 4;
|
|
}
|
|
|
|
|
|
int add_overflow(int a, int b)
|
|
{
|
|
return (INT_MAX - a) < b;
|
|
}
|
|
|
|
|
|
int shift_overflow(int a, int shift)
|
|
{
|
|
return (INT_MAX >> shift) < a;
|
|
}
|
|
|
|
|
|
int multiply_overflow(int a, int multiplier)
|
|
{
|
|
return (INT_MAX / multiplier) < a;
|
|
}
|
|
|
|
|
|
struct queue *queue_init(int size)
|
|
{
|
|
struct queue *queue = malloc(sizeof(struct queue));
|
|
|
|
if(queue == NULL)
|
|
EXIT_UNSQUASH("Out of memory in queue_init\n");
|
|
|
|
if(add_overflow(size, 1) ||
|
|
multiply_overflow(size + 1, sizeof(void *)))
|
|
EXIT_UNSQUASH("Size too large in queue_init\n");
|
|
|
|
queue->data = malloc(sizeof(void *) * (size + 1));
|
|
if(queue->data == NULL)
|
|
EXIT_UNSQUASH("Out of memory in queue_init\n");
|
|
|
|
queue->size = size + 1;
|
|
queue->readp = queue->writep = 0;
|
|
pthread_mutex_init(&queue->mutex, NULL);
|
|
pthread_cond_init(&queue->empty, NULL);
|
|
pthread_cond_init(&queue->full, NULL);
|
|
|
|
return queue;
|
|
}
|
|
|
|
|
|
void queue_put(struct queue *queue, void *data)
|
|
{
|
|
int nextp;
|
|
|
|
pthread_mutex_lock(&queue->mutex);
|
|
|
|
while((nextp = (queue->writep + 1) % queue->size) == queue->readp)
|
|
pthread_cond_wait(&queue->full, &queue->mutex);
|
|
|
|
queue->data[queue->writep] = data;
|
|
queue->writep = nextp;
|
|
pthread_cond_signal(&queue->empty);
|
|
pthread_mutex_unlock(&queue->mutex);
|
|
}
|
|
|
|
|
|
void *queue_get(struct queue *queue)
|
|
{
|
|
void *data;
|
|
pthread_mutex_lock(&queue->mutex);
|
|
|
|
while(queue->readp == queue->writep)
|
|
pthread_cond_wait(&queue->empty, &queue->mutex);
|
|
|
|
data = queue->data[queue->readp];
|
|
queue->readp = (queue->readp + 1) % queue->size;
|
|
pthread_cond_signal(&queue->full);
|
|
pthread_mutex_unlock(&queue->mutex);
|
|
|
|
return data;
|
|
}
|
|
|
|
|
|
void dump_queue(struct queue *queue)
|
|
{
|
|
pthread_mutex_lock(&queue->mutex);
|
|
|
|
printf("Max size %d, size %d%s\n", queue->size - 1,
|
|
queue->readp <= queue->writep ? queue->writep - queue->readp :
|
|
queue->size - queue->readp + queue->writep,
|
|
queue->readp == queue->writep ? " (EMPTY)" :
|
|
((queue->writep + 1) % queue->size) == queue->readp ?
|
|
" (FULL)" : "");
|
|
|
|
pthread_mutex_unlock(&queue->mutex);
|
|
}
|
|
|
|
|
|
/* Called with the cache mutex held */
|
|
void insert_hash_table(struct cache *cache, struct cache_entry *entry)
|
|
{
|
|
int hash = CALCULATE_HASH(entry->block);
|
|
|
|
entry->hash_next = cache->hash_table[hash];
|
|
cache->hash_table[hash] = entry;
|
|
entry->hash_prev = NULL;
|
|
if(entry->hash_next)
|
|
entry->hash_next->hash_prev = entry;
|
|
}
|
|
|
|
|
|
/* Called with the cache mutex held */
|
|
void remove_hash_table(struct cache *cache, struct cache_entry *entry)
|
|
{
|
|
if(entry->hash_prev)
|
|
entry->hash_prev->hash_next = entry->hash_next;
|
|
else
|
|
cache->hash_table[CALCULATE_HASH(entry->block)] =
|
|
entry->hash_next;
|
|
if(entry->hash_next)
|
|
entry->hash_next->hash_prev = entry->hash_prev;
|
|
|
|
entry->hash_prev = entry->hash_next = NULL;
|
|
}
|
|
|
|
|
|
/* Called with the cache mutex held */
|
|
void insert_free_list(struct cache *cache, struct cache_entry *entry)
|
|
{
|
|
if(cache->free_list) {
|
|
entry->free_next = cache->free_list;
|
|
entry->free_prev = cache->free_list->free_prev;
|
|
cache->free_list->free_prev->free_next = entry;
|
|
cache->free_list->free_prev = entry;
|
|
} else {
|
|
cache->free_list = entry;
|
|
entry->free_prev = entry->free_next = entry;
|
|
}
|
|
}
|
|
|
|
|
|
/* Called with the cache mutex held */
|
|
void remove_free_list(struct cache *cache, struct cache_entry *entry)
|
|
{
|
|
if(entry->free_prev == NULL || entry->free_next == NULL)
|
|
/* not in free list */
|
|
return;
|
|
else if(entry->free_prev == entry && entry->free_next == entry) {
|
|
/* only this entry in the free list */
|
|
cache->free_list = NULL;
|
|
} else {
|
|
/* more than one entry in the free list */
|
|
entry->free_next->free_prev = entry->free_prev;
|
|
entry->free_prev->free_next = entry->free_next;
|
|
if(cache->free_list == entry)
|
|
cache->free_list = entry->free_next;
|
|
}
|
|
|
|
entry->free_prev = entry->free_next = NULL;
|
|
}
|
|
|
|
|
|
struct cache *cache_init(int buffer_size, int max_buffers)
|
|
{
|
|
struct cache *cache = malloc(sizeof(struct cache));
|
|
|
|
if(cache == NULL)
|
|
EXIT_UNSQUASH("Out of memory in cache_init\n");
|
|
|
|
cache->max_buffers = max_buffers;
|
|
cache->buffer_size = buffer_size;
|
|
cache->count = 0;
|
|
cache->used = 0;
|
|
cache->free_list = NULL;
|
|
memset(cache->hash_table, 0, sizeof(struct cache_entry *) * 65536);
|
|
cache->wait_free = FALSE;
|
|
cache->wait_pending = FALSE;
|
|
pthread_mutex_init(&cache->mutex, NULL);
|
|
pthread_cond_init(&cache->wait_for_free, NULL);
|
|
pthread_cond_init(&cache->wait_for_pending, NULL);
|
|
|
|
return cache;
|
|
}
|
|
|
|
|
|
struct cache_entry *cache_get(struct cache *cache, long long block, int size)
|
|
{
|
|
/*
|
|
* Get a block out of the cache. If the block isn't in the cache
|
|
* it is added and queued to the reader() and inflate() threads for
|
|
* reading off disk and decompression. The cache grows until max_blocks
|
|
* is reached, once this occurs existing discarded blocks on the free
|
|
* list are reused
|
|
*/
|
|
int hash = CALCULATE_HASH(block);
|
|
struct cache_entry *entry;
|
|
|
|
pthread_mutex_lock(&cache->mutex);
|
|
|
|
for(entry = cache->hash_table[hash]; entry; entry = entry->hash_next)
|
|
if(entry->block == block)
|
|
break;
|
|
|
|
if(entry) {
|
|
/*
|
|
* found the block in the cache. If the block is currently unused
|
|
* remove it from the free list and increment cache used count.
|
|
*/
|
|
if(entry->used == 0) {
|
|
cache->used ++;
|
|
remove_free_list(cache, entry);
|
|
}
|
|
entry->used ++;
|
|
pthread_mutex_unlock(&cache->mutex);
|
|
} else {
|
|
/*
|
|
* not in the cache
|
|
*
|
|
* first try to allocate new block
|
|
*/
|
|
if(cache->count < cache->max_buffers) {
|
|
entry = malloc(sizeof(struct cache_entry));
|
|
if(entry == NULL)
|
|
EXIT_UNSQUASH("Out of memory in cache_get\n");
|
|
entry->data = malloc(cache->buffer_size);
|
|
if(entry->data == NULL)
|
|
EXIT_UNSQUASH("Out of memory in cache_get\n");
|
|
entry->cache = cache;
|
|
entry->free_prev = entry->free_next = NULL;
|
|
cache->count ++;
|
|
} else {
|
|
/*
|
|
* try to get from free list
|
|
*/
|
|
while(cache->free_list == NULL) {
|
|
cache->wait_free = TRUE;
|
|
pthread_cond_wait(&cache->wait_for_free,
|
|
&cache->mutex);
|
|
}
|
|
entry = cache->free_list;
|
|
remove_free_list(cache, entry);
|
|
remove_hash_table(cache, entry);
|
|
}
|
|
|
|
/*
|
|
* Initialise block and insert into the hash table.
|
|
* Increment used which tracks how many buffers in the
|
|
* cache are actively in use (the other blocks, count - used,
|
|
* are in the cache and available for lookup, but can also be
|
|
* re-used).
|
|
*/
|
|
entry->block = block;
|
|
entry->size = size;
|
|
entry->used = 1;
|
|
entry->error = FALSE;
|
|
entry->pending = TRUE;
|
|
insert_hash_table(cache, entry);
|
|
cache->used ++;
|
|
|
|
/*
|
|
* queue to read thread to read and ultimately (via the
|
|
* decompress threads) decompress the buffer
|
|
*/
|
|
pthread_mutex_unlock(&cache->mutex);
|
|
queue_put(to_reader, entry);
|
|
}
|
|
|
|
return entry;
|
|
}
|
|
|
|
|
|
void cache_block_ready(struct cache_entry *entry, int error)
|
|
{
|
|
/*
|
|
* mark cache entry as being complete, reading and (if necessary)
|
|
* decompression has taken place, and the buffer is valid for use.
|
|
* If an error occurs reading or decompressing, the buffer also
|
|
* becomes ready but with an error...
|
|
*/
|
|
pthread_mutex_lock(&entry->cache->mutex);
|
|
entry->pending = FALSE;
|
|
entry->error = error;
|
|
|
|
/*
|
|
* if the wait_pending flag is set, one or more threads may be waiting
|
|
* on this buffer
|
|
*/
|
|
if(entry->cache->wait_pending) {
|
|
entry->cache->wait_pending = FALSE;
|
|
pthread_cond_broadcast(&entry->cache->wait_for_pending);
|
|
}
|
|
|
|
pthread_mutex_unlock(&entry->cache->mutex);
|
|
}
|
|
|
|
|
|
void cache_block_wait(struct cache_entry *entry)
|
|
{
|
|
/*
|
|
* wait for this cache entry to become ready, when reading and (if
|
|
* necessary) decompression has taken place
|
|
*/
|
|
pthread_mutex_lock(&entry->cache->mutex);
|
|
|
|
while(entry->pending) {
|
|
entry->cache->wait_pending = TRUE;
|
|
pthread_cond_wait(&entry->cache->wait_for_pending,
|
|
&entry->cache->mutex);
|
|
}
|
|
|
|
pthread_mutex_unlock(&entry->cache->mutex);
|
|
}
|
|
|
|
|
|
void cache_block_put(struct cache_entry *entry)
|
|
{
|
|
/*
|
|
* finished with this cache entry, once the usage count reaches zero it
|
|
* can be reused and is put onto the free list. As it remains
|
|
* accessible via the hash table it can be found getting a new lease of
|
|
* life before it is reused.
|
|
*/
|
|
pthread_mutex_lock(&entry->cache->mutex);
|
|
|
|
entry->used --;
|
|
if(entry->used == 0) {
|
|
insert_free_list(entry->cache, entry);
|
|
entry->cache->used --;
|
|
|
|
/*
|
|
* if the wait_free flag is set, one or more threads may be
|
|
* waiting on this buffer
|
|
*/
|
|
if(entry->cache->wait_free) {
|
|
entry->cache->wait_free = FALSE;
|
|
pthread_cond_broadcast(&entry->cache->wait_for_free);
|
|
}
|
|
}
|
|
|
|
pthread_mutex_unlock(&entry->cache->mutex);
|
|
}
|
|
|
|
|
|
void dump_cache(struct cache *cache)
|
|
{
|
|
pthread_mutex_lock(&cache->mutex);
|
|
|
|
printf("Max buffers %d, Current size %d, Used %d, %s\n",
|
|
cache->max_buffers, cache->count, cache->used,
|
|
cache->free_list ? "Free buffers" : "No free buffers");
|
|
|
|
pthread_mutex_unlock(&cache->mutex);
|
|
}
|
|
|
|
|
|
char *modestr(char *str, int mode)
|
|
{
|
|
int i;
|
|
|
|
strcpy(str, "----------");
|
|
|
|
for(i = 0; table[i].mask != 0; i++) {
|
|
if((mode & table[i].mask) == table[i].value)
|
|
str[table[i].position] = table[i].mode;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
|
|
#define TOTALCHARS 25
|
|
int print_filename(char *pathname, struct inode *inode)
|
|
{
|
|
char str[11], dummy[12], dummy2[12]; /* overflow safe */
|
|
char *userstr, *groupstr;
|
|
int padchars;
|
|
struct passwd *user;
|
|
struct group *group;
|
|
struct tm *t;
|
|
|
|
if(short_ls) {
|
|
printf("%s\n", pathname);
|
|
return 1;
|
|
}
|
|
|
|
user = numeric ? NULL : getpwuid(inode->uid);
|
|
if(user == NULL) {
|
|
int res = snprintf(dummy, 12, "%d", inode->uid);
|
|
if(res < 0)
|
|
EXIT_UNSQUASH("snprintf failed in print_filename()\n");
|
|
else if(res >= 12)
|
|
/* unsigned int shouldn't ever need more than 11 bytes
|
|
* (including terminating '\0') to print in base 10 */
|
|
userstr = "*";
|
|
else
|
|
userstr = dummy;
|
|
} else
|
|
userstr = user->pw_name;
|
|
|
|
group = numeric ? NULL : getgrgid(inode->gid);
|
|
if(group == NULL) {
|
|
int res = snprintf(dummy2, 12, "%d", inode->gid);
|
|
if(res < 0)
|
|
EXIT_UNSQUASH("snprintf failed in print_filename()\n");
|
|
else if(res >= 12)
|
|
/* unsigned int shouldn't ever need more than 11 bytes
|
|
* (including terminating '\0') to print in base 10 */
|
|
groupstr = "*";
|
|
else
|
|
groupstr = dummy2;
|
|
} else
|
|
groupstr = group->gr_name;
|
|
|
|
printf("%s %s/%s ", modestr(str, inode->mode), userstr, groupstr);
|
|
|
|
switch(inode->mode & S_IFMT) {
|
|
case S_IFREG:
|
|
case S_IFDIR:
|
|
case S_IFSOCK:
|
|
case S_IFIFO:
|
|
case S_IFLNK:
|
|
padchars = TOTALCHARS - strlen(userstr) -
|
|
strlen(groupstr);
|
|
|
|
printf("%*lld ", padchars > 0 ? padchars : 0,
|
|
inode->data);
|
|
break;
|
|
case S_IFCHR:
|
|
case S_IFBLK:
|
|
padchars = TOTALCHARS - strlen(userstr) -
|
|
strlen(groupstr) - 7;
|
|
|
|
printf("%*s%3d,%3d ", padchars > 0 ? padchars : 0, " ",
|
|
(int) inode->data >> 8, (int) inode->data &
|
|
0xff);
|
|
break;
|
|
}
|
|
|
|
t = use_localtime ? localtime(&inode->time) : gmtime(&inode->time);
|
|
|
|
printf("%d-%02d-%02d %02d:%02d %s", t->tm_year + 1900, t->tm_mon + 1,
|
|
t->tm_mday, t->tm_hour, t->tm_min, pathname);
|
|
if((inode->mode & S_IFMT) == S_IFLNK)
|
|
printf(" -> %s", inode->symlink);
|
|
printf("\n");
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
void add_entry(struct hash_table_entry *hash_table[], long long start,
|
|
long long bytes)
|
|
{
|
|
int hash = CALCULATE_HASH(start);
|
|
struct hash_table_entry *hash_table_entry;
|
|
|
|
hash_table_entry = malloc(sizeof(struct hash_table_entry));
|
|
if(hash_table_entry == NULL)
|
|
EXIT_UNSQUASH("Out of memory in add_entry\n");
|
|
|
|
hash_table_entry->start = start;
|
|
hash_table_entry->bytes = bytes;
|
|
hash_table_entry->next = hash_table[hash];
|
|
hash_table[hash] = hash_table_entry;
|
|
}
|
|
|
|
|
|
long long lookup_entry(struct hash_table_entry *hash_table[], long long start)
|
|
{
|
|
int hash = CALCULATE_HASH(start);
|
|
struct hash_table_entry *hash_table_entry;
|
|
|
|
for(hash_table_entry = hash_table[hash]; hash_table_entry;
|
|
hash_table_entry = hash_table_entry->next)
|
|
|
|
if(hash_table_entry->start == start)
|
|
return hash_table_entry->bytes;
|
|
|
|
return -1;
|
|
}
|
|
|
|
int read_fs_sectors(int fd, uint32_t sector, uint32_t count, char *buf)
|
|
{
|
|
int i;
|
|
uint32_t total = 0;
|
|
uint32_t left = 0;
|
|
uint32_t offset = 0;
|
|
uint32_t readcnt = 0;
|
|
fs_disk_region *region;
|
|
|
|
for (i = 0; i < g_fs_region_num && count > 0; i++)
|
|
{
|
|
region = g_fs_region_list + i;
|
|
|
|
if (sector >= total && sector < total + region->count)
|
|
{
|
|
offset = sector - total;
|
|
left = region->count - offset;
|
|
readcnt = (count <= left) ? count : left;
|
|
|
|
lseek(fd, (uint64_t)(offset + region->sector) * 512ULL, SEEK_SET);
|
|
read(fd, buf, (uint64_t)readcnt * 512ULL);
|
|
|
|
buf += (uint64_t)readcnt * 512ULL;
|
|
count -= readcnt;
|
|
}
|
|
else
|
|
{
|
|
total += region->count;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 1
|
|
int read_fs_bytes(int fd, long long byte, int bytes, void *buff)
|
|
{
|
|
uint32_t mod = 0;
|
|
uint32_t align = 0;
|
|
uint32_t sector = 0;
|
|
uint32_t number = 0;
|
|
uint32_t leftsize = 0;
|
|
uint64_t offset = byte;
|
|
char *buf = (char *)buff;
|
|
char secbuf[512];
|
|
|
|
if (offset >= g_fs_disk_map.filesize || offset + bytes > g_fs_disk_map.filesize)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
leftsize = bytes;
|
|
sector = offset / 512;
|
|
|
|
mod = offset % 512;
|
|
if (mod > 0)
|
|
{
|
|
align = 512 - mod;
|
|
read_fs_sectors(fd, sector, 1, secbuf);
|
|
|
|
if (leftsize > align)
|
|
{
|
|
memcpy(buf, secbuf + mod, align);
|
|
buf += align;
|
|
offset += align;
|
|
sector++;
|
|
leftsize -= align;
|
|
}
|
|
else
|
|
{
|
|
memcpy(buf, secbuf + mod, leftsize);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
number = leftsize / 512;
|
|
read_fs_sectors(fd, sector, number, buf);
|
|
buf += number * 512;
|
|
|
|
mod = leftsize % 512;
|
|
if (mod > 0)
|
|
{
|
|
read_fs_sectors(fd, sector + number, 1, secbuf);
|
|
memcpy(buf, secbuf, mod);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#else
|
|
|
|
int read_fs_bytes(int fd, long long byte, int bytes, void *buff)
|
|
{
|
|
off_t off = byte;
|
|
int res, count;
|
|
|
|
TRACE("read_bytes: reading from position 0x%llx, bytes %d\n", byte,
|
|
bytes);
|
|
|
|
if(lseek(fd, start_offset + off, SEEK_SET) == -1) {
|
|
ERROR("Lseek failed because %s\n", strerror(errno));
|
|
return FALSE;
|
|
}
|
|
|
|
for(count = 0; count < bytes; count += res) {
|
|
res = read(fd, buff + count, bytes - count);
|
|
if(res < 1) {
|
|
if(res == 0) {
|
|
ERROR("Read on filesystem failed because "
|
|
"EOF\n");
|
|
return FALSE;
|
|
} else if(errno != EINTR) {
|
|
ERROR("Read on filesystem failed because %s\n",
|
|
strerror(errno));
|
|
return FALSE;
|
|
} else
|
|
res = 0;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
int read_block(int fd, long long start, long long *next, int expected,
|
|
void *block)
|
|
{
|
|
unsigned short c_byte;
|
|
int offset = 2, res, compressed;
|
|
int outlen = expected ? expected : SQUASHFS_METADATA_SIZE;
|
|
static char *buffer = NULL;
|
|
|
|
if(outlen > SQUASHFS_METADATA_SIZE)
|
|
return FALSE;
|
|
|
|
if(swap) {
|
|
if(read_fs_bytes(fd, start, 2, &c_byte) == FALSE)
|
|
goto failed;
|
|
c_byte = (c_byte >> 8) | ((c_byte & 0xff) << 8);
|
|
} else
|
|
if(read_fs_bytes(fd, start, 2, &c_byte) == FALSE)
|
|
goto failed;
|
|
|
|
TRACE("read_block: block @0x%llx, %d %s bytes\n", start,
|
|
SQUASHFS_COMPRESSED_SIZE(c_byte), SQUASHFS_COMPRESSED(c_byte) ?
|
|
"compressed" : "uncompressed");
|
|
|
|
if(SQUASHFS_CHECK_DATA(sBlk.s.flags))
|
|
offset = 3;
|
|
|
|
compressed = SQUASHFS_COMPRESSED(c_byte);
|
|
c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
|
|
|
|
/*
|
|
* The block size should not be larger than
|
|
* the uncompressed size (or max uncompressed size if
|
|
* expected is 0)
|
|
*/
|
|
if(c_byte > outlen)
|
|
return FALSE;
|
|
|
|
if(compressed) {
|
|
int error;
|
|
|
|
if(buffer == NULL) {
|
|
buffer = malloc(SQUASHFS_METADATA_SIZE);
|
|
|
|
if(buffer == NULL)
|
|
EXIT_UNSQUASH("read_block: Failed to allocate buffer\n");
|
|
}
|
|
|
|
res = read_fs_bytes(fd, start + offset, c_byte, buffer);
|
|
if(res == FALSE)
|
|
goto failed;
|
|
|
|
res = compressor_uncompress(comp, block, buffer, c_byte,
|
|
outlen, &error);
|
|
|
|
if(res == -1) {
|
|
ERROR("%s uncompress failed with error code %d\n",
|
|
comp->name, error);
|
|
goto failed;
|
|
}
|
|
} else {
|
|
res = read_fs_bytes(fd, start + offset, c_byte, block);
|
|
if(res == FALSE)
|
|
goto failed;
|
|
res = c_byte;
|
|
}
|
|
|
|
if(next)
|
|
*next = start + offset + c_byte;
|
|
|
|
/*
|
|
* if expected, then check the (uncompressed) return data
|
|
* is of the expected size
|
|
*/
|
|
if(expected && expected != res)
|
|
return FALSE;
|
|
else
|
|
return res;
|
|
|
|
failed:
|
|
ERROR("read_block: failed to read block @0x%llx\n", start);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void *read_inode_table(long long start, long long end)
|
|
{
|
|
int res;
|
|
long long size = 0;
|
|
long long bytes = 0;
|
|
void *inode_table = NULL;
|
|
|
|
TRACE("read_inode_table: start %lld, end %lld\n", start, end);
|
|
|
|
while(start < end) {
|
|
if(size - bytes < SQUASHFS_METADATA_SIZE) {
|
|
inode_table = realloc(inode_table, size +=
|
|
SQUASHFS_METADATA_SIZE);
|
|
if(inode_table == NULL) {
|
|
ERROR("Out of memory in read_inode_table");
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
add_entry(inode_table_hash, start, bytes);
|
|
|
|
res = read_block(fd, start, &start, 0, inode_table + bytes);
|
|
if(res == 0) {
|
|
ERROR("read_inode_table: failed to read block\n");
|
|
goto failed;
|
|
}
|
|
bytes += res;
|
|
|
|
/*
|
|
* If this is not the last metadata block in the inode table
|
|
* then it should be SQUASHFS_METADATA_SIZE in size.
|
|
* Note, we can't use expected in read_block() above for this
|
|
* because we don't know if this is the last block until
|
|
* after reading.
|
|
*/
|
|
if(start != end && res != SQUASHFS_METADATA_SIZE) {
|
|
ERROR("read_inode_table: metadata block should be %d "
|
|
"bytes in length, it is %d bytes\n",
|
|
SQUASHFS_METADATA_SIZE, res);
|
|
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
return inode_table;
|
|
|
|
failed:
|
|
free(inode_table);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int set_attributes(char *pathname, int mode, uid_t uid, gid_t guid, time_t time,
|
|
unsigned int xattr, unsigned int set_mode)
|
|
{
|
|
struct utimbuf times = { time, time };
|
|
|
|
if(utime(pathname, ×) == -1) {
|
|
EXIT_UNSQUASH_STRICT("set_attributes: failed to set time on %s, because %s\n",
|
|
pathname, strerror(errno));
|
|
return FALSE;
|
|
}
|
|
|
|
if(root_process) {
|
|
if(chown(pathname, uid, guid) == -1) {
|
|
EXIT_UNSQUASH_STRICT("set_attributes: failed to change uid and gids "
|
|
"on %s, because %s\n", pathname,
|
|
strerror(errno));
|
|
return FALSE;
|
|
}
|
|
} else
|
|
mode &= ~06000;
|
|
|
|
if((set_mode || (mode & 07000)) && chmod(pathname, (mode_t) mode) == -1) {
|
|
/*
|
|
* Some filesystems require root privileges to use the sticky
|
|
* bit. If we're not root and chmod() failed with EPERM when the
|
|
* sticky bit was included in the mode, try again without the
|
|
* sticky bit. Otherwise, fail with an error message.
|
|
*/
|
|
if (root_process || errno != EPERM || !(mode & 01000) ||
|
|
chmod(pathname, (mode_t) (mode & ~01000)) == -1) {
|
|
EXIT_UNSQUASH_STRICT("set_attributes: failed to change mode %s, because %s\n",
|
|
pathname, strerror(errno));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return write_xattr(pathname, xattr);
|
|
}
|
|
|
|
|
|
int write_bytes(int fd, char *buff, int bytes)
|
|
{
|
|
int res, count;
|
|
|
|
for(count = 0; count < bytes; count += res) {
|
|
res = write(fd, buff + count, bytes - count);
|
|
if(res == -1) {
|
|
if(errno != EINTR) {
|
|
ERROR("Write on output file failed because "
|
|
"%s\n", strerror(errno));
|
|
return -1;
|
|
}
|
|
res = 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int lseek_broken = FALSE;
|
|
char *zero_data = NULL;
|
|
|
|
int write_block(int file_fd, char *buffer, int size, long long hole, int sparse)
|
|
{
|
|
off_t off = hole;
|
|
|
|
if(hole) {
|
|
if(sparse && lseek_broken == FALSE) {
|
|
int error = lseek(file_fd, off, SEEK_CUR);
|
|
if(error == -1)
|
|
/* failed to seek beyond end of file */
|
|
lseek_broken = TRUE;
|
|
}
|
|
|
|
if((sparse == FALSE || lseek_broken) && zero_data == NULL) {
|
|
if((zero_data = malloc(block_size)) == NULL)
|
|
EXIT_UNSQUASH("write_block: failed to alloc "
|
|
"zero data block\n");
|
|
memset(zero_data, 0, block_size);
|
|
}
|
|
|
|
if(sparse == FALSE || lseek_broken) {
|
|
int blocks = (hole + block_size -1) / block_size;
|
|
int avail_bytes, i;
|
|
for(i = 0; i < blocks; i++, hole -= avail_bytes) {
|
|
avail_bytes = hole > block_size ? block_size :
|
|
hole;
|
|
if(write_bytes(file_fd, zero_data, avail_bytes)
|
|
== -1)
|
|
goto failure;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(write_bytes(file_fd, buffer, size) == -1)
|
|
goto failure;
|
|
|
|
return TRUE;
|
|
|
|
failure:
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
pthread_mutex_t open_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
pthread_cond_t open_empty = PTHREAD_COND_INITIALIZER;
|
|
int open_unlimited, open_count;
|
|
#define OPEN_FILE_MARGIN 10
|
|
|
|
|
|
void open_init(int count)
|
|
{
|
|
open_count = count;
|
|
open_unlimited = count == -1;
|
|
}
|
|
|
|
|
|
int open_wait(char *pathname, int flags, mode_t mode)
|
|
{
|
|
if (!open_unlimited) {
|
|
pthread_mutex_lock(&open_mutex);
|
|
while (open_count == 0)
|
|
pthread_cond_wait(&open_empty, &open_mutex);
|
|
open_count --;
|
|
pthread_mutex_unlock(&open_mutex);
|
|
}
|
|
|
|
return open(pathname, flags, mode);
|
|
}
|
|
|
|
|
|
void close_wake(int fd)
|
|
{
|
|
close(fd);
|
|
|
|
if (!open_unlimited) {
|
|
pthread_mutex_lock(&open_mutex);
|
|
open_count ++;
|
|
pthread_cond_signal(&open_empty);
|
|
pthread_mutex_unlock(&open_mutex);
|
|
}
|
|
}
|
|
|
|
|
|
void queue_file(char *pathname, int file_fd, struct inode *inode)
|
|
{
|
|
struct squashfs_file *file = malloc(sizeof(struct squashfs_file));
|
|
if(file == NULL)
|
|
EXIT_UNSQUASH("queue_file: unable to malloc file\n");
|
|
|
|
file->fd = file_fd;
|
|
file->file_size = inode->data;
|
|
file->mode = inode->mode;
|
|
file->gid = inode->gid;
|
|
file->uid = inode->uid;
|
|
file->time = inode->time;
|
|
file->pathname = strdup(pathname);
|
|
file->blocks = inode->blocks + (inode->frag_bytes > 0);
|
|
file->sparse = inode->sparse;
|
|
file->xattr = inode->xattr;
|
|
queue_put(to_writer, file);
|
|
}
|
|
|
|
|
|
void queue_dir(char *pathname, struct dir *dir)
|
|
{
|
|
struct squashfs_file *file = malloc(sizeof(struct squashfs_file));
|
|
if(file == NULL)
|
|
EXIT_UNSQUASH("queue_dir: unable to malloc file\n");
|
|
|
|
file->fd = -1;
|
|
file->mode = dir->mode;
|
|
file->gid = dir->guid;
|
|
file->uid = dir->uid;
|
|
file->time = dir->mtime;
|
|
file->pathname = strdup(pathname);
|
|
file->xattr = dir->xattr;
|
|
queue_put(to_writer, file);
|
|
}
|
|
|
|
|
|
int write_file(struct inode *inode, char *pathname)
|
|
{
|
|
unsigned int file_fd, i;
|
|
unsigned int *block_list;
|
|
int file_end = inode->data / block_size;
|
|
long long start = inode->start;
|
|
|
|
TRACE("write_file: regular file, blocks %d\n", inode->blocks);
|
|
|
|
file_fd = open_wait(pathname, O_CREAT | O_WRONLY |
|
|
(force ? O_TRUNC : 0), (mode_t) inode->mode & 0777);
|
|
if(file_fd == -1) {
|
|
EXIT_UNSQUASH_IGNORE("write_file: failed to create file %s, because %s\n",
|
|
pathname, strerror(errno));
|
|
return FALSE;
|
|
}
|
|
|
|
block_list = malloc(inode->blocks * sizeof(unsigned int));
|
|
if(block_list == NULL)
|
|
EXIT_UNSQUASH("write_file: unable to malloc block list\n");
|
|
|
|
s_ops->read_block_list(block_list, inode->block_ptr, inode->blocks);
|
|
|
|
/*
|
|
* the writer thread is queued a squashfs_file structure describing the
|
|
* file. If the file has one or more blocks or a fragment they are
|
|
* queued separately (references to blocks in the cache).
|
|
*/
|
|
queue_file(pathname, file_fd, inode);
|
|
|
|
for(i = 0; i < inode->blocks; i++) {
|
|
int c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(block_list[i]);
|
|
struct file_entry *block = malloc(sizeof(struct file_entry));
|
|
|
|
if(block == NULL)
|
|
EXIT_UNSQUASH("write_file: unable to malloc file\n");
|
|
block->offset = 0;
|
|
block->size = i == file_end ? inode->data & (block_size - 1) :
|
|
block_size;
|
|
if(block_list[i] == 0) /* sparse block */
|
|
block->buffer = NULL;
|
|
else {
|
|
block->buffer = cache_get(data_cache, start,
|
|
block_list[i]);
|
|
start += c_byte;
|
|
}
|
|
queue_put(to_writer, block);
|
|
}
|
|
|
|
if(inode->frag_bytes) {
|
|
int size;
|
|
long long start;
|
|
struct file_entry *block = malloc(sizeof(struct file_entry));
|
|
|
|
if(block == NULL)
|
|
EXIT_UNSQUASH("write_file: unable to malloc file\n");
|
|
s_ops->read_fragment(inode->fragment, &start, &size);
|
|
block->buffer = cache_get(fragment_cache, start, size);
|
|
block->offset = inode->offset;
|
|
block->size = inode->frag_bytes;
|
|
queue_put(to_writer, block);
|
|
}
|
|
|
|
free(block_list);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int create_inode(char *pathname, struct inode *i)
|
|
{
|
|
int res;
|
|
int failed = FALSE;
|
|
|
|
TRACE("create_inode: pathname %s\n", pathname);
|
|
|
|
if(created_inode[i->inode_number - 1]) {
|
|
TRACE("create_inode: hard link\n");
|
|
if(force)
|
|
unlink(pathname);
|
|
|
|
if(link(created_inode[i->inode_number - 1], pathname) == -1) {
|
|
EXIT_UNSQUASH_IGNORE("create_inode: failed to create hardlink, "
|
|
"because %s\n", strerror(errno));
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
switch(i->type) {
|
|
case SQUASHFS_FILE_TYPE:
|
|
case SQUASHFS_LREG_TYPE:
|
|
TRACE("create_inode: regular file, file_size %lld, "
|
|
"blocks %d\n", i->data, i->blocks);
|
|
|
|
res = write_file(i, pathname);
|
|
if(res == FALSE)
|
|
goto failed;
|
|
|
|
file_count ++;
|
|
break;
|
|
case SQUASHFS_SYMLINK_TYPE:
|
|
case SQUASHFS_LSYMLINK_TYPE: {
|
|
struct timespec times[2] = {
|
|
{ i->time, 0 },
|
|
{ i->time, 0 }
|
|
};
|
|
|
|
TRACE("create_inode: symlink, symlink_size %lld\n",
|
|
i->data);
|
|
|
|
if(force)
|
|
unlink(pathname);
|
|
|
|
res = symlink(i->symlink, pathname);
|
|
if(res == -1) {
|
|
EXIT_UNSQUASH_STRICT("create_inode: failed to create symlink "
|
|
"%s, because %s\n", pathname,
|
|
strerror(errno));
|
|
goto failed;
|
|
}
|
|
|
|
res = utimensat(AT_FDCWD, pathname, times,
|
|
AT_SYMLINK_NOFOLLOW);
|
|
if(res == -1) {
|
|
EXIT_UNSQUASH_STRICT("create_inode: failed to set time on "
|
|
"%s, because %s\n", pathname,
|
|
strerror(errno));
|
|
}
|
|
|
|
res = write_xattr(pathname, i->xattr);
|
|
if(res == FALSE)
|
|
failed = TRUE;
|
|
|
|
if(root_process) {
|
|
res = lchown(pathname, i->uid, i->gid);
|
|
if(res == -1) {
|
|
EXIT_UNSQUASH_STRICT("create_inode: failed to change "
|
|
"uid and gids on %s, because "
|
|
"%s\n", pathname,
|
|
strerror(errno));
|
|
failed = TRUE;
|
|
}
|
|
}
|
|
|
|
if(failed)
|
|
goto failed;
|
|
|
|
sym_count ++;
|
|
break;
|
|
}
|
|
case SQUASHFS_BLKDEV_TYPE:
|
|
case SQUASHFS_CHRDEV_TYPE:
|
|
case SQUASHFS_LBLKDEV_TYPE:
|
|
case SQUASHFS_LCHRDEV_TYPE: {
|
|
int chrdev = 0;
|
|
if ( i->type == SQUASHFS_CHRDEV_TYPE ||
|
|
i->type == SQUASHFS_LCHRDEV_TYPE)
|
|
chrdev = 1;
|
|
|
|
TRACE("create_inode: dev, rdev 0x%llx\n", i->data);
|
|
|
|
if(root_process) {
|
|
if(force)
|
|
unlink(pathname);
|
|
|
|
res = mknod(pathname, chrdev ? S_IFCHR : S_IFBLK,
|
|
makedev((i->data >> 8) & 0xff,
|
|
i->data & 0xff));
|
|
if(res == -1) {
|
|
EXIT_UNSQUASH_STRICT("create_inode: failed to create "
|
|
"%s device %s, because %s\n",
|
|
chrdev ? "character" : "block",
|
|
pathname, strerror(errno));
|
|
goto failed;
|
|
}
|
|
res = set_attributes(pathname, i->mode, i->uid,
|
|
i->gid, i->time, i->xattr, TRUE);
|
|
if(res == FALSE)
|
|
goto failed;
|
|
|
|
dev_count ++;
|
|
} else {
|
|
EXIT_UNSQUASH_STRICT("create_inode: could not create %s "
|
|
"device %s, because you're not "
|
|
"superuser!\n", chrdev ? "character" :
|
|
"block", pathname);
|
|
goto failed;
|
|
}
|
|
break;
|
|
}
|
|
case SQUASHFS_FIFO_TYPE:
|
|
case SQUASHFS_LFIFO_TYPE:
|
|
TRACE("create_inode: fifo\n");
|
|
|
|
if(force)
|
|
unlink(pathname);
|
|
|
|
res = mknod(pathname, S_IFIFO, 0);
|
|
if(res == -1) {
|
|
ERROR("create_inode: failed to create fifo %s, "
|
|
"because %s\n", pathname,
|
|
strerror(errno));
|
|
goto failed;
|
|
}
|
|
res = set_attributes(pathname, i->mode, i->uid, i->gid,
|
|
i->time, i->xattr, TRUE);
|
|
if(res == FALSE)
|
|
goto failed;
|
|
|
|
fifo_count ++;
|
|
break;
|
|
case SQUASHFS_SOCKET_TYPE:
|
|
case SQUASHFS_LSOCKET_TYPE:
|
|
TRACE("create_inode: socket\n");
|
|
ERROR("create_inode: socket %s ignored\n", pathname);
|
|
break;
|
|
default:
|
|
EXIT_UNSQUASH_STRICT("Unknown inode type %d in create_inode_table!\n",
|
|
i->type);
|
|
return FALSE;
|
|
}
|
|
|
|
created_inode[i->inode_number - 1] = strdup(pathname);
|
|
|
|
return TRUE;
|
|
|
|
failed:
|
|
/*
|
|
* Mark the file as created (even though it may not have been), so
|
|
* any future hard links to it fail with a file not found, which
|
|
* is correct as the file *is* missing.
|
|
*
|
|
* If we don't mark it here as created, then any future hard links will try
|
|
* to create the file as a separate unlinked file.
|
|
* If we've had some transitory errors, this may produce files
|
|
* in various states, which should be hard-linked, but are not.
|
|
*/
|
|
created_inode[i->inode_number - 1] = strdup(pathname);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void *read_directory_table(long long start, long long end)
|
|
{
|
|
int res;
|
|
long long bytes = 0;
|
|
long long size = 0;
|
|
void *directory_table = malloc(1);
|
|
|
|
TRACE("read_directory_table: start %lld, end %lld\n", start, end);
|
|
|
|
while(start < end) {
|
|
if(size - bytes < SQUASHFS_METADATA_SIZE) {
|
|
directory_table = realloc(directory_table, size +=
|
|
SQUASHFS_METADATA_SIZE);
|
|
if(directory_table == NULL) {
|
|
ERROR("Out of memory in "
|
|
"read_directory_table\n");
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
add_entry(directory_table_hash, start, bytes);
|
|
|
|
res = read_block(fd, start, &start, 0, directory_table + bytes);
|
|
if(res == 0) {
|
|
ERROR("read_directory_table: failed to read block\n");
|
|
goto failed;
|
|
}
|
|
|
|
bytes += res;
|
|
|
|
/*
|
|
* If this is not the last metadata block in the directory table
|
|
* then it should be SQUASHFS_METADATA_SIZE in size.
|
|
* Note, we can't use expected in read_block() above for this
|
|
* because we don't know if this is the last block until
|
|
* after reading.
|
|
*/
|
|
if(start != end && res != SQUASHFS_METADATA_SIZE) {
|
|
ERROR("read_directory_table: metadata block "
|
|
"should be %d bytes in length, it is %d "
|
|
"bytes\n", SQUASHFS_METADATA_SIZE, res);
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
return directory_table;
|
|
|
|
failed:
|
|
free(directory_table);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int squashfs_readdir(struct dir *dir, char **name, unsigned int *start_block,
|
|
unsigned int *offset, unsigned int *type)
|
|
{
|
|
if(dir->cur_entry == dir->dir_count)
|
|
return FALSE;
|
|
|
|
*name = dir->dirs[dir->cur_entry].name;
|
|
*start_block = dir->dirs[dir->cur_entry].start_block;
|
|
*offset = dir->dirs[dir->cur_entry].offset;
|
|
*type = dir->dirs[dir->cur_entry].type;
|
|
dir->cur_entry ++;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void squashfs_closedir(struct dir *dir)
|
|
{
|
|
free(dir->dirs);
|
|
free(dir);
|
|
}
|
|
|
|
|
|
char *get_component(char *target, char **targname)
|
|
{
|
|
char *start;
|
|
|
|
while(*target == '/')
|
|
target ++;
|
|
|
|
start = target;
|
|
while(*target != '/' && *target != '\0')
|
|
target ++;
|
|
|
|
*targname = strndup(start, target - start);
|
|
|
|
while(*target == '/')
|
|
target ++;
|
|
|
|
return target;
|
|
}
|
|
|
|
|
|
void free_path(struct pathname *paths)
|
|
{
|
|
int i;
|
|
|
|
for(i = 0; i < paths->names; i++) {
|
|
if(paths->name[i].paths)
|
|
free_path(paths->name[i].paths);
|
|
free(paths->name[i].name);
|
|
if(paths->name[i].preg) {
|
|
regfree(paths->name[i].preg);
|
|
free(paths->name[i].preg);
|
|
}
|
|
}
|
|
|
|
free(paths);
|
|
}
|
|
|
|
|
|
struct pathname *add_path(struct pathname *paths, char *target, char *alltarget)
|
|
{
|
|
char *targname;
|
|
int i, error;
|
|
|
|
TRACE("add_path: adding \"%s\" extract file\n", target);
|
|
|
|
target = get_component(target, &targname);
|
|
|
|
if(paths == NULL) {
|
|
paths = malloc(sizeof(struct pathname));
|
|
if(paths == NULL)
|
|
EXIT_UNSQUASH("failed to allocate paths\n");
|
|
|
|
paths->names = 0;
|
|
paths->name = NULL;
|
|
}
|
|
|
|
for(i = 0; i < paths->names; i++)
|
|
if(strcmp(paths->name[i].name, targname) == 0)
|
|
break;
|
|
|
|
if(i == paths->names) {
|
|
/*
|
|
* allocate new name entry
|
|
*/
|
|
paths->names ++;
|
|
paths->name = realloc(paths->name, (i + 1) *
|
|
sizeof(struct path_entry));
|
|
if(paths->name == NULL)
|
|
EXIT_UNSQUASH("Out of memory in add_path\n");
|
|
paths->name[i].name = targname;
|
|
paths->name[i].paths = NULL;
|
|
if(use_regex) {
|
|
paths->name[i].preg = malloc(sizeof(regex_t));
|
|
if(paths->name[i].preg == NULL)
|
|
EXIT_UNSQUASH("Out of memory in add_path\n");
|
|
error = regcomp(paths->name[i].preg, targname,
|
|
REG_EXTENDED|REG_NOSUB);
|
|
if(error) {
|
|
char str[1024]; /* overflow safe */
|
|
|
|
regerror(error, paths->name[i].preg, str, 1024);
|
|
EXIT_UNSQUASH("invalid regex %s in export %s, "
|
|
"because %s\n", targname, alltarget,
|
|
str);
|
|
}
|
|
} else
|
|
paths->name[i].preg = NULL;
|
|
|
|
if(target[0] == '\0')
|
|
/*
|
|
* at leaf pathname component
|
|
*/
|
|
paths->name[i].paths = NULL;
|
|
else
|
|
/*
|
|
* recurse adding child components
|
|
*/
|
|
paths->name[i].paths = add_path(NULL, target, alltarget);
|
|
} else {
|
|
/*
|
|
* existing matching entry
|
|
*/
|
|
free(targname);
|
|
|
|
if(paths->name[i].paths == NULL) {
|
|
/*
|
|
* No sub-directory which means this is the leaf
|
|
* component of a pre-existing extract which subsumes
|
|
* the extract currently being added, in which case stop
|
|
* adding components
|
|
*/
|
|
} else if(target[0] == '\0') {
|
|
/*
|
|
* at leaf pathname component and child components exist
|
|
* from more specific extracts, delete as they're
|
|
* subsumed by this extract
|
|
*/
|
|
free_path(paths->name[i].paths);
|
|
paths->name[i].paths = NULL;
|
|
} else
|
|
/*
|
|
* recurse adding child components
|
|
*/
|
|
add_path(paths->name[i].paths, target, alltarget);
|
|
}
|
|
|
|
return paths;
|
|
}
|
|
|
|
|
|
struct pathnames *init_subdir()
|
|
{
|
|
struct pathnames *new = malloc(sizeof(struct pathnames));
|
|
if(new == NULL)
|
|
EXIT_UNSQUASH("Out of memory in init_subdir\n");
|
|
new->count = 0;
|
|
return new;
|
|
}
|
|
|
|
|
|
struct pathnames *add_subdir(struct pathnames *paths, struct pathname *path)
|
|
{
|
|
if(paths->count % PATHS_ALLOC_SIZE == 0) {
|
|
paths = realloc(paths, sizeof(struct pathnames *) +
|
|
(paths->count + PATHS_ALLOC_SIZE) *
|
|
sizeof(struct pathname *));
|
|
if(paths == NULL)
|
|
EXIT_UNSQUASH("Out of memory in add_subdir\n");
|
|
}
|
|
|
|
paths->path[paths->count++] = path;
|
|
return paths;
|
|
}
|
|
|
|
|
|
void free_subdir(struct pathnames *paths)
|
|
{
|
|
free(paths);
|
|
}
|
|
|
|
|
|
int matches(struct pathnames *paths, char *name, struct pathnames **new)
|
|
{
|
|
int i, n;
|
|
|
|
if(paths == NULL) {
|
|
*new = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
*new = init_subdir();
|
|
|
|
for(n = 0; n < paths->count; n++) {
|
|
struct pathname *path = paths->path[n];
|
|
for(i = 0; i < path->names; i++) {
|
|
int match = use_regex ?
|
|
regexec(path->name[i].preg, name, (size_t) 0,
|
|
NULL, 0) == 0 : fnmatch(path->name[i].name,
|
|
name, FNM_PATHNAME|FNM_PERIOD|FNM_EXTMATCH) ==
|
|
0;
|
|
if(match && path->name[i].paths == NULL)
|
|
/*
|
|
* match on a leaf component, any subdirectories
|
|
* will implicitly match, therefore return an
|
|
* empty new search set
|
|
*/
|
|
goto empty_set;
|
|
|
|
if(match)
|
|
/*
|
|
* match on a non-leaf component, add any
|
|
* subdirectories to the new set of
|
|
* subdirectories to scan for this name
|
|
*/
|
|
*new = add_subdir(*new, path->name[i].paths);
|
|
}
|
|
}
|
|
|
|
if((*new)->count == 0) {
|
|
/*
|
|
* no matching names found, delete empty search set, and return
|
|
* FALSE
|
|
*/
|
|
free_subdir(*new);
|
|
*new = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* one or more matches with sub-directories found (no leaf matches),
|
|
* return new search set and return TRUE
|
|
*/
|
|
return TRUE;
|
|
|
|
empty_set:
|
|
/*
|
|
* found matching leaf exclude, return empty search set and return TRUE
|
|
*/
|
|
free_subdir(*new);
|
|
*new = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int pre_scan(char *parent_name, unsigned int start_block, unsigned int offset,
|
|
struct pathnames *paths)
|
|
{
|
|
unsigned int type;
|
|
int scan_res = TRUE;
|
|
char *name;
|
|
struct pathnames *new;
|
|
struct inode *i;
|
|
struct dir *dir = s_ops->opendir(start_block, offset, &i);
|
|
|
|
if(dir == NULL)
|
|
return FALSE;
|
|
|
|
while(squashfs_readdir(dir, &name, &start_block, &offset, &type)) {
|
|
struct inode *i;
|
|
char *pathname;
|
|
int res;
|
|
|
|
TRACE("pre_scan: name %s, start_block %d, offset %d, type %d\n",
|
|
name, start_block, offset, type);
|
|
|
|
if(!matches(paths, name, &new))
|
|
continue;
|
|
|
|
res = asprintf(&pathname, "%s/%s", parent_name, name);
|
|
if(res == -1)
|
|
EXIT_UNSQUASH("asprintf failed in dir_scan\n");
|
|
|
|
if(type == SQUASHFS_DIR_TYPE) {
|
|
res = pre_scan(parent_name, start_block, offset, new);
|
|
if(res == FALSE)
|
|
scan_res = FALSE;
|
|
} else if(new == NULL) {
|
|
if(type == SQUASHFS_FILE_TYPE ||
|
|
type == SQUASHFS_LREG_TYPE) {
|
|
i = s_ops->read_inode(start_block, offset);
|
|
if(created_inode[i->inode_number - 1] == NULL) {
|
|
created_inode[i->inode_number - 1] =
|
|
(char *) i;
|
|
total_blocks += (i->data +
|
|
(block_size - 1)) >> block_log;
|
|
}
|
|
total_files ++;
|
|
}
|
|
total_inodes ++;
|
|
}
|
|
|
|
free_subdir(new);
|
|
free(pathname);
|
|
}
|
|
|
|
squashfs_closedir(dir);
|
|
|
|
return scan_res;
|
|
}
|
|
|
|
|
|
int dir_scan(char *parent_name, unsigned int start_block, unsigned int offset,
|
|
struct pathnames *paths)
|
|
{
|
|
unsigned int type;
|
|
int scan_res = TRUE;
|
|
char *name;
|
|
struct pathnames *new;
|
|
struct inode *i;
|
|
struct dir *dir = s_ops->opendir(start_block, offset, &i);
|
|
|
|
if(dir == NULL) {
|
|
EXIT_UNSQUASH_IGNORE("dir_scan: failed to read directory %s\n",
|
|
parent_name);
|
|
return FALSE;
|
|
}
|
|
|
|
if((lsonly || info) && (!concise || dir->dir_count ==0))
|
|
print_filename(parent_name, i);
|
|
|
|
if(!lsonly) {
|
|
/*
|
|
* Make directory with default User rwx permissions rather than
|
|
* the permissions from the filesystem, as these may not have
|
|
* write/execute permission. These are fixed up later in
|
|
* set_attributes().
|
|
*/
|
|
int res = mkdir(parent_name, S_IRUSR|S_IWUSR|S_IXUSR);
|
|
if(res == -1) {
|
|
/*
|
|
* Skip directory if mkdir fails, unless we're
|
|
* forcing and the error is -EEXIST
|
|
*/
|
|
if(!force || errno != EEXIST) {
|
|
EXIT_UNSQUASH_IGNORE("dir_scan: failed to make directory %s, "
|
|
"because %s\n", parent_name,
|
|
strerror(errno));
|
|
squashfs_closedir(dir);
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Try to change permissions of existing directory so
|
|
* that we can write to it
|
|
*/
|
|
res = chmod(parent_name, S_IRUSR|S_IWUSR|S_IXUSR);
|
|
if (res == -1) {
|
|
EXIT_UNSQUASH_IGNORE("dir_scan: failed to change permissions "
|
|
"for directory %s, because %s\n",
|
|
parent_name, strerror(errno));
|
|
squashfs_closedir(dir);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
while(squashfs_readdir(dir, &name, &start_block, &offset, &type)) {
|
|
char *pathname;
|
|
int res;
|
|
|
|
TRACE("dir_scan: name %s, start_block %d, offset %d, type %d\n",
|
|
name, start_block, offset, type);
|
|
|
|
|
|
if(!matches(paths, name, &new))
|
|
continue;
|
|
|
|
res = asprintf(&pathname, "%s/%s", parent_name, name);
|
|
if(res == -1)
|
|
EXIT_UNSQUASH("asprintf failed in dir_scan\n");
|
|
|
|
if(type == SQUASHFS_DIR_TYPE) {
|
|
res = dir_scan(pathname, start_block, offset, new);
|
|
if(res == FALSE)
|
|
scan_res = FALSE;
|
|
free(pathname);
|
|
} else if(new == NULL) {
|
|
update_info(pathname);
|
|
|
|
i = s_ops->read_inode(start_block, offset);
|
|
|
|
if(lsonly || info)
|
|
print_filename(pathname, i);
|
|
|
|
if(!lsonly) {
|
|
res = create_inode(pathname, i);
|
|
if(res == FALSE)
|
|
scan_res = FALSE;
|
|
}
|
|
|
|
if(i->type == SQUASHFS_SYMLINK_TYPE ||
|
|
i->type == SQUASHFS_LSYMLINK_TYPE)
|
|
free(i->symlink);
|
|
} else
|
|
free(pathname);
|
|
|
|
free_subdir(new);
|
|
}
|
|
|
|
if(!lsonly)
|
|
queue_dir(parent_name, dir);
|
|
|
|
squashfs_closedir(dir);
|
|
dir_count ++;
|
|
|
|
return scan_res;
|
|
}
|
|
|
|
|
|
void squashfs_stat(char *source)
|
|
{
|
|
time_t mkfs_time = (time_t) sBlk.s.mkfs_time;
|
|
struct tm *t = use_localtime ? localtime(&mkfs_time) : gmtime(&mkfs_time);
|
|
char *mkfs_str = asctime(t);
|
|
|
|
#if __BYTE_ORDER == __BIG_ENDIAN
|
|
printf("Found a valid %sSQUASHFS %d:%d superblock on %s.\n",
|
|
sBlk.s.s_major == 4 ? "" : swap ? "little endian " :
|
|
"big endian ", sBlk.s.s_major, sBlk.s.s_minor, source);
|
|
#else
|
|
printf("Found a valid %sSQUASHFS %d:%d superblock on %s.\n",
|
|
sBlk.s.s_major == 4 ? "" : swap ? "big endian " :
|
|
"little endian ", sBlk.s.s_major, sBlk.s.s_minor, source);
|
|
#endif
|
|
|
|
printf("Creation or last append time %s", mkfs_str ? mkfs_str :
|
|
"failed to get time\n");
|
|
printf("Filesystem size %llu bytes (%.2f Kbytes / %.2f Mbytes)\n",
|
|
sBlk.s.bytes_used, sBlk.s.bytes_used / 1024.0,
|
|
sBlk.s.bytes_used / (1024.0 * 1024.0));
|
|
|
|
if(sBlk.s.s_major == 4) {
|
|
printf("Compression %s\n", comp->name);
|
|
|
|
if(SQUASHFS_COMP_OPTS(sBlk.s.flags)) {
|
|
char buffer[SQUASHFS_METADATA_SIZE] __attribute__ ((aligned));
|
|
int bytes;
|
|
|
|
if(!comp->supported)
|
|
printf("\tCould not display compressor options, because %s compression is not supported\n",
|
|
comp->name);
|
|
else {
|
|
bytes = read_block(fd, sizeof(sBlk.s), NULL, 0, buffer);
|
|
if(bytes == 0) {
|
|
ERROR("Failed to read compressor options\n");
|
|
return;
|
|
}
|
|
|
|
compressor_display_options(comp, buffer, bytes);
|
|
}
|
|
}
|
|
}
|
|
|
|
printf("Block size %d\n", sBlk.s.block_size);
|
|
printf("Filesystem is %sexportable via NFS\n",
|
|
SQUASHFS_EXPORTABLE(sBlk.s.flags) ? "" : "not ");
|
|
printf("Inodes are %scompressed\n",
|
|
SQUASHFS_UNCOMPRESSED_INODES(sBlk.s.flags) ? "un" : "");
|
|
printf("Data is %scompressed\n",
|
|
SQUASHFS_UNCOMPRESSED_DATA(sBlk.s.flags) ? "un" : "");
|
|
|
|
if(sBlk.s.s_major >= 4)
|
|
printf("Uids/Gids (Id table) are %scompressed\n",
|
|
SQUASHFS_UNCOMPRESSED_INODES(sBlk.s.flags) ||
|
|
SQUASHFS_UNCOMPRESSED_IDS(sBlk.s.flags) ? "un" : "");
|
|
|
|
if(sBlk.s.s_major > 1) {
|
|
if(SQUASHFS_NO_FRAGMENTS(sBlk.s.flags))
|
|
printf("Fragments are not stored\n");
|
|
else {
|
|
printf("Fragments are %scompressed\n",
|
|
SQUASHFS_UNCOMPRESSED_FRAGMENTS(sBlk.s.flags) ?
|
|
"un" : "");
|
|
printf("Always-use-fragments option is %sspecified\n",
|
|
SQUASHFS_ALWAYS_FRAGMENTS(sBlk.s.flags) ? "" :
|
|
"not ");
|
|
}
|
|
}
|
|
|
|
if(sBlk.s.s_major == 4) {
|
|
if(SQUASHFS_NO_XATTRS(sBlk.s.flags))
|
|
printf("Xattrs are not stored\n");
|
|
else
|
|
printf("Xattrs are %scompressed\n",
|
|
SQUASHFS_UNCOMPRESSED_XATTRS(sBlk.s.flags) ?
|
|
"un" : "");
|
|
}
|
|
|
|
if(sBlk.s.s_major < 4)
|
|
printf("Check data is %spresent in the filesystem\n",
|
|
SQUASHFS_CHECK_DATA(sBlk.s.flags) ? "" :
|
|
"not ");
|
|
|
|
if(sBlk.s.s_major > 1)
|
|
printf("Duplicates are %sremoved\n",
|
|
SQUASHFS_DUPLICATES(sBlk.s.flags) ? "" : "not ");
|
|
else
|
|
printf("Duplicates are removed\n");
|
|
|
|
if(sBlk.s.s_major > 1)
|
|
printf("Number of fragments %d\n", sBlk.s.fragments);
|
|
|
|
printf("Number of inodes %d\n", sBlk.s.inodes);
|
|
|
|
if(sBlk.s.s_major == 4)
|
|
printf("Number of ids %d\n", sBlk.s.no_ids);
|
|
else {
|
|
printf("Number of uids %d\n", sBlk.no_uids);
|
|
printf("Number of gids %d\n", sBlk.no_guids);
|
|
}
|
|
|
|
TRACE("sBlk.s.inode_table_start 0x%llx\n", sBlk.s.inode_table_start);
|
|
TRACE("sBlk.s.directory_table_start 0x%llx\n",
|
|
sBlk.s.directory_table_start);
|
|
|
|
if(sBlk.s.s_major > 1)
|
|
TRACE("sBlk.s.fragment_table_start 0x%llx\n\n",
|
|
sBlk.s.fragment_table_start);
|
|
|
|
if(sBlk.s.s_major > 2)
|
|
TRACE("sBlk.s.lookup_table_start 0x%llx\n\n",
|
|
sBlk.s.lookup_table_start);
|
|
|
|
if(sBlk.s.s_major == 4) {
|
|
TRACE("sBlk.s.id_table_start 0x%llx\n", sBlk.s.id_table_start);
|
|
TRACE("sBlk.s.xattr_id_table_start 0x%llx\n",
|
|
sBlk.s.xattr_id_table_start);
|
|
} else {
|
|
TRACE("sBlk.uid_start 0x%llx\n", sBlk.uid_start);
|
|
TRACE("sBlk.guid_start 0x%llx\n", sBlk.guid_start);
|
|
}
|
|
}
|
|
|
|
|
|
int check_compression(struct compressor *comp)
|
|
{
|
|
int res, bytes = 0;
|
|
char buffer[SQUASHFS_METADATA_SIZE] __attribute__ ((aligned));
|
|
|
|
if(!comp->supported) {
|
|
ERROR("Filesystem uses %s compression, this is "
|
|
"unsupported by this version\n", comp->name);
|
|
ERROR("Decompressors available:\n");
|
|
display_compressors("", "");
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Read compression options from disk if present, and pass to
|
|
* the compressor to ensure we know how to decompress a filesystem
|
|
* compressed with these compression options.
|
|
*
|
|
* Note, even if there is no compression options we still call the
|
|
* compressor because some compression options may be mandatory
|
|
* for some compressors.
|
|
*/
|
|
if(SQUASHFS_COMP_OPTS(sBlk.s.flags)) {
|
|
bytes = read_block(fd, sizeof(sBlk.s), NULL, 0, buffer);
|
|
if(bytes == 0) {
|
|
ERROR("Failed to read compressor options\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
res = compressor_check_options(comp, sBlk.s.block_size, buffer, bytes);
|
|
|
|
return res != -1;
|
|
}
|
|
|
|
|
|
int read_super(char *source)
|
|
{
|
|
squashfs_super_block_3 sBlk_3;
|
|
struct squashfs_super_block sBlk_4;
|
|
|
|
/*
|
|
* Try to read a Squashfs 4 superblock
|
|
*/
|
|
read_fs_bytes(fd, SQUASHFS_START, sizeof(struct squashfs_super_block),
|
|
&sBlk_4);
|
|
swap = sBlk_4.s_magic != SQUASHFS_MAGIC;
|
|
SQUASHFS_INSWAP_SUPER_BLOCK(&sBlk_4);
|
|
|
|
if(sBlk_4.s_magic == SQUASHFS_MAGIC && sBlk_4.s_major == 4 &&
|
|
sBlk_4.s_minor == 0) {
|
|
read_filesystem_tables = read_filesystem_tables_4;
|
|
memcpy(&sBlk, &sBlk_4, sizeof(sBlk_4));
|
|
|
|
/*
|
|
* Check the compression type
|
|
*/
|
|
comp = lookup_compressor_id(sBlk.s.compression);
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Not a Squashfs 4 superblock, try to read a squashfs 3 superblock
|
|
* (compatible with 1 and 2 filesystems)
|
|
*/
|
|
read_fs_bytes(fd, SQUASHFS_START, sizeof(squashfs_super_block_3),
|
|
&sBlk_3);
|
|
|
|
/*
|
|
* Check it is a SQUASHFS superblock
|
|
*/
|
|
swap = 0;
|
|
if(sBlk_3.s_magic != SQUASHFS_MAGIC) {
|
|
if(sBlk_3.s_magic == SQUASHFS_MAGIC_SWAP) {
|
|
squashfs_super_block_3 sblk;
|
|
ERROR("Reading a different endian SQUASHFS filesystem "
|
|
"on %s\n", source);
|
|
SQUASHFS_SWAP_SUPER_BLOCK_3(&sblk, &sBlk_3);
|
|
memcpy(&sBlk_3, &sblk, sizeof(squashfs_super_block_3));
|
|
swap = 1;
|
|
} else {
|
|
ERROR("Can't find a SQUASHFS superblock on %s\n",
|
|
source);
|
|
goto failed_mount;
|
|
}
|
|
}
|
|
|
|
sBlk.s.s_magic = sBlk_3.s_magic;
|
|
sBlk.s.inodes = sBlk_3.inodes;
|
|
sBlk.s.mkfs_time = sBlk_3.mkfs_time;
|
|
sBlk.s.block_size = sBlk_3.block_size;
|
|
sBlk.s.fragments = sBlk_3.fragments;
|
|
sBlk.s.block_log = sBlk_3.block_log;
|
|
sBlk.s.flags = sBlk_3.flags;
|
|
sBlk.s.s_major = sBlk_3.s_major;
|
|
sBlk.s.s_minor = sBlk_3.s_minor;
|
|
sBlk.s.root_inode = sBlk_3.root_inode;
|
|
sBlk.s.bytes_used = sBlk_3.bytes_used;
|
|
sBlk.s.inode_table_start = sBlk_3.inode_table_start;
|
|
sBlk.s.directory_table_start = sBlk_3.directory_table_start;
|
|
sBlk.s.fragment_table_start = sBlk_3.fragment_table_start;
|
|
sBlk.s.lookup_table_start = sBlk_3.lookup_table_start;
|
|
sBlk.no_uids = sBlk_3.no_uids;
|
|
sBlk.no_guids = sBlk_3.no_guids;
|
|
sBlk.uid_start = sBlk_3.uid_start;
|
|
sBlk.guid_start = sBlk_3.guid_start;
|
|
sBlk.s.xattr_id_table_start = SQUASHFS_INVALID_BLK;
|
|
|
|
/* Check the MAJOR & MINOR versions */
|
|
if(sBlk.s.s_major == 1 || sBlk.s.s_major == 2) {
|
|
sBlk.s.bytes_used = sBlk_3.bytes_used_2;
|
|
sBlk.uid_start = sBlk_3.uid_start_2;
|
|
sBlk.guid_start = sBlk_3.guid_start_2;
|
|
sBlk.s.inode_table_start = sBlk_3.inode_table_start_2;
|
|
sBlk.s.directory_table_start = sBlk_3.directory_table_start_2;
|
|
|
|
if(sBlk.s.s_major == 1) {
|
|
sBlk.s.block_size = sBlk_3.block_size_1;
|
|
sBlk.s.fragment_table_start = sBlk.uid_start;
|
|
read_filesystem_tables = read_filesystem_tables_1;
|
|
} else {
|
|
sBlk.s.fragment_table_start =
|
|
sBlk_3.fragment_table_start_2;
|
|
read_filesystem_tables = read_filesystem_tables_2;
|
|
}
|
|
} else if(sBlk.s.s_major == 3) {
|
|
read_filesystem_tables = read_filesystem_tables_3;
|
|
} else {
|
|
ERROR("Filesystem on %s is (%d:%d), ", source, sBlk.s.s_major,
|
|
sBlk.s.s_minor);
|
|
ERROR("which is a later filesystem version than I support!\n");
|
|
goto failed_mount;
|
|
}
|
|
|
|
/*
|
|
* 1.x, 2.x and 3.x filesystems use gzip compression.
|
|
*/
|
|
comp = lookup_compressor("gzip");
|
|
return TRUE;
|
|
|
|
failed_mount:
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
struct pathname *process_extract_files(struct pathname *path, char *filename)
|
|
{
|
|
FILE *fd;
|
|
char buffer[MAX_LINE + 1]; /* overflow safe */
|
|
char *name;
|
|
|
|
fd = fopen(filename, "r");
|
|
if(fd == NULL)
|
|
EXIT_UNSQUASH("Failed to open extract file \"%s\" because %s\n",
|
|
filename, strerror(errno));
|
|
|
|
while(fgets(name = buffer, MAX_LINE + 1, fd) != NULL) {
|
|
int len = strlen(name);
|
|
|
|
if(len == MAX_LINE && name[len - 1] != '\n')
|
|
/* line too large */
|
|
EXIT_UNSQUASH("Line too long when reading "
|
|
"extract file \"%s\", larger than %d "
|
|
"bytes\n", filename, MAX_LINE);
|
|
|
|
/*
|
|
* Remove '\n' terminator if it exists (the last line
|
|
* in the file may not be '\n' terminated)
|
|
*/
|
|
if(len && name[len - 1] == '\n')
|
|
name[len - 1] = '\0';
|
|
|
|
/* Skip any leading whitespace */
|
|
while(isspace(*name))
|
|
name ++;
|
|
|
|
/* if comment line, skip */
|
|
if(*name == '#')
|
|
continue;
|
|
|
|
/* check for initial backslash, to accommodate
|
|
* filenames with leading space or leading # character
|
|
*/
|
|
if(*name == '\\')
|
|
name ++;
|
|
|
|
/* if line is now empty after skipping characters, skip it */
|
|
if(*name == '\0')
|
|
continue;
|
|
|
|
path = add_path(path, name, name);
|
|
}
|
|
|
|
if(ferror(fd))
|
|
EXIT_UNSQUASH("Reading extract file \"%s\" failed because %s\n",
|
|
filename, strerror(errno));
|
|
|
|
fclose(fd);
|
|
return path;
|
|
}
|
|
|
|
|
|
/*
|
|
* reader thread. This thread processes read requests queued by the
|
|
* cache_get() routine.
|
|
*/
|
|
void *reader(void *arg)
|
|
{
|
|
while(1) {
|
|
struct cache_entry *entry = queue_get(to_reader);
|
|
int res = read_fs_bytes(fd, entry->block,
|
|
SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size),
|
|
entry->data);
|
|
|
|
if(res && SQUASHFS_COMPRESSED_BLOCK(entry->size))
|
|
/*
|
|
* queue successfully read block to the inflate
|
|
* thread(s) for further processing
|
|
*/
|
|
queue_put(to_inflate, entry);
|
|
else
|
|
/*
|
|
* block has either been successfully read and is
|
|
* uncompressed, or an error has occurred, clear pending
|
|
* flag, set error appropriately, and wake up any
|
|
* threads waiting on this buffer
|
|
*/
|
|
cache_block_ready(entry, !res);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* writer thread. This processes file write requests queued by the
|
|
* write_file() routine.
|
|
*/
|
|
void *writer(void *arg)
|
|
{
|
|
int i;
|
|
long failed = FALSE;
|
|
|
|
while(1) {
|
|
struct squashfs_file *file = queue_get(to_writer);
|
|
int file_fd;
|
|
long long hole = 0;
|
|
int res;
|
|
|
|
if(file == NULL) {
|
|
queue_put(from_writer, (void *) failed);
|
|
continue;
|
|
} else if(file->fd == -1) {
|
|
/* write attributes for directory file->pathname */
|
|
res = set_attributes(file->pathname, file->mode, file->uid,
|
|
file->gid, file->time, file->xattr, TRUE);
|
|
if(res == FALSE)
|
|
failed = TRUE;
|
|
free(file->pathname);
|
|
free(file);
|
|
continue;
|
|
}
|
|
|
|
TRACE("writer: regular file, blocks %d\n", file->blocks);
|
|
|
|
file_fd = file->fd;
|
|
|
|
for(i = 0; i < file->blocks; i++, cur_blocks ++) {
|
|
struct file_entry *block = queue_get(to_writer);
|
|
|
|
if(block->buffer == 0) { /* sparse file */
|
|
hole += block->size;
|
|
free(block);
|
|
continue;
|
|
}
|
|
|
|
cache_block_wait(block->buffer);
|
|
|
|
if(block->buffer->error) {
|
|
EXIT_UNSQUASH_IGNORE("writer: failed to read/uncompress file %s\n", file->pathname);
|
|
failed = TRUE;
|
|
}
|
|
|
|
if(failed)
|
|
continue;
|
|
|
|
res = write_block(file_fd, block->buffer->data +
|
|
block->offset, block->size, hole, file->sparse);
|
|
|
|
if(res == FALSE) {
|
|
EXIT_UNSQUASH_IGNORE("writer: failed to write file %s\n", file->pathname);
|
|
failed = TRUE;
|
|
}
|
|
|
|
hole = 0;
|
|
cache_block_put(block->buffer);
|
|
free(block);
|
|
}
|
|
|
|
if(hole && failed == FALSE) {
|
|
/*
|
|
* corner case for hole extending to end of file
|
|
*/
|
|
if(file->sparse == FALSE ||
|
|
lseek(file_fd, hole, SEEK_CUR) == -1) {
|
|
/*
|
|
* for files which we don't want to write
|
|
* sparsely, or for broken lseeks which cannot
|
|
* seek beyond end of file, write_block will do
|
|
* the right thing
|
|
*/
|
|
hole --;
|
|
if(write_block(file_fd, "\0", 1, hole,
|
|
file->sparse) == FALSE) {
|
|
EXIT_UNSQUASH_IGNORE("writer: failed to write sparse "
|
|
"data block for file %s\n", file->pathname);
|
|
failed = TRUE;
|
|
}
|
|
} else if(ftruncate(file_fd, file->file_size) == -1) {
|
|
EXIT_UNSQUASH_IGNORE("writer: failed to write sparse data "
|
|
"block for file %s\n", file->pathname);
|
|
failed = TRUE;
|
|
}
|
|
}
|
|
|
|
close_wake(file_fd);
|
|
if(failed == FALSE) {
|
|
res = set_attributes(file->pathname, file->mode, file->uid,
|
|
file->gid, file->time, file->xattr, force);
|
|
if(res == FALSE)
|
|
failed = TRUE;
|
|
} else
|
|
unlink(file->pathname);
|
|
free(file->pathname);
|
|
free(file);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* decompress thread. This decompresses buffers queued by the read thread
|
|
*/
|
|
void *inflator(void *arg)
|
|
{
|
|
char *tmp = malloc(block_size);
|
|
|
|
if(tmp == NULL)
|
|
EXIT_UNSQUASH("inflator: Failed to allocate block buffer\n");
|
|
|
|
while(1) {
|
|
struct cache_entry *entry = queue_get(to_inflate);
|
|
int error, res;
|
|
|
|
res = compressor_uncompress(comp, tmp, entry->data,
|
|
SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size), block_size,
|
|
&error);
|
|
|
|
if(res == -1)
|
|
ERROR("%s uncompress failed with error code %d\n",
|
|
comp->name, error);
|
|
else
|
|
memcpy(entry->data, tmp, res);
|
|
|
|
/*
|
|
* block has been either successfully decompressed, or an error
|
|
* occurred, clear pending flag, set error appropriately and
|
|
* wake up any threads waiting on this block
|
|
*/
|
|
cache_block_ready(entry, res == -1);
|
|
}
|
|
}
|
|
|
|
|
|
void *progress_thread(void *arg)
|
|
{
|
|
struct timespec requested_time, remaining;
|
|
struct itimerval itimerval;
|
|
struct winsize winsize;
|
|
|
|
if(ioctl(1, TIOCGWINSZ, &winsize) == -1) {
|
|
if(isatty(STDOUT_FILENO))
|
|
ERROR("TIOCGWINSZ ioctl failed, defaulting to 80 "
|
|
"columns\n");
|
|
columns = 80;
|
|
} else
|
|
columns = winsize.ws_col;
|
|
signal(SIGWINCH, sigwinch_handler);
|
|
signal(SIGALRM, sigalrm_handler);
|
|
|
|
itimerval.it_value.tv_sec = 0;
|
|
itimerval.it_value.tv_usec = 250000;
|
|
itimerval.it_interval.tv_sec = 0;
|
|
itimerval.it_interval.tv_usec = 250000;
|
|
setitimer(ITIMER_REAL, &itimerval, NULL);
|
|
|
|
requested_time.tv_sec = 0;
|
|
requested_time.tv_nsec = 250000000;
|
|
|
|
while(1) {
|
|
int res = nanosleep(&requested_time, &remaining);
|
|
|
|
if(res == -1 && errno != EINTR)
|
|
EXIT_UNSQUASH("nanosleep failed in progress thread\n");
|
|
|
|
if(progress_enabled) {
|
|
pthread_mutex_lock(&screen_mutex);
|
|
progress_bar(sym_count + dev_count +
|
|
fifo_count + cur_blocks, total_inodes -
|
|
total_files + total_blocks, columns);
|
|
pthread_mutex_unlock(&screen_mutex);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void initialise_threads(int fragment_buffer_size, int data_buffer_size)
|
|
{
|
|
struct rlimit rlim;
|
|
int i, max_files, res;
|
|
sigset_t sigmask, old_mask;
|
|
|
|
/* block SIGQUIT and SIGHUP, these are handled by the info thread */
|
|
sigemptyset(&sigmask);
|
|
sigaddset(&sigmask, SIGQUIT);
|
|
sigaddset(&sigmask, SIGHUP);
|
|
if(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) != 0)
|
|
EXIT_UNSQUASH("Failed to set signal mask in initialise_threads"
|
|
"\n");
|
|
|
|
/*
|
|
* temporarily block these signals so the created sub-threads will
|
|
* ignore them, ensuring the main thread handles them
|
|
*/
|
|
sigemptyset(&sigmask);
|
|
sigaddset(&sigmask, SIGINT);
|
|
sigaddset(&sigmask, SIGTERM);
|
|
if(pthread_sigmask(SIG_BLOCK, &sigmask, &old_mask) != 0)
|
|
EXIT_UNSQUASH("Failed to set signal mask in initialise_threads"
|
|
"\n");
|
|
|
|
if(processors == -1) {
|
|
#ifndef linux
|
|
int mib[2];
|
|
size_t len = sizeof(processors);
|
|
|
|
mib[0] = CTL_HW;
|
|
#ifdef HW_AVAILCPU
|
|
mib[1] = HW_AVAILCPU;
|
|
#else
|
|
mib[1] = HW_NCPU;
|
|
#endif
|
|
|
|
if(sysctl(mib, 2, &processors, &len, NULL, 0) == -1) {
|
|
ERROR("Failed to get number of available processors. "
|
|
"Defaulting to 1\n");
|
|
processors = 1;
|
|
}
|
|
#else
|
|
processors = sysconf(_SC_NPROCESSORS_ONLN);
|
|
#endif
|
|
}
|
|
|
|
if(add_overflow(processors, 3) ||
|
|
multiply_overflow(processors + 3, sizeof(pthread_t)))
|
|
EXIT_UNSQUASH("Processors too large\n");
|
|
|
|
thread = malloc((3 + processors) * sizeof(pthread_t));
|
|
if(thread == NULL)
|
|
EXIT_UNSQUASH("Out of memory allocating thread descriptors\n");
|
|
inflator_thread = &thread[3];
|
|
|
|
/*
|
|
* dimensioning the to_reader and to_inflate queues. The size of
|
|
* these queues is directly related to the amount of block
|
|
* read-ahead possible. To_reader queues block read requests to
|
|
* the reader thread and to_inflate queues block decompression
|
|
* requests to the inflate thread(s) (once the block has been read by
|
|
* the reader thread). The amount of read-ahead is determined by
|
|
* the combined size of the data_block and fragment caches which
|
|
* determine the total number of blocks which can be "in flight"
|
|
* at any one time (either being read or being decompressed)
|
|
*
|
|
* The maximum file open limit, however, affects the read-ahead
|
|
* possible, in that for normal sizes of the fragment and data block
|
|
* caches, where the incoming files have few data blocks or one fragment
|
|
* only, the file open limit is likely to be reached before the
|
|
* caches are full. This means the worst case sizing of the combined
|
|
* sizes of the caches is unlikely to ever be necessary. However, is is
|
|
* obvious read-ahead up to the data block cache size is always possible
|
|
* irrespective of the file open limit, because a single file could
|
|
* contain that number of blocks.
|
|
*
|
|
* Choosing the size as "file open limit + data block cache size" seems
|
|
* to be a reasonable estimate. We can reasonably assume the maximum
|
|
* likely read-ahead possible is data block cache size + one fragment
|
|
* per open file.
|
|
*
|
|
* dimensioning the to_writer queue. The size of this queue is
|
|
* directly related to the amount of block read-ahead possible.
|
|
* However, unlike the to_reader and to_inflate queues, this is
|
|
* complicated by the fact the to_writer queue not only contains
|
|
* entries for fragments and data_blocks but it also contains
|
|
* file entries, one per open file in the read-ahead.
|
|
*
|
|
* Choosing the size as "2 * (file open limit) +
|
|
* data block cache size" seems to be a reasonable estimate.
|
|
* We can reasonably assume the maximum likely read-ahead possible
|
|
* is data block cache size + one fragment per open file, and then
|
|
* we will have a file_entry for each open file.
|
|
*/
|
|
res = getrlimit(RLIMIT_NOFILE, &rlim);
|
|
if (res == -1) {
|
|
ERROR("failed to get open file limit! Defaulting to 1\n");
|
|
rlim.rlim_cur = 1;
|
|
}
|
|
|
|
if (rlim.rlim_cur != RLIM_INFINITY) {
|
|
/*
|
|
* leave OPEN_FILE_MARGIN free (rlim_cur includes fds used by
|
|
* stdin, stdout, stderr and filesystem fd
|
|
*/
|
|
if (rlim.rlim_cur <= OPEN_FILE_MARGIN)
|
|
/* no margin, use minimum possible */
|
|
max_files = 1;
|
|
else
|
|
max_files = rlim.rlim_cur - OPEN_FILE_MARGIN;
|
|
} else
|
|
max_files = -1;
|
|
|
|
/* set amount of available files for use by open_wait and close_wake */
|
|
open_init(max_files);
|
|
|
|
/*
|
|
* allocate to_reader, to_inflate and to_writer queues. Set based on
|
|
* open file limit and cache size, unless open file limit is unlimited,
|
|
* in which case set purely based on cache limits
|
|
*
|
|
* In doing so, check that the user supplied values do not overflow
|
|
* a signed int
|
|
*/
|
|
if (max_files != -1) {
|
|
if(add_overflow(data_buffer_size, max_files) ||
|
|
add_overflow(data_buffer_size, max_files * 2))
|
|
EXIT_UNSQUASH("Data queue size is too large\n");
|
|
|
|
to_reader = queue_init(max_files + data_buffer_size);
|
|
to_inflate = queue_init(max_files + data_buffer_size);
|
|
to_writer = queue_init(max_files * 2 + data_buffer_size);
|
|
} else {
|
|
int all_buffers_size;
|
|
|
|
if(add_overflow(fragment_buffer_size, data_buffer_size))
|
|
EXIT_UNSQUASH("Data and fragment queues combined are"
|
|
" too large\n");
|
|
|
|
all_buffers_size = fragment_buffer_size + data_buffer_size;
|
|
|
|
if(add_overflow(all_buffers_size, all_buffers_size))
|
|
EXIT_UNSQUASH("Data and fragment queues combined are"
|
|
" too large\n");
|
|
|
|
to_reader = queue_init(all_buffers_size);
|
|
to_inflate = queue_init(all_buffers_size);
|
|
to_writer = queue_init(all_buffers_size * 2);
|
|
}
|
|
|
|
from_writer = queue_init(1);
|
|
|
|
fragment_cache = cache_init(block_size, fragment_buffer_size);
|
|
data_cache = cache_init(block_size, data_buffer_size);
|
|
pthread_create(&thread[0], NULL, reader, NULL);
|
|
pthread_create(&thread[1], NULL, writer, NULL);
|
|
pthread_create(&thread[2], NULL, progress_thread, NULL);
|
|
init_info();
|
|
pthread_mutex_init(&fragment_mutex, NULL);
|
|
|
|
for(i = 0; i < processors; i++) {
|
|
if(pthread_create(&inflator_thread[i], NULL, inflator, NULL) !=
|
|
0)
|
|
EXIT_UNSQUASH("Failed to create thread\n");
|
|
}
|
|
|
|
if(pthread_sigmask(SIG_SETMASK, &old_mask, NULL) != 0)
|
|
EXIT_UNSQUASH("Failed to set signal mask in initialise_threads"
|
|
"\n");
|
|
}
|
|
|
|
|
|
void enable_progress_bar()
|
|
{
|
|
pthread_mutex_lock(&screen_mutex);
|
|
progress_enabled = progress;
|
|
pthread_mutex_unlock(&screen_mutex);
|
|
}
|
|
|
|
|
|
void disable_progress_bar()
|
|
{
|
|
pthread_mutex_lock(&screen_mutex);
|
|
if(progress_enabled) {
|
|
progress_bar(sym_count + dev_count + fifo_count + cur_blocks,
|
|
total_inodes - total_files + total_blocks, columns);
|
|
printf("\n");
|
|
}
|
|
progress_enabled = FALSE;
|
|
pthread_mutex_unlock(&screen_mutex);
|
|
}
|
|
|
|
|
|
void progressbar_error(char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
pthread_mutex_lock(&screen_mutex);
|
|
|
|
if(progress_enabled)
|
|
fprintf(stderr, "\n");
|
|
|
|
va_start(ap, fmt);
|
|
vfprintf(stderr, fmt, ap);
|
|
va_end(ap);
|
|
|
|
pthread_mutex_unlock(&screen_mutex);
|
|
}
|
|
|
|
|
|
void progressbar_info(char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
pthread_mutex_lock(&screen_mutex);
|
|
|
|
if(progress_enabled)
|
|
printf("\n");
|
|
|
|
va_start(ap, fmt);
|
|
vprintf(fmt, ap);
|
|
va_end(ap);
|
|
|
|
pthread_mutex_unlock(&screen_mutex);
|
|
}
|
|
static int get_max_digits(long long max)
|
|
{
|
|
int digits = 0;
|
|
|
|
while (max > 10) {
|
|
max /= 10;
|
|
digits++;
|
|
}
|
|
|
|
return digits;
|
|
}
|
|
|
|
void progress_bar(long long current, long long max, int columns)
|
|
{
|
|
char rotate_list[] = { '|', '/', '-', '\\' };
|
|
int max_digits, used, hashes, spaces;
|
|
static int tty = -1;
|
|
|
|
if(max == 0)
|
|
return;
|
|
|
|
//max_digits = floor(log10(max)) + 1;
|
|
max_digits = get_max_digits(max) + 1;
|
|
used = max_digits * 2 + 11;
|
|
hashes = (current * (columns - used)) / max;
|
|
spaces = columns - used - hashes;
|
|
|
|
if((current > max) || (columns - used < 0))
|
|
return;
|
|
|
|
if(tty == -1)
|
|
tty = isatty(STDOUT_FILENO);
|
|
if(!tty) {
|
|
static long long previous = -1;
|
|
|
|
/*
|
|
* Updating much more frequently than this results in huge
|
|
* log files.
|
|
*/
|
|
if((current % 100) != 0 && current != max)
|
|
return;
|
|
/* Don't update just to rotate the spinner. */
|
|
if(current == previous)
|
|
return;
|
|
previous = current;
|
|
}
|
|
|
|
printf("\r[");
|
|
|
|
while (hashes --)
|
|
putchar('=');
|
|
|
|
putchar(rotate_list[rotate]);
|
|
|
|
while(spaces --)
|
|
putchar(' ');
|
|
|
|
printf("] %*lld/%*lld", max_digits, current, max_digits, max);
|
|
printf(" %3lld%%", current * 100 / max);
|
|
fflush(stdout);
|
|
}
|
|
|
|
|
|
int multiply_overflowll(long long a, int multiplier)
|
|
{
|
|
return (LLONG_MAX / multiplier) < a;
|
|
}
|
|
|
|
|
|
int parse_numberll(char *start, long long *res, int size)
|
|
{
|
|
char *end;
|
|
long long number;
|
|
|
|
errno = 0; /* To distinguish success/failure after call */
|
|
|
|
number = strtoll(start, &end, 10);
|
|
|
|
/*
|
|
* check for strtoll underflow or overflow in conversion, and other
|
|
* errors.
|
|
*/
|
|
if((errno == ERANGE && (number == LLONG_MIN || number == LLONG_MAX)) ||
|
|
(errno != 0 && number == 0))
|
|
return 0;
|
|
|
|
/* reject negative numbers as invalid */
|
|
if(number < 0)
|
|
return 0;
|
|
|
|
if(size) {
|
|
/*
|
|
* Check for multiplier and trailing junk.
|
|
* But first check that a number exists before the
|
|
* multiplier
|
|
*/
|
|
if(end == start)
|
|
return 0;
|
|
|
|
switch(end[0]) {
|
|
case 'g':
|
|
case 'G':
|
|
if(multiply_overflowll(number, 1073741824))
|
|
return 0;
|
|
number *= 1073741824;
|
|
|
|
if(end[1] != '\0')
|
|
/* trailing junk after multiplier, but
|
|
* allow it to be "bytes" */
|
|
if(strcmp(end + 1, "bytes"))
|
|
return 0;
|
|
|
|
break;
|
|
case 'm':
|
|
case 'M':
|
|
if(multiply_overflowll(number, 1048576))
|
|
return 0;
|
|
number *= 1048576;
|
|
|
|
if(end[1] != '\0')
|
|
/* trailing junk after multiplier, but
|
|
* allow it to be "bytes" */
|
|
if(strcmp(end + 1, "bytes"))
|
|
return 0;
|
|
|
|
break;
|
|
case 'k':
|
|
case 'K':
|
|
if(multiply_overflowll(number, 1024))
|
|
return 0;
|
|
number *= 1024;
|
|
|
|
if(end[1] != '\0')
|
|
/* trailing junk after multiplier, but
|
|
* allow it to be "bytes" */
|
|
if(strcmp(end + 1, "bytes"))
|
|
return 0;
|
|
|
|
break;
|
|
case '\0':
|
|
break;
|
|
default:
|
|
/* trailing junk after number */
|
|
return 0;
|
|
}
|
|
} else if(end[0] != '\0')
|
|
/* trailing junk after number */
|
|
return 0;
|
|
|
|
*res = number;
|
|
return 1;
|
|
}
|
|
|
|
|
|
int parse_number(char *start, int *res)
|
|
{
|
|
long long number;
|
|
|
|
if(!parse_numberll(start, &number, 0))
|
|
return 0;
|
|
|
|
/* check if long result will overflow signed int */
|
|
if(number > INT_MAX)
|
|
return 0;
|
|
|
|
*res = (int) number;
|
|
return 1;
|
|
}
|
|
|
|
|
|
int ventoy_parse_disk_map(void)
|
|
{
|
|
int len = 0;
|
|
|
|
debug("ventoy_parse_disk_map\n");
|
|
|
|
len = (int)lseek(fd, 0, SEEK_END);
|
|
lseek(fd, 0, SEEK_SET);
|
|
|
|
if (len < sizeof(fs_disk_map) + sizeof(fs_disk_region))
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
read(fd, &g_fs_disk_map, sizeof(fs_disk_map));
|
|
|
|
debug("diskname=<%s> filesize=<%llu> region_num=<%u>\n",
|
|
g_fs_disk_map.diskname, g_fs_disk_map.filesize, g_fs_region_num);
|
|
|
|
g_fs_region_num = (len - sizeof(fs_disk_map)) / sizeof(fs_disk_region);
|
|
g_fs_region_list = malloc(g_fs_region_num * sizeof(fs_disk_region));
|
|
read(fd, g_fs_region_list, g_fs_region_num * sizeof(fs_disk_region));
|
|
|
|
close(fd);
|
|
|
|
fd = open(g_fs_disk_map.diskname, O_RDONLY);
|
|
debug("ventoy_parse_disk_map end fd=%d\n", fd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
#define VERSION() \
|
|
printf("unsquashfs version 4.4 (2019/08/29)\n");\
|
|
printf("copyright (C) 2019 Phillip Lougher "\
|
|
"<phillip@squashfs.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[])
|
|
{
|
|
char *dest = "squashfs-root";
|
|
int i, stat_sys = FALSE, version = FALSE, mkfs_time_opt = FALSE;
|
|
int n;
|
|
struct pathnames *paths = NULL;
|
|
struct pathname *path = NULL;
|
|
int fragment_buffer_size = FRAGMENT_BUFFER_DEFAULT;
|
|
int data_buffer_size = DATA_BUFFER_DEFAULT;
|
|
long res;
|
|
int exit_code = 0;
|
|
|
|
pthread_mutex_init(&screen_mutex, NULL);
|
|
root_process = geteuid() == 0;
|
|
if(root_process)
|
|
umask(0);
|
|
|
|
for(i = 1; i < argc; i++) {
|
|
if(*argv[i] != '-')
|
|
break;
|
|
if(strcmp(argv[i], "-UTC") == 0)
|
|
use_localtime = FALSE;
|
|
else if (strcmp(argv[i], "-t") == 0)
|
|
return 0;
|
|
else if (strcmp(argv[i], "-v") == 0)
|
|
verbose = 1;
|
|
else if(strcmp(argv[i], "-strict-errors") == 0 ||
|
|
strcmp(argv[i], "-st") == 0)
|
|
strict_errors = TRUE;
|
|
else if(strcmp(argv[i], "-ignore-errors") == 0 ||
|
|
strcmp(argv[i], "-ig") == 0)
|
|
ignore_errors = TRUE;
|
|
else if(strcmp(argv[i], "-quiet") == 0 ||
|
|
strcmp(argv[i], "-q") == 0)
|
|
quiet = TRUE;
|
|
else if(strcmp(argv[i], "-version") == 0 ||
|
|
strcmp(argv[i], "-v") == 0) {
|
|
VERSION();
|
|
version = TRUE;
|
|
} else if(strcmp(argv[i], "-info") == 0 ||
|
|
strcmp(argv[i], "-i") == 0)
|
|
info = TRUE;
|
|
else if(strcmp(argv[i], "-ls") == 0 ||
|
|
strcmp(argv[i], "-l") == 0)
|
|
lsonly = TRUE;
|
|
else if(strcmp(argv[i], "-lc") == 0) {
|
|
lsonly = TRUE;
|
|
concise = TRUE;
|
|
} else if(strcmp(argv[i], "-no-progress") == 0 ||
|
|
strcmp(argv[i], "-n") == 0)
|
|
progress = FALSE;
|
|
else if(strcmp(argv[i], "-no-xattrs") == 0 ||
|
|
strcmp(argv[i], "-no") == 0)
|
|
no_xattrs = TRUE;
|
|
else if(strcmp(argv[i], "-xattrs") == 0 ||
|
|
strcmp(argv[i], "-x") == 0)
|
|
no_xattrs = FALSE;
|
|
else if(strcmp(argv[i], "-user-xattrs") == 0 ||
|
|
strcmp(argv[i], "-u") == 0) {
|
|
user_xattrs = TRUE;
|
|
no_xattrs = FALSE;
|
|
} else if(strcmp(argv[i], "-dest") == 0 ||
|
|
strcmp(argv[i], "-d") == 0) {
|
|
if(++i == argc) {
|
|
fprintf(stderr, "%s: -dest missing filename\n",
|
|
argv[0]);
|
|
exit(1);
|
|
}
|
|
dest = argv[i];
|
|
} else if(strcmp(argv[i], "-processors") == 0 ||
|
|
strcmp(argv[i], "-p") == 0) {
|
|
if((++i == argc) ||
|
|
!parse_number(argv[i],
|
|
&processors)) {
|
|
ERROR("%s: -processors missing or invalid "
|
|
"processor number\n", argv[0]);
|
|
exit(1);
|
|
}
|
|
if(processors < 1) {
|
|
ERROR("%s: -processors should be 1 or larger\n",
|
|
argv[0]);
|
|
exit(1);
|
|
}
|
|
} else if(strcmp(argv[i], "-data-queue") == 0 ||
|
|
strcmp(argv[i], "-da") == 0) {
|
|
if((++i == argc) ||
|
|
!parse_number(argv[i],
|
|
&data_buffer_size)) {
|
|
ERROR("%s: -data-queue missing or invalid "
|
|
"queue size\n", argv[0]);
|
|
exit(1);
|
|
}
|
|
if(data_buffer_size < 1) {
|
|
ERROR("%s: -data-queue should be 1 Mbyte or "
|
|
"larger\n", argv[0]);
|
|
exit(1);
|
|
}
|
|
} else if(strcmp(argv[i], "-frag-queue") == 0 ||
|
|
strcmp(argv[i], "-fr") == 0) {
|
|
if((++i == argc) ||
|
|
!parse_number(argv[i],
|
|
&fragment_buffer_size)) {
|
|
ERROR("%s: -frag-queue missing or invalid "
|
|
"queue size\n", argv[0]);
|
|
exit(1);
|
|
}
|
|
if(fragment_buffer_size < 1) {
|
|
ERROR("%s: -frag-queue should be 1 Mbyte or "
|
|
"larger\n", argv[0]);
|
|
exit(1);
|
|
}
|
|
} else if(strcmp(argv[i], "-force") == 0 ||
|
|
strcmp(argv[i], "-f") == 0)
|
|
force = TRUE;
|
|
else if(strcmp(argv[i], "-stat") == 0 ||
|
|
strcmp(argv[i], "-s") == 0)
|
|
stat_sys = TRUE;
|
|
else if(strcmp(argv[i], "-mkfs-time") == 0 ||
|
|
strcmp(argv[i], "-fstime") == 0)
|
|
mkfs_time_opt = TRUE;
|
|
else if(strcmp(argv[i], "-lls") == 0 ||
|
|
strcmp(argv[i], "-ll") == 0) {
|
|
lsonly = TRUE;
|
|
short_ls = FALSE;
|
|
} else if(strcmp(argv[i], "-llnumeric") == 0 ||
|
|
strcmp(argv[i], "-lln") == 0) {
|
|
lsonly = TRUE;
|
|
short_ls = FALSE;
|
|
numeric = TRUE;
|
|
} else if(strcmp(argv[i], "-llc") == 0) {
|
|
lsonly = TRUE;
|
|
short_ls = FALSE;
|
|
concise = TRUE;
|
|
} else if(strcmp(argv[i], "-linfo") == 0 ||
|
|
strcmp(argv[i], "-li") == 0) {
|
|
info = TRUE;
|
|
short_ls = FALSE;
|
|
} else if(strcmp(argv[i], "-ef") == 0 ||
|
|
strcmp(argv[i], "-e") == 0) {
|
|
if(++i == argc) {
|
|
fprintf(stderr, "%s: -ef missing filename\n",
|
|
argv[0]);
|
|
exit(1);
|
|
}
|
|
path = process_extract_files(path, argv[i]);
|
|
} else if(strcmp(argv[i], "-regex") == 0 ||
|
|
strcmp(argv[i], "-r") == 0)
|
|
use_regex = TRUE;
|
|
else if(strcmp(argv[i], "-offset") == 0 || strcmp(argv[i], "-o") == 0) {
|
|
if((++i == argc) || !parse_numberll(argv[i], &start_offset, 1)) {
|
|
ERROR("%s: %s missing or invalid offset size\n", argv[0], argv[i - 1]);
|
|
exit(1);
|
|
}
|
|
} else
|
|
goto options;
|
|
}
|
|
|
|
if(lsonly || info)
|
|
progress = FALSE;
|
|
|
|
if(strict_errors && ignore_errors)
|
|
EXIT_UNSQUASH("Both -strict-errors and -ignore-errors should not be set\n");
|
|
|
|
#ifdef SQUASHFS_TRACE
|
|
/*
|
|
* Disable progress bar if full debug tracing is enabled.
|
|
* The progress bar in this case just gets in the way of the
|
|
* debug trace output
|
|
*/
|
|
progress = FALSE;
|
|
#endif
|
|
|
|
if(i == argc) {
|
|
if(!version) {
|
|
options:
|
|
ERROR("SYNTAX: %s [options] filesystem [directories or "
|
|
"files to extract]\n", argv[0]);
|
|
ERROR("\t-v[ersion]\t\tprint version, licence and "
|
|
"copyright information\n");
|
|
ERROR("\t-d[est] <pathname>\tunsquash to <pathname>, "
|
|
"default \"squashfs-root\"\n");
|
|
ERROR("\t-q[uiet]\t\tno verbose output\n");
|
|
ERROR("\t-n[o-progress]\t\tdon't display the progress "
|
|
"bar\n");
|
|
ERROR("\t-no[-xattrs]\t\tdon't extract xattrs in file system"
|
|
NOXOPT_STR"\n");
|
|
ERROR("\t-x[attrs]\t\textract xattrs in file system"
|
|
XOPT_STR "\n");
|
|
ERROR("\t-u[ser-xattrs]\t\tonly extract user xattrs in "
|
|
"file system.\n\t\t\t\tEnables extracting "
|
|
"xattrs\n");
|
|
ERROR("\t-p[rocessors] <number>\tuse <number> "
|
|
"processors. By default will use\n");
|
|
ERROR("\t\t\t\tnumber of processors available\n");
|
|
ERROR("\t-i[nfo]\t\t\tprint files as they are "
|
|
"unsquashed\n");
|
|
ERROR("\t-li[nfo]\t\tprint files as they are "
|
|
"unsquashed with file\n");
|
|
ERROR("\t\t\t\tattributes (like ls -l output)\n");
|
|
ERROR("\t-l[s]\t\t\tlist filesystem, but don't unsquash"
|
|
"\n");
|
|
ERROR("\t-ll[s]\t\t\tlist filesystem with file "
|
|
"attributes (like\n");
|
|
ERROR("\t\t\t\tls -l output), but don't unsquash\n");
|
|
ERROR("\t-lln[umeric]\t\t-lls but with numeric uids and gids\n");
|
|
ERROR("\t-lc\t\t\tlist filesystem concisely, displaying only"
|
|
" files\n\t\t\t\tand empty directories. Don't unsquash\n");
|
|
ERROR("\t-llc\t\t\tlist filesystem concisely with file attributes,"
|
|
"\n\t\t\t\tdisplaying only files and empty directories.\n\t\t\t\tDon't unsquash\n");
|
|
ERROR("\t-o[ffset] <bytes>\tskip <bytes> at start of <dest>\n");
|
|
ERROR("\t\t\t\tOptionally a suffix of K, M or G can be"
|
|
" given to specify\n\t\t\t\tKbytes, Mbytes or"
|
|
" Gbytes respectively.\n");
|
|
ERROR("\t\t\t\tDefault 0 bytes.\n");
|
|
ERROR("\t-f[orce]\t\tif file already exists then "
|
|
"overwrite\n");
|
|
ERROR("\t-ig[nore-errors]\tTreat errors writing files "
|
|
"to output as non-fatal\n");
|
|
ERROR("\t-st[rict-errors]\tTreat all errors as fatal\n");
|
|
ERROR("\t-s[tat]\t\t\tdisplay filesystem superblock "
|
|
"information\n");
|
|
ERROR("\t-UTC\t\t\tUse UTC rather than local time zone when displaying time\n");
|
|
ERROR("\t-mkfs-time\t\tdisplay filesystem superblock time\n");
|
|
ERROR("\t-fstime\t\t\tsynonym for -mkfs-time\n");
|
|
ERROR("\t-e[f] <extract file>\tlist of directories or "
|
|
"files to extract.\n\t\t\t\tOne per line\n");
|
|
ERROR("\t-da[ta-queue] <size>\tSet data queue to "
|
|
"<size> Mbytes. Default %d\n\t\t\t\tMbytes\n",
|
|
DATA_BUFFER_DEFAULT);
|
|
ERROR("\t-fr[ag-queue] <size>\tSet fragment queue to "
|
|
"<size> Mbytes. Default\n\t\t\t\t%d Mbytes\n",
|
|
FRAGMENT_BUFFER_DEFAULT);
|
|
ERROR("\t-r[egex]\t\ttreat extract names as POSIX "
|
|
"regular expressions\n");
|
|
ERROR("\t\t\t\trather than use the default shell "
|
|
"wildcard\n\t\t\t\texpansion (globbing)\n");
|
|
ERROR("\nDecompressors available:\n");
|
|
display_compressors("", "");
|
|
}
|
|
exit(1);
|
|
}
|
|
|
|
for(n = i + 1; n < argc; n++)
|
|
path = add_path(path, argv[n], argv[n]);
|
|
|
|
if((fd = open(argv[i], O_RDONLY)) == -1) {
|
|
ERROR("Could not open %s, because %s\n", argv[i],
|
|
strerror(errno));
|
|
exit(1);
|
|
}
|
|
|
|
ventoy_parse_disk_map();
|
|
|
|
if(read_super(argv[i]) == FALSE)
|
|
exit(1);
|
|
|
|
if(mkfs_time_opt) {
|
|
printf("%u\n", sBlk.s.mkfs_time);
|
|
exit(0);
|
|
}
|
|
|
|
if(stat_sys) {
|
|
squashfs_stat(argv[i]);
|
|
exit(0);
|
|
}
|
|
|
|
if(!check_compression(comp))
|
|
exit(1);
|
|
|
|
block_size = sBlk.s.block_size;
|
|
block_log = sBlk.s.block_log;
|
|
|
|
/*
|
|
* Sanity check block size and block log.
|
|
*
|
|
* Check they're within correct limits
|
|
*/
|
|
if(block_size > SQUASHFS_FILE_MAX_SIZE ||
|
|
block_log > SQUASHFS_FILE_MAX_LOG)
|
|
EXIT_UNSQUASH("Block size or block_log too large."
|
|
" File system is corrupt.\n");
|
|
|
|
/*
|
|
* Check block_size and block_log match
|
|
*/
|
|
if(block_size != (1 << block_log))
|
|
EXIT_UNSQUASH("Block size and block_log do not match."
|
|
" File system is corrupt.\n");
|
|
|
|
/*
|
|
* convert from queue size in Mbytes to queue size in
|
|
* blocks.
|
|
*
|
|
* In doing so, check that the user supplied values do not
|
|
* overflow a signed int
|
|
*/
|
|
if(shift_overflow(fragment_buffer_size, 20 - block_log))
|
|
EXIT_UNSQUASH("Fragment queue size is too large\n");
|
|
else
|
|
fragment_buffer_size <<= 20 - block_log;
|
|
|
|
if(shift_overflow(data_buffer_size, 20 - block_log))
|
|
EXIT_UNSQUASH("Data queue size is too large\n");
|
|
else
|
|
data_buffer_size <<= 20 - block_log;
|
|
|
|
initialise_threads(fragment_buffer_size, data_buffer_size);
|
|
|
|
created_inode = malloc(sBlk.s.inodes * sizeof(char *));
|
|
if(created_inode == NULL)
|
|
EXIT_UNSQUASH("failed to allocate created_inode\n");
|
|
|
|
memset(created_inode, 0, sBlk.s.inodes * sizeof(char *));
|
|
|
|
s_ops = read_filesystem_tables();
|
|
if(s_ops == NULL)
|
|
EXIT_UNSQUASH("failed to read file system tables\n");
|
|
|
|
if(path) {
|
|
paths = init_subdir();
|
|
paths = add_subdir(paths, path);
|
|
}
|
|
|
|
if(!quiet || progress) {
|
|
res = pre_scan(dest, SQUASHFS_INODE_BLK(sBlk.s.root_inode),
|
|
SQUASHFS_INODE_OFFSET(sBlk.s.root_inode), paths);
|
|
if(res == FALSE)
|
|
exit_code = 1;
|
|
|
|
memset(created_inode, 0, sBlk.s.inodes * sizeof(char *));
|
|
inode_number = 1;
|
|
|
|
if(!quiet) {
|
|
printf("Parallel unsquashfs: Using %d processor%s\n", processors,
|
|
processors == 1 ? "" : "s");
|
|
|
|
printf("%d inodes (%d blocks) to write\n\n", total_inodes,
|
|
total_inodes - total_files + total_blocks);
|
|
}
|
|
|
|
enable_progress_bar();
|
|
}
|
|
|
|
res = dir_scan(dest, SQUASHFS_INODE_BLK(sBlk.s.root_inode),
|
|
SQUASHFS_INODE_OFFSET(sBlk.s.root_inode), paths);
|
|
if(res == FALSE)
|
|
exit_code = 1;
|
|
|
|
queue_put(to_writer, NULL);
|
|
res = (long) queue_get(from_writer);
|
|
if(res == TRUE)
|
|
exit_code = 1;
|
|
|
|
disable_progress_bar();
|
|
|
|
if(!quiet && !lsonly) {
|
|
printf("\n");
|
|
printf("created %d files\n", file_count);
|
|
printf("created %d directories\n", dir_count);
|
|
printf("created %d symlinks\n", sym_count);
|
|
printf("created %d devices\n", dev_count);
|
|
printf("created %d fifos\n", fifo_count);
|
|
}
|
|
|
|
close(fd);
|
|
|
|
return exit_code;
|
|
}
|