/** Private Functions ***/
-static int
-opkg_configure_packages(char *pkg_name)
+static int opkg_configure_packages(char *pkg_name)
{
pkg_vec_t *all;
int i;
int finish_range;
};
-int
-curl_progress_cb(struct _curl_cb_data *cb_data, double t, /* dltotal */
- double d, /* dlnow */
- double ultotal, double ulnow)
+int curl_progress_cb(struct _curl_cb_data *cb_data, double t, /* dltotal */
+ double d, /* dlnow */
+ double ultotal, double ulnow)
{
int p = (t) ? d * 100 / t : 0;
static int prev = -1;
return 0;
}
-
+static struct opkg_conf saved_conf;
/*** Public API ***/
-int
-opkg_new()
+int opkg_new()
{
+ saved_conf = *conf;
+
if (opkg_conf_init())
goto err0;
- if (pkg_hash_load_feeds())
+ if (opkg_conf_load())
+ goto err0;
+
+ if (pkg_hash_load_feeds(0))
goto err1;
if (pkg_hash_load_status_files())
return -1;
}
-void
-opkg_free(void)
+void opkg_free(void)
{
#ifdef HAVE_CURL
opkg_curl_cleanup();
opkg_conf_deinit();
}
-int
-opkg_re_read_config_files(void)
+int opkg_re_read_config_files(void)
{
- pkg_hash_deinit();
- pkg_hash_init();
-
- if (pkg_hash_load_feeds())
- goto err;
-
- if (pkg_hash_load_status_files())
- goto err;
-
- return 0;
-
-err:
- pkg_hash_deinit();
- return -1;
+ opkg_free();
+ *conf = saved_conf;
+ return opkg_new();
}
-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[];
/* 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;
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) {
opkg_msg(ERROR, "Package %s is already installed\n",
- package_name);
+ package_name);
return -1;
}
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);
+ &unresolved);
if (unresolved) {
char **tmp = unresolved;
opkg_msg(ERROR, "Couldn't satisfy the following dependencies"
- " for %s:\n", package_name);
+ " for %s:\n", package_name);
while (*tmp) {
opkg_msg(ERROR, "\t%s", *tmp);
free(*tmp);
char *url;
pkg = deps->pkgs[i];
- if (pkg->local_filename)
+ if (pkg_get_string(pkg, PKG_LOCAL_FILENAME))
continue;
pdata.pkg = pkg;
if (pkg->src == NULL) {
opkg_msg(ERROR, "Package %s not available from any "
- "configured src\n", package_name);
+ "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);
+ pkg_set_string(pkg, PKG_LOCAL_FILENAME, local_filename);
+
cb_data.cb = progress_callback;
cb_data.progress_data = &pdata;
cb_data.user_data = user_data;
cb_data.start_range = 75 * i / deps->len;
cb_data.finish_range = 75 * (i + 1) / deps->len;
- err = opkg_download(url, pkg->local_filename,
+ err = opkg_download(url, local_filename,
(curl_progress_func) curl_progress_cb,
- &cb_data);
+ &cb_data, 0);
free(url);
if (err) {
}
pkg_vec_free(all);
-
/* 75% of "install" progress is for downloading */
pdata.pkg = new;
pdata.action = OPKG_INSTALL;
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;
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) ? -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 (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)) {
err = file_mkdir_hier(lists_dir, 0755);
if (err) {
opkg_msg(ERROR, "Couldn't create lists_dir %s\n",
- lists_dir);
+ lists_dir);
free(lists_dir);
return 1;
}
sprintf_alloc(&tmp, "%s/update-XXXXXX", conf->tmp_dir);
if (mkdtemp(tmp) == NULL) {
opkg_perror(ERROR, "Coundn't create temporary directory %s",
- tmp);
+ 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);
-
- opkg_msg(INFO, "Downloading %s to %s...\n", url,
- tmp_file_name);
-
- 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) {
- opkg_msg(INFO, "Inflating %s...\n",
- tmp_file_name);
- 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) {
+ if (opkg_download(url, list_file_name, NULL, NULL, 0)) {
opkg_msg(ERROR, "Couldn't retrieve %s\n", url);
result = -1;
}
free(url);
-#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
+#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL) || 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, NULL, NULL, 0);
if (err) {
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) {
opkg_msg(INFO, "Signature check "
- "passed for %s",
- list_file_name);
+ "passed for %s",
+ list_file_name);
} else {
opkg_msg(ERROR, "Signature check "
- "failed for %s",
- list_file_name);
+ "failed for %s",
+ list_file_name);
}
}
free(sig_file_name);
- free(list_file_name);
free(url);
}
#else
opkg_msg(INFO, "Signature check skipped for %s as GPG support"
- " has not been enabled in this build\n",
- list_file_name);
+ " 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)
+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;
return ret;
}
-int
-opkg_list_packages(opkg_package_callback_t callback, void *user_data)
+int opkg_list_packages(opkg_package_callback_t callback, void *user_data)
{
pkg_vec_t *all;
int i;
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;
}
/**
* @brief Check the accessibility of repositories.
- * @return return how many repositories cannot access. 0 means all okay.
+ * @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;
src = str_list_alloc();
list_for_each_entry(iter, &conf->pkg_src_list.head, node) {
- host = strstr(((pkg_src_t *)iter->data)->value, "://") + 3;
+ 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,
- end - ((pkg_src_t *) iter->data)->value);
+ end -
+ ((pkg_src_t *) iter->data)->value);
else
stmp = xstrdup(((pkg_src_t *) iter->data)->value);
iter1 = str_list_pop(src);
repositories--;
- if (opkg_download(iter1->data, "/dev/null", NULL, NULL))
+ if (opkg_download(iter1->data, "/dev/null", NULL, NULL, 0))
ret++;
str_list_elt_deinit(iter1);
}
projects / oweals / opkg-lede.git / blobdiff