dload.c 22.3 KB
Newer Older
Dan McGee's avatar
Dan McGee committed
1
/*
2
 *  dload.c
Dan McGee's avatar
Dan McGee committed
3
 *
Allan McRae's avatar
Allan McRae committed
4
 *  Copyright (c) 2006-2018 Pacman Development Team <pacman-dev@archlinux.org>
5
 *  Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
Dan McGee's avatar
Dan McGee committed
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
26
#include <sys/socket.h> /* setsockopt, SO_KEEPALIVE */
27
28
29
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
30
#include <signal.h>
31

32
33
34
35
36
37
38
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h> /* IPPROTO_TCP */
#endif
#ifdef HAVE_NETINET_TCP_H
#include <netinet/tcp.h> /* TCP_KEEPINTVL, TCP_KEEPIDLE */
#endif

39
40
41
42
#ifdef HAVE_LIBCURL
#include <curl/curl.h>
#endif

Dan McGee's avatar
Dan McGee committed
43
44
45
46
47
48
49
50
/* libalpm */
#include "dload.h"
#include "alpm_list.h"
#include "alpm.h"
#include "log.h"
#include "util.h"
#include "handle.h"

51
#ifdef HAVE_LIBCURL
52
static const char *get_filename(const char *url)
53
{
54
55
56
57
	char *filename = strrchr(url, '/');
	if(filename != NULL) {
		filename++;
	}
58
	return filename;
59
}
60

61
62
static char *get_fullpath(const char *path, const char *filename,
		const char *suffix)
63
{
64
65
66
	char *filepath;
	/* len = localpath len + filename len + suffix len + null */
	size_t len = strlen(path) + strlen(filename) + strlen(suffix) + 1;
67
	MALLOC(filepath, len, return NULL);
68
	snprintf(filepath, len, "%s%s%s", path, filename, suffix);
69

70
	return filepath;
71
72
}

73
74
75
76
77
78
79
80
81
static CURL *get_libcurl_handle(alpm_handle_t *handle)
{
	if(!handle->curl) {
		curl_global_init(CURL_GLOBAL_SSL);
		handle->curl = curl_easy_init();
	}
	return handle->curl;
}

82
83
84
85
86
enum {
	ABORT_SIGINT = 1,
	ABORT_OVER_MAXFILESIZE
};

87
static int dload_interrupted;
88
static void inthandler(int UNUSED signum)
89
{
90
	dload_interrupted = ABORT_SIGINT;
91
}
92

93
94
static int dload_progress_cb(void *file, curl_off_t dltotal, curl_off_t dlnow,
		curl_off_t UNUSED ultotal, curl_off_t UNUSED ulnow)
95
{
96
	struct dload_payload *payload = (struct dload_payload *)file;
97
	off_t current_size, total_size;
98

99
100
101
102
103
	/* avoid displaying progress bar for redirects with a body */
	if(payload->respcode >= 300) {
		return 0;
	}

104
105
106
107
108
	/* SIGINT sent, abort by alerting curl */
	if(dload_interrupted) {
		return 1;
	}

109
	current_size = payload->initial_size + dlnow;
110
111
112

	/* is our filesize still under any set limit? */
	if(payload->max_size && current_size > payload->max_size) {
113
		dload_interrupted = ABORT_OVER_MAXFILESIZE;
114
115
116
		return 1;
	}

117
	/* none of what follows matters if the front end has no callback */
118
	if(payload->handle->dlcb == NULL) {
119
120
121
		return 0;
	}

122
	total_size = payload->initial_size + dltotal;
123

124
	if(dltotal == 0 || payload->prevprogress == total_size) {
125
		return 0;
126
127
	}

128
	/* initialize the progress bar here to avoid displaying it when
129
130
131
132
133
134
135
	 * a repo is up to date and nothing gets downloaded.
	 * payload->handle->dlcb will receive the remote_name
	 * and the following arguments:
	 * 0, -1: download initialized
	 * 0, 0: non-download event
	 * x {x>0}, x: download complete
	 * x {x>0, x<y}, y {y > 0}: download progress, expected total is known */
136
	if(!payload->cb_initialized) {
137
		payload->handle->dlcb(payload->remote_name, 0, -1);
138
139
140
		payload->cb_initialized = 1;
	}
	if(payload->prevprogress == current_size) {
141
142
		payload->handle->dlcb(payload->remote_name, 0, 0);
	} else {
143
144
	/* do NOT include initial_size since it wasn't part of the package's
	 * download_size (nor included in the total download size callback) */
145
		payload->handle->dlcb(payload->remote_name, dlnow, dltotal);
146
	}
147

148
	payload->prevprogress = current_size;
149

150
	return 0;
151
152
}

