1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2016 RehiveTech. All rights reserved.
3 */
4
5 #include <stdio.h>
6 #include <string.h>
7 #include <errno.h>
8 #include <sys/queue.h>
9
10 #include <rte_debug.h>
11
12 #include "resource.h"
13
14 struct resource_list resource_list = TAILQ_HEAD_INITIALIZER(resource_list);
15
resource_size(const struct resource * r)16 size_t resource_size(const struct resource *r)
17 {
18 return r->end - r->begin;
19 }
20
resource_find(const char * name)21 const struct resource *resource_find(const char *name)
22 {
23 struct resource *r;
24
25 TAILQ_FOREACH(r, &resource_list, next) {
26 RTE_VERIFY(r->name);
27
28 if (!strcmp(r->name, name))
29 return r;
30 }
31
32 return NULL;
33 }
34
resource_fwrite(const struct resource * r,FILE * f)35 int resource_fwrite(const struct resource *r, FILE *f)
36 {
37 const size_t goal = resource_size(r);
38 size_t total = 0;
39
40 while (total < goal) {
41 size_t wlen = fwrite(r->begin + total, 1, goal - total, f);
42 if (wlen == 0) {
43 perror(__func__);
44 return -1;
45 }
46
47 total += wlen;
48 }
49
50 return 0;
51 }
52
resource_fwrite_file(const struct resource * r,const char * fname)53 int resource_fwrite_file(const struct resource *r, const char *fname)
54 {
55 FILE *f;
56 int ret;
57
58 f = fopen(fname, "w");
59 if (f == NULL) {
60 perror(__func__);
61 return -1;
62 }
63
64 ret = resource_fwrite(r, f);
65 fclose(f);
66 return ret;
67 }
68
69 #ifdef RTE_APP_TEST_RESOURCE_TAR
70 #include <archive.h>
71 #include <archive_entry.h>
72
do_copy(struct archive * r,struct archive * w)73 static int do_copy(struct archive *r, struct archive *w)
74 {
75 const void *buf;
76 size_t len;
77 #if ARCHIVE_VERSION_NUMBER >= 3000000
78 int64_t off;
79 #else
80 off_t off;
81 #endif
82 int ret;
83
84 while (1) {
85 ret = archive_read_data_block(r, &buf, &len, &off);
86 if (ret == ARCHIVE_RETRY)
87 continue;
88
89 if (ret == ARCHIVE_EOF)
90 return 0;
91
92 if (ret != ARCHIVE_OK)
93 return ret;
94
95 do {
96 ret = archive_write_data_block(w, buf, len, off);
97 if (ret != ARCHIVE_OK && ret != ARCHIVE_RETRY)
98 return ret;
99 } while (ret != ARCHIVE_OK);
100 }
101 }
102
resource_untar(const struct resource * res)103 int resource_untar(const struct resource *res)
104 {
105 struct archive *r;
106 struct archive *w;
107 struct archive_entry *e;
108 void *p;
109 int flags = 0;
110 int ret;
111
112 p = malloc(resource_size(res));
113 if (p == NULL)
114 rte_panic("Failed to malloc %zu B\n", resource_size(res));
115
116 memcpy(p, res->begin, resource_size(res));
117
118 r = archive_read_new();
119 if (r == NULL) {
120 free(p);
121 return -1;
122 }
123
124 archive_read_support_format_all(r);
125 archive_read_support_filter_all(r);
126
127 w = archive_write_disk_new();
128 if (w == NULL) {
129 archive_read_free(r);
130 free(p);
131 return -1;
132 }
133
134 flags |= ARCHIVE_EXTRACT_PERM;
135 flags |= ARCHIVE_EXTRACT_FFLAGS;
136 archive_write_disk_set_options(w, flags);
137 archive_write_disk_set_standard_lookup(w);
138
139 ret = archive_read_open_memory(r, p, resource_size(res));
140 if (ret != ARCHIVE_OK)
141 goto fail;
142
143 while (1) {
144 ret = archive_read_next_header(r, &e);
145 if (ret == ARCHIVE_EOF)
146 break;
147 if (ret != ARCHIVE_OK)
148 goto fail;
149
150 ret = archive_write_header(w, e);
151 if (ret == ARCHIVE_EOF)
152 break;
153 if (ret != ARCHIVE_OK)
154 goto fail;
155
156 if (archive_entry_size(e) == 0)
157 continue;
158
159 ret = do_copy(r, w);
160 if (ret != ARCHIVE_OK)
161 goto fail;
162
163 ret = archive_write_finish_entry(w);
164 if (ret != ARCHIVE_OK)
165 goto fail;
166 }
167
168 archive_write_free(w);
169 archive_read_free(r);
170 free(p);
171 return 0;
172
173 fail:
174 archive_write_free(w);
175 archive_read_free(r);
176 free(p);
177 rte_panic("Failed: %s\n", archive_error_string(r));
178 return -1;
179 }
180
resource_rm_by_tar(const struct resource * res)181 int resource_rm_by_tar(const struct resource *res)
182 {
183 struct archive *r;
184 struct archive_entry *e;
185 void *p;
186 int try_again = 1;
187 int attempts = 0;
188 int ret;
189
190 p = malloc(resource_size(res));
191 if (p == NULL)
192 rte_panic("Failed to malloc %zu B\n", resource_size(res));
193
194 memcpy(p, res->begin, resource_size(res));
195
196 /*
197 * If somebody creates a file somewhere inside the extracted TAR
198 * hierarchy during a test the resource_rm_by_tar might loop
199 * infinitely. We prevent this by adding the attempts counter there.
200 * In normal case, max N iteration is done where N is the depth of
201 * the file-hierarchy.
202 */
203 while (try_again && attempts < 10000) {
204 r = archive_read_new();
205 if (r == NULL) {
206 free(p);
207 return -1;
208 }
209
210 archive_read_support_format_all(r);
211 archive_read_support_filter_all(r);
212
213 ret = archive_read_open_memory(r, p, resource_size(res));
214 if (ret != ARCHIVE_OK) {
215 fprintf(stderr, "Failed: %s\n",
216 archive_error_string(r));
217 goto fail;
218 }
219
220 try_again = 0;
221
222 while (1) {
223 ret = archive_read_next_header(r, &e);
224 if (ret == ARCHIVE_EOF)
225 break;
226 if (ret != ARCHIVE_OK)
227 goto fail;
228
229 ret = remove(archive_entry_pathname(e));
230 if (ret < 0) {
231 switch (errno) {
232 case ENOTEMPTY:
233 case EEXIST:
234 try_again = 1;
235 break;
236
237 /* should not usually happen: */
238 case ENOENT:
239 case ENOTDIR:
240 case EROFS:
241 attempts += 1;
242 continue;
243 default:
244 perror("Failed to remove file");
245 goto fail;
246 }
247 }
248 }
249
250 archive_read_free(r);
251 attempts += 1;
252 }
253
254 if (attempts >= 10000) {
255 fprintf(stderr, "Failed to remove archive\n");
256 free(p);
257 return -1;
258 }
259
260 free(p);
261 return 0;
262
263 fail:
264 archive_read_free(r);
265 free(p);
266
267 rte_panic("Failed: %s\n", archive_error_string(r));
268 return -1;
269 }
270
271 #endif /* RTE_APP_TEST_RESOURCE_TAR */
272
resource_register(struct resource * r)273 void resource_register(struct resource *r)
274 {
275 TAILQ_INSERT_TAIL(&resource_list, r, next);
276 }
277