blob: 073d92f777059cbd565c2590184395c49dca70b3 (
plain)
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
|
/* SPDX-License-Identifier: LGPL-3.0-or-later */
/*
* fileapi.c
*
* Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
*/
#define SQFS_BUILDING_DLL
#include "internal.h"
static int add_sentinel_block(sqfs_block_processor_t *proc)
{
sqfs_block_t *blk = calloc(1, sizeof(*blk));
if (blk == NULL)
return SQFS_ERROR_ALLOC;
blk->inode = proc->inode;
blk->flags = proc->blk_flags | SQFS_BLK_LAST_BLOCK;
return append_to_work_queue(proc, blk);
}
static int flush_block(sqfs_block_processor_t *proc)
{
sqfs_block_t *block = proc->blk_current;
proc->blk_current = NULL;
if (block->size < proc->max_block_size &&
!(block->flags & SQFS_BLK_DONT_FRAGMENT)) {
block->flags |= SQFS_BLK_IS_FRAGMENT;
} else {
proc->blk_flags &= ~SQFS_BLK_FIRST_BLOCK;
}
return append_to_work_queue(proc, block);
}
int sqfs_block_processor_begin_file(sqfs_block_processor_t *proc,
sqfs_inode_generic_t *inode, sqfs_u32 flags)
{
if (proc->inode != NULL)
return SQFS_ERROR_SEQUENCE;
if (flags & ~SQFS_BLK_USER_SETTABLE_FLAGS)
return SQFS_ERROR_UNSUPPORTED;
proc->inode = inode;
proc->blk_flags = flags | SQFS_BLK_FIRST_BLOCK;
return 0;
}
int sqfs_block_processor_append(sqfs_block_processor_t *proc, const void *data,
size_t size)
{
sqfs_block_t *new;
size_t diff;
int err;
while (size > 0) {
if (proc->blk_current == NULL) {
new = alloc_flex(sizeof(*new), 1, proc->max_block_size);
if (new == NULL)
return SQFS_ERROR_ALLOC;
proc->blk_current = new;
proc->blk_current->flags = proc->blk_flags;
proc->blk_current->inode = proc->inode;
}
diff = proc->max_block_size - proc->blk_current->size;
if (diff == 0) {
err = flush_block(proc);
if (err)
return err;
continue;
}
if (diff > size)
diff = size;
memcpy(proc->blk_current->data + proc->blk_current->size,
data, diff);
size -= diff;
proc->blk_current->size += diff;
data = (const char *)data + diff;
proc->stats.input_bytes_read += diff;
}
if (proc->blk_current != NULL &&
proc->blk_current->size == proc->max_block_size) {
return flush_block(proc);
}
return 0;
}
int sqfs_block_processor_end_file(sqfs_block_processor_t *proc)
{
int err;
if (proc->inode == NULL)
return SQFS_ERROR_SEQUENCE;
if (!(proc->blk_flags & SQFS_BLK_FIRST_BLOCK)) {
if (proc->blk_current != NULL &&
(proc->blk_flags & SQFS_BLK_DONT_FRAGMENT)) {
proc->blk_flags |= SQFS_BLK_LAST_BLOCK;
} else {
err = add_sentinel_block(proc);
if (err)
return err;
}
}
if (proc->blk_current != NULL) {
err = flush_block(proc);
if (err)
return err;
}
proc->inode = NULL;
proc->blk_flags = 0;
return 0;
}
|
