General Public License for more details.
*/
-#include <config.h>
+#include <stdio.h>
+#include <unistd.h>
#include <fnmatch.h>
#include "opkg.h"
#include "opkg_conf.h"
-#include "args.h"
#include "opkg_install.h"
#include "opkg_configure.h"
#include <libbb/libbb.h>
-args_t *args;
-
#define opkg_assert(expr) if (!(expr)) { \
printf ("opkg: file %s: line %d (%s): Assertation '%s' failed",\
__FILE__, __LINE__, __PRETTY_FUNCTION__, # expr); abort (); }
/** Private Functions ***/
-static int
-opkg_configure_packages(char *pkg_name)
+static int opkg_configure_packages(char *pkg_name)
{
pkg_vec_t *all;
int i;
return err;
}
-struct _curl_cb_data {
- opkg_progress_callback_t cb;
- opkg_progress_data_t *progress_data;
- void *user_data;
- int start_range;
- int finish_range;
-};
+static struct opkg_conf saved_conf;
+/*** Public API ***/
-int
-curl_progress_cb(struct _curl_cb_data *cb_data, double t, /* dltotal */
- double d, /* dlnow */
- double ultotal, double ulnow)
+int opkg_new()
{
- int p = (t) ? d * 100 / t : 0;
- static int prev = -1;
- int progress = 0;
+ saved_conf = *conf;
- /* prevent the same value being sent twice (can occur due to rounding) */
- if (p == prev)
- return 0;
- prev = p;
+ if (opkg_conf_init())
+ goto err0;
- if (t < 1)
- return 0;
+ if (opkg_conf_load())
+ goto err0;
- progress = cb_data->start_range +
- (d / t * ((cb_data->finish_range - cb_data->start_range)));
- cb_data->progress_data->percentage = progress;
+ if (pkg_hash_load_feeds(0))
+ goto err1;
- (cb_data->cb) (cb_data->progress_data, cb_data->user_data);
+ if (pkg_hash_load_status_files())
+ goto err1;
return 0;
-}
-
-
-/*** Public API ***/
-
-int
-opkg_new()
-{
- int err;
-
- args = xcalloc(1, sizeof(args_t));
- args_init(args);
- err = opkg_conf_init(args);
- if (err) {
- free(args);
- return -1;
- }
-
- return 0;
+err1:
+ pkg_hash_deinit();
+err0:
+ opkg_conf_deinit();
+ return -1;
}
-void
-opkg_free(void)
+void opkg_free(void)
{
-#ifdef HAVE_CURL
- opkg_curl_cleanup();
-#endif
opkg_conf_deinit();
- args_deinit(args);
- free(args);
}
-int
-opkg_re_read_config_files(void)
+int opkg_re_read_config_files(void)
{
- /* Unfortunately, the easiest way to re-read the config files right now is to
- * throw away conf and start again */
opkg_free();
- memset(conf, '\0', sizeof(opkg_conf_t));
+ *conf = saved_conf;
return opkg_new();
- return 0;
}
-void
-opkg_get_option(char *option, void **value)
+void opkg_get_option(char *option, void **value)
{
int i = 0;
extern opkg_option_t options[];
/* get the option */
switch (options[i].type) {
case OPKG_OPT_TYPE_BOOL:
- *((int *) value) = *((int *) options[i].value);
+ *((int *)value) = *((int *)options[i].value);
return;
case OPKG_OPT_TYPE_INT:
- *((int *) value) = *((int *) options[i].value);
+ *((int *)value) = *((int *)options[i].value);
return;
case OPKG_OPT_TYPE_STRING:
- *((char **) value) = xstrdup(options[i].value);
+ *((char **)value) = xstrdup(options[i].value);
return;
}
}
-void
-opkg_set_option(char *option, void *value)
+void opkg_set_option(char *option, void *value)
{
int i = 0, found = 0;
extern opkg_option_t options[];
}
if (!found) {
- /* XXX: Warning: Option not found */
+ opkg_msg(ERROR, "Invalid option: %s\n", option);
return;
}
/* set the option */
switch (options[i].type) {
case OPKG_OPT_TYPE_BOOL:
- if (*((int *) value) == 0)
- *((int *) options[i].value) = 0;
+ if (*((int *)value) == 0)
+ *((int *)options[i].value) = 0;
else
- *((int *) options[i].value) = 1;
+ *((int *)options[i].value) = 1;
return;
case OPKG_OPT_TYPE_INT:
- *((int *) options[i].value) = *((int *) value);
+ *((int *)options[i].value) = *((int *)value);
return;
case OPKG_OPT_TYPE_STRING:
- *((char **) options[i].value) = xstrdup(value);
+ *((char **)options[i].value) = xstrdup(value);
return;
}
/**
* @brief libopkg API: Install package
* @param package_name The name of package in which is going to install
- * @param progress_callback The callback function that report the status to caller.
+ * @param progress_callback The callback function that report the status to caller.
*/
int
opkg_install_package(const char *package_name,
- opkg_progress_callback_t progress_callback,
- void *user_data)
+ opkg_progress_callback_t progress_callback,
+ void *user_data)
{
int err;
- char *stripped_filename;
+ char *stripped_filename, *local_filename;
opkg_progress_data_t pdata;
pkg_t *old, *new;
pkg_vec_t *deps, *all;
- int i, ndepends;
+ int i;
char **unresolved = NULL;
+ const char *filename;
opkg_assert(package_name != NULL);
/* ... */
pkg_info_preinstall_check();
-
/* check to ensure package is not already installed */
old = pkg_hash_fetch_installed_by_name(package_name);
if (old) {
- /* XXX: Error: Package is already installed. */
- return OPKG_PACKAGE_ALREADY_INSTALLED;
+ opkg_msg(ERROR, "Package %s is already installed\n",
+ package_name);
+ return -1;
}
new = pkg_hash_fetch_best_installation_candidate_by_name(package_name);
if (!new) {
- /* XXX: Error: Could not find package to install */
- return OPKG_PACKAGE_NOT_FOUND;
+ opkg_msg(ERROR, "Couldn't find package %s\n", package_name);
+ return -1;
}
new->state_flag |= SF_USER;
- pdata.action = OPKG_INSTALL;
+ pdata.action = -1;
pdata.pkg = new;
progress(pdata, 0);
/* find dependancies and download them */
deps = pkg_vec_alloc();
/* this function does not return the original package, so we insert it later */
- ndepends =
- pkg_hash_fetch_unsatisfied_dependencies(new, deps, &unresolved);
+ pkg_hash_fetch_unsatisfied_dependencies(new, deps, &unresolved);
if (unresolved) {
- /* XXX: Error: Could not satisfy dependencies */
+ char **tmp = unresolved;
+ opkg_msg(ERROR, "Couldn't satisfy the following dependencies"
+ " for %s:\n", package_name);
+ while (*tmp) {
+ opkg_msg(ERROR, "\t%s", *tmp);
+ free(*tmp);
+ tmp++;
+ }
+ free(unresolved);
pkg_vec_free(deps);
- return OPKG_DEPENDENCIES_FAILED;
+ opkg_message(ERROR, "\n");
+ return -1;
}
/* insert the package we are installing so that we download it */
pkg_vec_insert(deps, new);
- /* download package and dependancies */
+ /* download package and dependencies */
for (i = 0; i < deps->len; i++) {
pkg_t *pkg;
- struct _curl_cb_data cb_data;
char *url;
pkg = deps->pkgs[i];
- if (pkg->local_filename)
+ if (pkg_get_string(pkg, PKG_LOCAL_FILENAME))
continue;
pdata.pkg = pkg;
pdata.action = OPKG_DOWNLOAD;
if (pkg->src == NULL) {
- /* XXX: Error: Package not available from any configured src */
- return OPKG_PACKAGE_NOT_AVAILABLE;
+ opkg_msg(ERROR, "Package %s not available from any "
+ "configured src\n", package_name);
+ return -1;
}
- sprintf_alloc(&url, "%s/%s", pkg->src->value, pkg->filename);
+ filename = pkg_get_string(pkg, PKG_FILENAME);
+
+ sprintf_alloc(&url, "%s/%s", pkg->src->value, filename);
/* Get the filename part, without any directory */
- stripped_filename = strrchr(pkg->filename, '/');
+ stripped_filename = strrchr(filename, '/');
if (!stripped_filename)
- stripped_filename = pkg->filename;
+ stripped_filename = (char *)filename;
- sprintf_alloc(&pkg->local_filename, "%s/%s", conf->tmp_dir,
+ sprintf_alloc(&local_filename, "%s/%s", conf->tmp_dir,
stripped_filename);
- cb_data.cb = progress_callback;
- cb_data.progress_data = &pdata;
- cb_data.user_data = user_data;
- /* 75% of "install" progress is for downloading */
- cb_data.start_range = 75 * i / deps->len;
- cb_data.finish_range = 75 * (i + 1) / deps->len;
+ pkg_set_string(pkg, PKG_LOCAL_FILENAME, local_filename);
- err = opkg_download(url, pkg->local_filename,
- (curl_progress_func) curl_progress_cb,
- &cb_data);
+ err = opkg_download(url, local_filename, 0);
free(url);
if (err) {
pkg_vec_free(deps);
- return OPKG_DOWNLOAD_FAILED;
+ return -1;
}
}
}
pkg_vec_free(all);
-
/* 75% of "install" progress is for downloading */
pdata.pkg = new;
pdata.action = OPKG_INSTALL;
err = opkg_install_pkg(new, 0);
if (err) {
- return OPKG_UNKNOWN_ERROR;
+ return -1;
}
progress(pdata, 75);
/* run configure scripts, etc. */
err = opkg_configure_packages(NULL);
if (err) {
- return OPKG_UNKNOWN_ERROR;
+ return -1;
}
/* write out status files and file lists */
int
opkg_remove_package(const char *package_name,
- opkg_progress_callback_t progress_callback, void *user_data)
+ opkg_progress_callback_t progress_callback, void *user_data)
{
int err;
pkg_t *pkg = NULL;
pkg = pkg_hash_fetch_installed_by_name(package_name);
- if (pkg == NULL) {
- /* XXX: Error: Package not installed. */
- return OPKG_PACKAGE_NOT_INSTALLED;
+ if (pkg == NULL || pkg->state_status == SS_NOT_INSTALLED) {
+ opkg_msg(ERROR, "Package %s not installed\n", package_name);
+ return -1;
}
pdata.action = OPKG_REMOVE;
pdata.pkg = pkg;
progress(pdata, 0);
-
- if (pkg->state_status == SS_NOT_INSTALLED) {
- /* XXX: Error: Package seems to be not installed (STATUS = NOT_INSTALLED). */
- return OPKG_PACKAGE_NOT_INSTALLED;
- }
- progress(pdata, 25);
-
if (conf->restrict_to_default_dest) {
pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(pkg->name,
- conf->default_dest);
+ conf->
+ default_dest);
} else {
pkg_to_remove = pkg_hash_fetch_installed_by_name(pkg->name);
}
-
progress(pdata, 75);
err = opkg_remove_pkg(pkg_to_remove, 0);
opkg_conf_write_status_files();
pkg_write_changed_filelists();
-
progress(pdata, 100);
- return (err) ? OPKG_UNKNOWN_ERROR : OPKG_NO_ERROR;
+ return (err) ? -1 : 0;
}
int
opkg_upgrade_package(const char *package_name,
- opkg_progress_callback_t progress_callback,
- void *user_data)
+ opkg_progress_callback_t progress_callback,
+ void *user_data)
{
int err;
pkg_t *pkg;
if (conf->restrict_to_default_dest) {
pkg = pkg_hash_fetch_installed_by_name_dest(package_name,
conf->default_dest);
- if (pkg == NULL) {
- /* XXX: Error: Package not installed in default_dest */
- return OPKG_PACKAGE_NOT_INSTALLED;
- }
} else {
pkg = pkg_hash_fetch_installed_by_name(package_name);
}
if (!pkg) {
- /* XXX: Error: Package not installed */
- return OPKG_PACKAGE_NOT_INSTALLED;
+ opkg_msg(ERROR, "Package %s not installed\n", package_name);
+ return -1;
}
pdata.action = OPKG_INSTALL;
progress(pdata, 0);
err = opkg_upgrade_pkg(pkg);
- /* opkg_upgrade_pkg returns the error codes of opkg_install_pkg */
if (err) {
- return OPKG_UNKNOWN_ERROR;
+ return -1;
}
progress(pdata, 75);
err = opkg_configure_packages(NULL);
if (err) {
- return OPKG_UNKNOWN_ERROR;
+ return -1;
}
/* write out status files and file lists */
if (err)
return 1;
+ /* write out status files and file lists */
+ opkg_conf_write_status_files();
+ pkg_write_changed_filelists();
+
pdata.pkg = NULL;
progress(pdata, 100);
return 0;
int
opkg_update_package_lists(opkg_progress_callback_t progress_callback,
- void *user_data)
+ void *user_data)
{
char *tmp;
int err, result = 0;
progress(pdata, 0);
sprintf_alloc(&lists_dir, "%s", (conf->restrict_to_default_dest)
- ? conf->default_dest->lists_dir : conf->lists_dir);
+ ? conf->default_dest->lists_dir : conf->lists_dir);
if (!file_is_dir(lists_dir)) {
if (file_exists(lists_dir)) {
- /* XXX: Error: file exists but is not a directory */
+ opkg_msg(ERROR, "%s is not a directory\n", lists_dir);
free(lists_dir);
return 1;
}
err = file_mkdir_hier(lists_dir, 0755);
if (err) {
- /* XXX: Error: failed to create directory */
+ opkg_msg(ERROR, "Couldn't create lists_dir %s\n",
+ lists_dir);
free(lists_dir);
return 1;
}
sprintf_alloc(&tmp, "%s/update-XXXXXX", conf->tmp_dir);
if (mkdtemp(tmp) == NULL) {
- /* XXX: Error: could not create temporary file name */
+ opkg_perror(ERROR, "Coundn't create temporary directory %s",
+ tmp);
free(lists_dir);
free(tmp);
return 1;
src->gzip ? "Packages.gz" : "Packages");
sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
- if (src->gzip) {
- FILE *in, *out;
- struct _curl_cb_data cb_data;
- char *tmp_file_name = NULL;
-
- sprintf_alloc(&tmp_file_name, "%s/%s.gz", tmp,
- src->name);
- /* XXX: Note: downloading url */
-
- cb_data.cb = progress_callback;
- cb_data.progress_data = &pdata;
- cb_data.user_data = user_data;
- cb_data.start_range =
- 100 * sources_done / sources_list_count;
- cb_data.finish_range =
- 100 * (sources_done + 1) / sources_list_count;
-
- err = opkg_download(url, tmp_file_name,
- (curl_progress_func) curl_progress_cb,
- &cb_data);
-
- if (err == 0) {
- /* XXX: Note: Inflating downloaded file */
- in = fopen(tmp_file_name, "r");
- out = fopen(list_file_name, "w");
- if (in && out)
- unzip(in, out);
- else
- err = 1;
- if (in)
- fclose(in);
- if (out)
- fclose(out);
- unlink(tmp_file_name);
- }
- free(tmp_file_name);
- } else
- err = opkg_download(url, list_file_name, NULL, NULL);
-
- if (err) {
- /* XXX: Error: download error */
- result = OPKG_DOWNLOAD_FAILED;
+ if (opkg_download(url, list_file_name, 0)) {
+ opkg_msg(ERROR, "Couldn't retrieve %s\n", url);
+ result = -1;
}
free(url);
-#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
+#if defined(HAVE_USIGN)
if (conf->check_signature) {
char *sig_file_name;
/* download detached signitures to verify the package lists */
/* make sure there is no existing signature file */
unlink(sig_file_name);
- err = opkg_download(url, sig_file_name, NULL, NULL);
+ err = opkg_download(url, sig_file_name, 0);
if (err) {
- /* XXX: Warning: Download failed */
+ opkg_msg(ERROR, "Couldn't retrieve %s\n", url);
} else {
int err;
err = opkg_verify_file(list_file_name,
- sig_file_name);
+ sig_file_name);
if (err == 0) {
- /* XXX: Notice: Signature check passed */
+ opkg_msg(INFO, "Signature check "
+ "passed for %s",
+ list_file_name);
} else {
- /* XXX: Warning: Signature check failed */
+ opkg_msg(ERROR, "Signature check "
+ "failed for %s",
+ list_file_name);
}
}
free(sig_file_name);
- free(list_file_name);
free(url);
}
#else
- /* XXX: Note: Signature check for %s skipped because GPG support was not
- * enabled in this build
- */
+ opkg_msg(INFO, "Signature check skipped for %s as GPG support"
+ " has not been enabled in this build\n",
+ list_file_name);
#endif
+ free(list_file_name);
sources_done++;
progress(pdata, 100 * sources_done / sources_list_count);
return result;
}
+static int pkg_compare_names_and_version(const void *a0, const void *b0)
+{
+ const pkg_t *a = *(const pkg_t **)a0;
+ const pkg_t *b = *(const pkg_t **)b0;
+ int ret;
+
+ ret = strcmp(a->name, b->name);
-int
-opkg_list_packages(opkg_package_callback_t callback, void *user_data)
+ if (ret == 0)
+ ret = pkg_compare_versions(a, b);
+
+ return ret;
+}
+
+int opkg_list_packages(opkg_package_callback_t callback, void *user_data)
{
pkg_vec_t *all;
int i;
all = pkg_vec_alloc();
pkg_hash_fetch_available(all);
+
+ pkg_vec_sort(all, pkg_compare_names_and_version);
+
for (i = 0; i < all->len; i++) {
pkg_t *pkg;
head = prepare_upgrade_list();
for (node = active_list_next(head, head); node;
- active_list_next(head, node)) {
- old = list_entry(node, pkg_t, list);
- new = pkg_hash_fetch_best_installation_candidate_by_name(old->name);
+ node = active_list_next(head, node)) {
+ old = node->pkg;
+ new =
+ pkg_hash_fetch_best_installation_candidate_by_name(old->
+ name);
if (new == NULL)
continue;
callback(new, user_data);
return 0;
}
-pkg_t *
-opkg_find_package(const char *name, const char *ver, const char *arch,
- const char *repo)
+pkg_t *opkg_find_package(const char *name, const char *ver, const char *arch,
+ const char *repo)
{
+ int pkg_found = 0;
pkg_t *pkg = NULL;
pkg_vec_t *all;
int i;
/* check architecture */
if (arch) {
- if (sstrcmp(pkg->architecture, arch))
+ if (sstrcmp(pkg_get_architecture(pkg), arch))
continue;
}
}
/* match found */
+ pkg_found = 1;
break;
}
pkg_vec_free(all);
- return pkg;
+ return pkg_found ? pkg : NULL;
}
-#ifdef HAVE_CURL
-#include <curl/curl.h>
-#endif
/**
- * @brief Check the accessibility of repositories. It will try to access the repository to check if the respository is accessible throught current network status.
- * @return return how many repositories cannot access. 0 means all okay.
+ * @brief Check the accessibility of repositories.
+ * @return return how many repositories cannot access. 0 means all okay.
*/
-int
-opkg_repository_accessibility_check(void)
+int opkg_repository_accessibility_check(void)
{
pkg_src_list_elt_t *iter;
str_list_elt_t *iter1;
str_list_t *src;
int repositories = 0;
int ret = 0;
- int err;
- int ide
char *repo_ptr;
char *stmp;
+ char *host, *end;
src = str_list_alloc();
list_for_each_entry(iter, &conf->pkg_src_list.head, node) {
- idx = index (strstr (((pkg_src_t *) iter->data)->value, "://") + 3, '/');
- if (strstr(((pkg_src_t *) iter->data)->value, "://") && idx)
+ host = strstr(((pkg_src_t *) iter->data)->value, "://") + 3;
+ end = index(host, '/');
+ if (strstr(((pkg_src_t *) iter->data)->value, "://") && end)
stmp = xstrndup(((pkg_src_t *) iter->data)->value,
- idx -
- ((pkg_src_t *) iter->data)->value) * sizeof(char);
+ end -
+ ((pkg_src_t *) iter->data)->value);
else
stmp = xstrdup(((pkg_src_t *) iter->data)->value);
free(repo_ptr);
repositories++;
}
+
while (repositories > 0) {
iter1 = str_list_pop(src);
repositories--;
- err = opkg_download(iter1->data, "/dev/null", NULL, NULL);
-#ifdef HAVE_CURL
- if (!(err == CURLE_OK ||
- err == CURLE_HTTP_RETURNED_ERROR ||
- err == CURLE_FILE_COULDNT_READ_FILE ||
- err == CURLE_REMOTE_FILE_NOT_FOUND ||
- err == CURLE_TFTP_NOTFOUND)) {
-#else
- if (!(err == 0)) {
-#endif
+ if (opkg_download(iter1->data, "/dev/null", 0))
ret++;
- }
str_list_elt_deinit(iter1);
}
+
free(src);
+
return ret;
}
projects / oweals / opkg-lede.git / blobdiff