sqfs.c 40 KB

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