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
8 #include <asm/unaligned.h>
9 #include <compiler.h>
10 #include <errno.h>
11 #include <stdint.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15
16 #include "sqfs_decompressor.h"
17 #include "sqfs_filesystem.h"
18 #include "sqfs_utils.h"
19
sqfs_inode_size(struct squashfs_base_inode * inode,u32 blk_size)20 int sqfs_inode_size(struct squashfs_base_inode *inode, u32 blk_size)
21 {
22 switch (get_unaligned_le16(&inode->inode_type)) {
23 case SQFS_DIR_TYPE:
24 return sizeof(struct squashfs_dir_inode);
25
26 case SQFS_REG_TYPE: {
27 struct squashfs_reg_inode *reg =
28 (struct squashfs_reg_inode *)inode;
29 u32 fragment = get_unaligned_le32(®->fragment);
30 u32 file_size = get_unaligned_le32(®->file_size);
31 unsigned int blk_list_size;
32
33 if (SQFS_IS_FRAGMENTED(fragment))
34 blk_list_size = file_size / blk_size;
35 else
36 blk_list_size = DIV_ROUND_UP(file_size, blk_size);
37
38 return sizeof(*reg) + blk_list_size * sizeof(u32);
39 }
40
41 case SQFS_LDIR_TYPE: {
42 struct squashfs_ldir_inode *ldir =
43 (struct squashfs_ldir_inode *)inode;
44 u16 i_count = get_unaligned_le16(&ldir->i_count);
45 unsigned int index_list_size = 0, l = 0;
46 struct squashfs_directory_index *di;
47 u32 sz;
48
49 if (i_count == 0)
50 return sizeof(*ldir);
51
52 di = ldir->index;
53 while (l < i_count) {
54 sz = get_unaligned_le32(&di->size) + 1;
55 index_list_size += sz;
56 di = (void *)di + sizeof(*di) + sz;
57 l++;
58 }
59
60 return sizeof(*ldir) + index_list_size +
61 i_count * SQFS_DIR_INDEX_BASE_LENGTH;
62 }
63
64 case SQFS_LREG_TYPE: {
65 struct squashfs_lreg_inode *lreg =
66 (struct squashfs_lreg_inode *)inode;
67 u32 fragment = get_unaligned_le32(&lreg->fragment);
68 u64 file_size = get_unaligned_le64(&lreg->file_size);
69 unsigned int blk_list_size;
70
71 if (fragment == 0xFFFFFFFF)
72 blk_list_size = DIV_ROUND_UP(file_size, blk_size);
73 else
74 blk_list_size = file_size / blk_size;
75
76 return sizeof(*lreg) + blk_list_size * sizeof(u32);
77 }
78
79 case SQFS_SYMLINK_TYPE:
80 case SQFS_LSYMLINK_TYPE: {
81 struct squashfs_symlink_inode *symlink =
82 (struct squashfs_symlink_inode *)inode;
83
84 return sizeof(*symlink) +
85 get_unaligned_le32(&symlink->symlink_size);
86 }
87
88 case SQFS_BLKDEV_TYPE:
89 case SQFS_CHRDEV_TYPE:
90 return sizeof(struct squashfs_dev_inode);
91 case SQFS_LBLKDEV_TYPE:
92 case SQFS_LCHRDEV_TYPE:
93 return sizeof(struct squashfs_ldev_inode);
94 case SQFS_FIFO_TYPE:
95 case SQFS_SOCKET_TYPE:
96 return sizeof(struct squashfs_ipc_inode);
97 case SQFS_LFIFO_TYPE:
98 case SQFS_LSOCKET_TYPE:
99 return sizeof(struct squashfs_lipc_inode);
100 default:
101 printf("Error while searching inode: unknown type.\n");
102 return -EINVAL;
103 }
104 }
105
106 /*
107 * Given the uncompressed inode table, the inode to be found and the number of
108 * inodes in the table, return inode position in case of success.
109 */
sqfs_find_inode(void * inode_table,int inode_number,__le32 inode_count,__le32 block_size)110 void *sqfs_find_inode(void *inode_table, int inode_number, __le32 inode_count,
111 __le32 block_size)
112 {
113 struct squashfs_base_inode *base;
114 unsigned int offset = 0, k;
115 int sz;
116
117 if (!inode_table) {
118 printf("%s: Invalid pointer to inode table.\n", __func__);
119 return NULL;
120 }
121
122 for (k = 0; k < le32_to_cpu(inode_count); k++) {
123 base = inode_table + offset;
124 if (get_unaligned_le32(&base->inode_number) == inode_number)
125 return inode_table + offset;
126
127 sz = sqfs_inode_size(base, le32_to_cpu(block_size));
128 if (sz < 0)
129 return NULL;
130
131 offset += sz;
132 }
133
134 printf("Inode not found.\n");
135
136 return NULL;
137 }
138
sqfs_read_metablock(unsigned char * file_mapping,int offset,bool * compressed,u32 * data_size)139 int sqfs_read_metablock(unsigned char *file_mapping, int offset,
140 bool *compressed, u32 *data_size)
141 {
142 const unsigned char *data;
143 u16 header;
144
145 if (!file_mapping)
146 return -EFAULT;
147 data = file_mapping + offset;
148
149 header = get_unaligned((u16 *)data);
150 if (!header)
151 return -EINVAL;
152
153 *compressed = SQFS_COMPRESSED_METADATA(header);
154 *data_size = SQFS_METADATA_SIZE(header);
155
156 if (*data_size > SQFS_METADATA_BLOCK_SIZE) {
157 printf("Invalid metatada block size: %d bytes.\n", *data_size);
158 return -EINVAL;
159 }
160
161 return 0;
162 }
163