153
static int curl_gethost(const char *url, char *buffer, size_t buf_len)
154
{
155
	size_t hostlen;
156
	char *p, *q;
157
158

	if(strncmp(url, "file://", 7) == 0) {
159
160
		p = _("disk");
		hostlen = strlen(p);
161
162
163
	} else {
		p = strstr(url, "//");
		if(!p) {
164
			return 1;
165
166
167
		}
		p += 2; /* jump over the found // */
		hostlen = strcspn(p, "/");
168

Dave Reisner's avatar
Dave Reisner committed
169
170
171
172
173
174
175
176
177
		/* there might be a user:pass@ on the URL. hide it. avoid using memrchr()
		 * for portability concerns. */
		q = p + hostlen;
		while(--q > p) {
			if(*q == '@') {
				break;
			}
		}
		if(*q == '@' && p != q) {
178
179
180
			hostlen -= q - p + 1;
			p = q + 1;
		}
181
	}
182

183
184
185
	if(hostlen > buf_len - 1) {
		/* buffer overflow imminent */
		return 1;
186
	}
187
188
	memcpy(buffer, p, hostlen);
	buffer[hostlen] = '\0';
189

190
	return 0;
191
192
}

Dan McGee's avatar
Dan McGee committed
193
static int utimes_long(const char *path, long seconds)
194
{
Dan McGee's avatar
Dan McGee committed
195
	if(seconds != -1) {
196
197
		struct timeval tv[2];
		memset(&tv, 0, sizeof(tv));
Dan McGee's avatar
Dan McGee committed
198
		tv[0].tv_sec = tv[1].tv_sec = seconds;
199
200
201
202
203
		return utimes(path, tv);
	}
	return 0;
}

204
205
206
207
208
209
210
211
/* prefix to avoid possible future clash with getumask(3) */
static mode_t _getumask(void)
{
	mode_t mask = umask(0);
	umask(mask);
	return mask;
}

212
static size_t dload_parseheader_cb(void *ptr, size_t size, size_t nmemb, void *user)
Dave Reisner's avatar
Dave Reisner committed
213
214
215
216
217
{
	size_t realsize = size * nmemb;
	const char *fptr, *endptr = NULL;
	const char * const cd_header = "Content-Disposition:";
	const char * const fn_key = "filename=";
218
	struct dload_payload *payload = (struct dload_payload *)user;
219
	long respcode;
Dave Reisner's avatar
Dave Reisner committed
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235

	if(_alpm_raw_ncmp(cd_header, ptr, strlen(cd_header)) == 0) {
		if((fptr = strstr(ptr, fn_key))) {
			fptr += strlen(fn_key);

			/* find the end of the field, which is either a semi-colon, or the end of
			 * the data. As per curl_easy_setopt(3), we cannot count on headers being
			 * null terminated, so we look for the closing \r\n */
			endptr = fptr + strcspn(fptr, ";\r\n") - 1;

			/* remove quotes */
			if(*fptr == '"' && *endptr == '"') {
				fptr++;
				endptr--;
			}

236
			STRNDUP(payload->content_disp_name, fptr, endptr - fptr + 1,
237
					RET_ERR(payload->handle, ALPM_ERR_MEMORY, realsize));
Dave Reisner's avatar
Dave Reisner committed
238
239
		}
	}
240

241
242
243
244
245
	curl_easy_getinfo(payload->handle->curl, CURLINFO_RESPONSE_CODE, &respcode);
	if(payload->respcode != respcode) {
		payload->respcode = respcode;
	}

Dave Reisner's avatar
Dave Reisner committed
246
247
248
	return realsize;
}

