4 * Copyright(c) 2016 RehiveTech. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of RehiveTech nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 #include <archive_entry.h>
39 #include <sys/queue.h>
41 #include <rte_debug.h>
45 struct resource_list resource_list = TAILQ_HEAD_INITIALIZER(resource_list);
47 size_t resource_size(const struct resource *r)
49 return r->end - r->begin;
52 const struct resource *resource_find(const char *name)
56 TAILQ_FOREACH(r, &resource_list, next) {
59 if (!strcmp(r->name, name))
66 int resource_fwrite(const struct resource *r, FILE *f)
68 const size_t goal = resource_size(r);
71 while (total < goal) {
72 size_t wlen = fwrite(r->begin + total, 1, goal - total, f);
84 int resource_fwrite_file(const struct resource *r, const char *fname)
89 f = fopen(fname, "w");
95 ret = resource_fwrite(r, f);
100 static int do_copy(struct archive *r, struct archive *w)
104 #if ARCHIVE_VERSION_NUMBER >= 3000000
112 ret = archive_read_data_block(r, &buf, &len, &off);
113 if (ret == ARCHIVE_RETRY)
116 if (ret == ARCHIVE_EOF)
119 if (ret != ARCHIVE_OK)
123 ret = archive_write_data_block(w, buf, len, off);
124 if (ret != ARCHIVE_OK && ret != ARCHIVE_RETRY)
126 } while (ret != ARCHIVE_OK);
130 int resource_untar(const struct resource *res)
134 struct archive_entry *e;
139 p = malloc(resource_size(res));
141 rte_panic("Failed to malloc %zu B\n", resource_size(res));
143 memcpy(p, res->begin, resource_size(res));
145 r = archive_read_new();
151 archive_read_support_format_all(r);
152 archive_read_support_filter_all(r);
154 w = archive_write_disk_new();
156 archive_read_free(r);
161 flags |= ARCHIVE_EXTRACT_PERM;
162 flags |= ARCHIVE_EXTRACT_FFLAGS;
163 archive_write_disk_set_options(w, flags);
164 archive_write_disk_set_standard_lookup(w);
166 ret = archive_read_open_memory(r, p, resource_size(res));
167 if (ret != ARCHIVE_OK)
171 ret = archive_read_next_header(r, &e);
172 if (ret == ARCHIVE_EOF)
174 if (ret != ARCHIVE_OK)
177 ret = archive_write_header(w, e);
178 if (ret == ARCHIVE_EOF)
180 if (ret != ARCHIVE_OK)
183 if (archive_entry_size(e) == 0)
187 if (ret != ARCHIVE_OK)
190 ret = archive_write_finish_entry(w);
191 if (ret != ARCHIVE_OK)
195 archive_write_free(w);
196 archive_read_free(r);
201 archive_write_free(w);
202 archive_read_free(r);
204 rte_panic("Failed: %s\n", archive_error_string(r));
208 int resource_rm_by_tar(const struct resource *res)
211 struct archive_entry *e;
217 p = malloc(resource_size(res));
219 rte_panic("Failed to malloc %zu B\n", resource_size(res));
221 memcpy(p, res->begin, resource_size(res));
224 * If somebody creates a file somewhere inside the extracted TAR
225 * hierarchy during a test the resource_rm_by_tar might loop
226 * infinitely. We prevent this by adding the attempts counter there.
227 * In normal case, max N iteration is done where N is the depth of
228 * the file-hierarchy.
230 while (try_again && attempts < 10000) {
231 r = archive_read_new();
237 archive_read_support_format_all(r);
238 archive_read_support_filter_all(r);
240 ret = archive_read_open_memory(r, p, resource_size(res));
241 if (ret != ARCHIVE_OK) {
242 fprintf(stderr, "Failed: %s\n",
243 archive_error_string(r));
250 ret = archive_read_next_header(r, &e);
251 if (ret == ARCHIVE_EOF)
253 if (ret != ARCHIVE_OK)
256 ret = remove(archive_entry_pathname(e));
264 /* should not usually happen: */
271 perror("Failed to remove file");
277 archive_read_free(r);
281 if (attempts >= 10000) {
282 fprintf(stderr, "Failed to remove archive\n");
291 archive_read_free(r);
294 rte_panic("Failed: %s\n", archive_error_string(r));
298 void resource_register(struct resource *r)
300 TAILQ_INSERT_TAIL(&resource_list, r, next);