int read_block(long long start, long long *next, char *block, squashfs_super_block *sBlk)
{
unsigned short c_byte;
int offset = 2;
if(swap) {
if(read_bytes(start, 2, block) == FALSE)
goto failed;
((unsigned char *) &c_byte)[1] = block[0];
((unsigned char *) &c_byte)[0] = block[1];
} else
if(read_bytes(start, 2, (char *)&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->flags))
offset = 3;
if(SQUASHFS_COMPRESSED(c_byte)) {
char buffer[SQUASHFS_METADATA_SIZE];
int res;
unsigned long bytes = SQUASHFS_METADATA_SIZE;
c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
if(read_bytes(start + offset, c_byte, buffer) == FALSE)
goto failed;
if((res = uncompress((unsigned char *) block, &bytes, (const unsigned char *) buffer, c_byte)) != Z_OK) {
if(res == Z_MEM_ERROR)
ERROR("zlib::uncompress failed, not enough memory\n");
else if(res == Z_BUF_ERROR)
ERROR("zlib::uncompress failed, not enough room in output buffer\n");
else {
ERROR("zlib::uncompress failed, unknown error %d\n", res);
exit(1);
}
goto failed;
}
if(next)
*next = start + offset + c_byte;
return bytes;
} else {
c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
if(read_bytes(start + offset, c_byte, block) == FALSE)
goto failed;
if(next)
*next = start + offset + c_byte;
return c_byte;
}
failed:
return FALSE;
}
int read_block(int fd, long long start, long long *next, unsigned char *block, squashfs_super_block *sBlk)
{
unsigned short c_byte;
int offset = 2;
if(swap) {
read_bytes(fd, start, 2, (char *) block);
((unsigned char *) &c_byte)[1] = block[0];
((unsigned char *) &c_byte)[0] = block[1];
} else
read_bytes(fd, start, 2, (char *)&c_byte);
if(SQUASHFS_CHECK_DATA(sBlk->flags))
offset = 3;
if(SQUASHFS_COMPRESSED(c_byte)) {
char buffer[SQUASHFS_METADATA_SIZE];
int res;
unsigned long bytes = SQUASHFS_METADATA_SIZE;
c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
read_bytes(fd, start + offset, c_byte, buffer);
if(!lzma) {
if((res = uncompress(block, &bytes, (const unsigned char *) buffer, c_byte)) != Z_OK) {
if(res == Z_MEM_ERROR)
ERROR("zlib::uncompress failed, not enough memory\n");
else if(res == Z_BUF_ERROR)
ERROR("zlib::uncompress failed, not enough room in output buffer\n");
else
ERROR("zlib::uncompress failed, unknown error %d\n", res);
return 0;
}
}
/* lzma */
else {
if((res = LzmaUncompress(block, &bytes, buffer, c_byte)) != SZ_OK)
ERROR("LzmaUncompress: error (%d)\n", res);
}
if(next)
*next = start + offset + c_byte;
return bytes;
} else {
c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
read_bytes(fd, start + offset, c_byte, (char *) block);
if(next)
*next = start + offset + c_byte;
return c_byte;
}
}
long long write_xattrs()
{
unsigned short c_byte;
int i, avail_bytes;
char *datap = data_cache;
long long start_bytes = bytes;
struct squashfs_xattr_table header;
if(xattr_ids == 0)
return SQUASHFS_INVALID_BLK;
/*
* Move and compress cached uncompressed data into xattr table.
*/
while(cache_bytes) {
if((xattr_size - xattr_bytes) <
((SQUASHFS_METADATA_SIZE << 1)) + 2) {
xattr_table = realloc(xattr_table, xattr_size +
(SQUASHFS_METADATA_SIZE << 1) + 2);
if(xattr_table == NULL) {
goto failed;
}
xattr_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
}
avail_bytes = cache_bytes > SQUASHFS_METADATA_SIZE ?
SQUASHFS_METADATA_SIZE : cache_bytes;
c_byte = mangle(xattr_table + xattr_bytes + BLOCK_OFFSET, datap,
avail_bytes, SQUASHFS_METADATA_SIZE, noX, 0);
TRACE("Xattr block @ 0x%x, size %d\n", xattr_bytes, c_byte);
SQUASHFS_SWAP_SHORTS(&c_byte, xattr_table + xattr_bytes, 1);
xattr_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + BLOCK_OFFSET;
total_xattr_bytes += avail_bytes + BLOCK_OFFSET;
datap += avail_bytes;
cache_bytes -= avail_bytes;
}
/*
* Write compressed xattr table to file system
*/
write_destination(fd, bytes, xattr_bytes, (char *) xattr_table);
bytes += xattr_bytes;
/*
* Swap if necessary the xattr id table
*/
for(i = 0; i < xattr_ids; i++)
SQUASHFS_INSWAP_XATTR_ID(&xattr_id_table[i]);
header.xattr_ids = xattr_ids;
header.xattr_table_start = start_bytes;
SQUASHFS_INSWAP_XATTR_TABLE(&header);
return generic_write_table(xattr_ids * sizeof(struct squashfs_xattr_id),
(char *) xattr_id_table, sizeof(header), (char *) &header, 0);
failed:
ERROR("Out of memory in xattr_table reallocation!\n");
return -1;
}
static int read_metadata_block(const struct PkgData *pdata,
const long long start, long long *next,
void *buf, const size_t buf_size)
{
long long offset = start;
unsigned short c_byte;
int ret = read_fs_bytes(pdata->fd, offset, &c_byte, 2);
if (ret) {
goto failed;
}
offset += 2;
int csize = SQUASHFS_COMPRESSED_SIZE(c_byte);
TRACE("read_metadata_block: block @0x%llx, %d %s bytes\n", start, csize,
SQUASHFS_COMPRESSED(c_byte) ? "compressed" : "uncompressed");
ret = SQUASHFS_COMPRESSED(c_byte)
? read_compressed(pdata, offset, csize, buf, buf_size)
: read_uncompressed(pdata, offset, csize, buf, buf_size);
if (ret < 0) {
goto failed;
}
offset += csize;
if (next) *next = offset;
return ret;
failed:
ERROR("Failed to read metadata block @0x%llx\n", start);
return ret;
}
int read_block(int fd, long long start, long long *next, int expected,
void *block)
{
unsigned short c_byte;
int res, compressed;
int outlen = expected ? expected : SQUASHFS_METADATA_SIZE;
/* Read block size */
res = read_fs_bytes(fd, start, 2, &c_byte);
if(res == 0)
return 0;
SQUASHFS_INSWAP_SHORTS(&c_byte, 1);
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 0;
if(compressed) {
char buffer[c_byte];
int error;
res = read_fs_bytes(fd, start + 2, c_byte, buffer);
if(res == 0)
return 0;
res = compressor_uncompress(comp, block, buffer, c_byte,
outlen, &error);
if(res == -1) {
// CJH: Decompression errors are displayed elsewhere
//ERROR("%s uncompress failed with error code %d\n",
// comp->name, error);
return 0;
}
} else {
res = read_fs_bytes(fd, start + 2, c_byte, block);
if(res == 0)
return 0;
res = c_byte;
}
if(next)
*next = start + 2 + c_byte;
/*
* if expected, then check the (uncompressed) return data
* is of the expected size
*/
if(expected && expected != res)
return 0;
else
return res;
}
static void *get_xattr_space(unsigned int req_size, long long *disk)
{
int data_space;
unsigned short c_byte;
/*
* Move and compress cached uncompressed data into xattr table.
*/
while(cache_bytes >= SQUASHFS_METADATA_SIZE) {
if((xattr_size - xattr_bytes) <
((SQUASHFS_METADATA_SIZE << 1)) + 2) {
xattr_table = realloc(xattr_table, xattr_size +
(SQUASHFS_METADATA_SIZE << 1) + 2);
if(xattr_table == NULL) {
goto failed;
}
xattr_size += (SQUASHFS_METADATA_SIZE << 1) + 2;
}
c_byte = mangle(xattr_table + xattr_bytes + BLOCK_OFFSET,
data_cache, SQUASHFS_METADATA_SIZE,
SQUASHFS_METADATA_SIZE, noX, 0);
TRACE("Xattr block @ 0x%x, size %d\n", xattr_bytes, c_byte);
SQUASHFS_SWAP_SHORTS(&c_byte, xattr_table + xattr_bytes, 1);
xattr_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + BLOCK_OFFSET;
total_xattr_bytes += SQUASHFS_METADATA_SIZE + BLOCK_OFFSET;
memcpy(data_cache, data_cache + SQUASHFS_METADATA_SIZE,
cache_bytes - SQUASHFS_METADATA_SIZE);
cache_bytes -= SQUASHFS_METADATA_SIZE;
}
/*
* Ensure there's enough space in the uncompressed data cache
*/
data_space = cache_size - cache_bytes;
if(data_space < req_size) {
int realloc_size = req_size - data_space;
data_cache = realloc(data_cache, cache_size +
realloc_size);
if(data_cache == NULL) {
goto failed;
}
cache_size += realloc_size;
}
if(disk)
*disk = ((long long) xattr_bytes << 16) | cache_bytes;
cache_bytes += req_size;
return data_cache + cache_bytes - req_size;
failed:
ERROR("Out of memory in inode table reallocation!\n");
return NULL;
}
void read_block_list_1(unsigned int *block_list, char *block_ptr, int blocks)
{
unsigned short block_size;
int i;
TRACE("read_block_list: blocks %d\n", blocks);
for(i = 0; i < blocks; i++, block_ptr += 2) {
if(swap) {
unsigned short sblock_size;
memcpy(&sblock_size, block_ptr, sizeof(unsigned short));
SQUASHFS_SWAP_SHORTS_3((&block_size), &sblock_size, 1);
} else
memcpy(&block_size, block_ptr, sizeof(unsigned short));
block_list[i] = SQUASHFS_COMPRESSED_SIZE(block_size) |
(SQUASHFS_COMPRESSED(block_size) ? 0 :
SQUASHFS_COMPRESSED_BIT_BLOCK);
}
}
/*
* Read and decompress a metadata block or datablock. Length is non-zero
* if a datablock is being read (the size is stored elsewhere in the
* filesystem), otherwise the length is obtained from the first two bytes of
* the metadata block. A bit in the length field indicates if the block
* is stored uncompressed in the filesystem (usually because compression
* generated a larger block - this does occasionally happen with compression
* algorithms).
*/
int squashfs_read_data(struct super_block *sb, void **buffer, u64 index,
int length, u64 *next_index, int srclength, int pages)
{
struct squashfs_sb_info *msblk = sb->s_fs_info;
struct buffer_head **bh;
int offset = index & ((1 << msblk->devblksize_log2) - 1);
u64 cur_index = index >> msblk->devblksize_log2;
int bytes, compressed, b = 0, k = 0, page = 0, avail;
bh = kcalloc(((srclength + msblk->devblksize - 1)
>> msblk->devblksize_log2) + 1, sizeof(*bh), GFP_KERNEL);
if (bh == NULL)
return -ENOMEM;
if (length) {
/*
* Datablock.
*/
bytes = -offset;
compressed = SQUASHFS_COMPRESSED_BLOCK(length);
length = SQUASHFS_COMPRESSED_SIZE_BLOCK(length);
if (next_index)
*next_index = index + length;
TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n",
index, compressed ? "" : "un", length, srclength);
if (length < 0 || length > srclength ||
(index + length) > msblk->bytes_used)
goto read_failure;
for (b = 0; bytes < length; b++, cur_index++) {
bh[b] = sb_getblk(sb, cur_index);
if (bh[b] == NULL)
goto block_release;
bytes += msblk->devblksize;
}
ll_rw_block(READ, b, bh);
} else {
/*
* Metadata block.
*/
if ((index + 2) > msblk->bytes_used)
goto read_failure;
bh[0] = get_block_length(sb, &cur_index, &offset, &length);
if (bh[0] == NULL)
goto read_failure;
b = 1;
bytes = msblk->devblksize - offset;
compressed = SQUASHFS_COMPRESSED(length);
length = SQUASHFS_COMPRESSED_SIZE(length);
if (next_index)
*next_index = index + length + 2;
TRACE("Block @ 0x%llx, %scompressed size %d\n", index,
compressed ? "" : "un", length);
if (length < 0 || length > srclength ||
(index + length) > msblk->bytes_used)
goto block_release;
for (; bytes < length; b++) {
bh[b] = sb_getblk(sb, ++cur_index);
if (bh[b] == NULL)
goto block_release;
bytes += msblk->devblksize;
}
ll_rw_block(READ, b - 1, bh + 1);
}
if (compressed) {
length = squashfs_decompress(msblk, buffer, bh, b, offset,
length, srclength, pages);
if (length < 0)
goto read_failure;
} else {
/*
* Block is uncompressed.
*/
int i, in, pg_offset = 0;
for (i = 0; i < b; i++) {
wait_on_buffer(bh[i]);
if (!buffer_uptodate(bh[i]))
goto block_release;
}
for (bytes = length; k < b; k++) {
in = min(bytes, msblk->devblksize - offset);
bytes -= in;
while (in) {
if (pg_offset == PAGE_CACHE_SIZE) {
page++;
pg_offset = 0;
}
avail = min_t(int, in, PAGE_CACHE_SIZE -
pg_offset);
memcpy(buffer[page] + pg_offset,
bh[k]->b_data + offset, avail);
in -= avail;
pg_offset += avail;
offset += avail;
}
offset = 0;
put_bh(bh[k]);
}
}
kfree(bh);
return length;
block_release:
for (; k < b; k++)
put_bh(bh[k]);
read_failure:
ERROR("squashfs_read_data failed to read block 0x%llx\n",
(unsigned long long) index);
kfree(bh);
return -EIO;
}
} else
read_bytes(fd, start, 2, (char *)&c_byte);
if(SQUASHFS_CHECK_DATA(sBlk->flags))
offset = 3;
if(SQUASHFS_COMPRESSED(c_byte)) {
char buffer[SQUASHFS_METADATA_SIZE];
int res;
unsigned long bytes = SQUASHFS_METADATA_SIZE;
enum {Src, Dst};
struct sized_buf sbuf[] = {
{.buf = (void *)buffer},
{.buf = (void *)block, .sz = bytes}
};
c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
read_bytes(fd, start + offset, c_byte, buffer);
sbuf[Src].sz = c_byte;
res = sqlzma_un(&un, sbuf + Src, sbuf + Dst);
if (res)
abort();
bytes = un.un_reslen;
if(next)
*next = start + offset + c_byte;
return bytes;
} else {
c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
read_bytes(fd, start + offset, c_byte, (char *) block);
if(next)
*next = start + offset + c_byte;