249
static void curl_set_handle_opts(struct dload_payload *payload,
250
		CURL *curl, char *error_buffer)
251
252
253
254
255
256
{
	alpm_handle_t *handle = payload->handle;
	const char *useragent = getenv("HTTP_USER_AGENT");
	struct stat st;

	/* the curl_easy handle is initialized with the alpm handle, so we only need
Dave Reisner's avatar
Dave Reisner committed
257
	 * to reset the handle's parameters for each time it's used. */
258
259
260
261
	curl_easy_reset(curl);
	curl_easy_setopt(curl, CURLOPT_URL, payload->fileurl);
	curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, error_buffer);
	curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10L);
262
	curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 10L);
263
264
265
	curl_easy_setopt(curl, CURLOPT_FILETIME, 1L);
	curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
	curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
266
267
	curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, dload_progress_cb);
	curl_easy_setopt(curl, CURLOPT_XFERINFODATA, (void *)payload);
268
269
270
271
	if(!handle->disable_dl_timeout) {
		curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1L);
		curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);
	}
272
	curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, dload_parseheader_cb);
273
	curl_easy_setopt(curl, CURLOPT_HEADERDATA, (void *)payload);
274
	curl_easy_setopt(curl, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
275
276
277
	curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L);
	curl_easy_setopt(curl, CURLOPT_TCP_KEEPIDLE, 60L);
	curl_easy_setopt(curl, CURLOPT_TCP_KEEPINTVL, 60L);
278
	curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
279

Dave Reisner's avatar
Dave Reisner committed
280
281
	_alpm_log(handle, ALPM_LOG_DEBUG, "url: %s\n", payload->fileurl);

282
	if(payload->max_size) {
283
284
		_alpm_log(handle, ALPM_LOG_DEBUG, "maxsize: %jd\n",
				(intmax_t)payload->max_size);
285
		curl_easy_setopt(curl, CURLOPT_MAXFILESIZE_LARGE,
286
				(curl_off_t)payload->max_size);
287
288
289
	}

	if(useragent != NULL) {
290
		curl_easy_setopt(curl, CURLOPT_USERAGENT, useragent);
291
292
293
294
295
	}

	if(!payload->allow_resume && !payload->force && payload->destfile_name &&
			stat(payload->destfile_name, &st) == 0) {
		/* start from scratch, but only download if our local is out of date. */
296
297
		curl_easy_setopt(curl, CURLOPT_TIMECONDITION, CURL_TIMECOND_IFMODSINCE);
		curl_easy_setopt(curl, CURLOPT_TIMEVALUE, (long)st.st_mtime);
Dave Reisner's avatar
Dave Reisner committed
298
		_alpm_log(handle, ALPM_LOG_DEBUG,
299
				"using time condition: %ld\n", (long)st.st_mtime);
300
301
302
	} else if(stat(payload->tempfile_name, &st) == 0 && payload->allow_resume) {
		/* a previous partial download exists, resume from end of file. */
		payload->tempfile_openmode = "ab";
303
		curl_easy_setopt(curl, CURLOPT_RESUME_FROM_LARGE, (curl_off_t)st.st_size);
Dave Reisner's avatar
Dave Reisner committed
304
		_alpm_log(handle, ALPM_LOG_DEBUG,
305
306
				"tempfile found, attempting continuation from %jd bytes\n",
				(intmax_t)st.st_size);
307
		payload->initial_size = st.st_size;
308
309
310
	}
}

311
static void mask_signal(int signum, void (*handler)(int),
312
		struct sigaction *origaction)
