Radish alpha
H
HardenedBSD-pkg
rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9
HardenedBSD Package Manager
Radicle
Git
Commits › b5e8333
Do not alter a struct pkg to set the new version, but only push the old informations on it
Baptiste Daroussin committed 13 years ago
commit b5e833312706afa63069b602f962b85e87845626
parent 85b5acf
10 files changed +65 -71
modified libpkg/pkg.c
@@ -56,7 +56,7 @@ static struct _fields {
	[PKG_INFOS] = {"information", PKG_FILE|PKG_REMOTE|PKG_INSTALLED, 1},

	[PKG_REPOPATH] = {"repopath", PKG_REMOTE, 0},

	[PKG_CKSUM] = {"checksum", PKG_REMOTE, 0},
- 
	[PKG_NEWVERSION] = {"newversion", PKG_REMOTE, 1},
+ 
	[PKG_OLD_VERSION] = {"oldversion", PKG_REMOTE, 1},

	[PKG_REPONAME] = {"reponame", PKG_REMOTE, 1},

	[PKG_REPOURL] = {"repourl", PKG_REMOTE, 1},

	[PKG_DIGEST] = {"manifestdigest", PKG_REMOTE, 1}
@@ -94,8 +94,8 @@ pkg_reset(struct pkg *pkg, pkg_t type)
		sbuf_reset(pkg->scripts[i]);



	pkg->flatsize = 0;
- 
	pkg->new_flatsize = 0;
- 
	pkg->new_pkgsize = 0;
+ 
	pkg->old_flatsize = 0;
+ 
	pkg->pkgsize = 0;

	pkg->time = 0;

	pkg->flags = 0;

	pkg->automatic = false;
@@ -196,11 +196,11 @@ pkg_vget(struct pkg const *const pkg, va_list ap)
		case PKG_FLATSIZE:

			*va_arg(ap, int64_t *) = pkg->flatsize;

			break;
- 
		case PKG_NEW_FLATSIZE:
- 
			*va_arg(ap, int64_t *) = pkg->new_flatsize;
+ 
		case PKG_OLD_FLATSIZE:
+ 
			*va_arg(ap, int64_t *) = pkg->old_flatsize;

			break;
- 
		case PKG_NEW_PKGSIZE:
- 
			*va_arg(ap, int64_t *) = pkg->new_pkgsize;
+ 
		case PKG_PKGSIZE:
+ 
			*va_arg(ap, int64_t *) = pkg->pkgsize;

			break;

		case PKG_LICENSE_LOGIC:

			*va_arg(ap, lic_t *) = pkg->licenselogic;
@@ -316,11 +316,11 @@ pkg_vset(struct pkg *pkg, va_list ap)
		case PKG_FLATSIZE:

			pkg->flatsize = va_arg(ap, int64_t);

			break;
- 
		case PKG_NEW_FLATSIZE:
- 
			pkg->new_flatsize = va_arg(ap, int64_t);
+ 
		case PKG_OLD_FLATSIZE:
+ 
			pkg->old_flatsize = va_arg(ap, int64_t);

			break;
- 
		case PKG_NEW_PKGSIZE:
- 
			pkg->new_pkgsize = va_arg(ap, int64_t);
+ 
		case PKG_PKGSIZE:
+ 
			pkg->pkgsize = va_arg(ap, int64_t);

			break;

		case PKG_TIME:

			pkg->time = va_arg(ap, int64_t);
modified libpkg/pkg.h.in
@@ -210,14 +210,14 @@ typedef enum {
	PKG_INFOS,

	PKG_REPOPATH,

	PKG_CKSUM,
- 
	PKG_NEWVERSION,
+ 
	PKG_OLD_VERSION,

	PKG_REPONAME,

	PKG_REPOURL,

	PKG_DIGEST, 

	/* end of fields */

	PKG_FLATSIZE = 64U,
- 
	PKG_NEW_FLATSIZE,
- 
	PKG_NEW_PKGSIZE,
+ 
	PKG_OLD_FLATSIZE,
+ 
	PKG_PKGSIZE,

	PKG_LICENSE_LOGIC,

	PKG_AUTOMATIC,

	PKG_LOCKED,
modified libpkg/pkg_event.c
@@ -204,8 +204,8 @@ pipeevent(struct pkg_event *ev)
	case PKG_EVENT_UPGRADE_BEGIN:

		pkg_get(ev->e_upgrade_begin.pkg,

		    PKG_NAME, &name,
- 
		    PKG_VERSION, &version,
- 
		    PKG_NEWVERSION, &newversion);
+ 
		    PKG_OLD_VERSION, &version,
+ 
		    PKG_VERSION, &newversion);



		sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_BEGIN\", "

		    "\"data\": { "
@@ -220,8 +220,8 @@ pipeevent(struct pkg_event *ev)
	case PKG_EVENT_UPGRADE_FINISHED:

		pkg_get(ev->e_upgrade_finished.pkg,

		    PKG_NAME, &name,
- 
		    PKG_VERSION, &version,
- 
		    PKG_NEWVERSION, &newversion);
+ 
		    PKG_OLD_VERSION, &version,
+ 
		    PKG_VERSION, &newversion);



		sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_FINISHED\", "

		    "\"data\": { "
