123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725 |
- // SPDX-License-Identifier: GPL-2.0
- /*
- * Copyright (C) 2020 Bootlin
- *
- * Author: Joao Marcos Costa <joaomarcos.costa@bootlin.com>
- *
- * sqfs.c: SquashFS filesystem implementation
- */
- #include <asm/unaligned.h>
- #include <errno.h>
- #include <fs.h>
- #include <linux/types.h>
- #include <linux/byteorder/little_endian.h>
- #include <linux/byteorder/generic.h>
- #include <memalign.h>
- #include <stdlib.h>
- #include <string.h>
- #include <squashfs.h>
- #include <part.h>
- #include "sqfs_decompressor.h"
- #include "sqfs_filesystem.h"
- #include "sqfs_utils.h"
- static struct squashfs_ctxt ctxt;
- static int sqfs_disk_read(__u32 block, __u32 nr_blocks, void *buf)
- {
- ulong ret;
- if (!ctxt.cur_dev)
- return -1;
- ret = blk_dread(ctxt.cur_dev, ctxt.cur_part_info.start + block,
- nr_blocks, buf);
- if (ret != nr_blocks)
- return -1;
- return ret;
- }
- static int sqfs_read_sblk(struct squashfs_super_block **sblk)
- {
- *sblk = malloc_cache_aligned(ctxt.cur_dev->blksz);
- if (!*sblk)
- return -ENOMEM;
- if (sqfs_disk_read(0, 1, *sblk) != 1) {
- free(*sblk);
- sblk = NULL;
- return -EINVAL;
- }
- return 0;
- }
- static int sqfs_count_tokens(const char *filename)
- {
- int token_count = 1, l;
- for (l = 1; l < strlen(filename); l++) {
- if (filename[l] == '/')
- token_count++;
- }
- /* Ignore trailing '/' in path */
- if (filename[strlen(filename) - 1] == '/')
- token_count--;
- if (!token_count)
- token_count = 1;
- return token_count;
- }
- /*
- * Calculates how many blocks are needed for the buffer used in sqfs_disk_read.
- * The memory section (e.g. inode table) start offset and its end (i.e. the next
- * table start) must be specified. It also calculates the offset from which to
- * start reading the buffer.
- */
- static int sqfs_calc_n_blks(__le64 start, __le64 end, u64 *offset)
- {
- u64 start_, table_size;
- table_size = le64_to_cpu(end) - le64_to_cpu(start);
- start_ = le64_to_cpu(start) / ctxt.cur_dev->blksz;
- *offset = le64_to_cpu(start) - (start_ * ctxt.cur_dev->blksz);
- return DIV_ROUND_UP(table_size + *offset, ctxt.cur_dev->blksz);
- }
- /*
- * Retrieves fragment block entry and returns true if the fragment block is
- * compressed
- */
- static int sqfs_frag_lookup(u32 inode_fragment_index,
- struct squashfs_fragment_block_entry *e)
- {
- u64 start, n_blks, src_len, table_offset, start_block;
- unsigned char *metadata_buffer, *metadata, *table;
- struct squashfs_fragment_block_entry *entries;
- struct squashfs_super_block *sblk = ctxt.sblk;
- unsigned long dest_len;
- int block, offset, ret;
- u16 header;
- metadata_buffer = NULL;
- entries = NULL;
- table = NULL;
- if (inode_fragment_index >= get_unaligned_le32(&sblk->fragments))
- return -EINVAL;
- start = get_unaligned_le64(&sblk->fragment_table_start) /
- ctxt.cur_dev->blksz;
- n_blks = sqfs_calc_n_blks(sblk->fragment_table_start,
- sblk->export_table_start,
- &table_offset);
- /* Allocate a proper sized buffer to store the fragment index table */
- table = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
- if (!table) {
- ret = -ENOMEM;
- goto out;
- }
- if (sqfs_disk_read(start, n_blks, table) < 0) {
- ret = -EINVAL;
- goto out;
- }
- block = SQFS_FRAGMENT_INDEX(inode_fragment_index);
- offset = SQFS_FRAGMENT_INDEX_OFFSET(inode_fragment_index);
- /*
- * Get the start offset of the metadata block that contains the right
- * fragment block entry
- */
- start_block = get_unaligned_le64(table + table_offset + block *
- sizeof(u64));
- start = start_block / ctxt.cur_dev->blksz;
- n_blks = sqfs_calc_n_blks(cpu_to_le64(start_block),
- sblk->fragment_table_start, &table_offset);
- metadata_buffer = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
- if (!metadata_buffer) {
- ret = -ENOMEM;
- goto out;
- }
- if (sqfs_disk_read(start, n_blks, metadata_buffer) < 0) {
- ret = -EINVAL;
- goto out;
- }
- /* Every metadata block starts with a 16-bit header */
- header = get_unaligned_le16(metadata_buffer + table_offset);
- metadata = metadata_buffer + table_offset + SQFS_HEADER_SIZE;
- if (!metadata || !header) {
- ret = -ENOMEM;
- goto out;
- }
- entries = malloc(SQFS_METADATA_BLOCK_SIZE);
- if (!entries) {
- ret = -ENOMEM;
- goto out;
- }
- if (SQFS_COMPRESSED_METADATA(header)) {
- src_len = SQFS_METADATA_SIZE(header);
- dest_len = SQFS_METADATA_BLOCK_SIZE;
- ret = sqfs_decompress(&ctxt, entries, &dest_len, metadata,
- src_len);
- if (ret) {
- ret = -EINVAL;
- goto out;
- }
- } else {
- memcpy(entries, metadata, SQFS_METADATA_SIZE(header));
- }
- *e = entries[offset];
- ret = SQFS_COMPRESSED_BLOCK(e->size);
- out:
- free(entries);
- free(metadata_buffer);
- free(table);
- return ret;
- }
- /*
- * The entry name is a flexible array member, and we don't know its size before
- * actually reading the entry. So we need a first copy to retrieve this size so
- * we can finally copy the whole struct.
- */
- static int sqfs_read_entry(struct squashfs_directory_entry **dest, void *src)
- {
- struct squashfs_directory_entry *tmp;
- u16 sz;
- tmp = src;
- sz = get_unaligned_le16(src + sizeof(*tmp) - sizeof(u16));
- /*
- * 'src' points to the begin of a directory entry, and 'sz' gets its
- * 'name_size' member's value. name_size is actually the string
- * length - 1, so adding 2 compensates this difference and adds space
- * for the trailling null byte.
- */
- *dest = malloc(sizeof(*tmp) + sz + 2);
- if (!*dest)
- return -ENOMEM;
- memcpy(*dest, src, sizeof(*tmp) + sz + 1);
- (*dest)->name[sz + 1] = '\0';
- return 0;
- }
- static int sqfs_get_tokens_length(char **tokens, int count)
- {
- int length = 0, i;
- /*
- * 1 is added to the result of strlen to consider the slash separator
- * between the tokens.
- */
- for (i = 0; i < count; i++)
- length += strlen(tokens[i]) + 1;
- return length;
- }
- /* Takes a token list and returns a single string with '/' as separator. */
- static char *sqfs_concat_tokens(char **token_list, int token_count)
- {
- char *result;
- int i, length = 0, offset = 0;
- length = sqfs_get_tokens_length(token_list, token_count);
- result = malloc(length + 1);
- if (!result)
- return NULL;
- result[length] = '\0';
- for (i = 0; i < token_count; i++) {
- strcpy(result + offset, token_list[i]);
- offset += strlen(token_list[i]);
- result[offset++] = '/';
- }
- return result;
- }
- /*
- * Differently from sqfs_concat_tokens, sqfs_join writes the result into a
- * previously allocated string, and returns the number of bytes written.
- */
- static int sqfs_join(char **strings, char *dest, int start, int end,
- char separator)
- {
- int i, offset = 0;
- for (i = start; i < end; i++) {
- strcpy(dest + offset, strings[i]);
- offset += strlen(strings[i]);
- if (i < end - 1)
- dest[offset++] = separator;
- }
- return offset;
- }
- /*
- * Fills the given token list using its size (count) and a source string (str)
- */
- static int sqfs_tokenize(char **tokens, int count, const char *str)
- {
- int i, j, ret = 0;
- char *aux, *strc;
- strc = strdup(str);
- if (!strc)
- return -ENOMEM;
- if (!strcmp(strc, "/")) {
- tokens[0] = strdup(strc);
- if (!tokens[0]) {
- ret = -ENOMEM;
- goto free_strc;
- }
- } else {
- for (j = 0; j < count; j++) {
- aux = strtok(!j ? strc : NULL, "/");
- tokens[j] = strdup(aux);
- if (!tokens[j]) {
- for (i = 0; i < j; i++)
- free(tokens[i]);
- ret = -ENOMEM;
- goto free_strc;
- }
- }
- }
- free_strc:
- free(strc);
- return ret;
- }
- /*
- * Remove last 'updir + 1' tokens from the base path tokens list. This leaves us
- * with a token list containing only the tokens needed to form the resolved
- * path, and returns the decremented size of the token list.
- */
- static int sqfs_clean_base_path(char **base, int count, int updir)
- {
- int i;
- for (i = count - updir - 1; i < count; i++)
- free(base[i]);
- return count - updir - 1;
- }
- /*
- * Given the base ("current dir.") path and the relative one, generate the
- * absolute path.
- */
- static char *sqfs_get_abs_path(const char *base, const char *rel)
- {
- char **base_tokens, **rel_tokens, *resolved = NULL;
- int ret, bc, rc, i, updir = 0, resolved_size = 0, offset = 0;
- base_tokens = NULL;
- rel_tokens = NULL;
- /* Memory allocation for the token lists */
- bc = sqfs_count_tokens(base);
- rc = sqfs_count_tokens(rel);
- if (bc < 1 || rc < 1)
- return NULL;
- base_tokens = calloc(bc, sizeof(char *));
- if (!base_tokens)
- return NULL;
- rel_tokens = calloc(rc, sizeof(char *));
- if (!rel_tokens)
- goto out;
- /* Fill token lists */
- ret = sqfs_tokenize(base_tokens, bc, base);
- if (ret)
- goto out;
- ret = sqfs_tokenize(rel_tokens, rc, rel);
- if (ret)
- goto out;
- /* count '..' occurrences in target path */
- for (i = 0; i < rc; i++) {
- if (!strcmp(rel_tokens[i], ".."))
- updir++;
- }
- /* Remove the last token and the '..' occurrences */
- bc = sqfs_clean_base_path(base_tokens, bc, updir);
- if (bc < 0)
- goto out;
- /* Calculate resolved path size */
- if (!bc)
- resolved_size++;
- resolved_size += sqfs_get_tokens_length(base_tokens, bc) +
- sqfs_get_tokens_length(rel_tokens, rc);
- resolved = malloc(resolved_size + 1);
- if (!resolved)
- goto out;
- /* Set resolved path */
- memset(resolved, '\0', resolved_size + 1);
- offset += sqfs_join(base_tokens, resolved + offset, 0, bc, '/');
- resolved[offset++] = '/';
- offset += sqfs_join(rel_tokens, resolved + offset, updir, rc, '/');
- out:
- if (rel_tokens)
- for (i = 0; i < rc; i++)
- free(rel_tokens[i]);
- if (base_tokens)
- for (i = 0; i < bc; i++)
- free(base_tokens[i]);
- free(rel_tokens);
- free(base_tokens);
- return resolved;
- }
- static char *sqfs_resolve_symlink(struct squashfs_symlink_inode *sym,
- const char *base_path)
- {
- char *resolved, *target;
- u32 sz;
- sz = get_unaligned_le32(&sym->symlink_size);
- target = malloc(sz + 1);
- if (!target)
- return NULL;
- /*
- * There is no trailling null byte in the symlink's target path, so a
- * copy is made and a '\0' is added at its end.
- */
- target[sz] = '\0';
- /* Get target name (relative path) */
- strncpy(target, sym->symlink, sz);
- /* Relative -> absolute path conversion */
- resolved = sqfs_get_abs_path(base_path, target);
- free(target);
- return resolved;
- }
- /*
- * m_list contains each metadata block's position, and m_count is the number of
- * elements of m_list. Those metadata blocks come from the compressed directory
- * table.
- */
- static int sqfs_search_dir(struct squashfs_dir_stream *dirs, char **token_list,
- int token_count, u32 *m_list, int m_count)
- {
- struct squashfs_super_block *sblk = ctxt.sblk;
- char *path, *target, **sym_tokens, *res, *rem;
- int j, ret = 0, new_inode_number, offset;
- struct squashfs_symlink_inode *sym;
- struct squashfs_ldir_inode *ldir;
- struct squashfs_dir_inode *dir;
- struct fs_dir_stream *dirsp;
- struct fs_dirent *dent;
- unsigned char *table;
- res = NULL;
- rem = NULL;
- path = NULL;
- target = NULL;
- sym_tokens = NULL;
- dirsp = (struct fs_dir_stream *)dirs;
- /* Start by root inode */
- table = sqfs_find_inode(dirs->inode_table, le32_to_cpu(sblk->inodes),
- sblk->inodes, sblk->block_size);
- dir = (struct squashfs_dir_inode *)table;
- ldir = (struct squashfs_ldir_inode *)table;
- /* get directory offset in directory table */
- offset = sqfs_dir_offset(table, m_list, m_count);
- dirs->table = &dirs->dir_table[offset];
- /* Setup directory header */
- dirs->dir_header = malloc(SQFS_DIR_HEADER_SIZE);
- if (!dirs->dir_header)
- return -ENOMEM;
- memcpy(dirs->dir_header, dirs->table, SQFS_DIR_HEADER_SIZE);
- /* Initialize squashfs_dir_stream members */
- dirs->table += SQFS_DIR_HEADER_SIZE;
- dirs->size = get_unaligned_le16(&dir->file_size) - SQFS_DIR_HEADER_SIZE;
- dirs->entry_count = dirs->dir_header->count + 1;
- /* No path given -> root directory */
- if (!strcmp(token_list[0], "/")) {
- dirs->table = &dirs->dir_table[offset];
- memcpy(&dirs->i_dir, dir, sizeof(*dir));
- return 0;
- }
- for (j = 0; j < token_count; j++) {
- if (!sqfs_is_dir(get_unaligned_le16(&dir->inode_type))) {
- printf("** Cannot find directory. **\n");
- ret = -EINVAL;
- goto out;
- }
- while (!sqfs_readdir(dirsp, &dent)) {
- ret = strcmp(dent->name, token_list[j]);
- if (!ret)
- break;
- free(dirs->entry);
- dirs->entry = NULL;
- }
- if (ret) {
- printf("** Cannot find directory. **\n");
- ret = -EINVAL;
- goto out;
- }
- /* Redefine inode as the found token */
- new_inode_number = dirs->entry->inode_offset +
- dirs->dir_header->inode_number;
- /* Get reference to inode in the inode table */
- table = sqfs_find_inode(dirs->inode_table, new_inode_number,
- sblk->inodes, sblk->block_size);
- dir = (struct squashfs_dir_inode *)table;
- /* Check for symbolic link and inode type sanity */
- if (get_unaligned_le16(&dir->inode_type) == SQFS_SYMLINK_TYPE) {
- sym = (struct squashfs_symlink_inode *)table;
- /* Get first j + 1 tokens */
- path = sqfs_concat_tokens(token_list, j + 1);
- if (!path) {
- ret = -ENOMEM;
- goto out;
- }
- /* Resolve for these tokens */
- target = sqfs_resolve_symlink(sym, path);
- if (!target) {
- ret = -ENOMEM;
- goto out;
- }
- /* Join remaining tokens */
- rem = sqfs_concat_tokens(token_list + j + 1, token_count -
- j - 1);
- if (!rem) {
- ret = -ENOMEM;
- goto out;
- }
- /* Concatenate remaining tokens and symlink's target */
- res = malloc(strlen(rem) + strlen(target) + 1);
- if (!res) {
- ret = -ENOMEM;
- goto out;
- }
- strcpy(res, target);
- res[strlen(target)] = '/';
- strcpy(res + strlen(target) + 1, rem);
- token_count = sqfs_count_tokens(res);
- if (token_count < 0) {
- ret = -EINVAL;
- goto out;
- }
- sym_tokens = malloc(token_count * sizeof(char *));
- if (!sym_tokens) {
- ret = -EINVAL;
- goto out;
- }
- /* Fill tokens list */
- ret = sqfs_tokenize(sym_tokens, token_count, res);
- if (ret) {
- ret = -EINVAL;
- goto out;
- }
- free(dirs->entry);
- dirs->entry = NULL;
- ret = sqfs_search_dir(dirs, sym_tokens, token_count,
- m_list, m_count);
- goto out;
- } else if (!sqfs_is_dir(get_unaligned_le16(&dir->inode_type))) {
- printf("** Cannot find directory. **\n");
- free(dirs->entry);
- dirs->entry = NULL;
- ret = -EINVAL;
- goto out;
- }
- /* Check if it is an extended dir. */
- if (get_unaligned_le16(&dir->inode_type) == SQFS_LDIR_TYPE)
- ldir = (struct squashfs_ldir_inode *)table;
- /* Get dir. offset into the directory table */
- offset = sqfs_dir_offset(table, m_list, m_count);
- dirs->table = &dirs->dir_table[offset];
- /* Copy directory header */
- memcpy(dirs->dir_header, &dirs->dir_table[offset],
- SQFS_DIR_HEADER_SIZE);
- /* Check for empty directory */
- if (sqfs_is_empty_dir(table)) {
- printf("Empty directory.\n");
- free(dirs->entry);
- dirs->entry = NULL;
- ret = SQFS_EMPTY_DIR;
- goto out;
- }
- dirs->table += SQFS_DIR_HEADER_SIZE;
- dirs->size = get_unaligned_le16(&dir->file_size);
- dirs->entry_count = dirs->dir_header->count + 1;
- dirs->size -= SQFS_DIR_HEADER_SIZE;
- free(dirs->entry);
- dirs->entry = NULL;
- }
- offset = sqfs_dir_offset(table, m_list, m_count);
- dirs->table = &dirs->dir_table[offset];
- if (get_unaligned_le16(&dir->inode_type) == SQFS_DIR_TYPE)
- memcpy(&dirs->i_dir, dir, sizeof(*dir));
- else
- memcpy(&dirs->i_ldir, ldir, sizeof(*ldir));
- out:
- free(res);
- free(rem);
- free(path);
- free(target);
- free(sym_tokens);
- return ret;
- }
- /*
- * Inode and directory tables are stored as a series of metadata blocks, and
- * given the compressed size of this table, we can calculate how much metadata
- * blocks are needed to store the result of the decompression, since a
- * decompressed metadata block should have a size of 8KiB.
- */
- static int sqfs_count_metablks(void *table, u32 offset, int table_size)
- {
- int count = 0, cur_size = 0, ret;
- u32 data_size;
- bool comp;
- do {
- ret = sqfs_read_metablock(table, offset + cur_size, &comp,
- &data_size);
- if (ret)
- return -EINVAL;
- cur_size += data_size + SQFS_HEADER_SIZE;
- count++;
- } while (cur_size < table_size);
- return count;
- }
- /*
- * Storing the metadata blocks header's positions will be useful while looking
- * for an entry in the directory table, using the reference (index and offset)
- * given by its inode.
- */
- static int sqfs_get_metablk_pos(u32 *pos_list, void *table, u32 offset,
- int metablks_count)
- {
- u32 data_size, cur_size = 0;
- int j, ret = 0;
- bool comp;
- if (!metablks_count)
- return -EINVAL;
- for (j = 0; j < metablks_count; j++) {
- ret = sqfs_read_metablock(table, offset + cur_size, &comp,
- &data_size);
- if (ret)
- return -EINVAL;
- cur_size += data_size + SQFS_HEADER_SIZE;
- pos_list[j] = cur_size;
- }
- return ret;
- }
- static int sqfs_read_inode_table(unsigned char **inode_table)
- {
- struct squashfs_super_block *sblk = ctxt.sblk;
- u64 start, n_blks, table_offset, table_size;
- int j, ret = 0, metablks_count;
- unsigned char *src_table, *itb;
- u32 src_len, dest_offset = 0;
- unsigned long dest_len = 0;
- bool compressed;
- table_size = get_unaligned_le64(&sblk->directory_table_start) -
- get_unaligned_le64(&sblk->inode_table_start);
- start = get_unaligned_le64(&sblk->inode_table_start) /
- ctxt.cur_dev->blksz;
- n_blks = sqfs_calc_n_blks(sblk->inode_table_start,
- sblk->directory_table_start, &table_offset);
- /* Allocate a proper sized buffer (itb) to store the inode table */
- itb = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
- if (!itb)
- return -ENOMEM;
- if (sqfs_disk_read(start, n_blks, itb) < 0) {
- ret = -EINVAL;
- goto free_itb;
- }
- /* Parse inode table (metadata block) header */
- ret = sqfs_read_metablock(itb, table_offset, &compressed, &src_len);
- if (ret) {
- ret = -EINVAL;
- goto free_itb;
- }
- /* Calculate size to store the whole decompressed table */
- metablks_count = sqfs_count_metablks(itb, table_offset, table_size);
- if (metablks_count < 1) {
- ret = -EINVAL;
- goto free_itb;
- }
- *inode_table = malloc(metablks_count * SQFS_METADATA_BLOCK_SIZE);
- if (!*inode_table) {
- ret = -ENOMEM;
- printf("Error: failed to allocate squashfs inode_table of size %i, increasing CONFIG_SYS_MALLOC_LEN could help\n",
- metablks_count * SQFS_METADATA_BLOCK_SIZE);
- goto free_itb;
- }
- src_table = itb + table_offset + SQFS_HEADER_SIZE;
- /* Extract compressed Inode table */
- for (j = 0; j < metablks_count; j++) {
- sqfs_read_metablock(itb, table_offset, &compressed, &src_len);
- if (compressed) {
- dest_len = SQFS_METADATA_BLOCK_SIZE;
- ret = sqfs_decompress(&ctxt, *inode_table +
- dest_offset, &dest_len,
- src_table, src_len);
- if (ret) {
- free(*inode_table);
- *inode_table = NULL;
- goto free_itb;
- }
- dest_offset += dest_len;
- } else {
- memcpy(*inode_table + (j * SQFS_METADATA_BLOCK_SIZE),
- src_table, src_len);
- }
- /*
- * Offsets to the decompression destination, to the metadata
- * buffer 'itb' and to the decompression source, respectively.
- */
- table_offset += src_len + SQFS_HEADER_SIZE;
- src_table += src_len + SQFS_HEADER_SIZE;
- }
- free_itb:
- free(itb);
- return ret;
- }
- static int sqfs_read_directory_table(unsigned char **dir_table, u32 **pos_list)
- {
- u64 start, n_blks, table_offset, table_size;
- struct squashfs_super_block *sblk = ctxt.sblk;
- int j, ret = 0, metablks_count = -1;
- unsigned char *src_table, *dtb;
- u32 src_len, dest_offset = 0;
- unsigned long dest_len = 0;
- bool compressed;
- *dir_table = NULL;
- *pos_list = NULL;
- /* DIRECTORY TABLE */
- table_size = get_unaligned_le64(&sblk->fragment_table_start) -
- get_unaligned_le64(&sblk->directory_table_start);
- start = get_unaligned_le64(&sblk->directory_table_start) /
- ctxt.cur_dev->blksz;
- n_blks = sqfs_calc_n_blks(sblk->directory_table_start,
- sblk->fragment_table_start, &table_offset);
- /* Allocate a proper sized buffer (dtb) to store the directory table */
- dtb = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
- if (!dtb)
- return -ENOMEM;
- if (sqfs_disk_read(start, n_blks, dtb) < 0)
- goto out;
- /* Parse directory table (metadata block) header */
- ret = sqfs_read_metablock(dtb, table_offset, &compressed, &src_len);
- if (ret)
- goto out;
- /* Calculate total size to store the whole decompressed table */
- metablks_count = sqfs_count_metablks(dtb, table_offset, table_size);
- if (metablks_count < 1)
- goto out;
- *dir_table = malloc(metablks_count * SQFS_METADATA_BLOCK_SIZE);
- if (!*dir_table)
- goto out;
- *pos_list = malloc(metablks_count * sizeof(u32));
- if (!*pos_list)
- goto out;
- ret = sqfs_get_metablk_pos(*pos_list, dtb, table_offset,
- metablks_count);
- if (ret) {
- metablks_count = -1;
- goto out;
- }
- src_table = dtb + table_offset + SQFS_HEADER_SIZE;
- /* Extract compressed Directory table */
- dest_offset = 0;
- for (j = 0; j < metablks_count; j++) {
- sqfs_read_metablock(dtb, table_offset, &compressed, &src_len);
- if (compressed) {
- dest_len = SQFS_METADATA_BLOCK_SIZE;
- ret = sqfs_decompress(&ctxt, *dir_table +
- (j * SQFS_METADATA_BLOCK_SIZE),
- &dest_len, src_table, src_len);
- if (ret) {
- metablks_count = -1;
- goto out;
- }
- if (dest_len < SQFS_METADATA_BLOCK_SIZE) {
- dest_offset += dest_len;
- break;
- }
- dest_offset += dest_len;
- } else {
- memcpy(*dir_table + (j * SQFS_METADATA_BLOCK_SIZE),
- src_table, src_len);
- }
- /*
- * Offsets to the decompression destination, to the metadata
- * buffer 'dtb' and to the decompression source, respectively.
- */
- table_offset += src_len + SQFS_HEADER_SIZE;
- src_table += src_len + SQFS_HEADER_SIZE;
- }
- out:
- if (metablks_count < 1) {
- free(*dir_table);
- free(*pos_list);
- *dir_table = NULL;
- *pos_list = NULL;
- }
- free(dtb);
- return metablks_count;
- }
- int sqfs_opendir(const char *filename, struct fs_dir_stream **dirsp)
- {
- unsigned char *inode_table = NULL, *dir_table = NULL;
- int j, token_count = 0, ret = 0, metablks_count;
- struct squashfs_dir_stream *dirs;
- char **token_list = NULL, *path = NULL;
- u32 *pos_list = NULL;
- dirs = calloc(1, sizeof(*dirs));
- if (!dirs)
- return -EINVAL;
- /* these should be set to NULL to prevent dangling pointers */
- dirs->dir_header = NULL;
- dirs->entry = NULL;
- dirs->table = NULL;
- dirs->inode_table = NULL;
- dirs->dir_table = NULL;
- ret = sqfs_read_inode_table(&inode_table);
- if (ret) {
- ret = -EINVAL;
- goto out;
- }
- metablks_count = sqfs_read_directory_table(&dir_table, &pos_list);
- if (metablks_count < 1) {
- ret = -EINVAL;
- goto out;
- }
- /* Tokenize filename */
- token_count = sqfs_count_tokens(filename);
- if (token_count < 0) {
- ret = -EINVAL;
- goto out;
- }
- path = strdup(filename);
- if (!path) {
- ret = -EINVAL;
- goto out;
- }
- token_list = malloc(token_count * sizeof(char *));
- if (!token_list) {
- ret = -EINVAL;
- goto out;
- }
- /* Fill tokens list */
- ret = sqfs_tokenize(token_list, token_count, path);
- if (ret)
- goto out;
- /*
- * ldir's (extended directory) size is greater than dir, so it works as
- * a general solution for the malloc size, since 'i' is a union.
- */
- dirs->inode_table = inode_table;
- dirs->dir_table = dir_table;
- ret = sqfs_search_dir(dirs, token_list, token_count, pos_list,
- metablks_count);
- if (ret)
- goto out;
- if (le16_to_cpu(dirs->i_dir.inode_type) == SQFS_DIR_TYPE)
- dirs->size = le16_to_cpu(dirs->i_dir.file_size);
- else
- dirs->size = le32_to_cpu(dirs->i_ldir.file_size);
- /* Setup directory header */
- memcpy(dirs->dir_header, dirs->table, SQFS_DIR_HEADER_SIZE);
- dirs->entry_count = dirs->dir_header->count + 1;
- dirs->size -= SQFS_DIR_HEADER_SIZE;
- /* Setup entry */
- dirs->entry = NULL;
- dirs->table += SQFS_DIR_HEADER_SIZE;
- *dirsp = (struct fs_dir_stream *)dirs;
- out:
- for (j = 0; j < token_count; j++)
- free(token_list[j]);
- free(token_list);
- free(pos_list);
- free(path);
- if (ret) {
- free(inode_table);
- free(dirs);
- }
- return ret;
- }
- int sqfs_readdir(struct fs_dir_stream *fs_dirs, struct fs_dirent **dentp)
- {
- struct squashfs_super_block *sblk = ctxt.sblk;
- struct squashfs_dir_stream *dirs;
- struct squashfs_lreg_inode *lreg;
- struct squashfs_base_inode *base;
- struct squashfs_reg_inode *reg;
- int i_number, offset = 0, ret;
- struct fs_dirent *dent;
- unsigned char *ipos;
- dirs = (struct squashfs_dir_stream *)fs_dirs;
- if (!dirs->size) {
- *dentp = NULL;
- return -SQFS_STOP_READDIR;
- }
- dent = &dirs->dentp;
- if (!dirs->entry_count) {
- if (dirs->size > SQFS_DIR_HEADER_SIZE) {
- dirs->size -= SQFS_DIR_HEADER_SIZE;
- } else {
- *dentp = NULL;
- dirs->size = 0;
- return -SQFS_STOP_READDIR;
- }
- if (dirs->size > SQFS_EMPTY_FILE_SIZE) {
- /* Read follow-up (emitted) dir. header */
- memcpy(dirs->dir_header, dirs->table,
- SQFS_DIR_HEADER_SIZE);
- dirs->entry_count = dirs->dir_header->count + 1;
- ret = sqfs_read_entry(&dirs->entry, dirs->table +
- SQFS_DIR_HEADER_SIZE);
- if (ret)
- return -SQFS_STOP_READDIR;
- dirs->table += SQFS_DIR_HEADER_SIZE;
- }
- } else {
- ret = sqfs_read_entry(&dirs->entry, dirs->table);
- if (ret)
- return -SQFS_STOP_READDIR;
- }
- i_number = dirs->dir_header->inode_number + dirs->entry->inode_offset;
- ipos = sqfs_find_inode(dirs->inode_table, i_number, sblk->inodes,
- sblk->block_size);
- base = (struct squashfs_base_inode *)ipos;
- /* Set entry type and size */
- switch (dirs->entry->type) {
- case SQFS_DIR_TYPE:
- case SQFS_LDIR_TYPE:
- dent->type = FS_DT_DIR;
- break;
- case SQFS_REG_TYPE:
- case SQFS_LREG_TYPE:
- /*
- * Entries do not differentiate extended from regular types, so
- * it needs to be verified manually.
- */
- if (get_unaligned_le16(&base->inode_type) == SQFS_LREG_TYPE) {
- lreg = (struct squashfs_lreg_inode *)ipos;
- dent->size = get_unaligned_le64(&lreg->file_size);
- } else {
- reg = (struct squashfs_reg_inode *)ipos;
- dent->size = get_unaligned_le32(®->file_size);
- }
- dent->type = FS_DT_REG;
- break;
- case SQFS_BLKDEV_TYPE:
- case SQFS_CHRDEV_TYPE:
- case SQFS_LBLKDEV_TYPE:
- case SQFS_LCHRDEV_TYPE:
- case SQFS_FIFO_TYPE:
- case SQFS_SOCKET_TYPE:
- case SQFS_LFIFO_TYPE:
- case SQFS_LSOCKET_TYPE:
- dent->type = SQFS_MISC_ENTRY_TYPE;
- break;
- case SQFS_SYMLINK_TYPE:
- case SQFS_LSYMLINK_TYPE:
- dent->type = FS_DT_LNK;
- break;
- default:
- return -SQFS_STOP_READDIR;
- }
- /* Set entry name */
- strncpy(dent->name, dirs->entry->name, dirs->entry->name_size + 1);
- dent->name[dirs->entry->name_size + 1] = '\0';
- offset = dirs->entry->name_size + 1 + SQFS_ENTRY_BASE_LENGTH;
- dirs->entry_count--;
- /* Decrement size to be read */
- if (dirs->size > offset)
- dirs->size -= offset;
- else
- dirs->size = 0;
- /* Keep a reference to the current entry before incrementing it */
- dirs->table += offset;
- *dentp = dent;
- return 0;
- }
- int sqfs_probe(struct blk_desc *fs_dev_desc, struct disk_partition *fs_partition)
- {
- struct squashfs_super_block *sblk;
- int ret;
- ctxt.cur_dev = fs_dev_desc;
- ctxt.cur_part_info = *fs_partition;
- ret = sqfs_read_sblk(&sblk);
- if (ret)
- goto error;
- /* Make sure it has a valid SquashFS magic number*/
- if (get_unaligned_le32(&sblk->s_magic) != SQFS_MAGIC_NUMBER) {
- debug("Bad magic number for SquashFS image.\n");
- ret = -EINVAL;
- goto error;
- }
- ctxt.sblk = sblk;
- ret = sqfs_decompressor_init(&ctxt);
- if (ret) {
- goto error;
- }
- return 0;
- error:
- ctxt.cur_dev = NULL;
- free(ctxt.sblk);
- ctxt.sblk = NULL;
- return ret;
- }
- static char *sqfs_basename(char *path)
- {
- char *fname;
- fname = path + strlen(path) - 1;
- while (fname >= path) {
- if (*fname == '/') {
- fname++;
- break;
- }
- fname--;
- }
- return fname;
- }
- static char *sqfs_dirname(char *path)
- {
- char *fname;
- fname = sqfs_basename(path);
- --fname;
- *fname = '\0';
- return path;
- }
- /*
- * Takes a path to file and splits it in two parts: the filename itself and the
- * directory's path, e.g.:
- * path: /path/to/file.txt
- * file: file.txt
- * dir: /path/to
- */
- static int sqfs_split_path(char **file, char **dir, const char *path)
- {
- char *dirc, *basec, *bname, *dname, *tmp_path;
- int ret = 0;
- *file = NULL;
- *dir = NULL;
- dirc = NULL;
- basec = NULL;
- bname = NULL;
- dname = NULL;
- tmp_path = NULL;
- /* check for first slash in path*/
- if (path[0] == '/') {
- tmp_path = strdup(path);
- if (!tmp_path) {
- ret = -ENOMEM;
- goto out;
- }
- } else {
- tmp_path = malloc(strlen(path) + 2);
- if (!tmp_path) {
- ret = -ENOMEM;
- goto out;
- }
- tmp_path[0] = '/';
- strcpy(tmp_path + 1, path);
- }
- /* String duplicates */
- dirc = strdup(tmp_path);
- if (!dirc) {
- ret = -ENOMEM;
- goto out;
- }
- basec = strdup(tmp_path);
- if (!basec) {
- ret = -ENOMEM;
- goto out;
- }
- dname = sqfs_dirname(dirc);
- bname = sqfs_basename(basec);
- *file = strdup(bname);
- if (!*file) {
- ret = -ENOMEM;
- goto out;
- }
- if (*dname == '\0') {
- *dir = malloc(2);
- if (!*dir) {
- ret = -ENOMEM;
- goto out;
- }
- (*dir)[0] = '/';
- (*dir)[1] = '\0';
- } else {
- *dir = strdup(dname);
- if (!*dir) {
- ret = -ENOMEM;
- goto out;
- }
- }
- out:
- if (ret) {
- free(*file);
- free(*dir);
- *dir = NULL;
- *file = NULL;
- }
- free(basec);
- free(dirc);
- free(tmp_path);
- return ret;
- }
- static int sqfs_get_regfile_info(struct squashfs_reg_inode *reg,
- struct squashfs_file_info *finfo,
- struct squashfs_fragment_block_entry *fentry,
- __le32 blksz)
- {
- int datablk_count = 0, ret;
- finfo->size = get_unaligned_le32(®->file_size);
- finfo->offset = get_unaligned_le32(®->offset);
- finfo->start = get_unaligned_le32(®->start_block);
- finfo->frag = SQFS_IS_FRAGMENTED(get_unaligned_le32(®->fragment));
- if (finfo->frag && finfo->offset == 0xFFFFFFFF)
- return -EINVAL;
- if (finfo->size < 1 || finfo->start == 0xFFFFFFFF)
- return -EINVAL;
- if (finfo->frag) {
- datablk_count = finfo->size / le32_to_cpu(blksz);
- ret = sqfs_frag_lookup(get_unaligned_le32(®->fragment),
- fentry);
- if (ret < 0)
- return -EINVAL;
- finfo->comp = ret;
- if (fentry->size < 1 || fentry->start == 0x7FFFFFFF)
- return -EINVAL;
- } else {
- datablk_count = DIV_ROUND_UP(finfo->size, le32_to_cpu(blksz));
- }
- finfo->blk_sizes = malloc(datablk_count * sizeof(u32));
- if (!finfo->blk_sizes)
- return -ENOMEM;
- return datablk_count;
- }
- static int sqfs_get_lregfile_info(struct squashfs_lreg_inode *lreg,
- struct squashfs_file_info *finfo,
- struct squashfs_fragment_block_entry *fentry,
- __le32 blksz)
- {
- int datablk_count = 0, ret;
- finfo->size = get_unaligned_le64(&lreg->file_size);
- finfo->offset = get_unaligned_le32(&lreg->offset);
- finfo->start = get_unaligned_le64(&lreg->start_block);
- finfo->frag = SQFS_IS_FRAGMENTED(get_unaligned_le32(&lreg->fragment));
- if (finfo->frag && finfo->offset == 0xFFFFFFFF)
- return -EINVAL;
- if (finfo->size < 1 || finfo->start == 0x7FFFFFFF)
- return -EINVAL;
- if (finfo->frag) {
- datablk_count = finfo->size / le32_to_cpu(blksz);
- ret = sqfs_frag_lookup(get_unaligned_le32(&lreg->fragment),
- fentry);
- if (ret < 0)
- return -EINVAL;
- finfo->comp = ret;
- if (fentry->size < 1 || fentry->start == 0x7FFFFFFF)
- return -EINVAL;
- } else {
- datablk_count = DIV_ROUND_UP(finfo->size, le32_to_cpu(blksz));
- }
- finfo->blk_sizes = malloc(datablk_count * sizeof(u32));
- if (!finfo->blk_sizes)
- return -ENOMEM;
- return datablk_count;
- }
- int sqfs_read(const char *filename, void *buf, loff_t offset, loff_t len,
- loff_t *actread)
- {
- char *dir = NULL, *fragment_block, *datablock = NULL, *data_buffer = NULL;
- char *fragment = NULL, *file = NULL, *resolved, *data;
- u64 start, n_blks, table_size, data_offset, table_offset, sparse_size;
- int ret, j, i_number, datablk_count = 0;
- struct squashfs_super_block *sblk = ctxt.sblk;
- struct squashfs_fragment_block_entry frag_entry;
- struct squashfs_file_info finfo = {0};
- struct squashfs_symlink_inode *symlink;
- struct fs_dir_stream *dirsp = NULL;
- struct squashfs_dir_stream *dirs;
- struct squashfs_lreg_inode *lreg;
- struct squashfs_base_inode *base;
- struct squashfs_reg_inode *reg;
- unsigned long dest_len;
- struct fs_dirent *dent;
- unsigned char *ipos;
- *actread = 0;
- if (offset) {
- /*
- * TODO: implement reading at an offset in file
- */
- printf("Error: reading at a specific offset in a squashfs file is not supported yet.\n");
- return -EINVAL;
- }
- /*
- * sqfs_opendir will uncompress inode and directory tables, and will
- * return a pointer to the directory that contains the requested file.
- */
- sqfs_split_path(&file, &dir, filename);
- ret = sqfs_opendir(dir, &dirsp);
- if (ret) {
- goto out;
- }
- dirs = (struct squashfs_dir_stream *)dirsp;
- /* For now, only regular files are able to be loaded */
- while (!sqfs_readdir(dirsp, &dent)) {
- ret = strcmp(dent->name, file);
- if (!ret)
- break;
- free(dirs->entry);
- dirs->entry = NULL;
- }
- if (ret) {
- printf("File not found.\n");
- *actread = 0;
- ret = -ENOENT;
- goto out;
- }
- i_number = dirs->dir_header->inode_number + dirs->entry->inode_offset;
- ipos = sqfs_find_inode(dirs->inode_table, i_number, sblk->inodes,
- sblk->block_size);
- base = (struct squashfs_base_inode *)ipos;
- switch (get_unaligned_le16(&base->inode_type)) {
- case SQFS_REG_TYPE:
- reg = (struct squashfs_reg_inode *)ipos;
- datablk_count = sqfs_get_regfile_info(reg, &finfo, &frag_entry,
- sblk->block_size);
- if (datablk_count < 0) {
- ret = -EINVAL;
- goto out;
- }
- memcpy(finfo.blk_sizes, ipos + sizeof(*reg),
- datablk_count * sizeof(u32));
- break;
- case SQFS_LREG_TYPE:
- lreg = (struct squashfs_lreg_inode *)ipos;
- datablk_count = sqfs_get_lregfile_info(lreg, &finfo,
- &frag_entry,
- sblk->block_size);
- if (datablk_count < 0) {
- ret = -EINVAL;
- goto out;
- }
- memcpy(finfo.blk_sizes, ipos + sizeof(*lreg),
- datablk_count * sizeof(u32));
- break;
- case SQFS_SYMLINK_TYPE:
- case SQFS_LSYMLINK_TYPE:
- symlink = (struct squashfs_symlink_inode *)ipos;
- resolved = sqfs_resolve_symlink(symlink, filename);
- ret = sqfs_read(resolved, buf, offset, len, actread);
- free(resolved);
- goto out;
- case SQFS_BLKDEV_TYPE:
- case SQFS_CHRDEV_TYPE:
- case SQFS_LBLKDEV_TYPE:
- case SQFS_LCHRDEV_TYPE:
- case SQFS_FIFO_TYPE:
- case SQFS_SOCKET_TYPE:
- case SQFS_LFIFO_TYPE:
- case SQFS_LSOCKET_TYPE:
- default:
- printf("Unsupported entry type\n");
- ret = -EINVAL;
- goto out;
- }
- /* If the user specifies a length, check its sanity */
- if (len) {
- if (len > finfo.size) {
- ret = -EINVAL;
- goto out;
- }
- finfo.size = len;
- } else {
- len = finfo.size;
- }
- if (datablk_count) {
- data_offset = finfo.start;
- datablock = malloc(get_unaligned_le32(&sblk->block_size));
- if (!datablock) {
- ret = -ENOMEM;
- goto out;
- }
- }
- for (j = 0; j < datablk_count; j++) {
- start = data_offset / ctxt.cur_dev->blksz;
- table_size = SQFS_BLOCK_SIZE(finfo.blk_sizes[j]);
- table_offset = data_offset - (start * ctxt.cur_dev->blksz);
- n_blks = DIV_ROUND_UP(table_size + table_offset,
- ctxt.cur_dev->blksz);
- /* Don't load any data for sparse blocks */
- if (finfo.blk_sizes[j] == 0) {
- n_blks = 0;
- table_offset = 0;
- data_buffer = NULL;
- data = NULL;
- } else {
- data_buffer = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
- if (!data_buffer) {
- ret = -ENOMEM;
- goto out;
- }
- ret = sqfs_disk_read(start, n_blks, data_buffer);
- if (ret < 0) {
- /*
- * Possible causes: too many data blocks or too large
- * SquashFS block size. Tip: re-compile the SquashFS
- * image with mksquashfs's -b <block_size> option.
- */
- printf("Error: too many data blocks to be read.\n");
- goto out;
- }
- data = data_buffer + table_offset;
- }
- /* Load the data */
- if (finfo.blk_sizes[j] == 0) {
- /* This is a sparse block */
- sparse_size = get_unaligned_le32(&sblk->block_size);
- if ((*actread + sparse_size) > len)
- sparse_size = len - *actread;
- memset(buf + *actread, 0, sparse_size);
- *actread += sparse_size;
- } else if (SQFS_COMPRESSED_BLOCK(finfo.blk_sizes[j])) {
- dest_len = get_unaligned_le32(&sblk->block_size);
- ret = sqfs_decompress(&ctxt, datablock, &dest_len,
- data, table_size);
- if (ret)
- goto out;
- if ((*actread + dest_len) > len)
- dest_len = len - *actread;
- memcpy(buf + *actread, datablock, dest_len);
- *actread += dest_len;
- } else {
- if ((*actread + table_size) > len)
- table_size = len - *actread;
- memcpy(buf + *actread, data, table_size);
- *actread += table_size;
- }
- data_offset += table_size;
- if (data_buffer)
- free(data_buffer);
- data_buffer = NULL;
- if (*actread >= len)
- break;
- }
- /*
- * There is no need to continue if the file is not fragmented.
- */
- if (!finfo.frag) {
- ret = 0;
- goto out;
- }
- start = frag_entry.start / ctxt.cur_dev->blksz;
- table_size = SQFS_BLOCK_SIZE(frag_entry.size);
- table_offset = frag_entry.start - (start * ctxt.cur_dev->blksz);
- n_blks = DIV_ROUND_UP(table_size + table_offset, ctxt.cur_dev->blksz);
- fragment = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
- if (!fragment) {
- ret = -ENOMEM;
- goto out;
- }
- ret = sqfs_disk_read(start, n_blks, fragment);
- if (ret < 0)
- goto out;
- /* File compressed and fragmented */
- if (finfo.frag && finfo.comp) {
- dest_len = get_unaligned_le32(&sblk->block_size);
- fragment_block = malloc(dest_len);
- if (!fragment_block) {
- ret = -ENOMEM;
- goto out;
- }
- ret = sqfs_decompress(&ctxt, fragment_block, &dest_len,
- (void *)fragment + table_offset,
- frag_entry.size);
- if (ret) {
- free(fragment_block);
- goto out;
- }
- memcpy(buf + *actread, &fragment_block[finfo.offset], finfo.size - *actread);
- *actread = finfo.size;
- free(fragment_block);
- } else if (finfo.frag && !finfo.comp) {
- fragment_block = (void *)fragment + table_offset;
- memcpy(buf + *actread, &fragment_block[finfo.offset], finfo.size - *actread);
- *actread = finfo.size;
- }
- out:
- free(fragment);
- if (datablk_count) {
- free(data_buffer);
- free(datablock);
- }
- free(file);
- free(dir);
- free(finfo.blk_sizes);
- sqfs_closedir(dirsp);
- return ret;
- }
- int sqfs_size(const char *filename, loff_t *size)
- {
- struct squashfs_super_block *sblk = ctxt.sblk;
- struct squashfs_symlink_inode *symlink;
- struct fs_dir_stream *dirsp = NULL;
- struct squashfs_base_inode *base;
- struct squashfs_dir_stream *dirs;
- struct squashfs_lreg_inode *lreg;
- struct squashfs_reg_inode *reg;
- char *dir, *file, *resolved;
- struct fs_dirent *dent;
- unsigned char *ipos;
- int ret, i_number;
- sqfs_split_path(&file, &dir, filename);
- /*
- * sqfs_opendir will uncompress inode and directory tables, and will
- * return a pointer to the directory that contains the requested file.
- */
- ret = sqfs_opendir(dir, &dirsp);
- if (ret) {
- ret = -EINVAL;
- goto free_strings;
- }
- dirs = (struct squashfs_dir_stream *)dirsp;
- while (!sqfs_readdir(dirsp, &dent)) {
- ret = strcmp(dent->name, file);
- if (!ret)
- break;
- free(dirs->entry);
- dirs->entry = NULL;
- }
- if (ret) {
- printf("File not found.\n");
- *size = 0;
- ret = -EINVAL;
- goto free_strings;
- }
- i_number = dirs->dir_header->inode_number + dirs->entry->inode_offset;
- ipos = sqfs_find_inode(dirs->inode_table, i_number, sblk->inodes,
- sblk->block_size);
- free(dirs->entry);
- dirs->entry = NULL;
- base = (struct squashfs_base_inode *)ipos;
- switch (get_unaligned_le16(&base->inode_type)) {
- case SQFS_REG_TYPE:
- reg = (struct squashfs_reg_inode *)ipos;
- *size = get_unaligned_le32(®->file_size);
- break;
- case SQFS_LREG_TYPE:
- lreg = (struct squashfs_lreg_inode *)ipos;
- *size = get_unaligned_le64(&lreg->file_size);
- break;
- case SQFS_SYMLINK_TYPE:
- case SQFS_LSYMLINK_TYPE:
- symlink = (struct squashfs_symlink_inode *)ipos;
- resolved = sqfs_resolve_symlink(symlink, filename);
- ret = sqfs_size(resolved, size);
- free(resolved);
- break;
- case SQFS_BLKDEV_TYPE:
- case SQFS_CHRDEV_TYPE:
- case SQFS_LBLKDEV_TYPE:
- case SQFS_LCHRDEV_TYPE:
- case SQFS_FIFO_TYPE:
- case SQFS_SOCKET_TYPE:
- case SQFS_LFIFO_TYPE:
- case SQFS_LSOCKET_TYPE:
- default:
- printf("Unable to recover entry's size.\n");
- *size = 0;
- ret = -EINVAL;
- break;
- }
- free_strings:
- free(dir);
- free(file);
- sqfs_closedir(dirsp);
- return ret;
- }
- int sqfs_exists(const char *filename)
- {
- struct fs_dir_stream *dirsp = NULL;
- struct squashfs_dir_stream *dirs;
- char *dir, *file;
- struct fs_dirent *dent;
- int ret;
- sqfs_split_path(&file, &dir, filename);
- /*
- * sqfs_opendir will uncompress inode and directory tables, and will
- * return a pointer to the directory that contains the requested file.
- */
- ret = sqfs_opendir(dir, &dirsp);
- if (ret) {
- ret = -EINVAL;
- goto free_strings;
- }
- dirs = (struct squashfs_dir_stream *)dirsp;
- while (!sqfs_readdir(dirsp, &dent)) {
- ret = strcmp(dent->name, file);
- if (!ret)
- break;
- free(dirs->entry);
- dirs->entry = NULL;
- }
- sqfs_closedir(dirsp);
- free_strings:
- free(dir);
- free(file);
- return ret == 0;
- }
- void sqfs_close(void)
- {
- sqfs_decompressor_cleanup(&ctxt);
- free(ctxt.sblk);
- ctxt.sblk = NULL;
- ctxt.cur_dev = NULL;
- }
- void sqfs_closedir(struct fs_dir_stream *dirs)
- {
- struct squashfs_dir_stream *sqfs_dirs;
- if (!dirs)
- return;
- sqfs_dirs = (struct squashfs_dir_stream *)dirs;
- free(sqfs_dirs->inode_table);
- free(sqfs_dirs->dir_table);
- free(sqfs_dirs->dir_header);
- free(sqfs_dirs);
- }
|