313
{
314
	struct sigaction newaction;
315
316
317
318
319

	newaction.sa_handler = handler;
	sigemptyset(&newaction.sa_mask);
	newaction.sa_flags = 0;

320
321
	sigaction(signum, NULL, origaction);
	sigaction(signum, &newaction, NULL);
322
323
}

324
static void unmask_signal(int signum, struct sigaction *sa)
325
{
326
	sigaction(signum, sa, NULL);
327
328
}

329
330
331
332
static FILE *create_tempfile(struct dload_payload *payload, const char *localpath)
{
	int fd;
	FILE *fp;
333
334
	char *randpath;
	size_t len;
335
336

	/* create a random filename, which is opened with O_EXCL */
337
338
339
	len = strlen(localpath) + 14 + 1;
	MALLOC(randpath, len, RET_ERR(payload->handle, ALPM_ERR_MEMORY, NULL));
	snprintf(randpath, len, "%salpmtmp.XXXXXX", localpath);
340
	if((fd = mkstemp(randpath)) == -1 ||
341
			fchmod(fd, ~(_getumask()) & 0666) ||
342
343
			!(fp = fdopen(fd, payload->tempfile_openmode))) {
		unlink(randpath);
344
		close(fd);
345
		_alpm_log(payload->handle, ALPM_LOG_ERROR,
346
				_("failed to create temporary file for download\n"));
347
		free(randpath);
348
349
350
		return NULL;
	}
	/* fp now points to our alpmtmp.XXXXXX */
351
352
353
354
	free(payload->tempfile_name);
	payload->tempfile_name = randpath;
	free(payload->remote_name);
	STRDUP(payload->remote_name, strrchr(randpath, '/') + 1,
355
			fclose(fp); RET_ERR(payload->handle, ALPM_ERR_MEMORY, NULL));
356
357
358
359

	return fp;
}

360
361
362
/* RFC1123 states applications should support this length */
#define HOSTNAME_SIZE 256

363
static int curl_download_internal(struct dload_payload *payload,
364
		const char *localpath, char **final_file, const char **final_url)
365
{
366
	int ret = -1;
367
	FILE *localf = NULL;
368
	char *effective_url;
369
	char hostname[HOSTNAME_SIZE];
370
	char error_buffer[CURL_ERROR_SIZE] = {0};
371
	struct stat st;
372
	long timecond, remote_time = -1;
373
	double remote_size, bytes_dl;
374
	struct sigaction orig_sig_pipe, orig_sig_int;
375
376
	/* shortcut to our handle within the payload */
	alpm_handle_t *handle = payload->handle;
377
	CURL *curl = get_libcurl_handle(handle);
Ivy Foster's avatar
Ivy Foster committed
378
	handle->pm_errno = ALPM_ERR_OK;
379

380
381
382
383
384
	/* make sure these are NULL */
	FREE(payload->tempfile_name);
	FREE(payload->destfile_name);
	FREE(payload->content_disp_name);

385
	payload->tempfile_openmode = "wb";
386
	if(!payload->remote_name) {
387
388
		STRDUP(payload->remote_name, get_filename(payload->fileurl),
				RET_ERR(handle, ALPM_ERR_MEMORY, -1));
389
	}
390
	if(curl_gethost(payload->fileurl, hostname, sizeof(hostname)) != 0) {
391
		_alpm_log(handle, ALPM_LOG_ERROR, _("url '%s' is invalid\n"), payload->fileurl);
392
		RET_ERR(handle, ALPM_ERR_SERVER_BAD_URL, -1);
393
394
	}

395
396
	if(payload->remote_name && strlen(payload->remote_name) > 0 &&
			strcmp(payload->remote_name, ".sig") != 0) {
397
398
399
		payload->destfile_name = get_fullpath(localpath, payload->remote_name, "");
		payload->tempfile_name = get_fullpath(localpath, payload->remote_name, ".part");
		if(!payload->destfile_name || !payload->tempfile_name) {
Dave Reisner's avatar
Dave Reisner committed
400
401
402
			goto cleanup;
		}
	} else {
403
404
		/* URL doesn't contain a filename, so make a tempfile. We can't support
		 * resuming this kind of download; partial transfers will be destroyed */
405
		payload->unlink_on_fail = 1;
Dave Reisner's avatar
Dave Reisner committed
406

407
408
		localf = create_tempfile(payload, localpath);
		if(localf == NULL) {
Dave Reisner's avatar
Dave Reisner committed
409
410
			goto cleanup;
		}
411
	}
412

413
	curl_set_handle_opts(payload, curl, error_buffer);
414
415

	if(localf == NULL) {
416
		localf = fopen(payload->tempfile_name, payload->tempfile_openmode);
Dave Reisner's avatar
Dave Reisner committed
417
		if(localf == NULL) {
418
419
420
421
			handle->pm_errno = ALPM_ERR_RETRIEVE;
			_alpm_log(handle, ALPM_LOG_ERROR,
					_("could not open file %s: %s\n"),
					payload->tempfile_name, strerror(errno));
Dave Reisner's avatar
Dave Reisner committed
422
423
			goto cleanup;
		}
424
425
	}

Dave Reisner's avatar
Dave Reisner committed
426
427
428
429
	_alpm_log(handle, ALPM_LOG_DEBUG,
			"opened tempfile for download: %s (%s)\n", payload->tempfile_name,
			payload->tempfile_openmode);

430
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, localf);
431

