Attachment #188756 for bug #266455

View | Details | Raw Unified | Return to bug 266455
Collapse All | Expand All




void fetch(const char *, const char *);
void qmerge_initialize(const char *);
char *best_version(const char *, const char  *);
void pkg_fetch(int, depend_atom *, struct pkg_t *);
void pkg_merge(int, depend_atom *, struct pkg_t *);
int pkg_unmerge(char *, char *);
int unlink_empty(char *);
void pkg_process(int, char **, struct pkg_t *);
void print_Pkg(int, struct pkg_t *);
int parse_packages(const char *, int, char **);
int config_protected(const char *, int, char **);

						IF_DEBUG(fprintf(stderr, "+Installed: %s\n", p));
						if (strlen(p) < 1)
							if (!((strcmp(pkg->PF, subpkg->PF) == 0) && (strcmp(pkg->CATEGORY, subpkg->CATEGORY) == 0)))
								pkg_fetch(level+1, ratom, subpkg);

						atom_implode(subatom);
						atom_implode(ratom);

	return ret;
}

void pkg_process(int argc, char **argv, struct pkg_t *pkg)
{
	depend_atom *atom;
	char buf[255];
	char buf[255], str[255];
	int i;

	memset(buf, 0, sizeof(buf));
	memset(str, 0, sizeof(str));

	snprintf(buf, sizeof(buf), "%s/%s", pkg->CATEGORY, pkg->PF);
	if ((atom = atom_explode(buf)) == NULL)
		errf("%s/%s is not a valid atom", pkg->CATEGORY, pkg->PF);

	snprintf(str, sizeof(str), "%s/%s", pkgdir, pkg->CATEGORY);
	mkdir(str, 0755);

	for (i = 1; i < argc; i++) {
		if (argv[i][0] == '-')
			continue;

		if (match_pkg(argv[i], pkg) < 1)
			continue;

		pkg_fetch(0, atom, pkg);
	}
	/* free the atom */
	atom_implode(atom);
}
			pkg_merge(level, atom, pkg);
			continue;
		}

void pkg_fetch(int level, depend_atom *atom, struct pkg_t *pkg)
{
	char savecwd[_POSIX_PATH_MAX];
	char buf[255], str[255];
	memset(str, 0, sizeof(str));
			if ((pkg_verify_checksums(buf, pkg, atom, 0, 0)) != 0)
				unlink(buf);
		}
		if (access(buf, R_OK) == 0) {
			if ((!pkg->SHA1[0]) && (!pkg->MD5[0])) {
				warn("No checksum data for %s", buf);
				continue;
			} else {
				if ((pkg_verify_checksums(buf, pkg, atom, qmerge_strict, 1)) == 0) {
					pkg_merge(0, atom, pkg);
					continue;
				}
			}
		}
		if (verbose)
			printf("Fetching %s/%s.tbz2\n", atom->CATEGORY, pkg->PF);

	/* qmerge -pv patch */
	if (pretend) {
		if (!install) install++;
		/* qprint_tree_node(level, atom, pkg); */
		pkg_merge(level, atom, pkg);
		return;
	}

	/* check to see if file exists and it's checksum matches */
	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, pkg->CATEGORY, pkg->PF);
	unlink_empty(buf);

	snprintf(str, sizeof(str), "%s/%s", pkgdir, pkg->CATEGORY);
	mkdir(str, 0755);

	if ((force_download) && (access(buf, R_OK) == 0) && ((pkg->SHA1[0]) || (pkg->MD5[0]))) {
		if ((pkg_verify_checksums(buf, pkg, atom, 0, 0)) != 0)
		if (access(buf, R_OK) != 0) {
			warn("Failed to fetch %s.tbz2 from %s", pkg->PF, binhost);
			fflush(stderr);
			continue;
		}
		getcwd(savecwd, sizeof(savecwd));
		assert(chdir(pkgdir) == 0);
		if (chdir("All/") == 0) {
			snprintf(buf, sizeof(buf), "%s.tbz2", pkg->PF);
			snprintf(str, sizeof(str), "../%s/%s.tbz2", atom->CATEGORY, pkg->PF);
			unlink(buf);
	}
	if (access(buf, R_OK) == 0) {
		if ((!pkg->SHA1[0]) && (!pkg->MD5[0])) {
			warn("No checksum data for %s", buf);
			return;
		} else {
			if ((pkg_verify_checksums(buf, pkg, atom, qmerge_strict, 1)) == 0) {
				pkg_merge(0, atom, pkg);
				return;
			}
		}
	}
	if (verbose)
		printf("Fetching %s/%s.tbz2\n", atom->CATEGORY, pkg->PF);

	/* fetch the package */
	/* Check CATEGORY first */
	if (!old_repo) {
		snprintf(buf, sizeof(buf), "%s/%s.tbz2", atom->CATEGORY, pkg->PF);
		fetch(str, buf);
	}
	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, atom->CATEGORY, pkg->PF);
	if (access(buf, R_OK) != 0) {
		snprintf(buf, sizeof(buf), "%s.tbz2", pkg->PF);
		fetch(str, buf);
		old_repo = 1;
	}

	/* verify the pkg exists now. unlink if zero bytes */
	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, atom->CATEGORY, pkg->PF);
	unlink_empty(buf);

	if (access(buf, R_OK) != 0) {
		warn("Failed to fetch %s.tbz2 from %s", pkg->PF, binhost);
		fflush(stderr);
		return;
	}
	getcwd(savecwd, sizeof(savecwd));
	assert(chdir(pkgdir) == 0);
	if (chdir("All/") == 0) {
		snprintf(buf, sizeof(buf), "%s.tbz2", pkg->PF);
		snprintf(str, sizeof(str), "../%s/%s.tbz2", atom->CATEGORY, pkg->PF);
		unlink(buf);
		symlink(str, buf);
	}
	chdir(savecwd);

	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, atom->CATEGORY, pkg->PF);
	if ((pkg_verify_checksums(buf, pkg, atom, qmerge_strict, 1)) == 0) {
		pkg_merge(0, atom, pkg);
		return;
	}
	/* free the atom */
	atom_implode(atom);
}




