Branch data Line data Source code
1 : : /*-
2 : : * Copyright (c) 2011-2013 Baptiste Daroussin <bapt@FreeBSD.org>
3 : : * Copyright (c) 2011-2012 Julien Laffaye <jlaffaye@FreeBSD.org>
4 : : * Copyright (c) 2011-2012 Marin Atanasov Nikolov <dnaeon@gmail.com>
5 : : * Copyright (c) 2012-2013 Matthew Seaman <matthew@FreeBSD.org>
6 : : * Copyright (c) 2014 Vsevolod Stakhov <vsevolod@FreeBSD.org>
7 : : * Copyright (c) 2023 Serenity Cyber Security, LLC
8 : : * Author: Gleb Popov <arrowd@FreeBSD.org>
9 : : *
10 : : * All rights reserved.
11 : : *
12 : : * Redistribution and use in source and binary forms, with or without
13 : : * modification, are permitted provided that the following conditions
14 : : * are met:
15 : : * 1. Redistributions of source code must retain the above copyright
16 : : * notice, this list of conditions and the following disclaimer
17 : : * in this position and unchanged.
18 : : * 2. Redistributions in binary form must reproduce the above copyright
19 : : * notice, this list of conditions and the following disclaimer in the
20 : : * documentation and/or other materials provided with the distribution.
21 : : *
22 : : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
23 : : * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 : : * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 : : * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
26 : : * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 : : * NOT 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 OF
31 : : * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 : : */
33 : :
34 : : #include <sys/stat.h>
35 : : #include <sys/param.h>
36 : : #include <sys/mman.h>
37 : :
38 : : #include <stdio.h>
39 : : #include <stdlib.h>
40 : : #include <string.h>
41 : : #include <unistd.h>
42 : : #include <errno.h>
43 : : #include <limits.h>
44 : :
45 : : #include <libgen.h>
46 : :
47 : : #include "pkg.h"
48 : : #include "private/event.h"
49 : : #include "private/utils.h"
50 : : #include "private/pkgdb.h"
51 : : #include "private/pkg.h"
52 : : #include "binary.h"
53 : :
54 : : extern struct pkg_ctx ctx;
55 : :
56 : : int
57 : 354 : pkg_repo_binary_get_cached_name(struct pkg_repo *repo, struct pkg *pkg,
58 : : char *dest, size_t destlen)
59 : : {
60 : 354 : const char *ext = NULL;
61 : : const char *packagesite;
62 : : struct stat st;
63 : :
64 : 354 : packagesite = pkg_repo_url(repo);
65 : :
66 [ + + ]: 354 : if (strncmp(packagesite, "file:/", 6) == 0) {
67 : 684 : snprintf(dest, destlen, "%s/%s", packagesite + 6,
68 : 342 : pkg->repopath);
69 : 342 : return (EPKG_OK);
70 : : }
71 : :
72 [ - + ]: 12 : if (pkg->repopath != NULL)
73 : 12 : ext = strrchr(pkg->repopath, '.');
74 : :
75 [ + - ]: 12 : if (ext != NULL) {
76 : : /*
77 : : * The real naming scheme:
78 : : * <cachedir>/<name>-<version>-<checksum>.txz
79 : : */
80 : 24 : pkg_snprintf(dest, destlen, "%S/%n-%v%S%z%S",
81 : 12 : ctx.cachedir, pkg, pkg, PKG_HASH_SEPSTR, pkg, ext);
82 [ + + - + ]: 12 : if (stat (dest, &st) == -1 || pkg->pkgsize != st.st_size)
83 : 8 : return (EPKG_FATAL);
84 : :
85 : 4 : }
86 : : else {
87 : 0 : pkg_snprintf(dest, destlen, "%S/%n-%v%S%z", ctx.cachedir, pkg,
88 : 0 : pkg, PKG_HASH_SEPSTR, pkg);
89 : : }
90 : :
91 : 4 : return (EPKG_OK);
92 : 354 : }
93 : :
94 : : static int
95 : 2 : pkg_repo_binary_create_symlink(struct pkg *pkg, const char *fname,
96 : : const char *dir)
97 : : {
98 : : const char *ext, *dest_fname;
99 : : char link_dest_tmp[MAXPATHLEN], link_dest[MAXPATHLEN];
100 : :
101 : : /* Create symlink from full pkgname */
102 : 2 : ext = strrchr(fname, '.');
103 : 4 : pkg_snprintf(link_dest, sizeof(link_dest), "%S/%n-%v%S",
104 [ + - ]: 2 : dir, pkg, pkg, ext ? ext : "");
105 : 2 : snprintf(link_dest_tmp, sizeof(link_dest_tmp), "%s.new", link_dest);
106 : :
107 : : /* Ignore errors here */
108 : 2 : (void)unlink(link_dest_tmp);
109 : :
110 : : /* Trim the path to just the filename. */
111 [ - + ]: 2 : if ((dest_fname = strrchr(fname, '/')) != NULL)
112 : 2 : ++dest_fname;
113 [ + - ]: 2 : if (symlink(dest_fname, link_dest_tmp) == -1) {
114 : 0 : pkg_emit_errno("symlink", link_dest);
115 : 0 : return (EPKG_FATAL);
116 : : }
117 : :
118 [ + - ]: 2 : if (rename(link_dest_tmp, link_dest) == -1) {
119 : 0 : pkg_emit_errno("rename", link_dest);
120 : 0 : unlink(link_dest_tmp);
121 : 0 : return (EPKG_FATAL);
122 : : }
123 : :
124 : 2 : return (EPKG_OK);
125 : 2 : }
126 : :
127 : : static int
128 : 10 : pkg_repo_binary_try_fetch(struct pkg_repo *repo, struct pkg *pkg,
129 : : bool already_tried, bool mirror, const char *destdir)
130 : : {
131 : : char dest[MAXPATHLEN];
132 : : char url[MAXPATHLEN];
133 : 10 : char *dir = NULL;
134 : 10 : bool fetched = false;
135 : : struct stat st;
136 : 10 : const char *packagesite = NULL;
137 : 10 : ssize_t offset = -1;
138 : : int retval;
139 : :
140 : 10 : int retcode = EPKG_OK;
141 : :
142 [ + - ]: 10 : assert((pkg->type & PKG_REMOTE) == PKG_REMOTE);
143 : :
144 [ - + ]: 10 : if (mirror) {
145 : : const char *cachedir;
146 : :
147 [ # # ]: 0 : if (destdir != NULL)
148 : 0 : cachedir = destdir;
149 : : else
150 : 0 : cachedir = ctx.cachedir;
151 : :
152 : 0 : snprintf(dest, sizeof(dest), "%s/%s", cachedir, pkg->repopath);
153 : 0 : }
154 : : else
155 : 10 : pkg_repo_binary_get_cached_name(repo, pkg, dest, sizeof(dest));
156 : :
157 : : /* If it is already in the local cachedir, dont bother to
158 : : * download it */
159 [ + + ]: 10 : if (stat(dest, &st) == 0) {
160 : : /* try to resume */
161 [ - + ]: 4 : if (pkg->pkgsize > st.st_size) {
162 : 0 : offset = st.st_size;
163 : 0 : pkg_debug(1, "Resuming fetch");
164 : 0 : } else {
165 : 4 : goto checksum;
166 : : }
167 : 0 : }
168 : :
169 : : /* Create the dirs in cachedir */
170 : 6 : dir = get_dirname(xstrdup(dest));
171 [ - + ]: 6 : if ((retcode = pkg_mkdirs(dir)) != EPKG_OK)
172 : 0 : goto cleanup;
173 : :
174 : : /*
175 : : * In multi-repos the remote URL is stored in pkg[PKG_REPOURL]
176 : : * For a single attached database the repository URL should be
177 : : * defined by URL.
178 : : */
179 : 6 : packagesite = pkg_repo_url(repo);
180 : :
181 [ + - - + ]: 6 : if (packagesite == NULL || packagesite[0] == '\0') {
182 : 0 : pkg_emit_error("URL is not defined");
183 : 0 : retcode = 1;
184 : 0 : goto cleanup;
185 : : }
186 : :
187 [ - + ]: 6 : if (packagesite[strlen(packagesite) - 1] == '/')
188 : 0 : pkg_snprintf(url, sizeof(url), "%S%R", packagesite, pkg);
189 : : else
190 : 6 : pkg_snprintf(url, sizeof(url), "%S/%R", packagesite, pkg);
191 : :
192 [ + - + + ]: 6 : if (!mirror && strncasecmp(url, "file://", 7) == 0) {
193 : 4 : free(dir);
194 [ + - ]: 4 : if (access(url + strlen("file://"), F_OK) == 0) {
195 : 0 : return (EPKG_OK);
196 : : }
197 : 4 : pkg_emit_error("cached package %s-%s: "
198 : : "%s is missing from repo\n",
199 : 4 : pkg->name, pkg->version, url);
200 : 4 : return EPKG_FATAL;
201 : : }
202 : :
203 : 2 : retcode = pkg_fetch_file(repo, pkg->repopath, dest, 0, offset, pkg->pkgsize);
204 : :
205 [ - + ]: 2 : if (offset == -1)
206 : 2 : fetched = true;
207 : :
208 [ - + ]: 2 : if (retcode != EPKG_OK)
209 : 0 : goto cleanup;
210 : :
211 : : checksum:
212 : : /* checksum calculation is expensive, if size does not
213 : : match, skip it and assume failed checksum. */
214 [ + - - + ]: 6 : if (stat(dest, &st) == -1 || pkg->pkgsize != st.st_size) {
215 [ # # ]: 0 : if (already_tried) {
216 : 0 : pkg_emit_error("cached package %s-%s: "
217 : : "missing or size mismatch, cannot continue\n"
218 : : "Consider running 'pkg update -f'",
219 : 0 : pkg->name, pkg->version);
220 : 0 : retcode = EPKG_FATAL;
221 : 0 : goto cleanup;
222 : : }
223 : :
224 : 0 : unlink(dest);
225 : 0 : free(dir);
226 : 0 : pkg_emit_error("cached package %s-%s: "
227 : : "missing or size mismatch, fetching from remote",
228 : 0 : pkg->name, pkg->version);
229 : 0 : return (pkg_repo_binary_try_fetch(repo, pkg, true, mirror, destdir));
230 : : }
231 : 6 : retval = pkg_checksum_validate_file(dest, pkg->sum);
232 [ - + ]: 6 : if (retval == ENOENT) {
233 : 0 : pkg_emit_error("%s-%s missing "
234 : 0 : "from repository", pkg->name, pkg->version);
235 : 0 : return EPKG_FATAL;
236 : : }
237 [ + - ]: 6 : if (retval != 0) {
238 [ # # # # ]: 0 : if (already_tried || fetched) {
239 : 0 : pkg_emit_error("%s-%s failed checksum "
240 : 0 : "from repository", pkg->name, pkg->version);
241 : 0 : retcode = EPKG_FATAL;
242 : 0 : } else {
243 : 0 : pkg_emit_error("cached package %s-%s: "
244 : : "checksum mismatch, fetching from remote",
245 : 0 : pkg->name, pkg->version);
246 : 0 : unlink(dest);
247 : 0 : return (pkg_repo_binary_try_fetch(repo, pkg, true, mirror, destdir));
248 : : }
249 : 0 : }
250 : :
251 : : cleanup:
252 : :
253 [ - + ]: 6 : if (retcode != EPKG_OK)
254 : 0 : unlink(dest);
255 [ + - + + ]: 6 : else if (!mirror && dir != NULL) {
256 : 2 : (void)pkg_repo_binary_create_symlink(pkg, dest, dir);
257 : 2 : }
258 : :
259 : : /* allowed even if dir is NULL */
260 : 6 : free(dir);
261 : :
262 : 6 : return (retcode);
263 : 10 : }
264 : :
265 : : int
266 : 10 : pkg_repo_binary_fetch(struct pkg_repo *repo, struct pkg *pkg)
267 : : {
268 : 10 : return (pkg_repo_binary_try_fetch(repo, pkg, false, false, NULL));
269 : : }
270 : :
271 : : int
272 : 0 : pkg_repo_binary_mirror(struct pkg_repo *repo, struct pkg *pkg,
273 : : const char *destdir)
274 : : {
275 : 0 : return (pkg_repo_binary_try_fetch(repo, pkg, false, true, destdir));
276 : : }
|