432
433
	/* Ignore any SIGPIPE signals. With libcurl, these shouldn't be happening,
	 * but better safe than sorry. Store the old signal handler first. */
434
	mask_signal(SIGPIPE, SIG_IGN, &orig_sig_pipe);
435
	dload_interrupted = 0;
436
	mask_signal(SIGINT, &inthandler, &orig_sig_int);
437
438

	/* perform transfer */
439
	payload->curlerr = curl_easy_perform(curl);
440
441
	_alpm_log(handle, ALPM_LOG_DEBUG, "curl returned error %d from transfer\n",
			payload->curlerr);
442

443
	/* disconnect relationships from the curl handle for things that might go out
444
	 * of scope, but could still be touched on connection teardown. This really
Allan McRae's avatar
Allan McRae committed
445
	 * only applies to FTP transfers. */
446
	curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
447
	curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *)NULL);
448

449
	/* was it a success? */
450
	switch(payload->curlerr) {
451
		case CURLE_OK:
452
			/* get http/ftp response code */
453
454
			_alpm_log(handle, ALPM_LOG_DEBUG, "response code: %ld\n", payload->respcode);
			if(payload->respcode >= 400) {
455
				payload->unlink_on_fail = 1;
456
457
458
459
460
461
462
463
				if(!payload->errors_ok) {
					/* non-translated message is same as libcurl */
					snprintf(error_buffer, sizeof(error_buffer),
							"The requested URL returned error: %ld", payload->respcode);
					_alpm_log(handle, ALPM_LOG_ERROR,
							_("failed retrieving file '%s' from %s : %s\n"),
							payload->remote_name, hostname, error_buffer);
				}
464
465
				goto cleanup;
			}
466
467
			break;
		case CURLE_ABORTED_BY_CALLBACK:
468
469
			/* handle the interrupt accordingly */
			if(dload_interrupted == ABORT_OVER_MAXFILESIZE) {
470
				payload->curlerr = CURLE_FILESIZE_EXCEEDED;
471
				payload->unlink_on_fail = 1;
472
473
				handle->pm_errno = ALPM_ERR_LIBCURL;
				_alpm_log(handle, ALPM_LOG_ERROR,
474
475
						_("failed retrieving file '%s' from %s : expected download size exceeded\n"),
						payload->remote_name, hostname);
476
			}
477
			goto cleanup;
478
479
480
481
482
483
484
		case CURLE_COULDNT_RESOLVE_HOST:
			payload->unlink_on_fail = 1;
			handle->pm_errno = ALPM_ERR_SERVER_BAD_URL;
			_alpm_log(handle, ALPM_LOG_ERROR,
					_("failed retrieving file '%s' from %s : %s\n"),
					payload->remote_name, hostname, error_buffer);
			goto cleanup;
485
		default:
486
			/* delete zero length downloads */
Dan McGee's avatar
Dan McGee committed
487
			if(fstat(fileno(localf), &st) == 0 && st.st_size == 0) {
488
489
				payload->unlink_on_fail = 1;
			}
490
491
			if(!payload->errors_ok) {
				handle->pm_errno = ALPM_ERR_LIBCURL;
492
493
				_alpm_log(handle, ALPM_LOG_ERROR,
						_("failed retrieving file '%s' from %s : %s\n"),
494
						payload->remote_name, hostname, error_buffer);
495
			} else {
496
497
				_alpm_log(handle, ALPM_LOG_DEBUG,
						"failed retrieving file '%s' from %s : %s\n",
498
						payload->remote_name, hostname, error_buffer);
499
500
			}
			goto cleanup;
501
502
	}