void print_Pkg(int full, struct pkg_t *pkg)
{
	char *p = NULL;

						print_Pkg(verbose, pkg);
					}
				} else {
					pkg_process(argc, argv, pkg);
					pkg_fetch(argc, argv, pkg);
				}
				free(pkg);
			}

Return to bug 266455

Lines 98-107 Link Here

(-)qmerge.c (-76 / +85 lines)
98	void fetch(const char , const char );	98	void fetch(const char , const char );
99	void qmerge_initialize(const char *);	99	void qmerge_initialize(const char *);
100	char best_version(const char , const char *);	100	char best_version(const char , const char *);
		101	void pkg_fetch(int, depend_atom , struct pkg_t );
101	void pkg_merge(int, depend_atom , struct pkg_t );	102	void pkg_merge(int, depend_atom , struct pkg_t );
102	int pkg_unmerge(char , char );	103	int pkg_unmerge(char , char );
103	int unlink_empty(char *);	104	int unlink_empty(char *);
104	void pkg_fetch(int, char *, struct pkg_t );	105	void pkg_process(int, char *, struct pkg_t );
105	void print_Pkg(int, struct pkg_t *);	106	void print_Pkg(int, struct pkg_t *);
106	int parse_packages(const char , int, char *);	107	int parse_packages(const char , int, char *);
107	int config_protected(const char , int, char *);	108	int config_protected(const char , int, char *);
Lines 509-515 Link Here
509	IF_DEBUG(fprintf(stderr, "+Installed: %s\n", p));	510	IF_DEBUG(fprintf(stderr, "+Installed: %s\n", p));
510	if (strlen(p) < 1)	511	if (strlen(p) < 1)
511	if (!((strcmp(pkg->PF, subpkg->PF) == 0) && (strcmp(pkg->CATEGORY, subpkg->CATEGORY) == 0)))	512	if (!((strcmp(pkg->PF, subpkg->PF) == 0) && (strcmp(pkg->CATEGORY, subpkg->CATEGORY) == 0)))
512	pkg_merge(level+1, ratom, subpkg);	513	pkg_fetch(level+1, ratom, subpkg);
513		514
514	atom_implode(subatom);	515	atom_implode(subatom);
515	atom_implode(ratom);	516	atom_implode(ratom);
Lines 1004-1026 Link Here
1004	return ret;	1005	return ret;
1005	}	1006	}
1006		1007
1007	void pkg_fetch(int argc, char *argv, struct pkg_t pkg)	1008	void pkg_process(int argc, char *argv, struct pkg_t pkg)
1008	{	1009	{
1009	depend_atom *atom;	1010	depend_atom *atom;
1010	char savecwd[_POSIX_PATH_MAX];	1011	char buf[255];
1011	char buf[255], str[255];
1012	int i;	1012	int i;
1013		1013
1014	memset(buf, 0, sizeof(buf));	1014	memset(buf, 0, sizeof(buf));
1015	memset(str, 0, sizeof(str));
1016		1015
1017	snprintf(buf, sizeof(buf), "%s/%s", pkg->CATEGORY, pkg->PF);	1016	snprintf(buf, sizeof(buf), "%s/%s", pkg->CATEGORY, pkg->PF);
1018	if ((atom = atom_explode(buf)) == NULL)	1017	if ((atom = atom_explode(buf)) == NULL)
1019	errf("%s/%s is not a valid atom", pkg->CATEGORY, pkg->PF);	1018	errf("%s/%s is not a valid atom", pkg->CATEGORY, pkg->PF);
1020		1019
1021	snprintf(str, sizeof(str), "%s/%s", pkgdir, pkg->CATEGORY);
1022	mkdir(str, 0755);
1023
1024	for (i = 1; i < argc; i++) {	1020	for (i = 1; i < argc; i++) {
1025	if (argv[i][0] == '-')	1021	if (argv[i][0] == '-')
1026	continue;	1022	continue;
Lines 1029-1107 Link Here
1029	if (match_pkg(argv[i], pkg) < 1)	1025	if (match_pkg(argv[i], pkg) < 1)
1030	continue;	1026	continue;
1031		1027
1032	/* qmerge -pv patch */	1028	pkg_fetch(0, atom, pkg);
1033	if (pretend) {	1029	}
1034	int level = 0;	1030	/* free the atom */
1035	if (!install) install++;	1031	atom_implode(atom);
1036	/* qprint_tree_node(level, atom, pkg); */	1032	}
1037	pkg_merge(level, atom, pkg);
1038	continue;
1039	}
1040		1033
1041	/* check to see if file exists and it's checksum matches */	1034	void pkg_fetch(int level, depend_atom atom, struct pkg_t pkg)
1042	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, pkg->CATEGORY, pkg->PF);	1035	{
1043	unlink_empty(buf);	1036	char savecwd[_POSIX_PATH_MAX];
1044		1037	char buf[255], str[255];
1045	if ((force_download) && (access(buf, R_OK) == 0) && ((pkg->SHA1[0]) \|\| (pkg->MD5[0]))) {	1038	memset(str, 0, sizeof(str));
1046	if ((pkg_verify_checksums(buf, pkg, atom, 0, 0)) != 0)
1047	unlink(buf);
1048	}
1049	if (access(buf, R_OK) == 0) {
1050	if ((!pkg->SHA1[0]) && (!pkg->MD5[0])) {
1051	warn("No checksum data for %s", buf);
1052	continue;
1053	} else {
1054	if ((pkg_verify_checksums(buf, pkg, atom, qmerge_strict, 1)) == 0) {
1055	pkg_merge(0, atom, pkg);
1056	continue;
1057	}
1058	}
1059	}
1060	if (verbose)
1061	printf("Fetching %s/%s.tbz2\n", atom->CATEGORY, pkg->PF);
1062		1039
1063	/* fetch the package */	1040	/* qmerge -pv patch */
1064	/* Check CATEGORY first */	1041	if (pretend) {
1065	if (!old_repo) {	1042	if (!install) install++;
1066	snprintf(buf, sizeof(buf), "%s/%s.tbz2", atom->CATEGORY, pkg->PF);	1043	/* qprint_tree_node(level, atom, pkg); */
1067	fetch(str, buf);	1044	pkg_merge(level, atom, pkg);
1068	}	1045	return;
1069	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, atom->CATEGORY, pkg->PF);	1046	}
1070	if (access(buf, R_OK) != 0) {	1047
1071	snprintf(buf, sizeof(buf), "%s.tbz2", pkg->PF);	1048	/* check to see if file exists and it's checksum matches */
1072	fetch(str, buf);	1049	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, pkg->CATEGORY, pkg->PF);
1073	old_repo = 1;	1050	unlink_empty(buf);
1074	}	1051
1075		1052	snprintf(str, sizeof(str), "%s/%s", pkgdir, pkg->CATEGORY);
1076	/* verify the pkg exists now. unlink if zero bytes */	1053	mkdir(str, 0755);
1077	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, atom->CATEGORY, pkg->PF);	1054
1078	unlink_empty(buf);	1055	if ((force_download) && (access(buf, R_OK) == 0) && ((pkg->SHA1[0]) \|\| (pkg->MD5[0]))) {
1079		1056	if ((pkg_verify_checksums(buf, pkg, atom, 0, 0)) != 0)
1080	if (access(buf, R_OK) != 0) {
1081	warn("Failed to fetch %s.tbz2 from %s", pkg->PF, binhost);
1082	fflush(stderr);
1083	continue;
1084	}
1085	getcwd(savecwd, sizeof(savecwd));
1086	assert(chdir(pkgdir) == 0);
1087	if (chdir("All/") == 0) {
1088	snprintf(buf, sizeof(buf), "%s.tbz2", pkg->PF);
1089	snprintf(str, sizeof(str), "../%s/%s.tbz2", atom->CATEGORY, pkg->PF);
1090	unlink(buf);	1057	unlink(buf);
1091	symlink(str, buf);	1058	}
		1059	if (access(buf, R_OK) == 0) {
		1060	if ((!pkg->SHA1[0]) && (!pkg->MD5[0])) {
		1061	warn("No checksum data for %s", buf);
		1062	return;
		1063	} else {
		1064	if ((pkg_verify_checksums(buf, pkg, atom, qmerge_strict, 1)) == 0) {
		1065	pkg_merge(0, atom, pkg);
		1066	return;
		1067	}
1092	}	1068	}
1093	chdir(savecwd);	1069	}
		1070	if (verbose)
		1071	printf("Fetching %s/%s.tbz2\n", atom->CATEGORY, pkg->PF);
