#include "opkg_configure.h"
#include "opkg_download.h"
#include "opkg_remove.h"
+#include "opkg_upgrade.h"
#include "sprintf_alloc.h"
#include "file_util.h"
};
#define opkg_assert(expr) if (!(expr)) { \
- printf ("opkg: file %s: line %d (%s): Assertation '%s' failed",\
- __FILE__, __LINE__, __PRETTY_FUNCTION__, #expr); abort(); }
+ printf ("opkg: file %s: line %d (%s): Assertation '%s' failed",\
+ __FILE__, __LINE__, __PRETTY_FUNCTION__, # expr); abort (); }
#define progress(percent) if (progress_callback) progress_callback (opkg, percent, user_data);
int
curl_progress_cb (struct _curl_cb_data *cb_data,
- double t, /* dltotal */
- double d, /* dlnow */
- double ultotal,
- double ulnow)
+ double t, /* dltotal */
+ double d, /* dlnow */
+ double ultotal,
+ double ulnow)
{
- int p = (t) ? d*100/t : 0;
+ int p = (t) ? d * 100 / t : 0;
static int prev = -1;
/* prevent the same value being sent twice (can occur due to rounding) */
if (t < 1)
return 0;
- (cb_data->cb) (cb_data->opkg,
- cb_data->start_range + (d/t * ((cb_data->finish_range - cb_data->start_range))),
- cb_data->user_data);
+ (cb_data->cb)(cb_data->opkg,
+ cb_data->start_range + (d / t * ((cb_data->finish_range - cb_data->start_range))),
+ cb_data->user_data);
return 0;
}
/*** Public API ***/
+opkg_package_t *
+opkg_package_new ()
+{
+
+ opkg_package_t *p;
+
+ p = malloc (sizeof (opkg_package_t));
+ memset (p, 0, sizeof (opkg_package_t));
+
+ return p;
+}
+
+opkg_package_t *
+opkg_package_new_with_values (const char *name, const char *version,
+ const char *arch, const char *desc, const char *tags, int installed)
+{
+ opkg_package_t *package;
+ package = opkg_package_new ();
+
+#define sstrdup(x) (x) ? strdup (x) : NULL;
+
+ package->name = sstrdup (name);
+ package->version = sstrdup (version);
+ package->architecture = sstrdup (arch);
+ package->description = sstrdup (desc);
+ package->tags = sstrdup (tags);
+ package->installed = (installed != 0);
+
+ return package;
+}
+
+void
+opkg_package_free (opkg_package_t *p)
+{
+ free (p->name);
+ free (p->version);
+ free (p->architecture);
+ free (p->description);
+ free (p->tags);
+
+ free (p);
+}
+
opkg_t *
opkg_new ()
{
}
int
-opkg_read_config_files (opkg_t *opkg)
+opkg_re_read_config_files (opkg_t *opkg)
{
args_t *a;
opkg_conf_t *c;
void
opkg_set_option (opkg_t *opkg, char *option, void *value)
{
- int i = 0;
+ int i = 0, found = 0;
opkg_option_t *options;
opkg_assert (opkg != NULL);
{
if (strcmp (options[i].name, option) == 0)
{
+ found = 1;
break;
}
i++;
}
+ if (!found)
+ {
+ /* XXX: Warning: Option not found */
+ return;
+ }
+
/* set the option */
switch (options[i].type)
{
int
opkg_upgrade_package (opkg_t *opkg, const char *package_name, opkg_progress_callback_t progress_callback, void *user_data)
{
- return 1;
+ pkg_t *pkg;
+
+ opkg_assert (opkg != NULL);
+ opkg_assert (package_name != NULL);
+
+ progress (0);
+
+ pkg_info_preinstall_check (opkg->conf);
+
+ if (opkg->conf->restrict_to_default_dest)
+ {
+ pkg = pkg_hash_fetch_installed_by_name_dest (&opkg->conf->pkg_hash,
+ package_name,
+ opkg->conf->default_dest);
+ if (pkg == NULL)
+ {
+ /* XXX: Error: Package not installed in default_dest */
+ return 1;
+ }
+ }
+ else
+ {
+ pkg = pkg_hash_fetch_installed_by_name (&opkg->conf->pkg_hash,
+ package_name);
+ }
+
+ if (!pkg)
+ {
+ /* XXX: Error: Package not installed */
+ return 1;
+ }
+
+ progress (25);
+
+ opkg_upgrade_pkg (opkg->conf, pkg);
+ progress (75);
+
+ opkg_configure_packages (opkg->conf, NULL);
+ progress (100);
+ return 0;
}
int
opkg_upgrade_all (opkg_t *opkg, opkg_progress_callback_t progress_callback, void *user_data)
{
- return 1;
+ pkg_vec_t *installed;
+ int err = 0;
+ int i;
+ pkg_t *pkg;
+
+ opkg_assert (opkg != NULL);
+ progress (0);
+
+ installed = pkg_vec_alloc ();
+ pkg_info_preinstall_check (opkg->conf);
+
+ pkg_hash_fetch_all_installed (&opkg->conf->pkg_hash, installed);
+ for (i = 0; i < installed->len; i++)
+ {
+ pkg = installed->pkgs[i];
+ err += opkg_upgrade_pkg (opkg->conf, pkg);
+ progress (100 * i / installed->len);
+ }
+ pkg_vec_free (installed);
+
+ if (err)
+ return 1;
+
+ err = opkg_configure_packages (opkg->conf, NULL);
+ if (err)
+ return 1;
+
+ progress (100);
+ return 0;
}
int
return 0;
}
+
+
+int
+opkg_list_packages (opkg_t *opkg, opkg_package_callback_t callback, void *user_data)
+{
+ pkg_vec_t *all;
+ int i;
+
+ opkg_assert (opkg);
+ opkg_assert (callback);
+
+ all = pkg_vec_alloc ();
+ pkg_hash_fetch_available (&opkg->conf->pkg_hash, all);
+ for (i = 0; i < all->len; i++)
+ {
+ pkg_t *pkg;
+ opkg_package_t *package;
+
+ pkg = all->pkgs[i];
+
+ package = opkg_package_new_with_values (
+ pkg->name,
+ pkg->version,
+ pkg->architecture,
+ pkg->description,
+ pkg->tags,
+ (pkg->state_status == SS_INSTALLED));
+
+ callback (opkg, package, user_data);
+ }
+
+ pkg_vec_free (all);
+
+ return 0;
+}
+
+int
+opkg_list_upgradable_packages (opkg_t *opkg, opkg_package_callback_t callback, void *user_data)
+{
+ pkg_vec_t *all;
+ int i;
+
+ opkg_assert (opkg);
+ opkg_assert (callback);
+
+ all = pkg_vec_alloc ();
+ pkg_hash_fetch_available (&opkg->conf->pkg_hash, all);
+ for (i = 0; i < all->len; i++)
+ {
+ pkg_t *old, *new;
+ int cmp;
+ opkg_package_t *package;
+
+ old = all->pkgs[i];
+
+ if (old->state_status != SS_INSTALLED)
+ continue;
+
+ new = pkg_hash_fetch_best_installation_candidate_by_name(opkg->conf, old->name);
+ if (new == NULL) {
+ /* XXX: Notice: Assuming locally install package is up to date */
+ continue;
+ }
+
+ cmp = pkg_compare_versions(old, new);
+
+ if (cmp < 0)
+ {
+
+ package = opkg_package_new_with_values (
+ old->name,
+ old->version,
+ old->architecture,
+ old->description,
+ old->tags,
+ (old->state_status == SS_INSTALLED));
+
+ callback (opkg, package, user_data);
+ }
+ }
+
+ pkg_vec_free (all);
+
+ return 0;
+}
+
projects / oweals / opkg-lede.git / blobdiff