@@ -592,8 +592,8 @@ pkg_emit_upgrade_finished(struct pkg *p)
		int num_actions = sizeof(actions) / sizeof(*actions);

		int action;
- 
		pkg_get(p, PKG_NAME, &name, PKG_VERSION, &version,
- 
		    PKG_NEWVERSION, &newversion);
+ 
		pkg_get(p, PKG_NAME, &name, PKG_OLD_VERSION, &version,
+ 
		    PKG_VERSION, &newversion);

		action = pkg_version_cmp(version, newversion) + 1;

		if (action >= 0 && action < num_actions)

			syslog(LOG_NOTICE, "%s %s: %s -> %s ",
modified libpkg/pkg_jobs.c
@@ -528,7 +528,7 @@ get_local_pkg(struct pkg_jobs *j, const char *origin, unsigned flag)
static bool

newer_than_local_pkg(struct pkg_jobs *j, struct pkg *rp, bool force)

{
- 
	char *origin, *newversion, *oldversion, *oldsize, *newsize;
+ 
	char *origin, *newversion, *oldversion, *oldsize;

	struct pkg *lp;

	struct pkg_option *lo = NULL, *ro = NULL;

	struct pkg_dep *ld = NULL, *rd = NULL;
@@ -555,9 +555,9 @@ newer_than_local_pkg(struct pkg_jobs *j, struct pkg *rp, bool force)
		return (false);

	}
- 
	pkg_get(rp, PKG_VERSION, &newversion, PKG_FLATSIZE, &newsize);
- 
	pkg_set(rp, PKG_VERSION, oldversion, PKG_NEWVERSION, newversion,
- 
	    PKG_NEW_FLATSIZE, newsize, PKG_FLATSIZE, oldsize,
+ 
	pkg_get(rp, PKG_VERSION, &newversion);
+ 
	pkg_set(rp, PKG_OLD_VERSION, oldversion,
+ 
	    PKG_OLD_FLATSIZE, oldsize,

	    PKG_AUTOMATIC, (int64_t)automatic);



	if (force) {
@@ -855,14 +855,14 @@ pkg_jobs_install(struct pkg_jobs *j)
	pkgdb_transaction_begin(j->db->sqlite, "upgrade");



	while (pkg_jobs(j, &p) == EPKG_OK) {
- 
		const char *pkgorigin, *pkgrepopath, *newversion, *origin;
+ 
		const char *pkgorigin, *pkgrepopath, *oldversion, *origin;

		bool automatic, locked;

		flags = 0;



		pkg_get(p, PKG_ORIGIN, &pkgorigin, PKG_REPOPATH, &pkgrepopath,
- 
		    PKG_NEWVERSION, &newversion, PKG_AUTOMATIC, &automatic);
+ 
		    PKG_OLD_VERSION, &oldversion, PKG_AUTOMATIC, &automatic);
- 
		if (newversion != NULL) {
+ 
		if (oldversion != NULL) {

			pkg = NULL;

			it = pkgdb_query(j->db, pkgorigin, MATCH_EXACT);

			if (it != NULL) {
@@ -931,7 +931,7 @@ pkg_jobs_install(struct pkg_jobs *j)
		snprintf(path, sizeof(path), "%s/%s", cachedir, pkgrepopath);



		pkg_open(&newpkg, path, keys, 0);
- 
		if (newversion != NULL) {
+ 
		if (oldversion != NULL) {

			pkg_emit_upgrade_begin(p);

		} else {

			pkg_emit_install_begin(newpkg);
@@ -966,7 +966,7 @@ pkg_jobs_install(struct pkg_jobs *j)
			goto cleanup;

		}
- 
		if (newversion != NULL)
+ 
		if (oldversion != NULL)

			pkg_emit_upgrade_finished(p);

		else

			pkg_emit_install_finished(newpkg);
@@ -1078,7 +1078,7 @@ pkg_jobs_fetch(struct pkg_jobs *j)
	/* check for available size to fetch */

	while (pkg_jobs(j, &p) == EPKG_OK) {

		int64_t pkgsize;
- 
		pkg_get(p, PKG_NEW_PKGSIZE, &pkgsize, PKG_REPOPATH, &repopath);
+ 
		pkg_get(p, PKG_PKGSIZE, &pkgsize, PKG_REPOPATH, &repopath);

		snprintf(cachedpath, MAXPATHLEN, "%s/%s", cachedir, repopath);

		if (stat(cachedpath, &st) == -1)

			dlsize += pkgsize;
modified libpkg/pkg_manifest.c
@@ -99,7 +99,7 @@ static struct manifest_key {
	{ "options", PKG_OPTIONS, YAML_MAPPING_NODE, parse_mapping},

	{ "origin", PKG_ORIGIN, YAML_SCALAR_NODE, pkg_set_from_node},

	{ "path", PKG_REPOPATH, YAML_SCALAR_NODE, pkg_set_from_node},
- 
	{ "pkgsize", PKG_NEW_PKGSIZE, YAML_SCALAR_NODE, pkg_set_size_from_node},
+ 
	{ "pkgsize", PKG_PKGSIZE, YAML_SCALAR_NODE, pkg_set_size_from_node},

	{ "prefix", PKG_PREFIX, YAML_SCALAR_NODE, pkg_set_from_node},

	{ "scripts", PKG_SCRIPTS, YAML_MAPPING_NODE, parse_mapping},

	{ "shlibs_provided", PKG_SHLIBS_PROVIDED, YAML_SEQUENCE_NODE, parse_sequence},
@@ -974,7 +974,7 @@ emit_manifest(struct pkg *pkg, yaml_emitter_t *emitter, short flags)
	    PKG_LICENSE_LOGIC, &licenselogic, PKG_DESC, &desc,

	    PKG_FLATSIZE, &flatsize, PKG_MESSAGE, &message,

	    PKG_VERSION, &version, PKG_INFOS, &infos, PKG_REPOPATH, &repopath,
- 
	    PKG_CKSUM, &pkgsum, PKG_NEW_PKGSIZE, &pkgsize);
+ 
	    PKG_CKSUM, &pkgsum, PKG_PKGSIZE, &pkgsize);

	manifest_append_kv(mapping, "name", name, PLAIN);

	manifest_append_kv(mapping, "version", version, PLAIN);

	manifest_append_kv(mapping, "origin", pkgorigin, PLAIN);
modified libpkg/pkg_repo.c
@@ -479,7 +479,7 @@ read_pkg_file(void *data)
			sha256_file(fts_accpath, r->cksum);

			pkg_set(r->pkg, PKG_CKSUM, r->cksum,

			    PKG_REPOPATH, pkg_path,
- 
			    PKG_NEW_PKGSIZE, st_size);
+ 
			    PKG_PKGSIZE, st_size);

		}
modified libpkg/pkgdb.c
@@ -118,10 +118,10 @@ static struct column_mapping {
	{ "manifestdigest",	PKG_DIGEST },

	{ "message",	PKG_MESSAGE },

	{ "name",	PKG_NAME },
- 
	{ "newflatsize", PKG_NEW_FLATSIZE },
- 
	{ "newversion",	PKG_NEWVERSION },
+ 
	{ "oldflatsize", PKG_OLD_FLATSIZE },
+ 
	{ "oldversion",	PKG_OLD_VERSION },

	{ "origin",	PKG_ORIGIN },
- 
	{ "pkgsize",	PKG_NEW_PKGSIZE },
+ 
	{ "pkgsize",	PKG_PKGSIZE },

	{ "prefix",	PKG_PREFIX },

	{ "repopath",	PKG_REPOPATH },

	{ "rowid",	PKG_ROWID },
modified libpkg/pkgdb_repo.c
@@ -478,7 +478,7 @@ pkgdb_repo_add_package(struct pkg *pkg, const char *pkg_path,
			    PKG_MAINTAINER, &maintainer, PKG_WWW, &www,

			    PKG_PREFIX, &prefix, PKG_FLATSIZE, &flatsize,

			    PKG_LICENSE_LOGIC, &licenselogic, PKG_CKSUM, &sum,
- 
			    PKG_NEW_PKGSIZE, &pkgsize, PKG_REPOPATH, &rpath);
+ 
			    PKG_PKGSIZE, &pkgsize, PKG_REPOPATH, &rpath);



try_again:

	if ((ret = run_prepared_statement(PKG, origin, name, version,
modified libpkg/private/pkg.h
@@ -108,8 +108,8 @@ struct pkg {
	bool		 automatic;

	bool		 locked;

	int64_t		 flatsize;
- 
	int64_t		 new_flatsize;
- 
	int64_t		 new_pkgsize;
+ 
	int64_t		 old_flatsize;
+ 
	int64_t		 pkgsize;

	struct sbuf	*scripts[PKG_NUM_SCRIPTS];

	struct pkg_license	*licenses;

	struct pkg_category	*categories;
modified pkg/utils.c
@@ -238,7 +238,7 @@ print_info(struct pkg * const pkg, unsigned int options)
	const char *repopath;

	const char *tab;

	unsigned opt;
- 
	int64_t flatsize, newflatsize, newpkgsize;
+ 
	int64_t flatsize, oldflatsize, pkgsize;

	lic_t licenselogic;

	bool locked;

	int cout = 0;		/* Number of characters output */
@@ -256,8 +256,8 @@ print_info(struct pkg * const pkg, unsigned int options)
		PKG_COMMENT,       &comment,

		PKG_DESC,          &desc,

		PKG_FLATSIZE,      &flatsize,
- 
		PKG_NEW_FLATSIZE,  &newflatsize,
- 
		PKG_NEW_PKGSIZE,   &newpkgsize,
+ 
		PKG_OLD_FLATSIZE,  &oldflatsize,
+ 
		PKG_PKGSIZE,   &pkgsize,

		PKG_LICENSE_LOGIC, &licenselogic,

		PKG_MESSAGE,       &message,

		PKG_ARCH,	   &arch,
@@ -446,15 +446,9 @@ print_info(struct pkg * const pkg, unsigned int options)
			}

			break;

		case INFO_FLATSIZE:
- 
			if (pkg_type(pkg) == PKG_INSTALLED ||
- 
			    pkg_type(pkg) == PKG_FILE)
- 
				humanize_number(size, sizeof(size),
- 
						flatsize,"B",
- 
						HN_AUTOSCALE, 0);
- 
			else
- 
				humanize_number(size, sizeof(size),
- 
						newflatsize,"B",
- 
						HN_AUTOSCALE, 0);
+ 
			humanize_number(size, sizeof(size),
+ 
			    flatsize,"B",
+ 
			    HN_AUTOSCALE, 0);



			if (print_tag)

				printf("%-15s: ", "Flat size");
@@ -463,7 +457,7 @@ print_info(struct pkg * const pkg, unsigned int options)
		case INFO_PKGSIZE: /* Remote pkgs only */

			if (pkg_type(pkg) == PKG_REMOTE) {

				humanize_number(size, sizeof(size),
- 
						newpkgsize,"B",
+ 
						pkgsize,"B",

						HN_AUTOSCALE, 0);

				if (print_tag)

					printf("%-15s: ", "Pkg size");
@@ -591,9 +585,9 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
	struct pkg *pkg = NULL;

	char path[MAXPATHLEN];

	struct stat st;
- 
	const char *name, *version, *newversion, *pkgrepopath, *cachedir;
+ 
	const char *name, *version, *oldversion, *pkgrepopath, *cachedir;

	int64_t dlsize, oldsize, newsize;
- 
	int64_t flatsize, newflatsize, pkgsize;
+ 
	int64_t flatsize, oldflatsize, pkgsize;

	bool locked;

	char size[7];

	va_list ap;
@@ -606,15 +600,15 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
	va_end(ap);



	dlsize = oldsize = newsize = 0;
- 
	flatsize = newflatsize = pkgsize = 0;
- 
	name = version = newversion = NULL;
+ 
	flatsize = oldflatsize = pkgsize = 0;
+ 
	name = version = oldversion = NULL;

	

	pkg_config_string(PKG_CONFIG_CACHEDIR, &cachedir);



	while (pkg_jobs(jobs, &pkg) == EPKG_OK) {
- 
		pkg_get(pkg, PKG_NEWVERSION, &newversion, PKG_NAME, &name,
+ 
		pkg_get(pkg, PKG_OLD_VERSION, &oldversion, PKG_NAME, &name,

		    PKG_VERSION, &version, PKG_FLATSIZE, &flatsize,
- 
		    PKG_NEW_FLATSIZE, &newflatsize, PKG_NEW_PKGSIZE, &pkgsize,
+ 
		    PKG_OLD_FLATSIZE, &oldflatsize, PKG_PKGSIZE, &pkgsize,

		    PKG_REPOPATH, &pkgrepopath, PKG_LOCKED, &locked);



		if (locked) {
@@ -625,16 +619,16 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
			case PKG_JOBS_UPGRADE:

				/* If it's a new install, then it

				 * cannot have been locked yet. */
- 
				if (newversion != NULL) {
- 
					switch(pkg_version_cmp(version, newversion)) {
+ 
				if (oldversion != NULL) {
+ 
					switch(pkg_version_cmp(oldversion, version)) {

					case -1:
- 
						printf("and may not be upgraded to version %s\n", newversion);
+ 
						printf("and may not be upgraded to version %s\n", version);

						break;

					case 0:

						printf("and may not be reinstalled\n");

						break;

					case 1:
- 
						printf("and may not be downgraded to version %s\n", newversion);
+ 
						printf("and may not be downgraded to version %s\n", version);

						break;

					}

					continue;
@@ -661,20 +655,20 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
				   occur later and the file will be fetched from remote again */

				dlsize += pkgsize;
- 
			if (newversion != NULL) {
- 
				switch (pkg_version_cmp(version, newversion)) {
+ 
			if (oldversion != NULL) {
+ 
				switch (pkg_version_cmp(oldversion, version)) {

				case 1:
- 
					printf("\tDowngrading %s: %s -> %s\n", name, version, newversion);
+ 
					printf("\tDowngrading %s: %s -> %s\n", name, oldversion, version);

					break;

				case 0:

					printf("\tReinstalling %s-%s\n", name, version);

					break;

				case -1:
- 
					printf("\tUpgrading %s: %s -> %s\n", name, version, newversion);
+ 
					printf("\tUpgrading %s: %s -> %s\n", name, oldversion, version);

					break;

				}
- 
				oldsize += flatsize;
- 
				newsize += newflatsize;
+ 
				oldsize += oldflatsize;
+ 
				newsize += flatsize;

			} else {

				newsize += flatsize;

				printf("\tInstalling %s: %s\n", name, version);
@@ -682,8 +676,8 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
			break;

		case PKG_JOBS_DEINSTALL:

		case PKG_JOBS_AUTOREMOVE:
- 
			oldsize += flatsize;
- 
			newsize += newflatsize;
+ 
			oldsize += oldflatsize;
+ 
			newsize += flatsize;

			

			printf("\t%s-%s\n", name, version);

			break;
@@ -698,7 +692,7 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)


			humanize_number(size, sizeof(size), pkgsize, "B", HN_AUTOSCALE, 0);
- 
			printf("\t%s-%s (%" PRId64 "%% of %s)\n", name, newversion == NULL ? version : newversion , 100 - (100 * oldsize)/pkgsize, size);
+ 
			printf("\t%s-%s (%" PRId64 "%% of %s)\n", name, version, 100 - (100 * oldsize)/pkgsize, size);

			break;

		}

	}