503
	/* retrieve info about the state of the transfer */
504
505
506
507
508
	curl_easy_getinfo(curl, CURLINFO_FILETIME, &remote_time);
	curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &remote_size);
	curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD, &bytes_dl);
	curl_easy_getinfo(curl, CURLINFO_CONDITION_UNMET, &timecond);
	curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &effective_url);
509

510
511
512
513
	if(final_url != NULL) {
		*final_url = effective_url;
	}

514
515
	/* time condition was met and we didn't download anything. we need to
	 * clean up the 0 byte .part file that's left behind. */
516
	if(timecond == 1 && DOUBLE_EQ(bytes_dl, 0)) {
Dave Reisner's avatar
Dave Reisner committed
517
		_alpm_log(handle, ALPM_LOG_DEBUG, "file met time condition\n");
518
		ret = 1;
519
		unlink(payload->tempfile_name);
520
521
522
523
524
525
		goto cleanup;
	}

	/* remote_size isn't necessarily the full size of the file, just what the
	 * server reported as remaining to download. compare it to what curl reported
	 * as actually being transferred during curl_easy_perform() */
526
527
	if(!DOUBLE_EQ(remote_size, -1) && !DOUBLE_EQ(bytes_dl, -1) &&
			!DOUBLE_EQ(bytes_dl, remote_size)) {
528
		handle->pm_errno = ALPM_ERR_RETRIEVE;
529
		_alpm_log(handle, ALPM_LOG_ERROR, _("%s appears to be truncated: %jd/%jd bytes\n"),
530
				payload->remote_name, (intmax_t)bytes_dl, (intmax_t)remote_size);
531
532
533
		goto cleanup;
	}

534
	if(payload->trust_remote_name) {
535
536
537
		if(payload->content_disp_name) {
			/* content-disposition header has a better name for our file */
			free(payload->destfile_name);
538
539
			payload->destfile_name = get_fullpath(localpath,
				get_filename(payload->content_disp_name), "");
540
541
542
543
544
545
546
547
548
549
550
551
552
553
		} else {
			const char *effective_filename = strrchr(effective_url, '/');
			if(effective_filename && strlen(effective_filename) > 2) {
				effective_filename++;

				/* if destfile was never set, we wrote to a tempfile. even if destfile is
				 * set, we may have followed some redirects and the effective url may
				 * have a better suggestion as to what to name our file. in either case,
				 * refactor destfile to this newly derived name. */
				if(!payload->destfile_name || strcmp(effective_filename,
							strrchr(payload->destfile_name, '/') + 1) != 0) {
					free(payload->destfile_name);
					payload->destfile_name = get_fullpath(localpath, effective_filename, "");
				}
Dave Reisner's avatar
Dave Reisner committed
554
555
556
557
			}
		}
	}

558
559
560
561
562
	ret = 0;