1094		1072
1095	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, atom->CATEGORY, pkg->PF);	1073	/* fetch the package */
1096	if ((pkg_verify_checksums(buf, pkg, atom, qmerge_strict, 1)) == 0) {	1074	/* Check CATEGORY first */
1097	pkg_merge(0, atom, pkg);	1075	if (!old_repo) {
1098	continue;	1076	snprintf(buf, sizeof(buf), "%s/%s.tbz2", atom->CATEGORY, pkg->PF);
1099	}	1077	fetch(str, buf);
		1078	}
		1079	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, atom->CATEGORY, pkg->PF);
		1080	if (access(buf, R_OK) != 0) {
		1081	snprintf(buf, sizeof(buf), "%s.tbz2", pkg->PF);
		1082	fetch(str, buf);
		1083	old_repo = 1;
		1084	}
		1085
		1086	/* verify the pkg exists now. unlink if zero bytes */
		1087	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, atom->CATEGORY, pkg->PF);
		1088	unlink_empty(buf);
		1089
		1090	if (access(buf, R_OK) != 0) {
		1091	warn("Failed to fetch %s.tbz2 from %s", pkg->PF, binhost);
		1092	fflush(stderr);
		1093	return;
		1094	}
		1095	getcwd(savecwd, sizeof(savecwd));
		1096	assert(chdir(pkgdir) == 0);
		1097	if (chdir("All/") == 0) {
		1098	snprintf(buf, sizeof(buf), "%s.tbz2", pkg->PF);
		1099	snprintf(str, sizeof(str), "../%s/%s.tbz2", atom->CATEGORY, pkg->PF);
		1100	unlink(buf);
		1101	symlink(str, buf);
		1102	}
		1103	chdir(savecwd);
		1104
		1105	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2", pkgdir, atom->CATEGORY, pkg->PF);
		1106	if ((pkg_verify_checksums(buf, pkg, atom, qmerge_strict, 1)) == 0) {
		1107	pkg_merge(0, atom, pkg);
		1108	return;
1100	}	1109	}
1101	/* free the atom */
1102	atom_implode(atom);
1103	}	1110	}
1104		1111
		1112
		1113
		1114
1105	void print_Pkg(int full, struct pkg_t *pkg)	1115	void print_Pkg(int full, struct pkg_t *pkg)
1106	{	1116	{
1107	char *p = NULL;	1117	char *p = NULL;
Lines 1407-1414 Link Here
1407	print_Pkg(verbose, pkg);	1417	print_Pkg(verbose, pkg);
1408	}	1418	}
1409	} else {	1419	} else {
1410	/* this name is misleading */	1420	pkg_process(argc, argv, pkg);
1411	pkg_fetch(argc, argv, pkg);
1412	}	1421	}
1413	free(pkg);	1422	free(pkg);
1414	}	1423	}