fs/squashfs/sqfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2020 Bootlin
   4  *
   5  * Author: Joao Marcos Costa <joaomarcos.costa@bootlin.com>
   6  *
   7  * sqfs.c: SquashFS filesystem implementation
   8  */
   9
  10 #include <asm/unaligned.h>
  11 #include <errno.h>
  12 #include <fs.h>
  13 #include <linux/types.h>
  14 #include <linux/byteorder/little_endian.h>
  15 #include <linux/byteorder/generic.h>
  16 #include <memalign.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <squashfs.h>
  20 #include <part.h>
  21
  22 #include "sqfs_decompressor.h"
  23 #include "sqfs_filesystem.h"
  24 #include "sqfs_utils.h"
  25
  26 static struct squashfs_ctxt ctxt;
  27
  28 static int sqfs_disk_read(__u32 block, __u32 nr_blocks, void *buf)
  29 {
  30         ulong ret;
  31
  32         if (!ctxt.cur_dev)
  33                 return -1;
  34
  35         ret = blk_dread(ctxt.cur_dev, ctxt.cur_part_info.start + block,
  36                         nr_blocks, buf);
  37
  38         if (ret != nr_blocks)
  39                 return -1;
  40
  41         return ret;
  42 }
  43
  44 static int sqfs_read_sblk(struct squashfs_super_block **sblk)
  45 {
  46         *sblk = malloc_cache_aligned(ctxt.cur_dev->blksz);
  47         if (!*sblk)
  48                 return -ENOMEM;
  49
  50         if (sqfs_disk_read(0, 1, *sblk) != 1) {
  51                 free(*sblk);
  52                 return -EINVAL;
  53         }
  54
  55         return 0;
  56 }
  57
  58 static int sqfs_count_tokens(const char *filename)
  59 {
  60         int token_count = 1, l;
  61
  62         for (l = 1; l < strlen(filename); l++) {
  63                 if (filename[l] == '/')
  64                         token_count++;
  65         }
  66
  67         /* Ignore trailing '/' in path */
  68         if (filename[strlen(filename) - 1] == '/')
  69                 token_count--;
  70
  71         if (!token_count)
  72                 token_count = 1;
  73
  74         return token_count;
  75 }
  76
  77 /*
  78  * Calculates how many blocks are needed for the buffer used in sqfs_disk_read.
  79  * The memory section (e.g. inode table) start offset and its end (i.e. the next
  80  * table start) must be specified. It also calculates the offset from which to
  81  * start reading the buffer.
  82  */
  83 static int sqfs_calc_n_blks(__le64 start, __le64 end, u64 *offset)
  84 {
  85         u64 start_, table_size;
  86
  87         table_size = le64_to_cpu(end) - le64_to_cpu(start);
  88         start_ = le64_to_cpu(start) / ctxt.cur_dev->blksz;
  89         *offset = le64_to_cpu(start) - (start_ * ctxt.cur_dev->blksz);
  90
  91         return DIV_ROUND_UP(table_size + *offset, ctxt.cur_dev->blksz);
  92 }
  93
  94 /*
  95  * Retrieves fragment block entry and returns true if the fragment block is
  96  * compressed
  97  */
  98 static int sqfs_frag_lookup(u32 inode_fragment_index,
  99                             struct squashfs_fragment_block_entry *e)
 100 {
 101         u64 start, n_blks, src_len, table_offset, start_block;
 102         unsigned char *metadata_buffer, *metadata, *table;
 103         struct squashfs_fragment_block_entry *entries;
 104         struct squashfs_super_block *sblk = ctxt.sblk;
 105         unsigned long dest_len;
 106         int block, offset, ret;
 107         u16 header;
 108
 109         if (inode_fragment_index >= get_unaligned_le32(&sblk->fragments))
 110                 return -EINVAL;
 111
 112         start = get_unaligned_le64(&sblk->fragment_table_start) /
 113                 ctxt.cur_dev->blksz;
 114         n_blks = sqfs_calc_n_blks(sblk->fragment_table_start,
 115                                   sblk->export_table_start,
 116                                   &table_offset);
 117
 118         /* Allocate a proper sized buffer to store the fragment index table */
 119         table = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
 120         if (!table)
 121                 return -ENOMEM;
 122
 123         if (sqfs_disk_read(start, n_blks, table) < 0) {
 124                 free(table);
 125                 return -EINVAL;
 126         }
 127
 128         block = SQFS_FRAGMENT_INDEX(inode_fragment_index);
 129         offset = SQFS_FRAGMENT_INDEX_OFFSET(inode_fragment_index);
 130
 131         /*
 132          * Get the start offset of the metadata block that contains the right
 133          * fragment block entry
 134          */
 135         start_block = get_unaligned_le64(table + table_offset + block *
 136                                          sizeof(u64));
 137
 138         start = start_block / ctxt.cur_dev->blksz;
 139         n_blks = sqfs_calc_n_blks(cpu_to_le64(start_block),
 140                                   sblk->fragment_table_start, &table_offset);
 141
 142         metadata_buffer = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
 143         if (!metadata_buffer) {
 144                 ret = -ENOMEM;
 145                 goto free_table;
 146         }
 147
 148         if (sqfs_disk_read(start, n_blks, metadata_buffer) < 0) {
 149                 ret = -EINVAL;
 150                 goto free_buffer;
 151         }
 152
 153         /* Every metadata block starts with a 16-bit header */
 154         header = get_unaligned_le16(metadata_buffer + table_offset);
 155         metadata = metadata_buffer + table_offset + SQFS_HEADER_SIZE;
 156
 157         if (!metadata || !header) {
 158                 ret = -ENOMEM;
 159                 goto free_buffer;
 160         }
 161
 162         entries = malloc(SQFS_METADATA_BLOCK_SIZE);
 163         if (!entries) {
 164                 ret = -ENOMEM;
 165                 goto free_buffer;
 166         }
 167
 168         if (SQFS_COMPRESSED_METADATA(header)) {
 169                 src_len = SQFS_METADATA_SIZE(header);
 170                 dest_len = SQFS_METADATA_BLOCK_SIZE;
 171                 ret = sqfs_decompress(&ctxt, entries, &dest_len, metadata,
 172                                       src_len);
 173                 if (ret) {
 174                         ret = -EINVAL;
 175                         goto free_entries;
 176                 }
 177         } else {
 178                 memcpy(entries, metadata, SQFS_METADATA_SIZE(header));
 179         }
 180
 181         *e = entries[offset];
 182         ret = SQFS_COMPRESSED_BLOCK(e->size);
 183
 184 free_entries:
 185         free(entries);
 186 free_buffer:
 187         free(metadata_buffer);
 188 free_table:
 189         free(table);
 190
 191         return ret;
 192 }
 193
 194 /*
 195  * The entry name is a flexible array member, and we don't know its size before
 196  * actually reading the entry. So we need a first copy to retrieve this size so
 197  * we can finally copy the whole struct.
 198  */
 199 static int sqfs_read_entry(struct squashfs_directory_entry **dest, void *src)
 200 {
 201         struct squashfs_directory_entry *tmp;
 202         u16 sz;
 203
 204         tmp = src;
 205         sz = get_unaligned_le16(src + sizeof(*tmp) - sizeof(u16));
 206         /*
 207          * 'src' points to the begin of a directory entry, and 'sz' gets its
 208          * 'name_size' member's value. name_size is actually the string
 209          * length - 1, so adding 2 compensates this difference and adds space
 210          * for the trailling null byte.
 211          */
 212         *dest = malloc(sizeof(*tmp) + sz + 2);
 213         if (!*dest)
 214                 return -ENOMEM;
 215
 216         memcpy(*dest, src, sizeof(*tmp) + sz + 1);
 217         (*dest)->name[sz + 1] = '\0';
 218
 219         return 0;
 220 }
 221
 222 static int sqfs_get_tokens_length(char **tokens, int count)
 223 {
 224         int length = 0, i;
 225
 226         /*
 227          * 1 is added to the result of strlen to consider the slash separator
 228          * between the tokens.
 229          */
 230         for (i = 0; i < count; i++)
 231                 length += strlen(tokens[i]) + 1;
 232
 233         return length;
 234 }
 235
 236 /* Takes a token list and returns a single string with '/' as separator. */
 237 static char *sqfs_concat_tokens(char **token_list, int token_count)
 238 {
 239         char *result;
 240         int i, length = 0, offset = 0;
 241
 242         length = sqfs_get_tokens_length(token_list, token_count);
 243
 244         result = malloc(length + 1);
 245         if (!result)
 246                 return NULL;
 247
 248         result[length] = '\0';
 249
 250         for (i = 0; i < token_count; i++) {
 251                 strcpy(result + offset, token_list[i]);
 252                 offset += strlen(token_list[i]);
 253                 result[offset++] = '/';
 254         }
 255
 256         return result;
 257 }
 258
 259 /*
 260  * Differently from sqfs_concat_tokens, sqfs_join writes the result into a
 261  * previously allocated string, and returns the number of bytes written.
 262  */
 263 static int sqfs_join(char **strings, char *dest, int start, int end,
 264                      char separator)
 265 {
 266         int i, offset = 0;
 267
 268         for (i = start; i < end; i++) {
 269                 strcpy(dest + offset, strings[i]);
 270                 offset += strlen(strings[i]);
 271                 if (i < end - 1)
 272                         dest[offset++] = separator;
 273         }
 274
 275         return offset;
 276 }
 277
 278 /*
 279  * Fills the given token list using its size (count) and a source string (str)
 280  */
 281 static int sqfs_tokenize(char **tokens, int count, const char *str)
 282 {
 283         int i, j, ret = 0;
 284         char *aux, *strc;
 285
 286         strc = strdup(str);
 287         if (!strc)
 288                 return -ENOMEM;
 289
 290         if (!strcmp(strc, "/")) {
 291                 tokens[0] = strdup(strc);
 292                 if (!tokens[0]) {
 293                         ret = -ENOMEM;
 294                         goto free_strc;
 295                 }
 296         } else {
 297                 for (j = 0; j < count; j++) {
 298                         aux = strtok(!j ? strc : NULL, "/");
 299                         tokens[j] = strdup(aux);
 300                         if (!tokens[j]) {
 301                                 for (i = 0; i < j; i++)
 302                                         free(tokens[i]);
 303                                 ret = -ENOMEM;
 304                                 goto free_strc;
 305                         }
 306                 }
 307         }
 308
 309 free_strc:
 310         free(strc);
 311
 312         return ret;
 313 }
 314
 315 /*
 316  * Remove last 'updir + 1' tokens from the base path tokens list. This leaves us
 317  * with a token list containing only the tokens needed to form the resolved
 318  * path, and returns the decremented size of the token list.
 319  */
 320 static int sqfs_clean_base_path(char **base, int count, int updir)
 321 {
 322         int i;
 323
 324         for (i = count - updir - 1; i < count; i++)
 325                 free(base[i]);
 326
 327         return count - updir - 1;
 328 }
 329
 330 /*
 331  * Given the base ("current dir.") path and the relative one, generate the
 332  * absolute path.
 333  */
 334 static char *sqfs_get_abs_path(const char *base, const char *rel)
 335 {
 336         char **base_tokens, **rel_tokens, *resolved = NULL;
 337         int ret, bc, rc, i, updir = 0, resolved_size = 0, offset = 0;
 338
 339         /* Memory allocation for the token lists */
 340         bc = sqfs_count_tokens(base);
 341         rc = sqfs_count_tokens(rel);
 342         if (bc < 1 || rc < 1)
 343                 return NULL;
 344
 345         base_tokens = malloc(bc * sizeof(char *));
 346         if (!base_tokens)
 347                 return NULL;
 348
 349         rel_tokens = malloc(rc * sizeof(char *));
 350         if (!rel_tokens)
 351                 goto free_b_tokens;
 352
 353         /* Fill token lists */
 354         ret = sqfs_tokenize(base_tokens, bc, base);
 355         if (ret)
 356                 goto free_r_tokens;
 357
 358         sqfs_tokenize(rel_tokens, rc, rel);
 359         if (ret)
 360                 goto free_r_tokens;
 361
 362         /* count '..' occurrences in target path */
 363         for (i = 0; i < rc; i++) {
 364                 if (!strcmp(rel_tokens[i], ".."))
 365                         updir++;
 366         }
 367
 368         /* Remove the last token and the '..' occurrences */
 369         bc = sqfs_clean_base_path(base_tokens, bc, updir);
 370         if (bc < 0)
 371                 goto free_r_tokens;
 372
 373         /* Calculate resolved path size */
 374         if (!bc)
 375                 resolved_size++;
 376
 377         resolved_size += sqfs_get_tokens_length(base_tokens, bc) +
 378                 sqfs_get_tokens_length(rel_tokens, rc);
 379
 380         resolved = malloc(resolved_size + 1);
 381         if (!resolved)
 382                 goto free_r_tokens_loop;
 383
 384         /* Set resolved path */
 385         memset(resolved, '\0', resolved_size + 1);
 386         offset += sqfs_join(base_tokens, resolved + offset, 0, bc, '/');
 387         resolved[offset++] = '/';
 388         offset += sqfs_join(rel_tokens, resolved + offset, updir, rc, '/');
 389
 390 free_r_tokens_loop:
 391         for (i = 0; i < rc; i++)
 392                 free(rel_tokens[i]);
 393         for (i = 0; i < bc; i++)
 394                 free(base_tokens[i]);
 395 free_r_tokens:
 396         free(rel_tokens);
 397 free_b_tokens:
 398         free(base_tokens);
 399
 400         return resolved;
 401 }
 402
 403 static char *sqfs_resolve_symlink(struct squashfs_symlink_inode *sym,
 404                                   const char *base_path)
 405 {
 406         char *resolved, *target;
 407         u32 sz;
 408
 409         sz = get_unaligned_le32(&sym->symlink_size);
 410         target = malloc(sz + 1);
 411         if (!target)
 412                 return NULL;
 413
 414         /*
 415          * There is no trailling null byte in the symlink's target path, so a
 416          * copy is made and a '\0' is added at its end.
 417          */
 418         target[sz] = '\0';
 419         /* Get target name (relative path) */
 420         strncpy(target, sym->symlink, sz);
 421
 422         /* Relative -> absolute path conversion */
 423         resolved = sqfs_get_abs_path(base_path, target);
 424
 425         free(target);
 426
 427         return resolved;
 428 }
 429
 430 /*
 431  * m_list contains each metadata block's position, and m_count is the number of
 432  * elements of m_list. Those metadata blocks come from the compressed directory
 433  * table.
 434  */
 435 static int sqfs_search_dir(struct squashfs_dir_stream *dirs, char **token_list,
 436                            int token_count, u32 *m_list, int m_count)
 437 {
 438         struct squashfs_super_block *sblk = ctxt.sblk;
 439         char *path, *target, **sym_tokens, *res, *rem;
 440         int j, ret = 0, new_inode_number, offset;
 441         struct squashfs_symlink_inode *sym;
 442         struct squashfs_ldir_inode *ldir;
 443         struct squashfs_dir_inode *dir;
 444         struct fs_dir_stream *dirsp;
 445         struct fs_dirent *dent;
 446         unsigned char *table;
 447
 448         res = NULL;
 449         rem = NULL;
 450         path = NULL;
 451         target = NULL;
 452         sym_tokens = NULL;
 453
 454         dirsp = (struct fs_dir_stream *)dirs;
 455
 456         /* Start by root inode */
 457         table = sqfs_find_inode(dirs->inode_table, le32_to_cpu(sblk->inodes),
 458                                 sblk->inodes, sblk->block_size);
 459
 460         dir = (struct squashfs_dir_inode *)table;
 461         ldir = (struct squashfs_ldir_inode *)table;
 462
 463         /* get directory offset in directory table */
 464         offset = sqfs_dir_offset(table, m_list, m_count);
 465         dirs->table = &dirs->dir_table[offset];
 466
 467         /* Setup directory header */
 468         dirs->dir_header = malloc(SQFS_DIR_HEADER_SIZE);
 469         if (!dirs->dir_header)
 470                 return -ENOMEM;
 471
 472         memcpy(dirs->dir_header, dirs->table, SQFS_DIR_HEADER_SIZE);
 473
 474         /* Initialize squashfs_dir_stream members */
 475         dirs->table += SQFS_DIR_HEADER_SIZE;
 476         dirs->size = get_unaligned_le16(&dir->file_size) - SQFS_DIR_HEADER_SIZE;
 477         dirs->entry_count = dirs->dir_header->count + 1;
 478
 479         /* No path given -> root directory */
 480         if (!strcmp(token_list[0], "/")) {
 481                 dirs->table = &dirs->dir_table[offset];
 482                 memcpy(&dirs->i_dir, dir, sizeof(*dir));
 483                 return 0;
 484         }
 485
 486         for (j = 0; j < token_count; j++) {
 487                 if (!sqfs_is_dir(get_unaligned_le16(&dir->inode_type))) {
 488                         printf("** Cannot find directory. **\n");
 489                         ret = -EINVAL;
 490                         goto out;
 491                 }
 492
 493                 while (!sqfs_readdir(dirsp, &dent)) {
 494                         ret = strcmp(dent->name, token_list[j]);
 495                         if (!ret)
 496                                 break;
 497                         free(dirs->entry);
 498                         dirs->entry = NULL;
 499                 }
 500
 501                 if (ret) {
 502                         printf("** Cannot find directory. **\n");
 503                         ret = -EINVAL;
 504                         goto out;
 505                 }
 506
 507                 /* Redefine inode as the found token */
 508                 new_inode_number = dirs->entry->inode_offset +
 509                         dirs->dir_header->inode_number;
 510
 511                 /* Get reference to inode in the inode table */
 512                 table = sqfs_find_inode(dirs->inode_table, new_inode_number,
 513                                         sblk->inodes, sblk->block_size);
 514                 dir = (struct squashfs_dir_inode *)table;
 515
 516                 /* Check for symbolic link and inode type sanity */
 517                 if (get_unaligned_le16(&dir->inode_type) == SQFS_SYMLINK_TYPE) {
 518                         sym = (struct squashfs_symlink_inode *)table;
 519                         /* Get first j + 1 tokens */
 520                         path = sqfs_concat_tokens(token_list, j + 1);
 521                         if (!path) {
 522                                 ret = -ENOMEM;
 523                                 goto out;
 524                         }
 525                         /* Resolve for these tokens */
 526                         target = sqfs_resolve_symlink(sym, path);
 527                         if (!target) {
 528                                 ret = -ENOMEM;
 529                                 goto out;
 530                         }
 531                         /* Join remaining tokens */
 532                         rem = sqfs_concat_tokens(token_list + j + 1, token_count -
 533                                                  j - 1);
 534                         if (!rem) {
 535                                 ret = -ENOMEM;
 536                                 goto out;
 537                         }
 538                         /* Concatenate remaining tokens and symlink's target */
 539                         res = malloc(strlen(rem) + strlen(target) + 1);
 540                         if (!res) {
 541                                 ret = -ENOMEM;
 542                                 goto out;
 543                         }
 544                         strcpy(res, target);
 545                         res[strlen(target)] = '/';
 546                         strcpy(res + strlen(target) + 1, rem);
 547                         token_count = sqfs_count_tokens(res);
 548
 549                         if (token_count < 0) {
 550                                 ret = -EINVAL;
 551                                 goto out;
 552                         }
 553
 554                         sym_tokens = malloc(token_count * sizeof(char *));
 555                         if (!sym_tokens) {
 556                                 ret = -EINVAL;
 557                                 goto out;
 558                         }
 559
 560                         /* Fill tokens list */
 561                         ret = sqfs_tokenize(sym_tokens, token_count, res);
 562                         if (ret) {
 563                                 ret = -EINVAL;
 564                                 goto out;
 565                         }
 566                         free(dirs->entry);
 567                         dirs->entry = NULL;
 568
 569                         ret = sqfs_search_dir(dirs, sym_tokens, token_count,
 570                                               m_list, m_count);
 571                         goto out;
 572                 } else if (!sqfs_is_dir(get_unaligned_le16(&dir->inode_type))) {
 573                         printf("** Cannot find directory. **\n");
 574                         free(dirs->entry);
 575                         dirs->entry = NULL;
 576                         ret = -EINVAL;
 577                         goto out;
 578                 }
 579
 580                 /* Check if it is an extended dir. */
 581                 if (get_unaligned_le16(&dir->inode_type) == SQFS_LDIR_TYPE)
 582                         ldir = (struct squashfs_ldir_inode *)table;
 583
 584                 /* Get dir. offset into the directory table */
 585                 offset = sqfs_dir_offset(table, m_list, m_count);
 586                 dirs->table = &dirs->dir_table[offset];
 587
 588                 /* Copy directory header */
 589                 memcpy(dirs->dir_header, &dirs->dir_table[offset],
 590                        SQFS_DIR_HEADER_SIZE);
 591
 592                 /* Check for empty directory */
 593                 if (sqfs_is_empty_dir(table)) {
 594                         printf("Empty directory.\n");
 595                         free(dirs->entry);
 596                         dirs->entry = NULL;
 597                         ret = SQFS_EMPTY_DIR;
 598                         goto out;
 599                 }
 600
 601                 dirs->table += SQFS_DIR_HEADER_SIZE;
 602                 dirs->size = get_unaligned_le16(&dir->file_size);
 603                 dirs->entry_count = dirs->dir_header->count + 1;
 604                 dirs->size -= SQFS_DIR_HEADER_SIZE;
 605                 free(dirs->entry);
 606                 dirs->entry = NULL;
 607         }
 608
 609         offset = sqfs_dir_offset(table, m_list, m_count);
 610         dirs->table = &dirs->dir_table[offset];
 611
 612         if (get_unaligned_le16(&dir->inode_type) == SQFS_DIR_TYPE)
 613                 memcpy(&dirs->i_dir, dir, sizeof(*dir));
 614         else
 615                 memcpy(&dirs->i_ldir, ldir, sizeof(*ldir));
 616
 617 out:
 618         free(res);
 619         free(rem);
 620         free(path);
 621         free(target);
 622         free(sym_tokens);
 623         return ret;
 624 }
 625
 626 /*
 627  * Inode and directory tables are stored as a series of metadata blocks, and
 628  * given the compressed size of this table, we can calculate how much metadata
 629  * blocks are needed to store the result of the decompression, since a
 630  * decompressed metadata block should have a size of 8KiB.
 631  */
 632 static int sqfs_count_metablks(void *table, u32 offset, int table_size)
 633 {
 634         int count = 0, cur_size = 0, ret;
 635         u32 data_size;
 636         bool comp;
 637
 638         do {
 639                 ret = sqfs_read_metablock(table, offset + cur_size, &comp,
 640                                           &data_size);
 641                 if (ret)
 642                         return -EINVAL;
 643                 cur_size += data_size + SQFS_HEADER_SIZE;
 644                 count++;
 645         } while (cur_size < table_size);
 646
 647         return count;
 648 }
 649
 650 /*
 651  * Storing the metadata blocks header's positions will be useful while looking
 652  * for an entry in the directory table, using the reference (index and offset)
 653  * given by its inode.
 654  */
 655 static int sqfs_get_metablk_pos(u32 *pos_list, void *table, u32 offset,
 656                                 int metablks_count)
 657 {
 658         u32 data_size, cur_size = 0;
 659         int j, ret = 0;
 660         bool comp;
 661
 662         if (!metablks_count)
 663                 return -EINVAL;
 664
 665         for (j = 0; j < metablks_count; j++) {
 666                 ret = sqfs_read_metablock(table, offset + cur_size, &comp,
 667                                           &data_size);
 668                 if (ret)
 669                         return -EINVAL;
 670
 671                 cur_size += data_size + SQFS_HEADER_SIZE;
 672                 pos_list[j] = cur_size;
 673         }
 674
 675         return ret;
 676 }
 677
 678 static int sqfs_read_inode_table(unsigned char **inode_table)
 679 {
 680         struct squashfs_super_block *sblk = ctxt.sblk;
 681         u64 start, n_blks, table_offset, table_size;
 682         int j, ret = 0, metablks_count;
 683         unsigned char *src_table, *itb;
 684         u32 src_len, dest_offset = 0;
 685         unsigned long dest_len = 0;
 686         bool compressed;
 687
 688         table_size = get_unaligned_le64(&sblk->directory_table_start) -
 689                 get_unaligned_le64(&sblk->inode_table_start);
 690         start = get_unaligned_le64(&sblk->inode_table_start) /
 691                 ctxt.cur_dev->blksz;
 692         n_blks = sqfs_calc_n_blks(sblk->inode_table_start,
 693                                   sblk->directory_table_start, &table_offset);
 694
 695         /* Allocate a proper sized buffer (itb) to store the inode table */
 696         itb = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
 697         if (!itb)
 698                 return -ENOMEM;
 699
 700         if (sqfs_disk_read(start, n_blks, itb) < 0) {
 701                 ret = -EINVAL;
 702                 goto free_itb;
 703         }
 704
 705         /* Parse inode table (metadata block) header */
 706         ret = sqfs_read_metablock(itb, table_offset, &compressed, &src_len);
 707         if (ret) {
 708                 ret = -EINVAL;
 709                 goto free_itb;
 710         }
 711
 712         /* Calculate size to store the whole decompressed table */
 713         metablks_count = sqfs_count_metablks(itb, table_offset, table_size);
 714         if (metablks_count < 1) {
 715                 ret = -EINVAL;
 716                 goto free_itb;
 717         }
 718
 719         *inode_table = malloc(metablks_count * SQFS_METADATA_BLOCK_SIZE);
 720         if (!*inode_table) {
 721                 ret = -ENOMEM;
 722                 goto free_itb;
 723         }
 724
 725         src_table = itb + table_offset + SQFS_HEADER_SIZE;
 726
 727         /* Extract compressed Inode table */
 728         for (j = 0; j < metablks_count; j++) {
 729                 sqfs_read_metablock(itb, table_offset, &compressed, &src_len);
 730                 if (compressed) {
 731                         dest_len = SQFS_METADATA_BLOCK_SIZE;
 732                         ret = sqfs_decompress(&ctxt, *inode_table +
 733                                               dest_offset, &dest_len,
 734                                               src_table, src_len);
 735                         if (ret) {
 736                                 free(*inode_table);
 737                                 *inode_table = NULL;
 738                                 goto free_itb;
 739                         }
 740
 741                         dest_offset += dest_len;
 742                 } else {
 743                         memcpy(*inode_table + (j * SQFS_METADATA_BLOCK_SIZE),
 744                                src_table, src_len);
 745                 }
 746
 747                 /*
 748                  * Offsets to the decompression destination, to the metadata
 749                  * buffer 'itb' and to the decompression source, respectively.
 750                  */
 751
 752                 table_offset += src_len + SQFS_HEADER_SIZE;
 753                 src_table += src_len + SQFS_HEADER_SIZE;
 754         }
 755
 756 free_itb:
 757         free(itb);
 758
 759         return ret;
 760 }
 761
 762 static int sqfs_read_directory_table(unsigned char **dir_table, u32 **pos_list)
 763 {
 764         u64 start, n_blks, table_offset, table_size;
 765         struct squashfs_super_block *sblk = ctxt.sblk;
 766         int j, ret = 0, metablks_count = -1;
 767         unsigned char *src_table, *dtb;
 768         u32 src_len, dest_offset = 0;
 769         unsigned long dest_len = 0;
 770         bool compressed;
 771
 772         *dir_table = NULL;
 773         *pos_list = NULL;
 774         /* DIRECTORY TABLE */
 775         table_size = get_unaligned_le64(&sblk->fragment_table_start) -
 776                 get_unaligned_le64(&sblk->directory_table_start);
 777         start = get_unaligned_le64(&sblk->directory_table_start) /
 778                 ctxt.cur_dev->blksz;
 779         n_blks = sqfs_calc_n_blks(sblk->directory_table_start,
 780                                   sblk->fragment_table_start, &table_offset);
 781
 782         /* Allocate a proper sized buffer (dtb) to store the directory table */
 783         dtb = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
 784         if (!dtb)
 785                 return -ENOMEM;
 786
 787         if (sqfs_disk_read(start, n_blks, dtb) < 0)
 788                 goto out;
 789
 790         /* Parse directory table (metadata block) header */
 791         ret = sqfs_read_metablock(dtb, table_offset, &compressed, &src_len);
 792         if (ret)
 793                 goto out;
 794
 795         /* Calculate total size to store the whole decompressed table */
 796         metablks_count = sqfs_count_metablks(dtb, table_offset, table_size);
 797         if (metablks_count < 1)
 798                 goto out;
 799
 800         *dir_table = malloc(metablks_count * SQFS_METADATA_BLOCK_SIZE);
 801         if (!*dir_table)
 802                 goto out;
 803
 804         *pos_list = malloc(metablks_count * sizeof(u32));
 805         if (!*pos_list)
 806                 goto out;
 807
 808         ret = sqfs_get_metablk_pos(*pos_list, dtb, table_offset,
 809                                    metablks_count);
 810         if (ret) {
 811                 metablks_count = -1;
 812                 goto out;
 813         }
 814
 815         src_table = dtb + table_offset + SQFS_HEADER_SIZE;
 816
 817         /* Extract compressed Directory table */
 818         dest_offset = 0;
 819         for (j = 0; j < metablks_count; j++) {
 820                 sqfs_read_metablock(dtb, table_offset, &compressed, &src_len);
 821                 if (compressed) {
 822                         dest_len = SQFS_METADATA_BLOCK_SIZE;
 823                         ret = sqfs_decompress(&ctxt, *dir_table +
 824                                               (j * SQFS_METADATA_BLOCK_SIZE),
 825                                               &dest_len, src_table, src_len);
 826                         if (ret) {
 827                                 metablks_count = -1;
 828                                 goto out;
 829                         }
 830
 831                         if (dest_len < SQFS_METADATA_BLOCK_SIZE) {
 832                                 dest_offset += dest_len;
 833                                 break;
 834                         }
 835
 836                         dest_offset += dest_len;
 837                 } else {
 838                         memcpy(*dir_table + (j * SQFS_METADATA_BLOCK_SIZE),
 839                                src_table, src_len);
 840                 }
 841
 842                 /*
 843                  * Offsets to the decompression destination, to the metadata
 844                  * buffer 'dtb' and to the decompression source, respectively.
 845                  */
 846                 table_offset += src_len + SQFS_HEADER_SIZE;
 847                 src_table += src_len + SQFS_HEADER_SIZE;
 848         }
 849
 850 out:
 851         if (metablks_count < 1) {
 852                 free(*dir_table);
 853                 free(*pos_list);
 854                 *dir_table = NULL;
 855                 *pos_list = NULL;
 856         }
 857         free(dtb);
 858
 859         return metablks_count;
 860 }
 861
 862 int sqfs_opendir(const char *filename, struct fs_dir_stream **dirsp)
 863 {
 864         unsigned char *inode_table = NULL, *dir_table = NULL;
 865         int j, token_count, ret = 0, metablks_count;
 866         struct squashfs_dir_stream *dirs;
 867         char **token_list, *path;
 868         u32 *pos_list = NULL;
 869
 870         dirs = malloc(sizeof(*dirs));
 871         if (!dirs)
 872                 return -EINVAL;
 873
 874         /* these should be set to NULL to prevent dangling pointers */
 875         dirs->dir_header = NULL;
 876         dirs->entry = NULL;
 877         dirs->table = NULL;
 878         dirs->inode_table = NULL;
 879         dirs->dir_table = NULL;
 880
 881         ret = sqfs_read_inode_table(&inode_table);
 882         if (ret) {
 883                 ret = -EINVAL;
 884                 goto free_dirs;
 885         }
 886
 887         metablks_count = sqfs_read_directory_table(&dir_table, &pos_list);
 888         if (metablks_count < 1) {
 889                 ret = -EINVAL;
 890                 goto free_inode_table;
 891         }
 892
 893         /* Tokenize filename */
 894         token_count = sqfs_count_tokens(filename);
 895         if (token_count < 0) {
 896                 ret = -EINVAL;
 897                 goto free_inode_table;
 898         }
 899
 900         path = strdup(filename);
 901         if (!path) {
 902                 ret = -EINVAL;
 903                 goto free_inode_table;
 904         }
 905
 906         token_list = malloc(token_count * sizeof(char *));
 907         if (!token_list) {
 908                 ret = -EINVAL;
 909                 goto free_path;
 910         }
 911
 912         /* Fill tokens list */
 913         ret = sqfs_tokenize(token_list, token_count, path);
 914         if (ret)
 915                 goto free_tokens;
 916         /*
 917          * ldir's (extended directory) size is greater than dir, so it works as
 918          * a general solution for the malloc size, since 'i' is a union.
 919          */
 920         dirs->inode_table = inode_table;
 921         dirs->dir_table = dir_table;
 922         ret = sqfs_search_dir(dirs, token_list, token_count, pos_list,
 923                               metablks_count);
 924         if (ret)
 925                 goto free_tokens;
 926
 927         if (le16_to_cpu(dirs->i_dir.inode_type) == SQFS_DIR_TYPE)
 928                 dirs->size = le16_to_cpu(dirs->i_dir.file_size);
 929         else
 930                 dirs->size = le32_to_cpu(dirs->i_ldir.file_size);
 931
 932         /* Setup directory header */
 933         memcpy(dirs->dir_header, dirs->table, SQFS_DIR_HEADER_SIZE);
 934         dirs->entry_count = dirs->dir_header->count + 1;
 935         dirs->size -= SQFS_DIR_HEADER_SIZE;
 936
 937         /* Setup entry */
 938         dirs->entry = NULL;
 939         dirs->table += SQFS_DIR_HEADER_SIZE;
 940
 941         *dirsp = (struct fs_dir_stream *)dirs;
 942
 943 free_tokens:
 944         for (j = 0; j < token_count; j++)
 945                 free(token_list[j]);
 946         free(token_list);
 947         free(pos_list);
 948 free_path:
 949         free(path);
 950 free_inode_table:
 951         if (ret)
 952                 free(inode_table);
 953 free_dirs:
 954         if (ret)
 955                 free(dirs);
 956
 957         return ret;
 958 }
 959
 960 int sqfs_readdir(struct fs_dir_stream *fs_dirs, struct fs_dirent **dentp)
 961 {
 962         struct squashfs_super_block *sblk = ctxt.sblk;
 963         struct squashfs_dir_stream *dirs;
 964         struct squashfs_lreg_inode *lreg;
 965         struct squashfs_base_inode *base;
 966         struct squashfs_reg_inode *reg;
 967         int i_number, offset = 0, ret;
 968         struct fs_dirent *dent;
 969         unsigned char *ipos;
 970
 971         dirs = (struct squashfs_dir_stream *)fs_dirs;
 972         if (!dirs->size) {
 973                 *dentp = NULL;
 974                 return -SQFS_STOP_READDIR;
 975         }
 976
 977         dent = &dirs->dentp;
 978
 979         if (!dirs->entry_count) {
 980                 if (dirs->size > SQFS_DIR_HEADER_SIZE) {
 981                         dirs->size -= SQFS_DIR_HEADER_SIZE;
 982                 } else {
 983                         *dentp = NULL;
 984                         dirs->size = 0;
 985                         return -SQFS_STOP_READDIR;
 986                 }
 987
 988                 if (dirs->size > SQFS_EMPTY_FILE_SIZE) {
 989                         /* Read follow-up (emitted) dir. header */
 990                         memcpy(dirs->dir_header, dirs->table,
 991                                SQFS_DIR_HEADER_SIZE);
 992                         dirs->entry_count = dirs->dir_header->count + 1;
 993                         ret = sqfs_read_entry(&dirs->entry, dirs->table +
 994                                               SQFS_DIR_HEADER_SIZE);
 995                         if (ret)
 996                                 return -SQFS_STOP_READDIR;
 997
 998                         dirs->table += SQFS_DIR_HEADER_SIZE;
 999                 }
1000         } else {
1001                 ret = sqfs_read_entry(&dirs->entry, dirs->table);
1002                 if (ret)
1003                         return -SQFS_STOP_READDIR;
1004         }
1005
1006         i_number = dirs->dir_header->inode_number + dirs->entry->inode_offset;
1007         ipos = sqfs_find_inode(dirs->inode_table, i_number, sblk->inodes,
1008                                sblk->block_size);
1009
1010         base = (struct squashfs_base_inode *)ipos;
1011
1012         /* Set entry type and size */
1013         switch (dirs->entry->type) {
1014         case SQFS_DIR_TYPE:
1015         case SQFS_LDIR_TYPE:
1016                 dent->type = FS_DT_DIR;
1017                 break;
1018         case SQFS_REG_TYPE:
1019         case SQFS_LREG_TYPE:
1020                 /*
1021                  * Entries do not differentiate extended from regular types, so
1022                  * it needs to be verified manually.
1023                  */
1024                 if (get_unaligned_le16(&base->inode_type) == SQFS_LREG_TYPE) {
1025                         lreg = (struct squashfs_lreg_inode *)ipos;
1026                         dent->size = get_unaligned_le64(&lreg->file_size);
1027                 } else {
1028                         reg = (struct squashfs_reg_inode *)ipos;
1029                         dent->size = get_unaligned_le32(&reg->file_size);
1030                 }
1031
1032                 dent->type = FS_DT_REG;
1033                 break;
1034         case SQFS_BLKDEV_TYPE:
1035         case SQFS_CHRDEV_TYPE:
1036         case SQFS_LBLKDEV_TYPE:
1037         case SQFS_LCHRDEV_TYPE:
1038         case SQFS_FIFO_TYPE:
1039         case SQFS_SOCKET_TYPE:
1040         case SQFS_LFIFO_TYPE:
1041         case SQFS_LSOCKET_TYPE:
1042                 dent->type = SQFS_MISC_ENTRY_TYPE;
1043                 break;
1044         case SQFS_SYMLINK_TYPE:
1045         case SQFS_LSYMLINK_TYPE:
1046                 dent->type = FS_DT_LNK;
1047                 break;
1048         default:
1049                 return -SQFS_STOP_READDIR;
1050         }
1051
1052         /* Set entry name */
1053         strncpy(dent->name, dirs->entry->name, dirs->entry->name_size + 1);
1054         dent->name[dirs->entry->name_size + 1] = '\0';
1055
1056         offset = dirs->entry->name_size + 1 + SQFS_ENTRY_BASE_LENGTH;
1057         dirs->entry_count--;
1058
1059         /* Decrement size to be read */
1060         if (dirs->size > offset)
1061                 dirs->size -= offset;
1062         else
1063                 dirs->size = 0;
1064
1065         /* Keep a reference to the current entry before incrementing it */
1066         dirs->table += offset;
1067
1068         *dentp = dent;
1069
1070         return 0;
1071 }
1072
1073 int sqfs_probe(struct blk_desc *fs_dev_desc, struct disk_partition *fs_partition)
1074 {
1075         struct squashfs_super_block *sblk;
1076         int ret;
1077
1078         ctxt.cur_dev = fs_dev_desc;
1079         ctxt.cur_part_info = *fs_partition;
1080
1081         ret = sqfs_read_sblk(&sblk);
1082         if (ret)
1083                 return ret;
1084
1085         /* Make sure it has a valid SquashFS magic number*/
1086         if (get_unaligned_le32(&sblk->s_magic) != SQFS_MAGIC_NUMBER) {
1087                 printf("Bad magic number for SquashFS image.\n");
1088                 ctxt.cur_dev = NULL;
1089                 return -EINVAL;
1090         }
1091
1092         ctxt.sblk = sblk;
1093
1094         ret = sqfs_decompressor_init(&ctxt);
1095
1096         if (ret) {
1097                 ctxt.cur_dev = NULL;
1098                 free(ctxt.sblk);
1099                 return -EINVAL;
1100         }
1101
1102         return 0;
1103 }
1104
1105 static char *sqfs_basename(char *path)
1106 {
1107         char *fname;
1108
1109         fname = path + strlen(path) - 1;
1110         while (fname >= path) {
1111                 if (*fname == '/') {
1112                         fname++;
1113                         break;
1114                 }
1115
1116                 fname--;
1117         }
1118
1119         return fname;
1120 }
1121
1122 static char *sqfs_dirname(char *path)
1123 {
1124         char *fname;
1125
1126         fname = sqfs_basename(path);
1127         --fname;
1128         *fname = '\0';
1129
1130         return path;
1131 }
1132
1133 /*
1134  * Takes a path to file and splits it in two parts: the filename itself and the
1135  * directory's path, e.g.:
1136  * path: /path/to/file.txt
1137  * file: file.txt
1138  * dir: /path/to
1139  */
1140 static int sqfs_split_path(char **file, char **dir, const char *path)
1141 {
1142         char *dirc, *basec, *bname, *dname, *tmp_path;
1143         int ret = 0;
1144
1145         *file = NULL;
1146         *dir = NULL;
1147         dirc = NULL;
1148         basec = NULL;
1149         bname = NULL;
1150         dname = NULL;
1151         tmp_path = NULL;
1152
1153         /* check for first slash in path*/
1154         if (path[0] == '/') {
1155                 tmp_path = strdup(path);
1156                 if (!tmp_path) {
1157                         ret = -ENOMEM;
1158                         goto out;
1159                 }
1160         } else {
1161                 tmp_path = malloc(strlen(path) + 2);
1162                 if (!tmp_path) {
1163                         ret = -ENOMEM;
1164                         goto out;
1165                 }
1166                 tmp_path[0] = '/';
1167                 strcpy(tmp_path + 1, path);
1168         }
1169
1170         /* String duplicates */
1171         dirc = strdup(tmp_path);
1172         if (!dirc) {
1173                 ret = -ENOMEM;
1174                 goto out;
1175         }
1176
1177         basec = strdup(tmp_path);
1178         if (!basec) {
1179                 ret = -ENOMEM;
1180                 goto out;
1181         }
1182
1183         dname = sqfs_dirname(dirc);
1184         bname = sqfs_basename(basec);
1185
1186         *file = strdup(bname);
1187
1188         if (!*file) {
1189                 ret = -ENOMEM;
1190                 goto out;
1191         }
1192
1193         if (*dname == '\0') {
1194                 *dir = malloc(2);
1195                 if (!*dir) {
1196                         ret = -ENOMEM;
1197                         goto out;
1198                 }
1199
1200                 (*dir)[0] = '/';
1201                 (*dir)[1] = '\0';
1202         } else {
1203                 *dir = strdup(dname);
1204                 if (!*dir) {
1205                         ret = -ENOMEM;
1206                         goto out;
1207                 }
1208         }
1209
1210 out:
1211         if (ret) {
1212                 free(*file);
1213                 free(*dir);
1214                 *dir = NULL;
1215                 *file = NULL;
1216         }
1217         free(basec);
1218         free(dirc);
1219         free(tmp_path);
1220
1221         return ret;
1222 }
1223
1224 static int sqfs_get_regfile_info(struct squashfs_reg_inode *reg,
1225                                  struct squashfs_file_info *finfo,
1226                                  struct squashfs_fragment_block_entry *fentry,
1227                                  __le32 blksz)
1228 {
1229         int datablk_count = 0, ret;
1230
1231         finfo->size = get_unaligned_le32(&reg->file_size);
1232         finfo->offset = get_unaligned_le32(&reg->offset);
1233         finfo->start = get_unaligned_le32(&reg->start_block);
1234         finfo->frag = SQFS_IS_FRAGMENTED(get_unaligned_le32(&reg->fragment));
1235
1236         if (finfo->frag && finfo->offset == 0xFFFFFFFF)
1237                 return -EINVAL;
1238
1239         if (finfo->size < 1 || finfo->start == 0xFFFFFFFF)
1240                 return -EINVAL;
1241
1242         if (finfo->frag) {
1243                 datablk_count = finfo->size / le32_to_cpu(blksz);
1244                 ret = sqfs_frag_lookup(get_unaligned_le32(&reg->fragment),
1245                                        fentry);
1246                 if (ret < 0)
1247                         return -EINVAL;
1248                 finfo->comp = true;
1249                 if (fentry->size < 1 || fentry->start == 0x7FFFFFFF)
1250                         return -EINVAL;
1251         } else {
1252                 datablk_count = DIV_ROUND_UP(finfo->size, le32_to_cpu(blksz));
1253         }
1254
1255         finfo->blk_sizes = malloc(datablk_count * sizeof(u32));
1256         if (!finfo->blk_sizes)
1257                 return -ENOMEM;
1258
1259         return datablk_count;
1260 }
1261
1262 static int sqfs_get_lregfile_info(struct squashfs_lreg_inode *lreg,
1263                                   struct squashfs_file_info *finfo,
1264                                   struct squashfs_fragment_block_entry *fentry,
1265                                  __le32 blksz)
1266 {
1267         int datablk_count = 0, ret;
1268
1269         finfo->size = get_unaligned_le64(&lreg->file_size);
1270         finfo->offset = get_unaligned_le32(&lreg->offset);
1271         finfo->start = get_unaligned_le64(&lreg->start_block);
1272         finfo->frag = SQFS_IS_FRAGMENTED(get_unaligned_le32(&lreg->fragment));
1273
1274         if (finfo->frag && finfo->offset == 0xFFFFFFFF)
1275                 return -EINVAL;
1276
1277         if (finfo->size < 1 || finfo->start == 0x7FFFFFFF)
1278                 return -EINVAL;
1279
1280         if (finfo->frag) {
1281                 datablk_count = finfo->size / le32_to_cpu(blksz);
1282                 ret = sqfs_frag_lookup(get_unaligned_le32(&lreg->fragment),
1283                                        fentry);
1284                 if (ret < 0)
1285                         return -EINVAL;
1286                 finfo->comp = true;
1287                 if (fentry->size < 1 || fentry->start == 0x7FFFFFFF)
1288                         return -EINVAL;
1289         } else {
1290                 datablk_count = DIV_ROUND_UP(finfo->size, le32_to_cpu(blksz));
1291         }
1292
1293         finfo->blk_sizes = malloc(datablk_count * sizeof(u32));
1294         if (!finfo->blk_sizes)
1295                 return -ENOMEM;
1296
1297         return datablk_count;
1298 }
1299
1300 int sqfs_read(const char *filename, void *buf, loff_t offset, loff_t len,
1301               loff_t *actread)
1302 {
1303         char *dir, *fragment_block, *datablock = NULL, *data_buffer = NULL;
1304         char *fragment, *file, *resolved, *data;
1305         u64 start, n_blks, table_size, data_offset, table_offset;
1306         int ret, j, i_number, datablk_count = 0;
1307         struct squashfs_super_block *sblk = ctxt.sblk;
1308         struct squashfs_fragment_block_entry frag_entry;
1309         struct squashfs_file_info finfo = {0};
1310         struct squashfs_symlink_inode *symlink;
1311         struct fs_dir_stream *dirsp = NULL;
1312         struct squashfs_dir_stream *dirs;
1313         struct squashfs_lreg_inode *lreg;
1314         struct squashfs_base_inode *base;
1315         struct squashfs_reg_inode *reg;
1316         unsigned long dest_len;
1317         struct fs_dirent *dent;
1318         unsigned char *ipos;
1319
1320         *actread = 0;
1321
1322         /*
1323          * sqfs_opendir will uncompress inode and directory tables, and will
1324          * return a pointer to the directory that contains the requested file.
1325          */
1326         sqfs_split_path(&file, &dir, filename);
1327         ret = sqfs_opendir(dir, &dirsp);
1328         if (ret) {
1329                 goto free_paths;
1330         }
1331
1332         dirs = (struct squashfs_dir_stream *)dirsp;
1333
1334         /* For now, only regular files are able to be loaded */
1335         while (!sqfs_readdir(dirsp, &dent)) {
1336                 ret = strcmp(dent->name, file);
1337                 if (!ret)
1338                         break;
1339
1340                 free(dirs->entry);
1341                 dirs->entry = NULL;
1342         }
1343
1344         if (ret) {
1345                 printf("File not found.\n");
1346                 *actread = 0;
1347                 ret = -ENOENT;
1348                 goto free_paths;
1349         }
1350
1351         i_number = dirs->dir_header->inode_number + dirs->entry->inode_offset;
1352         ipos = sqfs_find_inode(dirs->inode_table, i_number, sblk->inodes,
1353                                sblk->block_size);
1354
1355         base = (struct squashfs_base_inode *)ipos;
1356         switch (get_unaligned_le16(&base->inode_type)) {
1357         case SQFS_REG_TYPE:
1358                 reg = (struct squashfs_reg_inode *)ipos;
1359                 datablk_count = sqfs_get_regfile_info(reg, &finfo, &frag_entry,
1360                                                       sblk->block_size);
1361                 if (datablk_count < 0) {
1362                         ret = -EINVAL;
1363                         goto free_paths;
1364                 }
1365
1366                 memcpy(finfo.blk_sizes, ipos + sizeof(*reg),
1367                        datablk_count * sizeof(u32));
1368                 break;
1369         case SQFS_LREG_TYPE:
1370                 lreg = (struct squashfs_lreg_inode *)ipos;
1371                 datablk_count = sqfs_get_lregfile_info(lreg, &finfo,
1372                                                        &frag_entry,
1373                                                        sblk->block_size);
1374                 if (datablk_count < 0) {
1375                         ret = -EINVAL;
1376                         goto free_paths;
1377                 }
1378
1379                 memcpy(finfo.blk_sizes, ipos + sizeof(*lreg),
1380                        datablk_count * sizeof(u32));
1381                 break;
1382         case SQFS_SYMLINK_TYPE:
1383         case SQFS_LSYMLINK_TYPE:
1384                 symlink = (struct squashfs_symlink_inode *)ipos;
1385                 resolved = sqfs_resolve_symlink(symlink, filename);
1386                 ret = sqfs_read(resolved, buf, offset, len, actread);
1387                 free(resolved);
1388                 goto free_paths;
1389         case SQFS_BLKDEV_TYPE:
1390         case SQFS_CHRDEV_TYPE:
1391         case SQFS_LBLKDEV_TYPE:
1392         case SQFS_LCHRDEV_TYPE:
1393         case SQFS_FIFO_TYPE:
1394         case SQFS_SOCKET_TYPE:
1395         case SQFS_LFIFO_TYPE:
1396         case SQFS_LSOCKET_TYPE:
1397         default:
1398                 printf("Unsupported entry type\n");
1399                 ret = -EINVAL;
1400                 goto free_paths;
1401         }
1402
1403         /* If the user specifies a length, check its sanity */
1404         if (len) {
1405                 if (len > finfo.size) {
1406                         ret = -EINVAL;
1407                         goto free_paths;
1408                 }
1409
1410                 finfo.size = len;
1411         }
1412
1413         if (datablk_count) {
1414                 data_offset = finfo.start;
1415                 datablock = malloc(get_unaligned_le32(&sblk->block_size));
1416                 if (!datablock) {
1417                         ret = -ENOMEM;
1418                         goto free_paths;
1419                 }
1420         }
1421
1422         for (j = 0; j < datablk_count; j++) {
1423                 start = data_offset / ctxt.cur_dev->blksz;
1424                 table_size = SQFS_BLOCK_SIZE(finfo.blk_sizes[j]);
1425                 table_offset = data_offset - (start * ctxt.cur_dev->blksz);
1426                 n_blks = DIV_ROUND_UP(table_size + table_offset,
1427                                       ctxt.cur_dev->blksz);
1428
1429                 data_buffer = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
1430
1431                 if (!data_buffer) {
1432                         ret = -ENOMEM;
1433                         goto free_datablk;
1434                 }
1435
1436                 ret = sqfs_disk_read(start, n_blks, data_buffer);
1437                 if (ret < 0) {
1438                         /*
1439                          * Possible causes: too many data blocks or too large
1440                          * SquashFS block size. Tip: re-compile the SquashFS
1441                          * image with mksquashfs's -b <block_size> option.
1442                          */
1443                         printf("Error: too many data blocks to be read.\n");
1444                         goto free_buffer;
1445                 }
1446
1447                 data = data_buffer + table_offset;
1448
1449                 /* Load the data */
1450                 if (SQFS_COMPRESSED_BLOCK(finfo.blk_sizes[j])) {
1451                         dest_len = get_unaligned_le32(&sblk->block_size);
1452                         ret = sqfs_decompress(&ctxt, datablock, &dest_len,
1453                                               data, table_size);
1454                         if (ret)
1455                                 goto free_buffer;
1456
1457                         memcpy(buf + offset + *actread, datablock, dest_len);
1458                         *actread += dest_len;
1459                 } else {
1460                         memcpy(buf + offset + *actread, data, table_size);
1461                         *actread += table_size;
1462                 }
1463
1464                 data_offset += table_size;
1465                 free(data_buffer);
1466                 data_buffer = NULL;
1467         }
1468
1469         free(finfo.blk_sizes);
1470
1471         /*
1472          * There is no need to continue if the file is not fragmented.
1473          */
1474         if (!finfo.frag) {
1475                 ret = 0;
1476                 goto free_buffer;
1477         }
1478
1479         start = frag_entry.start / ctxt.cur_dev->blksz;
1480         table_size = SQFS_BLOCK_SIZE(frag_entry.size);
1481         table_offset = frag_entry.start - (start * ctxt.cur_dev->blksz);
1482         n_blks = DIV_ROUND_UP(table_size + table_offset, ctxt.cur_dev->blksz);
1483
1484         fragment = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
1485
1486         if (!fragment) {
1487                 ret = -ENOMEM;
1488                 goto free_buffer;
1489         }
1490
1491         ret = sqfs_disk_read(start, n_blks, fragment);
1492         if (ret < 0)
1493                 goto free_fragment;
1494
1495         /* File compressed and fragmented */
1496         if (finfo.frag && finfo.comp) {
1497                 dest_len = get_unaligned_le32(&sblk->block_size);
1498                 fragment_block = malloc(dest_len);
1499                 if (!fragment_block) {
1500                         ret = -ENOMEM;
1501                         goto free_fragment;
1502                 }
1503
1504                 ret = sqfs_decompress(&ctxt, fragment_block, &dest_len,
1505                                       (void *)fragment  + table_offset,
1506                                       frag_entry.size);
1507                 if (ret) {
1508                         free(fragment_block);
1509                         goto free_fragment;
1510                 }
1511
1512                 for (j = offset + *actread; j < finfo.size; j++) {
1513                         memcpy(buf + j, &fragment_block[finfo.offset + j], 1);
1514                         (*actread)++;
1515                 }
1516
1517                 free(fragment_block);
1518
1519         } else if (finfo.frag && !finfo.comp) {
1520                 fragment_block = (void *)fragment + table_offset;
1521
1522                 for (j = offset + *actread; j < finfo.size; j++) {
1523                         memcpy(buf + j, &fragment_block[finfo.offset + j], 1);
1524                         (*actread)++;
1525                 }
1526         }
1527
1528 free_fragment:
1529         free(fragment);
1530 free_buffer:
1531         if (datablk_count)
1532                 free(data_buffer);
1533 free_datablk:
1534         if (datablk_count)
1535                 free(datablock);
1536 free_paths:
1537         free(file);
1538         free(dir);
1539         sqfs_closedir(dirsp);
1540
1541         return ret;
1542 }
1543
1544 int sqfs_size(const char *filename, loff_t *size)
1545 {
1546         struct squashfs_super_block *sblk = ctxt.sblk;
1547         struct squashfs_symlink_inode *symlink;
1548         struct fs_dir_stream *dirsp = NULL;
1549         struct squashfs_base_inode *base;
1550         struct squashfs_dir_stream *dirs;
1551         struct squashfs_lreg_inode *lreg;
1552         struct squashfs_reg_inode *reg;
1553         char *dir, *file, *resolved;
1554         struct fs_dirent *dent;
1555         unsigned char *ipos;
1556         int ret, i_number;
1557
1558         sqfs_split_path(&file, &dir, filename);
1559         /*
1560          * sqfs_opendir will uncompress inode and directory tables, and will
1561          * return a pointer to the directory that contains the requested file.
1562          */
1563         ret = sqfs_opendir(dir, &dirsp);
1564         if (ret) {
1565                 ret = -EINVAL;
1566                 goto free_strings;
1567         }
1568
1569         dirs = (struct squashfs_dir_stream *)dirsp;
1570
1571         while (!sqfs_readdir(dirsp, &dent)) {
1572                 ret = strcmp(dent->name, file);
1573                 if (!ret)
1574                         break;
1575                 free(dirs->entry);
1576                 dirs->entry = NULL;
1577         }
1578
1579         if (ret) {
1580                 printf("File not found.\n");
1581                 *size = 0;
1582                 ret = -EINVAL;
1583                 goto free_strings;
1584         }
1585
1586         i_number = dirs->dir_header->inode_number + dirs->entry->inode_offset;
1587         ipos = sqfs_find_inode(dirs->inode_table, i_number, sblk->inodes,
1588                                sblk->block_size);
1589         free(dirs->entry);
1590         dirs->entry = NULL;
1591
1592         base = (struct squashfs_base_inode *)ipos;
1593         switch (get_unaligned_le16(&base->inode_type)) {
1594         case SQFS_REG_TYPE:
1595                 reg = (struct squashfs_reg_inode *)ipos;
1596                 *size = get_unaligned_le32(&reg->file_size);
1597                 break;
1598         case SQFS_LREG_TYPE:
1599                 lreg = (struct squashfs_lreg_inode *)ipos;
1600                 *size = get_unaligned_le64(&lreg->file_size);
1601                 break;
1602         case SQFS_SYMLINK_TYPE:
1603         case SQFS_LSYMLINK_TYPE:
1604                 symlink = (struct squashfs_symlink_inode *)ipos;
1605                 resolved = sqfs_resolve_symlink(symlink, filename);
1606                 ret = sqfs_size(resolved, size);
1607                 free(resolved);
1608                 break;
1609         case SQFS_BLKDEV_TYPE:
1610         case SQFS_CHRDEV_TYPE:
1611         case SQFS_LBLKDEV_TYPE:
1612         case SQFS_LCHRDEV_TYPE:
1613         case SQFS_FIFO_TYPE:
1614         case SQFS_SOCKET_TYPE:
1615         case SQFS_LFIFO_TYPE:
1616         case SQFS_LSOCKET_TYPE:
1617         default:
1618                 printf("Unable to recover entry's size.\n");
1619                 *size = 0;
1620                 ret = -EINVAL;
1621                 break;
1622         }
1623
1624 free_strings:
1625         free(dir);
1626         free(file);
1627
1628         sqfs_closedir(dirsp);
1629
1630         return ret;
1631 }
1632
1633 void sqfs_close(void)
1634 {
1635         free(ctxt.sblk);
1636         ctxt.cur_dev = NULL;
1637         sqfs_decompressor_cleanup(&ctxt);
1638 }
1639
1640 void sqfs_closedir(struct fs_dir_stream *dirs)
1641 {
1642         struct squashfs_dir_stream *sqfs_dirs;
1643
1644         sqfs_dirs = (struct squashfs_dir_stream *)dirs;
1645         free(sqfs_dirs->inode_table);
1646         free(sqfs_dirs->dir_table);
1647         free(sqfs_dirs->dir_header);
1648         free(sqfs_dirs);
1649 }