8029c25 Use proper fields of jobs, remove legacy ones. — HardenedBSD-pkg

HardenedBSD Package Manager

Use proper fields of jobs, remove legacy ones.

Vsevolod Stakhov committed 12 years ago

commit 8029c256004a0c1664a3a530c3d5725645d9e828
parent b3e13a2db8b707c3170389c97e03bafeec354b71

4 files changed +153 -141

modified libpkg/pkg.h.in

@@ -1146,7 +1146,8 @@ int pkg_jobs_count(struct pkg_jobs *jobs);

  * @param pkg Must be set to NULL for the first call.
  * @return An error code.
  */
 int pkg_jobs(struct pkg_jobs *jobs, struct pkg **pkg);
 int pkg_jobs_add_iter(struct pkg_jobs *jobs, struct pkg **pkg);
 int pkg_jobs_delete_iter(struct pkg_jobs *jobs, struct pkg **pkg);
 /**
  * Apply the jobs in the queue (fetch and install).

modified libpkg/pkg_jobs.c

@@ -119,7 +119,6 @@ pkg_jobs_free(struct pkg_jobs *j)

 		}
 		free(un);
 	}
 	HASH_FREE(j->jobs, pkg, pkg_free);
 	LL_FREE(j->patterns, job_pattern, free);
 	free(j);

@@ -154,6 +153,22 @@ pkg_jobs_add(struct pkg_jobs *j, match_t match, char **argv, int argc)

 	return (EPKG_OK);
 }
 int
 pkg_jobs_add_iter(struct pkg_jobs *jobs, struct pkg **pkg)
 {
 	assert(pkg != NULL);
 	HASH_NEXT(jobs->jobs_add, (*pkg));
 }
 int
 pkg_jobs_delete_iter(struct pkg_jobs *jobs, struct pkg **pkg)
 {
 	assert(pkg != NULL);
 	HASH_NEXT(jobs->jobs_delete, (*pkg));
 }
 static void
 pkg_jobs_add_req(struct pkg_jobs *j, const char *origin, struct pkg *pkg, bool add)
 {

@@ -1031,9 +1046,12 @@ pkg_jobs_find(struct pkg_jobs *j, const char *origin, struct pkg **p)

 {
 	struct pkg *pkg;
 	HASH_FIND_STR(j->jobs, __DECONST(char *, origin), pkg);
 	if (pkg == NULL)
 		return (EPKG_FATAL);
 	HASH_FIND_STR(j->jobs_add, __DECONST(char *, origin), pkg);
 	if (pkg == NULL) {
 		HASH_FIND_STR(j->jobs_add, __DECONST(char *, origin), pkg);
 		if (pkg == NULL)
 			return (EPKG_FATAL);
 	}
 	if (p != NULL)
 		*p = pkg;

@@ -1046,7 +1064,7 @@ pkg_jobs_count(struct pkg_jobs *j)

 {
 	assert(j != NULL);
 	return (HASH_COUNT(j->jobs));
 	return (HASH_COUNT(j->jobs_add) + HASH_COUNT(j->jobs_delete));
 }
 pkg_jobs_t

@@ -1055,14 +1073,6 @@ pkg_jobs_type(struct pkg_jobs *j)

 	return (j->type);
 }
 int
 pkg_jobs(struct pkg_jobs *j, struct pkg **pkg)
 {
 	assert(j != NULL);
 	HASH_NEXT(j->jobs, (*pkg));
 }
 static int
 pkg_jobs_keep_files_to_del(struct pkg *p1, struct pkg *p2)
 {

@@ -1089,14 +1099,13 @@ pkg_jobs_keep_files_to_del(struct pkg *p1, struct pkg *p2)

 static int
 pkg_jobs_install(struct pkg_jobs *j)
 {
 	struct pkg *p = NULL;
 	struct pkg *p = NULL, *ptmp;
 	struct pkg *pkg = NULL;
 	struct pkg *newpkg = NULL;
 	struct pkg *pkg_temp = NULL;
 	struct pkgdb_it *it = NULL;
 	struct pkg *pkg_queue = NULL;
 	struct pkg_manifest_key *keys = NULL;
 	struct pkg_job_request *req, *rtmp;
 	char path[MAXPATHLEN + 1];
 	const char *cachedir = NULL;
 	int flags = 0;

@@ -1122,17 +1131,12 @@ pkg_jobs_install(struct pkg_jobs *j)

 	/* Install */
 	pkgdb_transaction_begin(j->db->sqlite, "upgrade");
 	HASH_ITER(hh, j->request_add, req, rtmp) {
 	HASH_ITER(hh, j->jobs_add, p, ptmp) {
 		const char *pkgorigin, *oldversion, *origin;
 		struct pkg_note *an;
 		bool automatic;
 		flags = 0;
 		if (req->skip)
 			continue;
 		p = req->pkg;
 		pkg_get(p, PKG_ORIGIN, &pkgorigin,
 		    PKG_OLD_VERSION, &oldversion, PKG_AUTOMATIC, &automatic);
 		an = pkg_annotation_lookup(p, "repository");

@@ -1267,10 +1271,9 @@ pkg_jobs_install(struct pkg_jobs *j)

 static int
 pkg_jobs_deinstall(struct pkg_jobs *j)
 {
 	struct pkg *p = NULL;
 	struct pkg *p = NULL, *ptmp;
 	int retcode;
 	int flags = 0;
 	struct pkg_job_request *req, *rtmp;
 	if ((j->flags & PKG_FLAG_DRY_RUN) == PKG_FLAG_DRY_RUN)
 		return (EPKG_OK); /* Do nothing */

@@ -1281,11 +1284,8 @@ pkg_jobs_deinstall(struct pkg_jobs *j)

 	if ((j->flags & PKG_FLAG_NOSCRIPT) == PKG_FLAG_NOSCRIPT)
 		flags |= PKG_DELETE_NOSCRIPT;
 	HASH_ITER(hh, j->request_add, req, rtmp) {
 		if (req->skip)
 			continue;
 	HASH_ITER(hh, j->jobs_delete, p, ptmp) {
 		p = req->pkg;
 		retcode = pkg_delete(p, j->db, flags);
 		if (retcode != EPKG_OK)

@@ -1344,7 +1344,7 @@ pkg_jobs_apply(struct pkg_jobs *j)

 static int
 pkg_jobs_fetch(struct pkg_jobs *j)
 {
 	struct pkg *p = NULL;
 	struct pkg *p = NULL, *ptmp;
 	struct pkg *pkg = NULL;
 	struct statfs fs;
 	struct stat st;

@@ -1360,7 +1360,7 @@ pkg_jobs_fetch(struct pkg_jobs *j)

 		return (EPKG_FATAL);
 	/* check for available size to fetch */
 	while (pkg_jobs(j, &p) == EPKG_OK) {
 	HASH_ITER(hh, j->jobs_add, p, ptmp) {
 		int64_t pkgsize;
 		pkg_get(p, PKG_PKGSIZE, &pkgsize, PKG_REPOPATH, &repopath);
 		snprintf(cachedpath, MAXPATHLEN, "%s/%s", cachedir, repopath);

@@ -1396,7 +1396,7 @@ pkg_jobs_fetch(struct pkg_jobs *j)

 	/* Fetch */
 	p = NULL;
 	while (pkg_jobs(j, &p) == EPKG_OK) {
 	HASH_ITER(hh, j->jobs_add, p, ptmp) {
 		if (pkg_repo_fetch(p) != EPKG_OK)
 			return (EPKG_FATAL);
 	}

@@ -1406,7 +1406,7 @@ pkg_jobs_fetch(struct pkg_jobs *j)

 	pkg_emit_integritycheck_begin();
 	pkg_manifest_keys_new(&keys);
 	while (pkg_jobs(j, &p) == EPKG_OK) {
 	HASH_ITER(hh, j->jobs_add, p, ptmp) {
 		const char *pkgrepopath;
 		pkg_get(p, PKG_REPOPATH, &pkgrepopath);

modified libpkg/private/pkg.h

@@ -209,9 +209,6 @@ struct pkg_job_universe_item {

 struct pkg_jobs {
 	struct pkg_job_universe_item *universe;
 	struct pkg	*jobs;
 	struct pkg 	*bulk;
 	struct pkg	*seen;
 	struct pkg_job_request	*request_add;
 	struct pkg_job_request	*request_delete;
 	struct pkg *jobs_add;

modified pkg/utils.c

@@ -537,141 +537,155 @@ print_info(struct pkg * const pkg, unsigned int options)

 	}
 }
 void
 print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
 static void
 print_jobs_summary_pkg(struct pkg *pkg, pkg_jobs_t type, int64_t *oldsize,
 		int64_t *newsize, int64_t *dlsize)
 {
 	struct pkg *pkg = NULL;
 	const char *oldversion, *cachedir, *why;
 	char path[MAXPATHLEN];
 	struct stat st;
 	const char *oldversion, *cachedir, *why;
 	int64_t dlsize, oldsize, newsize;
 	int64_t flatsize, oldflatsize, pkgsize;
 	char size[7];
 	va_list ap;
 	pkg_jobs_t type;
 	type = pkg_jobs_type(jobs);
 	va_start(ap, msg);
 	vprintf(msg, ap);
 	va_end(ap);
 	dlsize = oldsize = newsize = 0;
 	flatsize = oldflatsize = pkgsize = 0;
 	oldversion = NULL;
 	pkg_config_string(PKG_CONFIG_CACHEDIR, &cachedir);
 	while (pkg_jobs(jobs, &pkg) == EPKG_OK) {
 		pkg_get(pkg, PKG_OLD_VERSION, &oldversion,
 		    PKG_FLATSIZE, &flatsize, PKG_OLD_FLATSIZE, &oldflatsize,
 		    PKG_PKGSIZE, &pkgsize, PKG_REASON, &why);
 		if (pkg_is_locked(pkg)) {
 			pkg_printf("\tPackage %n-%v is locked ", pkg, pkg);
 			switch (type) {
 			case PKG_JOBS_INSTALL:
 			case PKG_JOBS_UPGRADE:
 				/* If it's a new install, then it
 				 * cannot have been locked yet. */
 				if (oldversion != NULL) {
 					switch(pkg_version_change(pkg)) {
 					case PKG_UPGRADE:
 						pkg_printf("and may not be upgraded to version %v\n", pkg);
 						break;
 					case PKG_REINSTALL:
 						printf("and may not be reinstalled\n");
 						break;
 					case PKG_DOWNGRADE:
 						pkg_printf("and may not be downgraded to version %v\n", pkg);
 						break;
 					}
 					continue;
 				}
 				break;
 			case PKG_JOBS_DEINSTALL:
 			case PKG_JOBS_AUTOREMOVE:
 				printf("and may not be deinstalled\n");
 				continue;
 				break;
 			case PKG_JOBS_FETCH:
 				printf("but a new package can still be fetched\n");
 				break;
 			}
 		}
 	pkg_config_string(PKG_CONFIG_CACHEDIR, &cachedir);
 	pkg_get(pkg, PKG_OLD_VERSION, &oldversion,
 			PKG_FLATSIZE, &flatsize, PKG_OLD_FLATSIZE, &oldflatsize,
 			PKG_PKGSIZE, &pkgsize, PKG_REASON, &why);
 	if (pkg_is_locked(pkg)) {
 		pkg_printf("\tPackage %n-%v is locked ", pkg, pkg);
 		switch (type) {
 		case PKG_JOBS_INSTALL:
 		case PKG_JOBS_UPGRADE:
 			pkg_snprintf(path, MAXPATHLEN, "%S/%R", cachedir, pkg);
 			if (stat(path, &st) == -1 || pkgsize != st.st_size)
 				/* file looks corrupted (wrong size),
 				   assume a checksum mismatch will
 				   occur later and the file will be
 				   fetched from remote again */
 				dlsize += pkgsize;
 			/* If it's a new install, then it
 			 * cannot have been locked yet. */
 			if (oldversion != NULL) {
 				switch (pkg_version_change(pkg)) {
 				case PKG_DOWNGRADE:
 					pkg_printf("\tDowngrading %n: %V -> %v", pkg, pkg, pkg);
 					if (pkg_repos_count() > 1)
 						pkg_printf(" [%N]", pkg);
 					printf("\n");
 				switch(pkg_version_change(pkg)) {
 				case PKG_UPGRADE:
 					pkg_printf("and may not be upgraded to version %v\n", pkg);
 					break;
 				case PKG_REINSTALL:
 					pkg_printf("\tReinstalling %n-%v", pkg, pkg);
 					if (pkg_repos_count() > 1)
 						pkg_printf(" [%N]", pkg);
 					if (why != NULL)
 						printf(" (%s)", why);
 					printf("\n");
 					printf("and may not be reinstalled\n");
 					break;
 				case PKG_UPGRADE:
 					pkg_printf("\tUpgrading %n: %V -> %v", pkg, pkg, pkg);
 					if (pkg_repos_count() > 1)
 						pkg_printf(" [%N]", pkg);
 					printf("\n");
 				case PKG_DOWNGRADE:
 					pkg_printf("and may not be downgraded to version %v\n", pkg);
 					break;
 				}
 				oldsize += oldflatsize;
 				newsize += flatsize;
 			} else {
 				newsize += flatsize;
 				pkg_printf("\tInstalling %n: %v", pkg, pkg);
 				if (pkg_repos_count() > 1)
 					pkg_printf(" [%N]", pkg);
 				printf("\n");
 				return;
 			}
 			break;
 		case PKG_JOBS_DEINSTALL:
 		case PKG_JOBS_AUTOREMOVE:
 			oldsize += oldflatsize;
 			newsize += flatsize;
 			pkg_printf("\t%n-%v\n", pkg, pkg);
 			printf("and may not be deinstalled\n");
 			return;
 			break;
 		case PKG_JOBS_FETCH:
 			dlsize += pkgsize;
 			pkg_snprintf(path, MAXPATHLEN, "%S/%R", cachedir, pkg);
 			if (stat(path, &st) != -1)
 				oldsize = st.st_size;
 			else
 				oldsize = 0;
 			dlsize -= oldsize;
 			printf("but a new package can still be fetched\n");
 			break;
 		}
 			humanize_number(size, sizeof(size), pkgsize, "B", HN_AUTOSCALE, 0);
 	}
 			pkg_printf("\t%n-%v ", pkg, pkg);
 			printf("(%" PRId64 "%% of %s)\n", 100 - (100 * oldsize)/pkgsize, size);
 			break;
 	switch (type) {
 	case PKG_JOBS_INSTALL:
 	case PKG_JOBS_UPGRADE:
 		pkg_snprintf(path, MAXPATHLEN, "%S/%R", cachedir, pkg);
 		if (stat(path, &st) == -1 || pkgsize != st.st_size)
 			/* file looks corrupted (wrong size),
 					   assume a checksum mismatch will
 					   occur later and the file will be
 					   fetched from remote again */
 			*dlsize += pkgsize;
 		if (oldversion != NULL) {
 			switch (pkg_version_change(pkg)) {
 			case PKG_DOWNGRADE:
 				pkg_printf("\tDowngrading %n: %V -> %v", pkg, pkg, pkg);
 				if (pkg_repos_count() > 1)
 					pkg_printf(" [%N]", pkg);
 				printf("\n");
 				break;
 			case PKG_REINSTALL:
 				pkg_printf("\tReinstalling %n-%v", pkg, pkg);
 				if (pkg_repos_count() > 1)
 					pkg_printf(" [%N]", pkg);
 				if (why != NULL)
 					printf(" (%s)", why);
 				printf("\n");
 				break;
 			case PKG_UPGRADE:
 				pkg_printf("\tUpgrading %n: %V -> %v", pkg, pkg, pkg);
 				if (pkg_repos_count() > 1)
 					pkg_printf(" [%N]", pkg);
 				printf("\n");
 				break;
 			}
 			*oldsize += oldflatsize;
 			*newsize += flatsize;
 		} else {
 			*newsize += flatsize;
 			pkg_printf("\tInstalling %n: %v", pkg, pkg);
 			if (pkg_repos_count() > 1)
 				pkg_printf(" [%N]", pkg);
 			printf("\n");
 		}
 		break;
 	case PKG_JOBS_DEINSTALL:
 	case PKG_JOBS_AUTOREMOVE:
 		*oldsize += oldflatsize;
 		*newsize += flatsize;
 		pkg_printf("\t%n-%v\n", pkg, pkg);
 		break;
 	case PKG_JOBS_FETCH:
 		*dlsize += pkgsize;
 		pkg_snprintf(path, MAXPATHLEN, "%S/%R", cachedir, pkg);
 		if (stat(path, &st) != -1)
 			*oldsize = st.st_size;
 		else
 			*oldsize = 0;
 		*dlsize -= *oldsize;
 		humanize_number(size, sizeof(size), pkgsize, "B", HN_AUTOSCALE, 0);
 		pkg_printf("\t%n-%v ", pkg, pkg);
 		printf("(%" PRId64 "%% of %s)\n", 100 - (100 * (*oldsize))/pkgsize, size);
 		break;
 	}
 }
 void
 print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
 {
 	struct pkg *pkg = NULL;
 	char size[7];
 	va_list ap;
 	pkg_jobs_t type;
 	int64_t dlsize, oldsize, newsize;
 	dlsize = oldsize = newsize = 0;
 	type = pkg_jobs_type(jobs);
 	va_start(ap, msg);
 	vprintf(msg, ap);
 	va_end(ap);
 	while (pkg_jobs_add_iter(jobs, &pkg) == EPKG_OK) {
 		print_jobs_summary_pkg(pkg, type, &oldsize, &newsize, &dlsize);
 	}
 	pkg = NULL;
 	while (pkg_jobs_delete_iter(jobs, &pkg) == EPKG_OK) {
 		print_jobs_summary_pkg(pkg, type, &oldsize, &newsize, &dlsize);
 	}
 	if (oldsize > newsize) {
 		humanize_number(size, sizeof(size), oldsize - newsize, "B", HN_AUTOSCALE, 0);