cleanup:
	if(localf != NULL) {
		fclose(localf);
563
		utimes_long(payload->tempfile_name, remote_time);
564
565
	}

566
	if(ret == 0) {
567
568
569
570
		const char *realname = payload->tempfile_name;
		if(payload->destfile_name) {
			realname = payload->destfile_name;
			if(rename(payload->tempfile_name, payload->destfile_name)) {
571
				_alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
572
						payload->tempfile_name, payload->destfile_name, strerror(errno));
573
574
				ret = -1;
			}
Dave Reisner's avatar
Dave Reisner committed
575
576
577
		}
		if(ret != -1 && final_file) {
			STRDUP(*final_file, strrchr(realname, '/') + 1,
578
					RET_ERR(handle, ALPM_ERR_MEMORY, -1));
Dave Reisner's avatar
Dave Reisner committed
579
580
581
		}
	}

582
583
584
	if((ret == -1 || dload_interrupted) && payload->unlink_on_fail &&
			payload->tempfile_name) {
		unlink(payload->tempfile_name);
585
586
	}

587
	/* restore the old signal handlers */
588
589
	unmask_signal(SIGINT, &orig_sig_int);
	unmask_signal(SIGPIPE, &orig_sig_pipe);
590
	/* if we were interrupted, trip the old handler */
591
	if(dload_interrupted == ABORT_SIGINT) {
592
593
594
		raise(SIGINT);
	}

595
	return ret;
596
597
598
}
#endif

Kerrick Staley's avatar
Kerrick Staley committed
599
600
/** Download a file given by a URL to a local directory.
 * Does not overwrite an existing file if the download fails.
601
 * @param payload the payload context
Kerrick Staley's avatar
Kerrick Staley committed
602
 * @param localpath the directory to save the file in
Dave Reisner's avatar
Dave Reisner committed
603
 * @param final_file the real name of the downloaded file (may be NULL)
Kerrick Staley's avatar
Kerrick Staley committed
604
605
 * @return 0 on success, -1 on error (pm_errno is set accordingly if errors_ok == 0)
 */
606
int _alpm_download(struct dload_payload *payload, const char *localpath,
607
		char **final_file, const char **final_url)
608
{
609
610
	alpm_handle_t *handle = payload->handle;

611
	if(handle->fetchcb == NULL) {
Dave Reisner's avatar
Dave Reisner committed
612
#ifdef HAVE_LIBCURL
613
		return curl_download_internal(payload, localpath, final_file, final_url);
614
#else
615
616
617
		/* work around unused warnings when building without libcurl */
		(void)final_file;
		(void)final_url;
618
		RET_ERR(handle, ALPM_ERR_EXTERNAL_DOWNLOAD, -1);
619
#endif
620
	} else {
621
622
		int ret = handle->fetchcb(payload->fileurl, localpath, payload->force);
		if(ret == -1 && !payload->errors_ok) {
623
			RET_ERR(handle, ALPM_ERR_EXTERNAL_DOWNLOAD, -1);
624
		}
625
		return ret;
626
627
	}
}
628

629
630
static char *filecache_find_url(alpm_handle_t *handle, const char *url)
{
631
	const char *filebase = strrchr(url, '/');
632

633
	if(filebase == NULL) {
634
635
636
		return NULL;
	}

637
	filebase++;
638
	if(*filebase == '\0') {
639
640
641
		return NULL;
	}

642
	return _alpm_filecache_find(handle, filebase);
643
644
}

645
/** Fetch a remote pkg. */
646
char SYMEXPORT *alpm_fetch_pkgurl(alpm_handle_t *handle, const char *url)
Dan McGee's avatar
Dan McGee committed
647
{
648
	char *filepath;
649
650
	const char *cachedir, *final_pkg_url = NULL;
	char *final_file = NULL;
651
	struct dload_payload payload;
652
	int ret = 0;
Dan McGee's avatar
Dan McGee committed
653

654
	CHECK_HANDLE(handle, return NULL);
655
	ASSERT(url, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL));
656

