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