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 <sys/queue.h>
39 #include <rte_debug.h>
43 struct resource_list resource_list
= TAILQ_HEAD_INITIALIZER(resource_list
);
45 size_t resource_size(const struct resource
*r
)
47 return r
->end
- r
->begin
;
50 const struct resource
*resource_find(const char *name
)
54 TAILQ_FOREACH(r
, &resource_list
, next
) {
57 if (!strcmp(r
->name
, name
))
64 int resource_fwrite(const struct resource
*r
, FILE *f
)
66 const size_t goal
= resource_size(r
);
69 while (total
< goal
) {
70 size_t wlen
= fwrite(r
->begin
+ total
, 1, goal
- total
, f
);
82 int resource_fwrite_file(const struct resource
*r
, const char *fname
)
87 f
= fopen(fname
, "w");
93 ret
= resource_fwrite(r
, f
);
98 #ifdef RTE_APP_TEST_RESOURCE_TAR
100 #include <archive_entry.h>
102 static int do_copy(struct archive
*r
, struct archive
*w
)
106 #if ARCHIVE_VERSION_NUMBER >= 3000000
114 ret
= archive_read_data_block(r
, &buf
, &len
, &off
);
115 if (ret
== ARCHIVE_RETRY
)
118 if (ret
== ARCHIVE_EOF
)
121 if (ret
!= ARCHIVE_OK
)
125 ret
= archive_write_data_block(w
, buf
, len
, off
);
126 if (ret
!= ARCHIVE_OK
&& ret
!= ARCHIVE_RETRY
)
128 } while (ret
!= ARCHIVE_OK
);
132 int resource_untar(const struct resource
*res
)
136 struct archive_entry
*e
;
141 p
= malloc(resource_size(res
));
143 rte_panic("Failed to malloc %zu B\n", resource_size(res
));
145 memcpy(p
, res
->begin
, resource_size(res
));
147 r
= archive_read_new();
153 archive_read_support_format_all(r
);
154 archive_read_support_filter_all(r
);
156 w
= archive_write_disk_new();
158 archive_read_free(r
);
163 flags
|= ARCHIVE_EXTRACT_PERM
;
164 flags
|= ARCHIVE_EXTRACT_FFLAGS
;
165 archive_write_disk_set_options(w
, flags
);
166 archive_write_disk_set_standard_lookup(w
);
168 ret
= archive_read_open_memory(r
, p
, resource_size(res
));
169 if (ret
!= ARCHIVE_OK
)
173 ret
= archive_read_next_header(r
, &e
);
174 if (ret
== ARCHIVE_EOF
)
176 if (ret
!= ARCHIVE_OK
)
179 ret
= archive_write_header(w
, e
);
180 if (ret
== ARCHIVE_EOF
)
182 if (ret
!= ARCHIVE_OK
)
185 if (archive_entry_size(e
) == 0)
189 if (ret
!= ARCHIVE_OK
)
192 ret
= archive_write_finish_entry(w
);
193 if (ret
!= ARCHIVE_OK
)
197 archive_write_free(w
);
198 archive_read_free(r
);
203 archive_write_free(w
);
204 archive_read_free(r
);
206 rte_panic("Failed: %s\n", archive_error_string(r
));
210 int resource_rm_by_tar(const struct resource
*res
)
213 struct archive_entry
*e
;
219 p
= malloc(resource_size(res
));
221 rte_panic("Failed to malloc %zu B\n", resource_size(res
));
223 memcpy(p
, res
->begin
, resource_size(res
));
226 * If somebody creates a file somewhere inside the extracted TAR
227 * hierarchy during a test the resource_rm_by_tar might loop
228 * infinitely. We prevent this by adding the attempts counter there.
229 * In normal case, max N iteration is done where N is the depth of
230 * the file-hierarchy.
232 while (try_again
&& attempts
< 10000) {
233 r
= archive_read_new();
239 archive_read_support_format_all(r
);
240 archive_read_support_filter_all(r
);
242 ret
= archive_read_open_memory(r
, p
, resource_size(res
));
243 if (ret
!= ARCHIVE_OK
) {
244 fprintf(stderr
, "Failed: %s\n",
245 archive_error_string(r
));
252 ret
= archive_read_next_header(r
, &e
);
253 if (ret
== ARCHIVE_EOF
)
255 if (ret
!= ARCHIVE_OK
)
258 ret
= remove(archive_entry_pathname(e
));
266 /* should not usually happen: */
273 perror("Failed to remove file");
279 archive_read_free(r
);
283 if (attempts
>= 10000) {
284 fprintf(stderr
, "Failed to remove archive\n");
293 archive_read_free(r
);
296 rte_panic("Failed: %s\n", archive_error_string(r
));
300 #endif /* RTE_APP_TEST_RESOURCE_TAR */
302 void resource_register(struct resource
*r
)
304 TAILQ_INSERT_TAIL(&resource_list
, r
, next
);