384 lines
8.5 KiB
C
384 lines
8.5 KiB
C
/* $NetBSD: pkg_io.c,v 1.1.1.9 2010/04/23 20:54:11 joerg Exp $ */
|
|
/*-
|
|
* Copyright (c) 2008, 2009 Joerg Sonnenberger <joerg@NetBSD.org>.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#if HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
#include <nbcompat.h>
|
|
#if HAVE_SYS_CDEFS_H
|
|
#include <sys/cdefs.h>
|
|
#endif
|
|
|
|
__RCSID("$NetBSD: pkg_io.c,v 1.1.1.9 2010/04/23 20:54:11 joerg Exp $");
|
|
|
|
#include <archive.h>
|
|
#include <archive_entry.h>
|
|
#if HAVE_ERR_H
|
|
#include <err.h>
|
|
#endif
|
|
#if HAVE_ERRNO_H
|
|
#include <errno.h>
|
|
#endif
|
|
#include <fetch.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "lib.h"
|
|
|
|
struct pkg_path {
|
|
TAILQ_ENTRY(pkg_path) pl_link;
|
|
char *pl_path;
|
|
};
|
|
|
|
static char *orig_cwd, *last_toplevel;
|
|
static TAILQ_HEAD(, pkg_path) pkg_path = TAILQ_HEAD_INITIALIZER(pkg_path);
|
|
|
|
struct fetch_archive {
|
|
struct url *url;
|
|
fetchIO *fetch;
|
|
char buffer[32768];
|
|
off_t size;
|
|
int restart;
|
|
};
|
|
|
|
static int
|
|
fetch_archive_open(struct archive *a, void *client_data)
|
|
{
|
|
struct fetch_archive *f = client_data;
|
|
struct url_stat us;
|
|
|
|
f->fetch = fetchXGet(f->url, &us, fetch_flags);
|
|
if (f->fetch == NULL)
|
|
return ENOENT;
|
|
f->size = us.size;
|
|
f->restart = 1;
|
|
f->url->offset = 0;
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t
|
|
fetch_archive_read(struct archive *a, void *client_data,
|
|
const void **buffer)
|
|
{
|
|
struct fetch_archive *f = client_data;
|
|
struct url_stat us;
|
|
ssize_t rv;
|
|
|
|
*buffer = f->buffer;
|
|
rv = fetchIO_read(f->fetch, f->buffer, sizeof(f->buffer));
|
|
if (rv > 0) {
|
|
f->url->offset += rv;
|
|
return rv;
|
|
}
|
|
if (f->restart == 0)
|
|
return rv;
|
|
if (rv == 0) {
|
|
if (f->size == -1)
|
|
return 0;
|
|
if (f->url->offset == f->size)
|
|
return 0;
|
|
}
|
|
f->restart = 0;
|
|
if (1) {
|
|
char *url = fetchStringifyURL(f->url);
|
|
fprintf(stderr, "Trying to reconnect %s\n", url);
|
|
free(url);
|
|
}
|
|
fetchIO_close(f->fetch);
|
|
f->fetch = fetchXGet(f->url, &us, fetch_flags);
|
|
if (f->fetch == NULL)
|
|
return -1;
|
|
if (us.size != f->size)
|
|
return -1;
|
|
rv = fetchIO_read(f->fetch, f->buffer, sizeof(f->buffer));
|
|
if (rv > 0)
|
|
f->url->offset += rv;
|
|
return rv;
|
|
}
|
|
|
|
static int
|
|
fetch_archive_close(struct archive *a, void *client_data)
|
|
{
|
|
struct fetch_archive *f = client_data;
|
|
|
|
if (f->fetch != NULL)
|
|
fetchIO_close(f->fetch);
|
|
fetchFreeURL(f->url);
|
|
free(f);
|
|
return 0;
|
|
}
|
|
|
|
static struct archive *
|
|
open_archive_by_url(struct url *url, char **archive_name)
|
|
{
|
|
struct fetch_archive *f;
|
|
struct archive *a;
|
|
|
|
f = xmalloc(sizeof(*f));
|
|
f->url = fetchCopyURL(url);
|
|
|
|
*archive_name = fetchStringifyURL(url);
|
|
|
|
a = archive_read_new();
|
|
archive_read_support_compression_all(a);
|
|
archive_read_support_format_all(a);
|
|
if (archive_read_open(a, f, fetch_archive_open, fetch_archive_read,
|
|
fetch_archive_close)) {
|
|
free(*archive_name);
|
|
*archive_name = NULL;
|
|
archive_read_finish(a);
|
|
return NULL;
|
|
}
|
|
|
|
return a;
|
|
}
|
|
|
|
struct archive *
|
|
open_archive(const char *url, char **archive_name)
|
|
{
|
|
struct url *u;
|
|
struct archive *a;
|
|
|
|
*archive_name = NULL;
|
|
|
|
if (!IS_URL(url)) {
|
|
a = archive_read_new();
|
|
archive_read_support_compression_all(a);
|
|
archive_read_support_format_all(a);
|
|
if (archive_read_open_filename(a, url, 1024)) {
|
|
archive_read_close(a);
|
|
return NULL;
|
|
}
|
|
*archive_name = xstrdup(url);
|
|
return a;
|
|
}
|
|
|
|
if ((u = fetchParseURL(url)) == NULL)
|
|
return NULL;
|
|
|
|
a = open_archive_by_url(u, archive_name);
|
|
|
|
fetchFreeURL(u);
|
|
return a;
|
|
}
|
|
|
|
static int
|
|
strip_suffix(char *filename)
|
|
{
|
|
size_t len;
|
|
|
|
len = strlen(filename);
|
|
if (len <= 4)
|
|
return 0;
|
|
if (strcmp(filename + len - 4, ".tgz") == 0 ||
|
|
strcmp(filename + len - 4, ".tbz") == 0) {
|
|
filename[len - 4] = '\0';
|
|
return 1;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
find_best_package_int(struct url *url, const char *pattern,
|
|
struct url **best_url)
|
|
{
|
|
char *cur_match, *url_pattern, *best_match = NULL;
|
|
struct url_list ue;
|
|
size_t i;
|
|
|
|
if (*best_url) {
|
|
if ((best_match = fetchUnquoteFilename(*best_url)) == NULL)
|
|
return -1;
|
|
} else
|
|
best_match = NULL;
|
|
|
|
if (best_match && strip_suffix(best_match) == 0) {
|
|
free(best_match);
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; pattern[i] != '\0'; ++i) {
|
|
if (!isalnum((unsigned char)(pattern[i])) &&
|
|
(pattern[i]) != '-')
|
|
break;
|
|
}
|
|
url_pattern = xasprintf("%*.*s*", (int)i, (int)i, pattern);
|
|
|
|
fetchInitURLList(&ue);
|
|
if (fetchList(&ue, url, url_pattern, fetch_flags)) {
|
|
char *base_url;
|
|
base_url = fetchStringifyURL(url);
|
|
warnx("Can't process %s/%s: %s", base_url, url_pattern,
|
|
fetchLastErrString);
|
|
free(base_url);
|
|
free(url_pattern);
|
|
fetchFreeURLList(&ue);
|
|
return -1;
|
|
}
|
|
free(url_pattern);
|
|
|
|
for (i = 0; i < ue.length; ++i) {
|
|
cur_match = fetchUnquoteFilename(ue.urls + i);
|
|
|
|
if (cur_match == NULL) {
|
|
free(best_match);
|
|
fetchFreeURLList(&ue);
|
|
return -1;
|
|
}
|
|
if (strip_suffix(cur_match) == 0) {
|
|
free(cur_match);
|
|
continue;
|
|
}
|
|
if (pkg_order(pattern, cur_match, best_match) == 1) {
|
|
if (*best_url)
|
|
fetchFreeURL(*best_url);
|
|
*best_url = fetchCopyURL(ue.urls + i);
|
|
free(best_match);
|
|
best_match = cur_match;
|
|
cur_match = NULL;
|
|
if (*best_url == NULL) {
|
|
free(best_match);
|
|
return -1;
|
|
}
|
|
}
|
|
free(cur_match);
|
|
}
|
|
free(best_match);
|
|
fetchFreeURLList(&ue);
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
process_pkg_path(void)
|
|
{
|
|
char cwd[PATH_MAX];
|
|
int relative_path;
|
|
struct pkg_path *pl;
|
|
const char *start, *next;
|
|
size_t len;
|
|
|
|
if (getcwd(cwd, sizeof(cwd)) == NULL)
|
|
errx(EXIT_FAILURE, "getcwd failed");
|
|
|
|
orig_cwd = xstrdup(cwd);
|
|
|
|
if (config_pkg_path == NULL)
|
|
return;
|
|
|
|
for (start = config_pkg_path; *start; start = next) {
|
|
len = strcspn(start, ";");
|
|
if (*(next = start + len) != '\0')
|
|
++next;
|
|
|
|
relative_path = !IS_FULLPATH(start) && !IS_URL(start);
|
|
pl = xmalloc(sizeof(*pl));
|
|
pl->pl_path = xasprintf("%s%s%*.*s",
|
|
relative_path ? cwd : "", len && relative_path ? "/" : "",
|
|
(int)len, (int)len, start);
|
|
TAILQ_INSERT_TAIL(&pkg_path, pl, pl_link);
|
|
}
|
|
}
|
|
|
|
struct url *
|
|
find_best_package(const char *toplevel, const char *pattern, int do_path)
|
|
{
|
|
struct url *url, *best_match = NULL;
|
|
struct pkg_path *pl;
|
|
|
|
if (toplevel) {
|
|
url = fetchParseURL(last_toplevel);
|
|
if (url != NULL) {
|
|
find_best_package_int(url, pattern, &best_match);
|
|
/* XXX Check return value and complain */
|
|
fetchFreeURL(url);
|
|
}
|
|
}
|
|
if (!do_path)
|
|
return best_match;
|
|
|
|
TAILQ_FOREACH(pl, &pkg_path, pl_link) {
|
|
url = fetchParseURL(pl->pl_path);
|
|
if (url != NULL) {
|
|
find_best_package_int(url, pattern, &best_match);
|
|
/* XXX Check return value and complain */
|
|
fetchFreeURL(url);
|
|
}
|
|
}
|
|
|
|
return best_match;
|
|
}
|
|
|
|
struct archive *
|
|
find_archive(const char *fname, int top_level, char **archive_name)
|
|
{
|
|
struct archive *a;
|
|
struct url *best_match;
|
|
char *full_fname, *last_slash;
|
|
int search_path;
|
|
|
|
search_path = 0;
|
|
if (IS_FULLPATH(fname) || IS_URL(fname)) {
|
|
full_fname = xstrdup(fname);
|
|
} else {
|
|
if (strchr(fname, '/') == NULL)
|
|
search_path = 1;
|
|
full_fname = xasprintf("%s/%s", orig_cwd, fname);
|
|
}
|
|
|
|
last_slash = strrchr(full_fname, '/');
|
|
if (top_level) {
|
|
free(last_toplevel);
|
|
*last_slash = '\0';
|
|
last_toplevel = xstrdup(full_fname);
|
|
*last_slash = '/';
|
|
}
|
|
|
|
a = open_archive(full_fname, archive_name);
|
|
if (a != NULL) {
|
|
free(full_fname);
|
|
return a;
|
|
}
|
|
|
|
fname = last_slash + 1;
|
|
*last_slash = '\0';
|
|
|
|
best_match = find_best_package(full_fname, fname, 0);
|
|
|
|
if (search_path && best_match == NULL)
|
|
best_match = find_best_package(last_toplevel, fname, 1);
|
|
|
|
free(full_fname);
|
|
|
|
if (best_match == NULL)
|
|
return NULL;
|
|
a = open_archive_by_url(best_match, archive_name);
|
|
fetchFreeURL(best_match);
|
|
return a;
|
|
}
|