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