Dan McGee's avatar
Dan McGee committed
657
	/* find a valid cache dir to download to */
658
	cachedir = _alpm_filecache_setup(handle);
Dan McGee's avatar
Dan McGee committed
659

660
	memset(&payload, 0, sizeof(struct dload_payload));
661
662
663
664
665
666
667

	/* attempt to find the file in our pkgcache */
	filepath = filecache_find_url(handle, url);
	if(filepath == NULL) {
		STRDUP(payload.fileurl, url, RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
		payload.allow_resume = 1;
		payload.handle = handle;
668
		payload.trust_remote_name = 1;
669
670

		/* download the file */
671
		ret = _alpm_download(&payload, cachedir, &final_file, &final_pkg_url);
672
673
674
675
676
677
678
		_alpm_dload_payload_reset(&payload);
		if(ret == -1) {
			_alpm_log(handle, ALPM_LOG_WARNING, _("failed to download %s\n"), url);
			free(final_file);
			return NULL;
		}
		_alpm_log(handle, ALPM_LOG_DEBUG, "successfully downloaded %s\n", url);
Dan McGee's avatar
Dan McGee committed
679
680
	}

681
	/* attempt to download the signature */
682
	if(ret == 0 && final_pkg_url && (handle->siglevel & ALPM_SIG_PACKAGE)) {
683
		char *sig_filepath, *sig_final_file = NULL;
684
685
		size_t len;

686
		len = strlen(final_pkg_url) + 5;
687
		MALLOC(payload.fileurl, len, free(final_file); RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
688
		snprintf(payload.fileurl, len, "%s.sig", final_pkg_url);
689
690
691
692

		sig_filepath = filecache_find_url(handle, payload.fileurl);
		if(sig_filepath == NULL) {
			payload.handle = handle;
693
			payload.trust_remote_name = 1;
694
695
696
697
698
699
			payload.force = 1;
			payload.errors_ok = (handle->siglevel & ALPM_SIG_PACKAGE_OPTIONAL);

			/* set hard upper limit of 16KiB */
			payload.max_size = 16 * 1024;

700
			ret = _alpm_download(&payload, cachedir, &sig_final_file, NULL);
701
702
703
704
705
706
707
708
709
710
			if(ret == -1 && !payload.errors_ok) {
				_alpm_log(handle, ALPM_LOG_WARNING,
						_("failed to download %s\n"), payload.fileurl);
				/* Warn now, but don't return NULL. We will fail later during package
				 * load time. */
			} else if(ret == 0) {
				_alpm_log(handle, ALPM_LOG_DEBUG,
						"successfully downloaded %s\n", payload.fileurl);
			}
			FREE(sig_final_file);
711
		}
712
		free(sig_filepath);
713
		_alpm_dload_payload_reset(&payload);
714
715
	}

Dan McGee's avatar
Dan McGee committed
716
	/* we should be able to find the file the second time around */
717
718
719
	if(filepath == NULL) {
		filepath = _alpm_filecache_find(handle, final_file);
	}
720
	free(final_file);
Dave Reisner's avatar
Dave Reisner committed
721

722
	return filepath;
Dan McGee's avatar
Dan McGee committed
723
724
}

725
726
void _alpm_dload_payload_reset(struct dload_payload *payload)
{
727
	ASSERT(payload, return);
728

729
	FREE(payload->remote_name);
730
731
	FREE(payload->tempfile_name);
	FREE(payload->destfile_name);
732
733
	FREE(payload->content_disp_name);
	FREE(payload->fileurl);
734
	memset(payload, '\0', sizeof(*payload));
735
736
}

737
738
739
740
741
742
743
744
void _alpm_dload_payload_reset_for_retry(struct dload_payload *payload)
{
	ASSERT(payload, return);

	FREE(payload->fileurl);
	payload->initial_size += payload->prevprogress;
	payload->prevprogress = 0;
	payload->unlink_on_fail = 0;
745
	payload->cb_initialized = 0;
746
}