1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/* SPDX-License-Identifier: GPL-3.0-or-later */
/*
* write_dir.c
*
* Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
*/
#include "config.h"
#include "sqfs/inode.h"
#include "sqfs/dir.h"
#include "highlevel.h"
#include "util.h"
#include <sys/stat.h>
#include <assert.h>
#include <endian.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
static int get_type(mode_t mode)
{
switch (mode & S_IFMT) {
case S_IFSOCK: return SQFS_INODE_SOCKET;
case S_IFIFO: return SQFS_INODE_FIFO;
case S_IFLNK: return SQFS_INODE_SLINK;
case S_IFBLK: return SQFS_INODE_BDEV;
case S_IFCHR: return SQFS_INODE_CDEV;
case S_IFDIR: return SQFS_INODE_DIR;
case S_IFREG: return SQFS_INODE_FILE;
default:
assert(0);
}
}
static int dir_index_grow(dir_index_t **index)
{
size_t size = sizeof(dir_index_t) + sizeof(idx_ref_t) * 10;
void *new;
if (*index == NULL) {
new = calloc(1, size);
} else {
if ((*index)->num_nodes < (*index)->max_nodes)
return 0;
size += sizeof(idx_ref_t) * (*index)->num_nodes;
new = realloc(*index, size);
}
if (new == NULL) {
perror("creating directory index");
return -1;
}
*index = new;
(*index)->max_nodes += 10;
return 0;
}
int meta_writer_write_dir(meta_writer_t *dm, dir_info_t *dir,
dir_index_t **index)
{
size_t i, size, count;
sqfs_dir_header_t hdr;
sqfs_dir_entry_t ent;
tree_node_t *c, *d;
uint16_t *diff_u16;
uint32_t offset;
uint64_t block;
int32_t diff;
c = dir->children;
dir->size = 0;
meta_writer_get_position(dm, &dir->start_block, &dir->block_offset);
while (c != NULL) {
meta_writer_get_position(dm, &block, &offset);
count = 0;
size = (offset + sizeof(hdr)) % SQFS_META_BLOCK_SIZE;
for (d = c; d != NULL; d = d->next) {
if ((d->inode_ref >> 16) != (c->inode_ref >> 16))
break;
diff = d->inode_num - c->inode_num;
if (diff > 32767 || diff < -32767)
break;
size += sizeof(ent) + strlen(c->name);
if (count > 0 && size > SQFS_META_BLOCK_SIZE)
break;
count += 1;
}
if (count > SQFS_MAX_DIR_ENT)
count = SQFS_MAX_DIR_ENT;
if (dir_index_grow(index))
return -1;
meta_writer_get_position(dm, &block, &offset);
i = (*index)->num_nodes++;
(*index)->idx_nodes[i].node = c;
(*index)->idx_nodes[i].block = block;
(*index)->idx_nodes[i].index = dir->size;
hdr.count = htole32(count - 1);
hdr.start_block = htole32(c->inode_ref >> 16);
hdr.inode_number = htole32(c->inode_num);
dir->size += sizeof(hdr);
if (meta_writer_append(dm, &hdr, sizeof(hdr)))
return -1;
d = c;
for (i = 0; i < count; ++i) {
ent.inode_diff = c->inode_num - d->inode_num;
diff_u16 = (uint16_t *)&ent.inode_diff;
*diff_u16 = htole16(*diff_u16);
ent.offset = htole16(c->inode_ref & 0x0000FFFF);
ent.type = htole16(get_type(c->mode));
ent.size = htole16(strlen(c->name) - 1);
dir->size += sizeof(ent) + strlen(c->name);
if (meta_writer_append(dm, &ent, sizeof(ent)))
return -1;
if (meta_writer_append(dm, c->name, strlen(c->name)))
return -1;
c = c->next;
}
}
return 0;
}
|
